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

最新推荐文章于 2024-08-16 09:51:20 发布
最新推荐文章于 2024-08-16 09:51:20 发布
阅读量2.7w 收藏 80
点赞数 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
关注
专栏目录
计算机视觉算法探究：OpenCV CLAHE 插值算法详解
老猿Python
02-09 4515
本文介绍了 OpenCV 对比度受限的自适应直方图均衡 CLAHE 算法的图像插值算法。相关内容在网上公开资料中没有公布，是老猿断断续续花费了 4 个月时间研究剖析，并在春节期间花了大量精力整理的，对计算机视觉算法感兴趣但不熟悉自适应直方图均衡 CLAHE 算法的各位同好应该是非常有帮助的资料。
基于OpenCV 和深度学习实现微笑检测-附免费源码
DT程序员的博客
07-07 839
基于OpenCV 和深度学习实现微笑检测，并提供免费源码
直方图均衡化的matlab实现
云淡风轻
12-06 1154
<br />clear all close all f = imread('./res/test.jpg'); [m, n] = size(f); pf = zeros(255, 1);%概率函数 maxpixels = size(f, 1) * size(f, 2); for i = 1:maxpixels pf(f(i)) = pf(f(i)) + 1; end pf = pf / maxpixels; c = zeros(255, 1);%对应于pf的累计概率函数 for
matlab 直方图自适应,自适应直方图均衡算法 代码
weixin_39538607的博客
03-22 313
该楼层疑似违规已被系统折叠隐藏此楼查看此楼直方图均衡化问题一种自适应直方图均衡化我不知道如何确定阈值T，无法编出代码，求助，很急，下面是已编的普通直方图均衡算法代码请求帮忙继续编写确定阈值T的代码，确定了T自适应直方图均衡算法也就出来了，已有代码如下：clear;closeall%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%...
OpenCV 直方图的应用（均衡化和图像比较）
最新发布
m0_37302966的博客
08-16 488
OpenCV 直方图的应用（均衡化和图像比较）
自适应直方图均衡化matlab 程序,直方图均衡化程序 matlab
weixin_36460573的博客
03-17 796
%直方图均衡化 I = imread('rice.png'); [height,width] = size(I); figure subplot(221) imshow(I)%显示原始图像 subplot(222) imhist(I)%显示原始图像直方图 %进行像素灰度统计; NumPixel = zeros(1,256);%统计各灰度...
自适应的直方图均衡化，Python
Ms_Big的博客
01-21 659
所以在RGB颜色空间执行直方图均衡化时，可能会导致颜色偏移或饱和度的变化，尤其是在图像中存在颜色梯度或色调变化较大的情况下。因为RGB颜色空间中的通道彼此相关，而且均衡化一个通道可能会影响整体颜色平衡。在RGB颜色空间中进行直方图均衡化可能引入一些问题。RGB颜色空间对颜色信息和亮度信息进行了混合，而YUV或Lab颜色空间将亮度信息与颜色信息分离，使得对亮度通道进行均衡化更为直接。所以使用YUV或Lab颜色空间能提供了更好的色彩保真性。
请解释一下这段代码 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通道进行直方图均衡化处理，...
使用OpenCv的一些总结，包括一些函数的使用方法以及效果
weixin_44500923的博客
05-25 571
OpenCv使用总结，主要是一些小trick一、图像增强相关函数（C++）二、其他的小Trick2.1图片镜像翻转功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出参考资料 一、图像增强相关函数（C++） 查看并显示图像的灰度分布 Sh
自适应直方图均衡化算法
03-22
C#项目，能够自定义块大小的自适应直方图均衡化算法。两种彩色图像处理方式。能手动调节块的长度和宽度。
自适应直方图均衡化
07-20
工程文件，里面包含了在C#条件下如何实现自实行直方图均衡化的代码
CLAHE_改进版直方图均衡化CLAHE_CLAHE_直方图均衡化_自适应均衡化_
10-02
对比度受限的自适应直方图均衡化算法（可直接运行）
VINS-Mono 代码详细解读——视觉跟踪 feature_trackers
try_again_later的博客
03-13 5338
原理 视觉： 1）提取Harris角点，KLT金字塔光流跟踪相邻帧； 2）2 维特征点先矫正为不失真的，然后在通过外点剔除后投影到一个单位球面上； 3）去除异常点：先进行F矩阵测试，通过RANSAC去除异常点； 4）关键帧选取：1、当前帧相对最近的关键帧的特征平均视差大于一个阈值就为关键帧（因为视差可以根据平移和旋转共同得到，而纯旋转则导致不能三角化成功，所以这一步需要IMU预积分进...
opencv之自定义直方图均衡化
lrzss的博客
04-26 133
【代码】opencv之自定义直方图均衡化。
C++实现bmp格式图像直方图均衡化及对比度受限的自适应直方图均衡化(CLAHE)
weixin_42465397的博客
04-30 1449
关于直方图均衡化以及自适应直方图均衡化(CLAHE)的理论可以去查阅相关博客或者课本，这里只是分享对bmp格式的图片的直方图均衡化处理以及自适应直方图均衡化(CLAHE)处理的代码。 准备工作：首先你得有图像的像素信息，图像的宽度和高度等等。 代码中用到的变量以及定义预先说明下： int m_nWidth：图像的宽度 int m_nHe...
自适应直方图均衡化CLAHE
ye1256的博客
03-01 1013
自适应直方图均衡化CLAHE
联合双边滤波器（joint bilateral filter)【OpenCV】
热门推荐
ShaderJoy 的兴趣技术杂货铺
10-17 2万+
转载自：pplong的博客 前面介绍了双边滤波器（bilateral filter,LBF），然而BF的权值是不稳定的，因此在边缘附近会出现一些翻转。此外BF计算复杂度是O(r^2)；为了改善BF权值的稳定性，引入了联合双边滤波器（joint bilateral filter ,LBF)。两者之间的差别就是JBF用了一个导向图作为值域权重的计算依据。下面我们通过数学公式展示二者的不同： 先看B
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ShaderJoy

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

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

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

打赏作者

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

抵扣说明：

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

余额充值