Remove support for multi-pass I/O except PointDataLeafNode

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

Author: danrbailey

openvdb/openvdb/Grid.h

@@ -1181,14 +1181,34 @@ struct TreeAdapter<tree::ValueAccessor<_TreeType> >
 ////////////////////////////////////////
 
 
+namespace points {
+
+template<typename T, Index Log2Dim> class PointDataLeafNode;
+
+/// @brief Type trait that evaluates to true only for @c PointDataLeafNode instantiations.
+template<typename T>
+struct IsPointDataLeafNode : std::false_type {};
+
+template<typename T, Index Log2Dim>
+struct IsPointDataLeafNode<PointDataLeafNode<T, Log2Dim>> : std::true_type {};
+
+} // namespace points
+
+
 /// @brief Metafunction that specifies whether a given leaf node, tree, or grid type
-/// requires multiple passes to read and write voxel data
-/// @details Multi-pass I/O allows one to optimize the data layout of leaf nodes
-/// for certain access patterns during delayed loading.
-/// @sa io::MultiPass
+/// requires multiple passes to read and write voxel data.
+/// @details Multi-pass I/O allows leaf nodes to optimize their serialization layout
+/// for delayed-load access patterns. Only @c PointDataLeafNode supports multi-pass I/O.
+/// Defining a custom leaf node that inherits @c io::MultiPass is no longer permitted.
+/// @sa points::IsPointDataLeafNode
 template<typename LeafNodeType>
 struct HasMultiPassIO {
-    static const bool value = std::is_base_of<io::MultiPass, LeafNodeType>::value;
+    static_assert(
+        !std::is_base_of<io::MultiPass, LeafNodeType>::value
+        || points::IsPointDataLeafNode<LeafNodeType>::value,
+        "Only PointDataLeafNode may inherit from io::MultiPass; "
+        "use points::IsPointDataLeafNode to test for multi-pass I/O support.");
+    static const bool value = points::IsPointDataLeafNode<LeafNodeType>::value;
 };
 
 // Partial specialization for Tree types

openvdb/openvdb/io/io.h

@@ -116,8 +116,8 @@ std::ostream& operator<<(std::ostream&, const StreamMetadata::AuxDataMap&);
 ////////////////////////////////////////
 
 
-/// @brief Leaf nodes that require multi-pass I/O must inherit from this struct.
-/// @sa Grid::hasMultiPassIO()
+/// @brief Tag for multi-pass I/O. Only points::PointDataLeafNode may inherit from this.
+/// @sa Grid::hasMultiPassIO(), points::IsPointDataLeafNode
 struct MultiPass {};
 
 

openvdb/openvdb/unittest/TestFile.cc

@@ -1522,246 +1522,6 @@ TEST_F(TestFile, testReadClippedGrid)
 ////////////////////////////////////////
 
 
-namespace {
-
-template<typename T, openvdb::Index Log2Dim> struct MultiPassLeafNode; // forward declaration
-
-// Dummy value type
-using MultiPassValue = openvdb::PointIndex<openvdb::Index32, 1000>;
-
-// Tree configured to match the default OpenVDB configuration
-using MultiPassTree = openvdb::tree::Tree<
-    openvdb::tree::RootNode<
-    openvdb::tree::InternalNode<
-    openvdb::tree::InternalNode<
-    MultiPassLeafNode<MultiPassValue, 3>, 4>, 5>>>;
-
-using MultiPassGrid = openvdb::Grid<MultiPassTree>;
-
-
-template<typename T, openvdb::Index Log2Dim>
-struct MultiPassLeafNode: public openvdb::tree::LeafNode<T, Log2Dim>, openvdb::io::MultiPass
-{
-    // The following had to be copied from the LeafNode class
-    // to make the derived class compatible with the tree structure.
-
-    using LeafNodeType  = MultiPassLeafNode;
-    using Ptr           = openvdb::SharedPtr<MultiPassLeafNode>;
-    using BaseLeaf      = openvdb::tree::LeafNode<T, Log2Dim>;
-    using NodeMaskType  = openvdb::util::NodeMask<Log2Dim>;
-    using ValueType     = T;
-    using ValueOnCIter  = typename BaseLeaf::template ValueIter<typename NodeMaskType::OnIterator,
-        const MultiPassLeafNode, const ValueType, typename BaseLeaf::ValueOn>;
-    using ChildOnIter = typename BaseLeaf::template ChildIter<typename NodeMaskType::OnIterator,
-        MultiPassLeafNode, typename BaseLeaf::ChildOn>;
-    using ChildOnCIter = typename BaseLeaf::template ChildIter<
-        typename NodeMaskType::OnIterator, const MultiPassLeafNode, typename BaseLeaf::ChildOn>;
-
-    MultiPassLeafNode(const openvdb::Coord& coords, const T& value, bool active = false)
-        : BaseLeaf(coords, value, active) {}
-    MultiPassLeafNode(openvdb::PartialCreate, const openvdb::Coord& coords, const T& value,
-        bool active = false): BaseLeaf(openvdb::PartialCreate(), coords, value, active) {}
-    MultiPassLeafNode(const MultiPassLeafNode& rhs): BaseLeaf(rhs) {}
-
-    ValueOnCIter cbeginValueOn() const { return ValueOnCIter(this->getValueMask().beginOn(),this); }
-    ChildOnCIter cbeginChildOn() const { return ChildOnCIter(this->getValueMask().endOn(), this); }
-    ChildOnIter   beginChildOn()       { return ChildOnIter(this->getValueMask().endOn(), this); }
-
-    // Methods in use for reading and writing multiple buffers
-
-    void readBuffers(std::istream& is, const openvdb::CoordBBox&, bool fromHalf = false)
-    {
-        this->readBuffers(is, fromHalf);
-    }
-
-    void readBuffers(std::istream& is, bool /*fromHalf*/ = false)
-    {
-        const openvdb::io::StreamMetadata::Ptr meta = openvdb::io::getStreamMetadataPtr(is);
-        if (!meta) {
-            OPENVDB_THROW(openvdb::IoError,
-                "Cannot write out a MultiBufferLeaf without StreamMetadata.");
-        }
-
-        // clamp pass to 16-bit integer
-        const uint32_t pass(static_cast<uint16_t>(meta->pass()));
-
-        // Read in the stored pass number.
-        uint32_t readPass;
-        is.read(reinterpret_cast<char*>(&readPass), sizeof(uint32_t));
-        EXPECT_EQ(pass, readPass);
-        // Record the pass number.
-        mReadPasses.push_back(readPass);
-
-        if (pass == 0) {
-            // Read in the node's origin.
-            openvdb::Coord origin;
-            is.read(reinterpret_cast<char*>(&origin), sizeof(openvdb::Coord));
-            EXPECT_EQ(origin, this->origin());
-        }
-    }
-
-    void writeBuffers(std::ostream& os, bool /*toHalf*/ = false) const
-    {
-        const openvdb::io::StreamMetadata::Ptr meta = openvdb::io::getStreamMetadataPtr(os);
-        if (!meta) {
-            OPENVDB_THROW(openvdb::IoError,
-                "Cannot read in a MultiBufferLeaf without StreamMetadata.");
-        }
-
-        // clamp pass to 16-bit integer
-        const uint32_t pass(static_cast<uint16_t>(meta->pass()));
-
-        // Leaf traversal analysis deduces the number of passes to perform for this leaf
-        // then updates the leaf traversal value to ensure all passes will be written.
-        if (meta->countingPasses()) {
-            if (mNumPasses > pass) meta->setPass(mNumPasses);
-            return;
-        }
-
-        // Record the pass number.
-        EXPECT_TRUE(mWritePassesPtr);
-        const_cast<std::vector<int>&>(*mWritePassesPtr).push_back(pass);
-
-        // Write out the pass number.
-        os.write(reinterpret_cast<const char*>(&pass), sizeof(uint32_t));
-        if (pass == 0) {
-            // Write out the node's origin and the pass number.
-            const auto origin = this->origin();
-            os.write(reinterpret_cast<const char*>(&origin), sizeof(openvdb::Coord));
-        }
-    }
-
-
-    uint32_t mNumPasses = 0;
-    // Pointer to external vector in which to record passes as they are written
-    std::vector<int>* mWritePassesPtr = nullptr;
-    // Vector in which to record passes as they are read
-    // (this needs to be internal, because leaf nodes are constructed as a grid is read)
-    std::vector<int> mReadPasses;
-}; // struct MultiPassLeafNode
-
-} // anonymous namespace
-
-
-TEST_F(TestFile, testMultiPassIO)
-{
-    using namespace openvdb;
-
-    openvdb::initialize();
-    MultiPassGrid::registerGrid();
-
-    // Create a multi-buffer grid.
-    const MultiPassGrid::Ptr grid = openvdb::createGrid<MultiPassGrid>();
-    grid->setName("test");
-    grid->setTransform(math::Transform::createLinearTransform(1.0));
-    MultiPassGrid::TreeType& tree = grid->tree();
-    tree.setValue(Coord(0, 0, 0), 5);
-    tree.setValue(Coord(0, 10, 0), 5);
-    EXPECT_EQ(2, int(tree.leafCount()));
-
-    const GridPtrVec grids{grid};
-
-    // Vector in which to record pass numbers (to ensure blocked ordering)
-    std::vector<int> writePasses;
-    {
-        // Specify the required number of I/O passes for each leaf node.
-        MultiPassGrid::TreeType::LeafIter leafIter = tree.beginLeaf();
-        leafIter->mNumPasses = 3;
-        leafIter->mWritePassesPtr = &writePasses;
-        ++leafIter;
-        leafIter->mNumPasses = 2;
-        leafIter->mWritePassesPtr = &writePasses;
-    }
-
-    const char* filename = "testMultiPassIO.vdb";
-    SharedPtr<const char> scopedFile(filename, ::remove);
-    {
-        // Verify that passes are written to a file in the correct order.
-        io::File(filename).write(grids);
-        EXPECT_EQ(6, int(writePasses.size()));
-        EXPECT_EQ(0, writePasses[0]); // leaf 0
-        EXPECT_EQ(0, writePasses[1]); // leaf 1
-        EXPECT_EQ(1, writePasses[2]); // leaf 0
-        EXPECT_EQ(1, writePasses[3]); // leaf 1
-        EXPECT_EQ(2, writePasses[4]); // leaf 0
-        EXPECT_EQ(2, writePasses[5]); // leaf 1
-    }
-    {
-        // Verify that passes are read in the correct order.
-        io::File file(filename);
-        file.open();
-        const auto newGrid = GridBase::grid<MultiPassGrid>(file.readGrid("test"));
-
-        auto leafIter = newGrid->tree().beginLeaf();
-        EXPECT_EQ(3, int(leafIter->mReadPasses.size()));
-        EXPECT_EQ(0, leafIter->mReadPasses[0]);
-        EXPECT_EQ(1, leafIter->mReadPasses[1]);
-        EXPECT_EQ(2, leafIter->mReadPasses[2]);
-        ++leafIter;
-        EXPECT_EQ(3, int(leafIter->mReadPasses.size()));
-        EXPECT_EQ(0, leafIter->mReadPasses[0]);
-        EXPECT_EQ(1, leafIter->mReadPasses[1]);
-        EXPECT_EQ(2, leafIter->mReadPasses[2]);
-    }
-    {
-        // Verify that when using multi-pass and bbox clipping that each leaf node
-        // is still being read before being clipped
-        io::File file(filename);
-        file.open();
-        const auto newGrid = GridBase::grid<MultiPassGrid>(
-            file.readGrid("test", BBoxd(Vec3d(0), Vec3d(1))));
-        EXPECT_EQ(Index64(1), newGrid->tree().leafCount());
-
-        auto leafIter = newGrid->tree().beginLeaf();
-        EXPECT_EQ(3, int(leafIter->mReadPasses.size()));
-        EXPECT_EQ(0, leafIter->mReadPasses[0]);
-        EXPECT_EQ(1, leafIter->mReadPasses[1]);
-        EXPECT_EQ(2, leafIter->mReadPasses[2]);
-        ++leafIter;
-        EXPECT_TRUE(!leafIter); // second leaf node has now been clipped
-    }
-
-    // Clear the pass data.
-    writePasses.clear();
-
-    {
-        // Verify that passes are written to and read from a non-seekable stream
-        // in the correct order.
-        std::ostringstream ostr(std::ios_base::binary);
-        io::Stream(ostr).write(grids);
-
-        EXPECT_EQ(6, int(writePasses.size()));
-        EXPECT_EQ(0, writePasses[0]); // leaf 0
-        EXPECT_EQ(0, writePasses[1]); // leaf 1
-        EXPECT_EQ(1, writePasses[2]); // leaf 0
-        EXPECT_EQ(1, writePasses[3]); // leaf 1
-        EXPECT_EQ(2, writePasses[4]); // leaf 0
-        EXPECT_EQ(2, writePasses[5]); // leaf 1
-
-        std::istringstream is(ostr.str(), std::ios_base::binary);
-        io::Stream strm(is);
-        const auto streamedGrids = strm.getGrids();
-        EXPECT_EQ(1, int(streamedGrids->size()));
-
-        const auto newGrid = gridPtrCast<MultiPassGrid>(*streamedGrids->begin());
-        EXPECT_TRUE(bool(newGrid));
-        auto leafIter = newGrid->tree().beginLeaf();
-        EXPECT_EQ(3, int(leafIter->mReadPasses.size()));
-        EXPECT_EQ(0, leafIter->mReadPasses[0]);
-        EXPECT_EQ(1, leafIter->mReadPasses[1]);
-        EXPECT_EQ(2, leafIter->mReadPasses[2]);
-        ++leafIter;
-        EXPECT_EQ(3, int(leafIter->mReadPasses.size()));
-        EXPECT_EQ(0, leafIter->mReadPasses[0]);
-        EXPECT_EQ(1, leafIter->mReadPasses[1]);
-        EXPECT_EQ(2, leafIter->mReadPasses[2]);
-    }
-}
-
-
-////////////////////////////////////////
-
-
 TEST_F(TestFile, testHasGrid)
 {
     using namespace openvdb;