openscad-cpp-evaluator 1.51.0__tar.gz → 1.52.0__tar.gz

{openscad_cpp_evaluator-1.51.0 → openscad_cpp_evaluator-1.52.0}/CLAUDE.md

@@ -535,11 +535,12 @@ cmake -S . -B build -DFETCHCONTENT_FULLY_DISCONNECTED=ON -DBUILD_TESTING=OFF \
   -DFETCHCONTENT_SOURCE_DIR_BOOST_CONFIG=...  -DFETCHCONTENT_SOURCE_DIR_BOOST_POLYGON=... \
   -DFETCHCONTENT_SOURCE_DIR_FREETYPE=...      -DFETCHCONTENT_SOURCE_DIR_HARFBUZZ=... \
   -DFETCHCONTENT_SOURCE_DIR_STB=...           -DFETCHCONTENT_SOURCE_DIR_CPP_LINENOISE=... \
-  -DFETCHCONTENT_SOURCE_DIR_NLOHMANN_JSON=...
+  -DFETCHCONTENT_SOURCE_DIR_NLOHMANN_JSON=... -DFETCHCONTENT_SOURCE_DIR_TBB=...
 ```
 
-That is the whole list for a wheel build (tests off; GoogleTest is the only other download, and
-TBB only with `MANIFOLD_PAR`). Clipper2 is Manifold's own download, pinned in Manifold's
+That is the whole list for a wheel build (tests off; GoogleTest is the only other download).
+Clipper2 and oneTBB (v2022.3.0, for `MANIFOLD_PAR`, which the root `CMakeLists.txt` forces on
+with Manifold's builtin static TBB) are Manifold's own downloads, pinned in Manifold's
 `cmake/manifoldDeps.cmake`; nlohmann_json is the parser's. FetchContent skips `PATCH_COMMAND` for a
 supplied source, so the root `CMakeLists.txt` runs `cmake/patch_manifold.cmake` itself when
 `FETCHCONTENT_SOURCE_DIR_MANIFOLD` is set -- otherwise an offline build would quietly ship the heap
@@ -1070,9 +1071,10 @@ grep for `ponytail:`.
   reference's `isValidDim` + `collectChildren2D`/`collectChildren3D`: a node's dimension is fixed by
   its first non-background, non-empty child, and every child of the other dimension is dropped with
   `Mixing 2D and 3D objects is not supported` followed by `Ignoring {N}D child object for {M}D
-  operation`. `linear_extrude`/`rotate_extrude`/`offset` are always-2D and `projection` always-3D, so
+  operation`. `linear_extrude`/`rotate_extrude` are always-2D and `projection` always-3D, so
   they skip the "mixing" line and emit only the second; `roof()` emits neither, matching the
-  reference. Background (`%`) children are exempt.
+  reference. `offset()` takes either dimension (the solid offset of `offset3d.cpp`), so it follows
+  the boolean rule: the first real child decides. Background (`%`) children are exempt.
   **The emptiness test is cached on the body (`ColoredBody::knownEmpty`, v1.17.0).** It used to
   call `Manifold::NumTri()` on every child at every level, and every Manifold accessor goes through
   `GetImpl()`, which materialises a lazy transform (a full mesh + collider copy) and runs a lazy
@@ -1123,10 +1125,8 @@ grep for `ponytail:`.
   (`Manifold::MinkowskiDifference`). 3D only, matching `minkowski()`'s own 3D-wins dispatch, since
   Manifold has no CrossSection erosion and 2D already has one in `offset(r=-N)`.
 
-  Worth knowing why this is a module rather than an extension of `offset()`: a *positive* 3D offset
-  is already expressible as `minkowski() { X; sphere(r); }`, so `offset(r=N)` on a solid would have
-  been pure sugar. Erosion is the half that is genuinely unavailable, and naming it after the
-  operation beats borrowing a 2D name for it. Eroding a cube by a cube is exact (no curved tool to
+  It predates the 3D `offset()` (see `## offset() in 3D`), which now erodes a solid too, and is kept
+  because it erodes by any tool, not only a ball, cube or octahedron. Eroding a cube by a cube is exact (no curved tool to
   tessellate), which is what the tests assert on; a sphere tool lands a little large, and that gap
   is the sphere's tessellation rather than an error in the erosion.
 - `src/builtins/extrude.cpp` — `linear_extrude()`/`rotate_extrude()`/`projection(cut=)`. All three
@@ -1140,7 +1140,9 @@ grep for `ponytail:`.
   `generateOffset`, also in this file) is the other CrossSection-transform-shaped builtin sharing
   `toCrossSection`; no children/generate-time-bounds dependency, so its resolve/generate split is
   the simple kind (segment count for `r=` IS resolvable early here, unlike `rotate_extrude`'s,
-  since `offset`'s own radius argument is already known at resolve time).
+  since `offset`'s own radius argument is already known at resolve time). A 3D child takes
+  `offset3d()` instead (`## offset() in 3D`): the foreground solids are unioned and offset as one,
+  `join` round/miter/square selecting r/delta/chamfer, and the result tagged as generated.
 - `src/builtins/roof.cpp` — `roof()`: the default `method="voronoi"` built on Boost.Polygon's
   segment Voronoi diagram (see the `roof()` note above for the full story of why this replaced an
   earlier straight-skeleton approximation mid-Phase-6), and `method="straight"`'s straight-skeleton
@@ -2037,3 +2039,67 @@ formats have no object names and ignore it. Geometry outside any `export_as()` i
   `export_as()` and drops an unknown module's children, so a portable script guards on
   `supported_feature("export-as")`.
 - `src/builtins/export_as.cpp`; tests in `tests/test_export_as.cpp`.
+
+## `offset()` in 3D
+
+`offset(r=)`, `offset(delta=)` and `offset(delta=, chamfer=true)` of a solid, outward and inward
+(`src/builtins/offset3d.cpp`, entry `offset3d()` in `include/openscad_cpp_evaluator/offset3d.hpp`;
+`supported_feature("offset-3d")` is 1). Upstream OpenSCAD's `offset()` is 2D only and drops a 3D
+child, so a portable script guards it. The modes mean what they mean in 2D: every face moves `d`
+along its normal; `delta=` keeps edges and corners sharp (**no miter limit**, as Clipper's 1e6 is
+none, so a sharp edge's miter reaches `d/sin(half its angle)`); `chamfer=true` cuts them flat
+(exactly `minkowski()` with an octahedron on an axis-aligned part); `r=` rounds them with a faceted
+ball **inscribed** in the true sphere (every vertex on it), `$fn`/`$fa`/`$fs` counted from `|r|` as
+in 2D -- so the default gives `r=1` five sides, and `$fn` is usually wanted. No published method
+covers all three modes (Cao 2024's mitered offset needs exact rationals; Zint 2023 and PCO round
+only), so the construction is our own, worked out in a Python prototype and checked by suites of
+exact volumes, topology, fuzzing, refine invariance and pathological meshes before the port.
+
+**Construction.** Outward is `A ∪ pieces`: a slab per triangle (the face swept by `d`), a wedge per
+convex edge (hull of the two faces' offset points; plus the miter points for `delta=`; a capsule
+for `r=`) and a cap per vertex (the same at a corner). Inward builds the same pieces on A with
+every triangle flipped and subtracts their union from A -- no bounding box, and a feature thinner
+than `2d` vanishes by construction. Outward `r=` is Manifold's `MinkowskiSum` with the inscribed
+ball, which is this construction and faster. Each piece is convex, made by `hullChecked` (hull in a
+PCA-whitened frame, since Manifold's hull dropped corners of long thin point sets, then every input
+point verified against the hull's planes). Mitered pieces are trimmed by the shifted half-spaces
+of the faces at their end vertices -- the ends of the whole straight edge (`chainEnds`), not of the
+triangle edge, or `refine()`'s midpoints left a 0.6 spike -- and by far faces only within their
+own convex patch (faces joined through convex or flat edges), which keeps separate parts apart.
+
+**Robustness rules, each from a failure:**
+- Pieces start `e = min(d, max(1e-5·d, 1e-9·scale))` behind the surface, so none shares a plane
+  with A (coincident faces left a rounding-thin skin); slabs widen by `e` past concave and flat
+  edges (otherwise zero-thickness fins, genus -87); wedges reach `1e-3·d` into both slabs and caps
+  along their edges, as absolute distances (fractions of an edge made `refine(2)` change the result).
+- Every piece is grown by `1e-9·scale`, so offsets meeting exactly overlap rather than touch
+  (touching counts as joined, as in Minkowski). Expect volumes ~1e-9 relative off exact.
+- The work runs at the origin (Manifold's union lost 0.35 of a chamfered cube at 1e5 from it), and
+  the result is moved back as a bare mesh: `Translate()` of a lazy CSG result re-runs its booleans
+  out there.
+- **`bare()` everywhere**: pieces and intermediate leaves are rebuilt from vertices and triangles
+  alone. A Manifold rebuilt from `GetMeshGL64()` keeps face IDs and the like, and unions of such
+  pieces lost whole wedges (adding six pieces once made the volume smaller). Manifold 3.5.4 does
+  the same, so a bump does not help.
+- **`lostPieces()` checks the union against its pieces.** Manifold's union is order- and
+  thread-dependent (TBB lost 0.045 of one piece where the single-threaded build did not). Pieces are
+  coloured so that no two of a colour have overlapping boxes, each colour `Compose`d (exact for
+  disjoint pieces) and tested with one boolean against the bare result -- against a lazy one,
+  Manifold flattened `G - (A + pieces)` into `G - A - pieces` and hid every loss. A remnant thicker
+  than `10e` (`2V/A`) marks its pieces lost; they are added again onto the bare result, up to 3 rounds.
+- `Simplify()` is not shape-safe (it moved 0.063 of a volume at 9e-12): each simplify is kept only
+  if the volume and the count and genus of non-empty shells are unchanged. The last one, at
+  `1e-9·scale` before moving back, collapses Manifold's own boolean slivers (vertices 1e-12 apart)
+  while that is safe -- off the origin, Manifold collapsed them itself and once lost 0.114.
+- `cleanShells`: zero-volume shells are dropped, and each remaining shell is probed against the
+  definition (in A, in a piece) so a spurious solid or void goes and a real one stays. A void is
+  never `Compose`d back (Compose ignores an inside-out shell): solids minus voids turned right side
+  out.
+- `|d|` below `1e-7` of the part's size returns the input: double precision cannot place it.
+
+**Known limits.** Exact-contact chamfer cases (two faces meeting at precisely the distance where a
+chamfer closes) can come out with the wrong genus, 4 of the 96 in the review suite. Speed is about
+2 s for a 32-segment sphere's `delta=1` (pieces built single-threaded 1.1 s, union 0.85 s, lost
+check 0.4 s), so it is a tool for parts, not for dense scans. `OFFSET3D_TIMING=1` prints each phase's
+wall time to stderr. `_offset3d(verts, tris, d, mode, segs)` in the Python facade is the test hook
+the prototype's suites run against; not public API. Tests: `tests/test_offset3d.cpp`.

{openscad_cpp_evaluator-1.51.0 → openscad_cpp_evaluator-1.52.0}/CMakeLists.txt

@@ -120,9 +120,13 @@ target_include_directories(openscad_cpp_parser PUBLIC
 include(FetchContent)
 
 # MANIFOLD_TEST off: we don't want Manifold's own (large) test/sample/extras
-# suite built as part of this project. MANIFOLD_PAR stays at its own default
-# (OFF) -- no TBB parallel backend needed yet; revisit if profiling later
-# shows single-threaded Boolean ops are a bottleneck. MANIFOLD_CROSS_SECTION
+# suite built as part of this project. MANIFOLD_PAR on: Manifold's TBB
+# backend made 3D offset() 2.1-3.3x faster (sphere(10,32) delta=1: 3.6 s ->
+# 1.7 s), and big booleans with it. TBB is always Manifold's own pinned copy
+# (oneTBB v2022.3.0, fetched and linked statically): a system TBB found by
+# find_package would make the wheel depend on a library it does not ship.
+# Booleans are not order-independent under it -- the same pieces unioned
+# differently -- which offset3d.cpp's lostPieces() checks for. MANIFOLD_CROSS_SECTION
 # stays at its own default (ON) -- 2D CrossSection support is needed from
 # Phase 3 onward.
 #
@@ -137,6 +141,8 @@ include(FetchContent)
 # fixes Windows and is a no-op everywhere else this project already worked.
 set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
 set(MANIFOLD_TEST OFF CACHE BOOL "" FORCE)
+set(MANIFOLD_PAR ON CACHE BOOL "" FORCE)
+set(MANIFOLD_USE_BUILTIN_TBB ON CACHE BOOL "" FORCE)
 FetchContent_Declare(
   manifold
   GIT_REPOSITORY https://github.com/elalish/manifold.git

{openscad_cpp_evaluator-1.51.0 → openscad_cpp_evaluator-1.52.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.51.0 → openscad_cpp_evaluator-1.52.0}/bindings/module.cpp

@@ -25,6 +25,7 @@
 #include "openscad_cpp_evaluator/export.hpp"
 #include "openscad_cpp_evaluator/freetype_font_provider.hpp"
 #include "openscad_cpp_evaluator/mesh_check.hpp"
+#include "openscad_cpp_evaluator/offset3d.hpp"
 #include "openscad_cpp_evaluator/manifold_cache.hpp"
 #include "openscad_cpp_evaluator/coverage.hpp"
 #include "openscad_cpp_evaluator/profile.hpp"
@@ -306,6 +307,30 @@ nb::tuple stripSliversPy(const std::vector<float>& verts, const std::vector<uint
     return nb::make_tuple(out.vertProperties, out.triVerts, rep);
 }
 
+// offset() on one closed mesh, without a script round trip: what the 3D
+// offset's test suites drive. Double precision both ways -- the float32
+// MeshGL is ~0.008 of resolution at 1e5. mode is "r", "delta" or "chamfer".
+nb::tuple offset3dPy(const std::vector<double>& verts, const std::vector<uint64_t>& tris, double d,
+                     const std::string& mode, int segs) {
+    manifold::MeshGL64 m;
+    m.numProp = 3;
+    m.vertProperties = verts;
+    m.triVerts = tris;
+    const oscadeval::Offset3DMode md = mode == "r"         ? oscadeval::Offset3DMode::Round
+                                       : mode == "chamfer" ? oscadeval::Offset3DMode::Chamfer
+                                                           : oscadeval::Offset3DMode::Delta;
+    manifold::MeshGL64 out;
+    std::vector<double> ov;
+    {
+        nb::gil_scoped_release rel;
+        out = oscadeval::offset3d(manifold::Manifold(m), d, md, segs).GetMeshGL64();
+        ov.reserve(out.NumVert() * 3);
+        for (size_t i = 0; i < out.NumVert(); ++i)
+            for (size_t k = 0; k < 3; ++k) ov.push_back(out.vertProperties[i * out.numProp + k]);
+    }
+    return nb::make_tuple(ov, out.triVerts);
+}
+
 nb::dict checkMeshPy(const std::vector<float>& verts, const std::vector<uint32_t>& tris) {
     manifold::MeshGL m;
     m.numProp = 3;
@@ -1052,6 +1077,9 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
     m.def("strip_slivers", &stripSliversPy, nb::arg("verts"), nb::arg("tris"),
           "Remove zero-area faces and repair the T-joints their removal "
           "exposes. Returns (verts, tris, report).");
+    m.def("offset3d", &offset3dPy, nb::arg("verts"), nb::arg("tris"), nb::arg("d"), nb::arg("mode"),
+          nb::arg("segs"),
+          "3D offset of one closed mesh: returns (verts, tris) as flat lists.");
     m.def("check_mesh", &checkMeshPy, nb::arg("verts"), nb::arg("tris"),
           "Diagnose a triangle mesh against the manifoldness conditions. "
           "verts is a flat [x,y,z,...] list, tris a flat index list. Returns "

openscad_cpp_evaluator-1.52.0/include/openscad_cpp_evaluator/offset3d.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+// offset() on a 3D solid: r= (rounded, an inscribed faceted ball), delta=
+// (mitered, no limit, as 2D) and chamfer= (corners cut flat), outward for
+// d > 0 and inward for d < 0. Pure geometry: no evaluator state. See
+// offset3d.cpp for the construction and CLAUDE.md "offset() in 3D".
+
+#include <manifold/manifold.h>
+
+namespace oscadeval {
+
+enum class Offset3DMode { Round, Delta, Chamfer };
+
+manifold::Manifold offset3d(const manifold::Manifold& m, double d, Offset3DMode mode, int segs);
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.51.0 → openscad_cpp_evaluator-1.52.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.51.0 → openscad_cpp_evaluator-1.52.0}/python/openscad_cpp_evaluator/__init__.py

@@ -419,6 +419,13 @@ def export_extensions() -> list:
     return list(_ext.export_extensions())
 
 
+def _offset3d(verts, tris, d, mode="delta", segs=24):
+    """3D offset of one closed mesh, as offset() does it for a solid: flat
+    vertex/triangle lists in, flat lists out. mode is "r", "delta" or
+    "chamfer". A test hook for the offset's suites, not public API."""
+    return _ext.offset3d([float(v) for v in verts], [int(t) for t in tris], float(d), mode, int(segs))
+
+
 def check_mesh(verts, tris) -> dict:
     """Diagnose a triangle mesh against the manifoldness conditions.
 

{openscad_cpp_evaluator-1.51.0 → openscad_cpp_evaluator-1.52.0}/src/CMakeLists.txt

@@ -48,6 +48,7 @@ add_library(openscad_cpp_evaluator STATIC
   builtins/import.cpp
   builtins/topology.cpp
   builtins/alpha_wrap.cpp
+  builtins/offset3d.cpp
   builtins/export_as.cpp
   ../third_party/predicates/predicates.c
   builtins/extrude.cpp

{openscad_cpp_evaluator-1.51.0 → openscad_cpp_evaluator-1.52.0}/src/builtins/extrude.cpp

@@ -1,4 +1,5 @@
 #include "builtins.hpp"
+#include "openscad_cpp_evaluator/offset3d.hpp"
 
 #include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/evaluator.hpp"
@@ -542,17 +543,46 @@ CSGParams resolveOffset(Evaluator& ev, const oscad::ModularCall& node, EvalConte
     return std::move(result.params);
 }
 
-std::vector<ColoredBody> generateOffset(Evaluator&, const CSGParams& params, const std::vector<std::unique_ptr<CSGNode>>& children,
-                                         const oscad::ASTNode&) {
+std::vector<ColoredBody> generateOffset(Evaluator& ev, const CSGParams& params,
+                                         const std::vector<std::unique_ptr<CSGNode>>& children,
+                                         const oscad::ASTNode& node) {
     const std::vector<ColoredBody> bodies = flattenCsgTree(children);
+    const double delta = std::get<double>(params.at("delta"));
+    const std::string& join = std::get<std::string>(params.at("join"));
+    const int segs = static_cast<int>(std::get<double>(params.at("segs")));
+
+    // 3D children (the dimension rule has already settled on one dimension
+    // and warned about the rest): the solid offset of offset3d.cpp.
+    const RoleSplit split = splitByRole(bodies);
+    std::vector<const ColoredBody*> solids;
+    for (const ColoredBody& b : split.foreground)
+        if (b.body && !b.body->IsEmpty()) solids.push_back(&b);
+    if (!solids.empty()) {
+        std::vector<ColoredBody> out;
+        if (std::isfinite(delta)) {
+            std::vector<manifold::Manifold> ms;
+            for (const ColoredBody* b : solids) ms.push_back(*b->body);
+            const manifold::Manifold a =
+                ms.size() == 1 ? ms[0] : manifold::Manifold::BatchBoolean(ms, manifold::OpType::Add);
+            const Offset3DMode mode = join == "round"    ? Offset3DMode::Round
+                                      : join == "square" ? Offset3DMode::Chamfer
+                                                         : Offset3DMode::Delta;
+            manifold::Manifold result = offset3d(a, delta, mode, segs);
+            if (!result.IsEmpty()) {
+                ColoredBody cb = ev.tagGenerated(std::move(result), node, Value{});
+                cb.color = valueToColor(params.at("color"));
+                out.push_back(std::move(cb));
+            }
+        }
+        for (const auto* group : {&split.background, &split.highlight, &split.showOnly, &split.displayOnly})
+            out.insert(out.end(), group->begin(), group->end());
+        return out;
+    }
+
     const std::optional<manifold::CrossSection> cs = toCrossSection(bodies);
     if (!cs) return {};
-
-    const double delta = std::get<double>(params.at("delta"));
     // An infinite (or NaN) distance has no shape to give.
     if (!std::isfinite(delta)) return {};
-    const std::string& join = std::get<std::string>(params.at("join"));
-    const int segs = static_cast<int>(std::get<double>(params.at("segs")));
     using JT = manifold::CrossSection::JoinType;
     const JT jt = join == "round" ? JT::Round : join == "square" ? JT::Square : JT::Miter;
     // "miter" joins stay sharp however acute the corner: no realistic

{openscad_cpp_evaluator-1.51.0 → openscad_cpp_evaluator-1.52.0}/src/builtins/function_builtins.cpp

@@ -1003,6 +1003,7 @@ const std::unordered_map<std::string, double>& featureLevels() {
         {"profile-time", 1.0},       // profile_time(label) { ... } and profile_time(label) expr
         {"alpha-wrap", 1.0},         // alpha_wrap(alpha, offset)
         {"export-as", 1.0},          // export_as(name) { ... }
+        {"offset-3d", 1.0},          // offset(r=|delta=, chamfer=) on a solid, in and out
     };
     return levels;
 }