Split image settings dialog into image settings and lens calibration dialogs

- Extract lens calibration (distortion coefficients, wizard) into a
  separate LensCalibrationDialog
- Add alignment_date and calibration_date timestamps to Camera model
  for tracking when each was last performed
- Add status icons (checkmark/warning) to Lens Calibration and Image
  Alignment rows in camera properties, with tooltips explaining state
- Show warning on alignment row when calibration was updated after
  alignment (points preserved but marked stale)
- Backward compatible: existing configs with alignment points or
  non-zero distortion coefficients get timestamps on load

Author: knipknap

rayforge/camera/models/camera.py

@@ -54,6 +54,7 @@ def __init__(self, name: str, device_id: str):
 
         # Properties for camera alignment points
         self._image_to_world: Optional[Tuple[PointList, PointList]] = None
+        self._alignment_date: Optional[datetime] = None
 
         # Signals
         self.changed = Signal()
@@ -264,6 +265,7 @@ def distortion_k1(self) -> float:
     @distortion_k1.setter
     def distortion_k1(self, value: float):
         self._distortion_k1 = float(value)
+        self._calibration_date = datetime.now()
         self.changed.send(self)
         self.settings_changed.send(self)
 
@@ -274,6 +276,7 @@ def distortion_k2(self) -> float:
     @distortion_k2.setter
     def distortion_k2(self, value: float):
         self._distortion_k2 = float(value)
+        self._calibration_date = datetime.now()
         self.changed.send(self)
         self.settings_changed.send(self)
 
@@ -284,6 +287,7 @@ def distortion_p1(self) -> float:
     @distortion_p1.setter
     def distortion_p1(self, value: float):
         self._distortion_p1 = float(value)
+        self._calibration_date = datetime.now()
         self.changed.send(self)
         self.settings_changed.send(self)
 
@@ -294,6 +298,7 @@ def distortion_p2(self) -> float:
     @distortion_p2.setter
     def distortion_p2(self, value: float):
         self._distortion_p2 = float(value)
+        self._calibration_date = datetime.now()
         self.changed.send(self)
         self.settings_changed.send(self)
 
@@ -304,6 +309,7 @@ def distortion_k3(self) -> float:
     @distortion_k3.setter
     def distortion_k3(self, value: float):
         self._distortion_k3 = float(value)
+        self._calibration_date = datetime.now()
         self.changed.send(self)
         self.settings_changed.send(self)
 
@@ -432,6 +438,10 @@ def image_to_world(self, value: Optional[Tuple[PointList, PointList]]):
             f"{self._image_to_world} to {value}"
         )
         self._image_to_world = value
+        if value is not None:
+            self._alignment_date = datetime.now()
+        else:
+            self._alignment_date = None
         self.changed.send(self)
         self.settings_changed.send(self)
 
@@ -489,6 +499,32 @@ def calibration_image_size(self) -> Optional[Tuple[int, int]]:
     def calibration_frames_used(self) -> Optional[int]:
         return self._calibration_frames_used
 
+    @property
+    def alignment_date(self) -> Optional[datetime]:
+        return self._alignment_date
+
+    @alignment_date.setter
+    def alignment_date(self, value: Optional[datetime]):
+        if self._alignment_date == value:
+            return
+        self._alignment_date = value
+        self.changed.send(self)
+        self.settings_changed.send(self)
+
+    @property
+    def has_alignment(self) -> bool:
+        return self._image_to_world is not None
+
+    @property
+    def alignment_valid(self) -> bool:
+        if not self.has_alignment:
+            return False
+        if self._calibration_date is None:
+            return True
+        if self._alignment_date is None:
+            return False
+        return self._alignment_date >= self._calibration_date
+
     def to_dict(self) -> Dict[str, Any]:
         data = {
             "name": self.name,
@@ -521,6 +557,14 @@ def to_dict(self) -> Dict[str, Any]:
         else:
             data["image_to_world"] = None
 
+        if self._alignment_date is not None:
+            data["alignment_date"] = self._alignment_date.isoformat()
+
+        if self._calibration_date is not None:
+            data["calibration_date"] = (
+                self._calibration_date.isoformat()
+            )
+
         if self.has_calibration:
             data["camera_matrix_fx"] = self._camera_matrix_fx
             data["camera_matrix_fy"] = self._camera_matrix_fy
@@ -569,6 +613,7 @@ def from_dict(cls, data: Dict[str, Any]) -> "Camera":
             "calibration_date",
             "calibration_image_size",
             "calibration_frames_used",
+            "alignment_date",
         }
         extra = {k: v for k, v in data.items() if k not in known_keys}
 
@@ -608,6 +653,13 @@ def from_dict(cls, data: Dict[str, Any]) -> "Camera":
         else:
             camera.image_to_world = None
 
+        if data.get("alignment_date"):
+            camera._alignment_date = datetime.fromisoformat(
+                data["alignment_date"]
+            )
+        elif camera._image_to_world is not None:
+            camera._alignment_date = datetime.now()
+
         camera._camera_matrix_fx = data.get("camera_matrix_fx")
         camera._camera_matrix_fy = data.get("camera_matrix_fy")
         camera._camera_matrix_cx = data.get("camera_matrix_cx")
@@ -617,6 +669,14 @@ def from_dict(cls, data: Dict[str, Any]) -> "Camera":
             camera._calibration_date = datetime.fromisoformat(
                 data["calibration_date"]
             )
+        elif any(v != 0.0 for v in [
+            camera._distortion_k1,
+            camera._distortion_k2,
+            camera._distortion_k3,
+            camera._distortion_p1,
+            camera._distortion_p2,
+        ]):
+            camera._calibration_date = datetime.now()
         if data.get("calibration_image_size"):
             camera._calibration_image_size = tuple(
                 data["calibration_image_size"]

rayforge/ui_gtk/camera/alignment_dialog.py

@@ -1,5 +1,6 @@
 import logging
 import math
+from datetime import datetime
 from gettext import gettext as _
 from typing import List, Optional, Tuple
 
@@ -641,6 +642,7 @@ def on_apply_clicked(self, _):
             raise ValueError("Less than 4 points for alignment.")
 
         self.camera.image_to_world = (image_points, world_points)
+        self.camera.alignment_date = datetime.now()
         logger.info("Camera alignment applied.")
         self.close()
 

rayforge/ui_gtk/camera/image_settings_dialog.py

@@ -248,63 +248,11 @@ def _setup_ui(self):
         )
         image_group.add(row)
 
-        calibration_group = Adw.PreferencesGroup(
-            title=_("Lens Calibration"),
-            description=_(
-                "Correct lens distortion for straighter lines. "
-                "Use the wizard for automatic calibration or adjust manually."
-            ),
-            margin_top=12,
-        )
-
-        self.wizard_button = Gtk.Button(
-            label=_("Wizard"), valign=Gtk.Align.CENTER, margin_start=8
-        )
-        self.wizard_button.connect("clicked", self._on_wizard_clicked)
-        calibration_group.set_header_suffix(self.wizard_button)
-
-        settings_box.append(calibration_group)
-
-        self._distortion_rows = {}
-        for key, title, subtitle in [
-            (
-                "distortion_k1",
-                _("Radial 1 (k1)"),
-                _("First order radial distortion"),
-            ),
-            (
-                "distortion_k2",
-                _("Radial 2 (k2)"),
-                _("Second order radial distortion"),
-            ),
-            (
-                "distortion_k3",
-                _("Radial 3 (k3)"),
-                _("Third order radial distortion"),
-            ),
-            (
-                "distortion_p1",
-                _("Tangential 1 (p1)"),
-                _("First order tangential distortion"),
-            ),
-            (
-                "distortion_p2",
-                _("Tangential 2 (p2)"),
-                _("Second order tangential distortion"),
-            ),
-        ]:
-            row = self._create_spin_row(
-                title, subtitle, getattr(self.camera, key), key
-            )
-            self._distortion_rows[key] = row
-            calibration_group.add(row)
-
         self.camera.settings_changed.connect(self._on_camera_settings_changed)
         self.controller.resolutions_probed.connect(self._on_resolutions_probed)
 
     def _on_camera_settings_changed(self, camera):
-        for key, row in self._distortion_rows.items():
-            row.set_value(getattr(camera, key))
+        pass
 
     def _on_resolution_changed(self, combo_row, pspec):
         if self._updating_ui:
@@ -405,27 +353,6 @@ def _create_slider_row(
             on_value_changed=callback,
         )
 
-    def _create_spin_row(
-        self, title: str, subtitle: str, value: float, config_key: str
-    ) -> Adw.SpinRow:
-        row = Adw.SpinRow(
-            title=title,
-            subtitle=subtitle,
-            adjustment=Gtk.Adjustment(
-                value=value,
-                lower=-10.0,
-                upper=10.0,
-                step_increment=0.001,
-                page_increment=0.01,
-            ),
-            digits=4,
-            numeric=True,
-        )
-        row.connect(
-            "notify::value", self._on_distortion_value_changed, config_key
-        )
-        return row
-
     def on_white_balance_changed(self, scale):
         if not self.auto_white_balance_switch.get_active():
             self.camera.white_balance = scale.get_value()
@@ -456,21 +383,6 @@ def on_denoise_changed(self, scale):
     def on_transparency_changed(self, scale):
         self.camera.transparency = scale.get_value()
 
-    def _on_distortion_value_changed(
-        self, spin_row: Adw.SpinRow, pspec, config_key: str
-    ):
-        setattr(self.camera, config_key, spin_row.get_value())
-
-    def _on_wizard_clicked(self, button):
-        from .calibration_wizard import CalibrationWizard
-
-        window = self.get_ancestor(Gtk.Window)
-        if not isinstance(window, Gtk.Window):
-            return
-
-        wizard = CalibrationWizard(window, self.controller)
-        wizard.present()
-
     def do_close_request(self, *args) -> bool:
         logger.debug(
             f"CameraImageSettingsDialog closing for camera {self.camera.name}"