## OpenCV 学习（像素操作 Manipuating the Pixels）
OpenCV 虽然提供了许多类型的图像处理函数，可以对图像进行各种常见的处理，但是总会有些操作时没有的，这时我们就需要自己来操纵像素，实现我们需要的功能。今天就来讲讲 OpenCV 进行像素级操作的几种方法，并做个比较。
在 OpenCV 中，图像用矩阵来表示，对应的数据类型为 cv::Mat 。 cv::Mat 功能很强大，矩阵的元素可以为字节、字、浮点数、数组等多种形式。对于灰度图像，每个像素用一个 8 bit 字节来表示，对彩色图像，每个像素是一个三个元素的数组，分别存储 **BGR** 分量，这里大家没看错，就是 BGR 而不是 RGB，每个像素三个字节，第一个字节是蓝色分量，别问我为啥设计成这样，我也不知道。
### 访问单个像素 （at 函数）
cv::Mat 类有个 at(int y, int x) 方法，可以访问单个像素。但是我们知道cv::Mat 可以存储各种类型的图像。在调用这个函数时必须要指定返回的像素的类型，因为 at 函数是模板函数。
如果是灰度图，我们知道像素是以无符号字符型变量的形式存储的。那么要像下面这样访问。
~~~
image.at<uchar>(j,i)= value;
~~~
如果图像是24位真彩色的，那么可以这样：
~~~
image.at<cv::Vec3b>(j,i)[channel]= value;
~~~
下面是个简单的例子，打开一副彩色图像，在上面随机的添加一些噪声。原始图像如下：
核心的代码：
~~~
cv::Mat image = cv::imread("Q:\\test.jpg", CV_LOAD_IMAGE_COLOR);
for(int k = 0; k < 1000; k++)
{
int i = rand() % image.cols;
int j = rand() % image.rows;
image.at<cv::Vec3b>(i, j)[0] = 255;
image.at<cv::Vec3b>(i, j)[1] = 255;
image.at<cv::Vec3b>(i, j)[2] = 255;
}
~~~
处理后的图像如下：
像上面这样每次用 at 函数时都指定类型很繁琐。这时可以利用 cv::Mat 的派生类，cv::Mat_ 类，这个类是模板类。在建立这个类的实例时就要指定类型，之后就无需每次使用时再指定类型了。下面是个例子。
~~~
cv::Mat_ <cv::Vec3b> ima = image;
cv::namedWindow("Origin image", cv::WINDOW_NORMAL);
cv::imshow("Origin image", image);
for(int k = 0; k < 1000; k++)
{
int i = rand() % ima.cols;
int j = rand() % ima.rows;
ima(i, j)[0] = 255;
ima(i, j)[1] = 255;
ima(i, j)[2] = 255;
}
~~~
这个代码处理后的效果是相同的。
上面的程序中有个
~~~
ima = image;
~~~
这里又涉及到 OpenCV 的一个特性，就是普通的矩阵拷贝操作都是所谓的浅拷贝。也就是说这样操作后 ima 和 image 共享相同的图像数据。
如果我们想要真正的复制图像数据。这时可以用 clone() 方法。类似下面的代码：
~~~
cv::Mat_ <cv::Vec3b> ima = image.clone();
~~~
这样之后 ima 和 image 就完全独立了。
### 利用指针遍历图像像素
经常，我们的算法需要遍历图像的全部像素。这时用 at 函数就会很慢。更高效的访问图像像素的方式是利用指针。
简单的说，我们通常是去获得一行像素的头指针。如果图像是灰度的，则类似这样操作。
~~~
uchar* data = image.ptr<uchar>(j);
~~~
如果图像是 24 位彩色的，则可以这样：
~~~
cv::Vec3b * data = image.ptr<cv::Vec3b> (j);
~~~
实际上，即使是彩色图像，也可以用一个 uchar 型指针去指向。只要我们自己去计算要访问的像素相对行首的位置偏移是多少。比如下面的函数，可以处理灰度图像，也能处理彩色图像，作用是缩减图像中使用到的颜色。
~~~
void colorReduce(cv::Mat &image, int div=64)
{
int nl = image.rows; // number of lines
// total number of elements per line
int nc = image.cols * image.channels();
for (int j = 0; j < nl; j++)
{
// get the address of row j
uchar* data= image.ptr<uchar>(j);
for (int i = 0; i < nc; i++)
{
// process each pixel ---------------------
data[i]= data[i] / div * div + div / 2;
// end of pixel processing ----------------
}
} // end of line
}
~~~
利用默认参数应用于我们的测试图像后得到的结果如下：
上面的代码中有这么一行，是用来计算一行像素有多少个字节的。当然这个前提是每个channel 占用一个字节。
~~~
int nc= image.cols * image.channels();
~~~
如果每个 channel 占用多个字节的话，上面的公式就是错误的了，这时我们可以这样计算。
~~~
int nc = image.cols * image.elemSize();
~~~
image.elemSize() 得到的是每个像素的字节数。乘以一行有多少个像素，正好就是一行有多少个字节。
上面的例子中，我们用了两重循环来遍历图像中的每一个像素。实际上，因为我们对每个像素进行的操作是相同的，我们根本不需要确定某个像素是哪一行的。因此上面的代码还可以进一步优化，只用一个循环来完成。
但是这时我们要特别注意，有些图像所占的内存空间是不连续的。在一行像素结束后，可能会空出一小块内存。之所以会这样是因为有些 CPU 的指令对数据有内存对其要求。这样虽然浪费了一些空间，但是运算起来会更快速。
图像所占内存是否是连续的可以利用 isContinuous() 来得到。如果是连续的则可以用一个循环将所有像素都处理完。下面是代码，这个代码兼顾了内存连续与不连续两种情况，内存不连续时就退化为两重循环：
~~~
void colorReduce2(cv::Mat &image, int div=64)
{
int nl = image.rows; // number of lines
int nc = image.cols * image.channels();
if (image.isContinuous())
{
// then no padded pixels
nc = nc * nl;
nl = 1; // it is now a 1D array
}
// this loop is executed only once
// in case of continuous images
for (int j = 0; j < nl; j++)
{
uchar* data = image.ptr<uchar>(j);
for (int i = 0; i < nc; i++)
{
// process each pixel ---------------------
data[i] = data[i] / div * div + div / 2;
// end of pixel processing ----------------
} // end of line
}
}
~~~
如果我们要获得图像数据的首地址，还可以这样：
~~~
uchar *data = image.data;
~~~
对于二维图像数据来说，每行图像所占据的字节数由成员变量 step 来存储。因此：
~~~
data += image.step;
~~~
使得 data 指向下一行图像的内存首地址。
当然，上面这些操作都是比较低级的指针操作，不建议使用。
### 利用 iterators 来遍历图像数据
C++ 的标准模板库(STL)中大量的使用到了 iterator。OpenCV 也模仿 STL 显示了自己的一套 iterator。
OpenCV 中设计了 cv::MatIterator_ 类，这个类与 cv::Mat_ 类似，也是模板类。将这个类实例化时需要指定具体的类型。比如下面的代码：
~~~
cv::MatIterator_<cv::Vec3b> it;
~~~
另一种使用方法如下：
~~~
cv::Mat_<cv::Vec3b>::iterator it;
~~~
如果我们只是用 iterator 来读取像素值而不改变它，则可以用常量型 iterator.
~~~
cv::MatConstIterator_<cv::Vec3b> it;
cv::Mat_<cv::Vec3b>::const_iterator it;
~~~
上面的例子用 iterator 重写后代码如下：
~~~
void colorReduce3(cv::Mat &image, int div=64)
{
// obtain iterator at initial position
cv::Mat_<cv::Vec3b>::iterator it = image.begin<cv::Vec3b>();
// obtain end position
cv::Mat_<cv::Vec3b>::iterator itend = image.end<cv::Vec3b>();
// loop over all pixels
for ( ; it!= itend; ++it)
{
// process each pixel ---------------------
(*it)[0] = (*it)[0] / div * div + div / 2;
(*it)[1] = (*it)[1] / div * div + div / 2;
(*it)[2] = (*it)[2] / div * div + div / 2;
}
}
~~~
这种方式有利也有弊，最大的缺点是这个代码只能处理 24 位真彩色图像。优点是无需关注内存是否连续的问题了。相对来说，利用 iterator 的代码的运算速度比直接指针操作还是要稍微的慢一点。
### 各种方法的速度比较
上面介绍了几种访问图像像素的方法，在不考虑效率的前提下，这些方法都很好，可以实现同样的功能。但是在计算机视觉应用场景中，计算效率（运行速度）经常是我们必须要考虑的关键因素。
因此这里专门用一个小节来比较各种方法的运行速度。
为了完整性，下面也给出了一个用 at函数访问像素的 colorReduce 函数。
~~~
void colorReduce0(cv::Mat &image, int div=64)
{
int nl = image.rows; // number of lines
int nc = image.cols;
for (int j=0; j<nl; j++)
{
for (int i=0; i<nc; i++)
{
// process each pixel ---------------------
image.at<cv::Vec3b>(j,i)[0]=
image.at<cv::Vec3b>(j,i)[0]/div*div + div/2;
image.at<cv::Vec3b>(j,i)[1]=
image.at<cv::Vec3b>(j,i)[1]/div*div + div/2;
image.at<cv::Vec3b>(j,i)[2]=
image.at<cv::Vec3b>(j,i)[2]/div*div + div/2;
// end of pixel processing ----------------
} // end of line
}
}
~~~
回顾一下我们实现的几种方法。
- colorReduce0(): 使用 at 函数访问像素
- colorReduce1(): 两重循环，用指针访问像素
- colorReduce2(): 当图像内存连续时用一重循环访问所有像素
- colorReduce3(): 用 iterator 访问像素
利用 cv::getTickCount() 来计算各个函数的运行时间。
- colorReduce0(): 240579
- colorReduce1(): 22363
- colorReduce2(): 21202
- colorReduce3(): 77573
结果一目了然，colorReduce0 运行的最慢，其次是 colorReduce3。
colorReduce1 和 colorReduce2 相差的不多。因此，我们写程序时，应尽可能的采用 colorReduce2 或 colorReduce1 这样的用法。
