Introduction

OpenVDBLink provides a Mathematica interface to OpenVDB, an efficient sparse voxel data structure ubiquitous in the VFX industry. This link ports over access to various grid containers including level sets, fog volumes, vector grids, integer grids, Boolean grids, and mask grids. Construction, modification, combinations, visualisations, queries, import, export, etc. can be achieved over grids too. Any Mathematica 3D region that’s ConstantRegionQ and BoundedRegionQ can be represented as a level set grid, providing a more seamless integration with OpenVDB.

OpenVDB is an Academy Award-winning open-source C++ library comprising a novel hierarchical data structure and a suite of tools for the efficient storage and manipulation of sparse volumetric data discretized on three-dimensional grids. It was developed by DreamWorks Animation for use in volumetric applications typically encountered in feature film production and is now maintained by the Academy Software Foundation (ASWF).

This notebook starts of with basic overview, followed by a thorough set of examples for each symbol in OpenVDBLink. For ease of navigation, symbols are grouped into sections, and sometimes subsections, based on functional area.

This notebook cannot be saved, so feel free to edit and evaluate input cells, and experiment!

Contributions are to this project welcome!

Installation

Dependencies and requirements▴

OpenVDBLink requires Mathematica version 11.0 or higher.

It also requires openvdb itself is installed and any downstream dependencies openvdb itself has.

Loading and compilation▴

Loading▴

Find the openvdb_wolfram directory in the openvdb directory and add this to $Path:

vdbpath = FileNameJoin[{"path", "to", "openvdb", "openvdb_wolfram"}];

$Path = DeleteDuplicates@Join[$Path, {vdbpath}];

Load the package:

<< OpenVDBLink`

Compilation▴

Only during the first time loading the package, it will automatically compile the necessary binary:

<< OpenVDBLink`

If compilation fails, you may need to add any include/link paths that are not currently in your path environment. These can be added in BuildSettings . m

For example, here are some paths added before compiling for MacOS:

Once these are set, reload and then recompile. Here the input True is optional and tells the system to print the compile command as well as any warnings or errors during compile:

<< OpenVDBLink`
OpenVDBLink`Developer`Recompile[True]

"/usr/bin/clang -dynamiclib -o \"/Users/ghurst/openvdb/openvdb_wolfram/OpenVDBLink/LibraryResources/MacOSX-x86-64/Working-2995MAC-GHURST-2-36758-366333440-1/OpenVDBLink.dylib\" -arch x86_64 -mmacosx-version-min=10.14 -install_name @rpath/OpenVDBLink.dylib -fPIC -O2 -std=c++11 -std=c++14 -ltbb -lHalf -lopenvdb -flto  -I\"/Applications/Mathematica.app/Contents/SystemFiles/IncludeFiles/C\" -I\"/Applications/Mathematica.app/Contents/SystemFiles/Links/MathLink/DeveloperKit/MacOSX-x86-64/CompilerAdditions\" -I\"/Users/ghurst/openvdb/openvdb_wolfram/OpenVDBLink/LTemplate/IncludeFiles\" \"/Users/ghurst/openvdb/openvdb_wolfram/OpenVDBLink/Source/ExplicitGrids/LTemplate-OpenVDBLink.cpp\"  -F\"/Applications/Mathematica.app/Contents/SystemFiles/Links/MathLink/DeveloperKit/MacOSX-x86-64/CompilerAdditions\" -L\"/Applications/Mathematica.app/Contents/SystemFiles/Libraries/MacOSX-x86-64\"  -framework \"mathlink\" -lc++ -framework Foundation 2>&1"

Basic usage

Available symbols▴

Length[Names["OpenVDBLink`*"]]

72

?? OpenVDBLink`*

Basic examples▴

Grid basics▴

Create a float grid with voxel size 1.0:

grid = OpenVDBCreateGrid[1.0]

OpenVDBCreateGrid returns an empty grid:

OpenVDBProperty[grid, "Empty"]

True

Short hand syntax:

grid["Empty"]

True

Set values at index coordinates {0, 0, 0} and {1, 0, 0}:

OpenVDBSetValues[grid, {{0, 0, 0}, {1, 0, 0}}, {0.5, 0.75}];

The grid is no longer empty:

grid["Empty"]

False

Grid types▴

List of supported grid types:

OpenVDBGridTypes[]

{"Scalar", "Vector", "Double", "Float", "Byte", "Int32", "Int64", "UInt32", "Vec2D", "Vec2I", "Vec2S", "Vec3D", "Vec3I", "Vec3S", "Boolean", "Mask"}

Here, "Scalar" is a synonym for "Float" and "Vector" is a synonym for "Vec3S" (3D scalar (float) valued vector).

Create a grid with voxel size 1.0 for each type:

grids = Association[Table[type -> OpenVDBCreateGrid[1.0, type], {type, OpenVDBGridTypes[][[3 ;; -1]]}]]

Retrieve their default background values:

#["BackgroundValue"] & /@ grids

<|"Double" -> 0., "Float" -> 0., "Byte" -> 0, "Int32" -> 0, "Int64" -> 0, "UInt32" -> 0, "Vec2D" -> {0., 0.}, "Vec2I" -> {0, 0}, "Vec2S" -> {0., 0.}, "Vec3D" -> {0., 0., 0.}, "Vec3I" -> {0, 0, 0}, "Vec3S" -> {0., 0., 0.}, "Boolean" -> 0, "Mask" -> Missing["NotApplicable"]|>

Level set▴

Create a level set from a mesh, with voxel size 0.05 and narrow band half width 3.0:

mesh = ExampleData[{"Geometry3D", "Triceratops"}, "MeshRegion"]

dinovdb = OpenVDBLevelSet[mesh, 0.05, 3.0]

Alternatively, first apply the voxel size and half width as global settings. These values will not need to be passed in explicitly anymore, unless different values are desired:

$OpenVDBSpacing = 0.05;
$OpenVDBHalfWidth = 3.0;

dinovdb = OpenVDBLevelSet[mesh]

Retrieve properties about the grid:

dinovdb["PropertyValueGrid"]

Drill a hole in the grid and apply 8 applications of a mean filter with window 2:

OpenVDBDifferenceFrom[dinovdb, Cylinder[{{0, -2, 0.5}, {0, 2, 0.5}}, 0.5]];

OpenVDBFilter[dinovdb, {"Mean", 2}, 8];

Since $OpenVDBSpacing and $OpenVDBHalfWidth have been set, the cylinder in the line above was automatically converted to a level set under the hood.

Render the object:

OpenVDBLevelSetRender[dinovdb]

Fog volume▴

Create a level set representation of a unit ball with voxel size 0.1:

ball = OpenVDBLevelSet[Ball[], 0.1, 2.0]

Create a fog volume:

fog = OpenVDBFogVolume[ball]

Retrieve the data as an Image3D object:

im3d = OpenVDBImage3D[fog]

Examine the slices:

Image3DSlices[im3d]

Image3DSlices[im3d, 10]

Import & meshing▴

Import a grid from a URL:

grid = OpenVDBImport["https://artifacts.aswf.io/io/aswf/openvdb/models/bunny.vdb/1.0.0/bunny.vdb-1.0.0.zip"]

Convert it to a mesh:

mesh = OpenVDBMesh[grid];

MeshCellCount[mesh]

{1339734, 4019196, 2679464}

Retrieve a smaller mesh:

mesh2 = OpenVDBMesh[grid, "Adaptivity" -> 1]

MeshCellCount[mesh2]

{22585, 67749, 45166}

Global settings

$OpenVDBSpacing▴

?$OpenVDBSpacing

In a fresh kernel, $OpenVDBSpacing has no value:

$OpenVDBSpacing

$OpenVDBSpacing

When $OpenVDBSpacing has no value, operations that need an explicit voxel size must have it passed in:

OpenVDBCreateGrid[]

$Failed

Create a grid with voxel size 0.1:

OpenVDBCreateGrid[0.1]

Set $OpenVDBSpacing to 0.1. Now every grid that’s created without being provided a voxel size will use 0.1:

$OpenVDBSpacing = 0.1;

grid = OpenVDBCreateGrid[];

grid["VoxelSize"]

0.1

Create a level set representation of a unit ball and render it, using the settings for $OpenVDBSpacing and $OpenVDBHalfWidth:

$OpenVDBSpacing = 0.1;
$OpenVDBHalfWidth = 3.0;

OpenVDBLevelSetRender[OpenVDBLevelSet[Ball[]]]

When both $OpenVDBSpacing and $OpenVDBHalfWidth are set, operations that require level set inputs will automatically convert valid regions into a level set using the global settings for voxel size and half width.

Passing in a region to an OpenVDBLink function automatically converts it into a level set under the hood.

$OpenVDBSpacing = 0.1;
$OpenVDBHalfWidth = 3.0;

OpenVDBLevelSetRender[Ball[]]

Clear $OpenVDBSpacing using Unset (=.):

$OpenVDBSpacing =.

It no longer has a value:

$OpenVDBSpacing

$OpenVDBSpacing

$OpenVDBHalfWidth▴

?$OpenVDBHalfWidth

In a fresh kernel, $OpenVDBHalfWidth has value 3.0:

$OpenVDBHalfWidth

3.

When $OpenVDBHalfWidth has a value, the OpenVDBLevelSet constructor will assume its value:

grid = OpenVDBLevelSet[Ball[], 0.1];
grid["HalfWidth"]

3.

Change its value:

$OpenVDBHalfWidth = 4.0;

grid = OpenVDBLevelSet[Ball[], 0.1];
grid["HalfWidth"]

4.

An explicitly passed in a half width takes precedence over $OpenVDBHalfWidth:

grid = OpenVDBLevelSet[Ball[], 0.1, 2.0];
grid["HalfWidth"]

2.

Create a level set representation of a unit ball and render it, using the settings for $OpenVDBSpacing and $OpenVDBHalfWidth:

$OpenVDBSpacing = 0.1;
$OpenVDBHalfWidth = 3.0;

OpenVDBLevelSetRender[OpenVDBLevelSet[Ball[]]]

When both $OpenVDBSpacing and $OpenVDBHalfWidth are set, operations that require level set inputs will automatically convert valid regions into a level set using the global settings for voxel size and half width.

Passing in a region to an OpenVDBLink function automatically converts it into a level set under the hood.

$OpenVDBSpacing = 0.1;
$OpenVDBHalfWidth = 3.0;

OpenVDBLevelSetRender[Ball[]]

Clear $OpenVDBHalfWidth using Unset (=.):

$OpenVDBHalfWidth =.

It no longer has a value:

$OpenVDBHalfWidth

$OpenVDBHalfWidth

$OpenVDBCreator▴

?$OpenVDBCreator

In a fresh kernel, $OpenVDBCreator has value None:

$OpenVDBCreator

None

When $OpenVDBCreator has no value, operations that create grids will not set a creator:

grid = OpenVDBCreateGrid[1.0];

grid["Creator"]

Missing["NotAvailable"]

Create a grid with a creator:

grid = OpenVDBCreateGrid[1.0, "Creator" -> "OpenVDBLink_Docs"];

grid["Creator"]

"OpenVDBLink_Docs"

Set $OpenVDBCreator. Now every grid that’s created without being provided a voxel size will use 0.1:

$OpenVDBCreator = "OpenVDBLink_Docs";

grid = OpenVDBCreateGrid[1.0];

grid["Creator"]

"OpenVDBLink_Docs"

OpenVDBDefaultSpace▴

?OpenVDBDefaultSpace

Consider a level set representation of a unit ball centered at the origin with voxel size 0.1:

ball = OpenVDBLevelSet[Ball[], 0.1];

The point {2, 0, 0} (in world space) is distance 1 from the ball, since the closest point on its boundary is {1, 0, 0}:

SignedRegionDistance[Ball[], {2, 0, 0}]

1

OpenVDBSignedDistance returns a similar result since the input point is assumed to be in world space by default:

OpenVDBSignedDistance[ball, {2, 0, 0}]

1.00751

We can determine that OpenVDBSignedDistance takes coordinates in world space by querying OpenVDBDefaultSpace:

OpenVDBDefaultSpace[OpenVDBSignedDistance]

"World"

On the other hand, we might want to know the signed distance of the coordinate 2 voxels from the origin, e.g. {2, 0, 0} in index space.

Query OpenVDBSignedDistance with a point in index space:

OpenVDBSignedDistance[ball, {2, 0, 0} -> "Index"]

-0.798116

In this example, the index coordinate {2, 0, 0} is equivalent to the world coordinate {0.2, 0, 0} since the voxel size is 0.1:

{
  OpenVDBSignedDistance[ball, {0.2, 0, 0}], 
  OpenVDBSignedDistance[ball, {0.2, 0, 0} -> "World"], 
  OpenVDBSignedDistance[ball, {2, 0, 0} -> "Index"] 
 }

{-0.798116, -0.798116, -0.798116}

The world coordinate {2, 0, 0} is equivalent to the index coordinate {20, 0, 0} since the voxel size is 0.1:

{
  OpenVDBSignedDistance[ball, {2, 0, 0}], 
  OpenVDBSignedDistance[ball, {2, 0, 0} -> "World"], 
  OpenVDBSignedDistance[ball, {20, 0, 0} -> "Index"] 
 }

{1.00751, 1.00751, 1.00751}

Gather functions based on their default space:

spacedata = PositionIndex[Association[# -> OpenVDBDefaultSpace[ToExpression[#]] & /@ Names["OpenVDBLink`*"]]];

Gather all functions that, by default, work in index space:

spacedata["Index"] // Multicolumn

Gather all functions that, by default, work in world space:

spacedata["World"] // Multicolumn

Grids

Grid modification▴

OpenVDBCreateGrid▴

?OpenVDBCreateGrid

Create a float grid with voxel size 1.0:

grid = OpenVDBCreateGrid[1.0]

OpenVDBCreateGrid creates an empty grid:

grid["Empty"]

True

Create a vector grid:

OpenVDBCreateGrid[1.0, "Vector"]

For each available grid type, create an empty grid with voxel size 0.5:

types = OpenVDBGridTypes[][[3 ;; -1]]

{"Double", "Float", "Byte", "Int32", "Int64", "UInt32", "Vec2D", "Vec2I", "Vec2S", "Vec3D", "Vec3I", "Vec3S", "Boolean", "Mask"}

grids = OpenVDBCreateGrid[1.0, #] & /@ types

No arguments are necessary if $OpenVDBSpacing is set:

$OpenVDBSpacing = 0.1;

grid = OpenVDBCreateGrid[]

grid["VoxelSize"]

0.1

Create a Boolean grid and manually set values:

bgrid = OpenVDBCreateGrid[1.0, "Boolean"]

OpenVDBSetValues[bgrid, Position[DiskMatrix[10 {1, 1, 1}], 1], 1];

OpenVDBImage3D[bgrid]

OpenVDBClearGrid▴

?OpenVDBClearGrid

Create a float grid with voxel size 1.0:

grid = OpenVDBCreateGrid[1.0]

Set 40 values along the positive x axis:

OpenVDBSetValues[grid, Table[{i, 0, 0}, {i, 40}], 0.5];

The grid now contains 40 active voxels:

grid["ActiveVoxelCount"]

40

Clear the grid:

OpenVDBClearGrid[grid];

No active voxels:

grid["ActiveVoxelCount"]

0

OpenVDBCopyGrid▴

?OpenVDBCopyGrid

Create a level set cube with voxel size 0.05:

cube = OpenVDBLevelSet[Cube[], 0.05];

Create a copy:

copy = OpenVDBCopyGrid[cube];

Apply a smoothing filter on the copy:

OpenVDBFilter[copy, "Gaussian"];

The original grid remains unchanged while the copy is smoothed:

OpenVDBMesh /@ {cube, copy}

List of grids▴

OpenVDBGridTypes▴

?OpenVDBGridTypes

List out all available types:

OpenVDBGridTypes[]

{"Scalar", "Vector", "Double", "Float", "Byte", "Int32", "Int64", "UInt32", "Vec2D", "Vec2I", "Vec2S", "Vec3D", "Vec3I", "Vec3S", "Boolean", "Mask"}

"Scalar" is a synonym for "Float":

OpenVDBCreateGrid[1.0, "Scalar"] // FullForm

"Vector" is a synonym for "Vec3S":

OpenVDBCreateGrid[1.0, "Vector"] // FullForm

"D" stands for double, "I" stands for integer, and "S" stands for scalar i.e. float:

v3dtypes = {"Vec3D", "Vec3I", "Vec3S"};

Initialize grids and set the value {0.1, 0.5, 1.7} at the origin:

veccgrids = OpenVDBCreateGrid[1.0, #] & /@ v3dtypes

Scan[OpenVDBSetValues[#, {0, 0, 0}, {0.1, 0.5, 1.7}] &, veccgrids]

Inspect each value at the origin. "S" (float) is not as accurate as "D" (double). "I" (integer) truncates values:

MapThread[#1 -> InputForm[OpenVDBValues[#2, {0, 0, 0}]] &, {v3dtypes, veccgrids}] // Column

OpenVDBGrids▴

?OpenVDBGrids

Initialize various grids with voxel size 1.0:

grids = Table[OpenVDBCreateGrid[1.0, type], {type, {"Float", "Byte", "Vec3S", "Boolean", "Mask"}}]

List out all grids:

OpenVDBGrids[]

Query just a specific grid type:

OpenVDBGrids["Float"]

In this kernel session there are no double grids in memory:

OpenVDBGrids["Double"]

{}

Use the input All to return an Association containing types with no grids too:

OpenVDBGrids[All]

Create more float grids:

grids2 = Table[OpenVDBCreateGrid[1.0, "Float"], 3]

These float grids are now present, as shown in their expression IDs in the information menus:

OpenVDBGrids["Float"]

Type Q functions▴

OpenVDBGridQ▴

?OpenVDBGridQ

Create a grid:

grid = OpenVDBCreateGrid[1.0]

Verify that it represents a valid grid:

OpenVDBGridQ[grid]

True

Inspect the FullForm of a grid:

OpenVDBCreateGrid[1.0] // FullForm

The internal ID must represent an active managed library expression:

OpenVDBGridQ[OpenVDBGrid[10^100, "Float"]]

False

Create a grid and print its FullForm:

With[{grid = OpenVDBCreateGrid[1.0]}, 
  Print[FullForm[grid]]; 
  OpenVDBGridQ[grid] 
 ]

True

Once the grid is no longer referenced by the system, it’s destroyed:

False

OpenVDBGrid does not format if it does not represent a valid grid:

OpenVDBGrid[74, "Float"]

OpenVDBScalarGridQ▴

?OpenVDBScalarGridQ

Create a scalar grid:

grid = OpenVDBCreateGrid[1.0]

Verify that it represents a valid scalar grid:

OpenVDBScalarGridQ[grid]

True

Find the list of valid grid types:

types = OpenVDBGridTypes[][[3 ;; -1]]

{"Double", "Float", "Byte", "Int32", "Int64", "UInt32", "Vec2D", "Vec2I", "Vec2S", "Vec3D", "Vec3I", "Vec3S", "Boolean", "Mask"}

For each grid type, test if it represents a scalar grid or not:

TextGrid[Table[{t, OpenVDBScalarGridQ[OpenVDBCreateGrid[1.0, t]]}, {t,types}], Frame -> All]

OpenVDBIntegerGridQ▴

?OpenVDBIntegerGridQ

Create an integer grid:

grid = OpenVDBCreateGrid[1.0, "Int32"]

Verify that it represents a valid integer grid:

OpenVDBIntegerGridQ[grid]

True

Find the list of valid grid types:

types = OpenVDBGridTypes[][[3 ;; -1]]

{"Double", "Float", "Byte", "Int32", "Int64", "UInt32", "Vec2D", "Vec2I", "Vec2S", "Vec3D", "Vec3I", "Vec3S", "Boolean", "Mask"}

For each grid type, test if it represents an integer grid or not:

TextGrid[Table[{t, OpenVDBIntegerGridQ[OpenVDBCreateGrid[1.0, t]]}, {t, types}], Frame -> All]

OpenVDBVectorGridQ▴

?OpenVDBVectorGridQ

Create a vector grid:

grid = OpenVDBCreateGrid[1.0, "Vector"]

Verify that it represents a valid vector grid:

OpenVDBVectorGridQ[grid]

True

Find the list of valid grid types:

types = OpenVDBGridTypes[][[3 ;; -1]]

{"Double", "Float", "Byte", "Int32", "Int64", "UInt32", "Vec2D", "Vec2I", "Vec2S", "Vec3D", "Vec3I", "Vec3S", "Boolean", "Mask"}

For each grid type, test if it represents a vector grid or not:

TextGrid[Table[{t, OpenVDBVectorGridQ[OpenVDBCreateGrid[1.0, t]]}, {t,types}], Frame -> All]

OpenVDBBooleanGridQ▴

?OpenVDBBooleanGridQ

Create a Boolean grid:

grid = OpenVDBCreateGrid[1.0, "Boolean"]

Verify that it represents a valid Boolean grid:

OpenVDBBooleanGridQ[grid]

True

Find the list of valid grid types:

types = OpenVDBGridTypes[][[3 ;; -1]]

{"Double", "Float", "Byte", "Int32", "Int64", "UInt32", "Vec2D", "Vec2I", "Vec2S", "Vec3D", "Vec3I", "Vec3S", "Boolean", "Mask"}

For each grid type, test if it represents a Boolean grid or not:

TextGrid[Table[{t, OpenVDBBooleanGridQ[OpenVDBCreateGrid[1.0, t]]}, {t, types}], Frame -> All]

OpenVDBMaskGridQ▴

?OpenVDBMaskGridQ

Create a mask grid:

grid = OpenVDBCreateGrid[1.0, "Mask"]

Verify that it represents a valid mask grid:

OpenVDBMaskGridQ[grid]

True

Find the list of valid grid types:

types = OpenVDBGridTypes[][[3 ;; -1]]

{"Double", "Float", "Byte", "Int32", "Int64", "UInt32", "Vec2D", "Vec2I", "Vec2S", "Vec3D", "Vec3I", "Vec3S", "Boolean", "Mask"}

For each grid type, test if it represents a mask grid or not:

TextGrid[Table[{t, OpenVDBMaskGridQ[OpenVDBCreateGrid[1.0, t]]}, {t, types}], Frame -> All]

Grid properties

OpenVDBProperty▴

?OpenVDBProperty

The following examples will use this level set grid as the base input:

grid = OpenVDBLevelSet[Ball[], 0.125];

Retrieve a property:

OpenVDBProperty[grid, "VoxelSize"]

0.125

OpenVDBGrid[…][prop] is shorthand for OpenVDBProperty[OpenVDBGrid[…], prop]:

grid["VoxelSize"]

0.125

Retrieve a list of all properties available for the grid:

grid["Properties"]

{"ActiveLeafVoxelCount", "ActiveTileCount", "ActiveVoxelCount", "BackgroundValue", "BoundingGridVoxelCount", "CreationDate", "Creator", "Description", "Empty", "ExpressionID", "GammaAdjustment", "GrayscaleWidth", "GridClass", "GridType", "HalfWidth", "IndexBoundingBox", "IndexDimensions", "LastModifiedDate", "MaxValue", "MemoryUsage", "MinValue", "MinMaxValues", "Name", "Properties", "PropertyValueGrid", "UniformVoxels", "VoxelSize", "WorldBoundingBox", "WorldDimensions"}

Multiple properties at once:

propertylist = {"ActiveLeafVoxelCount", "BackgroundValue", "BoundingGridVoxelCount", "VoxelSize"};

grid[propertylist]

{4982, 0.375, 9261, 0.125}

Key value pairs of properties in an Association:

OpenVDBProperty[grid, propertylist, "Association"]

<|"ActiveLeafVoxelCount" -> 4982, "BackgroundValue" -> 0.375, "BoundingGridVoxelCount" -> 9261, "VoxelSize" -> 0.125|>

Dataset of properties:

OpenVDBProperty[grid, propertylist, "Dataset"]

Rule list of properties:

OpenVDBProperty[grid, propertylist, "RuleList"]

{"ActiveLeafVoxelCount" -> 4982, "BackgroundValue" -> 0.375, "BoundingGridVoxelCount" -> 9261, "VoxelSize" -> 0.125}

View all properties at once in a grid. Any user controlled property that has not been set is indicated as such:

grid["PropertyValueGrid"]

Not all properties apply to every grid type:

bgrid = OpenVDBCreateGrid[1.0, "Boolean"]

bgrid["HalfWidth"]

Missing["NotApplicable"]

OpenVDBSetProperty▴

?OpenVDBSetProperty

The following examples will use this level set grid as the base input:

grid = OpenVDBLevelSet[Ball[], 0.125];

The list of properties OpenVDBSetProperty can control:

{"BackgroundValue", "Creator", "Description", "GridClass", "Name", "VoxelSize"}

Set the creator of the grid:

OpenVDBSetProperty[grid, "Creator", "OpenVDBLink_Docs"]

"OpenVDBLink_Docs"

Verify it’s been set:

OpenVDBProperty[grid, "Creator"]

"OpenVDBLink_Docs"

Or equivalently:

grid["Creator"]

"OpenVDBLink_Docs"

Set multiple properties at once:

OpenVDBSetProperty[grid, {"Description", "Name"}, {"This is a ball grid", "ball"}]

{"This is a ball grid", "ball"}

Verify they’ve been set:

OpenVDBProperty[grid, {"Creator", "Description", "Name"}, "Association"]

<|"Creator" -> "OpenVDBLink_Docs", "Description" -> "This is a ball grid", "Name" -> "ball"|>

Create an empty scalar grid with voxel size 1.0:

sgrid = OpenVDBCreateGrid[1.0, "Float"]

Set the background value, mark it as a level set, and change the voxel size to 0.1:

OpenVDBSetProperty[sgrid, {"BackgroundValue", "GridClass", "VoxelSize"}, {0.3, "LevelSet", 0.1}]

{0.3, "LevelSet", 0.1}

Verify:

sgrid[{"BackgroundValue", "GridClass", "VoxelSize"}]

{0.3, "LevelSet", 0.1}

Possible settings for "GridClass" include "LevelSet", "FogVolume", and None:

sgrid = OpenVDBCreateGrid[1.0, "Float"]

Various settings of "GridClass":

OpenVDBSetProperty[sgrid, "GridClass", "LevelSet"]

"LevelSet"

OpenVDBSetProperty[sgrid, "GridClass", "FogVolume"]

"FogVolume"

OpenVDBSetProperty[sgrid, "GridClass", None]

None

OpenVDBSetProperty[expr, prop -> val] is alternative syntax:

OpenVDBSetProperty[grid, "Creator" -> "OpenVDBLink_Docs"]

"OpenVDBLink_Docs"

OpenVDBSetProperty[grid, {"Description", "Name"} -> {"This is a ball grid", "ball"}]

{"This is a ball grid", "ball"}

OpenVDBSetProperty[expr,————{->,————->}] is alternative syntax:

OpenVDBSetProperty[grid, {"Creator" -> "OpenVDBLink_Docs", "Name" -> "ball"}]

{"OpenVDBLink_Docs", "ball"}

Level set creation

Basics▴

OpenVDBLevelSet▴

?OpenVDBLevelSet

Create a level set representation of a unit ball, with voxel size 0.1 and half width 3.0:

ball = OpenVDBLevelSet[Ball[], 0.1, 3.0]

Inspect its properties:

ball["PropertyValueGrid"]

The third argument may be omitted when $OpenVDBHalfWidth is set:

$OpenVDBHalfWidth = 3.0;

ball = OpenVDBLevelSet[Ball[], 0.1]

ball["ActiveLeafVoxelCount"]

7674

The second argument may be omitted when $OpenVDBSpacing is set:

$OpenVDBSpacing = 0.1;

ball = OpenVDBLevelSet[Ball[]]

ball["ActiveLeafVoxelCount"]

7674

Set the creator and name during construction:

ball = OpenVDBLevelSet[Ball[], 0.1, 3.0, "Creator" -> "OpenVDBLink_Docs", "Name" -> "ball"]

Set its description too:

OpenVDBSetProperty[ball, "Description" -> "This is a level set representation of a ball and it's wonderful."];

Inspect its properties:

ball["PropertyValueGrid"]

The first argument must be a region that is ConstantRegionQ and has RegionEmbeddingDimension equal to 3:

OpenVDBLevelSet[Disk[]]

$Failed

OpenVDBLevelSet[Ball[{x, y, z}, r]]

$Failed

Regions▴

Basic regions▴

The following examples will assume these settings:

$OpenVDBSpacing = 0.1;
$OpenVDBHalfWidth = 3.0;

Create a level set representation of any bounded and constant 3D basic region.

Examples include:

Ball:

OpenVDBLevelSet[Ball[]]

CapsuleShape:

OpenVDBLevelSet[CapsuleShape[{{0, 0, 0}, {1, 0, 0}}, 0.2]]

Dodecahedron:

OpenVDBLevelSet[Dodecahedron[]]

Ellipsoid:

OpenVDBLevelSet[Ellipsoid[{0.5, 1, 0}, {3, 2, 1}]]

Cylinder:

OpenVDBLevelSet[Cylinder[{{-2, -1, 0}, {0, 0, 0}}]]

Parallelepiped:

OpenVDBLevelSet[Parallelepiped[]]

Torus:

OpenVDBLevelSet[Torus[]]

Mesh regions▴

The following examples will assume these settings:

$OpenVDBSpacing = 0.1;
$OpenVDBHalfWidth = 3.0;

Create a level set representation of any 3D mesh region of dimension 2 or higher.

Examples include:

A closed surface MeshRegion:

OpenVDBLevelSet[ExampleData[{"Geometry3D", "Triceratops"}, "MeshRegion"]]

BoundaryMeshRegion:

OpenVDBLevelSet[ExampleData[{"Geometry3D", "Triceratops"}, "BoundaryMeshRegion"]]

A full dimensional MeshRegion with Tetrahedron elements:

mesh = DiscretizeRegion[Ball[]];

MeshCells[mesh, 3] // Short

OpenVDBLevelSet[mesh]

For mixed dimension MeshRegion, low dimension components are ignored:

mesh = MeshRegion[
    {{0, 0, 0}, {1, 0, 0}, {2, 0, 0}, {3, 0, -1/2}, {3, 0, 1/2}, {4, -1/2, 0}, {4, 1/2, 0}}, 
    {Point[1], Line[{2, 3}], Triangle[{3, 4, 5}], Tetrahedron[{4, 6, 5, 7}]} 
   ];

grid = OpenVDBLevelSet[mesh, 0.01]

Compare:

{mesh, OpenVDBMesh[grid]}

Formula regions▴

The following examples will assume these settings:

$OpenVDBSpacing = 0.1;
$OpenVDBHalfWidth = 3.0;

Create a level set representation of any 3D full dimensional formula region.

Examples include:

ImplicitRegion:

OpenVDBLevelSet[ImplicitRegion[x^2 + y^2 + z^2 <= 1, {x, y, z}]]

ParametricRegion:

OpenVDBLevelSet[ParametricRegion[{{x, y, z + y*x}, x^2 + y^2 + z^2 <= 1}, {x, y, z}]]

Lower dimensional components are ignored:

reg = ImplicitRegion[(x^2 + (9/4) y^2 + z^2 - 1)^3 - x^2 z^3 - (9/80) y^2 z^3 < 0 || (x^2 + y^2 == 2 && z == 0), {x, y, z}];

grid = OpenVDBLevelSet[reg, 0.05]

Compare:

{DiscretizeRegion[reg], OpenVDBMesh[grid]}

Derived regions▴

The following examples will assume these settings:

$OpenVDBSpacing = 0.1;
$OpenVDBHalfWidth = 3.0;

Create a level set representation of any 3D full dimensional formula region.

Examples include:

BooleanRegion:

OpenVDBLevelSet[RegionUnion[Ball[], Cuboid[]]]

TransformedRegion:

OpenVDBLevelSet[TransformedRegion[CapsuleShape[], ShearingTransform[30 \[Degree], {1, 0, 0}, {0, 1, 1}]]]

Fog volumes

OpenVDBFogVolume▴

?OpenVDBFogVolume

Create a level set ball with voxel size 0.1 and half width 2.0:

ball = OpenVDBLevelSet[Ball[], 0.1, 2.0]

Create a fog volume:

fog = OpenVDBFogVolume[ball]

Examine its slices:

OpenVDBImage3D[fog] // Image3DSlices

The grayscale band is roughly 2 voxels wide, which is the half width of the original level set:

Image[OpenVDBSliceImage[fog, 0], ImageSize -> 240]

OpenVDBFogVolume creates a new grid:

ball = OpenVDBLevelSet[Ball[], 0.1, 2.0];

fog = OpenVDBFogVolume[ball];

The original grid still represents a level set:

{ball["GridClass"], fog["GridClass"]}

{"LevelSet", "FogVolume"}

OpenVDBToFogVolume▴

?OpenVDBToFogVolume

Create a level set ball with voxel size 0.1 and half width 2.0:

ball = OpenVDBLevelSet[Ball[], 0.1, 2.0]

Convert to a fog volume:

OpenVDBToFogVolume[ball]

Examine its slices:

OpenVDBImage3D[ball] // Image3DSlices

The grayscale band is roughly 2 voxels wide, which is the half width of the original level set:

Image[OpenVDBSliceImage[ball, 0], ImageSize -> 240]

OpenVDBToFogVolume modifies the input data:

ball = OpenVDBLevelSet[Ball[], 0.1, 2.0];

OpenVDBToFogVolume[ball];

The original grid now represents a fog volume:

ball["GridClass"]

"FogVolume"

Mesh

OpenVDBMesh▴

?OpenVDBMesh

The following examples will use this level set grid as the base input:

grid = OpenVDBDifference[
    OpenVDBLevelSet[Ball[], 0.2], 
    OpenVDBLevelSet[Cylinder[{{0, -2, 0}, {0, 2, 0}}, .5], 0.2] 
   ];

OpenVDBFilter[grid, "Laplacian", 3];

Retrieve the object as a mesh:

mesh = OpenVDBMesh[grid]

This object is a surface MeshRegion and represents the 2D boundary:

mesh // Head

MeshRegion

Area[mesh]

10.5685

Volume[mesh]

Undefined

Retrieve the object as a BoundaryMeshRegion:

mesh = OpenVDBMesh[grid, "BoundaryMeshRegion"]

Volume[mesh]

1.71397

Retrieve the mesh of a fog volume:

OpenVDBMesh[OpenVDBFogVolume[grid]]

Retrieve the complex data of the mesh. The return value is of the form {coords, cells}:

Short /@ OpenVDBMesh[grid, "ComplexData"]

Retrieve the faces of the mesh:

faces = OpenVDBMesh[grid, "FaceData"];

Examine the vertices of the first 4 triangles:

faces[[1, 1 ;; 4]]

{{{-0.807618, -0.410372, -0.225385}, {-0.815691, -0.420792, -0.1}, {-0.871229, -0.3, -0.1}}, {{-0.833507, -0.302248, -0.295231}, {-0.807618, -0.410372, -0.225385}, {-0.871229, -0.3, -0.1}}, {{-0.814471, -0.237081, -0.42533}, {-0.833507, -0.302248, -0.295231}, {-0.884373, -0.1, -0.3}}, {{-0.827692, -0.1, -0.448292}, {-0.814471, -0.237081, -0.42533}, {-0.884373, -0.1, -0.3}}}

The first 20 triangles form a surface patch:

Graphics3D[Triangle[faces[[1, 1 ;; 20]]]]

Retrieve a piece of the mesh over specified bounds:

OpenVDBMesh[grid, Automatic, {{-0.8, 0}, {-1, 1}, {-1, 0}}]

By default OpenVDBMesh works in world coordinates:

OpenVDBDefaultSpace[OpenVDBMesh]

"World"

Pass in the bounds in index space:

OpenVDBMesh[grid, Automatic, {{-4, 0}, {-5, 5}, {-5, 0}} -> "Index"]

OpenVDBMesh has the following options:

Options[OpenVDBMesh]

{"Adaptivity" -> 0., "CloseBoundary" -> True, "IsoValue" -> Automatic,"ReturnQuads" -> False}

Adaptively sample to reduce triangle count. Adaptivity can range from 0.0 (none) to 1.0:

{OpenVDBMesh[grid, "Adaptivity" -> 0.0], OpenVDBMesh[grid, "Adaptivity" -> 1.0]}

Mesh over a different iso-band:

{OpenVDBMesh[grid], OpenVDBMesh[grid, "IsoValue" -> -0.1]}

Return quads:

OpenVDBMesh[grid, Automatic, {{-0.8, 0}, {-1, 1}, {-1, 0}}, "ReturnQuads" -> True]

With "Adaptivity" -> 0, the number of triangles can be estimated without needing to compute the mesh:

MeshCellCount[OpenVDBMesh[grid], 2]

752

Estimate the number of triangles:

3*OpenVDBArea[grid]/grid["VoxelSize"]^2

763.455

Values & states

Values▴

OpenVDBValues & OpenVDBSetValues▴

?OpenVDBValues

?OpenVDBSetValues

Create an empty grid:

grid = OpenVDBCreateGrid[1.0, "Float"];

Set the value at {0, 0, 0} to 0.5:

OpenVDBSetValues[grid, {0, 0, 0}, 0.5];

Verify it’s been set:

OpenVDBValues[grid, {0, 0, 0}]

0.5

Set multiple values at once:

grid = OpenVDBCreateGrid[1.0, "Float"];

OpenVDBSetValues[grid, {{0, 0, 0}, {1, 1, 1}, {2, 2, 2}}, {0.5, π, 2}];

Verify they’ve been set:

OpenVDBValues[grid, {{0, 0, 0}, {1, 1, 1}, {2, 2, 2}}]

{0.5, 3.14159, 2.}

Assign multiple points to have the same value:

grid = OpenVDBCreateGrid[1.0, "Float"];

OpenVDBSetValues[grid, {{0, 0, 0}, {1, 1, 1}, {2, 2, 2}}, 0.5];

Verify they’ve been set:

OpenVDBValues[grid, {{0, 0, 0}, {1, 1, 1}, {2, 2, 2}}]

{0.5, 0.5, 0.5}

By default OpenVDBValues and OpenVDBSetValues work in index coordinates:

OpenVDBDefaultSpace[OpenVDBValues]

"Index"

OpenVDBDefaultSpace[OpenVDBSetValues]

"Index"

Pass in coordinates in world space:

grid = OpenVDBCreateGrid[1.0, "Float"];

OpenVDBSetValues[grid, {{0, 0, 0}, {0.1, 0.1, 0.1}, {0.2, 0.2, 0.2}} -> "World", 0.5];

Verify they’ve been set:

OpenVDBValues[grid, {{0, 0, 0}, {0.1, 0.1, 0.1}, {0.2, 0.2, 0.2}} -> "World"]

{0.5, 0.5, 0.5}

OpenVDBValues and OpenVDBSetValues work with any grid type except mask:

Boolean grid:

grid = OpenVDBCreateGrid[1.0, "Boolean"];
OpenVDBSetValues[grid, {0, 0, 0}, 1];
OpenVDBValues[grid, {0, 0, 0}]

1

Integer grid:

grid = OpenVDBCreateGrid[1.0, "Int64"];
OpenVDBSetValues[grid, {0, 0, 0}, 17];
OpenVDBValues[grid, {0, 0, 0}]

17

Vector grid:

grid = OpenVDBCreateGrid[1.0, "Vec2D"];
OpenVDBSetValues[grid, {0, 0, 0}, {1.2, 5.6}];
OpenVDBValues[grid, {0, 0, 0}]

{1.2, 5.6}

Mask grid:

grid = OpenVDBCreateGrid[1.0, "Mask"];
OpenVDBSetValues[grid, {0, 0, 0}, 1];
OpenVDBValues[grid, {0, 0, 0}]

$Failed

States▴

OpenVDBStates & OpenVDBSetStates▴

?OpenVDBStates

?OpenVDBSetStates

Create an empty grid:

grid = OpenVDBCreateGrid[1.0, "Float"];

Mark {0, 0, 0} as an active voxel:

OpenVDBSetValues[grid, {0, 0, 0}, 1];

Verify it’s been set to active:

OpenVDBStates[grid, {0, 0, 0}]

1

Mark {0, 0, 0} back as inactive:

OpenVDBSetStates[grid, {0, 0, 0}, 0];

Verify it’s now inactive:

OpenVDBStates[grid, {0, 0, 0}]

0

Set multiple states at once:

grid = OpenVDBCreateGrid[1.0, "Float"];

OpenVDBSetStates[grid, {{0, 0, 0}, {1, 1, 1}, {2, 2, 2}}, {1, 0, 1}];

Verify they’ve been set appropriately:

OpenVDBStates[grid, {{0, 0, 0}, {1, 1, 1}, {2, 2, 2}}]

{1, 0, 1}

Assign multiple points to have the same active state:

grid = OpenVDBCreateGrid[1.0, "Float"];

OpenVDBSetStates[grid, {{0, 0, 0}, {1, 1, 1}, {2, 2, 2}}, 1];

Verify they’ve been set appropriately:

OpenVDBStates[grid, {{0, 0, 0}, {1, 1, 1}, {2, 2, 2}}]

{1, 1, 1}

By default OpenVDBStates and OpenVDBSetStates work in index coordinates:

OpenVDBDefaultSpace[OpenVDBStates]

"Index"

OpenVDBDefaultSpace[OpenVDBSetStates]

"Index"

Pass in coordinates in world space:

grid = OpenVDBCreateGrid[1.0, "Float"];

OpenVDBSetStates[grid, {{0, 0, 0}, {0.1, 0.1, 0.1}, {0.2, 0.2, 0.2}} -> "World", 1];

Verify they’ve been set appropriately:

OpenVDBStates[grid, {{0, 0, 0}, {0.1, 0.1, 0.1}, {0.2, 0.2, 0.2}} -> "World"]

{1, 1, 1}

OpenVDBStates and OpenVDBSetStates work with any grid type:

Boolean grid:

grid = OpenVDBCreateGrid[1.0, "Boolean"];
OpenVDBSetStates[grid, {0, 0, 0}, 1];
OpenVDBStates[grid, {0, 0, 0}]

1

Integer grid:

grid = OpenVDBCreateGrid[1.0, "Int64"];
OpenVDBSetStates[grid, {0, 0, 0}, 1];
OpenVDBStates[grid, {0, 0, 0}]

1

Vector grid:

grid = OpenVDBCreateGrid[1.0, "Vec2D"];
OpenVDBSetStates[grid, {0, 0, 0}, 1];
OpenVDBStates[grid, {0, 0, 0}]

1

Mask grid:

grid = OpenVDBCreateGrid[1.0, "Mask"];
OpenVDBSetStates[grid, {0, 0, 0}, 1];
OpenVDBStates[grid, {0, 0, 0}]

1

I/O

OpenVDBImport & OpenVDBExport▴

?OpenVDBImport

?OpenVDBExport

The following examples will use this file as a base input:

temploc = $TemporaryDirectory;

Export a level set:

grid = OpenVDBLevelSet[ExampleData[{"Geometry3D", "Triceratops"}, "MeshRegion"], 0.01];

file = FileNameJoin[{temploc, "tri.vdb"}];

OpenVDBExport[file, grid]

"/private/var/folders/bx/3hzyf2v96mv2xzm0yc02z87xgmf3zs/T/tri.vdb"

Verify it exported:

FileExistsQ[file]

True

FileByteCount[file]

11387892

Import the file:

grid2 = OpenVDBImport[file];

OpenVDBScalarGridQ[grid2]

True

Meta information is also exported:

grid = OpenVDBLevelSet[Ball[], 0.01, "Name" -> "ball"];

file = FileNameJoin[{temploc, "ball.vdb"}];

OpenVDBExport[file, grid]

"/private/var/folders/bx/3hzyf2v96mv2xzm0yc02z87xgmf3zs/T/ball.vdb"

Import the grid by name:

grid2 = OpenVDBImport[file, "ball"];

OpenVDBScalarGridQ[grid2]

True

Import fails when there is no grid of a given name:

OpenVDBImport[file, "foo"]

$Failed

Import a grid from a URL:

grid = OpenVDBImport["https://artifacts.aswf.io/io/aswf/openvdb/models/bunny.vdb/1.0.0/bunny.vdb-1.0.0.zip"];

grid["PropertyValueGrid"]

OpenVDBImport and OpenVDBExport work with any supported grid type:

grid = OpenVDBCreateGrid[1.0, "Int64"];
OpenVDBSetValues[grid, {{0, 0, 0}, {1, 0, 0}, {1, 1, 0}, {0, 1, 0}}, {17, -9, 4, 1}];

file = FileNameJoin[{temploc, "int_grid.vdb"}];

OpenVDBExport[file, grid]

"/private/var/folders/bx/3hzyf2v96mv2xzm0yc02z87xgmf3zs/T/int_grid.vdb"

Import it back:

grid2 = OpenVDBImport[file];

Verify the values at z = 0 are set:

OpenVDBSlice[grid2, 0]

{{1, 4}, {17, -9}}

By default, OpenVDBExport will not overwrite a file that already exists:

grid = OpenVDBLevelSet[Ball[], 0.01];

file = FileNameJoin[{temploc, "ball2.vdb"}];

OpenVDBExport[file, grid]

"/private/var/folders/bx/3hzyf2v96mv2xzm0yc02z87xgmf3zs/T/ball2.vdb"

Export again:

OpenVDBExport[file, grid]

$Failed

Tell OpenVDBExport to overwrite the file:

OpenVDBExport[file, grid, OverwriteTarget -> True]

"/private/var/folders/bx/3hzyf2v96mv2xzm0yc02z87xgmf3zs/T/ball2.vdb"

Rendering

OpenVDBLevelSetRender▴

?OpenVDBLevelSetRender

The following examples will use this level set grid as the base input:

grid = OpenVDBLevelSet[Torus[], 0.01];

Render a level set using default Graphics3D view options:

OpenVDBLevelSetRender[grid]

Render the grid using a different color:

OpenVDBLevelSetRender[grid, Red]

Render the grid using different base shaders:

baseshaders = {"Diffuse", "Matte", "Normal", "Position"};

Row[Labeled[OpenVDBLevelSetRender[grid, #], Text[#]] & /@ baseshaders, Spacer[1], BaseStyle -> ImageSizeMultipliers -> 1]

Render the grid using different materials:

materials = {"Aluminum", "Brass", "Bronze", "Copper", "Electrum", "Gold", "Iron", "Pewter", "Silver", "Clay", "Foil", "Glazed", "Plastic", "Rubber", "Satin"};

Multicolumn[Labeled[OpenVDBLevelSetRender[grid, #], Text[#]] & /@ materials, Appearance -> "Horizontal", BaseStyle -> ImageSizeMultipliers -> 1, Spacings -> 2]

Combine shaders and colors with second argument of the form {shader, color}:

OpenVDBLevelSetRender[grid, {"Plastic", Orange}]

Add different back-face coloring with second argument of the form {shader,,}:

OpenVDBLevelSetRender[grid, {"Plastic", Orange, Blue}, ViewRange -> {6.55, 100}]

Add different closed-face coloring, used during clipping, with second argument of the form {shader,,,}:

OpenVDBLevelSetRender[grid, {"Plastic", Orange, Blue, Purple}, ViewRange -> {6.55, 100}, "ClosedClipping" -> True]

Render the grid using named color themes:

themes = {"Default", "Monochrome", "Bronze", "Bold", "Cool", "Neon", "Pastel", "Soft", "Vibrant", "Warm"};

Multicolumn[Labeled[OpenVDBLevelSetRender[grid, #, ViewRange -> {6.55, 100}], Text[#]] & /@ themes, Appearance -> "Horizontal", BaseStyle -> ImageSizeMultipliers -> 1, Spacings -> 2]

Combine shaders and named color themes with second argument of the form {shader, theme}:

OpenVDBLevelSetRender[grid, {"Glazed", "Warm"}]

OpenVDBLevelSetRender shares the following options with Graphics3D:

Intersection[Options[OpenVDBLevelSetRender], Options[Graphics3D], SameTest -> (#1[[1]] === #2[[1]] &)]

{Background -> Automatic, ImageSize -> Automatic, ViewAngle -> Automatic, ViewCenter -> Automatic, ViewPoint -> {1.3, -2.4, 2.}, ViewProjection -> Automatic, ViewRange -> All, ViewVertical -> {0, 0, 1}}

These option values produce similar outputs compared to Graphics3D:

Graphics3D[Torus[], Background -> GrayLevel[0.85], ViewPoint -> {1, 1, -3}, ViewVertical -> {0, 1, 0}, ViewCenter -> {0, 0.5, 0.5}, ViewAngle -> Pi/8]

OpenVDBLevelSetRender[grid, Background -> GrayLevel[0.85], ViewPoint -> {1, 1, -3}, ViewVertical -> {0, 1, 0}, ViewCenter -> {0, 0.5, 0.5}, ViewAngle -> Pi/8]

OpenVDBLevelSetRender only works with level sets:

OpenVDBLevelSetRender[OpenVDBFogVolume[grid]]

$Failed

OpenVDBLevelSetRender[OpenVDBCreateGrid[1.0, "Byte"]]

$Failed

OpenVDBLevelSetViewer▴

?OpenVDBLevelSetViewer

The following examples are static images of an interactive output. Reevaluate them to interact.

The following examples will use this level set grid as the base input:

grid = OpenVDBLevelSet[Torus[], 0.01];

Interactively render a level set:

OpenVDBLevelSetViewer[grid]

The following controls can interactively move, zoom, and rotate the object:

• 3D rotation: Mouse down near the center of a 3D graphic and drag to rotate it in 3D. The cursor indicates 3D rotation.

• 2D rotation: Mouse down near the edge of a 3D graphic and drag to rotate it in the plane of the screen. The cursor indicates 2D rotation.

• Pan: Press shift while dragging to pan. The cursor indicates panning.

• Zoom: Press cmd (on mac), ctrl (otherwise) while dragging to zoom. Drag upward to zoom in and downward to zoom out. The cursor indicates zoom.

• Dolly (V13.1+): Press cmd+shift (on mac), ctrl+shift (otherwise) while dragging to dolly. Drag upward to move into the screen and downward to move out of the screen. The cursor indicates dolly.

• Look around (V13.1+): Press cmd+option (on mac), ctrl+option (otherwise) while dragging to look around while staying at a fixed view point. The cursor indicates looking around.

The Appearance tab lets you control settings like shading, resolution, iso‐value, and colors:

OpenVDBLevelSetViewer[grid]

The shading setting lets you pick different base shaders and materials:

With closed clipping enabled, another color option becomes available:

The color swatches are controls that open up an interactive color picker:

The Orientation tab lets you choose preset view verticals and view points, as well as controls to move around the scene:

OpenVDBLevelSetViewer[grid]

The Field of View tab lets you clip the object, zoom by changing the view angle, and choose the view projection:

OpenVDBLevelSetViewer[grid]

The General tab lets you copy the current image or view settings and allows you to reset the view:

OpenVDBLevelSetViewer[grid]

OpenVDBLevelSetViewer takes the same arguments as OpenVDBLevelSetRender, which determines its initial output:

OpenVDBLevelSetViewer[grid, {"Plastic", Orange}, Background -> Black, ViewPoint -> {0, 0, 10}, ViewAngle -> 0.11]

OpenVDBLevelSetViewer only works with level sets:

OpenVDBLevelSetViewer[OpenVDBFogVolume[grid]]

$Failed

OpenVDBLevelSetViewer[OpenVDBCreateGrid[1.0, "Byte"]]

$Failed

Aggregate data

Data▴

OpenVDBData▴

?OpenVDBData

Create a grid:

grid = OpenVDBLevelSet[Ball[], 0.1];

Retrieve the voxel data as a dense 3-tensor:

data = OpenVDBData[grid];

Check its dimensions:

data // Dimensions

{25, 25, 25}

Look at a slice in the middle the data:

ListDensityPlot[data[[13]], InterpolationOrder -> 0, PlotLegends -> Automatic]

Retrieve the voxel data over a bounding box:

grid = OpenVDBLevelSet[Ball[], 0.1];

data = OpenVDBData[grid, {{0, 10}, {0, 10}, {0, 10}}];

data // Dimensions

{11, 11, 11}

Look at a slice in the middle the data:

ListDensityPlot[data[[6]], InterpolationOrder -> 0, PlotLegends -> Automatic]

By default OpenVDBData works in index coordinates:

OpenVDBDefaultSpace[OpenVDBData]

"Index"

Pass in the bounds in world space:

grid = OpenVDBLevelSet[Ball[], 0.1];

data = OpenVDBData[grid, {{0.5, 0.9}, {0.5, 0.9}, {0, 1}} -> "World"];

data // Dimensions

{11, 5, 5}

ListDensityPlot[data[[6]], InterpolationOrder -> 0, PlotLegends -> Automatic]

OpenVDBData works with any grid type except mask.

Boolean grid:

grid = OpenVDBCreateGrid[1.0, "Boolean"];
OpenVDBSetValues[grid, {0, 0, 0}, 1];

OpenVDBData[grid, {{0, 1}, {0, 1}, {0, 1}}]

{{{0, 0}, {0, 0}}, {{0, 0}, {1, 0}}}

Integer grid:

grid = OpenVDBCreateGrid[1.0, "Int32"];
OpenVDBSetValues[grid, {0, 0, 0}, 17];

OpenVDBData[grid, {{0, 1}, {0, 1}, {0, 1}}]

{{{0, 0}, {0, 0}}, {{0, 0}, {17, 0}}}

Vector grid:

grid = OpenVDBCreateGrid[1.0, "Vector"];
OpenVDBSetValues[grid, {0, 0, 0}, {1, 1, 1}];

OpenVDBData[grid, {{0, 1}, {0, 1}, {0, 1}}]