图像处理 局部标准差_python实现局部标准差实现图像局部对比度增强算法 - CSDN
  • 局部标准差图像处理邻域具有广泛的应用,但是直接计算非常耗时,本文利用积分图像技术对局部标准差进行快速计算。 标准差定义如下(采用统计学中的定义,分母为): 其中。 为了计算图像的局部标准差,首先设定...

    局部标准差在图像处理邻域具有广泛的应用,但是直接计算非常耗时,本文利用积分图像对局部标准差的计算进行加速。

    局部标准差:

    标准差定义如下(采用统计学中的定义,分母为):


    其中

    为了计算图像的局部标准差,首先设定局部区域的大小为 ,则局部区域的像素点个数

    对标准差的公式进行化简:


    ,故:


    可以看出,局部标准差计算中需要对图像进行局部求和操作,即

    我们可以先分别计算出图像的积分图像,这样就能在常量时间计算出上述的局部和。

    时间复杂度:

    图像中共个像素点,每个局部区域共有个像素点,直接计算局部标准差的时间复杂度 ,利用积分图像计算局部标准差的时间复杂度为。(计算积分图像的时间为 、计算一个像素点的局部标准差需要常量时间,共个像素点,故最后的计算复杂度仍为 


    Matlab程序:

    Localstd.m:直接计算图像的局部标准差

    function Std=Localstd(Img,d)
    [m,n]=size(Img);
    Var=zeros(m,n);
    Img = padarray(Img,[d d],'symmetric');%边界填充
    N=(2*d+1)^2;
    for i=1:m
        for j=1:n
            i1=i+d;
            j1=j+d;
            B=Img(i1-d:i1+d,j1-d:j1+d);%取局部区域
            Var(i,j)=sum(sum((B-mean(B(:))).^2))/(N-1);%标准差公式
        end
    end
    Std=sqrt(Var);

    fastLocalstd.m:利用积分图像进行快速计算

    function Std=fastLocalstd(Img,d)
    [m,n]=size(Img);
    Img = padarray(Img,[d+1 d+1],'symmetric');%边界填充
    Img2=Img.^2;
    Int=integral(Img);%计算Img的积分图像
    Int2=integral(Img2);%计算Img^2的积分图像
    Var=zeros(m,n);
    N=(2*d+1)^2;%局部像素点个数
    for i=1:m
        for j=1:n
            i1=i+d+1;
            j1=j+d+1;
            %利用积分图像求局部和
            sumi2=Int2(i1+d,j1+d)+Int2(i1-d-1,j1-d-1)-Int2(i1+d,j1-d-1)-Int2(i1-d-1,j1+d);
            sumi=Int(i1+d,j1+d)+Int(i1-d-1,j1-d-1)-Int(i1+d,j1-d-1)-Int(i1-d-1,j1+d);
            Var(i,j)=(sumi2-sumi^2/N)/(N-1);
        end
    end
    Std=sqrt(Var);


    function I=Integral(Img) 
    Img=double(Img);
    [m,n]=size(Img);
    I=zeros(m,n);
    for i=1:m
        for j=1:n
            if i==1 && j==1             %积分图像左上角
                I(i,j)=Img(i,j);
            elseif i==1 && j~=1         %积分图像第一行
                I(i,j)=I(i,j-1)+Img(i,j);
            elseif i~=1 && j==1         %积分图像第一列
                I(i,j)=I(i-1,j)+Img(i,j);
            else                        %积分图像其它像素
                I(i,j)=Img(i,j)+I(i-1,j)+I(i,j-1)-I(i-1,j-1);  
            end
        end
    end

    main.m:

    clear all;
    close all;
    clc;
    Img=double(imread('lena.tif'));
    d=1;
    tic
    J1=Localstd(Img,d);
    toc
    tic
    J2=fastLocalstd(Img,d);
    toc
    figure;
    imshow([Img/max(Img(:)),J1/max(J1(:)),J2/max(J2(:))]);





    lena.tif大小为256*256,Localstd运行时间为 0.984451s,而fastLocalstd运行时为0.025528s。

    当然,对于局部标准差,Matlab本身提供了函数stdfilt,下面是它的核心代码:

    function Std=Stdfilt(I,d)
    I=double(I);
    h=ones(2*d+1);
    n=(2*d+1)^2;
    conv1 = imfilter(I.^2,h,'symmetric') / (n-1); 
    conv2 = imfilter(I,h,'symmetric').^2 / (n*(n-1));
    Std = sqrt(conv1-conv2);

    可以看出,它按照化简后的公式直接对图像进行卷积操作,因为imfilter函数是使用c实现的,且内部应该进行了优化,故速度较快。对上面的lena.tif运行时间为:0.064522s。


    展开全文
  • 局部标准差图像处理邻域具有广泛的应用,但是直接计算非常耗时,本文利用积分图像对局部标准差的计算进行加速。 局部标准差: 标准差定义如下(采用统计学中的定义,分母为): 其中。 为了计算图像的...

    局部标准差在图像处理邻域具有广泛的应用,但是直接计算非常耗时,本文利用积分图像对局部标准差的计算进行加速。

    局部标准差:

    标准差定义如下(采用统计学中的定义,分母为):


    其中

    为了计算图像的局部标准差,首先设定局部区域的大小为 ,则局部区域的像素点个数

    对标准差的公式进行化简:


    ,故:


    可以看出,局部标准差计算中需要对图像进行局部求和操作,即

    我们可以先分别计算出图像的积分图像,这样就能在常量时间计算出上述的局部和。

    时间复杂度:

    图像中共个像素点,每个局部区域共有个像素点,直接计算局部标准差的时间复杂度 ,利用积分图像计算局部标准差的时间复杂度为。(计算积分图像的时间为 、计算一个像素点的局部标准差需要常量时间,共个像素点,故最后的计算复杂度仍为 


    Matlab程序:

    Localstd.m:直接计算图像的局部标准差

    function Std=Localstd(Img,d)
    [m,n]=size(Img);
    Var=zeros(m,n);
    Img = padarray(Img,[d d],'symmetric');%边界填充
    N=(2*d+1)^2;
    for i=1:m
        for j=1:n
            i1=i+d;
            j1=j+d;
            B=Img(i1-d:i1+d,j1-d:j1+d);%取局部区域
            Var(i,j)=sum(sum((B-mean(B(:))).^2))/(N-1);%标准差公式
        end
    end
    Std=sqrt(Var);

    fastLocalstd.m:利用积分图像进行快速计算

    function Std=fastLocalstd(Img,d)
    [m,n]=size(Img);
    Img = padarray(Img,[d+1 d+1],'symmetric');%边界填充
    Img2=Img.^2;
    Int=integral(Img);%计算Img的积分图像
    Int2=integral(Img2);%计算Img^2的积分图像
    Var=zeros(m,n);
    N=(2*d+1)^2;%局部像素点个数
    for i=1:m
        for j=1:n
            i1=i+d+1;
            j1=j+d+1;
            %利用积分图像求局部和
            sumi2=Int2(i1+d,j1+d)+Int2(i1-d-1,j1-d-1)-Int2(i1+d,j1-d-1)-Int2(i1-d-1,j1+d);
            sumi=Int(i1+d,j1+d)+Int(i1-d-1,j1-d-1)-Int(i1+d,j1-d-1)-Int(i1-d-1,j1+d);
            Var(i,j)=(sumi2-sumi^2/N)/(N-1);
        end
    end
    Std=sqrt(Var);


    function I=Integral(Img) 
    Img=double(Img);
    [m,n]=size(Img);
    I=zeros(m,n);
    for i=1:m
        for j=1:n
            if i==1 && j==1             %积分图像左上角
                I(i,j)=Img(i,j);
            elseif i==1 && j~=1         %积分图像第一行
                I(i,j)=I(i,j-1)+Img(i,j);
            elseif i~=1 && j==1         %积分图像第一列
                I(i,j)=I(i-1,j)+Img(i,j);
            else                        %积分图像其它像素
                I(i,j)=Img(i,j)+I(i-1,j)+I(i,j-1)-I(i-1,j-1);  
            end
        end
    end

    main.m:

    clear all;
    close all;
    clc;
    Img=double(imread('lena.tif'));
    d=1;
    tic
    J1=Localstd(Img,d);
    toc
    tic
    J2=fastLocalstd(Img,d);
    toc
    figure;
    imshow([Img/max(Img(:)),J1/max(J1(:)),J2/max(J2(:))]);





    lena.tif大小为256*256,Localstd运行时间为 0.984451s,而fastLocalstd运行时为0.025528s。

    当然,对于局部标准差,Matlab本身提供了函数stdfilt,下面是它的核心代码:

    function Std=Stdfilt(I,d)
    I=double(I);
    h=ones(2*d+1);
    n=(2*d+1)^2;
    conv1 = imfilter(I.^2,h,'symmetric') / (n-1); 
    conv2 = imfilter(I,h,'symmetric').^2 / (n*(n-1));
    Std = sqrt(conv1-conv2);

    可以看出,它按照化简后的公式直接对图像进行卷积操作,因为imfilter函数是使用c实现的,且内部应该进行了优化,故速度较快。对上面的lena.tif运行时间为:0.064522s。


    版权声明:本文为博主原创文章,未经博主允许不得转载。

    转载于:https://www.cnblogs.com/luo-peng/p/4646216.html

    展开全文
  • 以前用代码实现过的一个算法,算法介绍在这里已经写的非常详细了,我也是根据这里的介绍写的算法代码,可能稍有改动。算法原理大家可以看原文,在这里给出代码供大家参考参考。

      以前用代码实现过的一个算法,算法介绍在这里已经写的非常详细了,我也是根据这里的介绍写的算法代码,可能稍有改动。算法原理大家可以看原文,在这里给出代码供大家参考参考。

    利用积分图像计算局部均值与局部标准差

      这个算法需要计算局部均值与局部标准差,我们知道,直接计算局部均值与标准差的效率是非常低的,设图像大小为 W*H, 窗口大小为 n, 那么直接计算的算法复杂度为 O(WHn2),如果我们采用积分图像来计算,算法复杂度为 O(WH),复杂度与窗口大小无关,仅与图像大小有关。

    计算图像的积分图像 (单通道 or 三通道):

    Mat Intergral_2(const Mat& image)
    {
        Mat result;
        Mat image_2;
        if (image.channels() == 1)
        {
            image.convertTo(image_2, CV_64FC1);
            result.create(image.size(), CV_64FC1);
    
        }
        else if (image.channels() == 3)
        {
            image.convertTo(image_2, CV_64FC3);
            result.create(image.size(), CV_64FC3);
        }
        //cout << image_2 << endl;
        int c = image_2.channels();
        int nr = image_2.rows;
        int nc = image_2.cols*c;
        for (int i = 0; i < nr; i++)
        {
            const double* inData = image_2.ptr<double>(i);
            double* outData = result.ptr<double>(i);
            if (i != 0)
            {
                const double* outData_up = result.ptr<double>(i - 1);
                for (int j = 0; j < nc; j++)
                {
                    if (j >= c)
                    {
                        outData[j] = inData[j] + outData_up[j] + outData[j - c] - outData_up[j - c];
                    }
                    else
                    {
                        outData[j] = inData[j] + outData_up[j];
                    }
                }
            }
            else
            {
                for (int j = 0; j < nc; j++)
                {
    
                    if (j >= c)
                    {
                        outData[j] = inData[j] + outData[j - c];
                    }
                    else
                    {
                        outData[j] = inData[j];
                    }
                }
            }
        }
        return result;
    }

    利用积分图象计算图像的局部均值与局部标准差 (单通道 or 三通道,d 为窗口大小的半径):

    int Local_MeanStd(const Mat &_image, Mat &_mean, Mat &_std, int d)
    {
        if (_image.channels() == 1)
        {
            _mean.create(_image.size(), CV_64FC1);
            _std.create(_image.size(), CV_64FC1);
    
        }
        else if (_image.channels() == 3)
        {
            _mean.create(_image.size(), CV_64FC3);
            _std.create(_image.size(), CV_64FC3);
        }
        //边界填充
        Mat image_big;
        copyMakeBorder(_image, image_big, d + 1, d + 1, d + 1, d + 1, BORDER_REFLECT_101);
        image_big.convertTo(image_big, _mean.type());
        Mat image_big_2 = image_big.mul(image_big);
        Mat Intergral_image1 = Intergral_2(image_big);
        Mat Intergral_image2 = Intergral_2(image_big_2);
    
        int N = (2 * d + 1)*(2 * d + 1);
        int c = _image.channels();
        int nr = _image.rows;
        int nc = _image.cols*c;
    
        //cout << Intergral_image1 << endl;
        //cout << Intergral_image2 << endl;
    
        for (int i = 0; i < nr; i++)
        {
            double* outData1 = _mean.ptr<double>(i);
            double* outData2 = _std.ptr<double>(i);
            double* inDataUp1 = Intergral_image1.ptr<double>(i);
            double* inDataUp2 = Intergral_image2.ptr<double>(i);
            double* inDataDown1 = Intergral_image1.ptr<double>(i + 2 * d + 1);
            double* inDataDown2 = Intergral_image2.ptr<double>(i + 2 * d + 1);
            for (int j = 0; j < nc; j++)
            {
    
                double sumi1 = inDataDown1[j + (2 * d + 1)*c] + inDataUp1[j] - inDataUp1[j + (2 * d + 1)*c] - inDataDown1[j];
                double sumi2 = inDataDown2[j + (2 * d + 1)*c] + inDataUp2[j] - inDataUp2[j + (2 * d + 1)*c] - inDataDown2[j];
                outData1[j] = sumi1 / N;
                outData2[j] = (sumi2 - sumi1*outData1[j]) / N;
            }
        }
        cv::sqrt(_std, _std);
        return 0;
    }

    对比度增强算法

    最后是增强算法的实现:

    int ACE(const Mat &_image, Mat &_result, int _d, int _Scale, int _MaxCG)
    {
        Mat localmean, localstd;
        Local_MeanStd(_image, localmean, localstd, _d);
        if (_image.channels() == 1)
        {
            _result.create(_image.size(), CV_64FC1);
        }
        else if (_image.channels() == 3)
        {
            _result.create(_image.size(), CV_64FC3);    
        }
        Mat mean_m, std_m;
        meanStdDev(_image, mean_m, std_m); 
        double std[3];
        std[0] = std_m.at<double>(0, 0);
        std[1] = std_m.at<double>(1, 0);
        std[2] = std_m.at<double>(2, 0);
    
        int c = _image.channels();
        int nr = _image.rows;
        int nc = _image.cols*c;
        double CG;
        for (int i = 0; i < nr; i++)
        {
            double* meanData = localmean.ptr<double>(i);
            double* stdData = localstd.ptr<double>(i);
            const uchar* imageData = _image.ptr<uchar>(i);
            double* outData = _result.ptr<double>(i);
            for (int j = 0; j < nc; j++)
            {
                CG = std[j % 3] / stdData[j];
                if (CG > _MaxCG)
                    CG = _MaxCG;
                outData[j] = meanData[j] + _Scale*CG*(int(imageData[j]) - meanData[j]);
            }
        }
        _result.convertTo(_result, CV_8UC3);
        return 0;
    }

    算法效果

    最后放几张处理前后的图片:

    这里写图片描述

    这里写图片描述

    这里写图片描述

    这里写图片描述

    这里写图片描述

    这里写图片描述

    展开全文
  • 图像的对比度增强算法在很多场合都有着重要的应用,特别是在医学图像上,这是因为在众多疾病的诊断中,医学图像的视觉检查时很有必要的。而医学图像由于本身及成像条件的限制,图像的对比度很低。因此,在这个方面...

    转自:http://blog.csdn.net/laviewpbt/article/details/11743115



    图像的对比度增强算法在很多场合都有着重要的应用,特别是在医学图像上,这是因为在众多疾病的诊断中,医学图像的视觉检查时很有必要的。而医学图像由于本身及成像条件的限制,图像的对比度很低。因此,在这个方面已经开展了很多的研究。这种增强算法一般都遵循一定的视觉原则。众所周知,人眼对高频信号(边缘处等)比较敏感。虽然细节信息往往是高频信号,但是他们时常嵌入在大量的低频背景信号中,从而使得其视觉可见性降低。因此适当的提高高频部分能够提高视觉效果并有利于诊断。

         在这一方面,传统的线性对比度拉升以及直方图均衡化是使用的最为广泛的全局图像增强方法。对比度拉升线性的调整了图像的动态范围,而直方图均衡化栖利用累计直方图分布概率重新映射图像的数据。这些方法虽然简单,但是都没有考虑到局部的信息。并且,全局直方图均衡化(GHE)还会产生使得一些噪音过度加强。

         在局部对比度增强方面,有两种方式是最为有名的,一种是自适应直方图均衡化(AHE),这个算法可以参考我的博文限制对比度自适应直方图均衡化算法原理、实现及效果。还有一种就是自适应对比度增强(ACE)。AHE算法使用局部的直方图的相关信息对数据进行映射。这改变了图像的对比度,但是需要大量的计算。后来有人利用了双线性差值技术克服了这个问题,首先将图像分块,然后分别计算这些快内部的映射关系。为了增强某一个像素点的值,映射关系通过与这个像素所在块相邻的四个块的映射关系差值获得。在这个算法中,仅仅需要一个块大小的参数(在我的博文中还对参数进行了扩展)。

          ACE算法采用了反锐化掩模技术,我们对此过程解释如下:首先图像被分成两个部分。一是低频的反锐化掩模(unsharp mask)部分,可以通过图像的低通滤波(平滑,模糊技术)获得。二是高频成分,可以过原图减去反锐化掩模获取。然后高频部分被放大(放大系数即为对比度增益CG)并加入到反锐化掩模中去,最后得到增强的图像。ACE算法的核心就是如何计算CG,这里将介绍两种简单的CG计算方法。

        在继续说明之前,先贴一幅这个算法处理的图给大家看看效果,免得都是通篇的文字。

       

                      原图                                     处理后的图

          在谈及CG之前,我们还是需要看看一些基础的工作。首先上面谈到了unsharp mask,他对应于图像的低频成分。对于具体的像素,一般可以通过计算以该像素为中心的局部区域的像素平均值来实现。我们假定x(i,j)是图像中某点的灰度值,局部区域的定义为:以(i,j)为中心,窗口大小为(2n+1)*(2n+1)的区域,其中n为一个整数。当然这个窗口区域也不一定就要是正方形。局部的平均值,也就是低频部分,可以用下式计算:

                        

          而局部方差为:

            

          上式中σx(i,j)就是所谓的局部标准差(LSD)。定义f(i,j)表示x(i,j)对应的增强后的像素值。则ACE算法可以表示如下:

                     

         其中的函数G(i,j)就是上文所讲的CG。一般情况下CG总是大于1的,这样高频成分就能得到增强。

         关于CG的取值,一种最简单的方式就是令其为常量,假定为C,一般C>1,这样式3就变为:

                        

         这种情况下,图像中所有的高频部分都被同等放大,可能有些高频部分会出现过增强的现象的。

       

                        原图                                                                      n=50,c=2                                                              n=50,c=3

        在上图中,分别使用了C=2及C=3的的情况,在C=3时,可见星球边缘的部分被过增强,出现成片的白色。

        一种解决的方案就是使用不同的增益。Lee等人提出了如下的方案:

                

         上式中,D是个常数,这样,CG是空间自适应的,并且和局部均方差成反比,在图像的边缘或者其他变化剧烈的地方,局部均方差比较大,因此CG的值就比较小,这样就不会产生振铃效应。然而,在平滑的区域,局部均方差就会很小,这样CG的值比较大,从而引起了噪音的放大,所以需要对CG的最大值做一定的限制才能获得更好的效果。

         D这个常数的取值有些文章介绍说用图像的全局平均值,我编程的时候是用的图像的全局均方差,并且增加一个参数Amount,用来再次控制高频增强的程度。

         对式我们进行了编程,并测试一些图像,当进行一些参数的调整时,都能获得比较理想的增强效果,举例如下:

      

                                  原图                                                     n=20,Amount=100,MaxCG=3                                 n=20,Amount=100,MaxCG=10

      

                                  原图                                                   n=25,Amount=100,MaxCG=2                                n=50,Amount=150,MaxCG=2

      

                                 原图                                                   n=50,Amount=150,MaxCG=3                                n=50,Amount=150,MaxCG=10

         不仅是对医学图像,对于我日常生活中的一些不是很理想的图片,经过上述ACE算法在大部分情况下也可获得较好的效果:

     

     

      为什么要对CG的最大值进行限制,我们举下面这个图作为例子:

     

                                    原图                                                                                                  n=50,Amount=150,CG不限制

       在上图中,图像右上角部位属于平滑区域,但是仔细观察有着微弱的层次感,如果不对CG进行限制,则由于LSD的值很小,导致CG的值特别大,从而产生像素饱和的现象(即像素的值超过了255)。如右图所示,解决这个问题一种方法就是增加n的值,即增加取样半径,通过取样半径的增加,使得以平滑区域为中心的窗口能够覆盖一些非平滑的区域,从而产生较大的LSD值。另外一种就是采用CG限幅的方式,效果如下:

        

                                     n=200,Amount=150,CG不限制                                                                          n=50,Amount=150,CG<3

         针对不同的图像,要想获得理想的效果,可能还是需要人工的去参与和调整这些参数,我目前尚未发现能自动确定这些参数的文章。

         根据公式5,是不难写出实现代码的,但还要实用,主要的难点还是如何实现快速的计算,因为随着取样半径n的增加,每个像素点涉及到的区域范围就越广,计算量会直线上升,因此需要采用优化的策略。

         均值模糊的优化已经有了很多成熟的方案,普遍的就是先行均值,在列均值,当然还有更好的优化方式。

         而计算局部均方差,则需要一定的水平了,但是同样的原理还是利用每变换一次都有很多的重叠的部分的数据,这个等有空了我会专门写篇文章的。

         虽然采用了优化算法,但是实际上这个算法还是有点慢的,主要原因还是计算均方差确实有点耗时,并且优化的算法也是下一行像素的结果值依赖于前一行的计算结果,而对于第一行是需要进行特殊处理的,因此,这个使用GPU计算也是很难进一步进行优化的。

         但是优化后的算法执行时间和n基本是没有关系的。

         同样,提供个编译好的文件给有兴趣研究该算法的朋友看看效果:http://files.cnblogs.com/Imageshop/LocalAreaContrastEnhance.rar

         当然,这个算法不是对任何图像都能产生正能量,那些本来就很好的图,你用它只会适得其反。

     

          参考论文:Real-Time Adaptive Contrast Enhancement

    2013.10.19 日补充:

         今日对改算法又进行了一些测试,发现其对雾天图像,或者比较昏暗的图像都有很好的增强作用,再补充一些测试图像的例子:

           

           

        抽空用C++写了个标准的DLL,结合OpenMp工具对算法实现了多线程运行,执行速度上比C#的多线程版本要快那么一点点的。

         DLL的接口函数函数如下:



    [DllImport("LocalAreaContrastEnhance.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode, ExactSpelling = true)]
    private static extern void LocalAreaContrastEnhance(byte* Scan0, int Width, int Height, int Stride, int Radius, int Amount, int MaxCG);

        注意我只实现了24位的算法。
        再上传一个C#调用该DLL的代码示例:http://files.cnblogs.com/Imageshop/LocalAreaContrastEnhanceTest.rar


    展开全文
  • 图像的对比度增强算法在很多场合都有着重要的应用,特别是在医学图像上,这是因为在众多疾病的诊断中,医学图像的视觉检查时很有必要的。而医学图像由于本身及成像条件的限制,图像的对比度很低。因此,在这个方面...
  • (1)局部增强可借助将图像分成子图像再对每个子图像具体增强。 直方图变换是空域增强中最常采用的风阀,它也很容易用于图像局部增强。只需先将图像分成一系列(一般互相不重叠)小区域(子图像),此时直方图均衡...
  • 如何求图像均值和标准差
  • 1,图像标准差;2,图像对比度;3,图像清晰度 上述三个问题的Matlab程序
  • http://www.cnblogs.com/Imageshop/p/3324282.html
  • 本文根据下面这篇文章,做下简单修改。 原文: ... 研究图像特征检测已经有一段时间了,图像特征...总体来说,图像特征可以包括颜色特征、纹理特等、形状特征以及局部特征点等。其中局部特点具有很好的稳定性,不容易...
  • ...使用局部标准差实现图像的局部对比度增强算法。 Posted on 2013-09-16 15:01 Imageshop 阅读(426) 评论(1) 编辑 收藏  图像的对比度增强算法在很多场合都有着重要的应
  • LOG,HOG,DOG微分算子在近圆的斑点检测方面效果很好 HOG特征 https://blog.csdn.net/coming_is_winter/article/details/72850511...总结:Dalal提出的Hog特征提取的过程:把样本图像分割为若干个像素的单元(cell),...
  • 图像处理中经常会用到方差和局部方差的概念,这里就给出计算图像局部方法的代码,方便使用。 注:代码是关于导向滤波论文中的源码,大家可以自己下载 function dataVariance = getLocalVariance(srcData, ...
  • 基于局部均方差的图像局部对比度增强算法 1.基于局部均方差增强原理  我们知道图像的高频部分代表的是图像中类似边缘的高频分量;底频部分代表的是图像中较为平坦的部分。假若用原始图像减去图像中低频部分的,...
  • 如何用MATLAB计算图像标准差,清晰度和全局对比度,求程序
  • 图像处理与识别学习小结   数字图像处理是对图像进行分析、加工、和处理,使其满足视觉、心理以及其他要求的技术。图像处理是信号处理在图像域上的一个应用。目前大多数的图像是以数字形式存储,因而图像处理很多...
  • 图像处理与识别

    2017-03-23 09:45:57
    数字图像处理是对图像进行分析、加工、和处理,使其满足视觉、心理以及其他要求的技术。图像处理是信号处理在图像域上的一个应用。目前大多数的图像是以数字形式存储,因而图像处理很多情况下指数字图像处理。此外,...
  • 图像处理(image processing),用计算机对图像进行分析,以达到所需结果的技术。又称影像处理。图像处理一般指数字图像处理。数字图像是指用工业相机、摄像机、扫描仪等设备经过拍摄得到的一个大的二维数组,该数组的...
  • 基于局部均方差的图像去噪声算法 1.基于局部均方去噪原理  假设一幅M*N的灰度图像的灰度图像,x(i,j)为模板中心的灰度值,那么在(2*n+1)(2*m+1)的窗口内,其局部均值可以表示为:  其局部均方差可以表示...
1 2 3 4 5 ... 20
收藏数 17,426
精华内容 6,970
关键字:

图像处理 局部标准差