Application: gvSIG desktop

package org.gvsig.raster.lib.buffer.impl;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

import org.gvsig.raster.lib.buffer.api.VectorROI;

import org.gvsig.raster.lib.buffer.api.exceptions.GettingEnvelopeException;

import org.gvsig.tools.locator.LocatorException;

/**

 * @author <a href="mailto:lmarques@disid.com">Lluis Marques</a>

 *

 */

public class DefaultVectorROI extends AbstractROI implements VectorROI {

    List<Geometry> rois;

    /**

     * Default constructor

     */

    public DefaultVectorROI() {

        this.rois = new ArrayList<Geometry>();

    }

    @Override

    public boolean isInside(int cellX, int cellY) throws CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Point point = geomManager.createPoint(cellX, cellY, Geometry.SUBTYPES.GEOM2D);

        // TODO: convertir este punto a coordenadas desde p?xeles

        return isInside(point);

    }

    @Override

    public boolean isInside(Geometry geometry) throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        if (rois != null && !rois.isEmpty()) {

            for (Geometry geom : rois) {

                if (geom.contains(geometry)) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public Envelope getEnvelope() throws GettingEnvelopeException {

        Envelope envelope = null;

        for (Geometry geom : rois) {

            try {

                if (envelope == null) {

                    envelope = (Envelope) geom.getEnvelope().clone();

                } else {

                    envelope.add((Envelope) geom.getEnvelope().clone());

                }

            } catch (CloneNotSupportedException e) {

                throw new GettingEnvelopeException(geom, e);

            }

        }

        if (envelope == null) {

            // Create default 2D envelope

            try {

                return GeometryLocator.getGeometryManager().createEnvelope(SUBTYPES.GEOM2D);

            } catch (LocatorException | CreateEnvelopeException e) {

                throw new GettingEnvelopeException(e);

            }

        }

        return envelope;

    }

    @Override

    public void addGeometry(Geometry geometry) {

        if(!geometry.getGeometryType().isSubTypeOf(SUBTYPES.GEOM2D)){

            throw new IllegalArgumentException("Vector ROI only supports 2D geometries");

        }

        this.rois.add(geometry);

    }

    @Override

    public void removeGeometry(int index) {

        this.rois.remove(index);

    }

    @Override

    public List<Geometry> getGeometries() {

        return Collections.unmodifiableList(this.rois);

    }

    @Override

    public int getGeometryCount() {

        return this.rois.size();

    }

}