Changeset 32603 in osm for applications/editors/josm

Timestamp:

2016-07-08T15:30:53+02:00 (8 years ago)

Author:

darya

Message:

Checks for adjacent ways

Location:

applications/editors/josm/plugins/pt_assistant

Files:

• src/org/openstreetmap/josm/plugins/pt_assistant/utils/RouteUtils.java (modified) (1 diff)
• src/org/openstreetmap/josm/plugins/pt_assistant/validation/WayChecker.java (modified) (4 diffs)
• test/data/oneway-wrong-direction2.osm (added)
• test/unit/org/openstreetmap/josm/plugins/pt_assistant/AbstractTest.java (modified) (1 diff)
• test/unit/org/openstreetmap/josm/plugins/pt_assistant/validation/AdjacentWaysTest.java (added)
• test/unit/org/openstreetmap/josm/plugins/pt_assistant/validation/DirecionTestTest.java (modified) (5 diffs)

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/utils/RouteUtils.java

@@ -149 +149 @@
         }
 
+        /**
+         * Checks if the ways have a common node
+         * @param w1
+         * @param w2
+         * @return
+         */
         public static boolean waysTouch(Way w1, Way w2) {
 

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

@@ -5 +5 @@
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 import javax.swing.SwingUtilities;
@@ -194 +196 @@
                         primitives.add(relation);
                         List<Way> highlighted = new ArrayList<>(1);
-                        highlighted.add(problematicWay);
+                        // highlighted.add(problematicWay);
+                        Set<Way> adjacentWays = checkAdjacentWays(problematicWay, new HashSet<Way>());
+                        highlighted.addAll(adjacentWays);
                         TestError e = new TestError(this.test, Severity.WARNING,
                                         tr("PT: Route passes a oneway road in the wrong direction"),
@@ -200 +204 @@
                         this.errors.add(e);
                 }
+
+        }
+
+        /**
+         * Checks if the current way touches its neighbouring was correctly
+         * 
+         * @param prev
+         *            can be null
+         * @param curr
+         *            cannot be null
+         * @param next
+         *            can be null
+         * @return
+         */
+        private boolean touchCorrectly(Way prev, Way curr, Way next) {
+
+                if (RouteUtils.isOnewayForPublicTransport(curr) == 0) {
+                        return true;
+                }
+
+                if (prev != null) {
+
+                        if (RouteUtils.waysTouch(curr, prev)) {
+                                Node nodeInQuestion;
+                                if (RouteUtils.isOnewayForPublicTransport(curr) == 1) {
+                                        nodeInQuestion = curr.firstNode();
+                                } else {
+                                        nodeInQuestion = curr.lastNode();
+                                }
+
+                                List<Way> nb = findNeighborWays(curr, nodeInQuestion);
+
+                                if (nb.size() < 2 && nodeInQuestion != prev.firstNode() && nodeInQuestion != prev.lastNode()) {
+                                        return false;
+                                }
+                        }
+                }
+
+                if (next != null) {
+
+                        if (RouteUtils.waysTouch(curr, next)) {
+                                Node nodeInQuestion;
+                                if (RouteUtils.isOnewayForPublicTransport(curr) == 1) {
+                                        nodeInQuestion = curr.lastNode();
+                                } else {
+                                        nodeInQuestion = curr.firstNode();
+                                }
+
+                                List<Way> nb = findNeighborWays(curr, nodeInQuestion);
+
+                                if (nb.size() < 2 && nodeInQuestion != next.firstNode() && nodeInQuestion != next.lastNode()) {
+                                        return false;
+                                }
+                        }
+                }
+
+                return true;
+
+        }
+
+        protected Set<Way> checkAdjacentWays(Way curr, Set<Way> flags) {
+                // curr is supposed to be a wrong oneway way!!
+
+                Set<Way> resultSet = new HashSet<>();
+                resultSet.addAll(flags);
+                resultSet.add(curr);
+
+                if (RouteUtils.isOnewayForPublicTransport(curr) == 0) {
+                        return null;
+                }
+
+                Node firstNodeInRouteDirection;
+                Node lastNodeInRouteDirection;
+                if (RouteUtils.isOnewayForPublicTransport(curr) == 1) {
+                        firstNodeInRouteDirection = curr.lastNode();
+                        lastNodeInRouteDirection = curr.firstNode();
+                } else {
+                        firstNodeInRouteDirection = curr.firstNode();
+                        lastNodeInRouteDirection = curr.lastNode();
+                }
+
+                List<Way> firstNodeInRouteDirectionNeighbors = findNeighborWays(curr, firstNodeInRouteDirection);
+                List<Way> lastNodeInRouteDirectionNeighbors = findNeighborWays(curr, lastNodeInRouteDirection);
+
+                for (Way nb : firstNodeInRouteDirectionNeighbors) {
+
+                        if (resultSet.contains(nb)) {
+                                continue;
+                        }
+
+                        if (RouteUtils.isOnewayForPublicTransport(nb) == 1 && nb.firstNode() == firstNodeInRouteDirection) {
+                                Set<Way> newSet = this.checkAdjacentWays(nb, resultSet);
+                                resultSet.addAll(newSet);
+
+                        } else if (RouteUtils.isOnewayForPublicTransport(nb) == -1 && nb.lastNode() == firstNodeInRouteDirection) {
+                                Set<Way> newSet = this.checkAdjacentWays(nb, resultSet);
+                                resultSet.addAll(newSet);
+
+                        }
+                }
+
+                for (Way nb : lastNodeInRouteDirectionNeighbors) {
+
+                        if (resultSet.contains(nb)) {
+                                continue;
+                        }
+
+                        if (RouteUtils.isOnewayForPublicTransport(nb) == 1 && nb.lastNode() == lastNodeInRouteDirection) {
+                                Set<Way> newSet = this.checkAdjacentWays(nb, resultSet);
+                                resultSet.addAll(newSet);
+                        } else if (RouteUtils.isOnewayForPublicTransport(nb) == -1 && nb.firstNode() == lastNodeInRouteDirection) {
+                                Set<Way> newSet = this.checkAdjacentWays(nb, resultSet);
+                                resultSet.addAll(newSet);
+                        }
+
+                }
+
+                return resultSet;
+
+        }
+
+        /**
+         * Finds all ways that touch the given way at the given node AND belong to
+         * the relation of this WayChecker
+         * 
+         * @param way
+         * @param node
+         * @return
+         */
+        private List<Way> findNeighborWays(Way way, Node node) {
+
+                List<Way> resultList = new ArrayList<>();
+
+                List<OsmPrimitive> nodeReferrers = node.getReferrers();
+
+                for (OsmPrimitive referrer : nodeReferrers) {
+                        if (referrer.getType().equals(OsmPrimitiveType.WAY)) {
+                                Way neighborWay = (Way) referrer;
+                                if (neighborWay != way && containsWay(neighborWay)) {
+                                        resultList.add(neighborWay);
+                                }
+                        }
+                }
+
+                return resultList;
+        }
+
+        /**
+         * Checks if the relation of this WayChecker contains the given way
+         * 
+         * @param way
+         * @return
+         */
+        private boolean containsWay(Way way) {
+
+                List<RelationMember> members = relation.getMembers();
+
+                for (RelationMember rm : members) {
+                        if (rm.isWay() && rm.getWay() == way) {
+                                return true;
+                        }
+                }
+
+                return false;
 
         }
@@ -365 +533 @@
         }
 
-        /**
-         * Checks if the current way touches its neighbouring was correctly
-         * 
-         * @param prev
-         *            can be null
-         * @param curr
-         *            cannot be null
-         * @param next
-         *            can be null
-         * @return
-         */
-        private boolean touchCorrectly(Way prev, Way curr, Way next) {
-
-                if (RouteUtils.isOnewayForPublicTransport(curr) == 0) {
-                        return true;
-                }
-
-                if (prev != null) {
-
-                        if (RouteUtils.waysTouch(curr, prev)) {
-                                Node nodeInQuestion;
-                                if (RouteUtils.isOnewayForPublicTransport(curr) == 1) {
-                                        nodeInQuestion = curr.firstNode();
-                                } else {
-                                        nodeInQuestion = curr.lastNode();
-                                }
-
-                                if (nodeInQuestion != prev.firstNode() && nodeInQuestion != prev.lastNode()) {
-                                        return false;
-                                }
-                        }
-                }
-
-                if (next != null) {
-
-                        if (RouteUtils.waysTouch(curr, next)) {
-                                Node nodeInQuestion;
-                                if (RouteUtils.isOnewayForPublicTransport(curr) == 1) {
-                                        nodeInQuestion = curr.lastNode();
-                                } else {
-                                        nodeInQuestion = curr.firstNode();
-                                }
-
-                                if (nodeInQuestion != next.firstNode() && nodeInQuestion != next.lastNode()) {
-                                        return false;
-                                }
-                        }
-                }
-
-                return true;
-
-        }
-
 }

applications/editors/josm/plugins/pt_assistant/test/unit/org/openstreetmap/josm/plugins/pt_assistant/AbstractTest.java

@@ -40 +40 @@
  public static final String PATH_TO_ROAD_TYPE_ERROR = "test/data/road-type.osm";
  
+ public static final String PATH_TO_ONEWAY_BAD_MEMBER_SORTING = "test/data/oneway-bad-member-sorting.osm";
  
+ public static final String PATH_TO_ONEWAY_WRONG_DIRECTION = "test/data/oneway-wrong-direction.osm";
+ public static final String PATH_TO_ONEWAY_WRONG_DIRECTION2 = "test/data/oneway-wrong-direction2.osm";
+
   /**
    * Initiates the basic parts of JOSM.

applications/editors/josm/plugins/pt_assistant/test/unit/org/openstreetmap/josm/plugins/pt_assistant/validation/DirecionTestTest.java

@@ -19 +19 @@
     
     @Test
-    public void test() {
+    public void testOnewayTrue() {
         
-        File file = new File(AbstractTest.PATH_TO_ROUNDABOUT_ONEWAY);
+        File file = new File(AbstractTest.PATH_TO_ONEWAY_WRONG_DIRECTION);
         DataSet ds = ImportUtils.importOsmFile(file, "testLayer");
         
@@ -33 +33 @@
         }
         
-        assertEquals(route.getMembersCount(), 213);
-                
+             
         List<TestError> errors = new ArrayList<>();
         
@@ -43 +42 @@
         }
         
-        assertEquals(errors.size(), 1);
+        assertEquals(errors.size(), 2);
         int onewayErrorCaught = 0;
         for (TestError e: errors ) {
@@ -51 +50 @@
         }
         
-        assertEquals(onewayErrorCaught, 1);
+        assertEquals(onewayErrorCaught, 2);
         
         // fix the direction errors:
@@ -60 +59 @@
                 @SuppressWarnings("unchecked")
                 List<OsmPrimitive> highlighted = (List<OsmPrimitive>) e.getHighlighted();
-                if (highlighted.get(0).getId() != 26130630 && highlighted.get(0).getId() != 151278290)  {
+                if (highlighted.get(0).getId() != 225732678 && highlighted.get(0).getId() != 24215210)  {
                     detectedErrorsAreCorrect = false;
                 }