OpenVDB: Class Hierarchy

OpenVDB 5.0.0

Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123]

C InternalNode< _ChildNodeType, Log2Dim >::TopologyUnion< OtherInternalNode >::A |
C InternalNode< _ChildNodeType, Log2Dim >::TopologyIntersection< OtherInternalNode >::A |
C InternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >::A |
C ABTransform | This 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
▶C AttributeArray::AccessorBase | Accessor base class for AttributeArray storage where type is not available
C AttributeArray::Accessor< T > |
C AccessorEval< CodecType, ValueType > | Accessor to call unsafe get and set methods based on templated Codec and Value
C AccessorEval< UnknownCodec, ValueType > | Partial specialization when Codec is not known at compile-time to use the supplied functor instead
C ActivationOp< TreeType > |
C AdaptiveLeafNodePointCount< PointIndexLeafNode > |
C AdaptivePrimBuilder |
C AddNodes< TreeType > |
C AlphaMask< GridT, MaskT, SamplerT, FloatT > |
C AppendAttributeOp< PointDataTreeType > |
▶C Archive | Grid serializer/unserializer
C File | Grid archive associated with a file on disk
C Stream | Grid archive associated with arbitrary input and output streams (not necessarily files)
C Array< T > |
▶C AttributeArray | Base class for storing attribute data
C TypedAttributeArray< ValueType_, Codec_ > | Typed class for storing attribute data
▶C AttributeHandle< ValueType, CodecType > |
C AttributeWriteHandle< ValueType, CodecType > | Write-able version of AttributeHandle
▶C AttributeHandle< StringIndexType, openvdb::v5_0::points::StringCodec< false > > |
C AttributeWriteHandle< StringIndexType, openvdb::v5_0::points::StringCodec< false > > |
C AttributeHashFilter< RandGenT, IntType > |
C AttributeTypeConversion< ValueType, CodecType > |
C AttributeTypeConversion< Name, CodecType > |
C LevelSetFilter< GridT, MaskT, InterruptT >::Filter::Avg< Axis > |
C InternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode >::B |
▶C BaseCamera | Abstract base class for the perspective and orthographic cameras
C OrthographicCamera |
C PerspectiveCamera |
▶C RootNodeMask::BaseIterator |
C RootNodeMask::DenseIterator |
C RootNodeMask::OffIterator |
C RootNodeMask::OnIterator |
▶C BaseMaskIterator< NodeMask > | Base class for the bit mask iterators
C DenseMaskIterator< NodeMask > |
C OffMaskIterator< NodeMask > |
C OnMaskIterator< NodeMask > |
▶C BasePointScatter< PointAccessorType, RandomGenerator, InterruptType > | Forward declaration of base class
C DenseUniformPointScatter< PointAccessorType, RandomGenerator, InterruptType > | Scatters a fixed (and integer) number of points in all active voxels and tiles
C NonUniformPointScatter< PointAccessorType, RandomGenerator, InterruptType > | Non-uniform scatters of point in the active voxels. The local point count is implicitly defined as a product of of a global density (called pointsPerVolume) and the local voxel (or tile) value
C UniformPointScatter< PointAccessorType, RandomGenerator, InterruptType > | The two point scatters UniformPointScatter and NonUniformPointScatter depend on the following two classes:
▶C BaseShader | Abstract base class for the shaders
C DiffuseShader< GridT, SamplerType > | Simple diffuse Lambertian surface shader
C DiffuseShader< Film::RGBA, SamplerType > |
C MatteShader< GridT, SamplerType > | Shader that produces a simple matte
C MatteShader< Film::RGBA, SamplerType > |
C NormalShader< GridT, SamplerType > | Color shader that treats the surface normal (x, y, z) as an RGB color
C NormalShader< Film::RGBA, SamplerType > |
C PositionShader< GridT, SamplerType > | Color shader that treats position (x, y, z) as an RGB color in a cube defined from an axis-aligned bounding box in world space
C PositionShader< Film::RGBA, SamplerType > |
C BaseStencil< DerivedType, GridT, IsSafe > |
▶C BaseStencil< BoxStencil< GridT, IsSafe >, GridT, IsSafe > |
C BoxStencil< GridT, IsSafe > |
▶C BaseStencil< BoxStencil< GridT, true >, GridT, true > |
C BoxStencil< GridT > |
▶C BaseStencil< CurvatureStencil< GridT, IsSafe >, GridT, IsSafe > |
C CurvatureStencil< GridT, IsSafe > |
▶C BaseStencil< DenseStencil< GridT, IsSafe >, GridT, IsSafe > |
C DenseStencil< GridT, IsSafe > | Dense stencil of a given width
▶C BaseStencil< FourthOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe > |
C FourthOrderDenseStencil< GridT, IsSafe > |
▶C BaseStencil< GradStencil< GridT, IsSafe >, GridT, IsSafe > |
C GradStencil< GridT, IsSafe > |
▶C BaseStencil< NineteenPointStencil< GridT, IsSafe >, GridT, IsSafe > |
C NineteenPointStencil< GridT, IsSafe > |
▶C BaseStencil< SecondOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe > |
C SecondOrderDenseStencil< GridT, IsSafe > |
▶C BaseStencil< SevenPointStencil< GridT, IsSafe >, GridT, IsSafe > |
C SevenPointStencil< GridT, IsSafe > |
▶C BaseStencil< SixthOrderDenseStencil< GridT, IsSafe >, GridT, IsSafe > |
C SixthOrderDenseStencil< GridT, IsSafe > |
▶C BaseStencil< ThirteenPointStencil< GridT, IsSafe >, GridT, IsSafe > |
C ThirteenPointStencil< GridT, IsSafe > |
▶C BaseStencil< WenoStencil< GridT, IsSafe >, GridT, IsSafe > |
C WenoStencil< GridT, IsSafe > | This is a special 19-point stencil that supports optimal fifth-order WENO upwinding, second-order central differencing, Laplacian, and zero-crossing test
C BBox< Vec3T > | Axis-aligned bounding box
C BBox< PosType > |
C BBox< Vec3d > |
C BBoxFilter |
C BBoxFilter< ParticleArrayType, IndexT > |
C BBoxFilter< PointArray, IndexT > |
C BIAS_SCHEME< bgs > |
C BIAS_SCHEME< FIRST_BIAS > |
C BIAS_SCHEME< HJWENO5_BIAS > |
C BIAS_SCHEME< SECOND_BIAS > |
C BIAS_SCHEME< THIRD_BIAS > |
C BIAS_SCHEME< WENO5_BIAS > |
C BinaryFilter< T1, T2, And > |
C BinPointIndicesOp< PointArray, PointIndexType, VoxelOffsetType > |
C GroupHandle::BitMask |
C BlindData< VisibleT, BlindT > |
C BloscCompressAttributesOp< PointDataTreeType > |
C BoolSampler |
▶C BoxSampler |
C Sampler< 1, false > |
C BuildPrimarySegment< TreeType, Operation > |
C BuildSecondarySegment< TreeType, Operation > |
C CacheItem< TreeCacheT, NodeVecT, AtRoot > |
C CacheItem< TreeCacheT, NodeVecT, true > | The tail of a compile-time list of cached node pointers, ordered from LeafNode to RootNode
C CacheItem< ValueAccessor, SubtreeT, boost::mpl::size< SubtreeT >::value==1 > |
C CalculatePositionBounds< PositionArrayT > |
C CanConvertType< FromType, ToType > | CanConvertType<FromType, ToType>::value is `true` if a value of type ToType can be constructed from a value of type FromType
C CanConvertType< math::Vec2< T >, math::Vec2< T > > |
C CanConvertType< math::Vec3< T >, math::Vec3< T > > |
C CanConvertType< math::Vec4< T >, math::Vec4< T > > |
C CanConvertType< PointDataIndex32, PointIndex32 > |
C CanConvertType< PointIndex32, PointDataIndex32 > |
C CanConvertType< T, math::Vec2< T > > |
C CanConvertType< T, math::Vec3< T > > |
C CanConvertType< T, math::Vec4< T > > |
C CanConvertType< T, ValueMask > |
C CanConvertType< T0, math::Vec2< T1 > > |
C CanConvertType< T0, math::Vec3< T1 > > |
C CanConvertType< T0, math::Vec4< T1 > > |
C CanConvertType< ValueMask, T > |
C ChangeBackgroundOp< TreeOrLeafManagerT > |
C ChangeLevelSetBackgroundOp< TreeOrLeafManagerT > |
C CheckDivergence< GridT, TreeIterT, DiffScheme > | Checks the divergence against a range
C CheckEikonal< GridT, TreeIterT, StencilT > | Checks the norm of the gradient at zero-crossing voxels against a range
C CheckFinite< GridT, TreeIterT > | Checks for both NaN and inf values, i.e. any value that is not finite
C CheckFogVolume< GridType > | Class that performs various types of checks on fog volumes
C CheckInf< GridT, TreeIterT > | Checks for infinite values, e.g. 1/0 or -1/0
C CheckLevelSet< GridType > | Class that performs various types of checks on narrow-band level sets
C CheckMagnitude< 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
C CheckMax< GridT, TreeIterT > | Checks a value against a maximum
C CheckMin< GridT, TreeIterT > | Checks a value against a minimum
C CheckNan< GridT, TreeIterT > | Checks NaN values
C CheckNormGrad< GridT, TreeIterT, GradScheme > | Checks the norm of the gradient against a range, i.e., |∇Φ| ∈ [min, max]
C CheckRange< GridT, MinInclusive, MaxInclusive, TreeIterT > | Checks a value against a range
C InternalNode< _ChildNodeType, Log2Dim >::ChildAll |
C LeafNode< T, Log2Dim >::ChildAll |
C InternalNode< _ChildNodeType, Log2Dim >::ChildOff |
C LeafNode< T, Log2Dim >::ChildOff |
C LeafNode< T, Log2Dim >::ChildOn |
C InternalNode< _ChildNodeType, Log2Dim >::ChildOn |
C ClosestPointDist< Index32LeafT > |
C ClosestPointProjector< CptGridT > |
C ClosestSurfacePoint< GridT > | Accelerated closest surface point queries for narrow band level sets
C CollapseAttributeOp< ValueType, PointDataTreeType > |
C CollapseAttributeOp< Name, PointDataTreeType > |
C CombineArgs< 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
C CombineLeafNodes< TreeType > |
C CombineOpAdapter< 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
C RemoveSelfIntersectingSurface< TreeType >::Comp |
C CompactAttributesOp< PointDataTreeType > |
C CompositeFunctorTranslator< OP, ValueT > | Translator that converts an enum to compositing functor types
C CompositeFunctorTranslator< DS_ADD, ValueT > |
C CompositeFunctorTranslator< DS_MAX, ValueT > |
C CompositeFunctorTranslator< DS_MIN, ValueT > |
C CompositeFunctorTranslator< DS_MULT, ValueT > |
C CompositeFunctorTranslator< DS_OVER, ValueT > |
C CompositeFunctorTranslator< DS_SUB, ValueT > |
C CompoundMap< 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
C CompReplaceOp< TreeT > |
C ComputeActiveVoxelCount< VolumePtrType > |
C ComputeAuxiliaryData< InputTreeType > |
C ComputeExtremas< ParticleArrayT > |
C ComputeIntersectingVoxelSign< TreeType, MeshDataAdapter > |
C ComputeNeumannVelocityOp< Vec3GridT, GradientT > |
C ComputeNodeConnectivity< TreeType > |
C ComputePointOrderOp< PointIndexType > |
C ComputePoints< InputTreeType > |
C ComputePolygons< TreeType, PrimBuilder > |
C ConnectNodeMaskSegments< TreeType, NodeType > |
C ConstrainedPointAdvect< GridT, PointListT, StaggeredVelocity, CptGridType, InterrupterType > |
C SparseStencilMatrix< ValueType_, STENCIL_SIZE >::ConstRow | Read-only accessor to a row of this matrix
C ConstructVoxelMask< TreeType > |
C SparseStencilMatrix< ValueType_, STENCIL_SIZE >::ConstValueIter | Iterator over the stored values in a row of this matrix
C Container |
C ContiguousOp< 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
C Conversion | Dummy class for tag dispatch of conversion constructors
C ConversionTraits< T > |
C ConversionTraits< openvdb::Name > |
C ConvertGrid< FromGridT, ToGridT > |
C ConvertGrid< GridT, GridT > |
C ConvertPointDataGridAttributeOp< PointDataTreeType, Attribute > |
C ConvertPointDataGridGroupOp< PointDataTreeType, Group > |
C ConvertPointDataGridPositionOp< PointDataTreeType, Attribute > |
C Coord | Signed (x, y, z) 32-bit integer coordinates
C CoordBBox | Axis-aligned bounding box of signed integer coordinates
C CopyableOpApplier< IterT, OpT > |
C CopyableOpTransformer< InIterT, OutTreeT, OpT > |
C CopyArray< T > |
C CopyConstness< FromType, ToType > |
C CopyConstness< const FromType, ToType > |
C CopyFromDense< _TreeT, _DenseT > | Copy the values from a dense grid into an OpenVDB tree
C CopyFromVecOp< TreeValueType, VIndexTreeType, VectorValueType > | Functor for use with LeafManager::foreach() to populate a tree with values from a vector
C CopyGroupOp< PointDataTreeType > | Copy a group attribute value from one group offset to another
C CopyLeafNodes< TreeT > |
C Morphology< TreeType >::CopyMasks |
C CopyOp< T > |
C CopyToDense< _TreeT, _DenseT > | Copy an OpenVDB tree into an existing dense grid
C CopyToVecOp< VectorValueType, SourceTreeType > | Functor for use with LeafManager::foreach() to populate a vector with the values of a tree's active voxels
C CopyTraits< T > |
C CopyTraits< math::Coord > |
C CopyTraits< math::Vec2< T > > |
C CopyTraits< math::Vec3< T > > |
C CopyTraits< math::Vec4< T > > |
C Cpt< InGridT, MaskGridType, InterruptT > | Compute the closest-point transform of a scalar grid
C CPT< MapType, DiffScheme > | Compute the closest-point transform to a level set
C CPT_RANGE< MapType, DiffScheme > | Compute the closest-point transform to a level set
C CpuTimer | Simple timer for basic profiling
C CreateOrderedPointIndexArrayOp< PointIndexType > |
▶C CsgVisitorBase< TreeType > |
C CsgDiffVisitor< TreeType > |
C CsgIntersectVisitor< TreeType > |
C CsgUnionVisitor< TreeType > |
C Curl< GridT, MaskGridType, InterruptT > | Compute the curl of a vector grid
C Curl< 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
C Curl< UniformScaleMap, CD_2ND > | Full template specialization of Curl
C Curl< UniformScaleMap, DiffScheme > | Partial template specialization of Curl
C Curl< UniformScaleTranslateMap, CD_2ND > | Full template specialization of Curl
C Curl< UniformScaleTranslateMap, DiffScheme > | Partial template specialization of Curl
C D1< DiffScheme > |
C D1< BD_1ST > |
C D1< BD_2ND > |
C D1< BD_3RD > |
C D1< BD_HJWENO5 > |
C D1< BD_WENO5 > |
C D1< CD_2ND > |
C D1< CD_2NDT > |
C D1< CD_4TH > |
C D1< CD_6TH > |
C D1< FD_1ST > |
C D1< FD_2ND > |
C D1< FD_3RD > |
C D1< FD_HJWENO5 > |
C D1< FD_WENO5 > |
C D1Vec< DiffScheme > |
C D1Vec< CD_2ND > |
C D1Vec< CD_2NDT > |
C D1Vec< CD_4TH > |
C D1Vec< CD_6TH > |
C D2< DiffScheme > |
C D2< CD_FOURTH > |
C D2< CD_SECOND > |
C D2< CD_SIXTH > |
C DDA< RayT, Log2Dim > | A Digital Differential Analyzer specialized for OpenVDB grids
C DDA< RayT, LeafT::TOTAL > |
C DDA< RayT, NodeT::TOTAL > |
C DDA< RayType, NodeT::TOTAL > |
C Tree< _RootNodeType >::DeallocateNodes< NodeType > |
C InternalNode< _ChildNodeType, Log2Dim >::DeepCopy< OtherInternalNode > |
C DeleteByFilterOp< PointDataTreeT, FilterT > |
C Delta< T > | Delta for small floating-point offsets
C Delta< double > |
C Delta< float > |
▶C DenseBase< ValueT, Layout > | Base class for Dense which is defined below
C Dense< ValueT, Layout > | Dense is a simple dense grid API used by the CopyToDense and CopyFromDense classes defined below
C DenseBase< ValueT, LayoutXYZ > | Partial template specialization of DenseBase
C DenseBase< ValueT, LayoutZYX > | Partial template specialization of DenseBase
C DenseTransformer< _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
▶CDescriptor |
C AttributeSet | Ordered collection of uniquely-named attribute arrays
C Vector< T >::DeterministicDotProductOp |
C Diagnose< GridT > | Performs multithreaded diagnostics of a grid
C Diagnose< GridType > |
C DiffLeafNodeMask< TreeType > |
C DilateOp< TreeT > |
C DilationOp< TreeT > | Class that performs multi-threaded dilation with support for active tiles
C DimToWord< Log2Dim > | Mapping from a Log2Dim to a data type of size 2^Log2Dim bits
C DimToWord< 3 > |
C DimToWord< 4 > |
C DimToWord< 5 > |
C DimToWord< 6 > |
C DimToWord< LEAF_LOG2DIM > |
C DiracDelta< RealT > | Smeared-out and continuous Dirac Delta function
C DirichletBoundaryOp< ValueType > | Dirichlet boundary condition functor
C DiscreteField< VelGridT, Interpolator > | Thin wrapper class for a velocity grid
C Divergence< InGridT, MaskGridType, InterruptT > | Compute the divergence of a vector grid
C Divergence< 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
C Divergence< ScaleMap, CD_2ND > |
C Divergence< ScaleMap, DiffScheme > |
C Divergence< ScaleTranslateMap, CD_2ND > |
C Divergence< ScaleTranslateMap, DiffScheme > |
C Divergence< TranslationMap, DiffScheme > |
C Divergence< UniformScaleMap, CD_2ND > |
C Divergence< UniformScaleMap, DiffScheme > |
C Divergence< UniformScaleTranslateMap, CD_2ND > |
C Divergence< UniformScaleTranslateMap, DiffScheme > |
C DropAttributesOp< PointDataTreeType > |
C DSConverter< DenseType, TreeType > |
C DualGridSampler< 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
C DualGridSampler< AccT, SamplerT > |
C DualGridSampler< tree::ValueAccessor< TreeT >, SamplerT > | Specialization of DualGridSampler for construction from a ValueAccessor type
C MeshToVoxelEdgeData::EdgeData | Internal edge data type
C EnrightField< ScalarT > | Analytical, divergence-free and periodic velocity field
C ErodeOp< TreeT > |
C Morphology< TreeType >::ErodeVoxelsOp |
▶Cexception |
▶C Exception |
C ArithmeticError |
C IllegalValueException |
C IndexError |
C IoError |
C KeyError |
C LookupError |
C NotImplementedError |
C ReferenceError |
C RuntimeError |
C TypeError |
C ValueError |
C ExpandLeafNodeRegion< TreeType > |
C ExpandNarrowband< TreeType, MeshDataAdapter > |
C ExpandNarrowbandMask< TreeType > |
C ExtractAll< _ResultTreeType, DenseValueType > | Simple utility class used by `extractSparseTreeWithMask`
▶C Extrema | This class computes the minimum and maximum values of a population of floating-point values
C Stats | This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values
C LeafBuffer< T, Log2Dim >::FileInfo |
C FillArray< ValueType > |
C FillArray< ValueType > |
C FillLeafNodeVoxels< TreeType > |
C FillMaskBoundary< TreeType > |
C FillOp< T > |
C Film | A simple class that allows for concurrent writes to pixels in an image, background initialization of the image, and PPM or EXR file output
C Filter< GridT, MaskT, InterruptT > | Volume filtering (e.g., diffusion) with optional alpha masking
C FilterTraits< T > |
C FilterTraits< BBoxFilter > |
C FilterTraits< BinaryFilter< T0, T1, And > > |
C FilterTraits< LevelSetFilter< T > > |
C FilterType | Selectively extract and filter point data using a custom filter operator
C FindMinMaxVoxelValue< LeafNodeType > |
C FindMinTileValue< InternalNodeType > |
C FindMinVoxelValue< LeafNodeType > |
C FixedPointCodec< OneByte, Range > |
C FlagAndCountQuadsToSubdivide |
C FlipRegionSign< LeafNodeType > |
C FloodFillSign< TreeType > |
C FormattedInt< IntT > | I/O manipulator that formats integer values with thousands separators
C ExpandNarrowband< TreeType, MeshDataAdapter >::Fragment |
C Divergence< InGridT, MaskGridType, InterruptT >::Functor< DiffScheme > |
C Gradient< InGridT, MaskGridType, InterruptT >::Functor |
C Laplacian< GridT, MaskGridType, InterruptT >::Functor |
C MeanCurvature< GridT, MaskGridType, InterruptT >::Functor |
C Magnitude< InGridT, MaskGridType, InterruptT >::Functor |
C Normalize< GridT, MaskGridType, InterruptT >::Functor |
C MeshToVoxelEdgeData::GenEdgeData |
C GenericMap | A wrapper that holds a MapBase::ConstPtr and exposes a reduced set of functionality needed by the mathematical operators
C GetVal< IterT, StatsT > |
C GetValImpl< T, IsVector > |
C GetValImpl< T, false > |
C GetValImpl< T, true > |
C Gradient< InGridT, MaskGridType, InterruptT > | Compute the gradient of a scalar grid
C Gradient< MapType, DiffScheme > | Center difference gradient operators, defined with respect to the range-space of the `map`
C Gradient< ScaleMap, CD_2ND > |
C Gradient< ScaleTranslateMap, CD_2ND > |
C Gradient< TranslationMap, DiffScheme > |
C Gradient< UniformScaleMap, CD_2ND > |
C Gradient< UniformScaleTranslateMap, CD_2ND > |
C GradientBiased< MapType, GradScheme > | Biased gradient operators, defined with respect to the range-space of the map
C GradientNormSqrd< MapType, GradScheme > |
C GradientNormSqrd< UniformScaleMap, GradScheme > | Partial template specialization of GradientNormSqrd
C GradientNormSqrd< UniformScaleTranslateMap, GradScheme > | Partial template specialization of GradientNormSqrd
C GreaterCount |
C GridCombinerOp< GridT > | Combines multiple grids into one by stealing leaf nodes and summing voxel values This class is designed to work with thread local storage containers such as tbb::combinable
C GridDescriptor |
C GridNamePred | Predicate functor that returns `true` for grids that have a specified name
C GridOperator< InGridT, MaskGridType, OutGridT, MapT, OperatorT, InterruptT > | Apply an operator to an input grid to produce an output grid with the same active voxel topology but a potentially different value type
C GridOrTreeConstructor< TreeType > |
C GridOrTreeConstructor< TreeType > |
C GridOrTreeConstructor< Grid< TreeType > > |
C GridOrTreeConstructor< Grid< TreeType > > |
▶C GridResampler |
C GridTransformer | A GridTransformer applies a geometric transformation to an input grid using one of several sampling schemes, and stores the result in an output grid
C GridSampler< GridOrTreeType, SamplerType > | Class that provides the interface for continuous sampling of values in a tree
C GridSampler< tree::ValueAccessor< TreeT >, SamplerType > | Specialization of GridSampler for construction from a ValueAccessor type
C GroupCodec |
C GroupFilter | Index filtering on group membership
▶C GroupHandle |
C GroupWriteHandle |
C GroupInfo | Convenience class with methods for analyzing group data
C HalfReader< IsReal, T > |
C HalfReader< false, T > | Partial specialization for non-floating-point types (no half to float promotion)
C HalfReader< true, T > | Partial specialization for floating-point types
C HalfWriter< IsReal, T > |
C HalfWriter< false, T > | Partial specialization for non-floating-point types (no float to half quantization)
C HalfWriter< true, T > | Partial specialization for floating-point types
C HasMultiPassIO< LeafNodeType > | Metafunction that specifies whether a given leaf node, tree, or grid type requires multiple passes to read and write voxel data
C HasMultiPassIO< Grid< TreeType > > |
C HasMultiPassIO< tree::Tree< RootNodeType > > |
C Histogram | This class computes a histogram, with a fixed interval width, of a population of floating-point values
C HistOp< IterT, ValueOp > |
C HomogeneousMatMul |
C IdentifyIntersectingVoxels< InputTreeType > |
C InactivateValues< TreeType > |
C InactivePruneOp< TreeT, TerminationLevel > |
C InactiveTileValues< TreeType > |
C InactiveVoxelValues< TreeType > |
C IndexIter< IteratorT, FilterT > | A forward iterator over array indices with filtering IteratorT can be either IndexIter or ValueIndexIter (or some custom index iterator) FilterT should be a struct or class with a valid() method than can be evaluated per index Here's a simple filter example that only accepts even indices:
C PointPartitioner< PointIndexType, BucketLog2Dim >::IndexIterator |
C Vector< T >::InfNormOp |
C InitialiseAttributesOp< PointDataTreeType, PointIndexTreeType > |
C AttributeSet::Inserter | Utility method to construct a NameAndType sequence
C InternalNode< _ChildNodeType, Log2Dim > |
C InvertedTree< HeadT, HeadLevel > |
C InvertedTree< HeadT, 1 > |
C is_diagonal_jacobian< T > |
C is_double< T > |
C is_double< double > |
C is_linear< T > | Map traits
C is_linear< AffineMap > |
C is_linear< CompoundMap< T1, T2 > > |
C is_linear< ScaleMap > |
C is_linear< ScaleTranslateMap > |
C is_linear< TranslationMap > |
C is_linear< UniformScaleMap > |
C is_linear< UniformScaleTranslateMap > |
C is_linear< UnitaryMap > |
C is_scale< T > |
C is_scale< ScaleMap > |
C is_scale_translate< T > |
C is_scale_translate< ScaleTranslateMap > |
C is_uniform_diagonal_jacobian< T > |
C is_uniform_scale< T > |
C is_uniform_scale< UniformScaleMap > |
C is_uniform_scale_translate< T > |
C is_uniform_scale_translate< TranslationMap > |
C is_uniform_scale_translate< UniformScaleTranslateMap > |
C is_vec3d< Vec3T > |
C is_vec3d< Vec3d > |
C ISCurl< DiffScheme > | Curl operator defined in index space using various first derivative schemes
C ISDivergence< DiffScheme > | Divergence operator defined in index space using various first derivative schemes
C Vector< T >::IsFiniteOp |
C SparseStencilMatrix< ValueType_, STENCIL_SIZE >::IsFiniteOp |
C ISGradient< DiffScheme > | Gradient operators defined in index space of various orders
C ISGradientBiased< GradScheme, Vec3Bias > | Biased Gradient Operators, using upwinding defined by the `Vec3Bias` input
C ISGradientNormSqrd< GradScheme > |
C ISLaplacian< DiffScheme > | Laplacian defined in index space, using various center-difference stencils
C ISLaplacian< CD_FOURTH > |
C ISLaplacian< CD_SECOND > |
C ISLaplacian< CD_SIXTH > |
C ISLaplacianOp< VIdxTreeT, BoundaryOp > | Functor for use with LeafManager::foreach() to populate a sparse Laplacian matrix
C ISMeanCurvature< DiffScheme2, DiffScheme1 > | Compute the mean curvature in index space
C ValidateIntersectingVoxels< TreeType >::IsNegative |
C ISOpMagnitude< OpType > | Adapter for vector-valued index-space operators to return the vector magnitude
C ISStaggeredLaplacianOp< BoolTreeType, BoundaryOp > | Functor for use with LeafManager::foreach() to populate a sparse Laplacian matrix
C BIAS_SCHEME< bgs >::ISStencil< GridType, IsSafe > |
C BIAS_SCHEME< FIRST_BIAS >::ISStencil< GridType, IsSafe > |
C BIAS_SCHEME< SECOND_BIAS >::ISStencil< GridType, IsSafe > |
C BIAS_SCHEME< THIRD_BIAS >::ISStencil< GridType, IsSafe > |
C BIAS_SCHEME< WENO5_BIAS >::ISStencil< GridType, IsSafe > |
C BIAS_SCHEME< HJWENO5_BIAS >::ISStencil< GridType, IsSafe > |
▶Citerator |
C PagedArray< ValueT, Log2PageSize, TableT >::ConstIterator |
C PagedArray< ValueT, Log2PageSize, TableT >::Iterator |
C LeafManager< TreeT >::LeafRange::Iterator |
C NodeList< NodeT >::NodeRange::Iterator |
C CoordBBox::Iterator< ZYXOrder > | Iterator over the Coord domain covered by a CoordBBox
C ParticleAtlas< PointIndexGridType >::Iterator | Provides accelerated range and nearest-neighbor searches for particles that are partitioned using the ParticleAtlas
▶C IteratorBase< MaskIterT, NodeT > | Base class for iterators over internal and leaf nodes
C DenseIteratorBase< MaskIterT, IterT, NodeT, SetItemT, UnsetItemT > | Base class for dense iterators over internal and leaf nodes
C SparseIteratorBase< MaskIterT, IterT, NodeT, ItemT > | Base class for sparse iterators over internal and leaf nodes
▶C SparseIteratorBase< MaskIterT, ChildIter< MaskIterT, NodeT >, NodeT, bool > |
C LeafNode< bool, Log2Dim >::ChildIter< MaskIterT, NodeT > | Leaf nodes have no children, so their child iterators have no get/set accessors
C LeafNode< ValueMask, Log2Dim >::ChildIter< MaskIterT, NodeT > | Leaf nodes have no children, so their child iterators have no get/set accessors
▶C SparseIteratorBase< MaskIterT, ChildIter< MaskIterT, NodeT, TagT >, NodeT, ValueType > |
C LeafNode< T, Log2Dim >::ChildIter< MaskIterT, NodeT, TagT > | Leaf nodes have no children, so their child iterators have no get/set accessors
▶C SparseIteratorBase< MaskIterT, ChildIter< NodeT, ChildT, MaskIterT, TagT >, NodeT, ChildT > |
C InternalNode< _ChildNodeType, Log2Dim >::ChildIter< NodeT, ChildT, MaskIterT, TagT > |
▶C SparseIteratorBase< MaskIterT, ValueIter< MaskIterT, NodeT, ValueT >, NodeT, ValueT > |
C LeafNode< bool, Log2Dim >::ValueIter< MaskIterT, NodeT, ValueT > |
C LeafNode< ValueMask, Log2Dim >::ValueIter< MaskIterT, NodeT, ValueT > |
▶C SparseIteratorBase< MaskIterT, ValueIter< MaskIterT, NodeT, ValueT, TagT >, NodeT, ValueT > |
C LeafNode< T, Log2Dim >::ValueIter< MaskIterT, NodeT, ValueT, TagT > |
▶C SparseIteratorBase< MaskIterT, ValueIter< NodeT, ValueT, MaskIterT, TagT >, NodeT, ValueT > |
C InternalNode< _ChildNodeType, Log2Dim >::ValueIter< NodeT, ValueT, MaskIterT, TagT > |
▶C IteratorBase< MaskDenseIter, NodeT > |
▶C DenseIteratorBase< MaskDenseIter, DenseIter< NodeT, ValueT >, NodeT, void, ValueT > |
C LeafNode< bool, Log2Dim >::DenseIter< NodeT, ValueT > |
C LeafNode< ValueMask, Log2Dim >::DenseIter< NodeT, ValueT > |
▶C IteratorBase< MaskDenseIterator, NodeT > |
▶C DenseIteratorBase< MaskDenseIterator, DenseIter< NodeT, ChildT, ValueT, TagT >, NodeT, ChildT, ValueT > |
C InternalNode< _ChildNodeType, Log2Dim >::DenseIter< NodeT, ChildT, ValueT, TagT > |
▶C DenseIteratorBase< MaskDenseIterator, DenseIter< NodeT, ValueT, TagT >, NodeT, void, ValueT > |
C LeafNode< T, Log2Dim >::DenseIter< NodeT, ValueT, TagT > |
C IteratorRange< IterT > |
C IterListItem< PrevItemT, NodeVecT, VecSize, _Level > | An IterListItem is an element of a compile-time linked list of iterators to nodes of different types
C IterListItem< IterListItem, RestT, VecSize - 1, 1 > |
C IterListItem< PrevChildItem, InvTreeT, ROOT_LEVEL+1, 0 > |
C IterListItem< PrevItem, InvTreeT, ROOT_LEVEL+1, LEAF_LEVEL > |
C IterListItem< PrevItemT, NodeVecT, 1, _Level > | The final element of a compile-time linked list of iterators to nodes of different types
C IterListItem< PrevItemT, NodeVecT, VecSize, 0U > | The initial element of a compile-time linked list of iterators to nodes of different types
C IterListItem< PrevValueItem, InvTreeT, ROOT_LEVEL+1, 0 > |
C IterTraits< NodeT, IterT > |
C IterTraits< IterT, AuxT > |
C IterTraits< NodeT, typename NodeT::ChildAllCIter > |
C IterTraits< NodeT, typename NodeT::ChildAllIter > |
C IterTraits< NodeT, typename NodeT::ChildOffCIter > |
C IterTraits< NodeT, typename NodeT::ChildOffIter > |
C IterTraits< NodeT, typename NodeT::ChildOnCIter > |
C IterTraits< NodeT, typename NodeT::ChildOnIter > |
C IterTraits< NodeT, typename NodeT::ValueAllCIter > |
C IterTraits< NodeT, typename NodeT::ValueAllIter > |
C IterTraits< NodeT, typename NodeT::ValueOffCIter > |
C IterTraits< NodeT, typename NodeT::ValueOffIter > |
C IterTraits< NodeT, typename NodeT::ValueOnCIter > |
C IterTraits< NodeT, typename NodeT::ValueOnIter > |
C IterTraits< tree::TreeValueIteratorBase< TreeT, ValueIterT > > |
C IterTraits< typename PrevIterT::NonConstNodeType, PrevIterT > |
C LabelBoundaryVoxels< LeafNodeType > | Negative active values are set `0`, everything else is set to `1`
C Laplacian< GridT, MaskGridType, InterruptT > |
C Laplacian< 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
C Laplacian< ScaleMap, DiffScheme > |
C Laplacian< ScaleTranslateMap, DiffScheme > |
C Laplacian< TranslationMap, DiffScheme > |
C Laplacian< UniformScaleMap, DiffScheme > |
C Laplacian< UniformScaleTranslateMap, DiffScheme > |
C Laplacian< UnitaryMap, DiffScheme > |
C LeafBuffer< T, Log2Dim > | Array of fixed size 23Log2Dim that stores the voxel values of a LeafNode
C LeafBuffer< bool, Log2Dim > |
C LeafBuffer< ValueType, Log2Dim > |
C LeafBufferFlags< T > |
C LeafBufferFlags< ValueType > |
C Morphology< TreeType >::LeafCache |
C LeafCountOp< LeafType > | Functor for use with LeafManager::foreach() to populate an array with per-leaf active voxel counts
C LeafIndexOp< LeafType > | Functor for use with LeafManager::foreach() to populate active leaf voxels with sequential indices
C LeafIteratorBase< TreeT, RootChildOnIterT > | Base class for tree-traversal iterators over all leaf nodes (but not leaf voxels)
C LeafManager< 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
C LeafManagerImpl< ManagerT > |
C LeafManagerImpl< LeafManager< const TreeT > > |
▶C LeafNode< 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
C PointDataLeafNode< T, Log2Dim > |
C PointIndexLeafNode< T, Log2Dim > |
C LeafNode< 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
C LeafNode< ValueMask, Log2Dim > | LeafNode specialization for values of type ValueMask that encodes both the active states and the boolean values of (2^Log2Dim)^3 voxels in a single bit mask, i.e. voxel values and states are indistinguishable!
C LeafNodeConnectivityTable< TreeType > |
C LeafNodeOriginOp< PointArray, PointIndexType > |
C LeafNodePointCount< LeafNodeLog2Dim > |
C LeafNodeVoxelOffsets |
C LeafOp< Index32LeafT > |
C LeafManager< TreeT >::LeafRange |
C LeafTopologyDiffOp< TreeType1, TreeType2 > | Functor for use with tools::foreach() to compute the boolean difference between the value masks of corresponding leaf nodes in two trees
C LeafTopologyIntOp< TreeType1, TreeType2 > | Functor for use with tools::foreach() to compute the boolean intersection between the value masks of corresponding leaf nodes in two trees
C LegacyFrustum | LegacyFrustum class used at DreamWorks for converting old vdb files
C LevelScope | A LevelScope object sets the logging level to a given level and restores it to the current level when the object goes out of scope
C LevelSetAdvection< GridT, FieldT, InterruptT > | Hyperbolic advection of narrow-band level sets in an external velocity field
C LevelSetFilter< LevelSetGridT > |
C LevelSetFracture< GridType, InterruptType > | Level set fracturing
C LevelSetHDDA< TreeT, NodeLevel > | Helper class that implements Hierarchical Digital Differential Analyzers and is specialized for ray intersections with level sets
C LevelSetHDDA< TreeT, -1 > | Specialization of Hierarchical Digital Differential Analyzer class that intersects a ray against the voxels of a level set
C LevelSetMeasure< GridT, InterruptT > | Multi-threaded computation of surface area, volume and average mean-curvature for narrow band level sets
C LevelSetMorphing< GridT, InterruptT > | Shape morphology of level sets. Morphing from a source narrow-band level sets to a target narrow-band level set
C LevelSetPruneOp< TreeT, TerminationLevel > |
C LevelSetRayIntersector< GridT, SearchImplT, NodeLevel, RayT > | This class provides the public API for intersecting a ray with a narrow-band level set
C LevelSetRayTracer< GridT, IntersectorT > | A (very) simple multithreaded ray tracer specifically for narrow-band level sets
C LevelSetSphere< GridT, InterruptT > | Generates a signed distance field (or narrow band level set) to a single sphere
▶C LevelSetTracker< GridT, InterruptT > | Performs multi-threaded interface tracking of narrow band level sets
C LevelSetFilter< GridT, MaskT, InterruptT > | Filtering (e.g. diffusion) of narrow-band level sets. An optional scalar field can be used to produce a (smooth) alpha mask for the filtering
C LinearOp< T > |
C LinearSearchImpl< GridT, Iterations, RealT > | Implements linear iterative search for an iso-value of the level set along the direction of the ray
C Magnitude< InGridT, MaskGridType, InterruptT > |
C MapAdapter< MapType, OpType, ResultType > | Adapter to associate a map with a world-space operator, giving it the same call signature as an index-space operator
▶C MapBase | Abstract base class for maps
C AffineMap | A general linear transform using homogeneous coordinates to perform rotation, scaling, shear and translation
C NonlinearFrustumMap | This map is composed of three steps. First it will take a box of size (Lx X Ly X Lz) defined by a member data bounding box and map it into a frustum with near plane (1 X Ly/Lx) and prescribed depth Then this frustum is transformed by an internal second map: most often a uniform scale, but other effects can be achieved by accumulating translation, shear and rotation: these are all applied to the second map
▶C ScaleMap | A specialized Affine transform that scales along the principal axis the scaling need not be uniform in the three-directions
C UniformScaleMap | A specialized Affine transform that scales along the principal axis the scaling is uniform in the three-directions
▶C ScaleTranslateMap | A specialized Affine transform that scales along the principal axis the scaling need not be uniform in the three-directions, and then translates the result
C UniformScaleTranslateMap | A specialized Affine transform that uniformaly scales along the principal axis and then translates the result
C TranslationMap | A specialized linear transform that performs a translation
C UnitaryMap | A specialized linear transform that performs a unitary maping i.e. rotation and or reflection
C MappedFile | Handle to control the lifetime of a memory-mapped .vdb file
C MapPoints< PointIndexLeafNode > |
C MapRegistry | Threadsafe singleton object for accessing the map type-name dictionary. Associates a map type-name with a factory function
C MaskBorderVoxels< BoolTreeType > |
C MaskDisorientedTrianglePoints< InputTreeType > |
C MaskedCopy< TreeType > |
C MaskInteriorTiles< TreeType, InternalNodeType > |
C MaskInteriorVoxels< TreeT > |
C MaskInteriorVoxels< LeafNodeType > |
C MaskIntersectingVoxels< InputTreeType > |
C MaskIsovalueCrossingVoxels< InputTreeType > |
C Morphology< TreeType >::MaskManager |
C MultiResGrid< TreeType >::MaskOp |
C MaskSeamLineVoxels< TreeType > |
C MaskSegmentGroup< TreeType > |
C MaskSurface< BoolTreeType > |
C MaskTileBorders< InputTreeType > |
▶C Mat< SIZE, T > |
C Mat3< double > |
C Mat2< T > |
▶C Mat< 3, T > |
C Mat3< T > | 3x3 matrix class
▶C Mat< 4, double > |
C Mat4< double > |
▶C Mat< 4, Real > |
C Mat4< Real > |
▶C Mat< 4, T > |
C Mat4< T > | 4x4 -matrix class
C MathOp< IterT, OpT, StatsT > |
C MatMul |
C MatMulNormalize |
C SparseStencilMatrix< ValueType_, STENCIL_SIZE >::MatrixCopyOp |
C GridTransformer::MatrixTransform |
C MaxOp< ValueType > |
C MeanCurvature< MapType, DiffScheme2, DiffScheme1 > | Compute the mean curvature
C MeanCurvature< GridT, MaskGridType, InterruptT > |
C MeanCurvature< TranslationMap, DiffScheme2, DiffScheme1 > |
C MeanCurvature< UniformScaleMap, DiffScheme2, DiffScheme1 > |
C MeanCurvature< UniformScaleTranslateMap, DiffScheme2, DiffScheme1 > |
C MergeBinsOp< PointIndexType > |
C MergeVoxelRegions< InputGridType > |
C MeshDataAdapter | Convert polygonal meshes that consist of quads and/or triangles into signed or unsigned distance field volumes
C MeshToVoxelEdgeData | Extracts and stores voxel edge intersection data from a mesh
▶C Metadata | Base class for storing metadata information in a grid
C TypedMetadata< T > | Templated metadata class to hold specific types
C UnknownMetadata | Subclass to hold raw data of an unregistered type
C MetadataStorage< PointDataTree, ValueType > |
C MetadataStorage< PointDataTree, Name > |
▶C MetaMap | Container that maps names (strings) to values of arbitrary types
▶C GridBase | Abstract base class for typed grids
C Grid< _TreeType > | Container class that associates a tree with a transform and metadata
C MultiResGrid< TreeType > |
C MinCombine< TreeType > |
C MinMax< ValueType, Less > | Templated class to compute the minimum and maximum values
C MinOp< ValueType > |
C Morphology< TreeType > |
C MoveSegmentDataOp< PointIndexType > |
C MultiGroupFilter |
▶C MultiPass | Leaf nodes that require multi-pass I/O must inherit from this struct
C PointDataLeafNode< T, Log2Dim > |
C MultOp< ValueType > |
C AttributeSet::Util::NameAndType | Attribute and type name pair
C File::NameIterator |
C Morphology< TreeType >::Neighbor |
C NodeChain< 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
C NodeChain< HeadT, 1 > | Specialization to terminate NodeChain
C IterTraits< NodeT, typename NodeT::ValueOffCIter >::NodeConverter< OtherNodeT > |
C IterTraits< NodeT, typename NodeT::ChildOnIter >::NodeConverter< OtherNodeT > |
C IterTraits< NodeT, typename NodeT::ChildAllIter >::NodeConverter< OtherNodeT > |
C IterTraits< NodeT, typename NodeT::ValueOffIter >::NodeConverter< OtherNodeT > |
C IterTraits< NodeT, typename NodeT::ValueOnCIter >::NodeConverter< OtherNodeT > |
C IterTraits< NodeT, typename NodeT::ValueAllIter >::NodeConverter< OtherNodeT > |
C IterTraits< NodeT, typename NodeT::ValueOnIter >::NodeConverter< OtherNodeT > |
C IterTraits< NodeT, typename NodeT::ChildOffCIter >::NodeConverter< OtherNodeT > |
C IterTraits< NodeT, typename NodeT::ValueAllCIter >::NodeConverter< OtherNodeT > |
C IterTraits< NodeT, typename NodeT::ChildAllCIter >::NodeConverter< OtherNodeT > |
C IterTraits< NodeT, typename NodeT::ChildOnCIter >::NodeConverter< OtherNodeT > |
C IterTraits< NodeT, typename NodeT::ChildOffIter >::NodeConverter< OtherNodeT > |
C NodeIteratorBase< _TreeT, RootChildOnIterT > | Base class for tree-traversal iterators over all nodes
C NodeList< NodeT > | This class caches tree nodes of a specific type in a linear array
C NodeList< NodeT0 > |
C NodeList< NodeT1 > |
C NodeList< NodeT2 > |
C NodeList< NodeT3 > |
C NodeList< typename RootNodeType::ChildNodeType > |
C NodeManager< TreeOrLeafManagerT, _LEVELS > | To facilitate threading over the nodes of a tree, cache node pointers in linear arrays, one for each level of the tree
C NodeManagerLink< NodeT, LEVEL > | This class is a link in a chain that each caches tree nodes of a specific type in a linear array
C NodeManagerLink< typename RootNodeType::ChildNodeType, LEVELS-1 > |
C NodeMask< Log2Dim > | Bit mask for the internal and leaf nodes of VDB. This is a 64-bit implementation
C NodeMask< 1 > | Template specialization of NodeMask for Log2Dim=1, i.e. 2^3 nodes
C NodeMask< 2 > | Template specialization of NodeMask for Log2Dim=2, i.e. 4^3 nodes
C NodeMaskSegment< NodeType > |
C NodeOp |
C NodeList< NodeT >::NodeRange |
C NodeUnion< ValueT, ChildT, Enable > |
C NodeUnion< ValueT, ChildT, typename std::enable_if< CopyTraits< ValueT >::IsCopyable >::type > |
C NodeUnion< ValueT, ChildT, typename std::enable_if< openvdb::v5_0::tree::CopyTraits< ValueT >::IsCopyable >::type > |
C NodeUnion< ValueT, ChildT, typename std::enable_if< std::is_pod< ValueT >::value >::type > |
C NodeUnion< ValueType, ChildNodeType > |
C Normalize< GridT, MaskGridType, InterruptT > |
C NullCodec |
C NullFilter | A no-op filter that can be used when iterating over all indices
C NullInterrupter | Dummy NOOP interrupter class defining interface
C OffsetAndMinComp< TreeType > |
C OffsetValues< TreeType > |
C OpAccumulator< IterT, OpT > |
C OpAdd< ValueT > |
C OpMagnitude< OpType, MapT > | Adapter for vector-valued world-space operators to return the vector magnitude
C OpMax< ValueT > |
C OpMin< ValueT > |
C OpMult< ValueT > |
C OpOver< ValueT > | Point wise methods used to apply various compositing operations
C OpSub< ValueT > |
C Magnitude< InGridT, MaskGridType, InterruptT >::OpT |
C Normalize< GridT, MaskGridType, InterruptT >::OpT |
C OrderSegmentsOp< PointIndexType > |
▶Costream |
C TempFile | Output stream to a unique temporary file
C PagedArray< ValueT, Log2PageSize, TableT >::Page |
C Page | Stores a variable-size, compressed, delayed-load Page of data that is loaded into memory when accessed. Access to the Page is thread-safe as loading and decompressing the data is protected by a mutex
C PagedArray< ValueT, Log2PageSize, TableT > | Concurrent, page-based, dynamically-sized linear data structure with O(1) random access and STL-compliant iterators. It is primarily intended for applications that concurrently insert (a possibly unkown number of) elements into a dynamically growing linear array, and fast random access to said elements
C PagedInputStream | A Paging wrapper to std::istream that is responsible for reading from a given input stream and creating Page objects and PageHandles that reference those pages for delayed reading
C PagedOutputStream | A Paging wrapper to std::ostream that is responsible for writing from a given output stream at intervals set by the PageSize. As Pages are variable in size, they are flushed to disk as soon as sufficiently large
C PageHandle | A PageHandle holds a shared ptr to a Page and a specific stream pointer to a point within the decompressed Page buffer
C ValueVoxelCIter::Parent |
C PartialCreate | Tag dispatch class that distinguishes constructors during file input
C ParticleArray | Partition particles and performs range and nearest-neighbor searches
C ParticleAtlas< PointIndexGridType > |
C ParticlesToLevelSet< SdfGridT, AttributeT, InterrupterT > |
▶CPatternLayout |
C ColoredPatternLayout | Log4cplus layout that outputs text in different colors for different log levels, using ANSI escape codes
C PointAccessor |
C PointAdvect< GridT, PointListT, StaggeredVelocity, InterrupterType > |
C PointArray | Partitions points into `BucketLog2Dim` aligned buckets using a parallel radix-based sorting algorithm
C PointArray |
C PointAttributeVector< ValueType > | Point-partitioner compatible STL vector attribute wrapper for convenience
C PointCountOp< PointDataTreeT, ValueIterT, FilterT > |
C PointDataNodeChain< HeadT, HeadLevel > | Recursive node chain which generates a boost::mpl::vector listing value converted types of nodes to PointDataGrid nodes of the same configuration, rooted at RootNodeType in reverse order, from LeafNode to RootNode. See also TreeConverter<>
C PointDataNodeChain< tree::InternalNode< ChildT, Log2Dim >, 1 > |
C PointDataNodeChain< tree::InternalNode< ChildT, Log2Dim >, HeadLevel > |
C PointIndex< IntType_, Kind > | Integer wrapper, required to distinguish PointIndexGrid and PointDataGrid from Int32Grid and Int64Grid
C PointIndexFilter< PointArray, TreeType > |
C PointIndexIterator< TreeType > | Accelerated range and nearest-neighbor searches for point index grids
C PointListCopy |
C PointListTransform |
C PointPartitioner< PointIndexType, BucketLog2Dim > |
▶C PointSampler |
C TileSampler< PointSampler, TreeT > | For point sampling, tree traversal is less expensive than testing bounding box membership
C Sampler< 0, false > |
C PointsToMask< GridT, InterrupterT > | Makes every voxel of a grid active if it contains a point
C PointsToScalarOp< GridT, PointDataGridT, FilterT > | Compute scalar grid from PointDataGrid while evaluating the point filter
C PointsToTransformedScalarOp< GridT, PointDataGridT, FilterT > | Compute scalar grid from PointDataGrid using a different transform and while evaluating the point filter
C PolygonPool | Collection of quads and triangles
C PopulateAttributeOp< PointDataTreeType, PointIndexTreeType, AttributeListType > |
C PopulateLeafNodesOp< LeafNodeT > |
C PopulatePositionAttributeOp< PointDataTreeType, PointIndexTreeType, PositionListType > |
C PopulateTree< TreeType > |
C PositionRange |
C Preconditioner< T > | Base class for conjugate gradient preconditioners
▶C Preconditioner< MatrixType::ValueType > |
C IncompleteCholeskyPreconditioner< MatrixType > | Preconditioner using incomplete Cholesky factorization
C JacobiPreconditioner< MatrixType > | Diagonal preconditioner
C PrimCpy |
C MultiResGrid< TreeType >::ProlongateOp |
C promote< S, T > |
C QuadAndTriangleDataAdapter< PointType, PolygonType > | Contiguous quad and triangle data adapter class
▶C QuadraticSampler |
C Sampler< 2, false > |
C QuantizedUnitVec | Unit vector occupying only 16 bits
C Quat< T > |
C Queue | Queue for asynchronous output of grids to files or streams
C RadialRangeFilter< ParticleArrayType, IndexT > |
C RadialRangeFilter< PointArray, IndexT > |
C Rand01< FloatType, EngineType > | Simple generator of random numbers over the range [0, 1)
C Rand01< double, RandomGenerator > |
C RandInt< IntType, EngineType > | Simple random integer generator
C RandomLeafFilter< PointDataTreeT, RandGenT > |
C Ray< RealT > |
C Ray< double > |
C RealToHalf< T > | RealToHalf and its specializations define a mapping from floating-point data types to analogous half float types
C RealToHalf< double > |
C RealToHalf< float > |
C RealToHalf< Vec2d > |
C RealToHalf< Vec2s > |
C RealToHalf< Vec3d > |
C RealToHalf< Vec3s > |
C PointsToMask< GridT, InterrupterT >::ReducePool |
C ReleaseChildNodes< NodeType > |
C RemapIndices< ParticleArrayType, PointIndexLeafNodeType > |
C RemoveSelfIntersectingSurface< TreeType > |
C Renormalize< TreeType > |
C RestoreOrigin< TreeType > |
C MultiResGrid< TreeType >::RestrictOp |
C ReturnValue< T > |
C ReviseSeamLineFlags |
C Film::RGBA | Floating-point RGBA components in the range [0, 1]
C RootNode< ChildType > |
C RootNodeCombineHelper< CombineOp, RootT, OtherRootT, Compatible > |
C RootNodeCombineHelper< CombineOp, RootT, OtherRootT, true > |
C RootNodeCopyHelper< RootT, OtherRootT, Compatible > |
C RootNodeCopyHelper< RootT, OtherRootT, true > |
C RootNodeMask |
C SparseStencilMatrix< ValueType_, STENCIL_SIZE >::RowEditor | Read/write accessor to a row of this matrix
C LeafNode< 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
C LeafNode< 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
C LeafNode< ValueMask, 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
C RootNode< 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
C InternalNode< _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
C SameInternalConfig< ChildT1, Dim1, NodeT2 > |
C SameInternalConfig< ChildT1, Dim1, InternalNode< ChildT2, Dim1 > > |
C SameLeafConfig< Dim1, NodeT2 > |
C SameLeafConfig< Dim1, LeafNode< T2, Dim1 > > |
C SameLeafConfig< Dim1, openvdb::tools::PointIndexLeafNode< T2, Dim1 > > |
C SameLeafConfig< Dim1, points::PointDataLeafNode< T2, Dim1 > > |
C SameRootConfig< ChildT1, NodeT2 > |
C SameRootConfig< ChildT1, RootNode< ChildT2 > > |
▶C Sampler< Order, Staggered > | Provises a unified interface for sampling, i.e. interpolation
C TileSampler< Sampler, TreeT > | A TileSampler wraps a grid sampler of another type (BoxSampler, QuadraticSampler, etc.), and for samples that fall within a given tile of the grid, it returns a cached tile value instead of accessing the grid
C ScalarToVectorConverter< 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
C SDFTilesToFogVolume< TreeType, InternalNodeType > |
C SDFVoxelsToFogVolume< LeafNodeType > |
C SeamLineWeights< InputTreeType > |
C SeedFillExteriorSign< TreeType > |
C SeedPoints< TreeType > |
C SegmentNodeMask< NodeType > |
C SetGroupByFilterOp< PointDataTree, FilterT, IterT > |
C SetGroupFromIndexOp< PointDataTree, PointIndexTree, Remove > |
C SetGroupOp< PointDataTree, Member > | Set membership on or off for the specified group
C SetSeamLineFlags< TreeType > |
C ShallowCopy | Tag dispatch class that distinguishes shallow copy constructors from deep copy constructors
C SharedOpApplier< IterT, OpT > |
C SharedOpTransformer< InIterT, OutTreeT, OpT > |
C SignedFloodFillOp< TreeOrLeafManagerT > |
C SolveBoundaryOp< Vec3GridT, MaskT > |
C SparseExtractor< 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
C SparseMaskedExtractor< 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
C SparseStencilMatrix< ValueType_, STENCIL_SIZE > | Sparse, square matrix representing a 3D stencil operator of size STENCIL_SIZE
C SparseStencilMatrix< OtherValueType, STENCIL_SIZE > |
C SparseStencilMatrix< ValueType, 4 > |
C SparseToDenseCompositor< CompositeMethod, _TreeT > |
C SplittableParticleArray< ParticleArrayT, PointIndex > |
▶C StaggeredBoxSampler |
C Sampler< 1, true > |
▶C StaggeredPointSampler |
C TileSampler< StaggeredPointSampler, TreeT > | For point sampling, tree traversal is less expensive than testing bounding box membership
C Sampler< 0, true > |
▶C StaggeredQuadraticSampler |
C Sampler< 2, true > |
C StashOriginAndStoreOffset< TreeType > |
C State | Information about the state of a conjugate gradient solution
C LevelSetTracker< GridT, InterruptT >::State | Lightweight struct that stores the state of the LevelSetTracker
C StatsOp< IterT, ValueOp, StatsT > |
C StealUniqueLeafNodes< TreeType > |
C NullCodec::Storage< T > |
C TruncateCodec::Storage< T > |
C UnitVecCodec::Storage< T > |
C GroupCodec::Storage< T > |
C StringCodec< Truncate >::Storage< T > |
C FixedPointCodec< OneByte, Range >::Storage< T > |
C StreamMetadata | Container for metadata describing how to unserialize grids from and/or serialize grids to a stream (which file format, compression scheme, etc. to use)
▶C StringAttributeHandle |
C StringAttributeWriteHandle |
C StringCodec< Truncate > |
C StringMetaInserter |
C StringTypeTrait< Truncate > |
C StringTypeTrait< true > |
C SubdivideQuads |
C SumOp< ValueType > |
C SwappedCombineOp< ValueType, CombineOp > |
C SweepExteriorSign< TreeType > |
C SyncMaskValues< BoolTreeType > |
C SyncVoxelMask< TreeType > |
C TestLeafIO< typename > |
C Ray< RealT >::TimeSpan |
C Tolerance< ValueType > |
C Tolerance< T > | Tolerance for floating-point comparison
C Tolerance< double > |
C Tolerance< float > |
C TolerancePruneOp< TreeT, TerminationLevel > |
C ToMaskGrid< GridType > | ToMaskGrid<T>::Type is the type of a grid having the same tree hierarchy as grid type T but a value equal to its active state
C TopologyCopy | Tag dispatch class that distinguishes topology copy constructors from deep copy constructors
C InternalNode< _ChildNodeType, Log2Dim >::TopologyCopy1< OtherInternalNode > |
C InternalNode< _ChildNodeType, Log2Dim >::TopologyCopy2< OtherInternalNode > |
C InternalNode< _ChildNodeType, Log2Dim >::TopologyDifference< OtherInternalNode > |
C InternalNode< _ChildNodeType, Log2Dim >::TopologyIntersection< OtherInternalNode > |
C InternalNode< _ChildNodeType, Log2Dim >::TopologyUnion< OtherInternalNode > |
C TransferSeamLineFlags< BoolTreeType, SignDataType > |
C Transform |
C TransformPoints< PointType > |
C TransformValues< TreeType > |
C Tree3< 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
C Tree4< 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
C Tree4< EdgeData, 5, 4, 3 > |
C Tree5< 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
C TreeAdapter< _TreeType > | This adapter allows code that is templated on a Tree type to accept either a Tree type or a Grid type
C TreeAdapter< Grid< _TreeType > > | Partial specialization for Grid types
C TreeAdapter< tree::ValueAccessor< _TreeType > > | Partial specialization for ValueAccessor types
▶C TreeBase | Base class for typed trees
C Tree< _RootNodeType > |
C TreeConverter< TreeType > | Similiar to ValueConverter, but allows for tree configuration conversion to a PointDataTree. ValueConverter<PointDataIndex32> cannot be used as a PointDataLeafNode is not a specialization of LeafNode
C TreeIterTraits< TreeT, IterT > | TreeIterTraits provides, for all tree iterators, a begin(tree) function that returns an iterator over a tree of arbitrary type
C TreeIterTraits< TreeT, typename TreeT::LeafCIter > |
C TreeIterTraits< TreeT, typename TreeT::LeafIter > |
C TreeIterTraits< TreeT, typename TreeT::NodeCIter > |
C TreeIterTraits< TreeT, typename TreeT::NodeIter > |
C TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllCIter > |
C TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildAllIter > |
C TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffCIter > |
C TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOffIter > |
C TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnCIter > |
C TreeIterTraits< TreeT, typename TreeT::RootNodeType::ChildOnIter > |
C TreeIterTraits< TreeT, typename TreeT::ValueAllCIter > |
C TreeIterTraits< TreeT, typename TreeT::ValueAllIter > |
C TreeIterTraits< TreeT, typename TreeT::ValueOffCIter > |
C TreeIterTraits< TreeT, typename TreeT::ValueOffIter > |
C TreeIterTraits< TreeT, typename TreeT::ValueOnCIter > |
C TreeIterTraits< TreeT, typename TreeT::ValueOnIter > |
C TreeTraits< TreeT > | Useful traits for Tree types
C TreeTraits< const TreeT > |
C TreeValueIteratorBase< _TreeT, _ValueIterT > | Base class for tree-traversal iterators over tile and voxel values
C TruncateCodec |
C TruncateTrait< T > |
C TruncateTrait< float > |
C TruncateTrait< int > |
C TruncateTrait< math::Vec3< T > > |
C Tuple< SIZE, T > |
▶C Tuple< 2, T > |
C Vec2< T > |
▶C Tuple< 3, double > |
C Vec3< double > |
▶C Tuple< 3, Real > |
C Vec3< Real > |
▶C Tuple< 3, T > |
C Vec3< T > |
▶C Tuple< 4, T > |
C Vec4< T > |
C UIntTypeTrait< OneByte, T > |
C UIntTypeTrait< false, math::Vec3< T > > |
C UIntTypeTrait< false, T > |
C UIntTypeTrait< true, math::Vec3< T > > |
C UIntTypeTrait< true, T > |
C UniformPrimBuilder |
C UnionValueMasks< LeafNodeTypeA, LeafNodeTypeB > |
C UnitRange |
C UnitVecCodec |
C UnknownCodec |
C Morphology< TreeType >::UpdateMasks |
C UpdatePoints |
C AttributeSet::Util |
C ValidateIntersectingVoxels< TreeType > |
C ValidPartitioningOp< PointArrayT > |
▶C ValueAccessorBase< 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
▶C ValueAccessor0< TreeType, IsSafe > |
C ValueAccessor< TreeType, IsSafe, 0, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and no cache levels
▶C ValueAccessor1< TreeType, IsSafe > |
C ValueAccessor< TreeType, IsSafe, 1, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and one cache level
▶C ValueAccessor2< TreeType, IsSafe > |
C ValueAccessor< TreeType, IsSafe, 2, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and two cache levels
▶C ValueAccessor3< TreeType, IsSafe > |
C ValueAccessor< TreeType, IsSafe, 3, tbb::null_mutex > | Template specialization of the ValueAccessor with no mutex and three cache levels
▶C ValueAccessor< TreeType, IsSafe, TreeType::DEPTH-1, tbb::spin_mutex > |
C ValueAccessorRW< TreeType, IsSafe > | This accessor is thread-safe (at the cost of speed) for both reading and writing to a tree. That is, multiple threads may safely access a single, shared ValueAccessorRW
▶C ValueAccessorBase< _TreeType, IsSafe > |
C ValueAccessor< _TreeType, IsSafe, CacheLevels, MutexType > |
C ValueAccessor0< _TreeType, IsSafe > | ValueAccessor with no mutex and no node caching
C ValueAccessor1< _TreeType, IsSafe, L0 > | Value accessor with one level of node caching
C ValueAccessor2< _TreeType, IsSafe, L0, L1 > | Value accessor with two levels of node caching
C ValueAccessor3< _TreeType, IsSafe, L0, L1, L2 > | Value accessor with three levels of node caching
▶C ValueAccessorBase< BoolTreeType, true > |
C ValueAccessor< BoolTreeType > |
▶C ValueAccessorBase< const InputTreeType, true > |
C ValueAccessor< const InputTreeType > |
▶C ValueAccessorBase< const TreeT, IsSafe > |
C ValueAccessor< const TreeT, false > |
▶C ValueAccessorBase< const TreeT, true > |
C ValueAccessor< const TreeT > |
▶C ValueAccessorBase< const TreeType, IsSafe > |
C ValueAccessor< const TreeType, IsSafe > |
▶C ValueAccessorBase< const TreeType, true > |
C ValueAccessor< const TreeType > |
▶C ValueAccessorBase< Index32TreeType, true > |
C ValueAccessor< Index32TreeType > |
▶C ValueAccessorBase< Int16TreeType, true > |
C ValueAccessor< Int16TreeType > |
▶C ValueAccessorBase< Int32TreeType, true > |
C ValueAccessor< Int32TreeType > |
▶C ValueAccessorBase< IntTreeT, true > |
C ValueAccessor< IntTreeT > |
▶C ValueAccessorBase< TreeT, true > |
C ValueAccessor< TreeT > |
▶C ValueAccessorBase< TreeType, true > |
C ValueAccessor< TreeType > |
▶C ValueAccessorBase< UCharTreeType, true > |
C ValueAccessor< UCharTreeType > |
C InternalNode< _ChildNodeType, Log2Dim >::ValueAll |
C LeafNode< T, Log2Dim >::ValueAll |
C PagedArray< ValueT, Log2PageSize, TableT >::ValueBuffer |
C InternalNode< _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
C LeafNode< ValueMask, 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
C RootNode< 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
C LeafNode< 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
C Tree< _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
C LeafNode< 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
C Grid< _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
C Tree< _RootNodeType >::ValueConverter< Int32 > |
C IndexIter< IteratorT, FilterT >::ValueIndexIter | A forward iterator over array indices from a value iterator (such as ValueOnCIter)
C ValueMask |
C LeafNode< T, Log2Dim >::ValueOff |
C InternalNode< _ChildNodeType, Log2Dim >::ValueOff |
C LeafNode< T, Log2Dim >::ValueOn |
C InternalNode< _ChildNodeType, Log2Dim >::ValueOn |
C ValueVoxelCIter | A forward iterator over array indices in a single voxel
C Vector< T > | Lightweight, variable-length vector
C Vector< ValueType > |
C VectorToScalarConverter< 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
C VectorToScalarGrid< VecGridT > | Metafunction to convert a vector-valued grid type to a scalar grid type
C VecTraits< T > |
C VecTraits< math::Vec2< T > > |
C VecTraits< math::Vec3< T > > |
C VecTraits< math::Vec4< T > > |
C VelocityIntegrator< GridT, Staggered, SampleOrder > | Performs Runge-Kutta time integration of variable order in a static velocity field
C VelocitySampler< GridT, Staggered, Order > |
C VelocitySampler< GridT, Staggered, SampleOrder > |
C VersionId |
C VolumeAdvection< VelocityGridT, StaggeredVelocity, InterrupterType > | Performs advections of an arbitrary type of volume in a static velocity field. The advections are performed by means of various derivatives of Semi-Lagrangian integration, i.e. backwards tracking along the hyperbolic characteristics followed by interpolation
C VolumeHDDA< TreeT, RayT, ChildNodeLevel > | Helper class that implements Hierarchical Digital Differential Analyzers for ray intersections against a generic volume
C VolumeHDDA< openvdb::v5_0::tree::Tree, RayType, NodeLevel > |
C VolumeHDDA< TreeT, RayT, 0 > | Specialization of Hierarchical Digital Differential Analyzer class that intersects against the leafs or tiles of a generic volume
C VolumeRayIntersector< GridT, NodeLevel, RayT > | This class provides the public API for intersecting a ray with a generic (e.g. density) volume
C VolumeRender< IntersectorT, SamplerT > | A (very) simple multithreaded volume render specifically for scalar density
C VolumeToMesh | Mesh any scalar grid that has a continuous isosurface
C VoxelEdgeAccessor< AccessorT, _AXIS > | Utility method to marks all voxels that share an edge
C VoxelizationData< 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)
C InternalNode< _ChildNodeType, Log2Dim >::VoxelizeActiveTiles |
C VoxelizePolygons< TreeType, MeshDataAdapter, Interrupter > |
C VoxelOrderOp< PointIndexType, BucketLog2Dim > |