Merge pull request #2140 from Idclip/m2v_interrupt

Improved the interruptibility of tools::meshToVolume

Author: Idclip

openvdb/openvdb/tools/MeshToVolume.h

@@ -2169,20 +2169,23 @@ class VoxelizePolygons
         unsigned char primId = data.getNewPrimId();
         data.primIdAcc.setValueOnly(ijk, primId);
 
+        // iteration number to check for an interrupt
+        constexpr Int32 freq = 2<<12;
+
         while (!coordList.empty()) {
             if (interrupter && interrupter->wasInterrupted()) {
                 thread::cancelGroupExecution();
                 break;
             }
-            for (Int32 pass = 0; pass < 1048576 && !coordList.empty(); ++pass) {
+            for (Int32 pass = 0; pass < freq && !coordList.empty(); ++pass) {
                 ijk = coordList.back();
                 coordList.pop_back();
 
                 for (Int32 i = 0; i < 26; ++i) {
                     nijk = ijk + util::COORD_OFFSETS[i];
                     if (primId != data.primIdAcc.getValue(nijk)) {
                         data.primIdAcc.setValueOnly(nijk, primId);
-                        if(updateDistance(nijk, prim, data)) coordList.push_back(nijk);
+                        if (updateDistance(nijk, prim, data)) coordList.push_back(nijk);
                     }
                 }
             }

openvdb/openvdb/unittest/TestMeshToVolume.cc

@@ -5,9 +5,12 @@
 #include <openvdb/Exceptions.h>
 #include <openvdb/tools/MeshToVolume.h>
 #include <openvdb/util/Util.h>
+#include <openvdb/util/NullInterrupter.h>
 
 #include <gtest/gtest.h>
 #include <vector>
+#include <thread>
+#include <chrono>
 
 class TestMeshToVolume: public ::testing::Test
 {
@@ -129,3 +132,87 @@ TEST_F(TestMeshToVolume, testCreateLevelSetBox)
     EXPECT_TRUE(grid->tree().getValue(ijk) > 0.0f);
 }
 
+
+TEST_F(TestMeshToVolume, testInterrupt)
+{
+    using namespace openvdb;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    struct Interrupter final : util::NullInterrupter
+    {
+        bool wasInterrupted(int percent = -1) override { (void)percent; return interrupted.load(); }
+        void interrupt() { interrupted.store(true); }
+        std::atomic<bool> interrupted = false;
+    };
+
+    struct MeshAdapter
+    {
+        MeshAdapter(const std::vector<Vec3d>& vertices, const std::vector<Vec3d>& triangles)
+            : vertices(vertices), triangles(triangles), positionsRequested(false) {}
+        size_t polygonCount() const { return triangles.size(); }
+        size_t pointCount() const { return vertices.size(); }
+        size_t vertexCount(size_t) const { return 3; }
+        void getIndexSpacePoint(size_t n, size_t v, Vec3d &pos) const
+        {
+            // Mark that positions have been accessed
+            positionsRequested = true;
+            pos = vertices[size_t(triangles[n][v])];
+        }
+        const std::vector<Vec3d>& vertices;
+        const std::vector<Vec3d>& triangles;
+        // Flag to check that meshToVolume has started accessing positions
+        mutable std::atomic<bool> positionsRequested;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    Interrupter interrupter;
+
+    // define geo for a box
+    const Vec3d size = {100000, 100000, 100000};
+    const double hx = size.x() / 2.0;
+    const double hy = size.y() / 2.0;
+    const double z  = size.z();
+
+    const std::vector<Vec3d> vertices = {
+        {-hx, -hy, 0.0}, {+hx, -hy, 0.0}, {+hx, -hy, z}, {-hx, -hy, z},
+        {-hx, +hy, 0.0}, {+hx, +hy, 0.0}, {+hx, +hy, z}, {-hx, +hy, z},
+    };
+
+    const std::vector<Vec3d> triangles = {
+        {0, 1, 2}, {0, 2, 3}, {1, 0, 4}, {1, 4, 5}, {1, 5, 6}, {1, 6, 2},
+        {3, 2, 6}, {3, 6, 7}, {4, 0, 3}, {4, 3, 7}, {4, 6, 5}, {4, 7, 6},
+    };
+
+    const MeshAdapter adapter(vertices, triangles);
+    const auto transform = math::Transform::createLinearTransform(1.0);
+    FloatGrid::Ptr grid;
+
+    std::chrono::steady_clock::time_point start, end;
+
+    // Start volume generation
+    std::thread m2vThread([&]() {
+        grid = tools::meshToVolume<FloatGrid>(interrupter, adapter, *transform);
+        // assign end here to avoid waiting for thread sync (we only care about
+        // meshToVolume returning).
+        end = std::chrono::steady_clock::now();
+    });
+
+    // Wait for method to start before interrupting
+    while (!adapter.positionsRequested) {} // loop until positions have been accessed
+    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // sleep for a bit longer
+
+    start = std::chrono::steady_clock::now();
+    // interrupt
+    interrupter.interrupt();
+    m2vThread.join();
+
+    // Should have returned _something_
+    EXPECT_TRUE(grid);
+
+    // Expect to interrupt in under a second
+    const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+    EXPECT_LT(duration.count(), 1000);
+}
+

pendingchanges/m2vinterrupt.txt

@@ -0,0 +1,3 @@
+OpenVDB:
+  Improvements:
+  - Improved the interruptibility of tools::meshToVolume [Reported by @RustyLooks]