Add Scalar and ValueMask codecs

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

Author: danrbailey

openvdb/openvdb/CMakeLists.txt

@@ -367,7 +367,9 @@ set(OPENVDB_LIBRARY_INCLUDE_FILES
 
 set(OPENVDB_LIBRARY_CODECS_INCLUDE_FILES
   codecs/BoolCodec.h
+  codecs/ScalarCodec.h
   codecs/TopologyCodec.h
+  codecs/ValueMaskCodec.h
 )
 
 set(OPENVDB_LIBRARY_IO_INCLUDE_FILES

openvdb/openvdb/codecs/ScalarCodec.h

@@ -0,0 +1,185 @@
+// Copyright Contributors to the OpenVDB Project
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef OPENVDB_IO_CODECS_SCALARCODEC_HAS_BEEN_INCLUDED
+#define OPENVDB_IO_CODECS_SCALARCODEC_HAS_BEEN_INCLUDED
+
+#include <openvdb/openvdb.h>
+#include <openvdb/tree/Tree.h>
+#include <openvdb/tools/Clip.h>
+#include <openvdb/tools/NodeVisitor.h>
+#include <openvdb/io/Codec.h>
+
+#include "ScalarLeafCodec.h"
+#include "TopologyCodec.h"
+
+namespace openvdb {
+OPENVDB_USE_VERSION_NAMESPACE
+namespace OPENVDB_VERSION_NAME {
+namespace codecs {
+namespace internal {
+
+template <typename TreeT>
+struct WriteBuffersOp
+{
+    using LeafT = typename TreeT::LeafNodeType;
+
+    WriteBuffersOp(std::ostream& _os, bool _saveFloatAsHalf)
+        : os(_os)
+        , saveFloatAsHalf(_saveFloatAsHalf) { }
+
+    template <typename NodeT>
+    void operator()(const NodeT&, size_t) { }
+
+    void operator()(const LeafT& leaf, size_t)
+    {
+        writeScalarLeafBuffers(leaf, os, saveFloatAsHalf);
+    }
+
+    std::ostream& os;
+    const bool saveFloatAsHalf;
+}; // struct WriteBuffersOp
+
+
+template <typename TreeT, typename StorageTreeT>
+struct ReadBuffersOp
+{
+    using RootT = typename TreeT::RootNodeType;
+    using LeafT = typename TreeT::LeafNodeType;
+    using ValueT = typename TreeT::ValueType;
+    using StorageLeafT = typename StorageTreeT::LeafNodeType;
+
+    ReadBuffersOp(std::istream& _is, bool _saveFloatAsHalf, const ValueT& _background,
+        const CoordBBox* _clipBBox)
+        : is(_is)
+        , saveFloatAsHalf(_saveFloatAsHalf)
+        , background(_background)
+        , clipBBox(_clipBBox) { }
+
+    void operator()(RootT& root, size_t)
+    {
+        if (clipBBox) {
+            root.clip(*clipBBox);
+        }
+    }
+
+    template <typename NodeT>
+    void operator()(NodeT& node, size_t)
+    {
+        if (clipBBox) {
+            node.clip(*clipBBox, background);
+        }
+    }
+
+    void operator()(LeafT& leaf, size_t)
+    {
+        readScalarLeafBuffers<LeafT, StorageLeafT>(leaf, is, saveFloatAsHalf, background, /*skip=*/false, clipBBox);
+    }
+
+    std::istream& is;
+    const bool saveFloatAsHalf;
+    const ValueT& background;
+    const CoordBBox* clipBBox = nullptr;
+}; // struct ReadBuffersOp
+
+
+// Free-standing function for both standard and conversion codec cases
+// Uses StorageGridT = GridT by default, but allows different storage type for conversions
+template<typename GridT, typename StorageGridT = GridT>
+void scalarCodecReadBuffers(GridT& grid, std::istream& is, const io::ReadOptions& options)
+{
+    if (grid.hasMultiPassIO()) {
+        OPENVDB_THROW(IoError, "Multi-pass IO is not supported in ScalarCodec");
+    }
+
+    using TreeT = typename GridT::TreeType;
+    using StorageTreeT = typename StorageGridT::TreeType;
+
+    io::checkFormatVersion(is);
+
+    bool saveFloatAsHalf = grid.saveFloatAsHalf();
+
+    auto& tree = grid.tree();
+    tree.clearAllAccessors();
+
+    std::unique_ptr<CoordBBox> clipIndexBBox;
+    if (options.clipBBox.isSorted()) {
+        clipIndexBBox = std::make_unique<CoordBBox>(grid.constTransform().worldToIndexNodeCentered(options.clipBBox));
+    }
+
+    // Works for both standard (TreeT == StorageTreeT) and conversion cases
+    ReadBuffersOp<TreeT, StorageTreeT> readBuffersOp(is, saveFloatAsHalf, tree.background(),
+        clipIndexBBox.get());
+    tools::visitNodesDepthFirst(grid.tree(), readBuffersOp, /*idx=*/0, /*topDown=*/false);
+}
+
+// Free-standing function for write case (no StorageGridT needed)
+template<typename GridT>
+void scalarCodecWriteBuffers(const GridT& grid, std::ostream& os)
+{
+    using TreeType = typename GridT::TreeType;
+
+    if (grid.hasMultiPassIO()) {
+        OPENVDB_THROW(IoError, "Multi-pass IO is not supported in ScalarCodec");
+    }
+
+    WriteBuffersOp<TreeType> writeBuffersOp(os, grid.saveFloatAsHalf());
+    tools::visitNodesDepthFirst(grid.tree(), writeBuffersOp);
+}
+
+} // namespace internal
+
+template <typename GridT, typename StorageGridT = GridT, io::CodecMode Mode = io::CodecMode::ReadWrite>
+struct ScalarCodec : public TopologyCodec<GridT, StorageGridT, Mode>
+{
+    static_assert(GridT::TreeType::RootNodeType::template SameConfiguration<
+        typename StorageGridT::TreeType::RootNodeType>::value,
+        "GridT and StorageGridT must have the same configuration");
+
+    using Ptr = std::unique_ptr<ScalarCodec<GridT, StorageGridT, Mode>>;
+
+    struct ScalarCodecData : public io::CodecData
+    {
+        std::vector<int> leafCoords;
+    };
+
+    ~ScalarCodec() noexcept = default;
+
+    io::CodecData::Ptr createData() final
+    {
+        auto data = std::make_unique<ScalarCodecData>();
+        data->grid = GridT::create();
+        return data;
+    }
+
+    static inline std::string name()
+    {
+        if constexpr (std::is_same_v<GridT, StorageGridT>) {
+            return GridT::gridType();
+        } else {
+            std::string buildType = typeNameAsString<typename GridT::BuildType>();
+            return StorageGridT::gridType() + "_to_" + buildType;
+        }
+    }
+
+    void readBuffers(std::istream& is, io::CodecData& data, const io::ReadOptions& options, io::ReadDiagnostics&) final
+    {
+        GridT& grid = static_cast<GridT&>(*data.grid);
+        internal::scalarCodecReadBuffers<GridT, StorageGridT>(grid, is, options);
+    }
+
+    void writeBuffers(std::ostream& os, const GridBase& gridBase, const io::WriteOptions&) final
+    {
+        if constexpr (Mode == io::CodecMode::ReadOnly) return;
+
+        const GridT& grid = static_cast<const GridT&>(gridBase);
+        internal::scalarCodecWriteBuffers(grid, os);
+    }
+}; // struct ScalarCodec
+
+
+} // namespace codecs
+} // namespace OPENVDB_VERSION_NAME
+} // namespace openvdb
+
+#endif // OPENVDB_IO_CODECS_SCALARCODEC_HAS_BEEN_INCLUDED

openvdb/openvdb/codecs/ScalarLeafCodec.h

@@ -0,0 +1,104 @@
+// Copyright Contributors to the OpenVDB Project
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef OPENVDB_IO_CODECS_SCALARLEAFCODEC_HAS_BEEN_INCLUDED
+#define OPENVDB_IO_CODECS_SCALARLEAFCODEC_HAS_BEEN_INCLUDED
+
+#include <openvdb/io/Compression.h>
+
+namespace openvdb {
+OPENVDB_USE_VERSION_NAMESPACE
+namespace OPENVDB_VERSION_NAME {
+namespace codecs {
+namespace internal {
+
+template <typename LeafT>
+void writeScalarLeafBuffers(const LeafT& leaf, std::ostream& os, bool saveFloatAsHalf)
+{
+    using NodeMaskT = typename LeafT::NodeMaskType;
+
+    // Write out the value mask.
+    leaf.getValueMask().save(os);
+
+    leaf.buffer().data(); // load values
+
+    io::writeCompressedValues(os, leaf.buffer().data(), LeafT::SIZE,
+        leaf.getValueMask(), /*childMask=*/NodeMaskT(), saveFloatAsHalf);
+}
+
+
+template <typename LeafT, typename StorageLeafT = LeafT>
+void readScalarLeafBuffers(LeafT& leaf, std::istream& is, bool saveFloatAsHalf,
+    const typename LeafT::ValueType& background, bool skip = false,
+    const math::CoordBBox* clipBBox = nullptr)
+{
+    using ValueT = typename LeafT::ValueType;
+    using NodeMaskT = typename LeafT::NodeMaskType;
+    using StorageBufferT = typename StorageLeafT::Buffer;
+    using StorageValueT = typename StorageLeafT::ValueType;
+
+    constexpr Index SIZE = LeafT::SIZE;
+
+    SharedPtr<io::StreamMetadata> meta = io::getStreamMetadataPtr(is);
+    const bool seekable = meta && meta->seekable();
+
+    auto& valueMask = leaf.getValueMask();
+
+    // Load or seek the value mask
+    if (seekable)   valueMask.seek(is);
+    else            valueMask.load(is);
+
+    if (skip) {
+        if (seekable) {
+            io::readCompressedValues<StorageValueT, NodeMaskT>(is, nullptr, SIZE, valueMask, saveFloatAsHalf);
+        } else {
+            StorageBufferT storageTemp;
+            io::readCompressedValues(is, storageTemp.data(), SIZE, valueMask, saveFloatAsHalf);
+        }
+        // Clear the value mask so that the skipped leaf has no active
+        // voxels. Without this, the leaf retains its on-disk active
+        // topology even though no data was read into its buffer.
+        valueMask.setOff();
+        return;
+    }
+
+    if constexpr (std::is_same_v<typename LeafT::BuildType, ValueMask>) {
+        // ValueMask leaf: value == active state, already captured in the value mask above.
+        // Seek/consume past the storage buffer without populating any separate leaf buffer.
+        if (seekable) {
+            io::readCompressedValues<StorageValueT, NodeMaskT>(is, nullptr, SIZE, valueMask, saveFloatAsHalf);
+        } else {
+            StorageBufferT storageTemp;
+            io::readCompressedValues(is, storageTemp.data(), SIZE, valueMask, saveFloatAsHalf);
+        }
+    } else if constexpr (std::is_same_v<ValueT, bool>) {
+        // Bool leaf: must read storage values regardless of seekability, then convert.
+        StorageBufferT storageTemp;
+        io::readCompressedValues(is, storageTemp.data(), SIZE, valueMask, saveFloatAsHalf);
+        for (Index i = 0; i < SIZE; ++i) {
+            leaf.buffer().setValue(i, static_cast<bool>(storageTemp.getValue(i)));
+        }
+    } else {
+        leaf.buffer().allocate();
+        if constexpr (std::is_same_v<StorageValueT, ValueT>) {
+            io::readCompressedValues(is, leaf.buffer().data(), SIZE, valueMask, saveFloatAsHalf);
+        } else {
+            StorageBufferT storageTemp;
+            io::readCompressedValues(is, storageTemp.data(), SIZE, valueMask, saveFloatAsHalf);
+            for (Index i = 0; i < SIZE; ++i) {
+                leaf.buffer().setValue(i, static_cast<ValueT>(storageTemp.getValue(i)));
+            }
+        }
+    }
+
+    if (clipBBox) {
+        leaf.clip(*clipBBox, background);
+    }
+}
+
+} // namespace internal
+} // namespace codecs
+} // namespace OPENVDB_VERSION_NAME
+} // namespace openvdb
+
+#endif // OPENVDB_IO_CODECS_SCALARLEAFCODEC_HAS_BEEN_INCLUDED

openvdb/openvdb/codecs/TopologyCodec.h

@@ -300,10 +300,10 @@ void topologyCodecWriteTopology(const GridBase& gridBase, std::ostream& os)
 
 } // namespace internal
 
-template <typename GridT, typename StorageGridT = GridT>
+template <typename GridT, typename StorageGridT = GridT, io::CodecMode Mode = io::CodecMode::ReadWrite>
 struct TopologyCodec : public io::Codec
 {
-    using Ptr = std::unique_ptr<TopologyCodec<GridT, StorageGridT>>;
+    using Ptr = std::unique_ptr<TopologyCodec<GridT, StorageGridT, Mode>>;
 
     ~TopologyCodec() noexcept = default;
 
@@ -322,6 +322,9 @@ struct TopologyCodec : public io::Codec
 
     void writeTopology(std::ostream& os, const GridBase& gridBase, const io::WriteOptions&) final
     {
+        // disable implementation when read only
+        if constexpr (Mode == io::CodecMode::ReadOnly) return;
+
         internal::topologyCodecWriteTopology<GridT>(gridBase, os);
     }
 }; // struct TopologyCodec