Index: src/org/openstreetmap/josm/actions/ValidateAction.java =================================================================== --- src/org/openstreetmap/josm/actions/ValidateAction.java (revision 14955) +++ src/org/openstreetmap/josm/actions/ValidateAction.java (working copy) @@ -116,6 +116,8 @@ private boolean canceled; private List errors; + private List> runTests; + /** * Constructs a new {@code ValidationTask} * @param tests the tests to run @@ -153,32 +155,47 @@ @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 tests, int testCounter) { + ArrayList 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; } } } Index: src/org/openstreetmap/josm/data/validation/OsmValidator.java =================================================================== --- src/org/openstreetmap/josm/data/validation/OsmValidator.java (revision 14955) +++ src/org/openstreetmap/josm/data/validation/OsmValidator.java (working copy) @@ -49,6 +49,7 @@ 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,6 +149,7 @@ LongSegment.class, // 3500 .. 3599 PublicTransportRouteTest.class, // 3600 .. 3699 RightAngleBuildingTest.class, // 3700 .. 3799 + IntersectionIssues.class, // 3800 .. 3899 }; /** Index: src/org/openstreetmap/josm/data/validation/Test.java =================================================================== --- src/org/openstreetmap/josm/data/validation/Test.java (revision 14955) +++ src/org/openstreetmap/josm/data/validation/Test.java (working copy) @@ -46,6 +46,9 @@ /** Name of the test */ protected final String name; + /** Test to run after */ + protected Class afterTest; + /** Description of the test */ protected final String description; @@ -67,6 +70,9 @@ /** The list of errors */ protected List errors = new ArrayList<>(30); + /** The list of previously found errors */ + protected List previousErrors; + /** Whether the test is run on a partial selection data */ protected boolean partialSelection; @@ -84,8 +90,21 @@ * @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 afterTest) { this.name = name; this.description = description; + this.afterTest = afterTest; } /** @@ -178,6 +197,15 @@ } /** + * 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 errors) { + previousErrors = errors; + } + + /** * Notification of the end of the test. The tester may perform additional * actions and destroy the used structures. *

@@ -319,6 +347,16 @@ } /** + * Get the class that the test must run after + * @return A class that extends {@code Test} + * + * @since xxx + */ + public Class getAfterClass() { + return afterTest; + } + + /** * Determines if the test has been canceled. * @return {@code true} if the test has been canceled, {@code false} otherwise */ Index: src/org/openstreetmap/josm/data/validation/tests/IntersectionIssues.java =================================================================== --- src/org/openstreetmap/josm/data/validation/tests/IntersectionIssues.java (nonexistent) +++ src/org/openstreetmap/josm/data/validation/tests/IntersectionIssues.java (working copy) @@ -0,0 +1,295 @@ +// 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> ways; + ArrayList 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 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 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 comparison) { + ArrayList 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 nearby = new ArrayList<>(); + nearby.add(one); + nearby.add(two); + List 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)) continue; + WayPoint waypoint = new WayPoint(node.getCoor()); + double distance = GpxDistance.getDistance(way2, waypoint); + if (((distance < MAX_DISTANCE && !node.isTagged()) + || (distance < MAX_DISTANCE_NODE_INFORMATION && node.isTagged())) + && getSmallestAngle(way2, nearby, node) < MAX_ANGLE) { + List primitiveIssues = new ArrayList<>(); + primitiveIssues.add(way1); + primitiveIssues.add(way2); + List 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 waysegments = new ArrayList<>(); + int index = way1.getNodes().indexOf(nearby); + waysegments.add(new WaySegment(way1, index)); + if (index > 0) waysegments.add(new WaySegment(way1, index - 1)); + index = way2.getNodes().indexOf(nearby); + waysegments.add(new WaySegment(way2, index)); + if (index > 0) waysegments.add(new WaySegment(way2, index - 1)); + boolean isShort = false; + for (WaySegment segment : waysegments) { + if (segment.toWay().getLength() < MAX_LENGTH) isShort = true; + } + if (!isShort) return; + + 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 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); + } +}