openscad-cpp-evaluator 0.54.0__tar.gz → 0.55.0__tar.gz

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -294,6 +294,15 @@ public:
     // depth-first on one thread.
     const oscad::Position* generateWarnEntry = nullptr;
 
+    // Set while generating anything beneath a hull(). An open mesh there is
+    // not a mistake to report: a convex hull needs only points, so BOSL2's
+    // hull_points(pts, fast=true) hands polyhedron() a deliberately garbage
+    // face list purely to carry the vertices in. The reference says nothing
+    // about it, and spheroid(circum=true, style="icosa") goes through that
+    // path -- warning would fire on an everyday BOSL2 call. Covers the whole
+    // subtree, not just direct children, since hull() consumes all of it.
+    bool insideHull = false;
+
     ColoredBody tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue);
 
     // tagGenerated()'s counterpart for a mesh Manifold refused to build --

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.0}/src/builtins/import.cpp

@@ -318,10 +318,13 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
         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());
+        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 "
+                        "it cannot take part in union/difference/intersection" +
+                        std::string(repair ? "" : ". Try import(..., repair=true)"),
+                    &node.position());
+        }
         // tagDisplayOnly carries a raw triangle soup for the renderer to
         // draw, and the renderer is float either way, so narrowing here
         // costs nothing this mesh will ever be measured on.

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.0}/src/builtins/primitives_3d.cpp

@@ -802,10 +802,12 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
         // closed mesh with reversed winding, non-manifold vertices or
         // self-intersections builds perfectly well, and only an OPEN one
         // reaches this branch. The count points straight at the problem.
-        ev.warn("polyhedron: mesh is not closed -- " + std::to_string(countBoundaryEdges(mesh)) +
-                    " boundary edge(s); drawing it as a surface, but it cannot "
-                    "take part in any CSG operation",
-                &node.position());
+        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 "
+                        "use its points, but it cannot take part in union/difference/intersection",
+                    &node.position());
+        }
         manifold::MeshGL soup;
         soup.numProp = 3;
         soup.vertProperties.assign(mesh.vertProperties.begin(), mesh.vertProperties.end());

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.0}/src/builtins/topology.cpp

@@ -35,19 +35,51 @@ CSGParams resolveHull(Evaluator& ev, const oscad::ModularCall& node, EvalContext
 // matching the reference's own `if bodies_3d: ... else: sections...`
 // either/or dispatch). background/highlight/show_only bodies pass through
 // untouched, same as union/difference/intersection.
+// Vertex positions out of a MeshGL, whatever else it carries per vertex.
+// Only the first three properties are the position; numProp may be larger.
+static void appendVertices(const manifold::MeshGL& mesh, std::vector<manifold::vec3>& out) {
+    const size_t stride = mesh.numProp;
+    if (stride < 3) return;
+    for (size_t i = 0; i + 2 < mesh.vertProperties.size(); i += stride)
+        out.push_back({mesh.vertProperties[i], mesh.vertProperties[i + 1],
+                       mesh.vertProperties[i + 2]});
+}
+
 std::vector<ColoredBody> generateHull(Evaluator&, const CSGParams&, const std::vector<std::unique_ptr<CSGNode>>& children,
                                        const oscad::ASTNode&) {
     const std::vector<ColoredBody> bodies = flattenCsgTree(children);
     if (bodies.empty()) return {};
     const RoleSplit split = splitByRole(bodies);
 
+    // An open mesh has no Manifold, but a convex hull only ever needed its
+    // POINTS -- closedness is irrelevant to one. BOSL2 depends on this:
+    // hull_points(pts, fast=true) hands polyhedron() a deliberately garbage
+    // face list purely to carry the vertices into hull(), and
+    // spheroid(circum=true, style="icosa") goes through it. Dropping those
+    // children left the loose triangles to fall through un-hulled, which is
+    // what the reference does not do.
+    std::vector<manifold::vec3> loosePoints;
+    for (const ColoredBody& c : split.displayOnly) {
+        if (c.rawMesh) appendVertices(*c.rawMesh, loosePoints);
+    }
+
     std::optional<ColoredBody> hullResult;
-    if (!split.foreground.empty()) {
+    if (!split.foreground.empty() || !loosePoints.empty()) {
         std::vector<manifold::Manifold> bodies3d;
         for (const ColoredBody& c : split.foreground) {
             if (c.body) bodies3d.push_back(*c.body);
         }
-        if (!bodies3d.empty()) {
+        if (!loosePoints.empty()) {
+            // Hulling points and bodies together has to go through the
+            // point overload, so the solids contribute their vertices too.
+            for (const manifold::Manifold& m : bodies3d)
+                appendVertices(m.GetMeshGL(), loosePoints);
+            ColoredBody cb;
+            cb.body = manifold::Manifold::Hull(loosePoints);
+            cb.color = split.foreground.empty() ? split.displayOnly.front().color
+                                                : split.foreground.front().color;
+            hullResult = std::move(cb);
+        } else if (!bodies3d.empty()) {
             ColoredBody cb;
             cb.body = manifold::Manifold::Hull(bodies3d);
             cb.color = split.foreground.front().color;
@@ -71,7 +103,10 @@ std::vector<ColoredBody> generateHull(Evaluator&, const CSGParams&, const std::v
     result.insert(result.end(), split.background.begin(), split.background.end());
     result.insert(result.end(), split.highlight.begin(), split.highlight.end());
     result.insert(result.end(), split.showOnly.begin(), split.showOnly.end());
-    result.insert(result.end(), split.displayOnly.begin(), split.displayOnly.end());
+    // Only pass the open meshes through if they were NOT hulled; hull()
+    // consumes its children, so re-adding them would draw them twice.
+    if (loosePoints.empty())
+        result.insert(result.end(), split.displayOnly.begin(), split.displayOnly.end());
     return result;
 }
 

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.0}/src/csg_generate.cpp

@@ -64,7 +64,13 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
             std::vector<CSGNode*> childPtrs;
             childPtrs.reserve(node.children.size());
             for (const std::unique_ptr<CSGNode>& c : node.children) childPtrs.push_back(c.get());
+            // Saved and restored rather than left set, exactly as
+            // generateWarnEntry is: a sibling generated afterwards is not
+            // inside this hull.
+            const bool savedInsideHull = insideHull;
+            if (node.isBuiltin && node.kind == "hull") insideHull = true;
             generateTreeImpl(childPtrs);
+            insideHull = savedInsideHull;
 
             applyDimensionRules(node);
 

{openscad_cpp_evaluator-0.54.0 → openscad_cpp_evaluator-0.55.0}/tests/test_csg_tree.cpp

@@ -314,3 +314,81 @@ TEST(WarningTrace, FromClauseNamesOutermostFrameNotImmediateCaller) {
     EXPECT_NE(warning.find("from <string>, line 3"), std::string::npos) << warning;
     EXPECT_EQ(warning.find("from <string>, line 2"), std::string::npos) << warning;
 }
+
+// -- hull() over an open mesh ------------------------------------------
+//
+// A convex hull needs only its input's POINTS; whether the mesh that
+// carried them is closed is irrelevant. BOSL2 leans on this hard:
+// hull_points(pts, fast=true) hands polyhedron() a deliberately garbage
+// face list purely as a vehicle for the vertices, and
+// spheroid(circum=true, style="icosa") goes through that path. Treating
+// the open mesh as display-only left the loose triangles to fall out of
+// hull() un-hulled -- the model rendered as a scatter of shards where the
+// reference produced a solid.
+
+TEST(HullOpenMesh, HullsThePointsOfAMeshThatDoesNotClose) {
+    Evaluated e = evalSrc(
+        "pts = [[0,0,0],[10,0,0],[10,10,0],[0,10,0],\n"
+        "       [0,0,10],[10,0,10],[10,10,10],[0,10,10]];\n"
+        "hull() polyhedron(points=pts, faces=[[0,1,2],[3,4,5],[6,7,0]]);\n");
+
+    ASSERT_EQ(e.bodies.size(), 1u) << "the open mesh must be consumed, not passed through";
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_FALSE(e.bodies[0].isDisplayOnly());
+    EXPECT_EQ(e.bodies[0].body->Status(), manifold::Manifold::Error::NoError);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-6);
+}
+
+TEST(HullOpenMesh, AnOpenMeshAndASolidHullTogether) {
+    // The solid's own vertices must survive the switch to the point-based
+    // hull: hulling only the loose points would silently shrink the result.
+    Evaluated e = evalSrc(
+        "hull() {\n"
+        "  polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]);\n"
+        "  translate([0,0,10]) cube(10);\n"
+        "}\n");
+
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_EQ(e.bodies[0].body->Status(), manifold::Manifold::Error::NoError);
+    // Hull of the z=0 square and the 10..20 cube: a prism, strictly larger
+    // than the cube alone.
+    EXPECT_GT(e.bodies[0].body->Volume(), 1000.0);
+}
+
+TEST(HullOpenMesh, AnOpenMeshOutsideAHullStillPassesThroughUntouched) {
+    Evaluated e = evalSrc(
+        "polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]);\n");
+
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_TRUE(e.bodies[0].isDisplayOnly()) << "only hull() may consume it";
+}
+
+TEST(HullOpenMesh, NoWarningForAnOpenMeshInsideAHull) {
+    // The reference is silent here, and BOSL2 reaches this on an everyday
+    // spheroid(circum=true, style="icosa") -- warning would cry wolf.
+    std::string warning;
+    evalSrc("hull() polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0],\n"
+            "                          [0,0,10],[10,0,10],[10,10,10],[0,10,10]],\n"
+            "                  faces=[[0,1,2],[3,4,5],[6,7,0]]);\n",
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+    EXPECT_EQ(warning, "") << warning;
+}
+
+TEST(HullOpenMesh, SuppressionCoversTheWholeSubtreeNotJustDirectChildren) {
+    std::string warning;
+    evalSrc("hull() { translate([0,0,1]) polyhedron(\n"
+            "    points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]); cube(1); }\n",
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+    EXPECT_EQ(warning, "") << warning;
+}
+
+TEST(HullOpenMesh, ASiblingAfterAHullStillWarns) {
+    // The flag is restored on the way out; an open mesh that is NOT hulled
+    // is still a real mistake.
+    std::string warning;
+    evalSrc("hull() cube(1);\n"
+            "polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]);\n",
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+    EXPECT_NE(warning.find("mesh is not closed"), std::string::npos) << warning;
+}