openscad-cpp-evaluator 1.24.0__tar.gz → 1.26.0__tar.gz

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/CLAUDE.md

@@ -946,6 +946,40 @@ grep for `ponytail:`.
   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.
 
+- `mesh_repair()` (also `topology.cpp`) — makes a broken mesh watertight, so geometry that was
+  merely *almost* closed can take part in CSG. Another BelfrySCAD extension: nothing in the language
+  could repair geometry, and a mesh from a library generator or an import is routinely a few
+  boundary edges short of a solid. The work is `repairMesh()`'s, already used by
+  `import(..., repair=true)`; this exposes the same six steps to any geometry — weld, drop
+  degenerate/duplicate, orient, fill holes, flip outward, strip zero-area faces.
+
+  **It reads `ColoredBody::rawMesh`, not `body`.** An open `polyhedron()` cannot build a Manifold,
+  so it keeps the raw triangle soup there and leaves `body` set but EMPTY. Repairing the empty
+  Manifold finds nothing to do and reports success at having done nothing, which is how the first
+  version of this failed silently. On success the soup is cleared, or `splitByRole()` keeps pulling
+  the body aside as un-CSG-able — the very thing the repair just fixed.
+
+  **The default tolerance is `GRID_FINE` (2⁻²⁰ ≈ 9.54e-7)**, OpenSCAD's own constant for deciding
+  two points are one, so a mesh that welds there welds here; it is exact in binary, so the
+  multiply-and-round in `weldMap()` adds no error. Deliberately tight, unlike `simplify()`'s
+  scale-relative default, because welding DISCARDS vertices: a default that quietly merged real
+  detail would be worse than one that leaves a mesh open, and hole filling closes what welding
+  declines to. `import(..., repair=true)` takes the same `tolerance=` argument for the same reason.
+
+  **Watertight is not the same as clean**, and the tolerance chooses. A gap whose rim is two
+  vertices that should be one closes either by welding (the duplicate disappears, no new geometry)
+  or by filling (the pair survives and step 4 stitches a triangle across). The filled patch is a
+  *needle* — two corners a hair apart — and step 6 will not remove it, because it strips
+  genuinely zero-area faces and a needle across a 2e-5 gap with its third corner 0.25 away has an
+  area around 2.5e-6. Thin, not degenerate. So a repaired-but-ugly mesh means the tolerance was too
+  small; the `polyhedron()` warning names a boundary edge's endpoints, so measure the gap and pass
+  a little more. A boundary loop of fewer than three edges — a crack, not a hole — has no fan to
+  build at all and is reported as left open; only a coarser weld closes that.
+
+  Not a substitute for a generator that emits a closed mesh: repair costs a full pass over the
+  geometry every render. Prompted by BelfrySCAD #521, where BOSL2's `isosurface()` computed a shared
+  voxel corner once per voxel and let the results drift 2e-5 apart.
+
 - `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
@@ -1653,6 +1687,20 @@ the former is worth dragging.
 A cache hit restamps to the chain reaching the geometry *now*, not the one that
 first produced it: a module called twice genuinely is two call chains.
 
+**A 2D shape is picked by `ColoredBody::sectionId`.** A `CrossSection` is contours
+with no run IDs, so a top-level 2D shape had no `idToNode` entry at all: its preview
+slab got fresh IDs from `Manifold::Extrude` in `toRenderableBodies`, after the table
+was built, and a click on it mapped to no source (it blocked BelfrySCAD's extrude
+gizmo, which exists to act on exactly those). Now the generate loop calls
+`tagSections` after every builtin's `GenerateFn`: any 2D body without an ID gets one
+reserved from Manifold's counter, attributed to that node. A transform keeps the ID
+it was given (it edits the body in place), so a 2D shape stays its primitive, as a
+solid's runs do; an op that builds a *new* section -- a 2D `union()`, `offset()`,
+`hull()` -- claims it, so the whole union is one pick. `restampCachedIds` restamps it
+by the solid rule (across renders, to the reused node), `recordRunColors` records its
+colour, and `toRenderableBodies` rebuilds the slab from a `MeshGL` whose one run
+carries it. Tested in `tests/test_python_bindings.py` (`_picked_text`).
+
 No stored script path is needed to tell the user's file from a library:
 `callStack_.front()` is by construction the call made from top level.
 
@@ -1661,7 +1709,7 @@ Exposed to Python as `node.call_sites` (innermost-first `_CallFrame`s, each a
 
 `Evaluator::measuring_` is set for the whole generate. It suppresses the four
 writes that exist solely to describe *drawn* geometry — `idToNode`/`idToColor`/`idToCallChain` in
-`tagGenerated` and `tagDisplayOnly`, the `restampCachedIds` call on a cache hit,
+`tagGenerated`, `tagDisplayOnly` and `tagSections`, the `restampCachedIds` call on a cache hit,
 and `cacheProducer_` — because those tables are cleared once per pass, so a leak
 is permanent and surfaces later as wrong click-to-source. It also suppresses
 `checkDebug`, which would otherwise inject stops at the paused statement's own

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -42,6 +42,15 @@ struct ColoredBody {
     std::optional<manifold::CrossSection> section;
     bool flatPreview = false;
 
+    // The originalID a 2D `section` is picked by. A CrossSection is contours
+    // and carries no run IDs, so a 2D shape had no entry in idToNode and a
+    // click on its preview slab mapped to no source at all. Reserved from
+    // Manifold's own counter (so it cannot collide with a solid's ID) by the
+    // generate loop, for the node that built the section -- a primitive, or
+    // an op like union() that made a new one; a transform keeps the one it
+    // was given. toRenderableBodies() gives the slab this ID.
+    std::optional<uint32_t> sectionId;
+
     // What a 2D `section` has been transformed BY that a CrossSection
     // cannot itself hold: a translation along Z, a rotation out of the XY
     // plane, anything with a Z component. Applied when

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -283,6 +283,9 @@ public:
     // attributes there).
     // Give cached bodies fresh originalIDs so a second call site reusing
     // them is not confused with the first. See its definition.
+    // Give every 2D body in `bodies` that has no sectionId yet one of its
+    // own, attributed to `node`. See ColoredBody::sectionId.
+    void tagSections(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node, uint32_t callChain);
     void restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node,
                           const oscad::ASTNode* producer, uint32_t callChain);
 

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/include/openscad_cpp_evaluator/mesh_check.hpp

@@ -82,6 +82,15 @@ struct MeshRepairReport {
     std::string summary() const;
 };
 
+//: Default welding tolerance: OpenSCAD's own GRID_FINE, 2^-20. Theirs is
+//: the constant their Grid.h uses to decide two points are one, so a mesh
+//: that welds there welds here. Exact in binary, so the multiply-and-round
+//: in weldMap() adds no error of its own. Deliberately tight: welding
+//: DISCARDS vertices, and a default that quietly merged real detail would
+//: be worse than one that leaves a mesh open -- hole filling closes what
+//: welding declines to. See issue #190.
+constexpr double kDefaultWeldTolerance = 0.00000095367431640625;
+
 // Best-effort repair, in the only order that works: welding first (it
 // changes which edges are shared, so every later test depends on it), then
 // degenerate and duplicate removal, then orientation, then hole filling
@@ -91,9 +100,10 @@ struct MeshRepairReport {
 // Returns the repaired mesh. A mesh it cannot close is still returned,
 // improved as far as it got, with the remainder reported in `report`.
 template <typename M>
-M repairMesh(const M& mesh, MeshRepairReport& report);
-extern template manifold::MeshGL repairMesh<manifold::MeshGL>(const manifold::MeshGL&, MeshRepairReport&);
-extern template manifold::MeshGL64 repairMesh<manifold::MeshGL64>(const manifold::MeshGL64&, MeshRepairReport&);
+M repairMesh(const M& mesh, MeshRepairReport& report,
+             double tolerance = kDefaultWeldTolerance);
+extern template manifold::MeshGL repairMesh<manifold::MeshGL>(const manifold::MeshGL&, MeshRepairReport&, double);
+extern template manifold::MeshGL64 repairMesh<manifold::MeshGL64>(const manifold::MeshGL64&, MeshRepairReport&, double);
 
 struct SliverStripReport {
     size_t removed = 0;        // zero-area faces taken out

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/src/builtins/builtins.hpp

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

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/src/builtins/function_builtins.cpp

@@ -1011,6 +1011,7 @@ const std::unordered_map<std::string, double>& featureLevels() {
         {"sphere-styles", 1.0},      // sphere(style=)
         {"export-name", 1.0},        // $export_name
         {"simplify-op", 1.0},        // simplify()
+        {"mesh-repair", 1.0},        // mesh_repair(), and import(tolerance=)
         {"expr-import", 1.0},        // import() in expression position
         {"object-function", 1.0},    // object(), unconditional here
         {"roof-op", 1.0},            // roof(), method="voronoi" only

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/src/builtins/import.cpp

@@ -186,6 +186,10 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
     // Not an OpenSCAD parameter. A script using it will not run upstream,
     // which is why it has to be asked for rather than being the default.
     const bool repair = truthy(getArg(args, std::nullopt, "repair", Value{false}));
+    // How far apart two vertices may be and still be welded into one.
+    // Named rather than hidden so import() and mesh_repair() answer the
+    // same question the same way (issue #190); undef keeps the default.
+    const Value toleranceArg = getArg(args, std::nullopt, "tolerance", Value{});
 
     CSGParams params;
     params["color"] = colorToValue(effCtx.color);
@@ -255,6 +259,7 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
         }
         params["kind"] = Value{std::string("mesh")};
         params["repair"] = Value{repair};
+        params["tolerance"] = toleranceArg;
         params["verts"] = Value{std::make_shared<const ValueList>(ValueList{std::move(vertsFlat)})};
         params["tris"] = Value{std::make_shared<const ValueList>(ValueList{std::move(trisFlat)})};
         return params;
@@ -315,9 +320,23 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
     const auto repairIt = params.find("repair");
     const bool repair = repairIt != params.end() && truthy(repairIt->second);
     if (repair) {
+        double tolerance = kDefaultWeldTolerance;
+        const auto tolIt = params.find("tolerance");
+        if (tolIt != params.end()) {
+            if (const double* t = std::get_if<double>(&tolIt->second)) {
+                if (*t < 0.0) {
+                    ev.warn("import: tolerance must not be negative; using the default",
+                            &node.position());
+                } else {
+                    tolerance = *t;
+                }
+            } else if (!std::holds_alternative<std::monostate>(tolIt->second)) {
+                ev.warn("import: tolerance must be a number", &node.position());
+            }
+        }
         const MeshDiagnosis before = checkMesh(mesh);
         MeshRepairReport rep;
-        manifold::MeshGL64 fixed = repairMesh(mesh, rep);
+        manifold::MeshGL64 fixed = repairMesh(mesh, rep, tolerance);
         const MeshDiagnosis after = checkMesh(fixed);
         if (rep.didAnything()) {
             ev.warn("import: repaired the mesh -- " + rep.summary(), &node.position());
@@ -344,7 +363,9 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
         if (why.empty()) why = manifoldErrorName(body.Status());
         if (!ev.insideHull) {
             ev.warn("import: mesh is not a closed solid (" + why +
-                        "); drawing it as a surface. hull() can still use its points, but "
+                        // Same rewording as polyhedron's: see the comment there.
+                        "); drawing the object as an open surface rather than a solid "
+                        "-- nothing is patched. hull() can still use its points, but "
                         "it cannot take part in union/difference/intersection" +
                         std::string(repair ? "" : ". Try import(..., repair=true)"),
                     &node.position());

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/src/builtins/primitives_3d.cpp

@@ -854,7 +854,15 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
                 open.first ? ", first at " + describeEdge(mesh, *open.first) : std::string();
             ev.warn("polyhedron: mesh is not closed -- " + std::to_string(open.count) +
                         " boundary edge(s)" + where +
-                        "; drawing it as a surface. hull() can still "
+                        // "drawing it as a surface" was read by a reporter as
+                        // the HOLE being surfaced over -- i.e. as automatic
+                        // repair hiding their defect. Nothing is repaired: the
+                        // mesh is drawn as the open surface it is. Name the
+                        // object as the thing being drawn, and say what it is
+                        // NOT, since "surface" alone does not imply "not solid"
+                        // to someone who did not know it could be either.
+                        "; drawing the object as an open surface rather than a "
+                        "solid -- nothing is patched. hull() can still "
                         "use its points, but it cannot take part in union/difference/intersection",
                     &node.position());
         }

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/src/builtins/registry.cpp

@@ -37,6 +37,7 @@ const std::unordered_map<std::string_view, ResolveFn>& resolveDispatch() {
         {"fill", &resolveFill},
         {"minkowski_difference", &resolveMinkowskiDifference},
         {"simplify", &resolveSimplify},
+        {"mesh_repair", &resolveMeshRepair},
         {"levelset", &resolveLevelSet},
         {"offset", &resolveOffset},
         {"surface", &resolveSurface},
@@ -79,6 +80,7 @@ const std::unordered_map<std::string_view, GenerateFn>& generateDispatch() {
         {"fill", &generateFill},
         {"minkowski_difference", &generateMinkowskiDifference},
         {"simplify", &generateSimplify},
+        {"mesh_repair", &generateMeshRepair},
         {"levelset", &generateLevelSet},
         {"offset", &generateOffset},
         {"surface", &generateSurface},
@@ -122,7 +124,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         // full and quietly given the whole drawing.)
         {"import",
           {"file", "layer", "convexity", "origin", "scale", "width", "height", "filename", "layername", "center", "dpi",
-           "id", "class", "repair"}},
+           "id", "class", "repair", "tolerance"}},
         {"linear_extrude", {"height", "v", "scale", "center", "twist", "slices", "segments", "convexity"}},
         {"rotate_extrude", {"angle", "start", "convexity"}},
         {"projection", {"cut", "convexity"}},
@@ -130,6 +132,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         {"fill", {}},
         {"minkowski_difference", {}},
         {"simplify", {"tolerance"}},
+        {"mesh_repair", {"tolerance"}},
         {"levelset", {"field", "bounds", "isovalue", "invert", "edge"}},
         {"offset", {"r", "delta", "chamfer"}},
         {"surface", {"file", "center", "convexity", "invert"}},

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/src/builtins/topology.cpp

@@ -2,6 +2,7 @@
 
 #include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/evaluator.hpp"
+#include "openscad_cpp_evaluator/mesh_check.hpp"
 
 #include <manifold/polygon.h>
 
@@ -503,6 +504,117 @@ std::vector<ColoredBody> generateSimplify(Evaluator& ev, const CSGParams& params
     return out;
 }
 
+// mesh_repair(tolerance) -- make a broken mesh watertight. A BelfrySCAD
+// extension: nothing in the OpenSCAD language can repair geometry, and a
+// mesh arriving from a library generator or an import is routinely almost
+// closed rather than closed. See issue #190.
+//
+// The work is repairMesh()'s, already used by import(..., repair=true);
+// this exposes the same six steps to any geometry, not only imported
+// files: weld, drop degenerate/duplicate, orient, fill holes, flip
+// outward, strip zero-area faces.
+//
+// NOT a substitute for a generator that emits a closed mesh. Repair costs
+// a full pass over the geometry every render, and welding discards
+// vertices -- which is why the default tolerance is tight enough to
+// weld only what is unambiguously one point, leaving hole filling to
+// close the rest.
+
+CSGParams resolveMeshRepair(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    CSGParams params;
+    // Position 0, so mesh_repair(0.001) reads the way simplify(0.1) does.
+    params["tolerance"] = getArg(args, 0, "tolerance", Value{});
+    EvalContext blockCtx = ev.blockScope(effCtx);
+    ev.evalChildren(node.children, blockCtx);
+    return params;
+}
+
+std::vector<ColoredBody> generateMeshRepair(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");
+    double tolerance = kDefaultWeldTolerance;
+    if (std::holds_alternative<double>(tolArg)) {
+        tolerance = std::get<double>(tolArg);
+        if (tolerance < 0.0) {
+            ev.warn("mesh_repair: tolerance must not be negative", &node.position());
+            return bodies;
+        }
+    } else if (!std::holds_alternative<std::monostate>(tolArg)) {
+        ev.warn("mesh_repair: tolerance must be a number", &node.position());
+    }
+
+    std::vector<ColoredBody> out;
+    out.reserve(bodies.size());
+    for (const ColoredBody& b : bodies) {
+        // Background/highlight geometry is a debugging aid, not part of the
+        // model; repairing it would spend the pass and say nothing useful.
+        // A 2D section has no mesh to repair either.
+        if (b.role != BodyRole::Normal || (!b.body && !b.rawMesh)) {
+            out.push_back(b);
+            continue;
+        }
+        // The case this module exists for: polyhedron() could not build a
+        // Manifold from an open mesh, so it kept the raw soup in rawMesh
+        // and left `body` set but EMPTY (see ColoredBody::rawMesh). Repair
+        // the soup -- repairing the empty Manifold would find nothing to
+        // do and report success at having done nothing.
+        MeshRepairReport report;
+        ColoredBody cb = b;
+        manifold::MeshGL64 fixed;
+        if (b.rawMesh) {
+            manifold::MeshGL64 soup;
+            soup.numProp = b.rawMesh->numProp;
+            soup.vertProperties.assign(b.rawMesh->vertProperties.begin(),
+                                        b.rawMesh->vertProperties.end());
+            soup.triVerts.assign(b.rawMesh->triVerts.begin(), b.rawMesh->triVerts.end());
+            fixed = repairMesh(soup, report, tolerance);
+        } else {
+            fixed = repairMesh(b.body->GetMeshGL64(), report, tolerance);
+        }
+        if (report.didAnything()) {
+            manifold::Manifold rebuilt(fixed);
+            if (rebuilt.Status() == manifold::Manifold::Error::NoError) {
+                cb.body = std::move(rebuilt);
+                // It is a real solid now, so stop carrying the display-only
+                // soup: leaving it set would keep splitByRole() pulling the
+                // body aside as un-CSG-able, which is the whole thing the
+                // repair just fixed.
+                cb.rawMesh.reset();
+                // triColors is indexed by triangle, and repair changes how
+                // many there are -- filling adds, sliver stripping removes.
+                // Carrying it across would mask an N-triangle mesh with an
+                // M-entry array, which is an IndexError rather than a wrong
+                // colour. Same reasoning as simplify()'s.
+                cb.triColors.reset();
+                ev.warn("mesh_repair: " + report.summary(), &node.position());
+            } else {
+                // Say what it could not do. Silently returning the original
+                // would leave the author believing a repair happened.
+                ev.warn("mesh_repair: could not rebuild the repaired mesh (" +
+                            std::string(manifoldErrorName(rebuilt.Status())) +
+                            "); geometry left unchanged",
+                        &node.position());
+            }
+        }
+        if (report.unfilledHoles) {
+            // The sub-3-edge boundary loop: a crack between two nearly
+            // coincident vertices, with no fan to build. Only a coarser
+            // weld closes it, so name the knob rather than just the count.
+            ev.warn("mesh_repair: " + std::to_string(report.unfilledHoles) +
+                        " hole(s) left open -- a crack too narrow to fill needs a"
+                        " larger tolerance to weld shut instead",
+                    &node.position());
+        }
+        out.push_back(std::move(cb));
+    }
+    return out;
+}
+
 // -- levelset(field, bounds, isovalue) -------------------------------------
 //
 // A solid from a grid of sampled values. Wraps Manifold::LevelSet with a C++

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/src/colored_body.cpp

@@ -37,6 +37,18 @@ std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodi
         if (!cb.body && cb.section) {
             ColoredBody flat;
             flat.body = manifold::Manifold::Extrude(cb.section->ToPolygons(), kTopLevel2dHeight);
+            if (cb.sectionId && !flat.body->IsEmpty()) {
+                // One run carrying the section's own ID, so a click on the
+                // slab finds the node that built the shape (see
+                // ColoredBody::sectionId). Manifold keeps a MeshGL's
+                // runOriginalID when it is given one.
+                manifold::MeshGL mesh = flat.body->GetMeshGL();
+                mesh.runOriginalID = {*cb.sectionId};
+                mesh.runIndex = {0, static_cast<uint32_t>(mesh.triVerts.size())};
+                mesh.runTransform.clear();
+                mesh.faceID.clear();
+                flat.body = manifold::Manifold(mesh);
+            }
             // Put it back where the transforms a CrossSection could not
             // hold would have placed it -- a Z offset, a rotation out of
             // the plane. See ColoredBody::sectionXform.

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/src/csg_generate.cpp

@@ -124,6 +124,7 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
                 generateWarnEntry = node.warnEntry;
                 generateCallChain = node.callChain;
                 node.bodies = it->second(*this, node.params, node.children, *node.node);
+                if (!measuring_) tagSections(node.bodies, *node.node, node.callChain);
                 generateWarnEntry = savedWarnEntry;
                 generateCallChain = savedCallChain;
             } else {
@@ -393,6 +394,16 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
     // its producer check keeps the first copy's descendants. They occupy
     // the same space, so there is nothing to select apart.
     for (ColoredBody& cb : bodies) {
+        // A 2D body's one ID, restamped by the same rule as a solid's runs.
+        if (cb.sectionId) {
+            const uint32_t fresh = manifold::Manifold::ReserveIDs(1);
+            auto old = idToNode.find(*cb.sectionId);
+            idToNode[fresh] =
+                (old != idToNode.end() && old->second != producer) ? old->second : &node;
+            idToCallChain[fresh] = callChain;
+            idToColor[fresh] = cb.color;
+            cb.sectionId = fresh;
+        }
         if (!cb.body || cb.body->IsEmpty()) continue;
         manifold::MeshGL mesh = cb.body->GetMeshGL();
         if (mesh.runOriginalID.empty()) continue;
@@ -475,6 +486,7 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
 
 
 void Evaluator::recordRunColors(ColoredBody& b, const std::optional<std::array<float, 4>>& rgba) {
+    if (b.sectionId) idToColor[*b.sectionId] = rgba;
     if (!b.body || bodyIsEmpty(b)) return;
     // A body that is still one original knows its own ID without building
     // a mesh -- the common case, and the cheap one.
@@ -486,6 +498,18 @@ void Evaluator::recordRunColors(ColoredBody& b, const std::optional<std::array<f
     for (uint32_t id : b.body->GetMeshGL().runOriginalID) idToColor[id] = rgba;
 }
 
+void Evaluator::tagSections(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node,
+                            uint32_t callChain) {
+    for (ColoredBody& cb : bodies) {
+        if (!cb.section || cb.body || cb.sectionId) continue;
+        const uint32_t id = manifold::Manifold::ReserveIDs(1);
+        idToNode[id] = &node;
+        idToColor[id] = cb.color;
+        idToCallChain[id] = callChain;
+        cb.sectionId = id;
+    }
+}
+
 ColoredBody Evaluator::tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue) {
     manifold::MeshGL mesh = body.GetMeshGL();
     std::optional<std::array<float, 4>> color = valueToColor(colorValue);

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/src/mesh_check.cpp

@@ -309,7 +309,7 @@ namespace {
 // this: unwelded duplicates split one shared edge into two boundary edges,
 // so a mesh that is really closed reads as full of holes until it is done.
 template <typename M>
-std::vector<Vert> weldMap(const M& m, size_t& welded) {
+std::vector<Vert> weldMap(const M& m, size_t& welded, double tolerance) {
     const size_t stride = m.numProp ? m.numProp : 3;
     const size_t n = stride ? m.vertProperties.size() / stride : 0;
     std::vector<Vert> remap(n);
@@ -332,12 +332,17 @@ std::vector<Vert> weldMap(const M& m, size_t& welded) {
         }
         bool samePos(const Keyed& o) const { return x == o.x && y == o.y && z == o.z; }
     };
+    // Snap to a grid of `tolerance`. Guarded because a caller can pass 0 or
+    // a negative to mean "weld only exact duplicates" -- dividing by that
+    // would give inf/NaN keys and weld the whole mesh into one point.
+    const double inv = tolerance > 0.0 ? 1.0 / tolerance : 0.0;
     std::vector<Keyed> keyed;
     keyed.reserve(n);
     for (size_t v = 0; v < n; ++v) {
         double p[3];
         pos(m, static_cast<Vert>(v), p);
-        keyed.push_back({llround(p[0] * 1e6), llround(p[1] * 1e6), llround(p[2] * 1e6), static_cast<Vert>(v)});
+        keyed.push_back({llround(p[0] * inv), llround(p[1] * inv), llround(p[2] * inv),
+                         static_cast<Vert>(v)});
     }
     std::sort(keyed.begin(), keyed.end());
     for (size_t i = 0; i < keyed.size();) {
@@ -400,14 +405,14 @@ std::vector<std::vector<Vert>> boundaryLoops(const std::vector<std::array<Vert,
 }  // namespace
 
 template <typename M>
-M repairMesh(const M& mesh, MeshRepairReport& report) {
+M repairMesh(const M& mesh, MeshRepairReport& report, double tolerance) {
     report = MeshRepairReport{};
     M out = mesh;
 
     // 1. Weld. Must come first -- it decides which edges are shared, and
     //    every later step reads the edge map.
     size_t welded = 0;
-    const std::vector<Vert> remap = weldMap(mesh, welded);
+    const std::vector<Vert> remap = weldMap(mesh, welded, tolerance);
     report.weldedVertices = welded;
 
     // Remap every face, then find the duplicates by sorting rather than by
@@ -850,8 +855,8 @@ M stripSlivers(const M& mesh, SliverStripReport& report) {
 // header, keeps compile times where they were.
 template MeshDiagnosis checkMesh<manifold::MeshGL>(const manifold::MeshGL&);
 template MeshDiagnosis checkMesh<manifold::MeshGL64>(const manifold::MeshGL64&);
-template manifold::MeshGL repairMesh<manifold::MeshGL>(const manifold::MeshGL&, MeshRepairReport&);
-template manifold::MeshGL64 repairMesh<manifold::MeshGL64>(const manifold::MeshGL64&, MeshRepairReport&);
+template manifold::MeshGL repairMesh<manifold::MeshGL>(const manifold::MeshGL&, MeshRepairReport&, double);
+template manifold::MeshGL64 repairMesh<manifold::MeshGL64>(const manifold::MeshGL64&, MeshRepairReport&, double);
 template manifold::MeshGL stripSlivers<manifold::MeshGL>(const manifold::MeshGL&, SliverStripReport&);
 template manifold::MeshGL64 stripSlivers<manifold::MeshGL64>(const manifold::MeshGL64&, SliverStripReport&);
 

{openscad_cpp_evaluator-1.24.0 → openscad_cpp_evaluator-1.26.0}/tests/test_booleans.cpp

@@ -1660,3 +1660,99 @@ TEST(CsgTree, InnerNodeBodiesAreReleasedOnceTheParentHasConsumedThem) {
     Evaluated plain = evalSrc("union() { cube(1); sphere(1); }"); // the union really was consumed first
     EXPECT_NEAR(e.bodies[0].body->Volume(), plain.bodies[0].body->Volume(), 1e-9);
 }
+
+// -- mesh_repair() ----------------------------------------------------------
+//
+// Issue #190, out of BelfrySCAD #521: a mesh that is almost closed is not a
+// solid, and nothing in the language could make it one. The repair itself is
+// repairMesh()'s, already covered in test_mesh_check.cpp; these cover the
+// module -- that it reaches the raw soup polyhedron() keeps, that the result
+// is a real solid, and that tolerance does what it claims.
+
+namespace {
+// A 20-cube with its lid left off: five faces, four boundary edges.
+const char* kOpenCube =
+    "polyhedron(points=[[-10,-10,-10],[10,-10,-10],[10,10,-10],[-10,10,-10],"
+    "                   [-10,-10, 10],[10,-10, 10],[10,10, 10],[-10,10, 10]],"
+    "           faces=[[0,1,2,3],[4,7,6,5],[0,4,5,1],[1,5,6,2],[2,6,7,3]]);";
+} // namespace
+
+TEST(MeshRepairModule, TurnsAnOpenMeshIntoASolid) {
+    // Unrepaired, polyhedron() cannot build a Manifold at all: it keeps the
+    // triangle soup for display and leaves an EMPTY body behind.
+    Evaluated broken = evalSrc(kOpenCube);
+    ASSERT_EQ(broken.bodies.size(), 1u);
+    EXPECT_TRUE(broken.bodies[0].rawMesh.has_value());
+    EXPECT_DOUBLE_EQ(broken.bodies[0].body->Volume(), 0.0);
+
+    Evaluated fixed = evalSrc(std::string("mesh_repair() ") + kOpenCube);
+    ASSERT_EQ(fixed.bodies.size(), 1u);
+    // The soup is gone: splitByRole() would otherwise keep pulling this
+    // aside as un-CSG-able, which is the thing the repair just fixed.
+    EXPECT_FALSE(fixed.bodies[0].rawMesh.has_value());
+    EXPECT_NEAR(fixed.bodies[0].body->Volume(), 20.0 * 20 * 20, 1e-6);
+    EXPECT_EQ(fixed.bodies[0].body->Status(), manifold::Manifold::Error::NoError);
+}
+
+TEST(MeshRepairModule, TheResultCanTakePartInCSG) {
+    // The whole point. An unrepaired open mesh is display-only.
+    Evaluated cut = evalSrc(std::string("difference() { mesh_repair() ") + kOpenCube +
+                            " cube(10, center=true); }");
+    ASSERT_EQ(cut.bodies.size(), 1u);
+    EXPECT_NEAR(cut.bodies[0].body->Volume(), 20.0 * 20 * 20 - 10.0 * 10 * 10, 1e-6);
+}
+
+TEST(MeshRepairModule, SaysWhatItDid) {
+    std::string said;
+    evalSrc(std::string("mesh_repair() ") + kOpenCube,
+            [&](const std::string& m) { if (m.find("mesh_repair") != std::string::npos && said.empty()) said = m; });
+    EXPECT_NE(said.find("hole filled"), std::string::npos) << said;
+}
+
+TEST(MeshRepairModule, LeavesAClosedMeshAloneAndSaysNothing) {
+    const char* closed = "cube(10, center=true);";
+    std::string said;
+    Evaluated e = evalSrc(std::string("mesh_repair() ") + closed,
+                          [&](const std::string& m) { if (said.empty()) said = m; });
+    EXPECT_EQ(said, "");
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-6);
+}
+
+TEST(MeshRepairModule, ToleranceWeldsVerticesThatTheDefaultLeavesSplit) {
+    // Two cubes sharing a face, with the shared corners 1e-3 apart -- far
+    // above GRID_FINE, so the default welds nothing and only hole filling
+    // closes it. A tolerance covering the gap welds instead, and the two
+    // routes are distinguishable by triangle count: filling ADDS faces.
+    const char* split =
+        "polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0],"
+        "                   [0,0,10],[10,0,10],[10,10,10],[0.001,10,10]],"
+        "           faces=[[0,1,2,3],[4,7,6,5],[0,4,5,1],[1,5,6,2],[2,6,7,3],[3,7,4,0]]);";
+    Evaluated tight = evalSrc(std::string("mesh_repair() ") + split);
+    Evaluated loose = evalSrc(std::string("mesh_repair(0.01) ") + split);
+    ASSERT_EQ(tight.bodies.size(), 1u);
+    ASSERT_EQ(loose.bodies.size(), 1u);
+    // Both must end up solid; the looser weld should not need more geometry
+    // than the tighter one.
+    EXPECT_EQ(tight.bodies[0].body->Status(), manifold::Manifold::Error::NoError);
+    EXPECT_EQ(loose.bodies[0].body->Status(), manifold::Manifold::Error::NoError);
+    EXPECT_LE(loose.bodies[0].body->NumTri(), tight.bodies[0].body->NumTri());
+}
+
+TEST(MeshRepairModule, RejectsANegativeTolerance) {
+    // polyhedron() warns about the open mesh first, so pick out ours.
+    std::string said;
+    evalSrc(std::string("mesh_repair(-1) ") + kOpenCube,
+            [&](const std::string& m) {
+                if (said.empty() && m.find("mesh_repair") != std::string::npos) said = m;
+            });
+    EXPECT_NE(said.find("must not be negative"), std::string::npos) << said;
+}
+
+TEST(MeshRepairModule, IsAdvertisedBySupportedFeature) {
+    // A portable script guards on the capability before calling the module,
+    // since mesh_repair() is an extension and will not parse upstream.
+    std::string said;
+    evalSrc("echo(supported_feature(\"mesh-repair\"));",
+            [&](const std::string& m) { if (said.empty()) said = m; });
+    EXPECT_NE(said.find("1"), std::string::npos) << said;
+}