OpenCV4入门教程017：像素读写

索引地址：系列索引

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

访问某一个像素点

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

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

#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;
}

执行后输出为：

$ ./pixel
[  0,   0,   0;
   0,   0,   0;
   0,   0,   0]

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

使用at方法

#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。

编译运行结果为：

$ ./pixel
[  0,   0,   0;
   0, 255,   0;
   0,   0,   0]
255

ptr方法

#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是指针，所以需要通过指针的方法来访问像素数值。

编译运行结果：

$ ./pixel        
[  0,   0,   0;
   0,  32,   0;
   0,   0,   0]
32

访问全部像素

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

at方法

#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;
}

和二维数组输出类似。

结果如下：

$ ./pixel        
0 -16777216 0 
0 255 0 
65280 0 0 

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

ptr方法

#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;
}

结果如下：

$ ./pixel        
0 0 0 
0 255 0 
0 0 0

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

迭代器方法

#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;
}

输出结果为：

$ ./pixel        
0 0 0 0 255 0 0 0 0 %

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

访问像素的14种方法

//---------------------------------【头文件、命名空间包含部分】-----------------------------
//      描述：包含程序所使用的头文件和命名空间
//-------------------------------------------------------------------------------------------------
#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，需要时进行类型转换。