| 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.topology.topologyrules;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.core.FGeometryUtil;

import org.gvsig.jts.JtsUtil;

import org.gvsig.jts.SnapLineStringSelfIntersectionChecker;

import org.gvsig.topology.AbstractTopologyRule;

import org.gvsig.topology.IRuleWithClusterTolerance;

import org.gvsig.topology.Messages;

import org.gvsig.topology.Topology;

import org.gvsig.topology.TopologyError;

import org.gvsig.topology.TopologyRuleDefinitionException;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

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

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

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

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

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Polygon;

/**

 * The polygons of a layer must not have self intersections

 * 

 */

public class PolygonMustNotSelfIntersect extends AbstractTopologyRule implements

                IRuleWithClusterTolerance {

        private static String ruleName = Messages

                        .getText("polygon_must_not_self_intersect");

        private double clusterTolerance;

        public PolygonMustNotSelfIntersect(Topology topology, FLyrVect originLyr,

                        double clusterTolerance) {

                super(topology, originLyr);

                this.clusterTolerance = clusterTolerance;

        }

        public PolygonMustNotSelfIntersect() {

        }

        public void checkPreconditions() throws TopologyRuleDefinitionException {

                try {

                        if (FGeometryUtil.getDimensions(originLyr.getShapeType()) != 2)

                                throw new TopologyRuleDefinitionException(

                                                "La capa no es de poligonos o multigeometrias");

                } catch (ReadDriverException e) {

                        throw new TopologyRuleDefinitionException(

                                        "Error de driver al chequear las precondiciones de la regla");

                }

        }

        public String getName() {

                return ruleName;

        }

        public void validateFeature(IFeature feature) {

                IGeometry geom = feature.getGeometry();

                int shapeType = geom.getGeometryType();

                if(FGeometryUtil.getDimensions(shapeType) != 2)

                        return;

                Geometry jtsGeom = geom.toJTSGeometry();

                process(jtsGeom, feature);

        }

        protected void process(Geometry jtsGeom, IFeature feature) {

                if (jtsGeom instanceof MultiPolygon) {

                        MultiPolygon multi = (MultiPolygon) jtsGeom;

                        int numPol = multi.getNumGeometries();

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

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

                                process(pol, feature);

                        }

                } else if (jtsGeom instanceof GeometryCollection) {

                        MultiPolygon multi = JtsUtil

                                        .convertToMultiPolygon((GeometryCollection) jtsGeom);

                        process(multi, feature);

                } else if (jtsGeom instanceof Polygon) {

                        Polygon pol = (Polygon) jtsGeom;

                        List<Coordinate> selfIntersections = new ArrayList<Coordinate>();

                        LineString shell = pol.getExteriorRing();

                        SnapLineStringSelfIntersectionChecker checker = new SnapLineStringSelfIntersectionChecker(

                                        shell, getClusterTolerance());

                        if (checker.hasSelfIntersections()) {

                                Coordinate[] selfIntersection = checker.getSelfIntersections();

                                selfIntersections.addAll(Arrays.asList(selfIntersection));

                        }

                        int numHoles = pol.getNumInteriorRing();

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

                                LineString hole = pol.getInteriorRingN(i);

                                checker = new SnapLineStringSelfIntersectionChecker(hole,

                                                getClusterTolerance());

                                if (checker.hasSelfIntersections()) {

                                        Coordinate[] selfIntersection = checker

                                                        .getSelfIntersections();

                                        selfIntersections.addAll(Arrays.asList(selfIntersection));

                                }// if

                        }// for

                        if (selfIntersections.size() > 0) {

                                Iterator<Coordinate> coordsIt = selfIntersections.iterator();

                                int count = 0;

                                int numberOfSelfCoords = selfIntersections.size();

                                double[] x = new double[numberOfSelfCoords];

                                double[] y = new double[numberOfSelfCoords];

                                while (coordsIt.hasNext()) {

                                        Coordinate coord = (Coordinate) coordsIt.next();

                                        x[count] = coord.x;

                                        y[count] = coord.y;

                                        count++;

                                }

                                FMultiPoint2D multiPoint = new FMultiPoint2D(x, y);

                                TopologyError topologyError = new TopologyError(multiPoint,

                                                                                                        this, feature, topology);

                                topologyError.setID(errorContainer.getErrorFid());

                                addTopologyError(topologyError);

                        }//if

                }// if polygon

        }

        public double getClusterTolerance() {

                return clusterTolerance;

        }

        public void setClusterTolerance(double clusterTolerance) {

                this.clusterTolerance = clusterTolerance;

        }

        public boolean acceptsOriginLyr(FLyrVect lyr) {

                try {

                        return FGeometryUtil.getDimensions(lyr.getShapeType()) == 2;

                } catch (ReadDriverException e) {

                        return false;

                }

        }

}