Return distance between the line defined by (x0,y0) and (x1,y1) and the point (x,y).

Description

Demo Code



public class Main{
    /**/* www .  ja v  a  2 s .c  o m*/
     * Return distance between the line defined by (x0,y0) and (x1,y1) and the
     * point (x,y). Ref:
     * http://astronomy.swin.edu.au/pbourke/geometry/pointline/ The 3D case
     * should be similar.
     *
     * @param x0, y0 First point of line.
     * @param x1, y1 Second point of line.
     * @param x, y, Point to consider.
     * @return Distance from x,y down to the (extended) line defined by x0, y0,
     * x1, y1.
     */
    public static double distance(int x0, int y0, int x1, int y1, int x,
            int y) {
        // If x0,y0,x1,y1 is same point, we return distance to that point
        double length = GeometryUtils.length(x0, y0, x1, y1);
        if (length == 0.0) {
            return GeometryUtils.length(x0, y0, x, y);
        }

        // If u is [0,1] then (xp,yp) is on the line segment (x0,y0),(x1,y1).
        double u = ((x - x0) * (x1 - x0) + (y - y0) * (y1 - y0))
                / (length * length);

        // This is the intersection point of the normal.
        // TODO: Might consider returning this as well.
        double xp = x0 + u * (x1 - x0);
        double yp = y0 + u * (y1 - y0);

        length = GeometryUtils.length(xp, yp, x, y);
        return length;
    }
    /**
     * Return the length of a vector.
     *
     * @param v Vector to compute length of [x,y,z].
     * @return Length of vector.
     */
    public static double length(double[] v) {
        return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
    }
    /**
     * Compute distance between two points.
     *
     * @param p0, p1 Points to compute distance between [x,y,z].
     * @return Distance between points.
     */
    public static double length(double[] p0, double[] p1) {
        double[] v = GeometryUtils.createVector(p0, p1);
        return length(v);
    }
    /**
     * Compute the length of the line from (x0,y0) to (x1,y1)
     *
     * @param x0, y0 First line end point.
     * @param x1, y1 Second line end point.
     * @return Length of line from (x0,y0) to (x1,y1).
     */
    public static double length(int x0, int y0, int x1, int y1) {
        return GeometryUtils.length((double) x0, (double) y0, (double) x1,
                (double) y1);
    }
    /**
     * Compute the length of the line from (x0,y0) to (x1,y1)
     *
     * @param x0, y0 First line end point.
     * @param x1, y1 Second line end point.
     * @return Length of line from (x0,y0) to (x1,y1).
     */
    public static double length(double x0, double y0, double x1, double y1) {
        double dx = x1 - x0;
        double dy = y1 - y0;

        return Math.sqrt(dx * dx + dy * dy);
    }
    /**
     * Compute the length of a polyline.
     *
     * @param x, y Arrays of x,y coordinates
     * @param nPoints Number of elements in the above.
     * @param isClosed True if this is a closed polygon, false otherwise
     * @return Length of polyline defined by x, y and nPoints.
     */
    public static double length(int[] x, int[] y, boolean isClosed) {
        double length = 0.0;

        int nPoints = x.length;
        for (int i = 0; i < nPoints - 1; i++) {
            length += GeometryUtils.length(x[i], y[i], x[i + 1], y[i + 1]);
        }

        // Add last leg if this is a polygon
        if (isClosed && nPoints > 1) {
            length += GeometryUtils.length(x[nPoints - 1], y[nPoints - 1],
                    x[0], y[0]);
        }

        return length;
    }
    /**
     * Construct the vector specified by two points.
     *
     * @param p0, p1 Points the construct vector between [x,y,z].
     * @return v Vector from p0 to p1 [x,y,z].
     */
    public static double[] createVector(double[] p0, double[] p1) {
        double v[] = { p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2] };
        return v;
    }
}
Return distance between the line defined by (x0,y0) and (x1,y1) and the point (x,y). - Java java.lang

Description

Demo Code

Related Tutorials
