DistancePath.java

Go to the documentation of this file.

package theba.core.math;

import java.awt.Point;
import java.util.ArrayList;

public class DistancePath {

        int w, h;

        short[] oldgeo, oldborder;

        short[] geodesic, borderdist, border;

        public short[] getPath(short[] geodesic, short[] border, short[] dist,
                        int w, int h) {
                this.geodesic = geodesic;
                this.border = border;

                short[] out = new short[h * w];
                ArrayList<Point> points = new ArrayList<Point> ();

                for (int y = 0; y < h; y++) {
                        for (int x = 0; x < w; x++) {
                                if (border[x + y * w] != 0)
                                        points.add(new Point(x, y));
                        }
                }

                Point po, p;

                int counter = 0; // Keep track of path length

                while (true) {

                        counter++;

                        if (counter > 120) {
                                // If maximum path length is reached, then abort.
                                // The path has most probably gotten lost.
                                System.err.println("Path too long to connect lumens");
                                for (int i = 0; i < border.length; i++)
                                        border[i] = 0;
                                return border;
                        }

                        int min = Integer.MAX_VALUE;

                        po = null;
                        for (int t = 0; t < points.size(); t++) {

                                p = points.get(t);

                                int val = geodesic[p.y * w + p.x];

                                val -= 2 * dist[p.y * w + p.x];

                                if (val < min && out[p.y * w + p.x] == 0) {
                                        po = p;
                                        min = val;
                                }
                        }

                        if (po == null)
                                return new short[geodesic.length]; // path has closed itself

                        if (geodesic[po.y * w + po.x] < 2)
                                break; // destination reached

                        out[po.y * w + po.x] = (byte) 255;

                        points.clear();
                        for (int a = -1; a <= 1; a++) {
                                for (int b = -1; b <= 1; b++) {
                                        if (a == 0 && b == 0)
                                                continue;
                                        if (po.x + a < 0 || po.x + a >= w || po.y + b < 0 || po.y + b >= h)
                                                continue;
                                        points.add(new Point(po.x + a, po.y + b));
                                }
                        }

                }

                return out;
        }
}