openscad-cpp-evaluator 0.31.0__tar.gz → 0.31.2__tar.gz

{openscad_cpp_evaluator-0.31.0 → openscad_cpp_evaluator-0.31.2}/PKG-INFO

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

{openscad_cpp_evaluator-0.31.0 → openscad_cpp_evaluator-0.31.2}/include/openscad_cpp_evaluator/mesh_check.hpp

@@ -51,7 +51,16 @@ struct MeshDiagnosis {
 
 // Diagnose `mesh` against all four conditions. Read-only; nothing is
 // modified and no exception is thrown for a broken mesh.
-MeshDiagnosis checkMesh(const manifold::MeshGL& mesh);
+// Templated on the mesh type so callers can hand over MeshGL64 and keep
+// their coordinates. This is not cosmetic: the welding below keys on a
+// fixed 1e-6 grid, and float32's step exceeds that beyond coordinate
+// magnitude ~17 -- so on any real model a float mesh is coarser than the
+// tolerance these functions claim to work at, and genuinely distinct
+// vertices collapse onto one key. Instantiated for MeshGL and MeshGL64.
+template <typename M>
+MeshDiagnosis checkMesh(const M& mesh);
+extern template MeshDiagnosis checkMesh<manifold::MeshGL>(const manifold::MeshGL&);
+extern template MeshDiagnosis checkMesh<manifold::MeshGL64>(const manifold::MeshGL64&);
 
 // What repairMesh did, for reporting. Not a diagnosis: these are actions.
 struct MeshRepairReport {
@@ -81,7 +90,10 @@ struct MeshRepairReport {
 //
 // Returns the repaired mesh. A mesh it cannot close is still returned,
 // improved as far as it got, with the remainder reported in `report`.
-manifold::MeshGL repairMesh(const manifold::MeshGL& mesh, MeshRepairReport& report);
+template <typename M>
+M repairMesh(const M& mesh, MeshRepairReport& report);
+extern template manifold::MeshGL repairMesh<manifold::MeshGL>(const manifold::MeshGL&, MeshRepairReport&);
+extern template manifold::MeshGL64 repairMesh<manifold::MeshGL64>(const manifold::MeshGL64&, MeshRepairReport&);
 
 struct SliverStripReport {
     size_t removed = 0;        // zero-area faces taken out
@@ -103,6 +115,9 @@ struct SliverStripReport {
 // vertex restores the match without moving any geometry.
 //
 // The mesh is returned unchanged if it has no slivers.
-manifold::MeshGL stripSlivers(const manifold::MeshGL& mesh, SliverStripReport& report);
+template <typename M>
+M stripSlivers(const M& mesh, SliverStripReport& report);
+extern template manifold::MeshGL stripSlivers<manifold::MeshGL>(const manifold::MeshGL&, SliverStripReport&);
+extern template manifold::MeshGL64 stripSlivers<manifold::MeshGL64>(const manifold::MeshGL64&, SliverStripReport&);
 
 }  // namespace oscadeval

{openscad_cpp_evaluator-0.31.0 → openscad_cpp_evaluator-0.31.2}/pyproject.toml

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

{openscad_cpp_evaluator-0.31.0 → openscad_cpp_evaluator-0.31.2}/src/builtins/import.cpp

@@ -267,19 +267,33 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
     const auto& tris = std::get<ListPtr>(params.at("tris"))->items;
     if (tris.empty()) ev.error("import: mesh has no triangles", node);
 
-    manifold::MeshGL mesh;
-    mesh.numProp = 3;
+    // Kept at full precision for the Manifold that CSG will actually use --
+    // MeshGL is MeshGLP<float>, and truncating there does not merely lose
+    // digits, it snaps nearly-distinct coordinates onto exactly-equal ones
+    // and manufactures the degenerate coincidences that make a later
+    // boolean leave a zero-thickness membrane behind (see
+    // generatePolyhedron). STL carries only float32 to begin with, but
+    // OBJ/OFF/3MF are text and can hold more, and this is the same
+    // import() either way.
+    manifold::MeshGL64 mesh64;
+    mesh64.numProp = 3;
     for (const Value& v : std::get<ListPtr>(params.at("verts"))->items) {
-        mesh.vertProperties.push_back(static_cast<float>(std::get<double>(v)));
+        mesh64.vertProperties.push_back(std::get<double>(v));
     }
-    for (const Value& t : tris) mesh.triVerts.push_back(static_cast<uint32_t>(std::get<double>(t)));
+    for (const Value& t : tris) mesh64.triVerts.push_back(static_cast<uint64_t>(std::get<double>(t)));
+
+    // checkMesh/repairMesh work at this precision too, which matters here:
+    // they weld on a fixed 1e-6 grid, and float32's step is coarser than
+    // that beyond coordinate magnitude ~17, so a float mesh would have them
+    // merging vertices that are genuinely distinct on any real model.
+    manifold::MeshGL64& mesh = mesh64;
 
     const auto repairIt = params.find("repair");
     const bool repair = repairIt != params.end() && truthy(repairIt->second);
     if (repair) {
         const MeshDiagnosis before = checkMesh(mesh);
         MeshRepairReport rep;
-        manifold::MeshGL fixed = repairMesh(mesh, rep);
+        manifold::MeshGL64 fixed = repairMesh(mesh, rep);
         const MeshDiagnosis after = checkMesh(fixed);
         if (rep.didAnything()) {
             ev.warn("import: repaired the mesh -- " + rep.summary(), &node.position());
@@ -308,7 +322,14 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
                     "); drawing it as a surface, but it cannot take part in any CSG "
                     "operation" + (repair ? "" : ". Try import(..., repair=true)"),
                 &node.position());
-        return {ev.tagDisplayOnly(std::move(mesh), node, params.at("color"))};
+        // tagDisplayOnly carries a raw triangle soup for the renderer to
+        // draw, and the renderer is float either way, so narrowing here
+        // costs nothing this mesh will ever be measured on.
+        manifold::MeshGL soup;
+        soup.numProp = 3;
+        soup.vertProperties.assign(mesh.vertProperties.begin(), mesh.vertProperties.end());
+        soup.triVerts.assign(mesh.triVerts.begin(), mesh.triVerts.end());
+        return {ev.tagDisplayOnly(std::move(soup), node, params.at("color"))};
     }
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }

{openscad_cpp_evaluator-0.31.0 → openscad_cpp_evaluator-0.31.2}/src/builtins/primitives_3d.cpp

@@ -31,17 +31,21 @@ bool isUndef(const Value& v) { return std::holds_alternative<std::monostate>(v);
 // camera auto-fit to infinity, which is worse than showing nothing. The
 // explicit finite check is belt-and-braces, since nothing documents that a
 // NotManifold mesh can't ALSO contain a NaN.
-bool isDrawableFailure(const manifold::Manifold& body, const manifold::MeshGL& mesh) {
+template <typename M>
+bool isDrawableFailure(const manifold::Manifold& body, const M& mesh) {
     if (body.Status() != manifold::Manifold::Error::NotManifold) return false;
     if (mesh.triVerts.empty()) return false;
     return std::all_of(mesh.vertProperties.begin(), mesh.vertProperties.end(),
                         [](float v) { return std::isfinite(v); });
 }
 
-size_t countBoundaryEdges(const manifold::MeshGL& mesh) {
+template <typename M>
+size_t countBoundaryEdges(const M& mesh) {
     std::map<std::pair<uint32_t, uint32_t>, int> uses;
     for (size_t i = 0; i + 2 < mesh.triVerts.size(); i += 3) {
-        const uint32_t v[3] = {mesh.triVerts[i], mesh.triVerts[i + 1], mesh.triVerts[i + 2]};
+        const uint32_t v[3] = {static_cast<uint32_t>(mesh.triVerts[i]),
+                                static_cast<uint32_t>(mesh.triVerts[i + 1]),
+                                static_cast<uint32_t>(mesh.triVerts[i + 2])};
         for (int e = 0; e < 3; ++e) {
             const uint32_t a = v[e], b = v[(e + 1) % 3];
             ++uses[{std::min(a, b), std::max(a, b)}];
@@ -162,13 +166,13 @@ CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalConte
 
 std::vector<ColoredBody> generateSphere(Evaluator& ev, const CSGParams& params, const std::vector<std::unique_ptr<CSGNode>>&,
                                          const oscad::ASTNode& node) {
-    manifold::MeshGL mesh;
+    manifold::MeshGL64 mesh;
     mesh.numProp = 3;
     for (const Value& v : std::get<ListPtr>(params.at("verts"))->items) {
-        mesh.vertProperties.push_back(static_cast<float>(std::get<double>(v)));
+        mesh.vertProperties.push_back(std::get<double>(v));
     }
     for (const Value& t : std::get<ListPtr>(params.at("tris"))->items) {
-        mesh.triVerts.push_back(static_cast<uint32_t>(std::get<double>(t)));
+        mesh.triVerts.push_back(static_cast<uint64_t>(std::get<double>(t)));
     }
     manifold::Manifold body(mesh);
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
@@ -473,13 +477,13 @@ CSGParams resolvePolyhedron(Evaluator& ev, const oscad::ModularCall& node, EvalC
 
 std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& params,
                                              const std::vector<std::unique_ptr<CSGNode>>&, const oscad::ASTNode& node) {
-    manifold::MeshGL mesh;
+    manifold::MeshGL64 mesh;
     mesh.numProp = 3;
     for (const Value& v : std::get<ListPtr>(params.at("verts"))->items) {
-        mesh.vertProperties.push_back(static_cast<float>(std::get<double>(v)));
+        mesh.vertProperties.push_back(std::get<double>(v));
     }
     for (const Value& t : std::get<ListPtr>(params.at("tris"))->items) {
-        mesh.triVerts.push_back(static_cast<uint32_t>(std::get<double>(t)));
+        mesh.triVerts.push_back(static_cast<uint64_t>(std::get<double>(t)));
     }
     manifold::Manifold body(mesh);
     if (isDrawableFailure(body, mesh)) {
@@ -498,7 +502,11 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
                     " boundary edge(s); drawing it as a surface, but it cannot "
                     "take part in any CSG operation",
                 &node.position());
-        return {ev.tagDisplayOnly(std::move(mesh), node, params.at("color"))};
+        manifold::MeshGL soup;
+        soup.numProp = 3;
+        soup.vertProperties.assign(mesh.vertProperties.begin(), mesh.vertProperties.end());
+        soup.triVerts.assign(mesh.triVerts.begin(), mesh.triVerts.end());
+        return {ev.tagDisplayOnly(std::move(soup), node, params.at("color"))};
     }
     if (body.Status() != manifold::Manifold::Error::NoError) {
         // Broken vertex data rather than merely-open topology (a NaN

{openscad_cpp_evaluator-0.31.0 → openscad_cpp_evaluator-0.31.2}/src/builtins/roof.cpp

@@ -394,12 +394,18 @@ manifold::Manifold voronoiRoof(const manifold::CrossSection& cs, double fa, doub
         }
     }
 
-    manifold::MeshGL mesh;
+    // MeshGL64, not MeshGL: MeshGL is MeshGLP<float>, so building through
+    // it truncates these coordinates to ~7 significant digits on the way
+    // into Manifold. That does not merely lose precision -- it snaps
+    // nearly-distinct coordinates onto exactly-equal ones, manufacturing
+    // the degenerate coincidences that make a later boolean leave a
+    // zero-thickness membrane behind. See generatePolyhedron.
+    manifold::MeshGL64 mesh;
     mesh.numProp = 3;
     for (const auto& v : verts) {
-        mesh.vertProperties.push_back(static_cast<float>(v[0]));
-        mesh.vertProperties.push_back(static_cast<float>(v[1]));
-        mesh.vertProperties.push_back(static_cast<float>(v[2]));
+        mesh.vertProperties.push_back(v[0]);
+        mesh.vertProperties.push_back(v[1]);
+        mesh.vertProperties.push_back(v[2]);
     }
     for (const auto& t : tris) {
         mesh.triVerts.push_back(t[0]);

{openscad_cpp_evaluator-0.31.0 → openscad_cpp_evaluator-0.31.2}/src/builtins/surface.cpp

@@ -71,19 +71,21 @@ std::vector<ColoredBody> generateSurface(Evaluator& ev, const CSGParams& params,
     const auto top = [&](std::size_t r, std::size_t c) { return static_cast<uint32_t>(r * cols + c); };
     const auto bot = [&](std::size_t r, std::size_t c) { return static_cast<uint32_t>(n + r * cols + c); };
 
-    manifold::MeshGL mesh;
+    // MeshGL64 -- see generatePolyhedron for why float truncation here
+    // manufactures degenerate coincidences for later booleans.
+    manifold::MeshGL64 mesh;
     mesh.numProp = 3;
     for (std::size_t r = 0; r < rows; ++r) {
         for (std::size_t c = 0; c < cols; ++c) {
-            mesh.vertProperties.push_back(static_cast<float>(static_cast<double>(c) + xOff));
-            mesh.vertProperties.push_back(static_cast<float>(static_cast<double>(r) + yOff));
-            mesh.vertProperties.push_back(static_cast<float>(heights[r][c]));
+            mesh.vertProperties.push_back(static_cast<double>(c) + xOff);
+            mesh.vertProperties.push_back(static_cast<double>(r) + yOff);
+            mesh.vertProperties.push_back(heights[r][c]);
         }
     }
     for (std::size_t r = 0; r < rows; ++r) {
         for (std::size_t c = 0; c < cols; ++c) {
-            mesh.vertProperties.push_back(static_cast<float>(static_cast<double>(c) + xOff));
-            mesh.vertProperties.push_back(static_cast<float>(static_cast<double>(r) + yOff));
+            mesh.vertProperties.push_back(static_cast<double>(c) + xOff);
+            mesh.vertProperties.push_back(static_cast<double>(r) + yOff);
             mesh.vertProperties.push_back(0.0f);
         }
     }

{openscad_cpp_evaluator-0.31.0 → openscad_cpp_evaluator-0.31.2}/src/mesh_check.cpp

@@ -15,29 +15,34 @@ using Edge = std::pair<Vert, Vert>;
 
 Edge undirected(Vert a, Vert b) { return {std::min(a, b), std::max(a, b)}; }
 
-size_t triCount(const manifold::MeshGL& m) { return m.triVerts.size() / 3; }
+template <typename M>
+size_t triCount(const M& m) { return m.triVerts.size() / 3; }
 
-void triVerts(const manifold::MeshGL& m, size_t t, Vert out[3]) {
+template <typename M>
+void triVerts(const M& m, size_t t, Vert out[3]) {
     out[0] = m.triVerts[t * 3];
     out[1] = m.triVerts[t * 3 + 1];
     out[2] = m.triVerts[t * 3 + 2];
 }
 
 // Position of vertex v, whatever the stride happens to be.
-void pos(const manifold::MeshGL& m, Vert v, double out[3]) {
+template <typename M>
+void pos(const M& m, Vert v, double out[3]) {
     const size_t stride = m.numProp ? m.numProp : 3;
     for (int i = 0; i < 3; ++i) out[i] = m.vertProperties[v * stride + i];
 }
 
 // A face naming the same vertex twice. Its "edges" include a self-edge, so
 // it cannot take part in the topology at all.
-bool repeatsAVertex(const manifold::MeshGL& m, size_t t) {
+template <typename M>
+bool repeatsAVertex(const M& m, size_t t) {
     Vert v[3];
     triVerts(m, t, v);
     return v[0] == v[1] || v[1] == v[2] || v[0] == v[2];
 }
 
-bool degenerate(const manifold::MeshGL& m, size_t t) {
+template <typename M>
+bool degenerate(const M& m, size_t t) {
     Vert v[3];
     triVerts(m, t, v);
     if (v[0] == v[1] || v[1] == v[2] || v[0] == v[2]) return true;
@@ -52,7 +57,8 @@ bool degenerate(const manifold::MeshGL& m, size_t t) {
 
 // Vertices that share a position but not an index. Keyed on rounded
 // coordinates, matching the welding polyhedron() already does.
-size_t countUnwelded(const manifold::MeshGL& m) {
+template <typename M>
+size_t countUnwelded(const M& m) {
     const size_t stride = m.numProp ? m.numProp : 3;
     const size_t n = stride ? m.vertProperties.size() / stride : 0;
     std::map<std::tuple<long long, long long, long long>, size_t> seen;
@@ -69,7 +75,8 @@ size_t countUnwelded(const manifold::MeshGL& m) {
 // The faces around `v`, as (prev, next) pairs on the opposite edge. The link
 // is one cycle when following those pairs from any starting corner visits
 // all of them; more than one walk means the surface pinches at v.
-size_t countPinched(const manifold::MeshGL& m,
+template <typename M>
+size_t countPinched(const M& m,
                     const std::vector<std::vector<size_t>>& vertTris) {
     size_t pinched = 0;
     for (Vert v = 0; v < vertTris.size(); ++v) {
@@ -130,7 +137,8 @@ std::string MeshDiagnosis::summary() const {
     return out;
 }
 
-MeshDiagnosis checkMesh(const manifold::MeshGL& mesh) {
+template <typename M>
+MeshDiagnosis checkMesh(const M& mesh) {
     MeshDiagnosis d;
     const size_t tris = triCount(mesh);
     const size_t stride = mesh.numProp ? mesh.numProp : 3;
@@ -220,7 +228,8 @@ namespace {
 // Merge vertices that share a position. Everything downstream depends on
 // this: unwelded duplicates split one shared edge into two boundary edges,
 // so a mesh that is really closed reads as full of holes until it is done.
-std::vector<Vert> weldMap(const manifold::MeshGL& m, size_t& welded) {
+template <typename M>
+std::vector<Vert> weldMap(const M& m, size_t& welded) {
     const size_t stride = m.numProp ? m.numProp : 3;
     const size_t n = stride ? m.vertProperties.size() / stride : 0;
     std::map<std::tuple<long long, long long, long long>, Vert> first;
@@ -275,9 +284,10 @@ std::vector<std::vector<Vert>> boundaryLoops(const std::vector<std::array<Vert,
 
 }  // namespace
 
-manifold::MeshGL repairMesh(const manifold::MeshGL& mesh, MeshRepairReport& report) {
+template <typename M>
+M repairMesh(const M& mesh, MeshRepairReport& report) {
     report = MeshRepairReport{};
-    manifold::MeshGL out = mesh;
+    M out = mesh;
 
     // 1. Weld. Must come first -- it decides which edges are shared, and
     //    every later step reads the edge map.
@@ -448,7 +458,8 @@ namespace {
 // between the same two points, so once it is gone the faces on either side
 // already meet along one edge and nothing needs splitting. The coincident
 // pair is merged so that is true by index as well as by position.
-bool coincidentPair(const manifold::MeshGL& m, const std::array<Vert, 3>& f,
+template <typename M>
+bool coincidentPair(const M& m, const std::array<Vert, 3>& f,
                     Vert& keep, Vert& drop) {
     for (int i = 0; i < 3; ++i) {
         const Vert a = f[i], b = f[(i + 1) % 3];
@@ -468,7 +479,8 @@ bool coincidentPair(const manifold::MeshGL& m, const std::array<Vert, 3>& f,
 
 // Index of the vertex opposite the longest edge -- for three collinear
 // points that is the one in the middle.
-int middleOfCollinear(const manifold::MeshGL& m, const std::array<Vert, 3>& f) {
+template <typename M>
+int middleOfCollinear(const M& m, const std::array<Vert, 3>& f) {
     double p[3][3];
     for (int i = 0; i < 3; ++i) pos(m, f[i], p[i]);
     auto d2 = [&](int a, int b) {
@@ -484,7 +496,8 @@ int middleOfCollinear(const manifold::MeshGL& m, const std::array<Vert, 3>& f) {
 
 }  // namespace
 
-manifold::MeshGL stripSlivers(const manifold::MeshGL& mesh, SliverStripReport& report) {
+template <typename M>
+M stripSlivers(const M& mesh, SliverStripReport& report) {
     report = SliverStripReport{};
     std::vector<std::array<Vert, 3>> tris;
     tris.reserve(triCount(mesh));
@@ -615,7 +628,7 @@ manifold::MeshGL stripSlivers(const manifold::MeshGL& mesh, SliverStripReport& r
         tris.swap(next);
     }
 
-    manifold::MeshGL out = mesh;
+    M out = mesh;
     out.triVerts.clear();
     out.triVerts.reserve(tris.size() * 3);
     for (const auto& f : tris) {
@@ -631,4 +644,16 @@ manifold::MeshGL stripSlivers(const manifold::MeshGL& mesh, SliverStripReport& r
     return out;
 }
 
+
+// Instantiated for both precisions: MeshGL for the paths that are float by
+// nature (STL, the renderer), MeshGL64 wherever the caller still has its
+// real coordinates. Keeping the definitions in this file, rather than the
+// header, keeps compile times where they were.
+template MeshDiagnosis checkMesh<manifold::MeshGL>(const manifold::MeshGL&);
+template MeshDiagnosis checkMesh<manifold::MeshGL64>(const manifold::MeshGL64&);
+template manifold::MeshGL repairMesh<manifold::MeshGL>(const manifold::MeshGL&, MeshRepairReport&);
+template manifold::MeshGL64 repairMesh<manifold::MeshGL64>(const manifold::MeshGL64&, MeshRepairReport&);
+template manifold::MeshGL stripSlivers<manifold::MeshGL>(const manifold::MeshGL&, SliverStripReport&);
+template manifold::MeshGL64 stripSlivers<manifold::MeshGL64>(const manifold::MeshGL64&, SliverStripReport&);
+
 }  // namespace oscadeval

{openscad_cpp_evaluator-0.31.0 → openscad_cpp_evaluator-0.31.2}/tests/test_cli.cpp

@@ -11,6 +11,12 @@
 #include <cmath>
 #include <filesystem>
 #include <fstream>
+#ifdef _WIN32
+#include <process.h>
+#define getpid _getpid
+#else
+#include <unistd.h>
+#endif
 #include <gtest/gtest.h>
 #include <sstream>
 
@@ -33,8 +39,45 @@ const char* kAmbiguousNameScript = "function fib(n) = n < 2 ? n : fib(n-1) + fib
                                     "}\n"
                                     "thing(1);\n";
 
+// One directory per process, created once.
+//
+// These tests write a script, run the CLI on it, and delete both it and
+// their output again -- and they collide heavily on names: three share
+// "m.scad" as input and twenty-four write "m_out.stl". Sharing one temp
+// directory meant that under `ctest -j` a test would delete the script
+// another was still reading (runCli then returns 1) or remove an output
+// another had just written (exists(out) then fails). It looked like shared
+// state in the debug REPL; it was only the filenames.
+//
+// The process id is what makes this work. ctest runs each discovered test
+// as its OWN process, so a static counter or a hash of the script name is
+// identical in every one of them -- an earlier attempt keyed on exactly
+// that and changed nothing, because every process produced the same
+// directory name. Names stay as they were, which matters: some tests
+// assert on the filename the debugger prints ("m.scad:1").
+const std::filesystem::path& testScratchDir() {
+    // Removed on the way out. The tests delete their own scripts and
+    // outputs, but the directory itself would otherwise pile up -- one per
+    // test process per run, which is 1,482 of them a suite.
+    struct Scratch {
+        std::filesystem::path path;
+        Scratch() {
+            path = std::filesystem::temp_directory_path() /
+                   ("oscad_cli_test_" +
+                    std::to_string(static_cast<unsigned long long>(::getpid())));
+            std::filesystem::create_directories(path);
+        }
+        ~Scratch() {
+            std::error_code ec;
+            std::filesystem::remove_all(path, ec); // best effort
+        }
+    };
+    static const Scratch scratch;
+    return scratch.path;
+}
+
 std::filesystem::path writeScript(const std::string& name, const std::string& text) {
-    const std::filesystem::path p = std::filesystem::temp_directory_path() / ("oscad_cli_test_" + name);
+    const std::filesystem::path p = testScratchDir() / name;
     std::ofstream out(p);
     out << text;
     return p;

{openscad_cpp_evaluator-0.31.0 → openscad_cpp_evaluator-0.31.2}/tests/test_import_export.cpp

@@ -308,3 +308,48 @@ TEST(ObjectBuiltin, PositionalMergesExistingObject) {
     const auto& items = std::get<ObjectPtr>(v)->items;
     ASSERT_EQ(items.size(), 3u);
 }
+
+// -- mesh-built geometry keeps full precision ----------------------------
+//
+// polyhedron()/sphere()/roof()/surface()/import() build their Manifold from
+// a mesh, and MeshGL is MeshGLP<float>. Going through it truncated script
+// doubles to ~7 significant digits, which does not merely lose precision:
+// it snaps nearly-distinct coordinates onto exactly-equal ones and
+// manufactures degenerate coincidences that make a later boolean leave a
+// zero-thickness membrane behind, sealing a hole that should go through.
+//
+// Found via a real user model (a coin-cell dispenser using BOSL2's
+// rounded/teardrop cyl(), which builds through polyhedron()): the bore came
+// out capped, the export was a valid closed solid a slicer would happily
+// print solid, and every mesh integrity check passed -- watertight,
+// manifold, orientable, no duplicate or degenerate faces. Only the genus
+// gave it away. A plain cylinder() never showed it, because that is a
+// Manifold primitive built in double precision all along.
+// A whole-model reproduction needs BOSL2 (its rounded/teardrop cyl() is what
+// builds through polyhedron() in the wild), which this suite cannot depend
+// on -- and a hand-written box does NOT reproduce it: Manifold handles
+// exactly-coincident PLANAR faces fine, as checked directly. The end-to-end
+// case lives in BelfrySCAD's scratch/coplanar_cut_repro.scad. What is
+// guarded here is the cause rather than one of its symptoms: that
+// mesh-built geometry keeps the precision it was given.
+TEST(MeshPrecision, PolyhedronKeepsCoordinatesFloatWouldRound) {
+    // 0.1 + 0.2 style values a float cannot hold: at float32 these two
+    // vertices would land on the same coordinate and the solid would
+    // degenerate. In doubles they stay apart.
+    Evaluated e = evalSrc(R"(
+        polyhedron(
+            points = [[0,0,0],[10.000000123,0,0],[10.000000123,10,0],[0,10,0],
+                      [0,0,10],[10.000000123,0,10],[10.000000123,10,10],[0,10,10]],
+            faces  = [[1,2,3,0],[7,6,5,4],[4,5,1,0],
+                      [5,6,2,1],[6,7,3,2],[7,4,0,3]]);
+    )");
+    ASSERT_FALSE(e.bodies.empty());
+    const manifold::MeshGL64 mesh = e.bodies.front().body->GetMeshGL64();
+    double maxX = 0.0;
+    for (size_t i = 0; i < mesh.vertProperties.size(); i += mesh.numProp) {
+        maxX = std::max(maxX, mesh.vertProperties[i]);
+    }
+    // float32 would round this to 10.0 exactly; double keeps the tail.
+    EXPECT_GT(maxX, 10.0);
+    EXPECT_NEAR(maxX, 10.000000123, 1e-9);
+}