SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
fix(kernel): fillets that end in faces at an angle or across two faces (#362)
Iraklis Kourtisafcec4d0bdb3
diff --git a/crates/kernel/src/blend.rs b/crates/kernel/src/blend.rsindex ec651c8966..9f21ccb797 100644--- a/crates/kernel/src/blend.rs+++ b/crates/kernel/src/blend.rs@@ -209,15 +209,27 @@ fn blend_geometry() -> Result<(Solid, Rebuild)> {let s = setback(r, phi, shape);let tol = (size * 1e-7).max(1e-9);- // End faces and the side edges at each end. A side edge that the fillet's setback uses up- // exactly is consumed: the rail ends at its far vertex (`ca`, `cb`).+ // The arc centre is r from both faces (inside the material for a convex edge, outside for a+ // concave one), in the cross-section through `p`.+ let centre = |p: Vec3| p + t1 * s + n1 * (r * side);+ // Each end of the blend lies in one more face (the end face, square to the edge or at an+ // angle) or, for a fillet, in two that meet at the edge's end (Vida, Martin and Várady 1994:+ // trimlines joined across existing faces): the blend then crosses the edge between them,+ // which is cut back to the crossing. The rails run parallel to the edge, set back by s in+ // their side faces, and end in the end plane they reach (`ga` from f1, `gb` from f2). A side+ // edge that the setback uses up exactly is consumed: the rail ends at its far vertex (`ca`,+ // `cb`; one end face only).struct End {v: mt::Vertex,- g: usize,+ g: Vec<usize>,e1: mt::Edge,e2: mt::Edge,+ /// The edge between two end faces, and where the blend crosses it.+ e3: Option<(mt::Edge, Vec3)>,a: Vec3,b: Vec3,+ /// The end's section of the blend, from A to B (across both faces when two).+ planes: Vec<(Vec3, Vec3)>,ca: Option<mt::Vertex>,cb: Option<mt::Vertex>,}@@ -225,70 +237,98 @@ fn blend_geometry(for (v, p) in [(&v0, p0), (&v1, p1)] {let at_v: Vec<usize> = (0..faces.len()).filter(|i| faces.get(*i).is_some_and(|f| f.vertex_iter().any(|x| &x == v))).collect();let others: Vec<usize> = at_v.iter().copied().filter(|i| *i != i1 && *i != i2).collect();- let [g] = others[..] else { return Err(unsupported("each end of the edge must touch exactly one more face")) };- let gf = faces.get(g).ok_or_else(|| KernelError::Failed("face".into()))?;- let ng = plane_normal(gf).ok_or_else(|| unsupported("the faces at the edge ends must be planar"))?;- if shape == Shape::Round && ng.dot(d).abs() < 1.0 - 1e-9 {- return Err(unsupported("the faces at the edge ends must be perpendicular to the edge"));- }- if ng.dot(d).abs() < 1e-9 {- return Err(unsupported("an end face parallel to the edge"));- }- // Each rail is parallel to the original edge and set back by s in its side- // face. Slide its endpoint along d until it lies on the actual end plane.- let endpoint = |t: Vec3| {- let q = p + t * s;- if shape == Shape::Flat { q - d * (ng.dot(t) * s / ng.dot(d)) } else { q }+ // The edge at v that face `fi` shares with face `g`, other than the blended edge.+ let shared = |fi: usize, g: usize| -> Option<mt::Edge> {+ let (f, gf) = (faces.get(fi)?, faces.get(g)?);+ f.edge_iter().find(|e| e.id() != edge.id() && (e.front() == v || e.back() == v) && gf.edge_iter().any(|x| x.id() == e.id()))+ };+ let (ga, gb) = match others[..] {+ [g] => (g, g),+ [x, y] if shape == Shape::Round && shared(i1, x).is_some() && shared(i2, y).is_some() => (x, y),+ [x, y] if shape == Shape::Round && shared(i1, y).is_some() && shared(i2, x).is_some() => (y, x),+ _ => return Err(unsupported("each end of the edge must touch exactly one more face")),};- let (a, b) = (endpoint(t1), endpoint(t2));- // Edges at v shared by g with f1 and with f2.- let shared = |fi: usize| -> Result<mt::Edge> {- let f = faces.get(fi).ok_or_else(|| KernelError::Failed("face".into()))?;- f.edge_iter()- .find(|e| e.id() != edge.id() && (e.front() == v || e.back() == v) && gf.edge_iter().any(|x| x.id() == e.id()))- .ok_or_else(|| unsupported("unexpected corner topology"))+ let normal = |g: usize| -> Result<Vec3> {+ let n = faces.get(g).and_then(|f| plane_normal(f)).ok_or_else(|| unsupported("the faces at the edge ends must be planar"))?;+ if n.dot(d).abs() < 1e-9 {+ return Err(unsupported("an end face parallel to the edge"));+ }+ Ok(n)};- let (e1, e2) = (shared(i1)?, shared(i2)?);+ let (na, nb) = (normal(ga)?, normal(gb)?);+ // Slide a point of the cross-section through `p` along d onto the end plane through p.+ let slide = |x: Vec3, n: Vec3| x - d * (n.dot(x - p) / n.dot(d));+ let (a, b) = (slide(p + t1 * s, na), slide(p + t2 * s, nb));+ let (e1, e2) = (+ shared(i1, ga).ok_or_else(|| unsupported("unexpected corner topology"))?,+ shared(i2, gb).ok_or_else(|| unsupported("unexpected corner topology"))?,+ );let mut consumed: [Option<mt::Vertex>; 2] = [None, None];- for (k, (e, q, t, fi)) in [(&e1, a, t1, i1), (&e2, b, t2, i2)].into_iter().enumerate() {+ for (k, (e, q, fi)) in [(&e1, a, i1), (&e2, b, i2)].into_iter().enumerate() {if !matches!(e.curve(), mt::Curve::Line(_)) {return Err(unsupported("the edges at the corners must be straight"));}let far = if e.front() == v { e.back().clone() } else { e.front().clone() };- let other = vtx(&far);- let delta = other - p;- if shape == Shape::Round {- // Fillets retain the square-end check: the original corner edge- // must run in the setback direction and have enough length left,- // or exactly the setback (the edge is consumed).- let along = delta.dot(t);- if (delta - t * along).len() > tol * 100.0 + 1e-7 || along < s - tol {- return Err(unsupported("the blend is larger than the neighbouring faces"));- }- if along <= s + tol- && let Some(slot) = consumed.get_mut(k)- {+ let delta = vtx(&far) - p;+ let len = delta.len();+ let dir = delta.normalized().ok_or_else(|| unsupported("zero-length corner edge"))?;+ let along = (q - p).dot(dir);+ if (q - p - dir * along).len() > tol * 100.0 + 1e-7 {+ return Err(unsupported("the blend is larger than the neighbouring faces"));+ }+ // A fillet's setback that uses up the side edge exactly consumes it.+ if shape == Shape::Round && ga == gb && (along - len).abs() <= tol {+ if let Some(slot) = consumed.get_mut(k) {*slot = Some(far);}continue;}- let len = delta.len();- let dir = delta.normalized().ok_or_else(|| unsupported("zero-length corner edge"))?;- let along = (q - p).dot(dir);- // An inner rim extends the neighbouring rim edge away from its other- // vertex. This is valid only within the trimmed side face.- if (q - p - dir * along).len() > tol * 100.0 + 1e-7- || along >= len - tol- || (along < 0.0 && !faces.get(fi).is_some_and(|f| extension_fits(f, p, q, tol)))- {+ // A rail ending before the old corner extends the neighbouring rim edge away from its+ // other vertex: valid only within the trimmed side face.+ if along >= len - tol || (along < 0.0 && !faces.get(fi).is_some_and(|f| extension_fits(f, p, q, tol))) {return Err(unsupported("the blend is larger than the neighbouring faces"));}}+ // Across two end faces: where the blend's cylinder crosses the edge between them, on the+ // blend's side of the axis (between its two rails).+ let e3 = if ga == gb {+ None+ } else {+ let (Some(fa), Some(fb)) = (faces.get(ga), faces.get(gb)) else { return Err(KernelError::Failed("face".into())) };+ let e3 = fa+ .edge_iter()+ .find(|e| (e.front() == v || e.back() == v) && fb.edge_iter().any(|x| x.id() == e.id()))+ .ok_or_else(|| unsupported("unexpected corner topology"))?;+ if !matches!(e3.curve(), mt::Curve::Line(_)) {+ return Err(unsupported("the edges at the corners must be straight"));+ }+ let far = if e3.front() == v { vtx(e3.back()) } else { vtx(e3.front()) };+ let (len3, u) = (far.dist(p), (far - p).normalized().ok_or_else(|| unsupported("zero-length corner edge"))?);+ let c0 = centre(p);+ let perp = |x: Vec3| x - d * x.dot(d);+ let (w, up) = (perp(p - c0), perp(u));+ // |w + λ up|² = r²+ let (qa, qb, qc) = (up.len2(), 2.0 * w.dot(up), w.len2() - r * r);+ let disc = qb * qb - 4.0 * qa * qc;+ if qa < 1e-18 || disc < 0.0 {+ return Err(unsupported("the blend does not cross the edge between the end faces"));+ }+ let (ra, rb) = (perp(p + t1 * s - c0), perp(p + t2 * s - c0));+ let angle = |x: Vec3, y: Vec3| (x.dot(y) / (x.len() * y.len()).max(1e-300)).clamp(-1.0, 1.0).acos();+ let between = |x: Vec3| (angle(ra, x) + angle(x, rb) - angle(ra, rb)).abs() < 1e-6;+ let root = [(-qb - disc.sqrt()) / (2.0 * qa), (-qb + disc.sqrt()) / (2.0 * qa)]+ .into_iter()+ .filter(|l| *l > tol && *l < len3 - tol)+ .find(|l| between(w + up * *l))+ .ok_or_else(|| unsupported("the blend does not cross the edge between the end faces"))?;+ Some((e3.clone(), p + u * root))+ };+ let planes = if ga == gb { vec![(p, na)] } else { vec![(p, na), (p, nb)] };let [ca, cb] = consumed;- ends.push(End { v: v.clone(), g, e1, e2, a, b, ca, cb });+ ends.push(End { v: v.clone(), g: if ga == gb { vec![ga] } else { vec![ga, gb] }, e1, e2, e3, a, b, planes, ca, cb });}let [end0, end1] = &ends[..] else { return Err(KernelError::Failed("ends".into())) };- if end0.g == end1.g {+ if end0.g.iter().any(|g| end1.g.contains(g)) {return Err(unsupported("both ends touch the same face"));}if (end1.a - end0.a).dot(d) <= tol || (end1.b - end0.b).dot(d) <= tol {@@ -316,42 +356,70 @@ fn blend_geometry(let rail_a = used_up(i1, &end0.ca, &end1.ca)?;let rail_b = used_up(i2, &end0.cb, &end1.cb)?;let vertex = |c: &Option<mt::Vertex>, p: Vec3| c.clone().unwrap_or_else(|| builder::vertex(p3(p)));- let a0 = vertex(&end0.ca, end0.a);- let b0 = vertex(&end0.cb, end0.b);- let a1 = vertex(&end1.ca, end1.a);- let b1 = vertex(&end1.cb, end1.b);- // Corner curves on the end faces (A → B) and the blend surface. The arc centre is r from- // both faces (inside the material for a convex edge, outside for a concave one); the arc's- // middle is the point nearest the old edge.- let centre = |p: Vec3| p + t1 * s + n1 * (r * side);- let arc_mid = |p: Vec3| {+ // Corner curves on the end faces (A → B): the blend's cross-section through the end vertex,+ // slid along the edge onto each end plane (an ellipse arc; the circle itself on a square+ // end face).+ let section = |p: Vec3, va: &mt::Vertex, vb: &mt::Vertex, from: Vec3, to: Vec3, plane: (Vec3, Vec3)| -> Result<mt::Edge> {+ if shape == Shape::Flat {+ return Ok(builder::line(va, vb));+ }let c = centre(p);- c + (p - c).normalized().unwrap_or(-n1) * r- };- let corner = |a: &mt::Vertex, b: &mt::Vertex, p: Vec3| -> mt::Edge {- match shape {- Shape::Round => builder::circle_arc(a, b, p3(arc_mid(p))),- Shape::Flat => builder::line(a, b),+ let mid = c + ((from - c) + (to - c)).normalized().unwrap_or(-n1) * r;+ let (o, n) = plane;+ if n.dot(d).abs() >= 1.0 - 1e-12 {+ return Ok(builder::circle_arc(va, vb, p3(mid)));}+ let arc = builder::circle_arc(&builder::vertex(p3(from)), &builder::vertex(p3(to)), p3(mid));+ let den = d.dot(n);+ // x ↦ x − d ((x − o)·n) / (d·n), column-major.+ let col = |j: usize| {+ let ej = [Vec3::X, Vec3::Y, Vec3::Z][j];+ ej - d * (ej.dot(n) / den)+ };+ let (c0, c1, c2) = (col(0), col(1), col(2));+ let tr = d * (o.dot(n) / 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);+ Ok(mt::Edge::new(va, vb, curve))};- let c0 = corner(&a0, &b0, p0);- let c1 = corner(&a1, &b1, p1);- let la = rail_a.clone().unwrap_or_else(|| builder::line(&a0, &a1));- let lb = rail_b.clone().unwrap_or_else(|| builder::line(&b0, &b1));+ let mut corners: Vec<(mt::Vertex, mt::Vertex, Vec<mt::Edge>, Option<mt::Vertex>)> = Vec::new();+ for (end, p) in [(end0, p0), (end1, p1)] {+ let (va, vb) = (vertex(&end.ca, end.a), vertex(&end.cb, end.b));+ let (sa, sb) = (p + t1 * s, p + t2 * s);+ let (chain, vq) = match (&end.e3, &end.planes[..]) {+ (None, [plane]) => (vec![section(p, &va, &vb, sa, sb, *plane)?], None),+ (Some((_, q)), [pa, pb]) => {+ let vq = builder::vertex(p3(*q));+ let sq = *q - d * (*q - p).dot(d);+ (vec![section(p, &va, &vq, sa, sq, *pa)?, section(p, &vq, &vb, sq, sb, *pb)?], Some(vq))+ }+ _ => return Err(KernelError::Failed("blend end".into())),+ };+ corners.push((va, vb, chain, vq));+ }+ let [(a0, b0, c0, q0), (a1, b1, c1, q1)] = &corners[..] else { return Err(KernelError::Failed("ends".into())) };+ let la = rail_a.clone().unwrap_or_else(|| builder::line(a0, a1));+ let lb = rail_b.clone().unwrap_or_else(|| builder::line(b0, b1));- // Substitutions: side edges at the ends now stop at A/B (consumed ones are dropped); the- // blended edge moves to A or B.+ // Substitutions: side edges at the ends now stop at A/B (consumed ones are dropped), an edge+ // between two end faces stops where the blend crosses it; the blended edge moves to A or B.let mut subst: HashMap<mt::EdgeID, mt::Edge> = HashMap::new();let mut dropped: Vec<mt::EdgeID> = Vec::new();- for (end, a, b) in [(end0, &a0, &b0), (end1, &a1, &b1)] {+ let shorten = |e: &mt::Edge, v: &mt::Vertex, nv: &mt::Vertex| {+ let (f, bk) = (e.absolute_front(), e.absolute_back());+ if f == v { builder::line(nv, bk) } else { builder::line(f, nv) }+ };+ for (end, a, b, q) in [(end0, a0, b0, q0), (end1, a1, b1, q1)] {for (e, nv, used) in [(&end.e1, a, &end.ca), (&end.e2, b, &end.cb)] {if used.is_some() {dropped.push(e.id());continue;}- let (f, bk) = (e.absolute_front(), e.absolute_back());- let ne = if f == &end.v { builder::line(nv, bk) } else { builder::line(f, nv) };- subst.insert(e.id(), ne);+ subst.insert(e.id(), shorten(e, &end.v, nv));+ }+ if let (Some((e3, _)), Some(q)) = (&end.e3, q) {+ subst.insert(e3.id(), shorten(e3, &end.v, q));}}// The side edges at the ends are pieces of themselves; the rails and corner curves are new.@@ -370,10 +438,12 @@ fn blend_geometry(let mut m = subst.clone();m.insert(edge.id(), lb.clone());rebuild_face(f, &m, &[])?- } else if i == end0.g {- rebuild_face_dropping(f, &subst, &dropped, std::slice::from_ref(&c0))?- } else if i == end1.g {- rebuild_face_dropping(f, &subst, &dropped, std::slice::from_ref(&c1))?+ } else if end0.g.contains(&i) {+ rebuild_face_dropping(f, &subst, &dropped, c0)?+ } else if end1.g.contains(&i) {+ rebuild_face_dropping(f, &subst, &dropped, c1)?+ } else if f.edge_iter().any(|e| subst.contains_key(&e.id())) {+ rebuild_face(f, &subst, &[])?} else {(*f).clone()};@@ -382,19 +452,39 @@ fn blend_geometry(}// The blend face uses each new edge opposite to its neighbour.let f1_forward = faces.get(i1).is_some_and(|f| f.boundaries().iter().any(|w| w.edge_iter().any(|e| e.id() == edge.id() && e.front() == &v0)));- let wire: mt::Wire = if f1_forward {- vec![c0.clone(), lb.clone(), c1.inverse(), la.inverse()].into()+ let reversed = |chain: &[mt::Edge]| chain.iter().rev().map(|e| e.inverse()).collect::<Vec<_>>();+ let mut edges_out: Vec<mt::Edge> = Vec::new();+ if f1_forward {+ edges_out.extend(c0.iter().cloned());+ edges_out.push(lb.clone());+ edges_out.extend(reversed(c1));+ edges_out.push(la.inverse());} else {- vec![la.clone(), c1.clone(), lb.inverse(), c0.inverse()].into()- };+ edges_out.push(la.clone());+ edges_out.extend(c1.iter().cloned());+ edges_out.push(lb.inverse());+ edges_out.extend(reversed(c0));+ }+ let wire: mt::Wire = edges_out.into();let blend_face = match shape {Shape::Flat => builder::try_attach_plane(&[wire]).map_err(|e| KernelError::Failed(format!("chamfer face: {e}")))?,Shape::Round => {- let swept: mt::Face = builder::tsweep(&c0, v3(p1 - p0));+ // The cylinder, from a cross-section before the first end to one past the second, so+ // it holds the end sections wherever the end planes slide them.+ let reach = ends+ .iter()+ .flat_map(|e| e.planes.iter().map(|(_, n)| (s + r) * (1.0 - n.dot(d).powi(2)).max(0.0).sqrt() / n.dot(d).abs()))+ .fold(0.0, f64::max)+ + r;+ let start = p0 - d * reach;+ let (sa, sb) = (start + t1 * s, start + t2 * s);+ let c = centre(start);+ let mid = c + ((sa - c) + (sb - c)).normalized().unwrap_or(-n1) * r;+ let base = builder::circle_arc(&builder::vertex(p3(sa)), &builder::vertex(p3(sb)), p3(mid));+ let swept: mt::Face = builder::tsweep(&base, v3(p1 - p0 + d * (2.0 * reach)));let mut surf = swept.oriented_surface();// Outward normal at the arc middle: away from the centre on a convex edge (the// centre is in the material), toward it on a concave one.- let (c, mid) = (centre(p0), arc_mid(p0));let outward = (mid - c) * (-side);use mt::{ParametricSurface3D, SearchParameter};if let Some((u, v)) = surf.search_parameter(p3(mid), None, 100) {@@ -1113,8 +1203,16 @@ mod tests {assert!(result.solid.vertex_iter().any(|v| vtx(&v).dist(point) < 1e-8));}assert!(blend(&body, &pick, 25.0, Shape::Flat, "chamfer").is_err());- // Oblique fillet caps need elliptical trims, which this local path does not build.- assert!(blend(&body, &pick, 2.0, Shape::Round, "fillet").is_err());+ // A fillet ends in each sloped end plane along an ellipse: the removed section's+ // length is taken at its centroid, c from the edge.+ let rounded = blend(&body, &pick, 2.0, Shape::Round, "fillet").unwrap();+ let (area, c) =+ ((1.0 - std::f64::consts::PI / 4.0) * 4.0, 2.0 * (10.0 - 3.0 * std::f64::consts::PI) / (3.0 * (4.0 - std::f64::consts::PI)));+ let removed = area * (40.0 - 2.0 * slope * c);+ let actual = crate::measure(&body).unwrap().volume - crate::measure(&rounded).unwrap().volume;+ // `measure` reads a round about 6e-4 heavy, square ends too.+ assert!((actual - removed).abs() < 1e-3 * removed, "{actual} vs {removed}");+ assert!(rounded.validity().is_empty());}}}diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rsindex 854573c461..db54305363 100644--- a/crates/kernel/src/tests.rs+++ b/crates/kernel/src/tests.rs@@ -176,9 +176,87 @@ fn fillets_on_several_edges_and_angles() {let cut = 24000.0 - measure(&two).unwrap().volume;let a = 4.0 * (1.0 - PI / 4.0);assert!(cut > a * (20.0 + 30.0 - 2.0) && cut < a * 50.0, "{cut}");- // Concave edge: not supported.+ // Concave edge where a post stands on the plate: the round adds material, its end caps+ // extending the post's end faces down onto the plate.let u = boolean(&b, &box_solid(Vec3::new(10.0, 10.0, 15.0), Vec3::new(20.0, 20.0, 30.0)).unwrap(), BoolOp::Union).unwrap().unwrap();- assert!(fillet(&u, &[Vec3::new(15.0, 10.0, 20.0)], 1.0).is_err());+ let f = fillet(&u, &[Vec3::new(15.0, 10.0, 20.0)], 1.0).unwrap();+ let added = measure(&f).unwrap().volume - measure(&u).unwrap().volume;+ assert!(rel(added, (1.0 - PI / 4.0) * 10.0) < 1e-3, "{added}");+ assert!(f.validity().is_empty());+ assert_eq!(f.lumps().unwrap().len(), 1);+}++#[test]+fn fillet_ends_in_an_end_face_at_an_angle() {+ // #215: the round ends in the end face's plane along an ellipse (its section) when that face+ // is not square to the edge. A prism on a trapezoid (0,0) (40,0) (30,20) (0,20), 10 high: the+ // top edge along y = 0 ends at x = 0 (square) and in the face x = 40 - y/2 (at an angle).+ let r: f64 = 2.0;+ let (area, c) = ((1.0 - PI / 4.0) * r * r, r * (10.0 - 3.0 * PI) / (3.0 * (4.0 - PI)));+ let trapezoid = |far: f64| {+ let pts = [Vec2::new(0.0, 0.0), Vec2::new(40.0, 0.0), Vec2::new(far, 20.0), Vec2::new(0.0, 20.0)];+ extrude(&Plane::XY, &[Region2 { outer: Loop2::polygon(&pts), holes: vec![] }], 0.0, 10.0).unwrap().pop().unwrap()+ };+ // The removed section's length at depth y into the top face is 40 + (far - 40) y / 20; its+ // mean over the section is taken at the section's centroid (c from the edge).+ for far in [30.0, 50.0] {+ let b = trapezoid(far);+ let v0 = measure(&b).unwrap().volume;+ let f = fillet(&b, &[Vec3::new(20.0, 0.0, 10.0)], r).unwrap();+ let want = v0 - area * (40.0 + (far - 40.0) * c / 20.0);+ let m = measure(&f).unwrap();+ assert!(rel(m.volume, want) < 2e-4, "far {far}: {} vs {want}", m.volume);+ assert_eq!(f.lumps().unwrap().len(), 1);+ assert!(f.validity().is_empty(), "far {far}: {:?}", f.validity());+ }+}++#[test]+fn fillet_ending_across_two_faces() {+ // #215: a plate's outline chamfered, then the mitre where two chamfers meet at a corner+ // rounded. The mitre runs from the top face (ending in it at an angle) down to the corner+ // where two side faces meet; the round ends across both, cutting back the vertical edge.+ let (r, k) = (2.0, 5.0);+ let b = box_solid(Vec3::ZERO, Vec3::new(100.0, 50.0, 20.0)).unwrap();+ let outline = [Vec3::new(50.0, 0.0, 20.0), Vec3::new(100.0, 25.0, 20.0), Vec3::new(50.0, 50.0, 20.0), Vec3::new(0.0, 25.0, 20.0)];+ let c = chamfer(&b, &outline, k).unwrap();+ let f = fillet(&c, &[Vec3::new(k / 2.0, k / 2.0, 20.0 - k / 2.0)], r).unwrap();+ assert!(f.validity().is_empty(), "{:?}", f.validity());+ assert_eq!(f.lumps().unwrap().len(), 1);+ // The removed material, by definition: inside the plate, between the two chamfers and the+ // round, i.e. outside the round's cylinder and on the corner's side of both lines where it+ // touches the chamfers (each at the setback s = r cot(φ/2) from the mitre, φ = 120° between+ // the chamfers). Sampled at pseudo-random points (a regular grid aliases with the region's+ // thin slivers along the chamfers): about 1.89 mm³, standard error about 0.02.+ let d = Vec3::new(1.0, 1.0, 1.0).normalized().unwrap();+ let (n1, n2) = (Vec3::new(0.0, -1.0, 1.0).normalized().unwrap(), Vec3::new(-1.0, 0.0, 1.0).normalized().unwrap());+ // In each chamfer, square to the mitre and away from the other chamfer.+ let into = |n: Vec3, other: Vec3| {+ let t = n.cross(d).normalized().unwrap();+ if t.dot(other) < 0.0 { t } else { -t }+ };+ let (t1, t2) = (into(n1, n2), into(n2, n1));+ let phi = (-n1.dot(n2)).acos();+ let s = r / (phi / 2.0).tan();+ let corner = Vec3::new(0.0, 0.0, 20.0 - k);+ let axis_at = corner + t1 * s - n1 * r;+ let removed_at = |q: Vec3| {+ let u = q - axis_at;+ q.z - q.x <= 15.0 && q.z - q.y <= 15.0 && (q - corner).dot(t1) < s && (q - corner).dot(t2) < s && (u - d * u.dot(d)).len() > r+ };+ let (lo, span) = (Vec3::new(0.0, 0.0, 20.0 - k - 2.0 * r), k + 2.0 * r);+ let mut state: u64 = 0x9E37_79B9_7F4A_7C15;+ let mut unit = || {+ state ^= state << 13;+ state ^= state >> 7;+ state ^= state << 17;+ (state >> 11) as f64 / (1u64 << 53) as f64+ };+ let samples = 4_000_000;+ let hits = (0..samples).filter(|_| removed_at(lo + Vec3::new(unit(), unit(), unit()) * span)).count();+ let removed = span.powi(3) * hits as f64 / samples as f64;+ let lost = measure(&c).unwrap().volume - measure(&f).unwrap().volume;+ assert!((lost - removed).abs() < 0.07, "{lost} vs {removed}");}#[test]