openscad-cpp-evaluator 1.7.2__tar.gz → 1.8.0__tar.gz

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.8.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.8.0}/bindings/module.cpp

@@ -357,7 +357,7 @@ struct Geometry {
 // exportModel, with the path/format/warnings marshalling. Releases the GIL:
 // a large export is seconds of Manifold work with no Python involved.
 nb::list exportModelPy(const std::string& path, const Geometry& geom, const std::string& format, bool asciiStl,
-                        bool stripSlivers) {
+                        bool stripSlivers, bool splitComponents) {
     std::vector<std::string> warnings;
     {
         nb::gil_scoped_release rel;
@@ -365,6 +365,7 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
         opts.format = format;
         opts.asciiStl = asciiStl;
         opts.stripSlivers = stripSlivers;
+        opts.splitComponents = splitComponents;
         warnings = oscadeval::exportModel(path, geom.bodies, opts);
     }
     nb::list out;
@@ -786,10 +787,14 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
 
     m.def("export_model", &exportModelPy, nb::arg("path"), nb::arg("geometry"), nb::arg("format") = std::string(),
           nb::arg("ascii_stl") = false, nb::arg("strip_slivers") = true,
+          nb::arg("split_components") = false,
           "Write `geometry` to `path`, format taken from the extension unless `format` says otherwise. "
           "Returns the warnings to surface (open shells, mesh problems, slivers removed) rather than "
           "logging them. Raises RuntimeError when there is no geometry, the format is unknown, or the "
-          "file cannot be opened.");
+          "file cannot be opened.\n\n"
+          "`split_components` gives every disconnected piece its own object in the multi-object formats "
+          "(3MF, AMF, OBJ, PLY, VRML, X3D). Off by default, matching OpenSCAD, which writes one object "
+          "per colour however many pieces it is in.");
 
     m.def("export_extensions", []() { return oscadeval::exportExtensions(); },
           "The file extensions export_model understands, dot-prefixed. Read from the C++ writer table "

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.8.0}/include/openscad_cpp_evaluator/export.hpp

@@ -39,13 +39,21 @@ struct ExportObject {
 //      `color("red") body(); color("blue") detail();` leaves the detail
 //      whole. Only the invisible interior is affected: the visible surface
 //      is identical either way.
-//   3. One object per connected component.
+//   3. One object per connected component -- OPTIONAL, and off by default.
+//      Rules 1 and 2 are about correctness; this one is presentation, and
+//      it is the one that diverges from OpenSCAD, which writes a single
+//      object however many disjoint pieces the model has. Splitting turned
+//      `cube(10); translate([20,0,0]) cube(10);` into two 3MF objects and a
+//      multiboard tile into hundreds, which slicers list individually and
+//      Prusa Slicer complains about (issue #319). Ask for it when separate
+//      pieces are what you want; leave it off to match OpenSCAD.
 //
 // 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.
 std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies,
-                                                std::vector<int>* openParts = nullptr);
+                                                std::vector<int>* openParts = nullptr,
+                                                bool splitComponents = false);
 
 // Writes a binary STL: composes every body's mesh into one solid (bodies
 // with no `.body` -- 2D-only sections -- or an empty Manifold are
@@ -130,6 +138,12 @@ struct ExportOptions {
     // break no topology, but slicers commonly discard them and are then
     // left with the holes their removal opens.
     bool stripSlivers = true;
+    // Rule 3 of splitBodiesForExport: give every disconnected piece its own
+    // object in the multi-object formats (3MF, AMF, OBJ, PLY, VRML, X3D).
+    // Off matches OpenSCAD, which writes one object per colour however many
+    // pieces it is in; see that function's own comment for why the default
+    // moved here.
+    bool splitComponents = false;
 };
 
 // Writes `bodies` to `path`, choosing the writer from the extension (or

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.8.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.8.0}/python/openscad_cpp_evaluator/__init__.py

@@ -292,13 +292,13 @@ def strip_slivers(verts, tris):
 
 
 def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
-                 strip_slivers: bool = True) -> list:
+                 strip_slivers: bool = True, split_components: bool = False) -> list:
     """Write `geometry` to `path`. Returns the warnings to surface.
 
     `geometry` is the handle an Evaluator stashes on itself as
     `.geometry` -- the evaluated bodies, still on the C++ side. Export has
     to do real CSG (the implicit top-level union, the per-colour volume
-    claim, the connected-component split), and going through the flattened
+    claim), and going through the flattened
     arrays the renderer gets would mean rebuilding every Manifold first:
     ~146ms on a 224k-triangle model, and Manifold's own provenance lost
     along the way.
@@ -309,9 +309,13 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
     here refuses to write: a deliberately open surface is a legitimate
     export. Raises EvalError when there is no geometry, the format is
     unknown, or the file cannot be opened.
+
+    `split_components` gives every disconnected piece its own object in the
+    multi-object formats. Off by default, which is what OpenSCAD writes.
     """
     try:
-        return list(_ext.export_model(path, geometry, format, ascii_stl, strip_slivers))
+        return list(_ext.export_model(path, geometry, format, ascii_stl, strip_slivers,
+                                       split_components))
     except Exception as e:
         raise EvalError(str(e)) from e
 

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.8.0}/src/export.cpp

@@ -418,7 +418,8 @@ std::vector<std::array<float, 4>> carryTriColors(const std::vector<std::array<fl
 
 } // namespace
 
-std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies, std::vector<int>* openParts) {
+std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies, std::vector<int>* openParts,
+                                                bool splitComponents) {
     struct Solid {
         manifold::Manifold man;
         std::optional<std::array<float, 4>> color;
@@ -545,9 +546,12 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
 
     std::vector<ExportObject> out;
     for (const Claimed& g : claimedGroups) {
-        // Decompose() is the rule-3 split. A single-component solid comes
-        // back as a one-element list, so there is no special case here.
-        std::vector<manifold::Manifold> parts = g.man.Decompose();
+        // Decompose() is the rule-3 split, and it is opt-in: without it this
+        // colour group stays one object however many disjoint pieces it is
+        // in, which is what OpenSCAD writes. A single-component solid comes
+        // back as a one-element list either way, so there is no special case.
+        std::vector<manifold::Manifold> parts;
+        if (splitComponents) parts = g.man.Decompose();
         if (parts.empty()) parts.push_back(g.man);
         for (const manifold::Manifold& part : parts) {
             if (part.IsEmpty()) continue;
@@ -1022,7 +1026,7 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
         // its own -- that is what the file contains.
         for (std::string& w : checkExportBodies(bodies)) warnings.push_back(std::move(w));
         std::vector<int> openParts;
-        const std::vector<ExportObject> objects = splitBodiesForExport(bodies, &openParts);
+        const std::vector<ExportObject> objects = splitBodiesForExport(bodies, &openParts, opts.splitComponents);
         reportOpen(openParts);
         if (objects.empty()) throw std::runtime_error("No geometry to export");
         if (ext == ".3mf") {

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.8.0}/tests/test_export.cpp

@@ -163,10 +163,16 @@ TEST(ExportAmf, WritesOneObjectAndOneMaterialPerColour) {
 }
 
 TEST(ExportAmf, TwoObjectsSharingAColourShareOneMaterial) {
+    // splitComponents, because two objects is the premise: same-coloured
+    // disjoint pieces are ONE object by default (see the DisjointPieces
+    // tests below). What is under test here is that the two of them share a
+    // single material entry rather than each declaring their own.
     std::vector<ColoredBody> bodies =
         evalToBodies("color(\"red\") cube(2); translate([10,0,0]) color(\"red\") cube(2);");
     const std::string path = tempPath("shared.amf").string();
-    exportModel(path, bodies, ExportOptions{});
+    ExportOptions opts;
+    opts.splitComponents = true;
+    exportModel(path, bodies, opts);
 
     const std::string xml = readFile(path);
     EXPECT_EQ(countOf(xml, "<object id="), 2u);
@@ -174,6 +180,50 @@ TEST(ExportAmf, TwoObjectsSharingAColourShareOneMaterial) {
     std::remove(path.c_str());
 }
 
+// Issue #319: a model in several disconnected pieces was written as one
+// object PER PIECE, so a slicer listed them individually -- hundreds of
+// entries for a multiboard tile, and Prusa Slicer objecting. OpenSCAD writes
+// one object, and so does this by default now; the split is still available
+// for callers that want the pieces apart.
+TEST(ExportSplit, DisjointPiecesAreOneObjectByDefault) {
+    std::vector<ColoredBody> bodies =
+        evalToBodies("cube(10); translate([20,0,0]) cube(10); translate([40,0,0]) cube(10);");
+    const std::string path = tempPath("joined.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 1u);
+    EXPECT_EQ(countOf(xml, "<volume"), 1u);
+    std::remove(path.c_str());
+}
+
+TEST(ExportSplit, DisjointPiecesSplitWhenAsked) {
+    std::vector<ColoredBody> bodies =
+        evalToBodies("cube(10); translate([20,0,0]) cube(10); translate([40,0,0]) cube(10);");
+    const std::string path = tempPath("split.amf").string();
+    ExportOptions opts;
+    opts.splitComponents = true;
+    exportModel(path, bodies, opts);
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 3u);
+    std::remove(path.c_str());
+}
+
+// Rule 2 is not what became optional: differently-coloured solids must stay
+// separate objects either way, or a multi-material export loses its colours.
+TEST(ExportSplit, ColoursStayApartWithTheSplitOff) {
+    std::vector<ColoredBody> bodies =
+        evalToBodies("color(\"red\") cube(10); translate([20,0,0]) color(\"blue\") cube(10);");
+    const std::string path = tempPath("colours.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 2u);
+    EXPECT_EQ(countOf(xml, "<material id="), 2u);
+    std::remove(path.c_str());
+}
+
 TEST(ExportAmf, MaterialAndObjectIdsStartAtOne) {
     // id 0 is reserved by the spec; a reader may drop anything using it.
     std::vector<ColoredBody> bodies = evalToBodies("cube(2);");

{openscad_cpp_evaluator-1.7.2 → openscad_cpp_evaluator-1.8.0}/tests/test_python_bindings.py

@@ -633,3 +633,29 @@ def test_degenerate_ranges_do_not_overflow_the_element_count(tmp_path):
     # Silent for NaN; the unbounded pair warn, with the reference's number.
     assert len(warnings) == 2, warnings
     assert all("too many elements (4294967295)" in w for w in warnings), warnings
+
+
+def test_export_model_facade_accepts_split_components(tmp_path):
+    """The Python facade's signature must track the nanobind binding's.
+
+    They are two hand-written parameter lists for one call, and adding
+    `split_components` to the binding alone left the facade dropping it --
+    a TypeError the C++ suite cannot see, because it never goes through
+    Python. Caught in practice, hence this.
+    """
+    from openscad_cpp_evaluator import Evaluator, export_model
+
+    src = tmp_path / "pieces.scad"
+    src.write_text("cube(10); translate([20,0,0]) cube(10); translate([40,0,0]) cube(10);")
+    ev = Evaluator()
+    ev.evaluate(str(src), {})
+
+    def objects_in(path, **kwargs):
+        export_model(str(path), ev.geometry, **kwargs)
+        import zipfile
+        with zipfile.ZipFile(path) as z:
+            return z.read("3D/3dmodel.model").decode().count("<object ")
+
+    # Default matches OpenSCAD: one object however many pieces.
+    assert objects_in(tmp_path / "joined.3mf") == 1
+    assert objects_in(tmp_path / "split.3mf", split_components=True) == 3