planex2d 0.2.0__tar.gz → 0.2.2__tar.gz

{planex2d-0.2.0 → planex2d-0.2.2}/CMakeLists.txt

@@ -106,7 +106,9 @@ function(planex_module name kind)
             if("x86_64" IN_LIST CMAKE_OSX_ARCHITECTURES)
                 target_compile_options(${name} PRIVATE "SHELL:-Xarch_x86_64 -march=core-avx2")
             endif()
-        elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64" AND NOT MSVC)
+        elseif(MSVC AND CMAKE_SYSTEM_PROCESSOR MATCHES "AMD64")
+            target_compile_options(${name} PRIVATE /arch:AVX2)
+        elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
             target_compile_options(${name} PRIVATE -march=core-avx2)
         endif()
     endif()
@@ -118,6 +120,14 @@ function(planex_module name kind)
     if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
         target_compile_options(${name} PRIVATE -ffp-contract=on)
     endif()
+    # a binding file has more sections than an MSVC object file holds by default; the sources are UTF-8, whatever the
+    # code page of the machine that builds; Visual Studio's generator compiles a target's files one after the other
+    # unless /MP, here as many at a time as the memory holds. Since Visual Studio 2022 17.10 a std::mutex built by the
+    # compiler crashes on its first lock when an older msvcp140.dll is already loaded in the Python process
+    if(MSVC)
+        target_compile_options(${name} PRIVATE /bigobj /utf-8 /MP${PLANEX_COMPILE_JOBS})
+        target_compile_definitions(${name} PRIVATE _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
+    endif()
     if(kind STREQUAL "occ")
         install(TARGETS ${name} LIBRARY DESTINATION ${PLANEX_OCC_DESTINATION})
     else()

{planex2d-0.2.0 → planex2d-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: planex2d
-Version: 0.2.0
+Version: 0.2.2
 Summary: Fast, exact 2D geometry for Python: sketches, constraint solving, exact Boolean operations and offsets, with export to OpenCASCADE, netgen/NGSolve and gmsh
 Keywords: geometry,2D,CAD,sketch,constraint solver,Boolean operations,offset,OpenCASCADE,netgen,NGSolve,meshing
 Author: Sebastian Hirnschall
@@ -42,7 +42,8 @@ Description-Content-Type: text/markdown
   <a href="https://planex2d.org/docs/">Documentation</a> ·
   <a href="https://planex2d.org/docs/core/installation.html">Installation</a> ·
   <a href="https://planex2d.org/docs/examples/index.html">Examples</a> ·
-  <a href="https://planex2d.org/docs/core/notices.html">License and notices</a>
+  <a href="https://planex2d.org/docs/core/notices.html">License and notices</a><br>
+  <a href="https://doi.org/10.5281/zenodo.23718969"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.23718969.svg" alt="DOI 10.5281/zenodo.23718969"></a>
 </p>
 
 planex2d is free software under the GNU Lesser General Public License, version 2.1 or (at your option) any later
@@ -67,13 +68,15 @@ pip install "planex2d[occ]"   # with the OpenCASCADE bindings and netgen
 
 The quotes keep shells like zsh, the default on macOS, from reading the brackets as a file pattern.
 
-planex2d comes as wheels for Linux (x86_64 and aarch64) and macOS (Apple silicon and Intel, macOS 13.3 or newer), for
-Python 3.11 to 3.14; Windows follows with version 0.2.1. The core runs on numpy alone. The extra `occ` installs
-planex2d-occ, the OpenCASCADE bindings built for the last netgen releases (on Linux x86_64 and macOS, where netgen has
-wheels), and netgen with it; planex picks the bindings for the installed netgen. The package is called `planex2d` on
-PyPI and `planex` in Python (`import planex as px`). See
-[Installation](https://planex2d.org/docs/core/installation.html) for the optional packages and for building from source
-(a C++20 compiler, CMake; Xcode 16 on macOS).
+planex2d comes as wheels for Linux (x86_64 and aarch64), macOS (Apple silicon and Intel, macOS 13.3 or newer) and
+Windows (x86-64), for Python 3.11 to 3.14; on Windows it needs the latest
+[Microsoft Visual C++ Redistributable](https://aka.ms/vc14/vc_redist.x64.exe) (x64), which most machines have. The core
+runs on numpy alone. The extra `occ` installs planex2d-occ, the
+OpenCASCADE bindings built for the last netgen releases (on Linux x86_64, macOS and Windows, where netgen has wheels),
+and netgen with it; planex picks the bindings for the installed netgen. The package is called `planex2d` on PyPI and
+`planex` in Python (`import planex as px`). See [Installation](https://planex2d.org/docs/core/installation.html) for the
+optional packages and for building from source (a C++20 compiler, CMake; Xcode 16 on macOS, Visual Studio 2022 on
+Windows).
 
 ## A first sketch
 
@@ -88,7 +91,7 @@ bracket = px.QuickSketch()
 bracket.Line(60).Turn(90).Line(10).Turn(90).Line(40)
 bracket.Arc(10, -90).Line(30).Turn(90).Line(10).Close()
 bracket.Circle((45, 5), 2.5).Circle((5, 35), 2.5)
-face = px.Face(bracket.Wires())
+face = bracket.Face()
 face.Plot()
 ```
 
@@ -110,6 +113,12 @@ face.Plot()
 - [Benchmarks](https://planex2d.org/docs/core/comparison/index.html): planex2d next to OpenCASCADE and polygon libraries on
   the same tasks.
 
+## Citing
+
+If you use planex2d in research, please cite it with its Zenodo DOI,
+[10.5281/zenodo.23718969](https://doi.org/10.5281/zenodo.23718969), which always points to the latest version.
+[CITATION.cff](CITATION.cff) holds the citation data.
+
 ## License
 
 planex2d is Copyright (C) 2026 Sebastian Hirnschall.

{planex2d-0.2.0 → planex2d-0.2.2}/README.md

@@ -8,7 +8,8 @@
   <a href="https://planex2d.org/docs/">Documentation</a> ·
   <a href="https://planex2d.org/docs/core/installation.html">Installation</a> ·
   <a href="https://planex2d.org/docs/examples/index.html">Examples</a> ·
-  <a href="https://planex2d.org/docs/core/notices.html">License and notices</a>
+  <a href="https://planex2d.org/docs/core/notices.html">License and notices</a><br>
+  <a href="https://doi.org/10.5281/zenodo.23718969"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.23718969.svg" alt="DOI 10.5281/zenodo.23718969"></a>
 </p>
 
 planex2d is free software under the GNU Lesser General Public License, version 2.1 or (at your option) any later
@@ -33,13 +34,15 @@ pip install "planex2d[occ]"   # with the OpenCASCADE bindings and netgen
 
 The quotes keep shells like zsh, the default on macOS, from reading the brackets as a file pattern.
 
-planex2d comes as wheels for Linux (x86_64 and aarch64) and macOS (Apple silicon and Intel, macOS 13.3 or newer), for
-Python 3.11 to 3.14; Windows follows with version 0.2.1. The core runs on numpy alone. The extra `occ` installs
-planex2d-occ, the OpenCASCADE bindings built for the last netgen releases (on Linux x86_64 and macOS, where netgen has
-wheels), and netgen with it; planex picks the bindings for the installed netgen. The package is called `planex2d` on
-PyPI and `planex` in Python (`import planex as px`). See
-[Installation](https://planex2d.org/docs/core/installation.html) for the optional packages and for building from source
-(a C++20 compiler, CMake; Xcode 16 on macOS).
+planex2d comes as wheels for Linux (x86_64 and aarch64), macOS (Apple silicon and Intel, macOS 13.3 or newer) and
+Windows (x86-64), for Python 3.11 to 3.14; on Windows it needs the latest
+[Microsoft Visual C++ Redistributable](https://aka.ms/vc14/vc_redist.x64.exe) (x64), which most machines have. The core
+runs on numpy alone. The extra `occ` installs planex2d-occ, the
+OpenCASCADE bindings built for the last netgen releases (on Linux x86_64, macOS and Windows, where netgen has wheels),
+and netgen with it; planex picks the bindings for the installed netgen. The package is called `planex2d` on PyPI and
+`planex` in Python (`import planex as px`). See [Installation](https://planex2d.org/docs/core/installation.html) for the
+optional packages and for building from source (a C++20 compiler, CMake; Xcode 16 on macOS, Visual Studio 2022 on
+Windows).
 
 ## A first sketch
 
@@ -54,7 +57,7 @@ bracket = px.QuickSketch()
 bracket.Line(60).Turn(90).Line(10).Turn(90).Line(40)
 bracket.Arc(10, -90).Line(30).Turn(90).Line(10).Close()
 bracket.Circle((45, 5), 2.5).Circle((5, 35), 2.5)
-face = px.Face(bracket.Wires())
+face = bracket.Face()
 face.Plot()
 ```
 
@@ -76,6 +79,12 @@ face.Plot()
 - [Benchmarks](https://planex2d.org/docs/core/comparison/index.html): planex2d next to OpenCASCADE and polygon libraries on
   the same tasks.
 
+## Citing
+
+If you use planex2d in research, please cite it with its Zenodo DOI,
+[10.5281/zenodo.23718969](https://doi.org/10.5281/zenodo.23718969), which always points to the latest version.
+[CITATION.cff](CITATION.cff) holds the citation data.
+
 ## License
 
 planex2d is Copyright (C) 2026 Sebastian Hirnschall.

{planex2d-0.2.0 → planex2d-0.2.2}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "scikit_build_core.build"
 [project]
 name = "planex2d"
 # a release takes its version from its git tag: the publish workflow writes it here (v0.1.0 gives 0.1.0)
-version = "0.2.0"
+version = "0.2.2"
 description = "Fast, exact 2D geometry for Python: sketches, constraint solving, exact Boolean operations and offsets, with export to OpenCASCADE, netgen/NGSolve and gmsh"
 readme = "README.md"
 authors = [{name = "Sebastian Hirnschall"}]

{planex2d-0.2.0 → planex2d-0.2.2}/src/boolean/boolean.hpp

@@ -64,15 +64,15 @@ namespace planex2d {
             // other operand can have new vertices, all others were snapped before
             static Timer tsnap("planex Boolean snap");
             Region regsnap(tsnap);
-            auto near = [&](size_t k) { return state[k].needsCutting; };
+            auto nearOther = [&](size_t k) { return state[k].needsCutting; };
             double s = 0.0;
             for (size_t k = 0; k < c.Size(); ++k)
-                if (near(k))
+                if (nearOther(k))
                     s = std::max(s, LengthScaleOf(c[k]));
-            ApplyIdentified(c, state, ids, near);
+            ApplyIdentified(c, state, ids, nearOther);
             ShareCongruent(c, grid, state, false, Tol(s));
             for (size_t k = 0; k < c.Size(); ++k)
-                if (!state[k].excluded && near(k))
+                if (!state[k].excluded && nearOther(k))
                     grid.Insert(k, BoxOf(c[k]));
             snapTol = Tol(s);
         }
@@ -234,7 +234,7 @@ namespace planex2d {
         const double tol = Tol(std::max(a.LengthScale(), b.LengthScale()));
         Grid grid = b.EdgeGrid();
         std::vector<Vertex> pts;
-        std::vector<uint32_t> near;
+        std::vector<uint32_t> nearby;
         // a point inside a stretch where a runs along b (the joints of a spline's pieces there) is no meeting point,
         // the stretch's ends are: a little before and after it along its edge of a, a still lies on b
         auto alongB = [&](const Vertex &q) {
@@ -252,9 +252,9 @@ namespace planex2d {
             return inner && alongB(PointAtFraction(e, t - step)) && alongB(PointAtFraction(e, t + step));
         };
         for (const Edge &ea : a) {
-            near.clear();
-            grid.InBox(BoxOf(ea).Grown(tol), near);
-            for (uint32_t j : near)
+            nearby.clear();
+            grid.InBox(BoxOf(ea).Grown(tol), nearby);
+            for (uint32_t j : nearby)
                 std::visit([&](const auto &x, const auto &y) {
                     ForEachPart(x, [&](const auto &pa) {
                         ForEachPart(y, [&](const auto &pb) {

{planex2d-0.2.0 → planex2d-0.2.2}/src/boolean/cut.hpp

@@ -669,12 +669,12 @@ namespace planex2d {
             for (const PrimitiveEdge &p : pb)
                 boxes.push_back(BoxOf(p));
             Grid grid = Grid::OfBoxes(boxes);
-            std::vector<uint32_t> near;
+            std::vector<uint32_t> nearby;
             for (const PrimitiveEdge &p : a.Approximation()) {
-                near.clear();
-                grid.InBox(BoxOf(p).Grown(2.0 * tol), near);
-                std::sort(near.begin(), near.end());
-                for (uint32_t j : near)
+                nearby.clear();
+                grid.InBox(BoxOf(p).Grown(2.0 * tol), nearby);
+                std::sort(nearby.begin(), nearby.end());
+                for (uint32_t j : nearby)
                     std::visit([&](const auto &x, const auto &y) { f(x, y); }, p, pb[j]);
             }
         } else {

{planex2d-0.2.0 → planex2d-0.2.2}/src/boolean/cutloop.hpp

@@ -63,14 +63,14 @@ namespace planex2d {
         const double tol = Tol(scale);
         Grid grid = w.EdgeGrid();
         std::vector<std::vector<Vertex>> at(w.Size());
-        std::vector<uint32_t> near;
+        std::vector<uint32_t> nearby;
         for (size_t i = 0; i < w.Size(); ++i) {
             const Circle *c = std::get_if<Circle>(&w[i]);
             if (!c || state[i].excluded || !state[i].needsCutting)
                 continue;
-            near.clear();
-            grid.InBox(BoxOf(w[i]).Grown(tol), near);
-            for (uint32_t j : near) {
+            nearby.clear();
+            grid.InBox(BoxOf(w[i]).Grown(tol), nearby);
+            for (uint32_t j : nearby) {
                 const Circle *other = std::get_if<Circle>(&w[j]);
                 if (j == i || (other && j < i) || !state[i].CanCut(state[j]) || (other && c->IsCongruent(*other, tol)))
                     continue;
@@ -198,14 +198,14 @@ namespace planex2d {
             if (!state[k].excluded && state[k].needsCutting)
                 scale = std::max(scale, LengthScaleOf(w[k]));
         const double tol = Tol(scale);
-        std::vector<uint32_t> near;
+        std::vector<uint32_t> nearby;
         for (size_t i = 0; i < w.Size(); ++i) {
             if (state[i].excluded || !state[i].needsCutting)
                 continue;
-            near.clear();
-            grid.InBox(BoxOf(w[i]).Grown(tol), near);
-            std::sort(near.begin(), near.end());
-            for (uint32_t j : near) {
+            nearby.clear();
+            grid.InBox(BoxOf(w[i]).Grown(tol), nearby);
+            std::sort(nearby.begin(), nearby.end());
+            for (uint32_t j : nearby) {
                 if (state[i].excluded)
                     break;
                 if (j <= i || !state[i].CanCut(state[j]))

{planex2d-0.2.0 → planex2d-0.2.2}/src/constraint_sketch/constraintsketch.hpp

@@ -187,7 +187,7 @@ namespace planex2d {
         }
 
         // as BasicSketch::Cut; not of a piece of an offset, and an expression that used what goes goes too
-        ConstraintSketch &Cut(const std::string &id, const std::vector<std::string> &cutterIds, std::optional<Vertex> near, bool reverse,
+        ConstraintSketch &Cut(const std::string &id, const std::vector<std::string> &cutterIds, std::optional<Vertex> nearPoint, bool reverse,
                               bool trim, bool tied = true) override {
             const std::string call = std::string(trim ? "Trim" : "Split") + "('" + id + "')";
             Flush();
@@ -199,7 +199,7 @@ namespace planex2d {
                                                 " follow it as it is; Split it with auto_constraint=True, or Remove them first");
             sketch::Undoable(*this, [&] {
                 const std::map<size_t, std::string> held = ValueHolders();
-                CutPieces(id, cutterIds, near, reverse, trim, tied, call);
+                CutPieces(id, cutterIds, nearPoint, reverse, trim, tied, call);
                 Prune(call, held);
                 if (const std::optional<std::string> wrong = OffsetProblem())
                     throw std::invalid_argument(call + ": " + *wrong);

{planex2d-0.2.0 → planex2d-0.2.2}/src/constraint_sketch/shapedsystem.hpp

@@ -16,9 +16,9 @@ namespace planex2d::cs {
 
     // a system as the solver sees it with the drawn shapes kept: a row per shape value of an element (a line's end minus
     // its start, an arc's ends from its centre, a spline's steps from point to point, every value of an element that is
-    // no point coordinate, every other unknown) whose change from ref goes into a slack unknown of its own, and the
-    // system's own unknowns counted by moveWeight: the least change then moves the geometry as a whole where it can and
-    // changes the drawn shapes as little as it can
+    // no point coordinate, every other unknown) whose change from ref goes into a slack unknown of its own, the slacks
+    // counted 1 / moveWeight times as much as the system's own unknowns: the least change then moves the geometry as a
+    // whole where it can and changes the drawn shapes as little as it can
     template <class S>
     class ShapedSystem {
         public:
@@ -78,20 +78,19 @@ namespace planex2d::cs {
                 J[slack] = -1.0;
             }
 
-            // the system's unknowns counted by moveWeight, then the slacks, each at its row's change from ref; the unknowns
-            // follow the solution in the solver's later pull rounds (Unknowns::follow), the slacks keep their target, no
-            // change of shape: the shapes then end as close to ref as the constraints let them, not moveWeight short of it
+            // the system's unknowns at their own scale, then the slacks, each at its row's change from ref, at the scale
+            // sqrt(moveWeight); the unknowns follow the solution in the solver's later pull rounds (Unknowns::follow), the
+            // slacks keep their target, no change of shape: the shapes then end as close to ref as the constraints let
+            // them, not moveWeight short of it
             Unknowns Extended(Unknowns x) const {
-                const double weight = 1.0 / std::sqrt(moveWeight);
-                for (double &scale : x.scale)
-                    scale *= weight;
+                const double slackScale = std::sqrt(moveWeight);
                 x.follow.assign(x.value.size(), 1);
                 for (const Row &row : shape) {
                     double v = 0.0;
                     for (size_t k = 0; k + 1 < row.indices.size(); ++k)
                         v += row.coef[k] * (x.value[row.indices[k]] - ref[row.indices[k]]);
                     x.value.push_back(v);
-                    x.scale.push_back(1.0);
+                    x.scale.push_back(slackScale);
                     x.fixed.push_back(0);
                     x.follow.push_back(0);
                 }

{planex2d-0.2.0 → planex2d-0.2.2}/src/constraint_sketch/solver.hpp

@@ -178,8 +178,9 @@ namespace planex2d {
         bool solved = true;
         size_t iterations = 0;
         double residual = 0.0;
-        // asked for: the largest change of an unknown (scaled to a length) the linear prediction makes, the undamped
-        // smallest step from where the solve started
+        // asked for: the largest change of an unknown of the geometry (scaled to a length; the unknowns that follow, if
+        // any do: not a ShapedSystem's slacks) the linear prediction makes, the undamped smallest step from where the
+        // solve started
         double predicted = 0.0;
     };
 
@@ -296,7 +297,10 @@ namespace planex2d {
                         continue;
                     z = wide ? r : g;
                     cholesky.Solve(z);
-                    result.predicted = wide ? (J.transpose() * z).cwiseAbs().maxCoeff() : z.cwiseAbs().maxCoeff();
+                    const Eigen::VectorXd gaussNewton = wide ? Eigen::VectorXd(J.transpose() * z) : z;
+                    for (size_t j = 0; j < n; ++j)
+                        if (x.follow.empty() || x.follow[eq.part.unknowns[j]])
+                            result.predicted = std::max(result.predicted, std::abs(gaussNewton[j]));
                     break;
                 }
                 // a small start: the values are a good guess, the drawing; solved already: nearly undamped

{planex2d-0.2.0 → planex2d-0.2.2}/src/curves/circletouch.hpp

@@ -123,8 +123,8 @@ namespace planex2d {
         if (x == a.Center())
             return std::nullopt;
         Vertex u = Normalized(x - a.Center());
-        Vertex near = a.Center() + u * a.Radius(), far = a.Center() - u * a.Radius();
-        return std::abs(Norm(near - x) - r) <= std::abs(Norm(far - x) - r) ? near : far;
+        Vertex closest = a.Center() + u * a.Radius(), farthest = a.Center() - u * a.Radius();
+        return std::abs(Norm(closest - x) - r) <= std::abs(Norm(farthest - x) - r) ? closest : farthest;
     }
     // +1 left of a line piece or outside an arc's circle, -1 right of it or inside
     inline double Side(const PrimitiveEdge &piece, const Vertex &p) {

{planex2d-0.2.0 → planex2d-0.2.2}/src/curves/curve.hpp

@@ -244,11 +244,11 @@ namespace planex2d {
         // the stretch from a to b as a curve of its own, its ends knots of full multiplicity; a or b within 1e-9 of the
         // range of a knot is taken as that knot (OCC's Segment does the same), so no span is nearly empty
         Curve Segment(S a, S b) const {
-            const S near = 1e-9 * (Last() - First());
+            const S nearTol = 1e-9 * (Last() - First());
             for (const S &t : knots) {
-                if (std::abs(t - a) <= near)
+                if (std::abs(t - a) <= nearTol)
                     a = t;
-                if (std::abs(t - b) <= near)
+                if (std::abs(t - b) <= nearTol)
                     b = t;
             }
             std::vector<S> t = knots, w = weights;

{planex2d-0.2.0 → planex2d-0.2.2}/src/integrations/netgenocc/prism.hpp

@@ -212,12 +212,12 @@ namespace planex2d {
     // the prism cut at the plane; its end there is a cap
     inline TopoDS_Solid CutAtPlane(const TopoDS_Solid &prism, const gp_Pln &plane, const Profile &profile, const PrismCall &c) {
         const gp_Dir n = plane.Axis().Direction();
-        const FarSide far = BeyondPlane(prism, plane, c.dir.Dot(n) > 0.0 ? n : n.Reversed());
-        BRepAlgoAPI_Cut cut(prism, far.box);
+        const FarSide farSide = BeyondPlane(prism, plane, c.dir.Dot(n) > 0.0 ? n : n.Reversed());
+        BRepAlgoAPI_Cut cut(prism, farSide.box);
         if (!cut.IsDone() || cut.HasErrors())
             throw std::runtime_error(c.call + "(until=): OCC could not cut the prism at the plane");
         PropagateProperties(cut, prism);
-        const TopTools_ListOfShape &end = cut.Modified(far.bottom);
+        const TopTools_ListOfShape &end = cut.Modified(farSide.bottom);
         if (end.IsEmpty())
             throw std::runtime_error(c.call + "(until=): OCC gave no end face at the plane");
         for (const TopoDS_Shape &s : end)

{planex2d-0.2.0 → planex2d-0.2.2}/src/io/planexformat.hpp

@@ -286,8 +286,8 @@ namespace planex2d {
             a.xDirection = xyz(node["x"]);
             a.yDirection = xyz(node["y"]);
             a.normal = xyz(node["normal"]);
-            const auto near = [](double v, double want) { return std::abs(v - want) <= 1e-12; };
-            if (!near(Dot(a.normal, a.normal), 1.0) || !near(Dot(a.xDirection, a.xDirection), 1.0) || !near(Dot(a.normal, a.xDirection), 0.0) ||
+            const auto isNear = [](double v, double want) { return std::abs(v - want) <= 1e-12; };
+            if (!isNear(Dot(a.normal, a.normal), 1.0) || !isNear(Dot(a.xDirection, a.xDirection), 1.0) || !isNear(Dot(a.normal, a.xDirection), 0.0) ||
                 !(Norm(a.yDirection - Cross(a.normal, a.xDirection)) <= 1e-12))
                 throw std::invalid_argument("planex file: a plane's directions are not orthonormal and right-handed");
             return a;

{planex2d-0.2.0 → planex2d-0.2.2}/src/offset/offsetpath.hpp

@@ -268,10 +268,10 @@ namespace planex2d {
     // the raw edges through its middle, +1 each running its way, -1 each running against it
     inline int WindingStep(const Wire &cut, size_t i, const Wire &raw, Grid &grid, double tol) {
         const Vertex m = MidPointOf(cut[i]), normal = LeftNormal(cut[i], m);
-        std::vector<uint32_t> near;
-        grid.InBox(BBox::Of(m, m).Grown(tol), near);
+        std::vector<uint32_t> nearby;
+        grid.InBox(BBox::Of(m, m).Grown(tol), nearby);
         int step = 0;
-        for (uint32_t r : near) {
+        for (uint32_t r : nearby) {
             const Vertex q = NearestPointOf(raw[r], m);
             if (q.IsClose(m, tol))
                 step += Dot(LeftNormal(raw[r], q), normal) > 0.0 ? 1 : -1;

{planex2d-0.2.0 → planex2d-0.2.2}/src/python/bindings/binding.hpp

@@ -43,6 +43,7 @@
 #include "shape/fillet.hpp"
 
 namespace py = pybind11;
+// Windows' headers (through OCC) declare a global function Arc: at global scope planex's Arc is planex2d::Arc
 using namespace planex2d;
 
 namespace pybind11::detail {
@@ -598,7 +599,7 @@ inline void CheckSampleLimit(const char *call, const E &x, const char *kind, dou
 }
 
 // points along an arc from its start to its end, every chord within tol of it
-inline std::vector<Vertex> ArcPoints(const Arc &a, double tol, const char *call, const char *kind) {
+inline std::vector<Vertex> ArcPoints(const planex2d::Arc &a, double tol, const char *call, const char *kind) {
     CheckSampleLimit(call, a, kind, tol);
     // the sagitta r (1 - cos(t / 2)) as 2 r sin^2(t / 4): no cancellation for a small tol
     const double step = std::min(std::numbers::pi, 4.0 * std::asin(std::min(1.0, std::sqrt(tol / (2.0 * a.Radius())))));
@@ -617,10 +618,10 @@ inline std::vector<Vertex> ArcPoints(const Arc &a, double tol, const char *call,
 // points along the edge from its start to its end, every chord within tol of it: a line its ends, an arc by its sagitta,
 // a circle by those of its two halves, a spline as Spline::Sample
 inline std::vector<Vertex> SamplePoints(const Edge &e, double tol, const char *call) {
-    if (const Arc *a = std::get_if<Arc>(&e))
+    if (const planex2d::Arc *a = std::get_if<planex2d::Arc>(&e))
         return ArcPoints(*a, tol, call, "arc");
     if (const Circle *c = std::get_if<Circle>(&e)) {
-        const std::array<Arc, 2> halves = c->Halves();
+        const std::array<planex2d::Arc, 2> halves = c->Halves();
         std::vector<Vertex> pts = ArcPoints(halves[0], tol, call, "circle");
         const std::vector<Vertex> rest = ArcPoints(halves[1], tol, call, "circle");
         pts.insert(pts.end(), rest.begin() + 1, rest.end());
@@ -1313,7 +1314,7 @@ inline Until UntilArg(S &s, const py::handle &t, std::optional<sketch::Target> &
 // one edge: of several with the name the one nearest to near, with a warning unless near was given or they all lie
 // on one carrier
 template <class S>
-inline Edge ReferenceEdge(S &s, const py::handle &t, const Vertex &near, bool nearGiven, const std::string &call) {
+inline Edge ReferenceEdge(S &s, const py::handle &t, const Vertex &nearPoint, bool nearGiven, const std::string &call) {
     if ((py::isinstance<py::tuple>(t) || py::isinstance<py::list>(t)) && py::len(t) == 2)
         throw py::type_error(call + ": a reference edge is an id, an Edge, a Wire, a Face, a Shape or an OCC shape; "
                              "a target with a point is for the positional ends and tangent, near= picks among edges of one name");
@@ -1324,9 +1325,9 @@ inline Edge ReferenceEdge(S &s, const py::handle &t, const Vertex &near, bool ne
         if (n == 0)
             throw py::value_error(call + ": no edge named '" + name + "'");
         if (n > 1 && !nearGiven && !named.IsOnOneCarrier())
-            Warning() << call << ": " << n << " edges named '" << name << "', using the one nearest (" << near.x << ", "
-                      << near.y << ")";
-        return s.NamedEdge(name, near);
+            Warning() << call << ": " << n << " edges named '" << name << "', using the one nearest (" << nearPoint.x
+                      << ", " << nearPoint.y << ")";
+        return s.NamedEdge(name, nearPoint);
     }
     EdgeList edges = TargetEdges(s, t, call);
     if (edges.size() != 1)
@@ -1389,14 +1390,14 @@ template <class S>
 inline sketch::LineRefs LineRefsOf(S &wp, const std::string &call, std::optional<double> l, const py::object &until, const py::object &from,
                            const py::object &to, const py::object &parallel, const py::object &perpendicular, const py::object &angle,
                            const py::object &congruent, const py::object &tangent, const py::object &distance,
-                           const py::object &through, const py::object &near, bool reverse) {
+                           const py::object &through, const py::object &nearPoint, bool reverse) {
     sketch::LineRefs r;
     r.call = call;
     r.reverse = reverse;
     r.until = UntilArg(wp, until, r.untilTarget, r.call);
-    r.near = PointArg(wp, near, r.call);
+    r.nearPoint = PointArg(wp, nearPoint, r.call);
     r.through = PointArg(wp, through, r.call);
-    const Vertex at = r.near.value_or(wp.Position());
+    const Vertex at = r.nearPoint.value_or(wp.Position());
     r.length = l;
     if (!from.is_none())
         r.from = EndArg(wp, from, r.call);
@@ -1404,17 +1405,17 @@ inline sketch::LineRefs LineRefsOf(S &wp, const std::string &call, std::optional
         r.to = EndArg(wp, to, r.call);
     r.tangent = TangentArg(wp, tangent, r.call);
     if (!parallel.is_none())
-        r.parallel = ReferenceEdge(wp, parallel, at, r.near.has_value(), r.call);
+        r.parallel = ReferenceEdge(wp, parallel, at, r.nearPoint.has_value(), r.call);
     if (!perpendicular.is_none())
-        r.perpendicular = ReferenceEdge(wp, perpendicular, at, r.near.has_value(), r.call);
+        r.perpendicular = ReferenceEdge(wp, perpendicular, at, r.nearPoint.has_value(), r.call);
     if (!congruent.is_none())
-        r.congruent = ReferenceEdge(wp, congruent, at, r.near.has_value(), r.call);
+        r.congruent = ReferenceEdge(wp, congruent, at, r.nearPoint.has_value(), r.call);
     if (py::isinstance<py::tuple>(angle) || py::isinstance<py::list>(angle)) {
         py::sequence a = angle;
         if (a.size() != 2)
             throw py::value_error(r.call + ": angle is degrees or (degrees, reference)");
         r.angle = a[0].cast<double>();
-        r.angleRef = ReferenceEdge(wp, a[1], at, r.near.has_value(), r.call);
+        r.angleRef = ReferenceEdge(wp, a[1], at, r.nearPoint.has_value(), r.call);
     } else if (!angle.is_none()) {
         r.angle = angle.cast<double>();
     }
@@ -1451,19 +1452,19 @@ template <class S>
 inline sketch::ArcRefs ArcRefsOf(S &wp, const std::string &call, std::optional<double> r, std::optional<double> ang,
                          const py::object &center, const py::object &concentric, const py::object &congruent,
                          const py::object &tangent, const py::object &through, const py::object &until, const py::object &from,
-                         const py::object &to, const py::object &near, bool reverse) {
+                         const py::object &to, const py::object &nearPoint, bool reverse) {
     sketch::ArcRefs a;
     a.call = call;
     a.reverse = reverse;
     a.until = UntilArg(wp, until, a.untilTarget, a.call);
     a.radius = r;
     a.sweep = ang;
-    a.near = PointArg(wp, near, a.call);
+    a.nearPoint = PointArg(wp, nearPoint, a.call);
     a.through = PointArg(wp, through, a.call);
-    const Vertex at = a.near.value_or(wp.Position());
-    a.center = CenterArg(wp, center, concentric, at, a.near.has_value(), a.call);
+    const Vertex at = a.nearPoint.value_or(wp.Position());
+    a.center = CenterArg(wp, center, concentric, at, a.nearPoint.has_value(), a.call);
     if (!congruent.is_none())
-        a.congruent = ReferenceEdge(wp, congruent, at, a.near.has_value(), a.call);
+        a.congruent = ReferenceEdge(wp, congruent, at, a.nearPoint.has_value(), a.call);
     if (!tangent.is_none() && IsPoint(tangent)) {
         a.start = tangent.cast<Vertex>();
         if (!(Norm(*a.start) > 0.0))
@@ -1480,19 +1481,19 @@ inline sketch::ArcRefs ArcRefsOf(S &wp, const std::string &call, std::optional<d
 template <class S>
 inline sketch::CircleRefs CircleRefsOf(S &wp, std::optional<double> r, const py::object &center, const py::object &concentric,
                                const py::object &congruent, const py::object &through, const py::object &tangent,
-                               const py::object &near, bool reverse) {
+                               const py::object &nearPoint, bool reverse) {
     sketch::CircleRefs refs;
     refs.call = CallText("Circle", {{"r", r ? py::object(py::float_(*r)) : py::object(py::none())}, {"center", center},
                                  {"concentric", concentric}, {"coincident", congruent}, {"through", through},
-                                 {"tangent", tangent}, {"near", near},
+                                 {"tangent", tangent}, {"near", nearPoint},
                                  {"reverse", reverse ? py::object(py::bool_(true)) : py::object(py::none())}});
     refs.radius = r;
     refs.reverse = reverse;
-    refs.near = PointArg(wp, near, refs.call);
-    const Vertex at = refs.near.value_or(wp.Position());
-    refs.center = CenterArg(wp, center, concentric, at, refs.near.has_value(), refs.call);
+    refs.nearPoint = PointArg(wp, nearPoint, refs.call);
+    const Vertex at = refs.nearPoint.value_or(wp.Position());
+    refs.center = CenterArg(wp, center, concentric, at, refs.nearPoint.has_value(), refs.call);
     if (!congruent.is_none())
-        refs.congruent = ReferenceEdge(wp, congruent, at, refs.near.has_value(), refs.call);
+        refs.congruent = ReferenceEdge(wp, congruent, at, refs.nearPoint.has_value(), refs.call);
     refs.through = PointArg(wp, through, refs.call);
     refs.tangent = TangentArg(wp, tangent, refs.call);
     return refs;
@@ -1808,8 +1809,10 @@ inline const char *FitArcsDoc(const std::string &cls, const std::string &text, c
 
 inline const char *CloseGapsDoc(const std::string &cls, const std::string &x, const std::string &more) {
     return Doc("CloseGaps(tol: float) -> " + cls + "\n\n"
-               "Joins every endpoint without an exact match on another edge with all endpoints of other edges within tol, "
-               "in place.\n\n" + more +
+               "Joins every endpoint without an exact match on another edge with all endpoints of other edges within tol "
+               "at their midpoint, in place.\n\n"
+               "The ends meet halfway between where they were, whatever the order of the edges; ends that already "
+               "coincide count once.\n\n" + more +
                "Args:\n"
                "    tol: the largest gap closed, a length.\n\n"
                "Returns:\n"
@@ -2374,12 +2377,12 @@ inline Thing CarrierOver(const EdgeView &r, const BBox &box) {
         const Vertex center = box.Center();
         const double reach = Norm(box.Size()) + Norm(mid - center) + 1.0;
         carrier.Add(Line(mid - dir * reach, mid + dir * reach));
-    } else if (const Arc *a = std::get_if<Arc>(&r.Get())) {
+    } else if (const planex2d::Arc *a = std::get_if<planex2d::Arc>(&r.Get())) {
         const Vertex opposite = a->Center() * 2.0 - a->Start();
-        carrier.Add(Arc(a->Start(), opposite, a->Center(), true));
-        carrier.Add(Arc(opposite, a->Start(), a->Center(), true));
+        carrier.Add(planex2d::Arc(a->Start(), opposite, a->Center(), true));
+        carrier.Add(planex2d::Arc(opposite, a->Start(), a->Center(), true));
     } else if (const Circle *c = std::get_if<Circle>(&r.Get())) {
-        for (const Arc &half : c->Halves())
+        for (const planex2d::Arc &half : c->Halves())
             carrier.Add(half);
     } else {
         throw py::value_error("on_carrier: a spline has no carrier");
@@ -2651,7 +2654,7 @@ inline std::optional<OnCircle> CircleOfEdges(const Wire &w) {
         const std::optional<CircleCarrier> k = CarrierOf(e);
         if (!k)
             return std::nullopt;
-        const Arc *a = std::get_if<Arc>(&e);
+        const planex2d::Arc *a = std::get_if<planex2d::Arc>(&e);
         const double tol = Tol(LengthScaleOf(e));
         if (!c)
             c = OnCircle{k->center, k->radius, 0.0};
@@ -2663,7 +2666,7 @@ inline std::optional<OnCircle> CircleOfEdges(const Wire &w) {
 }
 
 inline const char *KindOf(const Edge &e) {
-    return std::holds_alternative<Line>(e) ? "line" : std::holds_alternative<Arc>(e) ? "arc" : std::holds_alternative<Circle>(e) ? "circle" : "spline";
+    return std::holds_alternative<Line>(e) ? "line" : std::holds_alternative<planex2d::Arc>(e) ? "arc" : std::holds_alternative<Circle>(e) ? "circle" : "spline";
 }
 
 // the properties of one measured thing
@@ -3088,13 +3091,14 @@ inline const char *SplitDoc(const std::string &x) {
 
 
 template <class S>
-inline sketch::SymRef SymRefOf(S &s, const py::handle &t, const Vertex &near, bool nearGiven, const std::string &call) {
+inline sketch::SymRef SymRefOf(S &s, const py::handle &t, const Vertex &nearPoint, bool nearGiven,
+                               const std::string &call) {
     if (py::isinstance<py::str>(t))
         if (std::optional<Vertex> p = s.FindPoint(t.cast<std::string>()))
             return *p;
     if (std::optional<std::vector<double>> p = AsPoint(t); p && p->size() == 2)
         return Vertex{(*p)[0], (*p)[1]};
-    Edge e = ReferenceEdge(s, t, near, nearGiven, call);
+    Edge e = ReferenceEdge(s, t, nearPoint, nearGiven, call);
     if (const Line *l = std::get_if<Line>(&e))
         return *l;
     if (const std::optional<CircleCarrier> c = CarrierOf(e))