hough变换检测直线Java

hough变换检测直线原理：

假设在图像中存在一条直线y=k*x+b(此时k,b未知)。取直线上的任意两点进行说明，设为(x0,y0),(x1,y1)。

所有经过点(x0,y0)的直线满足：-x0*k+y0=b ---式1，那么以k、b为直角坐标轴做式1对应直线；

所有经过点(x1,y1)的直线满足：-x1*k+y1=b ---式2，那么以k、b为直角坐标轴做式2对应直线；

两直线交于一点(kk,bb)，此时该交点对应的直线y=kk*x+bb就是(x0,y0),(x1,y1)所确定的直线。

在hough变换中，我们首先将直线方程转换为极坐标形式：x*cos(theta)+y*sin(theta)=r ---式3（theta，r未知）。同上述原理，假设已知直线上的点的坐标，那么经过该点的曲线方程就对应着hough变换空间（即theta,r坐标系）的一条曲线，同一条直线上的点必定在hough变换空间相交于一点（theta*,r*），该点就是待检测直线方程式3对应的theta、r。当然，在hough变换空间两条曲线相交确定的（theta，r）并不能足以说明我们检测到了一条直线，只有当在（theta，r）这一点累加的曲线个数很大，通常是超过了我们提前设定的某个阈值时，我们才认为在（theta，r）是对应有一条直线的，否则我们应该使用极大值抑制的方法将这些干扰点（theta，r）去掉。下图是copy过来的，大概看看就行。

以下是hough变换检测直线的封装类，因实际需求，这里我是专门用来检测任意四边形的四条边的。

public class LineFilter {
    private int w;
    private int h;
    private int halfX;
    private int halfY;
    private int rmax;
    private int lineNum;
    private int[] output;
    private int[] n;
    private int[][] acc;
    private double[] sinValue;
    private double[] cosValue;
    private List<Acc> list;

    //Acc累加器，同一个r，theta的点进行累加，累加个数为val
    public class Acc {
        private int r = 0;
        private int theta = 0;
        private int val = 0;
        public Acc() {
        }
    }

    public int[] lineDetect(int width, int height, int lineNumber, int[] input) {
        init(width, height, lineNumber);
        /*
        * 转换：直角坐标空间~极坐标空间
        * 不断计算累加，最终得到相同(theta,r)的像素点累加个数acc[theta][r]
        * */
        for (int theta = 0; theta < 180; theta++) {
            for (int x = 0; x < w; x++) {
                for (int y = 0; y < h; y++) {
                    if (input[y * w + x] == Color.BLACK) {
                        int r = (int) ((x - halfX) * cosValue[theta] + (y - halfY) * sinValue[theta]);
                        r = r + rmax;//r的原本取值范围为(-ramx,ramx)，加rmax后取值范围为(0,2ramx)
                        if (r >= 0 && r < 2 * rmax)
                            acc[theta][r]++;
                    }
                }
            }
        }
        /*
        * 很重要的一步：在3*3窗口内对累加值进行极大值抑制，保留窗口内累加值最大的(theta,r)；
        * 之后将theta，r,acc[theta][r]添加进list里面；
        * 对list进行部分排序；
        * 之后取出list前面lineNum个Acc对象，通过theta和r值找出直角坐标空间的直线
        * */
        rankList(acc);
        System.out.println(".........acc个数：" + list.size());
        n = new int[lineNum];
        for (int i = 0; i < lineNum; i++) {
            Acc acc = list.get(i);
            n[i] = drawLine(acc.r, acc.theta, n[i]);
            System.out.println("检测出的第" + i + "条直线点的累积个数：" + acc.r + "..." + acc.theta + "..." + acc.val);
            System.out.println("实际输出第" + i + "条直线点的个数：" + n[i]);
        }
        return output;
    }

    private void init(int width, int height, int lineNumber) {
        w = width;
        h = height;
        halfX = w / 2;
        halfY = h / 2;
        lineNum = lineNumber;
        output = new int[w * h];
        int max = Math.max(w, h);
        rmax = (int) (Math.sqrt(2.0) * max);
        acc = new int[180][2 * rmax];
        list = new ArrayList<>();
        sinValue = new double[180];
        cosValue = new double[180];
        Arrays.fill(output, Color.WHITE);
        for (int theta = 0; theta < 180; theta++) {
            sinValue[theta] = Math.sin((theta * Math.PI) / 180);
            cosValue[theta] = Math.cos((theta * Math.PI) / 180);
        }
    }

    /*
    * 排序Acc数组，只对前面几个Acc进行排序，找出lineSize个较大的Acc
    * */
    private void rankList(int[][] acc) {
        /*
        * 对(theta,r)进行极大值抑制,因为有时候因为计算误差或者直线不是很直的原因，
        * 同一条直线上的点转换到极坐标空间时，就会出现多对不同的(theta,r),多对不同的(theta,r)转换到直角坐标空间就出现了多条直线，
        * 这就是为什么原本图像中只有一条直线最后在该位置检测出了多条直线，因此在进行极坐标到直角坐标转换之前，
        * 有必要对(theta,r)进行极大值抑制，只保留累积值val最大的那一对(theta,r)
        * */
        for (int theta = 0; theta < 180; theta++) {
            for (int r = 0; r < 2 * rmax; r++) {
                int val = acc[theta][r];
                boolean onlyLine = true;
                if (val > 0) {
                    for (int tt = -1; tt <=1; tt++) {
                        for (int rr = -1; rr <= 1; rr++) {
                            int newtheta = theta + tt;
                            int newr = r + rr;
                            if (newtheta < 0 || newtheta >= 180)
                                newtheta = 0;
                            if (newr < 0 || newr >= 2 * rmax) newr = 0;
                            if (acc[newtheta][newr] > val) onlyLine = false;
                        }
                    }
                    /*
                    *在3*3窗口内累加值最大的(theta,r)我们才添加进list ，
                    * 并标记theta，r，以及累加值val
                    * */
                    if (onlyLine) {
                        Acc subAcc = new Acc();
                        subAcc.r = r - rmax;
                        subAcc.theta = theta;
                        subAcc.val = acc[theta][r];
                        list.add(subAcc);
                    }
                }
            }
        }
        /*
        * 设置需要检测的直线条数为lineNum,
        * 按val值大小升序排列list，当然只需要进行前面部分的排序即可
        * */
        for (int i = 0; i < lineNum; i++) {
            int max = i;
            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(j).val > list.get(max).val) {
                    max = j;
                }
            }
            if (max != i) {
                Acc accmax = list.get(max);
                Acc acci = list.get(i);
                list.set(max, acci);
                list.set(i, accmax);
            }
        }
    }

    /*
    *转换：极坐标空间~直角坐标空间
    *r=(x-halfx)*cos(theta)+(y-halfy)*sin(theta);
    * 已知r，theta，x或者y的情况下，通过该式计算出符合条件的y或者x。
    * 画出lineNum条直线
    * */
    private int drawLine(int r, int theta, int n) {
        if (theta >= 45 && theta <= 135) {
            for (int x = 0; x < w; x++) {
                int y = (int) ((r - (x - halfX) * cosValue[theta]) / sinValue[theta]) + halfY;
                if (y >= 0 && y < h) {
                    output[y * w + x] = Color.BLACK;
                    n++;
                }
            }
        } else {
            for (int y = 0; y < h; y++) {
                int x = (int) ((r - (y - halfY) * sinValue[theta]) / cosValue[theta]) + halfX;
                if (x >= 0 && x < w) {
                    output[y * w + x] = Color.BLACK;
                    n++;
                }
            }
        }
        return n;
    }

}