diff --git a/crates/kernel/src/coplanar.rs b/crates/kernel/src/coplanar.rs index f986de45..a0eaa96c 100644 --- a/crates/kernel/src/coplanar.rs +++ b/crates/kernel/src/coplanar.rs @@ -268,7 +268,22 @@ pub(crate) fn boolean_apart(a: &Body, b: &Body, op: BoolOp) -> Option Option bool { + let size = a.size().max(b.size()); + let tol = (size * 1e-7).max(1e-9) * 10.0; + let faces: Vec = planes(b).into_iter().filter(|(_, p)| p.n.dot(m) > 1.0 - 1e-9 && (p.d - d).abs() < tol).map(|(i, _)| i).collect(); + let (Ok(ma), Ok(mb)) = (a.tessellate_with(size * 1e-3, true), b.tessellate_with(size * 1e-3, true)) else { return false }; + let inside = ma.inside_index(); + let mut points = Vec::new(); + for (t, fi) in mb.triangles.iter().zip(&mb.tri_face) { + if !faces.contains(&(*fi as usize)) { + continue; + } + let Some([p, q, r]) = mb.tri(t) else { continue }; + let c = (p + q + r) / 3.0; + points.extend([c, c.lerp(p, 0.8), c.lerp(q, 0.8), c.lerp(r, 0.8)]); + if points.len() > 4000 { + break; + } + } + !points.is_empty() && points.iter().all(|p| [0.05, 0.5, 1.0].iter().all(|k| inside.contains(*p + m * (depth * k)))) +} + /// Union of bodies that touch along one identical planar face, back to back (a body joined /// with its mirror image): the two faces go and the shells are stitched along their edges. /// `None` when no such pair of faces exists. @@ -387,3 +425,132 @@ pub(crate) fn glue(a: &Body, b: &Body) -> Option> { } None } + +/// A cylindrical face: its index, a point on the axis, the unit axis and the radius. +#[derive(Clone, Copy, Debug)] +struct CylFace { + index: usize, + origin: Vec3, + axis: Vec3, + radius: f64, +} + +fn cylinders(b: &Body) -> Vec { + (0..b.face_count()) + .filter_map(|index| match crate::face_surface(b, index)? { + crate::FaceSurface::Cylinder { origin, axis, radius } => Some(CylFace { index, origin, axis, radius }), + _ => None, + }) + .collect() +} + +/// Do the two cylinders lie on the same surface? +fn same_cylinder(x: &CylFace, y: &CylFace, tol: f64) -> bool { + let off = y.origin - x.origin; + x.axis.dot(y.axis).abs() > 1.0 - 1e-9 && (x.radius - y.radius).abs() < tol && (off - x.axis * off.dot(x.axis)).len() < tol +} + +/// Do the bodies have cylindrical faces on a common cylinder? +pub(crate) fn has_coincident_cylinders(a: &Body, b: &Body) -> bool { + let tol = (a.size().max(b.size()) * 1e-7).max(1e-9) * 10.0; + let cb = cylinders(b); + cylinders(a).iter().any(|x| cb.iter().any(|y| same_cylinder(x, y, tol))) +} + +/// Union of bodies with bores on a common cylinder (a drain pad's bore around the drain hole +/// it is joined over). The mesh intersection can't take the coincident walls, so the tool's +/// bore is narrowed (its walls pushed toward the axis, now clear of the target's), the bodies +/// are joined, and the cylinder of the original bore is cut out again over the tool's length. +/// That is exact when the cylinder holds no material of either body, which is checked on +/// sample points. Each way (the tool's bore narrowed, else the target's) gives a result only +/// when `accept` takes it. `None` when there are no coincident bores or no way works. +pub(crate) fn bore_union(a: &Body, b: &Body, accept: &dyn Fn(&Body) -> bool) -> Option { + let size = a.size().max(b.size()); + let tol = (size * 1e-7).max(1e-9) * 10.0; + let mtol = size * 2e-3; + let (ma, mb) = (a.tessellate_with(mtol, true).ok()?, b.tessellate_with(mtol, true).ok()?); + let (ia, ib) = (ma.inside_index(), mb.inside_index()); + let empty = |p: Vec3| !ia.contains(p) && !ib.contains(p); + let (ca, cb) = (cylinders(a), cylinders(b)); + // (body to narrow, its mesh and inside test, the other body, their faces on the cylinder). + let ways = [(b, &mb, &ib, a, &cb, &ca), (a, &ma, &ia, b, &ca, &cb)]; + for (tool, mesh, inside, target, ct, co) in ways { + for c in ct { + if !co.iter().any(|o| same_cylinder(c, o, tol)) { + continue; + } + let bore: Vec = ct.iter().filter(|x| same_cylinder(c, x, tol)).map(|x| x.index).collect(); + // The tool's extent along the axis on that cylinder, and whether it is a bore (the + // material outside it) at a point of the face. + let (mut t0, mut t1) = (f64::INFINITY, f64::NEG_INFINITY); + let mut probe = None; + for (t, fi) in mesh.triangles.iter().zip(&mesh.tri_face) { + if !bore.contains(&(*fi as usize)) { + continue; + } + let Some(ps) = mesh.tri(t) else { continue }; + for p in ps { + let s = (p - c.origin).dot(c.axis); + t0 = t0.min(s); + t1 = t1.max(s); + } + if probe.is_none() { + probe = Some((ps[0] + ps[1] + ps[2]) / 3.0); + } + } + let Some(q) = probe else { continue }; + if !(t1 - t0 > tol && c.radius > tol) { + continue; + } + let along = c.origin + c.axis * (q - c.origin).dot(c.axis); + let Some(radial) = (q - along).normalized() else { continue }; + let on = along + radial * c.radius; + let e = (c.radius * 0.05).max(size * 1e-4); + if !(inside.contains(on + radial * e) && !inside.contains(on - radial * e)) { + continue; + } + // The cylinder over the tool's length holds no material of either body. + let (u, w) = (c.axis.any_perp(), c.axis.cross(c.axis.any_perp())); + let at = |s: f64, r: f64, ang: f64| c.origin + c.axis * s + (u * ang.cos() + w * ang.sin()) * r; + let clear = (1..=9).all(|i| { + let s = t0 + (t1 - t0) * f64::from(i) / 10.0; + empty(at(s, 0.0, 0.0)) + && (0..8).all(|k| { + let ang = f64::from(k) * std::f64::consts::FRAC_PI_4 + 0.3; + empty(at(s, c.radius * 0.5, ang)) && empty(at(s, c.radius * 0.9, ang)) + }) + }); + if !clear { + continue; + } + // Past an end where the space is empty well beyond the radius too, the cut runs on a + // little (so its cap doesn't lie in a face's plane). Not where the other body's bore + // goes on: the cut's side would lie on its wall. + let ext = size * 0.01; + let past = |s: f64| { + empty(at(s, 0.0, 0.0)) + && (0..8).all(|k| { + let ang = f64::from(k) * std::f64::consts::FRAC_PI_4 + 0.3; + empty(at(s, c.radius * 0.9, ang)) && empty(at(s, c.radius * 1.1, ang)) && empty(at(s, c.radius * 1.5, ang)) + }) + }; + let lo = if past(t0 - ext * 0.5) && past(t0 - ext) { t0 - ext } else { t0 }; + let hi = if past(t1 + ext * 0.5) && past(t1 + ext) { t1 + ext } else { t1 }; + let d = (c.radius * 0.2).min(size * 0.01); + let run = || -> Result> { + let narrowed = crate::offset::offset_body(tool, |i, _| if bore.contains(&i) { d } else { 0.0 })?; + if !narrowed.validity().is_empty() { + return Err(KernelError::Failed("narrowing a bore: an unsound result".into())); + } + let Some(joined) = crate::ops::boolean(target, &narrowed, BoolOp::Union)? else { return Ok(None) }; + let cut = crate::build::cylinder(at(lo, 0.0, 0.0), c.axis, c.radius, hi - lo)?; + crate::ops::boolean(&joined, &cut, BoolOp::Cut) + }; + match run() { + Ok(Some(r)) if accept(&r) => return Some(r), + _ => continue, + } + } + } + None +} diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rs index b6367f38..ea049d5c 100644 --- a/crates/kernel/src/ops.rs +++ b/crates/kernel/src/ops.rs @@ -175,6 +175,13 @@ thread_local! { /// Set while a boolean runs on bodies whose coincident faces were pushed apart (no /// second round of pushing). static APART: std::cell::Cell = const { std::cell::Cell::new(false) }; + /// Set while a union runs with a bore narrowed off a common cylinder (no second round). + static BORES: std::cell::Cell = const { std::cell::Cell::new(false) }; +} + +/// Is a union with a narrowed bore running (see [`crate::coplanar::bore_union`])? +pub(crate) fn narrowing_bores() -> bool { + BORES.with(|c| c.get()) } /// Boolean of two bodies. The result may be empty (`Ok(None)`) for a cut that removes @@ -347,6 +354,15 @@ fn boolean_whole(a: &Body, b: &Body, op: BoolOp) -> Result> { } } } + // Bores on a common cylinder (a pad's bore around the hole it is joined over). + if op == BoolOp::Union && !BORES.with(|c| c.get()) && crate::coplanar::has_coincident_cylinders(a, b) { + BORES.with(|c| c.set(true)); + let r = crate::coplanar::bore_union(a, b, &|body| check(body).0); + BORES.with(|c| c.set(false)); + if let Some(body) = r { + return Ok(Some(body)); + } + } let mut empty_votes = 0; let keep: Vec> = a.split_keep().iter().chain(b.split_keep()).cloned().collect(); for (attempt, j) in JITTER.iter().enumerate() { diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rs index cb771d76..0fb2578c 100644 --- a/crates/kernel/src/tests.rs +++ b/crates/kernel/src/tests.rs @@ -290,6 +290,60 @@ fn moving_a_body_with_an_intersection_curve_edge_ends() { assert!(rel(v0, v1) < 1e-6, "{v0} vs {v1}"); } +/// Drain pads joined flush under a floor with a drain hole. The floor (100 × 80, top sloping +/// 1°, so not a prism) has a Ø20 hole through it at (50, 40). +/// - A ring whose bore is the hole's wall (coincident cylinders): used to fail. +/// - The same ring 2 mm into the floor: used to fail too. +/// - A disc across the hole: worked before, and must stay exact. +#[test] +fn drain_pads_flush_under_a_floor_with_a_hole() { + let t = 1f64.to_radians().tan(); + let hs = |n: Vec3, p: Vec3| { + let n = n.normalized().unwrap(); + HalfSpace { n, d: n.dot(p) } + }; + let slab = convex_polyhedron(&[ + hs(Vec3::X, Vec3::new(100.0, 0.0, 0.0)), + hs(-Vec3::X, Vec3::ZERO), + hs(Vec3::Y, Vec3::new(0.0, 80.0, 0.0)), + hs(-Vec3::Y, Vec3::ZERO), + hs(-Vec3::Z, Vec3::ZERO), + hs(Vec3::new(-t, 0.0, 1.0), Vec3::new(0.0, 0.0, 10.0)), + ]) + .unwrap(); + let hole = cylinder(Vec3::new(50.0, 40.0, -5.0), Vec3::Z, 10.0, 30.0).unwrap(); + let floor = boolean(&slab, &hole, BoolOp::Cut).unwrap().unwrap(); + // Top z = 10 + t x: the slab's volume is its mean height (at x = 50) times its area, the + // hole's likewise (its top is planar, centred at x = 50). + let v_floor = (10.0 + t * 50.0) * (8000.0 - PI * 100.0); + assert!(rel(measure(&floor).unwrap().volume, v_floor) < 2e-5, "{} vs {v_floor}", measure(&floor).unwrap().volume); + let ring = |z0: f64, z1: f64| { + let r = Region2 { outer: Loop2::circle(Vec2::new(50.0, 40.0), 20.0), holes: vec![Loop2::circle(Vec2::new(50.0, 40.0), 10.0).reversed()] }; + extrude(&Plane::XY, &[r], z0, z1).unwrap().pop().unwrap() + }; + // The ring's part inside the floor adds nothing: 5 mm of ring below it either way. + let v_ring = PI * (400.0 - 100.0) * 5.0; + for (z0, z1) in [(-5.0, 0.0), (-5.0, 2.0)] { + let u = boolean(&floor, &ring(z0, z1), BoolOp::Union).unwrap().unwrap(); + let v = measure(&u).unwrap().volume; + assert!(rel(v, v_floor + v_ring) < 2e-5, "ring {z0}..{z1}: {v} vs {}", v_floor + v_ring); + assert!(u.validity().is_empty(), "{:?}", u.validity()); + } + let disc = cylinder(Vec3::new(50.0, 40.0, -5.0), Vec3::Z, 20.0, 5.0).unwrap(); + let u = boolean(&floor, &disc, BoolOp::Union).unwrap().unwrap(); + let v = measure(&u).unwrap().volume; + let expect = v_floor + PI * 400.0 * 5.0; + assert!(rel(v, expect) < 2e-5, "disc across the hole: {v} vs {expect}"); + // A boss ring standing on the sloping top around the hole, its foot just under the top + // everywhere: it adds its annulus times its height above the top at the centre. + let foot = 10.0 + t * 30.0 - 0.2; + let u = boolean(&floor, &ring(foot, 14.0), BoolOp::Union).unwrap().unwrap(); + let v = measure(&u).unwrap().volume; + let expect = v_floor + PI * 300.0 * (14.0 - (10.0 + t * 50.0)); + assert!(rel(v, expect) < 2e-5, "boss ring on the slope: {v} vs {expect}"); + assert!(u.validity().is_empty(), "{:?}", u.validity()); +} + /// A trough whose floor falls 1° (or 2° toward a drain, in four faces), and short round pads /// and bosses crossing the fall. The B-rep results were right, but the plausibility check meshed /// them without refinement: on a round side trimmed to a thin band by the shallow cut, the plain