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

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

@@ -584,6 +584,24 @@ grep for `ponytail:`.
   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.36.0 → openscad_cpp_evaluator-0.37.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.36.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.36.0"
+version = "0.37.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-0.36.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.36.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},
@@ -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.36.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.36.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());
+}

{openscad_cpp_evaluator-0.36.0 → openscad_cpp_evaluator-0.37.0}/uv.lock

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