获取图像像素方法汇总

待我称王封你为后i 2022-06-17 01:44 1012阅读 0赞

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

# 1、指针操作 #

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

**\[html\]**  [view plain][]   [copy][view plain]

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][view plain]

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][view plain]

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][view plain]

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][view plain]

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][view plain 1]  [copy][view plain 1]

1.  cv::MatIterator\_<Vec3b> it;

或者是：

**\[cpp\]**  [view plain][view plain 1]  [copy][view plain 1]

1.  cv::Mat\_<Vec3b>::iterator it;

扫描图像的方法如下：

**\[html\]**  [view plain][]   [copy][view plain]

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][view plain 1]  [copy][view plain 1]

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][view plain]

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

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

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

**\[cpp\]**  [view plain][view plain 1]  [copy][view plain 1]

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][view plain]

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

顶

踩

[view plain]: http://blog.csdn.net/qq_37871032/article/details/70037921#
[view plain 1]: http://blog.csdn.net/yang_xian521/article/details/7182185#