CLAHE

最新推荐文章于 2024-04-30 12:32:32 发布
最新推荐文章于 2024-04-30 12:32:32 发布
阅读量3.3k 收藏 14
点赞数 1
分类专栏： # opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pc153262603/article/details/73866524
版权

实现了基于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;
}

HE算法：Mat eaualizeHist_GO(Mat src)

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;
}

我自己写的main函数

int main()
{
    Mat src = imread("12.jpg");
    Mat original= imread("12.jpg");
    //cvtColor(src,gray,COLOR_BGR2GRAY);
    std::vector<cv::Mat> channels(3);
    cv::split(src, channels);


    channels.at(0) = claheGO(channels.at(0));
    channels.at(1) = claheGO(channels.at(1));
    channels.at(2) = claheGO(channels.at(2));
    merge(channels, src);
    imshow("original", original);
    imshow("final", src);
    //imwrite("RGB合并", src);
    //imwrite("gray", src);
    cv::waitKey(0);
    //destroyAllWindows();

    return 0;
}
春江花月夜晨
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
clahe matlab代码
03-05
CLAHE（Contrast Limited Adaptive Histogram Equalization，限制对比度的自适应直方图均衡化）是一种图像处理技术，主要用于改善图像的局部对比度，尤其在医学影像、遥感图像等领域广泛应用。MATLAB作为强大的数值...
基于python的CLAHE算法实现,包含注释
07-22
CLAHE算法是一种自适应的对比度调节算法，它跟原始的直方图均衡化算法的最大不同在于，它对于局部的细节保留都挺完好的，不会像全局的直方图均衡化那样，会损失很多细节。这个算法最精髓的地方是分块插值算法来加速...
直方图均衡化
kebu12345678的博客
01-30 1万+
直方图均衡化(Histogram Equalization)是一种增强图像对比度(Image Contrast)的方法，其主要思想是将一副图像的直方图分布变成近似均匀分布，从而增强图像的对比度。直方图均衡化虽然只是数字图像处理(Digital Image Processing)里面的基本方法，但是其作用很强大，是一种很经典的算法。 下面，本文会介绍一些直方图均衡化方面的知识和方法，包括以下几个部分： 直方图均衡化与对比度增强 直方图均衡化(HE)原理和实现 自适应直方图均衡化(AHE)原理和实现
CLAHE算法的OpenCV重构及详细解读
zhoukehu
04-23 1179
CLAHE算法的OpenCV重构及详细解读。
【图像增强】基于限制对比度直方图均衡化算法CLAHE实现图像增强附matlab代码
最新发布
m0_60703264的博客
04-30 1329
图像增强是计算机视觉领域中一项重要的技术，其目的是在不改变图像内容的前提下，改善图像的视觉效果，使其更容易被人类或机器理解。直方图均衡化 (Histogram Equalization, HE) 是一种经典的图像增强方法，但它容易导致图像局部对比度过高，产生噪声和伪影。为了解决这个问题，本文介绍了一种基于限制对比度直方图均衡化算法 (Contrast Limited Adaptive Histogram Equalization, CLAHE) 的图像增强方法。
OpenCV-Python对比度受限的自适应直方图均衡CLAHE知识介绍
老猿Python
10-24 7097
本文介绍了OpenCV-Python对比度受限的自适应直方图均衡CLAHE相关知识，可以看到CLAHE比全局直方图均衡对明暗分布不均匀的图像的改善效果更好，而进行CLAHE处理时，clipLimit值越大，对暗区域的改善效果越明显，但亮区域反而会起到反作用。
【Qt&OpenCV 直方图均衡 CLAHE】
richard_yuu的博客
11-18 992
关于利用Qt构建GUI并使用OpenCV中的CLAHE进行直方图均衡处理。CLAHE类是OpenCV中进行对比度受限的自适应直方图均衡的基类。
COI实验室技能：常见的图像增强算法（含MATLAB代码）
小山山的博客
09-30 1万+
成像系统采集到的图片有时不一定具有很好的图像质量，往往需要进行一些图像增强的操作。本文主要整理了几种常见的图像增强算法，包括：同态滤波、CLAHE、Retinex、导向滤波、全局低照度增强等等。这些图像增强算法可以改变图像的对比度分布，使得图像视觉效果更好。下面将给出每个算法的简介及其matlab代码，以帮助读者能快速复现相关算法，篇幅较长，读者可以根据自己需求选读。
传统图像增强算法python实现
import_torch_as_tf
05-26 7815
1. 像素级方法 1.1图像反转 图像反转（Image Negative）在许多应用中都很有用，例如显示医学图像和用单色正片拍摄屏幕，其想法是将产生的负片用作投影片。 转换方程：T:G(x,y)=L−F(x,y)​，其中L​是最大强度值，灰度图像L​​为255。 效果： 代码： import cv2 as cv fig = cv.imread('test1.jpg') #图像反转 L = 255 fig1 = L - fig cv.imshow('image',fig) cv.imshow
CLAHE_改进版直方图均衡化CLAHE_CLAHE_直方图均衡化_自适应均衡化_
10-02
而CLAHE（Contrast Limited Adaptive Histogram Equalization，对比度受限的自适应直方图均衡化）是直方图均衡化的改进版本，它针对图像局部区域进行操作，从而提高了图像的局部对比度，同时控制了过高的对比度增强...
CLAHE_matlab代码
03-02
对比度受限的自适应直方图均衡化matlab代码
CLAHE_matlab，clahe_CLAHE_clahematlab实现_
10-01
CLAHE（Contrast Limited Adaptive Histogram Equalization，有限对比度自适应直方图均衡化）是一种在图像处理领域中用于增强局部对比度的算法。在MATLAB中，它被广泛应用于医学影像、遥感图像和各种视觉应用，以...
albumentations数据增强学习
qq_48345413的博客
05-10 1219
albumentations数据增强学习 ` ` 文章目录albumentations数据增强学习原图：CLAHE（限制对比度自适应直方图均衡化）数据增强RandomRotate90（随机旋转90度）Transpose（转置）RGBShift（随机平移RGB通道值）HueSaturationValue（色调饱和度值）Flip（垂直或水平和垂直翻转）HorizontalFlip（围绕Y轴水平翻转）VerticalFlip（围绕X轴垂直翻转）RandomBrightnessContrast（随机亮度对比度）a
限制对比度的自适应直方图均衡化（CLAHE）在opencv中的使用
凌桑的自我修养--You are the Eternity
05-24 1万+
1.CLAHE简介        HE直方图增强，大家都不陌生，是一种比较古老的对比度增强算法，它有两种变体：AHE和CLAHE；两者都是自适应的增强算法，功能差不多，但是前者有一个很大的缺陷，就是有时候会过度方法图像中相同区域的噪声问，为了解决这一问题，出现了HE的另一种改进算法，就是CLAHE；CLAHE是另外一种直方图均衡算法，能有效的增强或改善图像（局部）对比度，从而获取更多图像相关细节
图像增强：对比度受限直方图均衡化CLAHE
Ring__Rain的博客
07-12 2378
绪： 直方图均衡简单、高效； 但是，图像中不同的区域灰度分布相差甚远，对它们使用同一种变换常常产生不理想的效果； 实际应用中，常常需要增强图像的某些局部区域的细节。 为了解决这类问题，Pizer等提出了局部直方图均衡化的方法(AHE)； AHE方法仅仅考虑了局部区域的像素，忽略了图像其他区域的像素，且对于图像中相似区域具有过度放大噪声的缺点； K. Zuiderveld等人提出了对比度...
自适应直方图均衡（AHE）和限制对比度的自适应直方图均衡（CLAHE）
凌桑的自我修养--You are the Eternity
05-24 2万+
本文翻译自https://en.wikipedia.org/wiki/Adaptive_histogram_equalization，如有错误还望海涵。。 自适应的直方图均衡（Adaptive Histogram Equalization） 1.算法简介         AHE是一种用来改善图像对比度的图像处理技术，它与传统的（普通）直方图均衡相比，不同点主要在于，AHE通过计算图像每一个显
关于 CLAHE 的理解及实现
yfor1008
09-21 6574
CLAHE CLAHE 是一种非常有效的直方图均衡算法, 目前网上已经有很多文章进行了说明, 这里说一下自己的理解. CLAHE是怎么来的 直方图均衡是一种简单快速的图像增强方法, 其原理和实现过程以及改进可以查看这里: 一文搞懂直方图均衡_yfor1008-CSDN博客 目前存在一些问题: 直方图均衡是全局的, 对图像局部区域存在过亮或者过暗时, 效果不是很好; 直方图均衡会增强背景噪声, 如下图所示为 CLAHE 中的示例: 为了解决上述2个问题, 就有2方面的解决方法: 一是解决全局性问题, 二
对比度受限的自适应直方图均衡化(CLAHE)
热门推荐
xiaoluo91的专栏
11-02 3万+
直方图均衡化（HE）是一种很常用的直方图类方法，基本思想是通过图像的灰度分布直方图确定一条映射曲线，用来对图像进行灰度变换，以达到提高图像对比度的目的。该映射曲线其实就是图像的累计分布直方图（CDF）（严格来说是呈正比例关系）。然而HE是对图像全局进行调整的方法，不能有效低提高局部对比度，而且某些场合效果会非常差。如：
CLAHE opencv
08-14
CLAHE（Contrast Limited Adaptive Histogram Equalization）是一种自适应直方图均衡化的方法，用于增强图像的对比度。它是通过将图像分成小块，在每个块内执行直方图均衡化来实现的。这种方法可以有效地处理具有...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值