/ - Diff - Application: gvSIG desktop - gvSIG

     /**
      * Registers the default implementation for {@link GeometryManager}.
+     *
+     *
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public class GeometryLibrary extends AbstractLibrary {
-...
+        }
         protected void doInitialize() throws LibraryException {
+        }
         protected void doPostInitialize() throws LibraryException {
             // Validate there is any implementation registered.
             if(! GeometryLocator.getInstance().exists(GeometryLocator.GEOMETRY_MANAGER_NAME)) {
                 throw new ReferenceNotRegisteredException(
                     GeometryLocator.GEOMETRY_MANAGER_NAME,
                     GeometryLocator.getInstance());
+            }
+        }
         protected void doPostInitialize() throws LibraryException {
             DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();
             dataTypesManager.addtype(DataTypes.GEOMETRY, "Geometry", "Geometry",
                 Geometry.class, null);

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * 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 3
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.fmap.geom.primitive;
     /**
      * @author fdiaz
      */
     public interface FilledSpline extends Surface{
+    }

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * 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 3
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.fmap.geom.primitive;
     public interface Circumference extends Curve {
     	/**
     	 * Sets the two values to define a circumference.
     	 * @param center
     	 * The center point of the circumference.
     	 * @param radious
     	 * A point that is used to calculate the radius.
     	 */
     	void setPoints(Point center, Point radious);
     	/**
     	 * Sets the two values to define a circumference.
     	 * @param center
     	 * The center point of the circumference.
     	 * @param radious
     	 * The radius of the circumference.
     	 */
     	void setPoints(Point center, double radious);
     	/**
     	 * Sets the values to define a circumference from three points.
     	 * @param p1
     	 * First point
     	 * @param p2
     	 * Second point
     	 * @param p3
     	 * Third point
     	 */
     	void setPoints(Point p1, Point p2, Point p3);
     	/**
     	 * Returns the center of the circumference.
     	 * @return
     	 * The center of the circumference.
     	 */
     	Point getCenter();
     	/**
     	 * Returns the radius of the circumference
     	 * @return
     	 * The radius of the circumference
     	 */
     	double getRadious();
+    }

     package org.gvsig.fmap.geom.primitive;
     import org.gvsig.fmap.geom.aggregate.MultiPoint;
     /**
      * <p>
      * This interface is equivalent to the GM_OrientablePrimitive specified in
      * This interface is equivalent to the GM_OrientablePrimitive specified in
      * <a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=26012">ISO 19107</a>.
      * Orientable primitives are those that can be mirrored into new
      * geometric objects in terms of their internal local coordinate
      * Orientable primitives are those that can be mirrored into new
      * geometric objects in terms of their internal local coordinate
      * systems (manifold charts).
      * </p>
      * <p>
      * For curves, the orientation reflects the direction in which the curve is traversed,
      * that is, the sense of its parameterization. When used as boundary curves,
      * the surface being bounded is to the "left" of the oriented curve.
      * For curves, the orientation reflects the direction in which the curve is traversed,
      * that is, the sense of its parameterization. When used as boundary curves,
      * the surface being bounded is to the "left" of the oriented curve.
      * </p>
      * <p>
      * For surfaces, the orientation reflects from which direction the local coordinate
      * system can be viewed as right handed, the "top" or the surface being the direction
      * For surfaces, the orientation reflects from which direction the local coordinate
      * system can be viewed as right handed, the "top" or the surface being the direction
      * of a completing z-axis that would form a right-handed system.
      * </p>
      * <p>
      * When used as a boundary surface, the bounded solid is "below" the surface.
      * The orientation of points and solids has no immediate geometric interpretation
      * When used as a boundary surface, the bounded solid is "below" the surface.
      * The orientation of points and solids has no immediate geometric interpretation
      * in 3-dimensional space.
      * </p>
      * <p> OrientablePrimitive objects are essentially references to geometric primitives
      * that carry an "orientation" reversal flag (either "+" or "-") that determines whether
      * <p> OrientablePrimitive objects are essentially references to geometric primitives
      * that carry an "orientation" reversal flag (either "+" or "-") that determines whether
      * this primitive agrees or disagrees with the orientation of the referenced object.
      * </p>
      * @see <a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=26012">ISO 19107</a>
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public interface OrientablePrimitive extends Primitive {
         /**
          * Gets the one of the values of a coordinate (direct position) in a
          * concrete dimension.
+         *
+         *
          * @param index
          *            The index of the direct position to set.
          * @param dimension
-...
          * @return The value of the coordinate
          */
         public double getCoordinateAt(int index, int dimension);
         /**
          * Sets the value of a coordinate (direct position) in a concrete dimension
          * @param index
-...
          * The value to set
          */
         public void setCoordinateAt(int index, int dimension, double value);
         /**
          * Adds a vertex (or direct position) to the curve
          * @param point
          * The new point to add
          */
         public void addVertex(Point point);
         /**
          * Utility method for add a vertex
          * @param x
-...
          * @see #addVertex(Point)
          */
         public void addVertex(double x, double y, double z);
         /**
          * Remove a vertex (direct position) to the curve
          * @param index
          * The index of the vertex to remove
          */
         public void removeVertex(int index);
         /**
          * Gets a vertex (direct position)
          * Gets a vertex (direct position)
          * @param index
          * The index of the vertex to get
          * @return
          * One point
          */
         public Point getVertex(int index);
         /**
          * Gets the number of vertices (direct positions) of the curve
          * @return
          * The number of vertices
          */
         public int getNumVertices();
         /**
          * Inserts a vertex (direct position) to the curve.
          * @param index
-...
          * The vertex to add.
          */
         public void insertVertex(int index, Point p);
         /**
          * Sets a vertex in a concrete position and replaces the
          * previous one that was in this position.
-...
         public void setVertex(int index, Point p);
         /**
          * Sets all the coordinates of the curve
          * Sets all the coordinates of the curve
          * @param generalPathX The generalPath that contains all the coordinates
          * @deprecated use addVertex
          */
         public void setGeneralPath(GeneralPathX generalPathX);
         /**
          * Adds a vertex (or direct position) to the curve
          * @param point
-...
          *      add an inner surface
          */
         public void addMoveToVertex(Point point);
         /**
          * Closes the geometry
          * @deprecated
-...
          *      geometry.
          */
         public void closePrimitive();
         public void ensureCapacity(int capacity);
+    }

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * 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 3
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.fmap.geom.primitive;
     /**
      * <p>
      * This class represents the perimeter o an ellipse.
      * </p>
      * @author fdiaz</a>
      */
     public interface PeriEllipse extends Curve {
     	/**
     	 * Sets the values to define a ellipse.
     	 * @param axis1Start
     	 * The point where the first axis starts.
     	 * @param axis1End
     	 * The point where the first axis ends.
     	 * @param axis2Length
     	 * The length of the second axis.
     	 */
     	void setPoints(Point axis1Start, Point axis1End, double axis2Length);
     	/**
     	 * Returns the point where the first axis starts.
     	 * @return
     	 * The point where the first axis starts.
     	 */
     	Point getAxis1Start();
     	/**
     	 * Returns the point where the first axis ends.
     	 * @return
     	 * The point where the first axis ends.
     	 */
     	Point getAxis1End();
     	/**
     	 * Returns the length of the second axis.
     	 * @return
     	 * The length of the second axis.
     	 */
     	double getAxis2Dist();
+    }

     package org.gvsig.fmap.geom.primitive;
     import org.gvsig.fmap.geom.GeometryException;
     import org.gvsig.fmap.geom.aggregate.MultiLine;
     import org.gvsig.fmap.geom.aggregate.MultiPoint;
     import org.gvsig.fmap.geom.aggregate.MultiPolygon;
     public interface Line extends Curve {
         public MultiPoint toPoints() throws GeometryException;
         public MultiLine toLines() throws GeometryException;
         public MultiPolygon toPolygons() throws GeometryException;
+    }

      */
     package org.gvsig.fmap.geom.primitive;
     import org.gvsig.fmap.geom.GeometryException;
     import org.gvsig.fmap.geom.aggregate.MultiLine;
     import org.gvsig.fmap.geom.aggregate.MultiPoint;
     import org.gvsig.fmap.geom.aggregate.MultiPolygon;
     public interface Polygon extends Surface {
         public MultiPoint toPoints() throws GeometryException;
         public MultiLine toLines() throws GeometryException;
         public MultiPolygon toPolygons() throws GeometryException;
+    }

      * outward. For closed surfaces, which have no boundary, the up direction is
      * that of the surface patches, which must be consistent with one another.
      * </p>
+     *
+     *
      * @see <a
      *      href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=26012">ISO
      *      19107</a>
-...
     	/**
     	 * Sets the appearance of the Surface
+    	 *
+    	 *
     	 * @param app
     	 *            The appearance of the surface
     	 */
-...
     	/**
     	 * Gets surface appearance
+    	 *
+    	 *
     	 * @return the surface appearance
+    	 *
+    	 *
     	 */
     	public SurfaceAppearance getSurfaceAppearance();
             public int getNumInteriorRings();
             public Ring getInteriorRing(int index);
             public void addInteriorRing(Ring ring);
             /**
              * Creates a ring from the coordinates of the line and adds it to the surface like an inner ring.
+             *
              * @param ring
              */
             public void addInteriorRing(Line line);
             /**
              * Creates a ring from the coordinates of the shell of the polygon and adds it to the surface like an inner ring.
+             *
              * @param polygon
              */
             public void addInteriorRing(Polygon polygon);
             public void removeInteriorRing(int index);
+    }

     package org.gvsig.fmap.geom.primitive;
     import org.gvsig.fmap.geom.DirectPosition;
     import org.gvsig.fmap.geom.GeometryException;
     import org.gvsig.fmap.geom.aggregate.MultiPoint;
     /**
      * <p>
      * This interface is equivalent to the GM_Point specified in
      * This interface is equivalent to the GM_Point specified in
      * <a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=26012">ISO 19107</a>.
      * It is the basic data type for a geometric object consisting
      * of one and only one point.
      * It is the basic data type for a geometric object consisting
      * of one and only one point.
      * </p>
      * @see <a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=26012">ISO 19107</a>
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public interface Point extends Primitive {
     	/**
     	 * Gets the {@link DirectPosition of a point}, that is
     	 * composed by a set of ordinates
-...
     	 * The direct position
     	 */
     	public DirectPosition getDirectPosition();
     	/**
     	 * Sets a ordinate in a concrete dimension
     	 * @param dimension
-...
         /**
          * Sets the point coordinates
+         *
+         *
          * @param value
          *            The coordinates to set
          * @deprecated Use {@link #setCoordinateAt(int, double))} instead
          */
     	void setCoordinates(double[] values);
     	/**
     	 * Sets the X coordinate
     	 * @param x
     	 * The value to set
     	 */
     	void setX(double x);
     	/**
     	 * Sets the Y coordinate
     	 * @param y
     	 * The value to set
     	 */
     	void setY(double y);
     	/**
     	 * Gets the coordinate in a concrete dimension
     	 * @param dimension
-...
          * Returns an array of coordinates. Don't use the provided array to modify
          * the point coordinates, but use the {@link #setCoordinateAt(int, double))}
          * , {@link #setX(double))} or {@link #setY(double))} methods instead.
+         *
+         *
          * @return The point coordinates
          * @deprecated Use {@link #getCoordinateAt(int)} instead
          */
     	double[] getCoordinates();
     	/**
     	 * Returns the X coordinate
     	 * Returns the X coordinate
     	 * @return
     	 * The X coordinate
     	 */
     	double getX();
     	/**
     	 * Returns the Y coordinate
     	 * Returns the Y coordinate
     	 * @return
     	 * The Y coordinate
     	 */
     	double getY();
             public MultiPoint toPoints() throws GeometryException ;
+    }

     /**
      * <p>
      * This interface is equivalent to the GM_Arc specified in
      * This interface is equivalent to the GM_Arc specified in
      * <a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=26012">ISO 19107</a>.
      * A Arc is defined by 3 points, and consists of the arc of the circle determined by the 3 points,
      * starting at the first, passing through the second and terminating at the third.
      * If the 3 points are co-linear, then the arc shall be a 3-point line string, and will
      * not be able to return values for center, radius, start angle and end angle.
      * </p>
      * A Arc is defined by 3 points, and consists of the arc of the circle determined by the 3 points,
      * starting at the first, passing through the second and terminating at the third.
      * If the 3 points are co-linear, then the arc shall be a 3-point line string, and will
      * not be able to return values for center, radius, start angle and end angle.
      * </p>
      * @see <a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=26012">ISO 19107</a>
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public interface Arc extends Curve {
     	/**
     	 * Sets the three points to define an arc.
     	 * These are three ordered points that belong to the arc
     	 * (none of them is the center of the ellipse/circle). Therefore
     	 * they must not be aligned.
+    	 *
+    	 *
     	 * @param startPoint
     	 * The start point of an arc.
          * @param midPoint
-...
     	 * The end point of an arc.
     	 * @exception IllegalArgumentException if the three points are aligned or
     	 * there is a repeated point.
+    	 *
+    	 *
     	 */
     	void setPoints(Point startPoint, Point midPoint, Point endPoint);
     	/**
     	 * Sets the values to define an arc.
     	 * @param center The center of the arc.
     	 * @param radius The radius.
     	 * @param startAngle The start angle of the arc (in radians)
     	 * @param angleExt The angular extent of the arc (in radians).
+    	 *
     	 * The sign convention is:
+    	 *
     	 * startAngle = 0 is "3 o'clock";
     	 * startAngle = (PI / 3) is "1 o'clock";
          * angleExt > 0 means "advancing clockwise";
     	 * @param angleExt The angular extent of the arc (in radians).
+    	 *
     	 * The sign convention is:
+    	 *
     	 * startAngle = 0 is "3 o'clock";
     	 * startAngle = (PI / 3) is "1 o'clock";
          * angleExt > 0 means "advancing clockwise";
          * angleExt < 0 means "advancing counterclockwise".
     	 */
     	void setPoints (Point center, double radius, double startAngle, double angleExt);
-...
          * @param center The center of the arc.
          * @param radius The radius.
          * @param startAngle The start angle of the arc (in radians)
          * @param angleExt The angular extent of the arc (in radians).
+         *
          * The sign convention is:
+         *
          * startAngle = 0 is "3 o'clock";
          * startAngle = (PI / 3) is "1 o'clock";
          * angleExt > 0 means "advancing clockwise";
          * @param angleExt The angular extent of the arc (in radians).
+         *
          * The sign convention is:
+         *
          * startAngle = 0 is "3 o'clock";
          * startAngle = (PI / 3) is "1 o'clock";
          * angleExt > 0 means "advancing clockwise";
          * angleExt < 0 means "advancing counterclockwise".
          */
         void setPointsStartExt (Point center, double radius, double startAngle, double angleExt);
         /**
          * Sets the values to define an arc. The arc will go from
          * startAngle to endAngle clockwise. Angles will be
          * normalized to ]-PI, PI] (-PI excluded) before creating
          * the arc.
+         *
          * the arc.
+         *
          * @param center The center of the arc.
          * @param radius The radius.
          * @param startAngle The start angle of the arc (in radians)
          * @param endAngle The end angle of the arc (in radians).
+         *
          * @param endAngle The end angle of the arc (in radians).
+         *
          */
         void setPointsStartEnd (Point center, double radius, double startAngle, double endAngle );
     	/**
     	 * Return the first point that has been used to create the arc.
     	 * @return
     	 * The first point of the arc.
     	 */
     	Point getInitPoint();
     	/**
     	 * Return the end point that has been used to create the arc.
     	 * @return
     	 * The end point of the arc.
     	 */
     	Point getEndPoint();
     	/**
     	 * Return the center of the arc, that is, the center of the ellipse/circle
     	 * in which the arc is based.
+    	 *
+    	 *
     	 * @return The center of the arc.
     	 */
     	Point getCenterPoint();
     	   /**
          * Return the middle point of the arc.
+         *
          * @return The middle point of the arc.
          */
         Point getMiddlePoint();
+    }

     /**
      * Geometry type for point geometries.
+     *
+     *
      * @author gvSIG Team
      */
     /**
+     *
      * This class is deprecated.
      * Use GeometryType.
+     *
      * @deprecated use GeometryType
      */
     public interface PointGeometryType extends GeometryType {
         /**
          * Creates a new point object
          * Creates a new point object
          * @param x the x coordinate of the point
          * @param y the y coordinate of the point
          * @return the new point
          */
         Point createPoint(double x, double y);
         /**
          * Creates a new point object
          * Creates a new point object
          * @param coordinates the coordinates of the point
          * @return the new point
          */

     import org.cresques.cts.ICoordTrans;
     import org.gvsig.fmap.geom.aggregate.MultiLine;
     import org.gvsig.fmap.geom.aggregate.MultiPoint;
     import org.gvsig.fmap.geom.aggregate.MultiPolygon;
     import org.gvsig.fmap.geom.handler.Handler;
     import org.gvsig.fmap.geom.operation.GeometryOperationContext;
     import org.gvsig.fmap.geom.operation.GeometryOperationException;
-...
     		 * NO DATA geometry.
     		 */
     		public final static int NULL = 16;
                     public final static int COMPLEX = 17;
             public final static int COMPLEX = 17;
     		public final static int LINE = 18;
     		public final static int POLYGON = 19;
+    	}
     		public final static int RING = 20;
             public final static int MULTILINE = 21;
             public final static int MULTIPOLYGON = 22;
             public final static int CIRCUMFERENCE = 23;
             public final static int PERIELLIPSE = 24;
             public final static int FILLEDSPLINE = 25;
+    }
     	public interface DIMENSIONS {
     		public final static int X = 0;
     		public final static int Y = 1;
-...
     	 * The subtype of a geometry is related with the dimension of the geometry,
     	 * that is a combination between the spatial dimension (2D, 2ZD, 3D) and the
     	 * M coordinate or "measure".
+    	 *
+    	 *
     	 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
     	 */
     	public interface SUBTYPES {
-...
                 /**
                  * True if the geoemtry are valid.
+                 *
+                 *
                  * @return true form valid geometries
                  */
                 public boolean isValid();
                 /**
                  * Return the status code results of validate the geometry.
+                 *
+                 *
                  * @return validation code
                  */
                 public int getStatusCode();
                 /**
                  * Return the nearest point to the problem when validate the geometry.
+                 *
+                 *
                  * If the geometry is valid, this return null.
+                 *
+                 *
                  * @return the nearest point to the problem or null.
                  */
                 public Point getProblemLocation();
                 /**
                  * Return a human readable message explaining the cause of the problem.
+                 *
+                 *
                  * If the geometry is valid this is null.
+                 *
+                 *
                  * @return the message cause of the problem.
                  */
                 public String getMessage();
+            }
             public static int BEST = 0;
     	/**
     	 * North.
-...
     	 * constant that identifies its type. By convention this value is stored in
     	 * a constant called .CODE within the geometry class, for instance:
     	 * Point2D.CODE.
+    	 *
+    	 *
     	 * @return If this geometry is a predefined interface then one of
     	 *         {@link Geometry.TYPES} or a runtime constant if it is an extended
     	 *         type.
-...
     	/**
     	 * Creates a clone of this geometry.
+    	 *
+    	 *
     	 * @return A clone of this geometry.
     	 */
     	public Geometry cloneGeometry();
-...
     	/**
     	 * Returns true if this geometry intersects the rectangle passed as
     	 * parameter.
+    	 *
+    	 *
     	 * @param r
     	 *            Rectangle.
+    	 *
+    	 *
     	 * @return True, if <code>this</code> intersects <code>r</code>.
     	 */
     	public boolean intersects(Rectangle2D r);
-...
     	/**
     	 * Used by the drawing strategies to quickly test whether this geometry
     	 * intersects with the visible rectangle.
+    	 *
+    	 *
     	 * @param x
     	 *            The minimum X coordinate.
     	 * @param y
-...
     	 * one containing all the minimums for each ordinate, and second one
     	 * containing all the maximums.
     	 * </p>
+    	 *
+    	 *
     	 * @return The minimum bounding box for this Geometry.
     	 */
     	public Envelope getEnvelope();
-...
     	/**
     	 * Reprojects this geometry by the coordinate transformer passed as
     	 * parameter.
+    	 *
+    	 *
     	 * @param ct
     	 *            Coordinate Transformer.
     	 */
-...
     	 * If parameter value is null, it will be considered an
     	 * empty transformation, therefore equivalent to the identity
     	 * transformation.
+    	 *
+    	 *
     	 * @param at
     	 *            The transformation to apply.
     	 */
-...
     	 * geometric set can be associated with a subset that has the direct
     	 * position in its interior and is similar (isomorphic) to Rn, Euclidean
     	 * n-space.
+    	 *
+    	 *
     	 * @return The dimension.
     	 */
     	public int getDimension();
-...
     	 * means that every point in the interior of the object must have a metric
     	 * neighborhood whose intersection with the object is isomorphic to an
     	 * n-sphere, where n is the dimension of this Geometry.
+    	 *
+    	 *
     	 * @return If the geometry is simple.
     	 */
     	public boolean isSimple();
-...
     	/**
     	 * Invokes a geometry operation given its index and context.
+    	 *
+    	 *
     	 * @param index
     	 *            Unique index of the operation. Operation code.
     	 * @param ctx
-...
     	/**
     	 * Invokes a geometry operation given its name and context.
+    	 *
+    	 *
     	 * @param opName
     	 *            Operation name.
     	 * @param ctx
-...
     	/**
     	 * Instance of the GeometryType associated to this geometry.
+    	 *
+    	 *
     	 * @return The geometry type.
     	 */
     	public GeometryType getGeometryType();
     	/**
     	 * Return a byte array with the equivalent in WKB format of the Geometry.
+    	 *
+    	 *
     	 * Utility method to wrap the invocation to the operation
     	 * {@link OPERATIONS#CONVERTTOWKB}.
+    	 *
+    	 *
     	 * @return the WKB version of the geometry
     	 */
     	public byte[] convertToWKB() throws GeometryOperationNotSupportedException,
     		GeometryOperationException;
     	public byte[] convertToWKB(int srs)
     	public byte[] convertToWKB(int srs)
     		throws GeometryOperationNotSupportedException, GeometryOperationException;
     	public byte[] convertToWKBForcingType(int srs, int type)
     	public byte[] convertToWKBForcingType(int srs, int type)
     		throws GeometryOperationNotSupportedException, GeometryOperationException;
     	/**
     	 * Return a string with the equivalent in WKT format of the Geometry.
+    	 *
+    	 *
     	 * This is a utility method to wrap the invocation to the operation
     	 * {@link OPERATIONS#CONVERTTOWKT}.
+    	 *
+    	 *
     	 * @return the WKT version of the geometry.
+    	 *
+    	 *
     	 * @throws GeometryOperationNotSupportedException
     	 * @throws GeometryOperationException
     	 */
-...
     	/**
     	 * Computes a buffer area around this geometry having the given width
+    	 *
+    	 *
     	 * This is a utility method to wrap the invocation to the operation
     	 * {@link OPERATIONS#BUFFER}.
+    	 *
+    	 *
     	 * @param distance
     	 *            the width of the buffer
+    	 *
+    	 *
     	 * @return a new Geometry with the computed buffer.
+    	 *
+    	 *
     	 * @throws GeometryOperationNotSupportedException
     	 * @throws GeometryOperationException
     	 */
-...
     	/**
     	 * Tests whether this geometry contains the specified geometry.
+    	 *
+    	 *
     	 * This is a utility method to wrap the invocation to the operation
     	 * {@link OPERATIONS#CONTAINS}.
+    	 *
+    	 *
     	 * @param geometry
     	 *            the Geometry with which to compare this Geometry
+    	 *
+    	 *
     	 * @return if this Geometry contains the specified geometry
+    	 *
+    	 *
     	 * @throws GeometryOperationNotSupportedException
     	 * @throws GeometryOperationException
     	 */
-...
     	/**
     	 * Returns the minimum distance between this Geometry and the specified
     	 * geometry.
+    	 *
+    	 *
     	 * This is a utility method to wrap the invocation to the operation
     	 * {@link OPERATIONS#DISTANCE}.
+    	 *
+    	 *
     	 * @param geometry
     	 *            the Geometry from which to compute the distance
+    	 *
+    	 *
     	 * @return the distance between the geometries
+    	 *
+    	 *
     	 * @throws GeometryOperationNotSupportedException
     	 * @throws GeometryOperationException
     	 */
-...
     	public Geometry[] closestPoints(Geometry other)
     			throws GeometryOperationNotSupportedException,
     			GeometryOperationException;
     	boolean isWithinDistance(Geometry other, double distance)
     	boolean isWithinDistance(Geometry other, double distance)
     			throws GeometryOperationNotSupportedException,
     			GeometryOperationException;
     	/**
     	 * Tests whether this geometry overlaps the specified geometry.
+    	 *
+    	 *
     	 * This is a utility method to wrap the invocation to the operation
     	 * {@link OPERATIONS#OVERLAPS}.
+    	 *
+    	 *
     	 * @param geometry
     	 *            the Geometry with which to compare this Geometry
+    	 *
+    	 *
     	 * @return true if the two geometries overlap.
+    	 *
+    	 *
     	 * @throws GeometryOperationNotSupportedException
     	 * @throws GeometryOperationException
     	 */
-...
     	public boolean coveredBy(Geometry geometry)
     			throws GeometryOperationNotSupportedException,
     			GeometryOperationException;
             public boolean covers(Geometry geometry)
     			throws GeometryOperationNotSupportedException,
     			GeometryOperationException;
     	public boolean crosses(Geometry geometry)
     			throws GeometryOperationNotSupportedException,
     			GeometryOperationException;
-...
     	public Geometry snapTo(Geometry other, double snapTolerance)
     			throws GeometryOperationNotSupportedException,
     			GeometryOperationException;
     	public boolean touches(Geometry geometry)
     			throws GeometryOperationNotSupportedException,
     			GeometryOperationException;
-...
     			GeometryOperationException;
     	public Point centroid() throws GeometryOperationNotSupportedException, GeometryOperationException;
     	/**
     	 * This method returns a point which is inside the geometry.
     	 * This is useful for mathematical purposes but it is very unlikely
     	 * to be a suitable place for a label, for example.
+    	 *
+    	 *
+    	 *
+    	 *
     	 * @return an interior point
     	 * @throws GeometryOperationNotSupportedException
     	 * @throws GeometryOperationException
-...
     	public Point getInteriorPoint() throws GeometryOperationNotSupportedException, GeometryOperationException;
     	public double area() throws GeometryOperationNotSupportedException, GeometryOperationException;
     	public double perimeter() throws GeometryOperationNotSupportedException, GeometryOperationException;
     	/**
     	 * Rotates the geometry by radAngle radians using the given
     	 * coordinates as center of rotation. Rotating with a positive
-...
     	 * positive y axis. In most cases, we assume x increases
     	 * rightwards and y increases upwards, so in most cases,
     	 * a positive angle will mean counter-clockwise rotation.
+    	 *
+    	 *
     	 * @param radAngle the amount of rotation, in radians
     	 * @param basex x coordinate of center of rotation
     	 * @param basey y coordinate of center of rotation
     	 */
     	public void rotate(double radAngle, double basex, double basey);
     	/**
     	 * Shifts geometry by given amount in x and y axes
+    	 *
     	 * @param dx
+    	 *
     	 * @param dx
     	 * @param dy
     	 */
     	public void move(double dx, double dy);
     	/**
     	 * Scales geometry in x and y axes by given scale factors
     	 * using the given point as center of projection.
+    	 *
+    	 *
     	 * @param basePoint
     	 * @param sx scale factor in x axis
     	 * @param sy scale factor in y axis
     	 */
     	public void scale(Point basePoint, double sx, double sy);
             /**
              * Check if the geometry is valid.
+             *
+             *
              * @return true if the geometry is valid.
              */
     	public boolean isValid();
             /**
              * Check if the geometry is valid and returns the validation status.
+             *
              * @return the ValidationStatus
+             *
              * @return the ValidationStatus
              */
     	public ValidationStatus getValidationStatus();
-...
              * Try to fix the geometry and return the new geometry.
              * If the geometry is valid return the same geometry.
              * If the geometry is corrupt or can't fix it, return null.
+             *
+             *
              * @return the new fixed geometry
              */
             public Geometry makeValid();
     	//
     	// ===============================================
     	//
     	/**
          * @return  the awt shape used to display the geometry. It
          * @return  the awt shape used to display the geometry. It
          * applies a tranformation before to return the coordinates
          * of the shape
          * @deprecated this class inherits of {@link Shape} by historical
-...
          * the {@link Shape} class but it will removed in a future.
          */
     	public Shape getShape(AffineTransform affineTransform);
     	/**
          * @return  the awt shape used to display the geometry.
          * @return  the awt shape used to display the geometry.
          * @deprecated this class inherits of {@link Shape} by historical
          * reasons. This method has been added just to control the usage of
          * the {@link Shape} class but it will removed in a future.
-...
     	/**
     	 * Returns this geometry's boundary rectangle.
+    	 *
+    	 *
     	 * @deprecated use getEnvelope.
     	 * @return Boundary rectangle.
     	 */
-...
     	/**
     	 * If applies an affine transformation and returns the GeneralPathXIterator
     	 * with this geometry's information.
+    	 *
+    	 *
     	 * @param at
     	 *            The transformation to apply.
     	 * @return The GeneralPathXIterator with this geometry's information.
     	 * @deprecated don't use PathIterator over geometries, use instead specific API for each operation. If not has API for that operation let the project team.
+    	 *
+    	 *
     	 */
     	public PathIterator getPathIterator(AffineTransform at);
     	/**
     	 * It returns the handlers of the geometry, these they can be of two types
     	 * is straightening and of selection.
+    	 *
+    	 *
     	 * @param type
     	 *            Type of handlers.
+    	 *
+    	 *
     	 * @deprecated don't use Handlers over geometries, use instead specific API for each operation. If not has API for that operation let the project team.
     	 * @return The handlers.
     	 */
-...
     	/**
     	 * If applies an affine transformation and returns the GeneralPathXIterator
     	 * with this geometry's information.
+    	 *
+    	 *
     	 * @param at
     	 *            The affine transformation.
     	 * @param flatness
+    	 *
+    	 *
     	 * @return The GeneralPathXIterator with this geometry's information.
     	 * @deprecated don't use PathIterator over geometries, use instead specific API for each operation. If not has API for that operation let the project team.
     	 */
-...
     	/**
     	 * Useful to have the real shape behind the scenes. May be uses to edit it
     	 * knowing it it is a Circle, Ellipse, etc.
+    	 *
+    	 *
     	 * @return The awt shape
     	 * @deprecated
     	 */
-...
     	/**
     	 * Get GeneralPathIterator, to do registered operations to it.
+    	 *
+    	 *
     	 * @return The GeneralPathX.
     	 * @deprecated don't use GeneralPathX over geometries, use instead specific API for each operation. If not has API for that operation let the project team.
     	 */
     	public GeneralPathX getGeneralPath();
     	/**
     	 * Converts the geometry to be points and makes with them a multiPoint
+    	 *
     	 * @return MultiPoint
     	 * @throws GeometryException
     	 */
         public MultiPoint toPoints() throws GeometryException;
         /**
          * Converts the geometry to be lines and makes with them a multiLine
          * @return
          * @throws GeometryException
          */
         public MultiLine toLines() throws GeometryException;
         /**
          * Converts the geometry to be polygons and makes with them a multiPolygon
          * @return
          * @throws GeometryException
          */
         public MultiPolygon toPolygons() throws GeometryException;
         public void flip() throws GeometryOperationNotSupportedException, GeometryOperationException;
         public boolean ensureOrientation(boolean ccw) throws GeometryOperationNotSupportedException, GeometryOperationException;
         public boolean out(Geometry geometry) throws GeometryOperationNotSupportedException, GeometryOperationException;
+    }

      * @author jjdelcerro
      */
     public interface MultiLine extends MultiCurve {
         public MultiPoint toPoints() throws GeometryException;
         public MultiLine toLines() throws GeometryException;
         public MultiPolygon toPolygons() throws GeometryException;
+    }

      * @author jjdelcerro
      */
     public interface MultiPolygon extends MultiSurface {
         public MultiPoint toPoints() throws GeometryException;
         public MultiLine toLines() throws GeometryException;
         public MultiPolygon toPolygons() throws GeometryException;
+    }

       <modelVersion>4.0.0</modelVersion>
       <artifactId>org.gvsig.fmap.geometry</artifactId>
       <packaging>pom</packaging>
       <packaging>pom</packaging>
       <name>${project.artifactId}</name>
       <parent>
           <groupId>org.gvsig</groupId>
           <artifactId>org.gvsig.desktop.compat.cdc</artifactId>
           <version>2.0.103-SNAPSHOT</version>
       </parent>
       </parent>
       <modules>
         <module>org.gvsig.fmap.geometry.api</module>
         <module>org.gvsig.fmap.geometry.generalpath</module>
         <module>org.gvsig.fmap.geometry.operation</module>
         <!-- <module>org.gvsig.fmap.geometry.generalpath</module>
         <module>org.gvsig.fmap.geometry.operation</module> -->
         <module>org.gvsig.fmap.geometry.jts</module>
         <module>org.gvsig.fmap.geometry.operation.jts</module>
       </modules>
       <description>This project contains the geometry library used in gvSIG. </description>

          * @see org.gvsig.fmap.geom.primitive.OrientablePrimitive#addVertex(double, double)
          */
         public void addVertex(double x, double y) {
             double m = 0;
             if(coordinates.size()>0){
                 MCoordinate coordinateAnt = (MCoordinate) coordinates.get(coordinates.size()-1);
                 m = coordinateAnt.m + coordinateAnt.distance(JTSUtils.createMCoordinate(x, y, coordinateAnt.m));
+            }
             this.addVertex(new Point2DM(x, y, m));
             this.addVertex(new Point2DM(x, y, 0));
+        }
         /* (non-Javadoc)

          * @see org.gvsig.fmap.geom.primitive.OrientablePrimitive#addVertex(double, double, double)
          */
         public void addVertex(double x, double y, double z) {
             double m = 0;
             if (coordinates.size() > 0) {
                 MCoordinate coordinateAnt = (MCoordinate) coordinates.get(coordinates.size() - 1);
                 m = coordinateAnt.m + coordinateAnt.distance(JTSUtils.createMCoordinate(x, y, coordinateAnt.m));
+            }
             this.coordinates.add(new Point3DM(x, y, z, m).getJTSCoordinate());
             this.coordinates.add(new Point3DM(x, y, z, 0).getJTSCoordinate());
+        }
         /* (non-Javadoc)

Application: gvSIG desktop

Revision 42309