Application: gvSIG desktop

package org.gvsig.app.project.documents.view.toolListeners.snapping.snappers;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.geom.Geometry;

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

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

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

import org.gvsig.fmap.mapcontrol.PrimitivesDrawer;

import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.ISnapperGeometriesVectorial;

import org.gvsig.fmap.mapcontrol.tools.snapping.snappers.impl.AbstractSnapper;

import org.gvsig.i18n.Messages;

/**

 * Intersection point snapper.

 *

 * @author Vicente Caballero Navarro

 */

public class IntersectionPointSnapper extends AbstractSnapper

    implements ISnapperGeometriesVectorial {

    private static final Logger LOG = LoggerFactory.getLogger(IntersectionPointSnapper.class);

        private static int maxPointsGeom = 1000;

        private List<Geometry> geometries;

        private static long lastLogTime = 0;

    public Point2D getSnapPoint(Point2D point, Geometry geom,

        double tolerance, Point2D lastPointEntered) {

            if (!(geom instanceof Curve)){

                    return null;

            }

            Point2D result = null;

        if (geometries == null) {

            return null;

        }

        for (int i = 0; i < geometries.size(); i++) {

                Point2D r = intersects(geom, geometries.get(i), point, tolerance);

            if (r != null) {

                result = r;

            }

        }

        return result;

    }

    private Point2D intersects(Geometry geometry1, Geometry geometry2, Point2D point,

            double tolerance) {

            //If there is a topology error don't intersects

            if ((geometry1 == null) || (geometry2 == null)){

                return null;

            }

            if (hasMoreThanVertices(geometry1, maxPointsGeom)

                || hasMoreThanVertices(geometry2, maxPointsGeom)) {

                return null;

            }

            Geometry geometry;

        try {

            geometry = geometry1.intersection(geometry2);

            if ((geometry != null) && (geometry.getType() == Geometry.TYPES.POINT)){

                return geometry.getHandlers(Geometry.SELECTHANDLER)[0].getPoint();

            }

        } catch (GeometryOperationNotSupportedException e) {

            LOG.error("Unable to intersect these geometries", e);

        } catch (GeometryOperationException e) {

            LOG.error("Unable to intersect these geometries", e);

        } catch (Exception e) {

            /*

             * Sometimes there is a JTS TopologyException.

             * The cause is unknown because it's difficult to

             * reproduce, but probably caused by extremely similar

             * geometries. This is unlikely to cause functionality

             * problems, so we'll only log it once every 5 seconds

             * (otherwise the user can see performance issues because

             * this exception is thrown many times in those strange

             * cases)

             */

            long curr_time = System.currentTimeMillis();

            // This ensures not more than one log every 5 seconds

            if (curr_time - lastLogTime > 5000) {

                LOG.info("Error while intersecting.", e);

                lastLogTime = curr_time;

            }

        }

            return null;

    }

    public void draw(PrimitivesDrawer primitivesDrawer, Point2D pPixels) {

            primitivesDrawer.setColor(getColor());

        int half = getSizePixels() / 2;

        int x1 = (int) (pPixels.getX() - half);

        int x2 = (int) (pPixels.getX() + half);

        int y1 = (int) (pPixels.getY() - half);

        int y2 = (int) (pPixels.getY() + half);

        primitivesDrawer.drawLine(x1, y1, x2, y2);

        primitivesDrawer.drawLine(x1, y2, x2, y1);

    }

    public String getToolTipText() {

        return Messages.getText("Intersection_point");

    }

        public void setGeometries(List geoms) {

            this.geometries = geoms;

        }

        /**

     * Tells whether geometry has more than n vertices using its path

     * iterator

     * @param geom

     * @param n

     * @return

     */

    private static boolean hasMoreThanVertices(Geometry geom, int n) {

        PathIterator piter = geom.getPathIterator(null);

        if (piter == null) {

            return false;

        }

        if (n < 1) {

            return true;

        }

        int cnt = n;

        while (!piter.isDone()) {

            piter.next();

            cnt--;

            if (cnt == 0) {

                return true;

            }

        }

        return false;

    }

}