• 1.图像去噪的前言  上一篇博文中,我对噪声的类型进行了介绍,也使用的Matlab对各种噪声进行了实现。旧话重提,一幅图像,甚至是一个信号的老化,可以使用以下模型来表示。 可以使用以下算式来表示 这里,由于...

    1.图像去噪的前言


        上一篇博文中,我对噪声的类型进行了介绍,也使用的Matlab对各种噪声进行了实现。旧话重提,一幅图像,甚至是一个信号的老化,可以使用以下模型来表示。


    可以使用以下算式来表示


    这里,由于退化函数的作用,使得原图像产生退化(比如,运动模糊),然后在加上一个加性噪声项

          本博文,主要对去除加性噪声的线性滤波器的性能进行了比较。对于退化函数的去除(称为去卷积或者逆滤波),将放在稍后的博文。


          1.1 实验用图像 




          1.2 实验结果的评价

                实验的步骤为,将实验用图像加上加性噪声,然后使用滤波器进行去噪,比较所得到的图像的画质。这里,就涉及到画质的评价方法。一般的,去噪图像的评价一般使用PSNR(峰值信噪比)。


           对于8-bit的图片而言,这里的MAX为255。PSNR越大,其画质就越好。但是,有些时候,使用PSNR来进行评价,也有不太合理的时候。

           请对比如下三张图片,a)是使用平均滤波器进行了处理,使其有些模糊;b)是使用高斯噪声污染原图;c)是使用椒盐噪声污染的图像。


        问题来了,这三张图像哪张画质最好,哪张最差。普遍的,画质从好到差排列,大家的答案应该是

    a) > c) > b)

    这样的(更多实际例子,请参考https://ece.uwaterloo.ca/~z70wang/research/ssim/)。那么,我们求其的PSNR是这样的。


    这明显不科学,三幅图像的PSNR是一样的。反观PSNR的计算式,PSNR计算的时候,使用了MSE这个量。而MSE仅仅表现了两幅图像的灰度值的差,而对于图像的结构,却没有进行任何分析。

           这里使用一种比较好的图像画质评价的方法:SSIM(念做:艾斯-希姆)。这是一种由两张图像的灰度差异,构造差异和对比度去判断两张图的接近程度的方法。详情请参考[文献1],这里只做简单的介绍一下啦。


    SSIM从图像亮度(Luminance),图像对比度(Contrast)和图像构造(Structure)去判断处理过的图像与原图的差异。这里,使用了某个区域的内的平均值作为亮度度量,使用方差作为对比度度量,使用协方差作为构造度量,来进行判断。这样,SSIM就比仅使用灰度去判断的PSNR更加准确。一样的,使用SSIM求取上面三幅图象的类似度。


    从上表可以看出来,通过使用SSIM进行判断的结果,更加符合人眼的主观感受。本文余下的实验,全部使用SSIM去判断画质。


    2.几个均值滤波器---线性处理


        2.1 算术均值滤波器

        算术均值滤波器很简单,就是求某个区域内的所有像素的算术均值,可用下式子表示。
        
    从式子上可以看出来,这就是一个低通滤波器,会使得画面模糊,有些许去噪能力。稍微做个实验看看。

        将实验用图像加噪,噪声均值为0、方差为0.0298的噪声。


        下面,使用算术均值滤波器,看看去噪效果。


       被去掉了些许,只是些许。再看频率域内的图像,果然是一个低通滤波器,我们都可以脑补出这个滤波器的振幅特性了,对吧?


        2.2 几何均值滤波器

        接下来是几何均值滤波器,求某个区域内的几何平均值。
        
    对于这个滤波器,书(《Digital Image Processing》 Rafael C. Gonzalez / Richard E. Woods)上说了,这个滤波器产生的去噪效果可以与算术平均值滤波器基本一样,但是可以更少的丢失细节。
        同样的,将实验用图像加噪,噪声均值为0、方差为0.17的噪声。

           有结果可见,其去噪效果也不是太理想,但是原本芯片的pin脚什么的,比算术均值滤波器稍微好要一些的。当然,几何滤波器有一个致命的缺点,一旦有0值出现,那么这个像素的值立即被决定为0,这也就意味着,几何滤波器不可以去除胡椒噪声。

        2.3 算术均值滤波器与几何均值滤波器的比较

            为了对比几何均值滤波器与算术均值滤波器,我们进行了如下几组实验。由于篇幅问题,我就不贴出图来了。看数据就可以了。
            1.  噪声:高斯噪声,均值0,方差为0.17

             2.噪声:高斯噪声,均值0.2,方差为0.17

             3.噪声:椒盐噪声,胡椒密度0,盐粒密度0.1

    这个还是想把结果贴上,几何平均滤波器的实验结果还是具有一定的观赏性的。

             4.噪声:椒盐噪声,胡椒密度0.1,盐粒密度0

           就如同实验结果一样,由于包含了大量了胡椒噪声,几何滤波器坏掉了。得到的结果很糟糕。

           实验结论:实验4的数据说明,由于包含了0值,几何滤波器去噪效果并不太好。但是实验3,几何滤波器的去噪效果真的是很不错。简单而言,算术均值滤波器泛用性比较好,而几何滤波器则擅长于去除盐粒噪声。
    ================
           拓展运用:既然几何滤波器对于去除盐粒噪声,那么,对于仅仅函数胡椒噪声的图像取反,将胡椒噪声转换为盐粒噪声去处理,所得结果再返回来,那么,几何均值滤波器还是可以去除胡椒噪声的。
    ================

        2.4 谐波均值滤波器

        其表达式如下所示,

    注意式子的分母,这个滤波器不但不能去除椒盐噪声,对于灰度过黑的图像而言,也是要坏事的。书(《Digital Image Processing》 Rafael C. Gonzalez / Richard E. Woods)上又说了,这个滤波器,擅长于高斯噪声的去噪。实验一下看看。
        把实验用图加噪,类型为高斯噪声,均值为0,方差为0.15.

    从实验结果看,其实这个滤波器的去噪效果还不如算术平均滤波器和几何平均滤波器。

        2.5 逆谐波均值滤波器

        逆谐波滤波器可以对应多种噪声,式子如下。

    这个滤波器,可以通过Q值的变化,来获得一定的效果。当Q为正,这个滤波器可以去除胡椒噪声,当Q为负,这个滤波器可以去除盐粒噪声。贴个结果收活吧。
        

    3.总结

       本文介绍了几种图像去噪的线性滤波器,并对他们进行了比较。本次实验所用到的代码,我贴在下面。
       另外,评价函数ssim_index(),请自行网上查找。
    close all;
    clear all;
    clc;
    
    f = imread('./ckt-board-orig.tif');
    f = mat2gray(f,[0 255]);
    [M,N] = size(f);
    %% ---------------gaussian noise-------------------
    a = 0;
    b = 0.1;
    n_gaussian = a + b .* randn(M,N);
    
    g_gaussian = f + n_gaussian; 
    g_gaussian(find(g_gaussian > 1)) = 1;
    g_gaussian(find(g_gaussian < 0)) = 0;
    
    figure();
    subplot(1,2,1);
    imshow(g_gaussian,[0 1]);
    xlabel('a).Image corrupted by Gaussian noise');
    
    subplot(1,2,2);
    x = linspace(-0.2,1.2,358);
    h = hist(g_gaussian,x)/(M*N);
    Histogram = zeros(358,1);
    for y = 1:256
        Histogram = Histogram + h(:,y);
    end
    bar(-0.2:1/255:1.2,Histogram);
    axis([-0.2 1.2 0 0.014]),grid;
    xlabel('b).The Histogram of a');
    ylabel('Number of pixels');
    
    g_diff = abs(g_gaussian - f);
    
    MSE = sum(sum(g_diff .^2))/(M*N);
    PSNR = 10*log10((1*1)/MSE)
    
    [SSIM_G mssim] = ssim_index(f,g_gaussian,[0.01 0.03],ones(8),1);
    
    %% ---------------Denoise(Gaussian noise)-------------------
    g_Ex = zeros(M+2,N+2);
    for x = 1:M
        g_Ex(x+1,:) = [g_gaussian(x,1) g_gaussian(x,:) g_gaussian(x,N)];
    end
    g_Ex(1,:) = g_Ex(2,:);
    g_Ex(M+2,:) = g_Ex(M+1,:);
    
    % Arithemtic mean filter
    g_amf = zeros(M,N);
    for x = 2:M+1
        for y = 2:N+1
            g_amf(x-1,y-1) = g_amf(x-1,y-1) +  g_Ex(x  ,y);
            g_amf(x-1,y-1) = g_amf(x-1,y-1) +  g_Ex(x-1,y);
            g_amf(x-1,y-1) = g_amf(x-1,y-1) +  g_Ex(x  ,y-1);
            g_amf(x-1,y-1) = g_amf(x-1,y-1) +  g_Ex(x+1,y);
            g_amf(x-1,y-1) = g_amf(x-1,y-1) +  g_Ex(  x,y+1);
            g_amf(x-1,y-1) = g_amf(x-1,y-1) +  g_Ex(x-1,y+1);
            g_amf(x-1,y-1) = g_amf(x-1,y-1) +  g_Ex(x+1,y-1);
            g_amf(x-1,y-1) = g_amf(x-1,y-1) +  g_Ex(x+1,y+1);
            g_amf(x-1,y-1) = g_amf(x-1,y-1) +  g_Ex(x-1,y-1);
            
            g_amf(x-1,y-1) = g_amf(x-1,y-1)/9;
        end
    end
    
    g_amf_diff = abs(g_amf - f);
    
    MSE_amf = sum(sum(g_amf_diff .^2))/(M*N);
    PSNR_amf = 10*log10((1*1)/MSE_amf)
    
    [SSIM_amf mssim] = ssim_index(f,g_amf ,[0.01 0.03],ones(8),1);
    
    % Geometric mean filter
    
    g_gmf = zeros(M,N);
    for x = 2:M+1
        for y = 2:N+1
            g_gmf(x-1,y-1) = g_Ex(x  ,y);
            g_gmf(x-1,y-1) = g_gmf(x-1,y-1) *  g_Ex(x-1,y);
            g_gmf(x-1,y-1) = g_gmf(x-1,y-1) *  g_Ex(x  ,y-1);
            g_gmf(x-1,y-1) = g_gmf(x-1,y-1) *  g_Ex(x+1,y);
            g_gmf(x-1,y-1) = g_gmf(x-1,y-1) *  g_Ex(  x,y+1);
            g_gmf(x-1,y-1) = g_gmf(x-1,y-1) *  g_Ex(x-1,y+1);
            g_gmf(x-1,y-1) = g_gmf(x-1,y-1) *  g_Ex(x+1,y-1);
            g_gmf(x-1,y-1) = g_gmf(x-1,y-1) *  g_Ex(x+1,y+1);
            g_gmf(x-1,y-1) = g_gmf(x-1,y-1) *  g_Ex(x-1,y-1);
        end
    end
    
    g_gmf = (g_gmf).^(1/9);
    
    g_gmf_diff = abs(g_gmf - f);
    MSE_gmf = sum(sum(g_gmf_diff .^2))/(M*N);
    PSNR_gmf = 10*log10((1*1)/MSE_gmf)
    
    [SSIM_gmf mssim] = ssim_index(f,g_gmf ,[0.01 0.03],ones(8),1);
    
    figure();
    subplot(1,2,1);
    imshow(g_amf,[0 1]);
    xlabel('a).Ruselt of Denoise by Amf');
    
    figure();
    subplot(1,2,2);
    imshow(g_gmf,[0 1]);
    xlabel('a).Ruselt of Denoise by Gmf');
    
    % Harmonic mean filter
    g_hmf = zeros(M,N);
    for x = 2:M+1
        for y = 2:N+1
            g_hmf(x-1,y-1) = 1/g_Ex(x  ,y);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x-1,y);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x  ,y-1);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x+1,y);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(  x,y+1);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x-1,y+1);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x+1,y-1);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x+1,y+1);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x-1,y-1);
            
            g_hmf(x-1,y-1) = 9/g_hmf(x-1,y-1);
    
        end
    end
    
    g_hmf_diff = abs(g_hmf - f);
    MSE_hmf = sum(sum(g_hmf_diff .^2))/(M*N);
    PSNR_hmf = 10*log10((1*1)/MSE_hmf)
    
    [SSIM_hmf mssim] = ssim_index(f,g_hmf ,[0.01 0.03],ones(8),1);
    
    figure();
    subplot(1,2,1);
    imshow(g_hmf,[0 1]);
    xlabel('c).Ruselt of Denoise by Hmf');
    
    %% ---------------Denoise(salt and pepper noise)----------
    close all;
    clear all;
    clc;
    
    f = imread('./ckt-board-orig.tif');
    f = mat2gray(f,[0 255]);
    [M,N] = size(f);
    %% ---------------Salt & pepper-------------------
    b = 0;  %salt
    a = 0.2;    %pepper
    x = rand(M,N);
    
    g_sp = zeros(M,N);
    g_sp = f;
    
    g_sp(find(x<=a)) = 0;
    g_sp(find(x > a & x<(a+b))) = 1;
    
    g_diff = abs(g_sp - f);
    MSE = sum(sum(g_diff .^2))/(M*N);
    PSNR = 10*log10((1*1)/MSE)
    
    figure();
    subplot(1,2,1);
    imshow(g_sp,[0 1]);
    xlabel('a).Image corrupted by salt&pepper noise');
    
    %% ---------------Denoise(Salt & pepper)-------------------
    g_Ex = zeros(M+2,N+2);
    for x = 1:M
        g_Ex(x+1,:) = [g_sp(x,1) g_sp(x,:) g_sp(x,N)];
    end
    g_Ex(1,:) = g_Ex(2,:);
    g_Ex(M+2,:) = g_Ex(M+1,:);
    
    % Harmonic mean filter
    g_hmf = zeros(M,N);
    for x = 2:M+1
        for y = 2:N+1
            g_hmf(x-1,y-1) = 1/g_Ex(x  ,y);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x-1,y);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x  ,y-1);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x+1,y);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(  x,y+1);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x-1,y+1);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x+1,y-1);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x+1,y+1);
            g_hmf(x-1,y-1) = g_hmf(x-1,y-1) +  1/g_Ex(x-1,y-1);
            
            g_hmf(x-1,y-1) = 9/g_hmf(x-1,y-1);
        end
    end
    
    g_hmf_diff = abs(g_hmf - f);
    MSE_hmf = sum(sum(g_hmf_diff .^2))/(M*N);
    PSNR_hmf = 10*log10((1*1)/MSE_hmf)
    
    figure();
    subplot(1,2,1);
    imshow(g_sp,[0 1]);
    xlabel('a).Image corrupted by pepper noise');
    
    subplot(1,2,2);
    imshow(g_hmf,[0 1]);
    xlabel('b).Ruselt of Denoise by Hmf');
    
    % Contraharmonic mean filter
    Q = -1.5;
    
    g_cmf = zeros(M,N);
    for x = 2:M+1
        for y = 2:N+1
            g_cmf_M = (g_Ex(x  ,y))^(1+Q);
            g_cmf_M = g_cmf_M +  (g_Ex(x-1,y))^(1+Q);
            g_cmf_M = g_cmf_M +  (g_Ex(x  ,y-1))^(1+Q);
            g_cmf_M = g_cmf_M +  (g_Ex(x+1,y))^(1+Q);
            g_cmf_M = g_cmf_M +  (g_Ex(  x,y+1))^(1+Q);
            g_cmf_M = g_cmf_M +  (g_Ex(x-1,y+1))^(1+Q);
            g_cmf_M = g_cmf_M +  (g_Ex(x+1,y-1))^(1+Q);
            g_cmf_M = g_cmf_M +  (g_Ex(x+1,y+1))^(1+Q);
            g_cmf_M = g_cmf_M +  (g_Ex(x-1,y-1))^(1+Q);
            
            g_cmf_D = (g_Ex(x  ,y))^(Q);
            g_cmf_D = g_cmf_D +  (g_Ex(x-1,y))^(Q);
            g_cmf_D = g_cmf_D +  (g_Ex(x  ,y-1))^(Q);
            g_cmf_D = g_cmf_D +  (g_Ex(x+1,y))^(Q);
            g_cmf_D = g_cmf_D +  (g_Ex(  x,y+1))^(Q);
            g_cmf_D = g_cmf_D +  (g_Ex(x-1,y+1))^(Q);
            g_cmf_D = g_cmf_D +  (g_Ex(x+1,y-1))^(Q);
            g_cmf_D = g_cmf_D +  (g_Ex(x+1,y+1))^(Q);
            g_cmf_D = g_cmf_D +  (g_Ex(x-1,y-1))^(Q);
            
            g_cmf(x-1,y-1) = g_cmf_M/g_cmf_D;
        end
    end
    
    g_cmf_diff = abs(g_cmf - f);
    MSE_cmf = sum(sum(g_cmf_diff .^2))/(M*N);
    PSNR_cmf = 10*log10((1*1)/MSE_cmf)
    
    figure();
    subplot(1,2,1);
    imshow(g_cmf,[0 1]);
    xlabel('b).Ruselt of Denoise by Cmf(Q=-1.5)');
    


    参考文献

    [1] Z. Wang, A. C. Bovik, H. R. Sheikh and E. P. Simoncelli, "Image quality assessment: From error visibility to structural similarity," IEEE Transactions on Image Processing, vol. 13, no. 4, pp. 600-612, Apr. 2004.


    原文发于博客:http://blog.csdn.net/thnh169/ 

    =============更新日志===================

    2014.7.17     修正了一些语法错误。

    展开全文
  • 转自:openCV之中值滤波&amp;均值滤波(及代码实现):...均值滤波(及代码实现)首先我们看一下图像滤波的概念。图像滤波,即在尽量保留图像细节特征的条件下对目标图像的噪声进行抑...

    转自:openCV之中值滤波&均值滤波(及代码实现):https://blog.csdn.net/weixin_37720172/article/details/72627543

     在开始我们今天的博客之前,我们需要先了解一下什么是滤波:

    openCV之中值滤波&均值滤波(及代码实现)首先我们看一下图像滤波的概念。图像滤波,即在尽量保留图像细节特征的条件下对目标图像的噪声进行抑制,是图像预处理中不可缺少的操作,其处理效果的好坏将直接影响到后续图像处理和分析的有效性和可靠性。

    下图左边是原图右边是噪声图:

    消除图像中的噪声成分叫作图像的平滑化或滤波操作。信号或图像的能量大部分集中在幅度谱的低频和中频段是很常见的,而在较高频段,感兴趣的信息经常被噪声淹没。因此一个能降低高频成分幅度的滤波器就能够减弱噪声的影响。
    图像滤波的目的有两个:一是抽出对象的特征作为图像识别的特征模式;另一个是为适应图像处理的要求,消除图像数字化时所混入的噪声。
    而对滤波处理的要求也有两条:一是不能损坏图像的轮廓及边缘等重要信息;二是使图像清晰视觉效果好。

    平滑滤波是低频增强的空间域滤波技术。它的目的有两类:一类是模糊;另一类是消除噪音。
    空间域的平滑滤波一般采用简单平均法进行,就是求邻近像元点的平均亮度值。邻域的大小与平滑的效果直接相关,邻域越大平滑的效果越好,但邻域过大,平滑会使边缘信息损失的越大,从而使输出的图像变得模糊,因此需合理选择邻域的大小。
    关于滤波器,一种形象的比喻法是:我们可以把滤波器想象成一个包含加权系数的窗口,当使用这个滤波器平滑处理图像时,就把这个窗口放到图像之上,透过这个窗口来看我们得到的图像。

     

    举一个滤波在我们生活中的应用:美颜的磨皮功能。如果将我们脸上坑坑洼洼比作是噪声的话,那么滤波算法就是来取出这些噪声,使我们自拍的皮肤看起来很光滑。

    这篇博文会介绍中值滤波以及均值滤波两种算法

     

    一.均值滤波

              图片中一个方块区域(一般为3*3)内,中心点的像素为全部点像素值的平均值。均值滤波就是对于整张图片进行以上操作。

    我们可以看下图的矩阵进行理解

                                                                          

                             

    缺陷:均值滤波本身存在着固有的缺陷,即它不能很好地保护图像细节,在图像去噪的同时也破坏了图像的细节部分,从而使图像变得模糊,不能很好地去除噪声点。特别是椒盐噪声

    实现代码:

    #include "opencv2/imgproc.hpp"
    #include "opencv2/highgui.hpp"
    #include<ctime>
    using namespace cv;
    using namespace std;
     
    //均值滤波
    void AverFiltering(const Mat &src,Mat &dst) {
    	if (!src.data) return;
    	//at访问像素点
    	for (int i = 1; i<src.rows; ++i)
    		for (int j = 1; j < src.cols; ++j) {
    			if ((i - 1 >= 0) && (j - 1) >= 0 && (i + 1)<src.rows && (j + 1)<src.cols) {//边缘不进行处理
    				dst.at<Vec3b>(i, j)[0] = (src.at<Vec3b>(i, j)[0] + src.at<Vec3b>(i - 1, j - 1)[0] + src.at<Vec3b>(i - 1, j)[0] + src.at<Vec3b>(i, j - 1)[0] +
    					src.at<Vec3b>(i - 1, j + 1)[0] + src.at<Vec3b>(i + 1, j - 1)[0] + src.at<Vec3b>(i + 1, j + 1)[0] + src.at<Vec3b>(i, j + 1)[0] +
    					src.at<Vec3b>(i + 1, j)[0]) / 9;
    				dst.at<Vec3b>(i, j)[1] = (src.at<Vec3b>(i, j)[1] + src.at<Vec3b>(i - 1, j - 1)[1] + src.at<Vec3b>(i - 1, j)[1] + src.at<Vec3b>(i, j - 1)[1] +
    					src.at<Vec3b>(i - 1, j + 1)[1] + src.at<Vec3b>(i + 1, j - 1)[1] + src.at<Vec3b>(i + 1, j + 1)[1] + src.at<Vec3b>(i, j + 1)[1] +
    					src.at<Vec3b>(i + 1, j)[1]) / 9;
    				dst.at<Vec3b>(i, j)[2] = (src.at<Vec3b>(i, j)[2] + src.at<Vec3b>(i - 1, j - 1)[2] + src.at<Vec3b>(i - 1, j)[2] + src.at<Vec3b>(i, j - 1)[2] +
    					src.at<Vec3b>(i - 1, j + 1)[2] + src.at<Vec3b>(i + 1, j - 1)[2] + src.at<Vec3b>(i + 1, j + 1)[2] + src.at<Vec3b>(i, j + 1)[2] +
    					src.at<Vec3b>(i + 1, j)[2]) / 9;
    			}
    			else {//边缘赋值
    				dst.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i, j)[0];
    				dst.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i, j)[1];
    				dst.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i, j)[2];
    			}
    		}
    }
    //图像椒盐化
    void salt(Mat &image, int num) {
    	if (!image.data) return;//防止传入空图
    	int i, j;
    	srand(time(NULL));
    	for (int x = 0; x < num; ++x) {
    		i = rand() % image.rows;
    		j = rand() % image.cols;
    		image.at<Vec3b>(i, j)[0] = 255;
    		image.at<Vec3b>(i, j)[1] = 255;
    		image.at<Vec3b>(i, j)[2] = 255;
    	}
    }
    void main() {
    	Mat image = imread("路飞.jpg");
     
    	Mat Salt_Image;
    	image.copyTo(Salt_Image);
    	salt(Salt_Image, 3000);
     
    	Mat image1(image.size(), image.type());
    	Mat image2;
    	AverFiltering(Salt_Image, image1);
    	blur(Salt_Image, image2, Size(3, 3));//openCV库自带的均值滤波函数
    	imshow("原图", image);
    	imshow("自定义均值滤波", image1);
    	imshow("openCV自带的均值滤波", image2);
    	waitKey();
    }
    


    效果图:

     

    可以看到图片变模糊而且噪声并没有很有效的去除,该算法只是模糊化了图片而已。

    二.中值滤波

           首先,我们复习中值。在一连串数字{1,4,6,8,9}中,数字6就是这串数字的中值。由此我们可以应用到图像处理中。依然我们在图像中去3*3的矩阵,里面有9个像素点,我们将9个像素进行排序,最后将这个矩阵的中心点赋值为这九个像素的中值。

                                         

    代码:

    //求九个数的中值
    uchar Median(uchar n1, uchar n2, uchar n3, uchar n4, uchar n5,
    	uchar n6, uchar n7, uchar n8, uchar n9) {
    	uchar arr[9];
    	arr[0] = n1;
    	arr[1] = n2;
    	arr[2] = n3;
    	arr[3] = n4;
    	arr[4] = n5;
    	arr[5] = n6;
    	arr[6] = n7;
    	arr[7] = n8;
    	arr[8] = n9;
    	for (int gap = 9 / 2; gap > 0; gap /= 2)//希尔排序
    		for (int i = gap; i < 9; ++i)
    			for (int j = i - gap; j >= 0 && arr[j] > arr[j + gap]; j -= gap)
    				swap(arr[j], arr[j + gap]);
    	return arr[4];//返回中值
    }
     
    //图像椒盐化
    void salt(Mat &image, int num) {
    	if (!image.data) return;//防止传入空图
    	int i, j;
    	srand(time(NULL));
    	for (int x = 0; x < num; ++x) {
    		i = rand() % image.rows;
    		j = rand() % image.cols;
    		image.at<Vec3b>(i, j)[0] = 255;
    		image.at<Vec3b>(i, j)[1] = 255;
    		image.at<Vec3b>(i, j)[2] = 255;
    	}
    }
     
    //中值滤波函数
    void MedianFlitering(const Mat &src, Mat &dst) {
    	if (!src.data)return;
    	Mat _dst(src.size(), src.type());
    	for(int i=0;i<src.rows;++i)
    		for (int j=0; j < src.cols; ++j) {
    			if ((i - 1) > 0 && (i + 1) < src.rows && (j - 1) > 0 && (j + 1) < src.cols) {
    				_dst.at<Vec3b>(i, j)[0] = Median(src.at<Vec3b>(i, j)[0], src.at<Vec3b>(i + 1, j + 1)[0],
    					src.at<Vec3b>(i + 1, j)[0], src.at<Vec3b>(i, j + 1)[0], src.at<Vec3b>(i + 1, j - 1)[0],
    					src.at<Vec3b>(i - 1, j + 1)[0], src.at<Vec3b>(i - 1, j)[0], src.at<Vec3b>(i, j - 1)[0],
    					src.at<Vec3b>(i - 1, j - 1)[0]);
    				_dst.at<Vec3b>(i, j)[1] = Median(src.at<Vec3b>(i, j)[1], src.at<Vec3b>(i + 1, j + 1)[1],
    					src.at<Vec3b>(i + 1, j)[1], src.at<Vec3b>(i, j + 1)[1], src.at<Vec3b>(i + 1, j - 1)[1],
    					src.at<Vec3b>(i - 1, j + 1)[1], src.at<Vec3b>(i - 1, j)[1], src.at<Vec3b>(i, j - 1)[1],
    					src.at<Vec3b>(i - 1, j - 1)[1]);
    				_dst.at<Vec3b>(i, j)[2] = Median(src.at<Vec3b>(i, j)[2], src.at<Vec3b>(i + 1, j + 1)[2],
    					src.at<Vec3b>(i + 1, j)[2], src.at<Vec3b>(i, j + 1)[2], src.at<Vec3b>(i + 1, j - 1)[2],
    					src.at<Vec3b>(i - 1, j + 1)[2], src.at<Vec3b>(i - 1, j)[2], src.at<Vec3b>(i, j - 1)[2],
    					src.at<Vec3b>(i - 1, j - 1)[2]);
    			}
    			else
    				_dst.at<Vec3b>(i, j) = src.at<Vec3b>(i, j);
    		}
    	_dst.copyTo(dst);//拷贝
    }
     
     
    void main() {
    	Mat image = imread("路飞.jpg");
     
    	Mat Salt_Image;
    	image.copyTo(Salt_Image);
    	salt(Salt_Image, 3000);
     
    	Mat image3, image4;
    	MedianFlitering(Salt_Image, image3);
    	medianBlur(Salt_Image, image4, 3);
    	imshow("自定义中值滤波处理后", image3);
    	imshow("openCV自带的中值滤波", image4);
    	waitKey();
    }
    

     

    效果图:

    可以看到,椒盐噪声很好的被平滑了,而且也没均值那样模糊化太过于严重。

    三 填充问题

    在对图像应用滤波器进行过滤时,边界问题是一个需要处理的问题。一般来说,有3种处理的方法。

    1. 不做边界处理

    不对图像的边界作任何处理,在对图像进行滤波时,滤波器没有作用到图像的四周,因此图像的四周没有发生改变。

     

    2. 填充0

    对图像的边界做扩展,在扩展边界中填充0,对于边长为2k+1的方形滤波器,扩展的边界大小为k,若原来的图像为[m, n],则扩展后图像变为[m+2k, n+2k]。进行滤波之后,图像会出现一条黑色的边框。

     

    3. 填充最近像素值

    扩展与 填充0 的扩展类似,只不过填充0的扩展是在扩展部分填充0,而这个方法是填充距离最近的像素的值。

    四 总结:

    均值滤波和和中值滤波都可以起到平滑图像,虑去噪声的功能。

    均值滤波采用线性的方法,平均整个窗口范围内的像素值,均值滤波本身存在着固有的缺陷,即它不能很好地保护图像细节,在图像去噪的同时也破坏了图像的细节部分,从而使图像变得模糊,不能很好地去除噪声点。均值滤波对高斯噪声表现较好,对椒盐噪声表现较差。

    中值滤波采用非线性的方法,它在平滑脉冲噪声方面非常有效,同时它可以保护图像尖锐的边缘,选择适当的点来替代污染点的值,所以处理效果好,对椒盐噪声表现较好,对高斯噪声表现较差。

    参考:

    1.均值滤波和中值滤波

    https://blog.csdn.net/cjsh_123456/article/details/79261271

    2.

    展开全文
  • 均值滤波,是图像处理中常用的手段,从频率域观点来看均值滤波是一种低通滤波器,高频信号将会去掉。均值滤波可以帮助消除图像尖锐噪声,实现图像平滑,模糊等功能。理想的均值滤波是用每个像素和它周围像素计算出来...

    一. 均值滤波简介和原理

            均值滤波,是图像处理中常用的手段,从频率域观点来看均值滤波是一种低通滤波器,高频信号将会去掉。均值滤波可以帮助消除图像尖锐噪声,实现图像平滑,模糊等功能。理想的均值滤波是用每个像素和它周围像素计算出来的平均值替换图像中每个像素。

            以3*3均值滤波器为例,均值滤波器算法原理如下图:

              

                              ↑


    二. 用均值滤波器对椒盐噪声污染后的图像去噪

            python 源码:

    import cv2
    
    import numpy as np
    
    # mean filter
    
    def mean_filter(img, K_size=3):
    
        H, W, C = img.shape
    
        # zero padding
    
        pad = K_size // 2
    
        out = np.zeros((H + pad * 2, W + pad * 2, C), dtype=np.float)
    
        out[pad: pad + H, pad: pad + W] = img.copy().astype(np.float)
    
        tmp = out.copy()
    
        # filtering
    
        for y in range(H):
    
            for x in range(W):
    
                for c in range(C):
    
                    out[pad + y, pad + x, c] = np.mean(tmp[y: y + K_size, x: x + K_size, c])
    
        out = out[pad: pad + H, pad: pad + W].astype(np.uint8)
    
        return out
    
    # Read image
    
    img = cv2.imread("../paojie_sp1.jpg")
    
    # Mean Filter
    
    out = mean_filter(img, K_size=5)
    
    # Save result
    
    cv2.imwrite("out.jpg", out)
    
    cv2.imshow("result", out)
    
    cv2.waitKey(0)
    
    cv2.destroyAllWindows()
    
    

    三. 实验结果:

              

                        原图  ↑

              

                        模板大小5*5,均值滤波后的图像 ↑

            可以看到,均值滤波后,图像中噪声虽然有所减弱,但是图像变模糊了。因为均值滤波器过滤掉了图像中的高频分量,所以图像的边缘都变模糊了。(去除一定量椒盐噪声,可以考虑使用中值滤波)


    四. 参考内容:

            https://www.jianshu.com/p/8a507f44d68d

            https://www.cnblogs.com/wojianxin/p/12501891.html

    展开全文
  • MATLAB图像均值滤波

    2020-06-04 23:30:36
    图像添加一个方差为0.05的椒盐噪声(自己可以添加高斯噪声),然后对图像进行3*3算数均值滤波,几何均值滤波,Q=1.5大小的谐波滤波处理,可以观察处理后的结果
  • 本系列博客,注重图像处理领域基本算法的原理,主要用matlab语言实现。 1、滤波模板的产生 首先,滤波要有模板,在matlab中。得到模板的途径主要有两种,一种是自己定义,另一种是通过调用函数fspecial得到各种...

         这里主要通过实现一个均值滤波来阐述图像滤波的具体操作。本系列博客,注重图像处理领域基本算法的原理,主要用matlab语言实现。


    1、滤波模板的产生

    首先,滤波要有模板,在matlab中。得到模板的途径主要有两种,一种是自己定义,另一种是通过调用函数fspecial得到各种类型的模板。

    下面看一个均值滤波器的模板的产生,模板就是一个矩阵,这个没疑问吧!!!

      fspecial('average')
    
    ans =
    
           1/9            1/9            1/9     
           1/9            1/9            1/9     
           1/9            1/9            1/9 

    顺便说一下啊,通过库函数实现图像滤波的基本过程

    对于线性滤波器,通常使用imfilter函数实现滤波。

    对于非线性滤波,通常使用colfilt函数实现。中值滤波由于太常用,有单独封装的函数medfilt2.


    2、滤波具体实现过程

    有了模板之后,要做的工作主要就是让模板滑过我们的图像,然后与对应模板下面的元素做卷积运算(别把卷积看到吓死人,从上一篇博客可以看出,卷积对应离散的图像而言就是相乘求和的一个过程),不过在这个操作之前,一般需要对图像的边缘进行填充,想一下就能理解为什么要进行填充了是吧!!不懂的可以见这篇博客点击打开链接

    或者还是参考冈萨雷斯的书,实在是太经典了,经典到每个字,真心的!!!

    input = imread('lena.bmp');
    
    mask = 1 / 16 * [1 2 1; 2 4 2; 1 2 1];  % 考虑3*3的滤波模板
    
    % 使用库函数实现(在对sobel求取边缘的时候貌似也得分别求水平和垂直边缘)
    output1 = imfilter(double(input), mask, 'conv', 0, 'full');     %求竖边缘
    
    % 下面自己实现
    [m, n] = size(input);
    % 先填充输入图像,这里依旧通过0来填充外边界
    input_temp = zeros(m + 4, n + 4);
    
    % 初始化输入图像
    input_temp(3: m + 3 - 1, 3: n + 3 - 1) = input;
    
    % 让模板滑过扩展的输入向量
    xx = size(input_temp, 1) - 3 + 1;
    yy = size(input_temp, 2) - 3 + 1;
    output = zeros(xx,yy);
    
    for i = 1: xx
        for j = 1: yy
            output(i, j) = sum( sum( input_temp(i: i + 3 - 1 , j : j + 3 - 1) .* mask ) ) ;    
        end
    end
    
    fprintf('调用库函数imfilter完成相关运算');
    subplot(131);imshow( uint8(input) );  title('原图像');
    subplot(132);imshow( uint8(output1) );title('调用库函数实现均值滤波');
    subplot(133);imshow( uint8(output) ); title('自己实现均值滤波');
    
    % 看自己的滤波函数是否有问题
    equal = sum(sum(output1 ~= output))   % equal = 0 表示处理后的结果一样

    运行图:


    equal =
    
           0     

    equal等于0,表明自己实现的均值滤波和库函数得到同样的结果。


    ok,搞定!!!!


    展开全文
  • 算术均值 close all clear allf=imread('D:/testData/filtering.tif');[w,h]=size(f); image= f(:,:); fsize1=3; fsize2=5; fsize3=9;fssize1=(fsize1-1)/2; fssize2=(fsize2-1)/2; fssize3=(fsize3-1)/2;figure();...

    算术均值

    close all 
    clear all
    
    f=imread('D:/testData/filtering.tif');
    
    [w,h]=size(f);
    image= f(:,:);
    fsize1=3;
    fsize2=5;
    fsize3=9;
    
    fssize1=(fsize1-1)/2;
    fssize2=(fsize2-1)/2;
    fssize3=(fsize3-1)/2;
    
    figure();
    subplot(1,2,1);
    imshow(image);
    xlabel('原图像');
    
    resultImage = image;
    
    for x=1+fssize1:1:w-fssize1
        for y=1+fssize1:1:w-fssize1
            is=f(x-fssize1:1:x+fssize1,y-fssize1:1:y+fssize1);
            resultImage(x,y)=sum(is(:))/numel(is); 
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('3*3算术均值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize2:1:w-fssize2
        for y=1+fssize2:1:w-fssize2
            is=f(x-fssize2:1:x+fssize2,y-fssize2:1:y+fssize2);
            resultImage(x,y)=sum(is(:))/numel(is); 
    
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('5*5算术均值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize3:1:w-fssize3
        for y=1+fssize3:1:w-fssize3
            is=f(x-fssize3:1:x+fssize3,y-fssize3:1:y+fssize3);
            resultImage(x,y)=sum(is(:))/numel(is); 
    
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('9*9算术均值');

    几何均值

    close all 
    clear all
    
    f=imread('D:/testData/filtering.tif');
    
    [w,h]=size(f);
    image= f(:,:);
    fsize1=3;
    fsize2=5;
    fsize3=9;
    
    fssize1=(fsize1-1)/2;
    fssize2=(fsize2-1)/2;
    fssize3=(fsize3-1)/2;
    
    figure();
    subplot(1,2,1);
    imshow(image);
    xlabel('原图像');
    
    resultImage = image;
    
    for x=1+fssize1:1:w-fssize1
        for y=1+fssize1:1:w-fssize1
            is=f(x-fssize1:1:x+fssize1,y-fssize1:1:y+fssize1);
            resultImage(x,y)=prod(prod(is(:)))^(1/numel(is)); 
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('3*3几何均值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize2:1:w-fssize2
        for y=1+fssize2:1:w-fssize2
            %遍历每个点的四周
            is=f(x-fssize2:1:x+fssize2,y-fssize2:1:y+fssize2);
            resultImage(x,y)=prod(prod(is(:)))^(1/numel(is)); 
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('5*5几何均值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize3:1:w-fssize3
        for y=1+fssize3:1:w-fssize3
            %遍历每个点的四周
            is=f(x-fssize3:1:x+fssize3,y-fssize3:1:y+fssize3);
            resultImage(x,y)=prod(prod(is(:)))^(1/numel(is)); 
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('9*9几何均值');

    谐波均值

    close all 
    clear all
    
    f=imread('D:/testData/filtering.tif');
    
    [w,h]=size(f);
    image= f(:,:);
    fsize1=3;
    fsize2=5;
    fsize3=9;
    
    fssize1=(fsize1-1)/2;
    fssize2=(fsize2-1)/2;
    fssize3=(fsize3-1)/2;
    
    figure();
    subplot(1,2,1);
    imshow(image);
    xlabel('原图像');
    
    resultImage = image;
    
    for x=1+fssize1:1:w-fssize1
        for y=1+fssize1:1:w-fssize1
            is=f(x-fssize1:1:x+fssize1,y-fssize1:1:y+fssize1);
            is=1./is;
            resultImage(x,y)=numel(is)/sum(is(:)); 
    
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('3*3谐波均值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize2:1:w-fssize2
        for y=1+fssize2:1:w-fssize2
            %遍历每个点的四周
            is=f(x-fssize2:1:x+fssize2,y-fssize2:1:y+fssize2);
            is=1./is;
            resultImage(x,y)=numel(is)/sum(is(:));  
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('5*5谐波均值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize3:1:w-fssize3
        for y=1+fssize3:1:w-fssize3
            %遍历每个点的四周
            is=f(x-fssize3:1:x+fssize3,y-fssize3:1:y+fssize3);
            is=1./is;
            resultImage(x,y)=numel(is)/sum(is(:));   
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('9*9谐波均值');

    逆谐波

    close all 
    clear all
    
    f=imread('D:/testData/filtering.tif');
    
    [w,h]=size(f);
    image= f(:,:);
    Q1 = 1.5;
    fsize1=3;
    fsize2=5;
    fsize3=9;
    
    fssize1=(fsize1-1)/2;
    fssize2=(fsize2-1)/2;
    fssize3=(fsize3-1)/2;
    
    figure();
    subplot(1,2,1);
    imshow(image);
    xlabel('原图像');
    
    resultImage = image;
    
    for x=1+fssize1:1:w-fssize1
        for y=1+fssize1:1:w-fssize1
            is=f(x-fssize1:1:x+fssize1,y-fssize1:1:y+fssize1);
            resultImage(x,y) = sum(is(:).^(Q1+1))/sum(is(:).^(Q1));
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('3*3逆谐波均值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize2:1:w-fssize2
        for y=1+fssize2:1:w-fssize2
            %遍历每个点的四周
            is=f(x-fssize2:1:x+fssize2,y-fssize2:1:y+fssize2);
            resultImage(x,y) = sum(is(:).^(Q1+1))/sum(is(:).^(Q1));
    
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('5*5逆谐波均值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize3:1:w-fssize3
        for y=1+fssize3:1:w-fssize3
            %遍历每个点的四周
            is=f(x-fssize3:1:x+fssize3,y-fssize3:1:y+fssize3);
            resultImage(x,y) = sum(is(:).^(Q1+1))/sum(is(:).^(Q1));
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('9*9逆谐波均值');

    中值

    close all 
    clear all
    
    f=imread('D:/testData/filtering.tif');
    
    [w,h]=size(f);
    image= f(:,:);
    
    fsize1=3;
    fsize2=5;
    fsize3=9;
    
    fssize1=(fsize1-1)/2;
    fssize2=(fsize2-1)/2;
    fssize3=(fsize3-1)/2;
    
    figure();
    subplot(1,2,1);
    imshow(image);
    xlabel('原图像');
    
    resultImage = image;
    
    for x=1+fssize1:1:w-fssize1
        for y=1+fssize1:1:w-fssize1
            is=f(x-fssize1:1:x+fssize1,y-fssize1:1:y+fssize1);
            temp = sort(is(:));
            resultImage(x,y)= temp((numel(temp)-1)/2);
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('3*3中值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize2:1:w-fssize2
        for y=1+fssize2:1:w-fssize2
            %遍历每个点的四周
            is=f(x-fssize2:1:x+fssize2,y-fssize2:1:y+fssize2);
            temp = sort(is(:));
            resultImage(x,y)= temp((numel(temp)-1)/2);
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('5*5中值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize3:1:w-fssize3
        for y=1+fssize3:1:w-fssize3
            %遍历每个点的四周
            is=f(x-fssize3:1:x+fssize3,y-fssize3:1:y+fssize3);
            temp = sort(is(:));
            resultImage(x,y)= temp((numel(temp)-1)/2);
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('9*9中值');

    最大值

    close all 
    clear all
    
    f=imread('D:/testData/filtering.tif');
    
    [w,h]=size(f);
    image= f(:,:);
    
    fsize1=3;
    fsize2=5;
    fsize3=9;
    
    fssize1=(fsize1-1)/2;
    fssize2=(fsize2-1)/2;
    fssize3=(fsize3-1)/2;
    
    figure();
    subplot(1,2,1);
    imshow(image);
    xlabel('原图像');
    
    resultImage = image;
    
    for x=1+fssize1:1:w-fssize1
        for y=1+fssize1:1:w-fssize1
            is=f(x-fssize1:1:x+fssize1,y-fssize1:1:y+fssize1);
            temp = is(:);
            resultImage(x,y)= max(temp);
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('3*3最大值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize2:1:w-fssize2
        for y=1+fssize2:1:w-fssize2
            %遍历每个点的四周
            is=f(x-fssize2:1:x+fssize2,y-fssize2:1:y+fssize2);
            temp = is(:);
            resultImage(x,y)= max(temp);
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('5*5最大值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize3:1:w-fssize3
        for y=1+fssize3:1:w-fssize3
            %遍历每个点的四周
            is=f(x-fssize3:1:x+fssize3,y-fssize3:1:y+fssize3);
            temp = is(:);
            resultImage(x,y)= max(temp);
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('9*9最大值');

    最小值

    close all 
    clear all
    
    f=imread('D:/testData/filtering.tif');
    
    [w,h]=size(f);
    image= f(:,:);
    
    fsize1=3;
    fsize2=5;
    fsize3=9;
    
    fssize1=(fsize1-1)/2;
    fssize2=(fsize2-1)/2;
    fssize3=(fsize3-1)/2;
    
    figure();
    subplot(1,2,1);
    imshow(image);
    xlabel('原图像');
    
    resultImage = image;
    
    for x=1+fssize1:1:w-fssize1
        for y=1+fssize1:1:w-fssize1
            is=f(x-fssize1:1:x+fssize1,y-fssize1:1:y+fssize1);
            temp = is(:);
            resultImage(x,y)= min(temp);
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('3*3最小值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize2:1:w-fssize2
        for y=1+fssize2:1:w-fssize2
            %遍历每个点的四周
            is=f(x-fssize2:1:x+fssize2,y-fssize2:1:y+fssize2);
            temp = is(:);
            resultImage(x,y)= min(temp);
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('5*5最小值');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize3:1:w-fssize3
        for y=1+fssize3:1:w-fssize3
            %遍历每个点的四周
            is=f(x-fssize3:1:x+fssize3,y-fssize3:1:y+fssize3);
            temp = is(:);
            resultImage(x,y)= min(temp);
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('9*9最小值');

    中点

    close all 
    clear all
    
    f=imread('D:/testData/filtering.tif');
    
    [w,h]=size(f);
    image= f(:,:);
    
    fsize1=3;
    fsize2=5;
    fsize3=9;
    
    fssize1=(fsize1-1)/2;
    fssize2=(fsize2-1)/2;
    fssize3=(fsize3-1)/2;
    
    figure();
    subplot(1,2,1);
    imshow(image);
    xlabel('原图像');
    
    resultImage = image;
    
    for x=1+fssize1:1:w-fssize1
        for y=1+fssize1:1:w-fssize1
            is=f(x-fssize1:1:x+fssize1,y-fssize1:1:y+fssize1);
            temp = is(:);
            resultImage(x,y)= (max(temp) + min(temp))/2;
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('3*3中点');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize2:1:w-fssize2
        for y=1+fssize2:1:w-fssize2
            %遍历每个点的四周
            is=f(x-fssize2:1:x+fssize2,y-fssize2:1:y+fssize2);
            temp = is(:);
            resultImage(x,y)= (max(temp) + min(temp))/2;
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('5*5中点');
    
    resultImage= f(:,:);
    figure();
    subplot(1,2,1);
    imshow(f);
    xlabel('原图像');
    
    for x=1+fssize3:1:w-fssize3
        for y=1+fssize3:1:w-fssize3
            %遍历每个点的四周
            is=f(x-fssize3:1:x+fssize3,y-fssize3:1:y+fssize3);
            temp = is(:);
            resultImage(x,y)= (max(temp) + min(temp))/2;
        end
    end
    
    
    subplot(1,2,2);
    imshow(resultImage);
    xlabel('9*9中点');
    展开全文
  • 滤波器作为图像处理课程的重要内容,大致可分为两类,空域滤波器和频率域滤波器。本文主要介绍常用的四种滤波器:中值滤波器、均值滤波器、高斯滤波器、双边滤波器,并基于opencv做出实现。空域的滤波器一般可以通过...
  • 数字图像处理——均值滤波器【像素级别处理】(python) 文章目录数字图像处理——均值滤波器【像素级别处理】(python)原理代码实现 原理 简介: 均值滤波器是在指定邻域内对其像素点求平均值,然后代替相同...
  • 本篇文章中,我们一起仔细探讨了OpenCV图像处理技术中比较热门的图像滤波操作。图像滤波系列文章浅墨准备花两次更新的时间来讲,此为上篇,为大家剖析了“方框滤波“,”均值滤波“和”高斯滤波“三种常见线性邻域...
  • 均值滤波器用来降低噪声,均值滤波器的主要应用是去除图像中的不相关细节,不相关是指与滤波器的模板相比较小的像素区域。模糊图片以便得到感兴趣物体的粗略描述,因此那些较小的物体的灰度就会与背景混合在一起,较...
  • 图像处理 中值滤波均值滤波 matlab算法实现
  • 数字图像处理 均值滤波器自写函数系统函数参考文件 自写函数 %%自写滤波 I = double(imread('Fig3.35(a).jpg')); [m,n] = size(I); A3 = zeros(m,n); A5 = zeros(m,n); for i = 3:m-3 for j = 3:n-3 A3(i,j) = ( I...
  • 逆滤波和维纳滤波 简介 在图像的获取、传输以及记录保存过程中,由于各种因素,如成像设备与目标物体的相对运动,大气的湍流效应,光学系统的相差,成像系统的非线性畸变,环境的随机噪声等原因都会使图像产生一定...
  • 图像滤波的作用: 在尽可能保留图像细节特征的条件下,对目标图像的噪声进行抑制。 常见的图像滤波器:  线性滤波: 均值滤波 高斯滤波  非线性滤波:中值滤波 双边滤波 *均值滤波    均值...
  • 滤波器作为图像处理课程的重要内容,大致可分为两类,空域滤波器和频率域滤波器。本文主要介绍常用的四种滤波器:中值滤波器、均值滤波器、高斯滤波器、双边滤波器,并基于opencv做出实现。空域的滤波器一般可以通过...
  • 数字图像处理均值滤波,用于图像去噪。很完整的源代码
  • 均值滤波器中,模板内像素的权重都为一,其只是简单的像素加法平均 而,加权均值滤波器,对模板中的像素点赋予不同的权重,求的是像素的加权平均,典型的模板,例如高斯模糊,其模板权重呈现钟型的高斯分布: ...
  • 采用算数均值滤波器,几何均值滤波器,中值滤波,自适应滤波器对图像进行滤波操作,并输出图像。 首先放一下结果: (1)算术均值滤波器 计算子窗口的和并求平均 程序中对图像边缘不处理。右图为加入椒盐噪声,...
  • 基于MATLAB图像处理的中值滤波均值滤波以及高斯滤波的实现与对比 1.背景知识 中值滤波法是一种非线性平滑技术,它将每一像素点的灰度值设置为该点某邻域窗口内的所有像素点灰度值的中值. 中值滤波是基于排序...
  • 数字图像处理实验(2)——中值滤波 实验题目 编程实现灰度图像的中值滤波平滑处理。滤波模板的大小自定(可为3×3、5×5、7×7、15×15等)。实验图像可从提供的实验图像集中的噪声图像中选取。 思考题:(选做) ...
1 2 3 4 5 ... 20
收藏数 6,489
精华内容 2,595