一:历史

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像素转为灰度值的代码如下:

  1. <span style="font-size:18px;">int gray = (int) (0.299 * tr + 0.587 * tg + 0.114 * tb);</span>

2.      对图像进行高斯模糊

图像高斯模糊时,首先要根据输入参数确定高斯方差与窗口大小,这里我设置默认方

差值窗口大小为16x16,根据这两个参数生成高斯卷积核算子的代码如下:

  1. <span style="font-size:18px;">      float kernel[][] = new float[gaussianKernelWidth][gaussianKernelWidth];
  2. for(int x=0; x<gaussianKernelWidth; x++)
  3. {
  4. for(int y=0; y<gaussianKernelWidth; y++)
  5. {
  6. kernel[x][y] = gaussian(x, y, gaussianKernelRadius);
  7. }
  8. }</span>

获取了高斯卷积算子之后,我们就可以对图像高斯卷积模糊,关于高斯图像模糊更详

细的解释可以参见这里:http://blog.csdn.net/jia20003/article/details/7234741实现

图像高斯卷积模糊的代码如下:

  1. <span style="font-size:18px;">// 高斯模糊 -灰度图像
  2. int krr = (int)gaussianKernelRadius;
  3. for (int row = 0; row < height; row++) {
  4. for (int col = 0; col < width; col++) {
  5. index = row * width + col;
  6. double weightSum = 0.0;
  7. double redSum = 0;
  8. for(int subRow=-krr; subRow<=krr; subRow++)
  9. {
  10. int nrow = row + subRow;
  11. if(nrow >= height || nrow < 0)
  12. {
  13. nrow = 0;
  14. }
  15. for(int subCol=-krr; subCol<=krr; subCol++)
  16. {
  17. int ncol = col + subCol;
  18. if(ncol >= width || ncol <=0)
  19. {
  20. ncol = 0;
  21. }
  22. int index2 = nrow * width + ncol;
  23. int tr1 = (inPixels[index2] >> 16) & 0xff;
  24. redSum += tr1*kernel[subRow+krr][subCol+krr];
  25. weightSum += kernel[subRow+krr][subCol+krr];
  26. }
  27. }
  28. int gray = (int)(redSum / weightSum);
  29. outPixels[index] = gray;
  30. }
  31. }</span>

3.      计算图像X方向与Y方向梯度,根据梯度计算图像边缘幅值与角度大小

高斯模糊的目的主要为了整体降低图像噪声,目的是为了更准确计算图像梯度及边缘

幅值。计算图像梯度可以选择算子有Robot算子、Sobel算子、Prewitt算子等。关于

图像梯度计算更多的解释可以看这里:

http://blog.csdn.net/jia20003/article/details/7664777。

这里采用更加简单明了的2x2的算子,其数学表达如下:

  1. <span style="font-size:18px;">// 计算梯度-gradient, X放与Y方向
  2. data = new float[width * height];
  3. magnitudes = new float[width * height];
  4. for (int row = 0; row < height; row++) {
  5. for (int col = 0; col < width; col++) {
  6. index = row * width + col;
  7. // 计算X方向梯度
  8. float xg = (getPixel(outPixels, width, height, col, row+1) -
  9. getPixel(outPixels, width, height, col, row) +
  10. getPixel(outPixels, width, height, col+1, row+1) -
  11. getPixel(outPixels, width, height, col+1, row))/2.0f;
  12. float yg = (getPixel(outPixels, width, height, col, row)-
  13. getPixel(outPixels, width, height, col+1, row) +
  14. getPixel(outPixels, width, height, col, row+1) -
  15. getPixel(outPixels, width, height, col+1, row+1))/2.0f;
  16. // 计算振幅与角度
  17. data[index] = hypot(xg, yg);
  18. if(xg == 0)
  19. {
  20. if(yg > 0)
  21. {
  22. magnitudes[index]=90;
  23. }
  24. if(yg < 0)
  25. {
  26. magnitudes[index]=-90;
  27. }
  28. }
  29. else if(yg == 0)
  30. {
  31. magnitudes[index]=0;
  32. }
  33. else
  34. {
  35. magnitudes[index] = (float)((Math.atan(yg/xg) * 180)/Math.PI);
  36. }
  37. // make it 0 ~ 180
  38. magnitudes[index] += 90;
  39. }
  40. }</span>

在获取了图像每个像素的边缘幅值与角度之后

4.      非最大信号压制

信号压制本来是数字信号处理中经常用的,这里的非最大信号压制主要目的是实现边

缘细化,通过该步处理边缘像素进一步减少。非最大信号压制主要思想是假设3x3的

像素区域,中心像素P(x,y) 根据上一步中计算得到边缘角度值angle,可以将角度分

为四个离散值0、45、90、135分类依据如下:

其中黄色区域取值范围为0~22.5 与157.5~180

绿色区域取值范围为22.5 ~ 67.5

蓝色区域取值范围为67.5~112.5

红色区域取值范围为112.5~157.5

分别表示上述四个离散角度的取值范围。得到角度之后,比较中心像素角度上相邻

两个像素,如果中心像素小于其中任意一个,则舍弃该边缘像素点,否则保留。一

个简单的例子如下:

);

  • for (int row = 0; row < height; row++) {
  • for (int col = 0; col < width; col++) {
  • index = row * width + col;
  • float angle = magnitudes[index];
  • float m0 = data[index];
  • magnitudes[index] = m0;
  • if(angle >=0 && angle < 22.5) // angle 0
  • {
  • float m1 = getPixel(data, width, height, col-1, row);
  • float m2 = getPixel(data, width, height, col+1, row);
  • if(m0 < m1 || m0 < m2)
  • {
  • magnitudes[index] = 0;
  • }
  • }
  • else if(angle >= 22.5 && angle < 67.5) // angle +45
  • {
  • float m1 = getPixel(data, width, height, col+1, row-1);
  • float m2 = getPixel(data, width, height, col-1, row+1);
  • if(m0 < m1 || m0 < m2)
  • {
  • magnitudes[index] = 0;
  • }
  • }
  • else if(angle >= 67.5 && angle < 112.5) // angle 90
  • {
  • float m1 = getPixel(data, width, height, col, row+1);
  • float m2 = getPixel(data, width, height, col, row-1);
  • if(m0 < m1 || m0 < m2)
  • {
  • magnitudes[index] = 0;
  • }
  • }
  • else if(angle >=112.5 && angle < 157.5) // angle 135 / -45
  • {
  • float m1 = getPixel(data, width, height, col-1, row-1);
  • float m2 = getPixel(data, width, height, col+1, row+1);
  • if(m0 < m1 || m0 < m2)
  • {
  • magnitudes[index] = 0;
  • }
  • }
  • else if(angle >=157.5) // angle 0
  • {
  • float m1 = getPixel(data, width, height, col, row+1);
  • float m2 = getPixel(data, width, height, col, row-1);
  • if(m0 < m1 || m0 < m2)
  • {
  • magnitudes[index] = 0;
  • }
  • }
  • }
  • }</span>