openscad-cpp-evaluator 0.35.0__tar.gz → 0.36.0__tar.gz

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.36.0}/CLAUDE.md

@@ -561,6 +561,29 @@ grep for `ponytail:`.
   color instead of preserving each part's own, matching real OpenSCAD's actual behavior once fixed
   (cross-checked triangle-color-count-and-values against the Python reference directly, not just
   “does it run”).
+- `src/builtins/primitives_3d.cpp` — `sphere(style=)` is a BelfrySCAD extension naming the
+  tessellation, using BOSL2's five `spheroid()` style names and constructions: `"orig"` (the default,
+  and what OpenSCAD's own sphere() builds — rings offset half a step from the poles, no pole vertex),
+  `"aligned"` (a vertex at each pole, so an `$fn` divisible by 4 also lands vertices exactly on ±X
+  and ±Y), `"stagger"` (aligned with alternate rings rotated half a face), `"octa"` and `"icosa"`.
+  Only `"orig"` renders the same in real OpenSCAD.
+
+  `"octa"` is `Manifold::Sphere`, which already *is* a subdivided octahedron (`Shape::Octahedron`
+  then `Subdivide`). Same 146/288 topology as BOSL2's at `$fn=24`, ~0.05% apart in volume because
+  Manifold distributes the subdivision differently. `"icosa"` samples each icosahedral face against
+  its own corners rather than rotating copies of one sampled face the way BOSL2 does — the sampling
+  is affine in those corners, so it is the same points with far less machinery — and welds the
+  shared edges itself so the mesh reaches Manifold already manifold.
+
+  **BOSL2's VNF winding is the opposite of Manifold's**, so `buildAligned` emits every triangle with
+  its last two indices swapped. Without it the solid is inside-out, which `Manifold::Volume()`
+  reports as a NEGATIVE volume — and which comparing `|volume|` (as an STL-based check naturally
+  does) hides completely. Two of the tests assert a positive volume specifically to catch this.
+
+  Note when checking any of this against BOSL2: **BOSL2 shadows `sphere()`** with its own module, so
+  a file that includes BOSL2 to "compare against the reference" is comparing BOSL2 with itself. Call
+  `spheroid()` from a BOSL2-including file and `sphere()` from one without.
+
 - `src/builtins/dxf_dim.cpp` — `dxf_dim()`/`dxf_cross()`, which read a measurement out of a DXF file
   rather than out of the model. Ported from the reference's `io/dxfdim.cc` plus the DIMENSION/LINE
   half of `io/DxfData.cc`: `dxf_dim()` returns the first matching DIMENSION's value by its type

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.36.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.36.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.36.0}/src/builtins/primitives_3d.cpp

@@ -5,10 +5,12 @@
 #include "openscad_cpp_evaluator/segments.hpp"
 
 #include <algorithm>
+#include <array>
 #include <cmath>
 #include <cstdint>
 #include <map>
 #include <numbers>
+#include <set>
 
 namespace oscadeval {
 
@@ -100,22 +102,48 @@ std::vector<ColoredBody> generateCube(Evaluator& ev, const CSGParams& params, co
 // _resolve_sphere/_generate_sphere exactly, including the "stacks =
 // max(2, ceil(n/2))" ring count and the fan-cap winding.
 
-CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
-    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
-    Value dArg = getArg(args, std::nullopt, "d", Value{});
-    double r;
-    if (!isUndef(dArg)) {
-        r = toDoubleLenient(dArg) / 2.0;
-    } else {
-        Value rArg = getArg(args, 0, "r", Value{});
-        r = isUndef(rArg) ? 1.0 : toDoubleLenient(rArg);
-    }
+// sphere(r|d, style) -- `style` is a BelfrySCAD extension naming the
+// tessellation, with the same five names and the same constructions as
+// BOSL2's spheroid():
+//
+//   "orig"    stacked rings offset half a step from the poles, no pole
+//             vertex. What OpenSCAD's own sphere() builds, hence the name,
+//             and still the default here.
+//   "aligned" a vertex at each pole and rings on the latitudes between, so
+//             an $fn divisible by 4 puts vertices exactly on +-X and +-Y.
+//   "stagger" "aligned" with alternate rings rotated half a face, giving
+//             triangles that alternate direction rather than stacking.
+//   "octa"    a subdivided octahedron projected onto the sphere.
+//   "icosa"   a subdivided icosahedron projected onto the sphere -- the most
+//             uniform of the five.
+//
+// Only "orig" matches real OpenSCAD; the rest are additions, so a script
+// using them will not render the same shape elsewhere.
 
-    const int n = fnSegmentsFromCtx(effCtx, r); // longitude segments
-    const int stacks = std::max(2, static_cast<int>(std::ceil(n / 2.0)));
-    const double step = std::numbers::pi / stacks;
+namespace {
 
-    std::vector<double> verts; // flat x,y,z,...
+// BOSL2's spherical_to_xyz(r, theta, phi): theta around Z from +X, phi down
+// from +Z.
+std::array<double, 3> sphericalToXyz(double r, double thetaDeg, double phiDeg) {
+    const double th = thetaDeg * std::numbers::pi / 180.0;
+    const double ph = phiDeg * std::numbers::pi / 180.0;
+    return {r * std::sin(ph) * std::cos(th), r * std::sin(ph) * std::sin(th), r * std::cos(ph)};
+}
+
+struct SphereMesh {
+    std::vector<double> verts;   // flat x,y,z
+    std::vector<int> tris;
+};
+
+void pushVert(SphereMesh& m, const std::array<double, 3>& p) {
+    m.verts.insert(m.verts.end(), {p[0], p[1], p[2]});
+}
+
+// "orig": rings at (i+0.5) steps, no pole vertices, capped by a fan at each
+// end. Unchanged from the original implementation.
+SphereMesh buildOrig(double r, int n, int stacks) {
+    SphereMesh m;
+    const double step = std::numbers::pi / stacks;
     std::vector<std::vector<int>> rings(static_cast<size_t>(stacks));
     for (int s = 0; s < stacks; ++s) {
         const double lat = -std::numbers::pi / 2.0 + (s + 0.5) * step;
@@ -123,44 +151,214 @@ CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalConte
         const double z = r * std::sin(lat);
         for (int seg = 0; seg < n; ++seg) {
             const double angle = 2.0 * std::numbers::pi * seg / n;
-            rings[static_cast<size_t>(s)].push_back(static_cast<int>(verts.size() / 3));
-            verts.push_back(ringR * std::cos(angle));
-            verts.push_back(ringR * std::sin(angle));
-            verts.push_back(z);
+            rings[static_cast<size_t>(s)].push_back(static_cast<int>(m.verts.size() / 3));
+            pushVert(m, {ringR * std::cos(angle), ringR * std::sin(angle), z});
         }
     }
-
-    std::vector<int> tris;
     const auto& bot = rings.front();
-    for (int i = 1; i < n - 1; ++i) {
-        tris.insert(tris.end(), {bot[0], bot[static_cast<size_t>(i) + 1], bot[static_cast<size_t>(i)]});
-    }
+    for (int i = 1; i < n - 1; ++i) m.tris.insert(m.tris.end(), {bot[0], bot[size_t(i) + 1], bot[size_t(i)]});
     for (int s = 0; s < stacks - 1; ++s) {
-        const auto& lo = rings[static_cast<size_t>(s)];
-        const auto& hi = rings[static_cast<size_t>(s) + 1];
+        const auto& lo = rings[size_t(s)];
+        const auto& hi = rings[size_t(s) + 1];
         for (int seg = 0; seg < n; ++seg) {
-            const int a = lo[static_cast<size_t>(seg)], b = lo[static_cast<size_t>((seg + 1) % n)];
-            const int c = hi[static_cast<size_t>(seg)], d = hi[static_cast<size_t>((seg + 1) % n)];
-            tris.insert(tris.end(), {a, b, d});
-            tris.insert(tris.end(), {a, d, c});
+            const int a = lo[size_t(seg)], b = lo[size_t((seg + 1) % n)];
+            const int c = hi[size_t(seg)], d = hi[size_t((seg + 1) % n)];
+            m.tris.insert(m.tris.end(), {a, b, d});
+            m.tris.insert(m.tris.end(), {a, d, c});
         }
     }
     const auto& top = rings.back();
-    for (int i = 1; i < n - 1; ++i) {
-        tris.insert(tris.end(), {top[0], top[static_cast<size_t>(i)], top[static_cast<size_t>(i) + 1]});
+    for (int i = 1; i < n - 1; ++i) m.tris.insert(m.tris.end(), {top[0], top[size_t(i)], top[size_t(i) + 1]});
+    return m;
+}
+
+// "aligned"/"stagger": pole, vsides-1 rings, pole. Vertex order and face
+// indices follow BOSL2's spheroid() exactly so the two agree triangle for
+// triangle, not merely in shape.
+SphereMesh buildAligned(double r, int hsides, int vsides, bool stagger) {
+    SphereMesh m;
+    pushVert(m, sphericalToXyz(r, 0, 0));                      // north pole, index 0
+    for (int i = 1; i <= vsides - 1; ++i) {
+        const double phi = i * 180.0 / vsides;
+        for (int j = 0; j < hsides; ++j) {
+            const double theta = (j + ((stagger && i % 2 != 0) ? 0.5 : 0.0)) * 360.0 / hsides;
+            pushVert(m, sphericalToXyz(r, theta, phi));
+        }
+    }
+    pushVert(m, sphericalToXyz(r, 0, 180));                    // south pole, last index
+    const int lv = static_cast<int>(m.verts.size() / 3);
+
+    // BOSL2's VNF winding is the opposite of what Manifold wants, so every
+    // triangle below is emitted with its last two indices swapped. Without
+    // that the solid comes out inside-out -- and invisibly so if you only
+    // ever check |volume|, which is how this first went unnoticed.
+    const auto tri = [&m](int a, int b, int c) { m.tris.insert(m.tris.end(), {a, c, b}); };
+
+    for (int i = 0; i < hsides; ++i) {
+        const int b2 = lv - 2 - hsides;
+        tri(i + 1, 0, ((i + 1) % hsides) + 1);
+        tri(lv - 1, b2 + i + 1, b2 + ((i + 1) % hsides) + 1);
     }
+    for (int i = 0; i <= vsides - 3; ++i) {
+        const int base = 1 + hsides * i;
+        for (int j = 0; j < hsides; ++j) {
+            if (stagger && i % 2 != 0) {
+                tri(base + j, base + hsides + j % hsides, base + hsides + (j + hsides - 1) % hsides);
+                tri(base + j, base + (j + 1) % hsides, base + hsides + j);
+            } else {
+                tri(base + j, base + (j + 1) % hsides, base + hsides + (j + 1) % hsides);
+                tri(base + j, base + hsides + (j + 1) % hsides, base + hsides + j);
+            }
+        }
+    }
+    return m;
+}
 
-    std::vector<Value> vertsValues;
-    vertsValues.reserve(verts.size());
-    for (double v : verts) vertsValues.push_back(Value{v});
-    std::vector<Value> trisValues;
-    trisValues.reserve(tris.size());
-    for (int t : tris) trisValues.push_back(Value{static_cast<double>(t)});
+// "icosa": subdivide every icosahedral face into a triangular grid and push
+// each sample out to the sphere. BOSL2 subsamples one face and rotates
+// copies onto the rest; sampling each face against its own corners is the
+// same points (the sampling is affine in those corners) with far less
+// machinery. Coincident vertices along shared edges are welded here rather
+// than left for Manifold, so the mesh arrives already manifold.
+SphereMesh buildIcosa(double r, int hsides) {
+    const double phi = (1.0 + std::sqrt(5.0)) / 2.0;
+    std::vector<std::array<double, 3>> ico;
+    for (int i : {-1, 1}) {
+        for (int j : {-1, 1}) {
+            ico.push_back({0.0, double(i), double(j) * phi});
+            ico.push_back({double(i), double(j) * phi, 0.0});
+            ico.push_back({double(j) * phi, 0.0, double(i)});
+        }
+    }
+    // Hull faces by brute force: a triple is a face when every other vertex
+    // lies on one side of its plane. 12 vertices, so 220 triples.
+    std::vector<std::array<int, 3>> faces;
+    const int nv = static_cast<int>(ico.size());
+    for (int a = 0; a < nv; ++a)
+        for (int b = a + 1; b < nv; ++b)
+            for (int c = b + 1; c < nv; ++c) {
+                const std::array<double, 3> u{ico[b][0] - ico[a][0], ico[b][1] - ico[a][1], ico[b][2] - ico[a][2]};
+                const std::array<double, 3> v{ico[c][0] - ico[a][0], ico[c][1] - ico[a][1], ico[c][2] - ico[a][2]};
+                const std::array<double, 3> nrm{u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2],
+                                                 u[0] * v[1] - u[1] * v[0]};
+                int pos = 0, neg = 0;
+                for (int k = 0; k < nv; ++k) {
+                    if (k == a || k == b || k == c) continue;
+                    const double d = nrm[0] * (ico[k][0] - ico[a][0]) + nrm[1] * (ico[k][1] - ico[a][1]) +
+                                     nrm[2] * (ico[k][2] - ico[a][2]);
+                    if (d > 1e-9) ++pos;
+                    if (d < -1e-9) ++neg;
+                }
+                if (pos && neg) continue;
+                // Orient outward: the normal must point away from the centre.
+                if (neg == 0) faces.push_back({a, c, b});
+                else faces.push_back({a, b, c});
+            }
+
+    const int steps = std::max(1, static_cast<int>(std::lround(std::max(5, hsides) / 5.0)));
+    const int N = steps - 1;   // BOSL2's N; the grid has N+2 rows
+
+    SphereMesh m;
+    std::map<std::array<long long, 3>, int> weld;
+    const auto add = [&](const std::array<double, 3>& p) {
+        const double len = std::sqrt(p[0] * p[0] + p[1] * p[1] + p[2] * p[2]);
+        const std::array<double, 3> u{r * p[0] / len, r * p[1] / len, r * p[2] / len};
+        const std::array<long long, 3> key{std::llround(u[0] * 1e9), std::llround(u[1] * 1e9),
+                                            std::llround(u[2] * 1e9)};
+        auto it = weld.find(key);
+        if (it != weld.end()) return it->second;
+        const int idx = static_cast<int>(m.verts.size() / 3);
+        pushVert(m, u);
+        weld.emplace(key, idx);
+        return idx;
+    };
+
+    for (const std::array<int, 3>& f : faces) {
+        const std::array<double, 3>& p0 = ico[f[0]];
+        const std::array<double, 3>& p1 = ico[f[1]];
+        const std::array<double, 3>& p2 = ico[f[2]];
+        // Row i has N+2-i samples, mirroring _subsample_triangle.
+        std::vector<std::vector<int>> grid;
+        for (int i = 0; i <= N + 1; ++i) {
+            std::vector<int> row;
+            for (int j = 0; j <= N + 1 - i; ++j) {
+                const double a = double(i) / (N + 1), b = double(j) / (N + 1);
+                row.push_back(add({p0[0] + (p1[0] - p0[0]) * a + (p2[0] - p0[0]) * b,
+                                    p0[1] + (p1[1] - p0[1]) * a + (p2[1] - p0[1]) * b,
+                                    p0[2] + (p1[2] - p0[2]) * a + (p2[2] - p0[2]) * b}));
+            }
+            grid.push_back(std::move(row));
+        }
+        for (int i = 0; i <= N; ++i) {
+            for (int j = 0; j <= N - i; ++j) {
+                m.tris.insert(m.tris.end(), {grid[i][j], grid[i + 1][j], grid[i][j + 1]});
+                if (j < N - i) {
+                    m.tris.insert(m.tris.end(), {grid[i + 1][j], grid[i + 1][j + 1], grid[i][j + 1]});
+                }
+            }
+        }
+    }
+    return m;
+}
+
+} // namespace
+
+CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    Value dArg = getArg(args, std::nullopt, "d", Value{});
+    double r;
+    if (!isUndef(dArg)) {
+        r = toDoubleLenient(dArg) / 2.0;
+    } else {
+        Value rArg = getArg(args, 0, "r", Value{});
+        r = isUndef(rArg) ? 1.0 : toDoubleLenient(rArg);
+    }
+
+    const Value styleArg = getArg(args, std::nullopt, "style", Value{});
+    std::string style = "orig";
+    if (const std::string* sv = std::get_if<std::string>(&styleArg)) {
+        static const std::set<std::string> known{"orig", "aligned", "stagger", "octa", "icosa"};
+        if (known.count(*sv)) {
+            style = *sv;
+        } else {
+            ev.warn("sphere: unknown style \"" + *sv + "\"; expected one of orig, aligned, stagger, octa, icosa",
+                    &node.position());
+        }
+    } else if (!isUndef(styleArg)) {
+        ev.warn("sphere: style must be a string", &node.position());
+    }
+
+    const int hsides = fnSegmentsFromCtx(effCtx, r);
+    const int vsides = std::max(2, static_cast<int>(std::ceil(hsides / 2.0)));
 
     CSGParams params;
+    params["style"] = Value{style};
+    params["r"] = Value{r};
+    params["segs"] = Value{static_cast<double>(hsides)};
+    params["color"] = colorToValue(effCtx.color);
+
+    if (style == "octa") {
+        // Manifold::Sphere IS a subdivided octahedron (Shape::Octahedron,
+        // then Subdivide), so this needs no mesh of our own -- generate
+        // calls it directly.
+        params["verts"] = Value{std::make_shared<const ValueList>(ValueList{})};
+        params["tris"] = Value{std::make_shared<const ValueList>(ValueList{})};
+        return params;
+    }
+
+    const SphereMesh m = style == "aligned"   ? buildAligned(r, hsides, vsides, false)
+                         : style == "stagger" ? buildAligned(r, hsides, vsides, true)
+                         : style == "icosa"   ? buildIcosa(r, hsides)
+                                              : buildOrig(r, hsides, vsides);
+
+    std::vector<Value> vertsValues;
+    vertsValues.reserve(m.verts.size());
+    for (double v : m.verts) vertsValues.push_back(Value{v});
+    std::vector<Value> trisValues;
+    trisValues.reserve(m.tris.size());
+    for (int t : m.tris) trisValues.push_back(Value{static_cast<double>(t)});
     params["verts"] = Value{std::make_shared<const ValueList>(ValueList{std::move(vertsValues)})};
     params["tris"] = Value{std::make_shared<const ValueList>(ValueList{std::move(trisValues)})};
-    params["color"] = colorToValue(effCtx.color);
     return params;
 }
 
@@ -174,6 +372,11 @@ std::vector<ColoredBody> generateSphere(Evaluator& ev, const CSGParams& params,
     for (const Value& t : std::get<ListPtr>(params.at("tris"))->items) {
         mesh.triVerts.push_back(static_cast<uint64_t>(std::get<double>(t)));
     }
+    if (std::get<std::string>(params.at("style")) == "octa") {
+        manifold::Manifold octa = manifold::Manifold::Sphere(
+            std::get<double>(params.at("r")), static_cast<int>(std::get<double>(params.at("segs"))));
+        return {ev.tagGenerated(std::move(octa), node, params.at("color"))};
+    }
     manifold::Manifold body(mesh);
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.36.0}/src/builtins/registry.cpp

@@ -92,7 +92,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
     static const std::unordered_map<std::string, std::vector<std::string>> table = {
         // -- builtin modules ---------------------------------------------
         {"cube", {"size", "center"}},
-        {"sphere", {"r", "d"}},
+        {"sphere", {"r", "d", "style"}},
         {"cylinder", {"h", "r1", "r2", "center", "r", "d", "d1", "d2"}},
         {"polyhedron", {"points", "faces", "convexity", "triangles"}},
         {"square", {"size", "center"}},

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.36.0}/tests/test_primitives.cpp

@@ -273,3 +273,129 @@ TEST(Polyhedron, OpenMeshIsExcludedFromCsgButSurvivesIt) {
     EXPECT_EQ(solids, 1);
     EXPECT_EQ(displayOnly, 1);
 }
+
+// -- sphere(style=) -------------------------------------------------------
+//
+// A BelfrySCAD extension naming the tessellation, with BOSL2's five style
+// names and constructions. Every vertex/triangle count below was compared
+// against BOSL2's own spheroid(r=10, style=..., circum=false, $fn=24), and
+// the volumes matched exactly for aligned, stagger and icosa.
+//
+// Note BOSL2 *shadows* sphere() with its own module, so any comparison has
+// to call spheroid() from a BOSL2-including file and sphere() from one
+// without -- including BOSL2 to "check the reference" silently compares
+// BOSL2 against itself, which is how the first run of this looked correct
+// while testing nothing.
+
+namespace {
+
+struct SphereStats {
+    size_t verts = 0;
+    size_t tris = 0;
+    double volume = 0.0;
+};
+
+SphereStats sphereStats(const std::string& code) {
+    Evaluated e = evalSrc(code);
+    EXPECT_EQ(e.bodies.size(), 1u);
+    const manifold::Manifold& m = *e.bodies[0].body;
+    return {static_cast<size_t>(m.NumVert()), static_cast<size_t>(m.NumTri()), m.Volume()};
+}
+
+} // namespace
+
+TEST(SphereStyle, DefaultsToOrigAndIsUnchanged) {
+    const SphereStats def = sphereStats("sphere(r=10, $fn=24);");
+    const SphereStats orig = sphereStats("sphere(r=10, style=\"orig\", $fn=24);");
+    EXPECT_EQ(def.verts, orig.verts);
+    EXPECT_EQ(def.tris, orig.tris);
+    EXPECT_NEAR(def.volume, orig.volume, 1e-9);
+    // The pre-existing OpenSCAD construction: 24 segments x 12 stacks, no
+    // pole vertices.
+    EXPECT_EQ(orig.verts, 288u);
+}
+
+TEST(SphereStyle, AlignedPutsVerticesAtThePoles) {
+    Evaluated e = evalSrc("sphere(r=10, style=\"aligned\", $fn=24);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const manifold::Box bb = e.bodies[0].body->BoundingBox();
+    // A pole vertex reaches the full radius; "orig" stops short of it.
+    EXPECT_NEAR(bb.max.z, 10.0, 1e-9);
+    EXPECT_NEAR(bb.min.z, -10.0, 1e-9);
+    const manifold::Box origBb = evalSrc("sphere(r=10, style=\"orig\", $fn=24);").bodies[0].body->BoundingBox();
+    EXPECT_LT(origBb.max.z, 10.0);
+}
+
+TEST(SphereStyle, AlignedTouchesTheAxesWhenFnIsDivisibleByFour) {
+    // $fn divisible by 4 puts a ring on the equator and a vertex on each of
+    // +-X and +-Y, so the bounding box reaches the full radius on every
+    // axis. That is the whole point of the style.
+    Evaluated e = evalSrc("sphere(r=10, style=\"aligned\", $fn=24);");
+    const manifold::Box bb = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(bb.max.x, 10.0, 1e-9);
+    EXPECT_NEAR(bb.max.y, 10.0, 1e-9);
+    // ...whereas "orig" has no vertex on either axis and falls inside.
+    const manifold::Box ob = evalSrc("sphere(r=10, style=\"orig\", $fn=24);").bodies[0].body->BoundingBox();
+    EXPECT_LT(ob.max.x, 10.0);
+}
+
+TEST(SphereStyle, StaggerHasTheSameCountsAsAlignedButDiffers) {
+    const SphereStats a = sphereStats("sphere(r=10, style=\"aligned\", $fn=24);");
+    const SphereStats s = sphereStats("sphere(r=10, style=\"stagger\", $fn=24);");
+    EXPECT_EQ(a.verts, s.verts);   // same lattice size...
+    EXPECT_EQ(a.tris, s.tris);
+    EXPECT_GT(std::fabs(a.volume - s.volume), 1.0);   // ...different shape
+}
+
+TEST(SphereStyle, EveryStyleMatchesBosl2sCounts) {
+    // Compared against BOSL2 spheroid(r=10, style=..., circum=false, $fn=24).
+    EXPECT_EQ(sphereStats("sphere(r=10, style=\"aligned\", $fn=24);").verts, 266u);
+    EXPECT_EQ(sphereStats("sphere(r=10, style=\"aligned\", $fn=24);").tris, 528u);
+    EXPECT_EQ(sphereStats("sphere(r=10, style=\"stagger\", $fn=24);").verts, 266u);
+    EXPECT_EQ(sphereStats("sphere(r=10, style=\"octa\", $fn=24);").verts, 146u);
+    EXPECT_EQ(sphereStats("sphere(r=10, style=\"octa\", $fn=24);").tris, 288u);
+    EXPECT_EQ(sphereStats("sphere(r=10, style=\"icosa\", $fn=24);").verts, 252u);
+    EXPECT_EQ(sphereStats("sphere(r=10, style=\"icosa\", $fn=24);").tris, 500u);
+}
+
+TEST(SphereStyle, EveryStyleMatchesBosl2sVolume) {
+    // aligned/stagger/icosa agree with BOSL2 to the last digit. "octa" comes
+    // from Manifold::Sphere, whose octahedral subdivision distributes its
+    // vertices a little differently than BOSL2's -- same 146/288 topology,
+    // ~0.05% apart in volume.
+    EXPECT_NEAR(sphereStats("sphere(r=10, style=\"aligned\", $fn=24);").volume, 4070.5524, 1e-3);
+    EXPECT_NEAR(sphereStats("sphere(r=10, style=\"stagger\", $fn=24);").volume, 4082.1246, 1e-3);
+    EXPECT_NEAR(sphereStats("sphere(r=10, style=\"icosa\", $fn=24);").volume, 4097.2467, 1e-3);
+    EXPECT_NEAR(sphereStats("sphere(r=10, style=\"octa\", $fn=24);").volume, 4024.3239, 1e-3);
+}
+
+TEST(SphereStyle, EveryStyleIsAClosedSolidUnderTheTrueVolume) {
+    for (const char* st : {"orig", "aligned", "stagger", "octa", "icosa"}) {
+        const SphereStats s = sphereStats(std::string("sphere(r=10, style=\"") + st + "\", $fn=24);");
+        // Positive volume also means the winding is outward: an inverted
+        // solid reports a NEGATIVE volume here, which is how the first cut
+        // of aligned/stagger was caught. Checking |volume| would have missed
+        // it entirely.
+        EXPECT_GT(s.volume, 3900.0) << st;
+        EXPECT_LT(s.volume, 4188.7902) << st;   // strictly inside the true sphere
+        EXPECT_GT(s.tris, 100u) << st;
+    }
+}
+
+TEST(SphereStyle, UnknownStyleWarnsAndFallsBackToOrig) {
+    std::string last;
+    Evaluated e = evalSrc("sphere(r=10, style=\"banana\", $fn=24);",
+                           [&](const std::string& m) { last = m; });
+    EXPECT_NE(last.find("unknown style"), std::string::npos) << last;
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_EQ(static_cast<size_t>(e.bodies[0].body->NumVert()), 288u);   // orig
+}
+
+TEST(SphereStyle, StyleRespectsFnAndRadius) {
+    // Denser $fn subdivides further, and the radius scales the result.
+    EXPECT_GT(sphereStats("sphere(r=10, style=\"icosa\", $fn=64);").tris,
+              sphereStats("sphere(r=10, style=\"icosa\", $fn=24);").tris);
+    const double v10 = sphereStats("sphere(r=10, style=\"aligned\", $fn=24);").volume;
+    const double v20 = sphereStats("sphere(r=20, style=\"aligned\", $fn=24);").volume;
+    EXPECT_NEAR(v20 / v10, 8.0, 1e-6);   // volume goes as r^3
+}

{openscad_cpp_evaluator-0.35.0 → openscad_cpp_evaluator-0.36.0}/uv.lock

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