openscad-cpp-evaluator 1.7.0__tar.gz → 1.7.2__tar.gz

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.7.2}/PKG-INFO

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

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.7.2}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -816,6 +816,15 @@ struct CompiledChunk {
         // and copying it back out.
         struct ArgBind {
             int paramIndex = -1;    // >=0: this argument binds that parameter
+            // Any FURTHER parameters of the same name. Normally empty, but a
+            // declaration may repeat a parameter name -- BOSL2's
+            // regular_prism() declares both `length` and `height` twice --
+            // and the name-matching path this replaced bound every one of
+            // them, because it walked the parameter list asking "is there a
+            // bound argument called this?" rather than the other way round.
+            // Binding only the first silently left the body reading undef
+            // from whichever slot the duplicate name finally resolved to.
+            std::vector<int> alsoParams;
             bool toDyn = false;     // instead bind by name into ctx.dyn ($-named, undeclared)
             bool warnUnexpectedNamed = false;
             bool warnTooManyPositional = false;

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.7.2}/pyproject.toml

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

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.7.2}/src/bytecode_compiler.cpp

@@ -20,6 +20,22 @@
 namespace oscadeval {
 
 namespace {
+// Records every parameter called `name`, not just the first. See
+// CompiledChunk::CallSite::ArgBind::alsoParams for why there can be more
+// than one.
+void bindEveryParamNamed(CompiledChunk::CallSite::ArgBind& b,
+                         const std::vector<std::unique_ptr<oscad::ParameterDeclaration>>& params,
+                         const std::string& name) {
+    for (size_t p = 0; p < params.size(); ++p) {
+        if (params[p]->name->name != name) continue;
+        if (b.paramIndex < 0) {
+            b.paramIndex = static_cast<int>(p);
+        } else {
+            b.alsoParams.push_back(static_cast<int>(p));
+        }
+    }
+}
+
 // Replays buildBoundArgs' own positional/named matching rule (bytecode_vm.cpp)
 // against a parameter list known at compile time, recording the answer per
 // argument instead of recomputing it per call. The rule, unchanged: a named
@@ -38,19 +54,16 @@ void planCallSiteArgs(CompiledChunk::CallSite& site,
         CompiledChunk::CallSite::ArgBind& b = site.argBinds[i];
         if (site.argNames[i]) {
             const std::string& name = *site.argNames[i];
-            int found = -1;
-            for (size_t p = 0; p < nparams; ++p) {
-                if (params[p]->name->name == name) {
-                    found = static_cast<int>(p);
-                    break;
-                }
-            }
-            b.paramIndex = found;
-            b.warnUnexpectedNamed = (found < 0) && !isConfigVariable(name);
-            b.toDyn = (found < 0) && !name.empty() && name[0] == '$';
+            bindEveryParamNamed(b, params, name);
+            const bool found = b.paramIndex >= 0;
+            b.warnUnexpectedNamed = !found && !isConfigVariable(name);
+            b.toDyn = !found && !name.empty() && name[0] == '$';
         } else {
             if (positionalIdx < nparams) {
-                b.paramIndex = static_cast<int>(positionalIdx);
+                // By NAME, not just by index: a positional argument landing on
+                // a repeated name filled every parameter of that name too,
+                // because the old path keyed its bound arguments by name.
+                bindEveryParamNamed(b, params, params[positionalIdx]->name->name);
             } else if (positionalIdx == nparams) {
                 b.warnTooManyPositional = true;
             }

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.7.2}/src/bytecode_vm.cpp

@@ -151,6 +151,17 @@ void bindPlannedArgsIntoFrame(const CompiledChunk& chunk, const CompiledChunk::C
     for (size_t i = 0; i < argCount; ++i) {
         const CompiledChunk::CallSite::ArgBind& b = site.argBinds[i];
         if (b.paramIndex >= 0) {
+            // The duplicate-name case (alsoParams) needs the value more than
+            // once, so it is copied there and only the last one moves.
+            for (const int extra : b.alsoParams) {
+                const CompiledChunk::Param& e = chunk.params[static_cast<size_t>(extra)];
+                if (e.isDyn) {
+                    ctx.dyn->set(e.name, args[i]);
+                } else {
+                    frame.slots[static_cast<size_t>(e.slot)] = args[i];
+                }
+                frame.bound[static_cast<size_t>(extra)] = true;
+            }
             const CompiledChunk::Param& p = chunk.params[static_cast<size_t>(b.paramIndex)];
             if (p.isDyn) {
                 ctx.dyn->set(p.name, std::move(args[i]));

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.7.2}/src/mesh_check.cpp

@@ -257,16 +257,40 @@ template <typename M>
 std::vector<Vert> weldMap(const M& m, size_t& welded) {
     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>, Vert> first;
     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; }
+    };
+    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);
-        auto key = std::make_tuple(llround(p[0] * 1e6), llround(p[1] * 1e6), llround(p[2] * 1e6));
-        auto [it, fresh] = first.emplace(key, static_cast<Vert>(v));
-        remap[v] = it->second;
-        if (!fresh) ++welded;
+        keyed.push_back({llround(p[0] * 1e6), llround(p[1] * 1e6), llround(p[2] * 1e6), 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;
     }
     return remap;
 }
@@ -274,17 +298,28 @@ std::vector<Vert> weldMap(const M& m, size_t& welded) {
 // Boundary loops, as ordered vertex rings. Each boundary edge belongs to
 // exactly one, so following them from any start returns to it.
 std::vector<std::vector<Vert>> boundaryLoops(const std::vector<std::array<Vert, 3>>& tris) {
-    std::map<Edge, int> count;
-    std::multimap<Vert, Vert> next;      // directed, along the boundary
+    // Every edge, sorted, so "used exactly once" is a run of length one --
+    // the same answer the std::map<Edge,int> gave, without a tree node per
+    // edge. `next` stays a multimap: boundary edges are a handful even on a
+    // badly broken mesh, and it is erased from while being traversed.
+    std::vector<uint64_t> edges;
+    edges.reserve(tris.size() * 3);
     for (const auto& t : tris) {
-        for (int i = 0; i < 3; ++i) ++count[undirected(t[i], t[(i + 1) % 3])];
+        for (int i = 0; i < 3; ++i) edges.push_back(edgeKey(undirected(t[i], t[(i + 1) % 3])));
     }
+    std::sort(edges.begin(), edges.end());
+    const auto usedOnce = [&edges](uint64_t key) {
+        const auto lo = std::lower_bound(edges.begin(), edges.end(), key);
+        return lo != edges.end() && *lo == key && (lo + 1 == edges.end() || *(lo + 1) != key);
+    };
+
+    std::multimap<Vert, Vert> next;      // directed, along the boundary
     for (const auto& t : tris) {
         for (int i = 0; i < 3; ++i) {
             const Vert a = t[i], b = t[(i + 1) % 3];
             // A boundary edge is walked backwards to close the hole: the
             // filling faces must wind against the face that owns the edge.
-            if (count[undirected(a, b)] == 1) next.emplace(b, a);
+            if (usedOnce(edgeKey(undirected(a, b)))) next.emplace(b, a);
         }
     }
     std::vector<std::vector<Vert>> loops;
@@ -320,25 +355,45 @@ M repairMesh(const M& mesh, MeshRepairReport& report) {
     const std::vector<Vert> remap = weldMap(mesh, welded);
     report.weldedVertices = welded;
 
-    std::vector<std::array<Vert, 3>> tris;
-    std::set<std::array<Vert, 3>> seen;
-    for (size_t t = 0; t < triCount(mesh); ++t) {
+    // Remap every face, then find the duplicates by sorting rather than by
+    // inserting each into a std::set -- one tree node per face otherwise.
+    // "First occurrence wins" survives because the sort carries the face
+    // index and every later member of a run is what gets marked.
+    const size_t nTris = triCount(mesh);
+    std::vector<std::array<Vert, 3>> remapped(nTris);
+    std::vector<char> isDegenerate(nTris, 0), isDuplicate(nTris, 0);
+    std::vector<std::pair<std::array<Vert, 3>, size_t>> byShape;
+    byShape.reserve(nTris);
+    for (size_t t = 0; t < nTris; ++t) {
         Vert v[3];
         triVerts(mesh, t, v);
         std::array<Vert, 3> f{remap[v[0]], remap[v[1]], remap[v[2]]};
+        remapped[t] = f;
         // 2. Degenerate faces, now that welding has collapsed slivers into
         //    repeated indices.
         if (f[0] == f[1] || f[1] == f[2] || f[0] == f[2]) {
-            ++report.droppedDegenerate;
+            isDegenerate[t] = 1;
             continue;
         }
         std::array<Vert, 3> sorted = f;
         std::sort(sorted.begin(), sorted.end());
-        if (!seen.insert(sorted).second) {
+        byShape.emplace_back(sorted, t);
+    }
+    std::sort(byShape.begin(), byShape.end());
+    for (size_t i = 1; i < byShape.size(); ++i) {
+        if (byShape[i].first == byShape[i - 1].first) isDuplicate[byShape[i].second] = 1;
+    }
+
+    std::vector<std::array<Vert, 3>> tris;
+    tris.reserve(nTris);
+    for (size_t t = 0; t < nTris; ++t) {
+        if (isDegenerate[t]) {
+            ++report.droppedDegenerate;
+        } else if (isDuplicate[t]) {
             ++report.droppedDuplicate;
-            continue;
+        } else {
+            tris.push_back(remapped[t]);
         }
-        tris.push_back(f);
     }
 
     std::vector<size_t> component;
@@ -349,12 +404,19 @@ M repairMesh(const M& mesh, MeshRepairReport& report) {
     //    Before filling, so the new faces are wound against a settled
     //    surface rather than a mixed one.
     {
-        std::map<Edge, std::vector<size_t>> edgeTris;
+        // Every edge really is needed here (the flood fill walks all of
+        // them), so unlike stripSlivers' index this cannot be narrowed --
+        // but it can stop allocating a tree node per edge. Sorted flat, then
+        // searched by equal_range. Faces still come back in ascending index
+        // order within an edge, which the fill's traversal order depends on.
+        std::vector<std::pair<uint64_t, size_t>> edgeTris;
+        edgeTris.reserve(tris.size() * 3);
         for (size_t i = 0; i < tris.size(); ++i) {
             for (int e = 0; e < 3; ++e) {
-                edgeTris[undirected(tris[i][e], tris[i][(e + 1) % 3])].push_back(i);
+                edgeTris.emplace_back(edgeKey(undirected(tris[i][e], tris[i][(e + 1) % 3])), i);
             }
         }
+        std::sort(edgeTris.begin(), edgeTris.end());
         component.assign(tris.size(), SIZE_MAX);
         std::vector<char> done(tris.size(), 0);
         for (size_t seed = 0; seed < tris.size(); ++seed) {
@@ -368,7 +430,11 @@ M repairMesh(const M& mesh, MeshRepairReport& report) {
                 stack.pop_back();
                 for (int e = 0; e < 3; ++e) {
                     const Vert a = tris[i][e], b = tris[i][(e + 1) % 3];
-                    for (size_t j : edgeTris[undirected(a, b)]) {
+                    const uint64_t key = edgeKey(undirected(a, b));
+                    const auto lo = std::lower_bound(edgeTris.begin(), edgeTris.end(),
+                                                      std::make_pair(key, size_t{0}));
+                    for (auto it = lo; it != edgeTris.end() && it->first == key; ++it) {
+                        const size_t j = it->second;
                         if (j == i || done[j]) continue;
                         bool sameDir = false;
                         for (int f = 0; f < 3; ++f) {
@@ -427,22 +493,27 @@ M repairMesh(const M& mesh, MeshRepairReport& report) {
     // component that was turned inside out and then back reports nothing,
     // which is what the user sees.
     {
-        std::set<std::array<Vert, 3>> before;
-        for (size_t t = 0; t < triCount(mesh); ++t) {
-            Vert v[3];
-            triVerts(mesh, t, v);
-            before.insert({remap[v[0]], remap[v[1]], remap[v[2]]});
-        }
         auto rotated = [](std::array<Vert, 3> f) {
             // Winding is defined up to rotation, so compare canonically.
             if (f[1] < f[0] && f[1] <= f[2]) return std::array<Vert, 3>{f[1], f[2], f[0]};
             if (f[2] < f[0] && f[2] <= f[1]) return std::array<Vert, 3>{f[2], f[0], f[1]};
             return f;
         };
-        std::set<std::array<Vert, 3>> canon;
-        for (const auto& f : before) canon.insert(rotated(f));
+        // Was two std::sets over every face -- the incoming windings and
+        // their canonical rotations. One sorted, deduplicated vector answers
+        // the same membership questions with no node allocations. Built from
+        // `remapped`, which is every ORIGINAL face including the degenerate
+        // ones the set also held.
+        std::vector<std::array<Vert, 3>> canon;
+        canon.reserve(remapped.size());
+        for (const auto& f : remapped) canon.push_back(rotated(f));
+        std::sort(canon.begin(), canon.end());
+        canon.erase(std::unique(canon.begin(), canon.end()), canon.end());
+        const auto known = [&canon](const std::array<Vert, 3>& f) {
+            return std::binary_search(canon.begin(), canon.end(), f);
+        };
         for (const auto& f : tris) {
-            if (!canon.count(rotated(f)) && canon.count(rotated({f[0], f[2], f[1]}))) {
+            if (!known(rotated(f)) && known(rotated({f[0], f[2], f[1]}))) {
                 ++report.reversedFaces;
             }
         }

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.7.2}/tests/test_bytecode_compiler.cpp

@@ -2159,3 +2159,35 @@ TEST(BytecodeCompiler, CompileTimeArgumentPlanMatchesTheNameMatchingRules) {
                                "echo(count(100));"),
               "ECHO: 5050");
 }
+
+// A declaration may repeat a parameter name. BOSL2's regular_prism() declares
+// both `length` and `height` twice, and three of its own documentation
+// examples stopped rendering when the compile-time argument plan bound only
+// the first of them -- the body read undef from whichever slot the repeated
+// name finally resolved to, and asserted. The name-matching path this
+// replaced filled every parameter of that name, because it walked the
+// PARAMETERS asking which argument matched, not the other way round.
+TEST(BytecodeCompiler, ARepeatedParameterNameIsBoundEveryTimeItAppears) {
+    const std::string f = "function f(a, height, b, height) = str(a, \"/\", height, \"/\", b);\n";
+    const std::string g = "function g(height, b, height) = str(height, \"/\", b);\n";
+
+    for (const auto& [src, call] : std::vector<std::pair<std::string, std::string>>{
+             {f, "f(a = 1, height = 20, b = 2)"},   // named
+             {f, "f(1, 20, 2)"},                    // positional landing on the first copy
+             {g, "g(20, 2)"},                       // repeated name in first position
+             {f, "f(a = 1, b = 2, height = 20)"},   // named, out of order
+         }) {
+        std::string compiled, interpreted;
+        {
+            ScopedVm on(true);
+            compiled = runCapturingEcho(src + "echo(" + call + ");");
+        }
+        {
+            ScopedVm off(false);
+            interpreted = runCapturingEcho(src + "echo(" + call + ");");
+        }
+        EXPECT_EQ(compiled, interpreted) << "VM and interpreter disagree for: " << call;
+        EXPECT_NE(compiled.find("20"), std::string::npos)
+            << call << " lost its repeated-name argument: " << compiled;
+    }
+}

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.7.2}/tests/test_mesh_check.cpp

@@ -358,6 +358,33 @@ TEST(SliverStrip, ANeedleIsRemovedWithoutSplittingAnything) {
     EXPECT_TRUE(d.manifold()) << d.summary();
 }
 
+// Three copies of one position is TWO welds, not one, and the survivor is the
+// lowest-numbered of them. Both facts used to fall out of inserting into a
+// std::map and keeping whatever was already there; they now come from run
+// lengths in a sorted list, where an off-by-one or a wrong representative
+// would be silent -- the geometry is identical either way, only the indices
+// differ.
+TEST(MeshCheck, ThreeCoincidentVerticesAreTwoWeldsOntoTheLowestIndex) {
+    manifold::MeshGL m = tetra();
+    const uint32_t a = 4, b = 5;
+    m.vertProperties.insert(m.vertProperties.end(), {0, 0, 0});   // == vertex 0
+    m.vertProperties.insert(m.vertProperties.end(), {0, 0, 0});   // == vertex 0 again
+    bool usedA = false;
+    for (size_t i = 0; i < m.triVerts.size(); ++i) {
+        if (m.triVerts[i] != 0 || i < 6) continue;
+        m.triVerts[i] = usedA ? b : a;                            // spread over both copies
+        usedA = !usedA;
+    }
+
+    MeshRepairReport r;
+    const manifold::MeshGL fixed = repairMesh(m, r);
+    EXPECT_EQ(r.weldedVertices, 2u) << r.summary();
+    for (uint32_t v : fixed.triVerts) {
+        EXPECT_NE(v, a) << "welded away, so no face may still name it";
+        EXPECT_NE(v, b) << "welded away, so no face may still name it";
+    }
+}
+
 // import(repair=true) goes through repairMesh, so it has to deal with
 // slivers too -- an imported STL is exactly where they turn up.
 TEST(MeshRepair, StripsSliversAndRestitchesThem) {