第一篇 Frankle-Mccan去雾算法

最新推荐文章于 2024-01-10 22:55:54 发布
最新推荐文章于 2024-01-10 22:55:54 发布
阅读量900 收藏 1
点赞数
分类专栏： 数字图像处理---Opencv实现 文章标签： opencv visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18276435/article/details/52782499
版权
因为对图像处理感兴趣，就去本部蹭了丁老师的《数字图像处理》课程，感觉比自学效率高多了；

业余时间打算把课上部分代码实现，于是就有了这个博客；这里会不定期更新一些基础算法，大都是老师课上讲的，只注重算法实现，没有进行代码优化；这方面比较厉害的同学可以多多赐教；

PS：编译环境为VS2013+OpenCV3.0alpha;

**第一篇 Frankle-Mccan去雾算法**

PPT上语焉不详；根据PPT写的代码改了好几天效果还是很差，于是参考网上的matlab程序，对原理进行了反推，有了一定的去雾效果；

原理:

一、载入图像，

分为RGB三个通道准备依次处理；

二、参数计算；

求出MaxR、MaxG、MaxB；以及p和S；以Max值生成图像OPR,OPG,OPB;

p=log(min(m,n)-1);

S=2^p;(像素间隔）

三、图像处理：（这里以B通道为例）

3.1 S为指定间隔，求出B通道水平方向上间隔为S的像素差值DP；  

S>0时 , 求IP DP=B(i,j+S)-B(i,j); IP=DP+OPB(i,j); 

判断IP是否大于Max,大于Max,则赋予Max if(IP>MaxB) IP=MaxB 

求平均 并赋值给位置j+S的像素 OPB(i,j+S)=OPB(i,j+S)/2+IP/2;  

S<0时 求IP DP=B(i,j)-B(i,j+S);IP=DP+OPB(i,j+S); 

判断IP是否大于Max,大于Max,则赋予Max if(IP>MaxB) IP=MaxB 

求平均 并赋值给位置j的像素 OPB(i,j)=OPB(i,j)/2+IP/2;

垂直方向也做类似处理；

3.2 把步骤3.1重复k次

3.3 像素间隔S更新 S/= -2;

我参考的matlab程序在这里

【Frankle-McCann Retinex】matlab代码注释

下面是源代码；欢迎指正

#include<opencv2/opencv.hpp>
#include<iostream>
#include<math.h>
#define DIEDAI 7

using namespace std;
using namespace cv;
int main()
{
	//读入图像并分离为3个通道；
	Mat src = imread("1.jpg");
	imshow("原图", src);
	Mat Blue, Green, Red;
	vector<Mat> channels;
	split(src, channels);
	Blue = channels.at(0);
	Green = channels.at(1);
	Red = channels.at(2);
	
	//参数计算，三个通道的这几个参数相同
	int rows = Blue.rows;
	int cols = Blue.cols;
	int M = rows < cols ? rows : cols;
	int p = log(M) / log(2) - 1;//阶，这里采用隐式转换
	int S = pow(2, p);              //初始间隔

	//对图层进行处理  求初始OPB OPG OPR
	uchar MaxB = 0, MaxG = 0, MaxR = 0;
	cout << int(MaxB) << endl;
	uchar* dataB = nullptr;
	uchar* dataG = nullptr;
	uchar* dataR = nullptr;
	for (int i = 0; i < rows; i++)
	{
		dataB = Blue.ptr<uchar>(i);
		dataG = Green.ptr<uchar>(i);
		dataR = Red.ptr<uchar>(i);
		for (int j = 0; j < cols; j++)
		{
			if (*dataB > MaxB)
				MaxB = *dataB;
			if (*dataG > MaxG)
				MaxG = *dataG;
			if (*dataR > MaxR)
				MaxR = *dataR;
			dataB++;
			dataG++;
			dataR++;
		}
	}
	dataB = nullptr;
	dataG = nullptr;
	dataR = nullptr;

	Mat OPB(Blue.size(), Blue.depth());
	Mat OPG(Green.size(), Green.depth());
	Mat OPR(Red.size(), Red.depth());
	OPB.setTo(MaxB);
	OPG.setTo(MaxG);
	OPR.setTo(MaxR);

	int DP, IP;
	uchar* Data = nullptr;
	uchar* Data2 = nullptr;
	uchar* OPData = nullptr;
	uchar* OPData2 = nullptr;
	bool fushu = false;    //S是否为负数
		do
		{
			if (S < 0)
			{
				S *= -1;
				fushu = true;     //S为负数，DP=前-后，把差值与OP的J+S行相加得到IP;赋值给第一行
			}
			else
				fushu = false;   //S为正数，DP=后-前，这是把差值与OP的第一行相加得到IP；赋值给+S的位置；

			for (int i = 0; i < DIEDAI; i++)    
			{				
				//B列间隔迭代
				for (int i = 0; i < rows; i++)
				{
					Data = Blue.ptr<uchar>(i);       //获取i行第一个元素的指针
					OPData = OPB.ptr<uchar>(i);
					for (int j = 0; j < cols - S; j++)
					{
						if (fushu) 
						{
							DP = int(Data[j] - Data[j + S]);      //求i行第j+S个元素与第j个元素的差值
							IP = int(OPData[j + S]) + DP;          
							if (IP > MaxB)
								IP = MaxB;
							OPData[j ] = OPData[j] / 2 + IP / 2;
						}
						else
						{
							DP = int(Data[j + S]) - int(Data[j]);
							IP = int(OPData[j]) + DP;
											
							if (IP > MaxB)    
								IP = MaxB;
							OPData[j + S] = OPData[j+S] / 2 + IP / 2;
						}
					}
				}
				//B行间隔迭代
				for (int i = 0; i < rows - S; i++)
				{
					Data = Blue.ptr<uchar>(i);
					Data2 = Blue.ptr<uchar>(i + S);
					OPData = OPB.ptr<uchar>(i);
					OPData2 = OPB.ptr<uchar>(i + S);
					for (int j = 0; j < cols; j++)
					{
						if (fushu)
						{
							DP = int(*Data++ - *Data2++);
							IP = int(*OPData2) + DP;
							if (IP > MaxB)
								IP = MaxB;
							*OPData = *OPData / 2 + IP / 2;
							OPData++;
							OPData2++;
						}
						else
						{
							DP = int(*Data2++ - *Data++);
							IP = int(*OPData) + DP;

							if (IP > MaxB)
								IP = MaxB;
							*OPData2 = *OPData2 / 2 + IP / 2;
							OPData++;
							OPData2++;
						}
					}
				}				
				//G列间隔迭代
				for (int i = 0; i < rows; i++)
				{
					Data = Green.ptr<uchar>(i);
					OPData = OPG.ptr<uchar>(i);
					for (int j = 0; j < cols - S; j++)
					{
						if (fushu)
						{
							DP = int(Data[j] - Data[j + S]);
							IP = int(OPData[j + S]) + DP;
							if (IP > MaxB)
								IP = MaxB;
							OPData[j] = OPData[j] / 2 + IP / 2;
						}
						else
						{
							DP = int(Data[j + S]) - int(Data[j]);
							IP = int(OPData[j]) + DP;

							if (IP > MaxB)
								IP = MaxB;
							OPData[j + S] = OPData[j + S] / 2 + IP / 2;
						}
					}
				}
				//G行间隔迭代
				for (int i = 0; i < rows - S; i++)
				{
					Data = Green.ptr<uchar>(i);
					Data2 = Green.ptr<uchar>(i + S);
					OPData = OPG.ptr<uchar>(i);
					OPData2 = OPG.ptr<uchar>(i + S);
					for (int j = 0; j < cols; j++)
					{
						if (fushu)
						{
							DP = int(*Data++ - *Data2++);
							IP = int(*OPData2) + DP;
							if (IP > MaxB)
								IP = MaxB;
							*OPData = *OPData / 2 + IP / 2;
							OPData++;
							OPData2++;
						}
						else
						{
							DP = int(*Data2++ - *Data++);
							IP = int(*OPData) + DP;

							if (IP > MaxB)
								IP = MaxB;
							*OPData2 = *OPData2 / 2 + IP / 2;
							OPData++;
							OPData2++;
						}
					}
				}
				//R列间隔迭代
				for (int i = 0; i < rows; i++)
				{
					Data = Red.ptr<uchar>(i);
					OPData = OPR.ptr<uchar>(i);
					for (int j = 0; j < cols - S; j++)
					{
						if (fushu)
						{
							DP = int(Data[j] - Data[j + S]);
							IP = int(OPData[j + S]) + DP;
							if (IP > MaxB)
								IP = MaxB;
							OPData[j] = OPData[j] / 2 + IP / 2;
						}
						else
						{
							DP = int(Data[j + S]) - int(Data[j]);
							IP = int(OPData[j]) + DP;

							if (IP > MaxB)
								IP = MaxB;
							OPData[j + S] = OPData[j + S] / 2 + IP / 2;
						}
					}
				}
				//R行间隔迭代
				for (int i = 0; i < rows - S; i++)
				{
					Data = Red.ptr<uchar>(i);
					Data2 = Red.ptr<uchar>(i + S);
					OPData = OPR.ptr<uchar>(i);
					OPData2 = OPR.ptr<uchar>(i + S);
					for (int j = 0; j < cols; j++)
					{
						if (fushu)
						{
							DP = int(*Data++ - *Data2++);
							IP = int(*OPData2) + DP;
							if (IP > MaxB)
								IP = MaxB;
							*OPData = *OPData / 2 + IP / 2;
							OPData++;
							OPData2++;
						}
						else
						{
							DP = int(*Data2++ - *Data++);
							IP = int(*OPData) + DP;
							if (IP > MaxB)
								IP = MaxB;
							*OPData2 = *OPData2 / 2 + IP / 2;
							OPData++;
							OPData2++;
						}
					}
				}
			}
			if (fushu)
				S *= -1;   //恢复S的符号
			S /= -2;
			cout << S << endl;  
		} while (S != 0);  

		Data = nullptr;
		Data2 = nullptr;
		OPData = nullptr;
		OPData2 = nullptr;

		channels.at(0) = OPB;
		channels.at(1) = OPG;
		channels.at(2) = OPR;
		
		Mat dst(src.size(), src.depth());
		merge(channels, dst);   //合并通道

		imshow("结果", dst);

	waitKey(0);
}
原图：
原图在这里

效果图（迭代7次）


蜗牛奔月球
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[Python图像识别] 四十六.图像预处理之图像去雾详解（ACE算法和暗通道先验去雾算法）
杨秀璋的专栏
09-14 1万+
上一篇文章主要介绍目标检测原理，通过七个问题来普及什么是目标检测，然后利用ImageAI实现最简单的目标检测案例。这篇文章将详细介绍图像去雾算法，经过图像增强后的图像也能应用于目标检测或图像分类领域，并且效果更好。本文主要讲解ACE去雾算法、暗通道先验去雾算法以及雾化生成算法，并且参考了两位计算机视觉大佬（Rizzi 何恺明）的论文。希望您喜欢，且看且珍惜。
去雾算法Light-DehazeNet_去雾算法
09-24
Light-DehazeNet：一种用于单图像去雾论文的新型轻量级 CNN 架构
《Single Image Haze Removal Using Dark Channel Prior》一文中图像去雾算法的原理、实现、效果（速度可实时）...
weixin_33730836的博客
08-25 5097
      最新的效果见 ：http://video.sina.com.cn/v/b/124538950-1254492273.html         可处理视频的示例：视频去雾效果      在图像去雾这个领域，几乎没有人不知道《Single Image Haze Removal Using Dark Channel Prior》这篇文章，该文是2009年CVPR最佳论文。作者何凯明博士，...
Frankle_Mccan_Retinex与Mccann99_Retinex python版本
weixin_43934864的博客
12-16 1442
Frankle_Mccan_Retinex与Mccann99_Retinex python版本
Retinex 算法
chaiky的博客
05-08 1万+
1、Retinex 理论及数学模型 2、Retinex 算法发展历程 2.1 基于迭代的 Retinex 算法 2.1.1 Frankle-McCann Retinex 算法 2.1.2 McCann99 Retinex 算法 2.2基于中心环绕的 Retinex 算法 2.2.1SSR算法（单尺度） 2.2.2MSR算法（多尺度） 2.2.3MSRCR算法 2.3Retinex算法的频域处理............
图像去雾算法
热门推荐
识物专栏
02-17 16万+
一、定义 因为雾霾的影响，在雾天条件下拍摄到的图像导致图像可能会存在细节丢失、对比度低的情况，将会影响图像后续的分析识别工作。在雾天情况下，空气中存在大量的 悬浮颗粒物，会对光线产 生散射，导致物体反射出 的光线发生衰减，同时反射光与观察者直接接受到光线发生混合，造成观察者获取到的图像的对比 度和清晰度等特征都发生改变，细节信息大量丢失。图像去雾是以满 足特定条件下应用需求为目的，通过对有雾图像进行分析和预处理，突出图像中的细节信息使之更加适合人机识别的一种图像预处理方法。 目前图像去雾算法主要包括
《Single Image Haze Removal Using Dark Channel Prior》一文中图像去雾算法的原理、实现、效果（速度可实时）
weixin_39450742的博客
07-16 259
本篇博文来自博主Imageshop，打赏或想要查阅更多内容可以移步至Imageshop。 转载自：https://www.cnblogs.com/Imageshop/p/3281703.html 侵删 最新的效果见 ：http://video.sina.com.cn/v/b/124538950-1254492273.html 可处理视频的示例：视频去雾效果 在图像去雾这个领域，几乎没有人不知道《Single Image Haze Removal Using D...
(完整版)MATLAB典型去雾算法
最新发布
GPT_code的博客
01-10 333
Retinex 理论的基本内容是物体的颜色是由物体对长波（红）、中波（绿）和短波（蓝）光线的反射能力决定的，而不是由反射光强度的绝对值决定的；带色彩恢复因子C的多尺度算法(MSRCR)]是在多个固定尺度的基础上考虑色彩不失真恢复的结果，在多尺度Retinex算法过程中，我们通过引入一个色彩因子C来弥补由于图像局部区域对比度增强而导致图像颜色失真的缺陷，通常情况下所引入的色彩恢复因子C的表达式为。表示的是颜色空间的映射函数。=1，表示灰度图像。在对数域中，用原图像减去低通滤波后的图像，得到高频增强的图像。
图像去雾算法综述
qq_42627691的博客
11-09 9682
图像去雾算法 图像去雾算法研究综述 （ 魏红伟 ，田 杰 ，肖卓朋 ） 基于多幅图像的去雾算法 （1）Narasimhan 等通过在相同场景中拍摄多张不同天气条件下图片的方法恢复无雾图像，但需要等待天气变化 （2）Schechner 等和 Tali等考虑到天气条件变化，提出基于偏振图像的去雾算法，即在相同场景下拍摄多幅不同偏振图像 （3）Kopf 等提出在去雾算法中将场景几何信息作为补充输入信息。 缺点：在实际应用场景中，获取这些额外信息并不容易 基于图像增强的去雾算法 （1）直方图均衡化：将雾图的
含源码|基于MATLAB的去雾系统(5种去雾算法+1种本文的改进算法)
sfejojno的博客
05-14 3765
在原有的去雾系统基础上，引入了4种评价指标，增加了2种算法，其中一种也是一种简单改进，最后也是取得了不错的效果。
图像去雾算法opencv实现
05-10
图像去雾算法opencv实现图像去雾算法opencv实现 暗原色的opencv实现
经典去雾算法,去雾算法总结,matlab
09-10
图像去雾的几种经典方法 有空间双边滤波去雾 暗通道去雾 引导滤波去雾 图像去雾质量评价标准等代码
retinex_frankle_mccann.zip_ Retinex_Frankle-McCann_frankle mccan
09-14
retinex, frankle, mccann
retinex_frankle_mccann.rar_Frankle-McCann_retinex
09-14
retinex_frankle_mccann方法
基于FPGA的改进实时图像增强算法的设计与实现——Retinex图像增强技术。word版，公式文字可复制或者编辑
03-23
本文在对比目前常用的几种算法的优缺点后，将retinex作为本课题的图像增强算法，Retinex图像增强方法可以有效的压缩图像的动态范围，使阴影处的图像细节更加突出，有效保持图像色彩恒常性等优点。用过MATLAB对算法做...
图像处理，matlab程序，retinex_frankle_mccann算法加直方图均衡化算法，去雾
04-24
图像处理，matlab程序，retinex_frankle_mccann算法加直方图均衡化算法，实现去雾，薄雾的时候效果比较明显
彩票假说复制：Frankle和Carbin试图复制彩票假说纸
02-15
复制彩票假设纸这是试图复制Frankle和Carbin的。基本总结本文简而言之：1）火车网络2）修剪不必要的砝码/连接。 无需构建和训练整个网络就可以弄清楚如何识别子网。 这种修剪方法可以将参数数量减少10倍，同时保持...
基于色彩恒常（ color constancy）特性的Frankle-McCann Retinex图像增强。
weixin_34166472的博客
04-18 414
      相关随笔可见：带色彩恢复的多尺度视网膜增强算法（MSRCR）的原理、实现及应用。      从历史的顺序上讲，本篇应该放在MSRCR之前的，只是由于现在大多论文都是描述的MSRCR，因此我也是先学习MSRCR的。      今天，无意中找寻一些Retinex资料，搜索到一篇文章《Retinex in matlab》，原以为是MSRCR之类的matlab实现，结果仔细一看，和MSRC...
Retinex系列之Frankle-McCann Retinex 分类： M...
weixin_33696822的博客
12-01 625
一、Frankle-McCann Retinex Frankle-McCann算法选择一条螺旋结构的路径用于像素间的比较。如下图,算法沿着螺旋路径选取用于比较 像素点，这种路径选择包含了整个图像的全局明暗关系。并且越靠近预测中心点选取的点数越多，因为靠的 近的像素点与中心像素点的相关性要比远处的高。 此迭代方案基于成对像素亮度值间的互动，这一像素对在图像中的坐标(x,y)、...
推荐大模型基础知识学习资料
12-01
4.《The Lottery Ticket Hypothesis: Finding Sparse, Trainable Neural Networks》：这是一篇由Jonathan Frankle和Michael Carbin发表的论文，介绍了一种名为“彩票假设”的神经网络剪枝方法，该方法可以在不影响...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值