一、概述

让我们考虑一种简单的色彩还原方法。通过使用unsigned char C和c++类型进行矩阵项存储，一个像素通道可以有多达256个不同的值。对于一个三通道图像，这可能会形成太多的颜色(确切地说是1600万)。处理如此多的色度可能会严重影响我们的算法性能。然而，有时使用更少的元素就足以获得相同的最终结果。

在这种情况下，我们通常会减少色彩空间。这意味着我们将颜色空间当前值与一个新的输入值相除，从而得到更少的颜色。例如，0到9之间的每个值都取新值0,10到19之间的每个值取新值10，以此类推。

当我们将uchar (unsigned char -也就是0到255之间的值)值与int值相除时，结果也将是char。这些值只能是字符值。因此，任何分数都将四舍五入。利用这一事实，uchar域的上操作可以表示为:

一个简单的色彩空间缩减算法只需要遍历图像矩阵的每个像素并应用这个公式即可。值得注意的是，我们做了一个除法和一个乘法运算。这些操作对于系统来说是非常昂贵的。如果可能的话，可以通过使用一些更便宜的操作来避免它们，比如一些减法、加法，或者在最好的情况下一个简单的赋值。此外，请注意，我们只有有限数量的输入值用于上面的操作。在uchar系统中，确切地说是256。

因此，对于较大的图像，明智的做法是事先计算所有可能的值，并在赋值过程中使用查找表进行赋值。查找表是简单的数组(具有一个或多个维度)，对于给定的输入值变化，它保存最终输出值。它的优点是我们不需要进行计算，我们只需要读取结果。

我们的测试用例程序(以及下面的代码示例)将执行以下操作:读入作为命令行参数传递的图像(它可以是彩色的，也可以是灰度的)，并对给定的命令行参数整数值应用缩减。在OpenCV中，目前有三种主要的逐像素浏览图像的方法。为了让事情变得更有趣，我们将使用每种方法对图像进行扫描，并打印出扫描所花费的时间。

 int divideWith = 0; // convert our input string to number - C++ style
 stringstream s;
 s << argv[2];
 s >> divideWith;
 if (!s || !divideWith)
 {
 cout << "Invalid number entered for dividing. " << endl;
 return -1;
 }
 uchar table[256];
 for (int i = 0; i < 256; ++i)
 table[i] = (uchar)(divideWith * (i/divideWith));

这里，我们首先使用c++ stringstream类将第三个命令行参数从文本转换为整数格式。然后我们使用简单的查看和上面的公式来计算查找表。这里没有OpenCV特有的东西。

另一个问题是我们如何测量时间?OpenCV提供了两个简单的函数来实现cv::getTickCount()和cv::getTickFrequency()。第一个返回系统CPU从某个事件(比如自启动系统以来)的滴答数。第二个返回CPU在一秒钟内发出tick的次数。因此，测量两个操作之间经过的时间就像下面这样简单:

double t = (double)getTickCount();
// do something ...
t = ((double)getTickCount() - t)/getTickFrequency();
cout << "Times passed in seconds: " << t << endl;

二、图像矩阵如何存储在内存中?

矩阵的大小取决于所使用的颜色系统。更准确地说，它取决于所使用的通道的数量。在灰度图像的情况下，我们有这样的东西:

对于多通道图像，列包含与通道数量一样多的子列。例如，在BGR颜色系统的情况下:

注意通道的顺序是相反的:BGR而不是RGB。因为在许多情况下，内存足够大，可以以连续的方式存储行，所以行可以一个接一个地跟随，创建一个单独的长行。因为所有东西都在一个地方，一个接一个，这可能有助于加快扫描过程。我们可以使用cv::Mat::isContinuous()函数来询问矩阵是否存在这种情况。继续下一节查找示例。

三、高效的方式

说到性能，你无法击败经典的C风格操作符访问。因此，我们可以推荐的最有效的分配方法是:

Mat& ScanImageAndReduceC(Mat& I, const uchar* const table)
{
	 // accept only char type matrices
	 CV_Assert(I.depth() == CV_8U);
	 int channels = I.channels();
	 int nRows = I.rows;
	 
	 int nCols = I.cols * channels;	//单通道就是灰度图、三通道一般就是GBR色系
	 if (I.isContinuous())
	 {
		 nCols *= nRows;
		 nRows = 1;
	 }
	 int i,j;
	 uchar* p;
	 for( i = 0; i < nRows; ++i)
	 {
		 p = I.ptr<uchar>(i);
		 for ( j = 0; j < nCols; ++j)
			 {
			 	p[j] = table[p[j]];
			 }
	 }
	 return I;
}

这里我们基本上只是获取一个指向每行开头的指针然后遍历它直到它结束。在矩阵以连续方式存储的特殊情况下，我们只需要一次请求指针，然后一直到最后。我们需要注意彩色图像:我们有三个通道，所以我们需要在每行中传递三倍的项目。

还有另一种方法。Mat对象的data成员返回指向第一行第一列的指针。如果该指针为空，则在该对象中没有有效输入。检查这是检查图像加载是否成功的最简单方法。如果存储是连续的，我们可以用这个来遍历整个数据指针。在灰度图像的情况下，这看起来像:

uchar* p = I.data;
for( unsigned int i = 0; i < ncol*nrows; ++i)
 *p++ = table[*p];

你会得到相同的结果。然而，这段代码在后面阅读起来要困难得多。如果你有一些更高级的技术，它会变得更难。此外，在实践中，我观察到我们将获得相同的性能结果(因为大多数现代编译器可能会自动为我们进行这个小优化技巧)。

四、迭代器(安全)方法

在有效的情况下，确保我们通过适当数量的uchar字段，并跳过行之间可能发生的空白是我们的责任。迭代器方法被认为是一种更安全的方法，因为它从用户那里接管了这些任务。你所需要做的就是询问图像矩阵的开始和结束，然后只增加开始迭代器，直到你到达结束。要获取迭代器所指向的值，可以使用操作符(在其前面加上)。

Mat& ScanImageAndReduceIterator(Mat& I, const uchar* const table)
{
 // accept only char type matrices
 CV_Assert(I.depth() == CV_8U);
 const int channels = I.channels();
 switch(channels)
 {
 case 1:
 {
 MatIterator_<uchar> it, end;
 for( it = I.begin<uchar>(), end = I.end<uchar>(); it != end; ++it)
 *it = table[*it];
 break;
 }
 case 3:
 {
 MatIterator_<Vec3b> it, end;
 for( it = I.begin<Vec3b>(), end = I.end<Vec3b>(); it != end; ++it)
 {
 (*it)[0] = table[(*it)[0]];
 (*it)[1] = table[(*it)[1]];
 (*it)[2] = table[(*it)[2]];
 }
 }
 }
 return I;
}

对于彩色图像，我们每列有三个uchar项。这可以被认为是uchar项的短向量，在OpenCV中被命名为Vec3b。要访问第n个子列，我们使用简单的操作符[]访问。重要的是要记住，OpenCV迭代器遍历列并自动跳到下一行。因此，对于彩色图像，如果使用简单的uchar迭代器，则只能访问蓝色通道值。

五、带引用返回的动态地址计算

最后一种方法不建议用于扫描。它是用来获取或修改图像中的随机元素的。其基本用途是指定要访问的项的行号和列号。在我们之前的扫描方法中，你可能已经注意到，通过什么类型来观察图像是很重要的。这里没有什么不同，因为我们需要手动指定在自动查找时使用的类型。我们可以在以下源代码的灰度图像中观察到这一点(使用+ cv::Mat::at()函数):

Mat& ScanImageAndReduceRandomAccess(Mat& I, const uchar* const table)
{
 // accept only char type matrices
 CV_Assert(I.depth() == CV_8U);
 const int channels = I.channels();
 switch(channels)
 {
 case 1:
 {
 for( int i = 0; i < I.rows; ++i)
 for( int j = 0; j < I.cols; ++j )
 I.at<uchar>(i,j) = table[I.at<uchar>(i,j)];
 break;
 }
 case 3:
 {
 Mat_<Vec3b> _I = I;
 for( int i = 0; i < I.rows; ++i)
 for( int j = 0; j < I.cols; ++j )
 {
 _I(i,j)[0] = table[_I(i,j)[0]];
 _I(i,j)[1] = table[_I(i,j)[1]];
 _I(i,j)[2] = table[_I(i,j)[2]];
 }
 I = _I;
 break;
 }
 }
 return I;
}

该函数接受我们的输入类型和坐标，并计算查询项的地址。然后返回对它的引用。当你获取值时，它可能是一个常量，当你设置值时，它可能是非常量。作为调试模式下的安全步骤，只有*检查输入坐标是否有效且确实存在。如果不是这种情况，我们将在标准错误输出流上得到一个很好的输出消息。与释放模式下的有效方式相比，使用这种方式的唯一区别是，对于图像的每个元素，我们将获得一个新的行指针，而我们使用C操作符[]来获取列元素。

如果我们需要使用此方法对图像进行多次查找，那么为每次访问输入类型和at关键字可能会很麻烦且耗时。为了解决这个问题，OpenCV有一个cv::Mat_数据类型。它与Mat一样，只是需要在定义时通过查看数据矩阵来指定数据类型，但是反过来，我们可以使用operator()来快速访问项。为了使事情变得更好，这很容易从通常的cv::Mat数据类型转换为cv::Mat。我们可以在上面函数的彩色图像中看到一个示例用法。然而，需要注意的是，cv::Mat::at函数也可以执行相同的操作(运行时速度相同)。这只是一个为懒惰程序员编写的小技巧。

六、核心功能

这是在图像中实现查找表修改的额外方法。在图像处理中，你想要将所有给定的图像值修改为其他值是很常见的。OpenCV提供了一个修改图像值的功能，而不需要编写图像的扫描逻辑。我们使用核心模块的cv::LUT()函数。首先，我们构建一个Mat类型的查找表:

 Mat lookUpTable(1, 256, CV_8U);
 uchar* p = lookUpTable.ptr();
 for( int i = 0; i < 256; ++i)
 p[i] = table[i];

最后调用函数(I是我们的输入图像，J是输出图像):

 LUT(I, lookUpTable, J);

七、性能差异

为了获得最好的结果，编译程序并自己运行它。为了使差异更清楚，我使用了一个相当大的(2560 X 1600)图像。这里展示的表演是针对彩色图像的。为了得到一个更精确的值，我已经将函数调用得到的值平均了100次。

方法	时间
有效方式	79.4717毫秒
迭代器	83.7201毫秒
动态RA	93.7878毫秒
LUT函数	32.5759毫秒

我们可以得出一些结论。如果可能的话，使用OpenCV已有的函数(而不是重新发明这些函数)。最快的方法是LUT函数。这是因为OpenCV库是通过英特尔线程构建块启用多线程的。但是，如果我们需要编写一个简单的图像扫描首选指针方法。迭代器是一种更安全的选择，但是相当慢。在调试模式下，使用动态参考访问方法进行全像扫描是成本最高的。在发布模式下，它可能优于迭代器方法，也可能不优于迭代器方法，但它肯定为此牺牲了迭代器的安全特性。