diff --git a/crates/kernel/src/fill.rs b/crates/kernel/src/fill.rs index 7e946ea0b..166d5e100 100644 --- a/crates/kernel/src/fill.rs +++ b/crates/kernel/src/fill.rs @@ -5,15 +5,18 @@ //! 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`. +//! The general fill, which also meets the faces beside the loop with G1 or G2, passes through +//! given points, and fills loops that bound no height field, is a patch whose boundary rows are +//! the loop's own edges (`solidcraft_geom::fill_iso`): each edge's pcurve is a straight line in +//! (u, v). It takes loops of three or four line or spline edges; the frames across each edge are +//! read off the neighbouring face's record surface (exact second derivatives for G2). use solidcraft_geom::Vec3; +use solidcraft_geom::brep::eval::SurfaceEval; 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 solidcraft_geom::fill_general::{Across, MAX_FILL_POINTS}; +use solidcraft_geom::fill_iso::{IsoEdge, IsoSpec}; use crate::body::Body; use crate::bridge::Continuity; @@ -110,14 +113,217 @@ 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")?; - Err(general_fill_unported()) + let record = crate::native::brep_record(body)?; + let chain = picked_loop(&record, at, body.size() * 0.05 + 1e-6)?; + let mut orders = vec![spec.continuity; chain.len()]; + for (p, g) in &spec.edges { + let e = nearest_edge(&record, *p, body.size() * 0.05 + 1e-6).ok_or_else(|| KernelError::Invalid(format!("no edge at {p:?}")))?; + let k = chain.iter().position(|c| c.0 == e).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; + } + } + 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())); + } + general_fill(body, &record, &chain, &orders, &spec.points, spec.crown) } -/// 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(), - ) +/// The general fill of the loop `chain` of the record's edges, edge `k` meeting the face beside it +/// with `orders[k]` (module docs). +fn general_fill( + body: &Body, + record: &b::Brep, + chain: &[(usize, bool)], + orders: &[Continuity], + points: &[Vec3], + crown: f64, +) -> Result<(Body, PatchReport)> { + if !(3..=4).contains(&chain.len()) { + return Err(KernelError::Invalid(format!("not supported yet: a general patch on a loop of {} edges (three or four)", chain.len()))); + } + let edges: Vec = chain.iter().map(|&(e, forward)| iso_edge(record, e, forward)).collect::>()?; + let size = body.size().max(solidcraft_geom::LINEAR_TOL); + let mut beside: Vec> = Vec::with_capacity(chain.len()); + for (&(e, forward), order) in chain.iter().zip(orders) { + beside.push(if *order == Continuity::G0 { None } else { Some(Beside::new(record, e, forward, *order == Continuity::G2, size)?) }); + } + // Where a G1/G2 edge's neighbour and the one before disagree at their corner. + let n = chain.len(); + let mut clash = vec![false; n]; + for k in 0..n { + let prev = (k + n - 1) % n; + let (Some(Some(a)), Some(Some(b))) = (beside.get(prev), beside.get(k)) else { continue }; + let (Some(ea), Some(eb)) = (edges.get(prev), edges.get(k)) else { continue }; + let (end, start) = (ea.knots.last().copied().unwrap_or(0.0), eb.knots.first().copied().unwrap_or(0.0)); + if let (Some(x), Some(y)) = (a.across(record, end)?, b.across(record, start)?) { + clash[k] = x.normal.dot(y.normal).abs() < (2.0 * PATCH_ANGLE_TOL_DEG).to_radians().cos(); + } + } + let mut across = |k: usize, ts: &[f64]| -> std::result::Result>, String> { + match beside.get(k) { + None => Err("no such edge".into()), + Some(None) => Ok(vec![None; ts.len()]), + Some(Some(side)) => ts.iter().map(|t| side.across(record, *t).map_err(|e| e.to_string())).collect(), + } + }; + let spec = IsoSpec { tol: face_tolerance(body), angle_tol: PATCH_ANGLE_TOL_DEG.to_radians(), crown, points }; + let fill = solidcraft_geom::fill_iso::iso_fill(&edges, &mut across, &clash, &spec).map_err(spline_error)?; + let surface = surface_record(&fill.surface)?; + let made = patch_body(body, record, chain, surface, true, &Pcurves::Sides(&fill.sides), face_tolerance(body))?; + let a = fill.achieved; + let report = PatchReport { + general: true, + gap: 0.0, + normal_deviation_deg: a.normal_deviation.to_degrees(), + normal_deviation_all_deg: a.normal_deviation_all.to_degrees(), + curvature_mismatch: a.curvature_mismatch, + point_gap: a.point_deviation, + }; + Ok((made, report)) +} + +/// A loop edge as the patch takes it: a non-rational B-spline on the edge's interval, running +/// the loop's way, its ends on the edge's vertices. Conics and traced curves have no such form +/// in their own parameter (an arc's angle is no rational function of a NURBS parameter), and a +/// rational edge none the Coons sum can blend: refused by name. +fn iso_edge(record: &b::Brep, e: usize, forward: bool) -> Result { + let edge = record.edges.get(e).ok_or_else(|| KernelError::Failed("patch: edge reference".into()))?; + let v3 = |p: &[f64; 3]| Vec3::new(p[0], p[1], p[2]); + let [a, z] = edge.interval; + let (degree, knots, points): (usize, Vec, Vec) = match &edge.curve { + b::Curve::Line { start, end } => { + let (s, t) = (v3(start), v3(end)); + (1, vec![a, a, z, z], vec![s + (t - s) * a, s + (t - s) * z]) + } + 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(v3).collect()) + } + b::Curve::Spline { knots, points } => (knots.len().saturating_sub(points.len() + 1), knots.clone(), points.iter().map(v3).collect()), + b::Curve::RationalSpline { knots, homogeneous } if homogeneous.windows(2).all(|w| w[0][3] == w[1][3]) => ( + knots.len().saturating_sub(homogeneous.len() + 1), + knots.clone(), + homogeneous.iter().map(|h| Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3])).collect(), + ), + _ => { + return Err(KernelError::Invalid(format!( + "not supported yet: a general patch on edge {e}, a circle, ellipse, rational or traced curve (its pcurve on the patch has no exact form in its own parameter)" + ))); + } + }; + // The piece on the edge's interval, then run the loop's way. + let h: Vec = points.iter().map(|p| HPoint::weighted(*p, 1.0)).collect(); + let (mut knots, h) = solidcraft_geom::bspline::segment(degree, &knots, &h, a, z).map_err(spline_error)?; + let mut points: Vec = h.iter().map(|p| p.xyz()).collect(); + if !forward { + knots = knots.iter().rev().map(|k| a + z - k).collect(); + points.reverse(); + } + // Its ends exactly on the loop's vertices. + let vertex = |end: usize| record.vertices.get(edge.vertices[end] as usize).map(|v| v3(&v.point)); + let (first, last) = if forward { (vertex(0), vertex(1)) } else { (vertex(1), vertex(0)) }; + if let (Some(p), Some(q), Some(f)) = (first, last, points.first_mut()) { + *f = p; + if let Some(l) = points.last_mut() { + *l = q; + } + } + Ok(IsoEdge { degree, knots, points }) +} + +/// The face beside a G1/G2 edge, read at points of the edge: its record surface, which side of +/// it is outward, whether its boundary runs the edge the loop's way, and whether its curvature +/// is read (G2). +struct Beside { + surface: SurfaceEval, + side: f64, + along: bool, + edge: usize, + forward: bool, + curvature: bool, + reach: f64, +} + +impl Beside { + fn new(record: &b::Brep, e: usize, forward: bool, curvature: bool, size: f64) -> Result { + let edge = record.edges.get(e).ok_or_else(|| KernelError::Failed("patch: edge reference".into()))?; + let [u] = edge.uses.as_slice() else { + return Err(KernelError::Invalid("an edge of the loop lies between two faces: g1 and g2 need the one face beside it".into())); + }; + let face = record.faces.get(u.face as usize).ok_or_else(|| KernelError::Failed("patch: face reference".into()))?; + let surface = + SurfaceEval::new(&face.surface).map_err(|err| KernelError::Invalid(format!("the face beside edge {e} cannot be evaluated: {err}")))?; + let outward = record + .shells + .iter() + .find_map(|s| match s { + b::Shell::Faces { faces, .. } => faces.iter().find(|f| f.face == u.face).map(|f| f.forward), + _ => None, + }) + .unwrap_or(true); + let used_forward = match face.loops.get(u.r#loop as usize) { + Some(b::Loop::Edges { edges }) => edges.get(u.position as usize).map(|x| x.forward), + _ => None, + } + .ok_or_else(|| KernelError::Failed("patch: edge use".into()))?; + // A face's boundary runs counter-clockwise about its outward normal: the record's loops + // run so about the natural normal, reversed where the outward side is the other. + let runs_forward = used_forward == outward; + Ok(Beside { + surface, + side: if outward { 1.0 } else { -1.0 }, + along: runs_forward == forward, + edge: e, + forward, + curvature, + reach: (size * 1e-4).max(1e-6), + }) + } + + /// The neighbour's conditions at parameter `t` of the loop's edge (its `IsoEdge`, run the + /// loop's way, whose parameter is the edge's reversed where the loop runs against it): + /// its normal, the direction it leaves the edge in, away from it, and for G2 its curvature + /// vector along that direction. `None` where the edge has no tangent there. + fn across(&self, record: &b::Brep, t: f64) -> Result> { + let edge = record.edges.get(self.edge).ok_or_else(|| KernelError::Failed("patch: edge reference".into()))?; + let [a, z] = edge.interval; + let tau = if self.forward { t } else { a + z - t }; + let curve = CurveEval::new(&edge.curve).map_err(|e| KernelError::Invalid(e.to_string()))?; + let Some((p, d)) = curve.derivs(tau) else { return Ok(None) }; + let Some(tangent) = (d * if self.forward { 1.0 } else { -1.0 }).normalized() else { return Ok(None) }; + let uv = + self.surface.project(p, None, self.reach).ok_or_else(|| KernelError::Invalid("a picked edge is not on the face beside it".into()))?; + let (_, su, sv) = + self.surface.derivs(uv[0], uv[1]).ok_or_else(|| KernelError::Failed("patch: the face beside an edge has no derivatives".into()))?; + let normal = + (su.cross(sv) * self.side).normalized().ok_or_else(|| KernelError::Failed("patch: the face beside an edge has no normal".into()))?; + // Away from the face: its boundary's direction × its outward normal. + let boundary = if self.along { tangent } else { tangent * -1.0 }; + let leave = boundary.cross(normal).normalized().ok_or_else(|| KernelError::Invalid("the boundary runs along the face's normal".into()))?; + let bend = if self.curvature { Some(normal * normal_curvature(&self.surface, uv, normal, leave)?) } else { None }; + Ok(Some(Across { leave, normal, bend })) + } +} + +/// The normal curvature of a surface at `uv` along the unit tangent `w`: `n·r''` of the unit-speed +/// curve on it leaving that way (the second fundamental form, exact second derivatives). +fn normal_curvature(s: &SurfaceEval, uv: [f64; 2], n: Vec3, w: Vec3) -> Result { + let fail = || KernelError::Failed("patch: the face beside an edge has no curvature there".into()); + let (_, ru, rv) = s.derivs(uv[0], uv[1]).ok_or_else(fail)?; + let (ruu, ruv, rvv) = s.second(uv[0], uv[1]).ok_or_else(fail)?; + // w = ru·α + rv·β, solved in the tangent plane. + let (e, f, g) = (ru.dot(ru), ru.dot(rv), rv.dot(rv)); + let det = e * g - f * f; + if !(det > 0.0) { + return Err(fail()); + } + let (wu, wv) = (w.dot(ru), w.dot(rv)); + let (alpha, beta) = ((g * wu - f * wv) / det, (e * wv - f * wu) / det); + let k = n.dot(ruu * (alpha * alpha) + ruv * (2.0 * alpha * beta) + rvv * (beta * beta)); + k.is_finite().then_some(k).ok_or_else(fail) } /// [`crate::patch_edges`] with a crown on the fitted face: positive makes the patch's middle @@ -156,14 +362,23 @@ pub(crate) fn patch_loop(body: &Body, at: &[Vec3], crown: f64) -> Result { 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()), + // Not a height field over its plane: the general fill, 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, &record, &chain, &orders, &[], 0.0).map(|(b, _)| b); + } 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)) } }; - patch_body(body, &record, &chain, surface, ccw, pcurve.as_ref(), face_tolerance(body)) + let pcurves = match &pcurve { + Some(p) => Pcurves::Projected(p), + None => Pcurves::Computed, + }; + patch_body(body, &record, &chain, surface, ccw, &pcurves, face_tolerance(body)) } /// The closed loop of `record`'s edges picked by points on them (the edge nearest each, within @@ -321,6 +536,14 @@ fn conic_on(frame: &b::Frame, radii: [f64; 2], on: &dyn Fn([f64; 3]) -> bool, n: on(frame.origin) && radii[0] * axis(frame.x_axis) + radii[1] * axis(frame.y_axis) <= tol } +/// Where a patch's pcurves come from: the record's routine (a plane), the exact projection onto +/// a height field's plane, or the patch's own sides (each edge a straight line in (u, v)). +enum Pcurves<'a> { + Computed, + Projected(&'a Projection), + Sides(&'a [[[f64; 2]; 2]]), +} + /// The plane a height field stands on: its parameters are coordinates along `axes` from `origin`. struct Projection { origin: Vec3, @@ -389,15 +612,7 @@ fn surface_record(s: &solidcraft_geom::bspline::NurbsSurface) -> Result, - tol: f64, -) -> Result { +fn patch_body(body: &Body, record: &b::Brep, chain: &[(usize, bool)], surface: b::Surface, ccw: bool, pcurves: &Pcurves, tol: f64) -> Result { let fail = |m: &str| KernelError::Failed(format!("patch: {m}")); let mut vertices: Vec<[f64; 3]> = Vec::new(); let mut vertex_of: std::collections::HashMap = std::collections::HashMap::new(); @@ -413,13 +628,20 @@ fn patch_body( 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(|| { + let given = match pcurves { + Pcurves::Sides(sides) => { + let [s, z] = sides.get(k).copied().ok_or_else(|| fail("side"))?; + let [a, b] = edge.interval; + // The loop's start of the edge is its interval's start when the loop runs along it. + let (at_a, at_b) = if forward { (s, z) } else { (z, s) }; + Some(Curve2::Spline { knots: vec![a, a, b, b], points: vec![at_a, at_b] }) + } + Pcurves::Projected(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, + Pcurves::Computed => None, }; edges.push(PartEdge { curve: edge.curve.clone(), interval: edge.interval, vertices: ends }); uses.push(PartUse { edge: k as u32, forward, given });