openscad-cpp-evaluator 1.26.0__tar.gz → 1.27.0__tar.gz

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.27.0}/CLAUDE.md

@@ -1135,6 +1135,12 @@ grep for `ponytail:`.
   `writeSvg`, which needs the sections that step throws away, and which says so rather than writing
   the slab's outline. `tools/cli/cli_lib.cpp` is the only current caller; a future GUI/renderer
   caller needs the same call before passing results to its own mesh consumer.
+  **The slab height is a parameter** (`flatHeight`, default `kTopLevel2dHeight` = 1.0, the
+  reference's measured preview height that docs images and `--viewall` framing depend on). Python
+  reaches it as `Evaluator(flat_preview_height=...)`, which thins only the DISPLAYED bodies:
+  `evaluate()` converts the raw list a second time at 1.0 for `geometry`, because a 2D-only script
+  exports its slab and that must not become whatever a viewer found easiest to look at. BelfrySCAD's
+  viewport asks for 0.01 so a 2D shape reads as the flat contour it is.
 - `include/openscad_cpp_evaluator/function_builtins.hpp`, `src/builtins/function_builtins.cpp` —
   the math/string/list/type-check builtin *function* dispatch (`isBuiltinFunctionName`/
   `evalBuiltinFunction`), a completely separate namespace/table from `dispatch.hpp`'s builtin

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.27.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.27.0}/bindings/module.cpp

@@ -505,10 +505,15 @@ nb::object coverageResultToPy(const std::optional<oscadeval::CoverageResult>& cr
 
 nb::object evaluate(const std::string& path, nb::dict viewportParams,
                      std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, bool profile,
-                     bool generate, bool strictCommas, bool coverage, bool keepMinuendColor) {
+                     bool generate, bool strictCommas, bool coverage, bool keepMinuendColor,
+                     double flatPreviewHeight) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
+    // What export gets. The same list as `bodies` unless the caller asked
+    // for a thinner preview slab: a 2D-only script exports its slab, and
+    // that must stay the reference's 1 unit whatever the viewer shows.
+    std::vector<oscadeval::ColoredBody> exportBodies;
     std::vector<std::string> echoes;
     std::vector<IdSpan> idSpans;
     std::vector<std::unique_ptr<oscadeval::CSGNode>> csgTree;
@@ -532,7 +537,10 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
             ev.keepMinuendColor = keepMinuendColor;
             ev.setUsedFileGlobals(used.usedFileGlobals);
             oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
-            bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp, generate));
+            std::vector<oscadeval::ColoredBody> raw = ev.evaluate(used.processedNodes, ctx, vp, generate);
+            bodies = oscadeval::toRenderableBodies(raw, flatPreviewHeight);
+            exportBodies = flatPreviewHeight == oscadeval::kTopLevel2dHeight
+                               ? bodies : oscadeval::toRenderableBodies(raw);
             collectIdSpans(ev, idSpans);
             // Only moved out when it will actually be converted below --
             // csgTreeToPy() walks the whole tree building Python objects,
@@ -567,8 +575,8 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
     nb::list echoList;
     for (const std::string& s : echoes) echoList.append(s);
     auto geom = std::make_shared<Geometry>();
-    geom->bodies = std::move(bodies);
-    return nb::make_tuple(bodiesToList(geom->bodies), echoList, idSpansToDict(idSpans), csgTreeToPy(csgTree),
+    geom->bodies = std::move(exportBodies);
+    return nb::make_tuple(bodiesToList(bodies), echoList, idSpansToDict(idSpans), csgTreeToPy(csgTree),
                            profileResultToPy(profileResult), dyn, dynExplicit, geom, coverageResultToPy(coverageResult));
 }
 
@@ -780,7 +788,7 @@ void callPyReturnHook(nb::handle returnHook, const std::string& name, const osca
 nb::object debugEvaluate(const std::string& path, nb::dict viewportParams, nb::callable debugHook,
                           nb::callable errorBreak, nb::callable echoFn,
                           std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, nb::object returnHook,
-                          FastContinueSignal* fastContinueSignal) {
+                          FastContinueSignal* fastContinueSignal, double flatPreviewHeight) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
@@ -841,7 +849,7 @@ nb::object debugEvaluate(const std::string& path, nb::dict viewportParams, nb::c
             if (fastContinueSignal) ev.setFastContinueInterruptFlag(fastContinueSignal->flag());
             ev.setUsedFileGlobals(used.usedFileGlobals);
             oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
-            bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp));
+            bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp), flatPreviewHeight);
             collectIdSpans(ev, idSpans);
             {
                 nb::gil_scoped_acquire g;
@@ -985,6 +993,7 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
     m.def("evaluate", &evaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("manifold_cache") = nullptr,
           nb::arg("profile") = false, nb::arg("generate") = true, nb::arg("strict_commas") = false,
           nb::arg("coverage") = false, nb::arg("keep_minuend_color") = false,
+          nb::arg("flat_preview_height") = oscadeval::kTopLevel2dHeight,
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit, "
           "geometry, coverage_result).\n"
           "coverage=True records which statements, branch arms and bodies ran: coverage_result is a dict "
@@ -1024,5 +1033,6 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
     m.def("debug_evaluate", &debugEvaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("debug_hook"),
           nb::arg("error_break"), nb::arg("echo_fn"), nb::arg("manifold_cache") = nullptr,
           nb::arg("return_hook") = nb::none(), nb::arg("fast_continue_signal") = nullptr,
+          nb::arg("flat_preview_height") = oscadeval::kTopLevel2dHeight,
           "Evaluate with the debugger wired in; returns (bodies, [], id_to_node, dyn, dyn_explicit). Callbacks fire under the GIL.");
 }

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.27.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -169,6 +169,13 @@ std::optional<std::array<float, 4>> valueToColor(const Value& v);
 // (the CLI, any other mesh-export caller) should apply this to
 // Evaluator::evaluate()'s result before exporting, the same way the
 // reference's own cli.py does right before export_bodies().
-std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies);
+// The thickness toRenderableBodies() gives a top-level 2D shape's slab by
+// default: OpenSCAD's own preview height, measured (see colored_body.cpp).
+// Docs images and exports use it; an interactive viewer may pass a thinner
+// one so a 2D shape reads as the flat contour it is.
+inline constexpr double kTopLevel2dHeight = 1.0;
+
+std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies,
+                                            double flatHeight = kTopLevel2dHeight);
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.27.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.27.0}/python/openscad_cpp_evaluator/__init__.py

@@ -565,7 +565,7 @@ class Evaluator:
 
     def __init__(self, echo_fn=None, debug_hook=None, error_break_fn=None, return_hook=None,
                  manifold_cache=None, profile=False, fast_continue_signal=None, coverage=False,
-                 keep_minuend_color=False):
+                 keep_minuend_color=False, flat_preview_height=1.0):
         self._echo_fn = echo_fn
         self._debug_hook = debug_hook
         self._error_break_fn = error_break_fn
@@ -579,6 +579,12 @@ class Evaluator:
         # subtrahend's (or the cut green). A viewer option; see
         # Evaluator::keepMinuendColor in evaluator.hpp.
         self._keep_minuend_color = keep_minuend_color
+        # How thick a top-level 2D shape's preview slab is in the returned
+        # bodies. 1.0 is OpenSCAD's preview height, which docs images and
+        # --viewall framing depend on; a viewer can pass something thin so
+        # a 2D shape reads as a flat contour. Export (`geometry`) always
+        # keeps 1.0: a 2D-only script exports its slab.
+        self._flat_preview_height = float(flat_preview_height)
         self.csg_tree = []
         self.profile_result = None
         # coverage=True: after evaluate(), {"spans": [...], "files": [...],
@@ -621,7 +627,8 @@ class Evaluator:
                     source_path, vp, self._debug_hook,
                     self._error_break_fn or (lambda *a, **k: None),
                     self._echo_fn or (lambda _m: None),
-                    self._manifold_cache, self._return_hook, self._fast_continue_signal)
+                    self._manifold_cache, self._return_hook, self._fast_continue_signal,
+                    self._flat_preview_height)
                 self.csg_tree = []
                 self.profile_result = None
                 # The debugger path has no geometry handle: debug_evaluate
@@ -632,7 +639,8 @@ class Evaluator:
                 (body_dicts, echoes, id_spans, csg_tree, profile_result, dyn,
                  dyn_explicit, geometry, coverage_result) = _ext.evaluate(
                     source_path, vp, self._manifold_cache, self._profile, generate,
-                    strict_commas, self._coverage, self._keep_minuend_color)
+                    strict_commas, self._coverage, self._keep_minuend_color,
+                    self._flat_preview_height)
                 # The evaluated bodies, still on the C++ side. Stashed like
                 # csg_tree/profile_result rather than returned, so
                 # evaluate()'s own 2-tuple result is unchanged -- callers

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.27.0}/src/colored_body.cpp

@@ -20,23 +20,21 @@ std::optional<std::array<float, 4>> valueToColor(const Value& v) {
     return c;
 }
 
-namespace {
-// The reference extrudes a 2D shape to exactly 1 unit for preview -- measured
+// kTopLevel2dHeight (colored_body.hpp), the default slab height: the
+// reference extrudes a 2D shape to exactly 1 unit for preview -- measured
 // against OpenSCAD at three camera tilts (60/70/80 degrees), which put it at
 // 0.92/1.00/0.99, the 60 being pixel-rounding on the shallowest angle. Ours
 // was 1e-3, which reads as a flat silhouette with no visible edge and, more
 // annoyingly, gives --viewall a different bounding box to fit, so every 2D
 // docs image came out at a different scale from the published one.
-constexpr double kTopLevel2dHeight = 1.0;
-} // namespace
 
-std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies) {
+std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies, double flatHeight) {
     std::vector<ColoredBody> out;
     out.reserve(bodies.size());
     for (const ColoredBody& cb : bodies) {
         if (!cb.body && cb.section) {
             ColoredBody flat;
-            flat.body = manifold::Manifold::Extrude(cb.section->ToPolygons(), kTopLevel2dHeight);
+            flat.body = manifold::Manifold::Extrude(cb.section->ToPolygons(), flatHeight);
             if (cb.sectionId && !flat.body->IsEmpty()) {
                 // One run carrying the section's own ID, so a click on the
                 // slab finds the node that built the shape (see

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.27.0}/tests/test_python_bindings.py

@@ -1096,3 +1096,28 @@ def test_a_cached_2d_shape_is_picked_as_a_solid_would_be(tmp_path):
     assert all(t is not None for render in flat for body in render for t in body)
     assert flat[1] == [["square(3);"], ["translate([10, 0]) circle(4);"]]
     assert solid[1] == [["cube(3);"], ["translate([10, 0, 0]) sphere(4);"]]
+
+
+def test_a_viewer_can_ask_for_a_thin_2d_slab_and_export_keeps_1(tmp_path):
+    """flat_preview_height thins the DISPLAYED slab only: a 2D-only script
+    exports that slab, and it has to stay the reference's 1 unit."""
+    import openscad_cpp_evaluator as E
+    script = tmp_path / "flat.scad"
+    script.write_text("square(10);\n")
+
+    def z_extent(bodies):
+        verts = bodies[0].body.to_mesh().vert_properties
+        return float(verts[:, 2].max() - verts[:, 2].min())
+
+    default = E.Evaluator()
+    assert abs(z_extent(default.evaluate(str(script), {})[0]) - 1.0) < 1e-9
+    thin = E.Evaluator(flat_preview_height=0.01)
+    bodies, id_to_node = thin.evaluate(str(script), {})
+    assert abs(z_extent(bodies) - 0.01) < 1e-9
+    assert id_to_node, "still pickable"
+    out = tmp_path / "flat.off"            # ASCII: header, counts, vertices
+    E.export_model(str(out), thin.geometry)
+    lines = [l for l in out.read_text().splitlines() if l.strip() and not l.startswith("#")]
+    nverts = int(lines[1].split()[0])
+    zs = [float(l.split()[2]) for l in lines[2:2 + nverts]]
+    assert abs(max(zs) - min(zs) - 1.0) < 1e-6, "export is the 1-unit slab"