openscad-cpp-evaluator 0.51.0__tar.gz → 0.51.3__tar.gz

{openscad_cpp_evaluator-0.51.0 → openscad_cpp_evaluator-0.51.3}/.github/workflows/wheels.yml

@@ -85,9 +85,26 @@ jobs:
           # grammar requires %require "3.8". No newer bison package is
           # available via dnf on this base image, so build one from source
           # (fast: a few seconds) rather than switching manylinux images.
+          # Mirrors first, ftp.gnu.org last: ftp.gnu.org went unreachable
+          # (curl 7, connection timed out on 443) on both architectures for
+          # two consecutive runs of the v0.51.3 release, and it is a single
+          # point of failure for every Linux wheel we ship.
+          # ftpmirror.gnu.org is GNU's own redirector to a nearby mirror.
+          # Every line stays at THIS indent on purpose -- a more-indented
+          # line in a `>-` folded scalar keeps its newline instead of
+          # folding to a space, which would split a URL from its curl.
+          # CURL FLAG CEILING: this runs against AlmaLinux 8's curl 7.61,
+          # NOT the host's. --retry (7.12.3), --retry-connrefused (7.52)
+          # and --connect-timeout (7.7) are fine; --retry-all-errors is
+          # 7.71 and made every Linux wheel fail with
+          # "option --retry-all-errors: is unknown". Check `Added:` in
+          # curl/docs/cmdline-opts/<opt>.md before adding a flag here --
+          # testing the command on a Mac proves nothing about this curl.
           CIBW_BEFORE_ALL_LINUX: >-
             dnf install -y flex &&
-            curl -fsSL https://ftp.gnu.org/gnu/bison/bison-3.8.2.tar.gz -o /tmp/bison.tar.gz &&
+            { curl -fsSL --retry 3 --retry-connrefused --connect-timeout 20 https://ftpmirror.gnu.org/bison/bison-3.8.2.tar.gz -o /tmp/bison.tar.gz ||
+            curl -fsSL --retry 3 --retry-connrefused --connect-timeout 20 https://mirrors.kernel.org/gnu/bison/bison-3.8.2.tar.gz -o /tmp/bison.tar.gz ||
+            curl -fsSL --retry 3 --retry-connrefused --connect-timeout 20 https://ftp.gnu.org/gnu/bison/bison-3.8.2.tar.gz -o /tmp/bison.tar.gz ; } &&
             cd /tmp && tar xzf bison.tar.gz && cd bison-3.8.2 &&
             ./configure --prefix=/usr/local && make -j$(nproc) && make install
           # Mirrors ci.yml's macOS step: the hosted runner image ships an

{openscad_cpp_evaluator-0.51.0 → openscad_cpp_evaluator-0.51.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 0.51.0
+Version: 0.51.3
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-0.51.0 → openscad_cpp_evaluator-0.51.3}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -12,6 +12,7 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <deque>
 #include <vector>
 
 namespace oscadeval {
@@ -155,7 +156,16 @@ struct VmFrame {
     std::vector<bool> bound;
     std::vector<std::vector<Value>> accumStack;
     std::vector<IterList> iterLists;
-    std::vector<EvalContext> ctxChain;
+    // std::deque, NOT vector: Evaluator::enterUserCall stores
+    // CallStackFrame::bodyCtx as a pointer to ctxChain.back() (see
+    // pushBracketedCallFrame/pushBracketedModuleFrame), and that pointer is
+    // read LATER, by any checkDebug() that walks the whole call stack to
+    // build per-frame debugger locals. A vector reallocates on the next
+    // push -- which every transform inside a compiled body does, via
+    // Op::PushBuiltinWrap -- leaving bodyCtx pointing at the moved-from
+    // element (null let_) and segfaulting buildDebugFrame. deque never
+    // invalidates references to existing elements on push_back/pop_back.
+    std::deque<EvalContext> ctxChain;
     // Still-open Op::PushBuiltinWrap brackets, LIFO, scoped to THIS frame's
     // own instruction stream -- mirrors accumStack/iterLists' own role for
     // their respective bracket pairs. Normal execution always drains this

{openscad_cpp_evaluator-0.51.0 → openscad_cpp_evaluator-0.51.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "0.51.0"
+version = "0.51.3"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-0.51.0 → openscad_cpp_evaluator-0.51.3}/src/builtins/topology.cpp

@@ -970,6 +970,19 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
             if (i0[a] > n[a] - 2) i0[a] = n[a] - 2;
             t[a] = g[a] - static_cast<double>(i0[a]);
         }
+        // Outside the sampled block the answer is "outside", falling away
+        // with distance. Clamping instead (which is what the interpolation
+        // above does on its own) would smear the boundary values outward and
+        // extend the surface rather than close it.
+        double outside = 0.0;
+        for (int a = 0; a < 3; ++a) {
+            const double maxg = static_cast<double>(n[a] - 1);
+            const double raw = (pos[a] - origin[a]) / spacing[a];
+            if (raw < 0.0) outside = std::max(outside, -raw);
+            else if (raw > maxg) outside = std::max(outside, raw - maxg);
+        }
+        if (outside > 0.0) return invert ? (1.0 + outside) : -(1.0 + outside);
+
         double acc = 0.0;
         for (int c = 0; c < 8; ++c) {
             const size_t di = static_cast<size_t>(c & 1), dj = static_cast<size_t>((c >> 1) & 1),
@@ -980,8 +993,18 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
         return bandDistance(acc, isoLo, isoHi, invert);
     };
 
-    manifold::Box bounds(manifold::vec3(origin[0], origin[1], origin[2]),
-                          manifold::vec3((*hi)[0], (*hi)[1], (*hi)[2]));
+    // Manifold closes the mesh where the surface meets the edge of the box it
+    // is given, and that closure follows the sample lattice -- a visible
+    // staircase on anything that reaches the boundary, which a gyroid does
+    // everywhere. So sample a PADDED box, let the ragged closure happen out
+    // there, and cut back to the box actually asked for. The cut is then a
+    // clean plane.
+    //
+    // Exactly the fix already applied to the 2D path (clipToBounds); it was
+    // not applied here at the time because the 2D error was the one measured.
+    const double pad = 2.0 * edge;
+    manifold::Box bounds(manifold::vec3(origin[0] - pad, origin[1] - pad, origin[2] - pad),
+                          manifold::vec3((*hi)[0] + pad, (*hi)[1] + pad, (*hi)[2] + pad));
     // tolerance -1: a positive value makes Manifold do EXTRA evaluations per
     // output vertex to snap nearer the true surface. Against a fixed grid
     // those only re-interpolate data already used -- cost, no information.
@@ -996,6 +1019,10 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
                  : manifold::Manifold::LevelSet(sampleGrid, bounds, edge, 0.0, -1.0, /*canParallel=*/true);
 
     if (solid.IsEmpty()) return {};
+    solid = solid ^ manifold::Manifold::Cube(
+                        manifold::vec3((*hi)[0] - origin[0], (*hi)[1] - origin[1], (*hi)[2] - origin[2]))
+                        .Translate(manifold::vec3(origin[0], origin[1], origin[2]));
+    if (solid.IsEmpty()) return {};
     ColoredBody b;
     b.body = std::move(solid);
     std::vector<ColoredBody> out;

{openscad_cpp_evaluator-0.51.0 → openscad_cpp_evaluator-0.51.3}/src/bytecode_vm.cpp

@@ -270,8 +270,11 @@ void pushBracketedCallFrame(Evaluator& ev, const CompiledChunk& chunk, const osc
     applyCompiledDefaultsToFrame(ev, chunk, *frame);
 
     // enterUserCall's own bodyCtx must point at frame->ctxChain's OWN
-    // storage (stable: this VmFrame lives behind a unique_ptr, so its
-    // address never moves even if vmCallStack_ itself reallocates), not
+    // storage (stable on two counts: this VmFrame lives behind a
+    // unique_ptr, so its address never moves even if vmCallStack_ itself
+    // reallocates, AND ctxChain is a std::deque, so a later push onto it
+    // never moves the element handed over here -- see its own doc comment,
+    // bytecode_vm.hpp, for the segfault a vector caused), not
     // a plain local -- a local `childCtx` here would be destroyed the
     // instant this function returns, but CallStackFrame::bodyCtx is read
     // LATER, by ANY subsequent checkDebug() call (this call's own nested
@@ -328,7 +331,7 @@ void pushBracketedModuleFrame(Evaluator& ev, const CompiledChunk& chunk, const o
     frame->logicalName = decl.name->name;
     frame->ownsModuleSplice = true;
     // enterUserCall's own bodyCtx must point at frame->ctxChain's OWN
-    // storage, not the caller's own (about-to-be-destroyed) local
+    // (deque-stable) storage, not the caller's own (about-to-be-destroyed) local
     // `childCtx` -- see pushBracketedCallFrame's own doc comment, above,
     // for the full dangling-pointer hazard this avoids (same fix, same
     // root cause, module side).

{openscad_cpp_evaluator-0.51.0 → openscad_cpp_evaluator-0.51.3}/tests/test_booleans.cpp

@@ -1143,3 +1143,49 @@ TEST(LevelSet2d, A3dArrayWithA2dBoundsWarns) {
     EXPECT_FALSE(levelsetWarnings("levelset([[[1,2],[3,4]],[[5,6],[7,8]]], bounds=[[0,0],[1,1]]);")
                      .empty());
 }
+
+TEST(LevelSet, ASurfaceMeetingTheBoxIsCutCleanly) {
+    // Manifold closes the mesh where the surface reaches the edge of the box
+    // it is given, and that closure follows the SAMPLE LATTICE -- a visible
+    // staircase on anything that touches the boundary. A gyroid touches it
+    // everywhere, which is how this was found: the shape looked ragged next
+    // to BOSL2's isosurface() of the same field.
+    //
+    // Sampling a padded box and cutting back makes the cut a plane. The
+    // numeric form of that: a half-space is EXACTLY half the box, at every
+    // resolution. Before the fix it was resolution-dependent.
+    //
+    // The 2D path had this fixed already (clipToBounds); 3D did not, because
+    // 2D was the case that got measured at the time.
+    for (const char* edge : {"2", "1", "0.5"}) {
+        Evaluated e = evalSrc(std::string("levelset(function(x,y,z) x, "
+                                           "bounds=[[-20,-20,-20],[20,20,20]], "
+                                           "isovalue=[-1e18,0], edge=") +
+                               edge + ");");
+        ASSERT_EQ(e.bodies.size(), 1u) << "edge=" << edge;
+        EXPECT_NEAR(soleBody(e).Volume(), 32000.0, 1e-6) << "edge=" << edge;
+    }
+}
+
+TEST(LevelSet, PaddingDoesNotDisturbAShapeInsideTheBox) {
+    // The padding is sampled outside the requested bounds, so a shape that
+    // never reaches the boundary must come out exactly as before.
+    Evaluated e = evalSrc(sphereFieldSrc(50, 30) +
+                           "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=20);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const double analytic = 4.0 / 3.0 * 3.14159265358979 * 8000;
+    EXPECT_NEAR(soleBody(e).Volume(), analytic, 0.01 * analytic);
+    EXPECT_EQ(soleBody(e).Genus(), 0);
+}
+
+TEST(LevelSet, AGridFieldIsAlsoCutCleanlyAtTheBox) {
+    // The grid intake cannot sample beyond its data, so the sampler reads
+    // "outside" past the block rather than clamping and smearing the edge
+    // values outward. Same clean cut as the function form.
+    Evaluated e = evalSrc(
+        "N = 41;\nfunction co(t) = -20 + 40*t/(N-1);\n"
+        "f = [for (i=[0:N-1]) [for (j=[0:N-1]) [for (k=[0:N-1]) co(i) ]]];\n"
+        "levelset(f, bounds=[[-20,-20,-20],[20,20,20]], isovalue=[-1e18,0]);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(soleBody(e).Volume(), 32000.0, 40.0);   // one sample layer of slack
+}

{openscad_cpp_evaluator-0.51.0 → openscad_cpp_evaluator-0.51.3}/tests/test_debug_hooks.cpp

@@ -694,3 +694,45 @@ TEST(DebugHooksParity, BuiltinFunctionCallGetsNoCallSiteStop) {
 TEST(DebugHooksParity, ModifierAndItsWrappedChildBothStop) {
     EXPECT_EQ(recordStops("#cube(1);\n"), (std::vector<Stop>{{1, false, false}, {1, false, false}}));
 }
+
+// An enclosing COMPILED module frame's debugger locals must survive the
+// frame growing its own ctxChain. `enterUserCall` stores
+// CallStackFrame::bodyCtx as a pointer into VmFrame::ctxChain, and any
+// later push onto that chain -- which every transform inside a compiled
+// body does, via Op::PushBuiltinWrap -- used to reallocate the container
+// and leave bodyCtx dangling. buildDebugFrames then read a moved-from
+// EvalContext (null let_) and segfaulted: the crash a user hit by setting
+// a breakpoint inside a module wrapped in translate() and continuing.
+TEST(DebugHooksParity, EnclosingCompiledFrameLocalsSurviveCtxChainGrowth) {
+    ScopedVm vm(true);
+    // The breakpoint is what makes this mixed: `inner` (line 1) is forced
+    // to interpret, while `mid` -- called from inside compiled `top` --
+    // keeps running compiled, so its callStack_ entry's bodyCtx comes from
+    // pushBracketedModuleFrame and points into VmFrame::ctxChain. The
+    // translate() in mid's body then pushes onto that same chain.
+    const std::string src = "module inner(b) { c = b; }\n"
+                             "module mid(a) { translate([a,0,0]) inner(a); }\n"
+                             "module top() { mid(7); }\n"
+                             "top();\n";
+    bool sawMid = false;
+    DebugHooks hooks;
+    hooks.debugHook = [&](int line, int, bool, bool exprLevel, const std::string&,
+                           const std::vector<CallStackFrame>&, const DebugFramesFn& getFrame) {
+        if (exprLevel || line != 1) return DebugAction{};
+        std::vector<DebugFrame> frames = getFrame();
+        for (const DebugFrame& f : frames) {
+            auto it = f.locals.find("a");
+            if (it == f.locals.end()) continue;
+            sawMid = true;
+            EXPECT_EQ(std::get<double>(it->second), 7.0);
+        }
+        return DebugAction{};
+    };
+    Evaluator ev(EchoFn{}, nullptr, nullptr, hooks);
+    ev.setFastContinueBreakpoints(std::unordered_map<std::string, std::set<int>>{{"<string>", {1}}});
+    auto ast = parseSrc(src);
+    auto scope = oscad::buildScopes(ast);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    ev.resolveTree(ast, ctx);
+    EXPECT_TRUE(sawMid) << "mid()'s own frame never appeared in the debugger frames";
+}

{openscad_cpp_evaluator-0.51.0 → openscad_cpp_evaluator-0.51.3}/tests/test_profiling.cpp

@@ -182,9 +182,30 @@ TEST(ProfilePaths, SameCalleeUnderTwoCallersGetsSeparateNodes) {
     ASSERT_NE(workUnderHeavy, nullptr);
     // Two distinct nodes for the same callee -- the whole point.
     EXPECT_NE(workUnderLight, workUnderHeavy);
-    // ...and the expensive path is attributed the larger share. This is the
-    // fact the aggregated view cannot express at all.
-    EXPECT_GT(workUnderHeavy->cumulativeTime, workUnderLight->cumulativeTime);
+
+    // ...and each carries its OWN attribution, which is the fact the
+    // aggregated view cannot express at all.
+    //
+    // Asserted on call counts, not on elapsed time. The comparison here used
+    // to be EXPECT_GT on cumulativeTime, and it was flaky: the ratio is
+    // normally about 9x but was measured collapsing to 1.79x, and it failed
+    // a macOS CI run outright. Wall-clock on a shared runner is not a thing
+    // to assert an ordering on when an exact quantity is available.
+    //
+    // The recursion folds onto a child node (see RecursionFoldsOntoASingleNode),
+    // and THAT is where the difference in work shows up: 2 recursive calls
+    // under light against 20 under heavy. Exact, identical on both engines.
+    const auto* foldedLight = childNamed(r, *workUnderLight, "work");
+    const auto* foldedHeavy = childNamed(r, *workUnderHeavy, "work");
+    ASSERT_NE(foldedLight, nullptr);
+    ASSERT_NE(foldedHeavy, nullptr);
+    EXPECT_EQ(foldedLight->callCount, 2);
+    EXPECT_EQ(foldedHeavy->callCount, 20);
+
+    // Times are still recorded per path -- just not compared against each
+    // other, since only their existence is deterministic.
+    EXPECT_GT(workUnderLight->cumulativeTime, 0.0);
+    EXPECT_GT(workUnderHeavy->cumulativeTime, 0.0);
 
     // The flat view still totals both, unchanged.
     double siteTotal = 0.0;

{openscad_cpp_evaluator-0.51.0 → openscad_cpp_evaluator-0.51.3}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "0.37.0"
+version = "0.51.3"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },