Struct importer::generic::GenericCityImporter

pub struct GenericCityImporter {
    pub osm_url: String,
    pub map_config: MapConfig,
    pub onstreet_parking: OnstreetParking,
    pub public_offstreet_parking: PublicOffstreetParking,
    pub private_offstreet_parking: PrivateOffstreetParking,
    pub elevation: Option<String>,
    pub include_railroads: bool,
    pub extra_buildings: Option<String>,
}

Importing a new city can be done just by filling out this config file and specifying some polygon boundaries. Most fields are directly from convert_osm::Options.

If any extra data is imported for a city (like collisions or population), then for now, don't use this.

Fields

osm_url: String

The URL to a .osm or .osm.pbf file containing the entire city. http://download.geofabrik.de/ is recommended.

You can also put a path like input/us/seattle/osm/washington-latest.osm.pbf in here, and instead that file will be used. This is kind of a hack, because it'll assume the cities are imported in the proper order, but it prevents having to download duplicate large files.

map_config: MapConfig

onstreet_parking: OnstreetParking

public_offstreet_parking: PublicOffstreetParking

private_offstreet_parking: PrivateOffstreetParking

elevation: Option<String>

If provided, pull elevation data from this SRTM file. The SRTM parser is incorrect, so the results will be nonsense.

include_railroads: bool

OSM railway=rail will be included as light rail if so. Cosmetic only.

extra_buildings: Option<String>

If provided, read polygons from this GeoJSON file and add them to the RawMap as buildings.

Implementations

impl GenericCityImporter

pub fn osm_to_raw(
    &self,
    name: MapName,
    timer: &mut Timer<'_>,
    config: &ImporterConfiguration
) -> RawMap

Trait Implementations

impl<'de> Deserialize<'de> for GenericCityImporter

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

Deserialize this value from the given Serde deserializer.

impl Serialize for GenericCityImporter

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

Serialize this value into the given Serde serializer.