【OpenCV】访问Mat中每个像素的值

我不是女神ヾ 2022-08-23 04:50 171阅读 0赞

原文地址：http://blog.csdn.net/xiaowei\_cqu/article/details/19839019

目录[(?)][Link 1][\[-\]][Link 1]

1.  [Color Reduce][]
2.  [方法零ptr和操作符][ptr]
3.  [方法一ptr和指针操作][ptr 1]
4.  [方法二ptr指针操作和取模运算][ptr 2]
5.  [方法三ptr指针运算和位运算][ptr 3]
6.  [方法四指针运算][Link 2]
7.  [方法五ptr位运算以及imagecols imagechannels][ptr_imagecols imagechannels]
8.  [方法六连续图像][Link 3]
9.  [方法七continuouschannels][continuouschannels]
10. [方法八Mat \_iterator][Mat _iterator]
11. [方法九Mat\_ iterator 和位运算][Mat_ iterator]
12. [方法十MatIterator\_][MatIterator]
13. [方法十一图像坐标][Link 4]
14. [方法十二创建输出图像][Link 5]
15. [方法十三重载操作符][Link 6]
16. [时间对比][Link 7]
    
    1.  [转载请注明作者和出处httpblogcsdnnetxiaowei\_cqu 未经允许请勿用于商业用途][httpblogcsdnnetxiaowei_cqu]

在《OpenCV 2 Computer Vision Application Programming Cookbook》看到的例子，非常不错，算是对之前的文章[<访问Mat图像中每个像素的值>][Mat]的回顾和补充。

## Color Reduce ##

还是使用经典的Reduce Color的例子，即对图像中的像素表达进行量化。如常见的RGB24图像有256×256×256中颜色，通过Reduce Color将每个通道的像素减少8倍至256/8=32种，则图像只有32×32×32种颜色。假设量化减少的倍数是N，则代码实现时就是简单的value/N\*N，通常我们会再加上N/2以得到相邻的N的倍数的中间值，最后图像被量化为(256/N)×(256/N)×(256/N)种颜色。

![Center][]

## 方法零：.ptr和\[\]操作符 ##

Mat最直接的访问方法是通过.ptr<>函数得到一行的指针，并用\[\]操作符访问某一列的像素值。

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using .ptr and \[\]
2.  **void** colorReduce0(cv::Mat &image, **int** div=64) \{ 
3.  **int** nr= image.rows; // number of rows
4.  **int** nc= image.cols \* image.channels(); // total number of elements per line
5.  **for** (**int** j=0; j<nr; j++) \{ 
6.   uchar\* data= image.ptr<uchar>(j); 
7.  **for** (**int** i=0; i<nc; i++) \{ 
8.   data\[i\]= data\[i\]/div\*div + div/2; 
9.   \} 
10.  \} 
11. \}

##    方法一：.ptr和指针操作 ##

除了\[\]操作符，我们可以移动指针\*++的组合方法访问某一行中所有像素的值。

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using .ptr and \* ++ 
2.  **void** colorReduce1(cv::Mat &image, **int** div=64) \{ 
3.  **int** nr= image.rows; // number of rows
4.  **int** nc= image.cols \* image.channels(); // total number of elements per line
5.  **for** (**int** j=0; j<nr; j++) \{ 
6.   uchar\* data= image.ptr<uchar>(j); 
7.  **for** (**int** i=0; i<nc; i++) \{ 
8.   \*data++= \*data/div\*div + div/2; 
9.   \} // end of row 
10.  \} 
11. \}

##    方法二：.ptr、指针操作和取模运算 ##

方法二和方法一的访问方式相同，不同的是color reduce用模运算代替整数除法

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using .ptr and \* ++ and modulo
2.  **void** colorReduce2(cv::Mat &image, **int** div=64) \{ 
3.  **int** nr= image.rows; // number of rows
4.  **int** nc= image.cols \* image.channels(); // total number of elements per line
5.  **for** (**int** j=0; j<nr; j++) \{ 
6.   uchar\* data= image.ptr<uchar>(j); 
7.  **for** (**int** i=0; i<nc; i++) \{ 
8.  **int** v= \*data; 
9.   \*data++= v - v%div + div/2; 
10.  \} // end of row 
11.  \} 
12. \}

##    方法三：.ptr、指针运算和位运算 ##

由于进行量化的单元div通常是2的整次方，因此所有的乘法和除法都可以用位运算表示。

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using .ptr and \* ++ and bitwise
2.  **void** colorReduce3(cv::Mat &image, **int** div=64) \{ 
3.  **int** nr= image.rows; // number of rows
4.  **int** nc= image.cols \* image.channels(); // total number of elements per line
5.  **int** n= **static\_cast**<**int**>(log(**static\_cast**<**double**>(div))/log(2.0)); 
6.  // mask used to round the pixel value
7.   uchar mask= 0xFF<<n; // e.g. for div=16, mask= 0xF0
8.  **for** (**int** j=0; j<nr; j++) \{ 
9.   uchar\* data= image.ptr<uchar>(j); 
10. **for** (**int** i=0; i<nc; i++) \{ 
11.  \*data++= \*data&mask + div/2; 
12.  \} // end of row 
13.  \} 
14. \}

##    方法四：指针运算 ##

方法四和方法三量化处理的方法相同，不同的是用指针运算代替\*++操作。

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // direct pointer arithmetic
2.  **void** colorReduce4(cv::Mat &image, **int** div=64) \{ 
3.  **int** nr= image.rows; // number of rows
4.  **int** nc= image.cols \* image.channels(); // total number of elements per line
5.  **int** n= **static\_cast**<**int**>(log(**static\_cast**<**double**>(div))/log(2.0)); 
6.  **int** step= image.step; // effective width
7.  // mask used to round the pixel value
8.   uchar mask= 0xFF<<n; // e.g. for div=16, mask= 0xF0
9.  // get the pointer to the image buffer
10.  uchar \*data= image.data; 
11. **for** (**int** j=0; j<nr; j++) \{ 
12. **for** (**int** i=0; i<nc; i++) \{ 
13.  \*(data+i)= \*data&mask + div/2; 
14.  \} // end of row 
15.  data+= step; // next line
16.  \} 
17. \}

##    方法五：.ptr、\*++、位运算以及image.cols \* image.channels() ##

这种方法就是没有计算nc，基本是个充数的方法。

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using .ptr and \* ++ and bitwise with image.cols \* image.channels()
2.  **void** colorReduce5(cv::Mat &image, **int** div=64) \{ 
3.  **int** nr= image.rows; // number of rows
4.  **int** n= **static\_cast**<**int**>(log(**static\_cast**<**double**>(div))/log(2.0)); 
5.  // mask used to round the pixel value
6.   uchar mask= 0xFF<<n; // e.g. for div=16, mask= 0xF0
7.  **for** (**int** j=0; j<nr; j++) \{ 
8.   uchar\* data= image.ptr<uchar>(j); 
9.  **for** (**int** i=0; i<image.cols \* image.channels(); i++) \{ 
10.  \*data++= \*data&mask + div/2; 
11.  \} // end of row 
12.  \} 
13. \}

## 方法六：连续图像 ##

Mat提供了isContinuous()函数用来查看Mat在内存中是不是连续存储，如果是则图片被存储在一行中。

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using .ptr and \* ++ and bitwise (continuous)
2.  **void** colorReduce6(cv::Mat &image, **int** div=64) \{ 
3.  **int** nr= image.rows; // number of rows
4.  **int** nc= image.cols \* image.channels(); // total number of elements per line
5.  **if** (image.isContinuous()) \{ 
6.  // then no padded pixels
7.   nc= nc\*nr; 
8.   nr= 1; // it is now a 1D array
9.   \} 
10. **int** n= **static\_cast**<**int**>(log(**static\_cast**<**double**>(div))/log(2.0)); 
11. // mask used to round the pixel value
12.  uchar mask= 0xFF<<n; // e.g. for div=16, mask= 0xF0
13. **for** (**int** j=0; j<nr; j++) \{ 
14.  uchar\* data= image.ptr<uchar>(j); 
15. **for** (**int** i=0; i<nc; i++) \{ 
16.  \*data++= \*data&mask + div/2; 
17.  \} // end of row 
18.  \} 
19. \}

##    方法七：continuous+channels ##

与方法六基本相同，也是充数的。

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using .ptr and \* ++ and bitwise (continuous+channels)
2.  **void** colorReduce7(cv::Mat &image, **int** div=64) \{ 
3.  **int** nr= image.rows; // number of rows
4.  **int** nc= image.cols ; // number of columns
5.  **if** (image.isContinuous()) \{ 
6.  // then no padded pixels
7.   nc= nc\*nr; 
8.   nr= 1; // it is now a 1D array
9.   \} 
10. **int** n= **static\_cast**<**int**>(log(**static\_cast**<**double**>(div))/log(2.0)); 
11. // mask used to round the pixel value
12.  uchar mask= 0xFF<<n; // e.g. for div=16, mask= 0xF0
13. **for** (**int** j=0; j<nr; j++) \{ 
14.  uchar\* data= image.ptr<uchar>(j); 
15. **for** (**int** i=0; i<nc; i++) \{ 
16.  \*data++= \*data&mask + div/2; 
17.  \*data++= \*data&mask + div/2; 
18.  \*data++= \*data&mask + div/2; 
19.  \} // end of row 
20.  \} 
21. \}

##    方法八：Mat \_iterator ##

真正有区别的方法来啦，用Mat提供的迭代器代替前面的\[\]操作符或指针，血统纯正的官方方法~

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using Mat\_ iterator 
2.  **void** colorReduce8(cv::Mat &image, **int** div=64) \{ 
3.  // get iterators
4.   cv::Mat\_<cv::Vec3b>::iterator it= image.begin<cv::Vec3b>(); 
5.   cv::Mat\_<cv::Vec3b>::iterator itend= image.end<cv::Vec3b>(); 
6.  **for** ( ; it!= itend; ++it) \{ 
7.   (\*it)\[0\]= (\*it)\[0\]/div\*div + div/2; 
8.   (\*it)\[1\]= (\*it)\[1\]/div\*div + div/2; 
9.   (\*it)\[2\]= (\*it)\[2\]/div\*div + div/2; 
10.  \} 
11. \}

## 方法九：Mat\_ iterator 和位运算 ##

把方法八中的乘除法换成位运算。

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using Mat\_ iterator and bitwise
2.  **void** colorReduce9(cv::Mat &image, **int** div=64) \{ 
3.  // div must be a power of 2
4.  **int** n= **static\_cast**<**int**>(log(**static\_cast**<**double**>(div))/log(2.0)); 
5.  // mask used to round the pixel value
6.   uchar mask= 0xFF<<n; // e.g. for div=16, mask= 0xF0
7.  // get iterators
8.   cv::Mat\_<cv::Vec3b>::iterator it= image.begin<cv::Vec3b>(); 
9.   cv::Mat\_<cv::Vec3b>::iterator itend= image.end<cv::Vec3b>(); 
10. **for** ( ; it!= itend; ++it) \{ 
11.  (\*it)\[0\]= (\*it)\[0\]&mask + div/2; 
12.  (\*it)\[1\]= (\*it)\[1\]&mask + div/2; 
13.  (\*it)\[2\]= (\*it)\[2\]&mask + div/2; 
14.  \} 
15. \}

##    方法十：MatIterator\_ ##

和方法八基本相同。

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using MatIterator\_ 
2.  **void** colorReduce10(cv::Mat &image, **int** div=64) \{ 
3.   cv::Mat\_<cv::Vec3b> cimage= image; 
4.   cv::Mat\_<cv::Vec3b>::iterator it=cimage.begin(); 
5.   cv::Mat\_<cv::Vec3b>::iterator itend=cimage.end(); 
6.  **for** ( ; it!= itend; it++) \{ 
7.   (\*it)\[0\]= (\*it)\[0\]/div\*div + div/2; 
8.   (\*it)\[1\]= (\*it)\[1\]/div\*div + div/2; 
9.   (\*it)\[2\]= (\*it)\[2\]/div\*div + div/2; 
10.  \} 
11. \}

## 方法十一：图像坐标 ##

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using (j,i)
2.  **void** colorReduce11(cv::Mat &image, **int** div=64) \{ 
3.  **int** nr= image.rows; // number of rows
4.  **int** nc= image.cols; // number of columns
5.  **for** (**int** j=0; j<nr; j++) \{ 
6.  **for** (**int** i=0; i<nc; i++) \{ 
7.   image.at<cv::Vec3b>(j,i)\[0\]= image.at<cv::Vec3b>(j,i)\[0\]/div\*div + div/2; 
8.   image.at<cv::Vec3b>(j,i)\[1\]= image.at<cv::Vec3b>(j,i)\[1\]/div\*div + div/2; 
9.   image.at<cv::Vec3b>(j,i)\[2\]= image.at<cv::Vec3b>(j,i)\[2\]/div\*div + div/2; 
10.  \} // end of row 
11.  \} 
12. \}

##    方法十二：创建输出图像 ##

之前的方法都是直接修改原图，方法十二新建了输出图像，主要用于后面的时间对比。

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // with input/ouput images
2.  **void** colorReduce12(**const** cv::Mat &image, // input image 
3.   cv::Mat &result, // output image
4.  **int** div=64) \{ 
5.  **int** nr= image.rows; // number of rows
6.  **int** nc= image.cols ; // number of columns
7.  // allocate output image if necessary
8.   result.create(image.rows,image.cols,image.type()); 
9.  // created images have no padded pixels
10.  nc= nc\*nr; 
11.  nr= 1; // it is now a 1D array
12. **int** n= **static\_cast**<**int**>(log(**static\_cast**<**double**>(div))/log(2.0)); 
13. // mask used to round the pixel value
14.  uchar mask= 0xFF<<n; // e.g. for div=16, mask= 0xF0
15. **for** (**int** j=0; j<nr; j++) \{ 
16.  uchar\* data= result.ptr<uchar>(j); 
17. **const** uchar\* idata= image.ptr<uchar>(j); 
18. **for** (**int** i=0; i<nc; i++) \{ 
19.  \*data++= (\*idata++)&mask + div/2; 
20.  \*data++= (\*idata++)&mask + div/2; 
21.  \*data++= (\*idata++)&mask + div/2; 
22.  \} // end of row 
23.  \} 
24. \}

##    方法十三：重载操作符 ##

Mat重载了+&等操作符，可以直接将两个Scalar(B,G,R)数据进行位运算和数学运算。

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  // using overloaded operators
2.  **void** colorReduce13(cv::Mat &image, **int** div=64) \{ 
3.  **int** n= **static\_cast**<**int**>(log(**static\_cast**<**double**>(div))/log(2.0)); 
4.  // mask used to round the pixel value
5.   uchar mask= 0xFF<<n; // e.g. for div=16, mask= 0xF0
6.  // perform color reduction
7.   image=(image&cv::Scalar(mask,mask,mask))+cv::Scalar(div/2,div/2,div/2); 
8.  \}

##    时间对比 ##

通过迭代二十次取平均时间，得到每种方法是运算时间如下。

![20140224205651703][]

可以看到，指针\*++访问和位运算是最快的方法；而不断的计算image.cols\*image.channles()花费了大量重复的时间；另外迭代器访问虽然安全，但性能远低于指针运算；通过图像坐标(j,i)访问时最慢的，使用重载操作符直接运算效率最高。

[Link 1]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#
[Color Reduce]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t0
[ptr]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t1
[ptr 1]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t2
[ptr 2]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t3
[ptr 3]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t4
[Link 2]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t5
[ptr_imagecols imagechannels]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t6
[Link 3]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t7
[continuouschannels]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t8
[Mat _iterator]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t9
[Mat_ iterator]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t10
[MatIterator]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t11
[Link 4]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t12
[Link 5]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t13
[Link 6]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t14
[Link 7]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t15
[httpblogcsdnnetxiaowei_cqu]: http://blog.csdn.net/xiaowei_cqu/article/details/19839019#t16
[Mat]: http://blog.csdn.net/xiaowei_cqu/article/details/7771760
[Center]: /images/20220722/9d23b2a631db46ca97e58d10752cf19a.png
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/202820
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/202820/fork
[20140224205651703]: /images/20220722/9dc3468e322e4f1b849e54473b5b97d7.png

发表评论取消回复

表情：

评论列表（有 0 条评论，171人围观）

还没有评论，来说两句吧...

相关阅读

相关 OPencv java Mat 基本操作像素点（7）

前面我们说到了用Mat类进行行列式的计算，可能在OPenCv中不算太实用，那么今天我们介绍一个比较使用的，图片中的像素点我们知道OpenCv当我们read一个图片的时候，返

约定不等于承诺〃/ 2022年12月02日 15:02/ 0 赞/ 198 阅读

相关【笔记】opencv的python实现·像素处理像素访问 alpha通道

像素概念计算机在处理某个图像时，会首先将其划分为一个个小方块，每个小方块是一个独立的处理单位，成为像素点记录一些基础语法: ，X\[:,0\]就是取矩阵X的所有

淩亂°似流年/ 2022年11月02日 00:56/ 0 赞/ 260 阅读

相关【OpenCV】访问Mat中每个像素的值（新）

在《OpenCV 2 Computer Vision Application Programming Cookbook》看到的例子，非常不错，算是对之前的文章[<访问Mat图像

桃扇骨/ 2022年08月25日 08:42/ 0 赞/ 160 阅读

相关【OpenCV】访问Mat中每个像素的值

原文地址：http://blog.csdn.net/xiaowei\_cqu/article/details/19839019 目录[(?)][Link 1][\[-\]][

我不是女神ヾ/ 2022年08月23日 04:50/ 0 赞/ 172 阅读

相关访问Mat图像中每个像素的值

转载自：[http://blog.csdn.net/xiaowei\_cqu/article/details/7771760][http_blog.csdn.net_xiao

你的名字/ 2022年08月10日 11:49/ 0 赞/ 152 阅读

相关 Opencv学习笔记2--像素的访问

`include "opencv2\opencv.hpp"`\include iostream`![成员函数at用来读取像素，image.at<Vec3b>(i,j)[chan

旧城等待，/ 2022年06月17日 02:54/ 0 赞/ 154 阅读

相关 opencv访问（Mat）图像的像素方法汇总

20200521 新增： // 定义宏 define CV_MAT_ELEM2(src,dtype,y,x) (dtype)(src.data+sr

你的名字/ 2022年06月11日 09:17/ 0 赞/ 256 阅读

相关 IplImage访问图像像素值

opencv2.1版本之前使用IplImage\数据结构来表示图像，2.1之后的版本使用图像容器Mat来存储。IplImage结构体如下所示。 ![复制代码][copycod

水深无声/ 2022年05月30日 04:18/ 0 赞/ 266 阅读

相关 OpenCV的Mat操作像素点

Mat数据结构，操作灰度图像像素点： int gray\_value = (int) image.at<uchar>(i , j) ; 操作彩色图像像素点： int

ゝ一纸荒年。/ 2022年05月24日 12:20/ 0 赞/ 240 阅读

相关【OpenCV】OpenCV访问像素点的三种方式

环境配置 VS2013+OpenCV3.0+Win7（X64）前言 OpenCV是图像处理最常用的库之一。它提供了许多常用的图像处理算法相关

男娘i/ 2022年05月19日 02:48/ 0 赞/ 489 阅读