feat: stackviewer v2

.pre-commit-config.yaml

@@ -27,5 +27,5 @@ repos:
       - id: mypy
         files: "^src/"
         additional_dependencies:
-          - pymmcore-plus >=0.9.0
+          - pymmcore-plus >=0.9.5
           - useq-schema >=0.4.7

examples/mda_viewer.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from pymmcore_plus import CMMCorePlus, configure_logging
+from qtpy import QtWidgets
+from useq import MDASequence
+
+from pymmcore_widgets._stack_viewer_v2._mda_viewer import MDAViewer
+
+configure_logging(stderr_level="WARNING")
+
+mmcore = CMMCorePlus.instance()
+mmcore.loadSystemConfiguration()
+mmcore.defineConfig("Channel", "DAPI", "Camera", "Mode", "Artificial Waves")
+mmcore.defineConfig("Channel", "DAPI", "Camera", "StripeWidth", "1")
+mmcore.defineConfig("Channel", "FITC", "Camera", "Mode", "Artificial Waves")
+mmcore.defineConfig("Channel", "FITC", "Camera", "StripeWidth", "4")
+
+sequence = MDASequence(
+    channels=({"config": "DAPI", "exposure": 1}, {"config": "FITC", "exposure": 1}),
+    stage_positions=[(0, 0), (1, 1)],
+    z_plan={"range": 9, "step": 0.4},
+    time_plan={"interval": 0.2, "loops": 4},
+    # grid_plan={"rows": 2, "columns": 1},
+)
+
+
+qapp = QtWidgets.QApplication([])
+v = MDAViewer()
+v.show()
+
+mmcore.run_mda(sequence, output=v.data)
+qapp.exec()

examples/mda_viewer_queue.py

@@ -0,0 +1,24 @@
+import sys
+from queue import Queue
+
+from pymmcore_plus import CMMCorePlus
+from qtpy import QtWidgets
+from useq import MDAEvent
+
+from pymmcore_widgets._stack_viewer_v2._mda_viewer import MDAViewer
+
+app = QtWidgets.QApplication(sys.argv)
+mmcore = CMMCorePlus.instance()
+mmcore.loadSystemConfiguration()
+
+canvas = MDAViewer()
+canvas.show()
+
+q = Queue()
+mmcore.run_mda(iter(q.get, None), output=canvas.data)
+for i in range(10):
+    for c in range(2):
+        q.put(MDAEvent(index={"t": i, "c": c}, exposure=1))
+q.put(None)
+
+app.exec()

examples/stack_viewer/dask_arr.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import numpy as np
+from dask.array.core import map_blocks
+from qtpy import QtWidgets
+
+from pymmcore_widgets._stack_viewer_v2 import StackViewer
+
+frame_size = (1024, 1024)
+
+
+def _dask_block(block_id: tuple[int, int, int, int, int]) -> np.ndarray | None:
+    if isinstance(block_id, np.ndarray):
+        return None
+    data = np.random.randint(0, 255, size=frame_size, dtype=np.uint8)
+    return data[(None,) * 3]
+
+
+chunks = [(1,) * x for x in (1000, 64, 3)]
+chunks += [(x,) for x in frame_size]
+dask_arr = map_blocks(_dask_block, chunks=chunks, dtype=np.uint8)
+
+if __name__ == "__main__":
+    qapp = QtWidgets.QApplication([])
+    v = StackViewer(dask_arr)
+    v.show()
+    qapp.exec()

examples/stack_viewer/jax_arr.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import jax.numpy as jnp
+from numpy_arr import generate_5d_sine_wave
+from qtpy import QtWidgets
+
+from pymmcore_widgets._stack_viewer_v2._stack_viewer import StackViewer
+
+# Example usage
+array_shape = (10, 3, 5, 512, 512)  # Specify the desired dimensions
+sine_wave_5d = jnp.asarray(generate_5d_sine_wave(array_shape))
+
+if __name__ == "__main__":
+    qapp = QtWidgets.QApplication([])
+    v = StackViewer(sine_wave_5d, channel_axis=1)
+    v.show()
+    qapp.exec()

examples/stack_viewer/numpy_arr.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import numpy as np
+from qtpy import QtWidgets
+
+from pymmcore_widgets._stack_viewer_v2._stack_viewer import StackViewer
+
+
+def generate_5d_sine_wave(
+    shape: tuple[int, int, int, int, int],
+    amplitude: float = 240,
+    base_frequency: float = 5,
+) -> np.ndarray:
+    """5D dataset."""
+    # Unpack the dimensions
+    angle_dim, freq_dim, phase_dim, ny, nx = shape
+
+    # Create an empty array to hold the data
+    output = np.zeros(shape)
+
+    # Define spatial coordinates for the last two dimensions
+    half_per = base_frequency * np.pi
+    x = np.linspace(-half_per, half_per, nx)
+    y = np.linspace(-half_per, half_per, ny)
+    y, x = np.meshgrid(y, x)
+
+    # Iterate through each parameter in the higher dimensions
+    for phase_idx in range(phase_dim):
+        for freq_idx in range(freq_dim):
+            for angle_idx in range(angle_dim):
+                # Calculate phase and frequency
+                phase = np.pi / phase_dim * phase_idx
+                frequency = 1 + (freq_idx * 0.1)  # Increasing frequency with each step
+
+                # Calculate angle
+                angle = np.pi / angle_dim * angle_idx
+                # Rotate x and y coordinates
+                xr = np.cos(angle) * x - np.sin(angle) * y
+                np.sin(angle) * x + np.cos(angle) * y
+
+                # Compute the sine wave
+                sine_wave = (amplitude * 0.5) * np.sin(frequency * xr + phase)
+                sine_wave += amplitude * 0.5
+
+                # Assign to the output array
+                output[angle_idx, freq_idx, phase_idx] = sine_wave
+
+    return output
+
+
+try:
+    from skimage import data
+
+    img = data.cells3d()
+except Exception:
+    img = generate_5d_sine_wave((10, 3, 8, 512, 512))
+
+
+if __name__ == "__main__":
+    qapp = QtWidgets.QApplication([])
+    v = StackViewer(img)
+    v.show()
+    qapp.exec()

examples/stack_viewer/tensorstore_arr.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import numpy as np
+import tensorstore as ts
+from qtpy import QtWidgets
+
+from pymmcore_widgets._stack_viewer_v2 import StackViewer
+
+shape = (10, 4, 3, 512, 512)
+ts_array = ts.open(
+    {"driver": "zarr", "kvstore": {"driver": "memory"}},
+    create=True,
+    shape=shape,
+    dtype=ts.uint8,
+).result()
+ts_array[:] = np.random.randint(0, 255, size=shape, dtype=np.uint8)
+ts_array = ts_array[ts.d[:].label["t", "c", "z", "y", "x"]]
+
+if __name__ == "__main__":
+    qapp = QtWidgets.QApplication([])
+    v = StackViewer(ts_array)
+    v.show()
+    qapp.exec()

examples/stack_viewer/xarray_arr.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import xarray as xr
+from qtpy import QtWidgets
+
+from pymmcore_widgets._stack_viewer_v2 import StackViewer
+
+da = xr.tutorial.open_dataset("air_temperature").air
+
+if __name__ == "__main__":
+    qapp = QtWidgets.QApplication([])
+    v = StackViewer(da, colormaps=["thermal"], channel_mode="composite")
+    v.show()
+    qapp.exec()

examples/stack_viewer/zarr_arr.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import zarr
+import zarr.storage
+from qtpy import QtWidgets
+
+from pymmcore_widgets._stack_viewer_v2 import StackViewer
+
+URL = "https://s3.embl.de/i2k-2020/ngff-example-data/v0.4/tczyx.ome.zarr"
+zarr_arr = zarr.open(URL, mode="r")
+
+if __name__ == "__main__":
+    qapp = QtWidgets.QApplication([])
+    v = StackViewer(zarr_arr["s0"])
+    v.show()
+    qapp.exec()

examples/stack_viewer.py → examples/stack_viewer_v1.py

@@ -6,7 +6,7 @@
 from qtpy import QtWidgets
 from useq import MDASequence
 
-from pymmcore_widgets.experimental import StackViewer
+from pymmcore_widgets._stack_viewer_v1 import StackViewer
 
 size = 1028
 
@@ -20,7 +20,7 @@
 
 sequence = MDASequence(
     channels=(
-        # {"config": "DAPI", "exposure": 10},
+        {"config": "DAPI", "exposure": 10},
         # {"config": "FITC", "exposure": 1},
         {"config": "Cy5", "exposure": 1},
     ),

pyproject.toml

@@ -48,16 +48,24 @@ classifiers = [
 dynamic = ["version"]
 dependencies = [
     'fonticon-materialdesignicons6',
-    'pymmcore-plus[cli] >=0.9.0',
+    'pymmcore-plus[cli] >=0.9.5',
     'qtpy >=2.0',
-    'superqt[quantity] >=0.5.3',
+    'superqt[quantity] >=0.6.5',
     'useq-schema >=0.4.7',
 ]
 
 # extras
 # https://peps.python.org/pep-0621/#dependencies-optional-dependencies
 [project.optional-dependencies]
-test = ["pytest>=6.0", "pytest-cov", "pytest-qt", "PyYAML", "vispy", "cmap", "zarr"]
+test = [
+    "pytest>=6.0",
+    "pytest-cov",
+    "pytest-qt",
+    "PyYAML",
+    "vispy",
+    "cmap",
+    "zarr",
+]
 pyqt5 = ["PyQt5"]
 pyside2 = ["PySide2"]
 pyqt6 = ["PyQt6"]
@@ -127,6 +135,7 @@ docstring-code-format = true
 
 # https://docs.pytest.org/en/6.2.x/customize.html
 [tool.pytest.ini_options]
+markers = ["allow_leaks"]
 minversion = "6.0"
 testpaths = ["tests"]
 filterwarnings = [
@@ -174,4 +183,4 @@ ignore = [
 ]
 
 [tool.typos.default]
-extend-ignore-identifiers-re = ["(?i)ome"]
+extend-ignore-identifiers-re = ["(?i)nd2?.*", "(?i)ome"]

src/pymmcore_widgets/_stack_viewer/_stack_viewer.py → src/pymmcore_widgets/_stack_viewer_v1/_stack_viewer.py

@@ -464,11 +464,9 @@ def _reload_position(self) -> None:
         self.cmap_names = self.qt_settings.value("cmaps", ["gray", "cyan", "magenta"])
 
     def _collapse_view(self) -> None:
+        w, h = self.img_size
         view_rect = (
-            (
-                self.view_rect[0][0] - self.img_size[0] / 2,
-                self.view_rect[0][1] + self.img_size[1] / 2,
-            ),
+            (self.view_rect[0][0] - w / 2, self.view_rect[0][1] + h / 2),
             self.view_rect[1],
         )
         self.view.camera.rect = view_rect

src/pymmcore_widgets/_stack_viewer_v2/__init__.py

@@ -0,0 +1,4 @@
+from ._mda_viewer import MDAViewer
+from ._stack_viewer import StackViewer
+
+__all__ = ["StackViewer", "MDAViewer"]

src/pymmcore_widgets/_stack_viewer_v2/_backends/__init__.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import os
+import sys
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pymmcore_widgets._stack_viewer_v2._protocols import PCanvas
+
+
+def get_canvas(backend: str | None = None) -> type[PCanvas]:
+    backend = backend or os.getenv("CANVAS_BACKEND", None)
+    if backend == "vispy" or (backend is None and "vispy" in sys.modules):
+        from ._vispy import VispyViewerCanvas
+
+        return VispyViewerCanvas
+
+    if backend == "pygfx" or (backend is None and "pygfx" in sys.modules):
+        from ._pygfx import PyGFXViewerCanvas
+
+        return PyGFXViewerCanvas
+
+    if backend is None:
+        if importlib.util.find_spec("vispy") is not None:
+            from ._vispy import VispyViewerCanvas
+
+            return VispyViewerCanvas
+
+        if importlib.util.find_spec("pygfx") is not None:
+            from ._pygfx import PyGFXViewerCanvas
+
+            return PyGFXViewerCanvas
+
+    raise RuntimeError("No canvas backend found")