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

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

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

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

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

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

@@ -6,6 +6,8 @@
 
 #include <manifold/polygon.h>
 
+#include <algorithm>
+
 namespace oscadeval {
 
 // simplify()'s default tolerance, as a fraction of the body's bounding-box
@@ -663,14 +665,30 @@ std::vector<ColoredBody> generateMeshRepair(Evaluator& ev, const CSGParams& para
 // 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.
+// 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.
 
 namespace {
 
+// A sample as the field arrays and field functions hand it over. +-INF is a
+// legal sample -- a metaball field is 1/0 wherever a grid point lands on a
+// centre (#744 on BelfrySCAD) -- but it cannot be used as is: the trilinear
+// sampler weights corners, and 0 * INF is NaN. So it becomes a huge FINITE
+// value, which is the limit BOSL2's isosurface() takes (an edge to an INF
+// corner crosses at the other end). A quarter of DBL_MAX so that sums of
+// weighted corners and bandDistance's subtraction cannot overflow. NaN, or
+// anything not a number, has no meaning and is nullopt.
+std::optional<double> fieldSample(const Value& item) {
+    const double* d = std::get_if<double>(&item);
+    if (!d || std::isnan(*d)) return std::nullopt;
+    constexpr double kHuge = std::numeric_limits<double>::max() / 4;
+    return std::clamp(*d, -kHuge, kHuge);
+}
+
 struct ScalarField {
     std::vector<double> v;      // flat, x fastest
     size_t nx = 0, ny = 0, nz = 0;
@@ -698,8 +716,8 @@ std::optional<ScalarField> readField(const Value& val) {
                 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;
+                const std::optional<double> d = fieldSample((*zs)->items[k]);
+                if (!d) return std::nullopt;
                 f.v[(k * f.ny + j) * f.nx + i] = *d;
             }
         }
@@ -722,8 +740,8 @@ std::optional<std::vector<std::vector<double>>> readPlane(const Value& val) {
         std::vector<double> row;
         row.reserve(ny);
         for (const Value& item : (*ys)->items) {
-            const double* d = std::get_if<double>(&item);
-            if (!d || !std::isfinite(*d)) return std::nullopt;
+            const std::optional<double> d = fieldSample(item);
+            if (!d) return std::nullopt;
             row.push_back(*d);
         }
         out.push_back(std::move(row));
@@ -890,6 +908,162 @@ manifold::Polygons marchingSquares(const Contours2d& g) {
 }
 
 
+// -- 3D: marching cubes on the grid itself -----------------------------------
+//
+// For a grid sampled at the spacing it was given, Manifold's LevelSet is the
+// wrong tool: it samples its own body-centred lattice, which does not line up
+// with the grid, so it meshes a trilinear blend of the data rather than the
+// data. Measured on #745 on BelfrySCAD, that left a metaball field visibly
+// more faceted than BOSL2's isosurface(), which marches the grid itself. So
+// this does too.
+//
+// No 256-case table. The table's hard part is the ambiguous face (two
+// inside corners on a diagonal), and a table that resolves it per CELL can
+// disagree with the neighbouring cell and leave a crack -- fatal here, since
+// Manifold needs a closed mesh. So the triangles are built per FACE instead:
+// each face's crossings are paired into segments by a rule that reads only
+// that face's four values (the face-centre average decides a saddle, as the
+// 2D path does), so the two cells sharing a face always agree. A cell's
+// segments then link into closed loops, one polygon each. Vertices are keyed
+// on GRID EDGE identity, so neighbours share them by construction, exactly as
+// marchingSquares keys on edges rather than coordinates.
+//
+// Orientation: walking a face's corners anticlockwise as seen from outside
+// the cell, a segment runs from an outside->inside crossing to an
+// inside->outside one. A loop of such segments, read in order, is a polygon
+// whose normal points from inside to outside -- Manifold's convention, with
+// inside the positive side.
+//
+// The field arrives as band distance (positive inside) with a ring of
+// "outside" round it, like the 2D path, so every surface closes; the caller
+// clips the overhang back to the bounds.
+manifold::MeshGL64 marchingCubes(const std::vector<double>& d, const size_t n[3],
+                                  const std::array<double, 3>& org, const std::array<double, 3>& h) {
+    const auto P = [&](size_t i, size_t j, size_t k) { return (k * n[1] + j) * n[0] + i; };
+    // corner c of a cell is offset (c&1, c>>1&1, c>>2&1). Each face's
+    // corners, anticlockwise as seen from outside.
+    static constexpr int kFaces[6][4] = {
+        {0, 2, 3, 1}, {4, 5, 7, 6},   // -z, +z
+        {0, 4, 6, 2}, {1, 3, 7, 5},   // -x, +x
+        {0, 1, 5, 4}, {2, 6, 7, 3},   // -y, +y
+    };
+    manifold::MeshGL64 mesh;
+    mesh.numProp = 3;
+    // ponytail: one int per grid edge, ~12 bytes a sample next to the
+    // field's own ~67; key the vertices per slab if this ever binds.
+    std::vector<int64_t> edgeVert(3 * n[0] * n[1] * n[2], -1);
+    const auto addVert = [&](double x, double y, double z) {
+        mesh.vertProperties.insert(mesh.vertProperties.end(), {x, y, z});
+        return static_cast<int64_t>(mesh.vertProperties.size() / 3 - 1);
+    };
+    for (size_t k = 0; k + 1 < n[2]; ++k) {
+        for (size_t j = 0; j + 1 < n[1]; ++j) {
+            for (size_t i = 0; i + 1 < n[0]; ++i) {
+                double v[8];
+                size_t p[8];
+                int inside = 0;
+                for (int c = 0; c < 8; ++c) {
+                    p[c] = P(i + (c & 1), j + (c >> 1 & 1), k + (c >> 2 & 1));
+                    v[c] = d[p[c]];
+                    inside += v[c] > 0.0;
+                }
+                if (inside == 0 || inside == 8) continue;
+                // The vertex on the edge between corners a and b.
+                const auto vert = [&](int a, int b) -> int64_t {
+                    if (a > b) std::swap(a, b);           // a is the lower end
+                    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) {
+                        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));
+                        const double z = org[2] + h[2] * (static_cast<double>(k + (a >> 2 & 1)) + (axis == 2 ? t : 0.0));
+                        id = addVert(x, y, z);
+                    }
+                    return id;
+                };
+                // Segments start->end, at most two per face.
+                int64_t segFrom[12], segTo[12];
+                int nSeg = 0;
+                for (const auto& f : kFaces) {
+                    int64_t cross[4];
+                    bool outIn[4];
+                    int nc = 0;
+                    for (int m = 0; m < 4; ++m) {
+                        const int a = f[m], b = f[(m + 1) % 4];
+                        if ((v[a] > 0.0) != (v[b] > 0.0)) {
+                            cross[nc] = vert(a, b);
+                            outIn[nc++] = v[b] > 0.0;
+                        }
+                    }
+                    if (nc == 0) continue;
+                    // A saddle joins its inside corners when the face centre
+                    // is inside: each out->in crossing then pairs with the
+                    // PREVIOUS crossing instead of the next.
+                    const bool joined =
+                        nc == 4 && v[f[0]] + v[f[1]] + v[f[2]] + v[f[3]] > 0.0;
+                    for (int m = 0; m < nc; ++m) {
+                        if (!outIn[m]) continue;
+                        segFrom[nSeg] = cross[m];
+                        segTo[nSeg++] = cross[(m + (joined ? nc - 1 : 1)) % nc];
+                    }
+                }
+                // Link into loops; each vertex starts exactly one segment.
+                bool used[12] = {};
+                for (int s0 = 0; s0 < nSeg; ++s0) {
+                    if (used[s0]) continue;
+                    int64_t loop[12];
+                    int len = 0;
+                    for (int s = s0; s >= 0 && !used[s];) {
+                        used[s] = true;
+                        loop[len++] = segFrom[s];
+                        const int64_t want = segTo[s];
+                        s = -1;
+                        for (int q = 0; q < nSeg; ++q)
+                            if (!used[q] && segFrom[q] == want) { s = q; break; }
+                    }
+                    const auto tri = [&](int64_t a, int64_t b, int64_t c) {
+                        mesh.triVerts.insert(mesh.triVerts.end(), {static_cast<uint64_t>(a), static_cast<uint64_t>(b),
+                                                                   static_cast<uint64_t>(c)});
+                    };
+                    const auto at = [&](int64_t id, int axis) {
+                        return mesh.vertProperties[static_cast<size_t>(id) * 3 + static_cast<size_t>(axis)];
+                    };
+                    const auto dist2 = [&](int64_t a, int64_t b) {
+                        double s2 = 0;
+                        for (int ax = 0; ax < 3; ++ax) s2 += (at(a, ax) - at(b, ax)) * (at(a, ax) - at(b, ax));
+                        return s2;
+                    };
+                    if (len == 3) {
+                        tri(loop[0], loop[1], loop[2]);
+                    } else if (len == 4) {
+                        // Split along the shorter diagonal.
+                        if (dist2(loop[0], loop[2]) <= dist2(loop[1], loop[3])) {
+                            tri(loop[0], loop[1], loop[2]);
+                            tri(loop[0], loop[2], loop[3]);
+                        } else {
+                            tri(loop[1], loop[2], loop[3]);
+                            tri(loop[1], loop[3], loop[0]);
+                        }
+                    } else if (len > 4) {
+                        // A fan from one corner of a 5-7 sided, non-planar
+                        // loop can fold; a fan from its centroid cannot.
+                        double cx = 0, cy = 0, cz = 0;
+                        for (int m = 0; m < len; ++m) {
+                            cx += at(loop[m], 0);
+                            cy += at(loop[m], 1);
+                            cz += at(loop[m], 2);
+                        }
+                        const int64_t c = addVert(cx / len, cy / len, cz / len);
+                        for (int m = 0; m < len; ++m) tri(loop[m], loop[(m + 1) % len], c);
+                    }
+                }
+            }
+        }
+    }
+    return mesh;
+}
+
 CSGParams resolveLevelSet(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     CSGParams params;
@@ -1104,8 +1278,7 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
                 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* d = std::get_if<double>(&outv);
-                const double val = (d && std::isfinite(*d)) ? *d : std::numeric_limits<double>::max();
+                const double val = fieldSample(outv).value_or(std::numeric_limits<double>::max());
                 g.v[(j + 1) * g.nx + (i + 1)] = bandDistance(val, isoLo, isoHi, invert);
             }
         }
@@ -1121,6 +1294,7 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
     }
 
 
+    bool marchGrid = false;
     if (!fieldFn) {
         field = readField(fieldArg);
         if (!field) {
@@ -1135,6 +1309,15 @@ 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)};
+        // Marched on the grid itself unless edge= asks for a different
+        // spacing. A 1e-9 relative slack so an edge typed as the spacing,
+        // or computed from the same bounds, still counts as it.
+        const auto same = [](double a, double b) { return std::abs(a - b) <= 1e-9 * std::max(a, b); };
+        marchGrid = edge <= 0.0;
+        if (!marchGrid) {
+            marchGrid = true;
+            for (int a = 0; a < 3; ++a) marchGrid = marchGrid && same(edgeVec ? edgeV[a] : edge, spacing[a]);
+        }
         // 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]});
@@ -1151,10 +1334,9 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
         const double xyz[3] = {p.x, p.y, p.z};
         for (int a = 0; a < 3; ++a) bound.set(fnParams2[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();
+        // build; it becomes a huge value instead. +-INF keeps its sign.
+        const double v = fieldSample(out).value_or(std::numeric_limits<double>::max());
         return bandDistance(v, isoLo, isoHi, invert);
     };
 
@@ -1178,18 +1360,13 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
             if (i0[a] > n[a] - 2) i0[a] = n[a] - 2;
             t[a] = g[a] - static_cast<double>(i0[a]);
         }
-        // Outside the sampled block the answer is "outside", falling away
-        // with distance. Clamping instead (which is what the interpolation
-        // above does on its own) would smear the boundary values outward and
-        // extend the surface rather than close it.
-        double outside = 0.0;
-        for (int a = 0; a < 3; ++a) {
-            const double maxg = static_cast<double>(n[a] - 1);
-            const double raw = (pos[a] - origin[a]) / spacing[a];
-            if (raw < 0.0) outside = std::max(outside, -raw);
-            else if (raw > maxg) outside = std::max(outside, raw - maxg);
-        }
-        if (outside > 0.0) return invert ? (1.0 + outside) : -(1.0 + outside);
+        // 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).
 
         double acc = 0.0;
         for (int c = 0; c < 8; ++c) {
@@ -1214,11 +1391,15 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
     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.
-    // canParallel true: the lambda is pure C++ and never re-enters the
-    // evaluator, which is the whole point of taking a grid.
+    // 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.
+    //
     // 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
@@ -1226,19 +1407,32 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
     //
     // 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.
+    // 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 (!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 {
+    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;
+    }
+    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, -1.0, /*canParallel=*/false)
+                                                       unit, 1.0, 0.0, tol, /*canParallel=*/false)
                         : manifold::Manifold::LevelSet([&](manifold::vec3 q) { return sampleGrid(q * E); },
-                                                       unit, 1.0, 0.0, -1.0, /*canParallel=*/true);
+                                                       unit, 1.0, 0.0, tol, /*canParallel=*/true);
         solid = solid.Scale(E);
     }
 

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

@@ -1192,6 +1192,60 @@ TEST(LevelSet, MalformedFieldsWarn) {
     }
 }
 
+TEST(LevelSet, InfinityIsASampleNotAMalformedField) {
+    // INF is BOSL2's name for 1/0, not a builtin, so each script defines it.
+    // #744 on BelfrySCAD: a metaball field is 1/0 where a grid point lands on
+    // a centre. The field is rectangular; INF made it read as malformed and
+    // nothing was drawn. A metaball r/d around the origin, centre sample INF:
+    // [1, INF] is the ball of radius r.
+    const std::string field =
+        "INF = 1/0; N = 21; H = 10;\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(d = norm([co(i), co(j), co(k)])) d == 0 ? INF : 6 / d ]]];\n";
+    const std::vector<std::string> w =
+        levelsetWarnings(field + "levelset(f, bounds=[[-H,-H,-H],[H,H,H]], isovalue=[1, INF]);");
+    EXPECT_TRUE(w.empty()) << w.front();
+    Evaluated e = evalSrc(field + "levelset(f, bounds=[[-H,-H,-H],[H,H,H]], isovalue=[1, INF]);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const double analytic = 4.0 / 3.0 * 3.14159265358979 * 6 * 6 * 6;
+    EXPECT_NEAR(soleBody(e).Volume(), analytic, 0.05 * analytic);
+    EXPECT_EQ(soleBody(e).Genus(), 0);
+
+    // -INF keeps its sign: the same ball, as a field that is -INF at the centre.
+    Evaluated neg = evalSrc(
+        "INF = 1/0; N = 21; H = 10;\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(d = norm([co(i), co(j), co(k)])) d == 0 ? -INF : -6 / d ]]];\n"
+        "levelset(f, bounds=[[-H,-H,-H],[H,H,H]], isovalue=-1);");
+    ASSERT_EQ(neg.bodies.size(), 1u);
+    EXPECT_NEAR(soleBody(neg).Volume(), analytic, 0.05 * analytic);
+
+    // And the 2D reader the same way.
+    EXPECT_TRUE(levelsetWarnings(
+                    "INF = 1/0; f = [for (i=[-5:5]) [for (j=[-5:5]) let(d = norm([i,j])) d == 0 ? INF : 3 / d]];\n"
+                    "levelset(f, bounds=[[-5,-5],[5,5]], isovalue=[1, INF]);")
+                    .empty());
+}
+
+TEST(LevelSet, NanIsStillAMalformedField) {
+    EXPECT_FALSE(levelsetWarnings(
+                     "levelset([[[1,2],[3,0/0]],[[5,6],[7,8]]], bounds=[[0,0,0],[1,1,1]]);").empty());
+}
+
+TEST(LevelSet, AFunctionReturningMinusInfinityIsFarBelowNotFarAbove) {
+    // Every non-finite value used to become +DBL_MAX, so -INF counted as
+    // ABOVE every isovalue -- outside a scalar one. -INF over a ball of
+    // radius 6 and 0 elsewhere: at or below -1 is that ball, not nothing.
+    const std::string src =
+        "INF = 1/0; levelset(function(x,y,z) norm([x,y,z]) < 6 ? -INF : 0,\n"
+        "         bounds=[[-10,-10,-10],[10,10,10]], isovalue=-1, edge=0.5);";
+    EXPECT_TRUE(levelsetWarnings(src).empty());
+    Evaluated e = evalSrc(src);
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const double analytic = 4.0 / 3.0 * 3.14159265358979 * 6 * 6 * 6;
+    EXPECT_NEAR(soleBody(e).Volume(), analytic, 0.1 * analytic);
+}
+
 // -- levelset, function form ----------------------------------------------
 //
 // Same builtin, field given as function(x,y,z) instead of a grid. Slower --
@@ -1283,8 +1337,10 @@ TEST(LevelSetFn, AVectorEdgeIsExactlyAStretchedLattice) {
 }
 
 TEST(LevelSetFn, AVectorEdgeAlsoAppliesToAGrid) {
+    // Compared with an isotropic resample, not the default: the default
+    // marches the grid itself, which is a different mesher.
     Evaluated fine = evalSrc(sphereFieldSrc(50, 30) +
-                              "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=20);");
+                              "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=20, edge=1.2);");
     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);
@@ -1511,15 +1567,159 @@ TEST(LevelSet, PaddingDoesNotDisturbAShapeInsideTheBox) {
 }
 
 TEST(LevelSet, AGridFieldIsAlsoCutCleanlyAtTheBox) {
-    // The grid intake cannot sample beyond its data, so the sampler reads
-    // "outside" past the block rather than clamping and smearing the edge
-    // values outward. Same clean cut as the function form.
+    // The grid intake cannot sample beyond its data, so past the block the
+    // sampler clamps -- the edge values run on into the padding -- and the
+    // clip to the bounds makes the cut. It used to read "outside" there
+    // instead, which closed the surface AT the box face along Manifold's
+    // lattice: a waffle-textured staircase inside the bounds that the clip
+    // could not reach (#745 on BelfrySCAD). This test then needed one
+    // sample layer of slack; a clean cut needs none.
+    for (const char* edge : {"", ", edge=2", ", edge=[1,2,0.5]"}) {
+        Evaluated e = evalSrc(
+            std::string("N = 41;\nfunction co(t) = -20 + 40*t/(N-1);\n"
+                        "f = [for (i=[0:N-1]) [for (j=[0:N-1]) [for (k=[0:N-1]) co(i) ]]];\n"
+                        "levelset(f, bounds=[[-20,-20,-20],[20,20,20]], isovalue=[-1e18,0]") + edge + ");");
+        ASSERT_EQ(e.bodies.size(), 1u) << edge;
+        EXPECT_NEAR(soleBody(e).Volume(), 32000.0, 1e-6) << edge;
+    }
+    // And a curved surface the box cuts through: a sphere of radius 25 in a
+    // box of half-width 20. The faces lying flat on x=20 together make the
+    // full disc the plane cuts, not a staircase short of it.
+    Evaluated s = evalSrc(sphereFieldSrc(41, 20) +
+                           "levelset(f, bounds=[[-20,-20,-20],[20,20,20]], isovalue=25);");
+    ASSERT_EQ(s.bodies.size(), 1u);
+    const manifold::MeshGL m = soleBody(s).GetMeshGL();
+    double capArea = 0;
+    for (size_t t = 0; t + 2 < m.triVerts.size(); t += 3) {
+        manifold::vec3 p[3];
+        for (int k = 0; k < 3; ++k) {
+            const size_t v = static_cast<size_t>(m.triVerts[t + static_cast<size_t>(k)]) * m.numProp;
+            p[k] = manifold::vec3(m.vertProperties[v], m.vertProperties[v + 1], m.vertProperties[v + 2]);
+        }
+        if (std::abs(p[0].x - 20) < 1e-6 && std::abs(p[1].x - 20) < 1e-6 && std::abs(p[2].x - 20) < 1e-6)
+            capArea += 0.5 * manifold::la::length(manifold::la::cross(p[1] - p[0], p[2] - p[0]));
+    }
+    // The plane x=20 cuts the sphere in a disc of radius sqrt(25^2 - 20^2)
+    // = 15, which fits inside the 40x40 face.
+    const double r = 15.0;
+    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.
+    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=") +
+                               edge + ");");
+        ASSERT_EQ(e.bodies.size(), 1u) << edge;
+        const manifold::MeshGL m = soleBody(e).GetMeshGL();
+        double worst = 0;
+        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;
+    }
+}
+
+// -- levelset, grid marched directly ---------------------------------------
+//
+// At its own spacing a grid is marched as it stands (marchingCubes), not
+// resampled through Manifold's body-centred lattice -- which meshed a
+// trilinear blend of the data and left #745 on BelfrySCAD's metaballs more
+// faceted than BOSL2's isosurface(). The signature of marching the grid: a
+// vertex sits on a grid EDGE, so at least two of its coordinates are grid
+// lines. Manifold's lattice puts most of them on diagonals. The mesher also
+// falls back to resampling if Manifold ever refused its mesh, and this is
+// what would catch that happening silently.
+
+namespace {
+
+// Fraction of the body's vertices with two or more coordinates on the grid
+// lines lo + i*h. Polygons of 5+ sides get a centroid vertex, which does not
+// qualify, so marching the grid scores 0.66-0.81 on the fields below.
+// Resampling at an edge 1e-6 away from the grid's scores 0.001-0.024.
+double onGridLines(const manifold::Manifold& m, manifold::vec3 lo, manifold::vec3 h) {
+    const manifold::MeshGL g = m.GetMeshGL();
+    size_t on = 0, all = 0;
+    for (size_t v = 0; v + 2 < g.vertProperties.size(); v += g.numProp, ++all) {
+        int lines = 0;
+        for (int a = 0; a < 3; ++a) {
+            const double t = (g.vertProperties[v + static_cast<size_t>(a)] - lo[a]) / h[a];
+            lines += std::abs(t - std::round(t)) < 1e-4;
+        }
+        on += lines >= 2;
+    }
+    return all ? static_cast<double>(on) / static_cast<double>(all) : 0.0;
+}
+
+} // namespace
+
+TEST(LevelSetGrid, TheDefaultMarchesTheGridItself) {
+    Evaluated e = evalSrc(sphereFieldSrc(41, 20) +
+                           "levelset(f, bounds=[[-20,-20,-20],[20,20,20]], isovalue=15);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_GT(onGridLines(soleBody(e), manifold::vec3(-20.0), manifold::vec3(1.0)), 0.5);
+    EXPECT_EQ(soleBody(e).Genus(), 0);
+    const double analytic = 4.0 / 3.0 * 3.14159265358979 * 15 * 15 * 15;
+    EXPECT_NEAR(soleBody(e).Volume(), analytic, 0.01 * analytic);
+    // And edge= naming the grid's own spacing is the same request.
+    Evaluated same = evalSrc(sphereFieldSrc(41, 20) +
+                              "levelset(f, bounds=[[-20,-20,-20],[20,20,20]], isovalue=15, edge=[1,1,1]);");
+    ASSERT_EQ(same.bodies.size(), 1u);
+    EXPECT_EQ(soleBody(same).NumTri(), soleBody(e).NumTri());
+}
+
+TEST(LevelSetGrid, ADifferentEdgeStillResamples) {
+    Evaluated e = evalSrc(sphereFieldSrc(41, 20) +
+                           "levelset(f, bounds=[[-20,-20,-20],[20,20,20]], isovalue=15, edge=0.7);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_LT(onGridLines(soleBody(e), manifold::vec3(-20.0), manifold::vec3(1.0)), 0.1);
+}
+
+TEST(LevelSetGrid, SaddlesEverywhereStillCloseTheMesh) {
+    // Random samples: ambiguous faces in every direction, which is where a
+    // per-cell table cracks. A crack would fail Manifold's check and fall
+    // back to resampling, so the vertices would leave the grid lines.
+    for (const char* iso : {"0", "[-0.3, 0.4], invert=true"}) {
+        Evaluated e = evalSrc(std::string("r = rands(-1, 1, 20*20*20, 42);\n"
+                                          "f = [for (i=[0:19]) [for (j=[0:19]) [for (k=[0:19]) r[(i*20+j)*20+k] ]]];\n"
+                                          "levelset(f, bounds=[[0,0,0],[19,19,19]], isovalue=") + iso + ");");
+        ASSERT_EQ(e.bodies.size(), 1u) << iso;
+        EXPECT_GT(onGridLines(soleBody(e), manifold::vec3(0.0), manifold::vec3(1.0)), 0.5) << iso;
+        EXPECT_GT(soleBody(e).Volume(), 0.0) << iso;
+    }
+}
+
+TEST(LevelSetGrid, SamplesExactlyOnTheIsovalueStayManifold) {
+    // Integer data at an integer isovalue: crossings land ON grid corners,
+    // so several edges share a vertex position. The old resample of this
+    // exported 4 non-manifold edges and 2 duplicate faces.
     Evaluated e = evalSrc(
-        "N = 41;\nfunction co(t) = -20 + 40*t/(N-1);\n"
-        "f = [for (i=[0:N-1]) [for (j=[0:N-1]) [for (k=[0:N-1]) co(i) ]]];\n"
-        "levelset(f, bounds=[[-20,-20,-20],[20,20,20]], isovalue=[-1e18,0]);");
+        "f = [for (i=[0:9]) [for (j=[0:9]) [for (k=[0:9]) (i+j+k) % 3 ]]];\n"
+        "levelset(f, bounds=[[0,0,0],[9,9,9]], isovalue=1);");
     ASSERT_EQ(e.bodies.size(), 1u);
-    EXPECT_NEAR(soleBody(e).Volume(), 32000.0, 40.0);   // one sample layer of slack
+    EXPECT_EQ(soleBody(e).Status(), manifold::Manifold::Error::NoError);
+    EXPECT_GT(onGridLines(soleBody(e), manifold::vec3(0.0), manifold::vec3(1.0)), 0.5);
+}
+
+TEST(LevelSetGrid, UnequalSpacingPerAxisIsMarchedAsIs) {
+    // 31 samples over 20 x 40 x 10: three different spacings, no common edge
+    // to resample at. A unit-ball field becomes an ellipsoid of semi-axes
+    // 8, 16 and 4 at isovalue 0.8.
+    Evaluated e = evalSrc(
+        "N = 31;\nf = [for (i=[0:N-1]) [for (j=[0:N-1]) [for (k=[0:N-1])\n"
+        "      norm([(i-15)/15, (j-15)/15, (k-15)/15]) ]]];\n"
+        "levelset(f, bounds=[[-10,-20,-5],[10,20,5]], isovalue=0.8);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_GT(onGridLines(soleBody(e), manifold::vec3(-10, -20, -5), manifold::vec3(20.0 / 30, 40.0 / 30, 10.0 / 30)),
+              0.5);
+    const double analytic = 4.0 / 3.0 * 3.14159265358979 * 8 * 16 * 4;
+    EXPECT_NEAR(soleBody(e).Volume(), analytic, 0.02 * analytic);
 }
 
 // -- 2D union keeps every colour (bug report: "multiple colors inside a

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

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