openscad-cpp-evaluator 1.49.3__tar.gz → 1.49.5__tar.gz

{openscad_cpp_evaluator-1.49.3 → openscad_cpp_evaluator-1.49.5}/PKG-INFO

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

{openscad_cpp_evaluator-1.49.3 → openscad_cpp_evaluator-1.49.5}/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.3 → openscad_cpp_evaluator-1.49.5}/pyproject.toml

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

{openscad_cpp_evaluator-1.49.3 → openscad_cpp_evaluator-1.49.5}/src/builtins/extrude.cpp

@@ -478,7 +478,11 @@ std::vector<ColoredBody> generateProjection(Evaluator&, const CSGParams& params,
     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.3 → openscad_cpp_evaluator-1.49.5}/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.3 → openscad_cpp_evaluator-1.49.5}/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.3 → openscad_cpp_evaluator-1.49.5}/src/user_calls.cpp

@@ -1043,9 +1043,12 @@ std::optional<Evaluator::ChildrenForward> Evaluator::prepareChildrenForward(cons
     // subsequent body-index lookup, so the Nth statement is evaluated
     // directly instead.
     std::vector<const oscad::ASTNode*> geoNodes;
+    std::vector<const oscad::ASTNode*> assignments;
     for (const oscad::ASTNode* c : *ctx.childrenNodes) {
-        if (c->kind() != oscad::NodeKind::Assignment && c->kind() != oscad::NodeKind::ModuleDeclaration &&
-            c->kind() != oscad::NodeKind::FunctionDeclaration) {
+        if (c->kind() == oscad::NodeKind::Assignment) {
+            assignments.push_back(c);
+        } else if (c->kind() != oscad::NodeKind::ModuleDeclaration &&
+                   c->kind() != oscad::NodeKind::FunctionDeclaration) {
             geoNodes.push_back(c);
         }
     }
@@ -1112,6 +1115,14 @@ std::optional<Evaluator::ChildrenForward> Evaluator::prepareChildrenForward(cons
         pickedIndices.push_back(static_cast<size_t>(idx));
     }
     if (picked.empty()) return std::nullopt;
+    // The picked statement runs in its block's scope, so the block's
+    // assignments must be in it: `m() { n = 2; for (i=[0:n]) ...; }` with
+    // `children(0)` in m() read n as unknown (#815, BOSL2's attachable()).
+    // evalChildren runs them into evalCtx's let_, which the picked
+    // statements' scopes share (withScope).
+    // ponytail: a children(i, separate=true) expansion prepares twice, so a
+    // side effect in one of these assignments (echo, rands) runs twice there.
+    if (!assignments.empty()) evalChildren(assignments, evalCtx);
     return ChildrenForward{std::move(evalCtx), std::move(picked), separate, std::move(pickedIndices)};
 }
 

{openscad_cpp_evaluator-1.49.3 → openscad_cpp_evaluator-1.49.5}/tests/test_extrude_roof.cpp

@@ -245,6 +245,21 @@ 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);
+}
+
 // -- offset -----------------------------------------------------------------
 
 TEST(Offset, RoundGrowsAreaBySquarePerimeterPlusCircleCorners) {

{openscad_cpp_evaluator-1.49.3 → openscad_cpp_evaluator-1.49.5}/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).

{openscad_cpp_evaluator-1.49.3 → openscad_cpp_evaluator-1.49.5}/tests/test_scoping.cpp

@@ -212,3 +212,18 @@ TEST(Scoping, ReassignedVariableTakesItsLastValueAtItsFirstPosition) {
     for (const auto& m : out) warnings += m.find("but was overwritten") != std::string::npos;
     EXPECT_EQ(warnings, 3u) << "one per reassignment, even though m() could run again";
 }
+
+// #815: BOSL2's attachable() runs its children by index, and children(N)
+// used to skip the child block's assignments, so `last` was unknown.
+TEST(Scoping, IndexedChildrenSeeTheirBlocksAssignments) {
+    std::vector<std::string> out;
+    evaluateSrc("module one() children(0);\n"
+                "module both() { children(1); children([0:1]); }\n"
+                "one() { n = 2; for (i = [0:n]) echo(a = i); }\n"
+                "both() { k = 3; echo(b = k); echo(c = k + 1); }\n",
+                [&](const std::string& m) { out.push_back(m); });
+    EXPECT_TRUE(anyContains(out, "ECHO: a = 2"));
+    EXPECT_TRUE(anyContains(out, "ECHO: b = 3"));
+    EXPECT_TRUE(anyContains(out, "ECHO: c = 4"));
+    EXPECT_FALSE(anyContains(out, "unknown variable"));
+}

{openscad_cpp_evaluator-1.49.3 → openscad_cpp_evaluator-1.49.5}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.49.3"
+version = "1.49.4"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },