OpenCV坐标系与操作像素的四种方法

像素是图像的基本组成单位，熟悉了如何操作像素，就能更好的理解对图像的各种处理变换的实现方式了。

1.at方法

第一种操作像素的方法是使用“at”，如一幅3通道的彩色图像image的第i行j列的B、G、R分量分别表示为：

image.at<Vec3b>(i,j)[0];

image.at<Vec3b>(i,j)[1];

image.at<Vec3b>(i,j)[2];

而对于单通道的灰度图像就简单很多了：

image.at<uchar>(i,j); 

这里要注意at中(i,j)的顺序表示的是第i行第j列，跟Point(i,j)和Rect(i,j)中表示第j行第i列是相反的，如果把这个搞混了，很容易导致内存异常，还不容易发现错误。

 

补充说明一下：OpenCV中坐标体系中的零点坐标定义为图片的左上角，X轴为图像矩形的上面那条水平线，从左往右；Y轴为图像矩形左边的那条垂直线，从上往下。在Point(x,y)和Rect(x,y)中，第一个参数x代表的是元素所在图像的列数，第二个参数y代表的是元素所在图像的行数，而在at(x,y)中是相反的。

演示程序如下:

[cpp]  view plain  copy

 print ?

1. #include<iostream>  
2. #include<core/core.hpp>  
3. #include<highgui/highgui.hpp>  
4.   
5. using namespace cv;  
6. using namespace std;  
7.   
8. int main()  
9. {  
10.     Mat image(Size(500,500),CV_8UC3);  
11.     image.at<Vec3b>(100,250)[0]=0;  
12.     image.at<Vec3b>(100,250)[1]=0;  
13.     image.at<Vec3b>(100,250)[2]=255;  
14.     putText(image,"at(100,250) is Here!",Point(250,100),0,0.7,Scalar(255,0,0));  //点,字体，大小
15.   
16.     image.at<Vec3b>(Point(100,250))[0]=0;  
17.     image.at<Vec3b>(Point(100,250))[1]=0;  
18.     image.at<Vec3b>(Point(100,250))[2]=255;  
19.     putText(image,"at(Point(100,250)) is Here!",Point(100,250),0,0.7,Scalar(255,0,0));  
20.   
21.     imshow("Test Function at",image);  
22.     waitKey();  
23.     return 0;  
24. }  

 

2.行指针方法

行指针方法的思路是获取图像每一行的首地址的指针，把每一行当成一个循环对象，逐行遍历所有的像素。例如对于一个X行、Y列的图像image，每行需要循环 的数量是Y*image.channels()，channels表示的是图像的通道，对于灰度图像channels为1，对于彩色RGB图像，channels为3。

3.指针方法

对于硬件处理芯片来说，如果图像每行的长度是4或8的倍数的话，运算起来会更加快速，如果不是4或8的倍数的话，在运算前图像行长度会被补充至固定值。

“指针方法”是一种可以高效遍历图像的方式，但是只能针对没有经过填充的连续图像，所以在使用指针方法之前需要先判断图像有没有经过填充，是否连续性。判断的方法很简单，使用Mat的成员函数isContinuous来判断，若返回值为真的话，说明图像是连续的，可以应用行指针的方法遍历像素。

4.迭代方法

使用迭代器遍历图像集合中的各个元素，相比前3中方法，这个方法简直可以永简单快捷的“无脑操作”来形容，你只需获取集合中元素的首地址以及元素的终止位置，剩下的工作交给迭代器来完成就可以了，并且我们不用关心集合的数据类型，指针总是逐次访问下一地址，直到指针到达终止元素位置。不过其缺点也是显而易见的：不容易指定访问集合中某一个位置的元素。

话不多少，下边给出一个完整的四种访问图像像素方法的示例，并对每种方法的耗时作对比，包括opencv本身的Copy方法；当然五种方法实现的是同一个简单的功能——通过逐个遍历一幅图像的每一个像素，复制该图像到另一Mat对象。

[cpp]  view plain  copy

 print ?

1. #include<iostream>  
2. #include<core/core.hpp>  
3. #include<highgui/highgui.hpp>  
4.   
5. using namespace cv;  
6. using namespace std;  
7.   
8. //At方法  
9. double CopyImageByAt(Mat originalImage, Mat &targetImage);  
10. //行指针方法  
11. double CopyImageByRowPtr(Mat originalImage, Mat &targetImage);  
12. //指针方法  
13. double CopyImageByPtr(Mat originalImage, Mat &targetImage);  
14. //迭代方法  
15. double CopyImageByIterator(Mat originalImage, Mat &targetImage);  
16. //Opencv方法  
17. double CopyFun(Mat originalImage, Mat &targetImage);  
18.   
19.   
20. int main()  
21. {  
22.     //读入图片，注意图片路径 
23. //第二个参数表示图片读入的方式（flags可以缺省，缺省时flags=1，表示以彩色图片方式读入图片） 
    //flags>0时表示以彩色方式读入图片 
    //flags=0时表示以灰度图方式读入图片 
    //flags<0时表示以图片的本来的格式读入图片 
24.     Mat image=imread("D:\\Picture\\lena.jpg",1);  
25.   
26.     //图片读入成功与否判定  
27.     if(!image.data)  
28.     {  
29.         cout<<"you idiot！where did you hide lena！"<<endl;  
30.         //等待按键  
31.         system("pause");  
32.         return -1;  
33.     }  
34.     imshow("原始图像",image);  
35.     //输出图像  
36.     Mat targetImage(image.size(),image.type());  
37.     cout<<endl<<"At方法耗时："<<CopyImageByAt(image,targetImage)<<endl;  
38.     imshow("At方法",targetImage);  
39.     cout<<endl<<"行指针方法耗时："<<CopyImageByRowPtr(image,targetImage)<<endl;  
40.     imshow("行指针方法",targetImage);  
41.     cout<<endl<<"指针方法耗时："<<CopyImageByPtr(image,targetImage)<<endl;  
42.     imshow("指针方法",targetImage);  
43.     cout<<endl<<"迭代方法耗时："<<CopyImageByIterator(image,targetImage)<<endl;  
44.     imshow("迭代方法",targetImage);  
45.     cout<<endl<<"OpenCV Copy方法耗时："<<CopyFun(image,targetImage)<<endl;  
46.     imshow("Copy方法",targetImage);     
47.     waitKey();  
48.     return 0;  
49. }  
50.   
51. //使用at方法实现逐个像素复制  
52. double CopyImageByAt(Mat originalImage, Mat &targetImage)  
53. {  
54.     double now=getTickCount();  
55.     //行  
56.     int rows=originalImage.rows;  
57.     //列  
58.     int cols=originalImage.cols;  
59.     for(int i=0;i<rows;i++)  
60.     {  
61.         for(int j=0;j<cols;j++)  
62.         {  
63.             //若是灰度图像应使用如下表示：   
64.             //targetImage.at<uchar>(i,j)=originalImage.at<Vec3b>(i,j);            
65.             targetImage.at<Vec3b>(i,j)[0]=originalImage.at<Vec3b>(i,j)[0];  
66.             targetImage.at<Vec3b>(i,j)[1]=originalImage.at<Vec3b>(i,j)[1];  
67.             targetImage.at<Vec3b>(i,j)[2]=originalImage.at<Vec3b>(i,j)[2];  
68.         }  
69.     }  
70.     double end=getTickCount();  
71.     //返回方法耗时  
72.     return (end-now)/getTickFrequency();  
73. }  
74.   
75. //使用访问每行首指针方法实现像素复制  
76. double CopyImageByRowPtr(Mat originalImage, Mat &targetImage)  
77. {  
78.     double now=getTickCount();  
79.     //行  
80.     int rows=targetImage.rows;  
81.     //每行总元素数量，此处图像为3通道  
82.     int totalNum=targetImage.cols*targetImage.channels();  
83.     for(int i=0;i<rows;i++)  
84.     {  
85.         //data1指向目标图像第i行的首元素  
86.         uchar *data1=targetImage.ptr<uchar>(i);  
87.         data2指向原始图像第i行的首元素  
88.         uchar *data2=originalImage.ptr<uchar>(i);  
89.         for(int j=0;j<totalNum;j++)  
90.         {  
91.             //遍历每行所有元素  
92.             data1[j]=data2[j];  
93.         }  
94.     }  
95.     double end=getTickCount();  
96.     //返回方法耗时  
97.     return (end-now)/getTickFrequency();  
98. }  
99.   
100. //无扩充的图像，采用指针方法逐个像素复制  
101. double CopyImageByPtr(Mat originalImage, Mat &targetImage)  
102. {  
103.     double now=getTickCount();  
104.     //行  
105.     int rows=targetImage.rows;  
106.     //每行总元素数量，此处图像为3通道  
107.     int totalNum=targetImage.cols*targetImage.channels();  
108.     //判断图像数据是否连续  
109.     if(originalImage.isContinuous())  
110.     {  
111.         totalNum*=rows;  
112.         rows=1;  
113.     }  
114.     //外层循环只执行一次  
115.     for(int i=0;i<rows;i++)  
116.     {  
117.         uchar *data1=targetImage.ptr<uchar>(i);  
118.         uchar *data2=originalImage.ptr<uchar>(i);  
119.         for(int j=0;j<totalNum;j++)  
120.         {  
121.           data1[j]=data2[j];  
122.         }  
123.     }  
124.     double end=getTickCount();  
125.     //返回方法耗时  
126.     return (end-now)/getTickFrequency();  
127. }  
128.   
129. //使用迭代器遍历逐个像素复制  
130. double CopyImageByIterator(Mat originalImage, Mat &targetImage)  
131. {  
132.     double now=getTickCount();  
133.     //获取起始位置迭代器  
134.     Mat_<Vec3b>::iterator itBegin1=targetImage.begin<Vec3b>();  
135.     Mat_<Vec3b>::iterator itBegin2=originalImage.begin<Vec3b>();  
136.     //获取终止位置迭代器  
137.     Mat_<Vec3b>::iterator itEnd1=targetImage.end<Vec3b>();  
138.     Mat_<Vec3b>::iterator itEnd2=originalImage.end<Vec3b>();  
139.     for(;itBegin1!=itEnd1;++itBegin1)  
140.     {  
141.         (*itBegin1)[0]=(*itBegin2)[0];  
142.         (*itBegin1)[1]=(*itBegin2)[1];  
143.         (*itBegin1)[2]=(*itBegin2)[2];  
144.         ++itBegin2;  
145.     }  
146.     double end=getTickCount();  
147.     //返回方法耗时  
148.     return (end-now)/getTickFrequency();  
149. }  
150.   
151. //OpenCV Copy方法实现图像复制  
152. double CopyFun(Mat originalImage, Mat &targetImage)  
153. {  
154.     double now=getTickCount();  
155.     originalImage.copyTo(targetImage);  
156.     double end=getTickCount();    
157.     //返回方法耗时  
158.     return (end-now)/getTickFrequency();  
159. }  

可见，指针方法是高效快捷访问像素的首选方法，然而跟opencv的Copy方法相比，还是弱爆了……