utils#

Remove the observer with the given id from the actor.

Parameters:

actorvtkActor

idint

id of the observer to remove

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

Parameters:

vtk_object: vtk object

inp: vtkPolyData or vtkImageData or vtkAlgorithmOutput

Returns:

vtk_object

Notes

This can be used in the following way::

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

Convert Numpy points array to a vtk points array.

Parameters:

pointsndarray

Returns:

vtk_pointsvtkPoints()

Convert Numpy color array to a vtk color array.

Parameters:

colors: ndarray

Returns:

vtk_colorsvtkDataArray

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)

Convert numpy array to a vtk cell array.

Parameters:

datandarray

points coordinate or connectivity array (e.g triangles).

is_coordsndarray

Select the type of array. default: True.

Returns:

vtk_cellvtkCellArray

connectivity + offset information

Convert numpy array to a vtk image data.

Parameters:

arrayndarray

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

deepbool (optional)

decides the type of copy(ie. deep or shallow)

Returns:

vtk_imagevtkImageData

Evaluate input_array at the given indices using trilinear interpolation.

Parameters:

input_arrayndarray,

3D or 4D array

indicesndarray

Returns:

outputndarray

1D or 2D array

Create a vtkPolyData with lines and colors.

Parameters:

lineslist

list of N curves represented as 2D ndarrays

colorsarray (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_datavtkPolyData

color_is_scalarbool, true if the color array is a single scalar

Scalar array could be used with a colormap lut None if no color was used

Convert vtk polydata to a list of lines ndarrays.

Parameters:

line_polydatavtkPolyData

Returns:

lineslist

List of N curves represented as 2D ndarrays

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

Parameters:

polydatavtkPolyData

Returns:

outputarray (N, 3)

triangles

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

Parameters:

polydatavtkPolyData

Returns:

outputarray (N, 3)

points, represented as 2D ndarrays

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

Parameters:

polydatavtkPolyData

Returns:

outputarray (N, 2)

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

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

Parameters:

polydatavtkPolyData

Returns:

outputarray (N, 3)

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

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

Parameters:

polydatavtkPolyData

Returns:

outputarray (N, 3)

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

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

Parameters:

polydatavtkPolyData

Returns:

outputarray (N, 3)

Colors. None if no normals in the vtk polydata.

Get a field from a vtk polydata.

Parameters:

polydatavtkPolyData

field_namestr

as_vtkoptional

By default, ndarray is returned.

Returns:

outputndarray or vtkDataArray

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

Add a field to a vtk polydata.

Parameters:

polydatavtkPolyData

field_namestr

field_databool, int, float, double, numeric array or ndarray

array_typevtkArrayType

Add primitives count to polydata.

Parameters:

polydata: vtkPolyData

primitives_countint

Get primitives count from actor’s polydata.

Parameters:

polydata: vtkPolyData

Returns:

primitives countint

Add primitives count to actor’s polydata.

Parameters:

actor: :class: `UI` or `vtkProp3D` actor

primitives_countint

Get primitives count from actor’s polydata.

Parameters:

actor: :class: `UI` or `vtkProp3D` actor

Returns:

primitives countint

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

Parameters:

polydatavtkPolyData

trianglesarray (N, 3)

triangles, represented as 2D ndarrays (Nx3)

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

Parameters:

polydatavtkPolyData

verticesvertices, represented as 2D ndarrays (Nx3)

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

Parameters:

polydatavtkPolyData

normalsnormals, represented as 2D ndarrays (Nx3) (one per vertex)

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

Parameters:

polydatavtkPolyData

tangentstangents, represented as 2D ndarrays (Nx3) (one per vertex)

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

Parameters:

polydatavtkPolyData

colorscolors, represented as 2D ndarrays (Nx3)

colors are uint8 [0,255] RGB for each points

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

Parameters:

polydatavtkPolyData

tcoordstexture coordinates, represented as 2D ndarrays (Nx2)

(one per vertex range (0, 1))

Generate and update polydata normals.

Parameters:

polydatavtkPolyData

Get vtkPolyDataMapper from a vtkPolyData.

Parameters:

polydatavtkPolyData

Returns:

poly_mappervtkPolyDataMapper

Get actor from a vtkPolyDataMapper.

Parameters:

poly_mappervtkPolyDataMapper

Returns:

actoractor

Get actor from a vtkPolyData.

Parameters:

polydatavtkPolyData

Returns:

actoractor

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:

actoractor

Transform a vtksource to glyph.

Apply affine matrix affine to the actor act.

Parameters:

act: Actor

affine: (4, 4) array-like

Homogeneous affine, for 3D object.

Returns:

transformed_act: Actor

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

Homogeneous 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(…, N-1) array

transformed points

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]]]...)

Convert VTK matrix to numpy array.

Convert a numpy array to a VTK matrix.

Get the bounding box sizes of an actor.

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:

shapeslist of tuple of int

The shape (width, height) of every cell content.

aspect_ratiofloat (optional)

Aspect ratio of the grid (width/height). Default: 16:9.

dimtuple of int (optional)

Dimension (nb_rows, nb_cols) of the grid, if provided.

Returns:

ndarray

3D coordinates of every grid cell.

Create a shallow copy of a given vtkObject object.

Rotate actor around axis by angle.

Parameters:

actoractor or other prop

rotationtuple

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

RGB or RGBA images to VTK arrays.

Parameters:

datandarray

Shape can be (X, Y, 3) or (X, Y, 4)

Returns:

vtkImageData

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

Parameters:

arrayndarray

Shape (N, 3)

Returns:

norm_array

Calculate normals from vertices and faces.

Parameters:

vericesndarray

facesndarray

Returns:

normalsndarray

Shape same as vertices

Calculate tangents from normals and a 3D vector representing the

direction of anisotropy.

Parameters:

normalsnormals, represented as 2D ndarrays (Nx3) (one per vertex)

directiontuple (3,) or array (3,)

Returns:

outputarray (N, 3)

Tangents, represented as 2D ndarrays (Nx3).

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

Parameters:

verticesndarray

array of vertices making up a shape

facesndarray

array of triangles

Returns:

orderint

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

Change the vertices order of a given triangle.

Parameters:

trianglendarray, shape(1, 3)

array of 3 vertices making up a triangle

Returns:

new_trianglendarray, shape(1, 3)

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

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:

verticesndarray

array of vertices corresponding to a shape

trianglesndarray

array of triangles corresponding to a shape

clockwisebool

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

Returns:

corrected_trianglesndarray

The corrected order of the vert parameter

Access to vertices from actor.

Parameters:

actoractor

as_vtk: bool, optional

by default, ndarray is returned.

Returns:

verticesndarray

Access colors from actor which uses polydata.

Parameters:

actoractor

array_name: str

as_vtk: bool, optional

by default, numpy array is returned.

Returns:

outputarray (N, 3)

Colors

Access normals from actor which uses polydata.

Parameters:

actactor

Returns:

outputarray (N, 3)

Normals

Access tangents from actor which uses polydata.

Parameters:

actactor

Returns:

outputarray (N, 3)

Tangents

Access array from actor which uses polydata.

Parameters:

actoractor

array_name: str

as_vtk_type: bool, optional

by default, ndarray is returned.

Returns:

outputarray (N, 3)

Set normals to actor which uses polydata.

Parameters:

actactor

normalsnormals, represented as 2D ndarrays (Nx3) (one per vertex)

Returns:

actor

Set tangents to actor which uses polydata.

Parameters:

actactor

tangentstangents, represented as 2D ndarrays (Nx3) (one per vertex)

Compute Bounds of actor.

Parameters:

actoractor

Update actor.

Parameters:

actoractor

all_arrays: bool, optional

if False, only vertices are updated if True, all arrays associated to the actor are updated Default: True

Return Bounds of actor.

Parameters:

actoractor

Returns:

verticesndarray

Returns the actor wireframe.

Parameters:

actoractor

Returns:

actoractor

Update colors of a surface actor.

Parameters:

actorsurface actor

colorsndarray of shape (N, 3) having colors. The colors should be in the

range [0, 1].

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_lenint

length of points ndarray

colorsNone 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_arrayvtkDataArray

vtk scalar array with name ‘colors’.

global_opacityfloat

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.

Method to check if the passed actor is UI or vtkProp3D

Parameters:

actor: :class: `UI` or `vtkProp3D`

actor that is to be checked

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.

Returns the min-max normalization of data along an axis.

Parameters:

data: ndarray

2D array

axis: int, optional

axis for the function to be applied on

Returns:

outputndarray