openscad-cpp-evaluator 0.28.2__tar.gz → 0.29.1__tar.gz

{openscad_cpp_evaluator-0.28.2 → openscad_cpp_evaluator-0.29.1}/PKG-INFO

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

{openscad_cpp_evaluator-0.28.2 → openscad_cpp_evaluator-0.29.1}/pyproject.toml

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

{openscad_cpp_evaluator-0.28.2 → openscad_cpp_evaluator-0.29.1}/src/builtins/primitives_3d.cpp

@@ -239,6 +239,164 @@ std::vector<ColoredBody> generateCylinder(Evaluator& ev, const CSGParams& params
 // otherwise produce a NotManifold body). Mirrors
 // _resolve_polyhedron/_generate_polyhedron.
 
+
+namespace {
+
+// Triangulate one polyhedron face.
+//
+// A fan -- (v0, vi, vi+1) for every i -- is only correct for a polygon
+// that is both convex and planar, and BOSL2's vnf_polyhedron() routinely
+// hands over neither. The end caps of a nurbs_sheet() are 34-gons that
+// are concave and 3.5 units out of plane; fanning one produced 32
+// triangles covering 281% of the cap's true area with 15 of them wound
+// inside out, which inflated the finished solid by 12% of its surface
+// area and 5% of its volume.
+//
+// Ear clipping in the face's own best-fit plane instead. Newell's method
+// gives a normal that stays meaningful when the points are not coplanar,
+// which is what makes projecting them usable at all here.
+//
+// ponytail: O(n^2). Faces are a handful of points in nearly every model
+// and 34 in the one that prompted this; revisit if a model ever arrives
+// with thousand-sided faces.
+void triangulateFace(const std::vector<std::array<double, 3>>& verts, const std::vector<size_t>& loop,
+                      std::vector<uint32_t>& out) {
+    const size_t n = loop.size();
+    if (n < 3) return;
+
+    // Winding is reversed on the way out throughout: OpenSCAD's faces are
+    // clockwise seen from outside, Manifold wants counter-clockwise.
+    auto emit = [&out](size_t a, size_t b, size_t c) {
+        if (a == b || b == c || a == c) return;
+        out.push_back(static_cast<uint32_t>(a));
+        out.push_back(static_cast<uint32_t>(c));
+        out.push_back(static_cast<uint32_t>(b));
+    };
+    if (n == 3) {
+        emit(loop[0], loop[1], loop[2]);
+        return;
+    }
+
+    std::array<double, 3> nrm = {0.0, 0.0, 0.0};
+    for (size_t i = 0; i < n; ++i) {
+        const std::array<double, 3>& a = verts[loop[i]];
+        const std::array<double, 3>& b = verts[loop[(i + 1) % n]];
+        nrm[0] += (a[1] - b[1]) * (a[2] + b[2]);
+        nrm[1] += (a[2] - b[2]) * (a[0] + b[0]);
+        nrm[2] += (a[0] - b[0]) * (a[1] + b[1]);
+    }
+    const double len = std::sqrt(nrm[0] * nrm[0] + nrm[1] * nrm[1] + nrm[2] * nrm[2]);
+    if (!(len > 1e-12)) {
+        // Every point collinear, or the loop encloses no area: a fan is as
+        // good as anything and cannot make it worse.
+        for (size_t i = 1; i + 1 < n; ++i) emit(loop[0], loop[i], loop[i + 1]);
+        return;
+    }
+    for (double& c : nrm) c /= len;
+
+    // Any two axes spanning the plane will do; take the world axis least
+    // aligned with the normal so the projection never collapses.
+    const size_t drop = (std::abs(nrm[0]) > std::abs(nrm[1]))
+                            ? ((std::abs(nrm[0]) > std::abs(nrm[2])) ? 0 : 2)
+                            : ((std::abs(nrm[1]) > std::abs(nrm[2])) ? 1 : 2);
+    std::array<double, 3> axis = {0.0, 0.0, 0.0};
+    axis[(drop + 1) % 3] = 1.0;
+    std::array<double, 3> u = {axis[1] * nrm[2] - axis[2] * nrm[1], axis[2] * nrm[0] - axis[0] * nrm[2],
+                                axis[0] * nrm[1] - axis[1] * nrm[0]};
+    const double ulen = std::sqrt(u[0] * u[0] + u[1] * u[1] + u[2] * u[2]);
+    if (!(ulen > 1e-12)) {
+        for (size_t i = 1; i + 1 < n; ++i) emit(loop[0], loop[i], loop[i + 1]);
+        return;
+    }
+    for (double& c : u) c /= ulen;
+    const std::array<double, 3> w = {nrm[1] * u[2] - nrm[2] * u[1], nrm[2] * u[0] - nrm[0] * u[2],
+                                      nrm[0] * u[1] - nrm[1] * u[0]};
+
+    std::vector<std::array<double, 2>> flat(n);
+    for (size_t i = 0; i < n; ++i) {
+        const std::array<double, 3>& p = verts[loop[i]];
+        flat[i] = {p[0] * u[0] + p[1] * u[1] + p[2] * u[2], p[0] * w[0] + p[1] * w[1] + p[2] * w[2]};
+    }
+
+    auto cross2 = [](const std::array<double, 2>& a, const std::array<double, 2>& b,
+                     const std::array<double, 2>& c) {
+        return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+    };
+    double twiceArea = 0.0;
+    for (size_t i = 0; i < n; ++i) {
+        const std::array<double, 2>& a = flat[i];
+        const std::array<double, 2>& b = flat[(i + 1) % n];
+        twiceArea += a[0] * b[1] - b[0] * a[1];
+    }
+
+    std::vector<size_t> idx(n);
+    for (size_t i = 0; i < n; ++i) idx[i] = i;
+    if (twiceArea < 0.0) std::reverse(idx.begin(), idx.end());   // work counter-clockwise
+
+    auto inside = [&](const std::array<double, 2>& a, const std::array<double, 2>& b,
+                      const std::array<double, 2>& c, const std::array<double, 2>& p) {
+        // Strictly inside, so a vertex sitting exactly on an edge does not
+        // veto an otherwise good ear.
+        const double d1 = cross2(a, b, p), d2 = cross2(b, c, p), d3 = cross2(c, a, p);
+        return d1 > 1e-12 && d2 > 1e-12 && d3 > 1e-12;
+    };
+
+    // Take the best-shaped ear available rather than the first one found.
+    // Any valid ear gives a correct triangulation, but on a face that is
+    // not flat the choice decides how the surface folds: first-found
+    // clipping strung long thin triangles across the curved end caps and
+    // came out 29% larger in area than the reference's tessellation of the
+    // same polygon. Preferring fat ears tracks the surface instead.
+    auto squareness = [&](size_t a, size_t b, size_t c) {
+        // Twice the area over the sum of the squared sides -- highest for
+        // an equilateral triangle, near zero for a sliver.
+        const std::array<double, 3>& p = verts[loop[a]];
+        const std::array<double, 3>& q = verts[loop[b]];
+        const std::array<double, 3>& r = verts[loop[c]];
+        const std::array<double, 3> e1 = {q[0] - p[0], q[1] - p[1], q[2] - p[2]};
+        const std::array<double, 3> e2 = {r[0] - p[0], r[1] - p[1], r[2] - p[2]};
+        const std::array<double, 3> e3 = {r[0] - q[0], r[1] - q[1], r[2] - q[2]};
+        const std::array<double, 3> x = {e1[1] * e2[2] - e1[2] * e2[1], e1[2] * e2[0] - e1[0] * e2[2],
+                                          e1[0] * e2[1] - e1[1] * e2[0]};
+        const double area = std::sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
+        const double sides = e1[0] * e1[0] + e1[1] * e1[1] + e1[2] * e1[2] +
+                              e2[0] * e2[0] + e2[1] * e2[1] + e2[2] * e2[2] +
+                              e3[0] * e3[0] + e3[1] * e3[1] + e3[2] * e3[2];
+        return sides > 1e-18 ? area / sides : 0.0;
+    };
+
+    size_t guard = 0;
+    while (idx.size() > 3 && guard++ < n * n) {
+        size_t bestAt = idx.size();
+        double bestScore = -1.0;
+        for (size_t i = 0; i < idx.size(); ++i) {
+            const size_t pi = idx[(i + idx.size() - 1) % idx.size()];
+            const size_t ci = idx[i];
+            const size_t ni = idx[(i + 1) % idx.size()];
+            if (cross2(flat[pi], flat[ci], flat[ni]) <= 1e-12) continue;   // reflex, not an ear
+            bool empty = true;
+            for (size_t other : idx) {
+                if (other == pi || other == ci || other == ni) continue;
+                if (inside(flat[pi], flat[ci], flat[ni], flat[other])) { empty = false; break; }
+            }
+            if (!empty) continue;
+            const double score = squareness(pi, ci, ni);
+            if (score > bestScore) { bestScore = score; bestAt = i; }
+        }
+        if (bestAt == idx.size()) break;   // self-intersecting or otherwise unclippable
+        const size_t pi = idx[(bestAt + idx.size() - 1) % idx.size()];
+        const size_t ci = idx[bestAt];
+        const size_t ni = idx[(bestAt + 1) % idx.size()];
+        emit(loop[pi], loop[ci], loop[ni]);
+        idx.erase(idx.begin() + static_cast<long>(bestAt));
+    }
+    // Whatever is left: three points, or a remainder no ear could be found
+    // in. A fan over the remainder is the best available answer.
+    for (size_t i = 1; i + 1 < idx.size(); ++i) emit(loop[idx[0]], loop[idx[i]], loop[idx[i + 1]]);
+}
+
+} // namespace
+
 CSGParams resolvePolyhedron(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     Value pointsArg = getArg(args, 0, "points", Value{});
@@ -292,14 +450,7 @@ CSGParams resolvePolyhedron(Evaluator& ev, const oscad::ModularCall& node, EvalC
             const size_t idx = static_cast<size_t>(toDoubleLenient(idxVal));
             remapped.push_back(idx < remap.size() ? remap[idx] : 0);
         }
-        for (size_t i = 1; i + 1 < remapped.size(); ++i) {
-            const size_t a = remapped[0], b = remapped[i + 1], c = remapped[i];
-            if (a != b && b != c && a != c) {
-                tris.push_back(static_cast<uint32_t>(a));
-                tris.push_back(static_cast<uint32_t>(b));
-                tris.push_back(static_cast<uint32_t>(c));
-            }
-        }
+        triangulateFace(uniqueVerts, remapped, tris);
     }
 
     std::vector<Value> vertsValues;

openscad_cpp_evaluator-0.29.1/src/builtins/topology.cpp

@@ -0,0 +1,246 @@
+#include "builtins.hpp"
+
+#include "openscad_cpp_evaluator/call_args.hpp"
+#include "openscad_cpp_evaluator/evaluator.hpp"
+
+#include <manifold/polygon.h>
+
+namespace oscadeval {
+
+// hull()/minkowski() -- like union/difference/intersection, these splice
+// their children transparently in the CSG tree (resolve just evaluates
+// them for the side effect); the actual hull/minkowski-sum only happens
+// once every child's real geometry exists, in generate. Mirrors
+// _resolve_hull/_resolve_minkowski (both bodies of the same one-line
+// "evaluate children, return {}" shape as _resolve_transform).
+
+CSGParams resolveHull(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    (void)args;
+    ev.evalChildren(node.children, effCtx);
+    return CSGParams{};
+}
+
+// hull() of the foreground children: an all-3D hull if any child has a
+// body, else an all-2D hull over sections -- mirrors _generate_hull exactly
+// (a 2D/3D mix only ever hulls the 3D bodies, dropping any 2D sibling,
+// 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.
+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);
+
+    std::optional<ColoredBody> hullResult;
+    if (!split.foreground.empty()) {
+        std::vector<manifold::Manifold> bodies3d;
+        for (const ColoredBody& c : split.foreground) {
+            if (c.body) bodies3d.push_back(*c.body);
+        }
+        if (!bodies3d.empty()) {
+            ColoredBody cb;
+            cb.body = manifold::Manifold::Hull(bodies3d);
+            cb.color = split.foreground.front().color;
+            hullResult = std::move(cb);
+        } else {
+            std::vector<manifold::CrossSection> sections;
+            for (const ColoredBody& c : split.foreground) {
+                if (c.section) sections.push_back(*c.section);
+            }
+            if (!sections.empty()) {
+                ColoredBody cb;
+                cb.section = manifold::CrossSection::Hull(sections);
+                cb.color = split.foreground.front().color;
+                hullResult = std::move(cb);
+            }
+        }
+    }
+
+    std::vector<ColoredBody> result;
+    if (hullResult) result.push_back(std::move(*hullResult));
+    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());
+    return result;
+}
+
+CSGParams resolveMinkowski(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    (void)args;
+    ev.evalChildren(node.children, effCtx);
+    return CSGParams{};
+}
+
+
+namespace {
+
+// The convex pieces of a 2D shape, as point lists.
+//
+// A Minkowski sum only has a closed form for convex operands -- there it
+// is the convex hull of every pairwise sum -- so a shape that is not
+// convex has to be cut into pieces that are. A convex outline with no
+// holes is already one piece, which is the common case (a circle being
+// swept over something) and much cheaper than triangulating it.
+std::vector<manifold::SimplePolygon> convexPieces(const manifold::CrossSection& section) {
+    const manifold::Polygons polys = section.ToPolygons();
+    std::vector<manifold::SimplePolygon> out;
+
+    if (polys.size() == 1) {
+        const manifold::SimplePolygon& ring = polys[0];
+        bool convex = ring.size() >= 3;
+        int sign = 0;
+        for (size_t i = 0; convex && i < ring.size(); ++i) {
+            const manifold::vec2& a = ring[i];
+            const manifold::vec2& b = ring[(i + 1) % ring.size()];
+            const manifold::vec2& c = ring[(i + 2) % ring.size()];
+            const double cross = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+            if (std::abs(cross) < 1e-12) continue;      // collinear, no turn
+            const int s = cross > 0 ? 1 : -1;
+            if (sign == 0) sign = s;
+            else if (s != sign) convex = false;
+        }
+        if (convex) {
+            out.push_back(ring);
+            return out;
+        }
+    }
+
+    for (const manifold::ivec3& tri : manifold::Triangulate(polys)) {
+        // Triangulate indexes the contours end to end.
+        std::vector<manifold::vec2> flat;
+        for (const manifold::SimplePolygon& ring : polys)
+            flat.insert(flat.end(), ring.begin(), ring.end());
+        if (static_cast<size_t>(tri.x) >= flat.size() || static_cast<size_t>(tri.y) >= flat.size() ||
+            static_cast<size_t>(tri.z) >= flat.size()) {
+            continue;
+        }
+        out.push_back({flat[tri.x], flat[tri.y], flat[tri.z]});
+    }
+    return out;
+}
+
+// The 2D Minkowski sum of two shapes.
+//
+// Manifold has no 2D Minkowski, so this is the boundary-sweep identity:
+// for B convex and containing the origin,
+//
+//     A (+) B  =  A  union  (boundary of A (+) B)
+//
+// and the boundary is a chain of segments, each of which sums with a
+// convex B to the hull of B at its two ends. So sweeping B along every
+// edge of A and unioning A itself is the whole answer -- A is never cut
+// up, however concave it is or however many holes it has. Only B is,
+// and only because the per-segment hull needs it convex.
+//
+// The two conditions on B are met rather than assumed: it is decomposed
+// into convex pieces (Minkowski distributes over union, so the pieces'
+// sums are unioned), and each piece is shifted onto the origin with the
+// shift undone afterwards, since A (+) B = ((A (+) (B - c)) + c).
+//
+// ponytail: one hull per edge of A per convex piece of B. A piece count
+// of one is the case that turns up -- a circle swept over something --
+// and then it is simply one hull per edge.
+manifold::CrossSection minkowski2d(const manifold::CrossSection& a, const manifold::CrossSection& b) {
+    const manifold::Polygons outline = a.ToPolygons();
+    std::vector<manifold::CrossSection> parts;
+
+    for (const manifold::SimplePolygon& piece : convexPieces(b)) {
+        if (piece.size() < 3) continue;
+        // Bring the piece onto the origin; the sum is shifted back after.
+        manifold::vec2 shift = piece[0];
+        manifold::SimplePolygon centred;
+        centred.reserve(piece.size());
+        for (const manifold::vec2& q : piece) centred.push_back({q.x - shift.x, q.y - shift.y});
+
+        std::vector<manifold::CrossSection> swept;
+        // A itself: only sound because `centred` contains the origin.
+        swept.push_back(a);
+        for (const manifold::SimplePolygon& ring : outline) {
+            for (size_t i = 0; i < ring.size(); ++i) {
+                const manifold::vec2& v0 = ring[i];
+                const manifold::vec2& v1 = ring[(i + 1) % ring.size()];
+                manifold::SimplePolygon ends;
+                ends.reserve(centred.size() * 2);
+                for (const manifold::vec2& q : centred) {
+                    ends.push_back({v0.x + q.x, v0.y + q.y});
+                    ends.push_back({v1.x + q.x, v1.y + q.y});
+                }
+                swept.push_back(manifold::CrossSection::Hull(ends));
+            }
+        }
+        manifold::CrossSection sum =
+            manifold::CrossSection::BatchBoolean(swept, manifold::OpType::Add);
+        parts.push_back(sum.Translate(shift));
+    }
+
+    if (parts.empty()) return manifold::CrossSection();
+    return manifold::CrossSection::BatchBoolean(parts, manifold::OpType::Add);
+}
+
+} // namespace
+
+// minkowski() over 3D bodies, or over 2D sections when that is what it
+// was given. 2D used to be dropped on the floor -- silently, so
+// `linear_extrude() minkowski() { square(); circle(); }` produced nothing
+// at all where the reference produces the rounded square you asked for.
+std::vector<ColoredBody> generateMinkowski(Evaluator& ev, const CSGParams&, const std::vector<std::unique_ptr<CSGNode>>& children,
+                                            const oscad::ASTNode& node) {
+    const std::vector<ColoredBody> bodies = flattenCsgTree(children);
+    const RoleSplit split = splitByRole(bodies);
+
+    std::vector<const ColoredBody*> bodies3d;
+    std::vector<const ColoredBody*> sections2d;
+    for (const ColoredBody& c : split.foreground) {
+        if (c.body) bodies3d.push_back(&c);
+        else if (c.section) sections2d.push_back(&c);
+    }
+
+    std::vector<ColoredBody> passthrough;
+    passthrough.insert(passthrough.end(), split.background.begin(), split.background.end());
+    passthrough.insert(passthrough.end(), split.highlight.begin(), split.highlight.end());
+    passthrough.insert(passthrough.end(), split.showOnly.begin(), split.showOnly.end());
+    passthrough.insert(passthrough.end(), split.displayOnly.begin(), split.displayOnly.end());
+
+    // 2D only: sum the sections instead. A mix of 2D and 3D is the
+    // reference's error case, and the 3D bodies win here as they do there.
+    if (bodies3d.empty() && sections2d.size() >= 2) {
+        manifold::CrossSection acc = *sections2d.front()->section;
+        for (size_t i = 1; i < sections2d.size(); ++i)
+            acc = minkowski2d(acc, *sections2d[i]->section);
+        ColoredBody cb;
+        cb.section = std::move(acc);
+        cb.color = sections2d.front()->color;
+        std::vector<ColoredBody> out = {std::move(cb)};
+        out.insert(out.end(), passthrough.begin(), passthrough.end());
+        return out;
+    }
+    if (bodies3d.empty() && sections2d.size() == 1) {
+        std::vector<ColoredBody> out = {*sections2d.front()};
+        out.insert(out.end(), passthrough.begin(), passthrough.end());
+        return out;
+    }
+    if (bodies3d.empty()) return passthrough;
+    if (bodies3d.size() == 1) {
+        std::vector<ColoredBody> result = {*bodies3d.front()};
+        result.insert(result.end(), passthrough.begin(), passthrough.end());
+        return result;
+    }
+
+    manifold::Manifold result = *bodies3d.front()->body;
+    for (size_t i = 1; i < bodies3d.size(); ++i) result = result.MinkowskiSum(*bodies3d[i]->body);
+    if (result.Status() != manifold::Manifold::Error::NoError) {
+        ev.warn("minkowski: result is not manifold", &node.position());
+    }
+
+    ColoredBody cb;
+    cb.body = std::move(result);
+    cb.color = bodies3d.front()->color;
+    std::vector<ColoredBody> out = {std::move(cb)};
+    out.insert(out.end(), passthrough.begin(), passthrough.end());
+    return out;
+}
+
+} // namespace oscadeval

{openscad_cpp_evaluator-0.28.2 → openscad_cpp_evaluator-0.29.1}/tests/test_booleans.cpp

@@ -227,3 +227,216 @@ TEST(Modifiers, NoShowOnlyMeansAllRolesPassThrough) {
     Evaluated e = evaluateSrc("%cube(1); cube(2);");
     EXPECT_EQ(e.bodies.size(), 2u);
 }
+
+// -- polyhedron face triangulation ---------------------------------------
+
+// An L-shaped prism: its top and bottom are 6-gons with one reflex corner.
+// Fan-triangulating a concave face lays triangles outside the polygon and
+// winds some of them inside out, so the solid comes out the wrong size --
+// which is how BOSL2's nurbs_sheet() end caps ended up covering 281% of
+// their own area with 15 of 32 triangles reversed.
+// A U: vertex 0 cannot see the far arm, so a fan anchored there lays
+// triangles across the notch, outside the solid. (An L is not enough on
+// its own -- it happens to be star-shaped from its first vertex, so even
+// a fan triangulates it correctly, which is why the volume check below
+// needs this shape too.)
+static const char* kUPrism = R"(
+pts = [[0,0],[3,0],[3,3],[2,3],[2,1],[1,1],[1,3],[0,3]];
+polyhedron(
+  points = concat([for (p=pts) [p[0],p[1],0]], [for (p=pts) [p[0],p[1],1]]),
+  faces = concat(
+    [[for (i=[0:len(pts)-1]) i]],
+    [[for (i=[len(pts)-1:-1:0]) i+len(pts)]],
+    [for (i=[0:len(pts)-1]) [i, i+len(pts), (i+1)%len(pts)+len(pts), (i+1)%len(pts)]]
+  )
+);
+)";
+
+static const char* kLPrism = R"(
+polyhedron(
+    points = [
+        [0,0,0], [2,0,0], [2,1,0], [1,1,0], [1,2,0], [0,2,0],
+        [0,0,1], [2,0,1], [2,1,1], [1,1,1], [1,2,1], [0,2,1]
+    ],
+    faces = [
+        [0,1,2,3,4,5],
+        [11,10,9,8,7,6],
+        [0,6,7,1], [1,7,8,2], [2,8,9,3],
+        [3,9,10,4], [4,10,11,5], [5,11,6,0]
+    ]
+);
+)";
+
+TEST(PolyhedronFaces, AConcaveFaceGivesTheRightVolume) {
+    Evaluated e = evaluateSrc(kLPrism);
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    // The L is 3 square units, extruded 1 high.
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 3.0, 1e-9);
+}
+
+TEST(PolyhedronFaces, AConcaveFaceGivesTheRightSurfaceArea) {
+    Evaluated e = evaluateSrc(kLPrism);
+    ASSERT_EQ(e.bodies.size(), 1u);
+    // 2 x 3 for the ends, plus a perimeter of 8 x height 1.
+    EXPECT_NEAR(e.bodies[0].body->SurfaceArea(), 14.0, 1e-9);
+}
+
+TEST(PolyhedronFaces, EachFaceBecomesExactlyNMinusTwoTriangles) {
+    Evaluated e = evaluateSrc(kLPrism);
+    ASSERT_EQ(e.bodies.size(), 1u);
+    // Two 6-gons (4 each) and six quads (2 each).
+    const manifold::MeshGL mesh = e.bodies[0].body->GetMeshGL();
+    EXPECT_EQ(mesh.triVerts.size() / 3, 4u + 4u + 6u * 2u);
+}
+
+// A convex face has to keep working, and a triangle must not be disturbed.
+TEST(PolyhedronFaces, AFaceWithAnUnseeableCornerGivesTheRightVolume) {
+    Evaluated e = evaluateSrc(kUPrism);
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    // 3x3 less the 1x2 notch, one unit high.
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 7.0, 1e-9);
+    // Two ends of 7, plus a 16-long perimeter one unit high.
+    EXPECT_NEAR(e.bodies[0].body->SurfaceArea(), 30.0, 1e-9);
+}
+
+TEST(PolyhedronFaces, AConvexFaceIsUnchanged) {
+    Evaluated e = evaluateSrc("cube(2);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 8.0, 1e-9);
+    EXPECT_NEAR(e.bodies[0].body->SurfaceArea(), 24.0, 1e-9);
+}
+
+TEST(PolyhedronFaces, ADegenerateFaceDoesNotThrowOrHang) {
+    // All points collinear: no plane to project onto. It must fall through
+    // rather than spin in the ear-clipping loop.
+    Evaluated e = evaluateSrc(R"(
+        polyhedron(points=[[0,0,0],[1,0,0],[2,0,0],[0,0,1]],
+                   faces=[[0,1,2],[0,2,3],[0,3,1],[1,3,2]]);
+    )");
+    EXPECT_EQ(e.bodies.size(), 1u);
+}
+
+// -- 2D minkowski ---------------------------------------------------------
+
+// minkowski() used to drop 2D sections on the floor, silently: this
+// produced no geometry at all where the reference produces the rounded
+// square asked for. Manifold has no 2D Minkowski, so it is built from
+// convex pieces and hulls -- see minkowski2d().
+TEST(Minkowski2D, RoundsAConvexOutline) {
+    Evaluated e = evaluateSrc(
+        "linear_extrude(6) minkowski() { square([30,20], center=true); circle(4, $fn=24); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    // A 30x20 rectangle grown by 4: the rectangle, four 4-wide sides, and
+    // the corners adding up to one circle. Times 6 high.
+    const double expected = (30.0 * 20.0 + 2 * 4 * (30 + 20) + M_PI * 16.0) * 6.0;
+    EXPECT_NEAR(e.bodies[0].body->Volume(), expected, expected * 0.01);
+    const manifold::Box box = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(box.max.x - box.min.x, 38.0, 0.01);
+    EXPECT_NEAR(box.max.y - box.min.y, 28.0, 0.01);
+}
+
+// The case a hull cannot fake: a concave outline has to stay concave.
+TEST(Minkowski2D, KeepsAConcaveOutlineConcave) {
+    Evaluated e = evaluateSrc(R"(
+        linear_extrude(4) minkowski() {
+            polygon([[0,0],[40,0],[40,25],[22,25],[22,12],[0,12]]);
+            circle(3, $fn=16);
+        }
+    )");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const manifold::Box box = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(box.max.x - box.min.x, 46.0, 0.2);
+    EXPECT_NEAR(box.max.y - box.min.y, 31.0, 0.2);
+    // The notch has to still be a notch. A volume bound is too blunt to
+    // say so -- hulling the pieces rather than unioning them lands within
+    // 1% of the right answer here -- so probe the hole itself: the L is
+    // missing the region x 0..22, y 12..25, and rounding by 3 does not
+    // reach anywhere near the middle of it.
+    // The probe has to sit inside what a hull WOULD cover and outside the
+    // real shape, or it proves nothing: the hull runs from (0,12) to
+    // (22,25), and the rounded L stops at y=15 for any x below 22.
+    const manifold::Manifold probe =
+        manifold::Manifold::Cube({1.0, 1.0, 8.0}).Translate({17.0, 17.0, -2.0});
+    EXPECT_TRUE((*e.bodies[0].body ^ probe).IsEmpty()) << "the notch was filled in";
+    // ...while somewhere solid is genuinely solid.
+    const manifold::Manifold inside =
+        manifold::Manifold::Cube({2.0, 2.0, 8.0}).Translate({30.0, 5.0, -2.0});
+    EXPECT_FALSE((*e.bodies[0].body ^ inside).IsEmpty());
+}
+
+TEST(Minkowski2D, OneSectionIsHandedBackUnchanged) {
+    Evaluated e = evaluateSrc("linear_extrude(3) minkowski() { square([10,10]); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 300.0, 1e-6);
+}
+
+TEST(Minkowski2D, ThreeDStillWorksAndStillWins) {
+    Evaluated a = evaluateSrc("minkowski() { cube([30,20,6], center=true); sphere(3, $fn=12); }");
+    ASSERT_EQ(a.bodies.size(), 1u);
+    EXPECT_GT(a.bodies[0].body->Volume(), 30.0 * 20.0 * 6.0);
+}
+
+// The edge sweep is only valid when the shape being swept is convex and
+// contains the origin, and when a third operand is folded rather than
+// unioned in. Each of these fails, by a measurable amount, if the
+// corresponding step is skipped -- so each is here on its own.
+
+TEST(Minkowski2D, SweepsAConcaveSweeperByItsConvexPieces) {
+    // Hulling the sweeper instead of decomposing it computes A (+) hull(B)
+    // and comes out at 5092 against the reference's 4992.
+    Evaluated e = evaluateSrc(R"(
+        linear_extrude(4) minkowski() {
+            polygon([[0,0],[40,0],[40,25],[22,25],[22,12],[0,12]]);
+            polygon([[0,0],[8,0],[8,8],[5,8],[5,3],[0,3]]);
+        }
+    )");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 4992.0, 5.0);
+}
+
+TEST(Minkowski2D, ASweeperAwayFromTheOriginStillLandsInTheRightPlace) {
+    // The identity unions A itself, which only holds when the sweeper
+    // contains the origin. Without shifting it there and back, the result
+    // keeps an untranslated copy of A and starts at x=0 instead of x=16.
+    Evaluated e = evaluateSrc(R"(
+        linear_extrude(4) minkowski() {
+            polygon([[0,0],[40,0],[40,25],[22,25],[22,12],[0,12]]);
+            translate([20,0]) circle(4, $fn=24);
+        }
+    )");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const manifold::Box box = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(box.min.x, 16.0, 0.2);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 5120.47, 5.0);
+}
+
+TEST(Minkowski2D, ThreeOperandsAreSummedInTurnNotUnioned) {
+    // A (+) B (+) C, not A (+) (B union C) -- which would give 3711.
+    Evaluated e = evaluateSrc(
+        "linear_extrude(4) minkowski() { square([30,20], center=true);"
+        " circle(3, $fn=16); square([6,2], center=true); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 4670.21, 5.0);
+    const manifold::Box box = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(box.max.x - box.min.x, 42.0, 0.2);
+}
+
+TEST(Minkowski2D, AShapeWithAHoleHasBothItsContoursSwept) {
+    // Only the boundary of the shape being swept along is walked, so a
+    // hole is not a special case -- it is another contour.
+    Evaluated e = evaluateSrc(R"(
+        linear_extrude(3) minkowski() {
+            difference() { square([40,30], center=true); circle(8, $fn=24); }
+            circle(2, $fn=16);
+        }
+    )");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 4141.98, 5.0);
+    // The hole shrinks by the sweep rather than filling in.
+    const manifold::Manifold probe =
+        manifold::Manifold::Cube({1.0, 1.0, 6.0}).Translate({-0.5, -0.5, -1.0});
+    EXPECT_TRUE((*e.bodies[0].body ^ probe).IsEmpty()) << "the hole was filled in";
+}