diff --git a/crates/engine/src/cmd/clearance_tests.rs b/crates/engine/src/cmd/clearance_tests.rs index 3b057094f..901f4a74a 100644 --- a/crates/engine/src/cmd/clearance_tests.rs +++ b/crates/engine/src/cmd/clearance_tests.rs @@ -415,3 +415,53 @@ fn a_roller_pressed_into_a_large_plate_is_reported() { let want = (r * r * ((r - depth) / r).acos() - (r - depth) * (r * r - (r - depth) * (r - depth)).sqrt()) * length; assert!((f(&overlaps[0]["volume_mm3"]) - want).abs() < 0.01 * want, "{want} {res}"); } + +/// A pin turned from a profile (its wall in three faces) in the bore of a tube of its own size +/// (in two faces), its end inside the bore, a hair off the axis, and a slit tube with the pin +/// through it: touching, not overlapping. Their facets cross where one body's faces end on the +/// shared cylinder, and the pairs were left unchecked ("could not be intersected there"). +#[test] +fn a_turned_pin_in_a_bore_of_its_size_is_contact() { + let mut s = Session::default(); + let pin = |s: &mut Session, name: &str, off: [f64; 3], z0: f64, z1: f64| { + run(s, "sketch.create", json!({"plane": {"origin": off, "x_dir": [1, 0, 0], "y_dir": [0, 0, 1]}})); + run(s, "sketch.rectangle.two_point", json!({"p0": [0, z0], "p1": [3, z1]})); + run(s, "solid.revolve", json!({"axis": "y", "body_name": name})); + }; + let tube = |s: &mut Session, name: &str, x: f64| { + run(s, "solid.cylinder", json!({"radius": 5.25, "height": 19.55, "base": [x, 0, 0], "body_name": name})); + run(s, "solid.cylinder", json!({"radius": 3, "height": 19.55, "base": [x, 0, 0], "operation": "cut", "targets": [name]})); + }; + pin(&mut s, "Pin", [2.2e-8, 4.7e-7, 0.0], -2.35, 9.65); + tube(&mut s, "Tube", 0.0); + pin(&mut s, "Through", [30.0, 0.0, 0.0], -3.0, 22.0); + tube(&mut s, "Slit", 30.0); + run(&mut s, "solid.box", json!({"length": 8, "width": 0.1, "height": 21, "corner": [22, -0.05, -1], "operation": "cut", "targets": ["Slit"]})); + let r = run(&mut s, "inspect.clearance", json!({"bodies": ["Pin", "Through"], "against": ["Tube", "Slit"], "clearance": 1e-6})); + assert_eq!(r["unchecked"].as_array().map(Vec::len), Some(0), "{r}"); + assert_eq!(r["overlaps"].as_array().map(Vec::len), Some(0), "{r}"); + let near = r["near"].as_array().cloned().unwrap_or_default(); + assert_eq!(near.iter().map(pair).collect::>(), [["Pin", "Tube"], ["Slit", "Through"]], "{r}"); + assert!(near.iter().all(|n| f(&n["distance_mm"]) == 0.0 && n.get("overlap_mm3").is_none()), "{r}"); +} + +/// A pin of a bore's size through a D-bore whose flat is 0.022 mm inside the pin shares a +/// sliver with the tube along the whole bore (the circular segment beyond the flat, 0.21 mm³): +/// an overlap, not contact. Only the facetings of the shared cylinder may cross unseen; the flat +/// reaches into it. +#[test] +fn a_pin_through_a_d_bore_of_its_size_overlaps_the_flat() { + let (r, flat, length) = (3.0_f64, 2.978_f64, 19.55); + let mut s = Session::default(); + run(&mut s, "solid.cylinder", json!({"radius": 5.25, "height": length, "base": [0, 0, 0], "body_name": "Tube"})); + run(&mut s, "solid.cylinder", json!({"radius": r, "height": length, "base": [0, 0, 0], "operation": "cut", "targets": ["Tube"]})); + run(&mut s, "solid.box", json!({"length": 1, "width": 2, "height": length, "corner": [flat, -1, 0], "operation": "join", "targets": ["Tube"]})); + run(&mut s, "solid.cylinder", json!({"radius": r, "height": length + 6.0, "base": [0, 0, -3], "operation": "new", "body_name": "Pin"})); + let res = run(&mut s, "inspect.clearance", json!({"bodies": ["Pin"], "against": ["Tube"], "clearance": 1e-6})); + let want = (r * r * (flat / r).acos() - flat * (r * r - flat * flat).sqrt()) * length; + let overlaps = res["overlaps"].as_array().cloned().unwrap_or_default(); + assert!(res["near"].as_array().is_none_or(|n| n.is_empty()), "{res}"); + assert_eq!(res["unchecked"].as_array().map(Vec::len), Some(0), "{res}"); + assert_eq!(overlaps.len(), 1, "{res}"); + assert!((f(&overlaps[0]["volume_mm3"]) - want).abs() < 0.05 * want, "{want} {res}"); +} diff --git a/crates/geom/src/mesh.rs b/crates/geom/src/mesh.rs index 92339a0ab..45dd94161 100644 --- a/crates/geom/src/mesh.rs +++ b/crates/geom/src/mesh.rs @@ -100,7 +100,8 @@ pub fn find_close_pair( test: impl FnMut(&BoxedTriangle, &BoxedTriangle) -> bool, ) -> Option { let work = std::cell::Cell::new(*budget); - let found = find_close_pair_within(a, b, gap, &work, test); + let mut test = test; + let found = find_close_pair_within(a, b, gap, &work, |(_, t), (_, u)| test(t, u)); *budget = work.get(); found } @@ -110,7 +111,7 @@ fn find_close_pair_within( b: &[BoxedTriangle], gap: f64, work: &std::cell::Cell, - mut test: impl FnMut(&BoxedTriangle, &BoxedTriangle) -> bool, + mut test: impl FnMut((usize, &BoxedTriangle), (usize, &BoxedTriangle)) -> bool, ) -> Option { let spend = |n: usize| -> Option<()> { work.set(work.get().checked_sub(n)?); @@ -125,7 +126,7 @@ fn find_close_pair_within( && x.min.z <= y.max.z + gap && y.min.z <= x.max.z + gap }; - let mut call = |t: &BoxedTriangle, u: &BoxedTriangle| -> Option { + let mut call = |t: (usize, &BoxedTriangle), u: (usize, &BoxedTriangle)| -> Option { spend(1)?; Some(test(t, u)) }; @@ -179,7 +180,7 @@ fn find_close_pair_within( for &j in &big { if let Some(u) = b.get(j).filter(|u| close(&t.1, &u.1)) { seen[j] = i + 1; - if call(t, u)? { + if call((i, t), (j, u))? { return Some(true); } } @@ -187,7 +188,7 @@ fn find_close_pair_within( let Some([x, y, z]) = span(&t.1, 0.0) else { // A large triangle of `a`: against all of `b`. for (j, u) in b.iter().enumerate() { - if seen[j] != i + 1 && close(&t.1, &u.1) && call(t, u)? { + if seen[j] != i + 1 && close(&t.1, &u.1) && call((i, t), (j, u))? { return Some(true); } } @@ -203,7 +204,7 @@ fn find_close_pair_within( continue; } *mark = i + 1; - if close(&t.1, &u.1) && call(t, u)? { + if close(&t.1, &u.1) && call((i, t), (j as usize, u))? { return Some(true); } } @@ -215,7 +216,9 @@ fn find_close_pair_within( } /// Two triangles that pass through each other (see [`Mesh::crosses`]). -fn triangles_cross(t: &[Vec3; 3], u: &[Vec3; 3], tol: f64) -> bool { +/// Where two triangles pass through each other by more than `tol` (see [`Mesh::crosses`]): the +/// middle of the stretch of the line their planes share that both span, or `None`. +fn triangles_cross(t: &[Vec3; 3], u: &[Vec3; 3], tol: f64) -> Option { // Signed distances of one triangle's corners from the other's plane, when they lie more // than `tol` to both sides of it. let sides = |tri: &[Vec3; 3], plane: &[Vec3; 3]| -> Option<(Vec3, [f64; 3])> { @@ -224,24 +227,31 @@ fn triangles_cross(t: &[Vec3; 3], u: &[Vec3; 3], tol: f64) -> bool { let (lo, hi) = d.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), v| (lo.min(*v), hi.max(*v))); (lo < -tol && hi > tol).then_some((n, d)) }; - let (Some((nu, dt)), Some((nt, du))) = (sides(t, u), sides(u, t)) else { return false }; - let Some(line) = nt.cross(nu).normalized() else { return false }; + let (Some((nu, dt)), Some((nt, du))) = (sides(t, u), sides(u, t)) else { return None }; + let line = nt.cross(nu).normalized()?; // Where a triangle's edges pass through the other's plane, measured along the line the // two planes share. - let reach = |tri: &[Vec3; 3], d: &[f64; 3]| -> (f64, f64) { - let (mut lo, mut hi) = (f64::INFINITY, f64::NEG_INFINITY); + // With the points there, for the middle of the stretch both span. + let reach = |tri: &[Vec3; 3], d: &[f64; 3]| -> ((f64, Vec3), (f64, Vec3)) { + let (mut lo, mut hi) = ((f64::INFINITY, Vec3::ZERO), (f64::NEG_INFINITY, Vec3::ZERO)); for (i, j) in [(0, 1), (1, 2), (2, 0)] { let (p, q, dp, dq) = (tri[i], tri[j], d[i], d[j]); if (dp < 0.0) != (dq < 0.0) && dp != dq { - let at = line.dot(p + (q - p) * (dp / (dp - dq))); - lo = lo.min(at); - hi = hi.max(at); + let x = p + (q - p) * (dp / (dp - dq)); + let at = line.dot(x); + if at < lo.0 { + lo = (at, x); + } + if at > hi.0 { + hi = (at, x); + } } } (lo, hi) }; let ((t0, t1), (u0, u1)) = (reach(t, &dt), reach(u, &du)); - t1.min(u1) - t0.max(u0) > tol + let (from, to) = (if t0.0 > u0.0 { t0 } else { u0 }, if t1.0 < u1.0 { t1 } else { u1 }); + (to.0 - from.0 > tol).then(|| (from.1 + to.1) * 0.5) } /// Mass properties of a closed mesh. @@ -523,6 +533,14 @@ impl Mesh { /// can still overlap without crossing: one inside the other, or sharing a slab between /// faces that are parallel or in one plane. pub fn crosses(&self, o: &Mesh, tol: f64) -> bool { + self.crosses_except(o, tol, |_, _, _| false) + } + + /// [`Mesh::crosses`], leaving out the crossings for which `ignored` holds, asked with the + /// middle of the stretch the two triangles share and the faces of this mesh's and `o`'s + /// triangle (`u32::MAX` where a mesh has no face for it): where both meshes stand for one + /// surface of both bodies, and their facets cross by the facetings' error alone. + pub fn crosses_except(&self, o: &Mesh, tol: f64, ignored: impl Fn(Vec3, u32, u32) -> bool) -> bool { if !tol.is_finite() { return false; } @@ -532,23 +550,29 @@ impl Mesh { if region.is_empty() { return false; } - let near = |m: &Mesh| -> Vec<([Vec3; 3], Aabb3)> { + // The triangles near the other mesh, with their faces. + let near = |m: &Mesh| -> (Vec, Vec) { m.triangles .iter() - .filter_map(|t| { + .enumerate() + .filter_map(|(i, t)| { let t = m.tri(t)?; let mut bx = Aabb3::EMPTY; t.iter().for_each(|p| bx.add(*p)); - (!bx.is_empty() && boxes_meet(&bx, ®ion)).then_some((t, bx)) + (!bx.is_empty() && boxes_meet(&bx, ®ion)).then(|| ((t, bx), m.tri_face.get(i).copied().unwrap_or(u32::MAX))) }) - .collect() + .unzip() }; - let (ta, tb) = (near(self), near(o)); + let ((ta, fa), (tb, fb)) = (near(self), near(o)); if ta.is_empty() || tb.is_empty() { return false; } - let mut unlimited = usize::MAX; - find_close_pair(&ta, &tb, 0.0, &mut unlimited, |(t, _), (u, _)| triangles_cross(t, u, tol)).unwrap_or(false) + let work = std::cell::Cell::new(usize::MAX); + let face = |faces: &[u32], i: usize| faces.get(i).copied().unwrap_or(u32::MAX); + find_close_pair_within(&ta, &tb, 0.0, &work, |(i, (t, _)), (j, (u, _))| { + triangles_cross(t, u, tol).is_some_and(|at| !ignored(at, face(&fa, i), face(&fb, j))) + }) + .unwrap_or(false) } /// Closest intersection of a ray with the mesh: (distance along `dir`, triangle index). diff --git a/crates/geom/src/tests.rs b/crates/geom/src/tests.rs index 39010d872..7b8513aca 100644 --- a/crates/geom/src/tests.rs +++ b/crates/geom/src/tests.rs @@ -287,6 +287,8 @@ fn box_mesh(min: Vec3, max: Vec3, n: usize) -> Mesh { let k = m.positions.len() as u32; m.positions.extend([corner(i, j), corner(i + 1, j), corner(i + 1, j + 1), corner(i, j + 1)]); m.triangles.extend(if side > 0.0 { [[k, k + 1, k + 2], [k, k + 2, k + 3]] } else { [[k, k + 2, k + 1], [k, k + 3, k + 2]] }); + // Faces: 2 * axis, plus one on the far side. + m.tri_face.extend([(2 * axis) as u32 + side as u32; 2]); } } } @@ -318,6 +320,16 @@ fn meshes_cross_only_where_their_surfaces_pass_through_each_other() { // Passing through by less than the tolerance doesn't count. assert!(!a.crosses(&cube(9.995, 3.0, 1), 0.01)); assert!(!a.crosses(&cube(9.85, 3.0, 1), f64::NAN)); + // Crossings left out where the caller knows better: only those, by where they are. + let corner = cube(9.85, 9.85, 2); + assert!(!a.crosses_except(&corner, 0.01, |_, _, _| true)); + assert!(!a.crosses_except(&corner, 0.01, |p, _, _| p.x > 9.8 && p.y > 9.8)); + assert!(a.crosses_except(&corner, 0.01, |p, _, _| p.x < 9.8)); + // And by the faces that cross: `a`'s side at x = 10 through the corner's at y = 9.85, and + // `a`'s at y = 10 through the corner's at x = 9.85. + assert!(!a.crosses_except(&corner, 0.01, |_, f, g| matches!((f, g), (1, 2) | (3, 0)))); + assert!(a.crosses_except(&corner, 0.01, |_, f, g| (f, g) == (1, 2))); + assert!(a.crosses_except(&corner, 0.01, |_, f, g| (f, g) == (3, 0))); } /// A closed box mesh `[x0, x0+a] x [y0, y0+b] x [z0, z0+c]`, outward-facing. diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rs index 9e0d51578..eb6f1479e 100644 --- a/crates/kernel/src/ops.rs +++ b/crates/kernel/src/ops.rs @@ -281,6 +281,8 @@ fn overlap( /// Whether some facet of `m` has material just under it (`depth` in from its middle) that is /// inside the other body (`inside`) or outside it. With `within`, only facets in that box. +/// Points for which `ignored` holds, asked with the point and the facet's face (`u32::MAX` +/// where the mesh has none), are no evidence either. fn under_surface( m: &solidcraft_geom::Mesh, own: &solidcraft_geom::InsideIndex, @@ -288,42 +290,213 @@ fn under_surface( depth: f64, inside: bool, within: Option<&solidcraft_geom::Aabb3>, + ignored: &dyn Fn(Vec3, u32) -> bool, ) -> bool { - m.triangles.iter().filter_map(|t| m.tri(t)).any(|[p, q, r]| { + m.triangles.iter().enumerate().filter_map(|(i, t)| Some((m.tri(t)?, m.tri_face.get(i).copied().unwrap_or(u32::MAX)))).any(|([p, q, r], face)| { let Some(n) = (q - p).cross(r - p).normalized() else { return false }; let c = (p + q + r) * (1.0 / 3.0) - n * depth; let near = within.is_none_or(|b| c.x >= b.min.x && c.x <= b.max.x && c.y >= b.min.y && c.y <= b.max.y && c.z >= b.min.z && c.z <= b.max.z); // A wall thinner than `depth` puts the point outside its own body: no evidence. - near && other.contains(c) == inside && own.contains(c) + near && other.contains(c) == inside && own.contains(c) && !ignored(c, face) }) } /// Whether the bodies' facetings show that the samples' answer (see [`trivial`]) is wrong: /// their surfaces pass through each other, or a facet of one has material under it on the -/// wrong side of the other. Overlaps and gaps shallower than `tol` are not seen. +/// wrong side of the other. Overlaps and gaps shallower than `tol` are not seen, nor surfaces +/// that pass through each other only on a cylinder both bodies have faces on, there between +/// those faces or one of them and an end face across its axis, nor material under such an end +/// face's facets at the cylinder (`shared`, asked only when the facetings disagree). fn contradicted( (ma, ia): (&solidcraft_geom::Mesh, &solidcraft_geom::InsideIndex), (mb, ib): (&solidcraft_geom::Mesh, &solidcraft_geom::InsideIndex), (disjoint, b_in_a, a_in_b): (bool, bool, bool), tol: f64, + shared: &dyn Fn() -> SharedCylinders, ) -> bool { if !(disjoint || b_in_a || a_in_b) { return false; } + let cylinders = std::cell::OnceCell::new(); + let shared = || cylinders.get_or_init(shared); if ma.crosses(mb, tol) { - return true; + let shared = shared(); + if shared.cylinders.is_empty() || ma.crosses_except(mb, tol, |p, fa, fb| shared.ignores(p, fa, fb, tol)) { + return true; + } } + // The end faces of a shared cylinder end on it at their own faceting: a facet of a pin's end + // inside the hole, or of the hole part's end face round the pin, has its middle within the + // facetings' error of the cylinder, where the other body's facets can reach over it. + let (under_a, under_b) = (|p: Vec3, f: u32| shared().under_cap(p, f, true, tol), |p: Vec3, f: u32| shared().under_cap(p, f, false, tol)); if disjoint { let (ba, bb) = (ma.bounds(), mb.bounds()); - let shared = solidcraft_geom::Aabb3 { min: ba.min.max(bb.min), max: ba.max.min(bb.max) }; - return !shared.is_empty() && (under_surface(ma, ia, ib, tol, true, Some(&shared)) || under_surface(mb, ib, ia, tol, true, Some(&shared))); + let meet = solidcraft_geom::Aabb3 { min: ba.min.max(bb.min), max: ba.max.min(bb.max) }; + return !meet.is_empty() + && (under_surface(ma, ia, ib, tol, true, Some(&meet), &under_a) || under_surface(mb, ib, ia, tol, true, Some(&meet), &under_b)); } - (a_in_b && under_surface(ma, ia, ib, tol, false, None)) || (b_in_a && !a_in_b && under_surface(mb, ib, ia, tol, false, None)) + (a_in_b && under_surface(ma, ia, ib, tol, false, None, &under_a)) || (b_in_a && !a_in_b && under_surface(mb, ib, ia, tol, false, None, &under_b)) } /// Sampled overlap fraction below which two bodies share no material. const NONE: f64 = 0.003; +/// A cylinder both bodies have faces on (a pin in a hole of its own size, a bore drilled again), +/// and where along its axis both do. The two facetings of it are chords of one circle at +/// different angles: where one body's facets end on it (a pin's wall through the end face of the +/// hole's part, the pin's end inside the hole) they cross the other's by up to the facetings' +/// error, though the surfaces only touch. +struct SharedCylinder { + origin: Vec3, + axis: Vec3, + radius: f64, + span: (f64, f64), + /// The faces on it: of the first body, of the second. + faces: (usize, usize), + /// The end faces across its axis that keep to their body's side of it (a hole part's end + /// face round the hole, a pin's end inside it), within the facetings' error: of the first + /// body, of the second. A D-bore's end face, which reaches into the cylinder to the flat, + /// is not one. + caps: (Vec, Vec), +} + +impl SharedCylinder { + /// Whether `p` lies on the cylinder, within `tol`, where both bodies have faces on it. + fn holds(&self, p: Vec3, tol: f64) -> bool { + let v = p - self.origin; + let along = v.dot(self.axis); + ((v - self.axis * along).len() - self.radius).abs() <= tol && along >= self.span.0 - tol && along <= self.span.1 + tol + } +} + +/// The cylinders both bodies have faces on (see [`shared_cylinders`]). +#[derive(Default)] +struct SharedCylinders { + cylinders: Vec, +} + +impl SharedCylinders { + /// Whether a crossing at `p` of the first body's face `fa` with the second's `fb` is only + /// the facetings of a shared cylinder: on it, between the two faces on it, or between one of + /// them and one of its end faces (a pin's wall through the hole part's end face, the pin's + /// end inside the hole). A flat, key or rib along the axis still counts. + fn ignores(&self, p: Vec3, fa: u32, fb: u32, tol: f64) -> bool { + let (fa, fb) = (fa as usize, fb as usize); + self.cylinders.iter().any(|c| { + let (on_a, on_b) = (fa == c.faces.0, fb == c.faces.1); + ((on_a && on_b) || (on_a && c.caps.1.contains(&fb)) || (c.caps.0.contains(&fa) && on_b)) && c.holds(p, tol) + }) + } + + /// Whether `p`, just under a facet of the first body's face `face` (`first`) or the second's, + /// lies within `tol` of a shared cylinder with that face one of its end faces: material the + /// other body's facets of the cylinder can cover there, though the surfaces only touch. + fn under_cap(&self, p: Vec3, face: u32, first: bool, tol: f64) -> bool { + let face = face as usize; + self.cylinders.iter().any(|c| (if first { &c.caps.0 } else { &c.caps.1 }).contains(&face) && c.holds(p, tol)) + } +} + +/// The cylinders on which both `a` and `b` have faces: axes parallel and within `same` of each +/// other, radii within `same` (a pin a hair off its hole's axis shares a crescent, which this +/// tolerance leaves far below any volume worth reporting). Spans from the meshes `ma`, `mb`. +fn shared_cylinders(a: &Body, b: &Body, ma: &solidcraft_geom::Mesh, mb: &solidcraft_geom::Mesh, same: f64) -> SharedCylinders { + let cylinders = |body: &Body| -> Vec<(usize, Vec3, Vec3, f64)> { + (0..body.face_count()) + .filter_map(|i| match crate::face_surface(body, i)? { + crate::FaceSurface::Cylinder { origin, axis, radius } if origin.is_finite() && radius.is_finite() && radius > 0.0 => { + Some((i, origin, axis.normalized()?, radius)) + } + _ => None, + }) + .collect() + }; + let (ca, cb) = (cylinders(a), cylinders(b)); + if ca.is_empty() || cb.is_empty() { + return SharedCylinders::default(); + } + // Where a face's facets reach along an axis. + let span = |m: &solidcraft_geom::Mesh, face: usize, origin: Vec3, axis: Vec3| -> Option<(f64, f64)> { + let (mut lo, mut hi) = (f64::INFINITY, f64::NEG_INFINITY); + for (t, f) in m.triangles.iter().zip(&m.tri_face) { + if *f as usize != face { + continue; + } + for p in m.tri(t)? { + let s = (p - origin).dot(axis); + lo = lo.min(s); + hi = hi.max(s); + } + } + (lo <= hi).then_some((lo, hi)) + }; + // A face's facets. + fn facets(m: &solidcraft_geom::Mesh, face: usize) -> impl Iterator + '_ { + m.triangles.iter().zip(&m.tri_face).filter(move |(_, f)| **f as usize == face).filter_map(|(t, _)| m.tri(t)) + } + // How near to and far from an axis a face's facets reach (nearest on their edges), and + // whether its material is inside the cylinder there (its normals point away from the axis). + let reach = |m: &solidcraft_geom::Mesh, face: usize, origin: Vec3, axis: Vec3| -> (f64, f64, bool) { + let radial = |p: Vec3| { + let v = p - origin; + v - axis * v.dot(axis) + }; + let (mut near, mut far, mut out) = (f64::INFINITY, 0.0f64, 0.0); + for t in facets(m, face) { + for (p, q) in [(t[0], t[1]), (t[1], t[2]), (t[2], t[0])] { + let (p, q) = (radial(p), radial(q)); + let d = q - p; + let s = if d.dot(d) > 0.0 { (-p.dot(d) / d.dot(d)).clamp(0.0, 1.0) } else { 0.0 }; + near = near.min((p + d * s).len()); + far = far.max(p.len()); + } + out += (t[1] - t[0]).cross(t[2] - t[0]).dot(radial((t[0] + t[1] + t[2]) * (1.0 / 3.0))); + } + (near, far, out > 0.0) + }; + let planes = |body: &Body| -> Vec<(usize, Vec3)> { + (0..body.face_count()) + .filter_map(|i| match crate::face_surface(body, i)? { + crate::FaceSurface::Plane { normal, .. } => Some((i, normal.normalized()?)), + _ => None, + }) + .collect() + }; + let (pa, pb) = (planes(a), planes(b)); + let mut out = Vec::new(); + for &(fa, oa, xa, ra) in &ca { + for &(fb, ob, xb, rb) in &cb { + let d = ob - oa; + if xa.dot(xb).abs() <= 1.0 - 1e-9 || (ra - rb).abs() > same || (d - xa * d.dot(xa)).len() > same { + continue; + } + let (Some(sa), Some(sb)) = (span(ma, fa, oa, xa), span(mb, fb, oa, xa)) else { continue }; + let (lo, hi) = (sa.0.max(sb.0), sa.1.min(sb.1)); + if lo > hi { + continue; + } + // The facetings' error on the cylinder: how far inside it their chords pass. + let ((na, _, boss_a), (nb, _, boss_b)) = (reach(ma, fa, oa, xa), reach(mb, fb, oa, xa)); + let error = 2.0 * (ra - na).max(ra - nb).max(0.0) + same; + // End faces across the axis that keep to their body's side of the cylinder. + let caps = |m: &solidcraft_geom::Mesh, planes: &[(usize, Vec3)], boss: bool| -> Vec { + planes + .iter() + .filter(|(_, n)| n.dot(xa).abs() >= 1.0 - 1e-6) + .filter(|(i, _)| { + let (near, far, _) = reach(m, *i, oa, xa); + near <= far && if boss { far <= ra + error } else { near >= ra - error } + }) + .map(|(i, _)| *i) + .collect() + }; + let caps = (caps(ma, &pa, boss_a), caps(mb, &pb, boss_b)); + out.push(SharedCylinder { origin: oa, axis: xa, radius: ra, span: (lo, hi), faces: (fa, fb), caps }); + } + } + SharedCylinders { cylinders: out } +} + /// Booleans that need no intersection: one body clear of the other, or inside it. These are /// common with coincident curved faces (a hole drilled where one already is, a body joined /// with itself), which the intersection can't handle. `counts`: the operands' faces and edges. @@ -351,7 +524,10 @@ fn trivial( // The samples only say that nearly all of one body is clear of, or inside, the other. A // small part can still be on the wrong side (a peg overlapping a rib, a chamfer taken off // one edge), and then the bodies have to be intersected. - let sure = !contradicted((ma, &ia), (mb, &ib), (disjoint, b_in_a > ALL, a_in_b > ALL), tol); + // The same surface as the kernel takes it elsewhere (see `coaxial_overlap`). + let same = (a.size().max(b.size()) * 1e-7).max(1e-9) * 10.0; + let shared = || shared_cylinders(a, b, ma, mb, same); + let sure = !contradicted((ma, &ia), (mb, &ib), (disjoint, b_in_a > ALL, a_in_b > ALL), tol, &shared); let answer = match op { // Sampling only selects this candidate. Validate every shell boundary and the // complete material/void nesting before preserving a disconnected union. @@ -505,6 +681,151 @@ mod shortcut_tests { assert!(trivial(&outer, &protruding, BoolOp::Cut, &mesh, &protruding_mesh, &counts, 0.09).is_none()); } + /// A pin turned from a profile (its wall in three faces) in the bore of a tube (its wall in + /// two): one cylinder, faceted at different angles, so the pin's facets cross the tube's end + /// face and the bore's facets cross the pin's end by the facetings' error. The pin is still + /// clear of the tube, exactly on its axis or a hair off it (parts placed from rounded + /// coordinates), with the pin's end inside the bore or through it, and with a slit along + /// the tube: answered at once, without the boolean's retries. + #[test] + fn a_pin_in_a_bore_of_its_size_is_clear_of_it_whatever_the_facets() { + use solidcraft_geom::{Loop2, Plane, Region2, Vec2}; + let rect = |x1: f64, y0: f64, y1: f64| Region2 { + outer: Loop2::polygon(&[Vec2::new(0.0, y0), Vec2::new(x1, y0), Vec2::new(x1, y1), Vec2::new(0.0, y1)]), + holes: vec![], + }; + let pin = |off: Vec3, z0: f64, z1: f64| { + let plane = Plane { origin: off, x: Vec3::X, y: Vec3::Z }; + crate::revolve(&plane, &[rect(3.0, z0, z1)], Vec2::ZERO, Vec2::new(0.0, 1.0), std::f64::consts::TAU).unwrap().pop().unwrap() + }; + let outer = crate::cylinder(Vec3::ZERO, Vec3::Z, 5.25, 19.55).unwrap(); + let bore = crate::cylinder(Vec3::new(0.0, 0.0, -1.0), Vec3::Z, 3.0, 21.55).unwrap(); + let tube = boolean(&outer, &bore, BoolOp::Cut).unwrap().unwrap(); + let slit = crate::box_solid(Vec3::new(-6.0, -0.05, -1.0), Vec3::new(0.0, 0.05, 21.0)).unwrap(); + let slit_tube = boolean(&tube, &slit, BoolOp::Cut).unwrap().unwrap(); + let tube_volume = crate::measure(&tube).unwrap().volume; + for off in [Vec3::ZERO, Vec3::new(2.2e-8, 4.7e-7, 0.0)] { + for (p, t) in [(pin(off, -2.35, 9.65), &tube), (pin(off, -3.0, 22.0), &tube), (pin(off, -2.35, 9.65), &slit_tube)] { + assert_eq!(p.face_count(), 5); + for (x, y) in [(&p, t), (t, &p)] { + let (r, report) = crate::capture_boolean_diagnostics(|| boolean(x, y, BoolOp::Intersect)); + assert!(r.unwrap().is_none() && report.events.is_empty(), "{off:?} {report:?}"); + } + let cut = boolean(&tube, &p, BoolOp::Cut).unwrap().unwrap(); + assert!((crate::measure(&cut).unwrap().volume - tube_volume).abs() < 1e-6 * tube_volume); + } + } + // Off the axis by 0.01 mm the pin shares a crescent with the tube: not taken for apart. + let (ma, mb) = (pin(Vec3::new(0.01, 0.0, 0.0), -2.35, 9.65), tube.clone()); + let counts = record::counts(&[&ma, &mb]); + let (sa, sb) = (ma.tessellate_with(0.009, true).unwrap(), mb.tessellate_with(0.009, true).unwrap()); + assert!(trivial(&ma, &mb, BoolOp::Intersect, &sa, &sb, &counts, 0.027).is_none_or(|(_, sure)| !sure)); + } + + /// A pin turned from a profile (its wall in three faces) and a plate with a bore of the pin's + /// size (its wall in two), the pin's end inside the bore: turned about the pin's axis and + /// the pair placed and tilted. + fn pin_in_plate_bore(radius: f64, turn: f64, (to, axis, angle): (Vec3, Vec3, f64)) -> (Body, Body) { + use solidcraft_geom::{Loop2, Plane, Region2, Vec2}; + let profile = Region2 { + outer: Loop2::polygon(&[Vec2::new(0.0, -2.35), Vec2::new(radius, -2.35), Vec2::new(radius, 9.65), Vec2::new(0.0, 9.65)]), + holes: vec![], + }; + let plane = Plane { origin: Vec3::ZERO, x: Vec3::X, y: Vec3::Z }; + let pin = crate::revolve(&plane, &[profile], Vec2::ZERO, Vec2::new(0.0, 1.0), std::f64::consts::TAU).unwrap().pop().unwrap(); + let pin = crate::transform(&pin, Vec3::ZERO, Vec3::ZERO, Vec3::Z, turn).unwrap(); + let block = crate::box_solid(Vec3::new(-8.0, -8.0, 0.0), Vec3::new(8.0, 8.0, 19.5)).unwrap(); + let bore = crate::cylinder(Vec3::new(0.0, 0.0, -1.0), Vec3::Z, 3.0, 21.5).unwrap(); + let plate = boolean(&block, &bore, BoolOp::Cut).unwrap().unwrap(); + let place = |b: &Body| crate::transform(b, to, Vec3::ZERO, axis, angle).unwrap(); + (place(&pin), place(&plate)) + } + + /// Placements of the pair: as built, far off the origin on its side, and tilted two ways. + const PLACEMENTS: [(Vec3, Vec3, f64); 4] = [ + (Vec3::ZERO, Vec3::Z, 0.0), + (Vec3::new(-270.0, 267.1, 546.7), Vec3::Y, -std::f64::consts::FRAC_PI_2), + (Vec3::new(120.0, -40.0, 15.0), Vec3::new(1.0, 1.0, 0.0), 0.7), + (Vec3::new(-35.0, 80.0, -60.0), Vec3::new(0.3, -0.5, 1.0), 2.1), + ]; + + /// The pin's end lies on the bore's rim at its own faceting, the plate's end face round the + /// pin at the bore's: the middle of a facet there can be just under the other body's facets + /// of the cylinder, so the material under it looked inside the other body though the two + /// only touch (the pin turned 9 steps and the pair tilted about x = y did, the boolean then + /// fell back on its retries and called its answer unverified). At every turn and placement + /// the pin is clear of the plate, answered at once. + #[test] + fn a_pin_in_a_plate_bore_of_its_size_is_clear_of_it_at_any_placement() { + for k in 0..12 { + for placement in PLACEMENTS { + let (pin, plate) = pin_in_plate_bore(3.0, k as f64 * 0.13, placement); + for (x, y) in [(&pin, &plate), (&plate, &pin)] { + let (r, report) = crate::capture_boolean_diagnostics(|| boolean(x, y, BoolOp::Intersect)); + assert!(matches!(r, Ok(None)) && report.events.is_empty(), "{k} {placement:?} {r:?} {report:?}"); + } + } + } + } + + /// The same pin 0.02 mm larger than the bore shares a ring with the plate along the length + /// it is in it: an overlap, at the placements above too. + #[test] + fn a_pin_slightly_larger_than_its_plate_bore_still_overlaps_it() { + let want = std::f64::consts::PI * (3.02f64.powi(2) - 9.0) * 9.65; + for k in [0, 3, 6, 9] { + for placement in PLACEMENTS { + let (pin, plate) = pin_in_plate_bore(3.02, k as f64 * 0.13, placement); + let (r, report) = crate::capture_boolean_diagnostics(|| boolean(&pin, &plate, BoolOp::Intersect)); + let shared = r.unwrap().map(|b| crate::measure(&b).unwrap().volume); + assert!(shared.is_some_and(|v| (v - want).abs() < 0.05 * want), "{k} {placement:?} {shared:?} {want} {report:?}"); + } + } + } + + /// A pin of the bore's size pushed 0.05 mm on past the bore, into a narrower one, shares a + /// ring with the tube there (0.2 % of the pin, under what the samples see): the crossings on + /// the shared cylinder are left out, those of the pin's end with the narrow bore are not. + #[test] + fn a_pin_pushed_into_a_narrower_bore_is_not_taken_for_clear() { + let outer = crate::cylinder(Vec3::ZERO, Vec3::Z, 5.25, 19.55).unwrap(); + let wide = crate::cylinder(Vec3::new(0.0, 0.0, -1.0), Vec3::Z, 3.0, 10.0).unwrap(); + let narrow = crate::cylinder(Vec3::new(0.0, 0.0, -1.0), Vec3::Z, 2.0, 21.55).unwrap(); + let tube = boolean(&boolean(&outer, &wide, BoolOp::Cut).unwrap().unwrap(), &narrow, BoolOp::Cut).unwrap().unwrap(); + let pin = crate::cylinder(Vec3::new(0.0, 0.0, -2.0), Vec3::Z, 3.0, 11.05).unwrap(); + let counts = record::counts(&[&pin, &tube]); + let (ma, mb) = (pin.tessellate_with(0.009, true).unwrap(), tube.tessellate_with(0.009, true).unwrap()); + for op in [BoolOp::Intersect, BoolOp::Cut] { + assert!(trivial(&pin, &tube, op, &ma, &mb, &counts, 0.027).is_none_or(|(_, sure)| !sure), "{op:?}"); + } + } + + /// A pin of the bore's size through a D-bore whose flat is 0.022 mm inside the pin (a sliver + /// of 0.21 mm³ along the bore): the pin's wall passes through the tube's end faces where the + /// flat reaches into the cylinder, near the shared cylinder but deeper than its facetings' + /// error. That is real overlap, and must not be taken for the facetings of the cylinder. + #[test] + fn a_pin_through_a_d_bore_of_its_size_still_overlaps_the_flat() { + let (r, flat, length) = (3.0, 2.978, 19.55); + let outer = crate::cylinder(Vec3::ZERO, Vec3::Z, 5.25, length).unwrap(); + let bore = crate::cylinder(Vec3::new(0.0, 0.0, -1.0), Vec3::Z, r, length + 2.0).unwrap(); + let keep = crate::box_solid(Vec3::new(-4.0, -4.0, -2.0), Vec3::new(flat, 4.0, length + 2.0)).unwrap(); + let d_bore = boolean(&bore, &keep, BoolOp::Intersect).unwrap().unwrap(); + let tube = boolean(&outer, &d_bore, BoolOp::Cut).unwrap().unwrap(); + let pin = crate::cylinder(Vec3::new(0.0, 0.0, -3.0), Vec3::Z, r, length + 6.0).unwrap(); + // Faceted as the boolean does for bodies of this size (0.015 mm deep crossings seen). + let counts = record::counts(&[&pin, &tube]); + let (ma, mb) = (pin.tessellate_with(0.005, true).unwrap(), tube.tessellate_with(0.005, true).unwrap()); + for op in [BoolOp::Intersect, BoolOp::Cut] { + assert!(trivial(&pin, &tube, op, &ma, &mb, &counts, 0.015).is_none_or(|(_, sure)| !sure), "{op:?}"); + } + // Nor does the boolean pass them as clear without saying so: the shortcut it falls back + // on is reported unverified (the bodies can't be intersected along the shared walls), + // and the caller measures the overlap another way. + let (shared, report) = crate::capture_boolean_diagnostics(|| boolean(&pin, &tube, BoolOp::Intersect)); + assert!(shared.unwrap().is_some() || report.unverified().is_some(), "{report:?}"); + } + /// Bodies sharing less than the samples can see still meet: no shortcut, and the boolean /// gives the shared part. #[test]