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

{openscad_cpp_evaluator-1.47.0 → openscad_cpp_evaluator-1.48.0}/CLAUDE.md

@@ -606,6 +606,12 @@ grep for `ponytail:`.
   field squashed to unit spacing and `Scale`s the result back -- exact, since with tolerance -1 a
   vertex is a linear interpolation along a lattice edge, which commutes with an axis scale. A plain
   number takes the old path unchanged. `supported_feature("levelset")` is **2** from this change.
+  **A field array needs `bounds` OR `edge`**: given only `edge` (number or vector), the samples sit
+  `edge` apart **centred on the origin**, as BOSL2's `isosurface()` places an array given
+  `voxel_size`, and the array's depth (`field[i][j]` vs `field[i][j][k]`) decides 2D or 3D
+  (`boundsFromEdge`, #749 on BelfrySCAD). Both given: `edge` re-samples the field inside `bounds`
+  (trilinear in 3D, bilinear in 2D -- 2D used to ignore `edge` here) unless it equals the grid's own spacing. A function field still needs `bounds`.
+  `supported_feature("levelset")` is **3** from this change.
   **The field is a grid OR a `function(x,y,z)`, and the two trade off against each other** —
   neither is simply better:
 

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

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

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

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

{openscad_cpp_evaluator-1.47.0 → openscad_cpp_evaluator-1.48.0}/src/builtins/function_builtins.cpp

@@ -987,7 +987,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", 2.0},           // levelset(field, bounds, isovalue); 2: edge may be a vector
+        {"levelset", 3.0},           // levelset(field, bounds, isovalue); 2: edge may be a vector; 3: edge alone places a field array
         {"polyhedron-vnf", 1.0},     // polyhedron(vnf) / polyhedron(object)
         {"separate-children", 1.0},  // children(..., separate=true)
         {"minkowski-diff", 1.0},     // minkowski_difference()

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

@@ -7,6 +7,7 @@
 #include <manifold/polygon.h>
 
 #include <algorithm>
+#include <utility>
 
 namespace oscadeval {
 
@@ -689,6 +690,44 @@ std::optional<double> fieldSample(const Value& item) {
     return std::clamp(*d, -kHuge, kHuge);
 }
 
+// bounds for a field ARRAY given edge= and no bounds (#749 on BelfrySCAD):
+// the samples edge apart, centred on the origin, as BOSL2's isosurface()
+// places an array given voxel_size. The array's depth (field[i][j] or
+// field[i][j][k]) says 2D or 3D; the sizes come from its first row, and
+// readField/readPlane check the rest later. nullopt when edge is missing
+// or does not fit, leaving the caller's "bounds must be ..." warning.
+std::optional<std::pair<std::vector<double>, std::vector<double>>>
+boundsFromEdge(const Value& field, const Value& edge) {
+    std::vector<size_t> dims;
+    for (const Value* cur = &field; dims.size() < 3;) {
+        const ListPtr* l = std::get_if<ListPtr>(cur);
+        if (!l || !*l || (*l)->items.empty()) break;
+        dims.push_back((*l)->items.size());
+        cur = &(*l)->items[0];
+    }
+    if (dims.size() < 2) return std::nullopt;
+    std::vector<double> step;
+    if (const double* e = std::get_if<double>(&edge)) {
+        step.assign(dims.size(), *e);
+    } else if (const ListPtr* l = std::get_if<ListPtr>(&edge); l && *l && (*l)->items.size() == dims.size()) {
+        for (const Value& item : (*l)->items) {
+            const double* d = std::get_if<double>(&item);
+            if (!d) return std::nullopt;
+            step.push_back(*d);
+        }
+    } else {
+        return std::nullopt;
+    }
+    std::vector<double> lo, hi;
+    for (size_t a = 0; a < dims.size(); ++a) {
+        if (!std::isfinite(step[a]) || step[a] <= 0.0 || dims[a] < 2) return std::nullopt;
+        const double half = 0.5 * step[a] * static_cast<double>(dims[a] - 1);
+        lo.push_back(-half);
+        hi.push_back(half);
+    }
+    return std::make_pair(lo, hi);
+}
+
 struct ScalarField {
     std::vector<double> v;      // flat, x fastest
     size_t nx = 0, ny = 0, nz = 0;
@@ -1108,12 +1147,20 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
     // matches how the caller already has to think about the box.
     const ListPtr* bb = std::get_if<ListPtr>(&params.at("bounds"));
     std::optional<std::vector<double>> bLo, bHi;
+    const bool noBounds = std::holds_alternative<std::monostate>(params.at("bounds"));
     if (bb && *bb && (*bb)->items.size() == 2) {
         bLo = numbersOrInf((*bb)->items[0]);
         bHi = numbersOrInf((*bb)->items[1]);
+    } else if (noBounds && !fieldFn) {
+        if (const auto inferred = boundsFromEdge(fieldArg, params.at("edge"))) {
+            bLo = inferred->first;
+            bHi = inferred->second;
+        }
     }
     if (!bLo || !bHi || bLo->size() != bHi->size() || (bLo->size() != 2 && bLo->size() != 3)) {
-        ev.warn("levelset(): bounds must be [[x0,y0],[x1,y1]] or [[x0,y0,z0],[x1,y1,z1]]",
+        ev.warn(noBounds && !fieldFn
+                    ? "levelset(): a field array needs bounds=, or edge= (its sample spacing) to place it"
+                    : "levelset(): bounds must be [[x0,y0],[x1,y1]] or [[x0,y0,z0],[x1,y1,z1]]",
                 &node.position());
         return {};
     }
@@ -1211,74 +1258,82 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
 
     // ---- 2D: sample onto a padded grid, contour it, hand to CrossSection.
     if (is2d) {
-        size_t nx = 0, ny = 0;
-        double sx = 0, sy = 0;
         if (field) {
             ev.warn("levelset(): a 2D field must be field[i][j]; a 3D array was given",
                     &node.position());
             return {};
         }
+        const double x0 = (*bLo)[0], y0 = (*bLo)[1];
+        const double wx = (*bHi)[0] - x0, wy = (*bHi)[1] - y0;
+        double ex = edgeVec ? edgeV[0] : edge, ey = edgeVec ? edgeV[1] : edge;
+        std::optional<std::vector<std::vector<double>>> plane;
+        size_t px = 0, py = 0;
+        bool ownSamples = false;
         if (!fieldFn) {
-            const std::optional<std::vector<std::vector<double>>> plane = readPlane(fieldArg);
+            plane = readPlane(fieldArg);
             if (!plane || plane->size() < 2 || (*plane)[0].size() < 2) {
                 ev.warn("levelset(): 2D field must be a rectangular field[i][j] of numbers",
                         &node.position());
                 return {};
             }
-            nx = plane->size();
-            ny = (*plane)[0].size();
-            sx = ((*bHi)[0] - (*bLo)[0]) / static_cast<double>(nx - 1);
-            sy = ((*bHi)[1] - (*bLo)[1]) / static_cast<double>(ny - 1);
-            Contours2d g;
-            g.nx = nx + 2;
-            g.ny = ny + 2;
-            g.dx = sx;
-            g.dy = sy;
-            g.ox = (*bLo)[0] - sx;
-            g.oy = (*bLo)[1] - sy;
-            // Padded with a ring that is firmly OUTSIDE, so a contour meeting
-            // the box edge closes along it instead of running off. This is
-            // BOSL2's closed=true, and the only behaviour offered.
-            g.v.assign(g.nx * g.ny, -1.0);
-            for (size_t i = 0; i < nx; ++i)
-                for (size_t j = 0; j < ny; ++j)
-                    g.v[(j + 1) * g.nx + (i + 1)] = bandDistance((*plane)[i][j], isoLo, isoHi, invert);
-            const manifold::Polygons polys = marchingSquares(g);
-            if (polys.empty()) return {};
-            ColoredBody b;
-            b.section = clipToBounds(manifold::CrossSection(polys, manifold::CrossSection::FillRule::EvenOdd),
-                                      *bLo, *bHi);
-            if (b.section->IsEmpty()) return {};
-            std::vector<ColoredBody> out;
-            out.push_back(std::move(b));
-            return out;
+            px = plane->size();
+            py = (*plane)[0].size();
+            // Contoured on its own samples unless edge= asks for another
+            // spacing, as the 3D grid is marched; then re-sampled bilinearly.
+            const double gx = wx / static_cast<double>(px - 1), gy = wy / static_cast<double>(py - 1);
+            const auto same = [](double a, double b) { return std::abs(a - b) <= 1e-9 * std::max(a, b); };
+            ownSamples = ex <= 0.0 || (same(ex, gx) && same(ey, gy));
         }
-        // function(x,y): edge= gives the spacing, as in 3D
-        const double ex = edgeVec ? edgeV[0] : edge, ey = edgeVec ? edgeV[1] : edge;
-        nx = static_cast<size_t>(std::floor(((*bHi)[0] - (*bLo)[0]) / ex)) + 1;
-        ny = static_cast<size_t>(std::floor(((*bHi)[1] - (*bLo)[1]) / ey)) + 1;
+        // Counted from the array, not floor(width / spacing): rounding there
+        // could drop the last sample row.
+        const size_t nx = ownSamples ? px : static_cast<size_t>(std::floor(wx / ex)) + 1;
+        const size_t ny = ownSamples ? py : static_cast<size_t>(std::floor(wy / ey)) + 1;
         if (nx < 2 || ny < 2) {
             ev.warn("levelset(): edge is larger than the bounds", &node.position());
             return {};
         }
-        sx = ((*bHi)[0] - (*bLo)[0]) / static_cast<double>(nx - 1);
-        sy = ((*bHi)[1] - (*bLo)[1]) / static_cast<double>(ny - 1);
+        const double sx = wx / static_cast<double>(nx - 1), sy = wy / static_cast<double>(ny - 1);
+        // The plane at a point between its samples. Clamped at the edges,
+        // like the 3D grid sampler, so the clip below cuts a clean line.
+        const auto bilinear = [&](double x, double y) {
+            const auto cell = [](double u, size_t n, size_t& i0) {
+                i0 = static_cast<size_t>(std::clamp(std::floor(u), 0.0, static_cast<double>(n - 2)));
+                return std::clamp(u - static_cast<double>(i0), 0.0, 1.0);
+            };
+            size_t i, j;
+            const double tx = cell((x - x0) / wx * static_cast<double>(px - 1), px, i);
+            const double ty = cell((y - y0) / wy * static_cast<double>(py - 1), py, j);
+            const auto& p = *plane;
+            return (1 - tx) * ((1 - ty) * p[i][j] + ty * p[i][j + 1])
+                 + tx * ((1 - ty) * p[i + 1][j] + ty * p[i + 1][j + 1]);
+        };
         Contours2d g;
         g.nx = nx + 2;
         g.ny = ny + 2;
         g.dx = sx;
         g.dy = sy;
-        g.ox = (*bLo)[0] - sx;
-        g.oy = (*bLo)[1] - sy;
+        g.ox = x0 - sx;
+        g.oy = y0 - sy;
+        // Padded with a ring that is firmly OUTSIDE, so a contour meeting
+        // the box edge closes along it instead of running off. This is
+        // BOSL2's closed=true, and the only behaviour offered.
         g.v.assign(g.nx * g.ny, -1.0);
         for (size_t i = 0; i < nx; ++i) {
             for (size_t j = 0; j < ny; ++j) {
-                BoundArgs bound;
-                bound.set(fnParams2[0], Value{(*bLo)[0] + static_cast<double>(i) * sx});
-                bound.set(fnParams2[1], Value{(*bLo)[1] + static_cast<double>(j) * sy});
-                const Value outv =
-                    ev.evalFunctionLiteralFromBound(**fieldFn, std::move(bound), *fnCtx, &node.position());
-                const double val = fieldSample(outv).value_or(std::numeric_limits<double>::max());
+                const double x = x0 + static_cast<double>(i) * sx, y = y0 + static_cast<double>(j) * sy;
+                double val;
+                if (ownSamples) {
+                    val = (*plane)[i][j];
+                } else if (plane) {
+                    val = bilinear(x, y);
+                } else {
+                    BoundArgs bound;
+                    bound.set(fnParams2[0], Value{x});
+                    bound.set(fnParams2[1], Value{y});
+                    const Value outv =
+                        ev.evalFunctionLiteralFromBound(**fieldFn, std::move(bound), *fnCtx, &node.position());
+                    val = fieldSample(outv).value_or(std::numeric_limits<double>::max());
+                }
                 g.v[(j + 1) * g.nx + (i + 1)] = bandDistance(val, isoLo, isoHi, invert);
             }
         }

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

@@ -1374,11 +1374,12 @@ TEST(LevelSetFn, AVectorEdgeOfTheWrongSizeWarns) {
 
 TEST(LevelSetFn, SupportedFeatureSaysAVectorEdgeWorks) {
     // Level 2 is how a library such as BOSL2 tells a build with per-axis
-    // edge= from one that would reject it.
+    // edge= from one that would reject it; level 3, one that places a
+    // field array from edge= alone (#749 on BelfrySCAD).
     std::vector<std::string> out;
     evalSrc("echo(supported_feature(\"levelset\"));", [&](const std::string& m) { out.push_back(m); });
     ASSERT_EQ(out.size(), 1u);
-    EXPECT_NE(out[0].find("2"), std::string::npos) << out[0];
+    EXPECT_NE(out[0].find("3"), std::string::npos) << out[0];
 }
 
 TEST(LevelSetFn, AFunctionOfTheWrongArityWarns) {
@@ -1674,6 +1675,73 @@ TEST(LevelSetGrid, TheDefaultMarchesTheGridItself) {
     EXPECT_EQ(soleBody(same).NumTri(), soleBody(e).NumTri());
 }
 
+TEST(LevelSetGrid, EdgeWithoutBoundsCentresTheGridOnTheOrigin) {
+    // #749 on BelfrySCAD: edge= alone places a field array, its samples
+    // edge apart and centred on the origin, as BOSL2's isosurface() places
+    // an array given voxel_size. Same mesh as the explicit bounds.
+    Evaluated e = evalSrc(sphereFieldSrc(41, 20) + "levelset(f, isovalue=15, edge=1);");
+    Evaluated ref = evalSrc(sphereFieldSrc(41, 20) +
+                             "levelset(f, bounds=[[-20,-20,-20],[20,20,20]], isovalue=15);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_EQ(ref.bodies.size(), 1u);
+    EXPECT_EQ(soleBody(e).NumTri(), soleBody(ref).NumTri());
+    EXPECT_NEAR(soleBody(e).Volume(), soleBody(ref).Volume(), 1e-9 * soleBody(ref).Volume());
+    EXPECT_GT(onGridLines(soleBody(e), manifold::vec3(-20.0), manifold::vec3(1.0)), 0.5);
+}
+
+TEST(LevelSetGrid, AVectorEdgeWithoutBoundsSpacesEachAxis) {
+    // Every sample inside, so the solid is the whole box: 5 x 3 x 4 samples
+    // at [1, 2, 0.5] span 4 x 4 x 1.5, centred.
+    Evaluated e = evalSrc("f = [for (i=[0:4]) [for (j=[0:2]) [for (k=[0:3]) -1 ]]];\n"
+                           "levelset(f, edge=[1, 2, 0.5]);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const manifold::Box b = soleBody(e).BoundingBox();
+    EXPECT_NEAR(b.min.x, -2.0, 1e-9); EXPECT_NEAR(b.max.x, 2.0, 1e-9);
+    EXPECT_NEAR(b.min.y, -2.0, 1e-9); EXPECT_NEAR(b.max.y, 2.0, 1e-9);
+    EXPECT_NEAR(b.min.z, -0.75, 1e-9); EXPECT_NEAR(b.max.z, 0.75, 1e-9);
+}
+
+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);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].section.has_value());
+    const manifold::Rect r = e.bodies[0].section->Bounds();
+    EXPECT_NEAR(r.min.x, -4.0, 1e-9); EXPECT_NEAR(r.max.x, 4.0, 1e-9);
+    EXPECT_NEAR(r.min.y, -2.0, 1e-9); EXPECT_NEAR(r.max.y, 2.0, 1e-9);
+}
+
+TEST(LevelSetGrid, A2DGridIsResampledAtADifferentEdge) {
+    // As in 3D: edge= beside bounds re-samples the plane (bilinearly), where
+    // it used to be ignored. A cone sampled every 2, contoured at r=7.
+    const std::string field =
+        "f = [for (i=[0:10]) [for (j=[0:10]) let(x=-10+2*i, y=-10+2*j) sqrt(x*x+y*y) ]];\n";
+    const std::string box = "bounds=[[-10,-10],[10,10]], isovalue=7";
+    Evaluated own = evalSrc(field + "levelset(f, " + box + ");");
+    Evaluated same = evalSrc(field + "levelset(f, " + box + ", edge=2);");
+    Evaluated fine = evalSrc(field + "levelset(f, " + box + ", edge=0.25);");
+    for (Evaluated* e : {&own, &same, &fine}) {
+        ASSERT_EQ(e->bodies.size(), 1u);
+        ASSERT_TRUE(e->bodies[0].section.has_value());
+    }
+    EXPECT_EQ(same.bodies[0].section->NumVert(), own.bodies[0].section->NumVert());
+    EXPECT_GT(fine.bodies[0].section->NumVert(), 4 * own.bodies[0].section->NumVert());
+    const double disc = 3.14159265358979 * 49;
+    EXPECT_NEAR(fine.bodies[0].section->Area(), disc, 0.03 * disc);
+}
+
+TEST(LevelSetGrid, NeitherBoundsNorEdgeSaysWhatIsMissing) {
+    const std::vector<std::string> w =
+        levelsetWarnings("f = [for (i=[0:4]) [for (j=[0:2]) [for (k=[0:3]) -1 ]]];\nlevelset(f);");
+    ASSERT_EQ(w.size(), 1u);
+    EXPECT_NE(w[0].find("bounds=, or edge="), std::string::npos) << w[0];
+    // A function field has no sizes to infer from: bounds stays required.
+    const std::vector<std::string> fw =
+        levelsetWarnings("levelset(function(x,y,z) x, edge=1);");
+    ASSERT_EQ(fw.size(), 1u);
+    EXPECT_NE(fw[0].find("bounds must be"), std::string::npos) << fw[0];
+}
+
 TEST(LevelSetGrid, ADifferentEdgeStillResamples) {
     Evaluated e = evalSrc(sphereFieldSrc(41, 20) +
                            "levelset(f, bounds=[[-20,-20,-20],[20,20,20]], isovalue=15, edge=0.7);");

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

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