SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
fix(kernel): fillet mixed arc and line loop corners (#604)
onenewcode87d4eb55e5b3
diff --git a/ROADMAP.md b/ROADMAP.mdindex eb0ecb5732..30c1bd1f19 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -330,7 +330,9 @@ completed drawings publish atomically. The browser still exports synchronously.bevel faces, splitting their shared seam; picks on the same tangent chain are applied once (#1303);whole smooth loops of a planar face, picked whole or by one edge (tangentchain), including circles and walls at any angle (boss bases and tops, bores, pocket floors,- plate outlines), loops with sharp corners between straight edges (the blends meet in mitres), runs of+ plate outlines), loops with sharp corners between straight or mixed arc/line edges (straight+ blends meet in mitres; perpendicular curved walls use offset intersections, with D-rim removal+ checked within 0.1% of analytic offset slices), runs ofneighbouring edges along a planar face's loop (two top edges of a box: mitred, ending square;with the edge between them too, the corner becomes a sphere octant),rounded corners rounded again (sphere octants, tori at concave corners); every edge of adiff --git a/crates/kernel/src/blend.rs b/crates/kernel/src/blend.rsindex a4bd1aa107..7f03087930 100644--- a/crates/kernel/src/blend.rs+++ b/crates/kernel/src/blend.rs@@ -1773,7 +1773,20 @@ fn loop_split(cur: &Body, pts: &[Vec3]) -> Result<Option<(Vec<Vec<Vec3>>, Vec<Velet Some(e) = near.iter().find(|e| planar_edge.contains(&e.id())).or(near.first()) else { return Ok(None) };per.push((*p, e.id()));}- let ids: Vec<mt::EdgeID> = per.iter().map(|x| x.1).collect();+ // Fillets follow tangent chains in the original body. Include those edges before+ // recognising a whole loop, too: two picks across a sharp arc/line joint can cover+ // the entire rim once each pick's smooth chain is included.+ let ids = guard("loop tangent chains", || {+ let mut ids: std::collections::HashSet<mt::EdgeID> = per.iter().map(|x| x.1).collect();+ for (_, id) in &per {+ if let Some(edge) = all.iter().find(|e| e.id() == *id)+ && let Some(chain) = smooth_chain(&solid, edge)+ {+ ids.extend(chain);+ }+ }+ Ok(ids)+ })?;let mut covered: Vec<mt::EdgeID> = Vec::new();let mut groups = Vec::new();for f in solid.face_iter() {diff --git a/crates/kernel/src/loopblend.rs b/crates/kernel/src/loopblend.rsindex ab50132a99..d9f97c047b 100644--- a/crates/kernel/src/loopblend.rs+++ b/crates/kernel/src/loopblend.rs@@ -1,9 +1,10 @@//! 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. The loop must be smooth (lines and arcs meeting-//! tangentially). The face shrinks by the radius, the walls are trimmed by it, and each loop edge+//! 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 arcs at the joints. The result is exact.+//! 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.use std::collections::HashMap;@@ -56,6 +57,74 @@ impl Seg {}}+/// 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.+fn offset_profile(prev: &Seg, cur: &Seg, n: Vec3, side: f64, r: 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), r * 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};@@ -158,10 +227,19 @@ fn face_normal(f: &mt::Face, p: Vec3) -> Option<Vec3> {Vec3::new(n.x, n.y, n.z).normalized()}-/// Blend the loop of `edges` (by id) if it is a whole smooth boundary loop of a planar face with+/// 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)>> {+ match crate::guard("loop blend", || Ok(loop_blend_inner(solid, edge_ids, size, r, round))) {+ Ok(result) => result,+ Err(error) => Some(Err(error)),+ }+}++fn loop_blend_inner(solid: &Solid, edge_ids: &[mt::EdgeID], size: f64, r: f64, round: bool) -> 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();@@ -204,6 +282,8 @@ fn build(round: bool,run: Option<(usize, usize)>,) -> Result<(Solid, Rebuild)> {+ #[cfg(test)]+ assert!(crate::guarded(), "loop construction must run inside the kernel guard");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();@@ -226,7 +306,8 @@ fn build(// 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 between two lines (the blends then meet in a mitre).+ // 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 {@@ -236,7 +317,7 @@ fn build(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 !(matches!(prev, Seg::Line { .. }) && matches!(cur, Seg::Line { .. })) || ta.dot(tb) < -1.0 + 1e-3 {+ 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) {@@ -340,6 +421,7 @@ fn build(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 {@@ -360,7 +442,18 @@ fn build(};let x = d0.cross(d1);let lam = ((m * sb - m0 * sb0).cross(d1)).dot(x) / x.len2();- pa.push(p + m0 * sb0 + d0 * lam);+ 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, 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 || (sb0 / h0 - sb / h1).abs() > tol * 10.0 {@@ -453,6 +546,12 @@ fn build(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 curve = offset_profile(prev, cur, n, side, r, round, (r * 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;@@ -471,6 +570,8 @@ fn build(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);@@ -692,7 +793,19 @@ fn build(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, .. } => builder::rsweep(pr, p3(c), v3(axis), mt::Rad(angle)),+ 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, _) = frame(i, a).ok_or_else(|| unsupported("frame"))?;+ let (fa, wa) = (builder::vertex(p3(a + into(s, a) * sb)), builder::vertex(p3(a + t * sb)));+ 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.diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rsindex ce8a67edff..d6df9e509b 100644--- a/crates/kernel/src/tests.rs+++ b/crates/kernel/src/tests.rs@@ -1939,6 +1939,328 @@ fn fillet_an_open_curved_edge() {assert!(rel(removed, want) < 1e-3, "{removed} vs {want}");}+fn mixed_arc_and_line_prism() -> Body {+ use solidcraft_geom::Seg2;+ let d = Loop2 {+ segs: vec![+ Seg2::Arc { center: Vec2::ZERO, radius: 10.0, start: 0.0, sweep: PI },+ Seg2::Line { a: Vec2::new(-10.0, 0.0), b: Vec2::new(10.0, 0.0) },+ ],+ };+ extrude(&Plane::XY, &[Region2 { outer: d, holes: vec![] }], 0.0, 15.0).unwrap().pop().unwrap()+}++#[test]+fn fillet_smooth_arc_and_line_loop_keeps_exact_removal() {+ use solidcraft_geom::Seg2;+ // A stadium: four tangent joints, none of which should use a sharp-corner mitre.+ let outline = Loop2 {+ segs: vec![+ Seg2::Line { a: Vec2::new(-10.0, -10.0), b: Vec2::new(10.0, -10.0) },+ Seg2::Arc { center: Vec2::new(10.0, 0.0), radius: 10.0, start: -PI / 2.0, sweep: PI },+ Seg2::Line { a: Vec2::new(10.0, 10.0), b: Vec2::new(-10.0, 10.0) },+ Seg2::Arc { center: Vec2::new(-10.0, 0.0), radius: 10.0, start: PI / 2.0, sweep: PI },+ ],+ };+ let body = extrude(&Plane::XY, &[Region2 { outer: outline, holes: vec![] }], 0.0, 15.0).unwrap().pop().unwrap();+ let blended =+ fillet(&body, &[Vec3::new(0.0, -10.0, 15.0), Vec3::new(20.0, 0.0, 15.0), Vec3::new(0.0, 10.0, 15.0), Vec3::new(-20.0, 0.0, 15.0)], 0.5)+ .unwrap();+ assert!(blended.validity().is_empty(), "{:?}", blended.validity());+ let r = 0.5;+ let area = r * r * (1.0 - PI / 4.0);+ let centroid = r * (10.0 - 3.0 * PI) / (3.0 * (4.0 - PI));+ let want = area * (40.0 + 2.0 * PI * (10.0 - centroid));+ let fine = |b: &Body| b.tessellate_with(1e-4, true).unwrap().measure().volume;+ let removed = fine(&body) - fine(&blended);+ assert!(rel(removed, want) < 1e-3, "{removed} vs {want}");+}++#[test]+fn fillet_sharp_arc_and_arc_loop() {+ use solidcraft_geom::Seg2;+ // The intersection of two radius-10 disks whose centres are 10 mm apart.+ let outline = Loop2 {+ segs: vec![+ Seg2::Arc { center: Vec2::new(-5.0, 0.0), radius: 10.0, start: -PI / 3.0, sweep: 2.0 * PI / 3.0 },+ Seg2::Arc { center: Vec2::new(5.0, 0.0), radius: 10.0, start: 2.0 * PI / 3.0, sweep: 2.0 * PI / 3.0 },+ ],+ };+ let body = extrude(&Plane::XY, &[Region2 { outer: outline, holes: vec![] }], 0.0, 15.0).unwrap().pop().unwrap();+ let blended = fillet(&body, &[Vec3::new(5.0, 0.0, 15.0), Vec3::new(-5.0, 0.0, 15.0)], 0.5).unwrap();+ assert!(blended.validity().is_empty(), "{:?}", blended.validity());+ let mesh = blended.tessellate_with(1e-4, true).unwrap();+ for p in &mesh.positions {+ assert!((p.x - 5.0).hypot(p.y) <= 10.0 + 1e-3 && (p.x + 5.0).hypot(p.y) <= 10.0 + 1e-3, "outside the lens: {p:?}");+ }+ let area = |rho: f64| 2.0 * rho * rho * (5.0 / rho).acos() - 10.0 * (rho * rho - 25.0).sqrt();+ let dt = (PI / 2.0) / 8192.0;+ let want: f64 = (0..8192)+ .map(|i| {+ let theta = (f64::from(i) + 0.5) * dt;+ (area(10.0) - area(10.0 - 0.5 * (1.0 - theta.cos()))) * 0.5 * theta.cos() * dt+ })+ .sum();+ let removed = body.tessellate_with(1e-4, true).unwrap().measure().volume - mesh.measure().volume;+ assert!(rel(removed, want) < 1e-3, "{removed} vs {want}");+}++#[test]+fn fillet_tabbed_plate_outer_loop_and_partial_selection_after_hole() {+ use solidcraft_geom::Seg2;+ // Reconstruct the outer outline from its seven public pick coordinates:+ // R25 plate, x=+/-4 tab sides, R2 corners and a 4 mm straight top.+ // The hole's dimensions come from the public reproduction, not an original design file.+ let theta = (4.0_f64 / 25.0).acos();+ let y = (625.0_f64 - 16.0).sqrt();+ let corner_y = 280.0 / 9.0;+ let hole_y = 262.0 / 9.0;+ let outline = Loop2 {+ segs: vec![+ Seg2::Arc { center: Vec2::ZERO, radius: 25.0, start: PI - theta, sweep: PI + 2.0 * theta },+ Seg2::Line { a: Vec2::new(4.0, y), b: Vec2::new(4.0, corner_y) },+ Seg2::Arc { center: Vec2::new(2.0, corner_y), radius: 2.0, start: 0.0, sweep: PI / 2.0 },+ Seg2::Line { a: Vec2::new(2.0, corner_y + 2.0), b: Vec2::new(-2.0, corner_y + 2.0) },+ Seg2::Arc { center: Vec2::new(-2.0, corner_y), radius: 2.0, start: PI / 2.0, sweep: PI / 2.0 },+ Seg2::Line { a: Vec2::new(-4.0, corner_y), b: Vec2::new(-4.0, y) },+ ],+ };+ let body =+ extrude(&Plane::XY, &[Region2 { outer: outline, holes: vec![Loop2::circle(Vec2::new(0.0, hole_y), 1.5)] }], 0.0, 2.0).unwrap().pop().unwrap();+ let inner = fillet(&body, &[Vec3::new(1.5, hole_y, 2.0)], 0.5).unwrap();+ let edges = [+ Vec3::new(-24.91935125502191, -2.0064727829797544, 2.0),+ Vec3::new(24.919351255429795, -2.006472777913911, 2.0),+ Vec3::new(3.999999997492012, 27.894518234675537, 2.0),+ Vec3::new(3.4142135598750105, 32.525324672801695, 2.0),+ Vec3::new(-2.480541994032137e-9, 33.11111111046627, 2.0),+ Vec3::new(-3.4142135648720653, 32.52532467287703, 2.0),+ Vec3::new(-4.0000000025087745, 27.89451823429679, 2.0),+ ];+ // All 127 nonempty subsets: the whole rim, each individual edge, and every+ // contiguous or disjoint partial selection of the issue's seven picks.+ for mask in 1_u32..(1 << edges.len()) {+ let picks: Vec<_> = edges.iter().enumerate().filter(|(i, _)| mask & (1 << i) != 0).map(|(_, p)| *p).collect();+ let blended = fillet(&inner, &picks, 0.5).unwrap_or_else(|e| panic!("{picks:?}: {e}"));+ assert!(blended.validity().is_empty(), "{:?}", blended.validity());+ let mesh = blended.display_mesh(0.01).unwrap();+ for p in &mesh.positions {+ let inside = p.x.hypot(p.y) <= 25.001+ || (p.x.abs() <= 4.001 && p.y >= y - 0.001 && p.y <= corner_y)+ || (p.x.abs() <= 2.001 && p.y >= corner_y && p.y <= corner_y + 2.001)+ || (p.x - 2.0).hypot(p.y - corner_y) <= 2.001+ || (p.x + 2.0).hypot(p.y - corner_y) <= 2.001;+ assert!(inside && p.z >= -0.001 && p.z <= 2.001, "outside the plate: {p:?}");+ }+ }+}++fn partial_mixed_run_prism() -> Body {+ use solidcraft_geom::Seg2;+ let outline = Loop2 {+ segs: vec![+ Seg2::Line { a: Vec2::new(0.0, 0.0), b: Vec2::new(40.0, 0.0) },+ Seg2::Line { a: Vec2::new(40.0, 0.0), b: Vec2::new(40.0, 20.0) },+ Seg2::Line { a: Vec2::new(40.0, 20.0), b: Vec2::new(30.0, 20.0) },+ Seg2::Arc { center: Vec2::new(20.0, 20.0), radius: 10.0, start: 0.0, sweep: PI },+ Seg2::Line { a: Vec2::new(10.0, 20.0), b: Vec2::new(0.0, 20.0) },+ Seg2::Line { a: Vec2::new(0.0, 20.0), b: Vec2::new(0.0, 0.0) },+ ],+ };+ extrude(&Plane::XY, &[Region2 { outer: outline, holes: vec![] }], 0.0, 15.0).unwrap().pop().unwrap()+}++#[test]+fn mixed_loop_blend_guards_selection_and_construction() {+ let body = mixed_arc_and_line_prism();+ let solid = body.deep_copy();+ let top = solid+ .boundaries()+ .iter()+ .flat_map(|shell| shell.face_iter())+ .find(|face| face.edge_iter().all(|edge| (edge.front().point().z - 15.0).abs() < 1e-9 && (edge.back().point().z - 15.0).abs() < 1e-9))+ .unwrap();+ let edges: Vec<_> = top.edge_iter().map(|edge| edge.id()).collect();+ // The internal test-only assertions check the active guard during both selection and build.+ assert!(!crate::guarded());+ let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| crate::loopblend::loop_blend(&solid, &edges, body.size(), 0.5, true)));+ assert!(matches!(result, Ok(Some(Ok(_)))), "{result:?}");+ assert!(!crate::guarded());+ // A degenerate profile still returns a clean error and restores the guard depth.+ let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| crate::loopblend::loop_blend(&solid, &edges, body.size(), 0.0, true)));+ assert!(matches!(result, Ok(Some(Err(_)))), "{result:?}");+ assert!(!crate::guarded());+}++#[test]+fn fillet_mixed_arc_and_line_perimeter_edges() {+ let body = mixed_arc_and_line_prism();+ let blended = fillet(&body, &[Vec3::new(0.0, 10.0, 15.0), Vec3::new(5.0, 0.0, 15.0)], 0.5).unwrap();+ assert!(blended.validity().is_empty(), "{:?}", blended.validity());+ let display_tol = (blended.size() * 1e-3).max(1e-3);+ for mesh in [+ blended.tessellate_with(1e-4, true).unwrap(),+ blended.display_mesh_angular(display_tol, crate::DISPLAY_ANGLE).unwrap(),+ blended.reference_display_mesh_angular(display_tol, crate::DISPLAY_ANGLE).unwrap(),+ ] {+ let bounds = mesh.bounds();+ let tol = 1e-3;+ assert!(+ bounds.min.x >= -10.0 - tol+ && bounds.max.x <= 10.0 + tol+ && bounds.min.y >= -tol+ && bounds.max.y <= 10.0 + tol+ && bounds.min.z >= -tol+ && bounds.max.z <= 15.0 + tol,+ "{bounds:?}"+ );+ for p in &mesh.positions {+ assert!(p.x.hypot(p.y) <= 10.0 + tol, "outside the source semicircle: {p:?}");+ }+ }+}++/// Integrate exact inward-offset D slices, including the arc/line corner overlaps.+/// At height H-r+r*sin(theta), the inset is d=r*(1-cos(theta)); the remaining+/// slice is the circular segment of radius R-d above y=d. No kernel geometry is used.+fn d_fillet_removed_reference(r: f64, steps: u32) -> f64 {+ let dt = (PI / 2.0) / f64::from(steps);+ (0..steps)+ .map(|i| {+ let theta = (f64::from(i) + 0.5) * dt;+ let d = r * (1.0 - theta.cos());+ let rho = 10.0 - d;+ let remaining = rho * rho * (d / rho).acos() - d * (rho * rho - d * d).sqrt();+ (PI * 50.0 - remaining) * r * theta.cos() * dt+ })+ .sum()+}++#[test]+fn fillet_mixed_arc_and_line_removed_volume_converges() {+ let body = mixed_arc_and_line_prism();+ let source_exact = PI * 100.0 * 15.0 / 2.0;+ let tolerances = [1e-4, 2.5e-5];+ let source_volumes = tolerances.map(|tol| body.tessellate_with(tol, true).unwrap().measure().volume);+ for r in [0.5, 0.25] {+ let want = d_fillet_removed_reference(r, 8192);+ assert!((want - d_fillet_removed_reference(r, 4096)).abs() < 1e-7, "reference quadrature must converge");+ if r == 0.5 {+ assert!((want - 2.715578447526581).abs() < 1e-7, "{want}");+ }+ let blended = fillet(&body, &[Vec3::new(0.0, 10.0, 15.0), Vec3::new(5.0, 0.0, 15.0)], r).unwrap();+ let mut previous = None;+ for (tol, source) in tolerances.into_iter().zip(source_volumes) {+ let volume = blended.tessellate_with(tol, true).unwrap().measure().volume;+ // Equal chord tolerances reduce (not necessarily cancel) the error from the+ // unchanged walls. The convergence and exact-source checks below guard this.+ let removed = source - volume;+ assert!(rel(removed, want) < 1e-3, "r={r}, tol={tol}: removed {removed}, expected {want}");+ if let Some(coarser) = previous {+ assert!(rel(removed, coarser) < 1e-3, "r={r}: removal has not converged: {coarser} -> {removed}");+ let exact_removed = source_exact - volume;+ // The source's inscribed semicylinder loses at most pi*R*H*tol.+ // Do not charge its chord error to the much smaller fillet volume.+ let source_error = (source_exact - source).abs();+ assert!(source_error < PI * 10.0 * 15.0 * tol, "source chord error {source_error}");+ assert!((exact_removed - want).abs() < source_error + want * 1e-3, "r={r}: exact-source removal {exact_removed}, expected {want}");+ }+ previous = Some(removed);+ }+ }+}++#[test]+fn loop_chamfer_mixed_arc_and_line_uses_offset_intersections() {+ let body = mixed_arc_and_line_prism();+ // Exercise the shared loop builder; public chamfer prefers boolean cutters first.+ let solid = body.deep_copy();+ let top = solid+ .face_iter()+ .find(|face| face.edge_iter().all(|edge| (edge.front().point().z - 15.0).abs() < 1e-9 && (edge.back().point().z - 15.0).abs() < 1e-9))+ .unwrap();+ let edges: Vec<_> = top.edge_iter().map(|edge| edge.id()).collect();+ let (result, history) = crate::loopblend::loop_blend(&solid, &edges, body.size(), 0.5, false).unwrap().unwrap();+ let blended = crate::record::rebuilt(result, &[&solid], &history).unwrap();+ assert!(blended.validity().is_empty(), "{:?}", blended.validity());+ // A chamfer has a linear inset through its height instead of a circular section.+ let step = 0.5 / 8192.0;+ let want: f64 = (0..8192)+ .map(|i| {+ let d = (f64::from(i) + 0.5) * step;+ let rho = 10.0 - d;+ let remaining = rho * rho * (d / rho).acos() - d * (rho * rho - d * d).sqrt();+ (PI * 50.0 - remaining) * step+ })+ .sum();+ // The cone's triangulation needs this chord tolerance for the small volume difference.+ let fine = |b: &Body| b.tessellate_with(2.5e-5, true).unwrap().measure().volume;+ let removed = fine(&body) - fine(&blended);+ assert!(rel(removed, want) < 1e-3, "{removed} vs {want}");+}++#[test]+fn fillet_mixed_arc_and_line_joint_preserves_both_section_radii() {+ use truck_modeling::{BoundedCurve, ParametricCurve};++ let r = 0.5;+ let body = mixed_arc_and_line_prism();+ let blended = fillet(&body, &[Vec3::new(0.0, 10.0, 15.0), Vec3::new(5.0, 0.0, 15.0)], r).unwrap();+ crate::guard("inspect mixed fillet mitres", || {+ let solid = blended.deep_copy();+ let mut mitres = std::collections::HashSet::new();+ for edge in solid.boundaries().iter().flat_map(|shell| shell.edge_iter()) {+ let a = crate::body::from_p3(edge.front().point());+ let b = crate::body::from_p3(edge.back().point());+ // Only the two corner profiles join the top contact to the wall contact.+ if (a.z - b.z).abs() < r - 1e-8 || a.z.min(b.z) < 15.0 - r - 1e-8 || a.x * b.x <= 0.0 {+ continue;+ }+ if !mitres.insert(edge.id()) {+ continue;+ }+ let curve = edge.oriented_curve();+ let (lo, hi) = curve.range_tuple();+ for i in 0..=257 {+ let p = crate::body::from_p3(curve.subs(lo + (hi - lo) * f64::from(i) / 257.0));+ // The joint lies on both the cylindrical line blend and the toroidal+ // arc blend, not their tangent-plane approximation.+ let radius2 = (p.y - r).powi(2) + (p.z - (15.0 - r)).powi(2);+ assert!((radius2 - r * r).abs() < 1e-7, "distorted line section at {p:?}: radius squared {radius2}");+ let radius2 = (p.x.hypot(p.y) - (10.0 - r)).powi(2) + (p.z - (15.0 - r)).powi(2);+ assert!((radius2 - r * r).abs() < 1e-7, "distorted arc section at {p:?}: radius squared {radius2}");+ }+ }+ assert_eq!(mitres.len(), 2, "both arc/line corners must be checked");+ Ok(())+ })+ .unwrap();+}++#[test]+fn fillet_partial_mixed_arc_and_line_perimeter_run() {+ let body = partial_mixed_run_prism();+ let blended = fillet(&body, &[Vec3::new(35.0, 20.0, 15.0), Vec3::new(20.0, 30.0, 15.0), Vec3::new(5.0, 20.0, 15.0)], 0.5).unwrap();+ assert!(blended.validity().is_empty(), "{:?}", blended.validity());+ let mesh = blended.tessellate_with(1e-4, true).unwrap();+ let bounds = mesh.bounds();+ let tol = 1e-3;+ assert!(+ bounds.min.x >= -tol+ && bounds.max.x <= 40.0 + tol+ && bounds.min.y >= -tol+ && bounds.max.y <= 30.0 + tol+ && bounds.min.z >= -tol+ && bounds.max.z <= 15.0 + tol,+ "{bounds:?}"+ );+ for p in &mesh.positions {+ if p.y > 20.0 + tol {+ assert!((p.x - 20.0).hypot(p.y - 20.0) <= 10.0 + tol, "outside the source semicircle: {p:?}");+ }+ }+}+/// Boolean survey: random boxes, cylinders and spheres combined every way; prints what fails.#[test]#[ignore]