openscad-cpp-evaluator 1.23.1__tar.gz → 1.25.0__tar.gz

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.25.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

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.25.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.25.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -398,6 +398,14 @@ public:
     // than anything reentrancy-aware, since generateTreeImpl recurses
     // depth-first on one thread.
     const oscad::Position* generateWarnEntry = nullptr;
+    // Non-null while generateTreeImpl() is generating a subtree whose result
+    // it intends to cache: warn() appends each formatted line here as well as
+    // emitting it, so the entry can replay them on a later hit. Saved and
+    // restored around each node rather than left set, and the inner vector is
+    // merged into the outer one on the way out, so a parent's entry carries
+    // everything its whole subtree said -- which is what a parent-level hit
+    // has to reproduce, since it skips all of it. See ManifoldCache.
+    std::vector<std::string>* warnCapture = nullptr;
     // The same republish for CSGNode::callChain, read by tagGenerated to
     // fill idToCallChain.
     uint32_t generateCallChain = kNoCallChain;
@@ -530,6 +538,10 @@ public:
     // Public: builtins/import.cpp's not-manifold warning is emitted from a
     // free function, same reasoning as tagGenerated()/builtinChildren().
     void warn(const std::string& message, const oscad::Position* position);
+    // Hands one already-formatted warning line to echoFn_, recording it in
+    // warnCapture first when one is active. Every warning path goes through
+    // here, including a ManifoldCache hit replaying a cached line.
+    void emitWarning(const std::string& formatted);
 
     // Applies OpenSCAD's mixed-2D/3D rules to a node's children just
     // before its GenerateFn runs -- see csg_generate.cpp.

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.25.0}/include/openscad_cpp_evaluator/manifold_cache.hpp

@@ -3,6 +3,7 @@
 #include "openscad_cpp_evaluator/csg_node.hpp"
 
 #include <mutex>
+#include <vector>
 #include <optional>
 #include <string>
 #include <unordered_map>
@@ -22,15 +23,28 @@ namespace oscadeval {
 // threading.Lock -- a host may run renders/evaluates on a background
 // thread while another operation reads/clears the same cache). Mirrors
 // the reference's ManifoldCache class.
+// What one cache entry holds. The warnings matter as much as the bodies:
+// a hit skips the whole subtree's GenerateFn, and every generate-time
+// diagnostic is raised *inside* one of those (polyhedron's "mesh is not
+// closed", import()'s failures, the dimension rules). Cached without them,
+// a second render of unchanged source silently dropped every warning the
+// first one raised, so a real defect looked intermittent and the author
+// went hunting for a phantom. A cache has to be transparent; that includes
+// what it says, not only what it draws. See BelfrySCAD issue #521.
+struct CachedSubtree {
+    std::vector<ColoredBody> bodies;
+    std::vector<std::string> warnings;  // already formatted, replayed verbatim
+};
+
 class ManifoldCache {
 public:
-    std::optional<std::vector<ColoredBody>> get(const std::string& key) const;
-    void put(std::string key, std::vector<ColoredBody> bodies);
+    std::optional<CachedSubtree> get(const std::string& key) const;
+    void put(std::string key, std::vector<ColoredBody> bodies, std::vector<std::string> warnings);
     void clear();
 
 private:
     mutable std::mutex mutex_;
-    std::unordered_map<std::string, std::vector<ColoredBody>> entries_;
+    std::unordered_map<std::string, CachedSubtree> entries_;
 };
 
 // Structural content-hash key for `node`, used by generateTree()'s

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.25.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.23.1 → openscad_cpp_evaluator-1.25.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.25.0}/src/CMakeLists.txt

@@ -69,3 +69,37 @@ target_link_libraries(openscad_cpp_evaluator PRIVATE linenoise freetype harfbuzz
 target_compile_options(openscad_cpp_evaluator PRIVATE
   $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall;-Wextra>
 )
+
+# -Wall -Wextra above is about OUR code, but two TUs pull a vendored header
+# in wholesale and inherit its warnings: 27 from Boost.Polygon's voronoi
+# headers and 9 from stb_image_write's implementation, against 5 that were
+# real. Silenced per source file, per warning.
+#
+# Deliberately NOT -isystem, which looks like the tidier fix and is a trap:
+# clang searches -isystem AFTER /usr/local/include, so a Homebrew Boost
+# 1.90 silently won over the pinned 1.86 (measured, not assumed). Keeping
+# -I keeps the fetched copy winning.
+include(CheckCXXCompilerFlag)
+foreach(_w deprecated-enum-float-conversion missing-field-initializers deprecated-declarations)
+  check_cxx_compiler_flag("-Wno-${_w}" OSCAD_HAS_WNO_${_w})
+endforeach()
+
+if(OSCAD_HAS_WNO_deprecated-enum-float-conversion)
+  # <boost/polygon/voronoi.hpp> does floating-point arithmetic on an
+  # unnamed enum, deprecated in C++20.
+  set_source_files_properties(builtins/roof.cpp PROPERTIES
+    COMPILE_OPTIONS "-Wno-deprecated-enum-float-conversion")
+endif()
+
+# zip_stored.cpp defines STB_IMAGE_WRITE_IMPLEMENTATION, so stb's C compiles
+# as ours: `= { 0 }` partial initializers, and one sprintf().
+set(_stb_quiet "")
+if(OSCAD_HAS_WNO_missing-field-initializers)
+  list(APPEND _stb_quiet "-Wno-missing-field-initializers")
+endif()
+if(OSCAD_HAS_WNO_deprecated-declarations)
+  list(APPEND _stb_quiet "-Wno-deprecated-declarations")
+endif()
+if(_stb_quiet)
+  set_source_files_properties(zip_stored.cpp PROPERTIES COMPILE_OPTIONS "${_stb_quiet}")
+endif()

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.25.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.23.1 → openscad_cpp_evaluator-1.25.0}/src/builtins/function_builtins.cpp

@@ -837,38 +837,6 @@ Value builtinFontmetrics(Evaluator& ev, const CallArgs& args) {
     });
 }
 
-// Take only scalar numbers, mapped to how many leading positional
-// arguments must each actually BE a number. Anything else there (undef, a
-// string, a list, a bool, an object) is a type error yielding undef, and
-// so is supplying fewer arguments than the arity -- matching the
-// reference, which rejects the call outright rather than coercing.
-//
-// This has to be checked up front rather than left to each case below:
-// toDoubleLenient() silently turns undef/string/list into 0.0, which
-// would make `cos(misspelled_var)` quietly 1 instead of undef, and a
-// typo'd variable then produces plausible-looking geometry instead of an
-// obvious failure. Arity is deliberately a floor, not an exact match --
-// the reference also rejects EXTRA arguments, but tightening that too
-// risks breaking working library code for no correctness gain here.
-const std::unordered_map<std::string, size_t>& scalarNumericArity() {
-    static const std::unordered_map<std::string, size_t> arity = {
-        {"abs", 1}, {"sign", 1}, {"ceil", 1}, {"floor", 1}, {"round", 1}, {"sqrt", 1},
-        {"ln", 1}, {"log", 1}, {"exp", 1}, {"sin", 1}, {"cos", 1}, {"tan", 1},
-        {"asin", 1}, {"acos", 1}, {"atan", 1}, {"atan2", 2}, {"pow", 2}, {"rands", 3},
-    };
-    return arity;
-}
-
-// Numeric functions that legitimately take a LIST argument, so the
-// all-arguments-must-be-numbers rule above can't apply -- each validates
-// its own operands, and only needs the bool case caught here (Value's
-// bool and double are distinct alternatives, but the reference rejects
-// `max(true, 1)` as a type error rather than treating true as 1).
-const std::unordered_set<std::string>& numericOnlyNames() {
-    static const std::unordered_set<std::string> names = {"max", "min", "norm", "cross"};
-    return names;
-}
-
 } // namespace
 
 bool isBuiltinFunctionName(const std::string& name) {
@@ -1043,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.23.1 → openscad_cpp_evaluator-1.25.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.23.1 → openscad_cpp_evaluator-1.25.0}/src/builtins/primitives_3d.cpp

@@ -11,7 +11,10 @@
 #include <cstdint>
 #include <map>
 #include <numbers>
+#include <optional>
 #include <set>
+#include <string>
+#include <utility>
 
 namespace oscadeval {
 
@@ -42,8 +45,18 @@ bool isDrawableFailure(const manifold::Manifold& body, const M& mesh) {
                         [](float v) { return std::isfinite(v); });
 }
 
+struct BoundaryEdges {
+    size_t count = 0;
+    // Vertex indices of one representative open edge, or nullopt when the
+    // mesh is closed. A count alone is enough on a hand-written face list,
+    // where you can just read it; it is useless on generated geometry --
+    // three bad edges in a few thousand triangles cannot be found by eye,
+    // which is what happened in BelfrySCAD #521 / issue #187.
+    std::optional<std::pair<uint32_t, uint32_t>> first;
+};
+
 template <typename M>
-size_t countBoundaryEdges(const M& mesh) {
+BoundaryEdges findBoundaryEdges(const M& mesh) {
     std::map<std::pair<uint32_t, uint32_t>, int> uses;
     for (size_t i = 0; i + 2 < mesh.triVerts.size(); i += 3) {
         const uint32_t v[3] = {static_cast<uint32_t>(mesh.triVerts[i]),
@@ -54,11 +67,34 @@ size_t countBoundaryEdges(const M& mesh) {
             ++uses[{std::min(a, b), std::max(a, b)}];
         }
     }
-    size_t open = 0;
+    BoundaryEdges out;
+    // std::map iterates in vertex-index order, which is arbitrary from the
+    // author's point of view but DETERMINISTIC: the same mesh names the same
+    // edge on every run. That matters more than which edge gets picked --
+    // an identifier that moves between renders is worse than no identifier.
+    // A cluster of open edges is nearly always one hole, so the first is
+    // usually representative of the rest.
     for (const auto& [edge, count] : uses) {
-        if (count % 2 != 0) ++open;
+        if (count % 2 == 0) continue;
+        ++out.count;
+        if (!out.first) out.first = edge;
     }
-    return open;
+    return out;
+}
+
+// "[1, 2.5, 0] - [1, 3, 0]" for one edge, using the same number formatting
+// echo() uses, so a coordinate can be pasted straight back into a script.
+template <typename M>
+std::string describeEdge(const M& mesh, std::pair<uint32_t, uint32_t> edge) {
+    const size_t stride = mesh.numProp > 0 ? static_cast<size_t>(mesh.numProp) : 3;
+    auto point = [&](uint32_t v) {
+        const size_t base = static_cast<size_t>(v) * stride;
+        if (base + 2 >= mesh.vertProperties.size()) return std::string("?");
+        return "[" + formatNumber(static_cast<double>(mesh.vertProperties[base])) + ", " +
+               formatNumber(static_cast<double>(mesh.vertProperties[base + 1])) + ", " +
+               formatNumber(static_cast<double>(mesh.vertProperties[base + 2])) + "]";
+    };
+    return point(edge.first) + " - " + point(edge.second);
 }
 } // namespace
 
@@ -810,8 +846,23 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
         // self-intersections builds perfectly well, and only an OPEN one
         // reaches this branch. The count points straight at the problem.
         if (!ev.insideHull) {
-            ev.warn("polyhedron: mesh is not closed -- " + std::to_string(countBoundaryEdges(mesh)) +
-                        " boundary edge(s); drawing it as a surface. hull() can still "
+            const BoundaryEdges open = findBoundaryEdges(mesh);
+            // Name one of them. Where the hole IS is the only part of this
+            // message an author can act on; the count alone just says to go
+            // looking, across the whole mesh.
+            const std::string where =
+                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" 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.23.1 → openscad_cpp_evaluator-1.25.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.23.1 → openscad_cpp_evaluator-1.25.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++
@@ -621,18 +733,6 @@ double bandDistance(double v, double lo, double hi, bool invert) {
     return invert ? -d : d;
 }
 
-std::optional<std::array<double, 3>> readVec3(const Value& v) {
-    const ListPtr* l = std::get_if<ListPtr>(&v);
-    if (!l || !*l || (*l)->items.size() != 3) return std::nullopt;
-    std::array<double, 3> out{};
-    for (size_t i = 0; i < 3; ++i) {
-        const double* d = std::get_if<double>(&(*l)->items[i]);
-        if (!d || !std::isfinite(*d)) return std::nullopt;
-        out[i] = *d;
-    }
-    return out;
-}
-
 } // namespace
 
 // -- 2D: marching squares --------------------------------------------------

{openscad_cpp_evaluator-1.23.1 → openscad_cpp_evaluator-1.25.0}/src/csg_generate.cpp

@@ -58,9 +58,16 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
             // skipped. See CSGNode::keyHasClosure.
             if (node.keyHasClosure) key.reset();
         }
-        std::optional<std::vector<ColoredBody>> cached = key ? manifoldCache_->get(*key) : std::nullopt;
+        std::optional<CachedSubtree> cached = key ? manifoldCache_->get(*key) : std::nullopt;
         if (cached) {
-            node.bodies = std::move(*cached);
+            node.bodies = std::move(cached->bodies);
+            // Replay what generating this subtree said the first time. A hit
+            // runs none of it again, so without this the diagnostics simply
+            // disappear on every render after the first -- which is how a
+            // permanently-open polyhedron came to look like an intermittent
+            // one (BelfrySCAD #521). Goes through emitWarning so an enclosing
+            // capture records them too, exactly as a fresh generate would.
+            for (const std::string& w : cached->warnings) emitWarning(w);
             // Skipped entirely while measuring: restampCachedIds writes
             // idToNode/idToColor, and geometry that is about to be discarded
             // has no click-to-source identity worth recording. See
@@ -83,6 +90,23 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
             // inside this hull.
             const bool savedInsideHull = insideHull;
             if (node.isBuiltin && node.kind == "hull") insideHull = true;
+            // Collect everything this subtree warns about, so put() below can
+            // store it with the bodies. Only worth doing when the result is
+            // actually cacheable -- an uncacheable node (rands() taint, a
+            // closure in the key) regenerates every time and warns every time
+            // by itself.
+            std::vector<std::string> subtreeWarnings;
+            // RAII, unlike the plain save/restore insideHull and
+            // generateWarnEntry use above: those restore a value, this one
+            // restores a POINTER to a stack vector. An EvalError thrown out
+            // of a GenerateFn would otherwise leave warnCapture dangling at
+            // a destroyed vector for any warning raised afterwards.
+            struct CaptureGuard {
+                Evaluator& ev;
+                std::vector<std::string>* saved;
+                ~CaptureGuard() { ev.warnCapture = saved; }
+            } captureGuard{*this, warnCapture};
+            if (key) warnCapture = &subtreeWarnings;
             generateTreeImpl(childPtrs);
             insideHull = savedInsideHull;
 
@@ -111,12 +135,18 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
                 node.bodies = flattenCsgTree(node.children);
             }
             if (key) {
+                warnCapture = captureGuard.saved;
+                // Merge inward-out: an ancestor still capturing must end up
+                // holding this subtree's lines too, since a hit at ITS level
+                // skips everything down here.
+                if (warnCapture != nullptr)
+                    warnCapture->insert(warnCapture->end(), subtreeWarnings.begin(), subtreeWarnings.end());
                 // The geometry itself is still cached while measuring --
                 // cacheKey is content-addressed, so the real render can
                 // legitimately reuse it. Only the PRODUCER attribution is
                 // suppressed: a node that gets discarded must never be
                 // recorded as the origin of geometry a later render draws.
-                manifoldCache_->put(*key, node.bodies);
+                manifoldCache_->put(*key, node.bodies, std::move(subtreeWarnings));
                 if (!measuring_) cacheProducer_[*key] = node.node;
             }
                 // The children's bodies have been consumed (by the dispatch above,