高斯滤波原理
 
在数字图像中的高斯噪声主要来源出现在采集期间。由于不良照明或高温引起的传感器噪声。如果一个噪声，它的幅度分布服从高斯分布，而它的功率谱密度又是均匀分布的，则称它为高斯白噪声。高斯滤波器是一种线性滤波器，能够有效的抑制噪声，平滑图像。其作用原理和均值滤波器类似，都是取滤波器窗口内的像素的均值作为输出。其窗口模板的系数和均值滤波器不同，均值滤波器的模板系数都是相同的为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，得到最终的卷积核（权重矩阵）。
 
 
通过上述步骤计算出高斯核，基于该高斯核便可进行高斯滤波操作。假设现有9个像素点，灰度值（0-255）如下图中第一个卷积核所示，计算图中中心点的滤波后的值。每个像素点乘以相对应的权重值，得到最终的分布值。将这9个像素的值相加得到的结果，就是中心位置图像滤波后的值。对所有点重复这个过程，就得到了高斯滤波后的图像。如果原图是彩色图片，可以对RGB三个通道分别做高斯滤波。
 
 
参考自：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
 

双边滤波速度不是特别快
 
 
 
python 双边滤波与高斯滤波
 
高斯滤波就是对整幅图像进行加权平均的过程。每个像素点的值，都由其本身和邻域内的其它像素值经过加权平均后得到。高斯滤波的详细操作是：用一个模板（或称卷积、掩模）扫描图像中的每个像素。用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。
 
cv2.imshow('src',newimg)
 cv2.imshow('dst',lbimg)
 cv2.waitKey()
 cv2.destroyAllWindows()
 
 
 
 
  
 
   
#高斯滤波
 
   
lbimg=cv2.GaussianBlur(newimg,(3,3),1.8)
 
   
 
    
   

  
 

本文详细介绍高斯滤波和双边滤波的原理并给出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），其中均值决定了曲线的中心点，决定了曲线的宽度，越大曲线越宽。
 
                                                                                                         …………（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
 
使用上述功能绘制不同值对应的曲线，代码如下：
 
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，显然，决定了曲线的宽度，越大曲线越宽，且图像关于x = avg（这里为0）对称。
 
                                           
 
                                                                                   图2  不同值对应的一维高斯分布
 
补充说明：之前做了min-max标准化，将不同sigma值对应的曲线的取值范围均映射在了[0,1]范围内，但现在发现这种做法忽略了sigma取值对曲线高度的影响。
 
（高斯分布的性质：曲线下方与x轴上方的面积之和为1）sigma的取值不仅决定了曲线的宽度，也决定了曲线的高度，sigma越大，曲线越宽越矮；sigma越小，曲线越窄越高。
 
 
 
1.2 二维高斯分布
 
将x = x,y分别代入公式（1）后，二者相乘即可得到二维高斯分布公式（2）：
 
                                                                                       …………（2）
 
这里令可得简化版二维高斯分布函数公式（3）：
 
                                                                                                        …………（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）
 
                                                                                         …………（4）
 
                                                                                         …………（5）
 
       公式说明：定义(i, j)为中心点坐标，(k, l)为以点(i, j)为中心的邻域内任意一点。
 
       公式（4）（5）相乘即为双边滤波权重矩阵计算公式（6）
 
                                                                                  …………（6）
 
        最后，计算加权平均值作为中心点坐标滤波后的值
 
                                                                                 ………… （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），已知是过（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  选取
 
核大小通常为，即
 
因为距离中心点大小之外的系数与中点的系数值比较小，可以认为此之外的点与中心点几乎没有联系，权重系数可看作0.
 
4.2 值域sigma  选取
 
                                                 
 
                                                                                      图6   图像
 
当，灰度差值范围为[0,255]时，x 的取值范围 ，值域范围为：[0.3679,1];
 
当，灰度差值范围为[0,255]时，x 的取值范围 ，值域范围为：[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图中检测目标，下一步需要进行深入探究。

一、图像处理之均值滤波，高斯滤波(高斯模糊)，中值滤波，双边滤波
 
滤波器介绍
 滤波器作为图像处理课程的重要内容，大致可分为两类，空域滤波器和频率域滤波器。本文主要介绍常用的四种滤波器：中值滤波器、均值滤波器、高斯滤波器、双边滤波器，并基于opencv做出实现。空域的滤波器一般可以通过模板对原图像进行卷积。
 
注意：空域滤波器和频率域滤波器对比
 
1）空间域指图像本身，空域变换直接对图像中的像素进行操作。
 
2）图像变换是将图像从空间域变换到某变换域（如 傅立叶变换中的频率域）的数学变换，在变换域 中进行处理，然后通过反变换把处理结果返回到空间域。
 
3）图像在空域上具有很强的相关性，借助于正交变 换可使在空域的复杂计算转换到频域后得到简化
 
4）借助于频域特性的分析，将更有利于获得图像的 各种特性和进行特殊处理
 
2、理论知识：
 图像的空域滤波无非两种情况，线性滤波和非线性滤波。
 
  滤波的意思就是对原图像的每个像素周围一定范围内的像素进行运算，运算的范围就称为掩膜。而运算就分两种了，如果运算只是对各像素灰度值进行简单处理（如乘一个权值）最后求和，就称为线性滤波；而如果对像素灰度值的运算比较复杂，而不是最后求和的简单运算，则是非线性滤波；如求一个像素周围3x3范围内最大值、最小值、中值、均值等操作都不是简单的加权，都属于非线性滤波。
 
常见的线性滤波有：均值滤波、高斯滤波、盒子滤波、拉普拉斯滤波等等，通常线性滤波器之间只是模版系数不同。
 
非线性滤波利用原始图像跟模版之间的一种逻辑关系得到结果，如最值滤波器，中值滤波器和双边滤波器等。
 
1、线性滤波
 
线性滤波器表达公式：，其中均值滤波器和高斯滤波器属于线性滤波器，首先看这两种滤波器
 
均值滤波器：
 
模板：
 
从待处理图像首元素开始用模板对原始图像进行卷积，均值滤波直观地理解就是用相邻元素灰度值的平均值代替该元素的灰度值。
 
高斯滤波器：
 
高斯滤波一般针对的是高斯噪声，能够很好的抑制图像输入时随机引入的噪声，将像素点跟邻域像素看作是一种高斯分布的关系，它的操作是将图像和一个高斯核进行卷积操作：
 
模板：通过高斯内核函数产生的
 
高斯内核函数：
 
例如3*3的高斯内核模板：
 
中值滤波：同样是空间域的滤波，主题思想是取相邻像素的点，然后对相邻像素的点进行排序，取中点的灰度值作为该像素点的灰度值。
 
统计排序滤波器，对椒盐噪声有很好的抑制
 
详细请参考：数字图像处理之椒盐噪声和中值滤波
 中值滤波将窗口函数里面的所有像素进行排序取得中位数来代表该窗口中心的像素值，对椒盐噪声和脉冲噪声的抑制效果特别好，同时又能保留边缘细节，用公式表示是：
 
双边滤波(Bilateral filter)也是一种非线性的滤波方法，是结合图像的空间邻近度和像素值相似度的一种折衷处理，同时考虑空域信息和灰度相似性，达到保边去噪的目的，具有简单，非迭代、局部的特点，它比高斯滤波多了一个高斯方差σd，用公式表示就是：
 
w(x,y)为加权系数，取决于定义域核和值域核的乘积。
 
注意：
 
1）均值模糊无法克服边缘像素信息丢失的缺陷，原因是均值滤波是基于平均权重的。
 
2）高斯模糊部分克服了该缺陷，但无法完全避免，因为没有考虑像素值的不同。
 
3）高斯双边模糊-是边缘保留额滤波方法，避免了边缘信息丢失，保留了图像轮廓不变。
 
实验
 
结论：从滤波的结果可以看出各种滤波算法对图像的作用非常不同，有些变化非常大，有些甚至跟原图一样。在实际应用时，应根据噪声的特点、期望的图像和边缘特征等来选择合适的滤波器，这样才能发挥图像滤波的最大优点。
 
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)[jchannels + 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;
 
}
 
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