feat: add minimal Points plan view

examples/hcs_temp/fov_selector.py

@@ -0,0 +1,11 @@
+from qtpy.QtWidgets import QApplication
+from useq import RandomPoints
+
+from pymmcore_widgets.hcs._fov_widget._fov_widget import FOVSelectorWidget
+
+app = QApplication([])
+
+fs = FOVSelectorWidget(RandomPoints(num_points=80, allow_overlap=False))
+fs.show()
+
+app.exec()

src/pymmcore_widgets/hcs/__init__.py

@@ -0,0 +1 @@
+"""High content screening widgets for PyMMCore."""

src/pymmcore_widgets/hcs/_fov_widget/_fov_widget.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import useq
+from qtpy.QtCore import Signal
+from qtpy.QtWidgets import QHBoxLayout, QWidget
+
+from pymmcore_widgets.useq_widgets.points_plans import RelativePointPlanSelector
+
+from ._well_graphics_view import WellView
+
+
+class FOVSelectorWidget(QWidget):
+    """Widget to select the FOVVs per well of the plate."""
+
+    valueChanged = Signal(object)
+
+    def __init__(
+        self,
+        plan: useq.RelativeMultiPointPlan | None = None,
+        parent: QWidget | None = None,
+    ) -> None:
+        super().__init__(parent=parent)
+
+        self.selector = RelativePointPlanSelector()
+        # graphics scene to draw the well and the fovs
+        self.well_view = WellView()
+
+        # main
+        layout = QHBoxLayout(self)
+        layout.addWidget(self.selector)
+        layout.addWidget(self.well_view)
+
+        # connect
+        self.selector.valueChanged.connect(self._on_selector_value_changed)
+        self.well_view.maxPointsDetected.connect(self._on_view_max_points_detected)
+        self.well_view.positionClicked.connect(self._on_view_position_clicked)
+
+        if plan is not None:
+            self.setValue(plan)
+
+    def value(self) -> useq.RelativeMultiPointPlan:
+        return self.selector.value()
+
+    def setValue(self, plan: useq.RelativeMultiPointPlan) -> None:
+        self.selector.setValue(plan)
+
+    def _on_selector_value_changed(self, value: useq.RelativeMultiPointPlan) -> None:
+        self.well_view.setPointsPlan(value)
+        self.valueChanged.emit(value)
+
+    def _on_view_max_points_detected(self, value: int) -> None:
+        self.selector.random_points_wdg.num_points.setValue(value)
+
+    def _on_view_position_clicked(
+        self, index: int, position: useq.RelativePosition
+    ) -> None:
+        if self.selector.active_plan_type is useq.RandomPoints:
+            print(position, type(position))
+            self.selector.random_points_wdg.start_at = position.replace(name=None)

src/pymmcore_widgets/hcs/_fov_widget/_well_graphics_view.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING
+
+import useq
+from qtpy.QtCore import QRectF, QSize, Qt, Signal
+from qtpy.QtGui import QColor, QPainter, QPen
+from qtpy.QtWidgets import QGraphicsItem, QGraphicsScene, QWidget
+from useq import Shape
+
+from pymmcore_widgets.hcs._util import ResizingGraphicsView
+
+if TYPE_CHECKING:
+    from PyQt6.QtGui import QMouseEvent
+
+DATA_POSITION = 1
+DATA_POSITION_INDEX = 2
+
+
+class WellView(ResizingGraphicsView):
+    """Graphics view to draw a well and the FOVs."""
+
+    maxPointsDetected = Signal(int)
+    positionClicked = Signal(int, object)
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        self._scene = QGraphicsScene()
+
+        super().__init__(self._scene, parent)
+        self.setStyleSheet("background:grey; border-radius: 5px;")
+        self.setRenderHints(
+            QPainter.RenderHint.Antialiasing | QPainter.RenderHint.SmoothPixmapTransform
+        )
+
+        # the scene coordinates are all real-world coordinates, in µm
+        # with the origin at the center of the view (0, 0)
+        self._well_width_um: float | None = 6000
+        self._well_height_um: float | None = 6000
+        self._fov_width_um: float = 400
+        self._fov_height_um: float = 340
+        self._is_circular: bool = False
+
+        # the item that draws the outline of the entire well area
+        self._outline_item: QGraphicsItem | None = None
+        # all of the rectangles representing the FOVs
+        self._fov_items: list[QGraphicsItem] = []
+
+        self.setMinimumSize(250, 250)
+
+    def sizeHint(self) -> QSize:
+        return QSize(500, 500)
+
+    def setPointsPlan(self, plan: useq.RelativeMultiPointPlan) -> None:
+        """Set the plan to use to draw the FOVs."""
+        plandict = plan.model_dump(exclude_none=True)
+        # use our fov values if the plan doesn't have them
+        plandict.setdefault("fov_width", self._fov_width_um)
+        plandict.setdefault("fov_height", self._fov_height_um)
+        plan = plan.model_construct(**plandict)
+
+        self._fov_width_um = plan.fov_width
+        self._fov_height_um = plan.fov_height
+        if isinstance(plan, useq.RandomPoints):
+            self._is_circular = plan.shape == Shape.ELLIPSE
+
+        # WELL OUTLINE
+        self._draw_outline()
+
+        # DRAW FOVS
+        self._draw_fovs(plan)
+
+    def mousePressEvent(self, event: QMouseEvent | None) -> None:
+        if event is None:
+            return
+        scene_pos = self.mapToScene(event.pos())
+        items = self.scene().items(scene_pos)
+        for item in items:
+            if idx := item.data(DATA_POSITION_INDEX):
+                self.positionClicked.emit(idx, item.data(DATA_POSITION))
+                break
+
+    def setWellSize(self, width_mm: float | None, height_mm: float | None) -> None:
+        """Set the well size width and height in mm."""
+        self._well_width_um = (width_mm * 1000) if width_mm else None
+        self._well_height_um = (height_mm * 1000) if height_mm else None
+
+    def _well_rect(self) -> QRectF:
+        """Return the QRectF of the well area."""
+        if not self._well_width_um or not self._well_height_um:
+            return QRectF()
+        return QRectF(
+            -self._well_width_um / 2,
+            -self._well_height_um / 2,
+            self._well_width_um,
+            self._well_height_um,
+        )
+
+    def _draw_outline(self) -> None:
+        """Draw the outline of the well area."""
+        if self._outline_item:
+            self._scene.removeItem(self._outline_item)
+
+        pen = QPen(QColor(Qt.GlobalColor.green))
+        pen.setWidth(self._scaled_pen_size())
+        if self._is_circular:
+            self._outline_item = self._scene.addEllipse(self._well_rect(), pen=pen)
+        else:
+            self._outline_item = self._scene.addRect(self._well_rect(), pen=pen)
+
+    def _draw_fovs(self, plan: useq.RelativeMultiPointPlan) -> None:
+        """Draw the fovs in the scene as rectangles."""
+        # delete existing FOVs
+        while self._fov_items:
+            self._scene.removeItem(self._fov_items.pop())
+
+        half_fov_width = self._fov_width_um / 2
+        half_fov_height = self._fov_height_um / 2
+
+        # constrain random points to our own well size, regardless of the plan settings
+        # TODO: emit a warning here?
+        if isinstance(plan, useq.RandomPoints):
+            kwargs = {}
+            if self._well_width_um:
+                kwargs["max_width"] = self._well_width_um - half_fov_width * 1.4
+            if self._well_height_um:
+                kwargs["max_height"] = self._well_height_um - half_fov_height * 1.4
+            plan = plan.replace(**kwargs)
+
+        pen = QPen(Qt.GlobalColor.white)
+        pen.setWidth(self._scaled_pen_size())
+        line_pen = QPen(QColor(0, 0, 0, 100))
+        line_pen.setWidth(int(self._scaled_pen_size() // 1.5))
+
+        # iterate over the plan greedily, catching any warnings
+        # and then alert the model if we didn't get all the points
+        # XXX: I'm not sure about this pattern... feels like the model should be
+        # able to handle this itself, but this is perhaps the only place we actually
+        # iterate over the plan
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            points = list(plan)
+        if len(points) < getattr(plan, "num_points", 0):
+            self.maxPointsDetected.emit(len(points))
+
+        # draw the FOVs, and a connecting line
+        last_p: useq.RelativePosition | None = None
+        for i, pos in enumerate(points):
+            if i == 0:
+                pen.setColor(QColor(Qt.GlobalColor.black))
+            else:
+                pen.setColor(QColor(Qt.GlobalColor.white))
+            item = self._scene.addRect(
+                pos.x - half_fov_width,
+                pos.y - half_fov_height,
+                self._fov_width_um,
+                self._fov_height_um,
+                pen,
+            )
+            item.setData(DATA_POSITION, pos)
+            item.setData(DATA_POSITION_INDEX, i)
+            if item:
+                item.setZValue(100 if i == 0 else 0)
+                self._fov_items.append(item)
+            # draw a line from the last point to this one
+            if i > 0 and last_p:
+                self._fov_items.append(
+                    self._scene.addLine(last_p.x, last_p.y, pos.x, pos.y, line_pen)
+                )
+            last_p = pos
+
+    def _scaled_pen_size(self) -> int:
+        # pick a pen size appropriate for the scene scale
+        # we might also want to scale this based on the sceneRect...
+        # and it's possible this needs to be rescaled on resize
+        if self._well_width_um:
+            return int(self._well_width_um / 150)
+        return int(self.sceneRect().width() / 150)

src/pymmcore_widgets/hcs/_util.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from qtpy.QtCore import QMarginsF, Qt
+from qtpy.QtWidgets import QGraphicsScene, QGraphicsView, QWidget
+
+if TYPE_CHECKING:
+    from qtpy.QtGui import QResizeEvent
+
+
+class ResizingGraphicsView(QGraphicsView):
+    """A QGraphicsView that resizes the scene to fit the view."""
+
+    def __init__(self, scene: QGraphicsScene, parent: QWidget | None = None) -> None:
+        super().__init__(scene, parent)
+        self.padding = 0.05  # fraction of the bounding rect
+
+    def resizeEvent(self, event: QResizeEvent) -> None:
+        if not (scene := self.scene()):
+            return
+        rect = scene.itemsBoundingRect()
+        xmargin = rect.width() * self.padding
+        ymargin = rect.height() * self.padding
+        margins = QMarginsF(xmargin, ymargin, xmargin, ymargin)
+        self.fitInView(rect.marginsAdded(margins), Qt.AspectRatioMode.KeepAspectRatio)

src/pymmcore_widgets/useq_widgets/points_plans/_grid_row_column_widget.py

@@ -47,7 +47,7 @@ def __init__(self, parent: QWidget | None = None) -> None:
         # overlap along y
         self.overlap_y = QDoubleSpinBox()
         self.overlap_y.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        self.overlap_x.setRange(-10000, 100)
+        self.overlap_y.setRange(-10000, 100)
         # order combo
         self.mode = QComboBox()
         self.mode.addItems([mode.value for mode in OrderMode])

src/pymmcore_widgets/useq_widgets/points_plans/_points_plan_selector.py

@@ -15,8 +15,6 @@
 )
 from superqt.utils import signals_blocked
 
-from pymmcore_widgets._util import SeparatorWidget
-
 from ._grid_row_column_widget import GridRowColumnWidget
 from ._random_points_widget import RandomPointWidget
 
@@ -72,6 +70,7 @@
         self._active_plan_widget: (
             RelativePositionWidget | RandomPointWidget | GridRowColumnWidget
         ) = self.single_pos_wdg
+        self._active_plan_type: type[RelativePointPlan] = useq.RelativePosition
 
         # radio buttons  selection
 
@@ -95,14 +94,16 @@
 
         main_layout = QVBoxLayout(self)
         main_layout.setSpacing(10)
-        main_layout.setContentsMargins(10, 10, 10, 10)
+        main_layout.setContentsMargins(10, 0, 10, 0)
         for btn, wdg in (
             (self.single_radio_btn, self.single_pos_wdg),
             (self.random_radio_btn, self.random_points_wdg),
             (self.grid_radio_btn, self.grid_wdg),
         ):
             wdg.setEnabled(btn.isChecked())  # type: ignore [attr-defined]
             grpbx = QGroupBox()
+            # make a click on the groupbox act as a click on the button
+            grpbx.mousePressEvent = lambda _, b=btn: b.setChecked(True)
             grpbx.setLayout(QVBoxLayout())
             grpbx.layout().addWidget(wdg)
 
@@ -113,11 +114,15 @@
             layout.addWidget(grpbx, 1)
             main_layout.addLayout(layout)
 
-        for i in range(0, 7, 2):
-            main_layout.insertWidget(i, SeparatorWidget())
+        # for i in range(1, 5, 2):
+        # main_layout.insertWidget(i, SeparatorWidget())
 
     # _________________________PUBLIC METHODS_________________________ #
 
+    @property
+    def active_plan_type(self) -> type[RelativePointPlan]:
+        return self._active_plan_type
+
     def value(self) -> useq.RelativeMultiPointPlan:
         return self._active_plan_widget.value()
 
@@ -129,20 +134,22 @@
         plan : useq.RelativePosition | useq.RandomPoints | useq.GridRowsColumns
             The point plan to set.
         """
-        if isinstance(plan, useq.RandomPoints):
-            with signals_blocked(self.random_points_wdg):
+        if plan == self.value():
+            return
+
+        with signals_blocked(self):
+            if isinstance(plan, useq.RandomPoints):
                 self.random_points_wdg.setValue(plan)
-            self.random_radio_btn.setChecked(True)
-        elif isinstance(plan, useq.GridRowsColumns):
-            with signals_blocked(self.grid_wdg):
+                self.random_radio_btn.setChecked(True)
+            elif isinstance(plan, useq.GridRowsColumns):
                 self.grid_wdg.setValue(plan)
-            self.grid_radio_btn.setChecked(True)
-        elif isinstance(plan, useq.RelativePosition):
-            with signals_blocked(self.single_pos_wdg):
+                self.grid_radio_btn.setChecked(True)
+            elif isinstance(plan, useq.RelativePosition):
                 self.single_pos_wdg.setValue(plan)
-            self.single_radio_btn.setChecked(True)
-        else:  # pragma: no cover
-            raise ValueError(f"Invalid plan type: {type(plan)}")
+                self.single_radio_btn.setChecked(True)
+            else:  # pragma: no cover
+                raise ValueError(f"Invalid plan type: {type(plan)}")
+        self._on_value_changed()
 
     # _________________________PRIVATE METHODS_________________________ #
 
@@ -156,7 +163,12 @@
         wdg.setEnabled(checked)
         if checked:
             self._active_plan_widget = wdg
-            self.valueChanged.emit(self.value())
+            self._active_plan_type = {
+                self.single_radio_btn: useq.RelativePosition,
+                self.random_radio_btn: useq.RandomPoints,
+                self.grid_radio_btn: useq.GridRowsColumns,
+            }[btn]
+            self._on_value_changed()
 
     def _on_value_changed(self) -> None:
         self.valueChanged.emit(self.value())