| gvSIG desktop 1

import org.gvsig.fmap.core.NewFConverter;

import org.gvsig.jts.JtsUtil;

import org.gvsig.jts.SnapLineStringSelfIntersectionChecker;

import org.gvsig.topology.Messages;

import org.gvsig.topology.TopologyError;

import org.gvsig.topology.TopologyRuleDefinitionException;

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

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

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

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

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

import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;

import com.iver.cit.gvsig.fmap.edition.ISchemaManager;

import com.vividsolutions.jts.algorithms.SnapCGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Envelope;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.Point;

import com.vividsolutions.jts.geom.Polygon;

	String ruleName = Messages.getText("must_not_have_dangles");

	double clusterTol;

	/**

	 * Default constructor

	 *

	 */

	public LineMustNotHaveDangles(Topology topology, FLyrVect originLyr, double clusterTol){

		super(topology, originLyr);

		this.clusterTol = clusterTol;

	public LineMustNotHaveDangles(FLyrVect originLyr){

		super(originLyr);

	}

		return ruleName;

	public void checkPreconditions() throws TopologyRuleDefinitionException {

		//This rule doesnt apply to Point vectorial layers.

		try {

			int shapeType = this.originLyr.getShapeType();

			if(shapeType != FShape.LINE || shapeType != FShape.MULTI)

				throw new TopologyRuleDefinitionException();

		} catch (ReadDriverException e) {

			e.printStackTrace();

			throw new TopologyRuleDefinitionException("Error leyendo el tipo de geometria del driver",e);

		}	

	/**

	 * Validates this rule with a feature of the origin layer

	 * @param feature feature of the origin layer this rule is checking

	 */

		IGeometry geom = feature.getGeometry();

		int shapeType = geom.getGeometryType();

		if(shapeType != FShape.LINE && 

		   shapeType != FShape.ARC && 

		   shapeType != FShape.LINE + FShape.Z)

			return;

		Geometry jtsGeom = geom.toJTSGeometry();

		process(jtsGeom, feature);

	} 

	/**

	 * Utility class to check if a given linestring is a dangle

	 * (it has unconected extremes)

	 * 

	 * @author Alvaro Zabala

	 *

	 */

	class DangleChecker{

		Point end1;

		boolean ends1 = false;

		Point end2;

		boolean ends2 = false;

	private void process(Geometry geometry, IFeature feature){

		if(geometry instanceof GeometryCollection){

			GeometryCollection geomCol = (GeometryCollection) geometry;

			for(int i = 0; i < geomCol.getNumGeometries(); i++){

				Geometry geomI = geomCol.getGeometryN(i);

				process(geomI, feature);

			}

		}else if(geometry instanceof LineString){

			LineString lineString = (LineString) geometry;

			//first of all, we check for a closed linestring

			//first point equals to last point.

			//This would not be a dangle

			if(JtsUtil.isClosed(lineString, clusterTol)){

				return;

			}

			Point end1 = lineString.getPointN(0);

			Point end2 = lineString.getPointN(lineString.getNumPoints() - 1);

			DangleChecker checker = new DangleChecker();

			checker.end1 = end1;

			checker.end2 = end2;

			Rectangle2D rect = NewFConverter.

				convertEnvelopeToRectangle2D(lineString.getEnvelopeInternal());

			try {

				IFeatureIterator neighbours = originLyr.

											 getSource().

											 getFeatureIterator(rect, null, null, false);

				while(neighbours.hasNext()){

					IFeature neighbourFeature = neighbours.next();

					Geometry geom2 = neighbourFeature.getGeometry().toJTSGeometry();

					process2(checker, geom2);

				}

				SnapLineStringSelfIntersectionChecker selfIntChecker = 

					new SnapLineStringSelfIntersectionChecker(lineString, clusterTol);

				selfIntChecker.setLineString(lineString);

				if(! checker.ends1){//dangling node

					//we check if its is a selfintersection

					//(if true, its not a dangling node)

					boolean isSelfIntersection = false;

					if(selfIntChecker.hasSelfIntersections()){

						Coordinate[] selfs = selfIntChecker.getSelfIntersections();

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

							if(SnapCGAlgorithms.snapEquals2D(checker.end1.getCoordinate(), selfs[i], clusterTol)){

								isSelfIntersection = true;

							}

						}//for

					}

					if(! isSelfIntersection){

						IGeometry errorGeom = 

							ShapeFactory.createPoint2D(checker.end1.getX(),

													   checker.end1.getY());

					    TopologyError topologyError = 

							new TopologyError(errorGeom, 

												this, 

											 feature,

											topology);

					    topologyError.setID(errorContainer.getErrorFid());

					    addTopologyError(topologyError);

					}	

				}

				if(! checker.ends2){//dangling node

					boolean isSelfIntersection = false;

					if(selfIntChecker.hasSelfIntersections()){

						Coordinate[] selfs = selfIntChecker.getSelfIntersections();

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

							if(SnapCGAlgorithms.snapEquals2D(checker.end1.getCoordinate(), selfs[i], clusterTol)){

								isSelfIntersection = true;

							}

						}//for

					}

					if(! isSelfIntersection){

						IGeometry errorGeom = 

							ShapeFactory.createPoint2D(checker.end2.getX(),

													   checker.end2.getY());

					    TopologyError topologyError = 

							new TopologyError(errorGeom, 

												this, 

											 feature,

											topology);

					    topologyError.setID(errorContainer.getErrorFid());

					    addTopologyError(topologyError);

					}	

				}

				if(! checker.ends2 && ! checker.ends1){//dangling line

					GeneralPathX gp = new GeneralPathX();

					gp.moveTo(checker.end1.getX(), checker.end1.getY());

					gp.lineTo(checker.end2.getX(), checker.end2.getY());

					IGeometry errorGeom = ShapeFactory.createPolyline2D(gp);

					TopologyError topologyError = 

							new TopologyError(errorGeom, 

												this, 

											 feature,

											topology);

				    topologyError.setID(errorContainer.getErrorFid());

				    addTopologyError(topologyError);

				}

			} catch (ReadDriverException e) {

				e.printStackTrace();

				return;

			}

		}else{

			System.out.println("Encontrado:"+geometry.toString()+" en regla de dangles");

		}

	}

	private void process2(DangleChecker checker, Geometry intersectingGeom){

		if(intersectingGeom instanceof LineString){

			LineString lineString = (LineString) intersectingGeom;

			Envelope snapEnvelope = JtsUtil.

				toSnapRectangle(checker.end1.getCoordinate(), clusterTol);

			Geometry snapPolygon = null;

//			if(lineString.intersects(checker.end1)){

			if(lineString.getEnvelopeInternal().intersects(snapEnvelope)){

				snapPolygon = JtsUtil.geomFactory.toGeometry(snapEnvelope);

				if(lineString.intersects(snapPolygon))

					checker.ends1 = true;

			}

			snapEnvelope = JtsUtil.

				toSnapRectangle(checker.end2.getCoordinate(), clusterTol);

//			if(lineString.intersects(checker.end2)){

			if(lineString.getEnvelopeInternal().intersects(snapEnvelope)){

				snapPolygon = JtsUtil.geomFactory.toGeometry(snapEnvelope);

				if(lineString.intersects(snapPolygon))

					checker.ends2 = true;

			}

		}else if(intersectingGeom instanceof GeometryCollection){

			GeometryCollection geomCol = (GeometryCollection) intersectingGeom;

			for(int i = 0; i < geomCol.getNumGeometries(); i++){

				Geometry geomI = geomCol.getGeometryN(i);

				process2(checker, geomI);

			}

		}else{

			System.out.println("Encontrado:"+intersectingGeom.toString()+" en regla de dangles");

		}

	}