opencv之图像去雾

于 2023-04-27 09:12:45 发布
阅读量826 收藏 6
点赞数 1
文章标签： opencv 计算机视觉 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lrzss/article/details/130398589
版权

1、何恺明的暗通道去雾算法

        论文原文：Single Image Haze Removal Using Dark Channel Prior | IEEE Journals & Magazine | IEEE Xplore

        参考博客：[论文阅读] (11)ACE算法和暗通道先验图像去雾算法（Rizzi | 何恺明老师）_暗通道去雾算法_Eastmount的博客-CSDN博客

        参考公众号：GiantPandaCV 

        将各位大佬的实现代码粘出来，供大家学习！

#include <opencv2/opencv.hpp>
#include <iostream>
#include <Windows.h>
#include <vector>

using namespace std;
using namespace cv;

int getMax(Mat src)
{
	int row = src.rows;
	int col = src.cols;
	int temp = 0;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			temp = max((int)src.at<uchar>(i, j), temp);
		}
		if (temp == 255) return temp;
	}
	return temp;
}

Mat dehaze(Mat src)
{
	double eps;
	int row = src.rows;
	int col = src.cols;
	Mat M = Mat::zeros(row, col, CV_8UC1);
	Mat M_max = Mat::zeros(row, col, CV_8UC1);
	Mat M_ave = Mat::zeros(row, col, CV_8UC1);
	Mat L = Mat::zeros(row, col, CV_8UC1);
	Mat dst = Mat::zeros(row, col, CV_8UC3);
	double m_av, A;

	double sum = 0;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			uchar r, g, b, temp1, temp2;
			b = src.at<Vec3b>(i, j)[0];
			g = src.at<Vec3b>(i, j)[1];
			r = src.at<Vec3b>(i, j)[2];
			temp1 = min(min(b, g), r);
			temp2 = max(max(b, g), r);
			M.at<uchar>(i, j) = temp1;
			M_max.at<uchar>(i, j) = temp2;
			sum += temp1;
		}
	}
	m_av = sum / (row * col * 255);
	eps = 0.75 / m_av;
	boxFilter(M, M_ave, CV_8UC1, Size(15, 15));  // 中值滤波
	double delta = min(0.9, eps * m_av);
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			L.at<uchar>(i, j) = min((int)(delta * M_ave.at<uchar>(i, j)), (int)M.at<uchar>(i, j));
		}
	}
	A = (getMax(M_max) + getMax(M_ave)) * 0.5;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			int temp = L.at<uchar>(i, j);
			for (int k = 0; k < 3; k++)
			{
				int val = A * (src.at<Vec3b>(i, j)[k] - temp) / (A - temp);
				if (val > 255) val = 255;
				if (val < 0) val = 0;
				dst.at<Vec3b>(i, j)[k] = val;
			}
		}
	}
	return dst;
}



// 获取最小值矩阵
int row, col;
int** getMinChannel(Mat src)
{
	if (src.channels() != 3)
	{
		cout << "input error!" << endl;
		exit(-1);
	}
	int** imgGray;
	imgGray = new int* [row];
	for (int i = 0; i < row; i++)
	{
		imgGray[i] = new int[col];
	}
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			int localmin = 255;
			for (int k = 0; k < 3; k++)
			{
				if (src.at<Vec3b>(i, j)[k] < localmin)
				{
					localmin = src.at<Vec3b>(i, j)[k];
				}
			}
			imgGray[i][j] = localmin;
		}
	}
	return imgGray;
}

// 求暗通道  通过最小矩阵，及poolsize，获取最小矩阵在poolsize范围内的最小值
int** getDarkChannel(int** imgGray, int blocksize = 3)
{
	if (blocksize % 2 == 0 || blocksize < 3)
	{
		fprintf(stderr, "blocksize is not odd or too small!");
		exit(-1);
	}
	int poolsize = (blocksize - 1) / 2;
	int newheight = row + blocksize - 1;
	int newwidth = col + blocksize - 1;
	int** imgMiddle;
	imgMiddle = new int* [newheight];
	for (int i = 0; i < newheight; i++)
	{
		imgMiddle[i] = new int[newwidth];
	}
	for (int i = 0; i < newheight; i++)
	{
		for (int j = 0; j < newwidth; j++)
		{
			if (i < row && j < col)
			{
				imgMiddle[i][j] = imgGray[i][j];
			}
			else
			{
				imgMiddle[i][j] = 255;
			}
		}
	}
	int** imgDark;
	imgDark = new int* [row];
	for (int i = 0; i < row; i++)
	{
		imgDark[i] = new int[col];
	}
	int localmin = 255;
	for (int i = poolsize; i < newheight - poolsize; i++)
	{
		for (int j = poolsize; j < newwidth - poolsize; j++)
		{
			localmin = 255;
			for (int k = i - poolsize; k < i + poolsize + 1; k++)
			{
				for (int l = j - poolsize; l < j + poolsize + 1; l++)
				{
					if (imgMiddle[k][l] < localmin)
					{
						localmin = imgMiddle[k][l];
					}
				}
			}
			imgDark[i - poolsize][j - poolsize] = localmin;
		}
	}
	return imgDark;
}

struct node {
	int x, y, val;
	node() {}
	node(int _x,int _y,int _val):x(_x),y(_y),val(_val){}
	bool operator<(const node& rhs) {
		return val > rhs.val;
	}
};

// 估算全局大气光值
int getGlobalAtmosphericLightValue(int** imgDark, Mat src, bool meanmodel = false, float percent = 0.001)
{
	int size = row * col;
	vector<node> nodes;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			node temp;
			temp.x = i, temp.y = j, temp.val = imgDark[i][j];
			nodes.push_back(temp);
		}
	}
	sort(nodes.begin(), nodes.end());  // 从小到大排序

	int atmosphericLight = 0;
	if (int(percent * size) == 0)
	{
		for (int i = 0; i < 3; i++)
		{
			if (src.at<Vec3b>(nodes[0].x, nodes[0].y)[i] > atmosphericLight)  // imgDark最小处的原图中像素点中的最大值
			{
				atmosphericLight = src.at<Vec3b>(nodes[0].x, nodes[0].y)[i];
			}
		}
	}
	// 开启均值模式
	//if (meanmodel == true)
	//{
	//	int sum = 0;
	//	for (int i = 0; i < int(percent * size); i++)
	//	{
	//		for (int j = 0; j < 3; j++)
	//		{
	//			sum = sum + src.at<Vec3b>(nodes[i].x, nodes[i].y)[j];
	//		}
	//	}
	//}
	// 获取暗通道在前0.1%的位置的像素点在原图像中的最高亮度值
	for (int i = 0; i < int(percent * size); i++)
	{
		for (int j = 0; j < 3; j++)
		{
			if (src.at<Vec3b>(nodes[i].x, nodes[i].y)[j] > atmosphericLight)
			{
				atmosphericLight = src.at<Vec3b>(nodes[i].x, nodes[i].y)[j];
			}
		}
	}
	return atmosphericLight;
}
// 恢复原图  omega 去雾比例  t0 最小透射率值
Mat getRecoverScene(Mat src,float omega=0.85,float t0 =0.5,int blocksize=15,bool meanmodel=false,float percent=0.001)
{
	int** imgGray = getMinChannel(src);  // 获取每个像素点b,g,r中的最小值
	int** imgDark = getDarkChannel(imgGray, blocksize = blocksize);  // 通过最小矩阵，及poolsize，获取imgGray在poolsize范围内的最小值
	int atmosphericLight = getGlobalAtmosphericLightValue(imgDark, src, meanmodel = meanmodel, percent = percent);   // 估算全局大气光值
	float** imgDark2, ** transmission;
	/*imgDark2 = new float* [row];
	for (int i = 0; i < row; i++)
	{
		imgDark2[i] = new float[col];
	}*/
	transmission = new float* [row];  // t(x)
	for (int i = 0; i < row; i++)
	{
		transmission[i] = new float[col];
	}
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			//imgDark2[i][j] = float(imgDark[i][j]);
			transmission[i][j] = 1 - omega * imgDark[i][j] / atmosphericLight;
			if (transmission[i][j] < 0.1)
			{
				transmission[i][j] = 0.1;
			}
		}
	}
	Mat dst(src.rows, src.cols, CV_8UC3);

	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			for (int channel = 0; channel < 3; channel++)
			{
				int temp = (src.at<Vec3b>(i, j)[channel] - atmosphericLight) / transmission[i][j] + atmosphericLight;  // J(x) = (I(x) - A)/t(x) + A
				if (temp > 255) temp = 255;
				if (temp < 0) temp = 0;
				dst.at<Vec3b>(i, j)[channel] = temp;
			}
		}
	}
	
	return dst;

}

Mat MedianFilterFogRemove(Mat src, float p = 0.85, int kernelsize = 15, int blocksize = 3, bool meanmodel = false, float percent = 0.001)
{
	int** imgGray = getMinChannel(src);  // 获取每个像素点b,g,r中的最小值
	int** imgDark = getDarkChannel(imgGray, blocksize = blocksize);  // 通过最小矩阵，及poolsize，获取imgGray在poolsize范围内的最小值
	//int atmosphericLight = getGlobalAtmosphericLightValue(imgDark, src, meanmodel = meanmodel, percent = percent);  // 估算全局大气光值
    int Histgram[256] = {0};
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			Histgram[imgDark[i][j]]++;
		}
	}
	int sum = 0, atmosphericLight = 0;
	for (int i = 255; i >= 0; i--)
	{
		sum += Histgram[i];  // // sum的最大值为row*col
		if (sum > row * col * 0.01)
		{
			atmosphericLight = i;  //  从大到小的前0.1%所在的值作为大气光值

			break;
		}
	}
	int sumb = 0, sumg = 0, sumr = 0, amount = 0;
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			if (imgDark[i][j] >= atmosphericLight)
			{
				sumb += src.at<Vec3b>(i, j)[0];
				sumg += src.at<Vec3b>(i, j)[1];
				sumr += src.at<Vec3b>(i, j)[2];
				amount++;
			}
		}
	}
	sumb /= amount;
	sumg /= amount;
	sumr /= amount; // 从所有最小值矩阵范围内的最小值矩阵中大于大气光值的，获取原图中的所有b,g,r值，并取均值
	Mat filter(row, col, CV_8UC1);
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			filter.at<uchar>(i, j) = imgDark[i][j];   // 将imgDark赋给filter
		}
	}
	Mat A(row, col, CV_8UC1);
	medianBlur(filter, A, kernelsize);  // 中值滤波，得到A

	Mat temp(row, col, CV_8UC1);
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			int diff = filter.at<uchar>(i, j) - A.at<uchar>(i, j); 
			if (diff < 0) diff = -diff;
			temp.at<uchar>(i, j) = diff;
		}
	}
	medianBlur(temp, temp, kernelsize);   // 中值滤波
	Mat B(row, col, CV_8UC1);
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			int diff = A.at<uchar>(i, j) - temp.at<uchar>(i, j);
			if (diff < 0) diff = 0;
			B.at<uchar>(i, j) = diff;
		}
	}
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			int minn = B.at<uchar>(i, j) * p;
			if (imgDark[i][j] > minn)
			{
				B.at<uchar>(i,j) = minn;
			}
			else
			{
				B.at<uchar>(i, j) = imgDark[i][j];
			}
		}
	}
	Mat dst(row, col, CV_8UC3);
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			int F = B.at<uchar>(i, j);
			int value;
			if (sumb != F)
			{
				value = sumb * (src.at<Vec3b>(i, j)[0] - F) / (sumb - F);
			}
			else
			{
				value = src.at<Vec3b>(i, j)[0];
			}
			if (value < 0) value = 0;
			else if (value > 255) value = 255;
			dst.at<Vec3b>(i, j)[0] = value;

			if (sumg != F)
			{
				value = sumg * (src.at<Vec3b>(i, j)[1] - F) / (sumg - F);
			}
			else
			{
				value = src.at<Vec3b>(i, j)[1];
			}
			if (value < 0) value = 0;
			else if (value > 255) value = 255;
			dst.at<Vec3b>(i, j)[1] = value;

			if (sumr != F)
			{
				value = sumr * (src.at<Vec3b>(i, j)[2] - F) / (sumr - F);
			}
			else
			{
				value = src.at<Vec3b>(i, j)[2];
			}
			if (value < 0) value = 0;
			else if (value > 255) value = 255;
			dst.at<Vec3b>(i, j)[2] = value;
		}
	}
	return dst;
}

int main()
{

	Mat image = imread("E:/dataset/python_dataset/VOC07+12+test/VOCdevkit/VOC2007/JPEGImages/2008_000084.jpg");
	clock_t t0,t1,t2;
	t0 = clock();
	// 方式1 快速去雾
	Mat dst = dehaze(image);
	cout << "the method1 run time is :" << clock() - t0 << "ms" << endl;

	// 方式2 暗通道去雾法
	row = image.rows;
	col = image.cols;
	t1 = clock();
	Mat dst1 = getRecoverScene(image);
	cout << "the method2 run time is :" << clock() - t1 << "ms" << endl;

	// 方式3 中值滤波进行去雾
	t2 = clock();
	Mat dst2 = MedianFilterFogRemove(image);
	cout << "the method3 run time is :" << clock() - t2 << "ms" << endl;

	imshow("origin", image);
	imshow("result1", dst);
	imshow("result2", dst1);
	imshow("result3", dst2);
	char key = waitKey();
	if (key == 'q')
	{
		return 0;
	}
	system("pause");
	return 0;
}

输入输出结果：

 

 

 

 

lrzss
关注
机器学习实践系列之13 - OpenCV之图像去雾
跟随技术的脚步-linolzhang的专栏
03-02 2288
图像去雾 是图像质量保证的一个重要方面，这里要讲到的是这个领域的一个里程碑式的贡献：        来自 何凯铭 的基于 暗原色先验（dark channel prior）的单一输入图像去雾方法，这是一种简单但是有效的图像先验规律，不需要借助帧间关系。        论文参考：Single Image Haze Removal Using Dark Channel Prior
opencv-python图像增强二：图像去雾（暗通道去雾）
最新发布
HanWenKing的博客
08-08 1909
图像去雾是计算机视觉领域中的一个重要问题，其目的是恢复被雾气遮挡的图像中的真实细节。在自然场景中，雾气会导致图像的对比度下降、颜色失真以及细节模糊。去雾算法的主要目标是在保留图像内容的同时，尽可能地恢复被雾气遮挡的信息。本次使用的算法为暗通道去雾，暗通道去雾算法基于暗通道先验理论，该理论指出在自然场景的任意一点（除天空外），其暗通道图像中的像素值在大部分情况下都接近于0。通过提取暗通道图像，并对其进行去雾处理，可以恢复图像中的真实细节。
图像去雾算法opencv实现
05-10
图像去雾算法opencv实现图像去雾算法opencv实现 暗原色的opencv实现
图像去雾的OpenCV程序
燕子lovinglife
08-05 2982
去雾算法参考了一篇论文： Kaiming He, Jian Sun, Xiaoou Tang. Single Image Haze Removal Using Dark Channel Prior 大致内容是提出了一个叫做暗原色先验的东西来对有雾图像进行处理，十分巧妙，有兴趣者可以看看。这里使用OpenCV实现文中的去雾算法，然而论文提到的soft matting未在本程序中实现。
使用opencv 进行图像去雾
weixin_NineDays66
11-12 9907
背景 近年来国内的雾霾天气逐渐由中东地区向全国蔓延。雾霾自2013年起开始成为人们对天气关注的关键词。雾霾是特定气候条件与人类活动相互作用的结果。 高密度人口的经济及社会活动必然会排放大量细颗粒物（PM2.5），一旦排放超过大气循环能力和承载度，细颗粒物浓度将持续积聚，此时如果受静稳天气 等影响，极易出现大范围的雾霾。 雾天时，弥漫在空中的雾气和尘埃模糊了人们的视线，使得景物的能见度大幅降低。...
openCV实战——图像去雾
qq_35732321的博客
09-08 3005
全 局直方图处理通过对 RGB 图像的 R、G、B 三层通道分别进行直方图均衡化，再整合到新的图 像的方式进行。将整幅图像分成很多小块，然后再对每一个小块分别进行直方图均衡化，最后进行拼接。掩膜的主要是用来提取感兴趣区域。即自适应直方图均衡化。
用opencv实现图片去雾
03-24
利用opencv的图像处理技术实现图片去雾，简单方便！
图像去雾_opencv去雾_opencv图像去雾_图像处理_图像去雾_
10-01
OpenCV是一个广泛使用的开源计算机视觉库，它提供了多种图像处理功能，包括图像去雾。在本篇中，我们将深入探讨如何使用OpenCV在Visual Studio (VS)环境中实现图像去雾处理。 首先，我们需要理解图像去雾的基本原理...
图像去雾算法代码（opencv+c++）
12-02
本项目提供了基于OpenCV库的C++实现，可以帮助开发者理解和应用图像去雾算法。OpenCV（Open Source Computer Vision Library）是一个跨平台的计算机视觉库，包含了大量的图像和视频处理函数，广泛应用于图像分析、...
Python基于OpenCV的图像去雾算法[完整源码＆部署教程]
m0_73388125的博客
11-07 755
Python基于OpenCV的图像去雾算法
数字图像处理图像去雾代码（opencv）
12-23
数字图像处理图像去雾代码（opencv），内附实验报告。
OpenCV去雾
05-17
Single Image Haze Removal(图像去雾)-CVPR’09 Best Paper .自己用OpenCV实现的代码~
图像去雾opencv
04-24
用opencv实现的图像去雾，算法是何凯明在那篇论文中算法。网上有很多matlab实现该代码的，但是很少有c。
暗通道去雾算法Opencv实现
08-23
用OpenCV2.3.1实现的暗通道去雾算法。压缩文件是一个工程文件，解压后工程文件内附“说明文档.txt”粘贴代码即可使用.本人练手拙作，注释比较详细，工程内另附Matlab代码，整个OpenCV代码的实现过程依据的就是那段Matlab代码
基于opencv的单张图像去雾算法（一）
cfqcfqcfqcfqcfq的博客
10-18 5670
最近对图像去雾算法产生了兴趣，查阅学习了大量论文和大牛博客后，决定动手用自己熟悉的opencv来编写程序完成。文章专门记录了具体算法实现过程以及其中遇见的大量问题。供自己以后参考，当然也希望能给广大博友提供一些参考。本文着重讲实现过程，图像去雾理论会同过参考文献形式给出。整个内容拟大概分成三个章节来介绍。 开发环境：    计算机系统：win10(64-bit)     编译器：MS
OpenCV——去雾
weixin_30730151的博客
11-16 138
这是一个简化的实现算法，完整的算法请参考： Single Image Haze Removal Using Dark Channel Prior ——CVPR 2009 // define head function #ifndef PS_ALGORITHM_H_INCLUDED #define PS_ALGORITHM_H_INCLUDED #inclu...
图像增强算法（直方图均衡化、拉普拉斯、Log、伽马变换）
weixin_30836759的博客
08-03 2636
一、图像增强算法原理 图像增强算法常见于对图像的亮度、对比度、饱和度、色调等进行调节，增加其清晰度，减少噪点等。图像增强往往经过多个算法的组合，完成上述功能，比如图像去燥等同于低通滤波器，增加清晰度则为高通滤波器，当然增强一副图像是为最后获取图像有用信息服务为主。一般的算法流程可为：图像去燥、增加清晰度（对比度）、灰度化或者获取图像边缘特征或者对图像进行卷积、二值化等，上述四个步骤...
基于opencv的单张图像去雾算法（二）
cfqcfqcfqcfqcfq的博客
10-19 5660
1、暗原色方法的缺陷         使用暗原色先验知识获取到的t估计图关键就是利用最小值滤波器求去最小值，而这个过程受到滤波核ksize的影响较大，滤波核选取的比较小时，t估计图细节较多，层次感好。但是平滑较少，局部错误增多。而滤波核ksize取值较大时，会得到分布过于单一的暗原色图 ,致使t 估计图的细节和层次感不够明显 , 不能有效区分距离的远近 。由于多数真实图像的雾气浓度分布不
opencv图像去雾
05-02
OpenCV是一个开源的计算机视觉库，提供了丰富的图像处理和计算机视觉算法。在OpenCV中，图像去雾是一种常见的图像增强技术，用于去除图像中的雾霾或模糊效果，使图像更加清晰和细节更加突出。 在OpenCV中，可以使用以下步骤进行图像去雾： 1. 估计大气光照：通过分析图像中的亮度信息，可以估计图像中的大气光照值。常用的方法是选择图像中亮度最高的像素作为大气光照值。 2. 估计透射率：透射率表示光线在通过雾霾时的衰减程度。可以使用不同的方法来估计透射率，例如使用暗通道先验或者基于颜色空间的方法。 3. 估计场景辐射：通过将原始图像除以透射率来估计场景辐射，得到去雾后的图像。 在OpenCV中，可以使用以下函数来实现图像去雾： ```python import cv2 def dehaze(image, tmin=0.1, w=0.95): # 估计大气光照 dark_channel = cv2.min(image, axis=2) atmospheric_light = dark_channel.max() # 估计透射率 transmission = 1 - w * dark_channel / atmospheric_light transmission = cv2.max(transmission, tmin) # 估计场景辐射 scene_radiance = (image - atmospheric_light) / transmission + atmospheric_light scene_radiance = cv2.clip(scene_radiance, 0, 255).astype('uint8') return scene_radiance ``` 这是一个简单的图像去雾函数，其中`tmin`表示透射率的最小值，`w`表示透射率的权重。你可以根据具体的需求进行调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值