| gvSIG desktop 1

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

import org.gvsig.topology.TopologyError;

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

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) {

		this.clusterTolerance = clusterTolerance;

	public PolygonMustNotSelfIntersect() {

	}

		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");

		}

		return ruleName;

		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

	}

		return clusterTolerance;

		this.clusterTolerance = clusterTolerance;

	public boolean acceptsOriginLyr(FLyrVect lyr) {

		try {

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

		} catch (ReadDriverException e) {

			return false;

		}