Changeset 18453 in osm for applications/editors/josm/plugins

Timestamp:

2009-11-04T15:17:43+01:00 (15 years ago)

Author:

daeron

Message:

Partial rewrite of coastline checks

Build a list of the coastline ways, and in the end do all the checks.
This way it should now avoid some rare cases when the old code found bogus
errors due to some bug/feature in BackreferenceDataSet.

File:

• applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/Coastlines.java (modified) (5 diffs)

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

@@ -4 +4 @@
 
 import java.awt.geom.Area;
-import java.awt.geom.Point2D;
 import java.util.*;
 
@@ -14 +13 @@
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
+import org.openstreetmap.josm.gui.progress.ProgressMonitor;
 import org.openstreetmap.josm.plugins.validator.Severity;
 import org.openstreetmap.josm.plugins.validator.Test;
@@ -22 +22 @@
  *
  * @author frsantos
+ * @author Teemu Koskinen
  */
 public class Coastlines extends Test
@@ -29 +30 @@
     protected static int UNCONNECTED_COASTLINE = 903;
 
-    private boolean fixable = false;
+    private List<Way> coastlines;
+
+    private Area downloadedArea = null;
 
     /**
@@ -41 +44 @@
 
     @Override
-    public void visit(Way way)
-    {
-        if(!way.isUsable() || way.isClosed())
-            return;
-
-        String natural = way.get("natural");
-        if(natural == null || !natural.equals("coastline"))
-            return;
-
-        Node firstNode = way.firstNode();
-        Node lastNode = way.lastNode();
-        Way previousWay = null;
-        Way nextWay = null;
-
-        for (OsmPrimitive parent: this.backreferenceDataSet.getParents(firstNode)) {
-            natural = parent.get("natural");
-            if (parent instanceof Way && !way.equals(parent) && (natural != null && "coastline".equals(natural))) {
-                previousWay = (Way)parent;
-                break;
-            }
-        }
-        for (OsmPrimitive parent: this.backreferenceDataSet.getParents(lastNode)) {
-            natural = parent.get("natural");
-            if (parent instanceof Way && !way.equals(parent) && (natural != null && "coastline".equals(natural))) {
-                nextWay = (Way)parent;
-                break;
-            }
-        }
-
-        List<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();
-        List<OsmPrimitive> highlight = new ArrayList<OsmPrimitive>();
-        primitives.add(way);
+    public void startTest(ProgressMonitor monitor)
+    {
+        super.startTest(monitor);
 
         OsmDataLayer layer = Main.map.mapView.getEditLayer();
-        Area downloadedArea = null;
+
         if (layer != null)
             downloadedArea = layer.data.getDataSourceArea();
 
-        if (previousWay == null || nextWay == null) {
-            boolean firstNodeUnconnected = false;
-            boolean lastNodeUnconnected = false;
-
-            if (previousWay == null && (downloadedArea == null || downloadedArea.contains(firstNode.getCoor()))) {
-                firstNodeUnconnected = true;
-                highlight.add(firstNode);
-            }
-            if (nextWay == null && (downloadedArea == null || downloadedArea.contains(lastNode.getCoor()))) {
-                lastNodeUnconnected = true;
-                highlight.add(lastNode);
-            }
-
-            if (firstNodeUnconnected || lastNodeUnconnected)
-                errors.add(new TestError(this, Severity.ERROR, tr("Unconnected coastline"),
-                                         UNCONNECTED_COASTLINE, primitives, highlight));
-        }
-
-        boolean firstNodeUnordered = (previousWay != null && !firstNode.equals(previousWay.lastNode()));
-        boolean lastNodeUnordered = (nextWay != null && !lastNode.equals(nextWay.firstNode()));
-
-        if (firstNodeUnordered || lastNodeUnordered) {
-            if (firstNodeUnordered && lastNodeUnordered && !previousWay.equals(nextWay)) {
+        coastlines = new LinkedList<Way>();
+    }
+
+    @Override
+    public void endTest()
+    {
+        for (Way c1 : coastlines) {
+            Node head = c1.firstNode();
+            Node tail = c1.lastNode();
+
+            if (head.equals(tail))
+                continue;
+
+            int headWays = 0;
+            int tailWays = 0;
+            boolean headReversed = false;
+            boolean tailReversed = false;
+            boolean headUnordered = false;
+            boolean tailUnordered = false;
+            Way next = null;
+            Way prev = null;
+
+            for (Way c2 : coastlines) {
+                if (c1 == c2)
+                    continue;
+
+                if (c2.containsNode(head)) {
+                    headWays++;
+                    next = c2;
+
+                    if (head.equals(c2.firstNode()))
+                        headReversed = true;
+                    else if (!head.equals(c2.lastNode()))
+                        headUnordered = true;
+                }
+
+                if (c2.containsNode(tail)) {
+                    tailWays++;
+                    prev = c2;
+
+                    if (tail.equals(c2.lastNode()))
+                        tailReversed = true;
+                    else if (!tail.equals(c2.firstNode()))
+                        tailUnordered = true;
+                }
+            }
+
+
+            List<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();
+            primitives.add(c1);
+
+            if (headWays == 0 || tailWays == 0) {
+                List<OsmPrimitive> highlight = new ArrayList<OsmPrimitive>();
+
+                System.out.println("Unconnected coastline: " + c1.getId());
+                if (headWays == 0 && (downloadedArea == null || downloadedArea.contains(head.getCoor()))) {
+                    System.out.println("headways: " +headWays+ " node: " + head.toString());
+                    highlight.add(head);
+                }
+                if (tailWays == 0 && (downloadedArea == null || downloadedArea.contains(tail.getCoor()))) {
+                    System.out.println("tailways: " +tailWays+ " tail: " + tail.toString());
+                    highlight.add(tail);
+                }
+
+                if (highlight.size() > 0)
+                    errors.add(new TestError(this, Severity.ERROR, tr("Unconnceted coastline"),
+                                             UNCONNECTED_COASTLINE, primitives, highlight));
+            }
+
+            boolean unordered = false;
+            boolean reversed = false;
+
+            if (headWays == 1 && headReversed && tailWays == 1 && tailReversed)
+                reversed = true;
+
+            if (headWays > 1 || tailWays > 1)
+                unordered = true;
+            else if (headUnordered || tailUnordered)
+                unordered = true;
+            else if (reversed && next == prev)
+                unordered = true;
+
+            if (unordered) {
+                List<OsmPrimitive> highlight = new ArrayList<OsmPrimitive>();
+
+                System.out.println("Unordered coastline: " + c1.toString());
+                if (headWays > 1 || headUnordered || reversed) {
+                    System.out.println("head: " + head.toString());
+                    highlight.add(head);
+                }
+                if (tailWays > 1 || tailUnordered || reversed) {
+                    System.out.println("tail: " + tail.toString());
+                    highlight.add(tail);
+                }
+
+                errors.add(new TestError(this, Severity.ERROR, tr("Unordered coastline"),
+                                         UNORDERED_COASTLINE, primitives, highlight));
+            }
+            else if (reversed) {
                 errors.add(new TestError(this, Severity.ERROR, tr("Reversed coastline"),
                                          REVERSED_COASTLINE, primitives));
-
-            } else {
-                if (firstNodeUnordered)
-                    highlight.add(firstNode);
-                if (lastNodeUnordered)
-                    highlight.add(lastNode);
-
-                errors.add(new TestError(this, Severity.ERROR, tr("Unordered coastline"),
-                                         UNORDERED_COASTLINE, primitives, highlight));
             }
         }
+
+        coastlines = null;
+        downloadedArea = null;
+
+        super.endTest();
+    }
+
+    @Override
+    public void visit(Way way)
+    {
+        if (!way.isUsable())
+            return;
+
+        String natural = way.get("natural");
+        if (natural == null || !natural.equals("coastline"))
+            return;
+
+        coastlines.add(way);
     }