Application: gvSIG desktop

import java.awt.geom.Point2D;

import java.util.List;

import java.util.Objects;

import org.gvsig.euclidean.EuclideanLine2D;

import org.gvsig.euclidean.EuclideanManager;

import org.gvsig.fmap.geom.aggregate.MultiPoint;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.Arc;

import org.gvsig.fmap.geom.primitive.Circle;

import org.gvsig.fmap.geom.primitive.Ellipse;

import org.gvsig.fmap.geom.primitive.Spline;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.util.ToolsUtilLocator;

    /**

     * Creates a circle as of center and radius.

     *

     * @param center

     *            of new circle

     * @param radius

     *            of new circle

     * @param subtype

     *            subtype of circle. See {@link Geometry.SUBTYPES}

     * @return The circle created with center and radius

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Circle createCircle(Point center, double radius, int subtype)

            throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Circle circle = (Circle) geomManager.create(Geometry.TYPES.CIRCLE, subtype);

        circle.setPoints(center, radius);

        return circle;

    }

    /**

     * Creates a circle from three points.

     *

     * @param firstPoint

     *            of circle

     * @param secondPoint

     *            of circle

     * @param thirdPoint

     *            of circle

     * @param subtype

     *            subtype of circle. See {@link Geometry.SUBTYPES}

     * @return The circle created from three points received as parameters.

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Circle createCircle(Point firstPoint, Point secondPoint,

            Point thirdPoint, int subtype) throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Circle circle = (Circle) geomManager.create(Geometry.TYPES.CIRCLE, subtype);

        circle.setPoints(firstPoint, secondPoint, thirdPoint);

        return circle;

    }

    /**

     * Creates a circle from five points.The first two points are two points on a tangent to the circle.The next two are two points on another tangent to the circle.The last one is a point near the center of the circle.

     *

     * @param firstPoint

     * @param secondPoint

     * @param thirdPoint

     * @param fourthPoint

     * @param fifthPoint

     * @param subtype

     *            subtype of circle. See {@link Geometry.SUBTYPES}

     * @return The circle created from three points received as parameters.

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Circle createCircle(Point firstPoint, Point secondPoint, Point thirdPoint, Point fourthPoint, Point fifthPoint, int subtype) throws CreateGeometryException {

        EuclideanManager euclideanManager = ToolsUtilLocator.getEuclideanManager();

        EuclideanLine2D line1 = euclideanManager.createLine2D(firstPoint.getX(), firstPoint.getY(), secondPoint.getX(), secondPoint.getY());

        EuclideanLine2D line2 = euclideanManager.createLine2D(thirdPoint.getX(), thirdPoint.getY(), fourthPoint.getX(), fourthPoint.getY());

        return createCircle(line1, line2, fifthPoint, subtype);

    }

    /**

     * Creates a circle from two tangents and one point.

     *

     * @param line1

     *            A tangent line

     * @param line2

     *            Another tangent line

     * @param point

     *            A point near the center of the circle.

     * @param subtype

     *            subtype of circle. See {@link Geometry.SUBTYPES}

     * @return The circle created from two tangents and one point received as parameters.

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Circle createCircle(EuclideanLine2D line1, EuclideanLine2D line2, Point point, int subtype) throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        EuclideanManager euclideanManager = ToolsUtilLocator.getEuclideanManager();

        try {

            EuclideanLine2D perpendicular;

            EuclideanLine2D bisector;

            if (line1.isParallel(line2)) {

                if (Objects.equals(line1.getYIntercept(), line2.getYIntercept())

                        || (Objects.equals(Math.abs(line1.getYIntercept()), 0.0)

                        && Objects.equals(Math.abs(line2.getYIntercept()), 0.0))) { //Same lines

                    perpendicular = line1.getPerpendicular(point.getX(), point.getY());

                    Point2D intersection = line1.getIntersection(perpendicular);

                    return createCircle(point, point.distance(geomManager.createPoint(intersection.getX(), intersection.getY(), subtype)), subtype);

                } else if (Double.isInfinite(line1.getSlope())) { //Parallel and vertical lines

                    Point center = createPoint(-(line2.getC() + line1.getC()) / 2.0, point.getY(), subtype);

                    double radius = line1.getDistance(center.getX(), center.getY());

                    return createCircle(center, radius, subtype);

                } else { //Parallel lines

                    bisector = euclideanManager.createLine2D(line1.getA(), line1.getB(), (line2.getC()+line1.getC())/2);

                }

            } else {

                EuclideanLine2D[] bisectors = line1.getBisectors(line2);

                double distance1 = bisectors[0].getDistance(point.getX(), point.getY());

                double distance2 = bisectors[1].getDistance(point.getX(), point.getY());

                bisector = bisectors[0];

                if (distance1 > distance2) {

                    bisector = bisectors[1];

                }

            }

            if (Double.isInfinite(bisector.getSlope())) {

                Point2D intersection = line1.getIntersection(line2);

                Point center = createPoint(intersection.getX(), point.getY(), subtype);

                Double radius = line1.getDistance(center.getX(), center.getY());

                return createCircle(center, radius, subtype);

            } else if (bisector.getSlope() == 0.0) {

                if (line1.isParallel(line2)) { //Objects.equals(m0, m1)) { //Same slope

                    Point center = createPoint(point.getX(), bisector.getYIntercept(), subtype);

                    Double radius = line1.getDistance(center.getX(), center.getY());

                    return createCircle(center, radius, subtype);

                } else {

                    Point2D intersection = line1.getIntersection(line2);

                    Point center = createPoint(point.getX(), intersection.getY(), subtype);

                    Double radius = line1.getDistance(center.getX(), center.getY());

                    return createCircle(center, radius, subtype);

                }

            }

            perpendicular = bisector.getPerpendicular(point.getX(), point.getY());

            Point2D intersection = bisector.getIntersection(perpendicular);

            Double radius = line1.getDistance(intersection.getX(), intersection.getY());

            return createCircle(

                    geomManager.createPoint(intersection.getX(), intersection.getY(), subtype), 

                    radius, 

                    subtype);

        } catch (GeometryOperationNotSupportedException | GeometryOperationException ex) {

            throw new CreateGeometryException(Geometry.TYPES.CIRCLE, subtype, ex);

        }

    }

    /**

     * Creates a circle from two tangent geometries and the radius.

     *

     * @param geometry1

     *            A tangent geometry

     * @param geometry2

     *            Another tangent geometry

     * @param radius

     *            the radius of the cicle.

     * @param firstPoint

     *            a point near tangent point of geometry1

     * @param secondPoint

     *            a point near tangent point of geometry2

     * @param subtype

     *            subtype of circle. See {@link Geometry.SUBTYPES}

     * @return The circle created from two tangent geometries and the radius received as parameters.

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Circle createCircle(Geometry geometry1, Geometry geometry2, double radius, Point firstPoint, Point secondPoint, int subtype) throws CreateGeometryException {

        try {

            Geometry buffer1 = geometry1.buffer(radius);

            MultiLine lines1 = buffer1.toLines();

            Geometry buffer2 = geometry2.buffer(radius);

            MultiLine lines2 = buffer2.toLines();

            Geometry intersection = lines1.intersection(lines2);

            Point center = null;

            if(intersection!=null){

                MultiPoint points = intersection.toPoints();

                double distance = Double.POSITIVE_INFINITY;

                for (int i = 0; i < points.getPrimitivesNumber(); i++) {

                    Point point = points.getPointAt(i);

                    double pointDistance = point.distance(firstPoint)+point.distance(secondPoint);

                    if(pointDistance<distance){

                        center = point;

                        distance = pointDistance;

                    }

                }

            }

            if(center == null){

                return null;

            }

            return createCircle(center, radius, subtype);

        } catch (GeometryOperationNotSupportedException | GeometryOperationException | GeometryException ex) {

            throw new CreateGeometryException(Geometry.TYPES.CIRCLE, subtype, ex);

        }

    }

    /**

     * Creates an arc as of center, radius, start angle and extension angle.

     *

     * @param center

     *            center of arc.

     * @param radius

     *            of arc.

     * @param startAngle

     *            of arc in radians

     * @param angleExt

     *            of arc in radians

     * @param subtype

     *            subtype of arc. See {@link Geometry.SUBTYPES}

     * @return The arc created with center, radius, start angle and extension

     *         angle.

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Arc createArc(Point center, double radius, double startAngle,

            double angleExt, int subtype) throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Arc arc = (Arc) geomManager.create(Geometry.TYPES.ARC, subtype);

        arc.setPoints(center, radius, startAngle, angleExt);

        return arc;

    }

    /**

     * Creates an arc as of three points.

     *

     * @param start

     *            point of arc

     * @param middle

     *            point of arc. It can be any point of arc.

     * @param end

     *            point of arc

     * @param subtype

     *            of arc. See {@link Geometry.SUBTYPES}

     * @return The arc created that it start at start point, cross middle

     *         point and end at end point.

     * @throws org.gvsig.tools.exception.BaseException

     */

    public static Arc createArc(Point start, Point middle, Point end, int subtype)

            throws BaseException {

        Arc arc = (Arc) GeometryLocator.getGeometryManager().create(Geometry.TYPES.ARC, subtype);

        arc.setPoints(start, middle, end);

        return arc;

    }

    /**

     * Creates an ellipse from start and end point of A axis and half length

     * of B axis.

     *

     * @param firstPointAxisA

     *            first point of A axis

     * @param secondPointAxisA

     *            second point of B axis

     * @param halfLengthAxisB

     *            half length of B axis

     * @param subtype

     *            of ellipse See {@link Geometry.SUBTYPES}

     * @return The ellipse created

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Arc createEllipse(Point firstPointAxisA, Point secondPointAxisA,

            double halfLengthAxisB, int subtype) throws CreateGeometryException {

        try {

            double lengthAxisA = secondPointAxisA.distance(firstPointAxisA);

            Point origen = createPoint(0, 0, subtype);

            Arc ellipse = createArc(

                    origen,

                    lengthAxisA / 2,

                    0,

                    2 * Math.PI,

                    subtype);

            ellipse.scale(origen, 1, halfLengthAxisB * 2 / lengthAxisA);

            final EuclideanManager euclideanManager = ToolsUtilLocator.getEuclideanManager();

            EuclideanLine2D axisA = euclideanManager.createLine2D(

                    firstPointAxisA.getX(),

                    firstPointAxisA.getY(), 

                    secondPointAxisA.getX(),

                    secondPointAxisA.getY());

            double angle = axisA.getAngle();

            ellipse.rotate(angle, 0, 0);

            Point centerOfEllipse = getMidPoint(firstPointAxisA, secondPointAxisA, subtype);

            ellipse.move(centerOfEllipse.getX(), centerOfEllipse.getY());

            return ellipse;

        } catch (GeometryOperationNotSupportedException | GeometryOperationException e) {

            throw new CreateGeometryException(Geometry.TYPES.ARC, subtype, e);

        }

    }

    /**

     * Creates a filled ellipse from start and end point of A axis and half length

     * of B axis.

     *

     * @param firstPointAxisA

     *            first point of A axis

     * @param secondPointAxisA

     *            second point of B axis

     * @param halfLengthAxisB

     *            half length of B axis

     * @param subtype

     *            of ellipse See {@link Geometry.SUBTYPES}

     * @return The ellipse created

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Ellipse createFilledEllipse(Point firstPointAxisA,

            Point secondPointAxisA, double halfLengthAxisB, int subtype)

            throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Ellipse ellipse = (Ellipse) geomManager.create(Geometry.TYPES.ELLIPSE, subtype);

        ellipse.setPoints(firstPointAxisA, secondPointAxisA, halfLengthAxisB);

        return ellipse;

    }

    /**

     * Gets center point of three points.

     *

     * @param a

     *            Point one

     * @param b

     *            Point two

     * @param c

     *            Point three

     * @param subtype

     *            of point created. See {@link Geometry.SUBTYPES}

     * @return Point center.

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Point getCenter(Point a, Point b, Point c, int subtype)

            throws CreateGeometryException {

        EuclideanManager euclideanManager = ToolsUtilLocator.getEuclideanManager();

        Point midPointAC = getMidPoint(a, c, subtype);

        EuclideanLine2D lineAC = euclideanManager.createLine2D(a.getX(), a.getY(), c.getX(), c.getY());

        EuclideanLine2D bisectorAC = lineAC.getPerpendicular(midPointAC.getX(), midPointAC.getY());

        Point midPointBC = getMidPoint(b, c, subtype);

        EuclideanLine2D lineBC = euclideanManager.createLine2D(b.getX(), b.getY(), c.getX(), c.getY());

        EuclideanLine2D bisectorBC = lineBC.getPerpendicular(midPointBC.getX(), midPointBC.getY());

        Point2D intersection = bisectorAC.getIntersection(bisectorBC);

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        return geomManager.createPoint(intersection.getX(), intersection.getY(), subtype);

    }

    /**

     * Gets midpoint of two points

     *

     * @param a

     *            Point one

     * @param b

     *            Point two

     * @param subtype

     *            of point created. See {@link Geometry.SUBTYPES}

     * @return Mid point of points.

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Point getMidPoint(Point a, Point b, int subtype)

            throws CreateGeometryException {

        double x = (a.getX() + b.getX()) / 2;

        double y = (a.getY() + b.getY()) / 2;

        return createPoint(x, y, subtype);

    }

    /**

     * Creates line as of two point coordinates.

     *

     * @param x1

     *            The X1 coordinate

     * @param y1

     *            The y1 coordinate

     * @param x2

     *            The X2 coordinate

     * @param y2

     *            The y2 coordinate

     * @param subtype

     *            of line. See {@link Geometry.SUBTYPES}

     * @return The Line created.

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Line createLine(double x1, double y1, double x2, double y2,

            int subtype) throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Line line = (Line) geomManager.create(Geometry.TYPES.CURVE, subtype);

        line.addVertex(x1, y1);

        line.addVertex(x2, y2);

        return line;

    }

    /**

     * Creates line as of two point objects.

     *

     * @param p1

     *            First point

     * @param p2

     *            Second point

     * @param subtype

     *            of line. See {@link Geometry.SUBTYPES}

     * @return The Line created.

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Line createLine(Point p1, Point p2, int subtype)

            throws CreateGeometryException {

        return createLine(p1.getX(), p1.getY(), p2.getX(), p2.getY(),

                subtype);

    }

    /**

     * Create Spline from point list

     *

     * @param points

     * @param subtype

     * @return

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     */

    public static Spline createSpline(List<Point> points, int subtype)

            throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Spline spline = (Spline) geomManager.create(Geometry.TYPES.SPLINE, subtype);

        points.forEach((point) -> {

            spline.addVertex(point);

        });

        return spline;

    }