OpenVDB  3.1.0
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123]
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyIntersection< OtherInternalNode >::A
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >::A
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyUnion< OtherInternalNode >::A
 CABTransformThis class implements the Transformer functor interface (specifically, the isAffine(), transform() and invTransform() methods) for a transform that maps an A grid into a B grid's index space such that, after resampling, A's index space and transform match B's index space and transform
 CActivationOp< TreeType >
 CAdaptivePrimBuilder
 CAlphaMask< GridT, MaskT, SamplerT, FloatT >
 CArchiveGrid serializer/unserializer
 CArray< T >
 CLevelSetFilter< GridT, MaskT, InterruptT >::Filter::Avg< Axis >
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >::B
 CBaseCameraAbstract base class for the perspective and orthographic cameras
 CRootNodeMask::BaseIterator
 CBaseMaskIterator< NodeMask >Base class for the bit mask iterators
 CBasePointScatter< PointAccessorType, RandomGenerator, InterruptType >Forward declaration of base class
 CBaseShaderAbstract base class for the shaders
 CBaseStencil< DerivedType, GridT, IsSafe >
 CBaseStencil< BoxStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< BoxStencil< GridT, true >, GridT, true >
 CBaseStencil< CurvatureStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< DenseStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< FourthOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< GradStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< NineteenPointStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< SecondOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< SevenPointStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< SixthOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< ThirteenPointStencil< GridT, IsSafe >, GridT, IsSafe >
 CBaseStencil< WenoStencil< GridT, IsSafe >, GridT, IsSafe >
 CBBox< Vec3T >Axis-aligned bounding box
 CBBox< Vec3d >
 CBBoxFilter< PointArray, IndexT >
 CBIAS_SCHEME< bgs >
 CBIAS_SCHEME< FIRST_BIAS >
 CBIAS_SCHEME< HJWENO5_BIAS >
 CBIAS_SCHEME< SECOND_BIAS >
 CBIAS_SCHEME< THIRD_BIAS >
 CBIAS_SCHEME< WENO5_BIAS >
 CBinPointIndicesOp< PointArray, PointIndexType, VoxelOffsetType >
 CBlindData< VisibleT, BlindT >
 CBoolSampler
 CBoxSampler
 CLeafNode< T, Log2Dim >::BufferArray of fixed size $2^{3 \times {\rm Log2Dim}}$ that stores the voxel values of a LeafNode
 CLeafNode< bool, Log2Dim >::Buffer
 CCacheItem< TreeCacheT, NodeVecT, AtRoot >
 CCacheItem< TreeCacheT, NodeVecT, true >The tail of a compile-time list of cached node pointers, ordered from LeafNode to RootNode
 CCacheItem< ValueAccessor, SubtreeT, boost::mpl::size< SubtreeT >::value==1 >
 CCanConvertType< FromType, ToType >CanConvertType<FromType, ToType>::value is true if a value of type ToType can be constructed from a value of type FromType
 CCanConvertType< math::Vec2< T >, math::Vec2< T > >
 CCanConvertType< math::Vec3< T >, math::Vec3< T > >
 CCanConvertType< math::Vec4< T >, math::Vec4< T > >
 CCanConvertType< PointDataIndex32, PointIndex32 >
 CCanConvertType< PointIndex32, PointDataIndex32 >
 CCanConvertType< T, math::Vec2< T > >
 CCanConvertType< T, math::Vec3< T > >
 CCanConvertType< T, math::Vec4< T > >
 CCanConvertType< T0, math::Vec2< T1 > >
 CCanConvertType< T0, math::Vec3< T1 > >
 CCanConvertType< T0, math::Vec4< T1 > >
 CChangeBackgroundOp< TreeOrLeafManagerT >
 CChangeLevelSetBackgroundOp< TreeOrLeafManagerT >
 CCheckDivergence< GridT, TreeIterT, DiffScheme >Checks the divergence against a range
 CCheckEikonal< GridT, TreeIterT, StencilT >Checks the norm of the gradient at zero-crossing voxels against a range
 CCheckFinite< GridT, TreeIterT >Checks for both NaN and inf values, i.e. any value that is not finite
 CCheckFogVolume< GridType >Class that performs various types of checks on fog volumes
 CCheckInf< GridT, TreeIterT >Checks for infinite values, e.g. 1/0 or -1/0
 CCheckLevelSet< GridType >Class that performs various types of checks on narrow-band level sets
 CCheckMagnitude< GridT, TreeIterT >Check that the magnitude of a value, a, is close to a fixed magnitude, b, given a fixed tolerance c. That is | |a| - |b| | <= c
 CCheckMax< GridT, TreeIterT >Checks a value against a maximum
 CCheckMin< GridT, TreeIterT >Checks a value against a minimum
 CCheckNan< GridT, TreeIterT >Checks NaN values
 CCheckNormGrad< GridT, TreeIterT, GradScheme >Checks the norm of the gradient against a range, i.e. $|\nabla\phi|\in[min,max]$
 CCheckRange< GridT, MinInclusive, MaxInclusive, TreeIterT >Checks a value against a range
 CInternalNode< _ChildNodeType, Log2Dim >::ChildAll
 CLeafNode< T, Log2Dim >::ChildAll
 CInternalNode< _ChildNodeType, Log2Dim >::ChildOff
 CLeafNode< T, Log2Dim >::ChildOff
 CInternalNode< _ChildNodeType, Log2Dim >::ChildOn
 CLeafNode< T, Log2Dim >::ChildOn
 CClosestPointDist< IntLeafT >
 CClosestPointProjector< CptGridT >
 CClosestSurfacePoint< GridT >Accelerated closest surface point queries for narrow band level sets. Supports queries that originate at arbitrary world-space locations, is not confined to the narrow band region of the input volume geometry
 CCombineArgs< AValueType, BValueType >This struct collects both input and output arguments to "grid combiner" functors used with the tree::TypedGrid::combineExtended() and combine2Extended() methods. AValueType and BValueType are the value types of the two grids being combined
 CCombineLeafNodes< TreeType >
 CCombineOpAdapter< AValueT, CombineOp, BValueT >Helper class to adapt a three-argument (a, b, result) CombineOp functor into a single-argument functor that accepts a CombineArgs struct
 CRemoveSelfIntersectingSurface< TreeType >::Comp
 CCompositeFunctorTranslator< OP, ValueT >Translator that converts an enum to compositing functor types
 CCompositeFunctorTranslator< DS_ADD, ValueT >
 CCompositeFunctorTranslator< DS_MAX, ValueT >
 CCompositeFunctorTranslator< DS_MIN, ValueT >
 CCompositeFunctorTranslator< DS_MULT, ValueT >
 CCompositeFunctorTranslator< DS_OVER, ValueT >
 CCompositeFunctorTranslator< DS_SUB, ValueT >
 CCompoundMap< FirstMapType, SecondMapType >Creates the composition of two maps, each of which could be a composition. In the case that each component of the composition classified as linear an acceleration AffineMap is stored
 CCompReplaceOp< TreeT >
 CComputeIntersectingVoxelSign< TreeType, MeshDataAdapter >
 CComputeNodeConnectivity< TreeType >
 CComputePointOrderOp< PointIndexType >
 CConstrainedPointAdvect< GridT, PointListT, StaggeredVelocity, CptGridType, InterrupterType >
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::ConstRowRead-only accessor to a row of this matrix
 CConstructVoxelMask< TreeType >
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::ConstValueIterIterator over the stored values in a row of this matrix
 CContiguousOp< ValueT, PointWiseOp >Wrapper struct used to avoid unnecessary computation of memory access from Coord when all offsets are guaranteed to be within the dense grid
 CConvertGrid< FromGridT, ToGridT >
 CConvertGrid< GridT, GridT >
 CCoordSigned (x, y, z) 32-bit integer coordinates
 CCoordBBoxAxis-aligned bounding box of signed integer coordinates
 CCopyableOpApplier< IterT, OpT >
 CCopyableOpTransformer< InIterT, OutTreeT, OpT >
 CCopyConstness< FromType, ToType >
 CCopyConstness< const FromType, ToType >
 CCopyFromDense< _TreeT, _DenseT >Copy the values from a dense grid into an OpenVDB tree
 CCopyFromVecOp< TreeValueType, VIndexTreeType, VectorValueType >Functor for use with LeafManager::foreach() to populate a tree with values from a vector
 CCopyLeafNodes< TreeT >
 CMorphology< TreeType >::CopyMasks
 CCopyOp< T >
 CCopyToDense< _TreeT, _DenseT >Copy an OpenVDB tree into an existing dense grid
 CCopyToVecOp< VectorValueType, SourceTreeType >Functor for use with LeafManager::foreach() to populate a vector with the values of a tree's active voxels
 CCountPointsCounts the total number of points per leaf, accounts for cells with multiple points
 CCountRegions< IntTreeT >Counts the total number of points per collapsed region
 CCpt< InGridT, MaskGridType, InterruptT >Compute the closest-point transform of a scalar grid
 CCPT< MapType, DiffScheme >Compute the closest-point transform to a level set
 CCPT_RANGE< MapType, DiffScheme >Compute the closest-point transform to a level set
 CCpuTimerSimple timer for basic profiling
 CCreateOrderedPointIndexArrayOp< PointIndexType >
 CCsgVisitorBase< TreeType >
 CCurl< GridT, MaskGridType, InterruptT >Compute the curl of a vector grid
 CCurl< MapType, DiffScheme >Compute the curl of a vector-valued grid using differencing of various orders in the space defined by the range of the map
 CCurl< UniformScaleMap, CD_2ND >Full template specialization of Curl
 CCurl< UniformScaleMap, DiffScheme >Partial template specialization of Curl
 CCurl< UniformScaleTranslateMap, CD_2ND >Full template specialization of Curl
 CCurl< UniformScaleTranslateMap, DiffScheme >Partial template specialization of Curl
 CD1< DiffScheme >
 CD1< BD_1ST >
 CD1< BD_2ND >
 CD1< BD_3RD >
 CD1< BD_HJWENO5 >
 CD1< BD_WENO5 >
 CD1< CD_2ND >
 CD1< CD_2NDT >
 CD1< CD_4TH >
 CD1< CD_6TH >
 CD1< FD_1ST >
 CD1< FD_2ND >
 CD1< FD_3RD >
 CD1< FD_HJWENO5 >
 CD1< FD_WENO5 >
 CD1Vec< DiffScheme >
 CD1Vec< CD_2ND >
 CD1Vec< CD_2NDT >
 CD1Vec< CD_4TH >
 CD1Vec< CD_6TH >
 CD2< DiffScheme >
 CD2< CD_FOURTH >
 CD2< CD_SECOND >
 CD2< CD_SIXTH >
 CDDA< RayT, Log2Dim >A Digital Differential Analyzer specialized for OpenVDB grids
 CDDA< RayT, LeafT::TOTAL >
 CDDA< RayT, NodeT::TOTAL >
 CDDA< RayType, NodeT::TOTAL >
 CInternalNode< _ChildNodeType, Log2Dim >::DeepCopy< OtherInternalNode >
 CDelta< T >Delta for small floating-point offsets
 CDelta< double >
 CDelta< float >
 CDenseBase< ValueT, Layout >Base class for Dense which is defined below
 CDenseBase< ValueT, LayoutXYZ >Partial template specialization of DenseBase
 CDenseBase< ValueT, LayoutZYX >Partial template specialization of DenseBase
 CDenseTransformer< _ValueT, OpType >Class that applies a functor to the index space intersection of a prescribed bounding box and the dense grid. NB: This class only supports DenseGrids with ZYX memory layout
 CVector< T >::DeterministicDotProductOp
 CDiagnose< GridT >Performs multithreaded diagnostics of a grid
 CDiagnose< GridType >
 CDiffLeafNodeMask< TreeType >
 CDimToWord< Log2Dim >Mapping from a Log2Dim to a data type of size 2^Log2Dim bits
 CDimToWord< 3 >
 CDimToWord< 4 >
 CDimToWord< 5 >
 CDimToWord< 6 >
 CDimToWord< LEAF_LOG2DIM >
 CDiracDelta< RealT >Smeared-out and continuous Dirac Delta function
 CDirichletOp< ValueType >Constant boundary condition functor
 CDiscreteField< VelGridT, Interpolator >Thin wrapper class for a velocity grid
 CDivergence< InGridT, MaskGridType, InterruptT >Compute the divergence of a vector grid
 CDivergence< MapType, DiffScheme >Compute the divergence of a vector-valued grid using differencing of various orders, the result defined with respect to the range-space of the map
 CDivergence< ScaleMap, CD_2ND >
 CDivergence< ScaleMap, DiffScheme >
 CDivergence< ScaleTranslateMap, CD_2ND >
 CDivergence< ScaleTranslateMap, DiffScheme >
 CDivergence< TranslationMap, DiffScheme >
 CDivergence< UniformScaleMap, CD_2ND >
 CDivergence< UniformScaleMap, DiffScheme >
 CDivergence< UniformScaleTranslateMap, CD_2ND >
 CDivergence< UniformScaleTranslateMap, DiffScheme >
 CDSConverter< DenseType, TreeType >
 CDualGridSampler< GridOrTreeT, SamplerT >This is a simple convenience class that allows for sampling from a source grid into the index space of a target grid. At construction the source and target grids are checked for alignment which potentially renders interpolation unnecessary. Else interpolation is performed according to the templated Sampler type
 CDualGridSampler< AccT, SamplerT >
 CDualGridSampler< tree::ValueAccessor< TreeT >, SamplerT >Specialization of DualGridSampler for construction from a ValueAccessor type
 CMeshToVoxelEdgeData::EdgeDataInternal edge data type
 CEnrightField< ScalarT >Analytical, divergence-free and periodic velocity field
 CMorphology< TreeType >::ErodeVoxelsOp
 Cexception
 CExpandNarrowband< TreeType, MeshDataAdapter >
 CExtractAll< _ResultTreeType, DenseValueType >Simple utility class used by extractSparseTreeWithMask
 CExtremaThis class computes the minimum and maximum values of a population of floating-point values
 CLeafNode< T, Log2Dim >::FileInfo
 CPagedArray< ValueT, Log2PageSize >::Fill
 CFillArray< ValueType >
 CFillMaskBoundary< TreeType >
 CFillOp< T >
 CFilmA simple class that allows for concurrent writes to pixels in an image, background initialization of the image, and PPM or EXR file output
 CFilter< GridT, MaskT, InterruptT >Volume filtering (e.g., diffusion) with optional alpha masking
 CFilterTypeSelectively extract and filter point data using a custom filter operator
 CFindMinTileValue< InternalNodeType >
 CFindMinVoxelValue< LeafNodeType >
 CFlagUsedPoints
 CFlipRegionSign< LeafNodeType >
 CFormattedInt< IntT >I/O manipulator that formats integer values with thousands separators
 CDivergence< InGridT, MaskGridType, InterruptT >::Functor< DiffScheme >
 CGradient< InGridT, MaskGridType, InterruptT >::Functor
 CLaplacian< GridT, MaskGridType, InterruptT >::Functor
 CMeanCurvature< GridT, MaskGridType, InterruptT >::Functor
 CMagnitude< InGridT, MaskGridType, InterruptT >::Functor
 CNormalize< GridT, MaskGridType, InterruptT >::Functor
 CGenBoundaryMask< SrcTreeT >
 CMeshToVoxelEdgeData::GenEdgeData
 CGenericMapA wrapper that holds a MapBase::ConstPtr and exposes a reduced set of functionality needed by the mathematical operators
 CGenPoints< TreeT, LeafManagerT >
 CGenPolygons< LeafManagerT, PrimBuilder >
 CGenSeamMask< TreeT, LeafManagerT >
 CGenTileMask< TreeT >
 CGenTopologyMask< SrcTreeT >
 CGetVal< IterT, StatsT >
 CGetValImpl< T, IsVector >
 CGetValImpl< T, false >
 CGetValImpl< T, true >
 CGradient< InGridT, MaskGridType, InterruptT >Compute the gradient of a scalar grid
 CGradient< MapType, DiffScheme >Center difference gradient operators, defined with respect to the range-space of the map
 CGradient< ScaleMap, CD_2ND >
 CGradient< ScaleTranslateMap, CD_2ND >
 CGradient< TranslationMap, DiffScheme >
 CGradient< UniformScaleMap, CD_2ND >
 CGradient< UniformScaleTranslateMap, CD_2ND >
 CGradientBiased< MapType, GradScheme >Biased gradient operators, defined with respect to the range-space of the map
 CGradientNormSqrd< MapType, GradScheme >
 CGradientNormSqrd< UniformScaleMap, GradScheme >Partial template specialization of GradientNormSqrd
 CGradientNormSqrd< UniformScaleTranslateMap, GradScheme >Partial template specialization of GradientNormSqrd
 CGridDescriptor
 CGridNamePredPredicate functor that returns true for grids that have a specified name
 CGridOperator< InGridT, MaskGridType, OutGridT, MapT, OperatorT, InterruptT >Apply an operator on an input grid to produce an output grid with the same topology but a possibly different value type
 CGridOrTreeConstructor< TreeType >
 CGridOrTreeConstructor< Grid< TreeType > >
 CGridResampler
 CGridSampler< GridOrTreeType, SamplerType >Class that provides the interface for continuous sampling of values in a tree
 CGridSampler< tree::ValueAccessor< TreeT >, SamplerType >Specialization of GridSampler for construction from a ValueAccessor type
 CHalfReader< IsReal, T >
 CHalfReader< false, T >Partial specialization for non-floating-point types (no half to float promotion)
 CHalfReader< true, T >Partial specialization for floating-point types
 CHalfWriter< IsReal, T >
 CHalfWriter< false, T >Partial specialization for non-floating-point types (no float to half quantization)
 CHalfWriter< true, T >Partial specialization for floating-point types
 CHistogramThis class computes a histogram, with a fixed interval width, of a population of floating-point values
 CHistOp< IterT, ValueOp >
 CHomogeneousMatMul
 CInactivateValues< TreeType >
 CInactivePruneOp< TreeT, TerminationLevel >
 CInactiveTileValues< TreeType >
 CInactiveVoxelValues< TreeType >
 CPointPartitioner< PointIndexType, BucketLog2Dim >::IndexIterator
 CVector< T >::InfNormOp
 CInternalNode< _ChildNodeType, Log2Dim >
 CInvertedTree< HeadT, HeadLevel >
 CInvertedTree< HeadT, 1 >
 Cis_diagonal_jacobian< T >
 Cis_double< T >
 Cis_double< double >
 Cis_linear< T >Map traits
 Cis_linear< AffineMap >
 Cis_linear< CompoundMap< T1, T2 > >
 Cis_linear< ScaleMap >
 Cis_linear< ScaleTranslateMap >
 Cis_linear< TranslationMap >
 Cis_linear< UniformScaleMap >
 Cis_linear< UniformScaleTranslateMap >
 Cis_linear< UnitaryMap >
 Cis_scale< T >
 Cis_scale< ScaleMap >
 Cis_scale_translate< T >
 Cis_scale_translate< ScaleTranslateMap >
 Cis_uniform_diagonal_jacobian< T >
 Cis_uniform_scale< T >
 Cis_uniform_scale< UniformScaleMap >
 Cis_uniform_scale_translate< T >
 Cis_uniform_scale_translate< TranslationMap >
 Cis_uniform_scale_translate< UniformScaleTranslateMap >
 Cis_vec3d< Vec3T >
 Cis_vec3d< Vec3d >
 CISCurl< DiffScheme >Curl operator defined in index space using various first derivative schemes
 CISDivergence< DiffScheme >Divergence operator defined in index space using various first derivative schemes
 CVector< T >::IsFiniteOp
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::IsFiniteOp
 CISGradient< DiffScheme >Gradient operators defined in index space of various orders
 CISGradientBiased< GradScheme, Vec3Bias >Biased Gradient Operators, using upwinding defined by the Vec3Bias input
 CISGradientNormSqrd< GradScheme >
 CISLaplacian< DiffScheme >Laplacian defined in index space, using various center-difference stencils
 CISLaplacian< CD_FOURTH >
 CISLaplacian< CD_SECOND >
 CISLaplacian< CD_SIXTH >
 CISLaplacianOp< BoolTreeType, BoundaryOp >Functor for use with LeafManager::foreach() to populate a sparse Laplacian matrix
 CISMeanCurvature< DiffScheme2, DiffScheme1 >Compute the mean curvature in index space
 CValidateIntersectingVoxels< TreeType >::IsNegative
 CISOpMagnitude< OpType >Adapter for vector-valued index-space operators to return the vector magnitude
 CBIAS_SCHEME< bgs >::ISStencil< GridType, IsSafe >
 CBIAS_SCHEME< FIRST_BIAS >::ISStencil< GridType, IsSafe >
 CBIAS_SCHEME< SECOND_BIAS >::ISStencil< GridType, IsSafe >
 CBIAS_SCHEME< THIRD_BIAS >::ISStencil< GridType, IsSafe >
 CBIAS_SCHEME< WENO5_BIAS >::ISStencil< GridType, IsSafe >
 CBIAS_SCHEME< HJWENO5_BIAS >::ISStencil< GridType, IsSafe >
 Citerator
 CLeafManager< TreeT >::LeafRange::Iterator
 CNodeList< NodeT >::NodeRange::Iterator
 CIteratorBase< MaskIterT, NodeT >Base class for iterators over internal and leaf nodes
 CIteratorBase< MaskDenseIter, NodeT >
 CIteratorBase< MaskDenseIterator, NodeT >
 CIteratorRange< IterT >
 CIterListItem< PrevItemT, NodeVecT, VecSize, _Level >An IterListItem is an element of a compile-time linked list of iterators to nodes of different types
 CIterListItem< IterListItem, RestT, VecSize-1, 1 >
 CIterListItem< PrevChildItem, InvTreeT, ROOT_LEVEL+1, 0 >
 CIterListItem< PrevItem, InvTreeT, ROOT_LEVEL+1, LEAF_LEVEL >
 CIterListItem< PrevItemT, NodeVecT, 1, _Level >The final element of a compile-time linked list of iterators to nodes of different types
 CIterListItem< PrevItemT, NodeVecT, VecSize, 0U >The initial element of a compile-time linked list of iterators to nodes of different types
 CIterListItem< PrevValueItem, InvTreeT, ROOT_LEVEL+1, 0 >
 CIterTraits< IterT, AuxT >
 CIterTraits< NodeT, IterT >
 CIterTraits< NodeT, typename NodeT::ChildAllCIter >
 CIterTraits< NodeT, typename NodeT::ChildAllIter >
 CIterTraits< NodeT, typename NodeT::ChildOffCIter >
 CIterTraits< NodeT, typename NodeT::ChildOffIter >
 CIterTraits< NodeT, typename NodeT::ChildOnCIter >
 CIterTraits< NodeT, typename NodeT::ChildOnIter >
 CIterTraits< NodeT, typename NodeT::ValueAllCIter >
 CIterTraits< NodeT, typename NodeT::ValueAllIter >
 CIterTraits< NodeT, typename NodeT::ValueOffCIter >
 CIterTraits< NodeT, typename NodeT::ValueOffIter >
 CIterTraits< NodeT, typename NodeT::ValueOnCIter >
 CIterTraits< NodeT, typename NodeT::ValueOnIter >
 CIterTraits< tree::TreeValueIteratorBase< TreeT, ValueIterT > >
 CIterTraits< typename PrevIterT::NonConstNodeType, PrevIterT >
 CLabelBoundaryVoxels< LeafNodeType >Negative active values are set 0, everything else is set to 1
 CLaplacian< GridT, MaskGridType, InterruptT >
 CLaplacian< MapType, DiffScheme >Compute the Laplacian at a given location in a grid using finite differencing of various orders. The result is defined in the range of the map
 CLaplacian< ScaleMap, DiffScheme >
 CLaplacian< ScaleTranslateMap, DiffScheme >
 CLaplacian< TranslationMap, DiffScheme >
 CLaplacian< UniformScaleMap, DiffScheme >
 CLaplacian< UniformScaleTranslateMap, DiffScheme >
 CLaplacian< UnitaryMap, DiffScheme >
 CLeafBS< IntLeafT >
 CMorphology< TreeType >::LeafCache
 CLeafCountOp< LeafType >Functor for use with LeafManager::foreach() to populate an array with per-leaf active voxel counts
 CLeafIndexOp< LeafType >Functor for use with LeafManager::foreach() to populate active leaf voxels with sequential indices
 CLeafIteratorBase< TreeT, RootChildOnIterT >Base class for tree-traversal iterators over all leaf nodes (but not leaf voxels)
 CLeafManager< TreeT >This class 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
 CLeafManagerImpl< ManagerT >
 CLeafManagerImpl< LeafManager< const TreeT > >
 CLeafNode< T, Log2Dim >Templated block class to hold specific data types and a fixed number of values determined by Log2Dim. The actual coordinate dimension of the block is 2^Log2Dim, i.e. Log2Dim=3 corresponds to a LeafNode that spans a 8^3 block
 CLeafNode< bool, Log2Dim >LeafNode specialization for values of type bool that stores both the active states and the values of (2^Log2Dim)^3 voxels as bit masks
 CLeafNodeConnectivityTable< TreeType >
 CLeafNodeOriginOp< PointArray, PointIndexType >
 CLeafManager< TreeT >::LeafRange
 CLeafTopologyDiffOp< TreeType1, TreeType2 >Functor for use with tools::foreach() to compute the boolean difference between the value masks of corresponding leaf nodes in two trees
 CLeafTopologyIntOp< TreeType1, TreeType2 >Functor for use with tools::foreach() to compute the boolean intersection between the value masks of corresponding leaf nodes in two trees
 CLegacyFrustumLegacyFrustum class used at DreamWorks for converting old vdb files
 CLevelSetAdvection< GridT, FieldT, InterruptT >Hyperbolic advection of narrow-band level sets in an external velocity field
 CLevelSetFracture< GridType, InterruptType >Level set fracturing
 CLevelSetHDDA< TreeT, NodeLevel >Helper class that implements Hierarchical Digital Differential Analyzers and is specialized for ray intersections with level sets
 CLevelSetHDDA< TreeT,-1 >Specialization of Hierarchical Digital Differential Analyzer class that intersects a ray against the voxels of a level set
 CLevelSetMeasure< GridT, InterruptT >Multi-threaded computation of surface area, volume and average mean-curvature for narrow band level sets
 CLevelSetMorphing< GridT, InterruptT >Shape morphology of level sets. Morphing from a source narrow-band level sets to a target narrow-band level set
 CLevelSetPruneOp< TreeT, TerminationLevel >
 CLevelSetRayIntersector< GridT, SearchImplT, NodeLevel, RayT >This class provides the public API for intersecting a ray with a narrow-band level set
 CLevelSetRayTracer< GridT, IntersectorT >A (very) simple multithreaded ray tracer specifically for narrow-band level sets
 CLevelSetSphere< GridT, InterruptT >Generates a signed distance field (or narrow band level set) to a single sphere
 CLevelSetTracker< GridT, InterruptT >Performs multi-threaded interface tracking of narrow band level sets
 CLinearOp< T >
 CLinearSearchImpl< GridT, Iterations, RealT >Implements linear iterative search for an iso-value of the level set along the direction of the ray
 CMagnitude< InGridT, MaskGridType, InterruptT >
 CMapAdapter< MapType, OpType, ResultType >Adapter to associate a map with a world-space operator, giving it the same call signature as an index-space operator
 CMapBaseAbstract base class for maps
 CMappedFileHandle to control the lifetime of a memory-mapped .vdb file
 CMapPoints< Int16TreeT >Computes the point list indices for the index tree
 CMapRegistryThreadsafe singleton object for accessing the map type-name dictionary. Associates a map type-name with a factory function
 CMaskEdges< BoolTreeT >
 CMaskInteriorTiles< TreeType, InternalNodeType >
 CMaskInteriorVoxels< TreeT >
 CMaskInteriorVoxels< LeafNodeType >
 CMorphology< TreeType >::MaskManager
 CMat< SIZE, T >
 CMat2< T >
 CMat< 3, T >
 CMat< 4, double >
 CMat< 4, Real >
 CMat< 4, T >
 CMathOp< IterT, OpT, StatsT >
 CMatMul
 CMatMulNormalize
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::MatrixCopyOp
 CGridTransformer::MatrixTransform
 CMaxOp< ValueType >
 CMeanCurvature< GridT, MaskGridType, InterruptT >
 CMeanCurvature< MapType, DiffScheme2, DiffScheme1 >Compute the mean curvature
 CMeanCurvature< TranslationMap, DiffScheme2, DiffScheme1 >
 CMeanCurvature< UniformScaleMap, DiffScheme2, DiffScheme1 >
 CMeanCurvature< UniformScaleTranslateMap, DiffScheme2, DiffScheme1 >
 CMergeBinsOp< PointIndexType >
 CMergeVoxelRegions< TreeT, LeafManagerT >
 CMeshDataAdapterConvert polygonal meshes that consist of quads and/or triangles into signed or unsigned distance field volumes
 CMeshToVoxelEdgeDataExtracts and stores voxel edge intersection data from a mesh
 CMetadataBase class for storing metadata information in a grid
 CMetaMapContainer that maps names (strings) to values of arbitrary types
 CMinCombine< TreeType >
 CMinMaxVoxel< TreeType >
 CMinOp< ValueType >
 CMorphology< TreeType >
 CMovePoints
 CMoveSegmentDataOp< PointIndexType >
 CMultOp< ValueType >
 CFile::NameIterator
 CMorphology< TreeType >::Neighbor
 CNodeBS
 CNodeChain< HeadT, HeadLevel >NodeChain<RootNodeType, RootNodeType::LEVEL>::Type is a boost::mpl::vector that lists the types of the nodes of the tree rooted at RootNodeType in reverse order, from LeafNode to RootNode
 CNodeChain< HeadT, 1 >Specialization to terminate NodeChain
 CIterTraits< NodeT, typename NodeT::ValueOnIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ValueOffCIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ValueAllIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ChildOnIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ChildOffIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ChildAllCIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ValueOffIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ChildAllIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ChildOnCIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ChildOffCIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ValueOnCIter >::NodeConverter< OtherNodeT >
 CIterTraits< NodeT, typename NodeT::ValueAllCIter >::NodeConverter< OtherNodeT >
 CNodeIteratorBase< _TreeT, RootChildOnIterT >Base class for tree-traversal iterators over all nodes
 CNodeList< NodeT >This class caches tree nodes of a specific type in a linear array
 CNodeList< NodeT0 >
 CNodeList< NodeT1 >
 CNodeList< NodeT2 >
 CNodeList< NodeT3 >
 CNodeList< typename RootNodeType::ChildNodeType >
 CNodeManager< TreeOrLeafManagerT, _LEVELS >To facilitate threading over the nodes of a tree, cache node pointers in linear arrays, one for each level of the tree
 CNodeManager< TreeOrLeafManagerT, 0 >Template specialization of the NodeManager with no caching of nodes
 CNodeManager< TreeOrLeafManagerT, 1 >Template specialization of the NodeManager with one level of nodes
 CNodeManager< TreeOrLeafManagerT, 2 >Template specialization of the NodeManager with two levels of nodes
 CNodeManager< TreeOrLeafManagerT, 3 >Template specialization of the NodeManager with three levels of nodes
 CNodeManager< TreeOrLeafManagerT, 4 >Template specialization of the NodeManager with four levels of nodes
 CNodeManagerLink< NodeT, LEVEL >This class is a link in a chain that each caches tree nodes of a specific type in a linear array
 CNodeManagerLink< NodeT, 0 >Specialization that terminates the chain of cached tree nodes
 CNodeManagerLink< typename RootNodeType::ChildNodeType, LEVELS-1 >
 CNodeMask< Log2Dim >Bit mask for the internal and leaf nodes of VDB. This is a 64-bit implementation
 CNodeMask< 1 >Template specialization of NodeMask for Log2Dim=1, i.e. 2^3 nodes
 CNodeMask< 2 >Template specialization of NodeMask for Log2Dim=2, i.e. 4^3 nodes
 CNodeList< NodeT >::NodeRange
 CNodeList< NodeT >::NodeTransformer< NodeOp >
 CNodeUnionImpl< ValueIsClass, ValueT, ChildT >
 CNodeUnionImpl< boost::is_class< ValueT >::value, ValueT, ChildT >
 CNodeUnionImpl< boost::is_class< ValueType >::value, ValueType, ChildNodeType >
 CNodeUnionImpl< false, ValueT, ChildT >
 CNodeUnionImpl< true, ValueT, ChildT >
 CNormalize< GridT, MaskGridType, InterruptT >
 CNullInterrupterDummy NOOP interrupter class defining interface
 COffsetValues< TreeType >
 COpAccumulator< IterT, OpT >
 COpAdd< ValueT >
 COpMagnitude< OpType, MapT >Adapter for vector-valued world-space operators to return the vector magnitude
 COpMax< ValueT >
 COpMin< ValueT >
 COpMult< ValueT >
 COpOver< ValueT >Point wise methods used to apply various compositing operations
 COpSub< ValueT >
 CMagnitude< InGridT, MaskGridType, InterruptT >::OpT
 CNormalize< GridT, MaskGridType, InterruptT >::OpT
 COrderSegmentsOp< PointIndexType >
 Costream
 CPagedArray< ValueT, Log2PageSize >::Page
 CPagedArray< ValueT, Log2PageSize >Concurrent page-based linear data structure with O(1) random access and std-compliant iterators. It is primarily intended for applications that involve multi-threading of dynamically growing linear arrays with fast random access
 CPartGen< SrcTreeT >
 CPartialCreate
 CParticlesToLevelSet< SdfGridT, AttributeT, InterrupterT >
 CPartOp
 CPointAccessor
 CPointAdvect< GridT, PointListT, StaggeredVelocity, InterrupterType >
 CPointArrayPartitions points into BucketLog2Dim aligned buckets using a parallel radix-based sorting algorithm
 CPointArray
 CPointIndex< IntType_, Kind >Integer wrapper, required to distinguish PointIndexGrid and PointDataGrid from Int32Grid and Int64Grid
 CPointIndexFilter< PointArray, TreeType >
 CPointIndexIterator< TreeType >Accelerated range and nearest-neighbor searches for point index grids
 CPointListCopy
 CPointListTransform
 CPointPartitioner< PointIndexType, BucketLog2Dim >
 CPointSampler
 CPolygonPoolCollection of quads and triangles
 CPopulateLeafNodesOp< LeafNodeT >
 CPopulateTree< TreeType >
 CPreconditioner< T >Base class for conjugate gradient preconditioners
 CPreconditioner< MatrixType::ValueType >
 CPrimCpy
 Cpromote< S, T >
 CQuadAndTriangleDataAdapter< PointType, PolygonType >Contiguous quad and triangle data adapter class
 CQuadraticSampler
 CQuantizedUnitVec
 CQuat< T >
 CQueueQueue for asynchronous output of grids to files or streams
 CRadialRangeFilter< PointArray, IndexT >
 CRand01< FloatType, EngineType >Simple generator of random numbers over the range [0, 1)
 CRand01< double, RandomGenerator >
 CRandInt< IntType, EngineType >Simple random integer generator
 CRay< RealT >
 CRay< double >
 CRealToHalf< T >RealToHalf and its specializations define a mapping from floating-point data types to analogous half float types
 CRealToHalf< double >
 CRealToHalf< float >
 CRealToHalf< Vec2d >
 CRealToHalf< Vec2s >
 CRealToHalf< Vec3d >
 CRealToHalf< Vec3s >
 CReleaseChildNodes< NodeType >
 CRemapIndices
 CRemoveSelfIntersectingSurface< TreeType >
 CRenormalize< TreeType >
 CRestoreOrigin< TreeType >
 CReturnValue< T >
 CFilm::RGBAFloating-point RGBA components in the range [0, 1]
 CRootNode< ChildType >
 CRootNodeCombineHelper< CombineOp, RootT, OtherRootT, Compatible >
 CRootNodeCombineHelper< CombineOp, RootT, OtherRootT, true >
 CRootNodeCopyHelper< RootT, OtherRootT, Compatible >
 CRootNodeCopyHelper< RootT, OtherRootT, true >
 CRootNodeMask
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >::RowEditorRead/write accessor to a row of this matrix
 CInternalNode< _ChildNodeType, Log2Dim >::SameConfiguration< OtherNodeType >SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of an InternalNode with the same dimensions as this node and whose ChildNodeType has the same configuration as this node's ChildNodeType
 CLeafNode< T, Log2Dim >::SameConfiguration< OtherNodeType >SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node
 CLeafNode< bool, Log2Dim >::SameConfiguration< OtherNodeType >SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a LeafNode with the same dimensions as this node
 CRootNode< ChildType >::SameConfiguration< OtherNodeType >SameConfiguration<OtherNodeType>::value is true if and only if OtherNodeType is the type of a RootNode whose ChildNodeType has the same configuration as this node's ChildNodeType
 CSameInternalConfig< ChildT1, Dim1, NodeT2 >
 CSameInternalConfig< ChildT1, Dim1, InternalNode< ChildT2, Dim1 > >
 CSameLeafConfig< Dim1, NodeT2 >
 CSameLeafConfig< Dim1, LeafNode< T2, Dim1 > >
 CSameLeafConfig< Dim1, openvdb::tools::PointIndexLeafNode< T2, Dim1 > >
 CSameRootConfig< ChildT1, NodeT2 >
 CSameRootConfig< ChildT1, RootNode< ChildT2 > >
 CSampler< Order, Staggered >Provises a unified interface for sampling, i.e. interpolation
 CScalarToVectorConverter< ScalarGridType >ScalarToVectorConverter<ScalarGridType>::Type is the type of a grid having the same tree configuration as ScalarGridType but value type Vec3<T> where T is ScalarGridType::ValueType
 CSDFTilesToFogVolume< TreeType, InternalNodeType >
 CSDFVoxelsToFogVolume< LeafNodeType >
 CSeamWeights< TreeT >
 CSeedFillExteriorSign< TreeType >
 CSeedPoints< TreeType >
 CShallowCopy
 CSharedOpApplier< IterT, OpT >
 CSharedOpTransformer< InIterT, OutTreeT, OpT >
 CSignData< TreeT, LeafManagerT >
 CSignedFloodFillOp< TreeOrLeafManagerT >
 CSparseExtractor< OpType, DenseType >Functor-based class used to extract data that satisfies some criteria defined by the embedded OpType functor. The extractSparseTree function wraps this class
 CSparseMaskedExtractor< DenseType, MaskTreeType >Functor-based class used to extract data from a dense grid, at the index-space intersection with a supplied mask in the form of a sparse tree. The extractSparseTreeWithMask function wraps this class
 CSparseStencilMatrix< ValueType_, STENCIL_SIZE >Sparse, square matrix representing a 3D stencil operator of size STENCIL_SIZE
 CSparseStencilMatrix< OtherValueType, STENCIL_SIZE >
 CSparseStencilMatrix< ValueType, 4 >
 CSparseToDenseCompositor< CompositeMethod, _TreeT >
 CStaggeredBoxSampler
 CStaggeredPointSampler
 CStaggeredQuadraticSampler
 CStashOriginAndStoreOffset< TreeType >
 CStateInformation about the state of a conjugate gradient solution
 CLevelSetTracker< GridT, InterruptT >::StateLightweight struct that stores the state of the LevelSetTracker
 CStatsOp< IterT, ValueOp, StatsT >
 CStealUniqueLeafNodes< TreeType >
 CStreamMetadataContainer for metadata describing how to unserialize grids from and/or serialize grids to a stream (which file format, compression scheme, etc. to use)
 CSumOp< ValueType >
 CSwappedCombineOp< ValueType, CombineOp >
 CSweepExteriorSign< TreeType >
 CSyncVoxelMask< TreeType >
 CTagSeamEdges< TreeT >
 CTestLeafIO< typename >
 CRay< RealT >::TimeSpan
 CToBoolGrid< GridType >ToBoolGrid<T>::Type is the type of a grid having the same tree hierarchy as grid type T but a value type of bool
 CTolerance< ValueType >
 CTolerance< T >Tolerance for floating-point comparison
 CTolerance< double >
 CTolerance< float >
 CTolerancePruneOp< TreeT, TerminationLevel >
 CTopologyCopy
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyCopy1< OtherInternalNode >
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyCopy2< OtherInternalNode >
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyIntersection< OtherInternalNode >
 CInternalNode< _ChildNodeType, Log2Dim >::TopologyUnion< OtherInternalNode >
 CTransformCalculate an axis-aligned bounding box in index space from a bounding sphere in world space
 CTransformPoints< PointType >
 CTransformValues< TreeType >
 CTree3< T, N1, N2 >Tree3<T, N1, N2>::Type is the type of a three-level tree (Root, Internal, Leaf) with value type T and internal and leaf node log dimensions N1 and N2, respectively
 CTree4< T, N1, N2, N3 >Tree4<T, N1, N2, N3>::Type is the type of a four-level tree (Root, Internal, Internal, Leaf) with value type T and internal and leaf node log dimensions N1, N2 and N3, respectively
 CTree4< EdgeData, 5, 4, 3 >
 CTree5< T, N1, N2, N3, N4 >Tree5<T, N1, N2, N3, N4>::Type is the type of a five-level tree (Root, Internal, Internal, Internal, Leaf) with value type T and internal and leaf node log dimensions N1, N2, N3 and N4, respectively
 CTreeAdapter< _TreeType >This adapter allows code that is templated on a Tree type to accept either a Tree type or a Grid type
 CTreeAdapter< Grid< _TreeType > >Partial specialization for Grid types
 CTreeAdapter< tree::ValueAccessor< _TreeType > >Partial specialization for ValueAccessor types
 CTreeBaseBase class for typed trees
 CTreeIterTraits< TreeT, IterT >TreeIterTraits provides, for all tree iterators, a begin(tree) function that returns an iterator over a tree of arbitrary type
 CTreeIterTraits< TreeT, typename TreeT::LeafCIter >
 CTreeIterTraits< TreeT, typename TreeT::LeafIter >
 CTreeIterTraits< TreeT, typename TreeT::NodeCIter >
 CTreeIterTraits< TreeT, typename TreeT::NodeIter >
 CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllCIter >
 CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllIter >
 CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffCIter >
 CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffIter >
 CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnCIter >
 CTreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnIter >
 CTreeIterTraits< TreeT, typename TreeT::ValueAllCIter >
 CTreeIterTraits< TreeT, typename TreeT::ValueAllIter >
 CTreeIterTraits< TreeT, typename TreeT::ValueOffCIter >
 CTreeIterTraits< TreeT, typename TreeT::ValueOffIter >
 CTreeIterTraits< TreeT, typename TreeT::ValueOnCIter >
 CTreeIterTraits< TreeT, typename TreeT::ValueOnIter >
 CTreeTraits< TreeT >Useful traits for Tree types
 CTreeTraits< const TreeT >
 CTreeValueIteratorBase< _TreeT, _ValueIterT >Base class for tree-traversal iterators over tile and voxel values
 CTuple< SIZE, T >
 CTuple< 2, T >
 CTuple< 3, double >
 CTuple< 3, Real >
 CTuple< 3, T >
 CTuple< 4, T >
 CUniformPrimBuilder
 CUnionValueMasks< LeafNodeTypeA, LeafNodeTypeB >
 CUniquePtr< T >
 CUniquePtr< openvdb::Vec3s >
 CMorphology< TreeType >::UpdateMasks
 CUpdatePoints
 CValidateIntersectingVoxels< TreeType >
 CValidPartitioningOp< PointArrayT >
 CValueAccessorBase< TreeType, IsSafe >This base class for ValueAccessors manages registration of an accessor with a tree so that the tree can automatically clear the accessor whenever one of its nodes is deleted
 CValueAccessorBase< _TreeType, IsSafe >
 CValueAccessorBase< const BoolTreeT, true >
 CValueAccessorBase< const Int16TreeT, true >
 CValueAccessorBase< const IntTreeT, true >
 CValueAccessorBase< const TreeT, IsSafe >
 CValueAccessorBase< const TreeT, true >
 CValueAccessorBase< const TreeType, IsSafe >
 CValueAccessorBase< const TreeType, true >
 CValueAccessorBase< Int16TreeT, true >
 CValueAccessorBase< Int32TreeType, true >
 CValueAccessorBase< IntTreeT, true >
 CValueAccessorBase< TreeT, true >
 CValueAccessorBase< TreeType, true >
 CValueAccessorBase< UCharTreeType, true >
 CInternalNode< _ChildNodeType, Log2Dim >::ValueAll
 CLeafNode< T, Log2Dim >::ValueAll
 CPagedArray< ValueT, Log2PageSize >::ValueBuffer
 CInternalNode< _ChildNodeType, Log2Dim >::ValueConverter< OtherValueType >ValueConverter<T>::Type is the type of an InternalNode having the same child hierarchy and dimensions as this node but a different value type, T
 CRootNode< ChildType >::ValueConverter< OtherValueType >ValueConverter<T>::Type is the type of a RootNode having the same child hierarchy as this node but a different value type, T
 CGrid< _TreeType >::ValueConverter< OtherValueType >ValueConverter<T>::Type is the type of a grid having the same hierarchy as this grid but a different value type, T
 CLeafNode< bool, Log2Dim >::ValueConverter< ValueType >ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T
 CLeafNode< T, Log2Dim >::ValueConverter< OtherValueType >ValueConverter<T>::Type is the type of a LeafNode having the same dimensions as this node but a different value type, T
 CTree< _RootNodeType >::ValueConverter< OtherValueType >ValueConverter<T>::Type is the type of a tree having the same hierarchy as this tree but a different value type, T
 CTree< _RootNodeType >::ValueConverter< Int32 >
 CInternalNode< _ChildNodeType, Log2Dim >::ValueOff
 CLeafNode< T, Log2Dim >::ValueOff
 CInternalNode< _ChildNodeType, Log2Dim >::ValueOn
 CLeafNode< T, Log2Dim >::ValueOn
 CVector< T >Lightweight, variable-length vector
 CVector< ValueType >
 CVectorToScalarConverter< VectorGridType >VectorToScalarConverter<VectorGridType>::Type is the type of a grid having the same tree configuration as VectorGridType but a scalar value type, T, where T is the type of the original vector components
 CVecTraits< T >
 CVecTraits< math::Vec2< T > >
 CVecTraits< math::Vec3< T > >
 CVecTraits< math::Vec4< T > >
 CVelocityIntegrator< GridT, Staggered, SampleOrder >Performs Runge-Kutta time integration of variable order in a static velocity field
 CVelocitySampler< GridT, Staggered, Order >
 CVelocitySampler< GridT, Staggered, SampleOrder >
 CVersionId
 CVolumeAdvection< VelocityGridT, StaggeredVelocity, InterrupterType >Performs advections of an arbitrary type of volume in a static velocity field. The advections is performed by means of various derivatives of Semi-Lagrangian integration, i.e. backwards tracking along the hyperbolic characteristics followed by interpolation
 CVolumeHDDA< TreeT, RayT, ChildNodeLevel >Helper class that implements Hierarchical Digital Differential Analyzers for ray intersections against a generic volume
 CVolumeHDDA< openvdb::v3_1_0::tree::Tree, RayType, NodeLevel >
 CVolumeHDDA< TreeT, RayT, 0 >Specialization of Hierarchical Digital Differential Analyzer class that intersects against the leafs or tiles of a generic volume
 CVolumeRayIntersector< GridT, NodeLevel, RayT >This class provides the public API for intersecting a ray with a generic (e.g. density) volume
 CVolumeRender< IntersectorT, SamplerT >A (very) simple multithreaded volume render specifically for scalar density
 CVolumeToMeshMesh any scalar grid that has a continuous isosurface
 CVoxelizationData< TreeType >TBB body object to voxelize a mesh of triangles and/or quads into a collection of VDB grids, namely a squared distance grid, a closest primitive grid and an intersecting voxels grid (masks the mesh intersecting voxels)
 CVoxelizePolygons< TreeType, MeshDataAdapter, Interrupter >
 CVoxelOrderOp< PointIndexType, BucketLog2Dim >