• 热门专题

图像处理之Canny边缘检测

作者:  发布日期:2014-11-17 20:42:47
Tag标签:图像处理  边缘  
  • 图像处理之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) // 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;
    			}
    		}
    	}
    }

    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;
    	}
    
    }
    
    转载请务必注明出自本博客-gloomyfish

About IT165 - 广告服务 - 隐私声明 - 版权申明 - 免责条款 - 网站地图 - 网友投稿 - 联系方式
本站内容来自于互联网,仅供用于网络技术学习,学习中请遵循相关法律法规