Application: gvSIG desktop » Library: org.gvsig.tools

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.euclidean;

import java.awt.geom.Point2D;

/**

 *

 * @author fdiaz

 */

public class EuclideanLine2DImpl implements EuclideanLine2D {

    double coefA;

    double coefB;

    double coefC;

    double m;

    double b;

    public EuclideanLine2DImpl(double coefA, double coefB, double coefC) {

        this.coefA = coefA;

        this.coefB = coefB;

        this.coefC = coefC;

        reduceCoefs();

        this.m = -coefA/coefB;

        if(this.m == -0.0){

            this.m = 0.0;

        }

        this.b = -coefC / coefB;

    }

    public EuclideanLine2DImpl(double m, double b) {

        this.m = m;

        this.b = b;

        this.coefA = m;

        this.coefB = -1.0;

        this.coefC = b;

        reduceCoefs();

    }

    public EuclideanLine2DImpl(double x0, double y0, double x1, double y1) {

        this(y1 - y0, -(x1 - x0), -(y1 - y0) * x0 + (x1 - x0) * y0);

    }

    public EuclideanLine2DImpl(Point2D p0, Point2D p1) {

        this(p0.getX(), p0.getY(), p1.getX(), p1.getY());

    }

    private void reduceCoefs() {

        if(coefA != 0 && Double.isFinite(coefA)){

            coefC = coefC/coefA;

            coefB = coefB/coefA;

            coefA = 1.0;

        } else if(coefB != 0 && Double.isFinite(coefB)){

            coefA = coefA/coefB; // for change the sign of coefA when coefA is infinite && coefB = -1;

            coefC = coefC/coefB;

            coefB = 1.0;

        }

    }

    @Override

    public double getA() {

        return coefA;

    }

    @Override

    public double getB() {

        return coefB;

    }

    @Override

    public double getC() {

        return coefC;

    }

    @Override

    public double getSlope() {

        return m;

    }

    @Override

    public double getYIntercept() {

        return b;

    }

    @Override

    public double getY(double x) {

        return (-coefA*x-coefC)/coefB;

    }

    @Override

    public double getX(double y) {

        return (-coefB*y-coefC)/coefA;

    }

    @Override

    public double getAngle(EuclideanLine2D line) {

        double m1 = line.getSlope();

        return Math.atan(Math.abs((m1-m)/(1+m1*m)));

    }

    @Override

    public double getAngle(EuclideanLine2D line, Point2D quadrant) {

        //FIXME: not implemented yet

        double m1 = line.getSlope();

        return Math.atan(Math.abs((m1-m)/(1+m1*m)));

    }

    @Override

    public double getDegreesAngle(EuclideanLine2D line) {

        return Math.toDegrees(getAngle(line));

    }

    @Override

    public double getDegreesAngle(EuclideanLine2D line, Point2D quadrant) {

        return Math.toDegrees(getAngle(line, quadrant));

    }

    @Override

    public double getDistance(double pointX, double pointY) {

        // d(P,r)=|A*px+B*py+C|/SQRT(A?+B?)

        double den = Math.abs(Math.sqrt(Math.pow(coefA, 2) + Math.pow(coefB, 2)));

        return Math.abs((coefA * pointX + coefB * pointY + coefC)) / den;

    }

    @Override

    public double getDistance(Point2D point) {

        return getDistance(point.getX(), point.getY());

    }

    @Override

    public double getDistance(EuclideanLine2D line) {

        if (isParallel(line)) { //Parallel lines

            if (Double.isInfinite(m)) { //Vertical lines

                return line.getC() - coefC;

            }

            Double den = Math.sqrt(Math.pow(coefA, 2) + Math.pow(coefB, 2));

            return Math.abs(line.getC() - coefC) / den;

        }

        return 0d;

    }

    @Override

    public boolean isParallel(EuclideanLine2D line) {

        double m1 = line.getSlope();

        return (m == m1 || (Double.isInfinite(m) && Double.isInfinite(m1)));

    }

    @Override

    public Point2D getIntersection(EuclideanLine2D line) {

        //Using Cramer's rule

        double a1 = coefA;

        double b1 = coefB;

        double c1 = coefC;

        Double a2 = line.getA();

        Double b2 = line.getB();

        Double c2 = line.getC();

        Double det = a1 * b2 - a2 * b1;

        Double detX = -c1 * b2 + c2 * b1;

        Double detY =  -a1 * c2 + a2 * c1;

        Double x = detX / det;

        Double y = detY / det;

        return new Point2D.Double(x, y);

        //Using Apache commons math library, need import the library

//        RealMatrix coefficients =

//        new Array2DRowRealMatrix(new double[][] { { coefA, coefB }, { line.getA(), line.getB() } }, false);

//        DecompositionSolver solver = new LUDecomposition(coefficients).getSolver();

//        RealVector constants = new ArrayRealVector(new double[] { -coefC, -line.getC() }, false);

//        RealVector solution = solver.solve(constants);

//        return new Point2D.Double(solution.getEntry(0), solution.getEntry(1));

    }

    @Override

    public EuclideanLine2D getPerpendicular(double pointX, double pointY) {

        // perpendicular slope (m)

        Double m1 = -1 / m;

        // perpendicular y-intercept (b)

        Double b1 = pointY - (m1 * pointX);

        return new EuclideanLine2DImpl(m1, b1);

    }

    @Override

    public EuclideanLine2D getPerpendicular(Point2D point) {

        return getPerpendicular(point.getX(), point.getY());

    }

    @Override

    public Point2D getNearestPoint(double pointX, double pointY) {

        double x;

        double y;

        if (Double.isInfinite(m)) {

            y = pointY;

            x = (-coefB * y - coefC) / coefA;

        } else if (m == 0) {

            x = pointX;

            y = b;

        } else {

            EuclideanLine2D perp = getPerpendicular(pointX, pointY);

            Double m1 = perp.getSlope();

            Double b1 = perp.getYIntercept();

            x = (b1 - b) / (m - m1);

            y = m * x + b;

        }

        return new Point2D.Double(x, y);

    }

    @Override

    public Point2D getNearestPoint(Point2D point) {

        return getNearestPoint(point.getX(), point.getY());

    }

    @Override

    public EuclideanLine2D[] getBisectors(EuclideanLine2D line) {

        /*

            r) A1x + B1y + C1 = 0

            s) A2x + B2y + C2 = 0

            |A1x+B1y+C1|/SQRT(A1?+B1?)= |A2x+B2y+C2|/SQRT(A2?+B2?)

        */

        Double a1 = coefA;

        Double b1 = coefB;

        Double c1 = coefC;

        Double a2 = line.getA();

        Double b2 = line.getB();

        Double c2 = line.getC();

        Double den1 = Math.sqrt(Math.pow(a1,2) + Math.pow(b1,2));

        Double den2 = Math.sqrt(Math.pow(a1,2) + Math.pow(b1,2));

        EuclideanLine2D[] result = new EuclideanLine2DImpl[2];

        result[0] = new EuclideanLine2DImpl(

                den2 * a1 - den1 * a2,

                den2 * b1 - den1 * b2,

                den2 * c1 - den1 * c2

        );

        result[1] = new EuclideanLine2DImpl(

                den2 * a1 + den1 * a2,

                den2 * b1 + den1 * b2,

                den2 * c1 + den1 * c2

        );

        return result;

    }

}