/ - Diff - Application: gvSIG desktop - gvSIG

     /**
      * This singleton provides a centralized access to gvSIG's Geometry Model.
      * Its responsibilities are:<br>
+     *
+     *
      * <ul>
      * <li>Offering a set of convenient methods for registering and retrieving geometry types.
      * <li>Offering a set of convenient methods for registering and retrieving geometry operations associated
      * <li>Offering a set of convenient methods for registering and retrieving geometry operations associated
      * to one or more geometry types.
      * <li><code>TODO:</code> Offering a set of convenient methods for registering and retrieving custom
      * <li><code>TODO:</code> Offering a set of convenient methods for registering and retrieving custom
      * geometry factories.
      * <ul>
+     *
+     *
      * @author jiyarza
+     *
      */
     public class GeometryManager {
     	private static Logger logger = Logger.getLogger(GeometryManager.class);
     	private static GeometryManager instance;
     	/** This list holds the unique name of all registered geometry operations.
     	/** This list holds the unique name of all registered geometry operations.
     	 * The index in which they are stored is also the operation code used to invoke each one of them */
     	private List geometryOperations = new ArrayList();
     	/** Common operations are registered here. Type specific operations are registered in the corresponding GeometryType instance */
     	/** Common operations are registered here. Type specific operations are registered in the corresponding GeometryType instance */
     	private List commonOperations = new ArrayList();
     	/** Common operations are assigned an index greater or equal than this constant, so that it is easy and efficient for the manager
     	/** Common operations are assigned an index greater or equal than this constant, so that it is easy and efficient for the manager
     	 * to decide whether to lookup in the common register or in the type specific register. */
     	private static final int COMMON_OPS_OFFSET = 1000;
     	/** This map holds the instances of all registered GeometryType. The key is the name of the specific Geometry subclass.
     	 * In other words, the string "org.gvsig.fmap.geom.primitive.Point2D" is the hash key to obtain an instance of GeometryType holding the
     	/** This map holds the instances of all registered GeometryType. The key is the name of the specific Geometry subclass.
     	 * In other words, the string "org.gvsig.fmap.geom.primitive.Point2D" is the hash key to obtain an instance of GeometryType holding the
     	 * operations associated to the class org.gvsig.fmap.geom.primitive.Point2D.
     	 */
     	private Map geometryTypes = new HashMap();
     	/** GeometryType index counter. Each time a new geometry type is registered it is assigned this counter's value as index and after that
     	/** GeometryType index counter. Each time a new geometry type is registered it is assigned this counter's value as index and after that
     	 * it is incremented by 1 */
     	private int geomTypeIndex = 10000;
     	private int geomTypeIndex = 65536;//2^16
     	/**
     	 * Geometry Factory
     	 */
     	private GeometryFactory factory = new GeometryFactory();
     	/**
     	 * Singleton's private constructor
     	 */
-...
     	public void registerGeometryFactory(GeometryFactory factory) {
     		this.factory = factory;
+    	}
     	/**
     	 * Returns the current geometry factory
     	 * @return
-...
     	public GeometryFactory getGeometryFactory() {
     		return factory;
+    	}
     	/**
     	 * Registers the unique name of one operation. If it already exists then this method does nothing but returning
     	 * the name's corresponding index.
     	 * Registers the unique name of one operation. If it already exists then this method does nothing but returning
     	 * the name's corresponding index.
     	 * @param geomOpName Name used to register the geometry operation
     	 * @return index assigned to the operation name passed as parameter
     	 */
-...
+    		}
     		return index;
+    	}
     	/**
     	 * Sets a common operation into the common operations map.
     	 * Sets a common operation into the common operations map.
     	 * @param index index in which to set the operation
     	 * @param geomOp operation to be set
     	 */
     	private void setCommonOperation(int index, GeometryOperation geomOp) {
     		while (index > commonOperations.size()) {
     			commonOperations.add(null);
+    		}
     		if (index == commonOperations.size()) {
     			commonOperations.add(geomOp);
     		} else {
     		} else {
     			commonOperations.set(index, geomOp);
+    		}
+    	}
+    	}
     	/**
     	 * Registers a GeometryOperation associated to a GeometryType.
     	 * Registers a GeometryOperation associated to a GeometryType.
     	 * Returns an unique index that is used later to identify and invoke the operation.
+    	 *
+    	 *
     	 * This method is only used if you already got a reference to the GeometryType. If not,
     	 * it is more convenient to use the method that receives the geometry class as parameter.
+    	 *
     	 * By convention, the return value should be stored in a public constant within the class implementing
     	 * the operation:<BR>
     	 * it is more convenient to use the method that receives the geometry class as parameter.
+    	 *
     	 * By convention, the return value should be stored in a public constant within the class implementing
     	 * the operation:<BR>
     	 * <pre>
     	 * public class MyOperation extends GeometryOperation {
     	 *   public static final int CODE =
     	 *   public static final int CODE =
     	 *     GeometryManager.getInstance()
     	 *        .registerGeometryOperation("MyOperation", new MyOperation(), geomType);
     	 * }
-...
     	 * @param geomOp Specific GeometryOperation's instance implementing this operation
     	 * @param geomType GeometryType instance to which this operation should be associated
     	 * @return Index assigned to this operation. This index is used later to access the operation.
+    	 *
+    	 *
     	 */
     	public int registerGeometryOperation(String geomOpName,
     			GeometryOperation geomOp, GeometryType geomType) {
-...
     			throw new IllegalArgumentException("geomType cannot be null.");
     		int index = registerGeometryOperationName(geomOpName);
     		geomType.setGeometryOperation(index, geomOp);
     		return index;
+    	}
     	/**
     	 * Registers a GeometryOperation that is common for all GeometryType (registered yet or not)
     	 * Registers a GeometryOperation that is common for all GeometryType (registered yet or not)
     	 * Returns an unique index that is used later to identify and invoke the operation.
+    	 *
     	 * By convention, the return value should be stored in a public constant within the class implementing
     	 * the operation:<BR>
+    	 *
     	 * By convention, the return value should be stored in a public constant within the class implementing
     	 * the operation:<BR>
     	 * <pre>
     	 * public class MyOperation extends GeometryOperation {
     	 *   public static final int CODE =
     	 *   public static final int CODE =
     	 *     GeometryManager.getInstance()
     	 *        .registerGeometryOperation("MyOperation", new MyOperation());
     	 * }
     	 * </pre>
+    	 *
+    	 *
     	 * @param geomOpName Operation's unique name
     	 * @param geomOp Specific GeometryOperation's instance implementing this operation
     	 * @return Index assigned to this operation. This index is used later to access the operation.
     	 * @return Index assigned to this operation. This index is used later to access the operation.
     	 */
     	public int registerGeometryOperation(String geomOpName,
     			GeometryOperation geomOp) {
-...
     		int index = registerGeometryOperationName(geomOpName);
     		setCommonOperation(index, geomOp);
     		return index + COMMON_OPS_OFFSET;
+    	}
     	/**
     	 * Registers a GeometryOperation associated to a GeometryType.
     	 * Registers a GeometryOperation associated to a GeometryType.
     	 * Returns an unique index that is used later to identify and invoke the operation.<br>
+    	 *
     	 * By convention, the return value should be stored in a public constant within the class implementing
     	 * the operation:<BR>
+    	 *
     	 * By convention, the return value should be stored in a public constant within the class implementing
     	 * the operation:<BR>
     	 * <pre>
     	 * public class MyOperation extends GeometryOperation {
     	 *   public static final int CODE =
     	 *   public static final int CODE =
     	 *     GeometryManager.getInstance()
     	 *        .registerGeometryOperation("MyOperation", new MyOperation(), MyGeometry.class);
     	 * }
     	 * </pre>
+    	 *
+    	 *
     	 * This method is only used if you have not a reference to the GeometryType associated to the
     	 * geometry class. If you have such reference then it is slightly faster to use the method that receives
     	 * the GeometryType.<br>
+    	 *
+    	 *
     	 * @param geomOpName Operation's unique name
     	 * @param geomOp Specific GeometryOperation's instance implementing this operation
     	 * @param geomClass Geometry implementation class
     	 * @return Index assigned to this operation. This index is used later to access the operation.
     	 */
     	 */
     	public int registerGeometryOperation(String geomOpName,
     			GeometryOperation geomOp, Class geomClass) {
     		GeometryType geomType = getGeometryType(geomClass);
     		return registerGeometryOperation(geomOpName, geomOp, geomType);
+    	}
     	/**
     	 * Registers a GeometryOperation associated to a GeometryType.
     	 * Registers a GeometryOperation associated to a GeometryType.
     	 * Returns an unique index that is used later to identify and invoke the operation.<br>
+    	 *
     	 * By convention, the return value should be stored in a public constant within the class implementing
     	 * the operation:<BR>
+    	 *
     	 * By convention, the return value should be stored in a public constant within the class implementing
     	 * the operation:<BR>
     	 * <pre>
     	 * public class MyOperation extends GeometryOperation {
     	 *   public static final int CODE =
     	 *   public static final int CODE =
     	 *     GeometryManager.getInstance()
     	 *        .registerGeometryOperation("MyOperation", MyOperation.class, myGeomType);
     	 * }
-...
     	public int registerGeometryOperation(String geomOpName, Class geomOpClass,
     			GeometryType geomType)
     			throws IllegalAccessException, InstantiationException {
     		GeometryOperation geomOp = (GeometryOperation) geomOpClass.newInstance();
     		return registerGeometryOperation(geomOpName, geomOp, geomType);
     		GeometryOperation geomOp = (GeometryOperation) geomOpClass.newInstance();
     		return registerGeometryOperation(geomOpName, geomOp, geomType);
+    	}
     	/**
     	 * Registers a Geometry implementation class as a new geometry type and returns the
     	 * Registers a Geometry implementation class as a new geometry type and returns the
     	 * associated GeometryType instance. If the class is already registered
     	 * then this method does nothing but returning the associated GeometryType.<br>
+    	 *
+    	 *
     	 * How to register a new geometry type:
     	 * <pre>
+    	 *
+    	 *
     	 * public class MyGeom3D implements Solid {
     	 *   private static final GeometryType geomType = GeometryManager.getInstance()
     	 *	   .registerGeometryType(MyGeom3D.class, "MyGeom3D");
+    	 *
+    	 *
     	 *   public static final int .CODE = geomType.getType();
     	 * ...
     	 *   public int getType() {
-...
     	 *   }
     	 * }
     	 * </pre>
+    	 *
+    	 *
     	 * @param geomClass
     	 *            Geometry subclass. It must not be null and must implement Geometry, otherwise an exception
     	 *            Geometry subclass. It must not be null and must implement Geometry, otherwise an exception
     	 *            is raised.
     	 * @param name
     	 * 			  Symbolic name for the geometry type, it can be null. If it is null then the symbolic name
     	 * 			  Symbolic name for the geometry type, it can be null. If it is null then the symbolic name
     	 * 		      will be the simple class name.
     	 * @return Instance of GeometryType associated to the Geometry implementation class
     	 *         geomClass
-...
     			throw new IllegalArgumentException("Attempt to register a geometry type that is already registered: " + geomClass.getName());
+    		}
     		logger.debug("Class " + geomType.getGeometryClass().getName() + " registered with name " + geomType.getName());
     		return geomType;
+    	}
     	/**
     	 * Registers a Geometry implementation as a new geometry type and returns the
     	 * Registers a Geometry implementation as a new geometry type and returns the
     	 * associated GeometryType instance. If the class is already registered
     	 * then this method does nothing but returning the associated GeometryType.<br>
+    	 *
+    	 *
     	 * In this case the symbolic name will be the geometry's simple class name
+    	 *
+    	 *
     	 * How to register a new geometry type:
     	 * <pre>
+    	 *
+    	 *
     	 * public class MyGeom3D implements Solid {
     	 *   private static final GeometryType geomType = GeometryManager.getInstance()
     	 *	   .registerGeometryType(MyGeom3D.class);
+    	 *
+    	 *
     	 *   public static final int .CODE = geomType.getType();
     	 * ...
     	 *   public int getType() {
-...
     	 *   }
     	 * }
     	 * </pre>
+    	 *
+    	 *
     	 * @param geomClass
     	 *            Geometry implementation class. It must not be null and must implement Geometry,
     	 *            Geometry implementation class. It must not be null and must implement Geometry,
     	 *            otherwise an exception is thrown.
     	 * @return Instance of GeometryType associated to the Geometry implementation class
     	 * @throws IllegalArgumentException
-...
     		return registerGeometryType(geomClass, null);
+    	}
     	/**
     	 * Returns an instance of GeometryType given the associated Geometry implementation
     	 * Returns an instance of GeometryType given the associated Geometry implementation
     	 * class.
+    	 *
+    	 *
     	 * @param geomClass
     	 * @return Instance of GeometryType associated to the Geometry implementation class
     	 */
-...
     	/**
     	 * Returns the associated GeometryType given the fully qualified name of
     	 * the Geometry implementation class.
+    	 *
+    	 *
     	 * @param className
     	 *            Fully qualified name of the Geometry implementation class
     	 * @return GeometryType associated to the class
-...
+    	}
     	/**
     	 * Returns an operation given the Geometry implementation class and the operation
     	 * Returns an operation given the Geometry implementation class and the operation
     	 * code. If opCode corresponds to a common operation (a common operation is an operation
     	 * registered for all geometries), then this method returns the common operation.
     	 * <br>
     	 * For better performance, if you need to call an operation multiple times,
     	 * use this method only once and keep the returned object in a local variable
     	 * For better performance, if you need to call an operation multiple times,
     	 * use this method only once and keep the returned object in a local variable
     	 * over which you can iterate. For instance:
+    	 *
+    	 *
     	 * <pre>
     	 * ...
     	 *  // Get the operation you need
-...
     	 * } catch (GeometryOperationNotSupportedException gonse) {
     	 *    // treat exception
     	 * }
+    	 *
+    	 *
     	 *  // Fill the operation context with required params
     	 * GeometryOperationContext ctx = new GeometryOperationContext();
+    	 *
     	 *  // Here is the main loop where you call the operation
+    	 *
     	 *  // Here is the main loop where you call the operation
     	 * for (int i=0; i<MyGeometries.length; i++) {
     	 *    Object result = geomOp.invoke(myGeometries[i], ctx);
     	 * }
+    	 *
+    	 *
     	 * </pre>
+    	 *
+    	 *
     	 * @param geomClass
     	 * @param opCode
     	 * @return Geometry operation
     	 */
     	public GeometryOperation getGeometryOperation(Class geomClass, int opCode) throws GeometryTypeNotSupportedException, GeometryOperationNotSupportedException {
     		GeometryOperation geomOp = null;
     		GeometryOperation geomOp = null;
     		// Check if it is a common operation, and if so, get it from the common registry
     		if (opCode >= COMMON_OPS_OFFSET) {
     			geomOp = ((GeometryOperation)commonOperations.get(opCode - COMMON_OPS_OFFSET));
     			if (geomOp == null) {
     				throw new GeometryOperationNotSupportedException(opCode);
+    			}
     		} else {
     			// If it is type specific, get it from its type	registry
     			// If it is type specific, get it from its type	registry
     			if (geomClass != null) {
     				GeometryType geomType = getGeometryType(geomClass);
     				// If the geometry type is not registered, throw an exception
     				if (geomType == null) {
     					throw new GeometryTypeNotSupportedException(geomClass);
+    				}
     				// Get the operation
     				geomOp = geomType.getGeometryOperation(opCode);
     				// If the operation is not registered throw an exception
     				if (geomOp == null) {
     					throw new GeometryOperationNotSupportedException(opCode, geomType);
+    				}
+    				}
+    			}
+    		}
+    		}
     		return geomOp;
+    	}
     	/**
     	 * Invokes an operation given its code, the geometry and the operation context holding the
     	 * Invokes an operation given its code, the geometry and the operation context holding the
     	 * parameters required for the operation.
+    	 *
+    	 *
     	 * @param opCode Operation code.
     	 * @param geom Geometry to which apply the operation
     	 * @param ctx Context holding the operation parameters
     	 * @return The object returned by an operation, depends on each operation.
     	 * @return The object returned by an operation, depends on each operation.
     	 */
     	public Object invokeOperation(int opCode, Geometry geom, GeometryOperationContext ctx) throws GeometryOperationNotSupportedException, GeometryOperationException {
     		GeometryOperation geomOp = null;
     		if (opCode < COMMON_OPS_OFFSET) {
     			geomOp =  geom.getGeometryType().getGeometryOperation(opCode);
     		} else {
     			geomOp = ((GeometryOperation)commonOperations.get(opCode - COMMON_OPS_OFFSET));
+    		}
     		if (geomOp != null) {
     			return geomOp.invoke(geom, ctx);
+    		}
     		throw new GeometryOperationNotSupportedException(opCode, geom.getGeometryType());
+    	}
+    }

     package org.gvsig.fmap.geom.primitive;
     import org.gvsig.fmap.geom.Geometry;
     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
-...
      */
     public interface Surface extends OrientableSurface {
     	/** This predefined geometry's type */
     	public static final int CODE = Geometry.TYPES.SURFACE;
     	public static final int CODE = TYPES.SURFACE;
+    }

     /**
      * Polilinea 3D.
+     *
+     *
      * @author Vicente Caballero Navarro
      */
     public class Surface2DZ extends Surface2D implements Surface {
-...
     	private static GeometryType geomType = GeometryManager.getInstance()
     			.registerGeometryType(Surface2DZ.class);
     	public static int CODE = geomType.getType();
     	public static int CODE = TYPES.SURFACE | TYPES.Z;//geomType.getType();
     	double[] pZ = null;
     	/**
     	 * Crea un nuevo Polyline3D.
+    	 *
+    	 *
     	 * @param gpx
     	 *            GeneralPathX.
     	 * @param pZ
-...
     	/**
     	 * Clona FPolygon3D.
+    	 *
+    	 *
     	 * @return FShape clonado.
     	 */
     	public FShape cloneFShape() {
-...
     	/**
     	 * Devuelve un array con los valores de todas las Z.
+    	 *
+    	 *
     	 * @return Array de Zs.
     	 */
     	public double[] getZs() {

     	private static GeometryType geomType = GeometryManager.getInstance()
     			.registerGeometryType(Curve2D.class);
     	public static int CODE = geomType.getType();
     	public static int CODE = TYPES.CURVE;//geomType.getType();
     	public Curve2D(String id, IProjection projection, GeneralPathX gpx) {
     		super(id, projection, gpx);

     /**
      * DOCUMENT ME!
+     *
+     *
      * @author Vicente Caballero Navarro
      */
     public class Ellipse2D extends Surface2D implements Surface {
-...
     	private static GeometryType geomType = GeometryManager.getInstance()
     			.registerGeometryType(Ellipse2D.class);
     	public static int CODE = geomType.getType();
     	public static int CODE = TYPES.ELLIPSE;//geomType.getType();
     	private Point2D init;
     	private Point2D end;
-...
     	/**
     	 * DOCUMENT ME!
+    	 *
+    	 *
     	 * @param gpx
     	 */
     	public Ellipse2D(String id, IProjection projection, GeneralPathX gpx,
-...
     	/*
     	 * (non-Javadoc)
+    	 *
+    	 *
     	 * @see com.iver.cit.gvsig.fmap.core.FShape#cloneFShape()
     	 */
     	public FShape cloneFShape() {
-...
     	/**
     	 * DOCUMENT ME!
+    	 *
+    	 *
     	 * @param at
     	 *            DOCUMENT ME!
     	 */
-...
     	/**
     	 * DOCUMENT ME!
+    	 *
+    	 *
     	 * @return DOCUMENT ME!
     	 */
     	public Handler[] getStretchingHandlers() {
-...
     	/**
     	 * DOCUMENT ME!
+    	 *
+    	 *
     	 * @author Vicente Caballero Navarro
     	 */
     	class CenterHandler extends AbstractHandler implements Handler {
     		/**
     		 * Crea un nuevo PointHandler.
+    		 *
+    		 *
     		 * @param i
     		 *            DOCUMENT ME!
     		 * @param x
-...
     		/**
     		 * DOCUMENT ME!
+    		 *
+    		 *
     		 * @param x
     		 *            DOCUMENT ME!
     		 * @param y
     		 *            DOCUMENT ME!
+    		 *
+    		 *
     		 * @return DOCUMENT ME!
     		 */
     		public void move(double x, double y) {
-...
     	/**
     	 * DOCUMENT ME!
+    	 *
+    	 *
     	 * @author Vicente Caballero Navarro
     	 */
     	class CenterSelHandler extends AbstractHandler implements Handler {
     		/**
     		 * Crea un nuevo PointHandler.
+    		 *
+    		 *
     		 * @param i
     		 *            DOCUMENT ME!
     		 * @param x
-...
     		/**
     		 * DOCUMENT ME!
+    		 *
+    		 *
     		 * @param x
     		 *            DOCUMENT ME!
     		 * @param y
     		 *            DOCUMENT ME!
+    		 *
+    		 *
     		 * @return DOCUMENT ME!
     		 */
     		public void move(double x, double y) {
-...
     	/**
     	 * DOCUMENT ME!
+    	 *
+    	 *
     	 * @author Vicente Caballero Navarro
     	 */
     	class InitSelHandler extends AbstractHandler implements CuadrantHandler {
     		/**
     		 * Crea un nuevo PointHandler.
+    		 *
+    		 *
     		 * @param i
     		 *            DOCUMENT ME!
     		 * @param x
-...
     		/**
     		 * DOCUMENT ME!
+    		 *
+    		 *
     		 * @param x
     		 *            DOCUMENT ME!
     		 * @param y
     		 *            DOCUMENT ME!
+    		 *
+    		 *
     		 * @return DOCUMENT ME!
     		 */
     		public void move(double x, double y) {
-...
     	/**
     	 * DOCUMENT ME!
+    	 *
+    	 *
     	 * @author Vicente Caballero Navarro
     	 */
     	class EndSelHandler extends AbstractHandler implements CuadrantHandler {
     		/**
     		 * Crea un nuevo PointHandler.
+    		 *
+    		 *
     		 * @param i
     		 *            DOCUMENT ME!
     		 * @param x
-...
     		/**
     		 * DOCUMENT ME!
+    		 *
+    		 *
     		 * @param x
     		 *            DOCUMENT ME!
     		 * @param y
     		 *            DOCUMENT ME!
+    		 *
+    		 *
     		 * @return DOCUMENT ME!
     		 */
     		public void move(double x, double y) {
-...
     	/**
     	 * DOCUMENT ME!
+    	 *
+    	 *
     	 * @author Vicente Caballero Navarro
     	 */
     	class RadioSelYHandler extends AbstractHandler implements CuadrantHandler {
     		/**
     		 * Crea un nuevo PointHandler.
+    		 *
+    		 *
     		 * @param i
     		 *            DOCUMENT ME!
     		 * @param x
-...
     		/**
     		 * DOCUMENT ME!
+    		 *
+    		 *
     		 * @param x
     		 *            DOCUMENT ME!
     		 * @param y
     		 *            DOCUMENT ME!
+    		 *
+    		 *
     		 * @return DOCUMENT ME!
     		 */
     		public void move(double x, double y) {
-...
     	/*
     	 * (non-Javadoc)
+    	 *
+    	 *
     	 * @see com.iver.cit.gvsig.fmap.core.FPolyline2D#intersects(java.awt.geom.Rectangle2D)
     	 */
     	public boolean intersects(Rectangle2D r) {

     package org.gvsig.fmap.geom.primitive;
     import org.gvsig.fmap.geom.Geometry;
     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
-...
      * @author Jorge Piera Llodr? (jorge.piera@iver.es)
      */
     public interface Curve extends OrientableCurve{
     	/** This predefined geometry's type */
     	public static final int CODE = Geometry.TYPES.CURVE;
     	public static final int CODE = TYPES.CURVE;
+    }

     	private static GeometryType geomType = GeometryManager.getInstance()
     			.registerGeometryType(NullGeometry.class);
     	public static int CODE = geomType.getType();
     	public static int CODE = TYPES.NULL;//geomType.getType();
     	public NullGeometry() {
-...
     		// TODO Auto-generated method stub
     		return null;
+    	}
+    }

     	private static GeometryType geomType = GeometryManager.getInstance()
     			.registerGeometryType(Circle2D.class);
     	public static int CODE = geomType.getType();
     	public static int CODE = TYPES.CIRCLE;//geomType.getType();
     	private Point2D center;
     	private double radio;

     	private static GeometryType geomType = GeometryManager.getInstance()
     	.registerGeometryType(Arc2D.class);
     	public static int CODE = geomType.getType();
     	public static int CODE = TYPES.ARC;//geomType.getType();
     	private Point2D init;
     	private Point2D center;

     package org.gvsig.fmap.geom.primitive;
     import org.gvsig.fmap.geom.Geometry;
     public interface Circle extends Arc {
     	/** This predefined geometry's type */
     	public static final int CODE = Geometry.TYPES.CIRCLE;
     	public static final int CODE = TYPES.CIRCLE;
+    }

     /**
      * Polilinea 3D.
+     *
+     *
      * @author Vicente Caballero Navarro
      */
     public class Curve2DZ extends Curve2D implements Curve {
-...
     	private static GeometryType geomType = GeometryManager.getInstance()
     			.registerGeometryType(Curve2DZ.class);
     	public static int CODE = geomType.getType();
     	public static int CODE = TYPES.CURVE | TYPES.Z;//geomType.getType();
     	double[] pZ = null;
     	/**
     	 * Crea un nuevo Polyline3D.
+    	 *
+    	 *
     	 * @param gpx
     	 *            GeneralPathX
     	 * @param pZ
-...
     	/**
     	 * Devuelve un Array con todos los valores de Z.
+    	 *
+    	 *
     	 * @return Array de Zs.
     	 */
     	public double[] getZs() {
-...
     	/*
     	 * (non-Javadoc)
+    	 *
+    	 *
     	 * @see com.iver.cit.gvsig.fmap.core.FShape#cloneFShape()
     	 */
     	public FShape cloneFShape() {

     package org.gvsig.fmap.geom.primitive;
     import org.gvsig.fmap.geom.Geometry;
     public interface Arc extends Curve {
     	/** This predefined geometry's type */
     	public static final int CODE = Geometry.TYPES.ARC;
     	public static final int CODE = TYPES.ARC;
+    }

     public class Point2DZ extends Point2D implements Point{
     	private static final long serialVersionUID = 1L;
     	private static GeometryType geomType = GeometryManager.getInstance()
     		.registerGeometryType(Point2DZ.class);
     	public static int CODE = geomType.getType();
     	public static int CODE = TYPES.POINT | TYPES.Z;//geomType.getType();
     	double z;
     	/**
-...
     		super(id, projection, x, y);
     		this.z = z;
+    	}
     	public Point2DZ(double x, double y, double z) {
     		this(null, null, x, y, z);
+    	}
-...
     	public int getCoordinateDimension() {
     		return 3;
+    	}
     	public GeometryType getGeometryType() {
     		return geomType;
+    	}

     /**
      * Pol�gono 2D.
+     *
+     *
      * @author Vicente Caballero Navarro
      */
     public class Surface2D extends OrientableSurface2D implements Surface {
     	private static final long serialVersionUID = 1L;
     	private GeneralPathX generalpathx;
     	private static GeometryType geomType = GeometryManager.getInstance()
     			.registerGeometryType(Surface2D.class);
     	public static int CODE = geomType.getType();
     	public static int CODE = TYPES.SURFACE;//geomType.getType();
     	/**
     	 * Crea un nuevo Polygon2D.
+    	 *
+    	 *
     	 * @param gpx
     	 *            GeneralPathX.
     	 */
-...
     	/**
     	 * Clona FPolygon2D.
+    	 *
+    	 *
     	 * @return FShape clonado.
     	 */
     	public FShape cloneFShape() {
-...
     	/*
     	 * (non-Javadoc)
+    	 *
+    	 *
     	 * @see java.awt.Shape#intersects(java.awt.geom.Rectangle2D)
     	 */
     	public boolean intersects(Rectangle2D r) {
     		return gp.intersects(r);
+    	}
     	public GeometryType getGeometryType() {
     		return geomType;
+    	}
     	public int getType() {
     		return CODE;
+    	}
-...
     	public GeneralPathX getGeneralPath() {
     		// TODO Auto-generated method stub
     		return generalpathx;
+    	}
+    	}
+    }

     import org.cresques.cts.ICoordTrans;
     import org.cresques.cts.IProjection;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.handler.AbstractHandler;
     import org.gvsig.fmap.geom.handler.FinalHandler;
-...
     	private static final GeometryType geomType = GeometryManager.getInstance()
     			.registerGeometryType(Point2D.class);
     	public static final int CODE = geomType.getType();
     	public static final int CODE = TYPES.POINT;//geomType.getType();
     	/**

Application: gvSIG desktop

Revision 21731