图像处理之霍夫变换(直线检测算法)
霍夫变换是图像变换中的经典手段之一,主要用来从图像中分离出具有某种相同特征的几何
形状(如,直线,圆等)。霍夫变换寻找直线与圆的方法相比与其它方法可以更好的减少噪
声干扰。经典的霍夫变换常用来检测直线,圆,椭圆等。
霍夫变换算法思想:
以直线检测为例,每个像素坐标点经过变换都变成都直线特质有贡献的统一度量,一个简单
的例子如下:一条直线在图像中是一系列离散点的集合,通过一个直线的离散极坐标公式,
可以表达出直线的离散点几何等式如下:
X *cos(theta) + y * sin(theta) = r 其中角度theta指r与X轴之间的夹角,r为到直线几何垂
直距离。任何在直线上点,x, y都可以表达,其中 r, theta是常量。该公式图形表示如下:
然而在实现的图像处理领域,图像的像素坐标P(x, y)是已知的,而r, theta则是我们要寻找
的变量。如果我们能绘制每个(r, theta)值根据像素点坐标P(x, y)值的话,那么就从图像笛卡
尔坐标系统转换到极坐标霍夫空间系统,这种从点到曲线的变换称为直线的霍夫变换。变换
通过量化霍夫参数空间为有限个值间隔等分或者累加格子。当霍夫变换算法开始,每个像素
坐标点P(x, y)被转换到(r, theta)的曲线点上面,累加到对应的格子数据点,当一个波峰出现
时候,说明有直线存在。同样的原理,我们可以用来检测圆,只是对于圆的参数方程变为如
下等式:
(x –a ) ^2 + (y-b) ^ 2 = r^2其中(a, b)为圆的中心点坐标,r圆的半径。这样霍夫的参数空间就
变成一个三维参数空间。给定圆半径转为二维霍夫参数空间,变换相对简单,也比较常用。
编程思路解析:
1. 读取一幅带处理二值图像,最好背景为黑色。
2. 取得源像素数据
3. 根据直线的霍夫变换公式完成霍夫变换,预览霍夫空间结果
4. 寻找最大霍夫值,设置阈值,反变换到图像RGB值空间(程序难点之一)
5. 越界处理,显示霍夫变换处理以后的图像
关键代码解析:
直线的变换角度为[0 ~ PI]之间,设置等份为500为PI/500,同时根据参数直线参数方程的取值
范围为[-r, r]有如下霍夫参数定义:
// prepare for hough transform int centerX = width / 2; int centerY = height / 2; double hough_interval = PI_VALUE/(double)hough_space; int max = Math.max(width, height); int max_length = (int)(Math.sqrt(2.0D) * max); hough_1d = new int[2 * hough_space * max_length];
实现从像素RGB空间到霍夫空间变换的代码为:
// start hough transform now.... int[][] image_2d = convert1Dto2D(inPixels); for (int row = 0; row < height; row++) { for (int col = 0; col < width; col++) { int p = image_2d[row][col] & 0xff; if(p == 0) continue; // which means background color // since we does not know the theta angle and r value, // we have to calculate all hough space for each pixel point // then we got the max possible theta and r pair. // r = x * cos(theta) + y * sin(theta) for(int cell=0; cell < hough_space; cell++ ) { max = (int)((col - centerX) * Math.cos(cell * hough_interval) + (row - centerY) * Math.sin(cell * hough_interval)); max += max_length; // start from zero, not (-max_length) if (max < 0 || (max >= 2 * max_length)) {// make sure r did not out of scope[0, 2*max_lenght] continue; } hough_2d[cell][max] +=1; } } }
寻找最大霍夫值计算霍夫阈值的代码如下:
// find the max hough value int max_hough = 0; for(int i=0; imax_hough) { max_hough = hough_2d[i][j]; } } } System.out.println("MAX HOUGH VALUE = " + max_hough); // transfer back to image pixels space from hough parameter space int hough_threshold = (int)(threshold * max_hough);
从霍夫空间反变换回像素数据空间代码如下:
// transfer back to image pixels space from hough parameter space int hough_threshold = (int)(threshold * max_hough); for(int row = 0; row < hough_space; row++) { for(int col = 0; col < 2*max_length; col++) { if(hough_2d[row][col] < hough_threshold) // discard it continue; int hough_value = hough_2d[row][col]; boolean isLine = true; for(int i=-1; i<2; i++) { for(int j=-1; j<2; j++) { if(i != 0 || j != 0) { int yf = row + i; int xf = col + j; if(xf < 0) continue; if(xf < 2*max_length) { if (yf < 0) { yf += hough_space; } if (yf >= hough_space) { yf -= hough_space; } if(hough_2d[yf][xf] <= hough_value) { continue; } isLine = false; break; } } } } if(!isLine) continue; // transform back to pixel data now... double dy = Math.sin(row * hough_interval); double dx = Math.cos(row * hough_interval); if ((row <= hough_space / 4) || (row >= 3 * hough_space / 4)) { for (int subrow = 0; subrow < height; ++subrow) { int subcol = (int)((col - max_length - ((subrow - centerY) * dy)) / dx) + centerX; if ((subcol < width) && (subcol >= 0)) { image_2d[subrow][subcol] = -16776961; } } } else { for (int subcol = 0; subcol < width; ++subcol) { int subrow = (int)((col - max_length - ((subcol - centerX) * dx)) / dy) + centerY; if ((subrow < height) && (subrow >= 0)) { image_2d[subrow][subcol] = -16776961; } } } } }霍夫变换源图如下:
霍夫变换以后,在霍夫空间显示如下:(白色表示已经找到直线信号)
最终反变换回到像素空间效果如下:
一个更好的运行监测直线的结果(输入为二值图像):
完整的霍夫变换源代码如下:
package com.gloomyfish.image.transform; import java.awt.image.BufferedImage; import com.process.blur.study.AbstractBufferedImageOp; public class HoughLineFilter extends AbstractBufferedImageOp { public final static double PI_VALUE = Math.PI; private int hough_space = 500; private int[] hough_1d; private int[][] hough_2d; private int width; private int height; private float threshold; private float scale; private float offset; public HoughLineFilter() { // default hough transform parameters // scale = 1.0f; // offset = 0.0f; threshold = 0.5f; scale = 1.0f; offset = 0.0f; } public void setHoughSpace(int space) { this.hough_space = space; } public float getThreshold() { return threshold; } public void setThreshold(float threshold) { this.threshold = threshold; } public float getScale() { return scale; } public void setScale(float scale) { this.scale = scale; } public float getOffset() { return offset; } public void setOffset(float offset) { this.offset = offset; } @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 ); houghTransform(inPixels, outPixels); setRGB( dest, 0, 0, width, height, outPixels ); return dest; } private void houghTransform(int[] inPixels, int[] outPixels) { // prepare for hough transform int centerX = width / 2; int centerY = height / 2; double hough_interval = PI_VALUE/(double)hough_space; int max = Math.max(width, height); int max_length = (int)(Math.sqrt(2.0D) * max); hough_1d = new int[2 * hough_space * max_length]; // define temp hough 2D array and initialize the hough 2D hough_2d = new int[hough_space][2*max_length]; for(int i=0; i转载文章请务必注明出自本博客!!= 2 * max_length)) {// make sure r did not out of scope[0, 2*max_lenght] continue; } hough_2d[cell][max] +=1; } } } // find the max hough value int max_hough = 0; for(int i=0; i max_hough) { max_hough = hough_2d[i][j]; } } } System.out.println("MAX HOUGH VALUE = " + max_hough); // transfer back to image pixels space from hough parameter space int hough_threshold = (int)(threshold * max_hough); for(int row = 0; row < hough_space; row++) { for(int col = 0; col < 2*max_length; col++) { if(hough_2d[row][col] < hough_threshold) // discard it continue; int hough_value = hough_2d[row][col]; boolean isLine = true; for(int i=-1; i<2; i++) { for(int j=-1; j<2; j++) { if(i != 0 || j != 0) { int yf = row + i; int xf = col + j; if(xf < 0) continue; if(xf < 2*max_length) { if (yf < 0) { yf += hough_space; } if (yf >= hough_space) { yf -= hough_space; } if(hough_2d[yf][xf] <= hough_value) { continue; } isLine = false; break; } } } } if(!isLine) continue; // transform back to pixel data now... double dy = Math.sin(row * hough_interval); double dx = Math.cos(row * hough_interval); if ((row <= hough_space / 4) || (row >= 3 * hough_space / 4)) { for (int subrow = 0; subrow < height; ++subrow) { int subcol = (int)((col - max_length - ((subrow - centerY) * dy)) / dx) + centerX; if ((subcol < width) && (subcol >= 0)) { image_2d[subrow][subcol] = -16776961; } } } else { for (int subcol = 0; subcol < width; ++subcol) { int subrow = (int)((col - max_length - ((subcol - centerX) * dx)) / dy) + centerY; if ((subrow < height) && (subrow >= 0)) { image_2d[subrow][subcol] = -16776961; } } } } } // convert to hough 1D and return result for (int i = 0; i < this.hough_1d.length; i++) { int value = clamp((int)(scale * this.hough_1d[i] + offset)); // scale always equals 1 this.hough_1d[i] = (0xFF000000 | value + (value << 16) + (value << 8)); } // convert to image 1D and return for (int row = 0; row < height; row++) { for (int col = 0; col < width; col++) { outPixels[(col + row * width)] = image_2d[row][col]; } } } public BufferedImage getHoughImage() { BufferedImage houghImage = new BufferedImage(hough_2d[0].length, hough_space, BufferedImage.TYPE_4BYTE_ABGR); setRGB(houghImage, 0, 0, hough_2d[0].length, hough_space, hough_1d); return houghImage; } public static int clamp(int value) { if (value < 0) value = 0; else if (value > 255) { value = 255; } return value; } private int[][] convert1Dto2D(int[] pixels) { int[][] image_2d = new int[height][width]; int index = 0; for(int row = 0; row < height; row++) { for(int col = 0; col < width; col++) { index = row * width + col; image_2d[row][col] = pixels[index]; } } return image_2d; } }