Add AdaptiveTree and Grid registration

Signed-off-by: Dan Bailey <danbailey@ilm.com>

Author: danrbailey

openvdb/openvdb/CMakeLists.txt

@@ -403,6 +403,10 @@ set(OPENVDB_LIBRARY_IO_INCLUDE_FILES
   io/TempFile.h
 )
 
+set(OPENVDB_LIBRARY_ADAPTIVE_INCLUDE_FILES
+  adaptive/AdaptiveGrid.h
+)
+
 set(OPENVDB_LIBRARY_MATH_INCLUDE_FILES
   math/BBox.h
   math/ConjGradient.h

openvdb/openvdb/adaptive/AdaptiveGrid.h

@@ -0,0 +1,218 @@
+// Copyright Contributors to the OpenVDB Project
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef OPENVDB_ADAPTIVE_ADAPTIVE_GRID_HAS_BEEN_INCLUDED
+#define OPENVDB_ADAPTIVE_ADAPTIVE_GRID_HAS_BEEN_INCLUDED
+
+#include <openvdb/version.h>
+#include <openvdb/Grid.h>
+#include <openvdb/tree/Tree.h>
+
+
+namespace openvdb {
+OPENVDB_USE_VERSION_NAMESPACE
+namespace OPENVDB_VERSION_NAME {
+
+
+////////////////////////////////////////
+
+
+namespace adaptive {
+
+
+template<typename _ValueType>
+class AdaptiveTree final: public TreeBase
+{
+public:
+    using Ptr = SharedPtr<AdaptiveTree>;
+    using ConstPtr = SharedPtr<const AdaptiveTree>;
+
+    using ValueType = _ValueType;
+    using BuildType = _ValueType;
+
+    static const Index DEPTH = 1;
+
+    AdaptiveTree() = default;
+
+    AdaptiveTree& operator=(const AdaptiveTree&) = delete; // disallow assignment
+
+    /// Deep copy constructor
+    AdaptiveTree(const AdaptiveTree& other): TreeBase(other), mBackground(other.mBackground) { }
+
+    /// Empty tree constructor
+    AdaptiveTree(const ValueType& background): mBackground(background) { }
+
+    ~AdaptiveTree() override = default;
+
+    /// Return the name of this type of tree.
+    static const Name& treeType();
+
+    /// Return the name of this tree's type.
+    const Name& type() const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+    /// Return the name of the type of a voxel's value (e.g., "float" or "vec3d").
+    Name valueType() const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+    /// Return @c true if this tree is of the same type as the template parameter.
+    template<typename TreeType>
+    bool isType() const { return (this->type() == TreeType::treeType()); }
+
+    /// Return a pointer to a deep copy of this tree
+    TreeBase::Ptr copy() const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+    /// @brief Return this tree's background value.
+    const ValueType& background() const { return mBackground; }
+
+    /// @brief Return @c true if this tree contains no nodes.
+    bool empty() const { return true; }
+
+    /// Remove all nodes.
+    void clear() { }
+
+    /// @brief Not implemented.
+    void prune(const ValueType& /*tolerance*/ = zeroVal<ValueType>()) { OPENVDB_THROW(NotImplementedError, ""); }
+
+    /// @brief Not implemented.
+    void clip(const CoordBBox&) { OPENVDB_THROW(NotImplementedError, ""); }
+
+    //
+    // Tree methods
+    //
+
+    /// @brief Return in @a bbox the axis-aligned bounding box of all
+    /// active tiles and leaf nodes with active values.
+    /// @details This is faster than calling evalActiveVoxelBoundingBox,
+    /// which visits the individual active voxels, and hence
+    /// evalLeafBoundingBox produces a less tight, i.e. approximate, bbox.
+    /// @return @c false if the bounding box is empty (in which case
+    /// the bbox is set to its default value).
+    bool evalLeafBoundingBox(CoordBBox& /*bbox*/) const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+    /// @brief Return in @a dim the dimensions of the axis-aligned bounding box
+    /// of all leaf nodes.
+    /// @return @c false if the bounding box is empty.
+    bool evalLeafDim(Coord& /*dim*/) const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+    /// @brief Return in @a bbox the axis-aligned bounding box of all
+    /// active voxels and tiles.
+    /// @details This method produces a more accurate, i.e. tighter,
+    /// bounding box than evalLeafBoundingBox which is approximate but
+    /// faster.
+    /// @return @c false if the bounding box is empty (in which case
+    /// the bbox is set to its default value).
+    bool evalActiveVoxelBoundingBox(CoordBBox& /*bbox*/) const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+    /// @brief Return in @a 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.
+    /// @return @c false if the bounding box is empty.
+    bool evalActiveVoxelDim(Coord& /*dim*/) const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+    void getIndexRange(CoordBBox& /*bbox*/) const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+    /// @brief Replace with background tiles any nodes whose voxel buffers
+    /// have not yet been allocated.
+    /// @details Typically, unallocated nodes are leaf nodes whose voxel buffers
+    /// are not yet resident in memory because delayed loading is in effect.
+    /// @sa readNonresidentBuffers, io::File::open
+    void clipUnallocatedNodes() override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// Return the total number of unallocated leaf nodes residing in this tree.
+    Index32 unallocatedLeafCount() const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+
+    //
+    // Statistics
+    //
+    /// @brief Return the depth of this tree.
+    ///
+    /// A tree with only a root node and leaf nodes has depth 2, for example.
+    Index treeDepth() const override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// Return the number of leaf nodes.
+    Index32 leafCount() const override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// 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.
+    std::vector<Index32> nodeCount() const override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// Return the number of non-leaf nodes.
+    Index32 nonLeafCount() const override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// Return the number of active voxels stored in leaf nodes.
+    Index64 activeLeafVoxelCount() const override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// Return the number of inactive voxels stored in leaf nodes.
+    Index64 inactiveLeafVoxelCount() const override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// Return the total number of active voxels.
+    Index64 activeVoxelCount() const override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// Return the number of inactive voxels within the bounding box of all active voxels.
+    Index64 inactiveVoxelCount() const override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// Return the total number of active tiles.
+    Index64 activeTileCount() const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+
+    //
+    // I/O methods
+    //
+    /// Read all data buffers for this tree.
+    void readBuffers(std::istream&, bool /*saveFloatAsHalf*/ = false) override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// Read all of this tree's data buffers that intersect the given bounding box.
+    void readBuffers(std::istream&, const CoordBBox&, bool /*saveFloatAsHalf*/ = false) override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// @brief Read all of this tree's data buffers that are not yet resident in memory
+    /// (because delayed loading is in effect).
+    /// @details If this tree was read from a memory-mapped file, this operation
+    /// disconnects the tree from the file.
+    /// @sa clipUnallocatedNodes, io::File::open, io::MappedFile
+    void readNonresidentBuffers() const override { OPENVDB_THROW(NotImplementedError, ""); }
+    /// Write out all the data buffers for this tree.
+    void writeBuffers(std::ostream&, bool /*saveFloatAsHalf*/ = false) const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+    /// @brief Print statistics, memory usage and other information about this tree.
+    /// @param os            a stream to which to write textual information
+    /// @param verboseLevel  1: print tree configuration only;
+    ///                      2: include node and voxel statistics;
+    ///                      3: include memory usage;
+    ///                      4: include minimum and maximum voxel values
+    /// @warning @a verboseLevel 4 forces loading of any unallocated nodes.
+    void print(std::ostream& /*os*/ = std::cout, int /*verboseLevel*/ = 1) const override { OPENVDB_THROW(NotImplementedError, ""); }
+
+    /// @brief Dummy declarations to keep Grid class happy
+    using LeafNodeType = void;
+    using ValueAllIter = void;
+    using ValueAllCIter = void;
+    using ValueOnIter = void;
+    using ValueOnCIter = void;
+    using ValueOffIter = void;
+    using ValueOffCIter = void;
+
+private:
+    ValueType mBackground = zeroVal<ValueType>();
+}; // class AdaptiveTree
+
+
+
+////////////////////////////////////////
+
+
+template<typename ValueType>
+inline const Name&
+AdaptiveTree<ValueType>::treeType()
+{
+    static std::string sTreeTypeName = []()
+    {
+        std::ostringstream ostr;
+        ostr << "Adaptive_Tree_" << typeNameAsString<BuildType>();
+        return ostr.str();
+    }();
+    return sTreeTypeName;
+}
+
+
+/// @brief Adaptive grid.
+template <typename T>
+using AdaptiveGrid      = Grid<AdaptiveTree<T>>;
+
+using FloatAdaptiveGrid = AdaptiveGrid<float>;
+
+using AdaptiveGridTypes = TypeList<FloatAdaptiveGrid>;
+
+} // namespace adaptive
+} // namespace OPENVDB_VERSION_NAME
+} // namespace openvdb
+
+#endif // OPENVDB_ADAPTIVE_ADAPTIVE_GRID_HAS_BEEN_INCLUDED

openvdb/openvdb/openvdb.cc

@@ -80,7 +80,7 @@ initialize()
 
     // Register common grid types.
     GridBase::clearRegistry();
-    GridTypes::foreach<RegisterGrid>();
+    AllGridTypes::foreach<RegisterGrid>();
 
     // Register types associated with point index grids.
     Metadata::registerType(typeNameAsString<PointIndex32>(), Int32Metadata::createMetadata);

openvdb/openvdb/openvdb.h

@@ -13,6 +13,7 @@
 #include "Grid.h"
 #include "tree/Tree.h"
 #include "points/PointDataGrid.h"
+#include "adaptive/AdaptiveGrid.h"
 #include "io/File.h"
 
 
@@ -98,8 +99,8 @@ using NumericGridTypes  = RealGridTypes::Append<IntegerGridTypes>;
 /// The Vec3 Grid types which OpenVDB will register by default.
 using Vec3GridTypes     = TypeList<Vec3IGrid, Vec3SGrid, Vec3DGrid>;
 
-/// The Grid types which OpenVDB will register by default.
-using GridTypes =
+/// The sparse Grid types.
+using SparseGridTypes =
     NumericGridTypes::
         Append<Vec3GridTypes>::
         Append<tools::PointIndexGrid>::
@@ -110,6 +111,15 @@ using GridTypes =
         Append<BoolGrid, MaskGrid>;
 /// @}
 
+// for backwards-compatibility
+using GridTypes = SparseGridTypes;
+
+/// The Grid types which OpenVDB will register by default.
+using AllGridTypes =
+    SparseGridTypes::
+        Append<adaptive::AdaptiveGridTypes>;
+/// @}
+
 
 namespace internal {
 template <typename T> using ToTreeType = typename T::TreeType;

openvdb/openvdb/unittest/CMakeLists.txt

@@ -76,6 +76,7 @@ if(OPENVDB_TESTS)
 else()
   list(APPEND UNITTEST_SOURCE_FILES
     TestActivate.cc
+    TestAdaptive.cc
     TestAttributeArray.cc
     TestAttributeArrayString.cc
     TestAttributeGroup.cc

openvdb/openvdb/unittest/TestAdaptive.cc

@@ -0,0 +1,25 @@
+// Copyright Contributors to the OpenVDB Project
+// SPDX-License-Identifier: MPL-2.0
+
+#include <openvdb/openvdb.h>
+#include <openvdb/adaptive/AdaptiveGrid.h>
+
+#include <gtest/gtest.h>
+
+class TestAdaptive: public ::testing::Test
+{
+public:
+    void SetUp() override { openvdb::initialize(); }
+    void TearDown() override { openvdb::initialize(); }
+};
+
+
+////////////////////////////////////////
+
+
+TEST_F(TestAdaptive, test)
+{
+    openvdb::adaptive::AdaptiveGrid<float> adaptiveGrid(5.0f);
+
+    EXPECT_EQ(adaptiveGrid.background(), 5.0f);
+}