Loading...
Searching...
No Matches
nanovdb Namespace Reference

## Namespaces

namespace | io

## Classes

class | ValueIndex
| Dummy type for a voxel whose value equals an offset into an external value array. More...
class | ValueMask
| Dummy type for a voxel whose value equals its binary active state. More...
class | Half
| Dummy type for a 16 bit floating point values. More...
class | Fp4
| Dummy type for a 4bit quantization of float point values. More...
class | Fp8
| Dummy type for a 8bit quantization of float point values. More...
class | Fp16
| Dummy type for a 16bit quantization of float point values. More...
class | FpN
| Dummy type for a variable bit quantization of floating point values. More...
struct | is_same
| C++11 implementation of std::is_same. More...
struct | is_same< T, T >
struct | enable_if
| C++11 implementation of std::enable_if. More...
struct | enable_if< true, T >
struct | is_const
struct | is_const< const T >
struct | remove_const
struct | remove_const< const T >
struct | is_floating_point
| C++11 implementation of std::is_floating_point. More...
struct | is_specialization
| Metafunction used to determine if the first template parameter is a specialization of the class template given in the second template parameter. More...
struct | is_specialization< TemplateType< Args... >, TemplateType >
struct | BuildToValueMap
| Maps one type (e.g. the build types above) to other (actual) types. More...
struct | BuildToValueMap< ValueIndex >
struct | BuildToValueMap< ValueMask >
struct | BuildToValueMap< Half >
struct | BuildToValueMap< Fp4 >
struct | BuildToValueMap< Fp8 >
struct | BuildToValueMap< Fp16 >
struct | BuildToValueMap< FpN >
class | Rgba8
| 8-bit red, green, blue, alpha packed into 32 bit unsigned int More...
class | Version
| Bit-compacted representation of all three version numbers. More...
struct | Tolerance
| Tolerance for floating-point comparison. More...
struct | Tolerance< float >
struct | Tolerance< double >
struct | Delta
| Delta for small floating-point offsets. More...
struct | Delta< float >
struct | Delta< double >
struct | Maximum
| Maximum floating-point values. More...
class | Vec3
| A simple vector class with three double components, similar to openvdb::math::Vec3. More...
class | Coord
| Signed (i, j, k) 32-bit integer coordinate class, similar to openvdb::math::Coord. More...
class | Vec4
| A simple vector class with three double components, similar to openvdb::math::Vec4. More...
struct | TensorTraits
struct | TensorTraits< T, 0 >
struct | TensorTraits< T, 1 >
struct | FloatTraits
struct | FloatTraits< T, 8 >
struct | FloatTraits< bool, 1 >
struct | FloatTraits< ValueIndex, 1 >
struct | FloatTraits< ValueMask, 1 >
struct | BaseBBox
struct | BBox
struct | BBox< Vec3T, true >
| Partial template specialization for floating point coordinate types. More...
struct | BBox< CoordT, false >
| Partial template specialization for integer coordinate types. More...
class | Mask
| Bit-mask to encode active states and facilitate sequential iterators and a fast codec for I/O compression. More...
struct | Map
| Defines an affine transform and its inverse represented as a 3x3 matrix and a vec3 translation. More...
struct | GridBlindMetaData
struct | NodeTrait
| Struct to derive node type from its level in a given grid, tree or root while preserving constness. More...
struct | NodeTrait< GridOrTreeOrRootT, 0 >
struct | NodeTrait< const GridOrTreeOrRootT, 0 >
struct | NodeTrait< GridOrTreeOrRootT, 1 >
struct | NodeTrait< const GridOrTreeOrRootT, 1 >
struct | NodeTrait< GridOrTreeOrRootT, 2 >
struct | NodeTrait< const GridOrTreeOrRootT, 2 >
struct | NodeTrait< GridOrTreeOrRootT, 3 >
struct | NodeTrait< const GridOrTreeOrRootT, 3 >
struct | GridData
| Struct with all the member data of the Grid (useful during serialization of an openvdb grid). More...
class | ReadAccessor
class | Grid
| Highest level of the data structure. Contains a tree and a world->index transform (that currently only supports uniform scaling and translation). More...
struct | TreeData
struct | GridTree
| defines a tree type from a grid type while preserving constness More...
struct | GridTree< const GridT >
class | Tree
| VDB Tree, which is a thin wrapper around a RootNode. More...
struct | RootData
| Struct with all the member data of the RootNode (useful during serialization of an openvdb RootNode). More...
class | RootNode
| Top-most node of the VDB tree structure. More...
struct | InternalData
| Struct with all the member data of the InternalNode (useful during serialization of an openvdb InternalNode). More...
class | InternalNode
| Internal nodes of a VDB treedim(),. More...
struct | LeafData
| Stuct with all the member data of the LeafNode (useful during serialization of an openvdb LeafNode). More...
struct | LeafFnBase
| Base-class for quantized float leaf nodes. More...
struct | LeafData< Fp4, CoordT, MaskT, LOG2DIM >
| Stuct with all the member data of the LeafNode (useful during serialization of an openvdb LeafNode). More...
struct | LeafData< Fp8, CoordT, MaskT, LOG2DIM >
struct | LeafData< Fp16, CoordT, MaskT, LOG2DIM >
struct | LeafData< FpN, CoordT, MaskT, LOG2DIM >
struct | LeafData< bool, CoordT, MaskT, LOG2DIM >
struct | LeafData< ValueMask, CoordT, MaskT, LOG2DIM >
struct | LeafData< ValueIndex, CoordT, MaskT, LOG2DIM >
class | LeafNode
| Leaf nodes of the VDB tree. (defaults to 8x8x8 = 512 voxels). More...
struct | NanoNode
| Trait to map from LEVEL to node type. More...
struct | NanoNode< BuildT, 0 >
struct | NanoNode< BuildT, 1 >
struct | NanoNode< BuildT, 2 >
struct | NanoNode< BuildT, 3 >
class | ReadAccessor< BuildT, -1, -1, -1 >
| A read-only value accessor with three levels of node caching. This allows for inverse tree traversal during lookup, which is on average significantly faster than calling the equivalent method on the tree (i.e. top-down traversal). More...
class | ReadAccessor< BuildT, LEVEL0, -1, -1 >
| Node caching at a single tree level. More...
class | ReadAccessor< BuildT, LEVEL0, LEVEL1, -1 >
class | ReadAccessor< BuildT, 0, 1, 2 >
| Node caching at all (three) tree levels. More...
class | GridMetaData
| This is a convenient class that allows for access to grid meta-data that are independent of the value type of a grid. That is, this class can be used to get information about a grid without actually knowing its ValueType. More...
class | PointAccessor
| Class to access points at a specific voxel location. More...
class | ChannelAccessor
| Class to access values in channels at a specific voxel location. More...
class | CudaDeviceBuffer
| Simple memory buffer using un-managed pinned host memory when compiled with NVCC. Obviously this class is making explicit used of CUDA so replace it with your own memory allocator if you are not using CUDA. More...
struct | BufferTraits< CudaDeviceBuffer >
class | DitherLUT
class | AbsDiff
| Compression oracle based on absolute difference. More...
class | RelDiff
| Compression oracle based on relative difference. More...
class | GridBuilder
| Allows for the construction of NanoVDB grids without any dependency. More...
class | CRC32
| Class that computes the Cyclic Redundancy Check (CRC). More...
class | GridChecksum
| Class that encapsulates two CRC32 checksums, one for the Grid, Tree and Root node meta data and one for the remaining grid nodes. More...
class | GridHandleBase
class | GridHandle
| This class serves to manage a raw memory buffer of a NanoVDB Grid. More...
class | Extrema
class | Extrema< ValueT, 0 >
| Template specialization of Extrema on scalar value types, i.e. rank = 0. More...
class | Extrema< VecT, 1 >
| Template specialization of Extrema on vector value types, i.e. rank = 1. More...
class | Stats
class | Stats< ValueT, 0 >
| This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values. More...
class | Stats< ValueT, 1 >
| This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values. More...
struct | NoopStats
| No-op Stats class. More...
class | GridStats
| Allows for the construction of NanoVDB grids without any dependecy. More...
class | GridValidator
| Allows for the construction of NanoVDB grids without any dependecy. More...
class | HDDA
| A Digital Differential Analyzer specialized for OpenVDB grids. More...
class | DDA
| A Digital Differential Analyzer. Unlike HDDA (defined above) this DDA uses a fixed step-size defined by the template parameter Dim! More...
class | TreeMarcher
| A Tree Marcher for Generic Grids. More...
class | PointTreeMarcher
| A Tree Marcher for Point Grids. More...
struct | BufferTraits
class | HostBuffer
| This is a buffer that contains a shared or private pool to either externally or internally managed host memory. More...
class | IndexGridBuilder
| Allows for the construction of NanoVDB grids without any dependency. More...
class | NanoToOpenVDB
| This class will serialize an OpenVDB grid into a NanoVDB grid managed by a GridHandle. More...
class | NodeManager
| NodeManager allows for sequential access to nodes. More...
class | NodeManagerHandle
| NodeManagerHandle manages the memory of a NodeManager. More...
struct | NodeManagerData
struct | OpenToNanoType
| Converts OpenVDB types to NanoVDB types, e.g. openvdb::Vec3f to nanovdb::Vec3f Template specializations are defined below. More...
struct | OpenToNanoType< openvdb::Coord >
| Template specialization for openvdb::Coord. More...
struct | OpenToNanoType< openvdb::CoordBBox >
| Template specialization for openvdb::CoordBBox. More...
struct | OpenToNanoType< openvdb::math::BBox< T > >
| Template specialization for openvdb::math::BBox. More...
struct | OpenToNanoType< openvdb::math::Vec3< T > >
| Template specialization for openvdb::math::Vec3. More...
struct | OpenToNanoType< openvdb::math::Vec4< T > >
| Template specialization for openvdb::math::Vec4. More...
struct | OpenToNanoType< openvdb::ValueMask >
| Template specialization for openvdb::ValueMask. More...
struct | OpenToNanoType< openvdb::PointIndex32 >
struct | OpenToNanoType< openvdb::PointDataIndex32 >
struct | OpenGridType
| Grid trait that defines OpenVDB grids with the exact same configuration as NanoVDB grids. More...
struct | OpenGridType< openvdb::PointIndex32 >
| Template specialization for the PointIndexGrid. More...
struct | OpenGridType< openvdb::PointDataIndex32 >
| Template specialization for the PointDataGrid. More...
class | OpenToNanoVDB
| This class will convert an OpenVDB grid into a NanoVDB grid managed by a GridHandle. More...
class | Split
class | Range
class | Range< 1, T >
class | Range< 2, T >
class | Range< 3, T >
class | Ray
class | SampleFromVoxels
class | SampleFromVoxels< TreeOrAccT, 0, true >
| Nearest neighbor, i.e. zero order, interpolator with caching. More...
class | SampleFromVoxels< TreeOrAccT, 0, false >
| Nearest neighbor, i.e. zero order, interpolator without caching. More...
class | TrilinearSampler
| Tri-linear sampler, i.e. first order, interpolator. More...
class | SampleFromVoxels< TreeOrAccT, 1, false >
| Template specialization that does not use caching of stencil points. More...
class | SampleFromVoxels< TreeOrAccT, 1, true >
| Template specialization with caching of stencil values. More...
class | TriquadraticSampler
| Tri-quadratic sampler, i.e. second order, interpolator. More...
class | SampleFromVoxels< TreeOrAccT, 2, false >
| Template specialization that does not use caching of stencil points. More...
class | SampleFromVoxels< TreeOrAccT, 2, true >
| Template specialization with caching of stencil values. More...
class | TricubicSampler
| Tri-cubic sampler, i.e. third order, interpolator. More...
class | SampleFromVoxels< TreeOrAccT, 3, true >
class | SampleFromVoxels< TreeOrAccT, 3, false >
class | BaseStencil
class | BoxStencil
class | GradStencil
class | WenoStencil
| This is a special 19-point stencil that supports optimal fifth-order WENO upwinding, second-order central differencing, Laplacian, and zero-crossing test. More...
class | CurvatureStencil
class | Camera
| A minimal perspective camera for ray generation. More...
class | DenseGridHandle
struct | DenseData
class | DenseGrid
| Simple dense grid class. More...
struct | ImageData
class | Image
class | ImageHandle
class | CpuTimer

## Typedefs

using | PackedRGBA8 = Rgba8
using | Vec3R = Vec3<double>
using | Vec3d = Vec3<double>
using | Vec3f = Vec3<float>
using | Vec3i = Vec3<int>
using | Vec4R = Vec4<double>
using | Vec4d = Vec4<double>
using | Vec4f = Vec4<float>
using | Vec4i = Vec4<int>
using | CoordBBox = BBox<Coord>
using | BBoxR = BBox<Vec3R>
template<typename BuildT>
using | DefaultReadAccessor = ReadAccessor<BuildT, 0, 1, 2>
template<typename BuildT>
using | NanoLeaf = LeafNode<BuildT, Coord, Mask, 3>
| Template specializations to the default configuration used in OpenVDB: Root -> 32^3 -> 16^3 -> 8^3.
template<typename BuildT>
using | NanoLower = InternalNode<NanoLeaf<BuildT>, 4>
template<typename BuildT>
using | NanoUpper = InternalNode<NanoLower<BuildT>, 5>
template<typename BuildT>
using | NanoRoot = RootNode<NanoUpper<BuildT>>
template<typename BuildT>
using | NanoTree = Tree<NanoRoot<BuildT>>
template<typename BuildT>
using | NanoGrid = Grid<NanoTree<BuildT>>
using | FloatTree = NanoTree<float>
using | DoubleTree = NanoTree<double>
using | Int32Tree = NanoTree<int32_t>
using | UInt32Tree = NanoTree<uint32_t>
using | Int64Tree = NanoTree<int64_t>
using | Vec3fTree = NanoTree<Vec3f>
using | Vec3dTree = NanoTree<Vec3d>
using | Vec4fTree = NanoTree<Vec4f>
using | Vec4dTree = NanoTree<Vec4d>
using | Vec3ITree = NanoTree<Vec3i>
using | MaskTree = NanoTree<ValueMask>
using | IndexTree = NanoTree<ValueIndex>
using | BoolTree = NanoTree<bool>
using | FloatGrid = Grid<FloatTree>
using | DoubleGrid = Grid<DoubleTree>
using | Int32Grid = Grid<Int32Tree>
using | UInt32Grid = Grid<UInt32Tree>
using | Int64Grid = Grid<Int64Tree>
using | Vec3fGrid = Grid<Vec3fTree>
using | Vec3dGrid = Grid<Vec3dTree>
using | Vec4fGrid = Grid<Vec4fTree>
using | Vec4dGrid = Grid<Vec4dTree>
using | Vec3IGrid = Grid<Vec3ITree>
using | MaskGrid = Grid<MaskTree>
using | IndexGrid = Grid<IndexTree>
using | BoolGrid = Grid<BoolTree>
using | Range1D = Range<1, size_t>
using | Range2D = Range<2, size_t>
using | Range3D = Range<3, size_t>

## Enumerations

enum class | GridType : uint32_t { Unknown = 0 , Float = 1 , Double = 2 , Int16 = 3 , Int32 = 4 , Int64 = 5 , Vec3f = 6 , Vec3d = 7 , Mask = 8 , Half = 9 , UInt32 = 10 , Boolean = 11 , RGBA8 = 12 , Fp4 = 13 , Fp8 = 14 , Fp16 = 15 , FpN = 16 , Vec4f = 17 , Vec4d = 18 , Index = 19 , End = 20 }
| List of types that are currently supported by NanoVDB. More...
enum class | GridClass : uint32_t { Unknown = 0 , LevelSet = 1 , FogVolume = 2 , Staggered = 3 , PointIndex = 4 , PointData = 5 , Topology = 6 , VoxelVolume = 7 , IndexGrid = 8 , End = 9 }
| Classes (defined in OpenVDB) that are currently supported by NanoVDB. More...
enum class | GridFlags : uint32_t { HasLongGridName = 1 << 0 , HasBBox = 1 << 1 , HasMinMax = 1 << 2 , HasAverage = 1 << 3 , HasStdDeviation = 1 << 4 , IsBreadthFirst = 1 << 5 , End = 1 << 6 }
| Grid flags which indicate what extra information is present in the grid buffer. More...
enum class | GridBlindDataClass : uint32_t { Unknown = 0 , IndexArray = 1 , AttributeArray = 2 , GridName = 3 , ChannelArray = 4 , End = 5 }
| Blind-data Classes that are currently supported by NanoVDB. More...
enum class | GridBlindDataSemantic : uint32_t { Unknown = 0 , PointPosition = 1 , PointColor = 2 , PointNormal = 3 , PointRadius = 4 , PointVelocity = 5 , PointId = 6 , End = 8 }
| Blind-data Semantics that are currently understood by NanoVDB. More...
enum class | ChecksumMode : uint32_t { Disable = 0 , Partial = 1 , Full = 2 , Default = 1 , End = 3 }
| List of different modes for computing for a checksum. More...
enum class | StatsMode : uint32_t { Disable = 0 , BBox = 1 , MinMax = 2 , All = 3 , Default = 3 , End = 4 }
| Grid flags which indicate what extra information is present in the grid buffer. More...

## Functions

const char * | toStr (GridType gridType)
| Retuns a c-string used to describe a GridType.
const char * | toStr (GridClass gridClass)
| Retuns a c-string used to describe a GridClass.
const char * | toStr (GridFlags gridFlags)
| Retuns a c-string used to describe a GridFlags.
static bool | isAligned (const void *p)
| return true if the specified pointer is aligned
static bool | isValid (const void *p)
| return true if the specified pointer is aligned and not NULL
static uint64_t | alignmentPadding (const void *p)
| return the smallest number of bytes that when added to the specified pointer results in an aligned pointer
template<typename T>
static T * | alignPtr (T *p)
| offset the specified pointer so it is aligned.
template<typename T>
static const T * | alignPtr (const T *p)
| offset the specified pointer so it is aligned.
template<typename T1, typename T2>
static int64_t | PtrDiff (const T1 *p, const T2 *q)
template<typename DstT, typename SrcT>
static DstT * | PtrAdd (SrcT *p, int64_t offset)
template<typename DstT, typename SrcT>
static const DstT * | PtrAdd (const SrcT *p, int64_t offset)
bool | isFloatingPoint (GridType gridType)
| return true if the GridType maps to a floating point value.
bool | isValid (GridType gridType, GridClass gridClass)
| return true if the combination of GridType and GridClass is valid.
template<typename Type>
bool | isApproxZero (const Type &x)
template<typename Type>
Type | Min (Type a, Type b)
int32_t | Min (int32_t a, int32_t b)
uint32_t | Min (uint32_t a, uint32_t b)
float | Min (float a, float b)
double | Min (double a, double b)
template<typename Type>
Type | Max (Type a, Type b)
int32_t | Max (int32_t a, int32_t b)
uint32_t | Max (uint32_t a, uint32_t b)
float | Max (float a, float b)
double | Max (double a, double b)
float | Clamp (float x, float a, float b)
double | Clamp (double x, double a, double b)
float | Fract (float x)
double | Fract (double x)
int32_t | Floor (float x)
int32_t | Floor (double x)
int32_t | Ceil (float x)
int32_t | Ceil (double x)
template<typename T>
T | Pow2 (T x)
template<typename T>
T | Pow3 (T x)
template<typename T>
T | Pow4 (T x)
template<typename T>
T | Abs (T x)
template<>
float | Abs (float x)
template<>
double | Abs (double x)
template<>
int | Abs (int x)
template<typename CoordT, typename RealT, template< typename > class Vec3T>
CoordT | Round (const Vec3T< RealT > &xyz)
template<typename CoordT, template< typename > class Vec3T>
CoordT | Round (const Vec3T< float > &xyz)
template<typename CoordT, template< typename > class Vec3T>
CoordT | Round (const Vec3T< double > &xyz)
template<typename CoordT, typename RealT, template< typename > class Vec3T>
CoordT | RoundDown (const Vec3T< RealT > &xyz)
float | Sqrt (float x)
| Return the square root of a floating-point value.
double | Sqrt (double x)
template<typename T>
T | Sign (const T &x)
| Return the sign of the given value as an integer (either -1, 0 or 1).
template<typename Vec3T>
int | MinIndex (const Vec3T &v)
template<typename Vec3T>
int | MaxIndex (const Vec3T &v)
template<uint64_t wordSize>
uint64_t | AlignUp (uint64_t byteCount)
| round up byteSize to the nearest wordSize, e.g. to align to machine word: AlignUp<sizeof(size_t)(n)
template<typename T1, typename T2>
Vec3< T2 > | operator* (T1 scalar, const Vec3< T2 > &vec)
template<typename T1, typename T2>
Vec3< T2 > | operator/ (T1 scalar, const Vec3< T2 > &vec)
template<typename T1, typename T2>
Vec4< T2 > | operator* (T1 scalar, const Vec4< T2 > &vec)
template<typename T1, typename T2>
Vec4< T2 > | operator/ (T1 scalar, const Vec3< T2 > &vec)
template<typename BuildT>
GridType | mapToGridType ()
| Maps from a templated value type to a GridType enum.
template<typename Vec3T>
Vec3T | matMult (const float *mat, const Vec3T &xyz)
template<typename Vec3T>
Vec3T | matMult (const double *mat, const Vec3T &xyz)
template<typename Vec3T>
Vec3T | matMult (const float *mat, const float *vec, const Vec3T &xyz)
template<typename Vec3T>
Vec3T | matMult (const double *mat, const double *vec, const Vec3T &xyz)
template<typename Vec3T>
Vec3T | matMultT (const float *mat, const Vec3T &xyz)
template<typename Vec3T>
Vec3T | matMultT (const double *mat, const Vec3T &xyz)
template<typename Vec3T>
Vec3T | matMultT (const float *mat, const float *vec, const Vec3T &xyz)
template<typename Vec3T>
Vec3T | matMultT (const double *mat, const double *vec, const Vec3T &xyz)
static uint32_t | FindLowestOn (uint32_t v)
| Returns the index of the lowest, i.e. least significant, on bit in the specified 32 bit word.
static uint32_t | FindHighestOn (uint32_t v)
| Returns the index of the highest, i.e. most significant, on bit in the specified 32 bit word.
static uint32_t | FindLowestOn (uint64_t v)
| Returns the index of the lowest, i.e. least significant, on bit in the specified 64 bit word.
static uint32_t | FindHighestOn (uint64_t v)
| Returns the index of the highest, i.e. most significant, on bit in the specified 64 bit word.
uint32_t | CountOn (uint64_t v)
template<int LEVEL0 = -1, int LEVEL1 = -1, int LEVEL2 = -1, typename ValueT = float>
ReadAccessor< ValueT, LEVEL0, LEVEL1, LEVEL2 > | createAccessor (const NanoGrid< ValueT > &grid)
| Free-standing function for convenient creation of a ReadAccessor with optional and customizable node caching.
template<int LEVEL0 = -1, int LEVEL1 = -1, int LEVEL2 = -1, typename ValueT = float>
ReadAccessor< ValueT, LEVEL0, LEVEL1, LEVEL2 > | createAccessor (const NanoTree< ValueT > &tree)
template<int LEVEL0 = -1, int LEVEL1 = -1, int LEVEL2 = -1, typename ValueT = float>
ReadAccessor< ValueT, LEVEL0, LEVEL1, LEVEL2 > | createAccessor (const NanoRoot< ValueT > &root)
template<typename RangeT, typename FuncT>
void | forEach (RangeT range, const FuncT &func)
| simple wrapper for tbb::parallel_for with a naive std fallback
template<typename FuncT>
void | forEach (size_t begin, size_t end, size_t grainSize, const FuncT &func)
| Simple wrapper for the function defined above.
template<template< typename... > class ContainerT, typename... T, typename FuncT>
void | forEach (const ContainerT< T... > &c, const FuncT &func)
| Simple wrapper for the function defined above, which works with std::containers.
template<template< typename... > class ContainerT, typename... T, typename FuncT>
void | forEach (const ContainerT< T... > &c, size_t grainSize, const FuncT &func)
| Simple wrapper for the function defined above, which works with std::containers.
std::ostream & | operator<< (std::ostream &os, const AbsDiff &diff)
std::ostream & | operator<< (std::ostream &os, const RelDiff &diff)
template<typename ValueT>
uint64_t | checksum (const NanoGrid< ValueT > &grid, ChecksumMode mode=ChecksumMode::Default)
| Return the (2 x CRC32) checksum of the specified grid.
template<typename ValueT>
bool | validateChecksum (const NanoGrid< ValueT > &grid, ChecksumMode mode=ChecksumMode::Default)
| Return true if the checksum of the grid matches the expected value already encoded into the grid's meta data.
template<typename ValueT>
void | updateChecksum (NanoGrid< ValueT > &grid, ChecksumMode mode=ChecksumMode::Default)
| Updates the checksum of a grid.
std::uint_fast32_t | crc32 (const void *data, size_t size)
| Return the CRC32 checksum of the raw data of size.
template<typename IterT>
std::uint_fast32_t | crc32 (IterT begin, IterT end)
| Return the CRC32 checksum of the content pointed to be the iterator.
template<typename BuildT>
void | gridStats (NanoGrid< BuildT > &grid, StatsMode mode=StatsMode::Default)
| Re-computes the min/max, stats and bbox information for an existing NanoVDB Grid.
template<typename BuildT>
Extrema< typename NanoGrid< BuildT >::ValueType > | getExtrema (const NanoGrid< BuildT > &grid, const CoordBBox &bbox)
| return the extrema of all the values in a grid that intersects the specified bounding box.
template<typename ValueT>
bool | isValid (const NanoGrid< ValueT > &grid, bool detailed=true, bool verbose=false)
| Return true if the specified grid passes several validation tests.
template<typename RayT, typename AccT>
__hostdev__ bool | ZeroCrossing (RayT &ray, AccT &acc, Coord &ijk, typename AccT::ValueType &v, float &t)

returns true if the ray intersects a zero-crossing at the voxel level of the grid in the accessor The empty-space ray-marching is performed at all levels of the tree using an HDDA. If an intersection is detected, then ijk is updated with the index coordinate of the closest voxel after the intersection point, v contains the grid values at ijk, and t is set to the time of the intersection along the ray.

template<typename RayT, typename NodeT>
__hostdev__ bool | ZeroCrossingNode (RayT &ray, const NodeT &node, float v0, nanovdb::Coord &ijk, float &v, float &t)
template<typename RayT, typename AccT>
__hostdev__ bool | firstActive (RayT &ray, AccT &acc, Coord &ijk, float &t)
| returns true if the ray intersects an active value at any level of the grid in the accessor. The empty-space ray-marching is performed at all levels of the tree using an HDDA. If an intersection is detected, then ijk is updated with the index coordinate of the first active voxel or tile, and t is set to the time of its intersection along the ray.
template<typename Func, typename... Rest>
int | invoke (const Func &taskFunc1, Rest... taskFuncN)
template<typename NanoBuildT>
openvdb::Grid< typenameopenvdb::tree::Tree4< typenameConvertTrait< NanoBuildT >::Type >::Type >::Ptr | nanoToOpenVDB (const NanoGrid< NanoBuildT > &grid, int verbose=0)
| Forward declaration of free-standing function that de-serializes a typed NanoVDB grid into an OpenVDB Grid.
template<typename BufferT>
openvdb::GridBase::Ptr | nanoToOpenVDB (const GridHandle< BufferT > &handle, int verbose=0)
| Forward declaration of free-standing function that de-serializes a NanoVDB GridHandle into an OpenVDB GridBase.
template<typename BuildT, typename BufferT = HostBuffer>
NodeManagerHandle< BufferT > | createNodeManager (const NanoGrid< BuildT > &grid, const BufferT &buffer=BufferT())
| brief Construct a NodeManager and return its handle
template<typename BufferT = HostBuffer>
GridHandle< BufferT > | openToNanoVDB (const openvdb::GridBase::Ptr &base, StatsMode sMode=StatsMode::Default, ChecksumMode cMode=ChecksumMode::Default, int verbose=0)
| Forward declaration of free-standing function that converts an OpenVDB GridBase into a NanoVDB GridHandle.
template<typename BufferT = HostBuffer, typename OpenTreeT = openvdb::FloatTree, typename NanoBuildT = typename OpenToNanoType<typename OpenTreeT::BuildType>::Type>
GridHandle< BufferT > | openToNanoVDB (const openvdb::Grid< OpenTreeT > &grid, StatsMode sMode=StatsMode::Default, ChecksumMode cMode=ChecksumMode::Default, int verbose=0)
| Forward declaration of free-standing function that converts a typed OpenVDB Grid into a NanoVDB GridHandle.
template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>
GridHandle< BufferT > | createLevelSetSphere (ValueT radius=100, const Vec3< ValueT > &center=Vec3< ValueT >(0), double voxelSize=1.0, double halfWidth=3.0, const Vec3d &origin=Vec3d(0), const std::string &name="sphere_ls", StatsMode sMode=StatsMode::Default, ChecksumMode cMode=ChecksumMode::Default, float tolerance=-1.0f, bool ditherOn=false, const BufferT &buffer=BufferT())
| Returns a handle to a narrow-band level set of a sphere.
template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>
GridHandle< BufferT > | createFogVolumeSphere (ValueT radius=100.0f, const Vec3< ValueT > &center=Vec3< ValueT >(0.0f), double voxelSize=1.0f, double halfWidth=3.0f, const Vec3d &origin=Vec3d(0.0), const std::string &name="sphere_fog", StatsMode sMode=StatsMode::Default, ChecksumMode cMode=ChecksumMode::Default, float tolerance=-1.0f, bool ditherOn=false, const BufferT &buffer=BufferT())
| Returns a handle to a sparse fog volume of a sphere such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the sphere to 1 at the halfWidth and interior of the sphere.
template<typename ValueT = float, typename BufferT = HostBuffer>
GridHandle< BufferT > | createPointSphere (int pointsPerVoxel=1, ValueT radius=100.0f, const Vec3< ValueT > &center=Vec3< ValueT >(0.0f), double voxelSize=1.0f, const Vec3d &origin=Vec3d(0.0), const std::string &name="sphere_points", ChecksumMode mode=ChecksumMode::Default, const BufferT &buffer=BufferT())
| Returns a handle to a PointDataGrid containing points scattered on the surface of a sphere.
template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT >

createLevelSetTorus (ValueT majorRadius=100.0f, ValueT minorRadius=50.0f, const Vec3< ValueT > &center=Vec3< ValueT >(0.0f), double voxelSize=1.0, double halfWidth=3.0, const Vec3d &origin=Vec3d(0.0), const std::string &name="torus_ls", StatsMode sMode=StatsMode::Default, ChecksumMode cMode=ChecksumMode::Default, float tolerance=-1.0f, bool ditherOn=false, const BufferT &buffer=BufferT())

| Returns a handle to a narrow-band level set of a torus in the xz-plane.
template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT >

createFogVolumeTorus (ValueT majorRadius=100.0f, ValueT minorRadius=50.0f, const Vec3< ValueT > &center=Vec3< ValueT >(0.0f), double voxelSize=1.0, double halfWidth=3.0, const Vec3d &origin=Vec3d(0), const std::string &name="torus_fog", StatsMode sMode=StatsMode::Default, ChecksumMode cMode=ChecksumMode::Default, float tolerance=-1.0f, bool ditherOn=false, const BufferT &buffer=BufferT())

| Returns a handle to a sparse fog volume of a torus in the xz-plane such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the torus to 1 at the halfWidth and interior of the torus.
template<typename ValueT = float, typename BufferT = HostBuffer>
GridHandle< BufferT > | createPointTorus (int pointsPerVoxel=1, ValueT majorRadius=100.0f, ValueT minorRadius=50.0f, const Vec3< ValueT > &center=Vec3< ValueT >(0.0f), double voxelSize=1.0, const Vec3d &origin=Vec3d(0.0f), const std::string &name="torus_points", ChecksumMode cMode=ChecksumMode::Default, const BufferT &buffer=BufferT())
| Returns a handle to a PointDataGrid containing points scattered on the surface of a torus.
template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT >

createLevelSetBox (ValueT width=40.0f, ValueT height=60.0f, ValueT depth=100.0f, const Vec3< ValueT > &center=Vec3< ValueT >(0.0f), double voxelSize=1.0, double halfWidth=3.0, const Vec3d &origin=Vec3d(0.0), const std::string &name="box_ls", StatsMode sMode=StatsMode::Default, ChecksumMode cMode=ChecksumMode::Default, float tolerance=-1.0f, bool ditherOn=false, const BufferT &buffer=BufferT())

| Returns a handle to a narrow-band level set of a box.
template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT >

createFogVolumeBox (ValueT width=40.0f, ValueT height=60.0f, ValueT depth=100.0f, const Vec3< ValueT > &center=Vec3< ValueT >(0.0f), double voxelSize=1.0, double halfWidth=3.0, const Vec3d &origin=Vec3d(0.0), const std::string &name="box_fog", StatsMode sMode=StatsMode::Default, ChecksumMode cMode=ChecksumMode::Default, float tolerance=-1.0f, bool ditherOn=false, const BufferT &buffer=BufferT())

| Returns a handle to a sparse fog volume of a box such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the box to 1 at the halfWidth and interior of the box.
template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>
GridHandle< BufferT > | createLevelSetOctahedron (ValueT scale=100.0f, const Vec3< ValueT > &center=Vec3< ValueT >(0.0f), double voxelSize=1.0, double halfWidth=3.0, const Vec3d &origin=Vec3d(0.0), const std::string &name="octadedron_ls", StatsMode sMode=StatsMode::Default, ChecksumMode cMode=ChecksumMode::Default, float tolerance=-1.0f, bool ditherOn=false, const BufferT &buffer=BufferT())
| Returns a handle to a narrow-band level set of a octahedron.
template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>
GridHandle< BufferT > | createFogVolumeOctahedron (ValueT scale=100.0f, const Vec3< ValueT > &center=Vec3< ValueT >(0.0f), double voxelSize=1.0, double halfWidth=3.0, const Vec3d &origin=Vec3d(0.0), const std::string &name="octadedron_fog", StatsMode sMode=StatsMode::Default, ChecksumMode cMode=ChecksumMode::Default, float tolerance=-1.0f, bool ditherOn=false, const BufferT &buffer=BufferT())
| Returns a handle to a sparse fog volume of an octahedron such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the octahedron to 1 at the halfWidth and interior of the octahedron.
template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT >

createLevelSetBBox (ValueT width=40.0f, ValueT height=60.0f, ValueT depth=100.0f, ValueT thickness=10.0f, const Vec3< ValueT > &center=Vec3< ValueT >(0.0f), double voxelSize=1.0, double halfWidth=3.0, const Vec3d &origin=Vec3d(0.0), const std::string &name="bbox_ls", StatsMode sMode=StatsMode::Default, ChecksumMode cMode=ChecksumMode::Default, float tolerance=-1.0f, bool ditherOn=false, const BufferT &buffer=BufferT())

| Returns a handle to a narrow-band level set of a bounding-box (= wireframe of a box).
template<typename ValueT = float, typename BufferT = HostBuffer>
GridHandle< BufferT > | createPointBox (int pointsPerVoxel=1, ValueT width=40.0f, ValueT height=60.0f, ValueT depth=100.0f, const Vec3< ValueT > &center=Vec3< ValueT >(0.0f), double voxelSize=1.0, const Vec3d &origin=Vec3d(0.0), const std::string &name="box_points", ChecksumMode mode=ChecksumMode::Default, const BufferT &buffer=BufferT())
| Returns a handle to a PointDataGrid containing points scattered on the surface of a box.
template<typename ValueT = float, typename BufferT = HostBuffer>
GridHandle< BufferT > | createPointScatter (const NanoGrid< ValueT > &srcGrid, int pointsPerVoxel=1, const std::string &name="point_scatter", ChecksumMode mode=ChecksumMode::Default, const BufferT &buffer=BufferT())
| Given an input NanoVDB voxel grid this methods returns a GridHandle to another NanoVDB PointDataGrid with points scattered in the active leaf voxels of in input grid.
template<typename RangeT, typename T, typename FuncT, typename JoinT>
T | reduce (RangeT range, const T &identity, const FuncT &func, const JoinT &join)
template<typename T, typename FuncT, typename JoinT>
T | reduce (size_t begin, size_t end, size_t grainSize, const T &identity, const FuncT &func, const JoinT &join)
| Simple wrapper to the function defined above.
template<template< typename... > class ContainerT, typename... ArgT, typename T, typename FuncT, typename JoinT>
T | reduce (const ContainerT< ArgT... > &c, const T &identity, const FuncT &func, const JoinT &join)
| Simple wrapper that works with std::containers.
template<template< typename... > class ContainerT, typename... ArgT, typename T, typename FuncT, typename JoinT>
T | reduce (const ContainerT< ArgT... > &c, size_t grainSize, const T &identity, const FuncT &func, const JoinT &join)
| Simple wrapper that works with std::containers.
template<int Order, typename TreeOrAccT, bool UseCache = true>
SampleFromVoxels< TreeOrAccT, Order, UseCache > | createSampler (const TreeOrAccT &acc)
| Factory free-function for a sampler of specific polynomial orders.
template<typename CoordT, typename RealT, template< typename > class Vec3T>
CoordT | Floor (Vec3T< RealT > &xyz)
| Utility function that returns the Coord of the round-down of xyz and redefined (x,&nbsp y,&nbsp z) as the fractional part, ie xyz-in = return-value + xyz-out.
template<typename CoordT, template< typename > class Vec3T>
CoordT | Floor (Vec3T< float > &xyz)
| Template specialization of Floor for Vec3<float>.
template<typename CoordT, template< typename > class Vec3T>
CoordT | Floor (Vec3T< double > &xyz)
| Template specialization of Floor for Vec3<float>.
template<typename ValueType, typename RealT = ValueType>
ValueType | WENO5 (const ValueType &v1, const ValueType &v2, const ValueType &v3, const ValueType &v4, const ValueType &v5, RealT scale2=1.0)
| Implementation of nominally fifth-order finite-difference WENO.
template<typename RealT>
RealT | GodunovsNormSqrd (bool isOutside, RealT dP_xm, RealT dP_xp, RealT dP_ym, RealT dP_yp, RealT dP_zm, RealT dP_zp)
template<typename RealT>
RealT | GodunovsNormSqrd (bool isOutside, const Vec3< RealT > &gradient_m, const Vec3< RealT > &gradient_p)
template<typename GridT, typename BufferT = HostBuffer>
DenseGridHandle< BufferT > | convertToDense (const GridT &grid, const BufferT &allocator=BufferT())
| Converts a NanoVDB grid to a DenseGrid.

## Typedef Documentation

## BBoxR

using BBoxR = BBox<Vec3R>

## BoolGrid

using BoolGrid = Grid<BoolTree>

## BoolTree

using BoolTree = NanoTree<bool>

## CoordBBox

using CoordBBox = BBox<Coord>

## DefaultReadAccessor

template<typename BuildT>

using DefaultReadAccessor = ReadAccessor<BuildT, 0, 1, 2>

## DoubleGrid

using DoubleGrid = Grid<DoubleTree>

## DoubleTree

using DoubleTree = NanoTree<double>

## FloatGrid

using FloatGrid = Grid<FloatTree>

## FloatTree

using FloatTree = NanoTree<float>

## IndexGrid

using IndexGrid = Grid<IndexTree>

## IndexTree

using IndexTree = NanoTree<ValueIndex>

## Int32Grid

using Int32Grid = Grid<Int32Tree>

## Int32Tree

using Int32Tree = NanoTree<int32_t>

## Int64Grid

using Int64Grid = Grid<Int64Tree>

## Int64Tree

using Int64Tree = NanoTree<int64_t>

## MaskGrid

using MaskGrid = Grid<MaskTree>

## MaskTree

using MaskTree = NanoTree<ValueMask>

## NanoGrid

template<typename BuildT>

using NanoGrid = Grid<NanoTree<BuildT>>

## NanoLeaf

template<typename BuildT>

using NanoLeaf = LeafNode<BuildT, Coord, Mask, 3>

Template specializations to the default configuration used in OpenVDB: Root -> 32^3 -> 16^3 -> 8^3.

## NanoLower

template<typename BuildT>

using NanoLower = InternalNode<NanoLeaf<BuildT>, 4>

## NanoRoot

template<typename BuildT>

using NanoRoot = RootNode<NanoUpper<BuildT>>

## NanoTree

template<typename BuildT>

using NanoTree = Tree<NanoRoot<BuildT>>

## NanoUpper

template<typename BuildT>

using NanoUpper = InternalNode<NanoLower<BuildT>, 5>

## PackedRGBA8

using PackedRGBA8 = Rgba8

## Range1D

using Range1D = Range<1, size_t>

## Range2D

using Range2D = Range<2, size_t>

## Range3D

using Range3D = Range<3, size_t>

## UInt32Grid

using UInt32Grid = Grid<UInt32Tree>

## UInt32Tree

using UInt32Tree = NanoTree<uint32_t>

## Vec3d

using Vec3d = Vec3<double>

## Vec3dGrid

using Vec3dGrid = Grid<Vec3dTree>

## Vec3dTree

using Vec3dTree = NanoTree<Vec3d>

## Vec3f

using Vec3f = Vec3<float>

## Vec3fGrid

using Vec3fGrid = Grid<Vec3fTree>

## Vec3fTree

using Vec3fTree = NanoTree<Vec3f>

## Vec3i

using Vec3i = Vec3<int>

## Vec3IGrid

using Vec3IGrid = Grid<Vec3ITree>

## Vec3ITree

using Vec3ITree = NanoTree<Vec3i>

## Vec3R

using Vec3R = Vec3<double>

## Vec4d

using Vec4d = Vec4<double>

## Vec4dGrid

using Vec4dGrid = Grid<Vec4dTree>

## Vec4dTree

using Vec4dTree = NanoTree<Vec4d>

## Vec4f

using Vec4f = Vec4<float>

## Vec4fGrid

using Vec4fGrid = Grid<Vec4fTree>

## Vec4fTree

using Vec4fTree = NanoTree<Vec4f>

## Vec4i

using Vec4i = Vec4<int>

## Vec4R

using Vec4R = Vec4<double>

## Enumeration Type Documentation

## ChecksumMode

enum class ChecksumMode : uint32_t

strong

List of different modes for computing for a checksum.

Enumerator
Disable |
Partial |
Full |
Default |
End |

## GridBlindDataClass

enum class GridBlindDataClass : uint32_t

strong

Blind-data Classes that are currently supported by NanoVDB.

Enumerator
Unknown |
IndexArray |
AttributeArray |
GridName |
ChannelArray |
End |

## GridBlindDataSemantic

enum class GridBlindDataSemantic : uint32_t

strong

Blind-data Semantics that are currently understood by NanoVDB.

Enumerator
Unknown |
PointPosition |
PointColor |
PointNormal |
PointRadius |
PointVelocity |
PointId |
End |

## GridClass

enum class GridClass : uint32_t

strong

Classes (defined in OpenVDB) that are currently supported by NanoVDB.

Enumerator
Unknown |
LevelSet |
FogVolume |
Staggered |
PointIndex |
PointData |
Topology |
VoxelVolume |
IndexGrid |
End |

## GridFlags

enum class GridFlags : uint32_t

strong

Grid flags which indicate what extra information is present in the grid buffer.

Enumerator
HasLongGridName |
HasBBox |
HasMinMax |
HasAverage |
HasStdDeviation |
IsBreadthFirst |
End |

## GridType

enum class GridType : uint32_t

strong

List of types that are currently supported by NanoVDB.

Note
  To expand on this list do: 1) Add the new type between Unknown and End in the enum below 2) Add the new type to OpenToNanoVDB::processGrid that maps OpenVDB types to GridType 3) Verify that the ConvertTrait in NanoToOpenVDB.h works correctly with the new type 4) Add the new type to mapToGridType (defined below) that maps NanoVDB types to GridType 5) Add the new type to toStr (defined below)

Enumerator
Unknown |
Float |
Double |
Int16 |
Int32 |
Int64 |
Vec3f |
Vec3d |
Mask |
Half |
UInt32 |
Boolean |
RGBA8 |
Fp4 |
Fp8 |
Fp16 |
FpN |
Vec4f |
Vec4d |
Index |
End |

## StatsMode

enum class StatsMode : uint32_t

strong

Grid flags which indicate what extra information is present in the grid buffer.

Enumerator
Disable |
BBox |
MinMax |
All |
Default |
End |

## Function Documentation

## Abs() [1/4]

template<>

double Abs | ( | double | x | ) |

inline

## Abs() [2/4]

template<>

float Abs | ( | float | x | ) |

inline

## Abs() [3/4]

template<>

int Abs | ( | int | x | ) |

inline

## Abs() [4/4]

template<typename T>

T Abs | ( | T | x | ) |

inline

## alignmentPadding()

uint64_t alignmentPadding | ( | const void * | p | ) |

inline static

return the smallest number of bytes that when added to the specified pointer results in an aligned pointer

## alignPtr() [1/2]

template<typename T>

const T * alignPtr | ( | const T * | p | ) |

inline static

offset the specified pointer so it is aligned.

## alignPtr() [2/2]

template<typename T>

T * alignPtr | ( | T * | p | ) |

inline static

offset the specified pointer so it is aligned.

## AlignUp()

template<uint64_t wordSize>

uint64_t AlignUp | ( | uint64_t | byteCount | ) |

inline

round up byteSize to the nearest wordSize, e.g. to align to machine word: AlignUp<sizeof(size_t)(n)

both wordSize and byteSize are in byte units

## Ceil() [1/2]

int32_t Ceil | ( | double | x | ) |

inline

## Ceil() [2/2]

int32_t Ceil | ( | float | x | ) |

inline

## checksum()

template<typename ValueT>

uint64_t checksum | ( | const NanoGrid< ValueT > & | grid,
|  | ChecksumMode | mode = ChecksumMode::Default )

Return the (2 x CRC32) checksum of the specified grid.

Parameters

  grid | Grid from which the checksum is computed.
  mode | Defines the mode of computation for the checksum.

## Clamp() [1/2]

double Clamp | ( | double | x,
|  | double | a,
|  | double | b )

inline

## Clamp() [2/2]

float Clamp | ( | float | x,
|  | float | a,
|  | float | b )

inline

## convertToDense()

template<typename GridT, typename BufferT = HostBuffer>

DenseGridHandle< BufferT > convertToDense | ( | const GridT & | grid,
|  | const BufferT & | allocator = BufferT() )

Converts a NanoVDB grid to a DenseGrid.

## CountOn()

uint32_t CountOn | ( | uint64_t | v | ) |

inline

Returns
  Number of bits that are on in the specified 64-bit word

## crc32() [1/2]

std::uint_fast32_t crc32 | ( | const void * | data,
|  | size_t | size )

inline

Return the CRC32 checksum of the raw data of size.

Parameters

  data | The beginning of the raw data.
  size | Size of the data to bytes!

## crc32() [2/2]

template<typename IterT>

std::uint_fast32_t crc32 | ( | IterT | begin,
|  | IterT | end )

inline

Return the CRC32 checksum of the content pointed to be the iterator.

Parameters

  begin | Beginning of the iterator range
  end | End of the iterator range (exclusive)

Warning
  The dereference of the iterator must be convertible to a uint8_t

## createAccessor() [1/3]

template<int LEVEL0 = -1, int LEVEL1 = -1, int LEVEL2 = -1, typename ValueT = float>

ReadAccessor< ValueT, LEVEL0, LEVEL1, LEVEL2 > createAccessor | ( | const NanoGrid< ValueT > & | grid | ) |

Free-standing function for convenient creation of a ReadAccessor with optional and customizable node caching.

createAccessor<>(grid): No caching of nodes and hence it's thread-safe but slow createAccessor<0>(grid): Caching of leaf nodes only createAccessor<1>(grid): Caching of lower internal nodes only createAccessor<2>(grid): Caching of upper internal nodes only createAccessor<0,1>(grid): Caching of leaf and lower internal nodes createAccessor<0,2>(grid): Caching of leaf and upper internal nodes createAccessor<1,2>(grid): Caching of lower and upper internal nodes createAccessor<0,1,2>(grid): Caching of all nodes at all tree levels

## createAccessor() [2/3]

template<int LEVEL0 = -1, int LEVEL1 = -1, int LEVEL2 = -1, typename ValueT = float>

ReadAccessor< ValueT, LEVEL0, LEVEL1, LEVEL2 > createAccessor | ( | const NanoRoot< ValueT > & | root | ) |

## createAccessor() [3/3]

template<int LEVEL0 = -1, int LEVEL1 = -1, int LEVEL2 = -1, typename ValueT = float>

ReadAccessor< ValueT, LEVEL0, LEVEL1, LEVEL2 > createAccessor | ( | const NanoTree< ValueT > & | tree | ) |

## createFogVolumeBox()

template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT > createFogVolumeBox | ( | ValueT | width = 40.0f,
|  | ValueT | height = 60.0f,
|  | ValueT | depth = 100.0f,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0.0f),
|  | double | voxelSize = 1.0,
|  | double | halfWidth = 3.0,
|  | const Vec3d & | origin = Vec3d(0.0),
|  | const std::string & | name = "box_fog",
|  | StatsMode | sMode = StatsMode::Default,
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | float | tolerance = -1.0f,
|  | bool | ditherOn = false,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a sparse fog volume of a box such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the box to 1 at the halfWidth and interior of the box.

Parameters

  width | Width of box in world units
  height | Height of box in world units
  depth | Depth of box in world units
  center | Center of box in world units
  voxelSize | Size of a voxel in world units
  halfWidth | Half-width of narrow band in voxel units
  origin | Origin of grid in world units
  name | Name of the grid
  sMode | Mode of computation for the statistics.
  cMode | Mode of computation for the checksum.
  tolerance | Global error tolerance use when VoxelT = FpN
  ditherOn | If true dithering will be applied when VoxelT = {Fp4,Fp8,Fp16,FpN}
  buffer | Buffer used for memory allocation by the handle

The `ValueT` template parameter must be float (default) or double. The `VoxelT` template parameter must be one of the following: float (default), double, Fp4, Fp8, Fp16 or FpN. The `tolerance` argument is only used when VoxelT is set to FpN.

## createFogVolumeOctahedron()

template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT > createFogVolumeOctahedron | ( | ValueT | scale = 100.0f,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0.0f),
|  | double | voxelSize = 1.0,
|  | double | halfWidth = 3.0,
|  | const Vec3d & | origin = Vec3d(0.0),
|  | const std::string & | name = "octadedron_fog",
|  | StatsMode | sMode = StatsMode::Default,
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | float | tolerance = -1.0f,
|  | bool | ditherOn = false,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a sparse fog volume of an octahedron such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the octahedron to 1 at the halfWidth and interior of the octahedron.

Parameters

  scale | Scale of octahedron in world units
  center | Center of box in world units
  voxelSize | Size of a voxel in world units
  halfWidth | Half-width of narrow band in voxel units
  origin | Origin of grid in world units
  name | Name of the grid
  sMode | Mode of computation for the statistics.
  cMode | Mode of computation for the checksum.
  tolerance | Global error tolerance use when VoxelT = FpN
  ditherOn | If true dithering will be applied when VoxelT = {Fp4,Fp8,Fp16,FpN}
  buffer | Buffer used for memory allocation by the handle

The `ValueT` template parameter must be float (default) or double. The `VoxelT` template parameter must be one of the following: float (default), double, Fp4, Fp8, Fp16 or FpN. The `tolerance` argument is only used when VoxelT is set to FpN.

## createFogVolumeSphere()

template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT > createFogVolumeSphere | ( | ValueT | radius = 100.0f,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0.0f),
|  | double | voxelSize = 1.0f,
|  | double | halfWidth = 3.0f,
|  | const Vec3d & | origin = Vec3d(0.0),
|  | const std::string & | name = "sphere_fog",
|  | StatsMode | sMode = StatsMode::Default,
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | float | tolerance = -1.0f,
|  | bool | ditherOn = false,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a sparse fog volume of a sphere such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the sphere to 1 at the halfWidth and interior of the sphere.

Parameters

  radius | Radius of sphere in world units
  center | Center of sphere in world units
  voxelSize | Size of a voxel in world units
  halfWidth | Half-width of narrow band in voxel units
  origin | Origin of grid in world units
  name | Name of the grid
  sMode | Mode of computation for the statistics.
  cMode | Mode of computation for the checksum.
  tolerance | Global error tolerance use when VoxelT = FpN
  ditherOn | If true dithering will be applied when VoxelT = {Fp4,Fp8,Fp16,FpN}
  buffer | Buffer used for memory allocation by the handle

The `ValueT` template parameter must be float (default) or double. The `VoxelT` template parameter must be one of the following: float (default), double, Fp4, Fp8, Fp16 or FpN. The `tolerance` argument is only used when VoxelT is set to FpN.

## createFogVolumeTorus()

template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT > createFogVolumeTorus | ( | ValueT | majorRadius = 100.0f,
|  | ValueT | minorRadius = 50.0f,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0.0f),
|  | double | voxelSize = 1.0,
|  | double | halfWidth = 3.0,
|  | const Vec3d & | origin = Vec3d(0),
|  | const std::string & | name = "torus_fog",
|  | StatsMode | sMode = StatsMode::Default,
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | float | tolerance = -1.0f,
|  | bool | ditherOn = false,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a sparse fog volume of a torus in the xz-plane such that the exterior is 0 and inactive, the interior is active with values varying smoothly from 0 at the surface of the torus to 1 at the halfWidth and interior of the torus.

Parameters

  majorRadius | Major radius of torus in world units
  minorRadius | Minor radius of torus in world units
  center | Center of torus in world units
  voxelSize | Size of a voxel in world units
  halfWidth | Half-width of narrow band in voxel units
  origin | Origin of grid in world units
  name | Name of the grid
  sMode | Mode of computation for the statistics.
  cMode | Mode of computation for the checksum.
  tolerance | Global error tolerance use when VoxelT = FpN
  ditherOn | If true dithering will be applied when VoxelT = {Fp4,Fp8,Fp16,FpN}
  buffer | Buffer used for memory allocation by the handle

The `ValueT` template parameter must be float (default) or double. The `VoxelT` template parameter must be one of the following: float (default), double, Fp4, Fp8, Fp16 or FpN. The `tolerance` argument is only used when VoxelT is set to FpN.

## createLevelSetBBox()

template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT > createLevelSetBBox | ( | ValueT | width = 40.0f,
|  | ValueT | height = 60.0f,
|  | ValueT | depth = 100.0f,
|  | ValueT | thickness = 10.0f,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0.0f),
|  | double | voxelSize = 1.0,
|  | double | halfWidth = 3.0,
|  | const Vec3d & | origin = Vec3d(0.0),
|  | const std::string & | name = "bbox_ls",
|  | StatsMode | sMode = StatsMode::Default,
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | float | tolerance = -1.0f,
|  | bool | ditherOn = false,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a narrow-band level set of a bounding-box (= wireframe of a box).

Parameters

  width | Width of box in world units
  height | Height of box in world units
  depth | Depth of box in world units
  thickness | Thickness of the wire in world units
  center | Center of bbox in world units
  voxelSize | Size of a voxel in world units
  halfWidth | Half-width of narrow band in voxel units
  origin | Origin of grid in world units
  name | Name of the grid
  sMode | Mode of computation for the statistics.
  cMode | Mode of computation for the checksum.
  tolerance | Global error tolerance use when VoxelT = FpN
  ditherOn | If true dithering will be applied when VoxelT = {Fp4,Fp8,Fp16,FpN}
  buffer | Buffer used for memory allocation by the handle

The `ValueT` template parameter must be float (default) or double. The `VoxelT` template parameter must be one of the following: float (default), double, Fp4, Fp8, Fp16 or FpN. The `tolerance` argument is only used when VoxelT is set to FpN.

## createLevelSetBox()

template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT > createLevelSetBox | ( | ValueT | width = 40.0f,
|  | ValueT | height = 60.0f,
|  | ValueT | depth = 100.0f,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0.0f),
|  | double | voxelSize = 1.0,
|  | double | halfWidth = 3.0,
|  | const Vec3d & | origin = Vec3d(0.0),
|  | const std::string & | name = "box_ls",
|  | StatsMode | sMode = StatsMode::Default,
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | float | tolerance = -1.0f,
|  | bool | ditherOn = false,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a narrow-band level set of a box.

Parameters

  width | Width of box in world units
  height | Height of box in world units
  depth | Depth of box in world units
  center | Center of box in world units
  voxelSize | Size of a voxel in world units
  halfWidth | Half-width of narrow band in voxel units
  origin | Origin of grid in world units
  name | Name of the grid
  sMode | Mode of computation for the statistics.
  cMode | Mode of computation for the checksum.
  tolerance | Global error tolerance use when VoxelT = FpN
  ditherOn | If true dithering will be applied when VoxelT = {Fp4,Fp8,Fp16,FpN}
  buffer | Buffer used for memory allocation by the handle

The `ValueT` template parameter must be float (default) or double. The `VoxelT` template parameter must be one of the following: float (default), double, Fp4, Fp8, Fp16 or FpN. The `tolerance` argument is only used when VoxelT is set to FpN.

## createLevelSetOctahedron()

template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT > createLevelSetOctahedron | ( | ValueT | scale = 100.0f,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0.0f),
|  | double | voxelSize = 1.0,
|  | double | halfWidth = 3.0,
|  | const Vec3d & | origin = Vec3d(0.0),
|  | const std::string & | name = "octadedron_ls",
|  | StatsMode | sMode = StatsMode::Default,
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | float | tolerance = -1.0f,
|  | bool | ditherOn = false,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a narrow-band level set of a octahedron.

Parameters

  scale | Scale of octahedron in world units
  center | Center of octahedron in world units
  voxelSize | Size of a voxel in world units
  halfWidth | Half-width of narrow band in voxel units
  origin | Origin of grid in world units
  name | Name of the grid
  sMode | Mode of computation for the statistics.
  cMode | Mode of computation for the checksum.
  tolerance | Global error tolerance use when VoxelT = FpN
  ditherOn | If true dithering will be applied when VoxelT = {Fp4,Fp8,Fp16,FpN}
  buffer | Buffer used for memory allocation by the handle

The `ValueT` template parameter must be float (default) or double. The `VoxelT` template parameter must be one of the following: float (default), double, Fp4, Fp8, Fp16 or FpN. The `tolerance` argument is only used when VoxelT is set to FpN.

## createLevelSetSphere()

template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT > createLevelSetSphere | ( | ValueT | radius = 100,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0),
|  | double | voxelSize = 1.0,
|  | double | halfWidth = 3.0,
|  | const Vec3d & | origin = Vec3d(0),
|  | const std::string & | name = "sphere_ls",
|  | StatsMode | sMode = StatsMode::Default,
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | float | tolerance = -1.0f,
|  | bool | ditherOn = false,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a narrow-band level set of a sphere.

Parameters

  radius | Radius of sphere in world units
  center | Center of sphere in world units
  voxelSize | Size of a voxel in world units
  halfWidth | Half-width of narrow band in voxel units
  origin | Origin of grid in world units
  name | Name of the grid
  sMode | Mode of computation for the statistics.
  cMode | Mode of computation for the checksum.
  tolerance | Global error tolerance use when VoxelT = FpN
  ditherOn | If true dithering will be applied when VoxelT = {Fp4,Fp8,Fp16,FpN}
  buffer | Buffer used for memory allocation by the handle

The `ValueT` template parameter must be float (default) or double. The `VoxelT` template parameter must be one of the following: float (default), double, Fp4, Fp8, Fp16 or FpN. The `tolerance` argument is only used when VoxelT is set to FpN.

## createLevelSetTorus()

template<typename ValueT = float, typename VoxelT = ValueT, typename BufferT = HostBuffer>

GridHandle< BufferT > createLevelSetTorus | ( | ValueT | majorRadius = 100.0f,
|  | ValueT | minorRadius = 50.0f,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0.0f),
|  | double | voxelSize = 1.0,
|  | double | halfWidth = 3.0,
|  | const Vec3d & | origin = Vec3d(0.0),
|  | const std::string & | name = "torus_ls",
|  | StatsMode | sMode = StatsMode::Default,
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | float | tolerance = -1.0f,
|  | bool | ditherOn = false,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a narrow-band level set of a torus in the xz-plane.

Parameters

  majorRadius | Major radius of torus in world units
  minorRadius | Minor radius of torus in world units
  center | Center of torus in world units
  voxelSize | Size of a voxel in world units
  halfWidth | Half-width of narrow band in voxel units
  origin | Origin of grid in world units
  name | Name of the grid
  sMode | Mode of computation for the statistics.
  cMode | Mode of computation for the checksum.
  tolerance | Global error tolerance use when VoxelT = FpN
  ditherOn | If true dithering will be applied when VoxelT = {Fp4,Fp8,Fp16,FpN}
  buffer | Buffer used for memory allocation by the handle

The `ValueT` template parameter must be float (default) or double. The `VoxelT` template parameter must be one of the following: float (default), double, Fp4, Fp8, Fp16 or FpN. The `tolerance` argument is only used when VoxelT is set to FpN.

## createNodeManager()

template<typename BuildT, typename BufferT = HostBuffer>

NodeManagerHandle< BufferT > createNodeManager | ( | const NanoGrid< BuildT > & | grid,
|  | const BufferT & | buffer = BufferT() )

brief Construct a NodeManager and return its handle

Parameters

  grid | grid whose nodes will be accessed sequentially
  buffer | buffer from which to allocate the output handle

Note
  This is the only way to create a NodeManager since it's using managed memory pointed to by a NodeManagerHandle.

## createPointBox()

template<typename ValueT = float, typename BufferT = HostBuffer>

GridHandle< BufferT > createPointBox | ( | int | pointsPerVoxel = 1,
|  | ValueT | width = 40.0f,
|  | ValueT | height = 60.0f,
|  | ValueT | depth = 100.0f,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0.0f),
|  | double | voxelSize = 1.0,
|  | const Vec3d & | origin = Vec3d(0.0),
|  | const std::string & | name = "box_points",
|  | ChecksumMode | mode = ChecksumMode::Default,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a PointDataGrid containing points scattered on the surface of a box.

Parameters

  pointsPerVoxel | Number of point per voxel on on the surface
  width | Width of box in world units
  height | Height of box in world units
  depth | Depth of box in world units
  center | Center of box in world units
  voxelSize | Size of a voxel in world units
  origin | Origin of grid in world units
  name | Name of the grid
  mode | Mode of computation for the checksum.
  buffer | Buffer used for memory allocation by the handle

## createPointScatter()

template<typename ValueT = float, typename BufferT = HostBuffer>

GridHandle< BufferT > createPointScatter | ( | const NanoGrid< ValueT > & | srcGrid,
|  | int | pointsPerVoxel = 1,
|  | const std::string & | name = "point_scatter",
|  | ChecksumMode | mode = ChecksumMode::Default,
|  | const BufferT & | buffer = BufferT() )

inline

Given an input NanoVDB voxel grid this methods returns a GridHandle to another NanoVDB PointDataGrid with points scattered in the active leaf voxels of in input grid.

Parameters

  srcGrid | Const input grid used to determine the active voxels to scatter points into
  pointsPerVoxel | Number of point per voxel on on the surface
  name | Name of the grid
  mode | Mode of computation for the checksum.
  buffer | Buffer used for memory allocation by the handle

## createPointSphere()

template<typename ValueT = float, typename BufferT = HostBuffer>

GridHandle< BufferT > createPointSphere | ( | int | pointsPerVoxel = 1,
|  | ValueT | radius = 100.0f,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0.0f),
|  | double | voxelSize = 1.0f,
|  | const Vec3d & | origin = Vec3d(0.0),
|  | const std::string & | name = "sphere_points",
|  | ChecksumMode | mode = ChecksumMode::Default,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a PointDataGrid containing points scattered on the surface of a sphere.

Parameters

  pointsPerVoxel | Number of point per voxel on on the surface
  radius | Radius of sphere in world units
  center | Center of sphere in world units
  voxelSize | Size of a voxel in world units
  origin | Origin of grid in world units
  name | Name of the grid
  mode | Mode of computation for the checksum.
  buffer | Buffer used for memory allocation by the handle

The `ValueT` template parameter must be float (default) or double.

## createPointTorus()

template<typename ValueT = float, typename BufferT = HostBuffer>

GridHandle< BufferT > createPointTorus | ( | int | pointsPerVoxel = 1,
|  | ValueT | majorRadius = 100.0f,
|  | ValueT | minorRadius = 50.0f,
|  | const Vec3< ValueT > & | center = Vec3<ValueT>(0.0f),
|  | double | voxelSize = 1.0,
|  | const Vec3d & | origin = Vec3d(0.0f),
|  | const std::string & | name = "torus_points",
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | const BufferT & | buffer = BufferT() )

inline

Returns a handle to a PointDataGrid containing points scattered on the surface of a torus.

Parameters

  pointsPerVoxel | Number of point per voxel on on the surface
  majorRadius | Major radius of torus in world units
  minorRadius | Minor radius of torus in world units
  center | Center of torus in world units
  voxelSize | Size of a voxel in world units
  origin | Origin of grid in world units
  name | Name of the grid
  cMode | Mode of computation for the checksum.
  buffer | Buffer used for memory allocation by the handle

The `ValueT` template parameter must be float (default) or double.

## createSampler()

template<int Order, typename TreeOrAccT, bool UseCache = true>

SampleFromVoxels< TreeOrAccT, Order, UseCache > createSampler | ( | const TreeOrAccT & | acc | ) |

Factory free-function for a sampler of specific polynomial orders.

This allows for the compact syntax:

auto acc = grid.getAccessor();
auto smp = nanovdb::createSampler<1>( acc );
nanovdb::createSampler
SampleFromVoxels< TreeOrAccT, Order, UseCache > createSampler(const TreeOrAccT &acc)
Factory free-function for a sampler of specific polynomial orders.
Definition SampleFromVoxels.h:46

## FindHighestOn() [1/2]

uint32_t FindHighestOn | ( | uint32_t | v | ) |

inline static

Returns the index of the highest, i.e. most significant, on bit in the specified 32 bit word.

Warning
  Assumes that at least one bit is set in the word, i.e. v != uint32_t(0)!

## FindHighestOn() [2/2]

uint32_t FindHighestOn | ( | uint64_t | v | ) |

inline static

Returns the index of the highest, i.e. most significant, on bit in the specified 64 bit word.

Warning
  Assumes that at least one bit is set in the word, i.e. v != uint32_t(0)!

## FindLowestOn() [1/2]

uint32_t FindLowestOn | ( | uint32_t | v | ) |

inline static

Returns the index of the lowest, i.e. least significant, on bit in the specified 32 bit word.

Warning
  Assumes that at least one bit is set in the word, i.e. v != uint32_t(0)!

## FindLowestOn() [2/2]

uint32_t FindLowestOn | ( | uint64_t | v | ) |

inline static

Returns the index of the lowest, i.e. least significant, on bit in the specified 64 bit word.

Warning
  Assumes that at least one bit is set in the word, i.e. v != uint32_t(0)!

## firstActive()

template<typename RayT, typename AccT>

__hostdev__ bool firstActive | ( | RayT & | ray,
|  | AccT & | acc,
|  | Coord & | ijk,
|  | float & | t )

inline

returns true if the ray intersects an active value at any level of the grid in the accessor. The empty-space ray-marching is performed at all levels of the tree using an HDDA. If an intersection is detected, then ijk is updated with the index coordinate of the first active voxel or tile, and t is set to the time of its intersection along the ray.

## Floor() [1/5]

int32_t Floor | ( | double | x | ) |

inline

## Floor() [2/5]

int32_t Floor | ( | float | x | ) |

inline

## Floor() [3/5]

template<typename CoordT, template< typename > class Vec3T>

CoordT Floor | ( | Vec3T< double > & | xyz | ) |

inline

Template specialization of Floor for Vec3<float>.

## Floor() [4/5]

template<typename CoordT, template< typename > class Vec3T>

CoordT Floor | ( | Vec3T< float > & | xyz | ) |

inline

Template specialization of Floor for Vec3<float>.

## Floor() [5/5]

template<typename CoordT, typename RealT, template< typename > class Vec3T>

CoordT Floor | ( | Vec3T< RealT > & | xyz | ) |

inline

Utility function that returns the Coord of the round-down of xyz and redefined (x,&nbsp y,&nbsp z) as the fractional part, ie xyz-in = return-value + xyz-out.

## forEach() [1/4]

template<template< typename... > class ContainerT, typename... T, typename FuncT>

void forEach | ( | const ContainerT< T... > & | c,
|  | const FuncT & | func )

inline

Simple wrapper for the function defined above, which works with std::containers.

## forEach() [2/4]

template<template< typename... > class ContainerT, typename... T, typename FuncT>

void forEach | ( | const ContainerT< T... > & | c,
|  | size_t | grainSize,
|  | const FuncT & | func )

inline

Simple wrapper for the function defined above, which works with std::containers.

## forEach() [3/4]

template<typename RangeT, typename FuncT>

void forEach | ( | RangeT | range,
|  | const FuncT & | func )

inline

simple wrapper for tbb::parallel_for with a naive std fallback

Parameters

  range | Range, CoordBBox, tbb::blocked_range, blocked_range2D, or blocked_range3D.
  func | functor with the signature [](const RangeT&){...},

std::vector<int> array(100);
auto func = [&array](auto &r){for (auto i=r.begin(); i!=r.end(); ++i) array[i]=i;};
forEach(array, func);
nanovdb::forEach
void forEach(RangeT range, const FuncT &func)
simple wrapper for tbb::parallel_for with a naive std fallback
Definition ForEach.h:40

## forEach() [4/4]

template<typename FuncT>

void forEach | ( | size_t | begin,
|  | size_t | end,
|  | size_t | grainSize,
|  | const FuncT & | func )

inline

Simple wrapper for the function defined above.

## Fract() [1/2]

double Fract | ( | double | x | ) |

inline

## Fract() [2/2]

float Fract | ( | float | x | ) |

inline

## getExtrema()

template<typename BuildT>

Extrema< typename NanoGrid< BuildT >::ValueType > getExtrema | ( | const NanoGrid< BuildT > & | grid,
|  | const CoordBBox & | bbox )

return the extrema of all the values in a grid that intersects the specified bounding box.

## GodunovsNormSqrd() [1/2]

template<typename RealT>

RealT GodunovsNormSqrd | ( | bool | isOutside,
|  | const Vec3< RealT > & | gradient_m,
|  | const Vec3< RealT > & | gradient_p )

inline

## GodunovsNormSqrd() [2/2]

template<typename RealT>

RealT GodunovsNormSqrd | ( | bool | isOutside,
|  | RealT | dP_xm,
|  | RealT | dP_xp,
|  | RealT | dP_ym,
|  | RealT | dP_yp,
|  | RealT | dP_zm,
|  | RealT | dP_zp )

inline

## gridStats()

template<typename BuildT>

void gridStats | ( | NanoGrid< BuildT > & | grid,
|  | StatsMode | mode = StatsMode::Default )

Re-computes the min/max, stats and bbox information for an existing NanoVDB Grid.

Parameters

  grid | Grid whose stats to update
  mode | Mode of computation for the statistics.

## invoke()

template<typename Func, typename... Rest>

int invoke | ( | const Func & | taskFunc1,
|  | Rest... | taskFuncN )

Returns
  1 for serial, 2 for tbb multi-threading, and 3 for std multi-threading

## isAligned()

bool isAligned | ( | const void * | p | ) |

inline static

return true if the specified pointer is aligned

## isApproxZero()

template<typename Type>

bool isApproxZero | ( | const Type & | x | ) |

inline

## isFloatingPoint()

bool isFloatingPoint | ( | GridType | gridType | ) |

inline

return true if the GridType maps to a floating point value.

## isValid() [1/3]

template<typename ValueT>

bool isValid | ( | const NanoGrid< ValueT > & | grid,
|  | bool | detailed = true,
|  | bool | verbose = false )

Return true if the specified grid passes several validation tests.

Parameters

  grid | Grid to validate
  detailed | If true the validation test is detailed and relatively slow.
  verbose | If true information about the first failed test is printed to std::cerr

## isValid() [2/3]

bool isValid | ( | const void * | p | ) |

inline static

return true if the specified pointer is aligned and not NULL

## isValid() [3/3]

bool isValid | ( | GridType | gridType,
|  | GridClass | gridClass )

inline

return true if the combination of GridType and GridClass is valid.

## mapToGridType()

template<typename BuildT>

GridType mapToGridType | ( |  | ) |

inline

Maps from a templated value type to a GridType enum.

## matMult() [1/4]

template<typename Vec3T>

Vec3T matMult | ( | const double * | mat,
|  | const double * | vec,
|  | const Vec3T & | xyz )

inline

## matMult() [2/4]

template<typename Vec3T>

Vec3T matMult | ( | const double * | mat,
|  | const Vec3T & | xyz )

inline

## matMult() [3/4]

template<typename Vec3T>

Vec3T matMult | ( | const float * | mat,
|  | const float * | vec,
|  | const Vec3T & | xyz )

inline

## matMult() [4/4]

template<typename Vec3T>

Vec3T matMult | ( | const float * | mat,
|  | const Vec3T & | xyz )

inline

## matMultT() [1/4]

template<typename Vec3T>

Vec3T matMultT | ( | const double * | mat,
|  | const double * | vec,
|  | const Vec3T & | xyz )

inline

## matMultT() [2/4]

template<typename Vec3T>

Vec3T matMultT | ( | const double * | mat,
|  | const Vec3T & | xyz )

inline

## matMultT() [3/4]

template<typename Vec3T>

Vec3T matMultT | ( | const float * | mat,
|  | const float * | vec,
|  | const Vec3T & | xyz )

inline

## matMultT() [4/4]

template<typename Vec3T>

Vec3T matMultT | ( | const float * | mat,
|  | const Vec3T & | xyz )

inline

## Max() [1/5]

double Max | ( | double | a,
|  | double | b )

inline

## Max() [2/5]

float Max | ( | float | a,
|  | float | b )

inline

## Max() [3/5]

int32_t Max | ( | int32_t | a,
|  | int32_t | b )

inline

## Max() [4/5]

template<typename Type>

Type Max | ( | Type | a,
|  | Type | b )

inline

## Max() [5/5]

uint32_t Max | ( | uint32_t | a,
|  | uint32_t | b )

inline

## MaxIndex()

template<typename Vec3T>

int MaxIndex | ( | const Vec3T & | v | ) |

inline

## Min() [1/5]

double Min | ( | double | a,
|  | double | b )

inline

## Min() [2/5]

float Min | ( | float | a,
|  | float | b )

inline

## Min() [3/5]

int32_t Min | ( | int32_t | a,
|  | int32_t | b )

inline

## Min() [4/5]

template<typename Type>

Type Min | ( | Type | a,
|  | Type | b )

inline

## Min() [5/5]

uint32_t Min | ( | uint32_t | a,
|  | uint32_t | b )

inline

## MinIndex()

template<typename Vec3T>

int MinIndex | ( | const Vec3T & | v | ) |

inline

## nanoToOpenVDB() [1/2]

template<typename BufferT>

openvdb::GridBase::Ptr nanoToOpenVDB | ( | const GridHandle< BufferT > & | handle,
|  | int | verbose = 0 )

Forward declaration of free-standing function that de-serializes a NanoVDB GridHandle into an OpenVDB GridBase.

## nanoToOpenVDB() [2/2]

template<typename NanoBuildT>

openvdb::Grid< typenameopenvdb::tree::Tree4< typenameConvertTrait< NanoBuildT >::Type >::Type >::Ptr nanoToOpenVDB | ( | const NanoGrid< NanoBuildT > & | grid,
|  | int | verbose = 0 )

inline

Forward declaration of free-standing function that de-serializes a typed NanoVDB grid into an OpenVDB Grid.

## openToNanoVDB() [1/2]

template<typename BufferT = HostBuffer, typename OpenTreeT = openvdb::FloatTree, typename NanoBuildT = typename OpenToNanoType<typename OpenTreeT::BuildType>::Type>

GridHandle< BufferT > openToNanoVDB | ( | const openvdb::Grid< OpenTreeT > & | grid,
|  | StatsMode | sMode = StatsMode::Default,
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | int | verbose = 0 )

Forward declaration of free-standing function that converts a typed OpenVDB Grid into a NanoVDB GridHandle.

Unlike the function above that takes a base openvdb grid, this method is strongly typed and allows for compression, e.g. openToNanoVDB<HostBuffer, openvdb::FloatTree, nanovdb::Fp16>

## openToNanoVDB() [2/2]

template<typename BufferT = HostBuffer>

GridHandle< BufferT > openToNanoVDB | ( | const openvdb::GridBase::Ptr & | base,
|  | StatsMode | sMode = StatsMode::Default,
|  | ChecksumMode | cMode = ChecksumMode::Default,
|  | int | verbose = 0 )

Forward declaration of free-standing function that converts an OpenVDB GridBase into a NanoVDB GridHandle.

## operator*() [1/2]

template<typename T1, typename T2>

Vec3< T2 > operator* | ( | T1 | scalar,
|  | const Vec3< T2 > & | vec )

inline

## operator*() [2/2]

template<typename T1, typename T2>

Vec4< T2 > operator* | ( | T1 | scalar,
|  | const Vec4< T2 > & | vec )

inline

## operator/() [1/2]

template<typename T1, typename T2>

Vec4< T2 > operator/ | ( | T1 | scalar,
|  | const Vec3< T2 > & | vec )

inline

## operator/() [2/2]

template<typename T1, typename T2>

Vec3< T2 > operator/ | ( | T1 | scalar,
|  | const Vec3< T2 > & | vec )

inline

## operator<<() [1/2]

std::ostream & operator<< | ( | std::ostream & | os,
|  | const AbsDiff & | diff )

inline

## operator<<() [2/2]

std::ostream & operator<< | ( | std::ostream & | os,
|  | const RelDiff & | diff )

inline

## Pow2()

template<typename T>

T Pow2 | ( | T | x | ) |

inline

## Pow3()

template<typename T>

T Pow3 | ( | T | x | ) |

inline

## Pow4()

template<typename T>

T Pow4 | ( | T | x | ) |

inline

## PtrAdd() [1/2]

template<typename DstT, typename SrcT>

const DstT * PtrAdd | ( | const SrcT * | p,
|  | int64_t | offset )

inline static

## PtrAdd() [2/2]

template<typename DstT, typename SrcT>

DstT * PtrAdd | ( | SrcT * | p,
|  | int64_t | offset )

inline static

## PtrDiff()

template<typename T1, typename T2>

int64_t PtrDiff | ( | const T1 * | p,
|  | const T2 * | q )

inline static

## reduce() [1/4]

template<template< typename... > class ContainerT, typename... ArgT, typename T, typename FuncT, typename JoinT>

T reduce | ( | const ContainerT< ArgT... > & | c,
|  | const T & | identity,
|  | const FuncT & | func,
|  | const JoinT & | join )

inline

Simple wrapper that works with std::containers.

## reduce() [2/4]

template<template< typename... > class ContainerT, typename... ArgT, typename T, typename FuncT, typename JoinT>

T reduce | ( | const ContainerT< ArgT... > & | c,
|  | size_t | grainSize,
|  | const T & | identity,
|  | const FuncT & | func,
|  | const JoinT & | join )

inline

Simple wrapper that works with std::containers.

## reduce() [3/4]

template<typename RangeT, typename T, typename FuncT, typename JoinT>

T reduce | ( | RangeT | range,
|  | const T & | identity,
|  | const FuncT & | func,
|  | const JoinT & | join )

inline

Returns
  reduction

Parameters

  range | RangeT can be Range<dim,T>, CoordBBox, tbb::blocked_range, blocked_range2D, or blocked_range3D.
  identity | initial value
  func | functor with signature T FuncT::operator()(const RangeT& range, const T& a) const

  join

  functor with the signature T JoinT::operator()(const T& a, const T& b) const
  std::vector<int> array(100, 1);
  auto func = [&array](auto &r, int a){for (auto i=r.begin(); i!=r.end(); ++i) a+=array[i]; return a;};
  int sum = reduce(array, 0, func, [](int a, int b){return a + b;});
  nanovdb::reduce
  T reduce(RangeT range, const T &identity, const FuncT &func, const JoinT &join)
  Definition Reduce.h:42

## reduce() [4/4]

template<typename T, typename FuncT, typename JoinT>

T reduce | ( | size_t | begin,
|  | size_t | end,
|  | size_t | grainSize,
|  | const T & | identity,
|  | const FuncT & | func,
|  | const JoinT & | join )

inline

Simple wrapper to the function defined above.

## Round() [1/3]

template<typename CoordT, template< typename > class Vec3T>

CoordT Round | ( | const Vec3T< double > & | xyz | ) |

inline

## Round() [2/3]

template<typename CoordT, template< typename > class Vec3T>

CoordT Round | ( | const Vec3T< float > & | xyz | ) |

inline

## Round() [3/3]

template<typename CoordT, typename RealT, template< typename > class Vec3T>

CoordT Round | ( | const Vec3T< RealT > & | xyz | ) |

inline

## RoundDown()

template<typename CoordT, typename RealT, template< typename > class Vec3T>

CoordT RoundDown | ( | const Vec3T< RealT > & | xyz | ) |

inline

## Sign()

template<typename T>

T Sign | ( | const T & | x | ) |

inline

Return the sign of the given value as an integer (either -1, 0 or 1).

## Sqrt() [1/2]

double Sqrt | ( | double | x | ) |

inline

## Sqrt() [2/2]

float Sqrt | ( | float | x | ) |

inline

Return the square root of a floating-point value.

## toStr() [1/3]

const char * toStr | ( | GridClass | gridClass | ) |

inline

Retuns a c-string used to describe a GridClass.

## toStr() [2/3]

const char * toStr | ( | GridFlags | gridFlags | ) |

inline

Retuns a c-string used to describe a GridFlags.

## toStr() [3/3]

const char * toStr | ( | GridType | gridType | ) |

inline

Retuns a c-string used to describe a GridType.

## updateChecksum()

template<typename ValueT>

void updateChecksum | ( | NanoGrid< ValueT > & | grid,
|  | ChecksumMode | mode = ChecksumMode::Default )

Updates the checksum of a grid.

Parameters

  grid | Grid whose checksum will be updated.
  mode | Defines the mode of computation for the checksum.

## validateChecksum()

template<typename ValueT>

bool validateChecksum | ( | const NanoGrid< ValueT > & | grid,
|  | ChecksumMode | mode = ChecksumMode::Default )

Return true if the checksum of the grid matches the expected value already encoded into the grid's meta data.

Parameters

  grid | Grid whose checksum is validated.
  mode | Defines the mode of computation for the checksum.

## WENO5()

template<typename ValueType, typename RealT = ValueType>

ValueType WENO5 | ( | const ValueType & | v1,
|  | const ValueType & | v2,
|  | const ValueType & | v3,
|  | const ValueType & | v4,
|  | const ValueType & | v5,
|  | RealT | scale2 = 1.0 )

inline

Implementation of nominally fifth-order finite-difference WENO.

This function returns the numerical flux. See "High Order Finite Difference and Finite Volume WENO Schemes and Discontinuous Galerkin Methods for CFD" - Chi-Wang Shu ICASE Report No 2001-11 (page 6). Also see ICASE No 97-65 for a more complete reference (Shu, 1997). Given v1 = f(x-2dx), v2 = f(x-dx), v3 = f(x), v4 = f(x+dx) and v5 = f(x+2dx), return an interpolated value f(x+dx/2) with the special property that ( f(x+dx/2) - f(x-dx/2) ) / dx = df/dx (x) + error, where the error is fifth-order in smooth regions: O(dx) <= error <=O(dx^5)

## ZeroCrossing()

template<typename RayT, typename AccT>

__hostdev__ bool ZeroCrossing | ( | RayT & | ray,
|  | AccT & | acc,
|  | Coord & | ijk,
|  | typename AccT::ValueType & | v,
|  | float & | t )

inline

returns true if the ray intersects a zero-crossing at the voxel level of the grid in the accessor The empty-space ray-marching is performed at all levels of the tree using an HDDA. If an intersection is detected, then ijk is updated with the index coordinate of the closest voxel after the intersection point, v contains the grid values at ijk, and t is set to the time of the intersection along the ray.

## ZeroCrossingNode()

template<typename RayT, typename NodeT>

__hostdev__ bool ZeroCrossingNode | ( | RayT & | ray,
|  | const NodeT & | node,
|  | float | v0,
|  | nanovdb::Coord & | ijk,
|  | float & | v,
|  | float & | t )

inline