Add mono-preserving output mode to GenTL

Adds a `preserve_mono` option to the GenTL camera backend so Mono pixel formats can remain 2D Mono8 output instead of always converting to BGR. The backend now reports preserve-mono capability, exposes recommended/actual output format based on camera format, and persists detected pixel/output format metadata in settings. It also logs first-frame format details to make runtime format behavior easier to inspect.

Author: C-Achard

dlclivegui/cameras/backends/gentl_backend.py

@@ -90,6 +90,8 @@ def __init__(self, settings):
             ns = {}
 
         self._fast_start: bool = bool(ns.get("fast_start", False))
+        self._preserve_mono: bool = bool(getattr(settings, "preserve_mono", False) or ns.get("preserve_mono", False))
+        self._logged_first_frame: bool = False
 
         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")
@@ -177,10 +179,20 @@ def actual_pixel_format(self) -> str | None:
         """Camera/native pixel format selected on the GenICam PixelFormat node."""
         return self._camera_pixel_format or (self._pixel_format if self._pixel_format != "auto" else None)
 
+    @property
+    def recommended_preserve_mono(self) -> bool | None:
+        if not self._camera_pixel_format:
+            return None
+        return self._is_camera_mono()
+
     @property
     def actual_output_format(self) -> str | None:
-        """Current GenTL backend emits OpenCV-native BGR uint8 frames."""
-        return self._actual_output_format or "BGR8"
+        """Backend output frame format emitted to the app, e.g. 'Mono8' or 'BGR8'."""
+        if self._actual_output_format:
+            return self._actual_output_format
+        if not self._camera_pixel_format:
+            return None
+        return "Mono8" if self._should_output_mono() else "BGR8"
 
     @classmethod
     def is_available(cls) -> bool:
@@ -196,6 +208,7 @@ def static_capabilities(cls) -> dict[str, SupportLevel]:
             "device_discovery": SupportLevel.SUPPORTED,
             "stable_identity": SupportLevel.SUPPORTED,
             "hardware_trigger": SupportLevel.BEST_EFFORT,
+            "preserve_mono": SupportLevel.SUPPORTED,
         }
 
     def _debug_trigger_nodes(self, node_map, *, context: str = "") -> None:
@@ -606,6 +619,13 @@ 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"}
 
+    def _is_camera_mono(self) -> bool:
+        fmt = str(self._camera_pixel_format or self._pixel_format or "").strip()
+        return fmt.startswith("Mono")
+
+    def _should_output_mono(self) -> bool:
+        return bool(self._preserve_mono and self._is_camera_mono())
+
     @staticmethod
     def _output_format_for_frame(frame: np.ndarray) -> str:
         if frame.ndim == 2:
@@ -660,6 +680,25 @@ def read(self) -> CapturedFrame:
             except Exception:
                 pass
         self._actual_output_format = self._output_format_for_frame(frame)
+        try:
+            ns = self._ensure_settings_ns()
+            ns["actual_output_format"] = self._actual_output_format
+            ns["preserve_mono"] = self._preserve_mono
+        except Exception:
+            pass
+        if not self._logged_first_frame:
+            self._logged_first_frame = True
+            LOG.info(
+                "[GenTL] first frame device_id=%s shape=%s dtype=%s nbytes=%.2f MB "
+                "camera_pixel_format=%s output_format=%s preserve_mono=%s",
+                self._device_id,
+                frame.shape,
+                frame.dtype,
+                frame.nbytes / (1024 * 1024),
+                self._camera_pixel_format,
+                self.actual_output_format,
+                self._preserve_mono,
+            )
 
         return CapturedFrame(
             frame=frame,
@@ -1374,6 +1413,14 @@ def _configure_pixel_format(self, node_map) -> None:
             pixel_format_node.value = selected
             self._pixel_format = str(pixel_format_node.value)
             self._camera_pixel_format = self._pixel_format
+            try:
+                ns = self._ensure_settings_ns()
+                ns["actual_pixel_format"] = self._camera_pixel_format
+                ns["detected_pixel_format"] = self._camera_pixel_format
+                ns["actual_output_format"] = self.actual_output_format
+                ns["preserve_mono"] = self._preserve_mono
+            except Exception:
+                pass
 
             LOG.debug("GenTL pixel format selected: %s", self._pixel_format)
 
@@ -1879,6 +1926,9 @@ def _convert_frame(self, frame: np.ndarray) -> np.ndarray:
                 frame = cv2.cvtColor(frame, cv2.COLOR_BayerGR2BGR)
             elif fmt == "BayerBG8":
                 frame = cv2.cvtColor(frame, cv2.COLOR_BayerBG2BGR)
+            elif self._should_output_mono():
+                # Keep Mono* cameras as 2D uint8 frames when explicitly requested.
+                pass
             else:
                 frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)