图像像素访问

访问图像像素值是图像处理的基本操作。OPENCV2提供了很多中访问方式，本文实现了其中比较常用的三种方式： 
（1） 通过指针访问 
（2） 通过迭代器访问 
（3） 动态地址计算，通过at()函数实现

方法比较： 
（1）用指针访问像素，速度最快；但在彩色图像处理中，如果要单独对某一个颜色分量处理，则需要通过数学公式计算，不是很直观； 
（2）推荐用通过迭代器访问像素，速度快，而且提取BGR某一颜色分量很方便。 
（3）at()函数适用于随机访问某个具体的像素点（已知该像素点行、列坐标），不建议用at()函数遍历整个图。

本文基于以上方法，分别对灰度图和彩色图进行全图遍历，实现图像阈值处理。具体实现代码如下，且在vs2010测试通过。

#include "opencv2/core/core.hpp"#include "opencv2/highgui/highgui.hpp"#include "opencv2/imgproc/imgproc.hpp"#include "opencv2/photo/photo.hpp"#include <iostream>using namespace std;using namespace cv;//访问图像像素点，实现阈值处理void GetGrayImgIntensityByPointer(){    Mat srcImg, dstImg;    srcImg = imread("D:/openCV/data/naturalImage/data/redComponetImg.jpg", 0);    dstImg = srcImg.clone();//复制，不建议直接对原图处理    int rows = dstImg.rows;    int cols = dstImg.cols * dstImg.channels();    for(int j = 0; j < rows; j++)    {        unsigned char* data = dstImg.ptr(j);//获取每行首地址        for(int i = 0; i < cols; i++)        {            if(data[i] > 190)                data[i] = 255;            else                data[i] = 0;        }    }    imshow("原图像", srcImg);    imshow("阈值处理后图像", dstImg);    waitKey(0);}void GetGrayImgIntensityByInterator(){    Mat srcImg, dstImg;    srcImg = imread("D:/openCV/data/naturalImage/data/redComponetImg.jpg", 0);    dstImg = srcImg.clone();//复制，不建议直接对原图处理    Mat_<uchar>::iterator it = dstImg.begin<uchar>();    Mat_<uchar>::iterator itend = dstImg.end<uchar>();    for(; it != itend; it++)    {        if(*it > 190)            *it = 255;        else            *it = 0;    }    imshow("原图像", srcImg);    imshow("阈值处理后图像", dstImg);    waitKey(0);}void GetColorImgIntensityByPointer(){    Mat srcImg, dstImg;    srcImg = imread("D:/openCV/data/naturalImage/data/opencv.jpg", 1);    dstImg = srcImg.clone();//复制，不建议直接对原图处理    int rows = dstImg.rows;    int cols = dstImg.cols * dstImg.channels();    for(int j = 0; j < rows; j++)    {        unsigned char* data = dstImg.ptr(j);//获取每行首地址        for(int i = 0; i < cols; i++)        {            int ii = i % 2;            if(ii != 0)                data[i] = 0;            else            {                if(data[i] > 190)//对红色分量设置阈值，速度和效果都比不上迭代器                    data[i] = 255;                else                    data[i] = 0;            }        }    }    imshow("原图像", srcImg);    imshow("阈值处理后图像", dstImg);    waitKey(0);}void GetColorImgIntensityByInterator(){    Mat srcImg, dstImg;    srcImg = imread("D:/openCV/data/naturalImage/data/opencv.jpg", 1);    dstImg = srcImg.clone();//复制，不建议直接对原图处理    Mat_<Vec3b>::iterator it = dstImg.begin<Vec3b>();    Mat_<Vec3b>::iterator itend = dstImg.end<Vec3b>();    for(; it != itend; it++)    {        if((*it)[2] > 190)        {            (*it)[0] = 0;            (*it)[1] = 0;            (*it)[2] = 255;        }        else        {            (*it)[0] = 0;            (*it)[1] = 0;            (*it)[2] = 0;        }    }    imshow("原图像", srcImg);    imshow("阈值处理后图像", dstImg);    waitKey(0);}void RandomGetIntensity()//没用到颜色缩减{    Mat srcImg, dstImg;    srcImg = imread("D:/openCV/data/naturalImage/data/opencv.jpg", 1);    dstImg = srcImg.clone();//复制，不建议直接对原图处理    for(int j = 0; j < dstImg.rows; j++)        for(int i = 0; i < dstImg.cols; i++)        {            if(dstImg.at<Vec3b>(j, i)[2] > 190)            {                dstImg.at<Vec3b>(j, i)[0] = 0;                dstImg.at<Vec3b>(j, i)[1] = 0;                dstImg.at<Vec3b>(j, i)[2] = 255;            }            else            {                dstImg.at<Vec3b>(j, i)[0] = 0;                dstImg.at<Vec3b>(j, i)[1] = 0;                dstImg.at<Vec3b>(j, i)[2] = 0;            }        }        imshow("原图像", srcImg);        imshow("阈值处理后图像", dstImg);        waitKey(0);}int main(int argc, char* argv[]){    //GetGrayImgIntensityByPointer();    GetGrayImgIntensityByInterator();//效果好，速度快    //GetColorImgIntensityByInterator();    //GetColorImgIntensityByPointer();    //RandomGetIntensity();    return 0;}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

对灰度图阈值处理，效果图如下：

一、遍历图像的4种方式：at<typename>(i,j)

Mat类提供了一个at的方法用于取得图像上的点，它是一个模板函数，可以取到任何类型的图像上的点。下面我们通过一个图像处理中的实际来说明它的用法。

在实际应用中，我们很多时候需要对图像降色彩，因为256*256*256实在太多了，在图像颜色聚类或彩色直方图时，我们需要用一些代表性的颜色代替丰富的色彩空间，我们的思路是将每个通道的256种颜色用64种代替，即将原来256种颜色划分64个颜色段，每个颜色段取中间的颜色值作为代表色。

 1 void colorReduce(Mat& image,int div) 2 { 3     for(int i=0;i<image.rows;i++) 4     { 5         for(int j=0;j<image.cols;j++) 6         { 7             image.at<Vec3b>(i,j)[0]=image.at<Vec3b>(i,j)[0]/div*div+div/2; 8             image.at<Vec3b>(i,j)[1]=image.at<Vec3b>(i,j)[1]/div*div+div/2; 9             image.at<Vec3b>(i,j)[2]=image.at<Vec3b>(i,j)[2]/div*div+div/2;10         }11     }12 }

通过上面的例子我们可以看出，at方法取图像中的点的用法：

image.at<uchar>(i,j)：取出灰度图像中i行j列的点。

image.at<Vec3b>(i,j)[k]：取出彩色图像中i行j列第k通道的颜色点。其中uchar,Vec3b都是图像像素值的类型，不要对Vec3b这种类型感觉害怕，其实在core里它是通过typedef Vec<T,N>来定义的，N代表元素的个数，T代表类型。

更简单一些的方法：OpenCV定义了一个Mat的模板子类为Mat_，它重载了operator()让我们可以更方便的取图像上的点。

Mat_<uchar> im=image;

im(i,j)=im(i,j)/div*div+div/2;

二、高效一点：用指针来遍历图像

上面的例程中可以看到，我们实际喜欢把原图传进函数内，但是在函数内我们对原图像进行了修改，而将原图作为一个结果输出，很多时候我们需要保留原图，这样我们需要一个原图的副本。

 1 void colorReduce(const Mat& image,Mat& outImage,int div) 2 { 3     // 创建与原图像等尺寸的图像 4     outImage.create(image.size(),image.type()); 5     int nr=image.rows; 6     // 将3通道转换为1通道 7     int nl=image.cols*image.channels(); 8     for(int k=0;k<nr;k++) 9     {10         // 每一行图像的指针11         const uchar* inData=image.ptr<uchar>(k);12         uchar* outData=outImage.ptr<uchar>(k);13         for(int i=0;i<nl;i++)14         {15             outData[i]=inData[i]/div*div+div/2;16         }17     }18 }

从上面的例子中可以看出，取出图像中第i行数据的指针：image.ptr<uchar>(i)。

值得说明的是：程序中将三通道的数据转换为1通道，在建立在每一行数据元素之间在内存里是连续存储的，每个像素三通道像素按顺序存储。也就是一幅图像数据最开始的三个值，是最左上角的那像素的三个通道的值。

但是这种用法不能用在行与行之间，因为图像在OpenCV里的存储机制问题，行与行之间可能有空白单元。这些空白单元对图像来说是没有意思的，只是为了在某些架构上能够更有效率，比如intel MMX可以更有效的处理那种个数是4或8倍数的行。但是我们可以申明一个连续的空间来存储图像，这个话题引入下面最为高效的遍历图像的机制。

三、更高效的方法

上面已经提到过了，一般来说图像行与行之间往往存储是不连续的，但是有些图像可以是连续的，Mat提供了一个检测图像是否连续的函数isContinuous()。当图像连通时，我们就可以把图像完全展开，看成是一行。

 1 void colorReduce(const Mat& image,Mat& outImage,int div) 2 { 3     int nr=image.rows; 4     int nc=image.cols; 5     outImage.create(image.size(),image.type()); 6     if(image.isContinuous()&&outImage.isContinuous()) 7     { 8         nr=1; 9         nc=nc*image.rows*image.channels();10     }11     for(int i=0;i<nr;i++)12     {13         const uchar* inData=image.ptr<uchar>(i);14         uchar* outData=outImage.ptr<uchar>(i);15         for(int j=0;j<nc;j++)16         {17             *outData++=*inData++/div*div+div/2;18         }19     }20 }

用指针除了用上面的方法外，还可以用指针来索引固定位置的像素：

image.step返回图像一行像素元素的个数（包括空白元素），image.elemSize()返回一个图像像素的大小。

&image.at<uchar>(i,j)=image.data+i*image.step+j*image.elemSize();

四、还有吗？用迭代器来遍历。

下面的方法可以让我们来为图像中的像素声明一个迭代器：

MatIterator_<Vec3b> it;

Mat_<Vec3b>::iterator it;

如果迭代器指向一个const图像，则可以用下面的声明：

MatConstIterator<Vec3b> it; 或者

Mat_<Vec3b>::const_iterator it;

下面我们用迭代器来简化上面的colorReduce程序：

 1 void colorReduce(const Mat& image,Mat& outImage,int div) 2 { 3     outImage.create(image.size(),image.type()); 4     MatConstIterator_<Vec3b> it_in=image.begin<Vec3b>(); 5     MatConstIterator_<Vec3b> itend_in=image.end<Vec3b>(); 6     MatIterator_<Vec3b> it_out=outImage.begin<Vec3b>(); 7     MatIterator_<Vec3b> itend_out=outImage.end<Vec3b>(); 8     while(it_in!=itend_in) 9     {10         (*it_out)[0]=(*it_in)[0]/div*div+div/2;11         (*it_out)[1]=(*it_in)[1]/div*div+div/2;12         (*it_out)[2]=(*it_in)[2]/div*div+div/2;13         it_in++;14         it_out++;15     }16 }

如果你想从第二行开始，则可以从image.begin<Vec3b>()+image.rows开始。

上面4种方法中，第3种方法的效率最高！

五、图像的邻域操作

很多时候，我们对图像处理时，要考虑它的邻域，比如3*3是我们常用的，这在图像滤波、去噪中最为常见，下面我们介绍如果在一次图像遍历过程中进行邻域的运算。

下面我们进行一个简单的滤波操作，滤波算子为[0 –1 0;-1 5 –1;0 –1 0]。

它可以让图像变得尖锐，而边缘更加突出。核心公式即：sharp(i.j)=5*image(i,j)-image(i-1,j)-image(i+1,j

)-image(i,j-1)-image(i,j+1)。

 1 void ImgFilter2d(const Mat &image,Mat& result) 2 { 3     result.create(image.size(),image.type()); 4     int nr=image.rows; 5     int nc=image.cols*image.channels(); 6     for(int i=1;i<nr-1;i++) 7     { 8         const uchar* up_line=image.ptr<uchar>(i-1);//指向上一行 9         const uchar* mid_line=image.ptr<uchar>(i);//当前行10         const uchar* down_line=image.ptr<uchar>(i+1);//下一行11         uchar* cur_line=result.ptr<uchar>(i);12         for(int j=1;j<nc-1;j++)13         {14             cur_line[j]=saturate_cast<uchar>(5*mid_line[j]-mid_line[j-1]-mid_line[j+1]-15                 up_line[j]-down_line[j]);16         }17     }18     // 把图像边缘像素设置为019     result.row(0).setTo(Scalar(0));20     result.row(result.rows-1).setTo(Scalar(0));21     result.col(0).setTo(Scalar(0));22     result.col(result.cols-1).setTo(Scalar(0));23 }

上面的程序有以下几点需要说明：

1，staturate_cast<typename>是一个类型转换函数，程序里是为了确保运算结果还在uchar范围内。

2，row和col方法返回图像中的某些行或列，返回值是一个Mat。

3，setTo方法将Mat对像中的点设置为一个值，Scalar(n)为一个灰度值，Scalar(a,b,c)为一个彩色值。

六、图像的算术运算

Mat类把很多算数操作符都进行了重载，让它们来符合矩阵的一些运算，如果+、-、点乘等。

下面我们来看看用位操作和基本算术运算来完成本文中的colorReduce程序，它更简单，更高效。

将256种灰度阶降到64位其实是抛弃了二进制最后面的4位，所以我们可以用位操作来做这一步处理。

首先我们计算2^8降到2^n中的n：int n=static_cast<int>(log(static_cast<double>(div))/log(2.0));

然后可以得到mask，mask=0xFF<<n;

用下面简直的语句就可以得到我们想要的结果：

result=(image&Scalar(mask,mask,mask))+Scalar(div/2,div/2,div/2);

很多时候我们需要对图像的一个通信单独进行操作，比如在HSV色彩模式下，我们就经常把3个通道分开考虑。

1 vector<Mat> planes;2 // 将image分为三个通道图像存储在planes中3 split(image,planes);4 planes[0]+=image2;5 // 将planes中三幅图像合为一个三通道图像6 merge(planes,result);

顶

0

踩