| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

* 

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

* 

*/

/*

* AUTHORS (In addition to CIT):

* 2009 {Iver T.I.}   {Task}

*/

package org.gvsig.fmap.geom.impl;

import java.awt.Rectangle;

import java.awt.Shape;

import java.awt.geom.AffineTransform;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import org.cresques.cts.ICoordTrans;

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

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

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.operation.relationship.DefaultRelationshipGeometryOperationContext;

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

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

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

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

import org.gvsig.fmap.geom.util.Converter;

/**

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

public class Geometry2D implements Geometry{

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

        private Geometry geometry = null;

        /**

         * @param primitive

         */

        public Geometry2D(Geometry geometry) {

                super();

                this.geometry = geometry;

        }

        /* (non-Javadoc)

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

         */

        public Geometry cloneGeometry() {

                return new Geometry2D((Geometry)geometry.cloneGeometry());

        }

        /* (non-Javadoc)

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

         */

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

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

        }

        /* (non-Javadoc)

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

         */

        public Rectangle2D getBounds2D() {

                return geometry.getBounds2D();

        }

        /* (non-Javadoc)

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

         */

        public int getDimension() {

                return geometry.getDimension();

        }

        /* (non-Javadoc)

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

         */

        public Envelope getEnvelope() {

                return geometry.getEnvelope();

        }

        /* (non-Javadoc)

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

         */

        public GeneralPathX getGeneralPath() {

                return geometry.getGeneralPath();

        }

        /* (non-Javadoc)

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

         */

        public GeometryType getGeometryType() {

                return geometry.getGeometryType();

        }

        /* (non-Javadoc)

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

         */

        public Handler[] getHandlers(int type) {

                return geometry.getHandlers(type);

        }

        /* (non-Javadoc)

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

         */

        public Shape getInternalShape() {

                return geometry.getInternalShape();

        }

        /* (non-Javadoc)

         * @see org.gvsig.fmap.geom.Geometry#getPathIterator(java.awt.geom.AffineTransform)

         */

        public PathIterator getPathIterator(AffineTransform at) {

                return geometry.getPathIterator(at);

        }

        /* (non-Javadoc)

         * @see org.gvsig.fmap.geom.Geometry#getPathIterator(java.awt.geom.AffineTransform, double)

         */

        public PathIterator getPathIterator(AffineTransform at, double flatness) {

                return geometry.getPathIterator(at, flatness);

        }

        /* (non-Javadoc)

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

         */

        public int getType() {

                return geometry.getType();

        }

        /* (non-Javadoc)

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

         */

        public boolean intersects(Rectangle2D r) {

                return geometry.intersects(r);

        }

        /* (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 geometry.invokeOperation(index, 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 geometry.invokeOperation(opName, ctx);

        }

        /* (non-Javadoc)

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

         */

        public boolean isSimple() {

                return geometry.isSimple();

        }

        /* (non-Javadoc)

         * @see org.gvsig.fmap.geom.Geometry#reProject(org.cresques.cts.ICoordTrans)

         */

        public void reProject(ICoordTrans ct) {

                geometry.reProject(ct);

        }

        /* (non-Javadoc)

         * @see org.gvsig.fmap.geom.Geometry#transform(java.awt.geom.AffineTransform)

         */

        public void transform(AffineTransform at) {

                geometry.transform(at);

        }

        /* (non-Javadoc)

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

         */

        public boolean contains(Point2D p) {

                try {

                        return containsPoint(geometry, p.getX(), p.getY());

                } catch (GeometryOperationException e) {

                        logger.error("While doing contains: " + e.getMessage(), e);

                        return true;

                }

        }

        /* (non-Javadoc)

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

         */

        public boolean contains(Rectangle2D r) {

                try {

                        return containsRectangle(geometry,

                                        r.getMinX(),

                                        r.getMinY(),

                                        r.getWidth(),

                                        r.getHeight());

                } catch (GeometryOperationException e) {

                        logger.error("While doing contains: " + e.getMessage(), e);

                        return true;

                }

        }

        /* (non-Javadoc)

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

         */

        public boolean contains(double x, double y) {

                try {

                        return containsPoint(geometry, x, y);

                } catch (GeometryOperationException e) {

                        logger.error("While doing contains: " + e.getMessage(), e);

                        return true;

                }

        }

        /* (non-Javadoc)

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

         */

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

                try {

                        return containsRectangle(geometry, x, y, w, h);

                } catch (GeometryOperationException e) {

                        logger.error("While doing contains: " + e.getMessage(), e);

                        return true;

                }

        }

        /* (non-Javadoc)

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

         */

        public Rectangle getBounds() {

                return geometry.getBounds();

        }

        /* (non-Javadoc)

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

         */

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

                try {

                        return intersectsRectangle(geometry, x, y, w, h);

                } catch (GeometryOperationException e) {

                        logger.error("While doing intersects: " + e.getMessage(), e);

                        return true;

                }

        }

        /* (non-Javadoc)

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

         */

        public int compareTo(Object arg0) {

                return geometry.compareTo(arg0);

        }

        /**

         * Utility method

         * @param geometry

         * @param x

         * @param y

         * @return

         * @throws GeometryOperationException

         */

        protected boolean containsPoint(Geometry geom, double x, double y) throws GeometryOperationException {

                // exclude disjoint 

                Envelope env = geom.getEnvelope();

                if (x > env.getMaximum(0)) return false; 

                if (y > env.getMaximum(1)) return false; 

                if (x < env.getMinimum(0)) return false; 

                if (y < env.getMinimum(1)) return false; 

                // boxes overlap, need long version

                Geometry geompoint = null;

                try {

                        geompoint = GeometryLocator.getGeometryManager().createPoint(x, y, SUBTYPES.GEOM2D);

                } catch (Exception e1) {

                        throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e1);

                }

                DefaultRelationshipGeometryOperationContext drgoc =

                        new DefaultRelationshipGeometryOperationContext(geompoint);

                Object resp = null;

                boolean respboolean = true;

                try {

                        resp = geom.invokeOperation(GeometryOperation.OPERATION_CONTAINS_CODE, drgoc);

                        respboolean = ((Boolean) resp).booleanValue();

                } catch (Exception e) {

                        throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e);

                }

                return respboolean;

        }

        /**

         * 

         * @param geometry

         * @param x

         * @param y

         * @param w

         * @param h

         * @return

         */

        protected boolean containsRectangle(Geometry geom, double x, double y,

                        double w, double h) throws GeometryOperationException {

                // exclude disjoint boxes

                Envelope env = geom.getEnvelope();

                if (x > env.getMaximum(0)) return false; 

                if ((x+w) < env.getMinimum(0)) return false; 

                if (y > env.getMaximum(1)) return false; 

                if ((y+h) < env.getMinimum(1)) return false; 

                if (w == 0 && h == 0) {

                        return  containsPoint(geom, x, y); 

                }

                // boxes overlap, need long version

                Geometry rectgeom = null;

                GeneralPathX gpx = new GeneralPathX();

                gpx.moveTo(x, y);

                gpx.lineTo(x+w, y);

                gpx.lineTo(x+w, y+h);

                gpx.lineTo(x, y+h);

                gpx.lineTo(x, y);

                try {

                        rectgeom = GeometryLocator.getGeometryManager().createSurface(gpx, SUBTYPES.GEOM2D);

                } catch (Exception e1) {

                        throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e1);

                }

                DefaultRelationshipGeometryOperationContext drgoc =

                        new DefaultRelationshipGeometryOperationContext(rectgeom);

                Object resp = null;

                boolean respboolean = true;

                try {

                        resp = geom.invokeOperation(GeometryOperation.OPERATION_CONTAINS_CODE, drgoc);

                        respboolean = ((Boolean) resp).booleanValue();

                } catch (Exception e) {

                        throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e);

                }

                return respboolean;

        }

        /**

         * 

         * @param geom

         * @param x

         * @param y

         * @param w

         * @param h

         * @return

         */

        protected boolean intersectsRectangle(Geometry geom, double x, double y,

                        double w, double h) throws GeometryOperationException {

                // exclude disjoint boxes

                Envelope env = geom.getEnvelope();

                if (x > env.getMaximum(0)) return false; 

                if ((x+w) < env.getMinimum(0)) return false; 

                if (y > env.getMaximum(1)) return false; 

                if ((y+h) < env.getMinimum(1)) return false; 

                // boxes overlap, need long version

                Geometry rectgeom = null;

                GeneralPathX gpx = new GeneralPathX();

                gpx.moveTo(x, y);

                gpx.lineTo(x+w, y);

                gpx.lineTo(x+w, y+h);

                gpx.lineTo(x, y+h);

                gpx.lineTo(x, y);

                try {

                        rectgeom = GeometryLocator.getGeometryManager().createSurface(gpx, SUBTYPES.GEOM2D);

                } catch (Exception e1) {

                        throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_INTERSECTS_CODE, e1);

                }

                DefaultRelationshipGeometryOperationContext drgoc =

                        new DefaultRelationshipGeometryOperationContext(rectgeom);

                Object resp = null;

                boolean respboolean = true;

                try {

                        resp = geom.invokeOperation(GeometryOperation.OPERATION_INTERSECTS_CODE, drgoc);

                        respboolean = ((Boolean) resp).booleanValue();

                } catch (Exception e) {

                        throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_INTERSECTS_CODE, e);

                }

                return respboolean;

        }

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

                return Converter.geometryToJts(this);

        }

        public byte[] convertToWKB() throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                return (byte[]) this.invokeOperation(OPERATIONS.CONVERTTOWKB, null);

        }

        public String convertToWKT() throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                return (String) this.invokeOperation(OPERATIONS.CONVERTTOWKT, null);

        }

        public Geometry buffer(double distance)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                try {

                        return Converter.jtsToGeometry( getJTS().buffer(distance) );

                } catch (CreateGeometryException e) {

                        throw new GeometryOperationException(e);

                }

        }

        public boolean contains(Geometry geometry)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                return getJTS().contains(Converter.geometryToJts(geometry));

        }

        public double distance(Geometry geometry)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                return getJTS().distance( Converter.geometryToJts(geometry));

        }

        public boolean overlaps(Geometry geometry)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                return getJTS().overlaps(Converter.geometryToJts(geometry));

        }

        public Geometry convexHull() throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                try {

                        return Converter.jtsToGeometry( getJTS().convexHull() );

                } catch (CreateGeometryException e) {

                        throw new GeometryOperationException(e);

                }

        }

        public boolean coveredBy(Geometry geometry)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                return getJTS().coveredBy( Converter.geometryToJts(geometry));

        }

        public boolean crosses(Geometry geometry)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                return getJTS().crosses(Converter.geometryToJts(geometry));

        }

        public Geometry difference(Geometry other)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                try {

                        return Converter.jtsToGeometry( getJTS().difference( Converter.geometryToJts(other)) );

                } catch (CreateGeometryException e) {

                        throw new GeometryOperationException(e);

                }

        }

        public Geometry intersection(Geometry other)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                try {

                        return Converter.jtsToGeometry( getJTS().intersection(Converter.geometryToJts(other)) );

                } catch (CreateGeometryException e) {

                        throw new GeometryOperationException(e);

                }

        }

        public boolean intersects(Geometry geometry)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                return getJTS().intersects(Converter.geometryToJts(geometry));

        }

        public boolean touches(Geometry geometry)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                return getJTS().touches(Converter.geometryToJts(geometry));

        }

        public Geometry union(Geometry other)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                try {

                        return Converter.jtsToGeometry( getJTS().union(Converter.geometryToJts(other)) );

                } catch (CreateGeometryException e) {

                        throw new GeometryOperationException(e);

                }

        }

        public boolean disjoint(Geometry geometry)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                return getJTS().disjoint(Converter.geometryToJts(geometry));

        }

        public boolean within(Geometry geometry)

                        throws GeometryOperationNotSupportedException,

                        GeometryOperationException {

                // TODO: this method can be implemented throw invokeOperation 

                return getJTS().within(Converter.geometryToJts(geometry));

        }

        public Point centroid() throws GeometryOperationNotSupportedException, GeometryOperationException {

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

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

                GeometryOperationContext geometryOperationContext = new GeometryOperationContext();

                geometryOperationContext.setAttribute("JTSGeometry", point);

                return (Point)this.invokeOperation("fromJTS", geometryOperationContext);                

        }

        public double area() throws GeometryOperationNotSupportedException, GeometryOperationException

        {

            //Using get getJTS method instead of use the "toJTS" operation just for performance

            return getJTS().getArea();

        }

    public double perimeter() throws GeometryOperationNotSupportedException, GeometryOperationException

    {

      //Using get getJTS method instead of use the "toJTS" operation just for performance

        return getJTS().getLength();

    }

}