openscad-cpp-evaluator 1.45.2__tar.gz → 1.46.0__tar.gz

{openscad_cpp_evaluator-1.45.2 → openscad_cpp_evaluator-1.46.0}/CLAUDE.md

@@ -601,6 +601,11 @@ grep for `ponytail:`.
   One `LevelSet` pass either way; a bounded range *could* be
   `difference(levelset(hi), levelset(lo))` but that meshes twice and then booleans.
   3D wraps `Manifold::LevelSet` with a C++ sampling lambda; no new Manifold API.
+  **`edge` may be a vector**, one spacing per axis (`[ex,ey,ez]`, or `[ex,ey]` in 2D), as BOSL2's
+  `isosurface()` takes `voxel_size`. `LevelSet` takes one edge length, so the 3D path meshes the
+  field squashed to unit spacing and `Scale`s the result back -- exact, since with tolerance -1 a
+  vertex is a linear interpolation along a lattice edge, which commutes with an axis scale. A plain
+  number takes the old path unchanged. `supported_feature("levelset")` is **2** from this change.
   **The field is a grid OR a `function(x,y,z)`, and the two trade off against each other** —
   neither is simply better:
 
@@ -1237,8 +1242,20 @@ grep for `ponytail:`.
   `text_metrics.hpp`'s `measureText`/`textAlignOffset` plus `Evaluator::fontProvider()`) are
   implemented here too.
 - `include/openscad_cpp_evaluator/mesh_import.hpp`, `src/import/mesh_import.cpp` — STL (ASCII +
-  binary, exact-match vertex welding)/OBJ/OFF/3MF mesh loaders, returning plain `(verts, tris)` —
-  no `Evaluator`/`Value` dependency, so these are reusable from both `import()` contexts below.
+  binary)/OBJ/OFF/3MF mesh loaders, returning plain `(verts, tris)` — no `Evaluator`/`Value`
+  dependency, so these are reusable from both `import()` contexts below. **Every mesh loader welds
+  vertices at exactly the same position** (`weldVertices`, or `appendWelded` for one object of
+  many), so a closed solid written as a triangle soup or with a duplicated vertex list imports
+  closed. The granularity is OpenSCAD 2026.02.01's, checked by running it: the **whole file** for
+  STL, OBJ (across `o`/`g` groups -- two cube halves in separate `o` groups with their own vertex
+  copies import as one closed cube) and OFF (one mesh); **each object** for 3MF and AMF (two open
+  halves in separate objects stay open; OpenSCAD reports each not closed). OpenSCAD welds OBJ at
+  import, but OFF and single-object 3MF only when the mesh becomes a solid (a lone import exported
+  there keeps the raw soup) -- welding at import gives the same solid. Exact positions only: the
+  near-coincident soups (1e-9, 1e-7) OpenSCAD closes through its "repair and reconstruct" fallback
+  stay open here without `repair=true`. `weldVertices` also rejects a face index past the vertex
+  list (OBJ/3MF used to hand one to Manifold unchecked). The 3MF reader skips `<triangles>`, which
+  its `<triangle` search used to read as one degenerate triangle per mesh.
 - `src/import/scene_import.cpp` — AMF, X3D and VRML97 import, the three multi-object formats export
   writes that nothing could read back (current upstream OpenSCAD removed its AMF importer, so all
   three go beyond it). Geometry only, like the loaders above, but each format's scene structure is
@@ -1246,12 +1263,23 @@ grep for `ponytail:`.
   resolves, `ccw FALSE` flips winding, `IndexedFaceSet` polygons fan-triangulate (a last polygon
   without `-1` counts), and X3D's `IndexedTriangleSet`/`TriangleSet` are read. X3D goes through a
   small real XML parser (comments, CDATA, DOCTYPE, entities); VRML through a tokenizer + generic
-  node parser that steps over `PROTO`/`EXTERNPROTO`/`ROUTE` (VRML 1.0 is refused by name). AMF's
+  node parser that steps over `PROTO`/`EXTERNPROTO` declarations and `ROUTE` (VRML 1.0 is refused by
+  name). AMF's
   `unit` is ignored (OpenSCAD reads millimetres whatever it says), a zipped AMF (`PK` header) is read
   through `readStoredZipEntryBySuffix`, and each AMF object's vertices are welded by exact position
-  (`weldVertices`, STL's), so a closed object written as a triangle soup imports closed, as in
-  OpenSCAD -- per object, never across objects, and never near-coincident vertices.
-  What is not a mesh — primitives (Box, Sphere, ...), `Inline`, AMF constellations — lands in
+  (`appendWelded`), so a closed object written as a triangle soup imports closed, as in
+  OpenSCAD -- per object, never across objects, and never near-coincident vertices. X3D and VRML,
+  which OpenSCAD cannot import, weld each Shape's geometry node the same way (in
+  `emitIndexedFaces`), matching AMF/3MF's per-object rule; a `USE`d Shape is a separate mesh.
+  `Switch` imports only its `whichChoice` child (VRML `choice[k]`, X3D's k-th child element;
+  nothing at -1, the spec default, or out of range) and `LOD` only its first level (VRML `level[0]`,
+  X3D's first child). Prototypes are **not expanded**, but no longer silently: X3D does not walk
+  `ProtoDeclare`/`ExternProtoDeclare` (a declaration's body is a template -- it used to be imported
+  once as plain geometry with `IS` ignored) and counts those and `ProtoInstance` as skipped; VRML
+  records every `PROTO`/`EXTERNPROTO` name and counts an instance of one as `PROTO instance`, without
+  walking its fields. Both reach the user as the usual `skipped what is not a mesh: ...` warning.
+  Expanding them (substituting `IS` fields into a copy of the body per instance) is still to do.
+  What is not imported — primitives (Box, Sphere, ...), `Inline`, prototypes, AMF constellations — lands in
   `LoadedMesh::warnings`, which both `import()` faces emit as `import: '<file>': ...`.
 - `include/openscad_cpp_evaluator/import_builtin.hpp`, `include/openscad_cpp_evaluator/
   zip_stored.hpp` (+ `src/zip_stored.cpp`), `src/builtins/import.cpp` — `import()`'s two faces:

{openscad_cpp_evaluator-1.45.2 → openscad_cpp_evaluator-1.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.45.2
+Version: 1.46.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT AND OFL-1.1

{openscad_cpp_evaluator-1.45.2 → openscad_cpp_evaluator-1.46.0}/include/openscad_cpp_evaluator/mesh_import.hpp

@@ -19,19 +19,29 @@ struct LoadedMesh {
 };
 
 // Each throws std::runtime_error with a message suitable for wrapping into
-// "import: {what}" on parse/IO failure. Mirrors _load_stl/_load_obj/
-// _load_off/_load_3mf exactly (including STL's exact-match vertex welding
-// and OBJ/OFF's fan triangulation of >3-gon faces).
-// Merges vertices at exactly equal positions (STL's corners, an AMF
-// object's duplicated vertices); every position keeps its first index.
+// "import: {what}" on parse/IO failure. OBJ/OFF fan-triangulate >3-gon faces.
+//
+// Every loader merges vertices at exactly the same position, at the
+// granularity OpenSCAD 2026.02.01 does (or, for X3D/VRML, which it cannot
+// import, the same as AMF): the whole file for STL, OBJ and OFF; each
+// object for 3MF and AMF; each Shape's geometry for X3D and VRML. Where the
+// unit is an object, two open halves in separate objects stay open (an
+// OBJ's `o` groups are not objects in this sense: OpenSCAD welds across
+// them). Near-coincident vertices are never merged.
+//
+// weldVertices merges exactly-equal positions; every position keeps its
+// first index. Throws on a face index past the vertex list.
 LoadedMesh weldVertices(const std::vector<std::array<double, 3>>& verts, const std::vector<std::array<int, 3>>& tris);
+// Welds `part` and appends it to `out`, keeping `out`'s earlier objects apart.
+void appendWelded(LoadedMesh& out, const LoadedMesh& part);
 LoadedMesh loadStl(const std::string& path);
 LoadedMesh loadObj(const std::string& path);
 LoadedMesh loadOff(const std::string& path);
 LoadedMesh loadThreeMf(const std::string& path);
 // scene_import.cpp: the three multi-object formats export writes. AMF (plain
-// or zipped, `unit` scaled to mm), X3D and VRML97 (Transforms applied,
-// DEF/USE resolved, polygons fan-triangulated). Geometry only, like the rest.
+// or zipped, `unit` ignored as OpenSCAD ignores it), X3D and VRML97
+// (Transforms applied, DEF/USE resolved, polygons fan-triangulated).
+// Geometry only, like the rest.
 LoadedMesh loadAmf(const std::string& path);
 LoadedMesh loadX3d(const std::string& path);
 LoadedMesh loadVrml(const std::string& path);

{openscad_cpp_evaluator-1.45.2 → openscad_cpp_evaluator-1.46.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.45.2 → openscad_cpp_evaluator-1.46.0}/src/builtins/function_builtins.cpp

@@ -976,9 +976,8 @@ namespace {
 // is supposed to be safe).
 //
 // A LEVEL rather than a boolean so a feature whose semantics change later
-// can be told apart from its earlier self. Everything here is 1 today;
-// nothing has changed since this function existed, and a script cannot
-// observe what a build without supported_feature() did anyway.
+// can be told apart from its earlier self. A script cannot observe what a
+// build without supported_feature() did, so every feature starts at 1.
 //
 // This is the answer to a real hazard: OpenSCAD does not reject arguments or
 // names it doesn't know -- children(separate=true) is silently ignored there
@@ -988,7 +987,7 @@ const std::unordered_map<std::string, double>& featureLevels() {
     static const std::unordered_map<std::string, double> levels = {
         {"render-expr", 1.0},        // render() in expression position
         {"linear-solve", 1.0},       // linear_solve(A, b) -> {x, det, singular}
-        {"levelset", 1.0},           // levelset(field, bounds, isovalue)
+        {"levelset", 2.0},           // levelset(field, bounds, isovalue); 2: edge may be a vector
         {"polyhedron-vnf", 1.0},     // polyhedron(vnf) / polyhedron(object)
         {"separate-children", 1.0},  // children(..., separate=true)
         {"minkowski-diff", 1.0},     // minkowski_difference()

{openscad_cpp_evaluator-1.45.2 → openscad_cpp_evaluator-1.46.0}/src/builtins/topology.cpp

@@ -991,11 +991,31 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
     const std::array<double, 3> origin = *lo;
     std::array<double, 3> spacing{1.0, 1.0, 1.0};
     double edge = 0.0;
+    // edge may also be one spacing per axis, as BOSL2's isosurface() takes
+    // voxel_size -- a thin plate wants fine sampling across it and coarse
+    // along it (#729 on BelfrySCAD). edgeV is then the vector and `edge`
+    // its smallest component; for a plain number edgeV is unused.
+    std::array<double, 3> edgeV{0.0, 0.0, 0.0};
+    bool edgeVec = false;
     // Grid spacing is filled in below, once the array has been read at the
     // right dimensionality. Finer than the grid buys nothing.
-    if (const double* e = std::get_if<double>(&params.at("edge"))) {
+    const Value& edgeArg = params.at("edge");
+    if (const double* e = std::get_if<double>(&edgeArg)) {
         if (*e > 0.0) edge = *e;
         else ev.warn("levelset(): edge must be positive", &node.position());
+    } else if (!std::holds_alternative<std::monostate>(edgeArg)) {
+        const std::optional<std::vector<double>> ev3 = numbersOrInf(edgeArg);
+        bool ok = ev3 && ev3->size() == bLo->size();
+        for (size_t a = 0; ok && a < ev3->size(); ++a) ok = std::isfinite((*ev3)[a]) && (*ev3)[a] > 0.0;
+        if (ok) {
+            edgeVec = true;
+            for (size_t a = 0; a < ev3->size(); ++a) edgeV[a] = (*ev3)[a];
+            edge = *std::min_element(ev3->begin(), ev3->end());
+        } else {
+            ev.warn(is2d ? "levelset(): edge must be a positive number or [ex, ey]"
+                         : "levelset(): edge must be a positive number or [ex, ey, ez]",
+                    &node.position());
+        }
     }
     if (edge <= 0.0 && fieldFn) {
         // No grid to infer it from. Guessing would silently pick either a
@@ -1060,8 +1080,9 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
             return out;
         }
         // function(x,y): edge= gives the spacing, as in 3D
-        nx = static_cast<size_t>(std::floor(((*bHi)[0] - (*bLo)[0]) / edge)) + 1;
-        ny = static_cast<size_t>(std::floor(((*bHi)[1] - (*bLo)[1]) / edge)) + 1;
+        const double ex = edgeVec ? edgeV[0] : edge, ey = edgeVec ? edgeV[1] : edge;
+        nx = static_cast<size_t>(std::floor(((*bHi)[0] - (*bLo)[0]) / ex)) + 1;
+        ny = static_cast<size_t>(std::floor(((*bHi)[1] - (*bLo)[1]) / ey)) + 1;
         if (nx < 2 || ny < 2) {
             ev.warn("levelset(): edge is larger than the bounds", &node.position());
             return {};
@@ -1114,7 +1135,9 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
         spacing = {((*bHi)[0] - (*bLo)[0]) / static_cast<double>(field->nx - 1),
                     ((*bHi)[1] - (*bLo)[1]) / static_cast<double>(field->ny - 1),
                     ((*bHi)[2] - (*bLo)[2]) / static_cast<double>(field->nz - 1)};
-        if (!std::get_if<double>(&params.at("edge"))) edge = std::min({spacing[0], spacing[1], spacing[2]});
+        // Also when edge= was given but unusable (warned above): edge 0
+        // would ask Manifold for an infinitely fine lattice.
+        if (edge <= 0.0) edge = std::min({spacing[0], spacing[1], spacing[2]});
     }
 
     if (fieldFn && fnParams2.size() < 3) {
@@ -1187,9 +1210,10 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
     //
     // Exactly the fix already applied to the 2D path (clipToBounds); it was
     // not applied here at the time because the 2D error was the one measured.
-    const double pad = 2.0 * edge;
-    manifold::Box bounds(manifold::vec3(origin[0] - pad, origin[1] - pad, origin[2] - pad),
-                          manifold::vec3((*hi)[0] + pad, (*hi)[1] + pad, (*hi)[2] + pad));
+    const manifold::vec3 E = edgeVec ? manifold::vec3(edgeV[0], edgeV[1], edgeV[2]) : manifold::vec3(edge);
+    const manifold::vec3 pad = 2.0 * E;
+    manifold::Box bounds(manifold::vec3(origin[0], origin[1], origin[2]) - pad,
+                          manifold::vec3((*hi)[0], (*hi)[1], (*hi)[2]) + pad);
     // tolerance -1: a positive value makes Manifold do EXTRA evaluations per
     // output vertex to snap nearer the true surface. Against a fixed grid
     // those only re-interpolate data already used -- cost, no information.
@@ -1199,9 +1223,24 @@ std::vector<ColoredBody> generateLevelSet(Evaluator& ev, const CSGParams& params
     // C++, and NOT safe for a function, which re-enters the evaluator.
     // Manifold: parallel policies "will crash language runtimes with runtime
     // locks that expect to not be called back by unregistered threads".
-    manifold::Manifold solid =
-        fieldFn ? manifold::Manifold::LevelSet(sampleFn, bounds, edge, 0.0, -1.0, /*canParallel=*/false)
-                 : manifold::Manifold::LevelSet(sampleGrid, bounds, edge, 0.0, -1.0, /*canParallel=*/true);
+    //
+    // LevelSet takes a single edge length, so a per-axis edge meshes a field
+    // squashed to unit spacing on every axis and stretches the result back.
+    // Exact, not an approximation: with tolerance -1 a vertex is a linear
+    // interpolation along a lattice edge, and a linear interpolation commutes
+    // with an axis scale.
+    manifold::Manifold solid;
+    if (!edgeVec) {
+        solid = fieldFn ? manifold::Manifold::LevelSet(sampleFn, bounds, edge, 0.0, -1.0, /*canParallel=*/false)
+                        : manifold::Manifold::LevelSet(sampleGrid, bounds, edge, 0.0, -1.0, /*canParallel=*/true);
+    } else {
+        const manifold::Box unit(bounds.min / E, bounds.max / E);
+        solid = fieldFn ? manifold::Manifold::LevelSet([&](manifold::vec3 q) { return sampleFn(q * E); },
+                                                       unit, 1.0, 0.0, -1.0, /*canParallel=*/false)
+                        : manifold::Manifold::LevelSet([&](manifold::vec3 q) { return sampleGrid(q * E); },
+                                                       unit, 1.0, 0.0, -1.0, /*canParallel=*/true);
+        solid = solid.Scale(E);
+    }
 
     if (solid.IsEmpty()) return {};
     solid = solid ^ manifold::Manifold::Cube(

{openscad_cpp_evaluator-1.45.2 → openscad_cpp_evaluator-1.46.0}/src/import/mesh_import.cpp

@@ -3,6 +3,7 @@
 #include "openscad_cpp_evaluator/zip_stored.hpp"
 
 #include <algorithm>
+#include <cctype>
 #include <cstdint>
 #include <cstring>
 #include <fstream>
@@ -69,9 +70,10 @@ std::string attrValue(std::string_view tag, std::string_view attrName) {
 
 } // namespace
 
-// Exact-match vertex welding (STL has no shared-index concept; each
-// triangle carries its own private corner copies) -- matches
-// _weld_stl_vertices's np.unique(axis=0) exact-equality behavior.
+// Exact-match vertex welding: every position keeps its first index. Only
+// bit-identical coordinates merge; near-coincident ones stay apart (that is
+// repair=true's job). A face index past the vertex list is an error here
+// rather than a bad read.
 LoadedMesh weldVertices(const std::vector<std::array<double, 3>>& verts, const std::vector<std::array<int, 3>>& tris) {
     std::map<std::array<double, 3>, int> seen;
     LoadedMesh out;
@@ -87,11 +89,24 @@ LoadedMesh weldVertices(const std::vector<std::array<double, 3>>& verts, const s
             remap[i] = idx;
         }
     }
+    const auto at = [&](int i) {
+        if (i < 0 || static_cast<size_t>(i) >= verts.size())
+            throw std::runtime_error("face index " + std::to_string(i) + " is past its " + std::to_string(verts.size()) +
+                                     " vertices");
+        return remap[static_cast<size_t>(i)];
+    };
     out.tris.reserve(tris.size());
-    for (const auto& t : tris) out.tris.push_back({remap[t[0]], remap[t[1]], remap[t[2]]});
+    for (const auto& t : tris) out.tris.push_back({at(t[0]), at(t[1]), at(t[2])});
     return out;
 }
 
+void appendWelded(LoadedMesh& out, const LoadedMesh& part) {
+    const LoadedMesh w = weldVertices(part.verts, part.tris);
+    const int base = static_cast<int>(out.verts.size());
+    out.verts.insert(out.verts.end(), w.verts.begin(), w.verts.end());
+    for (const auto& t : w.tris) out.tris.push_back({base + t[0], base + t[1], base + t[2]});
+}
+
 LoadedMesh loadStl(const std::string& path) {
     const std::vector<uint8_t> bytes = readWholeFile(path);
     // OpenSCAD's wording for every file it cannot read as STL.
@@ -162,7 +177,11 @@ LoadedMesh loadObj(const std::string& path) {
             for (size_t i = 1; i + 1 < idx.size(); ++i) out.tris.push_back({idx[0], idx[i], idx[i + 1]});
         }
     }
-    return out;
+    // OpenSCAD welds an OBJ's exactly-equal vertices across the whole file,
+    // `o`/`g` boundaries included (checked, 2026.02.01: two halves of a cube
+    // in separate `o` objects, each with its own vertex copies, import as
+    // one closed cube).
+    return weldVertices(out.verts, out.tris);
 }
 
 LoadedMesh loadOff(const std::string& path) {
@@ -231,7 +250,10 @@ LoadedMesh loadOff(const std::string& path) {
         }
         for (int k = 1; k + 1 < cnt; ++k) out.tris.push_back({faceIdx[0], faceIdx[static_cast<size_t>(k)], faceIdx[static_cast<size_t>(k) + 1]});
     }
-    return out;
+    // An OFF is one mesh, and OpenSCAD merges its exactly-equal vertices
+    // when the mesh becomes a solid (checked, 2026.02.01: a triangle soup
+    // or a duplicated vertex list takes part in CSG as a closed solid).
+    return weldVertices(out.verts, out.tris);
 }
 
 LoadedMesh loadThreeMf(const std::string& path) {
@@ -248,26 +270,33 @@ LoadedMesh loadThreeMf(const std::string& path) {
         const std::string_view segment(xml.data() + meshStart, meshEnd - meshStart);
         searchPos = meshEnd + 7;
 
-        const int base = static_cast<int>(out.verts.size());
+        LoadedMesh obj;
         for (size_t p = 0;;) {
             const size_t vStart = segment.find("<vertex", p);
             if (vStart == std::string_view::npos) break;
             const size_t vEnd = segment.find('>', vStart);
             if (vEnd == std::string_view::npos) break;
             const std::string_view tag = segment.substr(vStart, vEnd - vStart + 1);
-            out.verts.push_back({std::stod(attrValue(tag, "x")), std::stod(attrValue(tag, "y")), std::stod(attrValue(tag, "z"))});
+            obj.verts.push_back({std::stod(attrValue(tag, "x")), std::stod(attrValue(tag, "y")), std::stod(attrValue(tag, "z"))});
             p = vEnd + 1;
         }
         for (size_t p = 0;;) {
             const size_t tStart = segment.find("<triangle", p);
             if (tStart == std::string_view::npos) break;
+            if (tStart + 9 < segment.size() && std::isalpha(static_cast<unsigned char>(segment[tStart + 9]))) {  // <triangles>, not a triangle
+                p = tStart + 9;
+                continue;
+            }
             const size_t tEnd = segment.find('>', tStart);
             if (tEnd == std::string_view::npos) break;
             const std::string_view tag = segment.substr(tStart, tEnd - tStart + 1);
-            out.tris.push_back({base + std::stoi(attrValue(tag, "v1")), base + std::stoi(attrValue(tag, "v2")),
-                                 base + std::stoi(attrValue(tag, "v3"))});
+            obj.tris.push_back({std::stoi(attrValue(tag, "v1")), std::stoi(attrValue(tag, "v2")), std::stoi(attrValue(tag, "v3"))});
             p = tEnd + 1;
         }
+        // Welded per object, as OpenSCAD makes each 3MF object a solid on
+        // its own (checked, 2026.02.01): a soup object closes, but two open
+        // halves in separate objects stay open.
+        appendWelded(out, obj);
     }
     return out;
 }

{openscad_cpp_evaluator-1.45.2 → openscad_cpp_evaluator-1.46.0}/src/import/scene_import.cpp

@@ -5,11 +5,24 @@
 // through import()). Each format's scene structure IS honoured, though:
 // X3D/VRML Transforms (translation, rotation, scale, center,
 // scaleOrientation) nest and apply, DEF/USE reuse resolves, `ccw FALSE`
-// flips winding, and polygons are fan-triangulated. AMF's `unit` scales to
-// millimetres, and a zipped AMF is read like 3MF.
+// flips winding, and polygons are fan-triangulated. AMF's `unit` is
+// ignored, as OpenSCAD ignores it (its numbers are read as millimetres),
+// and a zipped AMF is read like 3MF.
+//
+// Vertices at exactly the same position are merged (weldVertices) within
+// each AMF object and within each X3D/VRML Shape's geometry, never across
+// them -- so a closed object written as a triangle soup imports closed, and
+// two open halves in separate objects stay open. AMF's granularity is
+// OpenSCAD's (checked, 2026.02.01); OpenSCAD cannot import X3D or VRML, so
+// theirs follows AMF and 3MF, where each object is a solid on its own.
+//
+// Switch imports only its whichChoice child (none at the default -1) and
+// LOD only its first level.
 //
 // What is skipped says so, through LoadedMesh::warnings: X3D/VRML
-// primitives (Box, Sphere, ...), Inline references, and AMF constellations.
+// primitives (Box, Sphere, ...), Inline references, prototypes (not
+// expanded: X3D ProtoDeclare/ExternProtoDeclare/ProtoInstance, VRML
+// instances of a PROTO/EXTERNPROTO type), and AMF constellations.
 // None of them is a mesh, and inventing one would be a different model from
 // the file.
 #include "openscad_cpp_evaluator/mesh_import.hpp"
@@ -143,14 +156,14 @@ Mat transformNode(const std::vector<double>& t, const std::vector<double>& r, co
 void emitIndexedFaces(LoadedMesh& out, const std::vector<double>& points, const std::vector<double>& index,
                       const Mat& m, bool ccw, const std::string& what) {
     const int n = static_cast<int>(points.size() / 3);
-    const int base = static_cast<int>(out.verts.size());
-    for (int i = 0; i < n; ++i) out.verts.push_back(apply(m, points[i * 3], points[i * 3 + 1], points[i * 3 + 2]));
+    LoadedMesh part;
+    for (int i = 0; i < n; ++i) part.verts.push_back(apply(m, points[i * 3], points[i * 3 + 1], points[i * 3 + 2]));
     std::vector<int> poly;
     const auto flush = [&]() {
         for (size_t k = 1; k + 1 < poly.size(); ++k) {
-            std::array<int, 3> tri{base + poly[0], base + poly[k], base + poly[k + 1]};
+            std::array<int, 3> tri{poly[0], poly[k], poly[k + 1]};
             if (!ccw) std::swap(tri[1], tri[2]);
-            out.tris.push_back(tri);
+            part.tris.push_back(tri);
         }
         poly.clear();
     };
@@ -165,6 +178,9 @@ void emitIndexedFaces(LoadedMesh& out, const std::vector<double>& points, const
         poly.push_back(i);
     }
     flush();
+    // One geometry node is one Shape's mesh: welded on its own, like an AMF
+    // or 3MF object.
+    appendWelded(out, part);
 }
 
 // IndexedTriangleSet / TriangleSet: every three indices (or points) are one
@@ -331,6 +347,17 @@ public:
             for (const auto& c : n.children) geometry(resolve(*c), m);
         } else if (n.name == "Inline") {
             ++skipped["Inline"];
+        } else if (n.name == "Switch") {
+            // Only the chosen child; whichChoice defaults to -1, nothing.
+            const std::vector<double> w = nums(n, "whichChoice");
+            const long k = w.empty() ? -1 : static_cast<long>(w[0]);
+            if (k >= 0 && static_cast<size_t>(k) < n.children.size()) walk(*n.children[static_cast<size_t>(k)], m);
+        } else if (n.name == "LOD") {
+            if (!n.children.empty()) walk(*n.children[0], m);  // the first, most detailed level
+        } else if (n.name == "ProtoDeclare" || n.name == "ExternProtoDeclare" || n.name == "ProtoInstance") {
+            // Prototypes are not expanded: a declaration's body is a template,
+            // not geometry, and an instance has nothing to place without it.
+            ++skipped[n.name];
         } else {
             for (const auto& c : n.children) walk(*c, m);
         }
@@ -400,6 +427,9 @@ class VrmlParser {
 public:
     explicit VrmlParser(const std::string& text) { tokenize(text); }
 
+    // Node type names a PROTO or EXTERNPROTO declares.
+    std::set<std::string> protos;
+
     std::vector<VNodePtr> parseScene() {
         std::vector<VNodePtr> nodes;
         while (i_ < toks_.size()) {
@@ -407,6 +437,7 @@ public:
             if (t == "ROUTE") {
                 i_ += 4;  // ROUTE a.b TO c.d
             } else if (t == "PROTO" || t == "EXTERNPROTO") {
+                protos.insert(peek(1));
                 i_ += 2;
                 skipBalanced("[", "]");
                 if (t == "PROTO") {
@@ -538,10 +569,23 @@ class VrmlWalker {
 public:
     LoadedMesh out;
     std::map<std::string, int> skipped;
+    std::set<std::string> protos;
 
     void walk(const VNodePtr& n, const Mat& m) {
         if (!n) return;
-        if (n->type == "Transform") {
+        if (protos.count(n->type)) {
+            // Prototypes are not expanded, so an instance's geometry is lost.
+            ++skipped["PROTO instance"];
+        } else if (n->type == "Switch") {
+            // Only the chosen child; whichChoice defaults to -1, nothing.
+            const std::vector<double> w = nums(*n, "whichChoice");
+            const long k = w.empty() ? -1 : static_cast<long>(w[0]);
+            const auto& choice = kids(*n, "choice");
+            if (k >= 0 && static_cast<size_t>(k) < choice.size()) walk(choice[static_cast<size_t>(k)], m);
+        } else if (n->type == "LOD") {
+            const auto& level = kids(*n, "level");
+            if (!level.empty()) walk(level[0], m);  // the first, most detailed level
+        } else if (n->type == "Transform") {
             const Mat t = transformNode(nums(*n, "translation"), nums(*n, "rotation"), nums(*n, "scale"),
                                         nums(*n, "center"), nums(*n, "scaleOrientation"));
             for (const auto& c : kids(*n, "children")) walk(c, mul(m, t));
@@ -550,8 +594,8 @@ public:
         } else if (n->type == "Inline") {
             ++skipped["Inline"];
         } else {
-            // Group, Anchor, Billboard, Collision, Switch (choice), LOD (level)
-            // and anything else holding nodes: walk every node-valued field.
+            // Group, Anchor, Billboard, Collision and anything else holding
+            // nodes: walk every node-valued field.
             for (const auto& [name, f] : n->fields) {
                 for (const auto& c : f.nodes) walk(c, m);
             }
@@ -679,10 +723,7 @@ LoadedMesh loadAmf(const std::string& path) {
         // or with its vertices listed twice, imports as a closed solid.
         // Within each object only -- two open halves in separate objects
         // stay open there too. Near-coincident vertices are not merged.
-        obj = weldVertices(obj.verts, obj.tris);
-        const int base = static_cast<int>(out.verts.size());
-        out.verts.insert(out.verts.end(), obj.verts.begin(), obj.verts.end());
-        for (const auto& t : obj.tris) out.tris.push_back({base + t[0], base + t[1], base + t[2]});
+        appendWelded(out, obj);
     }
     if (xml.find("<constellation") != std::string::npos) {
         out.warnings.push_back("AMF constellations are not applied: each object is imported where it was modeled");
@@ -706,6 +747,7 @@ LoadedMesh loadVrml(const std::string& path) {
     VrmlParser parser(text);
     const std::vector<VNodePtr> scene = parser.parseScene();
     VrmlWalker walker;
+    walker.protos = parser.protos;
     for (const VNodePtr& n : scene) walker.walk(n, identity());
     if (!walker.skipped.empty()) walker.out.warnings.push_back(skippedWarning(walker.skipped));
     return std::move(walker.out);

{openscad_cpp_evaluator-1.45.2 → openscad_cpp_evaluator-1.46.0}/tests/test_booleans.cpp

@@ -1248,6 +1248,83 @@ TEST(LevelSetFn, AFunctionFieldRequiresEdge) {
     EXPECT_NE(w[0].find("edge="), std::string::npos) << w[0];
 }
 
+// edge= as one spacing per axis (#729 on BelfrySCAD), as BOSL2's
+// isosurface() takes voxel_size. LevelSet itself takes one edge length, so
+// the field is squashed to unit spacing and the mesh stretched back.
+
+TEST(LevelSetFn, AnEqualVectorEdgeMatchesTheNumber) {
+    const std::string f = "levelset(function(x,y,z) sqrt(x*x+y*y+z*z), "
+                          "bounds=[[-30,-30,-30],[30,30,30]], isovalue=20, edge=";
+    Evaluated num = evalSrc(f + "1.5);");
+    Evaluated vec = evalSrc(f + "[1.5,1.5,1.5]);");
+    ASSERT_EQ(num.bodies.size(), 1u);
+    ASSERT_EQ(vec.bodies.size(), 1u);
+    EXPECT_EQ(soleBody(vec).NumTri(), soleBody(num).NumTri());
+    EXPECT_NEAR(soleBody(vec).Volume(), soleBody(num).Volume(), 1e-9 * soleBody(num).Volume());
+}
+
+TEST(LevelSetFn, AVectorEdgeIsExactlyAStretchedLattice) {
+    // A sphere stretched 4x in z, sampled 4x coarser in z, is the sphere's
+    // own mesh stretched: a vertex is a linear interpolation along a lattice
+    // edge, and that commutes with an axis scale. So the volume is exactly
+    // 4x, not merely close -- anything else means the lattice is not the
+    // one asked for.
+    Evaluated sphere = evalSrc(
+        "levelset(function(x,y,z) sqrt(x*x+y*y+z*z), "
+        "bounds=[[-30,-30,-30],[30,30,30]], isovalue=20, edge=1.5);");
+    Evaluated tall = evalSrc(
+        "levelset(function(x,y,z) sqrt(x*x+y*y+z*z/16), "
+        "bounds=[[-30,-30,-120],[30,30,120]], isovalue=20, edge=[1.5,1.5,6]);");
+    ASSERT_EQ(sphere.bodies.size(), 1u);
+    ASSERT_EQ(tall.bodies.size(), 1u);
+    EXPECT_EQ(soleBody(tall).NumTri(), soleBody(sphere).NumTri());
+    EXPECT_NEAR(soleBody(tall).Volume(), 4.0 * soleBody(sphere).Volume(), 1e-6 * soleBody(tall).Volume());
+    EXPECT_EQ(soleBody(tall).Genus(), 0);
+}
+
+TEST(LevelSetFn, AVectorEdgeAlsoAppliesToAGrid) {
+    Evaluated fine = evalSrc(sphereFieldSrc(50, 30) +
+                              "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=20);");
+    Evaluated coarseZ = evalSrc(sphereFieldSrc(50, 30) +
+                                 "levelset(f, bounds=[[-30,-30,-30],[30,30,30]], isovalue=20, edge=[1.2,1.2,4]);");
+    ASSERT_EQ(coarseZ.bodies.size(), 1u);
+    EXPECT_LT(soleBody(coarseZ).NumTri(), soleBody(fine).NumTri() * 3 / 4);  // measured 56%
+    EXPECT_NEAR(soleBody(coarseZ).Volume(), soleBody(fine).Volume(), 0.03 * soleBody(fine).Volume());
+}
+
+TEST(LevelSetFn, AVectorEdgeIn2DSetsEachAxis) {
+    // A circle sampled finely in x and coarsely in y has fewer contour
+    // points than one sampled finely in both, and still the circle's area.
+    const std::string f = "levelset(function(x,y) sqrt(x*x+y*y), "
+                          "bounds=[[-30,-30],[30,30]], isovalue=20, edge=";
+    Evaluated fine = evalSrc(f + "0.5);");
+    Evaluated mixed = evalSrc(f + "[0.5,3]);");
+    ASSERT_EQ(mixed.bodies.size(), 1u);
+    ASSERT_TRUE(mixed.bodies[0].section);
+    EXPECT_LT(mixed.bodies[0].section->NumVert(), fine.bodies[0].section->NumVert());
+    const double circle = 3.14159265358979 * 400;
+    EXPECT_NEAR(mixed.bodies[0].section->Area(), circle, 0.02 * circle);
+}
+
+TEST(LevelSetFn, AVectorEdgeOfTheWrongSizeWarns) {
+    for (const char* bad : {"[1,1]", "[1,1,0]", "[1,1,-2]", "[1,\"a\",1]"}) {
+        const std::vector<std::string> w = levelsetWarnings(
+            std::string("levelset(function(x,y,z) sqrt(x*x+y*y+z*z), "
+                        "bounds=[[-3,-3,-3],[3,3,3]], isovalue=2, edge=") + bad + ");");
+        ASSERT_GE(w.size(), 1u) << bad;
+        EXPECT_NE(w[0].find("[ex, ey, ez]"), std::string::npos) << bad << ": " << w[0];
+    }
+}
+
+TEST(LevelSetFn, SupportedFeatureSaysAVectorEdgeWorks) {
+    // Level 2 is how a library such as BOSL2 tells a build with per-axis
+    // edge= from one that would reject it.
+    std::vector<std::string> out;
+    evalSrc("echo(supported_feature(\"levelset\"));", [&](const std::string& m) { out.push_back(m); });
+    ASSERT_EQ(out.size(), 1u);
+    EXPECT_NE(out[0].find("2"), std::string::npos) << out[0];
+}
+
 TEST(LevelSetFn, AFunctionOfTheWrongArityWarns) {
     // One parameter is wrong for either dimension, so the message names both.
     const std::vector<std::string> one = levelsetWarnings(

{openscad_cpp_evaluator-1.45.2 → openscad_cpp_evaluator-1.46.0}/tests/test_feature_detection.cpp

@@ -68,10 +68,10 @@ TEST(FeatureDetection, EveryDocumentedFeatureReportsALevel) {
         ScopedVm guard(vm);
         for (const char* f : kFeatures) {
             const std::vector<std::string> e =
-                echoesFrom(std::string("echo(supported_feature(\"") + f + "\"));");
+                echoesFrom(std::string("echo(supported_feature(\"") + f + "\") >= 1);");
             ASSERT_EQ(e.size(), 1u) << f << ", vm=" << vm;
-            EXPECT_NE(e[0].find("1"), std::string::npos) << f << ", vm=" << vm << ", got " << e[0];
-            EXPECT_EQ(e[0].find("0"), std::string::npos) << f << " reported unsupported, vm=" << vm;
+            EXPECT_NE(e[0].find("true"), std::string::npos) << f << " reported unsupported, vm=" << vm
+                                                           << ", got " << e[0];
         }
     }
 }