Struct AutoCostingOptions

Source

pub struct AutoCostingOptions { /* private fields */ }

Expand description

Auto Costing Options

Implementations§

Source §

impl AutoCostingOptions

Source

pub fn builder() -> Self

Creates a new instance of AutoCostingOptions.

Source

pub fn gate_cost(self, gate_cost: f32) -> Self

A cost applied when a gate with undefined or private access is encountered.

This cost is added to the estimated time / elapsed time.

Default: 30 seconds

Source

pub fn gate_penalty(self, gate_penalty: f32) -> Self

A penalty applied when a gate with no access information is on the road.

Default: 300 seconds

Source

pub fn private_access_penalty(self, private_access_penalty: f32) -> Self

A penalty applied when a gate or bollard with access=private is encountered.

Default: 450 seconds

Source

pub fn destination_only_penalty(self, destination_only_penalty: f32) -> Self

A penalty applied when entering a road which is only allowed to enter if necessary to reach the destination.

Source

pub fn toll_booth_cost(self, toll_booth_cost: f32) -> Self

A cost applied when a toll booth is encountered.

This cost is added to the estimated and elapsed times.

Default: 15 seconds

Source

pub fn toll_booth_penalty(self, toll_booth_penalty: f32) -> Self

A penalty applied to the cost when a toll booth is encountered.

This penalty can be used to create paths that avoid toll roads.

Default: 0

Source

pub fn ferry_cost(self, ferry_cost: f32) -> Self

A cost applied when entering a ferry.

This cost is added to the estimated and elapsed times.

Default: 300 seconds (5 minutes)

Source

pub fn use_ferry(self, use_ferry: f32) -> Self

This value indicates the willingness to take ferries.

This is a range of values between 0 and 1:

Values near 0 attempt to avoid ferries and
values near 1 will favor ferries.

Note: sometimes ferries are required to complete a route so values of 0 are not guaranteed to avoid ferries entirely.

Default: 0.5

Source

pub fn use_highways(self, use_highways: f32) -> Self

This value indicates the willingness to take highways.

This is a range of values between 0 and 1:

Values near 0 attempt to avoid highways and
values near 1 will favor highways.

Note: sometimes highways are required to complete a route so values of 0 are not guaranteed to avoid highways entirely.

Default: 1.0

Source

pub fn use_tolls(self, use_tolls: f32) -> Self

This value indicates the willingness to take roads with tolls.

This is a range of values between 0 and 1:

Values near 0 attempt to avoid tolls and
values near 1 will not attempt to avoid them.

Note: sometimes roads with tolls are required to complete a route so values of 0 are not guaranteed to avoid them entirely.

Default: 0.5

Source

pub fn use_living_streets(self, use_living_streets: f32) -> Self

This value indicates the willingness to take living streets.

This is a range of values between 0 and 1:

Values near 0 attempt to avoid living streets and
values near 1 will favor living streets.

Note: sometimes living streets are required to complete a route so values of 0 are not guaranteed to avoid living streets entirely.

Default:

truck: 0
cars/buses/motor scooters/motorcycles: 0.1

Source

pub fn use_tracks(self, use_tracks: f32) -> Self

This value indicates the willingness to take track roads.

This is a range of values between 0 and 1:

Values near 0 attempt to avoid tracks and
values near 1 will favor tracks a little bit.

Note: sometimes tracks are required to complete a route so values of 0 are not guaranteed to avoid tracks entirely.

Default:

0 for autos,
0.5 for motor scooters and motorcycles.

Source

pub fn service_penalty(self, service_penalty: f32) -> Self

A penalty applied for transition to generic service road.

Default:

0 trucks and
15 for cars, buses, motor scooters and motorcycles.

Source

pub fn service_factor(self, service_factor: f32) -> Self

A factor that modifies (multiplies) the cost when generic service roads are encountered.

Default: 1

Source

pub fn country_crossing_cost(self, country_crossing_cost: f32) -> Self

A cost applied when encountering an international border.

This cost is added to the estimated and elapsed times.

Default: 600 seconds

Source

pub fn country_crossing_penalty(self, country_crossing_penalty: f32) -> Self

A penalty applied for a country crossing.

This penalty can be used to create paths that avoid spanning country boundaries.

Default: 0

Source

pub fn only_consider_quasi_shortest(self) -> Self

Changes the metric to quasi-shortest, i.e. purely distance-based costing.

Disables ALL other costings & penalties. Also note, shortest will not disable hierarchy pruning, leading to potentially sub-optimal routes for some costing models.

Default: false

Source

pub fn use_distance(self, use_distance: f32) -> Self

A factor that allows controlling the contribution of distance and time to the route costs.

The value is in range between 0 and 1, where

0 only takes time into account (default),
0.5 will weight them roughly equally
1 only distance.

Note: this costing is currently only available for super::Costing::Auto.

Source

pub fn disable_hierarchy_pruning(self) -> Self

Disable hierarchies to calculate the actual optimal route.

Note: This could be quite a performance drainer so there is an upper limit of distance. If the upper limit is exceeded, this option will always be false.

Default: false

Source

pub fn top_speed(self, top_speed: f32) -> Self

Top speed the vehicle can go.

Also used to avoid roads with higher speeds than this value. Must be between 10 and 252 KPH.

Default:

truck: 120 KPH
auto/bus: 140 KPH

Source

pub fn fixed_speed(self, fixed_speed: u32) -> Self

Fixed speed the vehicle can go. Used to override the calculated speed.

Can be useful if speed of vehicle is known. Must be between 1 and 252 KPH.

Default: 0KPH which disables fixed speed and falls back to the standard calculated speed based on the road attribution.

Source

pub fn closure_factor(self, closure_factor: f32) -> Self

A factor that penalizes the cost when traversing a closed edge

Example: If search_filter.exclude_closures is false for origin and/or destination location and the route starts/ends on closed edges.

Its value can range from

1.0 don’t penalize closed edges,
to 10.0 apply high cost penalty to closed edges.

Note: This factor is applicable only for motorized modes of transport, i.e auto, motorcycle, motor_scooter, bus, truck & taxi.

Default: 9.0

Source

pub fn ignore_closures(self) -> Self

If set ignores all closures, marked due to live traffic closures, during routing.

Note: This option cannot be set if location.search_filter.exclude_closures is also specified in the request and will return an error if it is

Source

pub fn ignore_restrictions(self) -> Self

If set, ignores any restrictions (e.g. turn/dimensional/conditional restrictions).

Especially useful for matching GPS traces to the road network regardless of restrictions.

Default: false

Source

pub fn ignore_oneways(self) -> Self

If set, ignores one-way restrictions.

Especially useful for matching GPS traces to the road network ignoring uni-directional traffic rules. Not included in Self::ignore_restrictions option.

Default: false

Source

pub fn ignore_non_vehicular_restrictions(self) -> Self

Similar to Self::ignore_restrictions, but will respect restrictions that impact vehicle safety, such as weight and size restrictions.

Default: false

Source

pub fn ignore_access(self) -> Self

Ignore mode-specific access tags.

Especially useful for matching GPS traces to the road network regardless of restrictions.

Default false

Source

pub fn speed_types(self, speed_types: UsedSpeedSources) -> Self

Will determine which speed sources are used, if available.

A list of strings with the following possible values:

Default: UsedSpeedSources::All sources (again, only if available)

Source

pub fn height(self, height: f32) -> Self

The height of the vehicle (in meters).

Default:

car/bus/taxi: 1.9 and
truck: 4.11

Source

pub fn width(self, width: f32) -> Self

The width of the vehicle (in meters).

Default:

car/bus/taxi: 1.6 and
truck: 2.6

Source

pub fn exclude_unpaved(self) -> Self

Exclude unpaved roads.

If exclude_unpaved is set it is allowed to start and end with unpaved roads, but is not allowed to have them in the middle of the route path, otherwise they are allowed.

Default: false.

Source