com.graphhopper.routing.weighting.custom

Class CustomWeighting

java.lang.Object

com.graphhopper.routing.weighting.AbstractWeighting

com.graphhopper.routing.weighting.custom.CustomWeighting

All Implemented Interfaces:

Weighting

public final class CustomWeighting
extends AbstractWeighting

The CustomWeighting allows adjusting the edge weights relative to those we'd obtain for a given base flag encoder. For example a car flag encoder already provides speeds and access flags for every edge depending on certain edge properties. By default the CustomWeighting simply makes use of these values, but it is possible to adjust them by setting up rules that apply changes depending on the edges' encoded values.

The formula for the edge weights is as follows:

weight = distance/speed + distance_costs + stress_costs

The first term simply corresponds to the time it takes to travel along the edge. The second term adds a fixed per-distance cost that is proportional to the distance but *independent* of the edge properties, i.e. it reads

distance_costs = distance * distance_influence

The third term is also proportional to the distance but compared to the second it describes additional costs that *do* depend on the edge properties. It can represent any kind of costs that depend on the edge (like inconvenience or dangers encountered on 'high-stress' roads for bikes, toll roads (because they cost money), stairs (because they are awkward when going by bike) etc.). This 'stress' term reads

stress_costs = distance * stress_per_meter

and just like the distance term it describes costs measured in seconds. When modelling it, one always has to 'convert' the costs into some time equivalent (e.g. for toll roads one has to think about how much money can be spent to save a certain amount of time). Note that the distance_costs described by the second term in general cannot be properly described by the stress costs, because the distance term allows increasing the per-distance costs per-se (regardless of the type of the road). Also note that both the second and third term are different to the first in that they can increase the edge costs but do *not* modify the travel *time*.

Instead of letting you set the speed directly, `CustomWeighting` allows changing the speed relative to the speed we get from the base flag encoder. The stress costs can be specified by using a factor between 0 and 1 that is called 'priority'.

Therefore the full edge weight formula reads:

 weight = distance / (base_speed * speed_factor * priority)
        + distance * distance_influence
 

The open parameters that we can adjust are therefore: speed_factor, priority and distance_influence and they are specified via the `CustomModel`. The speed can also be restricted to a maximum value, in which case the value calculated via the speed_factor is simply overwritten. Edges that are not accessible according to the access flags of the base vehicle always get assigned an infinite weight and this cannot be changed using this weighting.

See Also:

for details how speed_factor and max_speed are derived from some given edge properties, for details how priority is derived for some given edge properties

Field Summary

Fields

Modifier and Type	Field and Description
static String	CATCH_ALL
static String	NAME

Fields inherited from class com.graphhopper.routing.weighting.AbstractWeighting

accessEnc, avSpeedEnc, flagEncoder

Fields inherited from interface com.graphhopper.routing.weighting.Weighting

INFINITE_U_TURN_COSTS

Constructor Summary

Constructors

Constructor and Description
CustomWeighting(FlagEncoder baseFlagEncoder, EncodedValueLookup lookup, TurnCostProvider turnCostProvider, CustomModel customModel)

Method Summary

Modifier and Type	Method and Description
long	calcEdgeMillis(EdgeIteratorState edgeState, boolean reverse) This method calculates the time taken (in milli seconds) to travel along the specified edgeState.
double	calcEdgeWeight(EdgeIteratorState edgeState, boolean reverse) In most cases subclasses should only override this method to change the edge-weight.
double	getMinWeight(double distance) Used only for the heuristic estimation in A*
String	getName()

Methods inherited from class com.graphhopper.routing.weighting.AbstractWeighting

calcTurnMillis, calcTurnWeight, equals, getFlagEncoder, hashCode, hasTurnCosts, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

NAME

public static final String NAME

See Also:

Constant Field Values

CATCH_ALL

public static final String CATCH_ALL

See Also:

Constant Field Values

Constructor Detail

CustomWeighting

public CustomWeighting(FlagEncoder baseFlagEncoder,
                       EncodedValueLookup lookup,
                       TurnCostProvider turnCostProvider,
                       CustomModel customModel)

Method Detail

getMinWeight

public double getMinWeight(double distance)

Description copied from interface: Weighting

Used only for the heuristic estimation in A*

Returns:

minimal weight for the specified distance in meter. E.g. if you calculate the fastest way the return value is 'distance/max_velocity'

calcEdgeWeight

public double calcEdgeWeight(EdgeIteratorState edgeState,
                             boolean reverse)

Description copied from class: AbstractWeighting

In most cases subclasses should only override this method to change the edge-weight. The turn cost handling should normally be changed by passing another TurnCostProvider implementation to the constructor instead.

Specified by:

calcEdgeWeight in interface Weighting

Specified by:

calcEdgeWeight in class AbstractWeighting

Parameters:

edgeState - the edge for which the weight should be calculated

reverse - if the specified edge is specified in reverse direction e.g. from the reverse case of a bidirectional search.

Returns:

the calculated weight with the specified velocity has to be in the range of 0 and +Infinity. Make sure your method does not return NaN which can e.g. occur for 0/0.

calcEdgeMillis

public long calcEdgeMillis(EdgeIteratorState edgeState,
                           boolean reverse)

Description copied from interface: Weighting

This method calculates the time taken (in milli seconds) to travel along the specified edgeState. It is typically used for post-processing and on only a few thousand edges.

Specified by:

calcEdgeMillis in interface Weighting

Overrides:

calcEdgeMillis in class AbstractWeighting

getName

public String getName()