GraphHopper (GraphHopper Core stable API)

java.lang.Object
- com.graphhopper.GraphHopper

All Implemented Interfaces:

GraphHopperAPI
```
public class GraphHopper
extends Object
implements GraphHopperAPI
```
Easy to use access point to configure import and (offline) routing.

Author:

Peter Karich

See Also:

GraphHopperAPI

Constructor Summary

Constructors
Constructor and Description

GraphHopper()

Constructors
Constructor and Description
`GraphHopper()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`List<Path>`	`calcPaths(GHRequest request, GHResponse ghRsp)` This method calculates the alternative path list using the low level Path objects.
`void`	`clean()` Removes the on-disc routing files.
`protected void`	`cleanUp()` Internal method to clean up the graph.
`void`	`close()` Releases all associated resources like memory or files.
`protected LocationIndex`	`createLocationIndex(Directory dir)`
`protected DataReader`	`createReader(GraphHopperStorage ghStorage)`
`protected RoutingTemplate`	`createRoutingTemplate(GHRequest request, GHResponse ghRsp, String algoStr, Weighting weighting)`
`Weighting`	`createWeighting(Profile profile, PMap hints)`
`Weighting`	`createWeighting(Profile profile, PMap hints, boolean disableTurnCosts)`
`protected void`	`ensureNotLoaded()`
`protected void`	`ensureWriteAccess()`
`protected void`	`flush()`
`GraphHopper`	`forDesktop()` Configures the underlying storage to be used on a Desktop computer or within another Java application with enough RAM but no network latency.
`GraphHopper`	`forMobile()` Configures the underlying storage to be used on a less powerful machine like Android or Raspberry Pi with only few MB of RAM.
`GraphHopper`	`forServer()` Configures the underlying storage and response to be used on a well equipped server.
`RoutingAlgorithmFactory`	`getAlgorithmFactory(String profile, boolean disableCH, boolean disableLM)`
`CHPreparationHandler`	`getCHPreparationHandler()`
`String`	`getDataReaderFile()`
`ElevationProvider`	`getElevationProvider()`
`EncodedValueFactory`	`getEncodedValueFactory()`
`EncodingManager`	`getEncodingManager()`
`String`	`getGraphHopperLocation()`
`GraphHopperStorage`	`getGraphHopperStorage()` The underlying graph used in algorithms.
`LMPreparationHandler`	`getLMPreparationHandler()`
`LocationIndex`	`getLocationIndex()` The location index created from the graph.
`int`	`getMaxVisitedNodes()`
`PathDetailsBuilderFactory`	`getPathDetailsBuilderFactory()`
`Profile`	`getProfile(String profileName)` Returns the profile for the given profile name, or null if it does not exist
`List<Profile>`	`getProfiles()`
`TagParserFactory`	`getTagParserFactory()`
`TranslationMap`	`getTranslationMap()`
`protected double`	`getWayPointMaxDistance()` Return maximum distance (in meter) to reduce points via douglas peucker while OSM import.
`protected int`	`getWorkerThreads()` Threads for data reading.
`boolean`	`hasElevation()`
`void`	`importAndClose()` Imports and processes data, storing it to disk when complete.
`protected DataReader`	`importData()`
`GraphHopper`	`importOrLoad()` Imports provided data from disc and creates graph.
`protected void`	`importPublicTransit()`
`GraphHopper`	`init(GraphHopperConfig ghConfig)` Reads the configuration from a `GraphHopperConfig` object which can be manually filled, or more typically is read from `config.yml`.
`protected DataReader`	`initDataReader(DataReader reader)`
`protected void`	`initLocationIndex()` Initializes the location index after the import is done.
`boolean`	`isAllowWrites()`
`boolean`	`load(String graphHopperFolder)` Opens existing graph folder.
`protected GraphHopper`	`loadGraph(GraphHopperStorage g)` For testing only
`protected void`	`loadOrPrepareLM(boolean closeEarly)` For landmarks it is required to always call this method: either it creates the landmark data or it loads it.
`void`	`postProcessing()` Does the preparation and creates the location index
`protected void`	`postProcessing(boolean closeEarly)` Does the preparation and creates the location index
`protected void`	`prepareCH(boolean closeEarly)`
`protected void`	`registerCustomEncodedValues(EncodingManager.Builder emBuilder)`
`GHResponse`	`route(GHRequest request)`
`GraphHopper`	`setAllowWrites(boolean allowWrites)` Specifies if it is allowed for GraphHopper to write.
`GraphHopper`	`setDataReaderFile(String dataReaderFileStr)` This file can be any file type supported by the DataReader.
`GraphHopper`	`setElevation(boolean includeElevation)` Enable storing and fetching elevation data.
`GraphHopper`	`setElevationProvider(ElevationProvider eleProvider)`
`GraphHopper`	`setEnableCalcPoints(boolean b)` This methods enables gps point calculation.
`GraphHopper`	`setEncodedValueFactory(EncodedValueFactory factory)`
`GraphHopper`	`setEncodingManager(EncodingManager em)` Specify which vehicles can be read by this GraphHopper instance.
`GraphHopper`	`setFlagEncoderFactory(FlagEncoderFactory factory)`
`GraphHopper`	`setGraphHopperLocation(String ghLocation)` Sets the graphhopper folder.
`void`	`setGraphHopperStorage(GraphHopperStorage ghStorage)`
`GraphHopper`	`setInMemory()` This method call results in an in-memory graph.
`protected void`	`setLocationIndex(LocationIndex locationIndex)`
`void`	`setMaxVisitedNodes(int maxVisitedNodes)` This methods stops the algorithm from searching further if the resulting path would go over the specified node count, important if none-CH routing is used.
`GraphHopper`	`setMemoryMapped()` Enable memory mapped configuration if not enough memory is available on the target platform.
`GraphHopper`	`setMinNetworkSize(int minNetworkSize)`
`void`	`setNonChMaxWaypointDistance(int nonChMaxWaypointDistance)`
`GraphHopper`	`setPathDetailsBuilderFactory(PathDetailsBuilderFactory pathBuilderFactory)`
`GraphHopper`	`setPreciseIndexResolution(int precision)` Precise location resolution index means also more space (disc/RAM) could be consumed and probably slower query times, which would be e.g.
`GraphHopper`	`setProfiles(List<Profile> profiles)`
`GraphHopper`	`setProfiles(Profile... profiles)` Sets the routing profiles that can be used for CH/LM preparation.
`GraphHopper`	`setSortGraph(boolean sortGraph)` Sorts the graph which requires more RAM while import.
`GraphHopper`	`setStoreOnFlush(boolean storeOnFlush)` Only valid option for in-memory graph and if you e.g.
`GraphHopper`	`setTagParserFactory(TagParserFactory factory)`
`GraphHopper`	`setWayPointMaxDistance(double wayPointMaxDistance)` This parameter specifies how to reduce points via douglas peucker while OSM import.
`protected void`	`validateRequest(GHRequest request)`

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

- Constructor Detail
  - GraphHopper
```
public GraphHopper()
```
- Method Detail
  - loadGraph
```
protected GraphHopper loadGraph(GraphHopperStorage g)
```
    For testing only
  - getEncodingManager
```
public EncodingManager getEncodingManager()
```
  - setEncodingManager
```
public GraphHopper setEncodingManager(EncodingManager em)
```
    Specify which vehicles can be read by this GraphHopper instance. An encoding manager defines how data from every vehicle is written (und read) into edges of the graph.
  - getElevationProvider
```
public ElevationProvider getElevationProvider()
```
  - setElevationProvider
```
public GraphHopper setElevationProvider(ElevationProvider eleProvider)
```
  - getWorkerThreads
```
protected int getWorkerThreads()
```
    Threads for data reading.
  - getWayPointMaxDistance
```
protected double getWayPointMaxDistance()
```
    Return maximum distance (in meter) to reduce points via douglas peucker while OSM import.
  - setWayPointMaxDistance
```
public GraphHopper setWayPointMaxDistance(double wayPointMaxDistance)
```
    This parameter specifies how to reduce points via douglas peucker while OSM import. Higher value means more details, unit is meter. Default is 1. Disable via 0.
  - setPathDetailsBuilderFactory
```
public GraphHopper setPathDetailsBuilderFactory(PathDetailsBuilderFactory pathBuilderFactory)
```
  - getPathDetailsBuilderFactory
```
public PathDetailsBuilderFactory getPathDetailsBuilderFactory()
```
  - forServer
```
public GraphHopper forServer()
```
    Configures the underlying storage and response to be used on a well equipped server. Result also optimized for usage in the web module i.e. try reduce network IO.
  - forDesktop
```
public GraphHopper forDesktop()
```
    Configures the underlying storage to be used on a Desktop computer or within another Java application with enough RAM but no network latency.
  - forMobile
```
public GraphHopper forMobile()
```
    Configures the underlying storage to be used on a less powerful machine like Android or Raspberry Pi with only few MB of RAM.
  - setPreciseIndexResolution
```
public GraphHopper setPreciseIndexResolution(int precision)
```
    Precise location resolution index means also more space (disc/RAM) could be consumed and probably slower query times, which would be e.g. not suitable for Android. The resolution specifies the tile width (in meter).
  - setMinNetworkSize
```
public GraphHopper setMinNetworkSize(int minNetworkSize)
```
  - setInMemory
```
public GraphHopper setInMemory()
```
    This method call results in an in-memory graph.
  - setStoreOnFlush
```
public GraphHopper setStoreOnFlush(boolean storeOnFlush)
```
    Only valid option for in-memory graph and if you e.g. want to disable store on flush for unit tests. Specify storeOnFlush to true if you want that existing data will be loaded FROM disc and all in-memory data will be flushed TO disc after flush is called e.g. while OSM import.
    
    Parameters:
    
    storeOnFlush - true by default
  - setMemoryMapped
```
public GraphHopper setMemoryMapped()
```
    Enable memory mapped configuration if not enough memory is available on the target platform.
  - setProfiles
```
public GraphHopper setProfiles(Profile... profiles)
```
    Sets the routing profiles that can be used for CH/LM preparation. So far adding these profiles is only required so we can refer to them when configuring the CH/LM preparations, later it will be required to specify all routing profiles that shall be supported by this GraphHopper instance here.
    Here is an example how to setup two CH profiles and one LM profile (via the Java API)
```
 
   // make sure the encoding manager contains a "car" and a "bike" flag encoder
   hopper.setProfiles(
     new Profile("my_car").setVehicle("car").setWeighting("shortest"),
     new Profile("your_bike").setVehicle("bike").setWeighting("fastest")
   );
   hopper.getCHPreparationHandler().setCHProfiles(
     new CHProfile("my_car"),
     new CHProfile("your_bike")
   );
   hopper.getLMPreparationHandler().setLMProfiles(
     new LMProfile("your_bike")
   );
 
 
```
    See also https://github.com/graphhopper/graphhopper/pull/1922.
    See Also:
    
    CHPreparationHandler.setCHProfiles(com.graphhopper.config.CHProfile...), LMPreparationHandler.setLMProfiles(com.graphhopper.config.LMProfile...)
  - setProfiles
```
public GraphHopper setProfiles(List<Profile> profiles)
```
  - getProfiles
```
public List<Profile> getProfiles()
```
  - getProfile
```
public Profile getProfile(String profileName)
```
    Returns the profile for the given profile name, or null if it does not exist
  - getMaxVisitedNodes
```
public int getMaxVisitedNodes()
```
  - setMaxVisitedNodes
```
public void setMaxVisitedNodes(int maxVisitedNodes)
```
    This methods stops the algorithm from searching further if the resulting path would go over the specified node count, important if none-CH routing is used.
  - hasElevation
```
public boolean hasElevation()
```
    Returns:
    
    true if storing and fetching elevation data is enabled. Default is false
  - setElevation
```
public GraphHopper setElevation(boolean includeElevation)
```
    Enable storing and fetching elevation data. Default is false
  - setEnableCalcPoints
```
public GraphHopper setEnableCalcPoints(boolean b)
```
    This methods enables gps point calculation. If disabled only distance will be calculated.
  - getGraphHopperLocation
```
public String getGraphHopperLocation()
```
  - setGraphHopperLocation
```
public GraphHopper setGraphHopperLocation(String ghLocation)
```
    Sets the graphhopper folder.
  - getDataReaderFile
```
public String getDataReaderFile()
```
  - setDataReaderFile
```
public GraphHopper setDataReaderFile(String dataReaderFileStr)
```
    This file can be any file type supported by the DataReader. E.g. for the OSMReader it is the OSM xml (.osm), a compressed xml (.osm.zip or .osm.gz) or a protobuf file (.pbf)
  - getGraphHopperStorage
```
public GraphHopperStorage getGraphHopperStorage()
```
    The underlying graph used in algorithms.
    
    Throws:
    
    IllegalStateException - if graph is not instantiated.
  - setGraphHopperStorage
```
public void setGraphHopperStorage(GraphHopperStorage ghStorage)
```
  - getLocationIndex
```
public LocationIndex getLocationIndex()
```
    The location index created from the graph.
    
    Throws:
    
    IllegalStateException - if index is not initialized
  - setLocationIndex
```
protected void setLocationIndex(LocationIndex locationIndex)
```
  - setSortGraph
```
public GraphHopper setSortGraph(boolean sortGraph)
```
    Sorts the graph which requires more RAM while import. See #12
  - isAllowWrites
```
public boolean isAllowWrites()
```
  - setAllowWrites
```
public GraphHopper setAllowWrites(boolean allowWrites)
```
    Specifies if it is allowed for GraphHopper to write. E.g. for read only filesystems it is not possible to create a lock file and so we can avoid write locks.
  - getTranslationMap
```
public TranslationMap getTranslationMap()
```
  - setFlagEncoderFactory
```
public GraphHopper setFlagEncoderFactory(FlagEncoderFactory factory)
```
  - getEncodedValueFactory
```
public EncodedValueFactory getEncodedValueFactory()
```
  - setEncodedValueFactory
```
public GraphHopper setEncodedValueFactory(EncodedValueFactory factory)
```
  - getTagParserFactory
```
public TagParserFactory getTagParserFactory()
```
  - setTagParserFactory
```
public GraphHopper setTagParserFactory(TagParserFactory factory)
```
  - init
```
public GraphHopper init(GraphHopperConfig ghConfig)
```
    Reads the configuration from a GraphHopperConfig object which can be manually filled, or more typically is read from `config.yml`.
  - importOrLoad
```
public GraphHopper importOrLoad()
```
    Imports provided data from disc and creates graph. Depending on the settings the resulting graph will be stored to disc so on a second call this method will only load the graph from disc which is usually a lot faster.
  - importAndClose
```
public void importAndClose()
```
    Imports and processes data, storing it to disk when complete.
  - importData
```
protected DataReader importData()
                         throws IOException
```
    Throws:
    
    IOException
  - createReader
```
protected DataReader createReader(GraphHopperStorage ghStorage)
```
  - initDataReader
```
protected DataReader initDataReader(DataReader reader)
```
  - load
```
public boolean load(String graphHopperFolder)
```
    Opens existing graph folder.
    
    Specified by:
    
    load in interface GraphHopperAPI
    
    Parameters:
    
    graphHopperFolder - is the folder containing graphhopper files. Can be a compressed file too ala folder-content.ghz.
  - getAlgorithmFactory
```
public RoutingAlgorithmFactory getAlgorithmFactory(String profile,
                                                   boolean disableCH,
                                                   boolean disableLM)
```
  - getCHPreparationHandler
```
public final CHPreparationHandler getCHPreparationHandler()
```
  - getLMPreparationHandler
```
public final LMPreparationHandler getLMPreparationHandler()
```
  - postProcessing
```
public final void postProcessing()
```
    Does the preparation and creates the location index
  - postProcessing
```
protected void postProcessing(boolean closeEarly)
```
    Does the preparation and creates the location index
    
    Parameters:
    
    closeEarly - release resources as early as possible
  - registerCustomEncodedValues
```
protected void registerCustomEncodedValues(EncodingManager.Builder emBuilder)
```
  - importPublicTransit
```
protected void importPublicTransit()
```
  - createWeighting
```
public final Weighting createWeighting(Profile profile,
                                       PMap hints)
```
  - createWeighting
```
public Weighting createWeighting(Profile profile,
                                 PMap hints,
                                 boolean disableTurnCosts)
```
    Parameters:
    
    profile - The profile for which the weighting shall be created
    
    hints - Additional hints that can be used to further specify the weighting that shall be created
    
    disableTurnCosts - Can be used to explicitly create the weighting without turn costs. This is sometimes needed when the weighting shall be used by some algorithm that can only be run with node-based graph traversal, like LM preparation or Isochrones
  - route
```
public GHResponse route(GHRequest request)
```
    Specified by:
    
    route in interface GraphHopperAPI
  - calcPaths
```
public List<Path> calcPaths(GHRequest request,
                            GHResponse ghRsp)
```
    This method calculates the alternative path list using the low level Path objects.
  - validateRequest
```
protected void validateRequest(GHRequest request)
```
  - createRoutingTemplate
```
protected RoutingTemplate createRoutingTemplate(GHRequest request,
                                                GHResponse ghRsp,
                                                String algoStr,
                                                Weighting weighting)
```
  - createLocationIndex
```
protected LocationIndex createLocationIndex(Directory dir)
```
  - initLocationIndex
```
protected void initLocationIndex()
```
    Initializes the location index after the import is done.
  - prepareCH
```
protected void prepareCH(boolean closeEarly)
```
  - loadOrPrepareLM
```
protected void loadOrPrepareLM(boolean closeEarly)
```
    For landmarks it is required to always call this method: either it creates the landmark data or it loads it.
  - cleanUp
```
protected void cleanUp()
```
    Internal method to clean up the graph.
  - flush
```
protected void flush()
```
  - close
```
public void close()
```
    Releases all associated resources like memory or files. But it does not remove them. To remove the files created in graphhopperLocation you have to call clean().
  - clean
```
public void clean()
```
    Removes the on-disc routing files. Call only after calling close or before importOrLoad or load
  - ensureNotLoaded
```
protected void ensureNotLoaded()
```
  - ensureWriteAccess
```
protected void ensureWriteAccess()
```
  - setNonChMaxWaypointDistance
```
public void setNonChMaxWaypointDistance(int nonChMaxWaypointDistance)
```

Class GraphHopper

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GraphHopper

Method Detail

loadGraph

getEncodingManager

setEncodingManager

getElevationProvider

setElevationProvider

getWorkerThreads

getWayPointMaxDistance

setWayPointMaxDistance

setPathDetailsBuilderFactory

getPathDetailsBuilderFactory

forServer

forDesktop

forMobile

setPreciseIndexResolution

setMinNetworkSize

setInMemory

setStoreOnFlush

setMemoryMapped

setProfiles

setProfiles

getProfiles

getProfile

getMaxVisitedNodes

setMaxVisitedNodes

hasElevation

setElevation

setEnableCalcPoints

getGraphHopperLocation

setGraphHopperLocation

getDataReaderFile

setDataReaderFile

getGraphHopperStorage

setGraphHopperStorage

getLocationIndex

setLocationIndex

setSortGraph

isAllowWrites

setAllowWrites

getTranslationMap

setFlagEncoderFactory

getEncodedValueFactory

setEncodedValueFactory

getTagParserFactory

setTagParserFactory

init

importOrLoad

importAndClose

importData

createReader

initDataReader

load

getAlgorithmFactory

getCHPreparationHandler

getLMPreparationHandler

postProcessing

postProcessing

registerCustomEncodedValues

importPublicTransit

createWeighting

createWeighting

route

calcPaths

validateRequest

createRoutingTemplate

createLocationIndex

initLocationIndex

prepareCH

loadOrPrepareLM

cleanUp

flush

close

clean

ensureNotLoaded