fixed issues regarding integration tests of CH, graphhopper#942

karussell · karussell · commit a4ebf88f9944 · 2017-01-23T17:12:07.000+01:00
diff --git a/core/src/main/java/com/graphhopper/routing/AStar.java b/core/src/main/java/com/graphhopper/routing/AStar.java
@@ -168,7 +168,7 @@ public int getVisitedNodes() {
 
     @Override
     public String getName() {
-        return Parameters.Algorithms.ASTAR;
+        return Parameters.Algorithms.ASTAR + "|" + weightApprox;
     }
 
     public static class AStarEntry extends SPTEntry {
diff --git a/core/src/main/java/com/graphhopper/routing/AStarBidirection.java b/core/src/main/java/com/graphhopper/routing/AStarBidirection.java
@@ -280,6 +280,6 @@ public void updateBestPath(EdgeIteratorState edgeState, AStarEntry entryCurrent,
 
     @Override
     public String getName() {
-        return Parameters.Algorithms.ASTAR_BI;
+        return Parameters.Algorithms.ASTAR_BI + "|" + weightApprox;
     }
 }
diff --git a/core/src/main/java/com/graphhopper/routing/ch/PrepareContractionHierarchies.java b/core/src/main/java/com/graphhopper/routing/ch/PrepareContractionHierarchies.java
@@ -671,7 +671,7 @@ protected Path createAndInitPath() {
 
             @Override
             public String getName() {
-                return "astarbiCH";
+                return "astarbi|ch";
             }
 
             @Override
@@ -707,7 +707,7 @@ protected Path createAndInitPath() {
 
             @Override
             public String getName() {
-                return "dijkstrabiCH";
+                return "dijkstrabi|ch";
             }
 
             @Override
diff --git a/core/src/main/java/com/graphhopper/routing/util/HintsMap.java b/core/src/main/java/com/graphhopper/routing/util/HintsMap.java
@@ -35,6 +35,10 @@ public HintsMap(String weighting) {
         setWeighting(weighting);
     }
 
+    public HintsMap(HintsMap map) {
+        super(map.toMap());
+    }
+
     @Override
     public HintsMap put(String key, Object str) {
         super.put(key, str);
diff --git a/core/src/main/java/com/graphhopper/routing/util/TestAlgoCollector.java b/core/src/main/java/com/graphhopper/routing/util/TestAlgoCollector.java
@@ -47,18 +47,28 @@ public TestAlgoCollector(String name) {
 
     public TestAlgoCollector assertDistance(AlgoHelperEntry algoEntry, List<QueryResult> queryList,
                                             OneRun oneRun) {
-        List<Path> altPaths = new ArrayList<Path>();
-        QueryGraph queryGraph = new QueryGraph(algoEntry.getQueryGraph());
+        List<Path> altPaths = new ArrayList<>();
+        QueryGraph queryGraph = new QueryGraph(algoEntry.getForQueryGraph());
         queryGraph.lookup(queryList);
-        AlgorithmOptions opts = algoEntry.opts;
+        AlgorithmOptions opts = algoEntry.getAlgorithmOptions();
         FlagEncoder encoder = opts.getWeighting().getFlagEncoder();
-        if (encoder.supports(TurnWeighting.class))
+        if (encoder.supports(TurnWeighting.class)) {
+            if (!opts.getTraversalMode().isEdgeBased()) {
+                errors.add("Cannot use TurnWeighting with a node based traversal");
+                return this;
+            }
             algoEntry.setAlgorithmOptions(AlgorithmOptions.start(opts).weighting(new TurnWeighting(opts.getWeighting(), (TurnCostExtension) queryGraph.getExtension())).build());
+        }
 
+        RoutingAlgorithmFactory factory = algoEntry.createRoutingFactory();
         for (int i = 0; i < queryList.size() - 1; i++) {
-            RoutingAlgorithm algo = algoEntry.createAlgo(queryGraph);
+            RoutingAlgorithm algo = factory.createAlgo(queryGraph, algoEntry.getAlgorithmOptions());
+//            if (!algoEntry.getExpectedAlgo().equals(algo.toString())) {
+//                errors.add("Algorithm expected " + algoEntry.getExpectedAlgo() + " but was " + algo.toString());
+//                return this;
+//            }
+
             Path path = algo.calcPath(queryList.get(i).getClosestNode(), queryList.get(i + 1).getClosestNode());
-            // System.out.println(path.calcInstructions().createGPX("temp", 0, "GMT"));
             altPaths.add(path);
         }
 
@@ -70,7 +80,7 @@ public TestAlgoCollector assertDistance(AlgoHelperEntry algoEntry, List<QueryRes
         pathMerger.doWork(rsp, altPaths, trMap.getWithFallBack(Locale.US));
 
         if (rsp.hasErrors()) {
-            errors.add(algoEntry + " response contains errors. Expected distance: " + rsp.getDistance()
+            errors.add("response for " + algoEntry + " contains errors. Expected distance: " + oneRun.getDistance()
                     + ", expected points: " + oneRun + ". " + queryList + ", errors:" + rsp.getErrors());
             return this;
         }
@@ -134,45 +144,45 @@ void printSummary() {
     }
 
     public static class AlgoHelperEntry {
-        private final Graph baseGraph;
         private final LocationIndex idx;
-        private Graph queryGraph;
+        private Graph forQueryGraph;
+        private String expectedAlgo;
         private AlgorithmOptions opts;
 
-        public AlgoHelperEntry(Graph g, Graph baseGraph, AlgorithmOptions opts, LocationIndex idx) {
-            this.queryGraph = g;
-            this.baseGraph = baseGraph;
+        public AlgoHelperEntry(Graph g, AlgorithmOptions opts, LocationIndex idx, String expectedAlgo) {
+            this.forQueryGraph = g;
             this.opts = opts;
             this.idx = idx;
+            this.expectedAlgo = expectedAlgo;
         }
 
-        public Graph getQueryGraph() {
-            return queryGraph;
+        public Graph getForQueryGraph() {
+            return forQueryGraph;
         }
 
-        public void setQueryGraph(Graph queryGraph) {
-            this.queryGraph = queryGraph;
+        public void setAlgorithmOptions(AlgorithmOptions opts) {
+            this.opts = opts;
         }
 
-        public Graph getBaseGraph() {
-            return baseGraph;
+        public RoutingAlgorithmFactory createRoutingFactory() {
+            return new RoutingAlgorithmFactorySimple();
         }
 
-        public void setAlgorithmOptions(AlgorithmOptions opts) {
-            this.opts = opts;
+        public AlgorithmOptions getAlgorithmOptions() {
+            return opts;
         }
 
         public LocationIndex getIdx() {
             return idx;
         }
 
-        public RoutingAlgorithm createAlgo(Graph qGraph) {
-            return new RoutingAlgorithmFactorySimple().createAlgo(qGraph, opts);
+        public String getExpectedAlgo() {
+            return expectedAlgo;
         }
 
         @Override
         public String toString() {
-            return opts.getAlgorithm() + (queryGraph instanceof CHGraph ? "CH" : "");
+            return "algoEntry(" + opts.getAlgorithm() + (forQueryGraph instanceof CHGraph ? "|ch" : "") + ")";
         }
     }
 
diff --git a/core/src/main/java/com/graphhopper/routing/weighting/BeelineWeightApproximator.java b/core/src/main/java/com/graphhopper/routing/weighting/BeelineWeightApproximator.java
@@ -69,4 +69,9 @@ public BeelineWeightApproximator setDistanceCalc(DistanceCalc distanceCalc) {
         this.distanceCalc = distanceCalc;
         return this;
     }
+
+    @Override
+    public String toString() {
+        return "beeline";
+    }
 }
diff --git a/core/src/main/java/com/graphhopper/routing/weighting/ConsistentWeightApproximator.java b/core/src/main/java/com/graphhopper/routing/weighting/ConsistentWeightApproximator.java
@@ -52,4 +52,9 @@ public double approximate(int fromNode, boolean reverse) {
 
         return weightApproximation;
     }
+
+    @Override
+    public String toString() {
+        return uniDirApproximatorForward.toString();
+    }
 }
diff --git a/core/src/main/java/com/graphhopper/routing/weighting/TurnWeighting.java b/core/src/main/java/com/graphhopper/routing/weighting/TurnWeighting.java
@@ -47,7 +47,7 @@ public TurnWeighting(Weighting superWeighting, TurnCostExtension turnCostExt) {
         this.turnCostEncoder = (TurnCostEncoder) superWeighting.getFlagEncoder();
         this.superWeighting = superWeighting;
         this.turnCostExt = turnCostExt;
-        
+
         if (turnCostExt == null)
             throw new RuntimeException("No storage set to calculate turn weight");
     }
@@ -124,6 +124,11 @@ public boolean matches(HintsMap weightingMap) {
         return superWeighting.matches(weightingMap);
     }
 
+    @Override
+    public String toString() {
+        return "turn|" + superWeighting.toString();
+    }
+
     @Override
     public String getName() {
         return "turn|" + superWeighting.getName();
diff --git a/core/src/main/java/com/graphhopper/util/PMap.java b/core/src/main/java/com/graphhopper/util/PMap.java
@@ -149,7 +149,7 @@ String get(String key) {
      * This method copies the underlying structur into a new Map object
      */
     public Map<String, String> toMap() {
-        return new HashMap<String, String>(map);
+        return new HashMap<>(map);
     }
 
     private Map<String, String> getMap() {
diff --git a/core/src/test/java/com/graphhopper/routing/RoutingAlgorithmIT.java b/core/src/test/java/com/graphhopper/routing/RoutingAlgorithmIT.java
@@ -17,15 +17,18 @@
  */
 package com.graphhopper.routing;
 
+import com.graphhopper.GraphHopper;
 import com.graphhopper.reader.PrinctonReader;
-import com.graphhopper.routing.ch.PrepareContractionHierarchies;
 import com.graphhopper.routing.util.EncodingManager;
 import com.graphhopper.routing.util.FlagEncoder;
+import com.graphhopper.routing.util.HintsMap;
 import com.graphhopper.routing.util.TestAlgoCollector.AlgoHelperEntry;
 import com.graphhopper.routing.util.TraversalMode;
-import com.graphhopper.routing.weighting.ShortestWeighting;
 import com.graphhopper.routing.weighting.Weighting;
-import com.graphhopper.storage.*;
+import com.graphhopper.storage.CHGraph;
+import com.graphhopper.storage.Directory;
+import com.graphhopper.storage.GraphBuilder;
+import com.graphhopper.storage.GraphHopperStorage;
 import com.graphhopper.storage.index.LocationIndex;
 import com.graphhopper.storage.index.LocationIndexTree;
 import com.graphhopper.util.Parameters;
@@ -44,32 +47,65 @@
 
 /**
  * Try algorithms, indices and graph storages with real data
- * <p>
  *
  * @author Peter Karich
  */
 public class RoutingAlgorithmIT {
-    public static List<AlgoHelperEntry> createAlgos(GraphHopperStorage ghStorage, LocationIndex idx, boolean withCH,
-                                                    TraversalMode tMode, Weighting weighting) {
-        List<AlgoHelperEntry> prepare = new ArrayList<AlgoHelperEntry>();
-        prepare.add(new AlgoHelperEntry(ghStorage, ghStorage, new AlgorithmOptions(ASTAR, weighting, tMode), idx));
+    public static List<AlgoHelperEntry> createAlgos(final GraphHopper hopper, final HintsMap hints, TraversalMode tMode) {
+        GraphHopperStorage ghStorage = hopper.getGraphHopperStorage();
+        LocationIndex idx = hopper.getLocationIndex();
+
+        String addStr = "";
+        if (tMode.isEdgeBased())
+            addStr = "turn|";
+
+        FlagEncoder encoder = hopper.getEncodingManager().getEncoder(hints.getVehicle());
+        Weighting weighting = hopper.createWeighting(hints, encoder, hopper.getGraphHopperStorage());
+
+        HintsMap defaultHints = new HintsMap().put(Parameters.CH.DISABLE, true)
+                .setVehicle(hints.getVehicle()).setWeighting(hints.getWeighting());
+
+        AlgorithmOptions defaultOpts = AlgorithmOptions.start(new AlgorithmOptions("", weighting, tMode)).hints(defaultHints).build();
+
+        List<AlgoHelperEntry> prepare = new ArrayList<>();
+        prepare.add(new AlgoHelperEntry(ghStorage, AlgorithmOptions.start(defaultOpts).algorithm(ASTAR).build(), idx, "astar|beeline|" + addStr + weighting));
         // later: include dijkstraOneToMany
-        prepare.add(new AlgoHelperEntry(ghStorage, ghStorage, new AlgorithmOptions(DIJKSTRA, weighting, tMode), idx));
+        prepare.add(new AlgoHelperEntry(ghStorage, AlgorithmOptions.start(defaultOpts).algorithm(DIJKSTRA).build(), idx, "dijkstra|" + addStr + weighting));
 
-        final AlgorithmOptions astarbiOpts = new AlgorithmOptions(ASTAR_BI, weighting, tMode);
+        AlgorithmOptions astarbiOpts = AlgorithmOptions.start(defaultOpts).algorithm(ASTAR_BI).build();
         astarbiOpts.getHints().put(ASTAR_BI + ".approximation", "BeelineSimplification");
-        final AlgorithmOptions dijkstrabiOpts = new AlgorithmOptions(DIJKSTRA_BI, weighting, tMode);
-        prepare.add(new AlgoHelperEntry(ghStorage, ghStorage, astarbiOpts, idx));
-        prepare.add(new AlgoHelperEntry(ghStorage, ghStorage, dijkstrabiOpts, idx));
-
-        if (withCH) {
-            final AlgorithmOptions chOpts = AlgorithmOptions.start(dijkstrabiOpts).build();
-            chOpts.getHints().put(Parameters.CH.DISABLE, true);
-            prepare.add(new AlgoHelperEntry(ghStorage, ghStorage, chOpts, idx));
-
-            final AlgorithmOptions astarCH = AlgorithmOptions.start(astarbiOpts).build();
-            astarCH.getHints().put(Parameters.CH.DISABLE, true);
-            prepare.add(new AlgoHelperEntry(ghStorage, ghStorage, astarCH, idx));
+        AlgorithmOptions dijkstrabiOpts = AlgorithmOptions.start(defaultOpts).algorithm(DIJKSTRA_BI).build();
+        prepare.add(new AlgoHelperEntry(ghStorage, astarbiOpts, idx, "astarbi|beeline|" + addStr + weighting));
+        prepare.add(new AlgoHelperEntry(ghStorage, dijkstrabiOpts, idx, "dijkstrabi|" + addStr + weighting));
+
+        // add additional preparations if CH preparation are enabled
+        if (hopper.getCHFactoryDecorator().isEnabled()) {
+            final HintsMap chHints = new HintsMap(defaultHints).put(Parameters.CH.DISABLE, false);
+            Weighting pickedWeighting = null;
+            for (Weighting tmpWeighting : hopper.getCHFactoryDecorator().getWeightings()) {
+                if (tmpWeighting.equals(weighting)) {
+                    pickedWeighting = tmpWeighting;
+                    break;
+                }
+            }
+            if (pickedWeighting == null)
+                throw new IllegalStateException("Didn't find weighting " + hints.getWeighting() + " in " + hopper.getCHFactoryDecorator().getWeightings());
+
+            prepare.add(new AlgoHelperEntry(ghStorage.getGraph(CHGraph.class, pickedWeighting),
+                    AlgorithmOptions.start(dijkstrabiOpts).hints(chHints).build(), idx, "dijkstrabi|ch|prepare|" + hints.getWeighting()) {
+                @Override
+                public RoutingAlgorithmFactory createRoutingFactory() {
+                    return hopper.getAlgorithmFactory(chHints);
+                }
+            });
+
+            prepare.add(new AlgoHelperEntry(ghStorage.getGraph(CHGraph.class, pickedWeighting),
+                    AlgorithmOptions.start(astarbiOpts).hints(chHints).build(), idx, "astarbi|ch|prepare|" + hints.getWeighting()) {
+                @Override
+                public RoutingAlgorithmFactory createRoutingFactory() {
+                    return hopper.getAlgorithmFactory(chHints);
+                }
+            });
         }
 
         return prepare;
@@ -81,20 +117,32 @@ public void testPerformance() throws IOException {
         int noJvmWarming = N / 4;
 
         Random rand = new Random(0);
-        EncodingManager eManager = new EncodingManager("car");
-        FlagEncoder encoder = eManager.getEncoder("car");
-        GraphHopperStorage graph = new GraphBuilder(eManager).create();
+        final EncodingManager eManager = new EncodingManager("car");
+        final GraphHopperStorage graph = new GraphBuilder(eManager).create();
 
         String bigFile = "10000EWD.txt.gz";
         new PrinctonReader(graph).setStream(new GZIPInputStream(PrinctonReader.class.getResourceAsStream(bigFile))).read();
-        Collection<AlgoHelperEntry> prepares = createAlgos(graph, null, false, TraversalMode.NODE_BASED,
-                new ShortestWeighting(encoder));
+        GraphHopper hopper = new GraphHopper() {
+            {
+                setCHEnabled(false);
+                setEncodingManager(eManager);
+                loadGraph(graph);
+            }
+
+            @Override
+            protected LocationIndex createLocationIndex(Directory dir) {
+                return new LocationIndexTree(graph, dir);
+            }
+        };
+
+        Collection<AlgoHelperEntry> prepares = createAlgos(hopper, new HintsMap().setWeighting("shortest").setVehicle("car"), TraversalMode.NODE_BASED);
+
         for (AlgoHelperEntry entry : prepares) {
             StopWatch sw = new StopWatch();
             for (int i = 0; i < N; i++) {
                 int node1 = Math.abs(rand.nextInt(graph.getNodes()));
                 int node2 = Math.abs(rand.nextInt(graph.getNodes()));
-                RoutingAlgorithm d = entry.createAlgo(graph);
+                RoutingAlgorithm d = entry.createRoutingFactory().createAlgo(graph, entry.getAlgorithmOptions());
                 if (i >= noJvmWarming)
                     sw.start();
 
diff --git a/reader-osm/src/test/java/com/graphhopper/routing/RoutingAlgorithmWithOSMIT.java b/reader-osm/src/test/java/com/graphhopper/routing/RoutingAlgorithmWithOSMIT.java

Original file line number	Diff line number	Diff line change
`@@ -168,7 +168,7 @@ public int getVisitedNodes() {`
`168`	`168`
`169`	`169`	`@Override`
`170`	`170`	`public String getName() {`
`171`		`- return Parameters.Algorithms.ASTAR;`
	`171`	`+ return Parameters.Algorithms.ASTAR + "\|" + weightApprox;`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`public static class AStarEntry extends SPTEntry {`
Original file line number	Diff line number	Diff line change
`@@ -280,6 +280,6 @@ public void updateBestPath(EdgeIteratorState edgeState, AStarEntry entryCurrent,`
`280`	`280`
`281`	`281`	`@Override`
`282`	`282`	`public String getName() {`
`283`		`- return Parameters.Algorithms.ASTAR_BI;`
	`283`	`+ return Parameters.Algorithms.ASTAR_BI + "\|" + weightApprox;`
`284`	`284`	`}`
`285`	`285`	`}`
Original file line number	Diff line number	Diff line change
`@@ -671,7 +671,7 @@ protected Path createAndInitPath() {`
`671`	`671`
`672`	`672`	`@Override`
`673`	`673`	`public String getName() {`
`674`		`- return "astarbiCH";`
	`674`	`+ return "astarbi\|ch";`
`675`	`675`	`}`
`676`	`676`
`677`	`677`	`@Override`
`@@ -707,7 +707,7 @@ protected Path createAndInitPath() {`
`707`	`707`
`708`	`708`	`@Override`
`709`	`709`	`public String getName() {`
`710`		`- return "dijkstrabiCH";`
	`710`	`+ return "dijkstrabi\|ch";`
`711`	`711`	`}`
`712`	`712`
`713`	`713`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -69,4 +69,9 @@ public BeelineWeightApproximator setDistanceCalc(DistanceCalc distanceCalc) {`
`69`	`69`	`this.distanceCalc = distanceCalc;`
`70`	`70`	`return this;`
`71`	`71`	`}`
	`72`	`+`
	`73`	`+ @Override`
	`74`	`+ public String toString() {`
	`75`	`+ return "beeline";`
	`76`	`+ }`
`72`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,4 +52,9 @@ public double approximate(int fromNode, boolean reverse) {`
`52`	`52`
`53`	`53`	`return weightApproximation;`
`54`	`54`	`}`
	`55`	`+`
	`56`	`+ @Override`
	`57`	`+ public String toString() {`
	`58`	`+ return uniDirApproximatorForward.toString();`
	`59`	`+ }`
`55`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ String get(String key) {`
`149`	`149`	`* This method copies the underlying structur into a new Map object`
`150`	`150`	`*/`
`151`	`151`	`public Map<String, String> toMap() {`
`152`		`- return new HashMap<String, String>(map);`
	`152`	`+ return new HashMap<>(map);`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`private Map<String, String> getMap() {`