OpenVDB

https://www.openvdb.org/documentation/doxygen/
Admin
OpenVDB is a C++ library providing a hierarchical data structure and tools for efficient...
Tokens:4,687,378
Snippets:39,597
Trust Score:9.4
Update:3 months ago
Show doc for...
Tokens:
Raw
### Building NanoVDB with OpenVDB Core

Source: https://www.openvdb.org/documentation/doxygen/NanoVDB_HowToBuild.html

This example shows how to build NanoVDB along with the OpenVDB core library. It assumes you are in the 'build' directory of the OpenVDB project and sets paths for TBB, Boost, BLOSC, and the installation prefix.

```bash
foo@bar:~$ mkdir build
foo@bar:~$ cd build
foo@bar:~$ cmake .. -DUSE_NANOVDB=ON -DTBB_ROOT=/path/to/tbb -DBOOST_ROOT=/path/to/boost -DBLOSC_ROOT=/path/to/blosc -DCMAKE_INSTALL_PREFIX=/install/path
foo@bar:~$ make -j 4 && make install
```

--------------------------------

### start

Source: https://www.openvdb.org/documentation/doxygen/classopenvdb_1_1v13__0_1_1math_1_1Ray.html

Returns the starting point of the ray.

```APIDOC
## start()

Return the starting point of the ray.

### Method
`Vec3R start() const`

### Returns
* `Vec3R` - The starting point of the ray.
```

--------------------------------

### start()

Source: https://www.openvdb.org/documentation/doxygen/classnanovdb_1_1util_1_1Timer.html

Starts the timer, optionally printing a message to a specified output stream.

```APIDOC
## start()

### Description
Start the timer. A message can be provided to be printed when the timer starts.

### Method
`void start(const std::string & _msg, std::ostream & _os = std::cerr)`

### Parameters
#### Path Parameters
- **_msg** (string) - Required - string message to be printed when timer is started
- **_os** (std::ostream) - Optional - output stream for the message above
```

--------------------------------

### Install OpenVDB

Source: https://www.openvdb.org/documentation/doxygen/build.html

Once the build is successful, use CMake to install the compiled files. Alternatively, 'make install' can be used on UNIX-like systems.

```bash
cmake --build . --target install
```

--------------------------------

### Build Everything in NanoVDB with OpenVDB Core

Source: https://www.openvdb.org/documentation/doxygen/NanoVDB_HowToBuild.html

Builds NanoVDB with all features enabled, including unit tests, examples, benchmarks, intrinsics, and CUDA support. Requires specifying paths for TBB, Boost, Blosc, and GTest. Installs to CMAKE_INSTALL_PREFIX.

```bash
foo@bar:~
$ mkdir build
$ cd build
$ cmake .. -DUSE_NANOVDB=ON -DNANOVDB_BUILD_UNITTESTS=ON -DNANOVDB_BUILD_EXAMPLES=ON -DNANOVDB_BUILD_BENCHMARK=ON -DNANOVDB_USE_INTRINSICS=ON -DNANOVDB_USE_CUDA=ON -DNANOVDB_CUDA_KEEP_PTX=ON -DTBB_ROOT=/path/to/tbb -DBOOST_ROOT=/path/to/boost -DBLOSC_ROOT=/path/to/blosc -DGTEST_ROOT=/path/to/gtest -DCMAKE_INSTALL_PREFIX=/install/path
$ make -j 4 && make install
```

--------------------------------

### Create and Write Grids

Source: https://www.openvdb.org/documentation/doxygen/python.html

Illustrates creating FloatGrids, filling them with data, associating metadata and transforms, and writing them to a VDB file. Use this to get started with basic grid operations.

```python
import pyopenvdb as vdb

# A grid comprises a sparse tree representation of voxel data,
# user-supplied metadata and a voxel space to world space transform,
# which defaults to the identity transform.
# A FloatGrid stores one single-precision floating point value per voxel.
# Other grid types include BoolGrid and Vec3SGrid. The module-level
# attribute pyopenvdb.GridTypes gives the complete list.
cube = vdb.FloatGrid()
cube.fill(min=(100, 100, 100), max=(199, 199, 199), value=1.0)
# Name the grid "cube".
cube.name = 'cube'
# Populate another FloatGrid with a sparse, narrow-band level set
# representation of a sphere with radius 50 voxels, located at
# (1.5, 2, 3) in index space.
sphere = vdb.createLevelSetSphere(radius=50, center=(1.5, 2, 3))
# Associate some metadata with the grid.
sphere['radius'] = 50.0
# Associate a scaling transform with the grid that sets the voxel size
# to 0.5 units in world space.
sphere.transform = vdb.createLinearTransform(voxelSize=0.5)
# Name the grid "sphere".
sphere.name = 'sphere'
# Write both grids to a VDB file.
vdb.write('mygrids.vdb', grids=[cube, sphere])
```

--------------------------------

### ValueAccessor Usage Example

Source: https://www.openvdb.org/documentation/doxygen/ValueAccessor_8h_source.html

Demonstrates how to use a ValueAccessor to set and get values in a FloatGrid. Initial accesses can be slow, but subsequent nearby accesses are fast due to caching. Accesses far from cached nodes require repopulation.

```cpp
// Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: Apache-2.0

// ... (other includes and namespace declarations)

/// @file tree/ValueAccessor.h
///
/// @brief ValueAccessors are designed to help accelerate accesses into the
/// OpenVDB Tree structures by storing caches to Tree branches. When
/// traversing a grid in a spatially coherent pattern (e.g., iterating over
/// neighboring voxels), the same branches and nodes of the underlying tree
/// can be hit. If you do this using the Tree/RootNode methods directly,
/// traversal will occur at O(log(n)) (or O(n) depending on the hash map
/// implementation) for every access. However, using a ValueAccessor allows
/// for the Accessor to cache previously visited Nodes, providing possible
/// subsequent access speeds of O(1) if the next access is close to a
/// previously cached Node. Accessors are lightweight and can be configured
/// to cache any number of arbitrary Tree levels.
///
/// The ValueAccessor interfaces matches that of compatible OpenVDB Tree
/// nodes. You can request an Accessor from a Grid (with Grid::getAccessor())
/// or construct one directly from a Tree. You can use, for example, the
/// accessor's @c getValue() and @c setValue() methods in place of those on
/// OpenVDB Nodes/Trees.
///
/// @par Example:
/// @code
FloatGrid grid;
FloatGrid::Accessor acc = grid.getAccessor();
// First access is slow:
acc.setValue(Coord(0, 0, 0), 100);

// Subsequent nearby accesses are fast, since the accessor now holds pointers
// to nodes that contain (0, 0, 0) along the path from the root of the grid's
// tree to the leaf:
acc.setValue(Coord(0, 0, 1), 100);
acc.getValue(Coord(0, 2, 0), 100);

// Slow, because the accessor must be repopulated:
acc.getValue(Coord(-1, -1, -1));

// Fast:
acc.getValue(Coord(-1, -1, -2));
acc.setValue(Coord(-1, -2, 0), -100);
// @endcode

```

--------------------------------

### Cook VDB SOP Example

Source: https://www.openvdb.org/documentation/doxygen/houdini.html

Example implementation of a cookVDBSOP function, demonstrating how to lock inputs, duplicate sources, evaluate group parameters, and iterate over selected VDB primitives.

```C++
OP_ERROR
MySOP::cookVDBSOP(OP_Context& context)
{
try {
houdini_utils::ScopedInputLock lock(*this, context);
const fpreal time = context.getTime();
// This does a deep copy of native Houdini primitives
// but only a shallow copy of VDB grids.
duplicateSource(0, context);
// Get the group of grids to process.
UT_String groupStr;
evalString(groupStr, "group", 0, time);
const GA_PrimitiveGroup* group = matchGroup(*gdp, groupStr.toStdString());
// Get other UI parameters.
int verbose = evalInt("verbose", 0, time);
UT_AutoInterrupt progress("Processing VDB grids");
// For each VDB primitive in the selected group...
for (openvdb_houdini::VdbPrimIterator it(gdp, group); it; ++it) {
if (progress.wasInterrupted()) {
throw std::runtime_error("processing was interrupted");
}
GU_PrimVDB* vdbPrim = *it;
// Optionally get the primitive's name (or, if the name is empty,
// the primitive's index).
const UT_String gridName = it.getPrimitiveNameOrIndex();
// If this primitive's grid is shared with other primitives, make
// a deep copy of it. If the grid is not going to be modified
// in place (or when using GEOvdbProcessTypedGrid()--see below),
// skip this step.
vdbPrim->makeGridUnique();
openvdb_houdini::Grid& grid = vdbPrim->getGrid();
// Process the grid.
// (Your code goes here.)
// In cases where it is not possible to process the primitive's
// grid in place, replace the grid with a new grid:
// openvdb_houdini::GridPtr outputGrid = ...;
// vdbPrim->setGrid(*outputGrid);
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
```

--------------------------------

### Install Built Project

Source: https://www.openvdb.org/documentation/doxygen/build.html

Install the compiled OpenVDB files after a successful build. This can be done using CMake's install target or Make's install command.

```bash
cmake --build . --target install
```

```bash
make install
```

--------------------------------

### CpuTimer::start(const std::string& msg)

Source: https://www.openvdb.org/documentation/doxygen/openvdb_2openvdb_2util_2CpuTimer_8h_source.html

Prints a message and then starts the timer. Useful for logging the start of a task.

```cpp
void start(const std::string& msg)
```

--------------------------------

### CpuTimer Start Methods

Source: https://www.openvdb.org/documentation/doxygen/classopenvdb_1_1v13__0_1_1util_1_1CpuTimer-members.html

Methods to start or restart the timer, optionally with a message.

```APIDOC
## CpuTimer Start Methods

### Description
Methods to start or restart the timer, optionally with a message.

### Methods
- `start()`
- `start(const std::string &msg)`
```

--------------------------------

### Install OpenVDB Dependencies with apt-get

Source: https://www.openvdb.org/documentation/doxygen/dependencies.html

Installs core libraries, build tools, and optional dependencies for OpenVDB using apt-get.

```bash
# Core library
apt-get install cmake # CMake
apt-get install libtbb-dev # TBB
apt-get install zlibc # zlib
apt-get install libboost-iostreams-dev # Boost::iostream
apt-get install libblosc-dev # Blosc
# AX
apt-get install llvm-15-dev # LLVM
# Python
apt-get install python-dev # Python
pip install nanobind # nanobind
# Optional
apt-get install libpng-dev # libpng
apt-get install libopenexr-dev # OpenEXR
apt-get install liblog4cplus-dev # Log4cplus
apt-get install googletest # GoogleTest
# vdb_view
apt-get install libglfw3-dev # GLFW
# Documentation
apt-get install doxygen # doxygen
# CUDA for NanoVDB
apt-get install nvidia-cuda-toolkit # CUDA
```

--------------------------------

### Install OpenVDB Dependencies with Homebrew

Source: https://www.openvdb.org/documentation/doxygen/dependencies.html

Installs core libraries, build tools, and optional dependencies for OpenVDB using Homebrew.

```bash
# Core library
brew install cmake # CMake
brew install tbb # TBB
brew install zlib # zlib
brew install boost # Boost
brew install c-blosc # blosc
# AX
brew install llvm # LLVM
# Python
brew install python # Python
brew install nanobind robin-map # nanobind
# Unit Tests
brew install gtest # GoogleTest
# vdb_view
brew install glfw #GLFW
# vdb_render
brew install openexr # OpenEXR
brew install libpng # libpng
# Documentation
brew install doxygen # Doxygen
```

--------------------------------

### Get Ray Start Point

Source: https://www.openvdb.org/documentation/doxygen/openvdb_2openvdb_2math_2Ray_8h_source.html

Returns the starting point of the ray. This method assumes the ray is defined within a time span.

```C++
inline Vec3R start() const { return (*this)(mTimeSpan.t0); }
```

--------------------------------

### Include Headers for NanoVDB Example

Source: https://www.openvdb.org/documentation/doxygen/ex__collide__level__set_2common_8h.html

Includes necessary headers for math operations, timing, file I/O, NanoVDB, and custom compute primitives.

```c++
#include <cmath>
#include <chrono>
#include <fstream>
#include <nanovdb/NanoVDB.h>
#include "ComputePrimitives.h"
```

--------------------------------

### x() [Value]

Source: https://www.openvdb.org/documentation/doxygen/classopenvdb_1_1v13__0_1_1math_1_1Vec4.html

Gets the component value. For example, float f = v.y();.

```APIDOC
## x() [2/2]

### Description
Get the component, e.g. float f = v.y();.

### Method
template<typename T>
T x() const

### Notes
This is an inline method.
```

--------------------------------

### init()

Source: https://www.openvdb.org/documentation/doxygen/structnanovdb_1_1LeafData_3_01Fp16_00_01CoordT_00_01MaskT_00_01LOG2DIM_01_4.html

Initializes the leaf with minimum, maximum, and bit width values.

```APIDOC
## ◆ init()
template<typename CoordT, template< uint32_t > class MaskT, uint32_t LOG2DIM>
| __hostdev__ void init  | ( | float | _min_ ,
|  | float | _max_ ,
|  | uint8_t | _bitWidth_ )
inlineinherited
```

--------------------------------

### Get Bounding Box Start Coordinate

Source: https://www.openvdb.org/documentation/doxygen/Coord_8h_source.html

Returns the minimum coordinate of the bounding box. This coordinate is inclusive.

```C++
Coord getStart() const { return mMin; }
```

--------------------------------

### Getting Elapsed Time in Microseconds

Source: https://www.openvdb.org/documentation/doxygen/openvdb_2openvdb_2util_2CpuTimer_8h_source.html

Retrieves the elapsed time in microseconds since the timer was constructed or started. This method provides high-resolution timing data.

```C++
timer.microseconds();
```

--------------------------------

### Hello, World for OpenVDB

Source: https://www.openvdb.org/documentation/doxygen/codeExamples.html

Demonstrates basic grid creation, random access to voxels using an accessor, and sequential access using an iterator. Initializes the OpenVDB library and sets values at specific coordinates, including minimum and maximum possible coordinates.

```cpp
#include <openvdb/openvdb.h>
#include <iostream>
int main()
{
// Initialize the OpenVDB library. This must be called at least
// once per program and may safely be called multiple times.
openvdb::initialize();
// Create an empty floating-point grid with background value 0.
openvdb::FloatGrid::Ptr grid = openvdb::FloatGrid::create();
std::cout << "Testing random access:" << std::endl;
// Get an accessor for coordinate-based access to voxels.
openvdb::FloatGrid::Accessor accessor = grid->getAccessor();
// Define a coordinate with large signed indices.
openvdb::Coord xyz(1000, -200000000, 30000000);
// Set the voxel value at (1000, -200000000, 30000000) to 1.
accessor.setValue(xyz, 1.0);
// Verify that the voxel value at (1000, -200000000, 30000000) is 1.
std::cout << "Grid" << xyz << " = " << accessor.getValue(xyz) << std::endl;
// Reset the coordinates to those of a different voxel.
xyz.reset(1000, 200000000, -30000000);
// Verify that the voxel value at (1000, 200000000, -30000000) is
// the background value, 0.
std::cout << "Grid" << xyz << " = " << accessor.getValue(xyz) << std::endl;
// Set the voxel value at (1000, 200000000, -30000000) to 2.
accessor.setValue(xyz, 2.0);
// Set the voxels at the two extremes of the available coordinate space.
// For 32-bit signed coordinates these are (-2147483648, -2147483648, -2147483648)
// and (2147483647, 2147483647, 2147483647).
accessor.setValue(openvdb::Coord::min(), 3.0f);
accessor.setValue(openvdb::Coord::max(), 4.0f);
std::cout << "Testing sequential access:" << std::endl;
// Print all active ("on") voxels by means of an iterator.
for (openvdb::FloatGrid::ValueOnCIter iter = grid->cbeginValueOn(); iter; ++iter) {
std::cout << "Grid" << iter.getCoord() << " = " << *iter << std::endl;
}
}
```

```text
Testing random access:
Grid[1000, -200000000, 30000000] = 1
Grid[1000, 200000000, -30000000] = 0
Testing sequential access:
Grid[-2147483648, -2147483648, -2147483648] = 3
Grid[1000, -200000000, 30000000] = 1
Grid[1000, 200000000, -30000000] = 2
Grid[2147483647, 2147483647, 2147483647] = 4
```

--------------------------------

### Example: Creating a Sparse Tree with Custom Rule

Source: https://www.openvdb.org/documentation/doxygen/DenseSparseTools_8h_source.html

Illustrates how to create a sparse tree from a dense grid using a custom rule. This example shows a template class `Rule` that can be adapted to specific value types and transformation logic.

```C++
template<typename ValueType>
class Rule
{
public:

```

--------------------------------

### Get Grid Tuple Size by Type

Source: https://www.openvdb.org/documentation/doxygen/UT__VDBUtils_8h_source.html

Returns the tuple size (number of components) for a given UT_VDBType. For example, Vec3f has a tuple size of 3.

```c++
inline int
UTvdbGetGridTupleSize(UT_VDBType type)
{
 switch(type)
 {
 case UT_VDB_FLOAT:
 case UT_VDB_DOUBLE:
 case UT_VDB_INT32:
 case UT_VDB_INT64:
 case UT_VDB_BOOL:
 return 1;

 case UT_VDB_VEC3F:
 case UT_VDB_VEC3D:
 case UT_VDB_VEC3I:
 return 3;

 case UT_VDB_POINTINDEX:
 case UT_VDB_POINTDATA:
 case UT_VDB_INVALID:
 default:
 break;
 }

 return 0;
}
```

--------------------------------

### begin()

Source: https://www.openvdb.org/documentation/doxygen/classopenvdb_1_1v13__0_1_1CoordBBox.html

Returns a ZYX-order iterator pointing to the minimum coordinate of the bounding box.

```APIDOC
## begin()

### Description
Returns a ZYX-order iterator that points to the minimum coordinate.

### Method
`const`

### Returns
`ZYXIterator`
```

--------------------------------

### Getting Elapsed Time in Milliseconds

Source: https://www.openvdb.org/documentation/doxygen/openvdb_2openvdb_2util_2CpuTimer_8h_source.html

Retrieves the elapsed time in milliseconds since the timer was constructed or started. This is a common unit for measuring code execution time.

```C++
timer.milliseconds();
```

--------------------------------

### Mesh to Volume Conversion Setup

Source: https://www.openvdb.org/documentation/doxygen/MeshToVolume_8h_source.html

Initializes grids and converts band widths for mesh to volume conversion. Handles invalid input values and logs debug messages.

```C++
typename GridType::Ptr distGrid(new GridType(std::numeric_limits<ValueType>::max()));
distGrid->setTransform(transform.copy());

ValueType exteriorWidth = ValueType(exteriorBandWidth);
ValueType interiorWidth = ValueType(interiorBandWidth);

if (!std::isfinite(exteriorWidth) || std::isnan(interiorWidth)) {
 std::stringstream msg;
 msg << "Illegal narrow band width: exterior = " << exteriorWidth
 << ", interior = " << interiorWidth;
 OPENVDB_LOG_DEBUG(msg.str());
 return distGrid;
}

const ValueType voxelSize = ValueType(transform.voxelSize()[0]);

if (!std::isfinite(voxelSize) || math::isZero(voxelSize)) {
 std::stringstream msg;
 msg << "Illegal transform, voxel size = " << voxelSize;
 OPENVDB_LOG_DEBUG(msg.str());
 return distGrid;
}

// Convert narrow band width from voxel units to world space units.
exteriorWidth *= voxelSize;
// Avoid the unit conversion if the interior band width is set to
// inf or std::numeric_limits<float>::max().
if (interiorWidth < std::numeric_limits<ValueType>::max()) {
 interiorWidth *= voxelSize;
}

const bool computeSignedDistanceField = (flags & UNSIGNED_DISTANCE_FIELD) == 0;
const bool removeIntersectingVoxels = (flags & DISABLE_INTERSECTING_VOXEL_REMOVAL) == 0;
const bool renormalizeValues = (flags & DISABLE_RENORMALIZATION) == 0;
const bool trimNarrowBand = (flags & DISABLE_NARROW_BAND_TRIMMING) == 0;

Int32GridType* indexGrid = nullptr;

typename Int32GridType::Ptr temporaryIndexGrid;

if (polygonIndexGrid) {
 indexGrid = polygonIndexGrid;
} else {
 temporaryIndexGrid.reset(new Int32GridType(Int32(util::INVALID_IDX)));
 indexGrid = temporaryIndexGrid.get();
}
```

--------------------------------

### Get Offset for PointIndex Leaf

Source: https://www.openvdb.org/documentation/doxygen/PNanoVDB_8h_source.html

Retrieves the base offset for a PointIndex leaf node. This is used to calculate the starting address of point data within the leaf.

```c
PNANOVDB_FORCE_INLINE pnanovdb_uint64_t pnanovdb_leaf_pointindex_get_offset(pnanovdb_buf_t buf, pnanovdb_leaf_handle_t leaf)
{
 return pnanovdb_read_uint64(buf, pnanovdb_leaf_get_min_address(PNANOVDB_GRID_TYPE_POINTINDEX, buf, leaf));
}
```

--------------------------------

### Configure CMake for Maya Build

Source: https://www.openvdb.org/documentation/doxygen/build.html

Use CMake to generate build files, specifying Maya installation paths and enabling Maya support. This example is for macOS.

```bash
cmake -D BOOST_ROOT=/path/to/boost/install \
-D Maya_ROOT=/Applications/Autodesk/maya2019/ \
-D USE_MAYA=ON \
../
```

--------------------------------

### start()

Source: https://www.openvdb.org/documentation/doxygen/classopenvdb_1_1v13__0_1_1tools_1_1UniformPointScatter.html

Initiates the scattering process with a given name.

```APIDOC
## ◆ start()

### Description
Initiates the scattering process with a given name.

### Method
N/A (This is a method within a class, not a standalone endpoint)

### Parameters
- **name** (const char *) - The name to start the scattering process with.
```

--------------------------------

### Interrupter Interface Example

Source: https://www.openvdb.org/documentation/doxygen/PointsToMask_8h.html

This shows the interface for an Interrupter class, which allows for interrupting long-running computations. It includes methods to start, end, and check if an interruption has been requested.

```cpp
class Interrupter {
...
public:
void start(const char* name = nullptr) // called when computations begin
void end() // called when computations end
bool wasInterrupted(int percent = -1) // return true to break computation
};
```

--------------------------------

### create

Source: https://www.openvdb.org/documentation/doxygen/structopenvdb_1_1v13__0_1_1ax_1_1VolumeExecutable_1_1CLI-members.html

Creates a CLI instance from command-line arguments.

```APIDOC
## create

### Description
Creates a CLI instance from command-line arguments.

### Signature
`static create(size_t argc, const char *argv[], bool *used = nullptr)`

### Parameters
*   **argc** (size_t) - The number of arguments.
*   **argv** (const char *) - The array of arguments.
*   **used** (bool *) - Optional pointer to a boolean that will be set to true if any arguments were used.
```

--------------------------------

### PointList Interface Example

Source: https://www.openvdb.org/documentation/doxygen/PointsToMask_8h.html

This illustrates the required interface for a PointList class, which must provide methods to get the total number of particles and the world space position of a specific particle.

```cpp
class PointList {
...
public:
// Return the total number of particles in list.
size_t size() const;
// Get the world space position of the nth particle.
void getPos(size_t n, Vec3R& xyz) const;
};
```

--------------------------------

### init()

Source: https://www.openvdb.org/documentation/doxygen/classnanovdb_1_1HostBuffer.html

Initializes the HostBuffer with a specified size and optional data pointer. If data is NULL, memory is allocated internally.

```APIDOC
## ◆ init()
| void init  | ( | uint64_t | _bufferSize_ ,   
|---|---|---|---|
|  | void * | _data_ = nullptr )  
| inline  

### Description
Initialize as a full buffer with the specified size. If data is NULL the memory is internally allocated.
```

--------------------------------

### Example: Creating a new POP operator with parameters

Source: https://www.openvdb.org/documentation/doxygen/ParmFactory_8h_source.html

Demonstrates how to use ParmFactory and OpFactory to define a new POP operator, including adding string parameters with choice lists.

```cpp
void
newPopOperator(OP_OperatorTable* table)
{
    houdini_utils::ParmList parms;

    parms.add(houdini_utils::ParmFactory(PRM_STRING, "group", "Group")
        .setHelpText("Specify a subset of the input VDB grids to be processed.")
        .setChoiceList(&houdini_utils::PrimGroupMenu));

    parms.add(...);

    ...

houdini_utils::OpFactory(MyOpPolicy(), My Node",
        POP_DW_MyNode::factory, parms, *table, houdini_utils::OpFactory::POP)
        .addInput("Input geometry") // input 0 (required)
        .addOptionalInput("Reference geometry"); // input 1 (optional)
}
```

--------------------------------

### Get Zero Tile Handle

Source: https://www.openvdb.org/documentation/doxygen/PNanoVDB_8h_source.html

Retrieves a tile handle initialized to the zero offset for a given grid type and root. This is often used as a starting point for iterating or accessing tiles.

```c
PNANOVDB_FORCE_INLINE pnanovdb_root_tile_handle_t pnanovdb_root_get_tile_zero(pnanovdb_grid_type_t grid_type, pnanovdb_root_handle_t root)
{
 pnanovdb_root_tile_handle_t tile = { root.address };
 tile.address = pnanovdb_address_offset(tile.address, PNANOVDB_GRID_TYPE_GET(grid_type, root_size));
 return tile;
}
```

--------------------------------

### initialize (no args)

Source: https://www.openvdb.org/documentation/doxygen/namespaceopenvdb_1_1v13__0_1_1logging.html

Initializes the logging system. This function should be called before any logging operations. It sets up the logging infrastructure, with an option to enable colorized output.

```APIDOC
## initialize()

### Description
Initialize the logging system if it is not already initialized.

### Method
POST (Conceptual)

### Endpoint
`/logging/initialize` (Conceptual)

### Parameters
#### Query Parameters
- **useColor** (boolean) - Optional - Whether to use colorized output. Defaults to true.
```

--------------------------------

### GetTile::get() - Accessing Tile from Existing Tile

Source: https://www.openvdb.org/documentation/doxygen/structnanovdb_1_1GetTile.html

This overload of the get function allows retrieving the root tile pointer starting from an existing tile within the grid. This can be useful for navigating up the hierarchy.

```APIDOC
## GetTile::get() [2/2]

### Description
Returns a pointer to the root Tile of the NanoVDB grid, starting from an existing tile. This overload facilitates navigation within the grid's hierarchy.

### Method
static

### Signature
`template<typename BuildT> Type get(const typename NanoRoot< BuildT >::Tile &tile)`

### Parameters
* `_tile_` (const typename NanoRoot< BuildT >::Tile &) - The current tile from which to find the root.
```

--------------------------------

### ValueAccessorImpl NodeTypeAtLevel Example

Source: https://www.openvdb.org/documentation/doxygen/ValueAccessor_8h_source.html

Demonstrates how to get a node type at a particular cache level within the ValueAccessor. The node type at a given cache level does not necessarily equal the same node type in the TreeType.

```cpp
template<typename _TreeType, bool IsSafe, typename MutexT, typename IntegerSequence>
class ValueAccessorImpl final :
 public ValueAccessorBase<_TreeType, IsSafe>,
 public ValueAccessorLeafBuffer<_TreeType, IntegerSequence>,
 public ValueAccessorLock<MutexT>
{
public:
 /// @note Not strictly the only Base Type but provided for backwards
 /// compatibility.
 using BaseT = ValueAccessorBase<_TreeType, IsSafe>;
 using LockT = ValueAccessorLock<MutexT>;
 using LeafCacheT = ValueAccessorLeafBuffer<_TreeType, IntegerSequence>;

 using TreeType = _TreeType;
 using ValueType = typename TreeType::ValueType;
 using RootNodeT = typename TreeType::RootNodeType;
 using LeafNodeT = typename TreeType::LeafNodeType;
 using NodeChainT = typename RootNodeT::NodeChainType;

 /// @brief A resolved, flattened TypeList of node types which this
 /// accessor is caching. The nodes index in this list does not
 /// necessarily correspond to the nodes level in the tree.
 using NodeLevelList =
 typename value_accessor_internal::NodeListBuilder
 <NodeChainT, RootNodeT::LEVEL, IntegerSequence>::ListT;
 using NodePtrList = typename NodeLevelList::template Transform<std::add_pointer_t>;

 /// @brief Return a node type at a particular cache level in the Value
 /// accessor. The node type at a given cache level does not necessarily
 /// equal the same node type in the TreeType as this depends entirely on
 /// which tree levels this Accessor is caching. For example:
 /// @par Example:
 /// @code
 /// // Cache tree levels 0 and 2
 /// using Impl = ValueAccessorImpl<FloatTree, true, void, 0, 2>
 /// using CacheLevel1 = Impl::template NodeTypeAtLevel<1>
 /// using TreeLevel2 = TreeType::RootNodeType::NodeChainType::Get<2>;
 /// static_assert(std::is_same<CacheLevel1, TreeLevel2>::value);
 /// @endcode
 template <size_t Level>
 using NodeTypeAtLevel = typename NodeLevelList::template Get<Level>;

 /// @brief Given a node type, return whether this Accessor can perform

```

--------------------------------

### NanoVDB Build Configuration Options

Source: https://www.openvdb.org/documentation/doxygen/NanoVDB_8h_source.html

Illustrates various preprocessor directives used to configure NanoVDB builds, such as enabling single root keys, using iostreams, or optimizing floating-point operations. These options allow customization of NanoVDB's behavior and performance.

```c++
#define TBB_SUPPRESS_DEPRECATED_MESSAGES 1

// This replaces a Coord key at the root level with a single uint64_t
#define NANOVDB_USE_SINGLE_ROOT_KEY

// This replaces three levels of Coord keys in the ReadAccessor with one Coord
//#define NANOVDB_USE_SINGLE_ACCESSOR_KEY

// Use this to switch between std::ofstream or FILE implementations
//#define NANOVDB_USE_IOSTREAMS

#define NANOVDB_FPN_BRANCHLESS

#if !defined(NANOVDB_ALIGN)
#define NANOVDB_ALIGN(n) alignas(n)
#endif // !defined(NANOVDB_ALIGN)
```

--------------------------------

### Get Point Address Range

Source: https://www.openvdb.org/documentation/doxygen/PNanoVDB_8h_source.html

Calculates the address range for points within a grid based on value type and level. Determines the stride based on the grid's value type to correctly compute the start and end addresses.

```c
PNANOVDB_FORCE_INLINE pnanovdb_uint64_t pnanovdb_root_pointindex_get_point_address_range(
 pnanovdb_buf_t buf,
 pnanovdb_grid_type_t value_type,
 pnanovdb_address_t value_address,
 pnanovdb_address_t blindmetadata_value_address,
 PNANOVDB_IN(pnanovdb_coord_t) ijk,
 pnanovdb_uint32_t level,
 PNANOVDB_INOUT(pnanovdb_address_t)address_begin,
 PNANOVDB_INOUT(pnanovdb_address_t)address_end
)
{
 pnanovdb_uint64_t range_begin;
 pnanovdb_uint64_t range_end;
 pnanovdb_uint64_t range_size = pnanovdb_root_pointindex_get_point_range(buf, value_address, ijk, level, PNANOVDB_REF(range_begin), PNANOVDB_REF(range_end));

 pnanovdb_uint32_t stride = 12u; // vec3f
 if (value_type == PNANOVDB_GRID_TYPE_VEC3U8)
 {
 stride = 3u;
 }
 else if (value_type == PNANOVDB_GRID_TYPE_VEC3U16)
 {
 stride = 6u;
 }
 PNANOVDB_DEREF(address_begin) = pnanovdb_address_offset64_product(blindmetadata_value_address, range_begin, stride);
 PNANOVDB_DEREF(address_end) = pnanovdb_address_offset64_product(blindmetadata_value_address, range_end, stride);
 return range_size;
}
```

--------------------------------

### initialize(bool useColor = true)

Source: https://www.openvdb.org/documentation/doxygen/logging_8h_source.html

Initializes the OpenVDB logging system. If the system is already initialized, this function does nothing. It sets up a default console appender and a warning log level.

```APIDOC
## initialize(bool useColor = true)

### Description
Initializes the OpenVDB logging system with default settings.

### Method
POST

### Endpoint
N/A (Function Call)

### Parameters
- **useColor** (bool) - Optional - Defaults to true. If true, enables colored text in log messages.
```

--------------------------------

### Initialization Methods

Source: https://www.openvdb.org/documentation/doxygen/classopenvdb_1_1v13__0_1_1tools_1_1FastSweeping.html

Methods for initializing the FastSweeping class with different types of input grids and parameters.

```APIDOC
## bool initSdf (const SdfGridT &sdfGrid, SdfValueT isoValue, bool isInputSdf)

### Description
Initializer for input grids that are either a signed distance field or a scalar fog volume.

### Method
initSdf (const SdfGridT &sdfGrid, SdfValueT isoValue, bool isInputSdf)

## template<typename ExtOpT> bool initExt (const SdfGridT &sdfGrid, const ExtOpT &op, const ExtValueT &background, SdfValueT isoValue, bool isInputSdf, FastSweepingDomain mode=FastSweepingDomain::SWEEP_ALL, const typename ExtGridT::ConstPtr extGrid=nullptr)

### Description
Initializer used whenever velocity extension is performed in addition to the computation of signed distance fields.

### Method
initExt (const SdfGridT &sdfGrid, const ExtOpT &op, const ExtValueT &background, SdfValueT isoValue, bool isInputSdf, FastSweepingDomain mode=FastSweepingDomain::SWEEP_ALL, const typename ExtGridT::ConstPtr extGrid=nullptr)

## bool initDilate (const SdfGridT &sdfGrid, int dilation, NearestNeighbors nn=NN_FACE, FastSweepingDomain mode=FastSweepingDomain::SWEEP_ALL)

### Description
Initializer used when dilating an existing signed distance field.

### Method
initDilate (const SdfGridT &sdfGrid, int dilation, NearestNeighbors nn=NN_FACE, FastSweepingDomain mode=FastSweepingDomain::SWEEP_ALL)

## template<typename MaskTreeT> bool initMask (const SdfGridT &sdfGrid, const Grid< MaskTreeT > &mask, bool ignoreActiveTiles=false)

### Description
Initializer used for the extension of an existing signed distance field into the active values of an input mask of arbitrary value type.

### Method
initMask (const SdfGridT &sdfGrid, const Grid< MaskTreeT > &mask, bool ignoreActiveTiles=false)

## template<typename OpT> bool initExt (const SdfGridT &fogGrid, const OpT &op, const ExtValueT &background, SdfValueT isoValue, bool isInputSdf, FastSweepingDomain mode, const typename ExtGridT::ConstPtr extGrid)

### Description
An overloaded initializer for velocity extension, similar to the other initExt method but potentially with different template parameters or default values.

### Method
initExt (const SdfGridT &fogGrid, const OpT &op, const ExtValueT &background, SdfValueT isoValue, bool isInputSdf, FastSweepingDomain mode, const typename ExtGridT::ConstPtr extGrid)
```

--------------------------------

### Get Value Address, Level, and Cache Info from Root

Source: https://www.openvdb.org/documentation/doxygen/PNanoVDB_8h_source.html

Retrieves the memory address, level, and cache information for a value starting from the grid's root. Handles cases for background values, leaf nodes, and recursively traverses through upper nodes.

```c
PNANOVDB_FORCE_INLINE pnanovdb_address_t pnanovdb_root_get_value_address_and_level_and_cache(pnanovdb_grid_type_t grid_type, pnanovdb_buf_t buf, pnanovdb_root_handle_t root, PNANOVDB_IN(pnanovdb_coord_t) ijk, PNANOVDB_INOUT(pnanovdb_readaccessor_t) acc, PNANOVDB_INOUT(pnanovdb_uint32_t) level)
{
 pnanovdb_root_tile_handle_t tile = pnanovdb_root_find_tile(grid_type, buf, root, ijk);
 pnanovdb_address_t ret;
 if (pnanovdb_address_is_null(tile.address))
 {
 ret = pnanovdb_address_offset(root.address, PNANOVDB_GRID_TYPE_GET(grid_type, root_off_background));
 PNANOVDB_DEREF(level) = 4u;
 }
 else if (pnanovdb_int64_is_zero(pnanovdb_root_tile_get_child(buf, tile)))
 {
 ret = pnanovdb_address_offset(tile.address, PNANOVDB_GRID_TYPE_GET(grid_type, root_tile_off_value));
 PNANOVDB_DEREF(level) = 3u;
 }
 else
 {
 pnanovdb_upper_handle_t child = pnanovdb_root_get_child(grid_type, buf, root, tile);
 PNANOVDB_DEREF(acc).upper = child;
 PNANOVDB_DEREF(acc).key = PNANOVDB_DEREF(ijk);
 ret = pnanovdb_upper_get_value_address_and_level_and_cache(grid_type, buf, child, ijk, acc, level);
 }
 return ret;
}
```

--------------------------------

### Asynchronous Grid Output with Callbacks

Source: https://www.openvdb.org/documentation/doxygen/classopenvdb_1_1v13__0_1_1io_1_1Queue.html

Demonstrates how to use the OpenVDB IO Queue to write grids asynchronously. It includes setting up a notifier callback to track task completion status and associating filenames with queued tasks. Grids should not be modified after queuing.

```cpp
#include <openvdb/openvdb.h>
#include <openvdb/io/Queue.h>
#include <tbb/concurrent_hash_map.h>
#include <functional>
using openvdb::io::Queue;
struct MyNotifier
{
// Use a concurrent container, because queue callback functions
// must be thread-safe.
using FilenameMap = tbb::concurrent_hash_map<Queue::Id, std::string>;
FilenameMap filenames;
// Callback function that prints the status of a completed task.
void callback(Queue::Id id, Queue::Status status)
{
const bool ok = (status == Queue::SUCCEEDED);
FilenameMap::accessor acc;
if (filenames.find(acc, id)) {
std::cout << (ok ? "wrote " : "failed to write ")
<< acc->second << std::endl;
filenames.erase(acc);
}
}
};
int main()
{
// Construct an object to receive notifications from the queue.
// The object's lifetime must exceed the queue's.
MyNotifier notifier;
Queue queue;
// Register the callback() method of the MyNotifier object
// to receive notifications of completed tasks.
queue.addNotifier(std::bind(&MyNotifier::callback, &notifier,
std::placeholders::_1, std::placeholders::_2));
// Queue grids for output (e.g., for each step of a simulation).
for (int step = 1; step <= 10; ++step) {
openvdb::FloatGrid::Ptr grid = ...;
std::ostringstream os;
os << "mygrid." << step << ".vdb";
const std::string filename = os.str();
Queue::Id id = queue.writeGrid(grid, openvdb::io::File(filename));
// Associate the filename with the ID of the queued task.
MyNotifier::FilenameMap::accessor acc;
notifier.filenames.insert(acc, id);
acc->second = filename;
}
}
```

--------------------------------

### initialize()

Source: https://www.openvdb.org/documentation/doxygen/namespacemembers_func_i.html

Initializes various components within OpenVDB, including ax, logging, and the main library.

```APIDOC
## initialize()

### Description
Initializes OpenVDB components. This function can be found in the `openvdb::v13_0::ax`, `openvdb::v13_0`, and `openvdb::v13_0::logging` namespaces.

### Method
Not specified (likely a function call).

### Endpoint
Not applicable.

### Parameters
None explicitly listed.

### Response
Not specified.
```

--------------------------------

### initialize(int& argc, char* argv[], bool useColor = true)

Source: https://www.openvdb.org/documentation/doxygen/logging_8h_source.html

Initializes the OpenVDB logging system using command-line arguments. It first calls the basic initialize function, then sets the logging level based on arguments, and finally sets the program name derived from the arguments.

```APIDOC
## initialize(int& argc, char* argv[], bool useColor = true)

### Description
Initializes the OpenVDB logging system using command-line arguments to set the log level and program name.

### Method
POST

### Endpoint
N/A (Function Call)

### Parameters
- **argc** (int&) - Required - A reference to the count of command-line arguments.
- **argv** (char*[]) - Required - An array of C-style strings representing the command-line arguments.
- **useColor** (bool) - Optional - Defaults to true. If true, enables colored text in log messages.

### Response
Initializes logging and modifies `argc` and `argv` in place.
```

--------------------------------

### Create and Write a FloatGrid Manually

Source: https://www.openvdb.org/documentation/doxygen/codeExamples.html

Illustrates the basic steps to create a FloatGrid, populate it with a sphere, add metadata, set a transform, and write it to a VDB file. Requires manual initialization and grid configuration.

```cpp
#include <openvdb/openvdb.h>
int main()
{
openvdb::initialize();
// Create a shared pointer to a newly-allocated grid of a built-in type: 
// in this case, a FloatGrid, which stores one single-precision floating point
// value per voxel. Other built-in grid types include BoolGrid, DoubleGrid,
// Int32Grid and Vec3SGrid (see openvdb.h for the complete list).
// The grid comprises a sparse tree representation of voxel data,
// user-supplied metadata and a voxel space to world space transform,
// which defaults to the identity transform.
openvdb::FloatGrid::Ptr grid = 
openvdb::FloatGrid::create(/*background value=*/2.0);
// Populate the grid with a sparse, narrow-band level set representation
// of a sphere with radius 50 voxels, located at (1.5, 2, 3) in index space.
makeSphere(*grid, /*radius=*/50.0, /*center=*/openvdb::Vec3f(1.5, 2, 3));
// Associate some metadata with the grid.
grid->insertMeta("radius", openvdb::FloatMetadata(50.0));
// Associate a scaling transform with the grid that sets the voxel size
// to 0.5 units in world space.
grid->setTransform(
openvdb::math::Transform::createLinearTransform(/*voxel size=*/0.5));
// Identify the grid as a level set.
grid->setGridClass(openvdb::GRID_LEVEL_SET);
// Name the grid "LevelSetSphere".
grid->setName("LevelSetSphere");
// Create a VDB file object.
openvdb::io::File file("mygrids.vdb");
// Add the grid pointer to a container.
openvdb::GridPtrVec grids;
gs.push_back(grid);
// Write out the contents of the container.
file.write(grids);
file.close();
}
```

--------------------------------

### get()

Source: https://www.openvdb.org/documentation/doxygen/classopenvdb_1_1v13__0_1_1points_1_1GroupWriteHandle.html

Gets the group membership for a specific index.

```APIDOC
## get()

### Description
Gets the group membership for a specific index.

### Parameters
* `n` (Index) - The index to query.

### Returns
* bool - True if the index is part of the group, false otherwise.
```

--------------------------------

### create()

Source: https://www.openvdb.org/documentation/doxygen/classopenvdb_1_1v13__0_1_1tools_1_1PointPartitioner.html

Statically creates and partitions point indices into buckets.

```APIDOC
## create()

### Description
Partitions point indices into `BucketLog2Dim` aligned buckets and returns a pointer to a new PointPartitioner.

### Method
`static Ptr create(const PointArray& _points_, const math::Transform& _xform_, bool _voxelOrder_ = false, bool _recordVoxelOffsets_ = false, bool _cellCenteredTransform_ = true)`

### Parameters
#### Path Parameters
- **_points_** (PointArray) - Required - list of world space points.
- **_xform_** (math::Transform) - Required - world to index space transform.
- **_voxelOrder_** (bool) - Optional - sort point indices by local voxel offsets.
- **_recordVoxelOffsets_** (bool) - Optional - construct local voxel offsets.
- **_cellCenteredTransform_** (bool) - Optional - toggle the cell-centered interpretation that imagines world space as divided into discrete cells (e.g., cubes) centered on the image of the index-space lattice points.

### Returns
- **Ptr** - A pointer to the newly created and partitioned PointPartitioner.
```

--------------------------------

### Starting Timer With a Message

Source: https://www.openvdb.org/documentation/doxygen/openvdb_2openvdb_2util_2CpuTimer_8h_source.html

Starts the CpuTimer and prints a specified message to the output stream, followed by the timer starting. This is typically used to indicate the beginning of a timed operation.

```C++
timer.start("message");
```

--------------------------------

### FastSweeping Initialization Methods

Source: https://www.openvdb.org/documentation/doxygen/FastSweeping_8h_source.html

Methods for initializing the FastSweeping algorithm with input grids and parameters.

```APIDOC
## FastSweeping Initialization Methods

### Description

These methods initialize the FastSweeping class. It is crucial to call one of these methods before calling the `sweep()` function to avoid a `RuntimeError`.

### Methods

- `bool initSdf(const SdfGridT &sdfGrid, SdfValueT isoValue, bool isInputSdf)`:
  - **Description**: Initializes the input grids, which can be a signed distance field or a scalar fog volume.
  - **Parameters**:
    - `sdfGrid` (const SdfGridT &): Input scalar grid.
    - `isoValue` (SdfValueT): Iso-value for the Dirichlet boundary condition.
    - `isInputSdf` (bool): True if `sdfGrid` is a signed distance field, false for a scalar fog volume.
  - **Returns**: True if initialization succeeded, false otherwise.
  - **Warning**: If this method returns false, a subsequent call to `sweep()` will throw a `RuntimeError`. Consider calling `clear()` and retrying.

- `bool initExt(const SdfGridT &sdfGrid, const std::function<ExtValueT(const Vec3R &xyz)> &op, ExtValueT background)`:
  - **Description**: Initializes for velocity extension in addition to signed distance field computation.
  - **Parameters**:
    - `sdfGrid` (const SdfGridT &): Input scalar grid.
    - `op` (const std::function<ExtValueT(const Vec3R &xyz)> &): Functor defining the Dirichlet boundary condition on the iso-surface for the field to be extended.
    - `background` (ExtValueT): Background value for the extension field.
  - **Returns**: True if initialization succeeded, false otherwise.
  - **Warning**: Similar to `initSdf`, failure requires calling `clear()` before retrying.
```

--------------------------------

### start()

Source: https://www.openvdb.org/documentation/doxygen/structopenvdb_1_1v13__0_1_1util_1_1NullInterrupter.html

Signals the start of an interruptible operation. This is an inline virtual function.

```APIDOC
## start()

Signal the start of an interruptible operation.

```cpp
virtual void start(const char* _name = nullptr);
```

**Parameters**
- **name**: An optional descriptive name for the operation.
```

--------------------------------

### Start Interrupter

Source: https://www.openvdb.org/documentation/doxygen/LevelSetTracker_8h_source.html

Starts the interrupter with a given message if an interrupter is present.

```cpp
template<typename GridT, typename InterruptT>
inline void
LevelSetTracker<GridT, InterruptT>::startInterrupter(const char* msg)
{
  if (mInterrupter) mInterrupter->start(msg);
}
```

--------------------------------

### Start Interrupter

Source: https://www.openvdb.org/documentation/doxygen/LevelSetTracker_8h_source.html

Starts an interrupter with a given message. Used for tracking and potentially interrupting long-running operations.

```cpp
void startInterrupter(const char* msg);
```
Tokens:
Raw