Changeset 4162 in osm for applications

Timestamp:

2007-08-16T02:39:09+02:00 (17 years ago)

Author:

frsantos

Message:

Include water and coastline in crossing roads test
Fix calculation of the cells that a segment crosses

Location:

applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator

Files:

• GridLayer.java (added)
• OSMValidatorPlugin.java (modified) (1 diff)
• PreferenceEditor.java (modified) (1 diff)
• tests/CrossingSegments.java (modified) (8 diffs)
• util/Util.java (modified) (3 diffs)

applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/OSMValidatorPlugin.java

@@ -83 +83 @@
                 newFrame.addToggleDialog(validationDialog);
             Main.main.addLayer(new ErrorLayer(tr("Validation errors")));
+                if( Main.pref.hasKey(PreferenceEditor.PREF_DEBUG + ".grid") )
+                        Main.main.addLayer(new GridLayer(tr("Grid")));
             Layer.listeners.add(this); 
                 }

applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/PreferenceEditor.java

@@ -26 +26 @@
         /** The preferences prefix */
         public static final String PREFIX = "validator";
-        
+
+        /** The preferences key for debug preferences */
+        public static final String PREF_DEBUG = PREFIX + ".debug";
+
         /** The preferences key for enabled tests */
         public static final String PREF_TESTS = PREFIX + ".tests";

applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/CrossingSegments.java

@@ -10 +10 @@
 import org.openstreetmap.josm.plugins.validator.*;
 import org.openstreetmap.josm.plugins.validator.util.Bag;
+import org.openstreetmap.josm.plugins.validator.util.Util;
 
 /**
@@ -53 +54 @@
             return;
         
-        if( w.get("highway") == null && w.get("waterway") == null && w.get("railway") == null )
+        String coastline1 = w.get("natural"); 
+        boolean isCoastline1 = coastline1 != null && (coastline1.equals("water") || coastline1.equals("coastline"));
+        String railway1 = w.get("railway"); 
+        boolean isSubway1 = railway1 != null && railway1.equals("subway");
+        if( w.get("highway") == null && w.get("waterway") == null && !isSubway1 && !isCoastline1) 
                 return;
         
         String layer1 = w.get("layer");
-        String railway1 = w.get("railway");
         for(Segment s : w.segments)
         {
@@ -63 +67 @@
                         continue;
                 
-            ExtendedSegment es1 = new ExtendedSegment(s, layer1, railway1);
+            ExtendedSegment es1 = new ExtendedSegment(s, layer1, railway1, coastline1);
             List<List<ExtendedSegment>> cellSegments = getSegments(s);
             for( List<ExtendedSegment> segments : cellSegments)
@@ -74 +78 @@
                         String layer2 = es2.layer;
                         String railway2 = es2.railway;
-                        if( (layer1 == null && layer2 == null || layer1 != null && layer1.equals(layer2)) &&
-                                !("subway".equals(railway1) && "subway".equals(railway2)) &&    
-                                es1.intersects(es2))
-                        {
-                            List<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();
-                            primitives.add(es1.s);
-                            primitives.add(es2.s);
-                            errors.add( new TestError(this, Severity.WARNING, tr("Crossing roads"), primitives) );
-                        }
+                        String coastline2 = es2.coastline;
+                        if( (layer1 != null || layer2 != null) && (layer1 == null || !layer1.equals(layer2)) )
+                                continue;
+                        
+                        if( !es1.intersects(es2) ) continue;
+                            if( isSubway1 && "subway".equals(railway2)) continue;
+                            
+                            boolean isCoastline2 = coastline2 != null && (coastline2.equals("water") || coastline2.equals("coastline"));
+                        if( isCoastline1 != isCoastline2 ) continue;
+                        
+                    List<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();
+                    primitives.add(es1.s);
+                    primitives.add(es2.s);
+                    errors.add( new TestError(this, Severity.WARNING, tr("Crossing roads"), primitives) );
                     }
                     segments.add(es1);
@@ -92 +101 @@
      * Returns all the cells this segment crosses . Each cell contains the list
      * of segments already processed
-     * <p>
-     * This method uses the Bresenham algorithm to follow all cells this segment
-     * crosses, so, in very few cases (when the segment is very long, and
-     * crosses a cell very close to the corner), it can miss a cell.
      * 
      * @param s The segment
@@ -103 +108 @@
         {
                 List<List<ExtendedSegment>> cells = new ArrayList<List<ExtendedSegment>>();
-                long x0 = Math.round(s.from.eastNorth.east() * 1000);
-                long x1 = Math.round(s.to.eastNorth.east()   * 1000);
-        long y0 = Math.round(s.from.eastNorth.north()* 1000);
-        long y1 = Math.round(s.to.eastNorth.north()  * 1000);
-        
-        boolean steep = Math.abs(y1 - y0) > Math.abs(x1 - x0);
-        long aux;
-        if( steep )
-        {
-            aux = x0; x0 = x1; x1 = aux;
-            aux = y0; y0 = y1; y1 = aux;
-        }
-        if( x0 > x1 )
-        {
-            aux = x0; x0 = x1; x1 = aux;
-            aux = y0; y0 = y1; y1 = aux;
-        }
-        long dx  = x1 - x0,
-             dy  = Math.abs(y1 - y0),
-             y   = y0,
-             error = -dx/2,
-             ystep = y0 < y1 ? 1 : -1;
-      
-        for( long x = x0; x <= x1; x++ )  
-        {
-            Point2D p = steep ? new Point2D.Double(y, x) : new Point2D.Double(x, y);
-            List<ExtendedSegment> segments = cellSegments.get( p );
+                for( Point2D cell : Util.getSegmentCells(s, 10000) )
+                {
+            List<ExtendedSegment> segments = cellSegments.get( cell );
             if( segments == null )
             {
                 segments = new ArrayList<ExtendedSegment>();
-                cellSegments.put(p, segments);
+                cellSegments.put(cell, segments);
             }
             cells.add(segments);
-            
-            error += dy;
-            if( error > 0 )
-            {
-                error -= dx;
-                y += ystep;
-            }
         }
         
@@ -162 +136 @@
         /** The railway type */
                 private String railway;
+
+                /** The coastline type */
+                private String coastline;
         
         /**
@@ -168 +145 @@
          * @param layer The layer of the way this segment is in
          * @param railway The railway type of the way this segment is in
+         * @param coastline The coastlyne typo of the way the segment is in
          */
-        public ExtendedSegment(Segment s, String layer, String railway)
+        public ExtendedSegment(Segment s, String layer, String railway, String coastline)
         {
             this.s = s;
             this.layer = layer;
             this.railway = railway;
+            this.coastline = coastline;
         }
         

applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/util/Util.java

@@ -261 +261 @@
 
         // First, round coordinates
-        long x0 = Math.round(start.from.eastNorth.east()  * 100000);
-        long y0 = Math.round(start.from.eastNorth.north() * 100000);
-        long x1 = Math.round(end.to.eastNorth.east()      * 100000);
-        long y1 = Math.round(end.to.eastNorth.north()     * 100000);
+        long x0 = Math.round(start.from.eastNorth.east()  * 10000);
+        long y0 = Math.round(start.from.eastNorth.north() * 10000);
+        long x1 = Math.round(end.to.eastNorth.east()      * 10000);
+        long y1 = Math.round(end.to.eastNorth.north()     * 10000);
 
         // Start of the way
@@ -292 +292 @@
 
         // Then floor coordinates, in case the way is in the border of the cell.
-        x0 = (long)Math.floor(start.from.eastNorth.east()  * 100000);
-        y0 = (long)Math.floor(start.from.eastNorth.north() * 100000);
-        x1 = (long)Math.floor(end.to.eastNorth.east()      * 100000);
-        y1 = (long)Math.floor(end.to.eastNorth.north()     * 100000);
+        x0 = (long)Math.floor(start.from.eastNorth.east()  * 10000);
+        y0 = (long)Math.floor(start.from.eastNorth.north() * 10000);
+        x1 = (long)Math.floor(end.to.eastNorth.east()      * 10000);
+        y1 = (long)Math.floor(end.to.eastNorth.north()     * 10000);
 
         // Start of the way
@@ -327 +327 @@
         return cells;
     }    
+    
+    /**
+         * Returns the coordinates of all cells in a grid that a segment goes through.
+         * 
+         * @param s The segment
+         * @param gridDetail The detail of the grid. Bigger values give smaller cells, but a bigger number of them.
+         * @return A list with the coordinates of all cells
+         */
+        public static List<Point2D> getSegmentCells(Segment s, int gridDetail) 
+        {
+                List<Point2D> cells = new ArrayList<Point2D>();
+                double x0 = s.from.eastNorth.east() * gridDetail;
+                double x1 = s.to.eastNorth.east()   * gridDetail;
+        double y0 = s.from.eastNorth.north()* gridDetail + 1;
+        double y1 = s.to.eastNorth.north()  * gridDetail + 1;
+
+        if( x0 > x1 )
+        {
+                // Move to 1st-4th cuadrants
+            double aux;
+            aux = x0; x0 = x1; x1 = aux;
+            aux = y0; y0 = y1; y1 = aux;
+        }
+        
+        double dx  = x1 - x0;
+        double dy  = y1 - y0;
+        long stepY = y0 <= y1 ? 1 : -1;
+        long gridX0 = (long)Math.floor(x0);
+        long gridX1 = (long)Math.floor(x1);
+        long gridY0 = (long)Math.floor(y0);
+        long gridY1 = (long)Math.floor(y1);
+        
+        long maxSteps = (gridX1 - gridX0) + Math.abs(gridY1 - gridY0) + 1;
+                while( (gridX0 <= gridX1 && (gridY0 - gridY1)*stepY <= 0) && maxSteps-- > 0)
+        {
+                        cells.add( new Point2D.Double(gridX0, gridY0) );
+                        
+                // Is the cross between the segment and next vertical line nearer than the cross with next horizontal line? 
+                // Note: segment line formula: y=dy/dx(x-x1)+y1
+                        // Note: if dy < 0, must use *bottom* line. If dy > 0, must use upper line 
+                double scanY = dy/dx * (gridX0 + 1 - x1) + y1 + (dy < 0 ? -1 : 0);
+                double scanX = dx/dy * (gridY0 + (dy < 0 ? 0 : 1)*stepY - y1) + x1;
+                
+                double distX = Math.pow(gridX0 + 1 - x0, 2) + Math.pow(scanY - y0, 2);
+                        double distY = Math.pow(scanX - x0, 2) + Math.pow(gridY0 + stepY - y0, 2);
+                        
+                        if( distX < distY)
+                        gridX0 += 1;
+                else
+                        gridY0 += stepY;
+        }
+                
+                return cells;
+        }   
 }