#include <openvdb/tree/Tree.h>

Inherits TreeBase.

Classes
struct	DeallocateNodes

struct	ValueConverter
	ValueConverter<T>::Type is the type of a tree having the same hierarchy as this tree but a different value type, T. More...

Public Types
using	Ptr = SharedPtr< Tree >

using	ConstPtr = SharedPtr< const Tree >

using	RootNodeType = _RootNodeType

using	ValueType = typename RootNodeType::ValueType

using	BuildType = typename RootNodeType::BuildType

using	LeafNodeType = typename RootNodeType::LeafNodeType

using	ValueAllIter = TreeValueIteratorBase< Tree, typename RootNodeType::ValueAllIter >

using	ValueAllCIter = TreeValueIteratorBase< const Tree, typename RootNodeType::ValueAllCIter >

using	ValueOnIter = TreeValueIteratorBase< Tree, typename RootNodeType::ValueOnIter >

using	ValueOnCIter = TreeValueIteratorBase< const Tree, typename RootNodeType::ValueOnCIter >

using	ValueOffIter = TreeValueIteratorBase< Tree, typename RootNodeType::ValueOffIter >

using	ValueOffCIter = TreeValueIteratorBase< const Tree, typename RootNodeType::ValueOffCIter >


using	NodeIter = NodeIteratorBase< Tree, typename RootNodeType::ChildOnIter >
	Iterator over all nodes in this tree. More...

using	NodeCIter = NodeIteratorBase< const Tree, typename RootNodeType::ChildOnCIter >
	Iterator over all nodes in this tree. More...


using	LeafIter = LeafIteratorBase< Tree, typename RootNodeType::ChildOnIter >
	Iterator over all leaf nodes in this tree. More...

using	LeafCIter = LeafIteratorBase< const Tree, typename RootNodeType::ChildOnCIter >
	Iterator over all leaf nodes in this tree. More...

Public Member Functions
	Tree ()

Tree &	operator= (const Tree &)=delete

	Tree (const Tree &other)
	Deep copy constructor. More...

template<typename OtherRootType >
	Tree (const Tree< OtherRootType > &other)
	Value conversion deep copy constructor. More...

template<typename OtherTreeType >
	Tree (const OtherTreeType &other, const ValueType &inactiveValue, const ValueType &activeValue, TopologyCopy)
	Topology copy constructor from a tree of a different type. More...

template<typename OtherTreeType >
	Tree (const OtherTreeType &other, const ValueType &background, TopologyCopy)
	Topology copy constructor from a tree of a different type. More...

	Tree (const ValueType &background)
	Empty tree constructor. More...

	~Tree () override

TreeBase::Ptr	copy () const override
	Return a pointer to a deep copy of this tree. More...

Name	valueType () const override
	Return the name of the type of a voxel's value (e.g., "float" or "vec3d") More...

const Name &	type () const override
	Return the name of this type of tree. More...

bool	operator== (const Tree &) const

bool	operator!= (const Tree &) const

template<typename OtherRootNodeType >
bool	hasSameTopology (const Tree< OtherRootNodeType > &other) const
	Return `true` if the given tree has the same node and active value topology as this tree, whether or not it has the same `ValueType`. More...

bool	evalLeafBoundingBox (CoordBBox &bbox) const override
	Return in bbox the axis-aligned bounding box of all active tiles and leaf nodes with active values. More...

bool	evalActiveVoxelBoundingBox (CoordBBox &bbox) const override
	Return in bbox the axis-aligned bounding box of all active voxels and tiles. More...

bool	evalActiveVoxelDim (Coord &dim) const override
	Return in dim the dimensions of the axis-aligned bounding box of all active voxels. This is a tighter bounding box than the leaf node bounding box. More...

bool	evalLeafDim (Coord &dim) const override
	Return in dim the dimensions of the axis-aligned bounding box of all leaf nodes. More...

void	readTopology (std::istream &, bool saveFloatAsHalf=false) override
	Read the tree topology from a stream. More...

void	writeTopology (std::ostream &, bool saveFloatAsHalf=false) const override
	Write the tree topology to a stream. More...

void	readBuffers (std::istream &, bool saveFloatAsHalf=false) override
	Read all data buffers for this tree. More...

void	readBuffers (std::istream &, const CoordBBox &, bool saveFloatAsHalf=false) override
	Read all of this tree's data buffers that intersect the given bounding box. More...

void	readNonresidentBuffers () const override
	Read all of this tree's data buffers that are not yet resident in memory (because delayed loading is in effect). More...

void	writeBuffers (std::ostream &, bool saveFloatAsHalf=false) const override
	Write out all data buffers for this tree. More...

void	print (std::ostream &os=std::cout, int verboseLevel=1) const override
	Print statistics, memory usage and other information about this tree. More...

Index	treeDepth () const override
	Return the depth of this tree. More...

Index32	leafCount () const override
	Return the number of leaf nodes. More...

std::vector< Index32 >	nodeCount () const override

Index32	nonLeafCount () const override
	Return the number of non-leaf nodes. More...

Index64	activeLeafVoxelCount () const override
	Return the number of active voxels stored in leaf nodes. More...

Index64	inactiveLeafVoxelCount () const override
	Return the number of inactive voxels stored in leaf nodes. More...

Index64	activeVoxelCount () const override
	Return the total number of active voxels. More...

Index64	inactiveVoxelCount () const override
	Return the number of inactive voxels within the bounding box of all active voxels. More...

Index64	activeTileCount () const override
	Return the total number of active tiles. More...

void	evalMinMax (ValueType &min, ValueType &max) const
	Return the minimum and maximum active values in this tree. More...

Index64	memUsage () const override
	Return the total amount of memory in bytes occupied by this tree. More...

const ValueType &	getValue (const Coord &xyz) const
	Return the value of the voxel at the given coordinates. More...

template<typename AccessT >
const ValueType &	getValue (const Coord &xyz, AccessT &) const
	Return the value of the voxel at the given coordinates and update the given accessor's node cache. More...

int	getValueDepth (const Coord &xyz) const
	Return the tree depth (0 = root) at which the value of voxel (x, y, z) resides. More...

void	setActiveState (const Coord &xyz, bool on)
	Set the active state of the voxel at the given coordinates but don't change its value. More...

void	setValueOnly (const Coord &xyz, const ValueType &value)
	Set the value of the voxel at the given coordinates but don't change its active state. More...

void	setValueOn (const Coord &xyz)
	Mark the voxel at the given coordinates as active but don't change its value. More...

void	setValueOn (const Coord &xyz, const ValueType &value)
	Set the value of the voxel at the given coordinates and mark the voxel as active. More...

void	setValue (const Coord &xyz, const ValueType &value)
	Set the value of the voxel at the given coordinates and mark the voxel as active. More...

template<typename AccessT >
void	setValue (const Coord &xyz, const ValueType &value, AccessT &)
	Set the value of the voxel at the given coordinates, mark the voxel as active, and update the given accessor's node cache. More...

void	setValueOff (const Coord &xyz)
	Mark the voxel at the given coordinates as inactive but don't change its value. More...

void	setValueOff (const Coord &xyz, const ValueType &value)
	Set the value of the voxel at the given coordinates and mark the voxel as inactive. More...

template<typename ModifyOp >
void	modifyValue (const Coord &xyz, const ModifyOp &op)
	Apply a functor to the value of the voxel at the given coordinates and mark the voxel as active. More...

template<typename ModifyOp >
void	modifyValueAndActiveState (const Coord &xyz, const ModifyOp &op)
	Apply a functor to the voxel at the given coordinates. More...

bool	probeValue (const Coord &xyz, ValueType &value) const
	Get the value of the voxel at the given coordinates. More...

bool	isValueOn (const Coord &xyz) const
	Return `true` if the value at the given coordinates is active. More...

bool	isValueOff (const Coord &xyz) const
	Return `true` if the value at the given coordinates is inactive. More...

bool	hasActiveTiles () const
	Return `true` if this tree has any active tiles. More...

void	clip (const CoordBBox &)
	Set all voxels that lie outside the given axis-aligned box to the background. More...

void	clipUnallocatedNodes () override
	Replace with background tiles any nodes whose voxel buffers have not yet been allocated. More...

Index32	unallocatedLeafCount () const override
	Return the total number of unallocated leaf nodes residing in this tree. More...

void	denseFill (const CoordBBox &bbox, const ValueType &value, bool active=true)
	Set all voxels within a given axis-aligned box to a constant value and ensure that those voxels are all represented at the leaf level. More...

void	voxelizeActiveTiles (bool threaded=true)
	Densify active tiles, i.e., replace them with leaf-level active voxels. More...

void	prune (const ValueType &tolerance=zeroVal< ValueType >())
	Reduce the memory footprint of this tree by replacing with tiles any nodes whose values are all the same (optionally to within a tolerance) and have the same active state. More...

void	addLeaf (LeafNodeType *leaf)
	Add the given leaf node to this tree, creating a new branch if necessary. If a leaf node with the same origin already exists, replace it. More...

void	addTile (Index level, const Coord &xyz, const ValueType &value, bool active)
	Add a tile containing voxel (x, y, z) at the specified tree level, creating a new branch if necessary. Delete any existing lower-level nodes that contain (x, y, z). More...

template<typename NodeT >
NodeT *	stealNode (const Coord &xyz, const ValueType &value, bool active)
	Return a pointer to the node of type `NodeT` that contains voxel (x, y, z) and replace it with a tile of the specified value and state. If no such node exists, leave the tree unchanged and return `nullptr`. More...

LeafNodeType *	touchLeaf (const Coord &xyz)
	Return a pointer to the leaf node that contains voxel (x, y, z). If no such node exists, create one that preserves the values and active states of all voxels. More...

template<typename ArrayT >
void	stealNodes (ArrayT &array)
	Steals all nodes of a certain type from the tree and adds them to a container with the following API: More...

template<typename ArrayT >
void	stealNodes (ArrayT &array, const ValueType &value, bool state)

bool	empty () const
	Return `true` if this tree contains no nodes other than the root node and no tiles other than background tiles. More...

void	clear ()
	Remove all tiles from this tree and all nodes other than the root node. More...

void	clearAllAccessors ()
	Clear all registered accessors. More...

Metadata::Ptr	getBackgroundValue () const override
	Return this tree's background value wrapped as metadata. More...

const ValueType &	background () const
	Return this tree's background value. More...

void	getIndexRange (CoordBBox &bbox) const override
	Min and max are both inclusive. More...

void	merge (Tree &other, MergePolicy=MERGE_ACTIVE_STATES)
	Efficiently merge another tree into this tree using one of several schemes. More...

template<typename OtherRootNodeType >
void	topologyUnion (const Tree< OtherRootNodeType > &other, const bool preserveTiles=false)
	Union this tree's set of active values with the active values of the other tree, whose `ValueType` may be different. More...

template<typename OtherRootNodeType >
void	topologyIntersection (const Tree< OtherRootNodeType > &other)
	Intersects this tree's set of active values with the active values of the other tree, whose `ValueType` may be different. More...

template<typename OtherRootNodeType >
void	topologyDifference (const Tree< OtherRootNodeType > &other)
	Difference this tree's set of active values with the active values of the other tree, whose `ValueType` may be different. So a resulting voxel will be active only if the original voxel is active in this tree and inactive in the other tree. More...

template<typename CombineOp >
void	combine (Tree &other, CombineOp &op, bool prune=false)

template<typename CombineOp >
void	combine (Tree &other, const CombineOp &op, bool prune=false)

template<typename ExtendedCombineOp >
void	combineExtended (Tree &other, ExtendedCombineOp &op, bool prune=false)

template<typename ExtendedCombineOp >
void	combineExtended (Tree &other, const ExtendedCombineOp &op, bool prune=false)

template<typename CombineOp , typename OtherTreeType >
void	combine2 (const Tree &a, const OtherTreeType &b, CombineOp &op, bool prune=false)

template<typename CombineOp , typename OtherTreeType >
void	combine2 (const Tree &a, const OtherTreeType &b, const CombineOp &op, bool prune=false)

template<typename ExtendedCombineOp , typename OtherTreeType >
void	combine2Extended (const Tree &a, const OtherTreeType &b, ExtendedCombineOp &op, bool prune=false)

template<typename ExtendedCombineOp , typename OtherTreeType >
void	combine2Extended (const Tree &a, const OtherTreeType &b, const ExtendedCombineOp &, bool prune=false)

template<typename BBoxOp >
void	visitActiveBBox (BBoxOp &op) const

template<typename VisitorOp >
void	visit (VisitorOp &op)

template<typename VisitorOp >
void	visit (const VisitorOp &op)

template<typename VisitorOp >
void	visit (VisitorOp &op) const

template<typename VisitorOp >
void	visit (const VisitorOp &op) const

template<typename OtherTreeType , typename VisitorOp >
void	visit2 (OtherTreeType &other, VisitorOp &op)

template<typename OtherTreeType , typename VisitorOp >
void	visit2 (OtherTreeType &other, const VisitorOp &op)

template<typename OtherTreeType , typename VisitorOp >
void	visit2 (OtherTreeType &other, VisitorOp &op) const

template<typename OtherTreeType , typename VisitorOp >
void	visit2 (OtherTreeType &other, const VisitorOp &op) const

template<typename IterT >
IterT	begin ()
	Return an iterator of type `IterT` (for example, begin<ValueOnIter>() is equivalent to beginValueOn()). More...

template<typename CIterT >
CIterT	cbegin () const
	Return a const iterator of type CIterT (for example, cbegin<ValueOnCIter>() is equivalent to cbeginValueOn()). More...

template<typename IterT >
IterT	cbegin () const

template<typename AccessT >
const RootNodeType::ValueType &	getValue (const Coord &xyz, AccessT &accessor) const


RootNodeType &	root ()
	Return this tree's root node. More...

const RootNodeType &	root () const
	Return this tree's root node. More...


void	sparseFill (const CoordBBox &bbox, const ValueType &value, bool active=true)
	Set all voxels within a given axis-aligned box to a constant value. More...

void	fill (const CoordBBox &bbox, const ValueType &value, bool active=true)
	Set all voxels within a given axis-aligned box to a constant value. More...


template<typename NodeType >
NodeType *	probeNode (const Coord &xyz)
	Return a pointer to the node of type `NodeType` that contains voxel (x, y, z). If no such node exists, return `nullptr`. More...

template<typename NodeType >
const NodeType *	probeConstNode (const Coord &xyz) const
	Return a pointer to the node of type `NodeType` that contains voxel (x, y, z). If no such node exists, return `nullptr`. More...

template<typename NodeType >
const NodeType *	probeNode (const Coord &xyz) const
	Return a pointer to the node of type `NodeType` that contains voxel (x, y, z). If no such node exists, return `nullptr`. More...


LeafNodeType *	probeLeaf (const Coord &xyz)
	Return a pointer to the leaf node that contains voxel (x, y, z). If no such node exists, return `nullptr`. More...

const LeafNodeType *	probeConstLeaf (const Coord &xyz) const
	Return a pointer to the leaf node that contains voxel (x, y, z). If no such node exists, return `nullptr`. More...

const LeafNodeType *	probeLeaf (const Coord &xyz) const
	Return a pointer to the leaf node that contains voxel (x, y, z). If no such node exists, return `nullptr`. More...


template<typename ArrayT >
void	getNodes (ArrayT &array)
	Adds all nodes of a certain type to a container with the following API: More...

template<typename ArrayT >
void	getNodes (ArrayT &array) const
	Adds all nodes of a certain type to a container with the following API: More...


void	attachAccessor (ValueAccessorBase< Tree, true > &) const
	Register an accessor for this tree. Registered accessors are automatically cleared whenever one of this tree's nodes is deleted. More...

void	attachAccessor (ValueAccessorBase< const Tree, true > &) const
	Register an accessor for this tree. Registered accessors are automatically cleared whenever one of this tree's nodes is deleted. More...


void	attachAccessor (ValueAccessorBase< Tree, false > &) const
	Dummy implementations. More...

void	attachAccessor (ValueAccessorBase< const Tree, false > &) const
	Dummy implementations. More...


void	releaseAccessor (ValueAccessorBase< Tree, true > &) const
	Deregister an accessor so that it is no longer automatically cleared. More...

void	releaseAccessor (ValueAccessorBase< const Tree, true > &) const
	Deregister an accessor so that it is no longer automatically cleared. More...


void	releaseAccessor (ValueAccessorBase< Tree, false > &) const
	Dummy implementations. More...

void	releaseAccessor (ValueAccessorBase< const Tree, false > &) const
	Dummy implementations. More...


RootNodeType::ChildOnCIter	beginRootChildren () const
	Return an iterator over children of the root node. More...

RootNodeType::ChildOnCIter	cbeginRootChildren () const
	Return an iterator over children of the root node. More...

RootNodeType::ChildOnIter	beginRootChildren ()
	Return an iterator over children of the root node. More...


RootNodeType::ChildOffCIter	beginRootTiles () const
	Return an iterator over non-child entries of the root node's table. More...

RootNodeType::ChildOffCIter	cbeginRootTiles () const
	Return an iterator over non-child entries of the root node's table. More...

RootNodeType::ChildOffIter	beginRootTiles ()
	Return an iterator over non-child entries of the root node's table. More...


RootNodeType::ChildAllCIter	beginRootDense () const
	Return an iterator over all entries of the root node's table. More...

RootNodeType::ChildAllCIter	cbeginRootDense () const
	Return an iterator over all entries of the root node's table. More...

RootNodeType::ChildAllIter	beginRootDense ()
	Return an iterator over all entries of the root node's table. More...


NodeIter	beginNode ()
	Return an iterator over all nodes in this tree. More...

NodeCIter	beginNode () const
	Return an iterator over all nodes in this tree. More...

NodeCIter	cbeginNode () const
	Return an iterator over all nodes in this tree. More...


LeafIter	beginLeaf ()
	Return an iterator over all leaf nodes in this tree. More...

LeafCIter	beginLeaf () const
	Return an iterator over all leaf nodes in this tree. More...

LeafCIter	cbeginLeaf () const
	Return an iterator over all leaf nodes in this tree. More...


ValueAllIter	beginValueAll ()
	Return an iterator over all values (tile and voxel) across all nodes. More...

ValueAllCIter	beginValueAll () const
	Return an iterator over all values (tile and voxel) across all nodes. More...

ValueAllCIter	cbeginValueAll () const
	Return an iterator over all values (tile and voxel) across all nodes. More...


ValueOnIter	beginValueOn ()
	Return an iterator over active values (tile and voxel) across all nodes. More...

ValueOnCIter	beginValueOn () const
	Return an iterator over active values (tile and voxel) across all nodes. More...

ValueOnCIter	cbeginValueOn () const
	Return an iterator over active values (tile and voxel) across all nodes. More...


ValueOffIter	beginValueOff ()
	Return an iterator over inactive values (tile and voxel) across all nodes. More...

ValueOffCIter	beginValueOff () const
	Return an iterator over inactive values (tile and voxel) across all nodes. More...

ValueOffCIter	cbeginValueOff () const
	Return an iterator over inactive values (tile and voxel) across all nodes. More...

Static Public Member Functions
static const Name &	treeType ()
	Return the name of this type of tree. More...

static void	getNodeLog2Dims (std::vector< Index > &dims)
	Traverse the type hierarchy of nodes, and return, in dims, a list of the Log2Dims of nodes in order from RootNode to LeafNode. More...

Static Public Attributes
static const Index	DEPTH = RootNodeType::LEVEL + 1

Protected Types
using	AccessorRegistry = tbb::concurrent_hash_map< ValueAccessorBase< Tree, true > *, bool >

using	ConstAccessorRegistry = tbb::concurrent_hash_map< ValueAccessorBase< const Tree, true > *, bool >

Protected Member Functions
void	releaseAllAccessors ()
	Notify all registered accessors, by calling ValueAccessor::release(), that this tree is about to be deleted. More...

Protected Attributes
RootNodeType	mRoot

AccessorRegistry	mAccessorRegistry

ConstAccessorRegistry	mConstAccessorRegistry

Static Protected Attributes
static std::unique_ptr< const Name >	sTreeTypeName

Member Typedef Documentation

using AccessorRegistry = tbb::concurrent_hash_map<ValueAccessorBase<Tree, true>*, bool>

protected

using BuildType = typename RootNodeType::BuildType

using ConstAccessorRegistry = tbb::concurrent_hash_map<ValueAccessorBase<const Tree, true>*, bool>

protected

using ConstPtr = SharedPtr<const Tree>

using LeafCIter = LeafIteratorBase<const Tree, typename RootNodeType::ChildOnCIter>

Iterator over all leaf nodes in this tree.

using LeafIter = LeafIteratorBase<Tree, typename RootNodeType::ChildOnIter>

Iterator over all leaf nodes in this tree.

using LeafNodeType = typename RootNodeType::LeafNodeType

using NodeCIter = NodeIteratorBase<const Tree, typename RootNodeType::ChildOnCIter>

Iterator over all nodes in this tree.

using NodeIter = NodeIteratorBase<Tree, typename RootNodeType::ChildOnIter>

Iterator over all nodes in this tree.

using Ptr = SharedPtr<Tree>

using RootNodeType = _RootNodeType

using ValueAllCIter = TreeValueIteratorBase<const Tree, typename RootNodeType::ValueAllCIter>

using ValueAllIter = TreeValueIteratorBase<Tree, typename RootNodeType::ValueAllIter>

using ValueOffCIter = TreeValueIteratorBase<const Tree, typename RootNodeType::ValueOffCIter>

using ValueOffIter = TreeValueIteratorBase<Tree, typename RootNodeType::ValueOffIter>

using ValueOnCIter = TreeValueIteratorBase<const Tree, typename RootNodeType::ValueOnCIter>

using ValueOnIter = TreeValueIteratorBase<Tree, typename RootNodeType::ValueOnIter>

using ValueType = typename RootNodeType::ValueType

Constructor & Destructor Documentation

Tree ( )

inline

Tree ( const Tree< _RootNodeType > & other )

inline

Deep copy constructor.

Tree ( const Tree< OtherRootType > & other )

inlineexplicit

Value conversion deep copy constructor.

Deep copy a tree of the same configuration as this tree type but a different ValueType, casting the other tree's values to this tree's ValueType.

Exceptions

TypeError if the other tree's configuration doesn't match this tree's or if this tree's ValueType is not constructible from the other tree's ValueType.

Tree	(	const OtherTreeType &	other,
		const ValueType &	inactiveValue,
		const ValueType &	activeValue,
		TopologyCopy
	)

inline

Topology copy constructor from a tree of a different type.

Copy the structure, i.e., the active states of tiles and voxels, of another tree of a possibly different type, but don't copy any tile or voxel values. Instead, initialize tiles and voxels with the given active and inactive values.

Parameters

other	a tree having (possibly) a different ValueType
inactiveValue	background value for this tree, and the value to which all inactive tiles and voxels are initialized
activeValue	value to which active tiles and voxels are initialized

Exceptions

TypeError if the other tree's configuration doesn't match this tree's.

Tree	(	const OtherTreeType &	other,
		const ValueType &	background,
		TopologyCopy
	)

inline

Topology copy constructor from a tree of a different type.

Note: This topology copy constructor is generally faster than the one that takes both a foreground and a background value.

Copy the structure, i.e., the active states of tiles and voxels, of another tree of a possibly different type, but don't copy any tile or voxel values. Instead, initialize tiles and voxels with the given background value.

Parameters

other	a tree having (possibly) a different ValueType
background	the value to which tiles and voxels are initialized

Exceptions

TypeError if the other tree's configuration doesn't match this tree's.

Tree ( const ValueType & background )

inline

Empty tree constructor.

~Tree ( )

inlineoverride

Member Function Documentation

Index64 activeLeafVoxelCount ( ) const

inlineoverridevirtual

Return the number of active voxels stored in leaf nodes.

Implements TreeBase.

Index64 activeTileCount ( ) const

inlineoverridevirtual

Return the total number of active tiles.

Implements TreeBase.

Index64 activeVoxelCount ( ) const

inlineoverridevirtual

Return the total number of active voxels.

Implements TreeBase.

void addLeaf ( LeafNodeType * leaf )

inline

Add the given leaf node to this tree, creating a new branch if necessary. If a leaf node with the same origin already exists, replace it.

Warning: Ownership of the leaf is transferred to the tree so the client code should not attempt to delete the leaf pointer!

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

inline

Add a tile containing voxel (x, y, z) at the specified tree level, creating a new branch if necessary. Delete any existing lower-level nodes that contain (x, y, z).

Note: level must be less than this tree's depth.

void attachAccessor ( ValueAccessorBase< Tree< _RootNodeType >, true > & accessor ) const

inline

Register an accessor for this tree. Registered accessors are automatically cleared whenever one of this tree's nodes is deleted.

void attachAccessor ( ValueAccessorBase< const Tree< _RootNodeType >, true > & accessor ) const

inline

Register an accessor for this tree. Registered accessors are automatically cleared whenever one of this tree's nodes is deleted.

void attachAccessor ( ValueAccessorBase< Tree< _RootNodeType >, false > & ) const

inline

Dummy implementations.

void attachAccessor ( ValueAccessorBase< const Tree< _RootNodeType >, false > & ) const

inline

Dummy implementations.

const ValueType& background ( ) const

inline

Return this tree's background value.

Note: Use tools::changeBackground to efficiently modify the background values. Else use tree.root().setBackground, which is serial and hence slower.

IterT begin ( )

inline

Return an iterator of type IterT (for example, begin<ValueOnIter>() is equivalent to beginValueOn()).

LeafIter beginLeaf ( )

inline

Return an iterator over all leaf nodes in this tree.

LeafCIter beginLeaf ( ) const

inline

Return an iterator over all leaf nodes in this tree.

NodeIter beginNode ( )

inline

Return an iterator over all nodes in this tree.

NodeCIter beginNode ( ) const

inline

Return an iterator over all nodes in this tree.

RootNodeType::ChildOnCIter beginRootChildren ( ) const

inline

Return an iterator over children of the root node.

RootNodeType::ChildOnIter beginRootChildren ( )

inline

Return an iterator over children of the root node.

RootNodeType::ChildAllCIter beginRootDense ( ) const

inline

Return an iterator over all entries of the root node's table.

RootNodeType::ChildAllIter beginRootDense ( )

inline

Return an iterator over all entries of the root node's table.

RootNodeType::ChildOffCIter beginRootTiles ( ) const

inline

Return an iterator over non-child entries of the root node's table.

RootNodeType::ChildOffIter beginRootTiles ( )

inline

Return an iterator over non-child entries of the root node's table.

ValueAllIter beginValueAll ( )

inline

Return an iterator over all values (tile and voxel) across all nodes.

ValueAllCIter beginValueAll ( ) const

inline

Return an iterator over all values (tile and voxel) across all nodes.

ValueOffIter beginValueOff ( )

inline

Return an iterator over inactive values (tile and voxel) across all nodes.

ValueOffCIter beginValueOff ( ) const

inline

Return an iterator over inactive values (tile and voxel) across all nodes.

ValueOnIter beginValueOn ( )

inline

Return an iterator over active values (tile and voxel) across all nodes.

ValueOnCIter beginValueOn ( ) const

inline

Return an iterator over active values (tile and voxel) across all nodes.

CIterT cbegin ( ) const

Return a const iterator of type CIterT (for example, cbegin<ValueOnCIter>() is equivalent to cbeginValueOn()).

IterT cbegin ( ) const

inline

LeafCIter cbeginLeaf ( ) const

inline

Return an iterator over all leaf nodes in this tree.

NodeCIter cbeginNode ( ) const

inline

Return an iterator over all nodes in this tree.

RootNodeType::ChildOnCIter cbeginRootChildren ( ) const

inline

Return an iterator over children of the root node.

RootNodeType::ChildAllCIter cbeginRootDense ( ) const

inline

Return an iterator over all entries of the root node's table.

RootNodeType::ChildOffCIter cbeginRootTiles ( ) const

inline

Return an iterator over non-child entries of the root node's table.

ValueAllCIter cbeginValueAll ( ) const

inline

Return an iterator over all values (tile and voxel) across all nodes.

ValueOffCIter cbeginValueOff ( ) const

inline

Return an iterator over inactive values (tile and voxel) across all nodes.

ValueOnCIter cbeginValueOn ( ) const

inline

Return an iterator over active values (tile and voxel) across all nodes.

void clear ( )

inline

Remove all tiles from this tree and all nodes other than the root node.

void clearAllAccessors ( )

inline

Clear all registered accessors.

void clip ( const CoordBBox & bbox )

inline

Set all voxels that lie outside the given axis-aligned box to the background.

void clipUnallocatedNodes ( )

inlineoverridevirtual

Replace with background tiles any nodes whose voxel buffers have not yet been allocated.

Typically, unallocated nodes are leaf nodes whose voxel buffers are not yet resident in memory because delayed loading is in effect.

See also: readNonresidentBuffers, io::File::open

Implements TreeBase.

void combine	(	Tree< _RootNodeType > &	other,
		CombineOp &	op,
		bool	prune = `false`
	)

inline

For a given function f, use sparse traversal to compute f(this, other) over all corresponding pairs of values (tile or voxel) of this tree and the other tree and store the result in this tree. This method is typically more space-efficient than the two-tree combine2(), since it moves rather than copies nodes from the other tree into this tree.

Note: This operation always empties the other tree.

Parameters

other	a tree of the same type as this tree
op	a functor of the form `void op(const T& a, const T& b, T& result)`, where `T` is this tree's `ValueType`, that computes `result = f(a, b)`
prune	if true, prune the resulting tree one branch at a time (this is usually more space-efficient than pruning the entire tree in one pass)

Example:: Compute the per-voxel difference between two floating-point trees, aTree and bTree, and store the result in aTree (leaving bTree empty).
{
struct Local {
static inline void diff(const float& a, const float& b, float& result) {
result = a - b;
}
};
aTree.combine(bTree, Local::diff);
}

Example:: Compute f * a + (1 - f) * b over all voxels of two floating-point trees, aTree and bTree, and store the result in aTree (leaving bTree empty).
namespace {
struct Blend {
Blend(float f): frac(f) {}
inline void operator()(const float& a, const float& b, float& result) const {
result = frac * a + (1.0 - frac) * b;
}
float frac;
};
}
{
aTree.combine(bTree, Blend(0.25)); // 0.25 * a + 0.75 * b
}

void combine	(	Tree< _RootNodeType > &	other,
		const CombineOp &	op,
		bool	prune = `false`
	)

inline

void combine2	(	const Tree< _RootNodeType > &	a,
		const OtherTreeType &	b,
		CombineOp &	op,
		bool	prune = `false`
	)

inline

For a given function f, use sparse traversal to compute f(a, b) over all corresponding pairs of values (tile or voxel) of trees A and B and store the result in this tree.

Parameters

a,b	two trees with the same configuration (levels and node dimensions) as this tree but with the B tree possibly having a different value type
op	a functor of the form `void op(const T1& a, const T2& b, T1& result)`, where `T1` is this tree's and the A tree's `ValueType` and `T2` is the B tree's `ValueType`, that computes `result = f(a, b)`
prune	if true, prune the resulting tree one branch at a time (this is usually more space-efficient than pruning the entire tree in one pass)

Exceptions

TypeError if the B tree's configuration doesn't match this tree's or if this tree's ValueType is not constructible from the B tree's ValueType.

Example:: Compute the per-voxel difference between two floating-point trees, aTree and bTree, and store the result in a third tree.
{
struct Local {
static inline void diff(const float& a, const float& b, float& result) {
result = a - b;
}
};
FloatTree resultTree;
resultTree.combine2(aTree, bTree, Local::diff);
}

void combine2	(	const Tree< _RootNodeType > &	a,
		const OtherTreeType &	b,
		const CombineOp &	op,
		bool	prune = `false`
	)

inline

void combine2Extended	(	const Tree< _RootNodeType > &	a,
		const OtherTreeType &	b,
		ExtendedCombineOp &	op,
		bool	prune = `false`
	)

inline

Like combine2(), but with

Parameters

a,b	two trees with the same configuration (levels and node dimensions) as this tree but with the B tree possibly having a different value type
op	a functor of the form `void op(CombineArgs<T1, T2>& args)`, where `T1` is this tree's and the A tree's `ValueType` and `T2` is the B tree's `ValueType`, that computes `args.setResult(f(args.a(), args.b()))` and, optionally, `args.setResultIsActive(g(args.aIsActive(), args.bIsActive()))` for some functions `f` and `g`
prune	if true, prune the resulting tree one branch at a time (this is usually more space-efficient than pruning the entire tree in one pass) This variant passes not only the a and b values but also the active states of the a and b values to the functor, which may then return, by calling `args.setResultIsActive()`, a computed active state for the result value. By default, the result is active if either the a or the b value is active.

Exceptions

TypeError if the B tree's configuration doesn't match this tree's or if this tree's ValueType is not constructible from the B tree's ValueType.

See also: openvdb/Types.h for the definition of the CombineArgs struct.

Example:: Compute the per-voxel maximum values of two single-precision floating-point trees, aTree and bTree, and store the result in a third tree. Set the active state of each output value to that of the larger of the two input values.
{
struct Local {
static inline void max(CombineArgs<float>& args) {
if (args.b() > args.a()) {
// Transfer the B value and its active state.
args.setResult(args.b());
args.setResultIsActive(args.bIsActive());
} else {
// Preserve the A value and its active state.
args.setResult(args.a());
args.setResultIsActive(args.aIsActive());
}
}
};
FloatTree aTree = ...;
FloatTree bTree = ...;
FloatTree resultTree;
resultTree.combine2Extended(aTree, bTree, Local::max);
}

Example:: Compute the per-voxel maximum values of a double-precision and a single-precision floating-point tree, aTree and bTree, and store the result in a third, double-precision tree. Set the active state of each output value to that of the larger of the two input values.
{
struct Local {
static inline void max(CombineArgs<double, float>& args) {
if (args.b() > args.a()) {
// Transfer the B value and its active state.
args.setResult(args.b());
args.setResultIsActive(args.bIsActive());
} else {
// Preserve the A value and its active state.
args.setResult(args.a());
args.setResultIsActive(args.aIsActive());
}
}
};
DoubleTree aTree = ...;
FloatTree bTree = ...;
DoubleTree resultTree;
resultTree.combine2Extended(aTree, bTree, Local::max);
}

void combine2Extended	(	const Tree< _RootNodeType > &	a,
		const OtherTreeType &	b,
		const ExtendedCombineOp &	op,
		bool	prune = `false`
	)

inline

void combineExtended	(	Tree< _RootNodeType > &	other,
		ExtendedCombineOp &	op,
		bool	prune = `false`
	)

inline

Like combine(), but with

Parameters

other	a tree of the same type as this tree
op	a functor of the form `void op(CombineArgs<ValueType>& args)` that computes `args.setResult(f(args.a(), args.b()))` and, optionally, `args.setResultIsActive(g(args.aIsActive(), args.bIsActive()))` for some functions `f` and `g`
prune	if true, prune the resulting tree one branch at a time (this is usually more space-efficient than pruning the entire tree in one pass)

This variant passes not only the a and b values but also the active states of the a and b values to the functor, which may then return, by calling args.setResultIsActive(), a computed active state for the result value. By default, the result is active if either the a or the b value is active.

See also: openvdb/Types.h for the definition of the CombineArgs struct.

Example:: Replace voxel values in floating-point aTree with corresponding values from floating-point bTree (leaving bTree empty) wherever the bTree values are larger. Also, preserve the active states of any transferred values.
{
struct Local {
static inline void max(CombineArgs<float>& args) {
if (args.b() > args.a()) {
// Transfer the B value and its active state.
args.setResult(args.b());
args.setResultIsActive(args.bIsActive());
} else {
// Preserve the A value and its active state.
args.setResult(args.a());
args.setResultIsActive(args.aIsActive());
}
}
};
aTree.combineExtended(bTree, Local::max);
}

void combineExtended	(	Tree< _RootNodeType > &	other,
		const ExtendedCombineOp &	op,
		bool	prune = `false`
	)

inline

TreeBase::Ptr copy ( ) const

inlineoverridevirtual

Return a pointer to a deep copy of this tree.

Implements TreeBase.

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

inline

Set all voxels within a given axis-aligned box to a constant value and ensure that those voxels are all represented at the leaf level.

Parameters

bbox	inclusive coordinates of opposite corners of an axis-aligned box.
value	the value to which to set voxels within the box.
active	if true, mark voxels within the box as active, otherwise mark them as inactive.

See also: voxelizeActiveTiles()

bool empty ( ) const

inline

Return true if this tree contains no nodes other than the root node and no tiles other than background tiles.

bool evalActiveVoxelBoundingBox ( CoordBBox & bbox ) const

inlineoverridevirtual

Return in bbox the axis-aligned bounding box of all active voxels and tiles.

This method produces a more accurate, i.e. tighter, bounding box than evalLeafBoundingBox which is approximate but faster.

Returns: false if the bounding box is empty (in which case the bbox is set to its default value).

Implements TreeBase.

bool evalActiveVoxelDim ( Coord & dim ) const

inlineoverridevirtual

Return in dim the dimensions of the axis-aligned bounding box of all active voxels. This is a tighter bounding box than the leaf node bounding box.

Returns: false if the bounding box is empty.

Implements TreeBase.

bool evalLeafBoundingBox ( CoordBBox & bbox ) const

inlineoverridevirtual

Return in bbox the axis-aligned bounding box of all active tiles and leaf nodes with active values.

This is faster than calling evalActiveVoxelBoundingBox, which visits the individual active voxels, and hence evalLeafBoundingBox produces a less tight, i.e. approximate, bbox.

Returns: false if the bounding box is empty (in which case the bbox is set to its default value).

Implements TreeBase.

bool evalLeafDim ( Coord & dim ) const

inlineoverridevirtual

Return in dim the dimensions of the axis-aligned bounding box of all leaf nodes.

Returns: false if the bounding box is empty.

Implements TreeBase.

void evalMinMax	(	ValueType &	min,
		ValueType &	max
	)		const

inline

Return the minimum and maximum active values in this tree.

void fill	(	const CoordBBox &	bbox,
		const ValueType &	value,
		bool	active = `true`
	)

inline

Set all voxels within a given axis-aligned box to a constant value.

Parameters

bbox	inclusive coordinates of opposite corners of an axis-aligned box
value	the value to which to set voxels within the box
active	if true, mark voxels within the box as active, otherwise mark them as inactive

Note: This operation generates a sparse, but not always optimally sparse, representation of the filled box. Follow fill operations with a prune() operation for optimal sparseness.

Metadata::Ptr getBackgroundValue ( ) const

overridevirtual

Return this tree's background value wrapped as metadata.

Note: Query the metadata object for the value's type.

Reimplemented from TreeBase.

void getIndexRange ( CoordBBox & bbox ) const

inlineoverridevirtual

Min and max are both inclusive.

Implements TreeBase.

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

inlinestatic

Traverse the type hierarchy of nodes, and return, in dims, a list of the Log2Dims of nodes in order from RootNode to LeafNode.

Note: Because RootNodes are resizable, the RootNode Log2Dim is 0 for all trees.

void getNodes ( ArrayT & array )

inline

Adds all nodes of a certain type to a container with the following API:

struct ArrayT {
   using value_type = ...;             // the type of node to be added to the array
   void push_back(value_type nodePtr); // add a node to the array
};

An example of a wrapper around a c-style array is:

 struct MyArray {
    using value_type = LeafType*;
    value_type* ptr;
    MyArray(value_type* array) : ptr(array) {}
    void push_back(value_type leaf) { *ptr++ = leaf; }
};

An example that constructs a list of pointer to all leaf nodes is:

std::vector<const LeafNodeType*> array;//most std contains have the required API
array.reserve(tree.leafCount());//this is a fast preallocation.
tree.getNodes(array);

void getNodes ( ArrayT & array ) const

inline

Adds all nodes of a certain type to a container with the following API:

struct ArrayT {
   using value_type = ...;             // the type of node to be added to the array
   void push_back(value_type nodePtr); // add a node to the array
};

An example of a wrapper around a c-style array is:

 struct MyArray {
    using value_type = LeafType*;
    value_type* ptr;
    MyArray(value_type* array) : ptr(array) {}
    void push_back(value_type leaf) { *ptr++ = leaf; }
};

An example that constructs a list of pointer to all leaf nodes is:

std::vector<const LeafNodeType*> array;//most std contains have the required API
array.reserve(tree.leafCount());//this is a fast preallocation.
tree.getNodes(array);

const RootNodeType::ValueType & getValue ( const Coord & xyz ) const

inline

Return the value of the voxel at the given coordinates.

const ValueType& getValue	(	const Coord &	xyz,
		AccessT &
	)		const

Return the value of the voxel at the given coordinates and update the given accessor's node cache.

const RootNodeType::ValueType& getValue	(	const Coord &	xyz,
		AccessT &	accessor
	)		const

inline

int getValueDepth ( const Coord & xyz ) const

inline

Return the tree depth (0 = root) at which the value of voxel (x, y, z) resides.

If (x, y, z) isn't explicitly represented in the tree (i.e., it is implicitly a background voxel), return -1.

bool hasActiveTiles ( ) const

inline

Return true if this tree has any active tiles.

bool hasSameTopology ( const Tree< OtherRootNodeType > & other ) const

inline

Return true if the given tree has the same node and active value topology as this tree, whether or not it has the same ValueType.

Index64 inactiveLeafVoxelCount ( ) const

inlineoverridevirtual

Return the number of inactive voxels stored in leaf nodes.

Implements TreeBase.

Index64 inactiveVoxelCount ( ) const

inlineoverridevirtual

Return the number of inactive voxels within the bounding box of all active voxels.

Implements TreeBase.

bool isValueOff ( const Coord & xyz ) const

inline

Return true if the value at the given coordinates is inactive.

bool isValueOn ( const Coord & xyz ) const

inline

Return true if the value at the given coordinates is active.

Index32 leafCount ( ) const

inlineoverridevirtual

Return the number of leaf nodes.

Implements TreeBase.

Index64 memUsage ( ) const

inlineoverridevirtual

Return the total amount of memory in bytes occupied by this tree.

Reimplemented from TreeBase.

void merge	(	Tree< _RootNodeType > &	other,
		MergePolicy	policy = `MERGE_ACTIVE_STATES`
	)

inline

Efficiently merge another tree into this tree using one of several schemes.

This operation is primarily intended to combine trees that are mostly non-overlapping (for example, intermediate trees from computations that are parallelized across disjoint regions of space).

Note: This operation is not guaranteed to produce an optimally sparse tree. Follow merge() with prune() for optimal sparseness.

Warning: This operation always empties the other tree.

void modifyValue	(	const Coord &	xyz,
		const ModifyOp &	op
	)

inline

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

Provided that the functor can be inlined, this is typically significantly faster than calling getValue() followed by setValueOn().

Parameters

xyz	the coordinates of a voxel whose value is to be modified
op	a functor of the form `void op(ValueType&) const` that modifies its argument in place

Example:: Coord xyz(1, 0, -2);
// Multiply the value of a voxel by a constant and mark the voxel as active.
floatTree.modifyValue(xyz, [](float& f) { f *= 0.25; }); // C++11
// Set the value of a voxel to the maximum of its current value and 0.25,
// and mark the voxel as active.
floatTree.modifyValue(xyz, [](float& f) { f = std::max(f, 0.25f); }); // C++11

Note: The functor is not guaranteed to be called only once.

See also: tools::foreach()

void modifyValueAndActiveState	(	const Coord &	xyz,
		const ModifyOp &	op
	)

inline

Apply a functor to the voxel at the given coordinates.

Provided that the functor can be inlined, this is typically significantly faster than calling getValue() followed by setValue().

Parameters

xyz	the coordinates of a voxel to be modified
op	a functor of the form `void op(ValueType&, bool&) const` that modifies its arguments, a voxel's value and active state, in place

Example:: Coord xyz(1, 0, -2);
// Multiply the value of a voxel by a constant and mark the voxel as inactive.
floatTree.modifyValueAndActiveState(xyz,
[](float& f, bool& b) { f *= 0.25; b = false; }); // C++11
// Set the value of a voxel to the maximum of its current value and 0.25,
// but don't change the voxel's active state.
floatTree.modifyValueAndActiveState(xyz,
[](float& f, bool&) { f = std::max(f, 0.25f); }); // C++11

Note: The functor is not guaranteed to be called only once.

See also: tools::foreach()

std::vector<Index32> nodeCount ( ) const

inlineoverridevirtual

Return a vector with node counts. The number of nodes of type NodeType is given as element NodeType::LEVEL in the return vector. Thus, the size of this vector corresponds to the height (or depth) of this tree.

Implements TreeBase.

Index32 nonLeafCount ( ) const

inlineoverridevirtual

Return the number of non-leaf nodes.

Implements TreeBase.

bool operator!= ( const Tree< _RootNodeType > & ) const

inline

Tree& operator= ( const Tree< _RootNodeType > & )

delete

bool operator== ( const Tree< _RootNodeType > & ) const

inline

void print	(	std::ostream &	os = `std::cout`,
		int	verboseLevel = `1`
	)		const

inlineoverridevirtual

Print statistics, memory usage and other information about this tree.

Parameters

os	a stream to which to write textual information
verboseLevel	1: print tree configuration only; 2: include node and voxel statistics; 3: include memory usage; 4: include minimum and maximum voxel values

Warning: verboseLevel 4 forces loading of any unallocated nodes.

Reimplemented from TreeBase.

const RootNodeType::LeafNodeType * probeConstLeaf ( const Coord & xyz ) const

inline

Return a pointer to the leaf node that contains voxel (x, y, z). If no such node exists, return nullptr.

const NodeType * probeConstNode ( const Coord & xyz ) const

inline

Return a pointer to the node of type NodeType that contains voxel (x, y, z). If no such node exists, return nullptr.

RootNodeType::LeafNodeType * probeLeaf ( const Coord & xyz )

inline

Return a pointer to the leaf node that contains voxel (x, y, z). If no such node exists, return nullptr.

const LeafNodeType* probeLeaf ( const Coord & xyz ) const

inline

Return a pointer to the leaf node that contains voxel (x, y, z). If no such node exists, return nullptr.

NodeType * probeNode ( const Coord & xyz )

inline

Return a pointer to the node of type NodeType that contains voxel (x, y, z). If no such node exists, return nullptr.

const NodeType * probeNode ( const Coord & xyz ) const

inline

Return a pointer to the node of type NodeType that contains voxel (x, y, z). If no such node exists, return nullptr.

bool probeValue	(	const Coord &	xyz,
		ValueType &	value
	)		const

inline

Get the value of the voxel at the given coordinates.

Returns: true if the value is active.

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

inline

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

Warning: Will soon be deprecated!

void readBuffers	(	std::istream &	is,
		bool	saveFloatAsHalf = `false`
	)

inlineoverridevirtual

Read all data buffers for this tree.

Implements TreeBase.

void readBuffers	(	std::istream &	is,
		const CoordBBox &	bbox,
		bool	saveFloatAsHalf = `false`
	)

inlineoverridevirtual

Read all of this tree's data buffers that intersect the given bounding box.

Implements TreeBase.

void readNonresidentBuffers ( ) const

inlineoverridevirtual

Read all of this tree's data buffers that are not yet resident in memory (because delayed loading is in effect).

If this tree was read from a memory-mapped file, this operation disconnects the tree from the file.

See also: clipUnallocatedNodes, io::File::open, io::MappedFile

Implements TreeBase.

void readTopology	(	std::istream &	is,
		bool	saveFloatAsHalf = `false`
	)

overridevirtual

Read the tree topology from a stream.

This will read the tree structure and tile values, but not voxel data.

Reimplemented from TreeBase.

void releaseAccessor ( ValueAccessorBase< Tree< _RootNodeType >, true > & accessor ) const

inline

Deregister an accessor so that it is no longer automatically cleared.

void releaseAccessor ( ValueAccessorBase< const Tree< _RootNodeType >, true > & accessor ) const

inline

Deregister an accessor so that it is no longer automatically cleared.

void releaseAccessor ( ValueAccessorBase< Tree< _RootNodeType >, false > & ) const

inline

Dummy implementations.

void releaseAccessor ( ValueAccessorBase< const Tree< _RootNodeType >, false > & ) const

inline

Dummy implementations.

void releaseAllAccessors ( )

inlineprotected

Notify all registered accessors, by calling ValueAccessor::release(), that this tree is about to be deleted.

RootNodeType& root ( )

inline

Return this tree's root node.

const RootNodeType& root ( ) const

inline

Return this tree's root node.

void setActiveState	(	const Coord &	xyz,
		bool	on
	)

inline

Set the active state of the voxel at the given coordinates but don't change its value.

void setValue	(	const Coord &	xyz,
		const ValueType &	value
	)

inline

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

void setValue	(	const Coord &	xyz,
		const ValueType &	value,
		AccessT &	accessor
	)

inline

Set the value of the voxel at the given coordinates, mark the voxel as active, and update the given accessor's node cache.

void setValueOff ( const Coord & xyz )

inline

Mark the voxel at the given coordinates as inactive but don't change its value.

void setValueOff	(	const Coord &	xyz,
		const ValueType &	value
	)

inline

Set the value of the voxel at the given coordinates and mark the voxel as inactive.

void setValueOn ( const Coord & xyz )

inline

Mark the voxel at the given coordinates as active but don't change its value.

void setValueOn	(	const Coord &	xyz,
		const ValueType &	value
	)

inline

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

void setValueOnly	(	const Coord &	xyz,
		const ValueType &	value
	)

inline

Set the value of the voxel at the given coordinates but don't change its active state.

void sparseFill	(	const CoordBBox &	bbox,
		const ValueType &	value,
		bool	active = `true`
	)

inline

Set all voxels within a given axis-aligned box to a constant value.

Parameters

bbox	inclusive coordinates of opposite corners of an axis-aligned box
value	the value to which to set voxels within the box
active	if true, mark voxels within the box as active, otherwise mark them as inactive

Note: This operation generates a sparse, but not always optimally sparse, representation of the filled box. Follow fill operations with a prune() operation for optimal sparseness.

NodeT * stealNode	(	const Coord &	xyz,
		const ValueType &	value,
		bool	active
	)

inline

Return a pointer to the node of type NodeT that contains voxel (x, y, z) and replace it with a tile of the specified value and state. If no such node exists, leave the tree unchanged and return nullptr.

Note: The caller takes ownership of the node and is responsible for deleting it.

void stealNodes ( ArrayT & array )

inline

Steals all nodes of a certain type from the tree and adds them to a container with the following API:

struct ArrayT {
   using value_type = ...;             // the type of node to be added to the array
   void push_back(value_type nodePtr); // add a node to the array
};

An example of a wrapper around a c-style array is:

 struct MyArray {
    using value_type = LeafType*;
    value_type* ptr;
    MyArray(value_type* array) : ptr(array) {}
    void push_back(value_type leaf) { *ptr++ = leaf; }
};

An example that constructs a list of pointer to all leaf nodes is:

std::vector<const LeafNodeType*> array;//most std contains have the required API
array.reserve(tree.leafCount());//this is a fast preallocation.
tree.stealNodes(array);

void stealNodes	(	ArrayT &	array,
		const ValueType &	value,
		bool	state
	)

inline

void topologyDifference ( const Tree< OtherRootNodeType > & other )

inline

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

Note: This operation can delete branches in this grid if they overlap with active tiles in the other grid. Likewise active voxels can be turned into inactive voxels resulting in leaf nodes with no active values. Thus, it is recommended to subsequently call tools::pruneInactive.

void topologyIntersection ( const Tree< OtherRootNodeType > & other )

inline

Intersects this tree's set of active values with the active values of the other tree, whose ValueType may be different.

The resulting state of a value is active only if the corresponding value was already active AND if it is active in the other tree. Also, a resulting value maps to a voxel if the corresponding value already mapped to an active voxel in either of the two grids and it maps to an active tile or voxel in the other grid.

Note: This operation can delete branches in this grid if they overlap with inactive tiles in the other grid. Likewise active voxels can be turned into inactive voxels resulting in leaf nodes with no active values. Thus, it is recommended to subsequently call tools::pruneInactive.

void topologyUnion	(	const Tree< OtherRootNodeType > &	other,
		const bool	preserveTiles = `false`
	)

inline

Union this tree's set of active values with the active values of the other tree, whose ValueType may be different.

The resulting state of a value is active if the corresponding value was already active OR if it is active in the other tree. Also, a resulting value maps to a voxel if the corresponding value already mapped to a voxel OR if it is a voxel in the other tree. Thus, a resulting value can only map to a tile if the corresponding value already mapped to a tile AND if it is a tile value in other tree.

Note: This operation modifies only active states, not values. Specifically, active tiles and voxels in this tree are not changed, and tiles or voxels that were inactive in this tree but active in the other tree are marked as active in this tree but left with their original values.; If preserveTiles is true, any active tile in this topology will not be densified by overlapping child topology.

RootNodeType::LeafNodeType * touchLeaf ( const Coord & xyz )

inline

Return a pointer to the leaf node that contains voxel (x, y, z). If no such node exists, create one that preserves the values and active states of all voxels.

Use this method to preallocate a static tree topology over which to safely perform multithreaded processing.

Index treeDepth ( ) const

inlineoverridevirtual

Return the depth of this tree.

A tree with only a root node and leaf nodes has depth 2, for example.

Implements TreeBase.

const Name & treeType ( )

inlinestatic

Return the name of this type of tree.

const Name& type ( ) const

inlineoverridevirtual

Return the name of this type of tree.

Implements TreeBase.

Index32 unallocatedLeafCount ( ) const

inlineoverridevirtual

Return the total number of unallocated leaf nodes residing in this tree.

Implements TreeBase.

Name valueType ( ) const

inlineoverridevirtual

Return the name of the type of a voxel's value (e.g., "float" or "vec3d")

Implements TreeBase.

void visit ( VisitorOp & op )

inline

Deprecated:: "Use tools::visitNodesDepthFirst or DynamicNodeManager instead"

void visit ( const VisitorOp & op )

inline

Deprecated:: "Use tools::visitNodesDepthFirst or DynamicNodeManager instead"

void visit ( VisitorOp & op ) const

inline

Deprecated:: "Use tools::visitNodesDepthFirst or DynamicNodeManager instead"

void visit ( const VisitorOp & op ) const

inline

Deprecated:: "Use tools::visitNodesDepthFirst or DynamicNodeManager instead"

void visit2	(	OtherTreeType &	other,
		VisitorOp &	op
	)

inline

Deprecated:: "Use tools::visitNodesDepthFirst or DynamicNodeManager instead"

void visit2	(	OtherTreeType &	other,
		const VisitorOp &	op
	)

inline

Deprecated:: "Use tools::visitNodesDepthFirst or DynamicNodeManager instead"

void visit2	(	OtherTreeType &	other,
		VisitorOp &	op
	)		const

inline

Deprecated:: "Use tools::visitNodesDepthFirst or DynamicNodeManager instead"

void visit2	(	OtherTreeType &	other,
		const VisitorOp &	op
	)		const

inline

Deprecated:: "Use tools::visitNodesDepthFirst or DynamicNodeManager instead"

void visitActiveBBox ( BBoxOp & op ) const

inline

Deprecated:: "Use tools::visitNodesDepthFirst or DynamicNodeManager instead"

void voxelizeActiveTiles ( bool threaded = true )

inline

Densify active tiles, i.e., replace them with leaf-level active voxels.

Parameters

threaded if true, this operation is multi-threaded (over the internal nodes).

Warning: This method can explode the tree's memory footprint, especially if it contains active tiles at the upper levels (in particular the root level)!

See also: denseFill()

void writeBuffers	(	std::ostream &	os,
		bool	saveFloatAsHalf = `false`
	)		const

inlineoverridevirtual

Write out all data buffers for this tree.

Implements TreeBase.

void writeTopology	(	std::ostream &	os,
		bool	saveFloatAsHalf = `false`
	)		const

overridevirtual

Write the tree topology to a stream.

This will write the tree structure and tile values, but not voxel data.

Reimplemented from TreeBase.

Member Data Documentation

const Index DEPTH = RootNodeType::LEVEL + 1

static

AccessorRegistry mAccessorRegistry

mutableprotected

ConstAccessorRegistry mConstAccessorRegistry

mutableprotected

RootNodeType mRoot

protected

std::unique_ptr< const Name > sTreeTypeName

staticprotected

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation