Application: gvSIG desktop

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.jts.gputils.DefaultGeneralPathX;

import org.gvsig.fmap.geom.jts.gputils.GeneralPathXIterator;

import org.gvsig.fmap.geom.jts.primitive.curve.AbstractCurve;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.GeneralPathX;

import org.gvsig.fmap.geom.primitive.IGeneralPathX;

import org.gvsig.fmap.geom.primitive.Point;

     */

    private static final long serialVersionUID = -1562503359430991082L;

    protected ArrayListCoordinateSequence coordinates;

    protected PointJTS anyVertex;

    protected static final double SUBSEGMENTS = 30.0;

    /**

    *

    */

   public AbstractSpline(int type, int subtype, Coordinate[] coordinates, PointJTS aVertex) {

       this(type, subtype);

       anyVertex = aVertex;

   }

    public com.vividsolutions.jts.geom.Geometry getJTS() {

        return JTSUtils.createJTSLineString(getSplineCoordinates());

    }

    static class Spline {

        /**

         * The constructor calculates the second derivatives of the interpolating function

    }

        point = fixPoint(point);

        coordinates.add(((PointJTS) point).getJTSCoordinate());

        anyVertex = (PointJTS) point;

    }

    public void setPoints(Point initialPoint, Point endPoint) {

        initialPoint = fixPoint(initialPoint);

        endPoint = fixPoint(endPoint);

    }

    /**

     * @return

     */

    protected abstract Point fixPoint(Point point);

    public double getCoordinateAt(int index, int dimension) {

        return coordinates.getOrdinate(index, dimension);

    }

        coordinates.setOrdinate(index, dimension, value);

    }

    public void removeVertex(int index) {

        coordinates.remove(index);

    }

    public int getNumVertices() {

        return coordinates.size();

    }

        p = fixPoint(p);

        coordinates.add(index, ((PointJTS) p).getJTSCoordinate());

    }

        p = fixPoint(p);

        coordinates.set(index, ((PointJTS) p).getJTSCoordinate());

    }

    public void setGeneralPath(GeneralPathX generalPathX) {

        PathIterator it = generalPathX.getPathIterator(null);

        }

    }

    public void addMoveToVertex(Point point) {

        throw new UnsupportedOperationException();

    }

    public void closePrimitive() {

        if (!coordinates.isEmpty() && !isClosed()) {

            coordinates.add((Coordinate)coordinates.get(0).clone());

        }

    }

        coordinates.ensureCapacity(capacity);

    }

    public void reProject(ICoordTrans ct) {

        if (ct == null) {

            return;

        }

        ArrayListCoordinateSequence tmpCoordinates = new ArrayListCoordinateSequence();

        tmpCoordinates.ensureCapacity(coordinates.size());

            java.awt.geom.Point2D p = new java.awt.geom.Point2D.Double(coordinate.x, coordinate.y);

            try {

                p = ct.convert(p, p);

                tmpCoordinates.add(coordinate);

            } catch (Exception exc) {

                /*

            }

        }

        coordinates=tmpCoordinates;

        this.setProjection(ct.getPDest());

    }

    public void transform(AffineTransform at) {

        if (at == null) {

            return;

        }

            java.awt.geom.Point2D p = new java.awt.geom.Point2D.Double(coordinate.x, coordinate.y);

            at.transform(p, p);

        }

    }

    public int getDimension() {

        return anyVertex.getDimension();

    }

    public Shape getShape(AffineTransform affineTransform) {

        return new DefaultGeneralPathX(new SplineIterator(affineTransform),false,0);

    }

    public Shape getShape() {

        return getShape(null);

    }

    public PathIterator getPathIterator(AffineTransform at) {

        SplineIterator pi = new SplineIterator(at);

        return pi;

    }

    public PathIterator getPathIterator(AffineTransform at, double flatness) {

        return getPathIterator(at);

    }

    public GeneralPathX getGeneralPath() {

        return new DefaultGeneralPathX(new SplineIterator(null),false,0);

    }

    public class SplineIterator extends GeneralPathXIterator {

        /** Transform applied on the coordinates during iteration */

        /** True when the point has been read once */

        private boolean done;

        /**

         * Creates a new PointIterator object.

         * @param at

         *            The affine transform applied to coordinates during

         *            iteration

         *

         * @return <code>WIND_EVEN_ODD</code> by default.

         */

        public int getWindingRule() {

            return PathIterator.WIND_EVEN_ODD;

        }

        public void next() {

            done = (getJTS().getCoordinates().length == ++index);

        }

        public boolean isDone() {

            return done;

        }

        public int currentSegment(double[] coords) {

            Coordinate[] jtsCoordinates = getJTS().getCoordinates();

            coords[0] = jtsCoordinates[index].x;

            }

        }

        public int currentSegment(float[] coords) {

            Coordinate[] jtsCoordinates = getJTS().getCoordinates();

            coords[0] = (float)jtsCoordinates[index].x;

    }

    public boolean is3D() {

        return anyVertex.is3D();

    }

    public void flip() throws GeometryOperationNotSupportedException, GeometryOperationException {

        Collections.reverse(coordinates);

    }

    protected ArrayListCoordinateSequence cloneCoordinates() {

        ArrayListCoordinateSequence cloned = new ArrayListCoordinateSequence();

        cloned.ensureCapacity(coordinates.size());

            cloned.add((Coordinate)coordinate.clone());

        }

        return cloned;

    public Geometry force2D() throws GeometryOperationNotSupportedException, GeometryOperationException {

        ArrayListCoordinateSequence coordinates2D = new ArrayListCoordinateSequence();

        coordinates2D.ensureCapacity(coordinates.size());

            coordinates2D.add(new Coordinate(coordinate.x, coordinate.y));

        }

        Spline2D s = new Spline2D(coordinates2D);