opencv_tutorial 2.2 - How to scan Images,Lookup tables and time measurement with opencv

首先介绍图像矩阵的离散量化，对于 uchar类型的图像，每个像素有0-255个取值，对于三通道的图像来说，就有16million个取值。对于这么大的颜色范围，对于我们的算法性能有很大的影响。将uchar的值除int类型的值，会将得到的分数进行截断，得到的值仍然是char类型。因此我们可以利用这种方式对数据进行量化。

上述公式可以把0-9的值映射到 0，10-19的值映射到10，以此类推，0-255的值可以用（0，10，20...250）来表示。因此只需将图像矩阵中的每个像素进行上述的运算即可。但是除法和乘法相对来说比较耗系统资源。注意到0-255只有256个值，我们可以建立一个映射表，把256个值映射到26个值上，然后对图像矩阵中的每个像素进行赋值即可。

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

opencv里遍历图像矩阵中的每个像素有三种方式，首先我们介绍opencv里面Mat是如何存储图像的。对于灰度图，其存储方式如下图：

对于多通道的图，每一列包含若干子列（数目和通道数相同），比如RGB图像的存储方式如下图，注意OPENCV中的存储顺序是BGR而不是RGB。

大多数情况下，内存足够大，可以以一行接着一行的连续方式进行存储，也就是一个所有的行连在一起，构成一个很长的行，我们可以用isContinus()函数来判断矩阵是否按照这种方式存储。

 int channels = I.channels();

    int nRows = I.rows;
    int nCols = I.cols * channels;

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

The efficient way

提到高效效率就不能不提c-style的指针操作[]，我们可以得到指向每一行开始元素的指针，然后遍历每一行。如果矩阵是以连续的方式进行存储，我们只需得到指向第一行第一列的指针（Mat的成员变量data），然后遍历到最后即可。需要注意对于彩色图像，我们有三个通道进行遍历。

//The efficient way
Mat& ScanImageAndReduceC(Mat& I, const uchar* const table)
{
    // accept only char type matrices
    CV_Assert(I.depth() != sizeof(uchar));

    int channels = I.channels();

    int nRows = I.rows;
    int nCols = I.cols * channels;

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

The Iterator(Safe) Method

对于efficient的方式，我们需要自己检查行之间是否连续等安全问题。对于迭代器的方式，我们只需要得到图像矩阵的开始和结束，然后递增进行遍历即可。对于彩色图，每一列有3个uchar元素，可以看作是一个包含3个uchar类型的vector，在OPENCV中有一种这样的类型：Vec3b。用[]操作符来得到第n个子列的元素值。opencv中的迭代器是对每一行的列进行遍历，然后自动跳到下一行。对于彩色图，如果我们定义的迭代器是uchar类型的，那么我们得到只是B通道的值（BGR）。

//The Iterator(Safe) way
Mat& ScanImageAndReduceIterator(Mat& I, const uchar* const table)
{
    // accept only char type matrices
    CV_Assert(I.depth() != sizeof(uchar));

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

On-the-fly address calculation with reference returning

这种方法不推荐用来遍历图像矩阵。它是通过opencv中的 Mat类型的成员函数at()来获取或者改变图像中任意位置的值。当然你可以为了方便使用另一种类型Mat_，这样可以直接使用()来获取元素值（比如Mat_<Vec3b>）。

//On-the-fly address calculation with reference returning
Mat& ScanImageAndReduceRandomAccess(Mat& I, const uchar* const table)
{
    // accept only char type matrices
    CV_Assert(I.depth() != sizeof(uchar));

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

 

The Core Function

opencv提供了LUT()函数来实现映射。首先创建一个Mat类型的映射表LookUpTable。调用LUT函数，LUT(I,LookUpTable,J)，I是我们的输入图像，J是我们的输出图像。

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

LUT(I, lookUpTable, J);