OpenVDB 7.0.0

Public Types | Public Member Functions | Static Public Attributes | Protected Attributes | List of all members
NodeManager< TreeOrLeafManagerT, _LEVELS > Class Template Reference

To facilitate threading over the nodes of a tree, cache node pointers in linear arrays, one for each level of the tree. More...

`#include <NodeManager.h>`

## Public Types
using | RootNodeType = typename TreeOrLeafManagerT::RootNodeType

## Public Member Functions
| NodeManager (TreeOrLeafManagerT &tree)
virtual | ~NodeManager ()
void | clear ()
| Clear all the cached tree nodes. More...
void | rebuild ()
| Clear and recache all the tree nodes from the tree. This is required if tree nodes have been added or removed. More...
const RootNodeType & | root () const
| Return a reference to the root node. More...
Index64 | nodeCount () const
| Return the total number of cached nodes (excluding the root node) More...
Index64 | nodeCount (Index i) const
| Return the number of cached nodes at level i, where 0 corresponds to the lowest level. More...
template<typename NodeOp >
void | foreachBottomUp (const NodeOp &op, bool threaded=true, size_t grainSize=1)
| Threaded method that applies a user-supplied functor to all the nodes in the tree. More...
template<typename NodeOp >
void | foreachTopDown (const NodeOp &op, bool threaded=true, size_t grainSize=1)
template<typename NodeOp >
void | reduceBottomUp (NodeOp &op, bool threaded=true, size_t grainSize=1)
| Threaded method that processes nodes with a user supplied functor. More...
template<typename NodeOp >
void | reduceTopDown (NodeOp &op, bool threaded=true, size_t grainSize=1)

## Static Public Attributes
static const Index | LEVELS = _LEVELS

## Protected Attributes
RootNodeType & | mRoot
NodeManagerLink< typename RootNodeType::ChildNodeType, LEVELS-1 > | mChain

## Detailed Description

### template<typename TreeOrLeafManagerT, Index _LEVELS>
class openvdb::v7_0::tree::NodeManager< TreeOrLeafManagerT, _LEVELS >

To facilitate threading over the nodes of a tree, cache node pointers in linear arrays, one for each level of the tree.

This implementation works with trees of any depth, but optimized specializations are provided for the most typical tree depths.

## Member Typedef Documentation

## ◆ RootNodeType

using RootNodeType = typename TreeOrLeafManagerT::RootNodeType

## Constructor & Destructor Documentation

## ◆ NodeManager()

NodeManager | ( | TreeOrLeafManagerT & | tree | ) |
| inline

## ◆ ~NodeManager()

virtual ~NodeManager | ( |  | ) |
| inline virtual

## Member Function Documentation

## ◆ clear()

void clear | ( |  | ) |
| inline

Clear all the cached tree nodes.

## ◆ foreachBottomUp()

void foreachBottomUp | ( | const NodeOp & | op,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

Threaded method that applies a user-supplied functor to all the nodes in the tree.

Parameters

  op | user-supplied functor, see examples for interface details.
  threaded | optional toggle to disable threading, on by default.
  grainSize | optional parameter to specify the grainsize for threading, one by default.

Warning
  The functor object is deep-copied to create TBB tasks.

Example:
  // Functor to offset all the inactive values of a tree. Note
  // this implementation also illustrates how different
  // computation can be applied to the different node types.
  template<typename TreeType>
  struct OffsetOp
  {
  using ValueT = typename TreeT::ValueType;
  using RootT = typename TreeT::RootNodeType;
  using LeafT = typename TreeT::LeafNodeType;
  OffsetOp(const ValueT& v) : mOffset(v) {}
  // Processes the root node. Required by the NodeManager
  void operator()(RootT& root) const
  {
  for (typename RootT::ValueOffIter i = root.beginValueOff(); i; ++i) *i += mOffset;
  }
  // Processes the leaf nodes. Required by the NodeManager
  void operator()(LeafT& leaf) const
  {
  for (typename LeafT::ValueOffIter i = leaf.beginValueOff(); i; ++i) *i += mOffset;
  }
  // Processes the internal nodes. Required by the NodeManager
  template<typename NodeT>
  void operator()(NodeT& node) const
  {
  for (typename NodeT::ValueOffIter i = node.beginValueOff(); i; ++i) *i += mOffset;
  }
  private:
  const ValueT mOffset;
  };
  // usage:
  OffsetOp<FloatTree> op(3.0f);
  tree::NodeManager<FloatTree> nodes(tree);
  nodes.foreachBottomUp(op);
  // or if a LeafManager already exists
  using T = tree::LeafManager<FloatTree>;
  OffsetOp<T> op(3.0f);
  tree::NodeManager<T> nodes(leafManager);
  nodes.foreachBottomUp(op);

## ◆ foreachTopDown()

void foreachTopDown | ( | const NodeOp & | op,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

## ◆ nodeCount() [1/2]

Index64 nodeCount | ( |  | ) | const
| inline

Return the total number of cached nodes (excluding the root node)

## ◆ nodeCount() [2/2]

Index64 nodeCount | ( | Index | i | ) | const
| inline

Return the number of cached nodes at level i, where 0 corresponds to the lowest level.

## ◆ rebuild()

void rebuild | ( |  | ) |
| inline

Clear and recache all the tree nodes from the tree. This is required if tree nodes have been added or removed.

## ◆ reduceBottomUp()

void reduceBottomUp | ( | NodeOp & | op,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

Threaded method that processes nodes with a user supplied functor.

Parameters

  op | user-supplied functor, see examples for interface details.
  threaded | optional toggle to disable threading, on by default.
  grainSize | optional parameter to specify the grainsize for threading, one by default.

Warning
  The functor object is deep-copied to create TBB tasks.

Example:
  // Functor to count nodes in a tree
  template<typename TreeType>
  struct NodeCountOp
  {
  NodeCountOp() : nodeCount(TreeType::DEPTH, 0), totalCount(0)
  {
  }
  NodeCountOp(const NodeCountOp& other, tbb::split) :
  nodeCount(TreeType::DEPTH, 0), totalCount(0)
  {
  }
  void join(const NodeCountOp& other)
  {
  for (size_t i = 0; i < nodeCount.size(); ++i) {
  nodeCount[i] += other.nodeCount[i];
  }
  totalCount += other.totalCount;
  }
  // do nothing for the root node
  void operator()(const typename TreeT::RootNodeType& node)
  {
  }
  // count the internal and leaf nodes
  template<typename NodeT>
  void operator()(const NodeT& node)
  {
  ++(nodeCount[NodeT::LEVEL]);
  ++totalCount;
  }
  std::vector<openvdb::Index64> nodeCount;
  openvdb::Index64 totalCount;
  };
  // usage:
  NodeCountOp<FloatTree> op;
  tree::NodeManager<FloatTree> nodes(tree);
  nodes.reduceBottomUp(op);
  // or if a LeafManager already exists
  NodeCountOp<FloatTree> op;
  using T = tree::LeafManager<FloatTree>;
  T leafManager(tree);
  tree::NodeManager<T> nodes(leafManager);
  nodes.reduceBottomUp(op);

## ◆ reduceTopDown()

void reduceTopDown | ( | NodeOp & | op,
|  | bool | threaded = `true`,
|  | size_t | grainSize = `1`
| ) |  |
| inline

## ◆ root()

const RootNodeType& root | ( |  | ) | const
| inline

Return a reference to the root node.

## Member Data Documentation

## ◆ LEVELS

const Index LEVELS = _LEVELS
| static

## ◆ mChain

NodeManagerLink<typename RootNodeType::ChildNodeType, LEVELS-1> mChain
| protected

## ◆ mRoot

RootNodeType& mRoot
| protected

The documentation for this class was generated from the following file:

- NodeManager.h

openvdb::v7_0::tree::NodeManager::root
const RootNodeType & root() const
Return a reference to the root node.
Definition: NodeManager.h:377
openvdb::v7_0::tree::NodeManager::nodeCount
Index64 nodeCount() const
Return the total number of cached nodes (excluding the root node)
Definition: NodeManager.h:380
openvdb::v7_0::Index64
uint64_t Index64
Definition: Types.h:30