ndv.v1 #

def guess_channel_axis(self) -> Any | None:
    """Return the (best guess) axis name for the channel dimension."""
    # for arrays with labeled dimensions,
    # see if any of the dimensions are named "channel"
    for dimkey, val in self.sizes().items():
        if str(dimkey).lower() in self.COMMON_CHANNEL_NAMES:
            if val <= self.MAX_CHANNELS:
                return dimkey

    # for shaped arrays, use the smallest dimension as the channel axis
    shape = getattr(self._data, "shape", None)
    if isinstance(shape, Sequence):
        with suppress(ValueError):
            smallest_dim = min(shape)
            if smallest_dim <= self.MAX_CHANNELS:
                return shape.index(smallest_dim)
    return None

@abstractmethod
def isel(self, indexers: Indices) -> np.ndarray:
    """Select a slice from a data store using (possibly) named indices.

    This follows the xarray-style indexing, where indexers is a mapping of
    dimension names to indices or slices.  Subclasses should implement this
    method to return a numpy array.
    """
    raise NotImplementedError

def isel_async(
    self, indexers: list[Indices]
) -> Future[Iterable[tuple[Indices, np.ndarray]]]:
    """Asynchronous version of isel."""
    return _EXECUTOR.submit(lambda: [(idx, self.isel(idx)) for idx in indexers])

def sizes(self) -> Sizes:
    """Return a mapping of {dimkey: size} for the data.

    The default implementation uses the shape attribute of the data, and
    tries to find dimension names in the `dims`, `names`, or `labels` attributes.
    (`dims` is used by xarray, `names` is used by torch, etc...). If no labels
    are found, the dimensions are just named by their integer index.
    """
    shape = getattr(self._data, "shape", None)
    if not isinstance(shape, Sequence) or not all(
        isinstance(x, int) for x in shape
    ):
        raise NotImplementedError(f"Cannot determine sizes for {type(self._data)}")
    dims = range(len(shape))
    return {dim: int(size) for dim, size in zip(dims, shape)}

def summary_info(self) -> str:
    """Return info label with information about the data."""
    package = getattr(self._data, "__module__", "").split(".")[0]
    info = f"{package}.{getattr(type(self._data), '__qualname__', '')}"

    if sizes := self.sizes():
        # if all of the dimension keys are just integers, omit them from size_str
        if all(isinstance(x, int) for x in sizes):
            size_str = repr(tuple(sizes.values()))
        # otherwise, include the keys in the size_str
        else:
            size_str = ", ".join(f"{k}:{v}" for k, v in sizes.items())
            size_str = f"({size_str})"
        info += f" {size_str}"
    if dtype := getattr(self._data, "dtype", ""):
        info += f", {dtype}"
    if nbytes := getattr(self._data, "nbytes", 0) / 1e6:
        info += f", {nbytes:.2f}MB"
    return info

@classmethod
@abstractmethod
def supports(cls, obj: Any) -> bool:
    """Return True if this wrapper can handle the given object.

    Any exceptions raised by this method will be suppressed, so it is safe to
    directly import necessary dependencies without a try/except block.
    """
    raise NotImplementedError

def eventFilter(self, obj: QObject | None, event: QEvent | None) -> bool:
    """Event filter installed on the canvas to handle mouse events."""
    if event is None:
        return False  # pragma: no cover

    # here is where we get a chance to intercept mouse events before passing them
    # to the canvas. Return `True` to prevent the event from being passed to
    # the backend widget.
    intercept = False
    # use children in case backend has a subwidget stealing events.
    if obj is self._qcanvas or obj in (self._qcanvas.children()):
        if isinstance(event, QMouseEvent):
            intercept |= self._canvas_mouse_event(event)
        if event.type() == QEvent.Type.KeyPress:
            self.keyPressEvent(cast("QKeyEvent", event))
    return intercept

def refresh(self) -> None:
    """Refresh the canvas."""
    self._clear_images()
    self._update_data_for_index(self._dims_sliders.value())

def set_channel_mode(self, mode: ChannelMode | str | None = None) -> None:
    """Set the mode for displaying the channels.

    In "composite" mode, the channels are displayed as a composite image, using
    self._channel_axis as the channel axis. In "grayscale" mode, each channel is
    displayed separately. (If mode is None, the current value of the
    channel_mode_picker button is used)

    Parameters
    ----------
    mode : ChannelMode | str | None
        The mode to set, must be one of 'composite' or 'mono'.
    """
    # bool may happen when called from the button clicked signal
    if mode is None or isinstance(mode, bool):
        mode = self._channel_mode_btn.mode()
    else:
        mode = ChannelMode(mode)
        self._channel_mode_btn.setMode(mode)
    if mode == self._channel_mode:
        return

    self._channel_mode = mode
    self._cmap_cycle = cycle(self._cmaps)  # reset the colormap cycle
    if self._channel_axis is not None:
        # set the visibility of the channel slider
        self._dims_sliders.set_dimension_visible(
            self._channel_axis, mode != ChannelMode.COMPOSITE
        )

    self.refresh()

def set_current_index(self, index: Indices | None = None) -> None:
    """Set the index of the displayed image.

    `index` is a mapping of dimensions to integers or slices that define the slice
    of the data to display.  For example, a numpy slice of `[0, 1, 5:10]` would be
    represented as `{0: 0, 1: 1, 2: slice(5, 10)}`, but dimensions can also be
    named, e.g. `{'t': 0, 'c': 1, 'z': slice(5, 10)}` if the data has named
    dimensions.

    Note, calling `.set_current_index()` with no arguments will force the widget
    to redraw the current slice.
    """
    self._dims_sliders.setValue(index or {})

def set_data(
    self, data: DataWrapper | Any, *, initial_index: Indices | None = None
) -> None:
    """Set the datastore, and, optionally, the sizes of the data.

    Properties
    ----------
    data : DataWrapper | Any
        The data to display.  This can be any duck-like ND array, including numpy,
        dask, xarray, jax, tensorstore, zarr, etc.  You can add support for new
        datastores by subclassing `DataWrapper` and implementing the required
        methods. If a `DataWrapper` instance is passed, it is used directly.
        See `DataWrapper` for more information.
    initial_index : Indices | None
        The initial index to display.  This is a mapping of dimensions to integers
        or slices that define the slice of the data to display.  If not provided,
        the initial index will be set to the middle of the data.
    """
    # clear current data
    if data is None:
        self._data_wrapper = None
        self._clear_images()
        self._dims_sliders.clear()
        self._data_info_label.setText("")
        return

    # store the data
    self._data_wrapper = DataWrapper.create(data)

    # set channel axis
    self._channel_axis = self._data_wrapper.guess_channel_axis()

    # update the dimensions we are visualizing
    sizes = self._data_wrapper.sizes()
    visualized_dims = list(sizes)[-self._ndims :]
    self.set_visualized_dims(visualized_dims)

    # update the range of all the sliders to match the sizes we set above
    with signals_blocked(self._dims_sliders):
        self._update_slider_ranges()

    # redraw
    if initial_index is None:
        idx = self._dims_sliders.value() or {
            k: int(v // 2) for k, v in sizes.items()
        }
    else:
        if not isinstance(initial_index, dict):  # pragma: no cover
            raise TypeError("initial_index must be a dict")
        idx = initial_index
    with signals_blocked(self._dims_sliders):
        self.set_current_index(idx)
    # update the data info label
    self._data_info_label.setText(self._data_wrapper.summary_info())
    self.refresh()

def set_ndim(self, ndim: Literal[2, 3]) -> None:
    """Set the number of dimensions to display."""
    if ndim not in (2, 3):
        raise ValueError("ndim must be 2 or 3")

    self._ndims = ndim
    self._canvas.set_ndim(ndim)

    if self._data_wrapper is None:
        return

    # set the visibility of the last non-channel dimension
    sizes = list(self._data_wrapper.sizes())
    if self._channel_axis is not None:
        sizes = [x for x in sizes if x != self._channel_axis]
    if len(sizes) >= 3:
        dim3 = sizes[-3]
        self._dims_sliders.set_dimension_visible(dim3, True if ndim == 2 else False)

    # clear image handles and redraw
    self.refresh()

def set_roi(
    self,
    vertices: list[tuple[float, float]] | None = None,
    color: Any = None,
    border_color: Any = None,
) -> None:
    """Set the properties of the ROI overlaid on the displayed data.

    Properties
    ----------
    vertices : list[tuple[float, float]] | None
        The vertices of the ROI.
    color : str, tuple, list, array, Color, or int
        The fill color.  Can be any "ColorLike".
    border_color : str, tuple, list, array, Color, or int
        The border color.  Can be any "ColorLike".
    """
    # Remove the old ROI
    if self._roi:
        self._roi.remove()
    color = cmap.Color(color) if color is not None else None
    border_color = cmap.Color(border_color) if border_color is not None else None
    self._roi = self._canvas.add_roi(
        vertices=vertices, color=color, border_color=border_color
    )

def set_visualized_dims(self, dims: Iterable[DimKey]) -> None:
    """Set the dimensions that will be visualized.

    This dims will NOT have sliders associated with them.
    """
    self._visualized_dims = set(dims)
    for d in self._dims_sliders._sliders:
        self._dims_sliders.set_dimension_visible(d, d not in self._visualized_dims)
    for d in self._visualized_dims:
        self._dims_sliders.set_dimension_visible(d, False)