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

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

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

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

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

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

     uchar mapTable[];//mapping table:mapTable[pixel_value_before]=255-pixel_value_before;
     for (int i = ; i < ; i++)
         mapTable[i] =  - 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 = ;//一维数组
     }
     //traverse pixel values
     for (int i = ; i < nrows; i++)
     {
         uchar* ptr = pSrcImg.ptr<uchar>(i);//获取行地址
         for (int j = ; 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 = ; 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 :
     {
         MatIterator_<uchar> it, end;
         for (it = pSrcImg.begin<uchar>(), end = pSrcImg.end<uchar>(); it != end; it++)
             *it = table[*it];
         break;
     }
     case :
     {
               MatIterator_<Vec3b> it, end;
               for (it = pSrcImg.begin<Vec3b>(), end = pSrcImg.end<Vec3b>(); it != end; it++)
               {
                   (*it)[] = table[(*it)[]];
                   (*it)[] = table[(*it)[]];
                   (*it)[] = table[(*it)[]];
               }
               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 :
     {
               for (int i = ; i < nrows;i++)
               for (int j = ; j < ncols; j++)
                   pSrcImg.at<uchar>(i, j) = table[pSrcImg.at<uchar>(i, j)];
               break;
     }
     case :
     {
               Mat_<Vec3b> _pSrcImg = pSrcImg;
               for (int i = ; i < nrows;i++)
                 for (int j = ; j < ncols; j++)
                 {
                     _pSrcImg(i, j)[] = table[_pSrcImg(i, j)[]];
                     _pSrcImg(i, j)[] = table[_pSrcImg(i, j)[]];
                     _pSrcImg(i, j)[] = table[_pSrcImg(i, j)[]];
                 }
 //                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 = ;//一维数组
     }
     //traverse pixel values
     for (int i = ; i < nrows; i++)
     {
         uchar* ptr = pSrcImg.ptr<uchar>(i);//获取行地址
         for (int j = ; 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 = ; 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 :
     {
         MatIterator_<uchar> it, end;
         for (it = pSrcImg.begin<uchar>(), end = pSrcImg.end<uchar>(); it != end; it++)
             *it = table[*it];
         break;
     }
     case :
     {
               MatIterator_<Vec3b> it, end;
               for (it = pSrcImg.begin<Vec3b>(), end = pSrcImg.end<Vec3b>(); it != end; it++)
               {
                   (*it)[] = table[(*it)[]];
                   (*it)[] = table[(*it)[]];
                   (*it)[] = table[(*it)[]];
               }
               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 :
     {
               for (int i = ; i < nrows;i++)
               for (int j = ; j < ncols; j++)
                   pSrcImg.at<uchar>(i, j) = table[pSrcImg.at<uchar>(i, j)];
               break;
     }
     case :
     {
               Mat_<Vec3b> _pSrcImg = pSrcImg;
               for (int i = ; i < nrows;i++)
                 for (int j = ; j < ncols; j++)
                 {
                     _pSrcImg(i, j)[] = table[_pSrcImg(i, j)[]];
                     _pSrcImg(i, j)[] = table[_pSrcImg(i, j)[]];
                     _pSrcImg(i, j)[] = table[_pSrcImg(i, j)[]];
                 }
 //                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[];//mapping table:mapTable[pixel_value_before]=255-pixel_value_before;
     for (int i = ; i < ; i++)
         mapTable[i] =  - 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();
     return ;
 }

运行结果：

原图：

变换效果图：

以上。