Application: gvSIG desktop

/*

 * Created on 18-sep-2007

 *

 * gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

 *

 * $Id: JtsUtil.java 19632 2008-03-16 12:42:28Z azabala $

 * $Log: JtsUtil.java,v $

 * Revision 1.1  2007/09/19 09:01:20  azabala

 * first version in cvs

 *

 *

 */

package org.gvsig.jts;

import java.awt.geom.Point2D;

import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.core.NewFConverter;

import com.iver.cit.gvsig.fmap.core.FGeometry;

import com.iver.cit.gvsig.fmap.core.FGeometryCollection;

import com.iver.cit.gvsig.fmap.core.FMultiPoint2D;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.vividsolutions.jts.algorithms.SnapCGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateSequence;

import com.vividsolutions.jts.geom.CoordinateSequences;

import com.vividsolutions.jts.geom.Envelope;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.GeometryFactory;

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

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.geom.PrecisionModel;

import com.vividsolutions.jts.geomgraph.Edge;

import com.vividsolutions.jts.geomgraph.EdgeIntersectionList;

import com.vividsolutions.jts.geomgraph.GeometryGraph;

/**

 * Utility methods for JTS library use.

 * 

 * @author azabala

 * 

 */

public class JtsUtil {

        //FIXME PrecionModel's scale should be configurable by a JTS preferences

        //dialog

        public static final PrecisionModel GVSIG_PRECISION_MODEL = 

                new PrecisionModel(10000);

        public static final GeometryFactory GEOMETRY_FACTORY = 

                new GeometryFactory(GVSIG_PRECISION_MODEL);

        public static Geometry createGeometry(Coordinate[] coords,

                        String geometryType) {

                if (geometryType.equalsIgnoreCase("POINT")) {

                        return GEOMETRY_FACTORY.createPoint(coords[0]);

                } else if (geometryType.equalsIgnoreCase("LINESTRING")) {

                        return GEOMETRY_FACTORY.createLineString(coords);

                } else if (geometryType.equalsIgnoreCase("LINEARRING")) {

                        return GEOMETRY_FACTORY.createLinearRing(coords);

                }

                // else if (geometryType.equalsIgnoreCase("POLYGON")) {

                // // LinearRing exterior = geomFactory.createLinearRing(coords);

                // // return geomFactory.createPolygon(exterior, null);

                // }

                else if (geometryType.equalsIgnoreCase("MULTIPOINT")) {

                        return GEOMETRY_FACTORY.createMultiPoint(coords);

                }

                return null;

        }

        public static Polygon createPolygon(Coordinate[] coords, int[] indexOfParts) {

                int numberOfHoles = indexOfParts.length - 1;

                int firstPointOfShell = 0;

                int lastPointOfShell;

                if (numberOfHoles == 0) {

                        lastPointOfShell = coords.length - 1;

                } else {

                        lastPointOfShell = indexOfParts[1] - 1;

                }

                Coordinate[] shellCoords = new Coordinate[lastPointOfShell

                                - firstPointOfShell + 1];

                System.arraycopy(coords, firstPointOfShell, shellCoords, 0,

                                shellCoords.length);

                LinearRing shell = GEOMETRY_FACTORY.createLinearRing(shellCoords);

                LinearRing[] holes = null;

                if (numberOfHoles > 0) {

                        holes = new LinearRing[numberOfHoles];

                        int firstPointOfHole, lastPointOfHole;

                        Coordinate[] holeCoords;

                        for (int i = 1; i < indexOfParts.length - 1; i++) {

                                firstPointOfHole = indexOfParts[i];

                                lastPointOfHole = indexOfParts[i + 1] - 1;

                                holeCoords = new Coordinate[lastPointOfHole - firstPointOfHole

                                                + 1];

                                System.arraycopy(coords, firstPointOfHole, holeCoords, 0,

                                                holeCoords.length);

                                holes[i - 1] = GEOMETRY_FACTORY.createLinearRing(holeCoords);

                        }

                        firstPointOfHole = indexOfParts[indexOfParts.length - 1];

                        lastPointOfHole = coords.length - 1;

                        holeCoords = new Coordinate[lastPointOfHole - firstPointOfHole + 1];

                        System.arraycopy(coords, firstPointOfHole, holeCoords, 0,

                                        holeCoords.length);

                        holes[holes.length - 1] = GEOMETRY_FACTORY.createLinearRing(holeCoords);

                }

                return GEOMETRY_FACTORY.createPolygon(shell, holes);

        }

        /**

         * Returns an array of lenght equals to the number of parts of a polygon.

         * Each member of the array has a 'pointer' to the first point of each part

         * in the coordinates array of the polygon.

         * 

         * 

         * @param polygon

         * @see createPolygon(Coordinate[] coords, int[] indexOfParts)

         * @return

         */

        public static int[] getIndexOfParts(Polygon polygon) {

                int numParts = polygon.getNumInteriorRing() + 1;

                int[] indexOfParts = new int[numParts];

                indexOfParts[0] = 0;

                if (numParts > 1) {

                        indexOfParts[1] = polygon.getExteriorRing().getNumPoints();

                }

                if (numParts > 2) {

                        for (int i = 1; i < polygon.getNumInteriorRing(); i++) {

                                indexOfParts[i + 1] = indexOfParts[i]

                                                + polygon.getInteriorRingN(i).getNumPoints() + 1;

                        }

                }

                return indexOfParts;

        }

        public static MultiLineString convertToMultiLineString(GeometryCollection geomCol){

                List<LineString> lines = new ArrayList<LineString>();

                int numGeometries = geomCol.getNumGeometries();

                for (int i = 0; i < numGeometries; i++) {

                        Geometry geom = geomCol.getGeometryN(i);

                        if (geom instanceof LineString)

                                lines.add((LineString) geom);

                        else if (geom instanceof MultiLineString) {

                                MultiLineString multiLine = (MultiLineString) geom;

                                int numLines = multiLine.getNumGeometries();

                                for (int j = 0; j < numLines; j++) {

                                        lines.add((LineString) multiLine.getGeometryN(j));

                                }// j

                        }// else

                        else if (geom instanceof GeometryCollection) {

                                MultiLineString multiLine = convertToMultiLineString((GeometryCollection) geom);

                                int numLines = multiLine.getNumGeometries();

                                for (int j = 0; j < numLines; j++) {

                                        lines.add((LineString) multiLine.getGeometryN(j));

                                }// j

                        }// else

                }// for i

                LineString[] lineArray = new LineString[lines.size()];

                lines.toArray(lineArray);

                return GEOMETRY_FACTORY.createMultiLineString(lineArray);

        }

        public static MultiPolygon convertToMultiPolygon(GeometryCollection geomCol) {

                List<Polygon> polygons = new ArrayList<Polygon>();

                int numGeometries = geomCol.getNumGeometries();

                for (int i = 0; i < numGeometries; i++) {

                        Geometry geom = geomCol.getGeometryN(i);

                        if (geom instanceof Polygon)

                                polygons.add((Polygon) geom);

                        else if (geom instanceof MultiPolygon) {

                                MultiPolygon multiPol = (MultiPolygon) geom;

                                int numPols = multiPol.getNumGeometries();

                                for (int j = 0; j < numPols; j++) {

                                        polygons.add((Polygon) multiPol.getGeometryN(j));

                                }// j

                        }// else

                        else if (geom instanceof GeometryCollection) {

                                MultiPolygon multiPol = convertToMultiPolygon((GeometryCollection) geom);

                                int numPols = multiPol.getNumGeometries();

                                for (int j = 0; j < numPols; j++) {

                                        polygons.add((Polygon) multiPol.getGeometryN(j));

                                }// j

                        }// else

                }// for i

                Polygon[] polyArray = new Polygon[polygons.size()];

                polygons.toArray(polyArray);

                return GEOMETRY_FACTORY.createMultiPolygon(polyArray);

        }

        public static boolean isClosed(Geometry geom) {

                return isClosed(geom, 0d);

        }

        public static Geometry getGeometryToClose(Geometry geom,

                        double snapTolerance) {

                if ((geom instanceof Point) || (geom instanceof MultiPoint))

                        return null;

                else if (geom instanceof GeometryCollection) {

                        GeometryCollection solution = null;

                        List<Geometry> solutionGeoms = new ArrayList<Geometry>();

                        GeometryCollection geomCol = (GeometryCollection) geom;

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

                                Geometry tempGeom = geomCol.getGeometryN(i);

                                Geometry geo2close = getGeometryToClose(tempGeom, snapTolerance);

                                solutionGeoms.add(geo2close);

                        }

                        Geometry[] solutionG = GeometryFactory

                                        .toGeometryArray(solutionGeoms);

                        solution = GEOMETRY_FACTORY.createGeometryCollection(solutionG);

                        return solution;

                } else if (geom instanceof LineString) {

                        LineString solution = null;

                        LineString tempGeom = (LineString) geom;

                        Coordinate start = tempGeom.getCoordinateN(0);

                        Coordinate end = tempGeom

                                        .getCoordinateN(tempGeom.getNumPoints() - 1);

                        if (!SnapCGAlgorithms.snapEquals2D(start, end, snapTolerance)) {

                                Coordinate[] coordinates = { start, end };

                                solution = GEOMETRY_FACTORY.createLineString(coordinates);

                        }

                        return solution;

                } else if (geom instanceof Polygon) {

                        GeometryCollection solution = null;

                        List<Geometry> solutionGeoms = new ArrayList<Geometry>();

                        Polygon polygon = (Polygon) geom;

                        LineString ring = polygon.getExteriorRing();

                        Geometry ring2close = getGeometryToClose(ring, snapTolerance);

                        if (ring2close != null)

                                solutionGeoms.add(ring2close);

                        // TODO Must we check all polygon rings, or only exterior ring?

                        int numHoles = polygon.getNumInteriorRing();

                        for (int i = 0; i < numHoles; i++) {

                                LineString hole = polygon.getInteriorRingN(i);

                                Geometry hole2close = getGeometryToClose(hole, snapTolerance);

                                if (hole != null)

                                        solutionGeoms.add(hole2close);

                        }

                        Geometry[] solutionArray = GeometryFactory

                                        .toGeometryArray(solutionGeoms);

                        if (solutionArray.length > 0)

                                solution = GEOMETRY_FACTORY.createGeometryCollection(solutionArray);

                        return solution;

                }// else

                return null;

        }

        public static boolean isClosed(Geometry geom, double snapTolerance) {

                if ((geom instanceof Point) || (geom instanceof MultiPoint))

                        return false;

                else if (geom instanceof GeometryCollection) {

                        GeometryCollection geomCol = (GeometryCollection) geom;

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

                                Geometry tempGeom = geomCol.getGeometryN(i);

                                if (!isClosed(tempGeom, snapTolerance))

                                        return false;

                        }

                        return true;

                } else if (geom instanceof LineString) {

                        LineString tempGeom = (LineString) geom;

                        return SnapCGAlgorithms.snapEquals2D(tempGeom.getCoordinateN(0),

                                        tempGeom.getCoordinateN(tempGeom.getNumPoints() - 1),

                                        snapTolerance);

                } else if (geom instanceof Polygon) {

                        Polygon polygon = (Polygon) geom;

                        LineString ring = polygon.getExteriorRing();

                        if (!isClosed(ring, snapTolerance))

                                return false;

                        // TODO Must we check all polygon rings, or only exterior ring?

                        int numHoles = polygon.getNumInteriorRing();

                        for (int i = 0; i < numHoles; i++) {

                                LineString hole = polygon.getInteriorRingN(i);

                                if (!isClosed(hole, snapTolerance))

                                        return false;

                        }

                        return true;

                }// else

                return false;

        }

        public static Coordinate[] getPoint2DAsCoordinates(Point2D[] point2d) {

                Coordinate[] solution = new Coordinate[point2d.length];

                for (int i = 0; i < point2d.length; i++) {

                        solution[i] = new Coordinate(point2d[i].getX(), point2d[i].getY());

                }

                return solution;

        }

        // TODO Quitar esto de FConverter, llevarlo a JtsUtil, y PROPONER LA

        // CREACION DE UN

        // PAQUETE JTS EN FMAP

        public static boolean pointInList(Coordinate testPoint,

                        Coordinate[] pointList) {

                return pointInList(testPoint, pointList, 0d);

        }

        public static boolean pointInList(Coordinate testPoint,

                        Coordinate[] pointList, double snapTolerance) {

                int t;

                int numpoints;

                Coordinate p;

                numpoints = Array.getLength(pointList);

                for (t = 0; t < numpoints; t++) {

                        p = pointList[t];

                        if (SnapCGAlgorithms.snapEquals2D(p, testPoint, snapTolerance))

                                return true;

                }

                return false;

        }

        public static Coordinate findPtNotNode(Coordinate[] testCoords,

                        LinearRing searchRing, GeometryGraph graph) {

                // find edge corresponding to searchRing.

                Edge searchEdge = graph.findEdge(searchRing);

                // find a point in the testCoords which is not a node of the searchRing

                EdgeIntersectionList eiList = searchEdge.getEdgeIntersectionList();

                // somewhat inefficient - is there a better way? (Use a node map, for

                // instance?)

                for (int i = 0; i < testCoords.length; i++) {

                        Coordinate pt = testCoords[i];

                        if (!eiList.isIntersection(pt))

                                return pt;

                }

                return null;

        }

        /**

         * This method is needed because call to LinearRing.reverse returns a

         * LineString,

         * 

         * @param ring

         * @return

         */

        public static LinearRing reverse(LinearRing ring) {

                CoordinateSequence seq = ring.getCoordinateSequence();

                CoordinateSequences.reverse(seq);

                LinearRing solution = GEOMETRY_FACTORY.createLinearRing(seq);

                return solution;

        }

        public static Geometry toJtsGeometry(IGeometry fmapGeometry) {

                Geometry solution = null;

                if (fmapGeometry instanceof FGeometry) {

                        FShape shp = (FShape) ((FGeometry) fmapGeometry).getInternalShape();

                        solution = NewFConverter.java2d_to_jts(shp);

                } else if (fmapGeometry instanceof FGeometryCollection) {

                        IGeometry[] geometries = ((FGeometryCollection) fmapGeometry)

                                        .getGeometries();

                        Geometry[] theGeoms = new Geometry[geometries.length];

                        for (int i = 0; i < geometries.length; i++) {

                                theGeoms[i] = ((IGeometry) geometries[i]).toJTSGeometry();

                        }

                        solution = GEOMETRY_FACTORY.createGeometryCollection(theGeoms);

                } else if (fmapGeometry instanceof FMultiPoint2D) {

                        solution = ((FMultiPoint2D) fmapGeometry).toJTSGeometry();

                }

                return solution;

        }

        public static Envelope toSnapRectangle(Coordinate coord, double snapTolerance){

                Envelope solution = null;

                double xmin = coord.x - snapTolerance;

                double xmax = coord.x + snapTolerance;

                double ymin = coord.y - snapTolerance;

                double ymax = coord.y + snapTolerance;

                solution = new Envelope(xmin, xmax, ymin, ymax);

                return solution;

        }

}