Struct raw_map::RawMap

pub struct RawMap {
    pub name: MapName,
    pub roads: BTreeMap<OriginalRoad, RawRoad>,
    pub intersections: BTreeMap<NodeID, RawIntersection>,
    pub buildings: BTreeMap<OsmID, RawBuilding>,
    pub areas: Vec<RawArea>,
    pub parking_lots: Vec<RawParkingLot>,
    pub parking_aisles: Vec<(WayID, Vec<Pt2D>)>,
    pub transit_routes: Vec<RawTransitRoute>,
    pub transit_stops: BTreeMap<String, RawTransitStop>,
    pub boundary_polygon: Polygon,
    pub gps_bounds: GPSBounds,
    pub config: MapConfig,
}

Fields

name: MapName

roads: BTreeMap<OriginalRoad, RawRoad>

intersections: BTreeMap<NodeID, RawIntersection>

buildings: BTreeMap<OsmID, RawBuilding>

areas: Vec<RawArea>

parking_lots: Vec<RawParkingLot>

parking_aisles: Vec<(WayID, Vec<Pt2D>)>

transit_routes: Vec<RawTransitRoute>

transit_stops: BTreeMap<String, RawTransitStop>

boundary_polygon: Polygon

gps_bounds: GPSBounds

config: MapConfig

Implementations

impl RawMap

pub fn save_to_geojson(
    &self,
    output_path: String,
    timer: &mut Timer<'_>
) -> Result<()>

Assumes run_all_simplifications has been called if desired

impl RawMap

fn mark_short_roads(&mut self, list: Vec<OriginalRoad>) -> Vec<OriginalRoad>

pub fn find_traffic_signal_clusters(&mut self) -> Vec<OriginalRoad>

A heuristic to find short roads near traffic signals

pub fn find_dog_legs(&mut self) -> Vec<OriginalRoad>

A heuristic to find short roads in places that would otherwise be a normal four-way intersection

      |
      |
---X~~X----
   |
   |

The ~~ is the short road we want to detect

impl RawMap

pub fn merge_short_road(
    &mut self,
    short: OriginalRoad
) -> Result<(NodeID, NodeID, Vec<OriginalRoad>, Vec<OriginalRoad>)>

Returns (the surviving intersection, the deleted intersection, deleted roads, new roads)

impl RawMap

pub fn run_all_simplifications(
    &mut self,
    consolidate_all_intersections: bool,
    remove_disconnected: bool,
    timer: &mut Timer<'_>
)

Run a sequence of transformations to the RawMap before converting it to a full Map.

We don’t want to run these during the OSM->RawMap import stage, because we want to use the map_editor tool to debug the RawMap.

impl RawMap

pub fn blank(name: MapName) -> RawMap

pub fn roads_per_intersection(&self, i: NodeID) -> Vec<OriginalRoad>

pub fn new_osm_node_id(&self, start: i64) -> NodeID

pub fn new_osm_way_id(&self, start: i64) -> WayID

pub fn preview_intersection(
    &self,
    id: NodeID
) -> Result<(Polygon, Vec<Polygon>, Vec<(String, Polygon)>)>

(Intersection polygon, polygons for roads, list of labeled polygons to debug)

pub fn trimmed_road_geometry(&self, road_id: OriginalRoad) -> Result<PolyLine>

Generate the trimmed PolyLine for a single RawRoad by calculating both intersections

pub fn save(&self)

pub fn get_city_name(&self) -> &CityName

impl RawMap

pub fn can_delete_intersection(&self, i: NodeID) -> bool

pub fn delete_intersection(&mut self, id: NodeID)

pub fn move_intersection(
    &mut self,
    id: NodeID,
    point: Pt2D
) -> Option<Vec<OriginalRoad>>

pub fn closest_intersection(&self, pt: Pt2D) -> NodeID

pub fn path_dist_to(&self, from: NodeID, to: NodeID) -> Option<Distance>

Trait Implementations

impl Debug for RawMap

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RawMap

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

Deserialize this value from the given Serde deserializer.

impl Serialize for RawMap

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

Serialize this value into the given Serde serializer.