Ticket #18127: 18127.2.patch

Index: src/org/openstreetmap/josm/data/validation/OsmValidator.java
===================================================================
--- src/org/openstreetmap/josm/data/validation/OsmValidator.java        (revision 15348)
+++ src/org/openstreetmap/josm/data/validation/OsmValidator.java        (working copy)
@@ -61,6 +62,7 @@
 import org.openstreetmap.josm.data.validation.tests.RelationChecker;
 import org.openstreetmap.josm.data.validation.tests.RightAngleBuildingTest;
 import org.openstreetmap.josm.data.validation.tests.SelfIntersectingWay;
+import org.openstreetmap.josm.data.validation.tests.SharpAngles;
 import org.openstreetmap.josm.data.validation.tests.SimilarNamedWays;
 import org.openstreetmap.josm.data.validation.tests.TagChecker;
 import org.openstreetmap.josm.data.validation.tests.TurnrestrictionTest;
@@ -148,6 +150,8 @@
         LongSegment.class, // 3500 .. 3599
         PublicTransportRouteTest.class, // 3600 .. 3699
         RightAngleBuildingTest.class, // 3700 .. 3799
+        SharpAngles.class, // 3800 .. 3899
     };

     /**
Index: src/org/openstreetmap/josm/data/validation/tests/SharpAngles.java
===================================================================
--- src/org/openstreetmap/josm/data/validation/tests/SharpAngles.java   (nonexistent)
+++ src/org/openstreetmap/josm/data/validation/tests/SharpAngles.java   (working copy)
@@ -0,0 +1,182 @@
+// 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.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.TreeSet;
+
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+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;
+
+/**
+ * Find highways that have sharp angles
+ * @author Taylor Smock
+ *
+ */
+public class SharpAngles extends Test {
+    private static final int SHARPANGLESCODE = 3800; // TODO change this before commit
+    /** The code for a sharp angle */
+    protected static final int SHARP_ANGLES = SHARPANGLESCODE + 0;
+    /** The maximum angle for sharp angles */
+    protected static final double MAX_ANGLE = 45.0; // degrees
+    /** The stepping points for severity */
+    protected static final Map<Double, Severity> severityBreakPoints = new LinkedHashMap<>();
+    static {
+        severityBreakPoints.put(MAX_ANGLE, Severity.OTHER);
+        severityBreakPoints.put(MAX_ANGLE * 2 / 3, Severity.WARNING);
+        severityBreakPoints.put(MAX_ANGLE / 3, Severity.ERROR);
+    }
+    /** Specific highway types to ignore */
+    protected static final Collection<String> ignoreHighways = new TreeSet<>();
+    static {
+        ignoreHighways.add("rest_area");
+        ignoreHighways.add("platform");
+        ignoreHighways.add("services");
+    }
+
+    ArrayList<Way> allWays;
+    /**
+     * Construct a new {@code IntersectionIssues} object
+     */
+    public SharpAngles() {
+        super(tr("Sharp angles"), tr("Check for sharp angles on roads"));
+    }
+
+    @Override
+    public void startTest(ProgressMonitor monitor) {
+        super.startTest(monitor);
+        allWays = new ArrayList<>();
+    }
+
+    @Override
+    public void endTest() {
+        Way pWay = null;
+        try {
+            for (Way way : allWays) {
+                pWay = way;
+                checkWayForSharpAngles(way);
+            }
+        } catch (Exception e) {
+            if (pWay != null) {
+                Logging.debug("Way https://osm.org/way/{0} caused an error ({1})", pWay.getOsmId(), e);
+            }
+            Logging.warn(e);
+        }
+        allWays = null;
+        super.endTest();
+    }
+
+    @Override
+    public void visit(Way way) {
+        if (!way.isUsable()) return;
+        if (way.hasKey("highway")) {
+            if (way.hasKey("area") && way.get("area").equalsIgnoreCase("yes") ||
+                    ignoreHighways.contains(way.get("highway"))) {
+                return;
+            }
+            allWays.add(way);
+        }
+    }
+
+    /**
+     * Check nodes in a way for sharp angles
+     * @param way A way to check for sharp angles
+     */
+    public void checkWayForSharpAngles(Way way) {
+        Node node1 = null;
+        Node node2 = null;
+        Node node3 = null;
+        int i = -2;
+        for (Node node : way.getNodes()) {
+            node1 = node2;
+            node2 = node3;
+            node3 = node;
+            checkAngle(node1, node2, node3, i, way);
+            i++;
+        }
+        if (way.isClosed()) {
+            node1 = node2;
+            node2 = node3;
+            node3 = way.firstNode();
+            checkAngle(node1, node2, node3, i, way);
+        }
+    }
+
+    private void checkAngle(Node node1, Node node2, Node node3, Integer i, Way way) {
+        if (node1 == null || node2 == null || node3 == null) return;
+        EastNorth n1 = node1.getEastNorth();
+        EastNorth n2 = node2.getEastNorth();
+        EastNorth n3 = node3.getEastNorth();
+        Double angle = Math.toDegrees(Math.abs(Geometry.getCornerAngle(n1, n2, n3)));
+        if (angle < MAX_ANGLE) {
+            processSharpAngleForErrorCreation(angle, i, way);
+        }
+    }
+
+    private void processSharpAngleForErrorCreation(Double angle, Integer i, Way way) {
+        Logging.info("Angle: {0}\r\nWaySegment: {1}, {2}", angle, i-1, i);
+        List<WaySegment> waysegmentList = Arrays.asList(new WaySegment(way, i), new WaySegment(way, i+1));
+        Optional<WaySegment> possibleShortSegment = waysegmentList.stream()
+                .min(Comparator.comparing(segment -> segment.toWay().getLength()));
+        if (possibleShortSegment.isPresent()) {
+            createNearlyOverlappingError(angle,
+                    Collections.singleton(way), Collections.singleton(possibleShortSegment.get()));
+        } else {
+            createNearlyOverlappingError(angle, Collections.singleton(way), waysegmentList);
+        }
+    }
+
+    private void createNearlyOverlappingError(Double angle,
+            Collection<? extends OsmPrimitive> primitiveIssues, Collection<WaySegment> waysegments) {
+        TestError.Builder testError = TestError.builder(this, getSeverity(angle), SHARP_ANGLES)
+                .primitives(primitiveIssues)
+                .highlightWaySegments(waysegments)
+                .message(tr("Sharp angle"));
+        errors.add(testError.build());
+    }
+
+    private Severity getSeverity(Double angle) {
+        Severity rSeverity = Severity.OTHER;
+        for (Entry<Double, Severity> entry : severityBreakPoints.entrySet()) {
+            if (angle < entry.getKey()) {
+                rSeverity = entry.getValue();
+            }
+        }
+        return rSeverity;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other instanceof SharpAngles) {
+            SharpAngles otherReal = (SharpAngles) other;
+            if (otherReal.allWays.equals(allWays)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return super.hashCode();
+    }
+}