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
116
117
118
119
120

use serde::{Deserialize, Serialize};

use abstio::{CityName, MapName};
use abstutil::Timer;
use geom::{GPSBounds, LonLat, Polygon, Ring};

use crate::{AreaType, Map};

// Hand-tuned. I think this is in units of meters?
const POLYGON_EPSILON: f64 = 1000.0;

/// A single city (like Seattle) can be broken down into multiple boundary polygons (udistrict,
/// ballard, downtown, etc). The load map screen uses this struct to display the entire city.
#[derive(Serialize, Deserialize)]
pub struct City {
    pub name: CityName,
    pub boundary: Polygon,
    pub areas: Vec<(AreaType, Polygon)>,
    /// The individual maps
    pub districts: Vec<(MapName, Polygon)>,
    // TODO Move nice_map_name from game into here?
}

impl City {
    /// If there's a single map covering all the smaller maps, use this.
    pub fn from_huge_map(huge_map: &Map) -> City {
        let city_name = huge_map.get_city_name().clone();
        let mut districts = abstio::list_dir(format!(
            "importer/config/{}/{}",
            city_name.country, city_name.city
        ))
        .into_iter()
        .filter(|path| path.ends_with(".poly"))
        .map(|path| {
            let pts = LonLat::read_osmosis_polygon(&path).unwrap();
            (
                MapName::from_city(&city_name, &abstutil::basename(path)),
                Ring::must_new(huge_map.get_gps_bounds().convert(&pts)).into_polygon(),
            )
        })
        .collect::<Vec<_>>();
        // Just a sort of z-ordering hack so that the largest encompassing district isn't first
        // later in the UI picker.
        districts.sort_by_key(|(_, poly)| poly.get_bounds().width() as usize);

        City {
            name: city_name,
            boundary: huge_map.get_boundary_polygon().clone(),
            areas: huge_map
                .all_areas()
                .iter()
                .map(|a| (a.area_type, a.polygon.simplify(POLYGON_EPSILON)))
                .collect(),
            districts,
        }
    }

    /// Generate a city from a bunch of smaller, individual maps. The boundaries of those maps
    /// may overlap and may have gaps between them.
    pub fn from_individual_maps(city_name: &CityName, timer: &mut Timer) -> City {
        let boundary_per_district: Vec<(MapName, Vec<LonLat>)> = abstio::list_dir(format!(
            "importer/config/{}/{}",
            city_name.country, city_name.city
        ))
        .into_iter()
        .filter(|path| path.ends_with(".poly"))
        .map(|path| {
            (
                MapName::from_city(city_name, &abstutil::basename(&path)),
                LonLat::read_osmosis_polygon(&path).unwrap(),
            )
        })
        .collect();
        // Figure out the total bounds for all the maps
        let mut gps_bounds = GPSBounds::new();
        for (_, pts) in &boundary_per_district {
            for pt in pts {
                gps_bounds.update(*pt);
            }
        }
        let boundary = gps_bounds.to_bounds().get_rectangle();

        let mut districts = Vec::new();
        for (name, pts) in boundary_per_district {
            districts.push((
                name,
                Ring::must_new(gps_bounds.convert(&pts)).into_polygon(),
            ));
        }
        // Just a sort of z-ordering hack so that the largest encompassing district isn't first
        // later in the UI picker.
        districts.sort_by_key(|(_, poly)| poly.get_bounds().width() as usize);

        // Add areas from every map. It's fine if they partly overlap.
        let mut areas = Vec::new();
        for path in abstio::list_dir(abstio::path(format!(
            "system/{}/{}/maps",
            city_name.country, city_name.city
        ))) {
            let map = Map::load_synchronously(path, timer);
            for area in map.all_areas() {
                let pts = map.gps_bounds.convert_back(area.polygon.points());
                // TODO Holes in the polygons get lost
                if let Ok(ring) = Ring::new(gps_bounds.convert(&pts)) {
                    areas.push((
                        area.area_type,
                        ring.into_polygon().simplify(POLYGON_EPSILON),
                    ));
                }
            }
        }

        City {
            name: city_name.clone(),
            boundary,
            areas,
            districts,
        }
    }
}