diff --git a/dlclivegui/cameras/backends/gentl_backend.py b/dlclivegui/cameras/backends/gentl_backend.py index eb28aea4..26d5c2f0 100644 --- a/dlclivegui/cameras/backends/gentl_backend.py +++ b/dlclivegui/cameras/backends/gentl_backend.py @@ -1,16 +1,18 @@ """GenTL backend implemented using the Harvesters library.""" -# dlclivegui/cameras/backends/gentl_backend.py +# dlclivegui/cameras/backends/gentl_backend.py from __future__ import annotations import logging +import threading import time from pathlib import Path -from typing import ClassVar +from typing import Any, ClassVar import cv2 import numpy as np +from ...config import CameraTriggerSettings from ..base import CameraBackend, SupportLevel, register_backend from ..factory import DetectedCamera from .utils import gentl_discovery as cti_finder @@ -31,112 +33,131 @@ @register_backend("gentl") class GenTLCameraBackend(CameraBackend): - """Capture frames from GenTL-compatible devices via Harvesters.""" + """Capture frames from GenTL-compatible devices via Harvesters. + + Notes + ----- + Multi-camera operation uses a shared Harvester per CTI set. Some GenTL + producers, including the Imaging Source USB3 Vision producer, can report no + devices if a second independent Harvester enumerates while another camera is + already open/streaming. Therefore open() acquires a shared Harvester and + never calls Harvester.update() during runtime open; initial enumeration is + handled by SharedHarvesterPool when the shared Harvester is created. + """ OPTIONS_KEY: ClassVar[str] = "gentl" - _LEGACY_DEFAULT_CTI_PATTERNS: tuple[str, ...] = ( # Windows-only, ignored on other platforms - r"C:\\Program Files\\The Imaging Source Europe GmbH\\IC4 GenTL Driver for USB3Vision Devices *\\bin\\*.cti", - r"C:\\Program Files\\The Imaging Source Europe GmbH\\TIS Grabber\\bin\\win64_x64\\*.cti", - r"C:\\Program Files\\The Imaging Source Europe GmbH\\TIS Camera SDK\\bin\\win64_x64\\*.cti", - r"C:\\Program Files (x86)\\The Imaging Source Europe GmbH\\TIS Grabber\\bin\\win64_x64\\*.cti", + _OPEN_LOCK: ClassVar[threading.RLock] = threading.RLock() + + _DEFAULT_CTI_PATTERNS: ClassVar[tuple[str, ...]] = ( + # Windows-only defaults; harmless/no-op on other platforms. + r"C:\Program Files\The Imaging Source Europe GmbH\IC4 GenTL Driver for USB3Vision Devices *\bin\*.cti", + r"C:\Program Files\The Imaging Source Europe GmbH\TIS Grabber\bin\win64_x64\*.cti", + r"C:\Program Files\The Imaging Source Europe GmbH\TIS Camera SDK\bin\win64_x64\*.cti", + r"C:\Program Files (x86)\The Imaging Source Europe GmbH\TIS Grabber\bin\win64_x64\*.cti", ) - # Source marker stored in properties["gentl"]["cti_files_source"] - # auto : persisted by auto-discovery (env vars, patterns, etc.). Cache, may be stale, re-discover if missing. - # user : explicitly set by user via properties.gentl.cti_file(s). Cache, strict raise if missing. + _COLOR_PIXEL_FORMATS: ClassVar[tuple[str, ...]] = ( + "BGR8", + "RGB8", + "BayerRG8", + "BayerGB8", + "BayerGR8", + "BayerBG8", + ) + _MONO_PIXEL_FORMATS: ClassVar[tuple[str, ...]] = ( + "Mono8", + "Mono10", + "Mono12", + "Mono16", + ) + + # Source marker stored in properties["gentl"]["cti_files_source"]. + # auto: persisted by auto-discovery; may be stale and can fall back. + # user: explicitly set by user; strict if stale/missing. _CTI_FILES_SOURCE_AUTO: ClassVar[str] = "auto" _CTI_FILES_SOURCE_USER: ClassVar[str] = "user" + # Keep individual Harvester.fetch() calls short enough that controller + # shutdown can stop worker threads promptly. Hardware-trigger waits are + # handled by repeated polling in SingleCameraWorker. + _MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT: ClassVar[float] = 1.0 + def __init__(self, settings): super().__init__(settings) - # --- Properties namespace handling (new UI stores backend options under properties["gentl"]) --- props = settings.properties if isinstance(settings.properties, dict) else {} ns = props.get(self.OPTIONS_KEY, {}) if not isinstance(ns, dict): ns = {} - # --- Fast probe mode (CameraProbeWorker sets this) --- - # When fast_start=True, open() should avoid starting acquisition if possible. self._fast_start: bool = bool(ns.get("fast_start", False)) - # --- Stable identity / serial selection --- - # New UI stores stable identity as ns["device_id"], with recommended formats: - # - "serial:" for true serials - # - "fp:" when serial is missing/ambiguous - # - # We keep legacy "serial_number"/"serial" behavior as fallback. raw_device_id = ns.get("device_id") or props.get("device_id") legacy_serial = ns.get("serial_number") or ns.get("serial") or props.get("serial_number") or props.get("serial") self._device_id: str | None = str(raw_device_id).strip() if raw_device_id else None + self._serial_number: str | None = self._serial_from_identity(self._device_id, legacy_serial) - # Decide what to use for actual device selection in open(): - # - If device_id is "serial:XXXX" -> use XXXX as serial_number - # - Otherwise, keep legacy serial if present; open() may still use index if serial is None - self._serial_number: str | None = None - if self._device_id: - did = self._device_id - if did.startswith("serial:"): - self._serial_number = did.split("serial:", 1)[1].strip() or None - elif did.startswith("fp:"): - # fingerprint: not directly usable as serial; rebind_settings should map fp -> index - self._serial_number = legacy_serial # keep legacy if any, otherwise None - else: - # If device_id is provided without prefix, treat it as a "serial-like" value for backward compatibility - self._serial_number = did - else: - self._serial_number = str(legacy_serial).strip() if legacy_serial else None - - # --- Pixel format / image transforms (legacy + backend options) --- - self._pixel_format: str = ns.get("pixel_format") or props.get("pixel_format", "Mono8") + self._pixel_format: str = ns.get("pixel_format") or props.get("pixel_format", "auto") + self._pixel_format = str(self._pixel_format).strip() self._rotate: int = int(ns.get("rotate", props.get("rotate", 0))) % 360 self._crop: tuple[int, int, int, int] | None = self._parse_crop(ns.get("crop", props.get("crop"))) - # --- Exposure / Gain: 0 means Auto (do not set) --- - exp_val = getattr(settings, "exposure", 0) - gain_val = getattr(settings, "gain", 0.0) - - self._exposure: float | None = ( - float(exp_val) if isinstance(exp_val, (int, float)) and float(exp_val) > 0 else None - ) + self._exposure: float | None = self._positive_float(getattr(settings, "exposure", 0)) if self._exposure is None: - v = ns.get("exposure", props.get("exposure")) - try: - self._exposure = float(v) if v is not None and float(v) > 0 else None - except Exception: - self._exposure = None + self._exposure = self._positive_float(ns.get("exposure", props.get("exposure"))) - self._gain: float | None = ( - float(gain_val) if isinstance(gain_val, (int, float)) and float(gain_val) > 0 else None - ) + self._gain: float | None = self._positive_float(getattr(settings, "gain", 0.0)) if self._gain is None: - v = ns.get("gain", props.get("gain")) - try: - self._gain = float(v) if v is not None and float(v) > 0 else None - except Exception: - self._gain = None + self._gain = self._positive_float(ns.get("gain", props.get("gain"))) - # --- Acquisition timeout --- self._timeout: float = float(ns.get("timeout", props.get("timeout", 2.0))) + raw_trigger = ns.get("trigger", props.get("trigger")) + raw_trigger_strict = isinstance(raw_trigger, dict) and bool(raw_trigger.get("strict", False)) + + try: + self._trigger = CameraTriggerSettings.from_any(raw_trigger) + except Exception as exc: + if raw_trigger_strict: + raise ValueError(f"Strict mode failure - Invalid GenTL trigger configuration: {exc}") from exc + + LOG.warning( + "Invalid GenTL trigger config; falling back to trigger role=off: %s. " + "Enable strict mode to force this to raise.", + exc, + ) + self._trigger = CameraTriggerSettings() + + trigger_timeout = self._positive_float(self._trigger_attr(self._trigger, "timeout", None)) + if trigger_timeout is not None: + role = str(self._trigger_attr(self._trigger, "role", "off") or "off").strip().lower() + + if role in {"external", "follower"}: + # Do not let a long hardware-trigger wait block shutdown. + # SingleCameraWorker treats these fetch timeouts as expected + # polling misses while waits_for_hardware_trigger is true. + self._timeout = min(float(trigger_timeout), self._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT) + else: + # For non-trigger-waiting modes, preserve legacy behavior. + self._timeout = float(trigger_timeout) - # --- Resolution request (None = device default / Auto) --- - # Uses settings.width/settings.height if set; falls back to legacy props["resolution"] if present. self._requested_resolution: tuple[int, int] | None = self._get_requested_resolution_or_none() - # --- Actuals for GUI --- self._actual_width: int | None = None self._actual_height: int | None = None self._actual_fps: float | None = None self._actual_gain: float | None = None self._actual_exposure: float | None = None - # --- Harvesters resources --- self._harvester = None self._acquirer = None + self._shared_entry = None self._device_label: str | None = None - self._cti_files_source_used: str | None = None + # ------------------------------------------------------------------ + # Public telemetry / capabilities + # ------------------------------------------------------------------ + @property def actual_resolution(self) -> tuple[int, int] | None: if self._actual_width and self._actual_height: @@ -168,14 +189,99 @@ def static_capabilities(cls) -> dict[str, SupportLevel]: "set_gain": SupportLevel.SUPPORTED, "device_discovery": SupportLevel.SUPPORTED, "stable_identity": SupportLevel.SUPPORTED, + "hardware_trigger": SupportLevel.BEST_EFFORT, } + def _debug_trigger_nodes(self, node_map, *, context: str = "") -> None: + names = ( + "TriggerMode", + "TriggerSelector", + "TriggerSource", + "TriggerActivation", + "AcquisitionMode", + # Generic line nodes, if available. + "LineSelector", + "LineMode", + "LineSource", + # TIS 37U / DMK 37BUX287 strobe/output nodes. + "GPIn", + "GPOut", + "StrobeEnable", + "StrobePolarity", + "StrobeOperation", + "StrobeDuration", + "StrobeDelay", + ) + + label = f"GenTL trigger debug {context}".strip() + + for name in names: + node = self._node(node_map, name) + if node is None: + continue + + value = self._node_value(node_map, name, None) + + extras = [] + + symbolics = self._node_symbolics(node) + if symbolics: + extras.append(f"symbolics={symbolics}") + + for attr in ("access_mode", "is_writable", "is_readable"): + try: + extras.append(f"{attr}={getattr(node, attr)}") + except Exception: + pass + + LOG.debug("%s: %s=%r %s", label, name, value, " ".join(extras)) + + def _debug_frame_rate_nodes(self, node_map, *, context: str = "") -> None: + names = ( + "AcquisitionFrameRateEnable", + "AcquisitionFrameRateControlEnable", + "AcquisitionFrameRate", + "AcquisitionFrameRateAbs", + "AcquisitionResultingFrameRate", + "ResultingFrameRate", + "AcquisitionFrameRateResulting", + "DeviceFrameRate", + "ExposureAuto", + "ExposureTime", + "ExposureTimeAbs", + "DeviceLinkThroughputLimit", + "DeviceLinkThroughputLimitMode", + "PayloadSize", + "Width", + "Height", + "PixelFormat", + ) + + label = f"GenTL FPS debug {context}".strip() + + for name in names: + node = self._node(node_map, name) + if node is None: + continue + + value = self._node_value(node_map, name, None) + + extras = [] + for attr in ("min", "max", "inc"): + try: + extras.append(f"{attr}={getattr(node, attr)}") + except Exception: + pass + + LOG.debug("%s: %s=%r %s", label, name, value, " ".join(extras)) + + # ------------------------------------------------------------------ + # Discovery + # ------------------------------------------------------------------ + @classmethod def get_device_count(cls) -> int: - """Get the number of GenTL devices detected by Harvester. - - Returns the number of devices found, or -1 if detection fails. - """ + """Return the number of GenTL devices, or -1 if detection fails.""" if Harvester is None: return -1 @@ -184,286 +290,407 @@ def get_device_count(cls) -> int: harvester, _, _ = cls._build_harvester_for_discovery(strict_single=False) if harvester is None: return -1 - infos = harvester.device_info_list or [] - return len(infos) + return len(harvester.device_info_list or []) except Exception: return -1 finally: - if harvester is not None: - try: - harvester.reset() - except Exception: - pass - - @staticmethod - def _cti_preflight(path: str) -> tuple[bool, str | None]: - """ - Best-effort check right before calling Harvester.add_file(). - Still subject to race conditions (e.g. file deleted after this check), - but helps diagnose common issues like missing files or permission errors more gracefully and early. - Returns (ok, reason_if_not_ok). - """ - p = Path(str(path)) - try: - if not p.exists(): - return False, "missing at load time" - if not p.is_file(): - return False, "not a file at load time" - # Optional: try opening for read to detect permission/locking issues early - with p.open("rb"): - pass - return True, None - except PermissionError: - return False, "permission denied at load time" - except OSError as e: - return False, f"os error at load time: {e}" - - def _resolve_cti_files_for_settings(self) -> list[str]: - """ - Resolve CTI files to load. - - - User override (properties.gentl.cti_file/cti_files OR legacy properties.cti_file/cti_files): - * strict: must exist, otherwise raise - * source = "user" - - Auto-persisted cache (properties.gentl.cti_files_source == "auto"): - * try persisted ctis first - * if stale/missing, fall back to discovery - * source = "auto" - - Default: discovery (env + configured patterns/dirs) => source = "auto" - - NOTE : legacy properties.cti_file(s) always take strict precedence as user override if present, - even if source marker says "auto". - Never raise just because multiple CTIs exist. - Raise only when none are found (after allowed fallback). - """ - props = self.settings.properties if isinstance(self.settings.properties, dict) else {} - ns = props.get(self.OPTIONS_KEY, {}) - if not isinstance(ns, dict): - ns = {} + cls._safe_reset_harvester(harvester) - # Read source marker - source = ns.get("cti_files_source") - source = str(source).strip().lower() if source is not None else None + @classmethod + def discover_devices( + cls, + *, + max_devices: int = 10, + should_cancel: callable[[], bool] | None = None, + progress_cb: callable[[str], None] | None = None, + ): + """Rich discovery path for CameraFactory.detect_cameras().""" + if Harvester is None: + return [] - # Explicit CTIs (namespace first, then legacy top-level) - ns_cti_files = ns.get("cti_files") - ns_cti_file = ns.get("cti_file") - legacy_cti_files = props.get("cti_files") - legacy_cti_file = props.get("cti_file") + def _canceled() -> bool: + return bool(should_cancel and should_cancel()) - # ------------------------------------------------------------ - # 1) Legacy explicit CTIs: always treat as user override (strict) - # ------------------------------------------------------------ - if legacy_cti_files or legacy_cti_file: - self._cti_files_source_used = self._CTI_FILES_SOURCE_USER + harvester = None + try: + if progress_cb: + progress_cb("Initializing GenTL discovery…") - candidates, diag = cti_finder.discover_cti_files( - cti_file=str(legacy_cti_file) if legacy_cti_file else None, - cti_files=cti_finder.cti_files_as_list(legacy_cti_files) if legacy_cti_files else None, - include_env=False, - must_exist=True, - ) - if not candidates: - raise RuntimeError( - "No valid GenTL producer (.cti) found from properties.cti_file/cti_files.\n\n" - f"Discovery details:\n{diag.summarize()}" - ) - return list(candidates) + harvester, loaded, _ = cls._build_harvester_for_discovery(strict_single=False) + if harvester is None or not loaded: + if progress_cb: + progress_cb("No GenTL producers could be loaded.") + return [] - # ------------------------------------------------------------------------ - # 2) Namespace explicit CTIs: behavior depends on cti_files_source marker - # - source=="auto": treat as cache, stale => fallback to discovery - # - otherwise: strict user override - # ------------------------------------------------------------------------ - if ns_cti_files or ns_cti_file: - is_auto_cache = source == self._CTI_FILES_SOURCE_AUTO + if progress_cb: + progress_cb(f"Loaded {len(loaded)} GenTL producer(s). Scanning devices…") - # Default to "user" if the marker is missing/unknown. - self._cti_files_source_used = self._CTI_FILES_SOURCE_AUTO if is_auto_cache else self._CTI_FILES_SOURCE_USER + infos = list(harvester.device_info_list or []) + limit = min(len(infos), max_devices if max_devices > 0 else len(infos)) + out: list[DetectedCamera] = [] - candidates, diag = cti_finder.discover_cti_files( - cti_file=str(ns_cti_file) if ns_cti_file else None, - cti_files=cti_finder.cti_files_as_list(ns_cti_files) if ns_cti_files else None, - include_env=False, - must_exist=True, - ) + for idx in range(limit): + if _canceled(): + break - if candidates: - return list(candidates) + info = infos[idx] + label = cls._label_from_info(info, idx) + device_id = cls._device_id_from_info(info) - # If auto cache is stale, fall back to discovery - if is_auto_cache: - LOG.info( - "Auto-persisted GenTL CTIs appear stale/missing; falling back to discovery. " - "Persisted cti_file=%s cti_files=%s", - ns_cti_file, - ns_cti_files, - ) - # Fall through to discovery (below) - else: - # User override: strict failure - raise RuntimeError( - "No valid GenTL producer (.cti) found from properties.gentl.cti_file/cti_files.\n\n" - f"Discovery details:\n{diag.summarize()}" + out.append( + DetectedCamera( + index=idx, + label=label, + device_id=device_id, + vid=None, + pid=None, + path=None, + backend_hint=None, + ) ) - # ------------------------------------------------------------ - # 3) Discovery path: env vars + patterns/dirs (source = "auto") - # ------------------------------------------------------------ - self._cti_files_source_used = self._CTI_FILES_SOURCE_AUTO - - search_paths = ns.get("cti_search_paths", props.get("cti_search_paths")) - extra_dirs = ns.get("cti_dirs", props.get("cti_dirs")) + if progress_cb: + progress_cb(f"Found: {label}") - candidates, diag = cti_finder.discover_cti_files( - cti_search_paths=cti_finder.cti_files_as_list(search_paths) if search_paths is not None else None, - include_env=True, - extra_dirs=cti_finder.cti_files_as_list(extra_dirs) if extra_dirs is not None else None, - recursive_env_search=False, - recursive_extra_search=False, - must_exist=True, - ) + out.sort(key=lambda c: c.index) + return out + except Exception: + LOG.debug("GenTL rich discovery failed", exc_info=True) + return [] + finally: + cls._safe_reset_harvester(harvester) - if not candidates: - raise RuntimeError( - "Could not locate any GenTL producer (.cti) file.\n\n" - "Fix options:\n" - " - Set camera.properties.gentl.cti_file to the full path of a .cti file\n" - " - Or set GENICAM_GENTL64_PATH / GENICAM_GENTL32_PATH to include the producer directory\n" - " - Or provide camera.properties.gentl.cti_search_paths with glob patterns\n\n" - f"Discovery details:\n{diag.summarize()}" - ) + @classmethod + def quick_ping(cls, index: int, _unused=None) -> bool: + """Fast presence check by index using a temporary discovery Harvester.""" + if Harvester is None: + return False - return list(candidates) + harvester = None + try: + harvester, _, _ = cls._build_harvester_for_discovery(strict_single=False) + if harvester is None: + return False + infos = harvester.device_info_list or [] + return 0 <= int(index) < len(infos) + except Exception: + return False + finally: + cls._safe_reset_harvester(harvester) @classmethod - def _build_harvester_for_discovery( - cls, - *, - strict_single: bool = False, # retained for optional future use - ): - """ - Build a Harvester instance and load CTI producers for class-level operations - (discover_devices, quick_ping, get_device_count, rebind_settings). - - Default policy: try to load ALL discovered producers. - """ + def _build_harvester_for_discovery(cls, *, strict_single: bool = False): + """Build a temporary Harvester for discovery-only operations.""" if Harvester is None: return None, [], None candidates, diag = cti_finder.discover_cti_files( include_env=True, - cti_search_paths=list(cls._LEGACY_DEFAULT_CTI_PATTERNS), + cti_search_paths=list(cls._DEFAULT_CTI_PATTERNS), must_exist=True, ) - if not candidates: return None, [], diag - # Default: load all candidates cti_files = list(candidates) - - # Optional strict mode (off by default) if strict_single: - # If you ever want strict, use choose_cti_files here; otherwise ignore. cti_files = cti_finder.choose_cti_files( - cti_files, policy=cti_finder.GenTLDiscoveryPolicy.RAISE_IF_MULTIPLE, max_files=1 + cti_files, + policy=cti_finder.GenTLDiscoveryPolicy.RAISE_IF_MULTIPLE, + max_files=1, ) harvester = Harvester() loaded: list[str] = [] - failures: list[tuple[str, str]] = [] for cti in cti_files: ok, reason = cls._cti_preflight(cti) if not ok: - failures.append((str(cti), reason or "Check failed")) LOG.warning("Skipping CTI '%s' during discovery preflight: %s", cti, reason) continue - try: harvester.add_file(cti) loaded.append(cti) except Exception as exc: - failures.append((str(cti), str(exc))) LOG.warning("Failed to load CTI '%s' during discovery: %s", cti, exc) if not loaded: - try: - harvester.reset() - except Exception: - pass + cls._safe_reset_harvester(harvester) return None, [], diag try: harvester.update() except Exception as exc: - LOG.error( - "Harvester.update() failed during discovery: %s" - " Device list not usable, treating as discovery failure." - " CTIs loaded before failure : %s", - exc, - loaded, - ) - try: - harvester.reset() - except Exception: - pass - # Update failure + LOG.error("Harvester.update() failed during discovery: %s. CTIs loaded: %s", exc, loaded) + cls._safe_reset_harvester(harvester) return None, [], diag return harvester, loaded, diag - def open(self) -> None: - if Harvester is None: # pragma: no cover - raise RuntimeError( - "The 'harvesters' package is required for the GenTL backend. Install it via 'pip install harvesters'." - ) + # ------------------------------------------------------------------ + # Settings rebinding + # ------------------------------------------------------------------ - # Ensure properties namespace exists for persistence back to UI - if not isinstance(self.settings.properties, dict): - self.settings.properties = {} - props = self.settings.properties - ns = props.get(self.OPTIONS_KEY, {}) + @classmethod + def rebind_settings(cls, settings): + """Map stable identity to current index when necessary. + + Serial identities are stable enough for open() to select directly, so + they intentionally avoid extra Harvester enumeration during multi-camera + startup. + """ + if Harvester is None: + return settings + + props = settings.properties if isinstance(settings.properties, dict) else {} + ns = props.get(cls.OPTIONS_KEY, {}) if not isinstance(ns, dict): ns = {} - props[self.OPTIONS_KEY] = ns - # Resolve CTIs (may return many). This no longer raises just because there are multiple. - cti_files = self._resolve_cti_files_for_settings() - ns["cti_files_source"] = ( - self._cti_files_source_used or ns.get("cti_files_source") or self._CTI_FILES_SOURCE_AUTO - ) + target_id = ns.get("device_id") or ns.get("serial_number") or ns.get("serial") + if not target_id: + return settings - self._harvester = Harvester() + target_id_str = str(target_id).strip() + if target_id_str.startswith("serial:"): + cls._persist_serial_identity(settings, target_id_str) + return settings - loaded: list[str] = [] - failed: list[tuple[str, str]] = [] + if target_id_str.startswith("fp:"): + return settings # open() will match by fingerprint via _select_device → _match_device - for cti in cti_files: - ok, reason = self._cti_preflight(cti) - if not ok: - failed.append((str(cti), reason or "preflight failed")) - LOG.warning("Skipping CTI '%s': %s", cti, reason) - continue + # Non-serial fallback retained for older configs / fingerprint IDs. + harvester = None + try: + explicit_files = ns.get("cti_files") or props.get("cti_files") + explicit_file = ns.get("cti_file") or props.get("cti_file") + source = str(ns.get("cti_files_source", "")).strip().lower() + is_auto_cache = source == cls._CTI_FILES_SOURCE_AUTO + + if explicit_files or explicit_file: + candidates, _ = cti_finder.discover_cti_files( + cti_file=explicit_file, + cti_files=cti_finder.cti_files_as_list(explicit_files), + include_env=False, + must_exist=True, + ) + if not candidates and is_auto_cache: + harvester, _, _ = cls._build_harvester_for_discovery(strict_single=False) + elif candidates: + harvester = Harvester() + loaded = [] + for cti in candidates: + try: + harvester.add_file(cti) + loaded.append(cti) + except Exception: + continue + if not loaded: + return settings + harvester.update() + else: + harvester, _, _ = cls._build_harvester_for_discovery(strict_single=False) + + if harvester is None: + return settings + + infos = list(harvester.device_info_list or []) + match_index, match_serial = cls._match_device(infos, target_id_str) + if match_index is None: + return settings + + settings.index = int(match_index) + ns2 = cls._ensure_ns_for_settings(settings) + ns2["device_id"] = target_id_str + if match_serial: + ns2["serial_number"] = str(match_serial) + return settings + except Exception: + return settings + finally: + cls._safe_reset_harvester(harvester) + # ------------------------------------------------------------------ + # Open / read / close + # ------------------------------------------------------------------ + + def open(self) -> None: + if Harvester is None: # pragma: no cover + raise RuntimeError( + "The 'harvesters' package is required for the GenTL backend. Install it via 'pip install harvesters'." + ) + + with type(self)._OPEN_LOCK: + loaded, failed = self._resolve_and_persist_ctis() try: - self._harvester.add_file(cti) - loaded.append(cti) + infos = self._acquire_shared_harvester(loaded) + if not infos: + self._reset_harvester() + raise RuntimeError( + "No GenTL cameras detected via Harvesters after loading producers.\n\n" + f"Loaded CTIs: {loaded}\n" + f"Failed CTIs: {failed}\n" + "Fix: ensure your camera vendor's GenTL producer is installed and working." + ) + + selected_index, selected_serial, selected_info = self._select_device(infos) + self.settings.index = int(selected_index) + + with self._shared_entry.lock: + self._acquirer = self._create_image_acquirer(selected_serial, int(selected_index)) + node_map = self._acquirer.remote_device.node_map + self._device_label = self._resolve_device_label(node_map) + + self._configure_pixel_format(node_map) + self._configure_resolution(node_map) + self._configure_exposure(node_map) + self._configure_gain(node_map) + self._configure_frame_rate(node_map) + self._configure_trigger(node_map) # keep low in the list + self._debug_trigger_nodes(node_map, context="after configuration before acquisition") + self._ensure_settings_ns()["trigger_actual"] = self._trigger_to_dict(self._trigger) + self._read_telemetry(node_map) + self._persist_device_metadata(selected_info, selected_serial) + + if self._fast_start: + LOG.info("GenTL open() in fast_start probe mode: acquisition not started.") + return + + self._acquirer.start() + + try: + self._read_telemetry(node_map) + self._debug_frame_rate_nodes(node_map, context="after starting acquisition") + except Exception: + LOG.warning( + "Failed to read telemetry after starting acquisition; some 'actual' values may be missing.", + exc_info=True, + ) + + LOG.debug( + "Opened GenTL camera index=%s serial=%s label=%s", + selected_index, + selected_serial, + self._device_label, + ) except Exception as exc: - failed.append((str(cti), str(exc))) - LOG.warning("Failed to load CTI '%s': %s", cti, exc) + try: + self.close() + except Exception: + pass + raise RuntimeError( + f"Failed to open GenTL camera.\n\nLoaded CTIs: {loaded}\nFailed CTIs: {failed}\nReason: {exc}" + ) from exc - # Persist diagnostics for UI / debugging - ns["cti_files"] = [str(p) for p in cti_files] # all resolved candidates - ns["cti_files_loaded"] = [str(p) for p in loaded] # successfully added to harvester - ns["cti_files_failed"] = [{"cti": c, "error": e} for c, e in failed] # load failures + @property + def waits_for_hardware_trigger(self) -> bool: + role = str(self._trigger_attr(getattr(self, "_trigger", None), "role", "off") or "off").lower() + return role in {"external", "follower"} - # Keep single-cti convenience key for backward compatibility / display + def read(self) -> tuple[np.ndarray, float]: + if self._acquirer is None: + raise RuntimeError("GenTL image acquirer not initialised") + + try: + with self._acquirer.fetch(timeout=self._timeout) as buffer: + component = buffer.payload.components[0] + channels = 3 if self._pixel_format in {"RGB8", "BGR8"} else 1 + array = np.asarray(component.data) + expected = component.height * component.width * channels + if array.size != expected: + array = np.frombuffer(bytes(component.data), dtype=array.dtype) + + try: + if channels > 1: + frame = array.reshape(component.height, component.width, channels).copy() + else: + frame = array.reshape(component.height, component.width).copy() + except ValueError: + frame = array.copy() + except HarvesterTimeoutError as exc: + if self.waits_for_hardware_trigger: + raise TimeoutError(str(exc) + " (GenTL timeout; waiting for hardware trigger?)") from exc + raise TimeoutError(str(exc) + " (GenTL timeout)") from exc + + frame = self._convert_frame(frame) + timestamp = time.time() + + if self._actual_width is None or self._actual_height is None: + h, w = frame.shape[:2] + self._actual_width = int(w) + self._actual_height = int(h) + + if self._actual_exposure is None or self._actual_gain is None: + try: + self._read_telemetry(self._acquirer.remote_device.node_map) + except Exception: + pass + + return frame, timestamp + + def stop(self) -> None: + if self._acquirer is not None: + try: + self._call_with_optional_lock(self._acquirer.stop) + except Exception: + pass + + def close(self) -> None: + if self._acquirer is not None: + try: + self._call_with_optional_lock(self._acquirer.stop) + except Exception: + pass + + try: + node_map = self._acquirer.remote_device.node_map + self._call_with_optional_lock(self._restore_trigger_idle, node_map) + except Exception: + pass + + try: + destroy = getattr(self._acquirer, "destroy", None) + if destroy is not None: + self._call_with_optional_lock(destroy) + finally: + self._acquirer = None + + if self._harvester is not None or self._shared_entry is not None: + self._reset_harvester() + + self._device_label = None + + # ------------------------------------------------------------------ + # CTI / shared Harvester helpers + # ------------------------------------------------------------------ + + def _resolve_and_persist_ctis(self) -> tuple[list[str], list[tuple[str, str]]]: + ns = self._ensure_settings_ns() + ns.setdefault("cti_search_paths", list(self._DEFAULT_CTI_PATTERNS)) + ns.setdefault("cti_files_source", self._CTI_FILES_SOURCE_AUTO) + + cti_files = self._resolve_cti_files_for_settings() + ns["cti_files_source"] = ( + self._cti_files_source_used or ns.get("cti_files_source") or self._CTI_FILES_SOURCE_AUTO + ) + + loaded: list[str] = [] + failed: list[tuple[str, str]] = [] + for cti in cti_files: + ok, reason = self._cti_preflight(cti) + if ok: + loaded.append(str(cti)) + else: + failed.append((str(cti), reason or "preflight failed")) + LOG.warning("Skipping CTI '%s': %s", cti, reason) + + ns["cti_files"] = [str(p) for p in cti_files] + ns["cti_files_loaded"] = loaded[:] + ns["cti_files_failed"] = [{"cti": c, "error": e} for c, e in failed] if loaded: - ns["cti_file"] = str(loaded[0]) + ns["cti_file"] = loaded[0] elif cti_files: - ns["cti_file"] = str(cti_files[0]) # best effort + ns["cti_file"] = str(cti_files[0]) if not loaded: self._reset_harvester() @@ -471,872 +698,1099 @@ def open(self) -> None: "No GenTL producer (.cti) could be loaded.\n\n" f"Resolved CTIs: {cti_files}\n" f"Failures: {failed}\n" - "Fix: remove/repair incompatible producers or " - "set properties.gentl.cti_file to a known working producer." + "Fix: remove/repair incompatible producers " + "or set properties.gentl.cti_file to a known working producer." ) - # Update device list after loading producers - self._harvester.update() + return loaded, failed + + def _acquire_shared_harvester(self, loaded: list[str]) -> list: + ns = self._ensure_settings_ns() + try: + self._shared_entry = cti_finder.SharedHarvesterPool.acquire(loaded) + self._harvester = self._shared_entry.harvester + + actual_loaded = list(getattr(self._shared_entry, "loaded_files", loaded)) + actual_failed = dict(getattr(self._shared_entry, "failed_files", {})) + + ns["cti_files_loaded"] = actual_loaded + if actual_failed: + existing_failed = ns.get("cti_files_failed") + merged_failed = list(existing_failed) if isinstance(existing_failed, list) else [] + merged_failed.extend({"cti": str(cti), "error": str(error)} for cti, error in actual_failed.items()) + ns["cti_files_failed"] = merged_failed + + with self._shared_entry.lock: + infos = list(self._harvester.device_info_list or []) + + LOG.debug( + "Using shared GenTL Harvester for %d device(s), refcount=%s", + len(infos), + cti_finder.SharedHarvesterPool.get_refcount(self._shared_entry), + ) + return infos + + except Exception as exc: + exc_loaded = list(getattr(exc, "loaded_files", [])) + exc_failed = dict(getattr(exc, "failed_files", {})) + + if exc_loaded or exc_failed: + ns["cti_files_loaded"] = [str(p) for p in exc_loaded] + existing_failed = ns.get("cti_files_failed") + merged_failed = list(existing_failed) if isinstance(existing_failed, list) else [] + merged_failed.extend({"cti": str(cti), "error": str(error)} for cti, error in exc_failed.items()) + ns["cti_files_failed"] = merged_failed + + if self._shared_entry is not None: + try: + cti_finder.SharedHarvesterPool.release(self._shared_entry) + except Exception: + pass + + self._shared_entry = None + self._harvester = None - if not self._harvester.device_info_list: - self._reset_harvester() raise RuntimeError( - "No GenTL cameras detected via Harvesters after loading producers.\n\n" - f"Loaded CTIs: {loaded}\n" - f"Failed CTIs: {failed}\n" - "Fix: ensure your camera vendor's GenTL producer is installed and working." + f"Failed to initialize shared GenTL producer state.\n\nCTIs: {loaded}\nReason: {exc}" + ) from exc + + def _reset_harvester(self) -> None: + try: + if self._shared_entry is not None: + cti_finder.SharedHarvesterPool.release(self._shared_entry) + self._shared_entry = None + else: + self._reset_select_harvester(self._harvester) + finally: + self._harvester = None + + @staticmethod + def _reset_select_harvester(harvester) -> None: + GenTLCameraBackend._safe_reset_harvester(harvester) + + @staticmethod + def _safe_reset_harvester(harvester) -> None: + if harvester is not None: + try: + harvester.reset() + except Exception: + pass + + @staticmethod + def _cti_preflight(path: str) -> tuple[bool, str | None]: + p = Path(str(path)) + try: + if not p.exists(): + return False, "missing at load time" + if not p.is_file(): + return False, "not a file at load time" + with p.open("rb"): + pass + return True, None + except PermissionError: + return False, "permission denied at load time" + except OSError as e: + return False, f"os error at load time: {e}" + + def _resolve_cti_files_for_settings(self) -> list[str]: + """Resolve CTI files using explicit user overrides, auto cache, then discovery.""" + props = self.settings.properties if isinstance(self.settings.properties, dict) else {} + ns = props.get(self.OPTIONS_KEY, {}) + if not isinstance(ns, dict): + ns = {} + + source = ns.get("cti_files_source") + source = str(source).strip().lower() if source is not None else None + + ns_cti_files = ns.get("cti_files") + ns_cti_file = ns.get("cti_file") + legacy_cti_files = props.get("cti_files") + legacy_cti_file = props.get("cti_file") + + if legacy_cti_files or legacy_cti_file: + self._cti_files_source_used = self._CTI_FILES_SOURCE_USER + candidates, diag = cti_finder.discover_cti_files( + cti_file=str(legacy_cti_file) if legacy_cti_file else None, + cti_files=cti_finder.cti_files_as_list(legacy_cti_files) if legacy_cti_files else None, + include_env=False, + must_exist=True, ) + if not candidates: + raise RuntimeError( + "No valid GenTL producer (.cti) found from properties.cti_file/cti_files.\n\n" + f"Discovery details:\n{diag.summarize()}" + ) + return list(candidates) + + if ns_cti_files or ns_cti_file: + is_auto_cache = source == self._CTI_FILES_SOURCE_AUTO + self._cti_files_source_used = self._CTI_FILES_SOURCE_AUTO if is_auto_cache else self._CTI_FILES_SOURCE_USER + candidates, diag = cti_finder.discover_cti_files( + cti_file=str(ns_cti_file) if ns_cti_file else None, + cti_files=cti_finder.cti_files_as_list(ns_cti_files) if ns_cti_files else None, + include_env=False, + must_exist=True, + ) + if candidates: + return list(candidates) + if not is_auto_cache: + raise RuntimeError( + "No valid GenTL producer (.cti) found from properties.gentl.cti_file/cti_files.\n\n" + f"Discovery details:\n{diag.summarize()}" + ) + LOG.info("Auto-persisted GenTL CTIs stale/missing; falling back to discovery.") + + self._cti_files_source_used = self._CTI_FILES_SOURCE_AUTO + search_paths = ns.get("cti_search_paths", props.get("cti_search_paths")) + extra_dirs = ns.get("cti_dirs", props.get("cti_dirs")) + search_patterns = ( + cti_finder.cti_files_as_list(search_paths) if search_paths is not None else list(self._DEFAULT_CTI_PATTERNS) + ) + + candidates, diag = cti_finder.discover_cti_files( + cti_search_paths=search_patterns, + include_env=True, + extra_dirs=cti_finder.cti_files_as_list(extra_dirs) if extra_dirs is not None else None, + recursive_env_search=False, + recursive_extra_search=False, + must_exist=True, + ) + if not candidates: + raise RuntimeError( + "Could not locate any GenTL producer (.cti) file.\n\n" + "Fix options:\n" + " - Set camera.properties.gentl.cti_file to the full path of a .cti file\n" + " - Or set GENICAM_GENTL64_PATH / GENICAM_GENTL32_PATH to include the producer directory\n" + " - Or provide camera.properties.gentl.cti_search_paths with glob patterns\n\n" + f"Discovery details:\n{diag.summarize(redact_env=False)}" + ) + return list(candidates) + + # ------------------------------------------------------------------ + # Device selection / identity helpers + # ------------------------------------------------------------------ + + def _select_device(self, infos: list) -> tuple[int, str | None, object]: + requested_index = int(self.settings.index or 0) + target_device_id = self._device_id or self._ensure_settings_ns().get("device_id") + + selected_index: int | None = None + selected_serial: str | None = None + + if target_device_id: + target = str(target_device_id).strip() + selected_index, selected_serial = self._match_device(infos, target) + if selected_index is None: + available = [str(self._info_get(i, "serial_number", "") or "").strip() for i in infos] + raise RuntimeError(f"GenTL device '{target}' not found. Available serials: {available}") + + elif self._serial_number: + serial = str(self._serial_number).strip() + selected_index, selected_serial = self._match_device(infos, serial) + if selected_index is None: + available = [str(self._info_get(i, "serial_number", "") or "").strip() for i in infos] + raise RuntimeError(f"GenTL camera with serial '{serial}' not found. Available serials: {available}") + + else: + if requested_index < 0 or requested_index >= len(infos): + raise RuntimeError(f"Camera index {requested_index} out of range for {len(infos)} GenTL device(s)") + selected_index = requested_index + serial = self._info_get(infos[selected_index], "serial_number", "") + selected_serial = str(serial).strip() if serial else None + + return int(selected_index), selected_serial, infos[int(selected_index)] + + @classmethod + def _match_device(cls, infos: list, target: str) -> tuple[int | None, str | None]: + if not target: + return None, None + + serial_target = target.split("serial:", 1)[1].strip() if target.startswith("serial:") else target + + for idx, info in enumerate(infos): + if cls._device_id_from_info(info) == target: + serial = cls._info_get(info, "serial_number", None) + return idx, str(serial).strip() if serial else None + + exact: list[tuple[int, str]] = [] + for idx, info in enumerate(infos): + sn = str(cls._info_get(info, "serial_number", "") or "").strip() + if sn == serial_target: + exact.append((idx, sn)) + if exact: + return exact[0] + + partial = [] + for idx, info in enumerate(infos): + sn = str(cls._info_get(info, "serial_number", "") or "").strip() + if serial_target and serial_target in sn: + partial.append((idx, sn)) + if len(partial) == 1: + return partial[0] + if len(partial) > 1: + raise RuntimeError( + f"Ambiguous GenTL serial match for '{serial_target}'. Candidates: {[sn for _, sn in partial]}" + ) + + return None, None + + @staticmethod + def _device_id_from_info(info) -> str | None: + serial = GenTLCameraBackend._first_info_value( + info, + "serial_number", + "SerialNumber", + "device_serial_number", + "sn", + "serial", + ) + if serial: + return f"serial:{serial}" + + parts = [] + for key, names in ( + ("vendor", ("vendor", "vendor_name", "manufacturer", "DeviceVendorName")), + ("model", ("model", "model_name", "DeviceModelName")), + ("user", ("user_defined_name", "user_id", "DeviceUserID", "DeviceUserId", "device_user_id")), + ("tl", ("tl_type", "transport_layer_type", "DeviceTLType")), + ("uid", ("id_", "id", "device_id", "uid", "guid", "mac_address", "interface_id", "display_name")), + ): + value = GenTLCameraBackend._first_info_value(info, *names) + if value: + parts.append(f"{key}={value}") + return "fp:" + "|".join(parts) if parts else None + + @staticmethod + def _first_info_value(info, *names: str) -> str | None: + for name in names: + value = GenTLCameraBackend._info_get(info, name, None) + if value is not None and str(value).strip(): + return str(value).strip() + return None + + @staticmethod + def _info_get(info, key: str, default=None): + try: + if hasattr(info, "get"): + value = info.get(key) + if value is not None: + return value + except Exception: + pass + try: + value = getattr(info, key, None) + if value is not None: + return value + except Exception: + pass + return default + + @staticmethod + def _label_from_info(info, index: int) -> str: + display = GenTLCameraBackend._info_get(info, "display_name", None) + if display: + return str(display).strip() + + vendor = str(GenTLCameraBackend._info_get(info, "vendor", "") or "").strip() + model = str(GenTLCameraBackend._info_get(info, "model", "") or "").strip() + serial = str(GenTLCameraBackend._info_get(info, "serial_number", "") or "").strip() + label = f"{vendor} {model}".strip() if (vendor or model) else f"GenTL device {index}" + return f"{label} ({serial})" if serial else label + + @staticmethod + def _serial_from_identity(device_id: str | None, legacy_serial) -> str | None: + if device_id: + did = str(device_id).strip() + if did.startswith("serial:"): + return did.split("serial:", 1)[1].strip() or None + if not did.startswith("fp:"): + return did + return str(legacy_serial).strip() if legacy_serial else None + + @classmethod + def _persist_serial_identity(cls, settings, device_id: str) -> None: + serial = device_id.split("serial:", 1)[1].strip() + if not serial: + return + ns = cls._ensure_ns_for_settings(settings) + ns["device_id"] = device_id + ns["serial_number"] = serial + + def _persist_device_metadata(self, selected_info, selected_serial: str | None) -> None: + ns = self._ensure_settings_ns() + computed_id = self._device_id_from_info(selected_info) + + if computed_id: + ns["device_id"] = computed_id + elif selected_serial: + ns["device_id"] = f"serial:{selected_serial}" - infos = list(self._harvester.device_info_list) + if selected_serial: + ns["serial_number"] = str(selected_serial) + ns["device_serial_number"] = str(selected_serial) - # Helper: robustly read device_info fields (dict-like or attribute-like) - def _info_get(info, key: str, default=None): - try: - if hasattr(info, "get"): - v = info.get(key) - if v is not None: - return v - except Exception: - pass - try: - v = getattr(info, key, None) - if v is not None: - return v - except Exception: - pass - return default + if self._device_label: + ns["device_name"] = str(self._device_label) - # ------------------------------------------------------------------ - # Device selection (stable device_id > serial > index) - # ------------------------------------------------------------------ - requested_index = int(self.settings.index or 0) - selected_index: int | None = None - selected_serial: str | None = None + for out_key, info_key in ( + ("device_display_name", "display_name"), + ("device_info_id", "id_"), + ("device_vendor", "vendor"), + ("device_model", "model"), + ("device_tl_type", "tl_type"), + ("device_user_defined_name", "user_defined_name"), + ("device_version", "version"), + ("device_access_status", "access_status"), + ): + value = self._info_get(selected_info, info_key, "") + ns[out_key] = value if out_key == "device_access_status" else str(value or "") - target_device_id = self._device_id or ns.get("device_id") or props.get("device_id") - if target_device_id: - target_device_id = str(target_device_id).strip() + @classmethod + def _ensure_ns_for_settings(cls, settings) -> dict: + if not isinstance(settings.properties, dict): + settings.properties = {} + ns = settings.properties.get(cls.OPTIONS_KEY, {}) + if not isinstance(ns, dict): + ns = {} + settings.properties[cls.OPTIONS_KEY] = ns + return ns - # Exact match against computed device_id - for idx, info in enumerate(infos): - try: - did = self._device_id_from_info(info) - except Exception: - did = None - if did and did == target_device_id: - selected_index = idx - selected_serial = _info_get(info, "serial_number", None) - selected_serial = str(selected_serial).strip() if selected_serial else None - break + def _ensure_settings_ns(self) -> dict: + return self._ensure_ns_for_settings(self.settings) - # If device_id is "serial:XXXX", match serial directly - if selected_index is None and target_device_id.startswith("serial:"): - serial_target = target_device_id.split("serial:", 1)[1].strip() - if serial_target: - exact = [] - for idx, info in enumerate(infos): - sn = _info_get(info, "serial_number", "") - sn = str(sn).strip() if sn is not None else "" - if sn == serial_target: - exact.append((idx, sn)) - if exact: - selected_index = exact[0][0] - selected_serial = exact[0][1] - else: - sub = [] - for idx, info in enumerate(infos): - sn = _info_get(info, "serial_number", "") - sn = str(sn).strip() if sn is not None else "" - if serial_target and serial_target in sn: - sub.append((idx, sn)) - if len(sub) == 1: - selected_index = sub[0][0] - selected_serial = sub[0][1] or None - elif len(sub) > 1: - candidates = [sn for _, sn in sub] - raise RuntimeError( - f"Ambiguous GenTL serial match for '{serial_target}'. Candidates: {candidates}" - ) - - # Legacy serial selection fallback - if selected_index is None: - serial = self._serial_number - if serial: - serial = str(serial).strip() - exact = [] - for idx, info in enumerate(infos): - sn = _info_get(info, "serial_number", "") - sn = str(sn).strip() if sn is not None else "" - if sn == serial: - exact.append((idx, sn)) - if exact: - selected_index = exact[0][0] - selected_serial = exact[0][1] - else: - sub = [] - for idx, info in enumerate(infos): - sn = _info_get(info, "serial_number", "") - sn = str(sn).strip() if sn is not None else "" - if serial and serial in sn: - sub.append((idx, sn)) - if len(sub) == 1: - selected_index = sub[0][0] - selected_serial = sub[0][1] or None - elif len(sub) > 1: - candidates = [sn for _, sn in sub] - raise RuntimeError(f"Ambiguous GenTL serial match for '{serial}'. Candidates: {candidates}") - else: - available = [str(_info_get(i, "serial_number", "")).strip() for i in infos] - raise RuntimeError(f"Camera with serial '{serial}' not found. Available cameras: {available}") - - # Index fallback - if selected_index is None: - device_count = len(infos) - if requested_index < 0 or requested_index >= device_count: - raise RuntimeError(f"Camera index {requested_index} out of range for {device_count} GenTL device(s)") - selected_index = requested_index - sn = _info_get(infos[selected_index], "serial_number", "") - selected_serial = str(sn).strip() if sn else None + # ------------------------------------------------------------------ + # Existing compatibility helpers + # ------------------------------------------------------------------ - # Update settings.index to actual selected index (UI stability) - self.settings.index = int(selected_index) - selected_info = infos[int(selected_index)] + def _call_with_optional_lock(self, func, *args, **kwargs): + if self._shared_entry is not None: + with self._shared_entry.lock: + return func(*args, **kwargs) + return func(*args, **kwargs) - # Create ImageAcquirer via Harvester.create(...) + def _create_image_acquirer(self, selected_serial: str | None, selected_index: int): + if self._harvester is None: + raise RuntimeError("Harvester is not initialized") try: if selected_serial: - self._acquirer = self._harvester.create({"serial_number": str(selected_serial)}) - else: - self._acquirer = self._harvester.create(int(selected_index)) + return self._harvester.create({"serial_number": str(selected_serial)}) + return self._harvester.create(int(selected_index)) except TypeError: if selected_serial: - self._acquirer = self._harvester.create({"serial_number": str(selected_serial)}) - else: - self._acquirer = self._harvester.create(index=int(selected_index)) + return self._harvester.create({"serial_number": str(selected_serial)}) + return self._harvester.create(index=int(selected_index)) - remote = self._acquirer.remote_device - node_map = remote.node_map + def _available_serials(self) -> list[str]: + assert self._harvester is not None + return [ + str(s).strip() + for s in (self._info_get(i, "serial_number", "") for i in self._harvester.device_info_list) + if s + ] + + def _create_acquirer(self, serial: str | None, index: int): + """Compatibility wrapper for older code/tests.""" + return self._create_image_acquirer(serial, index) + + # ------------------------------------------------------------------ + # Camera configuration helpers + # ------------------------------------------------------------------ + @staticmethod + def _node(node_map, name: str): + try: + return getattr(node_map, name) + except Exception: + return None - self._device_label = self._resolve_device_label(node_map) + @staticmethod + def _node_value(node_map, name: str, default=None): + """Best-effort read of a GenICam node value. - # Apply configuration - self._configure_pixel_format(node_map) - self._configure_resolution(node_map) - self._configure_exposure(node_map) - self._configure_gain(node_map) - self._configure_frame_rate(node_map) + Debug helpers must not make open() fail just because a value cannot be read. + Harvesters-style fake/test nodes usually expose `.value`; some SDK-style + nodes may expose `GetValue()`. + """ + node = GenTLCameraBackend._node(node_map, name) + if node is None: + return default - # Read back telemetry try: - self._actual_width = int(node_map.Width.value) - self._actual_height = int(node_map.Height.value) + return node.value except Exception: pass try: - self._actual_fps = float(node_map.ResultingFrameRate.value) + getter = getattr(node, "GetValue", None) + if getter is not None: + return getter() except Exception: - self._actual_fps = None + pass + return default + + @staticmethod + def _node_symbolics(node) -> list[str]: try: - self._actual_exposure = float(node_map.ExposureTime.value) + return list(getattr(node, "symbolics", []) or []) except Exception: - self._actual_exposure = None + return [] + @staticmethod + def _node_value(node_map, name: str, default=None): + """Best-effort read of a GenICam node value.""" try: - self._actual_gain = float(node_map.Gain.value) + node = getattr(node_map, name) except Exception: - self._actual_gain = None + return default - # Persist identity + metadata - computed_id = None try: - computed_id = self._device_id_from_info(selected_info) + return node.value except Exception: - computed_id = None - - if computed_id: - ns["device_id"] = computed_id - elif selected_serial: - ns["device_id"] = f"serial:{selected_serial}" - - if selected_serial: - ns["serial_number"] = str(selected_serial) - ns["device_serial_number"] = str(selected_serial) + return default - if self._device_label: - ns["device_name"] = str(self._device_label) + @classmethod + def _node_float(cls, node_map, *names: str, allow_zero: bool = False) -> float | None: + """Return the first positive float value from a list of GenICam node names.""" + for name in names: + value = cls._node_value(node_map, name, None) + try: + fvalue = float(value) + except Exception: + continue - ns["device_display_name"] = str(_info_get(selected_info, "display_name", "") or "") - ns["device_info_id"] = str(_info_get(selected_info, "id_", "") or "") - ns["device_vendor"] = str(_info_get(selected_info, "vendor", "") or "") - ns["device_model"] = str(_info_get(selected_info, "model", "") or "") - ns["device_tl_type"] = str(_info_get(selected_info, "tl_type", "") or "") - ns["device_user_defined_name"] = str(_info_get(selected_info, "user_defined_name", "") or "") - ns["device_version"] = str(_info_get(selected_info, "version", "") or "") - ns["device_access_status"] = _info_get(selected_info, "access_status", None) - - # Start acquisition unless fast_start - if getattr(self, "_fast_start", False): - LOG.info("GenTL open() in fast_start probe mode: acquisition not started.") - return + if fvalue > 0 or (allow_zero and fvalue == 0): + return fvalue - self._acquirer.start() + return None - @staticmethod - def _device_id_from_info(info) -> str | None: - """ - Build a stable-ish device identifier from Harvester device_info_list entries. - This helper supports both dict-like and attribute-like representations. - """ + @classmethod + def _node_str(cls, node_map, *names: str) -> str | None: + """Return the first non-empty string value from a list of GenICam node names.""" + for name in names: + value = cls._node_value(node_map, name, None) + if value is None: + continue - def _read(name: str): - # dict-like - try: - if hasattr(info, "get"): - v = info.get(name) # type: ignore[attr-defined] - if v is not None: - return v - except Exception: - pass - # attribute-like - try: - return getattr(info, name, None) - except Exception: - return None - - def _get(*names: str) -> str | None: - for n in names: - v = _read(n) - if v is None: - continue - s = str(v).strip() - if s: - return s - return None + text = str(value).strip() + if text: + return text - # Prefer serial if present (best stable key when available) - serial = _get("serial_number", "SerialNumber", "device_serial_number", "sn", "serial") - if serial: - return f"serial:{serial}" + return None - # Fallback components (best-effort; names may vary per producer) - vendor = _get("vendor", "vendor_name", "manufacturer", "DeviceVendorName") - model = _get("model", "model_name", "DeviceModelName") - user_id = _get("user_defined_name", "user_id", "DeviceUserID", "DeviceUserId", "device_user_id") - tl_type = _get("tl_type", "transport_layer_type", "DeviceTLType") + def _set_enum_node(self, node_map, name: str, value: str, *, strict: bool = False) -> bool: + node = self._node(node_map, name) + if node is None: + if strict: + raise RuntimeError(f"GenICam node '{name}' is not available") + LOG.debug("GenICam node '%s' is not available; skipping", name) + return False - unique = _get("id_", "id", "device_id", "uid", "guid", "mac_address", "interface_id", "display_name") + symbolics = self._node_symbolics(node) + if symbolics and value not in symbolics: + if strict: + raise RuntimeError(f"GenICam node '{name}' does not support '{value}'. Available: {symbolics}") + LOG.warning("GenICam node '%s' does not support '%s'. Available: %s", name, value, symbolics) + return False - parts = [] - for k, v in (("vendor", vendor), ("model", model), ("user", user_id), ("tl", tl_type), ("uid", unique)): - if v: - parts.append(f"{k}={v}") + try: + node.value = value + return True + except Exception as exc: + if strict: + raise RuntimeError(f"Failed to set GenICam node '{name}' to '{value}': {exc}") from exc + LOG.warning("Failed to set GenICam node '%s' to '%s': %s", name, value, exc) + return False - if not parts: - return None + @staticmethod + def _trigger_attr(trigger, name: str, default=None): + if isinstance(trigger, dict): + return trigger.get(name, default) + return getattr(trigger, name, default) - return "fp:" + "|".join(parts) + @staticmethod + def _trigger_to_dict(trigger) -> dict[str, Any]: + if trigger is None: + return {} + if isinstance(trigger, dict): + return dict(trigger) + if hasattr(trigger, "model_dump"): + try: + return trigger.model_dump(exclude_none=True) + except Exception: + pass + return {} - @classmethod - def discover_devices( - cls, - *, - max_devices: int = 10, - should_cancel: callable[[], bool] | None = None, - progress_cb: callable[[str], None] | None = None, - ): - """ - Rich discovery path for CameraFactory.detect_cameras(). - Returns a list of DetectedCamera with device_id filled when possible. + def _resolve_trigger_source(self, node_map, requested: str, *, strict: bool) -> tuple[str, bool]: + """Resolve TriggerSource against the camera-supported GenICam enum values. - Cross-platform CTI discovery: - - Uses GENICAM_GENTL64_PATH / GENICAM_GENTL32_PATH when available - - Falls back to built-in Windows patterns - - Best-effort loads multiple CTI producers + Model-level default is "auto"; this backend maps it to the first preferred + source supported by the actual camera. """ - if Harvester is None: - return [] + requested = str(requested or "auto").strip() + node = self._node(node_map, "TriggerSource") + available = self._node_symbolics(node) + + if not available: + if strict: + raise RuntimeError("GenICam node 'TriggerSource' is not available or has no symbolics") + LOG.warning("GenICam node 'TriggerSource' is not available; disabling trigger input.") + return requested, False + + if requested in available: + return requested, True + + if requested.lower() == "auto": + for candidate in ("Line0", "Line1", "Line2", "Any"): + if candidate in available: + LOG.info( + "GenTL TriggerSource auto-selected '%s'. Available: %s", + candidate, + available, + ) + return candidate, True - def _canceled() -> bool: - return bool(should_cancel and should_cancel()) + LOG.warning( + "Could not auto-select a GenTL TriggerSource. Available: %s", + available, + ) + return requested, False - harvester = None - try: - if progress_cb: - progress_cb("Initializing GenTL discovery…") + if strict: + raise RuntimeError(f"GenICam node 'TriggerSource' does not support '{requested}'. Available: {available}") - harvester, loaded, _ = cls._build_harvester_for_discovery(strict_single=False) + LOG.warning( + "GenTL TriggerSource '%s' is not available. Available: %s", + requested, + available, + ) + return requested, False - if harvester is None or not loaded: - if progress_cb: - progress_cb("No GenTL producers could be loaded.") - return [] + def _configure_pixel_format(self, node_map) -> None: + try: + pixel_format_node = getattr(node_map, "PixelFormat", None) + if pixel_format_node is None: + return - if progress_cb: - progress_cb(f"Loaded {len(loaded)} GenTL producer(s). Scanning devices…") + available = list(getattr(pixel_format_node, "symbolics", []) or []) + if not available: + return - infos = list(harvester.device_info_list or []) - if not infos: - return [] + requested = str(self._pixel_format or "auto").strip() - out: list[DetectedCamera] = [] - limit = min(len(infos), max_devices if max_devices > 0 else len(infos)) + if requested.lower() == "auto": + selected = None - for idx in range(limit): - if _canceled(): - break + for fmt in self._COLOR_PIXEL_FORMATS: + if fmt in available: + selected = fmt + break - info = infos[idx] + if selected is None: + for fmt in self._MONO_PIXEL_FORMATS: + if fmt in available: + selected = fmt + break - display_name = None - try: - display_name = ( - info.get("display_name") if hasattr(info, "get") else getattr(info, "display_name", None) - ) - except Exception: - display_name = None + if selected is None: + selected = available[0] - if display_name: - label = str(display_name).strip() - else: - vendor = ( - getattr(info, "vendor", None) or (info.get("vendor") if hasattr(info, "get") else None) or "" - ) - model = getattr(info, "model", None) or (info.get("model") if hasattr(info, "get") else None) or "" - serial = ( - getattr(info, "serial_number", None) - or (info.get("serial_number") if hasattr(info, "get") else None) - or "" + else: + selected = requested + if selected not in available: + LOG.warning( + "Pixel format '%s' not available. Available formats: %s. Falling back to auto.", + selected, + available, ) - vendor, model, serial = str(vendor).strip(), str(model).strip(), str(serial).strip() - label = f"{vendor} {model}".strip() if (vendor or model) else f"GenTL device {idx}" - if serial: - label = f"{label} ({serial})" + selected = None + for fmt in self._COLOR_PIXEL_FORMATS + self._MONO_PIXEL_FORMATS: + if fmt in available: + selected = fmt + break + if selected is None: + selected = available[0] - device_id = cls._device_id_from_info(info) + pixel_format_node.value = selected + self._pixel_format = str(pixel_format_node.value) - out.append( - DetectedCamera( - index=idx, - label=label, - device_id=device_id, - vid=None, - pid=None, - path=None, - backend_hint=None, - ) - ) + LOG.debug("GenTL pixel format selected: %s", self._pixel_format) - if progress_cb: - progress_cb(f"Found: {label}") + except Exception as e: + LOG.warning("Failed to configure pixel format '%s': %s", self._pixel_format, e) - out.sort(key=lambda c: c.index) - return out + def _configure_trigger(self, node_map) -> None: + cfg = self._trigger + role = str(self._trigger_attr(cfg, "role", "off") or "off").strip().lower() + strict = bool(self._trigger_attr(cfg, "strict", False)) - except Exception: - return [] - finally: - if harvester is not None: - try: - harvester.reset() - except Exception: - pass + if role in {"off", "disabled"}: + self._configure_trigger_off(node_map, strict=strict) + return - @classmethod - def rebind_settings(cls, settings): - """ - If a stable identity exists in settings.properties['gentl'], map it to the - correct current index (and serial_number if available). - - Strategy: - - If CTIs were persisted: - * if source == "auto" and they are stale -> fall back to discovery - * otherwise use them (best stability) - - Otherwise, fall back to env-var + pattern discovery (best-effort). - """ - if Harvester is None: - return settings + if role in {"external", "follower"}: + self._configure_trigger_input(node_map, cfg, strict=strict) + return - props = settings.properties if isinstance(settings.properties, dict) else {} - ns = props.get(cls.OPTIONS_KEY, {}) - if not isinstance(ns, dict): - ns = {} + if role == "master": + self._configure_trigger_master(node_map, cfg, strict=strict) + return - target_id = ns.get("device_id") or ns.get("serial_number") or ns.get("serial") - if not target_id: - return settings + if strict: + raise RuntimeError(f"Unsupported GenTL trigger role: {role!r}") - source = ns.get("cti_files_source") - source = str(source).strip().lower() if source is not None else None - is_auto_cache = source == cls._CTI_FILES_SOURCE_AUTO + LOG.warning("Unsupported GenTL trigger role '%s'; disabling trigger.", role) + self._configure_trigger_off(node_map, strict=False) - harvester = None - try: - explicit_files = ns.get("cti_files") or props.get("cti_files") - explicit_file = ns.get("cti_file") or props.get("cti_file") + def _configure_trigger_off(self, node_map, *, strict: bool = False) -> None: + self._set_enum_node(node_map, "TriggerMode", "Off", strict=strict) - if explicit_files or explicit_file: - candidates, _diag = cti_finder.discover_cti_files( - cti_file=explicit_file, - cti_files=cti_finder.cti_files_as_list(explicit_files), - include_env=False, - must_exist=True, - ) + def _configure_trigger_input(self, node_map, cfg, *, strict: bool = False) -> None: + role = str(self._trigger_attr(cfg, "role", "external") or "external").strip().lower() + selector = str(self._trigger_attr(cfg, "selector", "FrameStart") or "FrameStart") + activation = str(self._trigger_attr(cfg, "activation", "RisingEdge") or "RisingEdge") + source = str(self._trigger_attr(cfg, "source", "auto") or "auto").strip() - if not candidates and is_auto_cache: - # Auto cache stale -> fallback to discovery - harvester, _loaded, _diag2 = cls._build_harvester_for_discovery(strict_single=False) - if harvester is None: - return settings - elif not candidates: - # User override stale or unknown -> no rebind - return settings - else: - harvester = Harvester() - loaded: list[str] = [] - for cti in candidates: - try: - harvester.add_file(cti) - loaded.append(cti) - except Exception: - continue - if not loaded: - cls._reset_select_harvester(harvester) - if is_auto_cache: - harvester, _loaded, _diag2 = cls._build_harvester_for_discovery(strict_single=False) - if harvester is None: - return settings - else: - return settings - else: - harvester.update() - else: - harvester, _loaded, _diag = cls._build_harvester_for_discovery(strict_single=False) - if harvester is None: - return settings + # Disable trigger while changing trigger-related nodes. + self._set_enum_node(node_map, "TriggerMode", "Off", strict=False) - infos = list(harvester.device_info_list or []) - if not infos: - return settings + selector_ok = self._set_enum_node(node_map, "TriggerSelector", selector, strict=strict) - target_id_str = str(target_id).strip() - match_index = None - match_serial = None + resolved_source, source_supported = self._resolve_trigger_source( + node_map, + source, + strict=strict, + ) - # 1) Exact match by computed device_id - for idx, info in enumerate(infos): - dev_id = cls._device_id_from_info(info) - if dev_id and dev_id == target_id_str: - match_index = idx - match_serial = getattr(info, "serial_number", None) - break + source_ok = False + if source_supported: + source_ok = self._set_enum_node( + node_map, + "TriggerSource", + resolved_source, + strict=strict, + ) - # 2) Fallback: treat target as serial-ish substring - if match_index is None: - for idx, info in enumerate(infos): - serial = getattr(info, "serial_number", None) - if serial and target_id_str in str(serial): - match_index = idx - match_serial = serial - break + activation_ok = self._set_enum_node( + node_map, + "TriggerActivation", + activation, + strict=False, + ) - if match_index is None: - return settings + # TriggerSelector and TriggerSource are required routing nodes. + # If either failed in non-strict mode, do not arm TriggerMode=On. + # Otherwise the camera may wait on a previous/default input line. + if not (selector_ok and source_ok): + LOG.warning( + "Could not apply GenTL trigger input routing " + "(selector_ok=%s, source_ok=%s); disabling trigger. " + "requested role=%s selector=%s source=%s resolved_source=%s activation=%s", + selector_ok, + source_ok, + role, + selector, + source, + resolved_source, + activation, + ) + self._configure_trigger_off(node_map, strict=False) + self._trigger = CameraTriggerSettings() + return - # Apply rebinding - settings.index = int(match_index) + if not activation_ok: + LOG.warning( + "Could not apply GenTL TriggerActivation=%s; using camera default/current activation.", + activation, + ) - # Ensure namespace exists - if not isinstance(settings.properties, dict): - settings.properties = {} - ns2 = settings.properties.setdefault(cls.OPTIONS_KEY, {}) - if not isinstance(ns2, dict): - ns2 = {} - settings.properties[cls.OPTIONS_KEY] = ns2 + self._set_enum_node(node_map, "AcquisitionMode", "Continuous", strict=False) - if match_serial: - ns2["serial_number"] = str(match_serial) - ns2["device_id"] = target_id_str + if not self._set_enum_node(node_map, "TriggerMode", "On", strict=strict): + LOG.warning("Could not enable GenTL TriggerMode=On; disabling trigger.") + self._configure_trigger_off(node_map, strict=False) + self._trigger = CameraTriggerSettings() + return - return settings + LOG.info( + "GenTL trigger input configured: role=%s selector=%s source_requested=%s " + "source=%s activation=%s selector_ok=%s source_ok=%s activation_ok=%s", + role, + selector, + source, + resolved_source, + activation, + selector_ok, + source_ok, + activation_ok, + ) - except Exception: - return settings - finally: - if harvester is not None: - try: - harvester.reset() - except Exception: - pass + def _configure_trigger_master(self, node_map, cfg, *, strict: bool = False) -> None: + """Configure this camera as a free-running master that emits STROBE_OUT pulses. - @classmethod - def quick_ping(cls, index: int, _unused=None) -> bool: + For DMK 37BUX287 / TIS 37U series, the physical output is controlled by + StrobeEnable/StrobePolarity/StrobeOperation rather than SFNC LineSelector/ + LineMode/LineSource nodes. """ - Fast check: is there a device at this index according to Harvester? - Does not open/start acquisition. - """ - if Harvester is None: - return False + output_line = str(self._trigger_attr(cfg, "output_line", "Line2") or "Line2") + output_source = str(self._trigger_attr(cfg, "output_source", "ExposureActive") or "ExposureActive") - harvester = None - try: - harvester, _, _ = cls._build_harvester_for_discovery(strict_single=False) - if harvester is None: - return False - infos = harvester.device_info_list or [] - return 0 <= int(index) < len(infos) - except Exception: - return False - finally: - if harvester is not None: - try: - harvester.reset() - except Exception: - pass + # Optional extra fields if present in trigger dict/model. + strobe_polarity = str(self._trigger_attr(cfg, "strobe_polarity", "ActiveHigh") or "ActiveHigh") + strobe_operation = str(self._trigger_attr(cfg, "strobe_operation", "Exposure") or "Exposure") + strobe_duration = self._trigger_attr(cfg, "strobe_duration", None) + strobe_delay = self._trigger_attr(cfg, "strobe_delay", None) + + # Master camera should be free-running. + self._configure_trigger_off(node_map, strict=False) + + # ------------------------------------------------------------------ + # Preferred path for The Imaging Source 37U / DMK 37BUX287: + # StrobeEnable, StrobePolarity, StrobeOperation, StrobeDuration, StrobeDelay + # ------------------------------------------------------------------ + strobe_enable_node = self._node(node_map, "StrobeEnable") - def read(self) -> tuple[np.ndarray, float]: - if self._acquirer is None: - raise RuntimeError("GenTL image acquirer not initialised") + if strobe_enable_node is not None: + # Disable first while changing parameters. + self._set_enum_node(node_map, "StrobeEnable", "Off", strict=False) - try: - with self._acquirer.fetch(timeout=self._timeout) as buffer: - component = buffer.payload.components[0] - channels = 3 if self._pixel_format in {"RGB8", "BGR8"} else 1 - array = np.asarray(component.data) - expected = component.height * component.width * channels - if array.size != expected: - array = np.frombuffer(bytes(component.data), dtype=array.dtype) - try: - if channels > 1: - frame = array.reshape(component.height, component.width, channels).copy() - else: - frame = array.reshape(component.height, component.width).copy() - except ValueError: - frame = array.copy() - except HarvesterTimeoutError as exc: - raise TimeoutError(str(exc) + " (GenTL timeout)") from exc + polarity_ok = self._set_enum_node( + node_map, + "StrobePolarity", + strobe_polarity, + strict=False, + ) - frame = self._convert_frame(frame) - timestamp = time.time() + operation_ok = self._set_enum_node( + node_map, + "StrobeOperation", + strobe_operation, + strict=False, + ) - if self._actual_width is None or self._actual_height is None: - h, w = frame.shape[:2] - self._actual_width = int(w) - self._actual_height = int(h) + if strobe_duration is not None: + try: + node = self._node(node_map, "StrobeDuration") + if node is not None: + node.value = int(strobe_duration) + LOG.info("Configured GenTL StrobeDuration=%s", int(strobe_duration)) + except Exception as exc: + if strict: + raise RuntimeError(f"Failed to set StrobeDuration={strobe_duration}: {exc}") from exc + LOG.warning("Failed to set StrobeDuration=%s: %s", strobe_duration, exc) - if self._actual_exposure is None: - try: - self._actual_exposure = float(self._acquirer.node_map.ExposureTime.value) - except Exception: - self._actual_exposure = None + if strobe_delay is not None: + try: + node = self._node(node_map, "StrobeDelay") + if node is not None: + node.value = int(strobe_delay) + LOG.info("Configured GenTL StrobeDelay=%s", int(strobe_delay)) + except Exception as exc: + if strict: + raise RuntimeError(f"Failed to set StrobeDelay={strobe_delay}: {exc}") from exc + LOG.warning("Failed to set StrobeDelay=%s: %s", strobe_delay, exc) + + enable_ok = self._set_enum_node( + node_map, + "StrobeEnable", + "On", + strict=strict, + ) - if self._actual_gain is None: - try: - self._actual_gain = float(self._acquirer.node_map.Gain.value) - except Exception: - self._actual_gain = None + if enable_ok: + LOG.info( + "GenTL trigger master configured via Strobe*: " + "StrobeEnable=On StrobePolarity=%s polarity_ok=%s " + "StrobeOperation=%s operation_ok=%s", + strobe_polarity, + polarity_ok, + strobe_operation, + operation_ok, + ) + return - return frame, timestamp + if strict: + raise RuntimeError("Could not enable GenTL StrobeEnable=On") - def stop(self) -> None: - if self._acquirer is not None: - try: - self._acquirer.stop() - except Exception: - pass + LOG.warning( + "StrobeEnable node exists but could not be enabled; falling back to generic Line* output configuration." + ) - @staticmethod - def _reset_select_harvester(harvester) -> None: - if harvester is not None: - try: - harvester.reset() - except Exception: - pass + # ------------------------------------------------------------------ + # Generic SFNC fallback for cameras that expose LineSelector/LineMode/LineSource. + # ------------------------------------------------------------------ + line_selector = self._node(node_map, "LineSelector") + if line_selector is not None: + line_selected = self._set_enum_node( + node_map, + "LineSelector", + output_line, + strict=strict, + ) - def _reset_harvester(self) -> None: - try: - self._reset_select_harvester(self._harvester) - finally: - self._harvester = None + if not line_selected: + LOG.warning( + "Could not select GenTL output line '%s'; skipping Line* output configuration.", + output_line, + ) + else: + mode_ok = self._set_enum_node(node_map, "LineMode", "Output", strict=strict) + source_ok = self._set_enum_node(node_map, "LineSource", output_source, strict=strict) + + if mode_ok and source_ok: + LOG.info( + "GenTL trigger master configured via Line*: output_line=%s output_source=%s", + output_line, + output_source, + ) + return - def close(self) -> None: - if self._acquirer is not None: - try: - self._acquirer.stop() - except Exception: - pass - try: - destroy = getattr(self._acquirer, "destroy", None) - if destroy is not None: - destroy() - finally: - self._acquirer = None + LOG.warning( + "GenTL Line* trigger output configuration incomplete (LineMode ok=%s, LineSource ok=%s).", + mode_ok, + source_ok, + ) - if self._harvester is not None: - try: - self._harvester.reset() - finally: - self._harvester = None + msg = ( + "Could not configure GenTL trigger master output. " + "No supported Strobe* or Line* output path was successfully configured." + ) - self._device_label = None + if strict: + raise RuntimeError(msg) - # ------------------------------------------------------------------ - # Helpers - # ------------------------------------------------------------------ + LOG.warning(msg) - def _parse_crop(self, crop) -> tuple[int, int, int, int] | None: - if isinstance(crop, (list, tuple)) and len(crop) == 4: - return tuple(int(v) for v in crop) - return None + def _restore_trigger_idle(self, node_map) -> None: + """Best-effort restore to a safe non-triggering state after acquisition stops. - def _get_requested_resolution_or_none(self) -> tuple[int, int] | None: + Important: + - This should be called after acquirer.stop(), not while acquisition is active. + - It is intentionally non-strict because shutdown should not fail if a node + is missing or read-only. """ - Return (w, h) if user explicitly requested a resolution. - Return None to keep device defaults. - """ - props = self.settings.properties if isinstance(self.settings.properties, dict) else {} - - legacy = props.get("resolution") - if isinstance(legacy, (list, tuple)) and len(legacy) == 2: - try: - w, h = int(legacy[0]), int(legacy[1]) - if w > 0 and h > 0: - return (w, h) - except Exception: - pass + role = str(self._trigger_attr(getattr(self, "_trigger", None), "role", "off") or "off").lower() try: - w = int(getattr(self.settings, "width", 0) or 0) - h = int(getattr(self.settings, "height", 0) or 0) - if w > 0 and h > 0: - return (w, h) - except Exception: - pass + if role in {"external", "follower"}: + self._set_enum_node(node_map, "TriggerMode", "Off", strict=False) - return None + elif role == "master": + # Stop driving output if the camera exposes these nodes. + self._set_enum_node(node_map, "LineSource", "Off", strict=False) + self._set_enum_node(node_map, "LineMode", "Input", strict=False) + + except Exception: + LOG.debug("Best-effort GenTL trigger restore failed", exc_info=True) def _configure_resolution(self, node_map) -> None: - """ - Configure camera resolution only if explicitly requested. - If None, keep device defaults. - """ - req = self._requested_resolution - if req is None: - LOG.info("Resolution: using device default.") + if self._requested_resolution is None: return - requested_width, requested_height = req + requested_width, requested_height = self._requested_resolution actual_width, actual_height = None, None - # Width try: node = node_map.Width - min_w, max_w = node.min, node.max - inc_w = getattr(node, "inc", 1) - width = self._adjust_to_increment(requested_width, min_w, max_w, inc_w) + width = self._adjust_to_increment(requested_width, node.min, node.max, getattr(node, "inc", 1)) node.value = int(width) - actual_width = node.value + actual_width = int(node.value) except Exception as e: - LOG.warning(f"Failed to set width: {e}") + LOG.warning("Failed to set width: %s", e) - # Height try: node = node_map.Height - min_h, max_h = node.min, node.max - inc_h = getattr(node, "inc", 1) - height = self._adjust_to_increment(requested_height, min_h, max_h, inc_h) + height = self._adjust_to_increment(requested_height, node.min, node.max, getattr(node, "inc", 1)) node.value = int(height) - actual_height = node.value + actual_height = int(node.value) except Exception as e: - LOG.warning(f"Failed to set height: {e}") + LOG.warning("Failed to set height: %s", e) if actual_width is not None and actual_height is not None: - self._actual_width = int(actual_width) - self._actual_height = int(actual_height) + self._actual_width = actual_width + self._actual_height = actual_height if (actual_width, actual_height) != (requested_width, requested_height): LOG.warning( - f"Resolution mismatch: requested {requested_width}x{requested_height}, " - f"got {actual_width}x{actual_height}" - ) - else: - LOG.info(f"Resolution set to {actual_width}x{actual_height}") - - def _available_serials(self) -> list[str]: - assert self._harvester is not None - serials: list[str] = [] - for info in self._harvester.device_info_list: - serial = getattr(info, "serial_number", "") - if serial: - serials.append(serial) - return serials - - def _create_acquirer(self, serial: str | None, index: int): - assert self._harvester is not None - methods = [ - getattr(self._harvester, "create", None), - getattr(self._harvester, "create_image_acquirer", None), - ] - methods = [m for m in methods if m is not None] - errors: list[str] = [] - device_info = None - if not serial: - device_list = self._harvester.device_info_list - if 0 <= index < len(device_list): - device_info = device_list[index] - for create in methods: - try: - if serial: - return create({"serial_number": serial}) - except Exception as exc: - errors.append(f"{create.__name__} serial: {exc}") - for create in methods: - try: - return create(index=index) - except TypeError: - try: - return create(index) - except Exception as exc: - errors.append(f"{create.__name__} index positional: {exc}") - except Exception as exc: - errors.append(f"{create.__name__} index: {exc}") - if device_info is not None: - for create in methods: - try: - return create(device_info) - except Exception as exc: - errors.append(f"{create.__name__} device_info: {exc}") - if not serial and index == 0: - for create in methods: - try: - return create() - except Exception as exc: - errors.append(f"{create.__name__} default: {exc}") - joined = "; ".join(errors) or "no creation methods available" - raise RuntimeError(f"Failed to initialise GenTL image acquirer ({joined})") - - def _configure_pixel_format(self, node_map) -> None: - try: - if self._pixel_format in node_map.PixelFormat.symbolics: - node_map.PixelFormat.value = self._pixel_format - actual = node_map.PixelFormat.value - if actual != self._pixel_format: - LOG.warning(f"Pixel format mismatch: requested '{self._pixel_format}', got '{actual}'") - else: - LOG.info(f"Pixel format set to '{actual}'") - else: - LOG.warning( - f"Pixel format '{self._pixel_format}' not in available formats: {node_map.PixelFormat.symbolics}" + "Resolution mismatch: requested %sx%s, got %sx%s", + requested_width, + requested_height, + actual_width, + actual_height, ) - except Exception as e: - LOG.warning(f"Failed to set pixel format '{self._pixel_format}': {e}") def _configure_exposure(self, node_map) -> None: if self._exposure is None: return - # Try to disable auto exposure first - for attr in ("ExposureAuto",): - try: - node = getattr(node_map, attr) - node.value = "Off" - LOG.info("Auto exposure disabled") - break - except AttributeError: - continue - except Exception as e: - LOG.warning(f"Failed to disable auto exposure: {e}") + try: + node_map.ExposureAuto.value = "Off" + except Exception: + pass - # Set exposure value for attr in ("ExposureTime", "Exposure"): try: node = getattr(node_map, attr) - except AttributeError: - continue - try: node.value = float(self._exposure) - actual = node.value - if abs(actual - self._exposure) > 1.0: # Allow 1μs tolerance - LOG.warning(f"Exposure mismatch: requested {self._exposure}μs, got {actual}μs") - else: - LOG.info(f"Exposure set to {actual}μs") return - except Exception as e: - LOG.warning(f"Failed to set exposure via {attr}: {e}") + except AttributeError: continue - - LOG.warning(f"Could not set exposure to {self._exposure}μs (no compatible attribute found)") + except Exception as e: + LOG.warning("Failed to set exposure via %s: %s", attr, e) + LOG.warning("Could not set exposure to %s µs", self._exposure) def _configure_gain(self, node_map) -> None: if self._gain is None: return - # Try to disable auto gain first - for attr in ("GainAuto",): - try: - node = getattr(node_map, attr) - node.value = "Off" - LOG.info("Auto gain disabled") - break - except AttributeError: - continue - except Exception as e: - LOG.warning(f"Failed to disable auto gain: {e}") - - # Set gain value - for attr in ("Gain",): - try: - node = getattr(node_map, attr) - except AttributeError: - continue - try: - node.value = float(self._gain) - actual = node.value - if abs(actual - self._gain) > 0.1: # Allow 0.1 tolerance - LOG.warning(f"Gain mismatch: requested {self._gain}, got {actual}") - else: - LOG.info(f"Gain set to {actual}") - return - except Exception as e: - LOG.warning(f"Failed to set gain via {attr}: {e}") - continue + try: + node_map.GainAuto.value = "Off" + except Exception: + pass - LOG.warning(f"Could not set gain to {self._gain} (no compatible attribute found)") + try: + node_map.Gain.value = float(self._gain) + except Exception as e: + LOG.warning("Could not set gain to %s: %s", self._gain, e) def _configure_frame_rate(self, node_map) -> None: if not self.settings.fps: return target = float(self.settings.fps) + LOG.info("Configuring GenTL frame rate: requested %.3f FPS", target) - # Try to enable frame rate control for attr in ("AcquisitionFrameRateEnable", "AcquisitionFrameRateControlEnable"): try: - getattr(node_map, attr).value = True - LOG.info(f"Frame rate control enabled via {attr}") + node = getattr(node_map, attr) + before = getattr(node, "value", None) + node.value = True + after = getattr(node, "value", None) + LOG.info("Enabled GenTL %s: before=%r after=%r", attr, before, after) break except Exception: - continue + pass - # Set frame rate value - for attr in ("AcquisitionFrameRate", "ResultingFrameRate", "AcquisitionFrameRateAbs"): + for attr in ("AcquisitionFrameRate", "AcquisitionFrameRateAbs"): try: node = getattr(node_map, attr) - except AttributeError: - continue - try: + before = getattr(node, "value", None) node.value = target - actual = node.value - if abs(actual - target) > 0.1: - LOG.warning(f"FPS mismatch: requested {target:.2f}, got {actual:.2f}") - else: - LOG.info(f"Frame rate set to {actual:.2f} FPS") + after = getattr(node, "value", None) + + LOG.info( + "Set GenTL %s: before=%r requested=%.3f after=%r", + attr, + before, + target, + after, + ) + + try: + accepted = float(after) + if accepted > 0: + self._actual_fps = accepted + except Exception: + pass + return - except Exception as e: - LOG.warning(f"Failed to set frame rate via {attr}: {e}") + + except AttributeError: continue + except Exception as e: + LOG.warning("Failed to set frame rate via %s: %s", attr, e) + + LOG.warning("Could not set frame rate to %s FPS", target) + + def _read_telemetry(self, node_map) -> None: + try: + self._actual_width = int(node_map.Width.value) + self._actual_height = int(node_map.Height.value) + except Exception: + pass + + # Prefer true/resulting frame-rate readback nodes. + resulting_fps = self._node_float( + node_map, + "AcquisitionResultingFrameRate", + "ResultingFrameRate", + "AcquisitionFrameRateResulting", + "DeviceFrameRate", + ) + + # Fallback to requested/accepted frame-rate nodes only if no resulting node exists. + requested_fps = self._node_float( + node_map, + "AcquisitionFrameRate", + "AcquisitionFrameRateAbs", + ) + + if resulting_fps is not None: + self._actual_fps = resulting_fps + elif requested_fps is not None: + self._actual_fps = requested_fps + + exposure = self._node_float( + node_map, + "ExposureTime", + "ExposureTimeAbs", + "Exposure", + allow_zero=True, + ) + if exposure is not None: + self._actual_exposure = exposure + + gain = self._node_float( + node_map, + "Gain", + "GainRaw", + allow_zero=True, + ) + if gain is not None: + self._actual_gain = gain + + # Persist useful telemetry into properties["gentl"] for GUI/debugging. + try: + ns = self._ensure_settings_ns() + + if self._actual_width and self._actual_height: + ns["actual_resolution"] = [int(self._actual_width), int(self._actual_height)] + + if self._actual_fps is not None: + ns["actual_fps"] = float(self._actual_fps) - LOG.warning(f"Could not set frame rate to {target} FPS (no compatible attribute found)") + if resulting_fps is not None: + ns["actual_resulting_frame_rate"] = float(resulting_fps) + + if requested_fps is not None: + ns["actual_acquisition_frame_rate"] = float(requested_fps) + + if self._actual_exposure is not None: + ns["actual_exposure"] = float(self._actual_exposure) + + if self._actual_gain is not None: + ns["actual_gain"] = float(self._actual_gain) + + exposure_auto = self._node_str(node_map, "ExposureAuto") + if exposure_auto is not None: + ns["actual_exposure_auto"] = exposure_auto + + throughput = self._node_float(node_map, "DeviceLinkThroughputLimit", allow_zero=True) + if throughput is not None: + ns["actual_device_link_throughput_limit"] = float(throughput) + + throughput_mode = self._node_str(node_map, "DeviceLinkThroughputLimitMode") + if throughput_mode is not None: + ns["actual_device_link_throughput_limit_mode"] = throughput_mode + + pixel_format = self._node_str(node_map, "PixelFormat") + if pixel_format is not None: + ns["actual_pixel_format"] = pixel_format + + except Exception: + pass + + # ------------------------------------------------------------------ + # Frame conversion / local helpers + # ------------------------------------------------------------------ def _convert_frame(self, frame: np.ndarray) -> np.ndarray: if frame.dtype != np.uint8: @@ -1344,10 +1798,24 @@ def _convert_frame(self, frame: np.ndarray) -> np.ndarray: scale = 255.0 / max_val if max_val > 0.0 else 1.0 frame = np.clip(frame * scale, 0, 255).astype(np.uint8) + fmt = str(self._pixel_format or "").strip() + if frame.ndim == 2: - frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR) - elif frame.ndim == 3 and frame.shape[2] == 3 and self._pixel_format == "RGB8": - frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) + if fmt == "BayerRG8": + frame = cv2.cvtColor(frame, cv2.COLOR_BayerRG2BGR) + elif fmt == "BayerGB8": + frame = cv2.cvtColor(frame, cv2.COLOR_BayerGB2BGR) + elif fmt == "BayerGR8": + frame = cv2.cvtColor(frame, cv2.COLOR_BayerGR2BGR) + elif fmt == "BayerBG8": + frame = cv2.cvtColor(frame, cv2.COLOR_BayerBG2BGR) + else: + frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR) + + elif frame.ndim == 3 and frame.shape[2] == 3: + if fmt == "RGB8": + frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) + # BGR8 is already OpenCV-native. if self._crop is not None: top, bottom, left, right = (int(v) for v in self._crop) @@ -1355,9 +1823,7 @@ def _convert_frame(self, frame: np.ndarray) -> np.ndarray: left = max(0, left) bottom = bottom if bottom > 0 else frame.shape[0] right = right if right > 0 else frame.shape[1] - bottom = min(frame.shape[0], bottom) - right = min(frame.shape[1], right) - frame = frame[top:bottom, left:right] + frame = frame[top : min(frame.shape[0], bottom), left : min(frame.shape[1], right)] if self._rotate in (90, 180, 270): rotations = { @@ -1370,11 +1836,10 @@ def _convert_frame(self, frame: np.ndarray) -> np.ndarray: return frame.copy() def _resolve_device_label(self, node_map) -> str | None: - candidates = [ + for name_attr, serial_attr in ( ("DeviceModelName", "DeviceSerialNumber"), ("DeviceDisplayName", "DeviceSerialNumber"), - ] - for name_attr, serial_attr in candidates: + ): try: model = getattr(node_map, name_attr).value except AttributeError: @@ -1385,18 +1850,48 @@ def _resolve_device_label(self, node_map) -> str | None: except AttributeError: pass if model: - model_str = str(model) - serial_str = str(serial) if serial else None - return f"{model_str} ({serial_str})" if serial_str else model_str + return f"{model} ({serial})" if serial else str(model) + return None + + def _parse_crop(self, crop) -> tuple[int, int, int, int] | None: + if isinstance(crop, (list, tuple)) and len(crop) == 4: + return tuple(int(v) for v in crop) + return None + + def _get_requested_resolution_or_none(self) -> tuple[int, int] | None: + props = self.settings.properties if isinstance(self.settings.properties, dict) else {} + legacy = props.get("resolution") + if isinstance(legacy, (list, tuple)) and len(legacy) == 2: + try: + w, h = int(legacy[0]), int(legacy[1]) + if w > 0 and h > 0: + return (w, h) + except Exception: + pass + + try: + w = int(getattr(self.settings, "width", 0) or 0) + h = int(getattr(self.settings, "height", 0) or 0) + if w > 0 and h > 0: + return (w, h) + except Exception: + pass return None - def _adjust_to_increment(self, value: int, minimum: int, maximum: int, increment: int) -> int: + @staticmethod + def _adjust_to_increment(value: int, minimum: int, maximum: int, increment: int) -> int: value = max(minimum, min(maximum, int(value))) if increment <= 0: return value - offset = value - minimum - steps = offset // increment - return minimum + steps * increment + return minimum + ((value - minimum) // increment) * increment + + @staticmethod + def _positive_float(value) -> float | None: + try: + number = float(value) + return number if number > 0 else None + except Exception: + return None def device_name(self) -> str: if self._device_label: diff --git a/dlclivegui/cameras/backends/utils/gentl_discovery.py b/dlclivegui/cameras/backends/utils/gentl_discovery.py index ebce7344..3eed1997 100644 --- a/dlclivegui/cameras/backends/utils/gentl_discovery.py +++ b/dlclivegui/cameras/backends/utils/gentl_discovery.py @@ -5,7 +5,9 @@ from __future__ import annotations import glob +import logging import os +import threading from collections.abc import Iterable, Sequence from dataclasses import dataclass, field from enum import Enum, auto @@ -18,6 +20,125 @@ class GenTLDiscoveryPolicy(Enum): RAISE_IF_MULTIPLE = auto() # if > N candidates, raise an error to avoid ambiguity (forces explicit config) +try: # pragma: no cover - optional dependency + from harvesters.core import Harvester # type: ignore +except Exception: # pragma: no cover - optional dependency + Harvester = None # type: ignore + +logger = logging.getLogger(__name__) + + +class SharedHarvesterEntry: + """ + A shared Harvester instance keyed by a canonical tuple of CTI files. + """ + + def __init__(self, cti_files: list[str]): + if Harvester is None: # pragma: no cover + raise RuntimeError( + "The 'harvesters' package is required for the GenTL backend. Install it via 'pip install harvesters'." + ) + + self.lock = threading.RLock() + self.key = tuple(sorted(_normalize_path(p, casefold_windows=True) for p in cti_files)) + self.refcount = 0 + self.harvester = Harvester() + self.loaded_files: list[str] = [] + self.failed_files: dict[str, str] = {} + + for cti in self.key: + try: + self.harvester.add_file(cti) + self.loaded_files.append(cti) + except Exception as e: + logger.warning(f"Failed to load CTI file: {cti}. Skipping.") + self.failed_files[cti] = str(e) + + if not self.loaded_files: + e = RuntimeError("No GenTL producer (.cti) could be loaded by shared Harvester.") + self._raise_and_reset_harvester(e) + + # Initial device enumeration. + try: + self.harvester.update() + except Exception as e: + self._raise_and_reset_harvester(e) + + def _raise_and_reset_harvester(self, exc: Exception) -> None: + exc.loaded_files = self.loaded_files[:] + exc.failed_files = dict(self.failed_files) + try: + self.harvester.reset() + except Exception: + pass + raise exc + + +class SharedHarvesterPool: + """ + Process-local pool of shared Harvester instances. + + Keyed by the canonicalized CTI file set. + """ + + _lock = threading.RLock() + _entries: dict[tuple[str, ...], SharedHarvesterEntry] = {} + + @classmethod + def acquire(cls, cti_files: list[str]) -> SharedHarvesterEntry: + key = tuple(sorted(_normalize_path(p, casefold_windows=True) for p in cti_files)) + with cls._lock: + entry = cls._entries.get(key) + if entry is None: + entry = SharedHarvesterEntry(list(key)) + cls._entries[key] = entry + entry.refcount += 1 + return entry + + @classmethod + def release(cls, entry: SharedHarvesterEntry | None) -> None: + if entry is None: + return + + with cls._lock: + current = cls._entries.get(entry.key) + if current is None: + # Already released/reset. + return + + current.refcount -= 1 + if current.refcount > 0: + return + + try: + with current.lock: + try: + current.harvester.reset() + except Exception: + pass + finally: + cls._entries.pop(entry.key, None) + + @classmethod + def refresh(cls, entry: SharedHarvesterEntry | None) -> None: + """ + Optional helper when callers want to re-enumerate the device list + on an already-shared Harvester instance. + """ + if entry is None: + return + with entry.lock: + entry.harvester.update() + + @classmethod + def get_refcount(cls, entry: SharedHarvesterEntry | None) -> int: + if entry is None: + return 0 + with cls._lock: + current = cls._entries.get(entry.key) + return int(current.refcount) if current is not None else 0 + + @dataclass class CTIDiscoveryDiagnostics: explicit_files: list[str] = field(default_factory=list) @@ -81,18 +202,18 @@ def _expand_user_and_env(value: str) -> str: return s -def _normalize_path(p: str) -> str: - """ - Normalize a filesystem path in a cross-platform way: - - expands ~ and environment variables - - resolves to absolute where possible (without requiring existence) - """ +def _normalize_path(p: str, *, casefold_windows: bool = False) -> str: expanded = _expand_user_and_env(p) pp = Path(expanded) try: - return str(pp.resolve(strict=False)) + out = str(pp.resolve(strict=False)) except Exception: - return str(pp.absolute()) + out = str(pp.absolute()) + + if casefold_windows: + out = os.path.normcase(out) + + return out def _iter_cti_files_in_dir(directory: str, recursive: bool = False) -> Iterable[str]: diff --git a/dlclivegui/cameras/base.py b/dlclivegui/cameras/base.py index bc91ce9b..fefedd1d 100644 --- a/dlclivegui/cameras/base.py +++ b/dlclivegui/cameras/base.py @@ -70,6 +70,7 @@ class SupportLevel(str, Enum): "set_gain": SupportLevel.UNSUPPORTED, "device_discovery": SupportLevel.UNSUPPORTED, "stable_identity": SupportLevel.UNSUPPORTED, + "hardware_trigger": SupportLevel.UNSUPPORTED, } diff --git a/dlclivegui/config.py b/dlclivegui/config.py index 6d9e1de7..dac523da 100644 --- a/dlclivegui/config.py +++ b/dlclivegui/config.py @@ -12,6 +12,21 @@ TileLayout = Literal["auto", "2x2", "1x4", "4x1"] Precision = Literal["FP32", "FP16"] ModelType = Literal["pytorch", "tensorflow"] +TriggerRole = Literal["off", "external", "master", "follower"] +TriggerActivation = Literal["RisingEdge", "FallingEdge", "AnyEdge", "LevelHigh", "LevelLow"] +TriggerStrobePolarity = Literal["ActiveHigh", "ActiveLow"] +TriggerStrobeOperation = Literal["Exposure", "FixedDuration"] + +# Global settings +## GUI +GUI_MAX_DISPLAY_FPS: float = 30.0 + + +## Debug +### Timing logs +SINGLE_CAMERA_WORKER_DO_LOG_TIMING: bool = True +MULTI_CAMERA_WORKER_DO_LOG_TIMING: bool = True +# MAIN_WINDOW_DO_LOG_TIMING: bool = False class CameraSettings(BaseModel): @@ -38,6 +53,27 @@ class CameraSettings(BaseModel): enabled: bool = True properties: dict[str, Any] = Field(default_factory=dict) + def pretty(self) -> str: + crop = ( + "none" + if self.get_crop_region() is None + else f"({self.crop_x0}, {self.crop_y0}) -> ({self.crop_x1 or 'edge'}, {self.crop_y1 or 'edge'})" + ) + return ( + f"CameraSettings[\n" + f" name={self.name!r}, index={self.index}, backend={self.backend!r}, enabled={self.enabled}\n" + f" fps={self.fps}, size={self.width or 'auto'}x{self.height or 'auto'}, " + f"exposure={self.exposure or 'auto'}, gain={self.gain or 'auto'}\n" + f" rotation={self.rotation}, crop={crop}\n" + f"]" + ) + + def __str__(self) -> str: + return self.pretty() + + def __repr__(self) -> str: + return self.pretty() + @field_validator("fps", mode="before") @classmethod def _coerce_fps(cls, v): @@ -168,6 +204,158 @@ def check_diff(old: CameraSettings, new: CameraSettings) -> dict: pass return out + def backend_options(self, backend: str | None = None) -> dict[str, Any]: + key = backend or self.backend + props = self.properties if isinstance(self.properties, dict) else {} + ns = props.get(str(key).lower(), {}) + return ns if isinstance(ns, dict) else {} + + def get_trigger_settings(self, backend: str | None = None) -> CameraTriggerSettings: + ns = self.backend_options(backend) + return CameraTriggerSettings.from_any(ns.get("trigger")) + + def set_trigger_settings(self, trigger: CameraTriggerSettings, backend: str | None = None) -> None: + key = backend or self.backend + if not isinstance(self.properties, dict): + self.properties = {} + ns = self.properties.setdefault(str(key).lower(), {}) + if not isinstance(ns, dict): + ns = {} + self.properties[str(key).lower()] = ns + ns["trigger"] = trigger.to_properties() + + def with_save_defaults(self) -> CameraSettings: + out = self.model_copy(deep=True) + + backend = (out.backend or "").lower() + if backend != "gentl": + return out + + if not isinstance(out.properties, dict): + out.properties = {} + + ns = out.properties.setdefault("gentl", {}) + if not isinstance(ns, dict): + ns = {} + out.properties["gentl"] = ns + + ns.setdefault("trigger", CameraTriggerSettings().to_properties()) + + return out + + +class CameraTriggerSettings(BaseModel): + """ + Generic hardware-trigger settings. + + Backend-specific code may ignore fields that are unsupported by a given + camera/SDK. + + For GenTL/TIS DMK 37BUX287: + - follower/external maps mainly to TriggerMode, TriggerSelector, + TriggerActivation. TriggerSource may be read-only and is best-effort. + - master output maps primarily to StrobeEnable, StrobePolarity, + StrobeOperation, StrobeDuration, and StrobeDelay. + """ + + role: TriggerRole = "off" + + # Input trigger config: external/follower + selector: str = "FrameStart" + source: str = "auto" + activation: TriggerActivation | str = "RisingEdge" + + # Generic/SFNC output config: master fallback for cameras exposing Line* nodes. + output_line: str = "Line2" + output_source: str = "ExposureActive" + + # Strobe output config: master path for TIS/DMK 37U cameras. + strobe_polarity: TriggerStrobePolarity | str = "ActiveHigh" + strobe_operation: TriggerStrobeOperation | str = "Exposure" + strobe_duration: int | None = None # µs, used when strobe_operation=FixedDuration + strobe_delay: int | None = None # µs + + # Runtime behavior + timeout: float | None = None + strict: bool = False + + @field_validator("role", mode="before") + @classmethod + def _coerce_role(cls, v): + if v is None: + return "off" + + s = str(v).strip().lower() + aliases = { + "": "off", + "none": "off", + "false": "off", + "disabled": "off", + "disable": "off", + "off": "off", + "true": "external", + "on": "external", + "trigger": "external", + "triggered": "external", + "external": "external", + "follower": "follower", + "slave": "follower", + "master": "master", + "main": "master", + } + return aliases.get(s, s) + + @field_validator("timeout", mode="before") + @classmethod + def _coerce_timeout(cls, v): + if v in (None, ""): + return None + try: + fv = float(v) + except Exception: + return None + return fv if fv > 0 else None + + @field_validator("strobe_duration", "strobe_delay", mode="before") + @classmethod + def _coerce_optional_nonnegative_int(cls, v): + if v in (None, ""): + return None + try: + iv = int(float(v)) + except Exception: + return None + return iv if iv >= 0 else None + + @field_validator("source", mode="before") + @classmethod + def _coerce_source(cls, v): + if v is None: + return "auto" + + s = str(v).strip() + if not s: + return "auto" + + aliases = { + "default": "auto", + "automatic": "auto", + "device": "auto", + "camera": "auto", + } + return aliases.get(s.lower(), s) + + @classmethod + def from_any(cls, value) -> CameraTriggerSettings: + if isinstance(value, cls): + return value + if isinstance(value, dict): + return cls(**value) + return cls() + + def to_properties(self) -> dict[str, Any]: + return self.model_dump(exclude_none=True) + class MultiCameraSettings(BaseModel): cameras: list[CameraSettings] = Field(default_factory=list) @@ -206,12 +394,19 @@ def from_dict(cls, data: dict[str, Any]) -> MultiCameraSettings: return cls(cameras=cameras, max_cameras=max_cameras, tile_layout=tile_layout) def to_dict(self) -> dict[str, Any]: + out = self.with_save_defaults() return { - "cameras": [cam.model_dump() for cam in self.cameras], - "max_cameras": self.max_cameras, - "tile_layout": self.tile_layout, + "cameras": [cam.model_dump() for cam in out.cameras], + "max_cameras": out.max_cameras, + "tile_layout": out.tile_layout, } + def with_save_defaults(self) -> MultiCameraSettings: + """Return a copy with save defaults applied to all cameras.""" + out = self.model_copy(deep=True) + out.cameras = [cam.with_save_defaults() for cam in out.cameras] + return out + class DynamicCropModel(BaseModel): enabled: bool = False @@ -377,10 +572,13 @@ def from_dict(cls, data: dict[str, Any]) -> ApplicationSettings: ) def to_dict(self) -> dict[str, Any]: + camera = self.camera.with_save_defaults() + multi_camera = self.multi_camera.with_save_defaults() + return { "version": self.version, - "camera": self.camera.model_dump(), - "multi_camera": self.multi_camera.to_dict(), + "camera": camera.model_dump(), + "multi_camera": multi_camera.to_dict(), "dlc": self.dlc.model_dump(), "recording": self.recording.model_dump(), "bbox": self.bbox.model_dump(), diff --git a/dlclivegui/gui/camera_config/camera_config_dialog.py b/dlclivegui/gui/camera_config/camera_config_dialog.py index 4c94fb70..444f2738 100644 --- a/dlclivegui/gui/camera_config/camera_config_dialog.py +++ b/dlclivegui/gui/camera_config/camera_config_dialog.py @@ -18,9 +18,10 @@ ) from ...cameras.factory import CameraFactory, DetectedCamera, apply_detected_identity, camera_identity_key -from ...config import CameraSettings, MultiCameraSettings +from ...config import CameraSettings, CameraTriggerSettings, MultiCameraSettings from .loaders import CameraLoadWorker, CameraProbeWorker, CameraScanState, DetectCamerasWorker from .preview import PreviewSession, PreviewState, apply_crop, apply_rotation, resize_to_fit, to_display_pixmap +from .trigger_config_dialog import TriggerConfigDialog from .ui_blocks import setup_camera_config_dialog_ui LOGGER = logging.getLogger(__name__) @@ -328,6 +329,7 @@ def _connect_signals(self) -> None: self.active_cameras_list.currentRowChanged.connect(self._on_active_camera_selected) self.available_cameras_list.currentRowChanged.connect(self._on_available_camera_selected) self.available_cameras_list.itemDoubleClicked.connect(self._on_available_camera_double_clicked) + self.trigger_settings_btn.clicked.connect(self._open_trigger_settings_dialog) self.apply_settings_btn.clicked.connect(self._apply_camera_settings) self.reset_settings_btn.clicked.connect(self._reset_selected_camera) self.preview_btn.clicked.connect(self._toggle_preview) @@ -451,11 +453,24 @@ def _refresh_camera_labels(self) -> None: finally: cam_list.blockSignals(False) + def _trigger_role_for_label(self, cam: CameraSettings) -> str: + backend = (cam.backend or "").lower() + props = cam.properties if isinstance(cam.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" + return str(trigger.get("role", "off") or "off").lower() + def _format_camera_label(self, cam: CameraSettings, index: int = -1) -> str: status = "✓" if cam.enabled else "○" this_id = f"{(cam.backend or '').lower()}:{cam.index}" dlc_indicator = " [DLC]" if this_id == self._dlc_camera_id and cam.enabled else "" - return f"{status} {cam.name} [{cam.backend}:{cam.index}]{dlc_indicator}" + + trigger_role = self._trigger_role_for_label(cam) + trigger_indicator = "" if trigger_role in {"off", "disabled"} else f" [{trigger_role}]" + + return f"{status} {cam.name} [{cam.backend}:{cam.index}]{trigger_indicator}{dlc_indicator}" def _selected_detected_camera(self) -> DetectedCamera | None: row = self.available_cameras_list.currentRow() @@ -514,6 +529,9 @@ def apply(widget, feature: str, label: str, *, allow_best_effort: bool = True): apply(self.cam_exposure, "set_exposure", "Exposure") apply(self.cam_gain, "set_gain", "Gain") + # Hardware trigger / sync + apply(self.trigger_settings_btn, "hardware_trigger", "Hardware trigger") + def _set_preview_button_loading(self, loading: bool) -> None: if loading: self.preview_btn.setText("Cancel Loading") @@ -800,6 +818,21 @@ def _on_active_camera_selected(self, row: int) -> None: self._load_camera_to_form(cam) self._start_probe_for_camera(cam, apply_to_requested=False) + def _ensure_default_trigger_config(self, cam: CameraSettings) -> None: + backend = (cam.backend or "").lower() + if backend != "gentl": + return + + 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)) + def _add_selected_camera(self) -> None: if not self._commit_pending_edits(reason="before adding a new camera"): return @@ -850,6 +883,7 @@ def _add_selected_camera(self) -> None: properties={}, ) apply_detected_identity(new_cam, detected, backend) + self._ensure_default_trigger_config(new_cam) self._working_settings.cameras.append(new_cam) new_index = len(self._working_settings.cameras) - 1 new_item = QListWidgetItem(self._format_camera_label(new_cam, new_index)) @@ -969,6 +1003,7 @@ def _load_camera_to_form(self, cam: CameraSettings) -> None: self.cam_crop_y0.setValue(cam.crop_y0) self.cam_crop_x1.setValue(cam.crop_x1) self.cam_crop_y1.setValue(cam.crop_y1) + self._ensure_default_trigger_config(cam) self.apply_settings_btn.setEnabled(True) self._set_detected_labels(cam) finally: @@ -1029,6 +1064,39 @@ def _enabled_count_with(self, row: int, new_enabled: bool) -> int: count += 1 return count + def _open_trigger_settings_dialog(self) -> None: + """Open per-camera hardware trigger settings dialog.""" + if self._current_edit_index is None: + return + + row = self._current_edit_index + if row < 0 or row >= len(self._working_settings.cameras): + return + + # Commit normal camera edits first so we do not lose pending UI changes. + if not self._commit_pending_edits(reason="before opening trigger settings"): + return + + cam = self._working_settings.cameras[row] + + dlg = TriggerConfigDialog(cam, self) + if dlg.exec() != QDialog.Accepted: + return + + updated = dlg.camera_settings + + self._working_settings.cameras[row] = updated + self._update_active_list_item(row, updated) + self._load_camera_to_form(updated) + + # Trigger changes require reopening the camera preview/backend. + if self._is_preview_live(): + self._append_status("[Trigger] Restarting preview to apply trigger settings.") + self._request_preview_restart(updated, reason="trigger-settings") + + self.apply_settings_btn.setEnabled(False) + self._set_apply_dirty(False) + def _apply_camera_settings(self) -> bool: try: for sb in ( @@ -1085,9 +1153,7 @@ def _apply_camera_settings(self) -> bool: old_settings = current_model restart = False - should_consider_restart = self._preview.state == PreviewState.ACTIVE and isinstance( - old_settings, CameraSettings - ) + should_consider_restart = self._is_preview_live() and isinstance(old_settings, CameraSettings) if should_consider_restart: restart = self._should_restart_preview(old_settings, new_model) @@ -1099,7 +1165,7 @@ def _apply_camera_settings(self) -> bool: new_model.index, ) - if self._preview.state == PreviewState.ACTIVE and restart: + if self._is_preview_live() and restart: self._append_status("[Apply] Restarting preview to apply camera settings changes.") self._request_preview_restart(new_model, reason="apply-settings") @@ -1597,6 +1663,13 @@ def _bump_epoch(self) -> int: self._preview.epoch += 1 return self._preview.epoch + def _trigger_dict_for_cam(self, cam: CameraSettings) -> dict: + backend = (cam.backend or "").lower() + props = cam.properties if isinstance(cam.properties, dict) else {} + ns = props.get(backend, {}) if isinstance(props.get(backend), dict) else {} + trigger = ns.get("trigger", {}) + return trigger if isinstance(trigger, dict) else {} + def _should_restart_preview(self, old: CameraSettings, new: CameraSettings) -> bool: """ Fast UX policy: @@ -1612,6 +1685,9 @@ def _should_restart_preview(self, old: CameraSettings, new: CameraSettings) -> b except Exception: return True # safest: restart + if self._trigger_dict_for_cam(old) != self._trigger_dict_for_cam(new): + return True + # No restart needed if only rotation/crop/enabled changed return False @@ -1756,9 +1832,10 @@ def _on_loader_finished(self, e: int) -> None: self._preview.restart_scheduled = False self._preview.loader = None - if pending and self._preview.state == PreviewState.IDLE: + if pending and self._preview.state in (PreviewState.IDLE, PreviewState.ACTIVE): LOGGER.debug("[Loader] finished with pending restart for backend=%s idx=%s", pending.backend, pending.index) self._begin_preview_load(pending, reason="pending-restart-after-finish") + return # UI sync is already handled in _begin_preview_load self._sync_preview_ui() diff --git a/dlclivegui/gui/camera_config/trigger_config_dialog.py b/dlclivegui/gui/camera_config/trigger_config_dialog.py new file mode 100644 index 00000000..c6f78140 --- /dev/null +++ b/dlclivegui/gui/camera_config/trigger_config_dialog.py @@ -0,0 +1,271 @@ +# dlclivegui/gui/camera_config/trigger_config_dialog.py +from __future__ import annotations + +from PySide6.QtWidgets import ( + QCheckBox, + QComboBox, + QDialog, + QDialogButtonBox, + QDoubleSpinBox, + QFormLayout, + QGroupBox, + QLabel, + QLineEdit, + QMessageBox, + QSpinBox, + QVBoxLayout, + QWidget, +) + +from ...config import CameraSettings, CameraTriggerSettings + + +def _backend_namespace(cam: CameraSettings) -> dict: + backend = (cam.backend or "").lower() + if not isinstance(cam.properties, dict): + cam.properties = {} + ns = cam.properties.setdefault(backend, {}) + if not isinstance(ns, dict): + ns = {} + cam.properties[backend] = ns + return ns + + +class TriggerConfigDialog(QDialog): + """Small dialog for editing per-camera hardware trigger settings.""" + + def __init__(self, cam: CameraSettings, parent: QWidget | None = None): + super().__init__(parent) + self.setWindowTitle("Configure trigger mode") + self.setMinimumWidth(420) + + self._cam = cam.model_copy(deep=True) + + ns = _backend_namespace(self._cam) + try: + self._trigger = CameraTriggerSettings.from_any(ns.get("trigger")) + except Exception: + self._trigger = CameraTriggerSettings() + + self._setup_ui() + self._load_from_trigger(self._trigger) + self._sync_role_ui() + + @property + def camera_settings(self) -> CameraSettings: + return self._cam + + def _setup_ui(self) -> None: + root = QVBoxLayout(self) + + info = QLabel( + "Configure hardware trigger settings for this camera.\n" + "Follower/external mode arms the camera and waits for electrical pulses on TRIGGER_IN.\n" + "Master mode enables STROBE_OUT pulses. For TIS/DMK 37U cameras this uses Strobe settings; " + "Line output settings are kept as a generic fallback.\n" + "In strict mode, unsupported trigger nodes fail camera open." + ) + info.setWordWrap(True) + root.addWidget(info) + + group = QGroupBox("Hardware Trigger") + form = QFormLayout(group) + + self.role_combo = QComboBox() + self.role_combo.addItem("Off / Free-run", "off") + self.role_combo.addItem("External trigger", "external") + self.role_combo.addItem("Follower", "follower") + self.role_combo.addItem("Master", "master") + form.addRow("Role:", self.role_combo) + + self.selector_edit = QLineEdit() + self.selector_edit.setPlaceholderText("FrameStart") + form.addRow("Trigger selector:", self.selector_edit) + + self.source_edit = QLineEdit() + self.source_edit.setPlaceholderText("auto, Line0, Software, ...") + form.addRow("Trigger source:", self.source_edit) + + self.activation_combo = QComboBox() + for value in ("RisingEdge", "FallingEdge", "AnyEdge", "LevelHigh", "LevelLow"): + self.activation_combo.addItem(value, value) + form.addRow("Activation:", self.activation_combo) + + self.output_line_edit = QLineEdit() + self.output_line_edit.setPlaceholderText("Line2") + self.output_line_edit.setToolTip( + "Generic Line* output selector for cameras exposing LineSelector/LineSource. " + "Ignored by TIS/DMK 37U strobe-based output." + ) + form.addRow("Output line:", self.output_line_edit) + + self.output_source_edit = QLineEdit() + self.output_source_edit.setPlaceholderText("ExposureActive") + self.output_source_edit.setToolTip( + "Generic LineSource value for cameras exposing LineSource. " + "For TIS/DMK 37U cameras, use Strobe operation instead." + ) + form.addRow("Output source:", self.output_source_edit) + + self.strobe_polarity_combo = QComboBox() + self.strobe_polarity_combo.addItem("Active high", "ActiveHigh") + self.strobe_polarity_combo.addItem("Active low", "ActiveLow") + self.strobe_polarity_combo.setToolTip( + "Polarity of STROBE_OUT. If the follower does not trigger, also try changing the follower activation edge." + ) + form.addRow("Strobe polarity:", self.strobe_polarity_combo) + + self.strobe_operation_combo = QComboBox() + self.strobe_operation_combo.addItem("Exposure duration", "Exposure") + self.strobe_operation_combo.addItem("Fixed duration", "FixedDuration") + self.strobe_operation_combo.setToolTip( + "Exposure: strobe pulse length follows exposure time. " + "FixedDuration: strobe pulse length is set by Strobe duration." + ) + form.addRow("Strobe operation:", self.strobe_operation_combo) + + self.strobe_duration_spin = QSpinBox() + self.strobe_duration_spin.setRange(0, 32767) + self.strobe_duration_spin.setSingleStep(100) + self.strobe_duration_spin.setSuffix(" µs") + self.strobe_duration_spin.setSpecialValueText("Default") + self.strobe_duration_spin.setToolTip( + "Used only when Strobe operation is FixedDuration. 0 means backend/device default." + ) + form.addRow("Strobe duration:", self.strobe_duration_spin) + + self.strobe_delay_spin = QSpinBox() + self.strobe_delay_spin.setRange(0, 32767) + self.strobe_delay_spin.setSingleStep(100) + self.strobe_delay_spin.setSuffix(" µs") + self.strobe_delay_spin.setSpecialValueText("Default") + self.strobe_delay_spin.setToolTip( + "Delay between start of exposure and STROBE_OUT pulse. 0 means no delay/device default." + ) + form.addRow("Strobe delay:", self.strobe_delay_spin) + + self.timeout_spin = QDoubleSpinBox() + self.timeout_spin.setRange(0.0, 3600.0) + self.timeout_spin.setDecimals(3) + self.timeout_spin.setSingleStep(0.1) + self.timeout_spin.setSpecialValueText("Default") + self.timeout_spin.setToolTip( + "Fetch poll timeout in seconds. The backend may cap individual fetches to keep preview shutdown responsive." + ) + form.addRow("Read timeout:", self.timeout_spin) + + self.strict_checkbox = QCheckBox("Strict mode") + self.strict_checkbox.setToolTip("If enabled, missing/unsupported GenICam trigger nodes fail camera open.") + form.addRow(self.strict_checkbox) + + root.addWidget(group) + + buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) + buttons.accepted.connect(self._accept) + buttons.rejected.connect(self.reject) + root.addWidget(buttons) + + self.role_combo.currentIndexChanged.connect(self._sync_role_ui) + self.strobe_operation_combo.currentIndexChanged.connect(self._sync_role_ui) + + def _load_from_trigger(self, trigger: CameraTriggerSettings) -> None: + role = str(getattr(trigger, "role", "off") or "off").lower() + idx = self.role_combo.findData(role) + self.role_combo.setCurrentIndex(idx if idx >= 0 else 0) + + self.selector_edit.setText(str(getattr(trigger, "selector", "FrameStart") or "FrameStart")) + self.source_edit.setText(str(getattr(trigger, "source", "auto") or "auto")) + + activation = str(getattr(trigger, "activation", "RisingEdge") or "RisingEdge") + idx = self.activation_combo.findData(activation) + self.activation_combo.setCurrentIndex(idx if idx >= 0 else 0) + + self.output_line_edit.setText(str(getattr(trigger, "output_line", "Line2") or "Line2")) + self.output_source_edit.setText(str(getattr(trigger, "output_source", "ExposureActive") or "ExposureActive")) + + strobe_polarity = str(getattr(trigger, "strobe_polarity", "ActiveHigh") or "ActiveHigh") + idx = self.strobe_polarity_combo.findData(strobe_polarity) + self.strobe_polarity_combo.setCurrentIndex(idx if idx >= 0 else 0) + + strobe_operation = str(getattr(trigger, "strobe_operation", "Exposure") or "Exposure") + idx = self.strobe_operation_combo.findData(strobe_operation) + self.strobe_operation_combo.setCurrentIndex(idx if idx >= 0 else 0) + + strobe_duration = getattr(trigger, "strobe_duration", None) + self.strobe_duration_spin.setValue(int(strobe_duration) if strobe_duration is not None else 0) + + strobe_delay = getattr(trigger, "strobe_delay", None) + self.strobe_delay_spin.setValue(int(strobe_delay) if strobe_delay is not None else 0) + + timeout = getattr(trigger, "timeout", None) + self.timeout_spin.setValue(float(timeout) if timeout else 0.0) + + self.strict_checkbox.setChecked(bool(getattr(trigger, "strict", False))) + + def _sync_role_ui(self) -> None: + role = str(self.role_combo.currentData() or "off") + + input_enabled = role in {"external", "follower"} + + self.selector_edit.setEnabled(input_enabled) + self.source_edit.setEnabled(input_enabled) + self.activation_combo.setEnabled(input_enabled) + + output_enabled = role == "master" + # Generic Line* fallback fields. + self.output_line_edit.setEnabled(output_enabled) + self.output_source_edit.setEnabled(output_enabled) + + # TIS/DMK 37U Strobe* fields. + self.strobe_polarity_combo.setEnabled(output_enabled) + self.strobe_operation_combo.setEnabled(output_enabled) + + fixed_duration = ( + output_enabled and str(self.strobe_operation_combo.currentData() or "Exposure") == "FixedDuration" + ) + self.strobe_duration_spin.setEnabled(fixed_duration) + self.strobe_delay_spin.setEnabled(output_enabled) + + # Timeout is mostly useful for external/follower, but harmless for any role. + self.timeout_spin.setEnabled(role in {"external", "follower"}) + + def _accept(self) -> None: + role = str(self.role_combo.currentData() or "off") + + payload = { + "role": role, + "selector": self.selector_edit.text().strip() or "FrameStart", + "source": self.source_edit.text().strip() or "auto", + "activation": str(self.activation_combo.currentData() or "RisingEdge"), + # Generic/SFNC Line* fallback output settings. + "output_line": self.output_line_edit.text().strip() or "Line2", + "output_source": self.output_source_edit.text().strip() or "ExposureActive", + # Strobe output settings used by TIS/DMK 37U cameras. + "strobe_polarity": str(self.strobe_polarity_combo.currentData() or "ActiveHigh"), + "strobe_operation": str(self.strobe_operation_combo.currentData() or "Exposure"), + "strict": bool(self.strict_checkbox.isChecked()), + } + + timeout = float(self.timeout_spin.value()) + if role in {"external", "follower"} and timeout > 0: + payload["timeout"] = timeout + elif role == "off": + payload["timeout"] = None # ensure timeout is cleared when disabling trigger + strobe_duration = int(self.strobe_duration_spin.value()) + if role == "master" and strobe_duration > 0: + payload["strobe_duration"] = strobe_duration + + strobe_delay = int(self.strobe_delay_spin.value()) + if role == "master" and strobe_delay > 0: + payload["strobe_delay"] = strobe_delay + + try: + trigger = CameraTriggerSettings.from_any(payload) + except Exception as e: + QMessageBox.critical(self, "Error", f"Failed to apply trigger settings: {e}") + return + + ns = _backend_namespace(self._cam) + ns["trigger"] = trigger.to_properties() + + self.accept() diff --git a/dlclivegui/gui/camera_config/ui_blocks.py b/dlclivegui/gui/camera_config/ui_blocks.py index 86e4f19d..07a8025e 100644 --- a/dlclivegui/gui/camera_config/ui_blocks.py +++ b/dlclivegui/gui/camera_config/ui_blocks.py @@ -354,6 +354,13 @@ def build_settings_group(dlg: CameraConfigDialog) -> QGroupBox: dlg.settings_form.addRow("Crop:", crop_widget) + # --- Trigger settings button --- + dlg.trigger_settings_btn = QPushButton("Trigger Settings…") + dlg.trigger_settings_btn.setIcon(dlg.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogDetailedView)) + dlg.trigger_settings_btn.setEnabled(False) + dlg.trigger_settings_btn.setToolTip("Configure hardware trigger / GPIO sync settings for this camera.") + dlg.settings_form.addRow("Sync:", dlg.trigger_settings_btn) + # Apply/Reset buttons row dlg.apply_settings_btn = QPushButton("Apply Settings") dlg.apply_settings_btn.setIcon(dlg.style().standardIcon(QStyle.StandardPixmap.SP_DialogApplyButton)) diff --git a/dlclivegui/gui/main_window.py b/dlclivegui/gui/main_window.py index caf0937e..ef06a5d9 100644 --- a/dlclivegui/gui/main_window.py +++ b/dlclivegui/gui/main_window.py @@ -772,7 +772,8 @@ def _connect_signals(self) -> None: self.bbox_color_combo.currentIndexChanged.connect(self._on_bbox_color_changed) # Multi-camera controller signals (used for both single and multi-camera modes) - self.multi_camera_controller.frame_ready.connect(self._on_multi_frame_ready) + self.multi_camera_controller.frame_ready.connect(self._on_multi_frame_processing_ready) + self.multi_camera_controller.display_ready.connect(self._on_multi_frame_display_ready) self.multi_camera_controller.all_started.connect(self._on_multi_camera_started) self.multi_camera_controller.all_stopped.connect(self._on_multi_camera_stopped) self.multi_camera_controller.camera_error.connect(self._on_multi_camera_error) @@ -857,15 +858,23 @@ def _apply_config(self, config: ApplicationSettings) -> None: # Update recording path preview self._update_recording_path_preview() - def _current_config(self) -> ApplicationSettings: - # Get the first camera from multi-camera config for backward compatibility - active_cameras = self._config.multi_camera.get_active_cameras() - camera = active_cameras[0] if active_cameras else CameraSettings() + def _current_config(self, *, allow_empty_model_path=False) -> ApplicationSettings: + multi_camera = self._config.multi_camera + active_cameras = multi_camera.get_active_cameras() + camera = ( + active_cameras[0].model_copy(deep=True) + if active_cameras + else ( + multi_camera.cameras[0].model_copy(deep=True) + if multi_camera.cameras + else self._config.camera.model_copy(deep=True) + ) + ) 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(), @@ -877,14 +886,29 @@ 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 == "": + + existing_dlc = ( # explicitly init from default if unset + self._config.dlc.model_copy(deep=True) + if getattr(self._config, "dlc", None) is not None + else DEFAULT_CONFIG.dlc.model_copy(deep=True) + ) + if not model_path: + if allow_empty_model_path: + # Preserve all existing DLC settings and only clear the model path. + return existing_dlc.model_copy( + update={ + "model_path": "", + } + ) + 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) except Exception as e: @@ -893,15 +917,13 @@ def _dlc_settings_from_ui(self) -> DLCProcessorSettings: "Please ensure the model file is valid and has an appropriate extension " "(.pt, .pth for PyTorch or model directory for TensorFlow)." ) from e - return DLCProcessorSettings( - model_path=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=model_bknd, - # additional_options=self._parse_json(self.additional_options_edit.toPlainText()), + + # Preserve all unchanged DLC settings and only update values derived from the UI. + return existing_dlc.model_copy( + update={ + "model_path": model_path, + "model_type": model_bknd, + } ) def _recording_settings_from_ui(self) -> RecordingSettings: @@ -968,7 +990,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) @@ -1268,8 +1290,10 @@ def _refresh_dlc_camera_list_running(self) -> None: """Populate the inference camera dropdown from currently running cameras.""" self.dlc_camera_combo.blockSignals(True) self.dlc_camera_combo.clear() - for cam_id in sorted(self._running_cams_ids): - self.dlc_camera_combo.addItem(self._label_for_cam_id(cam_id), cam_id) + for cam in self._config.multi_camera.get_active_cameras(): + cam_id = get_camera_id(cam) + if cam_id in self._running_cams_ids: + self.dlc_camera_combo.addItem(self._label_for_cam_id(cam_id), cam_id) # Keep current selection if still present, else select first running if self._inference_camera_id in self._running_cams_ids: @@ -1351,13 +1375,12 @@ def _render_overlays_for_recording(self, cam_id, frame): ) return output - def _on_multi_frame_ready(self, frame_data: MultiFrameData) -> None: + def _on_multi_frame_processing_ready(self, frame_data: MultiFrameData) -> None: """Handle frames from multiple cameras. - Priority order for performance: + Priority: 1. DLC processing (highest priority - enqueue immediately, only for DLC camera) 2. Recording (queued writes, non-blocking) - 3. Display (lowest priority - tiled and updated on separate timer) """ self._multi_camera_frames = frame_data.frames src_id = frame_data.source_camera_id @@ -1371,7 +1394,7 @@ def _on_multi_frame_ready(self, frame_data: MultiFrameData) -> None: # Determine DLC camera (first active camera) selected_id = self._inference_camera_id - available_ids = sorted(frame_data.frames.keys()) + available_ids = list(frame_data.frames.keys()) if selected_id in frame_data.frames: dlc_cam_id = selected_id else: @@ -1414,7 +1437,12 @@ def _on_multi_frame_ready(self, frame_data: MultiFrameData) -> None: ts = frame_data.timestamps.get(src_id, time.time()) self._rec_manager.write_frame(src_id, frame, ts) - # PRIORITY 3: Mark display dirty (tiling done in display timer) + def _on_multi_frame_display_ready(self, frame_data: MultiFrameData) -> None: + """Throttled UI/display path. + + Called at GUI_MAX_DISPLAY_FPS, not at camera capture FPS for performance reasons. + """ + self._multi_camera_frames = frame_data.frames self._display_dirty = True def _on_multi_camera_started(self) -> None: @@ -1614,7 +1642,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: diff --git a/dlclivegui/main.py b/dlclivegui/main.py index eb444aa0..9e38a08c 100644 --- a/dlclivegui/main.py +++ b/dlclivegui/main.py @@ -3,6 +3,7 @@ import argparse import logging +import os import signal import sys @@ -26,32 +27,96 @@ def _maybe_allow_keyboard_interrupt(app: QApplication) -> None: """ - Gracefully handle Ctrl+C (SIGINT) by closing the main window and quitting Qt. + Gracefully handle Ctrl+C/SIGTERM by closing the main window and quitting Qt. + + Notes: + - The small timer keeps Python signal handling responsive while Qt owns the event loop. + - First Ctrl+C tries graceful cleanup via closeEvent(). + - Second Ctrl+C exits immediately with code 130. """ + quitting = {"requested": False} def _request_quit() -> None: + if quitting["requested"]: + return + + quitting["requested"] = True logging.info("Keyboard interrupt received, closing application...") + win = getattr(app, "_main_window", None) + if win is not None: - # Trigger your existing closeEvent cleanup (camera stop, threads, timers, etc.) - win.close() - else: - app.quit() + try: + # Trigger existing closeEvent cleanup: + # camera stop, controller shutdown, timers, DLC shutdown, etc. + win.close() + except Exception: + logging.exception("Error while closing main window after Ctrl+C") + + # Explicitly ask Qt to leave app.exec(). + # Do this even after win.close(), because closeEvent cleanup can be async + # and relying only on quitOnLastWindowClosed can be fragile. + QTimer.singleShot(0, app.quit) + + def _force_exit() -> None: + logging.warning("Second interrupt received, forcing process exit.") + os._exit(130) def _sigint_handler(_signum, _frame) -> None: + if quitting["requested"]: + _force_exit() QTimer.singleShot(0, _request_quit) signal.signal(signal.SIGINT, _sigint_handler) - # Keepalive timer to allow Python to handle signals while Qt is running. - sig_timer = QTimer() - sig_timer.setInterval(100) # 50–200ms typical; keep low overhead + # Ctrl+Break on Windows. + if hasattr(signal, "SIGBREAK"): + signal.signal(signal.SIGBREAK, _sigint_handler) + + # Useful when process is terminated from shells/process managers. + if hasattr(signal, "SIGTERM"): + signal.signal(signal.SIGTERM, _sigint_handler) + + # Parent the timer to app so Qt owns its lifetime. + sig_timer = QTimer(app) + sig_timer.setInterval(100) sig_timer.timeout.connect(lambda: None) sig_timer.start() - if hasattr(app, "_sig_timer"): - app._sig_timer.stop() # Stop any existing timer to avoid duplicates - app._sig_timer = sig_timer # Store on app to keep it alive and allow cleanup on exit + old_timer = getattr(app, "_sig_timer", None) + if old_timer is not None: + try: + old_timer.stop() + except Exception: + pass + + app._sig_timer = sig_timer + + +def configure_logging(debug: bool = False) -> None: + """Configure local application logging.""" + env_debug = os.environ.get("DLCLIVEGUI_DEBUG_LOGGING", "").strip().lower() in ( + "1", + "true", + "yes", + "on", + "debug", + ) + + enabled = bool(debug or env_debug) + level = logging.DEBUG if enabled else logging.INFO + + logging.basicConfig( + level=level, + format="%(asctime)s.%(msecs)03d %(levelname)-8s [%(threadName)s] %(name)s:%(lineno)d - %(message)s", + datefmt="%H:%M:%S", + force=True, + ) + + logging.getLogger("dlclivegui").setLevel(level) + + if enabled: + logging.debug("Debug logging enabled.") def parse_args(argv=None): @@ -77,12 +142,13 @@ def parse_args(argv=None): formatter_class=argparse.RawDescriptionHelpFormatter, ) parser.add_argument("--no-art", action="store_true", help="Disable ASCII art in help and when launching.") + parser.add_argument("--debug-log", action="store_true", help="Enable debug logging.") return parser.parse_known_args(argv) def main() -> None: args, _unknown = parse_args() - + configure_logging(debug=args.debug_log) logging.info("Starting DeepLabCut-Live GUI...") # If you want a startup banner, PRINT it (not log), and only in TTY contexts. diff --git a/dlclivegui/services/multi_camera_controller.py b/dlclivegui/services/multi_camera_controller.py index 18b2883a..ee3061f9 100644 --- a/dlclivegui/services/multi_camera_controller.py +++ b/dlclivegui/services/multi_camera_controller.py @@ -2,6 +2,7 @@ from __future__ import annotations +import copy import logging import time from dataclasses import dataclass @@ -15,9 +16,16 @@ from dlclivegui.cameras import CameraFactory from dlclivegui.cameras.base import CameraBackend +from dlclivegui.cameras.factory import camera_identity_key # from dlclivegui.config import CameraSettings -from dlclivegui.config import CameraSettings +from dlclivegui.config import ( + GUI_MAX_DISPLAY_FPS, + MULTI_CAMERA_WORKER_DO_LOG_TIMING, + SINGLE_CAMERA_WORKER_DO_LOG_TIMING, + CameraSettings, +) +from dlclivegui.utils.stats import WorkerTimingStats LOGGER = logging.getLogger(__name__) @@ -33,6 +41,7 @@ class MultiFrameData: timestamps: dict[str, float] # camera_id -> timestamp source_camera_id: str = "" # ID of camera that triggered this emission tiled_frame: np.ndarray | None = None # Combined tiled frame (deprecated, done in GUI) + display_ids: dict[str, str] = None # camera_id -> display_id (for labeling) class SingleCameraWorker(QObject): @@ -46,18 +55,41 @@ class SingleCameraWorker(QObject): def __init__(self, camera_id: str, settings: CameraSettings): super().__init__() self._camera_id = camera_id - self._settings = settings + self._settings = copy.deepcopy(settings) self._stop_event = Event() self._backend: CameraBackend | None = None self._max_consecutive_errors = 5 self._retry_delay = 0.1 + self._trigger_timeout_delay = 0.05 + + # Performance logs + self._timing = WorkerTimingStats( + camera_id, logger=LOGGER, log_interval=1.0, enabled=SINGLE_CAMERA_WORKER_DO_LOG_TIMING + ) @Slot() def run(self) -> None: self._stop_event.clear() try: + LOGGER.debug( + "[Worker %s] before create: backend=%s index=%s properties=%s", + self._camera_id, + self._settings.backend, + self._settings.index, + self._settings.properties, + ) + self._backend = CameraFactory.create(self._settings) + + LOGGER.debug( + "[Worker %s] after create: backend=%s index=%s properties=%s", + self._camera_id, + self._backend.settings.backend, + self._backend.settings.index, + self._backend.settings.properties, + ) + self._backend.open() except Exception as exc: LOGGER.exception(f"Failed to initialize camera {self._camera_id}", exc_info=exc) @@ -70,7 +102,8 @@ def run(self) -> None: while not self._stop_event.is_set(): try: - frame, timestamp = self._backend.read() + with self._timing.measure("Single.read"): + frame, timestamp = self._backend.read() if frame is None or frame.size == 0: consecutive_errors += 1 if consecutive_errors >= self._max_consecutive_errors: @@ -78,20 +111,57 @@ def run(self) -> None: self._camera_id, "Too many empty frames.\nWas the device disconnected ?" ) break - time.sleep(self._retry_delay) + if self._stop_event.wait(self._retry_delay): + break continue consecutive_errors = 0 - self.frame_captured.emit(self._camera_id, frame, timestamp) + with self._timing.measure("Single.emit.frame_captured"): + self.frame_captured.emit(self._camera_id, frame, timestamp) + + self._timing.note_frame() + self._timing.maybe_log() + + except TimeoutError as exc: + self._timing.note_timeout() + self._timing.maybe_log() + 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 + + if self._stop_event.wait(self._trigger_timeout_delay): + break # Stop event set during wait + continue + + consecutive_errors += 1 + if consecutive_errors >= self._max_consecutive_errors: + self.error_occurred.emit(self._camera_id, f"Camera read timeout: {exc}") + break + if self._stop_event.wait(self._retry_delay): + break + continue except Exception as exc: + self._timing.note_error() + self._timing.maybe_log() consecutive_errors += 1 if self._stop_event.is_set(): break if consecutive_errors >= self._max_consecutive_errors: self.error_occurred.emit(self._camera_id, f"Camera read error: {exc}") break - time.sleep(self._retry_delay) + if self._stop_event.wait(self._retry_delay): + break continue # Cleanup @@ -106,16 +176,73 @@ def stop(self) -> None: self._stop_event.set() -def get_camera_id(settings: CameraSettings) -> str: - """Generate a unique camera ID from settings.""" +def get_display_id(settings: CameraSettings) -> str: return f"{settings.backend}:{settings.index}" +def get_camera_id(settings: CameraSettings) -> str: + """Generate a unique camera ID from stable backend identity.""" + 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 {} + + device_id = ns.get("device_id") + if device_id: + return f"{backend}:{device_id}" + + serial = ns.get("serial_number") or ns.get("device_serial_number") or ns.get("serial") + if serial: + return f"{backend}:serial:{serial}" + + 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.""" # Signals - frame_ready = Signal(object) # MultiFrameData + frame_ready = Signal(object) # MultiFrameData (full cam FPS; recording and inference only) + display_ready = Signal(object) # MultiFrameData for GUI display (throttled to GUI_MAX_DISPLAY_FPS) camera_started = Signal(str, object) # camera_id, settings camera_stopped = Signal(str) # camera_id camera_error = Signal(str, str) # camera_id, error_message @@ -135,9 +262,17 @@ def __init__(self): self._frame_lock = Lock() self._running = False self._started_cameras: set = set() + self._camera_display_order: list[str] = [] + self._display_ids: dict[str, str] = {} # camera_id -> display_id (for labeling) self._failed_cameras: dict[str, str] = {} # camera_id -> error message self._expected_cameras: int = 0 # Number of cameras we're trying to start + # GUI display max FPS (for throttling display updates when many cameras are active) + self._gui_display_max_fps: float = GUI_MAX_DISPLAY_FPS + self._gui_display_last_emit: float = 0.0 + # Performance logs + self._timing_per_cam: dict[str, WorkerTimingStats] = {} + def is_running(self) -> bool: """Check if any camera is currently running.""" return self._running and len(self._started_cameras) > 0 @@ -146,42 +281,109 @@ def get_active_count(self) -> int: """Get the number of active cameras.""" return len(self._started_cameras) + def _timing_for_camera(self, camera_id: str) -> WorkerTimingStats: + timing = self._timing_per_cam.get(camera_id) + if timing is None: + timing = WorkerTimingStats( + f"Controller {camera_id}", + logger=LOGGER, + log_interval=1.0, + enabled=MULTI_CAMERA_WORKER_DO_LOG_TIMING, + ) + self._timing_per_cam[camera_id] = timing + return timing + + def _should_emit_display_ready(self) -> bool: + """Return True when the UI/display path should be updated. + + This only throttles display_ready. It must not throttle frame_ready, + because frame_ready is used for full-rate consumers such as recording. + """ + if self._gui_display_max_fps <= 0: + return True + + now = time.perf_counter() + min_interval = 1.0 / max(self._gui_display_max_fps, 1e-9) + + if now - self._gui_display_last_emit < min_interval: + return False + + self._gui_display_last_emit = now + return True + def start(self, camera_settings: list[CameraSettings]) -> None: """Start multiple cameras.""" if self._running: LOGGER.warning("Multi-camera controller already running") return - active_settings = [s for s in camera_settings if s.enabled][: self.MAX_CAMERAS] + active_settings_user_order = [s for s in camera_settings if s.enabled][: self.MAX_CAMERAS] + if not active_settings_user_order: + LOGGER.warning("No active cameras to start") + return + + # Display/tile order follows the user-configured camera order. + self._camera_display_order = [get_camera_id(s) for s in active_settings_user_order] + + # Startup order may differ for trigger safety: + # followers/external first, master last. + active_settings = sorted(active_settings_user_order, key=_camera_start_priority) if not active_settings: LOGGER.warning("No active cameras to start") return + # Check for dupes + seen = {} + for s in active_settings: + camera_id = get_camera_id(s) + try: + key = camera_identity_key(s) + except Exception: + LOGGER.exception( + "Failed to compute camera identity key for %s; falling back to camera_id", + camera_id, + ) + key = camera_id + + if key in seen: + self.initialization_failed.emit( + [ + ( + camera_id, + f"Duplicate camera configuration. Conflicts with {seen[key]}", + ) + ] + ) + return + + seen[key] = camera_id + self._running = True self._frames.clear() self._timestamps.clear() self._started_cameras.clear() self._failed_cameras.clear() - - unique_ids = {get_camera_id(s) for s in active_settings} - self._expected_cameras = len(unique_ids) + self._display_ids.clear() + self._expected_cameras = len(active_settings) for settings in active_settings: self._start_camera(settings) def _start_camera(self, settings: CameraSettings) -> None: """Start a single camera.""" - cam_id = get_camera_id(settings) - existing_thread = self._threads.get(cam_id) - if cam_id in self._workers and (existing_thread is None or not existing_thread.isRunning()): - LOGGER.warning(f"Stale camera worker/thread found for {cam_id}, cleaning up") - self._cleanup_camera(cam_id) + settings_copy = copy.deepcopy(settings) + cam_id = get_camera_id(settings_copy) + display_id = get_display_id(settings_copy) + if cam_id in self._workers: LOGGER.warning(f"Camera {cam_id} is already running, skipping start") return + LOGGER.info(f"[MultiCameraController] Starting {cam_id} with settings: {settings_copy}") + # Normalize and store the dataclass once - self._settings[cam_id] = settings + self._settings[cam_id] = settings_copy + self._display_ids[cam_id] = display_id dc = self._settings[cam_id] worker = SingleCameraWorker(cam_id, dc) thread = QThread() @@ -280,8 +482,15 @@ def stop(self, wait: bool = True) -> None: self.all_stopped.emit() return + self._timing_per_cam.clear() + self._gui_display_last_emit = 0.0 + self._workers.clear() + self._threads.clear() + self._settings.clear() self._started_cameras.clear() self._failed_cameras.clear() + self._camera_display_order.clear() + self._display_ids.clear() with self._frame_lock: self._frames.clear() self._timestamps.clear() @@ -291,30 +500,65 @@ def stop(self, wait: bool = True) -> None: def _on_frame_captured(self, camera_id: str, frame: np.ndarray, timestamp: float) -> None: """Handle a frame from one camera.""" - # Apply rotation if configured - settings = self._settings.get(camera_id) - if settings and settings.rotation: - frame = MultiCameraController.apply_rotation(frame, settings.rotation) - - # Apply cropping if configured - if settings: - crop_region = settings.get_crop_region() - if crop_region: - frame = MultiCameraController.apply_crop(frame, crop_region) - - with self._frame_lock: - self._frames[camera_id] = frame - self._timestamps[camera_id] = timestamp - - # Emit frame data without tiling (tiling done in GUI for performance) - if self._frames: - frame_data = MultiFrameData( - frames=dict(self._frames), - timestamps=dict(self._timestamps), - source_camera_id=camera_id, # Track which camera triggered this - tiled_frame=None, - ) - self.frame_ready.emit(frame_data) + timing = self._timing_for_camera(camera_id) + frame_data: MultiFrameData | None = None + + with timing.measure("Multi.slot.total"): + settings = self._settings.get(camera_id) + + with timing.measure("Multi.apply_transforms"): + if settings and settings.rotation: + frame = MultiCameraController.apply_rotation(frame, settings.rotation) + + if settings: + crop_region = settings.get_crop_region() + if crop_region: + frame = MultiCameraController.apply_crop(frame, crop_region) + + with self._frame_lock: + with timing.measure("Multi.store_latest"): + self._frames[camera_id] = frame + self._timestamps[camera_id] = timestamp + + with timing.measure("Multi.build_ordered"): + ordered_frames: dict[str, np.ndarray] = {} + ordered_timestamps: dict[str, float] = {} + + for cam_id in self._camera_display_order: + if cam_id in self._frames: + ordered_frames[cam_id] = self._frames[cam_id] + if cam_id in self._timestamps: + ordered_timestamps[cam_id] = self._timestamps[cam_id] + + # Any unexpected/legacy IDs, appended deterministically. + for cam_id in self._frames: + if cam_id not in ordered_frames: + ordered_frames[cam_id] = self._frames[cam_id] + for cam_id in self._timestamps: + if cam_id not in ordered_timestamps: + ordered_timestamps[cam_id] = self._timestamps[cam_id] + + with timing.measure("Multi.construct_frame_data"): + frame_data = MultiFrameData( + frames=ordered_frames, + timestamps=ordered_timestamps, + source_camera_id=camera_id, + tiled_frame=None, + display_ids=dict(self._display_ids), + ) + + + if frame_data is not None: + with timing.measure("Multi.emit.frame_ready"): + self.frame_ready.emit(frame_data) + + # GUI-only path: throttled display updates + if self._should_emit_display_ready(): + with timing.measure("Multi.emit.display_ready"): + self.display_ready.emit(frame_data) + + timing.note_frame() + timing.maybe_log() @staticmethod def apply_rotation(frame: np.ndarray, degrees: int) -> np.ndarray: @@ -500,6 +744,7 @@ def _on_camera_stopped(self, camera_id: str) -> None: # Check if this camera never started (initialization failure) was_started = camera_id in self._started_cameras self._started_cameras.discard(camera_id) + self._display_ids.pop(camera_id, None) self.camera_stopped.emit(camera_id) LOGGER.info(f"Camera {camera_id} stopped (was_started={was_started})") diff --git a/dlclivegui/utils/display.py b/dlclivegui/utils/display.py index 0eac657c..5cd29744 100644 --- a/dlclivegui/utils/display.py +++ b/dlclivegui/utils/display.py @@ -38,10 +38,10 @@ def compute_tiling_geometry( """Compute consistent tiling geometry for both tiling and overlay transforms. Returns: - (sorted_cam_ids, rows, cols, tile_w, tile_h) + (cam_ids, rows, cols, tile_w, tile_h) Notes: - - We intentionally base tile aspect on the first frame in sorted_cam_ids, + - We intentionally base tile aspect on the first frame in cam_ids, because create_tiled_frame uses the same ordering. This guarantees that compute_tile_info() and create_tiled_frame() agree on tile_w/tile_h. - If frames have different aspect ratios, they will be resized (possibly distorted) @@ -50,7 +50,7 @@ def compute_tiling_geometry( if not frames: return ([], 1, 1, 640, 480) - cam_ids = sorted(frames.keys()) + cam_ids = list(frames.keys()) frames_list = [frames[cid] for cid in cam_ids] num_frames = len(frames_list) @@ -63,7 +63,7 @@ def compute_tiling_geometry( max_w, max_h = max_canvas - # Reference aspect is based on the first frame in sorted order (matches tiler). + # Reference aspect is based on the first frame in display order (matches tiler). h0, w0 = frames_list[0].shape[:2] frame_aspect = (w0 / h0) if h0 > 0 else 1.0 @@ -83,7 +83,9 @@ def compute_tiling_geometry( return cam_ids, rows, cols, tile_w, tile_h -def create_tiled_frame(frames: dict[str, np.ndarray], max_canvas: tuple[int, int] = (1200, 800)) -> np.ndarray: +def create_tiled_frame( + frames: dict[str, np.ndarray], max_canvas: tuple[int, int] = (1200, 800), labels: dict[str, str] = None +) -> np.ndarray: """Create a tiled canvas (1x1, 1x2, or 2x2) with camera-id labels. Uses compute_tiling_geometry() so tile_w/tile_h are consistent with compute_tile_info(). @@ -105,10 +107,11 @@ def create_tiled_frame(frames: dict[str, np.ndarray], max_canvas: tuple[int, int frame = cv2.cvtColor(frame, cv2.COLOR_BGRA2BGR) resized = cv2.resize(frame, (tile_w, tile_h), interpolation=cv2.INTER_AREA) + label = labels.get(cam_id, cam_id) if labels else cam_id cv2.putText( resized, - cam_id, + label, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, @@ -135,7 +138,7 @@ def compute_tile_info( Critical robustness fix: - Tile dimensions are computed from the same reference used by create_tiled_frame() - (first frame in sorted order), so offsets/scales match the actual tiling. + (first frame in display order), so offsets/scales match the actual tiling. """ if not frames: return (0, 0), (1.0, 1.0) diff --git a/dlclivegui/utils/stats.py b/dlclivegui/utils/stats.py index 23e9d57f..38e3798b 100644 --- a/dlclivegui/utils/stats.py +++ b/dlclivegui/utils/stats.py @@ -1,10 +1,113 @@ # dlclivegui/utils/stats.py from __future__ import annotations +import logging +import time + from dlclivegui.services.dlc_processor import ProcessorStats from dlclivegui.services.video_recorder import RecorderStats +class WorkerTimingStats: + """Tiny timing accumulator for camera worker performance diagnostics. + + Usage: + with stats.measure("read"): + frame, ts = backend.read() + + Logs aggregate timings once per log_interval seconds. + """ + + def __init__( + self, camera_id: str, *, logger: logging.Logger | None = None, log_interval: float = 1.0, enabled: bool = True + ): + self.camera_id = camera_id + self.log_interval = float(log_interval) + self.enabled = bool(enabled) + self.logger = logger or logging.getLogger(__name__) + if self.enabled: # force logger to proper level + if not self.logger.isEnabledFor(logging.DEBUG): + self.logger.setLevel(logging.DEBUG) + + self._last_log = time.perf_counter() + self._frames = 0 + self._timeouts = 0 + self._errors = 0 + self._totals: dict[str, float] = {} + self._counts: dict[str, int] = {} + + class _Measure: + def __init__(self, parent: WorkerTimingStats, name: str): + self.parent = parent + self.name = name + self.t0 = 0.0 + + def __enter__(self): + if self.parent.enabled: + self.t0 = time.perf_counter() + return self + + def __exit__(self, exc_type, exc, tb): + if not self.parent.enabled: + return False + + dt = time.perf_counter() - self.t0 + self.parent._totals[self.name] = self.parent._totals.get(self.name, 0.0) + dt + self.parent._counts[self.name] = self.parent._counts.get(self.name, 0) + 1 + return False + + def measure(self, name: str): + return self._Measure(self, name) + + def note_frame(self) -> None: + if self.enabled: + self._frames += 1 + + def note_timeout(self) -> None: + if self.enabled: + self._timeouts += 1 + + def note_error(self) -> None: + if self.enabled: + self._errors += 1 + + def maybe_log(self) -> None: + if not self.enabled: + return + + now = time.perf_counter() + elapsed = now - self._last_log + if elapsed < self.log_interval: + return + + fps = self._frames / max(elapsed, 1e-9) + + parts = [ + f"[Worker {self.camera_id}]", + f"fps={fps:.1f}", + f"frames={self._frames}", + ] + + if self._timeouts: + parts.append(f"timeouts={self._timeouts}") + if self._errors: + parts.append(f"errors={self._errors}") + + for name in sorted(self._totals): + count = max(self._counts.get(name, 0), 1) + avg_ms = 1000.0 * self._totals[name] / count + parts.append(f"avg_{name}_ms={avg_ms:.3f}") + + self.logger.debug(" ".join(parts)) + + self._last_log = now + self._frames = 0 + self._timeouts = 0 + self._errors = 0 + self._totals.clear() + self._counts.clear() + + def format_recorder_stats(stats: RecorderStats) -> str: latency_ms = stats.last_latency * 1000.0 avg_ms = stats.average_latency * 1000.0 diff --git a/tests/cameras/backends/conftest.py b/tests/cameras/backends/conftest.py index 2d965a2e..f0a0b6b2 100644 --- a/tests/cameras/backends/conftest.py +++ b/tests/cameras/backends/conftest.py @@ -4,6 +4,7 @@ import importlib import logging import os +import threading from dataclasses import dataclass from typing import Any @@ -598,6 +599,18 @@ def __init__( self.GainAuto = _FakeNode("Off") self.Gain = _FakeNode(float(gain)) + # Trigger input nodes + self.AcquisitionMode = _FakeNode("Continuous", symbolics=["Continuous", "SingleFrame"]) + self.TriggerSelector = _FakeNode("FrameStart", symbolics=["FrameStart"]) + self.TriggerMode = _FakeNode("Off", symbolics=["Off", "On"]) + self.TriggerSource = _FakeNode("Line1", symbolics=["Line0", "Line1", "Software"]) + self.TriggerActivation = _FakeNode("RisingEdge", symbolics=["RisingEdge", "FallingEdge"]) + + # GPIO output nodes for master/follower setups + self.LineSelector = _FakeNode("Line0", symbolics=["Line0", "Line1", "Line2"]) + self.LineMode = _FakeNode("Input", symbolics=["Input", "Output"]) + self.LineSource = _FakeNode("Off", symbolics=["Off", "ExposureActive", "AcquisitionActive"]) + class _FakeRemoteDevice: def __init__(self, node_map: _FakeNodeMap): @@ -641,6 +654,122 @@ def __exit__(self, exc_type, exc, tb): return False +class FakeSharedHarvesterPoolAcquireError(RuntimeError): + """Raised by the fake shared pool when no CTI can be loaded.""" + + def __init__(self, message: str, *, loaded_files=None, failed_files=None): + super().__init__(message) + self.loaded_files = list(loaded_files or []) + self.failed_files = list(failed_files or []) + + +class FakeSharedEntry: + def __init__(self, harvester, loaded_files, failed_files=None): + self.harvester = harvester + self.loaded_files = list(loaded_files or []) + self.failed_files = list(failed_files or []) + self.lock = threading.RLock() + + +class FakeSharedHarvesterPool: + """ + Test double for cti_finder.SharedHarvesterPool. + + Important behavior: + - Reuses one Harvester per normalized CTI set. + - Calls update() only when creating the shared Harvester. + - Does not call update() when reusing an existing shared Harvester. + - Tracks loaded_files/failed_files so backend diagnostics can be tested. + """ + + _entries: dict[tuple[str, ...], FakeSharedEntry] = {} + _refcounts: dict[tuple[str, ...], int] = {} + _harvester_factory = None + + @classmethod + def configure(cls, harvester_factory): + cls.reset() + cls._harvester_factory = harvester_factory + + @staticmethod + def _key(cti_files) -> tuple[str, ...]: + # Stable across case/path spelling on Windows while preserving loaded_files separately. + return tuple(sorted(os.path.normcase(os.path.abspath(str(p))) for p in cti_files)) + + @classmethod + def acquire(cls, cti_files): + key = cls._key(cti_files) + + if key in cls._entries: + cls._refcounts[key] += 1 + return cls._entries[key] + + if cls._harvester_factory is None: + raise RuntimeError("FakeSharedHarvesterPool is not configured") + + h = cls._harvester_factory() + + loaded: list[str] = [] + failed: list[tuple[str, str]] = [] + + for cti in cti_files: + cti_str = str(cti) + try: + h.add_file(cti_str) + loaded.append(cti_str) + except Exception as exc: + failed.append((cti_str, str(exc))) + + if not loaded: + try: + h.reset() + except Exception: + pass + raise FakeSharedHarvesterPoolAcquireError( + "No fake CTIs could be loaded", + loaded_files=[], + failed_files=failed, + ) + + h.update() + + entry = FakeSharedEntry(h, loaded_files=loaded, failed_files=failed) + cls._entries[key] = entry + cls._refcounts[key] = 1 + return entry + + @classmethod + def release(cls, entry): + for key, value in list(cls._entries.items()): + if value is entry: + cls._refcounts[key] -= 1 + if cls._refcounts[key] <= 0: + try: + entry.harvester.reset() + except Exception: + pass + del cls._entries[key] + del cls._refcounts[key] + return + + @classmethod + def get_refcount(cls, entry): + for key, value in cls._entries.items(): + if value is entry: + return cls._refcounts[key] + return 0 + + @classmethod + def reset(cls): + for entry in list(cls._entries.values()): + try: + entry.harvester.reset() + except Exception: + pass + cls._entries.clear() + cls._refcounts.clear() + + @dataclass class FakeImageAcquirer: """ @@ -691,6 +820,7 @@ def _enqueue_default_frame(self): def start(self): self.start_calls += 1 self._started = True + self._queue.clear() def stop(self): self.stop_calls += 1 @@ -707,10 +837,28 @@ def fetch(self, timeout: float = 2.0): if not self._started: raise FakeGenTLTimeoutException("fetch called while not started") - if not self._queue: - raise FakeGenTLTimeoutException(f"timeout after {timeout}s") + if self._queue: + payload = self._queue.pop(0) + else: + # Generate from the current node map, because backend may have changed + # PixelFormat/Width/Height during open(). + pf = str(self.node_map.PixelFormat.value or "Mono8") + if pf in ("RGB8", "BGR8"): + channels, dtype = 3, np.uint8 + elif pf in ("Mono16", "Mono12", "Mono10"): + channels, dtype = 1, np.uint16 + else: + # Mono8 and Bayer*8 are single-channel uint8 + channels, dtype = 1, np.uint8 + + comp = _FakeComponent( + int(self.node_map.Width.value), + int(self.node_map.Height.value), + channels, + dtype=dtype, + ) + payload = _FakePayload(comp) - payload = self._queue.pop(0) return _FakeFetchedBufferCtx(payload) @@ -854,18 +1002,37 @@ def gentl_fail_add_file_for(): def patch_gentl_sdk(monkeypatch, fake_harvester_factory, gentl_fail_add_file_for, tmp_path): """ Patch dlclivegui.cameras.backends.gentl_backend to use FakeHarvester + Fake timeout. - Ensure CTI discovery succeeds for classmethods by creating a real dummy .cti and - exposing it via GENICAM_GENTL64_PATH. + + Important: + The production backend now uses cti_finder.SharedHarvesterPool.acquire() + during open(), so tests must patch that pool too. """ import dlclivegui.cameras.backends.gentl_backend as gb - # Patch Harvester symbol (the backend calls Harvester() directly) + # Reset and expose test counters/state. + gb.update_count = 0 + gb.fail_add_file_for = gentl_fail_add_file_for + + # Patch Harvester symbol for discovery/rebind paths. monkeypatch.setattr(gb, "Harvester", lambda: fake_harvester_factory(), raising=False) - # Keep timeout contract + # Count all fake update() calls. + original_update = FakeHarvester.update + + def update_with_count(self): + gb.update_count += 1 + return original_update(self) + + monkeypatch.setattr(FakeHarvester, "update", update_with_count, raising=True) + + # Keep timeout contract. monkeypatch.setattr(gb, "HarvesterTimeoutError", FakeGenTLTimeoutException, raising=False) - # Create a real CTI file and advertise it via env var + # Patch the shared pool used by open(). + FakeSharedHarvesterPool.configure(fake_harvester_factory) + monkeypatch.setattr(gb.cti_finder, "SharedHarvesterPool", FakeSharedHarvesterPool, raising=False) + + # Create a real CTI file and advertise it via env var. cti_file = tmp_path / "dummy.cti" if not cti_file.exists(): cti_file.write_text("fake", encoding="utf-8") @@ -873,10 +1040,11 @@ def patch_gentl_sdk(monkeypatch, fake_harvester_factory, gentl_fail_add_file_for monkeypatch.setenv("GENICAM_GENTL64_PATH", str(tmp_path)) monkeypatch.delenv("GENICAM_GENTL32_PATH", raising=False) - # OPTIONAL: expose failure control so tests can do gb.fail_add_file_for.add(...) - gb.fail_add_file_for = gentl_fail_add_file_for - - return gb + try: + yield gb + finally: + FakeSharedHarvesterPool.reset() + gb.fail_add_file_for = set() @pytest.fixture() diff --git a/tests/cameras/backends/test_gentl_backend.py b/tests/cameras/backends/test_gentl_backend.py index ecef1b7a..3ffdab20 100644 --- a/tests/cameras/backends/test_gentl_backend.py +++ b/tests/cameras/backends/test_gentl_backend.py @@ -318,11 +318,12 @@ def test_quick_ping_true_for_existing_false_for_missing(patch_gentl_sdk, gentl_i assert gb.GenTLCameraBackend.quick_ping(1) is False -def test_rebind_settings_updates_index_using_device_id_with_attribute_entries( +def test_rebind_settings_serial_device_id_persists_serial_without_enumeration( patch_gentl_sdk, gentl_settings_factory, gentl_inventory ): """ - rebind_settings has some getattr(...) usage; feed attribute-like entries to match that path. + Serial GenTL IDs are handled directly by open(), so rebind_settings() + intentionally avoids Harvester enumeration and leaves index unchanged. """ gb = patch_gentl_sdk @@ -338,9 +339,12 @@ def test_rebind_settings_updates_index_using_device_id_with_attribute_entries( settings = gentl_settings_factory(index=0, properties={"gentl": {"device_id": "serial:SER1"}}) out = gb.GenTLCameraBackend.rebind_settings(settings) - assert int(out.index) == 1 + # New behavior: no enumeration/rebind for serial IDs. + assert int(out.index) == 0 + ns = out.properties.get("gentl", {}) assert ns.get("device_id") == "serial:SER1" + assert ns.get("serial_number") == "SER1" def test_rebind_settings_no_device_id_no_change(patch_gentl_sdk, gentl_settings_factory, gentl_inventory): @@ -470,102 +474,6 @@ def create(self, *args, **kwargs): assert acq == "ACQ_POS_INDEX" -def test__create_acquirer_falls_back_to_create_image_acquirer_when_create_fails( - patch_gentl_sdk, gentl_settings_factory -): - gb = patch_gentl_sdk - - settings = gentl_settings_factory() - be = gb.GenTLCameraBackend(settings) - - class H: - device_info_list = [{"serial_number": "SER0"}] - - def create(self, *args, **kwargs): - raise RuntimeError("create fails") - - def create_image_acquirer(self, selector=None, index=None): - # Succeeds here - if isinstance(selector, dict) and selector.get("serial_number") == "SERX": - return "ACQ_CIA_SERIAL" - if index == 1: - return "ACQ_CIA_INDEX" - return "ACQ_CIA_OTHER" - - be._harvester = H() - acq = be._create_acquirer("SERX", 1) - assert acq == "ACQ_CIA_SERIAL" - - -def test__create_acquirer_uses_device_info_fallback_when_available(patch_gentl_sdk, gentl_settings_factory): - gb = patch_gentl_sdk - - settings = gentl_settings_factory() - be = gb.GenTLCameraBackend(settings) - - device_info_obj = {"serial_number": "SER0", "id_": "ID0"} - - class H: - device_info_list = [device_info_obj] - - def create(self, *args, **kwargs): - # Fail index, succeed if given device_info object - if "index" in kwargs or (len(args) == 1 and isinstance(args[0], int)): - raise RuntimeError("index path fails") - if len(args) == 1 and args[0] is device_info_obj: - return "ACQ_DEVICE_INFO" - raise RuntimeError("unexpected call") - - be._harvester = H() - acq = be._create_acquirer(None, 0) - assert acq == "ACQ_DEVICE_INFO" - - -def test__create_acquirer_tries_default_create_when_index0_and_no_serial(patch_gentl_sdk, gentl_settings_factory): - gb = patch_gentl_sdk - - settings = gentl_settings_factory() - be = gb.GenTLCameraBackend(settings) - - class H: - device_info_list = [{"serial_number": "SER0"}] - - def create(self, *args, **kwargs): - # Fail index attempts; succeed only on no-arg create() - if args or kwargs: - raise RuntimeError("only no-arg create works") - return "ACQ_DEFAULT" - - be._harvester = H() - acq = be._create_acquirer(None, 0) - assert acq == "ACQ_DEFAULT" - - -def test__create_acquirer_raises_runtimeerror_with_joined_errors(patch_gentl_sdk, gentl_settings_factory): - gb = patch_gentl_sdk - - settings = gentl_settings_factory() - be = gb.GenTLCameraBackend(settings) - - class H: - device_info_list = [{"serial_number": "SER0"}] - - def create(self, *args, **kwargs): - raise RuntimeError("create boom") - - def create_image_acquirer(self, *args, **kwargs): - raise RuntimeError("cia boom") - - be._harvester = H() - - with pytest.raises(RuntimeError) as ei: - be._create_acquirer("SERX", 0) - - # Error message should include some context about attempted creation methods - msg = str(ei.value).lower() - assert "failed to initialise gentl image acquirer" in msg - - # ---------------------------------- # CTI discovery and selection logic # ---------------------------------- @@ -767,3 +675,128 @@ def test_open_persists_cti_load_diagnostics_complete_failure(patch_gentl_sdk, ge assert sorted(d["cti"] for d in failed) == sorted([str(b1), str(b2)]) for d in failed: assert isinstance(d.get("error"), str) and d["error"] + + +def test_two_gentl_backends_share_same_harvester(patch_gentl_sdk, gentl_settings_factory, gentl_inventory): + gb = patch_gentl_sdk + + gentl_inventory[:] = [ + {"display_name": "Dev0", "serial_number": "SER0"}, + {"display_name": "Dev1", "serial_number": "SER1"}, + ] + + s0 = gentl_settings_factory(index=0, properties={"gentl": {"device_id": "serial:SER0"}}) + s1 = gentl_settings_factory(index=1, properties={"gentl": {"device_id": "serial:SER1"}}) + + b0 = gb.GenTLCameraBackend(s0) + b1 = gb.GenTLCameraBackend(s1) + + b0.open() + b1.open() + + assert b0._harvester is b1._harvester + assert b0._shared_entry is b1._shared_entry + + b1.close() + b0.close() + + +def test_second_open_reuses_shared_harvester_without_update(patch_gentl_sdk, gentl_settings_factory, gentl_inventory): + gb = patch_gentl_sdk + + gentl_inventory[:] = [ + {"display_name": "Dev0", "serial_number": "SER0"}, + {"display_name": "Dev1", "serial_number": "SER1"}, + ] + + s0 = gentl_settings_factory(index=0, properties={"gentl": {"device_id": "serial:SER0"}}) + s1 = gentl_settings_factory(index=1, properties={"gentl": {"device_id": "serial:SER1"}}) + + b0 = gb.GenTLCameraBackend(s0) + b1 = gb.GenTLCameraBackend(s1) + + b0.open() + update_count_after_first = gb.update_count + + b1.open() + + assert gb.update_count == update_count_after_first + + b1.close() + b0.close() + + +def test_open_failure_releases_shared_harvester(patch_gentl_sdk, gentl_settings_factory, gentl_inventory): + gb = patch_gentl_sdk + + gentl_inventory[:] = [{"display_name": "Dev0", "serial_number": "SER0"}] + + settings = gentl_settings_factory(properties={"gentl": {"device_id": "serial:DOES_NOT_EXIST"}}) + be = gb.GenTLCameraBackend(settings) + + with pytest.raises(RuntimeError): + be.open() + + assert be._harvester is None + assert be._shared_entry is None + assert be._acquirer is None + + +def test__create_acquirer_serial_create_runtimeerror_propagates(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + be = gb.GenTLCameraBackend(gentl_settings_factory()) + + class H: + device_info_list = [{"serial_number": "SER0"}] + + def create(self, *args, **kwargs): + raise RuntimeError("create fails") + + def create_image_acquirer(self, *args, **kwargs): + return "SHOULD_NOT_BE_USED" + + be._harvester = H() + + with pytest.raises(RuntimeError, match="create fails"): + be._create_acquirer("SERX", 1) + + +def test__create_acquirer_index_runtimeerror_propagates(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + be = gb.GenTLCameraBackend(gentl_settings_factory()) + + class H: + device_info_list = [{"serial_number": "SER0"}] + + def create(self, *args, **kwargs): + if len(args) == 1 and args[0] == 0: + raise RuntimeError("index path fails") + return "UNEXPECTED" + + be._harvester = H() + + with pytest.raises(RuntimeError, match="index path fails"): + be._create_acquirer(None, 0) + + +def test__create_acquirer_positional_typeerror_falls_back_to_index_keyword(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + be = gb.GenTLCameraBackend(gentl_settings_factory()) + + class H: + device_info_list = [{"serial_number": "SER0"}] + + def create(self, *args, **kwargs): + if args: + raise TypeError("positional index not supported") + if kwargs.get("index") == 2: + return "ACQ_KW_INDEX" + raise RuntimeError("unexpected call") + + be._harvester = H() + + acq = be._create_acquirer(None, 2) + assert acq == "ACQ_KW_INDEX" diff --git a/tests/cameras/backends/test_gentl_trigger.py b/tests/cameras/backends/test_gentl_trigger.py new file mode 100644 index 00000000..57339a10 --- /dev/null +++ b/tests/cameras/backends/test_gentl_trigger.py @@ -0,0 +1,460 @@ +# tests/cameras/backends/test_gentl_trigger.py +from __future__ import annotations + +import pytest + +# --------------------------------------------------------------------- +# GenTL hardware trigger configuration +# --------------------------------------------------------------------- + + +def _gentl_trigger_settings(gentl_settings_factory, trigger: dict, **kwargs): + """Build CameraSettings with a GenTL trigger block.""" + return gentl_settings_factory(properties={"gentl": {"trigger": trigger}}, **kwargs) + + +def test_gentl_capabilities_advertise_hardware_trigger_best_effort(patch_gentl_sdk): + gb = patch_gentl_sdk + + caps = gb.GenTLCameraBackend.static_capabilities() + + assert caps.get("hardware_trigger") == gb.SupportLevel.BEST_EFFORT + + +def test_trigger_default_off_configures_trigger_mode_off(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = gentl_settings_factory() + be = gb.GenTLCameraBackend(settings) + + be.open() + nm = be._acquirer.remote_device.node_map + + assert nm.TriggerMode.value == "Off" + + ns = settings.properties.get("gentl", {}) + assert ns.get("trigger_actual", {}).get("role") == "off" + + be.close() + + +def test_trigger_explicit_off_configures_trigger_mode_off(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings(gentl_settings_factory, {"role": "off"}) + be = gb.GenTLCameraBackend(settings) + + be.open() + nm = be._acquirer.remote_device.node_map + + assert nm.TriggerMode.value == "Off" + assert settings.properties["gentl"]["trigger_actual"]["role"] == "off" + + be.close() + + +def test_trigger_external_configures_input_line_and_timeout(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "external", + "selector": "FrameStart", + "source": "Line0", + "activation": "RisingEdge", + "timeout": gb.GenTLCameraBackend._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT, + }, + ) + be = gb.GenTLCameraBackend(settings) + + be.open() + nm = be._acquirer.remote_device.node_map + + assert nm.TriggerSelector.value == "FrameStart" + assert nm.TriggerSource.value == "Line0" + assert nm.TriggerActivation.value == "RisingEdge" + assert nm.TriggerMode.value == "On" + assert be.waits_for_hardware_trigger is True + assert be._timeout == pytest.approx(gb.GenTLCameraBackend._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT) + + ns = settings.properties["gentl"] + assert ns["trigger_actual"]["role"] == "external" + assert ns["trigger_actual"]["source"] == "Line0" + + be.close() + + +def test_trigger_follower_configures_input_line(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "follower", + "selector": "FrameStart", + "source": "Line1", + "activation": "FallingEdge", + }, + ) + be = gb.GenTLCameraBackend(settings) + + be.open() + nm = be._acquirer.remote_device.node_map + + assert nm.TriggerSelector.value == "FrameStart" + assert nm.TriggerSource.value == "Line1" + assert nm.TriggerActivation.value == "FallingEdge" + assert nm.TriggerMode.value == "On" + + ns = settings.properties["gentl"] + assert ns["trigger_actual"]["role"] == "follower" + + be.close() + + +def test_trigger_master_configures_output_line_and_keeps_trigger_off(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "master", + "output_line": "Line2", + "output_source": "ExposureActive", + }, + ) + be = gb.GenTLCameraBackend(settings) + + be.open() + nm = be._acquirer.remote_device.node_map + + assert nm.TriggerMode.value == "Off" + assert nm.LineSelector.value == "Line2" + assert nm.LineMode.value == "Output" + assert nm.LineSource.value == "ExposureActive" + + ns = settings.properties["gentl"] + assert ns["trigger_actual"]["role"] == "master" + assert ns["trigger_actual"]["output_line"] == "Line2" + + be.close() + + +def test_trigger_invalid_source_non_strict_disables_trigger(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "external", + "source": "LineDoesNotExist", + "strict": False, + }, + ) + be = gb.GenTLCameraBackend(settings) + + be.open() + nm = be._acquirer.remote_device.node_map + + # Source was unsupported, so the fake node should retain its default. + assert nm.TriggerSource.value == "Line1" + + # Safety behavior: do not arm TriggerMode on the previous/default source. + assert nm.TriggerMode.value == "Off" + + # Controller should not treat timeouts as expected trigger waits. + assert be.waits_for_hardware_trigger is False + + # trigger_actual is persisted after _configure_trigger(); since we reset + # self._trigger to off, the effective trigger state is off. + actual = settings.properties["gentl"]["trigger_actual"] + assert actual["role"] == "off" + + be.close() + + +def test_trigger_invalid_source_strict_raises_and_cleans_up(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "external", + "source": "LineDoesNotExist", + "strict": True, + }, + ) + be = gb.GenTLCameraBackend(settings) + + with pytest.raises(RuntimeError): + be.open() + + assert be._harvester is None + assert be._shared_entry is None + assert be._acquirer is None + + +def test_trigger_invalid_master_output_source_non_strict_does_not_crash(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "master", + "output_line": "Line2", + "output_source": "NotARealLineSource", + "strict": False, + }, + ) + be = gb.GenTLCameraBackend(settings) + + be.open() + nm = be._acquirer.remote_device.node_map + + assert nm.TriggerMode.value == "Off" + assert nm.LineSelector.value == "Line2" + assert nm.LineMode.value == "Output" + # Unsupported source should not be applied in non-strict mode. + assert nm.LineSource.value == "Off" + + be.close() + + +def test_trigger_invalid_master_output_source_strict_raises_and_cleans_up(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "master", + "output_line": "Line2", + "output_source": "NotARealLineSource", + "strict": True, + }, + ) + be = gb.GenTLCameraBackend(settings) + + with pytest.raises(RuntimeError): + be.open() + + assert be._harvester is None + assert be._shared_entry is None + assert be._acquirer is None + + +def test_trigger_alias_on_maps_to_external(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "on", + "source": "Line1", + }, + ) + be = gb.GenTLCameraBackend(settings) + + be.open() + nm = be._acquirer.remote_device.node_map + + assert nm.TriggerMode.value == "On" + assert nm.TriggerSource.value == "Line1" + assert settings.properties["gentl"]["trigger_actual"]["role"] == "external" + + be.close() + + +def test_trigger_timeout_is_capped_for_hardware_trigger_fetch_polling( + patch_gentl_sdk, + gentl_settings_factory, +): + gb = patch_gentl_sdk + expected_fetch_timeout = gb.GenTLCameraBackend._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "external", + "timeout": 7.5, + }, + ) + be = gb.GenTLCameraBackend(settings) + + try: + be.open() + + # Hardware-trigger fetch calls are intentionally capped so stop(wait=True) + # is not blocked by a long user trigger timeout. + assert be._timeout == pytest.approx(expected_fetch_timeout) + + # Fake acquisition is started, so read should pass and record the capped timeout. + frame, _ = be.read() + assert frame is not None + assert be._acquirer.fetch_calls[-1] == pytest.approx(expected_fetch_timeout) + + # The requested trigger timeout is still preserved in persisted trigger_actual. + actual = settings.properties["gentl"]["trigger_actual"] + assert actual["timeout"] == pytest.approx(7.5) + + finally: + be.close() + + +def test_trigger_timeout_error_mentions_hardware_trigger_when_waiting( + patch_gentl_sdk, + gentl_settings_factory, +): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "external", + "timeout": 3.0, + }, + ) + # fast_start keeps acquisition stopped; fake fetch then raises timeout. + # This lets us assert the backend timeout message without hardware. + settings.properties["gentl"]["fast_start"] = True + + be = gb.GenTLCameraBackend(settings) + + try: + be.open() + + assert be._timeout == pytest.approx(gb.GenTLCameraBackend._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT) + + with pytest.raises(TimeoutError) as ei: + be.read() + + msg = str(ei.value).lower() + assert "gentl timeout" in msg + assert "hardware trigger" in msg or "trigger" in msg + + finally: + be.close() + + +def test_trigger_actual_is_persisted_for_debugging(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "follower", + "source": "Line1", + "activation": "FallingEdge", + "timeout": 9.0, + "strict": False, + }, + ) + be = gb.GenTLCameraBackend(settings) + + try: + be.open() + + # Requested timeout remains in trigger_actual for debugging/config visibility. + actual = settings.properties["gentl"].get("trigger_actual") + assert isinstance(actual, dict) + assert actual["role"] == "follower" + assert actual["source"] == "Line1" + assert actual["activation"] == "FallingEdge" + assert actual["timeout"] == pytest.approx(9.0) + + # But each blocking Harvester.fetch() call is capped for responsive shutdown. + assert be._timeout == pytest.approx(gb.GenTLCameraBackend._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT) + + finally: + be.close() + + +def test_trigger_invalid_selector_non_strict_disables_trigger(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "external", + "selector": "NotARealSelector", + "source": "Line1", + "strict": False, + }, + ) + be = gb.GenTLCameraBackend(settings) + + be.open() + nm = be._acquirer.remote_device.node_map + + # Selector was unsupported, so the fake node should retain its default. + assert nm.TriggerSelector.value == "FrameStart" + + # Source may have been applied, but trigger must not be armed because + # the required selector routing failed. + assert nm.TriggerSource.value == "Line1" + assert nm.TriggerMode.value == "Off" + assert be.waits_for_hardware_trigger is False + + actual = settings.properties["gentl"]["trigger_actual"] + assert actual["role"] == "off" + + be.close() + + +def test_trigger_timeout_not_capped_for_master_mode(patch_gentl_sdk, gentl_settings_factory): + gb = patch_gentl_sdk + + settings = _gentl_trigger_settings( + gentl_settings_factory, + { + "role": "master", + "timeout": 7.5, + }, + ) + be = gb.GenTLCameraBackend(settings) + + try: + be.open() + + # Master is free-running / trigger-generating, not waiting for hardware input. + assert be.waits_for_hardware_trigger is False + assert be._timeout == pytest.approx(7.5) + + finally: + be.close() + + +def test_resolve_trigger_source_auto_selects_supported_line( + patch_gentl_sdk, + gentl_settings_factory, +): + gb = patch_gentl_sdk + be = gb.GenTLCameraBackend(gentl_settings_factory()) + + class Node: + symbolics = ["Line1", "Software", "Any"] + + class NodeMap: + TriggerSource = Node() + + source, ok = be._resolve_trigger_source(NodeMap(), "auto", strict=False) + + assert ok is True + assert source == "Line1" + + +def test_resolve_trigger_source_strict_raises_for_unsupported_explicit_line( + patch_gentl_sdk, + gentl_settings_factory, +): + gb = patch_gentl_sdk + be = gb.GenTLCameraBackend(gentl_settings_factory()) + + class Node: + symbolics = ["Line1", "Software", "Any"] + + class NodeMap: + TriggerSource = Node() + + with pytest.raises(RuntimeError, match="TriggerSource.*Line0"): + be._resolve_trigger_source(NodeMap(), "Line0", strict=True) diff --git a/tests/gui/test_app_entrypoint.py b/tests/gui/test_app_entrypoint.py index 0a68bb2e..b6b1c605 100644 --- a/tests/gui/test_app_entrypoint.py +++ b/tests/gui/test_app_entrypoint.py @@ -31,6 +31,7 @@ def set_use_splash_false(monkeypatch): @pytest.mark.gui def test_main_with_splash(monkeypatch, set_use_splash_true): appmod = _import_fresh() + monkeypatch.setattr(appmod, "_maybe_allow_keyboard_interrupt", MagicMock(name="_maybe_allow_keyboard_interrupt")) # --- Patch Qt app & icon in the entry module's namespace --- QApplication_cls = MagicMock(name="QApplication") @@ -101,6 +102,7 @@ def immediate_single_shot(ms, fn): @pytest.mark.gui def test_main_without_splash(monkeypatch, set_use_splash_false): appmod = _import_fresh() + monkeypatch.setattr(appmod, "_maybe_allow_keyboard_interrupt", MagicMock(name="_maybe_allow_keyboard_interrupt")) # Patch Qt app creation & window icon QApplication_cls = MagicMock(name="QApplication") diff --git a/tests/gui/test_pose_overlay.py b/tests/gui/test_pose_overlay.py index 369baf84..3af35308 100644 --- a/tests/gui/test_pose_overlay.py +++ b/tests/gui/test_pose_overlay.py @@ -65,7 +65,7 @@ def test_record_overlay_toggle_affects_frames_sent_to_recorder(window, recording # Provide a frame raw = np.zeros((100, 100, 3), dtype=np.uint8) - # Build minimal frame_data to call _on_multi_frame_ready + # Build minimal frame_data to call _on_multi_frame_processing_ready from dlclivegui.services.multi_camera_controller import MultiFrameData frame_data = MultiFrameData( @@ -76,7 +76,7 @@ def test_record_overlay_toggle_affects_frames_sent_to_recorder(window, recording # 1) toggle OFF: should record raw window.record_with_overlays_checkbox.setChecked(False) - window._on_multi_frame_ready(frame_data) + window._on_multi_frame_processing_ready(frame_data) assert cam_id in recording_frame_spy recorded_off = recording_frame_spy[cam_id] @@ -84,7 +84,7 @@ def test_record_overlay_toggle_affects_frames_sent_to_recorder(window, recording # 2) toggle ON: should record overlay frame (different) window.record_with_overlays_checkbox.setChecked(True) - window._on_multi_frame_ready(frame_data) + window._on_multi_frame_processing_ready(frame_data) recorded_on = recording_frame_spy[cam_id] assert not np.array_equal(recorded_on, raw) diff --git a/tests/gui/test_rec_manager.py b/tests/gui/test_rec_manager.py index 6a75d456..c789078b 100644 --- a/tests/gui/test_rec_manager.py +++ b/tests/gui/test_rec_manager.py @@ -3,8 +3,9 @@ import numpy as np import pytest +from dlclivegui.config import CameraSettings from dlclivegui.gui.recording_manager import RecordingManager -from dlclivegui.services.multi_camera_controller import get_camera_id +from dlclivegui.services.multi_camera_controller import get_camera_id, get_display_id from dlclivegui.services.video_recorder import RecorderStats @@ -277,3 +278,103 @@ def test_get_stats_summary_multi_aggregates( assert "30 frames" in summary # 10 + 20 assert "dropped 4" in summary # 1 + 3 assert "queue 6" in summary # 2 + 4 + + +@pytest.mark.unit +def test_recording_manager_uses_stable_camera_id_not_display_id( + recording_settings, + patch_video_recorder, + patch_build_run_dir, +): + mgr = RecordingManager() + + cam = CameraSettings( + name="GenTL cam", + backend="gentl", + index=0, + fps=30.0, + enabled=True, + properties={ + "gentl": { + "device_id": "serial:SER0", + "serial_number": "SER0", + } + }, + ).apply_defaults() + + stable_id = get_camera_id(cam) + display_id = get_display_id(cam) + + assert stable_id == "gentl:serial:SER0" + assert display_id == "gentl:0" + assert stable_id != display_id + + frame = np.zeros((480, 640, 3), dtype=np.uint8) + current_frames = {stable_id: frame} + + run_dir = mgr.start_all( + recording_settings, + [cam], + current_frames, + session_name="Sess", + ) + + assert run_dir is not None + assert stable_id in mgr.recorders + assert display_id not in mgr.recorders + + rec = mgr.recorders[stable_id] + assert rec.frame_size == (480, 640) + + mgr.write_frame(stable_id, frame, timestamp=123.0) + assert len(rec.write_calls) == 1 + assert rec.write_calls[-1][1] == 123.0 + + # Display ID is GUI-only and must not route frames internally. + mgr.write_frame(display_id, frame, timestamp=456.0) + assert len(rec.write_calls) == 1 + + +@pytest.mark.unit +def test_start_all_does_not_infer_frame_size_from_display_id( + recording_settings, + patch_video_recorder, + patch_build_run_dir, +): + mgr = RecordingManager() + + cam = CameraSettings( + name="GenTL cam", + backend="gentl", + index=0, + fps=30.0, + enabled=True, + properties={ + "gentl": { + "device_id": "serial:SER0", + "serial_number": "SER0", + } + }, + ).apply_defaults() + + stable_id = get_camera_id(cam) + display_id = get_display_id(cam) + + frame = np.zeros((480, 640, 3), dtype=np.uint8) + + # Simulate the buggy situation: frames are keyed by display ID. + current_frames = {display_id: frame} + + mgr.start_all( + recording_settings, + [cam], + current_frames, + session_name="Sess", + ) + + assert stable_id in mgr.recorders + assert display_id not in mgr.recorders + + # Since RecordingManager uses stable IDs internally, it should not find this frame. + rec = mgr.recorders[stable_id] + assert rec.frame_size is None diff --git a/tests/services/test_multicam_controller.py b/tests/services/test_multicam_controller.py index eca50218..e5bf6093 100644 --- a/tests/services/test_multicam_controller.py +++ b/tests/services/test_multicam_controller.py @@ -1,22 +1,30 @@ -# tests/services/test_multicam_controller.py import pytest from dlclivegui.cameras.factory import CameraFactory - -# from dlclivegui.config import CameraSettings from dlclivegui.config import CameraSettings -from dlclivegui.services.multi_camera_controller import MultiCameraController, get_camera_id +from dlclivegui.services.multi_camera_controller import ( + MultiCameraController, + _camera_start_priority, + _trigger_role_from_settings, + get_camera_id, + get_display_id, +) @pytest.mark.unit def test_start_and_frames(qtbot, patch_factory): mc = MultiCameraController() - # One dataclass + one dict (simulate mixed inputs) cam1 = CameraSettings(name="C1", backend="opencv", index=0, fps=25.0).apply_defaults() cam2 = {"name": "C2", "backend": "opencv", "index": 1, "fps": 30.0, "enabled": True} cam2 = CameraSettings.from_dict(cam2).apply_defaults() + cam1_id = get_camera_id(cam1) + cam2_id = get_camera_id(cam2) + + cam1_display = get_display_id(cam1) + cam2_display = get_display_id(cam2) + frames_seen = [] def on_ready(mfd): @@ -28,11 +36,24 @@ def on_ready(mfd): with qtbot.waitSignal(mc.all_started, timeout=1500): mc.start([cam1, cam2]) - # Wait for at least one composite emission qtbot.waitUntil(lambda: len(frames_seen) >= 1, timeout=2000) assert mc.is_running() - # We should have at least one entry with 1 or 2 frames (depending on timing) + + # Internal stable IDs should be used as frame keys and source IDs. + seen_keys = set() + seen_sources = set() + for source_id, shape_map in frames_seen: + seen_sources.add(source_id) + seen_keys.update(shape_map.keys()) + + assert seen_keys <= {cam1_id, cam2_id} + assert seen_sources <= {cam1_id, cam2_id} + + # Human/display IDs should not be used as internal frame keys. + assert cam1_display not in seen_keys + assert cam2_display not in seen_keys + assert any(len(shape_map) >= 1 for _, shape_map in frames_seen) finally: @@ -70,10 +91,8 @@ def on_ready(mfd): with qtbot.waitSignal(mc.all_started, timeout=1500): mc.start([cam]) - # Wait until a rotated+cropped frame arrives qtbot.waitUntil(lambda: last_shape["shape"] is not None, timeout=2000) - # Expect height=32, width=32, 3 channels assert last_shape["shape"] == (32, 32, 3) finally: @@ -83,7 +102,6 @@ def on_ready(mfd): @pytest.mark.unit def test_initialization_failure(qtbot, monkeypatch): - # Make factory.create raise def _create(_settings): raise RuntimeError("no device") @@ -92,6 +110,375 @@ def _create(_settings): mc = MultiCameraController() cam = CameraSettings(name="C", backend="opencv", index=0, enabled=True).apply_defaults() - # Expect initialization_failed with the camera id - with qtbot.waitSignals([mc.initialization_failed, mc.all_stopped], timeout=2000) as _: + with qtbot.waitSignals([mc.initialization_failed, mc.all_stopped], timeout=2000): mc.start([cam]) + + +@pytest.mark.unit +def test_get_camera_id_prefers_stable_device_id(): + cam = CameraSettings( + name="GenTL Cam", + backend="gentl", + index=0, + properties={ + "gentl": { + "device_id": "serial:30220469", + "serial_number": "30220469", + } + }, + ).apply_defaults() + + assert get_camera_id(cam) == "gentl:serial:30220469" + + +@pytest.mark.unit +def test_get_camera_id_falls_back_to_index_without_stable_identity(): + cam = CameraSettings( + name="Cam", + backend="opencv", + index=2, + ).apply_defaults() + + assert get_camera_id(cam) == "opencv:index:2" + + +@pytest.mark.unit +def test_get_display_id_is_human_index_label(): + cam = CameraSettings( + name="GenTL Cam", + backend="gentl", + index=3, + properties={ + "gentl": { + "device_id": "serial:30220469", + "serial_number": "30220469", + } + }, + ).apply_defaults() + + assert get_camera_id(cam) == "gentl:serial:30220469" + assert get_display_id(cam) == "gentl:3" + assert get_camera_id(cam) != get_display_id(cam) + + +@pytest.mark.unit +@pytest.mark.parametrize( + ("role", "expected"), + [ + ("off", "off"), + ("disabled", "off"), + ("on", "external"), + ("triggered", "external"), + ("external", "external"), + ("follower", "follower"), + ("slave", "follower"), + ("master", "master"), + ("main", "master"), + ], +) +def test_trigger_role_from_settings_aliases(role, expected): + cam = CameraSettings( + name="C", + backend="gentl", + index=0, + properties={ + "gentl": { + "trigger": { + "role": role, + } + } + }, + ).apply_defaults() + + assert _trigger_role_from_settings(cam) == expected + + +@pytest.mark.unit +def test_camera_start_priority_orders_trigger_roles(): + external = CameraSettings( + name="External", + backend="gentl", + index=0, + properties={"gentl": {"trigger": {"role": "external"}}}, + ).apply_defaults() + + normal = CameraSettings( + name="Normal", + backend="gentl", + index=1, + properties={"gentl": {"trigger": {"role": "off"}}}, + ).apply_defaults() + + master = CameraSettings( + name="Master", + backend="gentl", + index=2, + properties={"gentl": {"trigger": {"role": "master"}}}, + ).apply_defaults() + + assert _camera_start_priority(external) == 0 + assert _camera_start_priority(normal) == 1 + assert _camera_start_priority(master) == 2 + + +@pytest.mark.unit +def test_start_preserves_user_display_order_even_when_trigger_start_order_differs(qtbot, patch_factory): + mc = MultiCameraController() + + # User wants master first in display/tile order, follower second. + # Startup order should still be follower first internally. + master = CameraSettings( + name="Master", + backend="opencv", + index=0, + enabled=True, + properties={ + "opencv": { + "device_id": "master-cam", + "trigger": {"role": "master"}, + } + }, + ).apply_defaults() + + follower = CameraSettings( + name="Follower", + backend="opencv", + index=1, + enabled=True, + properties={ + "opencv": { + "device_id": "follower-cam", + "trigger": {"role": "follower"}, + } + }, + ).apply_defaults() + + expected_display_order = [get_camera_id(master), get_camera_id(follower)] + + try: + with qtbot.waitSignal(mc.all_started, timeout=1500): + mc.start([master, follower]) + + assert mc._camera_display_order == expected_display_order + + finally: + with qtbot.waitSignal(mc.all_stopped, timeout=2000): + mc.stop(wait=True) + + +@pytest.mark.unit +def test_frame_ready_emits_frames_in_user_configured_order(qtbot, patch_factory): + mc = MultiCameraController() + + cam_a = CameraSettings( + name="A", + backend="opencv", + index=0, + enabled=True, + properties={"opencv": {"device_id": "cam-a"}}, + ).apply_defaults() + + cam_b = CameraSettings( + name="B", + backend="opencv", + index=1, + enabled=True, + properties={"opencv": {"device_id": "cam-b"}}, + ).apply_defaults() + + expected_order = [get_camera_id(cam_a), get_camera_id(cam_b)] + seen_orders: list[list[str]] = [] + + def on_ready(mfd): + if len(mfd.frames) >= 2: + seen_orders.append(list(mfd.frames.keys())) + + mc.frame_ready.connect(on_ready) + + try: + with qtbot.waitSignal(mc.all_started, timeout=1500): + mc.start([cam_a, cam_b]) + + qtbot.waitUntil(lambda: bool(seen_orders), timeout=2500) + + assert seen_orders[-1] == expected_order + + finally: + with qtbot.waitSignal(mc.all_stopped, timeout=2000): + mc.stop(wait=True) + + +@pytest.mark.unit +def test_controller_uses_stable_camera_id_not_display_id(qtbot, patch_factory): + mc = MultiCameraController() + + cam = CameraSettings( + name="C1", + backend="gentl", + index=0, + fps=30.0, + enabled=True, + properties={ + "gentl": { + "device_id": "serial:SER0", + "serial_number": "SER0", + } + }, + ).apply_defaults() + + stable_id = get_camera_id(cam) + display_id = get_display_id(cam) + + assert stable_id == "gentl:serial:SER0" + assert display_id == "gentl:0" + assert stable_id != display_id + + seen = [] + + def on_ready(mfd): + seen.append(mfd) + + mc.frame_ready.connect(on_ready) + + try: + with qtbot.waitSignal(mc.all_started, timeout=1500): + mc.start([cam]) + + qtbot.waitUntil(lambda: bool(seen), timeout=2000) + + mfd = seen[-1] + + assert mfd.source_camera_id == stable_id + assert stable_id in mfd.frames + assert stable_id in mfd.timestamps + + assert display_id not in mfd.frames + assert display_id not in mfd.timestamps + + assert mfd.display_ids is not None + assert mfd.display_ids[stable_id] == display_id + + finally: + with qtbot.waitSignal(mc.all_stopped, timeout=2000): + mc.stop(wait=True) + + +@pytest.mark.unit +def test_display_order_is_cleared_on_stop(qtbot, patch_factory): + mc = MultiCameraController() + + cam = CameraSettings( + name="C", + backend="opencv", + index=0, + enabled=True, + properties={"opencv": {"device_id": "cam-0"}}, + ).apply_defaults() + + try: + with qtbot.waitSignal(mc.all_started, timeout=1500): + mc.start([cam]) + + assert mc._camera_display_order == [get_camera_id(cam)] + + finally: + with qtbot.waitSignal(mc.all_stopped, timeout=2000): + mc.stop(wait=True) + + assert mc._camera_display_order == [] + + +@pytest.mark.unit +def test_hardware_trigger_timeouts_are_not_fatal(qtbot, monkeypatch): + class WaitingTriggerBackend: + waits_for_hardware_trigger = True + + def __init__(self, settings): + self.settings = settings + self.opened = False + self.closed = False + + def open(self): + self.opened = True + + def read(self): + raise TimeoutError("waiting for hardware trigger") + + def close(self): + self.closed = True + + def _create(settings): + return WaitingTriggerBackend(settings) + + monkeypatch.setattr(CameraFactory, "create", staticmethod(_create)) + + mc = MultiCameraController() + cam = CameraSettings( + name="Triggered", + backend="gentl", + index=0, + enabled=True, + properties={ + "gentl": { + "device_id": "serial:30220469", + "trigger": {"role": "external", "timeout": 0.1}, + } + }, + ).apply_defaults() + + errors: list[tuple[str, str]] = [] + mc.camera_error.connect(lambda cam_id, msg: errors.append((cam_id, msg))) + + try: + with qtbot.waitSignal(mc.all_started, timeout=1500): + mc.start([cam]) + + # Let several timeout cycles happen. + qtbot.wait(500) + + assert mc.is_running() + assert errors == [] + + finally: + with qtbot.waitSignal(mc.all_stopped, timeout=2000): + mc.stop(wait=True) + + +@pytest.mark.unit +def test_non_trigger_timeouts_are_fatal_after_retries(qtbot, monkeypatch): + class TimeoutBackend: + waits_for_hardware_trigger = False + + def __init__(self, settings): + self.settings = settings + + def open(self): + pass + + def read(self): + raise TimeoutError("camera timeout") + + def close(self): + pass + + def _create(settings): + return TimeoutBackend(settings) + + monkeypatch.setattr(CameraFactory, "create", staticmethod(_create)) + + mc = MultiCameraController() + cam = CameraSettings(name="TimeoutCam", backend="opencv", index=0, enabled=True).apply_defaults() + + expected_id = get_camera_id(cam) + + with qtbot.waitSignal(mc.camera_error, timeout=3000) as blocker: + mc.start([cam]) + + cam_id, msg = blocker.args + assert cam_id == expected_id + assert "Camera read timeout" in msg + + # Cleanup if still running. + if mc.is_running(): + with qtbot.waitSignal(mc.all_stopped, timeout=2000): + mc.stop(wait=True) diff --git a/tests/test_config.py b/tests/test_config.py new file mode 100644 index 00000000..9f82017e --- /dev/null +++ b/tests/test_config.py @@ -0,0 +1,43 @@ +import pytest + +from dlclivegui.config import ApplicationSettings, CameraSettings, CameraTriggerSettings, MultiCameraSettings + + +@pytest.mark.unit +def test_save_applies_gentl_trigger_defaults_to_top_level_camera(): + cam = CameraSettings( + backend="gentl", + properties={"gentl": {}}, + ) + + settings = ApplicationSettings( + camera=cam, + multi_camera=MultiCameraSettings(cameras=[cam]), + ) + + data = settings.to_dict() + + assert "trigger" in data["camera"]["properties"]["gentl"] + + +@pytest.mark.unit +def test_save_applies_gentl_trigger_defaults_to_multi_camera(): + cam = CameraSettings( + backend="gentl", + properties={"gentl": {}}, + ) + + settings = ApplicationSettings( + multi_camera=MultiCameraSettings(cameras=[cam]), + ) + + data = settings.to_dict() + + assert "trigger" in data["multi_camera"]["cameras"][0]["properties"]["gentl"] + + +@pytest.mark.unit +def test_trigger_source_defaults_to_auto(): + trigger = CameraTriggerSettings() + + assert trigger.source == "auto" diff --git a/tests/utils/test_display.py b/tests/utils/test_display.py index 9ce8d49e..559aa152 100644 --- a/tests/utils/test_display.py +++ b/tests/utils/test_display.py @@ -41,7 +41,9 @@ def test_compute_tiling_geometry_single_frame_respects_max_canvas_and_min_tile() def test_compute_tiling_geometry_two_frames_is_1x2(): frames = {"camB": _frame(480, 640, 3), "camA": _frame(480, 640, 3)} cam_ids, rows, cols, tile_w, tile_h = compute_tiling_geometry(frames, max_canvas=(1200, 800)) - assert cam_ids == ["camA", "camB"] # sorted + + # Preserve insertion/display order, do not sort by camera ID. + assert cam_ids == ["camB", "camA"] assert (rows, cols) == (1, 2) assert tile_w >= 160 and tile_h >= 120 @@ -49,25 +51,106 @@ def test_compute_tiling_geometry_two_frames_is_1x2(): def test_compute_tiling_geometry_three_frames_is_2x2(): frames = {"c3": _frame(480, 640, 3), "c1": _frame(480, 640, 3), "c2": _frame(480, 640, 3)} cam_ids, rows, cols, tile_w, tile_h = compute_tiling_geometry(frames, max_canvas=(1200, 800)) - assert cam_ids == ["c1", "c2", "c3"] + + # Preserve insertion/display order. + assert cam_ids == ["c3", "c1", "c2"] assert (rows, cols) == (2, 2) assert tile_w >= 160 and tile_h >= 120 -def test_compute_tiling_geometry_reference_aspect_is_first_sorted_cam(): - # camA has aspect 2.0 (w/h), camB has aspect 0.5 +def test_compute_tiling_geometry_reference_aspect_is_first_display_order_cam(): + # camB is first in insertion/display order and has aspect 0.5. + # camA has aspect 2.0. frames = { - "camB": _frame(400, 200, 3), - "camA": _frame(200, 400, 3), + "camB": _frame(400, 200, 3), # aspect = 200 / 400 = 0.5 + "camA": _frame(200, 400, 3), # aspect = 400 / 200 = 2.0 } + cam_ids, rows, cols, tile_w, tile_h = compute_tiling_geometry(frames, max_canvas=(1200, 800)) - assert cam_ids == ["camA", "camB"] + + assert cam_ids == ["camB", "camA"] # For 2 cams, rows=1 cols=2 => initial tile_w=600 tile_h=800 => tile_aspect=0.75 - # frame_aspect for camA = 400/200 = 2.0 > 0.75 => tile_h adjusted to tile_w/frame_aspect = 600/2 = 300 + # frame_aspect for camB = 0.5 <= 0.75 => tile_w adjusted to tile_h * frame_aspect = 800 * 0.5 = 400 + assert (rows, cols) == (1, 2) + assert tile_w == 400 + assert tile_h == 800 + + +def test_compute_tiling_geometry_preserves_frame_insertion_order(): + frames = { + "gentl:serial:30220469": np.zeros((10, 20, 3), dtype=np.uint8), + "gentl:serial:10620051": np.zeros((10, 20, 3), dtype=np.uint8), + } + + cam_ids, rows, cols, tile_w, tile_h = compute_tiling_geometry(frames) + + assert cam_ids == ["gentl:serial:30220469", "gentl:serial:10620051"] + assert rows == 1 + assert cols == 2 + assert tile_w > 0 + assert tile_h > 0 + + +def test_compute_tiling_geometry_preserves_reversed_insertion_order(): + frames = { + "gentl:serial:10620051": np.zeros((10, 20, 3), dtype=np.uint8), + "gentl:serial:30220469": np.zeros((10, 20, 3), dtype=np.uint8), + } + + cam_ids, *_ = compute_tiling_geometry(frames) + + assert cam_ids == ["gentl:serial:10620051", "gentl:serial:30220469"] + + +def test_compute_tile_info_uses_display_order_for_offsets(): + cam0 = "gentl:serial:30220469" + cam1 = "gentl:serial:10620051" + + frames = { + cam0: np.zeros((100, 200, 3), dtype=np.uint8), + cam1: np.zeros((100, 200, 3), dtype=np.uint8), + } + + cam_ids, rows, cols, tile_w, tile_h = compute_tiling_geometry(frames) + + offset0, scale0 = compute_tile_info(cam0, frames[cam0], frames) + offset1, scale1 = compute_tile_info(cam1, frames[cam1], frames) + + assert cam_ids == [cam0, cam1] + assert offset0 == (0, 0) + assert offset1 == (tile_w, 0) + assert scale0[0] > 0 + assert scale0[1] > 0 + assert scale1[0] > 0 + assert scale1[1] > 0 + + +def test_create_tiled_frame_preserves_display_order_by_tile_content(): + # First frame is blue-ish, second is red-ish. + first = np.zeros((100, 100, 3), dtype=np.uint8) + first[:, :] = (255, 0, 0) # BGR blue + + second = np.zeros((100, 100, 3), dtype=np.uint8) + second[:, :] = (0, 0, 255) # BGR red + + frames = { + "gentl:serial:30220469": first, + "gentl:serial:10620051": second, + } + + cam_ids, rows, cols, tile_w, tile_h = compute_tiling_geometry(frames, max_canvas=(400, 200)) + out = create_tiled_frame(frames, max_canvas=(400, 200)) + + assert cam_ids == ["gentl:serial:30220469", "gentl:serial:10620051"] assert (rows, cols) == (1, 2) - assert tile_w == 600 - assert tile_h == 300 + + # Sample away from text label area. + left_sample = out[tile_h // 2, tile_w // 2] + right_sample = out[tile_h // 2, tile_w + tile_w // 2] + + assert left_sample[0] > left_sample[2] # blue tile first + assert right_sample[2] > right_sample[0] # red tile second def test_create_tiled_frame_empty_returns_default_canvas(): @@ -110,16 +193,18 @@ def test_create_tiled_frame_canvas_shape_matches_geometry(): def test_compute_tile_info_offset_and_scale_matches_tiling(): - # 2 frames => 1x2 tiling, cam ids sorted: ["cam1", "cam2"] + # 2 frames => 1x2 tiling, preserving insertion/display order: ["cam2", "cam1"] frames = {"cam2": _frame(200, 400, 3), "cam1": _frame(200, 400, 3)} cam_ids, rows, cols, tile_w, tile_h = compute_tiling_geometry(frames, max_canvas=(1200, 800)) original = _frame(200, 400, 3) (ox, oy), (sx, sy) = compute_tile_info("cam2", original, frames, max_canvas=(1200, 800)) - # cam2 is index 1 -> row 0 col 1 + assert cam_ids == ["cam2", "cam1"] assert (rows, cols) == (1, 2) - assert ox == tile_w + + # cam2 is first in display order => row 0 col 0 + assert ox == 0 assert oy == 0 assert sx == pytest.approx(tile_w / 400) assert sy == pytest.approx(tile_h / 200)