11、边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑

一、关于边缘检测

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

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

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

二、canny算子

　　最优边缘检测的三个主要评价标准:

1.低错误率: 标识出尽可能多的实际边缘，同时尽可能的减少噪声产生的误报。
2.高定位性: 标识出的边缘要与图像中的实际边缘尽可能接近。
3.最小响应: 图像中的边缘只能标识一次，并且可能存在的图像噪声不应标识为边缘。

1、Canny 边缘检测的步骤

1.消除噪声。 一般情况下，使用高斯平滑滤波器卷积降噪。
2.计算梯度幅值和方向。 
3.非极大值抑制。 这一步排除非边缘像素， 仅仅保留了一些细线条(候选边缘)。
4.滞后阈值。最后一步，Canny 使用了滞后阈值，滞后阈值需要两个阈值(高阈值和低阈值):

 

关于更多canny算子的细节，可以参看下列文章：

 

　　http://en.wikipedia.org/wiki/Canny_edge_detector

　　http://blog.csdn.net/likezhaobin/article/details/6892176

　　http://zh.wikipedia.org/wiki/Canny%E7%AE%97%E5%AD%90

　　https://blog.csdn.net/poem_qianmo/article/details/25560901

2、Canny函数详解

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

C++: void Canny(InputArray image,OutputArray edges, double threshold1, double threshold2, int apertureSize=3,bool L2gradient=false )

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

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

调用示例：

1 //载入原始图 
2        Mat src = imread("1.jpg");  //工程目录下应该有一张名为1.jpg的素材图
3        Canny(src, src, 3, 9,3 );
4        imshow("【效果图】Canny边缘检测", src);

完整示例：

 1 #include <opencv2/opencv.hpp>
 2 #include<opencv2/highgui/highgui.hpp>
 3 #include<opencv2/imgproc/imgproc.hpp>
 4 
 5 using namespace cv;
 6 
 7 int main( )
 8 {
 9     //载入原始图
10     Mat src = imread("1.jpg");  //工程目录下应该有一张名为1.jpg的素材图
11     Mat src1=src.clone();
12 
13     //显示原始图
14     imshow("【原始图】Canny边缘检测", src);
15 
16     //最简单的canny用法，拿到原图后直接用。
17     Canny( src, src, 150, 100,3 );
18     imshow("【效果图】Canny边缘检测", src);
19     imwrite("边缘检测.jpg", src);
20 
21     //    二、高阶的canny用法，转成灰度图，降噪，用canny，最后将得到的边缘作为掩码，拷贝原图到效果图上，得到彩色的边缘图
22     Mat dst,edge,gray;
23 
24     // 【1】创建与src同类型和大小的矩阵(dst)
25     dst.create( src1.size(), src1.type() );
26 
27     // 【2】将原图像转换为灰度图像
28     cvtColor( src1, gray, CV_BGR2GRAY );
29 
30     // 【3】先用使用3x3内核来降噪(均值滤波)
31     blur( gray, edge, Size(3,3) );
32 
33     // 【4】运行Canny算子
34     Canny( edge, edge, 3, 9,3 );
35 
36     //【5】将g_dstImage内的所有元素设置为0
37     dst = Scalar::all(0);
38 
39     //【6】使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
40     src1.copyTo( dst, edge);
41 
42     //【7】显示效果图
43     imshow("【效果图】Canny边缘检测2", dst);
44     imwrite("边缘检测2.jpg", dst);
45 
46     waitKey(0);
47 
48     return 0;
49 }

效果展示：

　　　　　　　　原图　　　　　　　　　　　　　　　　边缘检测  　　　　　　　　　　　　　　　　边缘检测2

     

三、sobel算子

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

1、sobel算子的计算过程

（1）分别在x和y两个方向求导。

（2）在图像的每一点，结合以上两个结果求出近似梯度。

更多细节参见：

　　http://zh.wikipedia.org/wiki/%E7%B4%A2%E8%B2%9D%E7%88%BE%E7%AE%97%E5%AD%90

　　http://www.cnblogs.com/lancidie/archive/2011/07/17/2108885.html

2、Sobel函数详解

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

 1 C++: void Sobel (
 2 InputArray src,//输入图
 3  OutputArray dst,//输出图
 4  int ddepth,//输出图像的深度
 5  int dx,
 6  int dy,
 7  int ksize=3,
 8  double scale=1,
 9  double delta=0,
10  int borderType=BORDER_DEFAULT );

 1     第一个参数，InputArray 类型的src，为输入图像，填Mat类型即可。
 2     第二个参数，OutputArray类型的dst，即目标图像，函数的输出参数，需要和源图片有一样的尺寸和类型。
 3     第三个参数，int类型的ddepth，输出图像的深度，支持如下src.depth()和ddepth的组合：
 4 
 5         若src.depth() = CV_8U, 取ddepth =-1/CV_16S/CV_32F/CV_64F
 6         若src.depth() = CV_16U/CV_16S, 取ddepth =-1/CV_32F/CV_64F
 7         若src.depth() = CV_32F, 取ddepth =-1/CV_32F/CV_64F
 8         若src.depth() = CV_64F, 取ddepth = -1/CV_64F
 9 
10     第四个参数，int类型dx，x 方向上的差分阶数。
11     第五个参数，int类型dy，y方向上的差分阶数。
12     第六个参数，int类型ksize，有默认值3，表示Sobel核的大小;必须取1，3，5或7。
13     第七个参数，double类型的scale，计算导数值时可选的缩放因子，默认值是1，表示默认情况下是没有应用缩放的。我们可以在文档中查阅getDerivKernels的相关介绍，来得到这个参数的更多信息。
14     第八个参数，double类型的delta，表示在结果存入目标图（第二个参数dst）之前可选的delta值，有默认值0。
15     第九个参数， int类型的borderType，我们的老朋友了（万年是最后一个参数），边界模式，默认值为BORDER_DEFAULT。这个参数可以在官方文档中borderInterpolate处得到更详细的信息。

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

示例：

 1 #include <opencv2/opencv.hpp>
 2 #include<opencv2/highgui/highgui.hpp>
 3 #include<opencv2/imgproc/imgproc.hpp>
 4 
 5 using namespace cv;
 6 
 7 int main( )
 8 {
 9     //【0】创建 grad_x 和 grad_y 矩阵
10     Mat grad_x, grad_y;
11     Mat abs_grad_x, abs_grad_y,dst;
12 
13     //【1】载入原始图
14     Mat src = imread("1.jpg");  //工程目录下应该有一张名为1.jpg的素材图
15 
16     //【2】显示原始图
17     imshow("【原始图】sobel边缘检测", src);
18 
19     //【3】求 X方向梯度
20     Sobel( src, grad_x, CV_16S, 1, 0, 3, 1, 1, BORDER_DEFAULT );
21     convertScaleAbs( grad_x, abs_grad_x );
22     imshow("【效果图】 X方向Sobel", abs_grad_x);
23     imwrite("X方向.jpg", abs_grad_x);
24 
25     //【4】求Y方向梯度
26     Sobel( src, grad_y, CV_16S, 0, 1, 3, 1, 1, BORDER_DEFAULT );
27     convertScaleAbs( grad_y, abs_grad_y );
28     imshow("【效果图】Y方向Sobel", abs_grad_y);
29     imwrite("Y方向.jpg", abs_grad_y);
30     //【5】合并梯度(近似)
31     addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, dst );
32     imshow("【效果图】整体方向Sobel", dst);
33     imwrite("整体方向.jpg", dst);
34 
35     waitKey(0);
36     return 0;
37 }

效果展示：

　　　　　　　　原图　　　　　　　　　　　　　　　　X方向  　　　　　　　　　　　　　　　　

   

　　　　　　　　Y方向　　　　　　　　　　　　　　    整体方向

   

四、Laplace算子

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

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

　　(1) f的拉普拉斯算子也是笛卡儿坐标系xi中的所有非混合二阶偏导数求和：

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

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

 更多细节参见：

　　http://www.cnblogs.com/xfzhang/archive/2011/01/19/1939020.html

　　http://zh.wikipedia.org/wiki/%E6%8B%89%E6%99%AE%E6%8B%89%E6%96%AF%E7%AE%97%E5%AD%90

2、Laplacian函数详解

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

1 C++: void Laplacian(InputArray src,OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, intborderType=BORDER_DEFAULT );

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

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

示例：

 1 #include <opencv2/opencv.hpp>
 2 #include<opencv2/highgui/highgui.hpp>
 3 #include<opencv2/imgproc/imgproc.hpp>
 4 
 5 using namespace cv;
 6 
 7 int main( )
 8 {
 9     //【0】变量的定义
10     Mat src,src_gray,dst, abs_dst;
11 
12     //【1】载入原始图
13     src = imread("1.jpg");  //工程目录下应该有一张名为1.jpg的素材图
14 
15     //【2】显示原始图
16     imshow("【原始图】图像Laplace变换", src);
17 
18     //【3】使用高斯滤波消除噪声
19     GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
20 
21     //【4】转换为灰度图
22     cvtColor( src, src_gray, CV_RGB2GRAY );
23 
24     //【5】使用Laplace函数
25     Laplacian( src_gray, dst, CV_16S, 3, 1, 0, BORDER_DEFAULT );
26 
27     //【6】计算绝对值，并将结果转换成8位
28     convertScaleAbs( dst, abs_dst );
29 
30     //【7】显示效果图
31     imshow( "【效果图】图像Laplace变换", abs_dst );
32     imwrite("Laplace变换.jpg", abs_dst);
33 
34     waitKey(0);
35 
36     return 0;
37 }

效果展示：

　　　　　　　　原图                                                    Laplace变换

   

五、scharr滤波器

1、Scharr函数详解

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

1 C++: void Scharr(
2 InputArray src, //源图
3  OutputArray dst, //目标图
4  int ddepth,//图像深度
5  int dx,// x方向上的差分阶数
6  int dy,//y方向上的差分阶数
7  double scale=1,//缩放因子
8  double delta=0,// delta值
9  intborderType=BORDER_DEFAULT )// 边界模式

 1     第一个参数，InputArray 类型的src，为输入图像，填Mat类型即可。
 2     第二个参数，OutputArray类型的dst，即目标图像，函数的输出参数，需要和源图片有一样的尺寸和类型。
 3     第三个参数，int类型的ddepth，输出图像的深度，支持如下src.depth()和ddepth的组合：
 4 
 5         若src.depth() = CV_8U, 取ddepth =-1/CV_16S/CV_32F/CV_64F
 6         若src.depth() = CV_16U/CV_16S, 取ddepth =-1/CV_32F/CV_64F
 7         若src.depth() = CV_32F, 取ddepth =-1/CV_32F/CV_64F
 8         若src.depth() = CV_64F, 取ddepth = -1/CV_64F
 9 
10     第四个参数，int类型dx，x方向上的差分阶数。
11     第五个参数，int类型dy，y方向上的差分阶数。
12     第六个参数，double类型的scale，计算导数值时可选的缩放因子，默认值是1，表示默认情况下是没有应用缩放的。我们可以在文档中查阅getDerivKernels的相关介绍，来得到这个参数的更多信息。
13     第七个参数，double类型的delta，表示在结果存入目标图（第二个参数dst）之前可选的delta值，有默认值0。
14     第八个参数， 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);

示例：

 1 #include <opencv2/opencv.hpp>
 2 #include<opencv2/highgui/highgui.hpp>
 3 #include<opencv2/imgproc/imgproc.hpp>
 4 
 5 using namespace cv;
 6 
 7 int main( )
 8 {
 9     //【0】创建 grad_x 和 grad_y 矩阵
10     Mat grad_x, grad_y;
11     Mat abs_grad_x, abs_grad_y,dst;
12 
13     //【1】载入原始图
14     Mat src = imread("1.jpg");  //工程目录下应该有一张名为1.jpg的素材图
15 
16     //【2】显示原始图
17     imshow("【原始图】Scharr滤波器", src);
18 
19     //【3】求 X方向梯度
20     Scharr( src, grad_x, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT );
21     convertScaleAbs( grad_x, abs_grad_x );
22     imshow("【效果图】 X方向Scharr", abs_grad_x);
23     imwrite("X方向.jpg", abs_grad_x);
24 
25     //【4】求Y方向梯度
26     Scharr( src, grad_y, CV_16S, 0, 1, 1, 0, BORDER_DEFAULT );
27     convertScaleAbs( grad_y, abs_grad_y );
28     imshow("【效果图】Y方向Scharr", abs_grad_y);
29     imwrite("Y方向.jpg", abs_grad_y);
30 
31     //【5】合并梯度(近似)
32     addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, dst );
33 
34     //【6】显示效果图
35     imshow("【效果图】合并梯度后Scharr", dst);
36     imwrite("Scharr.jpg", dst);
37 
38     waitKey(0);
39     return 0;
40 }

六、综合示例

  1 #include <opencv2/highgui/highgui.hpp>
  2 #include <opencv2/imgproc/imgproc.hpp>
  3 #include <iostream>
  4 
  5 using namespace std;
  6 using namespace cv;
  7 
  8 //原图，原图的灰度版，目标图
  9 Mat g_srcImage, g_srcGrayImage,g_dstImage;
 10 
 11 //Canny边缘检测相关变量
 12 Mat g_cannyDetectedEdges;
 13 int g_cannyLowThreshold=1;//TrackBar位置参数
 14 
 15 //Sobel边缘检测相关变量
 16 Mat g_sobelGradient_X, g_sobelGradient_Y;
 17 Mat g_sobelAbsGradient_X, g_sobelAbsGradient_Y;
 18 int g_sobelKernelSize=1;//TrackBar位置参数
 19 
 20 //Scharr滤波器相关变量
 21 Mat g_scharrGradient_X, g_scharrGradient_Y;
 22 Mat g_scharrAbsGradient_X, g_scharrAbsGradient_Y;
 23 
 24 static void ShowHelpText( );
 25 static void on_Canny(int, void*);//Canny边缘检测窗口滚动条的回调函数
 26 static void on_Sobel(int, void*);//Sobel边缘检测窗口滚动条的回调函数
 27 void Scharr( );//封装了Scharr边缘检测相关代码的函数
 28 
 29 int main( int argc, char** argv )
 30 {
 31     //显示欢迎语
 32     ShowHelpText();
 33 
 34     //载入原图
 35     g_srcImage = imread("1.jpg");
 36     if( !g_srcImage.data )
 37     {
 38         cout << "载入错误！" << endl;
 39         return false;
 40     }
 41     //显示原始图
 42     namedWindow("【原始图】");
 43     imshow("【原始图】", g_srcImage);
 44 
 45     // 创建与src同类型和大小的矩阵(dst)
 46     g_dstImage.create( g_srcImage.size(), g_srcImage.type() );
 47 
 48     // 将原图像转换为灰度图像
 49     cvtColor( g_srcImage, g_srcGrayImage, CV_BGR2GRAY );
 50 
 51     // 创建显示窗口
 52     namedWindow( "【效果图】Canny边缘检测", CV_WINDOW_AUTOSIZE );
 53     namedWindow( "【效果图】Sobel边缘检测", CV_WINDOW_AUTOSIZE );
 54 
 55     // 创建trackbar
 56     createTrackbar( "参数值：", "【效果图】Canny边缘检测", &g_cannyLowThreshold, 120, on_Canny );
 57     createTrackbar( "参数值：", "【效果图】Sobel边缘检测", &g_sobelKernelSize, 3, on_Sobel );
 58 
 59     // 调用回调函数
 60     on_Canny(0, 0);
 61     on_Sobel(0, 0);
 62 
 63     //调用封装了Scharr边缘检测代码的函数
 64     Scharr( );
 65 
 66     //轮询获取按键信息，若按下Q，程序退出
 67     while((char(waitKey(1)) != 'q')) {}
 68 
 69     return 0;
 70 }
 71 
 72 static void ShowHelpText()
 73 {
 74     //输出一些帮助信息
 75     cout << "\n\n\t嗯。运行成功，请调整滚动条观察图像效果~\n\n"
 76         "\t按下“q”键时，程序退出~!\n"
 77         "\n\n\t\t\t";
 78 }
 79 
 80 void on_Canny(int, void*)
 81 {
 82     // 先使用 3x3内核来降噪
 83     blur( g_srcGrayImage, g_cannyDetectedEdges, Size(3,3) );
 84 
 85     // 运行我们的Canny算子
 86     Canny( g_cannyDetectedEdges, g_cannyDetectedEdges, g_cannyLowThreshold, g_cannyLowThreshold*3, 3 );
 87 
 88     //先将g_dstImage内的所有元素设置为0
 89     g_dstImage = Scalar::all(0);
 90 
 91     //使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
 92     g_srcImage.copyTo( g_dstImage, g_cannyDetectedEdges);
 93 
 94     //显示效果图
 95     imshow( "【效果图】Canny边缘检测", g_dstImage );
 96 }
 97 
 98 void on_Sobel(int, void*)
 99 {
100     // 求 X方向梯度
101     Sobel( g_srcImage, g_sobelGradient_X, CV_16S, 1, 0, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
102     convertScaleAbs( g_sobelGradient_X, g_sobelAbsGradient_X );//计算绝对值，并将结果转换成8位
103 
104     // 求Y方向梯度
105     Sobel( g_srcImage, g_sobelGradient_Y, CV_16S, 0, 1, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
106     convertScaleAbs( g_sobelGradient_Y, g_sobelAbsGradient_Y );//计算绝对值，并将结果转换成8位
107 
108     // 合并梯度
109     addWeighted( g_sobelAbsGradient_X, 0.5, g_sobelAbsGradient_Y, 0.5, 0, g_dstImage );
110 
111     //显示效果图
112     imshow("【效果图】Sobel边缘检测", g_dstImage);
113 
114 }
115 
116 void Scharr( )
117 {
118     // 求 X方向梯度
119     Scharr( g_srcImage, g_scharrGradient_X, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT );
120     convertScaleAbs( g_scharrGradient_X, g_scharrAbsGradient_X );//计算绝对值，并将结果转换成8位
121 
122     // 求Y方向梯度
123     Scharr( g_srcImage, g_scharrGradient_Y, CV_16S, 0, 1, 1, 0, BORDER_DEFAULT );
124     convertScaleAbs( g_scharrGradient_Y, g_scharrAbsGradient_Y );//计算绝对值，并将结果转换成8位
125 
126     // 合并梯度
127     addWeighted( g_scharrAbsGradient_X, 0.5, g_scharrAbsGradient_Y, 0.5, 0, g_dstImage );
128 
129     //显示效果图
130     imshow("【效果图】Scharr滤波器", g_dstImage);
131 }