Application: gvSIG desktop

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

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

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

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

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

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

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

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

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

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

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.algorithms.SnapCGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Envelope;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Polygon;

	public static boolean isClosed(Shape shape){

		return isClosed(shape, 0d);

	}

	/**

	 * Returns the dimension (0, 1, 2) of the specified

	 * geometry type.

	 * 

	 * @param shapeType

	 * @return

	 */

	public static int getDimensions(int shapeType){

		switch(shapeType){

		case FShape.ARC:

		case FShape.LINE:

			return 1;

		case FShape.CIRCLE:

		case FShape.ELLIPSE:

		case FShape.POLYGON:

		case FShape.MULTI:

			return 2;

		case FShape.MULTIPOINT:

		case FShape.POINT:

		case FShape.TEXT:

			return 0;

		default:

			return -1;

		}

	}

	/**

	 * Returns the dimension (0, 1, 2, -1 for NULL geometries)

	 * of the given geometry.

	 * 

	 * @param shape

	 * @return

	 */

	public static int getDimensions(IGeometry geometry){

		if(geometry instanceof FGeometry){

			FGeometry fgeo = (FGeometry)geometry;

			FShape fshape = (FShape) fgeo.getInternalShape();

			return getXyDimensions(fshape);

		}else if(geometry instanceof FGeometryCollection){

			FGeometryCollection fgeo = (FGeometryCollection)geometry;

			IGeometry[] geoms = fgeo.getGeometries();

			int dimension = -1;

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

				IGeometry igeo = geoms[i];

				int igeoDimension = getDimensions(igeo);

				if(igeoDimension > dimension)

					dimension = igeoDimension;

			}

			return dimension;

		}else if(geometry instanceof FMultiPoint2D){

			return 0;

		}else if(geometry instanceof FMultipoint3D){

			return 0;

		}else if(geometry instanceof FNullGeometry){

			return -1;

		}else{

			return -1;

		}

	}

	/**

	 * Returns the dimension (0, 1, 2, -1 for NULL geometries)

	 * of the given shape.

	 * 

	 * @param shape

	 * @return

	 */

	public static int getXyDimensions(FShape shape){

		if(shape instanceof FArc2D){

			return 1;

		}else if(shape instanceof FCircle2D){

			return 2;

		}else if(shape instanceof FEllipse2D){

			return 2;

		}else if(shape instanceof FPoint2D){

			return 0;

		}else if(shape instanceof FPoint3D){

			return 0;

		}else if(shape instanceof FPolygon2D){

			return 2;

		}else if(shape instanceof FPolygon3D){

			return 2;

		}else if(shape instanceof FPolyline2D){

			return 1;

		}else if (shape instanceof FPolyline3D){

			return 1;

		}else if(shape instanceof FSpline2D){

			return 1;

		}else if(shape instanceof FLiteShape ){

			FLiteShape liteShape = (FLiteShape)shape;

			Geometry jtsGeo = liteShape.getGeometry();

			return jtsGeo.getDimension();

		}else{

			return -1;

		}

	}

	//TODO Solicitar que este metodo se ponga en FConverter sustituyendo

	//al viejo

	//TODO Movemos esto a JtsUtil en vez de en esta clase????

	/*

	 * Justificacion: libTopology constituye un sistema de control de calidad geometrica de los

	 * datos. FConverter deber?a asumir que los datos le llegan adecuadamente, y si no es as?,

	 * lanzar excepciones.

	 * 

	 * La responsabilidad de detectar que un dato (FShape) no es apropiado para pasar a poligono

	 * deberia tenerla libTopology (TopologyRule), y en caso de que as? se detecte, tratar el dato

	 * de forma previa a llamar a FConverter.

	 * 

	 * 

	 * */

	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.geomFactory.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 = 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.geomFactory.createPolygon((LinearRing) shells.get(i),

					(LinearRing[]) ((ArrayList<LinearRing>) holesForShells.get(i)).toArray(new LinearRing[0]));

		}

		return JtsUtil.geomFactory.createMultiPolygon(polygons);

	}

	public static Point2D[] getCoordinatesAsPoint2D(Coordinate[] coords){

		Point2D[] solution = new Point2D[coords.length];

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

			solution[i] = new Point2D.Double(coords[i].x, coords[i].y);

		}

		return solution;

	}

	public static IGeometry createFPolygon(Point2D[] points) {

		GeneralPathX gpx = new GeneralPathX();

		gpx.moveTo(points[0].getX(), points[0].getY());

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

			gpx.lineTo(points[i].getX(), points[i].getY());

		}

		if(! isClosed(gpx)){

			gpx.closePath();

		}

		return ShapeFactory.createPolygon2D(gpx);

	}