stop when blovk

algoim/organizer/organizer.hpp

@@ -419,7 +419,7 @@ void buildOcTreeV0(const Scene&             scene,
     }
     if (subNodes[1].blobTree.structure[4].inOut != NODE_IN_OUT_UNKNOWN
         && std::find(subNodes[1].polyIntersectIndices.begin(), subNodes[1].polyIntersectIndices.end(), 3)
-              != subNodes[1].polyIntersectIndices.end()) {
+               != subNodes[1].polyIntersectIndices.end()) {
         int aaa = 1;
         int bbb = 1;
     }
@@ -438,7 +438,7 @@ void basicTask(const std::shared_ptr<PrimitiveDesc>& p, int q = 20, real xmin =
     if (auto pt = std::dynamic_pointer_cast<SphereDesc>(p)) {
         tensor3 tensor(nullptr, 3);
         algoim_spark_alloc(real, tensor);
-        std::vector<AABB> aabbs;
+        std::vector<AABB>   aabbs;
         VisiblePrimitiveRep visiblePrimitiveRep{{tensor}, aabbs, AABB(), BlobTree()};
         makeSphere(*pt, visiblePrimitiveRep);
         detail::powerTransformation(range, xmin, tensor);
@@ -453,7 +453,7 @@ void basicTask(const std::shared_ptr<PrimitiveDesc>& p, int q = 20, real xmin =
         assert(faceCount > 1);
         std::vector<tensor3> planeTensors(faceCount, tensor3(nullptr, 2));
         algoim_spark_alloc(real, planeTensors);
-        std::vector<AABB> aabbs;
+        std::vector<AABB>   aabbs;
         VisiblePrimitiveRep visiblePrimitiveRep{planeTensors, aabbs, AABB(), BlobTree()};
         AABB                aabb;
         makeMesh(*pt, visiblePrimitiveRep);
@@ -483,7 +483,7 @@ void basicTask(const std::vector<std::shared_ptr<PrimitiveDesc>>& primitives, in
         if (auto pt = std::dynamic_pointer_cast<SphereDesc>(primitives[i])) {
             tensor3 tensor(nullptr, 3);
             phiStacks.emplace_back(algoim_spark_alloc_heap(real, tensor));
-            std::vector<AABB> aabbs;
+            std::vector<AABB>   aabbs;
             VisiblePrimitiveRep visiblePrimitiveRep{{tensor}, aabbs, AABB(), BlobTree()};
             makeSphere(*pt, visiblePrimitiveRep);
 
@@ -495,7 +495,7 @@ void basicTask(const std::vector<std::shared_ptr<PrimitiveDesc>>& primitives, in
             assert(faceCount > 1);
             std::vector<tensor3> planeTensors(faceCount, tensor3(nullptr, 3));
             algoimSparkAllocHeapVector(phiStacks, planeTensors);
-            std::vector<AABB> aabbs;
+            std::vector<AABB>   aabbs;
             VisiblePrimitiveRep visiblePrimitiveRep{planeTensors, aabbs, AABB(), BlobTree()};
             makeMesh(*pt, visiblePrimitiveRep);
 
@@ -549,7 +549,13 @@ BasicTaskRes basicTask(const Scene& scene, const OcTreeNode& node, int q = 10)
     }
     // ImplicitPolyQuadrature<3> ipquad(scene.minimalReps, node.polyIntersectIndices);
     ImplicitPolyQuadrature<3> ipquad(phis);
-
+#if STOP_WHEN_BLOCKED
+    if (stopCurrentQuadrature) {
+        stopCurrentQuadrature = false;
+        std::cout << "blocked" << std::endl;
+        return {0, 0};
+    }
+#endif
     ipquad.integrate(AutoMixed, q, [&](const uvector<real, 3>& x, real w) {
         auto realX = x * range + node.aabb.min; // 这里realX应该是最原始空间下的点？不过因为算体积，所以不影响
         if (keepQuadraturePoint(phis, node, x)) { volume += w * integrand(realX); }

algoim/quadrature_multipoly.hpp

@@ -36,6 +36,15 @@
 #include "tanhsinh.hpp"
 #include "bernstein.hpp"
 
+#define STOP_WHEN_BLOCKED true
+
+#if STOP_WHEN_BLOCKED
+#include <chrono>
+auto         timerStart            = std::chrono::high_resolution_clock::now();
+bool         stopCurrentQuadrature = false;
+const double MAX_DURATION          = 10; // seconds
+#endif
+
 // #define
 
 namespace algoim
@@ -404,6 +413,14 @@ void eliminate_axis(PolySet<N, ALGOIM_M>& phi, int k, PolySet<N - 1, ALGOIM_M>&
     // R
     for (int i = 0; i < phi.count(); ++i)
         for (int j = i + 1; j < phi.count(); ++j) {
+#if STOP_WHEN_BLOCKED
+            auto                          timerEnd = std::chrono::high_resolution_clock::now();
+            std::chrono::duration<double> duration = timerEnd - timerStart;
+            if (duration.count() > MAX_DURATION) {
+                stopCurrentQuadrature = true;
+                return;
+            } // 超过20s
+#endif
             const auto& p     = phi.poly(i);
             const auto& pmask = phi.mask(i);
             const auto& q     = phi.poly(j);
@@ -551,6 +568,9 @@ struct ImplicitPolyQuadrature {
     // Build quadrature hierarchy for a domain implicitly defined by a single polynomial
     ImplicitPolyQuadrature(const xarray<real, N>& p)
     {
+#if STOP_WHEN_BLOCKED
+        timerStart = std::chrono::high_resolution_clock::now();
+#endif
         auto mask = detail::nonzeroMask(p, booluarray<N, ALGOIM_M>(true));
 
         if (!detail::maskEmpty(mask)) {
@@ -563,6 +583,9 @@ struct ImplicitPolyQuadrature {
     // Build quadrature hierarchy for a domain implicitly defined by two polynomials
     ImplicitPolyQuadrature(const xarray<real, N>& p, const xarray<real, N>& q)
     {
+#if STOP_WHEN_BLOCKED
+        timerStart = std::chrono::high_resolution_clock::now();
+#endif
         {
             // auto tmp  = booluarray<N, ALGOIM_M>(false);
             auto mask = detail::nonzeroMask(p, booluarray<N, ALGOIM_M>(true));
@@ -580,6 +603,9 @@ struct ImplicitPolyQuadrature {
     // Build quadrature hierarchy for a domain implicitly defined by multiple polynomials
     ImplicitPolyQuadrature(const std::vector<xarray<real, N>>& ps)
     {
+#if STOP_WHEN_BLOCKED
+        timerStart = std::chrono::high_resolution_clock::now();
+#endif
         for (const auto& p : ps) {
             auto mask = detail::nonzeroMask(p, booluarray<N, ALGOIM_M>(true));
             if (!detail::maskEmpty(mask)) phi.push_back(p, mask);
@@ -608,6 +634,9 @@ struct ImplicitPolyQuadrature {
 
     ImplicitPolyQuadrature(const std::vector<tensor3>& tensors, const std::vector<int>& polyIndices)
     {
+#if STOP_WHEN_BLOCKED
+        timerStart = std::chrono::high_resolution_clock::now();
+#endif
         for (auto i : polyIndices) {
             auto mask = detail::nonzeroMask(tensors[i], booluarray<N, ALGOIM_M>(true));
             if (!detail::maskEmpty(mask)) phi.push_back(tensors[i], mask);
@@ -617,6 +646,9 @@ struct ImplicitPolyQuadrature {
 
     ImplicitPolyQuadrature(const std::vector<organizer::MinimalPrimitiveRep>& minimalReps, const std::vector<int>& polyIndices)
     {
+#if STOP_WHEN_BLOCKED
+        timerStart = std::chrono::high_resolution_clock::now();
+#endif
         for (auto i : polyIndices) {
             auto mask = detail::nonzeroMask(minimalReps[i].tensor, booluarray<N, ALGOIM_M>(true));
             if (!detail::maskEmpty(mask)) phi.push_back(minimalReps[i].tensor, mask);
@@ -630,6 +662,9 @@ struct ImplicitPolyQuadrature {
                            const xarray<real, N>&         q,
                            const booluarray<N, ALGOIM_M>& qmask)
     {
+#if STOP_WHEN_BLOCKED
+        timerStart = std::chrono::high_resolution_clock::now();
+#endif
         {
             auto mask = detail::nonzeroMask(p, pmask);
             if (!maskEmpty(mask)) phi.push_back(p, mask);
@@ -645,6 +680,7 @@ struct ImplicitPolyQuadrature {
     // Assuming phi has been instantiated, determine elimination axis and build base
     void build(bool outer, bool auto_apply_TS)
     {
+        if (stopCurrentQuadrature) { return; }
         type                = outer ? OuterSingle : Inner;
         this->auto_apply_TS = auto_apply_TS;