您的位置: 首页  >  文章  >  Canny边缘检测算法C#源码

Canny边缘检测算法C#源码

分类: 文章 • 2024-05-23 14:59:52

[算法说明]

Canny边缘检测算法可以分为4步：高斯滤波器平滑处理、梯度计算、非极大值抑制、双阈值边缘检

测和边缘连接。

  1，高斯滤波器平滑处理。由于图像中经常包含一些高斯噪声，因此在边缘检测前我们要先用高斯

滤波器对其进行滤波，为了方便，通常是使用一些高斯模板，这里我们使用如下的高斯滤波器模板。

Canny边缘检测算法C#源码

 

 

  1. /// <summary>

  2. /// Canny edge detect process.

  3. /// </summary>

  4. /// <param name="src">The source image.</param>

  5. /// <param name="highThreshould">The high threshould value. </param>

  6. /// <param name="lowThreshould">The low threshould value. </param>

  7. /// <returns></returns>

  8. public static WriteableBitmap CannyedgedetectProcess(WriteableBitmap src,int highThreshould,int lowThreshould)////图像油画效果

  9. {

  10. if (src != null)

  11. {

  12. int w = src.PixelWidth;

  13. int h = src.PixelHeight;

  14. WriteableBitmap srcImage = new WriteableBitmap(w, h);

  15. byte[] temp = src.PixelBuffer.ToArray();

  16. byte[] tempMask = (byte[])temp.Clone();

  17. int[,] srcBytes = new int[w, h];

  18. for (int j = 0; j < h; j++)

  19. {

  20. for (int i = 0; i < w; i++)

  21. {

  22. srcBytes[i, j] = (int)(tempMask[i * 4 + j * w * 4] * 0.114 + tempMask[i * 4 + 1 + j * w * 4] * 0.587 + tempMask[i * 4 + 2 + j * w * 4] * 0.299);

  23. }

  24. }

  25. float gradientMax = 0;

  26. float[,] gradient = new float[w, h];

  27. byte[,] degree = new byte[w, h];

  28. GaussFilter(ref srcBytes, w, h);

  29. GetGradientDegree(srcBytes, ref gradient, ref degree, ref gradientMax, w, h);

  30. NonMaxMini(gradient, ref srcBytes, gradientMax, w, h, degree);

  31. TwoThreshouldJudge(highThreshould, lowThreshould, ref srcBytes, w, h);

  32. for (int j = 0; j < h; j++)

  33. {

  34. for (int i = 0; i < w; i++)

  35. {

  36. temp[i * 4 + j * w * 4] = temp[i * 4 + 1 + j * w * 4] = temp[i * 4 + 2 + j * w * 4] = (byte)srcBytes[i, j];

  37. }

  38. }

  39. Stream sTemp = srcImage.PixelBuffer.AsStream();

  40. sTemp.Seek(0, SeekOrigin.Begin);

  41. sTemp.Write(temp, 0, w * 4 * h);

  42. return srcImage;

  43. }

  44. else

  45. {

  46. return null;

  47. }

  48. }

  49. //高斯滤波

  50. private static void GaussFilter(ref int[,] src, int x, int y)

  51. {

  52. for (int j = 1; j < y - 1; j++)

  53. {

  54. for (int i = 1; i < x - 1; i++)

  55. {

  56. src[i, j] = (4 * src[i, j] + src[i - 1, j - 1] + src[i + 1, j - 1] + src[i - 1, j + 1] + src[i + 1, j + 1] + 2 * src[i, j - 1] + 2 * src[i - 1, j] + 2 * src[i, j + 1] + 2 * src[i + 1, j]) / 16;

  57. }

  58. }

  59. }

  60. //梯度相位角获取

  61. private static void GetGradientDegree(int[,] srcBytes, ref float[,] gradient, ref byte[,] degree, ref float GradientMax, int x, int y)

  62. {

  63. gradient = new float[x, y];

  64. degree = new byte[x, y];

  65. int gx, gy;

  66. int temp;

  67. double div;

  68. for (int j = 1; j < y - 1; j++)

  69. {

  70. for (int i = 1; i < x - 1; i++)

  71. {

  72. gx = srcBytes[i + 1, j - 1] + 2 * srcBytes[i + 1, j] + srcBytes[i + 1, j + 1] - srcBytes[i - 1, j - 1] - 2 * srcBytes[i - 1, j] - srcBytes[i - 1, j + 1];

  73. gy = srcBytes[i - 1, j - 1] + 2 * srcBytes[i, j - 1] + srcBytes[i + 1, j - 1] - srcBytes[i - 1, j + 1] - 2 * srcBytes[i, j + 1] - srcBytes[i + 1, j + 1];

  74. gradient[i, j] = (float)Math.Sqrt((double)(gx * gx + gy * gy));

  75. if (GradientMax < gradient[i, j])

  76. {

  77. GradientMax = gradient[i, j];

  78. }

  79. if (gx == 0)

  80. {

  81. temp = (gy == 0) ? 0 : 90;

  82. }

  83. else

  84. {

  85. div = (double)gy / (double)gx;

  86. if (div < 0)

  87. {

  88. temp = (int)(180 - Math.Atan(-div) * 180 / Math.PI);

  89. }

  90. else

  91. {

  92. temp = (int)(Math.Atan(div) * 180 / Math.PI);

  93. }

  94. if (temp < 22.5)

  95. {

  96. temp = 0;

  97. }

  98. else if (temp < 67.5)

  99. {

  100. temp = 45;

  101. }

  102. else if (temp < 112.5)

  103. {

  104. temp = 90;

  105. }

  106. else if (temp < 157.5)

  107. {

  108. temp = 135;

  109. }

  110. else

  111. temp = 0;

  112. }

  113. degree[i, j] = (byte)temp;

  114. }

  115. }

  116. }

  117. //非极大值抑制

  118. private static void NonMaxMini(float[,] gradient, ref int[,] srcBytes, float GradientMax, int x, int y, byte[,] degree)

  119. {

  120. float leftPixel = 0, rightPixel = 0;

  121. for (int j = 1; j < y - 1; j++)

  122. {

  123. for (int i = 1; i < x - 1; i++)

  124. {

  125. switch (degree[i, j])

  126. {

  127. case 0:

  128. leftPixel = gradient[i - 1, j];

  129. rightPixel = gradient[i + 1, j];

  130. break;

  131. case 45:

  132. leftPixel = gradient[i - 1, j + 1];

  133. rightPixel = gradient[i + 1, j - 1];

  134. break;

  135. case 90:

  136. leftPixel = gradient[i, j + 1];

  137. rightPixel = gradient[i, j - 1];

  138. break;

  139. case 135:

  140. leftPixel = gradient[i + 1, j + 1];

  141. rightPixel = gradient[i - 1, j - 1];

  142. break;

  143. default:

  144. break;

  145. }

  146. if ((gradient[i, j] < leftPixel) || (gradient[i, j] < rightPixel))

  147. {

  148. srcBytes[i, j] = 0;

  149. }

  150. else

  151. {

  152. srcBytes[i, j] = (int)(255 * gradient[i, j] / GradientMax);

  153. }

  154. }

  155. }

  156. }

  157. //双阈值边缘判断

  158. private static void TwoThreshouldJudge(int highThreshold, int lowThreshould, ref int[,] srcBytes, int x, int y)

  159. {

  160. for (int j = 1; j < y - 1; j++)

  161. {

  162. for (int i = 1; i < x - 1; i++)

  163. {

  164. if (srcBytes[i, j] > highThreshold)

  165. {

  166. srcBytes[i, j] = 255;

  167. }

  168. else if (srcBytes[i, j] < lowThreshould)

  169. {

  170. srcBytes[i, j] = 0;

  171. }

  172. else

  173. {

  174. if (srcBytes[i - 1, j - 1] < highThreshold && srcBytes[i, j - 1] < highThreshold && srcBytes[i + 1, j - 1] < highThreshold && srcBytes[i - 1, j] < highThreshold

  175. && srcBytes[i + 1, j] < highThreshold && srcBytes[i - 1, j + 1] < highThreshold && srcBytes[i, j + 1] < highThreshold && srcBytes[i + 1, j + 1] < highThreshold)

  176. {

  177. srcBytes[i, j] = 0;

  178. }

  179. else

  180. srcBytes[i, j] = 255;

  181. }

  182. }

  183. }

  184. }

Canny边缘检测算法C#源码

相关推荐