Merge remote-tracking branch 'upstream/main'

Author: fdrgsp

examples/stage_explorer_widget.py

@@ -1,4 +1,5 @@
 from pymmcore_plus import CMMCorePlus
+from qtpy.QtCore import QModelIndex
 from qtpy.QtWidgets import QApplication, QHBoxLayout, QSplitter, QVBoxLayout, QWidget
 
 from pymmcore_widgets import (
@@ -34,6 +35,24 @@
 cam_roi = CameraRoiWidget()
 
 
+# As an example...
+# When ROIs are edited or destroyed, update the MDA widget's stage positions.
+def _on_data_changed(top_left: QModelIndex, bottom_right: QModelIndex) -> None:
+    mgr = explorer.roi_manager
+    positions = [
+        roi.create_useq_position(overlap=mgr.scan_overlap, mode=mgr.scan_mode)
+        for roi in mgr.all_rois()
+    ]
+    # optional: skip positions that don't actually have a valid sequence (grid plan)
+    positions = [pos for pos in positions if pos.sequence is not None]
+    mda_widget.stage_positions.setValue(positions)
+
+
+model = explorer.roi_manager.roi_model
+model.dataChanged.connect(_on_data_changed)
+model.rowsRemoved.connect(_on_data_changed)
+
+
 # layout
 
 splitter = QSplitter()

pyproject.toml

@@ -51,7 +51,7 @@ dependencies = [
     "pymmcore-plus[cli]>=0.15.4",
     'qtpy >=2.0',
     'superqt[quantity,cmap,iconify] >=0.7.1',
-    'useq-schema >=0.8.0',
+    'useq-schema >=0.8.1',
     'vispy >=0.15.1',
     "pyopengl >=3.1.9; platform_system == 'Darwin'",
     "shapely>=2.1.2; python_version >= '3.14'",

src/pymmcore_widgets/control/_rois/_vispy.py

@@ -3,6 +3,7 @@
 from typing import TYPE_CHECKING
 
 import numpy as np
+import useq
 from vispy.scene import Compound
 from vispy.visuals import LineVisual, MarkersVisual, PolygonVisual
 
@@ -40,15 +41,20 @@ def __init__(self, roi: ROI) -> None:
         self.set_gl_state(depth_test=False)
         self.update_vertices(roi.vertices)
 
-    def update_vertices(self, vertices: np.ndarray) -> None:
+    def update_vertices(
+        self,
+        vertices: np.ndarray,
+        overlap: float | tuple[float, float] = 0.0,
+        mode: useq.OrderMode = useq.OrderMode.row_wise_snake,
+    ) -> None:
         """Update the vertices of the polygon."""
         self._polygon.pos = vertices
         self._handles.set_data(pos=vertices)
 
-        centers: list[tuple[float, float]] = []
-        if (grid := self._roi.create_grid_plan()) is not None:
-            for p in grid:
-                centers.append((p.x, p.y))
+        grid = self._roi.create_grid_plan(overlap=overlap, mode=mode)
+        centers = [
+            (p.x, p.y) for p in (grid or ()) if p.x is not None and p.y is not None
+        ]
 
         if centers and (fov_size := self._roi.fov_size):
             edges = []
@@ -73,12 +79,17 @@ def update_vertices(self, vertices: np.ndarray) -> None:
             self._fov_centers.visible = False
             self._fov_lines.visible = False
 
-    def update_from_roi(self, roi: ROI) -> None:
+    def update_from_roi(
+        self,
+        roi: ROI,
+        overlap: float | tuple[float, float] = 0.0,
+        mode: useq.OrderMode = useq.OrderMode.row_wise_snake,
+    ) -> None:
         self._polygon.color = roi.fill_color
         self._polygon.border_color = roi.border_color
         self._polygon._border_width = roi.border_width
 
-        self.update_vertices(roi.vertices)
+        self.update_vertices(roi.vertices, overlap=overlap, mode=mode)
         self.set_selected(roi.selected)
 
     def set_selected(self, selected: bool) -> None:

src/pymmcore_widgets/control/_rois/q_roi_model.py

@@ -75,6 +75,11 @@ def flags(self, index: QModelIndex) -> Qt.ItemFlag:
 
     # editable stuff ------------------------------
 
+    def getRoi(self, index: int) -> ROI:
+        if 0 <= index < len(self._rois):
+            return self._rois[index]
+        raise IndexError("Index out of bounds")
+
     def setData(
         self, index: QModelIndex, value: Any, role: int = Qt.ItemDataRole.EditRole
     ) -> bool:

src/pymmcore_widgets/control/_rois/roi_manager.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Literal, cast
+from typing import TYPE_CHECKING, Literal
 
+import useq
 from qtpy.QtCore import (
     QEvent,
     QItemSelection,
@@ -62,6 +63,8 @@ def __init__(self, canvas: SceneCanvas) -> None:
         self._roi_visuals: dict[ROI, RoiPolygon] = {}
 
         self._fov_size: tuple[float, float] | None = None
+        self._scan_overlap: float | tuple[float, float] = 0.0
+        self._scan_mode: useq.OrderMode = useq.OrderMode.row_wise_snake
 
         self.roi_model = QROIModel()
         self.selection_model = QItemSelectionModel(self.roi_model)
@@ -122,7 +125,7 @@ def update_fovs(self, fov: tuple[float, float]) -> None:
         """Update the FOVs of all ROIs."""
         self._fov_size = fov
         for row in range(self.roi_model.rowCount()):
-            roi = cast("ROI", self.roi_model.index(row).internalPointer())
+            roi = self.roi_model.getRoi(row)
             roi.fov_size = fov
             self.roi_model.emitDataChange(roi)
 
@@ -149,9 +152,35 @@ def canvas_to_world(self, point: QPointF) -> tuple[float, float]:
     def selected_rois(self) -> list[ROI]:
         """Return a list of selected ROIs."""
         return [
-            index.internalPointer() for index in self.selection_model.selectedIndexes()
+            index.data(QROIModel.ROI_ROLE)
+            for index in self.selection_model.selectedIndexes()
         ]
 
+    def all_rois(self) -> list[ROI]:
+        """Return a list of all ROIs."""
+        return [self.roi_model.getRoi(row) for row in range(self.roi_model.rowCount())]
+
+    @property
+    def scan_overlap(self) -> float | tuple[float, float]:
+        """Return the current scan overlap."""
+        return self._scan_overlap
+
+    @property
+    def scan_mode(self) -> useq.OrderMode:
+        """Return the current scan order mode."""
+        return self._scan_mode
+
+    def set_scan_options(
+        self,
+        overlap: float | tuple[float, float],
+        mode: useq.OrderMode,
+    ) -> None:
+        """Set scan overlap and mode, then refresh all ROI visuals."""
+        self._scan_overlap = overlap
+        self._scan_mode = mode
+        for roi in self.all_rois():
+            self.roi_model.emitDataChange(roi)
+
     def delete_selected_rois(self) -> None:
         """Delete the selected ROIs from the model."""
         for roi in self.selected_rois():
@@ -168,7 +197,7 @@ def _on_rows_about_to_be_removed(
     ) -> None:
         # Remove the ROIs from the canvas
         for row in range(first, last + 1):
-            roi = self.roi_model.index(row).internalPointer()
+            roi = self.roi_model.getRoi(row)
             self._remove_roi_from_canvas(roi)
 
     def _on_data_changed(
@@ -181,24 +210,24 @@ def _on_data_changed(
 
         # Update the ROI on the canvas
         for row in range(top_left.row(), bottom_right.row() + 1):
-            roi = self.roi_model.index(row).internalPointer()
-            do_update(roi)
+            if roi := self.roi_model.index(row).data(QROIModel.ROI_ROLE):
+                do_update(roi)
 
     def _on_selection_changed(
         self, selected: QItemSelection, deselected: QItemSelection
     ) -> None:
         for index in deselected.indexes():
-            roi = cast("ROI", self.roi_model.index(index.row()).internalPointer())
+            roi = self.roi_model.getRoi(index.row())
             if visual := self._roi_visuals.get(roi):
                 visual.set_selected(False)
         for index in selected.indexes():
-            roi = cast("ROI", self.roi_model.index(index.row()).internalPointer())
+            roi = self.roi_model.getRoi(index.row())
             if visual := self._roi_visuals.get(roi):
                 visual.set_selected(True)
 
     def _on_rows_inserted(self, parent: QModelIndex, first: int, last: int) -> None:
         for row in range(first, last + 1):
-            roi = self.roi_model.index(row).internalPointer()
+            roi = self.roi_model.getRoi(row)
             self._add_roi_to_scene(roi)
 
     def _add_roi_to_scene(self, roi: ROI) -> None:
@@ -214,12 +243,16 @@ def _remove_roi_from_canvas(self, roi: ROI) -> None:
     def _update_roi_visual(self, roi: ROI) -> None:
         # Update the the full ROI visual already on the canvas
         if visual := self._roi_visuals.get(roi):
-            visual.update_from_roi(roi)
+            visual.update_from_roi(
+                roi, overlap=self._scan_overlap, mode=self._scan_mode
+            )
 
     def _update_roi_vertices(self, roi: ROI) -> None:
         # Update the only vertices of the ROI visual
         if visual := self._roi_visuals.get(roi):
-            visual.update_vertices(roi.vertices)
+            visual.update_vertices(
+                roi.vertices, overlap=self._scan_overlap, mode=self._scan_mode
+            )
 
 
 class ROIScene(QWidget):

src/pymmcore_widgets/control/_rois/roi_model.py

@@ -6,7 +6,6 @@
 
 import numpy as np
 import useq
-import useq._grid
 
 
 @dataclass(eq=False)
@@ -23,7 +22,6 @@ class ROI:
     font_size: int = 12
 
     fov_size: tuple[float, float] | None = None  # (width, height)
-    fov_overlap: tuple[float, float] | None = None  # frac (width, height) 0..1
 
     def translate(self, dx: float, dy: float) -> None:
         """Translate the ROI in place by (dx, dy)."""
@@ -90,8 +88,10 @@ def create_grid_plan(
         self,
         fov_w: float | None = None,
         fov_h: float | None = None,
-    ) -> useq._grid._GridPlan | None:
-        """Return a useq.AbsolutePosition object that covers the ROI."""
+        overlap: float | tuple[float, float] = 0.0,
+        mode: useq.OrderMode = useq.OrderMode.row_wise_snake,
+    ) -> useq.GridFromPolygon | useq.GridFromEdges | None:
+        """Return a grid plan that covers this ROI, or None if it fits in one FOV."""
         if fov_w is None or fov_h is None:
             if self.fov_size is None:
                 raise ValueError("fov_size must be set or fov_w and fov_h must be set")
@@ -103,14 +103,21 @@ def create_grid_plan(
         # a single position at the center of the roi is sufficient, otherwise create a
         # grid plan that covers the roi
         if abs(right - left) > fov_w or abs(bottom - top) > fov_h:
+            overlap = overlap if isinstance(overlap, tuple) else (overlap, overlap)
             if type(self) is not RectangleROI:
                 if len(self.vertices) < 3:
                     return None
-                return useq.GridFromPolygon(
-                    vertices=list(self.vertices),
-                    fov_width=fov_w,
-                    fov_height=fov_h,
-                )
+                try:
+                    return useq.GridFromPolygon(
+                        vertices=list(self.vertices),
+                        fov_width=fov_w,
+                        fov_height=fov_h,
+                        mode=mode,
+                        overlap=overlap,
+                    )
+                except ValueError:
+                    # likely a self-intersecting polygon that cannot be scanned...
+                    return None
             else:
                 return useq.GridFromEdges(
                     top=top,
@@ -119,30 +126,30 @@ def create_grid_plan(
                     right=right,
                     fov_width=fov_w,
                     fov_height=fov_h,
+                    mode=mode,
+                    overlap=overlap,
                 )
         return None
 
     def create_useq_position(
         self,
         fov_w: float | None = None,
         fov_h: float | None = None,
-        z_pos: float = 0.0,
+        z_pos: float | None = None,
+        overlap: float | tuple[float, float] = 0.0,
+        mode: useq.OrderMode = useq.OrderMode.row_wise_snake,
     ) -> useq.AbsolutePosition:
         """Return a useq.AbsolutePosition object that covers the ROI."""
-        grid_plan = self.create_grid_plan(fov_w=fov_w, fov_h=fov_h)
-        x, y = self.center()
-        pos = useq.AbsolutePosition(x=x, y=y, z=z_pos)
+        grid_plan = self.create_grid_plan(
+            fov_w=fov_w, fov_h=fov_h, overlap=overlap, mode=mode
+        )
+        pos = useq.AbsolutePosition(z=z_pos, name=f"{self.text}_{self._uuid.hex[-4:]}")
+
         if grid_plan is None:
             return pos
 
         return pos.model_copy(
-            update={
-                "sequence": useq.MDASequence(
-                    grid_plan=grid_plan,
-                    fov_width=fov_w,
-                    fov_height=fov_h,
-                )
-            }
+            update={"sequence": useq.MDASequence(grid_plan=grid_plan)}
         )