A spherical shell revolves into a solid with a void, and cuts and joins with hollow tools work (#451) (#4182)
This commit is contained in:
@@ -1298,3 +1298,51 @@ fn intersect_with_every_body_still_drops_the_ones_it_misses() -> crate::Result<(
|
||||
assert!((volume(&s, "Near") - 500.0).abs() < 1e-6);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// #451: a spherical shell (r 18.5 to 40, revolved on XY) cut from a block, or joined with it.
|
||||
/// Swept with its two radial lines, the shell had zero-area faces on the axis joining the outer
|
||||
/// sphere to the inner one, and a cut through the inner sphere's pole failed. As a solid with a
|
||||
/// void, the boolean took its shells one at a time: a cut through both spheres kept only the piece
|
||||
/// in the hollow, and a join failed.
|
||||
#[test]
|
||||
fn spherical_shell_cuts_and_joins_a_block_crossing_its_hollow() {
|
||||
let r: f64 = 18.5;
|
||||
// ∫∫ √(R² − y² − z²) dy dz over the blocks' 8 × 8 section, the inner integral in closed form,
|
||||
// the outer by Simpson's rule.
|
||||
let under = |big: f64| {
|
||||
let inner = |y: f64| {
|
||||
let a2 = big * big - y * y;
|
||||
let f = |z: f64| 0.5 * (z * (a2 - z * z).sqrt() + a2 * (z / a2.sqrt()).asin());
|
||||
f(4.0) - f(-4.0)
|
||||
};
|
||||
let n = 200;
|
||||
let h = 8.0 / n as f64;
|
||||
(0..n / 2).map(|i| -4.0 + 2.0 * i as f64 * h).map(|y| inner(y) + 4.0 * inner(y + h) + inner(y + 2.0 * h)).sum::<f64>() * h / 3.0
|
||||
};
|
||||
// From x = 8 to the inner sphere, and from the outer sphere to x = 50.
|
||||
let (hollow, beyond) = (under(r) - 8.0 * 64.0, 50.0 * 64.0 - under(40.0));
|
||||
let shell = 4.0 / 3.0 * std::f64::consts::PI * (40.0f64.powi(3) - r.powi(3));
|
||||
for (x0, length, operation, want) in [
|
||||
(-4.0, 8.0, "cut", 512.0),
|
||||
(8.0, 12.0, "cut", hollow),
|
||||
(8.0, 42.0, "cut", hollow + beyond),
|
||||
(8.0, 12.0, "join", shell + hollow),
|
||||
(8.0, 42.0, "join", shell + hollow + beyond),
|
||||
] {
|
||||
let mut s = Session::default();
|
||||
let mut run = |c: &str, p: Value| s.execute(c, &p).unwrap();
|
||||
run("solid.box", json!({"corner": [x0, -4, -4], "length": length, "width": 8, "height": 8, "body_name": "Block"}));
|
||||
run("sketch.create", json!({"plane": "XY", "name": "Ring"}));
|
||||
run("sketch.line", json!({"points": [[-40, 0], [40, 0]]}));
|
||||
run("sketch.arc.center_point", json!({"center": [0, 0], "start": [40, 0], "end": [-40, 0]}));
|
||||
run("sketch.arc.center_point", json!({"center": [0, 0], "start": [r, 0], "end": [-r, 0]}));
|
||||
run("sketch.finish", json!({}));
|
||||
run("solid.revolve", json!({"sketch": "Ring", "profiles": [{"point": [0, 30]}], "axis": "l1", "operation": operation, "targets": ["Block"]}));
|
||||
// A cut through both spheres leaves two pieces, one each side of the shell.
|
||||
let state = s.model.state();
|
||||
let got: f64 = state.bodies.iter().map(|b| solidcraft_kernel::measure(&b.body).unwrap().volume).sum();
|
||||
println!("#451 {operation} of the block from x = {x0} to {}: {got:.6} mm³ in {} bodies, expected {want:.6}", x0 + length, state.bodies.len());
|
||||
assert!((got - want).abs() < 1e-4 * want, "{operation} from x = {x0} to {}: {got} vs {want}", x0 + length);
|
||||
assert!(state.bodies.iter().all(|b| b.body.validity().is_empty()));
|
||||
}
|
||||
}
|
||||
|
||||
+31
-20
@@ -562,6 +562,36 @@ pub(crate) fn shell_volume(shell: &mt::Shell) -> Option<f64> {
|
||||
v.is_finite().then_some(v)
|
||||
}
|
||||
|
||||
/// A solid's volume off a mesh at `tol`, negative when it faces inwards, and how many faces that
|
||||
/// mesh left out.
|
||||
fn signed_volume(solid: &Solid, tol: f64) -> Result<(f64, usize)> {
|
||||
let orient = |tol: f64| {
|
||||
guard("orient", || {
|
||||
let shells = mesh_shells(solid, tol);
|
||||
let volume = shells.iter().map(|s| s.to_polygon().volume()).sum::<f64>();
|
||||
let missing =
|
||||
shells.iter().flat_map(|s| s.face_iter()).filter(|f| f.surface().is_none_or(|m| m.faces().triangle_iter().next().is_none())).count();
|
||||
Ok((volume, missing))
|
||||
})
|
||||
};
|
||||
let (mut v, missing) = orient(tol)?;
|
||||
// A long thin round part (a through hole's tool: a cylinder whose vertices all lie on
|
||||
// its seam, so they span its length only) meshed that coarsely can come out with a
|
||||
// negative volume when it is outward already: check finely before turning it inside out.
|
||||
let fine = (tol * 0.02).max(1e-4);
|
||||
if v < 0.0 && fine < tol {
|
||||
(v, _) = orient(fine)?;
|
||||
}
|
||||
Ok((v, missing))
|
||||
}
|
||||
|
||||
/// Whether a closed shell faces inwards (a void), by the check [`Body::new`] orients a solid by.
|
||||
/// Unlike [`shell_volume`], a negative coarse volume is checked again on a finer mesh.
|
||||
pub(crate) fn faces_inward(shell: &mt::Shell) -> Result<bool> {
|
||||
let solid = guard("shell", || Solid::try_new(vec![shell.clone()]).map_err(|e| KernelError::Failed(format!("shell: {e}"))))?;
|
||||
Ok(signed_volume(&solid, orientation_tolerance(span_of(&solid)))?.0 < 0.0)
|
||||
}
|
||||
|
||||
/// Deflection the orientation mesh uses: coarse enough for a large solid, fine enough that a
|
||||
/// small one still tessellates. `unmeshed_faces` counts at the same value, so the count the
|
||||
/// orientation mesh produced is reused instead of meshing the body again.
|
||||
@@ -616,30 +646,11 @@ impl Body {
|
||||
// every face comes out: a face missing from a coarse mesh can flip the sign).
|
||||
let span = span_of(&solid);
|
||||
let tol = orientation_tolerance(span);
|
||||
let orient = |tol: f64| {
|
||||
guard("orient", || {
|
||||
let shells = mesh_shells(&solid, tol);
|
||||
let volume = shells.iter().map(|s| s.to_polygon().volume()).sum::<f64>();
|
||||
let missing = shells
|
||||
.iter()
|
||||
.flat_map(|s| s.face_iter())
|
||||
.filter(|f| f.surface().is_none_or(|m| m.faces().triangle_iter().next().is_none()))
|
||||
.count();
|
||||
Ok((volume, missing))
|
||||
})
|
||||
};
|
||||
#[cfg(test)]
|
||||
ORIENTED.with(|n| n.set(n.get() + 1));
|
||||
// The faces missing from the coarse mesh are the same whichever way the solid turns out
|
||||
// to face, so the count is kept for `unmeshed_faces` either way.
|
||||
let (mut v, missing) = orient(tol)?;
|
||||
// A long thin round part (a through hole's tool: a cylinder whose vertices all lie on
|
||||
// its seam, so they span its length only) meshed that coarsely can come out with a
|
||||
// negative volume when it is outward already: check finely before turning it inside out.
|
||||
let fine = (tol * 0.02).max(1e-4);
|
||||
if v < 0.0 && fine < tol {
|
||||
(v, _) = orient(fine)?;
|
||||
}
|
||||
let (v, missing) = signed_volume(&solid, tol)?;
|
||||
if v < 0.0 {
|
||||
solid.not();
|
||||
}
|
||||
|
||||
+62
-32
@@ -434,40 +434,9 @@ fn revolved(plane: &Plane, regions: &[Region2], axis_origin: Vec2, axis_dir: Vec
|
||||
};
|
||||
let given = numbered_region(r)?.map_loops(|l| reseam(snap_loop(l).merged_lines(axis_run)));
|
||||
let r = &given.region();
|
||||
// A half disc on the axis revolved fully is a sphere: build it without poles. Every
|
||||
// patch is swept from the half disc's arcs.
|
||||
if angle.abs() >= std::f64::consts::TAU - 1e-9
|
||||
&& r.holes.is_empty()
|
||||
&& let Some((c, rad)) = half_disc(&r.outer, axis_origin, d)
|
||||
{
|
||||
let arcs: Vec<usize> = r
|
||||
.outer
|
||||
.segs
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter(|(_, s)| matches!(s, Seg2::Arc { .. }))
|
||||
.flat_map(|(i, _)| given.outer.numbers(i).to_vec())
|
||||
.collect();
|
||||
out.push(sphere_solid(plane.to_world(c), rad, [Vec3::X, Vec3::Y, Vec3::Z], &arcs)?);
|
||||
continue;
|
||||
}
|
||||
// A full turn of a profile that comes back to the axis along a curve (a half slot about
|
||||
// its centreline, a dome at the far end): truck's cone gives the faces
|
||||
// swept from it the wrong region (their pole is at the end of their curve), and cuts with
|
||||
// such a body failed (#1853). It is built as part turns are, a third of a turn at a time.
|
||||
if angle.abs() >= std::f64::consts::TAU - 1e-9
|
||||
&& r.holes.is_empty()
|
||||
&& pole_at_end(&r.outer, axis_origin, d)
|
||||
&& let Some(b) = revolve_on_axis(plane, &given.outer, axis_origin, d, angle)?
|
||||
{
|
||||
out.push(b);
|
||||
continue;
|
||||
}
|
||||
// A full revolution of a profile with one edge on the axis: sweep the rest of the loop
|
||||
// as a cone-like shell (no zero-area faces, which booleans can't handle).
|
||||
if angle.abs() >= std::f64::consts::TAU - 1e-9
|
||||
&& r.holes.is_empty()
|
||||
&& let Some(b) = revolve_touching_axis(plane, &given.outer, axis_origin, d)?
|
||||
&& let Some(b) = full_turn_on_axis(plane, &given.outer, axis_origin, d, angle)?
|
||||
{
|
||||
out.push(b);
|
||||
continue;
|
||||
@@ -1407,6 +1376,67 @@ fn half_disc(lp: &Loop2, axis_origin: Vec2, d: Vec2) -> Option<(Vec2, f64)> {
|
||||
(same && (total - std::f64::consts::PI).abs() < 1e-6).then_some((c, r))
|
||||
}
|
||||
|
||||
/// A full turn of a loop with edges on the axis, built without the zero-area faces truck sweeps
|
||||
/// from them (booleans can't handle those). `None` when no builder here takes the loop.
|
||||
fn full_turn_on_axis(plane: &Plane, nl: &NumberedLoop, axis_origin: Vec2, d: Vec2, angle: f64) -> Result<Option<Body>> {
|
||||
let lp = &nl.lp;
|
||||
// A half disc on the axis revolved fully is a sphere: build it without poles. Every
|
||||
// patch is swept from the half disc's arcs.
|
||||
if let Some((c, rad)) = half_disc(lp, axis_origin, d) {
|
||||
let arcs: Vec<usize> =
|
||||
lp.segs.iter().enumerate().filter(|(_, s)| matches!(s, Seg2::Arc { .. })).flat_map(|(i, _)| nl.numbers(i).to_vec()).collect();
|
||||
return sphere_solid(plane.to_world(c), rad, [Vec3::X, Vec3::Y, Vec3::Z], &arcs).map(Some);
|
||||
}
|
||||
// A full turn of a profile that comes back to the axis along a curve (a half slot about
|
||||
// its centreline, a dome at the far end): truck's cone gives the faces
|
||||
// swept from it the wrong region (their pole is at the end of their curve), and cuts with
|
||||
// such a body failed (#1853). It is built as part turns are, a third of a turn at a time.
|
||||
if pole_at_end(lp, axis_origin, d)
|
||||
&& let Some(b) = revolve_on_axis(plane, nl, axis_origin, d, angle)?
|
||||
{
|
||||
return Ok(Some(b));
|
||||
}
|
||||
// A full revolution of a profile with one edge on the axis: sweep the rest of the loop
|
||||
// as a cone-like shell (no zero-area faces, which booleans can't handle).
|
||||
if let Some(b) = revolve_touching_axis(plane, nl, axis_origin, d)? {
|
||||
return Ok(Some(b));
|
||||
}
|
||||
// Several edges on the axis (a spherical shell's two radial lines): each run of the loop
|
||||
// from the axis back to it, closed along the axis, turns into a shell of its own, a solid
|
||||
// where it runs the way the loop does and a void where it runs the other way. Swept whole,
|
||||
// the edges on the axis became zero-area faces joining the shells, and a cut through a pole
|
||||
// there failed (#451).
|
||||
let on_axis = |s: &Seg2| matches!(*s, Seg2::Line { a, b } if d.cross(a - axis_origin).abs() < 1e-9 && d.cross(b - axis_origin).abs() < 1e-9);
|
||||
let n = lp.segs.len();
|
||||
let axis_segs: Vec<usize> = (0..n).filter(|i| lp.segs.get(*i).is_some_and(on_axis)).collect();
|
||||
let [k0, _, ..] = axis_segs[..] else { return Ok(None) };
|
||||
let mut parts = Vec::new();
|
||||
for (i, &k) in axis_segs.iter().enumerate() {
|
||||
let run: Vec<usize> = (k + 1..axis_segs.get(i + 1).copied().unwrap_or(k0 + n)).map(|j| j % n).collect();
|
||||
let mut segs: Vec<Seg2> = run.iter().filter_map(|j| lp.segs.get(*j).copied()).collect();
|
||||
let (Some(first), Some(last)) = (segs.first(), segs.last()) else { return Ok(None) };
|
||||
segs.push(Seg2::Line { a: last.end(), b: first.start() });
|
||||
let sub = NumberedLoop { lp: Loop2 { segs }, from: run.iter().map(|j| nl.numbers(*j).to_vec()).chain([Vec::new()]).collect() };
|
||||
let void = sub.lp.is_ccw() != lp.is_ccw();
|
||||
let Some(b) = full_turn_on_axis(plane, &if void { sub.reversed() } else { sub }, axis_origin, d, angle)? else { return Ok(None) };
|
||||
parts.push((b, void));
|
||||
}
|
||||
let faces: Option<Vec<FaceProv>> =
|
||||
parts.iter().map(|(b, _)| b.history().map(|h| h.faces.clone())).collect::<Option<Vec<_>>>().map(|f| f.concat());
|
||||
let solid = guard("revolve", || {
|
||||
let mut shells = Vec::new();
|
||||
for (b, void) in &parts {
|
||||
let mut s = b.solid.as_ref().clone();
|
||||
if *void {
|
||||
s.not();
|
||||
}
|
||||
shells.extend(s.boundaries().iter().cloned());
|
||||
}
|
||||
Solid::try_new(shells).map_err(|e| KernelError::Failed(format!("revolve: {e}")))
|
||||
})?;
|
||||
record::attach(Body::new(solid)?, &[], faces, Default::default()).map(Some)
|
||||
}
|
||||
|
||||
/// Whether the loop has one edge on the axis and comes back to it along a curve (the segment
|
||||
/// before the axis edge is not a line). A line there (a drill point) sweeps a cone, which
|
||||
/// truck's cone builds right.
|
||||
|
||||
@@ -309,3 +309,36 @@ fn constructed_large_arc_split_and_reversal_preserve_one_source_segment() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A certified block cut by, or joined with, a spherical shell (r 18.5 to 40) through both its
|
||||
/// spheres: booleans with a tool that has a void (#451) keep the sources of the block's ends,
|
||||
/// which they leave as they were.
|
||||
#[test]
|
||||
fn hollow_tool_booleans_keep_planar_support_certificates() {
|
||||
use std::f64::consts::{PI, TAU};
|
||||
let ring = Region2 {
|
||||
outer: Loop2 {
|
||||
segs: vec![
|
||||
Seg2::Line { a: Vec2::new(18.5, 0.), b: Vec2::new(40., 0.) },
|
||||
Seg2::Arc { center: Vec2::ZERO, radius: 40., start: 0., sweep: PI },
|
||||
Seg2::Line { a: Vec2::new(-40., 0.), b: Vec2::new(-18.5, 0.) },
|
||||
Seg2::Arc { center: Vec2::ZERO, radius: 18.5, start: PI, sweep: -PI },
|
||||
],
|
||||
},
|
||||
holes: vec![],
|
||||
};
|
||||
let shell = crate::revolve(&Plane::XY, &[ring], Vec2::ZERO, Vec2::X, TAU).unwrap().remove(0);
|
||||
assert_eq!(shell.shell_count(), 2, "a solid with a void");
|
||||
let block = crate::box_solid(Vec3::new(8., -4., -4.), Vec3::new(50., 4., 4.)).unwrap().with_box_certificate(42).unwrap();
|
||||
for op in [crate::BoolOp::Cut, crate::BoolOp::Union] {
|
||||
let r = crate::boolean(&block, &shell, op).unwrap().unwrap();
|
||||
let ends: Vec<f64> = (0..r.face_count())
|
||||
.filter(|i| {
|
||||
matches!(r.face_sources().and_then(|s| s.get(*i)).and_then(Option::as_ref), Some(FaceSource::Box { producer: Some(42), axis: 0, .. }))
|
||||
})
|
||||
.map(|i| r.planar_face(i).unwrap().origin.x)
|
||||
.collect();
|
||||
assert!([8., 50.].iter().all(|x| ends.iter().any(|e| (e - x).abs() < 1e-9)), "{op:?}: {ends:?}");
|
||||
assert_exact_planes(&r);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -921,6 +921,9 @@ pub fn boolean(a: &Body, b: &Body, op: BoolOp) -> Result<Option<Body>> {
|
||||
}
|
||||
|
||||
fn boolean_untimed(a: &Body, b: &Body, op: BoolOp) -> Result<Option<Body>> {
|
||||
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) {
|
||||
@@ -1008,14 +1011,7 @@ fn boolean_via(a: &Body, b: &Body, op: BoolOp, whole: &dyn Fn(&Body, &Body, Bool
|
||||
)),
|
||||
};
|
||||
}
|
||||
r = r.map(|result| result.map(|body| body.inherit_regularization_protection(a).inherit_regularization_protection(b)));
|
||||
match op {
|
||||
BoolOp::Cut => r = r.and_then(|result| result.map(|body| body.with_preserved_boolean_planar_sources(a, b, true)).transpose()),
|
||||
BoolOp::Union => r = 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 = r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(a, b)).transpose()),
|
||||
}
|
||||
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)
|
||||
@@ -1034,6 +1030,19 @@ fn boolean_via(a: &Body, b: &Body, op: BoolOp, whole: &dyn Fn(&Body, &Body, Bool
|
||||
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<Option<Body>>) -> Result<Option<Body>> {
|
||||
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;
|
||||
|
||||
@@ -1100,6 +1109,81 @@ fn cut_around_voids(a: &Body, b: &Body, whole: &dyn Fn(&Body, &Body, BoolOp) ->
|
||||
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<Option<Body>> {
|
||||
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<Body> = 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::<Result<_>>()
|
||||
.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<Body>, op: BoolOp) -> Result<Option<Body>> {
|
||||
let counts = record::counts(&[a, b]);
|
||||
let traced: Vec<Traced> = 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<Option<Traced>> {
|
||||
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<Traced> = 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 {
|
||||
|
||||
Reference in New Issue
Block a user