OpenCV大型阵列类型Mat类

一、Mat类

Mat类是C++实现的OpenCV库的核心，表示一个N维度单通或多通道阵列，可以用来存储实数或复数值向量和数组，灰度或彩色图像，向量场，张量及直方图(当然高纬度的直方图存储在稀疏Mat类更合适)，OpenCV是一个图像处理库。它包含大量的图像处理功能。为了解决计算上的挑战，大多数时候你最终会使用库的多个功能。因此，将图像传递给函数是一种常见的做法。我们不应该忘记，我们正在讨论图像处理算法，这些算法往往计算量很大。我们想要做的最后一件事是通过制作不必要的大型图像副本来进一步降低程序的速度。

为了解决这个问题，OpenCV使用了一个引用计数系统。这个想法是，每个Mat对象都有自己的头部，但是矩阵可以通过让它们的矩阵指针指向相同的地址而在它们的两个实例之间共享。而且，复制操作符只会复制标题和指向大矩阵的指针，而不是数据本身。

1.1创建一个Mat对象

从上可以看出Mat基本上是一个包含两个数据部分的类：矩阵头（包含矩阵大小，用于存储的方法，存储矩阵的地址等信息）以及包含像素值（取决于选择用于存储的方法的任何维度）。矩阵头部大小是恒定的，但是矩阵本身的大小可能随着图像而变化，并且通常比数量级大。

创建一个Mat类型对象可以没有大小和数据类型，然后通过成员函数create()来分配指定，例如创建一个二维数组，可以使用create(int rows, int cols, types)备注：仅限于二维数组，第三个参数类型既指定了元素的类型又说明了通道数，这些类型都定义在矩阵头中，格式为：CV_{8U,16S,16U,32S,32F,64F}C{1,2,3}，然后通过setTo()函数设定每个通道上的具体数值；

通常定义创建一个Mat类型的对象可以通过构造函数在创建矩阵时即分配内存，其中一个构造函数的参数与create()函数参数相同；

//演示示例：创建一个Mat对象数组
#include <opencv2/highgui.hpp>
#include <opencv2/core.hpp>
#include <iostream>

using namespace std;
using namespace cv;

int main()
{
    Mat array_test;
    array_test.create( 3, 2, CV_32FC3 );       //create array header
    array_test.setTo(Scalar(1.0f,2.0f,3.0f));   //set array data

    cout << "array_test = " << endl << array_test << endl;
    //如下使用构造函数等同上面分布创建
    Mat array_test_con( 3, 2, CV_32FC3, Scalar(1.0f,2.0f,3.0f) );
    cout << "array_test_con = " << endl << array_test_con << endl;
    return 0;
}

1.2 Mat类对象的数据和Mat类矩阵头

如上叙述，为了解决图像处理繁杂计算问题，OpenCV使用了一个引用计数系统。这个想法是，针对图像的数据，每个Mat对象都有自己的头部相对应，通过让它们的矩阵指针指向相同的地址而在它们的两个实例对象之间共享。而且，复制操作符只会复制标题和指向大矩阵的指针，而不是数据本身。

//演示示例：矩阵头Array Header和矩阵数据Array data关系
#include <opencv2/highgui.hpp>
#include <opencv2/core.hpp>
#include <iostream>
using namespace std;
using namespace cv;
 
int main()
{
    Mat A( 2, 2, CV_8UC3, Scalar(10, 20, 30));
 
    cout << "A = " << endl << A << endl;
 
    cout << endl;
 
    Mat B(A);
    cout << "B = " << endl << B << endl;
 
    cout << endl;
 
    Mat C = A;
    cout << "C = " << endl << C << endl;
 
    cout << endl << "After Mat algebra..." << endl;
 
    Mat A1( 2, 2, CV_8UC3, Scalar(1, 2, 3));
 
    A = A +A1;
 
    cout << "A = " << endl << A << endl;
    cout << "B = " << endl << B << endl;
    cout << "C = " << endl << C << endl;
 
    return 0;
}

上述所有对象最后指向相同的单一数据矩阵。然而，它们的标头是不同的，并且使用它们中的任何一个进行修改也会影响所有其他标签。实际上，不同的对象只是为相同的底层数据提供不同的访问方法。不过，它们的矩阵头部分是真正相互独立的。这样，可以创建一个仅包含矩阵数据的一部分的矩阵对象。例如，要在图像中创建感兴趣的区域（ROI），您只需创建一个带有新边界的新矩阵头：

#include <opencv2/highgui.hpp>
#include <opencv2/core.hpp>
#include <iostream>

using namespace std;
using namespace cv;

int main()
{
    Mat A( 4, 4, CV_8UC3, Scalar(10, 20, 30));
    cout << "A = " << endl << A << endl;

    cout << endl;

    Mat B(A);
    cout << "B = " << endl << B << endl;

    cout << endl;

    Mat C = A;

    cout << "C = " << endl << C << endl;

    cout << endl << "After Mat algebra..." << endl;

    Mat A1( 4, 4, CV_8UC3, Scalar(1, 2, 3));

    A = A +A1;

    cout << "A = " << endl << A << endl;
    cout << "B = " << endl << B << endl;
    cout << "C = " << endl << C << endl;
    //在图像中创建感兴趣的区域（ROI）
    Mat D(A, Rect(0,0,2,2));
    cout << "D = " << endl << D << endl;

    D.setTo(Scalar(1, 2, 3));
    cout << "A = " << endl << A << endl;

    //创建一个带有新边界的新矩阵头
    Mat E = A(Range::all(), Range(2,3));
    cout << "E = " << endl << E << endl;

    E.setTo(Scalar(7, 8, 9));
    cout << "A = " << endl << A << endl;

    return 0;
}

当想复制矩阵本身，所以OpenCV提供了cv :: Mat :: clone（）和cv :: Mat :: copyTo（）函数。

#include <opencv2/highgui.hpp>
#include <opencv2/core.hpp>
#include <iostream>

using namespace std;
using namespace cv;

int main()
{
    Mat A( 4, 4, CV_8UC3, Scalar(10, 20, 30));
    cout << "A = " << endl << A << endl;

    cout << endl;

    Mat B(A);
    cout << "B = " << endl << B << endl;

    cout << endl;
 
    Mat C = A;
    cout << "C = " << endl << C << endl;

    cout << endl << "After Mat algebra..." << endl;

    Mat A1( 4, 4, CV_8UC3, Scalar(1, 2, 3));

    A = A +A1;

    cout << "A = " << endl << A << endl;
    cout << "B = " << endl << B << endl;
    cout << "C = " << endl << C << endl;
 
    Mat D(A, Rect(0,0,2,2));      //拷贝构造函数中Rect仅适用于二维矩阵
    cout << "D = " << endl << D << endl;

    D.setTo(Scalar(1, 2, 3));
    cout << "A = " << endl << A << endl;

    Mat E = A(Range::all(), Range(2,3)); //拷贝构造函数中Range 仅适用于二维矩阵
    cout << "E = " << endl << E << endl;
    E.setTo(Scalar(7, 8, 9));
    cout << "A = " << endl << A << endl;

    Mat F = A.clone();
    cout << "F = " << endl << F << endl;

    Mat G;
    A.copyTo(G);
    cout << "G = " << endl << G << endl;

    A.setTo(Scalar(10, 20, 30));
    cout << "A = " << endl << A << endl;
    cout << "F = " << endl << F << endl;
    cout << "G = " << endl << G << endl;
    return 0;
}

二、SpareMat类

针对稀疏矩阵，OpenCV定义了独立的数据结构SpareMat类。稀疏矩阵仅存储非零元素，避免了资源上的浪费，即将节省很多空间尤其针对元素存在许多零元素的数据， 使用稀疏矩阵的常用案例是直方图，对于直方图，大多数数据是零，存储这些零元素又是没有必要的。

三、数组常用操作

3.1两数组元素加权相加运算 AddWeighted()

void addWeighted(
InputArray src1,   //第一个输入矩阵
double alpha,      //第一个输入矩阵的权重
InputArray src2,   //第二个输入的矩阵
double beta,       //第二个输入矩阵的权重
double gamma,      //权重相加的偏移量
OutputArray dst,   //输出的结果
int dtype = -1)    //输出结果的类型

即加权的表达式如下：

Dst = α·src1 + β·src2 + γ

该函数可以用来实现alhpa融合(线性融合)，即将公式中的γ设置为0，则alpha融合的公式演变为：

Dst = α·src1 + β·src2 = α·src1 + （1-α）·src2

函数中需要两个源图像src1和src2，这两个源图像可以是任意类型的像素(灰度，彩色)，但只要他们属于同一类型一致即可，所输出的图像也是与源图像的像素类型一致；

注意：源图像可以是不同尺寸，但融合的操作区域（即感兴趣区域ROI）必须尺寸统一，否则OpenCV会产生错误；

//alpha融合演示示例
#include <opencv2/highgui.hpp>
#include <iostream>

using namespace std;
using namespace cv;

int main()
{
     //读取图像imread()显示图像imshow()函数待后续
     Mat src1 = imread("D:\workspace-qt\OpenCV\LinuxLogo.jpg");
     if(src1.empty()) {cout << "Can't Load the image..." << endl; return -1;}
     Mat src2 = imread("D:\workspace-qt\OpenCV\WindowsLogo.jpg");
     if(src2.empty()) {cout << "Can't Load the image..." << endl; return -1;}
     Mat dst;
     addWeighted(src1,0.5,src2,0.5,0.0,dst,-1);
     imshow("Alpha",dst);
     waitKey(0);
     return 0;
} 

备注：在加权融合图像的便宜参数γ方面，函数提供了更大的灵活性，一般而言，使α和β不小于0且相加不大于1，那么γ的设定取决于加权后图像像素所要调整到的平均值或最大值。

     

3.2 色彩空间转换 cvColor()

void cvtColor( InputArray src, OutputArray dst, int code, int dstCn = 0 )

输入图像数组可以是8位数组，16位无符号类型数组，或者32位浮点类型，而输出图像数组与输入数组保持着相同的尺寸大小和深度，转换操作由参数code来实现，dstCn表示输出图像的通道数，默认设为0意味着输出数组自动由源图像src和转换规则code作用后自动获取；

enum ColorConversionCodes {
    COLOR_BGR2BGRA     = 0, //!< add alpha channel to RGB or BGR image
    COLOR_RGB2RGBA     = COLOR_BGR2BGRA,

    COLOR_BGRA2BGR     = 1, //!< remove alpha channel from RGB or BGR image
    COLOR_RGBA2RGB     = COLOR_BGRA2BGR,

    COLOR_BGR2RGBA     = 2, //!< convert between RGB and BGR color spaces (with or without alpha channel)
    COLOR_RGB2BGRA     = COLOR_BGR2RGBA,

    COLOR_RGBA2BGR     = 3,
    COLOR_BGRA2RGB     = COLOR_RGBA2BGR,

    COLOR_BGR2RGB      = 4,
    COLOR_RGB2BGR      = COLOR_BGR2RGB,

    COLOR_BGRA2RGBA    = 5,
    COLOR_RGBA2BGRA    = COLOR_BGRA2RGBA,

    COLOR_BGR2GRAY     = 6, //!< convert between RGB/BGR and grayscale, @ref color_convert_rgb_gray "color conversions"
    COLOR_RGB2GRAY     = 7,
    COLOR_GRAY2BGR     = 8,
    COLOR_GRAY2RGB     = COLOR_GRAY2BGR,
    COLOR_GRAY2BGRA    = 9,
    COLOR_GRAY2RGBA    = COLOR_GRAY2BGRA,
    COLOR_BGRA2GRAY    = 10,
    COLOR_RGBA2GRAY    = 11,

    COLOR_BGR2BGR565   = 12, //!< convert between RGB/BGR and BGR565 (16-bit images)
    COLOR_RGB2BGR565   = 13,
    COLOR_BGR5652BGR   = 14,
    COLOR_BGR5652RGB   = 15,
    COLOR_BGRA2BGR565  = 16,
    COLOR_RGBA2BGR565  = 17,
    COLOR_BGR5652BGRA  = 18,
    COLOR_BGR5652RGBA  = 19,

    COLOR_GRAY2BGR565  = 20, //!< convert between grayscale to BGR565 (16-bit images)
    COLOR_BGR5652GRAY  = 21,

    COLOR_BGR2BGR555   = 22,  //!< convert between RGB/BGR and BGR555 (16-bit images)
    COLOR_RGB2BGR555   = 23,
    COLOR_BGR5552BGR   = 24,
    COLOR_BGR5552RGB   = 25,
    COLOR_BGRA2BGR555  = 26,
    COLOR_RGBA2BGR555  = 27,
    COLOR_BGR5552BGRA  = 28,
    COLOR_BGR5552RGBA  = 29,

    COLOR_GRAY2BGR555  = 30, //!< convert between grayscale and BGR555 (16-bit images)
    COLOR_BGR5552GRAY  = 31,

    COLOR_BGR2XYZ      = 32, //!< convert RGB/BGR to CIE XYZ, @ref color_convert_rgb_xyz "color conversions"
    COLOR_RGB2XYZ      = 33,
    COLOR_XYZ2BGR      = 34,
    COLOR_XYZ2RGB      = 35,

    COLOR_BGR2YCrCb    = 36, //!< convert RGB/BGR to luma-chroma (aka YCC), @ref color_convert_rgb_ycrcb "color conversions"
    COLOR_RGB2YCrCb    = 37,
    COLOR_YCrCb2BGR    = 38,
    COLOR_YCrCb2RGB    = 39,

    COLOR_BGR2HSV      = 40, //!< convert RGB/BGR to HSV (hue saturation value), @ref color_convert_rgb_hsv "color conversions"
    COLOR_RGB2HSV      = 41,

    COLOR_BGR2Lab      = 44, //!< convert RGB/BGR to CIE Lab, @ref color_convert_rgb_lab "color conversions"
    COLOR_RGB2Lab      = 45,

    COLOR_BGR2Luv      = 50, //!< convert RGB/BGR to CIE Luv, @ref color_convert_rgb_luv "color conversions"
    COLOR_RGB2Luv      = 51,
    COLOR_BGR2HLS      = 52, //!< convert RGB/BGR to HLS (hue lightness saturation), @ref color_convert_rgb_hls "color conversions"
    COLOR_RGB2HLS      = 53,

    COLOR_HSV2BGR      = 54, //!< backward conversions to RGB/BGR
    COLOR_HSV2RGB      = 55,

    COLOR_Lab2BGR      = 56,
    COLOR_Lab2RGB      = 57,
    COLOR_Luv2BGR      = 58,
    COLOR_Luv2RGB      = 59,
    COLOR_HLS2BGR      = 60,
    COLOR_HLS2RGB      = 61,

    COLOR_BGR2HSV_FULL = 66, //!<
    COLOR_RGB2HSV_FULL = 67,
    COLOR_BGR2HLS_FULL = 68,
    COLOR_RGB2HLS_FULL = 69,

    COLOR_HSV2BGR_FULL = 70,
    COLOR_HSV2RGB_FULL = 71,
    COLOR_HLS2BGR_FULL = 72,
    COLOR_HLS2RGB_FULL = 73,

    COLOR_LBGR2Lab     = 74,
    COLOR_LRGB2Lab     = 75,
    COLOR_LBGR2Luv     = 76,
    COLOR_LRGB2Luv     = 77,

    COLOR_Lab2LBGR     = 78,
    COLOR_Lab2LRGB     = 79,
    COLOR_Luv2LBGR     = 80,
    COLOR_Luv2LRGB     = 81,

    COLOR_BGR2YUV      = 82, //!< convert between RGB/BGR and YUV
    COLOR_RGB2YUV      = 83,
    COLOR_YUV2BGR      = 84,
    COLOR_YUV2RGB      = 85,

    //! YUV 4:2:0 family to RGB
    COLOR_YUV2RGB_NV12  = 90,
    COLOR_YUV2BGR_NV12  = 91,
    COLOR_YUV2RGB_NV21  = 92,
    COLOR_YUV2BGR_NV21  = 93,
    COLOR_YUV420sp2RGB  = COLOR_YUV2RGB_NV21,
    COLOR_YUV420sp2BGR  = COLOR_YUV2BGR_NV21,

    COLOR_YUV2RGBA_NV12 = 94,
    COLOR_YUV2BGRA_NV12 = 95,
    COLOR_YUV2RGBA_NV21 = 96,
    COLOR_YUV2BGRA_NV21 = 97,
    COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21,
    COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21,

    COLOR_YUV2RGB_YV12  = 98,
    COLOR_YUV2BGR_YV12  = 99,
    COLOR_YUV2RGB_IYUV  = 100,
    COLOR_YUV2BGR_IYUV  = 101,
    COLOR_YUV2RGB_I420  = COLOR_YUV2RGB_IYUV,
    COLOR_YUV2BGR_I420  = COLOR_YUV2BGR_IYUV,
    COLOR_YUV420p2RGB   = COLOR_YUV2RGB_YV12,
    COLOR_YUV420p2BGR   = COLOR_YUV2BGR_YV12,

    COLOR_YUV2RGBA_YV12 = 102,
    COLOR_YUV2BGRA_YV12 = 103,
    COLOR_YUV2RGBA_IYUV = 104,
    COLOR_YUV2BGRA_IYUV = 105,
    COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV,
    COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV,
    COLOR_YUV420p2RGBA  = COLOR_YUV2RGBA_YV12,
    COLOR_YUV420p2BGRA  = COLOR_YUV2BGRA_YV12,

    COLOR_YUV2GRAY_420  = 106,
    COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420,
    COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420,
    COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420,
    COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420,
    COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420,
    COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420,
    COLOR_YUV420p2GRAY  = COLOR_YUV2GRAY_420,

    //! YUV 4:2:2 family to RGB
    COLOR_YUV2RGB_UYVY = 107,
    COLOR_YUV2BGR_UYVY = 108,
    //COLOR_YUV2RGB_VYUY = 109,
    //COLOR_YUV2BGR_VYUY = 110,
    COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY,
    COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY,
    COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY,
    COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY,

    COLOR_YUV2RGBA_UYVY = 111,
    COLOR_YUV2BGRA_UYVY = 112,
    //COLOR_YUV2RGBA_VYUY = 113,
    //COLOR_YUV2BGRA_VYUY = 114,
    COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY,
    COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY,
    COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY,
    COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY,

    COLOR_YUV2RGB_YUY2 = 115,
    COLOR_YUV2BGR_YUY2 = 116,
    COLOR_YUV2RGB_YVYU = 117,
    COLOR_YUV2BGR_YVYU = 118,
    COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2,
    COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2,
    COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2,
    COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2,

    COLOR_YUV2RGBA_YUY2 = 119,
    COLOR_YUV2BGRA_YUY2 = 120,
    COLOR_YUV2RGBA_YVYU = 121,
    COLOR_YUV2BGRA_YVYU = 122,
    COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2,
    COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2,
    COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2,
    COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2,

    COLOR_YUV2GRAY_UYVY = 123,
    COLOR_YUV2GRAY_YUY2 = 124,
    //CV_YUV2GRAY_VYUY    = CV_YUV2GRAY_UYVY,
    COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY,
    COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY,
    COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2,
    COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2,
    COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2,

    //! alpha premultiplication
    COLOR_RGBA2mRGBA    = 125,
    COLOR_mRGBA2RGBA    = 126,

    //! RGB to YUV 4:2:0 family
    COLOR_RGB2YUV_I420  = 127,
    COLOR_BGR2YUV_I420  = 128,
    COLOR_RGB2YUV_IYUV  = COLOR_RGB2YUV_I420,
    COLOR_BGR2YUV_IYUV  = COLOR_BGR2YUV_I420,

    COLOR_RGBA2YUV_I420 = 129,
    COLOR_BGRA2YUV_I420 = 130,
    COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420,
    COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420,
    COLOR_RGB2YUV_YV12  = 131,
    COLOR_BGR2YUV_YV12  = 132,
    COLOR_RGBA2YUV_YV12 = 133,
    COLOR_BGRA2YUV_YV12 = 134,

    //! Demosaicing
    COLOR_BayerBG2BGR = 46,
    COLOR_BayerGB2BGR = 47,
    COLOR_BayerRG2BGR = 48,
    COLOR_BayerGR2BGR = 49,

    COLOR_BayerBG2RGB = COLOR_BayerRG2BGR,
    COLOR_BayerGB2RGB = COLOR_BayerGR2BGR,
    COLOR_BayerRG2RGB = COLOR_BayerBG2BGR,
    COLOR_BayerGR2RGB = COLOR_BayerGB2BGR,

    COLOR_BayerBG2GRAY = 86,
    COLOR_BayerGB2GRAY = 87,
    COLOR_BayerRG2GRAY = 88,
    COLOR_BayerGR2GRAY = 89,

    //! Demosaicing using Variable Number of Gradients
    COLOR_BayerBG2BGR_VNG = 62,
    COLOR_BayerGB2BGR_VNG = 63,
    COLOR_BayerRG2BGR_VNG = 64,
    COLOR_BayerGR2BGR_VNG = 65,

    COLOR_BayerBG2RGB_VNG = COLOR_BayerRG2BGR_VNG,
    COLOR_BayerGB2RGB_VNG = COLOR_BayerGR2BGR_VNG,
    COLOR_BayerRG2RGB_VNG = COLOR_BayerBG2BGR_VNG,
    COLOR_BayerGR2RGB_VNG = COLOR_BayerGB2BGR_VNG,

    //! Edge-Aware Demosaicing
    COLOR_BayerBG2BGR_EA  = 135,
    COLOR_BayerGB2BGR_EA  = 136,
    COLOR_BayerRG2BGR_EA  = 137,
    COLOR_BayerGR2BGR_EA  = 138,

    COLOR_BayerBG2RGB_EA  = COLOR_BayerRG2BGR_EA,
    COLOR_BayerGB2RGB_EA  = COLOR_BayerGR2BGR_EA,
    COLOR_BayerRG2RGB_EA  = COLOR_BayerBG2BGR_EA,
    COLOR_BayerGR2RGB_EA  = COLOR_BayerGB2BGR_EA,

    //! Demosaicing with alpha channel
    COLOR_BayerBG2BGRA = 139,
    COLOR_BayerGB2BGRA = 140,
    COLOR_BayerRG2BGRA = 141,
    COLOR_BayerGR2BGRA = 142,

    COLOR_BayerBG2RGBA = COLOR_BayerRG2BGRA,
    COLOR_BayerGB2RGBA = COLOR_BayerGR2BGRA,
    COLOR_BayerRG2RGBA = COLOR_BayerBG2BGRA,
    COLOR_BayerGR2RGBA = COLOR_BayerGB2BGRA,

    COLOR_COLORCVT_MAX  = 143
};

备注：色彩空间转换都用到如下约定：

8位图像的范围：0~255
16位图像的范围：0~65536
浮点数的范围：0.0~1.0
黑白图像转换位彩色图像时，最终图形与黑白图像的通道数相同
彩色图像转换为灰度图像时，灰度值计算使用加权公式：
Y= 0.299R+0.587G+0.114B

针对HSV色彩模式或者HLS色彩模式来说色调范围通常Rang(0,360)；

当HSV色彩模式以8位图像形式输出时，色调应处以2，才能不出现问题； 

//RGB转Gray演示示例
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <iostream>

using namespace std;
using namespace cv;

int main()
{
    Mat src2 = imread("D:\workspace-qt\OpenCV\WindowsLogo.jpg");
    if(src2.empty()) {cout << "Can't Load the image..." << endl; return -1;}

    Mat dst_gray;
    cvtColor(src2,dst_gray,CV_BGR2GRAY);
    imshow("Alpha",dst_gray);
    waitKey(0);
    return 0;
}

3.3 图像翻转flip()

void flip(InputArray src, OutputArray dst, int flipCode)

将图像绕X轴或者Y周或绕X轴Y轴上同时旋转，取决于参数flipCode的设置

图像绕X轴旋转：flipCode = 0；
图像绕Y轴旋转：flipCode = 1；
图像绕X轴和Y轴同时旋转：flipCode = -1；

常用于图像坐标原点在左上角和左下角的变换时使用，尤其是进行视频处理所进行的图像格式变化；

#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <iostream>

using namespace std;
using namespace cv;

int main()
{
    Mat src = imread("D:\workspace-qt\OpenCV\WindowsLogo.jpg");
    if(src.empty()) {cout << "Can't Load the image..." << endl; return -1;}

    imshow("src",src);
    Mat dst_x, dst_y, dst_x_y;
    flip(src,dst_x,0);
    flip(src,dst_y,1);
    flip(src,dst_x_y,-1);
    imshow("flipCode = 0",dst_x);
    imshow("flipCode = 1",dst_y);
    imshow("flipCode = -1",dst_x_y);
    waitKey(0);
    return 0;
}