//! Operations on bodies: booleans and rigid transforms. use serde::{Deserialize, Serialize}; use solidcraft_geom::Vec3; use truck_modeling as mt; use std::collections::HashMap; use crate::body::{Body, Solid, from_p3}; use crate::boolean_diagnostics::{BooleanFallback, BooleanStrategy, capture_boolean_diagnostics, merge, record, reject}; use crate::boolean_record::{self as recorded, Traced}; use crate::{KernelError, Result, guard, record}; #[cfg(test)] #[path = "bore_union_tests.rs"] mod bore_union_tests; #[path = "tool_reseam.rs"] mod tool_reseam; #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum BoolOp { Union, Cut, Intersect, } /// Exact planar Booleans need no sampled enlargement of their tool footprint. pub fn is_planar(body: &Body) -> bool { if body.is_mesh() || body.face_count() > 16_384 { return false; } guard("planar body", || Ok(body.solid.face_iter().all(|face| matches!(face.oriented_surface(), mt::Surface::Plane(_))))).unwrap_or(false) } /// Batch separated extrusion tools without repeatedly unioning an ever-growing target. /// Construction caps provide conservative bounds, including the full circle of each arc; /// unsupported or touching tools retain the caller's sequential Boolean path. pub fn compound_disjoint_extrusions(tools: &[Body]) -> Result> { if tools.len() < 2 || tools.len() > 1024 { return Ok(None); } guard("compound extrusion tools", || { let mut bounds = Vec::with_capacity(tools.len()); let mut corners = Vec::with_capacity(tools.len()); let mut axes = Vec::with_capacity(tools.len()); let mut remaining = 16_384usize; for tool in tools { let Some(sources) = tool.face_sources() else { return Ok(None) }; if sources.len() != tool.face_count() { return Ok(None); } let mut bb = solidcraft_geom::Aabb3::EMPTY; let mut points = Some(Vec::new()); let mut directions = Vec::new(); let mut caps = 0; for source in sources { let Some(left) = remaining.checked_sub(1) else { return Ok(None) }; remaining = left; match source { Some(crate::FaceSource::ExtrudeCap { region, plane, high }) => { caps += 1; // The bottom support is outward-facing, but its region retains // the original sketch coordinates (see build::extrude). let plane = if *high { *plane } else { solidcraft_geom::Plane { y: -plane.y, ..*plane } }; for segment in ®ion.outer.segs { let Some(left) = remaining.checked_sub(1) else { return Ok(None) }; remaining = left; match *segment { solidcraft_geom::Seg2::Line { a, b } => { let (a, b) = (plane.to_world(a), plane.to_world(b)); bb.add(a); bb.add(b); if let Some(points) = points.as_mut() { points.extend([a, b]); } if let Some(axis) = (b - a).cross(plane.normal()).normalized() { directions.push(axis); } } solidcraft_geom::Seg2::Arc { center, radius, .. } => { points = None; for x in [-radius, radius] { for y in [-radius, radius] { bb.add(plane.to_world(center + solidcraft_geom::Vec2::new(x, y))); } } } _ => return Ok(None), } } } Some(crate::FaceSource::ExtrudeSide { .. }) => {} _ => return Ok(None), } } if caps != 2 || bb.is_empty() || !bb.min.is_finite() || !bb.max.is_finite() { return Ok(None); } bounds.push(bb); corners.push(points); axes.push(directions); } let mut remaining_separation_work = 16_000_000usize; for (i, a) in bounds.iter().enumerate() { for (j, b) in bounds.iter().enumerate().skip(i + 1) { let gap = (a.diagonal().max(b.diagonal()) * 1e-6).max(1e-7); let separated = a.max.x + gap < b.min.x || b.max.x + gap < a.min.x || a.max.y + gap < b.min.y || b.max.y + gap < a.min.y || a.max.z + gap < b.min.z || b.max.z + gap < a.min.z; if separated { continue; } let (Some(Some(x)), Some(Some(y))) = (corners.get(i), corners.get(j)) else { return Ok(None) }; let Some(origin) = x.first() else { return Ok(None) }; // Every straight extrusion lies inside the hull of its cap corners. // A separating cap-edge axis therefore proves clearance even when // rotated tools' world-coordinate boxes overlap. Arcs retain the box test. let range = |points: &[Vec3], axis: Vec3| { points.iter().map(|p| (*p - *origin).dot(axis)).fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), v| (lo.min(v), hi.max(v))) }; let rounding = origin.x.abs().max(origin.y.abs()).max(origin.z.abs()) * f64::EPSILON * 128.0; let separated = axes.get(i).into_iter().flatten().chain(axes.get(j).into_iter().flatten()).any(|axis| { let Some(left) = remaining_separation_work.checked_sub(x.len().saturating_add(y.len())) else { return false }; remaining_separation_work = left; let (a, b) = (range(x, *axis), range(y, *axis)); a.1 + gap + rounding < b.0 || b.1 + gap + rounding < a.0 }); if !separated { return Ok(None); } } } let sources: std::collections::HashMap<_, _> = tools .iter() .flat_map(|tool| { tool.solid .face_iter() .zip(tool.face_sources().unwrap_or_default()) .map(|(face, source)| (face.id(), (face.orientation(), source.clone()))) }) .collect(); let operands: Vec<_> = tools.iter().collect(); let shells = tools.iter().flat_map(|tool| tool.solid.boundaries().clone()).collect(); let solid = Solid::try_new(shells).map_err(|error| KernelError::Failed(format!("extrusion compound: {error}")))?; let faces = tools .iter() .enumerate() .flat_map(|(operand, tool)| (0..tool.face_count()).map(move |face| record::from_face(operand, face, crate::history::Change::Kept))) .collect(); let mut edges = HashMap::new(); for (operand, tool) in tools.iter().enumerate() { edges.extend(record::edge_origins(&tool.solid, operand)); } record::build(solid, &record::counts(&operands), Some(faces), Some(&edges)).map(|mut body| { body.regularization_protected = tools.iter().any(|tool| tool.regularization_protected); // Only unchanged face identities carry these transient tool witnesses. // No whole-compound extrusion/producer certificate is created. let mapped = body .solid .face_iter() .map(|face| { sources.get(&face.id()).filter(|(orientation, _)| *orientation == face.orientation()).and_then(|(_, source)| source.clone()) }) .collect(); Some(body.with_face_sources(Some(std::sync::Arc::new(mapped)))) }) }) } /// Whether a union can sew two matching planar faces without intersecting them. /// Callers can retain the exact touching tool instead of extending it into material. pub fn can_join_touching_faces(a: &Body, b: &Body) -> bool { a.solid.boundaries().len() == 1 && b.solid.boundaries().len() == 1 && crate::coplanar::glue(a, b).is_some_and(|r| r.is_ok()) } /// Check all separated extrusion starts in one construction, without rebuilding /// the unchanged target once for each face. Partial seams keep the ordinary path. pub fn can_join_all_touching_faces(a: &Body, b: &Body) -> bool { if a.solid.boundaries().len() != 1 || !(2..=1024).contains(&b.solid.boundaries().len()) || a.face_count().max(b.face_count()) > 16_384 { return false; } guard("check extrusion seams", || Ok(crate::coplanar::glue_all_caps(a, b).is_some_and(|result| result.is_ok()))).unwrap_or(false) } /// Shifts applied to both operands on retries. The boolean classifies some faces by casting a /// ray whose direction is derived from point coordinates; moving both solids (and the result /// back) leaves the geometry unchanged but changes those rays. const JITTER: [[f64; 3]; 4] = [[0.0, 0.0, 0.0], [0.1373, 0.2719, 0.3911], [-0.5127, 0.0833, 0.2291], [0.6911, -0.3337, -0.6127]]; fn volume(b: &Body) -> f64 { // Measured once per (solid, tolerance) and shared by clones, so an operand a later // boolean takes again is not meshed twice for the same number. b.volume_at(b.size() * 2e-3).unwrap_or(f64::NAN) } /// Halton low-discrepancy value (base `b`) for index `i`. fn halton(mut i: usize, b: usize) -> f64 { let (mut f, mut r) = (1.0, 0.0); while i > 0 { f /= b as f64; r += f * (i % b) as f64; i /= b; } r } /// Fraction of sample points where `result` disagrees with `op` applied to `a` and `b` /// (membership by ray parity). Samples cover the overlap box densely and the union box lightly. fn mismatch(a: &solidcraft_geom::Mesh, b: &solidcraft_geom::Mesh, result: &solidcraft_geom::Mesh, op: BoolOp) -> Option { if a.triangles.len() + b.triangles.len() + result.triangles.len() > 60_000 { return None; } let (ba, bb) = (a.bounds(), b.bounds()); let lo = ba.min.max(bb.min); let hi = ba.max.min(bb.max); let all = ba.union(&bb); let mut boxes = vec![(all, 300usize)]; // A touching seam can overlap by round-off only. Samples there sit on the // operands' boundaries, where ray parity cannot classify membership reliably. let gap = all.diagonal().max(1.0) * 1e-9; if hi.x - lo.x > gap && hi.y - lo.y > gap && hi.z - lo.z > gap { boxes.push((solidcraft_geom::Aabb3 { min: lo, max: hi }, 900)); } let (ia_idx, ib_idx, ir_idx) = (a.inside_index(), b.inside_index(), result.inside_index()); let (mut n, mut bad) = (0usize, 0usize); for (bx, count) in boxes { let s = bx.size(); for i in 1..=count { let p = bx.min + Vec3::new(s.x * halton(i, 2), s.y * halton(i, 3), s.z * halton(i, 5)); let (ia, ib) = (ia_idx.contains(p), ib_idx.contains(p)); let want = match op { BoolOp::Union => ia || ib, BoolOp::Cut => ia && !ib, BoolOp::Intersect => ia && ib, }; n += 1; if ir_idx.contains(p) != want { bad += 1; } } } Some(bad as f64 / n.max(1) as f64) } /// How one body sits relative to another, from sample points: (fraction of `b`'s samples /// inside `a`, fraction of `a`'s samples inside `b`). fn overlap( a: &solidcraft_geom::Mesh, b: &solidcraft_geom::Mesh, ia: &solidcraft_geom::InsideIndex, ib: &solidcraft_geom::InsideIndex, ) -> Option<(f64, f64)> { let frac = |inner: &solidcraft_geom::Mesh, inner_i: &solidcraft_geom::InsideIndex, outer_i: &solidcraft_geom::InsideIndex| -> Option { let bx = inner.bounds(); let s = bx.size(); let (mut n, mut hit) = (0usize, 0usize); // A slender body lying across its box (a long hole tool drilled at an angle) fills // little of it: the samples go on past the first 2000 until enough land inside. for i in 1..=64_000 { if i > 2000 && n >= 50 { break; } let p = bx.min + Vec3::new(s.x * halton(i, 2), s.y * halton(i, 3), s.z * halton(i, 5)); if !inner_i.contains(p) { continue; } n += 1; if outer_i.contains(p) { hit += 1; } } (n >= 50).then(|| hit as f64 / n as f64) }; Some((frac(b, ib, ia)?, frac(a, ia, ib)?)) } /// 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, other: &solidcraft_geom::InsideIndex, depth: f64, inside: bool, within: Option<&solidcraft_geom::Aabb3>, ignored: &dyn Fn(Vec3, u32) -> bool, ) -> bool { 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) && !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, 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) { 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 meet = ba.intersection(&bb); 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, &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. /// `tol`: how far the meshes' surfaces may pass through each other and still count as touching /// (they are facetings of the bodies, so a few times their tolerance). /// /// The second value is false when the facetings contradict the samples ([`contradicted`]): /// the answer is then only what to fall back on if the bodies can't be intersected. fn trivial( a: &Body, b: &Body, op: BoolOp, ma: &solidcraft_geom::Mesh, mb: &solidcraft_geom::Mesh, counts: &[(usize, usize)], tol: f64, ) -> Option<(Option, bool)> { if ma.triangles.len() + mb.triangles.len() > 80_000 { return None; } let (ia, ib) = (ma.inside_index(), mb.inside_index()); let (b_in_a, a_in_b) = overlap(ma, mb, &ia, &ib)?; const ALL: f64 = 0.997; let disjoint = b_in_a < NONE && a_in_b < NONE; // 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. // 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. BoolOp::Union if disjoint => { let pieces = vec![(a.clone(), recorded::kept(a, 0, 2)), (b.clone(), recorded::kept(b, 1, 2))]; let joined = recorded::join(pieces, counts).ok().flatten()?; joined.separated_lumps().ok()?; Some(Some(joined)) } BoolOp::Cut if disjoint => Some(Some(recorded::operand(a, 0, counts))), BoolOp::Cut if a_in_b > ALL => Some(None), BoolOp::Intersect if disjoint => Some(None), BoolOp::Intersect if b_in_a > ALL => Some(Some(recorded::operand(b, 1, counts))), BoolOp::Intersect if a_in_b > ALL => Some(Some(recorded::operand(a, 0, counts))), BoolOp::Union if b_in_a > ALL => Some(Some(recorded::operand(a, 0, counts))), BoolOp::Union if a_in_b > ALL => Some(Some(recorded::operand(b, 1, counts))), // The tool wholly inside, clear of the outside: a void. BoolOp::Cut if b_in_a > ALL => { let candidate = void(a, b, counts).ok().flatten()?; candidate.separated_lumps().ok()?; Some(Some(candidate)) } _ => None, }; answer.map(|r| (r, sure)) } #[cfg(test)] mod shortcut_tests { use super::*; #[test] fn seam_roundoff_is_not_a_thin_meeting_but_real_thin_solids_are() { use solidcraft_geom::{Loop2, Plane, Region2, Vec2}; // This circle's seams lie on the X axis: its cylinder's vertex box is flat in Y. let region = Region2 { outer: Loop2::circle(Vec2::ZERO, 8.0), holes: vec![] }; let periodic = crate::extrude(&Plane::XY, &[region], 0.0, 20.0).unwrap().pop().unwrap(); let block = crate::box_solid(Vec3::new(-40.0, -40.0, -10.0), Vec3::new(40.0, 40.0, 10.0)).unwrap(); assert!(meeting_size(&periodic, &block).is_infinite()); let thin = crate::box_solid(Vec3::ZERO, Vec3::new(80.0, 80.0, 1e-5)).unwrap(); assert!((meeting_size(&thin, &thin) - 1e-5).abs() < 1e-12); } #[test] fn rotated_extrusion_bounds_use_exact_cap_separation_and_keep_sources() { use solidcraft_geom::{Loop2, Plane, Region2, Vec2}; let rectangle = |angle: f64, offset: f64| { let (c, s) = (angle.cos(), angle.sin()); Region2 { outer: Loop2::polygon( &[(-2., -0.5), (2., -0.5), (2., 0.5), (-2., 0.5)].map(|(x, y)| Vec2::new(x * c - (y + offset) * s, x * s + (y + offset) * c)), ), holes: vec![], } }; for offset in [1.2, 1., 0.8] { let tools = crate::extrude(&Plane::XY, &[rectangle(0.7, 0.), rectangle(0.7, offset)], 0., 2.).unwrap(); let compound = compound_disjoint_extrusions(&tools).unwrap(); assert_eq!(compound.is_some(), offset > 1.); if let Some(compound) = compound { let sources = compound.face_sources().unwrap(); assert_eq!(sources.len(), compound.face_count()); assert_eq!(sources.iter().filter(|source| matches!(source, Some(crate::FaceSource::ExtrudeCap { high: false, .. }))).count(), 2); assert!(compound.validity().is_empty()); } } } #[test] fn batched_contact_test_matches_individual_tolerances() { let target = crate::cylinder(Vec3::ZERO, Vec3::Z, 5., 3.).unwrap(); let tools = [ crate::box_solid(Vec3::new(-1., -1., 3.), Vec3::new(1., 1., 5.)).unwrap(), crate::box_solid(Vec3::new(-1., -1., 3.002), Vec3::new(1., 1., 5.)).unwrap(), crate::sphere(Vec3::new(20., 0., 1.), 1.).unwrap(), ]; let expected = tools.iter().map(|tool| target.meets(tool).unwrap()).collect::>(); assert_eq!(target.meets_each(&tools).unwrap(), expected); assert!(target.meets_each(&[]).unwrap().is_empty()); } #[test] fn compound_span_does_not_relax_full_face_seam_tolerance() { use solidcraft_geom::{Loop2, Plane, Region2, Vec2}; let mut target = crate::box_solid(Vec3::new(0., 0., -3.), Vec3::new(100., 2., -2.)).unwrap(); for x in [0., 98.] { let boss = crate::box_solid(Vec3::new(x, 0., -2.), Vec3::new(x + 2., 2., 0.)).unwrap(); target = boolean(&target, &boss, BoolOp::Union).unwrap().unwrap(); } let regions: Vec<_> = [0., 98.] .into_iter() .map(|x| Region2 { outer: Loop2::polygon(&[Vec2::new(x, 0.), Vec2::new(x + 2., 0.), Vec2::new(x + 2., 2.), Vec2::new(x, 2.)]), holes: vec![], }) .collect(); let tools = crate::extrude(&Plane::XY, ®ions, 0.000_105, 200.).unwrap(); assert!(tools.iter().all(|tool| !can_join_touching_faces(&target, tool))); let compound = compound_disjoint_extrusions(&tools).unwrap().unwrap(); assert!(!can_join_all_touching_faces(&target, &compound)); } #[test] fn extrusion_compound_requires_separated_construction_bounds() { use solidcraft_geom::{Loop2, Plane, Region2, Vec2}; let rectangle = |x: f64| Region2 { outer: Loop2::polygon(&[Vec2::new(x, 0.0), Vec2::new(x + 2.0, 0.0), Vec2::new(x + 2.0, 2.0), Vec2::new(x, 2.0)]), holes: vec![], }; let plane = Plane::from_normal(Vec3::new(100.0, -20.0, 8.0), Vec3::new(1.0, 2.0, 3.0)).unwrap(); let tools = crate::extrude(&plane, &[rectangle(0.0), rectangle(20.0)], -1.0, 5.0).unwrap(); let compound = compound_disjoint_extrusions(&tools).unwrap().unwrap(); assert_eq!(compound.shell_count(), 2); assert_eq!(compound.history().unwrap().operands, 2); assert!((crate::measure(&compound).unwrap().volume - 48.0).abs() < 1e-8); assert!(compound.validity().is_empty()); for x in [1.0, 2.0, 2.000_000_1] { let touching = crate::extrude(&solidcraft_geom::Plane::XY, &[rectangle(0.0), rectangle(x)], 0.0, 5.0).unwrap(); assert!(compound_disjoint_extrusions(&touching).unwrap().is_none()); } let unsupported = [crate::sphere(Vec3::ZERO, 1.0).unwrap(), crate::sphere(Vec3::new(10.0, 0.0, 0.0), 1.0).unwrap()]; assert!(compound_disjoint_extrusions(&unsupported).unwrap().is_none()); } #[test] fn extrusion_compound_includes_arc_extrema_between_seam_vertices() { use solidcraft_geom::{Loop2, Plane, Region2, Vec2}; let circle = |x| Region2 { outer: Loop2::circle(Vec2::new(x, 0.0), 2.0), holes: vec![] }; let separated = crate::extrude(&Plane::XY, &[circle(0.0), circle(8.0)], 0.0, 5.0).unwrap(); assert!(compound_disjoint_extrusions(&separated).unwrap().is_some()); let overlapping = crate::extrude(&Plane::XY, &[circle(0.0), circle(3.0)], 0.0, 5.0).unwrap(); assert!(compound_disjoint_extrusions(&overlapping).unwrap().is_none()); } #[test] fn curved_near_contact_never_uses_a_shell_only_boolean_candidate() { let direction = Vec3::new(1.0, 2.0, 3.0).normalized().unwrap(); let outer = crate::sphere(Vec3::ZERO, 10.0).unwrap(); let mesh = outer.tessellate(0.03).unwrap(); for distance in [19.999, 20.001] { let other = crate::sphere(direction * distance, 10.0).unwrap(); let other_mesh = other.tessellate(0.03).unwrap(); let counts = record::counts(&[&outer, &other]); assert!(trivial(&outer, &other, BoolOp::Union, &mesh, &other_mesh, &counts, 0.09).is_none()); assert!(trivial(&other, &outer, BoolOp::Union, &other_mesh, &mesh, &counts, 0.09).is_none()); } let protruding = crate::sphere(direction * 9.001, 1.0).unwrap(); let protruding_mesh = protruding.tessellate(0.03).unwrap(); let counts = record::counts(&[&outer, &protruding]); 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] fn a_small_overlap_is_not_taken_for_apart_or_inside() { let cube = |x: f64, y: f64| crate::box_solid(Vec3::new(x, y, 0.0), Vec3::new(x + 10.0, y + 10.0, 10.0)).unwrap(); let a = cube(0.0, 0.0); // A 0.01 slab between parallel faces (0.1 % of each cube), and a 0.02 x 0.02 corner. for (b, want) in [(cube(9.99, 0.0), 1.0), (cube(9.98, 9.98), 0.004)] { let (ma, mb) = (a.tessellate(0.001).unwrap(), b.tessellate(0.001).unwrap()); let counts = record::counts(&[&a, &b]); for op in [BoolOp::Intersect, BoolOp::Cut, BoolOp::Union] { assert!(trivial(&a, &b, op, &ma, &mb, &counts, 0.003).is_none_or(|(_, sure)| !sure), "{op:?} {want}"); } let shared = boolean(&a, &b, BoolOp::Intersect).unwrap().unwrap(); assert!((crate::measure(&shared).unwrap().volume - want).abs() < 1e-9, "{want}"); let cut = boolean(&a, &b, BoolOp::Cut).unwrap().unwrap(); assert!((crate::measure(&cut).unwrap().volume - (1000.0 - want)).abs() < 1e-9, "{want}"); } // Touching on a face, and one cube well inside the other, still take the shortcut. let (touching, inner) = (cube(10.0, 0.0), crate::box_solid(Vec3::new(2.0, 2.0, 2.0), Vec3::new(8.0, 8.0, 8.0)).unwrap()); let ma = a.tessellate(0.001).unwrap(); for (b, op) in [(&touching, BoolOp::Intersect), (&inner, BoolOp::Intersect), (&inner, BoolOp::Union)] { let counts = record::counts(&[&a, b]); assert!(trivial(&a, b, op, &ma, &b.tessellate(0.001).unwrap(), &counts, 0.003).is_some_and(|(_, sure)| sure), "{op:?}"); } } } /// `a` with the inside of `b` (wholly within it) taken out: a second, inward-facing shell. fn void(a: &Body, b: &Body, counts: &[(usize, usize)]) -> Result> { guard("void", || { let mut inner = b.deep_copy(); let inner_edges = record::edge_origins(&inner, 1); inner.not(); let mut shells = a.solid.boundaries().clone(); shells.extend(inner.boundaries().iter().cloned()); let s = crate::body::Solid::try_new(shells).map_err(|e| KernelError::Failed(format!("void: {e}")))?; let (faces, edges) = recorded::void(a, inner_edges, b.face_count()); Ok(Some(record::build(s, counts, Some(faces), Some(&edges))?)) }) } 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) }; /// The intersections left to the booleans running under [`with_attempt_budget`], if any. static ATTEMPTS: std::cell::Cell> = const { std::cell::Cell::new(None) }; } /// `f`, with the booleans it runs on this thread allowed `attempts` of the kernel's own /// intersections between them (each try of a boolean takes one): past those, a boolean fails at /// once instead of trying on. For a caller that would rather report a pair it could not answer /// than wait on bodies the boolean cannot take, and the same on every machine. A budget inside /// another takes the smaller and uses up the outer one's too. pub fn with_attempt_budget(attempts: usize, f: impl FnOnce() -> T) -> T { struct Restore(Option, usize); impl Drop for Restore { fn drop(&mut self) { let left = ATTEMPTS.with(|c| c.get()).unwrap_or(0); ATTEMPTS.with(|c| c.set(self.0.map(|outer| outer.saturating_sub(self.1.saturating_sub(left))))); } } let outer = ATTEMPTS.with(|c| c.get()); let mine = outer.map_or(attempts, |o| o.min(attempts)); ATTEMPTS.with(|c| c.set(Some(mine))); let _restore = Restore(outer, mine); f() } /// Takes one of the attempts left under [`with_attempt_budget`]; false when none is left. fn take_attempt() -> bool { ATTEMPTS.with(|c| match c.get() { None => true, Some(0) => false, Some(n) => { c.set(Some(n - 1)); true } }) } /// Boolean of two bodies. The result may be empty (`Ok(None)`) for a cut that removes /// everything or an intersection of disjoint bodies. Results are checked against volume bounds /// and retried with shifted copies and other tolerances when they fail or look wrong. /// /// The result carries its exact history ([`Body::history`]) over the operands `[a, b]`, /// whichever way it was made, or none where a step it took does not report one. pub fn boolean(a: &Body, b: &Body, op: BoolOp) -> Result> { crate::profile::timed(crate::profile::Kind::Boolean, || boolean_untimed(a, b, op)) } fn boolean_untimed(a: &Body, b: &Body, op: BoolOp) -> Result> { if let Some(r) = with_hollow_tool(a, b, op) { return finished(a, b, op, Ok(r)); } // Earlier coarse bores can leave a junction a later pattern copy cannot intersect. // Resolve conical-cut junctions from the first copy, while the operands are unchanged. if op == BoolOp::Cut && !APART.with(|c| c.get()) && conical_cut_junction(a, b) { let refined = |a: &Body, b: &Body, op| boolean_whole_with_refinement(a, b, op, true); if let Ok(result) = boolean_via(a, b, op, &refined) { return Ok(result); } } let r = boolean_via(a, b, op, &boolean_whole); if r.is_err() && op == BoolOp::Cut && !APART.with(|c| c.get()) && let Some(result) = tool_reseam::cut(a, b) { return Ok(Some(result)); } if r.is_ok() || !crate::tangent_cylinders::needed(a, b) { return r; } // Equal cylinders crossing each other touch at two points the boolean cannot take in the // middle of a face (#788): once more with the faces split along them. let split = |a: &Body, b: &Body, op| { crate::tangent_cylinders::boolean(a, b, op, &boolean_whole).unwrap_or_else(|| Err(KernelError::Failed("no split of faces helps".into()))) }; boolean_via(a, b, op, &split).or(r) } /// A conical cutter meeting a body with an earlier conical cut needs finer tracing at /// their junctions. Guard the analytic recognition as well as the Boolean itself. fn conical_cut_junction(a: &Body, b: &Body) -> bool { guard("conical cut junction", || { let conical = |body: &Body| { let tol = (body.size() * 1e-5).max(1e-7); body.solid.face_iter().any(|face| matches!(crate::offset::surf_of(face, tol), Some(crate::offset::Surf::Cone { .. }))) }; Ok(conical(b) && conical(a)) }) .unwrap_or(false) } /// [`boolean`], the boolean of the whole bodies taken by `whole`. fn boolean_via(a: &Body, b: &Body, op: BoolOp, whole: &dyn Fn(&Body, &Body, BoolOp) -> Result>) -> Result> { let (mut r, mut diagnostics) = capture_boolean_diagnostics(|| whole(a, b, op)); // Bodies in several pieces: when the whole failed (or came out empty), a piece at a time. let retry = match &r { Err(_) => true, Ok(None) => op != BoolOp::Intersect, Ok(Some(_)) => false, }; if retry && (a.solid.boundaries().len() > 1 || b.solid.boundaries().len() > 1) { let (la, lb) = (a.lumps()?, b.lumps()?); if la.len() > 1 || lb.len() > 1 { let (pieces, report) = capture_boolean_diagnostics(|| by_lumps(a, b, la, lb, op)); if let Ok(Some(x)) = pieces { r = Ok(Some(x)); diagnostics = report; diagnostics.push(BooleanFallback::new(BooleanStrategy::Piecewise)); } } } // A piece with sealed voids, cut clear of them: the outer shell alone, the voids put back. if op == BoolOp::Cut && r.is_err() { let (cut, report) = capture_boolean_diagnostics(|| cut_around_voids(a, b, whole)); if let Ok(Some(x)) = cut { r = Ok(Some(x)); diagnostics = report; diagnostics.push(BooleanFallback::new(BooleanStrategy::Piecewise)); } } if op == BoolOp::Union && let Ok(Some(body)) = &r && !preserves_planar_surfaces(a, b, body) { // Numerical retries must not quietly alter a planar design's dimensions. // Prefer the exact polygon result; reject an edge-only pinch if it cannot // form a closed solid without displacing either operand. r = match crate::polybool::planar_boolean(a, b, op) { Ok(Some(exact)) if preserves_planar_surfaces(a, b, &exact) => { diagnostics = Default::default(); diagnostics.events.push(BooleanFallback::new(BooleanStrategy::PlanarFallback)); Ok(Some(exact)) } _ => Err(KernelError::Invalid( "join cannot preserve the original faces; check for zero-thickness edge contact or add intentional overlap".into(), )), }; } r = finished(a, b, op, r); // A retry's result is held to what the operation can do at all; one that fails is refused // rather than returned wrong (issue #616). if (!diagnostics.events.is_empty() || diagnostics.truncated) && let Ok(result) = &r && let Err(e) = crate::boolean_guard::check_retry(a, b, op, result.as_ref()) { let tried = diagnostics.summary().unwrap_or_default(); r = Err(match e { KernelError::Failed(m) => KernelError::Failed(format!("{m} ({})", tried.trim_start_matches("Boolean retry: "))), other => other, }); } if r.is_ok() { merge(diagnostics); } r } /// What a boolean's result keeps of its operands: their regularization protection, and the /// sources of the planar faces it keeps. fn finished(a: &Body, b: &Body, op: BoolOp, r: Result>) -> Result> { let r = r.map(|result| result.map(|body| body.inherit_regularization_protection(a).inherit_regularization_protection(b))); match op { BoolOp::Cut => r.and_then(|result| result.map(|body| body.with_preserved_boolean_planar_sources(a, b, true)).transpose()), BoolOp::Union => r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(a, b)).transpose()), // Every face of an intersection lies on one operand's face, as a union's does: the same // roles carry over (#565). BoolOp::Intersect => r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(a, b)).transpose()), } } /// The most shells [`cut_around_voids`] takes apart. const MAX_VOID_SHELLS: usize = 64; /// `a` cut by `b` around `a`'s voids: when `a` is one piece with sealed voids (inner shells) and /// `b` stays clear of every void, the outer shell alone is cut and the voids are put back. The cut /// of the whole failed on such bodies where the same cut of the outer shell works: a sphere cut /// far from a void (robustness seed 15). `None` when `a` has no voids, `b` comes near one, or /// the cut of the outer shell fails too. The result carries no history. fn cut_around_voids(a: &Body, b: &Body, whole: &dyn Fn(&Body, &Body, BoolOp) -> Result>) -> Result> { let shells = a.solid.boundaries().clone(); if shells.len() < 2 || shells.len() > MAX_VOID_SHELLS || b.solid.boundaries().len() != 1 || a.lumps()?.len() != 1 { return Ok(None); } let tol = (a.size() * 1e-3).max(1e-3); let mut boxes = Vec::with_capacity(shells.len()); for sh in &shells { let piece = guard("void shell", || Body::new(Solid::try_new(vec![sh.clone()]).map_err(|e| KernelError::Failed(format!("void shell: {e}")))?))?; let m = piece.tessellate(tol)?; if m.positions.is_empty() { return Ok(None); } boxes.push(m.bounds()); } let extent = |i: usize| { boxes.get(i).map_or(0.0, |x| { let d = x.max - x.min; d.x * d.y * d.z }) }; let Some(outer) = (0..shells.len()).max_by(|i, j| extent(*i).total_cmp(&extent(*j))) else { return Ok(None) }; let Some(ob) = boxes.get(outer) else { return Ok(None) }; let tm = b.tessellate((b.size() * 1e-3).max(1e-3))?; let tb = tm.bounds(); // Clear of the tool by more than both meshes' deflection. let gap = 4.0 * tol + (b.size() * 1e-3).max(1e-3); let inside = |x: &solidcraft_geom::Aabb3| { x.min.x >= ob.min.x && x.min.y >= ob.min.y && x.min.z >= ob.min.z && x.max.x <= ob.max.x && x.max.y <= ob.max.y && x.max.z <= ob.max.z }; let clear = |x: &solidcraft_geom::Aabb3| { x.max.x + gap < tb.min.x || tb.max.x + gap < x.min.x || x.max.y + gap < tb.min.y || tb.max.y + gap < x.min.y || x.max.z + gap < tb.min.z || tb.max.z + gap < x.min.z }; let mut voids = Vec::new(); for (i, (sh, x)) in shells.iter().zip(&boxes).enumerate() { if i == outer { continue; } if !inside(x) || !clear(x) { return Ok(None); } voids.push(sh.clone()); } let Some(outer_shell) = shells.get(outer) else { return Ok(None) }; let alone = guard("outer shell", || Body::new(Solid::try_new(vec![outer_shell.clone()]).map_err(|e| KernelError::Failed(format!("outer shell: {e}")))?))?; let Some(cut) = boolean_via(&alone, b, BoolOp::Cut, whole)? else { return Ok(None) }; let mut all = cut.solid.boundaries().clone(); all.extend(voids); Ok(Some(guard("voids back", || Body::new(Solid::try_new(all).map_err(|e| KernelError::Failed(format!("voids back: {e}")))?))?)) } /// A cut or union with `b` when `b` is one outer shell with sealed voids, from booleans with the /// outer shell and with the solids the voids are: `a` cut by `b` is `a` cut by the outer shell /// beside `a` within each void, and `a` joined with `b` is `a` joined with the outer shell, with /// what of each void `a` does not fill as a void. truck takes a tool's shells one at a time, each /// as if it were a body of its own, which is neither: such cuts came out empty, or kept only what /// lies in the void (a block crossing both spheres of a spherical shell, #451). Planar tools are /// left to the exact paths. `None` for other operations and tools, a void not inside the outer /// shell, and a result that fails the membership samples the general way's results are held to /// (a piece that failed or came out empty): the bodies then go the general way. fn with_hollow_tool(a: &Body, b: &Body, op: BoolOp) -> Option> { let shells = b.solid.boundaries(); if op == BoolOp::Intersect || b.is_mesh() || shells.len() < 2 || shells.len() > MAX_VOID_SHELLS || is_planar(b) { return None; } let (mut outer, mut voids) = (None, Vec::new()); for sh in shells { if crate::body::faces_inward(sh).ok()? { voids.push(sh.clone()); } else if outer.replace(sh.clone()).is_some() { return None; } } // Each shell a body of its own, a void turned outwards: the solid it holds. let parts: Vec = std::iter::once(outer?) .chain(voids) .map(|sh| guard("hollow tool", || Body::new(Solid::try_new(vec![sh]).map_err(|e| KernelError::Failed(format!("hollow tool: {e}")))?))) .collect::>() .ok()?; let t = a.size().max(b.size()) * 5e-4; let (shell, holes) = parts.split_first()?; let mesh = shell.tessellate(t).ok()?; let inside = mesh.inside_index(); if !holes.iter().all(|h| h.solid.vertex_iter().all(|v| inside.contains(from_p3(v.point())))) { return None; } let r = by_outer_and_voids(a, b, parts, op).ok()?; let mr = match &r { Some(r) => r.tessellate_with(t, true).ok()?, None => solidcraft_geom::Mesh::default(), }; mismatch(&a.tessellate_with(t, true).ok()?, &b.tessellate_with(t, true).ok()?, &mr, op).is_some_and(|f| f < 0.004).then_some(r) } /// [`with_hollow_tool`]'s booleans, with `b` as its outer shell's solid, then its voids'. fn by_outer_and_voids(a: &Body, b: &Body, parts: Vec, op: BoolOp) -> Result> { let counts = record::counts(&[a, b]); let traced: Vec = recorded::parts_of(&parts, b).into_iter().zip(parts).map(|(h, p)| (p, recorded::placed(h, 1, 2))).collect(); let pair = |(x, hx): &Traced, (y, hy): &Traced, op: BoolOp| -> Result> { Ok(boolean(x, y, op)?.map(|r| { let h = recorded::of_pair(&r, hx, hy); (r, h) })) }; let a = (a.clone(), recorded::kept(a, 0, 2)); let Some((shell, voids)) = traced.split_first() else { return Ok(None) }; if op == BoolOp::Cut { let mut pieces: Vec = pair(&a, shell, BoolOp::Cut)?.into_iter().collect(); for v in voids { pieces.extend(pair(&a, v, BoolOp::Intersect)?); } return recorded::join(pieces, &counts); } let Some(mut joined) = pair(&a, shell, BoolOp::Union)? else { return Ok(None) }; // What of a void `a` leaves empty lies inside the outer shell, clear of the outside: a void again. for v in voids { if let Some((left, hl)) = pair(v, &a, BoolOp::Cut)? && let Some(r) = void(&joined.0, &left, &record::counts(&[&joined.0, &left]))? { let h = recorded::of_pair(&r, &joined.1, &hl); joined = (r, h); } } Ok(Some(joined.0.with_checked_history(joined.1, &counts))) } /// Every face of an all-planar union must remain on an operand's original plane. /// Curved operands keep their existing surface-specific boolean handling. fn preserves_planar_surfaces(a: &Body, b: &Body, result: &Body) -> bool { guard("validate planar union", || Ok(planar_surfaces_match(a, b, result))).unwrap_or(false) } fn planar_surfaces_match(a: &Body, b: &Body, result: &Body) -> bool { let planes: Option> = a .solid .face_iter() .chain(b.solid.face_iter()) .map(|f| { let mt::Surface::Plane(p) = f.oriented_surface() else { return None }; let n = p.normal(); let n = Vec3::new(n.x, n.y, n.z).normalized()?; Some((n, n.dot(from_p3(p.origin())))) }) .collect(); let Some(planes) = planes else { return true }; let tol = (a.size().max(b.size()) * 1e-9).max(1e-9); result.solid.face_iter().all(|f| { matches!(f.oriented_surface(), mt::Surface::Plane(_)) && planes.iter().any(|(n, d)| f.vertex_iter().all(|v| (n.dot(from_p3(v.point())) - d).abs() <= tol)) }) } /// Smallest side of the box where the bodies' vertex boxes overlap (infinite when they don't). fn meeting_size(a: &Body, b: &Body) -> f64 { let bbox = |x: &Body| { let mut bb = solidcraft_geom::Aabb3::EMPTY; for v in x.solid.vertex_iter() { bb.add(from_p3(v.point())); } bb }; let (ba, bb) = (bbox(a), bbox(b)); let s = ba.intersection(&bb).size(); // A closed sweep's section seams need not span its geometry. Roundoff in a flat // vertex box is not a thin meeting region: refining for it // makes millions of triangles and skips the bounded containment shortcut (#2005). let roundoff = a.size().max(b.size()) * 1e-12; if s.x > roundoff && s.y > roundoff && s.z > roundoff { s.x.min(s.y).min(s.z) } else { f64::INFINITY } } /// Smallest side of the box where the bounds of two meshes overlap (infinite when they don't). /// Unlike [`meeting_size`], this follows curved faces: a cylinder's vertices are only the points /// on its seam, so its vertex box says nothing about where its side reaches. fn mesh_meeting_size(a: &solidcraft_geom::Mesh, b: &solidcraft_geom::Mesh) -> f64 { let (ba, bb) = (a.bounds(), b.bounds()); let s = ba.intersection(&bb).size(); if s.x > 0.0 && s.y > 0.0 && s.z > 0.0 { s.x.min(s.y).min(s.z) } else { f64::INFINITY } } /// Whether a result volume is plausible for `op`: within the bounds the operands' volumes /// leave, plus the slack the meshed volumes are measured to. fn plausible(v: f64, op: BoolOp, va: f64, vb: f64, slack: f64) -> bool { v > 0.0 && match op { BoolOp::Union => v >= va.max(vb) - slack && v <= va + vb + slack, BoolOp::Cut => v >= va - vb - slack && v <= va + slack, BoolOp::Intersect => v <= va.min(vb) + slack, } } /// A boolean in 2D of prisms along one direction (see [`prism_result`]). type Route = fn(&Body, &Body, BoolOp) -> Option>>; /// A prism route's result (`route`: [`crate::prism::prism_boolean`] or /// [`crate::prism::prism_union_between_caps`]): `Some` when both operands are prisms along one /// direction, with a union's slab seams healed as the general B-rep boolean does. fn prism_result(a: &Body, b: &Body, op: BoolOp, size: f64, counts: &[(usize, usize)], route: Route) -> Option>> { // Slab-by-slab prism booleans sew a closed solid, but leave cap and wall pieces along slab // boundaries: a cut along Z through a box whose side wall already has a port in it splits // that wall into strips at the port's top and bottom, though the cut never touches it. Merge // those coplanar faces for every operation, just as the general B-rep boolean does, retaining // intentional Split Face lines. Authored boundaries (painted faces, regularization // protection) keep their pieces. let keep: Vec> = a.split_keep().iter().chain(b.split_keep()).cloned().collect(); let authored = |x: &Body| x.regularization_protected || x.paint().is_some_and(|p| !p.faces.is_empty()); route(a, b, op).map(|result| { result.map(|body| { body.map(|body| { if op == BoolOp::Union { guard("heal prism boolean", || recorded::heal_body(&body, (*body.solid).clone(), size, &keep, counts)).unwrap_or(body) } else if authored(a) || authored(b) { body } else { guard("heal prism boolean", || recorded::heal_prism_result(&body, size, &keep, counts)).unwrap_or(body) } }) }) }) } /// Walls swept along splines have flat B-spline tops and bottoms. With those made planes the /// operands are prisms, and two of them (same height, one direction) are decided in 2D: fast, and /// with no intersection of spline surfaces, which is what fails on them. The outlines are fitted /// by arcs within a micron (`prism_boolean_free_form`). `None` when the operands have no such /// face, are not such prisms, or the answer is implausible: the general boolean then takes over. fn swept_prism(a: &Body, b: &Body, op: BoolOp) -> Option { let (pa, pb) = (crate::planar_faces::planarized(a), crate::planar_faces::planarized(b)); if pa.is_none() && pb.is_none() { return None; } let (ra, rb) = (pa.as_ref().unwrap_or(a), pb.as_ref().unwrap_or(b)); let Some(Ok(Some(body))) = crate::prism::prism_boolean_free_form(ra, rb, op) else { return None }; let (va, vb) = (volume(a), volume(b)); plausible(volume(&body), op, va, vb, 2e-3 * (va + vb) + 1e-9).then_some(body) } fn boolean_whole(a: &Body, b: &Body, op: BoolOp) -> Result> { boolean_whole_with_refinement(a, b, op, false) } fn boolean_whole_with_refinement(a: &Body, b: &Body, op: BoolOp, refine: bool) -> Result> { boolean_whole_with(a, b, op, refine, &truck_boolean) } /// The whole-body strategies with the numerical intersection supplied separately, so tests /// can reproduce an empty numerical attempt without depending on a particular ray seed. fn boolean_whole_with(a: &Body, b: &Body, op: BoolOp, refine: bool, intersect: &F) -> Result> where F: Fn(&Body, &Body, BoolOp, Option, f64) -> Result<(Solid, Option)>, { if let Some(body) = swept_prism(a, b, op) { return Ok(Some(body)); } a.require_brep("a boolean")?; b.require_brep("a boolean")?; let size = a.size().max(b.size()); let counts = record::counts(&[a, b]); // The checks mesh both bodies; where they meet in a region much thinner than they are (a // thin part trimmed by a long one), a step from their size would facet the small faces // there coarsely enough to fail the membership test on a correct result. The meshes are // refined: a round side trimmed to a thin band (a short boss crossing a gently sloping // floor) is otherwise spanned by triangles cutting through it, which reads as missing // material. let mut tol_m = (size * 5e-4).min(meeting_size(a, b) * 2e-3).max(size * 1e-5); // A prism pair (a plate and the tool through it) is decided exactly in 2D, with no mesh of // either operand. The sampled shortcuts below need a refined mesh of both, and that mesh is // most of what a boolean costs: a pattern or a multi-profile sketch rebuilds the whole // target's mesh once per tool. Only a cut or an intersection meets its tool often enough to // be worth asking first - parts that stay apart are settled far more cheaply by the shell // join the sampled shortcut does. A pair the route cannot answer still takes the path below, // unchanged. let early_prism = matches!(op, BoolOp::Cut | BoolOp::Intersect); let prism = early_prism.then(|| prism_result(a, b, op, size, &counts, crate::prism::prism_boolean)).flatten(); if let Some(Ok(Some(body))) = &prism { let (va0, vb0) = (volume(a), volume(b)); let (v0, slack0) = (volume(body), 2e-3 * (va0 + vb0) + 1e-9); // A tool that misses its target, or covers it whole, leaves it as it is, and the // sampled shortcut below answers that by reusing the operand itself: the very same body. // The 2D route rebuilds it instead - the same shape on new faces - which would turn an // untouched body in a timeline into a different solid. The route declines those pairs // itself, from its exact sections (a volume measured off meshes could not tell an // engraving of thin strokes from no change), and they take the path below, which // decides them, and the identity they keep, exactly as it always has. if plausible(v0, op, va0, vb0, slack0) { return Ok(Some(body.clone())); } } let mut meshes = (a.tessellate_with(tol_m, true).ok(), b.tessellate_with(tol_m, true).ok()); // The vertex boxes above miss a curved operand's reach (a cylinder has only seam vertices), // so a thin meeting region of curved bodies kept the coarse step: a sliver 0.5 mm thick was // faceted at 0.017 mm and a correct result failed the membership test. The meshes just made // do span the bodies, so the step is set again from where they meet and the meshes are // remade once, when that is a much finer step. let refined = match &meshes { // A meeting box only a few steps thick is the tessellation error of bodies that merely // touch or miss each other: a finer mesh there cannot help and only slows the operation. (Some(ma), Some(mb)) => { let meet = mesh_meeting_size(ma, mb); (meet > tol_m * 8.0).then(|| (size * 5e-4).min(meet * 2e-3).max(size * 1e-5)) } _ => None, }; if let Some(refined) = refined && refined < tol_m * 0.5 { let again = (a.tessellate_with(refined, true).ok(), b.tessellate_with(refined, true).ok()); if again.0.is_some() && again.1.is_some() { tol_m = refined; meshes = again; } } let (va, vb) = match &meshes { (Some(ma), Some(mb)) => (ma.measure().volume, mb.measure().volume), _ => (volume(a), volume(b)), }; let slack = 2e-3 * (va + vb) + 1e-9; // Where a result's edges can run: a candidate with an edge far outside the operands is // discarded before it is meshed (#3020), as meshing such a face may never finish. let reach = crate::candidate_reach::Reach::new(a, b, (meshes.0.as_ref(), meshes.1.as_ref()), size); // Volume bounds, then membership against the operands (catches misclassified pieces), on // one mesh of the result. Returns (plausible, volume). // Shells that touch were never fused: coincident back-to-back faces leave the intersection // nothing to cut, so it returns both operands side by side (#396). Volume and point // sampling cannot see that; the shell grouping can. Only contact over an area counts // (bodies tangent along a line stay two lumps), and operands already like that, saved // before this was caught, stay joinable. Nor can they see a skin of no thickness left over // a hole by a tool ending in a face of the target ([`crate::coplanar::has_skin`]). let unfused = |r: &Body| { op == BoolOp::Union && r.shell_count() > 1 && r.union_lumps().is_err() && a.union_lumps().is_ok() && b.union_lumps().is_ok() && crate::coplanar::faces_touch(a, b) }; let check = |r: &Body| -> (bool, f64) { if let Some(reason) = reach.as_ref().and_then(|reach| reach.runaway(r)) { reject(reason); return (false, f64::NAN); } let Ok(mr) = r.tessellate_with(tol_m, true) else { return (false, f64::NAN) }; let v = mr.measure().volume; let bounds = plausible(v, op, va, vb, slack); if !bounds { return (false, v); } if unfused(r) || crate::coplanar::has_skin(r, &mr) { return (false, v); } let consistent = match &meshes { (Some(ma), Some(mb)) => mismatch(ma, mb, &mr, op).is_none_or(|f| f < 0.004), _ => true, }; (consistent, v) }; if refine { let keep: Vec> = a.split_keep().iter().chain(b.split_keep()).cloned().collect(); // Bounded to two finer meshes; no tool displacement or relaxed acceptance tests. for k in [1e-5, 1e-6] { let tol = (size * k).max(1e-6); if let Ok((solid, history)) = intersect(a, b, op, None, tol) && !solid.boundaries().is_empty() && let Ok(body) = guard("refined boolean result", || recorded::truck_result(solid, history, size, &keep, &counts)) && check(&body).0 && crate::boolean_guard::check_retry(a, b, op, Some(&body)).is_ok() { let mut event = BooleanFallback::new(BooleanStrategy::RefinedTolerance); event.tolerance_mm = tol; record(event); return Ok(Some(body)); } } return Err(KernelError::Failed("no reliable result at refined tolerances".into())); } // One body clear of or inside the other: no intersection needed. // Kept for the end when the facetings disagree with it: bodies that touch along curved // faces can pass through each other slightly, and often can't be intersected. let mut doubted = None; if let (Some(ma), Some(mb)) = &meshes && let Some((r, sure)) = trivial(a, b, op, ma, mb, &counts, 3.0 * tol_m) { if sure { return Ok(r); } doubted = Some(r); } let mut last = String::new(); // Coincident faces make the intersection fail after many retries; push them apart first. // Prisms along one direction (plates with holes): exact, in 2D (so only the volume bounds // are checked). For a cut or an intersection this already ran above; the other operations // ask here, after the sampled shortcut, which is where that shortcut is cheapest. let prism = prism.or_else(|| (!early_prism).then(|| prism_result(a, b, op, size, &counts, crate::prism::prism_boolean)).flatten()); if let Some(result) = prism { match result { Ok(Some(body)) => { // Measured as the operands were: a coarser mesh of a plate with many holes // overstates its volume by more than the slack. let v = match &meshes { (Some(_), Some(_)) => body.tessellate_with(tol_m, true).map(|m| m.measure().volume).unwrap_or(f64::NAN), _ => volume(&body), }; if plausible(v, op, va, vb, slack) { return Ok(Some(body)); } } Ok(None) => return Ok(None), // A failed prism attempt keeps trying the other strategies, as it did before. Err(_) => {} } } // Bodies touching along one whole face (a part joined with its mirror image). if op == BoolOp::Union && a.solid.boundaries().len() == 1 { let glued = if b.solid.boundaries().len() == 1 { crate::coplanar::glue(a, b) } else { crate::coplanar::glue_all_caps(a, b) }; if let Some(Ok(body)) = glued { let (ok, _) = check(&body); if ok { return Ok(Some(body)); } } } // Bores on a common cylinder (a pad's bore around the hole it is joined over, a disc filling // a hole). Asked before faces are pushed apart: that doesn't part walls on one cylinder, and // its tries at the general boolean, all failing on those walls, cost seconds. if op == BoolOp::Union && !BORES.with(|c| c.get()) && crate::coplanar::has_coincident_cylinders(a, b) { BORES.with(|c| c.set(true)); let (r, diagnostics) = capture_boolean_diagnostics(|| crate::coplanar::bore_union(a, b, &|body| check(body).0)); BORES.with(|c| c.set(false)); if let Some(body) = r { merge(diagnostics); return Ok(Some(body)); } } // Coincident planar faces: push them apart (exactly). Tried once, before the general // boolean; why it failed is reported if everything else fails too. let mut apart_failed = String::new(); // The exact polygon boolean's answer, when it was asked for early. let mut planar = None; if !APART.with(|c| c.get()) { APART.with(|c| c.set(true)); let (r, diagnostics) = capture_boolean_diagnostics(|| crate::coplanar::boolean_apart(a, b, op)); APART.with(|c| c.set(false)); match r { Some(Ok(Some(body))) => { let (ok, v) = check(&body); if ok { merge(diagnostics); let mut event = BooleanFallback::new(BooleanStrategy::CoplanarSeparation); event.face_shift_mm = size * 0.0229; record(event); return Ok(Some(body)); } apart_failed = format!("; faces pushed apart gave an implausible volume {v:.4}"); } Some(Err(e)) => apart_failed = format!("; {e}"), Some(Ok(None)) | None => {} } // A face with no room to move would take or add what it moves through. The exact // polygon boolean takes the bodies as they lie (bodies with only planar faces, or a // planar tool clear of the other body's curved faces): it is asked now, before the // general boolean has its tries at faces lying in each other. if apart_failed.contains(crate::coplanar::NO_ROOM) { // What its own booleans report counts only when its result is taken. let (exact, diagnostics) = capture_boolean_diagnostics(|| crate::polybool::planar_boolean(a, b, op)); match exact { Ok(Some(body)) if check(&body).0 => { merge(diagnostics); record(BooleanFallback::new(BooleanStrategy::PlanarFallback)); return Ok(Some(body)); } other => planar = Some(other), } } } // A face standing wholly inside a coincident face of the other body, back to back, and no // other contact (#396): exact, by topology alone. if op == BoolOp::Union && a.solid.boundaries().len() == 1 && b.solid.boundaries().len() == 1 && let Some(Ok(body)) = crate::coplanar::inset(a, b) && let (Some(ma), Some(mb)) = &meshes && overlap(ma, mb, &ma.inside_index(), &mb.inside_index()).is_some_and(|(b_in_a, a_in_b)| b_in_a < NONE && a_in_b < NONE) && check(&body).0 { return Ok(Some(body)); } // Faces back to back over part of their area: imprinted on each other and glued (exact; held // to the retry guard's checks all the same). if op == BoolOp::Union && crate::coplanar::faces_touch(a, b) { let accept = |body: &Body| check(body).0 && !unfused(body) && crate::boolean_guard::check_retry(a, b, op, Some(body)).is_ok(); // Imprinted along the contact's own outline (faces there bounded by lines and arcs), then // along the sides' surfaces. if let Some(body) = crate::outline::outline_union(a, b, &accept) { return Ok(Some(body)); } if let Some(body) = crate::coplanar::imprint_union(a, b, &accept) { return Ok(Some(body)); } } let mut empty_votes = 0; let mut empty_diagnostics = crate::BooleanDiagnostics::default(); let keep: Vec> = a.split_keep().iter().chain(b.split_keep()).cloned().collect(); // The tolerances below follow the larger body. Where the bodies meet in a region much // smaller than that (a hole a few millimetres across drilled through a long part, whose tool // is longer still), they are as coarse as the tool itself: its intersection curves are // traced at a step wider than the hole, and the cut comes out empty or fails. When those // tries fail, the same boolean is asked again at tolerances (and shifts) scaled to where the // bodies meet. Its result is checked as the others are, and held to the retry guard. // Bodies in several shells are retried a piece at a time (see [`boolean`]), where each // piece gets this pass of its own. let fine_tols: Vec = match &meshes { (Some(ma), Some(mb)) if a.solid.boundaries().len() == 1 && b.solid.boundaries().len() == 1 => { let (ba, bb) = (ma.bounds(), mb.bounds()); let s = ba.intersection(&bb).size(); // The thinner operand's thickness (twice its volume over its area: a plate's // thickness, a rod's radius) bounds what the tolerance must resolve as well. let thickness = |m: &solidcraft_geom::Mesh| { let x = m.measure(); if x.area > 0.0 { 2.0 * x.volume.abs() / x.area } else { f64::INFINITY } }; let feature = s.x.min(s.y).min(s.z).min(thickness(ma)).min(thickness(mb)).max(size * 1e-4); if feature > 0.0 && feature * 2e-3 < size * 2.5e-4 { vec![(feature * 2e-3).max(1e-6), (feature * 5e-4).max(1e-6)] } else { Vec::new() } } _ => Vec::new(), }; let fine = |last: &mut String| -> Option { let feature = fine_tols.first().map(|t| t / 2e-3)?; // Unshifted, then once shifted: each try at these tolerances costs many coarser ones. for (attempt, j) in JITTER.iter().enumerate().take(2) { let shift = mt::Vector3::new(j[0], j[1], j[2]) * (feature * 0.01); for &tol in &fine_tols { match intersect(a, b, op, if attempt > 0 { Some(shift) } else { None }, tol) { Ok((s, _)) if s.boundaries().is_empty() || s.face_iter().next().is_none() => *last = "empty result".into(), Ok((s, h)) => match guard("boolean result", || recorded::truck_result(s, h, size, &keep, &counts)) { Ok(body) => { let (ok, v) = check(&body); if ok { let mut event = BooleanFallback::new(if attempt > 0 { BooleanStrategy::ShiftedOperands } else { BooleanStrategy::RefinedTolerance }); event.translation_mm = Vec3::new(j[0], j[1], j[2]).len() * (feature * 0.01); event.tolerance_mm = tol; record(event); return Some(body); } *last = format!("implausible result volume {v:.4}"); } Err(e) => *last = e.to_string(), }, Err(e) => *last = e.to_string(), } } } None }; for (attempt, j) in JITTER.iter().enumerate() { // The operands as they lie failed. A planar tool beside the target's curved faces (a tooth // or a pocket cut next to a round edge) is decided exactly in the slab it lies in, where // the target is planar too, before the shifted tries: that is where they end anyway, as a // retry, after costing several times as much (on every copy of a pattern, #1197). if attempt == 1 && matches!(op, BoolOp::Cut | BoolOp::Intersect) { let (sliced, diagnostics) = capture_boolean_diagnostics(|| crate::polybool::sliced_planar_boolean(a, b, op)); if let Some(Ok(Some(body))) = sliced && check(&body).0 { merge(diagnostics); return Ok(Some(body)); } } // A prism tool whose walls only touch the target (a corner of its outline on a ring's bore // or in its end face, the wall beside it outside the ring): with those walls pushed // outward, clear of the target, it takes the same cut exactly, without the contact the // tries below fail on (and the nudge after them got through only seconds later, leaving a // face of no width at the corner). if attempt == 1 && op == BoolOp::Cut && let (Some(ma), Some(_)) = &meshes && let Some(body) = pushed_walls_cut(a, b, ma, 2.0 * tol_m, size, &keep, &counts, &check) { return Ok(Some(body)); } // A prism tool whose target is a prism along its direction only round it (a pocket made // deeper in a plate with a chamfered rim, a ring cut round a counterbored hole in a // chamfered disc): the exact 2D route in a column cut round the tool. Its walls lying on // the target's are what the tries below fail on. if attempt == 1 && matches!(op, BoolOp::Cut | BoolOp::Intersect) { let (local, diagnostics) = capture_boolean_diagnostics(|| crate::prism_local::local_prism_boolean(a, b, op)); if let Some(Ok(Some(body))) = local && check(&body).0 { merge(diagnostics); return Ok(Some(body)); } } // A lens cut from a sphere's projected outline carries a redundant cylinder // tangent to the sphere (#2750). Remove it only after proving that it // encloses the entire target, keeping the other wall and both caps exact. if attempt == 1 && op == BoolOp::Cut { let (lens, diagnostics) = capture_boolean_diagnostics(|| crate::sphere_lens::cut(a, b, &boolean_whole)); if let Some(Ok(result)) = lens && result.as_ref().is_none_or(|body| check(body).0) { merge(diagnostics); return Ok(result); } } // A whole turn of a cylinder or cone bounded by one wire along its seam (as STEP files // write them) can't be divided by a loop lying inside it, and the tries below end in a // nudged tool, or fail: the same boolean with such faces in two halves, which is exact. if attempt == 1 && crate::seam_faces::needed(a, b) { let (halves, diagnostics) = capture_boolean_diagnostics(|| crate::seam_faces::boolean(a, b, op, &boolean)); if let Some(Ok(r)) = halves && r.as_ref().is_none_or(|body| check(body).0) { merge(diagnostics); return Ok(r); } } // An implausible empty result from the unshifted numerical tries must still give // the exact strategies above a chance (#1765), including seam-face recovery. If none // recovers it, keep the original candidate for the outer guard, before displaced retries. if empty_votes >= 2 && op != BoolOp::Union { merge(empty_diagnostics); return Ok(None); } let shift = mt::Vector3::new(j[0], j[1], j[2]) * (size * 0.01); for k in [2e-3, 5e-4] { let tol = (size * k).max(1e-5); let r = intersect(a, b, op, if attempt > 0 { Some(shift) } else { None }, tol); match r { Ok((s, _)) if s.boundaries().is_empty() || s.face_iter().next().is_none() => { empty_votes += 1; if attempt > 0 || k != 2e-3 { let mut event = BooleanFallback::new(if attempt > 0 { BooleanStrategy::ShiftedOperands } else { BooleanStrategy::RefinedTolerance }); event.translation_mm = Vec3::new(j[0], j[1], j[2]).len() * (size * 0.01); event.tolerance_mm = tol; empty_diagnostics.push(event); } last = "empty result".into(); } Ok((s, h)) => match guard("boolean result", || recorded::truck_result(s, h, size, &keep, &counts)) { Ok(body) => { let (ok, v) = check(&body); if ok { if attempt > 0 || k != 2e-3 { let mut event = BooleanFallback::new(if attempt > 0 { BooleanStrategy::ShiftedOperands } else { BooleanStrategy::RefinedTolerance }); event.translation_mm = Vec3::new(j[0], j[1], j[2]).len() * (size * 0.01); event.tolerance_mm = tol; record(event); } return Ok(Some(body)); } last = if unfused(&body) { "the bodies touch along faces that could not be fused".into() } else { format!("implausible result volume {v:.4}") }; } Err(e) => last = e.to_string(), }, Err(e) => last = e.to_string(), } } if empty_votes >= 2 && op != BoolOp::Union { if let Some(body) = fine(&mut last) { return Ok(Some(body)); } if attempt == 0 && crate::boolean_guard::check_retry(a, b, op, None).is_err() { continue; } merge(empty_diagnostics); return Ok(None); } } last.push_str(&apart_failed); // Coincident faces defeat the B-rep boolean; bodies with only planar faces have an exact // polygon fallback. match planar.unwrap_or_else(|| crate::polybool::planar_boolean(a, b, op)) { Ok(Some(body)) => { let (ok, v) = check(&body); if ok { record(BooleanFallback::new(BooleanStrategy::PlanarFallback)); return Ok(Some(body)); } last = format!("planar fallback gave an implausible volume {v:.4}"); } Ok(None) => { record(BooleanFallback::new(BooleanStrategy::PlanarFallback)); return Ok(None); } Err(e) => last = format!("{last}; {e}"), } // Prisms along one direction that end at different levels (a barrel joined between two // faces of a wider part, its ends flush with them) were left to the B-rep boolean, which // the coincident ends defeat, with no room to push them apart (the part goes on past // them). In 2D they join exactly: asked before the tool is moved. if let Some(Ok(Some(body))) = prism_result(a, b, op, size, &counts, crate::prism::prism_union_between_caps) { let (ok, v) = check(&body); if ok { return Ok(Some(body)); } last = format!("{last}; the prisms joined in 2D gave an implausible volume {v:.4}"); } // Last resort: nudge the tool by a micron-scale screw motion (turned 2e-6 rad about a // skew axis and moved 2e-6 of the size), which breaks tangencies and seams lying exactly on // the other body. The result moves by no more than that. if !APART.with(|c| c.get()) { APART.with(|c| c.set(true)); let c = b.solid.vertex_iter().fold(Vec3::ZERO, |acc, v| acc + from_p3(v.point())) * (1.0 / b.solid.vertex_iter().count().max(1) as f64); let translation = |screw: usize| SCREWS.get(screw).map_or(Vec3::ZERO, |s| Vec3::new(s.0[0], s.0[1], s.0[2]) * (size * 2e-6)); let nudge = |screw: usize, sign: f64| { let axis = SCREWS.get(screw).map_or(Vec3::Z, |s| Vec3::new(s.1[0], s.1[1], s.1[2])); capture_boolean_diagnostics(|| { transform(b, translation(screw) * sign, c, axis, 2e-6 * sign).and_then(|nb| Ok(boolean(a, &nb, op)?.map(|r| nudged(r, &nb, &counts)))) }) }; let mut used = 0; let (mut r, mut diagnostics) = nudge(used, 1.0); // A nudge that pushes a face into a curved face it only touched (a cut whose end lies // tangent to a round side) leaves a sliver of that face behind, a fraction of a // millimetre wide, which later features (a shell, a fillet) can't work with. The // opposite nudge parts them instead. It is tried when this one failed or left more // slivers than the operands brought (a thin wall or a small round is no reason to run // another boolean), and taken when it works with fewer; an empty result stays as it is. let slivers = match &r { Ok(Some(body)) if check(body).0 => Some(sliver_faces(body, size)), _ => None, }; let made = slivers.is_none_or(|n| n > 0 && n > sliver_faces(a, size).saturating_add(sliver_faces(b, size))); if !matches!(r, Ok(None)) && made { let (r2, diagnostics2) = nudge(used, -1.0); if let Ok(Some(body)) = &r2 && slivers.is_none_or(|n| sliver_faces(body, size) < n) && check(body).0 { (r, diagnostics) = (r2, diagnostics2); } } // Neither way worked: the screw can turn the tool along a seam it lies in (a loft // standing in the rim of a shelled case with its ends in the wall's inner face, #1490). // The other screws are tried in turn, and the first result that checks is taken. let works = |r: &Result>| match r { Ok(None) => true, Ok(Some(body)) => check(body).0, Err(_) => false, }; if !works(&r) { 'screws: for screw in 1..SCREWS.len() { for sign in [1.0, -1.0] { let (r2, diagnostics2) = nudge(screw, sign); if matches!(&r2, Ok(Some(body)) if check(body).0) { (r, diagnostics, used) = (r2, diagnostics2, screw); break 'screws; } } } } let translation = translation(used); APART.with(|c| c.set(false)); match r { Ok(Some(body)) => { let (ok, v) = check(&body); // Measured finely too: a face the boolean left a hair wide, its loops a hair // apart, can mesh as its whole plane at a fine step though it meshed as a sliver // at the check's (#1360: an annulus cut flush with a hole's wall came out 21000 // mm³ larger than the part it was cut from, a square plane across it). let fine_ok = ok && crate::measure(&body).is_ok_and(|m| plausible(m.volume, op, va, vb, slack)); if ok && !fine_ok { last = format!("{last}; the nudged tool gave a solid whose faces mesh inconsistently"); } else if ok { merge(diagnostics); let mut event = BooleanFallback::new(BooleanStrategy::ToolNudge); event.translation_mm = translation.len(); event.rotation_rad = 2e-6; record(event); return Ok(Some(body)); } else { last = format!("{last}; the nudged tool gave an implausible volume {v:.4}"); } } Ok(None) => { merge(diagnostics); let mut event = BooleanFallback::new(BooleanStrategy::ToolNudge); event.translation_mm = translation.len(); event.rotation_rad = 2e-6; record(event); return Ok(None); } Err(e) => last = format!("{last}; nudged: {e}"), } } // A join whose coincident planar faces cannot be pushed apart because the neighbours of one of them curve (a flange // flush with the end of a lofted tube): the faces are grown instead, and what the growth leaves beyond the plane is cut // off by editing the faces. After every route above, the nudge included, has failed, so that a join any of them takes // stays as it was. if op == BoolOp::Union && !APART.with(|c| c.get()) { APART.with(|c| c.set(true)); let (r, diagnostics) = capture_boolean_diagnostics(|| crate::coplanar::boolean_grown(a, b, op)); APART.with(|c| c.set(false)); match r { Some(Ok(Some(body))) => { let (ok, v) = check(&body); if ok { merge(diagnostics); let mut event = BooleanFallback::new(BooleanStrategy::CoplanarSeparation); event.face_shift_mm = size * 0.0137; record(event); return Ok(Some(body)); } last = format!("{last}; faces grown apart gave an implausible volume {v:.4}"); } Some(Err(e)) => last = format!("{last}; {e}"), Some(Ok(None)) | None => {} } } // The tries at the meeting region's scale come last, after every strategy that answered // before them, so a result any of those gave is kept as it was. if let Some(body) = fine(&mut last) { return Ok(Some(body)); } // An intersection keeps what lies in both bodies: when the sampled answer keeps one of them // whole and is contradicted by facets that cross well past their faceting error, keeping it // would keep exactly what the intersection was asked to trim (#3244: teeth standing 0.27 mm // out of a trimming cylinder came back untrimmed). It fails instead, and the model is kept. // An empty answer stays reported as unverified: the clearance checks measure it another way. let deep = 2.0 * 3.0 * tol_m; if op == BoolOp::Intersect && matches!(doubted, Some(Some(_))) && let (Some(ma), Some(mb)) = &meshes && ma.crosses(mb, deep) { return Err(KernelError::Failed(format!( "boolean {op:?}: the bodies pass through each other by more than {deep:.3e} mm where they could not be intersected; {last}" ))); } match doubted { Some(r) => { let mut event = BooleanFallback::new(BooleanStrategy::UnverifiedShortcut); event.tolerance_mm = 3.0 * tol_m; record(event); Ok(r) } None => Err(KernelError::Failed(format!("boolean {op:?}: {last}"))), } } /// `a` cut by `b` with the walls of `b` that only touch `a` pushed outward (see /// [`crate::touching_walls`]), at each of the general boolean's tolerances by a little more than /// it (at least `by`, past the sag of `target`, the mesh of `a`): the first result that checks /// and whose faces lie on none of the pushed walls. The pushed tool keeps `b`'s order, so the /// history holds for `b`. #[allow(clippy::too_many_arguments)] fn pushed_walls_cut( a: &Body, b: &Body, target: &solidcraft_geom::Mesh, by: f64, size: f64, keep: &[Vec], counts: &[(usize, usize)], check: &dyn Fn(&Body) -> (bool, f64), ) -> Option { let inside = target.inside_index(); for k in [2e-3, 5e-4] { // Pushed past what the boolean takes for touching, and past the mesh's sag. let tol = (size * k).max(1e-5); let Some(pushed) = crate::touching_walls::pushed_tool(b, &inside, (2.5 * tol).max(by)) else { continue }; let Ok((s, h)) = truck_boolean(a, &pushed.tool, BoolOp::Cut, None, tol) else { continue }; if s.boundaries().is_empty() || s.face_iter().next().is_none() { continue; } let Ok(body) = guard("boolean result", || recorded::truck_result(s, h, size, keep, counts)) else { continue }; if pushed.untouched(&body) && check(&body).0 { return Some(body); } } None } /// The screw motions a tool is nudged by as a last resort: (direction of the move, axis of the /// turn), each tried both ways. The first is the one every nudge used before #1490; the others /// are asked only when it fails both ways. const SCREWS: [([f64; 3], [f64; 3]); 3] = [([0.61, -0.37, 0.71], [0.27, 0.83, -0.49]), ([-0.42, 0.68, 0.6], [0.77, -0.18, 0.61]), ([0.31, 0.52, -0.79], [-0.58, 0.41, 0.70])]; /// Faces of `b` narrower than 1/200 of `size` (twice their area over their boundary's /// length): the slivers a nudged tool leaves where it was pushed into a face it touched. fn sliver_faces(b: &Body, size: f64) -> usize { use std::collections::HashMap; let Ok(m) = b.tessellate((size * 1e-3).max(1e-4)) else { return usize::MAX }; let q = (size * 1e-7).max(1e-12); let key = |p: Vec3| ((p.x / q).round() as i64, (p.y / q).round() as i64, (p.z / q).round() as i64); // Per face: its area, and how many of its triangles use each mesh edge (its boundary once). let mut area: HashMap = HashMap::new(); let mut sides: HashMap<(u32, (i64, i64, i64), (i64, i64, i64)), (u32, f64)> = HashMap::new(); for (t, f) in m.triangles.iter().zip(&m.tri_face) { let Some([a, b, c]) = m.tri(t) else { continue }; *area.entry(*f).or_default() += (b - a).cross(c - a).len() * 0.5; for (p, r) in [(a, b), (b, c), (c, a)] { let (kp, kr) = (key(p), key(r)); let k = if kp <= kr { (*f, kp, kr) } else { (*f, kr, kp) }; sides.entry(k).or_insert((0, p.dist(r))).0 += 1; } } let mut boundary: HashMap = HashMap::new(); for ((f, _, _), (n, len)) in &sides { if *n == 1 { *boundary.entry(*f).or_default() += len; } } area.iter().filter(|(f, a)| boundary.get(f).is_some_and(|l| *l > 0.0 && 2.0 * **a / l < size * 5e-3)).count() } /// `r`, a boolean of the target and `nb` (the tool nudged), with its history over the target and /// the tool itself (the nudge keeps every face and edge). pub(crate) fn nudged(r: Body, nb: &Body, counts: &[(usize, usize)]) -> Body { let h = recorded::through(&r, 1, nb.history()); r.with_checked_history(h, counts) } /// What truck's boolean makes of `a` and `b`: the solid, and its history in our terms (see /// [`recorded::shapeops`]). On copies of the operands moved by `shift` (when given; the result /// is moved back), which changes the rays the boolean classifies faces by. Copies (and moved /// copies) keep the operands' face and edge order, and so does moving the result back, so the /// history truck records holds for the operands themselves. pub(crate) fn truck_boolean(a: &Body, b: &Body, op: BoolOp, shift: Option, tol: f64) -> Result<(Solid, Option)> { if !take_attempt() { return Err(KernelError::Failed("no result in the tries it was given".into())); } guard("boolean", || { let (mut sa, mut sb) = (a.deep_copy(), b.deep_copy()); if let Some(shift) = shift { sa = mt::builder::translated(&sa, shift); sb = mt::builder::translated(&sb, shift); } let tool_edges = (op == BoolOp::Cut).then(|| record::edge_origins(&sb, 1)); // A body that keeps its meshes is meshed once for all its booleans at this tolerance. let meshed = shift.is_none().then(|| a.boolean_meshes(tol)).flatten(); let and = |sa: &Solid, sb: &Solid| match &meshed { Some(m) => truck_shapeops::and_with_history_meshed(sa, m, sb, tol), None => truck_shapeops::and_with_history(sa, sb, tol), }; let res = match op { BoolOp::Union => truck_shapeops::or_with_history(&sa, &sb, tol), BoolOp::Cut => { sb.not(); and(&sa, &sb) } BoolOp::Intersect => and(&sa, &sb), }; let (s, h) = res.ok_or_else(|| KernelError::Failed("no result".into()))?; let h = h.and_then(|h| recorded::shapeops(&h, &sb, tool_edges.as_ref())); Ok((if let Some(shift) = shift { mt::builder::translated(&s, -shift) } else { s }, h)) }) } /// A boolean of `a` and `b` given as their pieces (`la`, `lb`); the result's pieces in one body. pub(crate) fn by_lumps(a: &Body, b: &Body, la: Vec, lb: Vec, op: BoolOp) -> Result> { let boxes_meet = |x: &Body, y: &Body| -> bool { let (Ok(mx), Ok(my)) = (x.tessellate(x.size() * 0.05 + 1e-3), y.tessellate(y.size() * 0.05 + 1e-3)) else { return true }; let (bx, by) = (mx.bounds(), my.bounds()); let g = (x.size() + y.size()) * 0.01; bx.min.x <= by.max.x + g && by.min.x <= bx.max.x + g && bx.min.y <= by.max.y + g && by.min.y <= bx.max.y + g && bx.min.z <= by.max.z + g && by.min.z <= bx.max.z + g }; // Each piece with its history over [a, b] (a piece's faces and edges are its body's own). let traced = |pieces: Vec, whole: &Body, operand: usize| -> Vec { let histories = recorded::parts_of(&pieces, whole); pieces.into_iter().zip(histories).map(|(p, h)| (p, recorded::placed(h, operand, 2))).collect() }; let (la, lb) = (traced(la, a, 0), traced(lb, b, 1)); let pair = |(x, hx): &Traced, (y, hy): &Traced, op: BoolOp| -> Result> { Ok(boolean(x, y, op)?.map(|r| { let h = recorded::of_pair(&r, hx, hy); (r, h) })) }; let mut out: Vec = Vec::new(); match op { BoolOp::Cut => { for x in la { let mut cur = Some(x); for y in &lb { cur = match cur { Some(c) if boxes_meet(&c.0, &y.0) => pair(&c, y, BoolOp::Cut)?, other => other, }; } out.extend(cur); } } BoolOp::Intersect => { for x in &la { for y in &lb { if boxes_meet(&x.0, &y.0) && let Some(r) = pair(x, y, BoolOp::Intersect)? { out.push(r); } } } } BoolOp::Union => { out = la; for y in lb { let mut cur = y; let mut rest = Vec::new(); for x in out { if boxes_meet(&x.0, &cur.0) { match pair(&x, &cur, BoolOp::Union)? { Some(u) if u.0.solid.boundaries().len() == 1 => cur = u, _ => rest.push(x), } } else { rest.push(x); } } rest.push(cur); out = rest; } } } recorded::join(out, &record::counts(&[a, b])) } /// Bodies whose bounding boxes are clearly apart, as one body of several pieces, without any /// intersection work (many identical pattern tools, #261). `None` when any two may meet, or a /// body is a mesh: the caller unions those the usual way. pub fn union_apart(bodies: &[Body]) -> Result> { crate::profile::timed(crate::profile::Kind::Boolean, || union_apart_untimed(bodies)) } fn union_apart_untimed(bodies: &[Body]) -> Result> { if bodies.len() < 2 || bodies.len() > 10_000 || bodies.iter().any(Body::is_mesh) { return Ok(None); } let mut boxes = Vec::with_capacity(bodies.len()); for b in bodies { // A coarse mesh is enough: the chord tolerance bounds how far the true surface lies // outside it, and the box grows by twice that. let tol = (b.size() * 0.02).max(1e-3); let bb = b.tessellate(tol)?.bounds(); if bb.is_empty() { return Ok(None); } boxes.push(bb.inflated(2.0 * tol)); } // Sweep along x: only boxes whose x ranges overlap are compared. let mut order: Vec = (0..boxes.len()).collect(); order.sort_by(|&i, &j| boxes.get(i).map(|b| b.min.x).unwrap_or(0.0).total_cmp(&boxes.get(j).map(|b| b.min.x).unwrap_or(0.0))); for (k, &i) in order.iter().enumerate() { let Some(a) = boxes.get(i) else { continue }; for &j in order.iter().skip(k + 1) { let Some(b) = boxes.get(j) else { continue }; if b.min.x > a.max.x { break; } if a.min.y <= b.max.y && b.min.y <= a.max.y && a.min.z <= b.max.z && b.min.z <= a.max.z { return Ok(None); } } } join_apart(bodies) } /// Bodies the caller knows are apart (no two meet or touch), as one body of several pieces, /// without any intersection work: [`union_apart`] without its check, for tools whose making /// shows they are apart (profiles apart in their sketch, extruded alike). `None` for fewer than /// two bodies or a mesh. pub fn join_apart(bodies: &[Body]) -> Result> { crate::profile::timed(crate::profile::Kind::Boolean, || join_apart_untimed(bodies)) } fn join_apart_untimed(bodies: &[Body]) -> Result> { if bodies.len() < 2 || bodies.len() > 10_000 || bodies.iter().any(Body::is_mesh) { return Ok(None); } // The pieces stay as they are, side by side: each face and edge of the result is its piece's // own (the history over `bodies`). let Some(joined) = join_pieces(bodies.to_vec())? else { return Ok(None) }; let operands: Vec<&Body> = bodies.iter().collect(); let faces = bodies .iter() .enumerate() .flat_map(|(operand, b)| { (0..b.face_count()).map(move |face| (std::collections::BTreeSet::from([crate::history::FaceOrigin::Face { operand, face }]), true)) }) .collect(); let mut edges = HashMap::new(); for (operand, b) in bodies.iter().enumerate() { edges.extend(record::edge_origins(&b.solid, operand)); } Ok(Some(record::traced(joined, &record::counts(&operands), Some(record::regions(faces)), Some(&edges)))) } /// Bodies (apart from each other) as one body of several pieces. pub(crate) fn join_pieces(pieces: Vec) -> Result> { match pieces.len() { 0 => Ok(None), 1 => Ok(pieces.into_iter().next()), _ => { let shells: Vec = pieces.iter().flat_map(|p| p.solid.boundaries().clone()).collect(); let solid = guard("pieces", || Solid::try_new(shells).map_err(|e| KernelError::Failed(e.to_string())))?; let protected = pieces.iter().any(|piece| piece.regularization_protected); Body::new(solid).map(|mut body| { body.regularization_protected = protected; Some(body) }) } } } /// Determinant of the linear part of a column-major 4x4 matrix: negative means the placement /// mirrors, which turns a solid inside out. fn det3(m: &[[f64; 4]; 4]) -> f64 { m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]) } /// Whether the linear part is a rigid motion (rotation or reflection: no scale or shear). pub(crate) fn rigid_placement(m: &[[f64; 4]; 4]) -> bool { let r = [Vec3::new(m[0][0], m[0][1], m[0][2]), Vec3::new(m[1][0], m[1][1], m[1][2]), Vec3::new(m[2][0], m[2][1], m[2][2])]; (0..3).all(|i| (r[i].dot(r[i]) - 1.0).abs() < 1e-9) && r[0].dot(r[1]).abs() < 1e-9 && r[0].dot(r[2]).abs() < 1e-9 && r[1].dot(r[2]).abs() < 1e-9 } /// Affine transform by a column-major 4x4 matrix (rotations, translations, reflections). pub fn transform_matrix(body: &Body, m: [[f64; 4]; 4]) -> Result { transform_matrix_keeping(body, m, false) } /// [`transform_matrix`] for showing a body where an assembly places it (world placement): the /// revolved faces stay turned the way the body has them instead of being searched again for /// every placed copy (#3044). A modelling operation keeps using [`transform_matrix`]: where a /// face wraps all the way round, the turn it finds depends on the copy's own coordinates, and /// booleans on the copy depend on that. pub fn place_matrix(body: &Body, m: [[f64; 4]; 4]) -> Result { transform_matrix_keeping(body, m, body.phased) } fn transform_matrix_keeping(body: &Body, m: [[f64; 4]; 4], phased: bool) -> Result { if m.iter().flatten().any(|x| !x.is_finite()) { return Err(KernelError::Invalid("non-finite transform".into())); } // A perspective row or a flattening (from a design file or a command's parameters) leaves // no solid: refused rather than built into faces that mesh to nonsense. let scale = (0..3).map(|c| Vec3::new(m[c][0], m[c][1], m[c][2]).len()).fold(0.0, f64::max); if m[0][3].abs() > 1e-12 || m[1][3].abs() > 1e-12 || m[2][3].abs() > 1e-12 || (m[3][3] - 1.0).abs() > 1e-12 { return Err(KernelError::Invalid("the transform is not affine: its last row must be 0, 0, 0, 1".into())); } if det3(&m).abs() <= 1e-12 * scale.powi(3) { return Err(KernelError::Invalid("the transform flattens the body: its linear part is singular".into())); } if let Some(placed) = body.mesh_transformed(&m) { let history = crate::history::History::identity(&placed); return placed.with_history(history, &[body]); } guard("transform", || { let mat = mt::Matrix4::new( m[0][0], m[0][1], m[0][2], m[0][3], m[1][0], m[1][1], m[1][2], m[1][3], m[2][0], m[2][1], m[2][2], m[2][3], m[3][0], m[3][1], m[3][2], m[3][3], ); // An affine placement retains face order and appearance metadata. Its edges are the // body's by identity: a reflection turns the solid inside out, which walks each face's // edges the other way and so changes the edge order. let sources = body.transformed_sources(m)?; let (solid, copies) = placed_topology_mapped(&body.solid, mat)?; let mut rec = record::Rebuild::default(); rec.pieces(&copies); for (copy, face) in solid.face_iter().zip(body.solid.face_iter()) { rec.whole(copy, face); } let (faces, edges) = rec.history(&solid, &[&body.solid]).unzip(); let counts = record::solid_counts(&[&body.solid]); // A rigid placement leaves every face's mesh, and so the missing-face count, as it was; // a mirrored one turns the solid inside out. Either way the orientation is read from the // matrix instead of meshing the whole copy again. let placed = record::build_placed( solid, &counts, faces, edges.as_ref(), det3(&m) < 0.0, rigid_placement(&m).then_some(body.coarse_missing).flatten(), phased, )?; Ok(placed.with_color(body.color()).with_paint(body.paint().cloned()).with_face_sources(sources).inherit_regularization_protection(body)) }) } /// `source` moved by `matrix`, keeping its face and edge order (transforms report an identity /// [`crate::history::History`] on that basis). Built here rather than by generic topology /// builders: a STEP periodic face may traverse a seam edge twice, and those reject that wire /// while cloning even though placement preserves its topology. pub(crate) fn placed_topology(source: &Solid, matrix: mt::Matrix4) -> Result { placed_topology_mapped(source, matrix).map(|(solid, _)| solid) } /// [`placed_topology`], with each edge of `source` (by identity) and its copy. fn placed_topology_mapped(source: &Solid, matrix: mt::Matrix4) -> Result<(Solid, HashMap)> { use mt::{Transform, Transformed}; let mut vertices = HashMap::new(); let mut edges = HashMap::new(); let mut shells = Vec::new(); let mut face_count = 0usize; let mut edge_visits = 0usize; for shell in source.boundaries() { let mut faces = Vec::new(); for face in shell { face_count = face_count.saturating_add(1); if face_count > 500_000 { return Err(KernelError::Invalid("placement exceeds face work limit".into())); } let mut wires = Vec::new(); for wire in face.absolute_boundaries() { let mut mapped = Vec::new(); for edge in wire { edge_visits = edge_visits.saturating_add(1); if edge_visits > 4_000_000 { return Err(KernelError::Invalid("placement exceeds edge work limit".into())); } if let std::collections::hash_map::Entry::Vacant(entry) = edges.entry(edge.id()) { for vertex in [edge.absolute_front(), edge.absolute_back()] { if let std::collections::hash_map::Entry::Vacant(entry) = vertices.entry(vertex.id()) { let point = matrix.transform_point(vertex.point()); if !from_p3(point).is_finite() { return Err(KernelError::Invalid("placement produced nonfinite geometry".into())); } entry.insert(mt::Vertex::new(point)); } } let front = vertices.get(&edge.absolute_front().id()).ok_or_else(|| KernelError::Failed("placement vertex missing".into()))?; let back = vertices.get(&edge.absolute_back().id()).ok_or_else(|| KernelError::Failed("placement vertex missing".into()))?; entry.insert(mt::Edge::new_unchecked(front, back, edge.curve().transformed(matrix))); } let copied = edges.get(&edge.id()).ok_or_else(|| KernelError::Failed("placement edge missing".into()))?; mapped.push(if edge.orientation() { copied.clone() } else { copied.inverse() }); } wires.push(mt::Wire::from(mapped)); } // Wire connectivity, seam sharing and orientation are copied exactly; // no new topology is introduced by this geometry-only operation. let mut copied = mt::Face::new_unchecked(wires, face.surface().transformed(matrix)); if !face.orientation() { copied.invert(); } faces.push(copied); } shells.push(mt::Shell::from(faces)); } Ok((Solid::new_unchecked(shells), edges)) } #[cfg(test)] #[test] fn affine_placement_keeps_body_and_face_paint_attached() { let paint = crate::Paint { opacity: 0.4, faces: vec![crate::FacePaint { face: 0, color: [0.8, 0.2, 0.1], opacity: 0.3 }] }; let body = crate::box_solid(Vec3::ZERO, Vec3::new(10.0, 20.0, 30.0)).unwrap().with_color(Some([0.2, 0.6, 0.8])).with_paint(Some(paint.clone())); let source_faces = body.faces(0.01).unwrap(); let transform = [[0.0, 2.0, 0.0, 0.0], [-1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.5, 0.0], [30.0, 40.0, 50.0, 1.0]]; let placed = transform_matrix(&body, transform).unwrap(); assert_eq!(placed.color(), body.color()); assert_eq!(placed.paint(), Some(&paint)); let faces = placed.faces(0.01).unwrap(); for source in source_faces { let target = faces.iter().find(|f| f.index == source.index).unwrap(); let p = source.centroid; assert!(target.centroid.dist(Vec3::new(30.0 - p.y, 40.0 + 2.0 * p.x, 50.0 + 0.5 * p.z)) < 1e-6); } } /// Rigid transform: rotate about `axis` through `origin` by `angle` radians, then translate. pub fn transform(body: &Body, translate: Vec3, origin: Vec3, axis: Vec3, angle: f64) -> Result { if !(translate.is_finite() && origin.is_finite() && angle.is_finite()) { return Err(KernelError::Invalid("non-finite transform".into())); } { // Same motion as a matrix: rotate about the line through `origin`, then translate. let ax = if angle.abs() > 1e-12 { axis.normalized().ok_or_else(|| KernelError::Invalid("rotation axis".into()))? } else { Vec3::Z }; let (c, s) = (angle.cos(), angle.sin()); let t = 1.0 - c; let r = [ [t * ax.x * ax.x + c, t * ax.x * ax.y + s * ax.z, t * ax.x * ax.z - s * ax.y], [t * ax.x * ax.y - s * ax.z, t * ax.y * ax.y + c, t * ax.y * ax.z + s * ax.x], [t * ax.x * ax.z + s * ax.y, t * ax.y * ax.z - s * ax.x, t * ax.z * ax.z + c], ]; let ro = Vec3::new( r[0][0] * origin.x + r[1][0] * origin.y + r[2][0] * origin.z, r[0][1] * origin.x + r[1][1] * origin.y + r[2][1] * origin.z, r[0][2] * origin.x + r[1][2] * origin.y + r[2][2] * origin.z, ); let tr = origin - ro + translate; let m = [[r[0][0], r[0][1], r[0][2], 0.0], [r[1][0], r[1][1], r[1][2], 0.0], [r[2][0], r[2][1], r[2][2], 0.0], [tr.x, tr.y, tr.z, 1.0]]; transform_matrix(body, m) } } /// Split a body with a plane: the parts on the positive and the negative side of the plane /// (only the non-empty ones). pub fn split_by_plane(body: &Body, plane: &solidcraft_geom::Plane) -> Result> { let mut out = Vec::new(); for positive in [true, false] { out.extend(half_space(body, plane, positive)?.0); } Ok(out) } /// The part of a body on one side of a plane (`None` when nothing is there), and the tool it is /// cut with: the part is the body's intersection with [`half_box`] (the tool), whose history it /// carries, over the body and the box. The box's face in the plane, the part's cut face, is its /// start cap on the positive side and its end cap on the negative side. pub fn half_space(body: &Body, plane: &solidcraft_geom::Plane, positive: bool) -> Result<(Option, Body)> { // The box's own construction roles describe no face of the design: the cut face has none. let tool = half_box(body, plane, positive)?.with_face_sources(None); let (part, report) = capture_boolean_diagnostics(|| boolean(body, &tool, BoolOp::Intersect)); // Faces of the body lying in the plane coincide with the box's cap, which the boolean may // only take by nudging the box, by a share of its own size: the cut face then moves off the // plane, a different way for each part, and the parts lose the slab between (#1510). Moved // off the plane to the side the box leaves out, those faces change nothing of the part, and // the cap meets no face. Asked only when the boolean failed or nudged the box: a part made // without, its faces' names included, stays as it is. let nudged = report.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge); if (part.is_err() || nudged) && let Some(moved) = off_plane(body, plane, positive) { let (exact, moved_report) = capture_boolean_diagnostics(|| boolean(&moved, &tool, BoolOp::Intersect)); if let Ok(exact) = exact { merge(moved_report); // The part's history over [body, box], through the moved body (its faces are the body's). let hb = recorded::placed(recorded::through(&moved, 0, recorded::kept(body, 0, 1).as_ref()), 0, 2); let ht = recorded::placed(recorded::kept(&tool, 0, 1), 1, 2); let counts = record::counts(&[body, &tool]); let exact = exact.map(|r| { let h = recorded::of_pair(&r, &hb, &ht); r.with_checked_history(h, &counts) }); return Ok((exact, tool)); } } merge(report); Ok((part?, tool)) } /// `body` with its planar faces lying in `plane` moved off it, a thousandth of the body's size, /// to the side a split's part on the `positive` side leaves out. `None` when no face lies there /// or moving them doesn't give a sound body. pub(crate) fn off_plane(body: &Body, plane: &solidcraft_geom::Plane, positive: bool) -> Option { let m = plane.normal().normalized()?; let keep = if positive { m } else { -m }; let size = body.size(); let tol = (size * 1e-7).max(1e-9); // Lying in the plane means in it, not within the boolean's tolerance of it: a face that close // but off it bounds a real sliver, which moving the face would take or add. let exact = (size * 1e-9).max(1e-12); let delta = size * 1e-3; let mut out: Option = None; for n in [keep, -keep] { let d = n.dot(plane.origin); // The faces `push_faces` takes for this plane (by their surface), which must all lie in // it: one only nearly parallel, its origin in the plane, would be moved where it isn't. let taken: Vec<&mt::Face> = body .solid .face_iter() .filter(|f| match f.oriented_surface() { mt::Surface::Plane(p) => { let q = p.normal(); Vec3::new(q.x, q.y, q.z).normalized().is_some_and(|q| q.dot(n) > 1.0 - 1e-9) && (n.dot(from_p3(p.origin())) - d).abs() < tol * 10.0 } _ => false, }) .collect(); if taken.is_empty() { continue; } // Its vertices and points along its edges (a disc has one vertex). let lies = |f: &mt::Face| { use mt::{BoundedCurve, ParametricCurve}; let on = |p: mt::Point3| (n.dot(from_p3(p)) - d).abs() < exact; f.vertex_iter().all(|v| on(v.point())) && f.edge_iter().all(|e| { let c = e.curve(); let (t0, t1) = c.range_tuple(); [0.25, 0.5, 0.75].iter().all(|k| on(c.subs(t0 + (t1 - t0) * k))) }) }; if !taken.iter().all(|f| lies(f)) { return None; } // Along -keep: inwards for a face facing the kept side, outwards for one facing away. let shift = if n.dot(keep) > 0.0 { -delta } else { delta }; let cur = out.as_ref().unwrap_or(body); out = Some(crate::coplanar::push_faces(cur, n, d, shift).ok().filter(|b| b.validity().is_empty())?); } out } /// A box covering everything of `body` on one side of a plane, its start cap in the plane. pub(crate) fn half_box(body: &Body, plane: &solidcraft_geom::Plane, positive: bool) -> Result { body.require_brep("split")?; let size = body.size(); let mut bb = solidcraft_geom::Aabb3::EMPTY; for v in body.solid.vertex_iter() { bb.add(crate::body::from_p3(v.point())); } let reach = (bb.diagonal() + plane.origin.dist(bb.center())) * 2.0 + size; let c = plane.to_local(bb.center()); let sq = solidcraft_geom::Region2 { outer: solidcraft_geom::Loop2::polygon(&[ solidcraft_geom::Vec2::new(c.x - reach, c.y - reach), solidcraft_geom::Vec2::new(c.x + reach, c.y - reach), solidcraft_geom::Vec2::new(c.x + reach, c.y + reach), solidcraft_geom::Vec2::new(c.x - reach, c.y + reach), ]), holes: vec![], }; let (lo, hi) = if positive { (0.0, reach) } else { (-reach, 0.0) }; crate::build::extrude(plane, std::slice::from_ref(&sq), lo, hi)?.pop().ok_or_else(|| KernelError::Failed("half space".into())) } #[cfg(test)] #[path = "empty_retry_tests.rs"] mod empty_retry_tests; #[cfg(test)] #[path = "prism_fast_path_tests.rs"] mod prism_fast_path_tests; #[cfg(test)] #[path = "placement_tests.rs"] mod placement_tests;