【第二部分|【第二部分图像处理】第3章 Opencv图像处理进阶【2 图像变换A-边缘检测】【第二部分图像处理】第3章

2.1关于边缘检测在具体介绍之前，先来一起看看边缘检测的一般步骤吧。
【第一步】滤波：边缘检测的算法主要是基于图像强度的一阶和二阶导数，但导数通常对噪声很敏感，因此必须采用滤波器来改善与噪声有关的边缘检测器的性能。常见的滤波方法主要有高斯滤波，即采用离散化的高斯函数产生一组归一化的高斯核，然后基于高斯核函数对图像灰度矩阵的每一点进行加权求和。
【第二步】增强：增强边缘的基础是确定图像各点邻域强度的变化值。增强算法可以将图像灰度点邻域强度值有显著变化的点凸显出来。在具体编程实现时，可通过计算梯度幅值来确定。
【第三步】检测：经过增强的图像，往往邻域中有很多点的梯度值比较大，而在特定的应用中，这些点并不是我们要找的边缘点，所以应该采用某种方法来对这些点进行取舍。实际工程中，常用的方法是通过阈值化方法来检测。
另外，需要注意，下文中讲到的Laplace算子，sobel算子和Scharr算子都是带方向的，所以，示例中我们分别写了X方向,Y方向和最终合成的的效果图。
2.2具体边缘检测算法 2.2.1 canny算子篇
2.2.1.1 canny算子相关理论与概念讲解 <1> canny算子简介
Canny边缘检测算法是澳大利亚科学家John F. Canny在1986年提出来的，更为重要的是 Canny 创立了边缘检测计算理论（Computational theory ofedge detection），解释了这项技术是如何工作的。Canny边缘检测算法以Canny的名字命名，被很多人推崇为当今最优的边缘检测的算法。其中，Canny 的目标是找到一个最优的边缘检测算法，让我们看一下最优边缘检测的三个主要评价标准:
? 低错误率（即好的信噪比）: 标识出尽可能多的实际边缘，同时尽可能的减少噪声产生的误报。
? 高定位性: 标识出的边缘要与图像中的实际边缘尽可能接近。
? 最小响应: 图像中的边缘只能标识一次，并且可能存在的图像噪声不应标识为边缘。
为了满足这些要求 Canny 使用了变分法，这是一种寻找满足特定功能的函数的方法。最优检测使用四个指数函数项的和表示，但是它非常近似于高斯函数的一阶导数。
<2> Canny 边缘检测的步骤
第一步：消除噪声。一般情况下，使用高斯平滑滤波器卷积降噪。如下显示了一个 size = 5 的高斯内核示例：

文章图片

第二步：计算梯度幅值和方向。此处，按照Sobel滤波器的步骤。
Ⅰ.运用一对卷积阵列 (分别作用于 x 和 y 方向)：

文章图片

Ⅱ.使用下列公式计算梯度幅值和方向：

文章图片

梯度方向近似到四个可能角度之一(一般为0, 45, 90, 135)
第三步：对梯度和幅值进行非极大值抑制。这一步排除非边缘像素，仅仅保留了一些细线条(候选边缘)。
第四步：滞后阈值。最后一步，Canny 使用了滞后阈值，滞后阈值需要两个阈值(高阈值和低阈值):
Ⅰ.如果某一像素位置的幅值超过高阈值, 该像素被保留为边缘像素。
Ⅱ.如果某一像素位置的幅值小于低阈值, 该像素被排除。
Ⅲ.如果某一像素位置的幅值在两个阈值之间,该像素仅仅在连接到一个高于高阈值的像素时被保留。
tips：对于Canny函数的使用，推荐的高低阈值比在2:1到3:1之间。
参考：
中文
英文
2.2.1.2 Canny( )源码分析

/*【canny( )函数源代码】************************************************************* * @Version：OpenCV 3.0.0（Opnencv2和Opnencv3差别不大，Linux和win的对应版本源码完全一样，均在对应的安装目录下） * @源码路径：…\opencv\sources\modules\imgproc\src\canny.cpp * @起始行数：580行 ********************************************************************************/ void cv::Canny( InputArray _src, OutputArray _dst, double low_thresh, double high_thresh, int aperture_size, bool L2gradient ) { const int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type); const Size size = _src.size(); CV_Assert( depth == CV_8U ); _dst.create(size, CV_8U); if (!L2gradient && (aperture_size & CV_CANNY_L2_GRADIENT) == CV_CANNY_L2_GRADIENT) { // backward compatibility aperture_size &= ~CV_CANNY_L2_GRADIENT; L2gradient = true; }if ((aperture_size & 1) == 0 || (aperture_size != -1 && (aperture_size < 3 || aperture_size > 7))) CV_Error(CV_StsBadFlag, "Aperture size should be odd"); if (low_thresh > high_thresh) std::swap(low_thresh, high_thresh); CV_OCL_RUN(_dst.isUMat() && (cn == 1 || cn == 3), ocl_Canny(_src, _dst, (float)low_thresh, (float)high_thresh, aperture_size, L2gradient, cn, size))Mat src = https://www.it610.com/article/_src.getMat(), dst = _dst.getMat(); #ifdef HAVE_TEGRA_OPTIMIZATION if (tegra::useTegra() && tegra::canny(src, dst, low_thresh, high_thresh, aperture_size, L2gradient)) return; #endif#ifdef USE_IPP_CANNY CV_IPP_CHECK() { if( aperture_size == 3 && !L2gradient && 1 == cn ) { if (ippCanny(src, dst, (float)low_thresh, (float)high_thresh)) { CV_IMPL_ADD(CV_IMPL_IPP); return; } setIppErrorStatus(); } } #endif#ifdef HAVE_TBBif (L2gradient) { low_thresh = std::min(32767.0, low_thresh); high_thresh = std::min(32767.0, high_thresh); if (low_thresh> 0) low_thresh *= low_thresh; if (high_thresh > 0) high_thresh *= high_thresh; } int low = cvFloor(low_thresh); int high = cvFloor(high_thresh); ptrdiff_t mapstep = src.cols + 2; AutoBuffer buffer((src.cols+2)*(src.rows+2)); uchar* map = (uchar*)buffer; memset(map, 1, mapstep); memset(map + mapstep*(src.rows + 1), 1, mapstep); int threadsNumber = tbb::task_scheduler_init::default_num_threads(); int grainSize = src.rows / threadsNumber; // Make a fallback for pictures with too few rows. uchar ksize2 = aperture_size / 2; int minGrainSize = 1 + ksize2; int maxGrainSize = src.rows - 2 - 2*ksize2; if ( !( minGrainSize <= grainSize && grainSize <= maxGrainSize ) ) { threadsNumber = 1; grainSize = src.rows; }tbb::task_group g; for (int i = 0; i < threadsNumber; ++i) { if (i < threadsNumber - 1) g.run(tbbCanny(Range(i * grainSize, (i + 1) * grainSize), src, map, low, high, aperture_size, L2gradient)); else g.run(tbbCanny(Range(i * grainSize, src.rows), src, map, low, high, aperture_size, L2gradient)); }g.wait(); #define CANNY_PUSH_SERIAL(d)*(d) = uchar(2), borderPeaks.push(d)// now track the edges (hysteresis thresholding) uchar* m; while (borderPeaks.try_pop(m)) { if (!m[-1])CANNY_PUSH_SERIAL(m - 1); if (!m[1])CANNY_PUSH_SERIAL(m + 1); if (!m[-mapstep-1]) CANNY_PUSH_SERIAL(m - mapstep - 1); if (!m[-mapstep])CANNY_PUSH_SERIAL(m - mapstep); if (!m[-mapstep+1]) CANNY_PUSH_SERIAL(m - mapstep + 1); if (!m[mapstep-1])CANNY_PUSH_SERIAL(m + mapstep - 1); if (!m[mapstep])CANNY_PUSH_SERIAL(m + mapstep); if (!m[mapstep+1])CANNY_PUSH_SERIAL(m + mapstep + 1); }#elseMat dx(src.rows, src.cols, CV_16SC(cn)); Mat dy(src.rows, src.cols, CV_16SC(cn)); Sobel(src, dx, CV_16S, 1, 0, aperture_size, 1, 0, BORDER_REPLICATE); Sobel(src, dy, CV_16S, 0, 1, aperture_size, 1, 0, BORDER_REPLICATE); if (L2gradient) { low_thresh = std::min(32767.0, low_thresh); high_thresh = std::min(32767.0, high_thresh); if (low_thresh > 0) low_thresh *= low_thresh; if (high_thresh > 0) high_thresh *= high_thresh; } int low = cvFloor(low_thresh); int high = cvFloor(high_thresh); ptrdiff_t mapstep = src.cols + 2; AutoBuffer buffer((src.cols+2)*(src.rows+2) + cn * mapstep * 3 * sizeof(int)); int* mag_buf[3]; mag_buf[0] = (int*)(uchar*)buffer; mag_buf[1] = mag_buf[0] + mapstep*cn; mag_buf[2] = mag_buf[1] + mapstep*cn; memset(mag_buf[0], 0, /* cn* */mapstep*sizeof(int)); uchar* map = (uchar*)(mag_buf[2] + mapstep*cn); memset(map, 1, mapstep); memset(map + mapstep*(src.rows + 1), 1, mapstep); int maxsize = std::max(1 << 10, src.cols * src.rows / 10); std::vector stack(maxsize); uchar **stack_top = &stack[0]; uchar **stack_bottom = &stack[0]; /* sector numbers (Top-Left Origin)123 *** * * * 0*******0 * * * *** 321 */#define CANNY_PUSH(d)*(d) = uchar(2), *stack_top++ = (d) #define CANNY_POP(d)(d) = *--stack_top#if CV_SSE2 bool haveSSE2 = checkHardwareSupport(CV_CPU_SSE2); #endif// calculate magnitude and angle of gradient, perform non-maxima suppression. // fill the map with one of the following values: //0 - the pixel might belong to an edge //1 - the pixel can not belong to an edge //2 - the pixel does belong to an edge for (int i = 0; i <= src.rows; i++) { int* _norm = mag_buf[(i > 0) + 1] + 1; if (i < src.rows) { short* _dx = dx.ptr(i); short* _dy = dy.ptr(i); if (!L2gradient) { int j = 0, width = src.cols * cn; #if CV_SSE2 if (haveSSE2) { __m128i v_zero = _mm_setzero_si128(); for ( ; j <= width - 8; j += 8) { __m128i v_dx = _mm_loadu_si128((const __m128i *)(_dx + j)); __m128i v_dy = _mm_loadu_si128((const __m128i *)(_dy + j)); v_dx = _mm_max_epi16(v_dx, _mm_sub_epi16(v_zero, v_dx)); v_dy = _mm_max_epi16(v_dy, _mm_sub_epi16(v_zero, v_dy)); __m128i v_norm = _mm_add_epi32(_mm_unpacklo_epi16(v_dx, v_zero), _mm_unpacklo_epi16(v_dy, v_zero)); _mm_storeu_si128((__m128i *)(_norm + j), v_norm); v_norm = _mm_add_epi32(_mm_unpackhi_epi16(v_dx, v_zero), _mm_unpackhi_epi16(v_dy, v_zero)); _mm_storeu_si128((__m128i *)(_norm + j + 4), v_norm); } } #elif CV_NEON for ( ; j <= width - 8; j += 8) { int16x8_t v_dx = vld1q_s16(_dx + j), v_dy = vld1q_s16(_dy + j); vst1q_s32(_norm + j, vaddq_s32(vabsq_s32(vmovl_s16(vget_low_s16(v_dx))), vabsq_s32(vmovl_s16(vget_low_s16(v_dy))))); vst1q_s32(_norm + j + 4, vaddq_s32(vabsq_s32(vmovl_s16(vget_high_s16(v_dx))), vabsq_s32(vmovl_s16(vget_high_s16(v_dy))))); } #endif for ( ; j < width; ++j) _norm[j] = std::abs(int(_dx[j])) + std::abs(int(_dy[j])); } else { int j = 0, width = src.cols * cn; #if CV_SSE2 if (haveSSE2) { for ( ; j <= width - 8; j += 8) { __m128i v_dx = _mm_loadu_si128((const __m128i *)(_dx + j)); __m128i v_dy = _mm_loadu_si128((const __m128i *)(_dy + j)); __m128i v_dx_ml = _mm_mullo_epi16(v_dx, v_dx), v_dx_mh = _mm_mulhi_epi16(v_dx, v_dx); __m128i v_dy_ml = _mm_mullo_epi16(v_dy, v_dy), v_dy_mh = _mm_mulhi_epi16(v_dy, v_dy); __m128i v_norm = _mm_add_epi32(_mm_unpacklo_epi16(v_dx_ml, v_dx_mh), _mm_unpacklo_epi16(v_dy_ml, v_dy_mh)); _mm_storeu_si128((__m128i *)(_norm + j), v_norm); v_norm = _mm_add_epi32(_mm_unpackhi_epi16(v_dx_ml, v_dx_mh), _mm_unpackhi_epi16(v_dy_ml, v_dy_mh)); _mm_storeu_si128((__m128i *)(_norm + j + 4), v_norm); } } #elif CV_NEON for ( ; j <= width - 8; j += 8) { int16x8_t v_dx = vld1q_s16(_dx + j), v_dy = vld1q_s16(_dy + j); int16x4_t v_dxp = vget_low_s16(v_dx), v_dyp = vget_low_s16(v_dy); int32x4_t v_dst = vmlal_s16(vmull_s16(v_dxp, v_dxp), v_dyp, v_dyp); vst1q_s32(_norm + j, v_dst); v_dxp = vget_high_s16(v_dx), v_dyp = vget_high_s16(v_dy); v_dst = vmlal_s16(vmull_s16(v_dxp, v_dxp), v_dyp, v_dyp); vst1q_s32(_norm + j + 4, v_dst); } #endif for ( ; j < width; ++j) _norm[j] = int(_dx[j])*_dx[j] + int(_dy[j])*_dy[j]; }if (cn > 1) { for(int j = 0, jn = 0; j < src.cols; ++j, jn += cn) { int maxIdx = jn; for(int k = 1; k < cn; ++k) if(_norm[jn + k] > _norm[maxIdx]) maxIdx = jn + k; _norm[j] = _norm[maxIdx]; _dx[j] = _dx[maxIdx]; _dy[j] = _dy[maxIdx]; } } _norm[-1] = _norm[src.cols] = 0; } else memset(_norm-1, 0, /* cn* */mapstep*sizeof(int)); // at the very beginning we do not have a complete ring // buffer of 3 magnitude rows for non-maxima suppression if (i == 0) continue; uchar* _map = map + mapstep*i + 1; _map[-1] = _map[src.cols] = 1; int* _mag = mag_buf[1] + 1; // take the central row ptrdiff_t magstep1 = mag_buf[2] - mag_buf[1]; ptrdiff_t magstep2 = mag_buf[0] - mag_buf[1]; const short* _x = dx.ptr(i-1); const short* _y = dy.ptr(i-1); if ((stack_top - stack_bottom) + src.cols > maxsize) { int sz = (int)(stack_top - stack_bottom); maxsize = std::max(maxsize * 3/2, sz + src.cols); stack.resize(maxsize); stack_bottom = &stack[0]; stack_top = stack_bottom + sz; }int prev_flag = 0; for (int j = 0; j < src.cols; j++) { #define CANNY_SHIFT 15 const int TG22 = (int)(0.4142135623730950488016887242097*(1< low) { int xs = _x[j]; int ys = _y[j]; int x = std::abs(xs); int y = std::abs(ys) << CANNY_SHIFT; int tg22x = x * TG22; if (y < tg22x) { if (m > _mag[j-1] && m >= _mag[j+1]) goto __ocv_canny_push; } else { int tg67x = tg22x + (x << (CANNY_SHIFT+1)); if (y > tg67x) { if (m > _mag[j+magstep2] && m >= _mag[j+magstep1]) goto __ocv_canny_push; } else { int s = (xs ^ ys) < 0 ? -1 : 1; if (m > _mag[j+magstep2-s] && m > _mag[j+magstep1+s]) goto __ocv_canny_push; } } } prev_flag = 0; _map[j] = uchar(1); continue; __ocv_canny_push: if (!prev_flag && m > high && _map[j-mapstep] != 2) { CANNY_PUSH(_map + j); prev_flag = 1; } else _map[j] = 0; }// scroll the ring buffer _mag = mag_buf[0]; mag_buf[0] = mag_buf[1]; mag_buf[1] = mag_buf[2]; mag_buf[2] = _mag; }// now track the edges (hysteresis thresholding) while (stack_top > stack_bottom) { uchar* m; if ((stack_top - stack_bottom) + 8 > maxsize) { int sz = (int)(stack_top - stack_bottom); maxsize = maxsize * 3/2; stack.resize(maxsize); stack_bottom = &stack[0]; stack_top = stack_bottom + sz; }CANNY_POP(m); if (!m[-1])CANNY_PUSH(m - 1); if (!m[1])CANNY_PUSH(m + 1); if (!m[-mapstep-1]) CANNY_PUSH(m - mapstep - 1); if (!m[-mapstep])CANNY_PUSH(m - mapstep); if (!m[-mapstep+1]) CANNY_PUSH(m - mapstep + 1); if (!m[mapstep-1])CANNY_PUSH(m + mapstep - 1); if (!m[mapstep])CANNY_PUSH(m + mapstep); if (!m[mapstep+1])CANNY_PUSH(m + mapstep + 1); }#endif// the final pass, form the final image const uchar* pmap = map + mapstep + 1; uchar* pdst = dst.ptr(); for (int i = 0; i < src.rows; i++, pmap += mapstep, pdst += dst.step) { for (int j = 0; j < src.cols; j++) pdst[j] = (uchar)-(pmap[j] >> 1); } }

我们在看看低版本函数的源码。

/*【cvCanny( )函数源代码】*********************************************************** * @Version：OpenCV 3.0.0（Opnencv2和Opnencv3差别不大，Linux和win的对应版本源码完全一样，均在对应的安装目录下） * @源码路径：…\opencv\sources\modules\imgproc\src\canny.cpp * @起始行数：963行 ********************************************************************************/void cvCanny( const CvArr* image, CvArr* edges, double threshold1, double threshold2, int aperture_size ) { cv::Mat src = https://www.it610.com/article/cv::cvarrToMat(image), dst = cv::cvarrToMat(edges); CV_Assert( src.size == dst.size && src.depth() == CV_8U && dst.type() == CV_8U ); cv::Canny(src, dst, threshold1, threshold2, aperture_size & 255, (aperture_size & CV_CANNY_L2_GRADIENT) != 0); }

值得一提的是，对于3.0以上版本是兼低版本函数的调用，通过源码可以发现，低版本的函数就是调用高版本的函数。
2.2.1.3 Canny( )函数详解 Canny函数利用Canny算法来进行图像的边缘检测。

C++: 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之间。
调用示例：

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

如上三句，就有结果出来，非常好用。
2.2.1.4 调用Canny函数的实例 OpenCV中调用Canny函数的实例代码如下：
代码参见附件【demo1】。

【第二部分|【第二部分图像处理】第3章 Opencv图像处理进阶【2 图像变换A-边缘检测】

文章图片

图1

文章图片

图2
参考：
英文
中文
2.2.2 sobel算子篇
2.2.2.1 sobel算子相关理论与概念讲解 <1>基本概念
Sobel 算子是一个主要用作边缘检测的离散微分算子 (discrete differentiation operator)。它Sobel算子结合了高斯平滑和微分求导，用来计算图像灰度函数的近似梯度。在图像的任何一点使用此算子，将会产生对应的梯度矢量或是其法矢量。
<2> sobel算子的计算过程
我们假设被作用图像为 I.然后进行如下的操作：
1.分别在x和y两个方向求导。
Ⅰ.水平变化: 将 I 与一个奇数大小的内核进行卷积。比如，当内核大小为3时, 的计算结果为:

文章图片

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

文章图片

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

文章图片

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

文章图片

2.2.2.2 Sobel( )源码分析

/*【Sobel( )函数源代码】************************************************************ * @Version：OpenCV 3.0.0（Opnencv2和Opnencv3差别不大，Linux和win的对应版本源码完全一样，均在对应的安装目录下） * @源码路径：…\opencv\sources\modules\imgproc\src\deriv.cpp * @起始行数：555行 ********************************************************************************/ void cv::Sobel( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType ) { int stype = _src.type(), sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype); if (ddepth < 0) ddepth = sdepth; int dtype = CV_MAKE_TYPE(ddepth, cn); _dst.create( _src.size(), dtype ); #ifdef HAVE_TEGRA_OPTIMIZATION if (tegra::useTegra() && scale == 1.0 && delta == 0) { Mat src = https://www.it610.com/article/_src.getMat(), dst = _dst.getMat(); if (ksize == 3 && tegra::sobel3x3(src, dst, dx, dy, borderType)) return; if (ksize == -1 && tegra::scharr(src, dst, dx, dy, borderType)) return; } #endif#ifdef HAVE_IPP CV_IPP_CHECK() { if (ksize < 0) { if (IPPDerivScharr(_src, _dst, ddepth, dx, dy, scale, delta, borderType)) { CV_IMPL_ADD(CV_IMPL_IPP); return; } } else if (0 < ksize) { if (IPPDerivSobel(_src, _dst, ddepth, dx, dy, ksize, scale, delta, borderType)) { CV_IMPL_ADD(CV_IMPL_IPP); return; } } } #endif int ktype = std::max(CV_32F, std::max(ddepth, sdepth)); Mat kx, ky; getDerivKernels( kx, ky, dx, dy, ksize, false, ktype ); if( scale != 1 ) { // usually the smoothing part is the slowest to compute, // so try to scale it instead of the faster differenciating part if( dx == 0 ) kx *= scale; else ky *= scale; } sepFilter2D( _src, _dst, ddepth, kx, ky, Point(-1, -1), delta, borderType ); }

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

C++: 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】对应的内核：

文章图片

2.2.2.4 调用Sobel( )函数的实例代码调用Sobel函数的实例代码如下。这里只是教大家如何使用Sobel函数，就没有先用一句cvtColor将原图; 转化为灰度图，而是直接用彩色图操作。
代码参考附件【demo2】。

图3 X方向

图4Y方向

图5整体方向
参考：
英文
中文
2.2.3 Laplace算子篇
2.2.3.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可以增强对比度。
2.2.3.2 Laplacian( )源码分析

/*【Laplacian ( )函数源代码】********************************************************** * @Version：OpenCV 3.0.0（Opnencv2和Opnencv3差别不大，Linux和win的对应版本源码完全一样，均在对应的安装目录下） * @源码路径：…\opencv\sources\modules\imgproc\src\deriv.cpp * @起始行数：802行 ********************************************************************************/ void cv::Laplacian( InputArray _src, OutputArray _dst, int ddepth, int ksize, double scale, double delta, int borderType ) { int stype = _src.type(), sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype); if (ddepth < 0) ddepth = sdepth; _dst.create( _src.size(), CV_MAKETYPE(ddepth, cn) ); #ifdef HAVE_IPP CV_IPP_CHECK() { if ((ksize == 3 || ksize == 5) && ((borderType & BORDER_ISOLATED) != 0 || !_src.isSubmatrix()) && ((stype == CV_8UC1 && ddepth == CV_16S) || (ddepth == CV_32F && stype == CV_32FC1)) && !ocl::useOpenCL()) { int iscale = saturate_cast(scale), idelta = saturate_cast(delta); bool floatScale = std::fabs(scale - iscale) > DBL_EPSILON, needScale = iscale != 1; bool floatDelta = std::fabs(delta - idelta) > DBL_EPSILON, needDelta = delta != 0; int borderTypeNI = borderType & ~BORDER_ISOLATED; Mat src = https://www.it610.com/article/_src.getMat(), dst = _dst.getMat(); if (src.data != dst.data) { Ipp32s bufsize; IppStatus status = (IppStatus)-1; IppiSize roisize = { src.cols, src.rows }; IppiMaskSize masksize = ksize == 3 ? ippMskSize3x3 : ippMskSize5x5; IppiBorderType borderTypeIpp = ippiGetBorderType(borderTypeNI); #define IPP_FILTER_LAPLACIAN(ippsrctype, ippdsttype, ippfavor) \ do \ { \ if (borderTypeIpp>= 0 && ippiFilterLaplacianGetBufferSize_##ippfavor##_C1R(roisize, masksize, &bufsize) >= 0) \ { \ Ipp8u * buffer = ippsMalloc_8u(bufsize); \ status = ippiFilterLaplacianBorder_##ippfavor##_C1R(src.ptr(), (int)src.step, dst.ptr(), \ (int)dst.step, roisize, masksize, borderTypeIpp, 0, buffer); \ ippsFree(buffer); \ } \ } while ((void)0, 0)CV_SUPPRESS_DEPRECATED_START if (sdepth == CV_8U && ddepth == CV_16S && !floatScale && !floatDelta) { IPP_FILTER_LAPLACIAN(Ipp8u, Ipp16s, 8u16s); if (needScale && status >= 0) status = ippiMulC_16s_C1IRSfs((Ipp16s)iscale, dst.ptr(), (int)dst.step, roisize, 0); if (needDelta && status >= 0) status = ippiAddC_16s_C1IRSfs((Ipp16s)idelta, dst.ptr(), (int)dst.step, roisize, 0); } else if (sdepth == CV_32F && ddepth == CV_32F) { IPP_FILTER_LAPLACIAN(Ipp32f, Ipp32f, 32f); if (needScale && status >= 0) status = ippiMulC_32f_C1IR((Ipp32f)scale, dst.ptr(), (int)dst.step, roisize); if (needDelta && status >= 0) status = ippiAddC_32f_C1IR((Ipp32f)delta, dst.ptr(), (int)dst.step, roisize); } CV_SUPPRESS_DEPRECATED_ENDif (status >= 0) { CV_IMPL_ADD(CV_IMPL_IPP); return; } setIppErrorStatus(); } } #undef IPP_FILTER_LAPLACIAN } #endif#ifdef HAVE_TEGRA_OPTIMIZATION if (tegra::useTegra() && scale == 1.0 && delta == 0) { Mat src = https://www.it610.com/article/_src.getMat(), dst = _dst.getMat(); if (ksize == 1 && tegra::laplace1(src, dst, borderType)) return; if (ksize == 3 && tegra::laplace3(src, dst, borderType)) return; if (ksize == 5 && tegra::laplace5(src, dst, borderType)) return; } #endifif( ksize == 1 || ksize == 3 ) { float K[2][9] = { { 0, 1, 0, 1, -4, 1, 0, 1, 0 }, { 2, 0, 2, 0, -8, 0, 2, 0, 2 } }; Mat kernel(3, 3, CV_32F, K[ksize == 3]); if( scale != 1 ) kernel *= scale; filter2D( _src, _dst, ddepth, kernel, Point(-1, -1), delta, borderType ); } else { int ktype = std::max(CV_32F, std::max(ddepth, sdepth)); int wdepth = sdepth == CV_8U && ksize <= 5 ? CV_16S : sdepth <= CV_32F ? CV_32F : CV_64F; int wtype = CV_MAKETYPE(wdepth, cn); Mat kd, ks; getSobelKernels( kd, ks, 2, 0, ksize, false, ktype ); CV_OCL_RUN(_dst.isUMat(), ocl_Laplacian5(_src, _dst, kd, ks, scale, delta, borderType, wdepth, ddepth))const size_t STRIPE_SIZE = 1 << 14; Ptr fx = createSeparableLinearFilter(stype, wtype, kd, ks, Point(-1,-1), 0, borderType, borderType, Scalar() ); Ptr fy = createSeparableLinearFilter(stype, wtype, ks, kd, Point(-1,-1), 0, borderType, borderType, Scalar() ); Mat src = https://www.it610.com/article/_src.getMat(), dst = _dst.getMat(); int y = fx->start(src), dsty = 0, dy = 0; fy->start(src); const uchar* sptr = src.ptr(y); int dy0 = std::min(std::max((int)(STRIPE_SIZE/(CV_ELEM_SIZE(stype)*src.cols)), 1), src.rows); Mat d2x( dy0 + kd.rows - 1, src.cols, wtype ); Mat d2y( dy0 + kd.rows - 1, src.cols, wtype ); for( ; dsty < src.rows; sptr += dy0*src.step, dsty += dy ) { fx->proceed( sptr, (int)src.step, dy0, d2x.ptr(), (int)d2x.step ); dy = fy->proceed( sptr, (int)src.step, dy0, d2y.ptr(), (int)d2y.step ); if( dy > 0 ) { Mat dstripe = dst.rowRange(dsty, dsty + dy); d2x.rows = d2y.rows = dy; // modify the headers, which should work d2x += d2y; d2x.convertTo( dstripe, ddepth, scale, delta ); } } } }

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

C++: 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的孔径：

文章图片

2.2.3.4调用Laplacian( )函数的实例代码让我们看一看调用实例。
代码参考附件【demo3】

文章图片

图6
参考：
中文
英文
2.2.4 scharr滤波器篇
scharr一般我就直接称它为滤波器，而不是算子。上文我们已经讲到，它在OpenCV中主要是配合Sobel算子的运算而存在的,一个万年备胎。让我们直接来看看函数讲解吧。
2.2.4.1 Scharr( )源码分析

/*【Scharr ( )函数源代码】********************************************************** * @Version：OpenCV 3.0.0（Opnencv2和Opnencv3差别不大，Linux和win的对应版本源码完全一样，均在对应的安装目录下） * @源码路径：…\opencv\sources\modules\imgproc\src\deriv.cpp * @起始行数：613行 ********************************************************************************/ void cv::Scharr( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy, double scale, double delta, int borderType ) { int stype = _src.type(), sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype); if (ddepth < 0) ddepth = sdepth; int dtype = CV_MAKETYPE(ddepth, cn); _dst.create( _src.size(), dtype ); #ifdef HAVE_TEGRA_OPTIMIZATION if (tegra::useTegra() && scale == 1.0 && delta == 0) { Mat src = https://www.it610.com/article/_src.getMat(), dst = _dst.getMat(); if (tegra::scharr(src, dst, dx, dy, borderType)) return; } #endif#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR>= 7) CV_IPP_CHECK() { if (IPPDerivScharr(_src, _dst, ddepth, dx, dy, scale, delta, borderType)) { CV_IMPL_ADD(CV_IMPL_IPP); return; } } #endif int ktype = std::max(CV_32F, std::max(ddepth, sdepth)); Mat kx, ky; getScharrKernels( kx, ky, dx, dy, false, ktype ); if( scale != 1 ) { // usually the smoothing part is the slowest to compute, // so try to scale it instead of the faster differenciating part if( dx == 0 ) kx *= scale; else ky *= scale; } sepFilter2D( _src, _dst, ddepth, kx, ky, Point(-1, -1), delta, borderType ); }

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

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

【参数】
第一个参数，InputArray 类型的src，为输入图像，填Mat类型即可。
第二个参数，OutputArray类型的dst，即目标图像，函数的输出参数，需要和源图片有一样的尺寸和类型。
第三个参数，int类型的ddepth，输出图像的深度，支持如下src.depth()和ddepth的组合：
? 若src.depth() = CV_8U, 取ddepth =-1/CV_16S/CV_32F/CV_64F
? 若src.depth() = CV_16U/CV_16S, 取ddepth =-1/CV_32F/CV_64F
? 若src.depth() = CV_32F, 取ddepth =-1/CV_32F/CV_64F
? 若src.depth() = CV_64F, 取ddepth = -1/CV_64F
第四个参数，int类型dx，x方向上的差分阶数。
第五个参数，int类型dy，y方向上的差分阶数。
第六个参数，double类型的scale，计算导数值时可选的缩放因子，默认值是1，表示默认情况下是没有应用缩放的。我们可以在文档中查阅getDerivKernels的相关介绍，来得到这个参数的更多信息。
第七个参数，double类型的delta，表示在结果存入目标图（第二个参数dst）之前可选的delta值，有默认值0。
第八个参数， int类型的borderType，我们的老朋友了（万年是最后一个参数），边界模式，默认值为BORDER_DEFAULT。这个参数可以在官方文档中borderInterpolate处得到更详细的信息。
不难理解，如下两者是等价的：
Scharr(src, dst, ddepth, dx, dy, scale,delta, borderType); 与
Sobel(src, dst, ddepth, dx, dy, CV_SCHARR,scale, delta, borderType);
2.2.4.3调用Scharr函数的实例代码参看附件【demo4】

图7 X方向

图8 Y方向

图9整体效果
2.2.5边缘检测综合实例
这个示例程序中，分别演示了canny边缘检测，sobel边缘检测，scharr滤波器的使用。
代码参看附件【demo5】，放出一些运行效果图。

文章图片

图10 canny边缘检测效果

文章图片

图11 Sobel边缘检测

图12 Scharr滤波器
参考论文：
A Computational Approach to Edge Detection-1986【论文在附件中】
本章附件点击进入
【【第二部分|【第二部分图像处理】第3章 Opencv图像处理进阶【2 图像变换A-边缘检测】】【注意】博主在附件中的代码只有Linux版本的，如何使用Windows使用该代码请参看博主的另一篇博文
Opencv环境搭建（Visual Studio+Windows）- 请点击
有任何问题请联系博主。