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

Timestamp:

2016-07-24T15:43:24+02:00 (9 years ago)

Author:

darya

Message:

correction for roundabouts

Location:

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

Files:

• data/PTRouteDataManager.java (modified) (7 diffs)
• data/PTWay.java (modified) (1 diff)
• validation/SegmentChecker.java (modified) (4 diffs)

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTRouteDataManager.java

@@ -2 +2 @@
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 
@@ -182 +183 @@
                 return this.failedMembers;
         }
-        
+
         /**
          * Returns the route relation for which this manager was created:
+         * 
          * @return
          */
@@ -324 +326 @@
          */
         public List<PTWay> getPTWaysBetween(Way start, Way end) {
-                
+
                 List<Integer> potentialStartIndices = new ArrayList<>();
                 List<Integer> potentialEndIndices = new ArrayList<>();
-                
+
                 for (int i = 0; i < ptways.size(); i++) {
                         if (ptways.get(i).getWays().contains(start)) {
@@ -336 +338 @@
                         }
                 }
-                
+
                 List<int[]> pairList = new ArrayList<>();
-                for (Integer potentialStartIndex: potentialStartIndices) {
-                        for (Integer potentialEndIndex: potentialEndIndices) {
+                for (Integer potentialStartIndex : potentialStartIndices) {
+                        for (Integer potentialEndIndex : potentialEndIndices) {
                                 if (potentialStartIndex <= potentialEndIndex) {
-                                        int[] pair = {potentialStartIndex, potentialEndIndex};
+                                        int[] pair = { potentialStartIndex, potentialEndIndex };
                                         pairList.add(pair);
                                 }
                         }
                 }
-                
+
                 int minDifference = Integer.MAX_VALUE;
-                int[] mostSuitablePair = {0, 0};
-                for (int[] pair: pairList) {
+                int[] mostSuitablePair = { 0, 0 };
+                for (int[] pair : pairList) {
                         int diff = pair[1] - pair[0];
                         if (diff < minDifference) {
@@ -356 +358 @@
                         }
                 }
-                
+
                 List<PTWay> result = new ArrayList<>();
                 for (int i = mostSuitablePair[0]; i <= mostSuitablePair[1]; i++) {
@@ -363 +365 @@
                 return result;
         }
-        
-        /**
-         * Returns the common Node of two PTWays or null if there is no common Node
+
+        /**
+         * Returns the common Node of two PTWays or null if there is no common Node.
+         * If there is more than one common Node, only the first found is returned.
+         * 
          * @param way1
          * @param way2
@@ -371 +375 @@
          */
         public Node getCommonNode(PTWay way1, PTWay way2) {
-                
+
                 List<Way> wayList1 = way1.getWays();
                 List<Way> wayList2 = way2.getWays();
-                
-                for (int i = 0; i < wayList1.size(); i++) {
-                        for (int j = 0; j < wayList2.size(); j++) {
-                                if (wayList1.get(i).firstNode() == wayList2.get(j).firstNode() || wayList1.get(i).firstNode() == wayList2.get(j).lastNode()) {
-                                        return wayList1.get(i).firstNode();
-                                }
-                                if (wayList1.get(i).lastNode() == wayList2.get(j).firstNode() || wayList1.get(i).lastNode() == wayList2.get(j).lastNode()) {
-                                        return wayList1.get(i).lastNode();
-                                }
-                        }
-                }
+
+                HashSet<Node> nodeSet1 = new HashSet<>();
+                for (Way w : wayList1) {
+                        nodeSet1.addAll(w.getNodes());
+                }
+                HashSet<Node> nodeSet2 = new HashSet<>();
+                for (Way w : wayList2) {
+                        nodeSet2.addAll(w.getNodes());
+                }
+
+                for (Node n : nodeSet1) {
+                        if (nodeSet2.contains(n)) {
+                                return n;
+                        }
+                }
+
                 return null;
         }

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTWay.java

@@ -118 +118 @@
                 return endNodes;
         }
+        
+        public boolean containsUnsplitRoundabout() {
+                
+                List<Way> ways = this.getWays();
+                for (Way way: ways) {
+                        if (way.hasTag("junction", "roundabout") && way.firstNode() == way.lastNode()) {
+                                return true;
+                        }
+                }
+                return false;
+        }
 
 }

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

@@ -342 +342 @@
                         // matter which of the geometrically equal PTWays it finds
 
-                        // find the next node in direction of travel (which is part of the
-                        // PTWay start):
-                        firstNodeOfRouteSegmentInDirectionOfTravel = getOppositeEndNode(current,
-                                        firstNodeOfRouteSegmentInDirectionOfTravel);
-
-                        List<PTWay> nextWaysInDirectionOfTravel = this.findNextPTWaysInDirectionOfTravel(current,
-                                        firstNodeOfRouteSegmentInDirectionOfTravel);
-        
                         PTWay nextPTWayAccortingToExistingSorting = manager.getNextPTWay(current);
-                        if (!nextWaysInDirectionOfTravel.contains(nextPTWayAccortingToExistingSorting)) {
-                                List<Relation> primitives = new ArrayList<>(1);
-                                primitives.add(relation);
-                                List<OsmPrimitive> highlighted = new ArrayList<>();
-
-                                highlighted.addAll(current.getWays());
-                                highlighted.add(firstNodeOfRouteSegmentInDirectionOfTravel);
-
-                                TestError e = new TestError(this.test, Severity.WARNING, tr("PT: Problem in the route segment"),
-                                                PTAssistantValidatorTest.ERROR_CODE_STOP_BY_STOP, primitives, highlighted);
-                                this.errors.add(e);
-                                this.firstNodeOfRouteSegmentInDirectionOfTravel = null;
-                                return false;
+
+                        // if current contains an unsplit roundabout:
+                        if (current.containsUnsplitRoundabout()) {
+                                firstNodeOfRouteSegmentInDirectionOfTravel = manager.getCommonNode(current,
+                                                nextPTWayAccortingToExistingSorting);
+                                if (firstNodeOfRouteSegmentInDirectionOfTravel == null) {
+                                        List<Relation> primitives = new ArrayList<>(1);
+                                        primitives.add(relation);
+                                        List<OsmPrimitive> highlighted = new ArrayList<>();
+                                        highlighted.addAll(current.getWays());
+                                        TestError e = new TestError(this.test, Severity.WARNING, tr("PT: Problem in the route segment"),
+                                                        PTAssistantValidatorTest.ERROR_CODE_STOP_BY_STOP, primitives, highlighted);
+                                        this.errors.add(e);
+                                        return false;
+                                }
+                        } else {
+                                // if this is a regular way, not an unsplit roundabout
+
+                                // find the next node in direction of travel (which is part of
+                                // the PTWay start):
+                                firstNodeOfRouteSegmentInDirectionOfTravel = getOppositeEndNode(current,
+                                                firstNodeOfRouteSegmentInDirectionOfTravel);
+
+                                List<PTWay> nextWaysInDirectionOfTravel = this.findNextPTWaysInDirectionOfTravel(current,
+                                                firstNodeOfRouteSegmentInDirectionOfTravel);
+
+                                if (!nextWaysInDirectionOfTravel.contains(nextPTWayAccortingToExistingSorting)) {
+                                        List<Relation> primitives = new ArrayList<>(1);
+                                        primitives.add(relation);
+                                        List<OsmPrimitive> highlighted = new ArrayList<>();
+
+                                        highlighted.addAll(current.getWays());
+                                        highlighted.add(firstNodeOfRouteSegmentInDirectionOfTravel);
+
+                                        TestError e = new TestError(this.test, Severity.WARNING, tr("PT: Problem in the route segment"),
+                                                        PTAssistantValidatorTest.ERROR_CODE_STOP_BY_STOP, primitives, highlighted);
+                                        this.errors.add(e);
+                                        this.firstNodeOfRouteSegmentInDirectionOfTravel = null;
+                                        return false;
+
+                                }
                         }
 
@@ -373 +393 @@
         }
 
+        /**
+         * Will return the same node if the way is an unsplit roundabout
+         * @param way
+         * @param node
+         * @return
+         */
         private Node getOppositeEndNode(Way way, Node node) {
 
@@ -386 +412 @@
         }
 
+        /**
+         * Does not work correctly for unsplit roundabouts
+         * @param ptway
+         * @param node
+         * @return
+         */
         private Node getOppositeEndNode(PTWay ptway, Node node) {
                 if (ptway.isWay()) {
@@ -425 +457 @@
 
                         if (ptway != currentWay) {
-                                Node[] endNodes = ptway.getEndNodes();
-                                if (endNodes[0] == nextNodeInDirectionOfTravel || endNodes[1] == nextNodeInDirectionOfTravel) {
-                                        nextPtways.add(ptway);
+                                for (Way way: ptway.getWays()) {
+                                        if (way.containsNode(nextNodeInDirectionOfTravel)) {
+                                                nextPtways.add(ptway);
+                                        }
                                 }
                         }