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

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

@@ -984,15 +984,16 @@ grep for `ponytail:`.
   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
   (`70 & 7` — 0 rotated, 1 aligned, 2 angular, 3/4 diameter/radius, 6 ordinate; type 5 is
-  unsupported there too), `dxf_cross()` intersects the first two LINE entities. Note the reference's
+  unsupported there too), `dxf_cross()` intersects the first two 2-point paths. Note the reference's
   own coordinate quirk, reproduced here: groups 11/12/16 (and 21/22/26) are scaled but NOT
   origin-shifted, being extents rather than positions.
 
   Deliberately its own group-code walk rather than sharing `src/import/dxf_import.cpp`'s: that one
   produces closed contours, and these need the DIMENSION entities' seven coordinate slots and the
-  raw LINE endpoints, neither of which a contour list keeps. One divergence: `dxf_cross()` takes the
-  first two LINEs, where the reference walks every 2-point path — for a real cross (two strokes
-  meeting in the middle, not at their endpoints) that is the same set.
+  raw LINE endpoints, neither of which a contour list keeps. A 2-point path is a LINE sharing
+  neither end with another LINE or an ARC (an ARC's ends read from its centre, radius and 50/51
+  angles): one that does belongs to an outline. Taking the first two LINEs outright found a "cross"
+  in example009.dxf's `fan_top` outline where the reference warns `Can't find cross`.
 
 - `src/csg_generate.cpp` — `Evaluator::applyDimensionRules`, run centrally just before every node's
   `GenerateFn` (and once more over the top-level list, which is an implicit union). Mirrors the
@@ -1135,6 +1136,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
@@ -1204,9 +1211,14 @@ grep for `ponytail:`.
   path-command tokenizer/flattener (`M`/`L`/`H`/`V`/`C`/`S`/`Q`/`T`/`A`, both absolute and relative,
   cubic/quadratic Bezier flattening, full elliptical-arc endpoint-to-center parameterization) plus
   `rect`/`circle`/`ellipse`/`polygon`/`polyline` and nested `transform="matrix()/translate()/
-  scale()/rotate()"` composition (including through `<g>` groups) — Y is flipped (SVG down →
-  OpenSCAD up) at the point-transform step, `applyMat()` (named to avoid colliding with
-  `std::apply` in an ADL lookup that broke the build once — see its own comment).
+  scale()/rotate()"` composition (including through `<g>` groups), in SVG user units at the
+  point-transform step, `applyMat()` (named to avoid colliding with `std::apply` in an ADL lookup
+  that broke the build once — see its own comment). **Placement is `pageMap()`, a port of the
+  reference's `import_svg.cc`**: the page's `width`/`height` to mm (a unitless length at `dpi=`,
+  72 by default; `px` at 96), the `viewBox` scaled onto the page under `preserveAspectRatio`
+  (default `xMidYMid meet`), and Y flipped about the page HEIGHT -- or about the drawing's centre
+  with `center=true`. Negating Y alone, as this did before, put a unitless 100-unit drawing in 2.8x
+  too large and below the X axis. Bounds match OpenSCAD 2026.02.01 (`SvgPlacement` tests).
 - `include/openscad_cpp_evaluator/font_provider.hpp` — the `FontProvider` abstract interface
   (`resolveFont`/`metrics`/`shapeText`/`glyphInkBounds`/`glyphOutline`), the seam that keeps
   `text()`/`textmetrics()`/`fontmetrics()` decoupled from any specific font backend. `Evaluator`'s

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

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

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.28.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.28.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.28.0}/include/openscad_cpp_evaluator/dxf_svg_import.hpp

@@ -34,8 +34,13 @@ struct SvgFilter {
 // `matched`, when given, reports whether the filter found anything. A miss
 // imports nothing rather than falling back to the whole drawing; the caller
 // warns. Always true when no filter was set.
+// Placed as OpenSCAD places them: page units to mm (a unitless length at
+// `dpi`), the viewBox under preserveAspectRatio, Y flipped about the page
+// height -- or about the drawing's centre with `center`.
 std::vector<Contour2d> loadSvgContours(const std::string& path,
                                        const SvgFilter& filter = {},
-                                       bool* matched = nullptr);
+                                       bool* matched = nullptr,
+                                       double dpi = 72.0,
+                                       bool center = false);
 
 } // namespace oscadeval

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

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.26.0"
+version = "1.28.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.28.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.28.0}/src/builtins/dxf_dim.cpp

@@ -6,6 +6,7 @@
 #include <cmath>
 #include <filesystem>
 #include <fstream>
+#include <map>
 #include <sstream>
 
 namespace oscadeval {
@@ -26,7 +27,9 @@ struct Entity {
     std::string layer;
     std::string name;                  // group 1: DIMENSION's text override
     int dimType = 0;                   // group 70
-    double angle = 0.0;                // group 50
+    double angle = 0.0;                // group 50 (an ARC's start angle)
+    double angle2 = 0.0;               // group 51: an ARC's end angle
+    double radius = 0.0;               // group 40: an ARC's radius
     double coords[7][2] = {};          // groups 10-16 / 20-26
     std::vector<double> xverts, yverts; // groups 10/11 and 20/21, in order
 };
@@ -91,6 +94,8 @@ std::vector<Entity> readEntities(const std::string& path, double xorigin, double
             case 20:
             case 21: cur.yverts.push_back((num() - yorigin) * scale); break;
             case 50: cur.angle = num(); break;
+            case 51: cur.angle2 = num(); break;
+            case 40: cur.radius = num() * scale; break;
             case 70:
                 try {
                     cur.dimType = std::stoi(data);
@@ -188,16 +193,34 @@ Value builtinDxfCross(Evaluator& ev, const CallArgs& args, const oscad::ASTNode&
         return Value{};
     }
 
-    // The first two LINEs on the layer are taken to be the cross. The
-    // reference walks every 2-point path instead, which for a real cross is
-    // the same set: its two strokes meet in the middle rather than at their
-    // endpoints, so neither gets joined into a longer path.
+    // The first two 2-POINT PATHS on the layer are the cross, as the
+    // reference walks them: a LINE sharing an end with another LINE or an
+    // ARC is joined into a longer path, part of an outline, and no stroke of
+    // a cross. Taking the first two LINEs outright found a "cross" in any
+    // outline -- example009.dxf's fan_top, where the reference finds none.
+    // ponytail: LINE and ARC ends only; polylines and splines don't
+    // disqualify a LINE here.
+    const std::vector<Entity> entities = readEntities(c.path, c.xorigin, c.yorigin, c.scale);
+    std::map<std::pair<long long, long long>, int> ends;
+    const auto endKey = [](double x, double y) { return std::make_pair(std::llround(x * 1e6), std::llround(y * 1e6)); };
+    for (const Entity& e : entities) {
+        if (!c.layer.empty() && c.layer != e.layer) continue;
+        if (e.type == "LINE" && e.xverts.size() >= 2 && e.yverts.size() >= 2) {
+            ++ends[endKey(e.xverts[0], e.yverts[0])];
+            ++ends[endKey(e.xverts[1], e.yverts[1])];
+        } else if (e.type == "ARC") {
+            for (double a : {e.angle, e.angle2}) {
+                ++ends[endKey(e.coords[0][0] + e.radius * std::cos(rad(a)), e.coords[0][1] + e.radius * std::sin(rad(a)))];
+            }
+        }
+    }
     double p[4][2];
     int found = 0;
-    for (const Entity& e : readEntities(c.path, c.xorigin, c.yorigin, c.scale)) {
+    for (const Entity& e : entities) {
         if (e.type != "LINE") continue;
         if (!c.layer.empty() && c.layer != e.layer) continue;
         if (e.xverts.size() < 2 || e.yverts.size() < 2) continue;
+        if (ends[endKey(e.xverts[0], e.yverts[0])] > 1 || ends[endKey(e.xverts[1], e.yverts[1])] > 1) continue;
         p[found][0] = e.xverts[0];
         p[found][1] = e.yverts[0];
         ++found;

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.28.0}/src/builtins/import.cpp

@@ -199,8 +199,18 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
     const std::string path = resolveFilePath(fileArg, node);
     const std::string ext = lowerExt(path);
 
+    if (!std::filesystem::exists(path)) {
+        // A missing file warns and imports nothing, as in OpenSCAD; it
+        // aborted the whole render. Warned at generate, where OpenSCAD does,
+        // so it follows the script's echoes.
+        params["kind"] = Value{std::string("missing")};
+        params["path"] = Value{path};
+        params["dxf"] = Value{ext == ".dxf"};
+        return params;
+    }
     if (ext == ".dxf" || ext == ".svg" || ext == ".pdf") {
         std::vector<Contour2d> contours;
+        bool filteredMiss = false;
         try {
             if (ext == ".dxf") {
                 std::optional<std::string> layer;
@@ -211,7 +221,10 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
                 if (const std::string* v = std::get_if<std::string>(&idArg)) filter.id = *v;
                 if (const std::string* v = std::get_if<std::string>(&classArg)) filter.cls = *v;
                 bool matched = true;
-                contours = loadSvgContours(path, filter, &matched);
+                const Value dpiArg = getArg(args, std::nullopt, "dpi", Value{72.0});
+                contours = loadSvgContours(path, filter, &matched,
+                                           std::holds_alternative<double>(dpiArg) ? std::get<double>(dpiArg) : 72.0,
+                                           truthy(getArg(args, std::nullopt, "center", Value{false})));
                 if (!matched) {
                     // Nothing imported, rather than silently falling back to
                     // the whole drawing -- a cut layer that quietly became
@@ -222,14 +235,15 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
                         if (!what.empty()) what += ", ";
                         what += "class = \"" + *filter.cls + "\"";
                     }
-                    ev.warn("import() filter " + what + " did not match anything in "
-                            + path, &node.position());
+                    // OpenSCAD's words, which name no file.
+                    ev.warn("import() filter " + what + " did not match anything", &node.position());
+                    filteredMiss = true;
                 }
             }
         } catch (const std::exception& e) {
             ev.error(std::string("import: ") + e.what(), node);
         }
-        if (contours.empty()) {
+        if (contours.empty() && !filteredMiss) {
             ev.error(ext == ".dxf" ? "import: no closed contours found in DXF file" : "import: no shapes found in SVG file", node);
         }
         params["kind"] = Value{std::string("region")};
@@ -276,6 +290,16 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
     const auto kindIt = params.find("kind");
     if (kindIt == params.end()) return {};
     const std::string& kind = std::get<std::string>(kindIt->second);
+    if (kind == "missing") {
+        // OpenSCAD's own wording, which names a line rather than a file.
+        const std::string& path = std::get<std::string>(params.at("path"));
+        ev.warn(std::get<bool>(params.at("dxf"))
+                    ? "Can't open DXF file '" + path + "'."
+                    : "Can't open import file '" + path + "', import() at line " +
+                          std::to_string(node.position().line),
+                nullptr);
+        return {};
+    }
     if (kind == "region") {
         const std::vector<Contour2d> contours = valueToContours(params.at("contours"));
         manifold::Polygons polys;
@@ -397,6 +421,10 @@ Value importAsValue(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& n
     }
     const std::string path = resolveFilePath(fileArg, node);
     const std::string ext = lowerExt(path);
+    if (!std::filesystem::exists(path)) {
+        ev.warn("Could not read file '" + path + "'", &node.position());
+        return Value{};
+    }
 
     try {
         if (ext == ".json") return loadJsonAsValue(path);
@@ -412,7 +440,10 @@ Value importAsValue(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& n
                 if (const std::string* v = std::get_if<std::string>(&idArg)) filter.id = *v;
                 if (const std::string* v = std::get_if<std::string>(&classArg)) filter.cls = *v;
                 bool matched = true;
-                contours = loadSvgContours(path, filter, &matched);
+                const Value dpiArg = getArg(args, std::nullopt, "dpi", Value{72.0});
+                contours = loadSvgContours(path, filter, &matched,
+                                           std::holds_alternative<double>(dpiArg) ? std::get<double>(dpiArg) : 72.0,
+                                           truthy(getArg(args, std::nullopt, "center", Value{false})));
                 if (!matched) {
                     // Nothing imported, rather than silently falling back to
                     // the whole drawing -- a cut layer that quietly became
@@ -423,8 +454,7 @@ Value importAsValue(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& n
                         if (!what.empty()) what += ", ";
                         what += "class = \"" + *filter.cls + "\"";
                     }
-                    ev.warn("import() filter " + what + " did not match anything in "
-                            + path, &node.position());
+                    ev.warn("import() filter " + what + " did not match anything", &node.position());
                 }
             }
             return contoursToValue(contours);

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.28.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.28.0}/src/coverage.cpp

@@ -7,6 +7,7 @@
 
 #include <algorithm>
 #include <map>
+#include <tuple>
 #include <unordered_set>
 
 namespace oscadeval {
@@ -354,8 +355,22 @@ CoverageResult buildCoverageResult(const std::vector<const ASTNode*>& roots,
                                    const std::vector<const ASTNode*>& extraStatements,
                                    const CoverageRecorder& recorder) {
     CoverageResult result;
+    // One span per source position. A file several files use<> is parsed
+    // once per use, so its nodes arrive once per parse -- BOSL2's
+    // builtins.scad three times, two of them with zero hits -- which
+    // counted its spans three times over and pulled its percentages down.
+    // Merged here, hits summed: each copy's executions are real ones.
+    std::map<std::tuple<std::string, int, int, CoverageKind>, size_t> index;
     for (const Coverable& c : collectCoverable(roots, extraStatements)) {
         const oscad::Position& p = c.node->position();
+        const auto key = std::make_tuple(p.origin, p.start_offset, p.end_offset, c.kind);
+        const auto [it, fresh] = index.emplace(key, result.spans.size());
+        if (!fresh) {
+            CoverageSpan& s = result.spans[it->second];
+            s.hits += recorder.hitsFor(*c.node);
+            s.arm = s.arm || c.arm;
+            continue;
+        }
         result.spans.push_back(CoverageSpan{p.origin, p.line, p.column, p.start_offset, p.end_offset, c.kind, c.arm,
                                             recorder.hitsFor(*c.node)});
     }

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.28.0}/src/export.cpp

@@ -663,7 +663,11 @@ void writePly(const std::string& path, const std::vector<ExportObject>& objects)
                     colors.push_back(rgb(o.triColors[t], 0));
                     colors.push_back(rgb(o.triColors[t], 1));
                     colors.push_back(rgb(o.triColors[t], 2));
-                    faces.push_back(static_cast<int32_t>(faces.size()) + base);
+                    // The vertex just pushed. Not faces.size() + base: faces
+                    // already holds every earlier object's entries, so that
+                    // counted `base` twice and pointed past the vertex list
+                    // on any object after the first.
+                    faces.push_back(static_cast<int32_t>(verts.size() / 3) - 1);
                 }
             }
         }

{openscad_cpp_evaluator-1.26.0 → openscad_cpp_evaluator-1.28.0}/src/import/svg_import.cpp

@@ -5,6 +5,7 @@
 #include <cmath>
 #include <cstring>
 #include <fstream>
+#include <optional>
 #include <sstream>
 #include <stdexcept>
 
@@ -194,7 +195,7 @@ Mat3 compose(const Mat3& m, const Mat3& acc) {
 std::array<double, 2> applyMat(const std::array<double, 2>& pt, const Mat3& m) {
     const double x = m.a * pt[0] + m.c * pt[1] + m.e;
     const double y = m.b * pt[0] + m.d * pt[1] + m.f;
-    return {x, -y}; // flip Y: SVG down -> OpenSCAD up
+    return {x, y}; // SVG user units; pageMap places them on the page
 }
 
 std::vector<double> parseNumberList(const std::string& s) {
@@ -489,11 +490,109 @@ void walkFiltered(const XmlNode& el, const Mat3& mat, const SvgFilter& f,
     for (const XmlNode& child : el.children) walkFiltered(child, m, f, out, matched);
 }
 
+// "12", "12.5mm", "3in" -> (number, unit); unit empty when unitless.
+// nullopt for anything else, which OpenSCAD treats as absent.
+std::optional<std::pair<double, std::string>> parseLength(const std::string& text) {
+    const size_t b = text.find_first_not_of(" \t\r\n");
+    if (b == std::string::npos) return std::nullopt;
+    const size_t e = text.find_last_not_of(" \t\r\n");
+    const std::string t = text.substr(b, e - b + 1);
+    size_t used = 0;
+    double n = 0.0;
+    try {
+        n = std::stod(t, &used);
+    } catch (...) {
+        return std::nullopt;
+    }
+    std::string unit = t.substr(used);
+    unit.erase(0, unit.find_first_not_of(" \t"));
+    static const char* known[] = {"", "em", "ex", "px", "in", "cm", "mm", "pt", "pc", "%"};
+    for (const char* k : known) {
+        if (unit == k) return std::make_pair(n, unit);
+    }
+    return std::nullopt;
+}
+
+// Place SVG user-unit contours as OpenSCAD's import_svg.cc does: the page's
+// width/height to millimetres (a unitless length at `dpi`, px at 96), the
+// viewBox scaled onto it under preserveAspectRatio (default xMidYMid meet),
+// and Y flipped about the page height -- or, with center, about the
+// drawing's own centre. Without this a unitless 100-unit drawing came in
+// 2.8x too large and below the X axis.
+void pageMap(const XmlNode& root, double dpi, bool center, std::vector<Contour2d>& contours) {
+    std::vector<double> vb;
+    {
+        std::string v = root.getAttr("viewBox");
+        std::replace(v.begin(), v.end(), ',', ' ');
+        std::istringstream in(v);
+        double x = 0.0;
+        while (in >> x) vb.push_back(x);
+    }
+    const bool valid = vb.size() == 4 && vb[2] >= 0.0 && vb[3] >= 0.0;
+    const auto toMm = [&](const char* attr, double viewbox) {
+        const auto len = parseLength(root.getAttr(attr));
+        if (!len) return valid ? 25.4 * viewbox / dpi : 0.0;  // absent: rely on dpi, as old Illustrator files do
+        const auto& [n, u] = *len;
+        if (u.empty()) return 25.4 * n / dpi;
+        if (u == "px") return 25.4 * n / 96.0;
+        if (u == "pt") return 25.4 * n / 72.0;
+        if (u == "pc") return 25.4 * n / 6.0;
+        if (u == "in") return 25.4 * n;
+        if (u == "cm") return 10.0 * n;
+        if (u == "mm") return n;
+        if (u == "%") return valid ? 25.4 * n / 100.0 * viewbox / dpi : 0.0;
+        return valid ? viewbox : 0.0;  // em, ex
+    };
+    const double widthMm = toMm("width", valid ? vb[2] : 0.0);
+    const double heightMm = toMm("height", valid ? vb[3] : 0.0);
+    double sx = 1.0, sy = 1.0, vbx = 0.0, vby = 0.0, ax = 0.0, ay = 0.0;
+    if (valid) {
+        const auto w = parseLength(root.getAttr("width")), h = parseLength(root.getAttr("height"));
+        vbx = vb[0] * (w && w->second == "%" ? w->first / 100.0 : 1.0);
+        vby = vb[1] * (h && h->second == "%" ? h->first / 100.0 : 1.0);
+        sx = vb[2] != 0.0 ? widthMm / vb[2] : 0.0;
+        sy = vb[3] != 0.0 ? heightMm / vb[3] : 0.0;
+        std::istringstream par(root.getAttr("preserveAspectRatio"));
+        std::string align, meet;
+        par >> align;
+        if (align == "defer") par >> align;
+        par >> meet;
+        if (align.empty()) align = "xMidYMid";
+        if (align != "none") {
+            const double scaling = meet == "slice" ? std::max(sx, sy) : std::min(sx, sy);
+            sx = sy = scaling;
+            const auto frac = [](const std::string& a) { return a == "Min" ? 0.0 : a == "Max" ? 1.0 : 0.5; };
+            const bool wellFormed = align.size() == 8 && align[0] == 'x' && align[4] == 'Y';
+            const double fx = wellFormed ? frac(align.substr(1, 3)) : 0.5;
+            const double fy = wellFormed ? frac(align.substr(5, 3)) : 0.5;
+            ax = fx * (widthMm - sx * vb[2]);
+            ay = fy * (heightMm - sy * vb[3]);
+        }
+    }
+    double cx = -ax, cy = heightMm - ay;
+    if (center) {
+        double lo[2] = {INFINITY, INFINITY}, hi[2] = {-INFINITY, -INFINITY};
+        for (const Contour2d& c : contours)
+            for (const auto& p : c) {
+                lo[0] = std::min(lo[0], sx * p[0]);
+                hi[0] = std::max(hi[0], sx * p[0]);
+                lo[1] = std::min(lo[1], sy * p[1]);
+                hi[1] = std::max(hi[1], sy * p[1]);
+            }
+        cx = std::isfinite(lo[0]) ? (lo[0] + hi[0]) / 2.0 : 0.0;
+        cy = std::isfinite(lo[1]) ? (lo[1] + hi[1]) / 2.0 : 0.0;
+    }
+    // -vby - y, not y - vby: OpenSCAD's own formula, kept for parity.
+    for (Contour2d& c : contours)
+        for (auto& p : c) p = {sx * (p[0] - vbx) - cx, sy * (-vby - p[1]) + cy};
+}
+
 } // namespace
 
 std::vector<Contour2d> loadSvgContours(const std::string& path,
                                       const SvgFilter& filter,
-                                      bool* matched) {
+                                      bool* matched, double dpi, bool center) {
+    if (!(dpi > 0.0)) dpi = 72.0;
     std::ifstream in(path);
     if (!in) throw std::runtime_error("could not open '" + path + "'");
     std::stringstream buf;
@@ -505,6 +604,7 @@ std::vector<Contour2d> loadSvgContours(const std::string& path,
     if (!filter.id && !filter.cls) {
         if (matched) *matched = true;   // no filter, nothing to miss
         walk(*root, Mat3{}, out);
+        pageMap(*root, dpi, center, out);
         return out;
     }
     bool hit = false;
@@ -513,6 +613,7 @@ std::vector<Contour2d> loadSvgContours(const std::string& path,
     // back to the whole drawing, which would be the silent-wrong-geometry
     // answer. The caller turns this into the warning.
     if (matched) *matched = hit;
+    pageMap(*root, dpi, center, out);
     return out;
 }