OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
2018-03-27 21:02
295 查看
本系列文章由@浅墨_毛星云 出品，转载请注明出处。
文章链接： http://blog.csdn.net/poem_qianmo/article/details/25560901 作者：毛星云（浅墨） 微博：http://weibo.com/u/1723155442 知乎：http://www.zhihu.com/people/mao-xing-yun 邮箱： happylifemxy@163.com
写作当前博文时配套使用的OpenCV版本： 2.4.9
本篇文章中，我们将一起学习OpenCV中边缘检测的各种算子和滤波器——Canny算子,Sobel算子,Laplace算子以及Scharr滤波器。文章中包含了五个浅墨为大家准备的详细注释的博文配套源代码。在介绍四块知识点的时候分别一个，以及最后的综合示例中的一个。文章末尾提供配套源代码的下载。
依然是是放出一些程序运行截图吧：
效果图看完，我们来唠唠嗑。
首先，需要说明的是，浅墨这篇文章最后的示例代码是采用两周前刚刚发布的2.4.9来书写的。里面的lib都已经改成了2.4.9版本的。如果大家需要运行的话，要么配置好2.4.9.要么把浅墨在工程中包含的末尾数字为249的各种lib改成之前的248或者你对应的OpenCV版本。
不然会提示： LINK : fatal error LNK1181: 无法打开输入文件“opencv_calib3d248.lib”之类的错误。
OpenCV 2.4.9的配置和之前的2.4.8差不多，如果还是不太清楚，具体可以参考浅墨修改过的对应2.4.9版的配置文章：
【OpenCV入门教程之一】 安装OpenCV：OpenCV 2.4.8或2.4.9 +VS 开发环境配置
第二，给大家分享一个OpenCV中写代码时节约时间的小常识。其实OpenCV中，不用namedWindow，直接imshow就可以显示出窗口。大家看下文的示例代码就可以发现，浅墨在写代码的时候并没有用namedWindow，遇到想显示出来的Mat变量直接imshow。我们一般是为了规范，才先用namedWindow创建窗口，再imshow出它来，因为我们还有需要用到指定窗口名称的地方，比如用到trackbar的时候。而一般情况想显示一个Mat变量的图片的话，直接imshow就可以啦。
OK，开始正文吧~
4000
在具体介绍之前，先来一起看看边缘检测的一般步骤吧。
1）滤波：边缘检测的算法主要是基于图像强度的一阶和二阶导数，但导数通常对噪声很敏感，因此必须采用滤波器来改善与噪声有关的边缘检测器的性能。常见的滤波方法主要有高斯滤波，即采用离散化的高斯函数产生一组归一化的高斯核（具体见“高斯滤波原理及其编程离散化实现方法”一文），然后基于高斯核函数对图像灰度矩阵的每一点进行加权求和（具体程序实现见下文）。
2）增强：增强边缘的基础是确定图像各点邻域强度的变化值。增强算法可以将图像灰度点邻域强度值有显著变化的点凸显出来。在具体编程实现时，可通过计算梯度幅值来确定。
3）检测：经过增强的图像，往往邻域中有很多点的梯度值比较大，而在特定的应用中，这些点并不是我们要找的边缘点，所以应该采用某种方法来对这些点进行取舍。实际工程中，常用的方法是通过阈值化方法来检测。
另外，需要注意，下文中讲到的Laplace算子，sobel算子和Scharr算子都是带方向的，所以，示例中我们分别写了X方向,Y方向和最终合成的的效果图。
OK，正餐开始，召唤canny算子。：）
其中，Canny 的目标是找到一个最优的边缘检测算法，让我们看一下最优边缘检测的三个主要评价标准:
1.低错误率: 标识出尽可能多的实际边缘，同时尽可能的减少噪声产生的误报。
2.高定位性: 标识出的边缘要与图像中的实际边缘尽可能接近。
3.最小响应: 图像中的边缘只能标识一次，并且可能存在的图像噪声不应标识为边缘。
为了满足这些要求 Canny 使用了变分法，这是一种寻找满足特定功能的函数的方法。最优检测使用四个指数函数项的和表示，但是它非常近似于高斯函数的一阶导数。
2.计算梯度幅值和方向。 此处，按照Sobel滤波器的步骤。
Ⅰ.运用一对卷积阵列 (分别作用于 x 和 y 方向):
Ⅱ.使用下列公式计算梯度幅值和方向:
梯度方向近似到四个可能角度之一(一般为0, 45, 90, 135)
3.非极大值抑制。 这一步排除非边缘像素， 仅仅保留了一些细线条(候选边缘)。
4.滞后阈值。最后一步，Canny 使用了滞后阈值，滞后阈值需要两个阈值(高阈值和低阈值):
Ⅰ.如果某一像素位置的幅值超过 高 阈值, 该像素被保留为边缘像素。
Ⅱ.如果某一像素位置的幅值小于 低 阈值, 该像素被排除。
Ⅲ.如果某一像素位置的幅值在两个阈值之间,该像素仅仅在连接到一个高于 高 阈值的像素时被保留。
tips：对于Canny函数的使用，推荐的高低阈值比在2:1到3:1之间。
更多的细节，可以参考canny算子的wikipedia：
http://en.wikipedia.org/wiki/Canny_edge_detector
canny边缘检测的原理讲述，课参看这篇博文：
http://blog.csdn.net/likezhaobin/article/details/6892176
canny算子的中文wikipedia：
http://zh.wikipedia.org/wiki/Canny%E7%AE%97%E5%AD%90
Canny函数利用Canny算法来进行图像的边缘检测。
[cpp] view plain copyC++: void Canny(InputArray image,OutputArray edges, double threshold1, double threshold2, int apertureSize=3,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之间。
调用示例：
[cpp] view plain copy//载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Canny(src, src, 3, 9,3 );
imshow("【效果图】Canny边缘检测", src);
如上三句，就有结果出来，非常好用。
OpenCV中调用Canny函数的实例代码如下：
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Mat src1=src.clone();
//显示原始图
imshow("【原始图】Canny边缘检测", src);
//----------------------------------------------------------------------------------
// 一、最简单的canny用法，拿到原图后直接用。
//----------------------------------------------------------------------------------
Canny( src, src, 150, 100,3 );
imshow("【效果图】Canny边缘检测", src);
//----------------------------------------------------------------------------------
// 二、高阶的canny用法，转成灰度图，降噪，用canny，最后将得到的边缘作为掩码，拷贝原图到效果图上，得到彩色的边缘图
//----------------------------------------------------------------------------------
Mat dst,edge,gray;
// 【1】创建与src同类型和大小的矩阵(dst)
dst.create( src1.size(), src1.type() );
// 【2】将原图像转换为灰度图像
cvtColor( src1, gray, CV_BGR2GRAY );
// 【3】先用使用 3x3内核来降噪
blur( gray, edge, Size(3,3) );
// 【4】运行Canny算子
Canny( edge, edge, 3, 9,3 );
//【5】将g_dstImage内的所有元素设置为0
dst = Scalar::all(0);
//【6】使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
src1.copyTo( dst, edge);
//【7】显示效果图
imshow("【效果图】Canny边缘检测2", dst);
waitKey(0);
return 0;
}
运行效果图：
sobel算子的wikipedia：
http://zh.wikipedia.org/wiki/%E7%B4%A2%E8%B2%9D%E7%88%BE%E7%AE%97%E5%AD%90
sobel算子相关概念，还可以参看这篇博文：
http://www.cnblogs.com/lancidie/archive/2011/07/17/2108885.html
3.1.2 sobel算子的计算过程
我们假设被作用图像为 I.然后进行如下的操作：
1.分别在x和y两个方向求导。
Ⅰ.水平变化: 将 I 与一个奇数大小的内核
进行卷积。比如，当内核大小为3时,
的计算结果为:
Ⅱ.垂直变化: 将: I 与一个奇数大小的内核
进行卷积。比如，当内核大小为3时,
的计算结果为:
2.在图像的每一点，结合以上两个结果求出近似梯度:
另外有时，也可用下面更简单公式代替:
[cpp] view plain copyC++: void Sobel (
InputArray src,//输入图
OutputArray dst,//输出图
int ddepth,//输出图像的深度
int dx,
int dy,
int ksize=3,
double scale=1,
double delta=0,
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】对应的内核：
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】创建 grad_x 和 grad_y 矩阵
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y,dst;
//【1】载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】sobel边缘检测", src);
//【3】求 X方向梯度
Sobel( src, grad_x, CV_16S, 1, 0, 3, 1, 1, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
imshow("【效果图】 X方向Sobel", abs_grad_x);
//【4】求Y方向梯度
Sobel( src, grad_y, CV_16S, 0, 1, 3, 1, 1, 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, 0, dst );
imshow("【效果图】整体方向Sobel", dst);
waitKey(0);
return 0;
}
运行截图如下：
Laplacian 算子是n维欧几里德空间中的一个二阶微分算子，定义为梯度grad（）的散度div（）。因此如果f是二阶可微的实函数，则f的拉普拉斯算子定义为：
(1) f的拉普拉斯算子也是笛卡儿坐标系xi中的所有非混合二阶偏导数求和：
(2) 作为一个二阶微分算子，拉普拉斯算子把C函数映射到C函数，对于k ≥ 2。表达式(1)（或(2)）定义了一个算子Δ :C(R) → C(R)，或更一般地，定义了一个算子Δ : C(Ω) → C(Ω)，对于任何开集Ω。
根据图像处理的原理我们知道，二阶导数可以用来进行检测边缘 。 因为图像是 “二维”, 我们需要在两个方向进行求导。使用Laplacian算子将会使求导过程变得简单。
Laplacian 算子的定义:
需要点破的是，由于 Laplacian使用了图像梯度，它内部的代码其实是调用了 Sobel 算子的。
另附一个小tips：让一幅图像减去它的Laplacian可以增强对比度。
关于Laplace算子的相关概念阐述，可以参看这篇博文：
http://www.cnblogs.com/xfzhang/archive/2011/01/19/1939020.html
Laplace算子的wikipedia：
http://zh.wikipedia.org/wiki/%E6%8B%89%E6%99%AE%E6%8B%89%E6%96%AF%E7%AE%97%E5%AD%90
[cpp] view plain copyC++: void Laplacian(InputArray src,OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, 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的孔径：
让我们看一看调用实例：
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】变量的定义
Mat src,src_gray,dst, abs_dst;
//【1】载入原始图
src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】图像Laplace变换", src);
//【3】使用高斯滤波消除噪声
GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
//【4】转换为灰度图
cvtColor( src, src_gray, CV_RGB2GRAY );
//【5】使用Laplace函数
Laplacian( src_gray, dst, CV_16S, 3, 1, 0, BORDER_DEFAULT );
//【6】计算绝对值，并将结果转换成8位
convertScaleAbs( dst, abs_dst );
//【7】显示效果图
imshow( "【效果图】图像Laplace变换", abs_dst );
waitKey(0);
return 0;
}
示例效果图：
使用Scharr滤波器运算符计算x或y方向的图像差分。其实它的参数变量和Sobel基本上是一样的，除了没有ksize核的大小。
[cpp] view plain copyC++: void Scharr(
InputArray src, //源图
OutputArray dst, //目标图
int ddepth,//图像深度
int dx,// x方向上的差分阶数
int dy,//y方向上的差分阶数
double scale=1,//缩放因子
double delta=0,// 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处得到更详细的信息。
不难理解，如下两者是等价的：
[cpp] view plain copyScharr(src, dst, ddepth, dx, dy, scale,delta, borderType);
与
[cpp] view plain copySobel(src, dst, ddepth, dx, dy, CV_SCHARR,scale, delta, borderType);
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】创建 grad_x 和 grad_y 矩阵
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y,dst;
//【1】载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】Scharr滤波器", src);
//【3】求 X方向梯度
Scharr( src, grad_x, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
imshow("【效果图】 X方向Scharr", abs_grad_x);
//【4】求Y方向梯度
Scharr( src, grad_y, CV_16S, 0, 1, 1, 0, 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, 0, dst );
//【6】显示效果图
imshow("【效果图】合并梯度后Scharr", dst);
waitKey(0);
return 0;
}
运行效果图：
依然是每篇文章都会配给大家的一个详细注释的博文配套示例程序，把这篇文章中介绍的知识点以代码为载体，展现给大家。
这个示例程序中，分别演示了canny边缘检测，sobel边缘检测，scharr滤波器的使用，那么，上详细注释的代码吧：
[cpp] view plain copy//-----------------------------------【程序说明】----------------------------------------------
// 程序名称:：《【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑合辑》 博文配套源码
// 开发所用IDE版本：Visual Studio 2010
// <span style="white-space:pre;"> </span>开发所用OpenCV版本： 2.4.9
// 2014年5月11日 Create by 浅墨
// 浅墨的微博：@浅墨_毛星云 http://weibo.com/1723155442/profile?topnav=1&wvr=5&user=1
// 浅墨的知乎：http://www.zhihu.com/people/mao-xing-yun
// 浅墨的豆瓣：http://www.douban.com/people/53426472/
//----------------------------------------------------------------------------------------------
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】--------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【全局变量声明部分】--------------------------------------
// 描述：全局变量声明
//-----------------------------------------------------------------------------------------------
//原图，原图的灰度版，目标图
Mat g_srcImage, g_srcGrayImage,g_dstImage;
//Canny边缘检测相关变量
Mat g_cannyDetectedEdges;
int g_cannyLowThreshold=1;//TrackBar位置参数
//Sobel边缘检测相关变量
Mat g_sobelGradient_X, g_sobelGradient_Y;
Mat g_sobelAbsGradient_X, g_sobelAbsGradient_Y;
int g_sobelKernelSize=1;//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边缘检测相关代码的函数
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
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, 120, on_Canny );
createTrackbar( "参数值：", "【效果图】Sobel边缘检测", &g_sobelKernelSize, 3, on_Sobel );
// 调用回调函数
on_Canny(0, 0);
on_Sobel(0, 0);
//调用封装了Scharr边缘检测代码的函数
Scharr( );
//轮询获取按键信息，若按下Q，程序退出
while((char(waitKey(1)) != 'q')) {}
return 0;
}
//-----------------------------------【ShowHelpText( )函数】----------------------------------
// 描述：输出一些帮助信息
//----------------------------------------------------------------------------------------------
static void ShowHelpText()
{
//输出一些帮助信息
printf( "\n\n\t嗯。运行成功，请调整滚动条观察图像效果~\n\n"
"\t按下“q”键时，程序退出~!\n"
"\n\n\t\t\t\t by浅墨" );
}
//-----------------------------------【on_Canny( )函数】----------------------------------
// 描述：Canny边缘检测窗口滚动条的回调函数
//-----------------------------------------------------------------------------------------------
void on_Canny(int, void*)
{
// 先使用 3x3内核来降噪
blur( g_srcGrayImage, g_cannyDetectedEdges, Size(3,3) );
// 运行我们的Canny算子
Canny( g_cannyDetectedEdges, g_cannyDetectedEdges, g_cannyLowThreshold, g_cannyLowThreshold*3, 3 );
//先将g_dstImage内的所有元素设置为0
g_dstImage = Scalar::all(0);
//使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
g_srcImage.copyTo( g_dstImage, g_cannyDetectedEdges);
//显示效果图
imshow( "【效果图】Canny边缘检测", g_dstImage );
}
//-----------------------------------【on_Sobel( )函数】----------------------------------
// 描述：Sobel边缘检测窗口滚动条的回调函数
//-----------------------------------------------------------------------------------------
void on_Sobel(int, void*)
{
// 求 X方向梯度
Sobel( g_srcImage, g_sobelGradient_X, CV_16S, 1, 0, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
convertScaleAbs( g_sobelGradient_X, g_sobelAbsGradient_X );//计算绝对值，并将结果转换成8位
// 求Y方向梯度
Sobel( g_srcImage, g_sobelGradient_Y, CV_16S, 0, 1, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
convertScaleAbs( g_sobelGradient_Y, g_sobelAbsGradient_Y );//计算绝对值，并将结果转换成8位
// 合并梯度
addWeighted( g_sobelAbsGradient_X, 0.5, g_sobelAbsGradient_Y, 0.5, 0, g_dstImage );
//显示效果图
imshow("【效果图】Sobel边缘检测", g_dstImage);
}
//-----------------------------------【Scharr( )函数】----------------------------------
// 描述：封装了Scharr边缘检测相关代码的函数
//-----------------------------------------------------------------------------------------
void Scharr( )
{
// 求 X方向梯度
Scharr( g_srcImage, g_scharrGradient_X, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT );
convertScaleAbs( g_scharrGradient_X, g_scharrAbsGradient_X );//计算绝对值，并将结果转换成8位
// 求Y方向梯度
Scharr( g_srcImage, g_scharrGradient_Y, CV_16S, 0, 1, 1, 0, BORDER_DEFAULT );
convertScaleAbs( g_scharrGradient_Y, g_scharrAbsGradient_Y );//计算绝对值，并将结果转换成8位
// 合并梯度
addWeighted( g_scharrAbsGradient_X, 0.5, g_scharrAbsGradient_Y, 0.5, 0, g_dstImage );
//显示效果图
imshow("【效果图】Scharr滤波器", g_dstImage);
}
放出一些运行效果图：
canny边缘检测效果图：
Sobel边缘检测：
Scharr滤波器：
好的，就放出这些效果图吧，具体更多的运行效果大家就自己下载示例程序回去玩~
本篇文章的配套源代码请点击这里下载：
【浅墨OpenCV入门教程之十二】配套源代码下载
OK，今天的内容大概就是这些，我们下篇文章见：）
本系列文章由@浅墨_毛星云 出品，转载请注明出处。 文章链接： http://blog.csdn.net/poem_qianmo/article/details/25560901 作者：毛星云（浅墨） 微博：http://weibo.com/u/1723155442 知乎：http://www.zhihu.com/people/mao-xing-yun 邮箱： happylifemxy@163.com
写作当前博文时配套使用的OpenCV版本： 2.4.9
本篇文章中，我们将一起学习OpenCV中边缘检测的各种算子和滤波器——Canny算子,Sobel算子,Laplace算子以及Scharr滤波器。文章中包含了五个浅墨为大家准备的详细注释的博文配套源代码。在介绍四块知识点的时候分别一个，以及最后的综合示例中的一个。文章末尾提供配套源代码的下载。
依然是是放出一些程序运行截图吧：
效果图看完，我们来唠唠嗑。
首先，需要说明的是，浅墨这篇文章最后的示例代码是采用两周前刚刚发布的2.4.9来书写的。里面的lib都已经改成了2.4.9版本的。如果大家需要运行的话，要么配置好2.4.9.要么把浅墨在工程中包含的末尾数字为249的各种lib改成之前的248或者你对应的OpenCV版本。
不然会提示： LINK : fatal error LNK1181: 无法打开输入文件“opencv_calib3d248.lib”之类的错误。
OpenCV 2.4.9的配置和之前的2.4.8差不多，如果还是不太清楚，具体可以参考浅墨修改过的对应2.4.9版的配置文章：
【OpenCV入门教程之一】 安装OpenCV：OpenCV 2.4.8或2.4.9 +VS 开发环境配置
第二，给大家分享一个OpenCV中写代码时节约时间的小常识。其实OpenCV中，不用namedWindow，直接imshow就可以显示出窗口。大家看下文的示例代码就可以发现，浅墨在写代码的时候并没有用namedWindow，遇到想显示出来的Mat变量直接imshow。我们一般是为了规范，才先用namedWindow创建窗口，再imshow出它来，因为我们还有需要用到指定窗口名称的地方，比如用到trackbar的时候。而一般情况想显示一个Mat变量的图片的话，直接imshow就可以啦。
OK，开始正文吧~
在具体介绍之前，先来一起看看边缘检测的一般步骤吧。
1）滤波：边缘检测的算法主要是基于图像强度的一阶和二阶导数，但导数通常对噪声很敏感，因此必须采用滤波器来改善与噪声有关的边缘检测器的性能。常见的滤波方法主要有高斯滤波，即采用离散化的高斯函数产生一组归一化的高斯核（具体见“高斯滤波原理及其编程离散化实现方法”一文），然后基于高斯核函数对图像灰度矩阵的每一点进行加权求和（具体程序实现见下文）。
2）增强：增强边缘的基础是确定图像各点邻域强度的变化值。增强算法可以将图像灰度点邻域强度值有显著变化的点凸显出来。在具体编程实现时，可通过计算梯度幅值来确定。
3）检测：经过增强的图像，往往邻域中有很多点的梯度值比较大，而在特定的应用中，这些点并不是我们要找的边缘点，所以应该采用某种方法来对这些点进行取舍。实际工程中，常用的方法是通过阈值化方法来检测。
另外，需要注意，下文中讲到的Laplace算子，sobel算子和Scharr算子都是带方向的，所以，示例中我们分别写了X方向,Y方向和最终合成的的效果图。
OK，正餐开始，召唤canny算子。：）
其中，Canny 的目标是找到一个最优的边缘检测算法，让我们看一下最优边缘检测的三个主要评价标准:
1.低错误率: 标识出尽可能多的实际边缘，同时尽可能的减少噪声产生的误报。
2.高定位性: 标识出的边缘要与图像中的实际边缘尽可能接近。
3.最小响应: 图像中的边缘只能标识一次，并且可能存在的图像噪声不应标识为边缘。
为了满足这些要求 Canny 使用了变分法，这是一种寻找满足特定功能的函数的方法。最优检测使用四个指数函数项的和表示，但是它非常近似于高斯函数的一阶导数。
2.计算梯度幅值和方向。 此处，按照Sobel滤波器的步骤。
Ⅰ.运用一对卷积阵列 (分别作用于 x 和 y 方向):
Ⅱ.使用下列公式计算梯度幅值和方向:
梯度方向近似到四个可能角度之一(一般为0, 45, 90, 135)
3.非极大值抑制。 这一步排除非边缘像素， 仅仅保留了一些细线条(候选边缘)。
4.滞后阈值。最后一步，Canny 使用了滞后阈值，滞后阈值需要两个阈值(高阈值和低阈值):
Ⅰ.如果某一像素位置的幅值超过 高 阈值, 该像素被保留为边缘像素。
Ⅱ.如果某一像素位置的幅值小于 低 阈值, 该像素被排除。
Ⅲ.如果某一像素位置的幅值在两个阈值之间,该像素仅仅在连接到一个高于 高 阈值的像素时被保留。
tips：对于Canny函数的使用，推荐的高低阈值比在2:1到3:1之间。
更多的细节，可以参考canny算子的wikipedia：
http://en.wikipedia.org/wiki/Canny_edge_detector
canny边缘检测的原理讲述，课参看这篇博文：
http://blog.csdn.net/likezhaobin/article/details/6892176
canny算子的中文wikipedia：
http://zh.wikipedia.org/wiki/Canny%E7%AE%97%E5%AD%90
Canny函数利用Canny算法来进行图像的边缘检测。
[cpp] view plain copyC++: void Canny(InputArray image,OutputArray edges, double threshold1, double threshold2, int apertureSize=3,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之间。
调用示例：
[cpp] view plain copy//载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Canny(src, src, 3, 9,3 );
imshow("【效果图】Canny边缘检测", src);
如上三句，就有结果出来，非常好用。
OpenCV中调用Canny函数的实例代码如下：
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Mat src1=src.clone();
//显示原始图
imshow("【原始图】Canny边缘检测", src);
//----------------------------------------------------------------------------------
// 一、最简单的canny用法，拿到原图后直接用。
//----------------------------------------------------------------------------------
Canny( src, src, 150, 100,3 );
imshow("【效果图】Canny边缘检测", src);
//----------------------------------------------------------------------------------
// 二、高阶的canny用法，转成灰度图，降噪，用canny，最后将得到的边缘作为掩码，拷贝原图到效果图上，得到彩色的边缘图
//----------------------------------------------------------------------------------
Mat dst,edge,gray;
// 【1】创建与src同类型和大小的矩阵(dst)
dst.create( src1.size(), src1.type() );
// 【2】将原图像转换为灰度图像
cvtColor( src1, gray, CV_BGR2GRAY );
// 【3】先用使用 3x3内核来降噪
blur( gray, edge, Size(3,3) );
// 【4】运行Canny算子
Canny( edge, edge, 3, 9,3 );
//【5】将g_dstImage内的所有元素设置为0
dst = Scalar::all(0);
//【6】使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
src1.copyTo( dst, edge);
//【7】显示效果图
imshow("【效果图】Canny边缘检测2", dst);
waitKey(0);
return 0;
}
运行效果图：
sobel算子的wikipedia：
http://zh.wikipedia.org/wiki/%E7%B4%A2%E8%B2%9D%E7%88%BE%E7%AE%97%E5%AD%90
sobel算子相关概念，还可以参看这篇博文：
http://www.cnblogs.com/lancidie/archive/2011/07/17/2108885.html
3.1.2 sobel算子的计算过程
我们假设被作用图像为 I.然后进行如下的操作：
1.分别在x和y两个方向求导。
Ⅰ.水平变化: 将 I 与一个奇数大小的内核
进行卷积。比如，当内核大小为3时,
的计算结果为:
Ⅱ.垂直变化: 将: I 与一个奇数大小的内核
进行卷积。比如，当内核大小为3时,
的计算结果为:
2.在图像的每一点，结合以上两个结果求出近似梯度:
另外有时，也可用下面更简单公式代替:
[cpp] view plain copyC++: void Sobel (
InputArray src,//输入图
OutputArray dst,//输出图
int ddepth,//输出图像的深度
int dx,
int dy,
int ksize=3,
double scale=1,
double delta=0,
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】对应的内核：
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】创建 grad_x 和 grad_y 矩阵
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y,dst;
//【1】载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】sobel边缘检测", src);
//【3】求 X方向梯度
Sobel( src, grad_x, CV_16S, 1, 0, 3, 1, 1, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
imshow("【效果图】 X方向Sobel", abs_grad_x);
//【4】求Y方向梯度
Sobel( src, grad_y, CV_16S, 0, 1, 3, 1, 1, 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, 0, dst );
imshow("【效果图】整体方向Sobel", dst);
waitKey(0);
return 0;
}
运行截图如下：
Laplacian 算子是n维欧几里德空间中的一个二阶微分算子，定义为梯度grad（）的散度div（）。因此如果f是二阶可微的实函数，则f的拉普拉斯算子定义为：
(1) f的拉普拉斯算子也是笛卡儿坐标系xi中的所有非混合二阶偏导数求和：
(2) 作为一个二阶微分算子，拉普拉斯算子把C函数映射到C函数，对于k ≥ 2。表达式(1)（或(2)）定义了一个算子Δ :C(R) → C(R)，或更一般地，定义了一个算子Δ : C(Ω) → C(Ω)，对于任何开集Ω。
根据图像处理的原理我们知道，二阶导数可以用来进行检测边缘 。 因为图像是 “二维”, 我们需要在两个方向进行求导。使用Laplacian算子将会使求导过程变得简单。
Laplacian 算子的定义:
需要点破的是，由于 Laplacian使用了图像梯度，它内部的代码其实是调用了 Sobel 算子的。
另附一个小tips：让一幅图像减去它的Laplacian可以增强对比度。
关于Laplace算子的相关概念阐述，可以参看这篇博文：
http://www.cnblogs.com/xfzhang/archive/2011/01/19/1939020.html
Laplace算子的wikipedia：
http://zh.wikipedia.org/wiki/%E6%8B%89%E6%99%AE%E6%8B%89%E6%96%AF%E7%AE%97%E5%AD%90
[cpp] view plain copyC++: void Laplacian(InputArray src,OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, 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的孔径：
让我们看一看调用实例：
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】变量的定义
Mat src,src_gray,dst, abs_dst;
//【1】载入原始图
src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】图像Laplace变换", src);
//【3】使用高斯滤波消除噪声
GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
//【4】转换为灰度图
cvtColor( src, src_gray, CV_RGB2GRAY );
//【5】使用Laplace函数
Laplacian( src_gray, dst, CV_16S, 3, 1, 0, BORDER_DEFAULT );
//【6】计算绝对值，并将结果转换成8位
convertScaleAbs( dst, abs_dst );
//【7】显示效果图
imshow( "【效果图】图像Laplace变换", abs_dst );
waitKey(0);
return 0;
}
示例效果图：
使用Scharr滤波器运算符计算x或y方向的图像差分。其实它的参数变量和Sobel基本上是一样的，除了没有ksize核的大小。
[cpp] view plain copyC++: void Scharr(
InputArray src, //源图
OutputArray dst, //目标图
int ddepth,//图像深度
int dx,// x方向上的差分阶数
int dy,//y方向上的差分阶数
double scale=1,//缩放因子
double delta=0,// 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处得到更详细的信息。
不难理解，如下两者是等价的：
[cpp] view plain copyScharr(src, dst, ddepth, dx, dy, scale,delta, borderType);
与
[cpp] view plain copySobel(src, dst, ddepth, dx, dy, CV_SCHARR,scale, delta, borderType);
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】创建 grad_x 和 grad_y 矩阵
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y,dst;
//【1】载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】Scharr滤波器", src);
//【3】求 X方向梯度
Scharr( src, grad_x, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
imshow("【效果图】 X方向Scharr", abs_grad_x);
//【4】求Y方向梯度
Scharr( src, grad_y, CV_16S, 0, 1, 1, 0, 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, 0, dst );
//【6】显示效果图
imshow("【效果图】合并梯度后Scharr", dst);
waitKey(0);
return 0;
}
运行效果图：
依然是每篇文章都会配给大家的一个详细注释的博文配套示例程序，把这篇文章中介绍的知识点以代码为载体，展现给大家。
这个示例程序中，分别演示了canny边缘检测，sobel边缘检测，scharr滤波器的使用，那么，上详细注释的代码吧：
[cpp] view plain copy//-----------------------------------【程序说明】----------------------------------------------
// 程序名称:：《【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑合辑》 博文配套源码
// 开发所用IDE版本：Visual Studio 2010
// <span style="white-space:pre;"> </span>开发所用OpenCV版本： 2.4.9
// 2014年5月11日 Create by 浅墨
// 浅墨的微博：@浅墨_毛星云 http://weibo.com/1723155442/profile?topnav=1&wvr=5&user=1
// 浅墨的知乎：http://www.zhihu.com/people/mao-xing-yun
// 浅墨的豆瓣：http://www.douban.com/people/53426472/
//----------------------------------------------------------------------------------------------
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】--------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【全局变量声明部分】--------------------------------------
// 描述：全局变量声明
//-----------------------------------------------------------------------------------------------
//原图，原图的灰度版，目标图
Mat g_srcImage, g_srcGrayImage,g_dstImage;
//Canny边缘检测相关变量
Mat g_cannyDetectedEdges;
int g_cannyLowThreshold=1;//TrackBar位置参数
//Sobel边缘检测相关变量
Mat g_sobelGradient_X, g_sobelGradient_Y;
Mat g_sobelAbsGradient_X, g_sobelAbsGradient_Y;
int g_sobelKernelSize=1;//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边缘检测相关代码的函数
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
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, 120, on_Canny );
createTrackbar( "参数值：", "【效果图】Sobel边缘检测", &g_sobelKernelSize, 3, on_Sobel );
// 调用回调函数
on_Canny(0, 0);
on_Sobel(0, 0);
//调用封装了Scharr边缘检测代码的函数
Scharr( );
//轮询获取按键信息，若按下Q，程序退出
while((char(waitKey(1)) != 'q')) {}
return 0;
}
//-----------------------------------【ShowHelpText( )函数】----------------------------------
// 描述：输出一些帮助信息
//----------------------------------------------------------------------------------------------
static void ShowHelpText()
{
//输出一些帮助信息
printf( "\n\n\t嗯。运行成功，请调整滚动条观察图像效果~\n\n"
"\t按下“q”键时，程序退出~!\n"
"\n\n\t\t\t\t by浅墨" );
}
//-----------------------------------【on_Canny( )函数】----------------------------------
// 描述：Canny边缘检测窗口滚动条的回调函数
//-----------------------------------------------------------------------------------------------
void on_Canny(int, void*)
{
// 先使用 3x3内核来降噪
blur( g_srcGrayImage, g_cannyDetectedEdges, Size(3,3) );
// 运行我们的Canny算子
Canny( g_cannyDetectedEdges, g_cannyDetectedEdges, g_cannyLowThreshold, g_cannyLowThreshold*3, 3 );
//先将g_dstImage内的所有元素设置为0
g_dstImage = Scalar::all(0);
//使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
g_srcImage.copyTo( g_dstImage, g_cannyDetectedEdges);
//显示效果图
imshow( "【效果图】Canny边缘检测", g_dstImage );
}
//-----------------------------------【on_Sobel( )函数】----------------------------------
// 描述：Sobel边缘检测窗口滚动条的回调函数
//-----------------------------------------------------------------------------------------
void on_Sobel(int, void*)
{
// 求 X方向梯度
Sobel( g_srcImage, g_sobelGradient_X, CV_16S, 1, 0, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
convertScaleAbs( g_sobelGradient_X, g_sobelAbsGradient_X );//计算绝对值，并将结果转换成8位
// 求Y方向梯度
Sobel( g_srcImage, g_sobelGradient_Y, CV_16S, 0, 1, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
convertScaleAbs( g_sobelGradient_Y, g_sobelAbsGradient_Y );//计算绝对值，并将结果转换成8位
// 合并梯度
addWeighted( g_sobelAbsGradient_X, 0.5, g_sobelAbsGradient_Y, 0.5, 0, g_dstImage );
//显示效果图
imshow("【效果图】Sobel边缘检测", g_dstImage);
}
//-----------------------------------【Scharr( )函数】----------------------------------
// 描述：封装了Scharr边缘检测相关代码的函数
//-----------------------------------------------------------------------------------------
void Scharr( )
{
// 求 X方向梯度
Scharr( g_srcImage, g_scharrGradient_X, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT );
convertScaleAbs( g_scharrGradient_X, g_scharrAbsGradient_X );//计算绝对值，并将结果转换成8位
// 求Y方向梯度
Scharr( g_srcImage, g_scharrGradient_Y, CV_16S, 0, 1, 1, 0, BORDER_DEFAULT );
convertScaleAbs( g_scharrGradient_Y, g_scharrAbsGradient_Y );//计算绝对值，并将结果转换成8位
// 合并梯度
addWeighted( g_scharrAbsGradient_X, 0.5, g_scharrAbsGradient_Y, 0.5, 0, g_dstImage );
//显示效果图
imshow("【效果图】Scharr滤波器", g_dstImage);
}
放出一些运行效果图：
canny边缘检测效果图：
Sobel边缘检测：
Scharr滤波器：
好的，就放出这些效果图吧，具体更多的运行效果大家就自己下载示例程序回去玩~
本篇文章的配套源代码请点击这里下载：
【浅墨OpenCV入门教程之十二】配套源代码下载
OK，今天的内容大概就是这些，我们下篇文章见：）
文章链接： http://blog.csdn.net/poem_qianmo/article/details/25560901 作者：毛星云（浅墨） 微博：http://weibo.com/u/1723155442 知乎：http://www.zhihu.com/people/mao-xing-yun 邮箱： happylifemxy@163.com
写作当前博文时配套使用的OpenCV版本： 2.4.9
本篇文章中，我们将一起学习OpenCV中边缘检测的各种算子和滤波器——Canny算子,Sobel算子,Laplace算子以及Scharr滤波器。文章中包含了五个浅墨为大家准备的详细注释的博文配套源代码。在介绍四块知识点的时候分别一个，以及最后的综合示例中的一个。文章末尾提供配套源代码的下载。
依然是是放出一些程序运行截图吧：
效果图看完，我们来唠唠嗑。
首先，需要说明的是，浅墨这篇文章最后的示例代码是采用两周前刚刚发布的2.4.9来书写的。里面的lib都已经改成了2.4.9版本的。如果大家需要运行的话，要么配置好2.4.9.要么把浅墨在工程中包含的末尾数字为249的各种lib改成之前的248或者你对应的OpenCV版本。
不然会提示： LINK : fatal error LNK1181: 无法打开输入文件“opencv_calib3d248.lib”之类的错误。
OpenCV 2.4.9的配置和之前的2.4.8差不多，如果还是不太清楚，具体可以参考浅墨修改过的对应2.4.9版的配置文章：
【OpenCV入门教程之一】 安装OpenCV：OpenCV 2.4.8或2.4.9 +VS 开发环境配置
第二，给大家分享一个OpenCV中写代码时节约时间的小常识。其实OpenCV中，不用namedWindow，直接imshow就可以显示出窗口。大家看下文的示例代码就可以发现，浅墨在写代码的时候并没有用namedWindow，遇到想显示出来的Mat变量直接imshow。我们一般是为了规范，才先用namedWindow创建窗口，再imshow出它来，因为我们还有需要用到指定窗口名称的地方，比如用到trackbar的时候。而一般情况想显示一个Mat变量的图片的话，直接imshow就可以啦。
OK，开始正文吧~
一、关于边缘检测
4000
在具体介绍之前，先来一起看看边缘检测的一般步骤吧。
1）滤波：边缘检测的算法主要是基于图像强度的一阶和二阶导数，但导数通常对噪声很敏感，因此必须采用滤波器来改善与噪声有关的边缘检测器的性能。常见的滤波方法主要有高斯滤波，即采用离散化的高斯函数产生一组归一化的高斯核（具体见“高斯滤波原理及其编程离散化实现方法”一文），然后基于高斯核函数对图像灰度矩阵的每一点进行加权求和（具体程序实现见下文）。
2）增强：增强边缘的基础是确定图像各点邻域强度的变化值。增强算法可以将图像灰度点邻域强度值有显著变化的点凸显出来。在具体编程实现时，可通过计算梯度幅值来确定。
3）检测：经过增强的图像，往往邻域中有很多点的梯度值比较大，而在特定的应用中，这些点并不是我们要找的边缘点，所以应该采用某种方法来对这些点进行取舍。实际工程中，常用的方法是通过阈值化方法来检测。
另外，需要注意，下文中讲到的Laplace算子，sobel算子和Scharr算子都是带方向的，所以，示例中我们分别写了X方向,Y方向和最终合成的的效果图。
OK，正餐开始，召唤canny算子。：）
二、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 使用了变分法，这是一种寻找满足特定功能的函数的方法。最优检测使用四个指数函数项的和表示，但是它非常近似于高斯函数的一阶导数。
2.1.2 Canny 边缘检测的步骤
1.消除噪声。 一般情况下，使用高斯平滑滤波器卷积降噪。 如下显示了一个 size = 5 的高斯内核示例:2.计算梯度幅值和方向。 此处，按照Sobel滤波器的步骤。
Ⅰ.运用一对卷积阵列 (分别作用于 x 和 y 方向):
Ⅱ.使用下列公式计算梯度幅值和方向:
梯度方向近似到四个可能角度之一(一般为0, 45, 90, 135)
3.非极大值抑制。 这一步排除非边缘像素， 仅仅保留了一些细线条(候选边缘)。
4.滞后阈值。最后一步，Canny 使用了滞后阈值，滞后阈值需要两个阈值(高阈值和低阈值):
Ⅰ.如果某一像素位置的幅值超过 高 阈值, 该像素被保留为边缘像素。
Ⅱ.如果某一像素位置的幅值小于 低 阈值, 该像素被排除。
Ⅲ.如果某一像素位置的幅值在两个阈值之间,该像素仅仅在连接到一个高于 高 阈值的像素时被保留。
tips：对于Canny函数的使用，推荐的高低阈值比在2:1到3:1之间。
更多的细节，可以参考canny算子的wikipedia：
http://en.wikipedia.org/wiki/Canny_edge_detector
canny边缘检测的原理讲述，课参看这篇博文：
http://blog.csdn.net/likezhaobin/article/details/6892176
canny算子的中文wikipedia：
http://zh.wikipedia.org/wiki/Canny%E7%AE%97%E5%AD%90
2.2 OpenCV中Canny函数详解
Canny函数利用Canny算法来进行图像的边缘检测。
[cpp] view plain copyC++: void Canny(InputArray image,OutputArray edges, double threshold1, double threshold2, int apertureSize=3,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之间。
调用示例：
[cpp] view plain copy//载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Canny(src, src, 3, 9,3 );
imshow("【效果图】Canny边缘检测", src);
如上三句，就有结果出来，非常好用。
2.3 调用Canny函数的实例代码
OpenCV中调用Canny函数的实例代码如下：
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Mat src1=src.clone();
//显示原始图
imshow("【原始图】Canny边缘检测", src);
//----------------------------------------------------------------------------------
// 一、最简单的canny用法，拿到原图后直接用。
//----------------------------------------------------------------------------------
Canny( src, src, 150, 100,3 );
imshow("【效果图】Canny边缘检测", src);
//----------------------------------------------------------------------------------
// 二、高阶的canny用法，转成灰度图，降噪，用canny，最后将得到的边缘作为掩码，拷贝原图到效果图上，得到彩色的边缘图
//----------------------------------------------------------------------------------
Mat dst,edge,gray;
// 【1】创建与src同类型和大小的矩阵(dst)
dst.create( src1.size(), src1.type() );
// 【2】将原图像转换为灰度图像
cvtColor( src1, gray, CV_BGR2GRAY );
// 【3】先用使用 3x3内核来降噪
blur( gray, edge, Size(3,3) );
// 【4】运行Canny算子
Canny( edge, edge, 3, 9,3 );
//【5】将g_dstImage内的所有元素设置为0
dst = Scalar::all(0);
//【6】使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
src1.copyTo( dst, edge);
//【7】显示效果图
imshow("【效果图】Canny边缘检测2", dst);
waitKey(0);
return 0;
}
运行效果图：
三、sobel算子篇
3.1 sobel算子相关理论与概念讲解
3.1.1 基本概念
Sobel 算子是一个主要用作边缘检测的离散微分算子 (discrete differentiation operator)。 它Sobel算子结合了高斯平滑和微分求导，用来计算图像灰度函数的近似梯度。在图像的任何一点使用此算子，将会产生对应的梯度矢量或是其法矢量。sobel算子的wikipedia：
http://zh.wikipedia.org/wiki/%E7%B4%A2%E8%B2%9D%E7%88%BE%E7%AE%97%E5%AD%90
sobel算子相关概念，还可以参看这篇博文：
http://www.cnblogs.com/lancidie/archive/2011/07/17/2108885.html
3.1.2 sobel算子的计算过程
我们假设被作用图像为 I.然后进行如下的操作：
1.分别在x和y两个方向求导。
Ⅰ.水平变化: 将 I 与一个奇数大小的内核
进行卷积。比如，当内核大小为3时,
的计算结果为:
Ⅱ.垂直变化: 将: I 与一个奇数大小的内核
进行卷积。比如，当内核大小为3时,
的计算结果为:
2.在图像的每一点，结合以上两个结果求出近似梯度:
另外有时，也可用下面更简单公式代替:
3.2 OpenCV中Sobel函数详解
Sobel函数使用扩展的 Sobel 算子，来计算一阶、二阶、三阶或混合图像差分。[cpp] view plain copyC++: void Sobel (
InputArray src,//输入图
OutputArray dst,//输出图
int ddepth,//输出图像的深度
int dx,
int dy,
int ksize=3,
double scale=1,
double delta=0,
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将原图;转化为灰度图，而是直接用彩色图操作。[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】创建 grad_x 和 grad_y 矩阵
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y,dst;
//【1】载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】sobel边缘检测", src);
//【3】求 X方向梯度
Sobel( src, grad_x, CV_16S, 1, 0, 3, 1, 1, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
imshow("【效果图】 X方向Sobel", abs_grad_x);
//【4】求Y方向梯度
Sobel( src, grad_y, CV_16S, 0, 1, 3, 1, 1, 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, 0, dst );
imshow("【效果图】整体方向Sobel", dst);
waitKey(0);
return 0;
}
运行截图如下：
四、Laplace算子篇
4.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算子将会使求导过程变得简单。
Laplacian 算子的定义:
需要点破的是，由于 Laplacian使用了图像梯度，它内部的代码其实是调用了 Sobel 算子的。
另附一个小tips：让一幅图像减去它的Laplacian可以增强对比度。
关于Laplace算子的相关概念阐述，可以参看这篇博文：
http://www.cnblogs.com/xfzhang/archive/2011/01/19/1939020.html
Laplace算子的wikipedia：
http://zh.wikipedia.org/wiki/%E6%8B%89%E6%99%AE%E6%8B%89%E6%96%AF%E7%AE%97%E5%AD%90
4.2 OpenCV中Laplacian函数详解
Laplacian函数可以计算出图像经过拉普拉斯变换后的结果。[cpp] view plain copyC++: void Laplacian(InputArray src,OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, 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函数的实例代码
让我们看一看调用实例：
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】变量的定义
Mat src,src_gray,dst, abs_dst;
//【1】载入原始图
src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】图像Laplace变换", src);
//【3】使用高斯滤波消除噪声
GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
//【4】转换为灰度图
cvtColor( src, src_gray, CV_RGB2GRAY );
//【5】使用Laplace函数
Laplacian( src_gray, dst, CV_16S, 3, 1, 0, BORDER_DEFAULT );
//【6】计算绝对值，并将结果转换成8位
convertScaleAbs( dst, abs_dst );
//【7】显示效果图
imshow( "【效果图】图像Laplace变换", abs_dst );
waitKey(0);
return 0;
}
示例效果图：
五、scharr滤波器篇
scharr一般我就直接称它为滤波器，而不是算子。上文我们已经讲到，它在OpenCV中主要是配合Sobel算子的运算而存在的,一个万年备胎。让我们直接来看看函数讲解吧。5.1 OpenCV中Scharr函数详解
使用Scharr滤波器运算符计算x或y方向的图像差分。其实它的参数变量和Sobel基本上是一样的，除了没有ksize核的大小。
[cpp] view plain copyC++: void Scharr(
InputArray src, //源图
OutputArray dst, //目标图
int ddepth,//图像深度
int dx,// x方向上的差分阶数
int dy,//y方向上的差分阶数
double scale=1,//缩放因子
double delta=0,// 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处得到更详细的信息。
不难理解，如下两者是等价的：
[cpp] view plain copyScharr(src, dst, ddepth, dx, dy, scale,delta, borderType);
与
[cpp] view plain copySobel(src, dst, ddepth, dx, dy, CV_SCHARR,scale, delta, borderType);
5.2 调用Scharr函数的实例代码
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】创建 grad_x 和 grad_y 矩阵
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y,dst;
//【1】载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】Scharr滤波器", src);
//【3】求 X方向梯度
Scharr( src, grad_x, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
imshow("【效果图】 X方向Scharr", abs_grad_x);
//【4】求Y方向梯度
Scharr( src, grad_y, CV_16S, 0, 1, 1, 0, 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, 0, dst );
//【6】显示效果图
imshow("【效果图】合并梯度后Scharr", dst);
waitKey(0);
return 0;
}
运行效果图：
六、综合示例篇——在实战中熟稔
依然是每篇文章都会配给大家的一个详细注释的博文配套示例程序，把这篇文章中介绍的知识点以代码为载体，展现给大家。
这个示例程序中，分别演示了canny边缘检测，sobel边缘检测，scharr滤波器的使用，那么，上详细注释的代码吧：
[cpp] view plain copy//-----------------------------------【程序说明】----------------------------------------------
// 程序名称:：《【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑合辑》 博文配套源码
// 开发所用IDE版本：Visual Studio 2010
// <span style="white-space:pre;"> </span>开发所用OpenCV版本： 2.4.9
// 2014年5月11日 Create by 浅墨
// 浅墨的微博：@浅墨_毛星云 http://weibo.com/1723155442/profile?topnav=1&wvr=5&user=1
// 浅墨的知乎：http://www.zhihu.com/people/mao-xing-yun
// 浅墨的豆瓣：http://www.douban.com/people/53426472/
//----------------------------------------------------------------------------------------------
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】--------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【全局变量声明部分】--------------------------------------
// 描述：全局变量声明
//-----------------------------------------------------------------------------------------------
//原图，原图的灰度版，目标图
Mat g_srcImage, g_srcGrayImage,g_dstImage;
//Canny边缘检测相关变量
Mat g_cannyDetectedEdges;
int g_cannyLowThreshold=1;//TrackBar位置参数
//Sobel边缘检测相关变量
Mat g_sobelGradient_X, g_sobelGradient_Y;
Mat g_sobelAbsGradient_X, g_sobelAbsGradient_Y;
int g_sobelKernelSize=1;//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边缘检测相关代码的函数
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
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, 120, on_Canny );
createTrackbar( "参数值：", "【效果图】Sobel边缘检测", &g_sobelKernelSize, 3, on_Sobel );
// 调用回调函数
on_Canny(0, 0);
on_Sobel(0, 0);
//调用封装了Scharr边缘检测代码的函数
Scharr( );
//轮询获取按键信息，若按下Q，程序退出
while((char(waitKey(1)) != 'q')) {}
return 0;
}
//-----------------------------------【ShowHelpText( )函数】----------------------------------
// 描述：输出一些帮助信息
//----------------------------------------------------------------------------------------------
static void ShowHelpText()
{
//输出一些帮助信息
printf( "\n\n\t嗯。运行成功，请调整滚动条观察图像效果~\n\n"
"\t按下“q”键时，程序退出~!\n"
"\n\n\t\t\t\t by浅墨" );
}
//-----------------------------------【on_Canny( )函数】----------------------------------
// 描述：Canny边缘检测窗口滚动条的回调函数
//-----------------------------------------------------------------------------------------------
void on_Canny(int, void*)
{
// 先使用 3x3内核来降噪
blur( g_srcGrayImage, g_cannyDetectedEdges, Size(3,3) );
// 运行我们的Canny算子
Canny( g_cannyDetectedEdges, g_cannyDetectedEdges, g_cannyLowThreshold, g_cannyLowThreshold*3, 3 );
//先将g_dstImage内的所有元素设置为0
g_dstImage = Scalar::all(0);
//使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
g_srcImage.copyTo( g_dstImage, g_cannyDetectedEdges);
//显示效果图
imshow( "【效果图】Canny边缘检测", g_dstImage );
}
//-----------------------------------【on_Sobel( )函数】----------------------------------
// 描述：Sobel边缘检测窗口滚动条的回调函数
//-----------------------------------------------------------------------------------------
void on_Sobel(int, void*)
{
// 求 X方向梯度
Sobel( g_srcImage, g_sobelGradient_X, CV_16S, 1, 0, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
convertScaleAbs( g_sobelGradient_X, g_sobelAbsGradient_X );//计算绝对值，并将结果转换成8位
// 求Y方向梯度
Sobel( g_srcImage, g_sobelGradient_Y, CV_16S, 0, 1, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
convertScaleAbs( g_sobelGradient_Y, g_sobelAbsGradient_Y );//计算绝对值，并将结果转换成8位
// 合并梯度
addWeighted( g_sobelAbsGradient_X, 0.5, g_sobelAbsGradient_Y, 0.5, 0, g_dstImage );
//显示效果图
imshow("【效果图】Sobel边缘检测", g_dstImage);
}
//-----------------------------------【Scharr( )函数】----------------------------------
// 描述：封装了Scharr边缘检测相关代码的函数
//-----------------------------------------------------------------------------------------
void Scharr( )
{
// 求 X方向梯度
Scharr( g_srcImage, g_scharrGradient_X, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT );
convertScaleAbs( g_scharrGradient_X, g_scharrAbsGradient_X );//计算绝对值，并将结果转换成8位
// 求Y方向梯度
Scharr( g_srcImage, g_scharrGradient_Y, CV_16S, 0, 1, 1, 0, BORDER_DEFAULT );
convertScaleAbs( g_scharrGradient_Y, g_scharrAbsGradient_Y );//计算绝对值，并将结果转换成8位
// 合并梯度
addWeighted( g_scharrAbsGradient_X, 0.5, g_scharrAbsGradient_Y, 0.5, 0, g_dstImage );
//显示效果图
imshow("【效果图】Scharr滤波器", g_dstImage);
}
放出一些运行效果图：
canny边缘检测效果图：
Sobel边缘检测：
Scharr滤波器：
好的，就放出这些效果图吧，具体更多的运行效果大家就自己下载示例程序回去玩~
本篇文章的配套源代码请点击这里下载：
【浅墨OpenCV入门教程之十二】配套源代码下载
OK，今天的内容大概就是这些，我们下篇文章见：）
本系列文章由@浅墨_毛星云 出品，转载请注明出处。 文章链接： http://blog.csdn.net/poem_qianmo/article/details/25560901 作者：毛星云（浅墨） 微博：http://weibo.com/u/1723155442 知乎：http://www.zhihu.com/people/mao-xing-yun 邮箱： happylifemxy@163.com
写作当前博文时配套使用的OpenCV版本： 2.4.9
本篇文章中，我们将一起学习OpenCV中边缘检测的各种算子和滤波器——Canny算子,Sobel算子,Laplace算子以及Scharr滤波器。文章中包含了五个浅墨为大家准备的详细注释的博文配套源代码。在介绍四块知识点的时候分别一个，以及最后的综合示例中的一个。文章末尾提供配套源代码的下载。
依然是是放出一些程序运行截图吧：
效果图看完，我们来唠唠嗑。
首先，需要说明的是，浅墨这篇文章最后的示例代码是采用两周前刚刚发布的2.4.9来书写的。里面的lib都已经改成了2.4.9版本的。如果大家需要运行的话，要么配置好2.4.9.要么把浅墨在工程中包含的末尾数字为249的各种lib改成之前的248或者你对应的OpenCV版本。
不然会提示： LINK : fatal error LNK1181: 无法打开输入文件“opencv_calib3d248.lib”之类的错误。
OpenCV 2.4.9的配置和之前的2.4.8差不多，如果还是不太清楚，具体可以参考浅墨修改过的对应2.4.9版的配置文章：
【OpenCV入门教程之一】 安装OpenCV：OpenCV 2.4.8或2.4.9 +VS 开发环境配置
第二，给大家分享一个OpenCV中写代码时节约时间的小常识。其实OpenCV中，不用namedWindow，直接imshow就可以显示出窗口。大家看下文的示例代码就可以发现，浅墨在写代码的时候并没有用namedWindow，遇到想显示出来的Mat变量直接imshow。我们一般是为了规范，才先用namedWindow创建窗口，再imshow出它来，因为我们还有需要用到指定窗口名称的地方，比如用到trackbar的时候。而一般情况想显示一个Mat变量的图片的话，直接imshow就可以啦。
OK，开始正文吧~
一、关于边缘检测
在具体介绍之前，先来一起看看边缘检测的一般步骤吧。
1）滤波：边缘检测的算法主要是基于图像强度的一阶和二阶导数，但导数通常对噪声很敏感，因此必须采用滤波器来改善与噪声有关的边缘检测器的性能。常见的滤波方法主要有高斯滤波，即采用离散化的高斯函数产生一组归一化的高斯核（具体见“高斯滤波原理及其编程离散化实现方法”一文），然后基于高斯核函数对图像灰度矩阵的每一点进行加权求和（具体程序实现见下文）。
2）增强：增强边缘的基础是确定图像各点邻域强度的变化值。增强算法可以将图像灰度点邻域强度值有显著变化的点凸显出来。在具体编程实现时，可通过计算梯度幅值来确定。
3）检测：经过增强的图像，往往邻域中有很多点的梯度值比较大，而在特定的应用中，这些点并不是我们要找的边缘点，所以应该采用某种方法来对这些点进行取舍。实际工程中，常用的方法是通过阈值化方法来检测。
另外，需要注意，下文中讲到的Laplace算子，sobel算子和Scharr算子都是带方向的，所以，示例中我们分别写了X方向,Y方向和最终合成的的效果图。
OK，正餐开始，召唤canny算子。：）
二、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 使用了变分法，这是一种寻找满足特定功能的函数的方法。最优检测使用四个指数函数项的和表示，但是它非常近似于高斯函数的一阶导数。
2.1.2 Canny 边缘检测的步骤
1.消除噪声。 一般情况下，使用高斯平滑滤波器卷积降噪。 如下显示了一个 size = 5 的高斯内核示例:2.计算梯度幅值和方向。 此处，按照Sobel滤波器的步骤。
Ⅰ.运用一对卷积阵列 (分别作用于 x 和 y 方向):
Ⅱ.使用下列公式计算梯度幅值和方向:
梯度方向近似到四个可能角度之一(一般为0, 45, 90, 135)
3.非极大值抑制。 这一步排除非边缘像素， 仅仅保留了一些细线条(候选边缘)。
4.滞后阈值。最后一步，Canny 使用了滞后阈值，滞后阈值需要两个阈值(高阈值和低阈值):
Ⅰ.如果某一像素位置的幅值超过 高 阈值, 该像素被保留为边缘像素。
Ⅱ.如果某一像素位置的幅值小于 低 阈值, 该像素被排除。
Ⅲ.如果某一像素位置的幅值在两个阈值之间,该像素仅仅在连接到一个高于 高 阈值的像素时被保留。
tips：对于Canny函数的使用，推荐的高低阈值比在2:1到3:1之间。
更多的细节，可以参考canny算子的wikipedia：
http://en.wikipedia.org/wiki/Canny_edge_detector
canny边缘检测的原理讲述，课参看这篇博文：
http://blog.csdn.net/likezhaobin/article/details/6892176
canny算子的中文wikipedia：
http://zh.wikipedia.org/wiki/Canny%E7%AE%97%E5%AD%90
2.2 OpenCV中Canny函数详解
Canny函数利用Canny算法来进行图像的边缘检测。
[cpp] view plain copyC++: void Canny(InputArray image,OutputArray edges, double threshold1, double threshold2, int apertureSize=3,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之间。
调用示例：
[cpp] view plain copy//载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Canny(src, src, 3, 9,3 );
imshow("【效果图】Canny边缘检测", src);
如上三句，就有结果出来，非常好用。
2.3 调用Canny函数的实例代码
OpenCV中调用Canny函数的实例代码如下：
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Mat src1=src.clone();
//显示原始图
imshow("【原始图】Canny边缘检测", src);
//----------------------------------------------------------------------------------
// 一、最简单的canny用法，拿到原图后直接用。
//----------------------------------------------------------------------------------
Canny( src, src, 150, 100,3 );
imshow("【效果图】Canny边缘检测", src);
//----------------------------------------------------------------------------------
// 二、高阶的canny用法，转成灰度图，降噪，用canny，最后将得到的边缘作为掩码，拷贝原图到效果图上，得到彩色的边缘图
//----------------------------------------------------------------------------------
Mat dst,edge,gray;
// 【1】创建与src同类型和大小的矩阵(dst)
dst.create( src1.size(), src1.type() );
// 【2】将原图像转换为灰度图像
cvtColor( src1, gray, CV_BGR2GRAY );
// 【3】先用使用 3x3内核来降噪
blur( gray, edge, Size(3,3) );
// 【4】运行Canny算子
Canny( edge, edge, 3, 9,3 );
//【5】将g_dstImage内的所有元素设置为0
dst = Scalar::all(0);
//【6】使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
src1.copyTo( dst, edge);
//【7】显示效果图
imshow("【效果图】Canny边缘检测2", dst);
waitKey(0);
return 0;
}
运行效果图：
三、sobel算子篇
3.1 sobel算子相关理论与概念讲解
3.1.1 基本概念
Sobel 算子是一个主要用作边缘检测的离散微分算子 (discrete differentiation operator)。 它Sobel算子结合了高斯平滑和微分求导，用来计算图像灰度函数的近似梯度。在图像的任何一点使用此算子，将会产生对应的梯度矢量或是其法矢量。sobel算子的wikipedia：
http://zh.wikipedia.org/wiki/%E7%B4%A2%E8%B2%9D%E7%88%BE%E7%AE%97%E5%AD%90
sobel算子相关概念，还可以参看这篇博文：
http://www.cnblogs.com/lancidie/archive/2011/07/17/2108885.html
3.1.2 sobel算子的计算过程
我们假设被作用图像为 I.然后进行如下的操作：
1.分别在x和y两个方向求导。
Ⅰ.水平变化: 将 I 与一个奇数大小的内核
进行卷积。比如，当内核大小为3时,
的计算结果为:
Ⅱ.垂直变化: 将: I 与一个奇数大小的内核
进行卷积。比如，当内核大小为3时,
的计算结果为:
2.在图像的每一点，结合以上两个结果求出近似梯度:
另外有时，也可用下面更简单公式代替:
3.2 OpenCV中Sobel函数详解
Sobel函数使用扩展的 Sobel 算子，来计算一阶、二阶、三阶或混合图像差分。[cpp] view plain copyC++: void Sobel (
InputArray src,//输入图
OutputArray dst,//输出图
int ddepth,//输出图像的深度
int dx,
int dy,
int ksize=3,
double scale=1,
double delta=0,
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将原图;转化为灰度图，而是直接用彩色图操作。[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】创建 grad_x 和 grad_y 矩阵
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y,dst;
//【1】载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】sobel边缘检测", src);
//【3】求 X方向梯度
Sobel( src, grad_x, CV_16S, 1, 0, 3, 1, 1, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
imshow("【效果图】 X方向Sobel", abs_grad_x);
//【4】求Y方向梯度
Sobel( src, grad_y, CV_16S, 0, 1, 3, 1, 1, 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, 0, dst );
imshow("【效果图】整体方向Sobel", dst);
waitKey(0);
return 0;
}
运行截图如下：
四、Laplace算子篇
4.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算子将会使求导过程变得简单。
Laplacian 算子的定义:
需要点破的是，由于 Laplacian使用了图像梯度，它内部的代码其实是调用了 Sobel 算子的。
另附一个小tips：让一幅图像减去它的Laplacian可以增强对比度。
关于Laplace算子的相关概念阐述，可以参看这篇博文：
http://www.cnblogs.com/xfzhang/archive/2011/01/19/1939020.html
Laplace算子的wikipedia：
http://zh.wikipedia.org/wiki/%E6%8B%89%E6%99%AE%E6%8B%89%E6%96%AF%E7%AE%97%E5%AD%90
4.2 OpenCV中Laplacian函数详解
Laplacian函数可以计算出图像经过拉普拉斯变换后的结果。[cpp] view plain copyC++: void Laplacian(InputArray src,OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, 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函数的实例代码
让我们看一看调用实例：
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】变量的定义
Mat src,src_gray,dst, abs_dst;
//【1】载入原始图
src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】图像Laplace变换", src);
//【3】使用高斯滤波消除噪声
GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
//【4】转换为灰度图
cvtColor( src, src_gray, CV_RGB2GRAY );
//【5】使用Laplace函数
Laplacian( src_gray, dst, CV_16S, 3, 1, 0, BORDER_DEFAULT );
//【6】计算绝对值，并将结果转换成8位
convertScaleAbs( dst, abs_dst );
//【7】显示效果图
imshow( "【效果图】图像Laplace变换", abs_dst );
waitKey(0);
return 0;
}
示例效果图：
五、scharr滤波器篇
scharr一般我就直接称它为滤波器，而不是算子。上文我们已经讲到，它在OpenCV中主要是配合Sobel算子的运算而存在的,一个万年备胎。让我们直接来看看函数讲解吧。5.1 OpenCV中Scharr函数详解
使用Scharr滤波器运算符计算x或y方向的图像差分。其实它的参数变量和Sobel基本上是一样的，除了没有ksize核的大小。
[cpp] view plain copyC++: void Scharr(
InputArray src, //源图
OutputArray dst, //目标图
int ddepth,//图像深度
int dx,// x方向上的差分阶数
int dy,//y方向上的差分阶数
double scale=1,//缩放因子
double delta=0,// 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处得到更详细的信息。
不难理解，如下两者是等价的：
[cpp] view plain copyScharr(src, dst, ddepth, dx, dy, scale,delta, borderType);
与
[cpp] view plain copySobel(src, dst, ddepth, dx, dy, CV_SCHARR,scale, delta, borderType);
5.2 调用Scharr函数的实例代码
[cpp] view plain copy//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】创建 grad_x 和 grad_y 矩阵
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y,dst;
//【1】载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】Scharr滤波器", src);
//【3】求 X方向梯度
Scharr( src, grad_x, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
imshow("【效果图】 X方向Scharr", abs_grad_x);
//【4】求Y方向梯度
Scharr( src, grad_y, CV_16S, 0, 1, 1, 0, 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, 0, dst );
//【6】显示效果图
imshow("【效果图】合并梯度后Scharr", dst);
waitKey(0);
return 0;
}
运行效果图：
六、综合示例篇——在实战中熟稔
依然是每篇文章都会配给大家的一个详细注释的博文配套示例程序，把这篇文章中介绍的知识点以代码为载体，展现给大家。
这个示例程序中，分别演示了canny边缘检测，sobel边缘检测，scharr滤波器的使用，那么，上详细注释的代码吧：
[cpp] view plain copy//-----------------------------------【程序说明】----------------------------------------------
// 程序名称:：《【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑合辑》 博文配套源码
// 开发所用IDE版本：Visual Studio 2010
// <span style="white-space:pre;"> </span>开发所用OpenCV版本： 2.4.9
// 2014年5月11日 Create by 浅墨
// 浅墨的微博：@浅墨_毛星云 http://weibo.com/1723155442/profile?topnav=1&wvr=5&user=1
// 浅墨的知乎：http://www.zhihu.com/people/mao-xing-yun
// 浅墨的豆瓣：http://www.douban.com/people/53426472/
//----------------------------------------------------------------------------------------------
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】--------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【全局变量声明部分】--------------------------------------
// 描述：全局变量声明
//-----------------------------------------------------------------------------------------------
//原图，原图的灰度版，目标图
Mat g_srcImage, g_srcGrayImage,g_dstImage;
//Canny边缘检测相关变量
Mat g_cannyDetectedEdges;
int g_cannyLowThreshold=1;//TrackBar位置参数
//Sobel边缘检测相关变量
Mat g_sobelGradient_X, g_sobelGradient_Y;
Mat g_sobelAbsGradient_X, g_sobelAbsGradient_Y;
int g_sobelKernelSize=1;//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边缘检测相关代码的函数
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
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, 120, on_Canny );
createTrackbar( "参数值：", "【效果图】Sobel边缘检测", &g_sobelKernelSize, 3, on_Sobel );
// 调用回调函数
on_Canny(0, 0);
on_Sobel(0, 0);
//调用封装了Scharr边缘检测代码的函数
Scharr( );
//轮询获取按键信息，若按下Q，程序退出
while((char(waitKey(1)) != 'q')) {}
return 0;
}
//-----------------------------------【ShowHelpText( )函数】----------------------------------
// 描述：输出一些帮助信息
//----------------------------------------------------------------------------------------------
static void ShowHelpText()
{
//输出一些帮助信息
printf( "\n\n\t嗯。运行成功，请调整滚动条观察图像效果~\n\n"
"\t按下“q”键时，程序退出~!\n"
"\n\n\t\t\t\t by浅墨" );
}
//-----------------------------------【on_Canny( )函数】----------------------------------
// 描述：Canny边缘检测窗口滚动条的回调函数
//-----------------------------------------------------------------------------------------------
void on_Canny(int, void*)
{
// 先使用 3x3内核来降噪
blur( g_srcGrayImage, g_cannyDetectedEdges, Size(3,3) );
// 运行我们的Canny算子
Canny( g_cannyDetectedEdges, g_cannyDetectedEdges, g_cannyLowThreshold, g_cannyLowThreshold*3, 3 );
//先将g_dstImage内的所有元素设置为0
g_dstImage = Scalar::all(0);
//使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
g_srcImage.copyTo( g_dstImage, g_cannyDetectedEdges);
//显示效果图
imshow( "【效果图】Canny边缘检测", g_dstImage );
}
//-----------------------------------【on_Sobel( )函数】----------------------------------
// 描述：Sobel边缘检测窗口滚动条的回调函数
//-----------------------------------------------------------------------------------------
void on_Sobel(int, void*)
{
// 求 X方向梯度
Sobel( g_srcImage, g_sobelGradient_X, CV_16S, 1, 0, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
convertScaleAbs( g_sobelGradient_X, g_sobelAbsGradient_X );//计算绝对值，并将结果转换成8位
// 求Y方向梯度
Sobel( g_srcImage, g_sobelGradient_Y, CV_16S, 0, 1, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
convertScaleAbs( g_sobelGradient_Y, g_sobelAbsGradient_Y );//计算绝对值，并将结果转换成8位
// 合并梯度
addWeighted( g_sobelAbsGradient_X, 0.5, g_sobelAbsGradient_Y, 0.5, 0, g_dstImage );
//显示效果图
imshow("【效果图】Sobel边缘检测", g_dstImage);
}
//-----------------------------------【Scharr( )函数】----------------------------------
// 描述：封装了Scharr边缘检测相关代码的函数
//-----------------------------------------------------------------------------------------
void Scharr( )
{
// 求 X方向梯度
Scharr( g_srcImage, g_scharrGradient_X, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT );
convertScaleAbs( g_scharrGradient_X, g_scharrAbsGradient_X );//计算绝对值，并将结果转换成8位
// 求Y方向梯度
Scharr( g_srcImage, g_scharrGradient_Y, CV_16S, 0, 1, 1, 0, BORDER_DEFAULT );
convertScaleAbs( g_scharrGradient_Y, g_scharrAbsGradient_Y );//计算绝对值，并将结果转换成8位
// 合并梯度
addWeighted( g_scharrAbsGradient_X, 0.5, g_scharrAbsGradient_Y, 0.5, 0, g_dstImage );
//显示效果图
imshow("【效果图】Scharr滤波器", g_dstImage);
}
放出一些运行效果图：
canny边缘检测效果图：
Sobel边缘检测：
Scharr滤波器：
好的，就放出这些效果图吧，具体更多的运行效果大家就自己下载示例程序回去玩~
本篇文章的配套源代码请点击这里下载：
【浅墨OpenCV入门教程之十二】配套源代码下载
OK，今天的内容大概就是这些，我们下篇文章见：）
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- OpenCV 边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- opencv----边缘检测：canny算子、sobel算子、laplace算子、scharr滤波器
- [转]【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- 【OpenCV3图像处理】边缘检测：Sobel算子,Laplace算子,Canny算子
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器
- OpenCV学习笔记（13）OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑合辑
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑
- 学习【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑---思维导图笔记
- 【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑