openscad-cpp-evaluator 1.1.0__tar.gz → 1.2.0__tar.gz

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.2.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.2.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.2.0}/src/builtins/booleans.cpp

@@ -214,7 +214,15 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
             : &std::get<ListPtr>(emptyIsAGroupIt->second)->items;
 
     std::vector<ColoredBody> allBg, allHi, allSo, allDo;
-    std::optional<ColoredBody> csgResult;
+    // Two accumulators, one per dimension. union() may legitimately carry
+    // both -- `translate(...) { part(); text("label"); }` is how a docs
+    // figure annotates a 3D part, and the reference draws both -- and a
+    // single optional that switched between body and section is exactly
+    // what used to be dereferenced empty when a group changed dimension
+    // part-way. difference and intersection still see one dimension only:
+    // applyDimensionRules drops the mismatch before it gets here, so for
+    // them just one of these is ever populated.
+    std::optional<ColoredBody> res3d, res2d;
     size_t idx = 0;
 
     size_t stmtIndex = 0;
@@ -273,50 +281,56 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
             // discards while no positive operand has been established yet;
             // union just skips the empty contributor and keeps going.
             if (op == "intersection") {
-                csgResult.reset();
+                res3d.reset();
+                res2d.reset();
                 break;
             }
-            if (op == "difference" && !csgResult) break;
+            if (op == "difference" && !res3d && !res2d) break;
             continue;
         }
 
+        // Each dimension accumulates on its own, so a statement holding
+        // both contributes to both rather than the 2D half falling off the
+        // end of an if/else.
         if (!bodies3d.empty()) {
             manifold::Manifold grp = *bodies3d.front().body;
             for (size_t i = 1; i < bodies3d.size(); ++i) grp = grp + *bodies3d[i].body;
-            if (!csgResult) {
+            if (!res3d) {
                 ColoredBody cb;
                 cb.body = std::move(grp);
                 cb.color = bodies3d.front().color;
-                csgResult = std::move(cb);
+                res3d = std::move(cb);
             } else if (op == "union") {
-                csgResult->body = *csgResult->body + grp;
+                res3d->body = *res3d->body + grp;
             } else if (op == "difference") {
-                csgResult->body = *csgResult->body - grp;
+                res3d->body = *res3d->body - grp;
             } else if (op == "intersection") {
-                csgResult->body = *csgResult->body ^ grp;
+                res3d->body = *res3d->body ^ grp;
             }
-        } else {
+        }
+        if (!sections2d.empty()) {
             manifold::CrossSection grp = *sections2d.front().section;
             for (size_t i = 1; i < sections2d.size(); ++i) grp = grp + *sections2d[i].section;
-            if (!csgResult) {
+            if (!res2d) {
                 ColoredBody cb;
                 cb.section = std::move(grp);
                 cb.color = sections2d.front().color;
-                csgResult = std::move(cb);
+                res2d = std::move(cb);
             } else if (op == "union") {
-                csgResult->section = *csgResult->section + grp;
+                res2d->section = *res2d->section + grp;
             } else if (op == "difference") {
-                csgResult->section = *csgResult->section - grp;
+                res2d->section = *res2d->section - grp;
             } else if (op == "intersection") {
-                csgResult->section = *csgResult->section ^ grp;
+                res2d->section = *res2d->section ^ grp;
             }
         }
     }
 
-    if (csgResult && csgResult->body) attachTriColors(ev, *csgResult);
+    if (res3d && res3d->body) attachTriColors(ev, *res3d);
 
     std::vector<ColoredBody> result;
-    if (csgResult) result.push_back(std::move(*csgResult));
+    if (res3d) result.push_back(std::move(*res3d));
+    if (res2d) result.push_back(std::move(*res2d));
     result.insert(result.end(), allBg.begin(), allBg.end());
     result.insert(result.end(), allHi.begin(), allHi.end());
     result.insert(result.end(), allSo.begin(), allSo.end());

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.2.0}/src/csg_generate.cpp

@@ -129,6 +129,20 @@ enum class DimRule {
     None,    // no dimension diagnostics at all
 };
 
+// Nodes that hand their children on as a list instead of combining them
+// into one result, so a mixed 2D/3D list reaches nothing that has to pick a
+// single dimension. generateTransform and generateColor map over the
+// bodies; generateCsg's union keeps a 3D and a 2D accumulator side by side.
+//
+// difference and intersection are deliberately absent: subtracting or
+// intersecting across dimensions has no meaning, and they still collapse to
+// one result. hull and minkowski likewise build a single hull.
+bool keepsMixedDimensions(const std::string& kind) {
+    return kind == "union" || kind == "color" || kind == "translate" ||
+           kind == "rotate" || kind == "scale" || kind == "mirror" ||
+           kind == "multmatrix" || kind == "resize";
+}
+
 DimRule dimRuleFor(const std::string& kind) {
     if (kind == "linear_extrude" || kind == "rotate_extrude" || kind == "offset") return DimRule::Only2D;
     if (kind == "projection") return DimRule::Only3D;
@@ -168,7 +182,11 @@ void Evaluator::applyDimensionRules(CSGNode& node) {
     std::vector<CSGNode*> kids;
     kids.reserve(node.children.size());
     for (const std::unique_ptr<CSGNode>& c : node.children) kids.push_back(c.get());
-    applyDimensionRulesTo(kids, static_cast<int>(rule));
+    // Only a Group-rule node can keep a mix. linear_extrude and friends take
+    // one dimension by definition, so a wrong-dimension child there is still
+    // dropped with its warning.
+    const bool keepMixed = rule == DimRule::Group && keepsMixedDimensions(node.kind);
+    applyDimensionRulesTo(kids, static_cast<int>(rule), keepMixed);
 }
 
 // `keepMixed` warns about a mixed group but drops nothing -- the top level's
@@ -199,7 +217,12 @@ void Evaluator::applyDimensionRulesTo(const std::vector<CSGNode*>& children, int
                 continue;
             }
             const oscad::Position* pos = child->node ? &child->node->position() : nullptr;
-            if (rule == DimRule::Group && !warnedMixing) {
+            // Silent when both are kept: the reference says nothing for
+            // `cube(1); square(4);`, `translate(...) { ... }` or `union()
+            // { ... }` -- checked by running it -- and a warning here would
+            // fail any docs example that legitimately draws a 2D annotation
+            // beside a 3D part.
+            if (rule == DimRule::Group && !keepMixed && !warnedMixing) {
                 warn("Mixing 2D and 3D objects is not supported", pos);
                 warnedMixing = true;
             }

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.2.0}/tests/test_booleans.cpp

@@ -618,41 +618,53 @@ std::vector<std::string> dimWarnings(const std::string& code) {
 }
 } // namespace
 
-TEST(MixedDimensions, ThreeDeeFirstUnionDoesNotCrash) {
-    // The regression that started this: a body-then-section group.
-    Evaluated e = evalSrc("union() { cube(1); square(4); }");
-    ASSERT_EQ(e.bodies.size(), 1u);
-    ASSERT_TRUE(e.bodies[0].body.has_value());
-    EXPECT_NEAR(e.bodies[0].body->Volume(), 1.0, 1e-9);
+// Both dimensions survive a union or a transform, in either order, because
+// the reference keeps both -- `translate([9,3]) { cube(10); text("hi"); }`
+// renders the cube AND the flat text there, which is how BOSL2's joiners
+// figure annotates a part. Checked by running the reference, not assumed.
+TEST(MixedDimensions, UnionKeepsBothDimensions) {
+    for (const char* src : {"union() { cube(1); square(4); }",
+                            "union() { square(4); cube(1); }"}) {
+        Evaluated e = evalSrc(src);
+        ASSERT_EQ(e.bodies.size(), 2u) << src;
+        const ColoredBody* solid = nullptr;
+        const ColoredBody* flat = nullptr;
+        for (const ColoredBody& b : e.bodies) {
+            if (b.body) solid = &b;
+            if (b.section) flat = &b;
+        }
+        ASSERT_TRUE(solid) << src;
+        ASSERT_TRUE(flat) << src;
+        EXPECT_NEAR(solid->body->Volume(), 1.0, 1e-9) << src;
+        EXPECT_NEAR(flat->section->Area(), 16.0, 1e-9) << src;
+    }
 }
 
-TEST(MixedDimensions, TwoDeeFirstKeepsTheTwoDeeChild) {
-    Evaluated e = evalSrc("union() { square(4); cube(1); }");
-    ASSERT_EQ(e.bodies.size(), 1u);
-    ASSERT_TRUE(e.bodies[0].section.has_value());
-    EXPECT_NEAR(e.bodies[0].section->Area(), 16.0, 1e-9);
+TEST(MixedDimensions, TransformKeepsBothDimensions) {
+    // The transform maps over its bodies rather than combining them, so the
+    // mix reaches nothing that has to choose.
+    Evaluated e = evalSrc("translate([0,0,0]) { square(4); cube(1); }");
+    ASSERT_EQ(e.bodies.size(), 2u);
 }
 
-TEST(MixedDimensions, GroupWarnsTwice) {
-    EXPECT_EQ(dimWarnings("union() { square(4); cube(1); }"),
-              (std::vector<std::string>{"WARNING: Ignoring 3D child object for 2D operation",
-                                        "WARNING: Mixing 2D and 3D objects is not supported"}));
-    EXPECT_EQ(dimWarnings("union() { cube(1); square(4); }"),
-              (std::vector<std::string>{"WARNING: Ignoring 2D child object for 3D operation",
-                                        "WARNING: Mixing 2D and 3D objects is not supported"}));
+TEST(MixedDimensions, KeepingBothIsSilent) {
+    // The reference warns for none of these -- verified by running it.
+    EXPECT_TRUE(dimWarnings("union() { square(4); cube(1); }").empty());
+    EXPECT_TRUE(dimWarnings("union() { cube(1); square(4); }").empty());
+    EXPECT_TRUE(dimWarnings("translate([0,0,0]) { square(4); cube(1); }").empty());
+    EXPECT_TRUE(dimWarnings("scale(2) { square(4); cube(1); }").empty());
+    EXPECT_TRUE(dimWarnings("color(\"red\") { square(4); cube(1); }").empty());
+    EXPECT_TRUE(dimWarnings("for (i = [0:0]) { square(4); cube(1); }").empty());
+    EXPECT_TRUE(dimWarnings("if (true) { square(4); cube(1); }").empty());
 }
 
-TEST(MixedDimensions, TransformsAndControlFlowAreGroupsToo) {
+TEST(MixedDimensions, CombiningOperationsStillPickOne) {
+    // These collapse to a single result, so a mix has no meaning and the
+    // odd child is still dropped, with both warnings.
     const std::vector<std::string> expected{"WARNING: Ignoring 3D child object for 2D operation",
                                             "WARNING: Mixing 2D and 3D objects is not supported"};
-    EXPECT_EQ(dimWarnings("translate([0,0,0]) { square(4); cube(1); }"), expected);
-    EXPECT_EQ(dimWarnings("scale(2) { square(4); cube(1); }"), expected);
-    EXPECT_EQ(dimWarnings("color(\"red\") { square(4); cube(1); }"), expected);
-    // for/if are transparent -- their children land at the top level, so
-    // they get the top level's keep-both treatment rather than a group's.
-    const std::vector<std::string> topLevel{"WARNING: Mixing 2D and 3D objects is not supported"};
-    EXPECT_EQ(dimWarnings("for (i = [0:0]) { square(4); cube(1); }"), topLevel);
-    EXPECT_EQ(dimWarnings("if (true) { square(4); cube(1); }"), topLevel);
+    EXPECT_EQ(dimWarnings("difference() { square(4); cube(1); }"), expected);
+    EXPECT_EQ(dimWarnings("intersection() { square(4); cube(1); }"), expected);
     EXPECT_EQ(dimWarnings("hull() { square(4); cube(1); }"), expected);
 }
 
@@ -678,15 +690,16 @@ TEST(MixedDimensions, RoofWarnsForNeither) {
     EXPECT_TRUE(dimWarnings("roof() { square(4); cube(1); }").empty());
 }
 
-TEST(MixedDimensions, TopLevelWarnsButKeepsBothDimensions) {
-    // The top level warns like any other group, but drops NOTHING. A real
-    // group has to pick one dimension because generateCsg builds a single
-    // result from it; the top level just hands back a list, and the
-    // reference's own preview draws 2D and 3D side by side. Dropping here
+TEST(MixedDimensions, TopLevelKeepsBothDimensionsSilently) {
+    // The top level drops NOTHING, and says nothing either: the reference
+    // is silent for `square(4); cube(1);` -- verified by running it -- and
+    // it draws 2D and 3D side by side in its own preview. Dropping here
     // silently lost the whole of a BOSL2 debug overlay (debug_bezier() of a
-    // 2D bezier is entirely 2D) whenever a 3D shape shared the script.
-    EXPECT_EQ(dimWarnings("square(4); cube(1);"),
-              (std::vector<std::string>{"WARNING: Mixing 2D and 3D objects is not supported"}));
+    // 2D bezier is entirely 2D) whenever a 3D shape shared the script; the
+    // warning went when union and the transforms learned to keep both, so
+    // that a docs figure annotating a 3D part with 2D text is not reported
+    // as a mistake.
+    EXPECT_TRUE(dimWarnings("square(4); cube(1);").empty());
     Evaluated e = evalSrc("square(4); cube(1);");
     ASSERT_EQ(e.bodies.size(), 2u);
     EXPECT_TRUE(e.bodies[0].section.has_value()) << "the 2D shape survived";

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.2.0}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.1.0"
+version = "1.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },