学习 opencv---(11)OpenC 边缘检测：Canny算子，Sobel算子，Laplace算子，Scharr滤波器

本篇文章中，我们将一起学习OpenCV中边缘检测的各种算子和滤波器——Canny算子,Sobel算子,Laplace算子以及Scharr滤波器。文章中包含了五个浅墨为大家准备的详细注释的博文配套源代码。在介绍四块知识点的时候分别一个，以及最后的综合示例中的一个。文章末尾提供配套源代码的下载。

**** 给大家分享一个OpenCv中写代码是节约时间的小常识。其实OpenCv中，不用nameWindow,直接imshow就可以显示出窗口。大家看下文的示例代码就可以发现，浅墨在写代码的时候并没有用namedWindow，遇到想显示出来的Mat变量直接imshow。我们一般是为了规范，才先用namedWindow创建窗口，再imshow出它来，因为我们还有需要用到指定窗口名称的地方，比如用到trackbar的时候。而一般情况想显示一个Mat变量的图片的话，直接imshow就可以啦。

一、关于边缘检测

在具体介绍之前，先来一起看看边缘检测的一般步骤吧。。

（1）滤波：边缘检测的 算法 主要是基于图像强度的一阶和二阶导数，但导数通常对噪声很敏感，因此必须采用滤波器来改善与噪声有关的边缘检测的性能。常见的滤波方法主要有 高斯滤波，即采用离散化的高斯函数产生一组归一化的高斯核（具体见“高斯滤波原理及其编程离散化实现方法”一文），然后基于高斯核函数对图像灰度矩阵的每一点进行加权和（具体程序见下文）

（2）增强 ：增强边缘 的基础是确定图像各点邻域强度的变化值。增强算法可以将图像灰度点邻域强度值有显著变化的点凸显出来。在具体编程实现时，可通过计算梯度幅值来确定。

（3）检测： 经过增强的图像，往往邻域中有很多点的梯度值比较大，而在特定的应用中，这些点并不是我们想要的找的边缘点，所以应该采用某种方法来对这些点进行取舍。在实际工程中，常用的方法是 通过阈值化方法来检测。

另外，需要注意，下文中讲到的Laplace算子，sobel算子和Scharr算子都是带方向的，所以，示例中我们分别写了X方向,Y方向和最终合成的的效果图。

二、canny算子篇

2.1 canny算子相关理论与概念讲解

2.1.1 canny算子简介

Canny 边缘检测算子是John F.Canny于 1986 年开发出来的一个多级边缘检测算法。更为重要的是 Canny 创立了边缘检测计算理论（Computational theory ofedge detection），解释了这项技术是如何工作的。Canny边缘检测算法以Canny的名字命名，被很多人推崇为当今最优的边缘检测的算法。

其中，Canny 的目标是找到一个最优的边缘检测算法，让我们看一下最优边缘检测的三个主要评价标准:

1 低错误率：标识出尽可能多的实际边缘，同时尽可能的减少噪声产生的误报

2 高定位性： 标识出的边缘要与图像中的实际边缘尽可能接近

3 最小响应： 图像中的边缘只能标识一次，并且可能存在的图像噪声不应标识为边缘

为了满足这些要求，Canny使用了 变分法 ，这是一种寻找满足特定功能的函数的方法。最优检测使用4个指数函数项的和来表示，但是它们非常近似于高斯函数的一阶导数。

2.1.2 Canny 边缘检测的步骤

1   消除噪声。一般情况下，使用高斯平滑滤波器卷积降噪。 如下显示了一个 size = 5 的高斯内核示例:

不能理解还。。。。。。。。。。。。。。

2.计算梯度幅值和方向。（此处按照Sobel滤波器的步骤）

（1）运用一对卷积阵列（分别作用于x和y方向）

（2）使用下列公式计算梯度幅值和方向

梯度方向近似到四个可能角度之一(一般为0, 45, 90, 135)

（3）非极大值抑制。这一步排除非边缘像素，仅仅保留了一些细线条（候选边缘）

（4）滞后阈值。最后一步，Canny使用了滞后阈值，滞后阈值需要两个阈值(高阈值和低阈值):

（1）如果某一像素位置的幅值超过高阈值，该像素被保留为边缘像素

（2）如果某一像素位置的幅值小于低阈值，该像素被排除

（3）如果某一像素位置的幅值在俩个阈值之间，该像素仅仅在连接到一个高于高阈值的像素时被保留

tips：对于Canny函数的使用，推荐的高低阈值比在2:1到3:1之间。

更多的细节，可以参考canny算子的wikipedia：http://en.wikipedia.org/wiki/Canny_edge_detector

发现浅墨大神推荐的俩个网址失效了，改天我会专门 写一节关于Canny的博客。。。。这里暂时先不做过多的理解

2.2 OpenCV中Canny函数详解

Canny函数利用Canny算法来进行图像的边缘检测。

 void Canny(InputArray image,OutputArray edges,double threshold1,

            threshold2,int apertureSize = ,bool L2gradient=false);

• 第一个参数，InputArray类型的image，输入图像，即源图像，填Mat类的对象即可，且需为单通道8位图像。
• 第二个参数，OutputArray类型的edges，输出的边缘图，需要和源图片有一样的尺寸和类型。
• 第三个参数，double类型的threshold1，第一个滞后性阈值。
• 第四个参数，double类型的threshold2，第二个滞后性阈值。
• 第五个参数，int类型的apertureSize，表示应用Sobel算子的孔径大小，其有默认值3。
• 第六个参数，bool类型的L2gradient，一个计算图像梯度幅值的标识，有默认值false。

需要注意的是，这个函数阈值1和阈值2两者的小者用于边缘连接，而大者用来控制强边缘的初始段，推荐的高低阈值比在2:1到3:1之间。

调用示例：

 //载入原始图

 Mat src = imread("1.jpg");

 Canny(src,src,,,);

 imshow("【效果图】Canny边缘检测", src);

如上三句，就有结果出来，非常好用。

2.3 调用Canny函数的实例代码

 #include <opencv2/core/core.hpp>

 #include <opencv2/opencv.hpp>

 #include <opencv2/highgui/highgui.hpp>

 #include <opencv2/imgproc/imgproc.hpp>

 #include <iostream>

 using namespace std;

 using namespace cv;

 /*-------------------------------------------

           【1】Canny算子

 --------------------------------------------*/

 int main()

 {

     //载入原始图

     Mat src = imread("1.jpg");

     Mat src1 = src.clone();

     //Mat src2 = src.clone();

     //显示原始图

     imshow("【原始图】Canny边缘检测", src);

     /*-------------------------------------------

       （1） 最简单的canny用法，拿到原图后直接用

     ---------------------------------------------*/

     Canny(src,src,,,);

     imshow("【效果图】Canny边缘检测", src);

     /*------------------------------------------------------------------------------------------------------------

        (2)高阶的canny用法，转成灰度图，降噪，用Canny,最后得到的边缘作为掩码，拷贝原图到效果图上，得到彩色的边缘图

     --------------------------------------------------------------------------------------------------------------*/

     Mat dst, edge, gray;

     //(1)创建于src 同类型和大小的矩阵（dst）

     dst.create(src1.size(),src1.type());

     //(2)将原图转换为灰度图像

     cvtColor(src1,gray,CV_BGR2GRAY);

     //(3)使用3*3内核来降噪

     blur(gray,edge,Size(,));

     //(4)运行Canny算子

     Canny(edge,edge,,,);

     //(5)将g_dstImage内的所有元素设置为0

     dst = Scalar::all();

     //(6)使用Canny算子输出的边缘图g_cannyDetectEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中

     src1.copyTo(dst,edge);

     //(7)显示效果图

     imshow("【效果图】Canny边缘检测2", dst);

     waitKey();

     return ;

 }

我这里第一个不知道为什么不成功，显示出的是一片黑。。。。。。。。。。（我猜是不是在3版本中不能这样直接用，或者格式不是这样的）

三、sobel算子篇

3.1 sobel算子相关理论与概念讲解

3.1.1 基本概念

sobel 算子是一个主要用做边缘检测的离散微分算子（discrete differentiation operator）.Sobel算子结合了高斯平滑和微分求导，用来计算图像灰度函数的近似梯度。在图像的任何一点使用此算子，将会产生对应的梯度矢量或是其法矢量。

sobel算子相关概念，还可以参看这篇博文：http://www.cnblogs.com/lancidie/archive/2011/07/17/2108885.html

   3.1.2 sobel算子的计算过程

   我们假设被作用图像为 I.然后进行如下的操作：

   

   1  分别在x 和 y 俩个方向求导

    （1）水平变化：将I 与一个奇数大小的内核进行卷积，比如，当内核大小为3时, 的计算结果为:

                                              

（2）垂直变化：将: I 与一个奇数大小的内核进行卷积。比如，当内核大小为3时,  的计算结果为:

2    在图像的每一点，结合以上俩个结果求出近似梯度：

另外有时，也可以用下面更简单的公式代替

3.2 OpenCV中Sobel函数详解

Sobel 函数使用扩展的Sobel 算子，来计算一阶，二阶，三阶或混合图像差分

  void Sobel(InputArray src,//输入图

   OutputArray dst,//输出图

   int ddepth,//输出图像的深度

   int dx,

   int dy,

   int ksize=,

   double scale=,

   double delta=,

   int borderType=BORDER_DEFAULT);

• 第一个参数，InputArray 类型的src，为输入图像，填Mat类型即可。
• 第二个参数，OutputArray类型的dst，即目标图像，函数的输出参数，需要和源图片有一样的尺寸和类型。
• 第三个参数，int类型的ddepth，输出图像的深度，支持如下src.depth()和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

• 第四个参数，int类型dx，x 方向上的差分阶数。
• 第五个参数，int类型dy，y方向上的差分阶数。
• 第六个参数，int类型ksize，有默认值3，表示Sobel核的大小;必须取1，3，5或7。
• 第七个参数，double类型的scale，计算导数值时可选的缩放因子，默认值是1，表示默认情况下是没有应用缩放的。我们可以在文档中查阅getDerivKernels的相关介绍，来得到这个参数的更多信息。
• 第八个参数，double类型的delta，表示在结果存入目标图（第二个参数dst）之前可选的delta值，有默认值0。
• 第九个参数， int类型的borderType，我们的老朋友了（万年是最后一个参数），边界模式，默认值为BORDER_DEFAULT。这个参数可以在官方文档中borderInterpolate处得到更详细的信息。

一般情况下，都是用ksize x ksize内核来计算导数的。然而，有一种特殊情况——当ksize为1时，往往会使用3 x 1或者1 x 3的内核。且这种情况下，并没有进行高斯平滑操作。

一些补充说明：

1 当内核大小为3时，我们的Sobel内核可能产生比较明显的误差（毕竟，Sobel算子只是求取了导数的近似值而已）。为解决这一问题，Opencv提供了Scharr函数，但函数仅作用于大小为3的内核。该函数的运算与Sobel函数一样快，但结果却更加精确，其内核是这样的:

2 因为Sobel算子结合了高斯平滑和分化（differentiation），因此结果会具有更多的抗噪性。大多数情况下，我们使用sobel函数时，取【xorder = 1，yorder = 0，ksize = 3】来计算图像X方向的导数，【xorder = 0，yorder = 1，ksize = 3】来计算图像y方向的导数。

计算图像X方向的导数，取【xorder= 1，yorder = 0，ksize = 3】情况对应的内核：

而计算图像Y方向的导数，取【xorder= 0，yorder = 1，ksize = 3】对应的内核：

3.3 调用Sobel函数的实例代码

调用Sobel 函数的实例代码如下，这里只是教大家如何使用Sobel函数，就没有先用几句cvtColor 将原图转化为灰度图，而是直接用彩色图操作

 int main()

 {

     //【0】创建 grad_x,grad_y 矩阵

     Mat grad_x, grad_y;

     Mat abs_grad_x, abs_grad_y;

     //【1】载入原始图

     Mat src = imread("1.jpg");

     Mat dst;

     //【2】显示原始图

     imshow("【原始图】sobel边缘检测",src);

     //【3】求 x 方向梯度

     Sobel(src,grad_x,CV_16S,,,,,,BORDER_DEFAULT);

     convertScaleAbs(grad_x,abs_grad_x);

     imshow("【效果图】 X方向Sobel",abs_grad_x);

     //【4】求 y 方向梯度

     Sobel(src, grad_y, CV_16S, , , , , , BORDER_DEFAULT);

     convertScaleAbs(grad_y, abs_grad_y);

     imshow("【效果图】 Y方向Sobel", abs_grad_y);

     //【5】合并梯度

     addWeighted(abs_grad_x,0.5,abs_grad_y,0.5,,dst);

     imshow("【效果图】整体方向Sobel", dst);

     waitKey();

     return ;

 }

四、Laplace算子篇

4.1 Laplace算子相关理论与概念讲解

Laplace 算子是n维欧几里德空间中的一个二阶微分算子，定义为梯度grad()的散度div().因此如果f 是二阶可微的实函数，则f的拉普拉斯算子定义为：

（1）f 的拉普拉斯算子也算是笛卡尔坐标系中的所有非混合二阶偏导数求和

（2）作为一个二阶微分算子，拉普拉斯算子把C函数映射到C函数，对于k ≥ 2。表达式(1)（或(2)）定义了一个算子Δ :C(R) → C(R)，或更一般地，定义了一个算子Δ : C(Ω) → C(Ω)，对于任何开集Ω。

根据图像处理的原理我们知道，二阶导数可以用来进行边缘检测。因为图像是“二维”，我们需要在俩个方向进行求导。使用Laplace算子将会使求导过程变得简单

Laplacian 算子的定义:

需要点破的是，由于 Laplacian使用了图像梯度，它内部的代码其实是调用了 Sobel 算子的。

另附一个小tips：让一幅图像减去它的Laplacian可以增强对比度。

关于Laplace算子的相关概念阐述，可以参看这篇博文：http://www.cnblogs.com/xfzhang/archive/2011/01/19/1939020.html

4.2 OpenCV中Laplacian函数详解

Laplacian 函数可以计算出图像经过拉普拉斯变换后的结果

 void Laplacian(InputArray src,OutputArray dst, int ddepth, int ksize=, double scale=, double delta=, intborderType=BORDER_DEFAULT);

• 第一个参数，InputArray类型的image，输入图像，即源图像，填Mat类的对象即可，且需为单通道8位图像。
• 第二个参数，OutputArray类型的edges，输出的边缘图，需要和源图片有一样的尺寸和通道数。
• 第三个参数，int类型的ddept，目标图像的深度。
• 第四个参数，int类型的ksize，用于计算二阶导数的滤波器的孔径尺寸，大小必须为正奇数，且有默认值1。
• 第五个参数，double类型的scale，计算拉普拉斯值的时候可选的比例因子，有默认值1。
• 第六个参数，double类型的delta，表示在结果存入目标图（第二个参数dst）之前可选的delta值，有默认值0。
• 第七个参数， int类型的borderType，边界模式，默认值为BORDER_DEFAULT。这个参数可以在官方文档中borderInterpolate()处得到更详细的信息。

Laplacian( )函数其实主要是利用sobel算子的运算。它通过加上sobel算子运算出的图像x方向和y方向上的导数，来得到我们载入图像的拉普拉斯变换结果。

其中，sobel算子（ksize>1）如下：

而当ksize=1时，Laplacian()函数采用以下3x3的孔径：

4.3 调用Laplacian函数的实例代码

 /*-------------------------------------------

        【3】Laplace算子

 --------------------------------------------*/

 int main()

 {

     //【0】变量的定义

     Mat src,dst, src_gray, abs_dst;

     //【1】载入原始图

     src = imread("1.jpg");

     //【2】显示原始图

     imshow("【原始图】图像Laplace变换",src);

     //【3】使用高斯滤波消除噪声

     GaussianBlur(src,src,Size(,),,,BORDER_DEFAULT);

     //【4】转换为灰度图

     cvtColor(src,src_gray,CV_RGB2GRAY);

     //【5】使用Laplace函数

     Laplacian(src_gray,dst,CV_16S,,,,BORDER_DEFAULT);

     //【6】计算绝对值，并将结果转换成8位

     convertScaleAbs(dst,abs_dst);

     //显示效果图

     imshow("【效果图】图像Laplace变换", abs_dst);

     waitKey();

     return ;

 }

五、scharr滤波器篇

scharr一般我就直接称它为滤波器，而不是算子。上文我们已经讲到，它在OpenCV中主要是配合Sobel算子的运算而存在的,一个万年备胎。让我们直接来看看函数讲解吧。

5.1 OpenCV中Scharr函数详解

使用Scharr滤波器运算符计算x或y方向的图像差分，其实它的参数变量和Sobel基本上是一样的，除了没有ksize核的大小

 void Scharr(InputArray src, //源图

  OutputArray dst, //目标图

  int ddepth,//图像深度

  int dx,// x方向上的差分阶数

  int dy,//y方向上的差分阶数

  double scale=,//缩放因子

  double delta=,// delta值

  intborderType=BORDER_DEFAULT   );// 边界模式

• 第一个参数，InputArray 类型的src，为输入图像，填Mat类型即可。
• 第二个参数，OutputArray类型的dst，即目标图像，函数的输出参数，需要和源图片有一样的尺寸和类型。
• 第三个参数，int类型的ddepth，输出图像的深度，支持如下src.depth()和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

• 第四个参数，int类型dx，x方向上的差分阶数。
• 第五个参数，int类型dy，y方向上的差分阶数。
• 第六个参数，double类型的scale，计算导数值时可选的缩放因子，默认值是1，表示默认情况下是没有应用缩放的。我们可以在文档中查阅getDerivKernels的相关介绍，来得到这个参数的更多信息。
• 第七个参数，double类型的delta，表示在结果存入目标图（第二个参数dst）之前可选的delta值，有默认值0。
• 第八个参数， int类型的borderType，我们的老朋友了（万年是最后一个参数），边界模式，默认值为BORDER_DEFAULT。这个参数可以在官方文档中borderInterpolate处得到更详细的信息。

不难理解，如下两者是等价的：

 Scharr(src, dst, ddepth, dx, dy, scale,delta, borderType); 

 Sobel(src, dst, ddepth, dx, dy, CV_SCHARR,scale, delta, borderType);  

5.2 调用Scharr函数的实例代码

 /*-------------------------------------------

        【4】Scharr滤波器

 --------------------------------------------*/

 int main()

 {

     //【0】创建grad_x和grad_y 矩阵

     Mat grad_x, grad_y;

     Mat dst,abs_grad_x, abs_grad_y;

     //【1】载入原始图

     Mat src = imread("1.jpg");

     //【2】显示原始图

     imshow("【原始图】Scharr滤波器", src);

     //【3】求x 方向梯度

     Scharr(src,grad_x,CV_16S,,,,,BORDER_DEFAULT);

     convertScaleAbs(grad_x,abs_grad_x);

     imshow("【效果图】 X方向Scharr",abs_grad_x);

     //【4】求y 方向梯度

     Scharr(src, grad_y, CV_16S, , , , , BORDER_DEFAULT);

     convertScaleAbs(grad_y, abs_grad_y);

     imshow("【效果图】 Y方向Scharr", abs_grad_y);

     //【5】合并梯度（近似）

     addWeighted(abs_grad_x,0.5,abs_grad_y,0.5,,dst);

     //【6】显示效果图

     imshow("【效果图】合并梯度后Scharr", dst);

     waitKey();

     return ;

 }

六、综合示例篇——在实战中熟稔

 /*------------------------------------------------------------------------

     OpenCV边缘检测：Canny算子，Sobel算子，Laplace算子，Scharr滤波器合辑

 ----------------------------------------------------------------------------*/

 // 全局变量声明

 Mat g_srcImage, g_srcGrayImage, g_dstImage;       //原图，原图的灰度版，目标图

 //Canny边缘检测相关变量

 Mat g_cannyDetectedEdges;

 int g_cannyLowThreshold = ; //trackbar 位置参数

 //Sobel边缘检测相关变量

 Mat g_sobelGradient_X, g_sobelGradient_Y;

 Mat g_sobelAbsGradient_X, g_sobelAbsGradient_Y;

 int g_sobelKernelSize = ;   //trackbar位置参数

 //scharr滤波器相关变量

 Mat g_scharrGradient_X, g_scharrGradient_Y;

 Mat g_scharrAbsGradient_X, g_scharrAbsGradient_Y;

 //全局函数声明

 static void ShowHelpText();

 static void on_Canny(int,void *);    //Canny边缘检测窗口滚动条的回调函数

 static void on_Sobel(int,void *);     //Sobel边缘检测窗口滚动条的回调函数

 void Scharr();      //封装了Scharr边缘检测相关代码的函数

 int main(int argc,char **argv)

 {

     //改变console字体颜色

     system("color 2F");

     //显示欢迎语

     ShowHelpText();

     //载入原图

     g_srcImage = imread("1.jpg");

     if (!g_srcImage.data)

     {

         printf("Oh，no，读取srcImage错误~！ \n");

         return false;

     }

     //显示原始图

     namedWindow("【原始图】");

     imshow("【原始图】", g_srcImage);

     //创建于src同类型和大小的矩阵（dst）

     g_dstImage.create(g_srcImage.size(), g_srcImage.type());

     //将原始图转换为灰度图像

     cvtColor(g_srcImage, g_srcGrayImage, CV_BGR2GRAY);

     //创建显示窗口

     namedWindow("【效果图】Canny边缘检测", CV_WINDOW_AUTOSIZE);

     namedWindow("【效果图】Sobel边缘检测", CV_WINDOW_AUTOSIZE);

     //创建trackbar

     createTrackbar("参数值：", "【效果图】Canny边缘检测", &g_cannyLowThreshold, , on_Canny);

     createTrackbar("参数值：", "【效果图】Sobel边缘检测", &g_sobelKernelSize, , on_Sobel);

     //调用回调函数

     on_Canny(, );

     on_Sobel(, );

     //调用封装了Scharr边缘检测代码的函数

     Scharr();

     //轮询获取按键信息，若按下Q，程序退出

     while ((char(waitKey()) != 'q')) {}

     return ;

 }

 static void ShowHelpText()

 {

     // 输出一些帮助信息

         printf("\n\n\t嗯。运行成功，请调整滚动条观察图像效果~\n\n"

         "\t按下“q”键时，程序退出~!\n"

         "\n\n\t\t\t\t by  hehhehhe");

 }

 //Canny边缘检测窗口滚动条的回调函数

  void on_Canny(int, void *)

 {

     //先使用3*3内核来降噪

     blur(g_srcGrayImage,g_cannyDetectedEdges,Size(,));

     //运行我们的Canny算子

     Canny(g_cannyDetectedEdges,g_cannyDetectedEdges,g_cannyLowThreshold,g_cannyLowThreshold*,);

     //先将g_dstImage内的所有元素设置为0

     g_dstImage = Scalar::all();

     //使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中

     g_srcImage.copyTo(g_dstImage,g_cannyDetectedEdges);

     //显示效果图

     imshow("【效果图】Canny边缘检测", g_dstImage);

 }

 //Sobel边缘检测窗口滚动条的回调函数

  void on_Sobel(int, void *)

 {

     //求X方向梯度

     Sobel(g_srcImage,g_sobelGradient_X,CV_16S,,,(*g_sobelKernelSize+),,,BORDER_DEFAULT);

     convertScaleAbs(g_sobelGradient_X,g_sobelAbsGradient_X);   //计算绝对值，并将结果转换成8位

     //求Y方向梯度

     Sobel(g_srcImage, g_sobelGradient_Y, CV_16S, , , ( * g_sobelKernelSize + ), , , BORDER_DEFAULT);

     convertScaleAbs(g_sobelGradient_Y, g_sobelAbsGradient_Y);   //计算绝对值，并将结果转换成8位

     //合并梯度

     addWeighted(g_sobelAbsGradient_X,0.5,g_sobelAbsGradient_Y, 0.5, , g_dstImage);

     //addWeighted(g_sobelAbsGradient_X, 0.5, g_sobelAbsGradient_Y, 0.5, 0, g_dstImage);

     //显示效果图

     imshow("【效果图】Sobel边缘检测", g_dstImage);

 }

 //封装了Scharr边缘检测相关代码的函数

  void Scharr()

 {

     //求X方向梯度

     Scharr(g_srcImage,g_scharrGradient_X,CV_16S,,,,,BORDER_DEFAULT);

     convertScaleAbs(g_scharrGradient_X,g_scharrAbsGradient_X); //计算绝对值，并将结果转换成8位

     //求Y方向梯度

     Scharr(g_srcImage, g_scharrGradient_Y, CV_16S, , , , , BORDER_DEFAULT);

     convertScaleAbs(g_scharrGradient_Y, g_scharrAbsGradient_Y); //计算绝对值，并将结果转换成8位

     //合并梯度

     addWeighted(g_scharrAbsGradient_X, 0.5, g_scharrAbsGradient_Y, 0.5, , g_dstImage);

     //显示效果图

     imshow("【效果图】Scharr滤波器", g_dstImage);

 }