OpenCV C++ 学习笔记（五）：颜色空间转换、数值类型转换、图像混合、图像缩放

文章目录

• 颜色空间转换cvtColor
• 通道分离split
• 通道合并merge
• 数值类型转换convertTo
• 图片混合addWeighted
• 图片缩放resize

---

颜色空间转换cvtColor

cvtColor 是 OpenCV 中用于将图像从一种色彩空间转换为另一种色彩空间的函数。它非常适用于各种图像处理任务，如灰度化、颜色空间转换等。

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

• src：源图像
• dst：输出图片
• code：转换码

cv::Mat gray;
    // 将BGR图像转换为灰度图像
    cv::cvtColor(src, gray, cv::COLOR_BGR2GRAY);

将RGB空间转换到灰度空间的通道融合比例0.299R + 0.587G + 0.114B

mpRawData = new unsigned short[width * height];
	for (int i = 0; i < count; ++i) {
		std::swap(mvScreenData[i * 3], mvScreenData[i * 3 + 2]);
		//0.299R + 0.587G + 0.114B
		mpRawData[i] = (unsigned short)((0.299 * image[i * 3] + 0.587 * image[i * 3 + 1] + 0.114 * image[i * 3 + 2]) * 255);
	}

---

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

通道分离split

split 函数用于将一个多通道数组分割成多个单通道数组。这对于单独处理图像的每个颜色通道（例如在RGB图像中处理红色、绿色和蓝色通道）非常有用。

CV_EXPORTS void split(const Mat& src, Mat* mvbegin);

• src：输入图像
• mvbegin：分离后的Mat数组的地址

CV_EXPORTS_W void split(InputArray m, OutputArrayOfArrays mv);

• m：输入图像
• mv：分离后的的Mat数组，可以使用STL容器vector。

std::vector<cv::Mat> channels;
cv::split(img, channels); // 分割为B,G,R三个单通道

// 现在channels[0]是蓝色通道, channels[1]是绿色通道, channels[2]是红色通道

通道合并merge

merge 函数则是做相反的操作，它接收多个单通道数组，并将它们组合成一个多通道数组。这在你独立处理完图像的各个通道后需要重新组合时特别有用。

CV_EXPORTS void merge(const Mat* mv, size_t count, OutputArray dst);

• mv：合并的图像数组的地址
• count：合并的图像的个数
• dst：输出图片

CV_EXPORTS_W void merge(InputArrayOfArrays mv, OutputArray dst);

• mv：欲合并的图像数组，可以使用STL容器vector。
• dst：输出图片

std::vector<cv::Mat> channels;
cv::split(img, channels); // 分割为B,G,R三个单通道

// 假设对某些通道进行了处理...

cv::Mat mergedImg;
cv::merge(channels, mergedImg); // 合并回多通道图像

数值类型转换convertTo

用于将矩阵的数值类型转换为另一种类型。这在图像处理中特别有用，比如当你需要将图像数据从一种位深度转换到另一种（例如从 8 位转换到 32 位浮点数），或者你需要调整数值范围时。

void Mat::convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;

src.convertTo(dst, type, alpha, beta);

• dst: 输出矩阵，它将存储转换后的结果。其大小和通道数与输入矩阵相同。
• type: 指定目标矩阵的数据类型（如 CV_8U, CV_16U, CV_32F 等）。如果指定为 -1，则输出矩阵与输入矩阵具有相同类型。
• alpha: 可选的比例因子，应用于源数组元素。默认值为 1。
• beta: 可选的增量，添加到缩放值。默认值为 0。

// 加载灰度图像
cv::Mat src = cv::imread("path/to/image.jpg", cv::IMREAD_GRAYSCALE);

// 目标图像
cv::Mat dst;

// 转换类型并调整数值范围
src.convertTo(dst, CV_32F, 1.0/255, 0); // 将像素值映射到 [0, 1] 区间

在这个例子中，我们首先加载了一张灰度图像。然后使用 convertTo 方法将图像从 CV_8U（默认的 8 位无符号整数格式）转换为 CV_32F（32 位浮点数），同时通过设置 alpha 参数为 1.0/255 来将像素值从 [0, 255] 映射到 [0, 1]。

不能进行原地运算

图片混合addWeighted

CV_EXPORTS_W void addWeighted(
	InputArray src1, double alpha, 
	InputArray src2, double beta, 
	double gamma, 
	OutputArray dst, 
	int dtype = -1
);

• src1 第一个输入图像（Mat 类型）
• alpha 第一个图像的权重系数（通常范围是 0~1）
• src2 第二个输入图像，必须与 src1 大小和类型相同
• beta 第二个图像的权重系数
• gamma 偏移量（scalar），可理解为亮度调节项
• dst 输出图像，与输入图像大小相同
• dtype 输出图像的数据深度，默认为 -1，表示自动匹配

计算公式

dst = src1 * alpha + src2 * beta + gamma;

所有运算都是逐像素进行的。

如果你想用作"图像叠加"或"图像混合"，可以设置 gamma = 0。

通常会设置 alpha + beta = 1 来保持图像亮度一致。

示例：图像叠加/融合

#include <opencv2/opencv.hpp>

int main() {
    // 加载两张图像（需尺寸一致）
    cv::Mat img1 = cv::imread("image1.jpg");
    cv::Mat img2 = cv::imread("image2.jpg");

    if (img1.empty() || img2.empty()) {
        std::cout << "Could not open or find the images!" << std::endl;
        return -1;
    }

    cv::Mat blended;
    // 按照权重融合图像
    cv::addWeighted(img1, 0.7,   // img1 权重 0.7
                    img2, 0.3,   // img2 权重 0.3
                    0.0,         // gamma = 0
                    blended);

    // 显示结果
    cv::imshow("Blended Image", blended);
    cv::waitKey(0);
    return 0;
}

两张图像必须具有相同的大小和通道数 （可以是单通道或多通道）。如果只想使用一张图并调整其亮度，可以让 src2 = Mat::zeros(...)。

可以用来实现：

• 图像透明度混合（如半透明水印）
• 图像渐变过渡
• 图像增强（调整亮度对比度）

---

示例：添加水印（透明文字或图像）

cv::Mat base = cv::imread("background.jpg");
cv::Mat overlay;
base.copyTo(overlay); // 创建副本

// 在 overlay 上绘制半透明矩形或文字
cv::rectangle(overlay, cv::Rect(50,50,200,100), cv::Scalar(255,255,255), -1);
cv::addWeighted(base, 0.6, overlay, 0.4, 0, base);

图片缩放resize

CV_EXPORTS_W void resize( 
	InputArray src, OutputArray dst,
	Size dsize, double fx = 0, double fy = 0,
	int interpolation = INTER_LINEAR 
);

• src 输入图像 (Mat)
• dst 输出图像 (Mat)
• dsize 输出图像的尺寸（宽 x 高），如 cv::Size(640, 480)
• fx 横向缩放比例（宽度方向），如果设定了 dsize 可为 0
• fy 纵向缩放比例（高度方向）
• interpolation 插值方法（决定缩放质量），常见选项如下：
  • cv::INTER_NEAREST 最近邻插值（速度快，效果差）
  • cv::INTER_LINEAR 双线性插值（默认，平衡速度与质量）
  • cv::INTER_CUBIC 双三次插值（更高质量，速度慢）
  • cv::INTER_AREA 区域插值（适合缩小图像）

放大建议使用 INTER_CUBIC 或 INTER_LINEAR

缩小建议使用 INTER_AREA

示例

方法一：指定目标尺寸

#include <opencv2/opencv.hpp>

int main() {
    cv::Mat src = cv::imread("image.jpg");
    if (src.empty()) return -1;

    cv::Mat dst;
    cv::resize(src, dst, cv::Size(640, 480)); // 直接指定尺寸

    cv::imshow("Resized", dst);
    cv::waitKey(0);
    return 0;
}

方法二：按比例缩放（推荐灵活使用）

cv::Mat src = cv::imread("image.jpg");
cv::Mat dst;

double scale = 0.5; // 缩小为原来的一半
cv::resize(src, dst, cv::Size(), scale, scale, cv::INTER_AREA);

• cv::Size() 表示自动计算输出大小。
• 这种方式适合动态缩放、响应式显示等场景。

保持宽高比：

如果你只想指定一个维度（比如宽度），另一个维度按比例计算：

int newWidth = 300;
double aspectRatio = static_cast<double>(src.cols) / src.rows;
int newHeight = static_cast<int>(newWidth / aspectRatio);

cv::resize(src, dst, cv::Size(newWidth, newHeight));