精华内容
下载资源
问答
  • 双边滤波与高斯滤波

    千次阅读 多人点赞 2020-11-07 16:10:46
    目录 双边滤波器工作原理

    高斯滤波原理

    在数字图像中的高斯噪声主要来源出现在采集期间。由于不良照明或高温引起的传感器噪声。如果一个噪声,它的幅度分布服从高斯分布,而它的功率谱密度又是均匀分布的,则称它为高斯白噪声。高斯滤波器是一种线性滤波器,能够有效的抑制噪声,平滑图像。其作用原理和均值滤波器类似,都是取滤波器窗口内的像素的均值作为输出。其窗口模板的系数和均值滤波器不同,均值滤波器的模板系数都是相同的为1;而高斯滤波器的模板系数,则随着距离模板中心的增大而系数减小高斯噪声就是它的概率密度函数服从高斯分布(即正态分布)的一类噪声。高斯分布公式为:

    其中,μ是x的均值,σ是x的标准差。由于每次计算都以当前计算点为原点,所以μ等于0。于是公式进一步简化为:

    在图形上,正态分布是一种钟形曲线,越接近中心,取值越大,越远离中心,取值越小。
    计算平均值的时候,我们只需要将"中心点"作为原点,其他点按照其在正态曲线上的位置,分配权重,就可以得到一个加权平均值。σ的大小决定了高斯函数的宽度,如下图所示:

    高斯分布的二维方程是:

    参考自:https://blog.csdn.net/fangyan90617/article/details/100516889

    高斯滤波过程

    高斯滤波也是一个非常典型的图像卷积例子,本质上,高斯滤波就是将(灰度)图像 和一个高斯核进行卷积操作,具体的方式和上面的两个滤波方法相似,只是卷积核存在差别。理论上,高斯分布在所有定义域上都有非负值,这就需要一个无限大的卷积核。在实际的计算过程中,卷积核是固定大小的,只需要将待计算的“中心点”作为原点,将周围的点按照正态分布函数分配权重,计算加权平均值,得到最终的值,这个过程就是二维高斯核的卷积过程。

    具体过程如下图所示,假定中心点坐标为(0,0),当设定卷积核为3时,只需计算距离它最近的8个点,如图中的第一个矩阵所示。以此矩阵中的坐标,带入到公式2-14中,并且取σ=1.5,则半径为1的权重矩阵如图中第二个矩阵所示。因为需要利用该权重矩阵做加权平均,故需要对原始的矩阵做归一化。具体操作方式是求出第二个矩阵的总和为0.4783,然后再将该矩阵的9个值分别除以0.4783,得到最终的卷积核(权重矩阵)。

    高斯滤波原理及python实现

    通过上述步骤计算出高斯核,基于该高斯核便可进行高斯滤波操作。假设现有9个像素点,灰度值(0-255)如下图中第一个卷积核所示,计算图中中心点的滤波后的值。每个像素点乘以相对应的权重值,得到最终的分布值。将这9个像素的值相加得到的结果,就是中心位置图像滤波后的值。对所有点重复这个过程,就得到了高斯滤波后的图像。如果原图是彩色图片,可以对RGB三个通道分别做高斯滤波。

    高斯滤波原理及python实现

    参考自:https://www.growai.cn/qlmx/143.html

    高斯滤波目的

    1.图像为什么要滤波?
    答:a.消除图像在数字化过程中产生或者混入的噪声。
    b.提取图片对象的特征作为图像识别的特征模式。
    2.滤波器该如何去理解?
    答:滤波器可以想象成一个包含加权系数的窗口或者说一个镜片,当使用滤波器去平滑处理图像的时候,就是把通过这个窗口或者镜片去看这个图像。
    参考自:https://www.jianshu.com/p/73e6ccbd8f3f

    双边滤波原理

    双边滤波(Bilateral filter)是一种非线性的滤波方法,是结合图像的空间邻近度和像素值相似度的一种折衷处理,同时考虑空域信息和灰度相似性,达到保边去噪的目的。双边滤波器之所以能够做到在平滑去噪的同时还能够很好的保存边缘(Edge Preserve),是由于其滤波器的核由两个函数生成:

    • 一个函数由像素欧式距离决定滤波器模板的系数
    • 另一个函数由像素的灰度差值决定滤波器的系数

    双边滤波其实很简单,它只是比高斯滤波多了一种掩膜而已。两种掩膜都是套用高斯分布公式得出来的,只是其中的代表的含义不同而已。求第一个掩膜所用的高斯分布中,代表掩膜中每一个点的位置,其中为掩膜中心的位置;求第二个掩膜所用的高斯分布中,代表掩膜中每一个点的像素亮度值,其中为掩膜中心的像素亮度值;(这里有一个是需要注意的:第二个掩膜是需要每次都求取的,因为像素的亮度值无法预先确定,不是维持一个固定不变的pattern)。对于高斯滤波,仅用空间距离的权值系数核与图像卷积后,确定中心点的灰度值。即认为离中心点越近的点,其权重系数越大。双边滤波中加入了对灰度信息的权重,即在邻域内,灰度值越接近中心点灰度值的点的权重更大,灰度值相差大的点权重越小。此权重大小,则由值域高斯函数确定。两者权重系数相乘,得到最终的卷积模板。由于双边滤波需要每个中心点邻域的灰度信息来确定其系数,所以其速度与比一般的滤波慢很多,而且计算量增长速度为核大小的平方。这就是双边滤波,不光考虑了像素在空间中位置远近程度的影响,还考虑了像素亮度相近程度的影响。

    双边滤波器中,输出像素的值依赖于邻域像素的值的加权组合,

    接下来我们来讨论最关键的w(i, j, k, l)
    ws为空间临近高斯函数,wr为像素值相似度高斯函数

    可以看到,w是ws和wr的乘积。对于ws来说,这就是普通的高斯滤波函数,其代入的坐标,sigmas是程序输入值,该函数是在空间临近度上计算的。而wr是计算像素值相似度(颜色空间),注意,这就是高斯函数代入坐标值,2sigmar^2的上方是范数,在这里的值为 |f(i,j)-f(k,l)|^2。也就是两个点像素值差值的绝对值的平方。双边滤波器的加权系数是这两部分因子的非线性组合,空间邻近度因子Ws和亮度相似度因子Wr的乘积。前者随着像素点与中心点之间欧几里德距离的增加而减小,后者随着两像素亮度值之差的增大而减小。在图像变化平缓的区域,邻域内像素亮度值相差不大,双边滤波转化为高斯低通滤波器;在图像变化剧烈的区域,滤波器利用边缘点附近亮度值相近的像素点的亮度值平均代替原亮度值。因此,双边滤波器既平滑滤波了图像,又保持了图像的边缘。双边滤波器受3个参数的控制:滤波器半宽N、参数δs和δr。N越大,平滑作用越强;δs和δr分别控制着空间邻近度因子Ws和亮度像似度因子Wr的衰减程度。

     

    参数选择:

             空间域sigma选取:其中核大小通常为sigma的6*sigma + 1。因为离中心点3*sigma大小之外的系数与中点的系数只比非常小,可以认为此之外的点与中心点没有任何联系,及权重系数为0.OpenCV中默认的计算公式也是如此,OpenCV参考文档内容如下:“对应高斯参数的 Gaussian sigma (标准差). 如果为零,则标准差由下面的核尺寸计算: sigma = (n/2 - 1)*0.3 + 0.8, 其中 n=param1 对应水平核,n=param2对应垂直核.”

             值域sigma选取:另灰度差△g  =  abs(gray(xi,yi)- gray(xc,yc)),忽略常数的影响,因此其函数可以简化为:

    已知 0≤△g≤255;

    1)假设sigma = 255,当△g = 255时,系数为exp(-1) = 0.3679,当△g = 0时,系数为exp(-0)= 1.灰度最大点的系数与相差最小的灰度值系数之比为 0.3679.

    2)假设sigma = 122.5,当△g = 255时,系数为exp(-4) = 0.0183,当△g = 0时,系数为exp(-0)= 1.灰度差最大点的系数与相差最小的灰度值系数之比为 0.0183.

    结论

    当simga较大时,灰度差最大值与最小值的系数在很小的一个范围之内,其比值较大。及灰度差较大的点,对于中心点也会有相应的较大的权值,此与双边滤波的保留边缘的初衷相违背。

    当sigma较小时,灰度差最大值与最小值的系数在较大的一个范围之内,其比值很小,及灰度差较大的点,对应中心点仅有很小的权重。

    综上分析可知:

    Sigma越大,边缘越模糊,极限情况为simga无穷大,值域系数近似相等(忽略常数时,将近为exp(0)= 1),与高斯模板(空间域模板)相乘后可认为等效于高斯滤波。

    Sigma越小,边缘越清晰,极限情况为simga无限接近0,值域系数近似相等(接近exp(-∞) =  0),与高斯模板(空间域模板)相乘后,可近似为系数皆相等,等效于源图像。

    代码实现

    摘自:https://qianmo.blog.csdn.net/article/details/23184547

    //-----------------------------------【程序说明】----------------------------------------------
    //            程序名称::《【OpenCV入门教程之九】非线性滤波专场:中值滤波、双边滤波  》 博文配套源码
    //            开发所用IDE版本:Visual Studio 2010
    //          开发所用OpenCV版本: 2.4.8
    //            2014年4月8日 Create by 浅墨
    //------------------------------------------------------------------------------------------------
     
    //-----------------------------------【头文件包含部分】---------------------------------------
    //            描述:包含程序所依赖的头文件
    //----------------------------------------------------------------------------------------------
    #include <opencv2/core/core.hpp>
    #include<opencv2/highgui/highgui.hpp>
    #include<opencv2/imgproc/imgproc.hpp>
    #include <iostream>
     
    //-----------------------------------【命名空间声明部分】---------------------------------------
    //            描述:包含程序所使用的命名空间
    //----------------------------------------------------------------------------------------------- 
    using namespace std;
    using namespace cv;
     
     
    //-----------------------------------【全局变量声明部分】--------------------------------------
    //            描述:全局变量声明
    //-----------------------------------------------------------------------------------------------
    Mat g_srcImage,g_dstImage1,g_dstImage2,g_dstImage3,g_dstImage4,g_dstImage5;
    int g_nBoxFilterValue=6;  //方框滤波内核值
    int g_nMeanBlurValue=10;  //均值滤波内核值
    int g_nGaussianBlurValue=6;  //高斯滤波内核值
    int g_nMedianBlurValue=10;  //中值滤波参数值
    int g_nBilateralFilterValue=10;  //双边滤波参数值
     
     
    //-----------------------------------【全局函数声明部分】--------------------------------------
    //            描述:全局函数声明
    //-----------------------------------------------------------------------------------------------
    //轨迹条回调函数
    static void on_BoxFilter(int, void *);            //方框滤波
    static void on_MeanBlur(int, void *);           //均值块滤波器
    static void on_GaussianBlur(int, void *);                    //高斯滤波器
    static void on_MedianBlur(int, void *);               //中值滤波器
    static void on_BilateralFilter(int, void*);                    //双边滤波器
     
     
     
    //-----------------------------------【main( )函数】--------------------------------------------
    //            描述:控制台应用程序的入口函数,我们的程序从这里开始
    //-----------------------------------------------------------------------------------------------
    int main(  )
    {
           system("color 5E"); 
     
           //载入原图
           g_srcImage= imread( "1.jpg", 1 );
           if(!g_srcImage.data ) { printf("Oh,no,读取srcImage错误~!\n"); return false; }
     
           //克隆原图到四个Mat类型中
           g_dstImage1= g_srcImage.clone( );
           g_dstImage2= g_srcImage.clone( );
           g_dstImage3= g_srcImage.clone( );
           g_dstImage4= g_srcImage.clone( );
           g_dstImage5= g_srcImage.clone( );
     
           //显示原图
           namedWindow("【<0>原图窗口】", 1);
           imshow("【<0>原图窗口】",g_srcImage);
     
     
           //=================【<1>方框滤波】=========================
           //创建窗口
           namedWindow("【<1>方框滤波】", 1);
           //创建轨迹条
           createTrackbar("内核值:", "【<1>方框滤波】",&g_nBoxFilterValue, 50,on_BoxFilter );
           on_MeanBlur(g_nBoxFilterValue,0);
           imshow("【<1>方框滤波】", g_dstImage1);
           //=====================================================
     
     
           //=================【<2>均值滤波】==========================
           //创建窗口
           namedWindow("【<2>均值滤波】", 1);
           //创建轨迹条
           createTrackbar("内核值:", "【<2>均值滤波】",&g_nMeanBlurValue, 50,on_MeanBlur );
           on_MeanBlur(g_nMeanBlurValue,0);
           //======================================================
     
     
           //=================【<3>高斯滤波】===========================
           //创建窗口
           namedWindow("【<3>高斯滤波】", 1);
           //创建轨迹条
           createTrackbar("内核值:", "【<3>高斯滤波】",&g_nGaussianBlurValue, 50,on_GaussianBlur );
           on_GaussianBlur(g_nGaussianBlurValue,0);
           //=======================================================
     
     
           //=================【<4>中值滤波】===========================
           //创建窗口
           namedWindow("【<4>中值滤波】", 1);
           //创建轨迹条
           createTrackbar("参数值:", "【<4>中值滤波】",&g_nMedianBlurValue, 50,on_MedianBlur );
           on_MedianBlur(g_nMedianBlurValue,0);
           //=======================================================
     
     
           //=================【<5>双边滤波】===========================
           //创建窗口
           namedWindow("【<5>双边滤波】", 1);
           //创建轨迹条
           createTrackbar("参数值:", "【<5>双边滤波】",&g_nBilateralFilterValue, 50,on_BilateralFilter);
           on_BilateralFilter(g_nBilateralFilterValue,0);
           //=======================================================
     
     
           //输出一些帮助信息
           cout<<endl<<"\t嗯。好了,请调整滚动条观察图像效果~\n\n"
                  <<"\t按下“q”键时,程序退出~!\n"
                  <<"\n\n\t\t\t\tby浅墨";
           while(char(waitKey(1))!= 'q') {}
     
           return 0;
    }
     
    //-----------------------------【on_BoxFilter( )函数】------------------------------------
    //            描述:方框滤波操作的回调函数
    //-----------------------------------------------------------------------------------------------
    static void on_BoxFilter(int, void *)
    {
           //方框滤波操作
           boxFilter(g_srcImage, g_dstImage1, -1,Size( g_nBoxFilterValue+1, g_nBoxFilterValue+1));
           //显示窗口
           imshow("【<1>方框滤波】", g_dstImage1);
    }
     
    //-----------------------------【on_MeanBlur( )函数】------------------------------------
    //            描述:均值滤波操作的回调函数
    //-----------------------------------------------------------------------------------------------
    static void on_MeanBlur(int, void *)
    {
           blur(g_srcImage, g_dstImage2, Size( g_nMeanBlurValue+1, g_nMeanBlurValue+1),Point(-1,-1));
           imshow("【<2>均值滤波】", g_dstImage2);
     
    }
     
    //-----------------------------【on_GaussianBlur( )函数】------------------------------------
    //            描述:高斯滤波操作的回调函数
    //-----------------------------------------------------------------------------------------------
    static void on_GaussianBlur(int, void *)
    {
           GaussianBlur(g_srcImage, g_dstImage3, Size( g_nGaussianBlurValue*2+1,g_nGaussianBlurValue*2+1 ), 0, 0);
           imshow("【<3>高斯滤波】", g_dstImage3);
    }
     
     
    //-----------------------------【on_MedianBlur( )函数】------------------------------------
    //            描述:中值滤波操作的回调函数
    //-----------------------------------------------------------------------------------------------
    static void on_MedianBlur(int, void *)
    {
           medianBlur( g_srcImage, g_dstImage4, g_nMedianBlurValue*2+1 );
           imshow("【<4>中值滤波】", g_dstImage4);
    }
     
     
    //-----------------------------【on_BilateralFilter( )函数】------------------------------------
    //            描述:双边滤波操作的回调函数
    //-----------------------------------------------------------------------------------------------
    static void on_BilateralFilter(int, void *)
    {
           bilateralFilter( g_srcImage, g_dstImage5, g_nBilateralFilterValue, g_nBilateralFilterValue*2,g_nBilateralFilterValue/2 );
           imshow("【<5>双边滤波】", g_dstImage5);
    }

    https://blog.csdn.net/abcjennifer/article/details/7616663

    https://www.cnblogs.com/walccott/p/4957108.html

    https://blog.csdn.net/Jfuck/article/details/8932978


    展开全文
  • 针对雾天图像存在信息丢失、区域不清晰以及雾气遮挡等问题,提出了一种基于双边滤波高斯金字塔变换Retinex图像增强算法,以提高雾天图像的对比度。首先,基于空间域核函数和像素差,建立了改进的双边滤波函数数学模型...
  • python 双边滤波与高斯滤波

    万次阅读 2018-04-07 17:51:44
    python 双边滤波与高斯滤波高斯滤波就是对整幅图像进行加权平均的过程。每个像素点的值,都由其本身和邻域内的其它像素值经过加权平均后得到。高斯滤波的详细操作是:用一个模板(或称卷积、掩模)扫描图像中的每个...

    双边滤波速度不是特别快

     

    python 双边滤波与高斯滤波

    高斯滤波就是对整幅图像进行加权平均的过程。每个像素点的值,都由其本身和邻域内的其它像素值经过加权平均后得到。高斯滤波的详细操作是:用一个模板(或称卷积、掩模)扫描图像中的每个像素。用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。

    cv2.imshow('src',newimg)
    cv2.imshow('dst',lbimg)
    cv2.waitKey()
    cv2.destroyAllWindows()

    #高斯滤波

    lbimg=cv2.GaussianBlur(newimg,(3,3),1.8)


    展开全文
  • 本代码主要用matlab实现图片的高斯滤波双边滤波,参数可调
  • 本文详细介绍高斯滤波和双边滤波的原理并给出MATLAB实现,最后对照高斯滤波与双边滤波的效果。 目录 一、滤波原理 1.1 一维高斯分布 1.2 二维高斯分布 1.3 高斯滤波总结 二、双边滤波 1. 双边滤波的原理 2. ...

    本文详细介绍高斯滤波和双边滤波的原理并给出MATLAB实现,最后对照高斯滤波与双边滤波的效果。


    目录

    一、滤波原理

    1.1 一维高斯分布

    1.2 二维高斯分布

    1.3 高斯滤波总结

     二、双边滤波

    1. 双边滤波的原理 

    2. 双边滤波是如何实现“保边去噪”的?

    3. MATLAB实现双边滤波

     4. 关于sigma值的选取

    4.1 空间域sigma  选取

    4.2 值域sigma  选取

    三、双边滤波与高斯滤波结果对照

    3.1 仿真图像对照

    3.2 真实图像对照

    3.3 总结


    一、滤波原理

    参考:https://blog.csdn.net/nima1994/article/details/79776802(高斯滤波的原理)

    划重点:

    空域滤波的本质即在窗口内“取平均”,模板半径越大,模糊效果越强。

    高斯滤波中,高斯函数是用来计算模板权重的,其依据为:连续图像中,越靠近的点关系越密切,越远离的点关系越疏远,因此,加权平均更合理,即距离中心点越近的点权重越大,距离越远的点权重越小。

    1.1 一维高斯分布

    而一维高斯分布(正态分布)刚好满足这一条件,如图1.

                                                        

                                                                                                  图1  正态分布“钟形曲线”

    一维高斯分布公式见式(1),其中均值\mu决定了曲线的中心点,\sigma决定了曲线的宽度,\sigma越大曲线越宽。

                                                                                            f= \frac{ 1}{ \sigma\sqrt{2\pi} }e^{ -(x-\mu)^{ 2}/2\sigma^{2}}                 …………(1)

    MATLAB实现一维高斯函数:

    function g = Gaussian(X,avg,sigma)
    %% 功能说明:一维高斯分布
    %% 参数说明:avg -- 均值,决定中心点位置
    %          sigma -- 标准差,决定曲线宽度
       temp_1 = 1 / (sigma * sqrt(2*pi));
       temp_2 = -(X - avg).^2./(2*sigma^2);
       g = temp_1 * exp(temp_2);
       g = g ./ sum(g(:));
    end
    

    使用上述功能绘制不同\sigma值对应的曲线,代码如下:

    X = -15:0.1:15;
    avg = 0;  % 图像中心点为0
    sigmas = [1;2;3;4];
    for i = 1:length(sigmas)
        g = Gaussian(X,avg,sigmas(i));
        plot(X,g)
        hold on
    end
    legend('\sigma = 1','\sigma = 2','\sigma = 3','\sigma = 4');

    图像如图2,显然,\sigma决定了曲线的宽度,\sigma越大曲线越宽,且图像关于x = avg(这里为0)对称。

                                               

                                                                                       图2  不同\sigma值对应的一维高斯分布

    补充说明:之前做了min-max标准化,将不同sigma值对应的曲线的取值范围均映射在了[0,1]范围内,但现在发现这种做法忽略了sigma取值对曲线高度的影响。

    (高斯分布的性质:曲线下方与x轴上方的面积之和为1)sigma的取值不仅决定了曲线的宽度,也决定了曲线的高度,sigma越大,曲线越宽越矮;sigma越小,曲线越窄越高。

     

    1.2 二维高斯分布

    将x = x,y分别代入公式(1)后,二者相乘即可得到二维高斯分布公式(2):

                                                                                     f = \frac{ 1}{ 2\pi\sigma^{ 2}} e^{ -((x-\mu_{1})^{2}+(y-\mu_{2})^{2})/2\sigma^{2}}      …………(2)

    这里令\mu_{1} = 0, \mu_{2} = 0可得简化版二维高斯分布函数公式(3):

                                                                                     f = \frac{ 1}{ 2\pi\sigma^{ 2}} e^{ -(x^{2}+y^{2})/2\sigma^{2}}                       …………(3)

    根据公式(3)即可计算高斯滤波模板中每个点的权重。

    二维高斯函数,代码如下:

    function [G] = Gaussian(R,sigma)
    %% 功能说明:二维高斯函数,可用于计算高斯滤波权重矩阵
    %          高斯滤波:仅考虑了空域信息,未考虑灰度相似性
    %% 输入参数:R -- 模板半径
    %          sigma -- 标准差
        [X,Y] = meshgrid(-R:0.1:R);
        temp1 = 1/(2*pi*sigma^2);
        temp2 = -(X.^2 + Y.^2)/(2*sigma^2);
        G = temp1 * exp(temp2);
        
        G = G./sum(G(:));  % 模板的权重之和必须等于1。
    
        % 绘制模板图
        figure
        surf(X,Y,G);
        shading interp;
    end

    大小为15*15,标准差为2的二维高斯分布模板如图3所示

                                                                

                                                                                                       图3  大小为11*11的二维高斯分布

    使用大小为5*5,标准差为0.3的模板对含有弱小目标和云层的图像进行高斯模糊,如图4所示。

                                                                           

                                                                                   图4 大小为5*5,标准差为0.3的模板高斯模糊滤波结果

    1.3 高斯滤波总结

     高斯滤波只考虑了图像像素之间的空间相似性,即连续图像中,越靠近的点关系越密切,越远离的点关系越疏远。

     二、双边滤波

    1. 双边滤波的原理 

    参考:https://blog.csdn.net/Chaolei3/article/details/88579377

           双边滤波是一种非线性的方法,与高斯滤波相比,双边滤波不仅考虑了图像的空间相似性,也考虑了其灰度相似性,可以达到“保边去噪”的目的。

           双边滤波包含两部分:空域矩阵与值域矩阵,空域矩阵可类比高斯滤波,用于模糊去噪;值域矩阵根据灰度相似性得到,用来保护边缘。

           空域矩阵计算公式(4),值域矩阵计算公式(5)

                                                                               d(i,j,k,l)=e^\frac{ -(i-k)^{2}+(j-l)^{2}}{ 2\sigma_{d}^{2}}              …………(4)

                                                                               r(i,j,k,l)=e^\frac{ -||f(k,l)-f(i,j)||^{2}}{ 2\sigma_r^{2}}              …………(5)

           公式说明:定义(i, j)为中心点坐标,(k, l)为以点(i, j)为中心的邻域内任意一点。

           公式(4)(5)相乘即为双边滤波权重矩阵计算公式(6)

                                                                                w(i,j,k,l)=e^{\frac{ -(i-k)^{2}+(j-l)^2}{ 2\sigma_{d}^{2}}+\frac{ -||f(k,l)-f(i,j)||^{2}}{2\sigma_r^{2}}}      …………(6)

            最后,计算加权平均值作为中心点坐标滤波后的值

                                                                                g(i,j)=\frac{ \sum_{(k,l)\in{S}}f(i,j)w(i,j,k,l)}{ \sum_{(k,l)\in{S}}w(i,j,k,l)}     ………… (7)

    2. 双边滤波是如何实现“保边去噪”的?

          参考:https://blog.csdn.net/Jfuck/article/details/8932978?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2.control

          由公式(4),空间域权重矩阵的权重分布仍然是“钟形”,即距中心点越近,所占权重越大;

          由公式(5)(6),已知y = e^{-x}是过(0,1)点的减函数,即灰度差值越大,权重越小,平滑效果越差,反之,灰度差值越小,权重越大,平滑效果越好。所以,当中心点位于边缘处时,灰度差值大,空间域平滑效果削弱,边缘被保留;当邻域灰度值接近中心点时,灰度差值接近0,值域权重接近1,此时滤波效果取决于空间域权重矩阵,与高斯滤波效果一致。

         公式(7)的含义:滤波后中心点的值 = 权重矩阵 .* 原始图像 (且保证权重之和为1,归一化处理)(参照滤波原理)

                                       

                                                                                                      图5  双边滤波“保边去噪”原理图

    3. MATLAB实现双边滤波

    function b = BF_Filter(img,r,sigma_d,sigma_r)
    %% 功能说明:双边滤波,用于计算双边滤波后的图像
    %          双边滤波是一种非线性方法,同时考虑图像的空域信息和灰度相似性。
    %          通过空域矩阵和值域矩阵形成新的权重矩阵,其中,空域矩阵用来模糊去噪,值域矩阵用来保护边缘。
    %% 输入参数:img -- 待滤波图像
    %          r -- 模板半径,e.g. 3*3模版的半径为1
    %          sigma_d -- 空域矩阵标准差
    %          sigma_r -- 值域矩阵标准差
        
        % 判断是否为灰度图像
        if(size(img,3)>1)
            img = rgb2gray(img);
        end
        [x,y] = meshgrid(-r:r);
        
        % 空域权重矩阵 size = (2r+1)*(2r+1)
        w_spacial = exp(-(x.^2 + y.^2)/(2*sigma_d.^2));
    
        [m,n] = size(img);
        img = double(img);
        
        % 扩展图像,size = (m+2r)*(n+2r)
        f_temp = padarray(img,[r r],'symmetric');
        
        % 滑动窗口并滤波
        b = zeros(m,n); % 滤波后图像
        for i = r+1:m+r
            for j = r+1:n+r
                temp = f_temp(i-r:i+r,j-r:j+r);
                w_value = exp(-(temp - img(i-r,j-r)).^2/(2*sigma_r^2));  % size = (2r+1)*(2r+1)
                w = w_spacial .* w_value;
                s = temp.*w;
                b(i-r,j-r) = sum(s(:))/sum(w(:));  
            end
        end
    end

     4. 关于sigma值的选取

    参考:https://blog.csdn.net/Jfuck/article/details/8932978?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2.control

    4.1 空间域sigma \sigma_d 选取

    核大小通常为(6\multi\sigma_d+1),即r=6\sigma_d

    因为距离中心点(3\multi\sigma_d+1)大小之外的系数与中点的系数值比较小,可以认为此之外的点与中心点几乎没有联系,权重系数可看作0.

    4.2 值域sigma \sigma_r 选取

                                                     

                                                                                          图6   y=e^{-x}图像

    \sigma_r=255,灰度差值范围为[0,255]时,x 的取值范围 x\leqslant 1,值域范围为:[0.3679,1];

    \sigma_r=122.5,灰度差值范围为[0,255]时,x 的取值范围 x\leqslant 4,值域范围为:[0.01832,1];

    所以,sigma越大,权重值域范围越小,此时即使邻域灰度值与中心点灰度值之差较大,其对应权重也会很大,这与双边滤波“保边”的初衷相违背;sigma越小,权重值域范围越大,此时当邻域灰度值域中心点灰度值之差较大时,其对应权重越小,可以削弱“平滑”,达到“保边”效果。

    综上,sigma越大,边缘越模糊,sigma-->∞时,x-->0,权重-->1,与高斯模板相乘后可认为等效于高斯滤波;

                sigma越小,边缘越清晰,sigma-->0时,x-->∞,权重-->0,与高斯模板相乘后可认为系数皆相等,等效于源图像。

    三、双边滤波与高斯滤波结果对照

    3.1 仿真图像对照

    生成含明显边缘的图像,如图7所示。

                                                                                         

                                                                                                                 图7  仿真图像

    img_B = zeros(250,250);
    img_B(:,40:50) = 1;
    img_B(:,180:200) = 1;
    img_B(100:105,:) = 1;
    imshow(img_B)

    高斯滤波与双边滤波结果如图8所示,显然,双边滤波可以更好地保留图像的边缘信息。

                                                                        

                                                                                                   图8  双边滤波与高斯滤波仿真图像对比结果

    %% 高斯滤波
    r = 7;
    sigma_d = 1;
    G = Gaussian(r, sigma_d);
    g = imfilter(img_B, G, 'symmetric');
    %% 双边滤波
    sigma_r = 3;
    b = BF_Filter(img_B,r,sigma_d,sigma_r);
    figure
    subplot(1,2,1)
    imshow(b);title([num2str(2*r+1),'*',num2str(2*r+1),'双边滤波结果','\sigma_d=1 ,',' \sigma_r=3']);
    subplot(1,2,2)
    imshow(g);title([num2str(2*r+1),'*',num2str(2*r+1),'高斯滤波结果','\sigma_d=1']);

    3.2 真实图像对照

    从结果来看,对于含有云层等结构背景及弱小目标的图像,与高斯滤波相比,双边滤波可以很好地保留图像的边缘(结构)信息。

                                                                                              

                                                                                                              图9  原真实图像

                                                                    

                                                                                            图10  双边滤波与高斯滤波真实图像对比结果

    img = imread('cloud.bmp');
    if(size(img,3)>1)
        img = rgb2gray(img);
    end
    r = 7;
    sigma_d = 0.5;
    G = Gaussian(r, sigma_d);
    img_g = imfilter(img, G, 'symmetric');
    
    sigma_r = 3;
    img_b = BF_Filter(img,r,sigma_d,sigma_r);
    subplot(1,3,1);
    imshow(img);title('原图');
    subplot(1,3,2)
    imshow(img_g,[]);title('高斯滤波结果');
    subplot(1,3,3);
    imshow(img_b,[]);title('双边滤波结果');

    3.3 总结

    结合弱小目标检测的课题目标,双边滤波适合预测含有丰富边缘(结构)信息的背景预测,通过实验选择合适的sigma值,对背景进行预测,原图-预测背景图=目标图(STI),然后从STI图中检测目标,下一步需要进行深入探究。

    展开全文
  • 基于双边滤波+retinex理论的图像中增强,增强图像细节
  • 高斯滤波双边滤波,高斯滤波双边滤波程序应用示例及区别,matlab源码
  • 一、图像处理之均值滤波,高斯滤波(高斯模糊),中值滤波,双边滤波 滤波器介绍 滤波器作为图像处理课程的重要内容,大致可分为两类,空域滤波器和频率域滤波器。本文主要介绍常用的四种滤波器:中值滤波器、均值...

    一、图像处理之均值滤波,高斯滤波(高斯模糊),中值滤波,双边滤波

    1. 滤波器介绍
      滤波器作为图像处理课程的重要内容,大致可分为两类,空域滤波器和频率域滤波器。本文主要介绍常用的四种滤波器:中值滤波器、均值滤波器、高斯滤波器、双边滤波器,并基于opencv做出实现。空域的滤波器一般可以通过模板对原图像进行卷积。

    注意:空域滤波器和频率域滤波器对比

    1)空间域指图像本身,空域变换直接对图像中的像素进行操作。

    2)图像变换是将图像从空间域变换到某变换域(如 傅立叶变换中的频率域)的数学变换,在变换域 中进行处理,然后通过反变换把处理结果返回到空间域。

    3)图像在空域上具有很强的相关性,借助于正交变 换可使在空域的复杂计算转换到频域后得到简化

    4)借助于频域特性的分析,将更有利于获得图像的 各种特性和进行特殊处理

    2、理论知识:
    图像的空域滤波无非两种情况,线性滤波和非线性滤波。

      滤波的意思就是对原图像的每个像素周围一定范围内的像素进行运算,运算的范围就称为掩膜。而运算就分两种了,如果运算只是对各像素灰度值进行简单处理(如乘一个权值)最后求和,就称为线性滤波;而如果对像素灰度值的运算比较复杂,而不是最后求和的简单运算,则是非线性滤波;如求一个像素周围3x3范围内最大值、最小值、中值、均值等操作都不是简单的加权,都属于非线性滤波。
    

    常见的线性滤波有:均值滤波、高斯滤波、盒子滤波、拉普拉斯滤波等等,通常线性滤波器之间只是模版系数不同。

    非线性滤波利用原始图像跟模版之间的一种逻辑关系得到结果,如最值滤波器,中值滤波器和双边滤波器等。

    1、线性滤波

    线性滤波器表达公式:,其中均值滤波器和高斯滤波器属于线性滤波器,首先看这两种滤波器

    均值滤波器:

    模板:

    从待处理图像首元素开始用模板对原始图像进行卷积,均值滤波直观地理解就是用相邻元素灰度值的平均值代替该元素的灰度值。

    高斯滤波器:

    高斯滤波一般针对的是高斯噪声,能够很好的抑制图像输入时随机引入的噪声,将像素点跟邻域像素看作是一种高斯分布的关系,它的操作是将图像和一个高斯核进行卷积操作:

    模板:通过高斯内核函数产生的

    高斯内核函数:

    例如3*3的高斯内核模板:

    中值滤波:同样是空间域的滤波,主题思想是取相邻像素的点,然后对相邻像素的点进行排序,取中点的灰度值作为该像素点的灰度值。

    统计排序滤波器,对椒盐噪声有很好的抑制

    详细请参考:数字图像处理之椒盐噪声和中值滤波
    中值滤波将窗口函数里面的所有像素进行排序取得中位数来代表该窗口中心的像素值,对椒盐噪声和脉冲噪声的抑制效果特别好,同时又能保留边缘细节,用公式表示是:

    双边滤波(Bilateral filter)也是一种非线性的滤波方法,是结合图像的空间邻近度和像素值相似度的一种折衷处理,同时考虑空域信息和灰度相似性,达到保边去噪的目的,具有简单,非迭代、局部的特点,它比高斯滤波多了一个高斯方差σd,用公式表示就是:

    w(x,y)为加权系数,取决于定义域核和值域核的乘积。

    注意:

    1)均值模糊无法克服边缘像素信息丢失的缺陷,原因是均值滤波是基于平均权重的。

    2)高斯模糊部分克服了该缺陷,但无法完全避免,因为没有考虑像素值的不同。

    3)高斯双边模糊-是边缘保留额滤波方法,避免了边缘信息丢失,保留了图像轮廓不变。

    1. 实验

    结论:从滤波的结果可以看出各种滤波算法对图像的作用非常不同,有些变化非常大,有些甚至跟原图一样。在实际应用时,应根据噪声的特点、期望的图像和边缘特征等来选择合适的滤波器,这样才能发挥图像滤波的最大优点。

    1. C++实现
      4.1均值滤波

    static void exchange(int& a, int& b)
    {
    int t = 0;
    t = a;
    a = b;
    b = t;
    }

    static void bubble_sort(int* K, int lenth)
    {
    for (int i = 0; i < lenth; i++)
    for (int j = i + 1; j < lenth; j++)
    {
    if (K[i]>K[j])
    exchange(K[i], K[j]);
    }
    }
    ///产生二维的高斯内核
    static cv::Mat generate_gassian_kernel(double u, double sigma, cv::Size size)
    {
    int width = size.width;
    int height = size.height;
    cv::Mat gassian_kernel(cv::Size(width, height), CV_64FC1);
    double sum = 0;
    double sum_sum = 0;
    for (int i = 0; i < width; i++)
    for (int j = 0; j < height; j++)
    {
    sum = 1.0 / 2.0 / CV_PI / sigma / sigma * exp(-1.0 * ((i - width / 2)(i - width / 2) + (j - width / 2)(j - width / 2)) / 2.0 / sigma / sigma);
    sum_sum += sum;
    gassian_kernel.ptr(i)[j] = sum;
    }
    for (int i = 0; i < width; i++)
    for (int j = 0; j < height; j++)
    {
    gassian_kernel.ptr(i)[j] /= sum_sum;
    }
    return gassian_kernel;
    }
    ///均值滤波
    void lmt_main_blur(cv::Mat& img_in, cv::Mat& img_out, int kernel_size)
    {
    img_out = img_in.clone();
    cv::Mat mat1;
    cv::copyMakeBorder(img_in, mat1, kernel_size, kernel_size, kernel_size, kernel_size, cv::BORDER_REPLICATE);

    int cols = mat1.cols;
    int rows = mat1.rows;
    int channels = img_out.channels();
    const uchar* const pt = mat1.ptr<uchar>(0);
    uchar* pt_out = img_out.ptr<uchar>(0);
    
    for (int i = kernel_size; i < rows - kernel_size; i++)
    {
        for (int j = kernel_size; j < cols - kernel_size; j++)
        {
            if (channels == 1)
            {
                long long int sum_pixel = 0;
                for (int m = -1 * kernel_size; m < kernel_size; m++)
                    for (int n = -1 * kernel_size; n < kernel_size; n++)
                    {
                        sum_pixel += pt[(i + m)*cols + (j + n)];
                    }
                img_out.ptr<uchar>(i - kernel_size)[j - kernel_size] = (double)sum_pixel / (kernel_size*kernel_size * 4);
            }
            else if (channels == 3)
            {
                long long int sum_pixel = 0;
                long long int sum_pixel1 = 0;
                long long int sum_pixel2 = 0;
                for (int m = -1 * kernel_size; m < kernel_size; m++)
                    for (int n = -1 * kernel_size; n < kernel_size; n++)
                    {
                        sum_pixel += pt[((i + m)*cols + (j + n))*channels + 0];
                        sum_pixel1 += pt[((i + m)*cols + (j + n))*channels + 1];
                        sum_pixel2 += pt[((i + m)*cols + (j + n))*channels + 2];
                    }
                img_out.ptr<uchar>(i - kernel_size)[(j - kernel_size)*channels + 0] = (double)sum_pixel / (double)(kernel_size*kernel_size * 4);
                img_out.ptr<uchar>(i - kernel_size)[(j - kernel_size)*channels + 1] = (double)sum_pixel1 / (double)(kernel_size*kernel_size * 4);
                img_out.ptr<uchar>(i - kernel_size)[(j - kernel_size)*channels + 2] = (double)sum_pixel2 / (double)(kernel_size*kernel_size * 4);
            }
        }
    }
    

    }
    ///中值滤波
    void lmt_median_blur(cv::Mat& img_in, cv::Mat& img_out, int kernel_size)
    {
    img_out = img_in.clone();
    cv::Mat mat1;
    cv::copyMakeBorder(img_in, mat1, kernel_size, kernel_size, kernel_size, kernel_size, cv::BORDER_REPLICATE);

    int cols = mat1.cols;
    int rows = mat1.rows;
    int channels = img_out.channels();
    
    cv::Mat mat[3];
    cv::Mat mat_out[3];
    cv::split(mat1, mat);
    cv::split(img_out, mat_out);
    for (int k = 0; k < 3; k++)
    {
        const uchar* const pt = mat[k].ptr<uchar>(0);
        uchar* pt_out = mat_out[k].ptr<uchar>(0);
        for (int i = kernel_size; i < rows - kernel_size; i++)
        {
            for (int j = kernel_size; j < cols - kernel_size; j++)
            {
                long long int sum_pixel = 0;
                int* K = new int[kernel_size*kernel_size * 4];
                int ker_num = 0;
                for (int m = -1 * kernel_size; m < kernel_size; m++)
                    for (int n = -1 * kernel_size; n < kernel_size; n++)
                    {
                        K[ker_num] = pt[(i + m)*cols + (j + n)];
                        ker_num++;
                    }
                bubble_sort(K, ker_num);
                mat_out[k].ptr<uchar>(i - kernel_size)[j - kernel_size] = K[ker_num / 2];
            }
        }
    }
    cv::merge(mat_out, 3, img_out);
    

    }
    ///高斯滤波
    void lmt_gaussian_blur(cv::Mat& img_src, cv::Mat& img_dst, cv::Size kernel_size)
    {
    img_dst = cv::Mat(cv::Size(img_src.cols, img_src.rows), img_src.type());
    int cols = img_src.cols;
    int rows = img_src.rows;
    int channels = img_src.channels();
    cv::Mat gassian_kernel = generate_gassian_kernel(0, 1, kernel_size);
    int width = kernel_size.width / 2;
    int height = kernel_size.height / 2;
    for (int i = height; i < rows - height; i++)
    {
    for (int j = width; j < cols - width; j++)
    {
    for (int k = 0; k < channels; k++)
    {
    double sum = 0.0;
    for (int m = -height; m <= height; m++)
    {
    for (int n = -width; n <= width; n++)
    {
    sum += (double)(img_src.ptr(i + m)[(j + n)channels + k]) * gassian_kernel.ptr(height + m)[width + n];
    }
    }
    if (sum > 255.0)
    sum = 255;
    if (sum < 0.0)
    sum = 0;
    img_dst.ptr(i)[j
    channels + k] = (uchar)sum;
    }
    }
    }

    }
    ///双边滤波
    void lmt_bilateral_filter(cv::Mat& img_in, cv::Mat& img_out, const int r, double sigma_d, double sigma_r)
    {
    int i, j, m, n, k;
    int nx = img_in.cols, ny = img_in.rows, m_nChannels = img_in.channels();
    const int w_filter = 2 * r + 1; // 滤波器边长

    double gaussian_d_coeff = -0.5 / (sigma_d * sigma_d);
    double gaussian_r_coeff = -0.5 / (sigma_r * sigma_r);
    double  **d_metrix = new double *[w_filter];
    for (int i = 0; i < w_filter; ++i)
        d_metrix[i] = new double[w_filter];
    
    double r_metrix[256];  // similarity weight  
    img_out = cv::Mat(img_in.size(),img_in.type());
    uchar* m_imgData = img_in.ptr<uchar>(0);
    uchar* m_img_outData = img_out.ptr<uchar>(0);
    // copy the original image  
    double* img_tmp = new double[m_nChannels * nx * ny];
    for (i = 0; i < ny; i++)
        for (j = 0; j < nx; j++)
            for (k = 0; k < m_nChannels; k++)
            {
                img_tmp[i * m_nChannels * nx + m_nChannels * j + k] = m_imgData[i * m_nChannels * nx + m_nChannels * j + k];
            }
    
    // compute spatial weight  
    for (i = -r; i <= r; i++)
        for (j = -r; j <= r; j++)
        {
            int x = j + r;
            int y = i + r;
    
            d_metrix[y][x] = exp((i * i + j * j) * gaussian_d_coeff);
        }
    
    // compute similarity weight  
    for (i = 0; i < 256; i++)
    {
        r_metrix[i] = exp(i * i * gaussian_r_coeff);
    }
    
    // bilateral filter  
    for (i = 0; i < ny; i++)
        for (j = 0; j < nx; j++)
        {
            for (k = 0; k < m_nChannels; k++)
            {
                double weight_sum, pixcel_sum;
                weight_sum = pixcel_sum = 0.0;
    
                for (m = -r; m <= r; m++)
                    for (n = -r; n <= r; n++)
                    {
                        if (m*m + n*n > r*r) continue;
    
                        int x_tmp = j + n;
                        int y_tmp = i + m;
    
                        x_tmp = x_tmp < 0 ? 0 : x_tmp;
                        x_tmp = x_tmp > nx - 1 ? nx - 1 : x_tmp;   // 边界处理,replicate  
                        y_tmp = y_tmp < 0 ? 0 : y_tmp;
                        y_tmp = y_tmp > ny - 1 ? ny - 1 : y_tmp;
    
                        int pixcel_dif = (int)abs(img_tmp[y_tmp * m_nChannels * nx + m_nChannels * x_tmp + k] - img_tmp[i * m_nChannels * nx + m_nChannels * j + k]);
                        double weight_tmp = d_metrix[m + r][n + r] * r_metrix[pixcel_dif];  // 复合权重  
    
                        pixcel_sum += img_tmp[y_tmp * m_nChannels * nx + m_nChannels * x_tmp + k] * weight_tmp;
                        weight_sum += weight_tmp;
                    }
    
                pixcel_sum = pixcel_sum / weight_sum;
                m_img_outData[i * m_nChannels * nx + m_nChannels * j + k] = (uchar)pixcel_sum;
    
            } // 一个通道  
    
        } // END ALL LOOP  
    for (i = 0; i < w_filter; i++)
        delete[] d_metrix[i];
    delete[] d_metrix;
    

    }

    1. Opencv API实现
      opencv相关函数简介:

    双边滤波函数:bilateralFilter(InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace,int borderType=BORDER_DEFAULT )

    src待滤波图像

    dst滤波后图像

    d滤波器半径

    sigmaColor滤波器值域的sigma

    sigmaSpace滤波器空间域的sigma

    borderType边缘填充方式 BORDER_REPLICATE BORDER_REFLECT BORDER_DEFAULT BORDER_REFLECT_101BORDER_TRANSPARENT BORDER_ISOLATED

    均值滤波函数:blur(InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), intborderType=BORDER_DEFAULT );

    src待滤波图像

    dst滤波后图像

    ksize 均值滤波器的大小

    Piont(-1,-1)指中心

    anchor均值滤波器的锚点也就是模板移动点

    borderType边缘填充方式 BORDER_REPLICATE BORDER_REFLECT BORDER_DEFAULT BORDER_REFLECT_101BORDER_TRANSPARENT BORDER_ISOLATED

    高斯滤波函数:GaussianBlur(InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0,int borderType=BORDER_DEFAULT );

    src待滤波图像

    dst滤波后图像

    ksize 高斯滤波器的大小Size(x,y),x和y必须是整数且是奇数。

    sigmaX 高斯滤波器的x方向的滤波器高斯sigma

    sigmaY 高斯滤波器的y方向的滤波器高斯sigma

    borderType边缘填充方式 BORDER_REPLICATE BORDER_REFLECT BORDER_DEFAULT BORDER_REFLECT_101BORDER_TRANSPARENT BORDER_ISOLATED

    中值滤波函数:medianBlur(InputArray src, OutputArray dst, int ksize );

    src待滤波图像
    
    dst滤波后图像
    
    ksize 中值滤波器的大小
    

    函数演示:

    void bilateral_filter_show(void)
    {
    cv::Mat mat1 = cv::imread(“F:\CVlibrary\obama.jpg”, CV_LOAD_IMAGE_GRAYSCALE); //灰度图加载进来,BGR->HSV 然后取H参数
    if (mat1.empty())
    return;
    cv::imshow(“原图像”, mat1);
    cv::Mat src = cv::imread(“F:\CVlibrary\obama.jpg”);
    cv::imshow(“原始彩色图像”, src);
    std::cout << "channel = " << mat1.channels() << std::endl;

    cv::Mat mat3;
    cv::bilateralFilter(src, mat3, 5, 50, 50,cv::BORDER_DEFAULT);
    cv::imshow("opencv给出的双边滤波器", mat3);
    cv::Mat mat4;
    cv::blur(src, mat4, cv::Size(3, 3));
    cv::imshow("均值滤波", mat4);
    cv::Mat mat5;
    cv::GaussianBlur(src, mat5, cv::Size(5, 5), 1,1);
    cv::imshow("高斯滤波器", mat5);
    cv::Mat mat6;
    cv::medianBlur(src, mat6, 3);
    cv::imshow("中值滤波", mat6); 
    cv::Mat mat7;
    lmt_gaussian_blur(src, mat7, cv::Size(5, 5));
    cv::imshow("my gaussian image",mat7);
    
    cv::waitKey(0);
    

    }

    高斯、中值、均值、双边滤波的效果
    #include “cv.h”
    #include “highgui.h”
    #include

    using namespace std;
    using namespace cv;

    int main(int argc, char* argv[])
    {
    Mat src = imread(“misaka.jpg”);
    Mat dst;

        //参数是按顺序写的
    
        //高斯滤波
        //src:输入图像
        //dst:输出图像
        //Size(5,5)模板大小,为奇数
        //x方向方差
        //Y方向方差
        GaussianBlur(src,dst,Size(5,5),0,0);
        imwrite("gauss.jpg",dst);
        
        //中值滤波
        //src:输入图像
        //dst::输出图像
        //模板宽度,为奇数
        medianBlur(src,dst,3);
        imwrite("med.jpg",dst);
        
        //均值滤波
        //src:输入图像
        //dst:输出图像
        //模板大小
        //Point(-1,-1):被平滑点位置,为负值取核中心
        blur(src,dst,Size(3,3),Point(-1,-1));
        imwrite("mean.jpg",dst);
    
        //双边滤波
        //src:输入图像
        //dst:输入图像
        //滤波模板半径
        //颜色空间标准差
        //坐标空间标准差
        bilateralFilter(src,dst,5,10.0,2.0);//这里滤波没什么效果,不明白
        imwrite("bil.jpg",dst);
    
        waitKey();
    
        return 0;
    

    ————————————————
    版权声明:本文为CSDN博主「csdnforyou」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/csdnforyou/article/details/82216301

    展开全文
  • 高斯滤波与双边滤波

    千次阅读 2019-09-23 17:42:59
    双边滤波(Bilateral filter)是一种非线性的滤波方法,是结合图像的空间邻近度和像素值相似度的一种折衷处理,同时考虑空域信息和灰度相似性,达到保边去噪的目的。普通的高斯滤波会将图像的边缘模糊掉,而双边...
  • 高斯滤波demo二. 非线性滤波2.1. 中值滤波demo2.2. 双边滤波demo结构体参考 一. 线性滤波 1.1. 方框滤波 方框滤波是所有滤波器中最简单的一种滤波方式。每一个输出像素的是内核邻域像素值的平均值得到。 通用的...
  • 线性滤波: 方框滤波、均值滤波、高斯滤波 非线性滤波: 中值滤波、双边滤波图像 图像滤波要求: 不能损害图像的轮廓和边缘, 图像清晰视觉效果更好 (1)方框滤波 它是滤波器中最简单的,是通过...
  • 双边滤波器的好处是可以做边缘保存(edge preserving),一般过去用的维纳滤波或者高斯滤波去降噪,都会较明显地模糊边缘,对于高频细节的保护效果并不明显。双边滤波器顾名思义比高斯滤波多了一个高斯方差sigma-d...
  • 高斯滤波、均值滤波、中值滤波,双边滤波滤波进行去噪处理,这四种滤波是在添加高斯噪声的基础上,分别得到信噪比,通过对比信噪比值,最终得到那种方式处理效果最好。并且源码可以在不同的卷积核滤波器大小、添加...
  • 图像平滑 图像平滑是一种区域增强...图像平滑有均值滤波、中值滤波、高斯滤波和高斯双边滤波等。 1.均值滤波: 用其像素点周围像素的平均值代替元像素值,在滤除噪声的同时也会滤掉图像的边缘信息。 均值滤波A...
  • 本文主要介绍常用的四种滤波器:中值滤波器、均值滤波器、高斯滤波器、双边滤波器,并基于opencv做出实现。空域的滤波器一般可以通过模板对原图像进行卷积。 注意:空域滤波器和频率域滤波器对比 1)空间域指图像...
  • 图像处理——高斯滤波与双边滤波高斯滤波References 高斯滤波 滤波是对输入信号进行卷积处理的一个过程,写成一个表达式的形式是这样的:滤波 = 卷积( 输入信号 ,卷积模板 ),卷积模板/掩膜 的不同决定了不同的...
  • 实现一个双边滤波(Bilateral Filter),并与高斯滤波比较保持图像边缘的效果,cv::bilateralFilter比较效果和速度。 双边滤波:计算权重时同时考虑空间位置和像素颜色之差
  • 目录线性滤波方框滤波均值滤波高斯滤波非线性滤波中值滤波双边滤波 **平滑处理:**也叫做模糊处理,通常用来减少图像上的噪点或者失真。 **图像滤波:**在尽量保留图像细节特征的条件下对目标图像的噪声进行抑制。**...
  • 图像降噪算法——中值滤波/均值滤波/高斯滤波/双边滤波 图像降噪算法——中值滤波/均值滤波/高斯滤波/双边滤波 1. 基本原理 2. C++代码实现 3. 结论 图像降噪算法——中值滤波/均值滤波/高斯滤波/双边滤波 空间域...
  • OpenCV python 高斯滤波与双边滤波 原图片[img_src.jpg] import cv2 import numpy as np def main(): # 1.创建原图片 img_src = np.zeros((500, 500), dtype=np.uint8) img_src[:, 250:] = 255 # 2.执行...
  • 相关图像处理概念介绍 “平滑处理“(smoothing)也称“模糊处理”(bluring),是一项简单且使用频率很高的图像处理方法。平滑处理的用途有很多,最常见的是用来减少图像上的噪点或者...而高斯滤波是指用高斯函数作...
  • 基于OpenCV+Python的均值滤波,高斯滤波,中值滤波,双边滤波 https://blog.csdn.net/qq_42860591/article/details/106630231?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_utm_term-2&spm=1001....
  • 图像卷积滤波的基本原理: 一个二维的滤波器矩阵(也就是卷积核)和一个要处理的二维图像;对于图像的每一个像素点,计算它的邻域像素和滤波器矩阵的对应元素的乘积,然后加起来,作为该像素位置的值,这样就完成了...
  • 本文主要介绍常用的四种滤波器:中值滤波器、均值滤波器、高斯滤波器、双边滤波器,并基于opencv做出实现。空域的滤波器一般可以通过模板对原图像进行卷积进行,卷积的相关知识请自行学习。 理论知识: 线性滤波器...
  • 双边滤波器的Matlab实现,附例程。简单的实现双边滤波器,是博客的附加例程 基本原理 保留边界细节,模糊变化不明显的区域 我们知道高斯滤波器可以起到模糊图像的作用,而上述的过程是选择性地进行模糊,在这里是对...
  • 滤波算法主要包括均值滤波,高斯滤波,中值滤波和双边滤波。 每种算法都有自己的特点,建议从原理上了解每种算法的优缺点。上图给出简洁版的总结。 以下是代码: import numpy as np import cv2 import ...
  • 高斯滤波函数、双边滤波函数的MATLAB实现高斯滤波函数双边滤波函数 自己编写滤波函数,剖析滤波内部结构 高斯滤波函数 clc; clear; close all; Image=imread('lena.bmp'); sigma1=0.6; sigma2=10; r=3; % 高斯模板...
  • 一维信号分别经过高斯滤波双边滤波后,得到的曲线和原曲线之间的差异,图片如![图片说明](https://img-ask.csdn.net/upload/201512/17/1450320427_527179.jpg),下面蓝色的是滤波后滤波前的差值,matlab程序如何...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,845
精华内容 1,938
关键字:

双边滤波与高斯滤波