openscad-cpp-evaluator 0.22.0__tar.gz → 0.23.0__tar.gz

{openscad_cpp_evaluator-0.22.0 → openscad_cpp_evaluator-0.23.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.22.0 → openscad_cpp_evaluator-0.23.0}/bindings/module.cpp

@@ -14,6 +14,7 @@
 #include <nanobind/nanobind.h>
 #include <nanobind/ndarray.h>
 #include <nanobind/stl/shared_ptr.h>
+#include <nanobind/stl/vector.h>
 #include <nanobind/stl/string.h>
 
 #include "openscad_cpp_evaluator/colored_body.hpp"
@@ -21,6 +22,7 @@
 #include "openscad_cpp_evaluator/eval_context.hpp"
 #include "openscad_cpp_evaluator/eval_use.hpp"
 #include "openscad_cpp_evaluator/evaluator.hpp"
+#include "openscad_cpp_evaluator/mesh_check.hpp"
 #include "openscad_cpp_evaluator/manifold_cache.hpp"
 #include "openscad_cpp_evaluator/profile.hpp"
 #include "openscad_cpp_evaluator/value.hpp"
@@ -242,6 +244,31 @@ nb::list csgTreeToPy(const std::vector<std::unique_ptr<oscadeval::CSGNode>>& tre
     return out;
 }
 
+// Exposed so a front end that writes its own files -- BelfrySCAD's GUI has
+// its own exporters -- can run the same check the CLI does rather than a
+// second, drifting implementation.
+nb::dict checkMeshPy(const std::vector<float>& verts, const std::vector<uint32_t>& tris) {
+    manifold::MeshGL m;
+    m.numProp = 3;
+    m.vertProperties = verts;
+    m.triVerts = tris;
+    const oscadeval::MeshDiagnosis d = oscadeval::checkMesh(m);
+    nb::dict out;
+    out["boundary_edges"] = d.boundaryEdges;
+    out["non_manifold_edges"] = d.nonManifoldEdges;
+    out["pinched_vertices"] = d.pinchedVertices;
+    out["inconsistent_edges"] = d.inconsistentEdges;
+    out["degenerate_faces"] = d.degenerateFaces;
+    out["duplicate_faces"] = d.duplicateFaces;
+    out["unwelded_vertices"] = d.unweldedVertices;
+    out["watertight"] = d.watertight();
+    out["manifold"] = d.manifold();
+    out["orientable"] = d.orientable();
+    out["ok"] = d.ok();
+    out["summary"] = d.summary();
+    return out;
+}
+
 nb::object profileResultToPy(const std::optional<oscadeval::ProfileResult>& pr) {
     if (!pr) return nb::none();
     nb::list sites;
@@ -681,6 +708,11 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).");
     m.def("parse_decls", &parseDecls, nb::arg("path"),
           "Parse a .scad file; return top-level declaration (namespace, name, start, end, line, column, origin) tuples.");
+    m.def("check_mesh", &checkMeshPy, nb::arg("verts"), nb::arg("tris"),
+          "Diagnose a triangle mesh against the manifoldness conditions. "
+          "verts is a flat [x,y,z,...] list, tris a flat index list. Returns "
+          "counts per condition plus watertight/manifold/orientable/ok and a "
+          "one-line summary.");
     m.def("parse_ast", &oscadbind::parseAstFromFile, nb::arg("path"), nb::arg("include_comments") = false,
           "Parse a .scad file; return the AST as a list of plain nested dicts "
           "(kind, position, plus that kind's own fields). A snapshot, not a view -- "

{openscad_cpp_evaluator-0.22.0 → openscad_cpp_evaluator-0.23.0}/include/openscad_cpp_evaluator/export.hpp

@@ -17,6 +17,15 @@ namespace oscadeval {
 //
 // 3MF and format-from-extension dispatch land in Phase 5 per the plan's
 // phased build order.
+// One message per body that is not a closed manifold solid, ready to print.
+// Empty when everything is sound.
+//
+// Returned rather than logged so each front end can surface it its own way,
+// and so export.cpp needs no logging dependency. Nothing here refuses to
+// write: a deliberately open surface is a legitimate thing to export, and
+// silently blocking a save would be worse than an honest warning.
+std::vector<std::string> checkExportBodies(const std::vector<ColoredBody>& bodies);
+
 void writeStl(const std::string& path, const std::vector<ColoredBody>& bodies);
 
 // Wavefront OBJ: "v x y z" per vertex then "f i j k" per triangle

openscad_cpp_evaluator-0.23.0/include/openscad_cpp_evaluator/mesh_check.hpp

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include <manifold/manifold.h>
+
+namespace oscadeval {
+
+// What is wrong with a triangle mesh, as four independent conditions. They
+// are separate because they fail separately and a mesh can satisfy any
+// subset: two boxes fused along a face are watertight but have edges with
+// four faces; two cones joined tip-to-tip have every edge shared by exactly
+// two faces and still pinch at the apex.
+struct MeshDiagnosis {
+    // Edges used by exactly one face: a hole.
+    size_t boundaryEdges = 0;
+    // Edges used by three or more faces: surfaces meeting along a seam.
+    size_t nonManifoldEdges = 0;
+    // Vertices whose incident faces form more than one fan -- the surface
+    // pinches to a point there. Passes the edge test, so it needs its own.
+    size_t pinchedVertices = 0;
+    // Edges whose two faces traverse them the same way round rather than in
+    // opposite directions: the winding disagrees across that edge.
+    size_t inconsistentEdges = 0;
+    // Zero-area triangles, and faces naming the same vertex twice.
+    size_t degenerateFaces = 0;
+    // Faces with the same three vertices as another face.
+    size_t duplicateFaces = 0;
+    // Distinct indices at the same position. These split what should be one
+    // edge into two boundary edges, which is the usual reason a mesh that
+    // looks closed is not.
+    size_t unweldedVertices = 0;
+
+    bool watertight() const { return boundaryEdges == 0; }
+    bool manifold() const {
+        return boundaryEdges == 0 && nonManifoldEdges == 0 && pinchedVertices == 0
+               && degenerateFaces == 0;
+    }
+    bool orientable() const { return inconsistentEdges == 0; }
+    bool ok() const { return manifold() && orientable(); }
+
+    // "4 boundary edges, 1 pinched vertex" -- empty when nothing is wrong.
+    std::string summary() const;
+};
+
+// Diagnose `mesh` against all four conditions. Read-only; nothing is
+// modified and no exception is thrown for a broken mesh.
+MeshDiagnosis checkMesh(const manifold::MeshGL& mesh);
+
+// What repairMesh did, for reporting. Not a diagnosis: these are actions.
+struct MeshRepairReport {
+    size_t weldedVertices = 0;
+    size_t droppedDegenerate = 0;
+    size_t droppedDuplicate = 0;
+    size_t reversedFaces = 0;
+    size_t filledHoles = 0;
+    size_t filledTriangles = 0;
+    size_t splitVertices = 0;
+    size_t unfilledHoles = 0;      // boundary loops it could not close
+
+    bool didAnything() const {
+        return weldedVertices || droppedDegenerate || droppedDuplicate || reversedFaces
+               || filledHoles || splitVertices;
+    }
+    // "welded 12 vertices, filled 1 hole (4 triangles)" -- empty if nothing.
+    std::string summary() const;
+};
+
+// 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
+// last -- filling before orienting would add faces wound against their
+// neighbours.
+//
+// Returns the repaired mesh. A mesh it cannot close is still returned,
+// improved as far as it got, with the remainder reported in `report`.
+manifold::MeshGL repairMesh(const manifold::MeshGL& mesh, MeshRepairReport& report);
+
+}  // namespace oscadeval

{openscad_cpp_evaluator-0.22.0 → openscad_cpp_evaluator-0.23.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.22.0 → openscad_cpp_evaluator-0.23.0}/python/openscad_cpp_evaluator/__init__.py

@@ -18,7 +18,7 @@ from ._openscad_cpp_evaluator import FastContinueSignal, ManifoldCache
 __all__ = [
     "Evaluator", "ColoredBody", "EvalError", "ParseError", "OscObject", "parse", "to_renderable_bodies",
     "ManifoldCache", "CallSiteProfile", "ProfileResult", "format_csg_tree", "bodies_from_dicts",
-    "FastContinueSignal", "parse_ast", "parse_ast_string",
+    "FastContinueSignal", "parse_ast", "parse_ast_string", "check_mesh",
 ]
 
 
@@ -274,6 +274,22 @@ def parse(path: str) -> RootScope:
     return RootScope(decls)
 
 
+def check_mesh(verts, tris) -> dict:
+    """Diagnose a triangle mesh against the manifoldness conditions.
+
+    `verts` is a flat [x, y, z, ...] sequence, `tris` a flat index sequence.
+    Returns a count per condition -- boundary_edges, non_manifold_edges,
+    pinched_vertices, inconsistent_edges, degenerate_faces, duplicate_faces,
+    unwelded_vertices -- plus watertight/manifold/orientable/ok and a
+    one-line `summary`.
+
+    The conditions are separate because they fail separately: a mesh can be
+    watertight and still non-manifold, and one that is both can still be
+    wound inconsistently.
+    """
+    return _ext.check_mesh([float(v) for v in verts], [int(t) for t in tris])
+
+
 def parse_ast(path: str, include_comments: bool = False) -> list:
     """Parse a .scad file; return its AST as a list of plain nested dicts.
 

{openscad_cpp_evaluator-0.22.0 → openscad_cpp_evaluator-0.23.0}/src/CMakeLists.txt

@@ -15,6 +15,7 @@ add_library(openscad_cpp_evaluator STATIC
   debug_profile.cpp
   eval_use.cpp
   export.cpp
+  mesh_check.cpp
   zip_stored.cpp
   import/mesh_import.cpp
   import/surface_load.cpp

{openscad_cpp_evaluator-0.22.0 → openscad_cpp_evaluator-0.23.0}/src/builtins/import.cpp

@@ -7,6 +7,8 @@
 #include "openscad_cpp_evaluator/mesh_import.hpp"
 
 #include <manifold/manifold.h>
+
+#include "openscad_cpp_evaluator/mesh_check.hpp"
 #include <nlohmann/json.hpp>
 
 #include <algorithm>
@@ -174,6 +176,9 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     const Value fileArg = getArg(args, 0, "file", Value{});
     const Value layerArg = getArg(args, std::nullopt, "layer", Value{});
+    // 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}));
 
     CSGParams params;
     params["color"] = colorToValue(effCtx.color);
@@ -225,6 +230,7 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
             trisFlat.push_back(Value{static_cast<double>(t[2])});
         }
         params["kind"] = Value{std::string("mesh")};
+        params["repair"] = Value{repair};
         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;
@@ -268,6 +274,26 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
     }
     for (const Value& t : tris) mesh.triVerts.push_back(static_cast<uint32_t>(std::get<double>(t)));
 
+    const auto repairIt = params.find("repair");
+    const bool repair = repairIt != params.end() && truthy(repairIt->second);
+    if (repair) {
+        const MeshDiagnosis before = checkMesh(mesh);
+        MeshRepairReport rep;
+        manifold::MeshGL fixed = repairMesh(mesh, rep);
+        const MeshDiagnosis after = checkMesh(fixed);
+        if (rep.didAnything()) {
+            ev.warn("import: repaired the mesh -- " + rep.summary(), &node.position());
+        }
+        if (!after.ok() && !before.ok()) {
+            // Say what is left rather than only what was done: a repair
+            // that helped but did not finish is the case where the user
+            // most needs to know the difference.
+            ev.warn("import: still not manifold after repair -- " + after.summary(),
+                    &node.position());
+        }
+        mesh = std::move(fixed);
+    }
+
     manifold::Manifold body(mesh);
     if (body.Status() != manifold::Manifold::Error::NoError) {
         // Same treatment as an open polyhedron() (see generatePolyhedron):
@@ -275,8 +301,12 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
         // this warned and then handed back an empty body, which was dropped
         // downstream -- so a broken STL warned once and showed nothing,
         // giving no way to see what was actually wrong with it.
-        ev.warn("import: mesh is not a closed solid (" + manifoldErrorName(body.Status()) +
-                    "); drawing it as a surface, but it cannot take part in any CSG operation",
+        const MeshDiagnosis d = checkMesh(mesh);
+        std::string why = d.summary();
+        if (why.empty()) why = manifoldErrorName(body.Status());
+        ev.warn("import: mesh is not a closed solid (" + why +
+                    "); drawing it as a surface, but it cannot take part in any CSG "
+                    "operation" + (repair ? "" : ". Try import(..., repair=true)"),
                 &node.position());
         return {ev.tagDisplayOnly(std::move(mesh), node, params.at("color"))};
     }

{openscad_cpp_evaluator-0.22.0 → openscad_cpp_evaluator-0.23.0}/src/export.cpp

@@ -1,5 +1,7 @@
 #include "openscad_cpp_evaluator/export.hpp"
 
+#include "openscad_cpp_evaluator/mesh_check.hpp"
+
 #include "openscad_cpp_evaluator/zip_stored.hpp"
 
 #include <manifold/manifold.h>
@@ -223,4 +225,18 @@ void writeThreeMf(const std::string& path, const std::vector<ColoredBody>& bodie
     writeDeflateZip(path, entries);
 }
 
+std::vector<std::string> checkExportBodies(const std::vector<ColoredBody>& bodies) {
+    std::vector<std::string> out;
+    size_t n = 0;
+    for (const auto& b : bodies) {
+        ++n;
+        if (!b.body || b.body->IsEmpty()) continue;
+        const MeshDiagnosis d = checkMesh(b.body->GetMeshGL());
+        if (d.ok()) continue;
+        out.push_back("part " + std::to_string(n) + " is not a closed manifold solid -- "
+                      + d.summary());
+    }
+    return out;
+}
+
 } // namespace oscadeval