opencv学习笔记（九）Mat 访问图像像素的值

对图像的像素进行访问，可以实现空间增强，反色，大部分图像特效系列都是基于像素操作的。图像容器Mat是一个矩阵的形式，一般情况下是二维的。单通道灰度图一般存放的是<uchar>类型，其数据存放格式如下：

多通道的图像中，每列并列存放通道数量的子列，如RGB三通道彩色图：

注意通道的顺序为BGR。通常在内存足够大的情况下，图像的每一行是连续存放的，亦即在内存上图像的所有数据组成一个一维向量，这种情况下，在访问时将更快捷。可用成员函数isContinuous()来判断Mat图像在内存中是否为连续存储的。

清楚了图像在内存中的存储方式，下面对像素值操作：在只对深度为8bit字节型图像操作的前提下，导入一幅彩色图像，将其像素值变换为对255的补数。如原像素值为55，则变换为255-55=200。

使用一映射表来完成该转换：

    uchar mapTable[256];//mapping table:mapTable[pixel_value_before]=255-pixel_value_before;
    for (int i = 0; i < 256; i++)
        mapTable[i] = 255 - i;

数组mapTable中装入的即是原像素值变换后的像素值。

可用如下方法对像素值进行操作：

1、指针的方式

//通过ptr和[]访问像素的值
void transformImageMethodOne(Mat& pSrcImg, const uchar* const table)
{
    CV_Assert(pSrcImg.depth() != sizeof(uchar));//if the statement is false,then return a wrong message
    int nchannels = pSrcImg.channels();
    int nrows = pSrcImg.rows;//矩阵的行数
    int ncols = pSrcImg.cols*nchannels;//矩阵的总列数=列数*nchannels
    if (pSrcImg.isContinuous())//isContinuous()函数用于判断矩阵是否连续，若连续，相当于只需要遍历一个一维数组
    {
        cout << "only one row!" << endl;
        ncols *= nrows;
        nrows = 1;//一维数组
    }
    //traverse pixel values
    for (int i = 0; i < nrows; i++)
    {
        uchar* ptr = pSrcImg.ptr<uchar>(i);//获取行地址
        for (int j = 0; j < ncols; j++)
            ptr[j] = table[ptr[j]];//修改像素值
    }
//    return pSrcImg;
}

如代码所示，我们获取每一行开始处的指针，然后遍历至该行末尾。如果矩阵是连续存储的，则只需请求一次指针即可。

2、或者，也可以借助Mat的成员data。

data会从Mat中返回指向矩阵的首地址。通过遍历data来扫描整个图像。具体操作如下：

//通过ptr和[]访问像素的值（使用到了Mat的成员data）
void transformImageMethodTwo(Mat& pSrcImg, const uchar* const table)
{
    CV_Assert(pSrcImg.depth() != sizeof(uchar));//if the statement is false,then return a wrong message
    int nchannels = pSrcImg.channels();
    int nrows = pSrcImg.rows;
    int ncols = pSrcImg.cols*nchannels;
    //traver pixel values
    uchar* ptr = pSrcImg.data;//指向矩阵的首地址
    for (int i = 0; i < ncols*nrows; i++)
        *ptr++ = table[*ptr];//*ptr++是先取出*p的值，然后让p++

}

3、使用迭代器

使用迭代器的方法，仅仅需要获得图像矩阵的begin和end，然后从begin迭代至end，将操作符*添加至迭代指针前，即可访问当前指向的内容。

//使用迭代器访问像素的值
void transformImageMethodThree(Mat& pSrcImg, const uchar* const table)
{
    CV_Assert(pSrcImg.depth() != sizeof(uchar));//if the statement is false,then return a wrong message
    const int nchannels = pSrcImg.channels();
    switch (nchannels)
    {
    case 1:
    {
        MatIterator_<uchar> it, end;
        for (it = pSrcImg.begin<uchar>(), end = pSrcImg.end<uchar>(); it != end; it++)
            *it = table[*it];
        break;
    }
    case 3:
    {
              MatIterator_<Vec3b> it, end;
              for (it = pSrcImg.begin<Vec3b>(), end = pSrcImg.end<Vec3b>(); it != end; it++)
              {
                  (*it)[0] = table[(*it)[0]];
                  (*it)[1] = table[(*it)[1]];
                  (*it)[2] = table[(*it)[2]];
              }
              break;
    }
    default:break;
    }

}

注意：这里对3通道的图像进行操作的时候，使用到了Vec3b。Vec3b作为一个对三元向量的数据结构，用在这里正好是能够表示RGB的三个分量。如果对于彩色图像，仍然使用uchar的话，则只能获得3通道中的B分量。

4、动态地址访问

这种方法在需要连续扫描所有点的应用场景时效率较低，因为它更适用于随机访问。这种方法最基本的用途是访问任意的某一行某一列：

//使用动态地址访问像素的值
void transformImageMethodFour(Mat& pSrcImg, const uchar* const table)
{
    CV_Assert(pSrcImg.depth() != sizeof(uchar));//if the statement is false,then return a wrong message
    const int nchannels = pSrcImg.channels();
    const int nrows = pSrcImg.rows;
    const int ncols = pSrcImg.cols;
    switch (nchannels)
    {
    case 1:
    {
              for (int i = 0; i < nrows;i++)
              for (int j = 0; j < ncols; j++)
                  pSrcImg.at<uchar>(i, j) = table[pSrcImg.at<uchar>(i, j)];
              break;
    }
    case 3:
    {
              Mat_<Vec3b> _pSrcImg = pSrcImg;
              for (int i = 0; i < nrows;i++)
                for (int j = 0; j < ncols; j++)
                {
                    _pSrcImg(i, j)[0] = table[_pSrcImg(i, j)[0]];
                    _pSrcImg(i, j)[1] = table[_pSrcImg(i, j)[1]];
                    _pSrcImg(i, j)[2] = table[_pSrcImg(i, j)[2]];
                }
//                pSrcImg = _pSrcImg;
                break;
    }
    default:break;
    }
}

测试代码：

/*
@author:CodingMengmeng
@theme:read the image pixel values by Mat
@time:2017-3-16 23:06:40
@blog:http://www.cnblogs.com/codingmengmeng/
*/
#include <cv.h>  
#include <highgui.h>  
using namespace std;
using namespace cv;

//通过ptr和[]访问像素的值
void transformImageMethodOne(Mat& pSrcImg, const uchar* const table)
{
    CV_Assert(pSrcImg.depth() != sizeof(uchar));//if the statement is false,then return a wrong message
    int nchannels = pSrcImg.channels();
    int nrows = pSrcImg.rows;//矩阵的行数
    int ncols = pSrcImg.cols*nchannels;//矩阵的总列数=列数*nchannels
    if (pSrcImg.isContinuous())//isContinuous()函数用于判断矩阵是否连续，若连续，相当于只需要遍历一个一维数组
    {
        cout << "only one row!" << endl;
        ncols *= nrows;
        nrows = 1;//一维数组
    }
    //traverse pixel values
    for (int i = 0; i < nrows; i++)
    {
        uchar* ptr = pSrcImg.ptr<uchar>(i);//获取行地址
        for (int j = 0; j < ncols; j++)
            ptr[j] = table[ptr[j]];//修改像素值
    }
//    return pSrcImg;
}
//通过ptr和[]访问像素的值（使用到了Mat的成员data）
void transformImageMethodTwo(Mat& pSrcImg, const uchar* const table)
{
    CV_Assert(pSrcImg.depth() != sizeof(uchar));//if the statement is false,then return a wrong message
    int nchannels = pSrcImg.channels();
    int nrows = pSrcImg.rows;
    int ncols = pSrcImg.cols*nchannels;
    //traver pixel values
    uchar* ptr = pSrcImg.data;//指向矩阵的首地址
    for (int i = 0; i < ncols*nrows; i++)
        *ptr++ = table[*ptr];//*ptr++是先取出*p的值，然后让p++

}
//使用迭代器访问像素的值
void transformImageMethodThree(Mat& pSrcImg, const uchar* const table)
{
    CV_Assert(pSrcImg.depth() != sizeof(uchar));//if the statement is false,then return a wrong message
    const int nchannels = pSrcImg.channels();
    switch (nchannels)
    {
    case 1:
    {
        MatIterator_<uchar> it, end;
        for (it = pSrcImg.begin<uchar>(), end = pSrcImg.end<uchar>(); it != end; it++)
            *it = table[*it];
        break;
    }
    case 3:
    {
              MatIterator_<Vec3b> it, end;
              for (it = pSrcImg.begin<Vec3b>(), end = pSrcImg.end<Vec3b>(); it != end; it++)
              {
                  (*it)[0] = table[(*it)[0]];
                  (*it)[1] = table[(*it)[1]];
                  (*it)[2] = table[(*it)[2]];
              }
              break;
    }
    default:break;
    }

}
//使用动态地址访问像素的值
void transformImageMethodFour(Mat& pSrcImg, const uchar* const table)
{
    CV_Assert(pSrcImg.depth() != sizeof(uchar));//if the statement is false,then return a wrong message
    const int nchannels = pSrcImg.channels();
    const int nrows = pSrcImg.rows;
    const int ncols = pSrcImg.cols;
    switch (nchannels)
    {
    case 1:
    {
              for (int i = 0; i < nrows;i++)
              for (int j = 0; j < ncols; j++)
                  pSrcImg.at<uchar>(i, j) = table[pSrcImg.at<uchar>(i, j)];
              break;
    }
    case 3:
    {
              Mat_<Vec3b> _pSrcImg = pSrcImg;
              for (int i = 0; i < nrows;i++)
                for (int j = 0; j < ncols; j++)
                {
                    _pSrcImg(i, j)[0] = table[_pSrcImg(i, j)[0]];
                    _pSrcImg(i, j)[1] = table[_pSrcImg(i, j)[1]];
                    _pSrcImg(i, j)[2] = table[_pSrcImg(i, j)[2]];
                }
//                pSrcImg = _pSrcImg;
                break;
    }
    default:break;
    }
}
int main(void)
{
    string imgName = "Route66.jpg";
    Mat img = imread(imgName);
    Mat imgCopy1 = img.clone();
    Mat imgCopy2 = img.clone();
    Mat imgCopy3 = img.clone();
    Mat imgCopy4 = img.clone();
    uchar mapTable[256];//mapping table:mapTable[pixel_value_before]=255-pixel_value_before;
    for (int i = 0; i < 256; i++)
        mapTable[i] = 255 - i;
    imshow("SRCIMAGE", img);
    transformImageMethodOne(imgCopy1, mapTable);
    imshow("TRANSFORMIMAGE_USE_METHOD1", imgCopy1);
    transformImageMethodTwo(imgCopy2, mapTable);
    imshow("TRANSFORMIMAGE_USE_METHOD2", imgCopy2);
    transformImageMethodThree(imgCopy3, mapTable);
    imshow("TRANSFORMIMAGE_USE_METHOD3", imgCopy3);
    transformImageMethodFour(imgCopy4, mapTable);
    imshow("TRANSFORMIMAGE_USE_METHOD4", imgCopy4);
    waitKey(0);
    return 0;
}

运行结果：

原图：

变换效果图：

以上。