Path: renamed nodes and points to calcNodes, calcPoints; fix bug in miniGraphUI

Author: Peter

src/main/java/com/graphhopper/GraphHopper.java

@@ -80,6 +80,8 @@ public GraphHopper forServer() {
     }
 
     public GraphHopper forAndroid() {
+        // no need to simplify as no IO and simplifying costs a bit CPU
+        simplify = false;
         return memoryMapped();
     }
 
@@ -213,7 +215,7 @@ public GHResponse route(GHRequest request) {
         RoutingAlgorithm algo = prepare.createAlgo();
         Path path = algo.calcPath(from, to);
         debug += " routing (" + algo.name() + "):" + sw.stop().getSeconds() + "s";
-        PointList points = path.points();
+        PointList points = path.calcPoints();
         if (simplify) {
             sw = new StopWatch().start();
             int del = new DouglasPeucker().setMaxDist(request.minPathPrecision()).simplify(points);

src/main/java/com/graphhopper/routing/Path.java

@@ -50,7 +50,6 @@ public class Path {
     private int fromNode = EdgeIterator.NO_EDGE;
     private TIntList edgeIds;
     private PointList cachedPoints;
-    private TIntList cachedNodes;
 
     Path() {
         this(null, ShortestCarCalc.DEFAULT);
@@ -68,7 +67,7 @@ public Path(Graph graph, WeightCalculation weightCalculation) {
     public Path(Path p) {
         this(p.graph, p.weightCalculation);
         weight = p.weight;
-        edgeIds = new TIntArrayList(edgeIds);  
+        edgeIds = new TIntArrayList(edgeIds);
         edgeEntry = p.edgeEntry;
     }
 
@@ -81,8 +80,12 @@ protected void addEdge(int edge) {
         edgeIds.add(edge);
     }
 
-    public void setFound(boolean found) {
-        this.found = found;
+    /**
+     * We need to remember fromNode explicitely as its not saved in one edgeId
+     * of edgeIds.
+     */
+    protected void setFromNode(int node) {
+        fromNode = node;
     }
 
     public int getFromNode() {
@@ -130,24 +133,8 @@ public void weight(double weight) {
         this.weight = weight;
     }
 
-    @Override public String toString() {
-        return "weight:" + weight() + ", edges:" + edgeIds;
-    }
-
-    public String toDetailsString() {
-        String str = "";
-        TIntList nodes = nodes();
-        for (int i = 0; i < nodes.size(); i++) {
-            if (i > 0)
-                str += "->";
-
-            str += nodes.get(i);
-        }
-        return toString() + ", " + str;
-    }
-
     /**
-     * Extract path from shortest-path-tree.
+     * Extracts the Path from the shortest-path-tree determined by edgeEntry.
      */
     public Path extract() {
         EdgeEntry goalEdge = edgeEntry;
@@ -161,14 +148,17 @@ public Path extract() {
         return found(true);
     }
 
-    protected void processWeight(int tmpEdge, int endNode) {
-        calcWeight(graph.getEdgeProps(tmpEdge, endNode));
-        addEdge(tmpEdge);
+    /**
+     * Calls calcWeight and adds the edgeId.
+     */
+    protected void processWeight(int edgeId, int endNode) {
+        calcWeight(graph.getEdgeProps(edgeId, endNode));
+        addEdge(edgeId);
     }
 
     /**
      * This method calculates not only the weight but also the distance in
-     * kilometer.
+     * kilometer for the specified edge.
      */
     public void calcWeight(EdgeIterator iter) {
         double dist = iter.distance();
@@ -179,19 +169,17 @@ public void calcWeight(EdgeIterator iter) {
     }
 
     /**
-     * @return the node indices of the tower nodes in this path.
+     * Used in combination with forEveryEdge.
      */
-    public TIntList nodes() {
-        if (cachedNodes == null)
-            calcNodes();
-        return cachedNodes;
+    public static interface EdgeVisitor {
+
+        void next(EdgeIterator iter);
     }
-    
-    public TDoubleList calcDistances() {
-        TDoubleList distances = new TDoubleArrayList(edgeIds.size());
-        if (edgeIds.isEmpty())
-            return distances;
 
+    /**
+     * Iterates over all edges in this path and calls the visitor for it.
+     */
+    public void forEveryEdge(EdgeVisitor visitor) {
         int tmpNode = getFromNode();
         int len = edgeIds.size();
         for (int i = 0; i < len; i++) {
@@ -201,69 +189,76 @@ public TDoubleList calcDistances() {
                         + " was empty when requested with node " + tmpNode
                         + ", edgeIndex:" + i + ", edges:" + edgeIds.size());
             tmpNode = iter.baseNode();
-            distances.add(iter.distance());
+            visitor.next(iter);
         }
-        return distances;
     }
 
-    private TIntList calcNodes() {
-        cachedNodes = new TIntArrayList(edgeIds.size() + 1);
+    /**
+     * @return the uncached node indices of the tower nodes in this path.
+     */
+    public TIntList calcNodes() {
+        final TIntArrayList nodes = new TIntArrayList(edgeIds.size() + 1);
         if (edgeIds.isEmpty())
-            return cachedNodes;
+            return nodes;
 
         int tmpNode = getFromNode();
-        cachedNodes.add(tmpNode);
-        int len = edgeIds.size();
-        for (int i = 0; i < len; i++) {
-            EdgeIterator iter = graph.getEdgeProps(edgeIds.get(i), tmpNode);
-            if (iter.isEmpty())
-                throw new IllegalStateException("Edge " + edgeIds.get(i)
-                        + " was empty when requested with node " + tmpNode
-                        + ", edgeIndex:" + i + ", edges:" + edgeIds.size());
-            cachedNodes.add(tmpNode = iter.baseNode());
-        }
-        return cachedNodes;
+        nodes.add(tmpNode);
+        forEveryEdge(new EdgeVisitor() {
+            @Override public void next(EdgeIterator iter) {
+                nodes.add(iter.baseNode());
+            }
+        });
+        return nodes;
     }
 
-    public PointList points() {
-        if (cachedPoints == null)
-            calcPoints();
-        return cachedPoints;
-    }
-
-    private PointList calcPoints() {
+    /**
+     * @return the cached list of lat,lon for this path
+     */
+    public PointList calcPoints() {
+        if (cachedPoints != null)
+            return cachedPoints;
         cachedPoints = new PointList(edgeIds.size() + 1);
+        if (edgeIds.isEmpty())
+            return cachedPoints;
         int tmpNode = getFromNode();
         cachedPoints.add(graph.getLatitude(tmpNode), graph.getLongitude(tmpNode));
-        int len = edgeIds.size();
-        for (int i = 0; i < len; i++) {
-            int edgeId = edgeIds.get(i);
-            EdgeIterator iter = graph.getEdgeProps(edgeId, tmpNode);
-            if (iter.isEmpty())
-                throw new IllegalStateException("Edge " + edgeId
-                        + " was empty when requested with node " + tmpNode
-                        + ", edgeIndex:" + i + ", edges:" + edgeIds.size());
-            tmpNode = iter.baseNode();            
-            PointList pl = iter.pillarNodes();
-            pl.reverse();
-            for (int j = 0; j < pl.size(); j++) {
-                cachedPoints.add(pl.latitude(j), pl.longitude(j));
-            }            
-            cachedPoints.add(graph.getLatitude(tmpNode), graph.getLongitude(tmpNode));
-        }
+        forEveryEdge(new EdgeVisitor() {
+            @Override public void next(EdgeIterator iter) {
+                PointList pl = iter.pillarNodes();
+                pl.reverse();
+                for (int j = 0; j < pl.size(); j++) {
+                    cachedPoints.add(pl.latitude(j), pl.longitude(j));
+                }
+                int baseNode = iter.baseNode();
+                cachedPoints.add(graph.getLatitude(baseNode), graph.getLongitude(baseNode));
+            }
+        });
         return cachedPoints;
     }
 
+    public TDoubleList calcDistances() {
+        final TDoubleList distances = new TDoubleArrayList(edgeIds.size());
+        if (edgeIds.isEmpty())
+            return distances;
+
+        forEveryEdge(new EdgeVisitor() {
+            @Override public void next(EdgeIterator iter) {
+                distances.add(iter.distance());
+            }
+        });
+        return distances;
+    }
+
     public TIntSet calculateIdenticalNodes(Path p2) {
         TIntHashSet thisSet = new TIntHashSet();
         TIntHashSet retSet = new TIntHashSet();
-        TIntList nodes = nodes();
+        TIntList nodes = calcNodes();
         int max = nodes.size();
         for (int i = 0; i < max; i++) {
             thisSet.add(nodes.get(i));
         }
 
-        nodes = p2.nodes();
+        nodes = p2.calcNodes();
         max = nodes.size();
         for (int i = 0; i < max; i++) {
             if (thisSet.contains(nodes.get(i)))
@@ -272,11 +267,19 @@ public TIntSet calculateIdenticalNodes(Path p2) {
         return retSet;
     }
 
-    /**
-     * We need to remember fromNode explicitely as its not saved in one edgeId
-     * of edgeIds.
-     */
-    protected void setFromNode(int node) {
-        fromNode = node;
+    @Override public String toString() {
+        return "weight:" + weight() + ", edges:" + edgeIds.size();
+    }
+
+    public String toDetailsString() {
+        String str = "";
+        TIntList nodes = calcNodes();
+        for (int i = 0; i < nodes.size(); i++) {
+            if (i > 0)
+                str += "->";
+
+            str += nodes.get(i);
+        }
+        return toString() + ", " + str;
     }
 }

src/main/java/com/graphhopper/routing/util/TestAlgoCollector.java

@@ -46,12 +46,12 @@ public TestAlgoCollector assertDistance(RoutingAlgorithm algo,
         } else if (Math.abs(path.distance() - distance) > 10)
             list.add(algo + " returns path not matching the expected distance of " + distance
                     + "\t Returned was " + path.distance() + "\t (expected points " + points
-                    + ", was " + path.points().size() + ") from:" + from + ", to:" + to);
+                    + ", was " + path.calcPoints().size() + ") from:" + from + ", to:" + to);
         // Yes, there are indeed real world instances where A-B-C is identical to A-C (in meter precision).
         // And for from:501620, to:155552 the node difference of astar to bi-dijkstra gets even bigger (7!).
-        if (Math.abs(path.points().size() - points) > 7)
+        if (Math.abs(path.calcPoints().size() - points) > 7)
             list.add(algo + " returns path not matching the expected points of " + points
-                    + "\t Returned was " + path.points().size() + "\t (expected distance " + distance
+                    + "\t Returned was " + path.calcPoints().size() + "\t (expected distance " + distance
                     + ", was " + path.distance() + ") from:" + from + ", to:" + to);
         return this;
     }

src/main/java/com/graphhopper/ui/MiniGraphUI.java

@@ -184,15 +184,15 @@ public MiniGraphUI(OSMReader reader, boolean debug) {
                     return;
                 }
 
-                logger.info("found path in " + sw.getSeconds() + "s with " + path.nodes() + " nodes: " + path);
+                logger.info("found path in " + sw.getSeconds() + "s with " + path.calcNodes().size() + " nodes: " + path);
                 g2.setColor(Color.BLUE.brighter().brighter());
-                PointList list = path.points();
+                PointList list = path.calcPoints();
                 double prevLat = Double.NaN;
                 double prevLon = Double.NaN;
                 for (int i = 0; i < list.size(); i++) {
                     double lat = list.latitude(i);
                     double lon = list.longitude(i);
-                    if (Double.isNaN(prevLat))
+                    if (!Double.isNaN(prevLat))
                         mg.plotEdge(g2, prevLat, prevLon, lat, lon, 3);
 
                     prevLat = lat;
@@ -227,17 +227,17 @@ private Path plotPath(Path tmpPath, Graphics2D g2, int w) {
 
         double lastLat = Double.NaN;
         double lastLon = Double.NaN;
-        for (int i = 0; i < tmpPath.points().size(); i++) {
-            double lat = tmpPath.points().latitude(i);
-            double lon = tmpPath.points().longitude(i);
+        for (int i = 0; i < tmpPath.calcPoints().size(); i++) {
+            double lat = tmpPath.calcPoints().latitude(i);
+            double lon = tmpPath.calcPoints().longitude(i);
             if (!Double.isNaN(lastLat))
                 mg.plotEdge(g2, lastLat, lastLon, lat, lon, w);
             else
                 mg.plot(g2, lat, lon, w);
             lastLat = lat;
             lastLon = lon;
         }
-        logger.info("dist:" + tmpPath.distance() + ", path points:" + tmpPath.points().size());
+        logger.info("dist:" + tmpPath.distance() + ", path points:" + tmpPath.calcPoints().size());
         return tmpPath;
     }
     private int dijkstraFromId = -1;