Application: gvSIG desktop

import java.awt.geom.Point2D;

import java.util.logging.Level;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.impl.DefaultMapContextManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

 * <p>

 * <code>MeasureEvent</code> is used to notify the selection of a polyline.</p>

 * <p>

 * Stores the information about the 2D vertexes and the

 * {@link GeneralPathX GeneralPathX} between them.</p>

    /**

     * The polyline, broken down in straight lines, and quadratic and cubic

     * (B?zier) curves.

     */

    private GeneralPathX gp;

    /**

     * Vector with the X coordinates.

     */

    private Double[] x;

    /**

     * Vector with the Y coordinates.

     */

    private Double[] y;

    /**

     * Mouse event that has been the cause of creating this event.

     */

    private MouseEvent event;

    private static final Logger logger = LoggerFactory

            .getLogger(MeasureEvent.class);

    /**

     * <p>

     * Creates a new <code>MeasureEvent</code> with all necessary data.</p>

     * <p>

     * The general path is calculated according the enclosed regions of the path

     * alternate between interior and exterior areas are traversed from the

     * outside of the path towards a point inside the region.</p>

     *

     * @param x vector with the X coordinates

     * @param y vector with the Y coordinates

     * @param e event that has been the cause of creating this one

     */

    public MeasureEvent(Double[] x, Double[] y, MouseEvent e) {

        this.x = x;

        this.y = y;

        this.event = e;

        gp = new GeneralPathX(GeneralPathX.WIND_EVEN_ODD, x.length);

        gp.moveTo(x[0].doubleValue(), y[0].doubleValue());

        for (int index = 1; index < x.length; index++) {

            gp.lineTo(x[index].doubleValue(), y[index].doubleValue());

        }

    }

    /**

     * <p>

     * Gets the {@link GeneralPathX GeneralPathX} of the measurement.</p>

     *

     * @see GeneralPathX

     *

     * @return geometric path constructed from straight lines, and quadratic and

     * cubic (B?zier) curves

     */

    public GeneralPathX getGP() {

        return gp;

    }

    /**

     * <p>

     * Sets the {@link GeneralPathX GeneralPathX} of the measurement.</p>

     *

     * @see GeneralPathX

     *

     * @param gP geometric path constructed from straight lines, and quadratic

     * and cubic (B?zier) curves

     */

    public void setGP(GeneralPathX gp) {

        this.gp = gp;

    }

    /**

     * <p>

     * Gets a vector with the X coordinates.</p>

     *

     * @return vector with the X coordinates

     */

    public Double[] getXs() {

        return x;

    }

    /**

     * <p>

     * Gets a vector with the Y coordinates.</p>

     *

     * @return vector with the Y coordinates

     */

    public Double[] getYs() {

        return y;

    }

    /**

     * <p>

     * Gets the event that has been the cause of creating this one.</p>

     *

     * @return mouse event that has been the cause of creating this one

     */

    public MouseEvent getEvent() {

        return event;

    }

    public Geometry getCircle() {

        GeometryManager manager = GeometryLocator.getGeometryManager();

        Point center;

        Geometry geom = null;

        try {

            center = (Point) manager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

            center.setX(this.getXs()[0]);

            center.setY(this.getYs()[0]);

            Point point2;

            point2 = (Point) manager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

            point2.setX(this.getXs()[1]);

            point2.setY(this.getYs()[1]);

            double radious = center.distance(point2);

            Circle circle;

            circle = (Circle) manager.create(Geometry.TYPES.CIRCLE, Geometry.SUBTYPES.GEOM2D);

            circle.setPoints(center, radious);

            geom = circle;

        } catch (CreateGeometryException e) {

            logger.error("Failed_creating_geometry", e);

        } catch (GeometryOperationNotSupportedException e) {

            logger.error("Operation_not_supported", e);

        } catch (GeometryOperationException e) {

            logger.error("Failed_performing_the_operation", e);

        }

        return geom;

    }

    public Geometry getCircumference() {

        GeometryManager manager = GeometryLocator.getGeometryManager();

        Point center;

        Geometry geom = null;

        try {

            center = (Point) manager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

            center.setX(this.getXs()[0]);

            center.setY(this.getYs()[0]);

            Point point2;

            point2 = (Point) manager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

            point2.setX(this.getXs()[1]);

            point2.setY(this.getYs()[1]);

            double radious = center.distance(point2);

            Circumference circle;

            circle = (Circumference) manager.create(Geometry.TYPES.CIRCUMFERENCE, Geometry.SUBTYPES.GEOM2D);

            circle.setPoints(center, radious);

            geom = circle;

        } catch (CreateGeometryException e) {

            logger.error("Failed_creating_geometry", e);

        } catch (GeometryOperationNotSupportedException e) {

            logger.error("Operation_not_supported", e);

        } catch (GeometryOperationException e) {

            logger.error("Failed_performing_the_operation", e);

        }

        return geom;

    }

    public Geometry getEllipse() {

        Geometry geom = null;

        try {

            GeometryManager manager = GeometryLocator.getGeometryManager();

            Point point1 = (Point) manager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

            point1.setX(this.getXs()[0]);

            point1.setY(this.getYs()[0]);

            Point point2 = (Point) manager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

            point2.setX(this.getXs()[1]);

            point2.setY(this.getYs()[1]);

            Point point3 = (Point) manager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

            point3.setX(this.getXs()[2]);

            point3.setY(this.getYs()[2]);

            double radious = point2.distance(point3);

            Ellipse ellipse;

            ellipse = (Ellipse) manager.create(Geometry.TYPES.ELLIPSE, Geometry.SUBTYPES.GEOM2D);

            ellipse.setPoints(point1, point2, radious);

            geom = ellipse;

        } catch (CreateGeometryException e) {

            logger.error("Failed_creating_geometry", e);

        } catch (GeometryOperationNotSupportedException e) {

            logger.error("Operation_not_supported", e);

        } catch (GeometryOperationException e) {

            logger.error("Failed_performing_the_operation", e);

        }

        return geom;

    }

    public Geometry getPeriEllipse() {

        Geometry geom = null;

        try {

            GeometryManager manager = GeometryLocator.getGeometryManager();

            Point point1 = (Point) manager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

            point1.setX(this.getXs()[0]);

            point1.setY(this.getYs()[0]);

            Point point2 = (Point) manager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

            point2.setX(this.getXs()[1]);

            point2.setY(this.getYs()[1]);

            Point point3 = (Point) manager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

            point3.setX(this.getXs()[2]);

            point3.setY(this.getYs()[2]);

            double radious = point2.distance(point3);

            PeriEllipse ellipse;

            ellipse = (PeriEllipse) manager.create(Geometry.TYPES.PERIELLIPSE, Geometry.SUBTYPES.GEOM2D);

            ellipse.setPoints(point1, point2, radious);

            geom = ellipse.toLines();

        } catch (CreateGeometryException e) {

            logger.error("Failed_creating_geometry", e);

        } catch (GeometryOperationNotSupportedException e) {

            logger.error("Operation_not_supported", e);

        } catch (GeometryOperationException e) {

            logger.error("Failed_performing_the_operation", e);

        } catch (GeometryException e) {

           logger.error("Can't create line geometry from ellipse", e);

        }

        return geom;

    }