基于自适应对数映射的局部对比度增强算法

最新推荐文章于 2024-09-10 20:30:00 发布
最新推荐文章于 2024-09-10 20:30:00 发布
阅读量3.1k 收藏 35
点赞数 8
分类专栏： 图像基础算法处理 OpenCV 文章标签： tone mapping 局部对比度增强
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lz0499/article/details/109688841
版权

对比度增强 自适应对数映射 色调映射 图像处理 局部增强
关键词由CSDN通过智能技术生成

                                           基于自适应对数映射的局部对比度增强算法

目录

                                           基于自适应对数映射的局部对比度增强算算法

一 、应用背景

二、算法细节

三、具体实现

四、实际效果 

 

一 、应用背景

光照环境不是很好的环境下所拍摄的图片，要么不是太亮，要么就是太暗，不能很好的兼顾亮区和暗区的细节。解决方式有很多种，一种是使用宽动态的sensor，获取一帧长曝光图像和一帧短曝光图像，再将两帧图像进行融合，这种合成的方式可以获取到比较高动态范围图像。当然使用宽动态的sensor成本会比一般的非宽动态sensor高；另外一种是从软件上进行处理，一般这种处理方式称为Tone Mapping，译为色调映射。色调映射的方法既可以提高图像暗区细节又不过多损失亮区图像信息。

今天打算分享一篇论文《Local Contrast Enhancement based on Adaptive Logarithmic Mappings》，翻译过来即是：基于自适应对数映射的局部对比度增强算算法。算法的主要思路是：根据每个像素的邻域信息，对图像暗区使用凸色调映射函数（图1 左侧所示），提高暗区像素值；对图像亮区使用凹色调映射函数（图二右侧所示），减小亮区像素值。如下图1所示：

 

                                                                                                                    图1

 

二、算法细节

算法的主要思路为：

 

 

各部分含义如下：

一、对于任意给定的输入像素 I:\partial \rightarrow \left [ 0,255 \right ]，输出像素 {I}'主要计算公式为：

 

上述公式主要包含三部分：第一部分是映射函数 ，第二部分是权重映射函数 ，第三部分是转换函数 。

映射函数 是基于对数的色调映射函数，主要参数为 。定义为：

色调映射函数可以保证无论亮度范围多大，最亮的部分总是能够映射为255，其他亮度也能够平缓变化。但是有些图像如果压缩过大的话，将会损失图像的对比度。图二显示的是不同a 取值的图像。

                                                                                                                          图2

  • 权重映射。权重映射主要是用了三种方式，我只实现了第一种方式。利用高斯滤波计算其权重，然后再归一化到[0,1]。一方面消除噪声的影响，另一方面利用像素的邻域信息自适应在转换函数中确定不同等级的色调映射曲线。
  • 转换函数。转换函数定义为：

     

 

如图3所示：

                                                                                                                       图3

为了保证不同的 能够平滑转换， 一般设置为0.05。

对于彩色图像而言，我们作用于彩色图像的每一个通道，但是经过上述非线性处理之后，改变了原始图像R/G/B的比例关系，为了保证原始图像R/G/B的比例关系，需要进行以下处理：

其中， 是经过局部自适应对比度增强后的亮度值， 是原始图像的亮度值。

三、具体实现

参考代码为：

#include"cv.h"
#include"highgui.h"
#include"cxcore.h"
#include<stdio.h>
#include<stdlib.h>
#include"types.h"

void color_processing(IplImage *B, IplImage *G,IplImage *R,
					  IplImage *local_img,IplImage *loglocal_outimg,
					  int w,int h)
{
	float factor,rr,gg,bb,outmax;
	int i,j,step,nChannels;


	for(i = 0;i < h;i++)
	{
		for(j = 0;j <w;j++)
		{
			if( ((uchar*)(local_img->imageData+i*local_img->widthStep))[j] != 0)
			{
				factor = (float)(((uchar*)(loglocal_outimg->imageData+i*loglocal_outimg->widthStep))[j])/(float)(((uchar*)(local_img->imageData+i*local_img->widthStep))[j]);
				rr=  ((uchar*)(R->imageData+i*R->widthStep))[j]*factor;
				gg=  ((uchar*)(G->imageData+i*G->widthStep))[j]*factor;
				bb=  ((uchar*)(B->imageData+i*B->widthStep))[j]*factor;

				outmax = (rr > gg)?((rr > bb)?(rr):(bb)):((gg > bb)?(gg):(bb));

				if(outmax > 255)
				{
					rr *= 255.0f/outmax;
					gg *= 255.0f/outmax;
					bb *= 255.0f/outmax;
				}


				((uchar*)(R->imageData+i*R->widthStep))[j] = CLIP((int)(rr+0.5),0,255);
				((uchar*)(G->imageData+i*G->widthStep))[j] = CLIP((int)(gg+0.5),0,255);
				((uchar*)(B->imageData+i*B->widthStep))[j] = CLIP((int)(bb+0.5),0,255);
			}
			else
			{
				((uchar*)(R->imageData+i*R->widthStep))[j] = 0;
				((uchar*)(G->imageData+i*G->widthStep))[j] = 0;
				((uchar*)(B->imageData+i*B->widthStep))[j] = 0;

			}

		}
	}

}
void loglocal_correction(IplImage *local_img,IplImage *loglocal_outimg,float sigma,int w,int h,float gammalog)
{
	int i,j,aai;
	float pix,aag,aagmax,alpha,*imgdata,*alphavalue_imgdata,*loglocal_outimg_data,*local_imgdata;
	IplImage *local_img_normalize,*mask,*alphavalue;
	
	local_img_normalize = cvCreateImage(cvSize(w,h),IPL_DEPTH_32F,1);
	mask = cvCreateImage(cvSize(w,h),IPL_DEPTH_32F,1);
	alphavalue= cvCreateImage(cvSize(w,h),IPL_DEPTH_32F,1);
	
	cvZero(local_img_normalize);
	cvZero(mask);
	cvZero(alphavalue);



#if 0
	for(i = 0;i < h;i++)
	{

		for(j = 0;j < w;j++)
		{
			pix = ((uchar*)(local_img->imageData+i*local_img->widthStep))[j]/255.0;
			((float*)(local_img_normalize->imageData+i*local_img_normalize->widthStep))[j] = pix;
		}
	}
#endif 


	cvNormalize(local_img,local_img_normalize,0.0f,1.0f,CV_MINMAX,NULL);
	cvSmooth(local_img_normalize,mask,CV_GAUSSIAN,5,5,sigma,0);
	
	


	for(i = 0;i < h;i++)
	{
		for(j = 0;j < w;j++)
		{
			pix = ((float*)(mask->imageData+i*mask->widthStep))[j];

			if(pix <= 0.5)
			{
				 ((float*)(alphavalue->imageData+i*alphavalue->widthStep))[j] = 0.5-0.5*pow((pix/0.5),gammalog);
			}
			else
			{
				((float*)(alphavalue->imageData+i*alphavalue->widthStep))[j] = -(0.5-0.5*pow(((1-pix)/0.5),gammalog));
			}
			
		}
	}

	
	for(i = 0; i < h;i++)
	{
		for(j = 0; j < w;j++)
		{
			alpha = ((float*)(alphavalue->imageData+i*alphavalue->widthStep))[j];
			aagmax = 255.0f/log(fabs(alpha)*255+1);

			if(alpha > 0)
				aag= aagmax*log(alpha*(float)(((uchar*)(local_img->imageData+i*local_img->widthStep))[j])+1);
			if(alpha < 0)
				aag= 255.0f-aagmax*log(fabs(alpha)*(float)(255.0-((uchar*)(local_img->imageData+i*local_img->widthStep))[j])+1);
			
			if(alpha == 0)
				aag = (((uchar*)(local_img->imageData+i*local_img->widthStep))[j]);


			aai = (int)(aag+0.5);
			((uchar*)(loglocal_outimg->imageData+i*loglocal_outimg->widthStep))[j] = CLIP(aai,0,255);
		}
	}


	cvReleaseImage(&local_img_normalize);
	cvReleaseImage(&mask);
	cvReleaseImage(&alphavalue);
}


void Calc_aveage(IplImage *average_img,IplImage *B_img,IplImage *G_img,IplImage *R_img,int w,int h)
{
	int row,col,R,G,B;

	for(row = 0;row < h;row++)
	{
		for(col = 0; col<w;col++)
		{
			B = ((uchar*)(B_img->imageData+row*B_img->widthStep))[col];
			G = ((uchar*)(G_img->imageData+row*G_img->widthStep))[col];
			R = ((uchar*)(R_img->imageData+row*R_img->widthStep))[col];


			((uchar*)(average_img->imageData+row*average_img->widthStep))[col] = (uchar)((0.5+(float)B+(float)G+(float)R)/3.0);
		}
	}
	
}



void stretch_range(IplImage *average_img,IplImage *stretch_img,int min,int max,int w,int h)
{
	int i,j;
	uchar pix;

	
	if(max == min)
		return ;

	for(i = 0;i < h;i++)
	{
		for(j = 0;j < w;j++)
		{
			pix = ((uchar*)(average_img->imageData+i*average_img->widthStep))[j];
			
			pix = (int)(255.0*(float)(pix-min)/(max-min));
			pix = CLIP(pix,0,255);

			((uchar*)(stretch_img->imageData+i*stretch_img->widthStep))[j] = pix;
		}
	}


}






int main()
{
	double min,max;
	int w,h;
	CvPoint minloc,maxloc;
	CvSize img_size;
	IplImage *src ,*RImage,*GImage,*BImage,*Average_Image,*strech_Image,*loglocal_outimg,*mergeImg;
	
	src = cvLoadImage("input_3.bmp",-1);
	img_size = cvGetSize(src);
	w = img_size.width;
	h = img_size.height;

	RImage = cvCreateImage(img_size,IPL_DEPTH_8U,1);
	GImage = cvCreateImage(img_size,IPL_DEPTH_8U,1);
	BImage = cvCreateImage(img_size,IPL_DEPTH_8U,1);
	strech_Image = cvCreateImage(img_size,IPL_DEPTH_8U,1);
	Average_Image = cvCreateImage(img_size,IPL_DEPTH_8U,1);
	mergeImg = cvCreateImage(img_size,IPL_DEPTH_8U,3);
	loglocal_outimg = cvCreateImage(cvSize(w,h),IPL_DEPTH_8U,1);
	

	cvZero(RImage);
	cvZero(GImage);
	cvZero(BImage);
	cvZero(Average_Image);
	cvZero(strech_Image);
	cvZero(mergeImg);
	cvZero(loglocal_outimg);

	cvNamedWindow("Show original image",0);
	cvShowImage("Show original image",src);
	cvSplit(src,BImage,GImage,RImage,0);
	Calc_aveage(Average_Image,BImage,GImage,RImage,w,h);
	//cvNamedWindow("Show average image",0);
	//cvShowImage("Show average image",Average_Image);

	cvMinMaxLoc(Average_Image,&min,&max,&minloc,&maxloc,NULL);
	stretch_range(Average_Image,strech_Image,min,max,w,h);
	//cvNamedWindow("Show stretch image",0);
	//cvShowImage("Show stretch image",Average_Image);
	printf("min:%lf, max:%lf,int_min:%d,int_max:%d minloc:(%d,%d),maxloc:(%d,%d)\n",min,max,(int)min,(int)max,minloc.x,minloc.y,maxloc.x,maxloc.y);

	//Create weight image

	loglocal_correction(strech_Image,loglocal_outimg,20,w,h,0.05);
	color_processing(BImage,GImage,RImage,Average_Image,loglocal_outimg,w,h);


	cvMerge(BImage,GImage,RImage,NULL,mergeImg);
	cvNamedWindow("Merge image",0);
	cvShowImage("Merge image",mergeImg);
	cvSaveImage("input_3_out.bmp",mergeImg);

	cvWaitKey(0);
	//cvDestroyWindow("Show average image");
	//cvDestroyWindow("Show stretch image");
	cvDestroyWindow("Merge image");
	cvDestroyWindow("Show original image");

	cvReleaseImage(&RImage);
	cvReleaseImage(&GImage);
	cvReleaseImage(&BImage);
	cvReleaseImage(&src);
	cvReleaseImage(&Average_Image);
	cvReleaseImage(&strech_Image);
	cvReleaseImage(&mergeImg);
	cvReleaseImage(&loglocal_outimg);
	
	return 0;

}

四、实际效果 

对较暗图像处理：

 

 

 

 

 

 

 

 

对一般图像处理：

 

 

 

对于比较暗得图像还是可以处理得比较好，对于一般图像，一方面降低了对比度，一方面出现了亮度过渡不均匀得地方。

大熊背
关注
专栏目录
OpenCV 局部自适应对比度增强ACE算法 C++
cyf15238622067的博客
04-11 6370
图像的对比度增强算法在很多场合都有着重要的应用，特别是在医学图像上，这是因为在众多疾病的诊断中，医学图像的视觉检查时很有必要的。而医学图像由于本身及成像条件的限制，图像的对比度很低。因此，在这个方面已经开展了很多的研究。这种增强算法一般都遵循一定的视觉原则。众所周知，人眼对高频信号（边缘处等）比较敏感。虽然细节信息往往是高频信号，但是他们时常嵌入在大量的低频背景信号中，从而使得其视觉可见性降...
图像局部对比度增强算法
沉心修炼
06-21 7883
本算法为基于灰度值的局部对比度提升算法。     核心想法是：采用局部处理，提升某一点与周围像素点的差别。     算法流程：     选择一定大小模板（默认3*3）在图像滑动，对于当前点f(x,y)，计算其局部区域（8邻域）均值     average = 1/8（f(x-1,y-1)+f(x-1,y)+f(x-1,y+1)+f(x,y-1)+f(x-1,y)+
基于局部标准差的的局部对比度增强算法
05-26 2221
http://www.cnblogs.com/Imageshop/p/3324282.html
图像处理 -- ISP功能之局部对比度增强 LCE
最新发布
sz66cm 学习随笔
09-10 1655
局部对比度增强（Local Contrast Enhancement, LCE）是一种图像处理技术，旨在通过调整图像的局部区域对比度，增强图像细节和视觉效果。LCE 的实现方式多种多样，以下是几种常见的类型与算法说明。
使用局部标准差实现图像的局部对比度增强算法。
weixin_34334744的博客
09-16 806
      图像的对比度增强算法在很多场合都有着重要的应用，特别是在医学图像上，这是因为在众多疾病的诊断中，医学图像的视觉检查时很有必要的。而医学图像由于本身及成像条件的限制，图像的对比度很低。因此，在这个方面已经开展了很多的研究。这种增强算法一般都遵循一定的视觉原则。众所周知，人眼对高频信号（边缘处等）比较敏感。虽然细节信息往往是高频信号，但是他们时常嵌入在大量的低频背景信号中，从而使得其视觉可...
局部标准差实现对比度增强
weixin_33962621的博客
10-06 342
基于“局部标准差”的图像增强（原理、算法、代码） 一、理论          图像增强算法的基本原则是“降低低频区域，突出高频区域”，以此强化边缘，达到增强的目的。最简单的例子就是通过原始图像减去高斯模糊处理后的图像，就能够将边缘强化出来。          直方图均衡化也是一种非常常见的增强方法。但是为了避免背景的干扰，更倾向于采用“局部”方法进行处理。我们这里着重研究自适应对比度增强(A...
Tone Mapping算法系列二：一种自适应对数映射的高对比度图像显示技术及其速度优化。...
05-18
这篇文章介绍了一种名为自适应对数映射（Adaptive Logarithmic Mapping，ALM）的高对比度图像显示技术及其速度优化方法。该方法可以在显示高对比度图像时，保留图像的细节和色彩信息。ALM方法通过对原始图像进行对数...
Opencv c++对比度增强（1.多尺度Retinex；2.LICE-Retinex；3.自适应对数映射。）
m0_44975814的博客
08-17 1001
常用对比度增强：直方图均衡化、gamma变换、对数变换，基本可以解决常见的工业问题。本期主要讲述的是三种效果较好的对比度增强算法：1.多尺度Retinex；2. 自适应对数映射。Retinex 理论的基本内容是物体的颜色是由物体对长波（红）、中波（绿）和短波（蓝）光线的反射能力决定的，而不是由反射光强度的绝对值决定的；物体的色彩不受光照非均性的影响，具有一致性，即Retinex理论是以色感一致性（颜色恒常性）为基础的。
基于Retinex理论的自适应局部色调映射算法
其次，为了实现良好的动态范围压缩和画面表现力，作者引入了一个基于场景亮度值的对比度增强因子。这个因子能够根据实际亮度变化调整图像的色调和对比度，使得图像在保留细节的同时，能够更好地适应不同亮度区域的...
matlab基于亮度分区的自适应对数色调映射代码
04-05
3. 对于每个亮度区域，使用CLAHE算法进行对比度增强。 4. 对于每个亮度区域，使用对数色调映射算法进行色调映射。 5. 将处理后的亮度区域合并为最终图像。 您可以参考这些步骤，结合Matlab中提供的函数来实现您的...
局部对比度增强的CLAHE算法
11-16
基于局部对比度增强的CLAHE算法 --直方图增强
论文研究-亮度分区自适应对数色调映射算法.pdf
07-22
色调映射可将高动态范围图像显示在低动态范围显示器上。常用的对数全局色调映射算法由于压缩范围有限容易引起细节丢失，针对高动态范围图像的显示问题给出一种基于亮度分区的自适应对数色调映射算法。将高动态范围图像由RGB颜色空间转换为XYZ颜色空间以提取图像亮度信息，然后将亮度图分为高、中、低三个照度区域。根据区域亮度属性实施对数色调映射实现动态范围局部压缩，并进行融合处理以消除区域交界处的显示效果。同时采用双边滤波技术进行细节补偿。实验结果表明，此算法能有效压缩动态范围并再现真实场景信息，同时可以保留丰富的细节。
HDR图像色调映射的自适应色彩调节算法
10-15
对数压缩确保了高亮区域的对比度减弱和低亮度区域的细节增强，以适应人眼的视觉感知。CLAHE则进一步提高了局部对比度，使图像更具活力。 【色域处理】在色域，色彩恢复利用HSI色度空间的饱和度参数s来调整色彩深度...
【论文阅读】局部对比度增强算法：从LCM、PCM到ALCNet
轻舟的万重重山
08-01 9577
文章目录1. LCM: local contrast method(2014) 参考资料与文献： 参考博客1 1. LCM: local contrast method(2014) 目标局部对比度的计算方法： 第一步：计算周围8个邻域的平均像素值: 式中，NuN_uNu​表示子窗口中包含的像素数量，IjiI_j^iIji​表示第iii个子窗口内的第jjj个像素的像素值 第二步：计算局部对比度 中心子窗口与其邻域窗口的对比度可表示为： 式中，L0L_0L0​表示中心子窗口的像素最大值 第三步：计算LC
局部自适应自动色阶/对比度算法在图像增强上的应用
weixin_39450742的博客
07-06 655
本篇博文来自博主Imageshop，打赏或想要查阅更多内容可以移步至Imageshop。 转载自：https://www.cnblogs.com/Imageshop/p/3395968.html 侵删 在限制对比度自适应直方图均衡化算法原理、实现及效果一文中针对全局直方图均衡化的一些缺点，提出了分块的自适应均衡化技术，很好的克服了全局直方图均衡化的一些缺点，对于图像增强也有着显著的作用，我们稍微回顾下CLAHE的算法流程，简单的可以用下面的过程描述： for each Tile i...
OpenCv，局部自适应图像增强(Local Adaptive Contrast Enhancement)
EbowTang的练习场
01-03 9699
一、理论          图像增强算法的基本原则是“降低低频区域，突出高频区域”，以此强化边缘，达到增强的目的。最简单的例子就是通过原始图像减去高斯模糊处理后的图像，就能够将边缘强化出来。          直方图均衡化也是一种非常常见的增强方法。但是为了避免背景的干扰，更倾向于采用“局部”方法进行处理。我们这里着重研究自适应对比度增强(ACE)的相关内容。         ACE的定义和
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值