utils#

Actor

alias of vtkActor

AlgorithmOutput

alias of vtkAlgorithmOutput

CellArray

alias of vtkCellArray

Glyph3D

alias of vtkGlyph3D

ImageData

alias of vtkImageData

Matrix3x3

alias of vtkMatrix3x3

Matrix4x4

alias of vtkMatrix4x4

Points

alias of vtkPoints

PolyData

alias of vtkPolyData

PolyDataMapper

alias of vtkPolyDataMapper

PolyDataNormals

alias of vtkPolyDataNormals

Transform

alias of vtkTransform

TransformPolyDataFilter

alias of vtkTransformPolyDataFilter

add_polydata_numeric_field(polydata, ...[, ...])

Add a field to a vtk polydata.

apply_affine(aff, pts)

Apply affine matrix aff to points pts.

apply_affine_to_actor(act, affine)

Apply affine matrix affine to the actor act.

array_from_actor(actor, array_name[, as_vtk])

Access array from actor which uses polydata.

asbytes(s)

change_vertices_order(triangle)

Change the vertices order of a given triangle.

color_check(pts_len[, colors])

Returns a VTK scalar array containing colors information for each one of the points according to the policy defined by the parameter colors.

colors_from_actor(actor[, array_name, as_vtk])

Access colors from actor which uses polydata.

compute_bounds(actor)

Compute Bounds of actor.

fix_winding_order(vertices, triangles[, ...])

Return corrected triangles.

get_actor_from_polydata(polydata)

Get actor from a vtkPolyData.

get_actor_from_polymapper(poly_mapper)

Get actor from a vtkPolyDataMapper.

get_actor_from_primitive(vertices, triangles)

Get actor from a vtkPolyData.

get_bounding_box_sizes(actor)

Get the bounding box sizes of an actor.

get_bounds(actor)

Return Bounds of actor.

get_grid_cells_position(shapes[, ...])

Construct a XY-grid based on the cells content shape.

get_polydata_colors(polydata)

Get points color (ndarrays Nx3 int) from a vtk polydata.

get_polydata_field(polydata, field_name[, ...])

Get a field from a vtk polydata.

get_polydata_lines(line_polydata)

Convert vtk polydata to a list of lines ndarrays.

get_polydata_normals(polydata)

Get vertices normal (ndarrays Nx3 int) from a vtk polydata.

get_polydata_primitives_count(polydata)

Get primitives count from actor's polydata.

get_polydata_tangents(polydata)

Get vertices tangent (ndarrays Nx3 int) from a vtk polydata.

get_polydata_tcoord(polydata)

Get texture coordinates (ndarrays Nx2 float) from a vtk polydata.

get_polydata_triangles(polydata)

Get triangles (ndarrays Nx3 int) from a vtk polydata.

get_polydata_vertices(polydata)

Get vertices (ndarrays Nx3 int) from a vtk polydata.

get_polymapper_from_polydata(polydata)

Get vtkPolyDataMapper from a vtkPolyData.

is_ui(actor)

Method to check if the passed actor is UI or vtkProp3D

line_colors(streamlines[, cmap])

Create colors for streamlines to be used in actor.line.

lines_to_vtk_polydata(lines[, colors])

Create a vtkPolyData with lines and colors.

map_coordinates(input, coordinates[, ...])

Map the input array to new coordinates by interpolation.

map_coordinates_3d_4d(input_array, indices)

Evaluate input_array at the given indices using trilinear interpolation.

normalize_v3(arr)

Normalize a numpy array of 3 component vectors shape=(N, 3).

normals_from_actor(act)

Access normals from actor which uses polydata.

normals_from_v_f(vertices, faces)

Calculate normals from vertices and faces.

normals_to_actor(act, normals)

Set normals to actor which uses polydata.

numpy_to_vtk_cells(data[, is_coords])

Convert numpy array to a vtk cell array.

numpy_to_vtk_colors(colors)

Convert Numpy color array to a vtk color array.

numpy_to_vtk_image_data(array[, spacing, ...])

Convert numpy array to a vtk image data.

numpy_to_vtk_matrix(array)

Convert a numpy array to a VTK matrix.

numpy_to_vtk_points(points)

Convert Numpy points array to a vtk points array.

primitives_count_from_actor(actor)

Get primitives count from actor's polydata.

primitives_count_to_actor(actor, ...)

Add primitives count to actor's polydata.

remove_observer_from_actor(actor, id)

Remove the observer with the given id from the actor.

repeat_sources(centers, colors[, ...])

Transform a vtksource to glyph.

rgb_to_vtk(data)

RGB or RGBA images to VTK arrays.

rotate(actor[, rotation])

Rotate actor around axis by angle.

set_actor_origin(actor[, center])

Change the origin of an actor to a custom position.

set_input(vtk_object, inp)

Set Generic input function which takes into account VTK 5 or 6.

set_polydata_colors(polydata, colors[, ...])

Set polydata colors with a numpy array (ndarrays Nx3 int).

set_polydata_normals(polydata, normals)

Set polydata normals with a numpy array (ndarrays Nx3 int).

set_polydata_primitives_count(polydata, ...)

Add primitives count to polydata.

set_polydata_tangents(polydata, tangents)

Set polydata tangents with a numpy array (ndarrays Nx3 int).

set_polydata_tcoords(polydata, tcoords)

Set polydata texture coordinates with a numpy array (ndarrays Nx2 float).

set_polydata_triangles(polydata, triangles)

Set polydata triangles with a numpy array (ndarrays Nx3 int).

set_polydata_vertices(polydata, vertices)

Set polydata vertices with a numpy array (ndarrays Nx3 int).

shallow_copy(vtk_object)

Create a shallow copy of a given vtkObject object.

tangents_from_actor(act)

Access tangents from actor which uses polydata.

tangents_from_direction_of_anisotropy(...)

Calculate tangents from normals and a 3D vector representing the

tangents_to_actor(act, tangents)

Set tangents to actor which uses polydata.

triangle_order(vertices, faces)

Determine the winding order of a given set of vertices and a triangle.

update_actor(actor[, all_arrays])

Update actor.

update_polydata_normals(polydata)

Generate and update polydata normals.

update_surface_actor_colors(actor, colors)

Update colors of a surface actor.

vertices_from_actor(actor[, as_vtk])

Access to vertices from actor.

vtk_matrix_to_numpy(matrix)

Convert VTK matrix to numpy array.

Actor#

fury.utils.Actor#

alias of vtkActor

AlgorithmOutput#

fury.utils.AlgorithmOutput#

alias of vtkAlgorithmOutput

CellArray#

fury.utils.CellArray#

alias of vtkCellArray

Glyph3D#

fury.utils.Glyph3D#

alias of vtkGlyph3D

ImageData#

fury.utils.ImageData#

alias of vtkImageData

Matrix3x3#

fury.utils.Matrix3x3#

alias of vtkMatrix3x3

Matrix4x4#

fury.utils.Matrix4x4#

alias of vtkMatrix4x4

Points#

fury.utils.Points#

alias of vtkPoints

PolyData#

fury.utils.PolyData#

alias of vtkPolyData

PolyDataMapper#

fury.utils.PolyDataMapper#

alias of vtkPolyDataMapper

PolyDataNormals#

fury.utils.PolyDataNormals#

alias of vtkPolyDataNormals

Transform#

fury.utils.Transform#

alias of vtkTransform

TransformPolyDataFilter#

fury.utils.TransformPolyDataFilter#

alias of vtkTransformPolyDataFilter

add_polydata_numeric_field#

fury.utils.add_polydata_numeric_field(polydata, field_name, field_data, array_type=6)[source]#

Add a field to a vtk polydata.

Parameters:
  • polydata (vtkPolyData) –

  • field_name (str) –

  • field_data (bool, int, float, double, numeric array or ndarray) –

  • array_type (vtkArrayType) –

apply_affine#

fury.utils.apply_affine(aff, pts)[source]#

Apply affine matrix aff to points pts.

Returns result of application of aff to the right of pts. The coordinate dimension of pts should be the last. For the 3D case, aff will be shape (4,4) and pts will have final axis length 3 - maybe it will just be N by 3. The return value is the transformed points, in this case:: res = np.dot(aff[:3,:3], pts.T) + aff[:3,3:4] transformed_pts = res.T This routine is more general than 3D, in that aff can have any shape (N,N), and pts can have any shape, as long as the last dimension is for the coordinates, and is therefore length N-1.

Parameters:
  • aff ((N, N) array-like) – Homogenous affine, for 3D points, will be 4 by 4. Contrary to first appearance, the affine will be applied on the left of pts.

  • pts ((..., N-1) array-like) – Points, where the last dimension contains the coordinates of each point. For 3D, the last dimension will be length 3.

Returns:

transformed_pts – transformed points

Return type:

(…, N-1) array

Notes

Copied from nibabel to remove dependency.

Examples

>>> aff = np.array([[0,2,0,10],[3,0,0,11],[0,0,4,12],[0,0,0,1]])
>>> pts = np.array([[1,2,3],[2,3,4],[4,5,6],[6,7,8]])
>>> apply_affine(aff, pts) 
array([[14, 14, 24],
       [16, 17, 28],
       [20, 23, 36],
       [24, 29, 44]]...)
Just to show that in the simple 3D case, it is equivalent to:
>>> (np.dot(aff[:3,:3], pts.T) + aff[:3,3:4]).T 
array([[14, 14, 24],
       [16, 17, 28],
       [20, 23, 36],
       [24, 29, 44]]...)
But `pts` can be a more complicated shape:
>>> pts = pts.reshape((2,2,3))
>>> apply_affine(aff, pts) 
array([[[14, 14, 24],
        [16, 17, 28]],

       [[20, 23, 36],
        [24, 29, 44]]]...)

apply_affine_to_actor#

fury.utils.apply_affine_to_actor(act, affine)[source]#

Apply affine matrix affine to the actor act.

Parameters:
  • act (Actor) –

  • affine ((4, 4) array-like) – Homogenous affine, for 3D object.

Returns:

transformed_act

Return type:

Actor

array_from_actor#

fury.utils.array_from_actor(actor, array_name, as_vtk=False)[source]#

Access array from actor which uses polydata.

Parameters:
  • actor (actor) –

  • array_name (str) –

  • as_vtk_type (bool, optional) – by default, ndarray is returned.

Returns:

output

Return type:

array (N, 3)

asbytes#

fury.utils.asbytes(s)[source]#

change_vertices_order#

fury.utils.change_vertices_order(triangle)[source]#

Change the vertices order of a given triangle.

Parameters:

triangle (ndarray, shape(1, 3)) – array of 3 vertices making up a triangle

Returns:

new_triangle – new array of vertices making up a triangle in the opposite winding order of the given parameter

Return type:

ndarray, shape(1, 3)

color_check#

fury.utils.color_check(pts_len, colors=None)[source]#

Returns a VTK scalar array containing colors information for each one of the points according to the policy defined by the parameter colors.

Parameters:
  • pts_len (int) – length of points ndarray

  • colors (None or tuple (3D or 4D) or array/ndarray (N, 3 or 4)) – If None a predefined color is used for each point. If a tuple of color is used. Then all points will have the same color. If an array (N, 3 or 4) is given, where N is equal to the number of points. Then every point is colored with a different RGB(A) color.

Returns:

  • color_array (vtkDataArray) – vtk scalar array with name ‘colors’.

  • global_opacity (float) – returns 1 if the colors array doesn’t contain opacity otherwise -1. If colors array has 4 dimensions, it checks values of the fourth dimension. If the value is the same, then assign it to global_opacity.

colors_from_actor#

fury.utils.colors_from_actor(actor, array_name='colors', as_vtk=False)[source]#

Access colors from actor which uses polydata.

Parameters:
  • actor (actor) –

  • array_name (str) –

  • as_vtk (bool, optional) – by default, numpy array is returned.

Returns:

output – Colors

Return type:

array (N, 3)

compute_bounds#

fury.utils.compute_bounds(actor)[source]#

Compute Bounds of actor.

Parameters:

actor (actor) –

fix_winding_order#

fury.utils.fix_winding_order(vertices, triangles, clockwise=False)[source]#

Return corrected triangles.

Given an ordering of the triangle’s three vertices, a triangle can appear to have a clockwise winding or counter-clockwise winding. Clockwise means that the three vertices, in order, rotate clockwise around the triangle’s center.

Parameters:
  • vertices (ndarray) – array of vertices corresponding to a shape

  • triangles (ndarray) – array of triangles corresponding to a shape

  • clockwise (bool) – triangle order type: clockwise (default) or counter-clockwise.

Returns:

corrected_triangles – The corrected order of the vert parameter

Return type:

ndarray

get_actor_from_polydata#

fury.utils.get_actor_from_polydata(polydata)[source]#

Get actor from a vtkPolyData.

Parameters:

polydata (vtkPolyData) –

Returns:

actor

Return type:

actor

get_actor_from_polymapper#

fury.utils.get_actor_from_polymapper(poly_mapper)[source]#

Get actor from a vtkPolyDataMapper.

Parameters:

poly_mapper (vtkPolyDataMapper) –

Returns:

actor

Return type:

actor

get_actor_from_primitive#

fury.utils.get_actor_from_primitive(vertices, triangles, colors=None, normals=None, backface_culling=True, prim_count=1)[source]#

Get actor from a vtkPolyData.

Parameters:
  • vertices ((Mx3) ndarray) – XYZ coordinates of the object

  • triangles ((Nx3) ndarray) – Indices into vertices; forms triangular faces.

  • colors ((Nx3) or (Nx4) ndarray) – RGB or RGBA (for opacity) R, G, B and A should be at the range [0, 1] N is equal to the number of vertices.

  • normals ((Nx3) ndarray) – normals, represented as 2D ndarrays (Nx3) (one per vertex)

  • backface_culling (bool) – culling of polygons based on orientation of normal with respect to camera. If backface culling is True, polygons facing away from camera are not drawn. Default: True

  • prim_count (int, optional) – primitives count to be associated with the actor

Returns:

actor

Return type:

actor

get_bounding_box_sizes#

fury.utils.get_bounding_box_sizes(actor)[source]#

Get the bounding box sizes of an actor.

get_bounds#

fury.utils.get_bounds(actor)[source]#

Return Bounds of actor.

Parameters:

actor (actor) –

Returns:

vertices

Return type:

ndarray

get_grid_cells_position#

fury.utils.get_grid_cells_position(shapes, aspect_ratio=1.7777777777777777, dim=None)[source]#

Construct a XY-grid based on the cells content shape.

This function generates the coordinates of every grid cell. The width and height of every cell correspond to the largest width and the largest height respectively. The grid dimensions will automatically be adjusted to respect the given aspect ratio unless they are explicitly specified.

The grid follows a row-major order with the top left corner being at coordinates (0,0,0) and the bottom right corner being at coordinates (nb_cols*cell_width, -nb_rows*cell_height, 0). Note that the X increases while the Y decreases.

Parameters:
  • shapes (list of tuple of int) – The shape (width, height) of every cell content.

  • aspect_ratio (float (optional)) – Aspect ratio of the grid (width/height). Default: 16:9.

  • dim (tuple of int (optional)) – Dimension (nb_rows, nb_cols) of the grid, if provided.

Returns:

3D coordinates of every grid cell.

Return type:

ndarray

get_polydata_colors#

fury.utils.get_polydata_colors(polydata)[source]#

Get points color (ndarrays Nx3 int) from a vtk polydata.

Parameters:

polydata (vtkPolyData) –

Returns:

output – Colors. None if no normals in the vtk polydata.

Return type:

array (N, 3)

get_polydata_field#

fury.utils.get_polydata_field(polydata, field_name, as_vtk=False)[source]#

Get a field from a vtk polydata.

Parameters:
  • polydata (vtkPolyData) –

  • field_name (str) –

  • as_vtk (optional) – By default, ndarray is returned.

Returns:

output – Field data. The return type depends on the value of the as_vtk parameter. None if the field is not found.

Return type:

ndarray or vtkDataArray

get_polydata_lines#

fury.utils.get_polydata_lines(line_polydata)[source]#

Convert vtk polydata to a list of lines ndarrays.

Parameters:

line_polydata (vtkPolyData) –

Returns:

lines – List of N curves represented as 2D ndarrays

Return type:

list

get_polydata_normals#

fury.utils.get_polydata_normals(polydata)[source]#

Get vertices normal (ndarrays Nx3 int) from a vtk polydata.

Parameters:

polydata (vtkPolyData) –

Returns:

output – Normals, represented as 2D ndarrays (Nx3). None if there are no normals in the vtk polydata.

Return type:

array (N, 3)

get_polydata_primitives_count#

fury.utils.get_polydata_primitives_count(polydata)[source]#

Get primitives count from actor’s polydata.

Parameters:

polydata (vtkPolyData) –

Returns:

primitives count

Return type:

int

get_polydata_tangents#

fury.utils.get_polydata_tangents(polydata)[source]#

Get vertices tangent (ndarrays Nx3 int) from a vtk polydata.

Parameters:

polydata (vtkPolyData) –

Returns:

output – Tangents, represented as 2D ndarrays (Nx3). None if there are no tangents in the vtk polydata.

Return type:

array (N, 3)

get_polydata_tcoord#

fury.utils.get_polydata_tcoord(polydata)[source]#

Get texture coordinates (ndarrays Nx2 float) from a vtk polydata.

Parameters:

polydata (vtkPolyData) –

Returns:

output – Tcoords, represented as 2D ndarrays. None if there are no texture in the vtk polydata.

Return type:

array (N, 2)

get_polydata_triangles#

fury.utils.get_polydata_triangles(polydata)[source]#

Get triangles (ndarrays Nx3 int) from a vtk polydata.

Parameters:

polydata (vtkPolyData) –

Returns:

output – triangles

Return type:

array (N, 3)

get_polydata_vertices#

fury.utils.get_polydata_vertices(polydata)[source]#

Get vertices (ndarrays Nx3 int) from a vtk polydata.

Parameters:

polydata (vtkPolyData) –

Returns:

output – points, represented as 2D ndarrays

Return type:

array (N, 3)

get_polymapper_from_polydata#

fury.utils.get_polymapper_from_polydata(polydata)[source]#

Get vtkPolyDataMapper from a vtkPolyData.

Parameters:

polydata (vtkPolyData) –

Returns:

poly_mapper

Return type:

vtkPolyDataMapper

is_ui#

fury.utils.is_ui(actor)[source]#

Method to check if the passed actor is UI or vtkProp3D

Parameters:

actor – actor that is to be checked

line_colors#

fury.utils.line_colors(streamlines, cmap='rgb_standard')[source]#

Create colors for streamlines to be used in actor.line.

Parameters:
  • streamlines (sequence of ndarrays) –

  • cmap (('rgb_standard', 'boys_standard')) –

Returns:

colors

Return type:

ndarray

lines_to_vtk_polydata#

fury.utils.lines_to_vtk_polydata(lines, colors=None)[source]#

Create a vtkPolyData with lines and colors.

Parameters:
  • lines (list) – list of N curves represented as 2D ndarrays

  • colors (array (N, 3), list of arrays, tuple (3,), array (K,)) – If None or False, a standard orientation colormap is used for every line. If one tuple of color is used. Then all streamlines will have the same colour. If an array (N, 3) is given, where N is equal to the number of lines. Then every line is coloured with a different RGB color. If a list of RGB arrays is given then every point of every line takes a different color. If an array (K, 3) is given, where K is the number of points of all lines then every point is colored with a different RGB color. If an array (K,) is given, where K is the number of points of all lines then these are considered as the values to be used by the colormap. If an array (L,) is given, where L is the number of streamlines then these are considered as the values to be used by the colormap per streamline. If an array (X, Y, Z) or (X, Y, Z, 3) is given then the values for the colormap are interpolated automatically using trilinear interpolation.

Returns:

  • poly_data (vtkPolyData)

  • color_is_scalar (bool, true if the color array is a single scalar) – Scalar array could be used with a colormap lut None if no color was used

map_coordinates#

fury.utils.map_coordinates(input, coordinates, output=None, order=3, mode='constant', cval=0.0, prefilter=True)[source]#

Map the input array to new coordinates by interpolation.

The array of coordinates is used to find, for each point in the output, the corresponding coordinates in the input. The value of the input at those coordinates is determined by spline interpolation of the requested order.

The shape of the output is derived from that of the coordinate array by dropping the first axis. The values of the array along the first axis are the coordinates in the input array at which the output value is found.

Parameters:
  • input (array_like) – The input array.

  • coordinates (array_like) – The coordinates at which input is evaluated.

  • output (array or dtype, optional) – The array in which to place the output, or the dtype of the returned array. By default an array of the same dtype as input will be created.

  • order (int, optional) – The order of the spline interpolation, default is 3. The order has to be in the range 0-5.

  • mode ({'reflect', 'grid-mirror', 'constant', 'grid-constant', 'nearest', 'mirror', 'grid-wrap', 'wrap'}, optional) –

    The mode parameter determines how the input array is extended beyond its boundaries. Default is ‘constant’. Behavior for each valid value is as follows (see additional plots and details on boundary modes):

    ’reflect’ (d c b a | a b c d | d c b a)

    The input is extended by reflecting about the edge of the last pixel. This mode is also sometimes referred to as half-sample symmetric.

    ’grid-mirror’

    This is a synonym for ‘reflect’.

    ’constant’ (k k k k | a b c d | k k k k)

    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter. No interpolation is performed beyond the edges of the input.

    ’grid-constant’ (k k k k | a b c d | k k k k)

    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter. Interpolation occurs for samples outside the input’s extent as well.

    ’nearest’ (a a a a | a b c d | d d d d)

    The input is extended by replicating the last pixel.

    ’mirror’ (d c b | a b c d | c b a)

    The input is extended by reflecting about the center of the last pixel. This mode is also sometimes referred to as whole-sample symmetric.

    ’grid-wrap’ (a b c d | a b c d | a b c d)

    The input is extended by wrapping around to the opposite edge.

    ’wrap’ (d b c d | a b c d | b c a b)

    The input is extended by wrapping around to the opposite edge, but in a way such that the last point and initial point exactly overlap. In this case it is not well defined which sample will be chosen at the point of overlap.

  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.

  • prefilter (bool, optional) – Determines if the input array is prefiltered with spline_filter before interpolation. The default is True, which will create a temporary float64 array of filtered values if order > 1. If setting this to False, the output will be slightly blurred if order > 1, unless the input is prefiltered, i.e. it is the result of calling spline_filter on the original input.

Returns:

map_coordinates – The result of transforming the input. The shape of the output is derived from that of coordinates by dropping the first axis.

Return type:

ndarray

See also

spline_filter, geometric_transform, scipy.interpolate

Notes

For complex-valued input, this function maps the real and imaginary components independently.

New in version 1.6.0: Complex-valued support added.

Examples

>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.arange(12.).reshape((4, 3))
>>> a
array([[  0.,   1.,   2.],
       [  3.,   4.,   5.],
       [  6.,   7.,   8.],
       [  9.,  10.,  11.]])
>>> ndimage.map_coordinates(a, [[0.5, 2], [0.5, 1]], order=1)
array([ 2.,  7.])

Above, the interpolated value of a[0.5, 0.5] gives output[0], while a[2, 1] is output[1].

>>> inds = np.array([[0.5, 2], [0.5, 4]])
>>> ndimage.map_coordinates(a, inds, order=1, cval=-33.3)
array([  2. , -33.3])
>>> ndimage.map_coordinates(a, inds, order=1, mode='nearest')
array([ 2.,  8.])
>>> ndimage.map_coordinates(a, inds, order=1, cval=0, output=bool)
array([ True, False], dtype=bool)

map_coordinates_3d_4d#

fury.utils.map_coordinates_3d_4d(input_array, indices)[source]#

Evaluate input_array at the given indices using trilinear interpolation.

Parameters:
  • input_array (ndarray,) – 3D or 4D array

  • indices (ndarray) –

Returns:

output – 1D or 2D array

Return type:

ndarray

normalize_v3#

fury.utils.normalize_v3(arr)[source]#

Normalize a numpy array of 3 component vectors shape=(N, 3).

Parameters:

array (ndarray) – Shape (N, 3)

Return type:

norm_array

normals_from_actor#

fury.utils.normals_from_actor(act)[source]#

Access normals from actor which uses polydata.

Parameters:

act (actor) –

Returns:

output – Normals

Return type:

array (N, 3)

normals_from_v_f#

fury.utils.normals_from_v_f(vertices, faces)[source]#

Calculate normals from vertices and faces.

Parameters:
  • verices (ndarray) –

  • faces (ndarray) –

Returns:

normals – Shape same as vertices

Return type:

ndarray

normals_to_actor#

fury.utils.normals_to_actor(act, normals)[source]#

Set normals to actor which uses polydata.

Parameters:
  • act (actor) –

  • normals (normals, represented as 2D ndarrays (Nx3) (one per vertex)) –

Return type:

actor

numpy_to_vtk_cells#

fury.utils.numpy_to_vtk_cells(data, is_coords=True)[source]#

Convert numpy array to a vtk cell array.

Parameters:
  • data (ndarray) – points coordinate or connectivity array (e.g triangles).

  • is_coords (ndarray) – Select the type of array. default: True.

Returns:

vtk_cell – connectivity + offset information

Return type:

vtkCellArray

numpy_to_vtk_colors#

fury.utils.numpy_to_vtk_colors(colors)[source]#

Convert Numpy color array to a vtk color array.

Parameters:

colors (ndarray) –

Returns:

vtk_colors

Return type:

vtkDataArray

Notes

If colors are not already in UNSIGNED_CHAR you may need to multiply by 255.

Examples

>>> import numpy as np
>>> from fury.utils import numpy_to_vtk_colors
>>> rgb_array = np.random.rand(100, 3)
>>> vtk_colors = numpy_to_vtk_colors(255 * rgb_array)

numpy_to_vtk_image_data#

fury.utils.numpy_to_vtk_image_data(array, spacing=(1.0, 1.0, 1.0), origin=(0.0, 0.0, 0.0), deep=True)[source]#

Convert numpy array to a vtk image data.

Parameters:
  • array (ndarray) – pixel coordinate and colors values.

  • spacing ((float, float, float) (optional)) – sets the size of voxel (unit of space in each direction x,y,z)

  • origin ((float, float, float) (optional)) – sets the origin at the given point

  • deep (bool (optional)) – decides the type of copy(ie. deep or shallow)

Returns:

vtk_image

Return type:

vtkImageData

numpy_to_vtk_matrix#

fury.utils.numpy_to_vtk_matrix(array)[source]#

Convert a numpy array to a VTK matrix.

numpy_to_vtk_points#

fury.utils.numpy_to_vtk_points(points)[source]#

Convert Numpy points array to a vtk points array.

Parameters:

points (ndarray) –

Returns:

vtk_points

Return type:

vtkPoints()

primitives_count_from_actor#

fury.utils.primitives_count_from_actor(actor)[source]#

Get primitives count from actor’s polydata.

Parameters:

actor

Returns:

primitives count

Return type:

int

primitives_count_to_actor#

fury.utils.primitives_count_to_actor(actor, primitives_count)[source]#

Add primitives count to actor’s polydata.

Parameters:
  • actor

  • primitives_count (int) –

remove_observer_from_actor#

fury.utils.remove_observer_from_actor(actor, id)[source]#

Remove the observer with the given id from the actor.

Parameters:
  • actor (vtkActor) –

  • id (int) – id of the observer to remove

repeat_sources#

fury.utils.repeat_sources(centers, colors, active_scalars=1.0, directions=None, source=None, vertices=None, faces=None, orientation=None)[source]#

Transform a vtksource to glyph.

rgb_to_vtk#

fury.utils.rgb_to_vtk(data)[source]#

RGB or RGBA images to VTK arrays.

Parameters:

data (ndarray) – Shape can be (X, Y, 3) or (X, Y, 4)

Return type:

vtkImageData

rotate#

fury.utils.rotate(actor, rotation=(90, 1, 0, 0))[source]#

Rotate actor around axis by angle.

Parameters:
  • actor (actor or other prop) –

  • rotation (tuple) – Rotate with angle w around axis x, y, z. Needs to be provided in the form (w, x, y, z).

set_actor_origin#

fury.utils.set_actor_origin(actor, center=None)[source]#

Change the origin of an actor to a custom position.

Parameters:
  • actor (Actor) – The actor object to change origin for.

  • center (ndarray, optional, default: None) – The new center position. If None, the origin will be set to the mean of the actor’s vertices.

set_input#

fury.utils.set_input(vtk_object, inp)[source]#

Set Generic input function which takes into account VTK 5 or 6.

Parameters:
  • vtk_object (vtk object) –

  • inp (vtkPolyData or vtkImageData or vtkAlgorithmOutput) –

Return type:

vtk_object

Notes

This can be used in the following way::

from fury.utils import set_input poly_mapper = set_input(PolyDataMapper(), poly_data)

set_polydata_colors#

fury.utils.set_polydata_colors(polydata, colors, array_name='colors')[source]#

Set polydata colors with a numpy array (ndarrays Nx3 int).

Parameters:
  • polydata (vtkPolyData) –

  • colors (colors, represented as 2D ndarrays (Nx3)) – colors are uint8 [0,255] RGB for each points

set_polydata_normals#

fury.utils.set_polydata_normals(polydata, normals)[source]#

Set polydata normals with a numpy array (ndarrays Nx3 int).

Parameters:
  • polydata (vtkPolyData) –

  • normals (normals, represented as 2D ndarrays (Nx3) (one per vertex)) –

set_polydata_primitives_count#

fury.utils.set_polydata_primitives_count(polydata, primitives_count)[source]#

Add primitives count to polydata.

Parameters:
  • polydata (vtkPolyData) –

  • primitives_count (int) –

set_polydata_tangents#

fury.utils.set_polydata_tangents(polydata, tangents)[source]#

Set polydata tangents with a numpy array (ndarrays Nx3 int).

Parameters:
  • polydata (vtkPolyData) –

  • tangents (tangents, represented as 2D ndarrays (Nx3) (one per vertex)) –

set_polydata_tcoords#

fury.utils.set_polydata_tcoords(polydata, tcoords)[source]#

Set polydata texture coordinates with a numpy array (ndarrays Nx2 float).

Parameters:
  • polydata (vtkPolyData) –

  • tcoords (texture coordinates, represented as 2D ndarrays (Nx2)) – (one per vertex range (0, 1))

set_polydata_triangles#

fury.utils.set_polydata_triangles(polydata, triangles)[source]#

Set polydata triangles with a numpy array (ndarrays Nx3 int).

Parameters:
  • polydata (vtkPolyData) –

  • triangles (array (N, 3)) – triangles, represented as 2D ndarrays (Nx3)

set_polydata_vertices#

fury.utils.set_polydata_vertices(polydata, vertices)[source]#

Set polydata vertices with a numpy array (ndarrays Nx3 int).

Parameters:
  • polydata (vtkPolyData) –

  • vertices (vertices, represented as 2D ndarrays (Nx3)) –

shallow_copy#

fury.utils.shallow_copy(vtk_object)[source]#

Create a shallow copy of a given vtkObject object.

tangents_from_actor#

fury.utils.tangents_from_actor(act)[source]#

Access tangents from actor which uses polydata.

Parameters:

act (actor) –

Returns:

output – Tangents

Return type:

array (N, 3)

tangents_from_direction_of_anisotropy#

fury.utils.tangents_from_direction_of_anisotropy(normals, direction)[source]#
Calculate tangents from normals and a 3D vector representing the

direction of anisotropy.

Parameters:
  • normals (normals, represented as 2D ndarrays (Nx3) (one per vertex)) –

  • direction (tuple (3,) or array (3,)) –

Returns:

output – Tangents, represented as 2D ndarrays (Nx3).

Return type:

array (N, 3)

tangents_to_actor#

fury.utils.tangents_to_actor(act, tangents)[source]#

Set tangents to actor which uses polydata.

Parameters:
  • act (actor) –

  • tangents (tangents, represented as 2D ndarrays (Nx3) (one per vertex)) –

triangle_order#

fury.utils.triangle_order(vertices, faces)[source]#

Determine the winding order of a given set of vertices and a triangle.

Parameters:
  • vertices (ndarray) – array of vertices making up a shape

  • faces (ndarray) – array of triangles

Returns:

order – If the order is counter clockwise (CCW), returns True. Otherwise, returns False.

Return type:

int

update_actor#

fury.utils.update_actor(actor, all_arrays=True)[source]#

Update actor.

Parameters:
  • actor (actor) –

  • all_arrays (bool, optional) – if False, only vertices are updated if True, all arrays associated to the actor are updated Default: True

update_polydata_normals#

fury.utils.update_polydata_normals(polydata)[source]#

Generate and update polydata normals.

Parameters:

polydata (vtkPolyData) –

update_surface_actor_colors#

fury.utils.update_surface_actor_colors(actor, colors)[source]#

Update colors of a surface actor.

Parameters:
  • actor (surface actor) –

  • colors (ndarray of shape (N, 3) having colors. The colors should be in the) – range [0, 1].

vertices_from_actor#

fury.utils.vertices_from_actor(actor, as_vtk=False)[source]#

Access to vertices from actor.

Parameters:
  • actor (actor) –

  • as_vtk (bool, optional) – by default, ndarray is returned.

Returns:

vertices

Return type:

ndarray

vtk_matrix_to_numpy#

fury.utils.vtk_matrix_to_numpy(matrix)[source]#

Convert VTK matrix to numpy array.