openscad-cpp-evaluator 1.20.2__tar.gz → 1.20.5__tar.gz

{openscad_cpp_evaluator-1.20.2 → openscad_cpp_evaluator-1.20.5}/PKG-INFO

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

{openscad_cpp_evaluator-1.20.2 → openscad_cpp_evaluator-1.20.5}/pyproject.toml

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

{openscad_cpp_evaluator-1.20.2 → openscad_cpp_evaluator-1.20.5}/src/builtins/text.cpp

@@ -70,6 +70,16 @@ CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     }
 
     CSGParams params;
+    // The handle is what generateText looks the face up by, but it is an
+    // index into THIS evaluator's FontProvider -- the first font resolved
+    // is handle 0 whatever it is. Two evaluators sharing a ManifoldCache
+    // (two tabs in a GUI, say) therefore agreed on "font_handle=0" for
+    // entirely different fonts, and the second render was served the
+    // first one's glyphs. The spec goes in the params too, so the cache
+    // key tells them apart: the same spec always resolves to the same
+    // face, and two specs that happen to resolve alike merely miss the
+    // cache rather than collide.
+    params["font_spec"] = Value{fontSpec};
     params["font_handle"] = Value{static_cast<double>(handle)};
     params["scale"] = Value{scale};
     params["segs"] = Value{static_cast<double>(segs)};

{openscad_cpp_evaluator-1.20.2 → openscad_cpp_evaluator-1.20.5}/src/export.cpp

@@ -362,9 +362,7 @@ void meshToArrays(const manifold::MeshGL& mesh, std::vector<float>& verts, std::
     tris = mesh.triVerts;
 }
 
-bool boxesOverlap(const manifold::Manifold& a, const manifold::Manifold& b) {
-    const manifold::Box ba = a.BoundingBox();
-    const manifold::Box bb = b.BoundingBox();
+bool boxesOverlap(const manifold::Box& ba, const manifold::Box& bb) {
     return !(ba.max.x < bb.min.x || bb.max.x < ba.min.x || ba.max.y < bb.min.y || bb.max.y < ba.min.y ||
              ba.max.z < bb.min.z || bb.max.z < ba.min.z);
 }
@@ -512,25 +510,42 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
             c.key = keys[0];
             claimedGroups.push_back(std::move(c));
         } else {
-            // Reverse order + subtract-what-is-already-claimed is what makes
-            // the LATER body win: by the time an earlier one is reached,
-            // everything after it has already taken its volume.
-            std::optional<manifold::Manifold> claimed;
+            // Reverse order is what makes the LATER body win: by the time
+            // an earlier one is reached, everything after it has already
+            // taken its volume.
+            //
+            // Each body is cut by the later ones that actually REACH it, not
+            // by a running union of all of them. The running union was
+            // quadratic -- it grows to span the whole model, so every one of
+            // n subtractions faced O(n) geometry however little the parts
+            // really touched, and a 100-body 3MF spent 6.6s on it (#177).
+            //
+            // The result is identical: a later body whose bounding box is
+            // disjoint from this one cannot intersect it, and subtracting a
+            // disjoint solid removes no volume. Bounding boxes settle that in
+            // nanoseconds, so what is left is proportional to how much the
+            // model overlaps rather than to how many parts it has.
+            //
+            // Skipping the subtraction entirely when nothing overlaps is not
+            // just a shortcut: `A - disjoint B` returns A's volume but
+            // REORDERS its triangle list, which throws away any per-triangle
+            // colours A carried. Most models are mostly disjoint parts, so
+            // without this a two-tone body lost its colours the moment any
+            // other differently-coloured body existed.
+            std::vector<manifold::Box> boxes;
+            boxes.reserve(solids.size());
+            for (const Solid& s : solids) boxes.push_back(s.man.BoundingBox());
+
             std::vector<Claimed> owned;
+            std::vector<manifold::Manifold> blockers;
             for (size_t n = solids.size(); n-- > 0;) {
                 Solid& s = solids[n];
-                manifold::Manifold piece = s.man;
-                if (claimed) {
-                    // Skipping the subtraction when the bounding boxes
-                    // cannot overlap is not just a shortcut: `A - disjoint
-                    // B` returns A's volume but REORDERS its triangle list,
-                    // which throws away any per-triangle colours A carried.
-                    // Most models are mostly disjoint parts, so without this
-                    // a two-tone body lost its colours the moment any other
-                    // differently-coloured body existed.
-                    if (boxesOverlap(s.man, *claimed)) piece = s.man - *claimed;
+                blockers.clear();
+                for (size_t m = n + 1; m < solids.size(); ++m) {
+                    if (boxesOverlap(boxes[n], boxes[m])) blockers.push_back(solids[m].man);
                 }
-                claimed = claimed ? (*claimed + s.man) : s.man;
+                manifold::Manifold piece = s.man;
+                if (!blockers.empty()) piece = s.man - addAll(blockers);
                 if (piece.IsEmpty()) continue;
                 Claimed c;
                 c.man = std::move(piece);

{openscad_cpp_evaluator-1.20.2 → openscad_cpp_evaluator-1.20.5}/src/mesh_check.cpp

@@ -79,20 +79,56 @@ size_t countUnwelded(const M& m) {
 // The faces around `v`, as (prev, next) pairs on the opposite edge. The link
 // is one cycle when following those pairs from any starting corner visits
 // all of them; more than one walk means the surface pinches at v.
+//
+// `vertTris` is CSR: the triangles around vertex v are
+// vertTriList[vertTriStart[v] .. vertTriStart[v+1]).
+//
+// Every buffer here is hoisted out of the loop and cleared per vertex. The
+// straightforward spelling -- an unordered_map of vectors for the link and a
+// std::set for the walk, both built fresh per vertex -- allocated on the
+// order of a dozen blocks for each of a mesh's vertices, millions of them on
+// a 200K-triangle model, to answer a question about roughly six neighbours.
+// Same reason the edge and face counts below collect flat and sort; see
+// their comment.
 template <typename M>
 size_t countPinched(const M& m,
-                    const std::vector<std::vector<size_t>>& vertTris) {
+                    const std::vector<size_t>& vertTriStart,
+                    const std::vector<size_t>& vertTriList) {
     size_t pinched = 0;
-    for (Vert v = 0; v < vertTris.size(); ++v) {
-        const auto& tris = vertTris[v];
-        if (tris.size() < 2) continue;
-        // next[a] = b for the corner opposite v in each face, undirected so
-        // a reversed neighbour still links up -- winding is checked
-        // separately and should not show up as a pinch too.
-        std::unordered_map<Vert, std::vector<Vert>> link;
-        for (size_t t : tris) {
+    const size_t nVerts = vertTriStart.empty() ? 0 : vertTriStart.size() - 1;
+
+    std::vector<Vert> nodes;        // the distinct neighbours of v
+    std::vector<size_t> parent;     // union-find over indices into `nodes`
+    std::vector<std::pair<uint32_t, uint32_t>> edges;
+
+    // Linear search, not a map: a vertex has a handful of neighbours, and at
+    // that size a scan beats hashing outright -- no allocation, no hashing,
+    // and the whole thing stays in cache.
+    const auto indexOf = [&](Vert w) -> uint32_t {
+        for (size_t i = 0; i < nodes.size(); ++i) {
+            if (nodes[i] == w) return static_cast<uint32_t>(i);
+        }
+        nodes.push_back(w);
+        parent.push_back(parent.size());
+        return static_cast<uint32_t>(nodes.size() - 1);
+    };
+    const auto find = [&](size_t i) {
+        while (parent[i] != i) {
+            parent[i] = parent[parent[i]];   // path halving
+            i = parent[i];
+        }
+        return i;
+    };
+
+    for (Vert v = 0; v < nVerts; ++v) {
+        const size_t begin = vertTriStart[v], end = vertTriStart[v + 1];
+        if (end - begin < 2) continue;
+        nodes.clear();
+        parent.clear();
+        edges.clear();
+        for (size_t k = begin; k < end; ++k) {
             Vert w[3];
-            triVerts(m, t, w);
+            triVerts(m, vertTriList[k], w);
             Vert a = 0, b = 0;
             int found = 0;
             for (int i = 0; i < 3; ++i) {
@@ -100,21 +136,20 @@ size_t countPinched(const M& m,
                 (found++ == 0 ? a : b) = w[i];
             }
             if (found < 2) continue;      // degenerate; counted elsewhere
-            link[a].push_back(b);
-            link[b].push_back(a);
+            edges.emplace_back(indexOf(a), indexOf(b));
         }
-        if (link.empty()) continue;
-        std::set<Vert> visited;
-        std::vector<Vert> stack{link.begin()->first};
-        while (!stack.empty()) {
-            Vert cur = stack.back();
-            stack.pop_back();
-            if (!visited.insert(cur).second) continue;
-            for (Vert nxt : link[cur]) {
-                if (!visited.count(nxt)) stack.push_back(nxt);
-            }
+        if (nodes.empty()) continue;
+        // Undirected, so a reversed neighbour still links up -- winding is
+        // checked separately and should not show up as a pinch too.
+        for (const auto& e : edges) {
+            const size_t ra = find(e.first), rb = find(e.second);
+            if (ra != rb) parent[ra] = rb;
+        }
+        size_t components = 0;
+        for (size_t i = 0; i < parent.size(); ++i) {
+            if (find(i) == i) ++components;
         }
-        if (visited.size() < link.size()) ++pinched;
+        if (components > 1) ++pinched;
     }
     return pinched;
 }
@@ -158,10 +193,16 @@ MeshDiagnosis checkMesh(const M& mesh) {
     // index below; see its comment for the measurement.
     std::vector<std::pair<uint64_t, bool>> uses;   // {undirected edge, traversed a->b}
     uses.reserve(tris * 3);
-    std::vector<std::vector<size_t>> vertTris(nVerts);
     std::vector<std::array<Vert, 3>> seenFaces;    // sorted-corner triples, deduplicated below
     seenFaces.reserve(tris);
 
+    // The triangles around each vertex, CSR rather than a vector per vertex:
+    // one inner vector per vertex is an allocation per vertex, and they are
+    // only ever read back as a flat run. Counted here, filled after the scan.
+    std::vector<size_t> vertTriStart(nVerts + 1, 0);
+    std::vector<size_t> vertTriList;
+    vertTriList.reserve(tris * 3);
+
     for (size_t t = 0; t < tris; ++t) {
         if (degenerate(mesh, t)) ++d.degenerateFaces;
         // Counted, but NOT removed from the topology. A zero-area triangle
@@ -181,12 +222,26 @@ MeshDiagnosis checkMesh(const M& mesh) {
         seenFaces.push_back(sorted);
 
         for (int i = 0; i < 3; ++i) {
-            if (v[i] < nVerts) vertTris[v[i]].push_back(t);
+            if (v[i] < nVerts) ++vertTriStart[v[i] + 1];
             const Vert a = v[i], b = v[(i + 1) % 3];
             uses.emplace_back(edgeKey(undirected(a, b)), a < b);
         }
     }
 
+    for (size_t i = 0; i < nVerts; ++i) vertTriStart[i + 1] += vertTriStart[i];
+    vertTriList.resize(vertTriStart[nVerts]);
+    {
+        std::vector<size_t> fill(vertTriStart.begin(), vertTriStart.end() - 1);
+        for (size_t t = 0; t < tris; ++t) {
+            if (repeatsAVertex(mesh, t)) continue;   // skipped above too
+            Vert v[3];
+            triVerts(mesh, t, v);
+            for (int i = 0; i < 3; ++i) {
+                if (v[i] < nVerts) vertTriList[fill[v[i]]++] = t;
+            }
+        }
+    }
+
     // A face seen N times is N-1 duplicates, which is what insert().second
     // counted one at a time.
     std::sort(seenFaces.begin(), seenFaces.end());
@@ -214,7 +269,7 @@ MeshDiagnosis checkMesh(const M& mesh) {
         i = j;
     }
 
-    d.pinchedVertices = countPinched(mesh, vertTris);
+    d.pinchedVertices = countPinched(mesh, vertTriStart, vertTriList);
     d.unweldedVertices = countUnwelded(mesh);
     return d;
 }

{openscad_cpp_evaluator-1.20.2 → openscad_cpp_evaluator-1.20.5}/tests/test_export.cpp

@@ -5,6 +5,7 @@
 #include "test_helpers.hpp"
 
 #include <algorithm>
+#include <array>
 #include <cstdint>
 #include <cstdio>
 #include <filesystem>
@@ -755,6 +756,69 @@ TEST(SplitColors, SingleMaterialGivesOneObject) {
     EXPECT_TRUE(objs[0].triColors.empty());  // no per-triangle colour to carry
 }
 
+// Each body is cut only by the later bodies that actually reach it, rather
+// than by a running union of all of them (#177). These pin the two things
+// that rewrite must not change.
+
+TEST(SplitColors, AFarAwayBodyChangesNothing) {
+    // A body nowhere near the others cannot take volume from them, so adding
+    // one must leave every other object exactly as it was. The old code
+    // subtracted the union of ALL later bodies and leaned on a bounding-box
+    // test against that union to stay correct -- once the union spanned the
+    // model, the test stopped discriminating.
+    const std::string pair =
+        "color(\"red\") cube(10); color(\"blue\") translate([5,0,0]) cube(10);";
+    std::vector<ColoredBody> without = evalToBodies(pair);
+    std::vector<ColoredBody> with =
+        evalToBodies(pair + " color(\"green\") translate([500,0,0]) cube(10);");
+
+    const std::vector<ExportObject> a = splitBodiesForExport(without, nullptr, false, true);
+    const std::vector<ExportObject> b = splitBodiesForExport(with, nullptr, false, true);
+    ASSERT_EQ(a.size(), 2u);
+    ASSERT_EQ(b.size(), 3u);
+    for (size_t i = 0; i < a.size(); ++i) {
+        EXPECT_EQ(a[i].tris.size(), b[i].tris.size()) << "object " << i << " was re-cut";
+        EXPECT_EQ(a[i].verts.size(), b[i].verts.size()) << "object " << i << " was re-cut";
+    }
+}
+
+TEST(SplitColors, LaterWinsAcrossAnInterveningColour) {
+    // red, blue, red -- all overlapping, in that order. The later body wins,
+    // so the second red takes its volume whole, blue keeps only what that
+    // red does not cover, and the first red keeps only what neither does.
+    //
+    // Worth pinning because the obvious way to make this cheaper -- union
+    // the same-coloured bodies first, then subtract per colour -- gets it
+    // wrong: it would let the first red beat the blue that comes after it.
+    std::vector<ColoredBody> bodies = evalToBodies(
+        "color(\"red\")  cube(10);"
+        "color(\"blue\") translate([5,0,0]) cube(10);"
+        "color(\"red\")  translate([10,0,0]) cube(10);");
+    const std::vector<ExportObject> objs = splitBodiesForExport(bodies, nullptr, false, true);
+    ASSERT_EQ(objs.size(), 2u);   // one per colour, the two reds merged
+
+    const auto volumeOf = [](const ExportObject& o) {
+        double v = 0.0;
+        for (size_t t = 0; t + 2 < o.tris.size(); t += 3) {
+            const auto at = [&](size_t k) {
+                const size_t b = static_cast<size_t>(o.tris[t + k]) * 3;
+                return std::array<double, 3>{o.verts[b], o.verts[b + 1], o.verts[b + 2]};
+            };
+            const std::array<double, 3> p = at(0), q = at(1), r = at(2);
+            v += (p[0] * (q[1] * r[2] - q[2] * r[1]) - p[1] * (q[0] * r[2] - q[2] * r[0]) +
+                  p[2] * (q[0] * r[1] - q[1] * r[0])) / 6.0;
+        }
+        return v;
+    };
+
+    // Blue spans x 5..15 and the later red takes x 10..20, leaving x 5..10:
+    // 5 x 10 x 10. The reds keep everything else: 2000 - 500.
+    double red = 0.0, blue = 0.0;
+    for (const ExportObject& o : objs) (o.color[2] > o.color[0] ? blue : red) += volumeOf(o);
+    EXPECT_NEAR(blue, 500.0, 1e-6);
+    EXPECT_NEAR(red, 1500.0, 1e-6);
+}
+
 TEST(SplitColors, SingleMaterialWeldsTouchingColourRegions) {
     // Unioned, not concatenated: two touching cubes of different colours
     // must come out as one solid without the coincident interior faces

{openscad_cpp_evaluator-1.20.2 → openscad_cpp_evaluator-1.20.5}/tests/test_manifold_cache.cpp

@@ -36,6 +36,28 @@ TEST(ManifoldCacheKey, BoolAndNumberParamsProduceDifferentCacheKeys) {
     EXPECT_NE(cacheKey(a), cacheKey(b));
 }
 
+TEST(ManifoldCacheKey, TwoFontsWithTheSameHandleDoNotShareAKey) {
+    // A FontHandle indexes the EVALUATOR's own FontProvider, so the first
+    // font any evaluator resolves is handle 0 whatever it is. Two
+    // evaluators sharing one ManifoldCache -- two tabs in a GUI -- agreed
+    // on "font_handle=0" for entirely different fonts, and the second was
+    // served the first one's glyphs. text() puts the SPEC in the params
+    // too, so the key tells them apart.
+    CSGNode a;
+    a.kind = "text";
+    a.isBuiltin = true;
+    a.params["font_handle"] = Value{0.0};
+    a.params["font_spec"] = Value{std::string("Arial:style=Regular")};
+
+    CSGNode b;
+    b.kind = "text";
+    b.isBuiltin = true;
+    b.params["font_handle"] = Value{0.0};          // same handle, different font
+    b.params["font_spec"] = Value{std::string("Arial:style=Bold")};
+
+    EXPECT_NE(cacheKey(a), cacheKey(b));
+}
+
 TEST(ManifoldCacheKey, IdenticalStructureProducesIdenticalKeyRegardlessOfParamInsertionOrder) {
     CSGNode a;
     a.kind = "cube";

{openscad_cpp_evaluator-1.20.2 → openscad_cpp_evaluator-1.20.5}/tests/test_mesh_check.cpp

@@ -76,6 +76,26 @@ TEST(MeshCheck, TwoTetrahedraSharingOneVertexPinchThere) {
     EXPECT_FALSE(d.manifold());
 }
 
+TEST(MeshCheck, ThreeTetrahedraOnOneVertexAreStillOnePinchedVertex) {
+    // The link at vertex 0 falls into THREE pieces, not two. The count is of
+    // pinched VERTICES, so this is still 1 -- worth pinning because the walk
+    // only has to notice that the link is not one piece, and an
+    // implementation that counts pieces instead would say 2 here and agree
+    // with the two-tetrahedron case by luck.
+    manifold::MeshGL m = tetra();
+    for (int k = 0; k < 2; ++k) {
+        const uint32_t base = static_cast<uint32_t>(m.vertProperties.size() / 3);
+        const float z = -1.0f - static_cast<float>(k) * 2.0f;
+        m.vertProperties.insert(m.vertProperties.end(),
+                                {0, 0, z,  1, 0, z,  0, 1, z});
+        m.triVerts.insert(m.triVerts.end(), {
+            0u, base + 1, base,      0u, base, base + 2,
+            0u, base + 2, base + 1,  base, base + 1, base + 2});
+    }
+    const MeshDiagnosis d = checkMesh(m);
+    EXPECT_EQ(d.pinchedVertices, 1u) << d.summary();
+}
+
 TEST(MeshCheck, AReversedFaceIsCaughtAsInconsistentWinding) {
     manifold::MeshGL m = tetra();
     std::swap(m.triVerts[1], m.triVerts[2]);      // flip one face

{openscad_cpp_evaluator-1.20.2 → openscad_cpp_evaluator-1.20.5}/tests/test_text.cpp

@@ -422,3 +422,30 @@ TEST(TextArgs, FontIsPositionalButTheRestAreNot) {
     // NOTHING, and halign by name does move it.
     EXPECT_EQ(echoes[0], "ECHO: true, false, true, false");
 }
+
+namespace oscadeval {
+
+// Why text() must put the font SPEC in its CSG params and not just the
+// handle: a handle numbers faces WITHIN one provider, and every Evaluator
+// makes its own. Two evaluators sharing a ManifoldCache -- two GUI tabs --
+// hand the cache the same number for different fonts (BelfrySCAD#434).
+TEST(FontHandles, AreOnlyMeaningfulWithinOneProvider) {
+    FreetypeFontProvider a, b;
+    const FontHandle aReg = a.resolveFont("Arial:style=Regular");
+    const FontHandle aBold = a.resolveFont("Arial:style=Bold");
+    if (aReg == aBold) {
+        GTEST_SKIP() << "this machine resolves both specs to one face";
+    }
+    EXPECT_NE(aReg, aBold) << "within one provider, two fonts get two handles";
+    // What a second provider numbers them is NOT asserted: it depends on
+    // which faces that machine has and the order they are opened in. On
+    // macOS a fresh provider resolving Bold first returns 4 -- the same
+    // number the first provider gave REGULAR, which is the collision this
+    // whole change is about. On a Linux runner with only the bundled faces
+    // the numbering happens to line up instead (0 and 1 either way). That
+    // it CAN collide is the point, and it is not a property to pin to a
+    // number here; the end-to-end regression test lives in BelfrySCAD,
+    // where the collision reproduces in both directions.
+}
+
+} // namespace oscadeval