AMR Visualization in Houdini

Goal of the Research

Adaptive Mesh Refinement (AMR) is a computational technique widely used in fields like astrophysics, fluid dynamics, and climate modeling. In AMR, simulations dynamically adjust the resolution of the computational grid: areas with complex phenomena receive higher resolution, while regions with less activity use coarser grids. This approach allows researchers to capture fine details efficiently without generating unnecessarily large datasets. However, the complexity and size of AMR data make it challenging to visualize and explore in traditional 3D software.

When visualizing AMR data in 3D applications, the raw simulation grids must first be converted into formats that the software can handle, such as VDB volumes, particles, or curves. While particle representations can depict individual data points, they are often difficult to edit, shade, and manipulate for detailed volumetric visualization. Volumetric representations like VDB volumes allow for interactive exploration, slicing, procedural shading, and high-quality rendering. This makes them ideal for scientific visualization, cinematic effects, and immersive applications.

We chose Houdini as the platform for this research because it offers robust tools for working with both particles and volumes. Houdini has native OpenVDB support, which makes it easier to generate and manipulate volumetric data efficiently. Its procedural workflow allows users to slice, resample, and shade volumes, as well as simulate particle-based phenomena when needed. This combination of flexibility, performance, and interactivity makes Houdini particularly suited for exploring large and complex AMR datasets.

The goal of this research is to integrate AMR visualization into Houdini in a way that allows scientists, researchers, and artists to interactively explore and analyze simulation data. By converting AMR grids to volumetric formats and leveraging Houdini’s procedural tools, users can gain better insight into physical phenomena, produce high-quality visualizations, and even create cinematic representations of scientific simulations.

Understanding AMR and Simulation

Adaptive Mesh Refinement (AMR) is a method to make simulations more efficient by using higher resolution grids in regions with complex phenomena, and lower resolution grids where things are simpler. Think of simulating a fluid: turbulent areas get finer grids while calm areas use coarse grids. This reduces computational cost while keeping accuracy where it matters.

AMR datasets consist of multiple blocks of grids at different resolutions. Each block stores values such as density, temperature, or velocity. Since the grids are not uniform, special software is needed to visualize them correctly.

You can experiment with AMR using Python-based tools like yt or pyAMR. Define your simulation domain, set initial conditions, and the solver will refine grids dynamically in regions that change rapidly. This allows you to see how refinement adapts to complexity.

Most AMR simulations can export data to HDF5 format, which organizes the grids in a hierarchical structure. HDF5 files store all the blocks efficiently and let you access only the parts you need, which is perfect for visualization.

With the HDF5 output, Python libraries like yt and h5py can convert the data into VDB volumes for Houdini. This enables interactive 3D exploration, slicing, shading, and even animation of your simulation.

Beginners can start with small toy simulations on a laptop, experimenting with 2D or 3D boxes, simple fluid or diffusion scenarios, exporting to HDF5, and visualizing in Houdini. This hands-on approach helps understand AMR and volumetric visualization workflows.

Research Objectives & Applications

Core Research Objectives

AMR → VDB Conversion – automated conversion of AMR grids into Houdini VDB volumes.
Interactive 3D Exploration – real-time zooming, slicing, and visualization of simulation data.
Shader Assignment – assign color and density shaders to different physical quantities like density, temperature, or velocity.
High-Resolution Scalability – handle large datasets efficiently using Houdini’s VDB tools.
Procedural Control – slice, resample, and manipulate volumes procedurally.

Applications

Astrophysics & Fluid Dynamics – visualizing simulations of galaxies, supernovae, turbulence, or weather patterns.
Education – interactive 3D visualization of computational science for teaching and learning.
Research – analyze simulation datasets, compare variables, or integrate multi-physics models.
Visual Effects – turn scientific simulations into cinematic volumetric effects for media and VR/AR.
Immersive VR/AR – explore complex volumetric data in immersive environments.

Technology Stack

The workflow combines Python-based scientific libraries with Houdini's procedural 3D tools to achieve high-performance, interactive visualization of AMR datasets.

Python Libraries

yt – for analyzing and processing AMR simulation data.
h5py – to read HDF5 datasets commonly used in simulations.
numpy – for numerical operations and array manipulation.

Houdini Tools

Native VDB Volumes – create volumes directly in Houdini without pyopenvdb.
Procedural Geometry & Shading – slice, resample, and apply shaders to volumetric data.
Rendering Pipeline – cinematic rendering of scientific simulations.

Why Houdini?

Direct VDB volume creation without external compilation.
Full procedural control for manipulation of large volumetric datasets.
Interactive visualization with shaders and cinematic rendering.
Bridges scientific accuracy and artistic flexibility.

Installation Instructions for Houdini

To process AMR datasets in Houdini, we need Python libraries like yt, h5py, and numpy. These libraries allow Houdini to read HDF5 outputs from simulations, process array data, and generate VDB volumes for visualization.

Important: These libraries are installed inside Houdini’s embedded Python environment, not your system Python. If you want to use pyopenvdb for additional volume manipulation, it must be built from source and is not required for the standard AMR → VDB workflow.

Windows

"C:\Program Files\Side Effects Software\Houdini XX.X.X\python39\python.exe" get-pip.py
"C:\Program Files\Side Effects Software\Houdini XX.X.X\python39\python.exe" -m pip install yt h5py numpy

macOS

/Applications/Houdini/HoudiniXX.X.X/Frameworks/Python.framework/Versions/Current/bin/python3 -m pip install yt h5py numpy

Linux

/opt/hfsXX.X.X/python/bin/python3 -m pip install yt h5py numpy

If pip is not available, bootstrap first:

/opt/hfsXX.X.X/python/bin/python3 -m ensurepip

Notes:

Replace XX.X.X with your installed Houdini version.
Restart Houdini after installing the libraries.
For pyopenvdb, building from source is required. See the OpenVDB build guide.
The old ytini method is deprecated; this pip-based installation is the recommended approach.

Ease of Use

You can start visualizing AMR data in Houdini in two ways:

Pre-built Houdini Digital Asset – drag-and-drop your AMR dataset, and it automatically converts to VDB volumes for interactive viewing.
Custom Python SOP – advanced users can load data via yt, process arrays with numpy, and convert to VDB programmatically.

The workflow allows real-time slicing, shading, and rendering of simulation volumes.

Resources & References

Below is a curated list of tools, libraries, and references useful for working with AMR datasets, volumetric visualization, and Houdini-based rendering.

yt Project Documentation – Python library for analyzing and visualizing volumetric and AMR datasets. Use: Reading, slicing, and analyzing simulation grids; generating derived fields. Alternatives: VisPy, ParaView.
h5py Documentation – Python interface for HDF5 files, a common format for simulation outputs. Use: Reading and writing hierarchical data structures in AMR simulations. Alternatives: PyTables.
NumPy – Core library for numerical computations in Python. Use: Efficient array operations, data processing, and preparation for visualization. Alternatives: SciPy, Pandas for structured data.
Houdini Official Page – The main software for procedural modeling, simulation, and volumetric visualization. Use: Converting AMR data into VDB volumes, simulating particles, shading, and rendering high-quality visuals. Alternatives: Blender (with OpenVDB support), Maya (particle/volume workflows).
OpenVDB – Open-source library for efficient volumetric data representation. Use: Storing and manipulating sparse volumetric grids; conversion from AMR or particle data. Alternatives: ParticleWorks for particle-to-volume workflows.
Sample AMR Datasets – Free datasets for testing and visualizing AMR simulations. Use: Learning, prototyping, and benchmarking volumetric rendering workflows. Alternatives: OpenFOAM Tutorials, Climate Simulation Data Repositories.
ParaView – Open-source visualization tool for large-scale scientific data. Use: Direct visualization of AMR, CFD, and volumetric datasets; alternative to Houdini for purely scientific exploration.
VTK (Visualization Toolkit) – Library for 3D computer graphics, image processing, and visualization. Use: Building custom visualization pipelines; Python, C++, and Java interfaces available.

Join the Research

Vedha Studios R&D welcomes collaboration from researchers, developers, and enthusiasts interested in advancing AMR visualization, procedural workflows, and volumetric analysis.

Contribute Code or Tools – improve Houdini Digital Asset, add features for AMR visualization or shading.
Research Collaboration – collaborate on simulation visualization, volumetric analysis, or multi-field studies.
Educational Projects – develop interactive learning modules for computational science.
Feedback and Testing – provide insights, test datasets, and suggest improvements.

Contact: research@vedhastudios.ca | Visit our Research Portal