学习 opencv---(7) 线性邻域滤波专场：方框滤波，均值滤波，高斯滤波

    本篇文章中，我们一起仔细探讨了OpenCV图像处理技术中比较热门的图像滤波操作。图像滤波系列文章浅墨准备花两次更新的时间来讲，此为上篇，为大家剖析了“方框滤波”，“均值滤波”，“高斯滤波”三种常见的邻域滤波操作。而作为非线性滤波的“中值滤波”和“双边滤波”，我们下次再分析。

 因为文章很长，如果详细啃的话，或许会消化不良。在这里给大家一个指引，如果是单单想要掌握这篇文章中讲解的OpenCV线性滤波相关的三个函数：boxFilter,blur 和 GausslanBlur 的使用方法的话，直接看第三部分“浅出”和第四部分“实例”就行。

  在以后写的OpenCV系列文章中，浅墨暂且准备将每篇博文中知识点都分成原理、深入、浅出和实例四大部分来讲解，

   第一部分为和图像处理中线性滤波相关的理论，第二部分“深入”部分主要深入opencv内部，带领大家领略opencv开源的魅力，进行opencv 相关源码的剖析，做到对opencv深刻理解，做一个高端大气的opencv使用者，第三部分“浅出”主要教会大家如何快速上手当前文章中介绍的相关opencvAPI 函数。而在第四部分，浅墨会为大家准备一个和本片文章相关的详细注释的综合实例程序。

   给出本篇万字文章的结构脉络：

      一、理论——相关图像处理概念介绍

      二、深入——OpenCV源码讲解

      三、浅出——API函数讲解

      四、实例——详细注释的博文配套程序

  

  一、理论与概念讲解

   <1>关于平滑处理

 

    “平滑处理”（smoothing）也称“模糊处理”（bluring）,是一项简单且使用频率很高的图像处理方法。平滑处理的用途很多，最常见的是用来减少图像上的噪点或者失真 。在涉及降低图像分辨率时，平滑处理是非常好用的方法。

   

   <2>图像滤波与滤波器

 

    首先我们看一下图像滤波的概念。

    图像滤波：即在尽量保留图像细节特征的条件下对目标图像的噪声进行抑制，是图像处理中不可缺少的操作，其处理效果的好坏将直接影响到后续图像处理和分析的有效性和可靠性。

    消除图像中的噪声成分叫做 图像的平滑化或滤波操作。 信号或图像的能量大部分集中在幅度谱的低频和中频段是很常见的，而在较高频段，感兴趣的信息经常被噪声掩没。因此一个能降低高频成分幅度的滤波器就能减弱噪声的影响。

    图像滤波的目的有俩个：一个是抽出对象的特征作为图像识别的特征模式； 另一个是为适应图像处理的要求，消除图像数字化时所混入的噪声，而对图像处理的要求也有俩条：（1）不能损坏图像的轮廓及边缘等重要信息；（2）使图像清晰视觉效果好

 

    平滑滤波 是低频增强的空间滤波技术。他的目的有俩类：一类是模糊；另一类是消除噪声

    空间域的平滑滤波一般采用简单平均法进行，就是求邻近像元点的平均亮度值。邻域的大小与平滑的效果直接相关，邻域越大平滑的效果越好，但邻域过大，平滑会使边缘信息损失的越大，从而使输出的图像变得模糊，因此需合理选择邻域的大小。

   关于滤波器，一种形象的比喻法是：我们可以把滤波器想象成一个包含加权系数的窗口，当使用这个滤波器平滑处理图像时，就把这个窗口放到图像之上，透过这个窗口来看我们得到的图像。

    滤波器的种类有很多， 在新版本的OpenCV中，提供了如下五种常用的图像平滑处理操作方法，且他们分别被封装在单独的函数中，使用起来非常方便： 

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

 

   今天我们要讲解的是作为线性滤波的方框滤波，均值滤波和高斯滤波。两种非线性滤波操作——中值滤波和双边滤波，我们留待下次讲解

  

    

   <3>对线性滤波器的简介

    线性滤波器：经常用于剔除输入信号中不想要的频率或者从许多频率中选择一个想要的频率。

   几种常见的线性滤波器：

    ----允许低频率通过的低通滤波器

    ----允许高频率通过的高通滤波器

    ----允许一定范围频率通过的带通滤波器

    ----阻止一定范围频率通过并且允许其它频率通过的带阻滤波器

    ----允许所有频率通过，仅仅改变相位关系的全通滤波器

    ----阻止一个狭窄频率范围通过的特殊带阻滤波器，陷波滤波器（band-stop filter）

 

   

 

  

   <4>关于滤波和模糊  

    关于滤波和模糊，大家往往在初次接触的时候会弄混淆，“一会儿说滤波，一会儿又说模糊，什么玩意儿啊”

 

    没关系，在这里，我们就来辨别一下，为大家扫清障碍。

 

     我们上文已经提到过，滤波是将信号中特定波段频率滤除的操作，是抑制和防止干扰的一项重要措施。

    为了方便说明，就拿我们经常用的高斯滤波来作例子吧。我们知道，滤波可分低通滤波和高通滤波两种。而高斯滤波是指用高斯函数作为滤波函数的滤波操作，至于是不是模糊，要看是高斯低通还是高斯高通，低通就是模糊，高通就是锐化。

   其实说白了是很简单的，对吧：

    高斯滤波是指用高斯函数作为滤波函数的滤波操作。

    高斯模糊就是高斯低通滤波。

 

   

  

  <5>邻域算子与线性邻域滤波

 

    邻域算子（局部算子）是利用给定像素周围的像素值的决定此像素的最终输出值的一种算子。而线性邻域滤波是一种常用的邻域算子，像素的输出值取决于输入像素的加权和，具体过程如下图。

    邻域算子除了用于局部色调调整以外，还可以用于图像滤波，实现图像的平滑和锐化，图像边缘增强或者图像噪声的去除。本篇文章，我们介绍的主角是线性邻域滤波算子，即用不同的权重去结合一个小邻域内的像素，来得到应有的处理效果。

   

 

    图注：邻域滤波（卷积）：左边图像与中间图像的卷积产生右边图像。目标图像中蓝色标记的像素是利用原图像中红色标记的像素计算得到

     线性滤波处理的输出像素值是输入像素值的加权和 :

                                             

     其中的加权和为 ，我们称其为“核”，滤波器的加权系数，即滤波器的“滤波系数”。

      上面的式子可以简单写作：

                                                         

    其中f表示输入像素值，h表示加权系数“核“，g表示输出像素值

      

  在新版本的OpenCV中，提供了如下三种常用的线性滤波操作，他们分别被封装在单独的函数中，使用起来非常方便：

     

   ----方框滤波 boxblur函数

  ----均值滤波  blur函数

  ----高斯滤波  GaussianBlur函数

   

   下面我们来对他们进行一一介绍。

 

   

   <6>方框滤波（box Filter）

    方框滤波（box Filter）被封装在一个名为boxblur的函数中，即boxblur函数的作用是使用方框滤波器（box filter）来模糊一张图片，从src输入，从dst输出。

    函数原型如下：

1 void boxFilter(InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), boolnormalize=true, int boardType=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（）函数方框滤波所用的核为：

                                                               

   其中：

  

 

   其中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函数文档中，给出的其核是这样的：

    

 

       

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

    blur函数的原型：

1 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）高斯滤波的理论简析

    高斯滤波是一种线性平滑滤波，适用于消除高斯噪声，广泛应用于图像处理的减噪过程。通俗的讲，高斯滤波就是对整幅图像进行加权平均的过程，每一个像素点的值，都由其本身和邻域内的其他像素值经过加权平均后得到。高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值 

大家常常说高斯滤波最有用的滤波操作，虽然它用起来，效率往往不是最高的。

高斯模糊技术生成的图像，其视觉效果就像是经过一个半透明屏幕在观察图像，这与镜头焦外成像效果散景以及普通照明阴影中的效果都明显不同。高斯平滑也用于计算机视觉算法中的预先处理阶段，以增强图像在不同比例大小下的图像效果（参见尺度空间表示以及尺度空间实现）。从数学的角度来看，图像的高斯模糊过程就是图像与正态分布做卷积。由于正态分布又叫作高斯分布，所以这项技术就叫作高斯模糊。

图像与圆形方框模糊做卷积将会生成更加精确的焦外成像效果。由于高斯函数的傅立叶变换是另外一个高斯函数，所以高斯模糊对于图像来说就是一个低通滤波操作。

  高斯滤波器是一类根据高斯函数的形状来选择权值的线性平滑滤波器。高斯平滑滤波器对于抑制服从正态分布的噪声非常有效。一维零均值高斯函数为：

                              

 

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

  二维高斯函数为：    

                                              

   

  

   2）在OpenCV中使用高斯滤波——GaussianBlur函数

  GaussianBlur函数的作用是用高斯滤波器来模糊一张图片，对输入的图像src进行高斯滤波后用dst输出。它将源图像和指定的高斯核函数做卷积运算，并且支持就地过滤（In-placefiltering）。

 

1  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源码剖析

   

    <1>OpenCV中boxFilter函数源码解析

    我们可以在OpenCV的安装路径的\sources\modules\imgproc\src下的smooth.cpp源文件的第1401行找到boxFilter函数的源代码.

 

 1 /*-------------------------------【boxFilter()函数注释】-------------------------
 2      作用：进行boxFilter 滤波操作的函数
 3      说明：以下代码来自于计算机开源视觉库opencv的官方代码
 4      代码版本：3.1
 5      原文件中的起始行数：1401
 6      copy  by zhao 
 7 */
 8 
 9 void cv::boxFilter(InputArray _src,OutputArray _dst, int ddepth,Size ksize,Point anchor,bool normalize,int borderType )
10 {
11       CV_OCL_RUN(_dst.isUMat(), ocl_boxFilter(_src, _dst, ddepth, ksize, anchor, borderType, normalize))
12       //这里先忽略这句，因为要查找他的源头，但我这里的源码工程还没有cmake好，还不能找到在哪里。so I don't know.
13         
14         Mat src = _src.getMat();    //拷贝源图的形参Mat数据到临时变量，用于稍后的操作
15         //定义int型临时变量，代表源图深度的sdepth,源图通道的引用cn ,type类型，这里全部用宏封装好了。
16         int stype = src.type(), sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype);
17         //处理ddepth小于零的情况
18         if(ddepth<0)
19                 ddepth = sdepth;
20                 _dst.create( src.size(),CV_MAKETYPE(ddepth, cn));    //初始化目标图
21         
22             Mat dst = _dst.getMat();  //拷贝源图的形参Mat数据到临时变量，用于稍后的操作
23         //处理boardType 不为BORDER_CONSTANT 且normalize为真的情况
24         if(borderType!= BORDER_CONSTANT && noarmalize)
25             {
26                 if(src.rows == 1)
27                     ksize.height == 1;
28                 if(src.cols == 1)
29                     ksize.width = 1;
30             }
31             
32             //若之前有过HAVE_TEGRA_OPTIMIZAION 优化选项的定义，则执行宏体中的tegra优化版函数并返回
33             #ifdef HAVE_TEGRA_OPTIMIZATION
34                if( tegra::useTegra() && tegra::box(src, dst, ksize, anchor, normalize, borderType) )   //多判断了一个函数
35                    return; 
36             #endif
37 
38 //大概是使用Intel 的IPP库来进行图片数据的优化，加快图片的存取速度，提高滤波的性能                                                  
39         #ifdef HAVE_IPP
40         int ippBorderType = borderType & ~BORDER_ISOLATED;
41     #endif
42             Point ocvAnchor, ippAnchor;
43             ocvAnchor.x = anchor.x < 0 ? ksize.width / 2 : anchor.x;
44             ocvAnchor.y = anchor.y < 0 ? ksize.height / 2 : anchor.y;
45             ippAnchor.x = ksize.width / 2 - (ksize.width % 2 == 0 ? 1 : 0);
46             ippAnchor.y = ksize.height / 2 - (ksize.height % 2 == 0 ? 1 : 0);
47             CV_IPP_RUN((normalize && !_src.isSubmatrix() && ddepth == sdepth &&
48                     (/*ippBorderType == BORDER_REPLICATE ||*/ /* returns ippStsStepErr: Step value is not valid */
49                      ippBorderType == BORDER_CONSTANT) && ocvAnchor == ippAnchor &&
50                      _dst.cols() != ksize.width && _dst.rows() != ksize.height),
51                      ipp_boxfilter( _src,  _dst,  ddepth, ksize,  anchor, normalize,  borderType));
52         
53         //调用FilterEgine滤波引擎，正式开始滤波操作
54         Ptr f = createBoxFilter(src.type(),dst.type(),ksize,anchor,normalize,borderType);
55         
56         f->apply(src,dst);
57 }

 

 

 

  其中的Ptr是用来动态分配的对象的智能指针模板类。可以发现，函数的内部代码思路是很清晰的，先拷贝源图的形参Mat 数据到临时变量，定义一些临时变量，再处理ddepth小于零的情况，接着处理borderType不为 BORDER_CONSTANT 且normalize为真 的情况，最终调用FilterEgine滤波引擎创建一个BoxFilter,正式开始滤波操作

 

   这里的FilterEgine是opencv图像滤波功能的核心引擎，。。。。。。。。

 

  

   <2>FilterEngine类解析——OpenCV图像滤波核心引擎

 

   FilterEgine类是opencv关于图像滤波的主力军类，opencv 图像滤波功能的核心引擎。各种滤波函数，如blur,GaussianBlur,到头来其实就是在函数末尾处定义了一个Ptr类型的f，然后f->apply（src,dst）了一下而已。

   这个类几乎是所有的滤波操作施加到图像上，它包含了所有必要的中间缓存器。有很多和滤波相关的create系函数的返回值直接就是Ptr。比如cv::createSeparableLinearFilter(), cv::createLinearFilter(),cv::createGaussianFilter(), cv::createDerivFilter(),cv::createBoxFilter() 和cv::createMorphologyFilter().，这里给出其中一个函数的原型吧：

 

1 Ptr 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引擎。

  我们看看其类声明经过注释的源码：（这里暂且看浅墨大神的，因为我的还没Cmake好，太难找，费时费力）

 

 1 /*-------------------------FilterEgine类中文注释------------------------------
 2     作用：FilterEgine类，opencv图像滤波功能的核心引擎
 3     来源于计算机开源视觉库opencv
 4 -----------------------------------------------------------------------------*/
 5 
 6 class CV_EXPORTS FilterEgine
 7 {
 8     public:
 9         FilterEgine();     //默认构造函数
10         
11         //完整的构造函数。_filter2D,roefilter 和 _columnfilter之一，必须为非空
12         FilterEgine(const Ptr &_filter2D,
13                                 const Ptr &_rowFilter,
14                                 const Ptr_columnFilter,
15                                 int srcType,int dstType,int buffType,
16                                 int _rowBorderType = BORDER_REPLICATE,
17                                 int _columnBorderType = -1,
18                                 const Scalar &_borderValue = Scalar());
19     
20     virtual ~FilterEgine();   //默认析构函数
21     
22     //重新初始化引擎。释放之前滤波器申请的内存
23     void init(const Ptr &_filter2D,
24                         const Ptr &_rowFilter,
25                         const Ptr_columnFilter,
26                         int srcType,int dstType,int buffType,
27                         int _rowBorderType = BORDER_REPLICATE,
28                         int _columnBorderType = -1,
29                         const Scalar &_borderValue = Scalar() );
30                         
31     virtual int start(Size wholeSize, Rect roi, int maxBufRows=-1);    //开始对指定了ROI区域和尺寸的图片进行滤波操作
32     virtual int start(const Mat &src, const Rect &srcRoi = Rect(0,0,-1,-1),
33                                         bool isolated = false, int maxBufRows=-1);        //开始对指定了ROI区域的图片进行滤波操作
34     virtual int proceed(const uchar *src, int srcStep, int srcCount,
35                                             uchar *dst, int dstStep);                                        //处理图像的下一个srcCount行（函数的第3个参数）
36     virtual void apply(const Mat &src,Mat &dst,
37                                          const Rect &srcRoi=Rect(0,0,-1,-1),
38                                          Point dstOfs=Point(0,0),
39                                          bool isolated=false); //对图像指定的ROI区域进行滤波操作，若srcRoi=Rect(0,0,-1,-1),则对整个图像进行滤波操作
40     bool Separable() const {return (const BaseFilter*)filter2D == 0;};
41     
42     //返回输入和输出行数
43     int remainingInputRows() const;
44     int remainingOutputRows() const;
45     
46     //一些成员函数定义
47     int srcType,dstType,bufType;
48     Size ksize;
49     Point anchor;
50     int maxWidth;
51     Size wholeSize;
52     Rect roi;
53     int dx1,dx2;
54     int rowBorderType,columnBorderType;
55     vector<int> borderTab;
56     int borderElemSize;
57     vector ringBuf;
58     vector srcRow;  
59     vector constBorderValue;  
60     vector constBorderRow;  
61     int bufStep, startY, startY0, endY, rowCount, dstY; 
62     vector rows;
63     
64     Ptr filter2D;
65     Ptr rowFilter;  
66   Ptr columnFilter; 
67 }

 

 

 

 

   <3>OpenCV中size类型剖析

 

   size类型我们也讲一下，通过转到定义，我们可以在……\opencv\sources\modules\core\include\opencv2\core\core.hpp路径下.

 

  其原型声明；

 

1 typedef Size_<int> Size2i;
2 typedef Size2i Size;

 

 

 

  Size_ 是个模板类，在这里Size_ 表示其类体内部的模板所代表的类型为int

  那这俩句的意思，就是首先给已知的数据类型Size_ 起个新名字，叫Size2i.

  然后又给已知的数据类型Size2i起个名字，叫Size.

  所以，连起来就是，Size_、Size2i、Size这三个类型名等价。

  然后我们追根溯源，找到Size_模板类的定义

 

 1 /*--------------------------------【Size_ 类注释】---------------------------
 2    作用：作为尺寸相关数据结构的Size_ 模板类
 3    来源于计算机开源视觉库opencv
 4 ----------------------------------------------------------------------------*/
 5 
 6 template class Size_
 7 {
 8     public _Tp value_type;
 9     
10     //不同的构造函数定义
11     Size_();
12     Size_(_Tp _width, _Tp _height);
13     Size_(const Size_ &sz);
14     Size_(const CvSize &sz);
15     Size_(const CvSize2D32f &sz);
16     Size_(const Point_<_Tp> &pt);
17     
18     Size_ &operator = (const Size_ &sz);
19     
20     _Tp area() const;   //区域（width*height）
21     
22     template operator Size_<_Tp2> const;   //转化另一种数据类型
23     
24     //转化为旧式的opencv类型
25     operator CvSize() const;
26     operator CvSize2D32f() const;  
27     
28     _Tp width,height;      //宽度和高度，常用属性   
29 }

 

 

 

  可以看到Size_模板类的内部又是重载了一些构造函数以满足我们的需要，其中，我们用得最多的是如下这个构造函数：

 

1 Size_(_Tp _width,_Tp _height);

 

 

 

  另外，代码末尾定义了模板类型的宽度和高度：

1 _Tp width, height; //宽度和高度  

 

 

 

  于是我们可以用XXX.width和XXX.height来分别表示其宽度和高度

   给大家一个示例，方便理解： 

1 Size(5,5);  //构造出的Size宽度和高度都为5，即XXX.width和XXX.height都为5 

 

 

 

 

  <4>OpenCV中blur函数源码剖析

 

  我们可以在OpenCV的安装路径的\sources\modules\imgproc\src下的smooth.cpp源文件中找到blur的源代码  

1 void cv::blur( InputArray src, OutputArray dst,
2            Size ksize, Point anchor, int borderType )
3 {
4     //调用boxFilter函数进行处理
5     boxFilter( src, dst, -1, ksize, anchor, true, borderType );
6 }

 

 

 

  可以看到在blur函数内部就是调用了一个boxFilter函数，且第六个参数为true，即我们上文所说的normalize=true，即均值滤波是均一化后的方框滤波。

  

  

  <5>OpenCV中GaussianBlur函数源码剖析

 

 最后，我们看一下OpenCV中GaussianBlur函数源代码：

 

 1 /*-------------------------------【GaussianBlur（）函数中文注释版源代码】------------------------
 2     代码作用：封装高斯滤波的GaussianBlur（）函数  
 3     说明：以下代码为来自于计算机开源视觉库OpenCV的官方源代码  
 4     源码路径：…\opencv\sources\modules\imgproc\src\smooth.cpp  
 5     源文件中如下代码的起始行数：1759行  
 6 --------------------------------------------------------------------------------------------------*/
 7 
 8 void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
 9                    double sigma1, double sigma2,
10                    int borderType )
11 {
12       //3系列和2系列的略有不一样
13     
14     //拷贝形参Mat数据到临时变量，用于稍后的操作 （下面3行） 
15     int type = _src.type();
16     Size size = _src.size();
17     _dst.create( size, type );
18 
19     //处理边界选项不为BORDER_CONSTANT时的情况  
20     if( borderType != BORDER_CONSTANT && (borderType & BORDER_ISOLATED) != 0 )
21     {
22         if( size.height == 1 )
23             ksize.height = 1;
24         if( size.width == 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 
36 //若之前有过HAVE_TEGRA_OPTIMIZATION优化选项的定义，则执行宏体中的tegra优化版函数并返回 
37 #ifdef HAVE_TEGRA_OPTIMIZATION
38     Mat src = _src.getMat();
39     Mat dst = _dst.getMat();
40     if(sigma1 == 0 && sigma2 == 0 && tegra::useTegra() && tegra::gaussian(src, dst, ksize, borderType))
41         return;
42 #endif
43 
44         //变动还挺大的，看来要看一下官方的代码升级的说明了。。。。。。。。。。。。。。。。
45     CV_IPP_RUN(true, ipp_GaussianBlur( _src,  _dst,  ksize, sigma1,  sigma2, borderType));
46 
47     Mat kx, ky;
48     createGaussianKernels(kx, ky, type, ksize, sigma1, sigma2);
49     sepFilter2D(_src, _dst, CV_MAT_DEPTH(type), kx, ky, Point(-1,-1), 0, borderType );
50 }

 

 

 

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

 

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

   这一部分的内容就是为了大家能快速上手boxFilter、blur和GaussianBlur这三个函数所准备的。还等什么呢，开始吧。

 

 

 

  

    <1>boxFilter函数——方框滤波

 

 

 

  boxFilter的函数作用是使用方框滤波（box filter）来模糊一张图片，由src输入，dst输出。

  函数原型如下：  

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

 

 

 

  参数详解前面哟。。。。。。

调用代码示范如下：

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

 

 

 

  用上面三句核心代码架起来的完整程序代码：

 

 1 /*-----------------------【程序说明】------------------------
 2     说明：【方框滤波boxFilter函数的使用示例程序】
 3     使用版本：3.1.0
 4     copy from qianmo
 5     使用体验：字节越大的图片，滤波过程越长，浅墨的大约可能需要半秒，用我的图片要快一点
 6 ---------------------------------------------------------------*/
 7 
 8 #include 
 9 #include 
10 #include 
11 
12 #include 
13 #include 
14 #include 
15 #include 
16 
17 using namespace cv;
18 
19 void main()
20 {
21 
22     clock_t starttime;
23     clock_t endtime;
24 
25     starttime = clock();
26 
27     //载入原图
28     Mat image = imread("3.jpg");
29 
30     //创建窗口
31     namedWindow("方框滤波【原图】");
32     namedWindow("方框滤波【效果图】");
33 
34     //显示原图
35     imshow("方框滤波【原图】",image);
36 
37     //进行方框滤波操作
38     Mat out;
39     boxFilter(image,out,-1,Size(5,5));
40 
41     //显示效果图
42     imshow("方框滤波【效果图】",out);
43 
44     endtime = clock();
45     printf("运行时间：%d\n", endtime - starttime);
46 
47     waitKey();
48 }

 

    

    <2>blur函数——均值滤波

   blur的作用是对输入的图像src进行均值滤波后用dst输出。

  函数原型如下 

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

 

    参数详解前面哟。。。。。。 

    调用代码示范：

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

 

  为了大家的理解和应用方便，还是给出用上面三句核心代码架起来完整程序的代码：

  

 1 #include 
 2 #include 
 3 #include 
 4 
 5 #include 
 6 #include 
 7 #include 
 8 #include 
 9 
10 void main()
11 {
12 
13     clock_t starttime;
14     clock_t endtime;
15 
16     starttime = clock();
17 
18     //载入原图
19     Mat image = imread("3.jpg");
20 
21     //创建窗口
22     namedWindow("均值滤波【原图】");
23     namedWindow("均值滤波【效果图】");
24 
25     //显示原图
26     imshow("均值滤波【原图】", image);
27 
28     //进行方框滤波操作
29     Mat out;
30     blur(image, out, Size(7, 7));
31 
32     //显示效果图
33     imshow("均值滤波【效果图】", out);
34 
35     endtime = clock();
36     printf("运行时间：%d\n", endtime - starttime);
37 
38     waitKey();
39 }

   运行效果图（内核大小Size(7, 7)）：

   

    

  <3>GaussianBlur函数——高斯滤波

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

   函数原型如下：

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

  参数详解前面哟。。。。。。

   调用示例：

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

 

     用上面三句核心代码架起来的完整程序代码：

   

 1 #include 
 2 #include 
 3 #include 
 4 
 5 #include 
 6 #include 
 7 #include 
 8 #include 
 9 
10 void main()
11 {
12 
13     clock_t starttime;
14     clock_t endtime;
15 
16     starttime = clock();
17 
18     //载入原图
19     Mat image = imread("3.jpg");
20 
21     //创建窗口
22     namedWindow("高斯滤波【原图】");
23     namedWindow("高斯滤波【效果图】");
24 
25     //显示原图
26     imshow("高斯滤波【原图】", image);
27 
28     //进行方框滤波操作
29     Mat out;
30     GaussianBlur(image, out, Size(3, 3),0,0);
31 
32     //显示效果图
33     imshow("高斯滤波【效果图】", out);
34 
35     endtime = clock();
36     printf("运行时间：%d\n", endtime - starttime);
37 
38     waitKey();
39 }

  

   

 

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

   这个实例程序中可以用轨迹条来控制三种线性滤波的核参数值，通过滑动滚动条，就可以控制图像在三种线性滤波下的模糊度。

   

  1 Mat g_srcImage, g_dstImage1, g_dstImage2, g_dstImage3;  //存储图片的Mat类型
  2 int g_nBoxFilterValue = 3;    //方框滤波参数值
  3 int g_nMeanBlurValue = 3;      //均值滤波参数值
  4 int g_nGaussianBlurValue = 3;   //高斯滤波参数值
  5 
  6 
  7 //4个轨迹条的回调函数
  8 static void on_BoxFilter(int, void *);      //方框滤波
  9 static void on_MeanBlur(int, void *);       //均值滤波
 10 static void on_GaussianBlur(int, void *);   //高斯滤波
 11 
 12 
 13 /*----------------------【on_BoxFilter()函数】--------------------------
 14    方框滤波的回调函数
 15 ------------------------------------------------------------------------*/
 16 static void on_BoxFilter(int, void*)
 17 {
 18     //方框滤波操作
 19     boxFilter(g_srcImage,g_dstImage1, -1, Size(g_nBoxFilterValue+1,g_nBoxFilterValue+1));
 20     //显示窗口
 21     imshow("【<1>方框滤波】",g_dstImage1);
 22 
 23 }
 24 
 25 
 26 /*----------------------【on_MeanBlur()函数】--------------------------
 27              均值滤波的回调函数
 28 ------------------------------------------------------------------------*/
 29 static void on_MeanBlur(int, void*)
 30 {
 31     //均值滤波操作
 32     blur(g_srcImage, g_dstImage2,Size(g_nBoxFilterValue + 1, g_nBoxFilterValue + 1),Point(-1,-1));
 33     //显示窗口
 34     imshow("【<2>均值滤波】", g_dstImage2);
 35 
 36 }
 37 
 38 /*----------------------【GaussianBlur()函数】--------------------------
 39                  高斯滤波的回调函数
 40 ------------------------------------------------------------------------*/
 41 static void on_GaussianBlur(int, void*)
 42 {
 43     //高斯滤波操作
 44     GaussianBlur(g_srcImage, g_dstImage3, Size(g_nBoxFilterValue * 2 + 1, g_nBoxFilterValue * 2 + 1),0,0);
 45     //显示窗口
 46     imshow("【<3>高斯滤波】", g_dstImage3);
 47 
 48 }
 49 
 50 
 51 int main()
 52 {
 53     //改变console字体颜色
 54     system("color 5E");
 55 
 56     //载入原图
 57     g_srcImage = imread("2.jpg",1);
 58     if (!g_srcImage.data)
 59     {
 60         printf("Oh，no，读取srcImage错误~！ \n");
 61         return false;
 62     }
 63 
 64     //克隆原图到3个Mat类型中
 65     g_dstImage1 = g_srcImage.clone();
 66     g_dstImage2 = g_srcImage.clone();
 67     g_dstImage3 = g_srcImage.clone();
 68 
 69     //显示原图
 70     namedWindow("【<0>原图窗口】",1);
 71     imshow("【<0>原图窗口】",g_srcImage);
 72 
 73     /*---------------------【方框滤波】---------------------*/
 74     //创建窗口
 75     namedWindow("【<1>方框滤波】",1);
 76     //创建轨迹条
 77     createTrackbar("内核值：", "【<1>方框滤波】",&g_nBoxFilterValue,40,on_BoxFilter);
 78     on_BoxFilter(g_nBoxFilterValue,0);
 79     imshow("【<1>方框滤波】",g_dstImage1);
 80 
 81     /*---------------------【均值滤波】---------------------*/
 82     //创建窗口
 83     namedWindow("【<2>均值滤波】", 1);
 84     //创建轨迹条
 85     createTrackbar("内核值：", "【<2>均值滤波】", &g_nMeanBlurValue, 40, on_MeanBlur);
 86     on_MeanBlur(g_nMeanBlurValue, 0);
 87     imshow("【<2>均值滤波】", g_dstImage2);
 88 
 89     /*---------------------【高斯滤波】---------------------*/
 90     //创建窗口
 91     namedWindow("【<3>高斯滤波】", 1);
 92     //创建轨迹条
 93     createTrackbar("内核值：", "【<3>高斯滤波】", &g_nGaussianBlurValue, 40, on_GaussianBlur);
 94     on_GaussianBlur(g_nGaussianBlurValue, 0);
 95     imshow("【<3>高斯滤波】", g_dstImage3);
 96 
 97     //输出一些帮助信息
 98     cout<"\t嗯。好了，请调整滚动条观察图像效果~\n\n"
 99         << "\t按下“q”键时，程序退出~!\n"
100         << "\n\n\t\t\t\t byhehheheh";
101 
102     //按下 q 键时，程序退出
103     while (char(waitKey(1) != 'q'));
104     {}
105 
106     return 0;
107 }

 

转载于:https://www.cnblogs.com/wyuzl/p/6234844.html