Struct map_model::Map

pub struct Map {

    pub(crate) roads: Vec<Road>,
    pub(crate) intersections: Vec<Intersection>,
    pub(crate) buildings: Vec<Building>,
    pub(crate) transit_stops: BTreeMap<TransitStopID, TransitStop>,
    pub(crate) transit_routes: Vec<TransitRoute>,
    pub(crate) areas: Vec<Area>,
    pub(crate) parking_lots: Vec<ParkingLot>,
    pub(crate) boundary_polygon: Polygon,
    pub(crate) stop_signs: BTreeMap<IntersectionID, ControlStopSign>,
    pub(crate) traffic_signals: BTreeMap<IntersectionID, ControlTrafficSignal>,
    pub(crate) gps_bounds: GPSBounds,
    pub(crate) bounds: Bounds,
    pub(crate) config: MapConfig,
    pub(crate) pathfinder: Pathfinder,
    pub(crate) pathfinder_dirty: bool,
    pub(crate) routing_params: RoutingParams,
    pub(crate) zones: Vec<Zone>,
    pub(crate) name: MapName,
    pub(crate) edits: MapEdits,
    pub(crate) edits_generation: usize,
    pub(crate) road_to_buildings: MultiMap<RoadID, BuildingID>,
}

Fields

roads: Vec<Road>

intersections: Vec<Intersection>

buildings: Vec<Building>

transit_stops: BTreeMap<TransitStopID, TransitStop>

transit_routes: Vec<TransitRoute>

areas: Vec<Area>

parking_lots: Vec<ParkingLot>

boundary_polygon: Polygon

stop_signs: BTreeMap<IntersectionID, ControlStopSign>

traffic_signals: BTreeMap<IntersectionID, ControlTrafficSignal>

gps_bounds: GPSBounds

bounds: Bounds

config: MapConfig

pathfinder: Pathfinder

pathfinder_dirty: bool

routing_params: RoutingParams

zones: Vec<Zone>

name: MapName

edits: MapEdits

edits_generation: usize

road_to_buildings: MultiMap<RoadID, BuildingID>

Implementations

impl Map

pub fn new_edits(&self) -> MapEdits

pub fn get_edits(&self) -> &MapEdits

pub fn unsaved_edits(&self) -> bool

pub fn get_r_edit(&self, r: RoadID) -> EditRoad

pub fn edit_road_cmd<F: Fn(&mut EditRoad)>(&self, r: RoadID, f: F) -> EditCmd

pub fn get_i_edit(&self, i: IntersectionID) -> EditIntersection

Panics on borders

pub fn save_edits(&self)

pub fn must_apply_edits(
    &mut self,
    new_edits: MapEdits,
    timer: &mut Timer<'_>
) -> EditEffects

Returns (changed_roads, deleted_lanes, deleted_turns, added_turns, changed_intersections)

pub fn try_apply_edits(&mut self, new_edits: MapEdits, timer: &mut Timer<'_>)

fn apply_edits(
    &mut self,
    new_edits: MapEdits,
    enforce_valid: bool,
    timer: &mut Timer<'_>
) -> EditEffects

pub fn recalculate_pathfinding_after_edits(&mut self, timer: &mut Timer<'_>)

This can expensive, so don’t constantly do it while editing in the UI. But this must happen before the simulation resumes.

pub fn incremental_edit_traffic_signal(&mut self, signal: ControlTrafficSignal)

Since the player is in the middle of editing, the signal may not be valid. Don’t go through the entire apply_edits flow.

pub fn get_edits_change_key(&self) -> usize

If you need to regenerate anything when the map is edited, use this key to detect edits.

impl Map

pub fn create_from_raw(
    raw: RawMap,
    opts: RawToMapOptions,
    timer: &mut Timer<'_>
) -> Map

impl Map

pub fn load_synchronously(path: String, timer: &mut Timer<'_>) -> Map

Load a map from a local serialized Map or RawMap. Note this won’t work on web. This should only be used by non-UI tools.

pub fn map_loaded_directly(&mut self, timer: &mut Timer<'_>)

After deserializing a map directly, call this after.

pub fn blank() -> Map

Just for temporary std::mem::replace tricks.

pub fn all_roads(&self) -> &Vec<Road>

pub fn all_lanes(&self) -> impl Iterator<Item = &Lane>

pub fn all_intersections(&self) -> &Vec<Intersection>

pub fn all_turns(&self) -> impl Iterator<Item = &Turn>

pub fn all_buildings(&self) -> &Vec<Building>

pub fn all_areas(&self) -> &Vec<Area>

pub fn all_parking_lots(&self) -> &Vec<ParkingLot>

pub fn all_zones(&self) -> &Vec<Zone>

pub fn maybe_get_r(&self, id: RoadID) -> Option<&Road>

pub fn maybe_get_l(&self, id: LaneID) -> Option<&Lane>

pub fn maybe_get_i(&self, id: IntersectionID) -> Option<&Intersection>

pub fn maybe_get_t(&self, id: TurnID) -> Option<&Turn>

pub fn maybe_get_b(&self, id: BuildingID) -> Option<&Building>

pub fn maybe_get_pl(&self, id: ParkingLotID) -> Option<&ParkingLot>

pub fn maybe_get_a(&self, id: AreaID) -> Option<&Area>

pub fn maybe_get_ts(&self, id: TransitStopID) -> Option<&TransitStop>

pub fn maybe_get_stop_sign(
    &self,
    id: IntersectionID
) -> Option<&ControlStopSign>

pub fn maybe_get_traffic_signal(
    &self,
    id: IntersectionID
) -> Option<&ControlTrafficSignal>

pub fn maybe_get_tr(&self, route: TransitRouteID) -> Option<&TransitRoute>

pub fn get_r(&self, id: RoadID) -> &Road

pub fn get_l(&self, id: LaneID) -> &Lane

pub(crate) fn mut_lane(&mut self, id: LaneID) -> &mut Lane

pub(crate) fn mut_road(&mut self, id: RoadID) -> &mut Road

pub fn get_i(&self, id: IntersectionID) -> &Intersection

pub fn get_t(&self, id: TurnID) -> &Turn

pub fn get_b(&self, id: BuildingID) -> &Building

pub fn get_a(&self, id: AreaID) -> &Area

pub fn get_pl(&self, id: ParkingLotID) -> &ParkingLot

pub fn get_stop_sign(&self, id: IntersectionID) -> &ControlStopSign

pub fn get_traffic_signal(&self, id: IntersectionID) -> &ControlTrafficSignal

pub fn get_turns_from_lane(&self, l: LaneID) -> Vec<&Turn>

The turns may belong to two different intersections!

pub fn get_turns_to_lane(&self, l: LaneID) -> Vec<&Turn>

pub fn get_turn_between(
    &self,
    from: LaneID,
    to: LaneID,
    parent: IntersectionID
) -> Option<&Turn>

pub fn get_next_turns_and_lanes(&self, from: LaneID) -> Vec<(&Turn, &Lane)>

pub fn get_next_turns_and_lanes_for(
    &self,
    from: LaneID,
    constraints: PathConstraints
) -> Vec<(&Turn, &Lane)>

pub fn get_turns_for(
    &self,
    from: LaneID,
    constraints: PathConstraints
) -> Vec<&Turn>

pub fn get_movements_for(
    &self,
    from: DirectedRoadID,
    constraints: PathConstraints
) -> Vec<MovementID>

Find all movements from one road to another that’re usable by someone.

pub fn get_next_roads(&self, from: RoadID) -> BTreeSet<RoadID>

pub fn get_parent(&self, id: LaneID) -> &Road

pub fn get_gps_bounds(&self) -> &GPSBounds

pub fn get_bounds(&self) -> &Bounds

pub fn get_city_name(&self) -> &CityName

pub fn get_name(&self) -> &MapName

pub fn all_transit_stops(&self) -> &BTreeMap<TransitStopID, TransitStop>

pub fn get_ts(&self, stop: TransitStopID) -> &TransitStop

pub fn get_tr(&self, route: TransitRouteID) -> &TransitRoute

pub fn all_transit_routes(&self) -> &Vec<TransitRoute>

pub fn get_transit_route(&self, name: &str) -> Option<&TransitRoute>

pub fn get_routes_serving_stop(&self, stop: TransitStopID) -> Vec<&TransitRoute>

pub fn building_to_road(&self, id: BuildingID) -> &Road

pub fn all_incoming_borders(&self) -> Vec<&Intersection>

This and all_outgoing_borders are expensive to constantly repeat

pub fn all_outgoing_borders(&self) -> Vec<&Intersection>

pub fn save(&self)

pub fn find_driving_lane_near_building(&self, b: BuildingID) -> LaneID

Cars trying to park near this building should head for the driving lane returned here, then start their search. Some parking lanes are connected to driving lanes that’re “parking blackholes” – if there are no free spots on that lane, then the roads force cars to a border.

pub fn get_boundary_polygon(&self) -> &Polygon

pub fn pathfind(&self, req: PathRequest) -> Result<Path>

pub fn pathfind_with_params(
    &self,
    req: PathRequest,
    params: &RoutingParams,
    cache_custom: PathfinderCaching
) -> Result<Path>

pub fn pathfind_v2(&self, req: PathRequest) -> Result<PathV2>

pub fn pathfind_v2_with_params(
    &self,
    req: PathRequest,
    params: &RoutingParams,
    cache_custom: PathfinderCaching
) -> Result<PathV2>

pub fn should_use_transit(
    &self,
    start: Position,
    end: Position
) -> Option<(TransitStopID, Option<TransitStopID>, TransitRouteID)>

pub fn clear_custom_pathfinder_cache(&self)

Clear any pathfinders with custom RoutingParams, created previously with cache_custom

pub fn all_costs_from(
    &self,
    req: PathRequest
) -> Option<(Duration, HashMap<DirectedRoadID, Duration>)>

Return the cost of a single path, and also a mapping from every directed road to the cost of getting there from the same start. This can be used to understand why an alternative route wasn’t chosen.

pub fn get_movement_for_traffic_signal(
    &self,
    t: TurnID
) -> Option<(MovementID, CompressedMovementID)>

None for SharedSidewalkCorners and turns not belonging to traffic signals

pub fn find_r_by_osm_id(&self, id: OriginalRoad) -> Result<RoadID>

pub fn find_i_by_osm_id(&self, id: NodeID) -> Result<IntersectionID>

pub fn find_b_by_osm_id(&self, id: OsmID) -> Option<BuildingID>

pub fn find_tr_by_gtfs(&self, gtfs_id: &str) -> Option<TransitRouteID>

pub fn hack_override_offstreet_spots(&mut self, spots_per_bldg: usize)

pub fn hack_override_offstreet_spots_individ(
    &mut self,
    b: BuildingID,
    spots: usize
)

pub fn hack_override_bldg_type(
    &mut self,
    b: BuildingID,
    bldg_type: BuildingType
)

pub fn hack_override_orig_spawn_times(
    &mut self,
    br: TransitRouteID,
    times: Vec<Time>
)

pub fn hack_add_area(
    &mut self,
    area_type: AreaType,
    polygon: Polygon,
    osm_tags: Tags
)

pub fn hack_override_routing_params(
    &mut self,
    routing_params: RoutingParams,
    timer: &mut Timer<'_>
)

pub fn keep_pathfinder_despite_edits(&mut self)

Normally after applying edits, you must call recalculate_pathfinding_after_edits. Alternatively, you can keep the old pathfinder exactly as it is. Use with caution – the pathfinder and the map may be out-of-sync in arbitrary ways.

pub fn get_languages(&self) -> BTreeSet<String>

pub fn get_config(&self) -> &MapConfig

pub fn simple_path_btwn(
    &self,
    i1: IntersectionID,
    i2: IntersectionID
) -> Option<(Vec<RoadID>, Vec<IntersectionID>)>

Simple search along undirected roads. Expresses the result as a sequence of roads and a sequence of intersections.

pub fn simple_path_btwn_v2(
    &self,
    i1: IntersectionID,
    i2: IntersectionID,
    constraints: PathConstraints
) -> Option<(Vec<RoadID>, Vec<IntersectionID>)>

Simple search along directed roads, weighted by distance. Expresses the result as a sequence of roads and a sequence of intersections.

Unlike the main pathfinding methods, this starts and ends at intersections. The first and last step can be on any road connected to the intersection.

pub fn routing_params(&self) -> &RoutingParams

Returns the routing params baked into the map.

pub fn road_to_buildings(&self, r: RoadID) -> &BTreeSet<BuildingID>

pub(crate) fn recalculate_road_to_buildings(&mut self)

pub(crate) fn recalculate_all_movements(&mut self, timer: &mut Timer<'_>)

pub fn find_road_between(
    &self,
    i1: IntersectionID,
    i2: IntersectionID
) -> Option<RoadID>

Finds the road directly connecting two intersections.

pub fn max_elevation(&self) -> Distance

Returns the highest elevation in the map

pub fn is_unprotected_turn(
    &self,
    from: RoadID,
    to: RoadID,
    turn_type: TurnType
) -> bool

Does a turn at a stop sign go from a smaller to a larger road? (Note this doesn’t look at unprotected movements in traffic signals, since we don’t yet have good heuristics for when those exist)

pub fn minify(&mut self, timer: &mut Timer<'_>)

Modifies the map in-place, removing parts not essential for the bike network tool.

pub fn minify_buildings(&mut self, timer: &mut Timer<'_>)

Modifies the map in-place, removing buildings.

Trait Implementations

impl Clone for Map

fn clone(&self) -> Map

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for Map

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

Deserialize this value from the given Serde deserializer.

impl Serialize for Map

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

Serialize this value into the given Serde serializer.