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

{openscad_cpp_evaluator-1.30.0 → openscad_cpp_evaluator-1.32.0}/.github/workflows/wheels.yml

@@ -119,6 +119,9 @@ jobs:
           # C:\msys64 (not on PATH); its bison/flex satisfy the parser
           # submodule's grammar version requirement.
           CIBW_BEFORE_ALL_WINDOWS: 'C:\msys64\usr\bin\bash.exe -lc "pacman -Sy --noconfirm bison flex"'
+          # The binding tests run under pytest (the file's own entry point
+          # hands over to it): most of them take tmp_path or use pytest.raises.
+          CIBW_TEST_REQUIRES: "pytest"
           CIBW_TEST_COMMAND: "python {package}/tests/test_python_bindings.py"
 
       - uses: actions/upload-artifact@v7
@@ -128,6 +131,9 @@ jobs:
 
   publish-testpypi:
     needs: [sdist, build_wheels]
+    # Tags only: a manual dispatch builds and tests every wheel, and must
+    # never publish whatever branch it was run on.
+    if: startsWith(github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
     environment: testpypi
     steps:
@@ -164,6 +170,9 @@ jobs:
 
   publish-pypi:
     needs: [publish-testpypi]
+    # Tags only: a manual dispatch builds and tests every wheel, and must
+    # never publish whatever branch it was run on.
+    if: startsWith(github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
     # The "pypi" environment carries no protection rules, so a tag runs
     # straight through TestPyPI to PyPI with nothing to stop it -- and a

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

@@ -1091,8 +1091,8 @@ grep for `ponytail:`.
   — skip it and the mesh comes out non-manifold at the seam). Self-contained 2D geometry math here
   (`dot2`/`len2`/`norm2`, the parabola-canonical-frame rotation in `discretizeArc`) exists nowhere
   else in this codebase.
-- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all ten
-  formats `exportExtensions()` lists: 3MF, AMF, PDF, STL, OBJ, OFF, PLY, SVG, VRML, X3D (3MF via
+- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all eleven
+  formats `exportExtensions()` lists: 3MF, AMF, DXF, PDF, STL, OBJ, OFF, PLY, SVG, VRML, X3D (3MF via
   `zip_stored.hpp`'s `writeDeflateZip`). **`exportExtensions()` is the one source of truth for
   which formats exist** — the Python facade and BelfrySCAD's dialog/CLI all ask it rather than
   restating the list, because three hand-written copies had already drifted far enough that `.off`
@@ -1120,6 +1120,16 @@ grep for `ponytail:`.
   binary's, vertex order and 6-vertex line wrap included. A 3D body in the list throws
   ("Current top level object is not a 2D object"), as OpenSCAD refuses too: there is no projection
   to fall back on. `ExportOptions::svg` carries OpenSCAD's five `-O export-svg/...` settings.
+  **`writeDxf` is the third 2D writer**, also on `collect2d()`: OpenSCAD's own `export_dxf.cc`
+  layout verbatim (AC1006 header with the extents, one CONTINUOUS linetype, layer 0, every contour
+  a closed `LWPOLYLINE` on layer 0 with holes as ordinary contours; 1- and 2-vertex contours as
+  `POINT`/`LINE`), pinned byte-for-byte by `ExportDxf.MatchesRealOpenscadByteForByte`. Two
+  deliberate differences: coordinates are the **shortest text that round-trips the double**
+  (`dxfNum`), not OpenSCAD's 6 significant digits -- a DXF feeds a cutter, and its circles do not
+  survive a re-import otherwise; and `$EXTMAX` is right for a model below zero (OpenSCAD seeds its
+  maxima with `numeric_limits<double>::min()`, the smallest POSITIVE double). Every number goes
+  through the classic locale, the file stream included: Qt sets the process locale, and a grouping
+  locale writes a 1500-vertex count as `1.500`.
   **`writePdf` is the other 2D writer**, and shares `collect2d()` with `writeSvg` so the all-2D
   rule and its refusal have one implementation. Everything else differs from SVG: the drawing is
   **centred on a fixed paper size** rather than the page being cut to fit, and **PDF user space is
@@ -1569,6 +1579,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.32.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.30.0 → openscad_cpp_evaluator-1.32.0}/include/openscad_cpp_evaluator/export.hpp

@@ -158,6 +158,17 @@ struct ExportSvgOptions {
 void writeSvg(const std::string& path, const std::vector<ColoredBody>& bodies,
               const ExportSvgOptions& opts = {});
 
+// DXF, the third 2D writer: OpenSCAD's own export_dxf.cc layout (an AC1006
+// header with the model's extents, one CONTINUOUS linetype, layer 0) and
+// every contour of every body a closed LWPOLYLINE on layer 0 -- holes are
+// contours like any other, as in OpenSCAD. A 1-vertex contour is a POINT
+// and a 2-vertex one a LINE, again as OpenSCAD writes them. Shares
+// collect2d() with writeSvg/writePdf, so a 3D model is refused the same
+// way. Coordinates are written at full round-trip precision, NOT OpenSCAD's
+// 6 significant digits: a DXF goes to a cutter, where 1234.567 written as
+// 1234.57 is a real error.
+void writeDxf(const std::string& path, const std::vector<ColoredBody>& bodies);
+
 // Options for the PDF writer, named and defaulted after OpenSCAD's own
 // `-O export-pdf/...` set.
 struct ExportPdfOptions {

openscad_cpp_evaluator-1.32.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.32.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.30.0"
+version = "1.32.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.32.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.32.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;
 }