图像处理之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

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

2.      对图像进行高斯模糊

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

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

[java] view plain copy

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实现

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

[java] view plain copy

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的算子，其数学表达如下：

[java] view plain copy

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

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

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

个简单的例子如下：

[java] view plain copy

1. <span style="font-size:18px;">// 非最大信号压制算法 3x3

2. Arrays.fill(magnitudes, 0);

3. for (int row = 0; row < height; row++) {

4. for (int col = 0; col < width; col++) {

5. index = row * width + col;

6. float angle = magnitudes[index];

7. float m0 = data[index];

8. magnitudes[index] = m0;

9. if(angle >=0 && angle < 22.5) // angle 0

10. {

11. float m1 = getPixel(data, width, height, col-1, row);

12. float m2 = getPixel(data, width, height, col+1, row);

13. if(m0 < m1 || m0 < m2)

14. {

15. magnitudes[index] = 0;

16. }

17. }

18. else if(angle >= 22.5 && angle < 67.5) // angle +45

19. {

20. float m1 = getPixel(data, width, height, col+1, row-1);

21. float m2 = getPixel(data, width, height, col-1, row+1);

22. if(m0 < m1 || m0 < m2)

23. {

24. magnitudes[index] = 0;

25. }

26. }

27. else if(angle >= 67.5 && angle < 112.5) // angle 90

28. {

29. float m1 = getPixel(data, width, height, col, row+1);

30. float m2 = getPixel(data, width, height, col, row-1);

31. if(m0 < m1 || m0 < m2)

32. {

33. magnitudes[index] = 0;

34. }

35. }

36. else if(angle >=112.5 && angle < 157.5) // angle 135 / -45

37. {

38. float m1 = getPixel(data, width, height, col-1, row-1);

39. float m2 = getPixel(data, width, height, col+1, row+1);

40. if(m0 < m1 || m0 < m2)

41. {

42. magnitudes[index] = 0;

43. }

44. }

45. else if(angle >=157.5) // 跟零度是一致的，感谢一位网友发现了这个问题

46. {

47. float m1 = getPixel(data, width, height, col+1, row);

48. float m2 = getPixel(data, width, height, col-1, row);

49. if(m0 < m1 || m0 < m2)

50. {

51. magnitudes[index] = 0;

52. }

53. }

54. }

55. }</span>

1.      双阈值边缘连接

非最大信号压制以后，输出的幅值如果直接显示结果可能会少量的非边缘像素被包

含到结果中，所以要通过选取阈值进行取舍，传统的基于一个阈值的方法如果选择

的阈值较小起不到过滤非边缘的作用，如果选择的阈值过大容易丢失真正的图像边

缘，Canny提出基于双阈值(Fuzzy threshold)方法很好的实现了边缘选取，在实际

应用中双阈值还有边缘连接的作用。双阈值选择与边缘连接方法通过假设两个阈值

其中一个为高阈值TH另外一个为低阈值TL则有

a.      对于任意边缘像素低于TL的则丢弃

b.      对于任意边缘像素高于TH的则保留

c.      对于任意边缘像素值在TL与TH之间的，如果能通过边缘连接到一个像素大于

TH而且边缘所有像素大于最小阈值TL的则保留，否则丢弃。代码实现如下：

[java] view plain copy

1. <span style="font-size:18px;">Arrays.fill(data, 0);

2. int offset = 0;

3. for (int row = 0; row < height; row++) {

4. for (int col = 0; col < width; col++) {

5. if(magnitudes[offset] >= highThreshold && data[offset] == 0)

6. {

7. edgeLink(col, row, offset, lowThreshold);

8. }

9. offset++;

10. }

11. }</span>

基于递归的边缘寻找方法edgeLink的代码如下：

[java] view plain copy

1. <span style="font-size:18px;">private void edgeLink(int x1, int y1, int index, float threshold) {

2. int x0 = (x1 == 0) ? x1 : x1 - 1;

3. int x2 = (x1 == width - 1) ? x1 : x1 + 1;

4. int y0 = y1 == 0 ? y1 : y1 - 1;

5. int y2 = y1 == height -1 ? y1 : y1 + 1;

6. data[index] = magnitudes[index];

7. for (int x = x0; x <= x2; x++) {

8. for (int y = y0; y <= y2; y++) {

9. int i2 = x + y * width;

10. if ((y != y1 || x != x1)

11. && data[i2] == 0

12. && magnitudes[i2] >= threshold) {

13. edgeLink(x, y, i2, threshold);

14. return;

15. }

16. }

17. }

18. }</span>

6.      结果二值化显示 - 不说啦，直接点，自己看吧，太简单啦

[java] view plain copy

1. <span style="font-size:18px;">// 二值化显示

2. for(int i=0; i<inPixels.length; i++)

3. {

4. int gray = clamp((int)data[i]);

5. outPixels[i] = gray > 0 ? -1 : 0xff000000;

6. }</span>

最终运行结果：