openscad-cpp-evaluator 1.49.4__tar.gz → 1.49.6__tar.gz

{openscad_cpp_evaluator-1.49.4 → openscad_cpp_evaluator-1.49.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.49.4
+Version: 1.49.6
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT AND OFL-1.1

{openscad_cpp_evaluator-1.49.4 → openscad_cpp_evaluator-1.49.6}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -132,6 +132,12 @@ struct ColoredBody {
     bool isDisplayOnly() const { return rawMesh.has_value(); }
 };
 
+// A `%` body or a `#` operand's ghost copy: drawn, never part of the model,
+// so an operation that consumes its children's geometry must skip it.
+inline bool isModifierGhost(const ColoredBody& b) {
+    return b.role == BodyRole::Background || b.role == BodyRole::HighlightGhost;
+}
+
 // The cached questions -- see ColoredBody::knownEmpty. Ask Manifold once per
 // body, never once per tree level.
 inline bool bodyIsEmpty(ColoredBody& b) {

{openscad_cpp_evaluator-1.49.4 → openscad_cpp_evaluator-1.49.6}/include/openscad_cpp_evaluator/mesh_check.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstddef>
 #include <cstdint>
 #include <string>
 #include <vector>
@@ -82,6 +83,19 @@ struct MeshRepairReport {
     std::string summary() const;
 };
 
+// Weld points on a grid of `tolerance`: returns, for each point, the index
+// of the lowest-numbered point it welds to (itself if none). Points in one
+// grid cell weld, as rounding to the grid always did -- and so do points
+// within tolerance/32 of each other across a cell boundary, which rounding
+// alone splits however close they are: two copies of a vertex at x*1e6 ==
+// 10454062.5, a few ULPs apart, round to different cells (BelfrySCAD #832).
+// `data` holds `n` points, each starting `stride` values after the last.
+// A tolerance of 0 or less welds exact duplicates only.
+template <typename T>
+std::vector<size_t> weldPoints(const T* data, size_t n, size_t stride, double tolerance);
+extern template std::vector<size_t> weldPoints<float>(const float*, size_t, size_t, double);
+extern template std::vector<size_t> weldPoints<double>(const double*, size_t, size_t, double);
+
 //: 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

{openscad_cpp_evaluator-1.49.4 → openscad_cpp_evaluator-1.49.6}/pyproject.toml

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

{openscad_cpp_evaluator-1.49.4 → openscad_cpp_evaluator-1.49.6}/src/builtins/booleans.cpp

@@ -64,11 +64,14 @@ RoleSplit splitByRole(const std::vector<ColoredBody>& bodies) {
 
 // Unions every 2D child into a single CrossSection; nullopt if there are no
 // 2D children at all. Mirrors _to_cross_section. Shared by
-// linear_extrude/rotate_extrude/roof (extrude.cpp, roof.cpp).
+// linear_extrude/rotate_extrude/offset/roof (extrude.cpp, roof.cpp).
+// A `%` body and a `#` operand's ghost copy are display aids, not model:
+// unioning them in filled a differenced-away notch back in (BelfrySCAD
+// #866). OpenSCAD shows neither under these operations, so they are dropped.
 std::optional<manifold::CrossSection> toCrossSection(const std::vector<ColoredBody>& bodies) {
     std::optional<manifold::CrossSection> cs;
     for (const ColoredBody& b : bodies) {
-        if (!b.section) continue;
+        if (!b.section || isModifierGhost(b)) continue;
         cs = cs ? (*cs + *b.section) : *b.section;
     }
     return cs;

{openscad_cpp_evaluator-1.49.4 → openscad_cpp_evaluator-1.49.6}/src/builtins/extrude.cpp

@@ -471,14 +471,20 @@ std::vector<ColoredBody> generateProjection(Evaluator&, const CSGParams& params,
     const std::vector<ColoredBody> bodies = flattenCsgTree(children);
     std::vector<ColoredBody> bodies3d;
     for (const ColoredBody& c : bodies) {
-        if (c.body) bodies3d.push_back(c);
+        // Not a `%` body or a `#` ghost: projecting them drew the
+        // differenced-away part's outline (BelfrySCAD #866). See toCrossSection.
+        if (c.body && !isModifierGhost(c)) bodies3d.push_back(c);
     }
     if (bodies3d.empty()) return {};
 
     const ColoredBody combined = combineBodies(bodies3d);
     manifold::CrossSection cs;
     if (std::get<bool>(params.at("cut"))) {
-        cs = manifold::CrossSection(combined.body->Slice(0.0), manifold::CrossSection::FillRule::EvenOdd);
+        // Positive, as OpenSCAD fills it. A self-overlapping polyhedron (a
+        // rope spool whose loops overlap, BelfrySCAD #831) slices to
+        // overlapping contours, and EvenOdd cut every overlap out as a hole.
+        // A clean solid slices the same either way.
+        cs = manifold::CrossSection(combined.body->Slice(0.0), manifold::CrossSection::FillRule::Positive);
     } else {
         const manifold::Polygons polys = combined.body->Project();
         cs = polys.empty() ? manifold::CrossSection() : manifold::CrossSection(polys, manifold::CrossSection::FillRule::Positive);

{openscad_cpp_evaluator-1.49.4 → openscad_cpp_evaluator-1.49.6}/src/builtins/primitives_3d.cpp

@@ -889,21 +889,16 @@ CSGParams resolvePolyhedron(Evaluator& ev, const oscad::ModularCall& node, EvalC
 
     std::vector<std::array<double, 3>> uniqueVerts;
     std::vector<size_t> remap(rawVerts.size());
-    std::map<std::array<int64_t, 3>, size_t> seen;
-    for (size_t i = 0; i < rawVerts.size(); ++i) {
-        const std::array<int64_t, 3> key = {
-            static_cast<int64_t>(std::llround(rawVerts[i][0] * 1e6)),
-            static_cast<int64_t>(std::llround(rawVerts[i][1] * 1e6)),
-            static_cast<int64_t>(std::llround(rawVerts[i][2] * 1e6)),
-        };
-        auto it = seen.find(key);
-        if (it != seen.end()) {
-            remap[i] = it->second;
-        } else {
-            const size_t newIdx = uniqueVerts.size();
-            uniqueVerts.push_back(rawVerts[i]);
-            seen[key] = newIdx;
-            remap[i] = newIdx;
+    {
+        const std::vector<size_t> rep =
+            weldPoints(rawVerts.empty() ? nullptr : rawVerts.front().data(), rawVerts.size(), 3, 1e-6);
+        for (size_t i = 0; i < rawVerts.size(); ++i) {
+            if (rep[i] == i) {
+                remap[i] = uniqueVerts.size();
+                uniqueVerts.push_back(rawVerts[i]);
+            } else {
+                remap[i] = remap[rep[i]];  // rep[i] < i, so already numbered
+            }
         }
     }
 

{openscad_cpp_evaluator-1.49.4 → openscad_cpp_evaluator-1.49.6}/src/mesh_check.cpp

@@ -1,6 +1,8 @@
 #include "openscad_cpp_evaluator/mesh_check.hpp"
 
 #include <algorithm>
+#include <array>
+#include <cstring>
 #include <cmath>
 #include <map>
 #include <set>
@@ -65,14 +67,9 @@ template <typename M>
 size_t countUnwelded(const M& m) {
     const size_t stride = m.numProp ? m.numProp : 3;
     const size_t n = stride ? m.vertProperties.size() / stride : 0;
-    std::map<std::tuple<long long, long long, long long>, size_t> seen;
+    const std::vector<size_t> rep = weldPoints(m.vertProperties.data(), n, stride, 1e-6);
     size_t extra = 0;
-    for (size_t v = 0; v < n; ++v) {
-        double p[3];
-        pos(m, static_cast<Vert>(v), p);
-        auto key = std::make_tuple(llround(p[0] * 1e6), llround(p[1] * 1e6), llround(p[2] * 1e6));
-        if (++seen[key] > 1) ++extra;
-    }
+    for (size_t v = 0; v < n; ++v) extra += rep[v] != v;
     return extra;
 }
 
@@ -312,45 +309,12 @@ template <typename M>
 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;
+    const std::vector<size_t> rep = weldPoints(m.vertProperties.data(), n, stride, tolerance);
     std::vector<Vert> remap(n);
     welded = 0;
-
-    // Grid key plus the vertex it came from, sorted so that equal positions
-    // land in a run. This was a std::map keyed by the tuple -- one tree node
-    // per VERTEX, ~885,000 of them for a 295K-triangle import -- and sorting
-    // gets the same answer with one allocation. Sorting by (key, vertex)
-    // puts the LOWEST-numbered vertex first in its run, which is the one
-    // emplace() kept as the representative, so the remap is unchanged.
-    struct Keyed {
-        long long x, y, z;
-        Vert v;
-        bool operator<(const Keyed& o) const {
-            if (x != o.x) return x < o.x;
-            if (y != o.y) return y < o.y;
-            if (z != o.z) return z < o.z;
-            return v < o.v;
-        }
-        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] * 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();) {
-        size_t j = i + 1;
-        while (j < keyed.size() && keyed[j].samePos(keyed[i])) ++j;
-        for (size_t k = i; k < j; ++k) remap[keyed[k].v] = keyed[i].v;
-        welded += j - i - 1;
-        i = j;
+        remap[v] = static_cast<Vert>(rep[v]);
+        welded += rep[v] != v;
     }
     return remap;
 }
@@ -849,6 +813,93 @@ M stripSlivers(const M& mesh, SliverStripReport& report) {
 }
 
 
+template <typename T>
+std::vector<size_t> weldPoints(const T* data, size_t n, size_t stride, double tolerance) {
+    std::vector<size_t> parent(n);
+    for (size_t i = 0; i < n; ++i) parent[i] = i;
+    auto find = [&](size_t v) {
+        while (parent[v] != v) v = parent[v] = parent[parent[v]];
+        return v;
+    };
+    // The lower index stays the root, so each point maps to the lowest it welds to.
+    auto unite = [&](size_t a, size_t b) {
+        a = find(a);
+        b = find(b);
+        if (a != b) parent[std::max(a, b)] = std::min(a, b);
+    };
+
+    // Grid key plus the point it came from, sorted so that one cell is a
+    // run. Sorting rather than a map: one allocation, not a tree or hash
+    // node per vertex (~885,000 of them for a 295K-triangle import).
+    struct Keyed {
+        int64_t k[3];
+        size_t v;
+        bool operator<(const Keyed& o) const {
+            for (int a = 0; a < 3; ++a)
+                if (k[a] != o.k[a]) return k[a] < o.k[a];
+            return v < o.v;
+        }
+    };
+    const bool exact = !(tolerance > 0.0);
+    const double inv = exact ? 0.0 : 1.0 / tolerance;
+    // How near a cell boundary a point must be to be compared with the
+    // next cell's points. Well above rounding noise, well below a grid
+    // step, and rare enough (~6% of points) to cost nothing.
+    constexpr double kNear = 1.0 / 64;
+    std::vector<Keyed> keyed(n);
+    std::vector<std::pair<size_t, std::array<int, 3>>> leaning;  // (point, which way per axis)
+    for (size_t i = 0; i < n; ++i) {
+        const T* p = data + i * stride;
+        std::array<int, 3> lean{};
+        for (int a = 0; a < 3; ++a) {
+            if (exact) {
+                const double c = static_cast<double>(p[a]) + 0.0;  // -0 and 0 are one position
+                std::memcpy(&keyed[i].k[a], &c, sizeof c);
+                continue;
+            }
+            const double s = p[a] * inv;
+            keyed[i].k[a] = std::llround(s);
+            const double f = s - static_cast<double>(keyed[i].k[a]);  // in [-0.5, 0.5]
+            lean[a] = f > 0.5 - kNear ? 1 : f < -0.5 + kNear ? -1 : 0;
+        }
+        keyed[i].v = i;
+        if (lean[0] || lean[1] || lean[2]) leaning.push_back({i, lean});
+    }
+    std::vector<Keyed> sorted = keyed;
+    std::sort(sorted.begin(), sorted.end());
+    for (size_t i = 1; i < n; ++i)
+        if (std::equal(sorted[i].k, sorted[i].k + 3, sorted[i - 1].k)) unite(sorted[i - 1].v, sorted[i].v);
+
+    // Across a boundary: each cell the point leans toward, by each subset
+    // of the axes it leans on, compared point by point.
+    const double reach = 2 * kNear * tolerance;
+    for (const auto& [i, lean] : leaning) {
+        const T* p = data + i * stride;
+        for (int mask = 1; mask < 8; ++mask) {
+            Keyed probe{{keyed[i].k[0], keyed[i].k[1], keyed[i].k[2]}, 0};
+            bool any = true;
+            for (int a = 0; a < 3; ++a) {
+                if (!(mask & (1 << a))) continue;
+                if (!lean[a]) { any = false; break; }
+                probe.k[a] += lean[a];
+            }
+            if (!any) continue;
+            for (auto it = std::lower_bound(sorted.begin(), sorted.end(), probe);
+                 it != sorted.end() && std::equal(it->k, it->k + 3, probe.k); ++it) {
+                const T* q = data + it->v * stride;
+                if (std::abs(p[0] - q[0]) <= reach && std::abs(p[1] - q[1]) <= reach
+                    && std::abs(p[2] - q[2]) <= reach)
+                    unite(i, it->v);
+            }
+        }
+    }
+
+    std::vector<size_t> rep(n);
+    for (size_t i = 0; i < n; ++i) rep[i] = find(i);
+    return rep;
+}
+
+
 // Instantiated for both precisions: MeshGL for the paths that are float by
 // nature (STL, the renderer), MeshGL64 wherever the caller still has its
 // real coordinates. Keeping the definitions in this file, rather than the
@@ -859,5 +910,7 @@ template manifold::MeshGL repairMesh<manifold::MeshGL>(const manifold::MeshGL&,
 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&);
+template std::vector<size_t> weldPoints<float>(const float*, size_t, size_t, double);
+template std::vector<size_t> weldPoints<double>(const double*, size_t, size_t, double);
 
 }  // namespace oscadeval

{openscad_cpp_evaluator-1.49.4 → openscad_cpp_evaluator-1.49.6}/tests/test_extrude_roof.cpp

@@ -245,6 +245,46 @@ TEST(Projection, CutSlicesAtZEqualsZero) {
     EXPECT_TRUE(area < 1e-6 || std::fabs(area - 6.0) < 1e-6);
 }
 
+// One polyhedron holding two overlapping cube shells, as a self-overlapping
+// mesh like a tightly wound rope spool is (BelfrySCAD #831). Its slice is
+// the union of the two squares, as OpenSCAD fills it -- not the two squares
+// with their overlap cut out.
+TEST(Projection, CutFillsWhereAPolyhedronOverlapsItself) {
+    Evaluated e = evalSrc(
+        "function box(o) = [for (z=[-1,1], y=[0,2], x=[0,2]) [x+o, y, z]];"
+        "f = [[0,1,3,2],[4,6,7,5],[0,4,5,1],[2,3,7,6],[0,2,6,4],[1,5,7,3]];"
+        "projection(cut=true) polyhedron(concat(box(0), box(1)),"
+        "    concat([for (q=f) [for (i=q) i]], [for (q=f) [for (i=q) i+8]]));");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].section.has_value());
+    EXPECT_NEAR(e.bodies[0].section->Area(), 6.0, 1e-6);
+}
+
+// A `#` operand is drawn again as a ghost and a `%` body is drawn but not
+// modelled; neither may reach the operation. Both leaked into projection()
+// and every 2D-consuming operation (BelfrySCAD #866): the ghost refilled
+// the cut-away corner and the `%` cube added its square.
+TEST(Projection, ModifierGhostsAreNotProjected) {
+    for (const char* src : {
+             "projection() difference() { cube([4,4,1]); #translate([-1,-1,-1]) cube(3); }",
+             "projection() union() { difference() { cube([4,4,1]); #translate([-1,-1,-1]) cube(3); }"
+             "  %translate([10,0,0]) cube(1); }"}) {
+        Evaluated e = evalSrc(src);
+        double area = 0;
+        for (const ColoredBody& b : e.bodies)
+            if (b.section) area += b.section->Area();
+        EXPECT_NEAR(area, 12.0, 1e-6) << src;
+    }
+}
+
+TEST(LinearExtrude, ModifierGhostsAreNotExtruded) {
+    Evaluated e = evalSrc("linear_extrude(1) difference() { square(4); #translate([-1,-1]) square(3); }");
+    double volume = 0;
+    for (const ColoredBody& b : e.bodies)
+        if (b.body) volume += b.body->Volume();
+    EXPECT_NEAR(volume, 12.0, 1e-6);
+}
+
 // -- offset -----------------------------------------------------------------
 
 TEST(Offset, RoundGrowsAreaBySquarePerimeterPlusCircleCorners) {

{openscad_cpp_evaluator-1.49.4 → openscad_cpp_evaluator-1.49.6}/tests/test_primitives.cpp

@@ -153,6 +153,23 @@ TEST(Polyhedron, TetrahedronVolumeMatchesAnalyticFormula) {
     EXPECT_NEAR(e.bodies[0].body->Volume(), 4.0 / 3.0, 1e-6);
 }
 
+// Two copies of a corner a few ULPs apart, either side of a weld-grid
+// boundary (x*1e6 == 0.5): rounding to the grid put them in different cells,
+// so the seam stayed open and a sound BOSL2 thread drew as an open surface
+// (BelfrySCAD #832). They weld now, and the solid is closed.
+TEST(Polyhedron, TwinVerticesStraddlingTheWeldGridStillWeld) {
+    std::vector<std::string> log;
+    Evaluated e = evalSrc("a = 5e-7 * (1 - 1e-12); b = 5e-7 * (1 + 1e-12);"
+                          "polyhedron("
+                          "points=[[a,0,0],[2,0,0],[0,2,0],[0,0,2],[b,0,0]], "
+                          "faces=[[0,1,2],[0,3,1],[4,2,3],[1,3,2]]);",
+                          [&](const std::string& m) { log.push_back(m); });
+    EXPECT_TRUE(log.empty()) << log[0];
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_EQ(e.bodies[0].body->Status(), manifold::Manifold::Error::NoError);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 4.0 / 3.0, 1e-5);
+}
+
 TEST(Polyhedron, MissingFacesWarnsAndDrawsNothing) {
     // Upstream builtin_polyhedron warns and draws nothing; the rest of the
     // script carries on (this used to stop the render).