Source code for napari.viewer

import sys
import typing
from typing import TYPE_CHECKING, Optional
from weakref import WeakSet

import magicgui as mgui

from .components.viewer_model import ViewerModel
from .utils import _magicgui, config

    # helpful for IDE support
    from ._qt.qt_main_window import Window

[docs]@mgui.register_type(bind=_magicgui.proxy_viewer_ancestor) class Viewer(ViewerModel): """Napari ndarray viewer. Parameters ---------- title : string, optional The title of the viewer window. by default 'napari'. ndisplay : {2, 3}, optional Number of displayed dimensions. by default 2. order : tuple of int, optional Order in which dimensions are displayed where the last two or last three dimensions correspond to row x column or plane x row x column if ndisplay is 2 or 3. by default None axis_labels : list of str, optional Dimension names. by default they are labeled with sequential numbers show : bool, optional Whether to show the viewer after instantiation. by default True. """ _window: 'Window' = None # type: ignore if sys.version_info < (3, 9): _instances: typing.ClassVar[WeakSet] = WeakSet() else: _instances: typing.ClassVar[WeakSet['Viewer']] = WeakSet() def __init__( self, *, title='napari', ndisplay=2, order=(), axis_labels=(), show=True, ): super().__init__( title=title, ndisplay=ndisplay, order=order, axis_labels=axis_labels, ) # having this import here makes all of Qt imported lazily, upon # instantiating the first Viewer. from .window import Window self._window = Window(self, show=show) self._instances.add(self) # Expose private window publically. This is needed to keep window off pydantic model @property def window(self) -> 'Window': return self._window
[docs] def update_console(self, variables): """Update console's namespace with desired variables. Parameters ---------- variables : dict, str or list/tuple of str The variables to inject into the console's namespace. If a dict, a simple update is done. If a str, the string is assumed to have variable names separated by spaces. A list/tuple of str can also be used to give the variable names. If just the variable names are give (list/tuple/str) then the variable values looked up in the callers frame. """ if self.window._qt_viewer._console is None: return else: self.window._qt_viewer.console.push(variables)
[docs] def screenshot( self, path=None, *, size=None, scale=None, canvas_only=True, flash: bool = True, ): """Take currently displayed screen and convert to an image array. Parameters ---------- path : str Filename for saving screenshot image. size : tuple (int, int) Size (resolution) of the screenshot. By default, the currently displayed size. Only used if `canvas_only` is True. scale : float Scale factor used to increase resolution of canvas for the screenshot. By default, the currently displayed resolution. Only used if `canvas_only` is True. canvas_only : bool If True, screenshot shows only the image display canvas, and if False include the napari viewer frame in the screenshot, By default, True. flash : bool Flag to indicate whether flash animation should be shown after the screenshot was captured. By default, True. Returns ------- image : array Numpy array of type ubyte and shape (h, w, 4). Index [0, 0] is the upper-left corner of the rendered region. """ return self.window.screenshot( path=path, size=size, scale=scale, flash=flash, canvas_only=canvas_only, )
[docs] def show(self, *, block=False): """Resize, show, and raise the viewer window."""
[docs] def close(self): """Close the viewer window.""" # Remove all the layers from the viewer self.layers.clear() # Close the main window self.window.close() if config.async_loading: from .components.experimental.chunk import chunk_loader # TODO_ASYNC: Find a cleaner way to do this? This fixes some # tests. We are telling the ChunkLoader that this layer is # going away: # for layer in self.layers: chunk_loader.on_layer_deleted(layer) self._instances.discard(self)
[docs] @classmethod def close_all(cls) -> int: """ Class metod, Close all existing viewer instances. This is mostly exposed to avoid leaking of viewers when running tests. As having many non-closed viewer can adversely affect performances. It will return the number of viewer closed. Returns ------- int number of viewer closed. """ # copy to not iterate while changing. viewers = [v for v in cls._instances] ret = len(viewers) for viewer in viewers: viewer.close() return ret
[docs]def current_viewer() -> Optional[Viewer]: """Return the currently active napari viewer.""" try: from napari._qt.qt_main_window import _QtMainWindow return _QtMainWindow.current_viewer() except ImportError: return None