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.utils;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateSequence;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.MultiLineString;

import com.vividsolutions.jts.geom.Polygon;

import org.gvsig.fmap.geom.Geometry;

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

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

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.primitive.Point;

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

/**

 * @author fdiaz

 *

 */

public class JTSUtils {

    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 Polygon createJTSPolygon(CoordinateSequence coordinates){

        return factory.createPolygon(coordinates);

    }

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

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

            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){

        }

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

        }

        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)

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

            if (g instanceof MultiLineString) {

                Polygon[] poly = new 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)

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

            if (g instanceof Polygon) {

                Polygon poly = (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);

        Polygon pol = factory.createPolygon(shell, null);

        return pol;

    }

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

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

    }

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

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

    }

}