tessl/pypi-napari
n-dimensional array viewer in Python with fast, interactive multi-dimensional image visualization
—
Pending
components.mddocs/
Components
Napari components are the core functional elements that manage viewer state, coordinate layer interactions, and control the visualization experience. These components handle dimensional navigation, camera positioning, layer management, and the overall viewer model.
Capabilities
Dimension Management
Controls dimensional navigation, slicing, and display parameters for multi-dimensional data visualization.
class Dims:
"""
Manages dimension indices, display order, and navigation for multi-dimensional data.
Controls which dimensions are displayed, sliced, or projected.
"""
@property
def ndim(self) -> int:
"""Total number of dimensions across all layers."""
@property
def ndisplay(self) -> int:
"""Number of displayed dimensions (2 or 3)."""
@property
def current_step(self) -> tuple:
"""Current position along each dimension."""
@property
def order(self) -> tuple:
"""Order of dimension display."""
@property
def axis_labels(self) -> list:
"""Labels for each dimension axis."""
def set_current_step(self, axis: int, value: int):
"""
Set the current step along a specific axis.
Parameters:
- axis: Dimension axis index
- value: Step value to set
"""
def set_range(self, axis: int, range_: tuple):
"""
Set the range of values for a dimension.
Parameters:
- axis: Dimension axis index
- range_: (min, max) range tuple
"""Camera Control
Manages the camera/view parameters including position, zoom, rotation, and perspective settings for 2D and 3D visualization.
class Camera:
"""
Controls camera position, zoom, rotation, and perspective for viewer display.
Handles both 2D and 3D viewing parameters.
"""
@property
def center(self) -> tuple:
"""Camera center position in data coordinates."""
@property
def zoom(self) -> float:
"""Current zoom level."""
@property
def angles(self) -> tuple:
"""Camera rotation angles (for 3D viewing)."""
@property
def perspective(self) -> float:
"""Perspective projection strength (0=orthographic, >0=perspective)."""
def set_center(self, center: tuple):
"""
Set camera center position.
Parameters:
- center: (y, x) or (z, y, x) center coordinates
"""
def set_zoom(self, zoom: float):
"""
Set camera zoom level.
Parameters:
- zoom: Zoom factor (1.0 = fit to window)
"""
def set_angles(self, angles: tuple):
"""
Set camera rotation angles for 3D viewing.
Parameters:
- angles: (x_angle, y_angle, z_angle) in degrees
"""Layer Management
Container and management system for all layers in the viewer, providing list-like interface with layer-specific functionality.
class LayerList:
"""
Container for managing layers in the viewer.
Provides list-like interface with layer-specific operations.
"""
def __len__(self) -> int:
"""Number of layers in the list."""
def __iter__(self):
"""Iterate over layers."""
def __getitem__(self, key):
"""Get layer by index or name."""
def append(self, layer):
"""
Add a layer to the end of the list.
Parameters:
- layer: Layer object to add
"""
def insert(self, index: int, layer):
"""
Insert a layer at a specific position.
Parameters:
- index: Position to insert at
- layer: Layer object to insert
"""
def remove(self, layer):
"""
Remove a layer from the list.
Parameters:
- layer: Layer object to remove
"""
def clear(self):
"""Remove all layers from the list."""
def move(self, src_index: int, dest_index: int):
"""
Move layer from one position to another.
Parameters:
- src_index: Source position
- dest_index: Destination position
"""
@property
def selection(self):
"""Currently selected layers."""Viewer Model
Core data model that coordinates all viewer components and manages the overall state of the napari viewer.
class ViewerModel:
"""
Core viewer data model that coordinates layers, dimensions, camera, and other components.
Serves as the central state manager for napari viewers.
"""
def __init__(
self,
*,
title: str = 'napari',
ndisplay: int = 2,
order: tuple = (),
axis_labels: tuple = ()
):
"""
Initialize the viewer model.
Parameters:
- title: Viewer window title
- ndisplay: Number of displayed dimensions (2 or 3)
- order: Dimension display order
- axis_labels: Labels for dimension axes
"""
@property
def layers(self) -> LayerList:
"""LayerList containing all viewer layers."""
@property
def dims(self) -> Dims:
"""Dims object managing dimensional navigation."""
@property
def camera(self) -> Camera:
"""Camera object controlling view parameters."""
@property
def title(self) -> str:
"""Viewer window title."""
@property
def cursor(self) -> dict:
"""Current cursor state and information."""
@property
def help(self) -> str:
"""Help text for current viewer state."""
def reset_view(self):
"""Reset camera to fit all layer data."""
def screenshot(self, path: str = None, **kwargs):
"""
Take a screenshot of the viewer.
Parameters:
- path: File path to save screenshot
- kwargs: Additional screenshot parameters
Returns:
Array or path: Screenshot data or saved file path
"""Usage Examples
Working with Dimensions
import napari
import numpy as np
# Create 4D data (time, z, y, x)
data_4d = np.random.random((10, 20, 100, 100))
viewer = napari.Viewer()
viewer.add_image(data_4d, name='4D Data')
# Access dimensions component
dims = viewer.dims
# Navigate through time dimension (axis 0)
dims.set_current_step(0, 5) # Go to time point 5
# Set custom axis labels
dims.axis_labels = ['time', 'z', 'y', 'x']
print(f"Current position: {dims.current_step}")
print(f"Total dimensions: {dims.ndim}")Camera Control
import napari
import numpy as np
data = np.random.random((100, 100, 100)) # 3D data
viewer = napari.Viewer(ndisplay=3) # 3D viewer
viewer.add_image(data, name='3D Volume')
# Access camera
camera = viewer.camera
# Set camera position
camera.set_center((50, 50, 50))
camera.set_zoom(2.0)
# For 3D viewing, set rotation angles
camera.set_angles((30, 45, 0)) # Rotate for better 3D view
print(f"Camera center: {camera.center}")
print(f"Zoom level: {camera.zoom}")Layer Management
import napari
import numpy as np
viewer = napari.Viewer()
# Add multiple layers
image1 = np.random.random((100, 100))
image2 = np.random.random((100, 100))
points_data = np.random.random((50, 2)) * 100
viewer.add_image(image1, name='Background')
viewer.add_image(image2, name='Overlay', opacity=0.5)
viewer.add_points(points_data, name='Points')
# Access layer list
layers = viewer.layers
print(f"Number of layers: {len(layers)}")
# Access layers by index or name
first_layer = layers[0]
points_layer = layers['Points']
# Reorder layers (move points to bottom)
layers.move(2, 0) # Move from index 2 to index 0
# Remove a layer
layers.remove(layers['Overlay'])Viewer Model Integration
import napari
import numpy as np
# Create viewer with custom settings
viewer = napari.Viewer(
title='My Analysis',
ndisplay=2,
axis_labels=['Y', 'X']
)
# Add data
data = np.random.random((100, 100))
viewer.add_image(data, name='Sample Data')
# Access viewer model properties
print(f"Title: {viewer.title}")
print(f"Number of layers: {len(viewer.layers)}")
print(f"Current dimensions: {viewer.dims.current_step}")
# Reset view to fit all data
viewer.reset_view()
# Take screenshot
screenshot = viewer.screenshot()
print(f"Screenshot shape: {screenshot.shape}")Coordinated Component Usage
import napari
import numpy as np
# Create time-lapse 3D data
data_5d = np.random.random((5, 10, 50, 50, 3)) # (t, z, y, x, c)
viewer = napari.Viewer(
title='Time-lapse Analysis',
ndisplay=2,
axis_labels=['time', 'z', 'y', 'x', 'channel']
)
# Add as RGB image
viewer.add_image(data_5d, rgb=True, name='Time-lapse')
# Coordinate all components
# Set time point
viewer.dims.set_current_step(0, 2) # Time point 2
# Set z-slice
viewer.dims.set_current_step(1, 5) # Z-slice 5
# Center camera on region of interest
viewer.camera.set_center((25, 25))
viewer.camera.set_zoom(2.0)
# Add annotation layer at current time/z position
points = np.array([[20, 20], [30, 30]])
viewer.add_points(points, name='Annotations', size=10)
napari.run()Install with Tessl CLI
npx tessl i tessl/pypi-napari