osm_to_railjson: fix missing local_track_name

editoast/osm_to_railjson/src/osm_to_railjson.rs

@@ -68,19 +68,8 @@ pub fn parse_osm(
         adjacencies.entry(edge.target).or_default().edges.push(edge);
     }
 
-    let nodes_tracks = NodeToTrack::from_edges(&edges);
-    let signals = signals(&osm_pbf_in, &nodes_tracks, &adjacencies);
-    let mut railjson = RailJson {
-        extended_switch_types: vec![],
-        detectors: signals.iter().map(detector).collect(),
-        signals,
-        speed_sections: rail_edges.clone().flat_map(speed_sections).collect(),
-        electrifications: rail_edges.clone().flat_map(electrifications).collect(),
-        operational_points: operational_points(&osm_pbf_in, &nodes_tracks),
-        ..Default::default()
-    };
-
-    railjson.track_sections = rail_edges
+    let track_sections: Vec<TrackSection> = rail_edges
+        .clone()
         .map(|e| {
             let geo = geos::geojson::Geometry::new(geos::geojson::Value::LineString(
                 e.geometry.iter().map(|c| vec![c.x, c.y]).collect(),
@@ -114,6 +103,19 @@ pub fn parse_osm(
         })
         .collect();
 
+    let nodes_tracks = NodeToTrack::from_edges(&edges);
+    let signals = signals(&osm_pbf_in, &nodes_tracks, &adjacencies);
+    let mut railjson = RailJson {
+        extended_switch_types: vec![],
+        detectors: signals.iter().map(detector).collect(),
+        signals,
+        speed_sections: rail_edges.clone().flat_map(speed_sections).collect(),
+        electrifications: rail_edges.clone().flat_map(electrifications).collect(),
+        operational_points: operational_points(&osm_pbf_in, &nodes_tracks, &track_sections),
+        track_sections,
+        ..Default::default()
+    };
+
     for (node, mut adj) in adjacencies {
         for e1 in &adj.edges {
             for e2 in &adj.edges {

editoast/osm_to_railjson/src/utils.rs

@@ -25,9 +25,11 @@ use schemas::infra::Speed;
 use schemas::infra::SpeedSection;
 use schemas::infra::Switch;
 use schemas::infra::TrackEndpoint;
+use schemas::infra::TrackSection;
 use schemas::primitives::Identifier;
 use schemas::primitives::NonBlankString;
 use std::collections::HashMap;
+use std::collections::HashSet;
 use std::str::FromStr;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
@@ -461,9 +463,32 @@ fn map_node_id_to_node(
         .collect()
 }
 
+/// Generate unique `local_track_names` for each `operational_point_parts`.
+fn generate_local_track_name(parts: &mut [OperationalPointPart]) {
+    let mut used_name: HashSet<NonBlankString> = parts
+        .iter()
+        .map(|part| part.local_track_name.clone())
+        .collect();
+    parts
+        .iter_mut()
+        .filter(|part| { part.local_track_name == "unknown".into()})
+        .for_each(|part| {
+            let mut track_number = 1;
+            part.local_track_name = loop {
+                let name = NonBlankString::from(track_number.to_string());
+                if !used_name.contains(&name) {
+                    used_name.insert(name.clone());
+                    break name;
+                }
+                track_number += 1;
+            };
+        });
+}
+
 pub fn operational_points(
     osm_pbf_in: &std::path::PathBuf,
     nodes_to_tracks: &NodeToTrack,
+    track_sections: &[TrackSection],
 ) -> Vec<OperationalPoint> {
     let file = std::fs::File::open(osm_pbf_in).unwrap();
     let mut pbf: OsmPbfReader<std::fs::File> = osm4routing::osmpbfreader::OsmPbfReader::new(file);
@@ -477,7 +502,7 @@ pub fn operational_points(
             _ => None,                                        // Discard Nodes and Ways
         })
         .flat_map(|rel| {
-            let parts: Vec<_> = rel
+            let mut parts: Vec<_> = rel
                 .refs
                 .iter()
                 .filter(|r| r.role == "stop") // We ignore other members of the relation
@@ -492,8 +517,31 @@ pub fn operational_points(
                     nodes_to_tracks
                         .track_and_position(node)
                         .map(|(track, position, local_track_name)| OperationalPointPart { track, position, local_track_name, extensions: Default::default() })
+                        .map(|mut opp| {
+                            // If the local_track_name is unknown, we try to find if the track_section associated
+                            // to this operational_point_part has a track_name.
+                            // If no track_name is found, keep it unknown and generate one in generate_local_track_name.
+                            if opp.local_track_name == "unknown".into() {
+                                opp.local_track_name = track_sections
+                                    .iter()
+                                    .find(|track_section| { track_section.id == opp.track })
+                                    .map(|track_section| {
+                                        if let Some(sncf) = &track_section.extensions.sncf
+                                            && sncf.track_name != "??".into() {
+                                                Some(sncf.track_name.clone())
+                                        }
+                                        else {
+                                            None
+                                        }
+                                    })
+                                    .expect("OperationalPointPart is linked to an invalid TrackSection id.")
+                                    .unwrap_or(NonBlankString::from("unknown"));
+                            }
+                            opp
+                        })
                 })
                 .collect();
+            generate_local_track_name(&mut parts);
             // Get operational point trigram
             // Look through the nodes member of the relation and find one that has a "railway:ref" tag
             let trigram = rel