Retinex算法的C++/opencv实现

最新推荐文章于 2024-04-14 13:28:33 发布
置顶 最新推荐文章于 2024-04-14 13:28:33 发布
阅读量5.7k 收藏 128
点赞数 24
分类专栏： 图像增强 文章标签： Retinex算法 C++ opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TmacDu/article/details/103499795
版权

最近在做图像增强方面的算法，在参考了一些博客，论文和源代码后 ，自己整理了Retinex相关算法的opencv实现，在这里贴出来供大家参考，有不当的地方欢迎大家指出！
一.Retinex算法原理
基础理论：物体的颜色是由物体对长波（红色），中波（绿色），短波（蓝色）光线的反射能力来决定的，而不是由反射光强度的绝对值来决定的；物体的颜色不受光照非均匀性的影响，具有一致性，即Retinex算法是基于物体的颜色恒常性来实现的。
Retinex算法可以在图像的动态颜色范围压缩，边缘增强和颜色恒常三个方面达到平衡，在图像除雾方面有着较好的效果（对正常图像的增强效果不明显）。
二.SSR（Single Scale Retinex）
根据Retinex算法的基础理论，我们可以得到以下数学表达式：
S(x,y)=R(x,y)*L(x,y)　 （2-1）
图示如下：
在这里插入图片描述
其中R（x,y）表示物体的反射性质，即图像的内在属性，应该最大程度的保留；L（x，y）表示入射光图像，决定了图像像素能够达到的动态范围，应该尽量去除；S（x,y）为人眼观察到或者相机接收到的图像。
对公式2-1的等式两边取对数，得到：
r(x,y)=Log[R(x,y)] = Log[S(x,y)]-Log[L(x,y)] (2-2)

算法的关键在于如何得到图像的入射光图像L（x,y），其中比较经典且效果较好的方法是通过对相机接收的图像S（x,y）做高斯模糊来估计L（x,y）。
算法的具体步骤如下：
（1）输入高斯模糊的高斯环绕尺度C（即二维高斯函数的标准差）；
（2）根据C对原始图像数据S（x，y）做高斯模糊得到L（x,y）;
（3）根据公式2-2对S（x,y）和L（x,y）分别取对数并作差得到r(x,y);
（4）将r（x,y）的像素值量化到0到255的范围内得到R（x,y），R（x,y）即我们想得到的增强图像。量化的公式如下：
R(x,y) = ( Value - Min ) / (Max - Min) * (255-0) (2-3)
算法的源代码如下：

void ssr(Mat src, Mat& dst, double sigma) {
	Mat src_log,gauss,gauss_log,dst_log;
	src_log= Mat(src.size(), CV_32FC3);
	gauss_log= Mat(src.size(), CV_32FC3);
	dst_log = Mat(src.size(), CV_32FC3);
	dst = Mat(src.size(), CV_32FC3);
	int height = dst_log.rows;
	int width = dst_log.cols;
	int ksize = (int)(sigma * 3/2);
	ksize = ksize * 2 + 1;
	//求Log(S(x,y)
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = src.at<Vec3b>(i, j)[k];
				if (value <= 0.01) value = 0.01;
				src_log.at<Vec3f>(i, j)[k] = log10(value);
			}
		}
	}
	GaussianBlur(src, gauss, Size(ksize,ksize),sigma,sigma,4);
	//求Log（L(x,y)）
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = gauss.at<Vec3b>(i, j)[k];
				if (value <= 0.01) value = 0.01;
				gauss_log.at<Vec3f>(i, j)[k] = log10(value);
			}
		}
	}
	//求Log（S（x,y）)-Log(L(x,y))
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value1 = src_log.at<Vec3f>(i, j)[k];
				float value2 = gauss_log.at<Vec3f>(i, j)[k];
				dst_log.at<Vec3f>(i, j)[k] = value1-value2;
			}
		}
	}
	float min[3] = { dst_log.at<Vec3f>(0, 0)[0], dst_log.at<Vec3f>(0, 0)[1],dst_log.at<Vec3f>(0, 0)[2] };
	float max[3] = { dst_log.at<Vec3f>(0, 0)[0], dst_log.at<Vec3f>(0, 0)[1],dst_log.at<Vec3f>(0, 0)[2] };
	//求R/G/B三通道的min,max
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = dst_log.at<Vec3f>(i, j)[k];
				if (value > max[k]) max[k] = value;
				if (value < min[k]) min[k] = value;
			}
		}
	}
	//量化处理
	cout << min[0] << " " << min[1] << " " << min[2] << endl;
	cout << max[0] << " " << max[1] << " " << max[2] << endl;
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = dst_log.at<Vec3f>(i, j)[k];
				dst.at<Vec3f>(i, j)[k] = (saturate_cast<float>(255 * (value - min[k]) / (max[k] - min[k])));
			}
		}
	}
	dst.convertTo(dst, CV_8UC3);
	return;
}

效果图如下：
原图：
原图
SSR（C=300）：
在这里插入图片描述
原图：
在这里插入图片描述
SSR（C=300）：
在这里插入图片描述
三.MSR（Multi Scale Retinex）
MSR是在SSR算法的基础上提出的，用不同的尺度C来估计L（x，y）。数学表达如下：
r(x,y)=∑k Wk*{logS(x,y)−log[Fk(x,y)⋅S(x,y)]} （3-1）
为了兼有SSR高，中，低三个尺度的优点的考虑，K通常取3，且有W1=W2=W3=1/3.
算法步骤：
（1）输入权值矩阵Wk和K个高斯环绕尺度；
（2）根据公式3-1得到r（x,y）;
（3）对r（x，y）做量化处理得到增强图像R（x,y）.
算法的源代码如下：

void msr(Mat src, Mat& dst, vector<float>weight, vector<float>sigmas) {
	Mat src_log, gauss, gauss_log, dst_log;
	src_log = Mat(src.size(), CV_32FC3);
	gauss_log = Mat(src.size(), CV_32FC3);
	dst_log = Mat::zeros(src.size(), CV_32FC3);
	dst = Mat::zeros(src.size(), CV_32FC3);
	int height = dst_log.rows;
	int width = dst_log.cols;
    
	//求Log(S(x,y)
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = src.at<Vec3b>(i, j)[k];
				if (value < 0.01) value = 0.01;
				src_log.at<Vec3f>(i, j)[k] = log10(value);
			}
		}
	}
	int scale = weight.size();
	for (int t = 0;t < scale;t++) {
		int ksize = (int)(sigmas[t] * 3 / 2);
		ksize = ksize * 2 + 1;
		GaussianBlur(src, gauss, Size(ksize, ksize), sigmas[t], sigmas[t], 4);
		//求Log（L(x,y)）
		for (int i = 0;i < height;i++) {
			for (int j = 0;j < width;j++) {
				for (int k = 0;k < 3;k++) {
					float value = gauss.at<Vec3b>(i, j)[k];
					if (value < 0.01) value = 0.01;
					gauss_log.at<Vec3f>(i, j)[k] = log10(value);
				}
			}
		}
		//求Log（S（x,y）)-Log(L(x,y))
		for (int i = 0;i < height;i++) {
			for (int j = 0;j < width;j++) {
				for (int k = 0;k < 3;k++) {
					float value1 = src_log.at<Vec3f>(i, j)[k];
					float value2 = gauss_log.at<Vec3f>(i, j)[k];
					dst_log.at<Vec3f>(i, j)[k] +=weight[t] * (value1 - value2);
				}
			}
		}
	}
	float min[3] = { dst_log.at<Vec3f>(0, 0)[0], dst_log.at<Vec3f>(0, 0)[1],dst_log.at<Vec3f>(0, 0)[2] };
	float max[3] = { dst_log.at<Vec3f>(0, 0)[0], dst_log.at<Vec3f>(0, 0)[1],dst_log.at<Vec3f>(0, 0)[2] };
	//求R/G/B三通道的min,max
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = dst_log.at<Vec3f>(i, j)[k];
				if (value > max[k]) max[k] = value;
				if (value < min[k]) min[k] = value;
			}
		}
	}
	//量化处理
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = dst_log.at<Vec3f>(i, j)[k];
				dst.at<Vec3f>(i, j)[k] =saturate_cast<float> (255 * (value - min[k]) / (max[k] - min[k]));
			}
		}
	}
	dst.convertTo(dst, CV_8UC3);
}

算法的效果图如下：
原图：
在这里插入图片描述
MSR(C1=40,C2=100,C3=300):
在这里插入图片描述
原图：
在这里插入图片描述
MSR（C1=40,C2=100,C3=300）：
在这里插入图片描述

四.MSRCR（带颜色恢复的MSR）
由SSR和MSR算法的效果图我们可以看到一般的Retinex算法在图像去雾时可能会导致图像失真。一般的Retinex算法处理图像时，都会假设初始图像灰度值是缓慢变化的，即图像是平滑的，在实际情况下，Retinex算法在亮度差异大的区域会产生光晕。
为了解决上述的图像颜色失真的情况，有人提出了一种带有颜色恢复的MSR算法。MSRCR算法在MSR算法的基础上，加入了色彩恢复因子来调节由于图像局部区域对比度增强导致的颜色失真。
算法核心如下：
在这里插入图片描述
算法源代码如下：

void scr(Mat &src, float low_clip, float high_clip) {
	int height = src.rows;
	int width = src.cols;
	int total = height*width;
	int u[3][256];//统计每个通道每个像素值出现的次数
	memset(u, 0, sizeof(u));
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				int v = src.at<Vec3b>(i, j)[k];
				u[k][v]++;
			}
		}
	}
	
	for (int i = 0; i < 3; i++) {
		for (int j = 1;j < 256;j++) {
			u[i][j] = u[i][j - 1] + u[i][j];
		}
	}
	int low_val[3], high_val[3];
	float low_rate = 0, high_rate = 0;
	for (int i = 0; i < 3; i++) {
		for (int j = 0;j < 256;j++) {
			float rate = u[i][j] / total;
			if (rate<  low_clip&&rate>low_rate) {
				low_val[i] = j;
				low_rate = rate;
			}
			if (rate < high_clip&&rate>high_rate) { 
				high_val[i] = j;
				high_rate = rate;
			}
		}
	}
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				int value = src.at<Vec3b>(i, j)[k];
				src.at<Vec3b>(i, j)[k] = max(min(value, high_val[k]), low_val[k]);
			}
		}
	}
}
void colorRestoration(Mat src, Mat& dst, float alpha, float beta) {
	dst = Mat(src.size(), CV_32FC3);
	for (int  i = 0; i < src.rows; i++)
	{
		for (int j = 0;j < src.cols;j++)
		{   
			float sum = 0;
			for (int t = 0;t < src.channels();t++) sum += src.at<Vec3b>(i, j)[t];
			for (int k=0;k<3;k++)
			{
				dst.at<Vec3f>(i, j)[k] = beta*(log10(alpha*src.at<Vec3b>(i, j)[k]) - log10(sum));
			}
		}
	}
}
void msrcr(Mat src, Mat& dst, vector<float>weight, vector<float>sigmas, float alpha, float beta, float low_clip, float high_clip) {
	Mat src_log, gauss, gauss_log, dst_log,dst_ci;
	src_log = Mat(src.size(), CV_32FC3);
	gauss_log = Mat(src.size(), CV_32FC3);
	dst_log = Mat::zeros(src.size(), CV_32FC3);
	dst_ci = Mat(src.size(), CV_32FC3);
	dst = Mat::zeros(src.size(), CV_32FC3);
	int height = dst_log.rows;
	int width = dst_log.cols;

	//求Log(S(x,y)
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = src.at<Vec3b>(i, j)[k];
				if (value < 0.01) value = 0.01;
				src_log.at<Vec3f>(i, j)[k] = log10(value);
			}
		}
	}
	int scale = weight.size();
	for (int t = 0;t < scale;t++) {
		int ksize = (int)(sigmas[t] * 3 / 2);
		ksize = ksize * 2 + 1;
		GaussianBlur(src, gauss, Size(ksize, ksize), sigmas[t], sigmas[t], 4);
		//求Log（L(x,y)）
		for (int i = 0;i < height;i++) {
			for (int j = 0;j < width;j++) {
				for (int k = 0;k < 3;k++) {
					float value = gauss.at<Vec3b>(i, j)[k];
					if (value < 0.01) value = 0.01;
					gauss_log.at<Vec3f>(i, j)[k] = log10(value);
				}
			}
		}
		//求Log（S（x,y）)-Log(L(x,y))
		for (int i = 0;i < height;i++) {
			for (int j = 0;j < width;j++) {
				for (int k = 0;k < 3;k++) {
					float value1 = src_log.at<Vec3f>(i, j)[k];
					float value2 = gauss_log.at<Vec3f>(i, j)[k];
					dst_log.at<Vec3f>(i, j)[k] += weight[t] * (value1 - value2);
				}
			}
		}
	}
	//求色彩恢复因子Ci
	colorRestoration(src, dst_ci, alpha, beta);
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float v1 = dst_log.at<Vec3f>(i, j)[k];
				float v2 = dst_ci.at<Vec3f>(i, j)[k];
				dst_log.at<Vec3f>(i, j)[k] = v1*v2 ;
			}
		}
	}

	float min[3] = { dst_log.at<Vec3f>(0, 0)[0], dst_log.at<Vec3f>(0, 0)[1],dst_log.at<Vec3f>(0, 0)[2] };
	float max[3] = { dst_log.at<Vec3f>(0, 0)[0], dst_log.at<Vec3f>(0, 0)[1],dst_log.at<Vec3f>(0, 0)[2] };
	//求R/G/B三通道的min,max
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = dst_log.at<Vec3f>(i, j)[k];
				if (value > max[k]) max[k] = value;
				if (value < min[k]) min[k] = value;
			}
		}
	}
	//量化处理
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = dst_log.at<Vec3f>(i, j)[k];
				dst.at<Vec3f>(i, j)[k] = saturate_cast<float> (255 * (value - min[k]) / (max[k] - min[k]));
			}
		}
	}
	dst.convertTo(dst, CV_8UC3);
	scr(dst, low_clip, high_clip);
}

上面的算法有着很多的经验参数，不利于手动实现，有人提出了一种基于GIMP的MSR算法，用参数Dynamic来控制图像的动态范围实现去除图像的色偏问题（一般取值2或3效果比较好）。这种算法的效果很好，能够一定程度解决颜色失真的问题。
算法的简要描述如下：
1.计算出 log[R(x,y)]中R/G/B各通道数据的均值Mean和均方差Var（注意是均方差）。
2.类似下述公式计算各通道的Min和Max值。
Min = Mean - Dynamic * Var;
Max = Mean + Dynamic * Var;
3.对Log[R(x,y)]的每一个值Value，进行线性映射：
R(x,y) = ( Value - Min ) / (Max - Min) * (255 - 0)
同时要注意增加一个溢出判断，即：
if (R(x, y) > 255) R(x,y) = 255;
else if (R(x,y) < 0) R(x,y) = 0;

算法的源码如下：

void msrcr_GIMP(Mat src, Mat& dst, vector<float>weight, vector<float>sigmas, int Dynamic) {
	Mat src_log, gauss, gauss_log, dst_log;
	src_log = Mat(src.size(), CV_32FC3);
	gauss_log = Mat(src.size(), CV_32FC3);
	dst_log = Mat(src.size(), CV_32FC3);
	dst = Mat(src.size(), CV_32FC3);
	float min[3] = { 0 };
	float max[3] = { 0 };
	float mean[3] = { 0 };
	float var[3] = { 0 };
	int height = dst_log.rows;
	int width = dst_log.cols;
	//求Log(S(x,y)
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = src.at<Vec3b>(i, j)[k];
				if (value < 0.01) value = 0.01;
				src_log.at<Vec3f>(i, j)[k] = log10(value);
			}
		}
	}
	int scale = weight.size();
	for (int t = 0;t < scale;t++) {
		int ksize = (int)(sigmas[t] * 3 / 2);
		ksize = ksize * 2 + 1;
		GaussianBlur(src, gauss, Size(ksize, ksize), sigmas[t], sigmas[t], 4);
		//求Log（L(x,y)）
		for (int i = 0;i < height;i++) {
			for (int j = 0;j < width;j++) {
				for (int k = 0;k < 3;k++) {
					float value = gauss.at<Vec3b>(i, j)[k];
					if (value < 0.01) value = 0.01;
					gauss_log.at<Vec3f>(i, j)[k] = log10(value);
				}
			}
		}
		//求Log（S（x,y）)-Log(L(x,y))
		for (int i = 0;i < height;i++) {
			for (int j = 0;j < width;j++) {
				for (int k = 0;k < 3;k++) {
					float value1 = src_log.at<Vec3f>(i, j)[k];
					float value2 = gauss_log.at<Vec3f>(i, j)[k];
					dst_log.at<Vec3f>(i, j)[k] += weight[t] * (value1 - value2);
				}
			}
		}
	}
	//求R/G/B各通道的均值mean和均方差var
	float sum[3] = {0};
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = dst_log.at<Vec3f>(i, j)[k];
				sum[k] += value;
			}
		}
	}
	for (int i = 0; i < 3; i++)
	{
		mean[i] = sum[i] / (height*width);

	}
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = dst_log.at<Vec3f>(i, j)[k];
				var[k] += (value - mean[k])*(value - mean[k]);
			}
		}
	}
	for (int i = 0; i < 3; i++)
	{
		var[i] = sqrt(var[i] / (height*width));

	}
	//计算R/G/B各通道的Min，Max
	for (int  i = 0; i < 3; i++)
	{
		min[i] = mean[i] - Dynamic*var[i];
		max[i] = mean[i] + Dynamic*var[i];
	}
	//量化处理
	for (int i = 0;i < height;i++) {
		for (int j = 0;j < width;j++) {
			for (int k = 0;k < 3;k++) {
				float value = dst_log.at<Vec3f>(i, j)[k];
				dst.at<Vec3f>(i, j)[k] = saturate_cast<float>(255 * (value - min[k]) / (max[k] - min[k]));
			}
		}
	}
	dst.convertTo(dst, CV_8UC3);
}

算法的效果图如下：
MSR(C1=40,C2=100,C3=300)：
在这里插入图片描述
MSRCR_GIMP(C1=40,C2=100,C3=300,Dynamic=2):
在这里插入图片描述
原图：
在这里插入图片描述
MSRCR_GIMP(C1=40,C2=100,C3=300,Dynamic=2):
在这里插入图片描述

以上就是我的Retinex算法的总结过程，算法本人已经实现过，效果图也贴出来供大家参考，有不当的地方欢迎大家指出来，楼主会及时修正，最后希望我的总结能够帮到大家！

MC庆仔
关注
  • 24
    点赞
  • 踩
  • 128
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python白平衡-光照问题之常见算法比较(附Python代码)
weixin_37988176的博客
10-30 2701
一、灰度世界算法① 算法原理灰度世界算法以灰度世界假设为基础，该假设认为：对于一幅有着大量色彩变化的图像，R,G,B三个分量的平均值趋于同一灰度值Gray。从物理意义上讲，灰色世界法假设自然界景物对于光线的平均反射的均值在总体上是个定值，这个定值近似地为"灰色”。颜色平衡算法将这一假设强制应用于待处理图像，可以从图像中消除环境光的影响，获得原始场景图像。一般有两种方法确定Gray值1) ...
图像去雾算法代码（opencv+c++）
12-02
图像清晰化处理，使用c++开发，利用开源opencv库，运行时需自行配置opencv库
C++基于 Retinex 的图像增强算法-Opencv-C++.zip
05-09
C++基于 Retinex 的图像增强算法-Opencv-C++。 一种常见图像增强算法，基于Retinex理论。本代码通过vs2015编译通过，Opencv3.1.0，C++ opencv c++ Retinex 图像增强
Retinex算法，C++，opencv
06-02
用opencv实现retinex算法，包括单尺度和多尺度Retinex
Retinex图像增强算法(SSR, MSR, MSRCR)详解及其OpenCV源码
mangsite的博客
02-19 6117
Retinex图像增强算法...
retinex算法_OpenCV图像处理专栏十四 | 基于Retinex成像原理的自动色彩均衡算法(ACE)...
weixin_39538847的博客
11-22 432
前言这个算法是IPOL上一篇名为《Automatic Color Equalization(ACE) and its Fast Implementation》提出的，这实际上也是《快速ACE算法及其在图像拼接中的应用》这篇论文中使用的ACE算法，这个算法主要是基于Retinex成像理论做的自动彩色均衡，我用C++ OpenCV实现了，来分享一下。算法原理在论文介绍中提到，高动态图像是指在一幅图像...
【OpenCV】Retinex图像增强（SSR，MSR，MSRCR）
GordonWei
10-05 8649
简介 1963年12月30日E. Land作为人类视觉的亮度和颜色感知的模型在俄亥俄州提出了一种颜色恒常知觉的计算理论——Retinex理论。Retinex是一个合成词，它的构成是retina（视网膜）+cortex（皮层）→ Retinex。40多年来，工作在IS&T、NASA的J. J. McCann和D. J. Jobson、Zia-Ur Rahman、G. A. Woodell等人...
C++实现Retinex算法（还有伽马矫正、直方图均衡化）
Lven_effi的博客
12-08 1141
之前的代码是学习MC庆仔的，后来自己为了加快运算时间，做了一些改动。同时也附上了伽马矫正、直方图均衡化的结果做对比。本次未写带颜色恢复的多尺度Retinex算法，如果后面需要的人多我再改一改附上。
Opencv c++对比度增强（1.多尺度Retinex；2.LICE-Retinex；3.自适应对数映射。）
m0_44975814的博客
08-17 663
常用对比度增强：直方图均衡化、gamma变换、对数变换，基本可以解决常见的工业问题。本期主要讲述的是三种效果较好的对比度增强算法：1.多尺度Retinex；2. 自适应对数映射。Retinex 理论的基本内容是物体的颜色是由物体对长波（红）、中波（绿）和短波（蓝）光线的反射能力决定的，而不是由反射光强度的绝对值决定的；物体的色彩不受光照非均性的影响，具有一致性，即Retinex理论是以色感一致性（颜色恒常性）为基础的。
图像增强算法Retinex原理与实现详解
全栈若城,专注知识分享
07-06 7166
本文介绍了图像增强算法Retinex的原理及其Python实现。Retinex是一种能够提高图像亮度和颜色表现的算法，通过对输入的图像进行多尺度高斯模糊处理和颜色恢复操作，实现图像的增强。文章详细讲解了代码中使用的各个函数，并给出了示例代码和测试结果。
Retinex SSR算法opencv
05-26
用opencv编写的Retinex SSR算法代码，代码简单，运行结果比较好
retinex算法MATLAB代码程序
12-06
retinex算法MATLAB代码程序 retinex算法是目前比较流行且重要的图像增强算法，主要是通过将影响图像质量的照度分量去除，得到图像本来面目的原理！利用了人类视觉系统的特性！
基于OpenCV实现Retinex
09-21
国外大牛写的Retinex图像处理，可用于图像增强，去雾等应用。
Retinex算法：用于 MSRCR、MSRCP 的python代码
06-07
执行/demo.py，见 /code/retinex.py 中的代码和注释
基于Retinex的图像增强算法-Opencv-C++
10-25
一种常见图像增强算法，基于Retinex理论。本代码通过vs2015编译通过，Opencv3.1.0，C++
【opencv】示例-videocapture_obsensor.cpp 读取和处理通过OBSENSOR摄像头获取的视频流数据...
最新发布
cxyhjl的博客
04-14 550
/** * 注意: Astra2、Gemini2 和 Gemini2L 相机目前仅支持 Windows 以及 Linux 内核版本不高于4.15，更高版本的 Linux 内核可能会有异常。 */ #include <opencv2/videoio.hpp> // 包含为视频捕捉提供的功能 #include <opencv2/highgui.hpp> // 包含...
【opencv】示例-pca.cpp PCA图像重建演示
cxyhjl的博客
04-12 559
// 加载必要的头文件 #include <iostream> // 用于标准输入输出流 #include <fstream> // 用于文件的输入输出 #include <sstream> // 用于字符串的输入输出流操作 #include <opencv2/core.hpp> // OpenCV核心功能的头文件 #inc...
opencv+python(顶帽+黑帽)
2303_76230584的博客
04-12 564
op, # 为形态变换的类型 MORPH_TOPHAT：顶帽，又称礼帽。op, # 为形态变换的类型 MORPH_BLACKHAT：黑帽。1、顶帽运算：去除目标图像外的噪声，原图-开运算；1、黑帽运算：去除目标图像内的噪声，原图-闭运算；
automatedMSRCR算法opencv c++ 实现
05-05
automatedMSRCR (Automatic Multi-Scale Retinex with Color Restoration) 算法是一种图像增强算法，它可以增强图像的对比度，保留细节和颜色。下面是使用 OpenCV C++ 实现 automatedMSRCR 算法的示例代码： ```c++ #include <opencv2/core.hpp> #include <opencv2/highgui.hpp> #include <opencv2/imgproc.hpp> using namespace cv; Mat automatedMSRCR(Mat input, float sigma_list[], int sigma_list_size, float G, float b, int alpha, int beta, int low_clip, int high_clip) { Mat L; input.convertTo(L, CV_32FC1); L = log(L + 1.0f); Mat R; for (int i = 0; i < sigma_list_size; i++) { Mat tmp; GaussianBlur(input, tmp, Size(0, 0), sigma_list[i], sigma_list[i], BORDER_DEFAULT); tmp.convertTo(tmp, CV_32FC1); tmp = log(tmp + 1.0f) - L; tmp = exp(tmp - G); R += tmp; } R /= sigma_list_size; Mat output; output = input * (1.0f - b) + R * b; output.convertTo(output, CV_8UC3); std::vector<Mat> channels; split(output, channels); for (int i = 0; i < 3; i++) { channels[i] = (channels[i] - mean(channels[i])) * alpha + mean(channels[i]); threshold(channels[i], channels[i], 0, 255, THRESH_TOZERO); normalize(channels[i], channels[i], low_clip, high_clip, NORM_MINMAX); } merge(channels, output); return output; } int main() { Mat input = imread("input.jpg"); float sigma_list[] = { 15.0f, 80.0f, 250.0f }; int sigma_list_size = sizeof(sigma_list) / sizeof(float); float G = 5.0f; float b = 25.0f; int alpha = 125; int beta = 46; int low_clip = 0; int high_clip = 255; Mat output = automatedMSRCR(input, sigma_list, sigma_list_size, G, b, alpha, beta, low_clip, high_clip); imshow("input", input); imshow("output", output); waitKey(); return 0; } ``` 在这个示例中，我们使用了 OpenCV 的核心模块（core）、图像 I/O 模块（highgui）和图像处理模块（imgproc）。具体来说，我们使用了以下函数： - `imread()`：加载输入图像。 - `GaussianBlur()`：对输入图像进行高斯模糊。 - `split()`：将输出图像的三个通道分离。 - `mean()`：计算每个通道的均值。 - `threshold()`：将每个通道的像素值截断为 0 到 255 之间。 - `normalize()`：将每个通道的像素值归一化为 0 到 255 之间。 - `merge()`：将三个通道合并为一幅图像。 - `imshow()`：显示图像。 - `waitKey()`：等待用户按键。 在实现 automatedMSRCR 算法时，我们需要将输入图像转换为浮点数类型，然后进行对数变换。接着，我们使用高斯模糊对输入图像进行多尺度处理，计算出 R 通道。最后，我们将 R 通道与输入图像的原始亮度值进行加权平均，并对每个通道进行颜色修正和像素值调整，最终得到增强后的图像。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值