Last modified: January 03, 2026

This article is written in: 🇺🇸

Animations and Time-Varying Data

VTK offers a set of tools to create animations and visualize time-varying data. This is particularly useful in scenarios such as:

1. Keyframe Animation
2. Temporal Data Visualization
3. Animation Export

Why you should care: animation turns a static “look at this” into a guided “watch what changes.” It’s how you show cause and effect, highlight progression, compare states, and keep viewers oriented as data evolves. And for time-varying datasets, animation isn’t decoration, it’s often the only way to truly understand trends, cycles, and transitions.

A good rule of thumb:

• Do use animation to reveal structure (what changes, when, and how fast).
• Don’t animate just because you can, motion without intent can make analysis harder.

Keyframe Animation

Keyframe animation is a technique used to create smooth transitions between different states of a visualization. This approach is particularly beneficial for visual storytelling or creating explanatory visualizations, where the evolution of data over time needs to be clearly communicated.

What makes keyframes so practical is that you don’t animate every moment manually, you define meaningful “poses” (keyframes), and the system fills in the in-between. That keeps your story intentional: you’re choosing the moments that matter (start state, mid state, end state) and letting interpolation handle smooth motion.

Concepts

The core classes involved in keyframe animation using VTK (Visualization Toolkit) are:

• vtkAnimationCue: Represents an individual animation sequence with defined start and end times. An animation cue controls how a particular property of an object changes over a specified period.
• vtkAnimationScene: Manages multiple animation cues and orchestrates the overall animation playback. It handles the timing and sequencing of various animation cues to create a cohesive animation.

A useful way to think about this:

• A scene is the timeline (global time, frame rate, looping).
• A cue is a clip on that timeline (what changes during that time window).
• A callback is the “hands” doing the work each tick (update radius, move camera, change opacity).

Basic Workflow

1. Set up the animation scene by creating an instance of vtkAnimationScene, and configuring its playback mode, loop setting, and frame rate.
2. Create animation cues for each property you want to animate by making an instance of vtkAnimationCue, and defining the start and end times for each cue.
3. Add the animation cues to the scene by including each vtkAnimationCue in the vtkAnimationScene.
4. Define callbacks to update the properties of the visual objects at each frame of the animation.

Do/don’t guidance that saves headaches:

• Do decide what “time” means (seconds, frames, simulation steps) and keep it consistent.
• Do separate “compute value” from “apply value” inside callbacks (easier to debug).
• Don’t call Render() more than you need to, ideally once per tick, not multiple times per property.

Example: Animating a Sphere's Radius

Below is an example demonstrating how to animate a sphere's radius using VTK. This example sets up an animation scene, creates a cue for the sphere's radius, and defines the necessary callbacks to update the radius over time.

import vtk

# Create a sphere
sphereSource = vtk.vtkSphereSource()
sphereSource.SetRadius(5)
sphereSource.SetPhiResolution(30)
sphereSource.SetThetaResolution(30)

# Create a mapper and actor
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(sphereSource.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)

# Create a renderer, render window, and interactor
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)

# Add the actor to the scene
renderer.AddActor(actor)
renderer.SetBackground(0.1, 0.2, 0.4)  # Background color

# Set up the animation scene
animationScene = vtk.vtkAnimationScene()
animationScene.SetModeToSequence()
animationScene.SetLoop(0)  # No looping
animationScene.SetFrameRate(60)
animationScene.SetStartTime(0)
animationScene.SetEndTime(2)  # Ensuring the scene's end time matches the cue's end time

# Define the callback to update the sphere's radius
def update_radius(caller, event):
    cue = caller
    t = cue.GetAnimationTime()

    # Normalize t to [0, 1] across the cue duration
    t0 = cue.GetStartTime()
    t1 = cue.GetEndTime()
    alpha = 0.0 if t1 == t0 else (t - t0) / (t1 - t0)

    # Example: increase radius linearly from 5 -> 10
    new_radius = 5 + 5 * alpha
    sphereSource.SetRadius(new_radius)

    renderWindow.Render()

# Set up an animation cue for the radius
radiusCue = vtk.vtkAnimationCue()
radiusCue.SetStartTime(0)
radiusCue.SetEndTime(2)
radiusCue.AddObserver(vtk.vtkCommand.AnimationCueTickEvent, update_radius)
animationScene.AddCue(radiusCue)

# Initialize the interactor and start the animation
renderWindow.Render()
animationScene.Play()
renderWindowInteractor.Start()

In this example:

• A sphere is created using vtkSphereSource.
• A mapper and actor are set up to render the sphere.
• A vtkAnimationScene is created and configured.
• A vtkAnimationCue is created for animating the sphere's radius over a 2-second period.
• A callback function update_radius is defined to update the sphere's radius based on the animation time.
• The animation cue is added to the animation scene.
• Finally, the animation is played, and the render window interactor is started.

https://github.com/user-attachments/assets/dc1e2d17-3c1c-40ee-b23b-8def5a67116e

Once you can animate one property (radius), you can animate almost anything, camera position, clipping planes, opacity ramps, color transfer functions, glyph scale, slice index, making it easy to build explainers and “guided tours” of a dataset.

Temporal Data Visualization

Temporal data visualization involves displaying data that varies over time. This technique is particularly useful for visualizing simulations, time-series data, or dynamic systems, providing insights into how data evolves and changes across different time steps.

The main “why”: time is an extra dimension of meaning. Without temporal playback, you’re forced to compare snapshots manually and you miss continuity, how quickly something emerges, whether changes are smooth or abrupt, whether patterns repeat, and whether cause precedes effect.

Do/don’t guidance:

• Do decide whether you want step-by-step truth (discrete timesteps) or smooth playback (interpolation).
• Don’t interpolate blindly if your data represents events or discontinuities (e.g., sudden fractures, threshold triggers). Interpolation can “invent” states that never existed.

Classes and Concepts

The main classes used for temporal data visualization in VTK (Visualization Toolkit) are:

• vtkTemporalDataSet: Represents a collection of datasets associated with different time steps. This class allows for organizing and managing temporal data effectively.
• vtkTemporalInterpolator: Interpolates between datasets at different time steps to create smooth transitions. This is essential for creating fluid animations and seamless visual transitions.

(Practical note: VTK’s time support is also strongly tied to the pipeline’s time requests, many readers/filters expose time steps and respond to requested update time. So the cleanest temporal workflows often come from letting the pipeline drive time, rather than manually “setting a timestep” on a reader that doesn’t support it.)

Basic Workflow

1. Load temporal data using appropriate readers to import the datasets.
2. Set up data interpolation (optional) to ensure smooth transitions between time steps by configuring a temporal interpolator.
3. Create a mapper and actor to visualize the data effectively.
4. Render the scene and animate through the time steps to visualize the temporal data.

Example: Loading and Visualizing a Temporal Dataset

Below is an example demonstrating how to load and visualize a temporal dataset using VTK. This example involves reading a temporal dataset, setting up a mapper and actor, and rendering the data.

import vtk

# Load temporal dataset
reader = vtk.vtkXMLMultiBlockDataReader()
reader.SetFileName("data.vtm")
reader.UpdateInformation()

# Optionally set up a temporal interpolator for smooth transitions
interpolator = vtk.vtkTemporalInterpolator()
interpolator.SetInputConnection(reader.GetOutputPort())

# Create a mapper and actor
mapper = vtk.vtkCompositePolyDataMapper2()
mapper.SetInputConnection(interpolator.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)

# Create a renderer, render window, and interactor
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)

# Add the actor to the scene
renderer.AddActor(actor)
renderer.SetBackground(0.1, 0.2, 0.4)  # Background color

# Get available time steps from the pipeline (if provided)
info = reader.GetOutputInformation(0)
time_steps = info.Get(vtk.vtkStreamingDemandDrivenPipeline.TIME_STEPS())

# Initialize and start the render window interactor
renderWindow.Render()
renderWindowInteractor.Initialize()

# Set up animation for the temporal data
animationScene = vtk.vtkAnimationScene()
animationScene.SetModeToSequence()
animationScene.SetLoop(1)  # Loop the animation
animationScene.SetFrameRate(24)  # 24 frames per second

# Define the callback to update the time step
def update_time_step(caller, event):
    cue = caller
    t = cue.GetAnimationTime()

    # Map animation time to an index in the available time steps
    if time_steps:
        t0 = cue.GetStartTime()
        t1 = cue.GetEndTime()
        alpha = 0.0 if t1 == t0 else (t - t0) / (t1 - t0)
        idx = int(alpha * (len(time_steps) - 1))
        requested_time = time_steps[idx]

        # Request this time from the pipeline
        out_info = interpolator.GetOutputInformation(0)
        out_info.Set(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_TIME_STEP(), requested_time)

        interpolator.Update()
        renderWindow.Render()

# Set up an animation cue for the time steps
timeCue = vtk.vtkAnimationCue()
timeCue.SetStartTime(0)
timeCue.SetEndTime(5)  # Example duration; tune to your dataset
timeCue.AddObserver(vtk.vtkCommand.AnimationCueTickEvent, update_time_step)
animationScene.AddCue(timeCue)

# Play the animation
animationScene.Play()
renderWindowInteractor.Start()

In this example:

• A temporal dataset is loaded using vtkXMLMultiBlockDataReader.
• An optional vtkTemporalInterpolator is set up to create smooth transitions between time steps.
• A mapper and actor are created to visualize the data.
• A renderer, render window, and interactor are initialized.
• An animation scene is set up to handle the temporal data animation.
• A callback function update_time_step is defined to request updates at different time steps.
• An animation cue is created to manage the animation timing.
• The animation is played, and the render window interactor is started.

https://github.com/user-attachments/assets/c00b6a01-832a-4dad-9ce2-3a38b5a5e244

When you use the pipeline’s time keys, you’re working with VTK “the VTK way”, filters that understand time can cooperate, and you’re less likely to rely on reader-specific methods that don’t exist.

Animation Export

Animation export involves saving an animation as a video or image sequence. This capability is crucial for sharing animations with others or for viewing them offline. It allows for easy distribution and playback of visualizations created in VTK (Visualization Toolkit).

The big “why”: a visualization that can’t be shared is often a visualization that can’t create impact. Export lets you put results into slide decks, papers, dashboards, tickets, or async reviews, so people can see what you see without needing your exact runtime environment.

Do/don’t guidance:

• Do export image sequences when quality matters (then encode later).
• Don’t assume video encoding is always available, some VTK builds lack FFMPEG support, so have a PNG-sequence fallback.

Classes and Concepts

The main classes used for exporting animations in VTK are:

• vtkWindowToImageFilter: Captures the contents of a render window as an image. This class is essential for converting the rendered scene into a format suitable for saving.
• vtkAVIWriter, vtkOggTheoraWriter, vtkFFMPEGWriter: These classes save image sequences as video files in different formats. They provide the functionality to encode and write video files.

Basic Workflow

1. Capture the render window using vtkWindowToImageFilter to save the current state of the render window as an image.
2. Set up a writer by choosing an appropriate one (vtkAVIWriter, vtkOggTheoraWriter, vtkFFMPEGWriter, etc.) to save the captured images as a video file.
3. Write the images or compile them into a video file using the chosen writer.

Example: Capturing a Render Window as an Image

Below is an example demonstrating how to capture the current render window as an image and save it using vtkPNGWriter.

import vtk

# Set up the render window and renderer
renderWindow = vtk.vtkRenderWindow()
renderer = vtk.vtkRenderer()
renderWindow.AddRenderer(renderer)

# Add an example actor to the scene
sphereSource = vtk.vtkSphereSource()
sphereMapper = vtk.vtkPolyDataMapper()
sphereMapper.SetInputConnection(sphereSource.GetOutputPort())
sphereActor = vtk.vtkActor()
sphereActor.SetMapper(sphereMapper)
renderer.AddActor(sphereActor)
renderer.SetBackground(0.1, 0.2, 0.4)  # Background color

# Render the scene
renderWindow.Render()

# Set up window to image filter
windowToImageFilter = vtk.vtkWindowToImageFilter()
windowToImageFilter.SetInput(renderWindow)
windowToImageFilter.Update()

# Write the image to a file
writer = vtk.vtkPNGWriter()
writer.SetFileName("screenshot.png")
writer.SetInputConnection(windowToImageFilter.GetOutputPort())
writer.Write()

Example: Exporting an Animation to a Video File

Below is an example demonstrating how to capture a series of frames and export them as a video file using vtkFFMPEGWriter.

import vtk

# Set up the render window and renderer
renderWindow = vtk.vtkRenderWindow()
renderer = vtk.vtkRenderer()
renderWindow.AddRenderer(renderer)

# Add an example actor to the scene
sphereSource = vtk.vtkSphereSource()
sphereMapper = vtk.vtkPolyDataMapper()
sphereMapper.SetInputConnection(sphereSource.GetOutputPort())
sphereActor = vtk.vtkActor()
sphereActor.SetMapper(sphereMapper)
renderer.AddActor(sphereActor)
renderer.SetBackground(0.1, 0.2, 0.4)  # Background color

# Render the scene
renderWindow.Render()

# Set up window to image filter
windowToImageFilter = vtk.vtkWindowToImageFilter()
windowToImageFilter.SetInput(renderWindow)

# Set up video writer
videoWriter = vtk.vtkFFMPEGWriter()
videoWriter.SetFileName("animation.mp4")
videoWriter.SetInputConnection(windowToImageFilter.GetOutputPort())
videoWriter.Start()

# Animate the scene and capture frames
for i in range(100):
    # Update the scene (example: rotate the sphere)
    sphereActor.RotateX(1)
    sphereActor.RotateY(1)
    renderWindow.Render()
    windowToImageFilter.Modified()
    videoWriter.Write()

# Finalize the video file
videoWriter.End()

In these examples:

• The render window's contents are captured and saved as a PNG image.
• A series of frames are captured while animating the scene, and these frames are compiled into an MP4 video file using vtkFFMPEGWriter.