@Test
public void testPathRecursiveUnpacking() {
// use an encoder where it is possible to store 2 weights per edge
FlagEncoder encoder = new Bike2WeightFlagEncoder();
ShortestWeighting weighting = new ShortestWeighting(encoder);
EncodingManager em = new EncodingManager(encoder);
GraphHopperStorage ghStorage =
createGHStorage(em, Collections.<Weighting>singleton(weighting), false);
CHGraphImpl g2 = (CHGraphImpl) ghStorage.getGraph(CHGraph.class, weighting);
g2.edge(0, 1, 1, true);
EdgeIteratorState iter1_1 = g2.edge(0, 2, 1.4, false);
EdgeIteratorState iter1_2 = g2.edge(2, 5, 1.4, false);
g2.edge(1, 2, 1, true);
g2.edge(1, 3, 3, true);
g2.edge(2, 3, 1, true);
g2.edge(4, 3, 1, true);
g2.edge(2, 5, 1.4, true);
g2.edge(3, 5, 1, true);
g2.edge(5, 6, 1, true);
g2.edge(4, 6, 1, true);
g2.edge(6, 7, 1, true);
EdgeIteratorState iter2_2 = g2.edge(5, 7);
iter2_2.setDistance(1.4).setFlags(encoder.setProperties(10, true, false));
ghStorage.freeze();
// simulate preparation
CHEdgeIteratorState iter2_1 = g2.shortcut(0, 5);
iter2_1.setDistance(2.8).setFlags(encoder.setProperties(10, true, false));
iter2_1.setSkippedEdges(iter1_1.getEdge(), iter1_2.getEdge());
CHEdgeIteratorState tmp = g2.shortcut(0, 7);
tmp.setDistance(4.2).setFlags(encoder.setProperties(10, true, false));
tmp.setSkippedEdges(iter2_1.getEdge(), iter2_2.getEdge());
g2.setLevel(1, 0);
g2.setLevel(3, 1);
g2.setLevel(4, 2);
g2.setLevel(6, 3);
g2.setLevel(2, 4);
g2.setLevel(5, 5);
g2.setLevel(7, 6);
g2.setLevel(0, 7);
AlgorithmOptions opts = new AlgorithmOptions(AlgorithmOptions.DIJKSTRA_BI, encoder, weighting);
Path p =
new PrepareContractionHierarchies(
new GHDirectory("", DAType.RAM_INT),
ghStorage,
g2,
encoder,
weighting,
TraversalMode.NODE_BASED)
.createAlgo(g2, opts)
.calcPath(0, 7);
assertEquals(Helper.createTList(0, 2, 5, 7), p.calcNodes());
assertEquals(1064, p.getTime());
assertEquals(4.2, p.getDistance(), 1e-5);
}
@Test
public void testUnpackingOrder_Fastest() {
LevelGraphStorage g = (LevelGraphStorage) createGraph();
PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
WeightCalculation calc = new FastestCalc(carEncoder);
initUnpackingGraph(g, calc);
RoutingAlgorithm algo = prepare.type(calc).vehicle(carEncoder).createAlgo();
Path p = algo.calcPath(10, 6);
assertEquals(7, p.distance(), 1e-1);
assertEquals(Helper.createTList(10, 0, 1, 2, 3, 4, 5, 6), p.calcNodes());
}
@Test
public void testRoundaboutUnpacking() {
LevelGraph g = createGraph();
initRoundaboutGraph(g);
int old = g.getAllEdges().maxId();
PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
prepare.doWork();
assertEquals(old + 25, g.getAllEdges().maxId());
RoutingAlgorithm algo = prepare.createAlgo();
Path p = algo.calcPath(4, 7);
assertEquals(Helper.createTList(4, 5, 6, 7), p.calcNodes());
}
@Test
public void testDirectedGraph2() {
LevelGraph g = createGraph();
initDirected2(g);
int old = GHUtility.count(g.getAllEdges());
PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
prepare.doWork();
// PrepareTowerNodesShortcutsTest.printEdges(g);
assertEquals(old + 15, GHUtility.count(g.getAllEdges()));
RoutingAlgorithm algo = prepare.createAlgo();
Path p = algo.calcPath(0, 10);
assertEquals(10, p.distance(), 1e-6);
assertEquals(Helper.createTList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10), p.calcNodes());
}
@Test
public void testPathRecursiveUnpacking() {
// use an encoder where it is possible to store 2 weights per edge
FlagEncoder encoder = new Bike2WeightFlagEncoder();
EncodingManager em = new EncodingManager(encoder);
LevelGraphStorage g2 = (LevelGraphStorage) createGraph(em, false);
g2.edge(0, 1, 1, true);
EdgeIteratorState iter1_1 = g2.edge(0, 2, 1.4, false);
EdgeIteratorState iter1_2 = g2.edge(2, 5, 1.4, false);
g2.edge(1, 2, 1, true);
g2.edge(1, 3, 3, true);
g2.edge(2, 3, 1, true);
g2.edge(4, 3, 1, true);
g2.edge(2, 5, 1.4, true);
g2.edge(3, 5, 1, true);
g2.edge(5, 6, 1, true);
g2.edge(4, 6, 1, true);
g2.edge(6, 7, 1, true);
EdgeIteratorState iter2_2 = g2.edge(5, 7);
iter2_2.setDistance(1.4).setFlags(encoder.setProperties(10, true, false));
// simulate preparation
EdgeSkipIterState iter2_1 = g2.shortcut(0, 5);
iter2_1.setDistance(2.8).setFlags(encoder.setProperties(10, true, false));
iter2_1.setSkippedEdges(iter1_1.getEdge(), iter1_2.getEdge());
EdgeSkipIterState tmp = g2.shortcut(0, 7);
tmp.setDistance(4.2).setFlags(encoder.setProperties(10, true, false));
tmp.setSkippedEdges(iter2_1.getEdge(), iter2_2.getEdge());
g2.setLevel(1, 0);
g2.setLevel(3, 1);
g2.setLevel(4, 2);
g2.setLevel(6, 3);
g2.setLevel(2, 4);
g2.setLevel(5, 5);
g2.setLevel(7, 6);
g2.setLevel(0, 7);
Path p =
new PrepareContractionHierarchies(encoder, new ShortestWeighting())
.setGraph(g2)
.createAlgo()
.calcPath(0, 7);
assertEquals(Helper.createTList(0, 2, 5, 7), p.calcNodes());
assertEquals(1064, p.getMillis());
assertEquals(4.2, p.getDistance(), 1e-5);
}
@Test
public void testDirectedGraph() {
LevelGraph g = createGraph();
g.edge(5, 4, 3, false);
g.edge(4, 5, 10, false);
g.edge(2, 4, 1, false);
g.edge(5, 2, 1, false);
g.edge(3, 5, 1, false);
g.edge(4, 3, 1, false);
int old = GHUtility.count(g.getAllEdges());
PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
prepare.doWork();
// PrepareTowerNodesShortcutsTest.printEdges(g);
assertEquals(old + 3, GHUtility.count(g.getAllEdges()));
RoutingAlgorithm algo = prepare.createAlgo();
Path p = algo.calcPath(4, 2);
assertEquals(3, p.distance(), 1e-6);
assertEquals(Helper.createTList(4, 3, 5, 2), p.calcNodes());
}
@Test
public void testBaseGraph() {
CarFlagEncoder carFE = new CarFlagEncoder();
AlgorithmOptions opts =
AlgorithmOptions.start().flagEncoder(carFE).weighting(new ShortestWeighting(carFE)).build();
GraphHopperStorage ghStorage =
createGHStorage(
new EncodingManager(carFE), Collections.singleton(opts.getWeighting()), false);
initDirectedAndDiffSpeed(ghStorage, carFE);
// do CH preparation for car
createFactory(ghStorage, opts);
// use base graph for solving normal Dijkstra
Path p1 = new RoutingAlgorithmFactorySimple().createAlgo(ghStorage, defaultOpts).calcPath(0, 3);
assertEquals(Helper.createTList(0, 1, 5, 2, 3), p1.calcNodes());
assertEquals(p1.toString(), 402.29, p1.getDistance(), 1e-2);
assertEquals(p1.toString(), 144823, p1.getTime());
}
@Override
public GHResponse route(GHRequest request) {
request.check();
StopWatch sw = new StopWatch().start();
GHResponse rsp = new GHResponse();
if (!setSupportsVehicle(request.getVehicle())) {
rsp.addError(
new IllegalArgumentException(
"Vehicle "
+ request.getVehicle()
+ " unsupported. Supported are: "
+ getEncodingManager()));
return rsp;
}
EdgeFilter edgeFilter = new DefaultEdgeFilter(encodingManager.getEncoder(request.getVehicle()));
int from =
index
.findClosest(request.getFrom().lat, request.getFrom().lon, edgeFilter)
.getClosestNode();
int to =
index.findClosest(request.getTo().lat, request.getTo().lon, edgeFilter).getClosestNode();
String debug = "idLookup:" + sw.stop().getSeconds() + "s";
if (from < 0)
rsp.addError(new IllegalArgumentException("Cannot find point 1: " + request.getFrom()));
if (to < 0)
rsp.addError(new IllegalArgumentException("Cannot find point 2: " + request.getTo()));
if (from == to) rsp.addError(new IllegalArgumentException("Point 1 is equal to point 2"));
sw = new StopWatch().start();
RoutingAlgorithm algo = null;
if (chUsage) {
if (request.getAlgorithm().equals("dijkstrabi")) algo = prepare.createAlgo();
else if (request.getAlgorithm().equals("astarbi"))
algo = ((PrepareContractionHierarchies) prepare).createAStar();
else
rsp.addError(
new IllegalStateException(
"Only dijkstrabi and astarbi is supported for LevelGraph (using contraction hierarchies)!"));
} else {
prepare =
NoOpAlgorithmPreparation.createAlgoPrepare(
graph,
request.getAlgorithm(),
encodingManager.getEncoder(request.getVehicle()),
request.getType());
algo = prepare.createAlgo();
}
if (rsp.hasErrors()) {
return rsp;
}
debug += ", algoInit:" + sw.stop().getSeconds() + "s";
sw = new StopWatch().start();
Path path = algo.calcPath(from, to);
debug +=
", "
+ algo.getName()
+ "-routing:"
+ sw.stop().getSeconds()
+ "s"
+ ", "
+ path.getDebugInfo();
PointList points = path.calcPoints();
simplifyRequest = request.getHint("simplifyRequest", simplifyRequest);
if (simplifyRequest) {
sw = new StopWatch().start();
int orig = points.getSize();
double minPathPrecision = request.getHint("douglas.minprecision", 1d);
if (minPathPrecision > 0) {
new DouglasPeucker().setMaxDistance(minPathPrecision).simplify(points);
}
debug +=
", simplify (" + orig + "->" + points.getSize() + "):" + sw.stop().getSeconds() + "s";
}
enableInstructions = request.getHint("instructions", enableInstructions);
if (enableInstructions) {
sw = new StopWatch().start();
rsp.setInstructions(path.calcInstructions());
debug += ", instructions:" + sw.stop().getSeconds() + "s";
}
return rsp.setPoints(points)
.setDistance(path.getDistance())
.setTime(path.getTime())
.setDebugInfo(debug);
}
public void runShortestPathPerf(int runs, RoutingAlgorithm algo) throws Exception {
BBox bbox = unterfrankenGraph.getBounds();
double minLat = bbox.minLat, minLon = bbox.minLon;
double maxLat = bbox.maxLat, maxLon = bbox.maxLon;
if (unterfrankenGraph instanceof LevelGraph) {
if (algo instanceof DijkstraBidirectionRef)
algo = new PrepareContractionHierarchies().setGraph(unterfrankenGraph).createAlgo();
// algo = new
// PrepareSimpleShortcuts().setGraph(unterfrankenGraph).createAlgo();
else if (algo instanceof AStarBidirection)
algo = new PrepareSimpleShortcuts().setGraph(unterfrankenGraph).createAStar();
else
// level graph accepts all algorithms but normally we want to use an optimized one
throw new IllegalStateException(
"algorithm which boosts query time for levelgraph not found " + algo);
logger.info("[experimental] using shortcuts with " + algo);
} else logger.info("running " + algo);
Random rand = new Random(123);
StopWatch sw = new StopWatch();
// System.out.println("cap:" + ((GraphStorage) unterfrankenGraph).capacity());
for (int i = 0; i < runs; i++) {
double fromLat = rand.nextDouble() * (maxLat - minLat) + minLat;
double fromLon = rand.nextDouble() * (maxLon - minLon) + minLon;
// sw.start();
int from = idx.findID(fromLat, fromLon);
double toLat = rand.nextDouble() * (maxLat - minLat) + minLat;
double toLon = rand.nextDouble() * (maxLon - minLon) + minLon;
int to = idx.findID(toLat, toLon);
// sw.stop();
// logger.info(i + " " + sw + " from (" + from + ")" + fromLat + ", " + fromLon
// + " to (" + to + ")" + toLat + ", " + toLon);
if (from == to) {
logger.warn("skipping i " + i + " from==to " + from);
continue;
}
algo.clear();
sw.start();
Path p = algo.calcPath(from, to);
sw.stop();
if (!p.found()) {
// there are still paths not found cause of oneway motorways => only routable in one
// direction
// e.g. unterfrankenGraph.getLatitude(798809) + "," + unterfrankenGraph.getLongitude(798809)
logger.warn(
"no route found for i="
+ i
+ " !? "
+ "graph-from "
+ from
+ "("
+ fromLat
+ ","
+ fromLon
+ "), "
+ "graph-to "
+ to
+ "("
+ toLat
+ ","
+ toLon
+ ")");
continue;
}
if (i % 20 == 0)
logger.info(i + " " + sw.getSeconds() / (i + 1) + " secs/run"); // (" + p + ")");
}
}
@Test
public void testBaseGraphMultipleVehicles() {
AlgorithmOptions footOptions =
AlgorithmOptions.start()
.flagEncoder(footEncoder)
.weighting(new FastestWeighting(footEncoder))
.build();
AlgorithmOptions carOptions =
AlgorithmOptions.start()
.flagEncoder(carEncoder)
.weighting(new FastestWeighting(carEncoder))
.build();
GraphHopperStorage g =
createGHStorage(
encodingManager,
Arrays.asList(footOptions.getWeighting(), carOptions.getWeighting()),
false);
initFootVsCar(g);
// do CH preparation for car
RoutingAlgorithmFactory contractedFactory = createFactory(g, carOptions);
// use contracted graph
Path p1 =
contractedFactory
.createAlgo(getGraph(g, carOptions.getWeighting()), carOptions)
.calcPath(0, 7);
assertEquals(Helper.createTList(0, 4, 6, 7), p1.calcNodes());
assertEquals(p1.toString(), 15000, p1.getDistance(), 1e-6);
// use base graph for solving normal Dijkstra via car
Path p2 = new RoutingAlgorithmFactorySimple().createAlgo(g, carOptions).calcPath(0, 7);
assertEquals(Helper.createTList(0, 4, 6, 7), p2.calcNodes());
assertEquals(p2.toString(), 15000, p2.getDistance(), 1e-6);
assertEquals(p2.toString(), 2700 * 1000, p2.getTime());
// use base graph for solving normal Dijkstra via foot
Path p3 = new RoutingAlgorithmFactorySimple().createAlgo(g, footOptions).calcPath(0, 7);
assertEquals(p3.toString(), 17000, p3.getDistance(), 1e-6);
assertEquals(p3.toString(), 12240 * 1000, p3.getTime());
assertEquals(Helper.createTList(0, 4, 5, 7), p3.calcNodes());
}
