Struct map_model::raw::RawMap

pub struct RawMap {
    pub name: MapName,
    pub roads: BTreeMap<OriginalRoad, RawRoad>,
    pub intersections: BTreeMap<NodeID, RawIntersection>,
    pub buildings: BTreeMap<OsmID, RawBuilding>,
    pub bus_routes: Vec<RawBusRoute>,
    pub areas: Vec<RawArea>,
    pub parking_lots: Vec<RawParkingLot>,
    pub parking_aisles: Vec<(WayID, Vec<Pt2D>)>,
    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>

bus_routes: Vec<RawBusRoute>

areas: Vec<RawArea>

parking_lots: Vec<RawParkingLot>

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

boundary_polygon: Polygon

gps_bounds: GPSBounds

config: MapConfig

Implementations

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: OriginalRoad) -> Option<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>

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

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

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

Look for short roads that should be merged, and mark them as junction=intersection.

pub fn run_all_simplifications(
    &mut self,
    consolidate_all_intersections: 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.

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.