算法Canny边缘检测用高斯滤波器平滑图像-YiruiWu

canny边缘检测的原理
Canny边缘检测是一种多级检测算法，其基本原理如下：
首先，使用高斯滤波器对图像进行平滑处理，以减少图像中的噪声。

然后，计算图像的梯度大小和方向，以便确定边缘的位置和方向。

在计算梯度的过程中，会遍历每个像素点，判断该像素点是否为边缘点。

在Canny算法中，非极大值抑制和双阈值法是两个关键步骤。

非极大值抑制的目的是去除那些非边缘的像素点，保留可能的边缘点。

双阈值法则是为了进一步筛选出真正的边缘点，避免出现过多的假边缘。

最后，Canny算法会对检测到的边缘进行跟踪和连接，形成完整的边缘图像。

总的来说，Canny边缘检测算法是一种非常有效的边缘检测算法，能够准确地检测出图像中的边缘，并且在处理噪声和防止假边缘方面具有很好的性能。

Canny检测算法与实现1、原理图象边缘就是图像颜⾊快速变化的位置，对于灰度图像来说，也就是灰度值有明显变化的位置。

图像边缘信息主要集中在⾼频段，图像锐化或检测边缘实质就是⾼通滤波。

数值微分可以求变化率，在图像上离散值求梯度，图像处理中有多种边缘检测（梯度）算⼦，常⽤的包括普通⼀阶差分，Robert算⼦（交叉差分），Sobel算⼦，⼆阶拉普拉斯算⼦等等，是基于寻找梯度强度。

Canny 边缘检测算法是John F. Canny 于1986年开发出来的⼀个多级边缘检测算法，也被很多⼈认为是边缘检测的最优算法, 最优边缘检测的三个主要评价标准是:低错误率: 标识出尽可能多的实际边缘，同时尽可能的减少噪声产⽣的误报。

⾼定位性: 标识出的边缘要与图像中的实际边缘尽可能接近。

最⼩响应: 图像中的边缘只能标识⼀次。

Canny算⼦求边缘点具体算法步骤如下：1. ⽤⾼斯滤波器平滑图像．2. ⽤⼀阶偏导有限差分计算梯度幅值和⽅向.3. 对梯度幅值进⾏⾮极⼤值抑制.4. ⽤双阈值算法检测和连接边缘．2、实现步骤2.1、消除噪声使⽤⾼斯平滑滤波器卷积降噪。

下⾯显⽰了⼀个 size = 5 的⾼斯内核⽰例:2.2、计算梯度幅值和⽅向按照Sobel滤波器的步骤，计算⽔平和垂直⽅向的差分Gx和Gy：在vs中可以看到sobel像素值和形状：梯度幅值和⽅向为：梯度⽅向近似到四个可能⾓度之⼀(⼀般 0, 45, 90, 135)。

2.3、⾮极⼤值抑制⾮极⼤值抑制是指寻找像素点局部最⼤值。

sobel算⼦检测出来的边缘太粗了，我们需要抑制那些梯度不够⼤的像素点，只保留最⼤的梯度，从⽽达到瘦边的⽬的。

沿着梯度⽅向，⽐较它前⾯和后⾯的梯度值，梯度不够⼤的像素点很可能是某⼀条边缘的过渡点，排除⾮边缘像素，最后保留了⼀些细线。

在John Canny提出的Canny算⼦的论⽂中，⾮最⼤值抑制就只是在0、90、45、135四个梯度⽅向上进⾏的，每个像素点梯度⽅向按照相近程度⽤这四个⽅向来代替。

一．Canny边缘检测算法原理JohnCanny于1986年提出Canny算子，属于是先平滑后求导数的方法。

其处理过程大体上分为下面四部分。

1. 对原始图像进行灰度化Canny算法通常处理的图像为灰度图，因此如果获取的是彩色图像，那首先就得进行灰度化。

对一幅彩色图进行灰度化，就是根据图像各个通道的采样值进行加权平均。

以RGB格式的彩图为例，通常灰度化采用的方法主要有：方法1：Gray=(R+G+B)/3;方法2：Gray=0.299R+0.587G+0.114B;（这种参数考虑到了人眼的生理特点）至于其他格式的彩色图像，可以根据相应的转换关系转为RGB然后再进行灰度化；在编程时要注意图像格式中RGB的顺序通常为BGR。

2. 对图像进行高斯滤波图像高斯滤波的实现可以用两个一维高斯核分别两次加权实现，也可以通过一个二维高斯核一次卷积实现。

1）高斯核实现上式为离散化的一维高斯函数，确定参数就可以得到一维核向量。

上式为离散化的二维高斯函数，确定参数就可以得到二维核向量。

在求得高斯核后，要对整个核进行归一化处理。

2）图像高斯滤波对图像进行高斯滤波，其实就是根据待滤波的像素点及其邻域点的灰度值按照一定的参数规则进行加权平均。

这样可以有效滤去理想图像中叠加的高频噪声。

通常滤波和边缘检测是矛盾的概念，抑制了噪声会使得图像边缘模糊，这会增加边缘定位的不确定性；而如果要提高边缘检测的灵敏度，同时对噪声也提高了灵敏度。

实际工程经验表明，高斯函数确定的核可以在抗噪声干扰和边缘检测精确定位之间提供较好的折衷方案。

3. 用一阶偏导的有限差分来计算梯度的幅值和方向关于图像灰度值得梯度可使用一阶有限差分来进行近似，这样就可以得图像在x和y 方向上偏导数的两个矩阵。

常用的梯度算子有如下几种：1）Roberts算子上式为其x和y方向偏导数计算模板，可用数学公式表达其每个点的梯度幅值为：2）Sobel算子上式三个矩阵分别为该算子的x向卷积模板、y向卷积模板以及待处理点的邻域点标记矩阵，据此可用数学公式表达其每个点的梯度幅值为：3）Prewitt算子和Sobel算子原理一样，在此仅给出其卷积模板。

基于sobel和canny算法的水珠边缘检测李建国1，李幸汶1，卜祥洲1，陈涛2（1.河南宏博测控技术有限公司；2.河南工业大学）摘要：水珠识别分析方法是利用数字图像处理及模式识别技术实现，本文简要说明了水珠通过边缘检测实现模式识别和计算的原理。

同时，着重讨论了水珠识别过程中的噪声识别算法，详尽地阐述了识别过程中的阈值选取方法。

此应用表明了算法的实时性好，可靠性高，能很好地满足工业生产和检测要求，大大提高了水珠识别的自动化与智能化。

关键词：水珠识别边缘检测边缘轮廓引言图像识别是计算机视觉领域的一个非常活跃的课题。

近几年来人们对图像识别做了大量的研究，提出了很多种算法和方法，但电力行业应用的相对较少。

传统的图像识别方法已不能满足高精度，高效率的要求。

电力输配电企业对绝缘子的憎水性要求较高，因为其憎水性直接决定着绝缘子绝缘性能的好坏，并可以减少高压电击穿和污闪故障的发生。

因绝缘子的憎水性变差而导致泄漏电流的增加，大大提高了输配电线路的安全隐患。

因此，迫切需要提高绝缘子憎水性能安全检测的手段，实现检测的自动化和智能化。

目前，检测系统都是拆卸绝缘子并通过实验室法进行测试，不能实现在线检测。

对于在线喷水并通过CCD取像得到的图像，核心功能是水珠识别算法，算法的不同就决定了检测效果有很大的差别。

那么，设计一个既快速又稳定的水珠识别算法，对水珠识别来说具有十分重要的意义。

本文就是在如何准确提取水珠面积（或轮廓）的思想下，提出的一种新的识别算法。

且通过人机交互接口，还可以满足其它行业（如建材或医疗）不同精度和质量级别需求。

工作原理其基本工作原理：喷水装置在喷雾过程中，通过取像CCD（Charge coupled Device）在线拍摄图像数据，图像数据经图像采集卡收集并传入计算机，由系统水珠识别算法设置相应的阈值，检测水珠边缘界线并计算水珠面积和所占用面积比，同时通过水珠的边缘轮廓计算水珠的形状因子。

形状因子决定了水珠是否有粘连或流动，而面积反应了水珠的大小。

学习笔记-canny边缘检测Canny边缘检测声明：阅读本⽂需要了解线性代数⾥⾯的点乘（图像卷积的原理），⾼等数学⾥的⼆元函数的梯度，极⼤值定义，了解概率论⾥的⼆维⾼斯分布1.canny边缘检测原理和简介2.实现步骤3.总结⼀、 Canny边缘检测算法的发展历史 边缘检测是从图像中提取有⽤的结构信息的⼀种技术，如果学过信息论就会知道，⼀⾯充满花纹的墙要⽐⼀⾯⽩墙的信息量⼤很多，没学过也没关系，直观上也能理解：充满花纹的图像要⽐单⾊图像信息更丰富。

为什么要检测边缘?因为我们需要计算机⾃动的提取图像的底层（纹理等）或者⾼层（时间地点⼈物等）的信息，边缘可以说是最直观、最容易发现的⼀种信息了。

Canny提出了⼀个对于边缘检测算法的评价标准，包括：1) 以低的错误率检测边缘，也即意味着需要尽可能准确的捕获图像中尽可能多的边缘。

2) 检测到的边缘应精确定位在真实边缘的中⼼。

3) 图像中给定的边缘应只被标记⼀次，并且在可能的情况下，图像的噪声不应产⽣假的边缘。

简单来说就是，检测算法要做到：边缘要全，位置要准，抵抗噪声的能⼒要强。

接下来介绍最经典的canny边缘检测算法，很多边缘检测算法都是在此基础上进⾏改进的，学习它有利于⼀通百通。

⼆、实现步骤 step1：⾼斯平滑滤波没有哪张图⽚是没有噪声的。

————鲁迅 滤波是为了去除噪声，选⽤⾼斯滤波也是因为在众多噪声滤波器中，⾼斯表现最好（表现怎么定义的？最好好到什么程度？），你也可以试试其他滤波器如均值滤波、中值滤波等等。

⼀个⼤⼩为(2k+1)x(2k+1)的⾼斯滤波器核（核⼀般都是奇数尺⼨的）的⽣成⽅程式由下式给出：‘ 下⾯是⼀个sigma = 1.4，尺⼨为3x3的⾼斯卷积核的例⼦，注意矩阵求和值为1（归⼀化）： 举个例⼦：若图像中⼀个3x3的窗⼝为A，要滤波的像素点为e，则经过⾼斯滤波之后，像素点e的亮度值为： 其中*为卷积符号，sum表⽰矩阵中所有元素相加求和，简单说，就是滤波后的每个像素值=其原像素中⼼值及其相邻像素的加权求和。

一种改进的Canny算子边缘检测算法宗露艳;吴陈【摘要】边缘是图像的基本特征之一,因此在图像处理中图像边缘检测是图像处理的一个重要部分.由于传统的Canny边缘检测算法是通过在2×2领域内求有限差分来计算梯度幅值的,易受噪声的影响,容易检测出孤立点和伪边缘.在基于传统的Canny边缘检测算法的基础上,采用3×3领域的梯度幅值计算方法,提高了边缘的定位精度,改善了对噪声的敏感性.实验结果表明,该算法在保证实时性的同时,具有更好的检测精度和准确度.%Edge is one of the basic characteristics of the image, so image edge detection is an important part of image proccssing.The traditional Canny edge detection algorithm found finite difference in 2 × 2 field to calculate gradient amplitude, so it can be easily affected by the noise, and the outlier and untrue edge can be easily detected.A 3×3 field gradient magnitude calculation method is used based on the traditional Canny edge detection algorithm.This method proves that it can improve the image's edge positioning accuracy and the sensitivity tonoise.Experimental results indicate that this algorithm has better examination precision and accuracy during guarantee its real-time performance.【期刊名称】《现代电子技术》【年(卷),期】2011(034)004【总页数】3页(P104-106)【关键词】Canny算子;边缘检测;图像处理;梯度幅值【作者】宗露艳;吴陈【作者单位】江苏科技大学,计算机科学与工程学院,江苏镇江212003;江苏科技大学,计算机科学与工程学院,江苏镇江212003【正文语种】中文【中图分类】TN919-34;TP3910 引言图像的边缘是图像灰度发生空间突变或在梯度方向上发生突变的像素集合。

Canny 边缘检测算法【OpenCV】Canny 边缘检测分类：【OpenCV】2012-08-08 10:17 490人阅读评论(10) 收藏举报Canny 边缘检测算法1986年，JOHN CANNY 提出一个很好的边缘检测算法，被称为Canny编边缘检测器[1]。

Canny边缘检测根据对信噪比与定位乘积进行测度，得到最优化逼近算子，也就是Canny算子。

类似与LoG边缘检测方法，也属于先平滑后求导数的方法。

使用Canny边缘检测器，图象边缘检测必须满足两个条件：能有效地抑制噪声；必须尽量精确确定边缘的位置。

算法大致流程：1、求图像与高斯平滑滤波器卷积:2、使用一阶有限差分计算偏导数的两个阵列P与Q：3、幅值和方位角:4、非极大值抑制（NMS ）：细化幅值图像中的屋脊带，即只保留幅值局部变化最大的点。

将梯度角的变化范围减小到圆周的四个扇区之一，方向角和幅值分别为：非极大值抑制通过抑制梯度线上所有非屋脊峰值的幅值来细化M[i,j],中的梯度幅值屋脊．这一算法首先将梯度角θ[i,j]的变化范围减小到圆周的四个扇区之一,如下图所示：5、取阈值将低于阈值的所有值赋零，得到图像的边缘阵列阈值τ取得太低->假边缘阈值τ取得太高->部分轮廊丢失选用两个阈值: 更有效的阈值方案．相关代码Canny算法实现：用高斯滤波器平滑图像（在调用Canny之前自己用blur平滑）用一阶偏导的有限差分来计算梯度的幅值和方向．对梯度幅值应用非极大值抑制．用双阈值算法检测和连接边缘．[cpp] view plaincopyprint?void cv::Canny( InputArray _src, OutputArray _dst,double low_thresh, double high_thresh,int aperture_size, bool L2gradient ){Mat src = _src.getMat();CV_Assert( src.depth() == CV_8U );_dst.create(src.size(), CV_8U);Mat dst = _dst.getMat();if (!L2gradient && (aperture_size &CV_CANNY_L2_GRADIENT) ==CV_CANNY_L2_GRADIENT){//backward compatibilityaperture_size &= ~CV_CANNY_L2_GRADIENT;L2gradient = true;}if ((aperture_size & 1) == 0 || (aperture_size != -1 && (aperture_size 7)))CV_Error(CV_StsBadFlag, "");#ifdef HA VE_TEGRA_OPTIMIZATIONif (tegra::canny(src, dst, low_thresh, high_thresh, aperture_size, L2gradient))return;#endifconst int cn = src.channels();cv::Mat dx(src.rows, src.cols, CV_16SC(cn));cv::Mat dy(src.rows, src.cols, CV_16SC(cn));cv::Sobel(src, dx, CV_16S, 1, 0, aperture_size, 1, 0,cv::BORDER_REPLICATE);cv::Sobel(src, dy, CV_16S, 0, 1, aperture_size, 1, 0, cv::BORDER_REPLICATE);if (low_thresh > high_thresh)std::swap(low_thresh, high_thresh);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;cv::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(1std::vector stack(maxsize);uchar **stack_top = &stack[0];uchar **stack_bottom = &stack[0];/* sector numbers(Top-Left Origin)1 2 3* * ** * *0*******0* * ** * *3 2 1*/#define CANNY_PUSH(d) *(d) = uchar(2), *stack_top++ = (d)#define CANNY_POP(d) (d) = *--stack_top// calculate magnitude and angle of gradient, performnon-maxima supression.// 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 edgefor (int i = 0; i{int* _norm = mag_buf[(i > 0) + 1] + 1;if (i{short* _dx = dx.ptrshort>(i);short* _dy = dy.ptrshort>(i);if (!L2gradient){for (int j = 0; j_norm[j] = std::abs(int(_dx[j])) + std::abs(int(_dy[j])); }else{for (int j = 0; j_norm[j] = int(_dx[j])*_dx[j] + int(_dy[j])*_dy[j];}if (cn > 1){for(int j = 0, jn = 0; j{int maxIdx = jn;for(int k = 1; kif(_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;}elsememset(_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 suppressionif (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.ptrshort>(i-1);const short* _y = dy.ptrshort>(i-1);if ((stack_top - stack_bottom) + src.cols > maxsize) {int sz = (int)(stack_top - stack_bottom);maxsize = maxsize * 3/2;stack.resize(maxsize);stack_bottom = &stack[0];stack_top = stack_bottom + sz;}int prev_flag = 0;for (int j = 0; j{#define CANNY_SHIFT 15const int TG22 =(int)(0.4142135623730950488016887242097*(1 int m = _mag[j];if (m > low){int xs = _x[j];int ys = _y[j];int x = std::abs(xs);int y = std::abs(ys)int tg22x = x * TG22;if (y{if (m > _mag[j-1] && m >= _mag[j+1]) goto __ocv_canny_push;}else{int tg67x = tg22x + (xif (y > tg67x){if (m > _mag[j+magstep2] && m >= _mag[j+magstep1]) goto __ocv_canny_push;}else{int s = (xs ^ ys)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); }// the final pass, form the final imageconst uchar* pmap = map + mapstep + 1;uchar* pdst = dst.ptr();for (int i = 0; i{for (int j = 0; jpdst[j] = (uchar)-(pmap[j] >> 1);}} void cv::Canny( InputArray _src, OutputArray _dst,double low_thresh, double high_thresh,int aperture_size, bool L2gradient ){Mat src = _src.getMat();CV_Assert( src.depth() == CV_8U );_dst.create(src.size(), CV_8U);Mat dst = _dst.getMat(); if (!L2gradient && (aperture_size & CV_CANNY_L2_GRADIENT) ==CV_CANNY_L2_GRADIENT){//backward compatibilityaperture_size &= ~CV_CANNY_L2_GRADIENT;L2gradient = true;} if ((aperture_size & 1) == 0 || (aperture_size != -1 && (aperture_size 7)))CV_Error(CV_StsBadFlag, "");#ifdefHA VE_TEGRA_OPTIMIZATIONif (tegra::canny(src, dst, low_thresh, high_thresh, aperture_size, L2gradient))return;#endif const int cn = src.channels();cv::Mat dx(src.rows, src.cols, CV_16SC(cn));cv::Mat dy(src.rows, src.cols, CV_16SC(cn));cv::Sobel(src, dx, CV_16S, 1, 0, aperture_size, 1, 0,cv::BORDER_REPLICATE);cv::Sobel(src, dy, CV_16S, 0, 1, aperture_size, 1, 0, cv::BORDER_REPLICATE); if (low_thresh > high_thresh) std::swap(low_thresh, high_thresh); 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;cv::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) 1 2 3* * ** * *0*******0* * ** * *3 2 1*/ #define CANNY_PUSH(d) *(d) = uchar(2),*stack_top++ = (d)#define CANNY_POP(d) (d) = *--stack_top // calculate magnitude and angle of gradient, perform non-maxima supression.// 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 edgefor (int i = 0; i 0) + 1] + 1;if (i < src.rows){short* _dx = dx.ptr(i);short* _dy = dy.ptr(i); if(!L2gradient){for (int j = 0; j < src.cols*cn; j++)_norm[j] = std::abs(int(_dx[j])) + std::abs(int(_dy[j]));}else{for (int j = 0; j 1){for(int j = 0, jn = 0; j _norm[maxIdx]) maxIdx = jn + k;_norm[j] = _norm[maxIdx];_dx[j] = _dx[maxIdx];_dy[j] = _dy[maxIdx];}}_norm[-1] = _norm[src.cols] = 0;}elsememset(_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 suppressionif (i == 0)continue; uchar* _map = map +mapstep*i + 1;_map[-1] = _map[src.cols] = 1; int* _mag = mag_buf[1] + 1; // take the central rowptrdiff_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 = maxsize * 3/2;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 15const 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) = _mag[j+1]) goto __ocv_canny_push;}else{int tg67x = tg22x + (x =_mag[j+magstep1]) goto __ocv_canny_push;}else{int s = (xs ^ ys)_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);} // the final pass, form the final imageconst uchar* pmap = map + mapstep + 1;uchar* pdst = dst.ptr();for (int i = 0; i 1);}}Canny() 调用接口（C++）：[cpp] viewplaincopyprint?void Canny(InputArray image, OutputArray edges, double threshold1, double threshold2,int apertureSize=3, bool L2gradient=false ) voidCanny(InputArray image, OutputArray edges, double threshold1, double threshold2,int apertureSize=3, boolL2gradient=false )实践示例[cpp] viewplaincopyprint?Mat src, src_gray;Mat dst, detected_edges;int edgeThresh = 1;int lowThreshold;int const max_lowThreshold = 100;int ratio = 3;int kernel_size = 3;char* window_name = "Edge Map";void CannyThreshold(int, void*){/// Reduce noise with a kernel 3x3blur( src_gray, detected_edges, Size(3,3) );/// Canny detectorCanny( detected_edges, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size );dst = Scalar::all(0);src.copyTo( dst, detected_edges);imshow( window_name, dst );}int main( ){src = imread( "images\\happycat.png" );if( !src.data ){ return -1; }dst.create( src.size(), src.type() );cvtColor( src, src_gray, CV_BGR2GRAY ); namedWindow( window_name,CV_WINDOW_AUTOSIZE );createTrackbar( "Min Threshold:", window_name,&lowThreshold, max_lowThreshold, CannyThreshold ); CannyThreshold(0, 0);waitKey(0);return 0;} Mat src, src_gray;Mat dst, detected_edges;int edgeThresh = 1;int lowThreshold;int const max_lowThreshold = 100;int ratio = 3;int kernel_size = 3;char* window_name = "Edge Map";void CannyThreshold(int, void*){/// Reduce noise with a kernel 3x3blur( src_gray, detected_edges, Size(3,3) );/// Canny detectorCanny( detected_edges, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size );dst = Scalar::all(0);src.copyTo( dst, detected_edges);imshow( window_name, dst );}int main( ){src = imread( "images\\happycat.png" );if( !src.data ){ return -1; }dst.create( src.size(), src.type() );cvtColor( src, src_gray, CV_BGR2GRAY ); namedWindow( window_name,CV_WINDOW_AUTOSIZE );createTrackbar( "Min Threshold:", window_name,&lowThreshold, max_lowThreshold, CannyThreshold ); CannyThreshold(0, 0);waitKey(0);return 0;} 原图：边缘检测效果图：（从左到右lowThread分别为0、50、100）参考文献：[1] Canny. A Computational Approach to Edge Detection, IEEE Trans. on PatternAnalysis and Machine Intelligence, 8(6), pp. 679-698 (1986).转载请注明出处：/xiaowei_cqu/article/details/7839140资源下载：/detail/xiaowei_cqu/4483966。

北京工业大学研究生课程考试答题纸课程类别：学位课选修课研究生学号：研究生姓名：学生类别：博士硕士工程硕士进修生考试时间：年月日一、实验目的：熟悉边缘检测原理，并运用matlab软件实现图像的canny边缘检测，体会canny 边缘检测的优缺点。

二、实验内容：编写matlab程序，实现对lena图像的边缘检测，输出程序运行结果。

三、实验原理或步骤：首先回顾一下边缘检测的一般步骤：边缘检测算法一般包含如下四个步骤：1.滤波（去噪）。

2.增强（一般是通过计算梯度幅值）。

3.检测（在图像中有许多点的梯度幅值会比较大，而这些点并不都是边缘，所以应该用某种方法来确定边缘点，比如最简单的边缘检测判据：梯度幅值阈值）。

4.定位（有的应用场合要求确定边缘位置，可以在子像素水平上来估计，指出边缘的位置和方向）Canny边缘检测的算法步骤：1.用高斯滤波器平滑图像（不同尺度的Canny检测子由高斯的不同标准差来表示）用一阶偏导的有限差分来计算梯度的幅值和方向。

2.对高斯平滑后的图像进行sobel边缘检测。

这里需要求横的竖的还有联合的，所以一共三个需要sobel边缘检测图像。

3.对联合的sobel检测图像进行非极大值抑制（Non-Maxima Suppression, NMS）4.用双阈值算法检测和连接边缘，并进行滞后阈值处理。

其中非极大值抑制细化了幅值图像中的屋脊带，只保留幅值局部变化最大的点。

双阈值算法：用两个阈值得到两个阈值图像，然后把高阈值的图像中的边缘连接成轮廓，连接时到达轮廓的端点时，在低阈值图像上找可以连接的边缘。

不断收集，直到所有的间隙连接起来为止。

四、运行结果和分析每步运行效果：Figure1原图:Figure2 高斯模糊后:Figure3 sobel边缘检测后:Figure4 非极大抑制后:Figure5 上阈值120，下阈值100检测结果:Canny算子的方向性使得它的边缘检测和定位优于其他算子，具有更好的边缘强度估计，能产生梯度方向和强度两个信息。

基于Canny算子的图像边缘检测算法作者：石桂名等来源：《现代电子技术》2015年第12期据图像的某种特定信息，把目标的边缘与周围的区分开来。

回顾了几种传统的边缘检测方法，并分析它们的优缺点，详细阐述了Canny算子的检测原理和实验方法。

实验结果表明Canny算子是最优的边缘检测算子，能够较稳定地对目标图像进行边缘信息提取，得到较好的检测效果。

关键词：图像处理；边缘检测； Canny算子；参数选择中图分类号： TN911.73⁃34 文献标识码： A 文章编号： 1004⁃373X（2015）12⁃0092⁃02边缘检测算法是图像处理中的一个重要部分，本文比较了几种常用的传统边缘检测算法，分析Canny算法的含义、原理和步骤，并将Canny算法应用于车牌和动物的检测。

实验仿真结果验证了Canny算法的良好性能：提取缘信息的同时，能很好地抑制噪声的干扰，提高了图像边缘检测效果，但对于某些细节过于复杂的图像可能丢失一些信息。

1 边缘检测算法简介Roberts算子是一种利用局部差分来寻找边缘的边缘检测算子，它处理的边缘效果不是很好，不够平滑。

Sobel算子是滤波算子，用于提取边缘时，可以利用快速卷积函数，方法简单，使用率较高，但是不能严格地模拟人的视觉生理特征，提取的图像轮廓并不能令人满意[1]。

Prewitt算子是一种基于一阶微分算子的边缘检测，利用像素点周围邻点的灰度差，在边缘处达到极值检测边缘，除掉一些假边缘，起到了平滑噪声的功能。

Laplacian算子是一个二阶微分算子，定义为梯度（[∇f]）的散度（[∇⋅f]）。

LoG算子也就是高斯拉普拉斯函数，常常用于数字图像的边缘提取和二值化，它结合了Gauss平滑滤波器和Laplacian锐化滤波器，效果更好。

Canny算子是一个多级边缘检测算法，边缘检测效果最好[2⁃3]。

2 Canny边缘检测算子2.1 Canny算法的含义1986年，John F.Canny找到一个可以实现多级边缘检测的算法，命名为Canny边缘检测算子，其含义如下[4]：（1）最佳检测：能够检测到足够多的图像中实际的边缘，减少真实边缘的漏检率和误检率。

基于Canny算子的彩色图像边缘检测算法【摘要】本文将Canny算子应用于彩色图像，针对单尺度滤波器的缺点，本文采用改进的多尺度滤波器对彩色图像进行平滑。

通过实验证明，本文所采取的彩色图像边缘检测方法对噪声有很好的抑制作用，并且能够提取比较完整的图像边缘，是一种有效的检测方法。

【关键词】彩色图像；Canny算子；多尺度高斯滤波器1、引言边缘检测是图像处理中最基础也是最重要的部分。

其中有关灰度边缘检测的算子众多，有Sobel、Laplace、Roberts、Prewitt、Kisch和Laplacian、Canny等算子[1]，然而，在我们现实生活中的大部分图像是彩色图像，与灰度图像相比，彩色图像能提供更多、更丰富的信息。

经过大量的实验证明，10%的边缘信息通过灰度边缘检测算子是检测不出来的[2]，可能会丢失一些重要信息。

所以彩色图像边缘检测越来越受到人们的关注。

本文选取在RGB颜色空间中进行彩色图像边缘检测，利用Canny算子对彩色图像进行边缘检测，能够继承Canny算子定位准确，单边响应，信噪比高等优点。

然而，Canny算子在进行平滑图像的过程中，采用单尺度高斯滤波器，不能很好的滤除复杂繁多的噪点，针对这些问题，本文采取了一些措施。

2、算法原理2.1 多尺度高斯滤波器平滑图像利用不同尺度的高斯函数对图像进行滤波，在每个尺度下分别对R、G、B 三个分量多维磨光形成新的真彩色图像。

在本文中选取四个不同尺度的滤波器，分别对图像的3个分量进行滤波，然后对三个分量的四个不同结果进行加权求和，最后输出一个滤波图像。

假设，我们选取的四个不同尺度分别是，则利用这四个不同尺度的高斯函数分别对输入图像的R、G、B三分量进行平滑。

对得到的三分量进行加权求和，最后得到一个平滑后的图像，之后对这两个图像进行后续处理。

假设，加权权值，它们的取值与四个不同尺度的选择有关。

在本文中取分别为：（1）最后得到的滤波图像的三分量为公式（2）：其中，分别表示经过四个不同尺度滤波器对三个颜色分量滤波后的三分量图。

OpenCV笔记（3）（Canny边缘检测、⾼斯⾦字塔、拉普拉斯⾦字塔、图像轮廓、模板匹配）⼀、Canny边缘检测Canny边缘检测是⼀系列⽅法综合的结果。

其中主要包含以下步骤：1.使⽤⾼斯滤波器，平滑图像，滤除噪声。

2.计算图像中每个像素点的梯度强度和⽅向。

3.应⽤⾮极⼤值抑制（NMS：Non-Maximum Suppression），以消除边缘检测带来的杂散相应。

4.应⽤双阈值（Double-Threshold）检测来确定真实和潜在的边缘。

5.通过抑制孤⽴的弱边缘最终完成边缘检测。

1.⾼斯滤波器平滑图像。

2.计算梯度和⽅向使⽤X和Y⽅向的Sobel算⼦来分别计算XY⽅向梯度：每个点的梯度强度有XY⽅向的梯度计算出来：计算每个点梯度的⽅向：3.使⽤NMS有两种⽅法，第⼀种⽅法（插值法，⽐较复杂）：通过计算出的梯度⽅向，找到与周边临近点的边的交点，然后使⽤权重计算交点的值，假设g1和g2之间的交点（左上的⿊点）处于6/4的位置，那么他的值为M = g1*(1-0.6)+g2*(0.4)。

当算出左上的⿊点和右下的⿊点值后，⽤这两个点与C的值进⾏⽐较，如果都⼩于C，则C归为边界。

如果有⼀个⽐C⼤，则丢弃C，这就叫抑制。

第⼆种⽅法（指定8个⽅向，不⽤插值，简化版）：4.双阈值检测在NMS的基础上，判断⼀个边界点的梯度强度： (1) 如果值⼤于maxVal，则处理为边界 (2) 如果值minVal<梯度值<maxVal，再检查是否挨着其他边界点，如果旁边没有边界点，则丢弃，如果连着确定的边界点，则也认为其为边界点。

(3) 梯度值<minVal，舍弃。

通过以上步骤，完成Canny边缘检测。

调⽤Canny API如下：# 使⽤Canny边界检测def use_canny(image):# 后⾯两个参数代表双阈值检测的minVal和maxValimg1 = cv.Canny(image, 50, 100)cv.imshow('img1', img1)# 这⾥使⽤更⼤的minVal和maxVal,细节边界变少了img2 = cv.Canny(image, 170, 250)cv.imshow('img2', img2)⼆、⾼斯⾦字塔图像⾦字塔：Image pyramid如图中所⽰，从0到3是⼀个下采样过程（指图⽚越来越⼩的⽅向），从3到0是⼀个上采样过程（将图⽚变⼤的过程），⼀次下采样加⼀次上采样不等于原图像，因为会损失⼀些细节信息。

Canny边缘检测算法的流程介绍边缘检测的⼀般标准包括：1) 以低的错误率检测边缘，也即意味着需要尽可能准确的捕获图像中尽可能多的边缘。

2) 检测到的边缘应精确定位在真实边缘的中⼼。

3) 图像中给定的边缘应只被标记⼀次，并且在可能的情况下，图像的噪声不应产⽣假的边缘。

在⽬前常⽤的边缘检测⽅法中，Canny边缘检测算法是具有严格定义的，可以提供良好可靠检测的⽅法之⼀。

由于它具有满⾜边缘检测的三个标准和实现过程简单的优势，成为边缘检测最流⾏的算法之⼀。

Canny边缘检测算法的处理流程Canny边缘检测算法可以分为以下5个步骤：1) 使⽤⾼斯滤波器，以平滑图像，滤除噪声。

2) 计算图像中每个像素点的梯度强度和⽅向。

3) 应⽤⾮极⼤值（Non-Maximum Suppression）抑制，以消除边缘检测带来的杂散响应。

4) 应⽤双阈值（Double-Threshold）检测来确定真实的和潜在的边缘。

5) 通过抑制孤⽴的弱边缘最终完成边缘检测。

下⾯详细介绍每⼀步的实现思路。

1 ⾼斯平滑滤波为了尽可能减少噪声对边缘检测结果的影响，所以必须滤除噪声以防⽌由噪声引起的错误检测。

为了平滑图像，使⽤⾼斯滤波器与图像进⾏卷积，该步骤将平滑图像，以减少边缘检测器上明显的噪声影响。

⼤⼩为(2k+1)x(2k+1)的⾼斯滤波器核的⽣成⽅程式由下式给出：下⾯是⼀个sigma = 1.4，尺⼨为3x3的⾼斯卷积核的例⼦（需要注意归⼀化）：若图像中⼀个3x3的窗⼝为A，要滤波的像素点为e，则经过⾼斯滤波之后，像素点e的亮度值为：其中*为卷积符号，sum表⽰矩阵中所有元素相加求和。

重要的是需要理解，⾼斯卷积核⼤⼩的选择将影响Canny检测器的性能。

尺⼨越⼤，检测器对噪声的敏感度越低，但是边缘检测的定位误差也将略有增加。

⼀般5x5是⼀个⽐较不错的trade off。

2 计算梯度强度和⽅向图像中的边缘可以指向各个⽅向，因此Canny算法使⽤四个算⼦来检测图像中的⽔平、垂直和对⾓边缘。

６９科技资讯　科技资讯　ＳＣＩＥＮＣＥ　＆　ＴＥＣＨＮＯＬＯＧＹ　ＩＮＦＯＲＭＡＴＩＯＮ２００７ ＮＯ．３４ＳＣＩＥＮＣＥ　＆　ＴＥＣＨＮＯＬＯＧＹ　ＩＮＦＯＲＭＡＴＩＯＮＩ　Ｔ　技　术物体的边缘是以图像局部的不连续性的形式出现的，例如，灰度值的突变，颜色的突变，纹理结构的突变等。

从本质上说，边缘常常意味着一个区域的终结和另一个区域的开始。

图像边缘信息在图像分布和人的视觉中都是十分重要的，是图像识别中提取图像特征的一个重要属性，而边缘提取算法则是图像边缘检测问题中经典技术难题之一。

它的解决对于我们进行高层次的特征描述、识别和理解等有着重大的影响，又由于边缘检测在许多方面都有着非常重要的使用价值，所以人们一直在致力于研究和解决如何构造出具有良好性质及好的效果的边缘检测算子的问题。

边缘检测的实质是采用某种算法来提取出图像中对象与背景间的交界线。

我们将边缘定义为图像中灰度发生急剧变化的区域边界。

图像灰度的变化情况可以用图像灰度分布的梯度来反映，因此我们可以用局部图像微分技术来获得边缘检测算子。

Ｃａｎｎｙ（坎尼）算子这种方法是以待处理像素为中心的邻域作为进行灰度分析的基础，实现对图像边缘的提取并已经取得了较好的处理效果。

由于Ｃａｎｎｙ边缘算子具有许多优点，所以重在介绍。

Ｃａｎｎｙ算子检测方法的优点：①低误码率，很少把边缘点误认为非边缘点；②高定位精度，即精确地把边缘点定位在灰度变化最大的像素上；③抑制虚假边缘。

１　Ｃａｎｎｙ边缘检测基本原理具有既能滤去噪声又保持边缘特性的边缘检测最优滤波器，其采用一阶微分滤波器。

采用二维高斯函数的任意方向上的一阶方向导数为噪声滤波器，通过与图像卷积进行滤波；然后对滤波后的图像寻找图像梯度的局部最大值，以此来确定图像边缘。

根据对信噪比与定位乘积进行测度，得到最优化逼近算子，这就是Ｃａｎｎｙ边缘检测算子。

类似与Ｍａｒｒ（ＬＯＧ）边缘检测方法，也属于先平滑后求导数的方法。

２　Ｃａｎｎｙ边缘检测算法，其数学描述如下：ｓｔｅｐ１：用高斯滤波器平滑图象。

图像处理中的边缘检测与特征提取边缘检测与特征提取在图像处理中扮演着至关重要的角色。

边缘是图像中灰度或颜色变化较为明显的区域，而特征则是对图像中的某个目标或者结构进行描述的量化指标。

本文将介绍边缘检测和特征提取的基本概念、应用场景以及常用方法。

一、边缘检测边缘检测是图像处理中一个基本的步骤，它可以帮助我们找到图像中物体边界的信息。

边缘检测的结果通常是一幅二值图像，其中边缘的位置被表示为像素值为1的点，其他区域的像素值为0。

1. Sobel算子Sobel算子是一种基于差分的边缘检测算法，它通过计算图像中每个像素点的梯度值来确定边缘的位置。

Sobel算子分别使用水平和垂直两个方向的差分模板来计算梯度值，然后将两个方向的梯度值进行综合来得到最终的边缘检测结果。

2. Canny算法Canny算法是一种广泛应用的边缘检测算法，它通过多个步骤来实现边缘检测的目标。

首先，Canny算法使用高斯滤波器对图像进行平滑处理，然后计算图像中每个像素点的梯度和方向。

接下来，通过非极大值抑制来消除梯度方向上的非极大值点，最后使用双阈值算法来进一步确定边缘的强度和连通性。

二、特征提取特征提取是对图像中感兴趣的区域或者目标进行描述和量化的过程。

通过提取图像中的各种特征，我们可以实现图像分类、目标检测、图像匹配等应用。

1. 颜色特征颜色是图像中最直观的特征之一，可以通过提取图像的颜色直方图来描述图像中不同颜色的分布情况。

另外，HSV（色调、饱和度、亮度）颜色空间也被广泛应用于颜色特征的提取。

2. 纹理特征纹理是图像中重要的一种特征，可以帮助我们区分物体的表面特征。

纹理特征可以通过统计图像中像素灰度或颜色的空间分布来描述，常用的方法包括灰度共生矩阵、小波变换等。

3. 形状特征形状是物体最基本的几何属性，可以通过提取物体轮廓的特征来描述。

常用的形状特征包括傅里叶描述子、轮廓矩等。

三、应用场景边缘检测和特征提取在图像处理中被广泛应用于各种场景。

2 Canny边缘检测基本原理Canny边缘检测器是高斯函数的一阶导数，是对信噪比与定位之乘积的最优化逼近算子[1]。

Canny认为好的边缘检测具有3个特点：（1）低概率的错标非边缘点和低概率不标真实边缘点；（2）检测出来的边缘点应该尽可能的靠近真实边缘中心；（3）边缘响应是单值的。

设表示两维高斯函数，表示图像；Canny边缘检测算子为式中：是边缘曲线的法向量，由于事先不知道边缘的方向，所以取。

那么边缘点是方程的解，即然后通过双阈值去掉伪边缘，Canny算子检测到的是边缘点是高斯函数平滑后的图像拐点。

Canny算法的实现步骤：Step1:用高斯滤波器平滑图像，去除图像噪声。

一般选择方差为1.4的高斯函数模板和图像进行卷积运算。

Step2:用一阶偏导的有限差分来计算梯度的幅值和方向。

使用的梯度算子计算x和y方向的偏导数和，方向角，梯度幅值。

Step3:对梯度幅值应用非极大值抑制。

幅值M越大，其对应的图像梯度值也越大，但这还不足以确定边缘，因为这里仅把图像快速变化的问题转化成求幅值局部最大值问题，为确定边缘，必须细化幅值图像中的屋脊带，只保留幅值局部变化最大的点，生成细化的边缘。

Step4:用双阈值算法检测并且连接边缘。

双阈值法使Canny算子提取的边缘点更具有鲁棒性，高低阈值分别表示为Hth和Lth，对于高阈值Hth的选折，基于计算出的图像梯度值对应的直方图进行选取。

在一幅图像中，非边缘点数目在总图像像素点数目中占的比例表示为Hratio，根据图像梯度值对应的直方图累加，累加数目达到总像素数目的Hratio时，对应的图像梯度值设置为Hth，在文中设定Hratio为0.7。

低阈值Lth的选择通过Lth=Lratio*Hth得到，文中Lratio设定为0.4。

最后通过对边缘点的标记和领域关系进行连接得到最后的边缘检测图。

3亚像素级Zernike矩算子精确定位边缘Zernike矩算子的基本思想是通过计算每个像素点的4个参数来判断该点是否为边缘点。