Struct map_model::Lane

pub struct Lane {
    pub id: LaneID,
    pub parent: RoadID,
    pub lane_type: LaneType,
    pub lane_center_pts: PolyLine,
    pub width: Distance,
    pub src_i: IntersectionID,
    pub dst_i: IntersectionID,
    pub bus_stops: BTreeSet<BusStopID>,
    pub driving_blackhole: bool,
    pub biking_blackhole: bool,
}

A road segment is broken down into individual lanes, which have a LaneType.

Fields

id: LaneID

parent: RoadID

lane_type: LaneType

lane_center_pts: PolyLine

width: Distance

src_i: IntersectionID

dst_i: IntersectionID

bus_stops: BTreeSet<BusStopID>

Meaningless order

driving_blackhole: bool

{Cars, bikes} trying to start or end here might not be able to reach most lanes in the graph, because this is near a border.

biking_blackhole: bool

Implementations

impl Lane

pub fn first_pt(&self) -> Pt2D

pub fn last_pt(&self) -> Pt2D

pub fn first_line(&self) -> Line

pub fn last_line(&self) -> Line

pub fn endpoint(&self, i: IntersectionID) -> Pt2D

pub fn end_line(&self, i: IntersectionID) -> Line

pt2 will be endpoint

pub fn dist_along_of_point(&self, pt: Pt2D) -> Option<Distance>

pub fn length(&self) -> Distance

pub fn intersections(&self) -> Vec<IntersectionID>

pub fn number_parking_spots(&self) -> usize

pub fn is_driving(&self) -> bool

pub fn is_biking(&self) -> bool

pub fn is_bus(&self) -> bool

pub fn is_walkable(&self) -> bool

pub fn is_sidewalk(&self) -> bool

pub fn is_shoulder(&self) -> bool

pub fn is_parking(&self) -> bool

pub fn is_light_rail(&self) -> bool

pub(crate) fn get_directed_parent(&self, map: &Map) -> DirectedRoadID

pub fn get_turn_restrictions(&self, road: &Road) -> Option<BTreeSet<TurnType>>

Trait Implementations

impl Debug for Lane

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Lane

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

Deserialize this value from the given Serde deserializer.

impl Serialize for Lane

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

Serialize this value into the given Serde serializer.