napari.layers.Shapes#
- class napari.layers.Shapes(data=None, *, ndim=None, features=None, feature_defaults=None, properties=None, property_choices=None, text=None, shape_type='rectangle', edge_width=1, edge_color='#777777', edge_color_cycle=None, edge_colormap='viridis', edge_contrast_limits=None, face_color='white', face_color_cycle=None, face_colormap='viridis', face_contrast_limits=None, z_index=0, name=None, metadata=None, scale=None, translate=None, rotate=None, shear=None, affine=None, opacity=0.7, blending='translucent', visible=True, cache=True, experimental_clipping_planes=None)[source]#
Bases:
Layer
Shapes layer.
- Parameters:
data (list or array) – List of shape data, where each element is an (N, D) array of the N vertices of a shape in D dimensions. Can be an 3-dimensional array if each shape has the same number of vertices.
ndim (int) – Number of dimensions for shapes. When data is not None, ndim must be D. An empty shapes layer can be instantiated with arbitrary ndim.
features (dict[str, array-like] or Dataframe-like) – Features table where each row corresponds to a shape and each column is a feature.
feature_defaults (dict[str, Any] or Dataframe-like) – The default value of each feature in a table with one row.
properties (dict {str: array (N,)}, DataFrame) – Properties for each shape. Each property should be an array of length N, where N is the number of shapes.
property_choices (dict {str: array (N,)}) – possible values for each property.
text (str, dict) – Text to be displayed with the shapes. If text is set to a key in properties, the value of that property will be displayed. Multiple properties can be composed using f-string-like syntax (e.g., ‘{property_1}, {float_property:.2f}). A dictionary can be provided with keyword arguments to set the text values and display properties. See TextManager.__init__() for the valid keyword arguments. For example usage, see /napari/examples/add_shapes_with_text.py.
shape_type (string or list) – String of shape shape_type, must be one of “{‘line’, ‘rectangle’, ‘ellipse’, ‘path’, ‘polygon’}”. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
edge_width (float or list) – Thickness of lines and edges. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
edge_color (str, array-like) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
edge_color_cycle (np.ndarray, list) – Cycle of colors (provided as string name, RGB, or RGBA) to map to edge_color if a categorical attribute is used color the vectors.
edge_colormap (str, napari.utils.Colormap) – Colormap to set edge_color if a continuous attribute is used to set face_color.
edge_contrast_limits (None, (float, float)) – clims for mapping the property to a color map. These are the min and max value of the specified property that are mapped to 0 and 1, respectively. The default value is None. If set the none, the clims will be set to (property.min(), property.max())
face_color (str, array-like) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
face_color_cycle (np.ndarray, list) – Cycle of colors (provided as string name, RGB, or RGBA) to map to face_color if a categorical attribute is used color the vectors.
face_colormap (str, napari.utils.Colormap) – Colormap to set face_color if a continuous attribute is used to set face_color.
face_contrast_limits (None, (float, float)) – clims for mapping the property to a color map. These are the min and max value of the specified property that are mapped to 0 and 1, respectively. The default value is None. If set the none, the clims will be set to (property.min(), property.max())
z_index (int or list) – Specifier of z order priority. Shapes with higher z order are displayed ontop of others. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
name (str) – Name of the layer.
metadata (dict) – Layer metadata.
translate (tuple of float) – Translation values for the layer.
rotate (float, 3-tuple of float, or n-D array.) – If a float convert into a 2D rotation matrix using that value as an angle. If 3-tuple convert into a 3D rotation matrix, using a yaw, pitch, roll convention. Otherwise assume an nD rotation. Angles are assumed to be in degrees. They can be converted from radians with np.degrees if needed.
shear (1-D array or n-D array) – Either a vector of upper triangular values, or an nD shear matrix with ones along the main diagonal.
affine (n-D array or napari.utils.transforms.Affine) – (N+1, N+1) affine transformation matrix in homogeneous coordinates. The first (N, N) entries correspond to a linear transform and the final column is a length N translation vector and a 1 or a napari Affine transform object. Applied as an extra transform on top of the provided scale, rotate, and shear values.
opacity (float) – Opacity of the layer visual, between 0.0 and 1.0.
blending (str) – One of a list of preset blending modes that determines how RGB and alpha values of the layer visual get mixed. Allowed values are {‘opaque’, ‘translucent’, and ‘additive’}.
visible (bool) – Whether the layer visual is currently being displayed.
cache (bool) – Whether slices of out-of-core datasets should be cached upon retrieval. Currently, this only applies to dask arrays.
- data#
List of shape data, where each element is an (N, D) array of the N vertices of a shape in D dimensions.
- Type:
(N, ) list of array
- features#
Features table where each row corresponds to a shape and each column is a feature.
- Type:
Dataframe-like
- feature_defaults#
Stores the default value of each feature in a table with one row.
- Type:
DataFrame-like
- properties#
Properties for each shape. Each property should be an array of length N, where N is the number of shapes.
- Type:
dict {str: array (N,)}, DataFrame
- text#
Text to be displayed with the shapes. If text is set to a key in properties, the value of that property will be displayed. Multiple properties can be composed using f-string-like syntax (e.g., ‘{property_1}, {float_property:.2f}). For example usage, see /napari/examples/add_shapes_with_text.py.
- current_edge_width#
Thickness of lines and edges of the next shape to be added or the currently selected shape.
- Type:
- current_edge_color#
Color of the edge of the next shape to be added or the currently selected shape.
- Type:
- current_face_color#
Color of the face of the next shape to be added or the currently selected shape.
- Type:
- mode#
Interactive mode. The normal, default mode is PAN_ZOOM, which allows for normal interactivity with the canvas.
The SELECT mode allows for entire shapes to be selected, moved and resized.
The DIRECT mode allows for shapes to be selected and their individual vertices to be moved.
The VERTEX_INSERT and VERTEX_REMOVE modes allow for individual vertices either to be added to or removed from shapes that are already selected. Note that shapes cannot be selected in this mode.
The ADD_RECTANGLE, ADD_ELLIPSE, ADD_LINE, ADD_PATH, and ADD_POLYGON modes all allow for their corresponding shape type to be added.
- Type:
Mode
Notes
- _data_dictDict of ShapeList
Dictionary containing all the shape data indexed by slice tuple
- _data_viewShapeList
Object containing the currently viewed shape data.
- _selected_data_historyset
Set of currently selected captured on press of <space>.
- _selected_data_storedset
Set of selected previously displayed. Used to prevent rerendering the same highlighted shapes when no data has changed.
- _selected_boxNone | np.ndarray
None if no shapes are selected, otherwise a 10x2 array of vertices of the interaction box. The first 8 points are the corners and midpoints of the box. The 9th point is the center of the box, and the last point is the location of the rotation handle that can be used to rotate the box.
- _drag_startNone | np.ndarray
If a drag has been started and is in progress then a length 2 array of the initial coordinates of the drag. None otherwise.
- _drag_boxNone | np.ndarray
If a drag box is being created to select shapes then this is a 2x2 array of the two extreme corners of the drag. None otherwise.
- _drag_box_storedNone | np.ndarray
If a drag box is being created to select shapes then this is a 2x2 array of the two extreme corners of the drag that have previously been rendered. None otherwise. Used to prevent rerendering the same drag box when no data has changed.
- _is_movingbool
Bool indicating if any shapes are currently being moved.
- _is_selectingbool
Bool indicating if a drag box is currently being created in order to select shapes.
- _is_creatingbool
Bool indicating if any shapes are currently being created.
- _fixed_aspectbool
Bool indicating if aspect ratio of shapes should be preserved on resizing.
- _aspect_ratiofloat
Value of aspect ratio to be preserved if _fixed_aspect is True.
- _fixed_vertexNone | np.ndarray
If a scaling or rotation is in progress then a length 2 array of the coordinates that are remaining fixed during the move. None otherwise.
- _fixed_indexint
If a scaling or rotation is in progress then the index of the vertex of the bounding box that is remaining fixed during the move. None otherwise.
- _update_propertiesbool
Bool indicating if properties are to allowed to update the selected shapes when they are changed. Blocking this prevents circular loops when shapes are selected and the properties are changed based on that selection
- _allow_thumbnail_updatebool
Flag set to true to allow the thumbnail to be updated. Blocking the thumbnail can be advantageous where responsiveness is critical.
- _clipboarddict
Dict of shape objects that are to be used during a copy and paste.
- _colorslist
List of supported vispy color names.
- _vertex_sizefloat
Size of the vertices of the shapes and bounding box in Canvas coordinates.
- _rotation_handle_lengthfloat
Length of the rotation handle of the bounding box in Canvas coordinates.
- _input_ndimint
Dimensions of shape data.
- _thumbnail_update_threshint
If there are more than this number of shapes, the thumbnail won’t update during interactive events
Methods
add
(data, *[, shape_type, edge_width, ...])Add shapes to the current layer.
add_ellipses
(data, *[, edge_width, ...])Add ellipses to the current layer.
add_lines
(data, *[, edge_width, edge_color, ...])Add lines to the current layer.
add_paths
(data, *[, edge_width, edge_color, ...])Add paths to the current layer.
add_polygons
(data, *[, edge_width, ...])Add polygons to the current layer.
add_rectangles
(data, *[, edge_width, ...])Add rectangles to the current layer.
as_layer_data_tuple
()bind_key
(key[, func, overwrite])Bind a key combination to a keymap.
Use this context manager to block thumbnail updates
block_update_properties
()click_plane_from_click_data
(click_position, ...)Calculate a (point, normal) plane parallel to the canvas in data coordinates, centered on the centre of rotation of the camera.
create
(data[, meta, layer_type])Create layer from data of type layer_type.
data_to_world
(position)Convert from data coordinates to world coordinates.
get_index_and_intersection
(position, ...)Get the shape index and intersection point of the first shape (i.e., closest to start_point) "under" a mouse click.
get_ray_intersections
(position, ...[, world])Get the start and end point for the ray extending from a point through the data bounding box.
get_source_str
()get_status
([position, view_direction, ...])Status message information of the data at a coordinate position.
get_value
(position, *[, view_direction, ...])Value of the data at a position.
interaction_box
(index)Create the interaction box around a shape or list of shapes.
Moves selected objects to be displayed behind all others.
Moves selected objects to be displayed in front of all others.
Calculate the length of the projection of a line between two mouse clicks onto a vector (or array of vectors) in data coordinates.
refresh
([event])Refresh all layer data based on current view slice.
refresh_colors
([update_color_mapping])Calculate and update face and edge colors if using a cycle or color map
Refresh the text values.
Remove any selected shapes.
save
(path[, plugin])Save this layer to
path
with default (or specified) plugin.set_view_slice
()to_labels
([labels_shape])Return an integer labels image.
to_masks
([mask_shape])Return an array of binary masks, one for each shape.
world_to_data
(position)Convert from world coordinates to data coordinates.
Attributes
Extra affine transform to go from physical to world coordinates.
Determines how RGB and alpha values get mixed.
bounding_box
class_keymap
color of shape edges including lines and paths.
Width of shape edges including lines and paths.
color of shape faces.
properties for the next added shape.
String identifying cursor displayed over canvas.
Size of cursor if custom.
Each element is an (N, D) array of the vertices of a shape.
Array of RGBA face colors for each shape
Color cycle for edge_color.
Edge color setting mode
Return the colormap to be applied to a property to get the edge color.
contrast limits for mapping the edge_color colormap property to 0 and 1
edge width for each shape.
Whether the current layer data is editable from the viewer.
experimental_clipping_planes
Extent of layer in data and world coordinates.
Array of RGBA face colors for each shape
Color cycle for face_color Can be a list of colors defined by name, RGB or RGBA
Face color setting mode
Return the colormap to be applied to a property to get the face color.
clims for mapping the face_color colormap property to 0 and 1
Dataframe-like with one row of feature default values.
Dataframe-like features table.
displayed in status bar bottom right.
interactive
Return True if this layer is fully loaded in memory.
Key/value map for user-stored data.
Interactive mode.
Determine if canvas interactive panning is enabled with the mouse.
Determine if canvas interactive zooming is enabled with the mouse.
Unique name of the layer.
Number of dimensions in the data.
Total number of shapes.
Opacity value between 0.0 and 1.0.
Annotations for each shape
property_choices
Rotation matrix in world coordinates.
Anisotropy factors to scale data into world coordinates.
set of currently selected shapes.
name of shape type for each shape.
Shear matrix in world coordinates.
source
The TextManager object containing the text properties
Integer array of thumbnail for the layer
Factors to shift the layer by in units of world coordinates.
translate_grid
Whether the visual is currently being displayed.
z_index for each shape.
Details
- add(data, *, shape_type='rectangle', edge_width=None, edge_color=None, face_color=None, z_index=None, gui=False)[source]#
Add shapes to the current layer.
- Parameters:
data (Array | Tuple(Array,str) | List[Array | Tuple(Array, str)] | Tuple(List[Array], str)) – List of shape data, where each element is either an (N, D) array of the N vertices of a shape in D dimensions or a tuple containing an array of the N vertices and the shape_type string. When a shape_type is present, it overrides keyword arg shape_type. Can be an 3-dimensional array if each shape has the same number of vertices.
shape_type (string | list) – String of shape shape_type, must be one of “{‘line’, ‘rectangle’, ‘ellipse’, ‘path’, ‘polygon’}”. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes. Overridden by data shape_type, if present.
edge_width (float | list) – thickness of lines and edges. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
edge_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
face_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
z_index (int | list) – Specifier of z order priority. Shapes with higher z order are displayed ontop of others. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
gui (bool) – Whether the shape is drawn by drawing in the gui.
- add_ellipses(data, *, edge_width=None, edge_color=None, face_color=None, z_index=None)[source]#
Add ellipses to the current layer.
- Parameters:
data (Array | List[Array]) – List of ellipse data where each element is a (4, D) array of 4 vertices in D dimensions representing a bounding box, or a (2, D) array of center position and radii magnitudes in D dimensions. Can be a 3-dimensional array for multiple shapes, or list of 2 or 4 vertices for a single shape.
edge_width (float | list) – thickness of lines and edges. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
edge_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
face_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
z_index (int | list) – Specifier of z order priority. Shapes with higher z order are displayed ontop of others. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
- add_lines(data, *, edge_width=None, edge_color=None, face_color=None, z_index=None)[source]#
Add lines to the current layer.
- Parameters:
data (Array | List[Array]) – List of line data where each element is a (2, D) array of 2 vertices in D dimensions representing a line. Can be a 3-dimensional array for multiple shapes, or list of 2 vertices for a single shape.
edge_width (float | list) – thickness of lines and edges. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
edge_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
face_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
z_index (int | list) – Specifier of z order priority. Shapes with higher z order are displayed ontop of others. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
- add_paths(data, *, edge_width=None, edge_color=None, face_color=None, z_index=None)[source]#
Add paths to the current layer.
- Parameters:
data (Array | List[Array]) – List of path data where each element is a (V, D) array of V vertices in D dimensions representing a path. Can be a 3-dimensional array if all paths have same number of vertices, or a list of V vertices for a single path.
edge_width (float | list) – thickness of lines and edges. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
edge_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
face_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
z_index (int | list) – Specifier of z order priority. Shapes with higher z order are displayed ontop of others. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
- add_polygons(data, *, edge_width=None, edge_color=None, face_color=None, z_index=None)[source]#
Add polygons to the current layer.
- Parameters:
data (Array | List[Array]) – List of polygon data where each element is a (V, D) array of V vertices in D dimensions representing a polygon. Can be a 3-dimensional array if polygons have same number of vertices, or a list of V vertices for a single polygon.
edge_width (float | list) – thickness of lines and edges. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
edge_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
face_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
z_index (int | list) – Specifier of z order priority. Shapes with higher z order are displayed ontop of others. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
- add_rectangles(data, *, edge_width=None, edge_color=None, face_color=None, z_index=None)[source]#
Add rectangles to the current layer.
- Parameters:
data (Array | List[Array]) – List of rectangle data where each element is a (4, D) array of 4 vertices in D dimensions, or a (2, D) array of 2 vertices in D dimensions, where the vertices are top-left and bottom-right corners. Can be a 3-dimensional array for multiple shapes, or list of 2 or 4 vertices for a single shape.
edge_width (float | list) – thickness of lines and edges. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
edge_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
face_color (str | tuple | list) – If string can be any color name recognized by vispy or hex value if starting with #. If array-like must be 1-dimensional array with 3 or 4 elements. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
z_index (int | list) – Specifier of z order priority. Shapes with higher z order are displayed ontop of others. If a list is supplied it must be the same length as the length of data and each element will be applied to each shape otherwise the same value will be used for all shapes.
- property affine#
Extra affine transform to go from physical to world coordinates.
- Type:
napari.utils.transforms.Affine
- bind_key(key, func=<object object>, *, overwrite=False)#
Bind a key combination to a keymap.
- Parameters:
keymap (dict of str: callable) – Keymap to modify.
key (str or ...) – Key combination.
...
acts as a wildcard if no key combinations can be matched in the keymap (this will overwrite all key combinations further down the lookup chain).func (callable, None, or ...) – Callable to bind to the key combination. If
None
is passed, unbind instead....
acts as a blocker, effectively unbinding the key combination for all keymaps further down the lookup chain.overwrite (bool, keyword-only, optional) – Whether to overwrite the key combination if it already exists.
- Returns:
unbound – Callable unbound by this operation, if any.
- Return type:
callable or None
Notes
Key combinations are represented in the form
[modifier-]key
, e.g.a
,Control-c
, orControl-Alt-Delete
. Valid modifiers are Control, Alt, Shift, and Meta.Letters will always be read as upper-case. Due to the native implementation of the key system, Shift pressed in certain key combinations may yield inconsistent or unexpected results. Therefore, it is not recommended to use Shift with non-letter keys. On OSX, Control is swapped with Meta such that pressing Command reads as Control.
Special keys include Shift, Control, Alt, Meta, Up, Down, Left, Right, PageUp, PageDown, Insert, Delete, Home, End, Escape, Backspace, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, Space, Enter, and Tab
Functions take in only one argument: the parent that the function was bound to.
By default, all functions are assumed to work on key presses only, but can be denoted to work on release too by separating the function into two statements with the yield keyword:
@viewer.bind_key('h') def hello_world(viewer): # on key press viewer.status = 'hello world!' yield # on key release viewer.status = 'goodbye world :('
To create a keymap that will block others,
bind_key(..., ...)`
.
- property blending#
Determines how RGB and alpha values get mixed.
- Blending.OPAQUE
Allows for only the top layer to be visible and corresponds to depth_test=True, cull_face=False, blend=False.
- Blending.TRANSLUCENT
Allows for multiple layers to be blended with different opacity and corresponds to depth_test=True, cull_face=False, blend=True, blend_func=(‘src_alpha’, ‘one_minus_src_alpha’), and blend_equation=(‘func_add’).
- Blending.TRANSLUCENT_NO_DEPTH
Allows for multiple layers to be blended with different opacity, but no depth testing is performed. Corresponds to
depth_test=False
, cull_face=False, blend=True, blend_func=(‘src_alpha’, ‘one_minus_src_alpha’), and blend_equation=(‘func_add’).- Blending.ADDITIVE
Allows for multiple layers to be blended together with different colors and opacity. Useful for creating overlays. It corresponds to depth_test=False, cull_face=False, blend=True, blend_func=(‘src_alpha’, ‘one’), and blend_equation=(‘func_add’).
- Blending.MINIMUM
Allows for multiple layers to be blended together such that the minimum of each RGB component and alpha are selected. Useful for creating overlays with inverted colormaps. It corresponds to depth_test=False, cull_face=False, blend=True, blend_equation=(‘min’).
- Type:
Blending mode
- click_plane_from_click_data(click_position: ndarray, view_direction: ndarray, dims_displayed: List) Tuple[ndarray, ndarray] #
Calculate a (point, normal) plane parallel to the canvas in data coordinates, centered on the centre of rotation of the camera.
- Parameters:
click_position (np.ndarray) – click position in world coordinates from mouse event.
view_direction (np.ndarray) – view direction in world coordinates from mouse event.
dims_displayed (List) – dimensions of the data array currently in view.
- Returns:
click_plane – tuple of (plane_position, plane_normal) in data coordinates.
- Return type:
Tuple[np.ndarray, np.ndarray]
- classmethod create(data, meta: dict | None = None, layer_type: str | None = None) Layer #
Create layer from data of type layer_type.
Primarily intended for usage by reader plugin hooks and creating a layer from an unwrapped layer data tuple.
- Parameters:
data (Any) – Data in a format that is valid for the corresponding layer_type.
meta (dict, optional) – Dict of keyword arguments that will be passed to the corresponding layer constructor. If any keys in meta are not valid for the corresponding layer type, an exception will be raised.
layer_type (str) – Type of layer to add. Must be the (case insensitive) name of a Layer subclass. If not provided, the layer is assumed to be “image”, unless data.dtype is one of (np.int32, np.uint32, np.int64, np.uint64), in which case it is assumed to be “labels”.
- Raises:
ValueError – If
layer_type
is not one of the recognized layer types.TypeError – If any keyword arguments in
meta
are unexpected for the corresponding add_* method for this layer_type.
Examples
A typical use case might be to upack a tuple of layer data with a specified layer_type.
>>> data = ( ... np.random.random((10, 2)) * 20, ... {'face_color': 'blue'}, ... 'points', ... ) >>> Layer.create(*data)
- property current_properties: Dict[str, ndarray]#
properties for the next added shape.
- Type:
dict{str
- Type:
np.ndarray(1,)}
- data_to_world(position)#
Convert from data coordinates to world coordinates.
- property edge_color#
Array of RGBA face colors for each shape
- Type:
(N x 4) np.ndarray
- property edge_color_cycle: ndarray#
Color cycle for edge_color.
Can be a list of colors defined by name, RGB or RGBA
- Type:
Union[list, np.ndarray]
- property edge_color_mode: str#
Edge color setting mode
DIRECT (default mode) allows each shape color to be set arbitrarily
CYCLE allows the color to be set via a color cycle over an attribute
COLORMAP allows color to be set via a color map over an attribute
- Type:
- property edge_colormap: Tuple[str, Colormap]#
Return the colormap to be applied to a property to get the edge color.
- Returns:
colormap – The Colormap object.
- Return type:
- property edge_contrast_limits: Tuple[float, float]#
contrast limits for mapping the edge_color colormap property to 0 and 1
- property extent: Extent#
Extent of layer in data and world coordinates.
- property face_color#
Array of RGBA face colors for each shape
- Type:
(N x 4) np.ndarray
- property face_color_cycle: ndarray#
Color cycle for face_color Can be a list of colors defined by name, RGB or RGBA
- Type:
Union[np.ndarray, cycle]
- property face_color_mode: str#
Face color setting mode
DIRECT (default mode) allows each shape color to be set arbitrarily
CYCLE allows the color to be set via a color cycle over an attribute
COLORMAP allows color to be set via a color map over an attribute
- Type:
- property face_colormap: Tuple[str, Colormap]#
Return the colormap to be applied to a property to get the face color.
- Returns:
colormap – The Colormap object.
- Return type:
- property face_contrast_limits: None | Tuple[float, float]#
clims for mapping the face_color colormap property to 0 and 1
- property feature_defaults#
Dataframe-like with one row of feature default values.
See features for more details on the type of this property.
- property features#
Dataframe-like features table.
It is an implementation detail that this is a pandas.DataFrame. In the future, we will target the currently-in-development Data API dataframe protocol [1]. This will enable us to use alternate libraries such as xarray or cuDF for additional features without breaking existing usage of this.
If you need to specifically rely on the pandas API, please coerce this to a pandas.DataFrame using features_to_pandas_dataframe.
References
- get_index_and_intersection(position: ndarray, view_direction: ndarray, dims_displayed: List[int]) Tuple[float | int, None] [source]#
Get the shape index and intersection point of the first shape (i.e., closest to start_point) “under” a mouse click.
See examples/add_points_on_nD_shapes.py for example usage.
- Parameters:
position (tuple) – Position in either data or world coordinates.
view_direction (Optional[np.ndarray]) – A unit vector giving the direction of the ray in nD world coordinates. The default value is None.
dims_displayed (Optional[List[int]]) – A list of the dimensions currently being displayed in the viewer. The default value is None.
- Returns:
value – The data value along the supplied ray.
intersection_point (np.ndarray) – (n,) array containing the point where the ray intersects the first shape (i.e., the shape most in the foreground). The coordinate is in layer coordinates.
- get_ray_intersections(position: List[float], view_direction: ndarray, dims_displayed: List[int], world: bool = True) Tuple[ndarray, ndarray] | Tuple[None, None] #
Get the start and end point for the ray extending from a point through the data bounding box.
- Parameters:
position – the position of the point in nD coordinates. World vs. data is set by the world keyword argument.
view_direction (np.ndarray) – a unit vector giving the direction of the ray in nD coordinates. World vs. data is set by the world keyword argument.
dims_displayed – a list of the dimensions currently being displayed in the viewer.
world (bool) – True if the provided coordinates are in world coordinates. Default value is True.
- Returns:
start_point (np.ndarray) – The point on the axis-aligned data bounding box that the cursor click intersects with. This is the point closest to the camera. The point is the full nD coordinates of the layer data. If the click does not intersect the axis-aligned data bounding box, None is returned.
end_point (np.ndarray) – The point on the axis-aligned data bounding box that the cursor click intersects with. This is the point farthest from the camera. The point is the full nD coordinates of the layer data. If the click does not intersect the axis-aligned data bounding box, None is returned.
- get_status(position: Tuple[float, ...] | None = None, *, view_direction: ndarray | None = None, dims_displayed: List[int] | None = None, world=False)#
Status message information of the data at a coordinate position.
- Parameters:
position (tuple of float) – Position in either data or world coordinates.
view_direction (Optional[np.ndarray]) – A unit vector giving the direction of the ray in nD world coordinates. The default value is None.
dims_displayed (Optional[List[int]]) – A list of the dimensions currently being displayed in the viewer. The default value is None.
world (bool) – If True the position is taken to be in world coordinates and converted into data coordinates. False by default.
- Returns:
source_info – Dictionary containing a information that can be used as a status update.
- Return type:
- get_value(position: Tuple[float], *, view_direction: ndarray | None = None, dims_displayed: List[int] | None = None, world=False)#
Value of the data at a position.
If the layer is not visible, return None.
- Parameters:
position (tuple of float) – Position in either data or world coordinates.
view_direction (Optional[np.ndarray]) – A unit vector giving the direction of the ray in nD world coordinates. The default value is None.
dims_displayed (Optional[List[int]]) – A list of the dimensions currently being displayed in the viewer. The default value is None.
world (bool) – If True the position is taken to be in world coordinates and converted into data coordinates. False by default.
- Returns:
value – Value of the data. If the layer is not visible return None.
- Return type:
tuple, None
- interaction_box(index)[source]#
Create the interaction box around a shape or list of shapes. If a single index is passed then the boudning box will be inherited from that shapes interaction box. If list of indices is passed it will be computed directly.
- Parameters:
index (int | list) – Index of a single shape, or a list of shapes around which to construct the interaction box
- Returns:
box – 10x2 array of vertices of the interaction box. The first 8 points are the corners and midpoints of the box in clockwise order starting in the upper-left corner. The 9th point is the center of the box, and the last point is the location of the rotation handle that can be used to rotate the box
- Return type:
np.ndarray
- property loaded: bool#
Return True if this layer is fully loaded in memory.
This base class says that layers are permanently in the loaded state. Derived classes that do asynchronous loading can override this.
- property mode#
Interactive mode. The normal, default mode is PAN_ZOOM, which allows for normal interactivity with the canvas.
The SELECT mode allows for entire shapes to be selected, moved and resized.
The DIRECT mode allows for shapes to be selected and their individual vertices to be moved.
The VERTEX_INSERT and VERTEX_REMOVE modes allow for individual vertices either to be added to or removed from shapes that are already selected. Note that shapes cannot be selected in this mode.
The ADD_RECTANGLE, ADD_ELLIPSE, ADD_LINE, ADD_PATH, and ADD_POLYGON modes all allow for their corresponding shape type to be added.
- Type:
MODE
- projected_distance_from_mouse_drag(start_position: ndarray, end_position: ndarray, view_direction: ndarray, vector: ndarray, dims_displayed: List | ndarray)#
Calculate the length of the projection of a line between two mouse clicks onto a vector (or array of vectors) in data coordinates.
- Parameters:
start_position (np.ndarray) – Starting point of the drag vector in data coordinates
end_position (np.ndarray) – End point of the drag vector in data coordinates
view_direction (np.ndarray) – Vector defining the plane normal of the plane onto which the drag vector is projected.
vector (np.ndarray) – (3,) unit vector or (n, 3) array thereof on which to project the drag vector from start_event to end_event. This argument is defined in data coordinates.
dims_displayed (Union[List, np.ndarray]) – (3,) list of currently displayed dimensions
- Returns:
projected_distance
- Return type:
(1, ) or (n, ) np.ndarray of float
- property properties: Dict[str, ndarray]#
Annotations for each shape
- Type:
dict {str
- Type:
np.ndarray (N,)}, DataFrame
- refresh(event=None)#
Refresh all layer data based on current view slice.
- refresh_colors(update_color_mapping: bool = False)[source]#
Calculate and update face and edge colors if using a cycle or color map
- Parameters:
update_color_mapping (bool) – If set to True, the function will recalculate the color cycle map or colormap (whichever is being used). If set to False, the function will use the current color cycle map or color map. For example, if you are adding/modifying shapes and want them to be colored with the same mapping as the other shapes (i.e., the new shapes shouldn’t affect the color cycle map or colormap), set update_color_mapping=False. Default value is False.
- refresh_text()[source]#
Refresh the text values.
This is generally used if the properties were updated without changing the data
- property rotate#
Rotation matrix in world coordinates.
- Type:
array
- save(path: str, plugin: str | None = None) List[str] #
Save this layer to
path
with default (or specified) plugin.- Parameters:
path (str) – A filepath, directory, or URL to open. Extensions may be used to specify output format (provided a plugin is available for the requested format).
plugin (str, optional) – Name of the plugin to use for saving. If
None
then all plugins corresponding to appropriate hook specification will be looped through to find the first one that can save the data.
- Returns:
File paths of any files that were written.
- Return type:
- property shear#
Shear matrix in world coordinates.
- Type:
array
- property text: TextManager#
The TextManager object containing the text properties
- Type:
TextManager
- property thumbnail#
Integer array of thumbnail for the layer
- Type:
array
- to_labels(labels_shape=None)[source]#
Return an integer labels image.
- Parameters:
labels_shape (np.ndarray | tuple | None) – Tuple defining shape of labels image to be generated. If non specified, takes the max of all the vertiecs
- Returns:
labels – Integer array where each value is either 0 for background or an integer up to N for points inside the shape at the index value - 1. For overlapping shapes z-ordering will be respected.
- Return type:
np.ndarray
- to_masks(mask_shape=None)[source]#
Return an array of binary masks, one for each shape.
- Parameters:
mask_shape (np.ndarray | tuple | None) – tuple defining shape of mask to be generated. If non specified, takes the max of all the vertices
- Returns:
masks – Array where there is one binary mask for each shape
- Return type:
np.ndarray
- world_to_data(position)#
Convert from world coordinates to data coordinates.