Treat 0 as Auto for camera settings

Make 0/None semantics explicit for camera settings and improve OpenCV probing/GUI behavior.

- Config: default fps/width/height/exposure/gain now use 0 to mean Auto; add coercion validators and avoid overwriting explicit zeros in apply_defaults.
- OpenCV backend: treat Auto resolution as (0,0), attempt FPS set even in fast-start (best-effort), readback FPS/resolution more robustly, add actual_exposure/actual_gain properties (unsupported -> None), and clarify capability support comments.
- Factory/tests: stop assuming 30 FPS for probe-created CameraSettings; update tests to expect Auto resolution (0,0).
- GUI: show elided device name, expose Auto FPS in UI, reorganize form rows/buttons, add probe/reset flow (quick probe that can apply detected values back to requested settings), adjust preview FPS reconciliation and status logging.

These changes enable explicit "Auto" requests, safer probing of device-reported values, and a user-facing Reset action to adopt device defaults.

Author: C-Achard

dlclivegui/cameras/backends/opencv_backend.py

@@ -129,12 +129,12 @@ def static_capabilities(cls) -> dict[str, SupportLevel]:
         caps = super().static_capabilities()
         caps.update(
             {
-                "set_resolution": SupportLevel.SUPPORTED,
-                "set_fps": SupportLevel.BEST_EFFORT,
+                "set_resolution": SupportLevel.BEST_EFFORT,  # see tolerance values in OpenCVOptions
+                "set_fps": SupportLevel.BEST_EFFORT,  # ditto
                 "set_exposure": SupportLevel.UNSUPPORTED,
                 "set_gain": SupportLevel.UNSUPPORTED,
-                "device_discovery": SupportLevel.SUPPORTED,
-                "stable_identity": SupportLevel.SUPPORTED,
+                "device_discovery": SupportLevel.SUPPORTED,  # uses opencv2-enumerate-cameras
+                "stable_identity": SupportLevel.SUPPORTED,  # to get VID/PID/path
             }
         )
         return caps
@@ -245,6 +245,16 @@ def actual_resolution(self) -> tuple[int, int] | None:
             return (self._actual_width, self._actual_height)
         return None
 
+    @property
+    def actual_exposure(self) -> None:
+        """Not supported by OpenCV backend."""
+        return None
+
+    @property
+    def actual_gain(self) -> None:
+        """Not supported by OpenCV backend."""
+        return None
+
     # ----------------------------
     # Internal helpers
     # ----------------------------
@@ -280,8 +290,8 @@ def _get_requested_resolution(self) -> tuple[int, int]:
         except Exception:
             pass
 
-        # 3) default
-        return (720, 540)
+        # 3) default -> auto (0,0)
+        return (0, 0)
 
     def _apply_resolution_policy(
         self,
@@ -367,76 +377,115 @@ def _configure_capture(self) -> None:
         self._codec_str = self._read_codec_string()
         logger.info(f"Camera using codec: {self._codec_str}")
 
-        # --- Resolution (explicit request) ---
+        # Requested values
         req_w, req_h = self._requested_resolution
         enforce_aspect = opt.enforce_aspect
+        requested_fps = float(self.settings.fps or 0.0)
+
+        # -------------------------
+        # Resolution
+        # -------------------------
+        # If Auto (0,0), do NOT set resolution. Just read device defaults.
+        if req_w <= 0 or req_h <= 0:
+            # Some backends only populate width/height after a few grabs.
+            try:
+                # for _ in range(3):
+                self._capture.grab()
+            except Exception:
+                pass
 
-        if not self._fast_start:
-            # verified, robust path
+            self._actual_width = int(self._capture.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
+            self._actual_height = int(self._capture.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
+            self._actual_fps = float(self._capture.get(cv2.CAP_PROP_FPS) or 0.0)
+
+            # For clarity in logs
+            logger.info("Resolution requested=Auto, actual=%sx%s", self._actual_width, self._actual_height)
+
+        elif not self._fast_start:
+            # Verified, robust path (tries candidates + verifies)
             result = apply_mode_with_verification(
                 self._capture,
                 ModeRequest(
                     width=req_w,
                     height=req_h,
-                    fps=float(self.settings.fps or 0.0),
+                    fps=requested_fps,
                     enforce_aspect=enforce_aspect,
                     aspect_tol=float(opt.aspect_tol),
                     area_tol=float(opt.area_tol),
                 ),
             )
             self._actual_width, self._actual_height, self._actual_fps = result.width, result.height, result.fps
+
         else:
             # fast-start: best-effort set (no heavy negotiation)
-            if req_w > 0 and req_h > 0:
-                try:
-                    self._capture.set(cv2.CAP_PROP_FRAME_WIDTH, float(req_w))
-                    self._capture.set(cv2.CAP_PROP_FRAME_HEIGHT, float(req_h))
-                except Exception as exc:
-                    logger.debug(f"Fast-start resolution set failed: {exc}")
+            try:
+                self._capture.set(cv2.CAP_PROP_FRAME_WIDTH, float(req_w))
+                self._capture.set(cv2.CAP_PROP_FRAME_HEIGHT, float(req_h))
+            except Exception as exc:
+                logger.debug(f"Fast-start resolution set failed: {exc}")
 
             self._actual_width = int(self._capture.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
             self._actual_height = int(self._capture.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
 
+        # Compute actual_res tuple if known
         actual_res = None
         if (self._actual_width or 0) > 0 and (self._actual_height or 0) > 0:
             actual_res = (int(self._actual_width), int(self._actual_height))
 
         logger.info(
-            "Resolution requested=%sx%s, actual=%s",
-            req_w,
-            req_h,
+            "Resolution requested=%s, actual=%s",
+            f"{req_w}x{req_h}" if (req_w > 0 and req_h > 0) else "Auto",
             f"{actual_res[0]}x{actual_res[1]}" if actual_res else "unknown",
         )
 
-        # enforce mismatch policy (warn/strict/accept)
-        self._apply_resolution_policy(
-            requested=(req_w, req_h),
-            actual=actual_res,
-            policy=opt.resolution_policy,
-        )
+        # Enforce mismatch policy only if a real request was made
+        if req_w > 0 and req_h > 0:
+            self._apply_resolution_policy(
+                requested=(req_w, req_h),
+                actual=actual_res,
+                policy=opt.resolution_policy,
+            )
 
-        # optional persistence of "what worked"
+        # Optional persistence of "what worked"
         if opt.persist_last_applied_resolution and actual_res:
             ns = self.settings.properties.setdefault(self.OPTIONS_KEY, {})
             ns["last_applied_resolution"] = [actual_res[0], actual_res[1]]
 
-        # --- FPS (keep your current logic) ---
-        requested_fps = float(self.settings.fps or 0.0)
-        if not self._fast_start and requested_fps > 0.0:
-            current_fps = float(self._capture.get(cv2.CAP_PROP_FPS) or 0.0)
+        # -------------------------
+        # FPS (best-effort always)
+        # -------------------------
+        # IMPORTANT CHANGE:
+        # Try to set FPS even in fast_start (best-effort). Many drivers ignore it,
+        # and CAP_PROP_FPS often reads back 0, but at least we attempt consistently.
+        if requested_fps > 0.0:
+            try:
+                current_fps = float(self._capture.get(cv2.CAP_PROP_FPS) or 0.0)
+            except Exception:
+                current_fps = 0.0
+
+            # Only attempt if clearly different or unknown
             if current_fps <= 0.0 or abs(current_fps - requested_fps) > 0.1:
-                if not self._capture.set(cv2.CAP_PROP_FPS, requested_fps):
-                    logger.debug(f"Device ignored FPS set to {requested_fps:.2f}")
-            self._actual_fps = float(self._capture.get(cv2.CAP_PROP_FPS) or 0.0)
-        else:
+                try:
+                    ok = self._capture.set(cv2.CAP_PROP_FPS, float(requested_fps))
+                    if not ok:
+                        logger.debug(f"Device ignored FPS set to {requested_fps:.2f}")
+                except Exception as exc:
+                    logger.debug(f"FPS set raised: {exc}")
+
+        # Read back (may be 0.0 on many backends)
+        try:
             self._actual_fps = float(self._capture.get(cv2.CAP_PROP_FPS) or 0.0)
+        except Exception:
+            self._actual_fps = 0.0
 
         if self._actual_fps and requested_fps and abs(self._actual_fps - requested_fps) > 0.1:
             logger.warning(f"FPS mismatch: requested {requested_fps:.2f}, got {self._actual_fps:.2f}")
 
         logger.info(f"Camera configured with FPS: {self._actual_fps:.2f}")
 
-        # --- Extra properties (safe whitelist) ---
+        # -------------------------
+        # Extra properties (safe whitelist)
+        # -------------------------
         for prop, value in self.settings.properties.items():
             if prop in ("api", "resolution", "fast_start", "alt_index_probe"):
                 continue

dlclivegui/cameras/factory.py

@@ -271,7 +271,6 @@ def _canceled() -> bool:
                     settings = CameraSettings(
                         name=f"Probe {index}",
                         index=index,
-                        fps=30.0,
                         backend=backend,
                         properties={},
                     )

dlclivegui/config.py

@@ -15,32 +15,68 @@
 class CameraSettings(BaseModel):
     name: str = "Camera 0"
     index: int = 0
-    fps: float = 25.0
     backend: str = "opencv"
-    width: int = 720
-    height: int = 540
-    exposure: int = 500  # 0=auto else µs
-    gain: float = 10.0  # 0.0=auto else value
+
+    # 0.0 = Auto (device default / don't request)
+    fps: float = 0.0
+    # 0 = Auto (device default / don't request)
+    width: int = 0
+    height: int = 0
+
+    exposure: int = 0  # 0=auto else µs
+    gain: float = 0.0  # 0.0=auto else value
+
     crop_x0: int = 0
     crop_y0: int = 0
     crop_x1: int = 0
     crop_y1: int = 0
+
     max_devices: int = 3
     rotation: Rotation = 0
     enabled: bool = True
     properties: dict[str, Any] = Field(default_factory=dict)
 
-    @field_validator("fps")
+    @field_validator("fps", mode="before")
     @classmethod
-    def _fps_positive(cls, v):
-        return float(v) if v and v > 0 else 30.0
-
-    @field_validator("exposure")
+    def _coerce_fps(cls, v):
+        """
+        Accept:
+          - None -> 0.0 (Auto)
+          - 0 / 0.0 -> Auto
+          - >0 -> requested fps
+        """
+        if v is None:
+            return 0.0
+        try:
+            fv = float(v)
+        except Exception:
+            return 0.0
+        # clamp negatives to Auto
+        return fv if fv >= 0.0 else 0.0
+
+    @field_validator("width", "height", mode="before")
+    @classmethod
+    def _coerce_resolution(cls, v):
+        """
+        Accept:
+          - None -> 0 (Auto)
+          - 0 -> Auto
+          - >0 -> requested dimension
+        """
+        if v is None:
+            return 0
+        try:
+            iv = int(v)
+        except Exception:
+            return 0
+        return iv if iv >= 0 else 0
+
+    @field_validator("exposure", mode="before")
     @classmethod
     def _coerce_exposure(cls, v):  # allow None->0 and int
         return int(v) if v is not None else 0
 
-    @field_validator("gain")
+    @field_validator("gain", mode="before")
     @classmethod
     def _coerce_gain(cls, v):
         return float(v) if v is not None else 0.0
@@ -69,14 +105,29 @@ def from_defaults(cls) -> CameraSettings:
         return cls()
 
     def apply_defaults(self) -> CameraSettings:
+        """
+        IMPORTANT:
+        0 means "Auto" for fps/width/height/exposure/gain.
+        So do NOT treat <=0 as "missing" for those fields.
+        Only fill in defaults when the value is None.
+        """
         default = self.from_defaults()
+
+        # Fields where 0 is meaningful ("Auto"), so we must not replace 0 with defaults.
+        auto_zero_fields = {"fps", "width", "height", "exposure", "gain"}
+
         for field in CameraSettings.model_fields:
             value = getattr(self, field)
-            if value is None or (isinstance(value, (int, float)) and value <= 0):
-                # auto means use default value
-                # TODO @C-Achard
-                # Consider a more explicit way to represent "use default" vs "explicitly disable/zero out"
+
+            # Only replace None with defaults universally
+            if value is None:
                 setattr(self, field, getattr(default, field))
+                continue
+
+            # Careful: crop uses 0 legitimately too, though default is also 0
+            if field not in auto_zero_fields and isinstance(value, (int, float)) and value < 0:
+                setattr(self, field, getattr(default, field))
+
         return self