| gvSIG desktop 1

/*

 * Created on 10-abr-2006

 *

 * 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.voronoi;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.gvsig.exceptions.BaseException;

import org.gvsig.jts.JtsUtil;

import org.gvsig.topology.Messages;

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

import com.iver.utiles.swing.threads.CancellableProgressTask;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Envelope;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.operation.polygonize.Polygonizer;

/**

 * Computes voronois diagrams from a mess of points.

 * 

 * 

 * @author Alvaro Zabala

 * 

 */

public class Voronoier {

        public interface VoronoiStrategy {

                public List<IFeature> createThiessenPolygons(VoronoiAndTinInputLyr inputLyr, boolean onlySelection, CancellableProgressTask progressMonitor) throws BaseException;

                public List<IFeature> createThiessenPolygons(VoronoiAndTinInputLyr inputLyr, boolean onlySelection) throws BaseException;

                public List<IFeature> createTin(VoronoiAndTinInputLyr inputLyr, boolean onlySelection) throws BaseException;

                public List<IFeature> createTin(VoronoiAndTinInputLyr inputLyr, boolean onlySelection, CancellableProgressTask progressMonitor) throws BaseException;

        }

        private static final Map<String, VoronoiStrategy> strategies =

                new HashMap<String, VoronoiStrategy>();

        static{

                strategies.put("CHEN", new ChenVoronoiStrategy());

                strategies.put("CHEW", new ChewVoronoiStrategy());

                strategies.put("DT", new IncrementalTinVoronoiStrategy());

        }

        public static List<IFeature> createThiessen(VoronoiAndTinInputLyr inputLyr, boolean onlySelection, String strategyStr, CancellableProgressTask progressMonitor) throws BaseException{

                VoronoiStrategy strategy = strategies.get(strategyStr);

                return strategy.createThiessenPolygons(inputLyr, onlySelection, progressMonitor);

        }

        public static List<IFeature> createThiessen(VoronoiAndTinInputLyr inputLyr, boolean onlySelection, String strategy) throws BaseException{

                return createThiessen(inputLyr, onlySelection, strategy, null);

        }

        public static List<IFeature> createTIN(VoronoiAndTinInputLyr inputLyr, boolean onlySelection, String strategy) throws BaseException{

                return createTIN(inputLyr, onlySelection, strategy, null);

        }

        public static List<IFeature> createTIN(VoronoiAndTinInputLyr inputLyr, boolean onlySelection, String strategyStr, CancellableProgressTask progressMonitor) throws BaseException{

                VoronoiStrategy strategy = strategies.get(strategyStr);

                return strategy.createTin(inputLyr, onlySelection, progressMonitor);

        }

        /**

         * Returns thiessen polygons associated to a tin

         * 

         * (tin and thiessen polygons are a dual)

         * @param edges

         * @param progressMonitor

         * @return

         */

        //TODO 

        /*

         * Para facilitar la reusabilidad, pasar un ThiessenVisitor como parametro, y hacerlo 

         * void. As? podemos devolver List<Geometry> o List<IGeometry> o List<IFeature>

         */

        public static List<Geometry> getThiessenPolygons(List<Geometry> edges, 

                                                                                CancellableProgressTask progressMonitor){

                // -- do union of all edges and use the polygonizer to create polygons

                // from it

                Geometry lines = null;

                Geometry mls = (Geometry) edges.get(0);

                if (progressMonitor != null) {

                        progressMonitor.setInitialStep(0);

                        int numOfSteps = edges.size();

                        progressMonitor.setFinalStep(numOfSteps);

                        progressMonitor.setDeterminatedProcess(true);

                        progressMonitor.setNote(Messages

                                        .getText("topology_clean_of_thiessen_edges"));

                        progressMonitor.setStatusMessage(Messages

                                        .getText("voronoi_diagram_layer_message"));

                        progressMonitor.reportStep();

                }

                for (int i = 1; i < edges.size(); i++) {

                        Geometry line = (Geometry) edges.get(i);

                        mls = mls.union(line);

                        if (progressMonitor != null)

                                progressMonitor.reportStep();

                }

                lines = mls;

                Polygonizer poly = new Polygonizer();

                poly.add(lines);

                Collection polys = poly.getPolygons();

                // -- get final polygons in bounding box (=intersection polygons with

                // the bbox)

                Envelope envelope = JtsUtil.getBoundingBox(edges);

                GeometryFactory gf = JtsUtil.GEOMETRY_FACTORY;

                double xmin = envelope.getMinX();

                double ymin = envelope.getMinY();

                double dx = envelope.getWidth();

                double dy = envelope.getHeight();

                xmin = xmin - (1.5 * dx);

                ymin = ymin - dy;

                Coordinate[] coords = new Coordinate[5];

                coords[0] = new Coordinate(xmin + 1 * dx,

                                                                        ymin + 0.5 * dy); // lowerleft

                coords[1] = new Coordinate(xmin + 3 * dx,

                                                   ymin + 0.5 * dy); // lowerright

                coords[2] = new Coordinate(xmin + 3 * dx,

                                                                        ymin + 2.5 * dy); // topright

                coords[3] = new Coordinate(xmin + 1 * dx,

                                                                        ymin + 2.5 * dy); // topleft

                // -- to close linestring

                coords[4] = new Coordinate(xmin + 1 * dx,

                                                                ymin + 0.5 * dy); // lowerleft

                LinearRing lr = gf.createLinearRing(coords);

                Geometry bbox = gf.createPolygon(lr, null);

                if (progressMonitor != null) {

                        progressMonitor.setInitialStep(0);

                        int numOfSteps = polys.size();

                        progressMonitor.setFinalStep(numOfSteps);

                        progressMonitor.setDeterminatedProcess(true);

                        progressMonitor.setNote(Messages

                                        .getText("computing_thiessen_polygons"));

                        progressMonitor.setStatusMessage(Messages

                                        .getText("voronoi_diagram_layer_message"));

                }

                ArrayList<Geometry> finalPolys = new ArrayList<Geometry>();

                for (Iterator iter = polys.iterator(); iter.hasNext();) {

                        Geometry candPoly = (Geometry) iter.next();

                        Geometry intersection = bbox.intersection(candPoly);

                        if (progressMonitor != null)

                                progressMonitor.reportStep();

                        if (intersection != null) {

                                if (intersection.getArea() > 0) {

                                        finalPolys.add(intersection);

                                }

                        }

                }

                if (progressMonitor != null)

                        progressMonitor.reportStep();

                return finalPolys;

        }

}