{BugFix} Visualization - Show optional viewer panels only when recorded

Summary:
Explanation:
`aria_rerun_viewer` always rendered the Neural Band tabs (EMG, EMG volts, accel, gyro)
and the GPS map view for Gen2 recordings, even for files that contain neither sensor.
The panels stayed empty for the whole session while still consuming layout space.

Two causes, both in `tools/aria_rerun_viewer/aria_rerun_viewer.py`:

- `enable_neural_band_batch` was derived from `get_stream_id_from_label("emg")`, which is
  not a presence check. For Gen2 the label mapper answers from a mostly-static
  device-model table, so it returns an id for every label the glasses *could* record
  (`emg` -> 241-1, `gps` -> 281-2, ...) whether or not the file has that stream. The
  condition was therefore true for every Gen2 recording.
- `enable_gps` was hardcoded to `True`.

Adds `get_recorded_stream_id()`, which resolves a label only when the recording really
carries that sensor: the label must map to a stream id, the id must appear in
`get_all_streams()`, and the stream must hold at least one data record. The last check
also covers streams that are declared in the file but never written to. Both optional
panels are now driven by it, and the Neural Band calibration lookup reuses the resolved
id instead of querying the label a second time.

Only blueprint composition changes. Stream delivery already filtered against
`DeliverQueuedOptions.get_stream_ids()`, so no sensor data was ever plotted for absent
streams and playback behavior is unchanged.

Reproducibility:
Verified on a Gen2 recording with no Neural Band stream by dumping the blueprint with
`--rrd-output-path` before and after the change: the four Neural Band views disappear
while the GPS view is retained, since that recording does contain GPS. Unit tests cover
a recorded stream, a label that maps to an absent stream, a stream with zero data
records, and the GPS variants.

___

Differential Revision: D115492740

fbshipit-source-id: e843378fb840be533ce8d1c76e4d832941d75d36

Author: kongchen1992

projectaria_tools/tools/aria_rerun_viewer/aria_rerun_viewer.py

@@ -29,6 +29,7 @@
 )
 from projectaria_tools.core.data_provider import DeliverQueuedOptions, VrsDataProvider
 from projectaria_tools.core.sensor_data import SensorDataType, TimeDomain, TimeSyncMode
+from projectaria_tools.core.stream_id import StreamId
 from projectaria_tools.tools.aria_rerun_viewer.aria_data_plotter import (
     AriaDataViewer,
     AriaDataViewerConfig,
@@ -137,6 +138,27 @@ def parse_args():
     return parser.parse_args()
 
 
+def get_recorded_stream_id(vrs_data_provider, label: str) -> Optional[StreamId]:
+    """
+    Get the stream id for `label`, or None if this recording carries no data for it.
+
+    `get_stream_id_from_label()` on its own is not a presence check: for Gen2 it
+    answers from a mostly-static device-model table, so it returns an id for
+    every label the glasses *could* record (`emg` -> 241-1, `gps` -> 281-2, ...)
+    whether or not this particular file has that stream. A panel keyed off it
+    alone would render permanently empty. Streams can also be declared with zero
+    data records, so the record count is checked as well.
+    """
+    maybe_stream_id = vrs_data_provider.get_stream_id_from_label(label)
+    if maybe_stream_id is None:
+        return None
+    if maybe_stream_id not in vrs_data_provider.get_all_streams():
+        return None
+    if vrs_data_provider.get_num_data(maybe_stream_id) == 0:
+        return None
+    return maybe_stream_id
+
+
 def get_deliver_option(
     vrs_data_provider,
     enabled_stream_labels: list[str] = None,
@@ -339,13 +361,17 @@ def log_vrs_to_rerun(
     else:
         raise ValueError(f" Unsupported Aria device version: {device_version}")
 
-    # Step 3: Create config
+    # Step 3: Create config. Optional panels are turned on only for sensors this
+    # recording actually carries, so the layout never reserves space for a panel
+    # that would stay empty for the whole session.
     viewer_config: AriaDataViewerConfig = AriaDataViewerConfig()
-    viewer_config.enable_gps = True
-    # VRS stream label is still `emg` (unchanged writer format).
-    viewer_config.enable_neural_band_batch = (
-        vrs_data_provider.get_stream_id_from_label("emg") is not None
+    viewer_config.enable_gps = any(
+        get_recorded_stream_id(vrs_data_provider, label) is not None
+        for label in ("gps", "gps-app")
     )
+    # VRS stream label is still `emg` (unchanged writer format).
+    emg_stream_id: Optional[StreamId] = get_recorded_stream_id(vrs_data_provider, "emg")
+    viewer_config.enable_neural_band_batch = emg_stream_id is not None
 
     # Step 4: Get configured deliver options
     parsed_subsample_rates: dict[str, int] = (
@@ -370,22 +396,18 @@ def log_vrs_to_rerun(
     )
     aria_data_viewer.plot_device_extrinsics()
 
-    if viewer_config.enable_neural_band_batch:
-        emg_stream_id = vrs_data_provider.get_stream_id_from_label("emg")
-        if emg_stream_id is not None:
-            sensor_calib = vrs_data_provider.get_sensor_calibration(emg_stream_id)
-            if (
-                sensor_calib is not None
-                and sensor_calib.sensor_calibration_type()
-                == SensorCalibrationType.NEURAL_BAND_BATCH_CALIBRATION
-            ):
-                batch_calib = sensor_calib.neural_band_batch_calibration()
-                if batch_calib.emg_calib is not None:
-                    aria_data_viewer.set_neural_band_emg_calibration(
-                        batch_calib.emg_calib
-                    )
-                # TODO: forward batch_calib.imu_calib once the viewer surfaces
-                # rectified accel/gyro (raw accel/gyro tabs already show wire values).
+    if emg_stream_id is not None:
+        sensor_calib = vrs_data_provider.get_sensor_calibration(emg_stream_id)
+        if (
+            sensor_calib is not None
+            and sensor_calib.sensor_calibration_type()
+            == SensorCalibrationType.NEURAL_BAND_BATCH_CALIBRATION
+        ):
+            batch_calib = sensor_calib.neural_band_batch_calibration()
+            if batch_calib.emg_calib is not None:
+                aria_data_viewer.set_neural_band_emg_calibration(batch_calib.emg_calib)
+            # TODO: forward batch_calib.imu_calib once the viewer surfaces
+            # rectified accel/gyro (raw accel/gyro tabs already show wire values).
 
     # Step 6: Plot queued sensor data
     plot_queued_sensor_data(

projectaria_tools/tools/aria_rerun_viewer/tests/test_aria_rerun_viewer.py

@@ -28,6 +28,7 @@
     ALL_STREAM_LABELS_GEN1,
     ALL_STREAM_LABELS_GEN2,
     get_deliver_option,
+    get_recorded_stream_id,
     log_vrs_to_rerun,
     main,
     MAX_IMU_BATCH_SIZE,
@@ -158,6 +159,47 @@ def test_rejects_invalid_enabled_stream_choice(self) -> None:
                 parse_args()
 
 
+class GetRecordedStreamIdTest(unittest.TestCase):
+    """Tests for `get_recorded_stream_id()`."""
+
+    def _make_provider(
+        self, label_to_id: dict, recorded: list, num_data: int = 1
+    ) -> MagicMock:
+        provider = MagicMock()
+        provider.get_stream_id_from_label.side_effect = label_to_id.get
+        provider.get_all_streams.return_value = recorded
+        provider.get_num_data.return_value = num_data
+        return provider
+
+    def test_returns_id_for_recorded_stream_with_data(self) -> None:
+        stream_id = MagicMock(name="emg_id")
+        provider = self._make_provider({"emg": stream_id}, recorded=[stream_id])
+
+        self.assertIs(get_recorded_stream_id(provider, "emg"), stream_id)
+
+    def test_returns_none_when_label_is_unknown(self) -> None:
+        provider = self._make_provider({}, recorded=[])
+
+        self.assertIsNone(get_recorded_stream_id(provider, "emg"))
+
+    def test_returns_none_when_stream_absent_from_recording(self) -> None:
+        # The device-model table resolves the label, but the file has no such
+        # stream -- the exact case that left the Neural Band panel always on.
+        stream_id = MagicMock(name="emg_id")
+        provider = self._make_provider({"emg": stream_id}, recorded=[])
+
+        self.assertIsNone(get_recorded_stream_id(provider, "emg"))
+        provider.get_num_data.assert_not_called()
+
+    def test_returns_none_when_stream_has_no_data_records(self) -> None:
+        stream_id = MagicMock(name="emg_id")
+        provider = self._make_provider(
+            {"emg": stream_id}, recorded=[stream_id], num_data=0
+        )
+
+        self.assertIsNone(get_recorded_stream_id(provider, "emg"))
+
+
 class GetDeliverOptionTest(unittest.TestCase):
     """Tests for `get_deliver_option()`."""
 
@@ -578,17 +620,29 @@ def _setup_provider(
         self,
         device_version: DeviceVersion,
         stream_labels: list = None,
+        phantom_labels: list = None,
+        empty_labels: list = None,
     ) -> MagicMock:
         """
         Build a mock VRS provider whose helpers cooperate with the real
         `get_deliver_option` implementation. Each label in `stream_labels`
         gets a distinct mock StreamId that flows through both
         `get_stream_id_from_label` and `deliver_options.get_stream_ids()`.
+
+        `phantom_labels` models the Gen2 device-model table in the external
+        StreamIdLabelMapper: the label resolves to a StreamId, but that stream
+        is absent from the recording. `empty_labels` models a stream that is
+        present but carries zero data records.
         """
         stream_labels = stream_labels or []
+        phantom_labels = phantom_labels or []
+        empty_labels = empty_labels or []
+        # Phantom labels resolve to an id but never appear in the file's streams.
         self.stream_id_map = {
-            label: MagicMock(name=f"stream_id_{label}") for label in stream_labels
+            label: MagicMock(name=f"stream_id_{label}")
+            for label in list(stream_labels) + list(phantom_labels)
         }
+        recorded_ids = [self.stream_id_map[label] for label in stream_labels]
 
         provider = MagicMock()
         (
@@ -597,11 +651,14 @@ def _setup_provider(
         provider.get_stream_id_from_label.side_effect = (
             lambda label: self.stream_id_map.get(label)
         )
+        provider.get_all_streams.return_value = recorded_ids
+        empty_ids = {self.stream_id_map[label] for label in empty_labels}
+        provider.get_num_data.side_effect = (
+            lambda stream_id: 0 if stream_id in empty_ids else 1
+        )
 
         self.deliver_options = MagicMock()
-        self.deliver_options.get_stream_ids.return_value = list(
-            self.stream_id_map.values()
-        )
+        self.deliver_options.get_stream_ids.return_value = recorded_ids
         provider.get_default_deliver_queued_options.return_value = self.deliver_options
         return provider
 
@@ -686,20 +743,65 @@ def test_default_vio_hf_subsample_rate_is_applied(self) -> None:
             AriaDataViewerConfig.vio_high_freq_subsample_rate,
         )
 
-    def test_neural_band_batch_enabled_only_when_emg_stream_present(self) -> None:
-        # VRS stream label is `emg` on the wire.
-        with_emg = self._setup_provider(DeviceVersion.Gen2, stream_labels=["emg"])
-        self.mock_create_provider.return_value = with_emg
-        log_vrs_to_rerun("/some.vrs")
-        with_emg_kwargs = self.mock_viewer_cls.call_args.kwargs
-        self.assertTrue(with_emg_kwargs["config"].enable_neural_band_batch)
-
+    def _config_for(self, provider: MagicMock):
+        """Run the viewer against `provider` and return the config it was built with."""
         self.mock_viewer_cls.reset_mock()
-        no_emg = self._setup_provider(DeviceVersion.Gen2, stream_labels=["camera-rgb"])
-        self.mock_create_provider.return_value = no_emg
+        self.mock_create_provider.return_value = provider
         log_vrs_to_rerun("/some.vrs")
-        no_emg_kwargs = self.mock_viewer_cls.call_args.kwargs
-        self.assertFalse(no_emg_kwargs["config"].enable_neural_band_batch)
+        return self.mock_viewer_cls.call_args.kwargs["config"]
+
+    def test_neural_band_batch_enabled_when_emg_stream_recorded(self) -> None:
+        # VRS stream label is `emg` on the wire.
+        config = self._config_for(
+            self._setup_provider(DeviceVersion.Gen2, stream_labels=["emg"])
+        )
+
+        self.assertTrue(config.enable_neural_band_batch)
+
+    def test_neural_band_batch_disabled_when_label_maps_to_absent_stream(self) -> None:
+        # The external Gen2 StreamIdLabelMapper resolves `emg` from a static
+        # device-model table, so it hands back 241-1 even for a recording that
+        # has no Neural Band stream. Presence in the file is what must decide.
+        config = self._config_for(
+            self._setup_provider(
+                DeviceVersion.Gen2,
+                stream_labels=["camera-rgb"],
+                phantom_labels=["emg"],
+            )
+        )
+
+        self.assertFalse(config.enable_neural_band_batch)
+
+    def test_neural_band_batch_disabled_when_stream_has_no_records(self) -> None:
+        # A declared-but-empty stream would render a panel that never fills.
+        config = self._config_for(
+            self._setup_provider(
+                DeviceVersion.Gen2,
+                stream_labels=["camera-rgb", "emg"],
+                empty_labels=["emg"],
+            )
+        )
+
+        self.assertFalse(config.enable_neural_band_batch)
+
+    def test_gps_enabled_only_when_a_gps_stream_is_recorded(self) -> None:
+        # `gps` and `gps-app` are separate streams; either one earns the map panel.
+        for labels in (["gps"], ["gps-app"], ["gps", "gps-app"]):
+            with self.subTest(stream_labels=labels):
+                config = self._config_for(
+                    self._setup_provider(DeviceVersion.Gen2, stream_labels=labels)
+                )
+                self.assertTrue(config.enable_gps)
+
+        config = self._config_for(
+            self._setup_provider(
+                DeviceVersion.Gen2,
+                stream_labels=["camera-rgb"],
+                phantom_labels=["gps", "gps-app"],
+            )
+        )
+
+        self.assertFalse(config.enable_gps)
 
     def test_user_subsample_rates_are_parsed_and_applied(self) -> None:
         # Real parse_subsample_rates + real get_deliver_option must translate