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

{openscad_cpp_evaluator-1.27.0 → openscad_cpp_evaluator-1.28.1}/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
@@ -1210,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.27.0 → openscad_cpp_evaluator-1.28.1}/PKG-INFO

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

{openscad_cpp_evaluator-1.27.0 → openscad_cpp_evaluator-1.28.1}/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.27.0 → openscad_cpp_evaluator-1.28.1}/pyproject.toml

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

{openscad_cpp_evaluator-1.27.0 → openscad_cpp_evaluator-1.28.1}/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.27.0 → openscad_cpp_evaluator-1.28.1}/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.27.0 → openscad_cpp_evaluator-1.28.1}/src/builtins/primitives_3d.cpp

@@ -102,18 +102,25 @@ std::string describeEdge(const M& mesh, std::pair<uint32_t, uint32_t> edge) {
 
 CSGParams resolveCube(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
-    Value sizeArg = getArg(args, 0, "size", Value{1.0});
+    const Value sizeArg = getArg(args, 0, "size", Value{});
     const bool center = truthy(getArg(args, 1, "center", Value{false}));
 
-    std::vector<Value> sizeVec;
+    // As OpenSCAD reads it: undef (absent or explicit) is the default of 1, a
+    // number or three numbers are the size, and anything else warns and
+    // falls back to 1. Explicit undef built a zero-size cube -- nothing --
+    // and a 2-vector or a string was converted leniently, without a word.
+    std::vector<Value> sizeVec(3, Value{1.0});
+    const ListPtr* l = std::get_if<ListPtr>(&sizeArg);
     if (const double* s = std::get_if<double>(&sizeArg)) {
         sizeVec = {Value{*s}, Value{*s}, Value{*s}};
-    } else if (const ListPtr* l = std::get_if<ListPtr>(&sizeArg); l && *l) {
-        for (size_t i = 0; i < 3; ++i) {
-            sizeVec.push_back(Value{i < (*l)->items.size() ? toDoubleLenient((*l)->items[i]) : 0.0});
-        }
-    } else {
-        sizeVec = {Value{0.0}, Value{0.0}, Value{0.0}};
+    } else if (l && *l && (*l)->items.size() == 3 &&
+               std::all_of((*l)->items.begin(), (*l)->items.end(),
+                           [](const Value& v) { return std::holds_alternative<double>(v); })) {
+        sizeVec = (*l)->items;
+    } else if (!std::holds_alternative<std::monostate>(sizeArg)) {
+        ev.warn("Unable to convert cube(size=" + fmtValue(sizeArg) +
+                    ", ...) parameter to a number or a vec3 of numbers",
+                &node.position());
     }
 
     CSGParams params;

{openscad_cpp_evaluator-1.27.0 → openscad_cpp_evaluator-1.28.1}/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.27.0 → openscad_cpp_evaluator-1.28.1}/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.27.0 → openscad_cpp_evaluator-1.28.1}/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;
 }
 

{openscad_cpp_evaluator-1.27.0 → openscad_cpp_evaluator-1.28.1}/tests/test_coverage.cpp

@@ -263,4 +263,40 @@ TEST(Coverage, IncludedAndUsedFilesCarryTheirOwnOrigin) {
     fs::remove_all(dir);
 }
 
+// A file two included files each use<> is parsed once per use; its spans
+// must still be listed once, with the hits of every copy, or its
+// percentages count the unexecuted copies as missed code.
+TEST(Coverage, AFileUsedTwiceIsListedOnce) {
+    namespace fs = std::filesystem;
+    const fs::path dir = fs::temp_directory_path() / "oscad_cov_twice";
+    fs::create_directories(dir);
+    const fs::path lib = dir / "lib.scad", a = dir / "a.scad", b = dir / "b.scad", main = dir / "main.scad";
+    std::ofstream(lib) << "function hit(x) = x;\nfunction miss(x) = x;\n";
+    std::ofstream(a) << "use <lib.scad>\nfunction fa() = hit(1);\n";
+    std::ofstream(b) << "use <lib.scad>\nfunction fb() = hit(2);\n";
+    std::ofstream(main) << "include <a.scad>\ninclude <b.scad>\necho(fa(), fb());\n";
+    auto ast = oscad::getASTFromFile(main.string());
+    ResolvedUseScopes uses = resolveUseScopes(ast, main.string(), {});
+    Evaluator ev({}, nullptr, nullptr, {}, false, /*coverage=*/true);
+    ev.setUsedFileGlobals(uses.usedFileGlobals);
+    EvalContext ctx = EvalContext::makeRoot(uses.rootScope.get());
+    ev.evaluate(uses.processedNodes, ctx, {}, false);
+    ASSERT_TRUE(ev.coverageResult.has_value());
+    std::map<int, std::vector<std::uint32_t>> libBodies;
+    for (const CoverageSpan& s : ev.coverageResult->spans) {
+        if (s.kind == CoverageKind::Body && fs::path(s.origin).filename() == "lib.scad") libBodies[s.line].push_back(s.hits);
+    }
+    ASSERT_EQ(libBodies[1].size(), 1u) << "one span per position, not one per parse";
+    EXPECT_EQ(libBodies[1][0], 2u);
+    ASSERT_EQ(libBodies[2].size(), 1u);
+    EXPECT_EQ(libBodies[2][0], 0u);
+    for (const CoverageFileSummary& f : ev.coverageResult->files) {
+        if (fs::path(f.origin).filename() == "lib.scad") {
+            EXPECT_EQ(f.bodies, 2u);
+            EXPECT_NEAR(f.body_percent(), 50.0, 1e-9);
+        }
+    }
+    fs::remove_all(dir);
+}
+
 } // namespace oscadeval

{openscad_cpp_evaluator-1.27.0 → openscad_cpp_evaluator-1.28.1}/tests/test_dxf_svg_import.cpp

@@ -1,3 +1,4 @@
+#include "openscad_cpp_evaluator/dxf_svg_import.hpp"
 #include "openscad_cpp_evaluator/evaluator.hpp"
 
 #include "test_helpers.hpp"
@@ -459,6 +460,14 @@ const char* kDimDxf =
     // two parallel LINEs, which have no crossing point
     "0\nLINE\n8\npar\n10\n0\n20\n0\n11\n10\n21\n0\n"
     "0\nLINE\n8\npar\n10\n0\n20\n5\n11\n10\n21\n5\n"
+    // an outline: two LINEs joined end to end cross mid-way, but form one path
+    "0\nLINE\n8\noutline\n10\n0\n20\n0\n11\n10\n21\n10\n"
+    "0\nLINE\n8\noutline\n10\n10\n20\n10\n11\n0\n21\n10\n"
+    "0\nLINE\n8\noutline\n10\n0\n20\n10\n11\n10\n21\n0\n"
+    // a LINE closed by an ARC (centre (0,0), r 10, 0..90 degrees): a path too
+    "0\nLINE\n8\narc\n10\n10\n20\n0\n11\n0\n21\n10\n"
+    "0\nARC\n8\narc\n10\n0\n20\n0\n40\n10\n50\n0\n51\n90\n"
+    "0\nLINE\n8\narc\n10\n0\n20\n0\n11\n10\n21\n10\n"
     "0\nENDSEC\n0\nEOF\n";
 
 double dimOf(const std::string& call, Evaluator& ev) { return std::get<double>(asExpr(call, ev)); }
@@ -535,6 +544,22 @@ TEST(DxfCross, FindsTheCrossingPoint) {
     std::filesystem::remove(path);
 }
 
+// The reference counts only 2-point paths: a LINE sharing an end with
+// another LINE or an ARC belongs to an outline and is no stroke of a cross,
+// even where two such lines do intersect. Checked against OpenSCAD
+// 2026.02.01 on example009.dxf's fan_top layer.
+TEST(DxfCross, LinesJoinedIntoAPathAreNoCross) {
+    const auto path = tempPath("dxfcross_paths.dxf");
+    writeFile(path, kDimDxf);
+    for (const char* layer : {"outline", "arc"}) {
+        std::string last;
+        Evaluator ev([&](const std::string& m) { last = m; });
+        EXPECT_TRUE(std::holds_alternative<std::monostate>(asExpr("dxf_cross(file=\"" + path.generic_string() + "\", layer=\"" + layer + "\")", ev)))
+            << layer;
+        EXPECT_NE(last.find("Can't find cross"), std::string::npos) << layer << ": " << last;
+    }
+}
+
 TEST(DxfCross, ParallelOrTooFewLinesWarns) {
     const auto path = tempPath("cross_par.dxf");
     writeFile(path, kDimDxf);
@@ -629,7 +654,8 @@ TEST(SvgFilter, AnEnclosingTransformStillApplies) {
     ASSERT_EQ(pts.size(), 4u);
     double minx = 1e9;
     for (const auto& p : pts) minx = std::min(minx, std::get<double>(std::get<ListPtr>(p)->items[0]));
-    EXPECT_NEAR(minx, 10.0, 1e-9);
+    // x = 10 on a unitless 100-unit page, which OpenSCAD reads at 72 dpi.
+    EXPECT_NEAR(minx, 10.0 * 25.4 / 72.0, 1e-9);
     std::filesystem::remove(path);
 }
 
@@ -652,3 +678,74 @@ TEST(SvgFilter, IdAndClassTogetherMatchEither) {
     EXPECT_EQ(contourCount(path.generic_string(), ", id=\"other\", class=\"cut\"", ev), 2u);
     std::filesystem::remove(path);
 }
+
+namespace oscadeval {
+namespace {
+
+// SVG placement as OpenSCAD 2026.02.01 does it: page units to mm, the
+// viewBox under preserveAspectRatio, Y flipped about the page height (or
+// about the drawing's centre with center=true). Bounds read off the
+// reference's own export for each document, with and without center.
+struct SvgPlacementCase {
+    const char* attrs;
+    const char* body;
+    bool center;
+    double bounds[4];
+};
+
+TEST(SvgPlacement, MatchesTheReference) {
+    const SvgPlacementCase cases[] = {
+        {R"(width="100" height="100" viewBox="0 0 100 100")",
+         R"(<rect x="0" y="0" width="10" height="10"/><rect x="20" y="50" width="30" height="5"/>)", false,
+         {0.0, 15.875, 17.639, 35.278}},
+        {R"(width="100" height="100" viewBox="0 0 100 100")",
+         R"(<rect x="0" y="0" width="10" height="10"/><rect x="20" y="50" width="30" height="5"/>)", true,
+         {-8.819, -9.701, 8.819, 9.701}},
+        {R"(width="50mm" height="20mm" viewBox="10 5 200 40")",
+         R"(<rect x="10" y="5" width="20" height="10"/><rect x="92" y="17" width="16" height="16"/>)", false,
+         {0.0, 5.5, 24.5, 12.5}},
+        {R"(width="4in" height="2in" viewBox="0 0 100 100" preserveAspectRatio="xMaxYMin meet")",
+         R"(<rect x="0" y="0" width="100" height="100"/>)", false, {50.8, 0.0, 101.6, 50.8}},
+        {R"(width="4in" height="2in" viewBox="0 0 100 100" preserveAspectRatio="xMaxYMin meet")",
+         R"(<rect x="0" y="0" width="100" height="100"/>)", true, {-25.4, -25.4, 25.4, 25.4}},
+        {R"(width="300px" height="150px")", R"(<rect x="10" y="10" width="30" height="20"/>)", false,
+         {10.0, 9.688, 40.0, 29.688}},
+        {R"(viewBox="0 0 200 100")", R"(<rect x="0" y="0" width="200" height="100"/>)", false,
+         {0.0, 0.0, 70.556, 35.278}},
+        {R"(viewBox="0 0 200 100")", R"(<rect x="0" y="0" width="200" height="100"/>)", true,
+         {-35.278, -17.639, 35.278, 17.639}},
+    };
+    int n = 0;
+    for (const SvgPlacementCase& c : cases) {
+        const auto path = std::filesystem::temp_directory_path() / ("svg_place_" + std::to_string(n++) + ".svg");
+        std::ofstream(path) << "<svg xmlns=\"http://www.w3.org/2000/svg\" " << c.attrs << ">" << c.body << "</svg>";
+        const std::vector<Contour2d> contours = loadSvgContours(path.string(), {}, nullptr, 72.0, c.center);
+        double lo[2] = {1e18, 1e18}, hi[2] = {-1e18, -1e18};
+        for (const Contour2d& ct : contours)
+            for (const auto& p : ct)
+                for (int a = 0; a < 2; ++a) {
+                    lo[a] = std::min(lo[a], p[a]);
+                    hi[a] = std::max(hi[a], p[a]);
+                }
+        EXPECT_NEAR(lo[0], c.bounds[0], 1e-3) << c.attrs << " center=" << c.center;
+        EXPECT_NEAR(lo[1], c.bounds[1], 1e-3) << c.attrs << " center=" << c.center;
+        EXPECT_NEAR(hi[0], c.bounds[2], 1e-3) << c.attrs << " center=" << c.center;
+        EXPECT_NEAR(hi[1], c.bounds[3], 1e-3) << c.attrs << " center=" << c.center;
+        std::filesystem::remove(path);
+    }
+}
+
+TEST(SvgPlacement, DpiScalesUnitlessLengths) {
+    const auto path = std::filesystem::temp_directory_path() / "svg_place_dpi.svg";
+    std::ofstream(path) << R"(<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100" viewBox="0 0 100 100">)"
+                        << R"(<rect x="0" y="0" width="10" height="10"/><rect x="20" y="50" width="30" height="5"/></svg>)";
+    const std::vector<Contour2d> contours = loadSvgContours(path.string(), {}, nullptr, 96.0, false);
+    double maxy = -1e18;
+    for (const Contour2d& ct : contours)
+        for (const auto& p : ct) maxy = std::max(maxy, p[1]);
+    EXPECT_NEAR(maxy, 26.458, 1e-3);
+    std::filesystem::remove(path);
+}
+
+} // namespace
+} // namespace oscadeval