Application: gvSIG desktop

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.jts.util;

import java.util.List;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateSequence;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.LineSegment;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.MultiLineString;

import com.vividsolutions.jts.geom.MultiPoint;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Triangle;

import com.vividsolutions.jts.util.GeometricShapeFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

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

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.jts.GeometryJTS;

import org.gvsig.fmap.geom.jts.MCoordinate;

import org.gvsig.fmap.geom.jts.aggregate.MultiLine2D;

import org.gvsig.fmap.geom.jts.aggregate.MultiLine2DM;

import org.gvsig.fmap.geom.jts.aggregate.MultiLine3D;

import org.gvsig.fmap.geom.jts.aggregate.MultiLine3DM;

import org.gvsig.fmap.geom.jts.aggregate.MultiPoint2D;

import org.gvsig.fmap.geom.jts.aggregate.MultiPoint2DM;

import org.gvsig.fmap.geom.jts.aggregate.MultiPoint3D;

import org.gvsig.fmap.geom.jts.aggregate.MultiPoint3DM;

import org.gvsig.fmap.geom.jts.aggregate.MultiPolygon2D;

import org.gvsig.fmap.geom.jts.aggregate.MultiPolygon2DM;

import org.gvsig.fmap.geom.jts.aggregate.MultiPolygon3D;

import org.gvsig.fmap.geom.jts.aggregate.MultiPolygon3DM;

import org.gvsig.fmap.geom.jts.primitive.curve.line.Line2D;

import org.gvsig.fmap.geom.jts.primitive.curve.line.Line2DM;

import org.gvsig.fmap.geom.jts.primitive.curve.line.Line3D;

import org.gvsig.fmap.geom.jts.primitive.curve.line.Line3DM;

import org.gvsig.fmap.geom.jts.primitive.point.Point2D;

import org.gvsig.fmap.geom.jts.primitive.point.Point2DM;

import org.gvsig.fmap.geom.jts.primitive.point.Point3D;

import org.gvsig.fmap.geom.jts.primitive.point.Point3DM;

import org.gvsig.fmap.geom.jts.primitive.point.PointJTS;

import org.gvsig.fmap.geom.jts.primitive.ring.Ring2D;

import org.gvsig.fmap.geom.jts.primitive.ring.Ring2DM;

import org.gvsig.fmap.geom.jts.primitive.ring.Ring3D;

import org.gvsig.fmap.geom.jts.primitive.ring.Ring3DM;

import org.gvsig.fmap.geom.jts.primitive.surface.polygon.Polygon2D;

import org.gvsig.fmap.geom.jts.primitive.surface.polygon.Polygon2DM;

import org.gvsig.fmap.geom.jts.primitive.surface.polygon.Polygon3D;

import org.gvsig.fmap.geom.jts.primitive.surface.polygon.Polygon3DM;

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

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

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

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

import org.gvsig.fmap.geom.type.GeometryType;

/**

 * @author fdiaz

 *

 */

public class JTSUtils {

    public static final Logger logger = LoggerFactory.getLogger(JTSUtils.class);

    public static final com.vividsolutions.jts.geom.GeometryFactory factory =

        new com.vividsolutions.jts.geom.GeometryFactory();

    public static Point createPoint(GeometryType type, Coordinate coordinate) throws CreateGeometryException {

        switch (type.getSubType()) {

        case Geometry.SUBTYPES.GEOM2D:

            return new Point2D(coordinate);

        case Geometry.SUBTYPES.GEOM2DM:

            return new Point2DM(coordinate);

        case Geometry.SUBTYPES.GEOM3D:

            return new Point3D(coordinate);

        case Geometry.SUBTYPES.GEOM3DM:

            return new Point3DM(coordinate);

        default:

            Point p = null;

            p = (Point) type.create();

            for (int i = 0; i < p.getDimension(); i++) {

                p.setCoordinateAt(i, coordinate.getOrdinate(i));

            }

            break;

        }

        return null;

    }

    public static LineString createJTSLineString(CoordinateSequence coordinates) {

        return factory.createLineString(coordinates);

    }

    public static LinearRing createJTSLinearRing(CoordinateSequence coordinates) {

        return factory.createLinearRing(coordinates);

    }

    public static MultiPoint createJTSMultiPoint(CoordinateSequence coordinates) {

        return factory.createMultiPoint(coordinates);

    }

    public static Geometry createGeometry(com.vividsolutions.jts.geom.Geometry jtsGeom) {

        if (jtsGeom instanceof com.vividsolutions.jts.geom.Point) {

            com.vividsolutions.jts.geom.Point point = (com.vividsolutions.jts.geom.Point)jtsGeom;

            Coordinate coordinate = jtsGeom.getCoordinate();

            if (coordinate instanceof MCoordinate) {

                if (Double.isNaN(coordinate.z)) {

                    return new Point2DM(coordinate);

                } else {

                    return new Point3DM(coordinate);

                }

            } else {

                if (Double.isNaN(coordinate.z)) {

                    return new Point2D(coordinate);

                } else {

                    return new Point3D(coordinate);

                }

            }

        }

        if (jtsGeom instanceof com.vividsolutions.jts.geom.LineString) {

            Coordinate[] coordinates = jtsGeom.getCoordinates();

            Coordinate coordinate = jtsGeom.getCoordinate();

            if (coordinate instanceof MCoordinate) {

                if (Double.isNaN(coordinate.z)) {

                    return new Line2DM(coordinates);

                } else {

                    return new Line3DM(coordinates);

                }

            } else {

                if (Double.isNaN(coordinate.z)) {

                    return new Line2D(coordinates);

                } else {

                    return new Line3D(coordinates);

                }

            }

        }

        if (jtsGeom instanceof com.vividsolutions.jts.geom.Polygon) {

            Polygon polygon;

            com.vividsolutions.jts.geom.Polygon polygonJTS = (com.vividsolutions.jts.geom.Polygon)jtsGeom;

            Coordinate[] coordinates = polygonJTS.getExteriorRing().getCoordinates();

            Coordinate coordinate = jtsGeom.getCoordinate();

            if (coordinate instanceof MCoordinate) {

                if (Double.isNaN(coordinate.z)) {

                    polygon = new Polygon2DM(coordinates);

                } else {

                    polygon = new Polygon3DM(coordinates);

                }

            } else {

                if (Double.isNaN(coordinate.z)) {

                    polygon = new Polygon2D(coordinates);

                } else {

                    polygon = new Polygon3D(coordinates);

                }

            }

            for(int i = 0; i<polygonJTS.getNumInteriorRing(); i++){

                LineString ringJTS = polygonJTS.getInteriorRingN(i);

                coordinates = ringJTS.getCoordinates();

                coordinate = ringJTS.getCoordinate();

                Ring ring;

                if (coordinate instanceof MCoordinate) {

                    if (Double.isNaN(coordinate.z)) {

                        ring = new Ring2DM(coordinates);

                    } else {

                        ring = new Ring3DM(coordinates);

                    }

                } else {

                    if (Double.isNaN(coordinate.z)) {

                        ring = new Ring2D(coordinates);

                    } else {

                        ring = new Ring3D(coordinates);

                    }

                }

                polygon.addInteriorRing(ring);

            }

            return polygon;

        }

        if (jtsGeom instanceof com.vividsolutions.jts.geom.GeometryCollection) {

            GeometryCollection collection = (com.vividsolutions.jts.geom.GeometryCollection)jtsGeom;

            Coordinate coordinate = collection.getCoordinate();

            MultiPrimitive multiprimitive = null;

            if (jtsGeom instanceof MultiLineString) {

                if (coordinate instanceof MCoordinate) {

                    if (Double.isNaN(coordinate.z)) {

                        multiprimitive = new MultiLine2DM();

                    } else {

                        multiprimitive = new MultiLine3DM();

                    }

                } else {

                    if (Double.isNaN(coordinate.z)) {

                        multiprimitive = new MultiLine2D();

                    } else {

                        multiprimitive = new MultiLine3D();

                    }

                }

            }

            if (jtsGeom instanceof MultiPolygon) {

                if (coordinate instanceof MCoordinate) {

                    if (Double.isNaN(coordinate.z)) {

                        multiprimitive = new MultiPolygon2DM();

                    } else {

                        multiprimitive = new MultiPolygon3DM();

                    }

                } else {

                    if (Double.isNaN(coordinate.z)) {

                        multiprimitive = new MultiPolygon2D();

                    } else {

                        multiprimitive = new MultiPolygon3D();

                    }

                }

            }

            if (jtsGeom instanceof MultiPoint) {

                if (coordinate instanceof MCoordinate) {

                    if (Double.isNaN(coordinate.z)) {

                        multiprimitive = new MultiPoint2DM();

                    } else {

                        multiprimitive = new MultiPoint3DM();

                    }

                } else {

                    if (Double.isNaN(coordinate.z)) {

                        multiprimitive = new MultiPoint2D();

                    } else {

                        multiprimitive = new MultiPoint3D();

                    }

                }

            }

            if (multiprimitive != null) {

                for (int i = 0; i < collection.getNumGeometries(); i++) {

                    com.vividsolutions.jts.geom.Geometry geometry = collection.getGeometryN(i);

                    multiprimitive.addPrimitive((Primitive) createGeometry(geometry));

                }

            }

            return multiprimitive;

        }

        return null;

    }

    /**

     * This function is called when the we need force types, that is the

     * destination

     * type does not match with the input geometry type

     *

     * @param g

     * @param sourceType

     * @param destinationType

     * @return

     */

    public static com.vividsolutions.jts.geom.Geometry convertTypes(com.vividsolutions.jts.geom.Geometry g,

        int sourceType, int destinationType) {

        if ((sourceType == Geometry.TYPES.CURVE || sourceType == Geometry.TYPES.SPLINE

            || sourceType == Geometry.TYPES.ARC || sourceType == Geometry.TYPES.ELLIPTICARC

            || sourceType == Geometry.TYPES.CIRCUMFERENCE || sourceType == Geometry.TYPES.PERIELLIPSE)

            && destinationType == Geometry.TYPES.MULTISURFACE) {

            if (g instanceof MultiLineString) {

                com.vividsolutions.jts.geom.Polygon[] poly = new com.vividsolutions.jts.geom.Polygon[((MultiLineString) g).getNumGeometries()];

                for (int i = 0; i < ((MultiLineString) g).getNumGeometries(); i++) {

                    com.vividsolutions.jts.geom.Geometry lineString = ((MultiLineString) g).getGeometryN(i);

                    poly[i] = convertLineStringToPolygon((LineString) lineString);

                }

                return factory.createMultiPolygon(poly);

            } else {

                return convertLineStringToPolygon((LineString) g);

            }

        }

        if ((sourceType == Geometry.TYPES.CIRCLE || sourceType == Geometry.TYPES.ELLIPSE

            || sourceType == Geometry.TYPES.ELLIPTICARC || sourceType == Geometry.TYPES.FILLEDSPLINE)

            && destinationType == Geometry.TYPES.MULTICURVE) {

            if (g instanceof com.vividsolutions.jts.geom.Polygon) {

                com.vividsolutions.jts.geom.Polygon poly = (com.vividsolutions.jts.geom.Polygon) g;

                LineString lineString = factory.createLinearRing(poly.getCoordinates());

                return factory.createMultiLineString(new LineString[] { lineString });

            }

        }

        return g;

    }

    private static com.vividsolutions.jts.geom.Polygon convertLineStringToPolygon(LineString line) {

        Coordinate[] coordinates = line.getCoordinates();

        LinearRing shell = factory.createLinearRing(coordinates);

        com.vividsolutions.jts.geom.Polygon pol = factory.createPolygon(shell, null);

        return pol;

    }

    public static MCoordinate createMCoordinate(double x, double y, double m) {

        return MCoordinate.create2dWithMeasure(x, y, m);

    }

    public static MCoordinate createMCoordinate(double x, double y, double z, double m) {

        return MCoordinate.create3dWithMeasure(x, y, z, m);

    }

    /**

     * @param init

     * @param middle

     * @param end

     * @return

     */

    public static Coordinate getCircumcentre(Point init, Point middle, Point end) {

        Triangle triangle =

            new Triangle(((PointJTS) init).getJTSCoordinate(),

                ((PointJTS) middle).getJTSCoordinate(),

                ((PointJTS) end).getJTSCoordinate());

        return triangle.circumcentre();

    }

    public static LineString createJTSLineStringFromArcPoints(Point centre, double radius, double startAngle, double endAngle){

        GeometricShapeFactory shapeFactory = new GeometricShapeFactory();

        shapeFactory.setCentre(((PointJTS)centre).getJTSCoordinate());

        shapeFactory.setSize(radius*2);

        return shapeFactory.createArc(startAngle, endAngle);

    }

    public static MultiLineString createJTSMultiLineString(LineString[] lineStrings) {

        return factory.createMultiLineString(lineStrings);

    }

    /**

     * @param coordinates

     * @param interiorRings

     * @return

     * @throws GeometryException

     */

    public static com.vividsolutions.jts.geom.Polygon createJTSPolygon(ArrayListCoordinateSequence coordinates,

        List<Ring> interiorRings) {

        LinearRing shell = factory.createLinearRing(coordinates);

        LinearRing[] holes = new LinearRing[interiorRings.size()];

        for(int i=0; i<interiorRings.size(); i++){

            Ring ring = interiorRings.get(i);

            holes[i] = (LinearRing) ((GeometryJTS) ring).getJTS();

        }

        return factory.createPolygon(shell, holes);

    }

    /**

     * @param coordinates

     * @return

     * @throws GeometryException

     */

    public static com.vividsolutions.jts.geom.Polygon createJTSPolygon(ArrayListCoordinateSequence coordinates) {

        LinearRing shell = factory.createLinearRing(coordinates);

        return factory.createPolygon(shell);

    }

    public static com.vividsolutions.jts.geom.MultiPolygon createJTSMultiPolygon(com.vividsolutions.jts.geom.Polygon[] polygons){

        return factory.createMultiPolygon(polygons);

    }

    /**

     * Returns the intersection point between an ellipse and her minor axis.

     *

     * @param init

     * @param middle

     * @param end

     * @return

     */

    public static Coordinate getPointAtYAxisInEllipse(Point init, Point end, Double ydist) {

        LineSegment segment = new LineSegment(((PointJTS) init).getJTSCoordinate(),

            ((PointJTS) end).getJTSCoordinate());

        Coordinate middle = segment.midPoint();

        LineSegment midSegment = new LineSegment(middle, ((PointJTS) end).getJTSCoordinate());

        double modulus = midSegment.getLength();

        //Mayor semi-axis unitary vector

        Coordinate uni = new Coordinate((end.getX()-middle.x)/modulus, (end.getY()-middle.y)/modulus);

        //Minor axis unitary vector

        Coordinate perpUni = new Coordinate(-uni.y,uni.x);

        Coordinate point = new Coordinate(middle.x+(perpUni.x*ydist), middle.y+(perpUni.y*ydist));

        return point;

    }

    /**

     * Returns the middle point between two points.

     *

     * @param init

     * @param middle

     * @param end

     * @return

     */

    public static Coordinate getMidPoint(Point init, Point end) {

        LineSegment segment = new LineSegment(((PointJTS) init).getJTSCoordinate(),

            ((PointJTS) end).getJTSCoordinate());

        Coordinate middle = segment.midPoint();

        return middle;

    }

}