/ - Diff - Application: gvSIG desktop - gvSIG

Revision 41098

     import java.awt.Color;
     import java.awt.Graphics;
     import java.awt.Graphics2D;
     import java.awt.Point;
     import java.awt.geom.AffineTransform;
     import java.awt.geom.Line2D;
     import java.awt.geom.Point2D;
-...
     		//MapControl asociado
     		return;
+    	}
     	public void calculateSnapPoint(Point point) {
     	    /*
     	     * This is the behavior of a MapControl when there is no snapping.
     	     * We do the same and save a lot of computations
     	     */
             adjustedPoint = point;
             mapAdjustedPoint = null;
+    	}
+    }

         	// mapControlManager.registerSnapper("InsertPointSnapper", new InsertPointSnapper.class);
         	/*
         	 * This snapper is not implemented in a sensible way.
         	 * We must think if it makes sense and how to implement it
+        	 *
         	mapControlManager.registerSnapper("IntersectionPointSnapper", IntersectionPointSnapper.class);
         	*/
             mapControlManager.registerSnapper("IntersectionPointSnapper", IntersectionPointSnapper.class);
         	mapControlManager.registerSnapper("MediumPointSnapper", MediumPointSnapper.class);
         	mapControlManager.registerSnapper("PerpendicularPointSnapper", PerpendicularPointSnapper.class);
         	mapControlManager.registerSnapper("TangentPointSnapper", TangentPointSnapper.class);

      */
     package org.gvsig.app.project.documents.view.toolListeners.snapping.snappers;
     import java.awt.geom.PathIterator;
     import java.awt.geom.Point2D;
     import java.util.ArrayList;
     import java.util.Iterator;
     import java.util.List;
     import com.vividsolutions.jts.geom.GeometryFactory;
     import com.vividsolutions.jts.geom.MultiPoint;
     import com.vividsolutions.jts.geom.Point;
     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.aggregate.MultiCurve;
     import org.gvsig.fmap.geom.aggregate.MultiSurface;
     import org.gvsig.fmap.geom.primitive.Curve;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.fmap.geom.primitive.Surface;
     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;
-...
         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 static final int MAX_GEOMETRIES_IN_RELAXED_LIST = 30;
         public static final int MAX_GEOMETRIES_WITHIN_TOLERANCE = 5;
     	private List relaxedList = null;
     	private GeometryFactory jtsGeoFact = null;
     	private long errorMsgCount = 0;
         public Point2D getSnapPoint(Point2D point, Geometry geom,
             double tolerance, Point2D lastPointEntered) {
         	if (!(geom instanceof Curve)){
         		return null;
+        	}
         	Point2D result = null;
             if (geometries == null) {
         public Point2D getSnapPoint(
             Point2D point,
             Geometry geom,
             double tolerance,
             Point2D lastPointEntered) {
             if (geom == 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;
+                }
             if (relaxedList == null
                 || relaxedList.size() < 2 /* We need 2 to intersect */
                 || relaxedList.size() > MAX_GEOMETRIES_IN_RELAXED_LIST) {
                 /*
                  * If there are a lot of geometries, we assume the user
                  * is not interested in snapping now. The relaxed list
                  * might be long because the spatial index used perhaps
                  * is "lazy" so the value of MAX_GEOMETRIES_IN_RELAXED_LIST
                  * has to be not very small
                  */
                 return null;
+            }
             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;
             List<Geometry> refinedList = null;
             try {
                 geometry = geometry1.intersection(geometry2);
                 if ((geometry != null) && (geometry.getType() == Geometry.TYPES.POINT)){
                     return geometry.getHandlers(Geometry.SELECTHANDLER)[0].getPoint();
                 refinedList = refineList(relaxedList, point, tolerance);
             } catch (Exception e1) {
                 errorMsgCount++;
                 if (errorMsgCount % 100 == 0) {
                     /*
                      * Prevents too many lines in logger. If this happens,
                      * it will happen many times, so we'll see it in the log file.
                      */
                     LOG.info("Error while refining list: " + e1.getMessage());
                     errorMsgCount = 0;
+                }
             } 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) {
                 return null;
+            }
             if (refinedList.size() > MAX_GEOMETRIES_WITHIN_TOLERANCE) {
                 /*
                  * 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)
                  * This refined list contains the geometries that are
                  * close to the current mouse. Again we use an upper limit
                  * to prevent the case where the user is in a zoom where
                  * he is not interested in snapping.
                  */
                 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.getMessage());
                     lastLogTime = curr_time;
                 return null;
+            }
             List<Point> interPoints = getInterPoints(refinedList);
             if (interPoints.size() == 0) {
                 return null;
+            }
             com.vividsolutions.jts.geom.Geometry jtsg = null;
             try {
                 jtsg = (com.vividsolutions.jts.geom.Geometry) geom.invokeOperation("toJTS", null);
             } catch (Exception e) {
                 errorMsgCount++;
                 if (errorMsgCount % 100 == 0) {
                     /*
                      * Prevents too many lines in logger. If this happens,
                      * it will happen many times, so we'll see it in the log file.
                      */
                     LOG.info("Error while refining list: " + e.getMessage());
                     errorMsgCount = 0;
+                }
+            }
         	return null;
                 return null;
+            }
             double zerodist = 0.001 * tolerance;
             int n = interPoints.size();
             Point po = null;
             for (int i=0; i<n; i++) {
                 po = interPoints.get(i);
                 if (point.distance(po.getX(), po.getY()) < tolerance) {
                     // This is a candidate, now we check that it belongs to the
                     // current geometry
                     if (jtsg.distance(po) < zerodist) {
                         return new Point2D.Double(po.getX(), po.getY());
+                    }
+                }
+            }
             return null;
+        }
         private List<Geometry> refineList(
             List geomlist,
             Point2D point,
             double tolerance) throws Exception {
             List<Geometry> resp = new ArrayList<Geometry>();
             if (geomlist == null || geomlist.size() == 0) {
                 return resp;
+            }
             double point_tol_north = point.getY() + tolerance;
             double point_tol_south = point.getY() - tolerance;
             double point_tol_east = point.getX() + tolerance;
             double point_tol_west = point.getX() - tolerance;
             Geometry item = null;
             Envelope env = null;
             Iterator iter = geomlist.iterator();
             while (iter.hasNext()) {
                 item = (Geometry) iter.next();
                 if (item.intersects(
                     point_tol_west, point_tol_south,
                     point_tol_east - point_tol_west,
                     point_tol_north - point_tol_south)) {
                     resp.add(item);
+                }
+            }
             return resp;
+        }
         public void draw(PrimitivesDrawer primitivesDrawer, Point2D pPixels) {
         	primitivesDrawer.setColor(getColor());
-...
+        }
     	public void setGeometries(List geoms) {
     	    this.geometries = geoms;
     	    relaxedList = leaveUsefulGeometries(geoms);
+    	}
     	private List<Point> getInterPoints(List geomes) {
     	    List<Point> resp = new ArrayList<Point>();
     	    List borders = getJTSBorders(geomes);
     	    com.vividsolutions.jts.geom.Geometry jtsg1 = null;
     	    com.vividsolutions.jts.geom.Geometry jtsg2 = null;
     	    com.vividsolutions.jts.geom.Geometry jtsinter = null;
     	    int n = borders.size();
     	    Point jtsp = null;
     	    MultiPoint jtsmp = null;
     	    for (int i=0; i<n; i++) {
     	        for (int j=0; j<i; j++) {
     	            if (i != j) {
     	                jtsg1 = (com.vividsolutions.jts.geom.Geometry) borders.get(i);
     	                jtsg2 = (com.vividsolutions.jts.geom.Geometry) borders.get(j);
     	                jtsinter = jtsg1.intersection(jtsg2);
     	                if (jtsinter instanceof Point) {
     	                    jtsp = (Point) jtsinter;
     	                    resp.add(jtsp);
     	                } else {
     	                    if (jtsinter instanceof MultiPoint) {
     	                        jtsmp = (MultiPoint) jtsinter;
     	                        int m = jtsmp.getNumGeometries();
     	                        for (int k=0; k<m; k++) {
     	                            jtsp = (Point) jtsmp.getGeometryN(k);
     	                            resp.add(jtsp);
+    	                        }
+    	                    }
+    	                }
+    	            }
+    	        }
+    	    }
     	    return resp;
+    	}
     	/**
          * 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) {
         private List getJTSBorders(List gvsigGeoms) {
             PathIterator piter = geom.getPathIterator(null);
             if (piter == null) {
                 return false;
+            }
             List resp = new ArrayList();
             com.vividsolutions.jts.geom.Geometry jtsborder = null;
             if (n < 1) {
                 return true;
             if (gvsigGeoms != null && gvsigGeoms.size() > 0) {
                 Iterator iter = gvsigGeoms.iterator();
                 Object itemobj = null;
                 while (iter.hasNext()) {
                     itemobj = iter.next();
                     if (itemobj instanceof Geometry) {
                         jtsborder = getJTSBorder((Geometry) itemobj);
                         if (jtsborder != null) {
                             resp.add(jtsborder);
+                        }
+                    }
+                }
+            }
             return resp;
+        }
             int cnt = n;
             while (!piter.isDone()) {
                 piter.next();
                 cnt--;
                 if (cnt == 0) {
                     return true;
         private com.vividsolutions.jts.geom.Geometry getJTSBorder(Geometry geom) {
             com.vividsolutions.jts.geom.Geometry resp = null;
             if (geom instanceof Curve || geom instanceof MultiCurve) {
                 try {
                     resp = (com.vividsolutions.jts.geom.Geometry)
                         geom.invokeOperation("toJTS", null);
                 } catch (Exception e) {
                     errorMsgCount++;
                     if (errorMsgCount % 100 == 0) {
                         /*
                          * Prevents too many lines in logger. If this happens,
                          * it will happen many times, so we'll see it in the log file.
                          */
                         LOG.info("Error while refining list: " + e.getMessage());
                         errorMsgCount = 0;
+                    }
                     return null;
+                }
                 return resp;
             } else {
                 if (geom instanceof Surface || geom instanceof MultiSurface) {
                     try {
                         resp = (com.vividsolutions.jts.geom.Geometry)
                             geom.invokeOperation("toJTS", null);
                         return resp.getBoundary();
                     } catch (Exception e) {
                         errorMsgCount++;
                         if (errorMsgCount % 100 == 0) {
                             /*
                              * Prevents too many lines in logger. If this happens,
                              * it will happen many times, so we'll see it in the log file.
                              */
                             LOG.info("Error while refining list: " + e.getMessage());
                             errorMsgCount = 0;
+                        }
                         return null;
+                    }
                 } else {
                     return null;
+                }
+            }
             return false;
+        }
         private List<Geometry> leaveUsefulGeometries(List geoms) {
             List resp = new ArrayList();
             if (geoms == null || geoms.size() == 0) {
                 return resp;
+            }
             Object item = null;
             Iterator iter = geoms.iterator();
             while (iter.hasNext()) {
                 item = iter.next();
                 if (item instanceof Curve || item instanceof Surface
                     || item instanceof MultiCurve || item instanceof MultiSurface) {
                     resp.add(item);
+                }
+            }
             return resp;
+        }
+    }

+         *
          * @see ViewPort#fromMapPoint(Point2D)
          */
         private Point2D adjustedPoint;
         protected Point2D adjustedPoint;
         /**
          * <p>
          * Determines if the position of the snap of the mouse's cursor on the
-...
+         *
          * @see MapControl#toMapPoint
          */
         private Point2D mapAdjustedPoint;
         protected Point2D mapAdjustedPoint;
         /**
          * Renderer used to draw the layers.

Also available in: Unified diff