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,
    timer: &mut Timer<'_>
) -> (Polygon, Vec<Polygon>, Vec<(String, Polygon)>)

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

pub fn save(&self)

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)

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.