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

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

@@ -591,7 +591,7 @@ grep for `ponytail:`.
   All 25 module/shape combinations were diffed against OpenSCAD 2026.02.01 warning for warning, with
   the surviving geometry compared by STL volume.
 
-- `src/builtins/topology.cpp` — `hull()`/`minkowski()`/`fill()`. All three splice their children transparently in
+- `src/builtins/topology.cpp` — `hull()`/`minkowski()`/`minkowski_difference()`/`fill()`. All four splice their children transparently in
   the CSG tree exactly like union/difference/intersection (resolve just evaluates them for the
   side effect); `hull()` picks an all-3D (`Manifold::Hull`) or all-2D (`CrossSection::Hull`) hull of
   the *foreground* (role-split) children, falling back to sections only when no child has a body;
@@ -604,6 +604,19 @@ grep for `ponytail:`.
   which matters because two outers can overlap once the holes between them are gone. Ported from
   the reference's `applyFill2D`, and checked shape-for-shape against OpenSCAD 2026.02.01 by
   extruding and comparing STL volumes.
+
+  `minkowski_difference()` is erosion, and a deliberate BelfrySCAD extension: OpenSCAD has no such
+  module and no way to spell the operation in the language, since `minkowski()` only ever sums.
+  Reads the same way — first child is the body, every child after it is a tool eroded away in turn
+  (`Manifold::MinkowskiDifference`). 3D only, matching `minkowski()`'s own 3D-wins dispatch, since
+  Manifold has no CrossSection erosion and 2D already has one in `offset(r=-N)`.
+
+  Worth knowing why this is a module rather than an extension of `offset()`: a *positive* 3D offset
+  is already expressible as `minkowski() { X; sphere(r); }`, so `offset(r=N)` on a solid would have
+  been pure sugar. Erosion is the half that is genuinely unavailable, and naming it after the
+  operation beats borrowing a 2D name for it. Eroding a cube by a cube is exact (no curved tool to
+  tessellate), which is what the tests assert on; a sphere tool lands a little large, and that gap
+  is the sphere's tessellation rather than an error in the erosion.
 - `src/builtins/extrude.cpp` — `linear_extrude()`/`rotate_extrude()`/`projection(cut=)`. All three
   union every 2D child into one `CrossSection` via `toCrossSection` first. `rotate_extrude`'s
   segment count can't be resolved until generate time (it depends on the merged children's bounds,

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

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

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

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

{openscad_cpp_evaluator-0.34.0 → openscad_cpp_evaluator-0.35.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 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,
+                                                      const oscad::ASTNode& node);
+
 CSGParams resolveFill(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateFill(Evaluator& ev, const CSGParams& params,
                                        const std::vector<std::unique_ptr<CSGNode>>& children,

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

@@ -35,6 +35,7 @@ const std::unordered_map<std::string_view, ResolveFn>& resolveDispatch() {
         {"projection", &resolveProjection},
         {"roof", &resolveRoof},
         {"fill", &resolveFill},
+        {"minkowski_difference", &resolveMinkowskiDifference},
         {"offset", &resolveOffset},
         {"surface", &resolveSurface},
         {"text", &resolveText},
@@ -74,6 +75,7 @@ const std::unordered_map<std::string_view, GenerateFn>& generateDispatch() {
         {"projection", &generateProjection},
         {"roof", &generateRoof},
         {"fill", &generateFill},
+        {"minkowski_difference", &generateMinkowskiDifference},
         {"offset", &generateOffset},
         {"surface", &generateSurface},
         {"text", &generateText},
@@ -119,6 +121,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         {"projection", {"cut", "convexity"}},
         {"roof", {"method", "convexity"}},
         {"fill", {}},
+        {"minkowski_difference", {}},
         {"offset", {"r", "delta", "chamfer"}},
         {"surface", {"file", "center", "convexity", "invert"}},
         {"text", {"text", "size", "font", "direction", "language", "script", "halign", "valign", "spacing"}},

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

@@ -313,4 +313,66 @@ std::vector<ColoredBody> generateMinkowski(Evaluator& ev, const CSGParams&, cons
     return out;
 }
 
+// minkowski_difference() -- erosion, the operation `minkowski()` has no
+// inverse for. A BelfrySCAD extension: OpenSCAD has no equivalent module and
+// no way to express it in the language, since minkowski() only ever sums.
+// Shrinking a part by a clearance, or hollowing one to a wall thickness,
+// otherwise needs hand-built difference() scaffolding that is not the same
+// operation.
+//
+// Reads like minkowski(): the first child is the body being eroded, and
+// every child after it is a tool eroded away from it in turn. 3D only, same
+// as minkowski()'s own 3D path -- Manifold has no CrossSection erosion, and
+// 2D already has one in offset(r=-N).
+
+CSGParams resolveMinkowskiDifference(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    (void)args;
+    ev.evalChildren(node.children, effCtx);
+    return CSGParams{};
+}
+
+std::vector<ColoredBody> generateMinkowskiDifference(Evaluator& ev, const CSGParams&,
+                                                      const std::vector<std::unique_ptr<CSGNode>>& children,
+                                                      const oscad::ASTNode& node) {
+    const std::vector<ColoredBody> bodies = flattenCsgTree(children);
+    const RoleSplit split = splitByRole(bodies);
+
+    std::vector<const ColoredBody*> bodies3d;
+    for (const ColoredBody& c : split.foreground) {
+        if (c.body) bodies3d.push_back(&c);
+    }
+
+    std::vector<ColoredBody> passthrough;
+    passthrough.insert(passthrough.end(), split.background.begin(), split.background.end());
+    passthrough.insert(passthrough.end(), split.highlight.begin(), split.highlight.end());
+    passthrough.insert(passthrough.end(), split.showOnly.begin(), split.showOnly.end());
+    passthrough.insert(passthrough.end(), split.displayOnly.begin(), split.displayOnly.end());
+
+    if (bodies3d.empty()) return passthrough;
+    if (bodies3d.size() == 1) {
+        // Nothing to erode with, so nothing happens -- the same no-op
+        // minkowski() gives for a single child.
+        std::vector<ColoredBody> result = {*bodies3d.front()};
+        result.insert(result.end(), passthrough.begin(), passthrough.end());
+        return result;
+    }
+
+    manifold::Manifold result = *bodies3d.front()->body;
+    for (size_t i = 1; i < bodies3d.size(); ++i) result = result.MinkowskiDifference(*bodies3d[i]->body);
+    if (result.Status() != manifold::Manifold::Error::NoError) {
+        ev.warn("minkowski_difference: result is not manifold", &node.position());
+    }
+
+    ColoredBody cb;
+    cb.body = std::move(result);
+    cb.color = bodies3d.front()->color;
+    // Per-triangle colour cannot survive an erosion: the surface it was
+    // indexed against is gone.
+    cb.triColors.reset();
+    std::vector<ColoredBody> out = {std::move(cb)};
+    out.insert(out.end(), passthrough.begin(), passthrough.end());
+    return out;
+}
+
 } // namespace oscadeval

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

@@ -620,3 +620,82 @@ TEST(MixedDimensions, UniformChildrenAreUntouched) {
     ASSERT_EQ(e.bodies.size(), 1u);
     EXPECT_NEAR(e.bodies[0].body->Volume(), 2.0, 1e-9);
 }
+
+// -- minkowski_difference() -----------------------------------------------
+//
+// Erosion: the operation minkowski() has no inverse for. A BelfrySCAD
+// extension, because OpenSCAD has no equivalent module and no way to spell
+// it in the language -- minkowski() only ever sums.
+//
+// Eroding a cube by a cube is exact (no curved tool to tessellate), so those
+// expectations are equalities rather than tolerances.
+
+TEST(MinkowskiDifference, ErodesACubeExactly) {
+    // A 10-cube eroded by a 2-cube is an 8-cube: every face moves in by the
+    // tool's half-width.
+    Evaluated e = evalSrc("minkowski_difference() { cube(10, center=true); cube(2, center=true); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 512.0, 1e-6);
+    const manifold::Box bb = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(bb.min.x, -4.0, 1e-9);
+    EXPECT_NEAR(bb.max.x, 4.0, 1e-9);
+}
+
+TEST(MinkowskiDifference, ErodesByASphereToWithinTessellation) {
+    // Same 8-cube, but the tool is a polyhedral sphere whose inradius is a
+    // touch under 1, so the result is a touch larger. That gap IS the
+    // tessellation and shrinks with $fn -- it is not an error in the erosion.
+    Evaluated e = evalSrc("minkowski_difference() { cube(10, center=true); sphere(1, $fn=64); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 512.0, 1.0);
+    EXPECT_GT(e.bodies[0].body->Volume(), 512.0);
+}
+
+TEST(MinkowskiDifference, ShrinksANonConvexBodyOnEverySide) {
+    // The case that motivates the module: a plate with holes, shrunk by a
+    // clearance. The bounding box must come in by the tool's radius all
+    // round -- 20x20x4 becomes 18x18x2.
+    Evaluated e = evalSrc(
+        "minkowski_difference() {"
+        "  difference() { cube([20,20,4], center=true);"
+        "                 for (x=[-6,0,6]) translate([x,0,0]) cylinder(h=6,r=2.5,center=true,$fn=24); }"
+        "  sphere(1, $fn=24); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    const manifold::Box bb = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(bb.max.x, 9.0, 0.05);
+    EXPECT_NEAR(bb.max.y, 9.0, 0.05);
+    EXPECT_NEAR(bb.max.z, 1.0, 0.05);
+}
+
+TEST(MinkowskiDifference, SingleChildIsANoOp) {
+    // Nothing to erode with, so nothing happens -- the same shape
+    // minkowski() gives a lone child back.
+    Evaluated e = evalSrc("minkowski_difference() { cube(10, center=true); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-9);
+}
+
+TEST(MinkowskiDifference, NoChildrenIsEmpty) {
+    Evaluated e = evalSrc("minkowski_difference();");
+    EXPECT_TRUE(e.bodies.empty());
+}
+
+TEST(MinkowskiDifference, ErodesSuccessivelyByEveryToolAfterTheFirst) {
+    // Two 2-cube tools take 1 off each side twice: 10 -> 8 -> 6.
+    Evaluated e = evalSrc(
+        "minkowski_difference() { cube(10, center=true); cube(2, center=true); cube(2, center=true); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 216.0, 1e-6);
+}
+
+TEST(MinkowskiDifference, TwoDeeChildrenAreIgnoredLikeMinkowskis) {
+    // 3D only, matching minkowski()'s own 3D-wins dispatch. 2D erosion
+    // already exists as offset(r=-N).
+    Evaluated e = evalSrc("minkowski_difference() { square(10); square(2); }");
+    EXPECT_TRUE(e.bodies.empty());
+}

{openscad_cpp_evaluator-0.34.0 → openscad_cpp_evaluator-0.35.0}/uv.lock

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