From 62b49f9f89e8a1386123786bb4e2d5d6b5521838 Mon Sep 17 00:00:00 2001 From: NOWN-DEV <257771410+NOWN-DEV@users.noreply.github.com> Date: Mon, 19 Oct 2026 23:56:40 +0000 Subject: [PATCH] Boolean: a pin in a bore of its size is clear at every placement (#2714) (#2715) * Boolean: a pin in a bore of its own size is clear of it, whatever its facets A pin whose wall is in other faces than the bore's (turned from a profile: three faces; the bore two) is faceted at other angles. Where one body's faces end on the shared cylinder (the pin's wall through the end face of the tube, the pin's end inside the bore) the facets cross by the facetings' error, so the sampled shortcut doubted its own "apart" answer, every retry failed on the coincident walls, and the result came back unverified after seconds: inspect.clearance left such pairs unchecked ("could not be intersected there"). The shortcut now leaves out crossings that lie on a cylinder both bodies have faces on (axes and radii within the kernel's same-surface tolerance, where both faces run). A pin a hair off its hole's axis, or one pushed into a narrower bore, is still not taken for apart. Co-Authored-By: Claude Opus 5.5 (1M context) * Boolean: skip only the shared cylinder's own crossings, not a flat along it The shortcut left out every crossing near a cylinder both bodies have faces on, from any face: a pin through a D-bore whose flat is 0.022 mm inside it came back as contact. Mesh::crosses_except now hands the predicate the two triangles' faces, and only crossings between the faces on the shared cylinder, or between one of them and an end face across its axis that keeps to its body's side of the cylinder (within the facetings' error), are left out. The D-bore's end face reaches into the cylinder to the flat, so the pin's wall through it counts again; a flat, key or rib along the axis always counts. Co-Authored-By: Claude Opus 5.5 (1M context) * Boolean: a pin in a bore of its size is clear at every placement The sampled shortcut's check that no facet has material under it on the wrong side of the other body still caught the facetings of a shared cylinder. A facet of a pin's end inside the bore (or of the bore part's end face round the pin) with all three corners on the rim has its middle just inside the cylinder. Where the other body's chords reach further in at that angle, the point under it lies inside the other mesh, though the bodies only touch. Which facets do so depends on the face splits and the placement, so the same pair read as clear at one placement and as "not verified" at another. Such points are no evidence now when they lie on the shared cylinder, under a facet of one of its end faces: the end faces and band the crossing check already leaves out. A pin 0.02 mm larger is no shared cylinder, and its overlap is still found. Co-Authored-By: Claude Opus 5.5 (1M context) --------- Co-authored-by: Claude Opus 5.5 (1M context) Co-authored-by: bherbruck --- crates/engine/src/cmd/clearance_tests.rs | 50 ++++ crates/geom/src/mesh.rs | 68 +++-- crates/geom/src/tests.rs | 12 + crates/kernel/src/ops.rs | 337 ++++++++++++++++++++++- 4 files changed, 437 insertions(+), 30 deletions(-) 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]