ROI Model

Author: gselzer

src/ndv/_types.py

@@ -56,33 +56,36 @@ class MouseButton(IntFlag):
     LEFT = auto()
     MIDDLE = auto()
     RIGHT = auto()
+    NONE = auto()
 
 
 class MouseMoveEvent(NamedTuple):
     """Event emitted when the user moves the cursor."""
 
     x: float
     y: float
+    btn: MouseButton = MouseButton.NONE
 
 
 class MousePressEvent(NamedTuple):
     """Event emitted when mouse button is pressed."""
 
     x: float
     y: float
-    btn: MouseButton = MouseButton.LEFT
+    btn: MouseButton
 
 
 class MouseReleaseEvent(NamedTuple):
     """Event emitted when mouse button is released."""
 
     x: float
     y: float
-    btn: MouseButton = MouseButton.LEFT
+    btn: MouseButton
 
 
 class CursorType(Enum):
     DEFAULT = "default"
+    CROSS = "cross"
     V_ARROW = "v_arrow"
     H_ARROW = "h_arrow"
     ALL_ARROW = "all_arrow"
@@ -101,9 +104,22 @@ def to_qt(self) -> Qt.CursorShape:
 
         return {
             CursorType.DEFAULT: Qt.CursorShape.ArrowCursor,
+            CursorType.CROSS: Qt.CursorShape.CrossCursor,
             CursorType.V_ARROW: Qt.CursorShape.SizeVerCursor,
             CursorType.H_ARROW: Qt.CursorShape.SizeHorCursor,
             CursorType.ALL_ARROW: Qt.CursorShape.SizeAllCursor,
             CursorType.BDIAG_ARROW: Qt.CursorShape.SizeBDiagCursor,
             CursorType.FDIAG_ARROW: Qt.CursorShape.SizeFDiagCursor,
         }[self]
+
+    def to_jupyter(self) -> str:
+        """Converts CursorType to jupyter cursor strings."""
+        return {
+            CursorType.DEFAULT: "default",
+            CursorType.CROSS: "crosshair",
+            CursorType.V_ARROW: "ns-resize",
+            CursorType.H_ARROW: "ew-resize",
+            CursorType.ALL_ARROW: "move",
+            CursorType.BDIAG_ARROW: "nesw-resize",
+            CursorType.FDIAG_ARROW: "nwse-resize",
+        }[self]

src/ndv/controllers/_array_viewer.py

@@ -9,7 +9,10 @@
 from ndv.controllers._channel_controller import ChannelController
 from ndv.models import ArrayDisplayModel, ChannelMode, DataWrapper, LUTModel
 from ndv.models._data_display_model import DataResponse, _ArrayDataDisplayModel
+from ndv.models._roi_model import RectangularROIModel
+from ndv.models._viewer_model import ArrayViewerModel, InteractionMode
 from ndv.views import _app
+from ndv.views.bases._graphics._canvas_elements import RectangularROI
 
 if TYPE_CHECKING:
     from concurrent.futures import Future
@@ -68,6 +71,9 @@ def __init__(
         self._data_model = _ArrayDataDisplayModel(
             data_wrapper=data, display=display_model or ArrayDisplayModel(**kwargs)
         )
+        self._viewer_model = ArrayViewerModel()
+        self._viewer_model.events.interaction_mode.connect(self._on_interaction_mode_changed)
+        self._roi_model: RectangularROIModel | None = None
 
         app = _app.gui_frontend()
 
@@ -87,10 +93,12 @@ def __init__(
         # get and create the front-end and canvas classes
         frontend_cls = _app.get_array_view_class()
         canvas_cls = _app.get_array_canvas_class()
-        self._canvas = canvas_cls()
+        self._canvas = canvas_cls(self._viewer_model)
 
         self._histogram: HistogramCanvas | None = None
-        self._view = frontend_cls(self._canvas.frontend_widget(), self._data_model)
+        self._view = frontend_cls(self._canvas.frontend_widget(), self._data_model, self._viewer_model)
+
+        self._roi_view: RectangularROI | None = None
 
         self._set_model_connected(self._data_model.display)
         self._canvas.set_ndim(self.display_model.n_visible_axes)
@@ -161,6 +169,19 @@ def data(self, data: Any) -> None:
         else:
             self._data_model.data_wrapper = DataWrapper.create(data)
         self._fully_synchronize_view()
+    
+    @property
+    def roi(self) -> RectangularROIModel | None:
+        return self._roi_model
+
+    @roi.setter
+    def roi(self, roi_model: RectangularROIModel | None) -> None:
+        if self._roi_model is not None:
+            self._set_roi_model_connected(self._roi_model, False)
+        self._roi_model = roi_model
+        if self._roi_model is not None:
+            self._set_roi_model_connected(self._roi_model)
+        self._fully_synchronize_view()
 
     def show(self) -> None:
         """Show the viewer."""
@@ -238,6 +259,22 @@ def _set_model_connected(
         ]:
             getattr(obj, _connect)(callback)
 
+    def _set_roi_model_connected(
+        self, model: RectangularROIModel, connect: bool = True
+    ) -> None:
+        """Connect or disconnect the model to/from the viewer.
+
+        We do this in a single method so that we are sure to connect and disconnect
+        the same events in the same order.  (but it's kinda ugly)
+        """
+        _connect = "connect" if connect else "disconnect"
+
+        for obj, callback in [
+            (model.events.bounding_box, self._on_roi_model_bounding_box_changed),
+            (model.events.visible, self._on_roi_model_visible_changed),
+        ]:
+            getattr(obj, _connect)(callback)
+
     # ------------------ Model callbacks ------------------
 
     def _fully_synchronize_view(self) -> None:
@@ -261,6 +298,9 @@ def _fully_synchronize_view(self) -> None:
             for lut_ctr in self._lut_controllers.values():
                 lut_ctr._update_view_from_model()
             self._update_hist_domain_for_dtype()
+        if self.roi is not None:
+            self._on_roi_model_bounding_box_changed(self.roi.bounding_box)
+            self._on_roi_model_visible_changed(self.roi.visible)
 
     def _on_model_visible_axes_changed(self) -> None:
         self._view.set_visible_axes(self._data_model.normed_visible_axes)
@@ -287,6 +327,31 @@ def _on_model_channel_mode_changed(self, mode: ChannelMode) -> None:
         # redraw
         self._clear_canvas()
         self._request_data()
+    
+    def _on_roi_model_bounding_box_changed(self, bb: tuple[tuple[float, float], tuple[float, float]]) -> None:
+        if self._roi_view is None:
+            self._roi_view = self._canvas.add_bounding_box()
+            # HACK
+            self._roi_view.set_visible(True)
+            self._roi_view.boundingBoxChanged.connect(self._on_roi_view_bounding_box_changed)
+        self._roi_view.set_bounding_box(*bb)
+
+    def _on_roi_model_visible_changed(self, visible: bool) -> None:
+        if self._roi_view is None:
+            self._roi_view = self._canvas.add_bounding_box()
+            # HACK
+            self._roi_view.set_visible(True)
+            self._roi_view.boundingBoxChanged.connect(self._on_roi_view_bounding_box_changed)
+        self._roi_view.set_visible(visible)
+    
+    def _on_interaction_mode_changed(self, mode: InteractionMode) -> None:
+        # TODO: Unify with _on_roi_model_bounding_box_changed
+        if mode == InteractionMode.CREATE_ROI:
+            if self._roi_view:
+                self._roi_view.remove()
+            self._roi_view = self._canvas.add_bounding_box()
+            # HACK
+            self._roi_view.boundingBoxChanged.connect(self._on_roi_view_bounding_box_changed)
 
     def _clear_canvas(self) -> None:
         for lut_ctrl in self._lut_controllers.values():
@@ -308,6 +373,10 @@ def _on_view_visible_axes_changed(self) -> None:
     def _on_view_reset_zoom_clicked(self) -> None:
         """Reset the zoom level of the canvas."""
         self._canvas.set_range()
+    
+    def _on_roi_view_bounding_box_changed(self, bb: tuple[tuple[float, float], tuple[float, float]]) -> None:
+        if self._roi_model:
+            self._roi_model.bounding_box = bb
 
     def _on_canvas_mouse_moved(self, event: MouseMoveEvent) -> None:
         """Respond to a mouse move event in the view."""

src/ndv/models/__init__.py

@@ -11,6 +11,7 @@
     ClimsStdDev,
     LUTModel,
 )
+from ._roi_model import RectangularROIModel
 
 __all__ = [
     "ArrayDisplayModel",
@@ -23,4 +24,5 @@
     "DataWrapper",
     "LUTModel",
     "NDVModel",
+    "RectangularROIModel",
 ]

src/ndv/models/_roi_model.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import field_validator
+
+from ndv.models._base_model import NDVModel
+
+if TYPE_CHECKING:
+    from typing import Any
+
+
+class RectangularROIModel(NDVModel):
+    """Representation of how to display an axis-aligned rectangular Region of Interest (ROI).
+
+    Parameters
+    ----------
+    visible : bool
+        Whether to display this roi.
+    bounding_box: tuple[Sequence[float], Sequence[float]]
+        The minimum point and the maximum point contained within the region.
+        Using these two points, an axis-aligned bounding box can be constructed.
+    """
+
+    visible: bool = True
+    bounding_box: tuple[tuple[float, float], tuple[float, float]] = ((0, 0), (0, 0))
+
+    @field_validator("bounding_box")
+    @classmethod
+    def _validate_bounding_box(
+        cls, bb: Any
+    ) -> tuple[tuple[float, float], tuple[float, float]]:
+        if not isinstance(bb, tuple):
+            raise ValueError(f"{bb} not a tuple of points!")
+        x1 = min(bb[0][0], bb[1][0])
+        y1 = min(bb[0][1], bb[1][1])
+        x2 = max(bb[0][0], bb[1][0])
+        y2 = max(bb[0][1], bb[1][1])
+        return ((x1, y1), (x2, y2))

src/ndv/models/_viewer_model.py

@@ -0,0 +1,27 @@
+from enum import Enum, auto
+
+from ndv.models._base_model import NDVModel
+
+
+class InteractionMode(Enum):
+    """An enum defining graphical interaction mechanisms with an array Viewer."""
+
+    PAN_ZOOM = auto()  # Mode allowing the user to pan and zoom
+    CREATE_ROI = auto()  # Mode where user clicks create ROIs
+
+
+class ArrayViewerModel(NDVModel):
+    """Representation of an array viewer.
+
+    TODO: This will likely contain other fields including:
+        * Dimensionality
+        * Camera position
+        * Camera frustum
+
+    Parameters
+    ----------
+    interaction_mode : InteractionMode
+        Describes the current interaction mode of the Viewer.
+    """
+
+    interaction_mode: InteractionMode = InteractionMode.PAN_ZOOM