Application: gvSIG desktop » gvSIG geoprocess

/*

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

 *

 * Copyright (C) 2010 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.

 */

package org.gvsig.sextante.app.algorithm.base.util;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.geom.GeometryLocator;

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

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

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

import org.gvsig.fmap.geom.operation.fromjts.FromJTS;

import org.gvsig.fmap.geom.operation.tojts.ToJTS;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Polygon;

import es.unex.sextante.core.Sextante;

public class GeometryUtil {

        private static GeometryFactory fact = new GeometryFactory();

        /**

         * Gets a JTS geometry from a DAL geometry

         * @param g

         * @return

         */

        public static Geometry geomToJTS(org.gvsig.fmap.geom.Geometry g) {

                try {

                        return (Geometry)g.invokeOperation(ToJTS.CODE, null);

                } catch (GeometryOperationNotSupportedException e1) {

                        Sextante.addErrorToLog(e1);

                } catch (GeometryOperationException e1) {

                        Sextante.addErrorToLog(e1);

                }

                return null;

        }

        /**

         * Gets a DAL geometry from a JTS geometry

         * @param g

         * @return

         */

        public static org.gvsig.fmap.geom.Geometry jtsToGeom(Geometry g) {

                GeometryOperationContext ctx = new GeometryOperationContext();

                ctx.setAttribute(FromJTS.PARAM, g);

                try {

                        return (org.gvsig.fmap.geom.Geometry)GeometryLocator.getGeometryManager().invokeOperation(FromJTS.NAME, ctx);

                } catch (GeometryOperationNotSupportedException e) {

                        Sextante.addErrorToLog(e);

                        return null;

                } catch (GeometryOperationException e) {

                        Sextante.addErrorToLog(e);

                        return null;

                }

        }

        /**

         * Joins the list of geometries

         * @param geometries

         * @param geometryType

         * @return

         */

        @SuppressWarnings("unchecked")

        public static Geometry geometryUnion(List geometries, int geometryType){

                Geometry[] geom = new Geometry[geometries.size()];

                geometries.toArray(geom);

                Geometry union = JTSFacade.union(geom, geometryType);

                return union;

        }

        public static Polygon removeDuplicates(Polygon polygon){

                LineString shell = polygon.getExteriorRing();

                LineString newShell = removeDuplicates(shell);

                LinearRing[] holes = new LinearRing[polygon.getNumInteriorRing()];

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

                        holes[i] = (LinearRing) polygon.getInteriorRingN(i);

                }

                Polygon newPolygon = fact.createPolygon((LinearRing) newShell, holes);

                return newPolygon;

        }

        public static MultiPolygon removeDuplicates(MultiPolygon multiPolygon){

                Polygon[] pols = new Polygon[multiPolygon.getNumGeometries()];

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

                        Polygon pol = (Polygon) multiPolygon.getGeometryN(i);

                        Polygon newPol = removeDuplicates(pol);

                        pols[i] = newPol;

                }

                return fact.createMultiPolygon(pols);

        }

        public static Geometry removeDuplicatesFrom(Geometry geometry){

                Geometry solution = null;

                if(geometry instanceof LineString)

                        solution = removeDuplicates((LineString)geometry);

                else if(geometry instanceof Polygon)

                        solution = removeDuplicates((Polygon) geometry);

                else if(geometry instanceof MultiPolygon)

                        solution = removeDuplicates((MultiPolygon) geometry);

                else

                        solution = geometry;

                return solution;

        }

        @SuppressWarnings("unchecked")

        public static LineString removeDuplicates(LineString line){

                ArrayList coordinates = new ArrayList();

                Coordinate prevCoord = null;

                Coordinate actualCoord = null;

                int numPoints = line.getNumPoints();

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

                        actualCoord = line.getCoordinateN(i);

                        if(prevCoord != null){

                                if(!prevCoord.equals2D(actualCoord)){

                                        coordinates.add(actualCoord);

                                }

                        }else{

                                coordinates.add(actualCoord);

                        }

                        prevCoord = actualCoord;

                }//for

                //llegados a este punto, construimos la nueva geometria

                Coordinate[] newCoord = new Coordinate[coordinates.size()];

                coordinates.toArray(newCoord);

                if(line instanceof LineString){

                        return fact.createLineString(newCoord);

                }else{

                        return fact.createLinearRing(newCoord);

                }

        }

}