openscad-cpp-evaluator 0.35.0__tar.gz → 0.37.0__tar.gz

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.37.0}/CLAUDE.md

@@ -561,6 +561,47 @@ grep for `ponytail:`.
   color instead of preserving each part's own, matching real OpenSCAD's actual behavior once fixed
   (cross-checked triangle-color-count-and-values against the Python reference directly, not just
   “does it run”).
+- `src/builtins/primitives_3d.cpp` — `sphere(style=)` is a BelfrySCAD extension naming the
+  tessellation, using BOSL2's five `spheroid()` style names and constructions: `"orig"` (the default,
+  and what OpenSCAD's own sphere() builds — rings offset half a step from the poles, no pole vertex),
+  `"aligned"` (a vertex at each pole, so an `$fn` divisible by 4 also lands vertices exactly on ±X
+  and ±Y), `"stagger"` (aligned with alternate rings rotated half a face), `"octa"` and `"icosa"`.
+  Only `"orig"` renders the same in real OpenSCAD.
+
+  `"octa"` is `Manifold::Sphere`, which already *is* a subdivided octahedron (`Shape::Octahedron`
+  then `Subdivide`). Same 146/288 topology as BOSL2's at `$fn=24`, ~0.05% apart in volume because
+  Manifold distributes the subdivision differently. `"icosa"` samples each icosahedral face against
+  its own corners rather than rotating copies of one sampled face the way BOSL2 does — the sampling
+  is affine in those corners, so it is the same points with far less machinery — and welds the
+  shared edges itself so the mesh reaches Manifold already manifold.
+
+  **BOSL2's VNF winding is the opposite of Manifold's**, so `buildAligned` emits every triangle with
+  its last two indices swapped. Without it the solid is inside-out, which `Manifold::Volume()`
+  reports as a NEGATIVE volume — and which comparing `|volume|` (as an STL-based check naturally
+  does) hides completely. Two of the tests assert a positive volume specifically to catch this.
+
+  Note when checking any of this against BOSL2: **BOSL2 shadows `sphere()`** with its own module, so
+  a file that includes BOSL2 to "compare against the reference" is comparing BOSL2 with itself. Call
+  `spheroid()` from a BOSL2-including file and `sphere()` from one without.
+
+- `simplify()` (also `topology.cpp`) — mesh decimation within a tolerance, wrapping
+  `Manifold::Simplify` and `CrossSection::Simplify`, so it works on sections as well as solids.
+  Another BelfrySCAD extension: nothing in the OpenSCAD language can reduce a triangle count, and
+  library-generated or imported geometry is routinely far denser than the model needs.
+
+  **The default tolerance is 0.1% of the body's own bounding-box diagonal**, not zero.
+  `Manifold::Simplify(0)` falls back to the mesh epsilon and changes nothing, so defaulting to zero
+  would make a bare `simplify()` silently do nothing — the worst possible outcome. It has to be
+  scale-relative, too: an absolute default sensible in millimetres is catastrophic in metres.
+  Measured on a drilled sphere (4764 triangles): the default takes it to 3732 for well under 0.1%
+  volume error, an explicit 0.25 halves it for 0.8%.
+
+  Two properties worth keeping, both covered by tests. Provenance survives — the original-ID runs
+  come through simplification intact, so selection and drag-to-edit still work through a
+  `simplify()`. So does topology: a drilled part keeps its genus rather than having holes welded
+  shut. Note the reduction is NOT monotonic in the tolerance (1.0 gave *more* triangles than 0.5 on
+  the test model, since simplification can force re-triangulation), so don't read a jump as a bug.
+
 - `src/builtins/dxf_dim.cpp` — `dxf_dim()`/`dxf_cross()`, which read a measurement out of a DXF file
   rather than out of the model. Ported from the reference's `io/dxfdim.cc` plus the DIMENSION/LINE
   half of `io/DxfData.cc`: `dxf_dim()` returns the first matching DIMENSION's value by its type

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.37.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.37.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.37.0}/src/builtins/builtins.hpp

@@ -165,6 +165,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 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,
+                                           const oscad::ASTNode& node);
+
 CSGParams resolveMinkowskiDifference(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateMinkowskiDifference(Evaluator& ev, const CSGParams& params,
                                                       const std::vector<std::unique_ptr<CSGNode>>& children,

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.37.0}/src/builtins/primitives_3d.cpp

@@ -5,10 +5,12 @@
 #include "openscad_cpp_evaluator/segments.hpp"
 
 #include <algorithm>
+#include <array>
 #include <cmath>
 #include <cstdint>
 #include <map>
 #include <numbers>
+#include <set>
 
 namespace oscadeval {
 
@@ -100,22 +102,48 @@ std::vector<ColoredBody> generateCube(Evaluator& ev, const CSGParams& params, co
 // _resolve_sphere/_generate_sphere exactly, including the "stacks =
 // max(2, ceil(n/2))" ring count and the fan-cap winding.
 
-CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
-    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
-    Value dArg = getArg(args, std::nullopt, "d", Value{});
-    double r;
-    if (!isUndef(dArg)) {
-        r = toDoubleLenient(dArg) / 2.0;
-    } else {
-        Value rArg = getArg(args, 0, "r", Value{});
-        r = isUndef(rArg) ? 1.0 : toDoubleLenient(rArg);
-    }
+// sphere(r|d, style) -- `style` is a BelfrySCAD extension naming the
+// tessellation, with the same five names and the same constructions as
+// BOSL2's spheroid():
+//
+//   "orig"    stacked rings offset half a step from the poles, no pole
+//             vertex. What OpenSCAD's own sphere() builds, hence the name,
+//             and still the default here.
+//   "aligned" a vertex at each pole and rings on the latitudes between, so
+//             an $fn divisible by 4 puts vertices exactly on +-X and +-Y.
+//   "stagger" "aligned" with alternate rings rotated half a face, giving
+//             triangles that alternate direction rather than stacking.
+//   "octa"    a subdivided octahedron projected onto the sphere.
+//   "icosa"   a subdivided icosahedron projected onto the sphere -- the most
+//             uniform of the five.
+//
+// Only "orig" matches real OpenSCAD; the rest are additions, so a script
+// using them will not render the same shape elsewhere.
 
-    const int n = fnSegmentsFromCtx(effCtx, r); // longitude segments
-    const int stacks = std::max(2, static_cast<int>(std::ceil(n / 2.0)));
-    const double step = std::numbers::pi / stacks;
+namespace {
 
-    std::vector<double> verts; // flat x,y,z,...
+// BOSL2's spherical_to_xyz(r, theta, phi): theta around Z from +X, phi down
+// from +Z.
+std::array<double, 3> sphericalToXyz(double r, double thetaDeg, double phiDeg) {
+    const double th = thetaDeg * std::numbers::pi / 180.0;
+    const double ph = phiDeg * std::numbers::pi / 180.0;
+    return {r * std::sin(ph) * std::cos(th), r * std::sin(ph) * std::sin(th), r * std::cos(ph)};
+}
+
+struct SphereMesh {
+    std::vector<double> verts;   // flat x,y,z
+    std::vector<int> tris;
+};
+
+void pushVert(SphereMesh& m, const std::array<double, 3>& p) {
+    m.verts.insert(m.verts.end(), {p[0], p[1], p[2]});
+}
+
+// "orig": rings at (i+0.5) steps, no pole vertices, capped by a fan at each
+// end. Unchanged from the original implementation.
+SphereMesh buildOrig(double r, int n, int stacks) {
+    SphereMesh m;
+    const double step = std::numbers::pi / stacks;
     std::vector<std::vector<int>> rings(static_cast<size_t>(stacks));
     for (int s = 0; s < stacks; ++s) {
         const double lat = -std::numbers::pi / 2.0 + (s + 0.5) * step;
@@ -123,44 +151,214 @@ CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalConte
         const double z = r * std::sin(lat);
         for (int seg = 0; seg < n; ++seg) {
             const double angle = 2.0 * std::numbers::pi * seg / n;
-            rings[static_cast<size_t>(s)].push_back(static_cast<int>(verts.size() / 3));
-            verts.push_back(ringR * std::cos(angle));
-            verts.push_back(ringR * std::sin(angle));
-            verts.push_back(z);
+            rings[static_cast<size_t>(s)].push_back(static_cast<int>(m.verts.size() / 3));
+            pushVert(m, {ringR * std::cos(angle), ringR * std::sin(angle), z});
         }
     }
-
-    std::vector<int> tris;
     const auto& bot = rings.front();
-    for (int i = 1; i < n - 1; ++i) {
-        tris.insert(tris.end(), {bot[0], bot[static_cast<size_t>(i) + 1], bot[static_cast<size_t>(i)]});
-    }
+    for (int i = 1; i < n - 1; ++i) m.tris.insert(m.tris.end(), {bot[0], bot[size_t(i) + 1], bot[size_t(i)]});
     for (int s = 0; s < stacks - 1; ++s) {
-        const auto& lo = rings[static_cast<size_t>(s)];
-        const auto& hi = rings[static_cast<size_t>(s) + 1];
+        const auto& lo = rings[size_t(s)];
+        const auto& hi = rings[size_t(s) + 1];
         for (int seg = 0; seg < n; ++seg) {
-            const int a = lo[static_cast<size_t>(seg)], b = lo[static_cast<size_t>((seg + 1) % n)];
-            const int c = hi[static_cast<size_t>(seg)], d = hi[static_cast<size_t>((seg + 1) % n)];
-            tris.insert(tris.end(), {a, b, d});
-            tris.insert(tris.end(), {a, d, c});
+            const int a = lo[size_t(seg)], b = lo[size_t((seg + 1) % n)];
+            const int c = hi[size_t(seg)], d = hi[size_t((seg + 1) % n)];
+            m.tris.insert(m.tris.end(), {a, b, d});
+            m.tris.insert(m.tris.end(), {a, d, c});
         }
     }
     const auto& top = rings.back();
-    for (int i = 1; i < n - 1; ++i) {
-        tris.insert(tris.end(), {top[0], top[static_cast<size_t>(i)], top[static_cast<size_t>(i) + 1]});
+    for (int i = 1; i < n - 1; ++i) m.tris.insert(m.tris.end(), {top[0], top[size_t(i)], top[size_t(i) + 1]});
+    return m;
+}
+
+// "aligned"/"stagger": pole, vsides-1 rings, pole. Vertex order and face
+// indices follow BOSL2's spheroid() exactly so the two agree triangle for
+// triangle, not merely in shape.
+SphereMesh buildAligned(double r, int hsides, int vsides, bool stagger) {
+    SphereMesh m;
+    pushVert(m, sphericalToXyz(r, 0, 0));                      // north pole, index 0
+    for (int i = 1; i <= vsides - 1; ++i) {
+        const double phi = i * 180.0 / vsides;
+        for (int j = 0; j < hsides; ++j) {
+            const double theta = (j + ((stagger && i % 2 != 0) ? 0.5 : 0.0)) * 360.0 / hsides;
+            pushVert(m, sphericalToXyz(r, theta, phi));
+        }
+    }
+    pushVert(m, sphericalToXyz(r, 0, 180));                    // south pole, last index
+    const int lv = static_cast<int>(m.verts.size() / 3);
+
+    // BOSL2's VNF winding is the opposite of what Manifold wants, so every
+    // triangle below is emitted with its last two indices swapped. Without
+    // that the solid comes out inside-out -- and invisibly so if you only
+    // ever check |volume|, which is how this first went unnoticed.
+    const auto tri = [&m](int a, int b, int c) { m.tris.insert(m.tris.end(), {a, c, b}); };
+
+    for (int i = 0; i < hsides; ++i) {
+        const int b2 = lv - 2 - hsides;
+        tri(i + 1, 0, ((i + 1) % hsides) + 1);
+        tri(lv - 1, b2 + i + 1, b2 + ((i + 1) % hsides) + 1);
     }
+    for (int i = 0; i <= vsides - 3; ++i) {
+        const int base = 1 + hsides * i;
+        for (int j = 0; j < hsides; ++j) {
+            if (stagger && i % 2 != 0) {
+                tri(base + j, base + hsides + j % hsides, base + hsides + (j + hsides - 1) % hsides);
+                tri(base + j, base + (j + 1) % hsides, base + hsides + j);
+            } else {
+                tri(base + j, base + (j + 1) % hsides, base + hsides + (j + 1) % hsides);
+                tri(base + j, base + hsides + (j + 1) % hsides, base + hsides + j);
+            }
+        }
+    }
+    return m;
+}
 
-    std::vector<Value> vertsValues;
-    vertsValues.reserve(verts.size());
-    for (double v : verts) vertsValues.push_back(Value{v});
-    std::vector<Value> trisValues;
-    trisValues.reserve(tris.size());
-    for (int t : tris) trisValues.push_back(Value{static_cast<double>(t)});
+// "icosa": subdivide every icosahedral face into a triangular grid and push
+// each sample out to the sphere. BOSL2 subsamples one face and rotates
+// copies onto the rest; sampling each face against its own corners is the
+// same points (the sampling is affine in those corners) with far less
+// machinery. Coincident vertices along shared edges are welded here rather
+// than left for Manifold, so the mesh arrives already manifold.
+SphereMesh buildIcosa(double r, int hsides) {
+    const double phi = (1.0 + std::sqrt(5.0)) / 2.0;
+    std::vector<std::array<double, 3>> ico;
+    for (int i : {-1, 1}) {
+        for (int j : {-1, 1}) {
+            ico.push_back({0.0, double(i), double(j) * phi});
+            ico.push_back({double(i), double(j) * phi, 0.0});
+            ico.push_back({double(j) * phi, 0.0, double(i)});
+        }
+    }
+    // Hull faces by brute force: a triple is a face when every other vertex
+    // lies on one side of its plane. 12 vertices, so 220 triples.
+    std::vector<std::array<int, 3>> faces;
+    const int nv = static_cast<int>(ico.size());
+    for (int a = 0; a < nv; ++a)
+        for (int b = a + 1; b < nv; ++b)
+            for (int c = b + 1; c < nv; ++c) {
+                const std::array<double, 3> u{ico[b][0] - ico[a][0], ico[b][1] - ico[a][1], ico[b][2] - ico[a][2]};
+                const std::array<double, 3> v{ico[c][0] - ico[a][0], ico[c][1] - ico[a][1], ico[c][2] - ico[a][2]};
+                const std::array<double, 3> nrm{u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2],
+                                                 u[0] * v[1] - u[1] * v[0]};
+                int pos = 0, neg = 0;
+                for (int k = 0; k < nv; ++k) {
+                    if (k == a || k == b || k == c) continue;
+                    const double d = nrm[0] * (ico[k][0] - ico[a][0]) + nrm[1] * (ico[k][1] - ico[a][1]) +
+                                     nrm[2] * (ico[k][2] - ico[a][2]);
+                    if (d > 1e-9) ++pos;
+                    if (d < -1e-9) ++neg;
+                }
+                if (pos && neg) continue;
+                // Orient outward: the normal must point away from the centre.
+                if (neg == 0) faces.push_back({a, c, b});
+                else faces.push_back({a, b, c});
+            }
+
+    const int steps = std::max(1, static_cast<int>(std::lround(std::max(5, hsides) / 5.0)));
+    const int N = steps - 1;   // BOSL2's N; the grid has N+2 rows
+
+    SphereMesh m;
+    std::map<std::array<long long, 3>, int> weld;
+    const auto add = [&](const std::array<double, 3>& p) {
+        const double len = std::sqrt(p[0] * p[0] + p[1] * p[1] + p[2] * p[2]);
+        const std::array<double, 3> u{r * p[0] / len, r * p[1] / len, r * p[2] / len};
+        const std::array<long long, 3> key{std::llround(u[0] * 1e9), std::llround(u[1] * 1e9),
+                                            std::llround(u[2] * 1e9)};
+        auto it = weld.find(key);
+        if (it != weld.end()) return it->second;
+        const int idx = static_cast<int>(m.verts.size() / 3);
+        pushVert(m, u);
+        weld.emplace(key, idx);
+        return idx;
+    };
+
+    for (const std::array<int, 3>& f : faces) {
+        const std::array<double, 3>& p0 = ico[f[0]];
+        const std::array<double, 3>& p1 = ico[f[1]];
+        const std::array<double, 3>& p2 = ico[f[2]];
+        // Row i has N+2-i samples, mirroring _subsample_triangle.
+        std::vector<std::vector<int>> grid;
+        for (int i = 0; i <= N + 1; ++i) {
+            std::vector<int> row;
+            for (int j = 0; j <= N + 1 - i; ++j) {
+                const double a = double(i) / (N + 1), b = double(j) / (N + 1);
+                row.push_back(add({p0[0] + (p1[0] - p0[0]) * a + (p2[0] - p0[0]) * b,
+                                    p0[1] + (p1[1] - p0[1]) * a + (p2[1] - p0[1]) * b,
+                                    p0[2] + (p1[2] - p0[2]) * a + (p2[2] - p0[2]) * b}));
+            }
+            grid.push_back(std::move(row));
+        }
+        for (int i = 0; i <= N; ++i) {
+            for (int j = 0; j <= N - i; ++j) {
+                m.tris.insert(m.tris.end(), {grid[i][j], grid[i + 1][j], grid[i][j + 1]});
+                if (j < N - i) {
+                    m.tris.insert(m.tris.end(), {grid[i + 1][j], grid[i + 1][j + 1], grid[i][j + 1]});
+                }
+            }
+        }
+    }
+    return m;
+}
+
+} // namespace
+
+CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    Value dArg = getArg(args, std::nullopt, "d", Value{});
+    double r;
+    if (!isUndef(dArg)) {
+        r = toDoubleLenient(dArg) / 2.0;
+    } else {
+        Value rArg = getArg(args, 0, "r", Value{});
+        r = isUndef(rArg) ? 1.0 : toDoubleLenient(rArg);
+    }
+
+    const Value styleArg = getArg(args, std::nullopt, "style", Value{});
+    std::string style = "orig";
+    if (const std::string* sv = std::get_if<std::string>(&styleArg)) {
+        static const std::set<std::string> known{"orig", "aligned", "stagger", "octa", "icosa"};
+        if (known.count(*sv)) {
+            style = *sv;
+        } else {
+            ev.warn("sphere: unknown style \"" + *sv + "\"; expected one of orig, aligned, stagger, octa, icosa",
+                    &node.position());
+        }
+    } else if (!isUndef(styleArg)) {
+        ev.warn("sphere: style must be a string", &node.position());
+    }
+
+    const int hsides = fnSegmentsFromCtx(effCtx, r);
+    const int vsides = std::max(2, static_cast<int>(std::ceil(hsides / 2.0)));
 
     CSGParams params;
+    params["style"] = Value{style};
+    params["r"] = Value{r};
+    params["segs"] = Value{static_cast<double>(hsides)};
+    params["color"] = colorToValue(effCtx.color);
+
+    if (style == "octa") {
+        // Manifold::Sphere IS a subdivided octahedron (Shape::Octahedron,
+        // then Subdivide), so this needs no mesh of our own -- generate
+        // calls it directly.
+        params["verts"] = Value{std::make_shared<const ValueList>(ValueList{})};
+        params["tris"] = Value{std::make_shared<const ValueList>(ValueList{})};
+        return params;
+    }
+
+    const SphereMesh m = style == "aligned"   ? buildAligned(r, hsides, vsides, false)
+                         : style == "stagger" ? buildAligned(r, hsides, vsides, true)
+                         : style == "icosa"   ? buildIcosa(r, hsides)
+                                              : buildOrig(r, hsides, vsides);
+
+    std::vector<Value> vertsValues;
+    vertsValues.reserve(m.verts.size());
+    for (double v : m.verts) vertsValues.push_back(Value{v});
+    std::vector<Value> trisValues;
+    trisValues.reserve(m.tris.size());
+    for (int t : m.tris) trisValues.push_back(Value{static_cast<double>(t)});
     params["verts"] = Value{std::make_shared<const ValueList>(ValueList{std::move(vertsValues)})};
     params["tris"] = Value{std::make_shared<const ValueList>(ValueList{std::move(trisValues)})};
-    params["color"] = colorToValue(effCtx.color);
     return params;
 }
 
@@ -174,6 +372,11 @@ std::vector<ColoredBody> generateSphere(Evaluator& ev, const CSGParams& params,
     for (const Value& t : std::get<ListPtr>(params.at("tris"))->items) {
         mesh.triVerts.push_back(static_cast<uint64_t>(std::get<double>(t)));
     }
+    if (std::get<std::string>(params.at("style")) == "octa") {
+        manifold::Manifold octa = manifold::Manifold::Sphere(
+            std::get<double>(params.at("r")), static_cast<int>(std::get<double>(params.at("segs"))));
+        return {ev.tagGenerated(std::move(octa), node, params.at("color"))};
+    }
     manifold::Manifold body(mesh);
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.37.0}/src/builtins/registry.cpp

@@ -36,6 +36,7 @@ const std::unordered_map<std::string_view, ResolveFn>& resolveDispatch() {
         {"roof", &resolveRoof},
         {"fill", &resolveFill},
         {"minkowski_difference", &resolveMinkowskiDifference},
+        {"simplify", &resolveSimplify},
         {"offset", &resolveOffset},
         {"surface", &resolveSurface},
         {"text", &resolveText},
@@ -76,6 +77,7 @@ const std::unordered_map<std::string_view, GenerateFn>& generateDispatch() {
         {"roof", &generateRoof},
         {"fill", &generateFill},
         {"minkowski_difference", &generateMinkowskiDifference},
+        {"simplify", &generateSimplify},
         {"offset", &generateOffset},
         {"surface", &generateSurface},
         {"text", &generateText},
@@ -92,7 +94,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
     static const std::unordered_map<std::string, std::vector<std::string>> table = {
         // -- builtin modules ---------------------------------------------
         {"cube", {"size", "center"}},
-        {"sphere", {"r", "d"}},
+        {"sphere", {"r", "d", "style"}},
         {"cylinder", {"h", "r1", "r2", "center", "r", "d", "d1", "d2"}},
         {"polyhedron", {"points", "faces", "convexity", "triangles"}},
         {"square", {"size", "center"}},
@@ -122,6 +124,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         {"roof", {"method", "convexity"}},
         {"fill", {}},
         {"minkowski_difference", {}},
+        {"simplify", {"tolerance"}},
         {"offset", {"r", "delta", "chamfer"}},
         {"surface", {"file", "center", "convexity", "invert"}},
         {"text", {"text", "size", "font", "direction", "language", "script", "halign", "valign", "spacing"}},

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.37.0}/src/builtins/topology.cpp

@@ -7,6 +7,12 @@
 
 namespace oscadeval {
 
+// simplify()'s default tolerance, as a fraction of the body's bounding-box
+// diagonal. 0.1% measured out at roughly a quarter of the triangles gone for
+// under 0.1% volume error on a representative model -- a good trade, and
+// scale-independent in a way no absolute default can be.
+static constexpr double kDefaultSimplifyFraction = 0.001;
+
 // hull()/minkowski() -- like union/difference/intersection, these splice
 // their children transparently in the CSG tree (resolve just evaluates
 // them for the side effect); the actual hull/minkowski-sum only happens
@@ -375,4 +381,74 @@ std::vector<ColoredBody> generateMinkowskiDifference(Evaluator& ev, const CSGPar
     return out;
 }
 
+// simplify() -- decimate a mesh within a tolerance. A BelfrySCAD extension:
+// nothing in the OpenSCAD language can reduce a mesh's triangle count, and
+// library-generated or imported geometry is routinely far denser than the
+// model needs, which every later boolean and the exported file both pay for.
+//
+// Wraps Manifold::Simplify (and CrossSection::Simplify for 2D), so it works
+// on sections as well as solids.
+
+CSGParams resolveSimplify(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    CSGParams params;
+    // Position 0 so simplify(0.1) reads naturally.
+    params["tolerance"] = getArg(args, 0, "tolerance", Value{});
+    ev.evalChildren(node.children, effCtx);
+    return params;
+}
+
+std::vector<ColoredBody> generateSimplify(Evaluator& ev, const CSGParams& params,
+                                           const std::vector<std::unique_ptr<CSGNode>>& children,
+                                           const oscad::ASTNode& node) {
+    const std::vector<ColoredBody> bodies = flattenCsgTree(children);
+    if (bodies.empty()) return {};
+
+    const Value tolArg = params.at("tolerance");
+    const bool explicitTol = std::holds_alternative<double>(tolArg);
+    const double explicitValue = explicitTol ? std::get<double>(tolArg) : 0.0;
+    if (!explicitTol && !std::holds_alternative<std::monostate>(tolArg)) {
+        ev.warn("simplify: tolerance must be a number", &node.position());
+    }
+    if (explicitTol && explicitValue < 0.0) {
+        ev.warn("simplify: tolerance must not be negative", &node.position());
+        return bodies;
+    }
+
+    std::vector<ColoredBody> out;
+    out.reserve(bodies.size());
+    for (const ColoredBody& b : bodies) {
+        if (b.role != BodyRole::Normal) {
+            out.push_back(b);           // background/highlight untouched
+            continue;
+        }
+        ColoredBody cb = b;
+        if (b.body) {
+            // Manifold::Simplify(0) falls back to the mesh epsilon and
+            // changes nothing, so a bare simplify() cannot default to zero
+            // -- it would silently do nothing, which is the worst outcome.
+            // Default instead to a fraction of the body's own size, which is
+            // the only scale-independent choice available: an absolute
+            // default sensible in millimetres is catastrophic in metres.
+            double tol = explicitValue;
+            if (!explicitTol) {
+                const manifold::Box bb = b.body->BoundingBox();
+                const manifold::vec3 d = bb.Size();
+                tol = kDefaultSimplifyFraction * std::sqrt(d.x * d.x + d.y * d.y + d.z * d.z);
+            }
+            if (tol > 0.0) cb.body = b.body->Simplify(tol);
+        } else if (b.section) {
+            double tol = explicitValue;
+            if (!explicitTol) {
+                const manifold::Rect r = b.section->Bounds();
+                const manifold::vec2 d = r.Size();
+                tol = kDefaultSimplifyFraction * std::sqrt(d.x * d.x + d.y * d.y);
+            }
+            if (tol > 0.0) cb.section = b.section->Simplify(tol);
+        }
+        out.push_back(std::move(cb));
+    }
+    return out;
+}
+
 } // namespace oscadeval

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.37.0}/tests/test_booleans.cpp

@@ -699,3 +699,97 @@ TEST(MinkowskiDifference, TwoDeeChildrenAreIgnoredLikeMinkowskis) {
     Evaluated e = evalSrc("minkowski_difference() { square(10); square(2); }");
     EXPECT_TRUE(e.bodies.empty());
 }
+
+// -- simplify() -----------------------------------------------------------
+//
+// Mesh decimation within a tolerance. A BelfrySCAD extension: nothing in the
+// OpenSCAD language can reduce a triangle count.
+
+namespace {
+const char* kSimplifyModel =
+    "difference() { sphere(r=20, $fn=64); "
+    "  for (a=[0:60:359]) rotate([0,0,a]) translate([12,0,0]) cylinder(h=60,r=4,center=true,$fn=32); }";
+
+const manifold::Manifold& soleBody(const Evaluated& e) { return *e.bodies[0].body; }
+} // namespace
+
+TEST(Simplify, ReducesTriangleCountWithinTolerance) {
+    Evaluated plain = evalSrc(std::string(kSimplifyModel) + ";");
+    Evaluated cut = evalSrc(std::string("simplify(0.1) ") + kSimplifyModel + ";");
+    ASSERT_EQ(cut.bodies.size(), 1u);
+    EXPECT_LT(soleBody(cut).NumTri(), soleBody(plain).NumTri());
+    // ...without moving the surface much: 0.1 costs well under 1% of volume.
+    EXPECT_NEAR(soleBody(cut).Volume(), soleBody(plain).Volume(),
+                0.01 * soleBody(plain).Volume());
+}
+
+TEST(Simplify, DefaultTolerandeScalesWithTheModel) {
+    // No argument means 0.1% of the bounding-box diagonal. Manifold's own
+    // default of 0 falls back to the mesh epsilon and does nothing at all,
+    // so a bare simplify() must NOT pass zero through -- silently doing
+    // nothing is the worst outcome.
+    Evaluated plain = evalSrc(std::string(kSimplifyModel) + ";");
+    Evaluated def = evalSrc(std::string("simplify() ") + kSimplifyModel + ";");
+    EXPECT_LT(soleBody(def).NumTri(), soleBody(plain).NumTri());
+
+    // Scale-independence is the point: the same model 1000x larger must lose
+    // the same proportion of its triangles, which an absolute default could
+    // never manage.
+    Evaluated big = evalSrc(std::string("scale(1000) simplify() ") + kSimplifyModel + ";");
+    Evaluated bigPlain = evalSrc(std::string("scale(1000) ") + kSimplifyModel + ";");
+    const double ratioSmall = double(soleBody(def).NumTri()) / soleBody(plain).NumTri();
+    const double ratioBig = double(soleBody(big).NumTri()) / soleBody(bigPlain).NumTri();
+    EXPECT_NEAR(ratioSmall, ratioBig, 0.02);
+}
+
+TEST(Simplify, KeepsOriginalIdProvenance) {
+    // Selection and drag-to-edit map an AST node to geometry through the
+    // original-ID runs, so a simplify() in the chain must not drop them.
+    Evaluated plain = evalSrc(std::string(kSimplifyModel) + ";");
+    Evaluated cut = evalSrc(std::string("simplify(0.1) ") + kSimplifyModel + ";");
+    const manifold::MeshGL a = soleBody(plain).GetMeshGL();
+    const manifold::MeshGL b = soleBody(cut).GetMeshGL();
+    // Compare the SHAPE of the provenance, not the ID values: tagGenerated
+    // stamps fresh ids on every evaluation, so the two runs here carry
+    // different numbers for the same parts (1 vs 27 in practice). What must
+    // survive simplification is that the runs are still there and still
+    // distinguish the same number of contributing parts.
+    EXPECT_EQ(a.runOriginalID.size(), b.runOriginalID.size());
+    ASSERT_FALSE(b.runOriginalID.empty());
+    const std::set<uint32_t> idsA(a.runOriginalID.begin(), a.runOriginalID.end());
+    const std::set<uint32_t> idsB(b.runOriginalID.begin(), b.runOriginalID.end());
+    EXPECT_EQ(idsA.size(), idsB.size());
+}
+
+TEST(Simplify, KeepsTopology) {
+    // Six drilled holes must still be six holes -- a decimation that welds
+    // one shut has changed the part, not just its mesh.
+    Evaluated plain = evalSrc(std::string(kSimplifyModel) + ";");
+    Evaluated cut = evalSrc(std::string("simplify(0.1) ") + kSimplifyModel + ";");
+    EXPECT_EQ(soleBody(cut).Genus(), soleBody(plain).Genus());
+}
+
+TEST(Simplify, WorksOnTwoDeeSections) {
+    // The tolerance is in model units here too: on an r=20 circle, 0.1
+    // costs 0.5% of the area and 0.5 costs 2.5%.
+    Evaluated plain = evalSrc("circle(r=20, $fn=256);");
+    Evaluated cut = evalSrc("simplify(0.1) circle(r=20, $fn=256);");
+    ASSERT_TRUE(cut.bodies[0].section.has_value());
+    EXPECT_NEAR(cut.bodies[0].section->Area(), plain.bodies[0].section->Area(),
+                0.01 * plain.bodies[0].section->Area());
+    EXPECT_LT(cut.bodies[0].section->Area(), plain.bodies[0].section->Area());
+}
+
+TEST(Simplify, NegativeToleranceWarnsAndPassesThrough) {
+    std::string last;
+    Evaluated e = evalSrc(std::string("simplify(-1) ") + kSimplifyModel + ";",
+                           [&](const std::string& m) { last = m; });
+    EXPECT_NE(last.find("must not be negative"), std::string::npos) << last;
+    Evaluated plain = evalSrc(std::string(kSimplifyModel) + ";");
+    EXPECT_EQ(soleBody(e).NumTri(), soleBody(plain).NumTri());
+}
+
+TEST(Simplify, NoChildrenIsEmpty) {
+    Evaluated e = evalSrc("simplify();");
+    EXPECT_TRUE(e.bodies.empty());
+}