| gvSIG desktop 1

import org.gvsig.topology.Messages;

import com.iver.cit.gvsig.exceptions.layers.LoadLayerException;

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

	public static FLyrVect getGaps(FLyrVect lyr, double clusterTolerance){

		 InternalMatchedSegmentFinder.Parameters msfParam

	        = new InternalMatchedSegmentFinder.Parameters();

		 msfParam.distanceTolerance = clusterTolerance;

		 double angleTolerance = 22.5d;

		 msfParam.angleTolerance = angleTolerance;

	    InternalMatchedSegmentFinder msf = 

	    	new InternalMatchedSegmentFinder(new FeatureCollectionAdapter(lyr.getSource()),

	    									msfParam);

	    FeatureCollection gapsCandidates = msf.getMatchedFeatures();

	    FeatureCollectionDataSourceAdapter driver =

	    	new FeatureCollectionDataSourceAdapter(Messages.getText("GAPS"), 

	    											gapsCandidates, 

	    											new FeatureSchemaLayerDefinitionAdapter(gapsCandidates.getFeatureSchema()));

	    FLayerGenericVectorial solution = new FLayerGenericVectorial();

		solution.setName(driver.getName());

		solution.setProjection(lyr.getProjection());

		solution.setDriver(driver);

		try {

			solution.load();

		} catch (LoadLayerException e) {

			e.printStackTrace();

		}

		return solution;

	}

	public static void alignCoverage(FLyrVect lyr, FLyrVect lyr2, double clusterTolerance, double angleTolerance){

				Geometry geom = NewFConverter.toJtsGeometry(feature.getGeometry());

//	public static LinearRing reverse(LinearRing ring) {

//		CoordinateSequence seq = ring.getCoordinateSequence();

//		CoordinateSequences.reverse(seq);

//		LinearRing solution = GEOMETRY_FACTORY.createLinearRing(seq);

//		return solution;

//	}

//	

//	

	public static LineString reverse(LineString lineString){

		LineString solution = lineString.reverse();

		if(lineString instanceof LinearRing)

			solution = toLinearRing(lineString);

				LinearRing newRing = (LinearRing) JtsUtil.reverse(testRing);

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

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

import com.vividsolutions.jts.algorithms.SnapCGAlgorithms;

 * FConverter does (for example, it doesnt close unclosed Polygons).

 * Also, it works with Jts.GEOMETRY_FACTORY, a global geometry factory which

 * works with a precision model selected by user. Precision Model is very important

 * to determine the number of significant digits of geometries, and to avoid precision problems.

 * 

			break;

	public static MultiPolygon toJtsPolygon(FShape shp) {

		ArrayList<LinearRing> shells = new ArrayList<LinearRing>();

		ArrayList<LinearRing> holes = new ArrayList<LinearRing>();

		List<Point2D[]> shpPoints = ShapePointExtractor.extractPoints(shp);

		for (int i = 0; i < shpPoints.size(); i++) {

			Point2D[] partPoints = shpPoints.get(i);

			Coordinate[] coords = JtsUtil.getPoint2DAsCoordinates(partPoints);

			try {

				LinearRing ring = JtsUtil.GEOMETRY_FACTORY

						.createLinearRing(coords);

				// TODO REPORTAR ESTO EN FMAP, CREO QUE EST? MAL PORQUE LO HACE

				// AL REV?S.

				// EL TEMA EST? EN QUE JTS HACE LAS COSAS AL REVES QUE EL

				// FORMATO SHP

				if (CGAlgorithms.isCCW(coords)) {

					shells.add(ring);

				} else {

					holes.add(ring);

				}

			} catch (Exception e) {

				/*

				 * Leer la cabecera del metodo: FConverter no deber?a hacer

				 * estos tratamientos boolean same = true; for (int j = 0; i <

				 * coords.length - 1 && same; j++) { if (coords[i].x !=

				 * coords[i+1].x || coords[i].y != coords[i+1].y) same = false; }

				 * if (same) return JtsUtil.geomFactory.createPoint(coords[0]);

				 */

				/*

				 * caso cuando es una l?nea de 3 puntos, no creo un LinearRing,

				 * sino una linea

				 */

				/*

				 * if (coords.length > 1 && coords.length <= 3) // return

				 * geomFactory.createLineString(points); return

				 * JtsUtil.geomFactory.createMultiLineString(new LineString[]

				 * {JtsUtil.geomFactory.createLineString(coords)});

				 */

				System.err

						.println("Caught Topology exception in GMLLinearRingHandler");

				return null;

			}

		}// for

		// At this point, we have a collection of shells and a collection of

		// holes

		// Now we have to find for each shell its holes

		ArrayList<List<LinearRing>> holesForShells = new ArrayList<List<LinearRing>>(

				shells.size());

		for (int i = 0; i < shells.size(); i++) {

			holesForShells.add(new ArrayList<LinearRing>());

		}

		/*

		 * Now, for each hole we look for the minimal shell that contains it. We

		 * look for minimal because many shells could contain the same hole.

		 */

		for (int i = 0; i < holes.size(); i++) {// for each hole

			LinearRing testHole = holes.get(i);

			LinearRing minShell = null;

			Envelope minEnv = null;

			Envelope testEnv = testHole.getEnvelopeInternal();

			Coordinate testPt = testHole.getCoordinateN(0);

			LinearRing tryRing = null;

			for (int j = 0; j < shells.size(); j++) {// for each shell

				tryRing = (LinearRing) shells.get(j);

				Envelope tryEnv = tryRing.getEnvelopeInternal();

				boolean isContained = false;

				Coordinate[] coordList = tryRing.getCoordinates();

				// if testpoint is in ring, or test point is a shell point, is

				// contained

				if (tryEnv.contains(testEnv)

						&& (SnapCGAlgorithms.isPointInRing(testPt, coordList) || JtsUtil

								.pointInList(testPt, coordList))) {

					isContained = true;

				}

				// check if this new containing ring is smaller than the current

				// minimum ring

				if (isContained) {

					if ((minShell == null) || minEnv.contains(tryEnv)) {

						minShell = tryRing;

						minEnv = minShell.getEnvelopeInternal();

					}

				}

			}// for shells

			// At this point, minShell is the shell that contains a testHole

			// if minShell is null, we have a SHELL which points were digitized

			// in the

			// wrong order

			if (minShell == null) {

				/*

				 * TODO Si las clases de FMap incluyesen en su semantica la

				 * diferencia entre un shell y un hole, no deberiamos hacer esta

				 * suposicion.

				 * 

				 * Pero como java.awt.geom.Shape no hace esta distincion,

				 * tenemos que hacerla.

				 * 

				 * 

				 */

				LinearRing reversed = (LinearRing) JtsUtil.reverse(testHole);

				shells.add(reversed);

				holesForShells.add(new ArrayList<LinearRing>());

			} else {

				((ArrayList<LinearRing>) holesForShells.get(shells

						.indexOf(minShell))).add(testHole);

			}

		}// for each hole

		Polygon[] polygons = new Polygon[shells.size()];

		for (int i = 0; i < shells.size(); i++) {

			polygons[i] = JtsUtil.GEOMETRY_FACTORY.createPolygon(

					(LinearRing) shells.get(i),

					(LinearRing[]) ((ArrayList<LinearRing>) holesForShells

							.get(i)).toArray(new LinearRing[0]));

		}

		return JtsUtil.GEOMETRY_FACTORY.createMultiPolygon(polygons);

	}

	public static Geometry toJtsGeometry(IGeometry fmapGeometry) {

		Geometry solution = null;

		if (fmapGeometry instanceof FGeometry) {

			FShape shp = (FShape) ((FGeometry) fmapGeometry).getInternalShape();

			solution = java2d_to_jts(shp);

		} else if (fmapGeometry instanceof FGeometryCollection) {

			IGeometry[] geometries = ((FGeometryCollection) fmapGeometry)

					.getGeometries();

			Geometry[] theGeoms = new Geometry[geometries.length];

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

				theGeoms[i] = NewFConverter.toJtsGeometry(((IGeometry) geometries[i]));

			}

			solution = JtsUtil.GEOMETRY_FACTORY.createGeometryCollection(theGeoms);

		} else if (fmapGeometry instanceof FMultiPoint2D) {

			solution = ((FMultiPoint2D) fmapGeometry).toJTSGeometry();

		}

		return solution;

	}

				Geometry jtsGeom = NewFConverter.toJtsGeometry(nextGeometry);

				IGeometry correctedFGeo = NewFConverter.toFMap(correctedGeom);

		Geometry jtsGeom = NewFConverter.toJtsGeometry(geometry);