openscad-cpp-evaluator 1.30.0__tar.gz → 1.31.0__tar.gz

{openscad_cpp_evaluator-1.30.0 → openscad_cpp_evaluator-1.31.0}/CLAUDE.md

@@ -1569,6 +1569,36 @@ than the current pause point). Ported identically (same qualifier syntax, same e
 - `tools/cli/main.cpp` — a 3-line wrapper: builds `args` from `argv`, calls `runCli(args)` with the
   real `std::cin`/`std::cout`/`std::cerr`, returns its exit code.
 
+## Curve discretization: `$fn`/`$fe`/`$fa`/`$fs` (`Discretizer`, segments.hpp)
+
+A port of upstream's `CurveDiscretizer` (src/core/CurveDiscretizer.cc): circle/arc segment counts,
+`linear_extrude` slice counts (helix, conical helix, diagonal) and outline splitting. Every count was
+checked against the 2026.02.01 binary (`--enable=discretization-by-error`), including volumes, since
+the side-quad diagonal choice changes a twisted solid without changing its triangle count.
+
+- **`$fe`** (max radial error): `n = pi/acos(1 - fe/r)`, 5 once `fe/r >= 0.1909830056`, capped at the
+  `$fa`/`$fs`=0.01 count; replaces `$fa`/`$fs` entirely; arcs scale the UNceiled n. Upstream gates it
+  behind `--enable=discretization-by-error`; here it is always on (`supported_feature
+  ("discretization-by-error")`). Not predefined in the root ctx, as upstream: a bare read warns.
+- **Bugs this fixed**, all pre-existing and all silent:
+  - `linear_extrude(twist=)` without `slices` was ONE slice: 180 degrees collapsed to a straight prism.
+  - `slices=N` gave N+1 slices (Manifold's `nDivisions` is the copies between the ends).
+  - Twisted and non-uniformly-scaled extrusions never split their outline edges.
+  - Partial `rotate_extrude(angle=)` packed the full circle's count into the arc (Manifold's
+    `Revolve` takes the count for the arc it is given).
+  - Text curves used `$fn` at radius 0, halved, instead of `circular(size)/8 + 1`.
+  - A fractional `$fn` truncated instead of rounding up.
+- **Twisted/non-uniform extrusions are built by hand** (`extrudeTwisted`, extrude.cpp), not by
+  `Manifold::Extrude`: their side quads are not planar and upstream splits each along its SHORTER
+  diagonal (`sgn_vdiff`, ties broken by twist direction and hole-ness). `Manifold::Extrude` always picks
+  the same diagonal: same triangle count, different volume (241 vs 254 for a 180-degree twist).
+  Planar cases (no twist, uniform scale) and a top scaled to zero stay on `Manifold::Extrude`.
+- **1-2 section arcs** (short `rotate_extrude` angles at coarse settings): `Revolve` substitutes its own
+  default below 3, so these are an extrude warped round Z. The warp inverts the solid for a positive
+  angle, hence the mirror-in-Y dance.
+- Kept departure: `$fa`/`$fs` <= 0 fall back to 12/2 rather than upstream's clamp-to-0.01 with a warning.
+- Not ported: `linear_extrude(v=)` (accepted, ignored); DXF/SVG import arcs don't read the discretizer.
+
 ## Cancel and the module recursion limit (#554)
 
 - **`Evaluator::setCancelFlag(shared_ptr<atomic<bool>>)`** -- bound as `CancelSignal` /

{openscad_cpp_evaluator-1.30.0 → openscad_cpp_evaluator-1.31.0}/PKG-INFO

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

openscad_cpp_evaluator-1.31.0/include/openscad_cpp_evaluator/segments.hpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "openscad_cpp_evaluator/eval_context.hpp"
+#include "openscad_cpp_evaluator/csg_node.hpp"
+
+#include <manifold/common.h>
+
+#include <optional>
+
+namespace oscadeval {
+
+// How curves become polygons: OpenSCAD's CurveDiscretizer (src/core/
+// CurveDiscretizer.cc, upstream master cc19000e0), ported. Every count here
+// matches the 2026.02.01 binary's.
+//
+// $fn > $fe > $fa/$fs. $fe is the most a curve's polygon may stray from the
+// true circle, measured along a radius to an edge's midpoint; when set (>=
+// 2^-20) it replaces $fa/$fs entirely. Upstream reads $fe only behind
+// --enable=discretization-by-error; this evaluator always honours it, and
+// advertises that as supported_feature("discretization-by-error").
+//
+// Departures from upstream, kept from before this port: $fa/$fs <= 0 fall
+// back to their defaults (12/2) rather than clamping to 0.01 with a warning.
+struct Discretizer {
+    double fn = 0.0;
+    double fe = 0.0;
+    double fa = 12.0;
+    double fs = 2.0;
+
+    static Discretizer fromCtx(const EvalContext& ctx);
+    // Stored in, and read back from, a node's params -- they are part of its
+    // cache key, and generate has only the params to go on.
+    static Discretizer fromParams(const CSGParams& params);
+    void store(CSGParams& params) const;
+
+    // Segments for `angle` degrees of arc at radius r. nullopt where
+    // upstream has none (r below 2^-20, a non-finite $fn/$fe/angle): every
+    // caller supplies its own fallback, as upstream's value_or() does.
+    std::optional<int> circular(double r, double angleDegrees = 360.0) const;
+
+    // linear_extrude slice counts: twist without scale, twist with uniform
+    // scale, and non-uniform scale (with or without twist).
+    std::optional<int> helixSlices(double rSqr, double height, double twistDegrees) const;
+    std::optional<int> conicalHelixSlices(double rSqr, double height, double twistDegrees, double scale) const;
+    std::optional<int> diagonalSlices(double deltaSqr, double height) const;
+
+    // Subdivide an outline's edges so a twisted or non-uniformly scaled
+    // extrusion keeps its shape between slices. `segments` is linear_extrude's
+    // own argument (0 = not given).
+    manifold::SimplePolygon splitOutline(const manifold::SimplePolygon& outline, double twistDegrees,
+                                         double scaleX, double scaleY, unsigned slices, unsigned segments) const;
+};
+
+// Full-circle segment count from ctx's $fn/$fe/$fa/$fs at radius r;
+// upstream's primitives fall back to 3.
+int fnSegmentsFromCtx(const EvalContext& ctx, double r = 0.0);
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.30.0 → openscad_cpp_evaluator-1.31.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.30.0 → openscad_cpp_evaluator-1.31.0}/src/builtins/extrude.cpp

@@ -5,7 +5,9 @@
 #include "openscad_cpp_evaluator/segments.hpp"
 
 #include <algorithm>
+#include <manifold/polygon.h>
 #include <cmath>
+#include <numbers>
 
 namespace oscadeval {
 
@@ -26,13 +28,110 @@ namespace oscadeval {
 // still not covered by PushBuiltinWrap) is behaviorally unobservable --
 // see computeRoofParams's own doc comment (roof.cpp) for the one builtin
 // in this group where that ISN'T true and a different split was needed.
+namespace {
+
+// Upstream's sgn_vdiff: which of two diagonals is shorter, treating lengths
+// within 1 part in 1e5 as a tie.
+int sgnVdiff(const manifold::vec2& v1, const manifold::vec2& v2) {
+    const double l1 = manifold::la::length(v1), l2 = manifold::la::length(v2);
+    return 2 * std::fabs(l1 - l2) * 1e5 > l1 + l2 ? (l1 < l2 ? -1 : 1) : 0;
+}
+
+// A twisted or non-uniformly scaled extrusion, built the way upstream's
+// linear_extrude.cc builds it. Its side quads are not planar, so which
+// diagonal splits each one changes the solid, and Manifold's own Extrude
+// always picks the same one: the result had OpenSCAD's triangle count and a
+// different volume (241 vs 254 for a 180-degree twist of square(5)).
+// Upstream splits along the SHORTER diagonal, breaking exact ties by twist
+// direction and whether the outline is a hole.
+manifold::Manifold extrudeTwisted(const manifold::Polygons& polys, double height, int slices, double twist,
+                                  double scaleX, double scaleY) {
+    size_t stride = 0;
+    for (const manifold::SimplePolygon& o : polys) stride += o.size();
+    const auto ringPoint = [&](const manifold::vec2& v, int j) {
+        const double t = static_cast<double>(j) / slices;
+        const double a = -twist * t * std::numbers::pi / 180.0;
+        return manifold::vec2((v.x * std::cos(a) - v.y * std::sin(a)) * (1 - (1 - scaleX) * t),
+                              (v.x * std::sin(a) + v.y * std::cos(a)) * (1 - (1 - scaleY) * t));
+    };
+
+    manifold::MeshGL64 mesh;
+    mesh.numProp = 3;
+    for (int j = 0; j <= slices; ++j) {
+        for (const manifold::SimplePolygon& o : polys) {
+            for (const manifold::vec2& v : o) {
+                const manifold::vec2 p = ringPoint(v, j);
+                mesh.vertProperties.insert(mesh.vertProperties.end(),
+                                           {p.x, p.y, height * j / slices});
+            }
+        }
+    }
+    const auto tri = [&](size_t a, size_t b, size_t c) { mesh.triVerts.insert(mesh.triVerts.end(), {a, b, c}); };
+
+    const bool backTwist = twist <= 0; // rotation_slice_top <= rotation_slice_bottom, every slice
+    for (int j = 1; j <= slices; ++j) {
+        const size_t bot = (j - 1) * stride, top = j * stride;
+        size_t cur = 0;
+        for (const manifold::SimplePolygon& o : polys) {
+            const size_t n = o.size();
+            double area2 = 0;
+            for (size_t i = 0; i < n; ++i) area2 += o[i].x * o[(i + 1) % n].y - o[(i + 1) % n].x * o[i].y;
+            const bool flip = (area2 < 0) != backTwist; // !positive xor back_twist
+            manifold::vec2 prevBot = ringPoint(o[0], j - 1), prevTop = ringPoint(o[0], j);
+            for (size_t i = 1; i <= n; ++i) {
+                const manifold::vec2 vBot = ringPoint(o[i % n], j - 1), vTop = ringPoint(o[i % n], j);
+                const size_t idx = cur + i % n, prev = cur + i - 1;
+                const int diff = sgnVdiff(prevBot - vTop, vBot - prevTop);
+                if (diff == -1 || (diff == 0 && !flip)) {
+                    tri(bot + idx, top + idx, bot + prev);
+                    tri(top + prev, bot + prev, top + idx);
+                } else {
+                    tri(bot + idx, top + prev, bot + prev);
+                    tri(bot + idx, top + idx, top + prev);
+                }
+                prevBot = vBot;
+                prevTop = vTop;
+            }
+            cur += n;
+        }
+    }
+
+    // Caps: one triangulation of the outline, reused at both ends.
+    manifold::PolygonsIdx indexed;
+    size_t cur = 0;
+    for (const manifold::SimplePolygon& o : polys) {
+        manifold::SimplePolygonIdx ring;
+        for (size_t i = 0; i < o.size(); ++i) ring.push_back({o[i], static_cast<int>(cur + i)});
+        indexed.push_back(std::move(ring));
+        cur += o.size();
+    }
+    const size_t topBase = static_cast<size_t>(slices) * stride;
+    for (const manifold::ivec3& t : manifold::TriangulateIdx(indexed)) {
+        tri(t.x, t.z, t.y);                                    // bottom faces down
+        tri(topBase + t.x, topBase + t.y, topBase + t.z);      // top faces up
+    }
+    return manifold::Manifold(mesh);
+}
+
+} // namespace
+
 BuiltinWrapParams computeLinearExtrudeParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
 
     const double height = toDoubleLenient(getArg(args, 0, "height", Value{1.0}));
     const bool center = truthy(getArg(args, std::nullopt, "center", Value{false}));
     const double twist = toDoubleLenient(getArg(args, std::nullopt, "twist", Value{0.0}));
-    const int slices = static_cast<int>(toDoubleLenient(getArg(args, std::nullopt, "slices", Value{0.0})));
+    // Upstream's validate_integral: any finite number counts as given, and is
+    // truncated and clamped (slices >= 1, segments >= 0). Not given, the
+    // discretizer decides.
+    const auto integral = [&](const char* name, double lo) -> std::optional<double> {
+        const Value v = getArg(args, std::nullopt, name, Value{});
+        const double* d = std::get_if<double>(&v);
+        if (!d || !std::isfinite(*d)) return std::nullopt;
+        return *d < lo ? lo : std::trunc(*d);
+    };
+    const std::optional<double> slices = integral("slices", 1.0);
+    const std::optional<double> segments = integral("segments", 0.0);
     const Value scaleArg = getArg(args, std::nullopt, "scale", Value{});
 
     double scaleX = 1.0, scaleY = 1.0;
@@ -47,7 +146,9 @@ BuiltinWrapParams computeLinearExtrudeParams(Evaluator& ev, const oscad::Modular
     params["height"] = Value{height};
     params["center"] = Value{center};
     params["twist"] = Value{twist};
-    params["slices"] = Value{static_cast<double>(slices)};
+    params["slices"] = slices ? Value{*slices} : Value{};
+    params["segments"] = segments ? Value{*segments} : Value{};
+    Discretizer::fromCtx(effCtx).store(params);
     params["scale_x"] = Value{scaleX};
     params["scale_y"] = Value{scaleY};
     params["color"] = colorToValue(effCtx.color);
@@ -69,11 +170,60 @@ std::vector<ColoredBody> generateLinearExtrude(Evaluator& ev, const CSGParams& p
     if (!cs || cs->IsEmpty()) return {};
 
     const double height = std::get<double>(params.at("height"));
-    const int slices = static_cast<int>(std::get<double>(params.at("slices")));
     const double twist = std::get<double>(params.at("twist"));
-    const manifold::vec2 scaleTop(std::get<double>(params.at("scale_x")), std::get<double>(params.at("scale_y")));
+    const double scaleX = std::get<double>(params.at("scale_x"));
+    const double scaleY = std::get<double>(params.at("scale_y"));
+    const double* givenSlices = std::get_if<double>(&params.at("slices"));
+    const double* givenSegments = std::get_if<double>(&params.at("segments"));
+    const Discretizer disc = Discretizer::fromParams(params);
+    manifold::Polygons polys = cs->ToPolygons();
+
+    // Upstream's calc_num_slices (linear_extrude.cc).
+    const auto maxDeltaSqr = [&] {
+        double m = 0;
+        for (const manifold::SimplePolygon& o : polys)
+            for (const manifold::vec2& v : o) m = std::max(m, manifold::la::length2(v - manifold::vec2(v.x * scaleX, v.y * scaleY)));
+        return m;
+    };
+    const int twistFallback = std::max(static_cast<int>(std::ceil(twist / 120.0)), 1);
+    int slices = 1;
+    if (givenSlices) {
+        slices = static_cast<int>(*givenSlices);
+    } else if (twist != 0.0) {
+        double maxR1Sqr = 0;
+        for (const manifold::SimplePolygon& o : polys)
+            for (const manifold::vec2& v : o) maxR1Sqr = std::max(maxR1Sqr, manifold::la::length2(v));
+        if (scaleX == 1.0 && scaleY == 1.0) {
+            slices = disc.helixSlices(maxR1Sqr, height, twist).value_or(twistFallback);
+        } else if (scaleX != scaleY) {
+            slices = std::max(disc.diagonalSlices(maxDeltaSqr(), height).value_or(1),
+                              disc.helixSlices(maxR1Sqr, height, twist).value_or(twistFallback));
+        } else {
+            slices = disc.conicalHelixSlices(maxR1Sqr, height, twist, scaleX).value_or(twistFallback);
+        }
+    } else if (scaleX != scaleY) {
+        slices = disc.diagonalSlices(maxDeltaSqr(), height).value_or(1);
+    }
+
+    // Split outline edges where a straight one would lose the shape between
+    // slices: twist or non-uniform scale, or `segments` asked for. segments=0
+    // turns it off.
+    const unsigned segments = givenSegments ? static_cast<unsigned>(*givenSegments) : 0;
+    const bool nonLinear = twist != 0.0 || scaleX != scaleY;
+    if (!(givenSegments && segments == 0) && (segments > 0 || nonLinear)) {
+        for (manifold::SimplePolygon& o : polys)
+            o = disc.splitOutline(o, twist, scaleX, scaleY, static_cast<unsigned>(slices), segments);
+    }
 
-    manifold::Manifold body = manifold::Manifold::Extrude(cs->ToPolygons(), height, slices, -twist, scaleTop);
+    // Planar side quads (no twist, uniform scale) come out the same however
+    // they are split, so Manifold's own Extrude does. So does a top scaled to
+    // zero in either axis, where upstream's shorter-diagonal rule is
+    // reversed to avoid zero-thickness ears; a cone tip is Extrude's to make.
+    // Manifold's nDivisions is the copies BETWEEN the ends: slices - 1.
+    manifold::Manifold body =
+        nonLinear && scaleX > 0 && scaleY > 0 && height > 0
+            ? extrudeTwisted(polys, height, slices, twist, scaleX, scaleY)
+            : manifold::Manifold::Extrude(polys, height, slices - 1, -twist, manifold::vec2(scaleX, scaleY));
     if (std::get<bool>(params.at("center"))) body = body.Translate(manifold::vec3(0, 0, -height / 2));
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }
@@ -91,18 +241,9 @@ BuiltinWrapParams computeRotateExtrudeParams(Evaluator& ev, const oscad::Modular
 
     const double angle = toDoubleLenient(getArg(args, 0, "angle", Value{360.0}));
 
-    const auto dynOr = [&](const char* name, double fallback) {
-        const Value* v = effCtx.dyn->find(name);
-        if (!v) return fallback;
-        const double* d = std::get_if<double>(v);
-        return d ? *d : fallback;
-    };
-
     CSGParams params;
     params["angle"] = Value{angle};
-    params["fn"] = Value{dynOr("$fn", 0.0)};
-    params["fa"] = Value{dynOr("$fa", 12.0)};
-    params["fs"] = Value{dynOr("$fs", 2.0)};
+    Discretizer::fromCtx(effCtx).store(params);
     params["color"] = colorToValue(effCtx.color);
     return BuiltinWrapParams{std::move(params), std::move(effCtx)};
 }
@@ -121,12 +262,41 @@ std::vector<ColoredBody> generateRotateExtrude(Evaluator& ev, const CSGParams& p
     const std::optional<manifold::CrossSection> cs = toCrossSection(flattenCsgTree(children));
     if (!cs || cs->IsEmpty()) return {};
 
+    // Upstream (rotate_extrude.cc) sizes the arc by the profile's extent in X,
+    // measured from the axis: both ends start at 0.
     const manifold::Rect bounds = cs->Bounds();
-    const double maxX = std::max(std::fabs(bounds.min.x), std::fabs(bounds.max.x));
-    const int segs = fnSegments(std::get<double>(params.at("fn")), std::get<double>(params.at("fa")),
-                                 std::get<double>(params.at("fs")), maxX);
-
-    manifold::Manifold body = manifold::Manifold::Revolve(cs->ToPolygons(), segs, std::get<double>(params.at("angle")));
+    const double width = std::max(bounds.max.x, 0.0) - std::min(bounds.min.x, 0.0);
+    const double angle = std::get<double>(params.at("angle"));
+    const int sections = Discretizer::fromParams(params).circular(width, angle).value_or(
+        std::max(1, static_cast<int>(std::fabs(angle) / 360 * 3)));
+    // Revolve takes this as the section count for the arc it is given -- not
+    // per full circle, which is what it used to be handed, packing a whole
+    // circle's worth into a partial one.
+    manifold::Manifold body;
+    if (sections >= 3 || bounds.min.x < 0) {
+        // (A profile left of the axis keeps Revolve's handling; a 1-2 section
+        // arc of one is the only case still drawn with 3.)
+        body = manifold::Manifold::Revolve(cs->ToPolygons(), std::max(sections, 3), angle);
+    } else {
+        // Revolve substitutes its own default below 3 sections, but a short
+        // arc at coarse settings is 1 or 2 (upstream draws exactly that). So
+        // extrude the profile into that many sections and wrap them round the
+        // Z axis. The wrap turns the solid inside out for a positive angle, so
+        // then the profile goes in mirrored in Y and comes back out unmirrored.
+        const double sign = angle > 0 ? -1.0 : 1.0;
+        manifold::Polygons profile = cs->ToPolygons();
+        if (sign < 0) {
+            for (manifold::SimplePolygon& o : profile) {
+                for (manifold::vec2& v : o) v.y = -v.y;
+                std::reverse(o.begin(), o.end());
+            }
+        }
+        const double rad = angle * std::numbers::pi / 180.0;
+        body = manifold::Manifold::Extrude(profile, 1.0, sections - 1).Warp([rad, sign](manifold::vec3& v) {
+            const double a = v.z * rad;
+            v = manifold::vec3(v.x * std::cos(a), v.x * std::sin(a), sign * v.y);
+        });
+    }
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }
 

{openscad_cpp_evaluator-1.30.0 → openscad_cpp_evaluator-1.31.0}/src/builtins/function_builtins.cpp

@@ -1017,6 +1017,7 @@ const std::unordered_map<std::string, double>& featureLevels() {
         {"object-function", 1.0},    // object(), unconditional here
         {"roof-op", 1.0},            // roof(), method="voronoi" only
         {"svg-class", 1.0},          // import(svg, class=); id= is upstream's
+        {"discretization-by-error", 1.0}, // $fe, always on (upstream: behind --enable)
     };
     return levels;
 }

openscad_cpp_evaluator-1.31.0/src/builtins/segments.cpp

@@ -0,0 +1,256 @@
+#include "openscad_cpp_evaluator/segments.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <numbers>
+#include <queue>
+#include <vector>
+
+namespace oscadeval {
+
+namespace {
+
+constexpr double kPi = std::numbers::pi;
+constexpr double kDeg2Rad = kPi / 180.0;
+constexpr double kGridFine = 0.00000095367431640625; // 2^-20, upstream's GRID_FINE
+constexpr double kFMinimum = 0.01;                   // upstream's F_MINIMUM
+
+double dynNumberOr(const EvalContext& ctx, const char* name, double fallback) {
+    const Value* v = ctx.dyn->find(name);
+    if (!v) return fallback;
+    const double* d = std::get_if<double>(v);
+    return d ? *d : fallback;
+}
+
+double paramOr(const CSGParams& params, const char* key, double fallback) {
+    auto it = params.find(key);
+    if (it == params.end()) return fallback;
+    const double* d = std::get_if<double>(&it->second);
+    return d ? *d : fallback;
+}
+
+double segmentsGivenFa(double fa) { return 360.0 / fa; }
+double segmentsGivenFs(double r, double fs) { return r * 2 * kPi / fs; }
+
+// https://mathworld.wolfram.com/Helix.html -- see upstream for the derivation.
+double helixArcLength(double rSqr, double height, double twistDegrees) {
+    const double t = twistDegrees * kDeg2Rad;
+    const double c = height / t;
+    return t * std::sqrt(rSqr + c * c);
+}
+
+double archimedesLength(double a, double theta) {
+    return 0.5 * a * (theta * std::sqrt(1 + theta * theta) + std::asinh(theta));
+}
+
+manifold::vec2 transformAt(const manifold::vec2& v, double twist, double scaleX, double scaleY, double t) {
+    // Eigen::Scaling(lerp(1, s, t)) * rotate_degrees(-twist * t), as upstream.
+    const double a = -twist * t * kDeg2Rad;
+    const double x = v.x * std::cos(a) - v.y * std::sin(a);
+    const double y = v.x * std::sin(a) + v.y * std::cos(a);
+    return {x * (1 + (scaleX - 1) * t), y * (1 + (scaleY - 1) * t)};
+}
+
+// The longest an outline edge gets over every slice of the extrusion.
+double maxEdgeLength(const manifold::vec2& v0, const manifold::vec2& v1, double twist, double scaleX,
+                     double scaleY, unsigned slices) {
+    if (scaleX == scaleY) return manifold::la::length(v1 - v0) * std::max(scaleX, 1.0);
+    double longest = 0.0;
+    for (unsigned j = 0; j <= slices; ++j) {
+        const double t = static_cast<double>(j) / slices;
+        longest = std::max(longest, manifold::la::length(transformAt(v1, twist, scaleX, scaleY, t) -
+                                               transformAt(v0, twist, scaleX, scaleY, t)));
+    }
+    return longest;
+}
+
+void addSegmentedEdge(manifold::SimplePolygon& out, const manifold::vec2& v0, const manifold::vec2& v1,
+                      unsigned segments) {
+    for (unsigned j = 0; j < segments; ++j) {
+        const double t = static_cast<double>(j) / segments;
+        out.push_back((1 - t) * v0 + t * v1);
+    }
+}
+
+// Upstream's splitOutlineByFn: while the outline has fewer than fn vertices,
+// split the edge whose segments are longest, a whole group of near-equal
+// edges at a time so the result stays symmetrical.
+manifold::SimplePolygon splitByFn(const manifold::SimplePolygon& o, double twist, double scaleX, double scaleY,
+                                  double fn, unsigned slices) {
+    struct Tracker {
+        size_t edge;
+        double maxLen;
+        unsigned count = 1;
+        double metric() const { return maxLen / (count + 0.5); }
+        bool operator<(const Tracker& rhs) const { return metric() < rhs.metric(); }
+        bool closeMatch(const Tracker& other) const {
+            const double l1 = metric(), l2 = other.metric();
+            return std::min(l1, l2) / std::max(l1, l2) >= 0.999;
+        }
+    };
+    const size_t n = o.size();
+    std::vector<unsigned> counts(n, 1);
+    std::priority_queue<Tracker> q;
+    for (size_t i = 1; i <= n; ++i) {
+        q.push(Tracker{i - 1, maxEdgeLength(o[i - 1], o[i % n], twist, scaleX, scaleY, slices)});
+    }
+    std::vector<Tracker> group;
+    size_t total = n;
+    while (total < fn) {
+        while (!q.empty() && (group.empty() || q.top().closeMatch(group.front()))) {
+            group.push_back(q.top());
+            q.pop();
+        }
+        if (total + group.size() <= fn) {
+            while (!group.empty()) {
+                Tracker cur = group.back();
+                group.pop_back();
+                ++cur.count;
+                ++counts[cur.edge];
+                ++total;
+                q.push(cur);
+            }
+        } else {
+            while (!group.empty()) {
+                q.push(group.back());
+                group.pop_back();
+            }
+            break;
+        }
+    }
+    manifold::SimplePolygon out;
+    for (size_t i = 1; i <= n; ++i) addSegmentedEdge(out, o[i - 1], o[i % n], counts[i - 1]);
+    return out;
+}
+
+manifold::SimplePolygon splitByFs(const manifold::SimplePolygon& o, double twist, double scaleX, double scaleY,
+                                  double fs, unsigned slices) {
+    const size_t n = o.size();
+    manifold::SimplePolygon out;
+    for (size_t i = 1; i <= n; ++i) {
+        const double len = maxEdgeLength(o[i - 1], o[i % n], twist, scaleX, scaleY, slices);
+        addSegmentedEdge(out, o[i - 1], o[i % n], static_cast<unsigned>(std::ceil(len / fs)));
+    }
+    return out;
+}
+
+} // namespace
+
+Discretizer Discretizer::fromCtx(const EvalContext& ctx) {
+    Discretizer d;
+    d.fn = dynNumberOr(ctx, "$fn", 0.0);
+    d.fe = dynNumberOr(ctx, "$fe", 0.0);
+    d.fa = dynNumberOr(ctx, "$fa", 12.0);
+    d.fs = dynNumberOr(ctx, "$fs", 2.0);
+    if (d.fa <= 0) d.fa = 12.0;
+    if (d.fs <= 0) d.fs = 2.0;
+    if (d.fn < 0) d.fn = 0.0;
+    if (d.fe < 0) d.fe = 0.0;
+    return d;
+}
+
+Discretizer Discretizer::fromParams(const CSGParams& params) {
+    Discretizer d;
+    d.fn = paramOr(params, "fn", 0.0);
+    d.fe = paramOr(params, "fe", 0.0);
+    d.fa = paramOr(params, "fa", 12.0);
+    d.fs = paramOr(params, "fs", 2.0);
+    return d;
+}
+
+void Discretizer::store(CSGParams& params) const {
+    params["fn"] = Value{fn};
+    params["fe"] = Value{fe};
+    params["fa"] = Value{fa};
+    params["fs"] = Value{fs};
+}
+
+std::optional<int> Discretizer::circular(double r, double angleDegrees) const {
+    if (r < kGridFine || !std::isfinite(fn) || !std::isfinite(angleDegrees)) return std::nullopt;
+    double result;
+    if (fn > 0.0) {
+        // Ceiled before scaling to the arc, as upstream keeps for compatibility.
+        result = std::ceil(std::max(fn, 3.0)) * std::fabs(angleDegrees) / 360.0;
+    } else {
+        if (!std::isfinite(fe)) return std::nullopt;
+        if (fe >= kGridFine) {
+            // Apothem r - fe: r*cos(pi/n) = r - fe, so n = pi / acos(1 - fe/r).
+            // At the ratio giving exactly 5 (which also covers fe >= r), 5.
+            const double maxSegments =
+                std::max(std::min(segmentsGivenFa(kFMinimum), segmentsGivenFs(r, kFMinimum)), 5.0);
+            const double ratio = fe / r;
+            result = ratio >= 0.1909830056 ? 5.0 : std::min(maxSegments, kPi / std::acos(1 - ratio));
+            // NOT ceiled before scaling to the arc, unlike the $fa/$fs branch.
+        } else {
+            result = std::ceil(std::max(std::min(segmentsGivenFa(fa), segmentsGivenFs(r, fs)), 5.0));
+        }
+        result *= std::fabs(angleDegrees) / 360.0;
+    }
+    return std::max(1, static_cast<int>(std::ceil(result)));
+}
+
+std::optional<int> Discretizer::helixSlices(double rSqr, double height, double twistDegrees) const {
+    twistDegrees = std::fabs(twistDegrees);
+    // At least 3 slices per full turn: 180 degrees in one slice is never manifold.
+    const int minSlices = std::max(static_cast<int>(std::ceil(twistDegrees / 120.0)), 1);
+    if (std::sqrt(rSqr) < kGridFine || !std::isfinite(fn) || std::isnan(height) || std::isnan(twistDegrees))
+        return std::nullopt;
+    if (fn > 0.0) return std::max(static_cast<int>(std::ceil(twistDegrees / 360.0 * fn)), minSlices);
+    if (fe > 0.0) {
+        // Error of the chord between two slices' furthest vertex, from the
+        // helix it approximates; see upstream's helix_slices_given_fe.
+        const double r = std::sqrt(rSqr);
+        if (fe >= r) return minSlices;
+        const double theta = 2 * (kPi - std::acos(fe / r - 1));
+        return std::max(static_cast<int>(std::ceil(twistDegrees * kDeg2Rad / theta)), minSlices);
+    }
+    const int faSlices = static_cast<int>(std::ceil(twistDegrees / fa));
+    const int fsSlices = static_cast<int>(std::ceil(helixArcLength(rSqr, height, twistDegrees) / fs));
+    return std::max(std::min(faSlices, fsSlices), minSlices);
+}
+
+std::optional<int> Discretizer::conicalHelixSlices(double rSqr, double height, double twistDegrees,
+                                                   double scale) const {
+    twistDegrees = std::fabs(twistDegrees);
+    const double r = std::sqrt(rSqr);
+    const int minSlices = std::max(static_cast<int>(std::ceil(twistDegrees / 120.0)), 1);
+    if (r < kGridFine || !std::isfinite(fn)) return std::nullopt;
+    if (fn > 0.0) return std::max(static_cast<int>(std::ceil(twistDegrees * fn / 360)), minSlices);
+    // Upstream has no $fe case here: a scaled twist is sized by $fa/$fs.
+    // The vertex follows a section of an Archimedes spiral; see upstream.
+    const double rads = twistDegrees * kDeg2Rad;
+    const double angleEnd = scale > 1 ? rads * scale / (scale - 1) : rads / (1 - scale);
+    const double angleStart = angleEnd - rads;
+    const double a = r / angleEnd;
+    const double spiral = archimedesLength(a, angleEnd) - archimedesLength(a, angleStart);
+    const double total = std::sqrt(spiral * spiral + height * height);
+    const int fsSlices = static_cast<int>(std::ceil(total / fs));
+    const int faSlices = static_cast<int>(std::ceil(twistDegrees / fa));
+    return std::max(std::min(faSlices, fsSlices), minSlices);
+}
+
+std::optional<int> Discretizer::diagonalSlices(double deltaSqr, double height) const {
+    if (std::sqrt(deltaSqr) < kGridFine || !std::isfinite(fn)) return std::nullopt;
+    if (fn > 0.0) return std::max(static_cast<int>(fn), 1);
+    return std::max(static_cast<int>(std::ceil(std::sqrt(deltaSqr + height * height) / fs)), 1);
+}
+
+manifold::SimplePolygon Discretizer::splitOutline(const manifold::SimplePolygon& o, double twist, double scaleX,
+                                                  double scaleY, unsigned slices, unsigned segments) const {
+    if (o.empty()) return o;
+    if (segments > 0 || fn > 0.0) {
+        const unsigned minVertices = segments > 0 ? segments : static_cast<unsigned>(std::max(fn, 3.0));
+        return o.size() >= minVertices ? o : splitByFn(o, twist, scaleX, scaleY, minVertices, slices);
+    }
+    // $fs, then check whether $fa gives fewer. (No $fe case upstream.)
+    const auto faSegs = static_cast<unsigned>(std::ceil(360.0 / fa));
+    if (o.size() >= faSegs) return o;
+    manifold::SimplePolygon byFs = splitByFs(o, twist, scaleX, scaleY, fs, slices);
+    return byFs.size() >= faSegs ? splitByFn(o, twist, scaleX, scaleY, faSegs, slices) : byFs;
+}
+
+int fnSegmentsFromCtx(const EvalContext& ctx, double r) {
+    return Discretizer::fromCtx(ctx).circular(r).value_or(3);
+}
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.30.0 → openscad_cpp_evaluator-1.31.0}/src/builtins/text.cpp

@@ -58,7 +58,10 @@ CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     const FontHandle handle = fp.resolveFont(fontSpec);
     const FontMetrics fm = fp.metrics(handle);
     const double scale = size * (100.0 / 72.0) / fm.unitsPerEm;
-    const int segs = std::max(2, fnSegmentsFromCtx(effCtx) / 2);
+    // Steps per glyph curve: an eighth of a circle's segments at the text's
+    // size, plus one (upstream FreetypeRenderer). This read $fn at radius 0
+    // and halved it, so default text came out at 2 steps per curve, not 4.
+    const int segs = std::max(Discretizer::fromCtx(effCtx).circular(size).value_or(3) / 8 + 1, 2);
     const TextMeasurement m = measureText(fp, handle, text, size, spacing, shape);
     const auto [offsetX, offsetY] = textAlignOffset(
         halign, valign, m, [&](const std::string& w) { ev.warn(w, &node.position()); });

{openscad_cpp_evaluator-1.30.0 → openscad_cpp_evaluator-1.31.0}/tests/CMakeLists.txt

@@ -31,6 +31,7 @@ add_executable(oscad_eval_tests
   test_use.cpp
   test_coverage.cpp
   test_extrude_roof.cpp
+  test_discretizer.cpp
   test_surface.cpp
   test_dxf_svg_import.cpp
   test_text.cpp