Ticket #16803: 16803.patch

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

@@ -12 +12 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 import org.openstreetmap.josm.command.ChangePropertyCommand;
 import org.openstreetmap.josm.data.osm.Node;
@@ -22 +21 @@
 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.tools.Geometry;
 import org.openstreetmap.josm.tools.Logging;
 import org.openstreetmap.josm.tools.Utils;
 
@@ -164 +164 @@
      */
     public static boolean isHighwayLinkOkay(final Way way) {
         final String highway = way.get(HIGHWAY);
-        if (highway == null || !highway.endsWith("_link")
-                || !IN_DOWNLOADED_AREA.test(way.getNode(0)) || !IN_DOWNLOADED_AREA.test(way.getNode(way.getNodesCount()-1))) {
+        if (highway == null || !highway.endsWith("_link")) {
             return true;
         }
 
-        final Set<OsmPrimitive> referrers = new HashSet<>();
-
-        if (way.isClosed()) {
-            // for closed way we need to check all adjacent ways
-            for (Node n: way.getNodes()) {
-                referrers.addAll(n.getReferrers());
+        for (int i = 0; i < way.getNodesCount(); i++) {
+            Node n = way.getNode(i);
+            if (!IN_DOWNLOADED_AREA.test(n))
+                return true;
+            Set<Way> otherWays = new HashSet<>();
+            otherWays.addAll(Utils.filteredCollection(n.getReferrers(), Way.class));
+            if (otherWays.size() == 1)
+                continue;
+            otherWays.remove(way);
+            otherWays.removeIf(w -> !highway.startsWith(w.get(HIGHWAY)) || w.getNodesCount() < 2);
+            if (otherWays.isEmpty())
+                continue;
+            //TODO: ignore ways which are not allowed because of turn restrictions, oneway attributes or access rules?
+            HashSet<Way> sameTag = new HashSet<>();
+            for (Way ow : otherWays) {
+                if (highway.equals(ow.get(HIGHWAY)))
+                    sameTag.add(ow);
+                else
+                    return true;
             }
-        } else {
-            referrers.addAll(way.firstNode().getReferrers());
-            referrers.addAll(way.lastNode().getReferrers());
+            // we have way(s) with the same _link tag, ignore those with a sharp angle
+            final int pos = i;
+            sameTag.removeIf(w -> isSharpAngle(way, pos, w));
+            if (!sameTag.isEmpty())
+                return true;
         }
+        return false;
 
-        // Find ways of same class (exact class of class_link)
-        List<Way> sameClass = Utils.filteredCollection(referrers, Way.class).stream().filter(
-                otherWay -> !way.equals(otherWay) && otherWay.hasTag(HIGHWAY, highway, highway.replaceAll("_link$", "")))
-                .collect(Collectors.toList());
-        if (sameClass.size() > 1) {
-            // It is possible to have a class_link between 2 segments of same class
-            // in roundabout designs that physically separate a specific turn from the main roundabout
-            // But if we have more than a single adjacent class, and one of them is a roundabout, that's an error
-            for (Way w : sameClass) {
-                if (w.hasTag("junction", "roundabout")) {
-                    return false;
-                }
+    }
+
+    /**
+     * Check if the two given connected ways form a sharp angle.
+     * @param way 1st way
+     * @param nodePos node position of connecting node in 1st way
+     * @param otherWay the 2nd way
+     * @return true if angle is sharp
+     */
+    private static boolean isSharpAngle(Way way, int nodePos, Way otherWay) {
+        Node n = way.getNode(nodePos);
+        Node n0 = way.getNode(nodePos == 0 ? 1 : nodePos -1);
+
+        Node n2 = null;
+        for (int i = 0; i < otherWay.getNodesCount(); i++) {
+            if (n == otherWay.getNode(i)) {
+                n2 = otherWay.getNode(i > 0 ? i-1 : 1);
+                break;
             }
         }
-        // Link roads should always at least one adjacent segment of same class
-        return !sameClass.isEmpty();
+        assert n != null && n0 != null : "node not found in 1st way";
+        assert n2 != null : "node not found in 2nd way";
+        if (n2 != null) {
+            double angle = Geometry.getNormalizedAngleInDegrees(
+                    Geometry.getCornerAngle(n0.getEastNorth(), n.getEastNorth(), n2.getEastNorth()));
+            return angle < 80;
+        }
+        return false;
     }
 
     private void testHighwayLink(final Way way) {