Add support for implicit conversion - float to half and scalar to bool/mask

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

Author: danrbailey

openvdb/openvdb/io/Archive.cc

@@ -885,10 +885,24 @@ Archive::readGridCount(std::istream& is)
 
 
 io::Codec*
-Archive::findCodec(const std::string& gridType, const io::ReadOptions&)
+Archive::findCodec(const std::string& gridType, const io::ReadOptions& options)
 {
     // Determine the I/O codec to use to read this grid
-    return io::CodecRegistry::get(gridType);
+    auto codec = io::CodecRegistry::get(gridType);
+
+    // if readMode is Half, then search for a codec that converts
+    // from the storage grid type to the grid type
+    if (options.readMode == ReadMode::Half) {
+        codec = io::CodecRegistry::get(gridType + "_to_half");
+    }
+    if (options.readMode == ReadMode::Bool) {
+        codec = io::CodecRegistry::get(gridType + "_to_bool");
+    }
+    if (options.readMode == ReadMode::Mask) {
+        codec = io::CodecRegistry::get(gridType + "_to_mask");
+    }
+
+    return codec;
 }
 
 

openvdb/openvdb/io/Codec.cc

@@ -42,13 +42,28 @@ namespace internal {
 template <typename GridT>
 struct RegisterCodec { inline void operator()() { CodecRegistry::registerCodec<codecs::ScalarCodec<GridT>>(); } };
 
+template <typename GridT>
+struct RegisterConvertCodec {
+    inline void operator()()
+    {
+        CodecRegistry::registerCodec<codecs::ScalarCodec<MaskGrid, GridT, CodecMode::ReadOnly>>();
+        CodecRegistry::registerCodec<codecs::ScalarCodec<BoolGrid, GridT, CodecMode::ReadOnly>>();
+    }
+}; // struct RegisterConvertCodec
+
 void initialize()
 {
     NumericGridTypes::foreach<RegisterCodec>();
     Vec3GridTypes::foreach<RegisterCodec>();
 
     CodecRegistry::registerCodec<codecs::BoolCodec<BoolGrid>>();
     CodecRegistry::registerCodec<codecs::ValueMaskCodec<MaskGrid>>();
+
+    // register the plugin that converts from scalar to mask/bool
+    NumericGridTypes::foreach<RegisterConvertCodec>();
+
+    // register the plugin that converts from float to half
+    CodecRegistry::registerCodec<codecs::ScalarCodec<HalfGrid, FloatGrid, CodecMode::ReadOnly>>();
 }
 
 void uninitialize()

openvdb/openvdb/io/Codec.h

@@ -38,6 +38,9 @@ enum class CodecMode {
 
 enum class ReadMode {
     Original,      // Read data as-is (default)
+    Half,          // Read data as half precision
+    Bool,          // Read data as boolean
+    Mask,          // Read data as mask
     TopologyOnly   // Read topology only, no buffer data
 };
 

openvdb/openvdb/unittest/TestCodec.cc

@@ -4,6 +4,7 @@
 #include <openvdb/io/Codec.h>
 #include <openvdb/io/File.h>
 #include <openvdb/openvdb.h>
+#include <openvdb/codecs/ScalarCodec.h>
 #include <openvdb/Exceptions.h>
 #include <openvdb/tools/Clip.h>
 #include <gtest/gtest.h>
@@ -257,3 +258,148 @@ TEST_F(TestCodec, testVec3SCodecIO) { testCodecIOImpl<openvdb::Vec3SGrid>("vec3s
 TEST_F(TestCodec, testVec3DCodecIO) { testCodecIOImpl<openvdb::Vec3DGrid>("vec3d_grid", openvdb::Vec3d(0.0), openvdb::Vec3d(1.0, 2.0, 3.0)); }
 TEST_F(TestCodec, testBoolCodecIO) { testCodecIOImpl<openvdb::BoolGrid>("bool_grid", false, true); }
 TEST_F(TestCodec, testMaskCodecIO) { testCodecIOImpl<openvdb::MaskGrid>("mask_grid", false, true); }
+
+TEST_F(TestCodec, testFloatToHalfCodecConversion)
+{
+    using namespace openvdb;
+    using namespace openvdb::io;
+
+    openvdb::initialize();
+    CodecRegistry::clear();
+
+    // Verify the conversion codec name
+    const std::string expectedName = FloatGrid::gridType() + "_to_half";
+    EXPECT_EQ((codecs::ScalarCodec<HalfGrid, FloatGrid, CodecMode::ReadOnly>::name()),
+              expectedName);
+
+    // Verify the codec is registered after initialize()
+    io::internal::initialize();
+    EXPECT_TRUE(CodecRegistry::isRegistered(expectedName));
+
+    // Write a FloatGrid with a known fill value (1.5f is exactly representable in half)
+    const std::string floatPath = "test_float_to_half.vdb";
+    const std::string gridName = "float_grid";
+    FloatGrid::Ptr srcGrid = FloatGrid::create(0.0f);
+    srcGrid->setName(gridName);
+    srcGrid->fill(CoordBBox(Coord(-5), Coord(5)), 1.5f, true);
+
+    {
+        io::File f(floatPath);
+        f.write(GridPtrVec{srcGrid});
+    }
+
+    // Read back with ReadMode::Half — triggers the float-to-half conversion codec
+    ReadOptions halfOpts;
+    halfOpts.readMode = ReadMode::Half;
+
+    GridBase::Ptr base;
+    {
+        io::File f(floatPath);
+        f.open();
+        base = f.readGrid(gridName, halfOpts);
+        f.close();
+    }
+    ASSERT_TRUE(base);
+
+    // The returned grid must be a HalfGrid
+    EXPECT_TRUE(base->isType<HalfGrid>());
+    HalfGrid::Ptr halfGrid = gridPtrCast<HalfGrid>(base);
+    ASSERT_TRUE(halfGrid);
+
+    // Topology must match the source FloatGrid
+    EXPECT_TRUE(srcGrid->tree().hasSameTopology(halfGrid->tree()));
+
+    // All active voxel values must equal Half(1.5f)
+    for (HalfGrid::ValueOnCIter it = halfGrid->cbeginValueOn(); it; ++it) {
+        EXPECT_EQ(*it, Half(1.5f));
+    }
+
+    // Background value must equal Half(0.0f)
+    EXPECT_EQ(halfGrid->background(), Half(0.0f));
+
+    // Cleanup
+    std::remove(floatPath.c_str());
+}
+
+template <typename SrcGridT, typename DstGridT, openvdb::io::ReadMode mode>
+void testConvertCodecImpl()
+{
+    using namespace openvdb;
+    using namespace openvdb::io;
+
+    openvdb::io::CodecRegistry::clear();
+    openvdb::io::internal::initialize();
+
+    // Verify the conversion codec name
+    const std::string expectedName =
+        SrcGridT::gridType() + "_to_" + typeNameAsString<typename DstGridT::BuildType>();
+    EXPECT_EQ((codecs::ScalarCodec<DstGridT, SrcGridT, CodecMode::ReadOnly>::name()),
+              expectedName);
+
+    // Verify the codec is registered after initialize()
+    EXPECT_TRUE(CodecRegistry::isRegistered(expectedName));
+
+    // Write a SrcGridT with a non-zero fill value
+    const std::string testPath = "test_" + expectedName + ".vdb";
+    const std::string gridName = SrcGridT::gridType();
+    typename SrcGridT::Ptr srcGrid =
+        SrcGridT::create(typename SrcGridT::ValueType(0));
+    srcGrid->setName(gridName);
+    srcGrid->fill(CoordBBox(Coord(-5), Coord(5)),
+                  typename SrcGridT::ValueType(1), true);
+
+    {
+        io::File f(testPath);
+        f.write(GridPtrVec{srcGrid});
+    }
+
+    // Read back with the specified ReadMode — triggers the conversion codec
+    ReadOptions opts;
+    opts.readMode = mode;
+
+    GridBase::Ptr base;
+    {
+        io::File f(testPath);
+        f.open();
+        base = f.readGrid(gridName, opts);
+        f.close();
+    }
+    ASSERT_TRUE(base);
+
+    // The returned grid must be a DstGridT
+    EXPECT_TRUE(base->isType<DstGridT>());
+    typename DstGridT::Ptr dstGrid = gridPtrCast<DstGridT>(base);
+    ASSERT_TRUE(dstGrid);
+
+    // Topology must match the source grid
+    EXPECT_TRUE(srcGrid->tree().hasSameTopology(dstGrid->tree()));
+
+    // All active voxel values must be true
+    for (typename DstGridT::ValueOnCIter it = dstGrid->cbeginValueOn(); it; ++it) {
+        EXPECT_EQ(*it, typename DstGridT::ValueType(true));
+    }
+
+    // Background value must be false
+    EXPECT_EQ(dstGrid->background(), typename DstGridT::ValueType(false));
+
+    // Cleanup
+    std::remove(testPath.c_str());
+}
+
+TEST_F(TestCodec, testNumericToBoolCodecConversion)
+{
+    testConvertCodecImpl<openvdb::FloatGrid,  openvdb::BoolGrid, openvdb::io::ReadMode::Bool>();
+    testConvertCodecImpl<openvdb::DoubleGrid, openvdb::BoolGrid, openvdb::io::ReadMode::Bool>();
+    testConvertCodecImpl<openvdb::Int32Grid,  openvdb::BoolGrid, openvdb::io::ReadMode::Bool>();
+    testConvertCodecImpl<openvdb::Int64Grid,  openvdb::BoolGrid, openvdb::io::ReadMode::Bool>();
+    testConvertCodecImpl<openvdb::HalfGrid,   openvdb::BoolGrid, openvdb::io::ReadMode::Bool>();
+}
+
+TEST_F(TestCodec, testNumericToMaskCodecConversion)
+{
+    testConvertCodecImpl<openvdb::FloatGrid,  openvdb::MaskGrid, openvdb::io::ReadMode::Mask>();
+    testConvertCodecImpl<openvdb::DoubleGrid, openvdb::MaskGrid, openvdb::io::ReadMode::Mask>();
+    testConvertCodecImpl<openvdb::Int32Grid,  openvdb::MaskGrid, openvdb::io::ReadMode::Mask>();
+    testConvertCodecImpl<openvdb::Int64Grid,  openvdb::MaskGrid, openvdb::io::ReadMode::Mask>();
+    testConvertCodecImpl<openvdb::HalfGrid,   openvdb::MaskGrid, openvdb::io::ReadMode::Mask>();
+}