Struct map_model::Intersection

pub struct Intersection {
    pub id: IntersectionID,
    pub polygon: Polygon,
    pub turns: Vec<Turn>,
    pub elevation: Distance,
    pub intersection_type: IntersectionType,
    pub orig_id: NodeID,
    pub incoming_lanes: Vec<LaneID>,
    pub outgoing_lanes: Vec<LaneID>,
    pub roads: BTreeSet<RoadID>,
    pub merged: bool,
}

An intersection connects roads. Most have >2 roads and are controlled by stop signs or traffic signals. Roads that lead to the boundary of the map end at border intersections, with only that one road attached.

Fields

id: IntersectionID

polygon: Polygon

This needs to be in clockwise orientation, or later rendering of sidewalk corners breaks.

turns: Vec<Turn>

elevation: Distance

intersection_type: IntersectionType

orig_id: NodeID

incoming_lanes: Vec<LaneID>

Note that a lane may belong to both incoming_lanes and outgoing_lanes.

outgoing_lanes: Vec<LaneID>

roads: BTreeSet<RoadID>

merged: bool

Was a short road adjacent to this intersection merged?

Implementations

impl Intersection

pub fn is_border(&self) -> bool

pub fn is_incoming_border(&self) -> bool

pub fn is_outgoing_border(&self) -> bool

pub fn is_closed(&self) -> bool

pub fn is_stop_sign(&self) -> bool

pub fn is_traffic_signal(&self) -> bool

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

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

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

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

pub fn get_incoming_lanes(
    &self,
    map: &Map,
    constraints: PathConstraints
) -> Vec<LaneID>

pub fn get_outgoing_lanes(
    &self,
    map: &Map,
    constraints: PathConstraints
) -> Vec<LaneID>

Strict for bikes. If there are bike lanes, not allowed to use other lanes.

pub fn get_zorder(&self, map: &Map) -> isize

pub fn get_rank(&self, map: &Map) -> RoadRank

pub fn get_roads_sorted_by_incoming_angle(
    &self,
    all_roads: &[Road]
) -> Vec<RoadID>

pub fn get_sorted_incoming_roads(&self, map: &Map) -> Vec<RoadID>

Return all incoming roads to an intersection, sorted by angle. This skips one-way roads outbound from the intersection, since no turns originate from those anyway. This allows heuristics for a 3-way intersection to not care if one of the roads happens to be a dual carriageway (split into two one-ways).

pub fn some_outgoing_road(&self, map: &Map) -> Option<DirectedRoadID>

pub fn some_incoming_road(&self, map: &Map) -> Option<DirectedRoadID>

pub fn name(&self, lang: Option<&String>, map: &Map) -> String

Trait Implementations

impl Clone for Intersection

fn clone(&self) -> Intersection

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Intersection

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Intersection

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

Deserialize this value from the given Serde deserializer.

impl Serialize for Intersection

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

Serialize this value into the given Serde serializer.