Application: gvSIG desktop

/**

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

import java.util.ArrayList;

import com.vividsolutions.jts.geom.Coordinate;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.geom.Geometry;

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * A minimum bounding box or rectangle. Regardless of dimension, an Envelope

 * can be represented without ambiguity as two direct positions (coordinate

 * points). To encode an Envelope, it is sufficient to encode these two

 * points. This is consistent with all of the data types in this

 * specification, their state is represented by their publicly accessible

 * attributes.

 * @author Vicente Caballero Navarro

 */

@SuppressWarnings("UseSpecificCatch")

public abstract class DefaultEnvelope implements Envelope, org.gvsig.tools.lang.Cloneable{

    private static final Logger LOG =

        LoggerFactory.getLogger(DefaultEnvelope.class);

    public static final String PERSISTENCE_DEFINITION_NAME = "Envelope";

    protected static final String LOWERCORNER_FIELD = "lowerCorner";

    protected static final String UPPERCORNER_FIELD = "upperCorner";

    protected Point min;

    protected Point max;

    protected boolean isEmpty;

    protected IProjection projection;

    private com.vividsolutions.jts.geom.Polygon jtsGeom = null;

    protected static GeometryManager manager = GeometryLocator.getGeometryManager();

    public DefaultEnvelope(){

        super();

        isEmpty = true;

    }

    public DefaultEnvelope(Point min, Point max){

        super();

        this.min = min;

        this.max = max;

        isEmpty = false;

    }

    public String toString() {

        if( this.isEmpty ) {

            return "POLYGON()";

        }

        // Para el 3D estaria mal ya que probablemente habria que devolber un cubo.

        StringBuilder builder = new StringBuilder();

        builder.append("POLYGON ((");

        builder.append(this.min.getX());

        builder.append(" ");

        builder.append(this.min.getY());

        builder.append(", ");

        builder.append(this.min.getX());

        builder.append(" ");

        builder.append(this.max.getY());

        builder.append(", ");

        builder.append(this.max.getX());

        builder.append(" ");

        builder.append(this.max.getY());

        builder.append(", ");

        builder.append(this.max.getX());

        builder.append(" ");

        builder.append(this.min.getY());

        builder.append(", ");

        builder.append(this.min.getX());

        builder.append(" ");

        builder.append(this.min.getY());

        builder.append("))");

        return builder.toString();

    }

    /**

     * Returns the center ordinate along the specified dimension.

     *

     * @param dimension DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     */

    public double getCenter(int dimension) {

        if (isEmpty){

            throw new EnvelopeNotInitializedException();

        }

        return (min.getCoordinateAt(dimension) + max.getCoordinateAt(dimension)) * 0.5;

    }

    /**

     * Returns the envelope length along the specified dimension.

     *

     * @param dimension

     *

     * @return

     */

    public double getLength(int dimension) {

        if (isEmpty){

            throw new EnvelopeNotInitializedException();

        }

        if (max.getCoordinateAt(dimension) > min.getCoordinateAt(dimension)) {

            return max.getCoordinateAt(dimension) - min.getCoordinateAt(dimension);

        }

        return min.getCoordinateAt(dimension) - max.getCoordinateAt(dimension);

    }

    /**

     * A coordinate position consisting of all the minimal ordinates for each

     * dimension for all points within the Envelope.

     *

     * @return

     */

    public Point getLowerCorner() {

        return min;

    }

    /**

     * Returns the maximal ordinate along the specified dimension.

     *

     * @param dimension

     *

     * @return

     */

    public double getMaximum(int dimension) {

        if (isEmpty){

            throw new EnvelopeNotInitializedException();

        }

        return max.getCoordinateAt(dimension);

    }

    /**

     * Returns the minimal ordinate along the specified dimension.

     *

     * @param dimension

     *

     * @return

     */

    public double getMinimum(int dimension) {

        if (isEmpty){

            throw new EnvelopeNotInitializedException();

        }

        return min.getCoordinateAt(dimension);

    }

    /**

     * A coordinate position consisting of all the maximal ordinates for each

     * dimension for all points within the Envelope.

     *

     * @return

     */

    public Point getUpperCorner() {

        return max;

    }

    public Geometry getGeometry() {

        if (isEmpty){

            throw new EnvelopeNotInitializedException();

        }

        try {

            // point?

            if (this.min.getX() == this.max.getX() && this.min.getY() == this.max.getY()) {

                Point point = this.min.clone();

                point.setProjection(projection);

                return point;

            }

            // vertical or horizontal line?

            if (this.min.getX() == this.max.getX() ||

                this.min.getY() == this.max.getY()) {

                Line line = manager.createLine(SUBTYPES.GEOM2D);

                line.addVertex(min.clone());

                line.addVertex(max.clone());

                line.setProjection(projection);

                return line;

            }

            Polygon polygon = manager.createPolygon(SUBTYPES.GEOM2D);

            polygon.addVertex(min.clone());

            polygon.addVertex(manager.createPoint(getMaximum(0),getMinimum(1), SUBTYPES.GEOM2D));

            polygon.addVertex(max.clone());

            polygon.addVertex(manager.createPoint(getMinimum(0),getMaximum(1), SUBTYPES.GEOM2D));

            polygon.addVertex(min.clone());

            polygon.setProjection(projection);

            return polygon;

        } catch (Exception e) {

            LOG.warn("Error creting the geometry from envelope", e);

        }

        return null;

    }

    public boolean contains(Envelope envelope) {

        if (isEmpty){

            return false;

        }

        if((envelope == null) || (envelope.isEmpty())) {

            return false;

        }

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

            if (getMinimum(i) > envelope.getMinimum(i)

                || getMaximum(i) < envelope.getMaximum(i)) {

                return false;

            }

        }

        return true;

    }

    public boolean intersects(Envelope envelope) {

        if (isEmpty){

            return false;

        }

        if((envelope == null) || (envelope.isEmpty())) {

            return false;

        }

        int dimension = getDimension();

        for (int i = 0; i < dimension; i++) {

            if (getMinimum(i)>envelope.getMaximum(i)){

                return false;

            } else if (getMaximum(i)<envelope.getMinimum(i)){

                return false;

            }

        }

        return true;

    }

    public boolean equals(Object other) {

        if (!(other == null || other instanceof Envelope)) {

            return false;

        }

        Envelope otherEnv = (Envelope) other;

        if (isEmpty && otherEnv.isEmpty()){

            return true;

        }

        if (otherEnv.getDimension() != this.getDimension()) {

            return false;

        }

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

            if (otherEnv.getMinimum(i) != this.getMinimum(i)) {

                return false;

            }

            if (otherEnv.getMaximum(i) != this.getMaximum(i)) {

                return false;

            }

        }

        return true;

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.geom.primitive.Envelope#setLowerCorner(org.gvsig.fmap.geom.primitive.Point)

     */

    public void setLowerCorner(Point lowerCorner) {

        this.min = lowerCorner;

        if (max != null){

            isEmpty = false;

        }

        this.min.setProjectionIffNull(projection);

        jtsGeom = null;

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.geom.primitive.Envelope#setUpperCorner(org.gvsig.fmap.geom.primitive.Point)

     */

    public void setUpperCorner(Point upperCorner) {

        this.max = upperCorner;

        if (min != null){

            isEmpty = false;

        }

        this.max.setProjectionIffNull(projection);        

        jtsGeom = null;

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if( manager.getDefinition(PERSISTENCE_DEFINITION_NAME)==null ) {

            DynStruct definition = manager.addDefinition(

                DefaultEnvelope.class,

                PERSISTENCE_DEFINITION_NAME,

                "DefaultEnvelope persistence definition",

                null,

                null

            );

            definition.addDynFieldObject(LOWERCORNER_FIELD).setClassOfValue(Point.class).setMandatory(true);

            definition.addDynFieldObject(UPPERCORNER_FIELD).setClassOfValue(Point.class).setMandatory(true);

        }

    }

    public void loadFromState(PersistentState state)

    throws PersistenceException {

        setLowerCorner((Point)state.get(LOWERCORNER_FIELD));

        setUpperCorner((Point)state.get(UPPERCORNER_FIELD));

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set(LOWERCORNER_FIELD, min);

        state.set(UPPERCORNER_FIELD, max);

    }

    public Object clone() throws CloneNotSupportedException {

        DefaultEnvelope other = (DefaultEnvelope) super.clone();

        if (!isEmpty){

            other.max = (Point) max.cloneGeometry();

            other.min = (Point) min.cloneGeometry();

        }

        return other;

    }

    @Override

    public boolean isEmpty() {

        return isEmpty;

    }

    @Override

    public void add(Geometry geometry) {

        if( geometry==null ) {

            return;

        }

        this.add(geometry.getEnvelope());

    }

    @Override

    public void clear() {

        isEmpty = true;

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.geom.primitive.Envelope#intersects(org.gvsig.fmap.geom.Geometry)

     */

    @Override

    public boolean intersects(Geometry geometry) {

        if(geometry instanceof GeometryJTS){

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

        }

        return false;

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.geom.primitive.Envelope#centerTo(org.gvsig.fmap.geom.primitive.Point)

     */

    @Override

    public void centerTo(Point p) {

        try {

            Point loweCorner = manager.createPoint(p.getX() - this.getLength(DIMENSIONS.X)/2,

                p.getY() - this.getLength(DIMENSIONS.Y)/2,

                    SUBTYPES.GEOM2D);

            Point upperCorner = manager.createPoint(p.getX() + this.getLength(DIMENSIONS.X)/2,

                p.getY() + this.getLength(DIMENSIONS.Y)/2,

                    SUBTYPES.GEOM2D);

            this.setLowerCorner(loweCorner);

            this.setUpperCorner(upperCorner);

        } catch (CreateGeometryException e) {

            LOG.error("Error creating corners to center the envelope", e);

        }

    }

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

        if (jtsGeom == null) {

            ArrayListCoordinateSequence coordinates = new ArrayListCoordinateSequence(new ArrayList<Coordinate>());

            coordinates.add(new com.vividsolutions.jts.geom.Coordinate(min.getX(), min.getY()));

            coordinates.add(new com.vividsolutions.jts.geom.Coordinate(getMaximum(0), getMinimum(1)));

            coordinates.add(new com.vividsolutions.jts.geom.Coordinate(max.getX(), max.getY()));

            coordinates.add(new com.vividsolutions.jts.geom.Coordinate(getMinimum(0), getMaximum(1)));

            coordinates.add(new com.vividsolutions.jts.geom.Coordinate(min.getX(), min.getY()));

            jtsGeom = JTSUtils.createJTSPolygon(coordinates);

        }

        return jtsGeom;

    }

    @Override

    public IProjection getProjection() {

        return this.projection;

    }

    @Override

    public void setProjectionIffNull(IProjection projection) {

        if (this.projection == null) {

            this.projection = projection;

        }

    }

    @Override

    public void setProjection(IProjection projection) {

        this.projection = projection;

    }

    @Override

    public boolean isCollapsed() {

        switch(this.getDimension()) {

            case 3:

                return this.isCollapsed(Geometry.SUBTYPES.GEOM3D);

            default:

            case 2:

                return this.isCollapsed(Geometry.SUBTYPES.GEOM2D);

        }

    }

    @Override

    public boolean isCollapsed(int subtype) {

        if( this.isEmpty ) {

            return true;

        }

        switch(subtype) {

            case Geometry.SUBTYPES.GEOM3DM:

                int m = this.getDimension()-1;

                if( this.getLength(m)!=0 ) {

                    return false;

                }

            case Geometry.SUBTYPES.GEOM2DM:

            case Geometry.SUBTYPES.GEOM3D:

                if( this.getLength(DIMENSIONS.Z)!=0 ) {

                    return false;

                }

            default:

            case Geometry.SUBTYPES.GEOM2D:

                if( this.getLength(DIMENSIONS.X)!=0 ) {

                    return false;

                }

                if( this.getLength(DIMENSIONS.Y)!=0 ) {

                    return false;

                }

                return true;

        }

    }

}