Application: gvSIG desktop

org.gvsig.fmap.geom.jts.DefaultGeometryLibrary

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

import java.awt.Rectangle;

import java.awt.Shape;

import java.awt.geom.AffineTransform;

import java.awt.geom.Rectangle2D;

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.io.WKBWriter;

import com.vividsolutions.jts.io.WKTWriter;

import com.vividsolutions.jts.operation.distance.DistanceOp;

import com.vividsolutions.jts.operation.overlay.snap.GeometrySnapper;

import com.vividsolutions.jts.operation.valid.IsValidOp;

import com.vividsolutions.jts.operation.valid.TopologyValidationError;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.jts.primitive.Envelope2D;

import org.gvsig.fmap.geom.jts.primitive.Envelope3D;

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.geom.type.GeometryTypeNotSupportedException;

import org.gvsig.fmap.geom.type.GeometryTypeNotValidException;

import org.gvsig.tools.locator.LocatorException;

/**

 * @author fdiaz

 *

 */

public abstract class AbstractGeometry implements GeometryJTS {

    private static final Logger logger = LoggerFactory.getLogger(AbstractGeometry.class);

    /**

     *

     */

    private static final long serialVersionUID = 4999326772576222293L;

    private final GeometryType geometryType;

    /**

     *

     */

    public AbstractGeometry(int type, int subtype) {

        try {

            this.geometryType = GeometryLocator.getGeometryManager().getGeometryType(type, subtype);

        } catch (Exception e) {

            // TODO: Ver de crear una excepcion para esto o si hay alguna en el API.

            throw new RuntimeException(e);

        }

    }

    public GeometryType getGeometryType(){

        return geometryType;

    }

    protected GeometryManager getManager() {

        return GeometryLocator.getGeometryManager();

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#contains(org.gvsig.fmap.geom.Geometry)

     */

    public boolean contains(Geometry geometry) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        if (!(geometry instanceof GeometryJTS)) {

            return false;

        }

        return getJTS().contains(((GeometryJTS) geometry).getJTS());

    }

    /*

     * (non-Javadoc)

     *

     * @see java.lang.Comparable#compareTo(java.lang.Object)

     */

    public int compareTo(Object o) {

        return getJTS().compareTo(((GeometryJTS) o).getJTS());

    }

    /*

     * (non-Javadoc)

     *

     * @see java.awt.Shape#contains(double, double)

     */

    public boolean contains(double x, double y) {

        notifyDeprecated("Calling deprecated method of geometry contains from shape interface");

        Shape shp = getShape();

        return shp.contains(x, y);

    }

    /*

     * (non-Javadoc)

     *

     * @see java.awt.Shape#intersects(double, double, double, double)

     */

    public boolean intersects(double x, double y, double w, double h) {

        notifyDeprecated("Calling deprecated method of geometry intersects from shape interface");

        Shape shp = this.getShape();

        return shp.intersects(x, y, w, h);

    }

    /*

     * (non-Javadoc)

     *

     * @see java.awt.Shape#contains(double, double, double, double)

     */

    public boolean contains(double x, double y, double w, double h) {

        notifyDeprecated("Calling deprecated method of geometry contains from shape interface");

        Shape shp = this.getShape();

        return shp.contains(x, y, w, h);

    }

    /*

     * (non-Javadoc)

     *

     * @see java.awt.Shape#contains(java.awt.geom.Point2D)

     */

    public boolean contains(java.awt.geom.Point2D p) {

        notifyDeprecated("Calling deprecated method of geometry contains from shape interface");

        Shape shp = this.getShape();

        return shp.contains(p);

    }

    /*

     * (non-Javadoc)

     *

     * @see java.awt.Shape#contains(java.awt.geom.Rectangle2D)

     */

    public boolean contains(Rectangle2D r) {

        notifyDeprecated("Calling deprecated method of geometry contains from shape interface");

        Shape shp = this.getShape();

        return shp.contains(r);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#distance(org.gvsig.fmap.geom.Geometry)

     */

    public double distance(org.gvsig.fmap.geom.Geometry other) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        return getJTS().distance(((GeometryJTS) other).getJTS());

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * org.gvsig.fmap.geom.Geometry#isWithinDistance(org.gvsig.fmap.geom.Geometry

     * , double)

     */

    public boolean isWithinDistance(org.gvsig.fmap.geom.Geometry other, double distance)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        return com.vividsolutions.jts.operation.distance.DistanceOp.isWithinDistance(this.getJTS(),

            ((GeometryJTS) other).getJTS(), distance);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#overlaps(org.gvsig.fmap.geom.Geometry)

     */

    public boolean overlaps(org.gvsig.fmap.geom.Geometry geometry) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        // TODO: this method can be implemented throw invokeOperation

        return getJTS().overlaps(((GeometryJTS) geometry).getJTS());

    }

    public boolean coveredBy(Geometry geometry) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        return getJTS().coveredBy(((GeometryJTS) geometry).getJTS());

    }

    public boolean covers(Geometry geometry) throws GeometryOperationNotSupportedException, GeometryOperationException {

        // TODO: this method can be implemented throw invokeOperation

        return getJTS().covers(((GeometryJTS) geometry).getJTS());

    }

    public boolean crosses(Geometry geometry) throws GeometryOperationNotSupportedException, GeometryOperationException {

        // TODO: this method can be implemented throw invokeOperation

        return getJTS().crosses(((GeometryJTS) geometry).getJTS());

    }

    public boolean intersects(Geometry geometry) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        return getJTS().intersects(((GeometryJTS) geometry).getJTS());

    }

    public boolean touches(Geometry geometry) throws GeometryOperationNotSupportedException, GeometryOperationException {

        // TODO: this method can be implemented throw invokeOperation

        return getJTS().touches(((GeometryJTS) geometry).getJTS());

    }

    public boolean disjoint(Geometry geometry) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        // TODO: this method can be implemented throw invokeOperation

        return getJTS().disjoint(((GeometryJTS) geometry).getJTS());

    }

    public boolean within(Geometry geometry) throws GeometryOperationNotSupportedException, GeometryOperationException {

        // TODO: this method can be implemented throw invokeOperation

        return getJTS().within(((GeometryJTS) geometry).getJTS());

    }

    public double area() throws GeometryOperationNotSupportedException, GeometryOperationException {

        return getJTS().getArea();

    }

    public double perimeter() throws GeometryOperationNotSupportedException, GeometryOperationException {

        return getJTS().getLength();

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#intersects(java.awt.geom.Rectangle2D)

     */

    public boolean intersects(Rectangle2D r) {

        double x = r.getMinX();

        double y = r.getMinY();

        double w = r.getWidth();

        double h = r.getHeight();

        return fastIntersects(x, y, w, h);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#fastIntersects(double, double, double,

     * double)

     */

    public boolean fastIntersects(double x, double y, double w, double h) {

        com.vividsolutions.jts.geom.Geometry rect = null;

        com.vividsolutions.jts.geom.Coordinate[] coord = new com.vividsolutions.jts.geom.Coordinate[5];

        coord[0] = new com.vividsolutions.jts.geom.Coordinate(x, y);

        coord[1] = new com.vividsolutions.jts.geom.Coordinate(x + w, y);

        coord[2] = new com.vividsolutions.jts.geom.Coordinate(x + w, y + w);

        coord[3] = new com.vividsolutions.jts.geom.Coordinate(x, y + w);

        coord[4] = new com.vividsolutions.jts.geom.Coordinate(x, y);

        rect = JTSUtils.factory.createPolygon(coord);

        return getJTS().intersects(rect);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#getEnvelope()

     */

    public Envelope getEnvelope() {

        if (is3D()) {

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

            double minx = Double.POSITIVE_INFINITY;

            double miny = Double.POSITIVE_INFINITY;

            double minz = Double.POSITIVE_INFINITY;

            double maxx = Double.NEGATIVE_INFINITY;

            double maxy = Double.NEGATIVE_INFINITY;

            double maxz = Double.NEGATIVE_INFINITY;

            double x;

            double y;

            double z;

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

                x = coordinates[i].x;

                y = coordinates[i].x;

                z = coordinates[i].x;

                minx = Math.min(x, minx);

                miny = Math.min(x, miny);

                minz = Math.min(x, minz);

                maxx = Math.max(x, maxx);

                maxy = Math.max(x, maxy);

                maxz = Math.max(x, maxz);

            }

            if (minx <= maxx && miny <= maxy && minz <= maxz) {

                Point min = new Point3D(minx, miny, minz);

                Point max = new Point3D(maxx, maxy, maxz);

                return new Envelope3D(min, max);

            }

            return new Envelope3D();

        } else {

            com.vividsolutions.jts.geom.Envelope envelope = getJTS().getEnvelopeInternal();

            return new Envelope2D(envelope);

        }

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#isSimple()

     */

    public boolean isSimple() {

        return this.getJTS().isSimple();

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#isCCW()

     */

    public boolean isCCW() throws GeometryOperationNotSupportedException, GeometryOperationException {

        return CGAlgorithms.isCCW(this.getJTS().getCoordinates());

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#invokeOperation(int,

     * org.gvsig.fmap.geom.operation.GeometryOperationContext)

     */

    public Object invokeOperation(int index, GeometryOperationContext ctx)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        return getManager().invokeOperation(index, this, ctx);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#invokeOperation(java.lang.String,

     * org.gvsig.fmap.geom.operation.GeometryOperationContext)

     */

    public Object invokeOperation(String opName, GeometryOperationContext ctx)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        return getManager().invokeOperation(opName, this, ctx);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#getType()

     */

    public int getType() {

        return this.getGeometryType().getType();

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#convertToWKB()

     */

    public byte[] convertToWKB() throws GeometryOperationNotSupportedException, GeometryOperationException {

        int subType = getGeometryType().getSubType();

        boolean is3D = subType == 1 || subType == 3;

        WKBWriter write = null;

        if (is3D)

            write = new WKBWriter(3);

        else

            write = new WKBWriter(2);

        com.vividsolutions.jts.geom.Geometry jts = getJTS();

        return write.write(jts);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#convertToWKB(int)

     */

    public byte[] convertToWKB(int srs) throws GeometryOperationNotSupportedException, GeometryOperationException {

        int subType = getGeometryType().getSubType();

        boolean is3D = subType == 1 || subType == 3;

        WKBWriter write = null;

        if (is3D)

            write = new WKBWriter(3);

        else

            write = new WKBWriter(2);

        com.vividsolutions.jts.geom.Geometry jts = getJTS();

        jts.setSRID(srs);

        return write.write(jts);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#convertToWKBForcingType(int, int)

     */

    public byte[] convertToWKBForcingType(int srs, int type) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        int subType = getGeometryType().getSubType();

        boolean is3D = subType == 1 || subType == 3;

        WKBWriter write = null;

        if (is3D)

            write = new WKBWriter(3);

        else

            write = new WKBWriter(2);

        com.vividsolutions.jts.geom.Geometry jts = getJTS();

        jts = JTSUtils.convertTypes(jts, this.getType(), type);

        jts.setSRID(srs);

        return write.write(jts);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#convertToWKT()

     */

    public String convertToWKT() throws GeometryOperationNotSupportedException, GeometryOperationException {

        int subType = getGeometryType().getSubType();

        boolean is3D = subType == 1 || subType == 3;

        WKTWriter write = null;

        if (is3D)

            write = new WKTWriter(3);

        else

            write = new WKTWriter(2);

        com.vividsolutions.jts.geom.Geometry jts = getJTS();

        return write.write(jts);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#buffer(double)

     */

    public org.gvsig.fmap.geom.Geometry buffer(double distance) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        return JTSUtils.createGeometry(getJTS().buffer(distance));

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#snapTo(org.gvsig.fmap.geom.Geometry,

     * double)

     */

    public org.gvsig.fmap.geom.Geometry snapTo(org.gvsig.fmap.geom.Geometry other, double snapTolerance)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        Geometry result = null;

        GeometrySnapper snapper = new GeometrySnapper(getJTS());

        com.vividsolutions.jts.geom.Geometry jts_result = snapper.snapTo(((GeometryJTS) other).getJTS(), snapTolerance);

        result = JTSUtils.createGeometry(jts_result);

        return result;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#getInteriorPoint()

     */

    public Point getInteriorPoint() throws GeometryOperationNotSupportedException, GeometryOperationException {

        com.vividsolutions.jts.geom.Geometry geometry = getJTS();

        com.vividsolutions.jts.geom.Point point = geometry.getInteriorPoint();

        Geometry result = JTSUtils.createGeometry(point);

        return (Point) result;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#isValid()

     */

    public boolean isValid() {

        return getJTS().isValid();

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#getValidationStatus()

     */

    public ValidationStatus getValidationStatus() {

        DefaultValidationStatus status = new DefaultValidationStatus(ValidationStatus.VALID, null);

        com.vividsolutions.jts.geom.Geometry jtsgeom = null;

        try {

            jtsgeom = this.getJTS();

            IsValidOp validOp = new IsValidOp(jtsgeom);

            if (validOp != null) {

                status.setValidationError(validOp.getValidationError());

            }

        } catch (Exception ex) {

            status.setStatusCode(ValidationStatus.CURRUPTED);

            status.setMesage("The geometry is corrupted.");

            if (this instanceof OrientableSurface) {

                int vertices = ((OrientableSurface) this).getNumVertices();

                if (vertices < 3) {

                    status.setStatusCode(ValidationStatus.TOO_FEW_POINTS);

                    status.setMesage(TopologyValidationError.errMsg[TopologyValidationError.TOO_FEW_POINTS]);

                }

            } else if (this instanceof OrientableCurve) {

                int vertices = ((OrientableCurve) this).getNumVertices();

                if (vertices < 2) {

                    status.setStatusCode(ValidationStatus.TOO_FEW_POINTS);

                    status.setMesage(TopologyValidationError.errMsg[TopologyValidationError.TOO_FEW_POINTS]);

                }

            }

        }

        return status;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#makeValid()

     */

    public org.gvsig.fmap.geom.Geometry makeValid() {

        try {

            ValidationStatus vs = this.getValidationStatus();

            if (vs.isValid()) {

                return this;

            }

            Geometry g = null;

            switch (vs.getStatusCode()) {

            case Geometry.ValidationStatus.RING_SELF_INTERSECTION:

            case Geometry.ValidationStatus.SELF_INTERSECTION:

                g = this.buffer(0);

                if (g.isValid()) {

                    return g;

                }

                break;

            case Geometry.ValidationStatus.TOO_FEW_POINTS:

                if (this instanceof OrientableCurve) {

                    int vertices = ((OrientableCurve) this).getNumVertices();

                    if (vertices < 2) {

                        return null; // new

                                     // DefaultNullGeometry(this.getGeometryType());

                    }

                }

                if (this instanceof OrientableSurface) {

                    int vertices = ((OrientableSurface) this).getNumVertices();

                    if (vertices < 3) {

                        return null; // new

                                     // DefaultNullGeometry(this.getGeometryType());

                    }

                }

            }

        } catch (Exception ex) {

            return null;

        }

        return null;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#getBounds2D()

     */

    public Rectangle2D getBounds2D() {

        com.vividsolutions.jts.geom.Envelope envInternal = getJTS().getEnvelopeInternal();

        return new Rectangle2D.Double(envInternal.getMinX(), envInternal.getMinY(), envInternal.getWidth(),

            envInternal.getHeight());

    }

    /*

     * (non-Javadoc)

     *

     * @see java.awt.Shape#getBounds()

     */

    public Rectangle getBounds() {

        return this.getShape().getBounds();

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.geom.Geometry#getInternalShape()

     */

    public Shape getInternalShape() {

        return getShape();

    }

    public void rotate(double radAngle, double basex, double basey) {

        AffineTransform at = new AffineTransform();

        at.rotate(radAngle, basex, basey);

        this.transform(at);

    }

    public void move(double dx, double dy) {

        AffineTransform at = new AffineTransform();

        at.translate(dx, dy);

        this.transform(at);

    }

    public void scale(Point basePoint, double sx, double sy) {

        AffineTransform at = new AffineTransform();

        at.setToTranslation(basePoint.getX(), basePoint.getY());

        at.scale(sx, sy);

        at.translate(-basePoint.getX(), -basePoint.getY());

        this.transform(at);

    }

    public Geometry[] closestPoints(Geometry other) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        Point[] points = null;

        Coordinate[] jts_points = DistanceOp.nearestPoints(getJTS(), ((GeometryJTS) other).getJTS());

        points = new Point[jts_points.length];

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

            try {

                points[i] = JTSUtils.createPoint(this.getGeometryType(), jts_points[i]);

            } catch (CreateGeometryException e) {

                throw new GeometryOperationException(e);

            }

        }

        return (Geometry[]) points;

    }

    public Geometry convexHull() throws GeometryOperationNotSupportedException, GeometryOperationException {

        return JTSUtils.createGeometry(getJTS().convexHull());

    }

    public Geometry difference(Geometry other) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        return JTSUtils.createGeometry(getJTS().difference(((GeometryJTS) other).getJTS()));

    }

    public Geometry intersection(Geometry other) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        return JTSUtils.createGeometry(getJTS().intersection(((GeometryJTS) other).getJTS()));

    }

    public Geometry union(Geometry other) throws GeometryOperationNotSupportedException, GeometryOperationException {

        return JTSUtils.createGeometry(getJTS().union(((GeometryJTS) other).getJTS()));

    }

    public org.gvsig.fmap.geom.primitive.Point centroid() throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        try {

            return JTSUtils.createPoint(this.getGeometryType(), getJTS().getCentroid().getCoordinate());

        } catch (CreateGeometryException e) {

            throw new GeometryOperationException(e);

        }

    }

    protected void notifyDeprecated(String message) {

        logger.info(message);

    }

}

/**

 * 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.jts.coerce;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypesManager.Coercion;

/**

 * Convert a Geometry to String encoded as WKT.

 * 

 *  

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public class CoerceToString implements Coercion {

	Coercion previous = null;

	public CoerceToString() {

		// Do nothing

	}

	public CoerceToString(Coercion previous) {

		this.previous = previous;

	}

	public Object coerce(Object value) throws CoercionException {

		try {

			if( value == null || value instanceof String ) {

				return value;

			}

			if( value instanceof Geometry ) {

				return ((Geometry)value).convertToWKT();

			}

			if( previous != null ) {

				return previous.coerce(value);

			}

		} catch (Exception e) {

			throw new CoercionException(e);

		}

		throw new CoercionException();

	}

}

/**

 * 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.jts.coerce;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypesManager.Coercion;

/**

 * Convert a object to Geometry.

 * 

 * Support convert:

 * - Geometry to Geometry (do nothing)

 * - WKB (byte[]) to Geometry

 * - WKT (String/toString) to Geometry

 * 

 *  

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public class CoerceToGeometry implements Coercion {

	public Object coerce(Object value) throws CoercionException {

		try {

			if( value == null || value instanceof Geometry ) {

				return value;

			}

			GeometryManager manager = GeometryLocator.getGeometryManager();

			if( value instanceof byte[] ) {

				return manager.createFrom((byte[])value);

			}

			return manager.createFrom(value.toString());

		} catch (Exception e) {

			throw new CoercionException(e);

		}

	}

}

/**

 * 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.jts.coerce;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypesManager.Coercion;

/**

 * Convert a object to Envelope.

 * 

 * Support convert:

 * - Envelope to Envelope (do nothing)

 * - Geometry to Envelope

 * - WKB (byte[]) to Geometry

 * - WKT (String/toString) to Geometry

 * 

 *  

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public class CoerceToEnvelope implements Coercion {

	public Object coerce(Object value) throws CoercionException {

		try {

			if(value == null || value instanceof Envelope ) {

				return value;

			}

			if( value instanceof Geometry ) {

				return ((Geometry)value).getEnvelope();

			}

			GeometryManager manager = GeometryLocator.getGeometryManager();

			if( value instanceof byte[] ) {

				Geometry geom = manager.createFrom((byte[])value);

				return geom.getEnvelope();

			}

			Geometry geom = manager.createFrom(value.toString());

			return geom.getEnvelope(); 

		} catch (Exception e) {

			throw new CoercionException(e);

		}

	}

}

/**

 * 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.jts.coerce;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypesManager.Coercion;

/**

 * Convert a Geometry to Byte Array encoded as WKB.

 *

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class CoerceToByteArray implements Coercion {

	Coercion previous = null;

	public CoerceToByteArray() {

		// Do nothing

	}

	public CoerceToByteArray(Coercion previous) {

		this.previous = previous;

	}

	public Object coerce(Object value) throws CoercionException {

		try {

			if( value == null || value instanceof byte[] ) {

				return value;

			}

			if( value instanceof Geometry ) {

				return ((Geometry)value).convertToWKT();

			}

			if( previous != null ) {

				return previous.coerce(value);

			}

		} catch (Exception e) {

			throw new CoercionException(e);

		}

		throw new CoercionException();

	}

}

/* 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.utils;

import java.util.ArrayList;

import java.util.Collection;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateSequence;

import com.vividsolutions.jts.geom.Envelope;

/**

 * @author fdiaz

 *

 */

public class ArrayListCoordinateSequence extends ArrayList<Coordinate> implements CoordinateSequence {

    /**

     *

     */

    public ArrayListCoordinateSequence(Collection<Coordinate> coordinates) {

        super(coordinates);

    }

    /* (non-Javadoc)

     * @see com.vividsolutions.jts.geom.CoordinateSequence#getDimension()

     */

    public int getDimension() {

        // TODO Auto-generated method stub

        return 0;

    }

    /* (non-Javadoc)

     * @see com.vividsolutions.jts.geom.CoordinateSequence#getCoordinate(int)

     */

    public com.vividsolutions.jts.geom.Coordinate getCoordinate(int i) {

        return (com.vividsolutions.jts.geom.Coordinate) get(i);

    }

    /* (non-Javadoc)

     * @see com.vividsolutions.jts.geom.CoordinateSequence#getCoordinateCopy(int)

     */

    public com.vividsolutions.jts.geom.Coordinate getCoordinateCopy(int i) {

        return (com.vividsolutions.jts.geom.Coordinate) ((com.vividsolutions.jts.geom.Coordinate)get(i)).clone();

    }

    /* (non-Javadoc)

     * @see com.vividsolutions.jts.geom.CoordinateSequence#getCoordinate(int, com.vividsolutions.jts.geom.Coordinate)

     */

    public void getCoordinate(int index, com.vividsolutions.jts.geom.Coordinate coord) {

        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)

     * @see com.vividsolutions.jts.geom.CoordinateSequence#getX(int)

     */

    public double getX(int index) {

        // TODO Auto-generated method stub

        return 0;

    }

    /* (non-Javadoc)

     * @see com.vividsolutions.jts.geom.CoordinateSequence#getY(int)

     */

    public double getY(int index) {

        // TODO Auto-generated method stub

        return 0;

    }

    /* (non-Javadoc)

     * @see com.vividsolutions.jts.geom.CoordinateSequence#getOrdinate(int, int)

     */

    public double getOrdinate(int index, int ordinateIndex) {

        // TODO Auto-generated method stub

        return 0;

    }

    /* (non-Javadoc)

     * @see com.vividsolutions.jts.geom.CoordinateSequence#setOrdinate(int, int, double)

     */

    public void setOrdinate(int index, int ordinateIndex, double value) {

        // TODO Auto-generated method stub

    }

    /* (non-Javadoc)

     * @see com.vividsolutions.jts.geom.CoordinateSequence#toCoordinateArray()

     */

    public com.vividsolutions.jts.geom.Coordinate[] toCoordinateArray() {

        // TODO Auto-generated method stub

        return null;

    }

    /* (non-Javadoc)

     * @see com.vividsolutions.jts.geom.CoordinateSequence#expandEnvelope(com.vividsolutions.jts.geom.Envelope)

     */

    public Envelope expandEnvelope(Envelope env) {

        // TODO Auto-generated method stub

        return null;

    }

}

/* 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.utils;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateSequence;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.MultiLineString;

import com.vividsolutions.jts.geom.Polygon;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.jts.MCoordinate;

import org.gvsig.fmap.geom.jts.primitive.curve.line.Line2D;

import org.gvsig.fmap.geom.jts.primitive.curve.line.Line2DM;

import org.gvsig.fmap.geom.jts.primitive.curve.line.Line3D;

import org.gvsig.fmap.geom.jts.primitive.curve.line.Line3DM;

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

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

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

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

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

import org.gvsig.fmap.geom.type.GeometryType;

/**

 * @author fdiaz

 *

 */

public class JTSUtils {

    public static final com.vividsolutions.jts.geom.GeometryFactory factory =

        new com.vividsolutions.jts.geom.GeometryFactory();

    public static Point createPoint(GeometryType type, Coordinate coordinate) throws CreateGeometryException {

        switch (type.getSubType()) {

        case Geometry.SUBTYPES.GEOM2D:

            return new Point2D(coordinate);

        case Geometry.SUBTYPES.GEOM2DM:

            return new Point2DM(coordinate);

        case Geometry.SUBTYPES.GEOM3D:

            return new Point3D(coordinate);

        case Geometry.SUBTYPES.GEOM3DM:

            return new Point3DM(coordinate);

        default:

            Point p = null;

            p = (Point) type.create();

            for (int i = 0; i < p.getDimension(); i++) {

                p.setCoordinateAt(i, coordinate.getOrdinate(i));

            }

            break;

        }

        return null;

    }

    public static LineString createJTSLineString(CoordinateSequence coordinates){

        return factory.createLineString(coordinates);

    }

    public static Polygon createJTSPolygon(CoordinateSequence coordinates){

        return factory.createPolygon(coordinates);

    }

    public static Geometry createGeometry(com.vividsolutions.jts.geom.Geometry jtsGeom) {

        if (jtsGeom instanceof com.vividsolutions.jts.geom.Point){

            Coordinate coordinate = jtsGeom.getCoordinate();

            if(coordinate instanceof MCoordinate){

                if(Double.isNaN(coordinate.z)){

                    return new Point2DM(coordinate);

                } else {

                    return new Point3DM(coordinate);

                }

            } else {

                if(Double.isNaN(coordinate.z)){

                    return new Point2D(coordinate);

                } else {

                    return new Point3D(coordinate);

                }

            }

        }

        if (jtsGeom instanceof com.vividsolutions.jts.geom.LineString){

            Coordinate[] coordinates = jtsGeom.getCoordinates();

            Coordinate coordinate = jtsGeom.getCoordinate();

            if(coordinate instanceof MCoordinate){

                if(Double.isNaN(coordinate.z)){

                    return new Line2DM(coordinates);

                } else {

                    return new Line3DM(coordinates);

                }

            } else {

                if(Double.isNaN(coordinate.z)){

                    return new Line2D(coordinates);

                } else {

                    return new Line3D(coordinates);

                }

            }

        }

        if (jtsGeom instanceof com.vividsolutions.jts.geom.Polygon){

        }

        if (jtsGeom instanceof com.vividsolutions.jts.geom.GeometryCollection){

        }

        return null;

    }

    /**

     * This function is called when the we need force types, that is the

     * destination

     * type does not match with the input geometry type

     *

     * @param g

     * @param sourceType

     * @param destinationType

     * @return

     */

    public static com.vividsolutions.jts.geom.Geometry convertTypes(com.vividsolutions.jts.geom.Geometry g,

        int sourceType, int destinationType) {

        if ((sourceType == Geometry.TYPES.CURVE || sourceType == Geometry.TYPES.SPLINE

            || sourceType == Geometry.TYPES.ARC || sourceType == Geometry.TYPES.ELLIPTICARC)

            && destinationType == Geometry.TYPES.MULTISURFACE) {

            if (g instanceof MultiLineString) {

                Polygon[] poly = new Polygon[((MultiLineString) g).getNumGeometries()];

                for (int i = 0; i < ((MultiLineString) g).getNumGeometries(); i++) {

                    com.vividsolutions.jts.geom.Geometry lineString = ((MultiLineString) g).getGeometryN(i);

                    poly[i] = convertLineStringToPolygon((LineString) lineString);

                }

                return factory.createMultiPolygon(poly);

            } else {

                return convertLineStringToPolygon((LineString) g);

            }

        }

        if ((sourceType == Geometry.TYPES.CIRCLE || sourceType == Geometry.TYPES.ELLIPSE)

            && destinationType == Geometry.TYPES.MULTICURVE) {

            if (g instanceof Polygon) {

                Polygon poly = (Polygon) g;

                LineString lineString = factory.createLinearRing(poly.getCoordinates());

                return factory.createMultiLineString(new LineString[] { lineString });

            }

        }

        return g;

    }

    private static com.vividsolutions.jts.geom.Polygon convertLineStringToPolygon(LineString line) {

        Coordinate[] coordinates = line.getCoordinates();

        LinearRing shell = factory.createLinearRing(coordinates);

        Polygon pol = factory.createPolygon(shell, null);

        return pol;

    }

    public static MCoordinate createMCoordinate(double x, double y, double m) {

        return (MCoordinate) MCoordinate.create2dWithMeasure(x, y, m);

    }

    public static MCoordinate createMCoordinate(double x, double y, double z, double m) {

        return (MCoordinate) MCoordinate.create3dWithMeasure(x, y, z, m);

    }

}

/* 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.utils;

import java.util.Collection;

import java.util.Iterator;

import com.vividsolutions.jts.geom.Coordinate;

/**

 * @author fdiaz

 *

 */

public class ReadOnlyCoordinates implements Collection<Coordinate> {

    Coordinate coordinates[];

    /**

     *

     */

    public ReadOnlyCoordinates(Coordinate coordinates[]) {

        this.coordinates = coordinates;

    }

    /* (non-Javadoc)

     * @see java.util.Collection#size()

     */

    public int size() {

        return this.coordinates.length;

    }

    /* (non-Javadoc)

     * @see java.util.Collection#isEmpty()

     */

    public boolean isEmpty() {

        return this.coordinates.length==0;

    }

    /* (non-Javadoc)

     * @see java.util.Collection#contains(java.lang.Object)

     */

    public boolean contains(Object o) {

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

            if(coordinates[i].equals(o)){

                return true;

            }

        }

        return false;

    }

    /* (non-Javadoc)

     * @see java.util.Collection#iterator()

     */

    public Iterator<Coordinate> iterator() {

        return new Iterator<Coordinate>() {

            int i=0;

            public boolean hasNext() {

                return i<coordinates.length;

            }

            public Coordinate next() {

                return coordinates[i++];

            }

            public void remove() {

                throw new UnsupportedOperationException();

            }

        };

    }

    /* (non-Javadoc)

     * @see java.util.Collection#toArray()

     */

    public Object[] toArray() {

        return this.coordinates;

    }

    /* (non-Javadoc)

     * @see java.util.Collection#toArray(java.lang.Object[])

     */

    public <T> T[] toArray(T[] a) {

        return (T[]) this.coordinates;

    }

    /* (non-Javadoc)

     * @see java.util.Collection#add(java.lang.Object)

     */

    public boolean add(Coordinate e) {

        throw new UnsupportedOperationException();

    }

    /* (non-Javadoc)

     * @see java.util.Collection#remove(java.lang.Object)

     */

    public boolean remove(Object o) {

        throw new UnsupportedOperationException();

    }

    /* (non-Javadoc)

     * @see java.util.Collection#containsAll(java.util.Collection)

     */

    public boolean containsAll(Collection<?> c) {

        for (Iterator iterator = c.iterator(); iterator.hasNext();) {

            Object object = (Object) iterator.next();

            if(contains(object)){

                return true;

            }

        }

        return false;

    }

    /* (non-Javadoc)

     * @see java.util.Collection#addAll(java.util.Collection)

     */

    public boolean addAll(Collection<? extends Coordinate> c) {

        throw new UnsupportedOperationException();

    }

    /* (non-Javadoc)

     * @see java.util.Collection#removeAll(java.util.Collection)

     */

    public boolean removeAll(Collection<?> c) {

        throw new UnsupportedOperationException();

    }

    /* (non-Javadoc)

     * @see java.util.Collection#retainAll(java.util.Collection)

     */

    public boolean retainAll(Collection<?> c) {

        throw new UnsupportedOperationException();

    }

    /* (non-Javadoc)

     * @see java.util.Collection#clear()

     */

    public void clear() {

        throw new UnsupportedOperationException();

    }

}

/**

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