openscad-cpp-evaluator 1.48.0__tar.gz → 1.49.1__tar.gz

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.48.0
+Version: 1.49.1
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT AND OFL-1.1

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -406,9 +406,14 @@ enum class Op {
     // for an attachable()-style multi-body operand) and appends it, as a
     // Value, onto csgWrapStack.back().groupSizes -- exactly one entry per
     // top-level geometry statement, in source order, mirroring resolveCsg's
-    // own `groupSizes.push_back(Value{...})` loop.
+    // own `groupSizes.push_back(Value{...})` loop. Bit 4 of `a`: the statement is an `if` (no else), an operand
+    // exactly when it took its branch, read from ev.lastIfTaken.
     CsgGroupEnd,
 
+    // Sets ev.lastIfTaken = (a != 0) as an `if` (no else) finishes. See
+    // Evaluator::lastIfTaken.
+    SetLastIfTaken,
+
     // One `children(..., separate=true)` statement inside a CSG bracket.
     // `a` interns the ModularCall in nativeStatements.
     //

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -228,6 +228,11 @@ public:
     // contributed by comparing this before/after evaluating just that one
     // statement.
     size_t currentTreeFrameSize() const { return treeStack_.back().size(); }
+    // Whether the last `if` (no else) to finish took its branch. Written as
+    // the statement ENDS, so after evaluating an outer `if` it describes
+    // that one and not an `if` nested inside it. Read by the CSG operand
+    // rule (emptyStatementIsAnOperand), which is its only reason to exist.
+    bool lastIfTaken = false;
 
 
     // Generate pass: walks `tree` bottom-up (children before their own

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/pyproject.toml

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

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/src/builtins/booleans.cpp

@@ -97,7 +97,12 @@ bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt) {
     const oscad::NodeKind k = stmt.kind();
     return k == oscad::NodeKind::ModularCall || k == oscad::NodeKind::ModularFor ||
            k == oscad::NodeKind::ModularIntersectionFor || k == oscad::NodeKind::ModularLet ||
-           k == oscad::NodeKind::ModularModifierShowOnly || k == oscad::NodeKind::ModularModifierHighlight;
+           k == oscad::NodeKind::ModularModifierShowOnly || k == oscad::NodeKind::ModularModifierHighlight ||
+           k == oscad::NodeKind::ModularIfElse;
+}
+
+bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt, bool ifTaken) {
+    return emptyStatementIsAnOperand(stmt) || (stmt.kind() == oscad::NodeKind::ModularIf && ifTaken);
 }
 
 CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
@@ -140,16 +145,20 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
         //
         // The reference builds a node for a module instantiation and for a
         // loop whatever they contain, so an empty one is an empty operand
-        // and annihilates an intersection. An `if` that takes no branch, a
-        // bare block, and a `*`-disabled statement build no node at all, so
-        // they are not operands and must be skipped.
+        // and annihilates an intersection. So does an `if` that TAKES a
+        // branch, even one that draws nothing -- `if (true) {}` empties an
+        // intersection, and so does BOSL2's partition() when its child
+        // draws only one half (`if ($children>0) children();`). An `if`
+        // that takes no branch, a bare block, and a `*`-disabled statement
+        // build no node at all, so they are not operands and must be
+        // skipped. An if/else always takes one.
         //
         // Every line of this was checked against OpenSCAD rather than
         // reasoned about -- `intersection(){ cube(10); X; }` keeps the cube
         // for `if(false) sphere(6)`, `{ }` and `*cube(1)`, and comes out
         // empty for `for(i=[1:0]) sphere(6)`, `union(){}`, `group(){}` and
         // a call to an empty user module.
-        emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*geoNode)});
+        emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*geoNode, ev.lastIfTaken)});
         backgroundStmt.push_back(Value{geoNode->kind() == oscad::NodeKind::ModularModifierBackground});
     }
 

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/src/builtins/builtins.hpp

@@ -264,6 +264,8 @@ std::vector<ColoredBody> generateSurface(Evaluator& ev, const CSGParams& params,
 // Whether a statement that produced no geometry still counts as a boolean
 // operand (and so empties an intersection) -- see resolveCsg.
 bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt);
+// The same, for a statement just evaluated: `ifTaken` is ev.lastIfTaken.
+bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt, bool ifTaken);
 
 // OpenSCAD's sin_degrees/cos_degrees/tan_degrees/atan2_degrees: exact at
 // multiples of 30 and 45 degrees.

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/src/builtins/control.cpp

@@ -138,7 +138,7 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
                 const size_t before = ev.currentTreeFrameSize();
                 ev.evalChildren(std::vector<const oscad::ASTNode*>{stmt}, parentCtx);
                 groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
-                emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*stmt)});
+                emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*stmt, ev.lastIfTaken)});
                 backgroundStmt.push_back(Value{stmt->kind() == oscad::NodeKind::ModularModifierBackground});
             }
             return;

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/src/builtins/topology.cpp

@@ -651,27 +651,22 @@ std::vector<ColoredBody> generateMeshRepair(Evaluator& ev, const CSGParams& para
 
 // -- levelset(field, bounds, isovalue) -------------------------------------
 //
-// A solid from a grid of sampled values. Wraps Manifold::LevelSet with a C++
-// trilinear-sampling lambda over the array the script handed us.
+// A solid from a grid of sampled values: the field array the script handed
+// us, or a function sampled onto a grid at edge= spacing. The grid is then
+// marched directly, as BOSL2's isosurface() does -- see marchingCubes() and
+// the end of generateLevelSet for why Manifold::LevelSet is no longer used.
 //
-// Why a grid rather than Manifold's own SDF-callback shape, which would be
-// the obvious mapping: measured, building the field in OpenSCAD costs
-// 0.41 us/sample against 0.96 us for a closure call per sample, because the
-// arithmetic inlines into the list comprehension. More importantly a grid
-// means the C++ side never re-enters the evaluator, so canParallel can be
-// TRUE -- Manifold's docs warn that parallel policies "will crash language
-// runtimes with runtime locks that expect to not be called back by
-// unregistered threads", which is exactly what a callback design forfeits.
+// Why offer an array at all, when a function is the obvious mapping:
+// measured, building the field in OpenSCAD costs 0.41 us/sample against
+// 0.96 us for a closure call per sample, because the arithmetic inlines into
+// the list comprehension.
 //
-// The trade is memory: ~67 bytes per cell, so 200^3 is about 550 MB and that
-// is the practical ceiling. A callback samples lazily and has no ceiling.
+// The trade is memory: ~67 bytes per cell for the array, so 200^3 is about
+// 550 MB and that is the practical ceiling.
 //
-// Accuracy is bounded by the GRID, not by Manifold. At the grid's own
-// spacing (the default) the grid is marched directly, as BOSL2's
-// isosurface() does -- see marchingCubes(). An edge= asking for a different
-// spacing resamples it through LevelSet instead, which samples a
-// body-centred cubic lattice (sdf.cpp:440-446) that a plain cubic grid does
-// not line up with, so the lambda interpolates trilinearly between samples.
+// Accuracy is bounded by the GRID. An array at its own spacing (the default)
+// is marched as is; an edge= asking for a different spacing re-samples it
+// trilinearly onto a grid at that spacing first.
 
 namespace {
 
@@ -1013,6 +1008,13 @@ manifold::MeshGL64 marchingCubes(const std::vector<double>& d, const size_t n[3]
                     const int axis = (b - a) == 1 ? 0 : (b - a) == 2 ? 1 : 2;
                     int64_t& id = edgeVert[3 * p[a] + static_cast<size_t>(axis)];
                     if (id < 0) {
+                        // Linear, as BOSL2 interpolates. Root-finding each
+                        // vertex onto the true surface of a function field was
+                        // tried and measured (#745 on BelfrySCAD): 16% less mean
+                        // normal error on a sphere, but where the grid is too
+                        // coarse for the field it put real ripples on vertices
+                        // the grid cannot connect -- jagged, sliver-strewn --
+                        // where interpolating smooths them away, as BOSL2 does.
                         const double t = v[a] / (v[a] - v[b]);
                         const double x = org[0] + h[0] * (static_cast<double>(i + (a & 1)) + (axis == 0 ? t : 0.0));
                         const double y = org[1] + h[1] * (static_cast<double>(j + (a >> 1 & 1)) + (axis == 1 ? t : 0.0));
@@ -1122,14 +1124,10 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
                                            const oscad::ASTNode& node) {
     // Two shapes of field, and the choice matters beyond taste:
     //
-    //   a GRID    -- faster to sample (0.41 vs 0.96 us) and meshes in
-    //                PARALLEL, because nothing re-enters the evaluator.
-    //                Accuracy is capped by the grid; memory is the ceiling.
-    //   a FUNCTION -- Manifold picks its own sample points and can snap to
-    //                the true surface, so it is MORE accurate, with no
-    //                memory ceiling. But every sample is a closure call, and
-    //                canParallel must be false or the evaluator gets called
-    //                back from threads it knows nothing about.
+    //   a GRID    -- faster to sample (0.41 vs 0.96 us). Accuracy is capped
+    //                by the grid; memory is the ceiling.
+    //   a FUNCTION -- sampled onto a grid at edge= spacing, one closure call
+    //                per sample. Needs edge=, since nothing else says how fine.
     const Value& fieldArg = params.at("field");
     const ClosurePtr* fieldFn = std::get_if<ClosurePtr>(&fieldArg);
     // The array is NOT parsed yet: whether it should be field[i][j] or
@@ -1415,13 +1413,8 @@ 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 clamping above extends the boundary
-        // values outward, so a surface meeting the box runs straight on into
-        // the padding and the clip to `bounds` below leaves a clean plane.
-        // Answering "outside" there instead (as this once did) made Manifold
-        // close the surface right AT the box face, along its own lattice: a
-        // waffle-textured staircase INSIDE the bounds, which the clip could
-        // not remove (#745 on BelfrySCAD).
+        // Clamped, though every grid node lies inside the block: the
+        // floating-point position of the last node can land a hair past it.
 
         double acc = 0.0;
         for (int c = 0; c < 8; ++c) {
@@ -1433,62 +1426,54 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
         return bandDistance(acc, isoLo, isoHi, invert);
     };
 
-    // 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.
+    // Every 3D field is marched on a REGULAR grid whose outermost nodes lie
+    // exactly on `bounds`, as BOSL2's isosurface() marches: an array at its
+    // own spacing as is, anything else sampled onto one first (a function by
+    // calling it, an array re-sampled trilinearly).
     //
-    // 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 manifold::vec3 E = edgeVec ? manifold::vec3(edgeV[0], edgeV[1], edgeV[2]) : manifold::vec3(edge);
-    const manifold::vec3 pad = 2.0 * E;
-    manifold::Box bounds(manifold::vec3(origin[0], origin[1], origin[2]) - pad,
-                          manifold::vec3((*hi)[0], (*hi)[1], (*hi)[2]) + pad);
-    // tolerance: Manifold root-finds along each crossing lattice edge until
-    // the bracket is within it (a distance along the edge, so independent of
-    // the field's units), instead of interpolating linearly between the two
-    // lattice samples. 1% of the edge. Measured on #745 on BelfrySCAD: the
-    // function form's vertices go from up to 0.2 off the true surface to on
-    // it, and the mean face-normal error on a per-axis edge halves to
-    // BOSL2's own; a grid gains too, since the trilinear field between
-    // samples is not linear along a lattice edge. Costs 11-20% more work.
+    // This replaced Manifold::LevelSet for the function form and for an
+    // array at another spacing (#745 on BelfrySCAD). LevelSet samples its own
+    // body-centred lattice, whose irregular triangles shade as a field of
+    // dimples even where every vertex is on the surface -- worse with a
+    // per-axis edge, which meshed a squashed field and stretched it back. And
+    // that lattice does not land on the box, so where the clip below cut it
+    // the cut face did not follow the same grid as the rest of the surface.
     //
-    // canParallel is the crux: safe for a grid because the lambda is pure
-    // C++, and NOT safe for a function, which re-enters the evaluator.
-    // Manifold: parallel policies "will crash language runtimes with runtime
-    // locks that expect to not be called back by unregistered threads".
-    //
-    // LevelSet takes a single edge length, so a per-axis edge meshes a field
-    // squashed to unit spacing on every axis and stretches the result back.
-    // The tolerance there is 1% of the unit edge, so 1% of each axis's own.
-    const double tol = 0.01 * (edgeVec ? 1.0 : edge);
-    manifold::Manifold solid;
-    if (marchGrid) {
-        const size_t n[3] = {field->nx + 2, field->ny + 2, field->nz + 2};
-        std::vector<double> d(n[0] * n[1] * n[2], -1.0);   // the "outside" ring
-        for (size_t k = 0; k < field->nz; ++k)
-            for (size_t j = 0; j < field->ny; ++j)
-                for (size_t i = 0; i < field->nx; ++i)
-                    d[((k + 1) * n[1] + (j + 1)) * n[0] + (i + 1)] =
-                        bandDistance(field->at(i, j, k), isoLo, isoHi, invert);
-        const std::array<double, 3> org{origin[0] - spacing[0], origin[1] - spacing[1], origin[2] - spacing[2]};
-        solid = manifold::Manifold(marchingCubes(d, n, org, spacing));
-        // Never expected; but a mesh Manifold refuses must not cost the
-        // user their shape, so fall back to resampling it.
-        if (solid.Status() != manifold::Manifold::Error::NoError) marchGrid = false;
+    // A per-axis edge that does not divide the box is shrunk to the nearest
+    // one that does, never grown: never coarser than the caller asked.
+    std::array<double, 3> h = spacing;
+    size_t cells[3];
+    for (int a = 0; a < 3; ++a) {
+        const double w = (*hi)[a] - origin[a];
+        if (marchGrid) {
+            cells[a] = static_cast<size_t>(std::llround(w / spacing[a]));
+        } else {
+            const double e = edgeVec ? edgeV[a] : edge;
+            cells[a] = std::max<size_t>(1, static_cast<size_t>(std::ceil(w / e - 1e-9)));
+            h[a] = w / static_cast<double>(cells[a]);
+        }
     }
-    if (!marchGrid && !edgeVec) {
-        solid = fieldFn ? manifold::Manifold::LevelSet(sampleFn, bounds, edge, 0.0, tol, /*canParallel=*/false)
-                        : manifold::Manifold::LevelSet(sampleGrid, bounds, edge, 0.0, tol, /*canParallel=*/true);
-    } else if (!marchGrid) {
-        const manifold::Box unit(bounds.min / E, bounds.max / E);
-        solid = fieldFn ? manifold::Manifold::LevelSet([&](manifold::vec3 q) { return sampleFn(q * E); },
-                                                       unit, 1.0, 0.0, tol, /*canParallel=*/false)
-                        : manifold::Manifold::LevelSet([&](manifold::vec3 q) { return sampleGrid(q * E); },
-                                                       unit, 1.0, 0.0, tol, /*canParallel=*/true);
-        solid = solid.Scale(E);
+    // One "outside" node beyond the box on every side, so every surface
+    // closes; the clip below cuts that overhang back to the box.
+    const size_t n[3] = {cells[0] + 3, cells[1] + 3, cells[2] + 3};
+    std::vector<double> d(n[0] * n[1] * n[2], -1.0);
+    for (size_t k = 0; k + 2 < n[2]; ++k)
+        for (size_t j = 0; j + 2 < n[1]; ++j)
+            for (size_t i = 0; i + 2 < n[0]; ++i) {
+                const double x = origin[0] + h[0] * static_cast<double>(i);
+                const double y = origin[1] + h[1] * static_cast<double>(j);
+                const double z = origin[2] + h[2] * static_cast<double>(k);
+                d[((k + 1) * n[1] + (j + 1)) * n[0] + (i + 1)] =
+                    marchGrid ? bandDistance(field->at(i, j, k), isoLo, isoHi, invert)
+                    : fieldFn ? sampleFn(manifold::vec3(x, y, z))
+                              : sampleGrid(manifold::vec3(x, y, z));
+            }
+    const std::array<double, 3> org{origin[0] - h[0], origin[1] - h[1], origin[2] - h[2]};
+    manifold::Manifold solid(marchingCubes(d, n, org, h));
+    if (solid.Status() != manifold::Manifold::Error::NoError) {
+        // Never expected: marchingCubes closes by construction.
+        ev.warn("levelset(): could not build a closed mesh from this field", &node.position());
+        return {};
     }
 
     if (solid.IsEmpty()) return {};

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/src/bytecode_compiler.cpp

@@ -1480,9 +1480,11 @@ public:
             compileStatementList(std::vector<const oscad::ASTNode*>{geoNode}, out);
             // `a` = whether a group that turns out EMPTY is still an
             // operand. See emptyStatementIsAnOperand (booleans.cpp).
-            // and bit 2 = it is a `%` statement, never an operand at all.
+            // and bit 2 = it is a `%` statement, never an operand at all,
+            // and bit 4 = an `if`, decided at run time.
             const int flags = (emptyStatementIsAnOperand(*geoNode) ? 1 : 0) |
-                              (geoNode->kind() == oscad::NodeKind::ModularModifierBackground ? 2 : 0);
+                              (geoNode->kind() == oscad::NodeKind::ModularModifierBackground ? 2 : 0) |
+                              (geoNode->kind() == oscad::NodeKind::ModularIf ? 4 : 0);
             out.push_back({Op::CsgGroupEnd, flags, 0, nullptr});
         }
     }
@@ -1794,7 +1796,12 @@ public:
                 out.push_back({Op::OpenLetScope, 0, 0, nullptr});
                 compileStatementList(n.trueBranch, out);
                 out.push_back({Op::CloseExprScope, 0, 0, nullptr});
+                out.push_back({Op::SetLastIfTaken, 1, 0, nullptr});
+                const int jumpEndIdx = static_cast<int>(out.size());
+                out.push_back({Op::Jump, 0, 0, nullptr});
                 out[static_cast<size_t>(jumpFalseIdx)].b = static_cast<int>(out.size());
+                out.push_back({Op::SetLastIfTaken, 0, 0, nullptr});
+                out[static_cast<size_t>(jumpEndIdx)].a = static_cast<int>(out.size());
                 return;
             }
             case NodeKind::ModularIfElse: {

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/src/bytecode_vm.cpp

@@ -1444,11 +1444,15 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     ++f.pc;
                     break;
                 }
+                case Op::SetLastIfTaken:
+                    ev.lastIfTaken = ins.a != 0;
+                    ++f.pc;
+                    break;
                 case Op::CsgGroupEnd: {
                     PendingCsgWrap& pending = f.csgWrapStack.back();
                     const size_t after = ev.treeStack_.back().size();
                     pending.groupSizes.push_back(Value{static_cast<double>(after - pending.groupStartSize)});
-                    pending.emptyIsAGroup.push_back(Value{(ins.a & 1) != 0});
+                    pending.emptyIsAGroup.push_back(Value{(ins.a & 1) != 0 || ((ins.a & 4) != 0 && ev.lastIfTaken)});
                     pending.backgroundStmt.push_back(Value{(ins.a & 2) != 0});
                     ++f.pc;
                     break;

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/src/stmt_eval.cpp

@@ -279,12 +279,14 @@ void Evaluator::evalStatement(const oscad::ASTNode& node, EvalContext& ctx) {
         // `_check_debug(branch[0] if branch else node, ctx, expr_level=True)`.
         case oscad::NodeKind::ModularIf: {
             auto& n = static_cast<const oscad::ModularIf&>(node);
-            if (truthy(evalExprMaybeCompiled(*n.condition, ctx))) {
+            const bool taken = truthy(evalExprMaybeCompiled(*n.condition, ctx));
+            if (taken) {
                 checkDebug(n.trueBranch.empty() ? node : *n.trueBranch.front(), ctx, /*forced=*/false,
                             /*exprLevel=*/true);
                 EvalContext branchCtx = blockScope(ctx);
                 evalChildren(n.trueBranch, branchCtx);
             }
+            lastIfTaken = taken;
             return;
         }
         case oscad::NodeKind::ModularIfElse: {

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/tests/test_booleans.cpp

@@ -11,6 +11,14 @@
 using namespace oscadeval;
 using namespace oscadeval::test;
 
+namespace {
+class ScopedVm {
+public:
+    explicit ScopedVm(bool enabled) { Evaluator::setBytecodeVmEnabledForTesting(enabled); }
+    ~ScopedVm() { Evaluator::setBytecodeVmEnabledForTesting(std::nullopt); }
+};
+} // namespace
+
 // -- difference / intersection -------------------------------------------
 
 TEST(Difference, SubtractsInnerCubeVolume) {
@@ -66,10 +74,17 @@ TEST(Intersection, EmptyStatementsFollowTheReferenceExactly) {
     // falls out: a module instantiation or a loop builds a node whatever it
     // contains, so an empty one is an empty operand and annihilates; an
     // `if` with no branch taken, a bare block and a `*`-disabled statement
-    // build no node at all and are not operands.
+    // build no node at all and are not operands. An `if` that takes a
+    // branch is one, whatever the branch draws.
     struct Case { const char* stmt; bool keepsTheCube; };
     const Case cases[] = {
         {"if (false) sphere(6);",            true},
+        {"if (true) { }",                    false},
+        {"if (true) if (false) sphere(6);",  false},
+        {"if (true) { x = 1; }",             false},
+        {"if (false) sphere(6); else { }",   false},
+        {"if (false) sphere(6); else if (false) sphere(6);", false},
+        {"{ if (false) sphere(6); }",        true},
         {"{ }",                              true},
         {"*cube(1);",                        true},
         {"for (i = [1:0]) sphere(6);",       false},
@@ -78,9 +93,16 @@ TEST(Intersection, EmptyStatementsFollowTheReferenceExactly) {
         {"let(x = 1) { }",                   false},
         {"#union() { }",                     false},
     };
+    // Each at top level and inside a module body, under both the
+    // interpreter and the VM, which decide an `if` separately.
+    for (const bool vm : {false, true})
+    for (const char* wrap : {"%s", "module w() { %s } w();"})
     for (const Case& c : cases) {
-        const std::string src =
+        ScopedVm scoped(vm);
+        const std::string inner =
             std::string("intersection() { cube(10, center=true); ") + c.stmt + " }";
+        std::string src = wrap;
+        src.replace(src.find("%s"), 2, inner);
         Evaluated e = evalSrc(src);
         if (c.keepsTheCube) {
             ASSERT_EQ(e.bodies.size(), 1u) << src;
@@ -94,6 +116,24 @@ TEST(Intersection, EmptyStatementsFollowTheReferenceExactly) {
     }
 }
 
+TEST(Intersection, BOSL2PartitionShowsOnlyTheHalfItsChildDraws) {
+    // partition()'s own shape: `intersection() { if ($children>0)
+    // children(); mask }`, once per half. A child drawing nothing for one
+    // half must empty that half, not leave its mask behind -- which is what
+    // `partition() if ($idx==0) cylinder(...)` drew. Verified against
+    // OpenSCAD: only the cube's own volume.
+    for (const bool vm : {false, true}) {
+        ScopedVm scoped(vm);
+        Evaluated e = evalSrc(
+            "module m() { intersection() { if ($children > 0) children(); cube(10); } }"
+            "m() if (false) sphere(5);");
+        const bool anyVolume = std::any_of(
+            e.bodies.begin(), e.bodies.end(),
+            [](const ColoredBody& b) { return b.body && !b.body->IsEmpty(); });
+        EXPECT_FALSE(anyVolume) << "vm=" << vm;
+    }
+}
+
 TEST(Intersection, AnEmptyUserModuleIsStillAnOperand) {
     // The reference builds a node for a module instantiation whatever the
     // module's body does, so calling one that draws nothing empties the
@@ -1606,13 +1646,13 @@ TEST(LevelSet, AGridFieldIsAlsoCutCleanlyAtTheBox) {
     EXPECT_NEAR(capArea, 3.14159265358979 * r * r, 0.03 * 3.14159265358979 * r * r);
 }
 
-TEST(LevelSetFn, VerticesLieOnTheTrueSurface) {
-    // A positive tolerance makes Manifold root-find along each lattice edge
-    // instead of interpolating linearly between its two samples, so a
-    // function field's vertices land on the surface itself. Measured on
-    // #745 on BelfrySCAD: 0.2 off at edge=2 before, on the surface after;
-    // the coarse, curved 1/r field there is where linear interpolation is
-    // worst.
+TEST(LevelSetFn, VerticesInterpolateAsBOSL2Does) {
+    // #745 on BelfrySCAD, second round: a function field is sampled onto a
+    // regular grid and marched, as BOSL2's isosurface() does, rather than
+    // meshed by Manifold::LevelSet, whose body-centred lattice shaded as
+    // dimples. Vertices are interpolated linearly along grid edges, so they
+    // are near the surface, not on it: the 1/r field at edge=2 is where that
+    // is worst. A per-axis edge must mesh as well as a plain one.
     for (const char* edge : {"2", "[1,2,0.4]"}) {
         Evaluated e = evalSrc(std::string("levelset(function(x,y,z) 5 / norm([x,y,z]), "
                                            "bounds=[[-8,-8,-8],[8,8,8]], isovalue=[1, 1/0], edge=") +
@@ -1623,7 +1663,8 @@ TEST(LevelSetFn, VerticesLieOnTheTrueSurface) {
         for (size_t v = 0; v + 2 < m.vertProperties.size(); v += m.numProp)
             worst = std::max(worst, std::abs(manifold::la::length(manifold::vec3(m.vertProperties[v], m.vertProperties[v + 1],
                                                                        m.vertProperties[v + 2])) - 5.0));
-        EXPECT_LT(worst, 0.03) << edge;
+        EXPECT_LT(worst, 0.3) << edge;
+        EXPECT_EQ(soleBody(e).Genus(), 0) << edge;
     }
 }
 
@@ -1701,6 +1742,28 @@ TEST(LevelSetGrid, AVectorEdgeWithoutBoundsSpacesEachAxis) {
     EXPECT_NEAR(b.min.z, -0.75, 1e-9); EXPECT_NEAR(b.max.z, 0.75, 1e-9);
 }
 
+TEST(LevelSetGrid, AFunctionIsMarchedOnAGridLandingOnTheBounds) {
+    // Per-axis edge [1, 2, 0.4] over a 12 x 16 x 7 box: x and y divide it,
+    // z does not (17.5 cells), so z is shrunk to 7/18 -- never coarsened --
+    // and the grid's last nodes lie exactly on the box. Every vertex is then
+    // on a grid edge.
+    Evaluated e = evalSrc("levelset(function(x,y,z) 5 / norm([x,y,z]), isovalue=[1, 1/0], "
+                           "bounds=[[-6,-8,0],[6,8,7]], edge=[1,2,0.4]);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_GT(onGridLines(soleBody(e), manifold::vec3(-6, -8, 0), manifold::vec3(1, 2, 7.0 / 18.0)), 0.5);
+}
+
+TEST(LevelSetGrid, AnArrayAtAnotherEdgeIsResampledOntoAGridLandingOnTheBounds) {
+    // #745 on BelfrySCAD: an array resampled at an edge= not dividing the box
+    // cut faces that did not follow the rest of the surface, since
+    // LevelSet's lattice did not land on the box. 40/2.7 is 14.8 cells, so
+    // the grid is 15 cells of 40/15 and the cut faces are its own.
+    Evaluated e = evalSrc(sphereFieldSrc(41, 20) +
+                           "levelset(f, bounds=[[-20,-20,-20],[20,20,20]], isovalue=25, edge=2.7);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_GT(onGridLines(soleBody(e), manifold::vec3(-20.0), manifold::vec3(40.0 / 15.0)), 0.5);
+}
+
 TEST(LevelSetGrid, A2DFieldArrayIsPlacedByEdgeToo) {
     // field[i][j] says 2D without a bounds to say so.
     Evaluated e = evalSrc("f = [for (i=[0:4]) [for (j=[0:2]) -1 ]];\nlevelset(f, edge=2);");

{openscad_cpp_evaluator-1.48.0 → openscad_cpp_evaluator-1.49.1}/uv.lock

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