Ticket #18127: 18127.patch

Index: src/org/openstreetmap/josm/data/validation/OsmValidator.java
===================================================================
--- src/org/openstreetmap/josm/data/validation/OsmValidator.java        (revision 15345)
@@ -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,155 @@
+// 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 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 = 3900; // 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);
+    }
+
+    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")) {
+            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;
+            if (node1 != null && node2 != null && node3 != null) {
+                Double angle = Math.toDegrees(
+                               Math.abs(
+                               Geometry.getCornerAngle(node1.getEastNorth(), node2.getEastNorth(), node3.getEastNorth())));
+                if (angle < MAX_ANGLE) {
+                    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);
+                    }
+                }
+            }
+            i++;
+        }
+    }
+
+    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();
+    }
+}