openscad-cpp-evaluator 0.49.0__tar.gz → 0.50.1__tar.gz

{openscad_cpp_evaluator-0.49.0 → openscad_cpp_evaluator-0.50.1}/CLAUDE.md

@@ -460,6 +460,51 @@ grep for `ponytail:`.
   unknown arguments -- `children(separate=true)` renders the wrong shape there with no warning --
   and both read as `undef` in OpenSCAD, so a guard written against them works in both.
 
+- **`levelset(field, bounds, isovalue)`** (`src/builtins/topology.cpp`, feature name `levelset`) —
+  a solid from a grid of sampled values: `field[i][j][k]` with i,j,k mapping to x,y,z. Wraps
+  `Manifold::LevelSet` with a C++ trilinear-sampling lambda; no new Manifold API.
+  **The field is a grid OR a `function(x,y,z)`, and the two trade off against each other** —
+  neither is simply better:
+
+  | | sampling | parallel | accuracy | ceiling |
+  |---|---|---|---|---|
+  | grid `field[i][j][k]` | 0.41 µs | **yes** | capped by the grid | ~550 MB at 200³ |
+  | `function(x,y,z)` | 0.96 µs | **no** | Manifold snaps toward the true surface | none |
+
+  Measured at matched resolution against the analytic sphere: **50³ grid 0.23 s (−0.244%) vs
+  function 0.32 s (−0.103%); 100³ grid 1.06 s (−0.059%) vs function 1.91 s (−0.025%)**. So the
+  function form is ~1.5× slower and ~2.4× more accurate. Both still beat BOSL2.
+  `canParallel` is the crux and is **not a tuning knob**: true for a grid because the lambda is
+  pure C++, false for a function because Manifold warns that parallel policies "will crash
+  language runtimes with runtime locks that expect to not be called back by unregistered threads".
+  The function form also needs `edge=` explicitly — there is no grid to infer spacing from and the
+  cost is cubic in it, so guessing would silently produce either a useless mesh or a ten-minute
+  one.
+  Measured against BOSL2's `isosurface.scad` (217 KB of marching cubes in script), same field:
+  **50³ 0.26 s vs 2.07 s (8.0×), 100³ 1.15 s vs 14.59 s (12.7×)**.
+  The trade is **memory**: ~67 bytes/cell, so 200³ ≈ 550 MB is the practical ceiling. A callback
+  samples lazily and has none.
+  **Accuracy is bounded by the grid, not by Manifold.** It samples on a body-centred cubic lattice
+  (`sdf.cpp:440-446`) so a plain cubic grid does not line up and the lambda interpolates — same
+  accuracy as grid-based marching cubes in script, worse than `LevelSet` given a true SDF. Hence
+  `tolerance = -1` is forced: a positive value makes Manifold do extra evaluations per vertex that
+  would only re-interpolate data already used. `edgeLength` defaults to the grid spacing for the
+  same reason.
+  Calling the field function from the generate pass has no live `EvalContext`, so a root is built
+  from the closure's own scope — `$`-variables sit at their defaults inside it.
+  **An explicitly-undef optional argument counts as ABSENT**, not as a bad one — the same rule in
+  `linear_solve` (`b`) and `levelset` (`isovalue`). BOSL2 reaches a builtin it also defines by
+  wrapping it in `builtins.scad`, which `use <>`s nothing, so the names there bind to the builtins:
+  `function _linear_solve(A, b) = linear_solve(A, b);`. That wrapper has a fixed signature and so
+  forwards `b` even when the caller passed none, so treating undef as a *bad* argument warned on
+  every `determinant()`-style call. Passing undef is idiomatically the same as not passing in
+  OpenSCAD, which is how BOSL2 threads optional arguments through wrappers throughout.
+  Verified against OpenSCAD 2026.02.01: the wrapper pattern resolves identically there.
+  Sign convention: Manifold takes positive as inside; a distance field is the other way round, so
+  the default flips it and `invert=true` flips back.
+  Two behaviours that look alike and are opposite: an isovalue **nothing reaches** gives empty
+  geometry; one **everything satisfies** gives the whole bounding box. Both are tested.
+
 - **`linear_solve(A, b)`** (`src/builtins/function_builtins.cpp`, feature name `linear-solve`) —
   returns `.x` (solution), `.det`, `.singular`. Dispatches on shape:
 

{openscad_cpp_evaluator-0.49.0 → openscad_cpp_evaluator-0.50.1}/PKG-INFO

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

{openscad_cpp_evaluator-0.49.0 → openscad_cpp_evaluator-0.50.1}/pyproject.toml

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

{openscad_cpp_evaluator-0.49.0 → openscad_cpp_evaluator-0.50.1}/src/builtins/builtins.hpp

@@ -183,6 +183,11 @@ std::vector<ColoredBody> generateHull(Evaluator& ev, const CSGParams& params,
 Value builtinDxfDim(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node);
 Value builtinDxfCross(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node);
 
+CSGParams resolveLevelSet(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
+std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params,
+                                           const std::vector<std::unique_ptr<CSGNode>>& children,
+                                           const oscad::ASTNode& node);
+
 CSGParams resolveSimplify(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateSimplify(Evaluator& ev, const CSGParams& params,
                                            const std::vector<std::unique_ptr<CSGNode>>& children,

{openscad_cpp_evaluator-0.49.0 → openscad_cpp_evaluator-0.50.1}/src/builtins/function_builtins.cpp

@@ -913,6 +913,7 @@ const std::unordered_map<std::string, double>& featureLevels() {
     static const std::unordered_map<std::string, double> levels = {
         {"render-expr", 1.0},        // render() in expression position
         {"linear-solve", 1.0},       // linear_solve(A, b) -> {x, det, singular}
+        {"levelset", 1.0},           // levelset(field, bounds, isovalue)
         {"polyhedron-vnf", 1.0},     // polyhedron(vnf) / polyhedron(object)
         {"separate-children", 1.0},  // children(..., separate=true)
         {"minkowski-diff", 1.0},     // minkowski_difference()
@@ -1344,9 +1345,19 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
         // The OpenSCAD release we track. version_num() is that same
         // year/month/day folded as y * 10000 + m * 100 + d, exactly like the
         // reference's own builtin_version_num (builtin_functions.cc).
-        case BuiltinFnId::LinearSolve:
-            return builtinLinearSolve(ev, getArg(args, 0, "A", Value{}), getArg(args, 1, "b", Value{}),
-                                       args.findPositional(1) != nullptr || args.findNamed("b") != nullptr, node);
+        case BuiltinFnId::LinearSolve: {
+            // An explicitly-undef b counts as ABSENT, not as a bad argument.
+            // A wrapper with a fixed signature -- BOSL2's builtins.scad
+            // pattern, `function _linear_solve(A, b) = linear_solve(A, b);`
+            // -- always forwards b, so determinant()-style callers that pass
+            // no right-hand side would otherwise warn on every call.
+            // Passing undef is idiomatically the same as not passing in
+            // OpenSCAD, which is how optional arguments are threaded through
+            // wrappers throughout BOSL2.
+            const Value bArg = getArg(args, 1, "b", Value{});
+            const bool haveB = !std::holds_alternative<std::monostate>(bArg);
+            return builtinLinearSolve(ev, getArg(args, 0, "A", Value{}), bArg, haveB, node);
+        }
         case BuiltinFnId::SupportedFeature: {
             const Value name = getArg(args, 0, "feature", Value{});
             const std::string* s = std::get_if<std::string>(&name);

{openscad_cpp_evaluator-0.49.0 → openscad_cpp_evaluator-0.50.1}/src/builtins/registry.cpp

@@ -37,6 +37,7 @@ const std::unordered_map<std::string_view, ResolveFn>& resolveDispatch() {
         {"fill", &resolveFill},
         {"minkowski_difference", &resolveMinkowskiDifference},
         {"simplify", &resolveSimplify},
+        {"levelset", &resolveLevelSet},
         {"offset", &resolveOffset},
         {"surface", &resolveSurface},
         {"text", &resolveText},
@@ -78,6 +79,7 @@ const std::unordered_map<std::string_view, GenerateFn>& generateDispatch() {
         {"fill", &generateFill},
         {"minkowski_difference", &generateMinkowskiDifference},
         {"simplify", &generateSimplify},
+        {"levelset", &generateLevelSet},
         {"offset", &generateOffset},
         {"surface", &generateSurface},
         {"text", &generateText},
@@ -125,6 +127,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         {"fill", {}},
         {"minkowski_difference", {}},
         {"simplify", {"tolerance"}},
+        {"levelset", {"field", "bounds", "isovalue", "invert", "edge"}},
         {"offset", {"r", "delta", "chamfer"}},
         {"surface", {"file", "center", "convexity", "invert"}},
         {"text", {"text", "size", "font", "direction", "language", "script", "halign", "valign", "spacing"}},

{openscad_cpp_evaluator-0.49.0 → openscad_cpp_evaluator-0.50.1}/src/builtins/topology.cpp

@@ -451,4 +451,259 @@ std::vector<ColoredBody> generateSimplify(Evaluator& ev, const CSGParams& params
     return out;
 }
 
+// -- 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.
+//
+// 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.
+//
+// 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.
+//
+// Accuracy is bounded by the GRID, not by Manifold. Manifold samples on a
+// body-centred cubic lattice (two interleaved cubic grids, sdf.cpp:440-446)
+// and a plain cubic grid does not line up with those points, so the lambda
+// interpolates. Same accuracy as a grid-based marching-cubes implementation
+// in script; worse than LevelSet given a true SDF. Do not imply otherwise.
+
+namespace {
+
+struct ScalarField {
+    std::vector<double> v;      // flat, x fastest
+    size_t nx = 0, ny = 0, nz = 0;
+    double at(size_t i, size_t j, size_t k) const { return v[(k * ny + j) * nx + i]; }
+};
+
+// field[i][j][k] -> flat, checking it is a full rectangular block.
+std::optional<ScalarField> readField(const Value& val) {
+    const ListPtr* xs = std::get_if<ListPtr>(&val);
+    if (!xs || !*xs || (*xs)->items.empty()) return std::nullopt;
+    ScalarField f;
+    f.nx = (*xs)->items.size();
+    for (size_t i = 0; i < f.nx; ++i) {
+        const ListPtr* ys = std::get_if<ListPtr>(&(*xs)->items[i]);
+        if (!ys || !*ys || (*ys)->items.empty()) return std::nullopt;
+        if (i == 0) f.ny = (*ys)->items.size();
+        else if ((*ys)->items.size() != f.ny) return std::nullopt;
+        for (size_t j = 0; j < f.ny; ++j) {
+            const ListPtr* zs = std::get_if<ListPtr>(&(*ys)->items[j]);
+            if (!zs || !*zs || (*zs)->items.empty()) return std::nullopt;
+            if (i == 0 && j == 0) {
+                f.nz = (*zs)->items.size();
+                f.v.assign(f.nx * f.ny * f.nz, 0.0);
+            } else if ((*zs)->items.size() != f.nz) {
+                return std::nullopt;
+            }
+            for (size_t k = 0; k < f.nz; ++k) {
+                const double* d = std::get_if<double>(&(*zs)->items[k]);
+                if (!d || !std::isfinite(*d)) return std::nullopt;
+                f.v[(k * f.ny + j) * f.nx + i] = *d;
+            }
+        }
+    }
+    return f;
+}
+
+std::optional<std::array<double, 3>> readVec3(const Value& v) {
+    const ListPtr* l = std::get_if<ListPtr>(&v);
+    if (!l || !*l || (*l)->items.size() != 3) return std::nullopt;
+    std::array<double, 3> out{};
+    for (size_t i = 0; i < 3; ++i) {
+        const double* d = std::get_if<double>(&(*l)->items[i]);
+        if (!d || !std::isfinite(*d)) return std::nullopt;
+        out[i] = *d;
+    }
+    return out;
+}
+
+} // namespace
+
+CSGParams resolveLevelSet(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    CSGParams params;
+    params["field"] = getArg(args, 0, "field", Value{});
+    params["bounds"] = getArg(args, 1, "bounds", Value{});
+    params["isovalue"] = getArg(args, 2, "isovalue", Value{0.0});
+    params["invert"] = getArg(args, 3, "invert", Value{false});
+    params["edge"] = getArg(args, 4, "edge", Value{});
+    ev.evalChildren(node.children, effCtx);
+    return params;
+}
+
+std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params,
+                                           const std::vector<std::unique_ptr<CSGNode>>&,
+                                           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.
+    const Value& fieldArg = params.at("field");
+    const ClosurePtr* fieldFn = std::get_if<ClosurePtr>(&fieldArg);
+    std::optional<ScalarField> field;
+    if (!fieldFn) {
+        field = readField(fieldArg);
+        if (!field) {
+            ev.warn("levelset(): field must be a function(x,y,z) or a rectangular field[i][j][k] of numbers",
+                    &node.position());
+            return {};
+        }
+        if (field->nx < 2 || field->ny < 2 || field->nz < 2) {
+            ev.warn("levelset(): the field needs at least 2 samples along each axis", &node.position());
+            return {};
+        }
+    } else if (!*fieldFn || (*fieldFn)->node == nullptr || (*fieldFn)->node->parameters.size() < 3) {
+        ev.warn("levelset(): the field function needs three parameters, as in function(x,y,z) ...",
+                &node.position());
+        return {};
+    }
+
+    const ListPtr* bb = std::get_if<ListPtr>(&params.at("bounds"));
+    std::optional<std::array<double, 3>> lo, hi;
+    if (bb && *bb && (*bb)->items.size() == 2) {
+        lo = readVec3((*bb)->items[0]);
+        hi = readVec3((*bb)->items[1]);
+    }
+    if (!lo || !hi) {
+        ev.warn("levelset(): bounds must be [[x0,y0,z0],[x1,y1,z1]]", &node.position());
+        return {};
+    }
+    for (int a = 0; a < 3; ++a) {
+        if (!((*hi)[a] > (*lo)[a])) {
+            ev.warn("levelset(): bounds must be increasing along every axis", &node.position());
+            return {};
+        }
+    }
+
+    // Same rule as linear_solve's b: an explicitly-undef argument is ABSENT,
+    // so a fixed-signature wrapper forwarding every parameter still works.
+    const Value& isoVal = params.at("isovalue");
+    double isovalue = 0.0;
+    if (!std::holds_alternative<std::monostate>(isoVal)) {
+        const double* isoArg = std::get_if<double>(&isoVal);
+        if (!isoArg) {
+            ev.warn("levelset(): isovalue must be a number", &node.position());
+            return {};
+        }
+        isovalue = *isoArg;
+    }
+    const bool invert = truthy(params.at("invert"));
+
+    const std::array<double, 3> origin = *lo;
+    std::array<double, 3> spacing{1.0, 1.0, 1.0};
+    double edge = 0.0;
+    if (field) {
+        // Grid spacing is corner-sample to corner-sample, so n-1 intervals.
+        spacing = {((*hi)[0] - (*lo)[0]) / static_cast<double>(field->nx - 1),
+                    ((*hi)[1] - (*lo)[1]) / static_cast<double>(field->ny - 1),
+                    ((*hi)[2] - (*lo)[2]) / static_cast<double>(field->nz - 1)};
+        // Finer than the grid buys nothing -- there is no information between
+        // samples -- and coarser throws away what the script paid to compute.
+        edge = std::min({spacing[0], spacing[1], spacing[2]});
+    }
+    if (const double* e = std::get_if<double>(&params.at("edge"))) {
+        if (*e > 0.0) edge = *e;
+        else ev.warn("levelset(): edge must be positive", &node.position());
+    }
+    if (edge <= 0.0) {
+        // No grid to infer it from. Guessing would silently pick either a
+        // useless mesh or a ten-minute one -- the cost is cubic in this
+        // number, so it is the caller's call to make.
+        ev.warn("levelset(): a function field needs edge= (the sample spacing)", &node.position());
+        return {};
+    }
+
+    // The function form: one closure call per sample. No live EvalContext at
+    // generate time, so a root is built from the closure's own scope -- the
+    // same approach the warp experiment used. $-variables are therefore at
+    // their defaults inside a field function.
+    std::optional<EvalContext> fnCtx;
+    std::array<std::string, 3> fnParams;
+    if (fieldFn) {
+        fnCtx = EvalContext::makeRoot((*fieldFn)->node->scope());
+        for (int a = 0; a < 3; ++a) fnParams[static_cast<size_t>(a)] = (*fieldFn)->node->parameters[static_cast<size_t>(a)]->name->name;
+    }
+
+    const auto sampleFn = [&](manifold::vec3 p) -> double {
+        BoundArgs bound;
+        const double xyz[3] = {p.x, p.y, p.z};
+        for (int a = 0; a < 3; ++a) bound.set(fnParams[static_cast<size_t>(a)], Value{xyz[a]});
+        const Value out = ev.evalFunctionLiteralFromBound(**fieldFn, std::move(bound), *fnCtx, &node.position());
+        const double* d = std::get_if<double>(&out);
+        // A field that returns junk at one point must not abort the whole
+        // build; treat it as far outside instead.
+        const double v = (d && std::isfinite(*d)) ? *d : std::numeric_limits<double>::max();
+        const double diff = v - isovalue;
+        return invert ? diff : -diff;
+    };
+
+    // Never dereferenced on the function path, but it must still be a valid
+    // reference -- binding one to a null pointer is undefined behaviour even
+    // where the lambda is never called.
+    const ScalarField emptyField;
+    const ScalarField& f = field ? *field : emptyField;
+    const auto sampleGrid = [&f, origin, spacing, isovalue, invert](manifold::vec3 p) -> double {
+        double g[3];
+        size_t i0[3];
+        double t[3];
+        const double pos[3] = {p.x, p.y, p.z};
+        const size_t n[3] = {f.nx, f.ny, f.nz};
+        for (int a = 0; a < 3; ++a) {
+            g[a] = (pos[a] - origin[a]) / spacing[a];
+            if (g[a] < 0.0) g[a] = 0.0;
+            const double maxg = static_cast<double>(n[a] - 1);
+            if (g[a] > maxg) g[a] = maxg;
+            i0[a] = static_cast<size_t>(g[a]);
+            if (i0[a] > n[a] - 2) i0[a] = n[a] - 2;
+            t[a] = g[a] - static_cast<double>(i0[a]);
+        }
+        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),
+                          dk = static_cast<size_t>((c >> 2) & 1);
+            const double w = (di ? t[0] : 1.0 - t[0]) * (dj ? t[1] : 1.0 - t[1]) * (dk ? t[2] : 1.0 - t[2]);
+            acc += w * f.at(i0[0] + di, i0[1] + dj, i0[2] + dk);
+        }
+        // Manifold takes POSITIVE as inside. A distance field is the other
+        // way round, which is the common case, so the default flips it.
+        const double d = acc - isovalue;
+        return invert ? d : -d;
+    };
+
+    manifold::Box bounds(manifold::vec3(origin[0], origin[1], origin[2]),
+                          manifold::vec3((*hi)[0], (*hi)[1], (*hi)[2]));
+    // 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.
+    // canParallel true: the lambda is pure C++ and never re-enters the
+    // evaluator, which is the whole point of taking a grid.
+    // 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".
+    manifold::Manifold solid =
+        fieldFn ? manifold::Manifold::LevelSet(sampleFn, bounds, edge, 0.0, -1.0, /*canParallel=*/false)
+                 : manifold::Manifold::LevelSet(sampleGrid, bounds, edge, 0.0, -1.0, /*canParallel=*/true);
+
+    if (solid.IsEmpty()) return {};
+    ColoredBody b;
+    b.body = std::move(solid);
+    std::vector<ColoredBody> out;
+    out.push_back(std::move(b));
+    return out;
+}
+
 } // namespace oscadeval

{openscad_cpp_evaluator-0.49.0 → openscad_cpp_evaluator-0.50.1}/tests/test_booleans.cpp

@@ -793,3 +793,230 @@ TEST(Simplify, NoChildrenIsEmpty) {
     Evaluated e = evalSrc("simplify();");
     EXPECT_TRUE(e.bodies.empty());
 }
+
+// -- levelset -------------------------------------------------------------
+//
+// A solid from a grid of sampled values. Takes a grid rather than an SDF
+// callback: measured, building the field in script costs 0.41 us/sample
+// against 0.96 us for a closure call, and a grid lets Manifold mesh in
+// parallel because nothing re-enters the evaluator.
+//
+// Accuracy is bounded by the grid, not by Manifold -- it samples on a
+// body-centred cubic lattice and the lambda interpolates -- so every
+// tolerance here is a percentage, not an epsilon.
+
+namespace {
+
+// field[i][j][k] of the distance from the origin, over [-half, half]^3.
+std::string sphereFieldSrc(int n, double half) {
+    return "N = " + std::to_string(n) + "; H = " + std::to_string(half) +
+            ";\nfunction co(t) = -H + 2*H*t/(N-1);\n"
+            "f = [for (i=[0:N-1]) [for (j=[0:N-1]) [for (k=[0:N-1])\n"
+            "      sqrt(co(i)*co(i) + co(j)*co(j) + co(k)*co(k)) ]]];\n";
+}
+
+std::vector<std::string> levelsetWarnings(const std::string& code) {
+    std::vector<std::string> out;
+    evalSrc(code, [&](const std::string& m) {
+        if (m.rfind("WARNING", 0) == 0) out.push_back(m);
+    });
+    return out;
+}
+
+} // namespace
+
+TEST(LevelSet, ASphereFieldGivesASphere) {
+    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 * 20 * 20 * 20;
+    EXPECT_NEAR(soleBody(e).Volume(), analytic, 0.01 * analytic);  // within 1%
+    EXPECT_EQ(soleBody(e).Genus(), 0);
+}
+
+TEST(LevelSet, AccuracyImprovesWithGridResolution) {
+    // The grid is the accuracy limit, so more samples must mean less error.
+    // Anything else means the resolution argument is not doing its job.
+    const double analytic = 4.0 / 3.0 * 3.14159265358979 * 20 * 20 * 20;
+    double prevErr = 1e30;
+    for (int n : {25, 40, 60}) {
+        Evaluated e = evalSrc(sphereFieldSrc(n, 30) +
+                               "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=20);");
+        ASSERT_EQ(e.bodies.size(), 1u) << "n=" << n;
+        const double err = std::abs(soleBody(e).Volume() - analytic);
+        EXPECT_LT(err, prevErr) << "n=" << n << " was no better than the coarser grid";
+        prevErr = err;
+    }
+}
+
+TEST(LevelSet, ATorusFieldHasGenusOne) {
+    // The test that catches an implementation producing plausible-looking
+    // but topologically wrong output -- volume alone would not.
+    Evaluated e = evalSrc(
+        "N = 60; H = 30;\nfunction co(t) = -H + 2*H*t/(N-1);\n"
+        "f = [for (i=[0:N-1]) [for (j=[0:N-1]) [for (k=[0:N-1])\n"
+        "      let(q = sqrt(co(i)*co(i) + co(j)*co(j)) - 15)\n"
+        "      sqrt(q*q + co(k)*co(k)) ]]];\n"
+        "levelset(f, bounds=[[-H,-H,-H],[H,H,H]], isovalue=6);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_EQ(soleBody(e).Genus(), 1);
+}
+
+TEST(LevelSet, DisjointBlobsComeOutAsSeparateComponents) {
+    // Two spheres: Euler characteristic 4, so genus 1 - 4/2 = -1.
+    Evaluated e = evalSrc(
+        "N = 60; H = 30;\nfunction co(t) = -H + 2*H*t/(N-1);\n"
+        "f = [for (i=[0:N-1]) [for (j=[0:N-1]) [for (k=[0:N-1])\n"
+        "      min(sqrt((co(i)-12)*(co(i)-12) + co(j)*co(j) + co(k)*co(k)),\n"
+        "          sqrt((co(i)+12)*(co(i)+12) + co(j)*co(j) + co(k)*co(k))) ]]];\n"
+        "levelset(f, bounds=[[-H,-H,-H],[H,H,H]], isovalue=8);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_EQ(soleBody(e).Genus(), -1);
+}
+
+TEST(LevelSet, IndexOrderIsXThenYThenZ) {
+    // Deliberately asymmetric: a symmetric field passes even if the axes are
+    // transposed, which is the classic marching-cubes bug.
+    Evaluated e = evalSrc(
+        "N = 60; H = 30;\nfunction co(t) = -H + 2*H*t/(N-1);\n"
+        "f = [for (i=[0:N-1]) [for (j=[0:N-1]) [for (k=[0:N-1])\n"
+        "      max(abs(co(i))/5, abs(co(j))/10, abs(co(k))/20) ]]];\n"
+        "levelset(f, bounds=[[-H,-H,-H],[H,H,H]], isovalue=1);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const manifold::Box b = soleBody(e).BoundingBox();
+    EXPECT_NEAR(b.max.x, 5.0, 0.6);
+    EXPECT_NEAR(b.max.y, 10.0, 0.6);
+    EXPECT_NEAR(b.max.z, 20.0, 0.6);
+}
+
+TEST(LevelSet, IsovalueSelectsTheSurface) {
+    Evaluated small = evalSrc(sphereFieldSrc(40, 30) +
+                               "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=10);");
+    Evaluated big = evalSrc(sphereFieldSrc(40, 30) +
+                             "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=20);");
+    EXPECT_LT(soleBody(small).Volume(), soleBody(big).Volume());
+}
+
+TEST(LevelSet, BoundsPlaceTheResult) {
+    Evaluated e = evalSrc(sphereFieldSrc(40, 30) +
+                           "levelset(f, bounds=[[100,-30,-30],[160,30,30]], isovalue=20);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const manifold::Box b = soleBody(e).BoundingBox();
+    EXPECT_NEAR((b.min.x + b.max.x) / 2, 130.0, 1.0);
+}
+
+TEST(LevelSet, AnIsovalueNothingReachesIsEmpty) {
+    // A distance field is never negative, so nothing is inside. Not an
+    // error: asking is a fair question.
+    Evaluated e = evalSrc(sphereFieldSrc(20, 30) +
+                           "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=-1);");
+    EXPECT_TRUE(e.bodies.empty());
+}
+
+TEST(LevelSet, AnIsovalueEverythingSatisfiesFillsTheBounds) {
+    // The mirror case, and it is NOT empty: if every sample is inside, the
+    // solid is the whole box, clipped at the bounds. Worth pinning, because
+    // "nothing crossed the surface" and "everything is inside" look alike
+    // from the outside and mean opposite things.
+    Evaluated e = evalSrc(sphereFieldSrc(20, 30) +
+                           "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=1000);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const manifold::Box b = soleBody(e).BoundingBox();
+    EXPECT_NEAR(b.max.x - b.min.x, 60.0, 1.0);
+    EXPECT_NEAR(soleBody(e).Volume(), 60.0 * 60.0 * 60.0, 0.02 * 60.0 * 60.0 * 60.0);
+}
+
+TEST(LevelSet, MalformedFieldsWarn) {
+    for (const char* code : {
+             "levelset([[[1,2],[3,4]],[[5,6],[7]]], bounds=[[0,0,0],[1,1,1]]);",   // ragged
+             "levelset([[[1,2],[3,\"x\"]],[[5,6],[7,8]]], bounds=[[0,0,0],[1,1,1]]);", // not numeric
+             "levelset(5, bounds=[[0,0,0],[1,1,1]]);",                              // not a field
+             "levelset([[[1,2],[3,4]],[[5,6],[7,8]]], bounds=[[0,0,0],[0,1,1]]);",  // empty extent
+         }) {
+        EXPECT_FALSE(levelsetWarnings(code).empty()) << "silent on: " << code;
+    }
+}
+
+// -- levelset, function form ----------------------------------------------
+//
+// Same builtin, field given as function(x,y,z) instead of a grid. Slower --
+// a closure call per sample, and canParallel must be false because the
+// evaluator would otherwise be called back from Manifold's worker threads --
+// but MORE accurate, because Manifold picks its own sample points and can
+// snap toward the true surface instead of interpolating a fixed lattice.
+//
+// Measured at matched resolution, sphere against analytic:
+//    50^3   grid 0.23s (-0.244%)   function 0.32s (-0.103%)
+//   100^3   grid 1.06s (-0.059%)   function 1.91s (-0.025%)
+
+TEST(LevelSetFn, AFunctionFieldGivesTheSameSphere) {
+    Evaluated e = evalSrc(
+        "levelset(function(x,y,z) sqrt(x*x+y*y+z*z), "
+        "bounds=[[-30,-30,-30],[30,30,30]], isovalue=20, edge=1.5);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const double analytic = 4.0 / 3.0 * 3.14159265358979 * 20 * 20 * 20;
+    EXPECT_NEAR(soleBody(e).Volume(), analytic, 0.01 * analytic);
+    EXPECT_EQ(soleBody(e).Genus(), 0);
+}
+
+TEST(LevelSetFn, AgreesWithTheGridFormOnTheSameField) {
+    // The two intakes must describe the same solid; they differ only in how
+    // finely they can resolve it.
+    Evaluated grid = evalSrc(sphereFieldSrc(50, 30) +
+                              "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=20);");
+    Evaluated fn = evalSrc(
+        "levelset(function(x,y,z) sqrt(x*x+y*y+z*z), "
+        "bounds=[[-30,-30,-30],[30,30,30]], isovalue=20, edge=" +
+        std::to_string(60.0 / 49.0) + ");");
+    ASSERT_EQ(grid.bodies.size(), 1u);
+    ASSERT_EQ(fn.bodies.size(), 1u);
+    EXPECT_EQ(soleBody(fn).Genus(), soleBody(grid).Genus());
+    EXPECT_NEAR(soleBody(fn).Volume(), soleBody(grid).Volume(),
+                0.01 * soleBody(grid).Volume());
+}
+
+TEST(LevelSetFn, TopologyIsFoundFromAFunctionToo) {
+    Evaluated e = evalSrc(
+        "levelset(function(x,y,z) let(q = sqrt(x*x+y*y) - 15) sqrt(q*q + z*z), "
+        "bounds=[[-30,-30,-30],[30,30,30]], isovalue=6, edge=1.2);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_EQ(soleBody(e).Genus(), 1);
+}
+
+TEST(LevelSetFn, AFunctionFieldRequiresEdge) {
+    // There is no grid to infer spacing from, and the cost is CUBIC in it --
+    // guessing would silently produce either a useless mesh or a ten-minute
+    // one. Making the caller say is the safer failure.
+    const std::vector<std::string> w = levelsetWarnings(
+        "levelset(function(x,y,z) sqrt(x*x+y*y+z*z), bounds=[[-1,-1,-1],[1,1,1]]);");
+    ASSERT_EQ(w.size(), 1u);
+    EXPECT_NE(w[0].find("edge="), std::string::npos) << w[0];
+}
+
+TEST(LevelSetFn, AFunctionOfTheWrongArityWarns) {
+    const std::vector<std::string> w = levelsetWarnings(
+        "levelset(function(p) 1, bounds=[[-1,-1,-1],[1,1,1]], edge=0.5);");
+    ASSERT_EQ(w.size(), 1u);
+    EXPECT_NE(w[0].find("three parameters"), std::string::npos) << w[0];
+}
+
+TEST(LevelSetFn, AFieldFunctionCanCaptureOuterVariables) {
+    Evaluated e = evalSrc(
+        "r = 20;\nlevelset(function(x,y,z) sqrt(x*x+y*y+z*z), "
+        "bounds=[[-30,-30,-30],[30,30,30]], isovalue=r, edge=1.5);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(soleBody(e).Volume(), 4.0 / 3.0 * 3.14159265358979 * 8000, 400.0);
+}
+
+TEST(LevelSet, AnExplicitlyUndefIsovalueFallsBackToTheDefault) {
+    // Same rule as linear_solve's b, and for the same reason: a wrapper
+    // with a fixed signature forwards every parameter, undef included.
+    Evaluated withUndef = evalSrc(sphereFieldSrc(30, 30) +
+                                   "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=undef);");
+    Evaluated withZero = evalSrc(sphereFieldSrc(30, 30) +
+                                  "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=0);");
+    EXPECT_EQ(withUndef.bodies.size(), withZero.bodies.size());
+    EXPECT_TRUE(levelsetWarnings(sphereFieldSrc(30, 30) +
+                                  "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=undef);")
+                    .empty());
+}

{openscad_cpp_evaluator-0.49.0 → openscad_cpp_evaluator-0.50.1}/tests/test_feature_detection.cpp

@@ -35,7 +35,7 @@ std::vector<std::string> echoesFrom(const std::string& src) {
 // in featureLevels() -- shows up as a 0.
 const char* kFeatures[] = {"separate-children", "minkowski-diff", "sphere-styles",   "export-name",
                             "simplify-op",       "expr-import",    "object-function", "roof-op",
-                            "render-expr",       "polyhedron-vnf", "linear-solve"};
+                            "render-expr",       "polyhedron-vnf", "linear-solve", "levelset"};
 
 } // namespace
 

{openscad_cpp_evaluator-0.49.0 → openscad_cpp_evaluator-0.50.1}/tests/test_function_builtins.cpp

@@ -883,3 +883,17 @@ TEST(LinearSolve, WorksUnderBothEngines) {
     }
 }
 
+
+TEST(LinearSolve, AnExplicitlyUndefRightHandSideCountsAsAbsent) {
+    // BOSL2's builtins.scad pattern is a wrapper with a fixed signature:
+    //   function _linear_solve(A, b) = linear_solve(A, b);
+    // so a determinant()-style caller that passes no right-hand side still
+    // forwards b as undef. Treating that as a BAD argument would warn on
+    // every such call. Passing undef is idiomatically the same as not
+    // passing in OpenSCAD -- BOSL2 threads optional arguments through
+    // wrappers that way throughout.
+    Evaluator ev;
+    EXPECT_NEAR(asNum(evalSrc("linear_solve([[2,1],[1,3]], undef).det", ev)), 5.0, 1e-12);
+    EXPECT_TRUE(isUndef(evalSrc("linear_solve([[2,1],[1,3]], undef).x", ev)));
+    EXPECT_TRUE(builtinWarnings("linear_solve([[2,1],[1,3]], undef)").empty());
+}