C++学习笔记——Mat类详解及元素的遍历方法

全文部分引自：http://blog.csdn.net/xiaowei_cqu/article/details/7771760
Mat的常见属性

data uchar型的指针。Mat类分为了两个部分：矩阵头和 指向矩阵部分的指针，data就是指向矩阵数据的指针
dims 矩阵的维度，例如5*6矩阵是二维矩阵，则dims=2，三维矩阵dims=3
rows 矩阵的行数
cols 矩阵的列数
size 矩阵的大小，size(cols,rows)，如果矩阵的维数大于2，则是size(-1,-1)
channels 矩阵元素拥有的通道数，例如常见的彩色图像，每一个像素由RGB三部分组成，则channels=3

和Mat相关的几个数据类型

type
表示了矩阵中元素的类型以及矩阵的通道个数，它是一系列的预定义的变量，其命名规则为CV_（位数）+（数据类型）+（通道数）。具体的有以下值：

这里U(unsigned integer)表示的是无符号整数，S(signed integer)，F(float)是浮点数。
例如：CV_16UC2，表示的是元素类型是一个16位的无符号整数，通道为2. C1，C2，C3，C4则表示通道是1,2,3,4
type一般是在创建Mat对象时设定，如果要取得Mat的元素类型，则无需使用type，使用下面的depth

depth
矩阵中元素的一个通道的数据类型，这个值和type是相关的。例如 type为 CV_16SC2，一个2通道的16位的有符号整数。那么，depth则是CV_16S。depth也是一系列的预定义值，
将type的预定义值去掉通道信息就是depth值:
CV_8U CV_8S CV_16U CV_16S CV_32S CV_32F CV_64F

elemSize
矩阵一个元素占用的字节数，例如：type是CV_16SC3，那么elemSize = 3 * 16 / 8 = 6 bytes

elemSize1
矩阵元素一个通道占用的字节数，例如：type是CV_16CS3，那么elemSize1 = 16 / 8 = 2 bytes = elemSize / channels

访问图像中的像素

高效的方法：C操作符【】
最快的是直接用C风格的内存访问操作符【】来访问：

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

一般情况 isContinous为true，运行不会出错，但你可以注释掉那个if，会有访问越界的问题。
这种访问形式就是在每行定义一个指针，然后在内存上直接连续访问。如果整个数组在内存上都是连续存放的，那么只需要定义一个指针就可以访问所有的数据！如单通道的灰度图访问方式如下：

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

安全的方法：迭代器iterator
相比用指针直接访问可能出现越界问题，迭代器绝对是非常安全的方法：

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

这里我们只定义了一个迭代器，用了一个for循环，这是因为在OpenCV里迭代器会访问每一列然后自动跳到下一行，不用管在内存上是否isContinous。另外要注意的是在三通道图像中我们定义的是 格式的迭代器，如果定义成uchar，则只能访问到B即蓝色通道的值。
这种方式虽然安全，但是挺慢的，一会儿就知道了。

更慢的方法：动态地址计算
这种方法在需要连续扫描所有点的应用时并不推荐，因为它更实用与随机访问。这种方法最基本的用途是访问任意的某一行某一列：

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

因为这种方法是为随机访问设计的，所以真的是奇慢无比。。。