Canny 边缘检测算法
Canny边缘检测器.ppt

对NMS结果进行二值化
• 对上述得到的N(x,y)使用阈值进行二值化 • 使用大的阈值,得到:
– 少量的边缘点 – 许多空隙
• 使用小的阈值,得到:
– 大量的边缘点 – 大量的错误检测
使用双阈值检测边缘
• 两个阈值T1,T2: T2 >> T1
–由T1得到E1(x,y),低阈值边缘图:更大的误检测率 –由T2得到E2(x,y),高阈值边缘图:更加可靠
Canny算子:流程
原始图像
原始图像经过Gauss平滑
Canny算子:流程
梯度幅值图像
梯度幅值经过非极大值抑制
Canny算子:流程
低阈值边缘图像
高阈值边缘图像
Canny输出边缘图像
使用Canny算子需要注意的问题
• Canny算子的优点:
– 参数较少 – 计算效率 – 得到的边缘连续完整
• 参数的选择:
Canny边缘检测器
• 也许是最常用的边缘检测方法 • 一个优化的方案
– 噪声抑制 – 边缘增强 – 边缘定位
CanБайду номын сангаасy边缘检测算法
• 算法基本过程:
计算图像梯度
幅值大小M(x,y) 方向Theta(x,y)
梯度非极大值抑制
NMS: Non-Maxima Suppression
双阈值提取边缘点
计算图像梯度:高斯函数的一阶导数
• 高斯函数的一阶导数(Derivative of Gaussian) • 可以很近似地满足以下三条边缘检测最优准则:
–好的边缘检测结果:Good detection 对边缘的响应大于对噪声的响应
–好的定位性能:Good localization 其最大值应接近边缘的实际位置
图像边缘检测的方法

图像边缘检测的方法图像边缘检测是在计算机视觉领域中一项重要的任务,它可以用来提取图像中物体的轮廓或边界信息。
常用的图像边缘检测方法包括基于梯度的方法、基于边缘模型的方法和基于机器学习的方法。
1. 基于梯度的方法基于梯度的方法通过计算图像中灰度的梯度来检测图像的边缘。
常用的基于梯度的方法包括Sobel算子、Prewitt算子和Canny算子。
(1)Sobel算子:Sobel算子是一种常用的边缘检测算子,它通过在图像中滑动一个3x3的卷积核来计算图像灰度的梯度。
它分别计算水平和垂直方向上的梯度,并将两个方向上的梯度相加得到最终的边缘强度。
(2)Prewitt算子:Prewitt算子与Sobel算子类似,也是通过计算图像灰度的水平和垂直方向上的梯度来检测边缘。
不同之处在于Prewitt算子使用了不同的卷积核,其效果也有所差异。
(3)Canny算子:Canny算子是一种边缘检测算法,它通过多个步骤来获得较为准确的边缘结果。
首先,它使用高斯滤波器对图像进行平滑处理,然后计算图像灰度梯度的幅值和方向。
接着,通过非极大值抑制来细化边缘。
最后,使用双阈值处理来检测和连接真正的边缘。
2. 基于边缘模型的方法基于边缘模型的方法是利用边缘在图像中的几何特征来进行检测。
常用的基于边缘模型的方法包括Hough变换和边缘跟踪算法。
(1)Hough变换:Hough变换是一种广泛应用于边缘检测的方法,它可以将图像中的边缘表示为参数空间中的曲线或直线。
通过在参数空间中寻找曲线或直线的交点,可以得到图像中的边缘。
(2)边缘跟踪算法:边缘跟踪算法是一种基于像素领域关系的边缘检测方法。
它首先选择一个起始点作为边缘点,然后根据一定的规则选择下一个与当前点相邻的点作为新的边缘点,并将其加入到边缘集合中。
通过不断跟踪边缘点,可以得到完整的边缘。
3. 基于机器学习的方法基于机器学习的方法是近年来较为流行的一种图像边缘检测方法。
它利用大量的已标注的训练数据来训练模型,然后使用训练好的模型对新的图像进行边缘检测。
改进的Canny图像边缘检测算法分析

网络天地171改进的Canny 图像边缘检测算法分析◆王 娟1 边缘检测的过程边缘检测主要用于解决图像边缘的真假,边缘的定向定位。
以此来初步分析图像和识别图像。
想要做好边缘检测,需要遵循以下五个方面的过程进行检测分析:(1)首先要明确的了解图像检测时图像的特性变化形式,运用合适的检测方法。
(2)根据特殊情况需求,利用多算子综合计算方法。
提取多范围的变化特性,以便检测图像上的所有特性变化。
(3)由于噪声的影响,使检测有一定的局限性。
检测时需要尽可能的滤除噪音。
还需要考虑到噪音的条件检测,进一步检测参数变化。
(4)尽可能用多种方法进行组合。
例如在检测时,先找到边缘,然后利用函数近似的放法,利用内插获得高精度定位。
(5)检测时,首先对原图像进行平滑处理,然后再进行边缘检测。
一方面可以有效地抑制噪音,另一方面也可以对边缘进行精准定位。
2 传统Canny 算子的基本工作原理由于系统固有的低筒滤波对实际的图像进行平滑,以至于边缘不明显。
所以,这就需要边缘检测通过寻找出图像局部具有最大梯度值的一些像素点。
同时由于摄影机以及周围环境的干扰,因此图片边缘检测必须满足两个条件:①逼近必须能够抑制噪音效应;②必须尽量精准的确定边缘的位置。
以高定位精准、高信噪比、单一边缘响应位判断标准。
Canny 算子的基本流程:输入原始图像→转为灰度图像→ 高斯平滑→ 梯度计算→ 非极大值抑制→ 双阈值检测→ 连接边缘→ 输出边缘图像。
作为一阶微分滤波器的Canny 算子属于边缘检测,有三大显著优点:1、最优过零点定位准则2、多峰值响应准则3、最大信噪比准则。
Canny 算子基本的工作原理首先便是利用高斯平滑滤波器对图像进行平滑处理,目的是为了去除噪音的影响,然后通过计算梯度差值,来完成领域局部强度值。
利用高阈值和低阈值以及双阈值的计算方法对图像边缘进行检测已达到增强边缘的效果。
3 Canny 算子的实现步骤Canny 算子在整体运算的过程中,其需要结合多个运算步骤进行整体的运算。
Canny边缘检测算法的一些改进

Canny边缘检测算法的⼀些改进传统的Canny边缘检测算法是⼀种有效⽽⼜相对简单的算法,可以得到很好的结果(可以参考上⼀篇)。
但是Canny算法本⾝也有⼀些缺陷,可以有改进的地⽅。
1. Canny边缘检测第⼀步⽤⾼斯模糊来去掉噪声,但是同时也会平滑边缘,使得边缘信息减弱,有可能使得在后⾯的步骤中漏掉⼀些需要的边缘,特别是弱边缘和孤⽴的边缘,可能在双阀值和联通计算中被剔除。
很⾃然地可以预见,如果加⼤⾼斯模糊的半径,对噪声的平滑⼒度加⼤,但也会使得最后得到的边缘图中的边缘明显减少。
这⾥依然⽤Lena图为例,保持Canny算法中⾼阀值100,低阀值50不变,⾼斯半径分别为2,3,5的Canny边缘⼆值图像如下。
可知⾼斯模糊把很多有⽤的边缘信息也模糊掉了,因此如何精确的选择⾼斯半径就相当重要。
⾼斯半径2 ⾼斯半径3 ⾼斯半径52. 在最初的Canny算法中是使⽤的最⼩的2x2领域来计算梯度幅值的。
这种⽅法对噪声很敏感,⽐较容易检测到伪边缘或漏掉真是边缘。
在上⼀篇算法实现中,实际上使⽤的是3x3的Sobel梯度算⼦,是⼀种⽐较好的选择。
3. 传统Canny算法的双阀值是全局固定的,因此双阀值⼤⼩的选取对最终的结果影响很⼤,也有⼀些经验,⽐如选择低阀值是⾼阀值的0.4或0.5。
然⽽这毕竟是⼀种经验选择,阀值的确定仍然很难决定⼀个最优值。
⽽且⼀个图像的不同局部区域可能需要各不相同的阀值来精确地找到真实边缘,因此全局阀值就不太合适了。
4. 传统算法仍然可能产⽣⼀条宽度⼤于1的边缘,达不到满意的⾼精度单点响应。
也就是需要继续细化边缘。
下⾯就⼀些可以改进的地⽅做⼀些讨论。
代替⾼斯模糊噪声是⾼频信号,边缘信号也属于⾼频信号。
既然⾼斯模糊不加区分的对所有的⾼频信息进⾏了模糊,效果⾃然不尽如⼈意。
那么⾃然就想到了带有保留边缘功能的各种选择性平滑⽅法,似乎在这⾥⽐⾼斯模糊会更加合适,那我们就来试⼀试。
带有保留边缘功能的平滑⽅法的基本思想不是让领域范围内的所有像素都参与该种平滑⽅法的计算,⽽是设定⼀个阀值,仅仅让和中⼼像素灰度的差值⼩于这个阀值的像素参与计算。
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边缘检测

Canny边缘检测图象的边缘是指图象局部区域亮度变化显著的部分,该区域的灰度剖面一般可以看作是一个阶跃,既从一个灰度值在很小的缓冲区域内急剧变化到另一个灰度相差较大的灰度值。
图象的边缘部分集中了图象的大部分信息,图象边缘的确定与提取对于整个图象场景的识别与理解是非常重要的,同时也是图象分割所依赖的重要特征,边缘检测主要是图象的灰度变化的度量、检测和定位,自从1959提出边缘检测以来,经过五十多年的发展,已有许多中不同的边缘检测方法。
根据作者的理解和实践,本文对边缘检测的原理进行了描述,在此基础上着重对Canny检测算法的实现进行详述。
本文所述内容均由编程验证而来,在实现过程中,有任何错误或者不足之处大家共同讨论(本文不讲述枯燥的理论证明和数学推导,仅仅从算法的实现以及改进上进行原理性和工程化的描述)。
1、边缘检测原理及步骤在之前的博文中,作者从一维函数的跃变检测开始,循序渐进的对二维图像边缘检测的基本原理进行了通俗化的描述。
结论是:实现图像的边缘检测,就是要用离散化梯度逼近函数根据二维灰度矩阵梯度向量来寻找图像灰度矩阵的灰度跃变位置,然后在图像中将这些位置的点连起来就构成了所谓的图像边缘(图像边缘在这里是一个统称,包括了二维图像上的边缘、角点、纹理等基元图)。
在实际情况中理想的灰度阶跃及其线条边缘图像是很少见到的,同时大多数的传感器件具有低频滤波特性,这样会使得阶跃边缘变为斜坡性边缘,看起来其中的强度变化不是瞬间的,而是跨越了一定的距离。
这就使得在边缘检测中首先要进行的工作是滤波。
1)滤波:边缘检测的算法主要是基于图像强度的一阶和二阶导数,但导数通常对噪声很敏感,因此必须采用滤波器来改善与噪声有关的边缘检测器的性能。
常见的滤波方法主要有高斯滤波,即采用离散化的高斯函数产生一组归一化的高斯核(具体见“高斯滤波原理及其编程离散化实现方法”一文),然后基于高斯核函数对图像灰度矩阵的每一点进行加权求和(具体程序实现见下文)。
医学图像处理中的边缘检测与分割算法

医学图像处理中的边缘检测与分割算法边缘检测与分割是医学图像处理中的重要部分,被广泛应用于疾病诊断、医学影像分析和手术辅助等领域。
边缘检测算法用于提取图像中的边缘信息,而分割算法则可以将图像划分为不同的区域,有助于医生对图像进行进一步分析和诊断。
一、边缘检测算法在医学图像处理中,常用的边缘检测算法包括基于梯度的方法、基于模型的方法和基于机器学习的方法。
1. 基于梯度的方法基于梯度的边缘检测算法通过计算图像中像素点的梯度值来确定边缘位置。
常用的算法包括Sobel算子、Prewitt算子和Canny算子。
Sobel算子是一种常用的离散微分算子,通过在图像中对每个像素点应用Sobel算子矩阵,可以得到图像的x方向和y方向的梯度图像。
通过计算梯度幅值和方向,可以得到边缘的位置和方向。
Prewitt算子与Sobel算子类似,也是一种基于梯度的边缘检测算子。
它通过将图像中的每个像素点与Prewitt算子矩阵进行卷积运算,得到图像的x方向和y方向的梯度图像。
进一步计算梯度幅值和方向,可以确定边缘的位置和方向。
Canny算子是一种经典的边缘检测算法,它采用多步骤的方法来检测边缘。
首先,对图像进行高斯滤波来减少噪声。
然后,计算图像的梯度幅值和方向,进一步剔除非最大值的梯度。
最后,通过设置双阈值来确定真正的边缘。
2. 基于模型的方法基于模型的边缘检测算法借助数学模型来描述边缘的形状和特征。
常用的算法包括基于边缘模型的Snake算法和基于边缘模型的Active Contour算法。
Snake算法(也称为活动轮廓模型)是一种基于曲线的边缘检测算法。
它通过将一条初始曲线沿着图像中的边缘移动,使得曲线更好地贴合真实边缘。
Snake算法考虑了边缘的连续性、平滑性和能量最小化,可以获得较为准确的边缘。
Active Contour算法是Snake算法的进一步发展,引入了图像能量函数。
通过最小化能量函数,可以得到最佳的边缘位置。
Active Contour算法可以自动调整曲线的形状和位置,适应复杂的图像边缘。
canny算子边缘检测原理

canny算子边缘检测原理
Canny算子是一种常用的边缘检测算法,其原理如下:
1. 高斯滤波:首先对图像进行高斯滤波,以减少噪声的影响。
高斯滤波是利用高斯函数对图像进行平滑操作,可以抑制高频噪声。
2. 计算梯度幅值和方向:对平滑后的图像进行梯度计算,通过计算像素点的梯度幅值和方向,可以找到图像中的边缘。
常用的梯度算子包括Sobel算子和Prewitt算子。
3. 非极大值抑制:在梯度图像中,对于每个像素点,通过比较其梯度方向上的两个相邻像素点的梯度幅值,将梯度幅值取最大值的点保留下来,其他点置为0。
这样可以剔除非边缘的像素。
4. 双阈值处理:将梯度幅值图像中的像素分为强边缘、弱边缘和非边缘三类。
设置两个阈值:高阈值和低阈值。
如果某个像素的梯度幅值大于高阈值,则将其标记为强边缘。
如果某个像素的梯度幅值小于低阈值,则将其剔除。
对于梯度幅值介于低阈值和高阈值之间的像素,如果其与某个强边缘像素相连,则将其标记为强边缘,否则将其标记为弱边缘。
5. 边缘连接:通过将强边缘和与其相连的弱边缘进行连接,找到完整的边缘。
这里通常使用8连通或4连通算法来判断两个像素是否相连。
通过以上步骤,Canny算子可以得到图像中的边缘信息,并且相对其他算法能够更好地抑制噪声和保持边缘的连续性。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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。