All Classes and Interfaces
Class
Description
The AdjustedWeighting wraps another Weighting.
Common subclass for bidirectional CH algorithms.
Common subclass for bidirectional algorithms.
Builds a PathDetail list, from values and intervals of a Path.
Common functionality used when working with SRTM hgt data.
Provides basic methods that are usually used in an ElevationProvider that reads tiff files.
This class implements the alternative paths search using the "plateau" and partially the
"penalty" method described in the following papers.
Minimum number-of-moving-parts implementation of alternative route search with
contraction hierarchies.
Minimum number-of-moving-parts implementation of alternative route search with
contraction hierarchies.
Calculates the angle of a turn, defined by three points.
This class implements the A* algorithm according to
http://en.wikipedia.org/wiki/A*_search_algorithm
This class implements a bidirectional A* algorithm.
Average elevation.
Increases the weight for a certain set of edges by a given factor and thus makes them less likely to be part of
a shortest path
Turns an unidirectional weight Approximation into a bidirectional balanced one.
The base graph handles nodes and edges file format.
Include all edges of this storage in the iterator.
A simple bounding box defined as follows: minLon, maxLon followed by minLat which is south(!) and
maxLat.
Approximates the distance to the goal node by weighting the beeline distance according to the
distance weighting
Defines the default rules for Belgian roads
Stores temporary so-called conditional restrictions from access:conditional and other conditional
tags affecting bikes.
LITTLE endianness is default for GraphHopper and most microprocessors.
This interface defines access to an edge property of type boolean.
Implementation of breadth first search (BFS)
Used to find 'bridge-paths' during edge-based CH preparation.
Defines the default rules for Bulgarian roads
Stores temporary so-called conditional restrictions from access:conditional and other conditional
tags affecting cars.
Elevation data from CGIAR project http://srtm.csi.cgiar.org/ 'PROCESSED SRTM DATA VERSION 4.1'.
Container to hold properties used for CH preparation Specifies all properties of a CH routing profile.
Graph data structure used for CH preparation.
This class handles the different CH preparations
Corresponds to an entry in the `profiles_ch` section in config.yml and specifies a routing profile that shall be
prepared using Contraction Hierarchies (CH)
Given a
RoutingCHGraph and possibly a QueryGraph this class sets up and creates routing
algorithm instances used for CH.DataAccess-based storage for CH shortcuts.
Builds a valid
CHStorage, i.e.This interface defines how to parse a OSM value from conditional restrictions.
Simply returns the same value everywhere, useful to represent values that are the same between two (via-)points
Defining several important constants for GraphHopper.
Adapted from org.opentripplanner.common.geometry.DelaunayIsolineBuilder,
which is under LGPL.
The enum constants correspond to the ISO3166-1:alpha3 code of the corresponding country.
GraphHopper uses country rules to adjust the routing behavior based on the country an edge is located in
Defines the default rules for Croatian roads
The CustomWeighting allows adjusting the edge weights relative to those we'd obtain for a given base flag encoder.
This class is for internal usage only.
Defines the default rules for the roads of the Czech Republic.
Life cycle: (1) object creation, (2) configuration (e.g.
This class represents a date range and is able to determine if a given date is in that range.
Parses a DateRange from OpenStreetMap.
Defines how a DataAccess object is created.
This class defines how and where to store an unsigned decimal value.
This class holds a signed decimal value and stores it as an integer value via a conversion factor and a certain
number of bits that determine the maximum value.
Builds a
Path from the two fwd- and bwd-shortest path tree entries of a bidirectional searchThis EdgeFilter combines the weighting result and the 'subnetwork' EncodedValue to consider the subnetwork removal
in LocationIndex lookup.
Defines the default rules for Polish roads
Implementation of depth first search (DFS) by LIFO queue
Implements a single source shortest path algorithm
http://en.wikipedia.org/wiki/Dijkstra's_algorithm
Uses a very simple version of stall-on-demand (SOD) for CH queries to prevent exploring nodes that can not be part
of a shortest path.
Calculates best path in bidirectional way.
A simple dijkstra tuned to perform multiple one to many queries with the same source and different target nodes
more efficiently than
Dijkstra.This class is used to determine the pairs of edges that go into/out of a node of the routing graph.
Maintains a collection of DataAccess objects stored at the same location.
Calculates the distance of two points or one point and an edge on earth via haversine formula.
This class implements a rather quick solution to calculate 3D distances on earth using euclidean
geometry mixed with Haversine formula used for the on earth distance.
Calculates the distance of two points or one point and an edge in euclidean space.
Calculates the approximate distance of two points on earth.
Edge-based version of Tarjan's algorithm to find strongly connected components on a directed graph.
Helper class used to perform local witness path searches for graph preparation in edge-based Contraction Hierarchies.
Abstract base class for tunnel/bridge edge elevation interpolators.
Elevation data is read from DEM tiles that have data points for rectangular tiles usually having an
edge length of 30 or 90 meter.
Elevation data is read from DEM tiles that have data points for rectangular tiles usually having an
edge length of 30 or 90 meter.
Class to get an EdgeIterator.
Class used to traverse a graph.
Calculate the Edge Id segments of a Path
Iterates through all edges of one node.
This interface represents an edge and is one possible state of an EdgeIterator.
Ensures that elevation is sampled along a point list with no more than maxDistance between samples.
Elevation interpolator calculates elevation for the given lat/lon coordinates
based on lat/lon/ele coordinates of the given points.
This interface defines how to store and read values from a list of integers
Manager class to register encoder, assign their flag values and check objects with all encoders
during parsing.
This class allows to store distinct values via an enum.
NodeAccess that allows adding additional pointsWorks like a normal encoded value, but the underlying data is not stored within the graph
This enum is used to specify which nodes should be included in the PointList when calling
EdgeIteratorState.fetchWayGeometry(FetchMode).An
EdgeFilter that only accepts edges with finite weight (in either direction)Stores temporary so-called conditional restrictions from access:conditional and other conditional
tags affecting foot.
Defines the default rules for French roads
Wrapper interface of an integer container for different implementations like OpenBitset, BitSet,
...
This implementation stores the bits inside the values of a long-array.
Implements some common methods for the subclasses.
Prefer GHTBitSet or GHBitSetImpl over this class.
We often do not mix maps but really need to avoid randomness or that threads can influence each
other and so we do not use the default HashOrderMixing employed in HPPC (which does this in a thread-safe manner).
A write lock interface.
An in-memory B-Tree with configurable value size (1-8 bytes).
A priority queue implemented by a treemap to allow fast key update.
Implements the bitset interface via a hash set.
A helper class to avoid cluttering the Graph interface with all the common methods.
Elevation data from Global Multi-resolution Terrain Elevation Data 2010 (GMTED2010).
An interface to represent a (geo) graph - suited for efficient storage as it can be requested via
indices called node IDs.
Easy to use access point to configure import and (offline) routing.
This class represents the global configuration for the GraphHopper class, which is typically configured via the
`config.yml` file.
Basically an OSM restriction, but in 'graph-representation', i.e.
Defines general restrictions for the transport of hazardous materials.
If not tagged it will be
If not tagged it will be
Hazmat.YESDefines the degree of restriction for the transport of hazardous goods through tunnels.
If not tagged it will be
If not tagged it will be
HazmatTunnel.ADefines general restrictions for the transport of goods through water protection areas.
If not tagged it will be
If not tagged it will be
HazmatWater.YESOne rectangle of height data from Shuttle Radar Topography Mission.
This enum defines the road access of an edge.
Defines the default rules for Hungarian roads
This class calculates instructions from the edges in a Path.
This class defines how and where to store an unsigned integer.
Implementation of the IntEncodedValue via a certain number of bits (that determines the maximum value) and
a minimum value (default is 0).
Calculate the intersections for a route.
This class is a partial copy of the class org.apache.commons.collections.BinaryHeap for
just the min heap and primitive, sorted float keys and associated int elements.
Idea and most of the code is from Lucene.
Defines the default rules for Italian roads
This class is copied from: https://github.com/tdebatty/java-string-similarity/blob/master/src/main/java/info/debatty/java/stringsimilarity/JaroWinkler.java
and slightly modified.
This class stores key-value pairs in an append-only manner.
Return a String value from the key-values
This class stores the landmark nodes and the weights from and to all other nodes in every
subnetwork.
This class collects landmarks from an external source for one subnetwork to avoid the expensive and sometimes
suboptimal automatic landmark finding process.
This class is a weight approximation based on precalculated landmarks.
This class deals with the A*, landmark and triangulation (ALT) preparations.
Corresponds to an entry in the `profiles_lm` section in config.yml and specifies a routing profile that shall be
prepared using Landmarks (LM)
Provides a way to map real world data "lat,lon" to internal ids/indices of a memory efficient graph
- often just implemented as an array.
This interface allows to visit edges stored in the LocationIndex.
This class implements a Quadtree to get the closest node or edge from GPS coordinates.
Defines the default rules for Luxembourgish roads
Simple impl of Map.Entry.
Defines the maximum weight per axle for an edge.
One of the four logistic attributes that can be stored per edge.
One of the four logistic attributes that can be stored per edge.
Maximum elevation change in m/100m.
This EncodedValue stores maximum speed values for car in km/h.
One of the four logistic attributes that can be stored per edge.
When the max_weight EncodedValue is not legally binding.
One of the four logistic attributes that can be stored per edge.
A minimum heap implemented using a binary tree (https://en.wikipedia.org/wiki/Binary_heap).
A DataAccess implementation using a memory-mapped file, i.e.
Manages memory mapped DataAccess objects.
Generate only a single points
The MultiSourceElevationProvider mixes different elevation providers to provide the best available elevation data
for a certain area.
This class defines the basis for NameSimilarity matching using an EdgeFilter.
Creates a write lock file.
Defines the default rules for Netherlands roads
This interface specifies how to access properties of the nodes in the graph.
Used to perform witness searches during node-based CH preparation.
Interpolates elevations of pillar nodes based on elevations of tower nodes.
Parses the node information regarding crossing=* and railway=*
Represents an OSM file header
see: https://wiki.openstreetmap.org/wiki/Key%3Afootway
This parser scans different OSM tags to identify ways where a cyclist has to get off her bike.
Parses the hiking difficulty.
Parses the horseback riding difficulty.
A readable OSM file.
https://wiki.openstreetmap.org/wiki/Key:lanes
Parses the mountain biking difficulty.
Parses an OSM file (xml, zipped xml or pbf) and creates a graph from it.
This class currently parses the duration tag only.
This parser fills the different XYTemporalAccess enums from the OSM conditional
restrictions based on the specified dateRangeParserDate.
This class represents a parsed Date and the parse type.
This class represents the result of a shortest path calculation.
The callback used in forEveryEdge.
Implementations of this class allow repeatedly calculating paths for different start/target nodes and edge restrictions
Calculate details for a path and keeps the AbstractPathDetailsBuilder corresponding to this detail.
Generates a list of PathDetailsBuilder from a List of PathDetail names
This class calculates a PathDetail list in a similar fashion to the instruction calculation,
also see
InstructionsFromEdges.This class merges multiple
Path objects into one continuous object that
can be used in the ResponsePath.This class simplifies the path, using
RamerDouglasPeucker, but also considers a given list of partitions of
the path.Converts PBF block data into decoded entities ready to be passed into an Osmosis pipeline.
Instances of this interface are used to receive results from PBFBlobDecoder.
Stores the results for a decoded Blob.
Decodes all blocks from a PBF stream using worker threads, and passes the results to the
downstream sink.
Manages decoding of the lower level PBF data structures.
Represents a single piece of raw blob data extracted from the PBF stream.
An OSM data source reading from a PBF file.
Parses a PBF data stream and extracts the raw data of each blob in sequence until the end of the
stream is reached.
Just a sanity-check implementation for WeightApproximator, which 'approximates' perfectly.
This class helps to store lat,lon,ele for every node parsed in OSMReader
We need all grid cells intersected by a line.
Defines the default rules for Polish roads
This class represents a polygon that is defined by a set of points.
Defines the default rules for Portuguese roads
This class prepares the graph for a bidirectional algorithm supporting contraction hierarchies
ie.
The flags are stored differently for shortcuts: just one weight and the two direction bits which is handled by this
class for now as static methods.
This class does the preprocessing for the ALT algorithm (A* , landmark, triangle inequality).
Detects and marks 'subnetworks' with a dedicated subnetwork encoded value.
Used to store a priority value in the way flags of an edge.
Corresponds to an entry of the `profiles` section in `config.yml` and specifies the properties of a routing profile.
A class which is used to query the underlying graph with real GPS points.
Whenever a
QueryGraph is used for shortest path calculations including turn costs we need to wrap the
Weighting we want to use with this class.This class is used to allow routing between virtual nodes (snapped coordinates that lie between the nodes of the
original graph) when using CH.
This is an in-memory byte-based data structure with the possibility to be stored on flush().
Manages in-memory DataAccess objects.
Simplifies a list of 2D points which are not too far away.
Base class for all network objects
Represents a node received from the reader.
Represents a relation received from the reader.
Container class for relation members
Represents a way received from the reader.
This interface serves the purpose of creating relation flags (max.
Parses the OSM restriction tags for given vehicle types / transportation modes.
This enum defines the road access of an edge.
This enum defines the road class of an edge.
This enum the road environment of an edge.
Defines the default rules for Croatian roads
Defines the default rules for Romanian roads
Implementation of calculating a route with one or more round trip (route with identical start and
end).
This enum defines the route network of an edge when part of a hiking or biking network.
This class contains various parameters that control the behavior of
Router.Calculates the shortest path from the specified node ids.
This interface manages RoutingAlgorithm creation.
A simple factory creating normal algorithms (RoutingAlgorithm) without preparation.
Defines the default rules for Serbian roads
A shape interface to implement circles, polygons or rectangles.
Recursively unpack shortcuts.
Computes a shortest path tree by a given weighting.
This class implements a simple boolean storage via an UnsignedIntEncodedValue with 1 bit.
Creates a write lock file.
push to end, pop from beginning
Generate only a single points
Skadi contains elevation data for the entire world with 1 arc second (~30m) accuracy in SRTM format stitched
together from many sources (https://github.com/tilezen/joerd/blob/master/docs/data-sources.md).
Defines the default rules for Slovakian roads
Defines the default rules for Slovenian roads
This enum defines the road smoothness of an edge.
Result of LocationIndex lookup.
Whether the query point is projected onto a tower node, pillar node or somewhere within
the closest edge.
Defines the default rules for Spanish roads
This class implements the idea of a geohash but without a string representation - to avoid confusion, this is
called 'spatial key'.
This class is used to create the shortest-path-tree from linked entities.
SRTMGL1 contains elevation data for most of the world with 1 arc second (~30m) accuracy.
Elevation data from NASA (SRTM).
The country subdivision is stored in this EncodedValue.
Make simple speed measurements possible.
Interface for a storage abstraction.
Writes an in-memory HashMap into a file on flush.
This class holds a List of up to
StringEncodedValue.maxValues encountered Strings and stores
index+1 to indicate a string is set or 0 if no value is assignedThis class is a partial Copy of the org.apache.commons.lang3.StringUtils
that can be found here: https://github.com/apache/commons-lang/blob/master/src/main/java/org/apache/commons/lang3/StringUtils.java
This EncodedValue, which should be available per profile, stores a boolean value per edge that indicates if the edge
is part of a too small subnetwork.
This class handles storage of subnetwork ids for every node.
This enum defines the road surface of an edge like unpaved or asphalt.
Defines the default rules for Swedish roads
Defines the default rules for Swiss roads
This interface defines how parts of the information from 'way' is converted into IntsRef.
Tarjan's algorithm to find strongly connected components of a directed graph.
Provides basic methods that are usually used in an ElevationProvider using tiles from files.
Calculate the time segments for a Path
This enum defines the toll value like MISSING (default), NO (no toll), HGV
(toll for heavy goods vehicles) and ALL (all vehicles)
Defines the strategy of creating tours.
This enum defines the track type of an edge which describes how well-maintained a certain track is.
A class which manages the translations in-memory.
Define disjunct ways of transportation that are used to create and populate our encoded values from a data source
like OpenStreetMap.
Implementations of this interface define how turn costs and turn times are calculated.
A key/value store, where the unique keys are triples (fromEdge, viaNode, toEdge) and the values
are integers that can be used to store encoded values.
Expression visitor for right-hand side value of limit_to or multiply_by.
The methods here can be used to calculate routes with or without via points and implement possible restrictions
like snap preventions, headings and curbsides.
Creates an edge state decoupled from a graph where nodes, pointList, etc are kept in memory.
Taken from Lucene DataOutput.
This class parses a given OSM file and splits OSM ways into 'segments' at all intersections (or 'junctions').
This map can store multiple edges (int) for each way ID (long).
Specifies a weight approximation between an node and the goalNode according to the specified
weighting.
Calculate the weight segments for a Path
Specifies how the best route is calculated.
This abstract class defines commonalities for BFS and DFS