OpenVDB: openvdb::v3_1_0::tools Namespace Reference

OpenVDB 3.1.0

- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- Namespace List
- Namespace Members

Namespaces | Classes | Typedefs | Enumerations | Functions
openvdb::v3_1_0::tools Namespace Reference

## Namespaces
| activation
| clip_internal
| composite
| diagnostics_internal
| ds
| filter_internal
| gridop
| internal
| level_set_util_internal
| local_util
| mesh_to_volume_internal
| p2ls_internal
| point_index_grid_internal
| point_partitioner_internal
| poisson
| Scheme
| stats_internal
| valxform

## Classes
class | 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. More...
class | AlphaMask
class | BaseCamera
| Abstract base class for the perspective and orthographic cameras. More...
class | BasePointScatter
| Forward declaration of base class. More...
class | BaseShader
| Abstract base class for the shaders. More...
struct | BoxSampler
class | ChangeBackgroundOp
class | ChangeLevelSetBackgroundOp
struct | CheckDivergence
| Checks the divergence against a range. More...
struct | CheckEikonal
| Checks the norm of the gradient at zero-crossing voxels against a range. More...
struct | CheckFinite
| Checks for both NaN and inf values, i.e. any value that is not finite. More...
class | CheckFogVolume
| Class that performs various types of checks on fog volumes. More...
struct | CheckInf
| Checks for infinite values, e.g. 1/0 or -1/0. More...
class | CheckLevelSet
| Class that performs various types of checks on narrow-band level sets. More...
struct | CheckMagnitude
| 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. More...
struct | CheckMax
| Checks a value against a maximum. More...
struct | CheckMin
| Checks a value against a minimum. More...
struct | CheckNan
| Checks NaN values. More...
struct | CheckNormGrad
| Checks the norm of the gradient against a range, i.e. . More...
struct | CheckRange
| Checks a value against a range. More...
class | ClosestPointProjector
class | ClosestSurfacePoint
| 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. More...
struct | CompReplaceOp
class | ConstrainedPointAdvect
struct | ContiguousOp
| a wrapper struct used to avoid unnecessary computation of memory access from `Coord` when all offsets are guaranteed to be within the dense grid. More...
class | CopyFromDense
| Copy the values from a dense grid into an OpenVDB tree. More...
class | CopyToDense
| Copy an OpenVDB tree into an existing dense grid. More...
class | Cpt
| Compute the closest-point transform of a scalar grid. More...
struct | CsgDiffVisitor
struct | CsgIntersectVisitor
struct | CsgUnionVisitor
class | CsgVisitorBase
class | Curl
| Compute the curl of a vector grid. More...
class | Dense
| Dense is a simple dense grid API used by the CopyToDense and CopyFromDense classes defined below. More...
class | DenseBase
| Base class for Dense which is defined below. More...
class | DenseBase< ValueT, LayoutXYZ >
| Partial template specialization of DenseBase. More...
class | DenseBase< ValueT, LayoutZYX >
| Partial template specialization of DenseBase. More...
class | DenseTransformer
| 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. More...
class | DenseUniformPointScatter
| Scatters a fixed (and integer) number of points in all active voxels and tiles. More...
class | Diagnose
| Performs multithreaded diagnostics of a grid. More...
class | DiffuseShader
| Simple diffuse Lambertian surface shader. More...
class | DiffuseShader< Film::RGBA, SamplerType >
struct | DimToWord
| Mapping from a Log2Dim to a data type of size 2^Log2Dim bits. More...
struct | DimToWord< 3 >
struct | DimToWord< 4 >
struct | DimToWord< 5 >
struct | DimToWord< 6 >
class | DiracDelta
| Smeared-out and continuous Dirac Delta function. More...
class | DiscreteField
| Thin wrapper class for a velocity grid. More...
class | Divergence
| Compute the divergence of a vector grid. More...
struct | DSConverter
class | DualGridSampler
| 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. More...
class | DualGridSampler< tree::ValueAccessor< TreeT >, SamplerT >
| Specialization of DualGridSampler for construction from a ValueAccessor type. More...
class | EnrightField
| Analytical, divergence-free and periodic velocity field. More...
struct | ExtractAll
| a simple utility class used by `extractSparseTreeWithMask` More...
class | 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. More...
class | Filter
| Volume filtering (e.g., diffusion) with optional alpha masking. More...
class | Gradient
| Compute the gradient of a scalar grid. More...
class | GridResampler
class | GridSampler
| Class that provides the interface for continuous sampling of values in a tree. More...
class | GridSampler< tree::ValueAccessor< TreeT >, SamplerType >
| Specialization of GridSampler for construction from a ValueAccessor type. More...
class | 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. More...
struct | HomogeneousMatMul
class | InactivePruneOp
class | Laplacian
class | LevelSetAdvection
| Hyperbolic advection of narrow-band level sets in an external velocity field. More...
class | LevelSetFilter
| 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. More...
class | LevelSetFracture
| Level set fracturing. More...
class | LevelSetMeasure
| Multi-threaded computation of surface area, volume and average mean-curvature for narrow band level sets. More...
class | LevelSetMorphing
| Shape morphology of level sets. Morphing from a source narrow-band level sets to a target narrow-band level set. More...
class | LevelSetPruneOp
class | LevelSetRayIntersector
| This class provides the public API for intersecting a ray with a narrow-band level set. More...
class | LevelSetRayTracer
| A (very) simple multithreaded ray tracer specifically for narrow-band level sets. More...
class | LevelSetSphere
| Generates a signed distance field (or narrow band level set) to a single sphere. More...
class | LevelSetTracker
| Performs multi-threaded interface tracking of narrow band level sets. More...
class | LinearSearchImpl
| Implements linear iterative search for an iso-value of the level set along the direction of the ray. More...
class | Magnitude
struct | MatMul
struct | MatMulNormalize
class | MatteShader
| Shader that produces a simple matte. More...
class | MatteShader< Film::RGBA, SamplerType >
class | MeanCurvature
class | MeshToVoxelEdgeData
| Extracts and stores voxel edge intersection data from a mesh. More...
class | Morphology
class | NonUniformPointScatter
| 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. More...
class | Normalize
class | NormalShader
| Color shader that treats the surface normal (x, y, z) as an RGB color. More...
class | NormalShader< Film::RGBA, SamplerType >
class | OrthographicCamera
class | ParticlesToLevelSet
class | PerspectiveCamera
class | PointAdvect
struct | PointIndexFilter
struct | PointIndexIterator
| Accelerated range and nearest-neighbor searches for point index grids. More...
struct | PointIndexLeafNode
class | PointPartitioner
struct | PointSampler
class | PolygonPool
| Collection of quads and triangles. More...
class | PositionShader
| 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. More...
class | PositionShader< Film::RGBA, SamplerType >
struct | QuadAndTriangleDataAdapter
| Contiguous quad and triangle data adapter class. More...
struct | QuadraticSampler
struct | Sampler
| Provises a unified interface for sampling, i.e. interpolation. More...
struct | Sampler< 0, false >
struct | Sampler< 0, true >
struct | Sampler< 1, false >
struct | Sampler< 1, true >
struct | Sampler< 2, false >
struct | Sampler< 2, true >
struct | ScalarToVectorConverter
| 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. More...
class | SignedFloodFillOp
class | SparseExtractor
| Functor-based class used to extract data that satisfies some criteria defined by the embedded `OpType` functor. The `extractSparseTree` function wraps this class. More...
class | SparseMaskedExtractor
| 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. More...
class | SparseToDenseCompositor
struct | StaggeredBoxSampler
struct | StaggeredPointSampler
struct | StaggeredQuadraticSampler
class | TolerancePruneOp
class | UniformPointScatter
| The two point scatters UniformPointScatter and NonUniformPointScatter depend on the following two classes: More...
struct | VectorToScalarConverter
| 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. More...
class | VelocityIntegrator
| Performs Runge-Kutta time integration of variable order in a static velocity field. More...
class | VelocitySampler
class | VolumeAdvection
| 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. More...
class | VolumeRayIntersector
| This class provides the public API for intersecting a ray with a generic (e.g. density) volume. More...
class | VolumeRender
| A (very) simple multithreaded volume render specifically for scalar density. More...
class | VolumeToMesh
| Mesh any scalar grid that has a continuous isosurface. More...

## Typedefs
typedef tree::Tree< tree::RootNode< tree::InternalNode< tree::InternalNode< PointIndexLeafNode< PointIndex32, 3 >, 4 >, 5 > > > | PointIndexTree
| Point index tree configured to match the default OpenVDB tree configuration. More...
typedef Grid< PointIndexTree > | PointIndexGrid
| Point index grid. More...
typedef PointPartitioner< uint32_t, 3 > | UInt32PointPartitioner
typedef boost::scoped_array< openvdb::Vec3s > | PointList
| Point and primitive list types. More...
typedef boost::scoped_array< PolygonPool > | PolygonPoolList
| Point and primitive list types. More...

## Enumerations
enum | MemoryLayout { LayoutXYZ, LayoutZYX }
enum | DSCompositeOp { DS_OVER, DS_ADD, DS_SUB, DS_MIN, DS_MAX, DS_MULT, DS_SET }
enum | MeshToVolumeFlags { UNSIGNED_DISTANCE_FIELD = 0x1, DISABLE_INTERSECTING_VOXEL_REMOVAL = 0x2, DISABLE_RENORMALIZATION = 0x4, DISABLE_NARROW_BAND_TRIMMING = 0x8 }
| Mesh to volume conversion flags. More...
enum | NearestNeighbors { NN_FACE = 6, NN_FACE_EDGE = 18, NN_FACE_EDGE_VERTEX = 26 }
| Voxel topology of nearest neighbors. More...
enum | { POLYFLAG_EXTERIOR = 0x1, POLYFLAG_FRACTURE_SEAM = 0x2, POLYFLAG_SUBDIVIDED = 0x4 }
| Polygon flags, used for reference based meshing. More...

## Functions
template<typename TreeOrLeafManagerT >
void | changeBackground (TreeOrLeafManagerT &tree, const typename TreeOrLeafManagerT::ValueType &background, bool threaded=true, size_t grainSize=32)
| Replace the background value in all the nodes of a tree. More...
template<typename TreeOrLeafManagerT >
void | changeLevelSetBackground (TreeOrLeafManagerT &tree, const typename TreeOrLeafManagerT::ValueType &halfWidth, bool threaded=true, size_t grainSize=32)
| Replace the background value in all the nodes of a floating-point tree containing a symmetric narrow-band level set. More...
template<typename TreeOrLeafManagerT >
void | changeAsymmetricLevelSetBackground (TreeOrLeafManagerT &tree, const typename TreeOrLeafManagerT::ValueType &outsideWidth, const typename TreeOrLeafManagerT::ValueType &insideWidth, bool threaded=true, size_t grainSize=32)
| Replace the background values in all the nodes of a floating-point tree containing a possibly asymmetric narrow-band level set. More...
template<typename GridType >
OPENVDB_STATIC_SPECIALIZATION GridType::Ptr | clip (const GridType &grid, const BBoxd &)
| Clip the given grid against a world-space bounding box and return a new grid containing the result. More...
template<typename GridType , typename MaskTreeType >
OPENVDB_STATIC_SPECIALIZATION GridType::Ptr | clip (const GridType &grid, const Grid< MaskTreeType > &mask)
| Clip a grid against the active voxels of another grid and return a new grid containing the result. More...
template<typename GridOrTreeT >
OPENVDB_STATIC_SPECIALIZATION void | csgUnion (GridOrTreeT &a, GridOrTreeT &b, bool prune=true)
| Given two level set grids, replace the A grid with the union of A and B. More...
template<typename GridOrTreeT >
OPENVDB_STATIC_SPECIALIZATION void | csgIntersection (GridOrTreeT &a, GridOrTreeT &b, bool prune=true)
| Given two level set grids, replace the A grid with the intersection of A and B. More...
template<typename GridOrTreeT >
OPENVDB_STATIC_SPECIALIZATION void | csgDifference (GridOrTreeT &a, GridOrTreeT &b, bool prune=true)
| Given two level set grids, replace the A grid with the difference A / B. More...
template<typename GridOrTreeT >
OPENVDB_STATIC_SPECIALIZATION void | compMax (GridOrTreeT &a, GridOrTreeT &b)
| Given grids A and B, compute max(a, b) per voxel (using sparse traversal). Store the result in the A grid and leave the B grid empty. More...
template<typename GridOrTreeT >
OPENVDB_STATIC_SPECIALIZATION void | compMin (GridOrTreeT &a, GridOrTreeT &b)
| Given grids A and B, compute min(a, b) per voxel (using sparse traversal). Store the result in the A grid and leave the B grid empty. More...
template<typename GridOrTreeT >
OPENVDB_STATIC_SPECIALIZATION void | compSum (GridOrTreeT &a, GridOrTreeT &b)
| Given grids A and B, compute a + b per voxel (using sparse traversal). Store the result in the A grid and leave the B grid empty. More...
template<typename GridOrTreeT >
OPENVDB_STATIC_SPECIALIZATION void | compMul (GridOrTreeT &a, GridOrTreeT &b)
| Given grids A and B, compute a * b per voxel (using sparse traversal). Store the result in the A grid and leave the B grid empty. More...
template<typename GridOrTreeT >
OPENVDB_STATIC_SPECIALIZATION void | compDiv (GridOrTreeT &a, GridOrTreeT &b)
| Given grids A and B, compute a / b per voxel (using sparse traversal). Store the result in the A grid and leave the B grid empty. More...
template<typename GridOrTreeT >
OPENVDB_STATIC_SPECIALIZATION void | compReplace (GridOrTreeT &a, const GridOrTreeT &b)
| Copy the active voxels of B into A. More...
template<typename DenseT , typename GridOrTreeT >
void | copyToDense (const GridOrTreeT &sparse, DenseT &dense, bool serial=false)
| Populate a dense grid with the values of voxels from a sparse grid, where the sparse grid intersects the dense grid. More...
template<typename DenseT , typename GridOrTreeT >
void | copyFromDense (const DenseT &dense, GridOrTreeT &sparse, const typename GridOrTreeT::ValueType &tolerance, bool serial=false)
| Populate a sparse grid with the values of all of the voxels of a dense grid. More...
template<typename OpType , typename DenseType >
OpType::ResultTreeType::Ptr | extractSparseTree (const DenseType &dense, const OpType &functor, const typename OpType::ResultValueType &background, bool threaded=true)
| Selectively extract and transform data from a dense grid, producing a sparse tree with leaf nodes only (e.g. create a tree from the square of values greater than a cutoff.) More...
template<typename DenseType , typename MaskTreeType >
DSConverter< DenseType, MaskTreeType >::Type::Ptr | extractSparseTreeWithMask (const DenseType &dense, const MaskTreeType &mask, const typename DenseType::ValueType &background, bool threaded=true)
| Copy data from the intersection of a sparse tree and a dense input grid. The resulting tree has the same configuration as the sparse tree, but holds the data type specified by the dense input. More...
template<typename ValueT , typename OpType >
void | transformDense (Dense< ValueT, openvdb::tools::LayoutZYX > &dense, const openvdb::CoordBBox &bbox, const OpType &op, bool parallel=true)
template<DSCompositeOp , typename TreeT >
void | compositeToDense (Dense< typename TreeT::ValueType, LayoutZYX > &dense, const TreeT &source, const TreeT &alpha, const typename TreeT::ValueType beta, const typename TreeT::ValueType strength, bool threaded=true)
| Composite data from a sparse tree into a dense array of the same value type. More...
template<typename ValueT , typename PointwiseOpT >
void | transformDense (Dense< ValueT, openvdb::tools::LayoutZYX > &dense, const openvdb::CoordBBox &bbox, const PointwiseOpT &functor, bool parallel)
| Apply a point-wise functor to the intersection of a dense grid and a given bounding box. More...
template<class GridType >
std::string | checkLevelSet (const GridType &grid, size_t number=9)
| Perform checks on a grid to see if it is a valid symmetric, narrow-band level set. More...
template<class GridType >
std::string | checkFogVolume (const GridType &grid, size_t number=6)
| Perform checks on a grid to see if it is a valid fog volume. More...
template<class GridType >
bool | uniqueInactiveValues (const GridType &grid, std::vector< typename GridType::ValueType > &values, size_t numValues)
| Threaded method to find unique inactive values. More...
template<typename GridType , typename InterruptT >
ScalarToVectorConverter< GridType >::Type::Ptr | cpt (const GridType &grid, bool threaded, InterruptT *interrupt)
| Compute the Closest-Point Transform (CPT) from a distance field. More...
template<typename GridType , typename MaskT , typename InterruptT >
ScalarToVectorConverter< GridType >::Type::Ptr | cpt (const GridType &grid, const MaskT &mask, bool threaded, InterruptT *interrupt)
template<typename GridType >
ScalarToVectorConverter< GridType >::Type::Ptr | cpt (const GridType &grid, bool threaded=true)
template<typename GridType , typename MaskT >
ScalarToVectorConverter< GridType >::Type::Ptr | cpt (const GridType &grid, const MaskT &mask, bool threaded=true)
template<typename GridType , typename InterruptT >
GridType::Ptr | curl (const GridType &grid, bool threaded, InterruptT *interrupt)
| Compute the curl of the given vector-valued grid. More...
template<typename GridType , typename MaskT , typename InterruptT >
GridType::Ptr | curl (const GridType &grid, const MaskT &mask, bool threaded, InterruptT *interrupt)
template<typename GridType >
GridType::Ptr | curl (const GridType &grid, bool threaded=true)
template<typename GridType , typename MaskT >
GridType::Ptr | curl (const GridType &grid, const MaskT &mask, bool threaded=true)
template<typename GridType , typename InterruptT >
VectorToScalarConverter< GridType >::Type::Ptr | divergence (const GridType &grid, bool threaded, InterruptT *interrupt)
| Compute the divergence of the given vector-valued grid. More...
template<typename GridType , typename MaskT , typename InterruptT >
VectorToScalarConverter< GridType >::Type::Ptr | divergence (const GridType &grid, const MaskT &mask, bool threaded, InterruptT *interrupt)
template<typename GridType >
VectorToScalarConverter< GridType >::Type::Ptr | divergence (const GridType &grid, bool threaded=true)
template<typename GridType , typename MaskT >
VectorToScalarConverter< GridType >::Type::Ptr | divergence (const GridType &grid, const MaskT &mask, bool threaded=true)
template<typename GridType , typename InterruptT >
ScalarToVectorConverter< GridType >::Type::Ptr | gradient (const GridType &grid, bool threaded, InterruptT *interrupt)
| Compute the gradient of the given scalar grid. More...
template<typename GridType , typename MaskT , typename InterruptT >
ScalarToVectorConverter< GridType >::Type::Ptr | gradient (const GridType &grid, const MaskT &mask, bool threaded, InterruptT *interrupt)
template<typename GridType >
ScalarToVectorConverter< GridType >::Type::Ptr | gradient (const GridType &grid, bool threaded=true)
template<typename GridType , typename MaskT >
ScalarToVectorConverter< GridType >::Type::Ptr | gradient (const GridType &grid, const MaskT &mask, bool threaded=true)
template<typename GridType , typename InterruptT >
GridType::Ptr | laplacian (const GridType &grid, bool threaded, InterruptT *interrupt)
| Compute the Laplacian of the given scalar grid. More...
template<typename GridType , typename MaskT , typename InterruptT >
GridType::Ptr | laplacian (const GridType &grid, const MaskT &mask, bool threaded, InterruptT *interrupt)
template<typename GridType >
GridType::Ptr | laplacian (const GridType &grid, bool threaded=true)
template<typename GridType , typename MaskT >
GridType::Ptr | laplacian (const GridType &grid, const MaskT mask, bool threaded=true)
template<typename GridType , typename InterruptT >
GridType::Ptr | meanCurvature (const GridType &grid, bool threaded, InterruptT *interrupt)
| Compute the mean curvature of the given grid. More...
template<typename GridType , typename MaskT , typename InterruptT >
GridType::Ptr | meanCurvature (const GridType &grid, const MaskT &mask, bool threaded, InterruptT *interrupt)
template<typename GridType >
GridType::Ptr | meanCurvature (const GridType &grid, bool threaded=true)
template<typename GridType , typename MaskT >
GridType::Ptr | meanCurvature (const GridType &grid, const MaskT &mask, bool threaded=true)
template<typename GridType , typename InterruptT >
VectorToScalarConverter< GridType >::Type::Ptr | magnitude (const GridType &grid, bool threaded, InterruptT *interrupt)
| Compute the magnitudes of the vectors of the given vector-valued grid. More...
template<typename GridType , typename MaskT , typename InterruptT >
VectorToScalarConverter< GridType >::Type::Ptr | magnitude (const GridType &grid, const MaskT &mask, bool threaded, InterruptT *interrupt)
template<typename GridType >
VectorToScalarConverter< GridType >::Type::Ptr | magnitude (const GridType &grid, bool threaded=true)
template<typename GridType , typename MaskT >
VectorToScalarConverter< GridType >::Type::Ptr | magnitude (const GridType &grid, const MaskT &mask, bool threaded=true)
template<typename GridType , typename InterruptT >
GridType::Ptr | normalize (const GridType &grid, bool threaded, InterruptT *interrupt)
| Normalize the vectors of the given vector-valued grid. More...
template<typename GridType , typename MaskT , typename InterruptT >
GridType::Ptr | normalize (const GridType &grid, const MaskT &mask, bool threaded, InterruptT *interrupt)
template<typename GridType >
GridType::Ptr | normalize (const GridType &grid, bool threaded=true)
template<typename GridType , typename MaskT >
GridType::Ptr | normalize (const GridType &grid, const MaskT &mask, bool threaded=true)
template<typename Sampler , typename Interrupter , typename GridType >
void | resampleToMatch (const GridType &inGrid, GridType &outGrid, Interrupter &interrupter)
| Resample an input grid into an output grid of the same type such that, after resampling, the input and output grids coincide (apart from sampling artifacts), but the output grid's transform is unchanged. More...
template<typename Sampler , typename GridType >
void | resampleToMatch (const GridType &inGrid, GridType &outGrid)
| Resample an input grid into an output grid of the same type such that, after resampling, the input and output grids coincide (apart from sampling artifacts), but the output grid's transform is unchanged. More...
template<typename Sampler , typename Interrupter , typename GridType >
void | doResampleToMatch (const GridType &inGrid, GridType &outGrid, Interrupter &interrupter)
template<class GridType >
Real | levelSetArea (const GridType &grid, bool useWorldSpace=true)
| Return the surface area of a narrow-band level set. More...
template<class GridType >
Real | levelSetVolume (const GridType &grid, bool useWorldSpace=true)
| Return the volume of a narrow-band level set surface. More...
template<class GridType >
void | levelSetMeasure (const GridType &grid, Real &area, Real &volume, bool useWorldSpace=true)
| Compute the surface area and volume of a narrow-band level set. More...
template<class GridType >
void | levelSetMeasure (const GridType &grid, Real &area, Real &volume, Real &avgCurvature, bool useWorldSpace=true)
| Compute the surface area and volume of a narrow-band level set. More...
template<class GridT >
boost::enable_if< boost::is_floating_point< typename GridT::ValueType >, Real >::type | doLevelSetArea (const GridT &grid, bool useWorldSpace)
template<class GridT >
boost::disable_if< boost::is_floating_point< typename GridT::ValueType >, Real >::type | doLevelSetArea (const GridT &, bool)
template<class GridT >
Real | levelSetArea (const GridT &grid, bool useWorldSpace)
template<class GridT >
boost::enable_if< boost::is_floating_point< typename GridT::ValueType >, Real >::type | doLevelSetVolume (const GridT &grid, bool useWorldSpace)
template<class GridT >
boost::disable_if< boost::is_floating_point< typename GridT::ValueType >, Real >::type | doLevelSetVolume (const GridT &, bool)
template<class GridT >
Real | levelSetVolume (const GridT &grid, bool useWorldSpace)
template<class GridT >
boost::enable_if< boost::is_floating_point< typename GridT::ValueType > >::type | doLevelSetMeasure (const GridT &grid, Real &area, Real &volume, bool useWorldSpace)
template<class GridT >
boost::disable_if< boost::is_floating_point< typename GridT::ValueType > >::type | doLevelSetMeasure (const GridT &, Real &, Real &, bool)
template<class GridT >
void | levelSetMeasure (const GridT &grid, Real &area, Real &volume, bool useWorldSpace)
template<class GridT >
boost::enable_if< boost::is_floating_point< typename GridT::ValueType > >::type | doLevelSetMeasure (const GridT &grid, Real &area, Real &volume, Real &avgCurvature, bool useWorldSpace)
template<class GridT >
boost::disable_if< boost::is_floating_point< typename GridT::ValueType > >::type | doLevelSetMeasure (const GridT &, Real &, Real &, Real &, bool)
template<class GridT >
void | levelSetMeasure (const GridT &grid, Real &area, Real &volume, Real &avgCurvature, bool useWorldSpace)
template<class GridType >
GridType::Ptr | levelSetRebuild (const GridType &grid, float isovalue=0, float halfWidth=float(LEVEL_SET_HALF_WIDTH), const math::Transform *xform=NULL)
| Return a new grid of type `GridType` that contains a narrow-band level set representation of an isosurface of a given grid. More...
template<class GridType >
GridType::Ptr | levelSetRebuild (const GridType &grid, float isovalue, float exBandWidth, float inBandWidth, const math::Transform *xform=NULL)
| Return a new grid of type `GridType` that contains a narrow-band level set representation of an isosurface of a given grid. More...
template<class GridType , typename InterruptT >
GridType::Ptr | levelSetRebuild (const GridType &grid, float isovalue, float exBandWidth, float inBandWidth, const math::Transform *xform=NULL, InterruptT *interrupter=NULL)
| Return a new grid of type `GridType` that contains a narrow-band level set representation of an isosurface of a given grid. More...
template<class GridType , typename InterruptT >
boost::enable_if< boost::is_floating_point< typename GridType::ValueType >, typename GridType::Ptr >::type | doLevelSetRebuild (const GridType &grid, typename GridType::ValueType iso, typename GridType::ValueType exWidth, typename GridType::ValueType inWidth, const math::Transform *xform, InterruptT *interrupter)
template<class GridType , typename InterruptT >
boost::disable_if< boost::is_floating_point< typename GridType::ValueType >, typename GridType::Ptr >::type | doLevelSetRebuild (const GridType &, typename GridType::ValueType, typename GridType::ValueType, typename GridType::ValueType, const math::Transform *, InterruptT *)
template<typename GridType , typename InterruptT >
GridType::Ptr | createLevelSetSphere (float radius, const openvdb::Vec3f &center, float voxelSize, float halfWidth=float(LEVEL_SET_HALF_WIDTH), InterruptT *interrupt=NULL)
| Return a grid of type `GridType` containing a narrow-band level set representation of a sphere. More...
template<typename GridType >
GridType::Ptr | createLevelSetSphere (float radius, const openvdb::Vec3f &center, float voxelSize, float halfWidth=float(LEVEL_SET_HALF_WIDTH))
| Return a grid of type `GridType` containing a narrow-band level set representation of a sphere. More...
template<class GridType >
void | sdfToFogVolume (GridType &grid, typename GridType::ValueType cutoffDistance=lsutilGridMax< GridType >())
| Threaded method to convert a sparse level set/SDF into a sparse fog volume. More...
template<class GridOrTreeType >
GridOrTreeType::template ValueConverter< bool >::Type::Ptr | sdfInteriorMask (const GridOrTreeType &volume, typename GridOrTreeType::ValueType isovalue=lsutilGridZero< GridOrTreeType >())
| Threaded method to construct a boolean mask that represents interior regions in a signed distance field. More...
template<typename GridOrTreeType >
GridOrTreeType::template ValueConverter< bool >::Type::Ptr | extractEnclosedRegion (const GridOrTreeType &volume, typename GridOrTreeType::ValueType isovalue=lsutilGridZero< GridOrTreeType >(), const typename TreeAdapter< GridOrTreeType >::TreeType::template ValueConverter< bool >::Type *fillMask=NULL)
| Extracts the interior regions of a signed distance field and topologically enclosed (watertight) regions of value greater than the isovalue (cavities) that can arise as the result of CSG union operations between different shapes where at least one of the shapes has a concavity that is capped. More...
template<typename GridType , typename MeshDataAdapter >
GridType::Ptr | meshToVolume (const MeshDataAdapter &mesh, const math::Transform &transform, float exteriorBandWidth=3.0f, float interiorBandWidth=3.0f, int flags=0, typename GridType::template ValueConverter< Int32 >::Type *polygonIndexGrid=NULL)
template<typename GridType , typename MeshDataAdapter , typename Interrupter >
GridType::Ptr | meshToVolume (Interrupter &interrupter, const MeshDataAdapter &mesh, const math::Transform &transform, float exteriorBandWidth=3.0f, float interiorBandWidth=3.0f, int flags=0, typename GridType::template ValueConverter< Int32 >::Type *polygonIndexGrid=NULL)
| Convert polygonal meshes that consist of quads and/or triangles into signed or unsigned distance field volumes. More...
template<typename GridType >
GridType::Ptr | meshToLevelSet (const openvdb::math::Transform &xform, const std::vector< Vec3s > &points, const std::vector< Vec3I > &triangles, float halfWidth=float(LEVEL_SET_HALF_WIDTH))
| Convert a triangle mesh to a level set volume. More...
template<typename GridType >
GridType::Ptr | meshToLevelSet (const openvdb::math::Transform &xform, const std::vector< Vec3s > &points, const std::vector< Vec4I > &quads, float halfWidth=float(LEVEL_SET_HALF_WIDTH))
| Convert a quad mesh to a level set volume. More...
template<typename GridType >
GridType::Ptr | meshToLevelSet (const openvdb::math::Transform &xform, const std::vector< Vec3s > &points, const std::vector< Vec3I > &triangles, const std::vector< Vec4I > &quads, float halfWidth=float(LEVEL_SET_HALF_WIDTH))
| Convert a triangle and quad mesh to a level set volume. More...
template<typename GridType >
GridType::Ptr | meshToSignedDistanceField (const openvdb::math::Transform &xform, const std::vector< Vec3s > &points, const std::vector< Vec3I > &triangles, const std::vector< Vec4I > &quads, float exBandWidth, float inBandWidth)
| Convert a triangle and quad mesh to a signed distance field with an asymmetrical narrow band. More...
template<typename GridType >
GridType::Ptr | meshToUnsignedDistanceField (const openvdb::math::Transform &xform, const std::vector< Vec3s > &points, const std::vector< Vec3I > &triangles, const std::vector< Vec4I > &quads, float bandWidth)
| Convert a triangle and quad mesh to an unsigned distance field. More...
template<typename GridType , typename VecType >
GridType::Ptr | createLevelSetBox (const math::BBox< VecType > &bbox, const openvdb::math::Transform &xform, typename VecType::ValueType halfWidth=LEVEL_SET_HALF_WIDTH)
| Return a grid of type `GridType` containing a narrow-band level set representation of a box. More...
template<typename FloatTreeT >
void | traceExteriorBoundaries (FloatTreeT &tree)
| Traces the exterior voxel boundary of closed objects in the input volume tree. Exterior voxels are marked with a negative sign, voxels with a value below `0.75` are left unchanged and act as the boundary layer. More...
template<typename GridType >
boost::enable_if< boost::is_floating_point< typename GridType::ValueType >, typename GridType::Ptr >::type | doMeshConversion (const openvdb::math::Transform &xform, const std::vector< Vec3s > &points, const std::vector< Vec3I > &triangles, const std::vector< Vec4I > &quads, float exBandWidth, float inBandWidth, bool unsignedDistanceField=false)
template<typename GridType >
boost::disable_if< boost::is_floating_point< typename GridType::ValueType >, typename GridType::Ptr >::type | doMeshConversion (const math::Transform &, const std::vector< Vec3s > &, const std::vector< Vec3I > &, const std::vector< Vec4I > &, float, float, bool=false)
std::ostream & | operator<< (std::ostream &ostr, const MeshToVoxelEdgeData::EdgeData &rhs)
MeshToVoxelEdgeData::EdgeData | Abs (const MeshToVoxelEdgeData::EdgeData &x)
template<typename TreeType >
OPENVDB_STATIC_SPECIALIZATION void | dilateVoxels (TreeType &tree, int iterations=1, NearestNeighbors nn=NN_FACE)
| Topologically dilate all leaf-level active voxels in a tree using one of three nearest neighbor connectivity patterns. More...
template<typename TreeType >
OPENVDB_STATIC_SPECIALIZATION void | dilateVoxels (tree::LeafManager< TreeType > &manager, int iterations=1, NearestNeighbors nn=NN_FACE)
| Topologically dilate all leaf-level active voxels in a tree using one of three nearest neighbor connectivity patterns. More...
template<typename GridOrTree >
void | activate (GridOrTree &, const typename GridOrTree::ValueType &value, const typename GridOrTree::ValueType &tolerance=zeroVal< typename GridOrTree::ValueType >())
| Mark as active any inactive tiles or voxels in the given grid or tree whose values are equal to value (optionally to within the given tolerance). More...
template<typename GridOrTree >
void | deactivate (GridOrTree &, const typename GridOrTree::ValueType &value, const typename GridOrTree::ValueType &tolerance=zeroVal< typename GridOrTree::ValueType >())
| Mark as inactive any active tiles or voxels in the given grid or tree whose values are equal to value (optionally to within the given tolerance). More...
template<typename GridT , typename PointArrayT >
GridT::Ptr | createPointIndexGrid (const PointArrayT &points, const math::Transform &xform)
| Partition points into a point index grid to accelerate range and nearest-neighbor searches. More...
template<typename PointArrayT , typename GridT >
bool | isValidPartition (const PointArrayT &points, const GridT &grid)
| Return `true` if the given point index grid represents a valid partitioning of the given point array. More...
template<typename GridT , typename PointArrayT >
GridT::ConstPtr | getValidPointIndexGrid (const PointArrayT &points, const typename GridT::ConstPtr &grid)
| Repartition the points if needed, otherwise return the input grid. More...
template<typename GridT , typename PointArrayT >
GridT::Ptr | getValidPointIndexGrid (const PointArrayT &points, const typename GridT::Ptr &grid)
| Repartition the points if needed, otherwise return the input grid. More...
template<typename TreeT >
void | prune (TreeT &tree, typename TreeT::ValueType tolerance=zeroVal< typename TreeT::ValueType >(), bool threaded=true, size_t grainSize=1)
| Reduce the memory footprint of a tree by replacing with tiles any nodes whose values are all the same (optionally to within a tolerance) and have the same active state. More...
template<typename TreeT >
void | pruneTiles (TreeT &tree, typename TreeT::ValueType tolerance=zeroVal< typename TreeT::ValueType >(), bool threaded=true, size_t grainSize=1)
| Reduce the memory footprint of a tree by replacing with tiles any non-leaf nodes whose values are all the same (optionally to within a tolerance) and have the same active state. More...
template<typename TreeT >
void | pruneInactive (TreeT &tree, bool threaded=true, size_t grainSize=1)
| Reduce the memory footprint of a tree by replacing with background tiles any nodes whose values are all inactive. More...
template<typename TreeT >
void | pruneInactiveWithValue (TreeT &tree, const typename TreeT::ValueType &value, bool threaded=true, size_t grainSize=1)
| Reduce the memory footprint of a tree by replacing any nodes whose values are all inactive with tiles of the given value. More...
template<typename TreeT >
void | pruneLevelSet (TreeT &tree, bool threaded=true, size_t grainSize=1)
| Reduce the memory footprint of a tree by replacing nodes whose values are all inactive with inactive tiles having a value equal to the first value encountered in the (inactive) child. More...
template<typename TreeT >
void | pruneLevelSet (TreeT &tree, const typename TreeT::ValueType &outsideWidth, const typename TreeT::ValueType &insideWidth, bool threaded=true, size_t grainSize=1)
| Reduce the memory footprint of a tree by replacing nodes whose voxel values are all inactive with inactive tiles having the value -| insideWidth | if the voxel values are negative and | outsideWidth | otherwise. More...
template<typename GridT >
void | rayTrace (const GridT &, const BaseShader &, BaseCamera &, size_t pixelSamples=1, unsigned int seed=0, bool threaded=true)
| Ray-trace a volume. More...
template<typename GridT , typename IntersectorT >
void | rayTrace (const GridT &, const IntersectorT &, const BaseShader &, BaseCamera &, size_t pixelSamples=1, unsigned int seed=0, bool threaded=true)
| Ray-trace a volume using a given ray intersector. More...
template<typename TreeOrLeafManagerT >
void | signedFloodFill (TreeOrLeafManagerT &tree, bool threaded=true, size_t grainSize=1)
| Set the values of all inactive voxels and tiles of a narrow-band level set from the signs of the active voxels, setting outside values to +background and inside values to -background. More...
template<typename TreeOrLeafManagerT >
void | signedFloodFillWithValues (TreeOrLeafManagerT &tree, const typename TreeOrLeafManagerT::ValueType &outsideWidth, const typename TreeOrLeafManagerT::ValueType &insideWidth, bool threaded=true, size_t grainSize=1)
| Set the values of all inactive voxels and tiles of a narrow-band level set from the signs of the active voxels, setting exterior values to outsideWidth and interior values to insideWidth. Set the background value of this tree to outsideWidth. More...
template<typename TreeOrLeafManagerT >
boost::enable_if_c< boost::is_floating_point< typename TreeOrLeafManagerT::ValueType >::value||boost::is_signed< typename TreeOrLeafManagerT::ValueType >::value, void >::type | doSignedFloodFill (TreeOrLeafManagerT &tree, typename TreeOrLeafManagerT::ValueType outsideValue, typename TreeOrLeafManagerT::ValueType insideValue, bool threaded, size_t grainSize)
template<typename TreeOrLeafManagerT >
boost::disable_if_c< boost::is_floating_point< typename TreeOrLeafManagerT::ValueType >::value||boost::is_signed< typename TreeOrLeafManagerT::ValueType >::value, void >::type | doSignedFloodFill (TreeOrLeafManagerT &, const typename TreeOrLeafManagerT::ValueType &, const typename TreeOrLeafManagerT::ValueType &, bool, size_t)
template<typename IterT >
math::Histogram | histogram (const IterT &iter, double minVal, double maxVal, size_t numBins=10, bool threaded=true)
| Iterate over a scalar grid and compute a histogram of the values of the voxels that are visited, or iterate over a vector-valued grid and compute a histogram of the magnitudes of the vectors. More...
template<typename IterT >
math::Extrema | extrema (const IterT &iter, bool threaded=true)
| Iterate over a scalar grid and compute extrema (min/max) of the values of the voxels that are visited, or iterate over a vector-valued grid and compute extrema of the magnitudes of the vectors. More...
template<typename IterT >
math::Stats | statistics (const IterT &iter, bool threaded=true)
| Iterate over a scalar grid and compute statistics (mean, variance, etc.) of the values of the voxels that are visited, or iterate over a vector-valued grid and compute statistics of the magnitudes of the vectors. More...
template<typename IterT , typename ValueOp >
math::Extrema | extrema (const IterT &iter, const ValueOp &op, bool threaded)
| Iterate over a grid and compute extrema (min/max) of the values produced by applying the given functor at each voxel that is visited. More...
template<typename IterT , typename ValueOp >
math::Stats | statistics (const IterT &iter, const ValueOp &op, bool threaded)
| Iterate over a grid and compute statistics (mean, variance, etc.) of the values produced by applying the given functor at each voxel that is visited. More...
template<typename OperatorT , typename IterT >
math::Stats | opStatistics (const IterT &iter, const OperatorT &op=OperatorT(), bool threaded=true)
| Iterate over a grid and compute statistics (mean, variance, etc.) of the values produced by applying a given operator (see math/Operators.h) at each voxel that is visited. More...
template<typename OperatorT , typename IterT >
math::Extrema | opExtrema (const IterT &iter, const OperatorT &op=OperatorT(), bool threaded=true)
| Same as opStatistics except it returns a math::Extrema vs a math::Stats. More...
template<typename IterT , typename XformOp >
void | foreach (const IterT &iter, XformOp &op, bool threaded=true, bool shareOp=true)
template<typename IterT , typename XformOp >
void | foreach (const IterT &iter, const XformOp &op, bool threaded=true, bool shareOp=true)
template<typename InIterT , typename OutGridT , typename XformOp >
void | transformValues (const InIterT &inIter, OutGridT &outGrid, XformOp &op, bool threaded=true, bool shareOp=true, MergePolicy merge=MERGE_ACTIVE_STATES)
template<typename InIterT , typename OutGridT , typename XformOp >
void | transformValues (const InIterT &inIter, OutGridT &outGrid, const XformOp &op, bool threaded=true, bool shareOp=true, MergePolicy merge=MERGE_ACTIVE_STATES)
template<typename IterT , typename XformOp >
void | accumulate (const IterT &iter, XformOp &op, bool threaded=true)
template<typename TreeT >
void | setValueOnMin (TreeT &tree, const Coord &xyz, const typename TreeT::ValueType &value)
| Set the value of the voxel at the given coordinates in tree to the minimum of its current value and value, and mark the voxel as active. More...
template<typename TreeT >
void | setValueOnMax (TreeT &tree, const Coord &xyz, const typename TreeT::ValueType &value)
| Set the value of the voxel at the given coordinates in tree to the maximum of its current value and value, and mark the voxel as active. More...
template<typename TreeT >
void | setValueOnSum (TreeT &tree, const Coord &xyz, const typename TreeT::ValueType &value)
| Set the value of the voxel at the given coordinates in tree to the sum of its current value and value, and mark the voxel as active. More...
template<typename TreeT >
void | setValueOnMult (TreeT &tree, const Coord &xyz, const typename TreeT::ValueType &value)
| Set the value of the voxel at the given coordinates in tree to the product of its current value and value, and mark the voxel as active. More...
template<typename GridType >
void | transformVectors (GridType &, const Mat4d &)
| Apply an affine transform to the voxel values of a vector-valued grid in accordance with the grid's vector type (covariant, contravariant, etc.). More...
template<typename GridType >
boost::disable_if_c< VecTraits< typename GridType::ValueType >::IsVec, void >::type | doTransformVectors (GridType &, const Mat4d &)
template<typename GridType >
boost::enable_if_c< VecTraits< typename GridType::ValueType >::IsVec, void >::type | doTransformVectors (GridType &grid, const Mat4d &mat)
template<typename GridType >
void | volumeToMesh (const GridType &grid, std::vector< Vec3s > &points, std::vector< Vec4I > &quads, double isovalue=0.0)
| Uniformly mesh any scalar grid that has a continuous isosurface. More...
template<typename GridType >
void | volumeToMesh (const GridType &grid, std::vector< Vec3s > &points, std::vector< Vec3I > &triangles, std::vector< Vec4I > &quads, double isovalue=0.0, double adaptivity=0.0)
| Adaptively mesh any scalar grid that has a continuous isosurface. More...
Vec3d | findFeaturePoint (const std::vector< Vec3d > &points, const std::vector< Vec3d > &normals)
| Given a set of tangent elements, `points` with corresponding `normals`, this method returns the intersection point of all tangent elements. More...
template<typename GridType >
boost::enable_if< boost::is_scalar< typename GridType::ValueType >, void >::type | doVolumeToMesh (const GridType &grid, std::vector< Vec3s > &points, std::vector< Vec3I > &triangles, std::vector< Vec4I > &quads, double isovalue, double adaptivity)
template<typename GridType >
boost::disable_if< boost::is_scalar< typename GridType::ValueType >, void >::type | doVolumeToMesh (const GridType &, std::vector< Vec3s > &, std::vector< Vec3I > &, std::vector< Vec4I > &, double, double)
template<typename GridT , typename InterrupterT >
void | fillWithSpheres (const GridT &grid, std::vector< openvdb::Vec4s > &spheres, int maxSphereCount, bool overlapping=false, float minRadius=1.0, float maxRadius=std::numeric_limits< float >::max(), float isovalue=0.0, int instanceCount=10000, InterrupterT *interrupter=NULL)
| Threaded method to fill a closed level set or fog volume with adaptively sized spheres. More...
template<typename GridT >
void | fillWithSpheres (const GridT &grid, std::vector< openvdb::Vec4s > &spheres, int maxSphereCount, bool overlapping=false, float minRadius=1.0, float maxRadius=std::numeric_limits< float >::max(), float isovalue=0.0, int instanceCount=10000)
| `fillWithSpheres` method variant that automatically infers the util::NullInterrupter. More...
template<typename TreeType >
OPENVDB_STATIC_SPECIALIZATION void | erodeVoxels (TreeType &tree, int iterations=1, NearestNeighbors nn=NN_FACE)
| Topologically erode all leaf-level active voxels in the given tree. More...
template<typename TreeType >
OPENVDB_STATIC_SPECIALIZATION void | erodeVoxels (tree::LeafManager< TreeType > &manager, int iterations=1, NearestNeighbors nn=NN_FACE)
| Topologically erode all leaf-level active voxels in the given tree. More...

## Typedef Documentation

typedef Grid<PointIndexTree> PointIndexGrid

Point index grid.

typedef tree::Tree<tree::RootNode<tree::InternalNode<tree::InternalNode <PointIndexLeafNode<PointIndex32, 3>, 4>, 5> > > PointIndexTree

Point index tree configured to match the default OpenVDB tree configuration.

typedef boost::scoped_array<openvdb::Vec3s> PointList

Point and primitive list types.

typedef boost::scoped_array<PolygonPool> PolygonPoolList

Point and primitive list types.

typedef PointPartitioner<uint32_t, 3> UInt32PointPartitioner

## Enumeration Type Documentation

anonymous enum

Polygon flags, used for reference based meshing.

Enumerator
POLYFLAG_EXTERIOR |
POLYFLAG_FRACTURE_SEAM |
POLYFLAG_SUBDIVIDED |

enum DSCompositeOp

We currrently support the following operations when compositing sparse data into a dense grid.

Enumerator
DS_OVER |
DS_ADD |
DS_SUB |
DS_MIN |
DS_MAX |
DS_MULT |
DS_SET |

enum MemoryLayout

We currently support the following two 3D memory layouts for dense volumes: XYZ, i.e. x is the fastest moving index, and ZYX, i.e. z is the fastest moving index. The ZYX memory layout leads to nested for-loops of the order x, y, z, which we find to be the most intuitive. Hence, ZYX is the layout used throughout VDB. However, other data structures, e.g. Houdini and Maya, employ the XYZ layout. Clearly a dense volume with the ZYX layout converts more efficiently to a VDB, but we support both for convenience.

Enumerator
LayoutXYZ |
LayoutZYX |

enum MeshToVolumeFlags

Mesh to volume conversion flags.

Enumerator
UNSIGNED_DISTANCE_FIELD | Switch from the default signed distance field conversion that classifies regions as either inside or outside the mesh boundary to a unsigned distance field conversion that only computes distance values. This conversion type does not require a closed watertight mesh.
DISABLE_INTERSECTING_VOXEL_REMOVAL | Disable the cleanup step that removes voxels created by self intersecting portions of the mesh.
DISABLE_RENORMALIZATION | Disable the distance renormalization step that smooths out bumps caused by self intersecting or overlapping portions of the mesh
DISABLE_NARROW_BAND_TRIMMING | Disable the cleanup step that removes active voxels that exceed the narrow band limits. (Only relevant for small limits)

enum NearestNeighbors

Voxel topology of nearest neighbors.

NN_FACE

  face adjacency (6 nearest neighbors, defined as all neighbor voxels connected along one of the primary axes)

NN_FACE_EDGE

  face and edge adjacency (18 nearest neighbors, defined as all neighbor voxels connected along either one or two of the primary axes)

NN_FACE_EDGE_VERTEX
  face, edge and vertex adjacency (26 nearest neighbors, defined as all neighbor voxels connected along either one, two or all three of the primary axes)

Enumerator
NN_FACE |
NN_FACE_EDGE |
NN_FACE_EDGE_VERTEX |

## Function Documentation

MeshToVoxelEdgeData::EdgeData openvdb::v3_1_0::tools::Abs | ( | const MeshToVoxelEdgeData::EdgeData & | x | ) |
| inline

void accumulate | ( | const IterT & | iter,
|  | XformOp & | op,
|  | bool | threaded = `true`
| ) |  |
| inline

Iterate over a grid and at each step call `op(iter)`. If threading is enabled, call `op.join(otherOp)` to accumulate intermediate results from pairs of threads.

Parameters

  iter | an iterator over a grid or its tree (`Grid::ValueOnCIter`, `Tree::NodeIter`, etc.)
  op | a functor with a join method of the form `void join(XformOp&)` and a call method of the form `void op(const IterT&)`, where `IterT` is the type of iter
  threaded | if true, transform multiple values of the grid in parallel

Note
  If threaded is true, each thread gets its own copy of the original functor. The order in which threads are joined is unspecified.
  If threaded is false, the join method is never called.

Example:
  Compute the average of the active values of a scalar, floating-point grid using the math::Stats class.
  namespace {
  struct Average {
  math::Stats stats;
  // Accumulate voxel and tile values into this functor's Stats object.
  inline void operator()(const FloatGrid::ValueOnCIter& iter) {
  if (iter.isVoxelValue()) stats.add(*iter);
  else stats.add(*iter, iter.getVoxelCount());
  }
  // Accumulate another functor's Stats object into this functor's.
  inline void join(Average& other) { stats.add(other.stats); }
  // Return the cumulative result.
  inline double average() const { return stats.mean(); }
  };
  }
  {
  FloatGrid grid = ...;
  Average op;
  tools::accumulate(grid.cbeginValueOn(), op);
  double average = op.average();
  }

Note
  For more complex operations that require finer control over threading, consider using `tbb::parallel_for()` or `tbb::parallel_reduce()` in conjunction with a tree::IteratorRange that wraps a grid or tree iterator.

void activate | ( | GridOrTree & | gridOrTree,
|  | const typename GridOrTree::ValueType & | value,
|  | const typename GridOrTree::ValueType & | tolerance = `zeroVal<typename GridOrTree::ValueType>()`
| ) |  |
| inline

Mark as active any inactive tiles or voxels in the given grid or tree whose values are equal to value (optionally to within the given tolerance).

void changeAsymmetricLevelSetBackground | ( | TreeOrLeafManagerT & | tree,
|  | const typename TreeOrLeafManagerT::ValueType & | outsideWidth,
|  | const typename TreeOrLeafManagerT::ValueType & | insideWidth,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `32`
| ) |  |
| inline

Replace the background values in all the nodes of a floating-point tree containing a possibly asymmetric narrow-band level set.

All inactive values will be set to +| outsideWidth | if outside and -| insideWidth | if inside, where outsideWidth is the outside width of the narrow band and insideWidth is its inside width.

Note
  This method is faster than changeBackground since it does not perform tests to see if inactive values are equal to the old background value.
  If a LeafManager is used the cached leaf nodes are reused, resulting in slightly better overall performance.

Parameters

  tree | Tree (or LeafManager) that will have its background value changed
  outsideWidth | The width of the outside of the narrow band
  insideWidth | The width of the inside of the narrow band
  threaded | enable or disable threading (threading is enabled by default)
  grainSize | used to control the threading granularity (default is 32)

Exceptions

  ValueError | if outsideWidth is negative or insideWidth is not negative (as defined by math::isNegative)

void changeBackground | ( | TreeOrLeafManagerT & | tree,
|  | const typename TreeOrLeafManagerT::ValueType & | background,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `32`
| ) |  |
| inline

Replace the background value in all the nodes of a tree.

The sign of the background value is preserved, and only inactive values equal to the old background value are replaced.

Note
  If a LeafManager is used the cached leaf nodes are reused, resulting in slightly better overall performance.

Parameters

  tree | Tree (or LeafManager) that will have its background value changed
  background | the new background value
  threaded | enable or disable threading (threading is enabled by default)
  grainSize | used to control the threading granularity (default is 32)

void changeLevelSetBackground | ( | TreeOrLeafManagerT & | tree,
|  | const typename TreeOrLeafManagerT::ValueType & | halfWidth,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `32`
| ) |  |
| inline

Replace the background value in all the nodes of a floating-point tree containing a symmetric narrow-band level set.

All inactive values will be set to +| halfWidth | if outside and -| halfWidth | if inside, where halfWidth is half the width of the symmetric narrow band.

Note
  This method is faster than changeBackground since it does not perform tests to see if inactive values are equal to the old background value.
  If a LeafManager is used the cached leaf nodes are reused, resulting in slightly better overall performance.

Parameters

  tree | Tree (or LeafManager) that will have its background value changed
  halfWidth | half of the width of the symmetric narrow band
  threaded | enable or disable threading (threading is enabled by default)
  grainSize | used to control the threading granularity (default is 32)

Exceptions

  ValueError | if halfWidth is negative (as defined by math::isNegative)

std::string checkFogVolume | ( | const GridType & | grid,
|  | size_t | number = `6`
| ) |  |

Perform checks on a grid to see if it is a valid fog volume.

Parameters

  grid | Grid to be checked
  number | Number of the checks to be performed (see below)

Returns
  string with a message indicating the nature of the issue. If no issue is detected the return string is empty.

number refers to the following ordered list of checks - always starting from the top. Fast checks 1: value type is floating point 2: has FOG volume class type 3: background value is zero

Slower checks 4: all the values are finite, i.e not NaN or infinite 5: inactive values are zero 6: active values are in the range [0,1]

std::string checkLevelSet | ( | const GridType & | grid,
|  | size_t | number = `9`
| ) |  |

Perform checks on a grid to see if it is a valid symmetric, narrow-band level set.

Parameters

  grid | Grid to be checked
  number | Number of the checks to be performed (see below)

Returns
  string with a message indicating the nature of the issue. If no issue is detected the return string is empty.

number refers to the following ordered list of checks - always starting from the top. Fast checks 1: value type is floating point 2: has level set class type 3: has uniform scale 4: background value is positive and n*dx

Slower checks 5: no active tiles 6: all the values are finite, i.e not NaN or infinite 7: active values in range between +-background 8: abs of inactive values = background, i.e. assuming a symmetric narrow band!

Relatively slow check (however multithreaded) 9: norm gradient is close to one, i.e. satisfied the Eikonal equation.

OPENVDB_STATIC_SPECIALIZATION GridType::Ptr clip | ( | const GridType & | grid,
|  | const BBoxd & | bbox
| ) |  |
| inline

Clip the given grid against a world-space bounding box and return a new grid containing the result.

Warning
  Clipping a level set will likely produce a grid that is no longer a valid level set.

OPENVDB_STATIC_SPECIALIZATION GridType::Ptr clip | ( | const GridType & | grid,
|  | const Grid< MaskTreeType > & | mask
| ) |  |
| inline

Clip a grid against the active voxels of another grid and return a new grid containing the result.

Parameters

  grid | the grid to be clipped
  mask | a grid whose active voxels form a boolean clipping mask

The mask grid need not have the same transform as the source grid. Also, if the mask grid is a level set, consider using tools::sdfInteriorMask to construct a new mask comprising the interior (rather than the narrow band) of the level set.

Warning
  Clipping a level set will likely produce a grid that is no longer a valid level set.

OPENVDB_STATIC_SPECIALIZATION void compDiv | ( | GridOrTreeT & | a,
|  | GridOrTreeT & | b
| ) |  |
| inline

Given grids A and B, compute a / b per voxel (using sparse traversal). Store the result in the A grid and leave the B grid empty.

OPENVDB_STATIC_SPECIALIZATION void compMax | ( | GridOrTreeT & | a,
|  | GridOrTreeT & | b
| ) |  |
| inline

Given grids A and B, compute max(a, b) per voxel (using sparse traversal). Store the result in the A grid and leave the B grid empty.

OPENVDB_STATIC_SPECIALIZATION void compMin | ( | GridOrTreeT & | a,
|  | GridOrTreeT & | b
| ) |  |
| inline

Given grids A and B, compute min(a, b) per voxel (using sparse traversal). Store the result in the A grid and leave the B grid empty.

OPENVDB_STATIC_SPECIALIZATION void compMul | ( | GridOrTreeT & | a,
|  | GridOrTreeT & | b
| ) |  |
| inline

Given grids A and B, compute a * b per voxel (using sparse traversal). Store the result in the A grid and leave the B grid empty.

void compositeToDense | ( | Dense< typename TreeT::ValueType, LayoutZYX > & | dense,
|  | const TreeT & | source,
|  | const TreeT & | alpha,
|  | const typename TreeT::ValueType | beta,
|  | const typename TreeT::ValueType | strength,
|  | bool | threaded = `true`
| ) |  |

Composite data from a sparse tree into a dense array of the same value type.

Parameters

  dense | Dense grid to be altered by the operation
  source | Sparse data to composite into `dense`
  alpha | Sparse Alpha mask used in compositing operations.
  beta | Constant multiplier on src
  strength | Constant multiplier on alpha
  threaded | Enable threading for this operation.

OPENVDB_STATIC_SPECIALIZATION void compReplace | ( | GridOrTreeT & | a,
|  | const GridOrTreeT & | b
| ) |  |
| inline

Copy the active voxels of B into A.

OPENVDB_STATIC_SPECIALIZATION void compSum | ( | GridOrTreeT & | a,
|  | GridOrTreeT & | b
| ) |  |
| inline

Given grids A and B, compute a + b per voxel (using sparse traversal). Store the result in the A grid and leave the B grid empty.

void copyFromDense | ( | const DenseT & | dense,
|  | GridOrTreeT & | sparse,
|  | const typename GridOrTreeT::ValueType & | tolerance,
|  | bool | serial = `false`
| ) |  |

Populate a sparse grid with the values of all of the voxels of a dense grid.

Parameters

  dense | the dense grid from which to copy values
  sparse | an OpenVDB grid or tree into which to copy values
  tolerance | values in the dense grid that are within this tolerance of the sparse grid's background value become inactive background voxels or tiles in the sparse grid
  serial | if false, process voxels in parallel

void copyToDense | ( | const GridOrTreeT & | sparse,
|  | DenseT & | dense,
|  | bool | serial = `false`
| ) |  |

Populate a dense grid with the values of voxels from a sparse grid, where the sparse grid intersects the dense grid.

Parameters

  sparse | an OpenVDB grid or tree from which to copy values
  dense | the dense grid into which to copy values
  serial | if false, process voxels in parallel

ScalarToVectorConverter< GridType >::Type::Ptr cpt | ( | const GridType & | grid,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

Compute the Closest-Point Transform (CPT) from a distance field.

Returns
  a new vector-valued grid with the same numerical precision as the input grid (for example, if the input grid is a DoubleGrid, the output grid will be a Vec3DGrid)

When a mask grid is specified, the solution is calculated only in the intersection of the mask active topology and the input active topology independent of the transforms associated with either grid.

Note
  The current implementation assumes all the input distance values are represented by leaf voxels and not tiles. This is true for all narrow-band level sets, which this class was originally developed for. In the future we will expand this class to also handle tile values.

ScalarToVectorConverter< GridType >::Type::Ptr cpt | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

ScalarToVectorConverter<GridType>::Type::Ptr openvdb::v3_1_0::tools::cpt | ( | const GridType & | grid,
|  | bool | threaded = `true`
| ) |  |
| inline

ScalarToVectorConverter<GridType>::Type::Ptr openvdb::v3_1_0::tools::cpt | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded = `true`
| ) |  |
| inline

GridType::Ptr createLevelSetBox | ( | const math::BBox< VecType > & | bbox,
|  | const openvdb::math::Transform & | xform,
|  | typename VecType::ValueType | halfWidth = `LEVEL_SET_HALF_WIDTH`
| ) |  |
| inline

Return a grid of type `GridType` containing a narrow-band level set representation of a box.

Parameters

  bbox | a bounding box in world units
  xform | world-to-index-space transform
  halfWidth | half the width of the narrow band, in voxel units

GridType::Ptr createLevelSetSphere | ( | float | radius,
|  | const openvdb::Vec3f & | center,
|  | float | voxelSize,
|  | float | halfWidth = `float(LEVEL_SET_HALF_WIDTH)`,
|  | InterruptT * | interrupt = `NULL`
| ) |  |

Return a grid of type `GridType` containing a narrow-band level set representation of a sphere.

Parameters

  radius | radius of the sphere in world units
  center | center of the sphere in world units
  voxelSize | voxel size in world units
  halfWidth | half the width of the narrow band, in voxel units
  interrupt | a pointer adhering to the util::NullInterrupter interface

Note
  `GridType::ValueType` must be a floating-point scalar.
  The leapfrog algorithm employed in this method is best suited for a single large sphere. For multiple small spheres consider using the faster algorithm in ParticlesToLevelSet.h

GridType::Ptr openvdb::v3_1_0::tools::createLevelSetSphere | ( | float | radius,
|  | const openvdb::Vec3f & | center,
|  | float | voxelSize,
|  | float | halfWidth = `float(LEVEL_SET_HALF_WIDTH)`
| ) |  |

Return a grid of type `GridType` containing a narrow-band level set representation of a sphere.

Parameters

  radius | radius of the sphere in world units
  center | center of the sphere in world units
  voxelSize | voxel size in world units
  halfWidth | half the width of the narrow band, in voxel units

Note
  `GridType::ValueType` must be a floating-point scalar.
  The leapfrog algorithm employed in this method is best suited for a single large sphere. For multiple small spheres consider using the faster algorithm in ParticlesToLevelSet.h

GridT::Ptr createPointIndexGrid | ( | const PointArrayT & | points,
|  | const math::Transform & | xform
| ) |  |
| inline

Partition points into a point index grid to accelerate range and nearest-neighbor searches.

Parameters

  points | world-space point array conforming to the PointArray interface
  xform | world-to-index-space transform

OPENVDB_STATIC_SPECIALIZATION void csgDifference | ( | GridOrTreeT & | a,
|  | GridOrTreeT & | b,
|  | bool | prune = `true`
| ) |  |
| inline

Given two level set grids, replace the A grid with the difference A / B.

Exceptions

  ValueError | if the background value of either grid is not greater than zero.

Note
  This operation always leaves the B grid empty.

OPENVDB_STATIC_SPECIALIZATION void csgIntersection | ( | GridOrTreeT & | a,
|  | GridOrTreeT & | b,
|  | bool | prune = `true`
| ) |  |
| inline

Given two level set grids, replace the A grid with the intersection of A and B.

Exceptions

  ValueError | if the background value of either grid is not greater than zero.

Note
  This operation always leaves the B grid empty.

OPENVDB_STATIC_SPECIALIZATION void csgUnion | ( | GridOrTreeT & | a,
|  | GridOrTreeT & | b,
|  | bool | prune = `true`
| ) |  |
| inline

Given two level set grids, replace the A grid with the union of A and B.

Exceptions

  ValueError | if the background value of either grid is not greater than zero.

Note
  This operation always leaves the B grid empty.

GridType::Ptr curl | ( | const GridType & | grid,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

Compute the curl of the given vector-valued grid.

Returns
  a new vector-valued grid

When a mask grid is specified, the solution is calculated only in the intersection of the mask active topology and the input active topology independent of the transforms associated with either grid.

GridType::Ptr curl | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

GridType::Ptr openvdb::v3_1_0::tools::curl | ( | const GridType & | grid,
|  | bool | threaded = `true`
| ) |  |
| inline

GridType::Ptr openvdb::v3_1_0::tools::curl | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded = `true`
| ) |  |
| inline

void deactivate | ( | GridOrTree & | gridOrTree,
|  | const typename GridOrTree::ValueType & | value,
|  | const typename GridOrTree::ValueType & | tolerance = `zeroVal<typename GridOrTree::ValueType>()`
| ) |  |
| inline

Mark as inactive any active tiles or voxels in the given grid or tree whose values are equal to value (optionally to within the given tolerance).

OPENVDB_STATIC_SPECIALIZATION void dilateVoxels | ( | TreeType & | tree,
|  | int | iterations = `1`,
|  | NearestNeighbors | nn = `NN_FACE`
| ) |  |
| inline

Topologically dilate all leaf-level active voxels in a tree using one of three nearest neighbor connectivity patterns.

Parameters

  tree | tree to be dilated
  iterations | number of iterations to apply the dilation
  nn | connectivity pattern of the dilation: either face-adjacent (6 nearest neighbors), face- and edge-adjacent (18 nearest neighbors) or face-, edge- and vertex-adjacent (26 nearest neighbors).

Note
  The values of any voxels are unchanged.

OPENVDB_STATIC_SPECIALIZATION void dilateVoxels | ( | tree::LeafManager< TreeType > & | manager,
|  | int | iterations = `1`,
|  | NearestNeighbors | nn = `NN_FACE`
| ) |  |
| inline

Topologically dilate all leaf-level active voxels in a tree using one of three nearest neighbor connectivity patterns.

Parameters

  manager | LeafManager containing the tree to be dilated.
  iterations | number of iterations to apply the dilation
  nn | connectivity pattern of the dilation: either face-adjacent (6 nearest neighbors), face- and edge-adjacent (18 nearest neighbors) or face-, edge- and vertex-adjacent (26 nearest neighbors).

Note
  The values of any voxels are unchanged.

VectorToScalarConverter< GridType >::Type::Ptr divergence | ( | const GridType & | grid,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

Compute the divergence of the given vector-valued grid.

Returns
  a new scalar-valued grid with the same numerical precision as the input grid (for example, if the input grid is a Vec3DGrid, the output grid will be a DoubleGrid)

When a mask grid is specified, the solution is calculated only in the intersection of the mask active topology and the input active topology independent of the transforms associated with either grid.

VectorToScalarConverter< GridType >::Type::Ptr divergence | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

VectorToScalarConverter<GridType>::Type::Ptr openvdb::v3_1_0::tools::divergence | ( | const GridType & | grid,
|  | bool | threaded = `true`
| ) |  |
| inline

VectorToScalarConverter<GridType>::Type::Ptr openvdb::v3_1_0::tools::divergence | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded = `true`
| ) |  |
| inline

boost::enable_if<boost::is_floating_point<typename GridT::ValueType>, Real>::type openvdb::v3_1_0::tools::doLevelSetArea | ( | const GridT & | grid,
|  | bool | useWorldSpace
| ) |  |
| inline

boost::disable_if<boost::is_floating_point<typename GridT::ValueType>, Real>::type openvdb::v3_1_0::tools::doLevelSetArea | ( | const GridT & | ,
|  | bool |
| ) |  |
| inline

boost::enable_if<boost::is_floating_point<typename GridT::ValueType> >::type openvdb::v3_1_0::tools::doLevelSetMeasure | ( | const GridT & | grid,
|  | Real & | area,
|  | Real & | volume,
|  | bool | useWorldSpace
| ) |  |
| inline

boost::disable_if<boost::is_floating_point<typename GridT::ValueType> >::type openvdb::v3_1_0::tools::doLevelSetMeasure | ( | const GridT & | ,
|  | Real & | ,
|  | Real & | ,
|  | bool |
| ) |  |
| inline

boost::enable_if<boost::is_floating_point<typename GridT::ValueType> >::type openvdb::v3_1_0::tools::doLevelSetMeasure | ( | const GridT & | grid,
|  | Real & | area,
|  | Real & | volume,
|  | Real & | avgCurvature,
|  | bool | useWorldSpace
| ) |  |
| inline

boost::disable_if<boost::is_floating_point<typename GridT::ValueType> >::type openvdb::v3_1_0::tools::doLevelSetMeasure | ( | const GridT & | ,
|  | Real & | ,
|  | Real & | ,
|  | Real & | ,
|  | bool |
| ) |  |
| inline

boost::enable_if<boost::is_floating_point<typename GridType::ValueType>,typename GridType::Ptr>::type openvdb::v3_1_0::tools::doLevelSetRebuild | ( | const GridType & | grid,
|  | typename GridType::ValueType | iso,
|  | typename GridType::ValueType | exWidth,
|  | typename GridType::ValueType | inWidth,
|  | const math::Transform * | xform,
|  | InterruptT * | interrupter
| ) |  |
| inline

The normal entry points for level set rebuild are the levelSetRebuild() functions. doLevelSetRebuild() is mainly for internal use, but when the isovalue and half band widths are given in ValueType units (for example, if they are queried from a grid), it might be more convenient to call this function directly.

boost::disable_if<boost::is_floating_point<typename GridType::ValueType>,typename GridType::Ptr>::type openvdb::v3_1_0::tools::doLevelSetRebuild | ( | const GridType & | ,
|  | typename GridType::ValueType | ,
|  | typename GridType::ValueType | ,
|  | typename GridType::ValueType | ,
|  | const math::Transform * | ,
|  | InterruptT * |
| ) |  |
| inline

boost::enable_if<boost::is_floating_point<typename GridT::ValueType>, Real>::type openvdb::v3_1_0::tools::doLevelSetVolume | ( | const GridT & | grid,
|  | bool | useWorldSpace
| ) |  |
| inline

boost::disable_if<boost::is_floating_point<typename GridT::ValueType>, Real>::type openvdb::v3_1_0::tools::doLevelSetVolume | ( | const GridT & | ,
|  | bool |
| ) |  |
| inline

boost::enable_if<boost::is_floating_point<typename GridType::ValueType>,typename GridType::Ptr>::type openvdb::v3_1_0::tools::doMeshConversion | ( | const openvdb::math::Transform & | xform,
|  | const std::vector< Vec3s > & | points,
|  | const std::vector< Vec3I > & | triangles,
|  | const std::vector< Vec4I > & | quads,
|  | float | exBandWidth,
|  | float | inBandWidth,
|  | bool | unsignedDistanceField = `false`
| ) |  |
| inline

boost::disable_if<boost::is_floating_point<typename GridType::ValueType>,typename GridType::Ptr>::type openvdb::v3_1_0::tools::doMeshConversion | ( | const math::Transform & | ,
|  | const std::vector< Vec3s > & | ,
|  | const std::vector< Vec3I > & | ,
|  | const std::vector< Vec4I > & | ,
|  | float | ,
|  | float | ,
|  | bool | = `false`
| ) |  |
| inline

void openvdb::v3_1_0::tools::doResampleToMatch | ( | const GridType & | inGrid,
|  | GridType & | outGrid,
|  | Interrupter & | interrupter
| ) |  |
| inline

The normal entry points for resampling are the resampleToMatch() functions, which correctly handle level set grids under scaling and shearing. doResampleToMatch() is mainly for internal use but is typically faster for level sets, and correct provided that no scaling or shearing is needed.

Warning
  Do not use this function to scale or shear a level set grid.

boost::enable_if_c< boost::is_floating_point<typename TreeOrLeafManagerT::ValueType>::value || boost::is_signed<typename TreeOrLeafManagerT::ValueType>::value, void>::type openvdb::v3_1_0::tools::doSignedFloodFill | ( | TreeOrLeafManagerT & | tree,
|  | typename TreeOrLeafManagerT::ValueType | outsideValue,
|  | typename TreeOrLeafManagerT::ValueType | insideValue,
|  | bool | threaded,
|  | size_t | grainSize
| ) |  |
| inline

boost::disable_if_c< boost::is_floating_point<typename TreeOrLeafManagerT::ValueType>::value || boost::is_signed<typename TreeOrLeafManagerT::ValueType>::value, void>::type openvdb::v3_1_0::tools::doSignedFloodFill | ( | TreeOrLeafManagerT & | ,
|  | const typename TreeOrLeafManagerT::ValueType & | ,
|  | const typename TreeOrLeafManagerT::ValueType & | ,
|  | bool | ,
|  | size_t |
| ) |  |
| inline

boost::disable_if_c<VecTraits<typename GridType::ValueType>::IsVec, void>::type openvdb::v3_1_0::tools::doTransformVectors | ( | GridType & | ,
|  | const Mat4d & |
| ) |  |
| inline

boost::enable_if_c<VecTraits<typename GridType::ValueType>::IsVec, void>::type openvdb::v3_1_0::tools::doTransformVectors | ( | GridType & | grid,
|  | const Mat4d & | mat
| ) |  |
| inline

boost::enable_if<boost::is_scalar<typename GridType::ValueType>, void>::type openvdb::v3_1_0::tools::doVolumeToMesh | ( | const GridType & | grid,
|  | std::vector< Vec3s > & | points,
|  | std::vector< Vec3I > & | triangles,
|  | std::vector< Vec4I > & | quads,
|  | double | isovalue,
|  | double | adaptivity
| ) |  |
| inline

boost::disable_if<boost::is_scalar<typename GridType::ValueType>, void>::type openvdb::v3_1_0::tools::doVolumeToMesh | ( | const GridType & | ,
|  | std::vector< Vec3s > & | ,
|  | std::vector< Vec3I > & | ,
|  | std::vector< Vec4I > & | ,
|  | double | ,
|  | double |
| ) |  |
| inline

OPENVDB_STATIC_SPECIALIZATION void erodeVoxels | ( | TreeType & | tree,
|  | int | iterations = `1`,
|  | NearestNeighbors | nn = `NN_FACE`
| ) |  |
| inline

Topologically erode all leaf-level active voxels in the given tree.

That is, shrink the set of active voxels by iterations voxels in the +x, -x, +y, -y, +z and -z directions, but don't change the values of any voxels, only their active states.

OPENVDB_STATIC_SPECIALIZATION void erodeVoxels | ( | tree::LeafManager< TreeType > & | manager,
|  | int | iterations = `1`,
|  | NearestNeighbors | nn = `NN_FACE`
| ) |  |
| inline

Topologically erode all leaf-level active voxels in the given tree.

That is, shrink the set of active voxels by iterations voxels in the +x, -x, +y, -y, +z and -z directions, but don't change the values of any voxels, only their active states.

GridOrTreeType::template ValueConverter< bool >::Type::Ptr extractEnclosedRegion | ( | const GridOrTreeType & | volume,
|  | typename GridOrTreeType::ValueType | isovalue = `lsutilGridZero<GridOrTreeType>()`,
|  | const typename TreeAdapter< GridOrTreeType >::TreeType::template ValueConverter< bool >::Type * | fillMask = `NULL`
| ) |  |
| inline

Extracts the interior regions of a signed distance field and topologically enclosed (watertight) regions of value greater than the isovalue (cavities) that can arise as the result of CSG union operations between different shapes where at least one of the shapes has a concavity that is capped.

For example the enclosed region of a capped bottle would include the walls and the interior cavity.

Returns
  A shared pointer to either a boolean grid or tree with the same tree configuration and potentially transform as the input `volume` and whose active and `true` values correspond to the interior and enclosed regions in the input signed distance field.

Parameters

  volume | Signed distance field / level set volume.
  isovalue | Threshold below which values are considered part of the interior region.
  fillMask | Optional boolean tree, when provided enclosed cavity regions that are not completely filled by this mask are ignored.

For instance if the fill mask does not completely fill the bottle in the previous example only the walls and cap are returned and the interior cavity will be ignored.

OpType::ResultTreeType::Ptr extractSparseTree | ( | const DenseType & | dense,
|  | const OpType & | functor,
|  | const typename OpType::ResultValueType & | background,
|  | bool | threaded = `true`
| ) |  |

Selectively extract and transform data from a dense grid, producing a sparse tree with leaf nodes only (e.g. create a tree from the square of values greater than a cutoff.)

Parameters

  dense | A dense grid that acts as a data source
  functor | A functor that selects and transforms data for output
  background | The background value of the resulting sparse grid
  threaded | Option to use threaded or serial code path

Returns
  `Ptr` to tree with the valuetype and configuration defined by typedefs in the `functor`.

Note
  To achieve optimal sparsity consider calling the prune() method on the result.
  To simply copy the all the data from a Dense grid to a OpenVDB Grid, use tools::copyFromDense() for better performance.

The type of the sparse tree is determined by the specified OtpType functor by means of the typedef OptType::ResultTreeType

The OptType function is responsible for the the transformation of dense grid data to sparse grid data on a per-voxel basis.

Only leaf nodes with active values will be added to the sparse grid.

The OpType must struct that defines a the minimal form

struct ExampleOp
{
typedef DesiredTreeType ResultTreeType;
template<typename IndexOrCoord>
void OpType::operator() (const DenseValueType a, const IndexOrCoord& ijk,
ResultTreeType::LeafNodeType* leaf);
};

For example, to generate a <ValueType, 5, 4, 3> tree with valuesOn at locations greater than a given maskvalue

template <typename ValueType>
class Rule
{
public:
// Standard tree type (e.g. BoolTree or FloatTree in openvdb.h)
typedef typename openvdb::tree::Tree4<ValueType, 5, 4, 3>::Type ResultTreeType;
typedef typename ResultTreeType::LeafNodeType ResultLeafNodeType;
typedef typename ResultTreeType::ValueType ResultValueType;
typedef float DenseValueType;
typedef vdbmath::Coord::ValueType Index;
Rule(const DenseValueType& value): mMaskValue(value){};
template <typename IndexOrCoord>
void operator()(const DenseValueType& a, const IndexOrCoord& offset,
ResultLeafNodeType* leaf) const
{
if (a > mMaskValue) {
leaf->setValueOn(offset, a);
}
}
private:
const DenseValueType mMaskValue;
};

DSConverter< DenseType, MaskTreeType >::Type::Ptr extractSparseTreeWithMask | ( | const DenseType & | dense,
|  | const MaskTreeType & | mask,
|  | const typename DenseType::ValueType & | background,
|  | bool | threaded = `true`
| ) |  |

Copy data from the intersection of a sparse tree and a dense input grid. The resulting tree has the same configuration as the sparse tree, but holds the data type specified by the dense input.

Parameters

  dense | A dense grid that acts as a data source
  mask | The active voxels and tiles intersected with dense define iteration mask
  background | The background value of the resulting sparse grid
  threaded | Option to use threaded or serial code path

Returns
  `Ptr` to tree with the same configuration as `mask` but of value type defined by `dense`.

math::Extrema extrema | ( | const IterT & | iter,
|  | bool | threaded = `true`
| ) |  |
| inline

Iterate over a scalar grid and compute extrema (min/max) of the values of the voxels that are visited, or iterate over a vector-valued grid and compute extrema of the magnitudes of the vectors.

Parameters

  iter | an iterator over the values of a grid or its tree (`Grid::ValueOnCIter`, `Tree::ValueOffIter`, etc.)
  threaded | if true, iterate over the grid in parallel

math::Extrema extrema | ( | const IterT & | iter,
|  | const ValueOp & | op,
|  | bool | threaded
| ) |  |
| inline

Iterate over a grid and compute extrema (min/max) of the values produced by applying the given functor at each voxel that is visited.

Parameters

  iter | an iterator over the values of a grid or its tree (`Grid::ValueOnCIter`, `Tree::ValueOffIter`, etc.)
  op | a functor of the form `void op(const IterT&, math::Stats&)`, where `IterT` is the type of iter, that inserts zero or more floating-point values into the provided `math::Stats` object
  threaded | if true, iterate over the grid in parallel

Note
  When threaded is true, each thread gets its own copy of the functor.

Example:
  Compute statistics of just the active and positive-valued voxels of a scalar, floating-point grid.
  struct Local {
  static inline
  void addIfPositive(const FloatGrid::ValueOnCIter& iter, math::Extrema& ex)
  {
  const float f = *iter;
  if (f > 0.0) {
  if (iter.isVoxelValue()) ex.add(f);
  else ex.add(f, iter.getVoxelCount());
  }
  }
  };
  FloatGrid grid = ...;
  math::Extrema stats =
  tools::extrema(grid.cbeginValueOn(), Local::addIfPositive, /*threaded=*/true);

void fillWithSpheres | ( | const GridT & | grid,
|  | std::vector< openvdb::Vec4s > & | spheres,
|  | int | maxSphereCount,
|  | bool | overlapping = `false`,
|  | float | minRadius = `1.0`,
|  | float | maxRadius = `std::numeric_limits<float>::max()`,
|  | float | isovalue = `0.0`,
|  | int | instanceCount = `10000`,
|  | InterrupterT * | interrupter = `NULL`
| ) |  |
| inline

Threaded method to fill a closed level set or fog volume with adaptively sized spheres.

Parameters

  grid | a scalar gird to fill with spheres.
  spheres | a `Vec4` array representing the spheres that returned by this method. The first three components specify the sphere center and the fourth is the radius. The spheres in this array are ordered by radius, biggest to smallest.
  maxSphereCount | no more than this number of spheres are generated.
  overlapping | toggle to allow spheres to overlap/intersect
  minRadius | determines the smallest sphere size in voxel units.
  maxRadius | determines the largest sphere size in voxel units.
  isovalue | the crossing point of the volume values that is considered the surface. The zero default value works for signed distance fields while fog volumes require a larger positive value, 0.5 is a good initial guess.
  instanceCount | how many interior points to consider for the sphere placement, increasing this count increases the chances of finding optimal sphere sizes.
  interrupter | a pointer adhering to the util::NullInterrupter interface

void openvdb::v3_1_0::tools::fillWithSpheres | ( | const GridT & | grid,
|  | std::vector< openvdb::Vec4s > & | spheres,
|  | int | maxSphereCount,
|  | bool | overlapping = `false`,
|  | float | minRadius = `1.0`,
|  | float | maxRadius = `std::numeric_limits<float>::max()`,
|  | float | isovalue = `0.0`,
|  | int | instanceCount = `10000`
| ) |  |
| inline

`fillWithSpheres` method variant that automatically infers the util::NullInterrupter.

Vec3d openvdb::v3_1_0::tools::findFeaturePoint | ( | const std::vector< Vec3d > & | points,
|  | const std::vector< Vec3d > & | normals
| ) |  |
| inline

Given a set of tangent elements, `points` with corresponding `normals`, this method returns the intersection point of all tangent elements.

Note
  Used to extract surfaces with sharp edges and corners from volume data, see the following paper for details: "Feature Sensitive Surface Extraction from Volume Data, Kobbelt et al. 2001".

void foreach | ( | const IterT & | iter,
|  | XformOp & | op,
|  | bool | threaded = `true`,
|  | bool | shareOp = `true`
| ) |  |
| inline

Iterate over a grid and at each step call `op(iter)`.

Parameters

  iter | an iterator over a grid or its tree (`Grid::ValueOnCIter`, `Tree::NodeIter`, etc.)
  op | a functor of the form `void op(const IterT&)`, where `IterT` is the type of iter
  threaded | if true, transform multiple values of the grid in parallel
  shareOp | if true and threaded is true, all threads use the same functor; otherwise, each thread gets its own copy of the original functor

Example:
  Multiply all values (both set and unset) of a scalar, floating-point grid by two.
  struct Local {
  static inline void op(const FloatGrid::ValueAllIter& iter) {
  iter.setValue(*iter * 2);
  }
  };
  FloatGrid grid = ...;
  tools::foreach(grid.beginValueAll(), Local::op);

Example:
  Rotate all active vectors of a vector grid by 45 degrees about the y axis.
  namespace {
  struct MatMul {
  math::Mat3s M;
  MatMul(const math::Mat3s& mat): M(mat) {}
  inline void operator()(const VectorGrid::ValueOnIter& iter) const {
  iter.setValue(M.transform(*iter));
  }
  };
  }
  {
  VectorGrid grid = ...;
  tools::foreach(grid.beginValueOn(),
  MatMul(math::rotation<math::Mat3s>(math::Y, M_PI_4)));
  }

Note
  For more complex operations that require finer control over threading, consider using `tbb::parallel_for()` or `tbb::parallel_reduce()` in conjunction with a tree::IteratorRange that wraps a grid or tree iterator.

void foreach | ( | const IterT & | iter,
|  | const XformOp & | op,
|  | bool | threaded = `true`,
|  | bool | shareOp = `true`
| ) |  |
| inline

GridT::ConstPtr getValidPointIndexGrid | ( | const PointArrayT & | points,
|  | const typename GridT::ConstPtr & | grid
| ) |  |
| inline

Repartition the points if needed, otherwise return the input grid.

GridT::Ptr getValidPointIndexGrid | ( | const PointArrayT & | points,
|  | const typename GridT::Ptr & | grid
| ) |  |
| inline

Repartition the points if needed, otherwise return the input grid.

ScalarToVectorConverter< GridType >::Type::Ptr gradient | ( | const GridType & | grid,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

Compute the gradient of the given scalar grid.

Returns
  a new vector-valued grid with the same numerical precision as the input grid (for example, if the input grid is a DoubleGrid, the output grid will be a Vec3DGrid)

When a mask grid is specified, the solution is calculated only in the intersection of the mask active topology and the input active topology independent of the transforms associated with either grid.

ScalarToVectorConverter< GridType >::Type::Ptr gradient | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

ScalarToVectorConverter<GridType>::Type::Ptr openvdb::v3_1_0::tools::gradient | ( | const GridType & | grid,
|  | bool | threaded = `true`
| ) |  |
| inline

ScalarToVectorConverter<GridType>::Type::Ptr openvdb::v3_1_0::tools::gradient | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded = `true`
| ) |  |
| inline

math::Histogram histogram | ( | const IterT & | iter,
|  | double | minVal,
|  | double | maxVal,
|  | size_t | numBins = `10`,
|  | bool | threaded = `true`
| ) |  |
| inline

Iterate over a scalar grid and compute a histogram of the values of the voxels that are visited, or iterate over a vector-valued grid and compute a histogram of the magnitudes of the vectors.

Parameters

  iter | an iterator over the values of a grid or its tree (`Grid::ValueOnCIter`, `Tree::ValueOffIter`, etc.)
  minVal | the smallest value that can be added to the histogram
  maxVal | the largest value that can be added to the histogram
  numBins | the number of histogram bins
  threaded | if true, iterate over the grid in parallel

bool isValidPartition | ( | const PointArrayT & | points,
|  | const GridT & | grid
| ) |  |
| inline

Return `true` if the given point index grid represents a valid partitioning of the given point array.

Parameters

  points | world-space point array conforming to the PointArray interface
  grid | point index grid to validate

GridType::Ptr laplacian | ( | const GridType & | grid,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

Compute the Laplacian of the given scalar grid.

Returns
  a new scalar grid

When a mask grid is specified, the solution is calculated only in the intersection of the mask active topology and the input active topology independent of the transforms associated with either grid.

GridType::Ptr laplacian | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

GridType::Ptr openvdb::v3_1_0::tools::laplacian | ( | const GridType & | grid,
|  | bool | threaded = `true`
| ) |  |
| inline

GridType::Ptr openvdb::v3_1_0::tools::laplacian | ( | const GridType & | grid,
|  | const MaskT | mask,
|  | bool | threaded = `true`
| ) |  |
| inline

Real openvdb::v3_1_0::tools::levelSetArea | ( | const GridType & | grid,
|  | bool | useWorldSpace = `true`
| ) |  |
| inline

Return the surface area of a narrow-band level set.

Parameters

  grid | a scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
  useWorldSpace | if true the area is computed in world space units, else in voxel units.

Exceptions

  TypeError | if grid is not scalar or not floating-point or not a level set.

Real openvdb::v3_1_0::tools::levelSetArea | ( | const GridT & | grid,
|  | bool | useWorldSpace
| ) |  |
| inline

void openvdb::v3_1_0::tools::levelSetMeasure | ( | const GridType & | grid,
|  | Real & | area,
|  | Real & | volume,
|  | bool | useWorldSpace = `true`
| ) |  |
| inline

Compute the surface area and volume of a narrow-band level set.

Parameters

  grid | a scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
  area | surface area of the level set
  volume | volume of the level set surface
  useWorldSpace | if true the area and volume are computed in world space units, else in voxel units.

Exceptions

  TypeError | if grid is not scalar or not floating-point or not a level set.

void openvdb::v3_1_0::tools::levelSetMeasure | ( | const GridType & | grid,
|  | Real & | area,
|  | Real & | volume,
|  | Real & | avgCurvature,
|  | bool | useWorldSpace = `true`
| ) |  |
| inline

Compute the surface area and volume of a narrow-band level set.

Parameters

  grid | a scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
  area | surface area of the level set
  volume | volume of the level set surface
  avgCurvature | average mean curvature of the level set surface
  useWorldSpace | if true the area, volume and curvature are computed in world space units, else in voxel units.

Exceptions

  TypeError | if grid is not scalar or not floating-point or not a level set.

void openvdb::v3_1_0::tools::levelSetMeasure | ( | const GridT & | grid,
|  | Real & | area,
|  | Real & | volume,
|  | bool | useWorldSpace
| ) |  |
| inline

void openvdb::v3_1_0::tools::levelSetMeasure | ( | const GridT & | grid,
|  | Real & | area,
|  | Real & | volume,
|  | Real & | avgCurvature,
|  | bool | useWorldSpace
| ) |  |
| inline

GridType::Ptr levelSetRebuild | ( | const GridType & | grid,
|  | float | isovalue = `0`,
|  | float | halfWidth = `float(LEVEL_SET_HALF_WIDTH)`,
|  | const math::Transform * | xform = `NULL`
| ) |  |
| inline

Return a new grid of type `GridType` that contains a narrow-band level set representation of an isosurface of a given grid.

Parameters

  grid | a scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
  isovalue | the isovalue that defines the implicit surface (defaults to zero, which is typical if the input grid is already a level set or a SDF).
  halfWidth | half the width of the narrow band, in voxel units (defaults to 3 voxels, which is required for some level set operations)
  xform | optional transform for the output grid (if not provided, the transform of the input grid will be matched)

Exceptions

  TypeError | if grid is not scalar or not floating-point

Note
  If the input grid contains overlapping isosurfaces, interior edges will be lost.

GridType::Ptr levelSetRebuild | ( | const GridType & | grid,
|  | float | isovalue,
|  | float | exBandWidth,
|  | float | inBandWidth,
|  | const math::Transform * | xform = `NULL`
| ) |  |
| inline

Return a new grid of type `GridType` that contains a narrow-band level set representation of an isosurface of a given grid.

Parameters

  grid | a scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
  isovalue | the isovalue that defines the implicit surface
  exBandWidth | the exterior narrow-band width in voxel units
  inBandWidth | the interior narrow-band width in voxel units
  xform | optional transform for the output grid (if not provided, the transform of the input grid will be matched)

Exceptions

  TypeError | if grid is not scalar or not floating-point

Note
  If the input grid contains overlapping isosurfaces, interior edges will be lost.

GridType::Ptr levelSetRebuild | ( | const GridType & | grid,
|  | float | isovalue,
|  | float | exBandWidth,
|  | float | inBandWidth,
|  | const math::Transform * | xform = `NULL`,
|  | InterruptT * | interrupter = `NULL`
| ) |  |
| inline

Return a new grid of type `GridType` that contains a narrow-band level set representation of an isosurface of a given grid.

Parameters

  grid | a scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
  isovalue | the isovalue that defines the implicit surface
  exBandWidth | the exterior narrow-band width in voxel units
  inBandWidth | the interior narrow-band width in voxel units
  xform | optional transform for the output grid (if not provided, the transform of the input grid will be matched)
  interrupter | optional interrupter object

Exceptions

  TypeError | if grid is not scalar or not floating-point

Note
  If the input grid contains overlapping isosurfaces, interior edges will be lost.

Real openvdb::v3_1_0::tools::levelSetVolume | ( | const GridType & | grid,
|  | bool | useWorldSpace = `true`
| ) |  |
| inline

Return the volume of a narrow-band level set surface.

Parameters

  grid | a scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
  useWorldSpace | if true the volume is computed in world space units, else in voxel units.

Exceptions

  TypeError | if grid is not scalar or not floating-point or not a level set.

Real openvdb::v3_1_0::tools::levelSetVolume | ( | const GridT & | grid,
|  | bool | useWorldSpace
| ) |  |
| inline

VectorToScalarConverter< GridType >::Type::Ptr magnitude | ( | const GridType & | grid,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

Compute the magnitudes of the vectors of the given vector-valued grid.

Returns
  a new scalar-valued grid with the same numerical precision as the input grid (for example, if the input grid is a Vec3DGrid, the output grid will be a DoubleGrid)

When a mask grid is specified, the solution is calculated only in the intersection of the mask active topology and the input active topology independent of the transforms associated with either grid.

VectorToScalarConverter< GridType >::Type::Ptr magnitude | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

VectorToScalarConverter<GridType>::Type::Ptr openvdb::v3_1_0::tools::magnitude | ( | const GridType & | grid,
|  | bool | threaded = `true`
| ) |  |
| inline

VectorToScalarConverter<GridType>::Type::Ptr openvdb::v3_1_0::tools::magnitude | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded = `true`
| ) |  |
| inline

GridType::Ptr meanCurvature | ( | const GridType & | grid,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

Compute the mean curvature of the given grid.

Returns
  a new grid

When a mask grid is specified, the solution is calculated only in the intersection of the mask active topology and the input active topology independent of the transforms associated with either grid.

GridType::Ptr meanCurvature | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

GridType::Ptr openvdb::v3_1_0::tools::meanCurvature | ( | const GridType & | grid,
|  | bool | threaded = `true`
| ) |  |
| inline

GridType::Ptr openvdb::v3_1_0::tools::meanCurvature | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded = `true`
| ) |  |
| inline

GridType::Ptr meshToLevelSet | ( | const openvdb::math::Transform & | xform,
|  | const std::vector< Vec3s > & | points,
|  | const std::vector< Vec3I > & | triangles,
|  | float | halfWidth = `float(LEVEL_SET_HALF_WIDTH)`
| ) |  |
| inline

Convert a triangle mesh to a level set volume.

Returns
  a grid of type `GridType` containing a narrow-band level set representation of the input mesh.

Exceptions

  TypeError | if `GridType` is not scalar or not floating-point

Note
  Requires a closed surface but not necessarily a manifold surface. Supports surfaces with self intersections and degenerate faces and is independent of mesh surface normals.

Parameters

  xform | transform for the output grid
  points | list of world space point positions
  triangles | triangle index list
  halfWidth | half the width of the narrow band, in voxel units

GridType::Ptr meshToLevelSet | ( | const openvdb::math::Transform & | xform,
|  | const std::vector< Vec3s > & | points,
|  | const std::vector< Vec4I > & | quads,
|  | float | halfWidth = `float(LEVEL_SET_HALF_WIDTH)`
| ) |  |
| inline

Convert a quad mesh to a level set volume.

Returns
  a grid of type `GridType` containing a narrow-band level set representation of the input mesh.

Exceptions

  TypeError | if `GridType` is not scalar or not floating-point

Note
  Requires a closed surface but not necessarily a manifold surface. Supports surfaces with self intersections and degenerate faces and is independent of mesh surface normals.

Parameters

  xform | transform for the output grid
  points | list of world space point positions
  quads | quad index list
  halfWidth | half the width of the narrow band, in voxel units

GridType::Ptr meshToLevelSet | ( | const openvdb::math::Transform & | xform,
|  | const std::vector< Vec3s > & | points,
|  | const std::vector< Vec3I > & | triangles,
|  | const std::vector< Vec4I > & | quads,
|  | float | halfWidth = `float(LEVEL_SET_HALF_WIDTH)`
| ) |  |
| inline

Convert a triangle and quad mesh to a level set volume.

Returns
  a grid of type `GridType` containing a narrow-band level set representation of the input mesh.

Exceptions

  TypeError | if `GridType` is not scalar or not floating-point

Note
  Requires a closed surface but not necessarily a manifold surface. Supports surfaces with self intersections and degenerate faces and is independent of mesh surface normals.

Parameters

  xform | transform for the output grid
  points | list of world space point positions
  triangles | triangle index list
  quads | quad index list
  halfWidth | half the width of the narrow band, in voxel units

GridType::Ptr meshToSignedDistanceField | ( | const openvdb::math::Transform & | xform,
|  | const std::vector< Vec3s > & | points,
|  | const std::vector< Vec3I > & | triangles,
|  | const std::vector< Vec4I > & | quads,
|  | float | exBandWidth,
|  | float | inBandWidth
| ) |  |
| inline

Convert a triangle and quad mesh to a signed distance field with an asymmetrical narrow band.

Returns
  a grid of type `GridType` containing a narrow-band signed distance field representation of the input mesh.

Exceptions

  TypeError | if `GridType` is not scalar or not floating-point

Note
  Requires a closed surface but not necessarily a manifold surface. Supports surfaces with self intersections and degenerate faces and is independent of mesh surface normals.

Parameters

  xform | transform for the output grid
  points | list of world space point positions
  triangles | triangle index list
  quads | quad index list
  exBandWidth | the exterior narrow-band width in voxel units
  inBandWidth | the interior narrow-band width in voxel units

GridType::Ptr meshToUnsignedDistanceField | ( | const openvdb::math::Transform & | xform,
|  | const std::vector< Vec3s > & | points,
|  | const std::vector< Vec3I > & | triangles,
|  | const std::vector< Vec4I > & | quads,
|  | float | bandWidth
| ) |  |
| inline

Convert a triangle and quad mesh to an unsigned distance field.

Returns
  a grid of type `GridType` containing a narrow-band unsigned distance field representation of the input mesh.

Exceptions

  TypeError | if `GridType` is not scalar or not floating-point

Note
  Does not requires a closed surface.

Parameters

  xform | transform for the output grid
  points | list of world space point positions
  triangles | triangle index list
  quads | quad index list
  bandWidth | the width of the narrow band, in voxel units

GridType::Ptr meshToVolume | ( | const MeshDataAdapter & | mesh,
|  | const math::Transform & | transform,
|  | float | exteriorBandWidth = `3.0f`,
|  | float | interiorBandWidth = `3.0f`,
|  | int | flags = `0`,
|  | typename GridType::template ValueConverter< Int32 >::Type * | polygonIndexGrid = `NULL`
| ) |  |
| inline

GridType::Ptr meshToVolume | ( | Interrupter & | interrupter,
|  | const MeshDataAdapter & | mesh,
|  | const math::Transform & | transform,
|  | float | exteriorBandWidth = `3.0f`,
|  | float | interiorBandWidth = `3.0f`,
|  | int | flags = `0`,
|  | typename GridType::template ValueConverter< Int32 >::Type * | polygonIndexGrid = `NULL`
| ) |  |
| inline

Convert polygonal meshes that consist of quads and/or triangles into signed or unsigned distance field volumes.

Parameters

  interrupter | a callback to interrupt the conversion process that conforms to the util::NullInterrupter interface
  mesh | mesh data access class that conforms to the MeshDataAdapter interface
  transform | world-to-index-space transform
  exteriorBandWidth | exterior narrow band width in voxel units
  interiorBandWidth | interior narrow band width in voxel units (set this value to std::numeric_limits<float>::max() to fill interior regions with distance values)
  flags | optional conversion flags defined in `MeshToVolumeFlags`
  polygonIndexGrid | optional grid output that will contain the closest-polygon index for each voxel in the active narrow band region

GridType::Ptr normalize | ( | const GridType & | grid,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

Normalize the vectors of the given vector-valued grid.

Returns
  a new vector-valued grid

When a mask grid is specified, the solution is calculated only in the intersection of the mask active topology and the input active topology independent of the transforms associated with either grid.

GridType::Ptr normalize | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded,
|  | InterruptT * | interrupt
| ) |  |
| inline

GridType::Ptr openvdb::v3_1_0::tools::normalize | ( | const GridType & | grid,
|  | bool | threaded = `true`
| ) |  |
| inline

GridType::Ptr openvdb::v3_1_0::tools::normalize | ( | const GridType & | grid,
|  | const MaskT & | mask,
|  | bool | threaded = `true`
| ) |  |
| inline

std::ostream& openvdb::v3_1_0::tools::operator<< | ( | std::ostream & | ostr,
|  | const MeshToVoxelEdgeData::EdgeData & | rhs
| ) |  |
| inline

math::Extrema opExtrema | ( | const IterT & | iter,
|  | const OperatorT & | op = `OperatorT()`,
|  | bool | threaded = `true`
| ) |  |
| inline

Same as opStatistics except it returns a math::Extrema vs a math::Stats.

math::Stats opStatistics | ( | const IterT & | iter,
|  | const OperatorT & | op = `OperatorT()`,
|  | bool | threaded = `true`
| ) |  |
| inline

Iterate over a grid and compute statistics (mean, variance, etc.) of the values produced by applying a given operator (see math/Operators.h) at each voxel that is visited.

Parameters

  iter | an iterator over the values of a grid or its tree (`Grid::ValueOnCIter`, `Tree::ValueOffIter`, etc.)
  op | an operator object with a method of the form `double result(Accessor&, const Coord&)`
  threaded | if true, iterate over the grid in parallel

Note
  World-space operators, whose `result()` methods are of the form `double result(const Map&, Accessor&, const Coord&)`, must be wrapped in a math::MapAdapter.
  Vector-valued operators like math::Gradient must be wrapped in an adapter such as math::OpMagnitude.

Example:
  Compute statistics of the magnitude of the gradient at the active voxels of a scalar, floating-point grid. (Note the use of the math::MapAdapter and math::OpMagnitude adapters.)
  FloatGrid grid = ...;
  // Assume that we know that the grid has a uniform scale map.
  typedef math::UniformScaleMap MapType;
  // Specify a world-space gradient operator that uses first-order differencing.
  typedef math::Gradient<MapType, math::FD_1ST> GradientOp;
  // Wrap the operator with an adapter that computes the magnitude of the gradient.
  typedef math::OpMagnitude<GradientOp, MapType> MagnitudeOp;
  // Wrap the operator with an adapter that associates a map with it.
  typedef math::MapAdapter<MapType, GradientOp, double> CompoundOp;
  if (MapType::Ptr map = grid.constTransform().constMap<MapType>()) {
  math::Stats stats = tools::opStatistics(grid.cbeginValueOn(), CompoundOp(*map));
  }

Example:
  Compute statistics of the divergence at the active voxels of a vector-valued grid.
  Vec3SGrid grid = ...;
  // Assume that we know that the grid has a uniform scale map.
  typedef math::UniformScaleMap MapType;
  // Specify a world-space divergence operator that uses first-order differencing.
  typedef math::Divergence<MapType, math::FD_1ST> DivergenceOp;
  // Wrap the operator with an adapter that associates a map with it.
  typedef math::MapAdapter<MapType, DivergenceOp, double> CompoundOp;
  if (MapType::Ptr map = grid.constTransform().constMap<MapType>()) {
  math::Stats stats = tools::opStatistics(grid.cbeginValueOn(), CompoundOp(*map));
  }

Example:
  As above, but computing the divergence in index space.
  Vec3SGrid grid = ...;
  // Specify an index-space divergence operator that uses first-order differencing.
  typedef math::ISDivergence<math::FD_1ST> DivergenceOp;
  math::Stats stats = tools::opStatistics(grid.cbeginValueOn(), DivergenceOp());

void prune | ( | TreeT & | tree,
|  | typename TreeT::ValueType | tolerance = `zeroVal<typename TreeT::ValueType>()`,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

Reduce the memory footprint of a tree by replacing with tiles any nodes whose values are all the same (optionally to within a tolerance) and have the same active state.

Note
  For trees with floating-point values a child node with (approximately) constant values are replaced with a tile value corresponding to the average of the extrema values in said child node. Else the first value encountered in the child node is used.

Parameters

  tree | the tree to be pruned
  tolerance | tolerance within which values are considered to be equal
  threaded | enable or disable threading (threading is enabled by default)
  grainSize | used to control the threading granularity (default is 1)

void pruneInactive | ( | TreeT & | tree,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

Reduce the memory footprint of a tree by replacing with background tiles any nodes whose values are all inactive.

Parameters

  tree | the tree to be pruned
  threaded | enable or disable threading (threading is enabled by default)
  grainSize | used to control the threading granularity (default is 1)

void pruneInactiveWithValue | ( | TreeT & | tree,
|  | const typename TreeT::ValueType & | value,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

Reduce the memory footprint of a tree by replacing any nodes whose values are all inactive with tiles of the given value.

Parameters

  tree | the tree to be pruned
  value | value assigned to inactive tiles created during pruning
  threaded | enable or disable threading (threading is enabled by default)
  grainSize | used to control the threading granularity (default is 1)

void pruneLevelSet | ( | TreeT & | tree,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

Reduce the memory footprint of a tree by replacing nodes whose values are all inactive with inactive tiles having a value equal to the first value encountered in the (inactive) child.

This method is faster than tolerance-based prune and useful for narrow-band level set applications where inactive values are limited to either an inside or an outside value.

Parameters

  tree | the tree to be pruned
  threaded | enable or disable threading (threading is enabled by default)
  grainSize | used to control the threading granularity (default is 1)

Exceptions

  ValueError | if the background of the tree is negative (as defined by math::isNegative)

void pruneLevelSet | ( | TreeT & | tree,
|  | const typename TreeT::ValueType & | outsideWidth,
|  | const typename TreeT::ValueType & | insideWidth,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

Reduce the memory footprint of a tree by replacing nodes whose voxel values are all inactive with inactive tiles having the value -| insideWidth | if the voxel values are negative and | outsideWidth | otherwise.

This method is faster than tolerance-based prune and useful for narrow-band level set applications where inactive values are limited to either an inside or an outside value.

Parameters

  tree | the tree to be pruned
  outsideWidth | the width of the outside of the narrow band
  insideWidth | the width of the inside of the narrow band
  threaded | enable or disable threading (threading is enabled by default)
  grainSize | used to control the threading granularity (default is 1)

Exceptions

  ValueError | if outsideWidth is negative or insideWidth is not negative (as defined by math::isNegative).

void pruneTiles | ( | TreeT & | tree,
|  | typename TreeT::ValueType | tolerance = `zeroVal<typename TreeT::ValueType>()`,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

Reduce the memory footprint of a tree by replacing with tiles any non-leaf nodes whose values are all the same (optionally to within a tolerance) and have the same active state.

Parameters

  tree | the tree to be pruned
  tolerance | tolerance within which values are considered to be equal
  threaded | enable or disable threading (threading is enabled by default)
  grainSize | used to control the threading granularity (default is 1)

void rayTrace | ( | const GridT & | grid,
|  | const BaseShader & | shader,
|  | BaseCamera & | camera,
|  | size_t | pixelSamples = `1`,
|  | unsigned int | seed = `0`,
|  | bool | threaded = `true`
| ) |  |
| inline

Ray-trace a volume.

void rayTrace | ( | const GridT & | ,
|  | const IntersectorT & | inter,
|  | const BaseShader & | shader,
|  | BaseCamera & | camera,
|  | size_t | pixelSamples = `1`,
|  | unsigned int | seed = `0`,
|  | bool | threaded = `true`
| ) |  |
| inline

Ray-trace a volume using a given ray intersector.

void resampleToMatch | ( | const GridType & | inGrid,
|  | GridType & | outGrid,
|  | Interrupter & | interrupter
| ) |  |
| inline

Resample an input grid into an output grid of the same type such that, after resampling, the input and output grids coincide (apart from sampling artifacts), but the output grid's transform is unchanged.

Specifically, this function resamples the input grid into the output grid's index space, using a sampling kernel like PointSampler, BoxSampler, or QuadraticSampler.

Parameters

  inGrid | the grid to be resampled
  outGrid | the grid into which to write the resampled voxel data
  interrupter | an object adhering to the util::NullInterrupter interface

Example:
  // Create an input grid with the default identity transform
  // and populate it with a level-set sphere.
  FloatGrid::ConstPtr src = tools::makeSphere(...);
  // Create an output grid and give it a uniform-scale transform.
  FloatGrid::Ptr dest = FloatGrid::create();
  const float voxelSize = 0.5;
  dest->setTransform(math::Transform::createLinearTransform(voxelSize));
  // Resample the input grid into the output grid, reproducing
  // the level-set sphere at a smaller voxel size.
  MyInterrupter interrupter = ...;
  tools::resampleToMatch<tools::QuadraticSampler>(*src, *dest, interrupter);

void resampleToMatch | ( | const GridType & | inGrid,
|  | GridType & | outGrid
| ) |  |
| inline

Resample an input grid into an output grid of the same type such that, after resampling, the input and output grids coincide (apart from sampling artifacts), but the output grid's transform is unchanged.

Specifically, this function resamples the input grid into the output grid's index space, using a sampling kernel like PointSampler, BoxSampler, or QuadraticSampler.

Parameters

  inGrid | the grid to be resampled
  outGrid | the grid into which to write the resampled voxel data

Example:
  // Create an input grid with the default identity transform
  // and populate it with a level-set sphere.
  FloatGrid::ConstPtr src = tools::makeSphere(...);
  // Create an output grid and give it a uniform-scale transform.
  FloatGrid::Ptr dest = FloatGrid::create();
  const float voxelSize = 0.5;
  dest->setTransform(math::Transform::createLinearTransform(voxelSize));
  // Resample the input grid into the output grid, reproducing
  // the level-set sphere at a smaller voxel size.
  tools::resampleToMatch<tools::QuadraticSampler>(*src, *dest);

GridOrTreeType::template ValueConverter< bool >::Type::Ptr sdfInteriorMask | ( | const GridOrTreeType & | volume,
|  | typename GridOrTreeType::ValueType | isovalue = `lsutilGridZero<GridOrTreeType>()`
| ) |  |
| inline

Threaded method to construct a boolean mask that represents interior regions in a signed distance field.

Returns
  A shared pointer to either a boolean grid or tree with the same tree configuration and potentially transform as the input `volume` and whose active and `true` values correspond to the interior of the input signed distance field.

Parameters

  volume | Signed distance field / level set volume.
  isovalue | Threshold below which values are considered part of the interior region.

void sdfToFogVolume | ( | GridType & | grid,
|  | typename GridType::ValueType | cutoffDistance = `lsutilGridMax<GridType>()`
| ) |  |
| inline

Threaded method to convert a sparse level set/SDF into a sparse fog volume.

For a level set, the active and negative-valued interior half of the narrow band becomes a linear ramp from 0 to 1; the inactive interior becomes active with a constant value of 1; and the exterior, including the background and the active exterior half of the narrow band, becomes inactive with a constant value of 0. The interior, though active, remains sparse.

For a generic SDF, a specified cutoff distance determines the width of the ramp, but otherwise the result is the same as for a level set.

Parameters

  grid | level set/SDF grid to transform
  cutoffDistance | optional world space cutoff distance for the ramp (automatically clamped if greater than the interior narrow band width)

void setValueOnMax | ( | TreeT & | tree,
|  | const Coord & | xyz,
|  | const typename TreeT::ValueType & | value
| ) |  |
| inline

Set the value of the voxel at the given coordinates in tree to the maximum of its current value and value, and mark the voxel as active.

This is typically significantly faster than calling getValue() followed by setValueOn().

Note
  TreeT can be either a Tree or a ValueAccessor.

void setValueOnMin | ( | TreeT & | tree,
|  | const Coord & | xyz,
|  | const typename TreeT::ValueType & | value
| ) |  |
| inline

Set the value of the voxel at the given coordinates in tree to the minimum of its current value and value, and mark the voxel as active.

This is typically significantly faster than calling getValue() followed by setValueOn().

Note
  TreeT can be either a Tree or a ValueAccessor.

void setValueOnMult | ( | TreeT & | tree,
|  | const Coord & | xyz,
|  | const typename TreeT::ValueType & | value
| ) |  |
| inline

Set the value of the voxel at the given coordinates in tree to the product of its current value and value, and mark the voxel as active.

This is typically significantly faster than calling getValue() followed by setValueOn().

Note
  TreeT can be either a Tree or a ValueAccessor.

void setValueOnSum | ( | TreeT & | tree,
|  | const Coord & | xyz,
|  | const typename TreeT::ValueType & | value
| ) |  |
| inline

Set the value of the voxel at the given coordinates in tree to the sum of its current value and value, and mark the voxel as active.

This is typically significantly faster than calling getValue() followed by setValueOn().

Note
  TreeT can be either a Tree or a ValueAccessor.

void signedFloodFill | ( | TreeOrLeafManagerT & | tree,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

Set the values of all inactive voxels and tiles of a narrow-band level set from the signs of the active voxels, setting outside values to +background and inside values to -background.

Warning
  This method should only be used on closed, symmetric narrow-band level sets.

Note
  If a LeafManager is used the cached leaf nodes are reused, resulting in slightly better overall performance.

Parameters

  tree | Tree or LeafManager that will be flood filled.
  threaded | enable or disable threading (threading is enabled by default)
  grainSize | used to control the threading granularity (default is 1)

Exceptions

  TypeError | if the ValueType of tree is not floating-point.

void signedFloodFillWithValues | ( | TreeOrLeafManagerT & | tree,
|  | const typename TreeOrLeafManagerT::ValueType & | outsideWidth,
|  | const typename TreeOrLeafManagerT::ValueType & | insideWidth,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

Set the values of all inactive voxels and tiles of a narrow-band level set from the signs of the active voxels, setting exterior values to outsideWidth and interior values to insideWidth. Set the background value of this tree to outsideWidth.

Warning
  This method should only be used on closed, narrow-band level sets.

Note
  If a LeafManager is used the cached leaf nodes are reused resulting in slightly better overall performance.

Parameters

  tree | Tree or LeafManager that will be flood filled
  outsideWidth | the width of the outside of the narrow band
  insideWidth | the width of the inside of the narrow band
  threaded | enable or disable threading (threading is enabled by default)
  grainSize | used to control the threading granularity (default is 1)

Exceptions

  TypeError | if the ValueType of tree is not floating-point.

math::Stats statistics | ( | const IterT & | iter,
|  | bool | threaded = `true`
| ) |  |
| inline

Iterate over a scalar grid and compute statistics (mean, variance, etc.) of the values of the voxels that are visited, or iterate over a vector-valued grid and compute statistics of the magnitudes of the vectors.

Parameters

  iter | an iterator over the values of a grid or its tree (`Grid::ValueOnCIter`, `Tree::ValueOffIter`, etc.)
  threaded | if true, iterate over the grid in parallel

math::Stats statistics | ( | const IterT & | iter,
|  | const ValueOp & | op,
|  | bool | threaded
| ) |  |
| inline

Iterate over a grid and compute statistics (mean, variance, etc.) of the values produced by applying the given functor at each voxel that is visited.

Parameters

  iter | an iterator over the values of a grid or its tree (`Grid::ValueOnCIter`, `Tree::ValueOffIter`, etc.)
  op | a functor of the form `void op(const IterT&, math::Stats&)`, where `IterT` is the type of iter, that inserts zero or more floating-point values into the provided `math::Stats` object
  threaded | if true, iterate over the grid in parallel

Note
  When threaded is true, each thread gets its own copy of the functor.

Example:
  Compute statistics of just the active and positive-valued voxels of a scalar, floating-point grid.
  struct Local {
  static inline
  void addIfPositive(const FloatGrid::ValueOnCIter& iter, math::Stats& stats)
  {
  const float f = *iter;
  if (f > 0.0) {
  if (iter.isVoxelValue()) stats.add(f);
  else stats.add(f, iter.getVoxelCount());
  }
  }
  };
  FloatGrid grid = ...;
  math::Stats stats =
  tools::statistics(grid.cbeginValueOn(), Local::addIfPositive, /*threaded=*/true);

void traceExteriorBoundaries | ( | FloatTreeT & | tree | ) |
| inline

Traces the exterior voxel boundary of closed objects in the input volume tree. Exterior voxels are marked with a negative sign, voxels with a value below `0.75` are left unchanged and act as the boundary layer.

Note
  Does not propagate sign information into tile regions.

void openvdb::v3_1_0::tools::transformDense | ( | Dense< ValueT, openvdb::tools::LayoutZYX > & | dense,
|  | const openvdb::CoordBBox & | bbox,
|  | const OpType & | op,
|  | bool | parallel = `true`
| ) |  |

Apply a point-wise functor to the intersection of a dense grid and a given bounding box

Parameters

  dense | A dense grid to be transformed
  bbox | Index space bounding box, define region where the transformation is applied
  op | A functor that acts on the dense grid value type
  parallel | Used to select multithreaded or single threaded Minimally, the `op` class has to support a `operator()` method, // Square values in a grid struct Op { ValueT operator()(const ValueT& in) const { // do work ValueT result = in * in; return result; } }; NB: only Dense grids with memory layout zxy are supported

void openvdb::v3_1_0::tools::transformDense | ( | Dense< ValueT, openvdb::tools::LayoutZYX > & | dense,
|  | const openvdb::CoordBBox & | bbox,
|  | const PointwiseOpT & | functor,
|  | bool | parallel
| ) |  |

Apply a point-wise functor to the intersection of a dense grid and a given bounding box.

void transformValues | ( | const InIterT & | inIter,
|  | OutGridT & | outGrid,
|  | XformOp & | op,
|  | bool | threaded = `true`,
|  | bool | shareOp = `true`,
|  | MergePolicy | merge = `MERGE_ACTIVE_STATES`
| ) |  |
| inline

Iterate over a grid and at each step call `op(iter, accessor)` to populate (via the accessor) the given output grid, whose `ValueType` need not be the same as the input grid's.

Parameters

  inIter | a non-`const` or (preferably) `const` iterator over an input grid or its tree (`Grid::ValueOnCIter`, `Tree::NodeIter`, etc.)
  outGrid | an empty grid to be populated
  op | a functor of the form `void op(const InIterT&, OutGridT::ValueAccessor&)`, where `InIterT` is the type of inIter
  threaded | if true, transform multiple values of the input grid in parallel
  shareOp | if true and threaded is true, all threads use the same functor; otherwise, each thread gets its own copy of the original functor
  merge | how to merge intermediate results from multiple threads (see Types.h)

Example:
  Populate a scalar floating-point grid with the lengths of the vectors from all active voxels of a vector-valued input grid.
  struct Local {
  static void op(
  const Vec3fGrid::ValueOnCIter& iter,
  FloatGrid::ValueAccessor& accessor)
  {
  if (iter.isVoxelValue()) { // set a single voxel
  accessor.setValue(iter.getCoord(), iter->length());
  } else { // fill an entire tile
  CoordBBox bbox;
  iter.getBoundingBox(bbox);
  accessor.getTree()->fill(bbox, iter->length());
  }
  }
  };
  Vec3fGrid inGrid = ...;
  FloatGrid outGrid;
  tools::transformValues(inGrid.cbeginValueOn(), outGrid, Local::op);

Note
  For more complex operations that require finer control over threading, consider using `tbb::parallel_for()` or `tbb::parallel_reduce()` in conjunction with a tree::IteratorRange that wraps a grid or tree iterator.

void transformValues | ( | const InIterT & | inIter,
|  | OutGridT & | outGrid,
|  | const XformOp & | op,
|  | bool | threaded = `true`,
|  | bool | shareOp = `true`,
|  | MergePolicy | merge = `MERGE_ACTIVE_STATES`
| ) |  |
| inline

void transformVectors | ( | GridType & | grid,
|  | const Mat4d & | mat
| ) |  |
| inline

Apply an affine transform to the voxel values of a vector-valued grid in accordance with the grid's vector type (covariant, contravariant, etc.).

Exceptions

  TypeError | if the grid is not vector-valued

bool uniqueInactiveValues | ( | const GridType & | grid,
|  | std::vector< typename GridType::ValueType > & | values,
|  | size_t | numValues
| ) |  |

Threaded method to find unique inactive values.

Parameters

  grid | A VDB volume.
  values | List of unique inactive values, returned by this method.
  numValues | Number of values to look for.

Returns
  `false` if the grid has more than numValues inactive values.

void volumeToMesh | ( | const GridType & | grid,
|  | std::vector< Vec3s > & | points,
|  | std::vector< Vec4I > & | quads,
|  | double | isovalue = `0.0`
| ) |  |
| inline

Uniformly mesh any scalar grid that has a continuous isosurface.

Parameters

  grid | a scalar grid to mesh
  points | output list of world space points
  quads | output quad index list
  isovalue | determines which isosurface to mesh

Exceptions

  TypeError | if grid does not have a scalar value type

void volumeToMesh | ( | const GridType & | grid,
|  | std::vector< Vec3s > & | points,
|  | std::vector< Vec3I > & | triangles,
|  | std::vector< Vec4I > & | quads,
|  | double | isovalue = `0.0`,
|  | double | adaptivity = `0.0`
| ) |  |
| inline

Adaptively mesh any scalar grid that has a continuous isosurface.

Parameters

  grid | a scalar grid to mesh
  points | output list of world space points
  triangles | output triangle index list
  quads | output quad index list
  isovalue | determines which isosurface to mesh
  adaptivity | surface adaptivity threshold [0 to 1]

Exceptions

  TypeError | if grid does not have a scalar value type