CLAHE的实现和研究

最新推荐文章于 2023-08-30 21:48:03 发布
最新推荐文章于 2023-08-30 21:48:03 发布
阅读量1.6k 收藏 6
点赞数
分类专栏： 直方图均衡化CLAHE
原文链接：https://www.cnblogs.com/jsxyhelu/p/6435601.html?utm_source=debugrun&utm_medium=referral
版权

CLAHE的实现和研究

CLAHE算法对于医学图像，特别是医学红外图像的增强效果非常明显。
在OpenCV中已经实现了CLAHE,但是它在使用过程中，存在参数选择的问题。为了从根本上搞明白，我参考了网络上的一些代码
实现了基于OpenCV的CLAHE实现和研究。从最基本的开始做，分别实现HE算法，AHE算法，CLHE算法和CLAHE算法。素材分别采用了手部和手臂的红外图片，同时调用OpenCV生成代码和自己编写代码进行比对。
调用代码和实现效果:
int _tmain( int argc, _TCHAR * argv[])
{
     //读入灰度的手部图像
    Mat src  = imread( "arm.jpg", 0);
    Mat dst  = src.clone();
    Mat HT_OpenCV;
    Mat HT_GO;
    Mat AHE_GO;
    Mat CLHE_GO;
    Mat CLAHE_Without_Interpolation;
    Mat CLAHE_OpenCV;
    Mat CLAHE_GO;
    Mat matInter;
     OpenCV HT 方法
    cv : :equalizeHist(src,HT_OpenCV);
     GO HT方法
    HT_GO  = eaualizeHist_GO(src);
     GO AHE方法
    AHE_GO  = aheGO(src);
     GO CLHE方法
    CLHE_GO  = clheGO(src);
     clahe不计算差值
    CLAHE_Without_Interpolation  = claheGoWithoutInterpolation(src);
     OpenCV CLAHE 方法
    Ptr <cv : :CLAHE > clahe  = createCLAHE(); //默认参数
    clahe - >apply(src, CLAHE_OpenCV);
     GO CLAHE方法
    CLAHE_GO  = claheGO(src);
 
     结果显示
    imshow( "原始图像",src);
    imshow( "OpencvHT",HT_OpenCV);
    imshow( "GOHT",HT_GO);
    imshow( "GOAHE",AHE_GO);
    imshow( "GOCLHE",CLHE_GO);
    imshow( "GOCLAHE",CLAHE_GO);
    imshow( "CLAHE_Without_Interpolation",CLAHE_Without_Interpolation);
    imshow( "OpencvCLAHE",CLAHE_OpenCV);
    waitKey();
     return  0;
}
原始图像
GOCLAHE效果
OpenCV CLAHE效果
HE算法： Mat eaualizeHist_GO(Mat src)
{
     int width  = src.cols;
     int height = src.rows;
    Mat HT_GO  = src.clone();
     int tmp[ 256]  ={ 0};
     float C[ 256]  = { 0. 0};
     int total  = width *height;  
     for ( int i = 0 ;i <src.rows;i ++)
    {
         for ( int j = 0;j <src.cols;j ++)
        {
             int index  = src.at <uchar >(i,j);
            tmp[index]  ++;
        }
    }
     //计算累积函数  
     for( int i  =  0;i  <  256 ; i ++){  
         if(i  ==  0)  
            C[i]  =  1.0f  * tmp[i]  / total;  
         else  
            C[i]  = C[i - 1]  +  1.0f  * tmp[i]  / total;  
    }  
     //这里的累积函数分配的方法非常直观高效
     for( int i  =  0;i  < src.rows;i ++){  
         for( int j  =  0;j  < src.cols;j ++){      
             int index  = src.at <uchar >(i,j);
            HT_GO.at <uchar >(i,j)  = C[index]  *  255  ;
        }  
    }  
     return HT_GO;
}
 
AHE算法:
Mat aheGO(Mat src, int _step  =  8)
{
    Mat AHE_GO  = src.clone();
     int block  = _step;
     int width  = src.cols;
     int height  = src.rows;
     int width_block  = width /block;  //每个小格子的长和宽
     int height_block  = height /block;
     //存储各个直方图  
     int tmp2[ 8 * 8][ 256]  ={ 0};
     float C2[ 8 * 8][ 256]  = { 0. 0};
     //分块
     int total  = width_block  * height_block; 
     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;  
             //遍历小块,计算直方图
             for( int ii  = start_x ; ii  < end_x ; ii ++)  
            {  
                 for( int jj  = start_y ; jj  < end_y ; jj ++)  
                {  
                     int index  =src.at <uchar >(jj,ii);
                    tmp2[num][index] ++;  
                }  
            } 
             //计算累积分布直方图  
             for( int k  =  0 ; k  <  256 ; k ++)  
            {  
                 if( k  ==  0)  
                    C2[num][k]  =  1.0f  * tmp2[num][k]  / total;  
                 else  
                    C2[num][k]  = C2[num][k - 1]  +  1.0f  * tmp2[num][k]  / total;  
            }  
        }
    }
     //将统计结果写入
     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;  
             //遍历小块,计算直方图
             for( int ii  = start_x ; ii  < end_x ; ii ++)  
            {  
                 for( int jj  = start_y ; jj  < end_y ; jj ++)  
                {  
                     int index  =src.at <uchar >(jj,ii);
                     //结果直接写入AHE_GO中去
                    AHE_GO.at <uchar >(jj,ii)  = C2[num][index]  *  255  ;
                }  
            } 
        }
    }
     return AHE_GO;
}
CLHE算法：
//这里是在全局直方图加入“限制对比度”方法
Mat clheGO(Mat src, int _step  =  8)
{
     int width  = src.cols;
     int height = src.rows;
    Mat CLHE_GO  = src.clone();
     int tmp[ 256]  ={ 0};
     float C[ 256]  = { 0. 0};
     int total  = width *height;  
     for ( int i = 0 ;i <src.rows;i ++)
    {
         for ( int j = 0;j <src.cols;j ++)
        {
             int index  = src.at <uchar >(i,j);
            tmp[index]  ++;
        }
    }
     /限制对比度计算部分,注意这个地方average的计算不一定科学
     int average  = width  * height  /  255 / 64;  
     int LIMIT  =  4  * average;  
     int steal  =  0;  
     for( int k  =  0 ; k  <  256 ; k ++)  
    {  
         if(tmp[k]  > LIMIT){  
            steal  += tmp[k]  - LIMIT;  
            tmp[k]  = LIMIT;  
        }  
    }  
     int bonus  = steal / 256;  
     //hand out the steals averagely  
     for( int k  =  0 ; k  <  256 ; k ++)  
    {  
        tmp[k]  += bonus;  
    }  
     ///
     //计算累积函数  
     for( int i  =  0;i  <  256 ; i ++){  
         if(i  ==  0)  
            C[i]  =  1.0f  * tmp[i]  / total;  
         else  
            C[i]  = C[i - 1]  +  1.0f  * tmp[i]  / total;  
    }  
     //这里的累积函数分配的方法非常直观高效
     for( int i  =  0;i  < src.rows;i ++){  
         for( int j  =  0;j  < src.cols;j ++){      
             int index  = src.at <uchar >(i,j);
            CLHE_GO.at <uchar >(i,j)  = C[index]  *  255  ;
        }  
    }  
     return CLHE_GO;
}
CLAHE不包括插值算法：
Mat claheGoWithoutInterpolation(Mat src,  int _step  =  8)
{
    Mat CLAHE_GO  = src.clone();
     int block  = _step; //pblock
     int width  = src.cols;
     int height = src.rows;
     int width_block  = width /block;  //每个小格子的长和宽
     int height_block  = height /block;
     //存储各个直方图  
     int tmp2[ 8 * 8][ 256]  ={ 0};
     float C2[ 8 * 8][ 256]  = { 0. 0};
     //分块
     int total  = width_block  * height_block; 
     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;  
             //遍历小块,计算直方图
             for( int ii  = start_x ; ii  < end_x ; ii ++)  
            {  
                 for( int jj  = start_y ; jj  < end_y ; jj ++)  
                {  
                     int index  =src.at <uchar >(jj,ii);
                    tmp2[num][index] ++;  
                }  
            } 
             //裁剪和增加操作，也就是clahe中的cl部分
             //这里的参数 对应《Gem》上面 fCliplimit  = 4  , uiNrBins  = 255
             int average  = width_block  * height_block  /  255;  
             int LIMIT  =  4  * average;  
             int steal  =  0;  
             for( int k  =  0 ; k  <  256 ; k ++)  
            {  
                 if(tmp2[num][k]  > LIMIT){  
                    steal  += tmp2[num][k]  - LIMIT;  
                    tmp2[num][k]  = LIMIT;  
                }  
            }  
             int bonus  = steal / 256;  
             //hand out the steals averagely  
             for( int k  =  0 ; k  <  256 ; k ++)  
            {  
                tmp2[num][k]  += bonus;  
            }  
             //计算累积分布直方图  
             for( int k  =  0 ; k  <  256 ; k ++)  
            {  
                 if( k  ==  0)  
                    C2[num][k]  =  1.0f  * tmp2[num][k]  / total;  
                 else  
                    C2[num][k]  = C2[num][k - 1]  +  1.0f  * tmp2[num][k]  / total;  
            }  
        }
    }
     //计算变换后的像素值  
     //将统计结果写入
     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;  
             //遍历小块,计算直方图
             for( int ii  = start_x ; ii  < end_x ; ii ++)  
            {  
                 for( int jj  = start_y ; jj  < end_y ; jj ++)  
                {  
                     int index  =src.at <uchar >(jj,ii);
                     //结果直接写入AHE_GO中去
                    CLAHE_GO.at <uchar >(jj,ii)  = C2[num][index]  *  255  ;
                }  
            } 
        }
    
     }  
     return CLAHE_GO;
}
CLAHE算法：
Mat claheGO(Mat src, int _step  =  8)
{
    Mat CLAHE_GO  = src.clone();
     int block  = _step; //pblock
     int width  = src.cols;
     int height = src.rows;
     int width_block  = width /block;  //每个小格子的长和宽
     int height_block  = height /block;
     //存储各个直方图  
     int tmp2[ 8 * 8][ 256]  ={ 0};
     float C2[ 8 * 8][ 256]  = { 0. 0};
     //分块
     int total  = width_block  * height_block; 
     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;  
             //遍历小块,计算直方图
             for( int ii  = start_x ; ii  < end_x ; ii ++)  
            {  
                 for( int jj  = start_y ; jj  < end_y ; jj ++)  
                {  
                     int index  =src.at <uchar >(jj,ii);
                    tmp2[num][index] ++;  
                }  
            } 
             //裁剪和增加操作，也就是clahe中的cl部分
             //这里的参数 对应《Gem》上面 fCliplimit  = 4  , uiNrBins  = 255
             int average  = width_block  * height_block  /  255;  
             //关于参数如何选择，需要进行讨论。不同的结果进行讨论
             //关于全局的时候，这里的这个cl如何算，需要进行讨论 
             int LIMIT  =  40  * average;  
             int steal  =  0;  
             for( int k  =  0 ; k  <  256 ; k ++)  
            {  
                 if(tmp2[num][k]  > LIMIT){  
                    steal  += tmp2[num][k]  - LIMIT;  
                    tmp2[num][k]  = LIMIT;  
                }  
            }  
             int bonus  = steal / 256;  
             //hand out the steals averagely  
             for( int k  =  0 ; k  <  256 ; k ++)  
            {  
                tmp2[num][k]  += bonus;  
            }  
             //计算累积分布直方图  
             for( int k  =  0 ; k  <  256 ; k ++)  
            {  
                 if( k  ==  0)  
                    C2[num][k]  =  1.0f  * tmp2[num][k]  / total;  
                 else  
                    C2[num][k]  = C2[num][k - 1]  +  1.0f  * tmp2[num][k]  / total;  
            }  
        }
    }
     //计算变换后的像素值  
     //根据像素点的位置，选择不同的计算方法  
     for( int  i  =  0 ; i  < width; i ++)  
    {  
         for( int j  =  0 ; j  < height; j ++)  
        {  
             //four coners  
             if(i  < = width_block / 2  && j  < = height_block / 2)  
            {  
                 int num  =  0;  
                CLAHE_GO.at <uchar >(j,i)  = ( int)(C2[num][CLAHE_GO.at <uchar >(j,i)]  *  255);  
            } else  if(i  < = width_block / 2  && j  > = ((block - 1) *height_block  + height_block / 2)){  
                 int num  = block *(block - 1);  
                CLAHE_GO.at <uchar >(j,i)  = ( int)(C2[num][CLAHE_GO.at <uchar >(j,i)]  *  255);  
            } else  if(i  > = ((block - 1) *width_block +width_block / 2)  && j  < = height_block / 2){  
                 int num  = block - 1;  
                CLAHE_GO.at <uchar >(j,i)  = ( int)(C2[num][CLAHE_GO.at <uchar >(j,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;  
                CLAHE_GO.at <uchar >(j,i)  = ( int)(C2[num][CLAHE_GO.at <uchar >(j,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;  
                CLAHE_GO.at <uchar >(j,i)  = ( int)((q *C2[num1][CLAHE_GO.at <uchar >(j,i)] + p *C2[num2][CLAHE_GO.at <uchar >(j,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;  
                CLAHE_GO.at <uchar >(j,i)  = ( int)((q *C2[num1][CLAHE_GO.at <uchar >(j,i)] + p *C2[num2][CLAHE_GO.at <uchar >(j,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;  
                CLAHE_GO.at <uchar >(j,i)  = ( int)((q *C2[num1][CLAHE_GO.at <uchar >(j,i)] + p *C2[num2][CLAHE_GO.at <uchar >(j,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;  
                CLAHE_GO.at <uchar >(j,i)  = ( int)((q *C2[num1][CLAHE_GO.at <uchar >(j,i)] + p *C2[num2][CLAHE_GO.at <uchar >(j,i)]) *  255);  
            }  
             //双线性插值
             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);  
                CLAHE_GO.at <uchar >(j,i)  = ( int)((u *v *C2[num4][CLAHE_GO.at <uchar >(j,i)]  +   
                    ( 1 -v) *( 1 -u) *C2[num1][CLAHE_GO.at <uchar >(j,i)]  +  
                    u *( 1 -v) *C2[num2][CLAHE_GO.at <uchar >(j,i)]  +  
                    v *( 1 -u) *C2[num3][CLAHE_GO.at <uchar >(j,i)])  *  255);  
            }  
             //最后这步，类似高斯平滑
            CLAHE_GO.at <uchar >(j,i)  = CLAHE_GO.at <uchar >(j,i)  + (CLAHE_GO.at <uchar >(j,i)  <<  8)  + (CLAHE_GO.at <uchar >(j,i)  <<  16);         
        }  
    }  
   return CLAHE_GO;
}
原始图像
GOCLAHE效果
OpenCV CLAHE效果
从结果上来看，GOCLAHE方法和OpenCV提供的CLAHE方法是一样的。
再放一组图片
代码实现之后，留下两个问题：
集中在这段代码
            //这里的参数 对应《Gem》上面 fCliplimit  = 4  , uiNrBins  = 255
             int average  = width_block  * height_block  /  255;  
             //关于参数如何选择，需要进行讨论。不同的结果进行讨论
             //关于全局的时候，这里的这个cl如何算，需要进行讨论 
             int LIMIT  =  40  * average;  
             int steal  =  0;  
1、在进行CLAHE中CL的计算，也就是限制对比度的计算的时候，参数的选择缺乏依据。在原始的《GEMS》中提供的参数中，  fCliplimit  = 4  , uiNrBins  = 255. 但是在OpenCV的默认参数中，这里是40.就本例而言，如果从结果上反推，我看10比较好。这里参数的选择缺乏依据；
2、CLHE是可以用来进行全局直方图增强的，那么这个时候，这个 average 如何计算，肯定不是width * height/255,这样就太大了，算出来的LIMIT根本没有办法获得。
但是就实现血管增强的效果而言，这些结果是远远不够的。一般来说，对于CLAHE计算出来的结果，进行Frangi增强或者使用超分辨率增强？结果就是要把血管区域强化出来。
p.s:
arm.jpg 和 hand.jpg
 
目前方向：图像拼接融合、图像识别 联系方式：jsxyhelu@foxmail.com
天地有道
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CLAHE_改进版直方图均衡化CLAHE_CLAHE_直方图均衡化_自适应均衡化_
10-02
对比度受限的自适应直方图均衡化算法（可直接运行）
计算机视觉OpenCV CLAHE C++源代码详细注释版
02-10
本资源为OpenCV CLAHE源代码改造而成： 1、去除了OPENCL处理相关的代码； 2、将其改造成了一个可以独立执行的程序； 3、增加了详细注释，在现有网上公开资料中没有如此详细透彻的注释。
retinex增强代码
01-23
retinex 增强图像源代码 增强图像清晰效果 ，
论文研究-一种多尺度低资源消耗的CLAHE算法 .pdf
08-16
一种多尺度低资源消耗的CLAHE算法，唐维旻，赵慧，CLAHE算法是一种基于直方图均衡的提升图像对比度的算法，其可以在较好地凸显图像的细节的同时避免图像出现对比度过度增强的问题。�
C++直方图均衡化源代码
02-13
一个基于c++和OpenCV的直方图均衡化源代码图像处理程序。供大家参考。
clahe（限制对比度自适应直方图均衡化）
Joson的博客
07-08 2万+
限制对比度自适应直方图均衡化 直方图均衡化(HE)数学原理：AHE（自适应直方图均衡）实现原理：CLAHE（ 限制对比度自适应直方图均衡化）原理：补充 ) 在讨论clahe(限制对比度自适应直方图均衡化),需要先了解关于直方图均衡化概念，观前提示很长。 代码实现 直方图均衡化(HE) 直方图均衡化(Histogram Equalization)是一种增强图像对比度(Image Contrast)的方法，其主要思想是将一副图像的直方图分布变成近似均匀分布，从而增强图像的对比度。 数学原理： 考虑一个离散的
CLAHE算法学习
热门推荐
On my way
12-30 2万+
0.前言 图像识别工程开发中需要增强图像对比度，便于后续处理，接触到了CLAHE（Contrast Limited Adaptive Histogram Equalization），记录一下其中的学习过程。 1.直方图均衡 1.1灰度直方图 灰度图中像素值的分布为0-255，以灰度值为横坐标，纵坐标为该灰度值对应的像素点数目/比例，则得到了灰度图像的直方图，体现的是图像中灰度的整体分布情况......
CLAHE算法
weixin_44797288的博客
04-03 7716
HE / AHE / CLAHE算法理解
基于FPGA的CLAHE图像增强算法设计
weixin_45962327的博客
08-02 3736
参考文献《基于FPGA的自适应直方图均衡算法的研究与实现》 CLAHE图像算法原理 CLAHE图像增强算法又称为对比度有限的自适应直方图均衡算法，其算法原理是通过有限的调整图像局部对比度来增强有效信号和抑制噪声信号。 CLAHE算法首先求解各个区域的直方图；然后基于期望阈值获得相应的裁剪限幅；接着按照灰度数不超过裁剪限幅的原则对灰度进行重新分配，将裁剪掉的部分均匀的分布到各个灰度级上；最后对图像灰度进行重新统计，计算直方图的累积分布函数（CDF）。 CLAHE算法求解主要包括计算直方图、CDF及其变换
ImageProcess(CLAHE)
11-02
这是编译好的CLAHE，MFC做的界面，核心代码C；
使用具有 3 级 FCM 聚类的阈值和 CLAHE 进行快速有效的医学图像分割-研究论文
06-10
医学图像分割是一种检查和提取医学输入数据不同部分的... 在图像分割之前，我们使用 CLAHE 来提高噪声图像的质量和分辨率，从而显着提高分割性能。 所提出的方法评估分区度量的不同指数值的性能，以实现更好的分割。
基于FPGA的自适应直方图均衡算法的研究与实现.pdf
07-13
基于FPGA的自适应直方图均衡算法的研究与实现.pdf
基于FPGA的自适应直方图均衡算法的研究与实现
01-12
为了避免图像中同一像素多次重复使用CLAHE算法，本文采用图像分区处理的方法，减少CLAHE算法的计算次数和总体计算时间，此外，通过FPGA实现该CLAHE算法，实现图像的实时高速自适应增强。结果表明：与算法软件运行...
论文研究-人眼灰度感知建模及其在图像增强中的应用.pdf
09-12
原直方图均衡化算法处理结果不理想，主要是...对比实验结果表明，提出算法相比于原直方图均衡化具有明显的改善效果，相比于CLAHE、BBHE以及HMF等直方图改进算法，也具有无需参数调节，增强效果显著和适应性强等优点。
CLAHE
sunsnow2的专栏
03-30 4202
1.简述      CLAHE同普通的自适应直方图均衡不同的地方主要是其对比度限幅。这个特性也可以应用到全局直方图均衡化中，即构成所谓的限制对比度直方图均衡（CLHE），但这在实际中很少使用。在CLAHE中，对于每个小区域都必须使用对比度限幅。CLAHE主要是用来克服AHE的过度放大噪音的问题。       这主要是通过限制AHE算法的对比提高程度来达到的。在指定的像素值周边的对比度放
自适应直方图均衡化（CLAHE）
最新发布
吃葡萄不吐葡萄皮
08-30 1992
当图像中存在广泛的对比度差异时，传统的直方图均衡化可能无法产生理想的结果。为了解决这个问题，引入了限制对比度自适应直方图均衡化（CLAHE）方法，它将图像分成小块，对每个小块进行直方图均衡化，并在均衡化过程中限制对比度增强的幅度。CLAHE 的意义在于它能够提高图像的视觉质量，同时避免了在局部区域过度增强对比度引起的噪声和伪影。4. 在进行直方图均衡化时，引入一个限制参数，它控制了对比度增强的程度。如果某个小块的直方图超过了这个限制，那么对比度增强会被限制，以避免过度增强。参数控制了对比度的限制程度，
OpenCV 对比度受限的自适应直方图均衡化(CLAHE) C++实现
cyf15238622067的博客
04-11 1万+
直方图均衡化（HE）是一种很常用的直方图类方法，基本思想是通过图像的灰度分布直方图确定一条映射曲线，用来对图像进行灰度变换，以达到提高图像对比度的目的。该映射曲线其实就是图像的累计分布直方图（CDF）（严格来说是呈正比例关系）。然而HE是对图像全局进行调整的方法，不能有效地提高局部对比度，而且某些场合效果会非常差。 对比度受限的自适应直方图均衡（CLAHE，Contrast Limited Ada...
AHE和CLAHE代码实现
05-20
AHE（自适应直方图均衡化）和CLAHE（对比度受限的自适应直方图均衡化）是两种图像增强技术。以下是Python中实现AHE和CLAHE的示例代码： AHE代码实现： ```python import cv2 import numpy as np def ahe(img, clip_limit=2.0, tile_size=8): """自适应直方图均衡化""" h, w = img.shape img_eq = np.zeros((h, w), dtype=np.uint8) for i in range(0, h, tile_size): for j in range(0, w, tile_size): # 获取当前块 block = img[i:i+tile_size, j:j+tile_size] # 计算当前块的直方图 hist, _ = np.histogram(block.flatten(), bins=256, range=(0, 255)) # 计算累积直方图 cdf = hist.cumsum() cdf = (cdf - cdf.min()) / (tile_size * tile_size - cdf.min()) # clip limit cdf = np.clip(cdf, 0, clip_limit) # 直方图均衡化 block_eq = np.interp(block.flatten(), np.arange(256), cdf * 255).astype(np.uint8) # 将均衡化后的块放回原图 img_eq[i:i+tile_size, j:j+tile_size] = block_eq.reshape((tile_size, tile_size)) return img_eq ``` CLAHE代码实现： ```python def clahe(img, clip_limit=2.0, tile_size=8): """对比度受限的自适应直方图均衡化""" h, w = img.shape img_eq = np.zeros((h, w), dtype=np.uint8) for i in range(0, h, tile_size): for j in range(0, w, tile_size): # 获取当前块 block = img[i:i+tile_size, j:j+tile_size] # 计算当前块的直方图 hist, _ = np.histogram(block.flatten(), bins=256, range=(0, 255)) # 计算累积直方图 cdf = hist.cumsum() cdf = (cdf - cdf.min()) / (tile_size * tile_size - cdf.min()) # clip limit cdf = np.clip(cdf, 0, clip_limit) # 直方图均衡化 block_eq = np.interp(block.flatten(), np.arange(256), cdf * 255).astype(np.uint8) # 将均衡化后的块放回原图 img_eq[i:i+tile_size, j:j+tile_size] = block_eq.reshape((tile_size, tile_size)) # 计算全局直方图 hist, _ = np.histogram(img_eq.flatten(), bins=256, range=(0, 255)) # clip limit cdf = hist.cumsum() cdf = (cdf - cdf.min()) / (h * w - cdf.min()) cdf = np.clip(cdf, 0, clip_limit) # 直方图均衡化 img_eq = np.interp(img_eq.flatten(), np.arange(256), cdf * 255).astype(np.uint8) img_eq = img_eq.reshape((h, w)) return img_eq ``` 以上代码中，`clip_limit`表示对比度限制因子，`tile_size`表示块的大小。在AHE中，每个块的直方图是独立计算的，而在CLAHE中，每个块的直方图都受到全局直方图的约束。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值