Struct map_model::objects::road::Road

pub struct Road {

    pub id: RoadID,
    pub osm_tags: Tags,
    pub turn_restrictions: Vec<(RestrictionType, RoadID)>,
    pub complicated_turn_restrictions: Vec<(RoadID, RoadID)>,
    pub orig_id: OriginalRoad,
    pub speed_limit: Speed,
    pub access_restrictions: AccessRestrictions,
    pub zorder: isize,
    pub percent_incline: f64,
    pub lanes_ltr: Vec<(LaneID, Direction, LaneType)>,
    pub center_pts: PolyLine,
    pub untrimmed_center_pts: PolyLine,
    pub src_i: IntersectionID,
    pub dst_i: IntersectionID,
}

A Road represents a segment between exactly two Intersections. It contains Lanes as children.

Fields

id: RoadID

osm_tags: Tags

turn_restrictions: Vec<(RestrictionType, RoadID)>

self is ‘from’

complicated_turn_restrictions: Vec<(RoadID, RoadID)>

self is ‘from’. (via, to). Only BanTurns.

orig_id: OriginalRoad

speed_limit: Speed

access_restrictions: AccessRestrictions

zorder: isize

percent_incline: f64

[-1.0, 1.0] theoretically, but in practice, about [-0.25, 0.25]. 0 is flat, positive is uphill from src_i -> dst_i, negative is downhill.

lanes_ltr: Vec<(LaneID, Direction, LaneType)>

Invariant: A road must contain at least one child

center_pts: PolyLine

The physical center of the road, including sidewalks, after trimming to account for the intersection geometry. The order implies road orientation.

untrimmed_center_pts: PolyLine

Like center_pts, but before any trimming for intersection geometry. This is preserved so that when modifying road width, intersection polygons can be calculated correctly.

src_i: IntersectionID

dst_i: IntersectionID

Implementations

impl Road

pub fn lanes_ltr(&self) -> Vec<(LaneID, Direction, LaneType)>

Returns all lanes from the left side of the road to right. Left/right is determined by the orientation of center_pts.

pub fn lane_specs(&self, map: &Map) -> Vec<LaneSpec>

pub fn get_left_side(&self, map: &Map) -> PolyLine

pub fn offset(&self, lane: LaneID) -> usize

Counting from the left side of the road

pub(crate) fn dir_and_offset(&self, lane: LaneID) -> (Direction, usize)

lane must belong to this road. Offset 0 is the centermost lane on each side of a road, then it counts up from there. Note this is a different offset than offset!

pub fn parking_to_driving(&self, parking: LaneID, map: &Map) -> Option<LaneID>

pub(crate) fn speed_limit_from_osm(&self) -> Speed

pub fn find_closest_lane<F: Fn(&Lane) -> bool>(
    &self,
    from: LaneID,
    filter: F,
    map: &Map
) -> Option<LaneID>

Includes off-side

pub fn all_lanes(&self) -> Vec<LaneID>

pub fn get_dir_change_pl(&self, map: &Map) -> PolyLine

This is the FIRST yellow line where the direction of the road changes. If multiple direction changes happen, the result is kind of arbitrary.

pub fn get_half_width(&self, map: &Map) -> Distance

pub fn get_width(&self, map: &Map) -> Distance

pub fn get_thick_polygon(&self, map: &Map) -> Polygon

pub fn get_half_polygon(&self, dir: Direction, map: &Map) -> Result<Polygon>

Creates the thick polygon representing one half of the road. For roads with multipe direction changes (like a two-way cycletrack adjacent to a regular two-way road), the results are probably weird.

pub fn get_name(&self, lang: Option<&String>) -> String

pub fn get_rank(&self) -> RoadRank

pub fn get_detailed_rank(&self) -> usize

pub fn all_bus_stops(&self, map: &Map) -> Vec<BusStopID>

pub fn is_light_rail(&self) -> bool

pub fn is_footway(&self) -> bool

pub fn is_service(&self) -> bool

pub fn is_cycleway(&self) -> bool

pub fn common_endpt(&self, other: &Road) -> IntersectionID

pub fn is_private(&self) -> bool

pub(crate) fn access_restrictions_from_osm(&self) -> AccessRestrictions

pub fn get_zone<'a>(&self, map: &'a Map) -> Option<&'a Zone>

pub fn is_extremely_short(&self) -> bool

Many roads wind up with almost no length, due to their representation in OpenStreetMap. In reality, these segments are likely located within the interior of an intersection. This method uses a hardcoded threshold to detect these cases.

pub fn directed_id_from(&self, i: IntersectionID) -> DirectedRoadID

Get the DirectedRoadID pointing to the intersection. Panics if the intersection isn’t an endpoint.

pub fn directed_id_to(&self, i: IntersectionID) -> DirectedRoadID

Get the DirectedRoadID pointing from the intersection. Panics if the intersection isn’t an endpoint.

pub(crate) fn create_lanes(
    &self,
    lane_specs_ltr: Vec<LaneSpec>,
    lane_id_counter: &mut usize
) -> Vec<Lane>

pub fn get_lanes_between(&self, l1: LaneID, l2: LaneID) -> Vec<LaneID>

Returns all lanes located between l1 and l2, exclusive.

pub fn high_stress_for_bikes(&self, map: &Map) -> bool

A simple classification of if the road is stressful or not for cycling. Arterial roads without a bike lane match this. Why arterial, instead of looking at speed limits? Even on arterial roads with official speed limits lowered, in practice vehicles still travel at the speed suggested by the design of the road.

impl Road

pub(crate) fn children_forwards(&self) -> Vec<(LaneID, LaneType)>

These are ordered from closest to center lane (left-most when driving on the right) to farthest (sidewalk)

pub(crate) fn children_backwards(&self) -> Vec<(LaneID, LaneType)>

pub(crate) fn children(&self, dir: Direction) -> Vec<(LaneID, LaneType)>

pub(crate) fn incoming_lanes(
    &self,
    i: IntersectionID
) -> Vec<(LaneID, LaneType)>

Returns lanes from the “center” going out

pub(crate) fn outgoing_lanes(
    &self,
    i: IntersectionID
) -> Vec<(LaneID, LaneType)>

Returns lanes from the “center” going out

Trait Implementations

impl Clone for Road

fn clone(&self) -> Road

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Road

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Road

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for Road

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.