| gvSIG desktop 1

import org.gvsig.fmap.geom.Geometry.DIMENSIONS;

        toWkb2d = manager.getGeometryOperation(ToWKBNative.CODE,

            Geometry.TYPES.GEOMETRY, Geometry.SUBTYPES.GEOM2D);

        fromWkb2d = manager.getGeometryOperation(FromWKB.CODE,

            Geometry.TYPES.GEOMETRY, Geometry.SUBTYPES.GEOM2D);

/* 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.primitive.impl.GeneralPathAdapter;

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, Shape{

    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.getShape().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();

    }

    public Shape getShape() {

        return this;

    }  

    public Shape getShape(AffineTransform affineTransform) {

        if (affineTransform == null){

            return this;

        }

        return new GeneralPathAdapter(affineTransform, getGeneralPath());

    }   

}

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

 *

 */

package org.gvsig.fmap.geom.impl;

import org.gvsig.fmap.geom.Geometry;

/**

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class Geometry2DZ extends Geometry2D{

    private static final long serialVersionUID = 9077261346066587523L;

    /**

     * @param geometry

     */

    public Geometry2DZ(Geometry geometry) {

        super(geometry);       

    }

}

        ;

        ;

        geometryManager.registerGeometryType(Geometry2D.class, "Geometry2D",

            TYPES.GEOMETRY, SUBTYPES.GEOM2D);

        geometryManager.registerGeometryType(Geometry2DZ.class, "Geometry3D", 

            TYPES.GEOMETRY, SUBTYPES.GEOM3D);