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

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateSequence;

import java.awt.Shape;

import java.awt.geom.AffineTransform;

import java.awt.geom.GeneralPath;

import java.awt.geom.PathIterator;

import java.util.Collections;

import java.util.Iterator;

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.mgeom.MCoordinate;

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

import org.gvsig.tools.util.GetItem;

import org.gvsig.tools.util.Size;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author fdiaz

 *

 */

public abstract class AbstractLine extends AbstractCurve implements Size, GetItem<Point> {

    /**

     *

     */

    private static final long serialVersionUID = 5034197096871344597L;

    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractLine.class);

    protected ArrayListCoordinateSequence coordinates;

    public class VertexIterator implements Iterator<Point> {

        private final PointJTS vertex;

        private int current;

        public VertexIterator() {

            this.current = 0;

            if( getNumVertices()>0 ) {

                this.vertex = (PointJTS) getVertex(0).cloneGeometry();

            } else {

                this.vertex = null;

            }

        }

        @Override

        public boolean hasNext() {

            return this.current < getNumVertices() ;

        }

        @Override

        public Point next() {

            this.vertex.setJTSCoordinate(coordinates.get(current) );

            this.current++;

            return this.vertex;

        }

        @Override

        public void remove() {

            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

        }

    }

    /**

    *

     * @param subtype

    */

    protected AbstractLine(int subtype) {

        super(Geometry.TYPES.LINE, subtype);

    }

    /**

     * @param type

     * @param subtype

     */

    public AbstractLine(int type, int subtype) {

        super(type, subtype);

    }

    @Override

    abstract public Point getVertex(int index);

    public Iterator<Point> iterator() {

        return new VertexIterator();

    }

    @Override

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

        return JTSUtils.createJTSLineString(coordinates);

    }

    @Override

    public OrientablePrimitive addVertex(Point point) {

        point = fixPoint(point);

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

        return (OrientablePrimitive) this;

    }

    public void setPoints(Point initialPoint, Point endPoint) {

        initialPoint = fixPoint(initialPoint);

        endPoint = fixPoint(endPoint);

        coordinates.clear();

        addVertex(initialPoint);

        addVertex(endPoint);

    }

    /**

     * @param point

     * @return

     */

    protected abstract Point fixPoint(Point point);

    @Override

    public double getCoordinateAt(int index, int dimension) {

        return coordinates.getOrdinate(index, dimension);

    }

    @Override

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

        coordinates.setOrdinate(index, dimension, value);

        return (OrientablePrimitive) this;

    }

    @Override

    public void removeVertex(int index) {

        coordinates.remove(index);

    }

    @Override

    public boolean isEmpty() {

        return coordinates==null || coordinates.isEmpty();

    }

    @Override

    public int getNumVertices() {

        if( isEmpty() ) {

            return 0;

        }

        return coordinates.size();

    }

    @Override

    public OrientablePrimitive insertVertex(int index, Point p) {

        p = fixPoint(p);

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

        return (OrientablePrimitive) this;

    }

    @Override

    public OrientablePrimitive setVertex(int index, Point p) {

        p = fixPoint(p);

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

        return (OrientablePrimitive) this;

    }

    @Override

    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:

                    if(!coordinates.get(0).equals(coordinates.get(coordinates.size()-1))){

                        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++;

        }

    }

    @Override

    public void addMoveToVertex(Point point) {

        notifyDeprecated("Calling deprecated metohd addMoveToVertex in Line");

        throw new UnsupportedOperationException();

    }

    @Override

    public void closePrimitive() {

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

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

        }

    }

    @Override

    public OrientablePrimitive ensureCapacity(int capacity) {

        this.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 (int i = 0; i < coordinates.size(); i++) {

            Coordinate coordinate = coordinates.get(i);

            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 this.getGeometryType().getDimension();

    }

    @Override

    public Shape getShape(AffineTransform affineTransform) {

        if( this.isEmpty() ) {

            // Esto no deberia de pasar, se trataria de una geometria

            // corrupta.

            return new GeneralPath();

        }

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

    }

    @Override

    public Shape getShape() {

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

    }

    @Override

    public PathIterator getPathIterator(AffineTransform at) {

        LineIterator pi = new LineIterator(at);

        return pi;

    }

    @Override

    public PathIterator getPathIterator(AffineTransform at, double flatness) {

        return getPathIterator(at);

    }

    @Override

    public GeneralPathX getGeneralPath() {

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

    }

    protected class LineIterator 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 LineIterator(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;

        }

        /**

         * @see java.awt.geom.PathIterator#next()

         */

        @Override

        public void next() {

            done = (coordinates.size() == ++index);

        }

        /**

         * @return 

         * @see java.awt.geom.PathIterator#isDone()

         */

        @Override

        public boolean isDone() {

            return done;

        }

        /**

         * @param coords

         * @return 

         * @see java.awt.geom.PathIterator#currentSegment(double[])

         */

        @Override

        public int currentSegment(double[] coords) {

            coords[0] = coordinates.getX(index);

            coords[1] = coordinates.getY(index);

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

            if (index == 0) {

                return PathIterator.SEG_MOVETO;

            } else {

                return PathIterator.SEG_LINETO;

            }

        }

        /*

         * (non-Javadoc)

         *

         * @see java.awt.geom.PathIterator#currentSegment(float[])

         */

        @Override

        public int currentSegment(float[] coords) {

            coords[0] = (float) coordinates.getX(index);

            coords[1] = (float) coordinates.getY(index);

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

            if (index == 0) {

                return PathIterator.SEG_MOVETO;

            } else {

                return PathIterator.SEG_LINETO;

            }

        }

    }

    @Override

    public boolean is3D() {

        int subtype = this.getGeometryType().getType();

        return subtype == Geometry.SUBTYPES.GEOM3D || subtype == Geometry.SUBTYPES.GEOM3DM;

    }

//    protected boolean isClosed(){

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

//    }

    @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 boolean canBeTransformed(AffineTransform at) {

        return true;

    }

    @Override

    public boolean canBeReprojected(ICoordTrans ct) {

        return true;

    }

    public boolean isClosed() {

        return this.isClosed(0);

    }

    public boolean isClosed(double tolerance) {

        int numVertices = this.getNumVertices();

        switch( numVertices ) {

            case 0:

            case 1:

            case 2:

                return false;

        }

        if( tolerance<0 ) {

            tolerance = 0.000001;

        }

        double[] first = this.getVertex(0).getCoordinates();

        double[] last = this.getVertex(numVertices-1).getCoordinates();

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

                if (Math.abs(first[i] - last[i]) > tolerance) {

                        return false;

                }

        }

        return true;

    }

    public void forceClose(double tolerance) {

        Point first;

        int numVertices = this.getNumVertices();

        switch( numVertices ) {

            case 0:

                return;

            case 1:

                first = this.getVertex(0);

                this.addVertex((Point) first.cloneGeometry());

                this.addVertex((Point) first.cloneGeometry());

                return;

            case 2:

                first = this.getVertex(0);

                this.addVertex((Point) first.cloneGeometry());

                return;

        }

        if( this.isClosed(0) ) {

            return;

        }

        first = this.getVertex(0);

        if( this.isClosed(tolerance) ) {

            this.setVertex(numVertices-1,(Point) first.cloneGeometry());

        } else {

            this.addVertex((Point) first.cloneGeometry());

        }

    }

    @Override

    public Geometry force2D() throws GeometryOperationNotSupportedException, GeometryOperationException {

        ArrayListCoordinateSequence coordinates2D = new ArrayListCoordinateSequence(coordinates.size());

        for (Coordinate coordinate : this.coordinates) {

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

        }

        Line2D l = new Line2D(coordinates2D);

        return l;

    }

    @Override

    public Geometry force2DM() throws GeometryOperationNotSupportedException, GeometryOperationException {

        if(this instanceof Line2DM){

            return this;

        }

        ArrayListCoordinateSequence coordinates2DM = new ArrayListCoordinateSequence(coordinates.size());

        for (Coordinate coordinate : this.coordinates) {

            coordinates2DM.add(MCoordinate.create2dWithMeasure(

                    coordinate.x, 

                    coordinate.y, 

                    (coordinate instanceof MCoordinate)?coordinate.getOrdinate(CoordinateSequence.M):0));

        }

        Line2DM line = new Line2DM(coordinates2DM);

        line.setProjection(this.getProjection());

        return line;

    }

    @Override

    public Geometry force3D() throws GeometryOperationNotSupportedException, GeometryOperationException {

        ArrayListCoordinateSequence coordinates3D = new ArrayListCoordinateSequence(coordinates.size());

        for (Coordinate coordinate : this.coordinates) {

            coordinates3D.add(new Coordinate(

                    coordinate.x, 

                    coordinate.y, 

                    Double.isNaN(coordinate.z)?0:coordinate.z

            ));

        }

        Line3D line = new Line3D(coordinates3D);

        line.setProjection(this.getProjection());

        return line;

    }

    @Override

    public Geometry force3DM() throws GeometryOperationNotSupportedException, GeometryOperationException {

        ArrayListCoordinateSequence coordinates3DM = new ArrayListCoordinateSequence(coordinates.size());

        for (Coordinate coordinate : this.coordinates) {

            coordinates3DM.add(MCoordinate.create3dWithMeasure(

                    coordinate.x, 

                    coordinate.y, 

                    (Double.isNaN(coordinate.z))?0:coordinate.z, 

                    (coordinate instanceof MCoordinate)?coordinate.getOrdinate(CoordinateSequence.M):0

            ));

        }

        Line3DM line = new Line3DM(coordinates3DM);

        line.setProjection(this.getProjection());

        return line;

    }

    @Override

    public int size() {

        return this.getNumVertices();

    }

    @Override

    public Point get(int position) {

        return this.getVertex(position);

    }

    public double getPathLength(Point point) {

        return JTSUtils.getPathLengthFromLine(this, point);

    }

    public Point extractPoint(double length) {

        return JTSUtils.extractPointFromLine(this, length);

    }

}