CLAHE算法的OpenCV重构及详细解读

已于 2023-07-27 14:22:18 修改
阅读量1.1k 收藏 12
点赞数 3
分类专栏： 学习 文章标签： opencv 算法 重构
于 2023-04-23 17:01:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoukehu_CSDN/article/details/130325385
版权

OpenCV封装的CLAHE算法阅读起来比较麻烦，作者使用OpenCV在完全遵循原代码逻辑的基础上对该算法进行了重构，完整实现了OpenCV4.6.0中的CLAHE算法（包括16位图像和8位图像），代码如下：

void CLAHE16UC1(const cv::Mat& src,cv::Mat& dst,double clip = 40.0, cv::Size tiles = cv::Size(8,8));
void CLAHE8UC1(const cv::Mat& src,cv::Mat& dst,double clip = 40.0, cv::Size tiles = cv::Size(8,8));

void CLAHE16UC1(const cv::Mat& src,cv::Mat& dst,double clip, cv::Size tiles)
{
    if(src.type() != CV_16UC1)
        return;

    int histSize = 65536;
    //图像被划分为tilesX×tilesY个分块
    int tilesX = tiles.width;
    int tilesY = tiles.height;
    cv::Size tileSize;

    cv::Mat srcForLut;
    if (src.size().width % tilesX == 0 && src.size().height % tilesY == 0)
    {
        tileSize = cv::Size(src.size().width / tilesX, src.size().height / tilesY);
        srcForLut = src.clone();
    }
    else
    {
        cv::Mat srcExt;
        //图像边缘填充，保证用于计算LUT的图像其宽度和高度可以分别被tilesX和tilesY整除
        cv::copyMakeBorder(src, srcExt,0, tilesY - (src.size().height % tilesY),0, tilesX - (src.size().width % tilesX), cv::BORDER_REFLECT_101);
        tileSize = cv::Size(srcExt.size().width / tilesX, srcExt.size().height / tilesY);
        srcForLut = srcExt.clone();
    }

    //计算直方图“削峰填谷”的阈值，计算clipLimit的过程可以理解为：局部分块图像直方图平均频数的clip倍
    int clipLimit = static_cast<int>(clip * tileSize.area() / histSize);
    clipLimit = std::max(clipLimit, 1);

    cv::Mat lut(tilesX*tilesY, histSize,src.type()); //存储每个分块的LUT，则共有tilesX*tilesY个LUT，每个LUT有histSize个元素
    lut.setTo(0);

    int* tileHist = new int[histSize];

    //对每个块分别计算LUT，存在上面的lut里
    for(int ty=0;ty<tilesY;ty++)
    {
        for(int tx=0;tx<tilesX;tx++)
        {
            memset(tileHist,0,histSize*sizeof(int));
            ushort* tileLut = lut.ptr<ushort>(ty*tilesX+tx);

            cv::Rect tileRect;
            tileRect.x = tx * tileSize.width;
            tileRect.y = ty * tileSize.height;
            tileRect.width = tileSize.width;
            tileRect.height = tileSize.height;

            const cv::Mat tile = srcForLut(tileRect).clone();
            const ushort* pTile = tile.ptr<ushort>();

            //统计局部分块的直方图
            for(int i=0;i<tile.rows;i++)
            {
                for(int j=0;j<tile.cols;j++)
                {
                    tileHist[pTile[i*tile.cols+j]]++;
                }
            }

            if (clipLimit > 0)
            {
                //直方图“削峰”，并统计削去的像素数
                int clipped = 0;
                for (int i = 0; i < histSize; ++i)
                {
                    if (tileHist[i] > clipLimit)
                    {
                        clipped += (tileHist[i] - clipLimit);
                        tileHist[i] = clipLimit;
                    }
                }

                //将削去的像素个数平均分配给直方图的每个灰阶
                int redistBatch = clipped / histSize;
                int residual = clipped - redistBatch * histSize;

                //将削去的像素个数平均分配给直方图的每个灰阶，1）首先平均分配
                for (int i = 0; i < histSize; ++i)
                    tileHist[i] += redistBatch;

                //将削去的像素个数平均分配给直方图的每个灰阶，2）仍然有剩余的，直方图上等间距分配
                if (residual != 0)
                {
                    int residualStep = MAX(histSize / residual, 1);
                    for (int i = 0; i < histSize && residual > 0; i += residualStep, residual--)
                        tileHist[i]++;
                }
            }


            const float lutScale = cv::saturate_cast<float>(histSize - 1) / (tile.cols*tile.rows);

            //计算LUT
            int sum = 0;
            for (int i = 0; i < histSize; ++i)
            {
                sum += tileHist[i];
                tileLut[i] = cv::saturate_cast<ushort>(sum * lutScale);
            }
        }
    }

    delete [] tileHist;
    tileHist = NULL;

    float invTileW = 1.0f/tileSize.width;
    float invTileH = 1.0f/tileSize.height;

    dst.create(src.size(),CV_16UC1);
    ushort* pDst = dst.ptr<ushort>();
    const ushort* pSrc = src.ptr<ushort>();

    //对每个像素点，找到其4个近邻分块的LUT所映射的像素值，并进行双线性插值
    for(int i=0;i<src.rows;i++)
    {
        for(int j=0;j<src.cols;j++)
        {
            ushort pix = pSrc[i*src.cols+j];

            float txf = j*invTileW - 0.5f;

            int tx1 = cvFloor(txf);
            int tx2 = tx1 + 1; //注意这里，说明4个近邻分块是紧挨着的

            float px1 = txf - tx1;
            float px2 = 1.0f - px1;

            tx1 = std::max(tx1, 0);
            tx2 = std::min(tx2, tilesX - 1);

            float tyf = i*invTileH - 0.5f;

            int ty1 = cvFloor(tyf);
            int ty2 = ty1 + 1; //注意这里，说明4个近邻分块是紧挨着的

            float py1 = tyf - ty1;
            float py2 = 1.0f - py1;

            ty1 = std::max(ty1, 0);
            ty2 = std::min(ty2, tilesY - 1);

            ushort* tileLuty1x1 = lut.ptr<ushort>(ty1*tilesX+tx1);
            ushort* tileLuty1x2 = lut.ptr<ushort>(ty1*tilesX+tx2);

            ushort* tileLuty2x1 = lut.ptr<ushort>(ty2*tilesX+tx1);
            ushort* tileLuty2x2 = lut.ptr<ushort>(ty2*tilesX+tx2);

            //4个邻块的映射灰度值线性插值，先x方向，再y方向
            //注意：前面提到px1+px2=1.0和py1+py2=1.0，这里的px1，px2，py1，py2都是距离。在作为双线性插值的权重时，距离近的权重应大；反之亦然。
            //以x方向插值举例：距离为px1时，其权重应取1.0-px1，即px2；距离为px2时，其权重应取1.0-px2，即px1。
            pDst[i*src.cols+j] = cv::saturate_cast<ushort>(
                        (tileLuty1x1[pix]*px2+tileLuty1x2[pix]*px1)*py2+
                        (tileLuty2x1[pix]*px2+tileLuty2x2[pix]*px1)*py1);
        }
    }
}

void CLAHE8UC1(const cv::Mat& src,cv::Mat& dst,double clip, cv::Size tiles)
{
    if(src.type() != CV_8UC1)
        return;

    int histSize = 256;
    //图像被划分为tilesX×tilesY个分块
    int tilesX = tiles.width;
    int tilesY = tiles.height;
    cv::Size tileSize;

    cv::Mat srcForLut;
    if (src.size().width % tilesX == 0 && src.size().height % tilesY == 0)
    {
        tileSize = cv::Size(src.size().width / tilesX, src.size().height / tilesY);
        srcForLut = src.clone();
    }
    else
    {
        cv::Mat srcExt;
        //图像边缘填充，保证用于计算LUT的图像其宽度和高度可以分别被tilesX和tilesY整除
        cv::copyMakeBorder(src, srcExt,0, tilesY - (src.size().height % tilesY),0, tilesX - (src.size().width % tilesX), cv::BORDER_REFLECT_101);
        tileSize = cv::Size(srcExt.size().width / tilesX, srcExt.size().height / tilesY);
        srcForLut = srcExt.clone();
    }

    //计算直方图“削峰填谷”的阈值，计算clipLimit的过程可以理解为：局部分块图像直方图平均频数的clip倍
    int clipLimit = static_cast<int>(clip * tileSize.area() / histSize);
    clipLimit = std::max(clipLimit, 1);

    cv::Mat lut(tilesX*tilesY, histSize,src.type()); //存储每个分块的LUT，则共有tilesX*tilesY个LUT，每个LUT有histSize个元素
    lut.setTo(0);

    int* tileHist = new int[histSize];

    //对每个块分别计算LUT，存在上面的lut里
    for(int ty=0;ty<tilesY;ty++)
    {
        for(int tx=0;tx<tilesX;tx++)
        {
            memset(tileHist,0,histSize*sizeof(int));
            uchar* tileLut = lut.ptr<uchar>(ty*tilesX+tx);

            cv::Rect tileRect;
            tileRect.x = tx * tileSize.width;
            tileRect.y = ty * tileSize.height;
            tileRect.width = tileSize.width;
            tileRect.height = tileSize.height;

            const cv::Mat tile = srcForLut(tileRect).clone();
            const uchar* pTile = tile.ptr<uchar>();

            //统计局部分块的直方图
            for(int i=0;i<tile.rows;i++)
            {
                for(int j=0;j<tile.cols;j++)
                {
                    tileHist[pTile[i*tile.cols+j]]++;
                }
            }

            if (clipLimit > 0)
            {
                //直方图“削峰”，并统计削去的像素数
                int clipped = 0;
                for (int i = 0; i < histSize; ++i)
                {
                    if (tileHist[i] > clipLimit)
                    {
                        clipped += (tileHist[i] - clipLimit);
                        tileHist[i] = clipLimit;
                    }
                }

                //将削去的像素个数平均分配给直方图的每个灰阶
                int redistBatch = clipped / histSize;
                int residual = clipped - redistBatch * histSize;

                //将削去的像素个数平均分配给直方图的每个灰阶，1）首先平均分配
                for (int i = 0; i < histSize; ++i)
                    tileHist[i] += redistBatch;

                //将削去的像素个数平均分配给直方图的每个灰阶，2）仍然有剩余的，直方图上等间距分配
                if (residual != 0)
                {
                    int residualStep = MAX(histSize / residual, 1);
                    for (int i = 0; i < histSize && residual > 0; i += residualStep, residual--)
                        tileHist[i]++;
                }
            }


            const float lutScale = cv::saturate_cast<float>(histSize - 1) / (tile.cols*tile.rows);

            //计算LUT
            int sum = 0;
            for (int i = 0; i < histSize; ++i)
            {
                sum += tileHist[i];
                tileLut[i] = cv::saturate_cast<uchar>(sum * lutScale);
            }
        }
    }

    delete [] tileHist;
    tileHist = NULL;

    float invTileW = 1.0f/tileSize.width;
    float invTileH = 1.0f/tileSize.height;

    dst.create(src.size(),CV_8UC1);
    uchar* pDst = dst.ptr<uchar>();
    const uchar* pSrc = src.ptr<uchar>();

    //对每个像素点，找到其4个近邻分块的LUT所映射的像素值，并进行双线性插值
    for(int i=0;i<src.rows;i++)
    {
        for(int j=0;j<src.cols;j++)
        {
            uchar pix = pSrc[i*src.cols+j];

            float txf = j*invTileW - 0.5f;

            int tx1 = cvFloor(txf);
            int tx2 = tx1 + 1; //注意这里，说明4个近邻分块是紧挨着的

            float px1 = txf - tx1;
            float px2 = 1.0f - px1;

            tx1 = std::max(tx1, 0);
            tx2 = std::min(tx2, tilesX - 1);

            float tyf = i*invTileH - 0.5f;

            int ty1 = cvFloor(tyf);
            int ty2 = ty1 + 1; //注意这里，说明4个近邻分块是紧挨着的

            float py1 = tyf - ty1;
            float py2 = 1.0f - py1;

            ty1 = std::max(ty1, 0);
            ty2 = std::min(ty2, tilesY - 1);

            uchar* tileLuty1x1 = lut.ptr<uchar>(ty1*tilesX+tx1);
            uchar* tileLuty1x2 = lut.ptr<uchar>(ty1*tilesX+tx2);

            uchar* tileLuty2x1 = lut.ptr<uchar>(ty2*tilesX+tx1);
            uchar* tileLuty2x2 = lut.ptr<uchar>(ty2*tilesX+tx2);

            //4个邻块的映射灰度值线性插值，先x方向，再y方向
            //注意：前面提到px1+px2=1.0和py1+py2=1.0，这里的px1，px2，py1，py2都是距离。在作为双线性插值的权重时，距离近的权重应大；反之亦然。
            //以x方向插值举例：距离为px1时，其权重应取1.0-px1，即px2；距离为px2时，其权重应取1.0-px2，即px1。
            pDst[i*src.cols+j] = cv::saturate_cast<uchar>(
                        (tileLuty1x1[pix]*px2+tileLuty1x2[pix]*px1)*py2+
                        (tileLuty2x1[pix]*px2+tileLuty2x2[pix]*px1)*py1);
        }
    }
}

代码中比较难理解的是双线性插值时4个近邻块的选择方式，这里根据作者的理解给出示意图（以图像被均分为6*6块为例，其中红色小块表示当前处理像素点所在位置，绿色大块表示所选择的用于双线性插值的4个近邻块的位置），如下所示：
双线性插值近邻分块选择示意图
使用上述代码里的默认参数，8位图像处理效果如下：
原图像处理后

zhoukehu91
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
CLAHE_改进版直方图均衡化CLAHE_CLAHE_直方图均衡化_自适应均衡化_
10-02
对比度受限的自适应直方图均衡化算法（可直接运行）
OpenCV-Python对比度受限的自适应直方图均衡CLAHE知识介绍
老猿Python
10-24 7116
本文介绍了OpenCV-Python对比度受限的自适应直方图均衡CLAHE相关知识，可以看到CLAHE比全局直方图均衡对明暗分布不均匀的图像的改善效果更好，而进行CLAHE处理时，clipLimit值越大，对暗区域的改善效果越明显，但亮区域反而会起到反作用。
OpenCV 对比度受限的自适应直方图均衡化(CLAHE) C++实现
cyf15238622067的博客
04-11 1万+
直方图均衡化（HE）是一种很常用的直方图类方法，基本思想是通过图像的灰度分布直方图确定一条映射曲线，用来对图像进行灰度变换，以达到提高图像对比度的目的。该映射曲线其实就是图像的累计分布直方图（CDF）（严格来说是呈正比例关系）。然而HE是对图像全局进行调整的方法，不能有效地提高局部对比度，而且某些场合效果会非常差。 对比度受限的自适应直方图均衡（CLAHE，Contrast Limited Ada...
【图像增强】基于限制对比度直方图均衡化算法CLAHE实现图像增强附matlab代码
最新发布
m0_60703264的博客
04-30 1370
图像增强是计算机视觉领域中一项重要的技术，其目的是在不改变图像内容的前提下，改善图像的视觉效果，使其更容易被人类或机器理解。直方图均衡化 (Histogram Equalization, HE) 是一种经典的图像增强方法，但它容易导致图像局部对比度过高，产生噪声和伪影。为了解决这个问题，本文介绍了一种基于限制对比度直方图均衡化算法 (Contrast Limited Adaptive Histogram Equalization, CLAHE) 的图像增强方法。
OpenCv：直方图均衡化(HE)，自适应直方图均衡化(AHE)，限制对比度自适应直方图均衡化(CLAHE)
qq_40280673的博客
01-03 8965
总结了使用Python OpenCv处理图像直方图均衡化(HE)，自适应直方图均衡化(AHE)，限制对比度自适应直方图均衡化(CLAHE)的方法。
OpenCV CLAHE直方图均衡解析笔记
会飞的鱼的博客
02-05 579
OpenCV CLAHE直方图均衡解析笔记
OpenCV基础（16）OpenCV直方图均衡化和自适应直方图均衡化(CLAHE)
weixin_43229348的博客
09-29 9661
在本教程中，您将学习使用OpenCV实现直方图均衡化和自适应直方图均衡化(CLAHE)。 直方图均衡化是一种基本的图像处理技术，通过更新图像直方图的像素强度分布来调整图像的全局对比度。这样做可以使低对比度的区域在输出图像中获得更高的对比度。 本质上，直方图均衡化的工作原理是: 1.计算图像像素强度的直方图 2.均匀展开并分布最频繁的像素值(即直方图中计数最大的像素值) 3.给出累积分布函数(CDF)的线性趋势 应用直方图均衡化的结果是得到一幅全局对比度更高的图像。 我们可以进一步改进直方图均衡化，采用一
CLAHE算法
weixin_44797288的博客
04-03 8281
HE / AHE / CLAHE算法理解
CLAHE算法MATLAB代码 对比度受限自适应直方图均衡化算法
03-24
# CLAHE算法MATLAB代码 对比度受限自适应直方图均衡化算法 该 MATLAB 程序用于对给定图像执行对比度受限自适应直方图均衡化 (CLAHE)，写有详细中文注释。 CLAHE 算法可以提高图像的对比度和细节,改善图像质量。它...
基于python的CLAHE算法实现,包含注释
07-22
CLAHE算法是一种自适应的对比度调节算法，它跟原始的直方图均衡化算法的最大不同在于，它对于局部的细节保留都挺完好的，不会像全局的直方图均衡化那样，会损失很多细节。这个算法最精髓的地方是分块插值算法来加速...
clahe.rar_ clahe_CLAHE_clahe算法_显著图
09-20
在`clahe.cpp`和`clahe.h`这两个文件中，我们可以预期找到实现CLAHE算法的C++代码。`clahe.cpp`可能包含了CLAHE的主要算法实现，包括图像分割、直方图计算、对比度限制以及边界平滑等步骤。而`clahe.h`则可能是对应...
计算机视觉OpenCV CLAHE C++源代码详细注释版
02-10
本资源为OpenCV CLAHE源代码改造而成： 1、去除了OPENCL处理相关的代码； 2、将其改造成了一个可以独立执行的程序； 3、增加了详细注释，在现有网上公开资料中没有如此详细透彻的注释。
局部对比度增强的CLAHE算法
11-16
局部对比度增强的CLAHE（Contrast Limited Adaptive Histogram Equalization，限制性自适应直方图均衡化）算法是图像处理领域中的一种高级技术，主要用于提高图像的局部对比度，尤其适用于医学图像、卫星图像等对...
OpenCV-Python自适应直方图均衡类CLAHE及方法详解
热门推荐
老猿Python
10-21 2万+
本文介绍了OpenCV-Python对比度受限自适应直方图均衡变换的CLAHE类及其方法，并通过代码介绍了相关方法的使用。在单图像的对比度受限自适应直方图均衡时，只需要使用createCLAHE创建CLAHE对象，然后调用该对象apply方法就可以完成对比度受限自适应直方图均衡处理，该类的其他方法用处不大，但如果是要进行多次对比度受限自适应直方图均衡处理，且需要设置不同的分块数和受限阈值，则可以通过提供的方法直接修改对象属性再进行均衡处理即可。
opencv- CLAHE 有限对比适应性直方图均衡化
weixin_42367888的博客
11-22 2567
opencv- CLAHE 有限对比适应性直方图均衡化
CLAHE 算法学习 matlab
baidu_34971492的博客
07-06 3613
概念可参考： CLAHE (Contrast Limited Adaptive Histogram Equalization)算法学习CLAHE具体实现主要包括6个步骤。1）：分块。将输入图像划分为大小相等的不重叠子块，每个子块含有的像素数为M。参考示例为8×8块。 2）：计算子块直方图。 3）：计算剪切阈值clipLimit 4）：像素点重分配。对每个子块，使用步骤三中多余的像素重新分配。 5）：直方图均衡。 6）：像素点灰度值重构。（源码中采用了双线性插值） http://www.realtimer
限制对比度的自适应直方图均衡化（CLAHE）在opencv中的使用
凌桑的自我修养--You are the Eternity
05-24 1万+
1.CLAHE简介        HE直方图增强，大家都不陌生，是一种比较古老的对比度增强算法，它有两种变体：AHE和CLAHE；两者都是自适应的增强算法，功能差不多，但是前者有一个很大的缺陷，就是有时候会过度方法图像中相同区域的噪声问，为了解决这一问题，出现了HE的另一种改进算法，就是CLAHE；CLAHE是另外一种直方图均衡算法，能有效的增强或改善图像（局部）对比度，从而获取更多图像相关细节
OpenCV3.4.X中Nonfree模块的使用-SURF为例
zhoukehu
10-18 1万+
作者使用OpenCV3.4.3+VS2015+CMake3.8.2编译了包含opencv3.4.3以及opencv_contrib的完整的OpenCV库，因而能够使用tracking、saliency等非稳定模块。 在后续工作中又需要利用SURF进行实验，代码如下： Ptr&lt;SURF&gt; surf = SURF::create(100); 但是运行时直接报错，控制台提示如下（De...
红外目标检测算法与数据集
zhoukehu
06-17 5464
本文为作者在查找文献时发现的一些关于红外目标检测的算法和数据集。
不用opencv，实现clahe算法
07-15
如果你不想使用OpenCV库，你可以手动实现CLAHE算法。以下是一个基于NumPy库的简单实现示例： ```python import numpy as np def calculate_histogram(image): histogram = np.zeros(256, dtype=np.uint32) for i in range(image.shape[0]): for j in range(image.shape[1]): pixel_value = image[i, j] histogram[pixel_value] += 1 return histogram def apply_clahe(image, clip_limit=2.0, grid_size=(8, 8)): # 计算图像的直方图 histogram = calculate_histogram(image) # 计算累积直方图 cdf = np.cumsum(histogram) # 计算CLAHE增强后的图像 enhanced_image = np.zeros_like(image) for i in range(image.shape[0]): for j in range(image.shape[1]): pixel_value = image[i, j] # 计算分块的起始和结束坐标 block_start_i = (i // grid_size[0]) * grid_size[0] block_end_i = block_start_i + grid_size[0] block_start_j = (j // grid_size[1]) * grid_size[1] block_end_j = block_start_j + grid_size[1] # 计算分块内的直方图 block_histogram = histogram[pixel_value] block_histogram += cdf[pixel_value] - cdf[block_start_i:block_end_i, block_start_j:block_end_j].mean() # 限制对比度增强 block_histogram = np.clip(block_histogram, 0, clip_limit) # 将像素值映射到增强后的直方图范围 block_histogram = (block_histogram / clip_limit) * 255 # 更新增强后的像素值 enhanced_image[i, j] = block_histogram[pixel_value] return enhanced_image ``` 在上述代码中，`calculate_histogram`函数计算输入图像的直方图。`apply_clahe`函数接收输入图像、对比度限制（clip_limit）和分块大小（grid_size）作为参数，并应用CLAHE增强算法。 请注意，这只是一个简单的CLAHE实现示例，可能没有考虑到所有细节和优化。CLAHE算法涉及到图像分块、直方图计算、限制对比度增强等步骤，因此实现完整的CLAHE算法可能需要更复杂的代码。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值