| gvSIG desktop 1

package org.gvsig.topology;

import com.hardcode.gdbms.engine.values.Value;

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

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

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

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

/**

 *Error produced when one or many features ?

 *violates a topology rule.

 */

public class TopologyError extends DefaultFeature {

	/**

	 *rule which has been violated

	 */

	private AbstractTopologyRule violatedRule;

	/**

	 *features of the source layer that

	 *violates the rule (if the rule is a self-rule,

	 *the error will only have source layer features)

	 */

	private IFeature[] sourceLyrFeatures;

	/**

	 *features of the destination layer

	 *that violate the rule (only in rules between

	 *two layers)

	 */

	private IFeature[] destinationLyrFeatures;

	private boolean exception;

	public TopologyError(){

		//FIXME Change the constructor of DefaultFeature

		super((IGeometry)null, (Value[])null,(String) null);

	}

	public void setViolatedRule(AbstractTopologyRule violatedRule) {

	}

	public AbstractTopologyRule getViolatedRule() {

		return null;

	}

	public void setSourceLyrFeatures(IFeature[] sourceLyrFeatures) {

	}

	public IFeature[] getSourceLyrFeatures() {

		return null;

	}

	public void setDestinationLyrFeatures(IFeature[] destinationLyrFeatures) {

	}

	public IFeature[] getDestinationLyrFeatures() {

		return null;

	}

	/**

	 *Ruturns the type of geometry of the error

	 */

	public int getShapeType() {

		return 0;

	}

	public void setException(boolean exception) {

	}

	public boolean isException() {

		return false;

	}

	public IGeometry getGeometry() {

		// TODO Auto-generated method stub

		return null;

	}

	public void setGeometry(IGeometry geom) {

		// TODO Auto-generated method stub

	}

	public IRow cloneRow() {

		// TODO Auto-generated method stub

		return null;

	}

	public String getID() {

		// TODO Auto-generated method stub

		return null;

	}

	public void setID(String ID) {

		// TODO Auto-generated method stub

	}

}

package org.gvsig.topology.topologyrules;

import org.gvsig.topology.AbstractTopologyRule;

import org.gvsig.topology.IOneLyrRule;

/**

 *This rule checks that lines of a line layer dont have

 *pseudonodes ends (a point that only touch another line)

 */

public class LinesMustNotHavePseudonodes extends AbstractTopologyRule implements IOneLyrRule {

}

package org.gvsig.topology.topologyrules;

import org.gvsig.topology.AbstractTopologyRule;

import org.gvsig.topology.IOneLyrRule;

/**

 *All end points of a line must touch at least another line.

 *(if only touch one line, its a pseudonode, not a dangle)

 *This rule is checked for the two ends of a line.

 *

 */

public class LineMustNotHaveDangles extends AbstractTopologyRule implements IOneLyrRule {

}

package org.gvsig.topology.topologyrules;

import org.gvsig.topology.AbstractTopologyRule;

import org.gvsig.topology.IOneLyrRule;

/**

 *This rule checks that a geometry (line or polygon)

 *dont have consecutive repeated points)

 *

 */

public class MustNotHaveRepeatedPoints extends AbstractTopologyRule implements IOneLyrRule {

}

package org.gvsig.topology.topologyrules;

import org.gvsig.topology.IOneLyrRule;

import org.gvsig.topology.AbstractTopologyRule;

import org.gvsig.topology.Topology;

/**

 *For lines o polygons. The lenght of a line or the perimeter

 *of a polygon must be larger than the cluster tolerance

 *

 */

public class MustBeLargerThanClusterTolerance extends AbstractTopologyRule implements IOneLyrRule {

	private Topology topology;

}

package org.gvsig.topology.topologyrules;

import org.gvsig.topology.AbstractTopologyRule;

import org.gvsig.topology.IOneLyrRule;

/**

 *Any validated geometry must be a right JTS geometry.

 */

public class JtsValidRule extends AbstractTopologyRule implements IOneLyrRule {

}

package org.gvsig.topology.topologyrules;

import org.gvsig.topology.AbstractTopologyRule;

import org.gvsig.topology.IOneLyrRule;

/**

 *Lines of a layer must not have self intersections.

 *JTS allows this. This is one of the restrictions that must

 *not have pseudonodos checks.

 *

 */

public class LineMustNotSelfIntersect extends AbstractTopologyRule implements IOneLyrRule {

}

package org.gvsig.topology.topologyrules;

import org.gvsig.topology.AbstractTopologyRule;

import org.gvsig.topology.IOneLyrRule;

/**

 *The polygons of a layer must not have self intersections

 *

 */

public class PolygonMustNotSelfIntersect extends AbstractTopologyRule implements IOneLyrRule {

}

package org.gvsig.topology.topologyrules;

import org.gvsig.topology.AbstractTopologyRule;

import org.gvsig.topology.IOneLyrRule;

/**

 *The polygons of a given layer must not overlaps

 *each other (their intersection must be a line, not an area)

 *

 */

public class PolygonsMustNotOverlap extends AbstractTopologyRule implements IOneLyrRule {

}

package org.gvsig.topology;

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

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

import java.awt.geom.Rectangle2D;

import java.util.Collection;

public abstract class AbstractTopologyRule implements ITopologyRule {

	private FLyrVect originLyr;

	private FLyrVect destinationLyr;

	private Topology topology;

	public void setOriginLyr(FLyrVect originLyr) {

	}

	public FLyrVect getOriginLyr() {

		return null;

	}

	public void setDestinationLyr(FLyrVect destinationLyr) {

	}

	public FLyrVect getDestinationLyr() {

		return null;

	}

	public String getName() {

		return null;

	}

	/**

	 *Checks if the rule's parameters 

	 *(sourceLyr, destinationLyr) verify 

	 *rule preconditions (geometry type, etc.)

	 */

	public void checkPreconditions() {

	}

	public void checkRule() {

	}

	void validateFeature(IFeature feature) {

	}

	public void checkRule(Rectangle2D rect) {

	}

	public Collection getTopologyErrors() {

		return null;

	}

}

package org.gvsig.topology;

/**

 *Marker interface for all rules that applies to only one layer

 *

 */

public interface IOneLyrRule extends ITopologyRule {

}

package org.gvsig.topology;

public interface ITopologyStatus {

	public static final byte VALIDATED = 0;

	public static final byte VALIDATED_WITH_ERRORS = 1;

	public static final byte NON_VALIDATED = 2;

}

package org.gvsig.topology;

import com.iver.cit.gvsig.fmap.MapContext;

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

import com.vividsolutions.jts.geom.Envelope;

import java.awt.geom.Rectangle2D;

import org.cresques.cts.IProjection;

import org.gvsig.topology.topologyrules.MustBeLargerThanClusterTolerance;

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

public class Topology extends FLayers implements ITopologyErrorContainer, ITopologyStatus {

	public Topology(MapContext fmap, FLayers parent) {

		super(fmap, parent);

		// TODO Auto-generated constructor stub

	}

	public Topology(){

		super(null, null);

	}

	private double clusterTolerance;

	private int status;

	/**

	 *If during validation process a topoly

	 *exceeds this parameters, validation will be stopped.

	 *

	 */

	private int maxNumberOfErrors = -1;

	private AbstractTopologyRule[] abstractTopologyRule;

	private Envelope[] envelope;

	private Rectangle2D[] dirtyZones;

	private MustBeLargerThanClusterTolerance[] clusterTolRule;

	public double getClusterTolerance() {

		return 0;

	}

	/**

	 *Adds a new topology rule to the topology.

	 */

	public void addRule(AbstractTopologyRule rule) {

	}

	/**

	 *Adds a layer to the topology. If the topology has been validated, changes

	 *topology status to NON-VALIDATED and adds a dirty zone equals to

	 *the layer extent.

	 */

	public void addLayer(FLyrVect layer, int xyRank, int zRank) {

	}

	public void setStatus(int status) {

	}

	public int getStatus() {

		return 0;

	}

	/**

	 *Adds a dirty zone to the topology

	 *(usually whe a feature of a layer

	 *of the topology has been edited)

	 */

	public void addDirtyZone(Rectangle2D dirtyZone) {

	}

	public Rectangle2D getDirtyZone() {

		return null;

	}

	public void validate() {

	}

	public int getLayerCount() {

		return 0;

	}

	public int getRuleCount() {

		return 0;

	}

	public FLyrVect getLyr(int lyrIndex) {

		return null;

	}

	public AbstractTopologyRule getRule(int ruleIndex) {

		return null;

	}

	/**

	 *Returns if a specified rectangle touch one

	 *of the existing dirty zones. If not, probably

	 *is needed to add to the dirty zones collection.

	 *If true, maybe it could modify the dirty zone.

	 */

	public boolean isInDirtyZone() {

		return false;

	}

	/**

	 *Modify the dirty zone of the specified index

	 */

	public void updateDirtyZone(int dirtyZoneIndex, Rectangle2D dirtyZone) {

	}

	public void setMaxNumberOfErrors(int maxNumberOfErrors) {

	}

	public int getMaxNumberOfErrors() {

		return 0;

	}

	public void addTopologyError(TopologyError topologyError) {

		// TODO Auto-generated method stub

	}

	public void markAsTopologyException(TopologyError topologyError,

			boolean markAsException) {

		// TODO Auto-generated method stub

	}

	public TopologyError[] getTopologyErrors(String ruleName, int shapeType,

			FLyrVect sourceLayer, IProjection desiredProjection,

			int includeExceptions) {

		// TODO Auto-generated method stub

		return null;

	}

}

package org.gvsig.topology;

public interface ITopologyRule {

}

package org.gvsig.topology;

import java.util.Map;

/**

 *Class with the responsability of persist topologies

 *and their elements.

 */

public class TopologyPersister {

	public static void persist(Topology topology) {

	}

	public static Topology load(Map storeParams) {

		return null;

	}

}

package org.gvsig.topology;

/**

 *Marker interface for all rules that applies to two layers

 */

public interface ITwoLyrRule extends ITopologyRule {

}

package org.gvsig.topology;

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

import org.cresques.cts.IProjection;

/**

 *All the classes that contains TopologyError must 

 *implement this interface.

 */

public interface ITopologyErrorContainer {

	public static final int ONLY_ERRORS = 0;

	public static final int ONLY_EXCEPTIONS = 1;

	public static final int BOTH_ERROR_EXCEPTIONS = 2;

	public void addTopologyError(TopologyError topologyError);

	/**

	 *Returns the errors contained. In function

	 *of the specified params, returned errors 

	 *will be reprojected, filtered by rule, geometry type,

	 *etc.

	 */

	public TopologyError[] getTopologyErrors(String ruleName, int shapeType, FLyrVect sourceLayer, IProjection desiredProjection, int includeExceptions);

	/**

	 *Marks the specified feature as the

	 *specified status (exception or not exception)

	 */

	public void markAsTopologyException(TopologyError topologyError, boolean markAsException);

}

package org.gvsig.jts;

import com.vividsolutions.jts.geom.Geometry;

/**

 *Moves coordinates (in a given tolerance) to force them to coincide.

 */

public class Snapper {

	public static Geometry[] snap(Geometry[] geoms2snap, int[] geomsWeights) {

		return null;

	}

}

package org.gvsig.jts;

import com.vividsolutions.jts.geom.Geometry;

/**

 *Cracks the geometries of a topology's layers to force

 *the sharing of coordinates

 *

 */

public class Cracker {

	/**

	 *Receives many geometries, cheks if the shared

	 *geometry is explicit, and if not, adds vertex

	 *in common points to ensure the sharing of common geometries

	 */

	public static Geometry[] crack(Geometry[] geoms2crack) {

		return null;

	}

}

package org.gvsig.jts;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

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

import com.vividsolutions.jts.algorithm.RobustLineIntersector;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geomgraph.Edge;

import com.vividsolutions.jts.geomgraph.EdgeIntersection;

import com.vividsolutions.jts.geomgraph.EdgeIntersectionList;

import com.vividsolutions.jts.geomgraph.GeometryGraph;

import com.vividsolutions.jts.geomgraph.index.EdgeSetIntersector;

import com.vividsolutions.jts.geomgraph.index.SegmentIntersector;

import com.vividsolutions.jts.geomgraph.index.SimpleMCSweepLineIntersector;

/**

 * 

 * Cheks if a given linestring has selfintersections,

 * and gives methods to split a line with self intersections

 * in many lines.

 * 

 * Doesnt  consideer snap tolerance.

 * 

 * @author azabala

 *

 */

public class LineStringSelfIntersectionChecker {

	private LineString lineString;

	private GeometryGraph graph;

	private boolean hasInitialized = false;

	//TODO Must we use a CoordinateMap ??

	private Coordinate[] selfIntersections;

	public LineStringSelfIntersectionChecker(LineString lineString){

		this.lineString = lineString;

		this.graph = new GeometryGraph(0, lineString);

	}

	public boolean hasSelfIntersections() {

		if(! hasInitialized){

			initialize();

			hasInitialized = true;

		}//if

		if(selfIntersections != null && selfIntersections.length > 0)

			return true;

		else

			return false;

	}

	private void initialize(){

		ArrayList selfIntersectionsList = new ArrayList();

		SnappingCoordinateMap selfIntersectionsMap = new SnappingCoordinateMap(0d);

//		SegmentIntersector si = graph.computeSelfNodes(new RobustLineIntersector(), true);

//		Iterator i = graph.getEdgeIterator();

		List edges = computeSelfNodes();

		Iterator i = edges.iterator();

		while (i.hasNext()) {//for each edge graph

			Edge e = (Edge) i.next();

			EdgeIntersectionList eiList = e.getEdgeIntersectionList();

			for (Iterator eiIt = eiList.iterator(); eiIt.hasNext(); ) {//PROBLEMA: LAS AUTOINTERSECCIONES EN LINEAS SON PERMITIDAS

				EdgeIntersection ei = (EdgeIntersection) eiIt.next();

				if(!graph.isBoundaryNode(0, ei.coord)){

					if(! selfIntersectionsMap.contains(ei.coord)){

						selfIntersectionsList.add(ei.coord);

						selfIntersectionsMap.put(ei.coord, ei.coord);

					}	

				}	

			}//for

		}//while

		int numSelfIntersections = selfIntersectionsList.size();

		if(numSelfIntersections > 0){

			selfIntersections = new Coordinate[numSelfIntersections];

			selfIntersectionsList.toArray(selfIntersections);

		}

	}

	private List computeSelfNodes(){

		SegmentIntersector si = new SegmentIntersector(new RobustLineIntersector(), true, false);

		EdgeSetIntersector esi = new SimpleMCSweepLineIntersector();

		List edges = new ArrayList();

		Iterator edgesIt = graph.getEdgeIterator();

		while(edgesIt.hasNext()){

			edges.add(edgesIt.next());

		}

		esi.computeIntersections(edges, si, true);

		return edges;

		/*

		 * By design, JTS allows self intersections.

		 * 

		public SegmentIntersector computeSelfNodes(LineIntersector li, boolean computeRingSelfNodes){

			SegmentIntersector si = new SegmentIntersector(li, true, false);

			EdgeSetIntersector esi = createEdgeSetIntersector();

			// optimized test for Polygons and Rings

			 if (! computeRingSelfNodes

			 	&& (parentGeom instanceof LinearRing

			 	|| parentGeom instanceof Polygon

			 	|| parentGeom instanceof MultiPolygon)) {

			 	esi.computeIntersections(edges, si, false);

              }

              else {

              	esi.computeIntersections(edges, si, true);

              }

              //System.out.println("SegmentIntersector # tests = " + si.numTests);

               addSelfIntersectionNodes(argIndex);

               return si;

          }

		  */

	}

	/**

	 *Returns the self intersections of the linestring

	 */

	public Coordinate[] getSelfIntersections() {

		return selfIntersections;

	}

	public Geometry[] clean() {

		/*

		 * The algorith to clean a polyline with self intersections is:

		 * 

		 * Create result (linestring) collection.

		 * 

		 * Create new empty geometry 

		 * 

		 * For each geometry vertex.

		 * 		add vertex to empty geometry

		 *      if vertex is self intersection

		 *      	save geometry in result collection

		 *          create new empty geometry

		 *          add self intersection to empty geometry 

		 *          

		 *          

		 *          

		 *  Special cases; what if a geometry only has one point 

		 *  (first vertex is selfintersection).

		 *  This wouldnt be consideered as self intersection. It is a node

		 *  of a closed polyline

		 *  

		 *  TODO A test case with this case       

		 * */

		Geometry[] cleanedLines = null;

		ArrayList solution = new ArrayList();

		GeometryFactory factory = new GeometryFactory();

		ArrayList solutionCoords = new ArrayList();

		Coordinate[] lineStringCoords = lineString.getCoordinates();

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

			Coordinate coord = lineStringCoords[i];

			solutionCoords.add(coord);

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

				Coordinate selfIntersection = selfIntersections[j];

				if(selfIntersection.equals2D(coord)){

					//the vertex is a self intersection

					Coordinate[] geomCoords = new Coordinate[solutionCoords.size()];

					solutionCoords.toArray(geomCoords);

					LineString newLineString = factory.createLineString(geomCoords);

					solution.add(newLineString);

					solutionCoords.clear();

					solutionCoords.add(coord);

					break;

				}//if

			}//for j

		}//for i

		//finally, create the last geometry

		Coordinate[] geomCoords = new Coordinate[solutionCoords.size()];

		solutionCoords.toArray(geomCoords);

		LineString newLineString = factory.createLineString(geomCoords);

		solution.add(newLineString);

		cleanedLines = new Geometry[solution.size()];

		solution.toArray(cleanedLines);

		return cleanedLines;

	}

	public LineString getLineString() {

		return lineString;

	}

	public void setLineString(LineString lineString) {

		this.lineString = lineString;

	}

}

/*

 * Created on 26-ago-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$

* Revision 1.1  2007-08-27 18:05:59  azabala

* first version in cvs

*

*

*/

package org.gvsig.topology;

import org.gvsig.jts.LineStringSelfIntersectionChecker;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.io.ParseException;

import com.vividsolutions.jts.io.WKTReader;

import junit.framework.TestCase;

/**

 * To see visually the geometries used for testing, use

 * JTS Test editor and paste WKT code.

 * 

 * TODO Maybe edition in gvSIG would have a wkt editor, or

 * a tool to select a geometry and see it in WKT.

 * 

 * 

 * 

 * */

public class LineStringSelfIntersectionTest extends TestCase {

	GeometryFactory factory = new GeometryFactory();

	WKTReader wktReader = new WKTReader(factory);

	public void testLine1() throws ParseException{

		//linestring with one self intersection

		String wkt1 = "LINESTRING (-12378 3231, -14205 1381, -8845 2486, -11080 4794, -13820 -663)";

		LineString lineString = (LineString) wktReader.read(wkt1);

		LineStringSelfIntersectionChecker checker = 

			new LineStringSelfIntersectionChecker(lineString);

		assertTrue(checker.hasSelfIntersections());

		Coordinate[] selfIntersections = checker.getSelfIntersections();

		assertTrue(selfIntersections.length == 1);

		Geometry[] cleanedLineString = checker.clean();

		assertTrue(cleanedLineString.length == 3);

	}

	public void testLine2() throws ParseException{

		String wkt2 = "LINESTRING (-16152 2534, -15190 5251, -10239 3808, -8316 -807, -11417 -1360, -11344 2246, -6128 5203, -600 2606, -1417 515, -3484 -1023, -5263 2486, -816 6765, 602 5948)";

		LineString lineString = (LineString) wktReader.read(wkt2);

		LineStringSelfIntersectionChecker checker = 

			new LineStringSelfIntersectionChecker(lineString);

		checker.hasSelfIntersections();

		checker.clean();

	}

}

/*

 * Created on 25/08/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$

* Revision 1.1  2007-08-27 18:05:59  azabala

* first version in cvs

*

*

*/

package org.gvsig.topology;

import junit.framework.TestCase;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.PrecisionModel;

import com.vividsolutions.jts.io.ParseException;

import com.vividsolutions.jts.io.WKTReader;

import com.vividsolutions.jts.operation.overlay.OverlayOp;

import com.vividsolutions.jts.operation.overlay.SnappingOverlayOperation;

/**

 * 

 * In these tests we try to probe the use of snapping and

 * precision reduction in JTS operations, to avoid undesired

 * effects (for example spureus lines in dissolve) and

 * to allow clustering tolerance in topologies.

 * 

 * Documentaci?n de tests.

 * Prueba de operaciones JTS con snapping.

 * 

 * 

 * @author azabala

 *

 */

public class JtsSnapTest extends TestCase {

	static String wktLS1 = "LINESTRING (260 120, 300 180, 420 180, 480 120)";

	static String wktLS2 = "LINESTRING (479.999 120, 459 114, 437 128, 426 130, 458 141)";

	public void testLineLineJTS18DEFAULT() throws ParseException{

//		GeometryFactory factory = new GeometryFactory();

//		WKTReader wktReader = new WKTReader(factory);

//		Geometry ls1 = wktReader.read(wktLS1);

//		Geometry ls2 = wktReader.read(wktLS2);

//		

//		Geometry intersection = SnapIfNeededOverlayOp.intersection(ls1, ls2);

//		System.out.println(intersection.toText());

//		assertTrue(intersection instanceof GeometryCollection);

//		GeometryCollection sol = (GeometryCollection)intersection;

//		assertTrue(sol.getNumGeometries() == 0);

	}

	//SnapIfNeeded solo actua si se producen errores de precision en el calculo de overlays

	//si no hay ningun error, pasa del snap

	public void testLineLineJTS18PMFIXED() throws ParseException{

//		GeometryFactory factory = new GeometryFactory(new PrecisionModel(1));

//		WKTReader wktReader = new WKTReader(factory);

//		Geometry ls1 = wktReader.read(wktLS1);

//		Geometry ls2 = wktReader.read(wktLS2);

//		Geometry intersection = SnapOverlayOp.intersection(ls1, ls2);

//		System.out.println(intersection.toText());

//		assertTrue(!(intersection instanceof GeometryCollection));

//		GeometryCollection sol = (GeometryCollection)intersection;

//		assertTrue(sol.getNumGeometries() != 0);

	}

	public void testLineLineJTS18PMFIXED2() throws ParseException{

//		GeometryFactory factory = new GeometryFactory(new PrecisionModel(1000));

//		WKTReader wktReader = new WKTReader(factory);

//		Geometry ls1 = wktReader.read(wktLS1);

//		Geometry ls2 = wktReader.read(wktLS2);

//		Geometry intersection = SnapOverlayOp.intersection(ls1, ls2);

//		System.out.println(intersection.toText());

//		assertTrue(!(intersection instanceof GeometryCollection));

	}

	/*

	 El resultado de estos tres primeros tests es el siguiente:

	 GEOMETRYCOLLECTION EMPTY

	 MULTIPOINT (458 141, 480 120)

	 LINESTRING (479.999 120, 480 120)

	 El snap de JTS viene determinado por el PrecisionModel

	 En el primer caso, el PrecisionModel es el por defecto (maxima precisi?n),

	 luego no se intersectan.

	 En el segundo caso, el PrecisionModel tiene una resoluci?n de 0.1, luego considera que

	 el primer y ultimo punto de la segunda linea intersectan.

	 AHORA BIEN. Como no hay desplazamiento, considera que (480, 120) y (479.999, 120) son

	 el mismo punto. Deber?an desplazarse??

	 En el tercer caso ya da resultados no deseados. Los puntos (479.999 120) y

	 (480, 120) si aplicamos una tolerancia de snap grande deben ser considerados el mismo punto,

	 pero si la tolerancia de snap es peque?a (1000 = 0.001 de resolucion) no deber?a dar

	 un LineString de solucion

	 REPORTAR A JTS-LIST

	 * */

	//TEST DE PRUEBA CON LAS CLASES DE JTS 1.7

	//OJO!!!!!!

	//EL SNAP DE GVSIG SOLO FUNCIONA CON JTS 1.7. CON JTS 1.8 NO COMPILA

	//TEST 1: INTERSECCI?N DE LINEAS

	public void testLineLineSnapGvSIG() throws ParseException{

//		GeometryFactory factory = new GeometryFactory();

//		WKTReader wktReader = new WKTReader(factory);

//		Geometry ls1 = wktReader.read(wktLS1);

//		Geometry ls2 = wktReader.read(wktLS2);

//		Geometry intersection = SnappingOverlayOperation.overlayOp(ls1, ls2, OverlayOp.INTERSECTION, 0.1d);

//		System.out.println(intersection.toText());

//		

//		

//		intersection = SnappingOverlayOperation.overlayOp(ls1, ls2, OverlayOp.INTERSECTION, 0.01d);

//		System.out.println(intersection.toText());

//		

//		intersection = SnappingOverlayOperation.overlayOp(ls1, ls2, OverlayOp.INTERSECTION, 0.001d);

//		System.out.println(intersection.toText());

//		

//		intersection = SnappingOverlayOperation.overlayOp(ls1, ls2, OverlayOp.INTERSECTION, 0.0001d);

//		System.out.println(intersection.toText());

//		

//		intersection = SnappingOverlayOperation.overlayOp(ls1, ls2, OverlayOp.INTERSECTION, 2d);

//		System.out.println(intersection.toText());

		/*

		 POINT (480 120)

		 POINT (480 120)

		 POINT (480 120)

		 GEOMETRYCOLLECTION EMPTY

		 MULTIPOINT (458 141, 480 120) 

		 Esto es increible!!!! El snap nuestro ofrece mejores resultados!!!!!!!

		 * */

		//ahora vemos si afecta el precisionmodel al modo tradicional

//		factory = new GeometryFactory(new PrecisionModel(1));

//		wktReader = new WKTReader(factory);

//		ls1 = wktReader.read(wktLS1);

//		ls2 = wktReader.read(wktLS2);

//		

//		intersection = SnappingOverlayOperation.overlayOp(ls1, ls2, OverlayOp.INTERSECTION, 0d);

//		System.out.println(intersection.toText());

//		

//		factory = new GeometryFactory(new PrecisionModel(10000));

//		wktReader = new WKTReader(factory);

//		ls1 = wktReader.read(wktLS1);

//		ls2 = wktReader.read(wktLS2);

//		

//		intersection = SnappingOverlayOperation.overlayOp(ls1, ls2, OverlayOp.INTERSECTION, 0d);

//		System.out.println(intersection.toText());

	}

	/*

	*/

	//MAS TESTS: INTERSECCIONES DE POLIGONOS CON POLIGONOS, LINEAS CON POLIGONOS, LINEAS

	//CON PUNTOS, POLIGONOS QUE SE AUTOINTERSECTEN Y LINEAS QUE SE AUTOINTERSECTEN

	//JTS 1.8

	public void testPolyPolyJTS18(){

	}

}