(OpenCV — 6)访问图像中的像素

最新推荐文章于 2022-04-20 22:23:20 发布

QtHalcon

最新推荐文章于 2022-04-20 22:23:20 发布

阅读量263

点赞数

分类专栏：计算机视觉

本文链接：https://blog.csdn.net/qq_40732350/article/details/89088885

版权

计算机视觉专栏收录该内容

42 篇文章 150 订阅

订阅专栏

1 图像在内存之中的存储方式

图像矩阵的大小取决于所用的颜色模型，确切地说，取决于所用通道数。如果是灰度图像，矩阵就会如图所示。

而对多通道图像来说，矩阵中的列会包含多个子列，其子列个数与通道数相等。例如，如图所示RGB 颜色模型的矩阵。

三通道：R：（8位），G：（8位），B：（8位）

可以看到， OpenCV 中子列的通道顺序是反过来的—-BGR 而不是 RGB 。很多情况下，因为内存足够大，可实现连续存储，因此，图像中的各行就能一行一行地连接起来，形成一个长行。连续存储有助于提升图像扫描速度，我们可以使用 isContinuous()来判断矩阵是否是连续存储的。

2 颜色空问缩减

单通道：用8位表示
3通道：用24位表示

三通道图像，这种存储格式的颜色数有六百多万种。用如此之多的颜色来进行处理，可能会对我们的算法性能造成严重影响。

其实，仅用这些颜色中具有代表性的很小的部分，就足以达到同样的效果。
如此，颜色空间缩减 (color space reduction ) 便可以派上用场了，它在很多应用中可以大大降低运算复杂度。颜色空间缩减的做法是：将现有颜色空间值除以某个输入值，以获得较少的颜色数。也就是 “做减法”，比如颜色值 0 到 9 可取为新值 0, 10 到 19 可取为 10, 以此类推。

如 uchar 类型的三通道图像，每个通道取值可以是 0~255, 于是就有 256X256X256个不同的值。我们可以定义：

0 ~ 9 范围的像素值为 0;
10~ 19 范围的像素值为 10;
20~ 29 范围的像素值为 20 。
这样的操作将颜色取值降低为 26X26X26 种情况。这个操作可以用一个简单的公式来实现。因为 C++ 中 int 类型除法操作会自动截余。例如 lold= l4 ;lnew=(lold/10) * 10=( 14 / 10)* 10= 1 * 10= 10;

在处理图像像素时，每个像素需要进行一遍上述计算，也需要一定的时间花销。但我们注意到其实只有 0~255 种像素，即只有 256 种情况。进一步可以把 256 种计算好的结果提前存在表中 table 中，这样每种情况不需计算，直接从 table中取结果即可。

int divideWith=l0;
uchar table[256] ;
for (int i = 0; i < 256; ++i)
    table[i] = divideWith * (i/ divideWith) ;

于是 table[i]存放的是值为 i 的像素减小颜色空间的结果，这样也就可以理解上述方法中的操作：

p[j] = table[p[j]];

这样，简单的颜色空间缩减算法就可由下面两步组成：
(1) 遍历图像矩阵的每一个像素；
(2) 对像素应用上述公式。

改进：

上述做法虽然减少了颜色值，但是在存储上还是用了24位，如果我们要用16位表示改怎么办？

如R：（4位），G：（6位），B：（6位）

则改为下面的运算：

unsigned short R_table[256] ;//红色
for (int i = 0; i < 256; ++i)
    R_table[i] = (i >> 4) << 12;//先左移4位去掉余数，再左移12位

unsigned short G_table[256] ;//绿色
for (int i = 0; i < 256; ++i)
    G_table[i] = (i >> 2) << 6;//先右移2位去掉余数，再左移6位

unsigned short B_table[256] ;//蓝色
for (int i = 0; i < 256; ++i)
    B_table[i] = i >> 2;//先右移2位去掉余数，再左移0位

取数为：

unsigned short rgb;//16位数
rgb = (R_table[ r[j] ] || G_table[ g[j] ] || B_table[ b[j] ]);

3 LUT 函数： Look up table 操作

对于上文提到的 Look up table 操作， OpenCV 官方文档中强烈推荐我们使用个原型为 operationsOnArrays:LUT()<lut>的函数来进行。它用于批量进行图像元素查找、扫描与操作图像。其使用方法如下：

//首先我们建立一个 mat 型用于查表
Mat lookUpTable(l , 256, CV_8U) ;
uchar* p = lookUpTable.data;
for (int i = 0; i < 256; ++i)
	p[i] = table[i];

//然后我们调用函数 (I是输入，J是输出）
for (int i = 0 ; 1. < times; ++i)
	LUT(I , lookUpTable , J);

4 计时函数

另外有个问题是如何计时。可以利用这两个简便的计时函数一一getTickCount()和 getTickFrequency() 。

getTickCount()函数返回 CPU 自某个事件（如启动电脑）以来走过的时钟周期数
getTickFrequency()函数返回 CPU 一秒钟所走的时钟周期数。这样，我们就能轻松地以秒为单位对某运算计时。

这两个函数组合起来使用的示例如下。不过我们一般不会使用这个函数，操作系统有专门的时间函数。

double time0 = static_cast<double>(getTickCount()) ; //记录起始时间
//进行 图像处理操作……
time0 = ((double ) getTickCount() - time0) /getTickFrequency() ;
cout<< " 此方法运行时间为： " <<time0<< " 秒 " << endl ;//输出运行时间

5 访问图像中像素的三类方法

任何图像处理算法，都是从操作每个像素开始的。即使我们不会使用 OpenCV提供的各种图像处理函数，只要了解了图像处理算法的基本原理，也可以写出具有相同功能的程序。在 OpenCV 中，提供了三种访问每个像素的方法。
• 方法一指针访问：C 操作符[ ]
• 方法二迭代器 iterator
• 方法三动态地址计算

这三种方法在访问速度上略有差异。 debug 模式下，这种差异非常明显，不过在 release 模式下，这种差异就不太明显了。我们通过一组程序来说明这几种方法。程序的目的是减少图像中颜色的数量，比如原来的图像是是 256 种颜色，我们希望将它变成 64 种颜色，那只需要将原来的颜色除以 4 (整除）以后再乘以 4就可以了。
将要使用的主程序代码如下。

/***头文件包含部分***/
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include <iostream>
#include <ctime>
/***命名空间声明部分***/
using namespace cv;
using namespace std;
int main( )
{
    //【1】创建原始图并显示
    Mat srcImage = imread("D:\\QT\\project\\opencv_qtcreaor\\4_2\\4_2\\image1.jpg");
    namedWindow("原始图像");
    imshow("原始图像",srcImage);

    //【2】按原始图的参数规格来创建创建效果图
    Mat dstImage;
    dstImage.create(srcImage.rows,srcImage.cols,srcImage.type());//效果图的大小、类型与原图片相同

    //【3】记录起始时间
    double time0 = static_cast<double>(getTickCount());

    //【4】调用颜色空间缩减函数
    colorReduce(srcImage,dstImage,32);

    //【5】计算运行时间并输出
    time0 = ((double)getTickCount() - time0)/getTickFrequency();
    cout <<"此方法运行时间为： "<<time0<<"秒"<<endl;  //输出运行时间

    //【6】显示效果图
    namedWindow("效果图");
    imshow("效果图",dstImage);
    waitKey(0);
}

1. 【方法一】用指针访问像素
用指针访问像素的这种方法利用的是 C 语言中的操作符[ ] 。这种方法最快，但是略有点抽象。实验条件下单次运行时间为 0.00665378 。

//使用【指针访问：C操作符[ ]】方法版的颜色空间缩减函数
void colorReduce(Mat& inputImage, Mat& outputImage, int div)
{
    //参数准备
    outputImage = inputImage.clone();  //拷贝实参到临时变量
    int rowNumber = outputImage.rows;  //行数
    int colNumber = outputImage.cols*outputImage.channels();  //列数 x 通道数=每一行元素的个数

    //双重循环，遍历所有的像素值
    for(int i = 0;i < rowNumber;i++)  //行循环
    {
        uchar* data = outputImage.ptr<uchar>(i);  //获取第i行的首地址
        for(int j = 0;j < colNumber;j++)   //列循环
        {
            // ---------【开始处理每个像素】-------------
            data[j] = data[j]/div*div + div/2;
            // ----------【处理结束】---------------------
        }  //行处理结束
    }
}

运行结果：

此方法运行时间为：  0.00657968 秒

2. 【方法二】用迭代器操作像素

第二种方法为用迭代器操作像素，这种方法与 STL 库的用法类似。
在迭代法中，我们所需要做的仅仅是获得图像矩阵的 begin 和 end , 然后增加迭代直至从 begin 到 end。将＊操作符添加在迭代指针前，即可访问当前指向的内容。相比用指针直接访问可能出现越界问题，迭代器绝对是非常安全的方法。

//描述：使用【迭代器】方法版的颜色空间缩减函数
void colorReduce2(Mat& inputImage, Mat& outputImage, int div)
{
    //参数准备
    outputImage = inputImage.clone();  //拷贝实参到临时变量
    //获取迭代器
    Mat_<Vec3b>::iterator it = outputImage.begin<Vec3b>();  //初始位置的迭代器
    Mat_<Vec3b>::iterator itend = outputImage.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;
        // ------------------------【处理结束】----------------------------
    }
}

运行结果：

此方法运行时间为：  0.0333115 秒

3 . 【方法三】动态地址计算

第三种方法为用动态地址计算来操作像素。下而是使用动态地址运算配合 at方法的 colorReduce 函数的代码。这种方法简洁明了，符合大家对像素的直观认识。

//描述：使用【动态地址运算配合at】方法版本的颜色空间缩减函数
void colorReduce3(Mat& inputImage, Mat& outputImage, int div)
{
    //参数准备
    outputImage = inputImage.clone();  //拷贝实参到临时变量
    int rowNumber = outputImage.rows;  //行数
    int colNumber = outputImage.cols;  //列数

    //存取彩色图像像素
    for(int i = 0;i < rowNumber;i++)
    {
        for(int j = 0;j < colNumber;j++)
        {
            // ------------------------【开始处理每个像素】--------------------
            outputImage.at<Vec3b>(i,j)[0] =  outputImage.at<Vec3b>(i,j)[0]/div*div + div/2;  //蓝色通道
            outputImage.at<Vec3b>(i,j)[1] =  outputImage.at<Vec3b>(i,j)[1]/div*div + div/2;  //绿色通道
            outputImage.at<Vec3b>(i,j)[2] =  outputImage.at<Vec3b>(i,j)[2]/div*div + div/2;  //红是通道
            // -------------------------【处理结束】----------------------------
        }  // 行处理结束
    }
}

运行结果：

此方法运行时间为：  0.0204504 秒

Mat 类中的 cols 和 rows 给出了图像的宽和高。而成员函数 at ( int y, int x )可以用来存取图像元素，但是必须在编译期知道图像的数据类型。需要注意的是，我们一定要确保指定的数据类型要和矩阵中的数据类型相符合，因为at 方法本身不会对任何数据类型进行转换。

对于彩色图像，每个像素由三个部分构成：蓝色通道、绿色通道和红色通道( BGR ) 。因此，对于一个包含彩色图像的 Mat , 会返回一个由三个 8 位数组成的向量。 OpenCV 将此类型的向量定义为 Vec3b, 即由三个 unsigned char 组成的向扯。这也解释了为什么存取彩色图像像素的代码可以写出如下形式：

image.at<VecJb>(j , i) [channel]=value;

其中，索引值 channel 标明了颜色通道号。另外需要再次提醒大家的是， OpenCV 中的彩色图像不是以 RGB 的顺序存放的，而是 BGR , 所以程序中的 outputlmage.at<Vec3b>(i, j)[0]代表的是该点的 B 分量。同理还有(*it)[0] 。

QtHalcon

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
(OpenCV — 6)访问图像中的像素

1 图像在内存之中的存储方式图像矩阵的大小取决于所用的颜色模型，确切地说，取决于所用通道数。如果是灰度图像，矩阵就会如图所示。而对多通道图像来说，矩阵中的列会包含多个子列，其子列个数与通道数相等。例如，如图所示RGB 颜色模型的矩阵。三通道：R：（8位），G：（8位），B：（8位）可以看到， OpenCV 中子列的通道顺序是反过来的—-BGR 而不是 RGB 。很多...
复制链接

扫一扫