人脸CANNY边缘检测参数控制的学习模式word

合集下载

CannyEdgeDetectionTutorial（Canny边缘检测教程）

CannyEdgeDetectionTutorial（Canny边缘检测教程）Canny Edge Detection Tutorial(Canny 边缘检测教程)关于此算法的代码可以再/caiye917015406/article/details/7863825找到This tutorial assumes the reader:(1) Knows how to develop source code to read raster data(2) Has already read my Sobel edge detection tutorialThis tutorial will teach you how to:这个教程将教你：(1) Implement the Canny edge detection algorithm. 实现Canny边缘检测算法INTRODUCTIONEdges characterize boundaries and are therefore a problem of fundamental importance in image processing. Edges in images are areas with strong intensity contrasts ? a jump in intensity from one pixel to the next. Edge detecting an imagesignificantly reduces the amount of data and filters out useless information, while preserving the important structural properties in an image. This was also stated in my Sobel and Laplace edge detection tutorial, but I just wanted reemphasize the point of why you would want to detect edges.边缘描述边界在图像的预处理中是一个重要的问题。

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边缘检测算法原理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算子原理一样，在此仅给出其卷积模板。

学习笔记-canny边缘检测

学习笔记-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边缘检测方法
Canny边缘检测方法是一种广泛应用于数字图像处理领域的算法，用于检测图像中的边缘。

它是由John Canny在1986年开发的，是一种基于多级梯度计算和非极大值抑制（Non-Maximum Suppression）的方法。

该算法的主要步骤包括以下几个步骤：
1. 高斯滤波：对图像进行高斯平滑滤波以去除噪声，同时模糊图像，使边缘在进行梯度计算时更平滑。

2. 梯度计算：使用Sobel等算子计算图像中每个像素点的梯度、方向和大小，从而找到边缘的位置。

3. 非极大值抑制：将检测到的梯度方向沿垂直方向上进行“压缩”，将每个像素点的位置更新为其在梯度方向上的最大值处。

4. 双重阈值：对非极大值抑制后的图像进行二值化操作，设定一个高阈值和低阈值，比较每个像素点的梯度大小是否高于高阈值或低于低阈值。

高于高阈值的点被标记为强边缘，低于低阈值的点被标记为背景，介于高低阈值之间的点被标记为弱边缘。

5. 边缘跟踪：将弱边缘与强边缘连接起来，最终得到连续的边缘。

Canny边缘检测方法具有较高的精度和鲁棒性，广泛应用于计算机视觉、机器视觉、物体检测等领域。

Canny 边缘检测算法

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。

结合canny边缘检测算法与k-means算法的图像文字识别

技术创新39结合ca n ny边缘检测算法与k-means算法的图像文字识别◊内江师范学院数学与信息科学学院向涛杨乾辉邓云吴苹杨秀霞许雷本文就图像中文本的识别进行了深入的研究，在目前的技术领域，文本识别的技术还够成熟，但是依然有许多的方法能够解决文本识别问题，比如边缘特征法、将文本图像连通寻找适当新的区域法、还有就是基于一些文本自身独特的特征和机器学习的方法；其次是就算得到了一些文本数据，因为世界是多姿多彩的，每个文本在自然界中受到的光照强度、文本自身的大小、倾斜程度等都会给图像文本的识别增加更大的难度，但是也不是说不能够完全识别文本区域内容，只是各种方法各有各的优势，因此需要对应找到更实用的方法。

目前大部分文本识别算法的核心都差不多，基本上都是先确定文本的大致区域，缩小识别范围，从而降低识别时间，还能够提高文本识别的效率。

当今世界最先好的识别技术（OCR）m是很好的也是非常成熟的一个方法，通过大量的数据验证得到的结果是（OCR）皿具有良好的性能，但直接使用效果却不是很好，因此本文采用了canny边缘检测算法和k-means算法进行文本定位，在一定程度上增强了文本区域的识别。

1canny与k_means算法原理1.1基于canny边缘检测算法原理该算法舷于边缘特征的一个检测性算法，它在对文本的处理过程中会保留文本属性值不变，但是并不是对文本不加以处理，而是会将文本图像的数据规模进行缩减。

目前世界研究中基于边缘检测的算法还是比较多，本文采用的是canny算法，该算法能够很好的处理边缘检测问题，这为文本识别带来了优势。

边缘检测算法是多种多样的，而canny算法是找到最适合的f瞬检测，含义如下所示。

（1）搜寻最佳检测：边缘检测会把文本边缘的一些特征尽可能的提取到的同时，还需要满足漏检的概率值尽可能的小。

（2）边缘定位规则：要求搜寻到边缘的点与实际文本的边缘点相差不远，总之就是使得搜寻的边缘位置与实际文本的边缘位置的偏差不能够太大，从而提高识别精度。

数字图像处理__Canny边缘检测

摘要边缘检测是数字图像处理中的重要内容，边缘是图像最基本的特性。

在图像边缘检测中，微分算子可以提取出图像的细节信息，景物边缘是细节信息中最具有描述景物特征的部分,也是图像分析中的一个不可或缺的部分。

本文详细地分析了目前常用的几种算法，即：Roberts交叉微分算子、Sobel微分算子、Priwitt微分算子和Laplacian微分算子以及Canny算子，用C语言编程实现各算子的边缘检测，并根据边缘检测的有效性和定位的可靠性，得出Canny算子具备有最优边缘检测所需的特性。

关键词：图像处理，微分算子，Canny算子，边缘检测AbstractEdge detection is the important contents of digital image processing ,and the edge is the most basic characteristics of the image.In the image edge detection ,differential operator can be used to extract the details of the images,features’edge is the most detailed information describing the characteristics of the features of the image analysis, and is also an integral part of the image.This article gives the detailed analysis of several algorithms which is commonly used at present,such as Roberts cross-differential operator、Sobel differential operator、Priwitt differential operator、Laplacian differential operator and Canny operator,and we complete with the C language procedure to come ture edge detection.According to the effectiveness of the image detection and the reliability of the orientation,we can deduced that the Canny operator have the characteristics which the image edge has.Keywords: Image processing, Canny operator, differential operator, edge detection目录摘要 (I)Abstract (II)第一章绪论 (1)1.1 引言 (1)1.2 数字图像技术的概述 (2)1.3 边缘检测 (3)1.4 论文各章节的安排 (4)第二章微分算子边缘检测 (5)2.1 Roberts算子 (5)2.2 Sobel算子 (5)2.3 Priwitt算子 (6)2.4 Laplacian算子 (6)第三章Canny边缘检测 (8)3.1 Canny指标 (8)3.2 Canny算子的实现 (9)第四章程序设计与实验 (12)4.1各微分算子的程序设计 (12)4.2 实验结果及比较 (14)第五章结论与展望 (17)5.1 结论 (17)5.2 展望 (17)致谢 ..................................................................................................... 错误！未定义书签。

基于candy算子的边缘检测技术学习

基于candy算子的边缘检测技术学习在数字图像中“边缘”往往包含着丰富且有用的信息，如城市中的道路、河流的水涯线、建筑物的边界等，这些边缘信息在数字摄影测量、模式识别等领域有着重要的研究意义。

对于人脸检测来说,一个好的边缘检测算法能很好的划分出待检测区域,有效降低无检测率。

对边缘检测算法进行研究性学习，了解该算法的执行过程和有关改进，对于人脸检测领域的深入学习是不可或缺的。

在众多的边缘检测算子中，Canny算子是目前最受欢迎的边缘检测算子口]。

Canny算子具有良好的信噪比，对单一边缘具有唯一响应，较好的定位性能等优点，因此决定对其深入学习了解。

Canny边缘检测算子(Canny，1986)主要由3个目标形成：无附加响应的最优检测、检测边缘位置和实际边缘位置之问距离最小的正确定位、减少单边缘的多重响应而得到单响应。

为实现以上3个目标，Canny边缘检测的主要步骤如下：(1)对图像应用高斯平滑处理Canny指出高斯算子对图像平滑处理是最优的。

二维高斯平滑算子如下：沿水平和垂直两个方向进行微分，可以得到：通过微分，把二维平滑算子分解为水平和垂直两个方向的滤波器，从而提高了平滑的速度。

(2)计算图像的梯度传统Canny算子采用2×2邻域一阶偏导的有限差分来计算平滑后的数据阵列I(z，y)的梯度幅值和方向，其中水平和垂直方向的差分算子分别为：Dx[i,j]=(I[i,j+1]-I[i,j]+I[i+1,j+1]-[i+1,j])/2Dy[i,j]=( I[i,j] - I[i+1,j] + I[i,j+1]- I[i+1,j+1])/2此处的梯度模值和方向分别为：(3)抑制局部非最大(MNS)数字图像中的边缘对应图像中灰度变化剧烈的部分，即梯度模值比较大的部分，因此可以把边缘检测问题转换为计算梯度模值的局部极大值的问题，即将梯度模值的局部极大值点作为边缘，这一过程就是抑制局部非最大的过程(Non-maxima Sup—pression，NMS)。

结合边缘信息和门卷积的人脸修复算法

结合边缘信息和门卷积的人脸修复算法王富平1,2+，李文楼2，刘颖1,2,3，卢津1,2，公衍超1,21.西安邮电大学电子信息现场勘验应用技术公安部重点实验室，西安7101212.西安邮电大学图像与信息处理研究所，西安7101213.陕西省无线通信与信息处理技术国际合作研究中心，西安710121+通信作者E-mail:***************摘要：针对任意形状遮挡下人脸修复，现有方法容易产生边缘模糊和恢复结果失真等问题。

提出了一种结合边缘信息和门卷积的人脸修复算法。

首先，通过先验人脸知识产生遮挡区域的边缘图，以约束人脸修复过程。

其次，利用门卷积在部分像素缺失下的精确局部特征描述能力，设计面向图像修复的门卷积深度生成对抗网络（GAN ）。

该模型由边缘连接生成对抗网络和图像修复生成对抗网络两部分组成。

边缘连接网络利用二值遮挡图和待修复图像及其边缘图的多源信息进行训练，实现对缺失边缘图像的自动补全和连接。

图像修复网络以补全的边缘图为引导信息，联合遮挡图像进行缺失区域修复。

实验结果表明：相比其他算法，该算法修复效果更好，其评价指标比当前基于深度学习的图像修复算法更优。

关键词：人脸修复；Canny 边缘；门卷积；深度学习；生成对抗网络（GAN ）文献标志码：A中图分类号：TP391Face Inpainting Algorithm Combining Edge Information with Gated ConvolutionWANG Fuping 1,2+,LI Wenlou 2,LIU Ying 1,2,3,LU Jin 1,2,GONG Yanchao 1,21.Key Laboratory of Electronic Information Application Technology for Crime Scene Investigation,Ministry of Public Security,Xi an University of Posts and Telecommunications,Xi an 710121,China2.Center for Image and Information Processing,Xi an University of Posts and Telecommunications,Xi an 710121,China3.International Joint Research Center for Wireless Communication and Information Processing Technology,Shaanxi Province,Xi an 710121,ChinaAbstract:For the face inpainting under arbitrary shape occlusion,the existing methods are easy to produce edge blur and distortion of the inpainting results.In this paper,an algorithm for face inpainting combining edge information with gated convolution is proposed.Firstly,the edge image of occluded area is generated by prior face knowledge to constrain the process of face inpainting.Secondly,the gated convolution holds the ability to extract accurate local feature in the absence of some pixels,and a gated convolution-based generative adversarial network (GAN)for image inpainting is designed.The model consists of two parts:edge connection GAN and image inpainting GAN.The edge connection network uses the binary occlusion image,the image to be repaired and its edge image for training,and realizes the automatic completion and connection of the missing edge image.The image inpainting计算机科学与探索1673-9418/2021/15(01)-0150-13doi:10.3778/j.issn.1673-9418.2001035开放科学(OSID)基金项目：国家自然科学基金青年科学基金项目（61802305，61801381）；陕西省教育厅专项科研计划项目（18JK0721，19JK0810）。

Canny-算子边缘检测原理解析

SNR(f) | G(x ) f ( x)dx |
w w

w
w
f 2 ( x)dx
G(-x)表示图像边函数 f(x)滤波器函数表示噪声的均方差
Canny算子详细原理
②高的定位精度：Location越大越好
Location | G ' ( x ) f ' ( x)dx |
• 链接边缘的具体步骤如下：
• 对图像2进行扫描，当遇到一个非零灰度的像素p(x,y)时，跟踪以p(x,y)为开始点的轮廓线，直到轮廓线的终点q(x,y)。 • 考察图像1中与图像2中q(x,y)点位置对应的点s(x,y)的8邻近区域。如果在s(x,y)点的8邻近区域中有非零像素s(x,y) 存在，则将其包括到图像2中，作为r(x,y)点。从r(x,y)开始，重复第一步，直到我们在图像1和图像2中都无法继续为止。 • 当完成对包含p(x,y)的轮廓线的连结之后，将这条轮廓线标记为已经访问。回到第一步，寻找下一条轮廓线。重复第一步、第二步、第三步，直到图像2中找不到新轮廓线为止。 • 至此，完成canny算子的边缘检测。
w w
w
w
通过以上算式得出算子的近似实现：边缘点位于图像被高斯平滑后的梯度值的极大值点。
算法过程
原始图像 A(x,yBy)
极大值抑制非
图像边缘
双阈值检测连结边缘
初步得到边缘点
详细算法过程
I. 高斯函数
x2 y2 n 1 G(x, y) exp | |, m , n表示 2 2 2 x m y m 高斯滤波器窗口大小
边缘检测算法
传统的边缘检测算子：Sobel算子，Prewitt算子，Roberts 算子，Krich算子等，大部分处理的效果都不很好，实际处理中不太实用，而Canny算子检测的性能较好，常被作为其他实验的标准来参考。Canny算子是John Canny在1986年发表的论文中首次提出的一种边缘检测算法，当时弥补了其他算法的不太好的缺点，因此Canny算子被认为是边缘检测领域较好的算法，并一直被引用，近几年来，随着研究的深入，性能更加完善的改性型的Canny算子也层出不穷，例如自适应Canny算子等。

Canny边缘检测算法的流程

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算法使⽤四个算⼦来检测图像中的⽔平、垂直和对⾓边缘。

自适应Canny算子边缘检测技术

幅值为
M [ i , j ] = ( Px [ i , j ]) 2 + ( Py [ i , j ]) 2 , (4) 梯度方向为
θ[ i , j ] = arctan ( Py [ i , j ]/ Px [ i , j ]) . (5) 11 3 对梯度幅值进行非极大值抑制
为了提取单像素宽边缘 ,必须细化梯度幅值图. 在梯度幅值图像中 , M [ i , j ]的极大值所在位置附近
前已述及 ,高低阈值的确定还是无法避免人为因素的干扰 ,不具备自适应性和鲁棒性 ,不适合实际工程应用. 因此 , 提出了完全可以排除人为干扰因素 ,针对不同图像 ,自适应地确定相关阈值的方法.
2 基于梯度幅度直方图和类内方差最小化动态的自动确定高低阈值
21 1 基于梯度幅度直方图的类内特性方差最小化 1979 年 ,Ot su[8] 根据最小二乘原理推导出来了
若此点的模极大值在邻域中最大等提出了模糊控制算法对阈值间的像素进行提取按此规则进行边缘提取和连接例系数hratioratio是一样的但是计算机计算出的高低阈值却是不同的这说明这种依靠人为设定阈值比例系数的自适应的方法较人为设定阈值进行试凑的方法有一定的灵活性但是发现在图中边缘检测的效果虽然损失一些细节信息但边缘检测整体效果较好但在图中发现采用同样的比例因子却误检了很多冗余信息针对不同的图片采用一致的比例系数是不科学的采用传统的cany边缘检测技术得到的结果均漏掉了一些边缘信息但得到各图检测结果所采用的比例系数和得到各这说明在应用传统的canny算子进行边缘检测的时候为了得到较好的检测结果需要反复的凭经验试凑而且系数的选取较难掌握为采用该文的方法所确定的阈值进行边缘检测的发现不需要人为的设定比例系数或者阈值即可实现较好效果的边缘检测细节信息和整体轮廓较好

图像处理之Canny边缘检测

图像处理之Canny边缘检测图像处理之Canny 边缘检测一：历史Canny边缘检测算法是1986年有John F. Canny开发出来一种基于图像梯度计算的边缘检测算法，同时Canny本人对计算图像边缘提取学科的发展也是做出了很多的贡献。

尽管至今已经许多年过去，但是该算法仍然是图像边缘检测方法经典算法之一。

二：Canny边缘检测算法经典的Canny边缘检测算法通常都是从高斯模糊开始，到基于双阈值实现边缘连接结束。

但是在实际工程应用中，考虑到输入图像都是彩色图像，最终边缘连接之后的图像要二值化输出显示，所以完整的Canny边缘检测算法实现步骤如下：1. 彩色图像转换为灰度图像2. 对图像进行高斯模糊3. 计算图像梯度，根据梯度计算图像边缘幅值与角度4. 非最大信号压制处理（边缘细化）5. 双阈值边缘连接处理6. 二值化图像输出结果三：各步详解与代码实现1. 彩色图像转灰度图像根据彩色图像RGB转灰度公式：gray = R * 0.299 + G * 0.587 + B * 0.114将彩色图像中每个RGB像素转为灰度值的代码如下：[java] view plain copy print?<spanstyle="font-size:18px;">int gray = (int) (0.299 * tr + 0.587 * tg + 0.114 * tb);</span> 2. 对图像进行高斯模糊图像高斯模糊时，首先要根据输入参数确定高斯方差与窗口大小，这里我设置默认方差值窗口大小为16x16，根据这两个参数生成高斯卷积核算子的代码如下：[java] view plain copy print?<span style="font-size:18px;"> float kernel[][] = newfloat[gaussianKernelWidth][gaussianKernelWidth];for(int x=0; x<gaussianKernelWidth; x++){ for(int y=0; y<gaussianKernelWidth; y++) { kernel[x][y] = gaussian(x, y, gaussianKernelRadius); } }</spa n> 获取了高斯卷积算子之后，我们就可以对图像高斯卷积模糊，关于高斯图像模糊更详细的解释可以参见这里：/jia20003/article/details/7234741实现图像高斯卷积模糊的代码如下：[java] view plain copyprint?<span style="font-size:18px;">// 高斯模糊-灰度图像int krr = (int)gaussianKernelRadius; for (int row = 0; row < height; row++) { for (int col = 0; col < width; col++) { index = row * width + col;double weightSum = 0.0; double redSum = 0;for(int subRow=-krr; subRow<=krr; subRow++){ int nrow = row + subRow;if(nrow >= height || nrow < 0){ nrow = 0; }for(int subCol=-krr; subCol<=krr; subCol++){ int ncol = col + subCol;if(ncol >= width || ncol <=0){ ncol = 0; }int index2 = nrow * width + ncol; int tr1 = (inPixels[index2] >> 16) & 0xff;redSum += tr1*kernel[subRow+krr][subCol+krr];weightSum +=kernel[subRow+krr][subCol+krr]; }} int gray = (int)(redSum / weightSum);outPixels[index] = gray; } }</span> 3.计算图像X方向与Y方向梯度，根据梯度计算图像边缘幅值与角度大小高斯模糊的目的主要为了整体降低图像噪声，目的是为了更准确计算图像梯度及边缘幅值。

基于CANNY边缘检测的人脸识别技术

基于CANNY边缘检测的人脸识别技术摘要生物特征识别技术使用了人体本身所固有的生物特征，与传统的身份识别方法完全不同，具有更高的安全性、可靠性和有效性，越来越受到人们的重视。

人脸识别技术作为生物特征识别技术的重要组成部分，在近三十年里得到了广泛的关注和研究，已经成为计算机视觉、模式识别领域的研究热点。

人脸识别在公共安全、证件验证、门禁系统、视频监视等领域中都有着广泛的应用前景。

本文使用的方法是基于24位彩色图像对人脸进行canny边缘提取识别，并通过基于canny算子的边缘检测算法实现了人脸轮廓的提取，这样就确定了识别的有效区域。

本文介绍的重点是图像处理，同时也讨论了相关的图像预处理技术，整个过程包括：图像获取、图像预处理和模式识别等过程。

主要用到的图像处理技术是：光线补偿、图像灰度化、高斯平滑、对比度增强、二值化和边缘提取。

经过特征标记、特征提取、最后与数据库比对查找并显示结果。

使用matlab对样本图片进行了处理，并给出了相关程序和图片处理的效果图。

关键词：CANNY，人脸识别, 边缘提取，变换AbstractBiometric identification technology using the body itself inherent biological characteristics, and the traditional identification methods are completely different, with more safety, reliability and validity, and people pay more and more attention. The technology of face recognition as a biological feature recognition technology is an important component of, in the past thirty years has been widespread concern and research, computer vision, pattern recognition has become a research hotspot in the field of. Face recognition in public security, certificate verification, access control systems, video surveillance and other fields have broad application prospects.The method is based on the24 bit color image of face recognition Canny edge extraction, and through canny based edge detection algorithm to achieve the face contour extraction, so as to determine the identification of effective area. This article focuses on the introduction of image processing, and also discusses the relevant technology of image pretreatment, the whole process includes: image acquisition, image processing and pattern recognition process.The main use of the image processing technology is: light compensation, image, Gauss smooth, contrast enhancement, two values and edge extraction. After the signature, feature extraction, and finally databases than search and display the results. The use of MA TLAB on sample images were processed, and gives the relevant procedures and picture processingeffect.Key words: CANNY, face recognition, edge extraction, transformation目录摘要 (1)关键词 (1)1绪论 (5)1.1生物识别技术及其特征 (5)1.2人脸识别的发展历史 (5)1.3人脸识别定义与意义 (6)1.4人脸识别优点 (6)1.5人脸技术的难点 (7)1.6人脸识别发展趋势 (8)1.7人脸识别常用方法 (10)2人脸识别总体设计 (12)2.1总体结构设计 (12)2.2方案概述 (13)2.2.1图像灰度变换 (14)2.2.2 直方图均衡 (14)2.2.3 滤波 (15)2.2.4 边缘提取 (16)2.3人脸检测定位算法 (18)2.4人脸定位模块 (19)3 图像预处理 (20)3.1引言 (20)3.2M A TLAB简介 (20)3.3图像处理及过程 (20)3.3.1 图像的灰度化 (21)3.3.2 直方图均衡 (22)3.3.3 滤波去噪 (23)3.3.5 图像的边缘检测 (27)4人脸特征的提取与识别 (33)4.1人脸定位 (33)4.2人脸识别流程图 (34)4.3人脸图像采集实例 (37)4.4模板匹配 (39)4.5人脸数据库 (41)4.6系统软硬件平台 (43)4.7系统执行界面 (43)4.8系统软件实现介绍 (44)5系统测试 (45)5.1评价人脸识别系统的标准 (45)5.2测试的原则 (45)5.3测试结果 (46)结论 (47)参考文献 (49)致谢 (50)1绪论目前，在个人身份鉴别中主要依靠ID卡和密码等传统手段，这些传统手段的安全性能较低，都是基于“What he possesses”或“What he remembers”的简单身份鉴别，离真正意义上的身份鉴别“Who he is”还相差甚远。

Canny边缘检测

Canny 边缘检测本文档尝试解答如下问题:, 使用OpenCV函数 Canny 检测边缘. 原理?1. Canny 是 John F. Canny 于 1986边缘检测算法年开发出来的一个多级边缘检测算法，也被很多人认为是边缘检测的最优算法, 最优边缘检测的三个主要评价标准是:, 低错误率: 标识出尽可能多的实际边缘，同时尽可能的减少噪声产生的误报。

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

, 最小响应: 图像中的边缘只能标识一次。

步骤? 1. 消除噪声。

使用高斯平滑滤波器卷积降噪。

下面显示了一个的高斯内核示例:2. 计算梯度幅值和方向。

此处，按照Sobel滤波器的步骤:a. 运用一对卷积阵列 (分别作用于和方向):b. 使用下列公式计算梯度幅值和方向:梯度方向近似到四个可能角度之一(一般 0,45, 90, 135)3. 非极大值抑制。

这一步排除非边缘像素，仅仅保留了一些细线条(候选边缘)。

4. : 最后一步，Canny 使用了滞后阈值，滞后滞后阈值阈值需要两个阈值(高阈值和低阈值):a. 如果某一像素位置的幅值超过高阈值, 该像素被保留为边缘像素。

b. 如果某一像素位置的幅值小于阈值, 该低像素被排除。

c. 如果某一像素位置的幅值在两个阈值之间,该像素仅仅在连接到一个高于高阈值的像素时被保留。

Canny 推荐的高:低阈值比在 2:1 到3:1之间。

5. 想要了解更多细节，你可以参考任何你喜欢的计算机视觉书籍。

源码?1. 本程序做什么?o 要求使用者输入一个数字，设置 Canny EdgeDetector 的低阈值 (通过trackbar)o 使用 Canny 边缘检测产生一个 mask (白线代表边缘，黑色代表背景)。

o 使用 mask 作为掩码显示原图像。

2. 本教程的源码如下，你也可以从这里下载#include "opencv2/imgproc/imgproc.hpp"#include "opencv2/highgui/highgui.hpp"#include <stdlib.h>#include <stdio.h>using namespace cv;/// 全局变量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";/*** @函数 CannyThreshold* @简介: trackbar 交互回调 - Canny阈值输入比例1:3*/void CannyThreshold(int, void*){/// 使用 3x3内核降噪blur( src_gray, detected_edges, Size(3,3) );/// 运行Canny算子Canny( detected_edges, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size );/// 使用 Canny算子输出边缘作为掩码显示原图像dst = Scalar::all(0);src.copyTo( dst, detected_edges);imshow( window_name, dst );}/** @函数 main */int main( int argc, char** argv ){/// 装载图像src = imread( argv[1] );if( !src.data ){ return -1; }/// 创建与src同类型和大小的矩阵(dst)dst.create( src.size(), src.type() );/// 原图像转换为灰度图像cvtColor( src, src_gray, CV_BGR2GRAY );/// 创建显示窗口namedWindow( window_name, CV_WINDOW_AUTOSIZE );/// 创建trackbarcreateTrackbar( "Min Threshold:", window_name, &lowThreshold, max_lowThreshold, CannyThreshold );/// 显示图像CannyThreshold(0, 0);/// 等待用户反应waitKey(0);return 0;}解释?1. 创建程序中要用到的变量:2. Mat src, src_gray;3. Mat dst, detected_edges;4.5. int edgeThresh = 1;6. int lowThreshold;7. int const max_lowThreshold = 100;8. int ratio = 3;9. int kernel_size = 3;10. char* window_name = "Edge Map";11.12. 注意:13.14. a. 我们首先设定高:低阈值比为 3:1 (通过变量 *ratio* )15. b. 设定内核尺寸为 :math:`3` (Canny函数内部调用Sobel操作)c. 将低阈值的上限设定为 :math:`100`. 16. 装载原图像:17. /// 装载图像18. src = imread( argv[1] );19.20. if( !src.data )21. { return -1; }22. 创建与 src 同类型和大小的矩阵(dst)23. dst.create( src.size(), src.type() );24. 将输入图像转换到灰度空间 (使用函数 cvtColor): 25. cvtColor( src, src_gray, CV_BGR2GRAY );26. 创建显示窗口27. namedWindow( window_name,CV_WINDOW_AUTOSIZE );28. 创建trackbar，来获取用户交互输入的低阈值:29. createTrackbar( "Min Threshold:",window_name, &lowThreshold, max_lowThreshold,CannyThreshold );注意:a. 通过trackbar控制的变量为 lowThreshold ，上限为 max_lowThreshold (我们已经设定为100)b. 每次用户通过trackbar产生变动,回调函数CannyThreshold 被调用.30. 让我们一步一步的来观察 CannyThreshold 函数:a. 首先, 使用 3x3的内核平滑图像:b. blur( src_gray, detected_edges,Size(3,3) );c. 其次,运用 Canny 寻找边缘:d. Canny( detected_edges, detected_edges,lowThreshold, lowThreshold*ratio,kernel_size );输入参数:, detected_edges: 原灰度图像, detected_edges: 输出图像 (支持原地计算，可为输入图像), lowThreshold: 用户通过 trackbar设定的值。

pythonCanny边缘检测算法的实现

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

我们知道微分运算是求信号的变化率，具有加强⾼频分量的作⽤。

在空域运算中来说，对图像的锐化就是计算微分。

对于数字图像的离散信号，微分运算就变成计算差分或梯度。

图像处理中有多种边缘检测（梯度）算⼦，常⽤的包括普通⼀阶差分，Robert算⼦（交叉差分），Sobel算⼦等等，是基于寻找梯度强度。

拉普拉斯算⼦（⼆阶差分）是基于过零点检测。

通过计算梯度，设置阀值，得到边缘图像。

Canny边缘检测算⼦是⼀种多级检测算法。

1986年由John F. Canny提出，同时提出了边缘检测的三⼤准则：低错误率的边缘检测：检测算法应该精确地找到图像中的尽可能多的边缘，尽可能的减少漏检和误检。

最优定位：检测的边缘点应该精确地定位于边缘的中⼼。

图像中的任意边缘应该只被标记⼀次，同时图像噪声不应产⽣伪边缘。

Canny算法出现以后⼀直是作为⼀种标准的边缘检测算法，此后也出现了各种基于Canny算法的改进算法。

时⾄今⽇，Canny算法及其各种变种依旧是⼀种优秀的边缘检测算法。

⽽且除⾮前提条件很适合，你很难找到⼀种边缘检测算⼦能显著地⽐Canny算⼦做的更好。

关于各种差分算⼦，还有Canny算⼦的简单介绍，这⾥就不罗嗦了，⽹上都可以找得到。

直接进⼊Canny算法的实现。

Canny算法分为以下⼏步。

1. ⾼斯模糊。

这⼀步很简单，类似于LoG算⼦（Laplacian of Gaussian）作⾼斯模糊⼀样，主要作⽤就是去除噪声。

因为噪声也集中于⾼频信号，很容易被识别为伪边缘。

应⽤⾼斯模糊去除噪声，降低伪边缘的识别。

但是由于图像边缘信息也是⾼频信号，⾼斯模糊的半径选择很重要，过⼤的半径很容易让⼀些弱边缘检测不到。

2. 计算梯度幅值和⽅向。

图像的边缘可以指向不同⽅向，因此经典Canny算法⽤了四个梯度算⼦来分别计算⽔平，垂直和对⾓线⽅向的梯度。

OpenCV人脸跟踪canny边缘检测

OpenCV人脸跟踪canny边缘检测为了学习图像检测技术,把开源的OpenCV拿来研究,刚刚能用它监测人脸位置.OpenCV的源码和安装包都在Sourceforge中可以搜到:/projects/opencvlibrary/files/OpenCV用起来还是很简单的,根据readme把项目包配置好,三个方面:1,dll库路径设好环境变量,2,头文件路径设好,3,静态库文件路径设好,就可以调用函数,而且还提供一套非常好用GUI,用起来跟Matlab差不多.下面贴出用C++实现的人脸跟踪程序Cpp代码1.#include "cv.h"2.#include "highgui.h"3.4.int main()5.{6.//读取摄像头7.//声明IplImage指针8.IplImage* pFrame = NULL;9.10. CvCapture* pCapture = NULL;11. IplImage* pgray=NULL;12. IplImage* pcanny;13. CvMemStorage* storage=0;14. //cascade 这个是和人脸检测很有关系的,15. //我猜它可能用了一个神经网络之类的,从一个文件中读取一个16. //已经训练好的神经网络,天!自己怎么实现啊!17. CvHaarClassifierCascade* cascade=0;18. char cascadename[100]="C:\\OpenCV2.1\\data\\haarcascades\\haarcascade_frontalface_alt2.xml";19. cascade = (CvHaarClassifierCascade*)cvLoad(cascadename,0,0,0);20. storage = cvCreateMemStorage(0);21. CvSeq* faces;22.23. //创建窗口//就这么一句就创建了一个窗口,比Windows Api简单点24. //窗口通过窗口名来标识25. cvNamedWindow("video", 1);26. //cvMoveWindow("video", 30, 0);27. //打开摄像头或视频流,OpenCV居然还支持Real.嗨!什么都让别人做了28. pCapture = cvCaptureFromCAM(-1);29. //pCapture = cvCaptureFromFile("E:\\电影\\战争\\卓别林第一部有声喜剧片大独裁者RMVB中文字幕.rm");30.31. //每次循环从摄像头中读取一帧图片,我用的USB摄像机,条件不太好哦32. bool first=true;33. while(pFrame = cvQueryFrame( pCapture ))34. {35. if(first)//初次循环,做些初始化36. {37. first=false;38. //创建单通道图片39. pgray=cvCreateImage(cvGetSize(pFrame),IPL_DEPTH_8U,1);40. //这是canny边缘监测,和我原来做的差分得边缘不是一个级别的41. pcanny=cvCreateImage(cvGetSize(pFrame),IPL_DEPTH_8U,1);42. }43. //将彩色图转化为2值图44. cvCvtColor(pFrame,pgray,CV_BGR2GRAY);45. cvCanny(pgray,pcanny,30,100,3); //canny边缘检测46.47. /*********************************/48. //检测人脸,49. faces = cvHaarDetectObjects(pgray,cascade,50.storage,1.1,2,051.,cvSize(30,30));52. for(short i=0;i<(faces?faces->total:0);i++)53. {54. //得到人脸的区域55. CvRect* rect = (CvRect*)cvGetSeqElem(faces,i);56. //在人脸区域画个圆圈57. CvPoint center; //中心58. center.x=rect->x+rect->width/2;59. center.y=rect->y+rect->height/2;60. short radius = sqrt(pow(rect->width,2)//半径61.+pow(rect->height,2))/2;62. CvScalar color={{255,0,0}}; //画圈的颜色63. cvCircle(pFrame,center,radius,color,3,8,0);64. /**********************************/65. }66. //显示图像67. //cvShowImage("video", pcanny);68.69. cvShowImage("video", pFrame);70. //延时,不然不会显示图像的,应该是扫描太快了71. if(cvWaitKey(10)>= 0)72. {73. break;74. }75. }76. //释放图像77. cvReleaseImage(&pFrame);78. cvReleaseImage(&pgray);79. cvReleaseImage(&pcanny);80.81. //销毁窗口82. cvDestroyWindow("video");83. //释放摄像设备84. cvReleaseCapture(&pCapture);85. return 0;86.}人脸检测图片:相机不太好,还是能检测到的下面是canny检测图片,检测出来的基本上都是重要的边界,自己做的杂音太多了,没法拿出来.。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

人脸CANNY 边缘检测参数控制的学习模式
作者
摘要：在开放或半开放样本采集环境中进行的人脸图像自动识别中，正确提取人脸的几何和
现状特征是正确识别的一个非常关键的环节。

CANNY 边缘检测在这方面具有比较突出的优点，但必须解决其相关参数的正确选择问题。

而解决问题的关键是必须建立相应的学习模式，以根据实际的样本和识别特征的要求来确定满足相关要求的控制参数。

Abstracts: In human face recognition
1.引言
目前，基于图像的自动检测和识别技术在一些领域有了一定的应用，特别是在图像采集环境（主要是背景和光线）较为稳定的场合（如指纹识别）获得了较好的应用效果。

但在图像采集环境变化场合（如开放或半开放环境中的人脸图像识别、车牌图像识别）的应用效果却尚不尽人意，主要表现为识别正确率不能满足自动检测和识别的要求，根本原因在于：1、图像样本中待识别对象的特征不稳定；2、计算机不能准确获得用以区分不同对象的特征信息。

根据视觉原理，人之所以能够识别图像中的不同对象，就在于图像中存在着颜色梯度（灰度图像为灰度梯度）以区别图像中不同部分。

对于计算机而言，则可以通过边缘检测将图像中不同颜色部分分割开。

因此，边缘检测相对而言更符合计算机视觉原理，是识别对象特征定位、选择和提取的及其重要的手段。

目前提出的边缘检测的方法比较多，其中CANNY 边缘检测在实际应用中表现出稳定性较高、边缘定位较准确（边缘宽度为一个像素）、泛化能力强（相关参数适应范围宽）的突出优点。

对于图像识别而言，CANNY 边缘检测的目的是为了获得识别对象的特征信息，而且这些特征信息还必须能够从背景信息中明确地分离出来。

因此影响CANNY 边缘检测效果的相关参数的确定，也必须以具体的识别对象的特征信息为依据，才能从图像中获得合适的边缘信息。

但是开放或半开放环境中的人脸图像样本的特征信息的变动范围往往比较大，必须通过对大量实际样本的学习训练，才能够确定合适的CANNY 边缘检测的相关参数。

因此，必须建立合理的人脸CANNY 边缘检测参数控制的学习模式。

2、采集图像样本的清晰度控制
所谓图像清晰度，反映的是图像细节的清晰程度。

如果图像样本的细节本身就非常模糊，则识别对象也难以与背景区分，边缘检测的目的也难以实现。

因此，必须对图像样本的清晰度进行适当的控制。

影响图像清晰度的因素主要是光线和相机的成像焦距，这里仅以特定光线补偿条件下，通过相机成像焦距的调整来实现对图像清晰度的控制。

图像清晰度采用八邻域梯度绝对值之和为评价函数
|
)1,1(),(||),1(),(||)1,1(),(||)1,(),(||
)1,(),(||)1,1(),(||),1(),(||)1,1(),(|
222
2++-++-+-+-++-+--++--+--+---=∑∑-=-=y x f y x f y x f y x f y x f y x f y x f y x f y x f y x f y x f y x f y x f y x f y x f y x f p N x N y
相机自动调焦系统以获得最大图像清晰度为焦距调整的依据，调整时以采集点标记物图像为样本，调整过程如图1所示。

图1图像采集自动调焦过程
3、CANNY 边缘检测的控制参数
Canny 算子边缘检测法由于具有信噪比大、定位精度高、单边缘响应的优点，在图像分割、纹理特征提取和形状特征提取方面有重要的作用。

其具体过程一般有如下步骤：
1）:用二维高斯滤波模板与灰度图像f(x,y)卷积，以减小噪声影响；二维高斯函数为：)]y x (21exp[21
)y ,x (E 2222+-=σπσ，σ为高斯滤波卷积核的宽度
卷积：)y ,x (f )y ,x (E )y ,x (A ⊗=
2）:利用导数算子(如Prewitt 算子、Sobel 算子)找到图像灰度沿着两个方向的导数G x 、G y ,并求出梯度的大小|G| 和方向θ： x A G x ∂∂=，y A G y ∂∂=，2
y 2
x G G |G |+=，)G G (arctan x y =θ
3）:对梯度幅值进行非极大值抑制。

遍历图像，如果某个像素的灰度值与其梯度方向上前后两个像素的灰度值相比不是最大的，则将该像素值置0，即不是边缘。

4）:用双阈值算法检测和连接边缘。

确定高、低两个阈值Th ，Tl ；梯度值大于Th 的像素为边缘，小于Tl 的不是边缘，介于两个阈值之间的，如果其邻接像素有梯度值大于高阈值的则为边缘，如没有则不是。

从上述过程可以知道，CANNY 边缘检测法检测出的边缘取决于参数σ、Th 和Tl 。

σ、Th 和Tl 值越小，图像中小边缘和噪声引起的假边缘保留下来的越多，要利用的边缘信息易被淹没；而σ、Th 和Tl 值越大，则易使要利用的边缘信息丢失，出现边缘间断现象。

如图所示（灰度区间为0—1）
012022023024032
0105020503050405
4、人脸CANNY边缘检测参数控制的学习模式
人脸CANNY边缘检测参数控制的学习模式如图所示
图CANNY边缘检测参数控制的学习模式
系统为具有三个反馈环的层次结构，通过基于实际图像样本的边缘特征分类知识学习，参数σ、Th和Tl补偿分类知识学习和参数σ、Th和Tl初值分类知识学习，以选择恰当的σ、Th和Tl初值及其补偿方式，实现获得合适的CANNY边缘检测结果，达到正确识别的目的。

边缘特征分类知识学习是为了获得用以对CANNY边缘检测效果进行评价的相关指标，这些指标以识别特征定位和提取时所需的有关信息为依据，如人脸轮廓边缘长度、耳廓边缘长度、嘴唇边缘长度、眼睛或眉毛边缘长度及其相互间的长度比关系等，一般情况下，需要综合利用其中的几个指标。

比如，以获得类水平和类垂直方向最大连续边缘长度及最大长宽比作为评价指标，可反映边缘检测后人脸轮廓的较好完整性。

参数σ、Th和Tl补偿分类知识学习是为了建立σ、Th和Tl补偿方式，包括补偿的方向、大小和补偿加速方法等。

具体到人脸识别时，应该以边缘特征评价的相关指标先由大至小训练参数σ，再由大至小训练参数Th和Tl，利于提高训练速度。

参数σ、Th和Tl初值分类知识学习是为了归纳σ、Th和Tl初值分类经验，缩小初值选择范围，提高收敛速度。

5、结论
对于图像分割、识别特征提取，必须要实现对相应特征像素的正确定位。

如果能够合理地选择合适的参数，则CANNY边缘检测具有非常突出的优点。

但是，目前公开的文献资料中，对于CANNY边缘检测参数的选择或是采用不具有普遍意义的经验数据，或是脱离具体识别对象和识别场合而单纯根据图像像素分布来选择，往往不能满足实际的识别要求。

本文所提出的学习模式，围绕人脸图像识别的目的，在实际样本的基础上进行学习，符合识别的本质要求；且该模式较为灵活，易于适应利用不同识别特征的识别方法。