| gvSIG desktop 1

/*

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

 * Revision 1.1  2007-09-14 17:34:46  azabala

 * first version in cvs

 *

 *

 */

package org.gvsig.topology;

import org.gvsig.jts.GeometryCracker;

import org.gvsig.jts.GeometrySnapper;

import org.gvsig.jts.LineStringSplitter;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.geom.PrecisionModel;

import com.vividsolutions.jts.io.ParseException;

import com.vividsolutions.jts.io.WKTReader;

import com.vividsolutions.jts.precision.EnhancedPrecisionOp;

import junit.framework.TestCase;

/**

 * Unit tests for GeometryCrack and GeometrySnap classes.

 * 

 * @author azabala

 * 

 */

public class SnapAndCrackTest extends TestCase {

	PrecisionModel pm;

	GeometryFactory factory;

	WKTReader wktReader;

	protected void setUp() throws Exception {

		super.setUp();

		pm = new PrecisionModel(10000);

		factory = new GeometryFactory(pm);

		wktReader = new WKTReader(factory);

	}

	protected void tearDown() throws Exception {

		super.tearDown();

		pm = null;

		factory = null;

		wktReader = null;

	}

	public void testCrackTwoPolygons() throws ParseException {

		String pol1txt = "POLYGON ((320 160, 320 120, 360 120, 360 160, 320 160))";

		String pol2txt = "POLYGON ((360 160, 360 140, 360 120, 400 120, 400 140, 400 160, 360 160))";

		Polygon geo1 = (Polygon) wktReader.read(pol1txt);

		Polygon geo2 = (Polygon) wktReader.read(pol2txt);

		// GeometryCracker cracker = new GeometryCracker(0.1d);

		LineString cracked1 = (LineString) GeometryCracker.crack(geo1.getExteriorRing(), 

																geo2.getExteriorRing(), 

																	0.1d);

		System.out.println(cracked1.toText());

	}

	public void testCrackTwoIntersectingLinesWithPseudonodes() throws ParseException{

		//a) Two linestrings that intersects in points that are not nodes (pseudonodes)

		String a = "LINESTRING (300 120, 360 140, 480 160, 420 100)";

		String b = "LINESTRING (320 140, 360 100, 420 180, 480 100, 400 120)";

		LineString linA = (LineString) wktReader.read(a);

		LineString linB = (LineString) wktReader.read(b);

		GeometryCracker cracker = new GeometryCracker(0.1);

		Geometry[] geoms = {linA, linB};

		Geometry[] cracked = cracker.crack(geoms);

		System.out.println(cracked[0].toText());

		System.out.println(cracked[1].toText());

		//Crack and Snap only affect to Vertices (it doesnt compute intersections)

		assertTrue(a.equalsIgnoreCase(cracked[0].toText()));

		assertTrue(b.equalsIgnoreCase(cracked[1].toText()));

		//a1) We split these two lines in their intersections (MustNotHavePseudonodes rule)

		Geometry intersections = EnhancedPrecisionOp.intersection(linA, linB);

		Coordinate[] intersectionPoints = intersections.getCoordinates();

		LineStringSplitter splitter = new LineStringSplitter();

		LineString[] linASplittedA = splitter.splitSimple(linA, intersectionPoints);

		LineString[] linBSplittedB = splitter.splitSimple(linB, intersectionPoints);

		assertTrue(linASplittedA.length == 6);

		assertTrue(linBSplittedB.length == 6);

		assertTrue(intersectionPoints.length == 5);

		//in this point, LineStringSplitter could return splitted linestring with

		//numerical precision problems. To avoid this, we could snap them.

		GeometrySnapper snapper = new GeometrySnapper(0.01d);

		Geometry[] aa = snapper.snap(linASplittedA);

		Geometry[] bb = snapper.snap(linBSplittedB);

		//FIXME

		//Instead of use Union for the test, use LineStringSewer

		Geometry splittedUnion = aa[0];

		for(int i = 1; i < aa.length; i++){

			splittedUnion = splittedUnion.union(aa[i]);

		}

//		assertTrue(splittedUnion.equalsExact(linA));

		splittedUnion = bb[0];

		for(int i = 1; i < bb.length; i++){

			splittedUnion = splittedUnion.union(bb[i]);

		}

//		assertTrue(splittedUnion.equals(linB));

		//b) Two intersecting lines with vertices that must be cracked and snapped

		//b1) vertex 320,180.001 must be cracked in first geometry

		// FIXME When were going to crack a vertex...?why dont apply the line equation y=mx+b

		//to avoid the pick 300 180, 320 180.001 360 180

		//b2) In 360,120 both lines intersects (this only will be detected in OverlayOp)

		//FIXME This is a real intersection. In the next test use a snap intersection

		// b3) In 380.01 99.99 we must crack first geometry

		// b4) 420.01 100.001 must be snapped

		//conclusion: to clean a topology we must: a) snap b) crack c) compute intersections

		a = "LINESTRING (300 180, 360 180, 360 100, 420 100)";

		b = "LINESTRING (320 180.001, 320 120, 380 120, 380.01 99.99, 400 180, 480 180, 420.01 100.001)";

		snapper = new GeometrySnapper(0.08);

		Geometry aG = wktReader.read(a);

		Geometry bG = wktReader.read(b);

		Geometry[] newgeoms = {aG,bG};

		Geometry[] snapped = snapper.snap(newgeoms);

		cracker = new GeometryCracker(0.08);

		snapped = cracker.crack(snapped);

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

			LineString ls1 = (LineString) snapped[i];

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

				if(i == j)

					continue;

				LineString ls2 = (LineString) snapped[i];

				//AQUI NO USAMOS SNAP. 

				Coordinate[] inters = EnhancedPrecisionOp.intersection(ls1, ls2).getCoordinates();

				LineString[] result1 = splitter.splitSimple(ls1, inters);

				Geometry multi1 = factory.createGeometryCollection(result1);

				LineString[] result2 = splitter.splitSimple(ls2, inters);

				Geometry multi2 = factory.createGeometryCollection(result2);

				multi2.toText();

				//Esto funciona porque son solo dos. Para hacerlo con muchas lineas, hay que mantener

				//para cada lineString una lista con todas las intersecciones, con independencia

				//de con que geomeetrias sea.. (USAR PARA ESTO EL PREPAREDGEOMETRY DE JTS)

			}//for

		}//for

	}

}

/*

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

* Revision 1.1  2007-09-14 17:35:52  azabala

* first version in cvs

*

*

*/

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

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geomgraph.Edge;

import com.vividsolutions.jts.geomgraph.EdgeIntersectionList;

import com.vividsolutions.jts.geomgraph.SnappingGeometryGraph;

import com.vividsolutions.jts.geomgraph.SnapEdgeIntersectionList.SnapEdgeIntersectNode;

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

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

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

public class SnapLineStringSelfIntersectionChecker extends

		LineStringSelfIntersectionChecker {

	public SnapLineStringSelfIntersectionChecker(LineString lineString,

			double snapTolerance) {

		super(lineString, snapTolerance);

		this.graph = new SnappingGeometryGraph(snapTolerance,0, lineString);

	}

	public SnapLineStringSelfIntersectionChecker(LineString lineString) {

		this(lineString, DEFAULT_SNAP_TOLERANCE);

	}

	protected void initialize() {

		ArrayList selfIntersectionsList = new ArrayList();

		SnappingCoordinateMap selfIntersectionsMap = new SnappingCoordinateMap(

				snapTolerance);

		List edges = computeSelfNodesWithSnap();

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

				Object obj =  eiIt.next();

				SnapEdgeIntersectNode ei = (SnapEdgeIntersectNode) obj;

				if (!isProper(ei.getCoordinate())) {

					if (!selfIntersectionsMap.containsKey(ei.getCoordinate())) {

						selfIntersectionsList.add(ei.getCoordinate());

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

					}//if

				}//if

			}// for

		}// while

		int numSelfIntersections = selfIntersectionsList.size();

		if (numSelfIntersections > 0) {

			selfIntersections = new Coordinate[numSelfIntersections];

			selfIntersectionsList.toArray(selfIntersections);

		}

	}

	private List computeSelfNodesWithSnap() {

		LineIntersector li = new SnapLineIntersector(snapTolerance);

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

		SnapSimpleMCSweepLineIntersector esi = new SnapSimpleMCSweepLineIntersector();

		List edges = new ArrayList();

		Iterator edgesIt = graph.getEdgeIterator();

		while (edgesIt.hasNext()) {

			edges.add(edgesIt.next());

		}

		esi.computeIntersections(edges, si, true);

		return edges;

	}

//	public Geometry[] clean() {

//		if (!hasInitialized) {

//			initialize();

//			hasInitialized = true;

//		}// if

//		if (selfIntersections == null && selfIntersections.length < 1)

//			return new Geometry[] { lineString };

//		else

//			return LineStringSplitter.removeSelfIntersections(lineString,

//					selfIntersections, snapTolerance);

//	}

}