基于Harr小波分解的图像融合opencv实现

最新推荐文章于 2024-03-22 21:44:19 发布
最新推荐文章于 2024-03-22 21:44:19 发布
阅读量2.9k 收藏 34
点赞数 5
分类专栏： 图像融合 文章标签： opencv 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TmacDu/article/details/107092063
版权

最近整理了基于Harr小波分解的图像融合技术实现可见光图像和红外图像的简单融合，本文侧重于图像融合，并不注重于Harr小波变换，所以就只做了二层小波分解和重构（分解层数越多，噪声处理起来也越麻烦），下面简要给出理论分析和代码。
一.Harr小波变换
小波变换的基本思想是想用一组小波函数或者基函数表示一个图像信号，其中Harr小波基函数是其中最简单的基函数，数学原理不做推导，有兴趣的同学可以学习小波变换的有关知识。
1.一维Harr小波分解
为了理解什么是一维Harr小波分解，下面用一个具体的例子来说明Harr小波分解的过程。假设有一幅只有8个像素的一维图像，对应像素为[2,4,6,8,10,12,14,16]。
（1）求均值：计算相邻像素对的平均值，得到一幅分辨率变为原来一半的图像[3,7,11,15],该部分储存是图像的整体信息，属于图像的高频分量。
（2）求差值：通过第一步求均值保留了图像的整体信息，但丢失了图像的细节信息，所以还要记录图像的细节信息以便重构时能够恢复图像的全部信息。通过计算原像素[2,4,6,8,10,12,14,16]相邻像素值之间的差值的1/2得到[-1,-1,-1,-1],该部分记录了图像的细节信息，属于低频分量。
（3）将（1）（2）得到的原始图像1/2分辨率的图像组合成新的图像[3,7,11,15,-1,-1,-1,-1],这就是Harr小波第一次分解的结果。如果还想做进一步的分解，可将第一次分解结果作为原始像素值重复第（1）（2）步即可。
2.二维Harr小波分解
有图像处理经验的同学都知道一幅图像可以看作一个二维矩阵，下面就从二维的角度讲解Harr小波分解。假设有一副8x8的灰度图像，表示为：
[64 2 3 61 60 6 7 57
9 55 54 12 13 51 50 16
17 47 46 20 21 43 42 24
40 26 27 37 36 30 31 33
32 34 35 29 28 38 39 25
41 23 22 44 45 19 18 48
49 15 14 52 53 11 10 56
8 58 59 5 4 62 63 1]
（1）经过行分解后得到：
[33 32 33 32 31 -29 27 -25
32 33 32 33 -23 21 -19 17
32 33 32 33 -15 13 -11 9
33 32 33 32 7 -5 3 -1
33 32 33 32 -1 3 -5 7
32 33 32 33 9 -11 13 -15
32 33 32 33 17 -19 21 -23
33 32 33 32 -25 27 -29 31
]
（2）在（1）的基础上经过列分解后得到：
[32.5 32.5 32.5 32.5 4 -4 4 -4
32.5 32.5 32.5 32.5 -4 4 -4 4
32.5 32.5 32.5 32.5 4 -4 4 -4
32.5 32.5 32.5 32.5 -4 4 -4 4
0.5 -0.5 0.5 -0.5 27 -25 23 -21
-0.5 0.5 -0.5 0.5 -11 9 -7 5
0.5 -0.5 0.5 -0.5 -5 7 -9 11
-0.5 0.5 -0.5 0.5 21 -23 25 -27
]。这就是一次二维Harr小波分解的结果，其中高频分量1个（左上角4x4的部分），低频分量3个（剩余部分），若还想多次分解，可重复（1）（2）过程。
二.代码实现
话不多说，直接上代码：

class WaveTransform
{
public:
	Mat WDT(const Mat &_src, const string _wname, const int _level);//小波分解
	Mat IWDT(const Mat &_src, const string _wname, const int _level);//小波重构
	void wavelet_D(const string _wname, Mat &_lowFilter, Mat &_highFilter);//分解包
	void wavelet_R(const string _wname, Mat &_lowFilter, Mat &_highFilter);//重构包
	Mat waveletDecompose(const Mat &_src, const Mat &_lowFilter, const Mat &_highFilter);
	Mat waveletReconstruct(const Mat &_src, const Mat &_lowFilter, const Mat &_highFilter);
};
Mat WaveTransform::WDT(const Mat &_src, const string _wname, const int _level)
{
	Mat_<float> src = Mat_<float>(_src);
	Mat dst = Mat::zeros(src.rows, src.cols, src.type());
	int row = src.rows;
	int col = src.cols;
	//高通低通滤波器
	Mat lowFilter;
	Mat highFilter;
	wavelet_D(_wname, lowFilter, highFilter);
	//小波变换
	int t = 1;

	while (t <= _level)
	{
		//先进行 行小波变换
		//#pragma omp parallel for
		for (int i = 0;i<row;i++)
		{
			//取出src中要处理的数据的一行
			Mat oneRow = Mat::zeros(1, col, src.type());

			for (int j = 0;j<col;j++)
			{
				oneRow.at<float>(0, j) = src.at<float>(i, j);
			}

			oneRow = waveletDecompose(oneRow, lowFilter, highFilter);
			for (int j = 0;j<col;j++)
			{
				dst.at<float>(i, j) = oneRow.at<float>(0, j);
			}
		}

		//小波列变换
		//#pragma omp parallel for
		for (int j = 0;j<col;j++)
		{
			Mat oneCol = Mat::zeros(row, 1, src.type());

			for (int i = 0;i<row;i++)
			{
				oneCol.at<float>(i, 0) = dst.at<float>(i, j);//dst,not src
			}
			oneCol = (waveletDecompose(oneCol.t(), lowFilter, highFilter)).t();

			for (int i = 0;i<row;i++)
			{
				dst.at<float>(i, j) = oneCol.at<float>(i, 0);
			}
		}
		//更新 
		row /= 2;
		col /= 2;
		t++;
		src = dst;
	}
	return dst;
}

Mat WaveTransform::IWDT(const Mat &_src, const string _wname, const int _level)
{
	
	Mat src = Mat_<float>(_src);
	Mat dst;
	src.copyTo(dst);
	int N = src.rows;
	int D = src.cols;

	//高低通滤波器
	Mat lowFilter;
	Mat highFilter;
	wavelet_R(_wname, lowFilter, highFilter);

	//小波变换
	int t = 1;
	int row = N / std::pow(2., _level - 1);
	int col = D / std::pow(2., _level - 1);

	while (row <= N && col <= D)
		//while(t<=_level)
	{
		//列逆变换
		for (int j = 0;j<col;j++)
		{
			Mat oneCol = Mat::zeros(row, 1, src.type());

			for (int i = 0;i<row;i++)
			{
				oneCol.at<float>(i, 0) = src.at<float>(i, j);
			}
			oneCol = (waveletReconstruct(oneCol.t(), lowFilter, highFilter)).t();

			for (int i = 0;i<row;i++)
			{
				dst.at<float>(i, j) = oneCol.at<float>(i, 0);
			}

		}

		//行逆变换
		for (int i = 0;i<row;i++)
		{
			Mat oneRow = Mat::zeros(1, col, src.type());
			for (int j = 0;j<col;j++)
			{
				oneRow.at<float>(0, j) = dst.at<float>(i, j);
			}
			oneRow = waveletReconstruct(oneRow, lowFilter, highFilter);
			for (int j = 0;j<col;j++)
			{
				dst.at<float>(i, j) = oneRow.at<float>(0, j);
			}
		}

		row *= 2;
		col *= 2;
		t++;
		src = dst;
	}

	return dst;
}


void WaveTransform::wavelet_D(const string _wname, Mat &_lowFilter, Mat &_highFilter)
{
	if (_wname == "haar" || _wname == "db1")
	{
		int N = 2;
		_lowFilter = Mat::zeros(1, N, CV_32F);
		_highFilter = Mat::zeros(1, N, CV_32F);

		_lowFilter.at<float>(0, 0) = 1 / sqrtf(N);
		_lowFilter.at<float>(0, 1) = 1 / sqrtf(N);

		_highFilter.at<float>(0, 0) = -1 / sqrtf(N);
		_highFilter.at<float>(0, 1) = 1 / sqrtf(N);
	}
	else if (_wname == "sym2")
	{
		int N = 4;
		float h[] = { -0.4830, 0.8365, -0.2241, -0.1294 };
		float l[] = { -0.1294, 0.2241,  0.8365, 0.4830 };

		_lowFilter = Mat::zeros(1, N, CV_32F);
		_highFilter = Mat::zeros(1, N, CV_32F);

		for (int i = 0;i<N;i++)
		{
			_lowFilter.at<float>(0, i) = l[i];
			_highFilter.at<float>(0, i) = h[i];
		}
	}
}
void WaveTransform::wavelet_R(const string _wname, Mat &_lowFilter, Mat &_highFilter)
{
	if (_wname == "haar" || _wname == "db1")
	{
		int N = 2;
		_lowFilter = Mat::zeros(1, N, CV_32F);
		_highFilter = Mat::zeros(1, N, CV_32F);


		_lowFilter.at<float>(0, 0) = 1 / sqrtf(N);
		_lowFilter.at<float>(0, 1) = 1 / sqrtf(N);

		_highFilter.at<float>(0, 0) = 1 / sqrtf(N);
		_highFilter.at<float>(0, 1) = -1 / sqrtf(N);
	}
	else if (_wname == "sym2")
	{
		int N = 4;
		float h[] = { -0.1294,-0.2241,0.8365,-0.4830 };
		float l[] = { 0.4830, 0.8365, 0.2241, -0.1294 };

		_lowFilter = Mat::zeros(1, N, CV_32F);
		_highFilter = Mat::zeros(1, N, CV_32F);

		for (int i = 0;i<N;i++)
		{
			_lowFilter.at<float>(0, i) = l[i];
			_highFilter.at<float>(0, i) = h[i];
		}
	}
}


Mat WaveTransform::waveletDecompose(const Mat &_src, const Mat &_lowFilter, const Mat &_highFilter)
{
	assert(_src.rows == 1 && _lowFilter.rows == 1 && _highFilter.rows == 1);
	assert(_src.cols >= _lowFilter.cols && _src.cols >= _highFilter.cols);
	Mat &src = Mat_<float>(_src);

	int D = src.cols;

	Mat &lowFilter = Mat_<float>(_lowFilter);
	Mat &highFilter = Mat_<float>(_highFilter);

	//频域滤波或时域卷积；ifft( fft(x) * fft(filter)) = cov(x,filter) 
	Mat dst1 = Mat::zeros(1, D, src.type());
	Mat dst2 = Mat::zeros(1, D, src.type());

	filter2D(src, dst1, -1, lowFilter);
	filter2D(src, dst2, -1, highFilter);

	//下采样
	//数据拼接
	for (int i = 0, j = 1;i<D / 2;i++, j += 2)
	{
		src.at<float>(0, i) = dst1.at<float>(0, j);//lowFilter
		src.at<float>(0, i + D / 2) = dst2.at<float>(0, j);//highFilter
	}
	return src;
}


Mat WaveTransform::waveletReconstruct(const Mat &_src, const Mat &_lowFilter, const Mat &_highFilter)
{
	assert(_src.rows == 1 && _lowFilter.rows == 1 && _highFilter.rows == 1);
	assert(_src.cols >= _lowFilter.cols && _src.cols >= _highFilter.cols);
	Mat &src = Mat_<float>(_src);

	int D = src.cols;

	Mat &lowFilter = Mat_<float>(_lowFilter);
	Mat &highFilter = Mat_<float>(_highFilter);


	/// 插值;
	Mat Up1 = Mat::zeros(1, D, src.type());
	Mat Up2 = Mat::zeros(1, D, src.type());


	for (int i = 0, cnt = 0; i < D / 2; i++, cnt += 2)
	{
		Up1.at<float>(0, cnt) = src.at<float>(0, i);     ///< 前一半
		Up2.at<float>(0, cnt) = src.at<float>(0, i + D / 2); ///< 后一半
	}

	/// 前一半低通，后一半高通
	Mat dst1 = Mat::zeros(1, D, src.type());
	Mat dst2 = Mat::zeros(1, D, src.type());
	filter2D(Up1, dst1, -1, lowFilter);
	filter2D(Up2, dst2, -1, highFilter);

	/// 结果相加
	dst1 = dst1 + dst2;
	return dst1;
}

void Coef_Fusion(Mat Visible, Mat Infrared, Mat &dst) {
	assert(Visible.rows == Infrared.rows&&Visible.cols == Infrared.cols);
	Mat Visible_gray,Infrared_gray;
	cvtColor(Visible, Visible_gray, CV_RGB2GRAY);
	normalize(Visible_gray, Visible_gray, 0, 255, CV_MINMAX);
	cvtColor(Infrared, Infrared_gray, CV_RGB2GRAY);
	normalize(Infrared_gray, Infrared_gray, 0, 255, CV_MINMAX);
	Visible_gray.convertTo(Visible_gray, CV_32F);
	Infrared_gray.convertTo(Infrared_gray, CV_32F);
	WaveTransform m_waveTransform;
	const int level = 2;
	Mat visible_dec = m_waveTransform.WDT(Visible_gray, "haar", level);
	Mat Infrared_dec = m_waveTransform.WDT(Infrared_gray, "haar", level);
	int row = Visible.rows;
	int col = Visible.cols;
	Mat dec = Mat(Visible.size(), CV_32FC1);
	//融合规则：高频部分采用加权平均的方法，低频部分采用模值取大的方法
	int halfRow = row / (2 * level);
	int halfCol = col / (2 * level);
	for (int i = 0;i < row;i++) {
		for (int j = 0;j < col;j++) {
			if (i < halfRow&&j < halfCol) {
				dec.at<float>(i, j) = (visible_dec.at<float>(i, j) + Infrared_dec.at<float>(i, j)) / 2;
			}
			else {
				float p = abs(visible_dec.at<float>(i, j));
				float q = abs(Infrared_dec.at<float>(i, j));
				if (p > q) {
					dec.at<float>(i, j) = visible_dec.at<float>(i, j);
				}
				else {
					dec.at<float>(i, j) = Infrared_dec.at<float>(i, j);
				}

			}
		}
	}
	dst = m_waveTransform.IWDT(dec, "haar", level);
	dst.convertTo(dst, CV_8UC1);
	normalize(dst, dst, 0, 255, CV_MINMAX);
	
}
int main(int argc, char *argv[])
{
	
	Mat Visible= imread("D:/VS2015/image/Visible.bmp");    //右图
	Mat Infrared = imread("D:/VS2015/image/Infrared.bmp");    //左图
	if (Visible.empty() || Infrared.empty()) {
		cout << "could not load the image..." << endl;
		return -1;
	}
	imshow("可见光图像", Visible);
	imshow("红外图像", Infrared);
	Mat dst;
	Coef_Fusion(Visible,Infrared,dst);
	if (dst.data) {
		imshow("融合结果", dst);
	}
	
	waitKey();
	destroyAllWindows();
	return 0;
}

函数说明：
Mat WDT(const Mat &_src, const string _wname, const int _level);//小波分解（src：输入图像，_wname:小波基，_level:分解层数）
Mat IWDT(const Mat &_src, const string _wname, const int _level);//小波重构（src：输入图像，_wname:小波基，_level:分解层数）
void Coef_Fusion(Mat Visible, Mat Infrared, Mat &dst);//融合函数（Visible：可见光图像，Infrared：红外图像，dst：融合结果）
注意：该方法只能处理灰度图像，也就是融合是基于灰度级的，结果也是灰度图片。
三.实验结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
四：参考
我的小波分解和重构也是参考别人的代码，这里把原作者的博客链接放在这里，大家可以去观看学习。
链接：https://blog.csdn.net/u014426939/article/details/82867874

以上就是所有分析和结果啦，如果有什么问题欢迎大家和我交流，非常乐意和大家交流计算机视觉相关的知识！

MC庆仔
关注
专栏目录
Haar小波对图像的分解
a1121420的博客
06-08 1568
haar小波对图像的一次分解实验，同样要求不使用matlab自带的小波函数和卷积函数。 分解过程： matlab代码如下： clc clear x=imread('cameraman.tif'); %读取matlab里自带的一副图片 %imshow(img);该图像的行列为366*364 %haar小波对图像进行分解 h1=x; h3=x; for i=1:256 for j=1:255 %对行,进行低通滤波 (1/2,1/2) h1(i,1)=0+1/2*x(
opencv实现小波变换
04-25
在VC++6.0和opencv1.0版本基础上实现小波变换
基于小波变换的图像融合代码
09-12
本文采用基于小波变换的图像融合方法，小波变换拥有水平，垂直和对角三种高频子带，可以有效改进以上问题，提高融合后的图像质量。但是小波变换也存在一定的局限性，它难以反映线和面的奇异行，还缺乏对自然图像进行稀释表示的能力。
VC++实现小波变换图像融合
11-25
用VC++开发实现的图像融合的源代码，用小波变换实现， 代码经测试可以编译运行。
二维图像haar小波变换的分解与重构
myslq的博客
11-05 1万+
二维图像haar小波变换的分解与重构 二维离散小波的理论推导和一维小波类似，但是以其尺度函数生成的尺度函数集作为标准正交基的尺度空间Vi的正交补空间Wi不能直接得到，而是可以证明，正交补空间Wi是由三个子空间的直和组成，对应的三个子空间可以由作为正交基的尺度函数、小波函数张成。 二维离散小波变换对图像的分解可以看做如下图所示的滤波过程，即首先进行行滤波，沿着列方向进行，然后下采样，然后对上一步得到的结果进行列滤波，沿着行方向，然后下采样，做完所有的列滤波后，获得4个不同的频带，一个近似分量、三个细节分量（水
OpenCV(C++)---图像混合
qq_45746744的博客
01-28 679
1、理论-线性混合操作 2、相关API(addWeighted) 解释说明： 参数1：inputArray src1 表示 输入图像Mat_src1 参数2：double alpha 表示 输入图像src1的alpha值（第一个权重即α） 参数3：inputArray src2 表示 输入图像Mat – src2 参数4：double beta 表示 输入图像src2的alpha值（第二个权重即1-α） 参数5：gamma值（校验值） 参数6：OutputArray dst 表示 输出混合图像 dty
基于OPENCV的图像小波分解
01-08
利用OPENCV对输入的图像进行一层小波分解，采用第二代的小波变换，用的是S小波。
基于IHS变换和小波变换的可见光和红外图像融合（opencv/C++实现）
TmacDu的博客
08-26 5895
之前写过一篇基于harr小波分解的可见光和红外图像的融合方法，不过该方法只能基于灰度级，无法输出RGB图像，在阅读了《基于 IHS 和小波变换的可见光与红外图像融合》这篇文章后并通过复现代码后弥补上了这个缺陷，现在融合后就可以输出RGB图像啦！ 一:融合原理 1.IHS变换 常用的色彩空间有 RGB 色彩空间和 IHS 色彩空间，RGB 色彩空间常用于计算机彩色显示器的显示系统中，RGB 中 R 代表红色，G 代表绿色，B 代表蓝色，3 种色彩叠加形成其他的色彩． 而 IHS 色彩空间包含亮度 I、色度 H
haar小波二维图像分解重构matlab代码
04-18
mra_mallat_2D_iterate.m实现二维图像的分解，mra_mallat_2D_merge_iterate.m实现二维图像的重构。程序针对2^N*2^M像素的图像设计，可以实现任意次数的分解与重构。也很很方便改写成针对任意像素的程序。
Chanda形态小波分解的opencv代码
windydreams的专栏
10-08 1183
//////////////////////////////////////////////////////////////////////////// //- 正变换，放在头文件中 #pragma once #include "cv.h" #include "highgui.h" #include &lt;iostream&gt; #include &lt;algorithm&gt; u...
matlab实现小波的二层分解
09-03
应用db5小波和 bior4.4小波, 对图象cameraman.tif分别进行2层小波分解和重构
基于小波分解的图像融合方法及性能评价
10-26
给出了一种新的基于小波多尺度分解的分层图像融合方法5其基本思想是先对源图像 进行小波多尺度分解J其次3按照融合规则3采用基于区域特性量测的选择及加权算子去构造融 合图像对应的小波系数J最后3通过逆小波变换重构融合图像5该方法被成功地用于图像的融合 处理5此外3利用熵K交叉熵K互信息K均方根误差K峰值信噪比等参量3对该融合方法的融合性能 进行了评价与分析5实验结果表明3该融合方法是十分有效的
VC++实现了基于图像小波变换的图像融合MFC
10-22
VC++的MFC框架实现了多种小波变换，可以构造不同的小波基如Haar小波等，分解与重建，并在此基础上实现图像融合。
基于opencv的图像融合
06-30
简单的用opencv程序实现两张图像的拼接和融合。
Opencv两图像融合
qq_45434544的博客
06-05 416
呜呜呜
Opencv面试题
最新发布
weixin_46319994的博客
03-22 2427
opencv面试题-50道
OpenCV 常用算法
热门推荐
lindazhou2005的专栏
03-19 3万+
 6月8日关于直方图    图像直方图是图像处理中一种十分重要的图像分析工具，它描述了一幅图像的灰度级内 容。        从数学上来说图像直方图是图像各灰度值统计特性与图像灰度值的函数，它统计一幅图像中各个灰度级出现的次数或概率；        从图形上来说，它是一个二维图， 横坐标表示图像中各个像素点的灰度级，纵坐标为各个灰度级上图像各个像素点出现的 次数或概率。任何一幅
图像处理与计算机视觉概述
ytffhew的博客
11-16 2093
图像处理与计算机视觉概述
ML\图像处理等资料汇总
fantasysolo的博客
07-25 1326
转自知乎: 计算机科学的领域 理论计算机科学 数据结构和算法 计算理论 信息论与编码理论 编程语言和编译器 形式化方法 计算机系统 计算机体系结构与计算机工程 操作系统 并发、并行与分布式系统 计算机网络 计算机安全和密码学 数据库 计算机应用技术 计算机图形学 科学计算 多媒体技术 数据挖掘 人工智能 自动推理 ...
小波转换详解：从Harr小波到STFT
在图像压缩中，Harr小波变换可以有效地提取图像的主要特征，通过保留重要的小波系数并丢弃次要信息来达到压缩的目的。由于小波变换能够区分高频细节和低频背景，因此在压缩过程中可以更精细地控制质量损失，保持图像...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值