openscad-cpp-evaluator 0.32.2__tar.gz → 0.34.0__tar.gz

{openscad_cpp_evaluator-0.32.2 → openscad_cpp_evaluator-0.34.0}/CLAUDE.md

@@ -512,6 +512,9 @@ grep for `ponytail:`.
   `Evaluator::evaluate()` also takes an optional `viewportParams` map (added after a test-suite
   parity review found it missing entirely): seeds arbitrary `$`-prefixed entries into `ctx.dyn`
   (e.g. `$vpt`/`$vpr`/`$vpd`/`$vpf` from a GUI host's current camera, or `$t` for animation time)
+  — note `EvalContext::makeRoot` also seeds `$preview` to **`false`**, always: there is no preview
+  mode here, and leaving it undef made the common `$preview ? cheap : real` idiom take the cheap
+  branch by accident while warning about an unknown variable
   before evaluation starts, via a direct `ctx.dyn` write that deliberately never touches
   `ctx.dynExplicit` — lets a caller tell "the script itself assigned this `$`-var"
   (`dynExplicit`) apart from "merely present because the caller seeded it" after `evaluate()`
@@ -558,13 +561,49 @@ grep for `ponytail:`.
   color instead of preserving each part's own, matching real OpenSCAD's actual behavior once fixed
   (cross-checked triangle-color-count-and-values against the Python reference directly, not just
   “does it run”).
-- `src/builtins/topology.cpp` — `hull()`/`minkowski()`. Both splice their children transparently in
+- `src/builtins/dxf_dim.cpp` — `dxf_dim()`/`dxf_cross()`, which read a measurement out of a DXF file
+  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
+  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.
+
+- `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
+  reference's `isValidDim` + `collectChildren2D`/`collectChildren3D`: a node's dimension is fixed by
+  its first non-background, non-empty child, and every child of the other dimension is dropped with
+  `Mixing 2D and 3D objects is not supported` followed by `Ignoring {N}D child object for {M}D
+  operation`. `linear_extrude`/`rotate_extrude`/`offset` are always-2D and `projection` always-3D, so
+  they skip the "mixing" line and emit only the second; `roof()` emits neither, matching the
+  reference. Background (`%`) children are exempt.
+
+  Doing this centrally is also what keeps `generateCsg` safe: it builds ONE result and switches on
+  whether it holds a `body` or a `section`, so a group that changed dimension part-way dereferenced
+  the empty optional -- `union() { cube(1); square(4); }` took the process down with "mutex lock
+  failed: Invalid argument". Filtering before dispatch means no `GenerateFn` ever sees a mixed group.
+  All 25 module/shape combinations were diffed against OpenSCAD 2026.02.01 warning for warning, with
+  the surviving geometry compared by STL volume.
+
+- `src/builtins/topology.cpp` — `hull()`/`minkowski()`/`fill()`. All three splice their children transparently in
   the CSG tree exactly like union/difference/intersection (resolve just evaluates them for the
   side effect); `hull()` picks an all-3D (`Manifold::Hull`) or all-2D (`CrossSection::Hull`) hull of
   the *foreground* (role-split) children, falling back to sections only when no child has a body;
   `minkowski()` only ever operates on 3D bodies (a 2D sibling among the foreground children is
   silently ignored, matching the reference exactly — no 2D `minkowski_sum` fallback the way hull
-  has one). Both pass background/highlight/show_only bodies through untouched.
+  has one). All pass background/highlight/show_only bodies through untouched. `fill()` is 2D-only
+  (a 3D foreground child draws the reference's own `fill() not yet implemented for 3D` warning and
+  contributes nothing): it unions the foreground sections, keeps only the outlines with positive
+  signed area — outer boundaries, since Manifold winds a hole clockwise — and re-unions those,
+  which matters because two outers can overlap once the holes between them are gone. Ported from
+  the reference's `applyFill2D`, and checked shape-for-shape against OpenSCAD 2026.02.01 by
+  extruding and comparing STL volumes.
 - `src/builtins/extrude.cpp` — `linear_extrude()`/`rotate_extrude()`/`projection(cut=)`. All three
   union every 2D child into one `CrossSection` via `toCrossSection` first. `rotate_extrude`'s
   segment count can't be resolved until generate time (it depends on the merged children's bounds,

{openscad_cpp_evaluator-0.32.2 → openscad_cpp_evaluator-0.34.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.32.2 → openscad_cpp_evaluator-0.34.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -330,6 +330,12 @@ public:
     // free function, same reasoning as tagGenerated()/builtinChildren().
     void warn(const std::string& message, const oscad::Position* position);
 
+    // Applies OpenSCAD's mixed-2D/3D rules to a node's children just
+    // before its GenerateFn runs -- see csg_generate.cpp.
+    void applyDimensionRules(CSGNode& node);
+    // ruleValue is a DimRule; the enum is file-local to csg_generate.cpp.
+    void applyDimensionRulesTo(const std::vector<CSGNode*>& children, int ruleValue);
+
     // Apply `!`: replace the whole tree with the first show_only
     // subtree, discarding its ancestors and every sibling. See its
     // definition for why this cannot be done by tagging bodies.

{openscad_cpp_evaluator-0.32.2 → openscad_cpp_evaluator-0.34.0}/include/openscad_cpp_evaluator/value.hpp

@@ -147,6 +147,12 @@ bool oscComparable(const Value& a, const Value& b);
 Value scale(double scalarValue, const Value& value);
 Value divScale(const Value& value, double divisor);
 
+// `number / vector`, the mirror of divScale's `vector / number` -- the
+// reference divides the scalar by each element in turn (Value.cc's
+// `operator/` NUMBER/VECTOR branch, `*this / vecval`), recursing into
+// nested lists the same way. `5 / [1, 2]` is `[5, 2.5]`, not undef.
+Value divInto(double numerator, const Value& value);
+
 // Elementwise `+`/`-` between two lists (zip semantics: truncates to the
 // shorter length when lengths differ), or the scalar/mismatched-type
 // fallback (numeric + numeric, everything else -> undef). `vecAdd` rejects
@@ -167,7 +173,14 @@ Value vecSub(const Value& a, const Value& b);
 // a Python bool silently). This divergence is undocumented/untested
 // behavior in the reference implementation -- revisit only if a real
 // script's `*` on a bool-containing vector is shown to need it.
-Value matmul(const Value& a, const Value& b);
+//
+// `error`, when non-null, receives the reference's own diagnostic text for
+// whichever undefined case was hit (multiply_visitor / multvecvec /
+// multmatvec / multvecmat in the reference's Value.cc) -- "vector*vector
+// requires matching lengths (2 != 3)", "Matrix must be rectangular. Problem
+// at row 1", and so on. applyBinaryOp warns with it; a caller that only
+// wants the value can leave it null. It is only written on an undef result.
+Value matmul(const Value& a, const Value& b, std::string* error = nullptr);
 
 // OpenSCAD's echo()/str() number formatting: at most 6 significant digits,
 // fixed-point for exponents in [-5, 5], scientific notation with no leading

{openscad_cpp_evaluator-0.32.2 → openscad_cpp_evaluator-0.34.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.32.2 → openscad_cpp_evaluator-0.34.0}/src/CMakeLists.txt

@@ -29,6 +29,7 @@ add_library(openscad_cpp_evaluator STATIC
   builtins/call_args.cpp
   builtins/segments.cpp
   builtins/registry.cpp
+  builtins/dxf_dim.cpp
   builtins/primitives_2d.cpp
   builtins/primitives_3d.cpp
   builtins/transforms.cpp

{openscad_cpp_evaluator-0.32.2 → openscad_cpp_evaluator-0.34.0}/src/builtins/builtins.hpp

@@ -160,6 +160,15 @@ CSGParams resolveHull(Evaluator& ev, const oscad::ModularCall& node, EvalContext
 std::vector<ColoredBody> generateHull(Evaluator& ev, const CSGParams& params,
                                        const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);
 
+// dxf_dim()/dxf_cross() -- read a dimension or a cross's centre out of a
+// DXF file. Functions, not modules; dispatched from evalBuiltinFunction.
+Value builtinDxfDim(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node);
+Value builtinDxfCross(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node);
+
+CSGParams resolveFill(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
+std::vector<ColoredBody> generateFill(Evaluator& ev, const CSGParams& params,
+                                       const std::vector<std::unique_ptr<CSGNode>>& children,
+                                       const oscad::ASTNode& node);
 CSGParams resolveMinkowski(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateMinkowski(Evaluator& ev, const CSGParams& params,
                                             const std::vector<std::unique_ptr<CSGNode>>& children,

openscad_cpp_evaluator-0.34.0/src/builtins/dxf_dim.cpp

@@ -0,0 +1,221 @@
+#include "builtins.hpp"
+
+#include "openscad_cpp_evaluator/call_args.hpp"
+#include "openscad_cpp_evaluator/evaluator.hpp"
+
+#include <cmath>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+
+namespace oscadeval {
+
+// dxf_dim() / dxf_cross() -- read a measurement straight out of a DXF file
+// rather than out of the model. Ported from the reference's io/dxfdim.cc
+// plus the DIMENSION/LINE half of io/DxfData.cc.
+//
+// These share the group-code walk with src/import/dxf_import.cpp but not its
+// output: that one only cares about closed contours, while these two need
+// the DIMENSION entities' seven coordinate slots and the raw LINE endpoints,
+// neither of which a contour list keeps.
+
+namespace {
+
+struct Entity {
+    std::string type;                  // "DIMENSION", "LINE", ...
+    std::string layer;
+    std::string name;                  // group 1: DIMENSION's text override
+    int dimType = 0;                   // group 70
+    double angle = 0.0;                // group 50
+    double coords[7][2] = {};          // groups 10-16 / 20-26
+    std::vector<double> xverts, yverts; // groups 10/11 and 20/21, in order
+};
+
+std::string trimmed(const std::string& s) {
+    const size_t b = s.find_first_not_of(" \t\r\n");
+    if (b == std::string::npos) return "";
+    return s.substr(b, s.find_last_not_of(" \t\r\n") - b + 1);
+}
+
+// One entity per group-0 marker. Coordinates carry the origin shift and
+// scale the reference applies while parsing, with its own exception: groups
+// 11, 12 and 16 (and their 21/22/26 partners) are scaled but NOT shifted,
+// since they are extents rather than positions.
+std::vector<Entity> readEntities(const std::string& path, double xorigin, double yorigin, double scale) {
+    std::ifstream in(path);
+    std::vector<Entity> out;
+    if (!in) return out;
+
+    std::string codeLine, dataLine;
+    Entity cur;
+    bool started = false;
+    while (std::getline(in, codeLine) && std::getline(in, dataLine)) {
+        const std::string codeStr = trimmed(codeLine);
+        const std::string data = trimmed(dataLine);
+        if (codeStr.empty()) continue;
+        int code = 0;
+        try {
+            code = std::stoi(codeStr);
+        } catch (...) {
+            break;
+        }
+        const auto num = [&]() -> double {
+            try {
+                return std::stod(data);
+            } catch (...) {
+                return 0.0;
+            }
+        };
+
+        if (code == 0) {
+            if (started) out.push_back(cur);
+            cur = Entity{};
+            cur.type = data;
+            started = true;
+            continue;
+        }
+        if (!started) continue;
+
+        if (code >= 10 && code <= 16) {
+            cur.coords[code - 10][0] =
+                (code == 11 || code == 12 || code == 16) ? num() * scale : (num() - xorigin) * scale;
+        } else if (code >= 20 && code <= 26) {
+            cur.coords[code - 20][1] =
+                (code == 21 || code == 22 || code == 26) ? num() * scale : (num() - yorigin) * scale;
+        }
+        switch (code) {
+            case 1: cur.name = data; break;
+            case 8: cur.layer = data; break;
+            case 10:
+            case 11: cur.xverts.push_back((num() - xorigin) * scale); break;
+            case 20:
+            case 21: cur.yverts.push_back((num() - yorigin) * scale); break;
+            case 50: cur.angle = num(); break;
+            case 70:
+                try {
+                    cur.dimType = std::stoi(data);
+                } catch (...) {
+                }
+                break;
+            default: break;
+        }
+    }
+    if (started) out.push_back(cur);
+    return out;
+}
+
+double deg(double r) { return r * 180.0 / 3.14159265358979323846; }
+double rad(double d) { return d * 3.14159265358979323846 / 180.0; }
+
+struct CommonArgs {
+    std::string path;
+    std::string rawFile;
+    std::string layer;
+    double xorigin = 0.0, yorigin = 0.0, scale = 1.0;
+};
+
+CommonArgs commonArgs(const CallArgs& args, const oscad::ASTNode& node) {
+    CommonArgs c;
+    const Value fileArg = getArg(args, 0, "file", Value{});
+    c.rawFile = std::holds_alternative<std::string>(fileArg) ? std::get<std::string>(fileArg) : fmtValue(fileArg);
+    c.path = resolveFilePath(fileArg, node);
+    const Value layerArg = getArg(args, std::nullopt, "layer", Value{});
+    if (const std::string* s = std::get_if<std::string>(&layerArg)) c.layer = *s;
+    const Value originArg = getArg(args, std::nullopt, "origin", Value{});
+    if (const ListPtr* l = std::get_if<ListPtr>(&originArg); l && *l && (*l)->items.size() >= 2) {
+        c.xorigin = toDoubleLenient((*l)->items[0]);
+        c.yorigin = toDoubleLenient((*l)->items[1]);
+    }
+    const Value scaleArg = getArg(args, std::nullopt, "scale", Value{1.0});
+    if (std::holds_alternative<double>(scaleArg)) c.scale = std::get<double>(scaleArg);
+    return c;
+}
+
+} // namespace
+
+Value builtinDxfDim(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node) {
+    const CommonArgs c = commonArgs(args, node);
+    const Value nameArg = getArg(args, std::nullopt, "name", Value{});
+    const std::string name = std::holds_alternative<std::string>(nameArg) ? std::get<std::string>(nameArg) : "";
+
+    if (!std::filesystem::exists(c.path)) {
+        ev.warn("Can't open DXF file '" + c.rawFile + "'!", &node.position());
+        return Value{};
+    }
+    for (const Entity& e : readEntities(c.path, c.xorigin, c.yorigin, c.scale)) {
+        if (e.type != "DIMENSION") continue;
+        if (!c.layer.empty() && c.layer != e.layer) continue;
+        if (!name.empty() && e.name != name) continue;
+
+        const int type = e.dimType & 7;
+        if (type == 0) {   // rotated, horizontal or vertical
+            const double x = e.coords[4][0] - e.coords[3][0];
+            const double y = e.coords[4][1] - e.coords[3][1];
+            return Value{std::fabs(x * std::cos(rad(e.angle)) + y * std::sin(rad(e.angle)))};
+        }
+        if (type == 1) {   // aligned
+            const double x = e.coords[4][0] - e.coords[3][0];
+            const double y = e.coords[4][1] - e.coords[3][1];
+            return Value{std::sqrt(x * x + y * y)};
+        }
+        if (type == 2) {   // angular
+            const double a1 = deg(std::atan2(e.coords[0][0] - e.coords[5][0], e.coords[0][1] - e.coords[5][1]));
+            const double a2 = deg(std::atan2(e.coords[4][0] - e.coords[3][0], e.coords[4][1] - e.coords[3][1]));
+            return Value{std::fabs(a1 - a2)};
+        }
+        if (type == 3 || type == 4) {   // diameter or radius
+            const double x = e.coords[5][0] - e.coords[0][0];
+            const double y = e.coords[5][1] - e.coords[0][1];
+            return Value{std::sqrt(x * x + y * y)};
+        }
+        if (type == 6) {   // ordinate
+            return Value{(e.dimType & 64) ? e.coords[3][0] : e.coords[3][1]};
+        }
+        // type 5 (angular 3-point) falls through, as in the reference.
+        ev.warn("Dimension '" + name + "' in '" + c.rawFile + "', layer '" + c.layer + "' has unsupported type!",
+                &node.position());
+        return Value{};
+    }
+    ev.warn("Can't find dimension '" + name + "' in '" + c.rawFile + "', layer '" + c.layer + "'!",
+            &node.position());
+    return Value{};
+}
+
+Value builtinDxfCross(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node) {
+    const CommonArgs c = commonArgs(args, node);
+    if (!std::filesystem::exists(c.path)) {
+        ev.warn("Can't open DXF file '" + c.rawFile + "'!", &node.position());
+        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.
+    double p[4][2];
+    int found = 0;
+    for (const Entity& e : readEntities(c.path, c.xorigin, c.yorigin, c.scale)) {
+        if (e.type != "LINE") continue;
+        if (!c.layer.empty() && c.layer != e.layer) continue;
+        if (e.xverts.size() < 2 || e.yverts.size() < 2) continue;
+        p[found][0] = e.xverts[0];
+        p[found][1] = e.yverts[0];
+        ++found;
+        p[found][0] = e.xverts[1];
+        p[found][1] = e.yverts[1];
+        ++found;
+        if (found == 4) {
+            const double x1 = p[0][0], y1 = p[0][1], x2 = p[1][0], y2 = p[1][1];
+            const double x3 = p[2][0], y3 = p[2][1], x4 = p[3][0], y4 = p[3][1];
+            const double dem = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+            if (dem == 0.0) break;   // parallel: no cross, same as the reference
+            const double ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / dem;
+            std::vector<Value> xy{Value{x1 + ua * (x2 - x1)}, Value{y1 + ua * (y2 - y1)}};
+            return Value{std::make_shared<const ValueList>(ValueList{std::move(xy)})};
+        }
+    }
+    ev.warn("Can't find cross in '" + c.rawFile + "', layer '" + c.layer + "'!", &node.position());
+    return Value{};
+}
+
+} // namespace oscadeval