openscad-cpp-evaluator 1.40.0__tar.gz → 1.41.0__tar.gz

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.41.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.41.0}/bindings/module.cpp

@@ -134,6 +134,7 @@ const char* roleToString(oscadeval::BodyRole role) {
         case oscadeval::BodyRole::Highlight:  return "highlight";
         case oscadeval::BodyRole::Background: return "background";
         case oscadeval::BodyRole::ShowOnly:   return "show_only";
+        case oscadeval::BodyRole::HighlightGhost: return "highlight_ghost";
         case oscadeval::BodyRole::Normal:
         default:                              return "normal";
     }

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.41.0}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -71,6 +71,9 @@ struct PendingCsgWrap {
     // Parallel to groupSizes: whether a group that came out EMPTY is still
     // an operand. See Op::CsgGroupEnd's `a`.
     std::vector<Value> emptyIsAGroup;
+    // Parallel too: whether the statement was a `%` one, which is never an
+    // operand. See Op::CsgGroupEnd's `a` (bit 2).
+    std::vector<Value> backgroundStmt;
     size_t groupStartSize = 0;
 };
 

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.41.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -12,7 +12,16 @@
 
 namespace oscadeval {
 
-enum class BodyRole { Normal, Highlight, Background, ShowOnly };
+// HighlightGhost is the see-through copy of a `#` operand that an operation
+// (difference, intersection, hull, ...) emits beside its result so the
+// viewport can still show the operand. The operand itself was merged into
+// the result; the ghost is drawing only. It is never an operand again and
+// never exported -- it used to be a plain Highlight body, so an outer
+// boolean used it twice and export wrote it as real geometry:
+// difference(){ cube(2); #translate([1,1,1]) cube(2); } exported volume 15
+// where OpenSCAD writes 7. A `#` with nothing merging it stays Highlight,
+// and exports like any other geometry, as it does upstream.
+enum class BodyRole { Normal, Highlight, Background, ShowOnly, HighlightGhost };
 
 // A single piece of evaluated geometry: exactly one of `body` (3D) or
 // `section` (2D) is set, never both -- mirrors the Python reference's
@@ -178,4 +187,26 @@ inline constexpr double kTopLevel2dHeight = 1.0;
 std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies,
                                             double flatHeight = kTopLevel2dHeight);
 
+// A 3D affine transform as it acts on the XY plane: rows x and y, columns
+// x, y and translation -- what OpenSCAD's GeometryEvaluator applies to 2D
+// geometry (z, and everything out of the plane, simply drops away).
+manifold::mat2x3 projectTo2d(const manifold::mat3x4& m);
+
+// Moves a section's carried transform (ColoredBody::sectionXform) into the
+// CrossSection itself, projected onto the plane, and resets it. Every 2D
+// operation does this to its children before it reads them: OpenSCAD's F6
+// has already projected each transform by then, and an operation that
+// ignored the carried one -- union, offset, hull, linear_extrude -- used the
+// shape as if the transform had never happened. False if the projection
+// was singular and the shape was removed (the caller warns).
+bool projectSectionXform(ColoredBody& b);
+
+// Applies `m`, projected onto the plane, to a CrossSection. A singular
+// projection -- scale([0,1]), a quarter turn about X -- empties it, as
+// upstream's Polygon2d::transform does, and returns false.
+bool transformSection(manifold::CrossSection& cs, const manifold::mat3x4& m);
+
+// Upstream's warning for that case, word for word.
+inline constexpr const char* kZeroScale2dWarning = "Scaling a 2D object with 0 - removing object";
+
 } // namespace oscadeval

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.41.0}/include/openscad_cpp_evaluator/export.hpp

@@ -52,6 +52,14 @@ struct ExportObject {
 // A body Manifold rejected (an open shell is not a solid) can take part in
 // none of that: it keeps its own triangles and its own object, and its
 // 1-based index is appended to `openParts` for the caller to warn about.
+// The dimension OpenSCAD's render gives these top-level bodies: that of the
+// first one with geometry (2 or 3), or 0 for none.
+int topLevelDimension(const std::vector<ColoredBody>& bodies);
+
+// OpenSCAD's render warnings for a top level that mixes 2D and 3D; export
+// writes only the first object's dimension.
+std::vector<std::string> mixedDimensionWarnings(const std::vector<ColoredBody>& bodies);
+
 std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies,
                                                 std::vector<int>* openParts = nullptr,
                                                 bool splitComponents = false,

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.41.0}/include/openscad_cpp_evaluator/segments.hpp

@@ -5,7 +5,9 @@
 
 #include <manifold/common.h>
 
+#include <functional>
 #include <optional>
+#include <string>
 
 namespace oscadeval {
 
@@ -27,7 +29,8 @@ struct Discretizer {
     double fa = 12.0;
     double fs = 2.0;
 
-    static Discretizer fromCtx(const EvalContext& ctx);
+    // `warn`, when given, receives upstream's clamping warnings.
+    static Discretizer fromCtx(const EvalContext& ctx, const std::function<void(const std::string&)>& warn = {});
     // Stored in, and read back from, a node's params -- they are part of its
     // cache key, and generate has only the params to go on.
     static Discretizer fromParams(const CSGParams& params);
@@ -53,6 +56,7 @@ struct Discretizer {
 
 // Full-circle segment count from ctx's $fn/$fe/$fa/$fs at radius r;
 // upstream's primitives fall back to 3.
-int fnSegmentsFromCtx(const EvalContext& ctx, double r = 0.0);
+int fnSegmentsFromCtx(const EvalContext& ctx, double r = 0.0,
+                      const std::function<void(const std::string&)>& warn = {});
 
 } // namespace oscadeval

openscad_cpp_evaluator-1.41.0/include/openscad_cpp_evaluator/surface_load.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace oscadeval {
+
+// Height data for surface(), read as upstream's SurfaceNode reads it: a
+// PNG (by its signature) as 16-bit luminance scaled to 0-100, negated by
+// `invert`, bottom image row at y = 0; anything else as a .dat grid, first
+// line at y = 0, short rows padded with 0. Never throws: a file that cannot
+// be read gives no heights and upstream's warning, and the script carries
+// on. `heights[row * cols + col]`; `minVal` is what the base sits 1 below.
+struct SurfaceData {
+    std::vector<double> heights;
+    int rows = 0;
+    int cols = 0;
+    double minVal = 0;
+    std::vector<std::string> warnings;
+};
+SurfaceData loadSurface(const std::string& path, bool invert);
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.41.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.41.0}/python/openscad_cpp_evaluator/__init__.py

@@ -249,7 +249,8 @@ def _summarize_param(value, max_items: int = 6, max_len: int = 40) -> str:
 # of kind -- pure internal bookkeeping or already represented structurally
 # elsewhere in the tree. Mirrors the reference's _DUMP_HIDDEN_PARAM_KEYS.
 _DUMP_HIDDEN_PARAM_KEYS = frozenset(
-    {"color", "op", "name", "group_sizes", "empty_is_a_group"})
+    {"color", "op", "name", "group_sizes", "empty_is_a_group", "background_stmt",
+     "m", "remove"})
 
 # Auto-generated tessellation data (not user-authored) for every kind except
 # polyhedron, where the equivalent data *is* the user's own points/faces.
@@ -520,7 +521,7 @@ class ColoredBody:
     section: object = None             # kept for API parity (always None here)
     flat_preview: bool = False
     tri_colors: Optional[object] = None  # (numTri, 4) float32 ndarray, real multi-color CSG merges only
-    role: str = "normal"               # "normal" | "highlight" | "background" | "show_only"
+    role: str = "normal"               # "normal" | "highlight" | "highlight_ghost" | "background" | "show_only"
 
 
 def bodies_from_dicts(body_dicts) -> list:

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.41.0}/src/builtins/booleans.cpp

@@ -33,17 +33,28 @@ RoleSplit splitByRole(const std::vector<ColoredBody>& bodies) {
     // boolean would silently zero the whole operation (the same failure
     // mode invalid operands caused before they were filtered out).
     for (const ColoredBody& c : bodies) {
-        if (c.isDisplayOnly() && c.role != BodyRole::Background && c.role != BodyRole::ShowOnly) {
+        if (c.isDisplayOnly() && c.role != BodyRole::Background && c.role != BodyRole::ShowOnly &&
+            c.role != BodyRole::HighlightGhost) {
             r.displayOnly.push_back(c);
         }
     }
     for (const ColoredBody& c : bodies) {
-        if (c.role != BodyRole::Background && c.role != BodyRole::ShowOnly && !c.isDisplayOnly()) {
+        if (c.role != BodyRole::Background && c.role != BodyRole::ShowOnly && c.role != BodyRole::HighlightGhost &&
+            !c.isDisplayOnly()) {
             r.foreground.push_back(c);
         }
     }
+    // A `#` operand is merged like any other (it is in `foreground` above)
+    // AND drawn again as a ghost; a ghost from deeper down just rides along.
     for (const ColoredBody& c : r.foreground) {
-        if (c.role == BodyRole::Highlight) r.highlight.push_back(c);
+        if (c.role == BodyRole::Highlight) {
+            ColoredBody ghost = c;
+            ghost.role = BodyRole::HighlightGhost;
+            r.highlight.push_back(std::move(ghost));
+        }
+    }
+    for (const ColoredBody& c : bodies) {
+        if (c.role == BodyRole::HighlightGhost) r.highlight.push_back(c);
     }
     for (const ColoredBody& c : bodies) {
         if (c.role == BodyRole::ShowOnly) r.showOnly.push_back(c);
@@ -82,6 +93,13 @@ std::optional<manifold::CrossSection> toCrossSection(const std::vector<ColoredBo
 // alongside real ManifoldCache/provenance work if per-triangle color
 // through a merge is needed).
 
+bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt) {
+    const oscad::NodeKind k = stmt.kind();
+    return k == oscad::NodeKind::ModularCall || k == oscad::NodeKind::ModularFor ||
+           k == oscad::NodeKind::ModularIntersectionFor || k == oscad::NodeKind::ModularLet ||
+           k == oscad::NodeKind::ModularModifierShowOnly || k == oscad::NodeKind::ModularModifierHighlight;
+}
+
 CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     const std::string& op = node.name->name;
     // union/difference/intersection take no positional arguments in real
@@ -110,6 +128,7 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
 
     std::vector<Value> groupSizes;
     std::vector<Value> emptyIsAGroup;
+    std::vector<Value> backgroundStmt;
     groupSizes.reserve(geoNodes.size());
     emptyIsAGroup.reserve(geoNodes.size());
     for (const oscad::ASTNode* geoNode : geoNodes) {
@@ -130,15 +149,8 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
         // for `if(false) sphere(6)`, `{ }` and `*cube(1)`, and comes out
         // empty for `for(i=[1:0]) sphere(6)`, `union(){}`, `group(){}` and
         // a call to an empty user module.
-        const oscad::NodeKind k = geoNode->kind();
-        emptyIsAGroup.push_back(Value{
-                                       k == oscad::NodeKind::ModularCall ||
-                                       k == oscad::NodeKind::ModularFor ||
-                                       k == oscad::NodeKind::ModularIntersectionFor ||
-                                       k == oscad::NodeKind::ModularLet ||
-                                       k == oscad::NodeKind::ModularModifierShowOnly ||
-                                       k == oscad::NodeKind::ModularModifierHighlight ||
-                                       k == oscad::NodeKind::ModularModifierBackground});
+        emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*geoNode)});
+        backgroundStmt.push_back(Value{geoNode->kind() == oscad::NodeKind::ModularModifierBackground});
     }
 
     CSGParams params;
@@ -146,6 +158,7 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
     params["group_sizes"] = Value{makeList(std::move(groupSizes))};
     params["empty_is_a_group"] =
         Value{makeList(std::move(emptyIsAGroup))};
+    params["background_stmt"] = Value{makeList(std::move(backgroundStmt))};
     return params;
 }
 
@@ -314,6 +327,11 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
     const std::string& op = std::get<std::string>(params.at("op"));
     const auto& groupSizes = std::get<ListPtr>(params.at("group_sizes"))->items;
     const auto emptyIsAGroupIt = params.find("empty_is_a_group");
+    const auto backgroundStmtIt = params.find("background_stmt");
+    const auto* backgroundStmt =
+        backgroundStmtIt != params.end() && std::holds_alternative<ListPtr>(backgroundStmtIt->second)
+            ? &std::get<ListPtr>(backgroundStmtIt->second)->items
+            : nullptr;
     const ListItems* emptyIsAGroup =
         emptyIsAGroupIt == params.end()
             ? nullptr
@@ -374,6 +392,20 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
         }
 
         RoleSplit split = splitByRole(stmtBodies);
+        // A `%` statement is scenery, not an operand: upstream leaves it out
+        // of the CSG entirely (collectChildren skips isBackground()), so the
+        // NEXT statement is the minuend of a difference(), and an
+        // intersection() is not cancelled by it. It was taken as an empty
+        // operand, which emptied both. Only the `%` statement itself: a
+        // module or union() holding nothing but `%` is still an (empty)
+        // operand there.
+        const bool isBackgroundStmt = backgroundStmt && thisStmt < backgroundStmt->size() &&
+                                      std::holds_alternative<bool>((*backgroundStmt)[thisStmt]) &&
+                                      std::get<bool>((*backgroundStmt)[thisStmt]);
+        if (isBackgroundStmt) {
+            allBg.insert(allBg.end(), split.background.begin(), split.background.end());
+            continue;
+        }
         allBg.insert(allBg.end(), split.background.begin(), split.background.end());
         allHi.insert(allHi.end(), split.highlight.begin(), split.highlight.end());
         allSo.insert(allSo.end(), split.showOnly.begin(), split.showOnly.end());

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.41.0}/src/builtins/builtins.hpp

@@ -267,6 +267,19 @@ std::vector<ColoredBody> generateSurface(Evaluator& ev, const CSGParams& params,
                                           const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);
 
 // text() -- text.cpp.
+// Whether a statement that produced no geometry still counts as a boolean
+// operand (and so empties an intersection) -- see resolveCsg.
+bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt);
+
+// OpenSCAD's sin_degrees/cos_degrees: exact at multiples of 30 and 45 degrees.
+double sinDeg(double x);
+double cosDeg(double x);
+
+// OpenSCAD's lookup_radius() (primitives_2d.cpp): `d` beats `r`, numbers only.
+std::optional<double> lookupRadius(Evaluator& ev, const CallArgs& args, std::optional<int> rPos,
+                                   std::optional<int> dPos, const std::string& rName, const std::string& dName,
+                                   const oscad::Position* where);
+
 CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 
 // The font size text()/textmetrics()/fontmetrics() draw at: `size`

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.41.0}/src/builtins/control.cpp

@@ -106,6 +106,8 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
     const std::vector<const oscad::ASTNode*> bodyNodes = ev.expandChildStatements(node.body, ctx);
 
     std::vector<Value> groupSizes;
+    std::vector<Value> emptyIsAGroup;
+    std::vector<Value> backgroundStmt;
 
     // Each dimension's own RHS is evaluated against `parentCtx` (not
     // upfront against the original `ctx`), re-evaluated on every entry
@@ -121,9 +123,25 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
             // evalFor) -- mirrors _resolve_intersection_for's single
             // `_check_debug(body_node[0], loop_ctx, expr_level=True)`.
             if (!bodyNodes.empty()) ev.checkDebug(*bodyNodes.front(), parentCtx, /*forced=*/false, /*exprLevel=*/true);
-            const size_t before = ev.currentTreeFrameSize();
-            ev.evalChildren(bodyNodes, parentCtx);
-            groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
+            // One operand per child STATEMENT of every iteration: upstream
+            // instantiates the children straight into the intersection
+            // node (control.cc), so they are intersected flat, not
+            // unioned per iteration first.
+            std::vector<const oscad::ASTNode*> assigns, stmts;
+            for (const oscad::ASTNode* stmt : bodyNodes) {
+                if (stmt->kind() == oscad::NodeKind::Assignment) assigns.push_back(stmt);
+                else if (stmt->kind() != oscad::NodeKind::ModuleDeclaration &&
+                         stmt->kind() != oscad::NodeKind::FunctionDeclaration)
+                    stmts.push_back(stmt);
+            }
+            if (!assigns.empty()) ev.evalChildren(assigns, parentCtx);
+            for (const oscad::ASTNode* stmt : stmts) {
+                const size_t before = ev.currentTreeFrameSize();
+                ev.evalChildren(std::vector<const oscad::ASTNode*>{stmt}, parentCtx);
+                groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
+                emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*stmt)});
+                backgroundStmt.push_back(Value{stmt->kind() == oscad::NodeKind::ModularModifierBackground});
+            }
             return;
         }
         const auto& assign = node.assignments[depth];
@@ -142,49 +160,19 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
 
     CSGParams params;
     params["group_sizes"] = Value{makeList(std::move(groupSizes))};
+    params["empty_is_a_group"] = Value{makeList(std::move(emptyIsAGroup))};
+    params["background_stmt"] = Value{makeList(std::move(backgroundStmt))};
     return params;
 }
 
-std::vector<ColoredBody> generateIntersectionFor(Evaluator&, const CSGParams& params,
+std::vector<ColoredBody> generateIntersectionFor(Evaluator& ev, const CSGParams& params,
                                                   const std::vector<std::unique_ptr<CSGNode>>& children,
-                                                  const oscad::ASTNode&) {
-    const auto& groupSizes = std::get<ListPtr>(params.at("group_sizes"))->items;
-    std::vector<ColoredBody> iterations;
-    size_t idx = 0;
-    for (const Value& sv : groupSizes) {
-        const size_t size = static_cast<size_t>(std::get<double>(sv));
-        std::vector<ColoredBody> stmtBodies = flattenCsgTree(children, idx, size);
-        idx += size;
-        if (!stmtBodies.empty()) iterations.push_back(combineBodies(stmtBodies));
-    }
-    if (iterations.empty()) return {};
-
-    std::vector<ColoredBody> bodies3d;
-    for (const ColoredBody& c : iterations) {
-        if (c.body) bodies3d.push_back(c);
-    }
-    if (!bodies3d.empty()) {
-        manifold::Manifold result = *bodies3d.front().body;
-        for (size_t i = 1; i < bodies3d.size(); ++i) result = result ^ *bodies3d[i].body;
-        ColoredBody cb;
-        cb.body = std::move(result);
-        cb.color = bodies3d.front().color;
-        return {cb};
-    }
-
-    std::vector<ColoredBody> sections;
-    for (const ColoredBody& c : iterations) {
-        if (c.section) sections.push_back(c);
-    }
-    if (!sections.empty()) {
-        manifold::CrossSection result = *sections.front().section;
-        for (size_t i = 1; i < sections.size(); ++i) result = result ^ *sections[i].section;
-        ColoredBody cb;
-        cb.section = std::move(result);
-        cb.color = iterations.front().color;
-        return {cb};
-    }
-    return {};
+                                                  const oscad::ASTNode& node) {
+    // The same operand rules as intersection() itself -- empty statements,
+    // `%` scenery, `#` ghosts, 2D vs 3D -- over the flat statement list.
+    CSGParams p = params;
+    p["op"] = Value{std::string("intersection")};
+    return generateCsg(ev, p, children, node);
 }
 
 } // namespace oscadeval