获取图像像素方法汇总

图像操作最基础的还是对像素获取及变换，也就相当于对矩阵中的元素的操作，使用不同的方法所用的时间也相差甚大。以下有几种方法：

1、指针操作

（1）双重循环，遍历图像所有的像素值

[html] view plain copy

1. <span style="font-size:18px;">for(int i = 0;i < rowNumber;i++)  //行循环  
2.     {    
3.         uchar* data = outputImage.ptr<uchar>(i);  //<span style="color:#ff0000;">获取第i行的首地址</span>  
4.         for(int j = 0;j < colNumber;j++)   //列循环  
5.         {     
6.             // ---------【开始处理每个像素】-------------       
7.             data[j] = data[j]/div*div + div/2;    
8.             // ----------【处理结束】---------------------  
9.         }  //行处理结束  
10.     }  </span>  

（2）更高效的扫描连续图像，把一副M*N（M行，N列）图像看成是1*（M*N）（1行M*N列）。使用方法如下：

[html] view plain copy

1. if (img.isContinuous())  
2. {<pre name="code" class="html">uchar* data = img.data;  
3. // img.at(i, j)  
4. data = img.data + i * img.step + j * img.elemSize();</pre><br>  
5. nc = img.rows*img.cols*img.channels();}  
6. <pre></pre>  
7. <pre></pre>  
8. <pre></pre>  

（3）更低级的指针操作就是使用Mat里的data指针，使用方法：

[html] view plain copy

1. uchar* data = img.data;  
2. // img.at(i, j)  
3. data = img.data + i * img.step + j * img.elemSize();  

2.Mat成员函数，存取单个像素值

（1）最通常的方法就是

[html] view plain copy

1.        //参数准备  
2. outputImage = inputImage.clone();  //拷贝实参到临时变量  
3. int rowNumber = outputImage.rows;  //行数  
4. int colNumber = outputImage.cols;  //列数  
5.   
6. //存取彩色图像像素  
7. for(int i = 0;i < rowNumber;i++)    
8. {    
9.     for(int j = 0;j < colNumber;j++)    
10.     {     
11.         // ------------------------【开始处理每个像素】--------------------  
12.         outputImage.at<Vec3b>(i,j)[0] =  outputImage.at<Vec3b>(i,j)[0]/div*div + div/2;  //蓝色通道  
13.         outputImage.at<Vec3b>(i,j)[1] =  outputImage.at<Vec3b>(i,j)[1]/div*div + div/2;  //绿色通道  
14.         outputImage.at<Vec3b>(i,j)[2] =  outputImage.at<Vec3b>(i,j)[2]/div*div + div/2;  //红是通道  
15.         // -------------------------【处理结束】----------------------------  
16.     }  // 行处理结束       
17. }    

（2）也可以考虑使用的Mat_类，使用重载操作符()实现取元素的操作。

[html] view plain copy

1. cv::Mat_<uchar> im2= img; // im2 refers to image  
2.    im2(50,100)= 0; // access to row 50 and column 100  

3.用迭代器iterator扫描图像

和C++STL里的迭代器类似，Mat的迭代器与之是兼容的。是MatIterator_。声明方法如下：

[cpp] view plain copy

1. cv::MatIterator_<Vec3b> it;  

或者是：

[cpp] view plain copy

1. cv::Mat_<Vec3b>::iterator it;  

扫描图像的方法如下：

[html] view plain copy

1.         //参数准备  
2. outputImage = inputImage.clone();  //拷贝实参到临时变量  
3. //获取迭代器  
4. Mat_<Vec3b>::iterator it = outputImage.begin<Vec3b>();  //初始位置的迭代器  
5. Mat_<Vec3b>::iterator itend = outputImage.end<Vec3b>();  //终止位置的迭代器  
6. //存取彩色图像像素  
7. for(;it != itend;++it)    
8. {    
9.     // ------------------------【开始处理每个像素】--------------------  
10.     (*it)[0] = (*it)[0]/div*div + div/2;    
11.     (*it)[1] = (*it)[1]/div*div + div/2;    
12.     (*it)[2] = (*it)[2]/div*div + div/2;    
13.     // ------------------------【处理结束】----------------------------  
14. }    

4.整行整列像素值的赋值

    对于整行或者整列的数据，可以考虑这种方式处理

[cpp] view plain copy

1. img.row(i).setTo(Scalar(255));  
2. img.col(j).setTo(Scalar(255));  

【3】记录起始时间
double time0 = static_cast<double>(getTickCount());  


//【4】调用颜色空间缩减函数
colorReduce(srcImage,dstImage,1);  


//【5】计算运行时间并输出
time0 = ((double

5.效率计算（时间）

使用getTickCount、getTickFrequency函数测试速度。

[html] view plain copy

1.         //记录起始时间  
2. double time0 = static_cast<double>(getTickCount());      
3.         //调用函数  
4.  //计算运行时间并输出  
5. time0 = ((double)getTickCount() - time0)/getTickFrequency();  

（1）内存分配是个耗时的工作，优化之；

（2）在循环中重复计算已经得到的值，是个费时的工作，优化之；举例：

[cpp] view plain copy

1. int nc = img.cols * img.channels();  
2. for (int i=0; i<nc; i++)  
3. {.......}  
4. //**************************  
5. for (int i=0; i<img.cols * img.channels(); i++)  
6. {......}  

后者的速度比前者要慢上好多。

（3）使用迭代器也会是速度变慢，但迭代器的使用可以减少程序错误的发生几率，考虑这个因素，可以酌情优化

（4）at操作要比指针的操作慢很多，所以对于不连续数据或者单个点处理，可以考虑at操作，对于连续的大量数据，不要使用它

（5）扫描连续图像的做法可能是把W*H的一副图像看成是一个1*（w*h）的一个一维数组这种办法也可以提高速度。短的循环比长循环更高效，即使他们的操作数是相同的

遍历图像像素的14种方法

[html] view plain copy

1. #include <iostream>  
2. #include <opencv2/core/core.hpp>  
3. #include <opencv2/highgui/highgui.hpp>  
4. using namespace cv;  
5. using namespace std;  
6. //---------------------------------【宏定义部分】---------------------------------------------  
7. //      描述：包含程序所使用宏定义  
8. //-------------------------------------------------------------------------------------------------  
9. #define NTESTS 14  
10. #define NITERATIONS 20  
11. //----------------------------------------- 【方法一】-------------------------------------------  
12. //      说明：利用.ptr 和 []  
13. //-------------------------------------------------------------------------------------------------  
14. void colorReduce0(Mat &image, int div=64) {  
15.   
16.       int nl= image.rows; //行数  
17.       int nc= image.cols * image.channels(); //每行元素的总元素数量  
18.                 
19.       for (int j=0; j<nl; j++)   
20.       {  
21.   
22.           uchar* data= image.ptr<uchar>(j);  
23.   
24.           for (int i=0; i<nc; i++)   
25.           {  
26.    
27.             //-------------开始处理每个像素-------------------  
28.                    
29.                   data[i]= data[i]/div*div + div/2;  
30.    
31.             //-------------结束像素处理------------------------  
32.    
33.             } //单行处理结束                    
34.       }  
35. }  
36. //-----------------------------------【方法二】-------------------------------------------------  
37. //      说明：利用 .ptr 和 * ++   
38. //-------------------------------------------------------------------------------------------------  
39. void colorReduce1(Mat &image, int div=64) {  
40.   
41.       int nl= image.rows; //行数  
42.       int nc= image.cols * image.channels(); //每行元素的总元素数量  
43.                 
44.       for (int j=0; j<nl; j++)   
45.       {  
46.   
47.           uchar* data= image.ptr<uchar>(j);  
48.   
49.           for (int i=0; i<nc; i++)   
50.           {  
51.    
52.             //-------------开始处理每个像素-------------------  
53.                    
54.                  *data++= *data/div*div + div/2;  
55.    
56.             //-------------结束像素处理------------------------  
57.    
58.             } //单行处理结束                
59.       }  
60. }  
61. //-----------------------------------------【方法三】-------------------------------------------  
62. //      说明：利用.ptr 和 * ++ 以及模操作  
63. //-------------------------------------------------------------------------------------------------  
64. void colorReduce2(Mat &image, int div=64) {  
65.   
66.       int nl= image.rows; //行数  
67.       int nc= image.cols * image.channels(); //每行元素的总元素数量  
68.                 
69.       for (int j=0; j<nl; j++)   
70.       {  
71.   
72.           uchar* data= image.ptr<uchar>(j);  
73.   
74.           for (int i=0; i<nc; i++)   
75.           {  
76.    
77.             //-------------开始处理每个像素-------------------  
78.          
79.                   int v= *data;  
80.                   *data++= v - v%div + div/2;  
81.    
82.             //-------------结束像素处理------------------------  
83.    
84.             } //单行处理结束                     
85.       }  
86. }  
87.   
88. //----------------------------------------【方法四】---------------------------------------------  
89. //      说明：利用.ptr 和 * ++ 以及位操作  
90. //----------------------------------------------------------------------------------------------------  
91. void colorReduce3(Mat &image, int div=64) {  
92.   
93.       int nl= image.rows; //行数  
94.       int nc= image.cols * image.channels(); //每行元素的总元素数量  
95.       int n= static_cast<int>(log(static_cast<double>(div))/log(2.0));  
96.       //掩码值  
97.       uchar mask= 0xFF<<n; // e.g. 对于 div=16, mask= 0xF0  
98.                 
99.       for (int j=0; j<nl; j++) {  
100.   
101.           uchar* data= image.ptr<uchar>(j);  
102.   
103.           for (int i=0; i<nc; i++) {  
104.    
105.             //------------开始处理每个像素-------------------  
106.                    
107.             *data++= *data&mask + div/2;  
108.    
109.             //-------------结束像素处理------------------------  
110.             }  //单行处理结束              
111.       }  
112. }  
113.   
114.   
115. //----------------------------------------【方法五】----------------------------------------------  
116. //      说明：利用指针算术运算  
117. //---------------------------------------------------------------------------------------------------  
118. void colorReduce4(Mat &image, int div=64) {  
119.   
120.       int nl= image.rows; //行数  
121.       int nc= image.cols * image.channels(); //每行元素的总元素数量  
122.       int n= static_cast<int>(log(static_cast<double>(div))/log(2.0));  
123.       int step= image.step; //有效宽度  
124.       //掩码值  
125.       uchar mask= 0xFF<<n; // e.g. 对于 div=16, mask= 0xF0  
126.                 
127.       //获取指向图像缓冲区的指针  
128.       uchar *data= image.data;  
129.   
130.       for (int j=0; j<nl; j++)  
131.       {  
132.   
133.           for (int i=0; i<nc; i++)   
134.           {  
135.    
136.             //-------------开始处理每个像素-------------------  
137.                    
138.             *(data+i)= *data&mask + div/2;  
139.    
140.             //-------------结束像素处理------------------------  
141.    
142.             } //单行处理结束                
143.   
144.             data+= step;  // next line  
145.       }  
146. }  
147.   
148. //---------------------------------------【方法六】----------------------------------------------  
149. //      说明：利用 .ptr 和 * ++以及位运算、image.cols * image.channels()  
150. //-------------------------------------------------------------------------------------------------  
151. void colorReduce5(Mat &image, int div=64) {  
152.   
153.       int nl= image.rows; //行数  
154.       int n= static_cast<int>(log(static_cast<double>(div))/log(2.0));  
155.       //掩码值  
156.       uchar mask= 0xFF<<n; // e.g. 例如div=16, mask= 0xF0  
157.                 
158.       for (int j=0; j<nl; j++)   
159.       {  
160.   
161.           uchar* data= image.ptr<uchar>(j);  
162.   
163.           for (int i=0; i<image.cols * image.channels(); i++)   
164.           {  
165.    
166.             //-------------开始处理每个像素-------------------  
167.                    
168.             *data++= *data&mask + div/2;  
169.    
170.             //-------------结束像素处理------------------------  
171.    
172.             } //单行处理结束              
173.       }  
174. }  
175.   
176. // -------------------------------------【方法七】----------------------------------------------  
177. //      说明：利用.ptr 和 * ++ 以及位运算(continuous)  
178. //-------------------------------------------------------------------------------------------------  
179. void colorReduce6(Mat &image, int div=64) {  
180.   
181.       int nl= image.rows; //行数  
182.       int nc= image.cols * image.channels(); //每行元素的总元素数量  
183.   
184.       if (image.isContinuous())    
185.       {  
186.           //无填充像素  
187.           nc= nc*nl;   
188.           nl= 1;  // 为一维数列  
189.        }  
190.   
191.       int n= static_cast<int>(log(static_cast<double>(div))/log(2.0));  
192.       //掩码值  
193.       uchar mask= 0xFF<<n; // e.g. 比如div=16, mask= 0xF0  
194.                 
195.       for (int j=0; j<nl; j++) {  
196.   
197.           uchar* data= image.ptr<uchar>(j);  
198.   
199.           for (int i=0; i<nc; i++) {  
200.    
201.             //-------------开始处理每个像素-------------------  
202.                    
203.             *data++= *data&mask + div/2;  
204.    
205.             //-------------结束像素处理------------------------  
206.    
207.             } //单行处理结束                     
208.       }  
209. }  
210.   
211. //------------------------------------【方法八】------------------------------------------------  
212. //      说明：利用 .ptr 和 * ++ 以及位运算 (continuous+channels)  
213. //-------------------------------------------------------------------------------------------------  
214. void colorReduce7(Mat &image, int div=64) {  
215.   
216.       int nl= image.rows; //行数  
217.       int nc= image.cols ; //列数  
218.   
219.       if (image.isContinuous())    
220.       {  
221.           //无填充像素  
222.           nc= nc*nl;   
223.           nl= 1;  // 为一维数组  
224.        }  
225.   
226.       int n= static_cast<int>(log(static_cast<double>(div))/log(2.0));  
227.       //掩码值  
228.       uchar mask= 0xFF<<n; // e.g. 比如div=16, mask= 0xF0  
229.                 
230.       for (int j=0; j<nl; j++) {  
231.   
232.           uchar* data= image.ptr<uchar>(j);  
233.   
234.           for (int i=0; i<nc; i++) {  
235.    
236.             //-------------开始处理每个像素-------------------  
237.                    
238.             *data++= *data&mask + div/2;  
239.             *data++= *data&mask + div/2;  
240.             *data++= *data&mask + div/2;  
241.    
242.             //-------------结束像素处理------------------------  
243.    
244.             } //单行处理结束                      
245.       }  
246. }  
247.   
248.   
249. // -----------------------------------【方法九】 ------------------------------------------------  
250. //      说明：利用Mat_ iterator  
251. //-------------------------------------------------------------------------------------------------  
252. void colorReduce8(Mat &image, int div=64) {  
253.   
254.       //获取迭代器  
255.       Mat_<Vec3b>::iterator it= image.begin<Vec3b>();  
256.       Mat_<Vec3b>::iterator itend= image.end<Vec3b>();  
257.   
258.       for ( ; it!= itend; ++it) {  
259.           
260.         //-------------开始处理每个像素-------------------  
261.   
262.         (*it)[0]= (*it)[0]/div*div + div/2;  
263.         (*it)[1]= (*it)[1]/div*div + div/2;  
264.         (*it)[2]= (*it)[2]/div*div + div/2;  
265.   
266.         //-------------结束像素处理------------------------  
267.       }//单行处理结束    
268. }  
269.   
270. //-------------------------------------【方法十】-----------------------------------------------  
271. //      说明：利用Mat_ iterator以及位运算  
272. //-------------------------------------------------------------------------------------------------  
273. void colorReduce9(Mat &image, int div=64) {  
274.   
275.       // div必须是2的幂  
276.       int n= static_cast<int>(log(static_cast<double>(div))/log(2.0));  
277.       //掩码值  
278.       uchar mask= 0xFF<<n; // e.g. 比如 div=16, mask= 0xF0  
279.   
280.       // 获取迭代器  
281.       Mat_<Vec3b>::iterator it= image.begin<Vec3b>();  
282.       Mat_<Vec3b>::iterator itend= image.end<Vec3b>();  
283.   
284.       //扫描所有元素  
285.       for ( ; it!= itend; ++it)   
286.       {  
287.           
288.         //-------------开始处理每个像素-------------------  
289.   
290.         (*it)[0]= (*it)[0]&mask + div/2;  
291.         (*it)[1]= (*it)[1]&mask + div/2;  
292.         (*it)[2]= (*it)[2]&mask + div/2;  
293.   
294.         //-------------结束像素处理------------------------  
295.       }//单行处理结束    
296. }  
297.   
298. //------------------------------------【方法十一】---------------------------------------------  
299. //      说明：利用Mat Iterator_  
300. //-------------------------------------------------------------------------------------------------  
301. void colorReduce10(Mat &image, int div=64) {  
302.   
303.       //获取迭代器  
304.       Mat_<Vec3b> cimage= image;  
305.       Mat_<Vec3b>::iterator it=cimage.begin();  
306.       Mat_<Vec3b>::iterator itend=cimage.end();  
307.   
308.       for ( ; it!= itend; it++) {   
309.           
310.         //-------------开始处理每个像素-------------------  
311.   
312.         (*it)[0]= (*it)[0]/div*div + div/2;  
313.         (*it)[1]= (*it)[1]/div*div + div/2;  
314.         (*it)[2]= (*it)[2]/div*div + div/2;  
315.   
316.         //-------------结束像素处理------------------------  
317.       }  
318. }  
319.   
320. //--------------------------------------【方法十二】--------------------------------------------  
321. //      说明：利用动态地址计算配合at  
322. //-------------------------------------------------------------------------------------------------  
323. void colorReduce11(Mat &image, int div=64) {  
324.   
325.       int nl= image.rows; //行数  
326.       int nc= image.cols; //列数  
327.                 
328.       for (int j=0; j<nl; j++)   
329.       {  
330.           for (int i=0; i<nc; i++)   
331.           {  
332.    
333.             //-------------开始处理每个像素-------------------  
334.                    
335.                   image.at<Vec3b>(j,i)[0]=     image.at<Vec3b>(j,i)[0]/div*div + div/2;  
336.                   image.at<Vec3b>(j,i)[1]=     image.at<Vec3b>(j,i)[1]/div*div + div/2;  
337.                   image.at<Vec3b>(j,i)[2]=     image.at<Vec3b>(j,i)[2]/div*div + div/2;  
338.    
339.             //-------------结束像素处理------------------------  
340.    
341.             } //单行处理结束                   
342.       }  
343. }  
344.   
345. //----------------------------------【方法十三】-----------------------------------------------   
346. //      说明：利用图像的输入与输出  
347. //-------------------------------------------------------------------------------------------------  
348. void colorReduce12(const Mat &image, //输入图像  
349.                  Mat &result,      // 输出图像  
350.                  int div=64) {  
351.   
352.       int nl= image.rows; //行数  
353.       int nc= image.cols ; //列数  
354.   
355.       //准备好初始化后的Mat给输出图像  
356.       result.create(image.rows,image.cols,image.type());  
357.   
358.       //创建无像素填充的图像  
359.       nc= nc*nl;   
360.       nl= 1;  //单维数组  
361.   
362.       int n= static_cast<int>(log(static_cast<double>(div))/log(2.0));  
363.       //掩码值  
364.       uchar mask= 0xFF<<n; // e.g.比如div=16, mask= 0xF0  
365.                 
366.       for (int j=0; j<nl; j++) {  
367.   
368.           uchar* data= result.ptr<uchar>(j);  
369.           const uchar* idata= image.ptr<uchar>(j);  
370.   
371.           for (int i=0; i<nc; i++) {  
372.    
373.             //-------------开始处理每个像素-------------------  
374.                    
375.             *data++= (*idata++)&mask + div/2;  
376.             *data++= (*idata++)&mask + div/2;  
377.             *data++= (*idata++)&mask + div/2;  
378.    
379.             //-------------结束像素处理------------------------  
380.    
381.           } //单行处理结束                     
382.       }  
383. }  
384.   
385. //--------------------------------------【方法十四】-------------------------------------------   
386. //      说明：利用操作符重载  
387. //-------------------------------------------------------------------------------------------------  
388. void colorReduce13(Mat &image, int div=64) {  
389.       
390.       int n= static_cast<int>(log(static_cast<double>(div))/log(2.0));  
391.       //掩码值  
392.       uchar mask= 0xFF<<n; // e.g. 比如div=16, mask= 0xF0  
393.   
394.       //进行色彩还原  
395.       image=(image&Scalar(mask,mask,mask))+Scalar(div/2,div/2,div/2);  
396. }  
397.   
398.   
399.   
400.   
401. //-----------------------------------【ShowHelpText( )函数】-----------------------------  
402. //      描述：输出一些帮助信息  
403. //----------------------------------------------------------------------------------------------  
404. void ShowHelpText()  
405. {  
406.     //输出欢迎信息和OpenCV版本  
407.     printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书！\n");  
408.     printf("\n\n\t\t\t此为本书OpenCV3版的第24个配套示例程序\n");  
409.     printf("\n\n\t\t\t   当前使用的OpenCV版本为：" CV_VERSION );  
410.     printf("\n\n  ----------------------------------------------------------------------------\n");  
411.   
412.     printf("\n\n正在进行存取操作，请稍等……\n\n");  
413. }  
414.   
415.   
416.   
417.   
418. //-----------------------------------【main( )函数】--------------------------------------------  
419. //      描述：控制台应用程序的入口函数，我们的程序从这里开始  
420. //-------------------------------------------------------------------------------------------------  
421. int main( )  
422. {  
423.     int64 t[NTESTS],tinit;  
424.     Mat image0;  
425.     Mat image1;  
426.     Mat image2;  
427.   
428.     system("color 4F");  
429.   
430.     ShowHelpText();  
431.   
432.     image0= imread("1.png");  
433.     if (!image0.data)  
434.         return 0;   
435.   
436.     //时间值设为0  
437.     for (int i=0; i<NTESTS; i++)  
438.         t[i]= 0;  
439.   
440.   
441.     // 多次重复测试  
442.     int n=NITERATIONS;  
443.     for (int k=0; k<n; k++)  
444.     {  
445.         cout << k << " of " << n << endl;   
446.   
447.         image1= imread("1.png");  
448.         //【方法一】利用.ptr 和 []  
449.         tinit= getTickCount();  
450.         colorReduce0(image1);  
451.         t[0]+= getTickCount()-tinit;  
452.   
453.         //【方法二】利用 .ptr 和 * ++   
454.         image1= imread("1.png");  
455.         tinit= getTickCount();  
456.         colorReduce1(image1);  
457.         t[1]+= getTickCount()-tinit;  
458.   
459.         //【方法三】利用.ptr 和 * ++ 以及模操作  
460.         image1= imread("1.png");  
461.         tinit= getTickCount();  
462.         colorReduce2(image1);  
463.         t[2]+= getTickCount()-tinit;  
464.   
465.         //【方法四】 利用.ptr 和 * ++ 以及位操作  
466.         image1= imread("1.png");  
467.         tinit= getTickCount();  
468.         colorReduce3(image1);  
469.         t[3]+= getTickCount()-tinit;  
470.   
471.         //【方法五】 利用指针的算术运算  
472.         image1= imread("1.png");  
473.         tinit= getTickCount();  
474.         colorReduce4(image1);  
475.         t[4]+= getTickCount()-tinit;  
476.   
477.         //【方法六】利用 .ptr 和 * ++以及位运算、image.cols * image.channels()  
478.         image1= imread("1.png");  
479.         tinit= getTickCount();  
480.         colorReduce5(image1);  
481.         t[5]+= getTickCount()-tinit;  
482.   
483.         //【方法七】利用.ptr 和 * ++ 以及位运算(continuous)  
484.         image1= imread("1.png");  
485.         tinit= getTickCount();  
486.         colorReduce6(image1);  
487.         t[6]+= getTickCount()-tinit;  
488.   
489.         //【方法八】利用 .ptr 和 * ++ 以及位运算 (continuous+channels)  
490.         image1= imread("1.png");  
491.         tinit= getTickCount();  
492.         colorReduce7(image1);  
493.         t[7]+= getTickCount()-tinit;  
494.   
495.         //【方法九】 利用Mat_ iterator  
496.         image1= imread("1.png");  
497.         tinit= getTickCount();  
498.         colorReduce8(image1);  
499.         t[8]+= getTickCount()-tinit;  
500.   
501.         //【方法十】 利用Mat_ iterator以及位运算  
502.         image1= imread("1.png");  
503.         tinit= getTickCount();  
504.         colorReduce9(image1);  
505.         t[9]+= getTickCount()-tinit;  
506.   
507.         //【方法十一】利用Mat Iterator_  
508.         image1= imread("1.png");  
509.         tinit= getTickCount();  
510.         colorReduce10(image1);  
511.         t[10]+= getTickCount()-tinit;  
512.   
513.         //【方法十二】 利用动态地址计算配合at  
514.         image1= imread("1.png");  
515.         tinit= getTickCount();  
516.         colorReduce11(image1);  
517.         t[11]+= getTickCount()-tinit;  
518.   
519.         //【方法十三】 利用图像的输入与输出  
520.         image1= imread("1.png");  
521.         tinit= getTickCount();  
522.         Mat result;  
523.         colorReduce12(image1, result);  
524.         t[12]+= getTickCount()-tinit;  
525.         image2= result;  
526.           
527.         //【方法十四】 利用操作符重载  
528.         image1= imread("1.png");  
529.         tinit= getTickCount();  
530.         colorReduce13(image1);  
531.         t[13]+= getTickCount()-tinit;  
532.   
533.         //------------------------------  
534.     }  
535.      //输出图像     
536.     imshow("原始图像",image0);  
537.     imshow("结果",image2);  
538.     imshow("图像结果",image1);  
539.   
540.     // 输出平均执行时间  
541.     cout << endl << "-------------------------------------------" << endl << endl;  
542.     cout << "\n【方法一】利用.ptr 和 []的方法所用时间为 " << 1000.*t[0]/getTickFrequency()/n << "ms" << endl;  
543.     cout << "\n【方法二】利用 .ptr 和 * ++ 的方法所用时间为" << 1000.*t[1]/getTickFrequency()/n << "ms" << endl;  
544.     cout << "\n【方法三】利用.ptr 和 * ++ 以及模操作的方法所用时间为" << 1000.*t[2]/getTickFrequency()/n << "ms" << endl;  
545.     cout << "\n【方法四】利用.ptr 和 * ++ 以及位操作的方法所用时间为" << 1000.*t[3]/getTickFrequency()/n << "ms" << endl;  
546.     cout << "\n【方法五】利用指针算术运算的方法所用时间为" << 1000.*t[4]/getTickFrequency()/n << "ms" << endl;  
547.     cout << "\n【方法六】利用 .ptr 和 * ++以及位运算、channels()的方法所用时间为" << 1000.*t[5]/getTickFrequency()/n << "ms" << endl;  
548.     cout << "\n【方法七】利用.ptr 和 * ++ 以及位运算(continuous)的方法所用时间为" << 1000.*t[6]/getTickFrequency()/n << "ms" << endl;  
549.     cout << "\n【方法八】利用 .ptr 和 * ++ 以及位运算 (continuous+channels)的方法所用时间为" << 1000.*t[7]/getTickFrequency()/n << "ms" << endl;  
550.     cout << "\n【方法九】利用Mat_ iterator 的方法所用时间为" << 1000.*t[8]/getTickFrequency()/n << "ms" << endl;  
551.     cout << "\n【方法十】利用Mat_ iterator以及位运算的方法所用时间为" << 1000.*t[9]/getTickFrequency()/n << "ms" << endl;  
552.     cout << "\n【方法十一】利用Mat Iterator_的方法所用时间为" << 1000.*t[10]/getTickFrequency()/n << "ms" << endl;    
553.     cout << "\n【方法十二】利用动态地址计算配合at 的方法所用时间为" << 1000.*t[11]/getTickFrequency()/n << "ms" << endl;      
554.     cout << "\n【方法十三】利用图像的输入与输出的方法所用时间为" << 1000.*t[12]/getTickFrequency()/n << "ms" << endl;     
555.     cout << "\n【方法十四】利用操作符重载的方法所用时间为" << 1000.*t[13]/getTickFrequency()/n << "ms" << endl;    
556.       
557.     waitKey();  
558.     return 0;  
559. }  

参考：

http://blog.csdn.net/yang_xian521/article/details/7182185

顶

0

踩