Application: gvSIG desktop

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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 2

 * 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.jts.primitive.curve.spline;

import java.awt.Shape;

import java.awt.geom.AffineTransform;

import java.awt.geom.PathIterator;

import java.util.Collections;

import java.util.Iterator;

import com.vividsolutions.jts.geom.Coordinate;

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.jts.primitive.point.Point2D;

import org.gvsig.fmap.geom.jts.primitive.point.PointJTS;

import org.gvsig.fmap.geom.jts.util.ArrayListCoordinateSequence;

import org.gvsig.fmap.geom.jts.util.JTSUtils;

import org.gvsig.fmap.geom.jts.util.ReadOnlyCoordinates;

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

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.OrientablePrimitive;

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

/**

 * @author fdiaz

 *

 */

public abstract class AbstractSpline extends AbstractCurve {

    /**

     *

     */

    private static final long serialVersionUID = -1562503359430991082L;

    protected ArrayListCoordinateSequence coordinates;

    protected PointJTS anyVertex;

    protected static final double SUBSEGMENTS = 30.0;

    /**

     * @param type

     * @param subtype

     */

    public AbstractSpline(int type, int subtype) {

        super(type, subtype);

    }

    /**

    *

     * @param type

     * @param subtype

     * @param coordinates

     * @param aVertex

    */

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

       this(type, subtype);

       this.coordinates = new ArrayListCoordinateSequence(new ReadOnlyCoordinates(coordinates));

       anyVertex = aVertex;

   }

    @Override

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

        return JTSUtils.createJTSLineString(getSplineCoordinates());

    }

    protected abstract ArrayListCoordinateSequence getSplineCoordinates();

    static class Spline {

        private final double y[];

        private final double y2[];

        /**

         * The constructor calculates the second derivatives of the interpolating function

         * at the tabulated points xi, with xi = (i, y[i]).

         * Based on numerical recipes in C, http://www.library.cornell.edu/nr/bookcpdf/c3-3.pdf .

         * @param y Array of y coordinates for cubic-spline interpolation.

         */

        public Spline(double y[]) {

            this.y = y;

            int n = y.length;

            y2 = new double[n];

            double u[] = new double[n];

            for (int i = 1; i < n - 1; i++) {

                y2[i] = -1.0 / (4.0 + y2[i - 1]);

                u[i] = (6.0 * (y[i + 1] - 2.0 * y[i] + y[i - 1]) - u[i - 1]) / (4.0 + y2[i - 1]);

            }

            for (int i = n - 2; i >= 0; i--) {

                y2[i] = y2[i] * y2[i + 1] + u[i];

            }

        }

        /**

         * Returns a cubic-spline interpolated value y for the point between

         * point (n, y[n]) and (n+1, y[n+1), with t ranging from 0 for (n, y[n])

         * to 1 for (n+1, y[n+1]).

         * @param n The start point.

         * @param t The distance to the next point (0..1).

         * @return A cubic-spline interpolated value.

         */

        public double fn(int n, double t) {

            return t * y[n + 1] - ((t - 1.0) * t * ((t - 2.0) * y2[n] - (t + 1.0) * y2[n + 1])) / 6.0 + y[n] - t * y[n];

        }

    }

    public OrientablePrimitive addVertex(Point point) {

        point = fixPoint(point);

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

        anyVertex = (PointJTS) point;

        return (OrientablePrimitive) this;

    }

    public void setPoints(Point initialPoint, Point endPoint) {

        initialPoint = fixPoint(initialPoint);

        endPoint = fixPoint(endPoint);

        coordinates.clear();

        addVertex(initialPoint);

        addVertex(endPoint);

        anyVertex = (PointJTS) endPoint;

    }

    /**

     * @param point

     * @return

     */

    protected abstract Point fixPoint(Point point);

    public double getCoordinateAt(int index, int dimension) {

        return coordinates.getOrdinate(index, dimension);

    }

    public OrientablePrimitive setCoordinateAt(int index, int dimension, double value) {

        coordinates.setOrdinate(index, dimension, value);

        return (OrientablePrimitive) this;

    }

    public void removeVertex(int index) {

        coordinates.remove(index);

    }

    public int getNumVertices() {

        return coordinates.size();

    }

    public OrientablePrimitive insertVertex(int index, Point p) {

        p = fixPoint(p);

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

        return (OrientablePrimitive) this;

    }

    public OrientablePrimitive setVertex(int index, Point p) {

        p = fixPoint(p);

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

        return (OrientablePrimitive) this;

    }

    public void setGeneralPath(GeneralPathX generalPathX) {

        PathIterator it = generalPathX.getPathIterator(null);

        double[] segment = new double[6];

        int i = 0;

        while(!it.isDone()){

            int type = it.currentSegment(segment);

            if(i==0){

                switch (type) {

                case IGeneralPathX.SEG_MOVETO:

                    Point p = new Point2D(segment[0], segment[1]);

                    p = fixPoint(p);

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

                    break;

                default:

                    String message = StringUtils.replace("Type of segment %(segment)s isn't SEG_MOVETO.","%(segment)s",String.valueOf(i));

                    logger.warn(message);

                    throw new RuntimeException(message);

                }

            } else {

                //Dudo de que los casos SEG_QUADTO y SEG_CUBICTO est?n bien pero se hac?a lo mismo en la librer?a de geometr?as vieja.

                Point p;

                switch (type) {

                case IGeneralPathX.SEG_LINETO:

                    p = new Point2D(segment[0], segment[1]);

                    p = fixPoint(p);

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

                    break;

                case IGeneralPathX.SEG_QUADTO:

                    for (int j = 0; j <= 1; j++) {

                        p = new Point2D(segment[i], segment[i+1]);

                        p = fixPoint(p);

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

                    }

                    break;

                case IGeneralPathX.SEG_CUBICTO:

                    for (int j = 0; j <= 2; j++) {

                        p = new Point2D(segment[i], segment[i+1]);

                        p = fixPoint(p);

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

                    }

                    break;

                case IGeneralPathX.SEG_CLOSE:

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

                    break;

                default:

                    String message = StringUtils.replace("The general path has a gap in segment %(segment)s.","%(segment)s",String.valueOf(i));

                    logger.warn(message);

                    throw new RuntimeException(message);

                }

            }

            it.next();

            i++;

        }

    }

    public void addMoveToVertex(Point point) {

        throw new UnsupportedOperationException();

    }

    public void closePrimitive() {

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

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

        }

    }

    public OrientablePrimitive ensureCapacity(int capacity) {

        coordinates.ensureCapacity(capacity);

        return (OrientablePrimitive) this;

    }

    @Override

    public void reProject(ICoordTrans ct) {

        if (ct == null) {

            return;

        }

        ArrayListCoordinateSequence tmpCoordinates = new ArrayListCoordinateSequence();

        tmpCoordinates.ensureCapacity(coordinates.size());

        for (Coordinate coordinate : coordinates) {

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

            try {

                p = ct.convert(p, p);

                coordinate.x = p.getX();

                coordinate.y = p.getY();

                tmpCoordinates.add(coordinate);

            } catch (Exception exc) {

                /*

                * This can happen when the reprojection lib is unable

                * to reproject (for example the source point

                * is out of the valid range and some computing

                * problem happens)

                */

            }

        }

        coordinates=tmpCoordinates;

        this.setProjection(ct.getPDest());

    }

    @Override

    public void transform(AffineTransform at) {

        if (at == null) {

            return;

        }

        for (Coordinate coordinate : coordinates) {

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

            at.transform(p, p);

            coordinate.x = p.getX();

            coordinate.y = p.getY();

        }

    }

    @Override

    public int getDimension() {

        return anyVertex.getDimension();

    }

    @Override

    public Shape getShape(AffineTransform affineTransform) {

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

    }

    @Override

    public Shape getShape() {

        return getShape(null);

    }

    @Override

    public PathIterator getPathIterator(AffineTransform at) {

        SplineIterator pi = new SplineIterator(at);

        return pi;

    }

    @Override

    public PathIterator getPathIterator(AffineTransform at, double flatness) {

        return getPathIterator(at);

    }

    @Override

    public GeneralPathX getGeneralPath() {

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

    }

    public class SplineIterator extends GeneralPathXIterator {

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

        private final AffineTransform at;

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

        private boolean done;

        private int index = 0;

        /**

         * Creates a new PointIterator object.

         * @param at

         *            The affine transform applied to coordinates during

         *            iteration

         */

        public SplineIterator(AffineTransform at) {

            super(new GeneralPathX());

            if (at == null) {

                at = new AffineTransform();

            }

            this.at = at;

            done = false;

        }

        /**

         * Return the winding rule for determining the interior of the path.

         *

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

         */

        @Override

        public int getWindingRule() {

            return PathIterator.WIND_EVEN_ODD;

        }

        @Override

        public void next() {

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

        }

        @Override

        public boolean isDone() {

            return done;

        }

        @Override

        public int currentSegment(double[] coords) {

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

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

            coords[1] = jtsCoordinates[index].y;

            at.transform(coords, 0, coords, 0, 1);

            if (index == 0) {

                return PathIterator.SEG_MOVETO;

            } else {

                return PathIterator.SEG_LINETO;

            }

        }

        @Override

        public int currentSegment(float[] coords) {

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

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

            coords[1] = (float)jtsCoordinates[index].y;

            at.transform(coords, 0, coords, 0, 1);

            if (index == 0) {

                return PathIterator.SEG_MOVETO;

            } else {

                return PathIterator.SEG_LINETO;

            }

        }

    }

    @Override

    public boolean is3D() {

        return anyVertex.is3D();

    }

    @Override

    public void flip() throws GeometryOperationNotSupportedException, GeometryOperationException {

        Collections.reverse(coordinates);

    }

    protected ArrayListCoordinateSequence cloneCoordinates() {

        ArrayListCoordinateSequence cloned = new ArrayListCoordinateSequence();

        cloned.ensureCapacity(coordinates.size());

        for (Coordinate coordinate : coordinates) {

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

        }

        return cloned;

    }

    @Override

    public Geometry force2D() throws GeometryOperationNotSupportedException, GeometryOperationException {

        ArrayListCoordinateSequence coordinates2D = new ArrayListCoordinateSequence();

        coordinates2D.ensureCapacity(coordinates.size());

        for (Coordinate coordinate : coordinates) {

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

        }

        Spline2D s = new Spline2D(coordinates2D);

        s.setProjection(this.getProjection());

        return s;

    }

    protected boolean isClosed(){

        return coordinates.get(0).equals(coordinates.get(coordinates.size()-1));

    }

    @Override

    public boolean canBeTransformed(AffineTransform at) {

        return true;

    }

    @Override

    public boolean canBeReprojected(ICoordTrans ct) {

        return true;

    }

}