mesofield 0.3.2b0__py3-none-any.whl

mesofield/gui/mdagui.py

@@ -0,0 +1,285 @@
+from pymmcore_plus import CMMCorePlus
+
+from PyQt6.QtWidgets import (
+    QCheckBox,
+    QGroupBox,
+    QHBoxLayout,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+    QSizePolicy,
+)
+
+from pymmcore_widgets import MDAWidget
+
+from mesofield.data.writer import CustomWriter
+from mesofield.gui.viewer import ImagePreview, InteractivePreview
+from mesofield.utils._logger import get_logger
+
+
+_logger = get_logger(__name__)
+
+
+class CameraButtons(QWidget):
+    """Snap + Live toggle wired through the BaseCamera contract.
+
+    Replaces pymmcore-widgets' ``SnapButton`` / ``LiveButton`` (which only
+    worked for mmcore-backed cameras) with two buttons that call
+    ``cam.snap()`` / ``cam.start_live()`` / ``cam.stop_live()``.  Those
+    methods are defined on :class:`mesofield.devices.base_camera.BaseCamera`
+    and implemented by every camera subclass, so the GUI no longer cares
+    whether the underlying backend is Micro-Manager, OpenCV, or the
+    synthetic :class:`MockFrameProducer`.
+
+    The widget delegates frame display to the camera's existing signal
+    plumbing:
+
+    - MMCamera: ``cam.snap()`` calls ``mmcore.snap()`` which fires the
+      ``imageSnapped`` event the :class:`ImagePreview` is already wired
+      to; ``cam.start_live()`` triggers ``startContinuousSequenceAcquisition``
+      and frames flow through the MDA events.
+    - OpenCVCamera / MockFrameProducer: ``snap()`` and the live loop emit
+      ``cam.image_ready`` (a ``pyqtSignal(np.ndarray)``) which the
+      ``ImagePreview`` subscribes to via ``image_payload``.
+    """
+
+    def __init__(self, cam, preview=None) -> None:
+        super().__init__()
+        self.cam = cam
+        self.preview = preview
+        layout = QHBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(layout)
+
+        self.snap_btn = QPushButton("Snap")
+        self.snap_btn.setToolTip(f"cam.snap()  [{cam.backend} backend]")
+        self.snap_btn.clicked.connect(self._on_snap)
+        layout.addWidget(self.snap_btn)
+
+        self.live_btn = QPushButton("Live")
+        self.live_btn.setCheckable(True)
+        self.live_btn.setToolTip(
+            f"toggle cam.start_live() / cam.stop_live()  [{cam.backend} backend]"
+        )
+        self.live_btn.toggled.connect(self._on_live_toggled)
+        layout.addWidget(self.live_btn)
+
+        # Runtime auto-contrast toggle for the live viewer. The "off" state
+        # restores a viewer-appropriate manual range (8-bit static preview
+        # vs 16-bit interactive preview).
+        self._manual_clims = (
+            (0, 65535) if isinstance(preview, InteractivePreview) else (0, 255)
+        )
+        self.auto_contrast_cb = QCheckBox("Auto-contrast")
+        self.auto_contrast_cb.setChecked(bool(getattr(cam, "auto_contrast", True)))
+        self.auto_contrast_cb.setToolTip("Toggle live-viewer auto-contrast")
+        self.auto_contrast_cb.toggled.connect(self._on_auto_contrast_toggled)
+        layout.addWidget(self.auto_contrast_cb)
+        # Sync the viewer's contrast mode to the checkbox's initial state.
+        self._on_auto_contrast_toggled(self.auto_contrast_cb.isChecked())
+
+    def set_enabled(self, enabled: bool) -> None:
+        """Enable/disable the snap + live controls (used during acquisition)."""
+        self.snap_btn.setEnabled(enabled)
+        self.live_btn.setEnabled(enabled)
+
+    def _on_auto_contrast_toggled(self, checked: bool) -> None:
+        if self.preview is None:
+            return
+        try:
+            self.preview.clims = "auto" if checked else self._manual_clims
+        except Exception as exc:
+            _logger.warning(
+                "auto-contrast toggle failed on %s: %s", self.cam.device_id, exc
+            )
+
+    def _on_snap(self) -> None:
+        try:
+            self.cam.snap()
+        except Exception as exc:
+            _logger.warning("snap failed on %s: %s", self.cam.device_id, exc)
+
+    def _on_live_toggled(self, checked: bool) -> None:
+        try:
+            if checked:
+                self.cam.start_live()
+                self.live_btn.setText("Stop Live")
+            else:
+                self.cam.stop_live()
+                self.live_btn.setText("Live")
+        except Exception as exc:
+            _logger.warning(
+                "live toggle failed on %s: %s", self.cam.device_id, exc
+            )
+            # Reset the toggle state if start/stop failed.
+            self.live_btn.blockSignals(True)
+            self.live_btn.setChecked(not checked)
+            self.live_btn.setText("Live")
+            self.live_btn.blockSignals(False)
+
+class CustomMDAWidget(MDAWidget):
+    def run_mda(self) -> None:
+        """Run the MDA sequence experiment."""
+        # in case the user does not press enter after editing the save name.
+        self.save_info.save_name.editingFinished.emit()
+
+        sequence = self.value()
+
+        # technically, this is in the metadata as well, but isChecked is more direct
+        if self.save_info.isChecked():
+            save_path = self._update_save_path_from_metadata(
+                sequence, update_metadata=True
+            )
+        else:
+            save_path = None
+
+        # run the MDA experiment asynchronously
+        self._mmc.run_mda(sequence, output=CustomWriter(save_path))
+
+class MDA(QWidget):
+    """
+    The `MDAWidget` provides a GUI to construct a `useq.MDASequence` object.
+    This object describes a full multi-dimensional acquisition;
+    In this example, we set the `MDAWidget` parameter `include_run_button` to `True`,
+    meaning that a `run` button is added to the GUI. When pressed, a `useq.MDASequence`
+    is first built depending on the GUI values and is then passed to the
+    `CMMCorePlus.run_mda` to actually execute the acquisition.
+    For details of the corresponding schema and methods, see
+    https://github.com/pymmcore-plus/useq-schema and
+    https://github.com/pymmcore-plus/pymmcore-plus.
+
+    """
+
+    def __init__(self, procedure) -> None:
+        """
+
+        The layout adapts the viewer based on the number of cores:
+
+        Single Core Layout:
+
+            +----------------------------------------+
+            | Live Viewer                            |
+            | +-----------------+-----------------+  |
+            | | [Snap Button]   |  [Live Button}  |  |
+            | +-----------------+-----------------+  |
+            | |                                   |  |
+            | |            Image Preview          |  |
+            | |                                   |  |
+            | +-----------------------------------+  |
+            +----------------------------------------+
+                
+        Dual Core Layout:
+
+            +-----------------------------------------------+
+            |   Live Viewer                                 |
+            |  +---------------------+-------------------+  |
+            |  |      Core 1         |      Core 2       |  |
+            |  +---------------------+-------------------+  |
+            |  |     [Buttons]       |     [Buttons]     |  |
+            |  +---------------------+-------------------+  |
+            |  |                     |                   |  |
+            |  |  Image Preview 1    |  Image Preview 2  |  |
+            |  |                     |                   |  |
+            |  +---------------------+-------------------+  |
+            +-----------------------------------------------+
+
+        """
+        super().__init__()
+        # get the CMMCore instance and load the default config
+        self.procedure = procedure
+        config = procedure.config
+        self.cameras = config.hardware.cameras
+        self.mmcores = tuple(cam.core for cam in self.cameras)
+        self._viewer_type = config.hardware._viewer
+        # instantiate the MDAWidget
+        #self.mda = MDAWidget(mmcore=self.mmcores[0])
+        # ----------------------------------Auto-set MDASequence and save_info----------------------------------#
+        #self.mda.setValue(config.pupil_sequence)
+        #self.mda.save_info.setValue({'save_dir': r'C:/dev', 'save_name': 'file', 'format': 'ome-tiff', 'should_save': True})
+        # -------------------------------------------------------------------------------------------------------#
+        self.setLayout(QHBoxLayout())
+
+        live_viewer = QGroupBox()
+        live_viewer.setLayout(QVBoxLayout())
+        live_viewer.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        buttons = QGroupBox()
+        buttons.setLayout(QHBoxLayout())
+
+        cores_groupbox = QGroupBox(f"{self.__module__}.{self.__class__.__name__}: Live Viewer")
+        cores_groupbox.setLayout(QHBoxLayout())
+
+        # Track the per-camera button widgets so acquisition can lock them out.
+        self._camera_buttons: list[CameraButtons] = []
+
+        for cam in self.cameras:
+            # Per-core container
+            core_box = QGroupBox(title=str(cam.name))
+            core_box.setLayout(QVBoxLayout())
+            core_box.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+            auto_contrast = getattr(cam, "auto_contrast", True)
+
+            # Preview widget: ImagePreview drives display.
+            # - mmcore-backed cameras wire the preview to mmcore events;
+            # - everyone else feeds it via the camera's `image_ready` Qt
+            #   signal (an attribute on every BaseCamera subclass).
+            if cam.viewer == "static":
+                if isinstance(cam.core, CMMCorePlus):
+                    preview = ImagePreview(
+                        mmcore=cam.core,
+                        _clims='auto' if auto_contrast else (0, 255),
+                    )
+                else:
+                    image_signal = getattr(cam, "image_ready", None)
+                    if image_signal is None and cam.core is not None:
+                        image_signal = getattr(cam.core, "image_ready", None)
+                    preview = ImagePreview(
+                        mmcore=None,
+                        image_payload=image_signal,
+                        progress_payload=getattr(cam, "progress", None),
+                        _clims='auto' if auto_contrast else (0, 255),
+                    )
+            else:
+                # Interactive / pyqtgraph viewer.
+                image_signal = getattr(cam, "image_ready", None)
+                if image_signal is None and cam.core is not None:
+                    image_signal = getattr(cam.core, "image_ready", None)
+                preview = InteractivePreview(image_payload=image_signal)
+
+            # Unified snap + live buttons -- driven by BaseCamera methods.
+            # Works for MMCamera (via mmcore), OpenCVCamera (capture thread),
+            # and MockFrameProducer (synthetic frames). Non-mmcore cameras
+            # used to auto-start on widget creation; now the user clicks
+            # "Live" to start, matching mmcore camera UX.
+            cam_buttons = CameraButtons(cam, preview)
+            self._camera_buttons.append(cam_buttons)
+            core_box.layout().addWidget(cam_buttons)
+            core_box.layout().addWidget(preview)
+            cores_groupbox.layout().addWidget(core_box)
+
+        # Add the cores_groupbox once, not once per camera (the old code
+        # added it inside the loop, producing duplicate top-level widgets).
+        self.layout().addWidget(cores_groupbox)
+
+        # Lock the Snap/Live buttons for the duration of a Procedure run.
+        # Bound-method connections auto-disconnect when this QWidget is
+        # destroyed (the widget is rebuilt on every hardware reload).
+        events = getattr(procedure, "events", None)
+        if events is not None:
+            events.procedure_started.connect(self._on_acquisition_started)
+            events.procedure_finished.connect(self._on_acquisition_finished)
+            events.procedure_error.connect(self._on_acquisition_finished)
+
+    def _on_acquisition_started(self, *_args) -> None:
+        self.set_acquisition_active(True)
+
+    def _on_acquisition_finished(self, *_args) -> None:
+        self.set_acquisition_active(False)
+
+    def set_acquisition_active(self, active: bool) -> None:
+        """Lock out the Snap/Live buttons while a Procedure run is in progress."""
+        for cam_buttons in self._camera_buttons:
+            cam_buttons.set_enabled(not active)
+
+
+
+

mesofield/gui/qt_device_adapter.py

@@ -0,0 +1,109 @@
+"""Qt adapter that bridges pure-Python device signals into ``pyqtSignal``s.
+
+GUI code (e.g. live plotting, image previews) needs Qt signals so that
+emissions are delivered on the main thread with QueuedConnection
+semantics.  Devices built on
+:class:`mesofield.devices.base.BaseDataProducer` use ``psygnal`` and
+remain Qt-free.  This module is the seam: attach an adapter to a
+device, expose the adapter's ``pyqtSignal`` as an attribute on the
+device, and the GUI reads that attribute.
+
+Two adapters live here:
+
+- :class:`QtDeviceAdapter` — for serial-style devices. Bridges
+  ``signals.data`` into ``serialDataReceived`` / ``serialSpeedUpdated``.
+- :class:`QtImageAdapter` — for camera-shaped devices. Provides an
+  ``image_ready(np.ndarray)`` pyqtSignal that the MDA viewer subscribes
+  to. The device pushes frames into the adapter via
+  ``adapter.emit_frame(frame)``.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import numpy as np
+from PyQt6.QtCore import QObject, pyqtSignal
+
+
+class QtDeviceAdapter(QObject):
+    """Bridges ``device.signals.data`` into Qt-friendly emissions.
+
+    Subscribes to the device's ``signals.data`` and re-emits:
+
+    - ``serialDataReceived(object)``  — the raw payload.
+    - ``serialSpeedUpdated(float, float)`` — ``(time_s, speed)`` whenever
+      the payload is a ``dict`` carrying a ``"speed"`` key.  ``time_s``
+      defaults to the device timestamp; if absent, the queue timestamp.
+    """
+
+    serialDataReceived = pyqtSignal(object)
+    serialSpeedUpdated = pyqtSignal(float, float)
+
+    def __init__(self, device: Any) -> None:
+        super().__init__()
+        self._device = device
+        signals = getattr(device, "signals", None)
+        data_sig = getattr(signals, "data", None) if signals is not None else None
+        if data_sig is not None and hasattr(data_sig, "connect"):
+            try:
+                data_sig.connect(self._on_data)
+            except Exception:
+                pass
+
+    def _on_data(self, payload: Any, ts: Any = None) -> None:
+        try:
+            self.serialDataReceived.emit(payload)
+        except Exception:
+            pass
+
+        # Pull a scalar "value" out of the payload for the live trace.
+        value: Optional[float] = None
+        t: Any = None
+        if isinstance(payload, dict):
+            if "speed" in payload:
+                value = payload["speed"]
+                t = payload.get("device_us")
+        elif isinstance(payload, (int, float)):
+            value = payload
+
+        if value is None:
+            return
+        if t is None:
+            t = ts if ts is not None else 0.0
+        try:
+            self.serialSpeedUpdated.emit(float(t), float(value))
+        except (TypeError, ValueError):
+            pass
+
+
+class QtImageAdapter(QObject):
+    """Bridges per-frame ndarray emissions into a Qt ``image_ready`` signal.
+
+    The MDA gui's static-viewer branch subscribes via
+    ``preview = ImagePreview(image_payload=cam.image_ready, ...)``, which
+    calls ``image_payload.connect(cb, type=QueuedConnection)`` -- so
+    ``image_ready`` MUST be a real ``pyqtSignal``. Devices built on
+    :class:`BaseDataProducer` are non-Qt; they hold an instance of this
+    adapter and expose its ``image_ready`` attribute as their own.
+
+    Usage::
+
+        class MyCam(BaseDataProducer):
+            def __init__(self, cfg=None, **kwargs):
+                super().__init__(cfg, **kwargs)
+                self._qt_image_adapter = QtImageAdapter()
+                self.image_ready = self._qt_image_adapter.image_ready
+
+            def _run_loop(self):
+                ...
+                self._qt_image_adapter.emit_frame(frame)
+    """
+
+    image_ready = pyqtSignal(np.ndarray)
+
+    def emit_frame(self, frame: np.ndarray) -> None:
+        try:
+            self.image_ready.emit(frame)
+        except Exception:
+            pass

mesofield/gui/speedplotter.py

@@ -0,0 +1,152 @@
+from PyQt6.QtWidgets import QWidget, QVBoxLayout, QLabel, QPushButton
+import pyqtgraph as pg
+
+
+class SerialWidget(QWidget):
+    """
+    A live-plotting widget for any serial device that emits a 
+    pyqtSignal(float, float) representing (time, value).
+    
+    Parameters
+    ----------
+    cfg : ExperimentConfig
+        The experiment configuration object.  The device is resolved from
+        ``cfg.hardware.<device_attr>``.  If that attribute is ``None`` or
+        missing the widget renders in a safe *disconnected* state.
+    device_attr : str
+        Attribute name on ``cfg.hardware`` to look up (default ``"encoder"``).
+    signal_name : str
+        Name of the pyqtSignal attribute on the device to connect to.
+    label : str
+        Human-readable name shown in the info label.
+    value_label : str
+        Y-axis label for the plot.
+    value_units : str
+        Y-axis units.
+    y_range : tuple[float, float]
+        Initial Y-axis range.
+    value_scale : float
+        Multiplicative factor applied to incoming values before plotting.
+    max_points : int
+        Number of data points to keep visible.
+    """
+
+    def __init__(
+        self,
+        cfg,
+        device_attr: str = "encoder",
+        signal_name: str = "serialSpeedUpdated",
+        label: str = "Serial Device",
+        value_label: str = "Value",
+        value_units: str = "",
+        y_range: tuple = (-1, 1),
+        value_scale: float = 0.01,
+        max_points: int = 100,
+    ):
+        super().__init__()
+        self.device = getattr(cfg.hardware, device_attr, None)
+        self.signal_name = signal_name
+        self.label = label
+        self.value_label = value_label
+        self.value_units = value_units
+        self.y_range = y_range
+        self.value_scale = value_scale
+        self.max_points = max_points
+        self.connected = self.device is not None
+
+        self._signal = getattr(self.device, self.signal_name, None) if self.connected else None
+
+        self.init_ui()
+        self.init_data()
+        self.setFixedHeight(300)
+
+    # ---- UI ----------------------------------------------------------------
+
+    def init_ui(self):
+        self.layout = QVBoxLayout()
+
+        if self.connected:
+            port = getattr(self.device, 'port', '?')
+            baud = getattr(self.device, 'baudrate', '?')
+            status_text = "Click 'Start Live View' to begin."
+            info_text = f'{self.label} on Port: {port} | Baud: {baud}'
+        else:
+            status_text = "No device connected."
+            info_text = f"{self.label}: not available"
+
+        self.status_label = QLabel(status_text)
+        self.info_label = QLabel(info_text)
+        self.start_button = QPushButton("Start Live View")
+        self.start_button.setCheckable(True)
+        self.start_button.setEnabled(self.connected)
+        self.plot_widget = pg.PlotWidget()
+
+        self.start_button.clicked.connect(self.toggle_serial_thread)
+
+        self.layout.addWidget(self.status_label)
+        self.layout.addWidget(self.info_label)
+        self.layout.addWidget(self.start_button)
+        self.layout.addWidget(self.plot_widget)
+        self.setLayout(self.layout)
+
+        units_str = self.value_units or None
+        self.plot_widget.setTitle('Serial Trace')
+        self.plot_widget.setLabel('left', self.value_label, units=units_str)
+        self.plot_widget.setLabel('bottom', 'Time', units='s')
+        self.data_curve = self.plot_widget.plot(pen='y')
+
+        self.plot_widget.setYRange(*self.y_range)
+        self.plot_widget.showGrid(x=True, y=True)
+
+        if self._signal is not None:
+            self._signal.connect(self.receive_data)
+
+    # ---- Data --------------------------------------------------------------
+
+    def init_data(self):
+        self.times = []
+        self.values = []
+        self.start_time = None
+        self.timer = None
+        self.previous_time = 0
+
+    def toggle_serial_thread(self):
+        if not self.connected:
+            return
+        if self.start_button.isChecked():
+            self._signal.connect(self.receive_data)
+            self.device.start()
+            self.status_label.setText("Serial thread started.")
+        else:
+            self.stop_serial_thread()
+            self.status_label.setText("Serial thread stopped.")
+
+    def stop_serial_thread(self):
+        if self._signal is not None:
+            self._signal.disconnect()
+
+    def receive_data(self, time, value):
+        self.times.append(time)
+        self.values.append(value * self.value_scale)
+        self.times = self.times[-self.max_points:]
+        self.values = self.values[-self.max_points:]
+        self.update_plot()
+        unit_suffix = f" {self.value_units}" if self.value_units else ""
+        self.status_label.setText(
+            f"{self.value_label}: {value:.2f}{unit_suffix}"
+        )
+
+    def update_plot(self):
+        try:
+            if self.times and self.values:
+                self.data_curve.setData(self.times, self.values)
+                self.plot_widget.setXRange(self.times[0], self.times[-1], padding=0)
+            else:
+                self.plot_widget.clear()
+                self.plot_widget.setTitle('No data received.')
+        except Exception as e:
+            print(f"Exception in update_plot: {e}")
+
+
+# Backwards-compatible alias
+EncoderWidget = SerialWidget