openscad-cpp-evaluator 1.49.9__tar.gz → 1.50.1__tar.gz

{openscad_cpp_evaluator-1.49.9 → openscad_cpp_evaluator-1.50.1}/CLAUDE.md

@@ -1970,3 +1970,40 @@ is evaluated before the clock starts. Times under 1 ms print in microseconds (`f
   after the body, which a tail step would not wait for.
 - `PROFILE:` lines go straight to `echoFn_`, not through `emitWarning`, so the ManifoldCache never
   stores or replays them (a replay would print a stale time as if it were current).
+
+## `alpha_wrap()`
+
+`alpha_wrap(alpha, offset) { ... }` shrink-wraps its children in a closed, manifold skin
+(BelfrySCAD #941; `supported_feature("alpha-wrap")` is 1). The skin follows any concavity a ball
+of radius `alpha` can enter and bridges any gap or hole narrower than that; every point of it lies
+`offset` outside the input. Defaults are CGAL's: alpha 1/20 of the bounding-box diagonal, offset
+alpha/30. All Normal 3D children are wrapped together into one body taking the first one's colour,
+**including an open `polyhedron()`'s raw triangles** (`ColoredBody::rawMesh`) -- wrapping geometry
+too broken for Manifold is half the point. 2D children and `%`/`#` bodies pass through (2D with a
+warning). A non-positive or non-numeric `alpha`/`offset` warns and leaves the children as they were.
+
+### Implementation notes
+
+- `src/builtins/alpha_wrap.cpp`, written **from the paper** (Portaneri et al., "Alpha Wrapping with
+  an Offset", SIGGRAPH 2022) and CGAL's user manual -- **not** from CGAL's `Alpha_wrap_3` source,
+  which is GPL and cannot be carried into this MIT project. Keep it that way: do not paste from CGAL.
+- Delaunay is our own Bowyer-Watson insertion over **Shewchuk's exact predicates**
+  (`third_party/predicates/`, public domain, the original file minus its `random()` test helpers,
+  which MSVC lacks). They are K&R C, so the project enables `C`; `predicates.c` is compiled with
+  warnings off and must never see fast-math. `exactinit()` runs once (`std::call_once`).
+- Four far "super" vertices stand in for the infinite vertex; a cell using one is outside and never
+  entered. The loose box's 8 corners are jittered by 1e-9 of the diagonal so no four are
+  cospherical; Steiner points are not jittered, and a tie (`insphere == 0`) counts as no conflict.
+- Gates are ordered by the smallest empty sphere through the face (its centre on the dual Voronoi
+  edge, nearest the face's circumcentre). Rule 1 finds where the Voronoi edge first meets the offset
+  surface by **sphere tracing** -- the distance to the input is 1-Lipschitz, so stepping by
+  `distance - offset` cannot overshoot. Rule 2 projects the circumcentre of a cell that overlaps the
+  input (separating-axis tet/triangle test over a BVH) onto the offset surface.
+- The skin is built as `MeshGL64`: rounding Steiner points to float can fold the thin triangles a
+  small offset produces. Input is read from each body's float `MeshGL`.
+- `checkCancel()` every 256 gates; a 5M-Steiner-point runaway guard warns and returns the children.
+- Measured: a 242-triangle bracket wraps in 5 ms at alpha 3 (362 faces) and 137 ms at alpha 0.5
+  (11.9k faces); extruded text, 2,468 triangles, 0.7 s at alpha 0.5 and 4 s at alpha 0.2 (102k
+  faces). Time follows OUTPUT size. Not done: CGAL's manifold post-pass for very thin features
+  (no failure seen yet), and the same input scaled can differ by a near-tie or two (same shape,
+  volume within 0.2%), which is why `DefaultsScaleWithTheModel` compares within tolerances.

{openscad_cpp_evaluator-1.49.9 → openscad_cpp_evaluator-1.50.1}/CMakeLists.txt

@@ -11,7 +11,8 @@ if(NOT _oscad_pyproject MATCHES "\nversion = \"([0-9]+)\.([0-9]+)\.([0-9]+)\"")
 endif()
 set(OSCAD_EVAL_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}")
 
-project(openscad_cpp_evaluator VERSION ${OSCAD_EVAL_VERSION} LANGUAGES CXX)
+# C for third_party/predicates (Shewchuk's robust predicates, used by alpha_wrap).
+project(openscad_cpp_evaluator VERSION ${OSCAD_EVAL_VERSION} LANGUAGES C CXX)
 
 # On Apple Silicon, warn (don't fail -- a universal or intentionally-x86_64
 # build is legitimate) if the effective target architecture is x86_64 while

{openscad_cpp_evaluator-1.49.9 → openscad_cpp_evaluator-1.50.1}/PKG-INFO

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

{openscad_cpp_evaluator-1.49.9 → openscad_cpp_evaluator-1.50.1}/external/openscad_cpp_parser/src/grammar/lexer.l

@@ -88,7 +88,17 @@ NUMLIT  0[xX][0-9A-Fa-f]+|[0-9]+([.][0-9]*)?([eE][+-]?[0-9]+)?|[.][0-9]+([eE][+-
     // U+FEFF (EF BB BF, a byte-order mark, anywhere in the file) and a bare
     // A0, Latin-1's no-break space.
 }
-"//"[^\n]*               { /* skip line comment */ }
+\xe2\x80\xa8|\xe2\x80\xa9|\xc2\x85 {
+    // U+2028 LINE SEPARATOR, U+2029 PARAGRAPH SEPARATOR and U+0085 NEXT
+    // LINE: line breaks to look at, so whitespace that also ends a `//`
+    // comment (below). Qt's editor types U+2028 for Shift+Enter, and it
+    // shows as a new line (BelfrySCAD #949). It does NOT count as a line:
+    // the editor numbers its lines by block and a U+2028 sits inside one,
+    // so every line and column after it still matches the editor's.
+    // OpenSCAD's lexer rejects all three.
+}
+    /* A line comment ends at a newline or at any separator above. */
+"//"([^\n\xe2\xc2]|\xe2[^\x80\n]|\xe2\x80[^\xa8\xa9\n]|\xc2[^\x85\n])* { /* skip line comment */ }
 "/*"([^*]|\*+[^*/])*\*+"/" { /* skip block comment */ }
 
 {IDENT} {

{openscad_cpp_evaluator-1.49.9 → openscad_cpp_evaluator-1.50.1}/external/openscad_cpp_parser/tests/test_lexical.cpp

@@ -483,6 +483,22 @@ TEST(LexicalWhitespace, NoBreakSpaceByteOrderMarkAndLatin1A0) {
     }
 }
 
+// U+2028/U+2029/U+0085 are whitespace that ends a line comment, without
+// counting as a line (BelfrySCAD's editor numbers lines by block, and a
+// U+2028 sits inside one).
+TEST(LexicalWhitespace, UnicodeLineSeparatorsEndACommentButNotALine) {
+    for (const char* sep : {"\xe2\x80\xa8", "\xe2\x80\xa9", "\xc2\x85"}) {
+        const std::string src = std::string("a = 1;") + sep + "b = 2; // note" + sep + "c = 3;\nd = 4;";
+        auto ast = parseSrc(src);
+        ASSERT_EQ(ast.size(), 4u) << "the comment swallowed c = 3";
+        EXPECT_EQ(ast[2]->position().line, 1);
+        EXPECT_EQ(size_t(ast[2]->position().start_offset), src.find("c = 3"));
+        EXPECT_EQ(ast[3]->position().line, 2);
+    }
+    // Other multi-byte characters stay inside the comment.
+    EXPECT_EQ(parseSrc("a = 1; // \xe2\x80\x94 \xc2\xa0 \xe2\x82\xac c = 3;\nb = 2;").size(), 2u);
+}
+
 // The message quotes a whole character, and names a byte that starts none,
 // so it is always valid UTF-8.
 TEST(LexicalWhitespace, UnexpectedCharacterMessageIsValidUtf8) {

{openscad_cpp_evaluator-1.49.9 → openscad_cpp_evaluator-1.50.1}/pyproject.toml

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

{openscad_cpp_evaluator-1.49.9 → openscad_cpp_evaluator-1.50.1}/src/CMakeLists.txt

@@ -47,6 +47,8 @@ add_library(openscad_cpp_evaluator STATIC
   builtins/function_builtins.cpp
   builtins/import.cpp
   builtins/topology.cpp
+  builtins/alpha_wrap.cpp
+  ../third_party/predicates/predicates.c
   builtins/extrude.cpp
   builtins/roof.cpp
   builtins/surface.cpp
@@ -73,6 +75,11 @@ target_compile_options(openscad_cpp_evaluator PRIVATE
   $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall;-Wextra>
 )
 
+# Shewchuk's predicates are 1996 K&R C, kept as published: quiet, and never
+# with fast-math, which would break their exact arithmetic.
+set_source_files_properties(../third_party/predicates/predicates.c PROPERTIES
+  COMPILE_OPTIONS "$<IF:$<C_COMPILER_ID:MSVC>,/w,-w>")
+
 # -Wall -Wextra above is about OUR code, but two TUs pull a vendored header
 # in wholesale and inherit its warnings: 27 from Boost.Polygon's voronoi
 # headers and 9 from stb_image_write's implementation, against 5 that were