OpenVDB 13.0.0
Loading...
Searching...
No Matches
File List
Here is a list of all files with brief descriptions:
 doc
  
nanovdb
 nanovdb
  examples
   ex_collide_level_set
    
common.h
   ex_raytrace_fog_volume
    
common.h
   ex_raytrace_level_set
    
common.h
   ex_util
    
ComputePrimitives.h
A collection of parallel compute primitives
   ex_vox_to_nanovdb
    
VoxToNanoVDB.h
  unittest
   
pnanovdb_validate_strides.h
This header implements validation tests for the strides used in PNanaoVDB.h (instead of pointers). It can be used both for unit-testing (hence its location), but also to update PNanoVDB.h if the ABI changes in NanoVDB.h
  util
   
CpuTimer.h
   
CreateNanoGrid.h
   
DitherLUT.h
   
ForEach.h
A unified wrapper for tbb::parallel_for and a naive std::thread fallback
   
GridBuilder.h
   
GridChecksum.h
   
GridStats.h
   
GridValidator.h
   
HDDA.h
   
HostBuffer.h
   
Invoke.h
A unified wrapper for tbb::parallel_invoke and a naive std::thread analog
   
IO.h
   
MorphologyHelpers.h
This file implements helper methods used in morphology operations
   
NanoToOpenVDB.h
   
NodeManager.h
   
OpenToNanoVDB.h
   
PrefixSum.h
Multi-threaded implementations of inclusive prefix sum
   
Primitives.h
   
Range.h
Custom Range class that is compatible with the tbb::blocked_range classes
   
Ray.h
   
Reduce.h
A unified wrapper for tbb::parallel_reduce and a naive std::future analog
   
SampleFromVoxels.h
   
Stencils.h
   
Timer.h
A simple timing class (in case openvdb::util::CpuTimer is unavailable)
   
Util.h
Utility functions
  
CNanoVDB.h
  
GridHandle.h
Defines GridHandle, which manages a host, and possibly a device, memory buffer containing one or more NanoVDB grids
  
HostBuffer.h
HostBuffer - a buffer that contains a shared or private bump pool to either externally or internally managed host memory
  
NanoVDB.h
Implements a light-weight self-contained VDB data-structure in a single file! In other words, this is a significantly watered-down version of the OpenVDB implementation, with few dependencies - so a one-stop-shop for a minimalistic VDB data structure that run on most platforms!
  
NodeManager.h
This class allows for sequential access to nodes in a NanoVDB tree on both the host and device
  
PNanoVDB.h
This file is a portable (e.g. pointer-less) C99/GLSL/HLSL port of NanoVDB.h, which is compatible with most graphics APIs
 openvdb
  io
   
Archive.h
   
Compression.h
   
DelayedLoadMetadata.h
   
File.h
   
GridDescriptor.h
   
io.h
   
Queue.h
   
Stream.h
   
TempFile.h
  math
   
BBox.h
   
ConjGradient.h
Preconditioned conjugate gradient solver (solves Ax = b using the conjugate gradient method with one of a selection of preconditioners)
   
Coord.h
   
DDA.h
Digital Differential Analyzers specialized for VDB
   
FiniteDifference.h
   
Half.h
   
HalfDecl.h
   
Maps.h
   
Mat.h
   
Mat3.h
   
Mat4.h
   
Math.h
General-purpose arithmetic and comparison routines, most of which accept arbitrary value types (or at least arbitrary numeric value types)
   
Operators.h
   
Proximity.h
   
QuantizedUnitVec.h
   
Quat.h
   
Ray.h
A Ray class
   
Stats.h
Classes to compute statistics and histograms
   
Stencils.h
Defines various finite difference stencils by means of the "curiously recurring template pattern" on a BaseStencil that caches stencil values and stores a ValueAccessor for fast lookup
   
Transform.h
   
Tuple.h
   
Vec2.h
   
Vec3.h
   
Vec4.h
  points
   impl
    
PointAttributeImpl.h
    
PointConversionImpl.h
    
PointCountImpl.h
    
PointDeleteImpl.h
    
PointGroupImpl.h
    
PointMaskImpl.h
    
PointMoveImpl.h
    
PointRasterizeEllipsoidsSDFImpl.h
    
PointRasterizeFrustumImpl.h
    
PointRasterizeSDFImpl.h
    
PointRasterizeTrilinearImpl.h
    
PointReplicateImpl.h
    
PointSampleImpl.h
    
PointScatterImpl.h
    
PointStatisticsImpl.h
    
PrincipalComponentAnalysisImpl.h
   
AttributeArray.h
Attribute Array storage templated on type and compression codec
   
AttributeArrayString.h
Attribute array storage for string data using Descriptor Metadata
   
AttributeGroup.h
Attribute Group access and filtering for iteration
   
AttributeSet.h
Set of Attribute Arrays which tracks metadata about each array
   
IndexFilter.h
Index filters primarily designed to be used with a FilterIndexIter
   
IndexIterator.h
Index Iterators
   
PointAdvect.h
Ability to advect VDB Points through a velocity field
   
PointAttribute.h
Point attribute manipulation in a VDB Point Grid
   
PointConversion.h
Convert points and attributes to and from VDB Point Data grids
   
PointCount.h
Methods for counting points in VDB Point grids
   
PointDataGrid.h
Attribute-owned data structure for points. Point attributes are stored in leaf nodes and ordered by voxel for fast random and sequential access
   
PointDelete.h
Methods for deleting points based on group membership
   
PointGroup.h
Point group manipulation in a VDB Point Grid
   
PointMask.h
Methods for extracting masks from VDB Point grids
   
PointMove.h
Ability to move VDB Points using a custom deformer
   
PointRasterizeFrustum.h
Volume rasterization of VDB Points using velocity and camera motion-blur
   
PointRasterizeSDF.h
Various transfer schemes for rasterizing point positions and radius data to signed distance fields with optional closest point attribute transfers. All methods support arbitrary target linear transformations, fixed or varying point radius, filtering of point data and arbitrary types for attribute transferring
   
PointRasterizeTrilinear.h
Transfer schemes for rasterizing point data
   
PointReplicate.h
Algorithms to duplicate points in PointDataGrids
   
PointSample.h
Sample a VDB Grid onto a VDB Points attribute
   
PointScatter.h
Various point scattering methods for generating VDB Points
   
PointStatistics.h
Functions to perform multi threaded reductions and analysis of arbitrary point attribute types. Each function imposes various requirements on the point ValueType (such as expected operators) and supports arbitrary point filters
   
PointTransfer.h
Framework methods for rasterizing PointDataGrid data to Trees
   
PrincipalComponentAnalysis.h
Provides methods to perform principal component analysis (PCA) over a point set to compute rotational and affine transformations for each point that represent a their neighborhoods anisotropy. The techniques and algorithms used here are described in: [Reconstructing Surfaces of Particle-Based Fluids Using Anisotropic Kernel - Yu Turk 2010]. The parameters and results of these methods can be combines with the ellipsoidal surfacing technique found in PointRasterizeSDF.h
   
StreamCompression.h
Convenience wrappers to using Blosc and reading and writing of Paged data
  tools
   impl
    
ConvexVoxelizer.h
Base class used to generate the narrow-band level set of a convex region
    
LevelSetDilatedMeshImpl.h
Generate a narrow-band level set of a dilated surface mesh
    
LevelSetTubesImpl.h
Generate a narrow-band level set of a capsule, tapered capsule, and tube complex
   
Activate.h
Implementation of topological activation/deactivation
   
ChangeBackground.h
Efficient multi-threaded replacement of the background values in tree
   
Clip.h
Functions to clip a grid against a bounding box, a camera frustum, or another grid's active voxel topology
   
Composite.h
Functions to efficiently perform various compositing operations on grids
   
Count.h
Functions to count tiles, nodes or voxels in a grid
   
Dense.h
This file defines a simple dense grid and efficient converters to and from VDB grids
   
DenseSparseTools.h
   
Diagnostics.h
Various diagnostic tools to identify potential issues with for example narrow-band level sets or fog volumes
   
FastSweeping.h
Defined the six functions {fog,sdf}To{Sdf,Ext,SdfAndExt} in addition to the two functions maskSdf and dilateSdf. Sdf denotes a signed-distance field (i.e. negative values are inside), fog is a scalar fog volume (i.e. higher values are inside), and Ext is a field (of arbitrary type) that is extended off the iso-surface. All these functions are implemented with the methods in the class named FastSweeping
   
Filter.h
Filtering of VDB volumes. All operations can optionally be masked with another grid that acts as an alpha-mask. By default, filtering operations do not modify the topology of the input tree and thus do not process active tiles. However Filter::setProcessTiles can be used to process active tiles, densifying them on demand when necessary
   
FindActiveValues.h
Finds the active values and tiles in a tree that intersects a bounding box. Methods are provided that count the number of active values and tiles, test for the existence of active values and tiles, and return a list of the active tiles that intersect a bbox
   
GridOperators.h
Apply an operator to an input grid to produce an output grid with the same active voxel topology but a potentially different value type
   
GridTransformer.h
   
Interpolation.h
   
LevelSetAdvect.h
Hyperbolic advection of narrow-band level sets
   
LevelSetDilatedMesh.h
Generate a narrow-band level set of a dilated surface mesh
   
LevelSetFilter.h
Performs various types of level set deformations with interface tracking. These unrestricted deformations include surface smoothing (e.g., Laplacian flow), filtering (e.g., mean value) and morphological operations (e.g., morphological opening). All these operations can optionally be masked with another grid that acts as an alpha-mask
   
LevelSetFracture.h
Divide volumes represented by level set grids into multiple, disjoint pieces by intersecting them with one or more "cutter" volumes, also represented by level sets
   
LevelSetMeasure.h
   
LevelSetMorph.h
Shape morphology of level sets. Morphing from a source narrow-band level sets to a target narrow-band level set
   
LevelSetPlatonic.h
Generate a narrow-band level sets of the five platonic solids
   
LevelSetRebuild.h
   
LevelSetSphere.h
Generate a narrow-band level set of sphere
   
LevelSetTracker.h
Performs multi-threaded interface tracking of narrow band level sets. This is the building-block for most level set computations that involve dynamic topology, e.g. advection
   
LevelSetTubes.h
Generate a narrow-band level set of a capsule, tapered capsule, and tube complex
   
LevelSetUtil.h
Miscellaneous utility methods that operate primarily or exclusively on level set grids
   
Mask.h
Construct boolean mask grids from grids of arbitrary type
   
Merge.h
Functions to efficiently merge grids
   
MeshToVolume.h
Convert polygonal meshes that consist of quads and/or triangles into signed or unsigned distance field volumes
   
Morphology.h
Implementation of morphological dilation and erosion
   
MultiResGrid.h
Multi-resolution grid that contains LoD sequences of trees with powers of two refinements
   
NodeVisitor.h
Implementation of a depth-first node visitor
   
ParticleAtlas.h
Space-partitioning acceleration structure for particles, points with radius. Partitions particle indices into voxels to accelerate range and nearest neighbor searches
   
ParticlesToLevelSet.h
Rasterize particles with position, radius and velocity into either a boolean mask grid or a narrow-band level set grid
   
PointAdvect.h
Class PointAdvect advects points (with position) in a static velocity field
   
PointIndexGrid.h
Space-partitioning acceleration structure for points. Partitions the points into voxels to accelerate range and nearest neighbor searches
   
PointPartitioner.h
Spatially partitions points using a parallel radix-based sorting algorithm
   
PointScatter.h
We offer three different algorithms (each in its own class) for scattering of points in active voxels:
   
PointsToMask.h
This tool produces a grid where every voxel that contains a point is active. It employs thread-local storage for best performance
   
PoissonSolver.h
Solve Poisson's equation ∇2x = b for x, where b is a vector comprising the values of all of the active voxels in a grid
   
PotentialFlow.h
Tools for creating potential flow fields through solving Laplace's equation
   
Prune.h
Defined various multi-threaded utility functions for trees
   
RayIntersector.h
Accelerated intersection of a ray with a narrow-band level set or a generic (e.g. density) volume. This will of course be useful for respectively surface and volume rendering
   
RayTracer.h
Defines two simple but multithreaded renders, a level-set ray tracer and a volume render. To support these renders we also define perspective and orthographic cameras (both designed to mimic a Houdini camera), a Film class and some rather naive shaders
   
SignedFloodFill.h
Propagate the signs of distance values from the active voxels in the narrow band to the inactive values outside the narrow band
   
Statistics.h
Functions to efficiently compute histograms, extrema (min/max) and statistics (mean, variance, etc.) of grid values
   
TopologyToLevelSet.h
This tool generates a narrow-band signed distance field / level set from the interface between active and inactive voxels in a vdb grid
   
ValueTransformer.h
   
VectorTransformer.h
   
VelocityFields.h
Defines two simple wrapper classes for advection velocity fields as well as VelocitySampler and VelocityIntegrator
   
VolumeAdvect.h
Sparse hyperbolic advection of volumes, e.g. a density or velocity (vs a level set interface)
   
VolumeToMesh.h
Extract polygonal surfaces from scalar volumes
   
VolumeToSpheres.h
Fill a closed level set or fog volume with adaptively-sized spheres
  tree
   
InternalNode.h
Internal table nodes for OpenVDB trees
   
Iterator.h
   
LeafBuffer.h
   
LeafManager.h
A LeafManager manages a linear array of pointers to a given tree's leaf nodes, as well as optional auxiliary buffers (one or more per leaf) that can be swapped with the leaf nodes' voxel data buffers
   
LeafNode.h
   
LeafNodeBool.h
   
LeafNodeMask.h
   
NodeManager.h
NodeManager produces linear arrays of all tree nodes allowing for efficient threading and bottom-up processing
   
NodeUnion.h
   
RootNode.h
The root node of an OpenVDB tree
   
Tree.h
   
TreeIterator.h
   
ValueAccessor.h
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
  util
   
Assert.h
   
CpuTimer.h
   
ExplicitInstantiation.h
   
Formats.h
Utility routines to output nicely-formatted numeric values
   
logging.h
   
MapsUtil.h
   
Name.h
   
NodeMasks.h
   
NullInterrupter.h
   
PagedArray.h
Concurrent, page-based, dynamically-sized linear data structure with O(1) random access and STL-compliant iterators. It is primarily intended for applications that involve multi-threading push_back of (a possibly unkown number of) elements into a dynamically growing linear array, and fast random access to said elements
   
Util.h
  
Exceptions.h
  
Grid.h
  
Metadata.h
  
MetaMap.h
  
openvdb.h
  
Platform.h
  
PlatformConfig.h
  
TypeList.h
A TypeList provides a compile time sequence of heterogeneous types which can be accessed, transformed and executed over in various ways. It incorporates a subset of functionality similar to boost::mpl::vector however provides most of its content through using declarations rather than additional typed classes
  
Types.h
  
version.h.in