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;
    }

}