【第二部分-图像处理】第3章 Opencv图像处理进阶-【1 图像处理A-滤波】（imgproc组件、feature2D组件）

1.1线性滤波

1.1.1理论与概念讲解

<1>关于平滑处理
“平滑处理“（smoothing）也称“模糊处理”（bluring），是一项简单且使用频率很高的图像处理方法。平滑处理的用途有很多，最常见的是用来减少图像上的噪点或者失真。在涉及到降低图像分辨率时，平滑处理是非常好用的方法。
<2>图像滤波与滤波器
首先我们看一下图像滤波的概念。图像滤波，即在尽量保留图像细节特征的条件下对目标图像的噪声进行抑制，是图像预处理中不可缺少的操作，其处理效果的好坏将直接影响到后续图像处理和分析的有效性和可靠性。
消除图像中的噪声成分叫作图像的平滑化或滤波操作。信号或图像的能量大部分集中在幅度谱的低频和中频段是很常见的，而在较高频段，感兴趣的信息经常被噪声淹没。因此一个能降低高频成分幅度的滤波器就能够减弱噪声的影响。
图像滤波的目的有两个：一是抽出对象的特征作为图像识别的特征模式；另一个是为适应图像处理的要求，消除图像数字化时所混入的噪声。
而对滤波处理的要求也有两条：一是不能损坏图像的轮廓及边缘等重要信息;二是使图像清晰视觉效果好。
平滑滤波是低频增强的空间域滤波技术。它的目的有两类：一类是模糊；另一类是消除噪音。（各种“两”，：））
空间域的平滑滤波一般采用简单平均法进行，就是求邻近像元点的平均亮度值。邻域的大小与平滑的效果直接相关，邻域越大平滑的效果越好，但邻域过大，平滑会使边缘信息损失的越大，从而使输出的图像变得模糊，因此需合理选择邻域的大小。
关于滤波器，一种形象的比喻法是：我们可以把滤波器想象成一个包含加权系数的窗口，当使用这个滤波器平滑处理图像时，就把这个窗口放到图像之上，透过这个窗口来看我们得到的图像。
滤波器的种类有很多， 在新版本的OpenCV中，提供了如下五种常用的图像平滑处理操作方法，且他们分别被封装在单独的函数中，使用起来非常方便：
方框滤波——boxblur函数
均值滤波（邻域平均滤波）——blur函数
高斯滤波——GaussianBlur函数
中值滤波——medianBlur函数
双边滤波——bilateralFilter函数
今天我们要讲解的是作为线性滤波的方框滤波，均值滤波和高斯滤波。两种非线性滤波操作——中值滤波和双边滤波。
<3>对线性滤波器的简介
线性滤波器：线性滤波器经常用于剔除输入信号中不想要的频率或者从许多频率中选择一个想要的频率。
几种常见的线性滤波器：
允许低频率通过的低通滤波器。
允许高频率通过的高通滤波器。
允许一定范围频率通过的带通滤波器。
阻止一定范围频率通过并且允许其它频率通过的带阻滤波器。
允许所有频率通过、仅仅改变相位关系的全通滤波器。
阻止一个狭窄频率范围通过的特殊带阻滤波器，陷波滤波器（Band-stop filter）。
<4>关于滤波和模糊
关于滤波和模糊，大家往往在初次接触的时候会弄混淆，“一会儿说滤波，一会儿又说模糊，什么玩意儿啊”。没关系，在这里，我们就来辨别一下，为大家扫清障碍。
我们上文已经提到过，滤波是将信号中特定波段频率滤除的操作，是抑制和防止干扰的一项重要措施。
为了方便说明，就拿我们经常用的高斯滤波来作例子吧。我们知道，滤波可分低通滤波和高通滤波两种。而高斯滤波是指用高斯函数作为滤波函数的滤波操作，至于是不是模糊，要看是高斯低通还是高斯高通，低通就是模糊，高通就是锐化。
高斯滤波是指用高斯函数作为滤波函数的滤波操作。
高斯模糊就是高斯低通滤波。
<5>邻域算子与线性邻域滤波
邻域算子（局部算子）是利用给定像素周围的像素值的决定此像素的最终输出值的一种算子。而线性邻域滤波是一种常用的邻域算子，像素的输出值取决于输入像素的加权和，具体过程如下图。
邻域算子除了用于局部色调调整以外，还可以用于图像滤波，实现图像的平滑和锐化，图像边缘增强或者图像噪声的去除。本篇文章，我们介绍的主角是线性邻域滤波算子，即用不同的权重去结合一个小邻域内的像素，来得到应有的处理效果。

图1
图注：邻域滤波（卷积）：左边图像与中间图像的卷积产生右边图像。目标图像中蓝色标记的像素是利用原图像中红色标记的像素计算得到的。
线性滤波处理的输出像素值g(i,j)是输入像素值f(i+k,j+l)的加权和 :
$$g(x,y)=\sum_{k,l} f(i+k,j+l)h(k,l)$$

其中的加权和为 ，我们称其为“核”，滤波器的加权系数，即滤波器的“滤波系数”。
上面的式子可以简单写作：

其中f表示输入像素值，h表示加权系数“核“，g表示输出像素值
在新版本的OpenCV中，提供了如下三种常用的线性滤波操作，他们分别被封装在单独的函数中，使用起来非常方便：
方框滤波——boxblur函数
均值滤波——blur函数
高斯滤波——GaussianBlur函数
<6>方框滤波（box Filter）
方框滤波（box Filter）被封装在一个名为boxblur的函数中，即boxblur函数的作用是使用方框滤波器（box filter）来模糊一张图片，从src输入，从dst输出。

C++: void boxFilter(InputArray src,
                    OutputArray dst, 
                    int ddepth, 
                    Size ksize, 
                    Point anchor=Point(-1,-1), 
                    boolnormalize=true, 
                    int borderType=BORDER_DEFAULT )  

【参数】
第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。该函数对通道是独立处理的，且可以处理任意通道数的图片，但需要注意，待处理的图片深度应该为CV_8U, CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。
第三个参数，int类型的ddepth，输出图像的深度，-1代表使用原图深度，即src.depth()。
第四个参数，Size类型（对Size类型稍后有讲解）的ksize，内核的大小。一般这样写Size( w,h )来表示内核的大小( 其中，w 为像素宽度， h为像素高度)。Size（3,3）就表示3x3的核大小，Size（5,5）就表示5x5的核大小
第五个参数，Point类型的anchor，表示锚点（即被平滑的那个点），注意他有默认值Point(-1,-1)。如果这个点坐标是负值的话，就表示取核的中心为锚点，所以默认值Point(-1,-1)表示这个锚点在核的中心。
第六个参数，bool类型的normalize，默认值为true，一个标识符，表示内核是否被其区域归一化（normalized）了。
第七个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。有默认值BORDER_DEFAULT，我们一般不去管它。
boxFilter()函数方框滤波所用的核为：

其中：
$$\alpha = \begin{cases} \frac{1}{ksize.width*ksize.height}, & \text{当normalize=true时} \\ 1, & \text{当normalize=false时} \end{cases}$$

其中f表示原图，h表示核，g表示目标图，当normalize=true的时候，方框滤波就变成了我们熟悉的均值滤波。也就是说，均值滤波是方框滤波归一化（normalized）后的特殊情况。其中，归一化就是把要处理的量都缩放到一个范围内,比如(0,1)，以便统一处理和直观量化。
而非归一化（Unnormalized）的方框滤波用于计算每个像素邻域内的积分特性，比如密集光流算法（dense optical flow algorithms）中用到的图像倒数的协方差矩阵（covariance matrices of image derivatives）
如果我们要在可变的窗口中计算像素总和，可以使用integral()函数。
<7>均值滤波
均值滤波，是最简单的一种滤波操作，输出图像的每一个像素是核窗口内输入图像对应像素的像素的平均值( 所有像素加权系数相等)，其实说白了它就是归一化后的方框滤波。
我们在下文进行源码剖析时会发现，blur函数内部中其实就是调用了一下boxFilter。下面开始讲均值滤波的内容吧。
1）均值滤波的理论简析
均值滤波是典型的线性滤波算法，主要方法为邻域平均法，即用一片图像区域的各个像素的均值来代替原图像中的各个像素值。一般需要在图像上对目标像素给出一个模板（内核），该模板包括了其周围的临近像素（比如以目标像素为中心的周围8（3x3-1）个像素，构成一个滤波模板，即去掉目标像素本身）。再用模板中的全体像素的平均值来代替原来像素值。即对待处理的当前像素点（x，y），选择一个模板，该模板由其近邻的若干像素组成，求模板中所有像素的均值，再把该均值赋予当前像素点（x，y），作为处理后图像在该点上的灰度个g（x，y），即个g（x，y）=1/m ∑f（x，y） ，其中m为该模板中包含当前像素在内的像素总个数。
2）均值滤波的缺陷
均值滤波本身存在着固有的缺陷，即它不能很好地保护图像细节，在图像去噪的同时也破坏了图像的细节部分，从而使图像变得模糊，不能很好地去除噪声点。
3）在OpenCV中使用均值滤波——blur函数
blur函数的作用是，对输入的图像src进行均值滤波后用dst输出。
blur函数文档中，给出的其核是这样的：

$$\alpha = \frac{1}{ksize.width*ksize.height} \begin{bmatrix} 1 & 1 & 1 &{\cdots} &1&1\\ 1 & 1 & 1 &{\cdots} &1&1\\ {\cdots} \\ 1 & 1 & 1 &{\cdots} &1&1 \end{bmatrix}$$

这个内核一看就明了，就是在求均值，即blur函数封装的就是均值滤波。

<8>高斯滤波

高斯滤波是一种线性平滑滤波，适用于消除高斯噪声，广泛应用于图像处理的减噪过程。通俗的讲，高斯滤波就是对整幅图像进行加权平均的过程，每一个像素点的值，都由其本身和邻域内的其他像素值经过加权平均后得到。高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。
大家常常说高斯滤波最有用的滤波操作，虽然它用起来，效率往往不是最高的。
高斯模糊技术生成的图像，其视觉效果就像是经过一个半透明屏幕在观察图像，这与镜头焦外成像效果散景以及普通照明阴影中的效果都明显不同。高斯平滑也用于计算机视觉算法中的预先处理阶段，以增强图像在不同比例大小下的图像效果（参见尺度空间表示以及尺度空间实现）。从数学的角度来看，图像的高斯模糊过程就是图像与正态分布做卷积。由于正态分布又叫作高斯分布，所以这项技术就叫作高斯模糊。
图像与圆形方框模糊做卷积将会生成更加精确的焦外成像效果。由于高斯函数的傅立叶变换是另外一个高斯函数，所以高斯模糊对于图像来说就是一个低通滤波操作。
高斯滤波器是一类根据高斯函数的形状来选择权值的线性平滑滤波器。高斯平滑滤波器对于抑制服从正态分布的噪声非常有效。一维零均值高斯函数为：

G(x)=exp(-x $^2$/(2sigma $^2$))

其中，高斯分布参数Sigma决定了高斯函数的宽度。对于图像处理来说，常用二维零均值离散高斯函数作平滑滤波器。
二维高斯函数为：

<9>卷积
在讲解了一些线性滤波后，在这里引入一个概念，那就是卷积，那么何为卷积呢，高度概括地说，卷积是在每一个图像块与某个算子（核）之间进行的运算。这里又引入另外一个概念-核。那什么又是核呢？核说白了就是一个固定大小的数值数组。该数组带有一个锚点 ，一般位于数组中央。一个特殊卷积所实现的功能是由其卷积核的形式决定的。这个核本质上是一个大小固定、由数值参数构成的数组，数组的参考点（anchor point，也叫锚点）通常位于数组的中心。

上面描述了一个以数组中心为参考点的3X3的卷积核，-4所在为锚点。若要计算图像上某个点的卷积值，则将卷积核的锚点定位到图像上的那个点，让核的其它元素覆盖图像中的相应的像素点。将图像上的点与卷积核对应相乘后再求和，并将这个结果放在图像上锚点的相对位置上。通过在图像上扫描卷积核，对图像的每个点重复此操作。

可以用以上公式来表示这个过程，其中定义图像为 $I(x,y)$ ，核为 $G(i,j)$，其中 $0<i<M_i-1$ 和 $0<j<M_j-1$ ，锚点位于相应核的 $(a_i,a_j)$坐标上。
kernel并不是中心点的镜像，如果需要一个正真的卷积，使用函数flip()并将中心点设置为(kernel.cols - anchor.x - 1, kernel.rows - anchor.y -1)。filter2D创建自定义线性滤波器，该函数在大核(11x11或更大)的情况下使用基于DFT的算法，而在小核情况下使用直接算法(使用createLinearFilter()检索得到)。
总结一下，假如你想得到图像的某个特定位置的卷积值，可用下列方法计算：
1.将核的锚点放在该特定位置的像素上，同时，核内的其他值与该像素邻域的各像素重合；
2.将核内各值与相应像素值相乘，并将乘积相加；
3.将所得结果放到与锚点对应的像素上；
4.对图像所有像素重复上述过程。

1.1.2 OpenCV源码分析

在这一部分中，笔者将带领大家领略OpenCV的开源魅力，对OpenCV中本篇文章里讲解到线性滤波函数——boxFilter，blur和GaussianBlur函数以及周边的涉及到的源码进行适当的剖析。这样，我们就可以对 OpenCV有一个更加深刻的理解，成为一个高端大气的OpenCV使用者。
<1>OpenCV中boxFilter函数源码解析

/*【boxFilter（）源代码】**************************************************************
 * @Version：OpenCV 3.0.0（Opnencv2和Opnencv3差别不大，Linux和PC的对应版本源码完全一样，均在对应的安装目录下）  
 * @源码路径：…\opencv\sources\modules\imgproc\src\smooth.cpp
 * @起始行数：1307行   
********************************************************************************/
void cv::boxFilter( InputArray _src, OutputArray _dst, int ddepth,
                Size ksize, Point anchor,
                bool normalize, int borderType )
{
    CV_OCL_RUN(_dst.isUMat(), ocl_boxFilter(_src, _dst, ddepth, ksize, anchor, borderType, normalize))

    Mat src = _src.getMat();//拷贝源图的形参Mat数据到临时变量
    int stype = src.type(), sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype); //定义int型临时变量，代表源图深度的sdepth，源图通道的引用cn  
//处理ddepth小于零的情况
    if( ddepth < 0 )
        ddepth = sdepth;
    _dst.create( src.size(), CV_MAKETYPE(ddepth, cn) ); //初始化目标图
    Mat dst = _dst.getMat();//拷贝目标图的形参Mat数据到临时变量，用于稍后的操作  
//处理 borderType不为 BORDER_CONSTANT 且normalize为真的情况
    if( borderType != BORDER_CONSTANT && normalize && (borderType & BORDER_ISOLATED) != 0 )
    {
        if( src.rows == 1 )
            ksize.height = 1;
        if( src.cols == 1 )
            ksize.width = 1;
}
//若之前有过HAVE_TEGRA_OPTIMIZATION优化选项的定义，则执行宏体中的tegra优化版函数并返回
#ifdef HAVE_TEGRA_OPTIMIZATION
    if ( tegra::useTegra() && tegra::box(src, dst, ksize, anchor, normalize, borderType) )
        return;
#endif

#if defined(HAVE_IPP)
    CV_IPP_CHECK()
    {
        int ippBorderType = borderType & ~BORDER_ISOLATED;
        Point ocvAnchor, ippAnchor;
        ocvAnchor.x = anchor.x < 0 ? ksize.width / 2 : anchor.x;
        ocvAnchor.y = anchor.y < 0 ? ksize.height / 2 : anchor.y;
        ippAnchor.x = ksize.width / 2 - (ksize.width % 2 == 0 ? 1 : 0);
        ippAnchor.y = ksize.height / 2 - (ksize.height % 2 == 0 ? 1 : 0);

        if (normalize && !src.isSubmatrix() && ddepth == sdepth &&
            (/*ippBorderType == BORDER_REPLICATE ||*/ /* returns ippStsStepErr: Step value is not valid */
             ippBorderType == BORDER_CONSTANT) && ocvAnchor == ippAnchor &&
             dst.cols != ksize.width && dst.rows != ksize.height) // returns ippStsMaskSizeErr: mask has an illegal value
        {
            Ipp32s bufSize = 0;
            IppiSize roiSize = { dst.cols, dst.rows }, maskSize = { ksize.width, ksize.height };

#define IPP_FILTER_BOX_BORDER(ippType, ippDataType, flavor) \
            do \
            { \
                if (ippiFilterBoxBorderGetBufferSize(roiSize, maskSize, ippDataType, cn, &bufSize) >= 0) \
                { \
                    Ipp8u * buffer = ippsMalloc_8u(bufSize); \
                    ippType borderValue[4] = { 0, 0, 0, 0 }; \
                    ippBorderType = ippBorderType == BORDER_CONSTANT ? ippBorderConst : ippBorderRepl; \
                    IppStatus status = ippiFilterBoxBorder_##flavor(src.ptr<ippType>(), (int)src.step, dst.ptr<ippType>(), \
                                                                    (int)dst.step, roiSize, maskSize, \
                                                                    (IppiBorderType)ippBorderType, borderValue, buffer); \
                    ippsFree(buffer); \
                    if (status >= 0) \
                    { \
                        CV_IMPL_ADD(CV_IMPL_IPP); \
                        return; \
                    } \
                } \
                setIppErrorStatus(); \
            } while ((void)0, 0)

            if (stype == CV_8UC1)
                IPP_FILTER_BOX_BORDER(Ipp8u, ipp8u, 8u_C1R);
            else if (stype == CV_8UC3)
                IPP_FILTER_BOX_BORDER(Ipp8u, ipp8u, 8u_C3R);
            else if (stype == CV_8UC4)
                IPP_FILTER_BOX_BORDER(Ipp8u, ipp8u, 8u_C4R);

            // Oct 2014: performance with BORDER_CONSTANT
            //else if (stype == CV_16UC1)
            //    IPP_FILTER_BOX_BORDER(Ipp16u, ipp16u, 16u_C1R);
            else if (stype == CV_16UC3)
                IPP_FILTER_BOX_BORDER(Ipp16u, ipp16u, 16u_C3R);
            else if (stype == CV_16UC4)
                IPP_FILTER_BOX_BORDER(Ipp16u, ipp16u, 16u_C4R);

            // Oct 2014: performance with BORDER_CONSTANT
            //else if (stype == CV_16SC1)
            //    IPP_FILTER_BOX_BORDER(Ipp16s, ipp16s, 16s_C1R);
            else if (stype == CV_16SC3)
                IPP_FILTER_BOX_BORDER(Ipp16s, ipp16s, 16s_C3R);
            else if (stype == CV_16SC4)
                IPP_FILTER_BOX_BORDER(Ipp16s, ipp16s, 16s_C4R);

            else if (stype == CV_32FC1)
                IPP_FILTER_BOX_BORDER(Ipp32f, ipp32f, 32f_C1R);
            else if (stype == CV_32FC3)
                IPP_FILTER_BOX_BORDER(Ipp32f, ipp32f, 32f_C3R);
            else if (stype == CV_32FC4)
                IPP_FILTER_BOX_BORDER(Ipp32f, ipp32f, 32f_C4R);
        }
#undef IPP_FILTER_BOX_BORDER
    }
#endif
//调用FilterEngine滤波引擎，正式开始滤波操作
    Ptr<FilterEngine> f = createBoxFilter( src.type(), dst.type(),
                        ksize, anchor, normalize, borderType );
    f->apply( src, dst );
}

其中的Ptr是用来动态分配的对象的智能指针模板类。可以发现，函数的内部代码思路是很清晰的，先拷贝源图的形参Mat数据到临时变量，定义一些临时变量，在处理ddepth小于零的情况，接着处理 borderType不为 BORDER_CONSTANT 且normalize为真的情况，最终调用FilterEngine滤波引擎创建一个BoxFilter，正式开始滤波操作。
这里的FilterEngine是OpenCV图像滤波功能的核心引擎，我们有必要详细剖析看其源代码。
<2>FilterEngine类解析——OpenCV图像滤波核心引擎
FilterEngine类是OpenCV关于图像滤波的主力军类，OpenCV图像滤波功能的核心引擎。各种滤波函数比如blur， GaussianBlur，到头来其实是就是在函数末尾处定义了一个Ptr类型的f，然后f->apply( src, dst )了一下而已。
这个类可以把几乎是所有的滤波操作施加到图像上。它包含了所有必要的中间缓存器。有很多和滤波相关的create系函数的返回值直接就是Ptr< FilterEngine >。比如
cv::createSeparableLinearFilter(),
cv::createLinearFilter(),cv::createGaussianFilter(), cv::createDerivFilter(),
cv::createBoxFilter() 和cv::createMorphologyFilter().，这里
给出其中一个函数的原型吧：

Ptr<FilterEngine>createLinearFilter(int srcType, 
                                    int dstType, 
                                    InputArray kernel, 
                                   Point_anchor=Point(-1,-1), 
                                   double delta=0, 
                                   int rowBorderType=BORDER_DEFAULT, 
                                   intcolumnBorderType=-1, 
                                   const Scalar& borderValue=Scalar() )  

上面我们提到过了，其中的Ptr是用来动态分配的对象的智能指针模板类，而上面的尖括号里面的模板参数就是FilterEngine。
使用FilterEngine类可以分块处理大量的图像，构建复杂的管线，其中就包含一些进行滤波阶段。如果我们需要使用预先定义好的的滤波操作，cv::filter2D(), cv::erode(),以及cv::dilate()，可以选择，他们不依赖于FilterEngine，自立自强，在自己函数体内部就实现了FilterEngine提供的功能。不像其他的诸如我们今天讲的blur系列函数，依赖于FilterEngine引擎。

<3>OpenCV中size类型剖析
size类型我们在前文【图像处理入门】已经具体讲过了，博主在这里给出其原型声明：

typedef Size_<int> Size2i;  
typedef Size2i Size;  

Size_ 是个模板类，在这里Size_表示其类体内部的模板所代表的类型为int。那这两句的意思，就是首先给已知的数据类型Size_起个新名字，叫Size2i。然后又给已知的数据类型Size2i起个新名字，叫Size。所以，连起来就是，Size_、Size2i、Size这三个类型名等价。
在这里，给大家一个示例，方便理解：
Size(5, 5)；//构造出的Size宽度和高度都为5，即XXX.width和XXX.height都为5
<4>OpenCV中blur函数源码剖析

/*【blur( )函数源代码】**************************************************************
 * @Version：OpenCV 3.0.0（Opnencv2和Opnencv3差别不大，Linux和PC的对应版本源码完全一样，均在对应的安装目录下）  
 * @源码路径：…\opencv\sources\modules\imgproc\src\smooth.cpp
 * @起始行数：1409行   
********************************************************************************/
void cv::blur( InputArray src, OutputArray dst,
           Size ksize, Point anchor, int borderType )
{
    //调用boxFilter函数进行处理  
    boxFilter( src, dst, -1, ksize, anchor, true, borderType );
}

可以看到在blur函数内部就是调用了一个boxFilter函数，且第六个参数为true，即我们上文所说的normalize=true，即均值滤波是均一化后的方框滤波。
<5>OpenCV中GaussianBlur函数源码剖析
最后，我们看一下OpenCV中GaussianBlur函数源代码：

/*【GaussianBlur ( )函数源代码】*******************************************************
 * @Version：OpenCV 3.0.0（Opnencv2和Opnencv3差别不大，Linux和PC的对应版本源码完全一样，均在对应的安装目录下）  
 * @源码路径：…\opencv\sources\modules\imgproc\src\smooth.cpp
 * @起始行数：1628行   
********************************************************************************/
void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
                   double sigma1, double sigma2,
                   int borderType )
{
    int type = _src.type();
    Size size = _src.size();
    _dst.create( size, type );
//处理边界选项不为BORDER_CONSTANT时的情况  
    if( borderType != BORDER_CONSTANT && (borderType & BORDER_ISOLATED) != 0 )
    {
        if( size.height == 1 )
            ksize.height = 1;
        if( size.width == 1 )
            ksize.width = 1;
    }
       //若ksize长宽都为1，将源图拷贝给目标图  
    if( ksize.width == 1 && ksize.height == 1 )
    {
        _src.copyTo(_dst);
        return;
    }

#ifdef HAVE_TEGRA_OPTIMIZATION
    Mat src = _src.getMat();//拷贝形参Mat数据到临时变量  
Mat dst = _dst.getMat();
//若之前有过HAVE_TEGRA_OPTIMIZATION优化选项的定义，则执行宏体中的tegra优化版函数并返回  
    if(sigma1 == 0 && sigma2 == 0 && tegra::useTegra() && tegra::gaussian(src, dst, ksize, borderType))
        return;
#endif

#if IPP_VERSION_X100 >= 801 && 0 // these functions are slower in IPP 8.1
    CV_IPP_CHECK()
    {
        int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);

        if ((depth == CV_8U || depth == CV_16U || depth == CV_16S || depth == CV_32F) && (cn == 1 || cn == 3) &&
                sigma1 == sigma2 && ksize.width == ksize.height && sigma1 != 0.0 )
        {
            IppiBorderType ippBorder = ippiGetBorderType(borderType);
            if (ippBorderConst == ippBorder || ippBorderRepl == ippBorder)
            {
                Mat src = _src.getMat(), dst = _dst.getMat();
                IppiSize roiSize = { src.cols, src.rows };
                IppDataType dataType = ippiGetDataType(depth);
                Ipp32s specSize = 0, bufferSize = 0;

                if (ippiFilterGaussianGetBufferSize(roiSize, (Ipp32u)ksize.width, dataType, cn, &specSize, &bufferSize) >= 0)
                {
                    IppFilterGaussianSpec * pSpec = (IppFilterGaussianSpec *)ippMalloc(specSize);
                    Ipp8u * pBuffer = (Ipp8u*)ippMalloc(bufferSize);

                    if (ippiFilterGaussianInit(roiSize, (Ipp32u)ksize.width, (Ipp32f)sigma1, ippBorder, dataType, 1, pSpec, pBuffer) >= 0)
                    {
#define IPP_FILTER_GAUSS(ippfavor, ippcn) \
        do \
        { \
            typedef Ipp##ippfavor ippType; \
            ippType borderValues[] = { 0, 0, 0 }; \
            IppStatus status = ippcn == 1 ? \
                ippiFilterGaussianBorder_##ippfavor##_C1R(src.ptr<ippType>(), (int)src.step, \
                    dst.ptr<ippType>(), (int)dst.step, roiSize, borderValues[0], pSpec, pBuffer) : \
                ippiFilterGaussianBorder_##ippfavor##_C3R(src.ptr<ippType>(), (int)src.step, \
                    dst.ptr<ippType>(), (int)dst.step, roiSize, borderValues, pSpec, pBuffer); \
            ippFree(pBuffer); \
            ippFree(pSpec); \
            if (status >= 0) \
            { \
                CV_IMPL_ADD(CV_IMPL_IPP); \
                return; \
            } \
        } while ((void)0, 0)

                        if (type == CV_8UC1)
                            IPP_FILTER_GAUSS(8u, 1);
                        else if (type == CV_8UC3)
                            IPP_FILTER_GAUSS(8u, 3);
                        else if (type == CV_16UC1)
                            IPP_FILTER_GAUSS(16u, 1);
                        else if (type == CV_16UC3)
                            IPP_FILTER_GAUSS(16u, 3);
                        else if (type == CV_16SC1)
                            IPP_FILTER_GAUSS(16s, 1);
                        else if (type == CV_16SC3)
                            IPP_FILTER_GAUSS(16s, 3);
                        else if (type == CV_32FC1)
                            IPP_FILTER_GAUSS(32f, 1);
                        else if (type == CV_32FC3)
                            IPP_FILTER_GAUSS(32f, 3);
#undef IPP_FILTER_GAUSS
                    }
                }
                setIppErrorStatus();
            }
        }
    }
#endif

Mat kx, ky;
// 调动高斯核，正式进行高斯滤波操作  
    createGaussianKernels(kx, ky, type, ksize, sigma1, sigma2);
    sepFilter2D(_src, _dst, CV_MAT_DEPTH(type), kx, ky, Point(-1,-1), 0, borderType );
}

<6>OpenCV中filter2D函数源码剖析
利用这个函数我们可以自定义滤波器的核，源码如下。

/*【filter2D ( )函数源代码】***********************************************************
 * @Version：OpenCV 3.0.0（Opnencv2和Opnencv3差别不大，Linux和PC的对应版本源码完全一样，均在对应的安装目录下）  
 * @源码路径：…\opencv\sources\modules\imgproc\src\filter.cpp
 * @起始行数：4559行   
********************************************************************************/
void cv::filter2D( InputArray _src, OutputArray _dst, int ddepth,
                   InputArray _kernel, Point anchor0,
                   double delta, int borderType )
{
    CV_OCL_RUN(_dst.isUMat() && _src.dims() <= 2,
               ocl_filter2D(_src, _dst, ddepth, _kernel, anchor0, delta, borderType))

    Mat src = _src.getMat(), kernel = _kernel.getMat();

    if( ddepth < 0 )
        ddepth = src.depth();

#if CV_SSE2
    int dft_filter_size = ((src.depth() == CV_8U && (ddepth == CV_8U || ddepth == CV_16S)) ||
        (src.depth() == CV_32F && ddepth == CV_32F)) && checkHardwareSupport(CV_CPU_SSE3)? 130 : 50;
#else
    int dft_filter_size = 50;
#endif

    _dst.create( src.size(), CV_MAKETYPE(ddepth, src.channels()) );
    Mat dst = _dst.getMat();
    Point anchor = normalizeAnchor(anchor0, kernel.size());

#if IPP_VERSION_X100 > 0 && !defined HAVE_IPP_ICV_ONLY
    CV_IPP_CHECK()
    {
        typedef IppStatus (CV_STDCALL * ippiFilterBorder)(const void * pSrc, int srcStep, void * pDst, int dstStep, IppiSize dstRoiSize,
                                                          IppiBorderType border, const void * borderValue,
                                                          const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer);

        int stype = src.type(), sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype),
                ktype = kernel.type(), kdepth = CV_MAT_DEPTH(ktype);
        bool isolated = (borderType & BORDER_ISOLATED) != 0;
        Point ippAnchor(kernel.cols >> 1, kernel.rows >> 1);
        int borderTypeNI = borderType & ~BORDER_ISOLATED;
        IppiBorderType ippBorderType = ippiGetBorderType(borderTypeNI);

        if (borderTypeNI == BORDER_CONSTANT || borderTypeNI == BORDER_REPLICATE)
        {
            ippiFilterBorder ippFunc =
                stype == CV_8UC1 ? (ippiFilterBorder)ippiFilterBorder_8u_C1R :
                stype == CV_8UC3 ? (ippiFilterBorder)ippiFilterBorder_8u_C3R :
                stype == CV_8UC4 ? (ippiFilterBorder)ippiFilterBorder_8u_C4R :
                stype == CV_16UC1 ? (ippiFilterBorder)ippiFilterBorder_16u_C1R :
                stype == CV_16UC3 ? (ippiFilterBorder)ippiFilterBorder_16u_C3R :
                stype == CV_16UC4 ? (ippiFilterBorder)ippiFilterBorder_16u_C4R :
                stype == CV_16SC1 ? (ippiFilterBorder)ippiFilterBorder_16s_C1R :
                stype == CV_16SC3 ? (ippiFilterBorder)ippiFilterBorder_16s_C3R :
                stype == CV_16SC4 ? (ippiFilterBorder)ippiFilterBorder_16s_C4R :
                stype == CV_32FC1 ? (ippiFilterBorder)ippiFilterBorder_32f_C1R :
                stype == CV_32FC3 ? (ippiFilterBorder)ippiFilterBorder_32f_C3R :
                stype == CV_32FC4 ? (ippiFilterBorder)ippiFilterBorder_32f_C4R : 0;

            if (sdepth == ddepth && (ktype == CV_16SC1 || ktype == CV_32FC1) &&
                    ippFunc && (int)ippBorderType >= 0 && (!src.isSubmatrix() || isolated) &&
                    std::fabs(delta - 0) < DBL_EPSILON && ippAnchor == anchor && dst.data != src.data)
            {
                IppiSize kernelSize = { kernel.cols, kernel.rows }, dstRoiSize = { dst.cols, dst.rows };
                IppDataType dataType = ippiGetDataType(ddepth), kernelType = ippiGetDataType(kdepth);
                Ipp32s specSize = 0, bufsize = 0;
                IppStatus status = (IppStatus)-1;

                if ((status = ippiFilterBorderGetSize(kernelSize, dstRoiSize, dataType, kernelType, cn, &specSize, &bufsize)) >= 0)
                {
                    IppiFilterBorderSpec * spec = (IppiFilterBorderSpec *)ippMalloc(specSize);
                    Ipp8u * buffer = ippsMalloc_8u(bufsize);
                    Ipp32f borderValue[4] = { 0, 0, 0, 0 };

                    Mat reversedKernel;
                    flip(kernel, reversedKernel, -1);

                    if ((kdepth == CV_32F && (status = ippiFilterBorderInit_32f((const Ipp32f *)reversedKernel.data, kernelSize,
                            dataType, cn, ippRndFinancial, spec)) >= 0 ) ||
                        (kdepth == CV_16S && (status = ippiFilterBorderInit_16s((const Ipp16s *)reversedKernel.data,
                            kernelSize, 0, dataType, cn, ippRndFinancial, spec)) >= 0))
                    {
                        status = ippFunc(src.data, (int)src.step, dst.data, (int)dst.step, dstRoiSize,
                                         ippBorderType, borderValue, spec, buffer);
                    }

                    ippsFree(buffer);
                    ippsFree(spec);
                }

                if (status >= 0)
                {
                    CV_IMPL_ADD(CV_IMPL_IPP);
                    return;
                }
                setIppErrorStatus();
            }
        }
    }
#endif

#ifdef HAVE_TEGRA_OPTIMIZATION
    if( tegra::useTegra() && tegra::filter2D(src, dst, kernel, anchor, delta, borderType) )
        return;
#endif

    if( kernel.cols*kernel.rows >= dft_filter_size )
    {
        Mat temp;
        // crossCorr doesn't accept non-zero delta with multiple channels
        if( src.channels() != 1 && delta != 0 )
        {
            // The semantics of filter2D require that the delta be applied
            // as floating-point math.  So wee need an intermediate Mat
            // with a float datatype.  If the dest is already floats,
            // we just use that.
            int corrDepth = dst.depth();
            if( (dst.depth() == CV_32F || dst.depth() == CV_64F) &&
                src.data != dst.data )
            {
                temp = dst;
            }
            else
            {
                corrDepth = dst.depth() == CV_64F ? CV_64F : CV_32F;
                temp.create( dst.size(), CV_MAKETYPE(corrDepth, dst.channels()) );
            }
            crossCorr( src, kernel, temp, src.size(),
                       CV_MAKETYPE(corrDepth, src.channels()),
                       anchor, 0, borderType );
            add( temp, delta, temp );
            if ( temp.data != dst.data )
            {
                temp.convertTo( dst, dst.type() );
            }
        }
        else
        {
            if( src.data != dst.data )
                temp = dst;
            else
                temp.create(dst.size(), dst.type());
            crossCorr( src, kernel, temp, src.size(),
                       CV_MAKETYPE(ddepth, src.channels()),
                       anchor, delta, borderType );
            if( temp.data != dst.data )
                temp.copyTo(dst);
        }
        return;
    }

    Ptr<FilterEngine> f = createLinearFilter(src.type(), dst.type(), kernel,
                                             anchor, delta, borderType & ~BORDER_ISOLATED );
    f->apply(src, dst, Rect(0,0,-1,-1), Point(), (borderType & BORDER_ISOLATED) != 0 );
}

原理部分学完，深入OpenCV源码部分也学完，相信大家应该对OpenCV中的线性滤波有了比较详细的认识，已经跃跃欲试想看这个几个函数用起来可以得出什么效果了。

【注】笔者分析的是3.0.0源码，对于2.0以上版本和3.0版本以上的源码大同小异，请读者自行对比学习。

1.1.3线性滤波函数讲解

这一部分的内容就是为了大家能快速上手boxFilter、blur和GaussianBlur这三个函数所准备的。还等什么呢，开始吧。
<1>boxFilter函数——方框滤波
boxFilter的函数作用是使用方框滤波（box filter）来模糊一张图片，由src输入，dst输出。

C++: void boxFilter(InputArray src,
                    OutputArray dst, 
                    int ddepth, 
                    Size ksize, Point anchor=Point(-1,-1), 
                    boolnormalize=true, 
                    int borderType=BORDER_DEFAULT )  

【参数】
第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。该函数对通道是独立处理的，且可以处理任意通道数的图片，但需要注意，待处理的图片深度应该为CV_8U, CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。
第三个参数，int类型的ddepth，输出图像的深度，-1代表使用原图深度，即src.depth()。
第四个参数，Size类型的ksize，内核的大小。一般这样写Size( w,h )来表示内核的大小( 其中，w 为像素宽度， h为像素高度)。Size（3,3）就表示3x3的核大小，Size（5,5）就表示5x5的核大小
第五个参数，Point类型的anchor，表示锚点（即被平滑的那个点），注意他有默认值Point(-1,-1)。如果这个点坐标是负值的话，就表示取核的中心为锚点，所以默认值Point(-1,-1)表示这个锚点在核的中心。
第六个参数，bool类型的normalize，默认值为true，一个标识符，表示内核是否被其区域归一化（normalized）了。
第七个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。有默认值BORDER_DEFAULT，我们一般不去管它。
调用代码示范如下：

//载入原图  
Mat image=imread("2.jpg");  
//进行均值滤波操作  
Mat out;  
boxFilter(image, out, -1,Size(5, 5));  

用上面三句核心代码架起来的完整程序代码。
【代码-参看附件demo1】
运行效果图（内核大小Size(5, 5)）：

图2方框滤波
<2>blur函数——均值滤波
blur的作用是对输入的图像src进行均值滤波后用dst输出。

C++: void blur(InputArray src, 
               OutputArraydst, 
               Size ksize, 
               Point anchor=Point(-1,-1), 
               int borderType=BORDER_DEFAULT )  

【参数】
第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。该函数对通道是独立处理的，且可以处理任意通道数的图片，但需要注意，待处理的图片深度应该为CV_8U, CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。比如可以用Mat::Clone，以源图片为模板，来初始化得到如假包换的目标图。
第三个参数，Size类型（对Size类型稍后有讲解）的ksize，内核的大小。一般这样写Size( w,h )来表示内核的大小( 其中，w 为像素宽度， h为像素高度)。Size（3,3）就表示3x3的核大小，Size（5,5）就表示5x5的核大小
第四个参数，Point类型的anchor，表示锚点（即被平滑的那个点），注意他有默认值Point(-1,-1)。如果这个点坐标是负值的话，就表示取核的中心为锚点，所以默认值Point(-1,-1)表示这个锚点在核的中心。
第五个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。有默认值BORDER_DEFAULT，我们一般不去管它。
调用代码示范：

//载入原图  
  Mat image=imread("1.jpg");  
  //进行均值滤波操作  
  Mat out;  
  blur(image, out, Size(7, 7));  

为了大家的理解和应用方便，还是给出用上面三句核心代码架起来完整程序的代码。
【代码-参见附件demo2】
运行效果图（内核大小Size(7, 7)）：

图3均值滤波
<3>GaussianBlur函数——高斯滤波
GaussianBlur函数的作用是用高斯滤波器来模糊一张图片，对输入的图像src进行高斯滤波后用dst输出。

C++: void GaussianBlur(InputArray src,
                       OutputArray dst, 
                       Size ksize, 
                       double sigmaX, 
                       double sigmaY=0, 
                       intborderType=BORDER_DEFAULT )  

【参数】
第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。它可以是单独的任意通道数的图片，但需要注意，图片深度应该为CV_8U,CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。比如可以用Mat::Clone，以源图片为模板，来初始化得到如假包换的目标图。
第三个参数，Size类型的ksize高斯内核的大小。其中ksize.width和ksize.height可以不同，但他们都必须为正数和奇数。或者，它们可以是零的，它们都是由sigma计算而来。
第四个参数，double类型的sigmaX，表示高斯核函数在X方向的的标准偏差。
第五个参数，double类型的sigmaY，表示高斯核函数在Y方向的的标准偏差。若sigmaY为零，就将它设为sigmaX，如果sigmaX和sigmaY都是0，那么就由ksize.width和ksize.height计算出来。为了结果的正确性着想，最好是把第三个参数Size，第四个参数sigmaX和第五个参数sigmaY全部指定到。
第六个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。注意它有默认值BORDER_DEFAULT。
【调用示例】

//载入原图  
Mat image=imread("1.jpg");  
//进行滤波操作  
Mat out;  
GaussianBlur( image, out, Size( 5, 5 ), 0, 0 );   

用上面三句核心代码架起来的完整程序代码。
【代码-参见附件demo3】
运行效果图（内核大小Size(5, 5)）。

图4高斯滤波

<4> filter2D函数——图像卷积运算函数滤波
该函数使用于任意线性滤波器的图像，支持就地操作。当其中心移动到图像外，函数可以根据指定的边界模式进行插值运算。
C++:void cv::filter2D( InputArray _src,
OutputArray _dst,
int ddepth,
InputArray _kernel,
Point anchor0,
double delta,
int borderType )
参数：
第一个参数，InputArray src: 输入图像
第二个参数，OutputArray dst: 输出图像，和输入图像具有相同的尺寸和通道数量
第三个参数，int ddepth: 目标图像深度，如果没写将生成与原图像深度相同的图像。原图像和目标图像支持的图像深度如下：
src.depth() = CV_8U, ddepth = -1/CV_16S/CV_32F/CV_64F
src.depth() = CV_16U/CV_16S, ddepth = -1/CV_32F/CV_64F
src.depth() = CV_32F, ddepth = -1/CV_32F/CV_64F
src.depth() = CV_64F, ddepth = -1/CV_64F
当ddepth输入值为-1时，目标图像和原图像深度保持一致。
第四个参数，InputArray kernel: 卷积核（或者是相关核）,一个单通道浮点型矩阵。如果想在图像不同的通道使用不同的kernel，可以先使用split()函数将图像通道事先分开。
第五个参数，Point anchor: 内核的基准点(anchor)，其默认值为(-1,-1)说明位于kernel的中心位置。基准点即kernel中与进行处理的像素点重合的点。
第六个参数，double delta: 在储存目标图像前可选的添加到像素的值，默认值为0
第七个参数，int borderType: 像素向外逼近的方法，默认值是BORDER_DEFAULT,即对全部边界进行计算。
通过filter2D函数可以自定义核，笔者在此通过filter2D函数实现了滤波。
代码参考附件【demo4】。效果如下图所示。首先显示的是原始图像，随后显示的是自定义核的图像，最后显示了由归一化滤波器模糊之后的图像。每过0.5秒，滤波器核的大小会有所变化。

图5

图6

官方参考：
英文链接
中文链接

1.1.4图像线性滤波实例

这个示例程序中可以用轨迹条来控制三种线性滤波的核参数值，通过滑动滚动条，就可以控制图像在三种线性滤波下的模糊度，有一定的可玩性。
【代码-参见附件demo5】
最后是一些运行截图。

图7方框滤波

图8均值滤波

图9高斯滤波

1.2非线性滤波

1.2.1理论与概念讲解

<1>非线性滤波概述
在上文，我们所考虑的滤波器都是线性的，即两个信号之和的响应和他们各自响应之和相等。换句话说，每个像素的输出值是一些输入像素的加权和，线性滤波器易于构造，并且易于从频率响应角度来进行分析。
其实在很多情况下，使用邻域像素的非线性滤波也许会得到更好的效果。比如在噪声是散粒噪声而不是高斯噪声，即图像偶尔会出现很大的值的时候。在这种情况下，用高斯滤波器对图像进行模糊的话，噪声像素是不会被去除的，它们只是转换为更为柔和但仍然可见的散粒。这就到了中值滤波登场的时候了。
<2>中值滤波
中值滤波（Median filter）是一种典型的非线性滤波技术，基本思想是用像素点邻域灰度值的中值来代替该像素点的灰度值，该方法在去除脉冲噪声、椒盐噪声的同时又能保留图像边缘细节，．
中值滤波是基于排序统计理论的一种能有效抑制噪声的非线性信号处理技术，其基本原理是把数字图像或数字序列中一点的值用该点的一个邻域中各点值的中值代替，让周围的像素值接近的真实值，从而消除孤立的噪声点，对于斑点噪声（speckle noise）和椒盐噪声（salt-and-pepper noise）来说尤其有用，因为它不依赖于邻域内那些与典型值差别很大的值。中值滤波器在处理连续图像窗函数时与线性滤波器的工作方式类似，但滤波过程却不再是加权运算。
中值滤波在一定的条件下可以克服常见线性滤波器如最小均方滤波、方框滤波器、均值滤波等带来的图像细节模糊，而且对滤除脉冲干扰及图像扫描噪声非常有效，也常用于保护边缘信息, 保存边缘的特性使它在不希望出现边缘模糊的场合也很有用，是非常经典的平滑噪声处理方法。
●中值滤波与均值滤波器比较
中值滤波器与均值滤波器比较的优势：在均值滤波器中，由于噪声成分被放入平均计算中，所以输出受到了噪声的影响，但是在中值滤波器中，由于噪声成分很难选上，所以几乎不会影响到输出。因此同样用3x3区域进行处理，中值滤波消除的噪声能力更胜一筹。中值滤波无论是在消除噪声还是保存边缘方面都是一个不错的方法。
中值滤波器与均值滤波器比较的劣势：中值滤波花费的时间是均值滤波的5倍以上。
顾名思义，中值滤波选择每个像素的邻域像素中的中值作为输出，或者说中值滤波将每一像素点的灰度值设置为该点某邻域窗口内的所有像素点灰度值的中值。
例如，取3 x 3的函数窗，计算以点[i,j]为中心的函数窗像素中值步骤如下：
（1） 按强度值大小排列像素点．
（2） 选择排序像素集的中间值作为点[i,j]的新值．
这一过程如图下图所示．

图10
一般采用奇数点的邻域来计算中值，但如果像素点数为偶数时，中值就取排序像素中间两点的平均值。
中值滤波在一定条件下，可以克服线性滤波器（如均值滤波等）所带来的图像细节模糊，而且对滤除脉冲干扰即图像扫描噪声最为有效。在实际运算过程中并不需要图像的统计特性，也给计算带来不少方便。但是对一些细节多，特别是线、尖顶等细节多的图像不宜采用中值滤波。
<3>双边滤波
双边滤波（Bilateral filter）是一种非线性的滤波方法，是结合图像的空间邻近度和像素值相似度的一种折衷处理，同时考虑空域信息和灰度相似性，达到保边去噪的目的。具有简单、非迭代、局部的特点。
双边滤波器的好处是可以做边缘保存（edge preserving），一般过去用的维纳滤波或者高斯滤波去降噪，都会较明显地模糊边缘，对于高频细节的保护效果并不明显。双边滤波器顾名思义比高斯滤波多了一个高斯方差sigma－d，它是基于空间分布的高斯滤波函数，所以在边缘附近，离的较远的像素不会太多影响到边缘上的像素值，这样就保证了边缘附近像素值的保存。但是由于保存了过多的高频信息，对于彩色图像里的高频噪声，双边滤波器不能够干净的滤掉，只能够对于低频信息进行较好的滤波。
在双边滤波器中，输出像素的值依赖于邻域像素值的加权值组合：
$$g(i,j)=\frac{\sum_{k,l} f(k,l)w(i,j,k,l)}{\sum_{k,l} w(i,j,k,l)}$$

而加权系数w(i,j,k,l)取决于定义域核和值域核的乘积。
其中定义域核表示如下：

$$d(i,j,k,l)=exp (-\frac{(i-k)^2+(j-l)^2}{2 \sigma^2_d})$$

定义域滤波：

图11
值域核表示为：
$$r(i,j,k,l)=exp (-\frac{||f(i,j)-f(k,l)||^2}{2 \sigma^2_r})$$

值域滤波：

图12
两者相乘后，就会产生依赖于数据的双边滤波权重函数：
$$w(i,j,k,l)=exp (-\frac{(i-k)^2+(j-l)^2}{2 \sigma^2_d} -\frac{||f(i,j)-f(k,l)||^2}{2 \sigma^2_r})$$

1.2.2 OpenCV源码分析

首先让我们一起领略medianBlur（）函数的源码。

/*【medianBlur ( )函数源代码】********************************************************
 * @Version：OpenCV 3.0.0（Opnencv2和Opnencv3差别不大，Linux和PC的对应版本源码完全一样，均在对应的安装目录下）  
 * @源码路径：…\opencv\sources\modules\imgproc\src\smooth.cpp
 * @起始行数：2635行   
********************************************************************************/
void cv::medianBlur( InputArray _src0, OutputArray _dst, int ksize )
{
    CV_Assert( (ksize % 2 == 1) && (_src0.dims() <= 2 ));

    if( ksize <= 1 )
    {
        _src0.copyTo(_dst);
        return;
    }

    CV_OCL_RUN(_dst.isUMat(),
               ocl_medianFilter(_src0,_dst, ksize))

    Mat src0 = _src0.getMat();//拷贝形参Mat数据到临时变量
    _dst.create( src0.size(), src0.type() );
    Mat dst = _dst.getMat();

#if IPP_VERSION_X100 >= 801
    CV_IPP_CHECK()
    {
#define IPP_FILTER_MEDIAN_BORDER(ippType, ippDataType, flavor) \
        do \
        { \
            if (ippiFilterMedianBorderGetBufferSize(dstRoiSize, maskSize, \
                ippDataType, CV_MAT_CN(type), &bufSize) >= 0) \
            { \
                Ipp8u * buffer = ippsMalloc_8u(bufSize); \
                IppStatus status = ippiFilterMedianBorder_##flavor(src.ptr<ippType>(), (int)src.step, \
                    dst.ptr<ippType>(), (int)dst.step, dstRoiSize, maskSize, \
                    ippBorderRepl, (ippType)0, buffer); \
                ippsFree(buffer); \
                if (status >= 0) \
                { \
                    CV_IMPL_ADD(CV_IMPL_IPP); \
                    return; \
                } \
            } \
            setIppErrorStatus(); \
        } \
        while ((void)0, 0)
              //处理特定的ksize值的不同情况  
        if( ksize <= 5 )
        {
            Ipp32s bufSize;
            IppiSize dstRoiSize = ippiSize(dst.cols, dst.rows), maskSize = ippiSize(ksize, ksize);
            Mat src;
            if( dst.data != src0.data )
                src = src0;
            else
                src0.copyTo(src);

            int type = src0.type();
            if (type == CV_8UC1)
                IPP_FILTER_MEDIAN_BORDER(Ipp8u, ipp8u, 8u_C1R);
            else if (type == CV_16UC1)
                IPP_FILTER_MEDIAN_BORDER(Ipp16u, ipp16u, 16u_C1R);
            else if (type == CV_16SC1)
                IPP_FILTER_MEDIAN_BORDER(Ipp16s, ipp16s, 16s_C1R);
            else if (type == CV_32FC1)
                IPP_FILTER_MEDIAN_BORDER(Ipp32f, ipp32f, 32f_C1R);
        }
#undef IPP_FILTER_MEDIAN_BORDER
    }
#endif
//若之前有过HAVE_TEGRA_OPTIMIZATION优化选项的定义，则执行宏体中的tegra优化版函数并返回
#ifdef HAVE_TEGRA_OPTIMIZATION
    if (tegra::useTegra() && tegra::medianBlur(src0, dst, ksize))
        return;
#endif

    bool useSortNet = ksize == 3 || (ksize == 5
#if !(CV_SSE2 || CV_NEON)
            && src0.depth() > CV_8U
#endif
        );

    Mat src;
    if( useSortNet )
    {
        if( dst.data != src0.data )
            src = src0;
        else
            src0.copyTo(src);
 //根据不同的位深，给medianBlur_SortNet函数取不同的模板类型值
        if( src.depth() == CV_8U )
            medianBlur_SortNet<MinMax8u, MinMaxVec8u>( src, dst, ksize );
        else if( src.depth() == CV_16U )
            medianBlur_SortNet<MinMax16u, MinMaxVec16u>( src, dst, ksize );
        else if( src.depth() == CV_16S )
            medianBlur_SortNet<MinMax16s, MinMaxVec16s>( src, dst, ksize );
        else if( src.depth() == CV_32F )
            medianBlur_SortNet<MinMax32f, MinMaxVec32f>( src, dst, ksize );
        else
            CV_Error(CV_StsUnsupportedFormat, "");

        return;
    }
    else
    {
        cv::copyMakeBorder( src0, src, 0, 0, ksize/2, ksize/2, BORDER_REPLICATE );

        int cn = src0.channels();
        CV_Assert( src.depth() == CV_8U && (cn == 1 || cn == 3 || cn == 4) );

        double img_size_mp = (double)(src0.total())/(1 << 20);
        if( ksize <= 3 + (img_size_mp < 1 ? 12 : img_size_mp < 4 ? 6 : 2)*
            (MEDIAN_HAVE_SIMD && (checkHardwareSupport(CV_CPU_SSE2) || checkHardwareSupport(CV_CPU_NEON)) ? 1 : 3))
            medianBlur_8u_Om( src, dst, ksize );
        else
            medianBlur_8u_O1( src, dst, ksize );
    }
}

仔细阅读源码我们可以发现，正式进入滤波操作时，根据图像不同的位深，我们会给medianBlur_SortNet函数模板取不同的模板类型值，或者调用medianBlur_8u_Om或medianBlur_8u_O1来进行操作。
上面我们刚说到，medianBlur_SortNet 是一个函数模板，其源码于smooth.cpp，由于其函数体很长，我们在此只贴出它的函数声明。

template<class Op, class VecOp>  
static void medianBlur_SortNet( constMat& _src, Mat& _dst, int m )；  

另外，bilateralFilter函数的源码也比较冗长，在smooth.cpp源码文件中，smooth.cpp源码的中自适应双边滤波器（adaptiveBilateralFilter）的源代码，有兴趣和精力的童鞋可以去探究探究。

1.2.3 API函数讲解

<1> 中值滤波——medianBlur函数
medianBlur函数使用中值滤波器来平滑（模糊）处理一张图片，从src输入，而结果从dst输出。且对于多通道图片，每一个通道都单独进行处理，并且支持就地操作（In-placeoperation）。

 C++: void medianBlur(InputArray src,
                      OutputArray dst, 
                      int ksize)  

【参数】
第一个参数，InputArray类型的src，函数的输入参数，填1、3或者4通道的Mat类型的图像；当ksize为3或者5的时候，图像深度需为CV_8U，CV_16U，或CV_32F其中之一，而对于较大孔径尺寸的图片，它只能是CV_8U。
第二个参数，OutputArray类型的dst，即目标图像，函数的输出参数，需要和源图片有一样的尺寸和类型。我们可以用Mat::Clone，以源图片为模板，来初始化得到如假包换的目标图。
第三个参数，int类型的ksize，孔径的线性尺寸（aperture linear size），注意这个参数必须是大于1的奇数，比如：3，5，7，9 …
调用范例：

//载入原图  
Mat image=imread("1.jpg");  
//进行中值滤波操作  
Mat out;  
medianBlur( image, out, 7);  

用上面三句核心代码架起来的完整程序代码。
【代码-参见附件demo6】
运行效果图（孔径的线性尺寸为7）：

图13中值滤波
<2>双边滤波——bilateralFilter函数
用双边滤波器来处理一张图片，由src输入图片，结果于dst输出。

C++: void bilateralFilter(InputArray src,
                          OutputArraydst, 
                          int d, 
                          double sigmaColor, 
                          double sigmaSpace, 
                          int borderType=BORDER_DEFAULT)  

【参数】
第一个参数，InputArray类型的src，输入图像，即源图像，需要为8位或者浮点型单通道、三通道的图像。
第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。
第三个参数，int类型的d，表示在过滤过程中每个像素邻域的直径。如果这个值我们设其为非正数，那么OpenCV会从第五个参数sigmaSpace来计算出它来。
第四个参数，double类型的sigmaColor，颜色空间滤波器的sigma值。这个参数的值越大，就表明该像素邻域内有更宽广的颜色会被混合到一起，产生较大的半相等颜色区域。
第五个参数，double类型的sigmaSpace坐标空间中滤波器的sigma值，坐标空间的标注方差。他的数值越大，意味着越远的像素会相互影响，从而使更大的区域足够相似的颜色获取相同的颜色。当d>0，d指定了邻域大小且与sigmaSpace无关。否则，d正比于sigmaSpace。
第六个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。注意它有默认值BORDER_DEFAULT。
调用代码示范如下：

 //载入原图  
Mat image=imread("1.jpg");  
//进行双边滤波操作  
Mat out;  
bilateralFilter( image, out, 25, 25*2, 25/2 );  

用一个完整的示例程序把bilateralFilter函数熟悉一下。
【代码-参考附件demo7】
运行效果图。

图14双边滤波

1.2.4非线性滤波综合实例

这个示例程序中可以用轨迹条来控制各种滤波（方框滤波、均值滤波、高斯滤波、中值滤波、双边滤波）的参数值，通过滑动滚动条，就可以控制图像在各种平滑处理下的模糊度，有一定的可玩性。
【代码-参见附件demo8】
放出一些效果图。

图15方框滤波

图16均值滤波

图17高斯滤波

图18中值滤波

图19双边滤波

参考链接：

英文链接
中文链接

本章附件：

请点击代码链接

【注意】博主在附件中的代码只有Linux版本的，如何使用Windows使用该代码请参看博主的另一篇博文
Opencv环境搭建（Visual Studio+Windows）- 请点击
有任何问题请联系博主。