OpenCV4入门教程017：像素读写

索引地址：系列索引

介绍完基本的数据结构和函数之后，我们现在正式进入OpenCV之旅。

访问某一个像素点

第一步是像素操作。一张图片由许多个点组成，每个点就是一个像素，每个像素包含不同的值。如果是一通道，那么每个像素只有一个值，比如0或者255。如果是三通道，每个像素包含三种值，可以通过分离通道的方式获取每个值，最开始我们从一通道黑白值图片为例。

首先，创建一个空白Mat对象，宽为3，高为3，一通道，8位，值类型为unsigned char：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main(){
    Mat a= Mat(3,3,CV_8UC1);
    cout<<a<<endl;

    waitKey(0);

    return 0;
}

执行后输出为：

1
2
3
4
$ ./pixel
[  0,   0,   0;
   0,   0,   0;
   0,   0,   0]

可以看出Mat默认值为0，也就是全黑。

使用at方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main(){
    Mat a= Mat(3,3,CV_8UC1);
    a.at<unsigned char>(1,1)=255;
    cout<<a<<endl;

    cout<<(int)a.at<unsigned char>(1,1)<<endl;

    waitKey();

    return 0;
}

按照参考手册的要求，通过at(1,1)来指定第2行第2列的那个像素，同时指定数值类型为unsigned 强制类型转换出Point(1,1)的数值，因为源类型是uc，我们使用强制类型转换为Int。

编译运行结果为：

1
2
3
4
5
$ ./pixel
[  0,   0,   0;
   0, 255,   0;
   0,   0,   0]
255

ptr方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main(){
    Mat a= Mat(3,3,CV_8UC1);
    int *data = a.ptr<int>(1,1);
    *data=32;
    cout<<a<<endl;

    cout<<*(a.ptr<int>(1,1))<<endl;

    waitKey();

    return 0;
}

ptr是指针，所以需要通过指针的方法来访问像素数值。

编译运行结果：

1
2
3
4
5
$ ./pixel        
[  0,   0,   0;
   0,  32,   0;
   0,   0,   0]
32

访问全部像素

一般我们处理图片是对图片中每一位像素进行处理，有三种方法：at，ptr，迭代器。

at方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main(){
    Mat a= Mat(3,3,CV_8UC1);
    int nRow=a.rows;
    int nCol=a.cols;

    a.at<int>(1,1)=255;
    for(int i=0;i<nCol;i++){
        for(int j=0;j<nRow;j++){
            cout<<a.at<int>(i,j)<<" ";
        }
        cout<<endl;
    }
    waitKey();

    return 0;
}

和二维数组输出类似。

结果如下：

1
2
3
4
$ ./pixel        
0 -16777216 0 
0 255 0 
65280 0 0

结果和我们的值有两个像素值不同。

ptr方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main(){
    Mat a= Mat(3,3,CV_8UC1);
    int nRow=a.rows;
    int nCol=a.cols;

    a.at<uchar>(1,1)=255;
    for(int i=0;i<nCol;i++){
        uchar *data = a.ptr<uchar>(i);//行指针
        for(int j=0;j<nRow;j++){
            cout<<(int)data[j]<<" ";
        }
        cout<<endl;
    }
    waitKey();

    return 0;
}

结果如下：

1
2
3
4
$ ./pixel        
0 0 0 
0 255 0 
0 0 0

此时，值就是我们赋予的。由此可见，uchar和int类型方面也会对数据处理产生一定影响。

迭代器方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main(){
    Mat a= Mat(3,3,CV_8UC1);
    int nRow=a.rows;
    int nCol=a.cols;

    a.at<uchar>(1,1)=255;

    Mat_<int>::iterator it = a.begin<int>();
    Mat_<int>::iterator itend=a.end<int>();

    for(;it!=itend;++it){
        int b=(uchar)*it;
        cout<<b<<" ";
    }
    waitKey();

    return 0;
}

输出结果为：

1
2
$ ./pixel        
0 0 0 0 255 0 0 0 0 %

就是普通的迭代器的用法，如果不了解也没有关系，至今为止我没有实际使用过这种方法。

访问像素的14种方法

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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
//---------------------------------【头文件、命名空间包含部分】-----------------------------
//      描述：包含程序所使用的头文件和命名空间
//-------------------------------------------------------------------------------------------------
#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
using namespace cv;
using namespace std;

//---------------------------------【宏定义部分】---------------------------------------------
//      描述：包含程序所使用宏定义
//-------------------------------------------------------------------------------------------------
#define NTESTS 14
#define NITERATIONS 20

//----------------------------------------- 【方法一】-------------------------------------------
//      说明：利用.ptr 和 []
//-------------------------------------------------------------------------------------------------
void colorReduce0(Mat &image, int div = 64) {
    int nl = image.rows;                    //行数
    int nc = image.cols * image.channels(); //每行元素的总元素数量

    for (int j = 0; j < nl; j++) {
        uchar *data = image.ptr<uchar>(j);

        for (int i = 0; i < nc; i++) {
            //-------------开始处理每个像素-------------------
            data[ i ] = data[ i ] / div * div + div / 2;
            //-------------结束像素处理------------------------
        } //单行处理结束
    }
}

//-----------------------------------【方法二】-------------------------------------------------
//      说明：利用 .ptr 和 * ++
//-------------------------------------------------------------------------------------------------
void colorReduce1(Mat &image, int div = 64) {
    int nl = image.rows;                    //行数
    int nc = image.cols * image.channels(); //每行元素的总元素数量

    for (int j = 0; j < nl; j++) {
        uchar *data = image.ptr<uchar>(j);

        for (int i = 0; i < nc; i++) {
            //-------------开始处理每个像素-------------------
            *data++ = *data / div * div + div / 2;
            //-------------结束像素处理------------------------
        } //单行处理结束
    }
}

//-----------------------------------------【方法三】-------------------------------------------
//      说明：利用.ptr 和 * ++ 以及模操作
//-------------------------------------------------------------------------------------------------
void colorReduce2(Mat &image, int div = 64) {
    int nl = image.rows;                    //行数
    int nc = image.cols * image.channels(); //每行元素的总元素数量

    for (int j = 0; j < nl; j++) {
        uchar *data = image.ptr<uchar>(j);

        for (int i = 0; i < nc; i++) {
            //-------------开始处理每个像素-------------------
            int v   = *data;
            *data++ = v - v % div + div / 2;
            //-------------结束像素处理------------------------
        } //单行处理结束
    }
}

//----------------------------------------【方法四】---------------------------------------------
//      说明：利用.ptr 和 * ++ 以及位操作
//----------------------------------------------------------------------------------------------------
void colorReduce3(Mat &image, int div = 64) {
    int nl = image.rows;                    //行数
    int nc = image.cols * image.channels(); //每行元素的总元素数量
    int n  = static_cast<int>(log(static_cast<double>(div)) / log(2.0));
    //掩码值
    uchar mask = 0xFF << n; // e.g. 对于 div=16, mask= 0xF0

    for (int j = 0; j < nl; j++) {
        uchar *data = image.ptr<uchar>(j);

        for (int i = 0; i < nc; i++) {
            //------------开始处理每个像素-------------------
            *data++ = *data & mask + div / 2;
            //-------------结束像素处理------------------------
        } //单行处理结束
    }
}

//----------------------------------------【方法五】----------------------------------------------
//      说明：利用指针算术运算
//---------------------------------------------------------------------------------------------------
void colorReduce4(Mat &image, int div = 64) {
    int nl   = image.rows;                    //行数
    int nc   = image.cols * image.channels(); //每行元素的总元素数量
    int n    = static_cast<int>(log(static_cast<double>(div)) / log(2.0));
    int step = image.step; //有效宽度
    //掩码值
    uchar mask = 0xFF << n; // e.g. 对于 div=16, mask= 0xF0

    //获取指向图像缓冲区的指针
    uchar *data = image.data;

    for (int j = 0; j < nl; j++) {
        for (int i = 0; i < nc; i++) {
            //-------------开始处理每个像素-------------------
            *(data + i) = *data & mask + div / 2;
            //-------------结束像素处理------------------------
        } //单行处理结束
        data += step; // next line
    }
}

//---------------------------------------【方法六】----------------------------------------------
//      说明：利用 .ptr 和 * ++以及位运算、image.cols * image.channels()
//-------------------------------------------------------------------------------------------------
void colorReduce5(Mat &image, int div = 64) {
    int nl = image.rows; //行数
    int n  = static_cast<int>(log(static_cast<double>(div)) / log(2.0));
    //掩码值
    uchar mask = 0xFF << n; // e.g. 例如div=16, mask= 0xF0

    for (int j = 0; j < nl; j++) {
        uchar *data = image.ptr<uchar>(j);

        for (int i = 0; i < image.cols * image.channels(); i++) {
            //-------------开始处理每个像素-------------------
            *data++ = *data & mask + div / 2;
            //-------------结束像素处理------------------------
        } //单行处理结束
    }
}

// -------------------------------------【方法七】----------------------------------------------
//      说明：利用.ptr 和 * ++ 以及位运算(continuous)
//-------------------------------------------------------------------------------------------------
void colorReduce6(Mat &image, int div = 64) {
    int nl = image.rows;                    //行数
    int nc = image.cols * image.channels(); //每行元素的总元素数量

    if (image.isContinuous()) {
        //无填充像素
        nc = nc * nl;
        nl = 1; // 为一维数列
    }

    int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));
    //掩码值
    uchar mask = 0xFF << n; // e.g. 比如div=16, mask= 0xF0

    for (int j = 0; j < nl; j++) {
        uchar *data = image.ptr<uchar>(j);

        for (int i = 0; i < nc; i++) {
            //-------------开始处理每个像素-------------------
            *data++ = *data & mask + div / 2;
            //-------------结束像素处理------------------------
        } //单行处理结束
    }
}

//------------------------------------【方法八】------------------------------------------------
//      说明：利用 .ptr 和 * ++ 以及位运算 (continuous+channels)
//-------------------------------------------------------------------------------------------------
void colorReduce7(Mat &image, int div = 64) {
    int nl = image.rows; //行数
    int nc = image.cols; //列数

    if (image.isContinuous()) {
        //无填充像素
        nc = nc * nl;
        nl = 1; // 为一维数组
    }

    int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));
    //掩码值
    uchar mask = 0xFF << n; // e.g. 比如div=16, mask= 0xF0

    for (int j = 0; j < nl; j++) {
        uchar *data = image.ptr<uchar>(j);

        for (int i = 0; i < nc; i++) {
            //-------------开始处理每个像素-------------------
            *data++ = *data & mask + div / 2;
            *data++ = *data & mask + div / 2;
            *data++ = *data & mask + div / 2;
            //-------------结束像素处理------------------------
        } //单行处理结束
    }
}

// -----------------------------------【方法九】 ------------------------------------------------
//      说明：利用Mat_ iterator
//-------------------------------------------------------------------------------------------------
void colorReduce8(Mat &image, int div = 64) {
    //获取迭代器
    Mat_<Vec3b>::iterator it    = image.begin<Vec3b>();
    Mat_<Vec3b>::iterator itend = image.end<Vec3b>();

    for (; it != itend; ++it) {
        //-------------开始处理每个像素-------------------
        (*it)[ 0 ] = (*it)[ 0 ] / div * div + div / 2;
        (*it)[ 1 ] = (*it)[ 1 ] / div * div + div / 2;
        (*it)[ 2 ] = (*it)[ 2 ] / div * div + div / 2;
        //-------------结束像素处理------------------------
    } //单行处理结束
}

//-------------------------------------【方法十】-----------------------------------------------
//      说明：利用Mat_ iterator以及位运算
//-------------------------------------------------------------------------------------------------
void colorReduce9(Mat &image, int div = 64) {
    // div必须是2的幂
    int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));
    //掩码值
    uchar mask = 0xFF << n; // e.g. 比如 div=16, mask= 0xF0

    // 获取迭代器
    Mat_<Vec3b>::iterator it    = image.begin<Vec3b>();
    Mat_<Vec3b>::iterator itend = image.end<Vec3b>();

    //扫描所有元素
    for (; it != itend; ++it) {
        //-------------开始处理每个像素-------------------
        (*it)[ 0 ] = (*it)[ 0 ] & mask + div / 2;
        (*it)[ 1 ] = (*it)[ 1 ] & mask + div / 2;
        (*it)[ 2 ] = (*it)[ 2 ] & mask + div / 2;
        //-------------结束像素处理------------------------
    } //单行处理结束
}

//------------------------------------【方法十一】---------------------------------------------
//      说明：利用Mat Iterator_
//-------------------------------------------------------------------------------------------------
void colorReduce10(Mat &image, int div = 64) {
    //获取迭代器
    Mat_<Vec3b>           cimage = image;
    Mat_<Vec3b>::iterator it     = cimage.begin();
    Mat_<Vec3b>::iterator itend  = cimage.end();

    for (; it != itend; it++) {
        //-------------开始处理每个像素-------------------
        (*it)[ 0 ] = (*it)[ 0 ] / div * div + div / 2;
        (*it)[ 1 ] = (*it)[ 1 ] / div * div + div / 2;
        (*it)[ 2 ] = (*it)[ 2 ] / div * div + div / 2;
        //-------------结束像素处理------------------------
    }
}

//--------------------------------------【方法十二】--------------------------------------------
//      说明：利用动态地址计算配合at
//-------------------------------------------------------------------------------------------------
void colorReduce11(Mat &image, int div = 64) {
    int nl = image.rows; //行数
    int nc = image.cols; //列数

    for (int j = 0; j < nl; j++) {
        for (int i = 0; i < nc; i++) {
            //-------------开始处理每个像素-------------------
            image.at<Vec3b>(j, i)[ 0 ] = image.at<Vec3b>(j, i)[ 0 ] / div * div + div / 2;
            image.at<Vec3b>(j, i)[ 1 ] = image.at<Vec3b>(j, i)[ 1 ] / div * div + div / 2;
            image.at<Vec3b>(j, i)[ 2 ] = image.at<Vec3b>(j, i)[ 2 ] / div * div + div / 2;
            //-------------结束像素处理------------------------
        } //单行处理结束
    }
}

//----------------------------------【方法十三】-----------------------------------------------
//      说明：利用图像的输入与输出
//-------------------------------------------------------------------------------------------------
void colorReduce12(const Mat &image,  //输入图像
                   Mat &      result, // 输出图像
                   int        div = 64) {

    int nl = image.rows; //行数
    int nc = image.cols; //列数

    //准备好初始化后的Mat给输出图像
    result.create(image.rows, image.cols, image.type());

    //创建无像素填充的图像
    nc = nc * nl;
    nl = 1; //单维数组

    int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));
    //掩码值
    uchar mask = 0xFF << n; // e.g.比如div=16, mask= 0xF0

    for (int j = 0; j < nl; j++) {
        uchar *      data  = result.ptr<uchar>(j);
        const uchar *idata = image.ptr<uchar>(j);

        for (int i = 0; i < nc; i++) {
            //-------------开始处理每个像素-------------------
            *data++ = (*idata++) & mask + div / 2;
            *data++ = (*idata++) & mask + div / 2;
            *data++ = (*idata++) & mask + div / 2;
            //-------------结束像素处理------------------------
        } //单行处理结束
    }
}

//--------------------------------------【方法十四】-------------------------------------------
//      说明：利用操作符重载
//-------------------------------------------------------------------------------------------------
void colorReduce13(Mat &image, int div = 64) {
    int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));
    //掩码值
    uchar mask = 0xFF << n; // e.g. 比如div=16, mask= 0xF0

    //进行色彩还原
    image = (image & Scalar(mask, mask, mask)) + Scalar(div / 2, div / 2, div / 2);
}

//-----------------------------------【main( )函数】--------------------------------------------
//      描述：控制台应用程序的入口函数，我们的程序从这里开始
//-------------------------------------------------------------------------------------------------
int main() {
    int64 t[ NTESTS ], tinit;
    Mat   image0;
    Mat   image1;
    Mat   image2;

    image0 = imread("1.png");
    if (!image0.data)
        return 0;

    //时间值设为0
    for (int i = 0; i < NTESTS; i++)
        t[ i ] = 0;

    // 多次重复测试
    int n = NITERATIONS;
    for (int k = 0; k < n; k++) {
        cout << k << " of " << n << endl;

        image1 = imread("1.png");
        //【方法一】利用.ptr 和 []
        tinit = getTickCount();
        colorReduce0(image1);
        t[ 0 ] += getTickCount() - tinit;

        //【方法二】利用 .ptr 和 * ++
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce1(image1);
        t[ 1 ] += getTickCount() - tinit;

        //【方法三】利用.ptr 和 * ++ 以及模操作
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce2(image1);
        t[ 2 ] += getTickCount() - tinit;

        //【方法四】 利用.ptr 和 * ++ 以及位操作
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce3(image1);
        t[ 3 ] += getTickCount() - tinit;

        //【方法五】 利用指针的算术运算
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce4(image1);
        t[ 4 ] += getTickCount() - tinit;

        //【方法六】利用 .ptr 和 * ++以及位运算、image.cols * image.channels()
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce5(image1);
        t[ 5 ] += getTickCount() - tinit;

        //【方法七】利用.ptr 和 * ++ 以及位运算(continuous)
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce6(image1);
        t[ 6 ] += getTickCount() - tinit;

        //【方法八】利用 .ptr 和 * ++ 以及位运算 (continuous+channels)
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce7(image1);
        t[ 7 ] += getTickCount() - tinit;

        //【方法九】 利用Mat_ iterator
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce8(image1);
        t[ 8 ] += getTickCount() - tinit;

        //【方法十】 利用Mat_ iterator以及位运算
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce9(image1);
        t[ 9 ] += getTickCount() - tinit;

        //【方法十一】利用Mat Iterator_
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce10(image1);
        t[ 10 ] += getTickCount() - tinit;

        //【方法十二】 利用动态地址计算配合at
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce11(image1);
        t[ 11 ] += getTickCount() - tinit;

        //【方法十三】 利用图像的输入与输出
        image1 = imread("1.png");
        tinit  = getTickCount();
        Mat result;
        colorReduce12(image1, result);
        t[ 12 ] += getTickCount() - tinit;
        image2 = result;

        //【方法十四】 利用操作符重载
        image1 = imread("1.png");
        tinit  = getTickCount();
        colorReduce13(image1);
        t[ 13 ] += getTickCount() - tinit;

        //------------------------------
    }
    //输出图像
    imshow("原始图像", image0);
    imshow("结果", image2);
    imshow("图像结果", image1);

    // 输出平均执行时间
    cout << endl << "-------------------------------------------" << endl << endl;
    cout << "\n【方法一】利用.ptr 和 []的方法所用时间为 " << 1000. * t[ 0 ] / getTickFrequency() / n
         << "ms" << endl;
    cout << "\n【方法二】利用 .ptr 和 * ++ 的方法所用时间为"
         << 1000. * t[ 1 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法三】利用.ptr 和 * ++ 以及模操作的方法所用时间为"
         << 1000. * t[ 2 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法四】利用.ptr 和 * ++ 以及位操作的方法所用时间为"
         << 1000. * t[ 3 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法五】利用指针算术运算的方法所用时间为"
         << 1000. * t[ 4 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法六】利用 .ptr 和 * ++以及位运算、channels()的方法所用时间为"
         << 1000. * t[ 5 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法七】利用.ptr 和 * ++ 以及位运算(continuous)的方法所用时间为"
         << 1000. * t[ 6 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法八】利用 .ptr 和 * ++ 以及位运算 (continuous+channels)的方法所用时间为"
         << 1000. * t[ 7 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法九】利用Mat_ iterator 的方法所用时间为"
         << 1000. * t[ 8 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法十】利用Mat_ iterator以及位运算的方法所用时间为"
         << 1000. * t[ 9 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法十一】利用Mat Iterator_的方法所用时间为"
         << 1000. * t[ 10 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法十二】利用动态地址计算配合at 的方法所用时间为"
         << 1000. * t[ 11 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法十三】利用图像的输入与输出的方法所用时间为"
         << 1000. * t[ 12 ] / getTickFrequency() / n << "ms" << endl;
    cout << "\n【方法十四】利用操作符重载的方法所用时间为"
         << 1000. * t[ 13 ] / getTickFrequency() / n << "ms" << endl;

    waitKey();
    return 0;
}

总结

方法有很多，只需要使用喜欢的或者熟悉的一种。就算你知道茴字有十一种写法，实际只需要会一种就可以了。

数据运算时，应该保持数据类型的一致。如果是UC，那么后面的所有运算都是UC，需要时进行类型转换。

OpenCV
#OpenCV #像素
OpenCV4入门教程017：像素读写
https://blog.jackeylea.com/opencv/opencv-pixel-read-write/
作者
JackeyLea
发布于
2020年6月6日
许可协议