OpenCV学习笔记【六】图像的混合操作，对比度和亮度调整，离散傅里叶变换-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_42132144/article/details/83147825

本文深入探讨了图像处理中的关键概念和技术，包括图像混合、多通道混合、对比度和亮度调整，以及离散傅里叶变换。通过具体的代码示例，展示了如何在OpenCV中实现这些操作，适用于图像叠加、混合以及频谱分析。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线性混合是一种典型的二元（两个输入）的像素操作，它的理论公式如下：

$g(x)=(1-a)f_{a}(x)+af_{3}(x)$

我们通过在范围0到1之间改变alpha值，来对两幅图像或两段视频产生时间上的画面叠化。下面给出代码示例：

//ROI区域图像叠加&图像混合
#include<opencv2/opencv.hpp>
#include"opencv2/imgproc/imgproc.hpp"
#include<iostream>
using namespace cv;
using namespace std;
bool ROI_ADDImage()
{//读入图像
	Mat srcImage1 = imread("group.jpg");
	Mat logoImage = imread("2.jpg");
	if (!srcImage1.data) { printf("读取srcImage错误~! \n"); return false; }
	if (!logoImage.data) { printf("读取logoImage错误~! \n"); return false; }
	//定义一个Mat类型并给其设定ROI区域
	Mat imageROI = srcImage1(Rect(300, 250, logoImage.cols, logoImage.rows));
	//加载掩模（必须是灰度图）
	Mat mask = imread("2.jpg",0);
	logoImage.copyTo(imageROI, mask);//将掩模复制到ROI
	//显示结果
	namedWindow("<1>利用ROI实现图像叠加示例窗口");
	imshow("<1>利用ROI实现图像叠加示例窗口", srcImage1);
	return true;
}
bool LinearBlending()
{//定义一些局部变量
	double alphaValue = 0.5;
	double betaValue;
	Mat srcImage2, srcImage3, dstImage;
	//读取图像（两幅图需为同样的类型和尺寸）
	srcImage2 = imread("mogu.jpg");
	srcImage3 = imread("rain.jpg");
	if (!srcImage2.data) { printf("读取srcImage2错误~! \n"); return false; }
	if (!srcImage3.data) { printf("读取srcImage3错误~! \n"); return false; }
	//做图像混合加权操作
	betaValue = (1.0 - alphaValue);
	addWeighted(srcImage2, alphaValue, srcImage3, betaValue, 0.0, dstImage);
	//创建并显示原图窗口
	namedWindow("<2>线形混合窗口【原图】",1);
	imshow("<2>线形混合窗口【原图】", srcImage2);
	namedWindow("<3>线形混合窗口【原图】", 1);
	imshow("<3>线形混合窗口【原图】", dstImage);
	return true;
}
bool ROI_LinearBlending()
{//读取图像
	Mat srcImage4 = imread("dota_pa.jpg", 1);
	Mat logoImage = imread("dota_logo.jpg");
	if (!srcImage4.data) { printf("读取srcImage4错误~！ \n"); return false; }
	if (!logoImage.data) { printf("读取logoImage错误~！ \n"); return false; }
	//定义一个Mat类型并给其设定ROI区域
	Mat imageROI;
	imageROI = srcImage4(Rect(200, 250, logoImage.cols, logoImage.rows));
	//将logo加到原图上
	addWeighted(imageROI, 0.5, logoImage, 0.3, 0., imageROI);
	//显示结果
	namedWindow("<4>区域线性图像混合示例窗口");
	imshow("<4>区域线性图像混合示例窗口",srcImage4);
	return true;
}
int main()
{
	if (ROI_ADDImage()&&LinearBlending()&&ROI_LinearBlending())
		cout << endl << "运行成功";
	waitKey(0);
	return 0;
}

效果图如下：

多通道混合

//多通道图像混合
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<iostream>
using namespace cv;
using namespace std;
//全局函数声明
bool MultiChannelBlending();
//void ShowHelpText();
//main函数
int main()
{
	system("color 9F");
	if (MultiChannelBlending())
	{
		cout << endl << "\n运行成功，得出了需要的图像";
	}
	waitKey(0);
	return 0;
}
bool MultiChannelBlending()
{//定义相关变量
	Mat srcImage;
	Mat logoImage;
	vector<Mat>channels;
	Mat imageBlueChannel;
	//蓝色通道部分，多通道混合—蓝色分量部分
	//1.读入图片
	logoImage = imread("dota_logo.jpg", 0);
	srcImage = imread("dota_jugg.jpg");
	if (!logoImage.data) { printf("读取logoImage错误~! \n"); return false; }
	if (!srcImage.data) { printf("读取srcImage错误~! \n"); return false; }
	//2.把一个3通道图像转换成3个单通道图像
	split(srcImage, channels);//分离彩色通道
	//3.将原图的蓝色通道引用返回给imageBlueChannel，
	//注意是引用，相当于两者是等价，修改其中一个另一个跟着变
	imageBlueChannel = channels.at(0);
	//4.将原图的蓝色通道的（500，250）坐标处右下方的一块区域和logo图进行加权操作，
	//将得到的混合结果存到imageBlueChannel中
	addWeighted(imageBlueChannel(Rect(500, 250, logoImage.cols, logoImage.rows)), 1.0,
		logoImage, 0.5,0,imageBlueChannel(Rect(500,250,logoImage.cols,logoImage.rows)));
	//5.将三个通道重新合并为一个三通道
	merge(channels, srcImage);
	namedWindow("<1>游戏原画+logo蓝色通道");
	imshow("<1>游戏原画+logo蓝色通道",srcImage);
//-------------------------------------绿色通道部分------------------------------------
	Mat imageGreenChannel;
	//蓝色通道部分，多通道混合—蓝色分量部分
	//1.读入图片
	logoImage = imread("dota_logo.jpg", 0);
	srcImage = imread("dota_jugg.jpg");
	if (!logoImage.data) { printf("读取logoImage错误~! \n"); return false; }
	if (!srcImage.data) { printf("读取srcImage错误~! \n"); return false; }
	//2.把一个3通道图像转换成3个单通道图像
	split(srcImage, channels);//分离彩色通道
	//3.将原图的蓝色通道引用返回给imageBlueChannel，
	//注意是引用，相当于两者是等价，修改其中一个另一个跟着变
	imageGreenChannel = channels.at(1);
	//4.将原图的蓝色通道的（500，250）坐标处右下方的一块区域和logo图进行加权操作，
	//将得到的混合结果存到imageBlueChannel中
	addWeighted(imageGreenChannel(Rect(500, 250, logoImage.cols, logoImage.rows)), 1.0,
		logoImage, 0.5,0,imageGreenChannel(Rect(500,250,logoImage.cols,logoImage.rows)));
	//5.将三个通道重新合并为一个三通道
	merge(channels, srcImage);
	namedWindow("<1>游戏原画+logo蓝色通道");
	imshow("<1>游戏原画+logo蓝色通道",srcImage);
//--------------------------------------红色通道部分------------------------------------
		Mat imageRedChannel;
	//蓝色通道部分，多通道混合—蓝色分量部分
	//1.读入图片
	logoImage = imread("dota_logo.jpg", 0);
	srcImage = imread("dota_jugg.jpg");
	if (!logoImage.data) { printf("读取logoImage错误~! \n"); return false; }
	if (!srcImage.data) { printf("读取srcImage错误~! \n"); return false; }
	//2.把一个3通道图像转换成3个单通道图像
	split(srcImage, channels);//分离彩色通道
	//3.将原图的蓝色通道引用返回给imageBlueChannel，
	//注意是引用，相当于两者是等价，修改其中一个另一个跟着变
	imageRedChannel = channels.at(2);
	//4.将原图的蓝色通道的（500，250）坐标处右下方的一块区域和logo图进行加权操作，
	//将得到的混合结果存到imageBlueChannel中
	addWeighted(imageRedChannel(Rect(500, 250, logoImage.cols, logoImage.rows)), 1.0,
		logoImage, 0.5,0,imageRedChannel(Rect(500,250,logoImage.cols,logoImage.rows)));
	//5.将三个通道重新合并为一个三通道
	merge(channels, srcImage);
	namedWindow("<1>游戏原画+logo蓝色通道");
	imshow("<1>游戏原画+logo蓝色通道",srcImage);
	return true;
}

图像对比度和亮度的调整

//图像对比度、亮度调整
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<iostream>
using namespace cv;
using namespace std;
//全局函数声明
static void on_ContrastAndBright(int, void*);
//static void ShowHelpText();
//全局变量声明
int g_nContrastValue;//对比度值
int g_nBrightValue;//亮度值
Mat g_srcImage, g_dstImage;
int main()
{//读入图像
	g_srcImage = imread("1.jpg");
	if (!g_srcImage.data) { printf("读取图片错误，请确定目录下是否有imread函数指定图片存在~!"); return false; }
	g_dstImage = Mat::zeros(g_srcImage.size(), g_srcImage.type());
	//设定对比度和亮度的初值
	g_nContrastValue = 80;
	g_nBrightValue = 80;
	//创建效果窗口
	namedWindow("【效果图窗口】", 1);
	//创建轨迹条
	createTrackbar("对比度：", "【效果图窗口】", &g_nContrastValue, 300, on_ContrastAndBright);
	createTrackbar("亮 度：", "【效果图窗口】", &g_nBrightValue, 200, on_ContrastAndBright);
	//进行回调函数初始化
	on_ContrastAndBright(g_nContrastValue, 0);
	on_ContrastAndBright(g_nBrightValue, 0);
	//按下“q”键时，程序退出 
	while (char(waitKey(1)) != 'q') {}
	return 0;
}
//改变图像对比度和亮度值的回调函数
static void on_ContrastAndBright(int, void*)
{//创建窗口
	namedWindow("【原始图窗口】",1);
//三个for循环，执行g_dstImage(i,j)=a*g_srcImage(i,j)+b
	for (int y = 0; y < g_srcImage.rows; y++)
	{
		for (int x = 0; x < g_srcImage.cols; x++)
		{
			for (int c = 0; c < 3; c++)
			{
				g_dstImage.at<Vec3b>(y, x)[c] =
					saturate_cast<uchar>( (g_nContrastValue*0.01)*(g_srcImage.at<Vec3b>
					(y,x)[c]) + g_nBrightValue);
			}
		}
		//显示图像
		imshow("【原始图窗口】", g_srcImage);
		imshow("【效果图窗口】", g_dstImage);
	}
}

离散傅里叶变换

//离散傅里叶变换
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include"opencv2/imgproc/imgproc.hpp"
#include<iostream>
using namespace cv;
using namespace std;
int main()
{//以灰度模式读取原始图像并显示
	Mat srcImage = imread("1.jpg", 0);
	if (!srcImage.data) { printf("读取图像错误，请确定目录下是否有imread函数指定图片存在~！"); return false; }
	imshow("原始图像", srcImage);
	//ShowHelpText();
	//将输入图像延扩到最佳的尺寸，边界用0补充
	int m = getOptimalDFTSize(srcImage.rows);
	int n = getOptimalDFTSize(srcImage.cols);	
	//将添加的像素初始化为0
	Mat padded;
	copyMakeBorder(srcImage, padded, 0, m - srcImage.rows, 0, n - srcImage.cols, BORDER_CONSTANT, Scalar::all(0));
	//为傅里叶变换的结果（实部和虚部）分配存储空间
	//将planes数组组合合并成一个多通道的数组complexI
	Mat planes[] = { Mat_<float>(padded),Mat::zeros(padded.size(),CV_32F) };
	Mat complexI;
	merge(planes, 2, complexI);
	//进行就地离散傅里叶变换
	dft(complexI, complexI);
	//将复数转换为幅值，即=>log(1+sqrt(Re(DFT(I))^2+Im(DFT(I))^2))
	split(complexI, planes);//planes[0] = Re(DFT(I), planes[1] = Im(DFT(I))
	magnitude(planes[0], planes[1], planes[0]);
	Mat magnitudeImage = planes[0];
	//进行对数尺度（logarithmic scale）缩放
	magnitudeImage += Scalar::all(1);
	log(magnitudeImage, magnitudeImage);
	//剪切和重分布幅度图象限
	//若有奇数行或奇数列，进行频谱裁剪
	magnitudeImage = magnitudeImage(Rect(0, 0, magnitudeImage.cols&-2, magnitudeImage.rows&-2));
	//重新排列傅里叶图像中的象限，使得原点位于图像中心
	int cx = magnitudeImage.cols / 2;
	int cy = magnitudeImage.rows / 2;
	Mat q0(magnitudeImage, Rect(0, 0, cx, cy));
	Mat q1(magnitudeImage, Rect(cx, 0, cx, cy));
	Mat q2(magnitudeImage, Rect(0, cy, cx, cy));
	Mat q3(magnitudeImage, Rect(cx, cy, cx, cy));
	//交换象限（左上与右下进行交换）
	Mat tmp;
	q0.copyTo(tmp);
	q3.copyTo(q0);
	tmp.copyTo(q3);
	//交换象限（右上与左下进行交换）
	q1.copyTo(tmp);
	q2.copyTo(q1);
	tmp.copyTo(q2);
	//归一化，用0到1之间的浮点值将矩阵变换为可视的图像格式
	normalize(magnitudeImage, magnitudeImage, 0, 1, NORM_MINMAX);
	imshow("频谱幅值", magnitudeImage);
	waitKey();
	return 0;
}