OpenCV2学习笔记(一）

Mat - 图像的容器

在对图像进行处理时，首先需要将图像载入到内存中，而Mat就是图像在内存中的容器，管理着图像在内存中的数据。Mat是C++ 的一个类，由于OpenCV2中引入了内存自动管理机制，所以不必手动的为Mat开辟内存空间以及手动的释放内存。Mat中包含的数据主要由两个部分构成：矩阵头（矩阵尺寸、存储方法、存储地址等信息）和一个指向存储图像所有像素值的矩阵（根据所选的存储方法不同的矩阵可以是不同的维数）的指针。

在图像处理中，对图像的处理不可能是在一个函数中完成的，这就需要在不同的函数间传递Mat。同时，图像处理的计算量是很大，除非万不得已就不要去传递比较大的Mat。这就要求使用某种机制来实现Mat的快速传递。Mat中主要有矩阵头和一个指向矩阵的指针，矩阵头是一个常数值，但是矩阵保存了图像所有的像素值，通常会比矩阵头大几个数量级，因此传递Mat是主要的消耗是在矩阵复制上。为了解决这个问题，OpenCV中引入了计数机制。每个Mat都有自己的信息头，但是共享同一个矩阵，也就是在传递Mat时，只复制矩阵头和指向矩阵的指针。

    Mat a,c ;
    a = imread("d:\test.jpg",1) ;
    Mat b(a) ; //拷贝构造函数
    a = c ; //复制运算符

上面代码中3个Mat对象a,b,c指向同一个矩阵，由于都指向了同一个矩阵，某一个对象对矩阵进行操作时也会影响到其他对象读取到的矩阵。

多个对象同时使用一个矩阵，那么当不需要该矩阵时，谁来负责清理？简单的回答是，最后一个使用它的对象。通过引用计数机制，无论什么时候Mat对象的信息头被复制了，都会增加矩阵的引用次数加1；反之，当一个Mat的信息头被释放后，引用计数就会被减1；当计数被减到0时，矩阵就会被释放。

当然，有些时候还是需要拷贝矩阵本身的，这时候可以使用clone和 copyTo。通过clone和copyTo创建的Mat，都有自己的矩阵，修改其中一个的矩阵不会对其他的造成影响。

 

访问像素的三种方法

对图像像素值的访问是图像处理最基本的要求，在OpenCV中提供了三种方式来访问图像的像素值。

矩阵在内存中的存储

首先来看一下图像像素值在内存中的保存方式。前面提到，像素值是以矩阵的方式保存的，矩阵的大小取决于图像采用的颜色模型，确切的说是图像的通道数。如果是灰度图像，矩阵是这样的：

矩阵的每一个元素代表一个像素 值。而对多通道图像来说，一个像素值需要多个矩阵元素来存储，矩阵中的列会包含多个子列，其子列数和通道数目相等。以常见的RGB模型来说：

而且，如果内存比较大，图像中的各行各列就可以一行一行的连接起来，形成一个长行。连续存储有助于提升图像的扫描速度，使用iscontinuous来判断矩阵是否是连续存储的。

颜色空间缩减

如果矩阵元素存储的是单通道像素，使用8位无符号来保存每个元素，那么像素可能有256个不同的值。如果是三通道的话，就会用一千六百多种颜色。如此多的颜色在有些时候不是必须的，而且会对算法的性能造成严重的影响。在这种情况下，最常用的做法就是颜色空间的缩减，也就是将现有的颜色空间进行映射，以获得较少的颜色数。例如：颜色值0到9映射为0，10到19映射为10，以此类推。

以简单颜色空间缩减为例，使用OpenCV提供的三种方式来遍历图像像素。将各个颜色值映射关系存储到表中，在对格像素的颜色值进行处理时，直接进行查表。下面是对映射表的初始化：

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

这里将各个像素的颜色值整除以10，然后再乘以10，这样会像上面所说的将0到9的颜色值映射为0，10到19的颜色值映射为10，以此类推。

指针遍历图像 Efficient Way

Mat& scanImageWithPointer(Mat &img , const uchar * const table)
{
    CV_Assert(img.depth () == sizeof(uchar));

    int channels = img.channels() ;

    int rows = img.rows * channels;
    int cols = img.cols ;

    if(img.isContinuous()) {
        cols *= rows ;
        rows = 1 ;
    }

    uchar * p ;
    for(int i = 0 ; i < rows ; i ++){
        p = img.ptr<uchar>(i);
        for(int j = 0 ; j < cols ; j ++){
            p[j] = table[p[j]] ;
        }
    }
    return img ;
}

首先使用断言，只处理使用8位无符号数保存元素值的矩阵。然后在取出举证的行数和列数，如果是多通道的话矩阵是有子列的，用通道数乘以矩阵的行数作为最终遍历时行数。另外，调用isContinuous来判断矩阵在内存中是不是连续存储的。p = img.ptr<uchar>(i); 来获取每一行开始处的指针，然后遍历至改行的末尾。如果是连续存储的，就只需要获取一次每行的开始指针，一路遍历下去即可。

Mat中的data字段会返回指向矩阵第一行第一列的指针，通过可以使用该字段来检查图像是否被载入成功了。当矩阵是连续存储时，也可以通过data来遍历整个图像。

   1:      uchar * p = img.data ;

   2:      for(unsigned int i = 0 ; i < img.rows * img.cols * img.channels() ; i ++)

   3:          *p ++ = table[*p] ;

但是这种代码可读性差，并且进一步操作困难，其在性能上的表现并不明显的优于上面的方法。

迭代遍历图像 Safe Method

Mat& scanImageWithIterator(Mat &img,const uchar * const table)
{
    CV_Assert(img.depth () == sizeof(uchar));

    const int channels = img.channels() ;

    switch (channels){
    case 1:
        {
            MatIterator_<uchar> it,end ;
            end = img.end<uchar>() ;
            for(it = img.begin<uchar>(); it != end ; it ++) {
                *it = table[*it] ;
            }
            break ;
        }
    case 2:
        {
            MatIterator_<Vec3b> it,end ;
            end = img.end<Vec3b>() ;
            for(it = img.begin<Vec3b>(); it != end ; it ++) {
                (*it)[0] = table[(*it)[0]] ;
                (*it)[1] = table[(*it)[1]] ;
                (*it)[2] = table[(*it)[2]] ;
            }
            break ;
        }
    }
    return img ;
}

有两种方式来获取图像矩阵的迭代器

   1:  cv::MatIterator_<cv::Vec3b> it = image.begin<cv::Vec3b>();

   2:  cv::Mat_<cv::Vec3b>::iterator it = image.begin<cv::Vec3b>();

同样的获取图像的常量迭代器也有两种方式

  cv::MatConstIterator_<cv::Vec3b> it = image.begin<cv::Vec3b>();
    cv::Mat_<cv::Vec3b>::const_iterator end = image.end<cv::Vec3b>();

 

另外需要注意的就是，对于多通道图像（例如三通道），每列中有3个uchar元素，也就是一个有3个元素的vector，在OpenCV中使用Vec3b来命名。如果要访问第n个子列，只需要使用[]来操作就可以了。而且，OpenCV迭代中扫过一行的所有列后会自动的跳到下一列，所以在RGB中如果使用uchar来进行迭代不实用Vec3b的话只能获取到B通道的值。

at<>遍历图像

这种方法不推荐用来遍历图像，它主要用来获取或更改图像的中随机元素的。基本用途是用来访问特定的矩阵元素（知道行数和列数）

Mat& scanImageWithAt(Mat& img,const uchar * const table)
{
    CV_Assert(img.depth () == sizeof(uchar));
    const int channels = img.channels() ;

    switch (channels){
    case 1:
        {
            for (int i = 0 ; i < img.rows ; i ++)
                for(int j = 0 ; j < img.cols ; j ++)
                    img.at<uchar>(i,j) = table[img.at<uchar>(i,j)] ;
            break ;
        }
    case 2:
        {
            Mat_<Vec3b> I = img ;
            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]] ;
                }
            }
            img = I ;
            break ;
        }
    }
    return img ;
}

在Mat种保存矩阵元素的数据类型是很重要的，Mat类中也提供了很多的模板方法来处理不同的矩阵元素类型，这种灵活性却会使得简单的代码复杂化，因此就有了Mat_模板类来简化操作。也就是说如果知道了Mat的矩阵元素的数据类型，就可以将其转换为Mat_模板类来简化代码。

前面提到，at<>主要是用来访问矩阵的随机元素的，下面使用该方法来给一张图像添加椒盐噪声。

//n添加椒盐噪声的个数
void salt(Mat& img,int n)
{
    for(int k = 0 ; k < n  ; k ++) {
        int i = rand() % img.rows ;
        int j = rand() % img.cols ;

        if(img.channels() == 1){
            img.at<uchar>(i,j) = 255 ;
        }else if(img.channels() == 3){
            img.at<Vec3b>(i,j)[0] = 255 ;
            img.at<Vec3b>(i,j)[1] = 255 ;
            img.at<Vec3b>(i,j)[2] = 255 ;
        }
    }
}

lenna图片添加椒盐噪声后

这里要提下，在使用imshow将Mat显示到命名窗口时，需要调用waitkey()这个函数下，不然的话在命名窗口显示不出来。

LUT

在图像处理中，对图像的所有像素重新映射是很常见的，在OpenCV中提供一个函数来实现该该操作，不需要去扫描整个图像，operation on array :LUT。

   1:      Mat lookupTable(1,256,CV_8S);

   2:      uchar *p = lookupTable.data ;

   3:      for(int i = 0 ; i < 256 ; i ++)

   4:          p[i] = table[i] ;

   5:   

   6:      Mat result ;

   7:      LUT(img,lookupTable,result) ;

LUT的函数原型

void LUT(InputArray src, InputArray lut, OutputArray dst)

src 输入的8位矩阵

lut 256个元素的查找表，为了应对多通道输入矩阵，查找表要么是单通道（此时，输入矩阵的多个通道使用相同的查找表），要么和输入矩阵有相同的通道数

dst 输出矩阵。和输入矩阵有相同的尺寸和通道