Add exposure/gain tracking and auto handling

Expose and track actual exposure and gain for Basler and GenTL backends, and treat non-positive values as "Auto" (do not set). Basler: add actual_exposure/actual_gain properties, read/write exposure/gain only when positive, probe actual FPS after opening. Introduce _settings_value(treat_nonpositive_as_none=True) to centralize zero-as-auto logic. GenTL: parse settings so 0 means auto, add actual_exposure/actual_gain fields and properties, and attempt to read those values from the device/node_map. Includes defensive error handling when reading or setting camera parameters.

Author: C-Achard

dlclivegui/cameras/backends/basler_backend.py

@@ -43,6 +43,8 @@ def __init__(self, settings):
         self._actual_width: int | None = None
         self._actual_height: int | None = None
         self._actual_fps: float | None = None
+        self._actual_exposure: float | None = None
+        self._actual_gain: float | None = None
 
     @property
     def actual_resolution(self) -> tuple[int, int] | None:
@@ -54,6 +56,14 @@ def actual_resolution(self) -> tuple[int, int] | None:
     def actual_fps(self) -> float | None:
         return self._actual_fps
 
+    @property
+    def actual_exposure(self) -> float | None:
+        return self._actual_exposure
+
+    @property
+    def actual_gain(self) -> float | None:
+        return self._actual_gain
+
     @classmethod
     def is_available(cls) -> bool:
         return pylon is not None
@@ -85,16 +95,20 @@ def open(self) -> None:
         self._camera = pylon.InstantCamera(pylon.TlFactory.GetInstance().CreateDevice(device))
         self._camera.Open()
 
-        # Exposure
-        exposure = self._settings_value("exposure", self.settings.properties)
+        # Exposure (0 = Auto -> do not set)
+        exposure = self._settings_value(
+            "exposure", self.settings.properties, fallback=self.settings.exposure, treat_nonpositive_as_none=True
+        )
         if exposure is not None:
             try:
                 self._camera.ExposureTime.SetValue(float(exposure))
             except Exception:
                 pass
 
-        # Gain
-        gain = self._settings_value("gain", self.settings.properties)
+        # Gain (0 = Auto -> do not set)
+        gain = self._settings_value(
+            "gain", self.settings.properties, fallback=self.settings.gain, treat_nonpositive_as_none=True
+        )
         if gain is not None:
             try:
                 self._camera.Gain.SetValue(float(gain))
@@ -104,15 +118,22 @@ def open(self) -> None:
         # Resolution (device default if None)
         self._configure_resolution()
 
-        # Frame rate
-        fps = self._settings_value("fps", self.settings.properties, fallback=self.settings.fps)
+        # Frame rate (0.0 = Auto -> do not set)
+        fps = self._settings_value(
+            "fps", self.settings.properties, fallback=self.settings.fps, treat_nonpositive_as_none=True
+        )
         if fps is not None:
             try:
                 self._camera.AcquisitionFrameRateEnable.SetValue(True)
                 self._camera.AcquisitionFrameRate.SetValue(float(fps))
-                self._actual_fps = float(self._camera.AcquisitionFrameRate.GetValue())
             except Exception:
-                self._actual_fps = None
+                pass
+
+        # Always try to read actual FPS for probing / GUI
+        try:
+            self._actual_fps = float(self._camera.AcquisitionFrameRate.GetValue())
+        except Exception:
+            self._actual_fps = None
 
         # Capture actual resolution even when using defaults
         try:
@@ -121,6 +142,16 @@ def open(self) -> None:
         except Exception:
             pass
 
+        try:
+            self._actual_exposure = float(self._camera.ExposureTime.GetValue())
+        except Exception:
+            self._actual_exposure = None
+
+        try:
+            self._actual_gain = float(self._camera.Gain.GetValue())
+        except Exception:
+            self._actual_gain = None
+
         self._camera.StartGrabbing(pylon.GrabStrategy_LatestImageOnly)
 
         self._converter = pylon.ImageFormatConverter()
@@ -250,6 +281,28 @@ def _configure_resolution(self) -> None:
             LOG.warning(f"Failed to set resolution to {req_w}x{req_h}: {exc}")
 
     @staticmethod
-    def _settings_value(key: str, source: dict, fallback: float | None = None):
+    def _settings_value(
+        key: str, source: dict, fallback: float | None = None, *, treat_nonpositive_as_none: bool = True
+    ):
+        """
+        Fetch setting from a dict with an optional fallback.
+
+        If treat_nonpositive_as_none is True:
+        - numeric values <= 0 are treated as "Auto" and returned as None
+        """
         value = source.get(key, fallback)
-        return None if value is None else value
+
+        if value is None:
+            return None
+
+        # Treat 0 / <=0 as Auto by default
+        if treat_nonpositive_as_none and isinstance(value, (int, float)):
+            try:
+                fv = float(value)
+                if fv <= 0.0:
+                    return None
+                return fv
+            except Exception:
+                return None
+
+        return value

dlclivegui/cameras/backends/gentl_backend.py

@@ -57,10 +57,29 @@ def __init__(self, settings):
         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 = (
-            settings.exposure if settings.exposure else ns.get("exposure", props.get("exposure"))
+            float(exp_val) if isinstance(exp_val, (int, float)) and float(exp_val) > 0 else None
         )
-        self._gain: float | None = settings.gain if settings.gain else ns.get("gain", props.get("gain"))
+        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._gain: float | None = (
+            float(gain_val) if isinstance(gain_val, (int, float)) and float(gain_val) > 0 else None
+        )
+        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._timeout: float = float(ns.get("timeout", props.get("timeout", 2.0)))
         self._cti_search_paths: tuple[str, ...] = self._parse_cti_paths(
@@ -74,6 +93,8 @@ def __init__(self, settings):
         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
 
         self._harvester = None
         self._acquirer = None
@@ -89,6 +110,14 @@ def actual_resolution(self) -> tuple[int, int] | None:
     def actual_fps(self) -> float | None:
         return self._actual_fps
 
+    @property
+    def actual_exposure(self) -> float | None:
+        return self._actual_exposure
+
+    @property
+    def actual_gain(self) -> float | None:
+        return self._actual_gain
+
     @classmethod
     def is_available(cls) -> bool:
         return Harvester is not None
@@ -213,6 +242,16 @@ def open(self) -> None:
         except Exception:
             self._actual_fps = None
 
+        try:
+            self._actual_exposure = float(node_map.ExposureTime.value)
+        except Exception:
+            self._actual_exposure = None
+
+        try:
+            self._actual_gain = float(node_map.Gain.value)
+        except Exception:
+            self._actual_gain = None
+
         self._acquirer.start()
 
     def read(self) -> tuple[np.ndarray, float]:
@@ -245,6 +284,18 @@ def read(self) -> tuple[np.ndarray, float]:
             self._actual_width = int(w)
             self._actual_height = int(h)
 
+        if self._actual_exposure is None:
+            try:
+                self._actual_exposure = float(self._acquirer.node_map.ExposureTime.value)
+            except Exception:
+                self._actual_exposure = None
+
+        if self._actual_gain is None:
+            try:
+                self._actual_gain = float(self._acquirer.node_map.Gain.value)
+            except Exception:
+                self._actual_gain = None
+
         return frame, timestamp
 
     def stop(self) -> None: