openscad-cpp-evaluator 1.45.3__tar.gz → 1.46.0__tar.gz

{openscad_cpp_evaluator-1.45.3 → openscad_cpp_evaluator-1.46.0}/CLAUDE.md

@@ -601,6 +601,11 @@ grep for `ponytail:`.
   One `LevelSet` pass either way; a bounded range *could* be
   `difference(levelset(hi), levelset(lo))` but that meshes twice and then booleans.
   3D wraps `Manifold::LevelSet` with a C++ sampling lambda; no new Manifold API.
+  **`edge` may be a vector**, one spacing per axis (`[ex,ey,ez]`, or `[ex,ey]` in 2D), as BOSL2's
+  `isosurface()` takes `voxel_size`. `LevelSet` takes one edge length, so the 3D path meshes the
+  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.
   **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.45.3 → openscad_cpp_evaluator-1.46.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.45.3 → openscad_cpp_evaluator-1.46.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.45.3 → openscad_cpp_evaluator-1.46.0}/src/builtins/function_builtins.cpp

@@ -976,9 +976,8 @@ namespace {
 // is supposed to be safe).
 //
 // A LEVEL rather than a boolean so a feature whose semantics change later
-// can be told apart from its earlier self. Everything here is 1 today;
-// nothing has changed since this function existed, and a script cannot
-// observe what a build without supported_feature() did anyway.
+// can be told apart from its earlier self. A script cannot observe what a
+// build without supported_feature() did, so every feature starts at 1.
 //
 // This is the answer to a real hazard: OpenSCAD does not reject arguments or
 // names it doesn't know -- children(separate=true) is silently ignored there
@@ -988,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", 1.0},           // levelset(field, bounds, isovalue)
+        {"levelset", 2.0},           // levelset(field, bounds, isovalue); 2: edge may be a vector
         {"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.45.3 → openscad_cpp_evaluator-1.46.0}/src/builtins/topology.cpp

@@ -991,11 +991,31 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
     const std::array<double, 3> origin = *lo;
     std::array<double, 3> spacing{1.0, 1.0, 1.0};
     double edge = 0.0;
+    // edge may also be one spacing per axis, as BOSL2's isosurface() takes
+    // voxel_size -- a thin plate wants fine sampling across it and coarse
+    // along it (#729 on BelfrySCAD). edgeV is then the vector and `edge`
+    // its smallest component; for a plain number edgeV is unused.
+    std::array<double, 3> edgeV{0.0, 0.0, 0.0};
+    bool edgeVec = false;
     // Grid spacing is filled in below, once the array has been read at the
     // right dimensionality. Finer than the grid buys nothing.
-    if (const double* e = std::get_if<double>(&params.at("edge"))) {
+    const Value& edgeArg = params.at("edge");
+    if (const double* e = std::get_if<double>(&edgeArg)) {
         if (*e > 0.0) edge = *e;
         else ev.warn("levelset(): edge must be positive", &node.position());
+    } else if (!std::holds_alternative<std::monostate>(edgeArg)) {
+        const std::optional<std::vector<double>> ev3 = numbersOrInf(edgeArg);
+        bool ok = ev3 && ev3->size() == bLo->size();
+        for (size_t a = 0; ok && a < ev3->size(); ++a) ok = std::isfinite((*ev3)[a]) && (*ev3)[a] > 0.0;
+        if (ok) {
+            edgeVec = true;
+            for (size_t a = 0; a < ev3->size(); ++a) edgeV[a] = (*ev3)[a];
+            edge = *std::min_element(ev3->begin(), ev3->end());
+        } else {
+            ev.warn(is2d ? "levelset(): edge must be a positive number or [ex, ey]"
+                         : "levelset(): edge must be a positive number or [ex, ey, ez]",
+                    &node.position());
+        }
     }
     if (edge <= 0.0 && fieldFn) {
         // No grid to infer it from. Guessing would silently pick either a
@@ -1060,8 +1080,9 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
             return out;
         }
         // function(x,y): edge= gives the spacing, as in 3D
-        nx = static_cast<size_t>(std::floor(((*bHi)[0] - (*bLo)[0]) / edge)) + 1;
-        ny = static_cast<size_t>(std::floor(((*bHi)[1] - (*bLo)[1]) / edge)) + 1;
+        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;
         if (nx < 2 || ny < 2) {
             ev.warn("levelset(): edge is larger than the bounds", &node.position());
             return {};
@@ -1114,7 +1135,9 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
         spacing = {((*bHi)[0] - (*bLo)[0]) / static_cast<double>(field->nx - 1),
                     ((*bHi)[1] - (*bLo)[1]) / static_cast<double>(field->ny - 1),
                     ((*bHi)[2] - (*bLo)[2]) / static_cast<double>(field->nz - 1)};
-        if (!std::get_if<double>(&params.at("edge"))) edge = std::min({spacing[0], spacing[1], spacing[2]});
+        // Also when edge= was given but unusable (warned above): edge 0
+        // would ask Manifold for an infinitely fine lattice.
+        if (edge <= 0.0) edge = std::min({spacing[0], spacing[1], spacing[2]});
     }
 
     if (fieldFn && fnParams2.size() < 3) {
@@ -1187,9 +1210,10 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
     //
     // 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));
+    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 -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.
@@ -1199,9 +1223,24 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
     // 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);
+    //
+    // 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.
+    // Exact, not an approximation: with tolerance -1 a vertex is a linear
+    // interpolation along a lattice edge, and a linear interpolation commutes
+    // with an axis scale.
+    manifold::Manifold solid;
+    if (!edgeVec) {
+        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);
+    } else {
+        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, -1.0, /*canParallel=*/false)
+                        : manifold::Manifold::LevelSet([&](manifold::vec3 q) { return sampleGrid(q * E); },
+                                                       unit, 1.0, 0.0, -1.0, /*canParallel=*/true);
+        solid = solid.Scale(E);
+    }
 
     if (solid.IsEmpty()) return {};
     solid = solid ^ manifold::Manifold::Cube(

{openscad_cpp_evaluator-1.45.3 → openscad_cpp_evaluator-1.46.0}/tests/test_booleans.cpp

@@ -1248,6 +1248,83 @@ TEST(LevelSetFn, AFunctionFieldRequiresEdge) {
     EXPECT_NE(w[0].find("edge="), std::string::npos) << w[0];
 }
 
+// edge= as one spacing per axis (#729 on BelfrySCAD), as BOSL2's
+// isosurface() takes voxel_size. LevelSet itself takes one edge length, so
+// the field is squashed to unit spacing and the mesh stretched back.
+
+TEST(LevelSetFn, AnEqualVectorEdgeMatchesTheNumber) {
+    const std::string f = "levelset(function(x,y,z) sqrt(x*x+y*y+z*z), "
+                          "bounds=[[-30,-30,-30],[30,30,30]], isovalue=20, edge=";
+    Evaluated num = evalSrc(f + "1.5);");
+    Evaluated vec = evalSrc(f + "[1.5,1.5,1.5]);");
+    ASSERT_EQ(num.bodies.size(), 1u);
+    ASSERT_EQ(vec.bodies.size(), 1u);
+    EXPECT_EQ(soleBody(vec).NumTri(), soleBody(num).NumTri());
+    EXPECT_NEAR(soleBody(vec).Volume(), soleBody(num).Volume(), 1e-9 * soleBody(num).Volume());
+}
+
+TEST(LevelSetFn, AVectorEdgeIsExactlyAStretchedLattice) {
+    // A sphere stretched 4x in z, sampled 4x coarser in z, is the sphere's
+    // own mesh stretched: a vertex is a linear interpolation along a lattice
+    // edge, and that commutes with an axis scale. So the volume is exactly
+    // 4x, not merely close -- anything else means the lattice is not the
+    // one asked for.
+    Evaluated sphere = 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);");
+    Evaluated tall = evalSrc(
+        "levelset(function(x,y,z) sqrt(x*x+y*y+z*z/16), "
+        "bounds=[[-30,-30,-120],[30,30,120]], isovalue=20, edge=[1.5,1.5,6]);");
+    ASSERT_EQ(sphere.bodies.size(), 1u);
+    ASSERT_EQ(tall.bodies.size(), 1u);
+    EXPECT_EQ(soleBody(tall).NumTri(), soleBody(sphere).NumTri());
+    EXPECT_NEAR(soleBody(tall).Volume(), 4.0 * soleBody(sphere).Volume(), 1e-6 * soleBody(tall).Volume());
+    EXPECT_EQ(soleBody(tall).Genus(), 0);
+}
+
+TEST(LevelSetFn, AVectorEdgeAlsoAppliesToAGrid) {
+    Evaluated fine = evalSrc(sphereFieldSrc(50, 30) +
+                              "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=20);");
+    Evaluated coarseZ = evalSrc(sphereFieldSrc(50, 30) +
+                                 "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=20, edge=[1.2,1.2,4]);");
+    ASSERT_EQ(coarseZ.bodies.size(), 1u);
+    EXPECT_LT(soleBody(coarseZ).NumTri(), soleBody(fine).NumTri() * 3 / 4);  // measured 56%
+    EXPECT_NEAR(soleBody(coarseZ).Volume(), soleBody(fine).Volume(), 0.03 * soleBody(fine).Volume());
+}
+
+TEST(LevelSetFn, AVectorEdgeIn2DSetsEachAxis) {
+    // A circle sampled finely in x and coarsely in y has fewer contour
+    // points than one sampled finely in both, and still the circle's area.
+    const std::string f = "levelset(function(x,y) sqrt(x*x+y*y), "
+                          "bounds=[[-30,-30],[30,30]], isovalue=20, edge=";
+    Evaluated fine = evalSrc(f + "0.5);");
+    Evaluated mixed = evalSrc(f + "[0.5,3]);");
+    ASSERT_EQ(mixed.bodies.size(), 1u);
+    ASSERT_TRUE(mixed.bodies[0].section);
+    EXPECT_LT(mixed.bodies[0].section->NumVert(), fine.bodies[0].section->NumVert());
+    const double circle = 3.14159265358979 * 400;
+    EXPECT_NEAR(mixed.bodies[0].section->Area(), circle, 0.02 * circle);
+}
+
+TEST(LevelSetFn, AVectorEdgeOfTheWrongSizeWarns) {
+    for (const char* bad : {"[1,1]", "[1,1,0]", "[1,1,-2]", "[1,\"a\",1]"}) {
+        const std::vector<std::string> w = levelsetWarnings(
+            std::string("levelset(function(x,y,z) sqrt(x*x+y*y+z*z), "
+                        "bounds=[[-3,-3,-3],[3,3,3]], isovalue=2, edge=") + bad + ");");
+        ASSERT_GE(w.size(), 1u) << bad;
+        EXPECT_NE(w[0].find("[ex, ey, ez]"), std::string::npos) << bad << ": " << w[0];
+    }
+}
+
+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.
+    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];
+}
+
 TEST(LevelSetFn, AFunctionOfTheWrongArityWarns) {
     // One parameter is wrong for either dimension, so the message names both.
     const std::vector<std::string> one = levelsetWarnings(

{openscad_cpp_evaluator-1.45.3 → openscad_cpp_evaluator-1.46.0}/tests/test_feature_detection.cpp

@@ -68,10 +68,10 @@ TEST(FeatureDetection, EveryDocumentedFeatureReportsALevel) {
         ScopedVm guard(vm);
         for (const char* f : kFeatures) {
             const std::vector<std::string> e =
-                echoesFrom(std::string("echo(supported_feature(\"") + f + "\"));");
+                echoesFrom(std::string("echo(supported_feature(\"") + f + "\") >= 1);");
             ASSERT_EQ(e.size(), 1u) << f << ", vm=" << vm;
-            EXPECT_NE(e[0].find("1"), std::string::npos) << f << ", vm=" << vm << ", got " << e[0];
-            EXPECT_EQ(e[0].find("0"), std::string::npos) << f << " reported unsupported, vm=" << vm;
+            EXPECT_NE(e[0].find("true"), std::string::npos) << f << " reported unsupported, vm=" << vm
+                                                           << ", got " << e[0];
         }
     }
 }

{openscad_cpp_evaluator-1.45.3 → openscad_cpp_evaluator-1.46.0}/uv.lock

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