Loading...
Searching...
No Matches
PointDataLeafNode< T, Log2Dim > Class Template Reference

`#include <openvdb/points/PointDataGrid.h>`

Inheritance diagram for PointDataLeafNode< T, Log2Dim >:

## Public Types

using | LeafNodeType = PointDataLeafNode<T, Log2Dim>
using | Ptr = std::shared_ptr<PointDataLeafNode>
using | ValueType = T
using | ValueTypePair = std::pair<ValueType, ValueType>
using | IndexArray = std::vector<ValueType>
using | Descriptor = AttributeSet::Descriptor
using | BaseLeaf = tree::LeafNode<T, Log2Dim>
using | NodeMaskType = util::NodeMask<Log2Dim>
using | ValueOn = typename BaseLeaf::ValueOn
using | ValueOff = typename BaseLeaf::ValueOff
using | ValueAll = typename BaseLeaf::ValueAll
using | ValueOnIter
using | ValueOnCIter
using | ValueOffIter
using | ValueOffCIter
using | ValueAllIter
using | ValueAllCIter
using | ChildOnIter
using | ChildOnCIter
using | ChildOffIter
using | ChildOffCIter
using | ChildAllIter
using | ChildAllCIter
using | IndexVoxelIter = IndexIter<ValueVoxelCIter, NullFilter>
using | IndexAllIter = IndexIter<ValueAllCIter, NullFilter>
using | IndexOnIter = IndexIter<ValueOnCIter, NullFilter>
using | IndexOffIter = IndexIter<ValueOffCIter, NullFilter>
using | BuildType = T
using | Buffer = LeafBuffer<ValueType, Log2Dim>

## Public Member Functions

| PointDataLeafNode ()
| Default constructor.
| ~PointDataLeafNode ()=default
| PointDataLeafNode (const PointDataLeafNode &other)
| Construct using deep copy of other PointDataLeafNode.
| PointDataLeafNode (const Coord &coords, const T &value=zeroVal< T >(), bool active=false)
| Construct using supplied origin, value and active status.
| PointDataLeafNode (const PointDataLeafNode &other, const Coord &coords, const T &value=zeroVal< T >(), bool active=false)
template<typename OtherValueType>
| PointDataLeafNode (const tools::PointIndexLeafNode< OtherValueType, Log2Dim > &other)
template<typename ValueType>
| PointDataLeafNode (const tree::LeafNode< ValueType, Log2Dim > &other, const T &value, TopologyCopy)
template<typename ValueType>
| PointDataLeafNode (const tree::LeafNode< ValueType, Log2Dim > &other, const T &, const T &, TopologyCopy)
| PointDataLeafNode (PartialCreate, const Coord &coords, const T &value=zeroVal< T >(), bool active=false)
const AttributeSet & | attributeSet () const
| Retrieve the attribute set.
AttributeSet::UniquePtr | stealAttributeSet ()
| Steal the attribute set, a new, empty attribute set is inserted in it's place.
void | initializeAttributes (const Descriptor::Ptr &descriptor, const Index arrayLength, const AttributeArray::ScopedRegistryLock *lock=nullptr)
| Create a new attribute set. Existing attributes will be removed.
void | clearAttributes (const bool updateValueMask=true, const AttributeArray::ScopedRegistryLock *lock=nullptr)
| Clear the attribute set.
bool | hasAttribute (const size_t pos) const
| Returns `true` if an attribute with this index exists.
bool | hasAttribute (const Name &attributeName) const
| Returns `true` if an attribute with this name exists.
AttributeArray::Ptr | appendAttribute (const Descriptor &expected, Descriptor::Ptr &replacement, const size_t pos, const Index strideOrTotalSize=1, const bool constantStride=true, const Metadata *metadata=nullptr, const AttributeArray::ScopedRegistryLock *lock=nullptr)
| Append an attribute to the leaf.
void | dropAttributes (const std::vector< size_t > &pos, const Descriptor &expected, Descriptor::Ptr &replacement)
| Drop list of attributes.
void | reorderAttributes (const Descriptor::Ptr &replacement)
| Reorder attribute set.
void | renameAttributes (const Descriptor &expected, Descriptor::Ptr &replacement)
| Rename attributes in attribute set (order must remain the same).
void | compactAttributes ()
| Compact all attributes in attribute set.
void | replaceAttributeSet (AttributeSet *attributeSet, bool allowMismatchingDescriptors=false)
| Replace the underlying attribute set with the given attributeSet.
void | resetDescriptor (const Descriptor::Ptr &replacement)
| Replace the descriptor with a new one The new Descriptor must exactly match the old one.
void | setOffsets (const std::vector< ValueType > &offsets, const bool updateValueMask=true)
| Sets all of the voxel offset values on this leaf, from the given vector of offsets. If updateValueMask is true, then the active value mask will be updated so voxels with points are active and empty voxels are inactive.
void | validateOffsets () const
| Throws an error if the voxel values on this leaf are not monotonically increasing or within the bounds of the attribute arrays.
AttributeArray & | attributeArray (const size_t pos)
| Read-write attribute array reference from index.
const AttributeArray & | attributeArray (const size_t pos) const
const AttributeArray & | constAttributeArray (const size_t pos) const
AttributeArray & | attributeArray (const Name &attributeName)
| Read-write attribute array reference from name.
const AttributeArray & | attributeArray (const Name &attributeName) const
const AttributeArray & | constAttributeArray (const Name &attributeName) const
GroupHandle | groupHandle (const AttributeSet::Descriptor::GroupIndex &index) const
| }
GroupHandle | groupHandle (const Name &group) const
| Read-only group handle from group name.
GroupWriteHandle | groupWriteHandle (const AttributeSet::Descriptor::GroupIndex &index)
| Read-write group handle from group index.
GroupWriteHandle | groupWriteHandle (const Name &name)
| Read-write group handle from group name.
Index64 | pointCount () const
| Compute the total point count for the leaf.
Index64 | onPointCount () const
| Compute the total active (on) point count for the leaf.
Index64 | offPointCount () const
| Compute the total inactive (off) point count for the leaf.
Index64 | groupPointCount (const Name &groupName) const
| Compute the point count in a specific group for the leaf.
void | updateValueMask ()
| Activate voxels with non-zero points, deactivate voxels with zero points.
void | setOffsetOn (Index offset, const ValueType &val)
void | setOffsetOnly (Index offset, const ValueType &val)
template<typename OtherType, Index OtherLog2Dim>
bool | hasSameTopology (const PointDataLeafNode< OtherType, OtherLog2Dim > *other) const
| Return `true` if the given node (which may have a different `ValueType` than this node) has the same active value topology as this node.
bool | operator== (const PointDataLeafNode &other) const
bool | operator!= (const PointDataLeafNode &other) const
void | addLeaf (PointDataLeafNode *)
template<typename AccessorT>
void | addLeafAndCache (PointDataLeafNode *, AccessorT &)
PointDataLeafNode * | touchLeaf (const Coord &)
| Return a pointer to this node.
template<typename AccessorT>
PointDataLeafNode * | touchLeafAndCache (const Coord &, AccessorT &)
template<typename NodeT, typename AccessorT>
NodeT * | probeNodeAndCache (const Coord &, AccessorT &)
PointDataLeafNode * | probeLeaf (const Coord &)
template<typename AccessorT>
PointDataLeafNode * | probeLeafAndCache (const Coord &, AccessorT &)
const PointDataLeafNode * | probeConstLeaf (const Coord &) const
| Return a const pointer to this node.
template<typename AccessorT>
const PointDataLeafNode * | probeConstLeafAndCache (const Coord &, AccessorT &) const
template<typename AccessorT>
const PointDataLeafNode * | probeLeafAndCache (const Coord &, AccessorT &) const
const PointDataLeafNode * | probeLeaf (const Coord &) const
template<typename NodeT, typename AccessorT>
const NodeT * | probeConstNodeAndCache (const Coord &, AccessorT &) const
void | readTopology (std::istream &is, bool fromHalf=false)
void | writeTopology (std::ostream &os, bool toHalf=false) const
Index | buffers () const
void | readBuffers (std::istream &is, bool fromHalf=false)
void | readBuffers (std::istream &is, const CoordBBox &, bool fromHalf=false)
void | writeBuffers (std::ostream &os, bool toHalf=false) const
Index64 | memUsage () const
Index64 | memUsageIfLoaded () const
void | evalActiveBoundingBox (CoordBBox &bbox, bool visitVoxels=true) const
CoordBBox | getNodeBoundingBox () const
| Return the bounding box of this node, i.e., the full index space spanned by this leaf node.
void | assertNonmodifiable ()
void | assertNonModifiableUnlessZero (const ValueType &value)
void | setActiveState (const Coord &xyz, bool on)
void | setActiveState (Index offset, bool on)
void | setValueOnly (const Coord &, const ValueType &)
void | setValueOnly (Index, const ValueType &)
void | setValueOff (const Coord &xyz)
void | setValueOff (Index offset)
void | setValueOff (const Coord &, const ValueType &)
void | setValueOff (Index, const ValueType &)
void | setValueOn (const Coord &xyz)
void | setValueOn (Index offset)
void | setValueOn (const Coord &, const ValueType &)
void | setValueOn (Index, const ValueType &)
void | setValue (const Coord &, const ValueType &)
void | setValuesOn ()
void | setValuesOff ()
template<typename ModifyOp>
void | modifyValue (Index, const ModifyOp &)
template<typename ModifyOp>
void | modifyValue (const Coord &, const ModifyOp &)
template<typename ModifyOp>
void | modifyValueAndActiveState (const Coord &, const ModifyOp &)
void | clip (const CoordBBox &, const ValueType &value)
void | fill (const CoordBBox &, const ValueType &, bool)
void | fill (const ValueType &value)
void | fill (const ValueType &, bool)
template<typename AccessorT>
void | setValueOnlyAndCache (const Coord &, const ValueType &, AccessorT &)
template<typename ModifyOp, typename AccessorT>
void | modifyValueAndActiveStateAndCache (const Coord &, const ModifyOp &, AccessorT &)
template<typename AccessorT>
void | setValueOffAndCache (const Coord &, const ValueType &, AccessorT &)
template<typename AccessorT>
void | setActiveStateAndCache (const Coord &xyz, bool on, AccessorT &parent)
void | resetBackground (const ValueType &, const ValueType &newBackground)
void | signedFloodFill (const ValueType &)
void | signedFloodFill (const ValueType &, const ValueType &)
void | negate ()
ValueVoxelCIter | beginValueVoxel (const Coord &ijk) const
| Leaf value voxel iterator.
IndexAllIter | beginIndexAll () const
| Leaf index iterator.
IndexOnIter | beginIndexOn () const
IndexOffIter | beginIndexOff () const
template<typename IterT, typename FilterT>
IndexIter< IterT, FilterT > | beginIndex (const FilterT &filter) const
template<typename FilterT>
IndexIter< ValueAllCIter, FilterT > | beginIndexAll (const FilterT &filter) const
| Filtered leaf index iterator.
template<typename FilterT>
IndexIter< ValueOnCIter, FilterT > | beginIndexOn (const FilterT &filter) const
template<typename FilterT>
IndexIter< ValueOffCIter, FilterT > | beginIndexOff (const FilterT &filter) const
IndexVoxelIter | beginIndexVoxel (const Coord &ijk) const
| Leaf index iterator from voxel.
template<typename FilterT>
IndexIter< ValueVoxelCIter, FilterT > | beginIndexVoxel (const Coord &ijk, const FilterT &filter) const
| Filtered leaf index iterator from voxel.
ValueOnCIter | cbeginValueOn () const
ValueOnCIter | beginValueOn () const
ValueOnIter | beginValueOn ()
ValueOffCIter | cbeginValueOff () const
ValueOffCIter | beginValueOff () const
ValueOffIter | beginValueOff ()
ValueAllCIter | cbeginValueAll () const
ValueAllCIter | beginValueAll () const
ValueAllIter | beginValueAll ()
ValueOnCIter | cendValueOn () const
ValueOnCIter | endValueOn () const
ValueOnIter | endValueOn ()
ValueOffCIter | cendValueOff () const
ValueOffCIter | endValueOff () const
ValueOffIter | endValueOff ()
ValueAllCIter | cendValueAll () const
ValueAllCIter | endValueAll () const
ValueAllIter | endValueAll ()
ChildOnCIter | cbeginChildOn () const
ChildOnCIter | beginChildOn () const
ChildOnIter | beginChildOn ()
ChildOffCIter | cbeginChildOff () const
ChildOffCIter | beginChildOff () const
ChildOffIter | beginChildOff ()
ChildAllCIter | cbeginChildAll () const
ChildAllCIter | beginChildAll () const
ChildAllIter | beginChildAll ()
ChildOnCIter | cendChildOn () const
ChildOnCIter | endChildOn () const
ChildOnIter | endChildOn ()
ChildOffCIter | cendChildOff () const
ChildOffCIter | endChildOff () const
ChildOffIter | endChildOff ()
ChildAllCIter | cendChildAll () const
ChildAllCIter | endChildAll () const
ChildAllIter | endChildAll ()
template<typename ValueIterT, typename FilterT>
IndexIter< ValueIterT, FilterT > | beginIndex (const FilterT &filter) const
void | nodeCount (std::vector< Index32 > &) const
| no-op
Index64 | onVoxelCount () const
| Return the number of voxels marked On.
Index64 | offVoxelCount () const
| Return the number of voxels marked Off.
Index64 | onLeafVoxelCount () const
Index64 | offLeafVoxelCount () const
bool | isEmpty () const
| Return `true` if this node has no active voxels.
bool | isDense () const
| Return `true` if this node contains only active voxels.
bool | isAllocated () const
| Return `true` if memory for this node's buffer has been allocated.
bool | allocate ()
| Allocate memory for this node's buffer if it has not already been allocated.
void | setOrigin (const Coord &origin)
| Set the grid index coordinates of this node's local origin.
const Coord & | origin () const
| Return the grid index coordinates of this node's local origin.
void | getOrigin (Coord &origin) const
void | getOrigin (Int32 &x, Int32 &y, Int32 &z) const
Coord | offsetToGlobalCoord (Index n) const
| Return the global coordinates for a linear table offset.
Index32 | transientData () const
| Return the transient data value.
void | setTransientData (Index32 transientData)
| Set the transient data value.
std::string | str () const
| Return a string representation of this node.
template<typename OtherType, Index OtherLog2Dim>
bool | hasSameTopology (const LeafNode< OtherType, OtherLog2Dim > *other) const
| Return `true` if the given node (which may have a different `ValueType` than this node) has the same active value topology as this node.
bool | operator== (const LeafNode &other) const
| Check for buffer, state and origin equivalence.
bool | operator!= (const LeafNode &other) const
void | swap (Buffer &other)
| Exchange this node's data buffer with the given data buffer without changing the active states of the values.
const Buffer & | buffer () const
Buffer & | buffer ()
size_t | streamingSize (bool toHalf=false) const
const ValueType & | getValue (const Coord &xyz) const
| Return the value of the voxel at the given coordinates.
const ValueType & | getValue (Index offset) const
| Return the value of the voxel at the given linear offset.
template<typename AccessorT>
const ValueType & | getValue (const Coord &xyz, bool &state, int &level, AccessorT &) const
| Return the value of the voxel at the given coordinates and return its active state and level (i.e., 0) in state and level.
bool | probeValue (const Coord &xyz, ValueType &val) const
| Return `true` if the voxel at the given coordinates is active.
bool | probeValue (Index offset, ValueType &val) const
| Return `true` if the voxel at the given offset is active.
bool | isValueOn (const Coord &xyz) const
| Return `true` if the voxel at the given coordinates is active.
bool | isValueOn (Index offset) const
| Return `true` if the voxel at the given offset is active.
void | denseFill (const CoordBBox &bbox, const ValueType &value, bool active=true)
| Set all voxels within an axis-aligned box to the specified value and active state.
template<typename DenseT>
void | copyToDense (const CoordBBox &bbox, DenseT &dense) const
| Copy into a dense grid the values of the voxels that lie within a given bounding box.
template<typename DenseT>
void | copyFromDense (const CoordBBox &bbox, const DenseT &dense, const ValueType &background, const ValueType &tolerance)
| Copy from a dense grid into this node the values of the voxels that lie within a given bounding box.
template<typename DenseT>
void | copyFromDense (const CoordBBox &bbox, const DenseT &dense, bool background, bool tolerance)
template<typename AccessorT>
const ValueType & | getValueAndCache (const Coord &xyz, AccessorT &) const
| Return the value of the voxel at the given coordinates.
template<typename AccessorT>
bool | isValueOnAndCache (const Coord &xyz, AccessorT &) const
| Return `true` if the voxel at the given coordinates is active.
template<typename AccessorT>
void | setValueAndCache (const Coord &xyz, const ValueType &val, AccessorT &)
| Change the value of the voxel at the given coordinates and mark it as active.
template<typename ModifyOp, typename AccessorT>
void | modifyValueAndCache (const Coord &xyz, const ModifyOp &op, AccessorT &)
| Apply a functor to the value of the voxel at the given coordinates and mark the voxel as active.
template<typename AccessorT>
bool | probeValueAndCache (const Coord &xyz, ValueType &val, AccessorT &) const
| Return `true` if the voxel at the given coordinates is active and return the voxel value in val.
const ValueType & | getFirstValue () const
| Return a const reference to the first value in the buffer.
const ValueType & | getLastValue () const
| Return a const reference to the last value in the buffer.
void | voxelizeActiveTiles (bool=true)
| No-op.
template<MergePolicy Policy>
void | merge (const LeafNode &)
template<MergePolicy Policy>
void | merge (const ValueType &tileValue, bool tileActive)
template<MergePolicy Policy>
void | merge (const LeafNode &other, const ValueType &, const ValueType &)
template<MergePolicy Policy>
void | merge (const LeafNode &other, bool, bool)
template<MergePolicy Policy>
void | merge (bool tileValue, bool tileActive)
template<typename OtherType>
void | topologyUnion (const LeafNode< OtherType, Log2Dim > &other, const bool preserveTiles=false)
| Union this node's set of active values with the active values of the other node, whose `ValueType` may be different. So a resulting voxel will be active if either of the original voxels were active.
template<typename OtherType>
void | topologyIntersection (const LeafNode< OtherType, Log2Dim > &other, const ValueType &)
| Intersect this node's set of active values with the active values of the other node, whose `ValueType` may be different. So a resulting voxel will be active only if both of the original voxels were active.
template<typename OtherType>
void | topologyIntersection (const LeafNode< OtherType, Log2Dim > &other, const bool &)
template<typename OtherType>
void | topologyDifference (const LeafNode< OtherType, Log2Dim > &other, const ValueType &)
| Difference this node's set of active values with the active values of the other node, whose `ValueType` may be different. So a resulting voxel will be active only if the original voxel is active in this LeafNode and inactive in the other LeafNode.
template<typename OtherType>
void | topologyDifference (const LeafNode< OtherType, Log2Dim > &other, const bool &)
template<typename CombineOp>
void | combine (const LeafNode &other, CombineOp &op)
template<typename CombineOp>
void | combine (const ValueType &value, bool valueIsActive, CombineOp &op)
template<typename CombineOp>
void | combine (bool value, bool valueIsActive, CombineOp &op)
template<typename CombineOp, typename OtherType>
void | combine2 (const LeafNode &other, const OtherType &, bool valueIsActive, CombineOp &)
template<typename CombineOp, typename OtherNodeT>
void | combine2 (const ValueType &, const OtherNodeT &other, bool valueIsActive, CombineOp &)
template<typename CombineOp, typename OtherNodeT>
void | combine2 (const LeafNode &b0, const OtherNodeT &b1, CombineOp &)
template<typename CombineOp, typename OtherNodeT>
void | combine2 (bool value, const OtherNodeT &other, bool valueIsActive, CombineOp &op)
void | prune (const ValueType &=zeroVal< ValueType >())
| This function exists only to enable template instantiation.
void | addLeaf (LeafNode *)
template<typename AccessorT>
void | addLeafAndCache (LeafNode *, AccessorT &)
template<typename NodeT>
NodeT * | stealNode (const Coord &, const ValueType &, bool)
template<typename NodeT>
NodeT * | probeNode (const Coord &)
template<typename NodeT>
const NodeT * | probeConstNode (const Coord &) const
template<typename ArrayT>
void | getNodes (ArrayT &) const
template<typename ArrayT>
void | stealNodes (ArrayT &, const ValueType &, bool)
void | addTile (Index level, const Coord &, const ValueType &, bool)
void | addTile (Index offset, const ValueType &, bool)
template<typename AccessorT>
void | addTileAndCache (Index, const Coord &, const ValueType &, bool, AccessorT &)
template<typename AccessorT>
void | addTileAndCache (Index level, const Coord &xyz, bool val, bool active, AccessorT &)
bool | isConstant (ValueType &firstValue, bool &state, const ValueType &tolerance=zeroVal< ValueType >()) const
bool | isConstant (ValueType &minValue, ValueType &maxValue, bool &state, const ValueType &tolerance=zeroVal< ValueType >()) const
ValueType | medianAll (ValueType *tmp=nullptr) const
| Computes the median value of all the active AND inactive voxels in this node.
Index | medianOn (ValueType &value, ValueType *tmp=nullptr) const
| Computes the median value of all the active voxels in this node.
Index | medianOff (ValueType &value, ValueType *tmp=nullptr) const
| Computes the median value of all the inactive voxels in this node.
bool | isInactive () const
| Return `true` if all of this node's values are inactive.
bool | isValueMaskOn (Index n) const
bool | isValueMaskOn () const
bool | isValueMaskOff (Index n) const
bool | isValueMaskOff () const
const NodeMaskType & | getValueMask () const
NodeMaskType & | getValueMask ()
const NodeMaskType & | valueMask () const
void | setValueMask (const NodeMaskType &mask)
bool | isChildMaskOn (Index) const
bool | isChildMaskOff (Index) const
bool | isChildMaskOff () const

## Static Public Member Functions

static Index | log2dim ()
| Return log2 of the dimension of this LeafNode, e.g. 3 if dimensions are 8^3.
static Index | dim ()
| Return the number of voxels in each coordinate dimension.
static Index | size ()
| Return the total number of voxels represented by this LeafNode.
static Index | numValues ()
| Return the total number of voxels represented by this LeafNode.
static Index | getLevel ()
| Return the level of this node, which by definition is zero for LeafNodes.
static void | getNodeLog2Dims (std::vector< Index > &dims)
| Append the Log2Dim of this LeafNode to the specified vector.
static Index | getChildDim ()
| Return the dimension of child nodes of this LeafNode, which is one for voxels.
static Index32 | leafCount ()
| Return the leaf count for this node, which is one.
static Index32 | nonLeafCount ()
| Return the non-leaf count for this node, which is zero.
static Index32 | childCount ()
| Return the child count for this node, which is zero.
static Index64 | onTileCount ()
static Index64 | offTileCount ()
static Index | coordToOffset (const Coord &xyz)
| Return the linear table offset of the given global or local coordinates.
static Coord | offsetToLocalCoord (Index n)
| Return the local coordinates for a linear table offset, where offset 0 has coordinates (0, 0, 0).
static Index | getValueLevel (const Coord &)
| Return the level (i.e., 0) at which leaf node values reside.
static bool | hasActiveTiles ()
| Return `false` since leaf nodes never contain tiles.
template<typename AccessorT>
static Index | getValueLevelAndCache (const Coord &, AccessorT &)
| Return the LEVEL (=0) at which leaf node values reside.

## Static Public Attributes

static const Index | LOG2DIM
static const Index | TOTAL
static const Index | DIM
static const Index | NUM_VALUES
static const Index | NUM_VOXELS
static const Index | SIZE
static const Index | LEVEL

## Protected Types

using | ChildOn = typename BaseLeaf::ChildOn
using | ChildOff = typename BaseLeaf::ChildOff
using | ChildAll = typename BaseLeaf::ChildAll
using | MaskOnIterator = typename NodeMaskType::OnIterator
using | MaskOffIterator = typename NodeMaskType::OffIterator
using | MaskDenseIterator = typename NodeMaskType::DenseIterator

## Protected Member Functions

void | setValueMask (Index n, bool on)
void | setValueMaskOn (Index n)
void | setValueMaskOff (Index n)
void | skipCompressedValues (bool seekable, std::istream &, bool fromHalf)

## Static Protected Member Functions

static void | evalNodeOrigin (Coord &xyz)
| Compute the origin of the leaf node that contains the voxel with the given coordinates.

## Friends

class | ::TestPointDataLeaf
template<typename, Index>
class | PointDataLeafNode
class | tree::IteratorBase< MaskOnIterator, PointDataLeafNode >
class | tree::IteratorBase< MaskOffIterator, PointDataLeafNode >
class | tree::IteratorBase< MaskDenseIterator, PointDataLeafNode >

## Member Typedef Documentation

## BaseLeaf

template<typename T, Index Log2Dim>

using BaseLeaf = tree::LeafNode<T, Log2Dim>

## Buffer

template<typename T, Index Log2Dim>

using Buffer = LeafBuffer<ValueType, Log2Dim>

inherited

## BuildType

template<typename T, Index Log2Dim>

using BuildType = T

inherited

## ChildAll

template<typename T, Index Log2Dim>

using ChildAll = typename BaseLeaf::ChildAll

protected

## ChildAllCIter

template<typename T, Index Log2Dim>

using ChildAllCIter

Initial value:
typename BaseLeaf::template DenseIter<
const PointDataLeafNode, const ValueType, ChildAll>
openvdb::v11_0::points::PointDataLeafNode::ChildAll
typename BaseLeaf::ChildAll ChildAll
Definition PointDataGrid.h:609
openvdb::v11_0::points::PointDataLeafNode::ValueType
T ValueType
Definition PointDataGrid.h:245
openvdb::v11_0::points::PointDataLeafNode::PointDataLeafNode
friend class PointDataLeafNode
Definition PointDataGrid.h:617
openvdb::v11_0::tree::LeafNode::DenseIter
Definition LeafNode.h:259

## ChildAllIter

template<typename T, Index Log2Dim>

using ChildAllIter

Initial value:
typename BaseLeaf::template DenseIter<
PointDataLeafNode, ValueType, ChildAll>

## ChildOff

template<typename T, Index Log2Dim>

using ChildOff = typename BaseLeaf::ChildOff

protected

## ChildOffCIter

template<typename T, Index Log2Dim>

using ChildOffCIter

Initial value:
typename BaseLeaf::template ChildIter<
MaskOffIterator, const PointDataLeafNode, ChildOff>
openvdb::v11_0::points::PointDataLeafNode::ChildOff
typename BaseLeaf::ChildOff ChildOff
Definition PointDataGrid.h:608
openvdb::v11_0::points::PointDataLeafNode::MaskOffIterator
typename NodeMaskType::OffIterator MaskOffIterator
Definition PointDataGrid.h:612
openvdb::v11_0::tree::LeafNode::ChildIter
Leaf nodes have no children, so their child iterators have no get/set accessors.
Definition LeafNode.h:250

## ChildOffIter

template<typename T, Index Log2Dim>

using ChildOffIter

Initial value:
typename BaseLeaf::template ChildIter<
MaskOffIterator, PointDataLeafNode, ChildOff>

## ChildOn

template<typename T, Index Log2Dim>

using ChildOn = typename BaseLeaf::ChildOn

protected

## ChildOnCIter

template<typename T, Index Log2Dim>

using ChildOnCIter

Initial value:
typename BaseLeaf::template ChildIter<
MaskOnIterator, const PointDataLeafNode, ChildOn>
openvdb::v11_0::points::PointDataLeafNode::ChildOn
typename BaseLeaf::ChildOn ChildOn
Definition PointDataGrid.h:607
openvdb::v11_0::points::PointDataLeafNode::MaskOnIterator
typename NodeMaskType::OnIterator MaskOnIterator
Definition PointDataGrid.h:611

## ChildOnIter

template<typename T, Index Log2Dim>

using ChildOnIter

Initial value:
typename BaseLeaf::template ChildIter<
MaskOnIterator, PointDataLeafNode, ChildOn>

## Descriptor

template<typename T, Index Log2Dim>

using Descriptor = AttributeSet::Descriptor

## IndexAllIter

template<typename T, Index Log2Dim>

using IndexAllIter = IndexIter<ValueAllCIter, NullFilter>

## IndexArray

template<typename T, Index Log2Dim>

using IndexArray = std::vector<ValueType>

## IndexOffIter

template<typename T, Index Log2Dim>

using IndexOffIter = IndexIter<ValueOffCIter, NullFilter>

## IndexOnIter

template<typename T, Index Log2Dim>

using IndexOnIter = IndexIter<ValueOnCIter, NullFilter>

## IndexVoxelIter

template<typename T, Index Log2Dim>

using IndexVoxelIter = IndexIter<ValueVoxelCIter, NullFilter>

## LeafNodeType

template<typename T, Index Log2Dim>

using LeafNodeType = PointDataLeafNode<T, Log2Dim>

## MaskDenseIterator

template<typename T, Index Log2Dim>

using MaskDenseIterator = typename NodeMaskType::DenseIterator

protected

## MaskOffIterator

template<typename T, Index Log2Dim>

using MaskOffIterator = typename NodeMaskType::OffIterator

protected

## MaskOnIterator

template<typename T, Index Log2Dim>

using MaskOnIterator = typename NodeMaskType::OnIterator

protected

## NodeMaskType

template<typename T, Index Log2Dim>

using NodeMaskType = util::NodeMask<Log2Dim>

## Ptr

template<typename T, Index Log2Dim>

using Ptr = std::shared_ptr<PointDataLeafNode>

## ValueAll

template<typename T, Index Log2Dim>

using ValueAll = typename BaseLeaf::ValueAll

## ValueAllCIter

template<typename T, Index Log2Dim>

using ValueAllCIter

Initial value:
typename BaseLeaf::template ValueIter<
MaskDenseIterator,const PointDataLeafNode,const ValueType,ValueAll>
openvdb::v11_0::points::PointDataLeafNode::ValueAll
typename BaseLeaf::ValueAll ValueAll
Definition PointDataGrid.h:600
openvdb::v11_0::points::PointDataLeafNode::MaskDenseIterator
typename NodeMaskType::DenseIterator MaskDenseIterator
Definition PointDataGrid.h:613
openvdb::v11_0::tree::LeafNode::ValueIter
Definition LeafNode.h:218

## ValueAllIter

template<typename T, Index Log2Dim>

using ValueAllIter

Initial value:
typename BaseLeaf::template ValueIter<
MaskDenseIterator, PointDataLeafNode, const ValueType, ValueAll>

## ValueOff

template<typename T, Index Log2Dim>

using ValueOff = typename BaseLeaf::ValueOff

## ValueOffCIter

template<typename T, Index Log2Dim>

using ValueOffCIter

Initial value:
typename BaseLeaf::template ValueIter<
MaskOffIterator,const PointDataLeafNode,const ValueType,ValueOff>
openvdb::v11_0::points::PointDataLeafNode::ValueOff
typename BaseLeaf::ValueOff ValueOff
Definition PointDataGrid.h:599

## ValueOffIter

template<typename T, Index Log2Dim>

using ValueOffIter

Initial value:
typename BaseLeaf::template ValueIter<
MaskOffIterator, PointDataLeafNode, const ValueType, ValueOff>

## ValueOn

template<typename T, Index Log2Dim>

using ValueOn = typename BaseLeaf::ValueOn

## ValueOnCIter

template<typename T, Index Log2Dim>

using ValueOnCIter

Initial value:
typename BaseLeaf::template ValueIter<
MaskOnIterator, const PointDataLeafNode, const ValueType, ValueOn>
openvdb::v11_0::points::PointDataLeafNode::ValueOn
typename BaseLeaf::ValueOn ValueOn
Definition PointDataGrid.h:598

## ValueOnIter

template<typename T, Index Log2Dim>

using ValueOnIter

Initial value:
typename BaseLeaf::template ValueIter<
MaskOnIterator, PointDataLeafNode, const ValueType, ValueOn>

## ValueType

template<typename T, Index Log2Dim>

using ValueType = T

## ValueTypePair

template<typename T, Index Log2Dim>

using ValueTypePair = std::pair<ValueType, ValueType>

## Constructor & Destructor Documentation

## PointDataLeafNode() [1/8]

template<typename T, Index Log2Dim>

PointDataLeafNode | ( |  | ) |

inline

Default constructor.

## ~PointDataLeafNode()

template<typename T, Index Log2Dim>

~PointDataLeafNode | ( |  | ) |

default

## PointDataLeafNode() [2/8]

template<typename T, Index Log2Dim>

PointDataLeafNode | ( | const PointDataLeafNode< T, Log2Dim > & | other | ) |

inlineexplicit

Construct using deep copy of other PointDataLeafNode.

## PointDataLeafNode() [3/8]

template<typename T, Index Log2Dim>

PointDataLeafNode | ( | const Coord & | coords,
|  | const T & | value = zeroVal<T>(),
|  | bool | active = false )

inlineexplicit

Construct using supplied origin, value and active status.

## PointDataLeafNode() [4/8]

template<typename T, Index Log2Dim>

PointDataLeafNode | ( | const PointDataLeafNode< T, Log2Dim > & | other,
|  | const Coord & | coords,
|  | const T & | value = zeroVal<T>(),
|  | bool | active = false )

inline

Construct using supplied origin, value and active status use attribute map from another PointDataLeafNode

## PointDataLeafNode() [5/8]

template<typename T, Index Log2Dim>
template<typename OtherValueType>

PointDataLeafNode | ( | const tools::PointIndexLeafNode< OtherValueType, Log2Dim > & | other | ) |

inline

## PointDataLeafNode() [6/8]

template<typename T, Index Log2Dim>
template<typename ValueType>

PointDataLeafNode | ( | const tree::LeafNode< ValueType, Log2Dim > & | other,
|  | const T & | value,
|  | TopologyCopy | )

inline

## PointDataLeafNode() [7/8]

template<typename T, Index Log2Dim>
template<typename ValueType>

PointDataLeafNode | ( | const tree::LeafNode< ValueType, Log2Dim > & | other,
|  | const T & | ,
|  | const T & | ,
|  | TopologyCopy | )

inline

## PointDataLeafNode() [8/8]

template<typename T, Index Log2Dim>

PointDataLeafNode | ( | PartialCreate | ,
|  | const Coord & | coords,
|  | const T & | value = zeroVal<T>(),
|  | bool | active = false )

inline

## Member Function Documentation

## addLeaf() [1/2]

template<typename T, Index Log2Dim>

void addLeaf | ( | PointDataLeafNode< T, Log2Dim > * |  | ) |

inline

## addLeaf() [2/2]

template<typename T, Index Log2Dim>

void addLeaf | ( | LeafNode< T, Log2Dim > * |  | ) |

inlineinherited

## addLeafAndCache() [1/2]

template<typename T, Index Log2Dim>
template<typename AccessorT>

void addLeafAndCache | ( | PointDataLeafNode< T, Log2Dim > * | ,
|  | AccessorT & | )

inline

## addLeafAndCache() [2/2]

template<typename T, Index Log2Dim>
template<typename AccessorT>

void addLeafAndCache | ( | LeafNode< T, Log2Dim > * | ,
|  | AccessorT & | )

inlineinherited

## addTile() [1/2]

template<typename T, Index Log2Dim>

void addTile | ( | Index | level,
|  | const Coord & | xyz,
|  | const ValueType & | val,
|  | bool | active )

inlineinherited

## addTile() [2/2]

template<typename T, Index Log2Dim>

void addTile | ( | Index | offset,
|  | const ValueType & | val,
|  | bool | active )

inlineinherited

## addTileAndCache() [1/2]

template<Index Log2Dim>
template<typename AccessorT>

void addTileAndCache | ( | Index | level,
|  | const Coord & | xyz,
|  | bool | val,
|  | bool | active,
|  | AccessorT & | )

inlineinherited

## addTileAndCache() [2/2]

template<typename T, Index Log2Dim>
template<typename AccessorT>

void addTileAndCache | ( | Index | level,
|  | const Coord & | xyz,
|  | const ValueType & | val,
|  | bool | active,
|  | AccessorT & | )

inlineinherited

## allocate()

template<typename T, Index Log2Dim>

bool allocate | ( |  | ) |

inlineinherited

Allocate memory for this node's buffer if it has not already been allocated.

## appendAttribute()

template<typename T, Index Log2Dim>

AttributeArray::Ptr appendAttribute | ( | const Descriptor & | expected,
|  | Descriptor::Ptr & | replacement,
|  | const size_t | pos,
|  | const Index | strideOrTotalSize = 1,
|  | const bool | constantStride = true,
|  | const Metadata * | metadata = nullptr,
|  | const AttributeArray::ScopedRegistryLock * | lock = nullptr )

inline

Append an attribute to the leaf.

Parameters

  expected | Existing descriptor is expected to match this parameter.
  replacement | New descriptor to replace the existing one.
  pos | Index of the new attribute in the descriptor replacement.
  strideOrTotalSize | Stride of the attribute array (if constantStride), total size otherwise
  constantStride | if `false`, stride is interpreted as total size of the array
  metadata | optional default value metadata
  lock | an optional scoped registry lock to avoid contention

## assertNonmodifiable()

template<typename T, Index Log2Dim>

void assertNonmodifiable | ( |  | ) |

inline

## assertNonModifiableUnlessZero()

template<typename T, Index Log2Dim>

void assertNonModifiableUnlessZero | ( | const ValueType & | value | ) |

inline

## attributeArray() [1/4]

template<typename T, Index Log2Dim>

AttributeArray & attributeArray | ( | const Name & | attributeName | ) |

inline

Read-write attribute array reference from name.

}

Attribute arrays can be shared across leaf nodes, so non-const access will deep-copy the array to make it unique. Always prefer accessing const arrays where possible to eliminate this copying. {

## attributeArray() [2/4]

template<typename T, Index Log2Dim>

const AttributeArray & attributeArray | ( | const Name & | attributeName | ) | const

inline

## attributeArray() [3/4]

template<typename T, Index Log2Dim>

AttributeArray & attributeArray | ( | const size_t | pos | ) |

inline

Read-write attribute array reference from index.

Attribute arrays can be shared across leaf nodes, so non-const access will deep-copy the array to make it unique. Always prefer accessing const arrays where possible to eliminate this copying. {

## attributeArray() [4/4]

template<typename T, Index Log2Dim>

const AttributeArray & attributeArray | ( | const size_t | pos | ) | const

inline

## attributeSet()

template<typename T, Index Log2Dim>

const AttributeSet & attributeSet | ( |  | ) | const

inline

Retrieve the attribute set.

## beginChildAll() [1/2]

template<typename T, Index Log2Dim>

ChildAllIter beginChildAll | ( |  | ) |

inline

## beginChildAll() [2/2]

template<typename T, Index Log2Dim>

ChildAllCIter beginChildAll | ( |  | ) | const

inline

## beginChildOff() [1/2]

template<typename T, Index Log2Dim>

ChildOffIter beginChildOff | ( |  | ) |

inline

## beginChildOff() [2/2]

template<typename T, Index Log2Dim>

ChildOffCIter beginChildOff | ( |  | ) | const

inline

## beginChildOn() [1/2]

template<typename T, Index Log2Dim>

ChildOnIter beginChildOn | ( |  | ) |

inline

## beginChildOn() [2/2]

template<typename T, Index Log2Dim>

ChildOnCIter beginChildOn | ( |  | ) | const

inline

## beginIndex() [1/2]

template<typename T, Index Log2Dim>
template<typename IterT, typename FilterT>

IndexIter< IterT, FilterT > beginIndex | ( | const FilterT & | filter | ) | const

## beginIndex() [2/2]

template<typename T, Index Log2Dim>
template<typename ValueIterT, typename FilterT>

IndexIter< ValueIterT, FilterT > beginIndex | ( | const FilterT & | filter | ) | const

inline

## beginIndexAll() [1/2]

template<typename T, Index Log2Dim>

IndexAllIter beginIndexAll | ( |  | ) | const

inline

Leaf index iterator.

## beginIndexAll() [2/2]

template<typename T, Index Log2Dim>
template<typename FilterT>

IndexIter< ValueAllCIter, FilterT > beginIndexAll | ( | const FilterT & | filter | ) | const

inline

Filtered leaf index iterator.

## beginIndexOff() [1/2]

template<typename T, Index Log2Dim>

IndexOffIter beginIndexOff | ( |  | ) | const

inline

## beginIndexOff() [2/2]

template<typename T, Index Log2Dim>
template<typename FilterT>

IndexIter< ValueOffCIter, FilterT > beginIndexOff | ( | const FilterT & | filter | ) | const

inline

## beginIndexOn() [1/2]

template<typename T, Index Log2Dim>

IndexOnIter beginIndexOn | ( |  | ) | const

inline

## beginIndexOn() [2/2]

template<typename T, Index Log2Dim>
template<typename FilterT>

IndexIter< ValueOnCIter, FilterT > beginIndexOn | ( | const FilterT & | filter | ) | const

inline

## beginIndexVoxel() [1/2]

template<typename T, Index Log2Dim>

PointDataLeafNode< T, Log2Dim >::IndexVoxelIter beginIndexVoxel | ( | const Coord & | ijk | ) | const

inline

Leaf index iterator from voxel.

## beginIndexVoxel() [2/2]

template<typename T, Index Log2Dim>
template<typename FilterT>

IndexIter< ValueVoxelCIter, FilterT > beginIndexVoxel | ( | const Coord & | ijk,
|  | const FilterT & | filter ) const

inline

Filtered leaf index iterator from voxel.

## beginValueAll() [1/2]

template<typename T, Index Log2Dim>

ValueAllIter beginValueAll | ( |  | ) |

inline

## beginValueAll() [2/2]

template<typename T, Index Log2Dim>

ValueAllCIter beginValueAll | ( |  | ) | const

inline

## beginValueOff() [1/2]

template<typename T, Index Log2Dim>

ValueOffIter beginValueOff | ( |  | ) |

inline

## beginValueOff() [2/2]

template<typename T, Index Log2Dim>

ValueOffCIter beginValueOff | ( |  | ) | const

inline

## beginValueOn() [1/2]

template<typename T, Index Log2Dim>

ValueOnIter beginValueOn | ( |  | ) |

inline

## beginValueOn() [2/2]

template<typename T, Index Log2Dim>

ValueOnCIter beginValueOn | ( |  | ) | const

inline

## beginValueVoxel()

template<typename T, Index Log2Dim>

ValueVoxelCIter beginValueVoxel | ( | const Coord & | ijk | ) | const

inline

Leaf value voxel iterator.

## buffer() [1/2]

template<typename T, Index Log2Dim>

Buffer & buffer | ( |  | ) |

inlineinherited

## buffer() [2/2]

template<typename T, Index Log2Dim>

const Buffer & buffer | ( |  | ) | const

inlineinherited

## buffers()

template<typename T, Index Log2Dim>

Index buffers | ( |  | ) | const

inline

## cbeginChildAll()

template<typename T, Index Log2Dim>

ChildAllCIter cbeginChildAll | ( |  | ) | const

inline

## cbeginChildOff()

template<typename T, Index Log2Dim>

ChildOffCIter cbeginChildOff | ( |  | ) | const

inline

## cbeginChildOn()

template<typename T, Index Log2Dim>

ChildOnCIter cbeginChildOn | ( |  | ) | const

inline

## cbeginValueAll()

template<typename T, Index Log2Dim>

ValueAllCIter cbeginValueAll | ( |  | ) | const

inline

## cbeginValueOff()

template<typename T, Index Log2Dim>

ValueOffCIter cbeginValueOff | ( |  | ) | const

inline

## cbeginValueOn()

template<typename T, Index Log2Dim>

ValueOnCIter cbeginValueOn | ( |  | ) | const

inline

## cendChildAll()

template<typename T, Index Log2Dim>

ChildAllCIter cendChildAll | ( |  | ) | const

inline

## cendChildOff()

template<typename T, Index Log2Dim>

ChildOffCIter cendChildOff | ( |  | ) | const

inline

## cendChildOn()

template<typename T, Index Log2Dim>

ChildOnCIter cendChildOn | ( |  | ) | const

inline

## cendValueAll()

template<typename T, Index Log2Dim>

ValueAllCIter cendValueAll | ( |  | ) | const

inline

## cendValueOff()

template<typename T, Index Log2Dim>

ValueOffCIter cendValueOff | ( |  | ) | const

inline

## cendValueOn()

template<typename T, Index Log2Dim>

ValueOnCIter cendValueOn | ( |  | ) | const

inline

## childCount()

template<typename T, Index Log2Dim>

Index32 childCount | ( |  | ) |

inlinestaticinherited

Return the child count for this node, which is zero.

## clearAttributes()

template<typename T, Index Log2Dim>

void clearAttributes | ( | const bool | updateValueMask = true,
|  | const AttributeArray::ScopedRegistryLock * | lock = nullptr )

inline

Clear the attribute set.

## clip()

template<typename T, Index Log2Dim>

void clip | ( | const CoordBBox & | ,
|  | const ValueType & | value )

inline

## combine() [1/3]

template<Index Log2Dim>
template<typename CombineOp>

void combine | ( | bool | value,
|  | bool | valueIsActive,
|  | CombineOp & | op )

inlineinherited

## combine() [2/3]

template<Index Log2Dim>
template<typename CombineOp>

void combine | ( | const LeafNode< T, Log2Dim > & | other,
|  | CombineOp & | op )

inlineinherited

## combine() [3/3]

template<typename T, Index Log2Dim>
template<typename CombineOp>

void combine | ( | const ValueType & | value,
|  | bool | valueIsActive,
|  | CombineOp & | op )

inlineinherited

## combine2() [1/4]

template<Index Log2Dim>
template<typename CombineOp, typename OtherNodeT>

void combine2 | ( | bool | value,
|  | const OtherNodeT & | other,
|  | bool | valueIsActive,
|  | CombineOp & | op )

inlineinherited

## combine2() [2/4]

template<Index Log2Dim>
template<typename CombineOp, typename OtherNodeT>

void combine2 | ( | const LeafNode< T, Log2Dim > & | b0,
|  | const OtherNodeT & | b1,
|  | CombineOp & | op )

inlineinherited

## combine2() [3/4]

template<Index Log2Dim>
template<typename CombineOp, typename OtherType>

void combine2 | ( | const LeafNode< T, Log2Dim > & | other,
|  | const OtherType & | value,
|  | bool | valueIsActive,
|  | CombineOp & | op )

inlineinherited

## combine2() [4/4]

template<typename T, Index Log2Dim>
template<typename CombineOp, typename OtherNodeT>

void combine2 | ( | const ValueType & | value,
|  | const OtherNodeT & | other,
|  | bool | valueIsActive,
|  | CombineOp & | op )

inlineinherited

## compactAttributes()

template<typename T, Index Log2Dim>

void compactAttributes | ( |  | ) |

inline

Compact all attributes in attribute set.

## constAttributeArray() [1/2]

template<typename T, Index Log2Dim>

const AttributeArray & constAttributeArray | ( | const Name & | attributeName | ) | const

inline

## constAttributeArray() [2/2]

template<typename T, Index Log2Dim>

const AttributeArray & constAttributeArray | ( | const size_t | pos | ) | const

inline

## coordToOffset()

template<Index Log2Dim>

Index coordToOffset | ( | const Coord & | xyz | ) |

inlinestaticinherited

Return the linear table offset of the given global or local coordinates.

## copyFromDense() [1/2]

template<Index Log2Dim>
template<typename DenseT>

void copyFromDense | ( | const CoordBBox & | bbox,
|  | const DenseT & | dense,
|  | bool | background,
|  | bool | tolerance )

inlineinherited

## copyFromDense() [2/2]

template<typename T, Index Log2Dim>
template<typename DenseT>

void copyFromDense | ( | const CoordBBox & | bbox,
|  | const DenseT & | dense,
|  | const ValueType & | background,
|  | const ValueType & | tolerance )

inlineinherited

Copy from a dense grid into this node the values of the voxels that lie within a given bounding box.

Only values that are different (by more than the given tolerance) from the background value will be active. Other values are inactive and truncated to the background value.

Parameters

  bbox | inclusive bounding box of the voxels to be copied into this node
  dense | dense grid with a stride in z of one (see tools::Dense in tools/Dense.h for the required API)
  background | background value of the tree that this node belongs to
  tolerance | tolerance within which a value equals the background value

Note
  bbox is assumed to be identical to or contained in the coordinate domains of both the dense grid and this node, i.e., no bounds checking is performed.
  Consider using tools::CopyFromDense in tools/Dense.h instead of calling this method directly.

## copyToDense()

template<Index Log2Dim>
template<typename DenseT>

void copyToDense | ( | const CoordBBox & | bbox,
|  | DenseT & | dense ) const

inlineinherited

Copy into a dense grid the values of the voxels that lie within a given bounding box.

Parameters

  bbox | inclusive bounding box of the voxels to be copied into the dense grid
  dense | dense grid with a stride in z of one (see tools::Dense in tools/Dense.h for the required API)

Note
  bbox is assumed to be identical to or contained in the coordinate domains of both the dense grid and this node, i.e., no bounds checking is performed.
  Consider using tools::CopyToDense in tools/Dense.h instead of calling this method directly.

## denseFill()

template<typename T, Index Log2Dim>

void denseFill | ( | const CoordBBox & | bbox,
|  | const ValueType & | value,
|  | bool | active = true )

inlineinherited

Set all voxels within an axis-aligned box to the specified value and active state.

## dim()

template<typename T, Index Log2Dim>

Index dim | ( |  | ) |

inlinestaticinherited

Return the number of voxels in each coordinate dimension.

## dropAttributes()

template<typename T, Index Log2Dim>

void dropAttributes | ( | const std::vector< size_t > & | pos,
|  | const Descriptor & | expected,
|  | Descriptor::Ptr & | replacement )

inline

Drop list of attributes.

Parameters

  pos | vector of attribute indices to drop
  expected | Existing descriptor is expected to match this parameter.
  replacement | New descriptor to replace the existing one.

## endChildAll() [1/2]

template<typename T, Index Log2Dim>

ChildAllIter endChildAll | ( |  | ) |

inline

## endChildAll() [2/2]

template<typename T, Index Log2Dim>

ChildAllCIter endChildAll | ( |  | ) | const

inline

## endChildOff() [1/2]

template<typename T, Index Log2Dim>

ChildOffIter endChildOff | ( |  | ) |

inline

## endChildOff() [2/2]

template<typename T, Index Log2Dim>

ChildOffCIter endChildOff | ( |  | ) | const

inline

## endChildOn() [1/2]

template<typename T, Index Log2Dim>

ChildOnIter endChildOn | ( |  | ) |

inline

## endChildOn() [2/2]

template<typename T, Index Log2Dim>

ChildOnCIter endChildOn | ( |  | ) | const

inline

## endValueAll() [1/2]

template<typename T, Index Log2Dim>

ValueAllIter endValueAll | ( |  | ) |

inline

## endValueAll() [2/2]

template<typename T, Index Log2Dim>

ValueAllCIter endValueAll | ( |  | ) | const

inline

## endValueOff() [1/2]

template<typename T, Index Log2Dim>

ValueOffIter endValueOff | ( |  | ) |

inline

## endValueOff() [2/2]

template<typename T, Index Log2Dim>

ValueOffCIter endValueOff | ( |  | ) | const

inline

## endValueOn() [1/2]

template<typename T, Index Log2Dim>

ValueOnIter endValueOn | ( |  | ) |

inline

## endValueOn() [2/2]

template<typename T, Index Log2Dim>

ValueOnCIter endValueOn | ( |  | ) | const

inline

## evalActiveBoundingBox()

template<typename T, Index Log2Dim>

void evalActiveBoundingBox | ( | CoordBBox & | bbox,
|  | bool | visitVoxels = true ) const

inline

## evalNodeOrigin()

template<typename T, Index Log2Dim>

void evalNodeOrigin | ( | Coord & | xyz | ) |

inlinestaticprotectedinherited

Compute the origin of the leaf node that contains the voxel with the given coordinates.

## fill() [1/3]

template<typename T, Index Log2Dim>

void fill | ( | const CoordBBox & | bbox,
|  | const ValueType & | value,
|  | bool | active )

inline

## fill() [2/3]

template<typename T, Index Log2Dim>

void fill | ( | const ValueType & | value,
|  | bool | active )

inline

## fill() [3/3]

template<typename T, Index Log2Dim>

void fill | ( | const ValueType & | value | ) |

inline

## getChildDim()

template<typename T, Index Log2Dim>

Index getChildDim | ( |  | ) |

inlinestaticinherited

Return the dimension of child nodes of this LeafNode, which is one for voxels.

## getFirstValue()

template<typename T, Index Log2Dim>

const ValueType & getFirstValue | ( |  | ) | const

inlineinherited

Return a const reference to the first value in the buffer.

Note
  Though it is potentially risky you can convert this to a non-const pointer by means of const_case<ValueType*>&.

## getLastValue()

template<typename T, Index Log2Dim>

const ValueType & getLastValue | ( |  | ) | const

inlineinherited

Return a const reference to the last value in the buffer.

## getLevel()

template<typename T, Index Log2Dim>

Index getLevel | ( |  | ) |

inlinestaticinherited

Return the level of this node, which by definition is zero for LeafNodes.

## getNodeBoundingBox()

template<typename T, Index Log2Dim>

CoordBBox getNodeBoundingBox | ( |  | ) | const

inline

Return the bounding box of this node, i.e., the full index space spanned by this leaf node.

## getNodeLog2Dims()

template<typename T, Index Log2Dim>

void getNodeLog2Dims | ( | std::vector< Index > & | dims | ) |

inlinestaticinherited

Append the Log2Dim of this LeafNode to the specified vector.

## getNodes()

template<typename T, Index Log2Dim>
template<typename ArrayT>

void getNodes | ( | ArrayT & |  | ) | const

inlineinherited

## getOrigin() [1/2]

template<typename T, Index Log2Dim>

void getOrigin | ( | Coord & | origin | ) | const

inlineinherited

## getOrigin() [2/2]

template<typename T, Index Log2Dim>

void getOrigin | ( | Int32 & | x,
|  | Int32 & | y,
|  | Int32 & | z ) const

inlineinherited

## getValue() [1/3]

template<Index Log2Dim>

const bool & getValue | ( | const Coord & | xyz | ) | const

inlineinherited

Return the value of the voxel at the given coordinates.

## getValue() [2/3]

template<typename T, Index Log2Dim>
template<typename AccessorT>

const ValueType & getValue | ( | const Coord & | xyz,
|  | bool & | state,
|  | int & | level,
|  | AccessorT & | ) const

inlineinherited

Return the value of the voxel at the given coordinates and return its active state and level (i.e., 0) in state and level.

Note
  Used internally by ValueAccessor.

## getValue() [3/3]

template<Index Log2Dim>

const bool & getValue | ( | Index | offset | ) | const

inlineinherited

Return the value of the voxel at the given linear offset.

## getValueAndCache()

template<typename T, Index Log2Dim>
template<typename AccessorT>

const ValueType & getValueAndCache | ( | const Coord & | xyz,
|  | AccessorT & | ) const

inlineinherited

Return the value of the voxel at the given coordinates.

Note
  Used internally by ValueAccessor.

## getValueLevel()

template<typename T, Index Log2Dim>

Index getValueLevel | ( | const Coord & |  | ) |

inlinestaticinherited

Return the level (i.e., 0) at which leaf node values reside.

## getValueLevelAndCache()

template<typename T, Index Log2Dim>
template<typename AccessorT>

Index getValueLevelAndCache | ( | const Coord & | ,
|  | AccessorT & | )

inlinestaticinherited

Return the LEVEL (=0) at which leaf node values reside.

Note
  Used internally by ValueAccessor (note last argument is a dummy).

## getValueMask() [1/2]

template<typename T, Index Log2Dim>

NodeMaskType & getValueMask | ( |  | ) |

inlineinherited

## getValueMask() [2/2]

template<typename T, Index Log2Dim>

const NodeMaskType & getValueMask | ( |  | ) | const

inlineinherited

## groupHandle() [1/2]

template<typename T, Index Log2Dim>

GroupHandle groupHandle | ( | const AttributeSet::Descriptor::GroupIndex & | index | ) | const

inline

}

Read-only group handle from group index

## groupHandle() [2/2]

template<typename T, Index Log2Dim>

GroupHandle groupHandle | ( | const Name & | group | ) | const

inline

Read-only group handle from group name.

## groupPointCount()

template<typename T, Index Log2Dim>

Index64 groupPointCount | ( | const Name & | groupName | ) | const

inline

Compute the point count in a specific group for the leaf.

## groupWriteHandle() [1/2]

template<typename T, Index Log2Dim>

GroupWriteHandle groupWriteHandle | ( | const AttributeSet::Descriptor::GroupIndex & | index | ) |

inline

Read-write group handle from group index.

## groupWriteHandle() [2/2]

template<typename T, Index Log2Dim>

GroupWriteHandle groupWriteHandle | ( | const Name & | name | ) |

inline

Read-write group handle from group name.

## hasActiveTiles()

template<typename T, Index Log2Dim>

bool hasActiveTiles | ( |  | ) |

inlinestaticinherited

Return `false` since leaf nodes never contain tiles.

## hasAttribute() [1/2]

template<typename T, Index Log2Dim>

bool hasAttribute | ( | const Name & | attributeName | ) | const

inline

Returns `true` if an attribute with this name exists.

Parameters

  attributeName | Name of the attribute

## hasAttribute() [2/2]

template<typename T, Index Log2Dim>

bool hasAttribute | ( | const size_t | pos | ) | const

inline

Returns `true` if an attribute with this index exists.

Parameters

  pos | Index of the attribute

## hasSameTopology() [1/2]

template<typename T, Index Log2Dim>
template<typename OtherType, Index OtherLog2Dim>

bool hasSameTopology | ( | const PointDataLeafNode< OtherType, OtherLog2Dim > * | other | ) | const

inline

Return `true` if the given node (which may have a different `ValueType` than this node) has the same active value topology as this node.

## hasSameTopology() [2/2]

template<Index Log2Dim>
template<typename OtherType, Index OtherLog2Dim>

bool hasSameTopology | ( | const LeafNode< OtherType, OtherLog2Dim > * | other | ) | const

inlineinherited

Return `true` if the given node (which may have a different `ValueType` than this node) has the same active value topology as this node.

## initializeAttributes()

template<typename T, Index Log2Dim>

void initializeAttributes | ( | const Descriptor::Ptr & | descriptor,
|  | const Index | arrayLength,
|  | const AttributeArray::ScopedRegistryLock * | lock = nullptr )

inline

Create a new attribute set. Existing attributes will be removed.

## isAllocated()

template<typename T, Index Log2Dim>

bool isAllocated | ( |  | ) | const

inlineinherited

Return `true` if memory for this node's buffer has been allocated.

## isChildMaskOff() [1/2]

template<typename T, Index Log2Dim>

bool isChildMaskOff | ( |  | ) | const

inlineinherited

## isChildMaskOff() [2/2]

template<typename T, Index Log2Dim>

bool isChildMaskOff | ( | Index |  | ) | const

inlineinherited

## isChildMaskOn()

template<typename T, Index Log2Dim>

bool isChildMaskOn | ( | Index |  | ) | const

inlineinherited

## isConstant() [1/2]

template<typename T, Index Log2Dim>

bool isConstant | ( | ValueType & | firstValue,
|  | bool & | state,
|  | const ValueType & | tolerance = zeroVal<ValueType>() ) const

inlineinherited

Return `true` if all of this node's values have the same active state and are in the range this->getFirstValue() +/- tolerance.

Parameters

  firstValue | Is updated with the first value of this leaf node.
  state | Is updated with the state of all values IF method returns `true`. Else the value is undefined!
  tolerance | The tolerance used to determine if values are approximately equal to the for value.

## isConstant() [2/2]

template<typename T, Index Log2Dim>

bool isConstant | ( | ValueType & | minValue,
|  | ValueType & | maxValue,
|  | bool & | state,
|  | const ValueType & | tolerance = zeroVal<ValueType>() ) const

inlineinherited

Return `true` if all of this node's values have the same active state and the range (maxValue - minValue) < tolerance.

Parameters

  minValue | Is updated with the minimum of all values IF method returns `true`. Else the value is undefined!
  maxValue | Is updated with the maximum of all values IF method returns `true`. Else the value is undefined!
  state | Is updated with the state of all values IF method returns `true`. Else the value is undefined!
  tolerance | The tolerance used to determine if values are approximately constant.

## isDense()

template<typename T, Index Log2Dim>

bool isDense | ( |  | ) | const

inlineinherited

Return `true` if this node contains only active voxels.

## isEmpty()

template<typename T, Index Log2Dim>

bool isEmpty | ( |  | ) | const

inlineinherited

Return `true` if this node has no active voxels.

## isInactive()

template<typename T, Index Log2Dim>

bool isInactive | ( |  | ) | const

inlineinherited

Return `true` if all of this node's values are inactive.

## isValueMaskOff() [1/2]

template<typename T, Index Log2Dim>

bool isValueMaskOff | ( |  | ) | const

inlineinherited

## isValueMaskOff() [2/2]

template<typename T, Index Log2Dim>

bool isValueMaskOff | ( | Index | n | ) | const

inlineinherited

## isValueMaskOn() [1/2]

template<typename T, Index Log2Dim>

bool isValueMaskOn | ( |  | ) | const

inlineinherited

## isValueMaskOn() [2/2]

template<typename T, Index Log2Dim>

bool isValueMaskOn | ( | Index | n | ) | const

inlineinherited

## isValueOn() [1/2]

template<typename T, Index Log2Dim>

bool isValueOn | ( | const Coord & | xyz | ) | const

inlineinherited

Return `true` if the voxel at the given coordinates is active.

## isValueOn() [2/2]

template<typename T, Index Log2Dim>

bool isValueOn | ( | Index | offset | ) | const

inlineinherited

Return `true` if the voxel at the given offset is active.

## isValueOnAndCache()

template<typename T, Index Log2Dim>
template<typename AccessorT>

bool isValueOnAndCache | ( | const Coord & | xyz,
|  | AccessorT & | ) const

inlineinherited

Return `true` if the voxel at the given coordinates is active.

Note
  Used internally by ValueAccessor.

## leafCount()

template<typename T, Index Log2Dim>

Index32 leafCount | ( |  | ) |

inlinestaticinherited

Return the leaf count for this node, which is one.

## log2dim()

template<typename T, Index Log2Dim>

Index log2dim | ( |  | ) |

inlinestaticinherited

Return log2 of the dimension of this LeafNode, e.g. 3 if dimensions are 8^3.

## medianAll()

template<typename T, Index Log2Dim>

bool medianAll | ( | ValueType * | tmp = nullptr | ) | const

inlineinherited

Computes the median value of all the active AND inactive voxels in this node.

Returns
  The median value of all values in this node.

Parameters

  tmp | Optional temporary storage that can hold at least NUM_VALUES values Use of this temporary storage can improve performance when this method is called multiple times.

Note
  If tmp = this->buffer().data() then the median value is computed very efficiently (in place) but the voxel values in this node are re-shuffled!

Warning
  If tmp != nullptr then it is the responsibility of the client code that it points to enough memory to hold NUM_VALUES elements of type ValueType.

## medianOff()

template<typename T, Index Log2Dim>

Index medianOff | ( | ValueType & | value,
|  | ValueType * | tmp = nullptr ) const

inlineinherited

Computes the median value of all the inactive voxels in this node.

Returns
  The number of inactive voxels.

Parameters

  value | If the return value is non zero value is updated with the median value.
  tmp | Optional temporary storage that can hold at least as many values as there are inactive voxels in this node. Use of this temporary storage can improve performance when this method is called multiple times.

Warning
  If tmp != nullptr then it is the responsibility of the client code that it points to enough memory to hold the number of inactive voxels of type ValueType.

## medianOn()

template<typename T, Index Log2Dim>

Index medianOn | ( | ValueType & | value,
|  | ValueType * | tmp = nullptr ) const

inlineinherited

Computes the median value of all the active voxels in this node.

Returns
  The number of active voxels.

Parameters

  value | If the return value is non zero value is updated with the median value.
  tmp | Optional temporary storage that can hold at least as many values as there are active voxels in this node. Use of this temporary storage can improve performance when this method is called multiple times.

Warning
  If tmp != nullptr then it is the responsibility of the client code that it points to enough memory to hold the number of active voxels of type ValueType.

## memUsage()

template<typename T, Index Log2Dim>

Index64 memUsage | ( |  | ) | const

inline

## memUsageIfLoaded()

template<typename T, Index Log2Dim>

Index64 memUsageIfLoaded | ( |  | ) | const

inline

## merge() [1/5]

template<Index Log2Dim>
template<MergePolicy Policy>

void merge | ( | bool | tileValue,
|  | bool | tileActive )

inlineinherited

## merge() [2/5]

template<typename T, Index Log2Dim>
template<MergePolicy Policy>

void merge | ( | const LeafNode< T, Log2Dim > & | other | ) |

inlineinherited

## merge() [3/5]

template<Index Log2Dim>
template<MergePolicy Policy>

void merge | ( | const LeafNode< T, Log2Dim > & | other,
|  | bool | ,
|  | bool | )

inlineinherited

## merge() [4/5]

template<typename T, Index Log2Dim>
template<MergePolicy Policy>

void merge | ( | const LeafNode< T, Log2Dim > & | other,
|  | const ValueType & | ,
|  | const ValueType & | )

inlineinherited

## merge() [5/5]

template<typename T, Index Log2Dim>
template<MergePolicy Policy>

void merge | ( | const ValueType & | tileValue,
|  | bool | tileActive )

inlineinherited

## modifyValue() [1/2]

template<typename T, Index Log2Dim>
template<typename ModifyOp>

void modifyValue | ( | const Coord & | ,
|  | const ModifyOp & | )

inline

## modifyValue() [2/2]

template<typename T, Index Log2Dim>
template<typename ModifyOp>

void modifyValue | ( | Index | ,
|  | const ModifyOp & | )

inline

## modifyValueAndActiveState()

template<typename T, Index Log2Dim>
template<typename ModifyOp>

void modifyValueAndActiveState | ( | const Coord & | ,
|  | const ModifyOp & | )

inline

## modifyValueAndActiveStateAndCache()

template<typename T, Index Log2Dim>
template<typename ModifyOp, typename AccessorT>

void modifyValueAndActiveStateAndCache | ( | const Coord & | ,
|  | const ModifyOp & | ,
|  | AccessorT & | )

inline

## modifyValueAndCache()

template<typename T, Index Log2Dim>
template<typename ModifyOp, typename AccessorT>

void modifyValueAndCache | ( | const Coord & | xyz,
|  | const ModifyOp & | op,
|  | AccessorT & | )

inlineinherited

Apply a functor to the value of the voxel at the given coordinates and mark the voxel as active.

Note
  Used internally by ValueAccessor.

## negate()

template<typename T, Index Log2Dim>

void negate | ( |  | ) |

inline

## nodeCount()

template<typename T, Index Log2Dim>

void nodeCount | ( | std::vector< Index32 > & |  | ) | const

inlineinherited

no-op

## nonLeafCount()

template<typename T, Index Log2Dim>

Index32 nonLeafCount | ( |  | ) |

inlinestaticinherited

Return the non-leaf count for this node, which is zero.

## numValues()

template<typename T, Index Log2Dim>

Index numValues | ( |  | ) |

inlinestaticinherited

Return the total number of voxels represented by this LeafNode.

## offLeafVoxelCount()

template<typename T, Index Log2Dim>

Index64 offLeafVoxelCount | ( |  | ) | const

inlineinherited

## offPointCount()

template<typename T, Index Log2Dim>

Index64 offPointCount | ( |  | ) | const

inline

Compute the total inactive (off) point count for the leaf.

## offsetToGlobalCoord()

template<Index Log2Dim>

Coord offsetToGlobalCoord | ( | Index | n | ) | const

inlineinherited

Return the global coordinates for a linear table offset.

## offsetToLocalCoord()

template<Index Log2Dim>

Coord offsetToLocalCoord | ( | Index | n | ) |

inlinestaticinherited

Return the local coordinates for a linear table offset, where offset 0 has coordinates (0, 0, 0).

## offTileCount()

template<typename T, Index Log2Dim>

Index64 offTileCount | ( |  | ) |

inlinestaticinherited

## offVoxelCount()

template<typename T, Index Log2Dim>

Index64 offVoxelCount | ( |  | ) | const

inlineinherited

Return the number of voxels marked Off.

## onLeafVoxelCount()

template<typename T, Index Log2Dim>

Index64 onLeafVoxelCount | ( |  | ) | const

inlineinherited

## onPointCount()

template<typename T, Index Log2Dim>

Index64 onPointCount | ( |  | ) | const

inline

Compute the total active (on) point count for the leaf.

## onTileCount()

template<typename T, Index Log2Dim>

Index64 onTileCount | ( |  | ) |

inlinestaticinherited

## onVoxelCount()

template<typename T, Index Log2Dim>

Index64 onVoxelCount | ( |  | ) | const

inlineinherited

Return the number of voxels marked On.

## operator!=() [1/2]

template<typename T, Index Log2Dim>

bool operator!= | ( | const PointDataLeafNode< T, Log2Dim > & | other | ) | const

inline

## operator!=() [2/2]

template<Index Log2Dim>

bool operator!= | ( | const LeafNode< T, Log2Dim > & | other | ) | const

inlineinherited

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

template<typename T, Index Log2Dim>

bool operator== | ( | const PointDataLeafNode< T, Log2Dim > & | other | ) | const

inline

Check for buffer, state and origin equivalence first. If this returns true, do a deeper comparison on the attribute set to check

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

template<Index Log2Dim>

bool operator== | ( | const LeafNode< T, Log2Dim > & | other | ) | const

inlineinherited

Check for buffer, state and origin equivalence.

## origin()

template<typename T, Index Log2Dim>

const Coord & origin | ( |  | ) | const

inlineinherited

Return the grid index coordinates of this node's local origin.

## pointCount()

template<typename T, Index Log2Dim>

Index64 pointCount | ( |  | ) | const

inline

Compute the total point count for the leaf.

## probeConstLeaf()

template<typename T, Index Log2Dim>

const PointDataLeafNode * probeConstLeaf | ( | const Coord & |  | ) | const

inline

Return a const pointer to this node.

## probeConstLeafAndCache()

template<typename T, Index Log2Dim>
template<typename AccessorT>

const PointDataLeafNode * probeConstLeafAndCache | ( | const Coord & | ,
|  | AccessorT & | ) const

inline

## probeConstNode()

template<typename T, Index Log2Dim>
template<typename NodeT>

const NodeT * probeConstNode | ( | const Coord & |  | ) | const

inlineinherited

## probeConstNodeAndCache()

template<typename T, Index Log2Dim>
template<typename NodeT, typename AccessorT>

const NodeT * probeConstNodeAndCache | ( | const Coord & | ,
|  | AccessorT & | ) const

inline

## probeLeaf() [1/2]

template<typename T, Index Log2Dim>

PointDataLeafNode * probeLeaf | ( | const Coord & |  | ) |

inline

## probeLeaf() [2/2]

template<typename T, Index Log2Dim>

const PointDataLeafNode * probeLeaf | ( | const Coord & |  | ) | const

inline

## probeLeafAndCache() [1/2]

template<typename T, Index Log2Dim>
template<typename AccessorT>

PointDataLeafNode * probeLeafAndCache | ( | const Coord & | ,
|  | AccessorT & | )

inline

## probeLeafAndCache() [2/2]

template<typename T, Index Log2Dim>
template<typename AccessorT>

const PointDataLeafNode * probeLeafAndCache | ( | const Coord & | ,
|  | AccessorT & | ) const

inline

## probeNode()

template<typename T, Index Log2Dim>
template<typename NodeT>

NodeT * probeNode | ( | const Coord & |  | ) |

inlineinherited

## probeNodeAndCache()

template<typename T, Index Log2Dim>
template<typename NodeT, typename AccessorT>

NodeT * probeNodeAndCache | ( | const Coord & | ,
|  | AccessorT & | )

inline

## probeValue() [1/2]

template<typename T, Index Log2Dim>

bool probeValue | ( | const Coord & | xyz,
|  | ValueType & | val ) const

inlineinherited

Return `true` if the voxel at the given coordinates is active.

Parameters

  | xyz | the coordinates of the voxel to be probed
  [out] | val | the value of the voxel at the given coordinates

## probeValue() [2/2]

template<typename T, Index Log2Dim>

bool probeValue | ( | Index | offset,
|  | ValueType & | val ) const

inlineinherited

Return `true` if the voxel at the given offset is active.

Parameters

  | offset | the linear offset of the voxel to be probed
  [out] | val | the value of the voxel at the given coordinates

## probeValueAndCache()

template<typename T, Index Log2Dim>
template<typename AccessorT>

bool probeValueAndCache | ( | const Coord & | xyz,
|  | ValueType & | val,
|  | AccessorT & | ) const

inlineinherited

Return `true` if the voxel at the given coordinates is active and return the voxel value in val.

Note
  Used internally by ValueAccessor.

## prune()

template<typename T, Index Log2Dim>

void prune | ( | const ValueType & | = zeroVal<ValueType>() | ) |

inlineinherited

This function exists only to enable template instantiation.

## readBuffers() [1/2]

template<typename T, Index Log2Dim>

void readBuffers | ( | std::istream & | is,
|  | bool | fromHalf = false )

inline

## readBuffers() [2/2]

template<typename T, Index Log2Dim>

void readBuffers | ( | std::istream & | is,
|  | const CoordBBox & | ,
|  | bool | fromHalf = false )

inline

## readTopology()

template<typename T, Index Log2Dim>

void readTopology | ( | std::istream & | is,
|  | bool | fromHalf = false )

inline

## renameAttributes()

template<typename T, Index Log2Dim>

void renameAttributes | ( | const Descriptor & | expected,
|  | Descriptor::Ptr & | replacement )

inline

Rename attributes in attribute set (order must remain the same).

Parameters

  expected | Existing descriptor is expected to match this parameter.
  replacement | New descriptor to replace the existing one.

## reorderAttributes()

template<typename T, Index Log2Dim>

void reorderAttributes | ( | const Descriptor::Ptr & | replacement | ) |

inline

Reorder attribute set.

Parameters

  replacement | New descriptor to replace the existing one.

## replaceAttributeSet()

template<typename T, Index Log2Dim>

void replaceAttributeSet | ( | AttributeSet * | attributeSet,
|  | bool | allowMismatchingDescriptors = false )

inline

Replace the underlying attribute set with the given attributeSet.

This leaf will assume ownership of the given attribute set. The descriptors must match and the voxel offsets values will need updating if the point order is different.

Exceptions

  ValueError | if allowMismatchingDescriptors is `false` and the descriptors do not match

## resetBackground()

template<typename T, Index Log2Dim>

void resetBackground | ( | const ValueType & | ,
|  | const ValueType & | newBackground )

inline

## resetDescriptor()

template<typename T, Index Log2Dim>

void resetDescriptor | ( | const Descriptor::Ptr & | replacement | ) |

inline

Replace the descriptor with a new one The new Descriptor must exactly match the old one.

## setActiveState() [1/2]

template<typename T, Index Log2Dim>

void setActiveState | ( | const Coord & | xyz,
|  | bool | on )

inline

## setActiveState() [2/2]

template<typename T, Index Log2Dim>

void setActiveState | ( | Index | offset,
|  | bool | on )

inline

## setActiveStateAndCache()

template<typename T, Index Log2Dim>
template<typename AccessorT>

void setActiveStateAndCache | ( | const Coord & | xyz,
|  | bool | on,
|  | AccessorT & | parent )

inline

## setOffsetOn()

template<typename T, Index Log2Dim>

void setOffsetOn | ( | Index | offset,
|  | const ValueType & | val )

inline

## setOffsetOnly()

template<typename T, Index Log2Dim>

void setOffsetOnly | ( | Index | offset,
|  | const ValueType & | val )

inline

## setOffsets()

template<typename T, Index Log2Dim>

void setOffsets | ( | const std::vector< ValueType > & | offsets,
|  | const bool | updateValueMask = true )

inline

Sets all of the voxel offset values on this leaf, from the given vector of offsets. If updateValueMask is true, then the active value mask will be updated so voxels with points are active and empty voxels are inactive.

## setOrigin()

template<typename T, Index Log2Dim>

void setOrigin | ( | const Coord & | origin | ) |

inlineinherited

Set the grid index coordinates of this node's local origin.

## setTransientData()

template<typename T, Index Log2Dim>

void setTransientData | ( | Index32 | transientData | ) |

inlineinherited

Set the transient data value.

## setValue()

template<typename T, Index Log2Dim>

void setValue | ( | const Coord & | ,
|  | const ValueType & | )

inline

## setValueAndCache()

template<typename T, Index Log2Dim>
template<typename AccessorT>

void setValueAndCache | ( | const Coord & | xyz,
|  | const ValueType & | val,
|  | AccessorT & | )

inlineinherited

Change the value of the voxel at the given coordinates and mark it as active.

Note
  Used internally by ValueAccessor.

## setValueMask() [1/2]

template<typename T, Index Log2Dim>

void setValueMask | ( | const NodeMaskType & | mask | ) |

inlineinherited

## setValueMask() [2/2]

template<typename T, Index Log2Dim>

void setValueMask | ( | Index | n,
|  | bool | on )

inlineprotectedinherited

## setValueMaskOff()

template<typename T, Index Log2Dim>

void setValueMaskOff | ( | Index | n | ) |

inlineprotectedinherited

## setValueMaskOn()

template<typename T, Index Log2Dim>

void setValueMaskOn | ( | Index | n | ) |

inlineprotectedinherited

## setValueOff() [1/4]

template<typename T, Index Log2Dim>

void setValueOff | ( | const Coord & | ,
|  | const ValueType & | )

inline

## setValueOff() [2/4]

template<typename T, Index Log2Dim>

void setValueOff | ( | const Coord & | xyz | ) |

inline

## setValueOff() [3/4]

template<typename T, Index Log2Dim>

void setValueOff | ( | Index | offset | ) |

inline

## setValueOff() [4/4]

template<typename T, Index Log2Dim>

void setValueOff | ( | Index | ,
|  | const ValueType & | )

inline

## setValueOffAndCache()

template<typename T, Index Log2Dim>
template<typename AccessorT>

void setValueOffAndCache | ( | const Coord & | ,
|  | const ValueType & | ,
|  | AccessorT & | )

inline

## setValueOn() [1/4]

template<typename T, Index Log2Dim>

void setValueOn | ( | const Coord & | ,
|  | const ValueType & | )

inline

## setValueOn() [2/4]

template<typename T, Index Log2Dim>

void setValueOn | ( | const Coord & | xyz | ) |

inline

## setValueOn() [3/4]

template<typename T, Index Log2Dim>

void setValueOn | ( | Index | offset | ) |

inline

## setValueOn() [4/4]

template<typename T, Index Log2Dim>

void setValueOn | ( | Index | ,
|  | const ValueType & | )

inline

## setValueOnly() [1/2]

template<typename T, Index Log2Dim>

void setValueOnly | ( | const Coord & | ,
|  | const ValueType & | )

inline

## setValueOnly() [2/2]

template<typename T, Index Log2Dim>

void setValueOnly | ( | Index | ,
|  | const ValueType & | )

inline

## setValueOnlyAndCache()

template<typename T, Index Log2Dim>
template<typename AccessorT>

void setValueOnlyAndCache | ( | const Coord & | ,
|  | const ValueType & | ,
|  | AccessorT & | )

inline

## setValuesOff()

template<typename T, Index Log2Dim>

void setValuesOff | ( |  | ) |

inline

## setValuesOn()

template<typename T, Index Log2Dim>

void setValuesOn | ( |  | ) |

inline

## signedFloodFill() [1/2]

template<typename T, Index Log2Dim>

void signedFloodFill | ( | const ValueType & |  | ) |

inline

## signedFloodFill() [2/2]

template<typename T, Index Log2Dim>

void signedFloodFill | ( | const ValueType & | ,
|  | const ValueType & | )

inline

## size()

template<typename T, Index Log2Dim>

Index size | ( |  | ) |

inlinestaticinherited

Return the total number of voxels represented by this LeafNode.

## skipCompressedValues()

template<typename T, Index Log2Dim>

void skipCompressedValues | ( | bool | seekable,
|  | std::istream & | is,
|  | bool | fromHalf )

inlineprotectedinherited

## stealAttributeSet()

template<typename T, Index Log2Dim>

AttributeSet::UniquePtr stealAttributeSet | ( |  | ) |

inline

Steal the attribute set, a new, empty attribute set is inserted in it's place.

## stealNode()

template<typename T, Index Log2Dim>
template<typename NodeT>

NodeT * stealNode | ( | const Coord & | ,
|  | const ValueType & | ,
|  | bool | )

inlineinherited

## stealNodes()

template<typename T, Index Log2Dim>
template<typename ArrayT>

void stealNodes | ( | ArrayT & | ,
|  | const ValueType & | ,
|  | bool | )

inlineinherited

## str()

template<Index Log2Dim>

std::string str | ( |  | ) | const

inlineinherited

Return a string representation of this node.

## streamingSize()

template<typename T, Index Log2Dim>

size_t streamingSize | ( | bool | toHalf = false | ) | const

inherited

## swap()

template<typename T, Index Log2Dim>

void swap | ( | Buffer & | other | ) |

inlineinherited

Exchange this node's data buffer with the given data buffer without changing the active states of the values.

## topologyDifference() [1/2]

template<Index Log2Dim>
template<typename OtherType>

void topologyDifference | ( | const LeafNode< OtherType, Log2Dim > & | other,
|  | const bool & | )

inlineinherited

## topologyDifference() [2/2]

template<typename T, Index Log2Dim>
template<typename OtherType>

void topologyDifference | ( | const LeafNode< OtherType, Log2Dim > & | other,
|  | const ValueType & | )

inlineinherited

Difference this node's set of active values with the active values of the other node, whose `ValueType` may be different. So a resulting voxel will be active only if the original voxel is active in this LeafNode and inactive in the other LeafNode.

The last dummy argument is required to match the signature for InternalNode::topologyDifference.

Note
  This operation modifies only active states, not values. Also, because it can deactivate all of this node's voxels, consider subsequently calling prune.

## topologyIntersection() [1/2]

template<Index Log2Dim>
template<typename OtherType>

void topologyIntersection | ( | const LeafNode< OtherType, Log2Dim > & | other,
|  | const bool & | )

inlineinherited

## topologyIntersection() [2/2]

template<typename T, Index Log2Dim>
template<typename OtherType>

void topologyIntersection | ( | const LeafNode< OtherType, Log2Dim > & | other,
|  | const ValueType & | )

inlineinherited

Intersect this node's set of active values with the active values of the other node, whose `ValueType` may be different. So a resulting voxel will be active only if both of the original voxels were active.

The last dummy argument is required to match the signature for InternalNode::topologyIntersection.

Note
  This operation modifies only active states, not values. Also note that this operation can result in all voxels being inactive so consider subsequently calling prune.

## topologyUnion()

template<Index Log2Dim>
template<typename OtherType>

void topologyUnion | ( | const LeafNode< OtherType, Log2Dim > & | other,
|  | const bool | preserveTiles = false )

inlineinherited

Union this node's set of active values with the active values of the other node, whose `ValueType` may be different. So a resulting voxel will be active if either of the original voxels were active.

Note
  This operation modifies only active states, not values.

## touchLeaf()

template<typename T, Index Log2Dim>

PointDataLeafNode * touchLeaf | ( | const Coord & |  | ) |

inline

Return a pointer to this node.

## touchLeafAndCache()

template<typename T, Index Log2Dim>
template<typename AccessorT>

PointDataLeafNode * touchLeafAndCache | ( | const Coord & | ,
|  | AccessorT & | )

inline

## transientData()

template<typename T, Index Log2Dim>

Index32 transientData | ( |  | ) | const

inlineinherited

Return the transient data value.

## updateValueMask()

template<typename T, Index Log2Dim>

void updateValueMask | ( |  | ) |

inline

Activate voxels with non-zero points, deactivate voxels with zero points.

## validateOffsets()

template<typename T, Index Log2Dim>

void validateOffsets | ( |  | ) | const

inline

Throws an error if the voxel values on this leaf are not monotonically increasing or within the bounds of the attribute arrays.

## valueMask()

template<typename T, Index Log2Dim>

const NodeMaskType & valueMask | ( |  | ) | const

inlineinherited

## voxelizeActiveTiles()

template<typename T, Index Log2Dim>

void voxelizeActiveTiles | ( | bool | = true | ) |

inlineinherited

No-op.

This function exists only to enable template instantiation.

## writeBuffers()

template<typename T, Index Log2Dim>

void writeBuffers | ( | std::ostream & | os,
|  | bool | toHalf = false ) const

inline

## writeTopology()

template<typename T, Index Log2Dim>

void writeTopology | ( | std::ostream & | os,
|  | bool | toHalf = false ) const

inline

## Friends And Related Symbol Documentation

## ::TestPointDataLeaf

template<typename T, Index Log2Dim>

friend class ::TestPointDataLeaf

friend

## PointDataLeafNode

template<typename T, Index Log2Dim>
template<typename, Index>

friend class PointDataLeafNode

friend

## tree::IteratorBase< MaskDenseIterator, PointDataLeafNode >

template<typename T, Index Log2Dim>

friend class tree::IteratorBase< MaskDenseIterator, PointDataLeafNode >

friend

## tree::IteratorBase< MaskOffIterator, PointDataLeafNode >

template<typename T, Index Log2Dim>

friend class tree::IteratorBase< MaskOffIterator, PointDataLeafNode >

friend

## tree::IteratorBase< MaskOnIterator, PointDataLeafNode >

template<typename T, Index Log2Dim>

friend class tree::IteratorBase< MaskOnIterator, PointDataLeafNode >

friend

## Member Data Documentation

## DIM

template<typename T, Index Log2Dim>

const Index DIM

static

## LEVEL

template<typename T, Index Log2Dim>

const Index LEVEL

static

## LOG2DIM

template<typename T, Index Log2Dim>

const Index LOG2DIM

static

## NUM_VALUES

template<typename T, Index Log2Dim>

const Index NUM_VALUES

static

## NUM_VOXELS

template<typename T, Index Log2Dim>

const Index NUM_VOXELS

static

## SIZE

template<typename T, Index Log2Dim>

const Index SIZE

static

## TOTAL

template<typename T, Index Log2Dim>

const Index TOTAL

static