Merge pull request #1498 from apradhana/vdbtool_ci

Add CI for vdb_tool

Author: kmuseth

ci/build.sh

@@ -189,6 +189,8 @@ cmake \
     -DOPENVDB_USE_DEPRECATED_ABI_9=ON \
     -DOPENVDB_BUILD_VDB_PRINT=ON \
     -DOPENVDB_BUILD_VDB_LOD=ON \
+    -DOPENVDB_BUILD_VDB_TOOL=ON \
+    -DOPENVDB_TOOL_USE_NANO=OFF \
     -DOPENVDB_BUILD_PYTHON_UNITTESTS=ON \
     -DMSVC_MP_THREAD_COUNT=${PARMS[-j]} \
     "${CMAKE_EXTRA[@]}" \

cmake/FindOpenVDB.cmake

@@ -394,6 +394,9 @@ foreach(COMPONENT ${OpenVDB_FIND_COMPONENTS})
   elseif(${COMPONENT} STREQUAL "openvdb_je")
     # alias to the result of openvdb which should be handled first
     set(OpenVDB_${COMPONENT}_LIBRARY ${OpenVDB_openvdb_LIBRARY})
+  elseif(${COMPONENT} STREQUAL "nanovdb")
+    # alias to the result of openvdb which should be handled first
+    set(OpenVDB_${COMPONENT}_LIBRARY ${OpenVDB_openvdb_LIBRARY})
   else()
     find_library(OpenVDB_${COMPONENT}_LIBRARY ${LIB_NAME}
       ${_FIND_OPENVDB_ADDITIONAL_OPTIONS}

nanovdb/nanovdb/NanoVDB.h

@@ -1139,9 +1139,9 @@ class Coord
 
     /// @brief Return the octant of this Coord
     //__hostdev__ size_t octant() const { return (uint32_t(mVec[0])>>31) | ((uint32_t(mVec[1])>>31)<<1) | ((uint32_t(mVec[2])>>31)<<2); }
-    __hostdev__ uint8_t octant() const { return (uint8_t(bool(mVec[0] & (1u << 31)))) |
+    __hostdev__ uint8_t octant() const { return uint8_t((uint8_t(bool(mVec[0] & (1u << 31)))) |
                                                 (uint8_t(bool(mVec[1] & (1u << 31))) << 1) |
-                                                (uint8_t(bool(mVec[2] & (1u << 31))) << 2); }
+                                                (uint8_t(bool(mVec[2] & (1u << 31))) << 2)); }
 
     /// @brief Return a single precision floating-point vector of this coordinate
     __hostdev__ inline Vec3<float> asVec3s() const;

nanovdb/nanovdb/util/GridBuilder.h

@@ -42,6 +42,7 @@ class AbsDiff
     /// @note The default value of -1 means it's un-initialized!
     AbsDiff(float tolerance = -1.0f) : mTolerance(tolerance) {}
     AbsDiff(const AbsDiff&) = default;
+    ~AbsDiff() = default;
     void  setTolerance(float tolerance) { mTolerance = tolerance; }
     float getTolerance() const { return mTolerance; }
     /// @brief Return true if the approximate value is within the accepted
@@ -68,6 +69,7 @@ class RelDiff
     /// @note The default value of -1 means it's un-initialized!
     RelDiff(float tolerance = -1.0f) : mTolerance(tolerance) {}
     RelDiff(const RelDiff&) = default;
+    ~RelDiff() = default;
     void  setTolerance(float tolerance) { mTolerance = tolerance; }
     float getTolerance() const { return mTolerance; }
     /// @brief Return true if the approximate value is within the accepted

openvdb/openvdb/tools/LevelSetFilter.h

@@ -160,7 +160,7 @@ class LevelSetFilter : public LevelSetTracker<GridT, InterruptT>
 
         Filter(LevelSetFilter* parent, const MaskType* mask) : mParent(parent), mMask(mask) {}
         Filter(const Filter&) = default;
-        virtual ~Filter() {}
+        ~Filter() {}
 
         void box(int width);
         void median(int width);

openvdb_cmd/vdb_tool/CMakeLists.txt

@@ -28,41 +28,53 @@ add_library(vdb_tool_common INTERFACE)
 # Optional components
 option(BUILD_TEST "Build unit tests" OFF)
 
-option(VDB_TOOL_USE_NANO "Compile with NanoVDB support" ON)
-option(VDB_TOOL_NANO_USE_ZIP "Compile NanoVDB with zip compression support. Requires VDB_TOOL_USE_NANO=ON to have effect" ON)
-option(VDB_TOOL_NANO_USE_BLOSC "Compile NanoVDB with Blosc compression support. Requires VDB_TOOL_USE_NANO=ON to have effect" ON)
-option(VDB_TOOL_USE_PNG "Compile with PNG support" OFF)
-option(VDB_TOOL_USE_EXR "Compile with EXR support" OFF)
-option(VDB_TOOL_USE_JPG "Compile with JPG support" OFF)
-option(VDB_TOOL_USE_ABC "Compile with Alembic support" OFF)
-option(VDB_TOOL_USE_ALL "Compile with all optional components" OFF)
-if(VDB_TOOL_USE_ALL)
-  set(VDB_TOOL_USE_NANO ON)
-  set(VDB_TOOL_USE_PNG ON)
-  set(VDB_TOOL_USE_EXR ON)
-  set(VDB_TOOL_USE_JPG ON)
-  set(VDB_TOOL_USE_ABC ON)
+option(OPENVDB_TOOL_USE_NANO "Compile with NanoVDB support" OFF)
+option(OPENVDB_TOOL_NANO_USE_ZIP "Compile NanoVDB with zip compression support. Requires OPENVDB_TOOL_USE_NANO=ON to have effect" ON)
+option(OPENVDB_TOOL_NANO_USE_BLOSC "Compile NanoVDB with Blosc compression support. Requires OPENVDB_TOOL_USE_NANO=ON to have effect" ON)
+option(OPENVDB_TOOL_USE_PNG "Compile with PNG support" OFF)
+option(OPENVDB_TOOL_USE_EXR "Compile with EXR support" OFF)
+option(OPENVDB_TOOL_USE_JPG "Compile with JPG support" OFF)
+option(OPENVDB_TOOL_USE_ABC "Compile with Alembic support" OFF)
+option(OPENVDB_TOOL_USE_ALL "Compile with all optional components" OFF)
+if(OPENVDB_TOOL_USE_ALL)
+  set(OPENVDB_TOOL_USE_NANO ON)
+  set(OPENVDB_TOOL_USE_PNG ON)
+  set(OPENVDB_TOOL_USE_EXR ON)
+  set(OPENVDB_TOOL_USE_JPG ON)
+  set(OPENVDB_TOOL_USE_ABC ON)
 endif()
 
-if(VDB_TOOL_USE_NANO)
-  add_compile_definitions("VDB_TOOL_USE_NANO")
-  if(VDB_TOOL_NANO_USE_ZIP)
-    add_compile_definitions("NANOVDB_USE_ZIP")
+if(OPENVDB_TOOL_USE_NANO)
+  target_compile_definitions(vdb_tool_common INTERFACE "VDB_TOOL_USE_NANO")
+  if(OPENVDB_TOOL_NANO_USE_ZIP)
+    target_compile_definitions(vdb_tool_common INTERFACE "NANOVDB_USE_ZIP")
     find_package(ZLIB REQUIRED)
     target_link_libraries(vdb_tool_common INTERFACE ZLIB::ZLIB)
   endif()
-  if(VDB_TOOL_NANO_USE_BLOSC)
-    add_compile_definitions("NANOVDB_USE_BLOSC")
+  if(OPENVDB_TOOL_NANO_USE_BLOSC)
+    target_compile_definitions(vdb_tool_common INTERFACE "NANOVDB_USE_BLOSC")
     find_package(Blosc REQUIRED)
     target_link_libraries(vdb_tool_common INTERFACE blosc)
   endif()
-  if(OPENVDB_BUILD_NANOVDB)
-    target_include_directories(vdb_tool_common INTERFACE ../../nanovdb/)
+  #target_include_directories(vdb_tool_common INTERFACE ${PROJECT_SOURCE_DIR}/../nanovdb/)
+  if(NOT OPENVDB_BUILD_NANOVDB)
+    find_package(OpenVDB COMPONENTS nanovdb)
+    if(NOT OpenVDB_nanovdb_FOUND OR NOT OpenVDB_FOUND)
+        message(FATAL_ERROR
+        " Couldn't find NanoVDB\n"
+        " Either set OPENVDB_CMAKE_PATH to <OpenVDB install path>/lib/cmake/OpenVDB"
+        " or please pass -DUSE_NANOVDB=ON as a cmake argument.")
+    endif()
+    set(NANOVDB_LIB OpenVDB::nanovdb)
+    target_include_directories(vdb_tool_common INTERFACE ${OPENVDB_nanovdb_INCLUDE_DIR})
+  else()
+    set(NANOVDB_LIB nanovdb)
   endif()
+  target_link_libraries(vdb_tool_common INTERFACE ${NANOVDB_LIB})
 endif()
 
-if(VDB_TOOL_USE_PNG)
-  add_compile_definitions("VDB_TOOL_USE_PNG")
+if(OPENVDB_TOOL_USE_PNG)
+  target_compile_definitions(vdb_tool_common INTERFACE "VDB_TOOL_USE_PNG")
   if(WIN32)
     find_package(libpng CONFIG REQUIRED)
   else()
@@ -71,26 +83,26 @@ if(VDB_TOOL_USE_PNG)
   target_link_libraries(vdb_tool_common INTERFACE png)
 endif()
 
-if(VDB_TOOL_USE_JPG)
-  add_compile_definitions("VDB_TOOL_USE_JPG")
+if(OPENVDB_TOOL_USE_JPG)
+  target_compile_definitions(vdb_tool_common INTERFACE "VDB_TOOL_USE_JPG")
   find_package(JPEG REQUIRED)
   target_link_libraries(vdb_tool_common INTERFACE ${JPEG_LIBRARIES})
   target_include_directories(vdb_tool_common INTERFACE ${JPEG_INCLUDE_DIR})
 endif()
 
-if(VDB_TOOL_USE_EXR)
-  add_compile_definitions("VDB_TOOL_USE_EXR")
+if(OPENVDB_TOOL_USE_EXR)
+  target_compile_definitions(vdb_tool_common INTERFACE "VDB_TOOL_USE_EXR")
   find_package(OpenEXR REQUIRED)
   target_link_libraries(vdb_tool_common INTERFACE OpenEXR::IlmImf)
 endif()
 
-if(VDB_TOOL_USE_ABC)
-  add_compile_definitions("VDB_TOOL_USE_ABC")
+if(OPENVDB_TOOL_USE_ABC)
+  target_compile_definitions(vdb_tool_common INTERFACE "VDB_TOOL_USE_ABC")
   find_package(Alembic CONFIG REQUIRED)
   target_link_libraries(vdb_tool_common INTERFACE Alembic::Alembic)
 endif()
 
-if(WIN32 AND (VDB_TOOL_USE_ALL OR (VDB_TOOL_USE_ABC AND VDB_TOOL_USE_EXR)))
+if(WIN32 AND (OPENVDB_TOOL_USE_ALL OR (OPENVDB_TOOL_USE_ABC AND OPENVDB_TOOL_USE_EXR)))
   message(WARNING
     " The OpenEXR and Alembic VCPKG packages are using conflicting Imath versions.\n"
     " Disable one, if you encounter unresolved external symbols")
@@ -100,41 +112,41 @@ endif()
 
 # GCC flags
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  add_compile_options(-Wno-invalid-offsetof -pthread -lpthread)
-  add_compile_options("$<$<CONFIG:DEBUG>:-O1>")
+  target_compile_options(vdb_tool_common INTERFACE -Wno-invalid-offsetof -pthread -lpthread)
+  target_compile_options(vdb_tool_common INTERFACE "$<$<CONFIG:DEBUG>:-O1>")
 endif()
 
 
 # MSVC flags
 # Increase the number of sections that an object file can contain
-add_compile_options("$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/bigobj>")
+target_compile_options(vdb_tool_common INTERFACE "$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/bigobj>")
 # Excludes APIs such as Cryptography, DDE, RPC, Shell, and Windows Sockets
-add_compile_definitions("$<$<CXX_COMPILER_ID:MSVC>:WIN32_LEAN_AND_MEAN>")
+target_compile_definitions(vdb_tool_common INTERFACE "$<$<CXX_COMPILER_ID:MSVC>:WIN32_LEAN_AND_MEAN>")
 # Disable non-secure CRT library function warnings
 # https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/
 #     compiler-warning-level-3-c4996?view=vs-2019#unsafe-crt-library-functions
-add_compile_definitions("$<$<CXX_COMPILER_ID:MSVC>:_CRT_SECURE_NO_WARNINGS>")
+target_compile_definitions(vdb_tool_common INTERFACE "$<$<CXX_COMPILER_ID:MSVC>:_CRT_SECURE_NO_WARNINGS>")
 # Disable POSIX function name warnings
 # https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/
 #     compiler-warning-level-3-c4996?view=vs-2019#posix-function-names
-add_compile_definitions("$<$<CXX_COMPILER_ID:MSVC>:_CRT_NONSTDC_NO_WARNINGS>")
+target_compile_definitions(vdb_tool_common INTERFACE "$<$<CXX_COMPILER_ID:MSVC>:_CRT_NONSTDC_NO_WARNINGS>")
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-  add_compile_options("$<$<CONFIG:RELEASE>:/Oi>")
+  target_compile_options(vdb_tool_common INTERFACE "$<$<CONFIG:RELEASE>:/Oi>")
 
   message(STATUS "Suppressing some noisy MSVC CXX warnings.")
 endif()
 # Conversion from int64_t to long
-add_compile_options("$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/wd4244>")
+target_compile_options(vdb_tool_common INTERFACE "$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/wd4244>")
 # It's not possible to use STL types in DLL interfaces in a portable and
 # reliable way so disable this warning
-add_compile_options("$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/wd4251>")
+target_compile_options(vdb_tool_common INTERFACE "$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/wd4251>")
 # Conversion from size_t to uLong
-add_compile_options("$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/wd4267>")
+target_compile_options(vdb_tool_common INTERFACE "$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/wd4267>")
 # Non dll-interface class used as base for dll-interface class
-#add_compile_options("$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/wd4275>")
+#target_compile_options(vdb_tool_common INTERFACE "$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/wd4275>")
 # Truncation from 'int' to 'bool'
-#add_compile_options("$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/wd4305>")
+#target_compile_options(vdb_tool_common INTERFACE "$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/wd4305>")
 
 if(OPENVDB_BUILD_CORE)
     target_link_libraries(vdb_tool_common INTERFACE ${OPENVDB_BINARIES_DEPENDENT_LIBS})

openvdb_cmd/vdb_tool/include/Geometry.h

@@ -337,7 +337,7 @@ void Geometry::writeSTL(std::ostream &os) const
     if (!mQuad.empty()) throw std::invalid_argument("STL file only supports triangles");
     uint8_t buffer[80] = {0};// fixed-sized buffer initiated with zeros!
     os.write((const char*)buffer, 80);// write header as zeros
-    const uint32_t nTri = mTri.size();
+    const uint32_t nTri = static_cast<uint32_t>(mTri.size());
     os.write((const char*)&nTri, 4);
     float *p = 3 + reinterpret_cast<float*>(buffer);// the normal will remain zero
     for (const Vec3I &tri : mTri) {
@@ -466,7 +466,7 @@ void Geometry::readPLY(std::istream &is)
     };
     auto tokens = tokenize_line();
     auto test = [&tokens](int i, std::vector<std::string> str) {
-        if (i >= tokens.size()) return false;
+        if (i >= static_cast<int>(tokens.size())) return false;
         for (auto &s : str) {
             if (tokens[i] == s) return true;
         }
@@ -520,20 +520,20 @@ void Geometry::readPLY(std::istream &is)
                             } else {// e.g. nx, ny, nz, intensity, s, t etc
                                 if (n!=0 && n!=3) error("vdb_tool::readPLY: vertex float property interlaced with coordinates");
                                 vtx_skip[m].count += 1;
-                                vtx_skip[m].bytes += sizeof(float);
+                                vtx_skip[m].bytes += static_cast<int>(sizeof(float));
                             }
                         } else if ( test(1, {"int16", "uint16"}) ) {// e.g. material_index etc
                             if (n!=0 && n!=3) error("vdb_tool::readPLY: vertex int16 property interlaced with coordinates is not supported");
                             vtx_skip[m].count += 1;
-                            vtx_skip[m].bytes += sizeof(int16_t);
+                            vtx_skip[m].bytes += static_cast<int>(sizeof(int16_t));
                         } else if ( test(1, {"int", "int32"}) ) {// e.g. material_index etc
                             if (n!=0 && n!=3) error("vdb_tool::readPLY: vertex int32 property interlaced with coordinates is not supported");
                             vtx_skip[m].count += 1;
-                            vtx_skip[m].bytes += sizeof(int32_t);
+                            vtx_skip[m].bytes += static_cast<int>(sizeof(int32_t));
                         } else if ( test(1, {"uchar", "int8"}) ) {// eg red, green, blue, alpha
                             if (n!=0 && n!=3) error("vdb_tool::readPLY: vertex int8 property interlaced with coordinates is not supported");
                             vtx_skip[m].count += 1;
-                            vtx_skip[m].bytes += sizeof(unsigned char);
+                            vtx_skip[m].bytes += static_cast<int>(sizeof(unsigned char));
                         } else {
                             error("vdb_tool::readPLY: invalid vertex property");
                         }
@@ -620,7 +620,7 @@ void Geometry::readPLY(std::istream &is)
     } else {// ascii
         for (auto &v : mVtx) {
             tokens = tokenize_line();
-            if (tokens.size() != vtx_skip[0].count + 3 + vtx_skip[1].count) {
+            if (static_cast<int>(tokens.size()) != vtx_skip[0].count + 3 + vtx_skip[1].count) {
                 error("vdb_tool::readPLY: error reading ascii vertex coordinates");
             }
             for (int i = 0; i<3; ++i) {
@@ -675,7 +675,7 @@ void Geometry::readPLY(std::istream &is)
                 throw std::invalid_argument("Geometry::readPLY: ascii " + std::to_string(n)+"-gons are not supported");
             }
             for (int i = 0; i<n; ++i) {
-                vtx[i] = std::stoll(tokens[i + 1 + ply_skip[0].count]);
+                vtx[i] = static_cast<uint32_t>(std::stoll(tokens[i + 1 + ply_skip[0].count]));
             }
             if (n==3) {
                 mTri.emplace_back(vtx);
@@ -706,14 +706,12 @@ void Geometry::readVDB(const std::string &fileName)
     io::File file(fileName);
     file.open();// enables delayed loading by default
     GridPtrVecPtr meta = file.readAllGridMetadata();
-    size_t count = 0;
     for (auto m : *meta) {
         if (m->isType<points::PointDataGrid>()) {
             auto grid = gridPtrCast<points::PointDataGrid>(file.readGrid(m->getName()));
             assert(grid);
             size_t n = mVtx.size();
             const auto m = points::pointCount(grid->tree());
-            count += m;
             mVtx.resize(n + m);
             for (auto leafIter = grid->tree().cbeginLeaf(); leafIter; ++leafIter) {
                 const points::AttributeArray& array = leafIter->constAttributeArray("P");
@@ -753,7 +751,6 @@ void Geometry::readPTS(const std::string &fileName)
     std::ifstream infile(fileName, std::ios::in);
     if (!infile.is_open()) throw std::runtime_error("Error opening particle file \""+fileName+"\"");
     std::string line;
-    size_t count = 0;
     std::istringstream iss;
     while(std::getline(infile, line)) {
         const size_t n = mVtx.size(), m = std::stoi(line);
@@ -801,7 +798,7 @@ void Geometry::readSTL(const std::string &fileName)
                         throw std::invalid_argument("Geometry::readSTL ASCII: error parsing line: \""+line+"\"");
                     }
                 }// endloop
-                const int vtx = mVtx.size() - 1;
+                const int vtx = static_cast<int>(mVtx.size()) - 1;
                 switch (nGone){
                 case 3:
                     mTri.emplace_back(vtx - 2, vtx - 1, vtx);
@@ -822,7 +819,7 @@ void Geometry::readSTL(const std::string &fileName)
         infile.seekg (0, infile.end);
         if (infile.tellg() != 80 + 4 + 50*numTri) throw std::invalid_argument("Geometry::readSTL binary: Unexpected file size");
         infile.seekg(80 + 4, infile.beg);
-        uint32_t vtxBegin = mVtx.size(), triBegin = mTri.size();
+        uint32_t vtxBegin = static_cast<uint32_t>(mVtx.size()), triBegin = static_cast<uint32_t>(mTri.size());
         mVtx.resize(vtxBegin + 3*numTri);
         mTri.resize(triBegin +   numTri);
         Vec3f *pV = mVtx.data() + vtxBegin;
@@ -841,9 +838,9 @@ void Geometry::readSTL(const std::string &fileName)
     mBBox = BBoxT();//invalidate BBox
 }// Geometry::readSTL
 
+#ifdef VDB_TOOL_USE_NANO
 void Geometry::readNVDB(const std::string &fileName)
 {
-#ifdef VDB_TOOL_USE_NANO
     auto handle = nanovdb::io::readGrid(fileName);
     auto grid = handle.grid<uint32_t>();
     if (grid == nullptr || !grid->isPointData()) return;
@@ -855,10 +852,13 @@ void Geometry::readNVDB(const std::string &fileName)
     mVtx.resize(n + count);
     for (size_t i=n; i<mVtx.size(); ++i) mVtx[i] = *p++;// loop over points
     mBBox = BBoxT();//invalidate BBox
+}// Geometry::readNVDB
 #else
+void Geometry::readNVDB(const std::string&)
+{
     throw std::runtime_error("NanoVDB support was disabled during compilation!");
-#endif
 }// Geometry::readNVDB
+#endif
 
 void Geometry::print(size_t n, std::ostream& os) const
 {
@@ -1115,9 +1115,9 @@ void Geometry::transform(const math::Transform &xform)
 {
     using RangeT = tbb::blocked_range<size_t>;
     tbb::parallel_for(RangeT(0, mVtx.size()), [&](RangeT r){
-        for (int i=r.begin(); i<r.end(); ++i){
+        for (size_t i=r.begin(); i<r.end(); ++i){
             Vec3d xyz(mVtx[i]);
-            mVtx[i] = xform.baseMap()->applyMap(xyz);
+            mVtx[i] = static_cast<Vec3s>(xform.baseMap()->applyMap(xyz));
         }
     });
     mBBox = BBoxT();//invalidate BBox