openscad-cpp-evaluator 1.11.0__tar.gz → 1.12.0__tar.gz

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.12.0}/CLAUDE.md

@@ -793,6 +793,18 @@ 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”).
+  **2D cannot use any of that, and keeps colour geometrically instead** (`Part2d`, same file): a
+  `CrossSection` is contours, not a mesh, so nothing in it remembers which child an edge came from
+  and there is no provenance for `attachTriColors` to read back. So the 2D accumulator holds **one
+  part per colour** rather than one merged section — same-coloured children still merge into one
+  part, a later statement notches what it covers out of the earlier parts (painter's order, the
+  rule `splitBodiesForExport` applies to overlapping 3D solids), `difference`/`intersection` apply
+  to every part, and a part cut away entirely is dropped. `generateCsg` then returns one
+  `ColoredBody` per surviving part, so **a 2D `union()` of differently-coloured children returns
+  several bodies where it used to return one**. Reported as a user bug: `union() { color("red")
+  square(10); color("blue") translate([12,0]) square(10); }` drew both squares red, where OpenSCAD
+  draws red and blue (verified by pixel-sampling both binaries' PNG output). `linear_extrude` of
+  such a union still drops colour entirely — checked against the real binary, which does the same.
 - `src/builtins/primitives_3d.cpp` — `sphere(style=)` is a BelfrySCAD extension naming the
   tessellation, using BOSL2's five `spheroid()` style names and constructions: `"orig"` (the default,
   and what OpenSCAD's own sphere() builds — rings offset half a step from the poles, no pole vertex),

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.12.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.12.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.12.0}/src/builtins/booleans.cpp

@@ -201,6 +201,57 @@ void attachTriColors(Evaluator& ev, ColoredBody& cb) {
     cb.triColors = std::move(triColors);
 }
 
+// One colour's worth of 2D result.
+//
+// 3D recovers per-child colour AFTER the merge, from Manifold's own
+// per-triangle provenance (attachTriColors above). A CrossSection has no
+// such thing -- it is contours, not a mesh, and nothing in it remembers
+// which child a given edge came from. So 2D has to keep colour
+// GEOMETRICALLY instead: one part per colour, each notched by whatever is
+// drawn over it later. That is the same painter's-order rule
+// splitBodiesForExport applies to overlapping 3D solids, and it is what
+// `union() { color("red") square(10); color("blue") ... }` needs to come
+// out as two coloured shapes instead of one shape wearing the first
+// child's colour.
+struct Part2d {
+    std::optional<std::array<float, 4>> color;
+    manifold::CrossSection section;
+};
+
+// Appends `add` to `parts`, merging into an existing part of the same
+// colour so `union() { color("red") a; color("red") b; }` stays one body.
+void addPart(std::vector<Part2d>& parts, const std::optional<std::array<float, 4>>& color,
+             const manifold::CrossSection& section) {
+    for (Part2d& p : parts) {
+        if (p.color == color) {
+            p.section = p.section + section;
+            return;
+        }
+    }
+    parts.push_back({color, section});
+}
+
+// The 2D operands of one statement, grouped by colour.
+std::vector<Part2d> partsOf(const std::vector<ColoredBody>& sections2d) {
+    std::vector<Part2d> parts;
+    for (const ColoredBody& c : sections2d) addPart(parts, c.color, *c.section);
+    return parts;
+}
+
+// Every part's section unioned -- the shape the statement covers,
+// whatever colours it is in.
+manifold::CrossSection coveredBy(const std::vector<Part2d>& parts) {
+    manifold::CrossSection all;
+    for (const Part2d& p : parts) all = all + p.section;
+    return all;
+}
+
+void dropEmptyParts(std::vector<Part2d>& parts) {
+    parts.erase(std::remove_if(parts.begin(), parts.end(),
+                                [](const Part2d& p) { return p.section.IsEmpty(); }),
+                parts.end());
+}
+
 } // namespace
 
 std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, const std::vector<std::unique_ptr<CSGNode>>& children,
@@ -222,7 +273,12 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
     // 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;
+    std::optional<ColoredBody> res3d;
+    // 2D keeps one entry per colour rather than one merged section; see
+    // Part2d. `have2d` distinguishes "no 2D operand yet" from "every 2D
+    // part has been cut away", which matters to difference().
+    std::vector<Part2d> res2d;
+    bool have2d = false;
     size_t idx = 0;
 
     size_t stmtIndex = 0;
@@ -282,10 +338,11 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
             // union just skips the empty contributor and keeps going.
             if (op == "intersection") {
                 res3d.reset();
-                res2d.reset();
+                res2d.clear();
+                have2d = false;
                 break;
             }
-            if (op == "difference" && !res3d && !res2d) break;
+            if (op == "difference" && !res3d && !have2d) break;
             continue;
         }
 
@@ -309,20 +366,25 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
             }
         }
         if (!sections2d.empty()) {
-            manifold::CrossSection grp = *sections2d.front().section;
-            for (size_t i = 1; i < sections2d.size(); ++i) grp = grp + *sections2d[i].section;
-            if (!res2d) {
-                ColoredBody cb;
-                cb.section = std::move(grp);
-                cb.color = sections2d.front().color;
-                res2d = std::move(cb);
+            std::vector<Part2d> stmtParts = partsOf(sections2d);
+            const manifold::CrossSection grp = coveredBy(stmtParts);
+            if (!have2d) {
+                res2d = std::move(stmtParts);
+                have2d = true;
             } else if (op == "union") {
-                res2d->section = *res2d->section + grp;
+                // Later wins the overlap: notch what is already there by
+                // everything this statement covers, then add this
+                // statement's parts. Same rule as two overlapping 3D
+                // solids of different colours, and the same thing a
+                // painter does.
+                for (Part2d& p : res2d) p.section = p.section - grp;
+                for (Part2d& np : stmtParts) addPart(res2d, np.color, np.section);
             } else if (op == "difference") {
-                res2d->section = *res2d->section - grp;
+                for (Part2d& p : res2d) p.section = p.section - grp;
             } else if (op == "intersection") {
-                res2d->section = *res2d->section ^ grp;
+                for (Part2d& p : res2d) p.section = p.section ^ grp;
             }
+            dropEmptyParts(res2d);
         }
     }
 
@@ -330,7 +392,12 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
 
     std::vector<ColoredBody> result;
     if (res3d) result.push_back(std::move(*res3d));
-    if (res2d) result.push_back(std::move(*res2d));
+    for (Part2d& p : res2d) {
+        ColoredBody cb;
+        cb.color = p.color;
+        cb.section = std::move(p.section);
+        result.push_back(std::move(cb));
+    }
     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.11.0 → openscad_cpp_evaluator-1.12.0}/tests/test_booleans.cpp

@@ -1439,3 +1439,118 @@ TEST(LevelSet, AGridFieldIsAlsoCutCleanlyAtTheBox) {
     ASSERT_EQ(e.bodies.size(), 1u);
     EXPECT_NEAR(soleBody(e).Volume(), 32000.0, 40.0);   // one sample layer of slack
 }
+
+// -- 2D union keeps every colour (bug report: "multiple colors inside a
+// union(), only one color is used") -----------------------------------
+
+namespace {
+
+// (colour, area) per 2D body, in result order.
+std::vector<std::pair<std::array<float, 4>, double>> colouredAreas(const std::vector<ColoredBody>& bodies) {
+    std::vector<std::pair<std::array<float, 4>, double>> out;
+    for (const ColoredBody& b : bodies) {
+        if (!b.section) continue;
+        out.emplace_back(b.color.value_or(std::array<float, 4>{0, 0, 0, 0}), b.section->Area());
+    }
+    return out;
+}
+
+constexpr std::array<float, 4> kRed{1, 0, 0, 1};
+constexpr std::array<float, 4> kBlue{0, 0, 1, 1};
+
+} // namespace
+
+TEST(Union2dColor, KeepsOneBodyPerColour) {
+    // A CrossSection has no per-edge provenance for attachTriColors to read
+    // back afterwards, so 2D keeps colour by staying in separate parts.
+    // Before this, both squares came out red -- the first child's colour
+    // for the whole merged section, where OpenSCAD draws red AND blue.
+    Evaluated e = evalSrc("union() { color(\"red\") square(10); color(\"blue\") translate([12,0]) square(10); }");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 2u);
+    EXPECT_EQ(parts[0].first, kRed);
+    EXPECT_EQ(parts[1].first, kBlue);
+    EXPECT_NEAR(parts[0].second, 100.0, 1e-6);
+    EXPECT_NEAR(parts[1].second, 100.0, 1e-6);
+}
+
+TEST(Union2dColor, OneColourStaysOneBody) {
+    // Splitting per colour must not split per child: two red squares are
+    // one red shape, as they always were.
+    Evaluated e = evalSrc("union() { color(\"red\") square(10); color(\"red\") translate([12,0]) square(10); }");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 1u);
+    EXPECT_EQ(parts[0].first, kRed);
+    EXPECT_NEAR(parts[0].second, 200.0, 1e-6);
+}
+
+TEST(Union2dColor, AnUncolouredUnionIsStillASingleBody) {
+    Evaluated e = evalSrc("union() { square(10); translate([12,0]) square(10); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].section.has_value());
+    EXPECT_FALSE(e.bodies[0].color.has_value());
+}
+
+TEST(Union2dColor, TheLaterColourWinsAnOverlap) {
+    // Painter's order, the same rule splitBodiesForExport applies to
+    // overlapping 3D solids -- and what OpenSCAD's own preview shows.
+    Evaluated e = evalSrc(
+        "union() { color(\"red\") square(10); color(\"blue\") translate([5,5]) square(10); }");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 2u);
+    EXPECT_EQ(parts[0].first, kRed);
+    EXPECT_EQ(parts[1].first, kBlue);
+    // Blue keeps its whole square; red is notched by the 5x5 overlap.
+    EXPECT_NEAR(parts[1].second, 100.0, 1e-6);
+    EXPECT_NEAR(parts[0].second, 75.0, 1e-6);
+}
+
+TEST(Union2dColor, DifferenceCutsEveryColouredPart) {
+    Evaluated e = evalSrc(
+        "difference() {"
+        "  union() { color(\"red\") square(10); color(\"blue\") translate([10,0]) square(10); }"
+        "  translate([5,0]) square(10);"
+        "}");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 2u);
+    // The cut spans both: 5 wide off red's right, 5 off blue's left.
+    EXPECT_NEAR(parts[0].second, 50.0, 1e-6);
+    EXPECT_NEAR(parts[1].second, 50.0, 1e-6);
+}
+
+TEST(Union2dColor, IntersectionKeepsColoursToo) {
+    Evaluated e = evalSrc(
+        "intersection() {"
+        "  union() { color(\"red\") square(10); color(\"blue\") translate([10,0]) square(10); }"
+        "  translate([5,0]) square(10);"
+        "}");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 2u);
+    EXPECT_EQ(parts[0].first, kRed);
+    EXPECT_EQ(parts[1].first, kBlue);
+    EXPECT_NEAR(parts[0].second, 50.0, 1e-6);
+    EXPECT_NEAR(parts[1].second, 50.0, 1e-6);
+}
+
+TEST(Union2dColor, APartCutAwayEntirelyIsDropped) {
+    Evaluated e = evalSrc(
+        "difference() {"
+        "  union() { color(\"red\") square(10); color(\"blue\") translate([20,0]) square(10); }"
+        "  square(10);"
+        "}");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 1u);
+    EXPECT_EQ(parts[0].first, kBlue);
+}
+
+TEST(Union2dColor, ExtrudingAColouredUnionStillDropsColour) {
+    // Not a bug, and checked against the real binary: OpenSCAD's own
+    // linear_extrude of coloured 2D children draws the default colour too.
+    // Splitting 2D by colour must not accidentally start colouring these.
+    Evaluated e = evalSrc(
+        "linear_extrude(5) union() { color(\"red\") square(10); color(\"blue\") translate([12,0]) square(10); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_FALSE(e.bodies[0].color.has_value());
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-6);
+}