editoast: osm-to-railjson: read operational points (stations)

Author: Tristramg

editoast/src/converters/osm_to_railjson.rs

@@ -68,13 +68,14 @@ pub fn parse_osm(osm_pbf_in: PathBuf) -> Result<RailJson, Box<dyn Error + Send +
     }
 
     let nodes_tracks = NodeToTrack::from_edges(&edges);
-    let signals = signals(osm_pbf_in, &nodes_tracks, &adjacencies);
+    let signals = signals(&osm_pbf_in, &nodes_tracks, &adjacencies);
     let mut railjson = RailJson {
         switch_types: default_switch_types(),
         detectors: signals.iter().map(detector).collect(),
         signals,
         speed_sections: rail_edges.clone().flat_map(speed_sections).collect(),
         catenaries: rail_edges.clone().flat_map(catenaries).collect(),
+        operational_points: operational_points(&osm_pbf_in, &nodes_tracks),
         ..Default::default()
     };
 
@@ -261,4 +262,15 @@ mod tests {
         assert_eq!(1, rj.catenaries.len());
         assert_eq!("15000", rj.catenaries[0].voltage);
     }
+
+    #[test]
+    fn parse_stations() {
+        let rj = parse_osm("src/tests/station.osm.pbf".into()).unwrap();
+        assert_eq!(1, rj.operational_points.len());
+        let op = &rj.operational_points[0];
+        assert_eq!(2, op.parts.len());
+        let ext = op.extensions.identifier.as_ref().unwrap();
+        assert_eq!("atlantis", ext.name);
+        assert_eq!(1234, ext.uic);
+    }
 }

editoast/src/converters/utils.rs

@@ -277,7 +277,7 @@ impl<'a> NodeToTrack<'a> {
 }
 
 pub fn signals(
-    osm_pbf_in: std::path::PathBuf,
+    osm_pbf_in: &std::path::PathBuf,
     nodes_to_tracks: &NodeToTrack,
     adjacencies: &HashMap<osm4routing::NodeId, NodeAdjacencies>,
 ) -> Vec<Signal> {
@@ -456,6 +456,69 @@ pub fn catenaries(edge: &Edge) -> Option<Catenary> {
     })
 }
 
+pub fn operational_points(
+    osm_pbf_in: &std::path::PathBuf,
+    nodes_to_tracks: &NodeToTrack,
+) -> Vec<OperationalPoint> {
+    let file = std::fs::File::open(osm_pbf_in).unwrap();
+    let mut pbf = osmpbfreader::OsmPbfReader::new(file);
+    pbf.iter()
+        .flatten()
+        .filter(|obj| obj.tags().contains("public_transport", "stop_area")) // https://wiki.openstreetmap.org/wiki/Tag:public_transport%3Dstop_area
+        .flat_map(|obj| match obj {
+            osmpbfreader::OsmObj::Relation(rel) => Some(rel), // Only consider OSM relations
+            _ => None,                                        // Discard Nodes and Ways
+        })
+        .map(|rel| {
+            let parts = rel
+                .refs
+                .iter()
+                .filter(|r| r.role == "stop") // We ignore other members of the relation
+                .flat_map(|r| match r.member {
+                    osmpbfreader::OsmId::Node(id) => Some(id),
+                    _ => {
+                        warn!("OpenStreetMap relation ({}) has a member ({:?}) with role `stop` that isn’t a node", rel.id.0, r.member);
+                        None
+                    },
+                })
+                .flat_map(|node| {
+                    nodes_to_tracks
+                        .track_and_position(node)
+                        .map(|(track, position)| OperationalPointPart { track, position })
+                })
+                .collect();
+
+            OperationalPoint {
+                id: rel.id.0.to_string().into(),
+                parts,
+                extensions: OperationalPointExtensions {
+                    identifier: identifier(&rel.tags),
+                    sncf: None,
+                },
+            }
+        })
+        .collect()
+}
+
+fn identifier(tags: &osmpbfreader::Tags) -> Option<OperationalPointIdentifierExtension> {
+    let uic = tags
+        .get("uic_ref")
+        .and_then(|uic| match i64::from_str(uic.as_str()) {
+            Ok(uic) => Some(uic),
+            Err(_) => {
+                warn!("Could not parse {uic} uic code as integer");
+                None
+            }
+        })
+        .unwrap_or_default();
+
+    tags.get("name")
+        .map(|name| OperationalPointIdentifierExtension {
+            name: name.as_str().into(),
+            uic,
+        })
+}
+
 #[cfg(test)]
 mod tests {
     use osm4routing::Coord;

editoast/src/schema/mod.rs

@@ -26,7 +26,10 @@ pub use detector::{Detector, DetectorCache};
 use enum_map::Enum;
 pub use errors::{InfraError, InfraErrorType};
 pub use geo_json::GeoJson;
-pub use operational_point::{OperationalPoint, OperationalPointCache, OperationalPointPart};
+pub use operational_point::{
+    OperationalPoint, OperationalPointCache, OperationalPointExtensions,
+    OperationalPointIdentifierExtension, OperationalPointPart,
+};
 pub use railjson::{find_objects, RailJson, RailjsonError};
 pub use route::Route;
 use serde::{Deserialize, Serialize};