自适应直方图均衡（CLAHE) 代码及详细注释【OpenCV】

最新推荐文章于 2024-09-21 16:36:49 发布
最新推荐文章于 2024-09-21 16:36:49 发布
阅读量2.8w 收藏 82
点赞数 9
分类专栏： 图像处理算法 OpenCV 文章标签： opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/panda1234lee/article/details/52852765
版权

 

 效果图

 

标题

 

CLAHE简介

       HE 直方图增强，大家都不陌生，是一种比较古老的对比度增强算法，它有两种变体：AHE 和 CLAHE；两者都是自适应的增强算法，功能差不多，但是前者有一个很大的缺陷，就是有时候会过度放大图像中相同区域的噪声，为了解决这一问题，出现了 HE 的另一种改进算法，就是 CLAHE；CLAHE 是另外一种直方图均衡算法，CLAHE 和 AHE 的区别在于前者对区域对比度实行了限制，并且利用插值来加快计算。它能有效的增强或改善图像（局部）对比度，从而获取更多图像相关边缘信息有利于分割。还能够有效改善 AHE 中放大噪声的问题。另外，CLAHE 的有一个用途是被用来对图像去雾。

详细理论请参考博客 

OpenCV源码的本地路径： %OPENCV%\opencv\sources\modules\imgproc\src\clahe.cpp

clahe.cpp

// ----------------------------------------------------------------------
// CLAHE

namespace
{
	class CLAHE_CalcLut_Body : public cv::ParallelLoopBody
	{
	public:
		CLAHE_CalcLut_Body(const cv::Mat& src, cv::Mat& lut, cv::Size tileSize, int tilesX, int clipLimit, float lutScale) :
			src_(src), lut_(lut), tileSize_(tileSize), tilesX_(tilesX), clipLimit_(clipLimit), lutScale_(lutScale)
		{
		}

		void operator ()(const cv::Range& range) const;

	private:
		cv::Mat src_;
		mutable cv::Mat lut_;

		cv::Size tileSize_;
		int tilesX_;
		int clipLimit_;
		float lutScale_;
	};

	// 计算直方图查找表
	void CLAHE_CalcLut_Body::operator ()(const cv::Range& range) const
	{
		const int histSize = 256;

		uchar* tileLut = lut_.ptr(range.start);
		const size_t lut_step = lut_.step;	// size = tilesX_*tilesY_ * lut_step

		// Range(0, tilesX_ * tilesY_)，全图被分为tilesX_*tiles_Y个块
		for (int k = range.start; k < range.end; ++k, tileLut += lut_step)
		{
			// (tx, ty)表示当前所在是哪一块
			// (0, 0) (1, 0)...(tilesX_-1, 0) 
			// (0, 1) (1, 1)...(tilesX_-1, 1) 
			// ...
			// (0, tilesY_-1)... (tilesX_-1, tilesY_-1)
			const int ty = k / tilesX_;
			const int tx = k % tilesX_;

			// retrieve tile submatrix
			// 注意：tileSize.width表示分块的宽度，tileSize.height表示分块高度
			cv::Rect tileROI;
			tileROI.x = tx * tileSize_.width;	// 换算为全局坐标
			tileROI.y = ty * tileSize_.height;
			tileROI.width = tileSize_.width;
			tileROI.height = tileSize_.height;

			const cv::Mat tile = src_(tileROI);

			// calc histogram
			int tileHist[histSize] = { 0, };
			// 统计 ROI 的直方图
			int height = tileROI.height;
			const size_t sstep = tile.step;
			for (const uchar* ptr = tile.ptr<uchar>(0); height--; ptr += sstep)
			{
				int x = 0;
				for (; x <= tileROI.width - 4; x += 4)
				{
					int t0 = ptr[x], t1 = ptr[x + 1];
					tileHist[t0]++; tileHist[t1]++;
					t0 = ptr[x + 2]; t1 = ptr[x + 3];
					tileHist[t0]++; tileHist[t1]++;
				}

				for (; x < tileROI.width; ++x)
					tileHist[ptr[x]]++;
			}

			// clip histogram
			if (clipLimit_ > 0)
			{
				// how many pixels were clipped
				int clipped = 0;
				for (int i = 0; i < histSize; ++i)
				{
					// 超过裁剪阈值
					if (tileHist[i] > clipLimit_)
					{
						clipped += tileHist[i] - clipLimit_;
						tileHist[i] = clipLimit_;
					}
				}

				// redistribute clipped pixels
				int redistBatch = clipped / histSize;
				int residual = clipped - redistBatch * histSize;

				// 平均分配裁剪的差值到所有直方图
				for (int i = 0; i < histSize; ++i)
					tileHist[i] += redistBatch;

				// 处理差值的余数
				for (int i = 0; i < residual; ++i)
					tileHist[i]++;
			}

			// calc Lut
			int sum = 0;
			for (int i = 0; i < histSize; ++i)
			{
				// 累加直方图
				sum += tileHist[i];
				tileLut[i] = cv::saturate_cast<uchar>(sum * lutScale_);	// static_cast<float>(histSize - 1) / tileSizeTotal
			}
		}
	}

	class CLAHE_Interpolation_Body : public cv::ParallelLoopBody
	{
	public:
		CLAHE_Interpolation_Body(const cv::Mat& src, cv::Mat& dst, const cv::Mat& lut, cv::Size tileSize, int tilesX, int tilesY) :
			src_(src), dst_(dst), lut_(lut), tileSize_(tileSize), tilesX_(tilesX), tilesY_(tilesY)
		{
		}

		void operator ()(const cv::Range& range) const;

	private:
		cv::Mat src_;
		mutable cv::Mat dst_;
		cv::Mat lut_;

		cv::Size tileSize_;
		int tilesX_;
		int tilesY_;
	};

	// 根据相邻4块的直方图插值
	void CLAHE_Interpolation_Body::operator ()(const cv::Range& range) const
	{
		const size_t lut_step = lut_.step;
		// Range(0, src.rows)
		for (int y = range.start; y < range.end; ++y)
		{
			const uchar* srcRow = src_.ptr<uchar>(y);
			uchar* dstRow = dst_.ptr<uchar>(y);

			const float tyf = (static_cast<float>(y) / tileSize_.height) - 0.5f;

			int ty1 = cvFloor(tyf);
			int ty2 = ty1 + 1;

			// 差值作为插值的比例
			const float ya = tyf - ty1;

			ty1 = std::max(ty1, 0);
			ty2 = std::min(ty2, tilesY_ - 1);

			const uchar* lutPlane1 = lut_.ptr(ty1 * tilesX_);	// 当前块的直方图
			const uchar* lutPlane2 = lut_.ptr(ty2 * tilesX_);	// 向下一块的直方图

			for (int x = 0; x < src_.cols; ++x)
			{
				const float txf = (static_cast<float>(x) / tileSize_.width) - 0.5f;

				int tx1 = cvFloor(txf);
				int tx2 = tx1 + 1;

				// 差值作为插值的比例
				const float xa = txf - tx1;

				tx1 = std::max(tx1, 0);
				tx2 = std::min(tx2, tilesX_ - 1);

				// src_.ptr<uchar>(y)[x]
				const int srcVal = srcRow[x];

				// 索引 LUT
				const size_t ind1 = tx1 * lut_step + srcVal;
				const size_t ind2 = tx2 * lut_step + srcVal;  // 向右一块的直方图

				float res = 0;
				// 根据直方图的值进行插值
				// lut_.ptr(ty1 * tilesX_)[tx1 * lut_step + srcVa] => lut_[ty1][tx1][srcVal]
				res += lutPlane1[ind1] * ((1.0f - xa) * (1.0f - ya));
				res += lutPlane1[ind2] * ((xa) * (1.0f - ya));
				res += lutPlane2[ind1] * ((1.0f - xa) * (ya));
				res += lutPlane2[ind2] * ((xa) * (ya));

				dstRow[x] = cv::saturate_cast<uchar>(res);
			}
		}
	}

	class CLAHE_Impl : public cv::CLAHE
	{
	public:
		CLAHE_Impl(double clipLimit = 40.0, int tilesX = 8, int tilesY = 8);

		cv::AlgorithmInfo* info() const; // Algorithm类工厂方法封装相关

		void apply(cv::InputArray src, cv::OutputArray dst);

		void setClipLimit(double clipLimit);
		double getClipLimit() const;

		void setTilesGridSize(cv::Size tileGridSize);
		cv::Size getTilesGridSize() const;

		void collectGarbage();

	private:
		double clipLimit_;
		int tilesX_;
		int tilesY_;

		cv::Mat srcExt_;
		cv::Mat lut_;
	};

	CLAHE_Impl::CLAHE_Impl(double clipLimit, int tilesX, int tilesY) :
		clipLimit_(clipLimit), tilesX_(tilesX), tilesY_(tilesY)
	{
	}
        // Algorithm类工厂方法封装相关 
	//CV_INIT_ALGORITHM(CLAHE_Impl, "CLAHE",
	//	obj.info()->addParam(obj, "clipLimit", obj.clipLimit_);
	//obj.info()->addParam(obj, "tilesX", obj.tilesX_);
	//obj.info()->addParam(obj, "tilesY", obj.tilesY_))

		void CLAHE_Impl::apply(cv::InputArray _src, cv::OutputArray _dst)
	{
		cv::Mat src = _src.getMat();

		CV_Assert(src.type() == CV_8UC1);

		_dst.create(src.size(), src.type());
		cv::Mat dst = _dst.getMat();

		const int histSize = 256;
		// 准备 LUT，tilesX_*tilesY_个块，每个块都有256个柱子的直方图
		lut_.create(tilesX_ * tilesY_, histSize, CV_8UC1);

		cv::Size tileSize;
		cv::Mat srcForLut;

		// 如果分块刚好（整除）
		if (src.cols % tilesX_ == 0 && src.rows % tilesY_ == 0)
		{
			tileSize = cv::Size(src.cols / tilesX_, src.rows / tilesY_);
			srcForLut = src;
		}
		// 否则对原图进行扩充
		else
		{
			cv::copyMakeBorder(src, srcExt_, 0, tilesY_ - (src.rows % tilesY_), 0, tilesX_ - (src.cols % tilesX_), cv::BORDER_REFLECT_101);

			tileSize = cv::Size(srcExt_.cols / tilesX_, srcExt_.rows / tilesY_);
			srcForLut = srcExt_;
		}

		const int tileSizeTotal = tileSize.area();
		const float lutScale = static_cast<float>(histSize - 1) / tileSizeTotal;		// △

		// 计算实际的clipLimit
		int clipLimit = 0;
		if (clipLimit_ > 0.0)
		{
			clipLimit = static_cast<int>(clipLimit_ * tileSizeTotal / histSize);
			clipLimit = std::max(clipLimit, 1);
		}

		// 分块并行计算： LUT
		CLAHE_CalcLut_Body calcLutBody(srcForLut, lut_, tileSize, tilesX_, clipLimit, lutScale);
		cv::parallel_for_(cv::Range(0, tilesX_ * tilesY_), calcLutBody);

		// 分块并行计算： 根据直方图插值
		CLAHE_Interpolation_Body interpolationBody(src, dst, lut_, tileSize, tilesX_, tilesY_);
		cv::parallel_for_(cv::Range(0, src.rows), interpolationBody);
	}

	void CLAHE_Impl::setClipLimit(double clipLimit)
	{
		clipLimit_ = clipLimit;
	}

	double CLAHE_Impl::getClipLimit() const
	{
		return clipLimit_;
	}

	void CLAHE_Impl::setTilesGridSize(cv::Size tileGridSize)
	{
		tilesX_ = tileGridSize.width;
		tilesY_ = tileGridSize.height;
	}

	cv::Size CLAHE_Impl::getTilesGridSize() const
	{
		return cv::Size(tilesX_, tilesY_);
	}

	void CLAHE_Impl::collectGarbage()
	{
		srcExt_.release();
		lut_.release();
	}
}

cv::Ptr<cv::CLAHE> cv::createCLAHE(double clipLimit, cv::Size tileGridSize)
{
	return new CLAHE_Impl(clipLimit, tileGridSize.width, tileGridSize.height);
}


main.cpp

int main(int argc, char** argv)
{
	cv::Mat inp_img = cv::imread("D:/Pictures/beard.jpg");
	if (!inp_img.data) {
		cout << "Something Wrong";
		return -1;
	}
	namedWindow("Input Image", CV_WINDOW_AUTOSIZE);
	cv::imshow("Input Image", inp_img);

	cv::Mat clahe_img;
	cv::cvtColor(inp_img, clahe_img, CV_BGR2Lab);
	std::vector<cv::Mat> channels(3);
	cv::split(clahe_img, channels);

	cv::Ptr<cv::CLAHE> clahe = cv::createCLAHE();
	// 直方图的柱子高度大于计算后的ClipLimit的部分被裁剪掉，然后将其平均分配给整张直方图
	// 从而提升整个图像
	clahe->setClipLimit(4.);	// (int)(4.*(8*8)/256)
	//clahe->setTilesGridSize(Size(8, 8)); // 将图像分为8*8块
	cv::Mat dst;
	clahe->apply(channels[0], dst);
	dst.copyTo(channels[0]);
	cv::merge(channels, clahe_img);

	cv::Mat image_clahe;
	cv::cvtColor(clahe_img, image_clahe, CV_Lab2BGR);

	//cout << cvFloor(-1.5) << endl;

	namedWindow("CLAHE Image", CV_WINDOW_AUTOSIZE);
	cv::imshow("CLAHE Image", image_clahe);
	imwrite("out.jpg", image_clahe);
	cv::waitKey(0);
	destroyAllWindows();
	
	return 0;
}

 

注意：cv::ParallelLoopBody 位于 %OpenCV%\opencv\sources\modules\core\src\parallel.cpp

延伸阅读：Algorithm类工厂方法封装相关

 

ShaderJoy
关注
专栏目录
自适应直方图均衡化（CLAHE）：Python和C++源代码分享
2301_79366177的博客
09-06 519
然而，传统的直方图均衡化方法在全局范围内对图像进行操作，可能导致细节丢失和过度增强的问题。首先，我们将图像转换为Lab颜色空间，并提取亮度通道。接下来，我们将CLAHE算法应用于亮度通道，并将结果合并回Lab颜色空间。通过使用以上的Python和C++源代码，您可以在自己的项目中实现自适应直方图均衡化（CLAHE）算法，以增强图像的对比度并获得更好的视觉效果。首先，我们将图像转换为Lab颜色空间，这是因为CLAHE算法对亮度通道进行操作。在C++实现中，我们使用了OpenCV的C++接口，并使用了。
Python实现自适应直方图均衡化算法——CLAHE
TechCraze的博客
08-10 589
在数字图像处理领域，直方图均衡是一种经典的图像增强方法，通过调整图像的灰度分布，增加图像的对比度和细节，提升图像的质量。CLAHE同样是基于直方图均衡的思想，但引入了限制对比度的因素，使得图像的局部增强更加准确、有效，并降低了图像噪声的程度。可以看到，通过使用CLAHE增强方法，Lena图像的局部细节明显增强，同时并没有出现明显的噪声。总而言之，在进行数字图像处理和增强时，CLAHE是一种非常有用的算法，它能够针对图像的局部特征进行自适应增强，从而提高图像的质量和实用性。1.导入必要的库文件和图像。
【图像增强】双平台直方图均衡化（DPHE）
AomanHao的博客
04-14 1461
平台直方图均衡是对直方图均衡的一种修正方法。首先选择一个合适的平台阈值T，对统计直方图进行如下修正 ：如果某灰度级的直方图值大于平台阈值T，将其直方图值置为T，如果其直方图值小于平台阈值T ，则保持不变。Pt​kTifpkTPt​kpkpk<=T​其中，Pt​k表示处理后的灰度统计。
C++实现bmp格式图像直方图均衡化及对比度受限的自适应直方图均衡化(CLAHE)
weixin_42465397的博客
04-30 1473
关于直方图均衡化以及自适应直方图均衡化(CLAHE)的理论可以去查阅相关博客或者课本，这里只是分享对bmp格式的图片的直方图均衡化处理以及自适应直方图均衡化(CLAHE)处理的代码。 准备工作：首先你得有图像的像素信息，图像的宽度和高度等等。 代码中用到的变量以及定义预先说明下： int m_nWidth：图像的宽度 int m_nHe...
机器视觉-7 检测原理之预处理（图像增强）
kaimingD的博客
09-21 743
OpenCV 提供了丰富的图像增强工具，涵盖了从基本的亮度、对比度调整，到复杂的去噪、变换等高级操作。通过这些方法，用户可以大大改善图像质量，或为后续的计算机视觉任务做准备。结合不同的图像增强技术，能够帮助解决各种复杂的图像处理问题。直方图均衡化：改善对比度，适合光照不均的图像。CLAHE：自适应直方图均衡化，适合复杂的光照条件。亮度与对比度调整：直接线性调整图像的亮度和对比度。锐化：增强图像的边缘和细节。边缘检测：检测图像中的显著边缘。伽马校正：非线性调整图像的亮度，适合暗部细节增强。
matlab 直方图自适应,自适应直方图均衡算法 代码
weixin_39538607的博客
03-22 325
该楼层疑似违规已被系统折叠隐藏此楼查看此楼直方图均衡化问题一种自适应直方图均衡化我不知道如何确定阈值T，无法编出代码，求助，很急，下面是已编的普通直方图均衡算法代码请求帮忙继续编写确定阈值T的代码，确定了T自适应直方图均衡算法也就出来了，已有代码如下：clear;closeall%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%...
自适应直方图均衡化matlab 程序,直方图均衡化程序 matlab
weixin_36460573的博客
03-17 815
%直方图均衡化 I = imread('rice.png'); [height,width] = size(I); figure subplot(221) imshow(I)%显示原始图像 subplot(222) imhist(I)%显示原始图像直方图 %进行像素灰度统计; NumPixel = zeros(1,256);%统计各灰度...
CLAHE代码
sunny的专栏
01-14 3026
为了提高运行速度，把CLAHE的代码进行了修改，方便运行。 CLAHE.h class CLAHE { public: CLAHE(void); ~CLAHE(void); int m_nGridX; /* CLAHE 宽网格的个数 */ int m_nGridY; /* CLAHE 高网格的个数 */ unsigned char m_aLUT[256]; /* CL
计算机视觉算法探究：OpenCV CLAHE 插值算法详解
老猿Python
02-09 4580
本文介绍了 OpenCV 对比度受限的自适应直方图均衡 CLAHE 算法的图像插值算法。相关内容在网上公开资料中没有公布，是老猿断断续续花费了 4 个月时间研究剖析，并在春节期间花了大量精力整理的，对计算机视觉算法感兴趣但不熟悉自适应直方图均衡 CLAHE 算法的各位同好应该是非常有帮助的资料。
基于opencv对指定图像进行预处理操作，包括图像增强、平滑、二值化、腐蚀、膨胀等处理，完成车牌识别（代码请详细注释）
最新发布
10-19
# 可能使用的函数如 adaptiveThreshold 或者 clahe (自适应直方图均衡化) clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) enhanced_image = clahe.apply(image) # 平滑 - 使用高斯滤波器去除噪声 ...
OpenCV数字图像处理详细教程
qq_68608661的博客
02-28 2661
本文主要讲解了OpenCV图像处理的基本操作和方法，并且通过具体的示例代码来帮助理解，适用于图像处理的初学者，入门计算机视觉。
自适应直方图均衡化算法
03-22
C#项目，能够自定义块大小的自适应直方图均衡化算法。两种彩色图像处理方式。能手动调节块的长度和宽度。
自适应直方图均衡化
07-20
工程文件，里面包含了在C#条件下如何实现自实行直方图均衡化的代码
CLAHE_改进版直方图均衡化CLAHE_CLAHE_直方图均衡化_自适应均衡化_
10-02
对比度受限的自适应直方图均衡化算法（可直接运行）
请解释一下这段代码 def hisEqulColor(img): ## 将RGB图像转换到YCrCb空间中 ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCR_CB) # 将YCrCb图像通道分离 channels = cv2.split(ycrcb) # 以下代码详细注释见官网： # https://docs.opencv.org/4.1.0/d5/daf/tutorial_py_histogram_equalization.html clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) clahe.apply(channels[0], channels[0]) cv2.merge(channels, ycrcb) cv2.cvtColor(ycrcb, cv2.COLOR_YCR_CB2BGR, img) return img
05-16
3.使用cv2.createCLAHE()函数创建一个对比度受限的自适应直方图均衡化对象clahe，其中clipLimit=2.0表示对比度的限制因子，tileGridSize=(8,8)表示将图像分为8x8个小块进行处理。 4.对Y通道进行直方图均衡化处理，...
[机器学习——代码python】（带注释）
weixin_43461608的博客
08-06 528
clahe自适应均衡化 import cv2#导入opencv库 import matplotlib.pyplot as plt#调用画图的库 img = cv2.imread('timg.jpg',0) #0：读为读为灰度图像，1：读成彩色图像 res = cv2.equalizeHist(img)#直方图均衡化，归一化图像亮度和增强对比度 #createCLAHE:将图片分成很多小块，...
自适应的直方图均衡化，Python
Ms_Big的博客
01-21 700
所以在RGB颜色空间执行直方图均衡化时，可能会导致颜色偏移或饱和度的变化，尤其是在图像中存在颜色梯度或色调变化较大的情况下。因为RGB颜色空间中的通道彼此相关，而且均衡化一个通道可能会影响整体颜色平衡。在RGB颜色空间中进行直方图均衡化可能引入一些问题。RGB颜色空间对颜色信息和亮度信息进行了混合，而YUV或Lab颜色空间将亮度信息与颜色信息分离，使得对亮度通道进行均衡化更为直接。所以使用YUV或Lab颜色空间能提供了更好的色彩保真性。
opencv之自定义直方图均衡化
lrzss的博客
04-26 151
【代码】opencv之自定义直方图均衡化。
使用Python实现自适应直方图均衡化（CLAHE）处理不同分块大小的图像问题
.
07-16 543
随后，应用CLAHE对象获得CLAHE图像。下面给出实现自适应直方图均衡（CLAHE）处理不同分块大小的图像问题的Python代码。在数字图像处理中，直方图均衡是一种广泛使用的技术，用来增强图像的对比度。然而，传统的直方图均衡技术是基于全局像素值分布的，可能导致某些局部区域过度增强，丢失细节信息。这样，就解决了自适应直方图均衡（CLAHE）处理不同分块大小的图像问题。为了解决这一问题，自适应直方图均衡（CLAHE）结合了直方图均衡和局部自适应技术，使图像在局部细节保持不变的同时增强对比度。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ShaderJoy

您的打赏是我继续写博客的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值