SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 142/509: kernel: the plain and crowned patch on a loop of the body's record edges, built by SMLib
jyviko3e564dffb09a
diff --git a/crates/kernel/src/fill.rs b/crates/kernel/src/fill.rsindex e9adfe9845..7e946ea0bf 100644--- a/crates/kernel/src/fill.rs+++ b/crates/kernel/src/fill.rs@@ -1,19 +1,24 @@-//! Filling a closed loop of a body's edges that is not planar with one face, bounded by the-//! body's own edges, whole: a B-spline height field over the loop's best-fit plane-//! (`solidcraft_geom::fill::fill_loop`) when the patch only has to meet the edges (G0) and the-//! loop bounds one; otherwise the general fill (`solidcraft_geom::fill_general`), developed from-//! the loop itself, which also meets the faces beside the loop with G1 or G2 and passes through-//! given points.+//! Filling a closed loop of a body's edges with one face, bounded by the body's own edges,+//! whole: the loop's plane when its edges certainly lie in one, otherwise a B-spline height field+//! over the loop's best-fit plane (`solidcraft_geom::fill::fill_loop`). The face is assembled on+//! the body's own edge records (`sew::assemble`) and built by SMLib. The height field's+//! parameters are plane coordinates, so each edge's pcurve is its exact projection onto the+//! plane.+//!+//! The general fill (`solidcraft_geom::fill_general`), which also meets the faces beside the loop+//! with G1 or G2 and passes through given points, is not ported yet: its surface's parameters are+//! developed from the loop, so the loop's edges have no exact pcurve on it, and the frames across+//! each edge come from `bridge::frames_across`.use solidcraft_geom::Vec3;-use solidcraft_geom::bspline::SplineError;-use solidcraft_geom::fill_general::{Across, FillSpec, MAX_FILL_POINTS, Station};-use truck_modeling as mt;--use crate::body::{Body, from_p3};-use crate::bridge::{Continuity, frames_across};-use crate::plane_fit::EdgeSampler;-use crate::record::{Rebuild, rebuilt_body};+use solidcraft_geom::brep::{self as b, Curve2, eval::CurveEval};+use solidcraft_geom::bspline::{HPoint, SplineError};+use solidcraft_geom::fill_general::MAX_FILL_POINTS;++use crate::body::Body;+use crate::bridge::Continuity;+use crate::history::{Change, EdgeOrigin, EdgeProv, FaceProv, History};+use crate::sew::{PartEdge, PartFace, PartUse, Parts, assemble};use crate::{KernelError, Result};/// How far (degrees) a G1 or G2 patch's normal may turn from its neighbour's along the loop.@@ -105,226 +110,341 @@ pub fn patch_edges_report(body: &Body, at: &[Vec3], spec: &PatchSpec) -> Result<return patch_edges_crowned(body, at, spec.crown).map(|b| (b, PatchReport::default()));}body.require_brep("patch")?;- crate::guard("patch", || {- let chain = crate::surfaces::picked_loop(body, at)?;- let mut orders = vec![spec.continuity; chain.len()];- for (p, g) in &spec.edges {- let e = crate::surfaces::edge_near(body, *p).ok_or_else(|| KernelError::Invalid(format!("no edge at {p:?}")))?;- let k = chain- .iter()- .position(|c| c.id() == e.id())- .ok_or_else(|| KernelError::Invalid("a continuity pick is not on an edge of the loop".into()))?;- if let Some(slot) = orders.get_mut(k) {- *slot = *g;- }+ Err(general_fill_unported())+}++/// The general fill's refusal until it is ported (module docs).+fn general_fill_unported() -> KernelError {+ KernelError::Invalid(+ "not supported yet: a patch meeting its neighbours with g1 or g2, through points, or on a loop that bounds no height field".into(),+ )+}++/// [`crate::patch_edges`] with a crown on the fitted face: positive makes the patch's middle+/// fuller, negative flatter, by `crown` times the loop's size (its projected box's diagonal), the+/// bump vanishing along the loop, so the face still meets the body's own edges. `crown` 0 is+/// exactly [`crate::patch_edges`], and a loop that is certainly planar makes the same exact planar+/// face whatever the crown. Its history is over `[body]`: the face is new, its edges the body's+/// own.+pub fn patch_edges_crowned(body: &Body, at: &[Vec3], crown: f64) -> Result<Body> {+ body.require_brep("patch")?;+ if at.is_empty() || at.len() > 10_000 {+ return Err(KernelError::Invalid("pick the edges of a closed loop".into()));+ }+ // A range test also throws out NaN.+ if !(solidcraft_geom::fill::MIN_CROWN..=solidcraft_geom::fill::MAX_CROWN).contains(&crown) {+ return Err(KernelError::Invalid("a patch's crown must be between -0.9 and 3".into()));+ }+ patch_loop(body, at, crown)+}++/// The patch on the closed loop of `body`'s edges picked by `at`: the loop's plane when it is+/// certainly planar (within [`planarity_tolerance`]), else the height field crowned by `crown`.+/// What `crate::patch_edges` makes with `crown` 0.+pub(crate) fn patch_loop(body: &Body, at: &[Vec3], crown: f64) -> Result<Body> {+ let record = crate::native::brep_record(body)?;+ let reach = body.size() * 0.05 + 1e-6;+ let chain = picked_loop(&record, at, reach)?;+ let mut sides = Vec::with_capacity(chain.len());+ for &(e, forward) in &chain {+ sides.push(Side::new(&record, e, forward)?);+ }+ let (surface, ccw, pcurve): (b::Surface, bool, Option<Projection>) = match planar(&record, &chain, &mut sides, planarity_tolerance(body))? {+ Some(plane) => (plane, true, None),+ None => {+ let tol = face_tolerance(body);+ let mut point = |k: usize, t: f64| sides.get_mut(k).and_then(|s| s.point(t));+ let fill = match solidcraft_geom::fill::fill_loop(chain.len(), &mut point, tol, crown) {+ Ok(fill) => fill,+ Err(SplineError::Unsupported(_)) if crown == 0.0 => return Err(general_fill_unported()),+ Err(e) => return Err(spline_error(e)),+ };+ let projection = Projection { origin: fill.origin, axes: fill.axes };+ (surface_record(&fill.surface)?, fill.counter_clockwise, Some(projection))}- if spec.crown != 0.0 && orders.iter().all(|g| *g == Continuity::G0) {- return Err(KernelError::Invalid("not supported yet: a crown on a patch through points with no g1 or g2 edge".into()));+ };+ patch_body(body, &record, &chain, surface, ccw, pcurve.as_ref(), face_tolerance(body))+}++/// The closed loop of `record`'s edges picked by points on them (the edge nearest each, within+/// `reach`), each with whether the loop runs along it: it starts with the last edge picked, run+/// its own way. Edges that branch, or do not close one loop, are refused.+fn picked_loop(record: &b::Brep, at: &[Vec3], reach: f64) -> Result<Vec<(usize, bool)>> {+ let mut picked: Vec<usize> = Vec::new();+ for p in at {+ if !p.is_finite() {+ return Err(KernelError::Invalid(format!("no edge at {p:?}")));+ }+ let e = nearest_edge(record, *p, reach).ok_or_else(|| KernelError::Invalid(format!("no edge at {p:?}")))?;+ if !picked.contains(&e) {+ picked.push(e);+ }+ }+ let ends = |e: usize| record.edges.get(e).map(|x| x.vertices);+ let mut uses: std::collections::HashMap<u32, usize> = std::collections::HashMap::new();+ for &e in &picked {+ for v in ends(e).into_iter().flatten() {+ *uses.entry(v).or_default() += 1;+ }+ }+ if uses.values().any(|n| *n > 2) {+ return Err(KernelError::Invalid("the edges branch: pick one chain".into()));+ }+ let open = || KernelError::Invalid("the edges do not form a closed loop".into());+ if uses.values().any(|n| *n != 2) {+ return Err(open());+ }+ let first = picked.pop().ok_or_else(open)?;+ let [start, mut at_v] = ends(first).ok_or_else(open)?;+ let mut chain = vec![(first, true)];+ while at_v != start {+ let k = picked.iter().position(|e| ends(*e).is_some_and(|[a, z]| a == at_v || z == at_v)).ok_or_else(open)?;+ let e = picked.remove(k);+ let [a, z] = ends(e).ok_or_else(open)?;+ let forward = a == at_v;+ at_v = if forward { z } else { a };+ chain.push((e, forward));+ }+ if !picked.is_empty() {+ return Err(open());+ }+ Ok(chain)+}++/// The record edge whose curve comes nearest `p` (by samples along each), within `reach`.+fn nearest_edge(record: &b::Brep, p: Vec3, reach: f64) -> Option<usize> {+ let mut best: Option<(f64, usize)> = None;+ for (i, e) in record.edges.iter().enumerate() {+ let Ok(c) = CurveEval::new(&e.curve) else { continue };+ let [t0, t1] = e.interval;+ for k in 0..=32 {+ let Some(q) = c.point(t0 + (t1 - t0) * k as f64 / 32.0) else { continue };+ let d = q.dist(p);+ if best.is_none_or(|(bd, _)| d < bd) {+ best = Some((d, i));+ }}- general_fill(body, &chain, &orders, &spec.points, spec.crown)- })+ }+ best.filter(|(d, _)| *d <= reach).map(|(_, e)| e)}-/// One edge of the loop as the general fill samples it.+/// One edge of the loop as the fill samples it: `t` from 0 at the loop's start of the edge to 1 at+/// its end, the start being the edge's own vertex (an imported edge's curve may end a little off+/// it).struct Side {- sampler: EdgeSampler,+ curve: CurveEval,+ interval: [f64; 2],+ forward: bool,start: Vec3,- /// The face beside the edge, and whether its boundary runs the edge the way the loop does.- face: mt::Face,- along: bool,- order: Continuity,- /// The loop has a corner at the edge's start, and the neighbours' tangent planes disagree- /// there.- corner: bool,- clash: bool,}impl Side {- fn point(&mut self, t: f64) -> Option<Vec3> {- // The loop's corners are its vertices (an imported edge's curve may end a little off).- if t <= 0.0 { Some(self.start) } else { self.sampler.at(t) }+ fn new(record: &b::Brep, e: usize, forward: bool) -> Result<Side> {+ let edge = record.edges.get(e).ok_or_else(|| KernelError::Failed("patch: edge reference".into()))?;+ let curve = CurveEval::new(&edge.curve).map_err(|err| KernelError::Invalid(format!("edge {e} cannot be sampled: {err}")))?;+ let v = edge.vertices[if forward { 0 } else { 1 }];+ let start = record.vertices.get(v as usize).map(|v| Vec3::new(v.point[0], v.point[1], v.point[2]));+ let start = start.ok_or_else(|| KernelError::Failed("patch: vertex reference".into()))?;+ Ok(Side { curve, interval: edge.interval, forward, start })}- /// The loop's unit tangent at `t`, by a central difference (one-sided at the ends).- fn tangent(&mut self, t: f64) -> Option<Vec3> {- const STEP: f64 = 1e-4;- let (a, b) = ((t - STEP).max(0.0), (t + STEP).min(1.0));- let (p, q) = (self.sampler.at(a)?, self.sampler.at(b)?);- (q - p).normalized()- }-- /// The face's frames at points of this edge with the loop's tangents there.- fn frames(&self, stations: &[(Vec3, Vec3)], size: f64, shape: bool) -> Result<Vec<(crate::Frame, Vec3)>> {- let along: Vec<(Vec3, Vec3)> = stations.iter().map(|(p, t)| (*p, if self.along { *t } else { *t * -1.0 })).collect();- frames_across(&self.face, &along, size, shape)+ fn point(&mut self, t: f64) -> Option<Vec3> {+ if t <= 0.0 {+ return Some(self.start);+ }+ let [a, z] = self.interval;+ let s = t.min(1.0);+ self.curve.point(if self.forward { a + (z - a) * s } else { z - (z - a) * s })}}-/// The general fill of the closed loop `chain` of `body`'s edges, edge `k` meeting the face beside-/// it with `orders[k]`, passing through `points`, its middle made fuller by `crown` (see-/// [`PatchSpec::crown`]). Call it under [`crate::guard`].-pub(crate) fn general_fill(body: &Body, chain: &[mt::Edge], orders: &[Continuity], points: &[Vec3], crown: f64) -> Result<(Body, PatchReport)> {- let tol = face_tolerance(body);- let size = body.size().max(solidcraft_geom::LINEAR_TOL);- let mut sides: Vec<Side> = Vec::with_capacity(chain.len());- for (e, order) in chain.iter().zip(orders) {- let faces: Vec<&mt::Face> = body.solid.face_iter().filter(|f| f.edge_iter().any(|x| x.id() == e.id())).collect();- let face = match faces.as_slice() {- [f] => (*f).clone(),- [f, ..] if *order == Continuity::G0 => (*f).clone(),- [] => return Err(KernelError::Failed("patch: an edge of the loop bounds no face".into())),- _ => return Err(KernelError::Invalid("an edge of the loop lies between two faces: g1 and g2 need the one face beside it".into())),- };- let along = face- .boundaries()- .iter()- .flat_map(|w| w.edge_iter())- .find(|x| x.id() == e.id())- .map(|x| x.orientation() == e.orientation())- .ok_or_else(|| KernelError::Failed("patch: the face beside an edge does not hold it".into()))?;- let sampler = EdgeSampler::new(e).ok_or_else(|| KernelError::Invalid("an edge has no parameter range".into()))?;- sides.push(Side { sampler, start: from_p3(e.front().point()), face, along, order: *order, corner: false, clash: false });- }- // The corners: where the loop's tangent turns, and where the faces beside it disagree.- let n = sides.len();- for k in 0..n {- let prev = (k + n - 1) % n;- let (Some(t_in), Some(t_out)) = (sides.get_mut(prev).and_then(|s| s.tangent(1.0)), sides.get_mut(k).and_then(|s| s.tangent(0.0))) else {- return Err(KernelError::Invalid("an edge of the loop has no tangent".into()));- };- let Some(vertex) = sides.get(k).map(|s| s.start) else { continue };- let corner = t_in.dot(t_out) < CORNER_DEG.to_radians().cos();- let normal = |s: Option<&Side>, t: Vec3| -> Result<Vec3> {- let s = s.ok_or_else(|| KernelError::Failed("patch: side".into()))?;- let f = s.frames(&[(vertex, t)], size, false)?;- f.first().map(|f| f.1).ok_or_else(|| KernelError::Failed("patch: frame".into()))+/// The plane of the loop when its edges certainly lie in one within `tol`, `None` otherwise. The+/// plane is fitted to points along the edges (through their mean, its normal the loop's area+/// vector, so the loop runs counter-clockwise about it); each edge is then certified+/// conservatively: a line by its ends, a polyline or spline by its control points (the curve lies+/// in their convex hull, weights positive), a circle or ellipse by its centre and how far its+/// axes tilt out of the plane, a traced intersection only when one of its two surfaces is a plane+/// that the loop's points lie on. Samples alone are never trusted: a spline can bulge out of the+/// plane between them.+fn planar(record: &b::Brep, chain: &[(usize, bool)], sides: &mut [Side], tol: f64) -> Result<Option<b::Surface>> {+ const SAMPLES: usize = 16;+ let mut pts = Vec::with_capacity(sides.len() * SAMPLES);+ for side in sides.iter_mut() {+ for k in 0..SAMPLES {+ let Some(p) = side.point(k as f64 / SAMPLES as f64) else { return Ok(None) };+ pts.push(p);+ }+ }+ let mean = pts.iter().fold(Vec3::ZERO, |s, p| s + *p) * (1.0 / pts.len().max(1) as f64);+ let area = pts.iter().zip(pts.iter().cycle().skip(1)).fold(Vec3::ZERO, |n, (p, q)| n + (*p - mean).cross(*q - mean));+ let Some(n) = area.normalized() else { return Ok(None) };+ let off = |p: Vec3| (p - mean).dot(n).abs();+ let on = |p: [f64; 3]| off(Vec3::new(p[0], p[1], p[2])) <= tol;+ if !pts.iter().all(|p| off(*p) <= tol) {+ return Ok(None);+ }+ let holds = |s: &b::Surface| -> bool {+ let (o, normal) = match s {+ b::Surface::Plane { origin, u_axis, v_axis } => {+ let (u, v) = (Vec3::new(u_axis[0], u_axis[1], u_axis[2]), Vec3::new(v_axis[0], v_axis[1], v_axis[2]));+ (Vec3::new(origin[0], origin[1], origin[2]), u.cross(v).normalized())+ }+ _ => return false,};- let g1 = |s: Option<&Side>| s.is_some_and(|s| s.order != Continuity::G0);- let clash = if g1(sides.get(prev)) || g1(sides.get(k)) {- let (a, b) = (normal(sides.get(prev), t_in)?, normal(sides.get(k), t_out)?);- a.dot(b).abs() < (2.0 * PATCH_ANGLE_TOL_DEG).to_radians().cos()- } else {- false+ let Some(q) = normal else { return false };+ pts.iter().all(|p| (*p - o).dot(q).abs() <= tol && (*p - n * (*p - mean).dot(n) - o).dot(q).abs() <= tol)+ };+ for &(e, _) in chain {+ let Some(edge) = record.edges.get(e) else { return Ok(None) };+ let certified = match &edge.curve {+ b::Curve::Line { start, end } => on(*start) && on(*end),+ b::Curve::Polyline { points } | b::Curve::Spline { points, .. } => points.iter().all(|p| on(*p)),+ b::Curve::RationalSpline { homogeneous, .. } => homogeneous.iter().all(|h| h[3] > 0.0 && on([h[0] / h[3], h[1] / h[3], h[2] / h[3]])),+ b::Curve::Circle { frame, radius } => conic_on(frame, [*radius; 2], &on, n, tol),+ b::Curve::Ellipse { frame, radii } => conic_on(frame, *radii, &on, n, tol),+ b::Curve::SurfaceIntersection { surfaces, .. } => surfaces.iter().any(|s| holds(s)),};- if let Some(s) = sides.get_mut(k) {- s.corner = corner;- s.clash = clash;+ if !certified {+ return Ok(None);}}- let mut stations = |k: usize, ts: &[f64]| -> std::result::Result<Vec<Station>, String> {- let side = sides.get_mut(k).ok_or("no such side")?;- let mut at = Vec::with_capacity(ts.len());- for &t in ts {- let (Some(p), Some(tangent)) = (side.point(t), side.tangent(t)) else { return Err("an edge cannot be sampled".into()) };- at.push((p, tangent));- }- let frames = side.frames(&at, size, side.order == Continuity::G2).map_err(|e| e.to_string())?;- let mut out = Vec::with_capacity(ts.len());- for ((&t, (p, tangent)), (frame, normal)) in ts.iter().zip(&at).zip(&frames) {- let up = tangent.cross(frame.leave).normalized().ok_or("the loop runs across its neighbour")?;- let across = (side.order != Continuity::G0).then(|| Across {- leave: frame.leave,- normal: *normal,- bend: (side.order == Continuity::G2).then_some(frame.bend),- });- let first = t <= 0.0;- out.push(Station { p: *p, up, across, corner: first && side.corner, clash: first && side.clash });- }- Ok(out)- };- let spec = FillSpec { tol, angle_tol: PATCH_ANGLE_TOL_DEG.to_radians(), crown, points };- let fill = solidcraft_geom::fill_general::fill_general(chain.len(), &mut stations, &spec).map_err(spline_error)?;- // The wire runs counter-clockwise about the surface's normal.- let wire: mt::Wire =- if fill.counter_clockwise { chain.to_vec().into() } else { chain.iter().rev().map(mt::Edge::inverse).collect::<Vec<_>>().into() };- let face = mt::Face::try_new(vec![wire], crate::spline_conv::surface(&fill.surface)?).map_err(|e| KernelError::Failed(format!("fill: {e}")))?;- let mut rec = Rebuild::default();- rec.made(&face, Vec::new());- let report = PatchReport {- general: true,- gap: fill.deviation,- normal_deviation_deg: fill.normal_deviation.to_degrees(),- normal_deviation_all_deg: fill.normal_deviation_all.to_degrees(),- curvature_mismatch: fill.curvature_mismatch,- point_gap: fill.point_deviation,- };- Ok((rebuilt_body(crate::surfaces::surface_body(vec![face]), &[&body.solid], &rec), report))+ let t = if n.x.abs() < 0.9 { Vec3::X } else { Vec3::Y };+ let Some(u) = (t - n * t.dot(n)).normalized() else { return Ok(None) };+ let arr = |p: Vec3| [p.x, p.y, p.z];+ Ok(Some(b::Surface::Plane { origin: arr(mean), u_axis: arr(u), v_axis: arr(n.cross(u)) }))}-/// The loop turns by more than this (degrees) at a corner: its stations hold position only.-const CORNER_DEG: f64 = 1.0;+/// A conic lies within `tol` of the plane (normal `n`) when its centre does and its axes, scaled by+/// its radii, tilt out of the plane by no more than that together.+fn conic_on(frame: &b::Frame, radii: [f64; 2], on: &dyn Fn([f64; 3]) -> bool, n: Vec3, tol: f64) -> bool {+ let axis = |a: [f64; 3]| Vec3::new(a[0], a[1], a[2]).dot(n).abs();+ on(frame.origin) && radii[0] * axis(frame.x_axis) + radii[1] * axis(frame.y_axis) <= tol+}-/// A surface body of one face filling the closed loop `chain` of `body`'s edges (each edge-/// oriented along the loop, each ending where the next starts), within [`face_tolerance`] of-/// every edge. Its history is over `[body]`: the face is new, its edges the body's own. Call it-/// under [`crate::guard`].-pub(crate) fn fill_loop(body: &Body, chain: &[mt::Edge]) -> Result<Body> {- fill_loop_crowned(body, chain, 0.0)+/// The plane a height field stands on: its parameters are coordinates along `axes` from `origin`.+struct Projection {+ origin: Vec3,+ axes: [Vec3; 2],}-/// [`fill_loop`] with a crown: positive makes the fitted patch's middle fuller, negative flatter,-/// by `crown` times the loop's size (see `solidcraft_geom::fill::fill_loop`). The bump vanishes on-/// the loop, so the face still meets the body's own edges exactly as the plain fill does.-pub(crate) fn fill_loop_crowned(body: &Body, chain: &[mt::Edge], crown: f64) -> Result<Body> {- let tol = face_tolerance(body);- let mut sides: Vec<(EdgeSampler, Vec3)> = Vec::with_capacity(chain.len());- for e in chain {- let sampler = EdgeSampler::new(e).ok_or_else(|| KernelError::Invalid("an edge has no parameter range".into()))?;- sides.push((sampler, from_p3(e.front().point())));- }- let mut point = |k: usize, t: f64| -> Option<Vec3> {- let (sampler, start) = sides.get_mut(k)?;- // The loop's corners are its vertices (an imported edge's curve may end a little off).- if t <= 0.0 { Some(*start) } else { sampler.at(t) }- };- let fill = match solidcraft_geom::fill::fill_loop(chain.len(), &mut point, tol, crown) {- Ok(fill) => fill,- // Not a height field over its plane (or too wavy for one): the general fill, developed- // from the loop itself, when no crown asks for the height field's bump.- Err(SplineError::Unsupported(_)) if crown == 0.0 => {- let orders = vec![Continuity::G0; chain.len()];- return general_fill(body, chain, &orders, &[], 0.0).map(|(b, _)| b);- }- Err(e) => return Err(spline_error(e)),- };- // The wire runs counter-clockwise about the surface's normal.- let wire: mt::Wire =- if fill.counter_clockwise { chain.to_vec().into() } else { chain.iter().rev().map(mt::Edge::inverse).collect::<Vec<_>>().into() };- let face = mt::Face::try_new(vec![wire], crate::spline_conv::surface(&fill.surface)?).map_err(|e| KernelError::Failed(format!("fill: {e}")))?;- let mut rec = Rebuild::default();- rec.made(&face, Vec::new());- Ok(rebuilt_body(crate::surfaces::surface_body(vec![face]), &[&body.solid], &rec))+impl Projection {+ /// The edge's exact pcurve on the height field: its curve projected onto the plane, which is+ /// affine, so a line or spline stays one with its knots and weights. `None` for a conic or a+ /// traced intersection, whose angle or trace parameter no B-spline in (u, v) reproduces.+ fn pcurve(&self, curve: &b::Curve, [a, z]: [f64; 2]) -> Option<Curve2> {+ let uv = |p: Vec3| [(p - self.origin).dot(self.axes[0]), (p - self.origin).dot(self.axes[1])];+ let v = |p: &[f64; 3]| Vec3::new(p[0], p[1], p[2]);+ let (degree, knots, ctrl): (usize, Vec<f64>, Vec<HPoint>) = match curve {+ b::Curve::Line { start, end } => {+ let (s, e) = (v(start), v(end));+ let (p, q) = (s + (e - s) * a, s + (e - s) * z);+ return Some(Curve2::Spline { knots: vec![a, a, z, z], points: vec![uv(p), uv(q)] });+ }+ b::Curve::Polyline { points } => {+ let mut knots = vec![0.0];+ knots.extend((0..points.len()).map(|i| i as f64));+ knots.push(points.len().saturating_sub(1) as f64);+ (1, knots, points.iter().map(|p| HPoint::weighted(v(p), 1.0)).collect())+ }+ b::Curve::Spline { knots, points } => {+ (knots.len().checked_sub(points.len() + 1)?, knots.clone(), points.iter().map(|p| HPoint::weighted(v(p), 1.0)).collect())+ }+ b::Curve::RationalSpline { knots, homogeneous } => (+ knots.len().checked_sub(homogeneous.len() + 1)?,+ knots.clone(),+ homogeneous.iter().map(|h| HPoint { x: h[0], y: h[1], z: h[2], w: h[3] }).collect(),+ ),+ b::Curve::Circle { .. } | b::Curve::Ellipse { .. } | b::Curve::SurfaceIntersection { .. } => return None,+ };+ // The piece on the edge's own interval (the same points at the same parameters).+ let domain = [*knots.get(degree)?, *knots.get(knots.len() - degree - 1)?];+ let (knots, ctrl) = if domain == [a, z] { (knots, ctrl) } else { solidcraft_geom::bspline::segment(degree, &knots, &ctrl, a, z).ok()? };+ let homogeneous = ctrl+ .iter()+ .map(|h| {+ let p = uv(Vec3::new(h.x / h.w, h.y / h.w, h.z / h.w));+ [p[0] * h.w, p[1] * h.w, h.w]+ })+ .collect();+ Some(Curve2::RationalSpline { knots, homogeneous })+ }}-/// [`crate::patch_edges`] with a crown on the fitted face: positive makes the patch's middle-/// fuller, negative flatter, by `crown` times the loop's size (its projected box's diagonal), the-/// bump vanishing along the loop, so the face still meets the body's own edges. `crown` 0 is-/// exactly [`crate::patch_edges`], and a loop that is certainly planar ([`crate::plane_fit`])-/// makes the same exact planar face whatever the crown. Its history is over `[body]`: the face is-/// new, its edges the body's own.-pub fn patch_edges_crowned(body: &Body, at: &[Vec3], crown: f64) -> Result<Body> {- if crown == 0.0 {- return crate::surfaces::patch_edges(body, at);+/// A geom NURBS surface as a record: a plain spline where every weight is one.+fn surface_record(s: &solidcraft_geom::bspline::NurbsSurface) -> Result<b::Surface> {+ let [ku, kv] = s.knots().clone();+ let rows = s.net().into_u_rows();+ if rows.iter().flatten().all(|h| h.w == 1.0) {+ Ok(b::Surface::Spline { u_knots: ku, v_knots: kv, points: rows.iter().map(|r| r.iter().map(|h| [h.x, h.y, h.z]).collect()).collect() })+ } else {+ Ok(b::Surface::RationalSpline {+ u_knots: ku,+ v_knots: kv,+ homogeneous: rows.iter().map(|r| r.iter().map(|h| [h.x, h.y, h.z, h.w]).collect()).collect(),+ })}- body.require_brep("patch")?;- if at.is_empty() || at.len() > 10_000 {- return Err(KernelError::Invalid("pick the edges of a closed loop".into()));+}++/// The one-face sheet on `surface` bounded by the loop `chain` of `record`'s own edges, run+/// counter-clockwise about the surface's natural normal (`ccw`: the chain already does), each+/// edge's pcurve the exact projection where the surface is a height field. Its history is over+/// `[body]`: the face is new, each edge the body's own.+fn patch_body(+ body: &Body,+ record: &b::Brep,+ chain: &[(usize, bool)],+ surface: b::Surface,+ ccw: bool,+ projection: Option<&Projection>,+ tol: f64,+) -> Result<Body> {+ let fail = |m: &str| KernelError::Failed(format!("patch: {m}"));+ let mut vertices: Vec<[f64; 3]> = Vec::new();+ let mut vertex_of: std::collections::HashMap<u32, u32> = std::collections::HashMap::new();+ let mut edges = Vec::with_capacity(chain.len());+ let mut uses = Vec::with_capacity(chain.len());+ for (k, &(e, forward)) in chain.iter().enumerate() {+ let edge = record.edges.get(e).ok_or_else(|| fail("edge reference"))?;+ let mut ends = [0u32; 2];+ for (end, v) in ends.iter_mut().zip(edge.vertices) {+ let next = u32::try_from(vertices.len()).map_err(|_| fail("vertex budget"))?;+ *end = *vertex_of.entry(v).or_insert(next);+ if *end == next {+ vertices.push(record.vertices.get(v as usize).ok_or_else(|| fail("vertex reference"))?.point);+ }+ }+ let given = match projection {+ Some(p) => Some(p.pcurve(&edge.curve, edge.interval).ok_or_else(|| {+ KernelError::Invalid(+ "not supported yet: a fitted patch on a circular, elliptic or traced edge (it has no exact pcurve on the fit)".into(),+ )+ })?),+ None => None,+ };+ edges.push(PartEdge { curve: edge.curve.clone(), interval: edge.interval, vertices: ends });+ uses.push(PartUse { edge: k as u32, forward, given });}- // A range test also throws out NaN.- if !(solidcraft_geom::fill::MIN_CROWN..=solidcraft_geom::fill::MAX_CROWN).contains(&crown) {- return Err(KernelError::Invalid("a patch's crown must be between -0.9 and 3".into()));+ if !ccw {+ uses = uses.into_iter().rev().map(|u| PartUse { forward: !u.forward, ..u }).collect();}- crate::guard("patch", || {- let chain = crate::surfaces::picked_loop(body, at)?;- let Some(face) = crate::plane_fit::planar_face(&chain, planarity_tolerance(body))? else {- // Not certainly planar: a fitted surface, crowned.- return fill_loop_crowned(body, &chain, crown);- };- // A new face on the body's own edges (a plane has no middle to fill).- let mut rec = Rebuild::default();- rec.made(&face, Vec::new());- Ok(rebuilt_body(crate::surfaces::surface_body(vec![face]), &[&body.solid], &rec))- })+ let made = assemble(Parts { vertices, edges, faces: vec![PartFace { surface, forward: true, loops: vec![uses] }], tolerance: tol }, false)?;+ let smlib = solidcraft_smlib::Brep::from_record(&made.brep, true).map_err(|e| KernelError::Failed(format!("patch: SMLib: {e}")))?;+ let (patch, order) = crate::native::body_from_smlib_ordered(&smlib)?;+ // The patch's edges in its own order, each from the loop edge it is.+ let Some(order) = order else { return Ok(patch) };+ let mut origins: Vec<Option<usize>> = vec![None; patch.edge_count()];+ for (k, c) in made.edges.iter().enumerate() {+ let (Some(c), Some(&(e, _))) = (c, chain.get(k)) else { continue };+ let j = if order.edges.is_empty() { *c } else { *order.edges.get(*c).ok_or_else(|| fail("edge order"))? };+ *origins.get_mut(j).ok_or_else(|| fail("edge order"))? = Some(e);+ }+ let Some(origins) = origins.into_iter().collect::<Option<Vec<usize>>>() else { return Ok(patch) };+ let history = History {+ operands: 1,+ faces: vec![FaceProv { origins: Vec::new(), change: Change::Generated }],+ edges: origins.into_iter().map(|edge| EdgeProv { faces: vec![0], origins: vec![EdgeOrigin::Edge { operand: 0, edge }] }).collect(),+ };+ patch.with_history(history, &[body])}/// How far a loop's edges may be from a plane for its patch to be that plane: `10⁻⁷` of the@@ -336,30 +456,31 @@ pub(crate) fn planarity_tolerance(body: &Body) -> f64 {}/// How far the fill's surface may be from the loop's edges: `10⁻⁶` of the body's size, at least-/// `10⁻⁵` mm — ten times [`planarity_tolerance`]. Truck meshes a face from its edges' own-/// polylines (shared with the neighbouring faces), so the mesh stays watertight whatever the-/// gap: measured on a five-sided rim, fills whose edges were up to `4.5·10⁻⁴` mm off the surface-/// meshed cleanly and stitched back into closed solids. Ten times the linear tolerance because a+/// `10⁻⁵` mm — ten times [`planarity_tolerance`]. Ten times the linear tolerance because a/// fitted surface approaches curved edges like a cubic spline, so each further factor of ten/// costs about twice the spans each way, and imported edges may already lie `10⁻⁵` mm or more off-/// their vertices; two orders below what meshing tolerates. Later operations must take the face-/// to contain its edges within this tolerance, not the linear one: the face's edges are the-/// body's exact edges, the surface between them is the fit.+/// their vertices. Later operations must take the face to contain its edges within this+/// tolerance, not the linear one: the face's edges are the body's exact edges, the surface+/// between them is the fit (the patch record gives its edges this tolerance).pub(crate) fn face_tolerance(body: &Body) -> f64 {(body.size() * 1e-6).max(1e-5)}#[cfg(test)]mod tests {- use mt::{BoundedCurve, InnerSpace, MetricSpace, ParametricCurve, ParametricSurface};+ use solidcraft_geom::brep::{self as b, eval::CurveEval, eval::SurfaceEval};use solidcraft_geom::{Loop2, Plane, Region2, Vec2, Vec3};- use truck_modeling as mt;- use crate::body::{Body, from_p3, p3};+ use crate::body::Body;use crate::boolean_record::tests::{Reach, checked};use crate::history::{Change, EdgeOrigin};+ use crate::sew::{PartEdge, PartFace, PartUse, Parts, assemble};use crate::{BoolOp, boolean, copy_faces, cylinder, extrude, measure, patch_edges, patch_edges_crowned, stitch};+ fn v3(p: [f64; 3]) -> Vec3 {+ Vec3::new(p[0], p[1], p[2])+ }+/// The cutting cylinder: axis along y at x = 0, z = 50, radius 40, so the top of a prism/// within 20 of the axis and 20 high is cut away everywhere (to between 10 and 15.4 mm).fn cut_height(x: f64) -> f64 {@@ -390,51 +511,49 @@ mod tests {(0..n).map(|k| Vec2::from_angle(phase + k as f64 * std::f64::consts::TAU / n as f64) * 20.0).collect()}- /// The distance from `p` to the surface: the nearest of a grid of samples, then Gauss–Newton- /// within the domain.- fn to_surface(s: &mt::Surface, p: mt::Point3) -> f64 {- let (Some((u0, u1)), Some((v0, v1))) = s.try_range_tuple() else { panic!("a bounded surface") };- let n = 80;- let mut best = (f64::MAX, u0, v0);- for i in 0..=n {- for j in 0..=n {- let (u, v) = (u0 + (u1 - u0) * i as f64 / n as f64, v0 + (v1 - v0) * j as f64 / n as f64);- let d = s.subs(u, v).distance(p);- if d < best.0 {- best = (d, u, v);- }- }- }- let (_, mut u, mut v) = best;- for _ in 0..50 {- let (q, a, b) = (s.subs(u, v), s.uder(u, v), s.vder(u, v));- let r = q - p;- let (aa, ab, bb) = (a.dot(a), a.dot(b), b.dot(b));- let det = aa * bb - ab * ab;- if det.abs() < 1e-300 {- break;- }- let (ga, gb) = (a.dot(r), b.dot(r));- u = (u - (bb * ga - ab * gb) / det).clamp(u0, u1);- v = (v - (aa * gb - ab * ga) / det).clamp(v0, v1);- }- s.subs(u, v).distance(p)+ /// The body's record.+ fn record(body: &Body) -> b::Brep {+ crate::native::brep_record(body).unwrap()+ }++ /// The surface of the body's first face.+ fn first_surface(body: &Body) -> b::Surface {+ record(body).faces[0].surface.clone()+ }++ /// The distance from `p` to the surface (its nearest point).+ fn to_surface(s: &b::Surface, p: Vec3) -> f64 {+ let e = SurfaceEval::new(s).unwrap();+ let uv = e.project(p, None, f64::INFINITY).expect("a nearest point");+ e.point(uv).unwrap().dist(p)}- /// The farthest point along the face's edges from its surface.- fn edges_off_surface(face: &mt::Face) -> f64 {- let s = face.surface();+ /// The farthest point along the first face's edges from its surface.+ fn edges_off_surface(body: &Body) -> f64 {+ let r = record(body);+ let face = &r.faces[0];let mut worst = 0.0f64;- for e in face.boundaries().iter().flat_map(|w| w.edge_iter()) {- let c = e.curve();- let (t0, t1) = c.range_tuple();- for k in 0..=24 {- worst = worst.max(to_surface(&s, c.subs(t0 + (t1 - t0) * k as f64 / 24.0)));+ for l in &face.loops {+ let b::Loop::Edges { edges } = l else { continue };+ for u in edges {+ let e = &r.edges[u.edge as usize];+ let c = CurveEval::new(&e.curve).unwrap();+ let [t0, t1] = e.interval;+ for k in 0..=24 {+ worst = worst.max(to_surface(&face.surface, c.point(t0 + (t1 - t0) * k as f64 / 24.0).unwrap()));+ }}}worst}+ /// Whether every edge of `made` is one of `of`'s own (the same curve record on the same+ /// interval).+ fn own_edges(made: &Body, of: &Body) -> bool {+ let own = record(of).edges;+ record(made).edges.iter().all(|e| own.iter().any(|o| o.curve == e.curve && o.interval == e.interval))+ }+/// The fill's mesh: every normal finite, and no triangle folded over (all face the same way/// as the mesh's total area vector, by a clear margin).fn mesh_is_clean(fill: &Body) -> f64 {@@ -463,15 +582,13 @@ mod tests {let fill = patch_edges(open, rim).unwrap();assert!(fill.is_surface());assert_eq!(fill.face_count(), 1, "one face");- let face = fill.solid.face_iter().next().unwrap().clone();- assert!(!matches!(face.surface(), mt::Surface::Plane(_)));- // Its edges are the open body's own, by identity, and nothing else.- let own: Vec<mt::EdgeID> = open.solid.edge_iter().map(|e| e.id()).collect();- assert!(fill.solid.edge_iter().all(|e| own.contains(&e.id())), "an edge that is not the body's");+ assert!(!matches!(first_surface(&fill), b::Surface::Plane { .. }));+ // Its edges are the open body's own, and nothing else.+ assert!(own_edges(&fill, open), "an edge that is not the body's");let h = checked(&fill, &[open], 0.05, Reach { made: 0.0, moved: 0.0 }, &|_| true);assert!(h.faces.iter().all(|f| f.change == Change::Generated && f.origins.is_empty()));assert!(h.edges.iter().all(|e| matches!(e.origins.as_slice(), [EdgeOrigin::Edge { operand: 0, .. }])));- let off = edges_off_surface(&face);+ let off = edges_off_surface(&fill);let tol = super::face_tolerance(open);assert!(off <= tol, "an edge is {off} off the face (tolerance {tol})");mesh_is_clean(&fill);@@ -481,12 +598,15 @@ mod tests {}/// The fill's height over the point `(x, y)`: Newton's method on the surface's `x`, `y` from- /// the nearest of a grid of samples.- fn height_over(s: &mt::Surface, x: f64, y: f64, start: &mut Option<(f64, f64)>) -> Option<f64> {- let (Some((u0, u1)), Some((v0, v1))) = s.try_range_tuple() else { return None };+ /// the middle of its face's domain (or the last answer).+ fn height_over(body: &Body, x: f64, y: f64, start: &mut Option<(f64, f64)>) -> Option<f64> {+ let r = record(body);+ let face = &r.faces[0];+ let s = SurfaceEval::new(&face.surface).ok()?;+ let [[u0, u1], [v0, v1]] = face.domain;let (mut u, mut v) = start.unwrap_or(((u0 + u1) / 2.0, (v0 + v1) / 2.0));for _ in 0..30 {- let (q, a, b) = (s.subs(u, v), s.uder(u, v), s.vder(u, v));+ let (q, a, b) = s.derivs(u, v)?;let (rx, ry) = (q.x - x, q.y - y);let det = a.x * b.y - a.y * b.x;if det.abs() < 1e-300 {@@ -495,7 +615,7 @@ mod tests {u = (u - (b.y * rx - b.x * ry) / det).clamp(u0, u1);v = (v - (a.x * ry - a.y * rx) / det).clamp(v0, v1);}- let q = s.subs(u, v);+ let q = s.point([u, v])?;*start = Some((u, v));((q.x - x).hypot(q.y - y) < 1e-9).then_some(q.z)}@@ -504,7 +624,6 @@ mod tests {/// cylinder integrated over the polygon (midpoint rule on a 300 × 300 grid; the integrand/// vanishes on the rim, so cells across it add little error).fn gained(fill: &Body, corners: &[Vec2]) -> f64 {- let s = fill.solid.face_iter().next().unwrap().surface();let polygon = solidcraft_geom::Ring::from(corners.to_vec());let solidcraft_geom::Aabb2 { min: lo, max: hi } = polygon.bounds();let n = 300;@@ -517,7 +636,7 @@ mod tests {for j in 0..n {let y = lo.y + (j as f64 + 0.5) * dy;if inside(x, y) {- let h = height_over(&s, x, y, &mut start).expect("the fill covers the polygon");+ let h = height_over(fill, x, y, &mut start).expect("the fill covers the polygon");sum += (h - cut_height(x)) * dx * dy;}}@@ -538,6 +657,78 @@ mod tests {assert!((got - want).abs() <= bound, "{name}: {got} vs {want}");}+ /// An open sheet of walls hanging from the closed loop `top` (each a curve record from one+ /// corner to the next, `corners[k]` to `corners[k + 1]`), each wall swept straight along+ /// `drop`: a plane under a line, a ruled B-spline under a spline (its pcurves its exact iso+ /// lines and rulings).+ fn walls(corners: &[Vec3], top: &[b::Curve], drop: Vec3) -> Body {+ let n = corners.len();+ let arr = |p: Vec3| [p.x, p.y, p.z];+ // Vertices: the top corners, then the bottom ones.+ let vertices: Vec<[f64; 3]> = corners.iter().map(|p| arr(*p)).chain(corners.iter().map(|p| arr(*p + drop))).collect();+ let moved = |c: &b::Curve| match c {+ b::Curve::Line { start, end } => b::Curve::Line { start: arr(v3(*start) + drop), end: arr(v3(*end) + drop) },+ b::Curve::Spline { knots, points } => {+ b::Curve::Spline { knots: knots.clone(), points: points.iter().map(|p| arr(v3(*p) + drop)).collect() }+ }+ _ => panic!("lines and splines"),+ };+ let interval = |c: &b::Curve| match c {+ b::Curve::Spline { knots, points } => [knots[knots.len() - points.len() - 1], knots[points.len()]],+ _ => [0.0, 1.0],+ };+ let mut edges = Vec::new();+ for k in 0..n {+ let c = &top[k];+ edges.push(PartEdge { curve: c.clone(), interval: interval(c), vertices: [k as u32, ((k + 1) % n) as u32] });+ edges.push(PartEdge { curve: moved(c), interval: interval(c), vertices: [(n + k) as u32, (n + (k + 1) % n) as u32] });+ edges.push(PartEdge {+ curve: b::Curve::Line { start: arr(corners[k]), end: arr(corners[k] + drop) },+ interval: [0.0, 1.0],+ vertices: [k as u32, (n + k) as u32],+ });+ }+ let (top_edge, bottom_edge, down) = (|k: usize| 3 * k as u32, |k: usize| 3 * k as u32 + 1, |k: usize| 3 * (k % n) as u32 + 2);+ let mut faces = Vec::new();+ for k in 0..n {+ let (surface, given) = match &top[k] {+ b::Curve::Spline { knots, points } => {+ let rows: Vec<Vec<[f64; 3]>> = points.iter().map(|p| vec![*p, arr(v3(*p) + drop)]).collect();+ let [a, z] = interval(&top[k]);+ let degree = knots.len() - points.len() - 1;+ let greville = |v: f64| -> b::Curve2 {+ let pts = (0..points.len()).map(|i| [(1..=degree).map(|r| knots[i + r]).sum::<f64>() / degree as f64, v]).collect();+ b::Curve2::Spline { knots: knots.clone(), points: pts }+ };+ let ruling = |u: f64| b::Curve2::Spline { knots: vec![0.0, 0.0, 1.0, 1.0], points: vec![[u, 0.0], [u, 1.0]] };+ let surface = b::Surface::Spline { u_knots: knots.clone(), v_knots: vec![0.0, 0.0, 1.0, 1.0], points: rows };+ (surface, Some([greville(0.0), ruling(z), greville(1.0), ruling(a)]))+ }+ _ => {+ let (p, q) = (corners[k], corners[(k + 1) % n]);+ let u = (q - p).normalized().unwrap();+ let w = (drop - u * drop.dot(u)).normalized().unwrap();+ (b::Surface::Plane { origin: arr(p), u_axis: arr(u), v_axis: arr(w) }, None)+ }+ };+ // Round the wall: along the top, down its far side, back along the bottom, up.+ let mut uses = vec![+ PartUse { edge: top_edge(k), forward: true, given: None },+ PartUse { edge: down(k + 1), forward: true, given: None },+ PartUse { edge: bottom_edge(k), forward: false, given: None },+ PartUse { edge: down(k), forward: false, given: None },+ ];+ if let Some(given) = given {+ for (u, g) in uses.iter_mut().zip(given) {+ u.given = Some(g);+ }+ }+ faces.push(PartFace { surface, forward: true, loops: vec![uses] });+ }+ let made = assemble(Parts { vertices, edges, faces, tolerance: 1e-6 }, false).unwrap();+ crate::native::body_from_smlib(&solidcraft_smlib::Brep::from_record(&made.brep, true).unwrap()).unwrap()+ }+#[test]fn regular_rims_of_three_to_eight_sides_fill_with_one_face_and_close_the_cup() {for n in 3..=8 {@@ -586,18 +777,15 @@ mod tests {fn a_flat_corner_between_two_edges_is_kept() {// A rim of five straight edges, two of them in line (a 180° corner between them), the// four true corners at different heights; walls hang below it.- let p = |x: f64, y: f64, z: f64| mt::Vertex::new(mt::Point3::new(x, y, z));+ let p = |x: f64, y: f64, z: f64| Vec3::new(x, y, z);let v = [p(-14.0, -14.0, 12.0), p(0.0, -14.0, 12.0), p(14.0, -14.0, 12.0), p(14.0, 14.0, 15.0), p(-14.0, 14.0, 10.0)];- let line = |a: &mt::Vertex, b: &mt::Vertex| mt::Edge::new(a, b, mt::Curve::Line(mt::Line(a.point(), b.point())));- let wire: mt::Wire = (0..5).map(|k| line(&v[k], &v[(k + 1) % 5])).collect::<Vec<_>>().into();- let low = mt::builder::translated(&wire, mt::Vector3::new(0.0, 0.0, -10.0));- let walls = mt::builder::try_wire_homotopy(&wire, &low).unwrap();- let body = crate::surfaces::surface_body(walls.face_iter().cloned().collect());- let rim: Vec<Vec3> = (0..5).map(|k| from_p3(v[k].point()).lerp(from_p3(v[(k + 1) % 5].point()), 0.5)).collect();+ let arr = |q: Vec3| [q.x, q.y, q.z];+ let top: Vec<b::Curve> = (0..5).map(|k| b::Curve::Line { start: arr(v[k]), end: arr(v[(k + 1) % 5]) }).collect();+ let body = walls(&v, &top, Vec3::new(0.0, 0.0, -10.0));+ let rim: Vec<Vec3> = (0..5).map(|k| v[k].lerp(v[(k + 1) % 5], 0.5)).collect();let fill = patch_edges(&body, &rim).unwrap();assert_eq!((fill.face_count(), fill.edge_count()), (1, 5), "one face on all five edges");- let face = fill.solid.face_iter().next().unwrap().clone();- assert!(edges_off_surface(&face) <= super::face_tolerance(&body));+ assert!(edges_off_surface(&fill) <= super::face_tolerance(&body));let area = mesh_is_clean(&fill);eprintln!("flat corner: one face of area {area}");assert!(area > 28.0 * 28.0 * 0.99 && area < 28.0 * 28.0 * 1.05, "{area}");@@ -611,12 +799,13 @@ mod tests {shuffled.rotate_left(3);shuffled.swap(0, 1);let (b, _) = fill_rim(&open, &shuffled);- let (sa, sb) = (a.solid.face_iter().next().unwrap().surface(), b.solid.face_iter().next().unwrap().surface());- let (Some((u0, u1)), Some((v0, v1))) = sa.try_range_tuple() else { panic!() };+ let (ra, rb) = (record(&a), record(&b));+ let (sa, sb) = (SurfaceEval::new(&ra.faces[0].surface).unwrap(), SurfaceEval::new(&rb.faces[0].surface).unwrap());+ let [[u0, u1], [v0, v1]] = ra.faces[0].domain;let mut gap = 0.0f64;for (x, y) in [(0.2, 0.3), (0.5, 0.5), (0.7, 0.9)] {- let (u, v) = (u0 + (u1 - u0) * x, v0 + (v1 - v0) * y);- gap = gap.max(sa.subs(u, v).distance(sb.subs(u, v)));+ let uv = [u0 + (u1 - u0) * x, v0 + (v1 - v0) * y];+ gap = gap.max(sa.point(uv).unwrap().dist(sb.point(uv).unwrap()));}assert!(gap < 1e-7, "pick order moved the surface by {gap}");let (area_a, area_b) = (mesh_is_clean(&a), mesh_is_clean(&b));@@ -661,12 +850,12 @@ mod tests {// The cup's vertices moved 2·10⁻⁵ mm off their curves, as a file might give them.let corners = regular(5, 0.3);let (solid, open, rim) = cup(&corners, Vec2::ZERO);- let shell = open.solid.boundaries()[0].mapped(- |p: &mt::Point3| *p + mt::Vector3::new(2e-5, 0.0, 0.0),- |c: &mt::Curve| c.clone(),- |s: &mt::Surface| s.clone(),- );- let imported = crate::surfaces::surface_body(shell.face_iter().cloned().collect());+ let mut moved = record(&open);+ for v in &mut moved.vertices {+ v.point[0] += 2e-5;+ v.tolerance = v.tolerance.max(1e-4);+ }+ let imported = crate::native::body_from_smlib(&solidcraft_smlib::Brep::from_record(&moved, true).unwrap()).unwrap();let (fill, got) = fill_rim(&imported, &rim);check_volume("imported", &solid, &fill, &corners, got);}@@ -679,26 +868,27 @@ mod tests {// a 32 × 32 grid, and then it is refused.for (spans, raised, must_fill) in [(1, 1, true), (64, 30, false)] {let count = spans + 3;- let pts: Vec<mt::Point3> =- (0..count).map(|i| mt::Point3::new(20.0 * i as f64 / (count - 1) as f64, 0.0, if i == raised { 1.5 } else { 0.0 })).collect();- let spline = mt::BSplineCurve::new(mt::KnotVec::uniform_knot(3, spans), pts);- let v: Vec<mt::Vertex> =- [(0.0, 0.0), (20.0, 0.0), (20.0, 10.0), (0.0, 10.0)].iter().map(|&(x, y)| mt::Vertex::new(mt::Point3::new(x, y, 0.0))).collect();- let line = |a: &mt::Vertex, b: &mt::Vertex| mt::Edge::new(a, b, mt::Curve::Line(mt::Line(a.point(), b.point())));- let bottom = mt::Edge::new(&v[0], &v[1], mt::Curve::BSplineCurve(spline.clone()));- let wire: mt::Wire = vec![bottom, line(&v[1], &v[2]), line(&v[2], &v[3]), line(&v[3], &v[0])].into();- let top = mt::builder::translated(&wire, mt::Vector3::new(0.0, 0.0, -5.0));- let walls = mt::builder::try_wire_homotopy(&wire, &top).unwrap();- let body = crate::surfaces::surface_body(walls.face_iter().cloned().collect());- let peak = from_p3(spline.subs((raised as f64 + 1.0) / (count + 1) as f64));- let rim = [from_p3(spline.subs(0.5)), Vec3::new(20.0, 5.0, 0.0), Vec3::new(10.0, 10.0, 0.0), Vec3::new(0.0, 5.0, 0.0)];+ let points: Vec<[f64; 3]> =+ (0..count).map(|i| [20.0 * i as f64 / (count - 1) as f64, 0.0, if i == raised { 1.5 } else { 0.0 }]).collect();+ // Uniform knots over [0, 1], clamped.+ let mut knots = vec![0.0; 4];+ knots.extend((1..spans).map(|i| i as f64 / spans as f64));+ knots.extend([1.0; 4]);+ let spline = b::Curve::Spline { knots, points };+ let c = CurveEval::new(&spline).unwrap();+ let corners: Vec<Vec3> = [(0.0, 0.0), (20.0, 0.0), (20.0, 10.0), (0.0, 10.0)].iter().map(|&(x, y)| Vec3::new(x, y, 0.0)).collect();+ let line = |a: Vec3, z: Vec3| b::Curve::Line { start: [a.x, a.y, a.z], end: [z.x, z.y, z.z] };+ let top = vec![spline.clone(), line(corners[1], corners[2]), line(corners[2], corners[3]), line(corners[3], corners[0])];+ let body = walls(&corners, &top, Vec3::new(0.0, 0.0, -5.0));+ let peak = c.point((raised as f64 + 1.0) / (count + 1) as f64).unwrap();+ let rim = [c.point(0.5).unwrap(), Vec3::new(20.0, 5.0, 0.0), Vec3::new(10.0, 10.0, 0.0), Vec3::new(0.0, 5.0, 0.0)];match patch_edges(&body, &rim) {Ok(fill) => {- let face = fill.solid.face_iter().next().unwrap().clone();- assert!(!matches!(face.surface(), mt::Surface::Plane(_)), "a plane would miss the bulge");- let (off, tol) = (edges_off_surface(&face), super::face_tolerance(&body));+ let surface = first_surface(&fill);+ assert!(!matches!(surface, b::Surface::Plane { .. }), "a plane would miss the bulge");+ let (off, tol) = (edges_off_surface(&fill), super::face_tolerance(&body));eprintln!("{spans}-span bump: filled, edges within {off:e} of the face");- assert!(off <= tol && to_surface(&face.surface(), p3(peak)) <= tol);+ assert!(off <= tol && to_surface(&surface, peak) <= tol);mesh_is_clean(&fill);}Err(e) => {@@ -711,18 +901,13 @@ mod tests {/// A point on each edge that bounds one face of `body` (its free edges).fn free_edge_points(body: &Body) -> Vec<Vec3> {- let mut uses: std::collections::HashMap<mt::EdgeID, (usize, mt::Edge)> = std::collections::HashMap::new();- for f in body.solid.face_iter() {- for e in f.boundaries().iter().flat_map(|w| w.edge_iter()) {- uses.entry(e.id()).or_insert((0, e.clone())).0 += 1;- }- }- uses.values()- .filter(|(n, _)| *n == 1)- .map(|(_, e)| {- let c = e.curve();- let (t0, t1) = c.range_tuple();- from_p3(c.subs(0.5 * (t0 + t1)))+ let r = record(body);+ r.edges+ .iter()+ .filter(|e| e.uses.len() == 1)+ .map(|e| {+ let [t0, t1] = e.interval;+ CurveEval::new(&e.curve).unwrap().point(0.5 * (t0 + t1)).unwrap()}).collect()}@@ -742,8 +927,7 @@ mod tests {let rim = free_edge_points(&side);let fill = patch_edges(&side, &rim).unwrap();assert_eq!(fill.face_count(), 1, "one face");- let face = fill.solid.face_iter().next().unwrap().clone();- let (off, tol) = (edges_off_surface(&face), super::face_tolerance(&side));+ let (off, tol) = (edges_off_surface(&fill), super::face_tolerance(&side));assert!(off <= tol, "an edge is {off} off the face (tolerance {tol})");// Its area is at least its shadow on the plane x = 0 (the 20 × 20 square the loop bounds// there) and, a least-bending fill, no more than the half side it spans.@@ -776,7 +960,7 @@ mod tests {let lid = patch_edges(&open, &rim).unwrap();assert_eq!(lid.face_count(), 1);let edges = lid.edge_count();- assert!(matches!(lid.solid.face_iter().next().unwrap().surface(), mt::Surface::Plane(_)), "tilt {tilt:?}");+ assert!(matches!(first_surface(&lid), b::Surface::Plane { .. }), "tilt {tilt:?}");let closed = stitch(&[&open, &lid], 0.0).unwrap();assert!(!closed.is_surface());let (want, got) = (measure(&solid).unwrap().volume, measure(&closed).unwrap().volume);@@ -796,7 +980,7 @@ mod tests {let rim = [Vec3::new(5.0, 0.0, 10.0), Vec3::new(10.0, 5.0, 10.0), Vec3::new(5.0, 10.0, 10.0), Vec3::new(0.0, 5.0, 10.0)];let lid = patch_edges(&open, &rim).unwrap();assert_eq!(lid.face_count(), 1);- assert!(matches!(lid.solid.face_iter().next().unwrap().surface(), mt::Surface::Plane(_)));+ assert!(matches!(first_surface(&lid), b::Surface::Plane { .. }));let closed = stitch(&[&open, &lid], 0.0).unwrap();assert!((measure(&closed).unwrap().volume - 1000.0).abs() < 1e-9);}@@ -824,21 +1008,19 @@ mod tests {for crown in [0.25, -0.25] {let full = patch_edges_crowned(&open, &rim, crown).unwrap();assert_eq!(full.face_count(), 1, "one face");- let face = full.solid.face_iter().next().unwrap().clone();- assert!(!matches!(face.surface(), mt::Surface::Plane(_)));- let own: Vec<mt::EdgeID> = open.solid.edge_iter().map(|e| e.id()).collect();- assert!(full.solid.edge_iter().all(|e| own.contains(&e.id())), "an edge that is not the body's");+ assert!(!matches!(first_surface(&full), b::Surface::Plane { .. }));+ assert!(own_edges(&full, &open), "an edge that is not the body's");// The loop's edges are within the fill's tolerance of the face, as for the plain fill.- let off = edges_off_surface(&face);+ let off = edges_off_surface(&full);assert!(off <= super::face_tolerance(&open), "an edge is {off} off the crowned face");mesh_is_clean(&full);// The middle of the loop's box moved by crown × its diagonal (the bump is 1 there).- let a = plain.solid.face_iter().next().unwrap().surface();- let b = face.surface();- let (Some((bu0, bu1)), Some((bv0, bv1))) = a.try_range_tuple() else { panic!("a bounded surface") };+ let (ra, rb) = (record(&plain), record(&full));+ let (a, b) = (SurfaceEval::new(&ra.faces[0].surface).unwrap(), SurfaceEval::new(&rb.faces[0].surface).unwrap());+ let [[bu0, bu1], [bv0, bv1]] = ra.faces[0].domain;let (uc, vc) = ((bu0 + bu1) / 2.0, (bv0 + bv1) / 2.0);let size = (bu1 - bu0).hypot(bv1 - bv0);- let bump = a.subs(uc, vc).distance(b.subs(uc, vc));+ let bump = a.point([uc, vc]).unwrap().dist(b.point([uc, vc]).unwrap());let want = (crown * size).abs();eprintln!("crown {crown}: the middle moved {bump:.6}, wanted {want:.6}");assert!((bump - want).abs() < 1e-6 * size, "middle {bump} against {want}");@@ -852,7 +1034,7 @@ mod tests {.unwrap();let rim = [Vec3::new(5.0, 0.0, 10.0), Vec3::new(10.0, 5.0, 10.0), Vec3::new(5.0, 10.0, 10.0), Vec3::new(0.0, 5.0, 10.0)];let lid = patch_edges_crowned(&open, &rim, 1.0).unwrap();- assert!(matches!(lid.solid.face_iter().next().unwrap().surface(), mt::Surface::Plane(_)), "a planar loop is a plane");+ assert!(matches!(first_surface(&lid), b::Surface::Plane { .. }), "a planar loop is a plane");// Hostile crowns are refused before anything is built.for crown in [f64::NAN, f64::INFINITY, 3.01, -0.91, 1e300] {assert!(patch_edges_crowned(&open, &rim, crown).is_err(), "crown {crown}");