feat: stage explorer part 1

examples/stage_viewer_widget.py

@@ -0,0 +1,30 @@
+import numpy as np
+from vispy import scene
+
+from pymmcore_widgets.control._stage_explorer._stage_viewer import StageViewer
+
+img = np.random.randint(0, 255, (256, 256))
+
+
+class SV(StageViewer):
+    """Stage viewer widget with mouse press event."""
+
+    def __init__(self):
+        super().__init__()
+
+        self.canvas.events.mouse_press.connect(self._on_mouse_press)
+
+    def _on_mouse_press(self, event) -> None:
+        """Handle the mouse press event."""
+        canvas_pos = (event.pos[0], event.pos[1])
+        world_pos = self._tform().map(canvas_pos)[:2]
+        print()
+        print(world_pos)
+
+    def _tform(self) -> scene.transforms.BaseTransform:
+        """Return the transform from canvas to scene."""
+        return list(self._get_images())[-1].transforms.get_transform("canvas", "scene")
+
+
+wdg = SV()
+wdg.show()

pyproject.toml

@@ -53,6 +53,7 @@ dependencies = [
     'qtpy >=2.0',
     'superqt[quantity,cmap] >=0.7.1',
     'useq-schema >=0.5.0',
+    'vispy'
 ]
 
 [tool.hatch.metadata]

src/pymmcore_widgets/control/_stage_explorer/_stage_viewer.py

@@ -0,0 +1,105 @@
+from collections.abc import Iterator
+from typing import Optional, cast
+
+import numpy as np
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import (
+    QVBoxLayout,
+    QWidget,
+)
+from vispy import scene
+from vispy.scene.visuals import Image
+from vispy.scene.widgets import ViewBox
+
+
+class StageViewer(QWidget):
+    """A widget to add images with a transform to a vispy canves."""
+
+    def __init__(self, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self.setWindowTitle("Stage Explorer")
+        self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+
+        self.canvas = scene.SceneCanvas(keys="interactive", show=True)
+        self.view = cast(ViewBox, self.canvas.central_widget.add_view())
+        self.view.camera = scene.PanZoomCamera(aspect=1)
+
+        main_layout = QVBoxLayout(self)
+        main_layout.setSpacing(0)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.addWidget(self.canvas.native)
+
+    # --------------------PUBLIC METHODS--------------------
+
+    def add_image(self, img: np.ndarray, transform: np.ndarray | None = None) -> None:
+        """Add an image to the scene with the given transform."""
+        frame = Image(img, cmap="grays", parent=self.view.scene, clim="auto")
+        # keep the added image on top of the others
+        frame.order = min(child.order for child in self._get_images()) - 1
+        # add the image to the scene with the transform
+        transform = np.eye(4) if transform is None else transform
+        frame.transform = scene.MatrixTransform(matrix=transform)
+
+    def clear_scene(self) -> None:
+        """Clear the scene."""
+        # remove all images from the scene
+        for child in reversed(self.view.scene.children):
+            if isinstance(child, Image):
+                child.parent = None
+
+    def reset_view(self) -> None:
+        """Recenter the view to the center of all images."""
+        min_x, max_x, min_y, max_y = self._get_full_boundaries()
+        if any(val is None for val in (min_x, max_x, min_y, max_y)):
+            return
+        self.view.camera.set_range(x=(min_x, max_x), y=(min_y, max_y), margin=0)
+
+    # --------------------PRIVATE METHODS--------------------
+
+    def _get_images(self) -> Iterator[Image]:
+        """Yield images in the scene."""
+        for child in self.view.scene.children:
+            if isinstance(child, Image):
+                yield child
+
+    def _get_full_boundaries(
+        self, pixel_size: float = 1.0
+    ) -> tuple[float | None, float | None, float | None, float | None]:
+        """Return the boundaries of the images in the scene...
+
+        as (min_x, max_x, min_y, max_y).
+
+        The pixel_size is used to convert the image dimensions to the scene
+        coordinates.
+        """
+        # TODO: maybe consider also the rectangles (ROIs) in the scene
+        all_corners: list[np.ndarray] = []
+        for child in self._get_images():
+            # get image dimensions
+            w, h = child.bounds(0)[1] * pixel_size, child.bounds(1)[1] * pixel_size
+            # get the (x, y) coordinates from the transform matrix
+            x, y = child.transform.matrix[3, :2]
+            # get the four corners of the image. NOTE: when an image is added to
+            # the scene with vispy, image origin is at the bottom-left corner
+            # TODO: Fix me! If we invert the coordinates in micromnager
+            # (e.g. transpose X), the image origin will be at the bottom-right.
+            # need to figure out what to do...
+            corners = np.array(
+                [
+                    [x, y],  # bottom-left
+                    [x + w, y],  # bottom-right
+                    [x + w, y + h],  # top-right
+                    [x, y + h],  # top-left
+                ]
+            )
+            # transform the corners to scene coordinates
+            all_corners.append(corners)
+
+        if not all_corners:
+            return None, None, None, None
+
+        # combine all corners into one array and compute the bounding box
+        all_corners_combined = np.vstack(all_corners)
+        min_x, min_y = all_corners_combined.min(axis=0)
+        max_x, max_y = all_corners_combined.max(axis=0)
+        return min_x, max_x, min_y, max_y

src/pymmcore_widgets/control/_stage_widget.py

@@ -464,6 +464,7 @@ def _move_stage_relative(self, x: float, y: float) -> None:
             self._mmc.logMessage(f"Error moving stage: {e}")  # pragma: no cover
         else:
             if self.snap_checkbox.isChecked():
+                self._mmc.waitForDevice(self._device)
                 self._mmc.snap()
 
     def _move_x_absolute(self) -> None:
@@ -475,6 +476,7 @@ def _move_x_absolute(self) -> None:
             self._mmc.logMessage(f"Error moving stage: {e}")  # pragma: no cover
         else:
             if self.snap_checkbox.isChecked():
+                self._mmc.waitForDevice(self._device)
                 self._mmc.snap()
 
     def _move_y_absolute(self) -> None:
@@ -489,6 +491,7 @@ def _move_y_absolute(self) -> None:
             self._mmc.logMessage(f"Error moving stage: {e}")  # pragma: no cover
         else:
             if self.snap_checkbox.isChecked():
+                self._mmc.waitForDevice(self._device)
                 self._mmc.snap()
 
     def _disconnect(self) -> None:

tests/test_stage_viewer.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from vispy.scene.visuals import Image
+
+from pymmcore_widgets.control._stage_explorer._stage_viewer import StageViewer
+
+if TYPE_CHECKING:
+    from pytestqt.qtbot import QtBot
+
+IMG = np.random.randint(0, 255, (100, 50), dtype=np.uint8)
+
+
+def _build_transform_matrix(x: float, y: float) -> np.ndarray:
+    T = np.eye(4)
+    T[0, 3] += x
+    T[1, 3] += y
+    return T
+
+
+def test_add_image(qtbot: QtBot):
+    stage_viewer = StageViewer()
+    qtbot.addWidget(stage_viewer)
+    T = _build_transform_matrix(100, 150)
+    stage_viewer.add_image(IMG, T.T)
+    images = [i for i in stage_viewer.view.scene.children if isinstance(i, Image)]
+    assert len(images) == 1
+    added_img = next(iter(images))
+    assert tuple(added_img.transform.matrix[3, :2]) == (100, 150)
+
+
+def test_clear_scene(qtbot: QtBot):
+    stage_viewer = StageViewer()
+    qtbot.addWidget(stage_viewer)
+    T = _build_transform_matrix(200, 50)
+    stage_viewer.add_image(IMG, T.T)
+    assert [i for i in stage_viewer.view.scene.children if isinstance(i, Image)]
+    stage_viewer.clear_scene()
+    assert not [i for i in stage_viewer.view.scene.children if isinstance(i, Image)]
+
+
+def test_reset_view(qtbot: QtBot):
+    stage_viewer = StageViewer()
+    qtbot.addWidget(stage_viewer)
+    T = _build_transform_matrix(500, 100)
+    stage_viewer.add_image(IMG, T.T)
+    stage_viewer.reset_view()
+    cx, cy = stage_viewer.view.camera.rect.center
+    assert round(cx) == 525  # image width is 50, center should be Tx + width/2
+    assert round(cy) == 150  # image height is 100, center should be Ty + height/2