Add ReadDiagnostics to Codecs

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

Author: danrbailey

openvdb/openvdb/codecs/BoolCodec.h

@@ -110,7 +110,7 @@ struct OPENVDB_API BoolCodec : public TopologyCodec<GridT>
 
     static inline std::string name() { return GridT::gridType(); }
 
-    void readBuffers(std::istream& is, io::CodecData& data, const io::ReadOptions& options) final
+    void readBuffers(std::istream& is, io::CodecData& data, const io::ReadOptions& options, io::ReadDiagnostics&) final
     {
         GridT& grid = static_cast<GridT&>(*data.grid);
 

openvdb/openvdb/codecs/TopologyCodec.h

@@ -107,17 +107,22 @@ struct ReadTopologyOp
     using LeafT = typename TreeT::LeafNodeType;
     using StorageValueT = typename StorageTreeT::ValueType;
 
-    ReadTopologyOp(std::istream& _is, bool _saveFloatAsHalf)
+    ReadTopologyOp(std::istream& _is, bool _saveFloatAsHalf, io::ReadDiagnostics& _diagnostics,
+            const std::string& _gridName)
         : is(_is)
-        , saveFloatAsHalf(_saveFloatAsHalf) { }
+        , saveFloatAsHalf(_saveFloatAsHalf)
+        , diagnostics(_diagnostics)
+        , gridName(_gridName) { }
 
     void operator()(RootT& root)
     {
         using ChildT = typename RootT::ChildNodeType;
 
         int32_t bufferCount;
         is.read(reinterpret_cast<char*>(&bufferCount), sizeof(int32_t));
-        if (bufferCount != 1) OPENVDB_LOG_WARN("multi-buffer trees are no longer supported");
+        if (bufferCount != 1) {
+            diagnostics.addWarning(gridName, "multi-buffer trees are no longer supported");
+        }
 
         // Delete the existing tree.
         root.clear();
@@ -216,6 +221,8 @@ struct ReadTopologyOp
     std::istream& is;
     bool saveFloatAsHalf;
     ValueT background;
+    io::ReadDiagnostics& diagnostics;
+    std::string gridName;
 }; // struct ReadTopologyOp
 
 template <typename TreeT>
@@ -264,14 +271,14 @@ void setTilesToBackground(TreeT& tree)
 
 // Free-standing function for read case (supports type conversion via StorageGridT)
 template<typename GridT, typename StorageGridT = GridT>
-void topologyCodecReadTopology(GridBase& gridBase, std::istream& is, const io::ReadOptions& options)
+void topologyCodecReadTopology(GridBase& gridBase, std::istream& is, const io::ReadOptions& options, io::ReadDiagnostics& diagnostics)
 {
     io::checkFormatVersion(is);
 
     GridT& grid = static_cast<GridT&>(gridBase);
     grid.tree().clearAllAccessors();
 
-    internal::ReadTopologyOp<typename GridT::TreeType, typename StorageGridT::TreeType> readTopologyOp(is, grid.saveFloatAsHalf());
+    internal::ReadTopologyOp<typename GridT::TreeType, typename StorageGridT::TreeType> readTopologyOp(is, grid.saveFloatAsHalf(), diagnostics, grid.getName());
     readTopologyOp(grid.tree().root());
 
     if (options.readMode == io::ReadMode::TopologyOnly) {
@@ -307,9 +314,10 @@ struct OPENVDB_API TopologyCodec : public io::Codec
         return data;
     }
 
-    void readTopology(std::istream& is, io::CodecData& data, const io::ReadOptions& options) final
+    void readTopology(std::istream& is, io::CodecData& data, const io::ReadOptions& options,
+        io::ReadDiagnostics& diagnostics) final
     {
-        internal::topologyCodecReadTopology<GridT, StorageGridT>(*data.grid, is, options);
+        internal::topologyCodecReadTopology<GridT, StorageGridT>(*data.grid, is, options, diagnostics);
     }
 
     void writeTopology(std::ostream& os, const GridBase& gridBase, const io::WriteOptions&) final

openvdb/openvdb/io/Archive.cc

@@ -384,6 +384,35 @@ Archive::copy() const
 }
 
 
+void
+Archive::enableReadDiagnostics()
+{
+    mReadDiagnostics.enable();
+}
+
+
+void
+Archive::disableReadDiagnostics()
+{
+    mReadDiagnostics.disable();
+    mReadDiagnostics.clear();
+}
+
+
+const ReadDiagnostics&
+Archive::readDiagnostics() const
+{
+    return mReadDiagnostics;
+}
+
+
+void
+Archive::clearReadDiagnostics()
+{
+    mReadDiagnostics.clear();
+}
+
+
 ////////////////////////////////////////
 
 
@@ -898,7 +927,7 @@ Archive::connectInstance(const GridDescriptor& gd, const NamedGridMap& grids) co
 
 
 GridBase::Ptr
-Archive::readGrid(const GridDescriptor& gd, std::istream& is, const io::ReadOptions& readOptions)
+Archive::readGrid(const GridDescriptor& gd, std::istream& is, const io::ReadOptions& readOptions, ReadDiagnostics& diagnostics)
 {
     // Read the compression settings for this grid and tag the stream with them
     // so that downstream functions can reference them.
@@ -964,13 +993,13 @@ Archive::readGrid(const GridDescriptor& gd, std::istream& is, const io::ReadOpti
     if (readOptions.readMode != io::ReadMode::TopologyOnly && !gd.isInstance()) {
         // read topology
         if (codec) {
-            codec->readTopology(is, *codecData, readOptions);
+            codec->readTopology(is, *codecData, readOptions, diagnostics);
         } else {
             grid->readTopology(is);
         }
         // read buffers
         if (codec) {
-            codec->readBuffers(is, *codecData, readOptions);
+            codec->readBuffers(is, *codecData, readOptions, diagnostics);
         } else {
             const auto& worldBBox = readOptions.clipBBox;
             const bool clip = worldBBox.isSorted();
@@ -987,6 +1016,14 @@ Archive::readGrid(const GridDescriptor& gd, std::istream& is, const io::ReadOpti
 }
 
 
+GridBase::Ptr
+Archive::readGrid(const GridDescriptor& gd, std::istream& is, const io::ReadOptions& readOptions)
+{
+    ReadDiagnostics nullDiagnostics;
+    return readGrid(gd, is, readOptions, nullDiagnostics);
+}
+
+
 ////////////////////////////////////////
 
 

openvdb/openvdb/io/Archive.h

@@ -98,6 +98,18 @@ class OPENVDB_API Archive
     /// @brief Return @c false (delayed loading has been removed).
     static bool isDelayedLoadingEnabled() { return false; }
 
+    /// @brief Enable collection of read diagnostics (warnings, etc.) during I/O operations.
+    void enableReadDiagnostics();
+
+    /// @brief Disable collection of read diagnostics.
+    void disableReadDiagnostics();
+
+    /// @brief Return a const reference to the diagnostics collector.
+    const ReadDiagnostics& readDiagnostics() const;
+
+    /// @brief Clear the diagnostics list while keeping collection active.
+    void clearReadDiagnostics();
+
 protected:
     /// @brief Return @c true if the input stream contains grid offsets
     /// that allow for random access or partial reading.
@@ -136,6 +148,8 @@ class OPENVDB_API Archive
 
     /// @brief Read in and create the grid represented by the given grid descriptor using the
     /// given input stream, using the provided options if given.
+    static GridBase::Ptr readGrid(const GridDescriptor&, std::istream&,
+        const io::ReadOptions& readOptions, ReadDiagnostics& diagnostics);
     static GridBase::Ptr readGrid(const GridDescriptor&, std::istream&,
         const io::ReadOptions& readOptions = io::ReadOptions{});
 
@@ -173,6 +187,9 @@ class OPENVDB_API Archive
         const io::WriteOptions& writeOptions = io::WriteOptions{}) const;
     //@}
 
+    /// Diagnostics collector for read operations (always valid; enabled/disabled via flag)
+    mutable ReadDiagnostics mReadDiagnostics;
+
 private:
     friend class ::TestFile;
 

openvdb/openvdb/io/Codec.h

@@ -8,6 +8,8 @@
 #include <unordered_map>
 #include <memory>
 #include <iostream>
+#include <vector>
+#include <mutex>
 
 #include <openvdb/Types.h>
 
@@ -71,6 +73,49 @@ struct OPENVDB_API WriteOptions
 {
 }; // struct WriteOptions
 
+enum class DiagnosticSeverity { Warning };
+
+struct ReadDiagnostic {
+    DiagnosticSeverity severity;
+    std::string context;
+    std::string message;
+};
+
+struct OPENVDB_API ReadDiagnostics {
+    ReadDiagnostics() = default;
+    ReadDiagnostics(const ReadDiagnostics& other) {
+        std::lock_guard<std::mutex> lock(other.mMutex);
+        mEnabled = other.mEnabled;
+        mDiagnostics = other.mDiagnostics;
+    }
+    ReadDiagnostics& operator=(const ReadDiagnostics& other) {
+        if (this != &other) {
+            std::scoped_lock lock(mMutex, other.mMutex);
+            mEnabled = other.mEnabled;
+            mDiagnostics = other.mDiagnostics;
+        }
+        return *this;
+    }
+    void addWarning(const std::string& context, const std::string& message) {
+        if (!mEnabled) return;
+        std::lock_guard<std::mutex> lock(mMutex);
+        mDiagnostics.push_back({DiagnosticSeverity::Warning, context, message});
+    }
+    void clear() {
+        std::lock_guard<std::mutex> lock(mMutex);
+        mDiagnostics.clear();
+    }
+    void enable() { mEnabled = true; }
+    void disable() { mEnabled = false; }
+    bool enabled() const { return mEnabled; }
+    const std::vector<ReadDiagnostic>& diagnostics() const { return mDiagnostics; }
+    bool empty() const { return mDiagnostics.empty(); }
+private:
+    bool mEnabled = false;
+    std::vector<ReadDiagnostic> mDiagnostics;
+    mutable std::mutex mMutex;
+}; // struct ReadDiagnostics
+
 /// Per-codec mutable data created by Codec::createData()
 /// Contains the grid and any codec-specific state
 struct OPENVDB_API CodecData
@@ -93,10 +138,10 @@ struct OPENVDB_API Codec
     virtual CodecData::Ptr createData() = 0;
 
     /// Read the grid topology
-    virtual void readTopology(std::istream&, CodecData&, const ReadOptions&) { }
+    virtual void readTopology(std::istream&, CodecData&, const ReadOptions&, ReadDiagnostics&) { }
 
     /// Read all data buffers for this grid
-    virtual void readBuffers(std::istream&, CodecData&, const ReadOptions&) { }
+    virtual void readBuffers(std::istream&, CodecData&, const ReadOptions&, ReadDiagnostics&) { }
 
     /// Write the grid topology
     virtual void writeTopology(std::ostream&, const GridBase&, const WriteOptions&) { }

openvdb/openvdb/io/File.cc

@@ -319,7 +319,7 @@ File::getGrids(const io::ReadOptions& readOptions) const
             const GridDescriptor& gd = i->second;
             // Seek to the grid in the file.
             gd.seekToGrid(inputStream());
-            GridBase::Ptr grid = Archive::readGrid(gd, inputStream(), readOptions);
+            GridBase::Ptr grid = Archive::readGrid(gd, inputStream(), readOptions, mReadDiagnostics);
             ret->push_back(grid);
             namedGrids[gd.uniqueName()] = grid;
         }
@@ -477,7 +477,7 @@ File::readGrid(const Name& name, const io::ReadOptions& readOptions)
     OPENVDB_ASSERT(inputHasGridOffsets());
     // Seek to the grid in the file.
     gd.seekToGrid(inputStream());
-    grid = Archive::readGrid(gd, inputStream(), readOptions);
+    grid = Archive::readGrid(gd, inputStream(), readOptions, mReadDiagnostics);
 
     if (gd.isInstance()) {
         /// @todo Refactor to share code with Archive::connectInstance()?
@@ -493,7 +493,7 @@ File::readGrid(const Name& name, const io::ReadOptions& readOptions)
         GridBase::Ptr parent;
         OPENVDB_ASSERT(inputHasGridOffsets());
         parentIt->second.seekToGrid(inputStream());
-        parent = Archive::readGrid(parentIt->second, inputStream(), readOptions);
+        parent = Archive::readGrid(parentIt->second, inputStream(), readOptions, mReadDiagnostics);
         if (parent) grid->setTree(parent->baseTreePtr());
     }
     return grid;
@@ -592,6 +592,7 @@ File::endName() const
     return File::NameIterator(mGridDescriptors.end());
 }
 
+
 } // namespace io
 } // namespace OPENVDB_VERSION_NAME
 } // namespace openvdb

openvdb/openvdb/unittest/TestCodec.cc

@@ -77,6 +77,71 @@ TEST_F(TestCodec, testCodecRegistry)
 }
 
 
+TEST_F(TestCodec, testReadDiagnostics)
+{
+    using namespace openvdb;
+    using namespace openvdb::io;
+
+    // ReadDiagnostics struct: disabled by default, addWarning is a no-op until enabled
+    {
+        ReadDiagnostics diags;
+        EXPECT_FALSE(diags.enabled());
+        diags.addWarning("grid_a", "something went wrong");
+        EXPECT_TRUE(diags.diagnostics().empty());
+
+        diags.enable();
+        diags.addWarning("grid_a", "something went wrong");
+        ASSERT_EQ(diags.diagnostics().size(), size_t(1));
+        EXPECT_EQ(diags.diagnostics()[0].severity, DiagnosticSeverity::Warning);
+
+        diags.clear();
+        EXPECT_TRUE(diags.diagnostics().empty());
+    }
+
+    CodecRegistry::clear();
+    openvdb::io::internal::initialize();
+
+    // Archive API and getGrids() with diagnostics
+
+    BoolGrid::Ptr srcGrid = BoolGrid::create(false);
+    srcGrid->setName("bool_grid");
+    srcGrid->fill(CoordBBox(Coord(-5), Coord(5)), true, true);
+
+    const std::string codecPath = "testReadDiagnostics.vdb";
+    {
+        io::File f(codecPath);
+        f.write(GridPtrVec{srcGrid});
+    }
+
+    // Disabled by default; enabling produces no warnings on a clean read
+    {
+        io::File f(codecPath);
+        f.open();
+        EXPECT_FALSE(f.readDiagnostics().enabled());
+        f.enableReadDiagnostics();
+        EXPECT_TRUE(f.readDiagnostics().enabled());
+        f.readGrid("bool_grid");
+        EXPECT_TRUE(f.readDiagnostics().diagnostics().empty());
+        f.close();
+    }
+
+    // clearReadDiagnostics() resets entries but keeps diagnostics enabled
+    {
+        io::File f(codecPath);
+        f.open();
+        f.enableReadDiagnostics();
+        GridPtrVecPtr grids = f.getGrids();
+        ASSERT_TRUE(grids && !grids->empty());
+        f.clearReadDiagnostics();
+        EXPECT_TRUE(f.readDiagnostics().enabled());
+        EXPECT_TRUE(f.readDiagnostics().diagnostics().empty());
+        f.close();
+    }
+
+    std::remove(codecPath.c_str());
+}
+
+
 template <typename GridT>
 void testIOImpl(
     const std::string& gridName,