openscad-cpp-evaluator 0.45.1__tar.gz → 0.46.0__tar.gz

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.46.0}/CLAUDE.md

@@ -711,8 +711,17 @@ grep for `ponytail:`.
   — skip it and the mesh comes out non-manifold at the seam). Self-contained 2D geometry math here
   (`dot2`/`len2`/`norm2`, the parabola-canonical-frame rotation in `discretizeArc`) exists nowhere
   else in this codebase.
-- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — binary STL, OBJ, OFF, and 3MF
-  writers (compose every body into one solid first; 3MF via `zip_stored.hpp`'s `writeDeflateZip`).
+- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all eight
+  formats `exportExtensions()` lists: 3MF, AMF, STL, OBJ, OFF, PLY, VRML, X3D (3MF via
+  `zip_stored.hpp`'s `writeDeflateZip`). **`exportExtensions()` is the one source of truth for
+  which formats exist** — the Python facade and BelfrySCAD's dialog/CLI all ask it rather than
+  restating the list, because three hand-written copies had already drifted far enough that `.off`
+  could be written by neither the GUI nor the CLI while every test passed.
+  Colour is carried by 3MF, AMF, OBJ (companion `.mtl`), PLY, VRML and X3D; STL and OFF compose
+  every body into one solid and store geometry only. **AMF** puts colour on the `<volume>` rather
+  than the face, so an object whose triangles are not all one colour is written as one volume per
+  colour — per-triangle `<color>` is legal in the spec but poorly supported by the slicers that are
+  the audience for it.
   `colored_body.hpp`/`.cpp`'s `toRenderableBodies()` (thin-extrudes any top-level 2D-only result to
   a 1e-3-unit-tall `flatPreview` Manifold) must run on a body list before handing it to any of these
   writers — none of them look at `ColoredBody::section` at all, only `.body`. `tools/cli/cli_lib.cpp`

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.46.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.46.0}/bindings/module.cpp

@@ -786,6 +786,10 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "logging them. Raises RuntimeError when there is no geometry, the format is unknown, or the "
           "file cannot be opened.");
 
+    m.def("export_extensions", []() { return oscadeval::exportExtensions(); },
+          "The file extensions export_model understands, dot-prefixed. Read from the C++ writer table "
+          "rather than restated here, so the Python side cannot drift from what can actually be written.");
+
     m.def("evaluate", &evaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("manifold_cache") = nullptr,
           nb::arg("profile") = false,
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).");

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.46.0}/include/openscad_cpp_evaluator/export.hpp

@@ -97,6 +97,13 @@ void writeVrml(const std::string& path, const std::vector<ExportObject>& objects
 // Color) and Shape level 1 (Appearance, Material), exactly the nodes used.
 void writeX3d(const std::string& path, const std::vector<ExportObject>& objects);
 
+// AMF 1.1. XML like X3D, but its colour lives on the <volume>, not the
+// face: a mesh holds one vertex list and one <volume> per material. An
+// object whose triangles are not all one colour therefore becomes several
+// volumes -- which is what a multimaterial slicer reads as separate
+// materials to assign to tools.
+void writeAmf(const std::string& path, const std::vector<ExportObject>& objects);
+
 // OFF (Object File Format): header "OFF", "$verts $tris 0", vertex lines,
 // then "3 i j k" per triangle (0-indexed, count-prefixed). Mirrors
 // export.py's write_off.

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.46.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.46.0}/python/openscad_cpp_evaluator/__init__.py

@@ -315,8 +315,14 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
 
 
 def export_extensions() -> list:
-    """The file extensions export_model understands, dot-prefixed."""
-    return [".3mf", ".stl", ".obj", ".off", ".ply", ".wrl", ".x3d"]
+    """The file extensions export_model understands, dot-prefixed.
+
+    Asked of the extension rather than restated here. The hardcoded copy
+    this replaces had already drifted: it was missing formats the C++
+    writer table had gained, and nothing failed -- callers simply could
+    not reach them.
+    """
+    return list(_ext.export_extensions())
 
 
 def check_mesh(verts, tris) -> dict:

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.46.0}/src/export.cpp

@@ -764,6 +764,91 @@ void writeX3d(const std::string& path, const std::vector<ExportObject>& objects)
     out << "  </Scene>\n</X3D>\n";
 }
 
+// AMF is XML like X3D, but its colour model is per-VOLUME rather than
+// per-face: a mesh carries one <vertices> list and any number of <volume>
+// blocks, each naming a material. So an object whose triangles are not all
+// one colour is written as one volume per distinct colour -- <color> on an
+// individual <triangle> is legal but far less widely read, and slicers are
+// the audience here.
+//
+// Material and object ids start at 1; id 0 is reserved by the spec.
+// The material table is global, so two objects sharing a colour share one
+// material entry rather than each declaring its own.
+void writeAmf(const std::string& path, const std::vector<ExportObject>& objects) {
+    std::ofstream out(path);
+    if (!out) throw std::runtime_error("Could not open '" + path + "' for writing");
+
+    std::vector<std::array<float, 4>> materials;
+    const auto materialFor = [&](const std::array<float, 4>& c) -> size_t {
+        for (size_t i = 0; i < materials.size(); ++i) {
+            if (materials[i] == c) return i + 1;
+        }
+        materials.push_back(c);
+        return materials.size();
+    };
+
+    struct Volume {
+        size_t material = 1;
+        std::vector<uint32_t> tris;
+    };
+    std::vector<std::vector<Volume>> perObject;
+    perObject.reserve(objects.size());
+    for (const ExportObject& o : objects) {
+        const FaceColors fc = faceColors(o);
+        std::vector<Volume> vols;
+        if (fc.palette.empty()) {
+            Volume v;
+            v.material = materialFor(o.color);
+            v.tris = o.tris;
+            vols.push_back(std::move(v));
+        } else {
+            vols.resize(fc.palette.size());
+            for (size_t i = 0; i < fc.palette.size(); ++i) vols[i].material = materialFor(fc.palette[i]);
+            for (size_t t = 0; t < o.tris.size() / 3; ++t) {
+                std::vector<uint32_t>& dst = vols[fc.index[t]].tris;
+                dst.push_back(o.tris[t * 3]);
+                dst.push_back(o.tris[t * 3 + 1]);
+                dst.push_back(o.tris[t * 3 + 2]);
+            }
+        }
+        perObject.push_back(std::move(vols));
+    }
+
+    out << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+    out << "<amf unit=\"millimeter\" version=\"1.1\">\n";
+    out << "  <metadata type=\"cad\">BelfrySCAD</metadata>\n";
+    for (size_t i = 0; i < materials.size(); ++i) {
+        const std::array<float, 4>& c = materials[i];
+        out << "  <material id=\"" << (i + 1) << "\">\n";
+        out << "    <color><r>" << formatG6(c[0]) << "</r><g>" << formatG6(c[1]) << "</g><b>"
+            << formatG6(c[2]) << "</b>";
+        if (c[3] < 1.0f) out << "<a>" << formatG6(c[3]) << "</a>";
+        out << "</color>\n";
+        out << "  </material>\n";
+    }
+    for (size_t oi = 0; oi < objects.size(); ++oi) {
+        const ExportObject& o = objects[oi];
+        out << "  <object id=\"" << (oi + 1) << "\">\n    <mesh>\n      <vertices>\n";
+        for (size_t v = 0; v < o.verts.size() / 3; ++v) {
+            out << "        <vertex><coordinates><x>" << formatG6(o.verts[v * 3]) << "</x><y>"
+                << formatG6(o.verts[v * 3 + 1]) << "</y><z>" << formatG6(o.verts[v * 3 + 2])
+                << "</z></coordinates></vertex>\n";
+        }
+        out << "      </vertices>\n";
+        for (const Volume& vol : perObject[oi]) {
+            if (vol.tris.empty()) continue;
+            out << "      <volume materialid=\"" << vol.material << "\">\n";
+            for (size_t t = 0; t < vol.tris.size() / 3; ++t) {
+                out << "        <triangle><v1>" << vol.tris[t * 3] << "</v1><v2>" << vol.tris[t * 3 + 1]
+                    << "</v2><v3>" << vol.tris[t * 3 + 2] << "</v3></triangle>\n";
+            }
+            out << "      </volume>\n";
+        }
+        out << "    </mesh>\n  </object>\n";
+    }
+    out << "</amf>\n";
+}
+
 
 // -- one entry point ------------------------------------------------------
 
@@ -779,7 +864,7 @@ std::string lowerExtension(const std::string& path) {
 }
 
 bool isMultiObject(const std::string& ext) {
-    return ext == ".3mf" || ext == ".obj" || ext == ".ply" || ext == ".wrl" || ext == ".x3d";
+    return ext == ".3mf" || ext == ".amf" || ext == ".obj" || ext == ".ply" || ext == ".wrl" || ext == ".x3d";
 }
 
 // The merged single mesh STL/OFF write, with the open shells kept.
@@ -898,7 +983,7 @@ void writeOffMesh(const std::string& path, const manifold::MeshGL& mesh) {
 } // namespace
 
 const std::vector<std::string>& exportExtensions() {
-    static const std::vector<std::string> exts = {".3mf", ".stl", ".obj", ".off", ".ply", ".wrl", ".x3d"};
+    static const std::vector<std::string> exts = {".3mf", ".amf", ".stl", ".obj", ".off", ".ply", ".wrl", ".x3d"};
     return exts;
 }
 
@@ -929,6 +1014,8 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
         if (objects.empty()) throw std::runtime_error("No geometry to export");
         if (ext == ".3mf") {
             writeThreeMf(path, objects);
+        } else if (ext == ".amf") {
+            writeAmf(path, objects);
         } else if (ext == ".obj") {
             writeObj(path, objects);
         } else if (ext == ".ply") {

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.46.0}/tests/test_export.cpp

@@ -121,3 +121,88 @@ TEST(ToRenderableBodies, A3dBodyPassesThroughUnchanged) {
     EXPECT_FALSE(renderable[0].flatPreview);
     EXPECT_NEAR(renderable[0].body->Volume(), 8.0, 1e-9);
 }
+
+// -- AMF -------------------------------------------------------------------
+
+namespace {
+
+std::string readFile(const std::string& path) {
+    std::ifstream in(path);
+    return std::string((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+}
+
+size_t countOf(const std::string& hay, const std::string& needle) {
+    size_t n = 0, at = 0;
+    while ((at = hay.find(needle, at)) != std::string::npos) { ++n; at += needle.size(); }
+    return n;
+}
+
+} // namespace
+
+TEST(ExportAmf, IsAnOfferedFormat) {
+    const std::vector<std::string>& exts = exportExtensions();
+    EXPECT_NE(std::find(exts.begin(), exts.end(), ".amf"), exts.end());
+}
+
+TEST(ExportAmf, WritesOneObjectAndOneMaterialPerColour) {
+    // Two separated cubes, different colours: two objects, two materials.
+    std::vector<ColoredBody> bodies =
+        evalToBodies("color(\"red\") cube(2); translate([10,0,0]) color(\"blue\") cube(2);");
+    const std::string path = tempPath("two.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);
+    // 12 triangles per cube, and every one lands in some volume.
+    EXPECT_EQ(countOf(xml, "<triangle>"), 24u);
+    EXPECT_NE(xml.find("<amf unit=\"millimeter\""), std::string::npos);
+    std::remove(path.c_str());
+}
+
+TEST(ExportAmf, TwoObjectsSharingAColourShareOneMaterial) {
+    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{});
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 2u);
+    EXPECT_EQ(countOf(xml, "<material id="), 1u);
+    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);");
+    const std::string path = tempPath("ids.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_NE(xml.find("<material id=\"1\">"), std::string::npos);
+    EXPECT_NE(xml.find("<object id=\"1\">"), std::string::npos);
+    EXPECT_EQ(xml.find("id=\"0\""), std::string::npos);
+    std::remove(path.c_str());
+}
+
+TEST(ExportAmf, NoGeometryThrows) {
+    std::vector<ColoredBody> empty;
+    EXPECT_THROW(exportModel(tempPath("empty.amf").string(), empty, ExportOptions{}), std::runtime_error);
+}
+
+TEST(ExportAmf, AMultiColouredObjectBecomesOneVolumePerColour) {
+    // A union welds these into ONE solid whose surface carries two colours.
+    // AMF has no per-face colour that slicers read reliably, so the object
+    // is written as one <volume> per colour -- which is exactly what a
+    // multimaterial slicer assigns to separate tools.
+    std::vector<ColoredBody> bodies = evalToBodies(
+        "union() { color(\"red\") cube(20); color(\"blue\") translate([10,5,5]) cube(20); }");
+    const std::string path = tempPath("multi.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 1u);
+    EXPECT_EQ(countOf(xml, "<volume materialid="), 2u);
+    EXPECT_EQ(countOf(xml, "<material id="), 2u);
+    std::remove(path.c_str());
+}