C++实现bmp格式图像直方图均衡化及对比度受限的自适应直方图均衡化(CLAHE)

最新推荐文章于 2024-04-30 12:32:32 发布
最新推荐文章于 2024-04-30 12:32:32 发布
阅读量1.4k 收藏 19
点赞数 3
分类专栏： mfc图像处理 MFC 文章标签： VC图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42465397/article/details/105862683
版权

       关于直方图均衡化以及自适应直方图均衡化(CLAHE)的理论可以去查阅相关博客或者课本，这里只是分享对bmp格式的图片的直方图均衡化处理以及自适应直方图均衡化(CLAHE)处理的代码。

     准备工作：首先你得有图像的像素信息，图像的宽度和高度等等。

     代码中用到的变量以及定义预先说明下：

     int m_nWidth：图像的宽度

     int m_nHeight：图像的高度

     int m_nDibWidth：四字节对齐后的宽度，比如m_nWidth = 511，m_nDibWidth = 512。

     BYTE *m_pImage:原图像数据信息，其大小为m_nDibWidth*m_nHeight

     BYTE *m_pImage2:处理后的图像数据信息

下面贴直方图均衡化的代码：

int i, j,k;
	BYTE* p, *p2;
	int t,N = m_nWidth*m_nHeight;
	double hist[256] = {0};
	for (i = 0; i < m_nHeight; i++) {
		for (j = 0; j < m_nWidth; j++) {
			p = m_pImage + i*m_nDibWidth + j;
			hist[*p] = hist[*p] + 1.0/N;//计算直方图，归一化的直方图，类似概率密度
		}
	}
	double cum[256] = { 0 };
	cum[0] = hist[0];
	for (k = 1; k < 256; k++) {
		cum[k] = cum[k - 1] + hist[k];//计算累加
	}
	for (i = 0; i < m_nHeight; i++) {
		for (j = 0; j < m_nWidth; j++) {
			p = m_pImage + i*m_nDibWidth + j;
			p2 = m_pImage2 + i*m_nDibWidth + j;
			*p2 = (BYTE)(cum[*p] * 255);
		}
	}

 

 

下面贴自适应直方图均衡化(CLAHE)的代码：

// TODO: 在此添加控件通知处理程序代码
	int block = 8;
	//将图像均匀分成等矩形大小，8行8列64个块是常用的选择  
	int width_block = m_nWidth / block;
	int height_block = m_nHeight / block;
	
	//存储各个直方图 
	int **tmp = NULL;
	tmp = (int **)malloc(sizeof(int*)*block*block);       //arr在这里可以看出成数组，数组的每个成员都是指向int类型的指针，这样每个指针指向的代表一行，共row行   
	for (int i = 0; i<block*block; i++)            //为每行申请空间
	{
		tmp[i] = (int*)malloc(sizeof(int)* 256);       //每一行有col列
	}
	//存储累积函数  
	float **C = NULL;
	C = (float **)malloc(sizeof(float*)*block*block);       //arr在这里可以看出成数组，数组的每个成员都是指向int类型的指针，这样每个指针指向的代表一行，共row行   
	for (int i = 0; i<block*block; i++)            //为每行申请空间
	{
		C[i] = (float*)malloc(sizeof(float) * 256);       //每一行有col列
	}
	//初始化为0
	for (int i = 0; i < block*block; i++) {
		for (int j = 0; j < 256; j++) {
			C[i][j] = 0;
			tmp[i][j] = 0;
		}
	}

	//计算累积函数  
	for (int i = 0; i < block; i++)
	{
		for (int j = 0; j < block; j++)
		{
			int start_x = i * width_block;
			int end_x = start_x + width_block;
			int start_y = j * height_block;
			int end_y = start_y + height_block;
			int num = i + block*j;
			int total = width_block * height_block;
			for (int ii = start_x; ii < end_x; ii++)
			{
				for (int jj = start_y; jj < end_y; jj++)
				{
					int index = (int)(*(m_pImage + jj * m_nDibWidth + ii));
					tmp[num][index]++;
				}
			}


			//裁剪操作  
			int average = width_block * height_block / 255;
			int LIMIT = 4 * average;
			int steal = 0;
			for (int k = 0; k < 256; k++)
			{
				if (tmp[num][k] > LIMIT) {
					steal += tmp[num][k] - LIMIT;
					tmp[num][k] = LIMIT;
				}

			}

			int bonus = steal / 256;
			//hand out the steals averagely  
			for (int k = 0; k < 256; k++)
			{
				tmp[num][k] += bonus;
			}

			//计算累积分布直方图  
			for (int k = 0; k < 256; k++)
			{
				if (k == 0)
					C[num][k] = 1.0f * tmp[num][k] / total;
				else
					C[num][k] = C[num][k - 1] + 1.0f * tmp[num][k] / total;
			}

		}
	}

//	int[][] new_mat = new int[height][width];
	//计算变换后的像素值  
	//根据像素点的位置，选择不同的计算方法  
	for (int i = 0; i < m_nWidth; i++)
	{
		for (int j = 0; j < m_nHeight; j++)
		{
			//four coners  
			if (i <= width_block / 2 && j <= height_block / 2)
			{
				int num = 0;
				*(m_pImage2 + j*m_nDibWidth + i) = C[num][((int)(*(m_pImage + j*m_nDibWidth + i)))] * 255;
				
			}
			else if (i <= width_block / 2 && j >= ((block - 1)*height_block + height_block / 2)) {
				int num = block*(block - 1);
				*(m_pImage2 + j*m_nDibWidth + i) = C[num][((int)(*(m_pImage + j*m_nDibWidth + i)))] * 255;
				
			}
			else if (i >= ((block - 1)*width_block + width_block / 2) && j <= height_block / 2) {
				int num = block - 1;
				*(m_pImage2 + j*m_nDibWidth + i) = C[num][((int)(*(m_pImage + j*m_nDibWidth + i)))] * 255;
				
			}
			else if (i >= ((block - 1)*width_block + width_block / 2) && j >= ((block - 1)*height_block + height_block / 2)) {
				int num = block*block - 1;
				*(m_pImage2 + j*m_nDibWidth + i) = C[num][((int)(*(m_pImage + j*m_nDibWidth + i)))] * 255;
				
			}

			//four edges except coners  
			else if (i <= width_block / 2)
			{
				//线性插值  
				int num_i = 0;
				int num_j = (j - height_block / 2) / height_block;
				int num1 = num_j*block + num_i;
				int num2 = num1 + block;
				float p = (j - (num_j*height_block + height_block / 2)) / (1.0f*height_block);
				float q = 1 - p;
				*(m_pImage2 + j*m_nDibWidth + i) = ( q*C[num1][((int)(*(m_pImage + j*m_nDibWidth + i)))] + p*C[num2][((int)(*(m_pImage + j*m_nDibWidth + i)))] )*255;
				
			}
			else if (i >= ((block - 1)*width_block + width_block / 2)) {
				//线性插值  
				int num_i = block - 1;
				int num_j = (j - height_block / 2) / height_block;
				int num1 = num_j*block + num_i;
				int num2 = num1 + block;
				float p = (j - (num_j*height_block + height_block / 2)) / (1.0f*height_block);
				float q = 1 - p;
				*(m_pImage2 + j*m_nDibWidth + i) = (q*C[num1][((int)(*(m_pImage + j*m_nDibWidth + i)))] + p*C[num2][((int)(*(m_pImage + j*m_nDibWidth + i)))]) * 255;
				
			}
			else if (j <= height_block / 2) {
				//线性插值  
				int num_i = (i - width_block / 2) / width_block;
				int num_j = 0;
				int num1 = num_j*block + num_i;
				int num2 = num1 + 1;
				float p = (i - (num_i*width_block + width_block / 2)) / (1.0f*width_block);
				float q = 1 - p;
				*(m_pImage2 + j*m_nDibWidth + i) = (q*C[num1][((int)(*(m_pImage + j*m_nDibWidth + i)))] + p*C[num2][((int)(*(m_pImage + j*m_nDibWidth + i)))]) * 255;
				
			}
			else if (j >= ((block - 1)*height_block + height_block / 2)) {
				//线性插值  
				int num_i = (i - width_block / 2) / width_block;
				int num_j = block - 1;
				int num1 = num_j*block + num_i;
				int num2 = num1 + 1;
				float p = (i - (num_i*width_block + width_block / 2)) / (1.0f*width_block);
				float q = 1 - p;
				*(m_pImage2 + j*m_nDibWidth + i) = (q*C[num1][((int)(*(m_pImage + j*m_nDibWidth + i)))] + p*C[num2][((int)(*(m_pImage + j*m_nDibWidth + i)))]) * 255;
				
			}

			//inner area  
			else {
				int num_i = (i - width_block / 2) / width_block;
				int num_j = (j - height_block / 2) / height_block;
				int num1 = num_j*block + num_i;
				int num2 = num1 + 1;
				int num3 = num1 + block;
				int num4 = num2 + block;
				float u = (i - (num_i*width_block + width_block / 2)) / (1.0f*width_block);
				float v = (j - (num_j*height_block + height_block / 2)) / (1.0f*height_block);
				*(m_pImage2 + j * m_nDibWidth + i) = (int)((u*v*C[num4][((int)(*(m_pImage + j*m_nDibWidth + i)))] +
					(1 - v)*(1 - u)*C[num1][((int)(*(m_pImage + j*m_nDibWidth + i)))] +
					u*(1 - v)*C[num2][((int)(*(m_pImage + j*m_nDibWidth + i)))] +
					v*(1 - u)*C[num3][((int)(*(m_pImage + j*m_nDibWidth + i)))]) * 255);

			}
			*(m_pImage2 + j*m_nDibWidth + i) = *(m_pImage2 + j*m_nDibWidth + i) + (*(m_pImage2 + j*m_nDibWidth + i) << 8) + (*(m_pImage2 + j*m_nDibWidth + i) << 16);
		}
	}

只能说：灰度图片的效果对比度是提升了，但其色彩的不丰富性导致看起来可能不咋地。

              所以彩色图片的效果会更好些。

 

GallagherZ
关注
  • 3
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
CLAHE基础算法程序 c++
songyimin1208的博客
10-08 3359
转载来自：http://blog.csdn.net/yeyang911/article/details/22752935#include #include #include #include #include using namespace cv; using namespace std; void main() { Mat I; I = imread("D:\\ymrf\\enha
直方图均衡化—C++代码实现
我的博客
08-16 1294
本文主要介绍了基于直方图均衡化的图像增强方法，以及C++代码实现，也给出了相关的论文，供阅读参考
【图像增强】基于限制对比度直方图均衡化算法CLAHE实现图像增强附matlab代码
最新发布
m0_60703264的博客
04-30 1282
图像增强是计算机视觉领域中一项重要的技术，其目的是在不改变图像内容的前提下，改善图像的视觉效果，使其更容易被人类或机器理解。直方图均衡化 (Histogram Equalization, HE) 是一种经典的图像增强方法，但它容易导致图像局部对比度过高，产生噪声和伪影。为了解决这个问题，本文介绍了一种基于限制对比度直方图均衡化算法 (Contrast Limited Adaptive Histogram Equalization, CLAHE) 的图像增强方法。
直方图均衡化原理及C++实现
shentu7的博客
05-10 5860
直方图均衡化是常用的图像增强的方法。通过一种映射改变图像中的灰度值，增加图像灰度值的动态范围从而增加图像的对比度。过度曝光的图像中的灰度值主要集中在高亮度的范围内，而曝光不足的图像中的灰度值主要集中在低亮度的范围内。使用直方图均衡化技术可以使得整幅图像的灰度值均匀分布在整个动态范围，从而增加图像的对比度，提升视觉观感。 1、直方图的基本概念 首先介绍一下直方图的基本概念，直方图是对图像像素值的统计，一般像素值的范围为0~255；直方图是对各个不同灰度值的像素进行统计，下面是一张直方图。 下面 下面是几种图像
OpenCV自适应直方图均衡CLAHE C++源代码分享
老猿Python
11-24 6173
一、引言 最近收到几个网友提供OpenCV中CLAHE的源代码的请求，在此直接将OpenCV4.54版本CLAHE.CPP的源码分享出来。 二、OpenCV源代码的下载 下载地址：https://sourceforge.net/projects/opencvlibrary/files/ 有3.4.10–4.5.4的版本，但下载很慢，老猿费了很大的劲，大家可以考虑专门的下载工具下载。如果实在下不下来，请关注老猿Python的微信公号给老猿发消息。 三、CLAHE C++源代码 /*M////////////.
CLAHE对比度受限自适应直方图均衡化的MATLAB仿真+含代码操作演示视频
05-11
CLAHE对比度受限自适应直方图均衡化的MATLAB仿真+含代码操作演示视频 运行注意事项：使用matlab2021a或者更高版本测试，运行里面的Runme.m文件，不要直接运行子函数文件。运行时注意matlab左侧的当前文件夹窗口必须...
CLAHE_改进版直方图均衡化CLAHE_CLAHE_直方图均衡化_自适应均衡化_
10-02
对比度受限的自适应直方图均衡化算法（可直接运行）
matlab图像均衡化代码-CLAHE:对比度受限的自适应直方图均衡
05-22
对比度受限的自适应直方图均衡化更改您的裁剪限制以获得更好的输出。 简单的直方图方法存在强度饱和的问题，这会导致信息丢失，这在医学图像的情况下是不可接受的。 因此，无论何时我们想要保留图像的细节同时提高...
CLAHE.zip_CLAHE_CLAHE简单实现_scientific8bk_对比度自适应直方图均衡化_限制对比度
09-23
本算法介绍了对比度限制自适应直方图均衡化算法的实现，供读者学习
CLAHE算法MATLAB代码 对比度受限自适应直方图均衡化算法
03-24
该 MATLAB 程序用于对给定图像执行对比度受限自适应直方图均衡化 (CLAHE)，写有详细中文注释。 CLAHE 算法可以提高图像的对比度和细节,改善图像质量。它通过将图像划分为小块(称为"上下文区域")来操作,而不是直接对...
CLAHE_C代码.rar
03-02
对比度受限的自适应直方图均衡化方法的c代码
【个人笔记】OpenCV4 C++ 快速入门 26课
CSDN仅为笔记之用。
01-26 1380
26 直方图均衡化
C++ OpenCV实践：复杂划痕背景下检测缺陷
DU_YULIN的博客
10-02 3198
文章目录前言1.2. C++ OpenCV实现3. 结果展示：总结 前言 1. 2. C++ OpenCV实现 #include <opencv2\imgcodecs.hpp> #include <opencv2\core.hpp> #include <opencv2\imgproc.hpp> #include <opencv2\highgui.hpp> #include <vector> using namespace cv; int m
OpenCV实用：C++实现低对比度图像脏污区域检测
DU_YULIN的博客
09-24 6213
文章目录前言1. 低对比度图像脏污区域检测2. 实现方法介绍3. C++源码实现4.结果总结参考 前言 今天看了一篇技术文档感觉挺有意思，是关于在低对比度图像中检测脏污区域（这里的脏污指的是比其他区域暗的部分，人眼都不一定能看出来）。 1. 低对比度图像脏污区域检测 先上图： 第一张图如果不是标注结果，我都没有发现脏污区域在哪里，第二张图还清晰一些，基本可以看出来图像靠近左边缘的位置有偏暗的区域，这就是我们所说的脏污区域了，也是我们要检测的区域。 标注结果图（引用https://jishuin.pr
c++ opencv4.5.5 学习笔记（六 ）边缘检测（Sobel算子、Laplacian、Canny、LoG）
qq_45723275的博客
01-18 3211
Sobel算子边缘检测 //Sobel算子边缘检测 void photoSobel(const cv::Mat src, cv::Mat& dst) { /** * Sobel Sobel算子边缘检测器 * src 原始图 * dst 目标图 * ddepth 目标图像的所需深度，包括CV_16S/CV_32F/CV_64F等 * ksize 滤波器大小，通常可选为(5,5)或(3,3)，或直接使用缺省 **/ cv::Sobel(src, ds
使用C++实现图像直方图均衡化
爱CV
08-28 3339
开门见山，直方图均衡化属于图像增；强领域的范畴，为的是让灰度分布更为均匀。 直方图均衡化的实现有已下几个步骤： 1.遍历全图，计算统计各个灰度级所占的总像素的比例； 2.求联合灰度分布； 3.根据规则重新计算每个灰度级吓得灰度值； 4.更新灰度值； #include&lt;opencv2\opencv.hpp&gt; #include&lt;iostream&gt; using n...
图像处理3：直方图均衡化（c++）
weixin_37707670的博客
03-09 1151
目的：改善图像的视觉效果，便于对图像的分析和处理。 直方图均衡化：通过修改直方图来增强图像。 图像锐化法：增强图像的边缘或轮廓。 直方图均衡化 将原图像通过某种变换，得到一幅具有均匀分布灰度直方图的新图像。g(i,j)=G(f(i,j)) 变换函数满足条件： 在 0≤f(i,j)≤255内为单调递增函数，灰度级从黑到白次序不变。 0≤g(i,j)≤255，确保映射函数变化后的像素在允许的范围内。 //直方图均衡化 Mat equalizeHist(Mat image) { //图像灰度化 Mat
OpenCv：直方图均衡化(HE)，自适应直方图均衡化(AHE)，限制对比度自适应直方图均衡化(CLAHE)
qq_40280673的博客
01-03 8579
总结了使用Python OpenCv处理图像直方图均衡化(HE)，自适应直方图均衡化(AHE)，限制对比度自适应直方图均衡化(CLAHE)的方法。
限制对比度自适应直方图均衡化(CLAHE)
mvpboy123的博客
08-03 729
import cv2 import numpy as np import glob img_path = '/home/zhengsc/Desktop/double_up_res_aspp/Dataset/Linear_lesion/img/f2/' new_path1 = '/home/zhengsc/Desktop/huidu/CLAHE/' new_path2 = '/home/zhengsc/Desktop/huidu/1/' img = glob.glob(img_path+'*.png') #
对比图像灰度修正、图像直方图均衡化方法、对比度受限的自适应直方图均衡化（CLAHE）三种对比度增强方法
04-30
三种对比度增强方法分别为图像灰度修正、图像直方图均衡化方法、对比度受限的自适应直方图均衡化（CLAHE）。 1. 图像灰度修正 图像灰度修正是最简单的对比度增强方法之一，它只是将图像中的灰度值进行线性变换，使得原来的灰度范围映射到了更宽的范围上。该方法适用于一些简单的图像处理任务，但是对于复杂的图像处理任务，效果并不理想。 2. 图像直方图均衡化方法 图像直方图均衡化是一种比较常用的对比度增强方法，它通过对图像的灰度直方图进行均衡化处理，使得图像中的灰度值分布更加均匀，从而达到增强对比度的目的。该方法适用于一些中等复杂度的图像处理任务。 3. 对比度受限的自适应直方图均衡化（CLAHE） CLAHE是一种改进的直方图均衡化方法，它通过将图像分成很多小块，然后对每个小块进行直方图均衡化处理，从而达到增强对比度的目的。CLAHE方法适用于一些比较复杂的图像处理任务，能够更好地保留图像的局部细节信息。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

GallagherZ

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值