animation#

Bases: object

Keyframe animation class.

Animation is responsible for keyframe animations for a single or a group of actors. It’s used to handle multiple attributes and properties of Fury actors such as transformations, color, and scale. It also accepts custom data and interpolates them, such as temperature. Linear interpolation is used by default to interpolate data between the main keyframes.

Attributes:

actorsActor or list[Actor], optional, default: None

Return a list of actors.

lengthfloat or int, default: None, optional

the fixed length of the animation. If set to None, the animation will get its duration from the keyframes being set.

loopbool, optional, default: True

Get loop condition of the current animation.

motion_path_resint, default: None

the number of line segments used to visualizer the animation’s motion path (visualizing position).

property actors#

Return a list of actors.

Returns:

list:

List of actors controlled by the Animation.

add(item)[source]#

Add an item to the Animation. This item can be an Actor, Animation, list of Actors, or a list of Animations.

Parameters:

item: Animation, vtkActor, list[Animation], or list[vtkActor]

Actor/s to be animated by the Animation.

add_actor(actor, *, static=False)[source]#

Add an actor or list of actors to the Animation.

Parameters:

actor: vtkActor or list(vtkActor)

Actor/s to be animated by the Animation.

static: bool

Indicated whether the actor should be animated and controlled by the animation or just a static actor that gets added to the scene along with the Animation.

add_child_animation(animation)[source]#

Add child Animation or list of Animations.

Parameters:

animation: Animation or list[Animation]

Animation/s to be added.

add_static_actor(actor)[source]#

Add an actor or list of actors as static actor/s which will not be controlled nor animated by the Animation. All static actors will be added to the scene when the Animation is added to the scene.

Parameters:

actor: vtkActor or list(vtkActor)

Static actor/s.

add_to_scene(scene)[source]#

Add this Animation, its actors and sub Animations to the scene

add_to_scene_at(timestamp)[source]#

Set timestamp for adding Animation to scene event.

Parameters:

timestamp: float

Timestamp of the event.

add_update_callback(callback, prop=None)[source]#

Add a function to be called each time animation is updated This function must accept only one argument which is the current value of the named property.

Parameters:

callback: callable

The function to be called whenever the animation is updated.

prop: str, optional, default: None

The name of the property.

Notes

If no attribute name was provided, current time of the animation will be provided instead of current value for the callback.

property child_animations: list[Animation]#

Return a list of child Animations.

Returns:

list:

List of child Animations of this Animation.

property current_timestamp#

Return the current time of the animation.

Returns:

float

The current time of the animation.

property duration#

Return the duration of the animation.

Returns:

float

The duration of the animation.

get_color(t)[source]#

Return the interpolated color.

Parameters:

t: float

The time to interpolate color value at.

Returns:

ndarray(1, 3):

The interpolated color.

get_current_value(attrib)[source]#

Return the value of an attribute at current time.

Parameters:

attrib: str

The attribute name.

get_keyframes(*, attrib=None)[source]#

Get a keyframe for a specific or all attributes.

Parameters:

attrib: str, optional, default: None

The name of the attribute. If None, all keyframes for all set attributes will be returned.

get_opacity(t)[source]#

Return the opacity value.

Parameters:

t: float

The time to interpolate opacity at.

Returns:

ndarray(1, 1):

The interpolated opacity.

get_position(t)[source]#

Return the interpolated position.

Parameters:

t: float

The time to interpolate position at.

Returns:

ndarray(1, 3):

The interpolated position.

get_rotation(t, as_quat=False)[source]#

Return the interpolated rotation.

Parameters:

t: float

the time to interpolate rotation at.

as_quat: bool

Returned rotation will be as quaternion if True.

Returns:

ndarray(1, 3):

The interpolated rotation as Euler degrees by default.

get_scale(t)[source]#

Return the interpolated scale.

Parameters:

t: float

The time to interpolate scale at.

Returns:

ndarray(1, 3):

The interpolated scale.

get_value(attrib, timestamp)[source]#

Return the value of an attribute at any given timestamp.

Parameters:

attrib: str

The attribute name.

timestamp: float

The timestamp to interpolate at.

is_inside_scene_at(timestamp)[source]#

Check if the Animation is set to be inside the scene at a specific timestamp.

Returns:

bool

True if the Animation is set to be inside the scene at the given timestamp.

Notes

If the parent Animation is set to be out of the scene at that time, all of their child animations will be out of the scene as well.

is_interpolatable(attrib)[source]#

Check whether a property is interpolatable.

Parameters:

attrib: str

The name of the property.

Returns:

bool

True if the property is interpolatable by the Animation.

Notes

True means that it’s safe to use Interpolator.interpolate(t) for the specified property. And False means the opposite.

property loop#

Get loop condition of the current animation.

Returns:

bool

Whether the animation in loop mode (True) or play one mode (False).

property parent_animation#

Return the hierarchical parent Animation for current Animation.

Returns:

Animation:

The parent Animation.

remove_actor(actor)[source]#

Remove an actor from the Animation.

Parameters:

actor: vtkActor

Actor to be removed from the Animation.

remove_actors()[source]#

Remove all actors from the Animation

remove_animations()[source]#

Remove all child Animations from the Animation

remove_from_scene(scene)[source]#

Remove Animation, its actors and sub Animations from the scene

remove_from_scene_at(timestamp)[source]#

Set timestamp for removing Animation to scene event.

Parameters:

timestamp: float

Timestamp of the event.

set_color(timestamp, color, **kwargs)[source]#

Set color keyframe at a specific timestamp.

Parameters:

timestamp: float

Timestamp of the keyframe

color: ndarray, shape(1, 3)

Color keyframe value associated with the timestamp.

set_color_interpolator(interpolator, *, is_evaluator=False)[source]#

Set the color interpolator.

Parameters:

interpolator: callable

The generator function of the interpolator that would handle the color keyframes.

is_evaluator: bool, optional

Specifies whether the interpolator is time-only based evaluation function that does not depend on keyframes.

Examples

>>> Animation.set_color_interpolator(lab_color_interpolator) 

set_color_keyframes(keyframes)[source]#

Set a dict of color keyframes at once. Should be in the following form: {timestamp_1: color_1, timestamp_2: color_2}

Parameters:

keyframes: dict

A dict with timestamps as keys and color as values.

Examples

>>> import numpy as np
>>> color_keyframes = {1, (1, 0, 1), 3, (0, 0, 1)}
>>> Animation.set_color_keyframes(color_keyframes) 

set_interpolator(attrib, interpolator, *, is_evaluator=False, **kwargs)[source]#

Set keyframes interpolator for a certain property

Parameters:

attrib: str

The name of the property.

interpolator: callable

The generator function of the interpolator to be used to interpolate/evaluate keyframes.

is_evaluator: bool, optional

Specifies whether the interpolator is time-only based evaluation function that does not depend on keyframes such as:

def get_position(t):

return np.array([np.sin(t), np.cos(t) * 5, 5])

Other Parameters:

spline_degree: int, optional

The degree of the spline in case of setting a spline interpolator.

Notes

If an evaluator is used to set the values of actor’s properties such as position, scale, color, rotation, or opacity, it has to return a value with the same shape as the evaluated property, i.e.: for scale, it has to return an array with shape 1x3, and for opacity, it has to return a 1x1, an int, or a float value.

Examples

>>> Animation.set_interpolator('position', linear_interpolator) 
>>> pos_fun = lambda t: np.array([np.sin(t), np.cos(t), 0]) 
>>> Animation.set_interpolator('position', pos_fun) 

set_keyframe(attrib, timestamp, value, *, update_interpolator=True, **kwargs)[source]#

Set a keyframe for a certain attribute.

Parameters:

attrib: str

The name of the attribute.

timestamp: float

Timestamp of the keyframe.

value: ndarray or float or bool

Value of the keyframe at the given timestamp.

update_interpolator: bool, optional

Interpolator will be reinitialized if True

Other Parameters:

in_cp: ndarray, shape (1, M), optional

The in control point in case of using cubic Bézier interpolator.

out_cp: ndarray, shape (1, M), optional

The out control point in case of using cubic Bézier interpolator.

in_tangent: ndarray, shape (1, M), optional

The in tangent at that position for the cubic spline curve.

out_tangent: ndarray, shape (1, M), optional

The out tangent at that position for the cubic spline curve.

set_keyframes(attrib, keyframes)[source]#

Set multiple keyframes for a certain attribute.

Parameters:

attrib: str

The name of the attribute.

keyframes: dict

A dict object containing keyframes to be set.

Notes

Keyframes can be on any of the following forms: >>> import numpy as np >>> key_frames_simple = {1: [1, 2, 1], 2: [3, 4, 5]} >>> key_frames_bezier = {1: {‘value’: [1, 2, 1]}, … 2: {‘value’: [3, 4, 5], ‘in_cp’: [1, 2, 3]}} >>> pos_keyframes = {1: np.array([1, 2, 3]), 3: np.array([5, 5, 5])} >>> Animation.set_keyframes(‘position’, pos_keyframes) # doctest: +SKIP

set_opacity(timestamp, opacity, **kwargs)[source]#

Set opacity keyframe at a specific timestamp.

Parameters:

timestamp: float

Timestamp of the keyframe

opacity: ndarray, shape(1, 3)

Opacity keyframe value associated with the timestamp.

set_opacity_interpolator(interpolator, *, is_evaluator=False)[source]#

Set the opacity interpolator.

Parameters:

interpolator: callable

The generator function of the interpolator that would handle the opacity keyframes.

is_evaluator: bool, optional

Specifies whether the interpolator is time-only based evaluation function that does not depend on keyframes.

Examples

>>> Animation.set_opacity_interpolator(step_interpolator) 

set_opacity_keyframes(keyframes)[source]#

Set a dict of opacity keyframes at once. Should be in the following form: {timestamp_1: opacity_1, timestamp_2: opacity_2}

Parameters:

keyframes: dict(float: ndarray, shape(1, 1) or float or int)

A dict with timestamps as keys and opacities as values.

Notes

Opacity values should be between 0 and 1.

Examples

>>> opacity = {1, (1, 1, 1), 3, (2, 2, 3)}
>>> Animation.set_scale_keyframes(opacity) 

set_position(timestamp, position, **kwargs)[source]#

Set a position keyframe at a specific timestamp.

Parameters:

timestamp: float

Timestamp of the keyframe

position: ndarray, shape (1, 3)

Position value

Other Parameters:

in_cp: float

The control point in case of using cubic Bézier interpolator when time exceeds this timestamp.

out_cp: float

The control point in case of using cubic Bézier interpolator when time precedes this timestamp.

in_tangent: ndarray, shape (1, M), optional

The in tangent at that position for the cubic spline curve.

out_tangent: ndarray, shape (1, M), optional

The out tangent at that position for the cubic spline curve.

Notes

in_cp and out_cp only needed when using the cubic bezier interpolation method.

set_position_interpolator(interpolator, *, is_evaluator=False, **kwargs)[source]#

Set the position interpolator.

Parameters:

interpolator: callable

The generator function of the interpolator that would handle the

position keyframes.

is_evaluator: bool, optional

Specifies whether the interpolator is time-only based evaluation function that does not depend on keyframes.

Other Parameters:

degree: int

The degree of the spline interpolation in case of setting the spline_interpolator.

Examples

>>> Animation.set_position_interpolator(spline_interpolator, degree=5) 

set_position_keyframes(keyframes)[source]#

Set a dict of position keyframes at once. Should be in the following form: {timestamp_1: position_1, timestamp_2: position_2}

Parameters:

keyframes: dict

A dict with timestamps as keys and positions as values.

Examples

>>> pos_keyframes = {1, (0, 0, 0), 3, (50, 6, 6)}
>>> Animation.set_position_keyframes(pos_keyframes) 

set_rotation(timestamp, rotation, **kwargs)[source]#

Set a rotation keyframe at a specific timestamp.

Parameters:

timestamp: float

Timestamp of the keyframe

rotation: ndarray, shape(1, 3) or shape(1, 4)

Rotation data in euler degrees with shape(1, 3) or in quaternions with shape(1, 4).

Notes

Euler rotations are executed by rotating first around Z then around X, and finally around Y.

set_rotation_as_vector(timestamp, vector, **kwargs)[source]#

Set a rotation keyframe at a specific timestamp.

Parameters:

timestamp: float

Timestamp of the keyframe

vector: ndarray, shape(1, 3)

Directional vector that describes the rotation.

set_rotation_interpolator(interpolator, *, is_evaluator=False)[source]#

Set the rotation interpolator .

Parameters:

interpolator: callable

The generator function of the interpolator that would handle the rotation (orientation) keyframes.

is_evaluator: bool, optional

Specifies whether the interpolator is time-only based evaluation function that does not depend on keyframes.

Examples

>>> Animation.set_rotation_interpolator(slerp) 

set_scale(timestamp, scalar, **kwargs)[source]#

Set a scale keyframe at a specific timestamp.

Parameters:

timestamp: float

Timestamp of the keyframe

scalar: ndarray, shape(1, 3)

Scale keyframe value associated with the timestamp.

set_scale_interpolator(interpolator, *, is_evaluator=False)[source]#

Set the scale interpolator.

Parameters:

interpolator: callable

The generator function of the interpolator that would handle the scale keyframes.

is_evaluator: bool, optional

Specifies whether the interpolator is time-only based evaluation function that does not depend on keyframes.

Examples

>>> Animation.set_scale_interpolator(step_interpolator) 

set_scale_keyframes(keyframes)[source]#

Set a dict of scale keyframes at once. Should be in the following form: {timestamp_1: scale_1, timestamp_2: scale_2}

Parameters:

keyframes: dict

A dict with timestamps as keys and scales as values.

Examples

>>> scale_keyframes = {1, (1, 1, 1), 3, (2, 2, 3)}
>>> Animation.set_scale_keyframes(scale_keyframes) 

property static_actors#

Return a list of static actors.

Returns:

list:

List of static actors.

property timeline#

Return the Timeline handling the current animation.

Returns:

Timeline:

The Timeline handling the current animation, None, if there is no associated Timeline.

update_animation(*, time=None)[source]#

Update the animation.

Update the animation at a certain time. This will make sure all attributes are calculated and set to the actors at that given time.

Parameters:

time: float or int, optional, default: None

The time to update animation at. If None, the animation will play without adding it to a Timeline.

update_duration()[source]#

Update and return the duration of the Animation.

Returns:

float

The duration of the animation.

update_motion_path()[source]#

Update motion path visualization actor

Bases: Animation

Camera keyframe animation class.

This is used for animating a single camera using a set of keyframes.

Attributes:

cameraCamera, optional, default: None

Return the camera assigned to this animation.

lengthfloat or int, default: None, optional

the fixed length of the animation. If set to None, the animation will get its duration from the keyframes being set.

loopbool, optional, default: True

Get loop condition of the current animation.

motion_path_resint, default: None

the number of line segments used to visualizer the animation’s motion path (visualizing position).

property camera: vtkCamera#

Return the camera assigned to this animation.

Returns:

Camera:

The camera that is being animated by this CameraAnimation.

get_focal(t)[source]#

Return the interpolated camera’s focal position.

Parameters:

t: float

The time to interpolate at.

Returns:

ndarray(1, 3):

The interpolated camera’s focal position.

Notes

The returned focal position does not necessarily reflect the current camera’s focal position, but the expected one.

get_view_up(t)[source]#

Return the interpolated camera’s view-up directional vector.

Parameters:

t: float

The time to interpolate at.

Returns:

ndarray(1, 3):

The interpolated camera view-up directional vector.

Notes

The returned focal position does not necessarily reflect the actual camera view up directional vector, but the expected one.

set_focal(timestamp, position, **kwargs)[source]#

Set camera’s focal position keyframe.

Parameters:

timestamp: float

The time to interpolate opacity at.

position: ndarray, shape(1, 3)

The camera position

set_focal_interpolator(interpolator, *, is_evaluator=False)[source]#

Set the camera focal position interpolator.

Parameters:

interpolator: callable

The generator function of the interpolator that would handle the interpolation of the camera focal position keyframes.

is_evaluator: bool, optional

Specifies whether the interpolator is time-only based evaluation function that does not depend on keyframes.

set_focal_keyframes(keyframes)[source]#

Set multiple camera focal position keyframes at once. Should be in the following form: {timestamp_1: focal_1, timestamp_2: focal_1, …}

Parameters:

keyframes: dict

A dict with timestamps as keys and camera focal positions as values.

Examples

>>> focal_pos = {0, (1, 1, 1), 3, (20, 0, 0)}
>>> CameraAnimation.set_focal_keyframes(focal_pos) 

set_view_up(timestamp, direction, **kwargs)[source]#

Set the camera view-up direction keyframe.

Parameters:

timestamp: float

The time to interpolate at.

direction: ndarray, shape(1, 3)

The camera view-up direction

set_view_up_interpolator(interpolator, *, is_evaluator=False)[source]#

Set the camera up-view vector animation interpolator.

Parameters:

interpolator: callable

The generator function of the interpolator that would handle the interpolation of the camera view-up keyframes.

is_evaluator: bool, optional

Specifies whether the interpolator is time-only based evaluation function that does not depend on keyframes.

set_view_up_keyframes(keyframes)[source]#

Set multiple camera view up direction keyframes. Should be in the following form: {timestamp_1: view_up_1, timestamp_2: view_up_2, …}

Parameters:

keyframes: dict

A dict with timestamps as keys and camera view up vectors as values.

Examples

>>> view_ups = {0, np.array([1, 0, 0]), 3, np.array([0, 1, 0])} 
>>> CameraAnimation.set_view_up_keyframes(view_ups) 

update_animation(*, time=None)[source]#

Update the camera animation.

Parameters:

time: float or int, optional, default: None

The time to update the camera animation at. If None, the animation will play.

Bases: object

Keyframe animation Timeline.

Timeline is responsible for handling the playback of keyframes animations. It has multiple playback options which makes it easy to control the playback, speed, state of the animation with/without a GUI playback panel.

Attributes:

animationsAnimation or list[Animation], optional, default: None

Return a list of Animations.

playback_panelbool, optional

If True, the timeline will have a playback panel set, which can be used to control the playback of the timeline.

lengthfloat or int, default: None, optional

the fixed length of the timeline. If set to None, the timeline will get

its length from the animations that it controls automatically.

loopbool, optional

Get loop condition of the timeline.

add_animation(animation)[source]#

Add Animation or list of Animations.

Parameters:

animation: Animation or list[Animation] or tuple[Animation]

Animation/s to be added.

add_to_scene(scene)[source]#

Add Timeline and all of its Animations to the scene

property animations: list[Animation]#

Return a list of Animations.

Returns:

list:

List of Animations controlled by the timeline.

property current_timestamp#

Get current timestamp of the Timeline.

Returns:

float

The current time of the Timeline.

property duration#

Return the duration of the Timeline.

Returns:

float

The duration of the Timeline.

property has_playback_panel#

Return whether the Timeline has a playback panel.

Returns:

bool: ‘True’ if the Timeline has a playback panel. otherwise, ‘False’

property loop#

Get loop condition of the timeline.

Returns:

bool

Whether the playback is in loop mode (True) or play one mode (False).

pause()[source]#

Pause the animation

property paused#

Return whether the Timeline is paused.

Returns:

bool

True if the Timeline is paused.

play()[source]#

Play the animation

property playing#

Return whether the Timeline is playing.

Returns:

bool

True if the Timeline is playing.

record(*, fname=None, fps=30, speed=1.0, size=(900, 768), order_transparent=True, multi_samples=8, max_peels=4, show_panel=False)[source]#

Record the animation

Parameters:

fnamestr, optional

The file name. Save a GIF file if name ends with ‘.gif’, or mp4 video if name ends with’.mp4’. If None, this method will only return an array of frames.

fpsint, optional

The number of frames per second of the record.

size(int, int)

(width, height) of the window. Default is (900, 768).

speedfloat, optional, default 1.0

The speed of the animation.

order_transparentbool, optional

Default False. Use depth peeling to sort transparent objects. If True also enables anti-aliasing.

multi_samplesint, optional

Number of samples for anti-aliasing (Default 8). For no anti-aliasing use 0.

max_peelsint, optional

Maximum number of peels for depth peeling (Default 4).

show_panelbool, optional, default False

Controls whether to show the playback (if True) panel of hide it (if False)

Returns:

ndarray:

The recorded frames.

Notes

It’s recommended to use 50 or 30 FPS while recording to a GIF file.

remove_from_scene(scene)[source]#

Remove Timeline and all of its Animations to the scene

restart()[source]#

Restart the animation

seek(timestamp)[source]#

Set the current timestamp of the Timeline.

Parameters:

timestamp: float

The time to seek.

seek_percent(percent)[source]#

Seek a percentage of the Timeline’s final timestamp.

Parameters:

percent: float

Value from 1 to 100.

property speed#

Return the speed of the timeline’s playback.

Returns:

float

The speed of the timeline’s playback.

stop()[source]#

Stop the animation

property stopped#

Return whether the Timeline is stopped.

Returns:

bool

True if Timeline is stopped.

update(*, force=False)[source]#

Update the timeline.

Update the Timeline and all the animations that it controls. As well as the playback of the Timeline (if exists).

Parameters:

force: bool, optional, default: False

If True, the timeline will update even when the timeline is paused or stopped and hence, more resources will be used.

update_duration()[source]#

Update and return the duration of the Timeline.

Returns:

float

The duration of the Timeline.