OpenVDB  3.0.0
Namespaces | Classes | Typedefs | Enumerations | Functions
openvdb::v3_0_0::tools Namespace Reference

Namespaces

 activation
 
 clip_internal
 
 composite
 
 diagnostics_internal
 
 ds
 
 filter_internal
 
 gridop
 
 internal
 
 local_util
 
 p2ls_internal
 
 point_index_grid_internal
 
 point_partitioner_internal
 
 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  CheckFinite
 Checks for both NaN and inf values, i.e. any value that is not finite. More...
 
struct  CheckInf
 Checks for infinite values, e.g. 1/0 or -1/0. 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. 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 worldspace 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 vecloity 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 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  MeshToVolume
 
class  MeshToVoxelEdgeData
 Extracts and stores voxel edge intersection data from a mesh. More...
 
class  MinMaxVoxel
 Threaded operator that finds the minimum and maximum values among the active leaf-level voxels of a grid. 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
 Partitions points into Log2Dim aligned buckets. More...
 
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  QuadraticSampler
 
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 suppiled maks 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  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< PointIndexTreePointIndexGrid
 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< PolygonPoolPolygonPoolList
 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  { GENERATE_PRIM_INDEX_GRID = 0x1, OUTPUT_RAW_DATA = 0x2 }
 Conversion flags, used to control the MeshToVolume output. 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 >
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 GridType >
Grid< typename GridType::TreeType::template ValueConverter< bool >::Type >::Ptr sdfInteriorMask (const GridType &grid, typename GridType::ValueType iso=lsutilGridZero< GridType >())
 Threaded method to extract an interior region mask from a level set/SDF grid. 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 >
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< typename boost::is_floating_point< typename TreeOrLeafManagerT::ValueType >::type >::type doSignedFloodFill (TreeOrLeafManagerT &tree, typename TreeOrLeafManagerT::ValueType outsideValue, typename TreeOrLeafManagerT::ValueType insideValue, bool threaded, size_t grainSize)
 
template<typename TreeOrLeafManagerT >
boost::disable_if< typename boost::is_floating_point< typename TreeOrLeafManagerT::ValueType >::type >::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 extremas (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

Point index grid.

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.

Enumeration Type Documentation

anonymous enum

Conversion flags, used to control the MeshToVolume output.

Enumerator
GENERATE_PRIM_INDEX_GRID 
OUTPUT_RAW_DATA 
anonymous enum

Polygon flags, used for reference based meshing.

Enumerator
POLYFLAG_EXTERIOR 
POLYFLAG_FRACTURE_SEAM 
POLYFLAG_SUBDIVIDED 

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 

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 

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_0_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
iteran iterator over a grid or its tree (Grid::ValueOnCIter, Tree::NodeIter, etc.)
opa 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
threadedif 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
treeTree (or LeafManager) that will have its background value changed
outsideWidthThe width of the outside of the narrow band
insideWidthThe width of the inside of the narrow band
threadedenable or disable threading (threading is enabled by default)
grainSizeused to control the threading granularity (default is 32)
Exceptions
ValueErrorif 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 perserved, 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
treeTree (or LeafManager) that will have its background value changed
backgroundthe new background value
threadedenable or disable threading (threading is enabled by default)
grainSizeused 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
treeTree (or LeafManager) that will have its background value changed
halfWidthhalf of the width of the symmetric narrow band
threadedenable or disable threading (threading is enabled by default)
grainSizeused to control the threading granularity (default is 32)
Exceptions
ValueErrorif halfWidth is negative (as defined by math::isNegative)
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
gridthe grid to be clipped
maska 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
denseDense grid to be altered by the operation
sourceSparse data to composite into dense
alphaSparse Alpha mask used in compositing operations.
betaConstant multiplier on src
strengthConstant multiplier on alpha
threadedEnable 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
densethe dense grid from which to copy values
sparsean OpenVDB grid or tree into which to copy values
tolerancevalues 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
serialif 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
sparsean OpenVDB grid or tree from which to copy values
densethe dense grid into which to copy values
serialif 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_0_0::tools::cpt ( const GridType &  grid,
bool  threaded = true 
)
inline
ScalarToVectorConverter<GridType>::Type::Ptr openvdb::v3_0_0::tools::cpt ( const GridType &  grid,
const MaskT &  mask,
bool  threaded = true 
)
inline
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
radiusradius of the sphere in world units
centercenter of the sphere in world units
voxelSizevoxel size in world units
halfWidthhalf the width of the narrow band, in voxel units
interrupta 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_0_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
radiusradius of the sphere in world units
centercenter of the sphere in world units
voxelSizevoxel size in world units
halfWidthhalf 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
pointsworld-space point array conforming to the PointArray interface
xformworld-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
ValueErrorif 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
ValueErrorif 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
ValueErrorif 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_0_0::tools::curl ( const GridType &  grid,
bool  threaded = true 
)
inline
GridType::Ptr openvdb::v3_0_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
treetree to be dilated
iterationsnumber of iterations to apply the dilation
nnconnectivity 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
managerLeafManager containing the tree to be dilated.
iterationsnumber of iterations to apply the dilation
nnconnectivity 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_0_0::tools::divergence ( const GridType &  grid,
bool  threaded = true 
)
inline
VectorToScalarConverter<GridType>::Type::Ptr openvdb::v3_0_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_0_0::tools::doLevelSetArea ( const GridT &  grid,
bool  useWorldSpace 
)
inline
boost::disable_if<boost::is_floating_point<typename GridT::ValueType>, Real>::type openvdb::v3_0_0::tools::doLevelSetArea ( const GridT &  ,
bool   
)
inline
boost::enable_if<boost::is_floating_point<typename GridT::ValueType> >::type openvdb::v3_0_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_0_0::tools::doLevelSetMeasure ( const GridT &  ,
Real ,
Real ,
bool   
)
inline
boost::enable_if<boost::is_floating_point<typename GridT::ValueType> >::type openvdb::v3_0_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_0_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_0_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_0_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_0_0::tools::doLevelSetVolume ( const GridT &  grid,
bool  useWorldSpace 
)
inline
boost::disable_if<boost::is_floating_point<typename GridT::ValueType>, Real>::type openvdb::v3_0_0::tools::doLevelSetVolume ( const GridT &  ,
bool   
)
inline
boost::enable_if<boost::is_floating_point<typename GridType::ValueType>,typename GridType::Ptr>::type openvdb::v3_0_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_0_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_0_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<typename boost::is_floating_point< typename TreeOrLeafManagerT::ValueType>::type>::type openvdb::v3_0_0::tools::doSignedFloodFill ( TreeOrLeafManagerT &  tree,
typename TreeOrLeafManagerT::ValueType  outsideValue,
typename TreeOrLeafManagerT::ValueType  insideValue,
bool  threaded,
size_t  grainSize 
)
inline
boost::disable_if<typename boost::is_floating_point< typename TreeOrLeafManagerT::ValueType>::type>::type openvdb::v3_0_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_0_0::tools::doTransformVectors ( GridType &  ,
const Mat4d  
)
inline
boost::enable_if_c<VecTraits<typename GridType::ValueType>::IsVec, void>::type openvdb::v3_0_0::tools::doTransformVectors ( GridType &  grid,
const Mat4d mat 
)
inline
boost::enable_if<boost::is_scalar<typename GridType::ValueType>, void>::type openvdb::v3_0_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_0_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.

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
denseA dense grid that acts as a data source
functorA functor that selects and transforms data for output
backgroundThe background value of the resulting sparse grid
threadedOption 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
denseA dense grid that acts as a data source
maskThe active voxels and tiles intersected with dense define iteration mask
backgroundThe background value of the resulting sparse grid
threadedOption 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
iteran iterator over the values of a grid or its tree (Grid::ValueOnCIter, Tree::ValueOffIter, etc.)
threadedif 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 extremas (min/max) of the values produced by applying the given functor at each voxel that is visited.

Parameters
iteran iterator over the values of a grid or its tree (Grid::ValueOnCIter, Tree::ValueOffIter, etc.)
opa 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
threadedif 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
grida scalar gird to fill with spheres.
spheresa 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.
maxSphereCountno more than this number of spheres are generated.
overlappingtoggle to allow spheres to overlap/intersect
minRadiusdetermines the smallest sphere size in voxel units.
maxRadiusdetermines the largest sphere size in voxel units.
isovaluethe 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.
instanceCounthow many interior points to consider for the sphere placement, increasing this count increases the chances of finding optimal sphere sizes.
interruptera pointer adhering to the util::NullInterrupter interface
void openvdb::v3_0_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_0_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
iteran iterator over a grid or its tree (Grid::ValueOnCIter, Tree::NodeIter, etc.)
opa functor of the form void op(const IterT&), where IterT is the type of iter
threadedif true, transform multiple values of the grid in parallel
shareOpif 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 {
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_0_0::tools::gradient ( const GridType &  grid,
bool  threaded = true 
)
inline
ScalarToVectorConverter<GridType>::Type::Ptr openvdb::v3_0_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
iteran iterator over the values of a grid or its tree (Grid::ValueOnCIter, Tree::ValueOffIter, etc.)
minValthe smallest value that can be added to the histogram
maxValthe largest value that can be added to the histogram
numBinsthe number of histogram bins
threadedif 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
pointsworld-space point array conforming to the PointArray interface
gridpoint 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_0_0::tools::laplacian ( const GridType &  grid,
bool  threaded = true 
)
inline
GridType::Ptr openvdb::v3_0_0::tools::laplacian ( const GridType &  grid,
const MaskT  mask,
bool  threaded = true 
)
inline
Real openvdb::v3_0_0::tools::levelSetArea ( const GridType &  grid,
bool  useWorldSpace = true 
)
inline

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

Parameters
grida scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
useWorldSpaceif true the area is computed in world space units, else in voxel units.
Exceptions
TypeErrorif grid is not scalar or not floating-point or not a level set.
Real openvdb::v3_0_0::tools::levelSetArea ( const GridT &  grid,
bool  useWorldSpace 
)
inline
void openvdb::v3_0_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
grida scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
areasurface area of the level set
volumevolume of the level set surface
useWorldSpaceif true the area and volume are computed in world space units, else in voxel units.
Exceptions
TypeErrorif grid is not scalar or not floating-point or not a level set.
void openvdb::v3_0_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
grida scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
areasurface area of the level set
volumevolume of the level set surface
avgCurvatureaverage mean curvature of the level set surface
useWorldSpaceif true the area, volume and curvature are computed in world space units, else in voxel units.
Exceptions
TypeErrorif grid is not scalar or not floating-point or not a level set.
void openvdb::v3_0_0::tools::levelSetMeasure ( const GridT &  grid,
Real area,
Real volume,
bool  useWorldSpace 
)
inline
void openvdb::v3_0_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
grida scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
isovaluethe isovalue that defines the implicit surface (defaults to zero, which is typical if the input grid is already a level set or a SDF).
halfWidthhalf the width of the narrow band, in voxel units (defaults to 3 voxels, which is required for some level set operations)
xformoptional transform for the output grid (if not provided, the transform of the input grid will be matched)
Exceptions
TypeErrorif 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
grida scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
isovaluethe isovalue that defines the implicit surface
exBandWidththe exterior narrow-band width in voxel units
inBandWidththe interior narrow-band width in voxel units
xformoptional transform for the output grid (if not provided, the transform of the input grid will be matched)
Exceptions
TypeErrorif 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
grida scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
isovaluethe isovalue that defines the implicit surface
exBandWidththe exterior narrow-band width in voxel units
inBandWidththe interior narrow-band width in voxel units
xformoptional transform for the output grid (if not provided, the transform of the input grid will be matched)
interrupteroptional interrupter object
Exceptions
TypeErrorif grid is not scalar or not floating-point
Note
If the input grid contains overlapping isosurfaces, interior edges will be lost.
Real openvdb::v3_0_0::tools::levelSetVolume ( const GridType &  grid,
bool  useWorldSpace = true 
)
inline

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

Parameters
grida scalar, floating-point grid with one or more disjoint, closed isosurfaces at the given isovalue
useWorldSpaceif true the volume is computed in world space units, else in voxel units.
Exceptions
TypeErrorif grid is not scalar or not floating-point or not a level set.
Real openvdb::v3_0_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_0_0::tools::magnitude ( const GridType &  grid,
bool  threaded = true 
)
inline
VectorToScalarConverter<GridType>::Type::Ptr openvdb::v3_0_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_0_0::tools::meanCurvature ( const GridType &  grid,
bool  threaded = true 
)
inline
GridType::Ptr openvdb::v3_0_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
TypeErrorif 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
xformtransform for the output grid
pointslist of world space point positions
trianglestriangle index list
halfWidthhalf 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
TypeErrorif 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
xformtransform for the output grid
pointslist of world space point positions
quadsquad index list
halfWidthhalf 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
TypeErrorif 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
xformtransform for the output grid
pointslist of world space point positions
trianglestriangle index list
quadsquad index list
halfWidthhalf 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
TypeErrorif 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
xformtransform for the output grid
pointslist of world space point positions
trianglestriangle index list
quadsquad index list
exBandWidththe exterior narrow-band width in voxel units
inBandWidththe 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
TypeErrorif GridType is not scalar or not floating-point
Note
Does not requires a closed surface.
Parameters
xformtransform for the output grid
pointslist of world space point positions
trianglestriangle index list
quadsquad index list
bandWidththe width of the narrow band, in voxel units
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_0_0::tools::normalize ( const GridType &  grid,
bool  threaded = true 
)
inline
GridType::Ptr openvdb::v3_0_0::tools::normalize ( const GridType &  grid,
const MaskT &  mask,
bool  threaded = true 
)
inline
std::ostream& openvdb::v3_0_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
iteran iterator over the values of a grid or its tree (Grid::ValueOnCIter, Tree::ValueOffIter, etc.)
opan operator object with a method of the form double result(Accessor&, const Coord&)
threadedif 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.

Parameters
treethe tree to be pruned
tolerancetolerance within which values are considered to be equal
threadedenable or disable threading (threading is enabled by default)
grainSizeused 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
treethe tree to be pruned
threadedenable or disable threading (threading is enabled by default)
grainSizeused 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
treethe tree to be pruned
valuevalue assigned to inactive tiles created during pruning
threadedenable or disable threading (threading is enabled by default)
grainSizeused 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
treethe tree to be pruned
threadedenable or disable threading (threading is enabled by default)
grainSizeused to control the threading granularity (default is 1)
Exceptions
ValueErrorif 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
treethe tree to be pruned
outsideWidththe width of the outside of the narrow band
insideWidththe width of the inside of the narrow band
threadedenable or disable threading (threading is enabled by default)
grainSizeused to control the threading granularity (default is 1)
Exceptions
ValueErrorif 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
treethe tree to be pruned
tolerancetolerance within which values are considered to be equal
threadedenable or disable threading (threading is enabled by default)
grainSizeused 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
inGridthe grid to be resampled
outGridthe grid into which to write the resampled voxel data
interrupteran 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.
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
inGridthe grid to be resampled
outGridthe 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.
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);
Grid< typename GridType::TreeType::template ValueConverter< bool >::Type >::Ptr sdfInteriorMask ( const GridType &  grid,
typename GridType::ValueType  iso = lsutilGridZero<GridType>() 
)
inline

Threaded method to extract an interior region mask from a level set/SDF grid.

Returns
a shared pointer to a new boolean grid with the same tree configuration and transform as the incoming grid and whose active voxels correspond to the interior of the input SDF
Parameters
grida level set/SDF grid
isothreshold below which values are considered to be 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
gridlevel set/SDF grid to transform
cutoffDistanceoptional 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
treeTree or LeafManager that will be flood filled.
threadedenable or disable threading (threading is enabled by default)
grainSizeused to control the threading granularity (default is 1)
Exceptions
TypeErrorif 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
treeTree or LeafManager that will be flood filled
outsideWidththe width of the outside of the narrow band
insideWidththe width of the inside of the narrow band
threadedenable or disable threading (threading is enabled by default)
grainSizeused to control the threading granularity (default is 1)
Exceptions
TypeErrorif 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
iteran iterator over the values of a grid or its tree (Grid::ValueOnCIter, Tree::ValueOffIter, etc.)
threadedif 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
iteran iterator over the values of a grid or its tree (Grid::ValueOnCIter, Tree::ValueOffIter, etc.)
opa 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
threadedif 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 openvdb::v3_0_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
denseA dense grid to be transformed
bboxIndex space bounding box, define region where the transformation is applied
opA functor that acts on the dense grid value type
parallelUsed 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_0_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
inItera non-const or (preferably) const iterator over an input grid or its tree (Grid::ValueOnCIter, Tree::NodeIter, etc.)
outGridan empty grid to be populated
opa functor of the form void op(const InIterT&, OutGridT::ValueAccessor&), where InIterT is the type of inIter
threadedif true, transform multiple values of the input grid in parallel
shareOpif true and threaded is true, all threads use the same functor; otherwise, each thread gets its own copy of the original functor
mergehow 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(
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
TypeErrorif 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
gridA VDB volume.
valuesList of unique inactive values, returned by this method.
numValuesNumber 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
grida scalar grid to mesh
pointsoutput list of world space points
quadsoutput quad index list
isovaluedetermines which isosurface to mesh
Exceptions
TypeErrorif 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
grida scalar grid to mesh
pointsoutput list of world space points
trianglesoutput quad index list
quadsoutput quad index list
isovaluedetermines which isosurface to mesh
adaptivitysurface adaptivity threshold [0 to 1]
Exceptions
TypeErrorif grid does not have a scalar value type