Struct map_model::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_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 trace_around_block(
    &self,
    map: &Map
) -> Option<(Polygon, BTreeSet<LaneID>)>

Starting from this lane, follow the lane’s left edge to the intersection, continuing to “walk around the block” until we reach the starting point. This only makes sense for the outermost lanes on a road. Returns the polygon and all visited lanes.

TODO This process currently fails for some starting positions; orienting is weird.

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.