Merge pull request #2154 from danrbailey/node_visitor_bottom_up

Extend visitNodesDepthFirst() to offer bottom-up traversal

Author: danrbailey

openvdb/openvdb/tools/NodeVisitor.h

@@ -30,6 +30,9 @@ namespace tools {
 /// @param op        user-supplied functor, see examples for interface details.
 /// @param idx       optional offset to start sequential node indexing from a
 ///                  non-zero index.
+/// @param topDown   if true, visit parent nodes before their children
+///                  (pre-order traversal). If false, visit children before
+///                  their parent nodes (post-order traversal). Defaults to true.
 ///
 /// @warning This method is single-threaded. Use the NodeManager or
 ///  DynamicNodeManager for much greater threaded performance.
@@ -173,7 +176,7 @@ namespace tools {
 ///
 /// @endcode
 template <typename TreeT, typename OpT>
-size_t visitNodesDepthFirst(TreeT& tree, OpT& op, size_t idx = 0);
+size_t visitNodesDepthFirst(TreeT& tree, OpT& op, size_t idx = 0, bool topDown = true);
 
 
 /// @brief Visit all nodes that are downstream of a specific node in
@@ -199,14 +202,15 @@ struct DepthFirstNodeVisitor
     using ChildNodeType = typename CopyConstness<NodeT, NonConstChildType>::Type;
 
     template <typename OpT>
-    static size_t visit(NodeT& node, OpT& op, size_t idx = 0)
+    static size_t visit(NodeT& node, OpT& op, size_t idx = 0, bool topDown = true)
     {
         size_t offset = 0;
-        op(node, idx + offset++);
+        if (topDown)    op(node, idx + offset++);
         for (auto iter = node.beginChildOn(); iter; ++iter) {
             offset += DepthFirstNodeVisitor<ChildNodeType>::visit(
-                *iter, op, idx + offset);
+                *iter, op, idx + offset, topDown);
         }
+        if (!topDown)    op(node, idx + offset++);
         return offset;
     }
 };
@@ -217,7 +221,7 @@ template <typename NodeT>
 struct DepthFirstNodeVisitor<NodeT, 0>
 {
     template <typename OpT>
-    static size_t visit(NodeT& node, OpT& op, size_t idx = 0)
+    static size_t visit(NodeT& node, OpT& op, size_t idx = 0, bool /*topDown*/ = true)
     {
         op(node, idx);
         return size_t(1);
@@ -226,12 +230,12 @@ struct DepthFirstNodeVisitor<NodeT, 0>
 
 
 template <typename TreeT, typename OpT>
-size_t visitNodesDepthFirst(TreeT& tree, OpT& op, size_t idx)
+size_t visitNodesDepthFirst(TreeT& tree, OpT& op, size_t idx, bool topDown)
 {
     using NonConstRootNodeType = typename TreeT::RootNodeType;
     using RootNodeType = typename CopyConstness<TreeT, NonConstRootNodeType>::Type;
 
-    return DepthFirstNodeVisitor<RootNodeType>::visit(tree.root(), op, idx);
+    return DepthFirstNodeVisitor<RootNodeType>::visit(tree.root(), op, idx, topDown);
 }
 
 

openvdb/openvdb/unittest/TestNodeVisitor.cc

@@ -286,3 +286,46 @@ TEST_F(TestNodeVisitor, testOffset)
     OffsetByLevelOp<FloatTree> byLevelOp(3.0f);
     tools::visitNodesDepthFirst(grid->tree(), byLevelOp);
 }
+
+
+struct RecordLevelOrderOp
+{
+    template <typename NodeT>
+    void operator()(const NodeT&, size_t)
+    {
+        const openvdb::Index level = NodeT::LEVEL;
+        levels.push_back(level);
+    }
+
+    std::vector<openvdb::Index> levels;
+}; // struct RecordLevelOrderOp
+
+
+TEST_F(TestNodeVisitor, testTopDownBottomUp)
+{
+    using namespace openvdb;
+
+    FloatGrid::Ptr grid = tools::createLevelSetCube<FloatGrid>(/*scale=*/10.0f);
+
+    // Visit with topDown=true (pre-order: parent before children)
+    RecordLevelOrderOp topDownOp;
+    tools::visitNodesDepthFirst(grid->tree(), topDownOp, 0, true);
+
+    // Visit with topDown=false (post-order: children before parent)
+    RecordLevelOrderOp bottomUpOp;
+    tools::visitNodesDepthFirst(grid->tree(), bottomUpOp, 0, false);
+
+    // Both should visit the same number of nodes
+    EXPECT_EQ(topDownOp.levels.size(), bottomUpOp.levels.size());
+    EXPECT_GT(topDownOp.levels.size(), size_t(0));
+
+    // Top-down: first element should be the root (highest level)
+    const Index rootLevel = FloatTree::RootNodeType::LEVEL;
+    EXPECT_EQ(topDownOp.levels.front(), rootLevel);
+
+    // Bottom-up: last element should be the root (highest level)
+    EXPECT_EQ(bottomUpOp.levels.back(), rootLevel);
+
+    // The two sequences should not be identical (different traversal order)
+    EXPECT_NE(topDownOp.levels, bottomUpOp.levels);
+}

pendingchanges/nodevisitorbottomup.txt

@@ -0,0 +1,3 @@
+OpenVDB:
+  Improvements:
+  - Extend tools::visitNodesDepthFirst() to be able to perform bottom-up traversal in addition to top-down traversal.