Changeset 32707 in osm for applications/editors/josm/plugins/pt_assistant/src

Timestamp:

2016-07-24T04:46:09+02:00 (8 years ago)

Author:

darya

Message:

stop-by-stop test added

Location:

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

Files:

• data/PTRouteDataManager.java (modified) (3 diffs)
• data/PTRouteSegment.java (modified) (1 diff)
• data/PTWay.java (modified) (4 diffs)
• utils/StopToWayAssigner.java (modified) (18 diffs)
• validation/PTAssistantValidatorTest.java (modified) (6 diffs)
• validation/SegmentChecker.java (modified) (7 diffs)

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

@@ -5 +5 @@
 
 import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.RelationMember;
@@ -181 +182 @@
                 return this.failedMembers;
         }
+        
+        /**
+         * Returns the route relation for which this manager was created:
+         * @return
+         */
+        public Relation getRelation() {
+                return this.relation;
+        }
 
         /**
@@ -218 +227 @@
                 return null;
         }
+
+        /**
+         * Returns all PTWays of this route that contain the given way.
+         * 
+         * @param way
+         * @return
+         */
+        public List<PTWay> findPTWaysThatContain(Way way) {
+
+                List<PTWay> ptwaysThatContain = new ArrayList<>();
+                for (PTWay ptway : ptways) {
+                        if (ptway.getWays().contains(way)) {
+                                ptwaysThatContain.add(ptway);
+                        }
+                }
+                return ptwaysThatContain;
+        }
+
+        /**
+         * Returns all PTWays of this route that contain the given node as their
+         * first or last node.
+         * 
+         * @return
+         */
+        public List<PTWay> findPTWaysThatContainAsEndNode(Node node) {
+
+                List<PTWay> ptwaysThatContain = new ArrayList<>();
+                for (PTWay ptway : ptways) {
+                        List<Way> ways = ptway.getWays();
+                        if (ways.get(0).firstNode() == node || ways.get(0).lastNode() == node
+                                        || ways.get(ways.size() - 1).firstNode() == node || ways.get(ways.size() - 1).lastNode() == node) {
+                                ptwaysThatContain.add(ptway);
+                        }
+                }
+                return ptwaysThatContain;
+
+        }
+
+        /**
+         * Checks if at most one PTWay of this route refers to the given node
+         * 
+         * @param node
+         * @return
+         */
+        public boolean isDeadendNode(Node node) {
+
+                List<PTWay> referringPtways = this.findPTWaysThatContainAsEndNode(node);
+                if (referringPtways.size() <= 1) {
+                        return true;
+                }
+                return false;
+        }
+
+        /**
+         * Returns the PTWay which comes directly after the given ptway according to
+         * the existing route member sorting
+         * 
+         * @param ptway
+         * @return
+         */
+        public PTWay getNextPTWay(PTWay ptway) {
+
+                for (int i = 0; i < ptways.size() - 1; i++) {
+                        if (ptways.get(i) == ptway) {
+                                return ptways.get(i + 1);
+                        }
+                }
+                return null;
+
+        }
+
+        /**
+         * Returns the PTWay which comes directly before the given ptway according
+         * to the existing route member sorting
+         * 
+         * @param ptway
+         * @return
+         */
+        public PTWay getPreviousPTWay(PTWay ptway) {
+
+                for (int i = 1; i < ptways.size(); i++) {
+                        if (ptways.get(i) == ptway) {
+                                return ptways.get(i - 1);
+                        }
+                }
+                return null;
+        }
+
+        /**
+         * Returns a sequence of PTWays that are between the start way and the end
+         * way. The resulting list includes the start and end PTWays.
+         * 
+         * @param start
+         * @param end
+         * @return
+         */
+        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)) {
+                                potentialStartIndices.add(i);
+                        }
+                        if (ptways.get(i).getWays().contains(end)) {
+                                potentialEndIndices.add(i);
+                        }
+                }
+                
+                List<int[]> pairList = new ArrayList<>();
+                for (Integer potentialStartIndex: potentialStartIndices) {
+                        for (Integer potentialEndIndex: potentialEndIndices) {
+                                if (potentialStartIndex <= potentialEndIndex) {
+                                        int[] pair = {potentialStartIndex, potentialEndIndex};
+                                        pairList.add(pair);
+                                }
+                        }
+                }
+                
+                int minDifference = Integer.MAX_VALUE;
+                int[] mostSuitablePair = {0, 0};
+                for (int[] pair: pairList) {
+                        int diff = pair[1] - pair[0];
+                        if (diff < minDifference) {
+                                minDifference = diff;
+                                mostSuitablePair = pair;
+                        }
+                }
+                
+                List<PTWay> result = new ArrayList<>();
+                for (int i = mostSuitablePair[0]; i <= mostSuitablePair[1]; i++) {
+                        result.add(ptways.get(i));
+                }
+                return result;
+        }
+        
+        /**
+         * Returns the common Node of two PTWays or null if there is no common Node
+         * @param way1
+         * @param way2
+         * @return
+         */
+        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();
+                                }
+                        }
+                }
+                return null;
+        }
+
 }

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

@@ -27 +27 @@
         }
         
+        public PTRouteSegment(PTStop firstStop, PTStop lastStop) {
+                this.firstStop = firstStop;
+                this.lastStop = lastStop;
+                this.ptways = new ArrayList<>();
+        }
+        
         public List<PTWay> getPTWays() {
                 return this.ptways;

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

@@ -4 +4 @@
 import java.util.List;
 
+import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
 import org.openstreetmap.josm.data.osm.RelationMember;
@@ -63 +64 @@
                 return this.ways;
         }
-        
 
         /**
@@ -74 +74 @@
                 return false;
         }
-        
+
         /**
-         * Determines if this PTWay is modeled by an OsmPrimitieType.RELATION (i.e. this is a nested relation)
+         * Determines if this PTWay is modeled by an OsmPrimitieType.RELATION (i.e.
+         * this is a nested relation)
          */
         public boolean isRelation() {
@@ -84 +85 @@
                 return false;
         }
-        
+
+        /**
+         * Returns the end nodes of this PTWay. If this PTWay is a nested relation,
+         * the order of the composing ways is assumed to be correct
+         * 
+         * @return
+         */
+        public Node[] getEndNodes() {
+                Node[] endNodes = new Node[2];
+
+                if (this.isWay()) {
+                        endNodes[0] = this.getWay().firstNode();
+                        endNodes[1] = this.getWay().lastNode();
+                        // TODO: if this is a roundabout
+                } else { // nested relation:
+                        Way firstWay = this.getWays().get(0);
+                        Way secondWay = this.getWays().get(1);
+                        Way prelastWay = this.getWays().get(this.getWays().size() - 2);
+                        Way lastWay = this.getWays().get(this.getWays().size() - 1);
+                        if (firstWay.firstNode() == secondWay.firstNode() || firstWay.firstNode() == secondWay.lastNode()) {
+                                endNodes[0] = firstWay.lastNode();
+                        } else {
+                                endNodes[0] = firstWay.firstNode();
+                        }
+                        if (lastWay.firstNode() == prelastWay.firstNode() || lastWay.firstNode() == prelastWay.lastNode()) {
+                                endNodes[1] = lastWay.lastNode();
+                        } else {
+                                endNodes[1] = lastWay.firstNode();
+                        }
+                }
+
+                return endNodes;
+        }
 
 }

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

@@ -4 +4 @@
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -30 +31 @@
 
         /* contains assigned stops */
-        private static HashMap<PTStop, PTWay> stopToWay = new HashMap<>();
+        public static HashMap<PTStop, List<Way>> stopToWay = new HashMap<>();
 
         /*
@@ -36 +37 @@
          * created
          */
-        private List<PTWay> ptways;
+        private HashSet<Way> ways;
+
+        /* route relation for which this StopToWayAssigner was created */
 
         public StopToWayAssigner(List<PTWay> ptways) {
-                this.ptways = ptways;
+                ways = new HashSet<Way>();
+                for (PTWay ptway: ptways) {
+                        ways.addAll(ptway.getWays());
+                }
         }
 
@@ -48 +54 @@
          * @return
          */
-        public PTWay get(PTStop stop) {
+        public Way get(PTStop stop) {
 
                 // 1) Search if this stop has already been assigned:
                 if (stopToWay.containsKey(stop)) {
-                        return stopToWay.get(stop);
+                        List<Way> assignedWays = stopToWay.get(stop);
+                        for (Way assignedWay: assignedWays) {
+                                if (this.ways.contains(assignedWay)) {
+                                        return assignedWay;
+                                }
+                        }
                 }
 
                 // 2) Search if the stop has a stop position:
-                PTWay ptwayOfStopPosition = findPtwayForNode(stop.getStopPosition());
-                if (ptwayOfStopPosition != null) {
-                        stopToWay.put(stop, ptwayOfStopPosition);
-                        return ptwayOfStopPosition;
-                }
+                Way wayOfStopPosition = findWayForNode(stop.getStopPosition());
+                if (wayOfStopPosition != null) {
+                        addAssignedWayToMap(stop, wayOfStopPosition);
+                        return wayOfStopPosition;
+                }
+
+                // TODO: search if a stop position is in the vicinity of a platform
 
                 // 3) Search if the stop has a stop_area:
@@ -75 +88 @@
                                 for (RelationMember rm : parentRelation.getMembers()) {
                                         if (rm.getMember().hasTag("public_transport", "stop_position")) {
-                                                PTWay rmPtway = this.findPtwayForNode(rm.getNode());
-                                                if (rmPtway != null) {
-                                                        stopToWay.put(stop, rmPtway);
-                                                        return rmPtway;
+                                                Way rmWay = this.findWayForNode(rm.getNode());
+                                                if (rmWay != null) {
+                                                        addAssignedWayToMap(stop, rmWay);
+                                                        return rmWay;
                                                 }
                                         }
@@ -89 +102 @@
                 while (searchRadius < 0.005) {
 
-                        PTWay foundWay = this.findNearestWayInRadius(stop.getPlatform(), searchRadius);
+                        Way foundWay = this.findNearestWayInRadius(stop.getPlatform(), searchRadius);
                         if (foundWay != null) {
-                                stopToWay.put(stop, foundWay);
+                                addAssignedWayToMap(stop, foundWay);
                                 return foundWay;
                         }
@@ -97 +110 @@
                         foundWay = this.findNearestWayInRadius(stop.getStopPosition(), searchRadius);
                         if (foundWay != null) {
-                                stopToWay.put(stop, foundWay);
+                                addAssignedWayToMap(stop, foundWay);
                                 return foundWay;
                         }
@@ -113 +126 @@
          * @return
          */
-        private PTWay findPtwayForNode(Node stopPosition) {
+        private Way findWayForNode(Node stopPosition) {
 
                 if (stopPosition == null) {
@@ -124 +137 @@
                         if (referredPrimitive.getType().equals(OsmPrimitiveType.WAY)) {
                                 Way referredWay = (Way) referredPrimitive;
-                                for (PTWay ptway : ptways) {
-                                        if (ptway.getWays().contains(referredWay)) {
-                                                return ptway;
-                                        }
+                                if (this.ways.contains(referredWay)) {
+                                        return referredWay;
                                 }
                         }
@@ -144 +155 @@
          * @return
          */
-        private PTWay findNearestWayInRadius(OsmPrimitive platform, double searchRadius) {
+        private Way findNearestWayInRadius(OsmPrimitive platform, double searchRadius) {
 
                 if (platform == null) {
@@ -157 +168 @@
                 BBox platformBBox = new BBox(ax, ay, bx, by);
 
-                List<Way> potentialWays = new ArrayList<>();
+                Set<Way> potentialWays = new HashSet<>();
 
                 Collection<Node> allNodes = platform.getDataSet().getNodes();
@@ -166 +177 @@
                                         if (referrer.getType().equals(OsmPrimitiveType.WAY)) {
                                                 Way referrerWay = (Way) referrer;
-                                                for (PTWay ptway : this.ptways) {
-                                                        if (ptway.getWays().contains(referrerWay)) {
-                                                                potentialWays.add(referrerWay);
-                                                        }
+                                                if (this.ways.contains(referrerWay)) {
+                                                        potentialWays.add(referrerWay);
                                                 }
                                         }
@@ -176 +185 @@
                         }
                 }
-                
+
                 Node platformNode = null;
                 if (platform.getType().equals(OsmPrimitiveType.NODE)) {
@@ -185 +194 @@
                 Way nearestWay = null;
                 Double minDistance = Double.MAX_VALUE;
-                for (Way potentialWay: potentialWays) {
-                        double distance = this.calculateMinDistance(platformNode, potentialWay);
+                for (Way potentialWay : potentialWays) {
+                        double distance = this.calculateMinDistanceToSegment(platformNode, potentialWay);
                         if (distance < minDistance) {
                                 minDistance = distance;
@@ -193 +202 @@
                 }
 
-                for (PTWay ptway: this.ptways) {
-                        if (ptway.getWays().contains(nearestWay)) {
-                                return ptway;
-                        }
-                }
-                
-                return null;
+                return nearestWay;
         }
 
         /**
          * Calculates the minimum distance between a node and a way
+         * 
          * @param node
          * @param way
          * @return
          */
-        private double calculateMinDistance(Node node, Way way) {
+        private double calculateMinDistanceToSegment(Node node, Way way) {
 
                 double minDistance = Double.MAX_VALUE;
 
                 List<Pair<Node, Node>> waySegments = way.getNodePairs(false);
+
                 for (Pair<Node, Node> waySegment : waySegments) {
                         if (waySegment.a != node && waySegment.b != node) {
-                                double distanceToLine = this.calculateDistance(node, waySegment);
+                                double distanceToLine = this.calculateDistanceToSegment(node, waySegment);
                                 if (distanceToLine < minDistance) {
                                         minDistance = distanceToLine;
@@ -227 +232 @@
 
         /**
-         * // * Calculates the distance from point to segment using formulas for
-         * triangle area.
+         * Calculates the distance from point to segment and differentiates between
+         * acute, right and obtuse triangles. If a triangle is acute or right, the
+         * distance to segment is calculated as distance from point to line. If the
+         * triangle is obtuse, the distance is calculated as the distance to the
+         * nearest vertex of the segment.
+         * 
+         * @param node
+         * @param segment
+         * @return
+         */
+        private double calculateDistanceToSegment(Node node, Pair<Node, Node> segment) {
+
+                if (node == segment.a || node == segment.b) {
+                        return 0.0;
+                }
+
+                double lengthA = node.getCoor().distance(segment.a.getCoor());
+                double lengthB = node.getCoor().distance(segment.b.getCoor());
+                double lengthC = segment.a.getCoor().distance(segment.b.getCoor());
+
+                if (isObtuse(lengthC, lengthB, lengthA)) {
+                        return lengthB;
+                }
+
+                if (isObtuse(lengthA, lengthC, lengthB)) {
+                        return lengthA;
+                }
+
+                return calculateDistanceToLine(node, segment);
+        }
+
+        /**
+         * Calculates the distance from point to line using formulas for triangle
+         * area. Does not differentiate between acute, right and obtuse triangles
          * 
          * @param node
@@ -234 +271 @@
          * @return
          */
-        private double calculateDistance(Node node, Pair<Node, Node> segment) {
+        private double calculateDistanceToLine(Node node, Pair<Node, Node> segment) {
 
                 /*
@@ -257 +294 @@
 
         /**
+         * Checks if the angle opposite of the edge c is obtuse. Uses the cosine
+         * theorem
+         * 
+         * @param lengthA
+         * @param lengthB
+         * @param lengthC
+         *            the triangle edge which is testes
+         * @return true if the angle opposite of te edge c is obtuse
+         */
+        private boolean isObtuse(double lengthA, double lengthB, double lengthC) {
+
+                /*-
+                 * Law of cosines:
+                 * c^2 = a^2 + b^2 - 2abcos
+                 * if c^2 = a^2 + b^2, it is a right triangle
+                 * if c^2 < a^2 + b^2, it is an acute triangle
+                 * if c^2 > a^2 + b^2, it is an obtuse triangle
+                 */
+
+                if (lengthC * lengthC > lengthA * lengthA + lengthB * lengthB) {
+                        return true;
+                }
+
+                return false;
+        }
+
+        /**
+         * Adds the given way to the map of assigned ways. Assumes that the given
+         * way is not contained in the map.
+         * 
+         * @param stop
+         * @param way
+         */
+        private void addAssignedWayToMap(PTStop stop, Way way) {
+                if (stopToWay.containsKey(stop)) {
+                        List<Way> assignedWays = stopToWay.get(stop);
+                        assignedWays.add(way);
+                } else {
+                        List<Way> assignedWays = new ArrayList<Way>();
+                        assignedWays.add(way);
+                        stopToWay.put(stop, assignedWays);
+                }
+        }
+
+        /**
          * May be needed if the correspondence between stops and ways has changed
          * significantly

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

@@ -15 +15 @@
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.validation.Severity;
 import org.openstreetmap.josm.data.validation.Test;
@@ -20 +21 @@
 import org.openstreetmap.josm.plugins.pt_assistant.actions.FixTask;
 import org.openstreetmap.josm.plugins.pt_assistant.actions.IncompleteMembersDownloadThread;
+import org.openstreetmap.josm.plugins.pt_assistant.data.PTRouteDataManager;
+import org.openstreetmap.josm.plugins.pt_assistant.data.PTRouteSegment;
+import org.openstreetmap.josm.plugins.pt_assistant.data.PTStop;
+import org.openstreetmap.josm.plugins.pt_assistant.data.PTWay;
 import org.openstreetmap.josm.plugins.pt_assistant.gui.IncompleteMembersDownloadDialog;
 import org.openstreetmap.josm.plugins.pt_assistant.gui.PTAssistantLayer;
 import org.openstreetmap.josm.plugins.pt_assistant.gui.ProceedDialog;
 import org.openstreetmap.josm.plugins.pt_assistant.utils.RouteUtils;
+import org.openstreetmap.josm.plugins.pt_assistant.utils.StopToWayAssigner;
 
 public class PTAssistantValidatorTest extends Test {
@@ -36 +42 @@
         public static final int ERROR_CODE_SOLITARY_STOP_POSITION = 3751;
         public static final int ERROR_CODE_PLATFORM_PART_OF_HIGHWAY = 3752;
+        public static final int ERROR_CODE_STOP_NOT_SERVED = 3753;
+        public static final int ERROR_CODE_STOP_BY_STOP = 3754;
+
 
         private PTAssistantLayer layer;
@@ -280 +289 @@
                 if (!routeChecker.getHasGap()) {
                         // Variant 1
-                        // TODO: add the segments of this route to the list correct route
-                        // segments
+//                      storeCorrectRouteSegments(r);
+
                 }
 
@@ -302 +311 @@
                 segmentChecker.performFirstStopTest();
                 segmentChecker.performLastStopTest();
-
-                // TODO: perform segment test
+                segmentChecker.performStopByStopTest();
+
                 this.errors.addAll(segmentChecker.getErrors());
-                // performDummyTest(r);
+        }
+
+        /**
+         * Creates the PTRouteSegments of a route that has been found correct and stores them in the list of correct route segments
+         * @param r route relation
+         */
+        @SuppressWarnings("unused")
+        private void storeCorrectRouteSegments(Relation r) {
+                PTRouteDataManager manager = new PTRouteDataManager(r);
+                StopToWayAssigner assigner = new StopToWayAssigner(manager.getPTWays());
+                if (manager.getPTStops().size() > 1) {
+                        for (int i = 1; i < manager.getPTStops().size(); i++) {
+                                PTStop segmentStartStop = manager.getPTStops().get(i-1);
+                                PTStop segmentEndStop = manager.getPTStops().get(i);
+                                Way segmentStartWay = assigner.get(segmentStartStop);
+                                Way segmentEndWay = assigner.get(segmentEndStop);
+                                List<PTWay> waysBetweenStops = manager.getPTWaysBetween(segmentStartWay, segmentEndWay);
+                                PTRouteSegment routeSegment = new PTRouteSegment(segmentStartStop, segmentEndStop, waysBetweenStops);
+                                SegmentChecker.addCorrectSegment(routeSegment);
+                        }
+                }
         }
 
@@ -340 +369 @@
                 }
 
-                if (testError.getCode() == ERROR_CODE_SOLITARY_STOP_POSITION || testError.getCode() == ERROR_CODE_PLATFORM_PART_OF_HIGHWAY) {
+                if (testError.getCode() == ERROR_CODE_SOLITARY_STOP_POSITION
+                                || testError.getCode() == ERROR_CODE_PLATFORM_PART_OF_HIGHWAY) {
                         commands.add(NodeChecker.fixError(testError));
                 }

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

@@ -6 +6 @@
 import java.util.List;
 
+import org.openstreetmap.josm.command.Command;
+import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
@@ -30 +32 @@
 
         /* PTRouteSegments that have been validated and are correct */
-        @SuppressWarnings("unused")
         private static List<PTRouteSegment> correctSegments = new ArrayList<PTRouteSegment>();
 
@@ -37 +38 @@
 
         /* Assigns PTStops to nearest PTWays and stores that correspondence */
-        @SuppressWarnings("unused")
         private StopToWayAssigner assigner;
 
+        /*
+         * Stores reference that shows in which direction the segment checker is
+         * moving
+         */
+        private Node firstNodeOfRouteSegmentInDirectionOfTravel;
+
         public SegmentChecker(Relation relation, Test test) {
 
@@ -45 +51 @@
 
                 this.manager = new PTRouteDataManager(relation);
-                
-                for (RelationMember rm: manager.getFailedMembers()) {
+
+                for (RelationMember rm : manager.getFailedMembers()) {
                         List<Relation> primitives = new ArrayList<>(1);
                         primitives.add(relation);
@@ -56 +62 @@
                 }
 
-
-                
                 this.assigner = new StopToWayAssigner(manager.getPTWays());
 
+        }
+
+        /**
+         * Returns the number of route segments that have been already successfully
+         * verified
+         * 
+         * @return
+         */
+        public static int getCorrectSegmentCount() {
+                return correctSegments.size();
+        }
+
+        /**
+         * Adds the given correct segment to the list of correct segments without
+         * checking its correctness
+         * 
+         * @param segment
+         *            to add to the list of correct segments
+         */
+        public static void addCorrectSegment(PTRouteSegment segment) {
+                correctSegments.add(segment);
         }
 
@@ -153 +178 @@
         }
 
-        @SuppressWarnings("unused")
-        private void performSegmentTest() {
-                // TODO
-        }
-
         /**
          * Checks if the given node belongs to the ways of this route.
@@ -192 +212 @@
         }
 
+        public void performStopByStopTest() {
+
+                if (manager.getPTStopCount() < 2) {
+                        return;
+                }
+
+                // Check each route segment:
+                for (int i = 1; i < manager.getPTStopCount(); i++) {
+
+                        PTStop startStop = manager.getPTStops().get(i - 1);
+                        PTStop endStop = manager.getPTStops().get(i);
+
+                        Way startWay = assigner.get(startStop);
+                        Way endWay = assigner.get(endStop);
+                        if (startWay == null) {
+                                this.firstNodeOfRouteSegmentInDirectionOfTravel = null;
+                                continue;
+                        }
+                        if (endWay == null) {
+                                this.firstNodeOfRouteSegmentInDirectionOfTravel = null;
+                                continue;
+                        }
+                        // FIXME: throw error if cannot find the corresponding way (which
+                        // means that the stop is too far away from way)
+                        List<PTWay> segmentWays = manager.getPTWaysBetween(startWay, endWay);
+
+                        if (this.firstNodeOfRouteSegmentInDirectionOfTravel == null) {
+                                // if we are at the beginning of the route or after a gap /
+                                // error:
+
+                                this.firstNodeOfRouteSegmentInDirectionOfTravel = findFirstNodeOfRouteSegmentInDirectionOfTravel(
+                                                segmentWays.get(0));
+                                if (this.firstNodeOfRouteSegmentInDirectionOfTravel == null) {
+                                        // TODO: throw error
+                                        continue;
+                                }
+                        }
+
+                        boolean sortingCorrect = existingWaySortingIsCorrect(segmentWays.get(0),
+                                        this.firstNodeOfRouteSegmentInDirectionOfTravel, segmentWays.get(segmentWays.size() - 1));
+                        if (sortingCorrect) {
+                                PTRouteSegment routeSegment = new PTRouteSegment(startStop, endStop, segmentWays);
+                                correctSegments.add(routeSegment);
+                        }
+                }
+
+        }
+
+        private Node findFirstNodeOfRouteSegmentInDirectionOfTravel(PTWay startWay) {
+
+                // 1) at first check if one of the first or last node of the first ptway
+                // is a deadend node:
+                Node[] startWayEndnodes = startWay.getEndNodes();
+                if (isDeadendNode(startWayEndnodes[0])) {
+                        return startWayEndnodes[0];
+                }
+                if (isDeadendNode(startWayEndnodes[1])) {
+                        return startWayEndnodes[1];
+                }
+
+                // 2) failing that, check which node this startWay shares with the
+                // following way:
+                PTWay nextWay = manager.getNextPTWay(startWay);
+                if (nextWay == null) {
+                        return null;
+                }
+                Node[] nextWayEndnodes = nextWay.getEndNodes();
+                if (startWayEndnodes[0] == nextWayEndnodes[0] || startWayEndnodes[0] == nextWayEndnodes[1]) {
+                        return startWayEndnodes[1];
+                }
+                if (startWayEndnodes[1] == nextWayEndnodes[0] || startWayEndnodes[1] == nextWayEndnodes[1]) {
+                        return startWayEndnodes[0];
+                }
+
+                return null;
+
+        }
+
+        private boolean isDeadendNode(Node node) {
+                int count = 0;
+                for (PTWay ptway : manager.getPTWays()) {
+                        List<Way> ways = ptway.getWays();
+                        for (Way way : ways) {
+                                if (way.firstNode() == node || way.lastNode() == node) {
+                                        count++;
+                                }
+                        }
+                }
+                return count == 1;
+        }
+
+        /**
+         * Finds the deadend node closest to the given node represented by its
+         * coordinates
+         * 
+         * @param coord
+         *            coordinates of the givenn node
+         * @param deadendNodes
+         * @return the closest deadend node
+         */
+        @SuppressWarnings("unused")
+        private Node findClosestDeadendNode(LatLon coord, List<Node> deadendNodes) {
+
+                Node closestDeadendNode = null;
+                double minSqDistance = Double.MAX_VALUE;
+                for (Node deadendNode : deadendNodes) {
+                        double distanceSq = coord.distanceSq(deadendNode.getCoor());
+                        if (distanceSq < minSqDistance) {
+                                minSqDistance = distanceSq;
+                                closestDeadendNode = deadendNode;
+                        }
+                }
+                return closestDeadendNode;
+
+        }
+
+        private boolean existingWaySortingIsCorrect(PTWay start, Node startWayPreviousNodeInDirectionOfTravel, PTWay end) {
+
+                if (start == end) {
+                        // if both PTStops are on the same PTWay
+                        return true;
+                }
+
+                PTWay current = start;
+
+                while (!current.equals(end)) {
+                        // "equals" is used here instead of "==" because when the same way
+                        // is passed multiple times by the bus, the algorithm should stop no
+                        // 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;
+                        }
+
+                        current = nextPTWayAccortingToExistingSorting;
+
+                }
+
+                return true;
+        }
+
+        private Node getOppositeEndNode(Way way, Node node) {
+
+                if (node == way.firstNode()) {
+                        return way.lastNode();
+                }
+
+                if (node == way.lastNode()) {
+                        return way.firstNode();
+                }
+
+                return null;
+        }
+
+        private Node getOppositeEndNode(PTWay ptway, Node node) {
+                if (ptway.isWay()) {
+                        return getOppositeEndNode(ptway.getWays().get(0), node);
+                }
+
+                Way firstWay = ptway.getWays().get(0);
+                Way lastWay = ptway.getWays().get(ptway.getWays().size() - 1);
+                Node oppositeNode = node;
+                if (firstWay.firstNode() == node || firstWay.lastNode() == node) {
+                        for (int i = 0; i < ptway.getWays().size(); i++) {
+                                oppositeNode = getOppositeEndNode(ptway.getWays().get(i), oppositeNode);
+                        }
+                        return oppositeNode;
+                } else if (lastWay.firstNode() == node || lastWay.lastNode() == node) {
+                        for (int i = ptway.getWays().size() - 1; i >= 0; i--) {
+                                oppositeNode = getOppositeEndNode(ptway.getWays().get(i), oppositeNode);
+                        }
+                        return oppositeNode;
+                }
+
+                return null;
+
+        }
+
+        /**
+         * 
+         * @param way
+         * @param nodeInDirectionOfTravel
+         * @return
+         */
+        private List<PTWay> findNextPTWaysInDirectionOfTravel(PTWay currentWay, Node nextNodeInDirectionOfTravel) {
+
+                List<PTWay> nextPtways = new ArrayList<>();
+
+                List<PTWay> ptways = manager.getPTWays();
+
+                for (PTWay ptway : ptways) {
+
+                        if (ptway != currentWay) {
+                                Node[] endNodes = ptway.getEndNodes();
+                                if (endNodes[0] == nextNodeInDirectionOfTravel || endNodes[1] == nextNodeInDirectionOfTravel) {
+                                        nextPtways.add(ptway);
+                                }
+                        }
+                }
+
+                return nextPtways;
+
+        }
+
+        protected static Command fixError(TestError testError) {
+
+                // FIXME
+
+                return null;
+        }
+
 }