OpenCV操作像素

在了解了图像的基础知识和OpenCV的基础知识和操作以后，接下来我们要做的就对像素进行操作，我们知道了图像的本质就是一个矩阵，那么一个矩阵中存储了那么多的像素，我们如何来操作呢?下面通过几个例子来看看像素的操作。

这个是原图，接下来的例子都是对这个图片进行操作的。

访问像素出现雪花效果

我们需要有雪花的效果，这里的雪花其实就是一个个白色的点，白色在像素值是255，所以我们的思路就是在一个图像上面的矩阵中的一些像素值转成值为255的，如果是彩色的图像的话就是三个通道，那么就是分别对三个通道的值都转为255，三通道在OpenCV里面是按照蓝绿红的顺序排布的。

• 代码实现

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <random>

// Add white noise to an image
void white(cv::Mat image, int n) {

    // C++11 random number generator
    std::default_random_engine generator;
    std::uniform_int_distribution<int> randomRow(0, image.rows - 1);
    std::uniform_int_distribution<int> randomCol(0, image.cols - 1);

    int i,j;
    for (int k=0; k<n; k++) {
        // 生成图形位置
        i= randomCol(generator);
        j= randomRow(generator);
        if (image.type() == CV_8UC1) { //灰度图像
            // 单通道8位
            image.at<uchar>(j,i)= 255;
        } else if (image.type() == CV_8UC3) { // color image
            // 3通道，分别是蓝绿红
            image.at<cv::Vec3b>(j,i)[0]= 255;
            image.at<cv::Vec3b>(j,i)[1]= 255;
            image.at<cv::Vec3b>(j,i)[2]= 255;
            // or simply:
            // image.at<cv::Vec3b>(j, i) = cv::Vec3b(255, 255, 255);
        }
    }
}

int main()
{
    // open the image
    cv::Mat image= cv::imread("boldt.jpg",1);

    // call function to add noise
    white(image,3000);

    // display result
    cv::namedWindow("Image1");
    cv::imshow("Image1",image);

    // write on disk
    cv::imwrite("salted.bmp",image);

    cv::waitKey();

    // test second version
    cv::Mat image2= cv::imread("boldt.jpg",0);//0表示灰度图

    white(image2, 500);

    cv::namedWindow("Image2");
    cv::imshow("Image2",image2);

    cv::waitKey();

    return 0;
}

• 效果

指针遍历像素：减少图像中颜色的数量

彩色图像由三通道像素组成，每个通道表示红、绿、蓝三原色中一种颜色的亮度值，每个数值都是8位无符号字符类型，因此颜色总数为 256×256×256，即超过 1600 万种颜色。

所以有时候为了降低分析的复杂性，需要减少图像中颜色的数量。

一种实现方法是把RGB空间细分到大小相等的方块中。例如，如果把每种颜色数量减少到 1/8，那么颜色总数就变为 32×32×32。将旧图像中的每个颜色值划分到一个方块，该方块的中间值就是新的颜色值；新图像使用新的颜色值，颜色数就减少了。

所以在这里的减少图像中颜色的数量的思路的步骤是：

• 假设 N 是减色因子，将图像中每个像素的值除以 N（这里假 定使用整数除法，不保留余数）。

• 然后将结果乘以 N，得到 N 的倍数，并且刚好不超过原始像素 值。

• 加上 N / 2，就得到相邻的 N 倍数之间的中间值。

• 对所有 8 位通道值重复这个过程，就会得到 (256 / N) × (256 / N) × (256 / N)种可能的颜色值。

#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>

void reduceColor(cv::Mat image, int div = 64)
{
    int nl = image.rows;//行数
    int nc = image.cols * image.channels();//每一行的像素数量

    for (int i = 0; i < nl; ++i) {
        //获取行i的地址
        auto data = image.ptr<uchar>(i);
        for (int j = 0; j < nc; ++j) {
            //处理每一个像素
            data[j] = data[j]/div*div + div/2;
        }
    }
}

int main()
{
    cv::Mat image = cv::imread("boldt.jpg");

    reduceColor(image, 64);
    cv::namedWindow("image");
    cv::imshow("image", image);
    cv::waitKey();
    return 0;
}

• 效果图

当然刚刚的这个代码是用普通的遍历完成的，我们也可以用迭代器完成对像素的遍历

void reduceColorNew(cv::Mat image, int div=64) {

    // div must be a power of 2
    int n= static_cast<int>(log(static_cast<double>(div))/log(2.0) + 0.5);
    // mask used to round the pixel value
    uchar mask= 0xFF<<n; // e.g. for div=16, mask= 0xF0
    uchar div2 = div >> 1; // div2 = div/2

    // get iterators
    cv::Mat_<cv::Vec3b>::iterator it= image.begin<cv::Vec3b>();
    cv::Mat_<cv::Vec3b>::iterator itend= image.end<cv::Vec3b>();

    // scan all pixels
    for ( ; it!= itend; ++it) {

        // process each pixel ---------------------

        (*it)[0]&= mask;
        (*it)[0]+= div2;
        (*it)[1]&= mask;
        (*it)[1]+= div2;
        (*it)[2]&= mask;
        (*it)[2]+= div2;

        // end of pixel processing ----------------
    }
}

扫描图像并访问相邻像素

在图像处理中经常有这样的处理函数，它在计算每个像素的数值时，需要使用周边像素的值。 如果相邻像素在上一行或下一行，就需要同时扫描图像的多行。

我们将使用一个锐化图像的处理函数。它基于拉普拉斯算子。在图像处理领域有一个众所周知的结论：如果从图像中减去拉普拉斯算子部分，图像 的边缘就会放大，因而图像会变得更加尖锐。

实现思路：

• 图像扫描中使用了三个指针
• 一个表 示当前行、一个表示上面的行、一个表示下面的行
• 另外，因为在计算每一个像素时都需要访问 与它相邻的像素，所以有些像素的值是无法计算的，比如第一行、最后一行和第一列、最后一列 的像素。

#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

void sharpen(const cv::Mat &image, cv::Mat &result) {

    result.create(image.size(), image.type()); // allocate if necessary
    int nchannels= image.channels();

    for (int j= 1; j<image.rows-1; j++) { // for all rows (except first and last)

        const uchar* previous= image.ptr<const uchar>(j-1); // previous row
        const uchar* current= image.ptr<const uchar>(j);   // current row
        const uchar* next= image.ptr<const uchar>(j+1);       // next row

        uchar* output= result.ptr<uchar>(j);   // output row

        for (int i=nchannels; i<(image.cols-1)*nchannels; i++) {

            // apply sharpening operator
            *output++= cv::saturate_cast<uchar>(5*current[i]-current[i-nchannels]-current[i+nchannels]-previous[i]-next[i]);
        }
    }

    // Set the unprocess pixels to 0
    result.row(0).setTo(cv::Scalar(0));
    result.row(result.rows-1).setTo(cv::Scalar(0));
    result.col(0).setTo(cv::Scalar(0));
    result.col(result.cols-1).setTo(cv::Scalar(0));
}


int main()
{
    cv::Mat image= cv::imread("boldt.jpg");
    if (!image.data)
        return 0;

    cv::Mat result;

    double time= static_cast<double>(cv::getTickCount());
    sharpen(image, result);
    time= (static_cast<double>(cv::getTickCount())-time)/cv::getTickFrequency();
    std::cout << "time= " << time << std::endl;

    cv::namedWindow("Image");
    cv::imshow("Image",result);

    cv::waitKey();

    return 0;
}

时间：time= 0.00339625