SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 126/509: kernel: the rolling-ball, corner, loop and vertex blend builders are gone
jyviko6a7581deaae1
diff --git a/crates/kernel/src/blend.rs b/crates/kernel/src/blend.rsindex accaa4860e..43b51b00eb 100644--- a/crates/kernel/src/blend.rs+++ b/crates/kernel/src/blend.rs@@ -769,3 +769,7 @@ mod tests {assert!(out.validity().is_empty(), "{:?}", out.validity());}}++#[cfg(test)]+#[path = "curvecorner_tests.rs"]+mod corner_tests;diff --git a/crates/kernel/src/blend_vertex.rs b/crates/kernel/src/blend_vertex.rsdeleted file mode 100644index 018cf5c920..0000000000--- a/crates/kernel/src/blend_vertex.rs+++ /dev/null@@ -1,404 +0,0 @@-//! Fillets of the three edges at a convex vertex of any smooth faces, of one radius: the rounds-//! end in a piece of sphere, as they do at the corner of a box.-//!-//! The ball of the fillets' radius that touches the three faces there (its centre `c`, its-//! contacts `q`) ends each round: round `k` stops at the circle where the ball meets the plane-//! through `c` and the contacts of its two faces, and the sphere's patch joins the three circles.-//! The construction uses only what a round with a plane end does already:-//! 1. cut off the corner beyond the three planes (a skewed box whose three faces are those-//! planes), so each of the three edges ends square on a plane face;-//! 2. round the three edges one after another, each ending in its plane face, which a round's-//! end arc and the sides it uses up reduce to a quarter disc of the ball's section;-//! 3. replace the three quarter discs, which meet along radii at `c`, by the sphere's patch,-//! which has the three end arcs for its boundary.--use std::collections::{HashMap, HashSet};--use solidcraft_geom::Vec3;-use truck_modeling::{self as mt};--use crate::blend::{edge_mid, too_large, unsupported, vtx};-use crate::body::{Body, Solid, from_p3, p3, v3};-use crate::curveblend::project;-use crate::record;-use crate::{BoolOp, KernelError, Result};--/// Round the edges nearest the points, `radius` each. The three edges meeting at a vertex that-/// all lie among them end in a sphere; the others are rounded as they would be alone.-pub(crate) fn fillet_ball_vertices(body: &Body, edges: &[Vec3], radius: f64) -> Result<Body> {- body.require_brep("fillet")?;- if !(radius.is_finite() && radius > 1e-6 && radius < 1e6) {- return Err(KernelError::Invalid("fillet size must be positive".into()));- }- if edges.len() < 3 {- return Err(unsupported("a vertex with three rounded edges"));- }- let counts = record::counts(&[body]);- let mut cur = crate::boolean_record::healed(body)?;- let mut todo: Vec<Vec3> = edges.to_vec();- let mut done = false;- while let Some((at, picks)) = find_vertex(&cur, &todo)? {- let next = round_vertex(&cur, at, radius)?;- cur = record::after(next, &cur, &counts);- todo.retain(|p| !picks.iter().any(|q| q.dist(*p) < 1e-12));- done = true;- }- if !done {- return Err(unsupported("a vertex with three rounded edges"));- }- if todo.is_empty() { Ok(cur) } else { crate::blend::fillet(&cur, &todo, radius) }-}--/// A vertex of three edges all among the picked ones (its position) and their picks.-fn find_vertex(cur: &Body, picks: &[Vec3]) -> Result<Option<(Vec3, Vec<Vec3>)>> {- let size = cur.size();- let tol = (size * 2e-3).max(1e-3);- let solid = cur.deep_copy();- let all = Body::unique_edges(&solid);- // The picked edges, by identity, with the pick each came from.- let mut picked: Vec<(mt::EdgeID, Vec3)> = Vec::new();- for p in picks {- let Some((idx, dist)) = cur.nearest_edge(*p, tol)? else { return Ok(None) };- if dist > size * 0.05 + 1e-3 {- return Err(KernelError::Invalid(format!("no edge near {:?}", [p.x, p.y, p.z])));- }- if let Some(e) = all.get(idx)- && !picked.iter().any(|(id, _)| *id == e.id())- {- picked.push((e.id(), *p));- }- }- let mut at_vertex: HashMap<mt::VertexID, Vec<(mt::EdgeID, Vec3)>> = HashMap::new();- for e in &all {- let Some((_, p)) = picked.iter().find(|(id, _)| *id == e.id()) else { continue };- for v in [e.absolute_front(), e.absolute_back()] {- at_vertex.entry(v.id()).or_default().push((e.id(), *p));- }- }- for (vid, list) in at_vertex {- let degree = all.iter().filter(|e| e.absolute_front().id() == vid || e.absolute_back().id() == vid).count();- if list.len() == 3 && degree == 3 {- let v = all.iter().find_map(|e| [e.absolute_front(), e.absolute_back()].into_iter().find(|v| v.id() == vid));- if let Some(v) = v {- return Ok(Some((vtx(v), list.iter().map(|(_, p)| *p).collect())));- }- }- }- Ok(None)-}--/// The ball touching three faces from inside, near the corner `v`: its centre and contacts.-struct Ball {- c: Vec3,- /// Contact with each face, and the face's outward normal there.- q: [Vec3; 3],-}--fn ball_at(faces: &[&mt::Face; 3], v: Vec3, r: f64, tol: f64) -> Result<Ball> {- let rows = |n: [Vec3; 3]| [[n[0].x, n[0].y, n[0].z], [n[1].x, n[1].y, n[1].z], [n[2].x, n[2].y, n[2].z]];- let near = |p: Vec3, hint: &mut [Option<(f64, f64)>; 3]| -> Option<([Vec3; 3], [Vec3; 3])> {- let mut q = [Vec3::ZERO; 3];- let mut n = [Vec3::ZERO; 3];- for (i, f) in faces.iter().enumerate() {- let (qi, ni, uv) = project(f, p, hint[i])?;- (q[i], n[i], hint[i]) = (qi, ni, Some(uv));- }- Some((q, n))- };- let mut hint = [None; 3];- let (_, n0) = near(v, &mut hint).ok_or_else(|| unsupported("the faces at the vertex"))?;- // The planes' ball first: each face r inside its tangent plane at the vertex.- let x = crate::polyhedron::solve3_pub(rows(n0), [-r, -r, -r]).ok_or_else(|| unsupported("a vertex whose faces do not meet in a corner"))?;- let mut c = v + Vec3::new(x[0], x[1], x[2]);- for _ in 0..60 {- let (q, n) = near(c, &mut hint).ok_or_else(|| unsupported("the ball at the vertex"))?;- let g = [(c - q[0]).dot(n[0]) + r, (c - q[1]).dot(n[1]) + r, (c - q[2]).dot(n[2]) + r];- let d = crate::polyhedron::solve3_pub(rows(n), [-g[0], -g[1], -g[2]])- .ok_or_else(|| unsupported("a vertex whose faces do not meet in a corner"))?;- let dc = Vec3::new(d[0], d[1], d[2]);- c += dc;- if !c.is_finite() {- break;- }- if dc.len() < tol * 1e-3 && g.iter().all(|x| x.abs() < tol) {- let (q, n) = near(c, &mut hint).ok_or_else(|| unsupported("the ball at the vertex"))?;- // A convex corner: the vertex lies out from every face the ball touches.- if n.iter().any(|ni| (v - c).dot(*ni) < 0.25 * r) {- return Err(unsupported("rounds at a corner that is not convex"));- }- return Ok(Ball { c, q });- }- }- Err(unsupported("the ball does not fit at the vertex"))-}--/// Round the three edges at the vertex at `at`, ending in a sphere.-fn round_vertex(cur: &Body, at: Vec3, r: f64) -> Result<Body> {- let size = cur.size();- let tol = (size * 1e-7).max(1e-9);- let solid = cur.deep_copy();- let all = Body::unique_edges(&solid);- let face_list: Vec<&mt::Face> = solid.face_iter().collect();- // The vertex, its three edges and the faces between them.- let v = all- .iter()- .flat_map(|e| [e.absolute_front().clone(), e.absolute_back().clone()])- .find(|v| vtx(v).dist(at) <= size * 1e-9 + 1e-12)- .ok_or_else(|| KernelError::Failed("fillet vertex".into()))?;- let edges: Vec<mt::Edge> = all.iter().filter(|e| *e.absolute_front() == v || *e.absolute_back() == v).cloned().collect();- let faces_of = |e: &mt::Edge| -> Vec<usize> {- (0..face_list.len()).filter(|i| face_list.get(*i).is_some_and(|f| f.edge_iter().any(|x| x.id() == e.id()))).collect()- };- let mut around: Vec<usize> = Vec::new();- for e in &edges {- for f in faces_of(e) {- if !around.contains(&f) {- around.push(f);- }- }- }- let [fa, fb, fc] = around[..] else { return Err(unsupported("a vertex of three faces")) };- let (Some(a), Some(b), Some(c)) = (face_list.get(fa), face_list.get(fb), face_list.get(fc)) else {- return Err(KernelError::Failed("faces".into()));- };- let faces = [*a, *b, *c];- let ball = ball_at(&faces, vtx(&v), r, tol * 100.0)?;- // The plane of each edge's end: through the centre and the contacts of the edge's two faces,- // its normal out toward the vertex.- let mut normals: Vec<Vec3> = Vec::with_capacity(3);- for e in &edges {- let sides: Vec<usize> = faces_of(e).iter().filter_map(|f| around.iter().position(|x| x == f)).collect();- let [i, j] = sides[..] else { return Err(unsupported("an edge not between two faces")) };- let (Some(qi), Some(qj)) = (ball.q.get(i), ball.q.get(j)) else { return Err(KernelError::Failed("contacts".into())) };- let m = (*qi - ball.c).cross(*qj - ball.c).normalized().ok_or_else(|| unsupported("a ball that touches an edge's faces at one point"))?;- normals.push(if m.dot(vtx(&v) - ball.c) < 0.0 { -m } else { m });- }- let [m0, m1, m2] = normals[..] else { return Err(KernelError::Failed("planes".into())) };- // The corner beyond the three planes, a skewed box from the centre along the three lines- // where two of the planes meet, long enough to hold the corner of the body.- let gen_ = |x: Vec3, y: Vec3, toward: Vec3| -> Result<Vec3> {- let g = x.cross(y).normalized().ok_or_else(|| unsupported("planes that do not meet in a corner"))?;- Ok(if g.dot(toward) < 0.0 { -g } else { g })- };- let reach = 3.0 * (vtx(&v).dist(ball.c) + r);- let (g0, g1, g2) = (gen_(m1, m2, m0)? * reach, gen_(m2, m0, m1)? * reach, gen_(m0, m1, m2)? * reach);- let unit = crate::build::box_solid(Vec3::ZERO, Vec3::new(1.0, 1.0, 1.0))?;- let m = [[g0.x, g0.y, g0.z, 0.0], [g1.x, g1.y, g1.z, 0.0], [g2.x, g2.y, g2.z, 0.0], [ball.c.x, ball.c.y, ball.c.z, 1.0]];- let cutter = crate::ops::transform_matrix(&unit, m)?;- let notched = crate::ops::boolean(cur, &cutter, BoolOp::Cut)?.ok_or_else(|| unsupported("a corner this small"))?;- // The cut splits a curved face along the trace of its plane (the whole way across, not just- // where the plane cuts): the pieces are one face again.- let notched = crate::guard("merge split faces", || merge_split_faces(¬ched, cur, size))?;- // A point on what is left of each edge, half way from where its plane crosses it to its far end.- let mut picks: Vec<Vec3> = Vec::with_capacity(3);- for (e, m) in edges.iter().zip(&normals) {- picks.push(remaining_pick(e, &v, ball.c, *m)?);- }- // Round them one after another, in an order that works.- let mut last: Option<KernelError> = None;- for order in [[0usize, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]] {- let mut step = notched.clone();- let mut ok = true;- for k in order {- let Some(p) = picks.get(k) else { return Err(KernelError::Failed("pick".into())) };- match crate::blend::fillet(&step, &[*p], r) {- Ok(b) => step = b,- Err(e) => {- last = Some(e);- ok = false;- break;- }- }- }- if ok {- return close_with_sphere(&step, &ball, [m0, m1, m2], r, vtx(&v));- }- }- Err(last.unwrap_or_else(|| unsupported("the three rounds at a vertex")))-}--/// A point on edge `e` between where the plane (through `c`, normal `m`) crosses it and its far-/// end (the end that is not `v`).-fn remaining_pick(e: &mt::Edge, v: &mt::Vertex, c: Vec3, m: Vec3) -> Result<Vec3> {- use mt::{BoundedCurve, ParametricCurve};- let curve = e.curve();- let (lo, hi) = curve.range_tuple();- // From the end at the vertex (outside the plane's far side) to the far end.- let (near, far) = if e.absolute_front() == v { (lo, hi) } else { (hi, lo) };- let side = |t: f64| (from_p3(curve.subs(t)) - c).dot(m);- let (mut a, mut b) = (near, far);- if !(side(a) > 0.0 && side(b) < 0.0) {- return Err(too_large("the blend is larger than the neighbouring faces"));- }- for _ in 0..80 {- let mid = 0.5 * (a + b);- if side(mid) > 0.0 { a = mid } else { b = mid }- }- Ok(from_p3(curve.subs(0.5 * (0.5 * (a + b) + far))))-}--/// `step` has the three rounds ending in three quarter discs; the sphere's patch takes their place.-fn close_with_sphere(step: &Body, ball: &Ball, planes: [Vec3; 3], r: f64, v: Vec3) -> Result<Body> {- let size = step.size();- let on_tol = (size * 1e-6).max(1e-9);- let solid = step.deep_copy();- let faces: Vec<mt::Face> = solid.face_iter().cloned().collect();- // The face in each plane: a plane face through the centre.- let mut discs: Vec<usize> = Vec::new();- for m in planes {- let found = faces.iter().position(|f| {- crate::blend::plane_normal(f).is_some_and(|n| n.dot(m).abs() > 1.0 - 1e-9)- && f.vertex_iter().next().is_some_and(|p| (vtx(&p) - ball.c).dot(m).abs() <= on_tol * 10.0)- && f.vertex_iter().any(|p| vtx(&p).dist(ball.c) <= on_tol * 10.0)- });- let Some(i) = found else { return Err(unsupported("the ends of the three rounds")) };- discs.push(i);- }- // The arc of each: its one edge that is not a straight line.- let mut arcs: Vec<mt::Edge> = Vec::with_capacity(3);- for i in &discs {- let f = faces.get(*i).ok_or_else(|| KernelError::Failed("face".into()))?;- let curved: Vec<mt::Edge> = f.edge_iter().filter(|e| !matches!(e.curve(), mt::Curve::Line(_))).collect();- let [arc] = &curved[..] else { return Err(unsupported("the ends of the three rounds")) };- arcs.push(arc.absolute_clone());- }- // The three arcs in a loop.- let first_arc = arcs.first().cloned().ok_or_else(|| KernelError::Failed("arc".into()))?;- let mut used: HashSet<mt::EdgeID> = HashSet::from([first_arc.id()]);- let mut wire: Vec<mt::Edge> = vec![first_arc];- for _ in 0..2 {- let end = wire.last().map(|e| e.back().clone()).ok_or_else(|| KernelError::Failed("arc".into()))?;- let next = arcs- .iter()- .find(|a| !used.contains(&a.id()) && (*a.front() == end || *a.back() == end))- .ok_or_else(|| unsupported("the ends of the three rounds"))?;- used.insert(next.id());- wire.push(if *next.front() == end { next.clone() } else { next.inverse() });- }- if wire.last().map(|e| e.back().clone()) != wire.first().map(|e| e.front().clone()) {- return Err(unsupported("the ends of the three rounds"));- }- // A sphere about the centre, its poles and seam away from the patch.- let out = (v - ball.c).normalized().ok_or_else(|| KernelError::Failed("sphere".into()))?;- let side = out.any_perp();- let (np, sp, back) = (ball.c + side * r, ball.c - side * r, ball.c - out * r);- let meridian = mt::builder::circle_arc(&mt::builder::vertex(p3(np)), &mt::builder::vertex(p3(sp)), p3(back));- let mut surf =- mt::Surface::RevolutedCurve(mt::Processor::new(mt::RevolutedCurve::by_revolution(meridian.oriented_curve(), p3(ball.c), v3(side))));- {- use mt::{ParametricSurface3D, SearchNearestParameter};- if let Some((u, w)) = surf.search_nearest_parameter(p3(ball.c + out * r), None, 100) {- let n = surf.normal(u, w);- if Vec3::new(n.x, n.y, n.z).dot(out) < 0.0 {- surf = mt::Invertible::inverse(&surf);- }- }- }- // The patch runs each arc opposite to the round that ends on it.- let rest: Vec<&mt::Face> = faces.iter().enumerate().filter(|(i, _)| !discs.contains(i)).map(|(_, f)| f).collect();- let uses = |id: mt::EdgeID| {- rest.iter().find_map(|f| {- f.boundaries().iter().flat_map(|w| w.edge_iter().cloned().collect::<Vec<_>>()).find(|x| x.id() == id).map(|x| x.front().id())- })- };- if let (Some(first), Some(front)) = (wire.first(), wire.first().and_then(|e| uses(e.id())))- && front == first.front().id()- {- wire = wire.iter().rev().map(|e| e.inverse()).collect();- }- let patch = mt::Face::try_new(vec![mt::Wire::from(wire)], surf).map_err(|e| KernelError::Failed(format!("sphere patch: {e}")))?;- let mut new_faces: Vec<mt::Face> = rest.into_iter().cloned().collect();- new_faces.push(patch);- let mut shells = solid.boundaries().clone();- let si = shells.iter().position(|sh| sh.face_iter().any(|f| discs.iter().any(|i| faces.get(*i).is_some_and(|d| d.id() == f.id())))).unwrap_or(0);- if let Some(sh) = shells.get_mut(si) {- *sh = new_faces.into();- }- let out: Solid = Solid::try_new(shells).map_err(|e| KernelError::Failed(format!("rounds ending in a sphere: {e}")))?;- record::rebuilt(out, &[&step.solid], &record::Rebuild::default())-}--/// `body` with the curved faces that are pieces of one input face (as the cut that made `body`-/// recorded them) joined again: the edges two pieces share go, the rest make the one boundary.-fn merge_split_faces(body: &Body, source: &Body, size: f64) -> Result<Body> {- let tol = (size * 1e-6).max(1e-9);- let Some(history) = body.history() else { return Ok(body.clone()) };- let solid = body.deep_copy();- let faces: Vec<mt::Face> = solid.face_iter().cloned().collect();- if history.faces.len() != faces.len() {- return Ok(body.clone());- }- let on = |a: &mt::Face, p: Vec3| project(a, p, None).is_some_and(|(q, _, uv)| crate::curveblend::in_range(a, uv) && q.dist(p) <= tol * 10.0);- // Pieces by the input face they come from.- let mut groups: Vec<Vec<usize>> = Vec::new();- for (i, f) in history.faces.iter().enumerate() {- let curved = faces.get(i).is_some_and(|x| crate::blend::plane_normal(x).is_none());- if !(curved && f.change == crate::history::Change::Split && f.origins.len() == 1) {- continue;- }- match groups.iter_mut().find(|g| g.first().and_then(|k| history.faces.get(*k)).is_some_and(|o| o.origins == f.origins)) {- Some(g) => g.push(i),- None => groups.push(vec![i]),- }- }- let mut out: Vec<Option<mt::Face>> = faces.iter().cloned().map(Some).collect();- let mut merged_any = false;- for group in groups.iter().filter(|g| g.len() >= 2) {- let pieces: Vec<&mt::Face> = group.iter().filter_map(|i| faces.get(*i)).collect();- if pieces.iter().any(|f| f.boundaries().len() != 1) {- continue;- }- // Edges used once, as the pieces walk them.- let all: Vec<mt::Edge> =- pieces.iter().flat_map(|f| f.boundaries().iter().flat_map(|w| w.edge_iter().cloned().collect::<Vec<_>>()).collect::<Vec<_>>()).collect();- let mut uses: HashMap<mt::EdgeID, usize> = HashMap::new();- for e in &all {- *uses.entry(e.id()).or_default() += 1;- }- let mut left: Vec<mt::Edge> = all.into_iter().filter(|e| uses.get(&e.id()) == Some(&1)).collect();- let Some(start) = left.pop() else { continue };- let mut wire = vec![start];- while let Some(end) = wire.last().map(|e| e.back().clone()) {- if wire.first().is_some_and(|e| *e.front() == end) {- break;- }- let Some(at) = left.iter().position(|e| *e.front() == end) else { break };- wire.push(left.swap_remove(at));- }- // One closed boundary, all of it used.- if !left.is_empty() || wire.first().map(|e| e.front().clone()) != wire.last().map(|e| e.back().clone()) {- continue;- }- // A boolean may restrict a piece's surface to its own parameter box. The- // joined boundary needs the original face's full patch, not an extrapolation- // of one piece (which the bounded display planner correctly refuses).- let all_on = |f: &mt::Face| {- pieces.iter().all(|p| p.vertex_iter().all(|v| on(f, vtx(&v))) && p.edge_iter().all(|e| edge_mid(&e).is_none_or(|m| on(f, m))))- };- let original = group.first().and_then(|i| history.faces.get(*i)).and_then(|h| match h.origins.as_slice() {- [crate::history::FaceOrigin::Face { operand: 0, face }] => source.solid.face_iter().nth(*face),- _ => None,- });- let Some(like) = original.filter(|f| all_on(f)).or_else(|| pieces.iter().copied().find(|f| all_on(f))) else { continue };- let Ok(joined) = mt::Face::try_new(vec![mt::Wire::from(wire)], like.oriented_surface()) else { continue };- let Some(first) = group.first() else { continue };- for i in group {- if let Some(slot) = out.get_mut(*i) {- *slot = None;- }- }- if let Some(slot) = out.get_mut(*first) {- *slot = Some(joined);- }- merged_any = true;- }- if !merged_any {- return Ok(body.clone());- }- let mut shells = solid.boundaries().clone();- if let Some(sh) = shells.first_mut() {- *sh = out.into_iter().flatten().collect::<Vec<_>>().into();- }- let rebuilt = Solid::try_new(shells).map_err(|e| KernelError::Failed(format!("a corner cut: {e}")))?;- record::rebuilt(rebuilt, &[&body.solid], &record::Rebuild::default())-}diff --git a/crates/kernel/src/curveblend.rs b/crates/kernel/src/curveblend.rsdeleted file mode 100644index 1051cae30f..0000000000--- a/crates/kernel/src/curveblend.rs+++ /dev/null@@ -1,2257 +0,0 @@-//! Rolling-ball blends along a closed chain of smooth edges between two smooth groups of faces-//! of any surfaces (a branch pipe meeting a main pipe, a boss on a cylinder). A ball rolls along-//! the edge touching both sides; its centre traces the spine and its contacts the curves where-//! the blend meets each side. The blend face is a rational B-spline through the circular-//! cross-sections (exact arcs at the samples), the side faces are trimmed back to the contact-//! curves, and seams that met the edge (lines, or arcs of an end face) are shortened to the-//! contacts.-//!-//! The ball's size along the chain is one of [`Size`]: one radius all along (the ordinary-//! fillet), a chord width across the blend (each section spans the requested width from contact-//! to contact, so its radius is `chord / (2 sin(ψ/2))` for the `ψ` between the two outward-//! normals where the ball touches), or a radius law along the chain (a [`RadiusSpline`] whose-//! positions are the fraction of the chain's arc length, zero only at an end, where the blend-//! closes to the edge's end point as the straight-edge fillet does).--use std::collections::HashMap;--use solidcraft_geom::Vec3;-use truck_modeling::{self as mt, builder};--use crate::blend::too_large;-use crate::blend_variable::RadiusSpline;-use crate::body::{Solid, from_p3, p3};-use crate::record::Rebuild;-use crate::{KernelError, Result};--fn unsupported(msg: &str) -> KernelError {- KernelError::Failed(format!("not supported yet: {msg}"))-}--/// Samples per edge for the contact curves and the blend surface.-const SAMPLES: usize = 24;-const MAX_SAMPLES: usize = 369;-const MAX_CHAIN_SAMPLES: usize = 100_000;-/// Sections past a slanted end of an open chain.-const EXTENSION: usize = 8;-/// `1 + n1·n2` below this: a knife edge, where the faces' normals are opposite and the ball's-/// centre is found by sliding along the faces rather than from their normals.-const KNIFE: f64 = 1e-4;-/// An end face this close to square-on-to-its-sides' normal counts as tangent to a side.-const TANGENT_END: f64 = 1e-6;-/// Times the run past a tangent end is halved when the ball does not fit along it (and the run-/// past a curved end is shortened when its sections wrap round).-const TANGENT_RETRIES: usize = 8;-/// The longest step between the centres of neighbouring sections past an open chain's end, as a-/// multiple of the step along the end tangent: longer, and the sections have wrapped round a-/// curved edge's ring of centres.-const MAX_STEP_STRETCH: f64 = 3.0;-/// Slides of the ball's centre along a knife edge's faces, each 1.6 times the last.-const KNIFE_STEPS: usize = 40;-/// Corrections of the radius a chord fillet makes to the width it measures across the blend.-const CHORD_STEPS: usize = 12;-/// A section this close to a point is closed: the blend ends at the edge's end point (a radius-/// that has run to zero there).-const CLOSED: f64 = 1e-7;-/// Parameters an edge is sampled at to measure the arc length a radius law is read off.-const LENGTH_STEPS: usize = 64;--/// The ball's size along the edge chain.-#[derive(Clone, Copy)]-enum Size<'a> {- /// One radius all along.- Constant(f64),- /// The width across the blend, from contact to contact, at every station.- Chord(f64),- /// The radius at the station's arc-length fraction along the chain, 0 at the front and 1 at- /// the back of its edge.- Law(&'a RadiusSpline),-}--struct Fit {- surface: mt::Surface,- contacts: [mt::Curve; 2],- /// Parameter range belonging to this edge (the fit includes neighbouring sections).- range: (f64, f64),- /// The part of the fit that is the chain's own run, as fractions of its parameter range.- span: (f64, f64),-}--struct Guide {- sections: Vec<Section>,- /// The size law's parameter (the arc-length fraction along the chain) at each section: the- /// radius between the samples is read off the law there, not off the spine's own length.- law: Vec<f64>,- lengths: Vec<f64>,- /// The part of the guide that is the chain itself, as fractions of its length: the sections- /// run on past the ends of the chain (only so that the fit can be cut back there) and the fit- /// is checked for accuracy on the chain alone.- span: (f64, f64),-}--impl Guide {- /// A guide whose law parameter is the section's own fraction of it (the size is one radius,- /// which needs no law).- fn new(sections: Vec<Section>) -> Result<Self> {- let den = sections.len().max(2) - 1;- let law = (0..sections.len()).map(|i| i as f64 / den as f64).collect();- Self::with_law(sections, law)- }-- fn with_law(sections: Vec<Section>, law: Vec<f64>) -> Result<Self> {- if sections.len() != law.len() {- return Err(unsupported("degenerate rolling-ball spine"));- }- let mut lengths = vec![0.0];- let mut total = 0.0;- for pair in sections.windows(2) {- let (Some(a), Some(b)) = (pair.first(), pair.get(1)) else { continue };- total += a.c.dist(b.c);- lengths.push(total);- }- if !total.is_finite() || total <= 1e-12 {- return Err(unsupported("degenerate rolling-ball spine"));- }- Ok(Self { sections, law, lengths, span: (0.0, 1.0) })- }-- /// The centre and tangent at `along` of the spine.- fn anchor(&self, along: f64) -> Option<(Vec3, Vec3)> {- self.anchor_at(along).map(|(centre, tangent, _)| (centre, tangent))- }-- /// [`Guide::anchor`] with the size law's parameter at that station.- fn anchor_at(&self, along: f64) -> Option<(Vec3, Vec3, f64)> {- if self.lengths.len() < 2 || !along.is_finite() || !(0.0..=1.0).contains(&along) {- return None;- }- let distance = self.lengths.last()? * along;- let hi = self.lengths.partition_point(|length| *length < distance).clamp(1, self.lengths.len().checked_sub(1)?);- let (a, b) = (self.sections.get(hi - 1)?, self.sections.get(hi)?);- let (lo, hi_length) = (self.lengths.get(hi - 1)?, self.lengths.get(hi)?);- let span = hi_length - lo;- if span <= 1e-12 {- return None;- }- let fraction = (distance - lo) / span;- let law = self.law.get(hi - 1)? * (1.0 - fraction) + self.law.get(hi)? * fraction;- Some((a.c + (b.c - a.c) * fraction, (b.c - a.c).normalized()?, law))- }-}--/// One interpolation for both the face and its boundary curves. Fitting the contacts-/// independently gives different end conditions and leaves gaps between the same faces.-fn fit_sections(sections: &[Vec<Section>], k: usize, closed: bool, round: bool) -> Result<Fit> {- let fail = |m: &str| KernelError::Failed(format!("curve blend: {m}"));- let n = sections.len();- let list = sections.get(k).ok_or_else(|| fail("section"))?;- let mut before = Vec::new();- if closed || k > 0 {- let prev = sections.get((k + n - 1) % n).ok_or_else(|| fail("section"))?;- before.extend(prev.iter().rev().skip(1).take(2).rev().copied());- }- let mut after = Vec::new();- if closed || k + 1 < n {- let next = sections.get((k + 1) % n).ok_or_else(|| fail("section"))?;- after.extend(next.iter().skip(1).take(2).copied());- }- fit_strip(list, &before, &after, round)-}--/// [`fit_sections`] with the neighbouring sections given: best spaced as the strip's own, since-/// the interpolation's parameters are uniform.-fn fit_strip(list: &[Section], before: &[Section], after: &[Section], round: bool) -> Result<Fit> {- use mt::Cut;- let fail = |m: &str| KernelError::Failed(format!("curve blend: {m}"));- let mut ext = Vec::with_capacity(list.len() + before.len() + after.len());- ext.extend(before.iter().copied());- ext.extend(list.iter().copied());- ext.extend(after.iter().copied());- let before = before.len();- let ctrl: Vec<[mt::Vector4; 3]> = ext.iter().map(|s| section_controls(s, round)).collect::<Option<_>>().ok_or_else(|| fail("section"))?;- let mut rows = Vec::with_capacity(3);- let mut vknots = None;- for j in 0..3 {- let xyz: Vec<Vec3> = ctrl.iter().filter_map(|c| c.get(j)).map(|c| Vec3::new(c.x, c.y, c.z)).collect();- let ww: Vec<Vec3> = ctrl.iter().filter_map(|c| c.get(j)).map(|c| Vec3::new(c.w, 0.0, 0.0)).collect();- let bx = crate::build::interpolate_cubic(&xyz).ok_or_else(|| fail("blend surface"))?;- let bw = crate::build::interpolate_cubic(&ww).ok_or_else(|| fail("blend surface"))?;- vknots = Some(bx.knot_vec().clone());- rows.push(bx.control_points().iter().zip(bw.control_points()).map(|(p, w)| mt::Vector4::new(p.x, p.y, p.z, w.x)).collect::<Vec<_>>());- }- let vk = vknots.ok_or_else(|| fail("knots"))?;- let den = ext.len().saturating_sub(1) as f64;- if den <= 0.0 {- return Err(fail("empty sections"));- }- let range = (before as f64 / den, (before + list.len().saturating_sub(1)) as f64 / den);- let contact = |row: usize| -> Result<mt::Curve> {- let points = rows.get(row).cloned().ok_or_else(|| fail("contact row"))?;- let bs = mt::BSplineCurve::try_new(vk.clone(), points).map_err(|e| fail(&e.to_string()))?;- let mut curve = mt::NurbsCurve::new(bs);- if range.0 > 0.0 {- curve = curve.cut(range.0);- }- if range.1 < 1.0 {- let _ = curve.cut(range.1);- }- Ok(mt::Curve::NurbsCurve(curve))- };- let contacts = [contact(0)?, contact(2)?];- let bs = mt::BSplineSurface::try_new((mt::KnotVec::bezier_knot(2), vk), rows).map_err(|e| fail(&e.to_string()))?;- Ok(Fit { surface: mt::Surface::NurbsSurface(mt::NurbsSurface::new(bs)), contacts, range, span: (0.0, 1.0) })-}--/// Compare the fitted strip with a solved circular section between interpolation nodes.-/// This checks the supporting contacts as well as the middle of the fillet band.-fn section_fits(fit: &Fit, section: &Section, along: f64, round: bool, sigma: f64, tolerance: f64) -> bool {- use mt::{ParametricSurface, ParametricSurface3D, SearchNearestParameter};- let Some(ctrl) = section_controls(section, round) else { return false };- let v = fit.range.0 + (fit.range.1 - fit.range.0) * along;- for u in [0.0, 0.25, 0.5, 0.75, 1.0] {- let [a, b, c] = ctrl;- let h = a * (1.0 - u) * (1.0 - u) + b * (2.0 * u * (1.0 - u)) + c * u * u;- if !h.w.is_finite() || h.w <= 1e-12 {- return false;- }- let exact = Vec3::new(h.x / h.w, h.y / h.w, h.z / h.w);- // The input intersection edge may use piecewise leader-curve parameters. A- // parameter-speed change is not a geometric error: compare nearest points, with- // contacts constrained to the corresponding boundary and all probes to the strip.- let (probe_u, probe_v) = if u == 0.0 || u == 1.0 {- let Some(contact) = fit.contacts.get(usize::from(u == 1.0)) else { return false };- let Some(parameter) = contact.search_nearest_parameter(p3(exact), v, 32) else { return false };- (u, parameter.clamp(fit.range.0, fit.range.1))- } else {- let Some((pu, pv)) = fit.surface.search_nearest_parameter(p3(exact), Some((u, v)), 32) else { return false };- (pu.clamp(0.0, 1.0), pv.clamp(fit.range.0, fit.range.1))- };- let actual = from_p3(fit.surface.subs(probe_u, probe_v));- if !actual.is_finite() || actual.dist(exact) > tolerance {- return false;- }- if round && (u == 0.0 || u == 1.0) {- let Some(want) = ((section.c - exact) * sigma).normalized() else { return false };- let normal = fit.surface.normal(probe_u, probe_v);- let Some(normal) = Vec3::new(normal.x, normal.y, normal.z).normalized() else { return false };- if normal.dot(want).abs() < 0.5f64.to_radians().cos() {- return false;- }- }- }- true-}--/// Where a blend strip run on past a chain end meets the end face: the contacts' parameters-/// there and the end curve from contact 1 to contact 2 (fitted through points where the-/// strip's cross-section curves meet the face's surface, and checked against both).-fn end_cap(fit: &Fit, g: &mt::Face, at: &Section, seams: [Option<&mt::Edge>; 2], round: bool, tolerance: f64) -> Result<(f64, f64, mt::Curve)> {- use mt::{ParametricCurve, ParametricSurface, SearchNearestParameter};- let fail = || unsupported("the blend's end on its end face");- let (surf, gs) = (&fit.surface, g.surface());- let mid = if round { at.c + ((at.q1 - at.c) + (at.q2 - at.c)).normalized().ok_or_else(fail)? * at.c.dist(at.q1) } else { (at.q1 + at.q2) * 0.5 };- let (_, v_start) = surf.search_nearest_parameter(p3(mid), None, 100).ok_or_else(fail)?;- // S(u, v) = G(a, b) for v, a, b by Newton from v.- let meet = |u: f64, v: f64| -> Option<f64> {- let mut v = v;- let (mut a, mut b) = gs.search_nearest_parameter(surf.subs(u, v), None, 100)?;- for _ in 0..60 {- let f = from_p3(surf.subs(u, v)) - from_p3(gs.subs(a, b));- if !f.is_finite() {- return None;- }- if f.len() <= tolerance * 1e-3 {- return (-1e-9..=1.0 + 1e-9).contains(&v).then_some(v.clamp(0.0, 1.0));- }- let (sv, ga, gb) = (surf.vder(u, v), gs.uder(a, b), gs.vder(a, b));- let m = [[sv.x, -ga.x, -gb.x], [sv.y, -ga.y, -gb.y], [sv.z, -ga.z, -gb.z]];- let [dv, da, db] = crate::polyhedron::solve3_pub(m, [-f.x, -f.y, -f.z])?;- // Keep each step within the strip's parameters.- let k = if dv.abs() > 0.1 { 0.1 / dv.abs() } else { 1.0 };- v += dv * k;- a += da * k;- b += db * k;- }- None- };- for m in [16usize, 32, 64] {- let mut pts = Vec::with_capacity(m + 1);- let mut vs = Vec::with_capacity(m + 1);- // From the middle out to both contacts, each search starting where the last ended.- let half = m / 2;- let mid_v = meet(0.5_f64.min(half as f64 / m as f64), v_start).ok_or_else(fail)?;- let mut found = vec![None; m + 1];- if let Some(slot) = found.get_mut(half) {- *slot = Some(mid_v);- }- let mut last = mid_v;- for i in (0..half).rev() {- last = meet(i as f64 / m as f64, last).ok_or_else(fail)?;- if let Some(slot) = found.get_mut(i) {- *slot = Some(last);- }- }- last = mid_v;- for i in half + 1..=m {- last = meet(i as f64 / m as f64, last).ok_or_else(fail)?;- if let Some(slot) = found.get_mut(i) {- *slot = Some(last);- }- }- for (i, v) in found.iter().enumerate() {- let v = v.ok_or_else(fail)?;- vs.push(v);- pts.push(from_p3(surf.subs(i as f64 / m as f64, v)));- }- snap_to_seams(&mut pts, seams, tolerance);- let bs = crate::build::interpolate_cubic(&pts).ok_or_else(fail)?;- let fits = (0..m).all(|i| {- let q = p3(from_p3(bs.subs((i as f64 + 0.5) / m as f64)));- let hint = vs.get(i).map(|v| ((i as f64 + 0.5) / m as f64, *v));- let on_g = gs.search_nearest_parameter(q, None, 100).is_some_and(|(a, b)| from_p3(gs.subs(a, b)).dist(from_p3(q)) <= tolerance);- let on_s = surf.search_nearest_parameter(q, hint, 100).is_some_and(|(u, v)| from_p3(surf.subs(u, v)).dist(from_p3(q)) <= tolerance);- on_g && on_s- });- if fits {- let (Some(t1), Some(t2)) = (vs.first(), vs.last()) else { return Err(fail()) };- // Both contacts are cut there: strictly inside the strip's own part.- let inside = |t: f64| t > fit.range.0 + 1e-6 && t < fit.range.1 - 1e-6;- if !(inside(*t1) && inside(*t2)) {- return Err(too_large("the blend is larger than the neighbouring faces (site 309)"));- }- return Ok((*t1, *t2, mt::Curve::BSplineCurve(bs)));- }- }- Err(fail())-}--/// The ends of an end curve (contact 1 to contact 2) that land within `tolerance` of an end of-/// their side's seam are that point exactly: the blend and the faces there meet at one vertex.-fn snap_to_seams(pts: &mut [Vec3], seams: [Option<&mt::Edge>; 2], tolerance: f64) {- let snap = |p: &mut Vec3, seam: Option<&mt::Edge>| {- for q in seam.into_iter().flat_map(|e| [from_p3(e.front().point()), from_p3(e.back().point())]) {- if p.dist(q) <= tolerance {- *p = q;- }- }- };- if let Some(first) = pts.first_mut() {- snap(first, seams[0]);- }- if let Some(last) = pts.last_mut() {- snap(last, seams[1]);- }-}--/// Where a blend strip run on past a chain end meets an end face that lies along the edge and is-/// tangent to one side there (a wall running out into the face, an earlier round that touches a-/// side along its contact): the end curve from contact 1 to contact 2, the same result as-/// [`end_cap`]. The strip touches the face along the tangent side's contact, so a Newton solve-/// for the crossing is singular there.-///-/// Both ends of the curve are where a contact meets a seam, which is a plain crossing: the-/// tangent side's contact leaves the end face where it crosses the seam of that side with the-/// face, the other contact where it crosses the other side's seam. Between those stations each-/// cross-section crosses the face once, a simple root. Either station may lie before or after-/// the vertex's section: the curve runs inwards along the edge or out along the extension.-fn tangent_cap(fit: &Fit, g: &mt::Face, tangent_side: u8, seams: [Option<&mt::Edge>; 2], tolerance: f64) -> Result<(f64, f64, mt::Curve)> {- use mt::{BoundedCurve, ParametricCurve, ParametricSurface, SearchNearestParameter};- let fail = || unsupported("the blend's end on its end face");- let surf = &fit.surface;- let (lo, hi) = (fit.range.0.min(fit.range.1), fit.range.0.max(fit.range.1));- let (u_t, u_o, seam_t, seam_o) = if tangent_side == 1 { (0.0, 1.0, seams[0], seams[1]) } else { (1.0, 0.0, seams[1], seams[0]) };- let (seam_t, seam_o) = (seam_t.ok_or_else(fail)?, seam_o.ok_or_else(fail)?);- // The station where the strip's contact `u` crosses `seam`.- let crossing = |u: f64, seam: &mt::Edge| -> Option<f64> {- let curve = seam.curve();- let (a, b) = curve.range_tuple();- let polyline: Vec<Vec3> = (0..=1024).map(|i| from_p3(curve.subs(a + (b - a) * f64::from(i) / 1024.0))).collect();- let dist = |v: f64| -> f64 {- let x = from_p3(surf.subs(u, v));- polyline.windows(2).map(|w| x.dist_to_segment(w[0], w[1])).fold(f64::INFINITY, f64::min)- };- let n = 400;- let step = (hi - lo) / f64::from(n);- let (mut best, mut best_d) = (lo, f64::INFINITY);- for i in 0..=n {- let v = lo + step * f64::from(i);- let d = dist(v);- if d < best_d {- (best, best_d) = (v, d);- }- }- let (mut x0, mut x1) = ((best - step).max(lo), (best + step).min(hi));- let phi = 0.618_033_988_749_894_9;- for _ in 0..80 {- let (c, d) = (x1 - phi * (x1 - x0), x0 + phi * (x1 - x0));- if dist(c) < dist(d) {- x1 = d;- } else {- x0 = c;- }- }- let v = 0.5 * (x0 + x1);- (dist(v) <= tolerance).then_some(v)- };- let (rt, ra) = (crossing(u_t, seam_t), crossing(u_o, seam_o));- let v_t = rt.ok_or_else(fail)?;- let v_a = ra.ok_or_else(|| too_large("the blend is larger than the neighbouring faces (site 387)"))?;- let inside = |t: f64| t > lo + 1e-6 && t < hi - 1e-6;- if !(inside(v_a) && inside(v_t)) || (v_a - v_t).abs() < 1e-9 {- return Err(too_large("the blend is larger than the neighbouring faces (site 390)"));- }- // How far the strip's point (u, v) is outside the end face (negative: inside the body).- let outside = |u: f64, v: f64| -> Option<f64> {- let x = from_p3(surf.subs(u, v));- let (q, n, _) = project(g, x, None)?;- Some((x - q).dot(n))- };- // Root of `f` between `lo` and `hi`, `f(lo)` and `f(hi)` of different sign.- let bisect = |f: &dyn Fn(f64) -> Option<f64>, mut x0: f64, mut x1: f64| -> Option<f64> {- let f0 = f(x0)?;- for _ in 0..60 {- let mid = 0.5 * (x0 + x1);- let fm = f(mid)?;- if fm.abs() <= tolerance * 1e-6 {- return Some(mid);- }- if fm.is_sign_negative() == f0.is_sign_negative() {- x0 = mid;- } else {- x1 = mid;- }- }- Some(0.5 * (x0 + x1))- };- for m in [16usize, 32, 64, 128] {- // The curve at stations v_i from the crossing contact to the tangent one, as (u, v, point).- let mut stations: Vec<(f64, f64, Vec3)> = Vec::with_capacity(m + 1);- for i in 0..=m {- // Clustered at both ends, where the curve can meet a contact tangentially (a square- // root in the station) and a uniform spacing would fit it poorly.- let v = v_a + (v_t - v_a) * 0.5 * (1.0 - (std::f64::consts::PI * i as f64 / m as f64).cos());- let u = if i == 0 {- u_o- } else if i == m {- u_t- } else {- let at_t = outside(u_t, v).ok_or_else(fail)?;- let at_o = outside(u_o, v).ok_or_else(fail)?;- // No crossing where the contacts are on one side: the curve is at the tangent one.- if at_t * at_o >= 0.0 { u_t } else { bisect(&|x| outside(x, v), u_o, u_t).ok_or_else(fail)? }- };- stations.push((u, v, from_p3(surf.subs(u, v))));- }- let mut pts: Vec<Vec3> = stations.iter().map(|x| x.2).collect();- // The curve runs from contact 1 to contact 2.- if u_o == 1.0 {- pts.reverse();- }- snap_to_seams(&mut pts, seams, tolerance);- let bs = crate::build::interpolate_cubic(&pts).ok_or_else(fail)?;- let gs = g.surface();- let fits = stations.windows(2).enumerate().all(|(i, w)| {- let (Some(a), Some(b)) = (w.first(), w.get(1)) else { return false };- let t = if u_o == 1.0 { 1.0 - (i as f64 + 0.5) / m as f64 } else { (i as f64 + 0.5) / m as f64 };- let q = p3(from_p3(bs.subs(t)));- let hint = (0.5 * (a.0 + b.0), 0.5 * (a.1 + b.1));- let on_g = gs.search_nearest_parameter(q, None, 100).is_some_and(|(x, y)| from_p3(gs.subs(x, y)).dist(from_p3(q)) <= tolerance);- let on_s = surf.search_nearest_parameter(q, Some(hint), 100).is_some_and(|(x, y)| from_p3(surf.subs(x, y)).dist(from_p3(q)) <= tolerance);- on_g && on_s- });- if fits {- let (t1, t2) = if u_o == 0.0 { (v_a, v_t) } else { (v_t, v_a) };- return Ok((t1, t2, mt::Curve::BSplineCurve(bs)));- }- }- Err(fail())-}--/// One cross-section of the blend: ball centre and its contacts with side 1 and side 2.-#[derive(Clone, Copy, Debug)]-struct Section {- c: Vec3,- q1: Vec3,- q2: Vec3,-}--/// The third condition of a section's solve, in place of staying in the plane square to the edge: a contact held at a seam.-#[derive(Clone, Copy)]-enum Extra<'a> {- /// Side `k`'s contact lies in this plane (a point on it, its normal): beside a straight seam.- Plane(usize, Vec3, Vec3),- /// Side `k`'s contact lies on this curved seam (a lofted wall's seam between its two halves).- Seam(usize, &'a mt::Edge),-}--/// The seam's point nearest `x` and its unit tangent there.-fn nearest_on_seam(seam: &mt::Edge, x: Vec3) -> Option<(Vec3, Vec3)> {- use mt::{BoundedCurve, ParametricCurve, SearchNearestParameter};- let curve = seam.curve();- let (lo, hi) = curve.range_tuple();- let at = |t: f64| from_p3(curve.subs(t));- // The nearest of a few samples starts the search: a long seam holds the point's neighbourhood- // far from its ends.- let hint = (0..=64).map(|i| lo + (hi - lo) * i as f64 / 64.0).min_by(|a, b| at(*a).dist(x).total_cmp(&at(*b).dist(x)))?;- let t = curve.search_nearest_parameter(p3(x), hint, 100)?.clamp(lo, hi);- let d = curve.der(t);- Some((at(t), Vec3::new(d.x, d.y, d.z).normalized()?))-}--/// Nearest point of a face's surface and the outward normal there.-pub(crate) fn project(f: &mt::Face, p: Vec3, hint: Option<(f64, f64)>) -> Option<(Vec3, Vec3, (f64, f64))> {- use mt::{ParametricSurface, ParametricSurface3D, SearchNearestParameter};- let s = f.oriented_surface();- let uv = s.search_nearest_parameter(p3(p), hint, 100).or_else(|| s.search_nearest_parameter(p3(p), None, 100))?;- let q = from_p3(s.subs(uv.0, uv.1));- let n = s.normal(uv.0, uv.1);- Some((q, Vec3::new(n.x, n.y, n.z).normalized()?, uv))-}--/// Whether `uv` lies within the parameters of the face's surface (unbounded directions pass).-pub(crate) fn in_range(f: &mt::Face, uv: (f64, f64)) -> bool {- use mt::ParametricSurface;- use std::ops::Bound;- let inside = |range: (Bound<f64>, Bound<f64>), x: f64| {- let slack = |a: f64, b: f64| (b - a).abs() * 1e-6 + 1e-9;- match range {- (Bound::Included(a) | Bound::Excluded(a), Bound::Included(b) | Bound::Excluded(b)) => x >= a - slack(a, b) && x <= b + slack(a, b),- (Bound::Included(a) | Bound::Excluded(a), Bound::Unbounded) => x >= a - 1e-9,- (Bound::Unbounded, Bound::Included(b) | Bound::Excluded(b)) => x <= b + 1e-9,- (Bound::Unbounded, Bound::Unbounded) => true,- }- };- let (ru, rv) = f.oriented_surface().parameter_range();- uv.0.is_finite() && uv.1.is_finite() && inside(ru, uv.0) && inside(rv, uv.1)-}--/// Solve for the ball touching both sides near `p`. `extra` adds a third condition (a plane the-/// side-k contact must lie in, or a curved seam it must lie on); without it the centre stays in the-/// plane through `p` square to `t`. `sigma` is +1 when the ball sits outside the material (concave edge), −1 inside.-/// `cusp` is ±1 at a knife edge (the faces' normals opposite: both leave the edge the same way,-/// along `cusp · n1 × t`, and the ball lies where the cusp has opened to its width), else 0.-#[allow(clippy::too_many_arguments)]-fn solve(f1: &[&mt::Face], f2: &[&mt::Face], p: Vec3, t: Vec3, r: f64, sigma: f64, cusp: f64, extra: Option<Extra<'_>>, tol: f64) -> Option<Section> {- solve_from(f1, f2, p, t, r, sigma, cusp, extra, tol, None)-}--/// [`solve`], started from the centre `start` when given (the corner builder's balls at a knife-/// edge start beside the last one).-#[allow(clippy::too_many_arguments)]-fn solve_from(- f1: &[&mt::Face],- f2: &[&mt::Face],- p: Vec3,- t: Vec3,- r: f64,- sigma: f64,- cusp: f64,- extra: Option<Extra<'_>>,- tol: f64,- start: Option<Vec3>,-) -> Option<Section> {- // The nearest face of a side (several faces on one smooth surface group). Each face's- // search starts from its last answer: the centre moves little between iterations. An- // answer outside the surface's parameters, or farther than that last point (the search- // ran away or settled on the far side), is searched again cold.- let last = std::cell::RefCell::new(HashMap::<mt::FaceID, ((f64, f64), Vec3)>::new());- let near = |fs: &[&mt::Face], c: Vec3| -> Option<(Vec3, Vec3)> {- fs.iter()- .filter_map(|f| {- let prev = last.borrow().get(&f.id()).copied();- let warm =- prev.and_then(|(uv, q)| project(f, c, Some(uv)).filter(|(x, _, uv)| in_range(f, *uv) && x.dist(c) <= q.dist(c) + tol * 1e-3));- let (q, n, uv) = match warm {- Some(x) => x,- None => project(f, c, None)?,- };- last.borrow_mut().insert(f.id(), (uv, q));- Some((q, n))- })- .min_by(|a, b| a.0.dist(c).total_cmp(&b.0.dist(c)))- };- let (q1, n1) = near(f1, p)?;- let (q2, n2) = near(f2, p)?;- let _ = (q1, q2);- let den = 1.0 + n1.dot(n2);- let mut c = if let Some(c) = start {- c- } else if cusp != 0.0 && den.abs() < KNIFE {- // The normals are (nearly) opposite: `(n1 + n2) / den` has no direction. The centre is r- // inside face 1 and slides along it, away from the edge, until it is r from face 2 too.- let w = n1.cross(t).normalized()? * cusp;- let centre = |s: f64| -> Option<Vec3> {- let (qa, na) = near(f1, p + w * s)?;- Some(qa + na * (sigma * r))- };- let gap = |s: f64| -> Option<f64> {- let c = centre(s)?;- let (q2, n2) = near(f2, c)?;- Some((c - q2).dot(n2) - sigma * r)- };- let (mut lo, mut g_lo) = (0.0, gap(0.0)?);- let mut hi = None;- let mut s = r * 0.05;- for _ in 0..KNIFE_STEPS {- let Some(g) = gap(s) else { break };- if g == 0.0 || g.is_sign_negative() != g_lo.is_sign_negative() {- hi = Some(s);- break;- }- (lo, g_lo) = (s, g);- s *= 1.6;- }- let mut hi = hi?;- for _ in 0..60 {- let mid = 0.5 * (lo + hi);- match gap(mid) {- Some(g) if g.is_sign_negative() == g_lo.is_sign_negative() => lo = mid,- Some(_) => hi = mid,- None => break,- }- }- centre(0.5 * (lo + hi))?- } else {- if den.abs() < 1e-9 {- return None;- }- p + (n1 + n2) * (sigma * r / den)- };- for _ in 0..60 {- let (q1, n1) = near(f1, c)?;- let (q2, n2) = near(f2, c)?;- let g1 = (c - q1).dot(n1) - sigma * r;- let g2 = (c - q2).dot(n2) - sigma * r;- // Third row: stay in the section plane, or put a contact on the seam plane.- let (row3, g3) = match extra {- None => (t, (c - p).dot(t)),- Some(Extra::Plane(k, o, m)) => {- let q = if k == 1 { q1 } else { q2 };- (m, (q - o).dot(m))- }- Some(Extra::Seam(k, seam)) => {- // The plane through the seam's nearest point to the contact, square to that side's- // surface, taken afresh each step: it holds the contact on the curved seam as the- // steps close in.- let (q, n) = if k == 1 { (q1, n1) } else { (q2, n2) };- let (on_seam, d) = nearest_on_seam(seam, q)?;- let m = d.cross(n).normalized()?;- (m, (q - on_seam).dot(m))- }- };- let a = [[n1.x, n1.y, n1.z], [n2.x, n2.y, n2.z], [row3.x, row3.y, row3.z]];- let b = [-g1, -g2, -g3];- let x = crate::polyhedron::solve3_pub(a, b)?;- let dc = Vec3::new(x[0], x[1], x[2]);- c += dc;- if dc.len() < tol * 1e-3 && g1.abs() < tol && g2.abs() < tol && g3.abs() < tol {- let (q1, _) = near(f1, c)?;- let (q2, _) = near(f2, c)?;- return Some(Section { c, q1, q2 });- }- }- None-}--/// Contacts of a convex chamfer in a cross-section normal to a straight edge. The caller-/// checks that sweeping the section stays on both supports within the fitting tolerance.-pub(crate) fn straight_chamfer_contacts(f1: &mt::Face, f2: &mt::Face, p: Vec3, d: Vec3, r: f64, tolerance: f64) -> Option<(Vec3, Vec3)> {- let section = solve(&[f1], &[f2], p, d, r, -1.0, 0.0, None, tolerance)?;- Some((section.q1, section.q2))-}--/// The section whose two contacts are `chord` apart: the ball's radius is `chord / (2 sin(ψ/2))`-/// for the `ψ` between the two outward normals where it touches, `|q1 − q2| = 2 r sin(ψ/2)`. The-/// normals turn as the ball grows against curved faces, so the width is measured on the solved-/// section and the radius corrected until it matches (the width is proportional to the radius,-/// so the corrections converge quickly). The normals at `p` give the first radius, exact where-/// both faces are planar; `None` where the faces meet too nearly tangentially to span a chord.-#[allow(clippy::too_many_arguments)]-fn solve_chord(- f1: &[&mt::Face],- f2: &[&mt::Face],- p: Vec3,- t: Vec3,- chord: f64,- sigma: f64,- cusp: f64,- extra: Option<Extra<'_>>,- tol: f64,-) -> Option<(Section, f64)> {- let normal = |fs: &[&mt::Face]| fs.iter().filter_map(|f| project(f, p, None)).min_by(|a, b| a.0.dist(p).total_cmp(&b.0.dist(p))).map(|x| x.1);- let (n1, n2) = (normal(f1)?, normal(f2)?);- let half = (n1.dot(n2).clamp(-1.0, 1.0).acos() / 2.0).sin();- if !(half > 1e-3) {- return None;- }- let mut r = chord / (2.0 * half);- for _ in 0..CHORD_STEPS {- if !(r.is_finite() && r > 0.0 && r < 1e9) {- return None;- }- let s = solve(f1, f2, p, t, r, sigma, cusp, extra, tol)?;- let width = s.q1.dist(s.q2);- if !width.is_finite() || width <= 0.0 {- return None;- }- if (width - chord).abs() <= (chord * 1e-9).max(tol * 0.5) {- return Some((s, r));- }- r *= chord / width;- }- None-}--/// The rolling ball at one station, sized by the blend's law.-struct Sizer<'a> {- size: Size<'a>,- /// The tolerance the section's equations are solved at.- tol: f64,-}--impl Sizer<'_> {- /// The section at `p` (tangent `t`, the size law's parameter `s`) holding the third- /// condition `extra` when given, with the radius it was solved at.- #[allow(clippy::too_many_arguments)]- fn section(- &self,- f1: &[&mt::Face],- f2: &[&mt::Face],- p: Vec3,- t: Vec3,- s: f64,- sigma: f64,- cusp: f64,- extra: Option<Extra<'_>>,- ) -> Option<(Section, f64)> {- match self.size {- Size::Constant(r) => solve(f1, f2, p, t, r, sigma, cusp, extra, self.tol).map(|x| (x, r)),- Size::Chord(chord) => solve_chord(f1, f2, p, t, chord, sigma, cusp, extra, self.tol),- Size::Law(law) => {- let r = law_beyond(law, s)?;- if !(r.is_finite() && (0.0..1e6).contains(&r)) {- return None;- }- solve(f1, f2, p, t, r, sigma, cusp, extra, self.tol).map(|x| (x, r))- }- }- }-- /// What a station the ball does not fit at is refused with: a chord too large is about the- /// size asked for, anything else about where the ball is.- fn refusal(&self) -> KernelError {- match self.size {- Size::Chord(_) => too_large("the blend is larger than the neighbouring faces (site 704)"),- _ => unsupported("the ball doesn't fit along the edge"),- }- }-}--/// Whether the strip's curvature jumps where two runs of sections meet (each three sections from-/// the joint outward, the joint's first): for the centres or either contact, the difference of-/// the circles through them would move the middle section by more than a tenth of `tolerance`.-fn bends(a: [&Section; 3], b: [&Section; 3], tolerance: f64) -> bool {- let curvature = |p: [Vec3; 3]| {- let (x, y, z) = (p[1] - p[0], p[2] - p[1], p[2] - p[0]);- let d = x.len() * y.len() * z.len();- if d > 1e-300 { 2.0 * x.cross(y).len() / d } else { 0.0 }- };- let h = a[0].c.dist(a[1].c);- [|s: &Section| s.c, |s: &Section| s.q1, |s: &Section| s.q2]- .iter()- .any(|f| (curvature(a.map(f)) - curvature(b.map(f))).abs() * h * h > tolerance * 0.1)-}--/// Whether the section is a point: a blend whose radius has run to zero, closing to the edge's-/// end point there.-fn closed_section(s: &Section) -> bool {- s.c.dist(s.q1) <= CLOSED && s.c.dist(s.q2) <= CLOSED-}--/// Homogeneous control points of the circular (or straight) cross-section from q1 to q2.-fn section_controls(s: &Section, round: bool) -> Option<[mt::Vector4; 3]> {- let h = |p: Vec3, w: f64| mt::Vector4::new(p.x * w, p.y * w, p.z * w, w);- if !round {- let m = (s.q1 + s.q2) * 0.5;- return Some([h(s.q1, 1.0), h(m, 1.0), h(s.q2, 1.0)]);- }- if closed_section(s) {- // A closed section: the arc has shrunk to the edge's end point, all three controls- // there, so the fitted strips of the neighbouring faces meet at that vertex.- return Some([h(s.c, 1.0), h(s.c, 1.0), h(s.c, 1.0)]);- }- let (a, b) = (s.q1 - s.c, s.q2 - s.c);- let theta = a.normalized()?.dot(b.normalized()?).clamp(-1.0, 1.0).acos();- if !(theta > 1e-6 && theta < std::f64::consts::PI - 1e-6) {- return None;- }- let half = (theta / 2.0).cos();- let bis = (a + b).normalized()?;- let m = s.c + bis * (a.len() / half);- Some([h(s.q1, 1.0), h(m, half), h(s.q2, 1.0)])-}--/// Where to start the ball at a knife edge through `p` (direction `t`, the sides running on from-/// it along `into`): the first point along them, from the edge, where they are a diameter-/// apart, midway.-fn knife_start(o1: &[&mt::Face], o2: &[&mt::Face], p: Vec3, t: Vec3, into: Vec3, r: f64) -> Option<Vec3> {- let w = (into - t * into.dot(t)).normalized()?;- (1..=256).find_map(|k| {- let x = p + w * (r * k as f64 / 8.0);- let a = o1.iter().filter_map(|f| project(f, x, None)).min_by(|a, b| a.0.dist(x).total_cmp(&b.0.dist(x)))?;- let b = o2.iter().filter_map(|f| project(f, x, None)).min_by(|a, b| a.0.dist(x).total_cmp(&b.0.dist(x)))?;- let c = (a.0 + b.0) * 0.5;- (a.0.dist(b.0) >= 2.0 * r).then(|| c - t * (c - p).dot(t))- })-}--/// Whether two faces meeting at no angle at `pm` (the first's outward normal `n1`, running on-/// from the edge along `into`) hold the material between them: a little way in, the second is-/// behind the first.-fn knife_convex(f1: &mt::Face, f2: &mt::Face, pm: Vec3, into: Vec3, r: f64) -> Option<bool> {- let x = pm + into * r;- let (a, b) = (project(f1, x, None)?, project(f2, x, None)?);- Some((b.0 - a.0).dot(a.1) < 0.0)-}--/// The nearest point of a face's (oriented) surface to `x`, its outward normal and parameters;-/// `last`: where the last search on it ended (the points asked about come in small steps).-fn nearest_on(surface: &mt::Surface, last: &std::cell::Cell<Option<(f64, f64)>>, x: Vec3) -> Option<(Vec3, Vec3, (f64, f64))> {- use mt::{ParametricSurface, ParametricSurface3D, SearchNearestParameter};- // The nearest of the search from the last answer, a fresh one (the first time, also from- // a grid over the surface's parameters: a fresh search on a conic can settle on its far- // side) and either kept within the parameters (past them a conic runs on round).- let (ru, rv) = surface.try_range_tuple();- let ((u0, u1), (v0, v1)) = (ru.unwrap_or((f64::NEG_INFINITY, f64::INFINITY)), rv.unwrap_or((f64::NEG_INFINITY, f64::INFINITY)));- let inside = |uv: (f64, f64)| uv.0 >= u0 - 1e-9 && uv.0 <= u1 + 1e-9 && uv.1 >= v0 - 1e-9 && uv.1 <= v1 + 1e-9;- let warm = last.get().and_then(|hint| surface.search_nearest_parameter(p3(x), Some(hint), 20));- let mut found: Vec<(f64, f64)> = warm.into_iter().collect();- if !warm.is_some_and(inside) {- found.extend(surface.search_nearest_parameter(p3(x), None, 100));- }- if last.get().is_none() && [u0, u1, v0, v1].iter().all(|x| x.is_finite()) {- for i in 0..5 {- for j in 0..5 {- let hint = (u0 + (u1 - u0) * (i as f64 + 0.5) / 5.0, v0 + (v1 - v0) * (j as f64 + 0.5) / 5.0);- found.extend(surface.search_nearest_parameter(p3(x), Some(hint), 50));- }- }- }- let clamped: Vec<(f64, f64)> = found.iter().map(|(u, v)| (u.clamp(u0, u1), v.clamp(v0, v1))).collect();- found.extend(clamped);- let d = |uv: &(f64, f64)| from_p3(surface.subs(uv.0, uv.1)).dist(x);- let uv = found.into_iter().filter(|uv| d(uv).is_finite()).min_by(|a, b| d(a).total_cmp(&d(b)))?;- last.set(Some(uv));- let n = surface.normal(uv.0, uv.1);- Some((from_p3(surface.subs(uv.0, uv.1)), Vec3::new(n.x, n.y, n.z).normalized()?, uv))-}--/// The strip with parameters in proportion to its lengths across and along (the same surface).-/// The mesher triangulates a face in its parameters: on a unit square for a strip a few-/// millimetres wide and tens long, the points of a slanted end fan out into triangles so long-/// along the curve that they turn over.-fn in_proportion(surface: &mt::Surface) -> Result<mt::Surface> {- use mt::ParametricSurface;- let fail = || KernelError::Failed("curve blend: strip parameters".into());- let mt::Surface::NurbsSurface(ns) = surface else { return Err(fail()) };- let length = |at: &dyn Fn(f64) -> Vec3| (0..32).map(|i| at(i as f64 / 32.0).dist(at((i + 1) as f64 / 32.0))).sum::<f64>();- let across = length(&|u| from_p3(surface.subs(u, 0.5)));- let along = length(&|v| from_p3(surface.subs(0.5, v)));- if !(across.is_finite() && along.is_finite() && across > 1e-9 && along > 1e-9) {- return Err(fail());- }- let bs = ns.non_rationalized();- let (mut uk, mut vk) = bs.knot_vecs().clone();- uk.transform(across, 0.0);- vk.transform(along, 0.0);- let bs = mt::BSplineSurface::try_new((uk, vk), bs.control_points().clone()).map_err(|_| fail())?;- Ok(mt::Surface::NurbsSurface(mt::NurbsSurface::new(bs)))-}--/// A chain edge the ball turns about instead of rolling along: an arc of the blend's radius on a-/// planar side (`side`), curving round the ball (a rounded corner rounded again). The ball's-/// centre stays at `c`, it touches the planar side only at the arc's centre `o`, and the blend-/// there is a piece of sphere (of cone, for a chamfer) about the axis through `c` along `axis`.-#[derive(Clone, Copy, Debug)]-struct Pivot {- c: Vec3,- o: Vec3,- axis: Vec3,- side: usize,-}--/// The circle an edge lies on (centre, radius, axis), if it is an arc of one within `tol`.-pub(crate) fn circle_of(e: &mt::Edge, tol: f64) -> Option<(Vec3, f64, Vec3)> {- use mt::{BoundedCurve, ParametricCurve};- let curve = e.oriented_curve();- let (t0, t1) = curve.range_tuple();- let at = |f: f64| from_p3(curve.subs(t0 + (t1 - t0) * f));- let (a, u, v) = (at(0.0), at(0.5) - at(0.0), at(1.0) - at(0.0));- let w = u.cross(v);- if w.len2() < 1e-24 {- return None;- }- let o = a + (v * u.len2() - u * v.len2()).cross(w) * (1.0 / (2.0 * w.len2()));- let (rho, axis) = (o.dist(a), w.normalized()?);- (0..=8).map(|i| at(i as f64 / 8.0)).all(|p| (p.dist(o) - rho).abs() <= tol && (p - o).dot(axis).abs() <= tol).then_some((o, rho, axis))-}--/// The surface the section (homogeneous controls from contact 1 to contact 2) sweeps turning by-/// `angle` about the axis through `c` along the unit `axis`: rational quadratic arcs in v, a-/// quarter turn at most each, so it is exact.-fn revolve(ctrl: [mt::Vector4; 3], c: Vec3, axis: Vec3, angle: f64) -> Option<mt::Surface> {- let pieces = ((angle.abs() / std::f64::consts::FRAC_PI_2).ceil() as usize).clamp(1, 8);- let step = angle / pieces as f64;- let half = (step / 2.0).cos();- if !(half.is_finite() && half > 1e-6) {- return None;- }- let rot = |x: Vec3, phi: f64| {- let (s, co) = phi.sin_cos();- x * co + axis.cross(x) * s + axis * (axis.dot(x) * (1.0 - co))- };- let h = |p: Vec3, w: f64| mt::Vector4::new(p.x * w, p.y * w, p.z * w, w);- let mut rows = Vec::with_capacity(3);- for q in ctrl {- if !(q.w.is_finite() && q.w > 1e-12) {- return None;- }- let x = Vec3::new(q.x / q.w, q.y / q.w, q.z / q.w) - c;- let along = axis * axis.dot(x);- let mut row = vec![h(c + x, q.w)];- for i in 0..pieces {- let a0 = step * i as f64;- row.push(h(c + along + rot(x - along, a0 + step / 2.0) * (1.0 / half), q.w * half));- row.push(h(c + rot(x, a0 + step), q.w));- }- rows.push(row);- }- let mut knots = vec![0.0; 3];- for i in 1..pieces {- let k = i as f64 / pieces as f64;- knots.extend([k, k]);- }- knots.extend([1.0; 3]);- let bs = mt::BSplineSurface::try_new((mt::KnotVec::bezier_knot(2), mt::KnotVec::from(knots)), rows).ok()?;- Some(mt::Surface::NurbsSurface(mt::NurbsSurface::new(bs)))-}--/// Whether the edge is straight: a line, or a curve on the segment between its ends within-/// `tol` (an earlier blend's contact along a straight edge is a fitted curve).-pub(crate) fn straight(e: &mt::Edge, tol: f64) -> bool {- use mt::{BoundedCurve, ParametricCurve};- let c = e.curve();- if matches!(c, mt::Curve::Line(_)) {- return true;- }- let (a, b) = (from_p3(e.front().point()), from_p3(e.back().point()));- let (t0, t1) = c.range_tuple();- a.dist(b) > tol && (0..=16).all(|i| from_p3(c.subs(t0 + (t1 - t0) * i as f64 / 16.0)).dist_to_segment(a, b) <= tol)-}--/// Consuming both seams of a side can leave its old boundary and a fitted contact on the-/// same curve (#1113). They are distinct topological edges but enclose no usable face. Keep-/// genuine two-edge faces (a lens or lune); refuse only coincident traces, in both directions-/// since the curves need not have the same parameterisation.-fn collapsed_boundary(edges: &[mt::Edge], tolerance: f64) -> bool {- use mt::{BoundedCurve, ParametricCurve};- let [a, b] = edges else { return false };- [(a, b), (b, a)].into_iter().all(|(edge, other)| {- let curve = edge.curve();- let (lo, hi) = curve.range_tuple();- (0..=16).all(|k| {- let p = from_p3(curve.subs(lo + (hi - lo) * f64::from(k) / 16.0));- crate::blend::on_edge(other, p, tolerance).is_some()- })- })-}--/// A curved seam (an arc of an end face) shortened to the blend's contacts: the part of its-/// curve between the new ends `a` and `b` (`None` keeps that end), which must lie on it, in-/// order, short of each other.-pub(crate) fn trim_curved_seam(seam: &mt::Edge, a: Option<mt::Vertex>, b: Option<mt::Vertex>, size: f64) -> Result<mt::Edge> {- // A closed seam (a full circle starting and ending at one vertex) has no "between": which- // end a contact replaces, and which way round the kept piece runs, are both ambiguous.- if seam.front() == seam.back() {- return Err(unsupported("a closed curved edge where the blend ends"));- }- use mt::{BoundedCurve, Cut, SearchNearestParameter};- let mut curve = seam.curve();- let (lo, hi) = curve.range_tuple();- let at = |v: &Option<mt::Vertex>, end: f64| -> Result<f64> {- let Some(v) = v else { return Ok(end) };- // Start from the nearest of a few samples: from the far end of a long arc- // the search can settle on the opposite side of the circle.- let q = from_p3(v.point());- let hint = (0..=32)- .map(|i| lo + (hi - lo) * i as f64 / 32.0)- .min_by(|x, y| {- let d = |t: f64| from_p3(mt::ParametricCurve::subs(&curve, t)).dist(q);- d(*x).total_cmp(&d(*y))- })- .unwrap_or(end);- let t = curve.search_nearest_parameter(v.point(), hint, 100).ok_or_else(|| unsupported("the blend is larger than the neighbouring faces"))?;- if !(t.is_finite() && from_p3(mt::ParametricCurve::subs(&curve, t)).dist(from_p3(v.point())) <= size * 1e-5) {- return Err(too_large("the blend is larger than the neighbouring faces (site 938)"));- }- Ok(t)- };- let (ta, tb) = (at(&a, lo)?, at(&b, hi)?);- let margin = (hi - lo) * 1e-9;- if ta < lo - margin || tb > hi + margin || tb - ta < (hi - lo) * 1e-6 {- return Err(too_large("the blend is larger than the neighbouring faces (site 945)"));- }- if tb < hi {- let _ = curve.cut(tb);- }- let piece = if ta > lo { curve.cut(ta) } else { curve };- let a = a.unwrap_or_else(|| seam.front().clone());- let b = b.unwrap_or_else(|| seam.back().clone());- mt::Edge::try_new(&a, &b, piece).map_err(|e| KernelError::Failed(format!("curve blend: seam: {e}")))-}--/// A monotone curve's parameter read off a table of its values at uniform parameters (`None` for-/// an empty table): the fraction of the way through it.-fn sampled(table: &[f64], along: f64) -> Option<f64> {- if table.len() < 2 || !along.is_finite() {- return None;- }- let x = along.clamp(0.0, 1.0) * (table.len() - 1) as f64;- let i = (x.floor() as usize).min(table.len() - 2);- let f = x - i as f64;- Some(table.get(i)? * (1.0 - f) + table.get(i + 1)? * f)-}--/// The arc length of `edge` from its front to its back at each of `LENGTH_STEPS + 1` uniform-/// parameters, accumulated. `None` for an edge that has no length (or runs back over itself).-fn edge_lengths(edge: &mt::Edge) -> Option<Vec<f64>> {- use mt::{BoundedCurve, ParametricCurve};- let c = edge.oriented_curve();- let (a, b) = c.range_tuple();- let mut last = from_p3(c.subs(a));- let mut total = 0.0;- let mut out = Vec::with_capacity(LENGTH_STEPS + 1);- out.push(0.0);- for i in 1..=LENGTH_STEPS {- let p = from_p3(c.subs(a + (b - a) * i as f64 / LENGTH_STEPS as f64));- total += last.dist(p);- last = p;- out.push(total);- }- (total.is_finite() && total > 1e-12).then_some(out)-}--/// The radius a law gives at the chain fraction `s`, continued past 0 and 1 at the law's own end-/// slope. The ball runs on past a chain end (to be cut back there by its end face), and holding-/// the end radius would kink the strip exactly where the edge begins: a kink a cubic fit spreads-/// back over the whole blend. Never below a fifth of the end radius, so that a law running down-/// steeply still has a ball to run on with.-fn law_beyond(law: &RadiusSpline, s: f64) -> Option<f64> {- if (0.0..=1.0).contains(&s) {- return Some(law.eval(s));- }- let (end, step) = if s < 0.0 { (0.0, s) } else { (1.0, s - 1.0) };- let h = 1e-3;- let slope = (law.eval(end + h) - law.eval(end)) / h;- let r = law.eval(end);- let r = (r + slope * step).max(0.2 * r);- (r.is_finite() && r > 0.0).then_some(r)-}--/// Blend the closed chain of edges (ids in any order) with radius `r`; with what it built from-/// `solid` (each blend face in place of its chain edge).-pub(crate) fn curve_blend(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64, round: bool) -> Result<(Solid, Rebuild)> {- curve_blend_with_limit(solid, ids, size, r, round, MAX_SAMPLES)-}--/// [`curve_blend`] with the blend `chord` wide across, from contact to contact, at every station.-pub(crate) fn curve_blend_chord(solid: &Solid, ids: &[mt::EdgeID], size: f64, chord: f64, round: bool) -> Result<(Solid, Rebuild)> {- curve_blend_sized(solid, ids, size, Size::Chord(chord), round, MAX_SAMPLES)-}--/// [`curve_blend`] with the radius following `law` along the chain (its positions the fraction of-/// the chain's arc length, from the front of its first edge to the back of its last).-pub(crate) fn curve_blend_law(solid: &Solid, ids: &[mt::EdgeID], size: f64, law: &RadiusSpline, round: bool) -> Result<(Solid, Rebuild)> {- curve_blend_sized(solid, ids, size, Size::Law(law), round, MAX_SAMPLES)-}--fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64, round: bool, max_samples: usize) -> Result<(Solid, Rebuild)> {- curve_blend_sized(solid, ids, size, Size::Constant(r), round, max_samples)-}--/// Blend the chain of edges (ids in any order) sized by `size`: one radius, a chord width, or a-/// radius law. With what it built from `solid` (each blend face in place of its chain edge).-fn curve_blend_sized(solid: &Solid, ids: &[mt::EdgeID], size: f64, size_law: Size<'_>, round: bool, max_samples: usize) -> Result<(Solid, Rebuild)> {- if !(size.is_finite() && size > 0.0) {- return Err(KernelError::Invalid("curve blend size and radius must be finite and positive".into()));- }- match size_law {- Size::Constant(r) | Size::Chord(r) => {- if !(r.is_finite() && r > 1e-6 && r < 1e6) {- return Err(KernelError::Invalid("curve blend size and radius must be finite and positive".into()));- }- }- Size::Law(law) => {- let knots = law.knots.len() == law.radii.len() + law.degree + 1;- if law.radii.len() < 2 || !knots || law.radii.iter().any(|r| !(r.is_finite() && (0.0..1e6).contains(r))) {- return Err(KernelError::Invalid("a radius law along the edge must be finite and non-negative".into()));- }- // A law that runs to zero closes the blend at the edge's end point. The fitted strip- // pinches to a point there, and the sections' own interpolation cannot follow the last- // span of it: the straight-edge fillet, which builds that closure exactly, is the way.- if law.eval(0.0) <= CLOSED || law.eval(1.0) <= CLOSED {- return Err(unsupported("a radius law that runs to zero along a curved edge"));- }- }- }- if !(4..=MAX_SAMPLES).contains(&max_samples) {- return Err(KernelError::Invalid("curve blend section limit is outside the supported range".into()));- }- let tol = (size * 1e-7).max(1e-9);- let shells = solid.boundaries();- let (si, shell) = shells- .iter()- .enumerate()- .find(|(_, sh)| sh.edge_iter().any(|e| ids.contains(&e.id())))- .ok_or_else(|| KernelError::Failed("edge not found".into()))?;- let faces: Vec<mt::Face> = shell.face_iter().cloned().collect();- // Order the chain: edges as stored (absolute direction), each starting where the last ended.- let mut chain: Vec<mt::Edge> = Vec::new();- let all: Vec<mt::Edge> = {- let mut seen = std::collections::HashSet::new();- shell.edge_iter().filter(|e| ids.contains(&e.id()) && seen.insert(e.id())).map(|e| e.absolute_clone()).collect()- };- // An open chain starts at a vertex only one of its edges touches.- let uses = |v: &mt::Vertex| all.iter().filter(|e| e.front() == v || e.back() == v).count();- let first = match all.iter().find_map(|e| {- if uses(e.front()) == 1 {- Some(e.clone())- } else if uses(e.back()) == 1 {- Some(e.inverse())- } else {- None- }- }) {- Some(e) => e,- None => all.first().cloned().ok_or_else(|| KernelError::Failed("no edges".into()))?,- };- chain.push(first.clone());- while chain.len() < all.len() {- let end = chain.last().map(|e| e.back().clone()).ok_or_else(|| KernelError::Failed("chain".into()))?;- let next = all- .iter()- .find(|e| !chain.iter().any(|c| c.id() == e.id()) && (*e.front() == end || *e.back() == end))- .ok_or_else(|| unsupported("the edges don't form one chain"))?;- chain.push(if *next.front() == end { next.clone() } else { next.inverse() });- }- let closed = chain.first().map(|e| e.front().clone()) == chain.last().map(|e| e.back().clone());- let n = chain.len();- // The chain's vertices (n for a closed chain, n + 1 for an open one).- let mut verts: Vec<mt::Vertex> = chain.iter().map(|e| e.front().clone()).collect();- if !closed && let Some(e) = chain.last() {- verts.push(e.back().clone());- }- let nv = verts.len();- // Faces of each edge, split into the two sides.- let faces_of = |e: &mt::Edge| -> Vec<usize> {- (0..faces.len()).filter(|i| faces.get(*i).is_some_and(|f| f.edge_iter().any(|x| x.id() == e.id()))).collect()- };- let mut side1: Vec<usize> = Vec::new();- let mut side2: Vec<usize> = Vec::new();- for (k, e) in chain.iter().enumerate() {- let fs = faces_of(e);- let [a, b] = fs[..] else { return Err(unsupported("an edge without two faces")) };- if k == 0 {- side1.push(a);- side2.push(b);- continue;- }- // The side-1 face of this edge is the one whose normal matches side 1 at the joint.- let p = from_p3(e.front().point());- let nrm = |fi: usize| faces.get(fi).and_then(|f| project(f, p, None)).map(|x| x.1);- let prev1 = side1.last().copied().and_then(nrm);- let (na, nb) = (nrm(a), nrm(b));- let a_is_1 = match (prev1, na, nb) {- (Some(x), Some(y), Some(z)) => x.dot(y) >= x.dot(z),- _ => return Err(KernelError::Failed("blend: normals".into())),- };- if a_is_1 {- side1.push(a);- side2.push(b);- } else {- side1.push(b);- side2.push(a);- }- }- let s1: Vec<&mt::Face> = side1.iter().filter_map(|i| faces.get(*i)).collect();- let s2: Vec<&mt::Face> = side2.iter().filter_map(|i| faces.get(*i)).collect();- // The faces the ball may touch near edges `ks` of the chain: their own, on each side. (The- // surface of another face of a side, such as a wall's plane past the bend it runs into,- // may pass nearer than the face the ball actually rolls on.)- let edge_sides = |ks: &[usize]| -> (Vec<&mt::Face>, Vec<&mt::Face>) {- let pick = |side: &[usize]| {- let mut out: Vec<usize> = Vec::new();- for k in ks {- if let Some(fi) = side.get(*k)- && !out.contains(fi)- {- out.push(*fi);- }- }- out.iter().filter_map(|i| faces.get(*i)).collect::<Vec<_>>()- };- (pick(&side1), pick(&side2))- };- // The chain's edges at vertex k.- let vertex_edges = |k: usize| -> Vec<usize> {- if closed {- vec![(k + n - 1) % n, k % n]- } else if k == 0 {- vec![0]- } else if k >= n {- vec![n - 1]- } else {- vec![k - 1, k]- }- };- // Convex or concave, from the first edge as its side-1 face runs it.- let e0 = chain.first().ok_or_else(|| KernelError::Failed("chain".into()))?;- let f1 = s1.first().ok_or_else(|| KernelError::Failed("side".into()))?;- let in_f1 = f1.boundary_iters().into_iter().flatten().find(|e| e.id() == e0.id()).ok_or_else(|| KernelError::Failed("edge use".into()))?;- let (pm, t1) = {- use mt::{BoundedCurve, ParametricCurve};- let c = in_f1.oriented_curve();- let (a, b) = c.range_tuple();- let m = (a + b) * 0.5;- let d = c.der(m);- (from_p3(c.subs(m)), Vec3::new(d.x, d.y, d.z).normalized().ok_or_else(|| KernelError::Failed("tangent".into()))?)- };- let (n1, n2) = match (project(f1, pm, None), s2.first().and_then(|f| project(f, pm, None))) {- (Some(x), Some(y)) => (x.1, y.1),- _ => return Err(KernelError::Failed("blend: normals".into())),- };- // A knife edge (opposite normals): both faces leave the edge along `w`; the second one lies- // below the first (against its outward normal) when the cusp is material, above when it is- // a gap. The cross product of the normals, which tells the other edges apart, is zero here.- let knife = 1.0 + n1.dot(n2) < KNIFE;- // The one radius, where the size is one radius (a chord or a law has none).- let fixed = match size_law {- Size::Constant(r) => Some(r),- _ => None,- };- // The blend's scale where the size itself is not what matters (the knife edge's probe): the- // radius asked for, or the law's middle value.- let scale = match size_law {- Size::Constant(r) | Size::Chord(r) => r,- Size::Law(law) => law.eval(0.5).max(1e-6),- };- let (convex, cusp) = if knife {- let w = n1.cross(t1).normalized().ok_or_else(|| KernelError::Failed("blend: cusp direction".into()))?;- // Second order: from the point of face 1 a little way along `w`, face 2's nearest point.- let probe = project(f1, pm + w * scale, None)- .and_then(|(qa, na, _)| s2.first().and_then(|f| project(f, qa, None)).map(|(qb, _, _)| (qb - qa).dot(na)))- .filter(|depth| depth.abs() > size * 1e-9)- .ok_or_else(|| unsupported("a knife edge whose faces lie flat on each other"))?;- // Whether the chain runs along the edge as face 1 uses it decides which way `w` points- // from the chain's tangent.- (probe < 0.0, if in_f1.front() == e0.front() { 1.0 } else { -1.0 })- } else {- (t1.dot(n1.cross(n2)) > 0.0, 0.0)- };- let sigma = if convex { -1.0 } else { 1.0 };- if n1.dot(n2) > 1.0 - 1e-6 {- return Err(unsupported("blending a smooth edge"));- }- // The chain's arc length, in fractions of its whole, at each station: where the size is one- // radius it is not read, but the sections take their parameter from it all the same.- let tables: Vec<Vec<f64>> = chain.iter().map(|e| edge_lengths(e).unwrap_or_else(|| vec![0.0; LENGTH_STEPS + 1])).collect();- let total: f64 = tables.iter().filter_map(|t| t.last().copied()).sum();- if !matches!(size_law, Size::Constant(_)) && !(total.is_finite() && total > 1e-12) {- return Err(unsupported("a zero-length edge of the chain"));- }- let total = if total > 1e-12 { total } else { 1.0 };- let mut cum: Vec<f64> = Vec::with_capacity(n + 1);- let mut acc = 0.0;- for table in &tables {- cum.push(acc);- acc += table.last().copied().unwrap_or(0.0);- }- cum.push(acc);- // A law that runs around a closed chain meets itself: its two ends must agree there.- if closed- && let Size::Law(law) = size_law- && (law.eval(0.0) - law.eval(1.0)).abs() > 1e-9 * law.radii.iter().copied().fold(1.0_f64, f64::max)- {- return Err(KernelError::Invalid("a closed edge chain runs back into itself: give the same radius law at both ends".into()));- }- // The law's parameter at `along` of edge `k` (its front to its back).- let frac_at = |k: usize, along: f64| -> f64 {- let (Some(table), Some(lo)) = (tables.get(k), cum.get(k)) else { return if k >= n { 1.0 } else { 0.0 } };- let s = sampled(table, along).unwrap_or(0.0);- ((lo + s) / total).clamp(0.0, 1.0)- };- let sizer = Sizer { size: size_law, tol: tol * 100.0 };- // Arcs on a planar side that curve round the ball: its centre runs round them at their- // radius less the blend's. Less than nothing is too large; nothing is a pivot.- let mut pivots: Vec<Option<Pivot>> = vec![None; n];- 'pivots: for (k, e) in chain.iter().enumerate() {- // A size that varies along the edge has no one radius to compare a corner's arc with.- let Some(r) = fixed else { break 'pivots };- let Some((o, rho, _)) = circle_of(e, tol * 1e3) else { continue };- for side in [1, 2] {- let Some(f) = (if side == 1 { side1.get(k) } else { side2.get(k) }).and_then(|i| faces.get(*i)) else { continue };- let mt::Surface::Plane(pl) = f.oriented_surface() else { continue };- let Some(np) = Vec3::new(pl.normal().x, pl.normal().y, pl.normal().z).normalized() else { continue };- // Into the face (left of the edge as the face runs it, about its outward normal).- let Some(used) = f.boundary_iters().into_iter().flatten().find(|x| x.id() == e.id()) else { continue };- let Some((pm, tm)) = ({- use mt::{BoundedCurve, ParametricCurve};- let c = used.oriented_curve();- let (a, b) = c.range_tuple();- let d = c.der((a + b) * 0.5);- Vec3::new(d.x, d.y, d.z).normalized().map(|t| (from_p3(c.subs((a + b) * 0.5)), t))- }) else {- continue;- };- if (o - pm).dot(np.cross(tm)) <= 0.0 {- continue;- }- if rho < r - tol * 1e3 {- return Err(too_large("the blend is larger than a corner radius (site 1257)"));- }- if (rho - r).abs() > tol * 1e3 {- continue;- }- // The ball sits on the planar side at the arc's centre; the other side must be a round- // about the same axis, the ball touching it all along.- let c = o + np * (sigma * r);- let (a1, a2) = edge_sides(&[k]);- let other = if side == 1 { a2 } else { a1 };- let reach = other.iter().filter_map(|f| project(f, c, None)).map(|x| x.0.dist(c)).fold(f64::INFINITY, f64::min);- if (reach - r).abs() <= size * 1e-4 {- if let Some(slot) = pivots.get_mut(k) {- *slot = Some(Pivot { c, o, axis: np, side });- }- break;- }- }- }- if pivots.iter().all(Option::is_some) {- return Err(unsupported("rounding again only rounded corners of the blend's radius"));- }- // Seams at the chain's vertices: edges there that aren't in the chain, and their side.- let chain_ids: Vec<mt::EdgeID> = chain.iter().map(|e| e.id()).collect();- let mut seams: Vec<Vec<(usize, mt::Edge)>> = Vec::with_capacity(nv);- // At an open chain's ends: the end face (planar, square to the edge there).- let mut end_faces: Vec<(usize, usize)> = Vec::new(); // (vertex index, face index)- // A flat strip on planar sides can end across two planar faces (an earlier chamfer).- // Their shared seam is shortened to the crossing of the new chamfer plane.- let mut split_ends: Vec<(usize, usize, usize, mt::Edge)> = Vec::new();- // Chain ends whose end face is not a plane square to the edge: (vertex, face, point, tangent,- // the side (1 or 2) the end face is tangent to when it lies along the edge there).- let mut slanted: Vec<(usize, usize, Vec3, Vec3, Option<u8>)> = Vec::new();- for (k, v) in verts.iter().enumerate() {- let at_end = !closed && (k == 0 || k == nv - 1);- let (k1, k2) = {- let ei = if k == nv - 1 && !closed { n - 1 } else { k.min(n - 1) };- (side1.get(ei).copied().unwrap_or(usize::MAX), side2.get(ei).copied().unwrap_or(usize::MAX))- };- let mut found: Vec<(usize, mt::Edge)> = Vec::new();- for (fi, f) in faces.iter().enumerate() {- if !f.vertex_iter().any(|x| x == *v) {- continue;- }- let on_side = side1.contains(&fi) || side2.contains(&fi);- if !on_side {- if !at_end || end_faces.iter().filter(|(kk, _)| *kk == k).count() >= 2 {- return Err(unsupported("a vertex of the edge chain where other faces meet"));- }- end_faces.push((k, fi));- continue;- }- for x in f.edge_iter() {- if chain_ids.contains(&x.id()) || !(*x.front() == *v || *x.back() == *v) || found.iter().any(|(_, y)| y.id() == x.id()) {- continue;- }- let side = if fi == k1 || (side1.contains(&fi) && fi != k2) { 1 } else { 2 };- found.push((side, x.absolute_clone()));- }- }- if at_end && !end_faces.iter().any(|(kk, _)| *kk == k) {- return Err(unsupported("an open chain of curved edges must end at a face"));- }- let ends: Vec<usize> = end_faces.iter().filter(|(kk, _)| *kk == k).map(|(_, fi)| *fi).collect();- if let [ga, gb] = ends[..] {- let terminal = chain.get(if k == 0 { 0 } else { n - 1 }).ok_or_else(|| unsupported("chain end"))?;- let planar = [ga, gb, k1, k2].iter().all(|i| faces.get(*i).and_then(crate::blend::plane_normal).is_some());- if round || !planar || !straight(terminal, tol * 10.0) {- return Err(unsupported("a vertex of the edge chain where other faces meet"));- }- let shares = |g: usize, side: usize| {- faces- .get(g)- .zip(faces.get(side))- .is_some_and(|(g, s)| g.edge_iter().any(|e| (e.front() == v || e.back() == v) && s.edge_iter().any(|x| x.id() == e.id())))- };- let (ga, gb) = if shares(ga, k1) && shares(gb, k2) {- (ga, gb)- } else if shares(gb, k1) && shares(ga, k2) {- (gb, ga)- } else {- return Err(unsupported("the end faces do not meet both sides of the chain"));- };- let seam = faces- .get(ga)- .and_then(|a| {- faces.get(gb).and_then(|b| a.edge_iter().find(|e| (e.front() == v || e.back() == v) && b.edge_iter().any(|x| x.id() == e.id())))- })- .ok_or_else(|| unsupported("the end faces have no shared seam"))?;- if !straight(&seam, tol * 10.0) {- return Err(unsupported("a curved seam between the end faces"));- }- // The first face is the one reached by side 1's contact.- end_faces.retain(|(kk, _)| *kk != k);- end_faces.extend([(k, ga), (k, gb)]);- split_ends.push((k, ga, gb, seam.absolute_clone()));- }- // At most one seam per side.- if found.iter().filter(|x| x.0 == 1).count() > 1 || found.iter().filter(|x| x.0 == 2).count() > 1 {- return Err(unsupported("a vertex of the edge chain where several seams meet"));- }- seams.push(found);- }- // Sections: at each vertex (a contact on the seam there), then along each edge.- let tangent_at = |e: &mt::Edge, s: f64| -> Option<(Vec3, Vec3)> {- use mt::{BoundedCurve, ParametricCurve};- let c = e.oriented_curve();- let (a, b) = c.range_tuple();- let t = a + (b - a) * s;- let d = c.der(t);- Some((from_p3(c.subs(t)), Vec3::new(d.x, d.y, d.z).normalized()?))- };- let mut vsec: Vec<Section> = Vec::with_capacity(nv);- // The radius each vertex section was solved at (the closed end of a law: zero).- let mut vradius: Vec<f64> = Vec::with_capacity(nv);- for k in 0..nv {- let (p, t) = if k < n {- tangent_at(chain.get(k).ok_or_else(|| KernelError::Failed("edge".into()))?, 0.0)- } else {- tangent_at(chain.get(n - 1).ok_or_else(|| KernelError::Failed("edge".into()))?, 1.0)- }- .ok_or_else(|| KernelError::Failed("tangent".into()))?;- let here = seams.get(k).cloned().unwrap_or_default();- let at_end = end_faces.iter().any(|(kk, _)| *kk == k);- // Next to a pivot the ball is at its centre, touching the other side square above the- // vertex.- let pivoting: Vec<Pivot> = [(k < n).then_some(k), if k > 0 { Some(k - 1) } else { closed.then_some(n - 1) }]- .into_iter()- .flatten()- .filter_map(|i| pivots.get(i).copied().flatten())- .collect();- if let Some(pv) = pivoting.first().copied() {- if at_end || pivoting.iter().any(|x| x.c.dist(pv.c) > tol * 1e3) {- return Err(unsupported("a rounded corner of the blend's radius where the edge chain ends or turns"));- }- let q = pv.c + (p - pv.o);- vsec.push(if pv.side == 1 { Section { c: pv.c, q1: pv.o, q2: q } } else { Section { c: pv.c, q1: q, q2: pv.o } });- vradius.push(fixed.unwrap_or_default());- continue;- }- // The law's parameter at this vertex: the front of its edge, or the back of the last- // edge at an open chain's end.- let law_s = if k < n { frac_at(k, 0.0) } else { frac_at(n - 1, 1.0) };- if at_end {- // A plane square to the edge holds the blend's end section. Any other end face: the- // blend runs on past the end and is cut back where it meets that face.- let (_, fi) = end_faces.iter().find(|(kk, _)| *kk == k).copied().unwrap_or_default();- let g = faces.get(fi).ok_or_else(|| KernelError::Failed("end face".into()))?;- let square = match g.oriented_surface() {- mt::Surface::Plane(pl) => {- let m = pl.normal();- Vec3::new(m.x, m.y, m.z).normalized().is_some_and(|ng| ng.dot(t).abs() >= 1.0 - 1e-6)- }- _ => false,- };- // A radius that has run to zero closes the blend at the vertex itself: it does not run- // on past the end, and the end face keeps the corner it had there.- let closed_end = matches!(size_law, Size::Law(law) if law.eval(law_s) <= CLOSED);- if (!square || split_ends.iter().any(|e| e.0 == k)) && !closed_end {- slanted.push((k, fi, p, t, None));- }- }- let extra = match here.first().filter(|_| !at_end) {- None => None,- // A curved seam holds the contact on itself (the chain runs on smoothly across it: a- // lofted wall's two halves).- Some((side, seam)) if !straight(seam, tol * 10.0) => Some(Extra::Seam(*side, seam)),- Some((side, seam)) => {- let side = *side;- // The plane through the seam square to that side's surface.- let o = from_p3(seam.front().point());- let d = (from_p3(seam.back().point()) - o).normalized().ok_or_else(|| KernelError::Failed("seam".into()))?;- let fs = if side == 1 { &s1 } else { &s2 };- // The side's normal at the joint: from its face nearest the joint (any face of a- // longer side is no guide here).- let nn = fs- .iter()- .filter_map(|f| project(f, p, None))- .min_by(|a, b| a.0.dist(p).total_cmp(&b.0.dist(p)))- .map(|x| x.1)- .ok_or_else(|| KernelError::Failed("seam normal".into()))?;- Some(Extra::Plane(side, o, d.cross(nn).normalized().ok_or_else(|| KernelError::Failed("seam plane".into()))?))- }- };- // On the faces of the edge from this vertex alone (the last edge's at an open chain's- // end): the other edge's faces are untrimmed here and can run on near the ball where it no- // longer is (a wall past the round at a corner, which a ball rolling round it pokes- // through).- let (a1, a2) = edge_sides(&[k.min(n - 1)]);- let (s, r) = sizer.section(&a1, &a2, p, t, law_s, sigma, cusp, extra).ok_or_else(|| sizer.refusal())?;- // A seam on the other side too must pass through that side's contact.- if let Some((side, seam)) = here.get(1).filter(|_| !at_end) {- let q = if *side == 1 { s.q1 } else { s.q2 };- let (a, b) = (from_p3(seam.front().point()), from_p3(seam.back().point()));- if !straight(seam, tol * 10.0) || q.dist_to_segment(a, b) > tol * 1e3 {- return Err(unsupported("seams on both sides of a corner of the edge chain"));- }- }- vsec.push(s);- vradius.push(r);- }- // Past a slanted end: sections of the same rolling ball beyond the end vertex (far to near- // at the chain's start, near to far at its end), far enough to cross the end face.- let mut beyond: Vec<(usize, Vec<Section>, Vec<f64>)> = Vec::new();- for (k, fi, p, t, tangent) in slanted.iter_mut() {- let g = faces.get(*fi).ok_or_else(|| KernelError::Failed("end face".into()))?;- let at = vsec.get(*k).copied().ok_or_else(|| KernelError::Failed("section".into()))?;- let (_, ng, _) = project(g, *p, None).ok_or_else(|| unsupported("the blend's end on its end face"))?;- let cos = split_ends- .iter()- .find(|e| e.0 == *k)- .and_then(|(_, _, gb, _)| faces.get(*gb))- .and_then(crate::blend::plane_normal)- .map_or(ng.dot(*t).abs(), |nb| ng.dot(*t).abs().min(nb.dot(*t).abs()));- // An end face along the edge and tangent to one side there (a wall that runs out into- // the face): the blend meets it along a curve that touches that side's contact at the- // vertex. Any other end face that close to the edge is refused.- let (e1, e2) = edge_sides(&vertex_edges(*k));- *tangent = if cos < TANGENT_END {- [(1u8, &e1), (2u8, &e2)].into_iter().find_map(|(side, faces)| {- faces.iter().filter_map(|f| project(f, *p, None)).any(|(_, n, _)| n.dot(ng).abs() > 1.0 - TANGENT_END).then_some(side)- })- } else {- None- };- if cos < 0.15 && tangent.is_none() {- return Err(unsupported("an end face almost along the edge"));- }- let width = at.q1.dist(*p).max(at.q2.dist(*p)).max(at.c.dist(*p)) + vradius.get(*k).copied().unwrap_or(scale);- let reach = 1.5 * width / if tangent.is_some() { 1.0 } else { cos };- let out = if *k == 0 { -*t } else { *t };- // The run on past the end only gives the fit its context (the end face cuts it back), but- // it keeps the law's end slope: the radius is read at the distance past the end.- let law_s = |d: f64| if *k == 0 { -d / total } else { 1.0 + d / total };- // Past a tangent end the straight run along the tangent leaves the curved spine: where- // the ball no longer fits, the run is shortened (it only gives the fit its context).- let mut list = Vec::with_capacity(EXTENSION);- let mut laws = Vec::with_capacity(EXTENSION);- let mut reach = reach;- // Past the end of a curved edge the planes square to its end tangent cut the ring of- // centres further and further round it, until a step jumps across the ring (#1255: a- // knuckle's cap circle with a round as wide as 0.7 of its radius). The run is shortened- // then, as long as one of its sections still lies wholly past the end face.- let ng_out = if ng.dot(out) < 0.0 { -ng } else { ng };- let past = |sec: &Section| [sec.c, sec.q1, sec.q2].iter().all(|x| (*x - *p).dot(ng_out) > tol);- // A run shortened when its centres jump across the ring (a knuckle's cap circle, #1255)- // stands if no full-length run works; a size law's own end slope is read at each station's- // distance past the end.- let mut fallback: Option<Vec<(f64, Section)>> = None;- for attempt in 0..TANGENT_RETRIES {- list.clear();- laws.clear();- let step = reach / EXTENSION as f64;- let sections = (1..=EXTENSION).map(|j| {- let d = step * j as f64;- let anchor = *p + out * d;- let s = law_s(d);- sizer.section(&e1, &e2, anchor, *t, s, sigma, cusp, None).map(|(section, _)| (s, section))- });- match sections.collect::<Option<Vec<_>>>() {- Some(all) => {- let smooth = tangent.is_some()- || std::iter::once(at.c).chain(all.iter().map(|(_, s)| s.c)).collect::<Vec<_>>().windows(2).all(|w| match w {- [a, b] => a.dist(*b) <= MAX_STEP_STRETCH * step,- _ => true,- });- if smooth {- // A shortened run must still cross the end face; else the first,- // full-length run stands.- if fallback.is_none() || all.iter().any(|(_, s)| past(s)) {- list = all.iter().map(|(_, s)| *s).collect();- laws = all.iter().map(|(s, _)| *s).collect();- }- break;- }- fallback.get_or_insert(all);- }- None if tangent.is_none() || fallback.is_some() || attempt + 1 == TANGENT_RETRIES => break,- None => {}- }- reach *= if tangent.is_some() { 0.5 } else { 0.75 };- }- if list.is_empty() {- match fallback {- // The shortened run stands when the ring's step jumped, whatever its size.- Some(all) => {- list = all.iter().map(|(_, s)| *s).collect();- laws = all.iter().map(|(s, _)| *s).collect();- }- // A size asked for beyond what the faces around the end hold is refused as such;- // one radius past the end is the rolling ball's own failure to fit.- None => {- return Err(match size_law {- Size::Constant(_) => unsupported("the ball doesn't fit past the end of the edge"),- _ => too_large("the blend is larger than the neighbouring faces (site 1472)"),- });- }- }- }- if *k == 0 {- list.reverse();- laws.reverse();- }- beyond.push((*k, list, laws));- }- // Uniform refinement preserves a common spacing across neighbouring patches. Work is- // capped: a difficult strip returns an error instead of accepting an inaccurate fit.- let fit_tolerance = (size * 1e-5).clamp(1e-5, 0.001);- // At a seam the contact lies on the seam plane, which need not be square to the- // original edge. Its ball centre therefore need not lie in the edge's normal plane.- // Interpolate that plane's displacement so the interior sections tend to the exact- // seam sections, rather than leaving a finite jump as sampling gets finer.- let offsets: Vec<(f64, f64)> = chain- .iter()- .enumerate()- .map(|(k, edge)| {- let (p0, t0) = tangent_at(edge, 0.0).ok_or_else(|| KernelError::Failed("tangent".into()))?;- let (p1, t1) = tangent_at(edge, 1.0).ok_or_else(|| KernelError::Failed("tangent".into()))?;- let start = vsec.get(k).ok_or_else(|| KernelError::Failed("section".into()))?;- let end = vsec.get((k + 1) % nv).ok_or_else(|| KernelError::Failed("section".into()))?;- Ok(((start.c - p0).dot(t0), (end.c - p1).dot(t1)))- })- .collect::<Result<_>>()?;- let section_at = |k: usize, edge: &mt::Edge, along: f64| -> Result<(Section, f64)> {- let (p, t) = tangent_at(edge, along).ok_or_else(|| KernelError::Failed("tangent".into()))?;- let (start, end) = offsets.get(k).copied().ok_or_else(|| KernelError::Failed("section offset".into()))?;- let anchor = p + t * (start * (1.0 - along) + end * along);- let (a1, a2) = edge_sides(&[k]);- sizer.section(&a1, &a2, anchor, t, frac_at(k, along), sigma, cusp, None).ok_or_else(|| sizer.refusal())- };- let mut samples = SAMPLES.min(max_samples);- let (esec, fits) = loop {- if n.checked_mul(samples).is_none_or(|count| count > MAX_CHAIN_SAMPLES) {- return Err(unsupported("curve blend exceeds the section fitting limit"));- }- // No guide along a pivot: its sections are the two at its ends.- let mut guides: Vec<Option<Guide>> = Vec::with_capacity(n);- for (k, e) in chain.iter().enumerate() {- if pivots.get(k).copied().flatten().is_some() {- guides.push(None);- continue;- }- let mut list = vec![*vsec.get(k).ok_or_else(|| KernelError::Failed("section".into()))?];- let mut law = vec![frac_at(k, 0.0)];- let (mut front_beyond, mut back_beyond) = (0usize, 0usize);- for j in 1..samples - 1 {- let along = j as f64 / (samples - 1) as f64;- let (section, _) = section_at(k, e, along)?;- list.push(section);- law.push(frac_at(k, along));- }- list.push(*vsec.get((k + 1) % nv).ok_or_else(|| KernelError::Failed("section".into()))?);- law.push(frac_at(k, 1.0));- for (kv, ext, exts) in &beyond {- if *kv == k && k == 0 {- list.splice(0..0, ext.iter().copied());- law.splice(0..0, exts.iter().copied());- front_beyond = ext.len();- } else if *kv == k + 1 && k + 1 == nv - 1 {- list.extend(ext.iter().copied());- law.extend(exts.iter().copied());- back_beyond = ext.len();- }- }- let mut guide = Guide::with_law(list, law)?;- // The chain's own run: the spliced sections at either end are context for the fit- // only (the blend is cut back where it meets the end face there).- let last = guide.lengths.last().copied().unwrap_or(0.0);- let at = |i: usize| if last > 0.0 { guide.lengths.get(i).copied().unwrap_or(0.0) / last } else { 0.0 };- guide.span = (at(front_beyond), at(guide.sections.len().saturating_sub(1 + back_beyond)));- guides.push(Some(guide));- }- // Intersection curves inherit their leader's piecewise parameter speed. Fitting- // those parameters creates oscillations even on a geometrically smooth spine.- // Resample by distance along the rolling centres, projecting each interpolated- // centre back onto the exact two offset surfaces before it becomes a section.- let uniform_section = |k: usize, along: f64| -> Result<Section> {- let guide = guides.get(k).and_then(Option::as_ref).ok_or_else(|| KernelError::Failed("spine guide".into()))?;- if along == 0.0 {- return guide.sections.first().copied().ok_or_else(|| KernelError::Failed("section".into()));- }- if along == 1.0 {- return guide.sections.last().copied().ok_or_else(|| KernelError::Failed("section".into()));- }- let (anchor, tangent, law_s) = guide.anchor_at(along).ok_or_else(|| unsupported("degenerate rolling-ball spine"))?;- let (a1, a2) = edge_sides(&[k]);- sizer- .section(&a1, &a2, anchor, tangent, law_s, sigma, cusp, None)- .map(|(section, _)| section)- .ok_or_else(|| unsupported("the ball doesn't fit along the resampled spine"))- };- let esec: Vec<Vec<Section>> = (0..n)- .map(|k| match guides.get(k) {- Some(Some(_)) => (0..samples).map(|j| uniform_section(k, j as f64 / (samples - 1) as f64)).collect::<Result<Vec<_>>>(),- _ => Ok(vec![- *vsec.get(k).ok_or_else(|| KernelError::Failed("section".into()))?,- *vsec.get((k + 1) % nv).ok_or_else(|| KernelError::Failed("section".into()))?,- ]),- })- .collect::<Result<_>>()?;- // Each strip's neighbouring sections at its own spacing (edges of different lengths- // have differently spaced samples, which makes a uniform interpolation overshoot).- let length = |k: usize| guides.get(k).and_then(Option::as_ref).and_then(|g| g.lengths.last().copied()).unwrap_or(0.0);- let rolls = |k: usize| guides.get(k).is_some_and(Option::is_some);- let mut fits: Vec<Option<Fit>> = Vec::with_capacity(n);- for k in 0..n {- // A pivot's surface is made whole (`revolve`); a strip next to one ends on the joint's- // section on its own.- if !rolls(k) {- fits.push(None);- continue;- }- let h = length(k) / (samples - 1) as f64;- // A neighbour shorter than two of the strip's steps lends none: its own sections are- // spaced far closer (a small round beside a long line), and borrowing them made the- // strip overshoot and fold back on itself past the joint, which its faces' meshes- // then folded with (#1667). The strip ends on the joint's section on its own.- let spaced = |nb: usize, from_end: bool| -> Result<Vec<Section>> {- let l = length(nb);- if !(l > 2.0 * h && h > 0.0) {- return Ok(Vec::new());- }- let mut out = Vec::with_capacity(2);- for j in [1.0, 2.0] {- out.push(uniform_section(nb, if from_end { 1.0 - j * h / l } else { j * h / l })?);- }- if from_end {- out.reverse();- }- Ok(out)- };- let (prev, next) = ((k + n - 1) % n, (k + 1) % n);- let list = esec.get(k).ok_or_else(|| KernelError::Failed("section".into()))?;- // Not across a joint where the strip's curvature jumps (a line or a wide arc into a- // small round): a spline smooth through it spreads the jump over the sections beside- // it, and the error falls only with the square of their spacing. The strip then ends- // on the joint's section on its own, which the next one shares.- let smooth = |near: [Option<&Section>; 3], beyond: [Option<&Section>; 3]| match (near, beyond) {- ([Some(a), Some(b), Some(c)], [Some(x), Some(y), Some(z)]) => !bends([a, b, c], [x, y, z], fit_tolerance),- _ => false,- };- let before = match (closed || k > 0) && rolls(prev) {- true => {- let b = spaced(prev, true)?;- if smooth([list.first(), list.get(1), list.get(2)], [list.first(), b.get(1), b.first()]) { b } else { Vec::new() }- }- false => Vec::new(),- };- let after = match (closed || k + 1 < n) && rolls(next) {- true => {- let a = spaced(next, false)?;- let m = list.len();- let tail = [list.last(), m.checked_sub(2).and_then(|i| list.get(i)), m.checked_sub(3).and_then(|i| list.get(i))];- if smooth(tail, [list.last(), a.first(), a.get(1)]) { a } else { Vec::new() }- }- false => Vec::new(),- };- let mut fit = crate::guard("fit curve blend", || fit_strip(list, &before, &after, round))?;- fit.span = guides.get(k).and_then(Option::as_ref).map(|g| g.span).unwrap_or((0.0, 1.0));- fits.push(Some(fit));- }- let mut accurate = true;- 'edges: for k in 0..n {- let Some(Some(fit)) = fits.get(k) else { continue };- for j in 0..samples - 1 {- for fraction in [0.25, 0.5, 0.75] {- let along = (j as f64 + fraction) / (samples - 1) as f64;- // A size that varies along the edge reaches past its ends only for the fit's- // context (the end face cuts that away), so it is not held to the tolerance- // there. One radius keeps the check it always had, the whole strip.- if !matches!(size_law, Size::Constant(_))- && fits.get(k).and_then(Option::as_ref).is_some_and(|f| along < f.span.0 || along > f.span.1)- {- continue;- }- let section = uniform_section(k, along)?;- if !crate::guard("check curve blend fit", || Ok(section_fits(fit, §ion, along, round, sigma, fit_tolerance)))? {- accurate = false;- break 'edges;- }- }- }- }- if accurate {- break (esec, fits);- }- if samples >= max_samples {- return Err(KernelError::Failed("curve blend: could not fit the rolling-ball surface within the accuracy and section limits".into()));- }- samples = (2 * samples - 1).min(max_samples);- };- // Where each extended blend meets its slanted end face: (vertex, edge, cut parameters of- // the two contacts, the end curve from contact 1 to contact 2).- let mut caps: Vec<(usize, usize, f64, f64, mt::Curve)> = Vec::new();- let mut split_caps: Vec<(usize, mt::Edge, Vec3)> = Vec::new();- for (k, fi, _, _, tangent) in &slanted {- let ke = if *k == 0 { 0 } else { n - 1 };- let fit = fits.get(ke).and_then(Option::as_ref).ok_or_else(|| KernelError::Failed("curve blend fit".into()))?;- let g = faces.get(*fi).ok_or_else(|| KernelError::Failed("end face".into()))?;- let at = vsec.get(*k).copied().ok_or_else(|| KernelError::Failed("section".into()))?;- let seam = |s: u8| seams.get(*k).and_then(|l| l.iter().find(|(x, _)| *x as u8 == s)).map(|(_, e)| e);- let both = [seam(1), seam(2)];- if let Some((_, ga, gb, middle)) = split_ends.iter().find(|e| e.0 == *k) {- use mt::{BSplineCurve, KnotVec, ParametricCurve, SearchNearestParameter};- let fail = || unsupported("the chamfer does not cross both end faces");- let p = from_p3(verts.get(*k).ok_or_else(fail)?.point());- let (_, t) = tangent_at(chain.get(ke).ok_or_else(fail)?, if *k == 0 { 0.0 } else { 1.0 }).ok_or_else(fail)?;- let hit = |q: Vec3, fi: usize| -> Option<Vec3> {- let normal = faces.get(fi).and_then(crate::blend::plane_normal)?;- let den = normal.dot(t);- (den.abs() > 1e-6).then(|| q - t * (normal.dot(q - p) / den))- };- let a = hit(at.q1, *ga).ok_or_else(fail)?;- let b = hit(at.q2, *gb).ok_or_else(fail)?;- let m = (at.q2 - at.q1).cross(t).normalized().ok_or_else(fail)?;- let far = if middle.front() == verts.get(*k).ok_or_else(fail)? { middle.back() } else { middle.front() };- let u = from_p3(far.point()) - p;- let den = m.dot(u);- if den.abs() < tol {- return Err(fail());- }- let fraction = m.dot(at.q1 - p) / den;- let c = p + u * fraction;- let across = (c - at.q1).dot(at.q2 - at.q1) / (at.q2 - at.q1).len2();- if !(fraction > 1e-6 && fraction < 1.0 - 1e-6 && across > 1e-6 && across < 1.0 - 1e-6) {- return Err(fail());- }- let parameter = |row: usize, q: Vec3| -> Option<f64> {- let curve = fit.contacts.get(row)?;- let v = curve.search_nearest_parameter(p3(q), None, 100)?;- (v > fit.range.0 + 1e-6 && v < fit.range.1 - 1e-6 && from_p3(curve.subs(v)).dist(q) <= fit_tolerance).then_some(v)- };- let (ta, tb) = (parameter(0, a).ok_or_else(fail)?, parameter(1, b).ok_or_else(fail)?);- let curve = BSplineCurve::try_new(KnotVec::from(vec![0.0, 0.0, 0.5, 1.0, 1.0]), vec![p3(a), p3(c), p3(b)])- .map_err(|e| KernelError::Failed(format!("chamfer end: {e}")))?;- caps.push((*k, ke, ta, tb, mt::Curve::BSplineCurve(curve)));- split_caps.push((*k, middle.clone(), c));- continue;- }- let cap = crate::guard("curve blend end", || match tangent {- Some(side) => tangent_cap(fit, g, *side, both, fit_tolerance),- None => end_cap(fit, g, &at, both, round, fit_tolerance),- })?;- caps.push((*k, ke, cap.0, cap.1, cap.2));- }- // Both ends of one edge cut back: the contacts must keep a piece between them.- if let [(_, 0, s1, s2, _), (_, 0, e1, e2, _)] = &caps[..]- && n == 1- && !(s1 + 1e-6 < *e1 && s2 + 1e-6 < *e2)- {- return Err(too_large("the blend is larger than the neighbouring faces (site 1668)"));- }- crate::guard("curve blend", || {- let fail = |m: &str| KernelError::Failed(format!("curve blend: {m}"));- // Vertices and arcs at the chain's vertices.- let mut v1: Vec<mt::Vertex> = vsec.iter().map(|s| builder::vertex(p3(s.q1))).collect();- let mut v2: Vec<mt::Vertex> = vsec.iter().map(|s| builder::vertex(p3(s.q2))).collect();- for (k, _, _, _, curve) in &caps {- use mt::{BoundedCurve, ParametricCurve};- let (lo, hi) = curve.range_tuple();- if let (Some(a), Some(b)) = (v1.get_mut(*k), v2.get_mut(*k)) {- *a = builder::vertex(curve.subs(lo));- *b = builder::vertex(curve.subs(hi));- }- }- // A closed section (a radius that has run to zero) has one vertex for both contacts, so- // the blend face's wire and the side faces' meet there.- for (k, s) in vsec.iter().enumerate() {- if !closed_section(s) {- continue;- }- if let Some(v) = v1.get(k).cloned()- && let Some(slot) = v2.get_mut(k)- {- *slot = v;- }- }- // Along a pivot the planar side's contact is one point: one vertex at both its ends.- for (k, pv) in pivots.iter().enumerate() {- let Some(pv) = pv else { continue };- let vs = if pv.side == 1 { &mut v1 } else { &mut v2 };- if let Some(v) = vs.get(k).cloned()- && let Some(slot) = vs.get_mut((k + 1) % nv)- {- *slot = v;- }- }- // A chain end (a cap, or the section at a square end) on the far end of its seam uses that- // seam up: that vertex is the end.- let mut consumed: HashMap<mt::EdgeID, mt::Vertex> = HashMap::new();- for (k, _) in &end_faces {- for (side, seam) in seams.get(*k).into_iter().flatten() {- let Some(old) = verts.get(*k) else { continue };- let far = if seam.front() == old { seam.back() } else { seam.front() };- let slot = if *side == 1 { v1.get_mut(*k) } else { v2.get_mut(*k) };- if let Some(nv) = slot- && far != old- && from_p3(far.point()).dist(from_p3(nv.point())) <= fit_tolerance- {- *nv = far.clone();- consumed.insert(seam.id(), far.clone());- }- }- }- // The section's own radius, where the blend is sized by a law or a chord width (`r` is the- // one radius of a constant blend, exactly as before).- let rad = |s: &Section| match size_law {- Size::Constant(r) => r,- Size::Chord(_) | Size::Law(_) => s.c.dist(s.q1),- };- let mut arcs: Vec<Option<mt::Edge>> = Vec::with_capacity(nv);- let mut split_arcs: HashMap<usize, Vec<mt::Edge>> = HashMap::new();- for (k, s) in vsec.iter().enumerate() {- let (a, b) = (v1.get(k).ok_or_else(|| fail("vertex"))?, v2.get(k).ok_or_else(|| fail("vertex"))?);- // A closed section has no arc to run between the contacts: the blend meets itself- // there, at the edge's end point.- let e = if closed_section(s) {- None- } else if round {- let m = s.c + ((s.q1 - s.c) + (s.q2 - s.c)).normalized().ok_or_else(|| fail("arc"))? * rad(s);- Some(builder::circle_arc(a, b, p3(m)))- } else {- Some(builder::line(a, b))- };- let e = match caps.iter().find(|c| c.0 == k) {- Some((_, _, _, _, curve)) => Some(mt::Edge::try_new(a, b, curve.clone()).map_err(|e| fail(&e.to_string()))?),- None => e,- };- if let Some((_, _, c)) = split_caps.iter().find(|cap| cap.0 == k) {- let v = builder::vertex(p3(*c));- split_arcs.insert(k, vec![builder::line(a, &v), builder::line(&v, b)]);- }- arcs.push(e);- }- // Outward: toward the ball centre on a concave edge, away on a convex one.- let oriented = |mut surface: mt::Surface, list: &[Section]| -> Result<mt::Surface> {- use mt::{ParametricSurface3D, SearchNearestParameter};- let s = list.get(list.len() / 2).ok_or_else(|| fail("section"))?;- let mid = s.c + ((s.q1 - s.c) + (s.q2 - s.c)).normalized().ok_or_else(|| fail("mid"))? * rad(s);- if let Some((u, v)) = surface.search_nearest_parameter(p3(mid), None, 100) {- let nn = surface.normal(u, v);- let want = (s.c - mid) * sigma;- if Vec3::new(nn.x, nn.y, nn.z).dot(want) < 0.0 {- surface = mt::Invertible::inverse(&surface);- }- }- Ok(surface)- };- // Contact curves and blend faces per edge.- // (None: the planar side's contact along a pivot, a point.)- let mut c1: Vec<Option<mt::Edge>> = Vec::with_capacity(n);- let mut c2: Vec<Option<mt::Edge>> = Vec::with_capacity(n);- let mut blends: Vec<mt::Surface> = Vec::with_capacity(n);- for (k, list) in esec.iter().enumerate() {- let k1 = (k + 1) % nv;- let (a1, b1, a2, b2) = (v1.get(k), v1.get(k1), v2.get(k), v2.get(k1));- let (Some(a1), Some(b1), Some(a2), Some(b2)) = (a1, b1, a2, b2) else { return Err(fail("vertex")) };- if let Some(pv) = pivots.get(k).copied().flatten() {- // The section at the start turned about the axis to the one at the end; the other- // side's contact is the circle its end runs on.- let (s0, s1e) = (list.first().ok_or_else(|| fail("section"))?, list.last().ok_or_else(|| fail("section"))?);- let (qa, qb) = if pv.side == 1 { (s0.q2, s1e.q2) } else { (s0.q1, s1e.q1) };- let (a, b) = (qa - pv.c, qb - pv.c);- let angle = pv.axis.dot(a.cross(b)).atan2(a.dot(b));- let (sn, cs) = (angle / 2.0).sin_cos();- let mid = pv.c + a * cs + pv.axis.cross(a) * sn + pv.axis * (pv.axis.dot(a) * (1.0 - cs));- let surface = section_controls(s0, round).and_then(|ctrl| revolve(ctrl, pv.c, pv.axis, angle)).ok_or_else(|| fail("pivot"))?;- let (from, to) = if pv.side == 1 { (a2, b2) } else { (a1, b1) };- let arc = builder::circle_arc(from, to, p3(mid));- let (e1, e2) = if pv.side == 1 { (None, Some(arc)) } else { (Some(arc), None) };- c1.push(e1);- c2.push(e2);- blends.push(oriented(surface, list)?);- continue;- }- let fit = fits.get(k).and_then(Option::as_ref).ok_or_else(|| fail("fit"))?;- let [cv1, cv2] = &fit.contacts;- // Contacts past a slanted end stop at the end curve.- let (mut cv1, mut cv2) = (cv1.clone(), cv2.clone());- for (kv, _, t1, t2, _) in caps.iter().filter(|c| c.1 == k) {- use mt::Cut;- if *kv == k + 1 {- let _ = cv1.cut(*t1);- let _ = cv2.cut(*t2);- }- }- for (kv, _, t1, t2, _) in caps.iter().filter(|c| c.1 == k) {- use mt::Cut;- if *kv == k && k == 0 {- cv1 = cv1.cut(*t1);- cv2 = cv2.cut(*t2);- }- }- c1.push(Some(mt::Edge::new(a1, b1, cv1)));- c2.push(Some(mt::Edge::new(a2, b2, cv2)));- blends.push(oriented(fit.surface.clone(), list)?);- }- // Rebuild the side faces: chain edges become contact curves, seams start at contacts.- let mut subst: HashMap<mt::EdgeID, (Option<mt::Edge>, Option<mt::Edge>)> = HashMap::new();- for (k, e) in chain.iter().enumerate() {- let (Some(x), Some(y)) = (c1.get(k), c2.get(k)) else { return Err(fail("contact")) };- subst.insert(e.id(), (x.clone(), y.clone()));- }- // Seams get new ends at the contacts (an edge between two chain vertices at both).- let mut ends: HashMap<mt::EdgeID, (mt::Edge, Option<mt::Vertex>, Option<mt::Vertex>)> = HashMap::new();- for (k, sm) in seams.iter().enumerate().flat_map(|(k, l)| l.iter().map(move |x| (k, x))) {- let (side, seam) = sm;- let v = verts.get(k).cloned().ok_or_else(|| fail("vertex"))?;- let nv = if *side == 1 { v1.get(k) } else { v2.get(k) }.ok_or_else(|| fail("vertex"))?.clone();- let slot = ends.entry(seam.id()).or_insert_with(|| (seam.clone(), None, None));- if *seam.front() == v {- slot.1 = Some(nv);- } else {- slot.2 = Some(nv);- }- }- let mut seam_subst: HashMap<mt::EdgeID, mt::Edge> = HashMap::new();- for (k, seam, _) in &split_caps {- let old = verts.get(*k).ok_or_else(|| fail("end vertex"))?;- let v = split_arcs.get(k).and_then(|es| es.first()).map(|e| e.back()).ok_or_else(|| fail("end seam"))?;- seam_subst.insert(seam.id(), crate::blend::retarget(seam, old, v, fit_tolerance)?);- }- for (id, (seam, a, b)) in ends {- if consumed.contains_key(&id) {- continue;- }- // At an end of an open chain the blend may stop past the seam's old end (a slanted end- // face, or one turning back past the side, as a box side beside a boss joined to it):- // the seam then runs on along its line or circle, within its planar face.- let one_end = match (&a, &b) {- (Some(nv), None) => Some((seam.front().clone(), nv.clone())),- (None, Some(nv)) => Some((seam.back().clone(), nv.clone())),- _ => None,- };- if let Some((old, nv)) = one_end- && end_faces.iter().any(|(k, _)| verts.get(*k) == Some(&old))- {- let on_tol = (size * 1e-5).max(1e-6);- let q = from_p3(nv.point());- if crate::blend::on_edge(&seam, q, on_tol).is_none() {- let fits = faces- .iter()- .filter(|f| f.edge_iter().any(|e| e.id() == id))- .any(|f| crate::blend::plane_normal(f).is_some() && crate::blend::extension_fits(f, from_p3(old.point()), q, tol));- if !fits || !crate::blend::on_extension(&seam, q, on_tol) {- return Err(too_large("the blend is larger than the neighbouring faces (site 1853)"));- }- }- seam_subst.insert(id, crate::blend::retarget(&seam, &old, &nv, on_tol)?);- continue;- }- if !matches!(seam.curve(), mt::Curve::Line(_)) {- seam_subst.insert(id, trim_curved_seam(&seam, a, b, size)?);- continue;- }- // The new ends must stay on the seam, in order, short of each other.- let (p0, p1) = (from_p3(seam.front().point()), from_p3(seam.back().point()));- let at = |v: &mt::Vertex| {- let q = from_p3(v.point());- let d = p1 - p0;- ((q - p0).dot(d) / d.len2().max(1e-300), (q - p0 - d * ((q - p0).dot(d) / d.len2().max(1e-300))).len())- };- let (ta, oa) = a.as_ref().map(at).unwrap_or((0.0, 0.0));- let (tb, ob) = b.as_ref().map(at).unwrap_or((1.0, 0.0));- if oa > size * 1e-5 || ob > size * 1e-5 || ta < -1e-9 || tb > 1.0 + 1e-9 || tb - ta < 1e-6 {- return Err(too_large("the blend is larger than the neighbouring faces (site 1873)"));- }- let a = a.unwrap_or_else(|| seam.front().clone());- let b = b.unwrap_or_else(|| seam.back().clone());- seam_subst.insert(id, builder::line(&a, &b));- }- let mut out: Vec<mt::Face> = Vec::new();- let mut rec = Rebuild::default();- rec.pieces(&seam_subst);- for (fi, f) in faces.iter().enumerate() {- let corners: Vec<usize> = end_faces.iter().filter(|(_, g)| *g == fi).map(|(k, _)| *k).collect();- if !corners.is_empty() {- if corners.iter().any(|k| split_arcs.contains_key(k)) {- let connectors: Vec<mt::Edge> = corners- .iter()- .flat_map(|k| split_arcs.get(k).cloned().unwrap_or_else(|| arcs.get(*k).cloned().flatten().into_iter().collect()))- .collect();- let rebuilt = crate::blend::rebuild_face(f, &seam_subst, &connectors)?;- rec.face(&rebuilt, f);- out.push(rebuilt);- continue;- }- // The end face (one or both ends of the chain): its two edges at a chain end now- // stop at the contacts, with the blend's end arc between them.- let mut wires = Vec::new();- for w in f.absolute_boundaries() {- let mut es: Vec<mt::Edge> = Vec::new();- for e in w.edge_iter() {- let ne = match seam_subst.get(&e.id()) {- Some(s) => {- if e.front() == e.absolute_front() {- s.clone()- } else {- s.inverse()- }- }- None => e.clone(),- };- // Arriving at an old corner: continue along that end's arc. A seam the- // blend used up is left out, and the arc starts at its far end.- let arrives = corners.iter().copied().find(|k| verts.get(*k).is_some_and(|v| *e.back() == *v));- let used_up = consumed.contains_key(&e.id());- if !used_up {- es.push(ne.clone());- }- if let Some(k) = arrives {- // A closed section has no blend arc at the corner: the blend ends at- // the vertex itself and the end face keeps the corner it had.- let (Some(arc), Some(a1), Some(a2)) = (arcs.get(k).and_then(Option::as_ref), v1.get(k), v2.get(k)) else {- continue;- };- let to = if used_up { e.front() } else { ne.back() };- let corner = if to == a1 {- arc.clone()- } else if to == a2 {- arc.inverse()- } else {- return Err(fail("end face corner"));- };- es.push(corner);- }- }- wires.push(mt::Wire::from(es));- }- let rebuilt = crate::heal::absolute_face(f, wires).ok_or_else(|| fail("an end face could not be rebuilt"))?;- rec.face(&rebuilt, f);- out.push(rebuilt);- continue;- }- let on1 = side1.contains(&fi);- let on2 = side2.contains(&fi);- if !on1 && !on2 && !f.edge_iter().any(|e| seam_subst.contains_key(&e.id())) {- out.push(f.clone());- continue;- }- let mut wires = Vec::new();- for w in f.absolute_boundaries() {- let mut es = Vec::new();- for e in w.edge_iter() {- let ne = if let Some((x, y)) = subst.get(&e.id()) {- // A point along a pivot: the contacts beside it meet there.- let Some(base) = (if on1 { x } else { y }) else { continue };- // Same direction as the chain edge, or reversed.- let chain_e = chain.iter().find(|c| c.id() == e.id()).ok_or_else(|| fail("edge"))?;- if e.front() == chain_e.front() { base.clone() } else { base.inverse() }- } else if let Some(s) = seam_subst.get(&e.id()) {- if e.front() == e.absolute_front() { s.clone() } else { s.inverse() }- } else if consumed.contains_key(&e.id()) {- continue;- } else {- e.clone()- };- es.push(ne);- }- if collapsed_boundary(&es, fit_tolerance) {- return Err(too_large("the blend would consume a neighbouring face"));- }- wires.push(mt::Wire::from(es));- }- let rebuilt = crate::heal::absolute_face(f, wires).ok_or_else(|| fail("a side face could not be rebuilt"))?;- rec.face(&rebuilt, f);- out.push(rebuilt);- }- // Blend faces: each runs its side-1 contact the other way from side 1's face.- for (k, bf) in blends.iter().enumerate() {- let (Some(e1), Some(e2)) = (c1.get(k), c2.get(k)) else {- return Err(fail("blend"));- };- let ak = arcs.get(k).and_then(Option::as_ref);- let ak1 = arcs.get((k + 1) % nv).and_then(Option::as_ref);- let f1i = side1.get(k).ok_or_else(|| fail("side"))?;- let f1 = faces.get(*f1i).ok_or_else(|| fail("side"))?;- let chain_e = chain.get(k).ok_or_else(|| fail("edge"))?;- let used_fwd = f1- .boundary_iters()- .into_iter()- .flatten()- .find(|e| e.id() == chain_e.id())- .map(|e| e.front() == chain_e.front())- .ok_or_else(|| fail("edge use"))?;- // Side 1 runs the contact forward (as the chain) when it ran the edge forward.- // A pivot's planar contact is a point: three sides. A closed section has no arc: two.- let edges: Vec<mt::Edge> = if used_fwd {- [e1.as_ref().map(|e| e.inverse()), ak.cloned(), e2.clone(), ak1.map(|e| e.inverse())]- } else {- [e1.clone(), ak1.cloned(), e2.as_ref().map(|e| e.inverse()), ak.map(|e| e.inverse())]- }- .into_iter()- .flatten()- .collect();- // An arc the chamfer crossed is two lines through the crossing: the blend meets the- // shortened seam there.- let wire: mt::Wire = edges- .into_iter()- .flat_map(|e| {- let split = [(k, ak), ((k + 1) % nv, ak1)]- .into_iter()- .filter_map(|(i, arc)| arc.map(|arc| (i, arc.clone())))- .find(|(_, arc)| arc.id() == e.id())- .and_then(|(i, arc)| split_arcs.get(&i).map(|parts| (arc, parts)));- match split {- Some((arc, parts)) if e.orientation() == arc.orientation() => parts.clone(),- Some((_, parts)) => parts.iter().rev().map(|p| p.inverse()).collect(),- None => vec![e],- }- })- .collect();- let face = mt::Face::try_new(vec![wire], bf.clone()).map_err(|e| fail(&e.to_string()))?;- rec.blend(&face, [chain_e.id()]);- out.push(face);- }- let mut shells = solid.boundaries().clone();- if let Some(sh) = shells.get_mut(si) {- *sh = out.into();- }- Ok((Solid::try_new(shells).map_err(|e| fail(&format!("invalid solid: {e}")))?, rec))- })-}--#[path = "curvecorner.rs"]-mod corner;-pub(crate) use corner::{corner_blend_style, param_on};-// The planar corner builder the G2 corner work left in place of `corner_blend_style`'s sphere.-#[allow(unused_imports)]-pub(crate) use corner::corner_blend;--#[cfg(test)]-#[path = "curveblend_tests.rs"]-mod tests;--#[cfg(test)]-#[path = "curveblend_law_tests.rs"]-mod law_tests;diff --git a/crates/kernel/src/curveblend_law_tests.rs b/crates/kernel/src/curveblend_law_tests.rsdeleted file mode 100644index 44495a1475..0000000000--- a/crates/kernel/src/curveblend_law_tests.rs+++ /dev/null@@ -1,315 +0,0 @@-//! Chord-width and radius-law blends along curved edges: the width across the blend at every-//! station, and the radius along the edge, measured on the body the kernel built against values-//! worked out from the input geometry alone (the two cylinders' axes, the arc's axis).--use mt::{BoundedCurve, ParametricCurve, SearchNearestParameter};-use solidcraft_geom::Vec3;--use super::*;-use crate::blend::vtx;-use crate::blend_variable::{RadiusSpline, fillet_chord, fillet_variable, fillet_variable_points, fillet_variable_spline};-use crate::{Body, BoolOp, boolean, box_solid, cylinder, fillet, measure, step_export};--/// An oblique boss: a rod of radius 8 whose axis leans 26.57° from the plate's normal, standing on-/// a 5 mm plate. The edge where its side meets the plate's top plane is an ellipse whose two faces-/// run from 63° to 117° apart around it.-fn oblique_boss() -> (Body, Vec3, Vec3) {- let plate = box_solid(Vec3::new(-40.0, -40.0, 0.0), Vec3::new(40.0, 40.0, 5.0)).unwrap();- let base = Vec3::new(0.0, 0.0, -10.0);- let axis = Vec3::new(0.5, 0.0, 1.0).normalized().unwrap();- let rod = cylinder(base, axis, 8.0, 30.0).unwrap();- (boolean(&plate, &rod, BoolOp::Union).unwrap().unwrap(), base, axis)-}--/// A 40 × 40 × 20 box whose front wall is an arc of radius 40 about a Z axis: `concave` cuts a-/// cylinder away from the front (the wall curves into the part), otherwise the part is the box-/// within the cylinder (the wall curves out). With the bottom arc's midpoint, the axis's base-/// point and the side of the wall the material is on (+1 away from the axis, −1 toward it).-fn arc_walled_box(concave: bool) -> (Body, Vec3, Vec3, f64) {- let block = box_solid(Vec3::ZERO, Vec3::new(40.0, 40.0, 20.0)).unwrap();- let (axis, op, side) =- if concave { (Vec3::new(20.0, -30.0, 0.0), BoolOp::Cut, 1.0) } else { (Vec3::new(20.0, 70.0, 0.0), BoolOp::Intersect, -1.0) };- let tool = cylinder(axis, Vec3::Z, 40.0, 20.0).unwrap();- let body = boolean(&block, &tool, op).unwrap().unwrap();- (body, axis + Vec3::new(0.0, side * 40.0, 0.0), axis, side)-}--/// The blend face a blend built over `input`: the fitted surface that is on neither of the faces-/// it runs between (a boolean leaves the curved faces it kept as fitted surfaces themselves).-fn blend_face(input: &Body, body: &Body) -> Option<mt::Face> {- use mt::ParametricSurface;- let on_input = |p: Vec3| input.solid.face_iter().any(|f| project(f, p, None).is_some_and(|(q, _, _)| q.dist(p) <= 1e-6));- body.solid- .face_iter()- .filter(|f| matches!(f.oriented_surface(), mt::Surface::NurbsSurface(_)))- .find(|f| !on_input(from_p3(f.surface().subs(0.5, 0.5))))- .cloned()-}--/// The edges of the blend face's boundary, each once, with the point at the middle of it (the-/// blend is bounded by its two contacts and, at each end, an arc or the curve of an end face).-fn blend_boundary(input: &Body, body: &Body) -> Vec<(mt::Edge, Vec3)> {- let Some(f) = blend_face(input, body) else { return Vec::new() };- let mut out: Vec<(mt::Edge, Vec3)> = Vec::new();- for w in f.absolute_boundaries() {- for e in w.edge_iter() {- if out.iter().any(|(x, _)| x.id() == e.id()) {- continue;- }- let c = e.oriented_curve();- let (lo, hi) = c.range_tuple();- out.push((e.absolute_clone(), from_p3(c.subs((lo + hi) * 0.5))));- }- }- out-}--/// The edges of a contact: the boundary of the blend face whose middle point `side` picks out.-fn contact(input: &Body, body: &Body, side: &dyn Fn(Vec3) -> bool) -> Vec<mt::Edge> {- blend_boundary(input, body).into_iter().filter(|(_, m)| side(*m)).map(|(e, _)| e).collect()-}--/// The fraction of the way along `edge` (its absolute front to its back) of the point of it-/// nearest `q`.-fn along_fraction(edge: &mt::Edge, q: Vec3) -> Option<f64> {- let e = edge.absolute_clone();- let c = e.oriented_curve();- let (lo, hi) = c.range_tuple();- let steps = 512;- let mut at = vec![from_p3(c.subs(lo))];- let mut run = vec![0.0];- for i in 1..=steps {- let p = from_p3(c.subs(lo + (hi - lo) * i as f64 / steps as f64));- run.push(run.last().copied()? + at.last().copied()?.dist(p));- at.push(p);- }- let total = *run.last()?;- let d = |i: usize| at.get(i).map(|p| p.dist(q)).unwrap_or(f64::INFINITY);- let hint = (0..=steps).min_by(|x, y| d(*x).total_cmp(&d(*y))).unwrap_or(0);- let t = c.search_nearest_parameter(p3(q), lo + (hi - lo) * hint as f64 / steps as f64, 100)?;- let i = (((t - lo) / (hi - lo)) * steps as f64).clamp(0.0, steps as f64);- let (k, f) = (i.floor() as usize, i.fract());- let (Some(a), Some(b)) = (run.get(k), run.get((k + 1).min(steps))) else { return None };- Some((a + (b - a) * f) / total)-}--/// The azimuth of `p` about the Z axis through `axis`.-fn azimuth(axis: Vec3, p: Vec3) -> f64 {- (p.y - axis.y).atan2(p.x - axis.x)-}--/// The point of the curves running round the Z axis through `axis` at the azimuth `phi`.-fn at_azimuth(edges: &[mt::Edge], axis: Vec3, phi: f64) -> Option<Vec3> {- let off = |p: Vec3| {- let mut d = azimuth(axis, p) - phi;- while d > std::f64::consts::PI {- d -= std::f64::consts::TAU;- }- while d < -std::f64::consts::PI {- d += std::f64::consts::TAU;- }- d- };- let (mut best, mut best_d) = (Vec3::ZERO, f64::INFINITY);- for e in edges {- let c = e.oriented_curve();- let (lo, hi) = c.range_tuple();- let steps = 512;- let mut at = lo;- let mut dist = f64::INFINITY;- for i in 0..=steps {- let t = lo + (hi - lo) * i as f64 / steps as f64;- let d = off(from_p3(c.subs(t))).abs();- if d < dist {- (at, dist) = (t, d);- }- }- let step = (hi - lo) / steps as f64;- let (mut x0, mut x1) = ((at - step).max(lo), (at + step).min(hi));- let g = 0.618_033_988_749_894_9;- for _ in 0..80 {- let (a, b) = (x1 - g * (x1 - x0), x0 + g * (x1 - x0));- if off(from_p3(c.subs(a))).abs() < off(from_p3(c.subs(b))).abs() {- x1 = b;- } else {- x0 = a;- }- }- let t = 0.5 * (x0 + x1);- let d = off(from_p3(c.subs(t))).abs();- if d < best_d {- (best, best_d) = (from_p3(c.subs(t)), d);- }- }- (best_d < 1e-6).then_some(best)-}--/// A chord fillet along the cylinder-into-plane edge of an oblique boss — the two faces run from-/// 63° to 117° apart around it. The blend's chain stops at the seams between the patches a boolean-/// left of the rod's surface, where the end face is tangent to the rod; the cap that cuts the strip-/// back there is only placed for one radius, so a width that varies along the edge is refused-/// rather than approximated (the fixed radius of `fillet` along the same edge rolls).-#[test]-fn a_chord_fillet_along_an_oblique_boss_edge_is_refused() {- let (body, _, _) = oblique_boss();- let pick = Vec3::new(7.5 + 8.944_271_909_999_16, 0.0, 5.0);- // A fixed radius rolls along the same chain: the edge itself is supported.- assert!(fillet(&body, &[pick], 2.5).is_ok());- let e = fillet_chord(&body, &[pick], 4.0).unwrap_err();- assert!(matches!(e, KernelError::TooLarge(_)), "{e}");-}--/// A chord fillet along an arc whose two faces meet at a right angle: the width across the blend-/// is the chord, so the round is the one of radius `chord / √2` (checked against the constant-/// fillet of that radius) and its two contacts are that far apart at every station.-#[test]-fn chord_fillet_along_an_arc_edge() {- let (chord, r) = (3.0, 3.0 / 2f64.sqrt());- let (body, mid, axis, _) = arc_walled_box(false);- let blended = fillet_chord(&body, &[mid], chord).unwrap();- assert!(blended.validity().is_empty(), "{:?}", blended.validity());- assert_eq!(blended.unmeshed_faces(), 0);- let plain = fillet(&body, &[mid], r).unwrap();- let (made, exact) = (measure(&blended).unwrap().volume, measure(&plain).unwrap().volume);- assert!((made - exact).abs() < exact * 1e-6, "volume {made} vs {exact}");- // The contact on the plane and the one on the wall at the same azimuth: the width across.- let plane = contact(&body, &blended, &|m| m.z.abs() < 1e-6);- let wall = contact(&body, &blended, &|m| m.z.abs() >= 1e-6);- assert!(!plane.is_empty() && !wall.is_empty(), "the contacts are not the plane's and the wall's");- let mid_azimuth = azimuth(axis, mid);- let mut worst: f64 = 0.0f64;- let mut stations = 0;- for i in 1..12 {- let phi = mid_azimuth + (i as f64 / 12.0 - 0.5) * 0.9;- let (Some(p), Some(w)) = (at_azimuth(&plane, axis, phi), at_azimuth(&wall, axis, phi)) else { continue };- stations += 1;- worst = worst.max((p.dist(w) - chord).abs());- }- eprintln!("arc chord {chord}: worst width error {worst:.6} mm at {stations} stations");- assert!(stations >= 9, "only {stations} stations measured");- assert!(worst < 0.01, "the width across the blend is {worst} mm off the chord {chord}");-}--/// A chord fillet on a straight edge between planar faces is still the exact local round: the-/// same body, bit for bit, as the fillet of the radius the chord gives (a right angle: chord c is-/// r = c / √2).-#[test]-fn chord_fillet_on_a_straight_edge_is_unchanged() {- let b = box_solid(Vec3::ZERO, Vec3::new(10.0, 20.0, 30.0)).unwrap();- let (at, chord) = (Vec3::new(10.0, 10.0, 30.0), 4.0);- let f = fillet_chord(&b, &[at], chord).unwrap();- let k = fillet(&b, &[at], chord / 2f64.sqrt()).unwrap();- assert_eq!(step_export(&[&f], "part").unwrap(), step_export(&[&k], "part").unwrap());- assert_eq!(f.unmeshed_faces(), 0);-}--/// A variable radius along an arc edge: a ball whose radius is the law's at each station's fraction-/// of the edge's length rolls along it, and the setback on the planar face — the plane and the-/// wall meet at a right angle, so it is the section's radius — follows the law from end to end.-#[test]-fn variable_radius_along_an_arc_edge_follows_the_law() {- let (body, mid, axis, _) = arc_walled_box(false);- let edge = crate::surfaces::edge_near(&body, mid).unwrap();- // Started from the edge's back end: the law runs the other way, as the positions are from the- // end nearest `start`.- let start = vtx(edge.absolute_back());- // A wider law (2 → 4, the radius doubling over the arc) is out of reach of the fitted strip:- // the sections' own last spans cannot be held to the fit's accuracy there. That is refused,- // not approximated.- for wide in [4.0, 5.0] {- let e = fillet_variable(&body, mid, start, 2.0, wide).unwrap_err();- assert!(e.to_string().contains("accuracy and section limits"), "2 -> {wide}: {e}");- }- let (r0, r1) = (2.0, 3.4);- let blended = fillet_variable(&body, mid, start, r0, r1).unwrap();- assert!(blended.validity().is_empty(), "{:?}", blended.validity());- assert_eq!(blended.unmeshed_faces(), 0);- let law = RadiusSpline::through(&[(0.0, r0), (1.0, r1)], false);- // The law runs from the end nearest `start`: the chain's front here is the far end.- let want = if vtx(edge.absolute_back()).dist(start) < vtx(edge.absolute_front()).dist(start) { law.reversed() } else { law.clone() };- // `start` is the chain's back end, so the law is read back to front there: r0 at the back, r1- // at the front.- assert!((want.eval(1.0) - r0).abs() < 1e-12 && (want.eval(0.0) - r1).abs() < 1e-12);- // The blend's contact on the bottom plane is at 40 − r from the axis.- let plane = contact(&body, &blended, &|m| m.z.abs() < 1e-6);- assert!(!plane.is_empty(), "no contact on the bottom plane");- let mut worst: f64 = 0.0;- let mut stations = 0;- let mut shown = Vec::new();- for e in &plane {- let c = e.oriented_curve();- let (lo, hi) = c.range_tuple();- for i in 0..=32 {- let p = from_p3(c.subs(lo + (hi - lo) * i as f64 / 32.0));- let measured = 40.0 - (p - axis).len();- let along = along_fraction(&edge, p).unwrap();- // Leave the two ends, where the caps cut the contact: the blend closes on the end- // faces there.- if !(0.04..=0.96).contains(&along) {- continue;- }- stations += 1;- if shown.len() < 3 || (0.45..0.55).contains(&along) {- shown.push((along, measured, want.eval(along)));- }- worst = worst.max((measured - want.eval(along)).abs());- }- }- eprintln!("arc variable {r0} -> {r1}: worst radius error {worst:.6} mm at {stations} stations; law vs measured {shown:?}");- assert!(stations >= 24, "only {stations} stations measured");- assert!(worst < 0.02, "the section radius is {worst} mm off the law");- // Wider, still inside what the strip holds: the same body as the exact straight-edge case of- // that law is not built here, but the radius is the law's at every station measured.-}--/// A radius law that runs to zero at an end of a curved edge: refused by name. The blend would-/// close to the edge's end point, but the fitted strip pinches to a point there and the last span-/// of it cannot be held to the fit's accuracy: the straight-edge fillet, which closes exactly, is-/// the way (see `variable_radius_down_to_zero_at_one_end`).-#[test]-fn a_law_running_to_zero_along_a_curved_edge_is_refused() {- let (body, mid, _, _) = arc_walled_box(false);- let edge = crate::surfaces::edge_near(&body, mid).unwrap();- for start in [vtx(edge.absolute_front()), vtx(edge.absolute_back())] {- let e = fillet_variable(&body, mid, start, 3.0, 0.0).unwrap_err();- assert!(e.to_string().contains("runs to zero along a curved edge"), "{e}");- let law = RadiusSpline { degree: 1, knots: vec![0.0, 0.0, 1.0, 1.0], radii: vec![0.0, 3.0] };- assert!(fillet_variable_spline(&body, mid, mid, &law).is_err());- // A law that stays clear of zero along it rolls: the blend is closed, a three-sided face- // where nothing closes it.- let made = fillet_variable(&body, mid, start, 3.0, 2.4).unwrap();- assert!(made.validity().is_empty(), "{:?}", made.validity());- let mesh = made.mesh(&crate::MeshTolerance::chord(5e-4)).unwrap();- let about = |o: Vec3| {- mesh.triangles- .iter()- .map(|t| (mesh.positions[t[0] as usize] - o).dot((mesh.positions[t[1] as usize] - o).cross(mesh.positions[t[2] as usize] - o)) / 6.0)- .sum::<f64>()- };- assert!((about(Vec3::ZERO) - about(Vec3::new(-100.0, 50.0, 30.0))).abs() < 1e-2, "the mesh is not closed");- }-}--/// What a chord or a law the local geometry cannot hold is refused with: an error naming the size,-/// never a silent approximation and never a panic.-#[test]-fn a_chord_or_radius_the_faces_cannot_hold_is_refused() {- let (body, mid, _, _) = arc_walled_box(false);- // A chord of 30 across a 40 mm wide wall (r ≈ 21, past the side walls and the block).- let e = fillet_chord(&body, &[mid], 30.0).unwrap_err();- assert!(matches!(e, KernelError::TooLarge(_)), "{e}");- assert!(fillet_chord(&body, &[mid], 3.0 / 2f64.sqrt()).is_ok());- // A radius law too large for the wall.- assert!(fillet_variable(&body, mid, Vec3::new(0.0, 30.0, 0.0), 2.0, 30.0).is_err());- assert!(fillet_variable(&body, mid, Vec3::new(0.0, 30.0, 0.0), 20.0, 20.0).is_err());- // Non-finite, negative and zero-at-both-ends laws: refused before the geometry is touched.- let bad = |radii: Vec<f64>| RadiusSpline { degree: 1, knots: vec![0.0, 0.0, 1.0, 1.0], radii };- assert!(fillet_variable_spline(&body, mid, mid, &bad(vec![2.0, f64::NAN])).is_err());- assert!(fillet_variable_spline(&body, mid, mid, &bad(vec![2.0, f64::INFINITY])).is_err());- assert!(fillet_variable_spline(&body, mid, mid, &bad(vec![2.0, -1.0])).is_err());- assert!(fillet_variable_spline(&body, mid, mid, &bad(vec![0.0, 0.0])).is_err());- assert!(fillet_variable_spline(&body, mid, mid, &RadiusSpline { degree: 1, knots: vec![0.0, 0.5, 1.0], radii: vec![2.0, 3.0] }).is_err());- assert!(fillet_variable_points(&body, mid, mid, &[(0.0, 2.0), (1.5, 3.0)], false).is_err());- // An edge the body does not have is refused by name, not approximated.- assert!(fillet_chord(&body, &[Vec3::new(500.0, 500.0, 500.0)], 3.0).is_err());-}diff --git a/crates/kernel/src/curveblend_tests.rs b/crates/kernel/src/curveblend_tests.rsdeleted file mode 100644index 9e7a63f3b2..0000000000--- a/crates/kernel/src/curveblend_tests.rs+++ /dev/null@@ -1,731 +0,0 @@-//! Independent analytic reference: the centre of a ball tangent to two perpendicular-//! cylinders lies on the intersection of their radius-offset cylinders.--use mt::{BoundedCurve, ParametricCurve, ParametricSurface, ParametricSurface3D, SearchNearestParameter};--use super::*;-use crate::blend::plane_normal;-use crate::issue_851_tests::planned_volume;-use crate::{Body, BoolOp, boolean, cylinder, fillet};--#[test]-fn issue_1303_chamfer_open_rim_after_end_chamfer() {- use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2};- let rim = Region2 {- outer: Loop2 {- segs: vec![- Seg2::Line { a: Vec2::new(31.0, -15.0), b: Vec2::new(31.0, -11.75) },- Seg2::Line { a: Vec2::new(31.0, -11.75), b: Vec2::new(0.0, -11.75) },- Seg2::Arc { center: Vec2::ZERO, radius: 11.75, start: -std::f64::consts::FRAC_PI_2, sweep: -std::f64::consts::PI },- Seg2::Line { a: Vec2::new(0.0, 11.75), b: Vec2::new(31.0, 11.75) },- Seg2::Line { a: Vec2::new(31.0, 11.75), b: Vec2::new(31.0, 15.0) },- Seg2::Line { a: Vec2::new(31.0, 15.0), b: Vec2::new(0.0, 15.0) },- Seg2::Arc { center: Vec2::ZERO, radius: 15.0, start: std::f64::consts::FRAC_PI_2, sweep: std::f64::consts::PI },- Seg2::Line { a: Vec2::new(0.0, -15.0), b: Vec2::new(31.0, -15.0) },- ],- },- holes: vec![],- };- let mut body = crate::extrude(&Plane::XY, &[rim], 0.0, 13.0).unwrap().pop().unwrap();- // Exact local end bevels, meeting at the four-face vertices (30, +/-11.75, 13).- body = crate::blend_corner::chamfer(- &body,- &[Vec3::new(31.0, 13.375, 13.0), Vec3::new(31.0, -13.375, 13.0), Vec3::new(31.0, 11.75, 8.0), Vec3::new(31.0, -11.75, 8.0)],- 1.0,- )- .unwrap();- let picks = [Vec3::new(-11.75, 0.0, 13.0), Vec3::new(15.0, 11.75, 13.0), Vec3::new(15.0, -11.75, 13.0)];- let result = crate::chamfer(&body, &picks, 1.0).unwrap();- assert!(result.validity().is_empty(), "{:?}", result.validity());- assert_eq!(result.crossed_face_loops().unwrap(), 0);- // At height 12 + u, the removed half-ring area is pi/2 * (2*r*u + u^2).- // The straight strips end at min(31-u, 30+v), 0 <= v <= u. Their integral- // over 0 <= u <= 1 is 30 + 1/6; this includes both split end sections.- let expected = 30.0 + 1.0 / 6.0 + std::f64::consts::PI * (11.75 / 2.0 + 1.0 / 6.0);- let volume = |b: &Body| b.mesh(&crate::MeshTolerance::chord(0.0001)).unwrap().measure().volume;- let removed = volume(&body) - volume(&result);- assert!((removed - expected).abs() < 0.02, "removed {removed}, expected {expected}");- for p in [Vec3::new(30.5, 12.25, 12.5), Vec3::new(30.5, -12.25, 12.5)] {- assert!(result.solid.vertex_iter().any(|v| from_p3(v.point()).dist(p) < 1e-6));- }- for selection in [vec![picks[0]], picks.into_iter().rev().collect()] {- let other = crate::chamfer(&body, &selection, 1.0).unwrap();- assert!(other.validity().is_empty(), "{:?}", other.validity());- assert!((volume(&body) - volume(&other) - expected).abs() < 0.02);- }- assert!(crate::chamfer(&body, &picks, 4.0).is_err());-}--fn tee(scale: f64, origin: Vec3) -> Body {- let main = cylinder(origin + Vec3::new(-40.0, 0.0, 0.0) * scale, Vec3::X, 15.0 * scale, 80.0 * scale).unwrap();- let branch = cylinder(origin, Vec3::Z, 10.0 * scale, 35.0 * scale).unwrap();- boolean(&main, &branch, BoolOp::Union).unwrap().unwrap()-}--fn analytic_section(theta: f64, scale: f64, origin: Vec3) -> (Vec3, Vec3, Vec3) {- let centre = Vec3::new(13.0 * theta.cos(), 13.0 * theta.sin(), (324.0 - 169.0 * theta.sin().powi(2)).sqrt());- let main = Vec3::new(centre.x, centre.y * 15.0 / 18.0, centre.z * 15.0 / 18.0);- let branch = Vec3::new(centre.x * 10.0 / 13.0, centre.y * 10.0 / 13.0, centre.z);- (origin + centre * scale, origin + main * scale, origin + branch * scale)-}--fn nearest_blend(surfaces: &[mt::Surface], point: Vec3) -> (f64, Vec3) {- surfaces- .iter()- .filter_map(|s| {- let (u, v) = s.search_nearest_parameter(p3(point), None, 100)?;- let actual = from_p3(s.subs(u, v));- let n = s.normal(u, v);- Some((actual.dist(point), Vec3::new(n.x, n.y, n.z).normalized()?))- })- .min_by(|a, b| a.0.total_cmp(&b.0))- .unwrap()-}--fn distance_to_analytic_arc(theta: f64, point: Vec3) -> f64 {- let (centre, main, branch) = analytic_section(theta, 1.0, Vec3::ZERO);- let a = (main - centre).normalized().unwrap();- let b = (branch - centre).normalized().unwrap();- let plane = a.cross(b).normalized().unwrap();- let radial = point - centre;- let projected = radial - plane * radial.dot(plane);- let direction = projected.normalized().unwrap();- let angle = a.dot(b).clamp(-1.0, 1.0).acos();- let from_main = a.dot(direction).clamp(-1.0, 1.0).acos();- let from_branch = b.dot(direction).clamp(-1.0, 1.0).acos();- if (from_main + from_branch - angle).abs() < 1e-7 { point.dist(centre + direction * 3.0) } else { point.dist(main).min(point.dist(branch)) }-}--fn distance_to_analytic_band(point: Vec3) -> f64 {- // The arc's XY azimuth stays between its two contacts' azimuths. Their difference- // for this tee is less than 0.1 rad; bracket generously around the query azimuth.- let azimuth = point.y.atan2(point.x);- let (mut lo, mut hi) = (azimuth - 0.3, azimuth + 0.3);- for _ in 0..55 {- let a = lo + (hi - lo) * 0.38196601125;- let b = lo + (hi - lo) * 0.61803398875;- if distance_to_analytic_arc(a, point) < distance_to_analytic_arc(b, point) {- hi = b;- } else {- lo = a;- }- }- distance_to_analytic_arc((lo + hi) * 0.5, point)-}--#[test]-fn fitted_contact_edges_coincide_with_their_surface_boundaries() {- let sections: Vec<Vec<Section>> = (0..4)- .map(|k| {- (0..SAMPLES)- .map(|i| {- let theta = std::f64::consts::FRAC_PI_2 * (k as f64 + i as f64 / (SAMPLES - 1) as f64);- let (c, q1, q2) = analytic_section(theta, 1.0, Vec3::ZERO);- Section { c, q1, q2 }- })- .collect()- })- .collect();- for k in 0..sections.len() {- let fit = crate::guard("contact consistency", || fit_sections(§ions, k, true, true)).unwrap();- for (side, curve) in fit.contacts.iter().enumerate() {- let (lo, hi) = curve.range_tuple();- for i in 0..=200 {- let parameter = lo + (hi - lo) * i as f64 / 200.0;- let edge = from_p3(curve.subs(parameter));- let surface = from_p3(fit.surface.subs(side as f64, parameter));- assert!(edge.dist(surface) < 1e-9, "contact-to-surface gap {}", edge.dist(surface));- }- }- }-}--#[test]-fn rolling_ball_matches_analytic_tee_and_contacts() {- for (scale, origin) in [(1.0, Vec3::ZERO), (0.25, Vec3::new(23.0, -17.0, 9.0))] {- let body = tee(scale, origin);- let point = origin + Vec3::new(0.0, 10.0, 125f64.sqrt()) * scale;- let blend = fillet(&body, &[point], 3.0 * scale).unwrap();- assert!(blend.validity().is_empty(), "{:?}", blend.validity());- let surfaces: Vec<_> = blend.solid.face_iter().map(|f| f.oriented_surface()).filter(|s| matches!(s, mt::Surface::NurbsSurface(_))).collect();- assert!(!surfaces.is_empty());- let mut distance: f64 = 0.0;- let mut tangent_angle: f64 = 0.0;- for i in 0..96 {- // Offset the angular samples from patch seams; contact endpoints are tested below.- let theta = std::f64::consts::TAU * (i as f64 + 0.37) / 96.0;- let (centre, main, branch) = analytic_section(theta, scale, origin);- let a = (main - centre).normalized().unwrap();- let b = (branch - centre).normalized().unwrap();- let angle = a.dot(b).clamp(-1.0, 1.0).acos();- for fraction in [0.0, 0.25, 0.5, 0.75, 1.0] {- // Spherical linear interpolation of the radial unit vectors, independent of- // the production rational control-point construction and fitting parameters.- let radial = (a * ((1.0 - fraction) * angle).sin() + b * (fraction * angle).sin()) / angle.sin();- let exact = centre + radial * (3.0 * scale);- let (error, normal) = nearest_blend(&surfaces, exact);- distance = distance.max(error);- if fraction == 0.0 || fraction == 1.0 {- let want = (centre - exact).normalized().unwrap();- tangent_angle = tangent_angle.max(normal.dot(want).abs().min(1.0).acos().to_degrees());- }- }- }- assert!(distance <= 0.005, "scale {scale}: analytic surface deviation {distance} mm");- assert!(tangent_angle <= 0.5, "scale {scale}: contact normals differ by {tangent_angle} degrees");-- // The reverse direction uses points on the actual trimmed face mesh, so an- // untrimmed neighbouring surface cannot conceal an overshooting blend patch.- let mesh = blend.mesh(&crate::MeshTolerance::chord(0.002)).unwrap();- let mut reverse_distance: f64 = 0.0;- let mut probes = 0;- for point in mesh.positions.iter().step_by(19) {- let p = (*point - origin) / scale;- if (p.x * p.x + p.y * p.y).sqrt() <= 10.000001- || (p.y * p.y + p.z * p.z).sqrt() <= 15.000001- || !(10.0..20.0).contains(&p.z)- || p.x.abs() > 16.0- {- continue;- }- probes += 1;- reverse_distance = reverse_distance.max(distance_to_analytic_band(p) * scale);- }- assert!(probes > 300, "only {probes} trimmed surface points checked");- assert!(reverse_distance <= 0.005, "scale {scale}: reverse analytic deviation {reverse_distance} mm");- eprintln!("scale {scale}: surface {distance:.9} mm, reverse {reverse_distance:.9} mm, contact normals {tangent_angle:.6} degrees");-- let mut contact_count = 0;- for edge in Body::unique_edges(&blend.solid) {- let curve = edge.oriented_curve();- let (lo, hi) = curve.range_tuple();- let endpoints = [from_p3(curve.subs(lo)), from_p3(curve.subs(hi))].map(|p| (p - origin) / scale);- if endpoints.iter().any(|p| !(9.0..20.0).contains(&p.z) || p.x.abs() > 16.0) {- continue;- }- let branch = endpoints.iter().all(|p| ((p.x * p.x + p.y * p.y).sqrt() - 10.0).abs() < 1e-5);- let main = endpoints.iter().all(|p| ((p.y * p.y + p.z * p.z).sqrt() - 15.0).abs() < 1e-5);- if !branch && !main {- continue;- }- contact_count += 1;- for i in 0..=200 {- let p = (from_p3(curve.subs(lo + (hi - lo) * i as f64 / 200.0)) - origin) / scale;- let radius_error = if branch { ((p.x * p.x + p.y * p.y).sqrt() - 10.0).abs() } else { ((p.y * p.y + p.z * p.z).sqrt() - 15.0).abs() };- assert!(radius_error * scale <= 0.002, "supporting cylinder deviation {} mm", radius_error * scale);- }- }- assert!(contact_count >= 4, "only {contact_count} contacts checked");- }-}--#[test]-fn rolling_ball_refinement_cap_returns_an_error_and_preserves_input() {- let body = tee(1.0, Vec3::ZERO);- let solid = body.deep_copy();- let ids: Vec<_> = Body::unique_edges(&solid)- .iter()- .filter(|edge| {- let curve = edge.oriented_curve();- let (lo, hi) = curve.range_tuple();- let p = from_p3(curve.subs((lo + hi) * 0.5));- p.z > 10.0 && ((p.x * p.x + p.y * p.y).sqrt() - 10.0).abs() < 0.01 && ((p.y * p.y + p.z * p.z).sqrt() - 15.0).abs() < 0.01- })- .map(mt::Edge::id)- .collect();- assert!(!ids.is_empty());- let before = crate::step_export(&[&body], "unchanged").unwrap();- let input_before = crate::step_export(&[&Body::new(solid.clone()).unwrap()], "unchanged").unwrap();- // Four sections deliberately undersample the saddle; production starts at 24.- let error = crate::guard("limited rolling ball", || curve_blend_with_limit(&solid, &ids, body.size(), 3.0, true, 4)).unwrap_err();- assert!(error.to_string().contains("accuracy and section limits"), "{error}");- assert_eq!(crate::step_export(&[&body], "unchanged").unwrap(), before);- assert_eq!(crate::step_export(&[&Body::new(solid.clone()).unwrap()], "unchanged").unwrap(), input_before);-}--/// Plan-view construction of a round between two overlapping circles (a concave vertical edge-/// where two Z cylinders meet): the ball centre `f`, the circle and fillet arc angles, and the-/// area the round fills in, all independent of the kernel.-struct Gap {- /// Points along the round's arc in plan, contacts included.- arc: Vec<Vec3>,- /// Arc angles on circle 1, circle 2 and the fillet between the corner and the contacts.- angles: [f64; 3],- area: f64,-}--fn gap(c1: Vec3, r1: f64, c2: Vec3, r2: f64, corner: Vec3, r: f64) -> Gap {- // The ball centre is r from both circles, on the corner's side of the centre line.- let (a, b) = (r1 + r, r2 + r);- let d = c1.dist(c2);- let u = (c2 - c1) * (1.0 / d);- let along = (a * a - b * b + d * d) / (2.0 * d);- let mut side = Vec3::new(-u.y, u.x, 0.0);- if (corner - c1).dot(side) < 0.0 {- side = side * -1.0;- }- let f = c1 + u * along + side * (a * a - along * along).sqrt();- let (t1, t2) = (c1 + (f - c1) * (r1 / a), c2 + (f - c2) * (r2 / b));- let angle = |c: Vec3, p: Vec3, q: Vec3| (p - c).normalized().unwrap().dot((q - c).normalized().unwrap()).clamp(-1.0, 1.0).acos();- let angles = [angle(c1, t1, corner), angle(c2, corner, t2), angle(f, t2, t1)];- // Shoelace over the three short arcs: circle 1 to the corner, circle 2 on, fillet back.- let mut ring = Vec::new();- for (c, p, q) in [(c1, t1, corner), (c2, corner, t2), (f, t2, t1)] {- let (p0, q0) = (p - c, q - c);- let (a0, a1) = (p0.y.atan2(p0.x), q0.y.atan2(q0.x));- let mut sweep = a1 - a0;- while sweep > std::f64::consts::PI {- sweep -= std::f64::consts::TAU;- }- while sweep < -std::f64::consts::PI {- sweep += std::f64::consts::TAU;- }- let rr = p0.len();- for i in 0..20_000 {- let t = a0 + sweep * i as f64 / 20_000.0;- ring.push(c + Vec3::new(t.cos(), t.sin(), 0.0) * rr);- }- }- let area = ring.iter().map(|p| solidcraft_geom::Vec2::new(p.x, p.y)).collect::<solidcraft_geom::Ring<_>>().signed_area().abs();- let (p, q) = ((t1 - f).normalized().unwrap(), (t2 - f).normalized().unwrap());- let arc = (0..=8).map(|i| angles[2] * i as f64 / 8.0).map(|t| f + (p * ((angles[2] - t).sin()) + q * t.sin()) * (r / angles[2].sin())).collect();- Gap { arc, angles, area }-}--#[test]-fn rolling_ball_along_a_straight_edge_between_cylinders_trims_curved_end_seams() {- // Two Z cylinders crossing square to each other: the vertical lines where they meet are- // concave edges between two curved faces, and the blend ends on the planar caps, where the- // seams are arcs.- let (r1, r2, h, r) = (17.0, 9.5, 10.0, 6.0);- let (c1, c2) = (Vec3::ZERO, Vec3::new(r1, r2, 0.0));- let a = cylinder(c1, Vec3::Z, r1, h).unwrap();- let b = cylinder(c2, Vec3::Z, r2, h).unwrap();- let body = boolean(&a, &b, BoolOp::Union).unwrap().unwrap();- // The corner: one of the two points where the circles cross.- let d = c1.dist(c2);- let u = (c2 - c1) * (1.0 / d);- let along = (r1 * r1 - r2 * r2 + d * d) / (2.0 * d);- let corner = c1 + u * along + Vec3::new(-u.y, u.x, 0.0) * (r1 * r1 - along * along).sqrt();- let g = gap(c1, r1, c2, r2, corner, r);- let blend = fillet(&body, &[corner + Vec3::Z * (h / 2.0)], r).unwrap();- assert!(blend.validity().is_empty(), "{:?}", blend.validity());- // One blend face; the edge is replaced by two contact lines and two end arcs.- let (before, after) = (crate::measure(&body).unwrap(), crate::measure(&blend).unwrap());- assert_eq!((after.faces, after.edges, after.vertices), (before.faces + 1, before.edges + 3, before.vertices + 2), "{before:?} -> {after:?}");- // The round fills the gap over the full height. The caps gain it twice; the walls lose- // their arcs to the contacts and gain the round.- let (m0, m1) = (body.mesh(&crate::MeshTolerance::chord(0.0005)).unwrap().measure(), blend.mesh(&crate::MeshTolerance::chord(0.0005)).unwrap().measure());- let volume = h * g.area;- assert!((m1.volume - m0.volume - volume).abs() < volume * 3e-3, "added volume {} vs {volume}", m1.volume - m0.volume);- let [a1, a2, af] = g.angles;- let area = 2.0 * g.area + h * (r * af - r1 * a1 - r2 * a2);- assert!((m1.area - m0.area - area).abs() < area.abs() * 3e-3, "added area {} vs {area}", m1.area - m0.area);- // The round is the analytic arc at every height, from contact to contact.- let surfaces: Vec<_> = blend.solid.face_iter().map(|f| f.oriented_surface()).filter(|s| matches!(s, mt::Surface::NurbsSurface(_))).collect();- let mut worst: f64 = 0.0;- for z in [0.0, 0.25, 0.5, 0.75, 1.0] {- for p in &g.arc {- worst = worst.max(nearest_blend(&surfaces, *p + Vec3::Z * (h * z)).0);- }- }- assert!(worst < 1e-3, "blend surface is {worst} mm off the analytic round");-}--#[test]-fn closed_curved_seam_is_not_supported() {- // A closed seam (one edge starting and ending at the same vertex, as a full cap circle can- // be in imported geometry) has no "between" two contacts, so trimming it is refused rather- // than guessed.- let body = cylinder(Vec3::ZERO, Vec3::Z, 10.0, 5.0).unwrap();- let arc = body.solid.edge_iter().find(|e| !matches!(e.curve(), mt::Curve::Line(_))).expect("a cap arc");- let circle = mt::Edge::new_unchecked(arc.front(), arc.front(), arc.curve());- assert_eq!(circle.front(), circle.back());- // Contacts on the circle itself: a third and two thirds of the way round.- let (lo, hi) = circle.curve().range_tuple();- let on = |f: f64| mt::Vertex::new(circle.curve().subs(lo + (hi - lo) * f));- for (a, b) in [(Some(on(1.0 / 3.0)), None), (None, Some(on(2.0 / 3.0))), (Some(on(1.0 / 3.0)), Some(on(2.0 / 3.0))), (None, None)] {- let err = trim_curved_seam(&circle, a, b, 20.0).unwrap_err();- assert!(err.to_string().contains("not supported yet: a closed curved edge"), "{err}");- }-}--#[test]-fn rolling_ball_past_the_end_seam_is_too_large_and_reduces() {- // The crossing cylinders of the test above with the small one's centre inside the large- // one: a round of 3 would reach past the end of the cap arc it trims, so it is too large- // (a smaller one fits), and the largest that fits is the analytic round over the full height- // (checked on its surface: its added volume is too small beside the body's to measure).- let (r1, r2, d, h) = (17.0, 9.5, 12.0, 10.0);- let (c1, c2) = (Vec3::ZERO, Vec3::new(d, 0.0, 0.0));- let body = boolean(&cylinder(c1, Vec3::Z, r1, h).unwrap(), &cylinder(c2, Vec3::Z, r2, h).unwrap(), BoolOp::Union).unwrap().unwrap();- let along = (r1 * r1 - r2 * r2 + d * d) / (2.0 * d);- let corner = Vec3::new(along, (r1 * r1 - along * along).sqrt(), 0.0);- let at = [corner + Vec3::Z * (h / 2.0)];- let e = fillet(&body, &at, 3.0).unwrap_err();- assert!(matches!(e, KernelError::TooLarge(_)), "{e}");- let (r, blend) = crate::fillet_max(&body, &at, 3.0).unwrap();- assert!(r > 1.5 && r < 3.0, "{r}");- assert!(blend.validity().is_empty(), "{:?}", blend.validity());- let g = gap(c1, r1, c2, r2, corner, r);- let surfaces: Vec<_> = blend.solid.face_iter().map(|f| f.oriented_surface()).filter(|s| matches!(s, mt::Surface::NurbsSurface(_))).collect();- let mut worst: f64 = 0.0;- for z in [0.0, 0.25, 0.5, 0.75, 1.0] {- for p in &g.arc {- worst = worst.max(nearest_blend(&surfaces, *p + Vec3::Z * (h * z)).0);- }- }- assert!(worst < 1e-3, "blend surface is {worst} mm off the analytic round at r {r}");-}--#[test]-fn a_refused_edge_is_not_rolled_again_after_blends_far_from_it() {- // The crossing cylinders' seam refuses a round of 3 (too large). A bar joined to them has- // two straight edges at its far end that round on their own. Each blend there leaves the- // seam's surroundings as they were, so the seam is tried once, not once per blend, and the- // refusal is the same.- let (r1, r2, d, h) = (17.0, 9.5, 12.0, 10.0);- let body = boolean(&cylinder(Vec3::ZERO, Vec3::Z, r1, h).unwrap(), &cylinder(Vec3::new(d, 0.0, 0.0), Vec3::Z, r2, h).unwrap(), BoolOp::Union)- .unwrap()- .unwrap();- let bar = crate::box_solid(Vec3::new(-80.0, -5.0, 0.0), Vec3::new(-10.0, 5.0, h)).unwrap();- let body = boolean(&body, &bar, BoolOp::Union).unwrap().unwrap();- let along = (r1 * r1 - r2 * r2 + d * d) / (2.0 * d);- let seam = Vec3::new(along, (r1 * r1 - along * along).sqrt(), h / 2.0);- let ends = [Vec3::new(-80.0, -5.0, h / 2.0), Vec3::new(-80.0, 5.0, h / 2.0)];- crate::blend::ROLLS.with(|n| n.set(0));- let e = fillet(&body, &[seam, ends[0], ends[1]], 3.0).unwrap_err();- assert!(matches!(e, KernelError::TooLarge(_)), "{e}");- let rolls = crate::blend::ROLLS.with(|n| n.get());- assert_eq!(rolls, 1, "the seam was rolled {rolls} times");- // The far edges alone still round.- assert!(fillet(&body, &ends, 3.0).is_ok());-}--/// At a knife edge (the plane and the wall's normals opposite) the ball's centre is the same-/// whichever face is side 1: `r` inside the plane and `r` outside the wall's cylinder.-#[test]-fn knife_edge_ball_centre_does_not_depend_on_the_side_order() {- const R: f64 = 21.0;- let tip = Vec3::new(62.0 + 1.0 / 6.0, 0.0, 5.0);- let slab = crate::box_solid(Vec3::new(0.0, -R, 0.0), Vec3::new(tip.x, 0.0, 10.0)).unwrap();- let disc = cylinder(Vec3::new(tip.x, -R, 0.0), Vec3::Z, R, 10.0).unwrap();- let body = boolean(&slab, &disc, BoolOp::Cut).unwrap().unwrap();- let faces: Vec<&mt::Face> = body.solid.face_iter().collect();- let plane = faces.iter().copied().find(|f| plane_normal(f).is_some_and(|n| n.y > 0.99)).unwrap();- let wall = faces.iter().copied().find(|f| plane_normal(f).is_none()).unwrap();- for r in [0.5, 2.0, 5.0] {- let centre = Vec3::new(tip.x - (4.0 * R * r).sqrt(), -r, tip.z);- // `cusp` is +1 when n1 × t points into the cusp: the wall's normal is −y, the plane's +y.- for (f1, f2, cusp) in [(wall, plane, 1.0), (plane, wall, -1.0)] {- let s = solve(&[f1], &[f2], tip, Vec3::Z, r, -1.0, cusp, None, 1e-6).unwrap();- assert!(s.c.dist(centre) < 1e-6, "r={r} cusp={cusp}: centre {:?}, expected {centre:?}", s.c);- }- }-}--/// #896: the seams where rounds run into the faces beside them are picked to be rounded again.-/// The faces meet tangentially there, so there is nothing to round: the refusal says so, rather-/// than that blending such an edge isn't supported yet.-#[test]-fn a_smooth_seam_is_refused_as_having_no_corner() {- let b = crate::box_solid(Vec3::ZERO, Vec3::new(150.0, 200.0, 70.0)).unwrap();- let mut edges = Vec::new();- for (x, y) in [(0.0, 0.0), (150.0, 0.0), (0.0, 200.0), (150.0, 200.0)] {- edges.push(Vec3::new(x, y, 35.0));- }- for (a, z) in [(0.0, 0.0), (150.0, 0.0), (0.0, 70.0), (150.0, 70.0)] {- edges.push(Vec3::new(a, 100.0, z));- }- for (y, z) in [(0.0, 0.0), (200.0, 0.0), (0.0, 70.0), (200.0, 70.0)] {- edges.push(Vec3::new(75.0, y, z));- }- let rounded = fillet(&b, &edges, 10.0).unwrap();- // The seam on the top face beside the round of the edge along y at x = 0, and the seam- // with the end face x = 0 beside the round of the top edge along y.- for seam in [Vec3::new(10.0, 100.0, 70.0), Vec3::new(0.0, 100.0, 60.0)] {- for chamfer in [false, true] {- let r = if chamfer { crate::chamfer(&rounded, &[seam], 1.0) } else { fillet(&rounded, &[seam], 1.0) };- match r {- Err(KernelError::Invalid(m)) => assert!(m.contains("smooth") && m.contains("no corner"), "{m}"),- other => panic!("{seam:?}: {:?}", other.map(|_| "a body")),- }- }- }- // A sharp edge of a box with one round still takes a fillet beside the round's seams.- let one = fillet(&crate::box_solid(Vec3::ZERO, Vec3::new(40.0, 30.0, 20.0)).unwrap(), &[Vec3::new(40.0, 30.0, 10.0)], 5.0).unwrap();- assert!(fillet(&one, &[Vec3::new(20.0, 0.0, 20.0)], 1.0).is_ok());- assert!(matches!(fillet(&one, &[Vec3::new(35.0, 30.0, 10.0)], 1.0), Err(KernelError::Invalid(_))));-}--/// A 40 × 40 × 20 box whose front wall is an arc of radius 40 about a Z axis: `concave` cuts a-/// cylinder away from the front (the wall curves into the part), otherwise the part is the box-/// within the cylinder (the wall curves out). The arc meets the planar side walls x = 0 and-/// x = 40 at an angle, not square. With the bottom arc's midpoint, the axis's base point and the-/// side of the wall the material is on (+1 away from the axis, −1 toward it).-fn arc_walled_box(concave: bool) -> (Body, Vec3, Vec3, f64) {- let block = crate::box_solid(Vec3::ZERO, Vec3::new(40.0, 40.0, 20.0)).unwrap();- let (axis, op, side) =- if concave { (Vec3::new(20.0, -30.0, 0.0), BoolOp::Cut, 1.0) } else { (Vec3::new(20.0, 70.0, 0.0), BoolOp::Intersect, -1.0) };- let tool = cylinder(axis, Vec3::Z, 40.0, 20.0).unwrap();- let body = boolean(&block, &tool, op).unwrap().unwrap();- (body, axis + Vec3::new(0.0, side * 40.0, 0.0), axis, side)-}--/// Volume the blend removes along the bottom arc: the corner's cross-section at each distance-/// ρ from the axis (`depth(x)`, x ∈ [0, size] from the wall into the material), times the arc-/// of radius ρ between the side walls.-fn removed_volume(side: f64, size: f64, depth: impl Fn(f64) -> f64) -> f64 {- let steps = 4000;- let h = size / steps as f64;- (0..=steps)- .map(|i| {- let x = i as f64 * h;- let rho = 40.0 + side * x;- let w = if i == 0 || i == steps {- 1.0- } else if i % 2 == 1 {- 4.0- } else {- 2.0- };- w * depth(x) * 2.0 * rho * (20.0 / rho).asin()- })- .sum::<f64>()- * h- / 3.0-}--#[test]-fn rolling_ball_along_an_arc_ends_in_side_walls_at_an_angle() {- // The bottom edge of an arc wall ends in the side walls at an angle (#556). The round is the- // torus about the cylinder's axis (centre circle of radius 40 ± r at height r), trimmed by- // the side walls; the chamfer is the cone between the two contacts.- let r = 2.0;- for concave in [true, false] {- let (body, mid, axis, side) = arc_walled_box(concave);- let v0 = planned_volume(&body);- for round in [true, false] {- let what = format!("{} {}", if concave { "concave" } else { "convex" }, if round { "fillet" } else { "chamfer" });- let blend = if round { fillet(&body, &[mid], r) } else { crate::chamfer(&body, &[mid], r) }.unwrap_or_else(|e| panic!("{what}: {e}"));- assert!(blend.validity().is_empty(), "{what}: {:?}", blend.validity());- let volume = planned_volume(&blend);- let removed =- if round { removed_volume(side, r, |x| r - (r * r - (r - x) * (r - x)).max(0.0).sqrt()) } else { removed_volume(side, r, |x| r - x) };- assert!((v0 - volume - removed).abs() < removed * 3e-3, "{what}: removed {} vs {removed}", v0 - volume);- // The blend face stays between the side walls and, for the round, on the torus.- let surfaces: Vec<_> =- blend.solid.face_iter().map(|f| f.oriented_surface()).filter(|s| matches!(s, mt::Surface::NurbsSurface(_))).collect();- assert!(!surfaces.is_empty(), "{what}: no blend face");- let mesh = blend.mesh(&crate::MeshTolerance::chord(0.0005)).unwrap();- let (lo, hi) = mesh.positions.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), p| (lo.min(p.x), hi.max(p.x)));- assert!(lo > -1e-3 && hi < 40.0 + 1e-3, "{what}: the blend runs past the side walls: x {lo}..{hi}");- if round {- // Sections of the round across the arc: the quarter circle about the centre- // ring (radius 40 ± r about the axis, at height r) from contact to contact.- let ring = 40.0 + side * r;- let mut worst: f64 = 0.0;- for i in 0..=40 {- let x = 40.0 * i as f64 / 40.0;- for a in 1..8 {- let t = std::f64::consts::FRAC_PI_2 * a as f64 / 8.0;- let (rho, z) = (ring - side * r * t.cos(), r - r * t.sin());- let dx = x - axis.x;- let dy = (rho * rho - dx * dx).sqrt() * if concave { 1.0 } else { -1.0 };- let p = Vec3::new(x, axis.y + dy, z);- worst = worst.max(nearest_blend(&surfaces, p).0);- }- }- assert!(worst < 1e-3, "{what}: blend surface is {worst} mm off the torus");- }- }- }-}--#[test]-fn rolling_ball_past_a_slanted_end_face_is_too_large_and_reduces() {- // On the outward-curving wall a round of 4 would run its bottom contact into the back face- // before it reaches the side wall (the contact circle of radius 36 meets x = 0 at y ≈ 40.07):- // too large, and the largest that fits rounds the edge.- let (body, mid, _, _) = arc_walled_box(false);- let e = fillet(&body, &[mid], 4.0).unwrap_err();- assert!(matches!(e, KernelError::TooLarge(_)), "{e}");- let (r, blend) = crate::fillet_max(&body, &[mid], 4.0).unwrap();- assert!(r > 3.0 && r < 4.0, "{r}");- assert!(blend.validity().is_empty(), "{:?}", blend.validity());-}--#[test]-fn rolling_ball_runs_into_a_knife_edge_tip() {- // The corner of a block outside a cylinder of radius 21 about (21, −21): its wall meets the- // back face y = 0 tangentially at (21, 0) and the left face x = 0 at (0, −21), knife-edge- // tips at both ends of the arc. The round of the bottom arc runs into both, cut off by the- // end faces' planes, which touch the wall contact at the tips without crossing it: at- // distance ρ from the axis it runs from x = 0 to y = 0, ρ (asin(21 / ρ) − acos(21 / ρ)).- let block = crate::box_solid(Vec3::new(0.0, -21.0, 0.0), Vec3::new(21.0, 0.0, 10.0)).unwrap();- let body = boolean(&block, &cylinder(Vec3::new(21.0, -21.0, -1.0), Vec3::Z, 21.0, 12.0).unwrap(), BoolOp::Cut).unwrap().unwrap();- let mid = Vec3::new(21.0 - 21.0 * std::f64::consts::FRAC_1_SQRT_2, -21.0 + 21.0 * std::f64::consts::FRAC_1_SQRT_2, 0.0);- let r = 2.0;- let blend = fillet(&body, &[mid], r).unwrap();- assert!(blend.validity().is_empty(), "{:?}", blend.validity());- let (n, h) = (4000, r / 4000.0);- let removed = (0..=n)- .map(|i| {- let x = i as f64 * h;- let rho = 21.0 + x;- let w = if i == 0 || i == n {- 1.0- } else if i % 2 == 1 {- 4.0- } else {- 2.0- };- w * (r - (r * r - (r - x) * (r - x)).max(0.0).sqrt()) * rho * ((21.0 / rho).asin() - (21.0 / rho).acos())- })- .sum::<f64>()- * h- / 3.0;- let got = planned_volume(&body) - planned_volume(&blend);- assert!((got - removed).abs() < removed * 5e-3, "removed {got} vs {removed}");-}--#[test]-fn rolling_ball_turns_about_a_rounded_corner_of_its_radius() {- // The box with the inward-curving wall, its 60° corner at x = 0 rounded (r 2) first. The- // bottom edges then run: the side wall's, the corner round's (an arc of radius 2) and the- // arc wall's into the slanted side wall at x = 40. Rounded again with r 2 the ball can't- // roll round the corner: it turns about one point there, and the blend is a piece of sphere.- // It is what the rolling round tends to as its radius tends to the corner's, too large past- // it, and its mesh is closed.- let (body, _, _, _) = arc_walled_box(true);- let body = fillet(&body, &[Vec3::new(0.0, 4.641016151377546, 10.0)], 2.0).unwrap();- // The corner round's centre is 4 from the corner along its bisector, (2, 8.105): its arc's- // middle is 2 back toward the corner.- let ends = [Vec3::new(0.0, 25.0, 0.0), Vec3::new(1.0, 6.373, 0.0), Vec3::new(20.0, 10.0, 0.0)];- let v0 = planned_volume(&body);- let removed = |r: f64| {- let b = fillet(&body, &ends, r).unwrap_or_else(|e| panic!("r {r}: {e}"));- assert!(b.validity().is_empty(), "r {r}: {:?}", b.validity());- v0 - planned_volume(&b)- };- let (a, b, at) = (removed(1.96), removed(1.98), removed(2.0));- let expected = 2.0 * b - a;- assert!((at - expected).abs() < expected * 2e-3, "removed {at} at r 2, {a} and {b} before it");- let e = fillet(&body, &ends, 2.5).unwrap_err();- assert!(matches!(e, KernelError::TooLarge(_)), "{e}");- let (r, _) = crate::fillet_max(&body, &ends, 2.5).unwrap();- assert!(r > 1.5 && r <= 2.0 + 1e-9, "{r}");-}--#[test]-fn rolling_ball_along_a_straight_edge_ends_in_a_curved_face() {- // The box with the inward-curving wall: the bottom edge of the side wall x = 0 runs from the- // back to the curved wall (#556). The round of radius 2 along it is cut off by that wall:- // at d from the side wall it runs from y = −30 + √(40² − (d − 20)²) to the back at y = 40.- let (body, _, _, _) = arc_walled_box(true);- let r = 2.0;- for round in [true, false] {- let blend =- if round { fillet(&body, &[Vec3::new(0.0, 25.0, 0.0)], r) } else { crate::chamfer(&body, &[Vec3::new(0.0, 25.0, 0.0)], r) }.unwrap();- assert!(blend.validity().is_empty(), "{:?}", blend.validity());- let (n, h) = (4000, r / 4000.0);- let removed = (0..=n)- .map(|i| {- let d = i as f64 * h;- let w = if i == 0 || i == n {- 1.0- } else if i % 2 == 1 {- 4.0- } else {- 2.0- };- let depth = if round { r - (r * r - (r - d) * (r - d)).max(0.0).sqrt() } else { r - d };- w * depth * (40.0 - (-30.0 + (1600.0 - (d - 20.0) * (d - 20.0)).sqrt()))- })- .sum::<f64>()- * h- / 3.0;- let (m0, m1) = (body.mesh(&crate::MeshTolerance::chord(0.0005)).unwrap(), blend.mesh(&crate::MeshTolerance::chord(0.0005)).unwrap());- let got = m0.measure().volume - m1.measure().volume;- assert!((got - removed).abs() < removed * 3e-3, "round {round}: removed {got} vs {removed}");- let volume_about = |o: Vec3| {- let at = |i: u32| m1.positions[i as usize] - o;- m1.triangles.iter().map(|t| at(t[0]).dot(at(t[1]).cross(at(t[2]))) / 6.0).sum::<f64>()- };- let shift = volume_about(Vec3::ZERO) - volume_about(Vec3::new(-100.0, 50.0, 30.0));- assert!(shift.abs() < 1e-2, "round {round}: the mesh is not closed (volume moves {shift} with the origin)");- }-}--#[test]-fn chamfer_a_chain_of_a_line_and_an_arc_into_a_slanted_end() {- // A 40 × 40 block, 20 high, whose front runs straight for 20 and then along an arc of- // radius 29 about (20, 29), tangent to it, up to (40, 8): the right face meets the arc at an- // angle. The top front chain chamfered by 2 (the planes' and the cone's sections are 2 × 2- // corners, 2 − w high at w in from the edge): 2 a millimetre along the line, and along the- // arc out to the right face, at each distance ρ from its axis, the height times the arc of- // radius ρ inside x ≤ 40.- use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2};- let start = -std::f64::consts::FRAC_PI_2;- let end = (-21.0f64).atan2(20.0);- let segs = vec![- Seg2::Line { a: Vec2::new(0.0, 0.0), b: Vec2::new(20.0, 0.0) },- Seg2::Arc { center: Vec2::new(20.0, 29.0), radius: 29.0, start, sweep: end - start },- Seg2::Line { a: Vec2::new(40.0, 8.0), b: Vec2::new(40.0, 40.0) },- Seg2::Line { a: Vec2::new(40.0, 40.0), b: Vec2::new(0.0, 40.0) },- Seg2::Line { a: Vec2::new(0.0, 40.0), b: Vec2::new(0.0, 0.0) },- ];- let body = crate::extrude(&Plane::XY, &[Region2 { outer: Loop2 { segs }, holes: vec![] }], 0.0, 20.0).unwrap().pop().unwrap();- let volume = |b: &Body| b.mesh(&crate::MeshTolerance::chord(0.0005)).unwrap().measure().volume;- let made = crate::chamfer(&body, &[Vec3::new(10.0, 0.0, 20.0)], 2.0).unwrap();- let n = 2000;- let h = 2.0 / n as f64;- let arc = (0..=n)- .map(|i| {- let rho = 27.0 + i as f64 * h;- let w = if i == 0 || i == n { 1.0 } else { [2.0, 4.0][i % 2] };- w * (rho - 27.0) * rho * (20.0 / rho).asin()- })- .sum::<f64>()- * h- / 3.0;- let want = 40.0 + arc;- let got = volume(&body) - volume(&made);- assert!((got - want).abs() < want * 1e-3, "removed {got} vs {want}");-}--/// #1667: an R1 round around the end of a long bar whose four long edges are R5. The chain is-/// 290 mm lines and quarter turns of 7.85 mm, so the lines' sections are spaced far wider than-/// the turns'; borrowing the turns' sections for the lines' ends made their strips overshoot and-/// fold back past the joints, the strips' meshes folded with them, and the measured volume came-/// out thousands of mm³ off. The R1 pipe is exact: the corner's section, `1 - π/4`, along the-/// lines, and round each turn's axis at the section's centroid (Pappus).-#[test]-fn round_along_long_lines_and_small_turns_measures_its_volume() {- use std::f64::consts::{FRAC_PI_2, FRAC_PI_4};- let (w, d, h) = (300.0, 60.0, 40.0);- let bar = crate::build::box_solid(Vec3::new(-w / 2.0, 0.0, 0.0), Vec3::new(w / 2.0, d, h)).unwrap();- let long = [Vec3::new(-w / 2.0, d / 2.0, 0.0), Vec3::new(w / 2.0, d / 2.0, 0.0), Vec3::new(-w / 2.0, d / 2.0, h), Vec3::new(w / 2.0, d / 2.0, h)];- let rounded = fillet(&bar, &long, 5.0).unwrap();- // The rolling ball along the end face's loop (the exact blends would take this loop; a- // loop next to free-form faces, as in the issue, comes here).- let ids: Vec<mt::EdgeID> = crate::body::Body::unique_edges(&rounded.solid)- .into_iter()- .filter(|e| [e.front(), e.back()].iter().all(|v| crate::blend::vtx(v).y.abs() < 1e-9))- .map(|e| e.id())- .collect();- assert_eq!(ids.len(), 8);- let (solid, _) = crate::guard("test", || curve_blend(&rounded.solid, &ids, rounded.size(), 1.0, true)).unwrap();- let body = Body::new(solid).unwrap();- assert!(body.validity().is_empty(), "{:?}", body.validity());- let section = 1.0 - FRAC_PI_4;- // The section's centroid lies this far from its corner along each side.- let inset = (5.0 / 6.0 - FRAC_PI_4) / section;- let lines = 2.0 * (w - 10.0) + 2.0 * (h - 10.0);- let turns = 4.0 * FRAC_PI_2 * (5.0 - inset);- let want = w * d * h - 4.0 * 25.0 * section * d - section * (lines + turns);- let m = crate::measure(&body).unwrap();- assert!((m.volume - want).abs() < 1e-5 * want, "{} vs {want}", m.volume);- // Centred across the bar, as the part is.- assert!(m.centroid.x.abs() < 1e-3, "centre of mass x {}", m.centroid.x);-}diff --git a/crates/kernel/src/curvecorner.rs b/crates/kernel/src/curvecorner.rsdeleted file mode 100644index a3dbc88922..0000000000--- a/crates/kernel/src/curvecorner.rs+++ /dev/null@@ -1,1246 +0,0 @@-//! Corners where rolling-ball blends meet on faces of any surface (the arc wall of an extruded-//! profile and the edges round it): what [`crate::blend_corner`] does for straight edges between-//! planes, with each blend fitted as in the parent module.-//!-//! Each blended edge's strip (its rolling-ball sections, fitted) runs a little past both ends.-//! Every end vertex has three faces and three edges. There:-//! - one blended edge: the strip ends where the third face cuts it, between where its contacts-//! cross the other two edges;-//! - two: the strips cut each other along a crease, from where their contacts cross on the face-//! they share to the third edge. When one strip's contact-//! reaches further along the third edge, the other's ends on the crease alone and the first-//! runs on beyond it to end on the other's third face;-//! - three (one radius): each strip ends at its section through the ball touching all three-//! faces, and a piece of that ball's sphere fills the corner.--use std::cell::Cell;-use std::collections::{HashMap, HashSet};--use solidcraft_geom::Vec3;-use truck_modeling::{self as mt, builder};--use super::{- Guide, MAX_SAMPLES, SAMPLES, Section, fit_sections, in_proportion, knife_convex, knife_start, nearest_on, project, section_fits, solve_from,- unsupported,-};-use crate::blend::{too_large, vtx};-use crate::body::{Solid, from_p3, p3, v3};-use crate::bridge::Frame;-use crate::record::Rebuild;-use crate::{KernelError, Result};--fn fail(m: &str) -> KernelError {- KernelError::Failed(format!("blend corner: {m}"))-}--/// One blended edge's strip: the fitted rolling-ball surface (u across, from the contact with-/// side `fa` at 0 to side `fb`'s at 1; v along the edge from its front, running on past both-/// ends), its contacts (in v) and its sections.-struct Strip {- edge: mt::Edge,- fa: usize,- fb: usize,- surface: mt::Surface,- contacts: [mt::Curve; 2],- /// v of the sections at the edge's front and back vertex.- ends: [f64; 2],- /// +1 when the surface's normal points out of the material, −1 when into it.- flip: f64,- /// −1 for a convex edge (the ball inside the material), +1 for a concave one.- sigma: f64,- /// Sections with their v.- sections: Vec<(f64, Section)>,-}--impl Strip {- fn row(&self, f: usize) -> Result<usize> {- if f == self.fa {- Ok(0)- } else if f == self.fb {- Ok(1)- } else {- Err(fail("a face beside a blend"))- }- }-- fn contact(&self, f: usize) -> Result<&mt::Curve> {- self.contacts.get(self.row(f)?).ok_or_else(|| fail("contact"))- }-- /// u of the contact with face `f`.- fn u(&self, f: usize) -> Result<f64> {- self.row(f).map(|i| i as f64)- }-- fn at(&self, u: f64, v: f64) -> Vec3 {- use mt::ParametricSurface;- from_p3(self.surface.subs(u, v))- }-- /// The edge's own stretch of v.- fn own(&self) -> (f64, f64) {- let [a, b] = self.ends;- (a.min(b), a.max(b))- }-- /// v of the edge's end at `v`, and +1 when the strip runs on past it toward larger v.- fn end_at(&self, v: &mt::Vertex) -> (f64, f64) {- let [a, b] = self.ends;- if self.edge.front() == v { (a, -1.0) } else { (b, 1.0) }- }-- /// The strip's nearest point to `x` (u and v within it): from the section whose ball is- /// nearest, by Gauss-Newton steps kept within the strip.- fn nearest(&self, x: Vec3) -> Option<(f64, f64)> {- use mt::ParametricSurface;- let (v0, s0) = self.sections.iter().min_by(|a, b| a.1.c.dist(x).total_cmp(&b.1.c.dist(x)))?;- let (a, b, w) = (s0.q1 - s0.c, s0.q2 - s0.c, x - s0.c);- let angle = |p: Vec3, q: Vec3| (p.dot(q) / (p.len() * q.len()).max(1e-300)).clamp(-1.0, 1.0).acos();- let total = angle(a, b);- let mut uv = ((angle(a, w) / total.max(1e-12)).clamp(0.0, 1.0), *v0);- let dist = |uv: (f64, f64)| from_p3(self.surface.subs(uv.0, uv.1)).dist(x);- let mut d = dist(uv);- for _ in 0..50 {- let p = from_p3(self.surface.subs(uv.0, uv.1));- let (su, sv) = (self.surface.uder(uv.0, uv.1), self.surface.vder(uv.0, uv.1));- let (su, sv) = (Vec3::new(su.x, su.y, su.z), Vec3::new(sv.x, sv.y, sv.z));- let r = x - p;- let (a11, a12, a22) = (su.dot(su), su.dot(sv), sv.dot(sv));- let (b1, b2) = (su.dot(r), sv.dot(r));- let det = a11 * a22 - a12 * a12;- if !(det.abs() > 1e-300) {- break;- }- let (mut du, mut dv) = ((b1 * a22 - b2 * a12) / det, (a11 * b2 - a12 * b1) / det);- let mut moved = false;- for _ in 0..30 {- let next = ((uv.0 + du).clamp(0.0, 1.0), (uv.1 + dv).clamp(0.0, 1.0));- let dn = dist(next);- if dn <= d {- moved = (next.0 - uv.0).abs() + (next.1 - uv.1).abs() > 1e-15;- uv = next;- d = dn;- break;- }- du *= 0.5;- dv *= 0.5;- }- if !moved {- break;- }- }- Some(uv)- }-}--/// Signed distance from a surface, positive out of the material; each search starts where the-/// last ended (the points asked about come in small steps). A strip's is measured to its-/// nearest point within it: past a contact, to the contact along the face there.-enum Away<'a> {- Face(Box<(mt::Surface, Cell<Option<(f64, f64)>>)>),- Strip(&'a Strip),-}--impl<'a> Away<'a> {- fn face(f: &mt::Face) -> Self {- Away::Face(Box::new((f.oriented_surface(), Cell::new(None))))- }-- fn strip(s: &'a Strip) -> Self {- Away::Strip(s)- }-- fn at(&self, x: Vec3) -> Option<f64> {- use mt::{ParametricSurface, ParametricSurface3D, SearchNearestParameter};- match self {- Away::Face(face) if matches!(face.0, mt::Surface::Plane(_)) => nearest_on(&face.0, &face.1, x).map(|(q, n, _)| (x - q).dot(n)),- Away::Face(face) => {- let (surface, last) = (&face.0, &face.1);- // The nearest of the search from the last answer, a fresh one and either kept- // within the surface's parameters: past them a conic's patch runs on round to- // its far side, where a search can settle.- let (ru, rv) = surface.try_range_tuple();- let ((u0, u1), (v0, v1)) = (ru.unwrap_or((f64::NEG_INFINITY, f64::INFINITY)), rv.unwrap_or((f64::NEG_INFINITY, f64::INFINITY)));- let inside = |uv: (f64, f64)| uv.0 >= u0 - 1e-9 && uv.0 <= u1 + 1e-9 && uv.1 >= v0 - 1e-9 && uv.1 <= v1 + 1e-9;- let warm = last.get().and_then(|h| surface.search_nearest_parameter(p3(x), Some(h), 20));- let mut found: Vec<(f64, f64)> = warm.into_iter().collect();- if !warm.is_some_and(inside) {- found.extend(surface.search_nearest_parameter(p3(x), None, 100));- }- let clamped: Vec<(f64, f64)> = found.iter().map(|(u, v)| (u.clamp(u0, u1), v.clamp(v0, v1))).collect();- found.extend(clamped);- let d = |uv: &(f64, f64)| from_p3(surface.subs(uv.0, uv.1)).dist(x);- let uv = found.into_iter().filter(|uv| d(uv).is_finite()).min_by(|a, b| d(a).total_cmp(&d(b)))?;- last.set(Some(uv));- let q = from_p3(surface.subs(uv.0, uv.1));- let n = surface.normal(uv.0, uv.1);- Some((x - q).dot(Vec3::new(n.x, n.y, n.z).normalized()?))- }- Away::Strip(s) => {- let (u, v) = s.nearest(x)?;- let q = from_p3(s.surface.subs(u, v));- let n = s.surface.normal(u, v);- Some((x - q).dot(Vec3::new(n.x, n.y, n.z).normalized()?) * s.flip)- }- }- }-}--/// Unit direction along a curve at `t`.-fn tangent(c: &mt::Curve, t: f64) -> Option<Vec3> {- use mt::ParametricCurve;- let d = c.der(t);- Vec3::new(d.x, d.y, d.z).normalized()-}--/// Nearest parameter on `c` to `x`, started from the nearest of a few samples.-/// The radius of edge `e` seen along the unit `axis`: its points, moved along the axis into one-/// plane, all on one circle (within `tol`).-fn radius_along(e: &mt::Edge, axis: Vec3, tol: f64) -> Option<f64> {- use mt::{BoundedCurve, ParametricCurve};- let curve = e.curve();- let (t0, t1) = curve.range_tuple();- let at = |f: f64| {- let p = from_p3(curve.subs(t0 + (t1 - t0) * f));- p - axis * axis.dot(p)- };- let (a, u, v) = (at(0.0), at(0.5) - at(0.0), at(1.0) - at(0.0));- let w = u.cross(v);- if w.len2() < 1e-24 || w.normalized()?.dot(axis).abs() < 1.0 - 1e-6 {- return None;- }- let o = a + (v * u.len2() - u * v.len2()).cross(w) * (1.0 / (2.0 * w.len2()));- let rho = o.dist(a);- (0..=16).map(|i| at(i as f64 / 16.0)).all(|p| (p.dist(o) - rho).abs() <= tol).then_some(rho)-}--/// The parameter of `c`'s point nearest `x`: the nearest of 65 samples, refined where that-/// comes nearer.-pub(crate) fn param_on(c: &mt::Curve, x: Vec3) -> Option<f64> {- use mt::{BoundedCurve, ParametricCurve, SearchNearestParameter};- let (lo, hi) = c.range_tuple();- let d = |t: f64| from_p3(c.subs(t)).dist(x);- let hint = (0..=64).map(|i| lo + (hi - lo) * i as f64 / 64.0).min_by(|a, b| d(*a).total_cmp(&d(*b)))?;- let t = c.search_nearest_parameter(p3(x), hint, 100).unwrap_or(hint).clamp(lo, hi);- Some(if d(t) <= d(hint) { t } else { hint })-}--/// Where curve `a` crosses curve `b` on face `f`, both lying in it: its parameter on `a` and-/// the point. Of several, the one within `own` (a range of `a`'s parameter) nearest `near`.-fn cross(a: &mt::Curve, b: &mt::Curve, f: &mt::Face, near: Vec3, own: (f64, f64), tol: f64) -> Option<(f64, Vec3)> {- use mt::{BoundedCurve, ParametricCurve, SearchNearestParameter};- let (a0, a1) = a.range_tuple();- let (b0, b1) = b.range_tuple();- let surface = f.oriented_surface();- let last = Cell::new(None);- let hint = Cell::new(None::<f64>);- // Signed distance across `b` in the face, and how far `b`'s nearest point is.- // `b` sampled once (an intersection curve is slow to evaluate).- let along_b: Vec<(f64, Vec3)> = (0..=64).map(|i| b0 + (b1 - b0) * i as f64 / 64.0).map(|t| (t, from_p3(b.subs(t)))).collect();- let lateral = |s: f64| -> Option<(f64, f64)> {- let x = from_p3(a.subs(s));- // From the last answer when that is still nearest, else from the nearest sample of `b`- // (a search from the far end of a short arc can stay there).- let d = |t: f64| from_p3(b.subs(t)).dist(x);- let warm = hint.get().map(|h| b.search_nearest_parameter(p3(x), h, 50).unwrap_or(h).clamp(b0, b1));- let (start, ds) = along_b.iter().map(|(t, p)| (*t, p.dist(x))).min_by(|p, q| p.1.total_cmp(&q.1))?;- let t = match warm {- Some(w) if d(w) <= ds => w,- _ => {- let cold = b.search_nearest_parameter(p3(x), start, 50).unwrap_or(start).clamp(b0, b1);- match warm {- Some(w) if d(w) <= d(cold).min(ds) => w,- _ if d(cold) <= ds => cold,- _ => start,- }- }- };- hint.set(Some(t));- let y = from_p3(b.subs(t));- let (_, n, _) = nearest_on(&surface, &last, y)?;- let m = n.cross(tangent(b, t)?).normalized()?;- Some(((x - y).dot(m), x.dist(y)))- };- let steps = 256;- let samples: Vec<(f64, Option<(f64, f64)>)> = (0..=steps)- .map(|i| {- let s = a0 + (a1 - a0) * i as f64 / steps as f64;- (s, lateral(s))- })- .collect();- // Only where `a` comes within a sample's step of `b` (elsewhere the side flips only round- // an end of `b`).- let step = samples.windows(2).map(|w| from_p3(a.subs(w[1].0)).dist(from_p3(a.subs(w[0].0)))).fold(0.0, f64::max);- let close = |d: f64| d <= 2.0 * step + tol;- let mut found: Vec<(f64, Vec3)> = Vec::new();- for w in samples.windows(2) {- let [(s0, Some((h0, d0))), (s1, Some((h1, d1)))] = w else { continue };- if h1.abs() <= tol && *d1 <= tol {- found.push((*s1, from_p3(a.subs(*s1))));- continue;- }- if (*h0 < 0.0) == (*h1 < 0.0) || !(close(*d0) || close(*d1)) {- continue;- }- let (mut lo, mut hi, glo) = (*s0, *s1, *h0);- hint.set(None);- for _ in 0..60 {- let m = (lo + hi) * 0.5;- let Some((hm, _)) = lateral(m) else { break };- if (hm < 0.0) == (glo < 0.0) {- lo = m;- } else {- hi = m;- }- }- let s = (lo + hi) * 0.5;- hint.set(None);- if lateral(s).is_some_and(|(_, d)| d <= tol) {- found.push((s, from_p3(a.subs(s))));- }- }- if let Some((s, Some((h, d)))) = samples.first()- && h.abs() <= tol- && *d <= tol- {- found.push((*s, from_p3(a.subs(*s))));- }- // Touching without crossing: through an end of `b` (an edge the blend uses up to its far- // vertex), where the side `b` is measured from turns over. Where the distance comes down- // to nothing.- for w in samples.windows(3) {- let [(s0, Some((_, d0))), (_, Some((_, d1))), (s2, Some((_, d2)))] = w else { continue };- if !(d1 <= d0 && d1 <= d2 && close(*d1)) {- continue;- }- let gap = |s: f64| {- hint.set(None);- lateral(s).map_or(f64::INFINITY, |x| x.1)- };- let (mut lo, mut hi) = (*s0, *s2);- for _ in 0..80 {- let (x, y) = (lo + (hi - lo) * 0.381_966, lo + (hi - lo) * 0.618_034);- if gap(x) < gap(y) {- hi = y;- } else {- lo = x;- }- }- let s = (lo + hi) * 0.5;- if gap(s) <= tol && !found.iter().any(|f| (f.0 - s).abs() <= (a1 - a0) * 1e-6) {- found.push((s, from_p3(a.subs(s))));- }- }- let slack = (a1 - a0) * 1e-6;- let outside = |s: f64| s < own.0 - slack || s > own.1 + slack;- found.into_iter().min_by(|x, y| outside(x.0).cmp(&outside(y.0)).then(x.1.dist(near).total_cmp(&y.1.dist(near))))-}--/// Where curve `c` crosses `side`'s surface: its parameter and the point; of several, the one-/// nearest `near`.-fn reach(c: &mt::Curve, side: &Away, near: Vec3, tol: f64) -> Option<(f64, Vec3)> {- use mt::{BoundedCurve, ParametricCurve};- let (lo, hi) = c.range_tuple();- let g = |s: f64| side.at(from_p3(c.subs(s))).filter(|x| x.is_finite());- let steps = 256;- let samples: Vec<(f64, Option<f64>)> = (0..=steps)- .map(|i| {- let s = lo + (hi - lo) * i as f64 / steps as f64;- (s, g(s))- })- .collect();- let mut found: Vec<(f64, Vec3)> = Vec::new();- for w in samples.windows(2) {- let [(s0, Some(g0)), (s1, Some(g1))] = w else { continue };- if (*g0 < 0.0) == (*g1 < 0.0) {- continue;- }- let (mut a, mut b, ga) = (*s0, *s1, *g0);- for _ in 0..60 {- let m = (a + b) * 0.5;- let Some(gm) = g(m) else { break };- if (gm < 0.0) == (ga < 0.0) {- a = m;- } else {- b = m;- }- }- let s = (a + b) * 0.5;- if g(s).is_some_and(|x| x.abs() <= tol) {- found.push((s, from_p3(c.subs(s))));- }- }- found.into_iter().min_by(|x, y| x.1.dist(near).total_cmp(&y.1.dist(near)))-}--/// The curve on strip `s` from `a` to `b` (each u, v and point) where `side` changes sign (it is-/// negative in the material kept): for each u between, the v where it does nearest a guess-/// between the ends, stepping toward `out` (+1: larger v) while inside. Interpolated by chord-/// length through u spaced closer toward the ends; between its points it stays on the strip and-/// on the surface.-fn trace(s: &Strip, a: (f64, f64, Vec3), b: (f64, f64, Vec3), side: &Away, out: f64, tolerance: f64) -> Result<mt::Curve> {- use mt::ParametricCurve;- let beyond = || too_large("the blend is larger than the neighbouring faces");- let (ua, va, pa) = a;- let (ub, vb, pb) = b;- let f = |u: f64, v: f64| side.at(s.at(u, v)).unwrap_or(f64::NAN);- let root = |frac: f64| -> Option<(f64, f64)> {- let u = ua + (ub - ua) * frac;- let guess = (va + (vb - va) * frac).clamp(0.0, 1.0);- // Steps in proportion to the distance from the nearer end, where the curve is known: a- // face tangent to a contact there (a knife-edge tip) crosses the strip only within a- // window that narrows toward it.- let step = (vb - va).abs().max(1e-3) * frac.min(1.0 - frac).clamp(1e-6, 0.5) / 8.0;- let g = f(u, guess);- if !g.is_finite() {- return None;- }- let dir = if g < 0.0 { out } else { -out };- let mut prev = (guess, g);- for i in 1..=4096 {- let v = (guess + dir * step * i as f64).clamp(0.0, 1.0);- let cur = (v, f(u, v));- if !cur.1.is_finite() {- return None;- }- if (prev.1 < 0.0) != (cur.1 < 0.0) {- let (mut x, mut y) = (prev, cur);- for _ in 0..60 {- let m = (x.0 + y.0) * 0.5;- let fm = f(u, m);- if (fm < 0.0) == (x.1 < 0.0) {- x = (m, fm);- } else {- y = (m, fm);- }- }- return Some((u, (x.0 + y.0) * 0.5));- }- if v <= 0.0 || v >= 1.0 {- return None;- }- prev = cur;- }- None- };- let across = |t: f64| (1.0 - (std::f64::consts::PI * t).cos()) * 0.5;- let mut m = 8;- loop {- let mut pts = vec![pa];- for i in 1..m {- let (u, v) = root(across(i as f64 / m as f64)).ok_or_else(beyond)?;- pts.push(s.at(u, v));- }- pts.push(pb);- let (curve, params) = crate::build::interpolate_cubic_chordal(&pts).ok_or_else(|| fail("end curve"))?;- let mut accurate = true;- for (i, w) in params.windows(2).enumerate() {- let (Some(t0), Some(t1)) = (w.first(), w.get(1)) else { continue };- root(across((i as f64 + 0.5) / m as f64)).ok_or_else(beyond)?;- let x = from_p3(curve.subs((t0 + t1) * 0.5));- let on = s.nearest(x).map(|(a, b)| s.at(a, b).dist(x));- let off = side.at(x).map(f64::abs);- if !(on.is_some_and(|d| d <= tolerance) && off.is_some_and(|d| d <= tolerance)) {- accurate = false;- break;- }- }- if accurate {- return Ok(mt::Curve::BSplineCurve(curve));- }- if m >= 256 {- return Err(fail("could not fit where the blends meet"));- }- m *= 2;- }-}--/// Convex (−1) or concave (+1): from the edge's direction as its first face runs it and the-/// faces' outward normals at its middle. At a knife edge (normals opposite), also the-/// direction both faces run on from it.-fn convexity(faces: &[mt::Face], e: &mt::Edge, fa: usize, fb: usize, r: f64) -> Result<(f64, Option<Vec3>)> {- use mt::{BoundedCurve, ParametricCurve};- let (Some(f1), Some(f2)) = (faces.get(fa), faces.get(fb)) else { return Err(fail("face")) };- let used = f1.boundary_iters().into_iter().flatten().find(|x| x.id() == e.id()).ok_or_else(|| fail("edge use"))?;- let c = used.oriented_curve();- let (a, b) = c.range_tuple();- let pm = from_p3(c.subs((a + b) * 0.5));- let t = tangent(&c, (a + b) * 0.5).ok_or_else(|| fail("tangent"))?;- let (Some(n1), Some(n2)) = (project(f1, pm, None).map(|x| x.1), project(f2, pm, None).map(|x| x.1)) else { return Err(fail("normals")) };- if n1.dot(n2) > 1.0 - 1e-6 {- return Err(unsupported("blending a smooth edge"));- }- if n1.dot(n2) < -1.0 + 1e-6 {- let into = n1.cross(t).normalized().ok_or_else(|| fail("normals"))?;- return match knife_convex(f1, f2, pm, into, r) {- Some(true) => Ok((-1.0, Some(into))),- _ => Err(unsupported("blending a knife edge inside the material (a crack)")),- };- }- Ok((if t.dot(n1.cross(n2)) > 0.0 { -1.0 } else { 1.0 }, None))-}--/// The strip of edge `e` between faces `fa` and `fb`, running on past each end as far as the-/// ball still fits, up to `reach`.-#[allow(clippy::too_many_arguments)]-fn strip(- faces: &[mt::Face],- e: &mt::Edge,- (fa, fb): (usize, usize),- r: f64,- round: bool,- (sigma, knife): (f64, Option<Vec3>),- reach: f64,- tol: f64,- fit_tol: f64,-) -> Result<Strip> {- use mt::{BoundedCurve, ParametricCurve, ParametricSurface3D, SearchNearestParameter};- let (Some(f1), Some(f2)) = (faces.get(fa), faces.get(fb)) else { return Err(fail("face")) };- let (o1, o2) = ([f1], [f2]);- let curve = e.curve();- let (t0, t1) = curve.range_tuple();- let at = |s: f64| -> Option<(Vec3, Vec3)> {- let t = t0 + (t1 - t0) * s;- Some((from_p3(curve.subs(t)), tangent(&curve, t)?))- };- // At a knife edge each ball starts where the last one was, beside it (the first where the- // faces are a diameter apart): the edge itself is no start.- let offset: Cell<Option<Vec3>> = Cell::new(None);- let ball = |p: Vec3, t: Vec3| -> Option<Section> {- let start = match (knife, offset.get()) {- (None, _) => None,- (Some(_), Some(o)) => Some(p + o),- (Some(into), None) => Some(knife_start(&o1, &o2, p, t, into, r)?),- };- let s = solve_from(&o1, &o2, p, t, r, sigma, 0.0, None, tol * 100.0, start)?;- if knife.is_some() {- offset.set(Some(s.c - p));- }- Some(s)- };- // Along the edge, then on along its curve past its ends (a line runs straight on, a conic's- // arc round its circle) while the ball fits.- let mut raw: Vec<Section> = Vec::new();- let (p0, _) = at(0.0).ok_or_else(|| fail("tangent"))?;- let n = 32;- let mut along = Vec::with_capacity(n + 1);- for i in 0..=n {- let (p, t) = at(i as f64 / n as f64).ok_or_else(|| fail("tangent"))?;- along.push(ball(p, t).ok_or_else(|| unsupported("the ball doesn't fit along the edge"))?);- }- let length = (0..n).filter_map(|i| Some(at(i as f64 / n as f64)?.0.dist(at((i + 1) as f64 / n as f64)?.0))).sum::<f64>();- if !(length.is_finite() && length > tol) {- return Err(fail("edge length"));- }- let past = |sign: f64| -> Vec<Section> {- let mut list = Vec::new();- for k in 1..=16 {- let s = (sign * reach * k as f64 / 16.0) / length;- match at(if sign < 0.0 { s } else { 1.0 + s }).filter(|(p, t)| p.is_finite() && t.is_finite()).and_then(|(p, t)| ball(p, t)) {- Some(x) => list.push(x),- None => break,- }- }- list- };- let after = past(1.0);- offset.set(along.first().map(|s| s.c - p0));- let before = past(-1.0);- raw.extend(before.iter().rev().copied());- let first = raw.len();- raw.extend(along);- let last = raw.len() - 1;- raw.extend(after);- let guide = Guide::new(raw)?;- let total = guide.lengths.last().copied().ok_or_else(|| fail("spine"))?;- let ends = [- guide.lengths.get(first).copied().ok_or_else(|| fail("spine"))? / total,- guide.lengths.get(last).copied().ok_or_else(|| fail("spine"))? / total,- ];- let uniform = |along: f64| -> Result<Section> {- if along <= 0.0 {- return guide.sections.first().copied().ok_or_else(|| fail("section"));- }- if along >= 1.0 {- return guide.sections.last().copied().ok_or_else(|| fail("section"));- }- let (anchor, t) = guide.anchor(along).ok_or_else(|| unsupported("degenerate rolling-ball spine"))?;- solve_from(&o1, &o2, anchor, t, r, sigma, 0.0, None, tol * 100.0, None)- .ok_or_else(|| unsupported("the ball doesn't fit along the resampled spine"))- };- let mut samples = SAMPLES;- let (list, fit) = loop {- let list: Vec<Section> = (0..samples).map(|j| uniform(j as f64 / (samples - 1) as f64)).collect::<Result<_>>()?;- let fit = crate::guard("fit corner blend", || fit_sections(std::slice::from_ref(&list), 0, false, round))?;- let mut accurate = true;- 'check: for j in 0..samples - 1 {- for fraction in [0.25, 0.5, 0.75] {- let along = (j as f64 + fraction) / (samples - 1) as f64;- if !section_fits(&fit, &uniform(along)?, along, round, sigma, fit_tol) {- accurate = false;- break 'check;- }- }- }- if accurate {- break (list, fit);- }- if samples >= MAX_SAMPLES {- return Err(fail("could not fit the rolling-ball surface"));- }- samples = (2 * samples - 1).min(MAX_SAMPLES);- };- // Outward: toward the ball centre on a concave edge, away on a convex one.- let mid = list.get(list.len() / 2).ok_or_else(|| fail("section"))?;- let m = mid.c + ((mid.q1 - mid.c) + (mid.q2 - mid.c)).normalized().ok_or_else(|| fail("section"))? * r;- let (u, v) = fit.surface.search_nearest_parameter(p3(m), Some((0.5, 0.5)), 100).ok_or_else(|| fail("orientation"))?;- let nn = fit.surface.normal(u, v);- let flip = if Vec3::new(nn.x, nn.y, nn.z).dot((mid.c - m) * sigma) < 0.0 { -1.0 } else { 1.0 };- let sections = list.iter().enumerate().map(|(j, s)| (j as f64 / (samples - 1) as f64, *s)).collect();- let [c1, c2] = fit.contacts;- Ok(Strip { edge: e.clone(), fa, fb, surface: fit.surface, contacts: [c1, c2], ends, flip, sigma, sections })-}--/// The point a radius from all three faces (inside the material for a convex corner), from-/// `start`, and its contacts with them.-fn corner_ball(faces: [&mt::Face; 3], start: Vec3, r: f64, sigma: f64, tol: f64) -> Option<(Vec3, [Vec3; 3])> {- let mut c = start;- for _ in 0..100 {- let mut rows = [[0.0; 3]; 3];- let mut rhs = [0.0; 3];- let mut qs = [Vec3::ZERO; 3];- let mut worst: f64 = 0.0;- for (((f, row), b), q) in faces.iter().zip(rows.iter_mut()).zip(rhs.iter_mut()).zip(qs.iter_mut()) {- let (x, n, _) = project(f, c, None)?;- let g = (c - x).dot(n) - sigma * r;- *row = [n.x, n.y, n.z];- *b = -g;- *q = x;- worst = worst.max(g.abs());- }- let d = crate::polyhedron::solve3_pub(rows, rhs)?;- let dc = Vec3::new(d[0], d[1], d[2]);- if worst < tol && dc.len() < tol {- return Some((c, qs));- }- c += dc;- if !c.is_finite() {- return None;- }- }- None-}--/// Flip a surface so that its normal near `at` points along `outward`.-fn orient(mut surf: mt::Surface, at: Vec3, outward: Vec3) -> mt::Surface {- use mt::{ParametricSurface3D, SearchNearestParameter};- if let Some((u, v)) = surf.search_nearest_parameter(p3(at), None, 100) {- let n = surf.normal(u, v);- if Vec3::new(n.x, n.y, n.z).dot(outward) < 0.0 {- surf = mt::Invertible::inverse(&surf);- }- }- surf-}--/// Where a blend's contact ends at a vertex where it ends alone: crossing the edge there (its-/// parameter and the point), or past that edge's far vertex `w`, crossing the next edge `g` of-/// its face there (`h`: the third edge at `w`, between the faces `f4` beyond and the vertex's-/// third face).-enum Reached {- Edge(f64, Vec3),- Past { t: f64, p: Vec3, w: mt::Vertex, g: mt::EdgeID, h: mt::EdgeID, f4: usize },-}--/// A face of the shell being rebuilt, a strip, or a corner's sphere.-#[derive(Clone, Copy, PartialEq)]-enum Owner {- Face(usize),- Strip(mt::EdgeID),- Patch,-}--/// Edges from `from` to `to` through the pool edges of `owner`.-fn connect(from: &mt::Vertex, to: &mt::Vertex, pool: &[(mt::Edge, Vec<Owner>)], owner: Owner) -> Result<Vec<mt::Edge>> {- let mut out = Vec::new();- let mut used: HashSet<mt::EdgeID> = HashSet::new();- let mut cur = from.clone();- for _ in 0..=pool.len() {- if &cur == to {- return Ok(out);- }- let next = pool.iter().filter(|(e, o)| o.contains(&owner) && !used.contains(&e.id())).find_map(|(e, _)| {- if e.front() == &cur {- Some(e.clone())- } else if e.back() == &cur {- Some(e.inverse())- } else {- None- }- });- let Some(e) = next else { break };- used.insert(e.id());- cur = e.back().clone();- out.push(e);- }- Err(fail("a boundary does not close"))-}--/// The strip's own station nearest the corner ball `c`: the section where the strip stops against-/// that ball, where its direction of leave and its curvature are read.-fn corner_station(strip: &Strip, c: Vec3) -> Option<f64> {- strip.sections.iter().min_by(|a, b| a.1.c.dist(c).total_cmp(&b.1.c.dist(c))).map(|x| x.0)-}--/// One side of a G2 corner: the corner ball's own section arc of radius `r` about `c`, from its-/// contact `q_from` to its contact `q_to`, each station carrying the direction the corner patch-/// leaves the blend in (towards the corner's apex) and the blend's own curvature across it, read-/// from `strip` where the ball stops against it. A rolling ball's section is a circular arc about-/// its own centre wherever the edge runs, so this arc is the blend's section curve itself, and its-/// ends are the ball's contacts exactly — the sides close the loop whatever the fit's station-/// spacing is.-fn g2_side(strip: &Strip, c: Vec3, r: f64, q_from: Vec3, q_to: Vec3, apex: Vec3) -> Result<Vec<Frame>> {- use mt::ParametricSurface;- /// Stations across one section: enough for the patch's cubic cross-sections, few enough to- /// keep the corner's own patch small.- const STATIONS: usize = 9;- let vec_of = |d: mt::Vector3| Vec3::new(d.x, d.y, d.z);- let v = corner_station(strip, c).ok_or_else(|| fail("corner section"))?;- let a = (q_from - c).normalized().ok_or_else(|| fail("corner contact"))?;- let b = (q_to - c).normalized().ok_or_else(|| fail("corner contact"))?;- let dot = a.dot(b).clamp(-1.0, 1.0);- let w = (b - a * dot).normalized().ok_or_else(|| fail("corner contact"))?;- let theta = dot.acos();- // The blend's own direction of leave and curvature across the seam, at its corner station.- let speed = vec_of(strip.surface.vder(0.5, v)).len();- if !(speed > 1e-30) {- return Err(unsupported("a corner section of no width"));- }- let leave = vec_of(strip.surface.vder(0.5, v)) * (1.0 / speed);- let bend = vec_of(strip.surface.vvder(0.5, v)) * (1.0 / (speed * speed));- if !(leave.is_finite() && bend.is_finite() && theta.is_finite() && r.is_finite()) {- return Err(unsupported("a corner section that is not finite"));- }- let mut out = Vec::with_capacity(STATIONS);- for k in 0..STATIONS {- let t = theta * k as f64 / (STATIONS - 1) as f64;- let p = c + (a * t.cos() + w * t.sin()) * r;- // The patch leaves the blend towards the material the corner caps, so the sign is the one- // towards the corner's apex (the blends' own v direction runs away from the vertex).- let leave = if leave.dot(apex - p) < 0.0 { -leave } else { leave };- if !(p.is_finite() && leave.is_finite() && bend.is_finite()) {- return Err(unsupported("a corner section that is not finite"));- }- out.push(Frame { p, leave, bend, bend_change: Vec3::ZERO });- }- Ok(out)-}--/// Blend the edges `ids` of `solid` with radius `r` (a chamfer's distance), rebuilding the-/// corners at their ends; with what it built from `solid`.-pub(crate) fn corner_blend(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64, round: bool) -> Result<(Solid, Rebuild)> {- corner_blend_style(solid, ids, size, r, round, false)-}--/// [`corner_blend`]; with `g2`, the corners where three blends meet are G2 patches-/// ([`crate::corner_g2`]) instead of pieces of the rolling ball's sphere.-pub(crate) fn corner_blend_style(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64, round: bool, g2: bool) -> Result<(Solid, Rebuild)> {- if !(size.is_finite() && size > 0.0 && r.is_finite() && r > 0.0) {- return Err(KernelError::Invalid("blend size and radius must be finite and positive".into()));- }- if ids.is_empty() || ids.len() > 64 {- return Err(KernelError::Invalid("select 1…64 edges".into()));- }- let tol = (size * 1e-7).max(1e-9);- let fit_tol = (size * 1e-5).clamp(1e-5, 0.001);- let shells = solid.boundaries();- let si = shells.iter().position(|sh| sh.edge_iter().any(|e| ids.contains(&e.id()))).ok_or_else(|| fail("edge not found"))?;- let shell = shells.get(si).ok_or_else(|| fail("shell"))?;- if ids.iter().any(|id| !shell.edge_iter().any(|e| e.id() == *id)) {- return Err(unsupported("blends on separate lumps in one go"));- }- let faces: Vec<mt::Face> = shell.face_iter().cloned().collect();- let edges: HashMap<mt::EdgeID, mt::Edge> = shell.edge_iter().map(|e| (e.id(), e.absolute_clone())).collect();- let mut on_edge: HashMap<mt::EdgeID, Vec<usize>> = HashMap::new();- let mut at_vertex: HashMap<mt::VertexID, (HashSet<mt::EdgeID>, Vec<usize>)> = HashMap::new();- for (fi, f) in faces.iter().enumerate() {- for e in f.edge_iter() {- let list = on_edge.entry(e.id()).or_default();- if !list.contains(&fi) {- list.push(fi);- }- for v in [e.front(), e.back()] {- let a = at_vertex.entry(v.id()).or_default();- a.0.insert(e.id());- if !a.1.contains(&fi) {- a.1.push(fi);- }- }- }- }- let face_with = |a: mt::EdgeID, b: mt::EdgeID| -> Result<usize> {- let fa = on_edge.get(&a).cloned().unwrap_or_default();- let fb = on_edge.get(&b).cloned().unwrap_or_default();- fa.into_iter().find(|f| fb.contains(f)).ok_or_else(|| fail("faces"))- };- let face = |fi: usize| faces.get(fi).ok_or_else(|| fail("face"));-- // The vertices at the blended edges' ends: three faces, three edges.- let mut touched: HashMap<mt::VertexID, mt::Vertex> = HashMap::new();- let mut sides: HashMap<mt::EdgeID, (usize, usize, f64, Option<Vec3>)> = HashMap::new();- for id in ids {- let e = edges.get(id).ok_or_else(|| fail("edge"))?;- if e.front() == e.back() {- return Err(unsupported("blending a closed edge at a corner"));- }- let fs = on_edge.get(id).cloned().unwrap_or_default();- let [fa, fb] = fs[..] else { return Err(unsupported("the edge is not between two faces")) };- let (sigma, knife) = convexity(&faces, e, fa, fb, r)?;- sides.insert(*id, (fa, fb, sigma, knife));- touched.insert(e.front().id(), e.front().clone());- touched.insert(e.back().id(), e.back().clone());- }- for vid in touched.keys() {- let (eids, fids) = at_vertex.get(vid).ok_or_else(|| fail("vertex"))?;- if eids.len() != 3 || fids.len() != 3 {- return Err(unsupported("blends ending where more than three edges meet"));- }- let chosen: Vec<&mt::EdgeID> = eids.iter().filter(|id| sides.contains_key(id)).collect();- if chosen.len() >= 2 && chosen.iter().any(|id| sides.get(*id).is_none_or(|s| s.2 > 0.0)) {- return Err(unsupported("concave blends meeting at a corner"));- }- if chosen.len() == 3 && !round {- return Err(unsupported("three chamfers at one corner"));- }- // A blended edge running on smoothly into one that isn't: the blend follows it there- // (a chain round the corner, blended elsewhere), unless it is an earlier round's arc of- // this radius, which the blend ends in. Round a smaller one the ball can't.- let v = touched.get(vid).ok_or_else(|| fail("vertex"))?;- let leaves = |e: &mt::Edge| {- use mt::BoundedCurve;- let c = e.curve();- let (t0, t1) = c.range_tuple();- tangent(&c, if e.front() == v { t0 } else { t1 }).map(|d| if e.front() == v { d } else { -d })- };- for id in &chosen {- let Some(d) = edges.get(*id).and_then(leaves) else { continue };- for g in eids.iter().filter(|g| !sides.contains_key(*g)) {- let Some(e) = edges.get(g) else { continue };- if !leaves(e).is_some_and(|x| x.dot(d) < -1.0 + 1e-6) {- continue;- }- // The earlier round's end may also be where it meets a curved face: a circle only- // seen along the round's axis, which its contact with the third face runs along.- let third = eids.iter().find(|x| *x != *id && *x != g).and_then(|x| edges.get(x)).and_then(leaves);- let seen = super::circle_of(e, tol * 1e3).map(|c| c.1).or_else(|| third.and_then(|a| radius_along(e, a, tol * 1e3)));- match seen {- Some(rho) if (rho - r).abs() <= tol * 1e3 => {}- Some(rho) if rho < r => return Err(too_large("the blend is larger than a corner radius")),- _ => return Err(unsupported("a blend running on smoothly into an edge not blended")),- }- }- }- }-- crate::guard("blend corners", || {- // The strips.- let mut strips: HashMap<mt::EdgeID, Strip> = HashMap::new();- for id in ids {- let (Some(e), Some((fa, fb, sigma, knife))) = (edges.get(id), sides.get(id).copied()) else { return Err(fail("edge")) };- strips.insert(*id, strip(&faces, e, (fa, fb), r, round, (sigma, knife), 8.0 * r, tol, fit_tol)?);- }- let strip_of = |id: &mt::EdgeID| strips.get(id).ok_or_else(|| fail("strip"));- // New end points: (edge, vertex, the face of a blended edge's contact).- let mut endpt: HashMap<(mt::EdgeID, mt::VertexID, Option<usize>), mt::Vertex> = HashMap::new();- let mut pool: HashMap<mt::VertexID, Vec<(mt::Edge, Vec<Owner>)>> = HashMap::new();- let mut patches: Vec<(mt::Face, Vec<mt::EdgeID>)> = Vec::new();- // Edges a blend uses up to their far vertex (an earlier round's edge, when the radii- // are equal): left out, the blend ends at that vertex.- let mut consumed: HashSet<mt::EdgeID> = HashSet::new();- // Vertices a blend takes in (an earlier round's corner past the end of its edge).- let mut gone: HashMap<mt::VertexID, mt::Vertex> = HashMap::new();- // In a fixed order (by position): the work and the result don't depend on hashing.- let mut order_v: Vec<(&mt::VertexID, &mt::Vertex)> = touched.iter().collect();- order_v.sort_by(|a, b| {- let (p, q) = (vtx(a.1), vtx(b.1));- p.x.total_cmp(&q.x).then(p.y.total_cmp(&q.y)).then(p.z.total_cmp(&q.z))- });- for (vid, vert) in order_v {- let v = vtx(vert);- let (eids, _) = at_vertex.get(vid).ok_or_else(|| fail("vertex"))?;- let mut chosen: Vec<mt::EdgeID> = eids.iter().filter(|id| sides.contains_key(id)).copied().collect();- let rest: Vec<mt::EdgeID> = eids.iter().filter(|id| !sides.contains_key(id)).copied().collect();- chosen.sort_by_key(|id| ids.iter().position(|x| x == id));- let curve_of = |id: &mt::EdgeID| edges.get(id).map(|e| e.curve()).ok_or_else(|| fail("edge"));- // The new end on edge `id` at `p`: its far vertex when the blend reaches it.- // A contact (`along`: the curves arriving there, and where) that runs into that- // vertex along another of its edges would leave a face no wider than nothing: refused.- let at_end = |id: &mt::EdgeID, p: Vec3, along: &[(&mt::Curve, f64, usize)]| -> Result<(mt::Vertex, bool)> {- let far = edges.get(id).map(|e| if e.front().id() == *vid { e.back().clone() } else { e.front().clone() });- let Some(w) = far.filter(|w| vtx(w).dist(p) <= fit_tol * 10.0 && !touched.contains_key(&w.id())) else {- return Ok((builder::vertex(p3(p)), false));- };- let others = at_vertex.get(&w.id()).map(|x| x.0.iter().filter(|g| *g != id).copied().collect::<Vec<_>>()).unwrap_or_default();- for g in others {- use mt::BoundedCurve;- let Some(e) = edges.get(&g) else { continue };- let c = e.curve();- let (t0, t1) = c.range_tuple();- let leaves = tangent(&c, if e.front() == &w { t0 } else { t1 });- let of = on_edge.get(&g).cloned().unwrap_or_default();- if along- .iter()- .filter(|(_, _, f)| of.contains(f))- .filter_map(|(c, t, _)| tangent(c, *t))- .any(|d| leaves.is_some_and(|l| l.dot(d).abs() > 1.0 - 1e-6))- {- return Err(unsupported("a blend that runs along an edge where it ends"));- }- }- Ok((w, true))- };- let mut ending = |id: &mt::EdgeID, p: Vec3, along: &[(&mt::Curve, f64, usize)]| -> Result<mt::Vertex> {- let (w, used) = at_end(id, p, along)?;- if used {- consumed.insert(*id);- }- Ok(w)- };- let list = pool.entry(*vid).or_default();- match (&chosen[..], &rest[..]) {- ([e1], [e2, e3]) => {- let s1 = strip_of(e1)?;- let (f12, f31, f23) = (face_with(*e1, *e2)?, face_with(*e1, *e3)?, face_with(*e2, *e3)?);- let (_, out) = s1.end_at(vert);- let (c12, c31) = (s1.contact(f12)?, s1.contact(f31)?);- let none = || too_large("the blend is larger than the neighbouring faces");- // Each contact crosses its edge at the vertex, or runs past that edge's far- // end (the blend takes in that corner, an earlier round's) to the next edge of- // its face there.- let side = |ei: &mt::EdgeID, fi: usize| -> Result<Reached> {- let c = s1.contact(fi)?;- if let Some((t, p)) = cross(c, &curve_of(ei)?, face(fi)?, v, s1.own(), fit_tol) {- return Ok(Reached::Edge(t, p));- }- // Only an earlier round's corner: the third face runs on smoothly from a- // side at the vertex (else the blend would wrap round a corner of the part).- let normal = |f: usize| face(f).ok().and_then(|g| project(g, v, None)).map(|x| x.1);- let smooth = normal(f23).is_some_and(|n| [f12, f31].iter().any(|f| normal(*f).is_some_and(|m| m.dot(n) > 1.0 - 1e-6)));- if !smooth {- return Err(none());- }- let e = edges.get(ei).ok_or_else(|| fail("edge"))?;- let w = if e.front().id() == *vid { e.back().clone() } else { e.front().clone() };- let (ws, wf) = at_vertex.get(&w.id()).ok_or_else(|| fail("vertex"))?;- if touched.contains_key(&w.id()) || ws.len() != 3 || wf.len() != 3 || ws.iter().any(|x| sides.contains_key(x)) {- return Err(none());- }- let on = |f: usize| ws.iter().filter(|x| *x != ei).find(|x| on_edge.get(*x).is_some_and(|fs| fs.contains(&f))).copied();- let (Some(g), Some(h)) = (on(fi), on(f23)) else { return Err(none()) };- let f4 = face_with(g, h)?;- let (t, p) = cross(c, &curve_of(&g)?, face(fi)?, v, s1.own(), fit_tol).ok_or_else(none)?;- // Through that far vertex itself: the contact reaches the edge's end there- // (touching it where it runs in tangent to the contact, as at a knife-edge- // tip).- if p.dist(vtx(&w)) <= fit_tol * 10.0 {- return Ok(Reached::Edge(t, vtx(&w)));- }- Ok(Reached::Past { t, p, w, g, h, f4 })- };- match (side(e2, f12)?, side(e3, f31)?) {- (Reached::Edge(v2, p2), Reached::Edge(v3, p3_)) => {- let (a, b) = (ending(e2, p2, &[(c12, v2, f12)])?, ending(e3, p3_, &[(c31, v3, f31)])?);- endpt.insert((*e2, *vid, None), a.clone());- endpt.insert((*e1, *vid, Some(f12)), a.clone());- endpt.insert((*e3, *vid, None), b.clone());- endpt.insert((*e1, *vid, Some(f31)), b.clone());- let end = Away::face(face(f23)?);- let c = trace(s1, (s1.u(f12)?, v2, p2), (s1.u(f31)?, v3, p3_), &end, out, fit_tol)?;- list.push((mt::Edge::new(&a, &b, c), vec![Owner::Face(f23), Owner::Strip(*e1)]));- }- (r2, r3) => {- // The end runs from the edge reached across the third face to where- // it crosses the edge `h` from the corner taken in, then across the- // face beyond (`f4`) to the next edge `g`.- let ((ed, fd, td, pd), (ex, fx, past)) = match (r2, r3) {- (Reached::Edge(t, p), past @ Reached::Past { .. }) => ((e2, f12, t, p), (e3, f31, past)),- (past @ Reached::Past { .. }, Reached::Edge(t, p)) => ((e3, f31, t, p), (e2, f12, past)),- _ => return Err(unsupported("a blend running past both edges where it ends")),- };- let Reached::Past { t: tx, p: px, w, g, h, f4 } = past else { return Err(fail("corner")) };- let a = ending(ed, pd, &[(s1.contact(fd)?, td, fd)])?;- let b = builder::vertex(p3(px));- let (_, y) = reach(&curve_of(&h)?, &Away::strip(s1), vtx(&w), fit_tol).ok_or_else(none)?;- let (u_y, v_y) = s1.nearest(y).ok_or_else(none)?;- if s1.at(u_y, v_y).dist(y) > fit_tol * 10.0 {- return Err(none());- }- let yv = builder::vertex(p3(y));- consumed.insert(*ex);- gone.insert(w.id(), w.clone());- endpt.insert((*ed, *vid, None), a.clone());- endpt.insert((*e1, *vid, Some(fd)), a.clone());- endpt.insert((*e1, *vid, Some(fx)), b.clone());- endpt.insert((g, w.id(), None), b.clone());- endpt.insert((h, w.id(), None), yv.clone());- let first = trace(s1, (s1.u(fd)?, td, pd), (u_y, v_y, y), &Away::face(face(f23)?), out, fit_tol)?;- let second = trace(s1, (u_y, v_y, y), (s1.u(fx)?, tx, px), &Away::face(face(f4)?), out, fit_tol)?;- list.push((mt::Edge::new(&a, &yv, first), vec![Owner::Face(f23), Owner::Strip(*e1)]));- list.push((mt::Edge::new(&yv, &b, second), vec![Owner::Face(f4), Owner::Strip(*e1)]));- }- }- }- ([ea, eb], [e3]) => {- let (sa, sb) = (strip_of(ea)?, strip_of(eb)?);- let fab = face_with(*ea, *eb)?;- let (fa3, fb3) = (face_with(*ea, *e3)?, face_with(*eb, *e3)?);- let c3 = curve_of(e3)?;- let none = || too_large("the blend is larger than the neighbouring faces");- // Where the contacts cross on the shared face, and each reaches the third edge.- let (va_q, q) = cross(sa.contact(fab)?, sb.contact(fab)?, face(fab)?, v, sa.own(), fit_tol).ok_or_else(none)?;- let vb_q = param_on(sb.contact(fab)?, q).ok_or_else(none)?;- let (va_x, xa) = cross(sa.contact(fa3)?, &c3, face(fa3)?, v, sa.own(), fit_tol).ok_or_else(none)?;- let (vb_x, xb) = cross(sb.contact(fb3)?, &c3, face(fb3)?, v, sb.own(), fit_tol).ok_or_else(none)?;- let qv = builder::vertex(p3(q));- endpt.insert((*ea, *vid, Some(fab)), qv.clone());- endpt.insert((*eb, *vid, Some(fab)), qv.clone());- if xa.dist(xb) <= fit_tol * 10.0 {- // The crease runs to the third edge.- let x = (xa + xb) * 0.5;- let xv = ending(e3, x, &[(sa.contact(fa3)?, va_x, fa3), (sb.contact(fb3)?, vb_x, fb3)])?;- endpt.insert((*e3, *vid, None), xv.clone());- endpt.insert((*ea, *vid, Some(fa3)), xv.clone());- endpt.insert((*eb, *vid, Some(fb3)), xv.clone());- let (_, out) = sa.end_at(vert);- let c = trace(sa, (sa.u(fab)?, va_q, q), (sa.u(fa3)?, va_x, x), &Away::strip(sb), out, fit_tol)?;- list.push((mt::Edge::new(&qv, &xv, c), vec![Owner::Strip(*ea), Owner::Strip(*eb)]));- } else {- // The strip reaching further along the third edge (`big`) runs on past- // the crease to end on the other's third face.- let (big, small, ebig, esmall, fbig3, fsmall3, x, vbig_x) =- if xa.dist(v) > xb.dist(v) { (sa, sb, *ea, *eb, fa3, fb3, xa, va_x) } else { (sb, sa, *eb, *ea, fb3, fa3, xb, vb_x) };- let vs_q = if esmall == *ea { va_q } else { vb_q };- let (vs_y, y) = reach(small.contact(fsmall3)?, &Away::strip(big), v, fit_tol).ok_or_else(none)?;- let (u_y, v_y) = big.nearest(y).ok_or_else(none)?;- if big.at(u_y, v_y).dist(y) > fit_tol * 10.0 {- return Err(unsupported("blends this different at one corner"));- }- let xv = ending(e3, x, &[(big.contact(fbig3)?, vbig_x, fbig3)])?;- let yv = builder::vertex(p3(y));- endpt.insert((*e3, *vid, None), xv.clone());- endpt.insert((ebig, *vid, Some(fbig3)), xv.clone());- endpt.insert((esmall, *vid, Some(fsmall3)), yv.clone());- let (_, out_s) = small.end_at(vert);- let (_, out_b) = big.end_at(vert);- let crease = trace(small, (small.u(fab)?, vs_q, q), (small.u(fsmall3)?, vs_y, y), &Away::strip(big), out_s, fit_tol)?;- let section = trace(big, (u_y, v_y, y), (big.u(fbig3)?, vbig_x, x), &Away::face(face(fsmall3)?), out_b, fit_tol)?;- list.push((mt::Edge::new(&qv, &yv, crease), vec![Owner::Strip(*ea), Owner::Strip(*eb)]));- list.push((mt::Edge::new(&yv, &xv, section), vec![Owner::Face(fsmall3), Owner::Strip(ebig)]));- }- }- ([e1, e2, e3], []) => {- let s1 = strip_of(e1)?;- let (f12, f23, f31) = (face_with(*e1, *e2)?, face_with(*e2, *e3)?, face_with(*e3, *e1)?);- // The corner ball, from the first strip's section nearest the vertex.- let (v1, _) = s1.end_at(vert);- let start = s1- .sections- .iter()- .min_by(|a, b| (a.0 - v1).abs().total_cmp(&(b.0 - v1).abs()))- .map(|x| x.1.c)- .ok_or_else(|| fail("section"))?;- let (c, [q12, q23, q31]) = corner_ball([face(f12)?, face(f23)?, face(f31)?], start, r, s1.sigma, tol * 100.0)- .ok_or_else(|| unsupported("the ball doesn't fit in the corner"))?;- let (v12, v23, v31) = (builder::vertex(p3(q12)), builder::vertex(p3(q23)), builder::vertex(p3(q31)));- for (e, f, x) in [(e1, f12, &v12), (e2, f12, &v12), (e2, f23, &v23), (e3, f23, &v23), (e3, f31, &v31), (e1, f31, &v31)] {- endpt.insert((*e, *vid, Some(f)), x.clone());- }- let arc = |a: &mt::Vertex, b: &mt::Vertex| -> Result<mt::Edge> {- let m = c + ((vtx(a) - c) + (vtx(b) - c)).normalized().ok_or_else(|| fail("corner arc"))? * r;- Ok(builder::circle_arc(a, b, p3(m)))- };- let (a1, a2, a3) = (arc(&v12, &v31)?, arc(&v12, &v23)?, arc(&v23, &v31)?);- // A sphere with its poles and seam away from the patch.- let n = |f: usize, q: Vec3| face(f).ok().and_then(|g| project(g, q, None)).map(|x| x.1).unwrap_or(Vec3::Z);- let out = (n(f12, q12) + n(f23, q23) + n(f31, q31)).normalized().unwrap_or(Vec3::Z);- let side = out.any_perp();- let (np, sp, back) = (c + side * r, c - side * r, c - out * r);- if g2 {- // A G2 patch on the blends' own end sections, gathered at the ball's pole- // (the point the sphere's meridians are built through above). Each side is- // the strip's section through the ball's contact with the face it shares- // with the previous strip; the strips run on past their edges, so that- // station is found by projecting the contact point, not taken from the- // edge's own end.- let s2 = strip_of(e2)?;- let s3 = strip_of(e3)?;- // The cap's own pole: the ball's point nearest the corner (the sphere- // patch's `back` above is its opposite pole, where the meridian starts).- let apex = c + out * r;- // Side 1 runs from the ball's contact with the face it shares with e3- // round to the one it shares with e2, and so on round the loop: each- // side's last station is the next side's first, at that contact.- let sides = [g2_side(s1, c, r, q31, q12, apex)?, g2_side(s2, c, r, q12, q23, apex)?, g2_side(s3, c, r, q23, q31, apex)?];- let _patch = crate::corner_g2::corner_g2_patch(&sides, apex)?;- // Sewing the patch into the shell is not done yet: it brings its own- // boundary vertices where the strips' contacts end at the ball's contacts- // (`v12`/`v23`/`v31`), and a truck vertex is its allocation, not its point,- // so the rebuilt shell does not close there (rewrapping the section curves- // onto the contacts is the missing step). Refused rather than left open:- // the rolling ball fills the corner instead.- return Err(unsupported(- "a G2 corner sewn between these blends (the patch's section curves do not join the blends' contacts yet)",- ));- }- let meridian = builder::circle_arc(&builder::vertex(p3(np)), &builder::vertex(p3(sp)), p3(back));- let surf = mt::Surface::RevolutedCurve(mt::Processor::new(mt::RevolutedCurve::by_revolution(- meridian.oriented_curve(),- p3(c),- v3(side),- )));- let surf = orient(surf, c + out * r, out * -s1.sigma);- let wire: mt::Wire = vec![a2.clone(), a3.clone(), a1.inverse()].into();- let patch = mt::Face::try_new(vec![wire], surf).map_err(|e| fail(&format!("corner patch: {e}")))?;- patches.push((patch, vec![*e1, *e2, *e3]));- list.push((a1, vec![Owner::Strip(*e1), Owner::Patch]));- list.push((a2, vec![Owner::Strip(*e2), Owner::Patch]));- list.push((a3, vec![Owner::Strip(*e3), Owner::Patch]));- }- _ => return Err(unsupported("this corner")),- }- }-- // Rebuilt edges: contacts per (edge, face), shortened edges per edge.- let end_of =- |id: mt::EdgeID, v: &mt::Vertex, f: Option<usize>| -> mt::Vertex { endpt.get(&(id, v.id(), f)).cloned().unwrap_or_else(|| v.clone()) };- let mut lines: HashMap<(mt::EdgeID, Option<usize>), mt::Edge> = HashMap::new();- let mut line_of = |e: &mt::Edge, f: Option<usize>| -> Result<mt::Edge> {- use mt::Cut;- if let Some(x) = lines.get(&(e.id(), f)) {- return Ok(x.clone());- }- let abs = e.absolute_clone();- let (a, b) = (end_of(e.id(), abs.front(), f), end_of(e.id(), abs.back(), f));- let x = match (f, strips.get(&e.id())) {- (Some(fi), Some(s)) => {- // The contact between its new ends.- let c = s.contact(fi)?;- let none = || too_large("the blend is larger than the neighbouring faces");- let (ta, tb) = (param_on(c, vtx(&a)).ok_or_else(none)?, param_on(c, vtx(&b)).ok_or_else(none)?);- if tb - ta < 1e-9 {- return Err(too_large("the blend is larger than the neighbouring faces"));- }- let mut piece = c.clone();- let _ = piece.cut(tb);- let piece = piece.cut(ta);- mt::Edge::try_new(&a, &b, piece).map_err(|e| fail(&format!("contact: {e}")))?- }- _ => {- let orig = vtx(abs.back()) - vtx(abs.front());- if (vtx(&b) - vtx(&a)).dot(orig) <= size * 1e-9 * orig.len() {- return Err(too_large("the blend is larger than the neighbouring faces"));- }- if matches!(abs.curve(), mt::Curve::Line(_)) {- builder::line(&a, &b)- } else {- let moved = |n: &mt::Vertex, o: &mt::Vertex| (n != o).then(|| n.clone());- super::trim_curved_seam(&abs, moved(&a, abs.front()), moved(&b, abs.back()), size)?- }- }- };- lines.insert((e.id(), f), x.clone());- Ok(x)- };- let changed = |v: &mt::Vertex| touched.contains_key(&v.id()) || gone.contains_key(&v.id());- let moved = |e: &mt::Edge| changed(e.front()) || changed(e.back());- let everywhere: Vec<(mt::Edge, Vec<Owner>)> = pool.values().flatten().cloned().collect();- let mut rec = Rebuild::default();- let mut out: Vec<mt::Face> = Vec::with_capacity(faces.len() + strips.len() + patches.len());- for (fi, f) in faces.iter().enumerate() {- if !f.vertex_iter().any(|v| changed(&v)) {- out.push(f.clone());- continue;- }- let mut wires = Vec::new();- for w in f.boundaries() {- let olds: Vec<mt::Edge> = w.edge_iter().filter(|e| !consumed.contains(&e.id())).cloned().collect();- let mut news = Vec::with_capacity(olds.len());- for e in &olds {- let ne = if strips.contains_key(&e.id()) {- line_of(e, Some(fi))?- } else if moved(e) {- let piece = line_of(e, None)?;- rec.piece(&piece, e);- piece- } else {- news.push(e.clone());- continue;- };- news.push(if e.front() == e.absolute_front() { ne } else { ne.inverse() });- }- let n = news.len();- let mut ws = Vec::new();- for i in 0..n {- let (Some(a), Some(b)) = (news.get(i), news.get((i + 1) % n)) else { continue };- ws.push(a.clone());- if a.back() != b.front() {- ws.extend(connect(a.back(), b.front(), &everywhere, Owner::Face(fi))?);- }- }- wires.push(mt::Wire::from(ws));- }- let rebuilt = mt::Face::try_new(wires, f.oriented_surface()).map_err(|e| fail(&format!("face: {e}")))?;- rec.face(&rebuilt, f);- out.push(rebuilt);- }- // The strips: back along the first face's contact, round the front corner, along the- // second's, round the back corner.- for id in ids {- let (Some(s), Some(e)) = (strips.get(id), edges.get(id)) else { continue };- let (va, vb) = (e.front(), e.back());- let a_forward = faces.get(s.fa).is_some_and(|f| f.boundaries().iter().any(|w| w.edge_iter().any(|x| x.id() == *id && x.front() == va)));- let la = line_of(e, Some(s.fa))?;- let lb = line_of(e, Some(s.fb))?;- let (first, second) = if a_forward { (la.inverse(), lb) } else { (lb.inverse(), la) };- let p1 = pool.get(&va.id()).map(|x| &x[..]).unwrap_or(&[]);- let p2 = pool.get(&vb.id()).map(|x| &x[..]).unwrap_or(&[]);- let mut w = vec![first.clone()];- w.extend(connect(first.back(), second.front(), p1, Owner::Strip(*id))?);- w.push(second.clone());- w.extend(connect(second.back(), first.front(), p2, Owner::Strip(*id))?);- let surface = if s.flip < 0.0 { mt::Invertible::inverse(&s.surface) } else { s.surface.clone() };- let surface = in_proportion(&surface)?;- let blend = mt::Face::try_new(vec![w.into()], surface).map_err(|e| fail(&format!("blend face: {e}")))?;- rec.blend(&blend, [*id]);- out.push(blend);- }- // Corner patches run each section opposite to its strip.- for (mut p, corner) in patches {- let uses = |f: &mt::Face, id: mt::EdgeID| {- f.boundaries().iter().flat_map(|w| w.edge_iter().cloned().collect::<Vec<_>>()).find(|x| x.id() == id).map(|x| x.front().id())- };- let flip = p- .boundaries()- .first()- .and_then(|w| w.edge_iter().next())- .and_then(|pe| out.iter().find_map(|f| uses(f, pe.id())).map(|front| front == pe.front().id()));- if flip == Some(true) {- let surf = p.oriented_surface();- let wires: Vec<mt::Wire> = p.boundaries().iter().map(|w| w.inverse()).collect();- p = mt::Face::try_new(wires, surf).map_err(|e| fail(&format!("corner patch: {e}")))?;- }- rec.blend(&p, corner);- out.push(p);- }- let mut shells = solid.boundaries().clone();- if let Some(sh) = shells.get_mut(si) {- *sh = out.into();- }- let res = Solid::try_new(shells).map_err(|e| fail(&format!("invalid solid: {e}")))?;- Ok((res, rec))- })-}--#[cfg(test)]-#[path = "curvecorner_tests.rs"]-mod tests;diff --git a/crates/kernel/src/curvecorner_tests.rs b/crates/kernel/src/curvecorner_tests.rsindex 947b200324..af199c53c9 100644--- a/crates/kernel/src/curvecorner_tests.rs+++ b/crates/kernel/src/curvecorner_tests.rs@@ -275,9 +275,9 @@ fn rounds_together_in_any_order() {}}-/// The blends this part needs the corner build for (and the back edge, rolled into the tip) at+/// The blends this part has corners in (and the back edge, rounded into the tip) at/// 0.01 and 100 times the part's size, the radius scaled with it: they take off what they take at-/// full size, scaled by the cube, so the build's tolerances and limits follow the model's size.+/// full size, scaled by the cube, so the tolerances and limits follow the model's size.#[test]fn corner_blends_hold_at_any_scale() {let cases: [(&str, Vec<Vec<Vec3>>); 6] = [diff --git a/crates/kernel/src/loopblend.rs b/crates/kernel/src/loopblend.rsdeleted file mode 100644index 89b21a2ef2..0000000000--- a/crates/kernel/src/loopblend.rs+++ /dev/null@@ -1,959 +0,0 @@-//! Blending a whole boundary loop of a planar face whose neighbours are walls standing-//! perpendicular to it (planes, and cylinders with axes along the face normal): a pocket floor,-//! the top outline of an extruded plate. Lines and arcs can meet tangentially or at mitred sharp-//! corners. The face shrinks by the radius, the walls are trimmed by it, and each loop edge-//! gets a blend face: a cylinder (or plane, for a chamfer) along a line, a torus (or cone) along-//! an arc, all meeting along the profile curves at the joints. Sharp joints at perpendicular-//! curved walls follow the intersections of the exact offsets, fitted within tolerance.-//! A chamfer may also set back by different distances on the face and up the walls (two-//! distances, or a distance and an angle: [`loop_chamfer_sides`]).--use std::collections::HashMap;--use solidcraft_geom::Vec3;-use truck_modeling::{self as mt, builder};--use crate::blend::{ChamferSide, too_large};-use crate::body::{Solid, from_p3, p3, v3};-use crate::record::Rebuild;-use crate::{KernelError, Result};--fn unsupported(msg: &str) -> KernelError {- KernelError::Failed(format!("not supported yet: {msg}"))-}--#[derive(Clone, Copy, Debug)]-enum Seg {- Line {- a: Vec3,- b: Vec3,- },- /// Arc from `a` to `b` about `c` turning by `angle` about `axis` (right hand, angle > 0).- Arc {- a: Vec3,- c: Vec3,- axis: Vec3,- angle: f64,- mid: Vec3,- },-}--impl Seg {- fn start(&self) -> Vec3 {- match *self {- Seg::Line { a, .. } | Seg::Arc { a, .. } => a,- }- }- fn end(&self) -> Vec3 {- match *self {- Seg::Line { b, .. } => b,- Seg::Arc { a, c, axis, angle, .. } => turn(a, c, axis, angle),- }- }- /// Unit tangent (direction of travel) at a point of the segment.- fn tangent(&self, p: Vec3) -> Option<Vec3> {- match *self {- Seg::Line { a, b } => (b - a).normalized(),- Seg::Arc { c, axis, .. } => axis.cross(p - c).normalized(),- }- }-}--/// Intersection of two inward offsets nearest their shared corner, in the face plane.-fn offset_joint(prev: &Seg, cur: &Seg, n: Vec3, d: f64) -> Option<Vec3> {- let p = cur.start();- let line_circle = |line: &Seg, arc: &Seg| {- let Seg::Arc { a, c, .. } = *arc else { return None };- let tangent = line.tangent(p)?;- let origin = p + n.cross(tangent) * d;- let radius = a.dist(c) + n.cross(arc.tangent(p)?).dot((p - c).normalized()?) * d;- let foot = origin + tangent * (c - origin).dot(tangent);- let height2 = radius * radius - foot.dist(c).powi(2);- if !(radius > 0.0 && height2 >= 0.0) {- return None;- }- let (a, b) = (foot + tangent * height2.sqrt(), foot - tangent * height2.sqrt());- Some(if a.dist(p) < b.dist(p) { a } else { b })- };- match (prev, cur) {- (Seg::Line { .. }, Seg::Arc { .. }) => line_circle(prev, cur),- (Seg::Arc { .. }, Seg::Line { .. }) => line_circle(cur, prev),- (Seg::Arc { a: a0, c: c0, .. }, Seg::Arc { a: a1, c: c1, .. }) => {- let delta = *c1 - *c0;- let distance = delta.len();- let axis = delta.normalized()?;- let r0 = a0.dist(*c0) + n.cross(prev.tangent(p)?).dot((p - *c0).normalized()?) * d;- let r1 = a1.dist(*c1) + n.cross(cur.tangent(p)?).dot((p - *c1).normalized()?) * d;- let along = (r0 * r0 - r1 * r1 + distance * distance) / (2.0 * distance);- let height2 = r0 * r0 - along * along;- if !(r0 > 0.0 && r1 > 0.0 && height2 >= 0.0) {- return None;- }- let foot = *c0 + axis * along;- let across = n.cross(axis) * height2.sqrt();- let (a, b) = (foot + across, foot - across);- Some(if a.dist(p) < b.dist(p) { a } else { b })- }- _ => None,- }-}--/// A curved-wall joint is generally not planar. Fit its exact offset slices rather than-/// projecting a circular section onto a tangent mitre and revolving that distorted section.-/// `(r, rw)`: the round's radius (`rw` unused), or a chamfer's setbacks on the face and up the wall.-fn offset_profile(prev: &Seg, cur: &Seg, n: Vec3, side: f64, (r, rw): (f64, f64), round: bool, tol: f64) -> Result<mt::Curve> {- use mt::ParametricCurve;- let point = |u: f64| {- let (d, h) = if round {- let (sin, cos) = (u * std::f64::consts::FRAC_PI_2).sin_cos();- (r * (1.0 - sin), r * (1.0 - cos))- } else {- (r * (1.0 - u), rw * u)- };- offset_joint(prev, cur, n, d).map(|p| p + n * (side * h))- };- for count in [8, 16, 32, 64, 128] {- let pts = (0..=count)- .map(|i| point(f64::from(i) / f64::from(count)))- .collect::<Option<Vec<_>>>()- .ok_or_else(|| too_large("the blend's offset walls do not meet"))?;- let curve = crate::build::interpolate_cubic(&pts).ok_or_else(|| unsupported("curved corner profile"))?;- if (0..count).all(|i| {- let u = (f64::from(i) + 0.5) / f64::from(count);- point(u).is_some_and(|p| p.dist(from_p3(curve.subs(u))) <= tol)- }) {- return Ok(mt::Curve::BSplineCurve(curve));- }- }- Err(unsupported("could not fit the curved corner within tolerance"))-}--/// The exact shape of an oriented loop edge (a line, or an arc found from samples).-fn seg_of(e: &mt::Edge, tol: f64) -> Option<Seg> {- use mt::{BoundedCurve, ParametricCurve};- let (a, b) = (from_p3(e.front().point()), from_p3(e.back().point()));- let c = e.oriented_curve();- let (t0, t1) = c.range_tuple();- let pts: Vec<Vec3> = (0..=16).map(|k| from_p3(c.subs(t0 + (t1 - t0) * k as f64 / 16.0))).collect();- let closed = a.dist(b) < tol;- if !closed && pts.iter().all(|p| p.dist_to_segment(a, b) < tol) {- return Some(Seg::Line { a, b });- }- let m = *pts.get(8)?;- // A closed edge (a full circle): fit through points a third of the way round.- let (b_fit, m_fit) = if closed { (*pts.get(5)?, *pts.get(11)?) } else { (b, m) };- let (u, v) = (b_fit - a, m_fit - a);- let w = u.cross(v);- let d = 2.0 * w.len2();- if d < 1e-300 {- return None;- }- let centre = a + (v.cross(w) * u.len2() + w.cross(u) * v.len2()) * (1.0 / d);- let r = centre.dist(a);- if !pts.iter().all(|p| (p.dist(centre) - r).abs() < tol) {- return None;- }- // Turning direction: the travel at a is axis × (a − c).- let t_a = (*pts.get(1)? - a).normalized()?;- let mut axis = w.normalized()?;- if axis.cross(a - centre).dot(t_a) < 0.0 {- axis = -axis;- }- let (ra, rb) = ((a - centre).normalized()?, (b - centre).normalized()?);- let mut angle = ra.dot(rb).clamp(-1.0, 1.0).acos();- if ra.cross(rb).dot(axis) < 0.0 {- angle = std::f64::consts::TAU - angle;- }- if closed {- angle = std::f64::consts::TAU;- }- Some(Seg::Arc { a, c: centre, axis, angle, mid: m })-}--/// Whether an edge is a straight segment: a line, or a curve whose points all lie on the chord-/// (the contact lines of a rolling-ball blend between parallel walls are such curves).-fn is_straight(e: &mt::Edge, tol: f64) -> bool {- use mt::{BoundedCurve, ParametricCurve};- if matches!(e.curve(), mt::Curve::Line(_)) {- return true;- }- let (a, b) = (from_p3(e.absolute_front().point()), from_p3(e.absolute_back().point()));- if a.dist(b) < tol {- return false;- }- let c = e.curve();- let (t0, t1) = c.range_tuple();- (0..=16).all(|k| from_p3(c.subs(t0 + (t1 - t0) * k as f64 / 16.0)).dist_to_segment(a, b) < tol)-}--/// `p` turned about the line (c, axis) by `ang`.-fn turn(p: Vec3, c: Vec3, axis: Vec3, ang: f64) -> Vec3 {- let k = axis.normalized().unwrap_or(Vec3::Z);- let v = p - c;- let (s, co) = ang.sin_cos();- c + v * co + k.cross(v) * s + k * (k.dot(v) * (1.0 - co))-}--/// Split full circles in two halves (an edge needs two ends).-fn pieces(segs: &[Seg]) -> Vec<(usize, Seg)> {- let mut out = Vec::new();- for (i, s) in segs.iter().enumerate() {- match *s {- Seg::Arc { a, c, axis, angle, .. } if angle > std::f64::consts::TAU - 1e-9 => {- let h = std::f64::consts::PI;- let a2 = turn(a, c, axis, h);- out.push((i, Seg::Arc { a, c, axis, angle: h, mid: turn(a, c, axis, h / 2.0) }));- out.push((i, Seg::Arc { a: a2, c, axis, angle: h, mid: turn(a, c, axis, 1.5 * h) }));- }- _ => out.push((i, *s)),- }- }- out-}--fn plane_normal(f: &mt::Face) -> Option<Vec3> {- match f.oriented_surface() {- mt::Surface::Plane(p) => {- let n = p.normal();- Vec3::new(n.x, n.y, n.z).normalized()- }- _ => None,- }-}--/// Outward normal of a face at a point on it.-fn face_normal(f: &mt::Face, p: Vec3) -> Option<Vec3> {- use mt::{ParametricSurface3D, SearchNearestParameter, SearchParameter};- let s = f.oriented_surface();- let (u, v) = s.search_parameter(p3(p), None, 100).or_else(|| s.search_nearest_parameter(p3(p), None, 100))?;- let n = s.normal(u, v);- Vec3::new(n.x, n.y, n.z).normalized()-}--/// Blend `edges` (by id) if they form a boundary loop or neighbouring run of a planar face with-/// perpendicular walls, with what it built from `solid` (each blend face in place of its loop-/// edge). `None` when the edges are not such a loop.-pub(crate) fn loop_blend(solid: &Solid, edge_ids: &[mt::EdgeID], size: f64, r: f64, round: bool) -> Option<Result<(Solid, Rebuild)>> {- loop_blend_sized(solid, edge_ids, size, Sizing::Equal { r, round })-}--/// [`loop_blend`] as a chamfer of `d1` on its first face and the second side by `side`. The-/// first face is the one facing up most (the planar face or its wall, decided as for a straight-/// edge, see [`crate::chamfer_sides`]), the other one with `flip`.-pub(crate) fn loop_chamfer_sides(- solid: &Solid,- edge_ids: &[mt::EdgeID],- size: f64,- d1: f64,- side: ChamferSide,- flip: bool,-) -> Option<Result<(Solid, Rebuild)>> {- loop_blend_sized(solid, edge_ids, size, Sizing::Sides { d1, side, flip })-}--/// How large a loop blend is.-#[derive(Clone, Copy, Debug)]-enum Sizing {- /// A round of radius `r` (`round`), or an equal-distance chamfer of `r`.- Equal { r: f64, round: bool },- /// A chamfer of `d1` on its first face, the second side by `side` ([`loop_chamfer_sides`]).- Sides { d1: f64, side: ChamferSide, flip: bool },-}--fn loop_blend_sized(solid: &Solid, edge_ids: &[mt::EdgeID], size: f64, sizing: Sizing) -> Option<Result<(Solid, Rebuild)>> {- match crate::guard("loop blend", || Ok(loop_blend_inner(solid, edge_ids, size, sizing))) {- Ok(result) => result,- Err(error) => Some(Err(error)),- }-}--fn loop_blend_inner(solid: &Solid, edge_ids: &[mt::EdgeID], size: f64, sizing: Sizing) -> Option<Result<(Solid, Rebuild)>> {- #[cfg(test)]- assert!(crate::guarded(), "loop selection must run inside the kernel guard");- let tol = (size * 1e-6).max(1e-7);- for (si, shell) in solid.boundaries().iter().enumerate() {- let faces: Vec<&mt::Face> = shell.face_iter().collect();- for (fi, f) in faces.iter().enumerate() {- let Some(n) = plane_normal(f) else { continue };- for (wi, w) in f.boundaries().iter().enumerate() {- let ids: Vec<mt::EdgeID> = w.edge_iter().map(|e| e.id()).collect();- if !edge_ids.iter().all(|e| ids.contains(e)) {- continue;- }- if ids.len() == edge_ids.len() {- return Some(build(solid, si, &faces, fi, wi, n, size, tol, sizing, None));- }- // A run of neighbouring edges of the loop (its ends meet unblended edges).- let m = ids.len();- let inside = |i: usize| ids.get(i % m).is_some_and(|x| edge_ids.contains(x));- let starts: Vec<usize> = (0..m).filter(|i| inside(*i) && !inside(*i + m - 1)).collect();- if let [s0] = starts[..]- && (0..edge_ids.len()).all(|j| inside(s0 + j))- {- return Some(build(solid, si, &faces, fi, wi, n, size, tol, sizing, Some((s0, edge_ids.len()))));- }- }- }- }- None-}--#[allow(clippy::too_many_arguments)]-fn build(- solid: &Solid,- si: usize,- faces: &[&mt::Face],- fi: usize,- wi: usize,- n: Vec3,- size: f64,- tol: f64,- sizing: Sizing,- run: Option<(usize, usize)>,-) -> Result<(Solid, Rebuild)> {- #[cfg(test)]- assert!(crate::guarded(), "loop construction must run inside the kernel guard");- // `r`: the round's radius or the equal chamfer's size; an unequal chamfer's first distance- // (its setbacks come from `frame`).- let (r, round, sides) = match sizing {- Sizing::Equal { r, round } => (r, round, None),- Sizing::Sides { d1, side, flip } => (d1, false, Some((side, flip))),- };- let f = faces.get(fi).ok_or_else(|| KernelError::Failed("face".into()))?;- let wire = f.boundaries().get(wi).cloned().ok_or_else(|| KernelError::Failed("loop".into()))?;- let all_edges: Vec<mt::Edge> = wire.edge_iter().cloned().collect();- // The blended edges in loop order: the whole loop, or a run of it (open).- let open = run.is_some();- let edges: Vec<mt::Edge> = match run {- None => all_edges,- Some((s0, len)) => (0..len).filter_map(|j| all_edges.get((s0 + j) % all_edges.len().max(1)).cloned()).collect(),- };- let edge_segs: Vec<Seg> = edges- .iter()- .map(|e| seg_of(e, (size * 1e-5).max(1e-6)))- .collect::<Option<_>>()- .ok_or_else(|| unsupported("loop edges must be lines or arcs"))?;- // Pieces: the loop's edges, full circles in halves; each knows its edge.- let split = pieces(&edge_segs);- let owner: Vec<usize> = split.iter().map(|x| x.0).collect();- let segs: Vec<Seg> = split.iter().map(|x| x.1).collect();- let k = segs.len();- // Joints: k round a whole loop; k + 1 along a run (its two ends included).- let nj = if open { k + 1 } else { k };- let nxt = |i: usize| if open { i + 1 } else { (i + 1) % k };- // Joints: smooth, or sharp where the walls meet in one straight seam (the blends- // then meet in a mitre). A loop can therefore mix lines and arcs at its corners.- let mut mitre = vec![false; nj];- for i in 0..k {- if open && i == 0 {- continue;- }- let (Some(prev), Some(cur)) = (segs.get((i + k - 1) % k), segs.get(i)) else { continue };- let p = cur.start();- let (Some(ta), Some(tb)) = (prev.tangent(p), cur.tangent(p)) else { return Err(unsupported("degenerate loop edge")) };- if ta.dot(tb) < 1.0 - 1e-6 {- if ta.dot(tb) < -1.0 + 1e-3 {- return Err(unsupported("blending a loop with sharp corners next to arcs"));- }- if let Some(x) = mitre.get_mut(i) {- *x = true;- }- }- }- // Walls: the other face of each edge, perpendicular to the face; all on one side.- let mut walls: Vec<usize> = Vec::with_capacity(k);- let mut side = 0.0;- for (oi, s) in owner.iter().zip(&segs) {- let e = edges.get(*oi).ok_or_else(|| KernelError::Failed("edge".into()))?;- let wf = faces- .iter()- .position(|g| !std::ptr::eq(*g, *f) && g.edge_iter().any(|x| x.id() == e.id()))- .ok_or_else(|| unsupported("an edge with one face"))?;- let mid = match *s {- Seg::Line { a, b } => (a + b) * 0.5,- Seg::Arc { mid, .. } => mid,- };- let g = faces.get(wf).ok_or_else(|| KernelError::Failed("wall".into()))?;- let gn = face_normal(g, mid).ok_or_else(|| unsupported("wall normal"))?;- if gn.dot(n).abs() > 1.0 - 1e-6 {- return Err(unsupported("a wall tangent to the face"));- }- // Into the face from the loop: left of travel.- let m = n.cross(s.tangent(mid).ok_or_else(|| unsupported("tangent"))?);- let sd = if gn.dot(m) > 0.0 { 1.0 } else { -1.0 };- if side != 0.0 && sd != side {- return Err(unsupported("a loop that is partly convex and partly concave"));- }- side = sd;- walls.push(wf);- }- // A run ends in the cross-section through its end vertex: the face there must hold it (a- // plane square to the run). One at an angle cuts the blend's two contacts at different- // places, which the rolling-ball blend handles.- if open {- let ends = [- (edges.first().map(|e| e.front().clone()), segs.first().map(|s| (s.start(), *s))),- (edges.last().map(|e| e.back().clone()), segs.last().map(|s| (s.end(), *s))),- ];- for (v, seg) in ends {- let (Some(v), Some((p, s))) = (v, seg) else { return Err(KernelError::Failed("run end".into())) };- let t = s.tangent(p).ok_or_else(|| unsupported("degenerate loop edge"))?;- let square = faces- .iter()- .enumerate()- .filter(|(gi, g)| *gi != fi && !walls.contains(gi) && g.vertex_iter().any(|x| x == v))- .all(|(_, g)| plane_normal(g).is_some_and(|gn| gn.dot(t).abs() > 1.0 - 1e-6));- if !square {- return Err(unsupported("a run of edges ending at a face at an angle"));- }- }- }- // Cross-section at a loop point: into the face (m) and up the wall (t, away from the edge,- // up a concave wall and down a convex one). The ball of radius r touches both at the- // setback s = r / tan(φ/2), φ the angle between m and t; its centre is on the bisector.- let into = |s: &Seg, p: Vec3| -> Vec3 { s.tangent(p).map(|t| n.cross(t)).unwrap_or(Vec3::ZERO) };- let up = |i: usize, p: Vec3| -> Option<Vec3> {- let s = segs.get(i)?;- let g = faces.get(*walls.get(i)?)?;- let gn = face_normal(g, p)?;- let t = s.tangent(p)?.cross(gn).normalized()?;- Some(if t.dot(n * side) < 0.0 { -t } else { t })- };- // An unequal chamfer: whether its first side is the planar face (else the walls). As for a- // straight edge, that is the one facing up most (a curved wall by its mean normal along each- // edge), the other with `flip`; it must be the same all round the loop.- let face_first = match sides {- None => true,- Some((_, flip)) => {- use mt::{BoundedCurve, ParametricCurve};- let up = Vec3::new(1e-6, 1e-3, 1.0);- let face_up = n.dot(up);- let mut first: Option<bool> = None;- for (pi, oi) in owner.iter().enumerate() {- if pi > 0 && owner.get(pi - 1) == Some(oi) {- continue;- }- let (Some(e), Some(g)) = (edges.get(*oi), walls.get(pi).and_then(|w| faces.get(*w))) else {- return Err(KernelError::Failed("loop edge".into()));- };- let c = e.curve();- let (t0, t1) = c.range_tuple();- let ups: Vec<f64> =- (0..=8).filter_map(|j| face_normal(g, from_p3(c.subs(t0 + (t1 - t0) * f64::from(j) / 8.0))).map(|gn| gn.dot(up))).collect();- if ups.is_empty() {- return Err(unsupported("wall normal"));- }- let wall_up = ups.iter().sum::<f64>() / ups.len() as f64;- let mine = (face_up >= wall_up) != flip;- if first.is_some_and(|x| x != mine) {- return Err(unsupported(- "an unequal chamfer round a loop whose first face changes along it (the face faces up more than some walls and less than others)",- ));- }- first = Some(mine);- }- first.unwrap_or(true)- }- };- // Into the face (m), up the wall (t), the setbacks along each and the distance from the edge- // to a round's centre.- let frame = |i: usize, p: Vec3| -> Option<(Vec3, Vec3, f64, f64, f64)> {- let s = segs.get(i)?;- let (m, t) = (into(s, p), up(i, p)?);- let phi = m.dot(t).clamp(-1.0, 1.0).acos();- if !(phi > 1e-3 && phi < std::f64::consts::PI - 1e-3) {- return None;- }- let (sf, sw) = match sides {- None => {- let sb = if round { r / (phi / 2.0).tan() } else { r };- (sb, sb)- }- Some((cs, _)) => {- let d2 = match cs {- ChamferSide::Distance(d) => d,- // The triangle edge–A–B: angle φ at the edge, `a` at A (on the first side).- ChamferSide::Angle(a) => {- let den = (phi + a).sin();- if den <= 1e-9 {- return None;- }- r * a.sin() / den- }- };- if face_first { (r, d2) } else { (d2, r) }- }- };- Some((m, t, sf, sw, r / (phi / 2.0).sin()))- };- if let Some((ChamferSide::Angle(a), _)) = sides {- for (i, s) in segs.iter().enumerate() {- let p = s.start();- if let Some(t) = up(i, p)- && (into(s, p).dot(t).clamp(-1.0, 1.0).acos() + a).sin() <= 1e-9- {- return Err(KernelError::Invalid("that chamfer angle runs past the other face".into()));- }- }- }- // The straight seam between the walls at a sharp joint (direction away from the face).- let seam_dir = |i: usize, p: Vec3| -> Option<Vec3> {- let o = owner.get(i)?;- let v = edges.get(*o)?.front().clone();- let loop_ids: Vec<mt::EdgeID> = edges.iter().map(|e| e.id()).collect();- let mut dirs = Vec::new();- for g in faces {- for e in g.edge_iter() {- if loop_ids.contains(&e.id()) || !(*e.front() == v || *e.back() == v) {- continue;- }- let other = if *e.front() == v { e.back().clone() } else { e.front().clone() };- if let Some(d) = (from_p3(other.point()) - p).normalized()- && !dirs.iter().any(|x: &Vec3| x.dot(d) > 1.0 - 1e-9)- {- dirs.push(d);- }- }- }- match dirs[..] {- [d] => Some(d),- _ => None,- }- };- let mut pa = Vec::with_capacity(nj);- let mut pb = Vec::with_capacity(nj);- let mut centres = Vec::with_capacity(nj);- let mut curved_joint = vec![false; nj];- // Joint i: the start of piece i (the end of the last piece for a run's far end).- let joint_point = |i: usize| if i < k { segs.get(i).map(|s| s.start()) } else { segs.last().map(|s| s.end()) };- for i in 0..nj {- let p = joint_point(i).unwrap_or_default();- let (m, t, sb, sbw, dc) = frame(i.min(k - 1), p).ok_or_else(|| unsupported("the face and wall meet at an angle the blend can't take"))?;- centres.push(p + (m + t).normalized().unwrap_or(m) * dc);- if !mitre.get(i).copied().unwrap_or(false) {- pa.push(p + m * sb);- pb.push(p + t * sbw);- continue;- }- // Sharp joint: the face rails meet where the two offset lines cross; the wall rails- // meet on the seam.- let ip = (i + k - 1) % k;- let (m0, t0, sb0, sbw0, _) = frame(ip, p).ok_or_else(|| unsupported("the face and wall meet at an angle the blend can't take"))?;- let (Some(d0), Some(d1)) = (segs.get(ip).and_then(|x| x.tangent(p)), segs.get(i).and_then(|x| x.tangent(p))) else {- return Err(unsupported("degenerate loop edge"));- };- let x = d0.cross(d1);- let lam = ((m * sb - m0 * sb0).cross(d1)).dot(x) / x.len2();- let exact = (matches!(segs.get(ip), Some(Seg::Arc { .. })) || matches!(segs.get(i), Some(Seg::Arc { .. })))- && t.dot(n * side) > 1.0 - 1e-9- && t0.dot(n * side) > 1.0 - 1e-9;- if exact {- let (Some(prev), Some(cur)) = (segs.get(ip), segs.get(i)) else { return Err(unsupported("corner segments")) };- pa.push(- offset_joint(prev, cur, n, if sides.is_some() { sb } else { r }).ok_or_else(|| too_large("the blend's offset walls do not meet"))?,- );- if let Some(slot) = curved_joint.get_mut(i) {- *slot = true;- }- } else {- pa.push(p + m0 * sb0 + d0 * lam);- }- let e = seam_dir(i, p).ok_or_else(|| unsupported("a sharp corner without one straight seam"))?;- let (h0, h1) = (e.dot(t0), e.dot(t));- if h0 < 1e-6 || h1 < 1e-6 || (sbw0 / h0 - sbw / h1).abs() > tol * 10.0 {- return Err(unsupported("a sharp corner whose walls meet the blend differently"));- }- pb.push(p + e * (sbw / h1));- }- // Sharp joints between straight rim edges can extend beyond the old corner.- // Equal wall slopes reach this path instead of the corner builder, and must- // also reject an extension through the outer wall or another hole.- for (i, q) in pa.iter().enumerate() {- // Smooth arc transitions and open-run ends retain their existing checks.- if !mitre.get(i).copied().unwrap_or(false) {- continue;- }- let p = joint_point(i).ok_or_else(|| unsupported("degenerate loop joint"))?;- if !crate::blend::extension_fits(f, p, *q, size * 1e-7) {- return Err(too_large("the blend is larger than the neighbouring faces"));- }- }- // The offset arcs must not turn inside out; an arc of exactly the blend's radius shrinks- // to a point (a rounded corner rounded again: the blend there is a sphere).- let mut collapsed = vec![false; k.max(nj)];- for (i, s) in segs.iter().enumerate() {- if let Seg::Arc { a, c, .. } = *s {- let toward = into(s, a).dot(c - a) > 0.0;- // An unequal chamfer's offset on the face; it never ends in a point (a cone's apex).- if sides.is_some() {- let reach = frame(i, a).map(|x| x.2).ok_or_else(|| unsupported("the face and wall meet at an angle the blend can't take"))?;- if toward && a.dist(c) <= reach + tol * 10.0 {- return Err(too_large("the chamfer is larger than a corner radius"));- }- continue;- }- if toward && (a.dist(c) - r).abs() <= tol * 10.0 && !mitre.get(i).copied().unwrap_or(true) && !mitre.get(nxt(i)).copied().unwrap_or(true)- {- if let Some(x) = collapsed.get_mut(i) {- *x = true;- }- } else if toward && a.dist(c) <= r + tol {- return Err(too_large("the blend is larger than a corner radius"));- }- }- }- if collapsed.iter().all(|x| *x) {- return Err(too_large("the blend is larger than a corner radius"));- }- let mut va: Vec<mt::Vertex> = pa.iter().map(|p| builder::vertex(p3(*p))).collect();- // A collapsed piece starts and ends at one vertex.- for i in 0..k {- if collapsed.get(i).copied().unwrap_or(false)- && let Some(v) = va.get(i).cloned()- && let Some(slot) = va.get_mut(nxt(i))- {- *slot = v;- }- }- // Model vertices at the joints (the second half of a circle starts at none).- let mut joint_vertex: Vec<Option<mt::Vertex>> = (0..k)- .map(|i| if i == 0 || owner.get(i) != owner.get(i - 1) { owner.get(i).and_then(|o| edges.get(*o)).map(|e| e.front().clone()) } else { None })- .collect();- if open {- joint_vertex.push(edges.last().map(|e| e.back().clone()));- }- let loop_ids: Vec<mt::EdgeID> = edges.iter().map(|e| e.id()).collect();- let on_face = |e: &mt::Edge| f.edge_iter().any(|x| x.id() == e.id());- // A blend as tall as its walls uses them up: each wall seam ends exactly where the- // wall-side rail would, at a vertex of the walls' far boundary, which becomes the rail.- let wall_end: Vec<Option<mt::Vertex>> = joint_vertex- .iter()- .zip(&pb)- .map(|(v, target)| {- let v = v.as_ref()?;- faces.iter().flat_map(|g| g.edge_iter()).find_map(|e| {- if loop_ids.contains(&e.id()) || on_face(&e) || !(e.front() == v || e.back() == v) || !matches!(e.curve(), mt::Curve::Line(_)) {- return None;- }- let other = if e.front() == v { e.back().clone() } else { e.front().clone() };- (from_p3(other.point()).dist(*target) <= tol * 10.0).then_some(other)- })- })- .collect();- let used_up = wall_end.iter().filter(|x| x.is_some()).count();- if used_up > 0 && (used_up != nj || open) {- return Err(unsupported("the blend uses up only part of the walls"));- }- let walls_used_up = used_up > 0;- let vb: Vec<mt::Vertex> = match walls_used_up {- true => wall_end.into_iter().flatten().collect(),- false => pb.iter().map(|p| builder::vertex(p3(*p))).collect(),- };- let centre = |i: usize| centres.get(i).copied().unwrap_or_default();- let profile_mid = |i: usize| {- let (Some(p), c) = (joint_point(i), centre(i)) else { return Vec3::ZERO };- c + (p - c).normalized().unwrap_or(n) * r- };- // Profiles at the joints (face side → wall side).- let mut profiles: Vec<mt::Edge> = Vec::with_capacity(nj);- for i in 0..nj {- let (Some(a), Some(b)) = (va.get(i), vb.get(i)) else { return Err(KernelError::Failed("joint".into())) };- if curved_joint.get(i).copied().unwrap_or(false) {- let (Some(prev), Some(cur)) = (segs.get((i + k - 1) % k), segs.get(i)) else { return Err(unsupported("corner segments")) };- let setbacks = match sides {- None => (r, r),- Some(_) => joint_point(i).and_then(|p| frame(i.min(k - 1), p)).map(|x| (x.2, x.3)).ok_or_else(|| unsupported("frame"))?,- };- let curve = offset_profile(prev, cur, n, side, setbacks, round, (setbacks.0.min(setbacks.1) * 1e-7).max(1e-9))?;- profiles.push(mt::Edge::try_new(a, b, curve).map_err(|e| KernelError::Failed(format!("curved corner: {e}")))?);- continue;- }- if !round {- profiles.push(builder::line(a, b));- continue;- }- if !mitre.get(i).copied().unwrap_or(false) {- profiles.push(builder::circle_arc(a, b, p3(profile_mid(i))));- continue;- }- // Mitre: the cross-section circle of this edge's blend where it passes the face-side- // point, slid along the edge onto the mitre plane (an ellipse arc, on both blends).- let p = segs.get(i).map(|x| x.start()).unwrap_or_default();- let d1 = segs.get(i).and_then(|x| x.tangent(p)).ok_or_else(|| unsupported("tangent"))?;- let (pa_i, pb_i) = (from_p3(a.point()), from_p3(b.point()));- let lam = (pa_i - p).dot(d1);- let (_, t, sb, _, _) = frame(i, p).ok_or_else(|| unsupported("frame"))?;- let cc = centre(i) + d1 * lam;- let q = p + t * sb + d1 * lam;- let mid = cc + ((pa_i - cc) + (q - cc)).normalized().unwrap_or(t) * r;- // q projects onto the wall rail at pb_i; fitting through pb_i before projection- // would distort the circular cross-section at mixed line/arc corners.- let arc = builder::circle_arc(&builder::vertex(p3(pa_i)), &builder::vertex(p3(q)), p3(mid));- let nb = (pa_i - p).cross(pb_i - p).normalized().ok_or_else(|| unsupported("mitre plane"))?;- let den = d1.dot(nb);- if den.abs() < 1e-9 {- return Err(unsupported("mitre plane along the edge"));- }- // x ↦ x − d1 ((x − p)·nb) / (d1·nb), column-major.- let col = |j: usize| {- let ej = [Vec3::X, Vec3::Y, Vec3::Z][j];- ej - d1 * (ej.dot(nb) / den)- };- let (c0, c1, c2) = (col(0), col(1), col(2));- let tr = d1 * (p.dot(nb) / den);- let mat = mt::Matrix4::new(c0.x, c0.y, c0.z, 0.0, c1.x, c1.y, c1.z, 0.0, c2.x, c2.y, c2.z, 0.0, tr.x, tr.y, tr.z, 1.0);- let mut curve = arc.curve();- mt::Transformed::transform_by(&mut curve, mat);- profiles.push(mt::Edge::new(a, b, curve));- }- let rail = |vs: &[mt::Vertex], i: usize, offset: &dyn Fn(Vec3, &Seg) -> Vec3| -> Option<mt::Edge> {- let s = segs.get(i)?;- if std::ptr::eq(vs, va.as_slice()) && collapsed.get(i).copied().unwrap_or(false) {- return None;- }- let (a, b) = (vs.get(i)?, vs.get(nxt(i))?);- Some(match *s {- Seg::Line { .. } => builder::line(a, b),- Seg::Arc { mid, .. } => builder::circle_arc(a, b, p3(offset(mid, s))),- })- };- let piece_of = |s: &Seg| segs.iter().position(|x| std::ptr::eq(x, s)).unwrap_or(0);- let face_off = |p: Vec3, s: &Seg| {- let i = piece_of(s);- frame(i, p).map(|(m, _, sb, _, _)| p + m * sb).unwrap_or(p)- };- let wall_off = |p: Vec3, s: &Seg| {- let i = piece_of(s);- frame(i, p).map(|(_, t, _, sbw, _)| p + t * sbw).unwrap_or(p)- };- let face_rails: Vec<Option<mt::Edge>> = (0..k).map(|i| rail(&va, i, &face_off)).collect();- if face_rails.iter().zip(&collapsed).any(|(r, c)| r.is_none() && !c) {- return Err(KernelError::Failed("rail".into()));- }- let wall_rails: Vec<mt::Edge> = if walls_used_up {- // Each piece's wall rail is the wall's far edge between the joints, where the offset- // rail lies (checked at the piece's middle).- (0..k)- .map(|i| -> Result<mt::Edge> {- let (Some(a), Some(b), Some(s), Some(wf)) = (vb.get(i), vb.get(nxt(i)), segs.get(i), walls.get(i)) else {- return Err(KernelError::Failed("rail".into()));- };- let mid = match *s {- Seg::Line { a, b } => (a + b) * 0.5,- Seg::Arc { mid, .. } => mid,- };- let want = wall_off(mid, s);- let g = faces.get(*wf).ok_or_else(|| KernelError::Failed("wall".into()))?;- g.edge_iter()- .find(|e| (e.front() == a && e.back() == b) || (e.front() == b && e.back() == a))- .filter(|e| crate::blend::edge_mid(e).is_some_and(|m| m.dist(want) <= tol * 10.0))- .map(|e| if e.front() == a { e.clone() } else { e.inverse() })- .ok_or_else(|| unsupported("the blend uses up walls whose far edge is not where the blend ends"))- })- .collect::<Result<_>>()?- } else {- (0..k).map(|i| rail(&vb, i, &wall_off)).collect::<Option<_>>().ok_or_else(|| KernelError::Failed("rail".into()))?- };- // Seams between neighbouring walls at the joints get shorter.- // At a run's ends the face's next loop edges stop at the face-side point.- let mut seam_subst: HashMap<mt::EdgeID, mt::Edge> = HashMap::new();- let mut seam_ends: HashMap<mt::EdgeID, (mt::Edge, Option<mt::Vertex>, Option<mt::Vertex>)> = HashMap::new();- for (i, v) in joint_vertex.iter().enumerate() {- let Some(v) = v else { continue };- for g in faces {- for e in g.edge_iter() {- if loop_ids.contains(&e.id()) || !(e.front() == v || e.back() == v) {- continue;- }- // Once per edge and joint (an edge between both ends of a run is met twice).- if seam_ends.get(&e.id()).is_some_and(|x: &(mt::Edge, Option<mt::Vertex>, Option<mt::Vertex>)| {- (x.0.absolute_front() == v && x.1.is_some()) || (x.0.absolute_back() == v && x.2.is_some())- }) {- continue;- }- let (fa, fb) = (e.absolute_front().clone(), e.absolute_back().clone());- let other = if &fa == v { &fb } else { &fa };- if !is_straight(&e, (size * 1e-5).max(1e-6)) {- return Err(unsupported("the wall seams must be straight"));- }- let face_side = on_face(&e);- // A used-up wall goes, seams and all.- if walls_used_up && !face_side {- continue;- }- let target = if face_side { pa.get(i) } else { pb.get(i) }.copied().unwrap_or_default();- let along = (from_p3(other.point()) - from_p3(v.point())).dot(target - from_p3(v.point()));- let reach = (target - from_p3(v.point())).len2();- if along <= reach + tol {- return Err(too_large(if face_side { "the blend is longer than the next edge" } else { "the blend is taller than the walls" }));- }- let nb = if face_side { va.get(i) } else { vb.get(i) }.ok_or_else(|| KernelError::Failed("joint".into()))?;- let slot = seam_ends.entry(e.id()).or_insert_with(|| (e.absolute_clone(), None, None));- if &fa == v {- slot.1 = Some(nb.clone());- } else {- slot.2 = Some(nb.clone());- }- }- }- }- for (id, (e, a, b)) in seam_ends {- let a = a.unwrap_or_else(|| e.absolute_front().clone());- let b = b.unwrap_or_else(|| e.absolute_back().clone());- if from_p3(a.point()).dist(from_p3(b.point())) < tol * 10.0 {- return Err(too_large("the blend is longer than the next edge"));- }- seam_subst.insert(id, builder::line(&a, &b));- }- // Rebuild faces.- let idx_of = |id: mt::EdgeID| loop_ids.iter().position(|x| *x == id);- let rebuild = |g: &mt::Face, rails: &[Option<mt::Edge>]| -> Result<mt::Face> {- let mut wires = Vec::new();- for w in g.absolute_boundaries() {- let mut es = Vec::new();- for e in w.edge_iter() {- if let Some(i) = idx_of(e.id()) {- // Rails run in loop order; an edge used the other way takes them reversed.- let mine: Vec<&mt::Edge> = owner.iter().zip(rails).filter(|(o, _)| **o == i).filter_map(|(_, r)| r.as_ref()).collect();- let same = edges.get(i).is_some_and(|le| le.orientation() == e.orientation());- if same {- es.extend(mine.into_iter().cloned());- } else {- es.extend(mine.into_iter().rev().map(|r| r.inverse()));- }- continue;- }- let ne = if let Some(s) = seam_subst.get(&e.id()) {- if e.front() == e.absolute_front() { s.clone() } else { s.inverse() }- } else {- e.clone()- };- es.push(ne);- }- // A run's end: the face's edge and the wall's seam now stop at the two ends of the- // end profile, which closes the gap between them.- if open {- let mut fixed: Vec<mt::Edge> = Vec::with_capacity(es.len() + 2);- let m = es.len();- for j in 0..m {- let (Some(cur), Some(next)) = (es.get(j), es.get((j + 1) % m)) else { continue };- fixed.push(cur.clone());- if cur.back() == next.front() {- continue;- }- for ji in [0, nj - 1] {- let (Some(a), Some(b), Some(pr)) = (va.get(ji), vb.get(ji), profiles.get(ji)) else { continue };- if cur.back() == a && next.front() == b {- fixed.push(pr.clone());- } else if cur.back() == b && next.front() == a {- fixed.push(pr.inverse());- }- }- }- es = fixed;- }- wires.push(mt::Wire::from(es));- }- crate::heal::absolute_face(g, wires).ok_or_else(|| KernelError::Failed("loop blend: a face could not be rebuilt".into()))- };- let mut out: Vec<mt::Face> = Vec::new();- let mut rec = Rebuild::default();- rec.pieces(&seam_subst);- for (gi, g) in faces.iter().enumerate() {- let rebuilt = if gi == fi {- rebuild(g, &face_rails)?- } else if walls.contains(&gi) {- if walls_used_up {- continue;- }- let wr: Vec<Option<mt::Edge>> = wall_rails.iter().cloned().map(Some).collect();- rebuild(g, &wr)?- } else if g.edge_iter().any(|e| seam_subst.contains_key(&e.id())) {- rebuild(g, &[])?- } else {- (*g).clone()- };- rec.face(&rebuilt, g);- out.push(rebuilt);- }- // Blend faces.- use mt::{ParametricSurface3D, SearchNearestParameter};- for i in 0..k {- let (Some(s), Some(pr), Some(pr_next), Some(fr), Some(wr)) =- (segs.get(i), profiles.get(i), profiles.get(nxt(i)), face_rails.get(i), wall_rails.get(i))- else {- continue;- };- let swept: mt::Shell = match *s {- Seg::Line { a, b } => {- // The cross-section at the start, swept along the whole edge and beyond (the- // face may reach past the edge's ends at a mitre).- let d = (b - a).normalized().ok_or_else(|| unsupported("degenerate loop edge"))?;- let (_, t, sb, sbw, _) = frame(i, a).ok_or_else(|| unsupported("frame"))?;- let m = into(s, a);- let ext = size;- let back = d * -ext;- let (fa, wa) = (builder::vertex(p3(a + m * sb + back)), builder::vertex(p3(a + t * sbw + back)));- let base = if round { builder::circle_arc(&fa, &wa, p3(profile_mid(i) + back)) } else { builder::line(&fa, &wa) };- vec![builder::tsweep(&base, v3(b - a + d * (2.0 * ext)))].into()- }- Seg::Arc { .. } if collapsed.get(i).copied().unwrap_or(false) => {- // A sphere about the profile's centre, its poles well away from the corner- // patch (a pole inside a face's corner confuses the meshing).- let c = centre(i);- let corners = [from_p3(pr.front().point()), from_p3(pr.back().point()), from_p3(pr_next.back().point())];- let g = corners.iter().fold(Vec3::ZERO, |acc, q| acc + (*q - c).normalized().unwrap_or(Vec3::ZERO));- let g = g.normalized().ok_or_else(|| unsupported("sphere corner"))?;- let w = g.any_perp();- let (top, eq, bottom) = (builder::vertex(p3(c + w * r)), p3(c + g * r), builder::vertex(p3(c - w * r)));- let meridian = builder::circle_arc(&top, &bottom, eq);- builder::rsweep(&meridian, p3(c), v3(w), mt::Rad(std::f64::consts::TAU))- }- Seg::Arc { c, axis, angle, .. }- if !curved_joint.get(i).copied().unwrap_or(false) && !curved_joint.get(nxt(i)).copied().unwrap_or(false) =>- {- builder::rsweep(pr, p3(c), v3(axis), mt::Rad(angle))- }- Seg::Arc { a, c, axis, angle, .. } => {- // Sweep a radial section, not the shared corner curve: the latter can be- // nonplanar and would change the round's radius all along this edge.- let (_, t, sb, sbw, _) = frame(i, a).ok_or_else(|| unsupported("frame"))?;- let (fa, wa) = (builder::vertex(p3(a + into(s, a) * sb)), builder::vertex(p3(a + t * sbw)));- let base = if round { builder::circle_arc(&fa, &wa, p3(profile_mid(i))) } else { builder::line(&fa, &wa) };- builder::rsweep(&base, p3(c), v3(axis), mt::Rad(angle))- }- };- let mut surf = swept.face_iter().next().map(|x| x.oriented_surface()).ok_or_else(|| KernelError::Failed("blend surface".into()))?;- // Outward: toward the profile centre on a concave loop, away from it on a convex one.- // An unequal chamfer's profile has no centre: its middle, away from the edge on a concave- // loop (where the chamfer fills) and toward it on a convex one.- let (c, mid) = (centre(i), profile_mid(i));- let (mid, outward) = match (sides, joint_point(i)) {- (Some(_), Some(p)) => {- let m = (from_p3(pr.front().point()) + from_p3(pr.back().point())) * 0.5;- (m, (m - p) * side)- }- _ => (mid, (c - mid) * side),- };- if let Some((u, v)) = surf.search_nearest_parameter(p3(mid), None, 100) {- let nn = surf.normal(u, v);- if Vec3::new(nn.x, nn.y, nn.z).dot(outward) < 0.0 {- surf = mt::Invertible::inverse(&surf);- }- }- let w: mt::Wire = match fr {- Some(fr) => vec![fr.inverse(), pr.clone(), wr.clone(), pr_next.inverse()].into(),- None => vec![pr.clone(), wr.clone(), pr_next.inverse()].into(),- };- let face = mt::Face::try_new(vec![w.clone()], surf.clone()).map_err(|e| KernelError::Failed(format!("blend face: {e}")))?;- // In place of the loop edge this piece runs along (a full circle's two halves both).- rec.blend(&face, owner.get(i).and_then(|o| edges.get(*o)).map(|e| e.id()));- out.push(face);- }- let mut shells = solid.boundaries().clone();- if let Some(sh) = shells.get_mut(si) {- *sh = out.into();- }- let solid = Solid::try_new(shells).map_err(|e| KernelError::Failed(format!("loop blend produced an invalid solid: {e}")))?;- Ok((solid, rec))-}