| gvSIG desktop 1

/*

 * Created on 07-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: 

 * $Log: 

 *

 */

package org.gvsig.jts;

import java.util.ArrayList;

import java.util.List;

import com.iver.cit.gvsig.util.SnappingCoordinateMap;

import com.vividsolutions.jts.algorithms.SnapCGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateList;

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

import com.vividsolutions.jts.geom.Polygon;

/**

 * Moves coordinates of geometries (in a given tolerance) 

 * to force them to coincide with coordinates of other geometries 

 * in its proximity (the snap tolerance).

 * 

 * Also, it could normalize coordinates of the same geometry. By normalize

 * we mean to force the coherence of isClosed method and coordinates.

 * (for example, LINESTRING(100 100, 200 100, 200 200, 100 200, 100 100.01)

 *  return 'true' to isClosed call. After normalize the last coordinate

 *  will be (100 100))

 * 

 */

public class GeometrySnapper {

        private double snapTolerance;

        private GeometryFactory geomFactory = new GeometryFactory();

        public GeometrySnapper(double snapTolerance) {

                this.snapTolerance = snapTolerance;

        }

        /**

         * Utility class for compute coordinate average

         * */

        class SnapCoordinate {

                int weight;

                Coordinate coordinate;

        }

        /**

         * Snaps the coordinates of many geometries with the same weight

         * (all coordinates must move)

         * @param geoms

         * @return

         */

        public Geometry[] snap(Geometry[] geoms){

                int weight[] = new int[geoms.length];

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

                        weight[i] = 1;

                }

                return snap(geoms, weight);

        }

        /**

         * Snaps all the coordinates of the given geometries

         * .

         * If many coords are in the same distance tolerance radius, it applies a weighted

         * average. If one geometry's weight is 0, it wont participate in the average.

         * 

         * @param geoms geometries whose coordinates we want to snap

         * @param weights weight of each geometry in the computation of the weighted average

         * 

         * */

        public Geometry[] snap(Geometry[] geoms, int[] weights) {

                SnappingCoordinateMap coordinateMap = new SnappingCoordinateMap(snapTolerance);

                Geometry[] solution = new Geometry[geoms.length];

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

                        Geometry geom = geoms[i];

                        Coordinate[] coords = geom.getCoordinates();

                        CoordinateList coordList = new CoordinateList(coords);

                        for(int j = 0; j < coords.length; j++){

                                Coordinate coord = coords[j];

                                Coordinate existingSolution = (Coordinate) coordinateMap.get(coord);

                                if(coordinateMap.get(coord) != null){//this coordinate has already been snapped

                                        coordList.set(j, existingSolution);

                                        continue;

                                }

                                ArrayList coordsToSnap = new ArrayList();

                                SnapCoordinate snapCoord = new SnapCoordinate();

                                snapCoord.weight = weights[i];

                                snapCoord.coordinate = coord;

                                coordsToSnap.add(snapCoord);

                                for (int k = 0; k < geoms.length; k++){

                                        Geometry geom2 = geoms[k];

                                        if(i == k)

                                                continue;

                                        Coordinate[] coords2 = geom2.getCoordinates();

                                        for( int z = 0; z < coords2.length; z++){

                                                Coordinate coord2 = coords2[z];

                                                if(SnapCGAlgorithms.snapEquals2D(coord, coord2, snapTolerance)){

                                                        snapCoord = new SnapCoordinate();

                                                        snapCoord.weight = weights[k];

                                                        snapCoord.coordinate = coord2;

                                                        coordsToSnap.add(snapCoord);

                                                }//if

                                        }//for z

                                }//for k

                                Coordinate newCoord = snapAverage(coordsToSnap);

                                coordList.set(j, newCoord);

                                coordinateMap.put(newCoord, newCoord);

                        }//for j

                        Coordinate[] newPts = coordList.toCoordinateArray();

                        solution[i] = createGeometry(newPts, geom);

                }//for i

                return solution;

        }

        /**

         * Creates a geometry of the same type as geom with newPts coordinates.

         * geom mustn be a GeometryCollection (MultiPolygon, etc.)

         * @param newPts

         * @param geom

         * @return

         */

        //TODO See how to manage the snap of polygon holes

        private Geometry createGeometry(Coordinate[] newPts, Geometry geom) {

                Geometry solution = null;

                if(geom instanceof Point){

                        if(newPts.length == 1)

                                return geomFactory.createPoint(newPts[0]);

                        else{

                                solution = geomFactory.createMultiPoint(newPts);

                        }

                }else if(geom instanceof LineString){

                        solution = geomFactory.createLineString(newPts);

                }else if(geom instanceof Polygon){

                        LinearRing linearRing = geomFactory.createLinearRing(newPts);

                        solution =  geomFactory.createPolygon(linearRing, null);

                }

                return solution;

        }

        public Coordinate snapAverage(List coordinates, int[] weights){

                List snapList = new ArrayList();

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

                        Coordinate coord = (Coordinate) coordinates.get(i);

                        int weight = weights[i];

                        SnapCoordinate snap = new SnapCoordinate();

                        snap.weight = weight;

                        snap.coordinate = coord;

                        snapList.add(snap);

                }

                return snapAverage(snapList);

        }

        private Coordinate snapAverage(List coordsToSnap){

                if(coordsToSnap.size() == 1)

                {

                        return ((SnapCoordinate)coordsToSnap.get(0)).coordinate;

                }

                double sumX = 0d;

                double sumY = 0d;

                double sumW = 0d;

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

                        SnapCoordinate snapCoord = (SnapCoordinate) coordsToSnap.get(i);

                        Coordinate coord = snapCoord.coordinate;

                        int weight = snapCoord.weight;

                        if(weight == 0)

                                continue;

                        double weightD = 1d / (double)weight;

                        sumX += weightD * coord.x;

                        sumY += weightD * coord.y;

                        sumW += weightD;

                }

                double newX = sumX / sumW;

                double newY = sumY / sumW;

                return new Coordinate(newX, newY);

        }

        public boolean isClosed(Geometry a) {

                Coordinate[] coords = a.getCoordinates();

                Coordinate firstPoint = coords[0];

                Coordinate lastPoint = coords[coords.length - 1];

                return SnapCGAlgorithms.snapEquals2D(firstPoint, lastPoint,

                                snapTolerance);

        }

        /**

         * If geometry 'a' is not exactly closed, but its extremes are 

         * in a snap radius, its snap the last point to the first point of the

         * geometry

         * @param a

         * @return

         */

        public Geometry normalizeExtremes(Geometry a){

                Coordinate[] coords = a.getCoordinates();

                Coordinate firstPoint = coords[0];

                Coordinate lastPoint = coords[coords.length - 1];

                if(!firstPoint.equals2D(lastPoint) && isClosed(a)){

                    CoordinateList coordList = new CoordinateList(coords);

                    coordList.set(coords.length - 1, coords[0]);

                    return createGeometry(coordList.toCoordinateArray(), a);

                }else

                        return a;

        }

        public static boolean isClosed(Geometry a, double snap){

                Coordinate[] coords = a.getCoordinates();

                Coordinate firstPoint = coords[0];

                Coordinate lastPoint = coords[coords.length - 1];

                return SnapCGAlgorithms.snapEquals2D(firstPoint, lastPoint, snap);

        }

        /**

         * Snaps coordinates in srcPts with coordinates of snapPts.

         * This method forces the snap: the points of srcPoints are shifted to

         * snap with points in snapPts. No average is computed for coordinates.

         * @param srcPts

         * @param isClosed

         * @param snapPts

         * @return

         */

        private Coordinate[] snapTo(Coordinate[] srcPts, 

                                                        boolean isClosed,

                                                        Coordinate[] snapPts) {

                CoordinateList coordList = new CoordinateList(srcPts);

                int coordinateCount = coordList.size();

                if(isClosed)

                        coordinateCount --;

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

                        Coordinate srcPt = (Coordinate) coordList.get(i);

                        Coordinate snapVert = findSnapForVertex(srcPt, snapPts);

                        if (snapVert != null) {

                                coordList.set(i, new Coordinate(snapVert));

                                if (i == 0 && isClosed)

                                        coordList.set(coordList.size() - 1,

                                                                new Coordinate(snapVert));

                        }//if

                }//for

                Coordinate[] newPts = coordList.toCoordinateArray();

                return newPts;

        }

        private Coordinate findSnapForVertex(Coordinate pt, Coordinate[] snapPts) {

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

                        if (pt.equals2D(snapPts[i]))

                                return null;

                        if(SnapCGAlgorithms.snapEquals2D(pt, snapPts[i], snapTolerance)){

                                return snapPts[i];

                        }

                }

                return null;

        }

}