AI 助理
备案控制台
开发者社区 人工智能 文章 正文

图像处理之Canny边缘检测

2024-06-07 31
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 图像处理之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像素转为灰度值的代码如下：

int gray = (int) (0.299 * tr + 0.587 * tg + 0.114 * tb);

2.      对图像进行高斯模糊

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

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

    float kernel[][] = new float[gaussianKernelWidth][gaussianKernelWidth];
    for(int x=0; x<gaussianKernelWidth; x++)
    {
      for(int y=0; y<gaussianKernelWidth; y++)
      {
        kernel[x][y] = gaussian(x, y, gaussianKernelRadius);
      }
    }

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

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

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

// 高斯模糊 -灰度图像
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;
  }
}

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


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


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


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


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


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


// 计算梯度-gradient, X放与Y方向
data = new float[width * height];
magnitudes = new float[width * height];
for (int row = 0; row < height; row++) {
  for (int col = 0; col < width; col++) {
    index = row * width + col;
    // 计算X方向梯度
    float xg = (getPixel(outPixels, width, height, col, row+1) - 
        getPixel(outPixels, width, height, col, row) + 
        getPixel(outPixels, width, height, col+1, row+1) -
        getPixel(outPixels, width, height, col+1, row))/2.0f;
    float yg = (getPixel(outPixels, width, height, col, row)-
        getPixel(outPixels, width, height, col+1, row) +
        getPixel(outPixels, width, height, col, row+1) -
        getPixel(outPixels, width, height, col+1, row+1))/2.0f;
    // 计算振幅与角度
    data[index] = hypot(xg, yg);
    if(xg == 0)
    {
      if(yg > 0)
      {
        magnitudes[index]=90;           
      }
      if(yg < 0)
      {
        magnitudes[index]=-90;
      }
    }
    else if(yg == 0)
    {
      magnitudes[index]=0;
    }
    else
    {
      magnitudes[index] = (float)((Math.atan(yg/xg) * 180)/Math.PI);          
    }
    // make it 0 ~ 180
    magnitudes[index] += 90;
  }
}

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

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

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

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

个简单的例子如下：


// 非最大信号压制算法 3x3
Arrays.fill(magnitudes, 0);
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) // 跟零度是一致的，感谢一位网友发现了这个问题
    {
      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;
      }
    }
  }
}

1.      双阈值边缘连接


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


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


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


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


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


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


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


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


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


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

Arrays.fill(data, 0);
int offset = 0;
for (int row = 0; row < height; row++) {
  for (int col = 0; col < width; col++) {
    if(magnitudes[offset] >= highThreshold && data[offset] == 0)
    {
      edgeLink(col, row, offset, lowThreshold);
    }
    offset++;
  }
}

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

private void edgeLink(int x1, int y1, int index, float threshold) {
  int x0 = (x1 == 0) ? x1 : x1 - 1;
  int x2 = (x1 == width - 1) ? x1 : x1 + 1;
  int y0 = y1 == 0 ? y1 : y1 - 1;
  int y2 = y1 == height -1 ? y1 : y1 + 1;
  
  data[index] = magnitudes[index];
  for (int x = x0; x <= x2; x++) {
    for (int y = y0; y <= y2; y++) {
      int i2 = x + y * width;
      if ((y != y1 || x != x1)
        && data[i2] == 0 
        && magnitudes[i2] >= threshold) {
        edgeLink(x, y, i2, threshold);
        return;
      }
    }
  }
}


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

// 二值化显示
for(int i=0; i<inPixels.length; i++)
{
  int gray = clamp((int)data[i]);
  outPixels[i] = gray > 0 ? -1 : 0xff000000;     
}

最终运行结果：


四：完整的Canny算法源代码

package com.gloomyfish.filter.study;
 
import java.awt.image.BufferedImage;
import java.util.Arrays;
 
public class CannyEdgeFilter extends AbstractBufferedImageOp {
  private float gaussianKernelRadius = 2f;
  private int gaussianKernelWidth = 16;
  private float lowThreshold;
  private float highThreshold;
  // image width, height
  private int width;
  private int height;
  private float[] data;
  private float[] magnitudes;
 
  public CannyEdgeFilter() {
    lowThreshold = 2.5f;
    highThreshold = 7.5f;
    gaussianKernelRadius = 2f;
    gaussianKernelWidth = 16;
  }
 
  public float getGaussianKernelRadius() {
    return gaussianKernelRadius;
  }
 
  public void setGaussianKernelRadius(float gaussianKernelRadius) {
    this.gaussianKernelRadius = gaussianKernelRadius;
  }
 
  public int getGaussianKernelWidth() {
    return gaussianKernelWidth;
  }
 
  public void setGaussianKernelWidth(int gaussianKernelWidth) {
    this.gaussianKernelWidth = gaussianKernelWidth;
  }
 
  public float getLowThreshold() {
    return lowThreshold;
  }
 
  public void setLowThreshold(float lowThreshold) {
    this.lowThreshold = lowThreshold;
  }
 
  public float getHighThreshold() {
    return highThreshold;
  }
 
  public void setHighThreshold(float highThreshold) {
    this.highThreshold = highThreshold;
  }
 
  @Override
  public BufferedImage filter(BufferedImage src, BufferedImage dest) {
    width = src.getWidth();
    height = src.getHeight();
    if (dest == null)
      dest = createCompatibleDestImage(src, null);
    // 图像灰度化
    int[] inPixels = new int[width * height];
    int[] outPixels = new int[width * height];
    getRGB(src, 0, 0, width, height, inPixels);
    int index = 0;
    for (int row = 0; row < height; row++) {
      int ta = 0, tr = 0, tg = 0, tb = 0;
      for (int col = 0; col < width; col++) {
        index = row * width + col;
        ta = (inPixels[index] >> 24) & 0xff;
        tr = (inPixels[index] >> 16) & 0xff;
        tg = (inPixels[index] >> 8) & 0xff;
        tb = inPixels[index] & 0xff;
        int gray = (int) (0.299 * tr + 0.587 * tg + 0.114 * tb);
        inPixels[index] = (ta << 24) | (gray << 16) | (gray << 8)
            | gray;
      }
    }
    
    // 计算高斯卷积核
    float kernel[][] = new float[gaussianKernelWidth][gaussianKernelWidth];
    for(int x=0; x<gaussianKernelWidth; x++)
    {
      for(int y=0; y<gaussianKernelWidth; y++)
      {
        kernel[x][y] = gaussian(x, y, gaussianKernelRadius);
      }
    }
    // 高斯模糊 -灰度图像
    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;
      }
    }
    
    // 计算梯度-gradient, X放与Y方向
    data = new float[width * height];
    magnitudes = new float[width * height];
    for (int row = 0; row < height; row++) {
      for (int col = 0; col < width; col++) {
        index = row * width + col;
        // 计算X方向梯度
        float xg = (getPixel(outPixels, width, height, col, row+1) - 
            getPixel(outPixels, width, height, col, row) + 
            getPixel(outPixels, width, height, col+1, row+1) -
            getPixel(outPixels, width, height, col+1, row))/2.0f;
        float yg = (getPixel(outPixels, width, height, col, row)-
            getPixel(outPixels, width, height, col+1, row) +
            getPixel(outPixels, width, height, col, row+1) -
            getPixel(outPixels, width, height, col+1, row+1))/2.0f;
        // 计算振幅与角度
        data[index] = hypot(xg, yg);
        if(xg == 0)
        {
          if(yg > 0)
          {
            magnitudes[index]=90;           
          }
          if(yg < 0)
          {
            magnitudes[index]=-90;
          }
        }
        else if(yg == 0)
        {
          magnitudes[index]=0;
        }
        else
        {
          magnitudes[index] = (float)((Math.atan(yg/xg) * 180)/Math.PI);          
        }
        // make it 0 ~ 180
        magnitudes[index] += 90;
      }
    }
    
    // 非最大信号压制算法 3x3
    Arrays.fill(magnitudes, 0);
    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;
          }
        }
      }
    }
    // 寻找最大与最小值
    float min = 255;
    float max = 0;
    for(int i=0; i<magnitudes.length; i++)
    {
      if(magnitudes[i] == 0) continue;
      min = Math.min(min, magnitudes[i]);
      max = Math.max(max, magnitudes[i]);
    }
    System.out.println("Image Max Gradient = " + max + " Mix Gradient = " + min);
 
    // 通常比值为 TL : TH = 1 : 3， 根据两个阈值完成二值化边缘连接
    // 边缘连接-link edges
    Arrays.fill(data, 0);
    int offset = 0;
    for (int row = 0; row < height; row++) {
      for (int col = 0; col < width; col++) {
        if(magnitudes[offset] >= highThreshold && data[offset] == 0)
        {
          edgeLink(col, row, offset, lowThreshold);
        }
        offset++;
      }
    }
    
    // 二值化显示
    for(int i=0; i<inPixels.length; i++)
    {
      int gray = clamp((int)data[i]);
      outPixels[i] = gray > 0 ? -1 : 0xff000000;     
    }
    setRGB(dest, 0, 0, width, height, outPixels );
    return dest;
  }
  
  public int clamp(int value) {
    return value > 255 ? 255 :
      (value < 0 ? 0 : value);
  }
  
  private void edgeLink(int x1, int y1, int index, float threshold) {
    int x0 = (x1 == 0) ? x1 : x1 - 1;
    int x2 = (x1 == width - 1) ? x1 : x1 + 1;
    int y0 = y1 == 0 ? y1 : y1 - 1;
    int y2 = y1 == height -1 ? y1 : y1 + 1;
    
    data[index] = magnitudes[index];
    for (int x = x0; x <= x2; x++) {
      for (int y = y0; y <= y2; y++) {
        int i2 = x + y * width;
        if ((y != y1 || x != x1)
          && data[i2] == 0 
          && magnitudes[i2] >= threshold) {
          edgeLink(x, y, i2, threshold);
          return;
        }
      }
    }
  }
  
  private float getPixel(float[] input, int width, int height, int col,
      int row) {
    if(col < 0 || col >= width)
      col = 0;
    if(row < 0 || row >= height)
      row = 0;
    int index = row * width + col;
    return input[index];
  }
  
  private float hypot(float x, float y) {
    return (float) Math.hypot(x, y);
  }
  
  private int getPixel(int[] inPixels, int width, int height, int col,
      int row) {
    if(col < 0 || col >= width)
      col = 0;
    if(row < 0 || row >= height)
      row = 0;
    int index = row * width + col;
    return inPixels[index];
  }
  
  private float gaussian(float x, float y, float sigma) {
    float xDistance = x*x;
    float yDistance = y*y;
    float sigma22 = 2*sigma*sigma;
    float sigma22PI = (float)Math.PI * sigma22;
    return (float)Math.exp(-(xDistance + yDistance)/sigma22)/sigma22PI;
  }
 
}
文章标签：
算法
计算机视觉
机器人
opencv学堂
目录
相关文章
龙腾九州
|
5月前
|
算法
Canny边缘检测
【6月更文挑战第7天】Canny边缘检测。
龙腾九州
36 1
龙腾九州
|
5月前
Sobel边缘检测
【6月更文挑战第7天】Sobel边缘检测。
龙腾九州
40 1
richard_yuu
|
5月前
|
算法 计算机视觉
【Qt&OpenCV 图像边缘检测 Sobel/Laplace/Canny】
【Qt&OpenCV 图像边缘检测 Sobel/Laplace/Canny】
richard_yuu
63 0
opencv学堂
|
5月前
|
计算机视觉
图像处理之直方图均衡化
图像处理之直方图均衡化
opencv学堂
38 0
年少轻与狂
|
计算机视觉
opencv之 边缘检测(canny)
opencv之 边缘检测(canny)
年少轻与狂
93 0
时义龙
|
11月前
|
算法 计算机视觉
1.Opencv_Canny(),边缘检测详解
1.Opencv_Canny(),边缘检测详解
时义龙
61 0
翟天保Steven
|
算法
OpenCV-Canny边缘检测
OpenCV-Canny边缘检测
翟天保Steven
63 0
翟天保Steven
OpenCV-Sobel边缘检测
OpenCV-Sobel边缘检测
翟天保Steven
49 0
翟天保Steven
|
计算机视觉
OpenCV-Laplacian边缘检测
OpenCV-Laplacian边缘检测
翟天保Steven
46 0
宋wz
|
Python
边缘检测汇总
边缘检测汇总
宋wz
42 0