限制对比度自适应直方图均衡化（自我理解）

最新推荐文章于 2025-05-23 13:58:55 发布
最新推荐文章于 2025-05-23 13:58:55 发布
阅读量1w 收藏 69
点赞数 14
CC 4.0 BY-SA版权
分类专栏： 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u013066730/article/details/83000004

CLAHE算法对于医学图像，特别是医学红外图像的增强效果非常明显。

CLAHE  https://en.wikipedia.org/wiki/Adaptive_histogram_equalization

中文方面非常好的资料 限制对比度自适应直方图均衡化算法原理、实现及效果（我自己直接看解释没怎么看懂，不如直接看本篇博文下面的代码）

在OpenCV中已经实现了CLAHE,但是它在使用过程中，存在参数选择的问题。为了从根本上搞明白，我参考了网络上的一些代码

主要是来源 http://blog.youkuaiyun.com/abcd1992719g/article/details/25483395 （我觉的这篇博客的java代码更容易使人理解）

看完上面的java代码，我的理解：

首先你得了解直方图均衡化（https://blog.youkuaiyun.com/u013066730/article/details/82969768）。

限制对比度自适应直方图均衡化方法步骤为：

将整幅图像切分为5*5的块block（但通常代码中为8*8，但本文以5*5举例），如图一右侧的黑色实线框所示。

                                                 图一

接着计算每个block的累积分布，在计算累积分布时，限制一下他的对比度，别让直方图出现特别陡峭的情况，直观图像就如图二所示。具体操作就是将直方图中高于某个阈值a的数值全都找出来构成一个集合B，然后B中的每一个元素b都变为a，其中b高于a的部分进行求和得到c，c除以256（该256是指灰度等级，也就是0-255）得到d，将d加在每一个灰度等级下，其实就是图二中蓝色尖状部分变为平坦状。

                                  图二

累积分布求好后，就需要将原始图像中的每个像素值通过累积分布映射为新的像素值。其中使用了双线性插值的方法，而在使用双线性插值时，需要将原图重新分配，也就是图一的粉色，绿色和紫色区域。其中粉色区域的像素值就直接使用对应block的累积分布直接计算即可得到新的像素值（这里如何计算可以参考直方图均衡化）。绿色区域的像素值a，使用绿色区域中邻近的2个block的累计分布计算得到全新的2个像素值b1,b2，然后根据a与这两个block的距离比例得到求和比例c1,1-c1，所以原始像素a对应的最终像素d = b1*c1+b2*(1-c1)。紫色区域的像素值p，使用紫色区域中邻近的4个block的累积分布计算得到全新的4个像素值q1,q2,q3,q4，然后像素p根据与这4个block的距离远近得到对应比例，第一个block的比例为u,v（就是图一中紫色方框叉距离第一个黑色实心框的x，y的比例），第二个block的比例为1-u,v，第三个block的比例为u,1-v，第四个block的比例为1-u,1-v，所以原始像素p对应的最终结果i=u*v*q1+(1-u)*v*q2+u*(1-v)*q3+(1-u)*(1-v)*q4。

哎，我这里说的也有点乱，我感觉不如直接花点时间看下面的代码，真是一看就懂。

/* 
     * CLAHE 
     * 自适应直方图均衡化 
     */  
    public int[][] AHE(int[][] oldmat,int pblock)  
    {  
        int block = pblock;  
        //将图像均匀分成等矩形大小，8行8列64个块是常用的选择  
        int width_block = width/block;  
        int height_block = height/block;  
          
        //存储各个直方图  
        int[][] tmp = new int[block*block][256];  
        //存储累积函数  
        float[][] C = new float[block*block][256];  
          
        //计算累积函数  
        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 = oldmat[jj][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 < width; i++)  
        {  
            for(int j = 0 ; j < height; j++)  
            {  
                //four coners  
                if(i <= width_block/2 && j <= height_block/2)  
                {  
                    int num = 0;  
                    new_mat[j][i] = (int)(C[num][oldmat[j][i]] * 255);  
                }else if(i <= width_block/2 && j >= ((block-1)*height_block + height_block/2)){  
                    int num = block*(block-1);  
                    new_mat[j][i] = (int)(C[num][oldmat[j][i]] * 255);  
                }else if(i >= ((block-1)*width_block+width_block/2) && j <= height_block/2){  
                    int num = block-1;  
                    new_mat[j][i] = (int)(C[num][oldmat[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;  
                    new_mat[j][i] = (int)(C[num][oldmat[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;  
                    new_mat[j][i] = (int)((q*C[num1][oldmat[j][i]]+ p*C[num2][oldmat[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;  
                    new_mat[j][i] = (int)((q*C[num1][oldmat[j][i]]+ p*C[num2][oldmat[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;  
                    new_mat[j][i] = (int)((q*C[num1][oldmat[j][i]]+ p*C[num2][oldmat[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;  
                    new_mat[j][i] = (int)((q*C[num1][oldmat[j][i]]+ p*C[num2][oldmat[j][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);  
                    new_mat[j][i] = (int)((u*v*C[num4][oldmat[j][i]] +   
                            (1-v)*(1-u)*C[num1][oldmat[j][i]] +  
                            u*(1-v)*C[num2][oldmat[j][i]] +  
                            v*(1-u)*C[num3][oldmat[j][i]]) * 255);  
  
                }  
                  
                new_mat[j][i] = new_mat[j][i] + (new_mat[j][i] << 8) + (new_mat[j][i] << 16);         
            }  
        }  
          
        return new_mat;  
          
    }

 

图像增强：全局直方图均衡化与限制对比度自适应直方图均衡化（python程序）
yuxiaoye03222的博客
05-23 1677
主要分四个步骤： 计算图像的灰度直方图 计算灰度直方图的累加直方图 根据累加直方图和直方图均衡化原理得到输入灰度级和输出灰度级之间的映射关系 根据第三步得到的灰度级映射关系，循环得到输出图像的每一个像素的灰度级 import cv2 import numpy as np import sys import matplotlib.pyplot as plt import math import zengqiang_huidu #全局直方图均衡化，无参数 def equalHist(image):
基于MATLAB的限制对比度自适应直方图均衡化（CLAHE）实现
qq_39421053的博客
07-30 1239
限制对比度自适应直方图均衡化（CLAHE）通过对局部区域进行直方图均衡化，能有效地增强图像的对比度，并在保持图像细节的同时避免了过度增强的问题，文末附源码。
限制对比度自适应直方图均衡化（CLAHE）
热门推荐
Joson的博客
07-08 3万+
🌟 在探索CLAHE的奥秘之前，让我们先了解一下直方图均衡化的基础知识。温馨提示：本文内容较为深入，建议准备好一杯咖啡慢慢阅读。
【信道估计】MIMO4x4系统下对ZFMMSEML等线性预编码算法误码率性能的比较附matlab代码
Matlab_dashi的博客
04-16 1300
在多输入多输出 (MIMO) 系统中，信道估计是提高系统性能的关键技术。线性预编码算法是一种有效的信道估计方法，它通过在发送端对数据进行预编码，来提高接收端的信噪比。本文针对 MIMO 4x4 系统，对 ZF-MMSE-ML 等线性预编码算法的误码率性能进行了比较。通过仿真，分析了不同信道条件和不同算法参数对误码率的影响。结果表明，ZF-MMSE-ML 算法在高信噪比条件下具有较好的误码率性能，而 MMSE 算法在低信噪比条件下表现更佳。
第29周———Inception v3算法实战与解析
boooo_hhh的博客
05-23 487
🍨本文为🔗365天深度学习训练营中的学习记录博客🍖K同学啊相较于 Inception V1，它在结构上进行了多项优化，进一步提升了模型的准确率和计算效率。该网络引入了多个关键改进，如使用因式分解卷积（例如将 5×5 卷积分解为两个 3×3 卷积）以减少计算成本，引入批归一化（Batch Normalization）以加速收敛和提高稳定性，以及采用辅助分类器增强梯度传播。此外，Inception V3 还通过更加复杂的模块堆叠方式提高了模型对图像特征的表达能力。
自适应直方图均衡化
11-30
自适应直方图均衡化 对比度受限直方图均衡化
对比度受限的自适应直方图均衡化（CLAHE）
杯酒释兵权
01-26 3541
对比度受限的自适应直方图均衡化（CLAHE）直方图均衡化引言直方图均衡化直方图均衡化的概念直方图均衡化的计算简单举例 直方图均衡化 引言 图像增强的方法主要有： 直方图均衡化 直方图均衡化的概念 定义：通过图像灰度直方图均衡化处理，使得图像的灰度分布趋向于均匀，图像所占有的像素灰度间距拉开，加大了反差，改善视觉效果，达到图像增强的目的。 映射函数：原始图像灰度r的累计分布函数 S=T(r)=(L−1)∫0rpr(w)dwS=T(r)=(L-1)\int_0^rp_r(w)dwS=T(r)=(L−1)∫0
【图像增强】对比度限制自适应直方图均衡化
qq_36926037的博客
09-19 1万+
直方图均衡化一、直方图均衡化(HE)1.1 直方图均衡化1.2 直方图均衡化步骤1.3 直方图均衡化分析二、自适应直方图均衡化(AHE)2.1 自适应直方图均衡化2.2 自适应直方图均衡化分析三、限制对比度自适应直方图均衡化(CLAHE)3.1 限制对比度自适应直方图均衡化四、总结 一、直方图均衡化(HE) 1.1 直方图均衡化   特点： 暗图像的直方图分量集中在灰度较低的一端，而亮图像直方图分量偏向于灰度较高的一端。   图像的灰度分布不均匀，其灰度分布集中在更窄的范围，图像的细节不够清晰且对比度
CLAHE对比度受限自适应直方图均衡化的MATLAB仿真+含代码操作演示视频
05-11
CLAHE对比度受限自适应直方图均衡化的MATLAB仿真+含代码操作演示视频 运行注意事项：使用matlab2021a或者更高版本测试，运行里面的Runme.m文件，不要直接运行子函数文件。运行时注意matlab左侧的当前文件夹窗口必须...
自适应直方图均衡化算法
03-22
C#项目，能够自定义块大小的自适应直方图均衡化算法。两种彩色图像处理方式。能手动调节块的长度和宽度。
matlab图像均衡化代码-CLAHE:对比度受限的自适应直方图均衡
05-22
matlab图像均衡化代码克拉赫 对比度受限的自适应直方图均衡化更改您的裁剪限制以获得更好的输出。 简单的直方图方法存在强度饱和的问题，这会导致信息丢失，这在医学图像的情况下是不可接受的。 因此，无论何时我们想要保留图像的细节同时提高图像质量，CLAHE都是最好的选择之一。 在图像强度很暗的医学图像中，CLAHE可提供更好的图像。 运行代码的步骤： 打开MATLAB并转到存储fn_CLAHE.m的路径。 在“运行”中将图像名称指定为“ example.jpg” 运行程序并查看结果
自适应直方图均衡化算法在图像增强处理的应用
06-16
自适应直方图均衡化算法在图像增强处理的应用
自适应直方图均衡化方法_局部
03-01
对图像自动局部均衡化的程序，希望对大家有用，里面是C代码
限定对比度自适应直方图均衡化图像去雾
04-16
限定对比度自适应直方图均衡化图像去雾是一种先进的图像处理技术，用于改善视觉效果和图像质量。直方图均衡化是一种常用的方法，其基本思想是将原始图像的直方图分布改变为均匀分布，从而增强图像的对比度。然而，...
CLAHE.zip_CLAHE_CLAHE简单实现_scientific8bk_对比度自适应直方图均衡化_限制对比度
09-23
对比度自适应直方图均衡化（Contrast Limited Adaptive Histogram Equalization，简称CLAHE）是一种在图像处理领域中广泛使用的增强局部对比度的技术。相比于传统的全局直方图均衡化，CLAHE更注重于图像的局部区域，...
自适应直方图均衡化（CLAHE）
吃葡萄不吐葡萄皮
08-30 4764
当图像中存在广泛的对比度差异时，传统的直方图均衡化可能无法产生理想的结果。为了解决这个问题，引入了限制对比度自适应直方图均衡化（CLAHE）方法，它将图像分成小块，对每个小块进行直方图均衡化，并在均衡化过程中限制对比度增强的幅度。CLAHE 的意义在于它能够提高图像的视觉质量，同时避免了在局部区域过度增强对比度引起的噪声和伪影。4. 在进行直方图均衡化时，引入一个限制参数，它控制了对比度增强的程度。如果某个小块的直方图超过了这个限制，那么对比度增强会被限制，以避免过度增强。参数控制了对比度的限制程度，
限制对比度自适应直方图均衡化
weixin_43843322的博客
11-11 6377
1.累积分布函数： 累积分布函数(Cumulative Distribution Function)，又叫分布函数，是概率密度函数的积分，能完整描述一个实随机变量X的概率分布。一般以大写CDF标记,，与概率密度函数probability density function（小写pdf）相对。 对于所有实数 ，累积分布函数定义如下： 即累积分布函数表示：对离散变量而言，所有小于等于a的值出现概率的和 。 2.直方图均衡化(HE) 直方图均衡化(Histogram Equalization)是一种增强图像对
限制对比度直方图阈值均衡化
最新发布
07-24
<think>嗯，用户这次问的是图像处理中的CLAHE算法，看来是对专业算法有研究需求。从引用内容看，用户可能正在学习图像增强技术，或者需要解决实际图像处理问题。用户提供的引用资料比较详细，但有些零散，需要我系统性地整合。 用户的问题很明确：要求解释CLAHE的原理和应用。不过从引用的代码片段看，用户可能还关心具体实现细节。引用[1]和[2]都提到传统直方图均衡化的局限性，这正好是CLAHE的改进点。引用[3]的OpenCV代码示例很有价值，说明用户可能需要编程指导。 我需要从基础概念讲起，但要注意层次。首先应该解释为什么需要CLAHE——传统直方图均衡化在局部区域效果差，全局调整会导致噪声放大。然后分三步说明原理：分块处理、对比度限制、双线性插值。应用部分要突出实用性，比如医学影像和遥感这些对局部对比度敏感的场景。 用户提供的参考文献显示他们可能看过一些资料，但不够系统。我注意到引用[2]提到“某些场合效果非常差”，这点很重要，应该在算法局限性里强调。代码示例虽然给出了参数设置，但没解释clipLimit和网格尺寸的选择依据，这部分需要补充说明。 在组织回答时，考虑把数学公式单独呈现，比如直方图均衡化的变换函数$s_k = T(r_k) = \sum_{j=0}^{k}\frac{n_j}{n}$。但要注意用户可能不是数学专业，需要搭配文字解释。对于双线性插值这样的空间算法，用文字描述可能不够直观，考虑在相关问题里建议可视化资源。 最后的应用建议要具体。引用[3]的代码里clipLimit=4是个典型值，但没说明调整规则，这点在回答里需要展开。另外注意到用户贴的代码最后做了二值化处理，这可能是个特殊应用场景，不过在核心原理部分先不涉及。</think>### 限制对比度自适应直方图均衡化（CLAHE）算法原理及应用 #### 一、算法原理 CLAHE 是对传统直方图均衡化（HE）的改进，通过**局部处理**和**对比度限制**解决 HE 的缺陷： 1. **传统 HE 的局限性** HE 通过全局变换函数 $s_k = T(r_k) = \sum_{j=0}^{k}\frac{n_j}{n}$ 增强对比度（$r_k$ 为输入灰度，$n_j$ 为灰度级 $j$ 的像素数）。但会导致： - 局部区域对比度提升不足 - 噪声放大（尤其在均匀区域）[^2] 2. **自适应直方图均衡化（AHE）** - 将图像划分为 $M \times N$ 个小网格 - 对每个网格独立进行 HE，增强局部对比度 - **问题**：放大噪声，在平坦区域产生过度增强 3. **CLAHE 的核心改进** - **对比度限制** 预设裁剪阈值 $\beta$（如 clipLimit=4），限制每个网格直方图的高度。超出部分均匀分配到所有灰度级，确保变换函数斜率 $\frac{ds}{dr} \leq 1 + \beta$ *数学表达*： $$ h_{clip}(k) = \min(h(k), \beta) + \frac{\sum \max(h(k)-\beta, 0)}{K} $$ （$K$ 为灰度级数） - **双线性插值** 为避免网格边界伪影，对每个像素点的变换值由其周围 $4$ 个网格的变换函数插值得到： $$ s(x,y) = (1-a)(1-b)T_{ij}(r) + a(1-b)T_{i+1,j}(r) + (1-a)bT_{i,j+1}(r) + abT_{i+1,j+1}(r) $$ （$a,b$ 为相对位置权重） #### 二、应用场景 1. **医学影像**：增强 X 光、CT 的局部组织对比度，辅助病灶识别 2. **遥感图像**：提升地表纹理细节，如地质结构、植被分布 3. **低光照图像**：恢复暗区细节（如监控视频） 4. **计算机视觉**：作为特征提取的预处理步骤（如人脸检测） #### 三、代码实现（OpenCV 示例） ```python import cv2 import numpy as np # 读取图像并转为 Lab 色彩空间 bgr_img = cv2.imread("input.jpg") lab_img = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2Lab) l_channel, a_channel, b_channel = cv2.split(lab_img) # 创建 CLAHE 对象 clahe = cv2.createCLAHE(clipLimit=4.0, tileGridSize=(8,8)) # 关键参数 cl_channel = clahe.apply(l_channel) # 合并通道并转回 BGR enhanced_lab = cv2.merge((cl_channel, a_channel, b_channel)) result_img = cv2.cvtColor(enhanced_lab, cv2.COLOR_Lab2BGR) ``` **参数说明**： - `clipLimit`：对比度限制阈值（典型值 2-5） - `tileGridSize`：网格尺寸（如 (8,8) 表示 8×8 网格） #### 四、与传统 HE 效果对比 | 指标 | HE | CLAHE | |--------------|------------------|------------------| | 局部对比度 | 弱 | **强** | | 噪声控制 | 放大噪声 | **有效抑制** | | 均匀区域 | 过度增强 | **自然过渡** | | 计算复杂度 | 低 | 较高 | #### 五、局限性 - 需手动调整 `clipLimit` 和网格尺寸 - 高噪声图像仍需先降噪 - 边缘可能残留轻微块效应 > CLAHE 通过局部处理与对比度限制的平衡，显著提升了图像增强的实用性，成为医学影像、遥感等领域的标准预处理技术[^1][^3]。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值