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 = ; i < rows; i++)
     {
         uchar* data = dstImg.ptr<uchar>(i);
         for(int j = ; j < cols; j++)
         {
             data[j] = ;  //处理每一个像素
             //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 = ;
         //cout << "is continuous " << endl;
     }

     for(int i = ; i < rows; i++)
     {
         uchar* data = dstImg.ptr<uchar>(i);
         for(int j = ; j < cols * channels; j++)
         {
             data[j] = ;  //处理每一个像素
             //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 :
         {
             Mat_<uchar>::iterator it= dstImg.begin<uchar>();
             Mat_<uchar>::iterator itend= dstImg.end<uchar>();
             for ( ; it!= itend; it++) //处理每一个像素
             {
                 *it = ;
             }
             break;
         }
     case :
         {
             Mat_<Vec3b>::iterator it3= dstImg.begin<Vec3b>();
             Mat_<Vec3b>::iterator itend3= dstImg.end<Vec3b>();
             for ( ; it3!= itend3; it3++) //处理每一个像素
             {
                 (*it3)[]= ;
                 (*it3)[]= ;
                 (*it3)[]= ;
             }
             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 :
         {
             for(int i = ; i < rows; i++)
                 for(int j = ; j < cols; j++)
                     dstImg.at<uchar>(i,j) = ;
             break;
         }
     case :
         {
             for(int i = ; i < rows; i++)
                 for(int j = ; j < cols; j++)
                 {
                     dstImg.at<Vec3b>(i,j)[] =  ;
                     dstImg.at<Vec3b>(i,j)[] =  ;
                     dstImg.at<Vec3b>(i,j)[] = ;
                 }
             break;
         }
     }
 }

测试代码-总

 #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();
     return ;
 }

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

     for(int i = ; i < rows; i++)
     {
         uchar* data = dstImg.ptr<uchar>(i);
         for(int j = ; j < cols; j++)
         {
             data[j] = ;  //处理每一个像素
             //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 = ;
         //cout << "is continuous " << endl;
     }

     for(int i = ; i < rows; i++)
     {
         uchar* data = dstImg.ptr<uchar>(i);
         for(int j = ; j < cols * channels; j++)
         {
             data[j] = ;  //处理每一个像素
             //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 :
         {
             Mat_<uchar>::iterator it= dstImg.begin<uchar>();
             Mat_<uchar>::iterator itend= dstImg.end<uchar>();
             for ( ; it!= itend; it++) //处理每一个像素
             {
                 *it = ;
             }
             break;
         }
     case :
         {
             Mat_<Vec3b>::iterator it3= dstImg.begin<Vec3b>();
             Mat_<Vec3b>::iterator itend3= dstImg.end<Vec3b>();
             for ( ; it3!= itend3; it3++) //处理每一个像素
             {
                 (*it3)[]= ;
                 (*it3)[]= ;
                 (*it3)[]= ;
             }
             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 :
         {
             for(int i = ; i < rows; i++)
                 for(int j = ; j < cols; j++)
                     dstImg.at<uchar>(i,j) = ;
             break;
         }
     case :
         {
             for(int i = ; i < rows; i++)
                 for(int j = ; j < cols; j++)
                 {
                     dstImg.at<Vec3b>(i,j)[] =  ;
                     dstImg.at<Vec3b>(i,j)[] =  ;
                     dstImg.at<Vec3b>(i,j)[] = ;
                 }
             break;
         }
     }
 }