Ticket #17528: intersectionissues_v5.patch

src/org/openstreetmap/josm/actions/ValidateAction.java

@@ -116 +116 @@
         private boolean canceled;
         private List<TestError> errors;
 
+        private List<Class<? extends Test>> runTests;
+
         /**
          * Constructs a new {@code ValidationTask}
          * @param tests  the tests to run
@@ -153 +155 @@
         @Override
         protected void realRun() throws SAXException, IOException,
         OsmTransferException {
+            runTests = new ArrayList<>();
             if (tests == null || tests.isEmpty())
                 return;
             errors = new ArrayList<>(200);
             getProgressMonitor().setTicksCount(tests.size() * validatedPrimitives.size());
-            int testCounter = 0;
+            runTests(tests, 0);
+            tests = null;
+            if (ValidatorPrefHelper.PREF_USE_IGNORE.get()) {
+                getProgressMonitor().setCustomText("");
+                getProgressMonitor().subTask(tr("Updating ignored errors ..."));
+                for (TestError error : errors) {
+                    if (canceled) return;
+                    error.updateIgnored();
+                }
+            }
+        }
+
+        protected int runTests(Collection<Test> tests, int testCounter) {
+            ArrayList<Test> remaining = new ArrayList<>();
             for (Test test : tests) {
                 if (canceled)
-                    return;
+                    return testCounter;
+                if (test.getAfterClass() != null && !runTests.contains(test.getAfterClass())) {
+                    remaining.add(test);
+                    continue;
+                }
                 testCounter++;
-                getProgressMonitor().setCustomText(tr("Test {0}/{1}: Starting {2}", testCounter, tests.size(), test.getName()));
+                getProgressMonitor().setCustomText(tr("Test {0}/{1}: Starting {2}", testCounter, this.tests.size(), test.getName()));
                 test.setPartialSelection(formerValidatedPrimitives != null);
+                test.setPreviousErrors(errors);
                 test.startTest(getProgressMonitor().createSubTaskMonitor(validatedPrimitives.size(), false));
                 test.visit(validatedPrimitives);
                 test.endTest();
                 errors.addAll(test.getErrors());
                 test.clear();
+                runTests.add(test.getClass());
             }
-            tests = null;
-            if (ValidatorPrefHelper.PREF_USE_IGNORE.get()) {
-                getProgressMonitor().setCustomText("");
-                getProgressMonitor().subTask(tr("Updating ignored errors ..."));
-                for (TestError error : errors) {
-                    if (canceled) return;
-                    error.updateIgnored();
-                }
+            if (!remaining.isEmpty()) {
+                testCounter = runTests(remaining, testCounter);
             }
+            return testCounter;
         }
     }
 }

src/org/openstreetmap/josm/data/validation/OsmValidator.java

@@ -49 +49 @@
 import org.openstreetmap.josm.data.validation.tests.DuplicatedWayNodes;
 import org.openstreetmap.josm.data.validation.tests.Highways;
 import org.openstreetmap.josm.data.validation.tests.InternetTags;
+import org.openstreetmap.josm.data.validation.tests.IntersectionIssues;
 import org.openstreetmap.josm.data.validation.tests.Lanes;
 import org.openstreetmap.josm.data.validation.tests.LongSegment;
 import org.openstreetmap.josm.data.validation.tests.MapCSSTagChecker;
@@ -148 +149 @@
         LongSegment.class, // 3500 .. 3599
         PublicTransportRouteTest.class, // 3600 .. 3699
         RightAngleBuildingTest.class, // 3700 .. 3799
+        IntersectionIssues.class, // 3800 .. 3899
     };
 
     /**

src/org/openstreetmap/josm/data/validation/Test.java

@@ -46 +46 @@
     /** Name of the test */
     protected final String name;
 
+    /** Test to run after */
+    protected Class<? extends Test> afterTest;
+
     /** Description of the test */
     protected final String description;
 
@@ -67 +70 @@
     /** The list of errors */
     protected List<TestError> errors = new ArrayList<>(30);
 
+    /** The list of previously found errors */
+    protected List<TestError> previousErrors;
+
     /** Whether the test is run on a partial selection data */
     protected boolean partialSelection;
 
@@ -84 +90 @@
      * @param description Description of the test
      */
     public Test(String name, String description) {
+        this(name, description, null);
+    }
+
+    /**
+     * Constructor
+     * @param name Name of the test
+     * @param description Description of the test
+     * @param afterTest Ensure the test is run after a test with this name
+     *
+     * @since xxx
+     */
+    public Test(String name, String description, Class<? extends Test> afterTest) {
         this.name = name;
         this.description = description;
+        this.afterTest = afterTest;
     }
 
     /**
@@ -178 +197 @@
     }
 
     /**
+     * Set the validation errors accumulated by other tests until this moment
+     * For validation errors accumulated by this test, use {@code getErrors()}
+     * @param errors The errors from previous tests
+     */
+    public void setPreviousErrors(List<TestError> errors) {
+        previousErrors = errors;
+    }
+
+    /**
      * Notification of the end of the test. The tester may perform additional
      * actions and destroy the used structures.
      * <p>
@@ -319 +347 @@
     }
 
     /**
+     * Get the class that the test must run after
+     * @return A class that extends {@code Test}
+     *
+     * @since xxx
+     */
+    public Class<? extends Test> getAfterClass() {
+        return afterTest;
+    }
+
+    /**
      * Determines if the test has been canceled.
      * @return {@code true} if the test has been canceled, {@code false} otherwise
      */

src/org/openstreetmap/josm/data/validation/tests/IntersectionIssues.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.validation.tests;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.gpx.GpxDistance;
+import org.openstreetmap.josm.data.gpx.WayPoint;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.WaySegment;
+import org.openstreetmap.josm.data.validation.Severity;
+import org.openstreetmap.josm.data.validation.Test;
+import org.openstreetmap.josm.data.validation.TestError;
+import org.openstreetmap.josm.gui.progress.ProgressMonitor;
+import org.openstreetmap.josm.tools.Geometry;
+import org.openstreetmap.josm.tools.Logging;
+
+/**
+ * Finds issues with highway intersections
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class IntersectionIssues extends Test {
+    private static final int INTERSECTIONISSUESCODE = 3800;
+    /** The code for an intersection which briefly interrupts a road */
+    public static final int SHORT_DISCONNECT = INTERSECTIONISSUESCODE + 0;
+    /** The code for a node that is almost on a way */
+    public static final int NEARBY_NODE = INTERSECTIONISSUESCODE + 1;
+    /** The distance to consider for nearby nodes/short disconnects */
+    public static final double MAX_DISTANCE = 5.0; // meters
+    /** The distance to consider for nearby nodes with tags */
+    public static final double MAX_DISTANCE_NODE_INFORMATION = MAX_DISTANCE / 5.0; // meters
+    /** The maximum angle for almost overlapping ways */
+    public static final double MAX_ANGLE = 15.0; // degrees
+    /** The maximum length to consider for almost overlapping ways */
+    public static final double MAX_LENGTH = 5.0; // meters
+
+    private HashMap<String, ArrayList<Way>> ways;
+    ArrayList<Way> allWays;
+
+    /**
+     * Construct a new {@code IntersectionIssues} object
+     */
+    public IntersectionIssues() {
+        super(tr("Intersection Issues"), tr("Check for issues at intersections"), OverlappingWays.class);
+    }
+
+    @Override
+    public void startTest(ProgressMonitor monitor) {
+        super.startTest(monitor);
+        ways = new HashMap<>();
+        allWays = new ArrayList<>();
+    }
+
+    @Override
+    public void endTest() {
+        Way pWay = null;
+        try {
+            for (String key : ways.keySet()) {
+                ArrayList<Way> comparison = ways.get(key);
+                pWay = comparison.get(0);
+                checkNearbyEnds(comparison);
+            }
+            for (Way way : allWays) {
+                pWay = way;
+                for (Way way2 : allWays) {
+                    if (way2.equals(way)) continue;
+                    pWay = way2;
+                    if (way.getBBox().intersects(way2.getBBox())) {
+                        checkNearbyNodes(way, way2);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            if (pWay != null) {
+                Logging.debug("Way https://osm.org/way/{0} caused an error", pWay.getOsmId());
+            }
+            Logging.warn(e);
+        }
+        ways = null;
+        allWays = null;
+        super.endTest();
+    }
+
+    @Override
+    public void visit(Way way) {
+        if (!way.isUsable()) return;
+        if (way.hasKey("highway") && !way.get("highway").contains("_link")) {
+            String[] identityTags = new String[] {"name", "ref"};
+            for (String tag : identityTags) {
+                if (way.hasKey(tag)) {
+                    ArrayList<Way> similar = ways.get(way.get(tag)) == null ? new ArrayList<>() : ways.get(way.get(tag));
+                    if (!similar.contains(way)) similar.add(way);
+                    ways.put(way.get(tag), similar);
+                }
+            }
+            if (!allWays.contains(way)) allWays.add(way);
+        }
+    }
+
+    /**
+     * Check for ends that are nearby but not directly connected
+     * @param comparison Ways to look at
+     */
+    public void checkNearbyEnds(ArrayList<Way> comparison) {
+        ArrayList<Way> errored = new ArrayList<>();
+        for (Way one : comparison) {
+            LatLon oneLast = one.lastNode().getCoor();
+            LatLon oneFirst = one.firstNode().getCoor();
+            for (Way two : comparison) {
+                if (one.equals(two)) continue;
+                if (one.isFirstLastNode(two.firstNode()) || one.isFirstLastNode(two.lastNode()) ||
+                        (errored.contains(one) && errored.contains(two))) continue;
+                LatLon twoLast = two.lastNode().getCoor();
+                LatLon twoFirst = two.firstNode().getCoor();
+                int nearCase = getNearCase(oneFirst, oneLast, twoFirst, twoLast);
+                if (nearCase != 0) {
+                    for (Way way : two.lastNode().getParentWays()) {
+                        if (way.equals(two)) continue;
+                        if (one.hasKey("name") && way.hasKey("name") && way.get("name").equals(one.get("name")) ||
+                                one.hasKey("ref") && way.hasKey("ref") && way.get("ref").equals(one.get("ref"))) {
+                            return;
+                        }
+                    }
+                    for (Way way : two.firstNode().getParentWays()) {
+                        if (way.equals(two)) continue;
+                        if (one.hasKey("name") && way.hasKey("name") && way.get("name").equals(one.get("name")) ||
+                                one.hasKey("ref") && way.hasKey("ref") && way.get("ref").equals(one.get("ref"))) {
+                            return;
+                        }
+                    }
+                }
+                if (nearCase > 0) {
+                    List<Way> nearby = new ArrayList<>();
+                    nearby.add(one);
+                    nearby.add(two);
+                    List<WaySegment> segments = new ArrayList<>();
+                    if ((nearCase & 1) != 0) {
+                        segments.add(new WaySegment(two, two.getNodesCount() - 2));
+                        segments.add(new WaySegment(one, one.getNodesCount() - 2));
+                    }
+                    if ((nearCase & 2) != 0) {
+                        segments.add(new WaySegment(two, two.getNodesCount() - 2));
+                        segments.add(new WaySegment(one, 0));
+                    }
+                    if ((nearCase & 4) != 0) {
+                        segments.add(new WaySegment(two, 0));
+                        segments.add(new WaySegment(one, one.getNodesCount() - 2));
+                    }
+                    if ((nearCase & 8) != 0) {
+                        segments.add(new WaySegment(two, 0));
+                        segments.add(new WaySegment(one, 0));
+                    }
+                    errored.addAll(nearby);
+                    allWays.removeAll(errored);
+                    TestError.Builder testError = TestError.builder(this, Severity.WARNING, SHORT_DISCONNECT)
+                            .primitives(nearby)
+                            .highlightWaySegments(segments)
+                            .message(tr("Disconnected road"));
+                    errors.add(testError.build());
+                }
+            }
+        }
+    }
+
+    /**
+     * Get nearby cases
+     * @param oneFirst The {@code LatLon} of the the first node of the first way
+     * @param oneLast The {@code LatLon} of the the last node of the first way
+     * @param twoFirst The {@code LatLon} of the the first node of the second way
+     * @param twoLast The {@code LatLon} of the the last node of the second way
+     * @return A bitwise int (8421 -> twoFirst/oneFirst, twoFirst/oneLast, twoLast/oneFirst, twoLast/oneLast)
+     *
+     */
+    private int getNearCase(LatLon oneFirst, LatLon oneLast, LatLon twoFirst, LatLon twoLast) {
+        int returnInt = 0;
+        if (twoLast.greatCircleDistance(oneLast) <= MAX_DISTANCE) {
+            returnInt = returnInt | 1;
+        }
+        if (twoLast.greatCircleDistance(oneFirst) <= MAX_DISTANCE) {
+            returnInt = returnInt | 2;
+        }
+        if (twoFirst.greatCircleDistance(oneLast) <= MAX_DISTANCE) {
+            returnInt = returnInt | 4;
+        }
+        if (twoFirst.greatCircleDistance(oneFirst) <= MAX_DISTANCE) {
+            returnInt = returnInt | 8;
+        }
+        return returnInt;
+    }
+
+    /**
+     * Check nearby nodes to an intersection of two ways
+     * @param way1 A way to check an almost intersection with
+     * @param way2 A way to check an almost intersection with
+     */
+    public void checkNearbyNodes(Way way1, Way way2) {
+        Node intersectingNode = getIntersectingNode(way1, way2);
+        if (intersectingNode == null) return;
+        checkNearbyNodes(way1, way2, intersectingNode);
+        checkNearbyNodes(way2, way1, intersectingNode);
+    }
+
+    private void checkNearbyNodes(Way way1, Way way2, Node nearby) {
+        for (Node node : way1.getNeighbours(nearby)) {
+            if (node.equals(nearby) || way2.containsNode(node)) continue;
+            WayPoint waypoint = new WayPoint(node.getCoor());
+            double distance = GpxDistance.getDistance(way2, waypoint);
+            double angle = getSmallestAngle(way2, nearby, node);
+            if (((distance < MAX_DISTANCE && !node.isTagged())
+                    || (distance < MAX_DISTANCE_NODE_INFORMATION && node.isTagged()))
+                    && angle < MAX_ANGLE) {
+                List<Way> primitiveIssues = new ArrayList<>();
+                primitiveIssues.add(way1);
+                primitiveIssues.add(way2);
+                List<TestError> tErrors = new ArrayList<>();
+                tErrors.addAll(previousErrors);
+                tErrors.addAll(getErrors());
+                for (TestError error : tErrors) {
+                    int code = error.getCode();
+                    if ((code == SHORT_DISCONNECT || code == NEARBY_NODE
+                            || code == OverlappingWays.OVERLAPPING_HIGHWAY
+                            || code == OverlappingWays.DUPLICATE_WAY_SEGMENT
+                            || code == OverlappingWays.OVERLAPPING_HIGHWAY_AREA
+                            || code == OverlappingWays.OVERLAPPING_WAY
+                            || code == OverlappingWays.OVERLAPPING_WAY_AREA
+                            || code == OverlappingWays.OVERLAPPING_RAILWAY
+                            || code == OverlappingWays.OVERLAPPING_RAILWAY_AREA)
+                            && primitiveIssues.containsAll(error.getPrimitives())) {
+                        return;
+                    }
+                }
+                List<WaySegment> waysegments = new ArrayList<>();
+                int index = way1.getNodes().indexOf(nearby);
+                if (index >= way1.getNodesCount() - 1) index--;
+                waysegments.add(new WaySegment(way1, index));
+                if (index > 0) waysegments.add(new WaySegment(way1, index - 1));
+                index = way2.getNodes().indexOf(nearby);
+                if (index >= way2.getNodesCount() - 1) index--;
+                waysegments.add(new WaySegment(way2, index));
+                if (index > 0) waysegments.add(new WaySegment(way2, index - 1));
+
+                TestError.Builder testError = TestError.builder(this, Severity.WARNING, NEARBY_NODE)
+                        .primitives(primitiveIssues)
+                        .highlightWaySegments(waysegments)
+                        .message(tr("Almost overlapping highways"));
+                errors.add(testError.build());
+            }
+        }
+    }
+
+    /**
+     * Get the intersecting node of two ways
+     * @param way1 A way that (hopefully) intersects with way2
+     * @param way2 A way to find an intersection with
+     * @return {@code Node} if there is an intersecting node, {@code null} otherwise
+     */
+    public Node getIntersectingNode(Way way1, Way way2) {
+        for (Node node : way1.getNodes()) {
+            if (way2.containsNode(node)) {
+                return node;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Get the corner angle between nodes
+     * @param way The way with additional nodes
+     * @param intersection The node to get angles around
+     * @param comparison The node to get angles from
+     * @return The angle for comparison->intersection->(additional node) (normalized degrees)
+     */
+    public double getSmallestAngle(Way way, Node intersection, Node comparison) {
+        Set<Node> neighbours = way.getNeighbours(intersection);
+        double angle = Double.MAX_VALUE;
+        EastNorth eastNorthIntersection = intersection.getEastNorth();
+        EastNorth eastNorthComparison = comparison.getEastNorth();
+        for (Node node : neighbours) {
+            EastNorth eastNorthNode = node.getEastNorth();
+            double tAngle = Geometry.getCornerAngle(eastNorthComparison, eastNorthIntersection, eastNorthNode);
+            if (Math.abs(tAngle) < angle) angle = Math.abs(tAngle);
+        }
+        return Geometry.getNormalizedAngleInDegrees(angle);
+    }
+}