1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use geom::{LonLat, Pt2D};
use map_model::osm::RoadRank;
use map_model::{Intersection, IntersectionID, Map, PathConstraints};

use crate::TripMode;

/// Lists all border intersections of the map, broken down by mode and whether they support
/// incoming or outgoing traffic.
#[derive(Clone)]
pub struct MapBorders {
    pub incoming_walking: Vec<MapBorder>,
    pub incoming_driving: Vec<MapBorder>,
    pub incoming_biking: Vec<MapBorder>,
    pub outgoing_walking: Vec<MapBorder>,
    pub outgoing_driving: Vec<MapBorder>,
    pub outgoing_biking: Vec<MapBorder>,
}

#[derive(Clone)]
pub struct MapBorder {
    pub i: IntersectionID,
    pub pos: Pt2D,
    pub gps_pos: LonLat,
    /// Based on the classification of the connecting road, a weight for how likely this border is
    /// to be used for traffic.
    pub weight: usize,
}

impl MapBorders {
    pub fn new(map: &Map) -> MapBorders {
        let incoming_walking = map
            .all_incoming_borders()
            .into_iter()
            .filter(|i| {
                !i.get_outgoing_lanes(map, PathConstraints::Pedestrian)
                    .is_empty()
            })
            .map(|i| MapBorder::new(map, i))
            .collect::<Vec<_>>();
        let incoming_driving = map
            .all_incoming_borders()
            .into_iter()
            .filter(|i| !i.get_outgoing_lanes(map, PathConstraints::Car).is_empty())
            .map(|i| MapBorder::new(map, i))
            .collect::<Vec<_>>();
        let incoming_biking = map
            .all_incoming_borders()
            .into_iter()
            .filter(|i| !i.get_outgoing_lanes(map, PathConstraints::Bike).is_empty())
            .map(|i| MapBorder::new(map, i))
            .collect::<Vec<_>>();
        let outgoing_walking = map
            .all_outgoing_borders()
            .into_iter()
            .filter(|i| {
                !i.get_incoming_lanes(map, PathConstraints::Pedestrian)
                    .is_empty()
            })
            .map(|i| MapBorder::new(map, i))
            .collect::<Vec<_>>();
        let outgoing_driving = map
            .all_outgoing_borders()
            .into_iter()
            .filter(|i| !i.get_incoming_lanes(map, PathConstraints::Car).is_empty())
            .map(|i| MapBorder::new(map, i))
            .collect::<Vec<_>>();
        let outgoing_biking = map
            .all_outgoing_borders()
            .into_iter()
            .filter(|i| !i.get_incoming_lanes(map, PathConstraints::Bike).is_empty())
            .map(|i| MapBorder::new(map, i))
            .collect::<Vec<_>>();
        MapBorders {
            incoming_walking,
            incoming_driving,
            incoming_biking,
            outgoing_walking,
            outgoing_driving,
            outgoing_biking,
        }
    }

    /// Returns the (incoming, outgoing) borders for the specififed mode.
    pub fn for_mode(&self, mode: TripMode) -> (&Vec<MapBorder>, &Vec<MapBorder>) {
        match mode {
            TripMode::Walk | TripMode::Transit => (&self.incoming_walking, &self.outgoing_walking),
            TripMode::Drive => (&self.incoming_driving, &self.outgoing_driving),
            TripMode::Bike => (&self.incoming_biking, &self.outgoing_biking),
        }
    }
}

impl MapBorder {
    fn new(map: &Map, i: &Intersection) -> Self {
        // TODO Mostly untuned, and agnostic to TripMode
        let road = map.get_r(*i.roads.iter().next().unwrap());
        let mut weight = match road.get_rank() {
            RoadRank::Local => 3,
            RoadRank::Arterial => 5,
            RoadRank::Highway => 8,
        };
        // TODO We should consider more values for RoadRank
        if road.is_service() {
            weight = 1;
        }

        let pos = i.polygon.center();
        Self {
            i: i.id,
            pos,
            gps_pos: pos.to_gps(map.get_gps_bounds()),
            weight,
        }
    }
}