Struct map_model::objects::lane::Lane

pub struct Lane {
    pub id: LaneID,
    pub lane_type: LaneType,
    pub lane_center_pts: PolyLine,
    pub width: Distance,
    pub dir: Direction,
    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

lane_type: LaneType

lane_center_pts: PolyLine

width: Distance

dir: Direction

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, cfg: &MapConfig) -> 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 fn get_directed_parent(&self) -> DirectedRoadID

pub fn get_nearest_side_of_road(&self, map: &Map) -> RoadSideID

This is just based on typical driving sides. Bidirectional or contraflow cycletracks as input may produce weird results.

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

Returns the set of allowed turn types, based on individual turn lane restrictions. None means all turn types are allowed.

This will return None for bus lanes, unless force_bus is true. OSM turn restrictions on bus lanes usually apply to regular vehicles, not the buses. When generating the turns for buses, we probably don’t want to use the restrictions.

pub fn common_endpt(&self, other: &Lane) -> Option<IntersectionID>

If the lanes share one endpoint, returns it. If they share two – because they belong to the same road or there are two different roads connecting the same pair of intersections – then return None. If they share no common endpoint, panic. (This is a weird API, really should be an enum with 3 cases)

pub fn get_thick_polygon(&self) -> Polygon

Trait Implementations

impl Clone for Lane

fn clone(&self) -> Lane

Returns a copy of the value.

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

Performs copy-assignment from source.

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.