src/applogic/mod.rs

@@ -106,7 +106,6 @@ pub struct GlosaSignalInfo {
 pub struct SignalGroupData {
     pub phase: SignalPhase,
     pub maneuver: map::Maneuvers,
-    pub usages: Vec<map::UsageType>,
     pub timing: Option<TimingData>,
 }
 
@@ -384,29 +383,35 @@ impl State {
                             }),
                         )
                     } else {
-                        // get signal groups which are in our approach and have a maneuver
+                        // get signal groups which are in our approach
                         let mut approach_sig_grps = intersection
                             .signal_groups()
                             .iter()
-                            .filter_map(|i| {
+                            .filter(|i| {
-                                if let Some(maneuver) = i.maneuvers()
+                                info.signal_groups
-                                    && info
+                                    .iter()
-                                        .signal_groups
+                                    .find(|sg_id| **sg_id == i.id())
-                                        .iter()
+                                    .is_some()
-                                        .find(|sg_id| **sg_id == i.id())
+                            })
-                                        .is_some()
+                            .collect::<Vec<_>>();
-                                {
+
-                                    let phase = i
+                        // sort signal groups by maneuver
+                        approach_sig_grps.sort_by_key(|v| v.maneuvers());
+
+                        // display signal phases
+                        let sig_grps = approach_sig_grps
+                            .iter()
+                            .filter_map(|sig| {
+                                if let Some(maneuver) = sig.maneuvers() {
+                                    let phase = sig
                                         .phase()
                                         .map(core::convert::Into::into)
                                         .unwrap_or_default();
-                                    let timing = TimingData::new(i, self.time.and_utc());
+                                    let timing = TimingData::new(sig, self.time.and_utc());
-                                    let usages = i.source_lane_usages().to_vec();
 
                                     Some(SignalGroupData {
                                         phase,
                                         maneuver,
-                                        usages,
                                         timing,
                                     })
                                 } else {
@@ -415,39 +420,11 @@ impl State {
                             })
                             .collect::<Vec<_>>();
 
-                        // sort signal groups by maneuver
-                        approach_sig_grps.sort_by_key(|v| v.maneuver);
-
-                        // // display signal phases
-                        // let sig_grps = approach_sig_grps
-                        //     .iter()
-                        //     .filter_map(|sig| {
-                        //         if let Some(maneuver) = sig.sig_group.maneuvers() {
-                        //             let phase = sig
-                        //                 .sig_group
-                        //                 .phase()
-                        //                 .map(core::convert::Into::into)
-                        //                 .unwrap_or_default();
-                        //             let timing =
-                        //                 TimingData::new(&sig.sig_group, self.time.and_utc());
-
-                        //             Some(SignalGroupData {
-                        //                 phase,
-                        //                 maneuver,
-                        //                 timing,
-                        //                 usages: sig.lane_types.clone(),
-                        //             })
-                        //         } else {
-                        //             None
-                        //         }
-                        //     })
-                        //     .collect::<Vec<_>>();
-
                         (
                             None,
                             GlosaOutput::Locked(GlosaSignalInfo {
                                 intersection_id: intersection.id(),
-                                signal_groups: approach_sig_grps,
+                                signal_groups: sig_grps,
                             }),
                         ) // keep state, return signal groups
                     }

src/applogic/v2x/map.rs

@@ -191,35 +191,27 @@ impl Intersection {
     fn collect_signal_groups(lanes: &[Lane]) -> Vec<SignalGroup> {
         let mut connections = lanes
             .iter()
-            .flat_map(ConnectionExt::from_lane)
+            .flat_map(|i| i.connections.clone())
-            .filter(|i| i.conn.signal_group.is_some())
+            .filter(|i| i.signal_group.is_some())
             .collect::<Vec<_>>();
 
-        connections.sort_by_key(|i| i.conn.signal_group.unwrap_or_default());
+        connections.sort_by_key(|i| i.signal_group.unwrap_or_default());
 
-        let chunks = connections.chunk_by(|a, b| a.conn.signal_group == b.conn.signal_group);
+        let chunks = connections.chunk_by(|a, b| a.signal_group == b.signal_group);
         chunks
             .map(|chunk| {
-                let (sig_grp_id, maneuvers, mut target_lanes, mut source_lane_usages) =
+                let (sig_grp_id, maneuvers, mut target_lanes) = chunk.iter().fold(
-                    chunk.iter().fold(
+                    (None, Maneuvers::default(), vec![]),
-                        (None, Maneuvers::default(), vec![], vec![]),
+                    |(sig_grp_id, maneuvers, mut lanes), i| {
-                        |(sig_grp_id, maneuvers, mut lanes, mut usages), i| {
+                        let new_maneuvers = i
-                            let new_maneuvers = i
+                            .maneuvers
-                                .conn
+                            .map(|v| core::ops::Add::add(maneuvers, v))
-                                .maneuvers
+                            .unwrap_or_default();
-                                .map(|v| core::ops::Add::add(maneuvers, v))
+                        lanes.push(i.target_lane_id);
-                                .unwrap_or_default();
-                            lanes.push(i.conn.target_lane_id);
 
-                            let lane_usages = i.source_lane_usages.clone();
+                        (i.signal_group, new_maneuvers, lanes)
-                            usages.extend_from_slice(&lane_usages);
+                    },
-
+                );
-                            usages.sort_unstable();
-                            usages.dedup(); // TODO: only do this after all lanes were added?
-
-                            (i.conn.signal_group, new_maneuvers, lanes, usages)
-                        },
-                    );
 
                 // unwrap is fine since we removed all connections without signal group beforehand
                 let id = sig_grp_id.unwrap();
@@ -234,7 +226,6 @@ impl Intersection {
                 SignalGroup {
                     id,
                     maneuvers,
-                    source_lane_usages,
                     target_lanes,
                     phase: None,
                     min_end_time: None,
@@ -411,28 +402,6 @@ impl From<&etsi_its_dsrc::Connection> for Connection {
     }
 }
 
-#[derive(Debug, Clone)]
-#[allow(unused)]
-struct ConnectionExt {
-    source_lane_id: u8,
-    source_lane_usages: Vec<UsageType>,
-    conn: Connection,
-}
-
-impl ConnectionExt {
-    fn from_lane(value: &Lane) -> Vec<Self> {
-        value
-            .connections
-            .iter()
-            .map(|conn| Self {
-                source_lane_id: value.id,
-                source_lane_usages: value.usages.clone(),
-                conn: *conn,
-            })
-            .collect()
-    }
-}
-
 /// Different view on a lane connection
 ///
 /// Technically this data is redundant with the `Connection` data of a `Lane`,
@@ -442,8 +411,7 @@ impl ConnectionExt {
 pub struct SignalGroup {
     id: u8,
     maneuvers: Option<Maneuvers>,
-    source_lane_usages: Vec<UsageType>, // for easier signal group evaluation
+    target_lanes: Vec<u8>, // mainly for debugging
-    target_lanes: Vec<u8>,              // mainly for debugging
 
     // SPAT data
     /// current signal phase
@@ -473,9 +441,6 @@ impl SignalGroup {
     pub fn maneuvers(&self) -> Option<Maneuvers> {
         self.maneuvers
     }
-    pub fn source_lane_usages(&self) -> &[UsageType] {
-        &self.source_lane_usages
-    }
     pub fn phase(&self) -> Option<etsi_its_dsrc::MovementPhaseState> {
         self.phase
     }

src/screen.rs

@@ -356,9 +356,6 @@ where
             .draw(&mut self.target)?;
 
             // TODO: draw lane type?
-            for usage in &sig.usages {
-                esp_println::println!("TODO: {usage:?}");
-            }
 
             // draw maneuver
             text::Text::with_alignment(