openscad-cpp-evaluator 1.43.0__tar.gz → 1.44.0__tar.gz

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.44.0}/CLAUDE.md

@@ -211,8 +211,23 @@ Challenges and Experiences"), `roof.cpp` was rewritten from scratch as a close p
 `roof_vd.cc`'s `voronoi_diagram_roof`/`vd_inner_faces`/`discretize_arc` (CGAL/Eigen/Clipper2Lib
 swapped for `manifold::vec2` arithmetic and `manifold::Triangulate`), on top of Boost.Polygon's
 Voronoi builder (fetched as just `boostorg/polygon` + `boostorg/config`, confirmed to need nothing
-else from Boost). Both `method` values dispatch to this same construction (no CGAL-based `"straight"`
-path exists in this port). **Verified independently**, not just "it compiles": a brute-force
+else from Boost). **`method="straight"` is its own construction** (`StraightSkeletonRoof` in
+`roof.cpp`), a true straight-skeleton roof written from the literature (Aichholzer et al. 1995;
+Felkel & Obdržálek 1998's event-driven wavefront) and the reference binary's black-box output --
+no CGAL, and no OpenSCAD roof source read. It simulates the shrinking wavefront event by event
+(edge, split and vertex events; a vertex event reconnects every wavefront edge at the meeting point
+by angle), O(n^2 log n): 5000 vertices in ~0.5 s. Its input is welded first (`weldContours`: corners
+within 2^-19 of the extent snapped together or onto edges, then a Clipper2 union), because a 2D
+union often hands back pieces sharing an edge as separate outlines a hairline apart, and spikes
+are cut away (`dropSpikes`). It matches OpenSCAD 2026.02.01 (`--enable=roof`) in volume, height and
+vertex set on every shape compared that the reference does not crash on -- the reference segfaults
+on many unions of rectangles/triangles that touch along edges, so those were checked only for being
+valid 45-degree roofs (roof area = floor area x sqrt 2). Until this landed both methods built the
+Voronoi roof, wrong for any concave outline. **Warnings**: `$fs`/`$fa` clamping (via the shared
+`Discretizer::fromCtx`) and `Unknown roof method '...'` (a non-string shown as str() shows it) are
+printed BEFORE the children run, as the reference does -- `computeRoofParams` therefore runs at
+`Op::PushBuiltinWrap` time like every other wrap kind (it used to be deferred to Pop on the belief
+that the warning followed the children). **Verified independently**, not just "it compiles": a brute-force
 distance-transform grid search over a square-frame-with-a-hole test case found the same ridge height
 (≈1.756) this implementation produces — the Python reference's own SDF fallback gets this case
 measurably wrong (≈1.5, ~15% low) since it was never more than a documented approximation for
@@ -1115,9 +1130,10 @@ grep for `ponytail:`.
   `toCrossSection`; no children/generate-time-bounds dependency, so its resolve/generate split is
   the simple kind (segment count for `r=` IS resolvable early here, unlike `rotate_extrude`'s,
   since `offset`'s own radius argument is already known at resolve time).
-- `src/builtins/roof.cpp` — `roof()`, built on Boost.Polygon's segment Voronoi diagram (see the
-  `roof()` note above for the full story of why this replaced an earlier straight-skeleton
-  approximation mid-Phase-6). `voronoiRoof` scales the merged cross-section's polygons into signed
+- `src/builtins/roof.cpp` — `roof()`: the default `method="voronoi"` built on Boost.Polygon's
+  segment Voronoi diagram (see the `roof()` note above for the full story of why this replaced an
+  earlier straight-skeleton approximation mid-Phase-6), and `method="straight"`'s straight-skeleton
+  wavefront simulation (`StraightSkeletonRoof`, same note). `voronoiRoof` scales the merged cross-section's polygons into signed
   32-bit integer coordinates (`chooseScale`, headroom below 2^31 for Boost.Polygon's own internal
   robustness margin), constructs the Voronoi diagram over the resulting segments, walks it
   (`vdInnerFaces`, discretizing parabolic point-vs-segment bisector edges via `discretizeArc`) to get

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.43.0
+Version: 1.44.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT AND OFL-1.1

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -287,14 +287,13 @@ enum class Op {
     // this AFTER would silently drop uncacheable/ManifoldCache taint
     // tracking for a rands() call embedded in the wrapper's own
     // arguments), computes this site's own params for every kind except
-    // Modifier (empty, no ctx push) and Roof (deferred to Pop -- see
-    // BuiltinWrapSite's own doc comment) via that kind's own native
+    // Modifier (empty, no ctx push) via that kind's own native
     // compute function (computeTransformParams/computeColorParams/etc.,
     // builtins.hpp) -- always a possibly-$-scoped child EvalContext,
     // pushed onto f.ctxChain unconditionally for every non-Modifier kind
-    // (Roof pushes it too, params or not) -- pushes a fresh ev.treeStack_
-    // frame, and stashes {params, randsBefore, siteIdx, (Roof only)
-    // deferredArgs} onto VmFrame::builtinWrapStack (a real per-frame LIFO
+    // -- pushes a fresh ev.treeStack_
+    // frame, and stashes {params, randsBefore, siteIdx} onto
+    // VmFrame::builtinWrapStack (a real per-frame LIFO
     // stack, not a single slot: Push/PopBuiltinWrap pairs can nest or
     // sequence within one frame's own instruction stream, e.g.
     // `translate(a) translate(b) recur();`). The compiler always emits a
@@ -311,12 +310,7 @@ enum class Op {
     // VmFrame::builtinWrapStack's own top entry FIRST (before anything
     // that can itself throw, e.g. Evaluator::setTreeDepthOrThrow below --
     // so the exception-teardown path's own pending count is already
-    // correct if THIS throws); for Roof only, computes `pending.params`
-    // HERE via computeRoofParams(ev, pending.deferredArgs, ctx) -- the one
-    // kind whose params computation has an observable side effect
-    // (ev.warn()) that must stay ordered AFTER children, unlike every
-    // other kind's params (computed at Push, before children, since
-    // nothing else in this group has an order-sensitive side effect); pops
+    // correct if THIS throws); pops
     // the ctx Push made (every kind except Modifier); pops ev.treeStack_
     // to retrieve the children this bracket's own body produced, and
     // builds the tagged CSGNode exactly like Evaluator::buildTreeNode's
@@ -956,10 +950,9 @@ struct CompiledChunk {
     // rotate_extrude()/projection()/offset()/roof()) share Transform/
     // Color's exact push-time-computed-params shape, just via a different
     // native compute function each (Op::PushBuiltinWrap's own runtime
-    // handler switches on `kind` to pick it) -- see that op's own doc
-    // comment for the one exception (Roof, whose params computation has
-    // to run at POP time instead, after children, to preserve an
-    // observable warn() ordering).
+    // handler switches on `kind` to pick it). Roof's warnings ($fs/$fa
+    // clamping, unknown method) therefore come before its children's
+    // output, as in OpenSCAD 2026.02.01.
     struct BuiltinWrapSite {
         enum class Kind {
             Transform,
@@ -977,7 +970,7 @@ struct CompiledChunk {
             RotateExtrude,
             Projection,
             Offset,
-            Roof,          // computed at POP time, not PUSH -- see this struct's own doc comment
+            Roof,
         };
         Kind kind;
         std::string tagName; // "translate"/"rotate"/.../"color"/"highlight"/"background"/"show_only"/"hull"/...

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -30,15 +30,6 @@ struct PendingBuiltinWrap {
     CSGParams params;
     std::uint64_t randsBefore = 0;
     int siteIdx = -1;
-    // Only populated for BuiltinWrapSite::Kind::Roof -- the already-
-    // resolved call arguments, retained across the whole bracket so
-    // Op::PopBuiltinWrap's handler can compute roof()'s own params AFTER
-    // children finish (computeRoofParams needs them; re-running
-    // resolveCallArgs at Pop time instead would re-evaluate every argument
-    // expression a second time -- double rands()/side effects). Every
-    // other kind computes its params at Push time and leaves this default-
-    // empty.
-    CallArgs deferredArgs;
 
     // ev.measuring_ as it stood immediately BEFORE this bracket opened.
     // Recorded for EVERY kind, not just Measure, so the exception teardown

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/format_closure.hpp

@@ -3,6 +3,7 @@
 #include <string>
 
 namespace oscad {
+class ASTNode;
 class FunctionLiteral;
 }
 
@@ -16,5 +17,8 @@ namespace oscadeval {
 // precedence-minimal and which 94 places inside the parser depend on. See
 // format_closure.cpp for where each rule came from.
 std::string formatFunctionLiteral(const oscad::FunctionLiteral& fn);
+// Any expression, spelled the same way: what assert() quotes as its
+// condition ("Assertion '(a > 1)' failed").
+std::string formatExpression(const oscad::ASTNode& expr);
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.44.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.44.0}/src/builtins/builtins.hpp

@@ -246,17 +246,11 @@ CSGParams resolveOffset(Evaluator& ev, const oscad::ModularCall& node, EvalConte
 std::vector<ColoredBody> generateOffset(Evaluator& ev, const CSGParams& params,
                                          const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);
 
-// roof() -- roof.cpp. Tier 1 (exact straight skeleton, stable single-
-// contour polygons) + Tier 3 (SDF/level-set fallback) only, per the plan --
-// Tier 2 (general multi-contour/hole straight skeleton) is a named,
-// documented follow-up, not silently dropped (see CLAUDE.md).
-// computeRoofParams: UNLIKE computeLinearExtrudeParams and friends above,
-// this is the params-computation half taken from AFTER evalChildren (it
-// calls ev.warn(), an observable side effect that must stay ordered after
-// any child's own echo/warn output) -- takes already-resolved CallArgs,
-// not a raw node+ctx, since Op::PushBuiltinWrap's own runtime handler
-// calls this at POP time. See its own doc comment (roof.cpp).
-CSGParams computeRoofParams(Evaluator& ev, const CallArgs& args, EvalContext& effCtx);
+// roof() -- roof.cpp. method="voronoi" (the default) is the Voronoi-diagram
+// roof, method="straight" the straight-skeleton one.
+// computeRoofParams: the params half, from already-resolved arguments;
+// it warns ($fs/$fa clamping, unknown method), before the children run.
+CSGParams computeRoofParams(Evaluator& ev, const CallArgs& args, EvalContext& effCtx, const oscad::Position* where);
 CSGParams resolveRoof(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateRoof(Evaluator& ev, const CSGParams& params,
                                        const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.44.0}/src/builtins/extrude.cpp

@@ -27,9 +27,7 @@ namespace oscadeval {
 // side effect of its own (no warn()/echo()/rands() call), so moving it
 // before evalChildren (unlike this function's own former single-body
 // shape, which computed params AFTER children like every other builtin
-// 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.
+// still not covered by PushBuiltinWrap) is behaviorally unobservable.
 namespace {
 
 // Picks the diagonal that splits one side quad: true for A0-B1, false for