QueryGraph (GraphHopper Core 1.0-pre2 API)

java.lang.Object
- com.graphhopper.routing.QueryGraph

All Implemented Interfaces:

Graph
```
public class QueryGraph
extends Object
implements Graph
```
A class which is used to query the underlying graph with real GPS points. It does so by introducing virtual nodes and edges. It is lightweight in order to be created every time a new query comes in, which makes the behaviour thread safe.
Calling any lookup method creates virtual edges between the tower nodes of the existing graph and new virtual tower nodes. Every virtual node has two adjacent nodes and is connected to each adjacent nodes via 2 virtual edges with opposite base node / adjacent node encoding. However, the edge explorer returned by createEdgeExplorer() only returns two virtual edges per virtual node (the ones with correct base node).

Author:

Peter Karich

Constructor Summary

Constructors
Constructor and Description

QueryGraph(Graph graph)

Constructors
Constructor and Description
`QueryGraph(Graph graph)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clearUnfavoredStatus()` Removes the 'unfavored' status of all virtual edges.
`Graph`	`copyTo(Graph g)` Copy this Graph into the specified Graph g.
`EdgeExplorer`	`createEdgeExplorer()`
`EdgeExplorer`	`createEdgeExplorer(EdgeFilter edgeFilter)` Returns an EdgeExplorer which makes it possible to traverse all filtered edges of a specific node.
`EdgeIteratorState`	`edge(int a, int b)` Creates an edge between the nodes a and b.
`EdgeIteratorState`	`edge(int a, int b, double distance, boolean bothDirections)` Use edge(a,b).setDistance().setFlags instead
`EdgeIteratorState`	`edge(int a, int b, double distance, int flags)`
`boolean`	`enforceHeading(int nodeId, double favoredHeading, boolean incoming)` Set those edges at the virtual node (nodeId) to 'unfavored' that require at least a turn of 100° from favoredHeading.
`AllEdgesIterator`	`getAllEdges()`
`Graph`	`getBaseGraph()`
`BBox`	`getBounds()` Returns the implicit bounds of this graph calculated from the lat,lon input of setNode
`EdgeIteratorState`	`getEdgeIteratorState(int origEdgeId, int adjNode)` Returns a wrapper over the specified edgeId.
`int`	`getEdges()`
`GraphExtension`	`getExtension()`
`NodeAccess`	`getNodeAccess()` Creates a node explorer to access node properties.
`int`	`getNodes()`
`EdgeIteratorState`	`getOriginalEdgeFromVirtNode(int nodeId)`
`int`	`getOtherNode(int edge, int node)`
`Set<EdgeIteratorState>`	`getUnfavoredVirtualEdges()` Returns all virtual edges that have been unfavored via `enforceHeading(int, double, boolean)` or `unfavorVirtualEdgePair(int, int)`.
`boolean`	`isAdjacentToNode(int edge, int node)`
`boolean`	`isVirtualEdge(int edgeId)`
`boolean`	`isVirtualNode(int nodeId)`
`static QueryGraph`	`lookup(Graph graph, List<QueryResult> queryResults)`
`void`	`lookup(List<QueryResult> resList)` For all specified query results calculate snapped point and if necessary set closest node to a virtual one and reverse closest edge.
`QueryGraph`	`lookup(QueryResult fromRes, QueryResult toRes)` Convenient method to initialize this QueryGraph with the two specified query results.
`QueryGraph`	`setUseEdgeExplorerCache(boolean useEECache)` This method is an experimental feature to reduce memory and CPU resources if there are many locations ("hundreds") for one QueryGraph.
`void`	`unfavorVirtualEdgePair(int virtualNodeId, int virtualEdgeId)` Sets the virtual edge with virtualEdgeId and its reverse edge to 'unfavored', which effectively penalizes both virtual edges towards an adjacent node of virtualNodeId.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - QueryGraph
```
public QueryGraph(Graph graph)
```
- Method Detail
  - lookup
```
public static QueryGraph lookup(Graph graph,
                                List<QueryResult> queryResults)
```
  - lookup
```
public QueryGraph lookup(QueryResult fromRes,
                         QueryResult toRes)
```
    Convenient method to initialize this QueryGraph with the two specified query results.
    
    See Also:
    
    lookup(List)
  - lookup
```
public void lookup(List<QueryResult> resList)
```
    For all specified query results calculate snapped point and if necessary set closest node to a virtual one and reverse closest edge. Additionally the wayIndex can change if an edge is swapped.
    
    See Also:
    
    QueryGraph
  - getBaseGraph
```
public Graph getBaseGraph()
```
    Specified by:
    
    getBaseGraph in interface Graph
    
    Returns:
    
    a graph which behaves like an unprepared graph and e.g. the normal unidirectional Dijkstra or any graph traversal algorithm can be executed.
  - getOriginalEdgeFromVirtNode
```
public EdgeIteratorState getOriginalEdgeFromVirtNode(int nodeId)
```
  - isVirtualEdge
```
public boolean isVirtualEdge(int edgeId)
```
  - isVirtualNode
```
public boolean isVirtualNode(int nodeId)
```
  - setUseEdgeExplorerCache
```
public QueryGraph setUseEdgeExplorerCache(boolean useEECache)
```
    This method is an experimental feature to reduce memory and CPU resources if there are many locations ("hundreds") for one QueryGraph. EdgeExplorer instances are cached based on the EdgeFilter passed into createEdgeExplorer(EdgeFilter). For equal (in the java sense) EdgeFilters always the same EdgeExplorer will be returned when caching is enabled. Care has to be taken for example for custom or threaded algorithms, when using custom EdgeFilters, or when the same edge explorer is used with different vehicles/encoders.
  - enforceHeading
```
public boolean enforceHeading(int nodeId,
                              double favoredHeading,
                              boolean incoming)
```
    Set those edges at the virtual node (nodeId) to 'unfavored' that require at least a turn of 100° from favoredHeading.
    
    Parameters:
    
    nodeId - VirtualNode at which edges get unfavored
    
    favoredHeading - north based azimuth of favored heading between 0 and 360
    
    incoming - if true, incoming edges are unfavored, else outgoing edges
    
    Returns:
    
    boolean indicating if enforcement took place
  - unfavorVirtualEdgePair
```
public void unfavorVirtualEdgePair(int virtualNodeId,
                                   int virtualEdgeId)
```
    Sets the virtual edge with virtualEdgeId and its reverse edge to 'unfavored', which effectively penalizes both virtual edges towards an adjacent node of virtualNodeId. This makes it more likely (but does not guarantee) that the router chooses a route towards the other adjacent node of virtualNodeId.
    
    Parameters:
    
    virtualNodeId - virtual node at which edges get unfavored
    
    virtualEdgeId - this edge and the reverse virtual edge become unfavored
  - getUnfavoredVirtualEdges
```
public Set<EdgeIteratorState> getUnfavoredVirtualEdges()
```
    Returns all virtual edges that have been unfavored via enforceHeading(int, double, boolean) or unfavorVirtualEdgePair(int, int).
  - clearUnfavoredStatus
```
public void clearUnfavoredStatus()
```
    Removes the 'unfavored' status of all virtual edges.
  - getNodes
```
public int getNodes()
```
    Specified by:
    
    getNodes in interface Graph
    
    Returns:
    
    the number of created locations - via setNode() or edge()
  - getEdges
```
public int getEdges()
```
    Specified by:
    
    getEdges in interface Graph
    
    Returns:
    
    the number of edges in this graph. Equivalent to getAllEdges().length().
  - getNodeAccess
```
public NodeAccess getNodeAccess()
```
    Description copied from interface: Graph
    
    Creates a node explorer to access node properties.
    
    Specified by:
    
    getNodeAccess in interface Graph
  - getBounds
```
public BBox getBounds()
```
    Description copied from interface: Graph
    
    Returns the implicit bounds of this graph calculated from the lat,lon input of setNode
    
    Specified by:
    
    getBounds in interface Graph
  - getEdgeIteratorState
```
public EdgeIteratorState getEdgeIteratorState(int origEdgeId,
                                              int adjNode)
```
    Description copied from interface: Graph
    
    Returns a wrapper over the specified edgeId.
    
    Specified by:
    
    getEdgeIteratorState in interface Graph
    
    adjNode - is the node that will be returned via getAdjNode(). If adjNode is Integer.MIN_VALUE then the edge will be returned in the direction of how it is stored
    
    Returns:
    
    a new EdgeIteratorState object or potentially null if adjNode does not match
  - createEdgeExplorer
```
public EdgeExplorer createEdgeExplorer(EdgeFilter edgeFilter)
```
    Description copied from interface: Graph
    
    Returns an EdgeExplorer which makes it possible to traverse all filtered edges of a specific node. Calling this method might be expensive, so e.g. create an explorer before a for loop!
    
    Specified by:
    
    createEdgeExplorer in interface Graph
    
    See Also:
    
    EdgeExplorer, Graph.createEdgeExplorer()
  - createEdgeExplorer
```
public EdgeExplorer createEdgeExplorer()
```
    Specified by:
    
    createEdgeExplorer in interface Graph
    
    See Also:
    
    Graph.createEdgeExplorer(com.graphhopper.routing.util.EdgeFilter)
  - getAllEdges
```
public AllEdgesIterator getAllEdges()
```
    Specified by:
    
    getAllEdges in interface Graph
    
    Returns:
    
    all edges in this graph, where baseNode will be the smaller node.
  - edge
```
public EdgeIteratorState edge(int a,
                              int b)
```
    Description copied from interface: Graph
    
    Creates an edge between the nodes a and b. To set distance or access use the returned edge and e.g. edgeState.setDistance
    
    Specified by:
    
    edge in interface Graph
    
    Parameters:
    
    a - the index of the starting (tower) node of the edge
    
    b - the index of the ending (tower) node of the edge
    
    Returns:
    
    the newly created edge
  - edge
```
public EdgeIteratorState edge(int a,
                              int b,
                              double distance,
                              int flags)
```
  - edge
```
public EdgeIteratorState edge(int a,
                              int b,
                              double distance,
                              boolean bothDirections)
```
    Description copied from interface: Graph
    
    Use edge(a,b).setDistance().setFlags instead
    
    Specified by:
    
    edge in interface Graph
  - copyTo
```
public Graph copyTo(Graph g)
```
    Description copied from interface: Graph
    
    Copy this Graph into the specified Graph g.
    
    Specified by:
    
    copyTo in interface Graph
    
    Returns:
    
    the specified Graph g
  - getExtension
```
public GraphExtension getExtension()
```
    Specified by:
    
    getExtension in interface Graph
    
    Returns:
    
    the graph extension like a TurnCostExtension
  - getOtherNode
```
public int getOtherNode(int edge,
                        int node)
```
    Specified by:
    
    getOtherNode in interface Graph
    
    Returns:
    
    the 'opposite' node of a given edge, so if there is an edge 3-2 and node =2 this returns 3
  - isAdjacentToNode
```
public boolean isAdjacentToNode(int edge,
                                int node)
```
    Specified by:
    
    isAdjacentToNode in interface Graph
    
    Returns:
    
    true if the edge with id edge is adjacent to node, false otherwise

Class QueryGraph

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

QueryGraph

Method Detail

lookup

lookup

lookup

getBaseGraph

getOriginalEdgeFromVirtNode

isVirtualEdge

isVirtualNode

setUseEdgeExplorerCache

enforceHeading

unfavorVirtualEdgePair

getUnfavoredVirtualEdges

clearUnfavoredStatus

getNodes

getEdges

getNodeAccess

getBounds

getEdgeIteratorState

createEdgeExplorer

createEdgeExplorer

getAllEdges

edge

edge

edge

copyTo

getExtension

getOtherNode

isAdjacentToNode