feat: return 3d support to v2

examples/notebook.ipynb

@@ -2,13 +2,13 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f2fe7ce4f36847ffaba8c042bf85b76d",
+       "model_id": "f93b58f35c5e44dc9f115d43f8a9b1a8",
        "version_major": 2,
        "version_minor": 0
       },
@@ -22,7 +22,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "92985e7df82f47cabfe3ab5ce9ab0498",
+       "model_id": "6c134f66cf2b4a2e883fc41f76eda14d",
        "version_major": 2,
        "version_minor": 0
       },
@@ -38,8 +38,8 @@
     "from ndv import data, imshow\n",
     "\n",
     "viewer = imshow(data.cells3d())\n",
-    "viewer.model.channel_mode = \"composite\"\n",
-    "viewer.model.current_index.update({0: 32})"
+    "viewer.display_model.channel_mode = \"composite\"\n",
+    "viewer.display_model.current_index.update({0: 32})"
    ]
   },
   {

src/ndv/controllers/_array_viewer.py

@@ -63,6 +63,9 @@ def __init__(
                 "When display_model is provided, kwargs are be ignored.",
                 stacklevel=2,
             )
+        self._data_model = _ArrayDataDisplayModel(
+            data_wrapper=data, display=display_model or ArrayDisplayModel(**kwargs)
+        )
 
         # mapping of channel keys to their respective controllers
         # where None is the default channel
@@ -74,15 +77,11 @@ def __init__(
         self._canvas = canvas_cls()
 
         self._histogram: HistogramCanvas | None = None
-        self._view = frontend_cls(self._canvas.frontend_widget())
+        self._view = frontend_cls(self._canvas.frontend_widget(), self._data_model)
 
-        display_model = display_model or ArrayDisplayModel(**kwargs)
-        self._data_model = _ArrayDataDisplayModel(
-            data_wrapper=data, display=display_model
-        )
         self._set_model_connected(self._data_model.display)
         self._canvas.set_ndim(self.display_model.n_visible_axes)
-        self._view.set_visible_axes(self.display_model.visible_axes)
+        self._view.set_visible_axes(self._data_model.normed_visible_axes)
 
         self._view.currentIndexChanged.connect(self._on_view_current_index_changed)
         self._view.resetZoomClicked.connect(self._on_view_reset_zoom_clicked)
@@ -245,7 +244,7 @@ def _fully_synchronize_view(self) -> None:
             self._update_hist_domain_for_dtype()
 
     def _on_model_visible_axes_changed(self) -> None:
-        self._view.set_visible_axes(self.display_model.visible_axes)
+        self._view.set_visible_axes(self._data_model.normed_visible_axes)
         self._update_visible_sliders()
         self._clear_canvas()
         self._update_canvas()

src/ndv/models/_data_display_model.py

@@ -40,6 +40,8 @@ def __post_init__(self) -> None:
         self.dtype = self.data.dtype
 
 
+# NOTE: nobody particularly likes this class.  It does important stuff, but we're
+# not yet sure where this logic belongs.
 class _ArrayDataDisplayModel(NDVModel):
     """Utility class combining ArrayDisplayModel model with a DataWrapper.
 

src/ndv/models/data_wrappers/_data_wrapper.py

@@ -71,6 +71,8 @@ class DataWrapper(Generic[ArrayT], ABC):
     PRIORITY: ClassVar[int] = 50
     # These names will be checked when looking for a channel axis
     COMMON_CHANNEL_NAMES: ClassVar[Container[str]] = ("channel", "ch", "c")
+    COMMON_Z_AXIS_NAMES: ClassVar[Container[str]] = ("z", "depth", "focus")
+
     # Maximum dimension size consider when guessing the channel axis
     MAX_CHANNELS = 16
 
@@ -172,6 +174,22 @@ def guess_channel_axis(self) -> Hashable | None:
         # otherwise use the smallest dimension as the channel axis
         return min(sizes, key=sizes.get)  # type: ignore [arg-type]
 
+    def guess_z_axis(self) -> Hashable | None:
+        """Return the (best guess) axis name for the z (3rd spatial) dimension."""
+        sizes = self.sizes()
+        ch = self.guess_channel_axis()
+        for dimkey in sizes:
+            if str(dimkey).lower() in self.COMMON_Z_AXIS_NAMES:
+                if (normed := self.normalized_axis_key(dimkey)) != ch:
+                    return normed
+
+        # otherwise return the LAST axis that is neither in the last two dimensions
+        # or the channel axis guess
+        return next(
+            (self.normalized_axis_key(x) for x in reversed(self.dims[:-2]) if x != ch),
+            None,
+        )
+
     def summary_info(self) -> str:
         """Return info label with information about the data."""
         package = getattr(self._data, "__module__", "").split(".")[0]

src/ndv/views/_jupyter/_array_view.py

@@ -15,6 +15,7 @@
     from vispy.app.backends import _jupyter_rfb
 
     from ndv._types import AxisKey
+    from ndv.models._data_display_model import _ArrayDataDisplayModel
 
 # not entirely sure why it's necessary to specifically annotat signals as : PSignal
 # i think it has to do with type variance?
@@ -110,9 +111,12 @@ def frontend_widget(self) -> Any:
 
 class JupyterArrayView(ArrayView):
     def __init__(
-        self, canvas_widget: _jupyter_rfb.CanvasBackend, **kwargs: Any
+        self,
+        canvas_widget: _jupyter_rfb.CanvasBackend,
+        data_model: _ArrayDataDisplayModel,
     ) -> None:
         # WIDGETS
+        self._data_model = data_model
         self._canvas_widget = canvas_widget
         self._visible_axes: Sequence[AxisKey] = []
 
@@ -269,16 +273,22 @@ def set_visible_axes(self, axes: Sequence[AxisKey]) -> None:
         self._ndims_btn.value = len(axes) == 3
 
     def _on_ndims_toggled(self, change: dict[str, Any]) -> None:
-        was_3d = len(self._visible_axes) > 2
-        is_3d = change["new"]
-        if was_3d and not is_3d:
+        if len(self._visible_axes) > 2:
+            if change["new"]:  # no change
+                return
             self._visible_axes = self._visible_axes[-2:]
-        elif not was_3d and is_3d:
-            # FIXME
-            # HACCCCCKKK
-            # need a better way to add the next dimension in the GUI
-            new_ax = 0
-            self._visible_axes = (new_ax, *self._visible_axes)
+        else:
+            z_ax = None
+            if wrapper := self._data_model.data_wrapper:
+                z_ax = wrapper.guess_z_axis()
+            if z_ax is None:
+                # get the last slider that is not in visible axes
+                z_ax = next(
+                    ax for ax in reversed(self._sliders) if ax not in self._visible_axes
+                )
+            self._visible_axes = (z_ax, *self._visible_axes)
+        # TODO: a future PR may decide to set this on the model directly...
+        # since we now have access to it.
         self.visibleAxesChanged.emit()
 
     def close(self) -> None:

src/ndv/views/_qt/_array_view.py

@@ -30,6 +30,7 @@
     from qtpy.QtGui import QIcon
 
     from ndv._types import AxisKey
+    from ndv.models._data_display_model import _ArrayDataDisplayModel
 
 SLIDER_STYLE = """
 QSlider::groove:horizontal {
@@ -346,7 +347,10 @@ def __init__(self, canvas_widget: QWidget, parent: QWidget | None = None):
 
 
 class QtArrayView(ArrayView):
-    def __init__(self, canvas_widget: QWidget) -> None:
+    def __init__(
+        self, canvas_widget: QWidget, data_model: _ArrayDataDisplayModel
+    ) -> None:
+        self._data_model = data_model
         self._qwidget = qwdg = _QArrayViewer(canvas_widget)
         qwdg.histogram_btn.clicked.connect(self._on_add_histogram_clicked)
 
@@ -410,17 +414,22 @@ def set_current_index(self, value: Mapping[AxisKey, int | slice]) -> None:
         """Set the current value of the sliders."""
         self._qwidget.dims_sliders.set_current_index(value)
 
-    def _on_ndims_toggled(self, checked: bool) -> None:
-        was_3d = len(self._visible_axes) > 2
-        is_3d = checked
-        if was_3d and not is_3d:
+    def _on_ndims_toggled(self, is_3d: bool) -> None:
+        if len(self._visible_axes) > 2:
+            if is_3d:  # no change
+                return
             self._visible_axes = self._visible_axes[-2:]
-        elif not was_3d and is_3d:
-            # FIXME
-            # HACCCCCKKK
-            # need a better way to add the next dimension in the GUI
-            new_ax = 0
-            self._visible_axes = (new_ax, *self._visible_axes)
+        else:
+            z_ax = None
+            if wrapper := self._data_model.data_wrapper:
+                z_ax = wrapper.guess_z_axis()
+            if z_ax is None:
+                # get the last slider that is not in visible axes
+                sld = reversed(self._qwidget.dims_sliders._sliders)
+                z_ax = next(ax for ax in sld if ax not in self._visible_axes)
+            self._visible_axes = (z_ax, *self._visible_axes)
+        # TODO: a future PR may decide to set this on the model directly...
+        # since we now have access to it.
         self.visibleAxesChanged.emit()
 
     def visible_axes(self) -> Sequence[AxisKey]:

src/ndv/views/_wx/_array_view.py

@@ -19,6 +19,7 @@
     import cmap
 
     from ndv._types import AxisKey
+    from ndv.models._data_display_model import _ArrayDataDisplayModel
 
 
 # mostly copied from _qt.qt_view._QLUTWidget
@@ -91,6 +92,11 @@ def set_colormap(self, cmap: cmap.Colormap) -> None:
 
     def set_clims(self, clims: tuple[float, float]) -> None:
         self._wxwidget.clims.SetValue(*clims)
+        # FIXME: this is a hack.
+        # it's required to make `set_auto_scale_without_signal` work as intended
+        # But it's not a complete solution.  The general pattern of blocking signals
+        # in Wx needs to be re-evaluated.
+        wx.Yield()
 
     def set_channel_visible(self, visible: bool) -> None:
         self._wxwidget.visible.SetValue(visible)
@@ -194,41 +200,58 @@ def __init__(self, canvas_widget: wx.Window, parent: wx.Window = None):
 
         # Channel mode combo box
         self.channel_mode_combo = wx.ComboBox(
-            self, choices=[x.value for x in ChannelMode], style=wx.CB_DROPDOWN
+            self,
+            choices=[ChannelMode.GRAYSCALE.value, ChannelMode.COMPOSITE.value],
+            style=wx.CB_DROPDOWN,
         )
 
         # Reset zoom button
         self.reset_zoom_btn = wx.Button(self, label="Reset Zoom")
 
+        # Reset zoom button
+        self.ndims_btn = wx.ToggleButton(self, label="3D")
+
         # LUT layout (simple vertical grouping for LUT widgets)
         self.luts = wx.BoxSizer(wx.VERTICAL)
 
         btns = wx.BoxSizer(wx.HORIZONTAL)
-        btns.Add(self.channel_mode_combo, 0, wx.RIGHT, 5)
-        btns.Add(self.reset_zoom_btn, 0, wx.RIGHT, 5)
+        btns.AddStretchSpacer()
+        btns.Add(self.channel_mode_combo, 0, wx.ALL, 5)
+        btns.Add(self.reset_zoom_btn, 0, wx.ALL, 5)
+        btns.Add(self.ndims_btn, 0, wx.ALL, 5)
 
         # Layout for the panel
-        main_sizer = wx.BoxSizer(wx.VERTICAL)
-        main_sizer.Add(self._data_info_label, 0, wx.EXPAND | wx.BOTTOM, 5)
-        main_sizer.Add(self._canvas, 1, wx.EXPAND | wx.ALL, 5)
-        main_sizer.Add(self._hover_info_label, 0, wx.EXPAND | wx.BOTTOM, 5)
-        main_sizer.Add(self.dims_sliders, 0, wx.EXPAND | wx.BOTTOM, 5)
-        main_sizer.Add(self.luts, 0, wx.EXPAND, 5)
-        main_sizer.Add(btns, 0, wx.EXPAND, 5)
-
-        self.SetSizer(main_sizer)
+        inner = wx.BoxSizer(wx.VERTICAL)
+        inner.Add(self._data_info_label, 0, wx.EXPAND | wx.BOTTOM, 5)
+        inner.Add(self._canvas, 1, wx.EXPAND | wx.ALL)
+        inner.Add(self._hover_info_label, 0, wx.EXPAND | wx.BOTTOM)
+        inner.Add(self.dims_sliders, 0, wx.EXPAND | wx.BOTTOM)
+        inner.Add(self.luts, 0, wx.EXPAND)
+        inner.Add(btns, 0, wx.EXPAND)
+
+        outer = wx.BoxSizer(wx.VERTICAL)
+        outer.Add(inner, 1, wx.ALL, 10)
+        self.SetSizer(outer)
         self.SetInitialSize(wx.Size(600, 800))
         self.Layout()
 
 
 class WxArrayView(ArrayView):
-    def __init__(self, canvas_widget: wx.Window, parent: wx.Window = None) -> None:
+    def __init__(
+        self,
+        canvas_widget: wx.Window,
+        data_model: _ArrayDataDisplayModel,
+        parent: wx.Window = None,
+    ) -> None:
+        self._data_model = data_model
         self._wxwidget = wdg = _WxArrayViewer(canvas_widget, parent)
+        self._visible_axes: Sequence[AxisKey] = []
 
         # TODO: use emit_fast
         wdg.dims_sliders.currentIndexChanged.connect(self.currentIndexChanged.emit)
         wdg.channel_mode_combo.Bind(wx.EVT_COMBOBOX, self._on_channel_mode_changed)
         wdg.reset_zoom_btn.Bind(wx.EVT_BUTTON, self._on_reset_zoom_clicked)
+        wdg.ndims_btn.Bind(wx.EVT_TOGGLEBUTTON, self._on_ndims_toggled)
 
     def _on_channel_mode_changed(self, event: wx.CommandEvent) -> None:
         mode = self._wxwidget.channel_mode_combo.GetValue()
@@ -237,6 +260,32 @@ def _on_channel_mode_changed(self, event: wx.CommandEvent) -> None:
     def _on_reset_zoom_clicked(self, event: wx.CommandEvent) -> None:
         self.resetZoomClicked.emit()
 
+    def _on_ndims_toggled(self, event: wx.CommandEvent) -> None:
+        is_3d = self._wxwidget.ndims_btn.GetValue()
+        if len(self._visible_axes) > 2:
+            if is_3d:  # no change
+                return
+            self._visible_axes = self._visible_axes[-2:]
+        else:
+            z_ax = None
+            if wrapper := self._data_model.data_wrapper:
+                z_ax = wrapper.guess_z_axis()
+            if z_ax is None:
+                # get the last slider that is not in visible axes
+                sld = reversed(self._wxwidget.dims_sliders._sliders)
+                z_ax = next(ax for ax in sld if ax not in self._visible_axes)
+            self._visible_axes = (z_ax, *self._visible_axes)
+        # TODO: a future PR may decide to set this on the model directly...
+        # since we now have access to it.
+        self.visibleAxesChanged.emit()
+
+    def visible_axes(self) -> Sequence[AxisKey]:
+        return self._visible_axes  # no widget to control this yet
+
+    def set_visible_axes(self, axes: Sequence[AxisKey]) -> None:
+        self._visible_axes = tuple(axes)
+        self._wxwidget.ndims_btn.SetValue(len(axes) == 3)
+
     def frontend_widget(self) -> wx.Window:
         return self._wxwidget
 
@@ -283,11 +332,5 @@ def set_visible(self, visible: bool) -> None:
         else:
             self._wxwidget.Hide()
 
-    def set_visible_axes(self, axes: Sequence[AxisKey]) -> None:
-        pass
-
-    def visible_axes(self) -> Sequence[AxisKey]:
-        return []
-
     def close(self) -> None:
         self._wxwidget.Close()

src/ndv/views/bases/_array_view.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any
 
@@ -13,10 +13,11 @@
     from collections.abc import Container, Hashable, Mapping, Sequence
 
     from ndv._types import AxisKey
+    from ndv.models._data_display_model import _ArrayDataDisplayModel
     from ndv.views.bases import LutView
 
 
-class ArrayView(Viewable):
+class ArrayView(Viewable, ABC):
     """ABC for ND Array viewers widget.
 
     Currently, this is the "main" widget that contains the array display and
@@ -30,8 +31,11 @@ class ArrayView(Viewable):
     visibleAxesChanged = Signal()
     channelModeChanged = Signal(ChannelMode)
 
+    # model: _ArrayDataDisplayModel is likely a temporary parameter
     @abstractmethod
-    def __init__(self, canvas_widget: Any, **kwargs: Any) -> None: ...
+    def __init__(
+        self, canvas_widget: Any, model: _ArrayDataDisplayModel, **kwargs: Any
+    ) -> None: ...
     @abstractmethod
     def create_sliders(self, coords: Mapping[int, Sequence]) -> None: ...
     @abstractmethod