opencv之访问图像像素的 三种方法

最新推荐文章于 2023-05-08 14:46:41 发布
最新推荐文章于 2023-05-08 14:46:41 发布
阅读量1k 收藏 4
点赞数
分类专栏： 图像处理和计算机视觉 文章标签： opencv 遍历 指针

opencv之访问图像像素

访问像素的三种方法

①指针访问：最快

②迭代器iterator：较慢，非常安全，指针访问可能出现越界问题

③动态地址计算：更慢，通过at()实现。适用于访问具体某个第i行，j列的像素，而不适用遍历像素

 

Mat在内存中存储形式

　　灰度图的存储形式

　　　　

 

　　RGB的存储形式

　　

一般情况下，Mat是连续存储的，按行连接。可以通过isContinuous()函数，判断矩阵是否连续存储，若连续返回true。

 

访问像素的三种方法

1.指针访问

void VisitImgByPointer(Mat &inputImg, Mat &dstImg)
{
    dstImg = inputImg.clone();
    int rows = dstImg.rows;
    int cols = dstImg.cols * dstImg.channels();

    for(int i = 0; i < rows; i++)
    {
        uchar* data = dstImg.ptr<uchar>(i);
        for(int j = 0; j < cols; j++)
        {
            data[j] = 0;  //处理每一个像素
            //add code
        }
    } 
}

当Mat按行连续存储时，可以用指针直接访问所有数据。 

void VisitContinueImgByPointer(Mat &inputImg, Mat &dstImg)
{
    dstImg = inputImg.clone();
    int rows = dstImg.rows;
    int cols = dstImg.cols;
    int channels = dstImg.channels();

    if(dstImg.isContinuous())
    {
        cols *= rows;
        rows = 1;
        //cout << "is continuous " << endl;
    }

    for(int i = 0; i < rows; i++)
    {
        uchar* data = dstImg.ptr<uchar>(i);
        for(int j = 0; j < cols * channels; j++)
        {
            data[j] = 155;  //处理每一个像素
            //add code
        }
    } 
    //若存储连续，等效于以下代码
    //uchar* data = dstImg.data;
    //for(int i = 0; i < cols * rows * channels; i++)
    //    data[i] = 155;    //处理每一个像素

}
2.迭代器访问 

void VisitImgByIterator(Mat &inputImg, Mat &dstImg)
{
    dstImg = inputImg.clone();
    const int channels = dstImg.channels();
  
    switch(channels)
    {
    case 1:
        {
            Mat_<uchar>::iterator it= dstImg.begin<uchar>();
            Mat_<uchar>::iterator itend= dstImg.end<uchar>();
            for ( ; it!= itend; it++) //处理每一个像素
            {
                *it = 150;
            }
            break;
        }
    case 3:
        {
            Mat_<Vec3b>::iterator it3= dstImg.begin<Vec3b>();
            Mat_<Vec3b>::iterator itend3= dstImg.end<Vec3b>();
            for ( ; it3!= itend3; it3++) //处理每一个像素
            { 
                (*it3)[0]= 255;
                (*it3)[1]= 0;
                (*it3)[2]= 0;
            }
            break;
        }
    }
}

3.动态地址访问 

void VisitImgByAt(Mat &inputImg, Mat &dstImg)
{
    dstImg = inputImg.clone();
    int rows = dstImg.rows;
    int cols = dstImg.cols;
    int channels = dstImg.channels();

    switch(channels)
    {
    case 1:
        {
            for(int i = 0; i < rows; i++)
                for(int j = 0; j < cols; j++)
                    dstImg.at<uchar>(i,j) = 150;
            break;
        }
    case 3:
        {
            for(int i = 0; i < rows; i++)
                for(int j = 0; j < cols; j++)
                {
                    dstImg.at<Vec3b>(i,j)[0] =  0;
                    dstImg.at<Vec3b>(i,j)[1] =  0;
                    dstImg.at<Vec3b>(i,j)[2] = 255;
                }
            break;
        }
    }
}

4. 测试代码 

#include <iostream>
#include <opencv2/opencv.hpp>  
using namespace cv;
using namespace std;


void VisitImgByPointer(Mat &inputImg, Mat &dstImg);
void VisitContinueImgByPointer(Mat &inputImg, Mat &dstImg);
void VisitImgByIterator(Mat &inputImg, Mat &dstImg);
void VisitImgByAt(Mat &inputImg, Mat &dstImg);


int main()
{
    Mat srcImg = imread("pig.png"), dstImg;
    Mat grayImg;
    cvtColor(srcImg, grayImg, CV_BGR2GRAY);
    //VisitImgByPointer(srcImg,dstImg);
    //VisitContinueImgByPointer(grayImg,dstImg);
    
    //VisitImgByIterator(srcImg,dstImg);
    //VisitImgByIterator(grayImg,dstImg);
    
    //VisitImgByAt(srcImg,dstImg);
    VisitImgByAt(grayImg,dstImg);


    //imshow("原始图", srcImg);
    //imshow("灰度图", grayImg);
    imshow("生成图", dstImg);


    waitKey(0);
    return 0;
}


void VisitImgByPointer(Mat &inputImg, Mat &dstImg)
{
    dstImg = inputImg.clone();
    int rows = dstImg.rows;
    int cols = dstImg.cols * dstImg.channels();


    for(int i = 0; i < rows; i++)
    {
        uchar* data = dstImg.ptr<uchar>(i);
        for(int j = 0; j < cols; j++)
        {
            data[j] = 0;  //处理每一个像素
            //add code
        }
    } 
}


void VisitContinueImgByPointer(Mat &inputImg, Mat &dstImg)
{
    dstImg = inputImg.clone();
    int rows = dstImg.rows;
    int cols = dstImg.cols;
    int channels = dstImg.channels();


    if(dstImg.isContinuous())
    {
        cols *= rows;
        rows = 1;
        //cout << "is continuous " << endl;
    }


    for(int i = 0; i < rows; i++)
    {
        uchar* data = dstImg.ptr<uchar>(i);
        for(int j = 0; j < cols * channels; j++)
        {
            data[j] = 155;  //处理每一个像素
            //add code
        }
    } 
    //若存储连续，等效于一下代码
    //uchar* data = dstImg.data;
    //for(int i = 0; i < cols * rows * channels; i++)
    //    data[i] = 155;    //处理每一个像素


}




void VisitImgByIterator(Mat &inputImg, Mat &dstImg)
{
    dstImg = inputImg.clone();
    const int channels = dstImg.channels();
  
    switch(channels)
    {
    case 1:
        {
            Mat_<uchar>::iterator it= dstImg.begin<uchar>();
            Mat_<uchar>::iterator itend= dstImg.end<uchar>();
            for ( ; it!= itend; it++) //处理每一个像素
            {
                *it = 150;
            }
            break;
        }
    case 3:
        {
            Mat_<Vec3b>::iterator it3= dstImg.begin<Vec3b>();
            Mat_<Vec3b>::iterator itend3= dstImg.end<Vec3b>();
            for ( ; it3!= itend3; it3++) //处理每一个像素
            { 
                (*it3)[0]= 255;
                (*it3)[1]= 0;
                (*it3)[2]= 0;
            }
            break;
        }
    }
}


void VisitImgByAt(Mat &inputImg, Mat &dstImg)
{
    dstImg = inputImg.clone();
    int rows = dstImg.rows;
    int cols = dstImg.cols;
    int channels = dstImg.channels();


    switch(channels)
    {
    case 1:
        {
            for(int i = 0; i < rows; i++)
                for(int j = 0; j < cols; j++)
                    dstImg.at<uchar>(i,j) = 150;
            break;
        }
    case 3:
        {
            for(int i = 0; i < rows; i++)
                for(int j = 0; j < cols; j++)
                {
                    dstImg.at<Vec3b>(i,j)[0] =  0;
                    dstImg.at<Vec3b>(i,j)[1] =  0;
                    dstImg.at<Vec3b>(i,j)[2] = 255;
                }
            break;
        }
    }
}

原文链接：http://www.cnblogs.com/kuotian/p/6389260.html?utm_source=itdadao&utm_medium=referral

baolinq
关注
专栏目录
OpenCV访问图片像素的三种方法
Qt学视觉
01-13 673
OpenCV访问图片像素的高效方法
【OpenCV C++】访问图像中像素的三种方法
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
03-09 1274
Opencv C++ 访问图像中像素的三种方法程序说明方法一 用指针访问像素运行效果方法二 用迭代器访问像素运行效果方法二 用动态地址计算配合at访问像素运行效果总结 程序说明 // 程序描述：OpenCV C++访问图像中像素的三种方法 // 参 考：毛星云《OpenCV3编程入门》 // 操作系统： Windows 10 64bit // 开发语言： C++ // IDE 版 本：Visual Studio 2019 // OpenCV版本：4.20 任何图像处理算法，都是从操作每个像
OpenCV中访问图像像素的三种方法及快慢比较
zbr794866300的博客
12-26 1730
三种访问Mat中元素的方法为： 指针访问 迭代器iterator 动态地址访问 1.用指针访问像素 指针访问像素利用的是C语言中的操作符[].从处理时间上看这种方法最快。Mat.ptr<>（i）取第i行的首地址，列数是Mat.cols列数乘以Mat.channels()通道数，元素一共就有列数*行数*通道数。 Mat image1=imread("name.jpg",1);...
OpenCV（总结篇）图像逐像素访问（三种操作：指针、迭代器、at()函数）
great_yzl的博客
08-12 4125
目录 概述 1、指针访问 2、迭代器访问 3、at()函数访问 总代码 效果 参考资料 概述 访问图像像素值是图像处理的基本操作。OpenCV提供了很多访问方式，比较常用的三种方式： （1） 通过指针访问 （逐通道） （2） 通过迭代器访问 （逐像素） （3） 动态地址计算，通过at()函数实现 方法比较： （1）用指针访问像素，速度最快；但在彩色图像处理中，如果要单独对某一个颜色分量处理，则需要通过数学公式计算，不是很直观； （2）推荐用通过迭代器访问像素，速度快，而且提取BGR...
OpenCV学习笔记九——访问图像中的像素
weifangmql的博客
12-28 934
1、图像在内存之中的存储方式 图像矩阵的大小取决于所用的颜色模型 如果是灰度图像： 如果是多通道图像，则矩阵的每一列都包含多个子列。如：RGB图像： 很多情况下，因为内存足够大，可以实现连续存储，因此，图像中的各行就能一行一行的连接起来，形成一个长行。连续存储有助于提升图像扫描速度，我们可以使用isContinuous()来判断矩阵是否是连续存储的。 2、颜色空间缩减 若矩
OpenCV—访问图像中的像素
qq_44859533的博客
06-09 2307
序言： OpenCV3编程入门已经进入第五章 (Core组件进阶） 学习了，后面也越来越多对图像的处理，这一节主要是对像素的认识。图像矩阵的大小取决于所用的颜色模型，也就是说取决于所用的通道数。如下灰度图像：对于多通道的图像，矩阵中的列会包含多个子列，子列个数与通道数相等。（1）问题提出：对于单通道像素，有256个不同的值，若三通道图像，颜色的存储值就有一千六百万多种。解决： 如此之多的颜色数值，但是达到同样效果的只占很小一部分。颜色空间缩减（color space reduction）可以大大降低运算复杂
OpenCV之访问图像中的像素
sono_io的博客
04-20 2935
1、图像在内存之中的存储方式 图像矩阵的大小取决于所用的颜色模型，确切的说，取决于所用通道数。如果是灰度图像，矩阵就如图所示： 对于多通道来说，矩阵中的列会包含多个子列，其子列个数与通道数相等，如图RGB颜色模型的矩阵： 可以看到，OpenCV中子列的通道顺序是反过来的-----BGR 而不是 RGB。 2、颜色空间缩减 如果矩阵元素存储的是单通道像素，使用C或者C++的无符号字符类型，像素可有256个不同值。 如果是三通道图像，这种存储格式的颜色数就太多了。256 * 256 * 25
OpenCV访问像素点
weixin_30551963的博客
05-10 267
三种方法 迭代器 创建一个Mat::Iterator对象it，通过it=Mat::begin()来的到迭代首地址，递增迭代器知道it==Mat::end()结束迭代； while (it != Scr.end<Vec3b>()) { //(*it)[0] = 0;//蓝色通道置零； (*it)[1] = 0;//绿色通道置零； //(*it)[2] = 0;//红色通...
OpenCV图像像素访问方法
01-28 1146
图像处理中经常会使用到OpenCV，需要遍历图像的像素值，下面介绍几种OpenCV中图像像素访问的方法。案例中，用RGB转灰度当作实例。 一、直接下标M.at<>(i,j)方法。 void Color2Gray(Mat bgrImg, unsigned char *dataY) { int row = bgrImg.rows; int col = bgrImg.cols; for (int i = 0; i < row; i++) { for
opencv访问图像像素的几种方法
11-14
本文将详细介绍在OpenCV 2.4.3版本中访问图像像素的三种主要方法：at函数法、指针法和迭代器法。这三种方法各有优势，适用于不同的场景，对于初学者来说，了解并熟练掌握这些方法对深入学习OpenCV至关重要。 1. **...
opencv中对图像像素的访问
11-21
首次接触图像处理，通过次来记录自己的学习记录，以方便回忆。 //指针访问像素 void colorReduce(Mat& temImage, int div) { //行数 int rowNumber = temImage.rows; cout << "图像通道数：" << temImage.channels() << endl; //列数*通道数=每一行的元素个数 int colNumber = temImage.cols * temImage.channels(); for (int row = 0; row < rowNumber;row++) { uchar* data = temImage.ptr<uchar>(row); for (int col = 0; col < colNumber;col++) { data[col] = data[col] / div*div + div / 2; } } } //迭代器iterator操作像素 void iterColorReduce(Mat& temImage,int div) { Mat_<Vec3b>::iterator it = temImage.begin<Vec3b>(); Mat_<Vec3b>::iterator itend = temImage.end<Vec3b>(); //存取彩色图像的像素 while (it != itend) { //开始处理每个像素 (*it)[0] = (*it)[0] / div*div + div / 2; (*it)[1] = (*it)[1] / div*div + div / 2; (*it)[2] = (*it)[2] / div*div + div / 2; ++it; } } //动态地址计算像素 void atColorReduce(Mat& temImage, int div) { int rowNumber = temImage.rows; int colNumber = temImage.cols; //存取彩色图像 for (int row = 0; row < rowNumber; row++) { for (int col = 0; col < colNumber; col++) { //开始处理每个图像 //蓝色通道 temImage.at<Vec3b>(row, col)[0] = temImage.at<Vec3b>(row, col)[0] / div*div + div / 2; //绿色通道 temImage.at<Vec3b>(row, col)[1] = temImage.at<Vec3b>(row, col)[1] / div*div + div / 2; //红色通道 temImage.at<Vec3b>(row, col)[2] = temImage.at<Vec3b>(row, col)[2] / div*div + div / 2; } } }
opencv对像素的访问
11-21
首次接触图像处理，通过次来记录自己的学习记录，随着了解的越多，可能就会有不同的理解，到时再来补充。通过对毛星云大大例程的操作，指针、迭代、动态地址访问之间最大的区别就是，时间的消耗会越来越大
4遍历图像像素的14种方法.rar_VS 图像处理_opencv vs_opencv像素点_图像处理
09-14
本篇将详细讲解如何在VS+OpenCV环境中利用不同的方法遍历图像像素点，并进行图像处理。 1. **基础遍历** 最基础的遍历方式是通过二维循环实现，如`for`循环。遍历图像的每个像素，可以获取到像素的RGB值或其他通道...
OpenCV4 学习：几种访问图像像素的方法
m0_64428335的博客
08-20 1133
在 OpenCV 中，访问图像像素有好几种，如：.at、.ptr、ptr()、.data、MatIterator_ 等，不同的像素访问方式的处理时间都不相同。对于实时性要求比较高的应用场景来说，处理的时间极为重要。下面我就来带大家测试一下各种方法的处理时间，以便使大家可以选择性能较优的方法，从而更好地开展 OpenCV 相关的代码编写。
Day 5 - Opencv 访问图像像素值
ruotianxia的博客
04-30 295
Day 5 - Opencv 访问图像像素值1. 访问图像像素值 1. 访问图像像素值 #include <opencv2/core.hpp> #include <opencv2/highgui.hpp> #include <random> #include <iostream> //加入椒盐噪声的函数 void addSalt(cv::Mat image, int n); int main(int argc, char** argv) { cv::Ma
OpenCV4 学习指导2 —— 多种方式访问图像的像素值
最新发布
DAOCHI
05-08 782
opencv 不同方式的像素访问以及性能对比
OpenCV学习2：访问像素值
st66688的博客
01-30 2228
在图像中加入椒盐噪声。 椒盐噪声是一个专门的噪声类型，它随机选择一些像素，把它们的颜色替换成白色或黑色。如果通信时出错，部分像素的值在传输时丢失，就会产生这种噪声。这里只是随机选择一些像素，把它们设置为白色。 函数声明： void salt(cv::Mat image, int n); 函数定义： void salt(cv::Mat image, int n) { // C++11 的随机数生成器 std::default_random_engine generator; std::uniform_
OpenCV 访问图像像素点
dearbigdog的博客
09-24 973
最快的访问3通道图像像素点的方法。直接地址访问。 for(int y = 0; y height; y++) { uchar *ptr=(uchar *)(pImg3->imageData+y*pImg3->widthStep); for(int x = 0; x width; x++) { //green G ptr[3*x+1]=0; //re
Opencv访问图像中像素的三类方法（C++）
beiketaoerge的博客
09-24 1172
使用指针访问、动态地址访问、Mat_（类似于STL）的三种访问形式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值