Patch fills non-planar edge loops with one smooth face (#250) (#472)

* Add a one-surface fill of closed 3D loops to geom

A closed loop of curves that does not lie in a plane has no exact surface;
the usual answer is one smooth face fitted over it. fill_loop does that:

- the loop's best-fit plane (Newell normal), with a frame chosen from the
  loop itself so the result does not depend on where the loop starts, its
  direction, or where the part sits
- the loop seen along that normal must be simple and must not fold or run
  along the normal; otherwise it is refused ("not supported yet"), never
  filled with wrong geometry
- one non-rational bicubic B-spline height field over the loop's box,
  fitted by least squares to the loop's samples (The NURBS Book 9.4.1,
  9.4.3, eq. 9.62/9.65) with a thin-plate smoothness term
  lambda*A*int(h_uu^2 + 2 h_uv^2 + h_vv^2), A one grid cell's area, so the
  fit is the same at any scale; only planes are reproduced exactly
- span counts per direction (long narrow loops fit), refined until the
  loop is within tolerance, else refused with the deviation reached

bspline: bisected span search, basis functions on a stack array, one
clamping helper shared by curves and surfaces, one binomial helper.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J53sR6gEaVt56soFDpTck8

* Patch fills non-planar loops of edges with one smooth face (#250)

surface.patch with edges refused any loop that is not planar ("not
supported yet: patching a loop that is not planar"). It now fills it:

- planar loops still get one exact planar face, but planarity is certified
  conservatively: lines by their ends, B-spline/NURBS edges by their control
  points, intersection curves by their samples lying on a support plane
  within tolerance; a loop that can't be certified is filled instead
- other loops get one face from geom's fill_loop, bounded by the body's own
  chained edges, whole (no split): its history is one generated face whose
  edges are the body's, and it stitches back into a closed solid
- intersection-curve edges are sampled by a seeded, guarded double
  projection shared by the planarity test and the fill (plane_fit)
- the face tolerance is 10x the planarity tolerance (documented: later
  operations take the face to contain its edges within it)
- edge picking runs inside the guard; the geom->truck conversion is shared
  with the T-spline sheets (spline_conv); the Newell plane fit is shared with
  STEP import

Tests: 3- to 8-sided, concave (dart, arrow, plus), flat-corner, two-edge and
imported rims fill as one face and stitch closed (volumes against an
independent integral); finite mesh normals, same result for any pick order
or placement; non-height-field loops and too-fine detail are refused.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J53sR6gEaVt56soFDpTck8

* Test the Patch dialog filling a non-planar loop of picked edges

The Patch dialog's only test used a sketch profile. Picking the four
curved rim edges of a box cut by a sideways cylinder now makes one
surface.patch command whose result is a single smooth face over the rim.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J53sR6gEaVt56soFDpTck8

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

crates/kernel/src/tspline.rs

@@ -11,6 +11,7 @@ use solidcraft_geom::tspline::TSpline;
 use truck_modeling as mt;
 
 use crate::body::Body;
+use crate::spline_conv::{h4, nurbs_curve, nurbs_surface};
 use crate::{KernelError, Result, guard};
 
 /// A T-spline as a surface body (an open shell of NURBS faces whose normals follow
@@ -34,25 +35,11 @@ fn fail(m: impl std::fmt::Display) -> KernelError {
     KernelError::Failed(format!("t-spline sheet: {m}"))
 }
 
-fn h4(h: HPoint) -> mt::Vector4 {
-    mt::Vector4::new(h.x, h.y, h.z, h.w)
-}
-
 fn vertex(h: HPoint) -> Result<mt::Vertex> {
     let p = h.project().ok_or_else(|| fail("a corner has no position"))?;
     Ok(mt::builder::vertex(crate::body::p3(p)))
 }
 
-fn nurbs_curve(knots: mt::KnotVec, ctrl: &[HPoint]) -> Result<mt::Curve> {
-    let c = mt::BSplineCurve::try_new(knots, ctrl.iter().copied().map(h4).collect()).map_err(fail)?;
-    Ok(mt::Curve::NurbsCurve(mt::NurbsCurve::new(c)))
-}
-
-fn surface(knots: (mt::KnotVec, mt::KnotVec), rows: Vec<Vec<mt::Vector4>>) -> Result<mt::Surface> {
-    let s = mt::BSplineSurface::try_new(knots, rows).map_err(fail)?;
-    Ok(mt::Surface::NurbsSurface(mt::NurbsSurface::new(s)))
-}
-
 /// One face from a clamped tensor surface, bounded by its four boundary curves.
 fn tensor_face(n: &NurbsSurface) -> Result<mt::Face> {
     let [nu, nv] = n.count();
@@ -69,8 +56,7 @@ fn tensor_face(n: &NurbsSurface) -> Result<mt::Face> {
     let top = edge(v3, v2, nurbs_curve(ku.clone(), &row(nv - 1))?)?;
     let left = edge(v0, v3, nurbs_curve(kv.clone(), &column(0))?)?;
     let wire: mt::Wire = vec![bottom, right, top.inverse(), left.inverse()].into();
-    let rows: Vec<Vec<mt::Vector4>> = (0..nu).map(|i| (0..nv).map(|j| h4(n.point(i, j))).collect()).collect();
-    mt::Face::try_new(vec![wire], surface((ku, kv), rows)?).map_err(fail)
+    mt::Face::try_new(vec![wire], crate::spline_conv::surface(n)?).map_err(fail)
 }
 
 /// A parameter point, exact (knot values are shared, so equal points have equal bits).
@@ -148,7 +134,7 @@ fn patch_faces(patches: &[BezierPatch]) -> Result<Vec<mt::Face>> {
         }
         let [ps, pt] = p.degree;
         let rows: Vec<Vec<mt::Vector4>> = (0..=ps).map(|i| (0..=pt).map(|j| h4(p.point(i, j))).collect()).collect();
-        let surf = surface((mt::KnotVec::bezier_knot(ps), mt::KnotVec::bezier_knot(pt)), rows)?;
+        let surf = nurbs_surface((mt::KnotVec::bezier_knot(ps), mt::KnotVec::bezier_knot(pt)), rows)?;
         faces.push(mt::Face::try_new(vec![wire.into()], surf).map_err(fail)?);
     }
     Ok(faces)