Changeset 33502 in osm for applications/editors/josm/plugins/pt_assistant

Timestamp:

2017-08-17T11:03:28+02:00 (7 years ago)

Author:

giackserva

Message:

[pt_assistant] #josm15088 - detecting the trivial fix

Location:

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation

Files:

• PTAssistantValidatorTest.java (modified) (1 diff)
• RouteChecker.java (modified) (8 diffs)

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssistantValidatorTest.java

@@ -46 +46 @@
     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;

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/RouteChecker.java

@@ -12 +12 @@
 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 +24 @@
 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 +30 @@
 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 +75 @@
         }
 
-        int numOfGaps = countGaps(waysToCheck);
+        List<Pair<Integer, Pair<Direction, Direction>>> gaps = getGaps(waysToCheck);
+        int numOfGaps = gaps.size();
 
         if (numOfGaps > 0) {
@@ -95 +99 @@
                 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<Integer, Pair<Direction, Direction>> 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<Way> 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 +261 @@
      *
      * @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<RelationMember> waysToCheck) {
@@ -230 +268 @@
 
     /**
-     * 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 +274 @@
      */
     private int countGaps(List<RelationMember> 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<Pair<Integer, Pair<Direction, Direction>>> getGaps(List<RelationMember> waysToCheck) {
 
         WayConnectionTypeCalculator connectionTypeCalculator = new WayConnectionTypeCalculator();
         final List<WayConnectionType> 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<Pair<Integer, Pair<Direction, Direction>>> 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;
     }