com.graphhopper.routing.ch

Class EdgeBasedWitnessPathSearcher

java.lang.Object

com.graphhopper.routing.ch.EdgeBasedWitnessPathSearcher

public class EdgeBasedWitnessPathSearcher
extends Object

Helper class used to perform local witness path searches for graph preparation in edge-based Contraction Hierarchies.

(source edge) -- s -- x -- t -- (target edge) Let x be a node to be contracted (the 'center node') and s and t neighboring un-contracted nodes of x that are directly connected with x (via a normal edge or a shortcut). This class is used to examine the optimal path between s and t in the graph of not yet contracted nodes. More precisely it looks at the minimal-weight-path from an original edge incoming to s (the 'source edge') to an arbitrary original edge incoming to t where the turn-costs at t onto a given original edge outgoing from t (the 'target edge') are also considered. This class is mainly used to differentiate between the following two cases:

1) The optimal path described above has finite weight and only consists of one edge from s to x, an arbitrary number of loops at x, and one edge from x to t. This is called a 'bridge-path' here. 2) The optimal path has infinite weight or it includes an edge from s to another node than x or an edge from another node than x to t. This is called a 'witness-path'.

To find the optimal path an edge-based unidirectional Dijkstra algorithm is used that takes into account turn-costs. The search can be initialized for a given source edge and node to be contracted x. Subsequent searches for different target edges will keep on building the shortest path tree from previous searches. For the performance of edge-based CH graph preparation it is crucial to limit the local witness path searches. However the search always needs to at least find the best bridge-path if one exists. Therefore we may stop expanding edges when a certain amount of settled edges is exceeded, but even then we still need to expand edges that could possibly yield a bridge-path and we may only stop this when it is guaranteed that no bridge-path exists. Here we limit the maximum number of settled edges during the search and determine this maximum number based on the statistics we collected during previous searches.

Author:

easbar

Constructor Summary

Constructors

Constructor and Description
EdgeBasedWitnessPathSearcher(PrepareCHGraph chGraph, PMap pMap)

Method Summary

Modifier and Type	Method and Description
long	getNumPolledEdges()
String	getStatisticsString()
long	getTotalNumSearches()
int	initSearch(int centerNode, int sourceNode, int sourceEdge) Deletes the shortest path tree that has been found so far and initializes a new witness path search for a given node to be contracted and search edge.
void	resetStats()
CHEntry	runSearch(int targetNode, int targetEdge) Runs a witness path search for a given target edge.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

EdgeBasedWitnessPathSearcher

public EdgeBasedWitnessPathSearcher(PrepareCHGraph chGraph,
                                    PMap pMap)

Method Detail

initSearch

public int initSearch(int centerNode,
                      int sourceNode,
                      int sourceEdge)

Deletes the shortest path tree that has been found so far and initializes a new witness path search for a given node to be contracted and search edge.

Parameters:

centerNode - the node to be contracted (x)

sourceNode - the neighbor node from which the search starts (s)

sourceEdge - the original edge incoming to s from which the search starts

Returns:

the number of initial entries and always 0 if we can not directly reach the center node from the given source edge, e.g. when turn costs at s do not allow this.

runSearch

public CHEntry runSearch(int targetNode,
                         int targetEdge)

Runs a witness path search for a given target edge. Results of previous searches (the shortest path tree) are reused and the previous search is extended if necessary. Note that you need to call initSearch(int, int, int) before calling this method to initialize the search.

Parameters:

targetNode - the neighbor node that should be reached by the path (t)

targetEdge - the original edge outgoing from t where the search ends

Returns:

the leaf shortest path tree entry (including all ancestor entries) ending in an edge incoming in t if a 'bridge-path' (see above) has been found to be the optimal path or null if the optimal path is either a witness path or no finite weight path starting with the search edge and leading to the target edge could be found at all.

getStatisticsString

public String getStatisticsString()

getNumPolledEdges

public long getNumPolledEdges()

getTotalNumSearches

public long getTotalNumSearches()

resetStats

public void resetStats()