Handle camera trigger defaults & trigger-aware startup

Populate gentl trigger defaults on save and allow saving configs with empty DLCLive model path. Add _with_camera_defaults_for_save to ensure CameraTriggerSettings are present for gentl cameras and thread through allow_empty_model_path in _dlc_settings_from_ui/_current_config so configs can be saved without a model while preserving existing DLC fields.

Improve multi-camera runtime robustness: treat TimeoutError from hardware-trigger backends as an expected 'no trigger' event (don't count as a camera failure) and add _trigger_role_from_settings/_camera_start_priority helpers. Start active cameras sorted by trigger role so trigger-waiting (external/follower) devices are armed before masters. Also extend DLCLive configuration error handling to include RuntimeError.

Author: C-Achard

dlclivegui/gui/main_window.py

@@ -56,6 +56,7 @@
     ApplicationSettings,
     BoundingBoxSettings,
     CameraSettings,
+    CameraTriggerSettings,
     DLCProcessorSettings,
     MultiCameraSettings,
     RecordingSettings,
@@ -854,15 +855,36 @@ def _apply_config(self, config: ApplicationSettings) -> None:
         # Update recording path preview
         self._update_recording_path_preview()
 
-    def _current_config(self) -> ApplicationSettings:
+    def _with_camera_defaults_for_save(self, settings: MultiCameraSettings) -> MultiCameraSettings:
+        out = settings.model_copy(deep=True)
+
+        for cam in out.cameras:
+            backend = (cam.backend or "").lower()
+            if backend != "gentl":
+                continue
+
+            if not isinstance(cam.properties, dict):
+                cam.properties = {}
+
+            ns = cam.properties.setdefault("gentl", {})
+            if not isinstance(ns, dict):
+                ns = {}
+                cam.properties["gentl"] = ns
+
+            ns.setdefault("trigger", CameraTriggerSettings().model_dump(exclude_none=True))
+
+        return out
+
+    def _current_config(self, *, allow_empty_model_path=False) -> ApplicationSettings:
         # Get the first camera from multi-camera config for backward compatibility
+        multi_camera = self._with_camera_defaults_for_save(self._config.multi_camera)
         active_cameras = self._config.multi_camera.get_active_cameras()
         camera = active_cameras[0] if active_cameras else CameraSettings()
 
         return ApplicationSettings(
             camera=camera,
-            multi_camera=self._config.multi_camera,
-            dlc=self._dlc_settings_from_ui(),
+            multi_camera=multi_camera,
+            dlc=self._dlc_settings_from_ui(allow_empty_model_path=allow_empty_model_path),
             recording=self._recording_settings_from_ui(),
             bbox=self._bbox_settings_from_ui(),
             visualization=self._visualization_settings_from_ui(),
@@ -874,13 +896,24 @@ def _parse_json(self, value: str) -> dict:
             return {}
         return json.loads(text)
 
-    def _dlc_settings_from_ui(self) -> DLCProcessorSettings:
+    def _dlc_settings_from_ui(self, *, allow_empty_model_path=False) -> DLCProcessorSettings:
         model_path = self.model_path_edit.text().strip()
         if Path(model_path).exists() and Path(model_path).suffix == ".pb":
             # IMPORTANT NOTE: DLClive expects a directory for TensorFlow models,
             # so if user selects a .pb file, we should pass the parent directory to DLCLive
             model_path = str(Path(model_path).parent)
-        if model_path == "":
+        if not model_path:
+            if allow_empty_model_path:
+                return DLCProcessorSettings(
+                    model_path="",
+                    model_directory=self._config.dlc.model_directory,  # Preserve from config
+                    device=self._config.dlc.device,  # Preserve from config
+                    dynamic=self._config.dlc.dynamic,  # Preserve from config
+                    resize=self._config.dlc.resize,  # Preserve from config
+                    precision=self._config.dlc.precision,  # Preserve from config
+                    model_type=None,
+                    # additional_options=self._parse_json(self.additional_options_edit.toPlainText()),
+                )
             raise ValueError("Model path cannot be empty. Please enter a valid path to a DLCLive model file.")
         try:
             model_bknd = DLCLiveProcessor.get_model_backend(model_path)
@@ -965,7 +998,7 @@ def _action_save_config_as(self) -> None:
 
     def _save_config_to_path(self, path: Path) -> None:
         try:
-            config = self._current_config()
+            config = self._current_config(allow_empty_model_path=True)
             config.save(path)
             self._settings_store.set_last_config_path(str(path))
             self._settings_store.save_full_config_snapshot(config)
@@ -1611,7 +1644,7 @@ def _stop_preview(self) -> None:
     def _configure_dlc(self) -> bool:
         try:
             settings = self._dlc_settings_from_ui()
-        except (ValueError, json.JSONDecodeError) as exc:
+        except (ValueError, RuntimeError, json.JSONDecodeError) as exc:
             self._show_error(f"Invalid DLCLive settings: {exc}")
             return False
         if not settings.model_path:

dlclivegui/services/multi_camera_controller.py

@@ -99,6 +99,29 @@ def run(self) -> None:
                 consecutive_errors = 0
                 self.frame_captured.emit(self._camera_id, frame, timestamp)
 
+            except TimeoutError as exc:
+                if self._stop_event.is_set():
+                    break
+
+                # In hardware-trigger mode, a timeout usually means:
+                # "no trigger pulse arrived during this poll interval".
+                # This is expected and should not count as a camera failure.
+                if bool(getattr(self._backend, "waits_for_hardware_trigger", False)):
+                    LOGGER.debug(
+                        "[Worker %s] waiting for hardware trigger: %s",
+                        self._camera_id,
+                        exc,
+                    )
+                    consecutive_errors = 0
+                    continue
+
+                consecutive_errors += 1
+                if consecutive_errors >= self._max_consecutive_errors:
+                    self.error_occurred.emit(self._camera_id, f"Camera read timeout: {exc}")
+                    break
+                time.sleep(self._retry_delay)
+                continue
+
             except Exception as exc:
                 consecutive_errors += 1
                 if self._stop_event.is_set():
@@ -138,6 +161,46 @@ def get_camera_id(settings: CameraSettings) -> str:
     return f"{backend}:index:{int(settings.index)}"
 
 
+def _trigger_role_from_settings(settings: CameraSettings) -> str:
+    backend = (settings.backend or "").lower()
+    props = settings.properties if isinstance(settings.properties, dict) else {}
+    ns = props.get(backend, {}) if isinstance(props.get(backend), dict) else {}
+
+    trigger = ns.get("trigger", {})
+    if not isinstance(trigger, dict):
+        return "off"
+
+    role = str(trigger.get("role", "off") or "off").strip().lower()
+
+    # Match CameraTriggerSettings aliases enough for controller ordering.
+    if role in {"true", "on", "trigger", "triggered"}:
+        return "external"
+    if role in {"slave"}:
+        return "follower"
+    if role in {"main"}:
+        return "master"
+    if role in {"false", "none", "disabled", "disable", ""}:
+        return "off"
+
+    return role
+
+
+def _camera_start_priority(settings: CameraSettings) -> int:
+    """Start trigger-waiting cameras before trigger-generating cameras.
+
+    Priority:
+      0: external/follower cameras, which should be armed first
+      1: normal/free-run cameras
+      2: master cameras, which may generate trigger pulses
+    """
+    role = _trigger_role_from_settings(settings)
+    if role in {"external", "follower"}:
+        return 0
+    if role == "master":
+        return 2
+    return 1
+
+
 class MultiCameraController(QObject):
     """Controller for managing multiple cameras simultaneously."""
 
@@ -180,6 +243,7 @@ def start(self, camera_settings: list[CameraSettings]) -> None:
             return
 
         active_settings = [s for s in camera_settings if s.enabled][: self.MAX_CAMERAS]
+        active_settings = sorted(active_settings, key=_camera_start_priority)
         if not active_settings:
             LOGGER.warning("No active cameras to start")
             return