Commit Graph
22 Commits
Author SHA1 Message Date
jyvikoandClaude Opus 5.5 87e9123d3a Kernel tests: a crowned patch's hostile crowns are refused for their range
a_crowned_patch_fills_its_middle_and_keeps_its_edges checked only that NaN,
infinity, 3.01, -0.91 and 1e300 are refused; it now checks why: "a patch's
crown must be between -0.9 and 3" (patch_edges_crowned's range test).

The bump check is left as it is. The audit proposed measuring it in model
space along the loop plane's normal, but it already is: both patches are
height fields over the same plane on the same parameters, so the distance
between their points at the domain's centre is the bump along the normal,
and the record's domain is the fit's box in mm (diagonal 52.5). The crowned
patch's middle rises 7.656 where the documented crown x size is 13.125:
the crown's bump reaches 7/12 of what patch_edges_crowned promises on this
pentagonal cup (geom's own test of fill_loop, on a fine hexagon net, gets
it to 1e-9), a real gap, still failing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 07:12:24 -04:00
jyvikoandClaude Opus 5.5 c5b0385481 Fill: its tolerances follow a size that does not depend on where the body is
face_tolerance (and planarity_tolerance) was 10⁻⁶ of the body's bounding-box
diagonal, which changes as a body turns: the cup turned 0.7 rad about
(1, 2, 3) grew from 54.7 to 61.6, its fill sampled to another tolerance, a
different surface (area 974.543 against 974.527). The size is now the
diameter of the smallest ball holding the vertices (solidcraft_geom::Ball,
Welzl's algorithm, expected O(n)), the same wherever the body is and however
it is turned. Twice the farthest vertex's distance from the vertices'
centroid is that too, but up to twice the body's diameter where the
vertices crowd one end: a rounded box's set-back-13 G2 corner patch then
ran 2.0e-3 past the box (corner_g2
a_long_setback_keeps_the_g2_patch_inside_the_box, limit 1e-3).

The own-edge check of the fill tests compares an edge's NURBS form to
rounding (10⁻¹² of each coordinate): SMLib makes a conic's form again on a
round trip, the last bit of a coordinate apart.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 12:05:17 -04:00
jyvikoandClaude Opus 5.5 4faee7dd80 Fill: the general fill takes a loop of one or two edges in exact pieces of their curves
The iso fill needs three sides or more, so a loop of one closed edge (a tube's
end) or two was refused as "a loop of 1 edges". Such a loop's edges are now
taken in equal pieces of their own parameters (one edge in four, two in two;
a break that falls on one of the curve's knots, a conic's quarter points, is
that knot exactly), each piece the edge's own curve segmented exactly; the
patch's edges are those pieces, their ends new vertices shared by the pieces
either side. A piece of an edge the loop runs against has its parameter
reflected about the edge's interval, as a whole edge's is.

The tube end is still refused: one four-sided patch on four quarters of a
circle has corners where its sides run on straight (180°), and the G1 dome
folds there.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 12:05:17 -04:00
jyvikoandClaude Opus 5.5 1e7713d1ec Fill: a patch's edges and vertices hold its fit's gap in SMLib's tolerance model
A record's tolerance is SMLib's intersection tolerance: SMLib holds an edge's
gap to its faces to half of it (the zone tolerance) and a vertex's gaps to a
quarter (SM_XSECT_TO_ZONETOL3D, SmBrep::ValidateAndUpdateTolerances). The fill
gave its edges and vertices the face tolerance itself, the gap its surface is
certified to, so SMLib's check refused every fitted patch (an edge/surface gap
of 2.6e-5 against 1.85e-5 where the fit holds 3.7e-5), alone or stitched to
its body. Its edges now take twice the gap and its vertices four times.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 12:05:17 -04:00
jyvikoandClaude Opus 5.5 b68f71a2de Fill: a patch's edges are the body's own edges again, circles and ellipses included
A record edge on a circle or ellipse carries the NURBS form SMLib holds it as,
its interval on that form. The patch built its loop edges from the form alone
(sew::PartEdge had no place for it), so a fill's rim came back from SMLib as a
plain B-spline rather than the body's ellipse. PartEdge now carries the form;
assemble keeps a given form and labels the edge with what it is.

Test helpers that sampled an edge on `curve` with the form's interval picked
points off the edge ("no edge at …"); they sample `parameters()`. The fill's
own-edge check compares the curve's kind and the exact form it is parameterised
on: SMLib renormalises a conic's frame axes in the last bit on a round trip.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 12:05:17 -04:00
jyvikoandClaude Opus 5.5 ed830a168d geom: the patch fill takes the dense spline edges a blend leaves, and holds what its corners allow
- One patch has a space along u and one along v, each holding its two sides that run that way;
  a side's knot keeps its continuity when raised (multiplicity m + q - p), and each side is
  carried in exactly by interpolation at the space's Greville abscissae.
- Refinement halves the spans only in the direction whose sides miss, and one patch's normal
  equations are banded (the shorter direction numbered fastest), so a loop with a long
  intersection curve refines where it needs to.
- At a corner whose neighbours agree to a lower order than asked (their tangent planes, their
  twist between the two edges, or their forms), the stations near it ask no more than that.
- A station is held to the angle tolerance beyond the edge's own lean out of its neighbour's
  tangent plane: a fill that holds the edge cannot come nearer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 00:30:03 -04:00
jyvikoandClaude Opus 5.5 99297495b3 geom, kernel: the patch fill meets its neighbours with G0 to G4, on rational edges too
One order-n implementation in the linkage-curve formulation (Pegna & Wolter 1992;
Hermann, Lukacs & Wolter 1999): geom::linkage reads the neighbour as a height over its
tangent plane to order n (its jet, from the surface's exact partials of any order) and
gives each order's condition on the linkage curve, with exact gradients (dual numbers),
so fill_iso solves orders 2..n by Newton's method. Each order's row is weighed by h^(k-1)
and its jump is held, carried into the fill by Taylor's theorem, within the angle tolerance.

The iso fill takes rational edges (a circle's arc on its NURBS form): homogeneous rows,
each edge scaled so the corner weights agree, the inside weights the Coons blend and
fixed, so the fill stays a linear least-squares problem. Its degree is at least n + 1,
refinement adds simple knots, breaks of different sides within rounding are one, and the
weak Hermite rows act in the tangent plane at the Coons start's own speed, so they no
longer pull against the G1 rows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LUXeKMoxpM7Vuv8Rb6E3K2
2026-10-29 00:30:03 -04:00
jyvikoandClaude Opus 5.5 704640375d kernel: fillet_g2_corners, set-back corners filled G2 to every face round them
A corner where three or more rounded edges meet, every edge there rounded, is
set back (1.5 r unless a setback names it) and left open by SMLib
(blend_smlib::fillet_setback_open: the sheet and each corner's hole, in the
sheet's orders); each hole is filled by fill::matched_patch, the height field
over its plane fitted to the position, tangent plane and normal curvature
across the boundary of every face beside it (exact second derivatives), rounds
and planes alike, each edge's pcurve its exact projection; SMLib sews the
sheet and the patches into one solid, which must close. The history is the
sewing's carried through the sheet's, each patch face made from the rounded
edges its neighbours come from.

corner_g2 is that construction now. The polar patch over three sections it
held (never sewn in) could not be: its boundary is a closed cubic through
stations, which rounds off a corner of the loop, and the setback hole has six.

The 60 x 40 x 20 box corner of r5 rounds (07/015): 10 faces, a valid closed
solid (record and SMLib's check), curvature jump across the patch's seams
6.3e-4 per mm clear of the hole's corners against the ball's 0.2; set back 8
between the hull and prism bounds; set back 11 to 15 inside the box but by
under 7e-4; all eight corners of a box filled; refusals named.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 12:24:10 -04:00
jyvikoandClaude Opus 5.5 562a5bd337 Formatting: rustfmt over the rebased branch
cargo fmt --all, nothing else: code from the branch's commits and from the rebase's
resolutions that was not yet in rustfmt's layout.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HoZgkCdAVrscuw2kjQTWDs
2026-10-27 02:28:53 -04:00
jyvikoandClaude Opus 5.5 6892ceac78 brep, kernel: code that reads an edge's angles takes them from the circle, code that evaluates takes the NURBS form
Edge::curve_interval (and brep::curve_interval for assemble's edges) gives the interval on the
edge's curve itself: a form circle's angles of its ends, its frame turned by the SMLib conversion
so the angle grows along the NURBS. lip and the ruled surfaces read arcs by it; the hull, the
blend tangents, the patch pcurves, point paths, IGES output and the prism runs evaluate on
Edge::parameters. assemble carries an edge's form through.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:51 -04:00
jyvikoandClaude Opus 5.5 b1326e48d6 brep: an edge on a line, circle or ellipse carries the NURBS form SMLib holds it as
The edge mirror of a face's NURBS form: Edge::nurbs keeps the NURBS SMLib holds a conic as, and
the edge's interval and its pcurves' parameter are its. Edge::parameters is the curve every
evaluation at a parameter uses; curve says what the edge is. Nothing writes the form yet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:51 -04:00
jyvikoandClaude Opus 5.5 b6a3b31ff9 brep: a face on a cylinder, cone, sphere or torus carries the NURBS form SMLib holds it as
Every SMLib analytic surface is a B-spline surface, and its trims are in that NURBS's
parameters. Face::nurbs keeps that NURBS: the face's domain and pcurves are its (u, v), and
`surface` says what the face is. Face::parameters is the surface every (u, v) evaluation uses.
The SMLib conversion reads and writes it (fork FACE_NURBS_FORM, SMLIB_REV c4483f6); the STEP
writer writes the analytic surface and the face's edges without pcurves.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
2026-10-27 02:28:50 -04:00
jyvikoandClaude Opus 5.5 f6afec8eab kernel: dead code left by the port deleted; clippy -D warnings clean on all targets
No caller is left for: Assembly::sheet and assemble::outward_normal, Body::shell_nesting,
regularize_generated_planar_faces, with_shell_planar_sources, boolean_record's Traced and
of_pair, offset's normal, plane_fit's plane_through, EdgeSampler, planar_face and
plane_frame (fill has its own on the record), polyhedron's solve3, prism's wall_along,
record::regions/region, splitface's side_of_point, Analytic, analytic_face, face_sides and
canonical, surfaces::picked_loop, sweep_path's closed_path, turn and stations,
shell_groups' groups and parents with their limits, and the whole of spline_conv. Their
tests go with them: prism's curved_prism_wall_requires_positive_separable_rational_weights,
body_lump's shell_grouping_preserves_large_disconnected_patterns_and_bounds_hostile_work,
and regularization protection's check of the generated regularizer. Three names follow
clippy's conventions: into_face -> direction_into_face, from_to -> ends_along, and Params::
to_eval takes its Copy self by value; fill's clash loop walks its slots.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
2026-10-27 02:28:50 -04:00
jyvikoandClaude Opus 5.5 98548fe164 kernel: one canonicaliser; one tensor sheet
sew::assemble and surfaces::Parts::canonical each lay out their record as its parts stand
(regions, shells, faces, edges with no uses, vertices) and end in Brep::canonical; their own
ordering walks are deleted. spline_conv::tensor_face (no callers left) is deleted in favour
of surfaces::tensor_sheet, and fill's copy of the spline surface record in favour of
surfaces::spline_surface.

(not type-checked: the kernel stops at name resolution in step_*, build, sweep_path and
surface_ruled)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
2026-10-27 02:28:49 -04:00
jyvikoandClaude Opus 5.5 7c0d9b5e82 kernel: the general fill on loops of five or more edges, its patches about a centre
general_fill takes loops of three to sixteen edges. quilt_body assembles fill_iso's
patches into one sheet: each loop edge whole, or for five or more its two halves at the
middle of its interval, both on the edge's exact curve record and sharing a midpoint
vertex; each spoke a new edge from that vertex to the centre; every pcurve the straight
line in (u, v) of its side. The history marks every face generated, each edge or half a
piece of the body's own edge, each spoke new. A reversed loop edge's knots keep the
interval's ends exactly, so pieces name the edge's own vertices.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
2026-10-27 02:28:49 -04:00
jyvikoandClaude Opus 5.5 3ef93b3630 kernel: the general fill is the iso-parametric patch on three or four edges
The general fill (G1/G2 patches, patches through points, loops that bound no height
field) is solidcraft_geom::fill_iso's patch on the loop's own edges: each line or spline
edge, on its interval and run the loop's way, is a side, so its pcurve is a straight line
in (u, v), exact. The frames across a G1/G2 edge are read off the one face beside it in
the record: its outward normal, the way it leaves the edge, and for G2 its normal
curvature from the surface's exact second derivatives. Corners whose neighbours' tangent
planes disagree are exempt from the angle tolerance. Loops of five or more edges, and
conic, rational or traced edges, are refused by name.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
2026-10-27 02:28:48 -04:00
jyvikoandClaude Opus 5.5 291af4bdbd kernel: the plain and crowned patch on a loop of the body's record edges, built by SMLib
patch_loop picks the closed loop among the record's edges, certifies a plane (lines by
their ends, splines by their control points, conics by centre and tilt, traced curves by
a planar support) or fits the height field, and assembles one face on the body's own edge
records; the height field's parameters are plane coordinates, so each line or spline
edge's pcurve is its exact projection (segmented to the edge's interval). The history
marks the face generated and each edge the body's own. A fit on circular, elliptic or
traced edges, whose pcurves on the spline have no exact form, is refused by name, as is
the general fill (G1/G2, points, loops bounding no height field) until it is ported.
Tests ported to the record; the general-fill ones stay and fail until then.

(not built: base in progress)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
2026-10-27 02:28:48 -04:00
jyvikoandClaude Opus 5.5 42997a62ed WIP kernel: Body::mesh(&MeshTolerance) as the one mesher (does not build yet)
Body::mesh / mesh_plan / mesh_of and MeshTolerance (chord, display, display_of, export_of)
replace tessellate, tessellate_with, display_mesh*, display_plan*, reference_display_mesh_angular;
every caller in kernel, doc, engine, io, ui-egui, gpu and the CLI renamed mechanically; the
truck-mesher fallback, mesh_shells*, refined* removed; Body::new orients from the planner;
truck-meshalgo dropped from Cargo.toml with the tests of its hooks. Still to fix: trait imports
in tess/*, splitface/lumps/preview/step_in/boolean_record meshalgo uses, measure.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt
2026-10-27 02:28:47 -04:00
fe3b14e798 refactor: Aabb2 and point-built Aabb3 for every hand-rolled box (#2428)
* Iterate instead of indexing in nine loops

Replace index loops that look up neighbours by position with enumerate,
zip(cycle().skip(1)) for wrap-around pairs and zip(skip(1)) for
consecutive pairs. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* geom: ring_edges for the edges of a closed ring

Every walk over a polygon's edges, the last back to the first, spelled
x.iter().zip(x.iter().cycle().skip(1)); eighteen of them now call
geom::ring_edges. Three redundant take(len) calls go with them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* geom: Ring, a closed ring that knows it is closed

A Ring holds items in order around a closed polygon, loop or fan; edges()
walks each with the next and the last with the first, corners() each
with both neighbours. Ring<Vec2> has signed_area and even-odd contains.

Loop2::polyline returns a Ring, as do doc's face_loops and
boundary_loops, kernel's coplanar wire samples, CapLoop's segments,
tess pieces' rings, the gizmo's plane quads and the navigation cube's
facets. Their walks take edges() or corners() instead of wrapping an
index; sketch's text-hole test and doc's poly_area become contains and
signed_area. Loop2::joints pairs each segment with the next.

Replaces the ring_edges free function.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* geom: Chain, Ring and Path; bounds for a chain of points

Ring becomes Chain<T, Closed> beside Path = Chain<T, Open>: edges()
closes a ring and stops at a path's end, Path::close makes the ring,
and bounds() (the empty box for no points) serves both. Eight
hand-rolled min/max folds over a loop's polyline call bounds(); doc's
flat_polyline returns a Ring.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* geom: area and inside on Ring for any planar point

Ring's signed_area and contains take any Planar point (Vec2 or
[f64; 2]). The cam profile in joints_cam is a Ring: its own even-odd
test goes, and its edge walks, gap and area take edges(). face_params'
loop area, the text path's winding, tess pieces' ring area and the
copies in three tests call signed_area or contains; the formulas are
the same term for term.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* doc: sheet's closed outlines go through Ring

dedup takes and returns a Ring (dropping a last point back on the first
is what makes it a ring's), near_outline walks a Ring's edges, and the
copy of it beside fold checks calls it. point_in goes: its callers ask
the Ring. Its formula anchored each crossing on the other end of the
edge, so the two can differ only for a point on an edge to the last
digit; one caller sets such points aside first, the others test a
region's interior point, a cut's midpoint or another outline's corners.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* doc: cam tests build their outlines with Ring::from

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* geom: area_vector on Ring<Vec3>; three Newell sums use it

Ring<Vec3>::area_vector is half the sum of a × b round the ring. heal's
loop_area, lip's outer-loop turning and the revolve's loop orientation
summed it by hand with a wrapped index; they take it from the Ring
(the half is exact, and two of them only read its sign).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* geom: Aabb3 from points; boxes built and asked through it

Aabb3 collects from points (skipping non-finite ones, as add does) and
gains inflated, contains and meets. Fifteen hand-rolled min/max folds
over points or boxes in kernel, doc and engine become collect or union,
and their "within tol of the box" tests become inflated(tol).contains.
blend's refused-edge boxes and naming's face index hold an Aabb3.

A NaN point is now outside every box, where the old negated
comparisons let it in; an infinite point no longer stretches a box.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* geom: Aabb2, the plane's box; 2D folds and box tuples use it

Aabb2 mirrors Aabb3 (collect, add, union, inflated, contains, meets)
and adds relative, a point's place in the box. sketch's link and
link_loops each had that formula; link_loops' boundaries, prism's
segment and loop boxes, profiles' shape boxes and grid, and ends'
segment box hold an Aabb2 instead of a (low, high) pair. Folds in the
cam, sketch bounds, sheet's perforation grid and the sketch clipboard
collect one.

Boxes are built from the same terms (a round's box keeps c - r - tol).
As with Aabb3, a NaN point is outside every box and an infinite point
no longer stretches one.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* kernel: prism's segment boxes are plain Aabb2s

The SegBox alias named a (low, high) pair; Aabb2 says it itself.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* geom: Chain::bounds is an Aabb2; the boxes #2382 left as pairs follow

Chain::bounds returns an Aabb2. Its callers keep it: sheet's hole and
cut boxes (loop_box), letter boxes, island outlines and line-near-cut
test use meets, contains and inflated; profile's outline overlap and
max_clearance, profiles' box tests and the cam test read its corners.
flat_size and the flat pattern's JSON size are the union of the loops'
boxes (0 × 0 for no loop, where the pair fold gave -∞).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* geom: Aabb3::intersection; hand-grown and hand-met boxes use the box

Aabb3::intersection is the box both hold. ops' four overlap boxes of a
boolean's operands take it, and seven boxes grown by hand (ops' body
boxes, the distance set's bounds, coplanar's face box, eval_more's
padded mesh box, compare's group and region boxes) call inflated with
the same amount on every side.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
2026-10-20 03:44:49 +00:00
Irakli Kourtis fac3f96bdd Patch: G1/G2 to the faces beside the loop, general and N-sided loops, points (#759) (#1521)
Thanks @jyviko.
2026-10-15 23:07:24 -04:00
midasdf e8e2ccc8a9 Class-A surfacing 1/3: the continuity core, a G3 free-form blend and patch crown (#1249)
The continuity core (kernel bridge: Hermite control rows reproducing a support surface's position, tangent, curvature and change of curvature, G0 to G3), surface.blend between two edge chains (#764), and a crown for fitted patches. Existing patches and fillets are unchanged by default (crown 0 is the plain patch bit for bit). SurfaceBlend and Patch.crown are noted under format 22.
2026-10-15 13:32:16 -04:00
Irakli KourtisandClaude Opus 5.5 201e9d5f9f 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>
2026-10-12 21:37:01 -04:00