线性滤波：方框、均值、高斯

超、凢脫俗 2022-08-07 09:44 267阅读 0赞

向浅墨学习。

> 本系列文章由@浅墨\_毛星云 出品，转载请注明出处。 
> 
> 文章链接：[http://blog.csdn.net/poem\_qianmo/article/details/22745559][http_blog.csdn.net_poem_qianmo_article_details_22745559]
> 
> 作者：毛星云（浅墨） 邮箱： [happylifemxy@163.com][happylifemxy_163.com]
> 
> 写作当前博文时配套使用的OpenCV版本： 2.4.8
> 
>   
> 
> 
>   
> 
> 
> 本篇文章中，我们一起仔细探讨了OpenCV图像处理技术中比较热门的图像滤波操作。图像滤波系列文章浅墨准备花两次更新的时间来讲，此为上篇，为大家剖析了“方框滤波“，”均值滤波“和”高斯滤波“三种常见线性邻域滤波操作。而作为非线性滤波的“中值滤波”和“双边滤波”，留待我们下次剖析。
> 
> 先上一张精彩截图：
> 
> ![SouthEast][]  
> 
> 
>   
> 
> 
> 浅墨其实很希望把这篇文章写得精简和简明扼要，发现越深入写进去，需要讲的周边内容越多，于是文章越写越长，最后在word中字数统计突破了一万。。。。。。。
> 
> 因为文章很长，如果详细啃的话，或许会消化不良。在这里给大家一个指引，如果是单单想要掌握这篇文章中讲解的OpenCV线性滤波相关的三个函数：boxFilter，blur和GaussianBlur的使用方法的话，直接看第三部分“浅出”和第四部分“实例”就行。
> 
> 在以后写的OpenCV系列文章中，浅墨暂且准备将每篇博文中知识点都分成原理、深入、浅出和实例四大部分来讲解，
> 
> 第一部分为和图像处理中线性滤波相关的理论，第二部分“深入”部分主要深入OpenCV内部，带领大家领略OpenCV的开源魅力，进行OpenCV相关源码的剖析，做到对OpenCV理解深刻，做一个高端大气的OpenCV使用者。 第三部分“浅出”主要教会大家如何快速上手当前文章中介绍的相关OpenCV API函数。而在第四部分，浅墨会为大家准备一个和本篇文章相关的详细注释的综合实例程序。
> 
> 这样的话呢，文章既不失深度，也不失快速入门的良方。希望浅墨按这样的新思路写出来的文章,无论是新手还是高手，看了都能有所收获。
> 
>   
> 
> 
> 给出本篇万字文章的结构脉络：

> > 一、理论——相关图像处理概念介绍
> 
> > 二、深入——OpenCV源码讲解
> 
> > 三、浅出——API函数讲解
> 
> > 四、实例——详细注释的博文配套程序

> OK，我们开始吧。
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
>   
>

一、理论与概念讲解

>   
> 
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
> ## <1>关于平滑处理 ##
> 
>   
> 
> 
> “平滑处理“（smoothing）也称“模糊处理”（bluring），是一项简单且使用频率很高的图像处理方法。平滑处理的用途有很多，最常见的是用来减少图像上的噪点或者失真。在涉及到降低图像分辨率时，平滑处理是非常好用的方法。
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
> ## <2>图像滤波与滤波器 ##
> 
>   
>   
>   
> 
> 
> 首先我们看一下图像滤波的概念。图像滤波，即在尽量保留图像细节特征的条件下对目标图像的噪声进行抑制，是图像预处理中不可缺少的操作，其处理效果的好坏将直接影响到后续图像处理和分析的有效性和可靠性。  
> 消除图像中的噪声成分叫作图像的平滑化或滤波操作。信号或图像的能量大部分集中在幅度谱的低频和中频段是很常见的，而在较高频段，感兴趣的信息经常被噪声淹没。因此一个能降低高频成分幅度的滤波器就能够减弱噪声的影响。  
> 图像滤波的目的有两个:一是抽出对象的特征作为图像识别的特征模式;另一个是为适应图像处理的要求，消除图像数字化时所混入的噪声。  
> 而对滤波处理的要求也有两条:一是不能损坏图像的轮廓及边缘等重要信息;二是使图像清晰视觉效果好。  
>   
> 平滑滤波是低频增强的空间域滤波技术。它的目的有两类：一类是模糊；另一类是消除噪音。（各种“两"，：））  
> 空间域的平滑滤波一般采用简单平均法进行，就是求邻近像元点的平均亮度值。邻域的大小与平滑的效果直接相关，邻域越大平滑的效果越好，但邻域过大，平滑会使边缘信息损失的越大，从而使输出的图像变得模糊，因此需合理选择邻域的大小。  
> 关于滤波器，一种形象的比喻法是：我们可以把滤波器想象成一个包含加权系数的窗口，当使用这个滤波器平滑处理图像时，就把这个窗口放到图像之上，透过这个窗口来看我们得到的图像。  
> 滤波器的种类有很多， 在新版本的OpenCV中，提供了如下五种常用的图像平滑处理操作方法，且他们分别被封装在单独的函数中，使用起来非常方便：  
> 
> 
>   
>

> >  *  方框滤波——boxblur函数
> >  *  均值滤波（邻域平均滤波）——blur函数
> >  *  高斯滤波——GaussianBlur函数
> >  *  中值滤波——medianBlur函数
> >  *  双边滤波——bilateralFilter函数

> 今天我们要讲解的是作为线性滤波的方框滤波，均值滤波和高斯滤波。两种非线性滤波操作——中值滤波和双边滤波，我们留待下次讲解。
> 
>   
> 
> 
>   
> 
> 
> ## <3>对线性滤波器的简介 ##
> 
> 线性滤波器：线性滤波器经常用于剔除输入信号中不想要的频率或者从许多频率中选择一个想要的频率。
> 
> 几种常见的线性滤波器：
> 
>  *  允许低频率通过的低通滤波器。
>  *  允许高频率通过的高通滤波器。
>  *  允许一定范围频率通过的带通滤波器。
>  *  阻止一定范围频率通过并且允许其它频率通过的带阻滤波器。
>  *  允许所有频率通过、仅仅改变相位关系的全通滤波器。
>  *  阻止一个狭窄频率范围通过的特殊带阻滤波器，陷波滤波器（Band-stop filter）。
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
> ## <4>关于滤波和模糊 ##
> 
>   
> 
> 
> 关于滤波和模糊，大家往往在初次接触的时候会弄混淆，“一会儿说滤波，一会儿又说模糊，什么玩意儿啊”。
> 
> 没关系，在这里，我们就来辨别一下，为大家扫清障碍。
> 
> 我们上文已经提到过，滤波是将信号中特定波段频率滤除的操作，是抑制和防止干扰的一项重要措施。
> 
> 为了方便说明，就拿我们经常用的高斯滤波来作例子吧。我们知道，滤波可分低通滤波和高通滤波两种。而高斯滤波是指用高斯函数作为滤波函数的滤波操作，至于是不是模糊，要看是高斯低通还是高斯高通，低通就是模糊，高通就是锐化。
> 
> 其实说白了是很简单的，对吧：
> 
> **高斯滤波是指用高斯函数作为滤波函数的滤波操作。**
> 
> **高斯模糊就是高斯低通滤波。**
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
> ## <5>邻域算子与线性邻域滤波 ##
> 
>   
> 
> 
> 邻域算子（局部算子）是利用给定像素周围的像素值的决定此像素的最终输出值的一种算子。而线性邻域滤波是一种常用的邻域算子，像素的输出值取决于输入像素的加权和，具体过程如下图。
> 
> 邻域算子除了用于局部色调调整以外，还可以用于图像滤波，实现图像的平滑和锐化，图像边缘增强或者图像噪声的去除。本篇文章，我们介绍的主角是线性邻域滤波算子，即用不同的权重去结合一个小邻域内的像素，来得到应有的处理效果。  
> 
> 
> ![SouthEast 1][]  
> 
> 
>   
> 
> 
> 图注：邻域滤波（卷积）：左边图像与中间图像的卷积产生右边图像。目标图像中蓝色标记的像素是利用原图像中红色标记的像素计算得到的。
> 
> 线性滤波处理的输出像素值![SouthEast 2][]是输入像素值![SouthEast 3][]的加权和 :
> 
>   
> 
> 
>  ![SouthEast 4][]
> 
>   
> 
> 
> 其中的加权和为 ，我们称其为“核”，滤波器的加权系数，即滤波器的“滤波系数”。
> 
> 上面的式子可以简单写作：
> 
>  ![SouthEast 5][]
> 
>   
> 
> 
> 其中f表示输入像素值，h表示加权系数“核“，g表示输出像素值
> 
>   
> 
> 
> 在新版本的OpenCV中，提供了如下三种常用的线性滤波操作，他们分别被封装在单独的函数中，使用起来非常方便：

> > 方框滤波——boxblur函数
> 
> > 均值滤波——blur函数
> 
> > 高斯滤波——GaussianBlur函数

> 下面我们来对他们进行一一介绍。
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
> ## <6>方框滤波（box Filter） ##
> 
>   
> 
> 
> 方框滤波（box Filter）被封装在一个名为boxblur的函数中，即boxblur函数的作用是使用方框滤波器（box filter）来模糊一张图片，从src输入，从dst输出。
> 
> 函数原型如下：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  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（）函数方框滤波所用的核为：

> > > > > > > ![SouthEast 6][]

> 其中：

> > ![SouthEast 7][]

> 其中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函数文档中，给出的其核是这样的：
> 
> ![SouthEast 8][]  
> 
> 
> 这个内核一看就明了，就是在求均值，即blur函数封装的就是均值滤波。
> 
>  blur函数的原型：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  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，我们一般不去管它。
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
> ## <8>高斯滤波 ##
> 
> ###     ###
> 
>   
> 
> 
> ### 1）高斯滤波的理论简析 ###
> 
> 高斯滤波是一种线性平滑滤波，适用于消除高斯噪声，广泛应用于图像处理的减噪过程。通俗的讲，高斯滤波就是对整幅图像进行加权平均的过程，每一个像素点的值，都由其本身和邻域内的其他像素值经过加权平均后得到。高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。
> 
> 大家常常说高斯滤波最有用的滤波操作，虽然它用起来，效率往往不是最高的。
> 
> 高斯模糊技术生成的图像，其视觉效果就像是经过一个半透明屏幕在观察图像，这与镜头焦外成像效果散景以及普通照明阴影中的效果都明显不同。高斯平滑也用于计算机视觉算法中的预先处理阶段，以增强图像在不同比例大小下的图像效果（参见尺度空间表示以及尺度空间实现）。从数学的角度来看，图像的高斯模糊过程就是图像与正态分布做卷积。由于正态分布又叫作高斯分布，所以这项技术就叫作高斯模糊。
> 
> 图像与圆形方框模糊做卷积将会生成更加精确的焦外成像效果。由于高斯函数的傅立叶变换是另外一个高斯函数，所以高斯模糊对于图像来说就是一个低通滤波操作。
> 
> 高斯滤波器是一类根据高斯函数的形状来选择权值的线性平滑滤波器。高斯平滑滤波器对于抑制服从正态分布的噪声非常有效。一维零均值高斯函数为：

> > > > > > ![SouthEast 9][]

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

> > > > > > ![SouthEast 10][]
> > > > > > 
> > > > > >   
> > > > > >

> ### 2）在OpenCV中使用高斯滤波——GaussianBlur函数 ###
> 
> GaussianBlur函数的作用是用高斯滤波器来模糊一张图片，对输入的图像src进行高斯滤波后用dst输出。它将源图像和指定的高斯核函数做卷积运算，并且支持就地过滤（In-placefiltering）。
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  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，我们一般不去管它。
> 
>  嗯，第一部分的理论介绍大概就是这些了，我们接着进入第二部分，OpenCV的源码剖析。
> 
>   
> 
> 
>   
> 
> 
>   
>

二、深入——OpenCV源码剖析

> #     #
> 
>   
> 
> 
> 上一篇文章中我们已经和当前最新版的OpenCV的源码亲密接触过。 在这一部分中，浅墨将带领大家领略OpenCV的开源魅力，对OpenCV中本篇文章里讲解到线性滤波函数——boxFilter，blur和GaussianBlur函数以及周边的涉及到的源码进行适当的剖析。

> 这样，我们就可以对 OpenCV有一个更加深刻的理解，成为一个高端大气的OpenCV使用者。
> 
>   
> 
> 
>   
> 
> 
> ## <1>OpenCV中boxFilter函数源码解析 ##
> 
>   
> 
> 
> 我们可以在OpenCV的安装路径的\\sources\\modules\\imgproc\\src下的smooth.cpp源文件的第711行找到boxFilter函数的源代码。对应于浅墨将OpenCV 2.4.8安装在D:\\Program Files\\opencv的路径下，那么，smooth.cpp文件就在D:\\ProgramFiles\\opencv\\sources\\modules\\imgproc\\src路径下。
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //-----------------------------------【boxFilter（）函数中文注释版源代码】----------------------------
> 2.  // 代码作用：进行box Filter滤波操作的函数
> 3.  // 说明：以下代码为来自于计算机开源视觉库OpenCV的官方源代码
> 4.  // OpenCV源代码版本：2.4.8
> 5.  // 源码路径：…\\opencv\\sources\\modules\\imgproc\\src\\smooth.cpp
> 6.  // 源文件中如下代码的起始行数：711行
> 7.  // 中文注释by浅墨
> 8.  //--------------------------------------------------------------------------------------------------------
> 9.  **void** cv::boxFilter( InputArray \_src,OutputArray \_dst, **int** ddepth, 
> 10.  Size ksize, Point anchor, 
> 11. **bool** normalize, **int** borderType) 
> 12. \{ 
> 13.  Mat src = \_src.getMat();//拷贝源图的形参Mat数据到临时变量，用于稍后的操作
> 14. **int** sdepth =src.depth(), cn = src.channels();//定义int型临时变量，代表源图深度的sdepth，源图通道的引用cn
> 15. 
> 16. //处理ddepth小于零的情况
> 17. **if**( ddepth < 0 ) 
> 18.  ddepth = sdepth; 
> 19.  \_dst.create( src.size(), CV\_MAKETYPE(ddepth, cn) );//初始化目标图
> 20. Mat dst =\_dst.getMat();//拷贝目标图的形参Mat数据到临时变量，用于稍后的操作
> 21. 
> 22. //处理 borderType不为 BORDER\_CONSTANT 且normalize为真的情况
> 23. **if**( borderType != BORDER\_CONSTANT && normalize ) \{ 
> 24. **if**( src.rows == 1 ) 
> 25.  ksize.height = 1; 
> 26. **if**( src.cols == 1 ) 
> 27.  ksize.width = 1; 
> 28. \} 
> 29. 
> 30. //若之前有过HAVE\_TEGRA\_OPTIMIZATION优化选项的定义，则执行宏体中的tegra优化版函数并返回
> 31. \#ifdef HAVE\_TEGRA\_OPTIMIZATION
> 32. **if** ( tegra::box(src, dst, ksize, anchor, normalize, borderType) ) 
> 33. **return**; 
> 34. \#endif
> 35. 
> 36. //调用FilterEngine滤波引擎，正式开始滤波操作
> 37.  Ptr<FilterEngine> f = createBoxFilter( src.type(), dst.type(), 
> 38.  ksize, anchor,normalize, borderType ); 
> 39.  f->apply( src, dst ); 
> 40. \} 
> 
>   
> 
> 
> 其中的Ptr是用来动态分配的对象的智能指针模板类。可以发现，函数的内部代码思路是很清晰的，先拷贝源图的形参Mat数据到临时变量，定义一些临时变量，在处理ddepth小于零的情况，接着处理 borderType不为 BORDER\_CONSTANT 且normalize为真的情况，最终调用FilterEngine滤波引擎创建一个BoxFilter，正式开始滤波操作。
> 
> 这里的FilterEngine是OpenCV图像滤波功能的核心引擎，我们有必要详细剖析看其源代码。
> 
>   
> 
> 
>   
> 
> 
> ## <2>FilterEngine类解析——OpenCV图像滤波核心引擎 ##
> 
>   
> 
> 
> FilterEngine类是OpenCV关于图像滤波的主力军类，OpenCV图像滤波功能的核心引擎。各种滤波函数比如blur， GaussianBlur，到头来其实是就是在函数末尾处定义了一个Ptr<FilterEngine>类型的f，然后f->apply( src, dst )了一下而已。
> 
> 这个类可以把几乎是所有的滤波操作施加到图像上。它包含了所有必要的中间缓存器。有很多和滤波相关的create系函数的返回值直接就是Ptr<FilterEngine>。比如cv::createSeparableLinearFilter(),
> 
>  cv::createLinearFilter(),cv::createGaussianFilter(), cv::createDerivFilter(),
> 
>  cv::createBoxFilter() 和cv::createMorphologyFilter().，这里给出其中一个函数的原型吧：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  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引擎。
> 
>   
> 
> 
> 我们看下其类声明经过浅墨详细注释的源码：  
> 
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //-----------------------------------【FilterEngine类中文注释版源代码】----------------------------
> 2.  // 代码作用：FilterEngine类，OpenCV图像滤波功能的核心引擎
> 3.  // 说明：以下代码为来自于计算机开源视觉库OpenCV的官方源代码
> 4.  // OpenCV源代码版本：2.4.8
> 5.  // 源码路径：…\\opencv\\sources\\modules\\imgproc\\include\\opencv2\\imgproc\\imgproc.hpp
> 6.  // 源文件中如下代码的起始行数：222行
> 7.  // 中文注释by浅墨
> 8.  //--------------------------------------------------------------------------------------------------------
> 9.  
> 10. **class** CV\_EXPORTS FilterEngine 
> 11. \{ 
> 12. **public**: 
> 13. //默认构造函数
> 14.  FilterEngine(); 
> 15. //完整的构造函数。 \_filter2D 、\_rowFilter 和 \_columnFilter之一，必须为非空
> 16.  FilterEngine(**const** Ptr<BaseFilter>& \_filter2D, 
> 17.  constPtr<BaseRowFilter>& \_rowFilter, 
> 18.  constPtr<BaseColumnFilter>& \_columnFilter, 
> 19. **int** srcType, **int** dstType, intbufType, 
> 20.  int\_rowBorderType=BORDER\_REPLICATE, 
> 21. **int** \_columnBorderType=-1, 
> 22. **const** Scalar&\_borderValue=Scalar()); 
> 23. //默认析构函数
> 24. **virtual** ~FilterEngine(); 
> 25. //重新初始化引擎。释放之前滤波器申请的内存。
> 26. **void** init(**const** Ptr<BaseFilter>& \_filter2D, 
> 27.  constPtr<BaseRowFilter>& \_rowFilter, 
> 28.  constPtr<BaseColumnFilter>& \_columnFilter, 
> 29. **int** srcType, **int** dstType, intbufType, 
> 30.  int\_rowBorderType=BORDER\_REPLICATE, **int** \_columnBorderType=-1, 
> 31. **const** Scalar&\_borderValue=Scalar()); 
> 32. //开始对指定了ROI区域和尺寸的图片进行滤波操作
> 33. **virtual****int** start(Size wholeSize, Rect roi, **int** maxBufRows=-1); 
> 34. //开始对指定了ROI区域的图片进行滤波操作
> 35. **virtual****int** start(**const** Mat& src, **const** Rect&srcRoi=Rect(0,0,-1,-1), 
> 36. **bool** isolated=**false**, intmaxBufRows=-1); 
> 37. //处理图像的下一个srcCount行（函数的第三个参数）
> 38. **virtual****int** proceed(**const** uchar\* src, **int** srcStep, **int** srcCount, 
> 39.  uchar\* dst, intdstStep); 
> 40. //对图像指定的ROI区域进行滤波操作，若srcRoi=(0,0,-1,-1)，则对整个图像进行滤波操作
> 41. **virtual****void** apply( **const** Mat& src, Mat& dst, 
> 42. **const** Rect&srcRoi=Rect(0,0,-1,-1), 
> 43.  Point dstOfs=Point(0,0), 
> 44. **bool** isolated=**false**); 
> 45. 
> 46. //如果滤波器可分离，则返回true
> 47. boolisSeparable() **const** \{ **return** (**const** BaseFilter\*)filter2D == 0; \} 
> 48. 
> 49. //返回输入和输出行数
> 50. **int** remainingInputRows() **const**; 
> 51. intremainingOutputRows() **const**; 
> 52. 
> 53. //一些成员参数定义
> 54. **int** srcType, dstType, bufType; 
> 55.  Size ksize; 
> 56.  Point anchor; 
> 57. **int** maxWidth; 
> 58.  Size wholeSize; 
> 59.  Rect roi; 
> 60. **int** dx1, dx2; 
> 61. **int** rowBorderType, columnBorderType; 
> 62.  vector<**int**> borderTab; 
> 63. **int** borderElemSize; 
> 64.  vector<uchar> ringBuf; 
> 65.  vector<uchar> srcRow; 
> 66.  vector<uchar> constBorderValue; 
> 67.  vector<uchar> constBorderRow; 
> 68. **int** bufStep, startY, startY0, endY, rowCount, dstY; 
> 69.  vector<uchar\*> rows; 
> 70. 
> 71.  Ptr<BaseFilter> filter2D; 
> 72.  Ptr<BaseRowFilter> rowFilter; 
> 73.  Ptr<BaseColumnFilter> columnFilter; 
> 74. \}; 
> 
>   
>   
> 
> 
>   
> 
> 
>   
> 
> 
> ## <3>OpenCV中size类型剖析 ##
> 
>   
> 
> 
> size类型我们也讲一下，通过转到定义，我们可以在……\\opencv\\sources\\modules\\core\\include\\opencv2\\core\\core.hpp路径下，对应于浅墨的OpenCV安装路径，就是在
> 
> D:\\ProgramFiles\\opencv\\sources\\modules\\core\\include\\opencv2\\core\\core.hpp下，找到其原型声明：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  **typedef** Size\_<**int**> Size2i; 
> 2.  **typedef** Size2i Size; 
> 
>   
> 
> 
> Size\_ 是个模板类，在这里Size\_<int>表示其类体内部的模板所代表的类型为int。
> 
> 那这两句的意思，就是首先给已知的数据类型Size\_<int>起个新名字，叫Size2i。
> 
> 然后又给已知的数据类型Size2i起个新名字，叫Size。
> 
> 所以，连起来就是，Size\_<int>、Size2i、Size这三个类型名等价。
> 
> 然后我们追根溯源，找到Size\_模板类的定义：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //-----------------------------------【Size\_类中文注释版源代码】----------------------------
> 2.  // 代码作用：作为尺寸相关数据结构的Size\_ 模板类
> 3.  // 说明：以下代码为来自于计算机开源视觉库OpenCV的官方源代码
> 4.  // OpenCV源代码版本：2.4.8
> 5.  // 源码路径：…\\opencv\\sources\\modules\\core\\include\\opencv2\\core\\core.hpp
> 6.  // 源文件中如下代码的起始行数：816行
> 7.  // 中文注释by浅墨
> 8.  //--------------------------------------------------------------------------------------------------------
> 9.  **template**<**typename** \_Tp> **class** Size\_ 
> 10. \{ 
> 11. **public**: 
> 12. **typedef** \_Tp value\_type; 
> 13. 
> 14. //不同的构造函数定义
> 15.  Size\_(); 
> 16.  Size\_(\_Tp \_width, \_Tp \_height); 
> 17.  Size\_(**const** Size\_& sz); 
> 18.  Size\_(**const** CvSize& sz); 
> 19.  Size\_(**const** CvSize2D32f& sz); 
> 20.  Size\_(**const** Point\_<\_Tp>& pt); 
> 21. 
> 22.  Size\_& operator = (**const** Size\_& sz); 
> 23. //区域(width\*height)
> 24.  \_Tp area() **const**; 
> 25. 
> 26. //转化另一种数据类型。
> 27. **template**<typename\_Tp2> operator Size\_<\_Tp2>() **const**; 
> 28. 
> 29. //转换为旧式的OpenCV类型.
> 30.  operator CvSize() **const**; 
> 31.  operator CvSize2D32f() **const**; 
> 32. 
> 33.  \_Tp width, height; //宽度和高度，常用属性
> 34. \}; 
> 
>   
>   
> 
> 
>   
> 
> 
>   
> 
> 
> 可以看到Size\_模板类的内部又是重载了一些构造函数以满足我们的需要，其中，我们用得最多的是如下这个构造函数：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  Size\_(\_Tp \_width, \_Tp \_height); 
> 
>   
> 
> 
> 另外，代码末尾定义了模板类型的宽度和高度：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  \_Tp width, height; //宽度和高度
> 
> 于是我们可以用XXX.width和XXX.height来分别表示其宽度和高度。
> 
> 给大家一个示例，方便理解：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  Size(5, 5)；//构造出的Size宽度和高度都为5，即XXX.width和XXX.height都为5
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
> ## <4>OpenCV中blur函数源码剖析 ##
> 
>   
> 
> 
>   
> 
> 
> 我们可以在OpenCV的安装路径的\\sources\\modules\\imgproc\\src下的smooth.cpp源文件中找到blur的源代码。对应于浅墨将OpenCV 2.4.8安装在D:\\Program Files\\opencv下，那么，smooth.cpp文件就在D:\\ProgramFiles\\opencv\\sources\\modules\\imgproc\\src路径下。
> 
> 一起来看一下OpenCV中blur函数定义的真面目：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //-----------------------------------【blur（）函数中文注释版源代码】----------------------------
> 2.  // 代码作用：进行blur均值滤波操作的函数
> 3.  // 说明：以下代码为来自于计算机开源视觉库OpenCV的官方源代码
> 4.  // OpenCV源代码版本：2.4.8
> 5.  // 源码路径：…\\opencv\\sources\\modules\\imgproc\\src\\smooth.cpp
> 6.  // 源文件中如下代码的起始行数：738行
> 7.  // 中文注释by浅墨
> 8.  //--------------------------------------------------------------------------------------------------------
> 9.  
> 10. **void** cv::blur(InputArray src, OutputArray dst, 
> 11.  Size ksize, Point anchor, **int** borderType ) 
> 12. \{ 
> 13. //调用boxFilter函数进行处理
> 14.  boxFilter( src, dst, -1, ksize, anchor, **true**, borderType ); 
> 15. \} 
> 
>   
> 
> 
> 可以看到在blur函数内部就是调用了一个boxFilter函数，且第六个参数为true，即我们上文所说的normalize=true，即均值滤波是均一化后的方框滤波。
> 
> ## <5>OpenCV中GaussianBlur函数源码剖析 ##
> 
> 最后，我们看一下OpenCV中GaussianBlur函数源代码：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //-----------------------------------【GaussianBlur（）函数中文注释版源代码】-----------------------
> 2.  // 代码作用：封装高斯滤波的GaussianBlur（）函数
> 3.  // 说明：以下代码为来自于计算机开源视觉库OpenCV的官方源代码
> 4.  // OpenCV源代码版本：2.4.8
> 5.  // 源码路径：…\\opencv\\sources\\modules\\imgproc\\src\\smooth.cpp
> 6.  // 源文件中如下代码的起始行数：832行
> 7.  // 中文注释by浅墨
> 8.  //--------------------------------------------------------------------------------------------------------
> 9.  
> 10. **void** cv::GaussianBlur( InputArray \_src,OutputArray \_dst, Size ksize, 
> 11. **double** sigma1, doublesigma2, 
> 12. **int** borderType ) 
> 13. \{ 
> 14. //拷贝形参Mat数据到临时变量，用于稍后的操作
> 15.  Mat src = \_src.getMat(); 
> 16.  \_dst.create( src.size(), src.type() ); 
> 17. Mat dst =\_dst.getMat(); 
> 18. 
> 19. //处理边界选项不为BORDER\_CONSTANT时的情况
> 20. **if**( borderType != BORDER\_CONSTANT ) 
> 21.  \{ 
> 22. **if**( src.rows == 1 ) 
> 23.  ksize.height = 1; 
> 24. **if**( src.cols == 1 ) 
> 25.  ksize.width = 1; 
> 26. \} 
> 27. 
> 28. //若ksize长宽都为1，将源图拷贝给目标图
> 29. **if**( ksize.width == 1 && ksize.height == 1 ) 
> 30.  \{ 
> 31.  src.copyTo(dst); 
> 32. **return**; 
> 33. \} 
> 34. 
> 35. //若之前有过HAVE\_TEGRA\_OPTIMIZATION优化选项的定义，则执行宏体中的tegra优化版函数并返回
> 36. \#ifdef HAVE\_TEGRA\_OPTIMIZATION
> 37. **if**(sigma1 == 0 && sigma2 == 0 && tegra::gaussian(src,dst, ksize, borderType)) 
> 38. **return**; 
> 39. \#endif
> 40. 
> 41. //如果HAVE\_IPP&& (IPP\_VERSION\_MAJOR >= 7为真，则执行宏体中语句
> 42. \#if defined HAVE\_IPP &&(IPP\_VERSION\_MAJOR >= 7)
> 43. **if**(src.type() == CV\_32FC1 && sigma1 == sigma2 &&ksize.width == ksize.height && sigma1 != 0.0 ) 
> 44.  \{ 
> 45.  IppiSize roi = \{src.cols, src.rows\}; 
> 46. **int** bufSize = 0; 
> 47.  ippiFilterGaussGetBufferSize\_32f\_C1R(roi, ksize.width, &bufSize); 
> 48.  AutoBuffer<uchar> buf(bufSize+128); 
> 49. **if**( ippiFilterGaussBorder\_32f\_C1R((**const** Ipp32f \*)src.data,(**int**)src.step, 
> 50.  (Ipp32f \*)dst.data, (**int**)dst.step, 
> 51.  roi,ksize.width, (Ipp32f)sigma1, 
> 52.  (IppiBorderType)borderType, 0.0, 
> 53.  alignPtr(&buf\[0\],32)) >= 0 ) 
> 54. **return**; 
> 55.  \} 
> 56. \#endif
> 57. 
> 58. //调动滤波引擎，正式进行高斯滤波操作
> 59.  Ptr<FilterEngine> f = createGaussianFilter( src.type(), ksize,sigma1, sigma2, borderType ); 
> 60.  f->apply( src, dst ); 
> 61. \} 
> 
>   
>   
> 
> 
>   
> 
> 
> 嗯，今天的源码解析就到这里吧，原理部分学完，深入OpenCV源码部分也学完，相信大家应该对OpenCV中的线性滤波有了比较详细的认识，已经跃跃欲试想看这个几个函数用起来可以得出什么效果了。
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
>   
>

三、浅出——线性滤波函数快速上手攻略

> ##     ##
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
> ## 这一部分的内容就是为了大家能快速上手boxFilter、blur和GaussianBlur这三个函数所准备的。还等什么呢，开始吧。 ##
> 
>   
> 
> 
> ## <1>boxFilter函数——方框滤波 ##
> 
>   
> 
> 
>   
> 
> 
> boxFilter的函数作用是使用方框滤波（box filter）来模糊一张图片，由src输入，dst输出。
> 
> 函数原型如下：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  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，我们一般不去管它。
> 
> 调用代码示范如下：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //载入原图
> 2.  Mat image=imread("2.jpg"); 
> 3.  //进行均值滤波操作
> 4.  Mat out; 
> 5.  boxFilter(image, out, -1,Size(5, 5)); 
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
> 用上面三句核心代码架起来的完整程序代码：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //-----------------------------------【头文件包含部分】---------------------------------------
> 2.  // 描述：包含程序所依赖的头文件
> 3.  //----------------------------------------------------------------------------------------------
> 4.  \#include "opencv2/core/core.hpp"
> 5.  \#include"opencv2/highgui/highgui.hpp"
> 6.  \#include"opencv2/imgproc/imgproc.hpp"
> 7.  
> 8.  //-----------------------------------【命名空间声明部分】---------------------------------------
> 9.  // 描述：包含程序所使用的命名空间
> 10. //----------------------------------------------------------------------------------------------- 
> 11. **using****namespace** cv; 
> 12. 
> 13. //-----------------------------------【main( )函数】--------------------------------------------
> 14. // 描述：控制台应用程序的入口函数，我们的程序从这里开始
> 15. //-----------------------------------------------------------------------------------------------
> 16. **int** main( ) 
> 17. \{ 
> 18. //载入原图
> 19.  Mat image=imread("2.jpg"); 
> 20. 
> 21. //创建窗口
> 22.  namedWindow("均值滤波【原图】" ); 
> 23.  namedWindow("均值滤波【效果图】"); 
> 24. 
> 25. //显示原图
> 26.  imshow("均值滤波【原图】", image ); 
> 27. 
> 28. //进行滤波操作
> 29.  Mat out; 
> 30.  boxFilter(image, out, -1,Size(5, 5)); 
> 31. 
> 32. //显示效果图
> 33.  imshow("均值滤波【效果图】" ,out ); 
> 34. 
> 35.  waitKey(0 ); 
> 36. \} 
> 
>   
>   
> 
> 
> 运行效果图（内核大小Size(5, 5)）：
> 
> ![SouthEast 11][]
> 
>   
> 
> 
> ## <2>blur函数——均值滤波 ##
> 
>   
> 
> 
> blur的作用是对输入的图像src进行均值滤波后用dst输出。
> 
> 函数原型如下：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  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，我们一般不去管它。
> 
> 调用代码示范：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //载入原图
> 2.   Mat image=imread("1.jpg"); 
> 3.  //进行均值滤波操作
> 4.   Mat out; 
> 5.   blur(image, out, Size(7, 7)); 
> 
>   
> 
> 
> 为了大家的理解和应用方便，还是给出用上面三句核心代码架起来完整程序的代码：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //-----------------------------------【头文件包含部分】---------------------------------------
> 2.  // 描述：包含程序所依赖的头文件
> 3.  //----------------------------------------------------------------------------------------------
> 4.  \#include "opencv2/core/core.hpp"
> 5.  \#include"opencv2/highgui/highgui.hpp"
> 6.  \#include"opencv2/imgproc/imgproc.hpp"
> 7.  \#include <stdio.h>
> 8.  
> 9.  //-----------------------------------【命名空间声明部分】---------------------------------------
> 10. // 描述：包含程序所使用的命名空间
> 11. //----------------------------------------------------------------------------------------------- 
> 12. **using****namespace** cv; 
> 13. 
> 14. //-----------------------------------【main( )函数】--------------------------------------------
> 15. // 描述：控制台应用程序的入口函数，我们的程序从这里开始
> 16. //-----------------------------------------------------------------------------------------------
> 17. **int** main( ) 
> 18. \{ 
> 19. //载入原图
> 20.  Mat image=imread("1.jpg"); 
> 21. 
> 22. //创建窗口
> 23.  namedWindow("均值滤波【原图】" ); 
> 24.  namedWindow("均值滤波【效果图】"); 
> 25. 
> 26. //显示原图
> 27.  imshow("均值滤波【原图】", image ); 
> 28. 
> 29. //进行滤波操作
> 30.  Mat out; 
> 31.  blur(image, out, Size(7, 7)); 
> 32. 
> 33. //显示效果图
> 34.  imshow("均值滤波【效果图】" ,out ); 
> 35. 
> 36.  waitKey(0 ); 
> 37. \} 
> 
> 运行效果图（内核大小Size(7, 7)）：
> 
> ![SouthEast 12][]  
> 
> 
>   
> 
> 
>   
> 
> 
> ## <3>GaussianBlur函数——高斯滤波 ##
> 
>   
> 
> 
>   
> 
> 
> GaussianBlur函数的作用是用高斯滤波器来模糊一张图片，对输入的图像src进行高斯滤波后用dst输出。
> 
> 函数原型如下：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  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。
> 
>  调用示例：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //载入原图
> 2.  Mat image=imread("1.jpg"); 
> 3.  //进行滤波操作
> 4.  Mat out; 
> 5.  GaussianBlur( image, out, Size( 5, 5 ), 0, 0 ); 
> 
>   
> 
> 
> 用上面三句核心代码架起来的完整程序代码：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //-----------------------------------【头文件包含部分】---------------------------------------
> 2.  // 描述：包含程序所依赖的头文件
> 3.  //----------------------------------------------------------------------------------------------
> 4.  \#include "opencv2/core/core.hpp"
> 5.  \#include"opencv2/highgui/highgui.hpp"
> 6.  \#include"opencv2/imgproc/imgproc.hpp"
> 7.  \#include <stdio.h>
> 8.  
> 9.  //-----------------------------------【命名空间声明部分】---------------------------------------
> 10. // 描述：包含程序所使用的命名空间
> 11. //----------------------------------------------------------------------------------------------- 
> 12. **using****namespace** cv; 
> 13. 
> 14. //-----------------------------------【main( )函数】--------------------------------------------
> 15. // 描述：控制台应用程序的入口函数，我们的程序从这里开始
> 16. //-----------------------------------------------------------------------------------------------
> 17. **int** main( ) 
> 18. \{ 
> 19. //载入原图
> 20.  Mat image=imread("1.jpg"); 
> 21. 
> 22. //创建窗口
> 23.  namedWindow("均值滤波【原图】" ); 
> 24.  namedWindow("均值滤波【效果图】"); 
> 25. 
> 26. //显示原图
> 27.  imshow("均值滤波【原图】", image ); 
> 28. 
> 29. //进行均值滤波操作
> 30.  Mat out; 
> 31.  GaussianBlur(image, out, Size( 3, 3 ), 0, 0 ); 
> 32. 
> 33. //显示效果图
> 34.  imshow("均值滤波【效果图】" ,out ); 
> 35. 
> 36.  waitKey(0 ); 
> 37. \} 
> 
>   
>   
> 
> 
>   
> 
> 
> 运行效果图（内核大小Size(5, 5)）：
> 
> ![SouthEast 13][]  
> 
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
> #  #

四、图像线性滤波综合示例 程序

>   
> 
> 
> 依然是每篇文章都会配给大家的一个详细注释的博文配套示例程序，把这篇文章中介绍的知识点以代码为载体，展现给大家。
> 
> 这个示例程序中可以用轨迹条来控制三种线性滤波的核参数值，通过滑动滚动条，就可以控制图像在三种线性滤波下的模糊度，有一定的可玩性。废话不多说，上代码吧：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //-----------------------------------【程序说明】----------------------------------------------
> 2.  // 程序名称:：【OpenCV入门教程之八】线性滤波专场：方框滤波、均值滤波与高斯滤波 配套源码
> 3.  // 开发所用OpenCV版本：2.4.8
> 4.  // 2014年3月31 日 Create by 浅墨
> 5.  //------------------------------------------------------------------------------------------------
> 6.  
> 7.  //-----------------------------------【头文件包含部分】---------------------------------------
> 8.  // 描述：包含程序所依赖的头文件
> 9.  //----------------------------------------------------------------------------------------------
> 10. \#include <opencv2/core/core.hpp>
> 11. \#include<opencv2/highgui/highgui.hpp>
> 12. \#include <opencv2/imgproc/imgproc.hpp>
> 13. \#include <iostream>
> 14. 
> 15. //-----------------------------------【命名空间声明部分】---------------------------------------
> 16. // 描述：包含程序所使用的命名空间
> 17. //----------------------------------------------------------------------------------------------- 
> 18. **using****namespace** std; 
> 19. **using****namespace** cv; 
> 20. 
> 21. 
> 22. //-----------------------------------【全局变量声明部分】--------------------------------------
> 23. // 描述：全局变量声明
> 24. //-----------------------------------------------------------------------------------------------
> 25. Mat g\_srcImage,g\_dstImage1,g\_dstImage2,g\_dstImage3;//存储图片的Mat类型
> 26. **int** g\_nBoxFilterValue=3; //方框滤波参数值
> 27. **int** g\_nMeanBlurValue=3; //均值滤波参数值
> 28. **int** g\_nGaussianBlurValue=3; //高斯滤波参数值
> 29. 
> 30. 
> 31. //-----------------------------------【全局函数声明部分】--------------------------------------
> 32. // 描述：全局函数声明
> 33. //-----------------------------------------------------------------------------------------------
> 34. //轨迹条的回调函数
> 35. **static****void** on\_BoxFilter(**int**, **void** \*); //方框滤波
> 36. **static****void** on\_MeanBlur(**int**, **void** \*); //均值滤波
> 37. **static****void** on\_GaussianBlur(**int**, **void** \*); //高斯滤波
> 38. 
> 39. 
> 40. 
> 41. //-----------------------------------【main( )函数】--------------------------------------------
> 42. // 描述：控制台应用程序的入口函数，我们的程序从这里开始
> 43. //-----------------------------------------------------------------------------------------------
> 44. **int** main( ) 
> 45. \{ 
> 46. //改变console字体颜色
> 47.  system("color5E"); 
> 48. 
> 49. //载入原图
> 50.  g\_srcImage= imread( "1.jpg", 1 ); 
> 51. **if**(!g\_srcImage.data ) \{ printf("Oh，no，读取srcImage错误~！\\n"); **return****false**; \} 
> 52. 
> 53. //克隆原图到三个Mat类型中
> 54.  g\_dstImage1= g\_srcImage.clone( ); 
> 55.  g\_dstImage2= g\_srcImage.clone( ); 
> 56.  g\_dstImage3= g\_srcImage.clone( ); 
> 57. 
> 58. //显示原图
> 59.  namedWindow("【<0>原图窗口】", 1); 
> 60.  imshow("【<0>原图窗口】",g\_srcImage); 
> 61. 
> 62. 
> 63. //=================【<1>方框滤波】==================
> 64. //创建窗口
> 65.  namedWindow("【<1>方框滤波】", 1); 
> 66. //创建轨迹条
> 67.  createTrackbar("内核值：", "【<1>方框滤波】",&g\_nBoxFilterValue, 40,on\_BoxFilter ); 
> 68.  on\_MeanBlur(g\_nBoxFilterValue,0); 
> 69.  imshow("【<1>方框滤波】", g\_dstImage1); 
> 70. //================================================
> 71. 
> 72. //=================【<2>均值滤波】==================
> 73. //创建窗口
> 74.  namedWindow("【<2>均值滤波】", 1); 
> 75. //创建轨迹条
> 76.  createTrackbar("内核值：", "【<2>均值滤波】",&g\_nMeanBlurValue, 40,on\_MeanBlur ); 
> 77.  on\_MeanBlur(g\_nMeanBlurValue,0); 
> 78. //================================================
> 79. 
> 80. //=================【<3>高斯滤波】=====================
> 81. //创建窗口
> 82.  namedWindow("【<3>高斯滤波】", 1); 
> 83. //创建轨迹条
> 84.  createTrackbar("内核值：", "【<3>高斯滤波】",&g\_nGaussianBlurValue, 40,on\_GaussianBlur ); 
> 85.  on\_GaussianBlur(g\_nGaussianBlurValue,0); 
> 86. //================================================
> 87. 
> 88. 
> 89. //输出一些帮助信息
> 90.  cout<<endl<<"\\t嗯。好了，请调整滚动条观察图像效果~\\n\\n"
> 91.  <<"\\t按下“q”键时，程序退出~!\\n"
> 92.  <<"\\n\\n\\t\\t\\t\\tby浅墨"; 
> 93. 
> 94. //按下“q”键时，程序退出
> 95. **while**(**char**(waitKey(1))!= 'q') \{\} 
> 96. 
> 97. **return** 0; 
> 98. \} 
> 99. 
> 100. 
> 101. //-----------------------------【on\_BoxFilter( )函数】------------------------------------
> 102. // 描述：方框滤波操作的回调函数
> 103. //-----------------------------------------------------------------------------------------------
> 104. **static****void** on\_BoxFilter(**int**, **void** \*) 
> 105. \{ 
> 106. //方框滤波操作
> 107.  boxFilter(g\_srcImage, g\_dstImage1, -1,Size( g\_nBoxFilterValue+1, g\_nBoxFilterValue+1)); 
> 108. //显示窗口
> 109.  imshow("【<1>方框滤波】", g\_dstImage1); 
> 110. \} 
> 111. 
> 112. 
> 113. //-----------------------------【on\_MeanBlur( )函数】------------------------------------
> 114. // 描述：均值滤波操作的回调函数
> 115. //-----------------------------------------------------------------------------------------------
> 116. **static****void** on\_MeanBlur(**int**, **void** \*) 
> 117. \{ 
> 118. //均值滤波操作
> 119.  blur(g\_srcImage, g\_dstImage2, Size( g\_nMeanBlurValue+1, g\_nMeanBlurValue+1),Point(-1,-1)); 
> 120. //显示窗口
> 121.  imshow("【<2>均值滤波】", g\_dstImage2); 
> 122. \} 
> 123. 
> 124. 
> 125. //-----------------------------【on\_GaussianBlur( )函数】------------------------------------
> 126. // 描述：高斯滤波操作的回调函数
> 127. //-----------------------------------------------------------------------------------------------
> 128. **static****void** on\_GaussianBlur(**int**, **void** \*) 
> 129. \{ 
> 130. //高斯滤波操作
> 131.  GaussianBlur(g\_srcImage, g\_dstImage3, Size( g\_nGaussianBlurValue\*2+1,g\_nGaussianBlurValue\*2+1 ), 0, 0); 
> 132. //显示窗口
> 133.  imshow("【<3>高斯滤波】", g\_dstImage3); 
> 134. \} 
> 
>   
> 
> 
> 最后是一些运行截图，原图：
> 
> ![SouthEast 14][]
> 
>  方框滤波：
> 
> ![SouthEast 15][]  
> 
> 
> 均值滤波：
> 
> ![SouthEast 16][]  
> 
> 
> 高斯滤波：
> 
> ![SouthEast 17][]  
> 
> 
> 本篇文章到这里就基本结束了，最后放出文章配套示例程序的打包下载地址（共四个程序），
> 
> 本篇文章的配套源代码请点击这里下载：
> 
>   
> 
> 
> [【浅墨OpenCV入门教程之八】配套源代码下载][OpenCV]
> 
> OK，今天的内容大概就是这些，我们下篇文章见：）

## ![SouthEast 18][] ##

[http_blog.csdn.net_poem_qianmo_article_details_22745559]: http://blog.csdn.net/poem_qianmo/article/details/22745559
[happylifemxy_163.com]: mailto:happylifemxy@163.com
[SouthEast]: /images/20220805/49d4dd87963742188d2d123f2ef82f6b.png
[SouthEast 1]: /images/20220805/b726b089e04f4b22917eaa6705a22ccf.png
[SouthEast 2]: https://img-blog.csdn.net/20140401182658000?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcG9lbV9xaWFubW8=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast
[SouthEast 3]: /images/20220805/411a27de30af488aa1213c95fb56526a.png
[SouthEast 4]: /images/20220805/cdf68939cb40484eab7f8cddb6bac4e8.png
[SouthEast 5]: /images/20220805/f98d99d8c55446e3a3ce73a5a399adb8.png
[view plain]: http://blog.csdn.net/poem_qianmo/article/details/22745559#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/269362
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/269362/fork
[SouthEast 6]: /images/20220805/5d5b8017bb664450b38825af78730f0c.png
[SouthEast 7]: /images/20220805/e68bc6d6abdc4d55a1e733f9e727e952.png
[SouthEast 8]: /images/20220805/750efbf9bc854c34ae082e6d4eb045b9.png
[SouthEast 9]: /images/20220805/3d4d983a7a034ff19857a6889fb7dda5.png
[SouthEast 10]: /images/20220805/42637169e25d477a935ac4f91b1c26f3.png
[SouthEast 11]: /images/20220805/01ef7f26f69041a2b3ac07c0a7c0bd67.png
[SouthEast 12]: /images/20220805/3335c781c5f14eebaa17445b171fedf0.png
[SouthEast 13]: /images/20220805/dfe3c0b613bb48fcab6fbceebb5e89fd.png
[SouthEast 14]: /images/20220805/2d8c1e9eeccb47d0b7dae2cb54f85ba6.png
[SouthEast 15]: /images/20220805/5f3f9cf026a24d32beea76d0adeb9b1d.png
[SouthEast 16]: /images/20220805/cc2c119de2a7453297601a0126892705.png
[SouthEast 17]: /images/20220805/54f69d812b9e4e608b5c35091d7228b3.png
[OpenCV]: http://download.csdn.net/detail/zhmxy555/7131549
[SouthEast 18]: /images/20220805/d98ea67a25ff49ac9f350e250bcda5bc.png