Application: gvSIG desktop

/**

 * 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 new

 * geometries.

 * </ul>

 * @author jiyarza

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

        public final static String FROMWKT = "FromWKT";

        public final static String FROMWKB = "FromWKB";

        public final static String FROMEWKB = "FromEWKB";

        public final static String TOWKT = "ToWKT";

        public final static String TOWKB = "ToWKB";

        public final static String TOEWKB = "ToEWKB";

     * class that implements the operation. The value of this variable must be

     * set using the method

     * {@link GeometryManager#getGeometryOperationCode(String)}:<BR>

     * <pre>

     * public class MyOperation extends GeometryOperation {

     *     public static final int CODE = GeometryLocator.getGeometryManager()

     *         .getGeometryOperationCode("MyOperation");

     * }

     * </pre>

     * </p>

     * @param geomOpName

     *            Operation's unique name

     * @param geomOp

     *            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);

     * class that implements the operation. The value of this variable must be

     * set using the method

     * {@link GeometryManager#getGeometryOperationCode(String)}:<BR>

     * <pre>

     * public class MyOperation extends GeometryOperation {

     *     public static final int CODE = GeometryLocator.getGeometryManager()

     *         .getGeometryOperationCode("MyOperation");

     * }

     * </pre>

     * </p>

     * @param geomOpName

     *            Operation's unique name

     * @param geomOp

     * class that implements the operation. The value of this variable must be

     * set using the method

     * {@link GeometryManager#getGeometryOperationCode(String)}:<BR>

     * <pre>

     * public class MyOperation extends GeometryOperation {

     *     public static final int CODE = GeometryLocator.getGeometryManager()

     *         .getGeometryOperationCode("MyOperation");

     * }

     * </pre>

     * </p>

     * <p>

     * 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>

     * </p>

     * @param geomOpName

     *            Operation's unique name

     * @param geomOp

     * class that implements the operation. The value of this variable must be

     * set using the method

     * {@link GeometryManager#getGeometryOperationCode(String)}:<BR>

     * <pre>

     * public class MyOperation extends GeometryOperation {

     *     public static final int CODE = GeometryLocator.getGeometryManager()

     *         .getGeometryOperationCode("MyOperation");

     * }

     * </pre>

     * </p>

     * @param geomOpName

     *            Operation's unique name

     * @param geomOp

     */

    public int registerGeometryOperation(String geomOpName,

        GeometryOperation geomOp, int type);

    /**

     * <p>

     * Registers a GeometryOperation associated to all the geometries which

     * is used later to identify and invoke the operation.<br>

     * </p>

     * <p>

     * class that implements the operation. The value of this variable must be

     * set using the method

     * {@link GeometryManager#getGeometryOperationCode(String)}:<BR>

     * <pre>

     * public class MyOperation extends GeometryOperation {

     *     public static final int CODE = GeometryLocator.getGeometryManager()

     *         .getGeometryOperationCode("MyOperation");

     * }

     * </pre>

     * </p>

     * @param geomOpName

     *            Operation's unique name

     * @param geomOp

     */

    public int registerGeometryOperationBySuperType(String geomOpName,

        GeometryOperation geomOp, int superType);

    /**

     * <p>

     * Registers a GeometryOperation associated to all the geometries which

     * is used later to identify and invoke the operation.<br>

     * </p>

     * <p>

     * class that implements the operation. The value of this variable must be

     * set using the method

     * {@link GeometryManager#getGeometryOperationCode(String)}:<BR>

     * <pre>

     * public class MyOperation extends GeometryOperation {

     *     public static final int CODE = GeometryLocator.getGeometryManager()

     *         .getGeometryOperationCode("MyOperation");

     * }

     * </pre>

     * </p>

     * @param geomOpName

     *            Operation's unique name

     * @param geomOp

     * class that implements the operation. The value of this variable must be

     * set using the method

     * {@link GeometryManager#getGeometryOperationCode(String)}:<BR>

     * <pre>

     * public class MyOperation extends GeometryOperation {

     *     public static final int CODE = GeometryLocator.getGeometryManager()

     *         .getGeometryOperationCode("MyOperation");

     * }

     * </pre>

     * </p>

     * @param geomOpName

     *            Operation's unique name

     * @param geomOp

    /**

     * <p>

     * </p>

     * @param geometryType

     *            A {@link GeometryType} instance to create {@link Geometry} objects

     */

    public void registerGeometryType(GeometryType geometryType);

    /**

     * <p>

     * Registers a Geometry implementation class with a predefined geometry type

     * </p>

     * <p>

     * How to register a geometry class with a predefined type:

     * <pre>

     * GeometryType geomType = GeometryLocator.getGeometryManager()

     *     .registerBasicGeometryType(Point2D.class, "Point2D", Geometry.TYPES.POINT,

     *         Geometry.SYBTYPES.GEOM2D);

     * </pre>

     * </p>

     * @param geomClass

     *            Geometry subclass. It must not be null and must implement

     *            Geometry, otherwise an exception

     */

    public GeometryType registerGeometryType(Class geomClass, String name,

        int type, int subType);

    /**

     * <p>

     * Registers a Geometry implementation class with a predefined geometry type

     * and returns the associated GeometryType instance. Available predefined

     * types are defined in {@link Geometry.TYPES} and the subtypes are defined

     * </p>

     * <p>

     * It adds also the super type and the super subType of the geometry, that

     * type (or subType)

     * </p>

     * <p>

     * How to register a geometry class with a predefined type:

     * <pre>

     * GeometryType geomType = GeometryLocator.getGeometryManager()

     *     .registerBasicGeometryType(Arc3D.class, "Arc3D", Geometry.TYPES.ARC,

     *         Geometry.SYBTYPES.GEOM3D, Geometry.TYPES.CURVE, Geometry.SYBTYPES.GEOM2D);

     * </pre>

     * </p>

     * @param geomClass

     *            Geometry subclass. It must not be null and must implement

     *            Geometry, otherwise an exception

     */

    public GeometryType registerGeometryType(Class geomClass, String name,

        int type, int subType, int superType, int superSubType);

    /**

     * <p>

     * Registers a Geometry implementation class with a predefined geometry type

     * and returns the associated GeometryType instance. Available predefined

     * types are defined in {@link Geometry.TYPES} and the subtypes are defined

     * </p>

     * <p>

     * check if the type inherits of other type.

     * </p>

     * <p>

     * How to register a geometry class with a predefined type:

     * <pre>

     * GeometryType geomType = GeometryLocator.getGeometryManager()

     *     .registerBasicGeometryType(Arc3D.class, "Arc3D", Geometry.TYPES.ARC,

     *         Geometry.SYBTYPES.GEOM3D, Geometry.TYPES.CURVE);

     * </pre>

     * </p>

     * @param geomClass

     *            Geometry subclass. It must not be null and must implement

     *            Geometry, otherwise an exception

     *            {@link Geometry.SUBTYPES}

     * @param superType

     *              Super type of a geometry. Must be a value defined in

     * @return Instance of GeometryType associated to the Geometry

     *         implementation class

     *         geomClass

     */

    public GeometryType registerGeometryType(Class geomClass, String name,

        int type, int subType, int superType);

    /**

     * <p>

     * Registers a Geometry implementation class with a predefined geometry type

     * and returns the associated GeometryType instance. Available predefined

     * types are defined in {@link Geometry.TYPES} and the subtypes are defined

     * </p>

     * <p>

     * It adds also the super types and the super subTypes of the geometry, that

     * types (or subTypes)

     * </p>

     * <p>

     * How to register a geometry class with a predefined type:

     * <pre>

     * GeometryType geomType = GeometryLocator.getGeometryManager()

     *     .registerBasicGeometryType(Circle3DM.class, "Circle3DM", Geometry.TYPES.CIRCLE,

     *         Geometry.SYBTYPES.GEOM3DM,

     *         new int[]{Geometry.TYPES.CURVE, Geometry.TYPES.GEOMETRY},

     *         new int[]{Geometry.SYBTYPES.GEOM2D, Geometry.SYBTYPES.GEOM3D});

     * </pre>

     * </p>

     * @param geomClass

     *            Geometry subclass. It must not be null and must implement

     *            Geometry, otherwise an exception

     */

    public GeometryType registerGeometryType(Class geomClass, String name,

        int type, int subType, int[] superTypes, int superSubTypes[]);

    /**

     * <p>

     * Registers a Geometry implementation class with a predefined geometry type

     * and returns the associated GeometryType instance. Available predefined

     * types are defined in {@link Geometry.TYPES} and the subtypes are defined

     * </p>

     * <p>

     * It adds also the super types and the super subTypes of the geometry, that

     * </p>

     * <p>

     * How to register a geometry class with a predefined type:

     * <pre>

     * GeometryType geomType = GeometryLocator.getGeometryManager()

     *     .registerBasicGeometryType(Circle2D.class, "Circle2DM", Geometry.TYPES.CIRCLE,

     *         Geometry.SYBTYPES.GEOM2D,

     * </pre>

     * </p>

     * @param geomClass

     *            Geometry subclass. It must not be null and must implement

     *            Geometry, otherwise an exception

     * In this case the symbolic name will be the geometry's simple class name

     * </p>

     * How to register a new geometry type:

     * <pre>

     * GeometryType geomType = GeometryLocator.getGeometryManager()

     *     .registerBasicGeometryType(Point2D.class, Geometry.TYPES.POINT,

     *         Geometry.SYBTYPES.GEOM2D);

     * </pre>

     * @param geomClass

     *            Geometry implementation class. It must not be null and must

     *            implement Geometry,

     * Returns an instance of GeometryType given the Geometry type and the

     * subtype.

     * </p>

     * @param type

     *            Type of geometry. Must be a value defined in

     *            {@link Geometry.TYPES}

     * </p>

     * <p>

     * This example creates a point2D and sets the coordinates to 1,1:

     * <pre>

     * Point point =

     *     (Point) GeometryLocator.getGeometryManager().create(GEOMETRY.TYPES.POINT,

     * point.setX(1);

     * point.setY(1);

     * </pre>

     * </p>

     * @param geomType

     *            The geometry type

     * @return

     * Creates a Envelope with a concrete subtype. The envelope is empty and it

     * have to be filled with the corners once has been created.

     * </p>

     * @param subType

     *            SubType of envelope. Must be a value defined in

     *            {@link Geometry.SUBTYPES}

     * Creates a Envelope with a concrete subtype. It sets the values for the

     * lower corner and the upper corner (in 2D) using the method parameters.

     * </p>

     * @param minX

     *            The minimum value for the X coordinate.

     * @param minY

     * This example creates a point2D and sets the coordinates to 1,1: It

     * supposes that there is a Point2D class with name "Point2D".

     * </p>

     * <pre>

     * Point point = (Point) GeometryLocator.getGeometryManager().create("Point2D");

     * point.setX(1);

     * point.setY(1);

     * </pre>

     * @param name

     *            The name of the geometry type

     * @return

    /**

     * Create a geometry from a WKT definition.

     * This is a utility method to wrap the invocation to the operation

     * {@link OPERATIONS#FROMWKT}.

     * @param wkt

     *            geometry in Well-known text format

     * @return the geometry as a Geometry

     * @throws CreateGeometryException

     * @throws GeometryException

     */

    /**

     * Create a geometry from a WKB definition.

     * This is a utility method to wrap the invocation to the operation

     * {@link OPERATIONS#FROMWKB}.

     * @param wkb

     *            geometry in well-known binary format

     * @return the geometry as a Geometry

     * @throws CreateGeometryException

     * @throws GeometryException

     */

     * This example creates a point2D and sets the coordinates to 1,1. It

     * supposes that there is a Point2D class with the id 1.

     * </p>

     * <pre>

     * Point point =

     *     (Point) GeometryLocator.getGeometryManager().create(Geometry.TYPES.POINT,

     * point.setX(1);

     * point.setY(1);

     * </pre>

     * @param type

     *            Type of geometry. Must be a value defined in

     *            {@link Geometry.TYPES}

     * <p>

     * It creates a null geometry with a concrete subtype.

     * <p>

     * @param subType

     *            SubType of geometry. Must be a value defined in

     *            {@link Geometry.SUBTYPES}

     * Create a new point with a concrete type and sets the value for the X and

     * the Y.

     * </p>

     * @param x

     *            The X coordinate

     * @param y

    /**

     * Create a new line with a concrete type. Use later addVertex to add

     * @param subType SubType of geometry. Must be a value defined in {@link Geometry.SUBTYPES}

     * @return a line

     * @throws CreateGeometryException

    /**

     * Create a new polygon with a concrete type.

     * Use later addVertex to add vertex to te polygon.

     * @param subType

     *            SubType of geometry. Must be a value defined in

     *            {@link Geometry.SUBTYPES}

    /**

     * Create a new multipoint with a concrete subtype.

     * Use addPrimitive to populate the multipoint.

     * @param subType

     *            SubType of geometry. Must be a value defined in

     *            {@link Geometry.SUBTYPES}

     */

    public MultiPoint createMultiPoint(int subType)

        throws CreateGeometryException;

    /**

     * Create a new multicurve with a concrete subtype.

     * Use addPrimitive to populate the multicurve.

     * @param subType

     *            SubType of geometry. Must be a value defined in

     *            {@link Geometry.SUBTYPES}

    /**

     * Create a new multisurface with a concrete subtype.

     * Use later addPrimitive to populate.

     * @param subType

     *            SubType of geometry. Must be a value defined in

     *            {@link Geometry.SUBTYPES}

     * 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

     * GeometryManager gm = GeometryLocator.getGeometryManager()

     * GeometryOperation geomOp = null;

     * try {

     *    Geometry.SUBTYPES.GEOM2D);

     * } catch (GeometryTypeNotSupportedException gtnse) {

     *    // treat exception

     * } 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

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

     *    Object result = geomOp.invoke(myGeometries[i], ctx);

     * }

     * </pre>

     * </p>

     * @param opCode

     *            The operation code

     * @param type

     * 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

     * GeometryManager gm = GeometryLocator.getGeometryManager()

     * } catch (GeometryOperationNotSupportedException gonse) {

     *    // treat exception

     * }

     *  // Fill the operation context with required params

     * FromWKBGeometryOperationContext ctx = new FromWKBGeometryOperationContext();

     *  // Here is the main loop where you call the operation

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

     *    ctx.setData(myGeometriesWKB[i]);

     *    Object result = geomOp.invoke(null, ctx);

     * }

     * </pre>

     * </p>

     * @param opCode

     *            The operation code

     * @return Geometry operation

     * Invokes an operation given its code, the geometry and the operation

     * context holding the parameters required for the operation.

     * </p>

     * @param opCode

     *            Operation code.

     * @param geom

     * Invokes an operation given its code, the geometry and the operation

     * context holding the parameters required for the operation.

     * </p>

     * @param geomOpName

     *            Operation name.

     * @param geom

     * Invokes an operation given its code, and the operation context holding

     * the parameters required for the operation.

     * </p>

     * @param geomOpName

     *            Operation name.

     * @param ctx

     * By convention this method is used to set the value of the final and

     * static variable that is located in the classes that implements the

     * operation:<BR>

     * <pre>

     * public class MyOperation extends GeometryOperation {

     *     public static final int CODE = GeometryLocator.getGeometryManager()

     *         .getGeometryOperationCode("MyOperation");

     * }

     * </pre>

     * </p>

     * @param geomOpName

     *            Name used to register the geometry operation

     * @return

    /**

     * Returns a list with the name of the operations that have been

     * registered.

     * @return

     *         A list of the registered operations.

     */

    /**

     * Returns the flatness used to convert a curve is a set

     * of points.

     * @return

     *         The flatness.

     */

    /**

     * Sets the application flatness.

     * @param flatness

     *            The flatness to set

     */

    public void setFlatness(double flatness);

    /**

     * Create a memory spatial index with the default implementation.

     * @return a new SpatialIndex

     */

    public SpatialIndex createDefaultMemorySpatialIndex() throws ServiceException;

    /**

     * Create a spatial index with the implementation specified as name.

     * If the creation of index don't requery parameters can be passed a null.

     * @param name of the type of spatial index to create

     * @param parameters used to create the index or null.

     * @return the new SpatialIndex or null if not exists the type of index.

     */

    public SpatialIndex createSpatialIndex(String name, DynObject parameters) throws ServiceException;

    /**

     * Return the name of the factory of the spatial index required.

     * @param name of the spatial index factory

     * @return the SpatialIndexFactory required or null if not exists

     */

    public SpatialIndexFactory getSpatialIndexFactory(String name);

    /**

     * Create a GeneralPathX to populate a geometry.

     * primitive geometries or {@link MultiPrimitive#addPrimitive(org.gvsig.fmap.geom.primitive.Primitive)} to add geometries to an aggregate.

     * @param rule

     * @param pathIterator , can be null

     * @return a GeneralPathX

     * @see OrientablePrimitive#addVertex(Point) or {@link MultiPrimitive#addPrimitive(org.gvsig.fmap.geom.primitive.Primitive)}

     */

    public IGeneralPathX createGeneralPath(int rule, PathIterator pathIterator);

	 * Create a new curve with a concrete type and sets the value for the

	 * coordinates using a GeneralPathX.

	 * </p>

	 * @param generalPathX

	 *            It is used to set the values for the X and Y coordinates.

	 * @param subType

	 * @throws CreateGeometryException

	 *             This exception is thrown when the manager can not create

	 *             the geometry.

	 */

	public Curve createCurve(GeneralPathX generalPathX, int subType)

	    throws CreateGeometryException;

	/**

	 * <p>

	 * Create a new multicurve with a concrete type and sets the value for the

	 * coordinates using a GeneralPathX.

	 * </p>

	 * @param generalPathX

	 *            It is used to set the values for the X and Y coordinates.

	 * @param subType

	 */

	public MultiCurve createMultiCurve(GeneralPathX generalPathX, int subType)

	        throws CreateGeometryException;

	/**

	 * <p>

	 * Create a new surface with a concrete type and sets the value for the

	 * coordinates using a GeneralPathX.

	 * </p>

	 * @param generalPathX

	 *            It is used to set the values for the X and Y coordinates.

	 * @param subType

	 */

	public Surface createSurface(GeneralPathX generalPathX, int subType)

	    throws CreateGeometryException;

	/**

	 * <p>

	 * Create a new multisurface with a concrete type and sets the value for the

	 * coordinates using a GeneralPathX.

	 * </p>

	 * @param generalPathX

	 *            It is used to set the values for the X and Y coordinates.

	 * @param subType

	 */

	public MultiSurface createMultiSurface(GeneralPathX generalPathX,

	    int subType) throws CreateGeometryException;

}