Grasshopper re-write: caps, placement, booleans...

.gitattributes

@@ -12,4 +12,8 @@
 # Denote files that are truly binary and should not be modified.
 *.png binary
 *.jpg binary
-*.bmp binary
+*.bmp binary
+
+# Grasshopper documents: .gh is binary (no diff/merge); .ghx is XML text (diffable).
+*.gh binary
+*.ghx text

CLAUDE.md

@@ -0,0 +1,108 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+Bertini_real is a numerical algorithm for decomposing real algebraic curves (dim 1) and
+surfaces (dim 2) into cell complexes, using **Bertini 1** as the homotopy-continuation engine.
+The C++ side produces the decomposition; the Python package (`python/`) parses the on-disk
+output and renders/plots it. MATLAB code in `matlab_codes/` is legacy post-processing.
+
+Two C++ executables are built: `bertini_real` (computes the decomposition) and `sampler`
+(refines/adaptively samples an existing decomposition for smoother output).
+
+## Building (C++)
+
+As of July 2025 the build is **CMake** (previously autotools), and it requires **Bertini 1
+version >= 1.7** (which itself moved to CMake — install location and headers changed).
+
+```sh
+mkdir build && cd build
+cmake ../
+make            # use -j for parallelism
+make install    # may need sudo; installs bertini_real + sampler to bin/
+```
+
+Dependencies (all must be findable by CMake): MPFR, GMP, `bertini-parallel` (>=1.7, found via
+`find_package(bertini1 1.7 CONFIG)`), Boost (>=1.53, components `filesystem` + `timer`), MPI
+(openmpi/mpich), plus tools CMake, Flex, Bison. **Bertini 1 must be compiled from source
+against the same GMP/MPFR/MPI libraries.** Custom CMake find-modules live in `cmake/`.
+`brconfig.h.in` is configured into `build/config.h`. Source-file lists are in `files.cmake`
+(not globbed) — **add new `.cpp`/`.hpp` files there**, not just to disk.
+
+Clone recursively (`git clone --recursive`) to get the `matlab_codes/brakelab` submodule.
+
+## Python package
+
+```sh
+cd python && pip install -e .          # installs the `bertini_real` package
+```
+Deps: matplotlib, trimesh, dill, algopy, sympy, scipy, networkx. `glumpy` (OpenGL rendering)
+is optional and imported defensively in `__init__.py`.
+
+Typical interactive use, run **from inside a decomposition output folder**:
+```python
+import bertini_real
+bertini_real.gather_and_plot()   # data.gather() -> plot.plot()
+```
+`data.gather()` reads the raw on-disk output into a `Curve` or `Surface` object (chosen by the
+dimension in the directory name); `data.gather_and_save()` also dills it to a `BRdataN.pkl`.
+
+## Running / tests
+
+There is **no automated test suite or test runner**. `test/curve/*` and `test/surface/*` are
+example systems, each a directory containing a Bertini `input` file (and sometimes Python
+plot/assemble scripts). The manual workflow for any example:
+
+1. Run Bertini 1 on the `input` file with `tracktype: 1` to produce a numerical irreducible
+   decomposition and a `witness_data` file.
+2. Run `bertini_real` in that directory; it consumes `input` + `witness_data`. If there are
+   multiple components it prompts for which to decompose. Optional flags:
+   `-sphere <file> -pi <projectionfile>`.
+3. Optionally run `sampler` to refine the decomposition.
+4. Use the Python package to plot the result.
+
+Output is plain-text files in a subfolder of cwd, written incrementally after each major stage
+(so a crash still leaves the last good parsable state). Key files: `decomp`, `vertex_set`,
+copies of `input` + `witness_data`; curves add `E.edge`; surfaces add `S.surf` plus curve
+sub-decompositions in their own subfolders. The README and `manual/bertini_real_manual.pdf`
+document these formats in full.
+
+## C++ architecture
+
+`src/` and `include/` mirror each other and are organized by subsystem (file lists in
+`files.cmake`). `src/bertini_real.cpp` and `src/sampler/` hold the two executable `main`s;
+everything else compiles into both (`common_src`).
+
+- **`bertini1/`** — `bertini_extensions`: the C++ bridge to Bertini 1's C structures/headers
+  (`bertini_headers.hpp`).
+- **`nag/`** — numerical algebraic geometry core. `nid` (numerical irreducible decomposition),
+  `witness_set`, `system_randomizer`, and `nag/solvers/` (the homotopy solvers: `midpoint`,
+  `multilintolin`, `nullspace`, `sphere_intersection`, `postProcessing`, common `solver`).
+- **`decompositions/`** — the top-level algorithms: `curve`, `surface`, base `decomposition`,
+  and `checkSelfConjugate` (real-vs-complex detection).
+- **`cells/`** + **`containers/`** — the cell-complex data model: `vertex`/`edge`/`face`/`cell`,
+  held in `vertex_set` and `holders`.
+- **`symbolics/`** — symbolic preprocessing: `derivative_systems`, `isosingular` (deflation),
+  `nullspace`, `slicing`, `sphere_intersection`.
+- **`io/`** — `fileops`, terminal `color`, and the **Flex** parser `partitionParse.l` (compiled
+  to `partitionParse.yy.c` at build time; CMake `flex_target` with prefix `partitionParse`).
+- top-level: `programConfiguration` (CLI flags / config), `parallelism` (MPI master/worker),
+  `double_odometer`, `limbo`.
+
+The program is **MPI-parallel** (head/worker model in `parallelism`). C++14.
+
+## Python architecture
+
+`python/bertini_real/` mirrors the C++ cell model in Python objects. `data/` does the parsing
+(`gather*`), `curve`/`surface`/`edge`/`face`/`vertex`/`cell`/`decomposition` are the parsed
+types, `parse/` reads the directory naming convention, `plot/`/`glumpyplotter`/`anaglypy` do
+rendering, `dehomogenize/` handles projective coords, `paths/` and `util/` are helpers.
+
+## Notes
+
+- `documentation/` holds the Doxygen config (`bertini_real.doxy.config`) for the C++ docs at
+  doc.bertinireal.com/cpp; `python/docs/` is the Sphinx source for doc.bertinireal.com/python.
+- GitHub Actions only mirrors pushes to an MPI GitLab (`.github/workflows/github-gitlab-sync.yml`);
+  there is no CI build/test.

grasshopper/bertini_real/Capping.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using Rhino;
+using Rhino.Geometry;
+
+namespace bertini_real
+{
+    /// <summary>
+    /// Shared helpers for the cap components (Sphere Caps, Flat Caps): finding the piece mesh's
+    /// own naked boundary loops that lie on the sphere, and adding non-degenerate triangles.
+    /// </summary>
+    internal static class Capping
+    {
+        // a tiny absolute distance below which two cap vertices are treated as the same point
+        public const double CoincidentTol = 1e-9;
+
+        /// <summary>
+        /// Closed loops (ordered lists of TopologyVertex indices) of the mesh's naked boundary that
+        /// lie on the sphere.  Sets <paramref name="unclean"/> if some on-sphere boundary did not
+        /// form clean degree-2 cycles.  Works in topology space (coincident vertices merged); zero-
+        /// length edges collapse and are ignored.
+        /// </summary>
+        public static List<List<int>> OnSphereBoundaryLoops(Mesh mesh, Point3d center, double radius, double tol, out bool unclean)
+        {
+            unclean = false;
+            var result = new List<List<int>>();
+
+            var topo = mesh.TopologyVertices;
+            var edges = mesh.TopologyEdges;
+
+            bool OnSphere(int tv)
+            {
+                Point3d p = topo[tv];
+                return Math.Abs(p.DistanceTo(center) - radius) < tol;
+            }
+
+            var adj = new Dictionary<int, List<int>>();
+            void Link(int u, int v)
+            {
+                if (!adj.TryGetValue(u, out var lu)) { lu = new List<int>(); adj[u] = lu; }
+                if (!lu.Contains(v)) lu.Add(v);
+            }
+
+            for (int e = 0; e < edges.Count; e++)
+            {
+                if (edges.GetConnectedFaces(e).Length != 1) continue; // not naked
+                IndexPair ip = edges.GetTopologyVertices(e);
+                int i = ip.I, j = ip.J;
+                if (i == j) continue;                 // degenerate (collapsed) edge
+                if (!OnSphere(i) || !OnSphere(j)) continue;
+                Link(i, j);
+                Link(j, i);
+            }
+
+            if (adj.Count == 0) return result;
+
+            var visited = new HashSet<int>();
+            foreach (int start in adj.Keys)
+            {
+                if (visited.Contains(start)) continue;
+
+                var loop = new List<int>();
+                int prev = -1, cur = start;
+                bool clean = true;
+
+                while (true)
+                {
+                    visited.Add(cur);
+                    loop.Add(cur);
+
+                    var nbrs = adj[cur];
+                    if (nbrs.Count != 2) { clean = false; break; } // junction or dead-end
+
+                    int next = nbrs[0] != prev ? nbrs[0] : nbrs[1];
+                    if (next == start) break;          // closed the loop
+                    if (visited.Contains(next)) { clean = false; break; }
+                    prev = cur;
+                    cur = next;
+                }
+
+                if (clean && loop.Count >= 3)
+                    result.Add(loop);
+                else
+                    unclean = true;
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Add a triangle, skipping only TRULY degenerate ones (a collapsed edge -- two coincident
+        /// vertices); thin-but-valid triangles must be kept, or high-resolution caps develop holes.
+        /// </summary>
+        public static void AddTri(Mesh m, int i, int j, int k)
+        {
+            Point3d a = m.Vertices[i];
+            Point3d b = m.Vertices[j];
+            Point3d c = m.Vertices[k];
+            if (a.DistanceTo(b) < CoincidentTol ||
+                b.DistanceTo(c) < CoincidentTol ||
+                a.DistanceTo(c) < CoincidentTol)
+                return;
+            m.Faces.AddFace(i, j, k);
+        }
+    }
+}

grasshopper/bertini_real/CurveReadGhJson.cs

@@ -0,0 +1,99 @@
+using System;
+using Grasshopper;
+using Grasshopper.Kernel;
+using Grasshopper.Kernel.Data;
+using Rhino.Geometry;
+
+namespace bertini_real
+{
+    /// <summary>
+    /// Reads a self-contained standalone-curve export (br_gh_export.json) written by Python's
+    /// Curve.export_gh_json.  Brings the vertices in as ONE unified set and exposes each curve
+    /// piece as a polyline referring to those vertices by index.
+    /// </summary>
+    public class CurveReadGhJson : GH_Component
+    {
+        public CurveReadGhJson()
+          : base("Curve Read GH JSON", "CurveReadJSON",
+                 "Read a bertini_real curve export: one unified vertex set, curve pieces as polylines",
+                 "bertini_real", "Curve")
+        {
+        }
+
+        protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
+        {
+            pManager.AddTextParameter("File Path", "F", "Path to br_gh_export.json (a curve export)", GH_ParamAccess.item);
+            pManager.AddNumberParameter("Scale", "Sc", "Uniform scale applied on import (about the world origin), so the curve comes in bigger without a Scale component", GH_ParamAccess.item, 1.0);
+            Params.Input[1].Optional = true;
+        }
+
+        protected override void RegisterOutputParams(GH_Component.GH_OutputParamManager pManager)
+        {
+            pManager.AddPointParameter("Vertices", "V", "The single unified vertex set; list index = global vertex id", GH_ParamAccess.list);
+            pManager.AddCurveParameter("Curves", "C", "One polyline per curve piece", GH_ParamAccess.tree);
+            pManager.AddTextParameter("Curve Types", "T", "Type tag per curve piece, parallel to Curves", GH_ParamAccess.tree);
+            pManager.AddIntegerParameter("Curve Indices", "CI", "Per curve piece: vertex indices into Vertices", GH_ParamAccess.tree);
+        }
+
+        protected override void SolveInstance(IGH_DataAccess DA)
+        {
+            string path = "";
+            if (!DA.GetData(0, ref path)) return;
+
+            double scale = 1.0;
+            DA.GetData(1, ref scale);
+
+            GhExport content;
+            try
+            {
+                content = GhJsonIO.Load(path);
+            }
+            catch (Exception e)
+            {
+                AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Failed to read/parse JSON: " + e.Message);
+                return;
+            }
+
+            if (content == null || content.decomposition_type != "curve")
+            {
+                AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Not a curve export (decomposition_type != 'curve').");
+                return;
+            }
+
+            var verts = GhJsonIO.ToVertices(content);
+            if (scale != 1.0)
+                for (int i = 0; i < verts.Count; i++)
+                    verts[i] = verts[i] * scale;
+
+            var curves = new DataTree<Curve>();
+            var types = new DataTree<string>();
+            var curveIdx = new DataTree<int>();
+
+            if (content.curve_pieces != null)
+            {
+                foreach (var cp in content.curve_pieces)
+                {
+                    var branch = new GH_Path(cp.piece_index);
+
+                    PolylineCurve pl = GhJsonIO.ToPolyline(cp.vertex_indices, verts);
+                    if (pl != null) curves.Add(pl, branch);
+
+                    types.Add(cp.type, branch);
+                    if (cp.vertex_indices != null) curveIdx.AddRange(cp.vertex_indices, branch);
+                }
+            }
+
+            DA.SetDataList(0, verts);
+            DA.SetDataTree(1, curves);
+            DA.SetDataTree(2, types);
+            DA.SetDataTree(3, curveIdx);
+        }
+
+        protected override System.Drawing.Bitmap Icon => IconLoader.GetIcon("telephone.png");
+
+        public override Guid ComponentGuid
+        {
+            get { return new Guid("7C2A9F10-3B8E-4D55-A1C7-6E0B4F92D38B"); }
+        }
+    }
+}