Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssistantValidatorTest.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssistantValidatorTest.java (revision 33501) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssistantValidatorTest.java (revision 33502) @@ -46,4 +46,5 @@ public static final int ERROR_CODE_FROM_TO_ROUTE_TAG = 3701; public static final int ERROR_CODE_FIRST_LAST_STOP_WAY_TAG = 3702; + public static final int ERROR_CODE_TRIVIAL_FIX = 3710; public static final int ERROR_CODE_SORTING = 3711; public static final int ERROR_CODE_PARTIAL_SORTING = 3712; Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/RouteChecker.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/RouteChecker.java (revision 33501) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/RouteChecker.java (revision 33502) @@ -12,4 +12,5 @@ import org.openstreetmap.josm.command.ChangeCommand; import org.openstreetmap.josm.command.Command; +import org.openstreetmap.josm.data.osm.Node; import org.openstreetmap.josm.data.osm.OsmPrimitive; import org.openstreetmap.josm.data.osm.OsmPrimitiveType; @@ -23,4 +24,5 @@ import org.openstreetmap.josm.gui.dialogs.relation.sort.RelationSorter; import org.openstreetmap.josm.gui.dialogs.relation.sort.WayConnectionType; +import org.openstreetmap.josm.gui.dialogs.relation.sort.WayConnectionType.Direction; import org.openstreetmap.josm.gui.dialogs.relation.sort.WayConnectionTypeCalculator; import org.openstreetmap.josm.plugins.pt_assistant.data.PTRouteDataManager; @@ -28,4 +30,5 @@ import org.openstreetmap.josm.plugins.pt_assistant.utils.RouteUtils; import org.openstreetmap.josm.plugins.pt_assistant.utils.StopToWayAssigner; +import org.openstreetmap.josm.tools.Pair; /** @@ -72,5 +75,6 @@ } - int numOfGaps = countGaps(waysToCheck); + List>> gaps = getGaps(waysToCheck); + int numOfGaps = gaps.size(); if (numOfGaps > 0) { @@ -95,6 +99,41 @@ TestError e = builder.build(); this.errors.add(e); - } - } + } else if (numOfGaps == numOfGapsAfterSort) { + //if sorting doesn't help try to fix the gaps trivially + //by adding one way + for (Pair> gap : gaps) { + Way before = waysToCheck.get(gap.a).getWay(); + Way after = waysToCheck.get(gap.a + 1).getWay(); + + Way fix = findTrivialFix(before, gap.b.a, after, gap.b.b); + if (fix != null) { + Builder builder = TestError.builder(this.test, Severity.WARNING, PTAssistantValidatorTest.ERROR_CODE_TRIVIAL_FIX); + builder.message(tr("PT: Route gap can be closed by adding a single way")); + builder.primitives(relation, before, after, fix); + TestError e = builder.build(); + this.errors.add(e); + } + } + } + } + } + + //given two ways and the direction of the route on those two ways, it seeks + //another way that connects the two given ones respecting the directions + private Way findTrivialFix(Way before, Direction beforeDirection, Way after, Direction afterDirection) { + Node startNode = beforeDirection == Direction.FORWARD ? before.lastNode() : before.firstNode(); + Node lastNode = afterDirection == Direction.FORWARD ? after.firstNode() : after.lastNode(); + List candidates = startNode.getParentWays(); + candidates.removeIf(w -> !RouteUtils.isWaySuitableForPublicTransport(w)); + + for (Way candidate : candidates) { + if (candidate.equals(before)) continue; + if ((candidate.firstNode().equals(startNode) && candidate.lastNode().equals(lastNode)) + || (candidate.lastNode().equals(startNode) && candidate.firstNode().equals(lastNode))) { + return candidate; + } + } + + return null; } @@ -222,6 +261,5 @@ * * @param waysToCheck ways to check - * @return true if has gap (in the sense of continuity of ways in the - * Relation Editor), false otherwise + * @return true if has gaps , false otherwise */ public boolean hasGaps(List waysToCheck) { @@ -230,7 +268,5 @@ /** - * Counts how many gaps there are for a given list of ways. It does not check if - * the way actually stands for a public transport platform - that should be - * checked beforehand. + * Counts how many gaps there are for a given list of ways. * * @param waysToCheck ways to check @@ -238,21 +274,31 @@ */ private int countGaps(List waysToCheck) { - int numberOfGaps = 0; + return getGaps(waysToCheck).size(); + } + + /** + * Finds the gaps (in the sense of continuity of ways in the Relation + * Editor) in a given list of ways. It does not check if the way actually + * stands for a public transport platform - that should be checked beforehand. + * + * @param waysToCheck ways to check + * @return It returns a list of gaps. a gap is a pair of an index (the index + * of the way right before the gap) and a pair of directions of the two ways + * around the gap. + */ + private List>> getGaps(List waysToCheck) { WayConnectionTypeCalculator connectionTypeCalculator = new WayConnectionTypeCalculator(); final List links = connectionTypeCalculator.updateLinks(waysToCheck); - for (int i = 0; i < links.size(); i++) { - final WayConnectionType link = links.get(i); - if (!(i == 0 || link.linkPrev) - || !(i == links.size() - 1 - || link.linkNext) - || link.direction == null - || WayConnectionType.Direction.NONE.equals(link.direction)) { - numberOfGaps++; - i++; - } - } - - return numberOfGaps; + List>> gaps = new ArrayList<>(); + + for (int i = 0; i < links.size() -1; i++) { + WayConnectionType link = links.get(i); + if (!link.linkNext) { + gaps.add(new Pair<>(i, new Pair<>(link.direction, links.get(i+1).direction))); + } + } + + return gaps; }