Files
solidcraft/crates/kernel/src/polybool.rs
T
jyvikoandClaude Opus 5.5 39e1dcea03 Faceted boolean: a body's own mesh is closed once its faces' shared corners are one vertex
faceted_boolean took the tool mesh's triangles by vertex index and refused any edge not shared
by exactly two triangles. A body's mesh (Body::mesh) gives each face its own vertices, the faces
along an edge the very same points, so a box's mesh came in as six open patches: "the mesh is
not closed". Corners at the very same point are now one vertex first (triangles keep their order,
so the history's triangle faces are unchanged).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 12:07:50 -04:00

224 lines
11 KiB
Rust

//! Booleans of a body with a closed triangle mesh: the mesh becomes a polyhedral solid (each
//! run of coplanar triangles joined across their shared edges one planar face, sewn), which
//! SMLib's boolean takes with the body as it is. The result's history is over the body and the
//! mesh, the mesh's faces being its triangles.
use std::collections::{BTreeMap, BTreeSet};
use solidcraft_geom::{Mesh, Vec3};
use crate::body::Body;
use crate::heal::find;
use crate::history::{Change, EdgeOrigin, EdgeProv, FaceOrigin, FaceProv, History, Side};
use crate::sew::{EdgeSpec, FaceSpec, SurfSpec};
use crate::{BoolOp, KernelError, Result};
/// The most triangles a mesh operand may have.
const MAX_TRIANGLES: usize = 200_000;
fn failed(what: &str) -> KernelError {
KernelError::Failed(format!("faceted boolean: {what}"))
}
/// Boolean of a body with a closed triangle mesh (wound outward). `tol` (mm): how far a
/// triangle's corners may lie off the plane of the triangles beside it and still make one
/// face with them. For tools that come as meshes; the body keeps its exact faces.
///
/// The result's history is over `[a, b]`, the mesh's faces being its triangles (and it having
/// no edges): a face of the result lies on faces of `a` or on triangles of `b`; an edge where
/// `a` meets the mesh meets the triangles of the face it lies along.
pub fn faceted_boolean(a: &Body, b: &Mesh, op: BoolOp, tol: f64) -> Result<Option<Body>> {
crate::profile::timed(crate::profile::Kind::Boolean, "faceted_boolean", || faceted_boolean_untimed(a, b, op, tol))
}
fn faceted_boolean_untimed(a: &Body, b: &Mesh, op: BoolOp, tol: f64) -> Result<Option<Body>> {
a.require_brep("a boolean")?;
if !(tol.is_finite() && tol > 0.0) {
return Err(KernelError::Invalid("facet tolerance".into()));
}
if b.triangles.len() > MAX_TRIANGLES {
return Err(failed(&format!("the mesh is too detailed ({} triangles, at most {MAX_TRIANGLES})", b.triangles.len())));
}
let welded = welded(b);
let b = &welded;
let groups = coplanar_groups(b, tol)?;
let mut faces = Vec::new();
let mut face_group = Vec::new();
for (g, triangles) in groups.iter().enumerate() {
for spec in group_faces(b, triangles)? {
faces.push(spec);
face_group.push(g);
}
}
let (tool, from) = crate::sew::sew_touching_with_sources(&faces, &vec![None; faces.len()])?;
let Some(result) = crate::boolean(a, &tool, op)? else { return Ok(None) };
// The result's history over [a, tool], with the tool's own over the mesh put in its place.
let inner = from.and_then(|from| tool_history(&tool, &from, &face_group, &groups));
let history = match (result.history(), inner) {
(Some(h), Some(inner)) => h.clone().substituted(1, &inner).ok(),
_ => None,
};
let counts = [(a.face_count(), a.edge_count()), (b.triangles.len(), 0)];
Ok(Some(result.with_checked_history(history, &counts)))
}
/// `m` with corners at the very same point made one vertex, triangles in their order: a body's
/// own mesh (Body::mesh) gives each face its own vertices, the faces along an edge its very
/// points, and is closed only once they are one.
fn welded(m: &Mesh) -> Mesh {
let mut at: BTreeMap<[u64; 3], u32> = BTreeMap::new();
let mut positions = Vec::with_capacity(m.positions.len());
let index: Vec<u32> = m
.positions
.iter()
.map(|p| {
*at.entry([p.x.to_bits(), p.y.to_bits(), p.z.to_bits()]).or_insert_with(|| {
positions.push(*p);
(positions.len() - 1) as u32
})
})
.collect();
let triangles = m.triangles.iter().map(|t| t.map(|i| index.get(i as usize).copied().unwrap_or(i))).collect();
Mesh { positions, triangles, ..Mesh::default() }
}
/// The mesh's triangles in runs that make one planar face each: triangles sharing an edge, on
/// one plane within `tol`, are one run.
fn coplanar_groups(m: &Mesh, tol: f64) -> Result<Vec<Vec<usize>>> {
let mut planes = Vec::with_capacity(m.triangles.len());
for t in &m.triangles {
let [p, q, r] = m.tri(t).ok_or_else(|| failed("a triangle refers to a missing vertex"))?;
let n = (q - p).cross(r - p).normalized().ok_or_else(|| failed("a triangle has no area"))?;
planes.push((n, n.dot(p)));
}
let mut by_edge: BTreeMap<(u32, u32), Vec<usize>> = BTreeMap::new();
for (i, t) in m.triangles.iter().enumerate() {
for k in 0..3 {
let (a, b) = (t[k], t[(k + 1) % 3]);
by_edge.entry((a.min(b), a.max(b))).or_default().push(i);
}
}
let on_plane = |(n, w): (Vec3, f64), t: usize| {
m.triangles.get(t).and_then(|t| m.tri(t)).is_some_and(|corners| corners.iter().all(|p| (n.dot(*p) - w).abs() <= tol))
};
let mut parent: Vec<usize> = (0..m.triangles.len()).collect();
for sharing in by_edge.values() {
let &[t, u] = sharing.as_slice() else { return Err(failed("the mesh is not closed: an edge is not shared by exactly two triangles")) };
let (Some(&pt), Some(&pu)) = (planes.get(t), planes.get(u)) else { continue };
if pt.0.dot(pu.0) > 1.0 - 1e-12 && on_plane(pt, u) && on_plane(pu, t) {
let (rt, ru) = (find(&mut parent, t), find(&mut parent, u));
if let Some(slot) = parent.get_mut(rt) {
*slot = ru;
}
}
}
let mut groups: BTreeMap<usize, Vec<usize>> = BTreeMap::new();
for t in 0..m.triangles.len() {
groups.entry(find(&mut parent, t)).or_default().push(t);
}
Ok(groups.into_values().collect())
}
/// The planar faces of one run of coplanar triangles: its boundary (the edges no other triangle
/// of the run runs back along) chained into loops, split where a loop passes a vertex twice,
/// each outer loop (counter-clockwise about the run's normal) with the holes it holds.
fn group_faces(m: &Mesh, triangles: &[usize]) -> Result<Vec<FaceSpec>> {
let bad = || failed("a triangle refers to a missing vertex");
let first = *triangles.first().ok_or_else(|| failed("an empty face"))?;
let [p, q, r] = m.triangles.get(first).and_then(|t| m.tri(t)).ok_or_else(bad)?;
let normal = (q - p).cross(r - p).normalized().ok_or_else(|| failed("a triangle has no area"))?;
let directed: BTreeSet<(u32, u32)> =
triangles.iter().filter_map(|t| m.triangles.get(*t)).flat_map(|t| (0..3).map(move |k| (t[k], t[(k + 1) % 3]))).collect();
let mut out: BTreeMap<u32, Vec<u32>> = BTreeMap::new();
for &(a, b) in &directed {
if !directed.contains(&(b, a)) {
out.entry(a).or_default().push(b);
}
}
let point = |v: u32| m.positions.get(v as usize).copied().ok_or_else(bad);
let mut loops: Vec<Vec<u32>> = Vec::new();
while let Some((&start, _)) = out.iter().find(|(_, next)| !next.is_empty()) {
let mut walk = vec![start];
let mut at = start;
loop {
let next = out.get_mut(&at).and_then(Vec::pop).ok_or_else(|| failed("a face's boundary does not close"))?;
if next == start {
break;
}
walk.push(next);
at = next;
}
// A walk through a vertex twice (two loops touching there) is split into simple loops.
let mut stack: Vec<u32> = Vec::new();
for v in walk {
if let Some(at) = stack.iter().position(|x| *x == v) {
loops.push(stack.split_off(at));
}
stack.push(v);
}
loops.push(stack);
}
let polygon = |lp: &[u32]| lp.iter().map(|v| point(*v)).collect::<Result<Vec<Vec3>>>();
let area = |pts: &[Vec3]| pts.iter().zip(pts.iter().cycle().skip(1)).fold(Vec3::ZERO, |s, (a, b)| s + a.cross(*b)).dot(normal) * 0.5;
let (u, w) = (normal.any_perp(), normal.cross(normal.any_perp()));
let inside = |pt: Vec3, poly: &[Vec3]| {
let (px, py) = (pt.dot(u), pt.dot(w));
let mut odd = false;
for (a, b) in poly.iter().zip(poly.iter().cycle().skip(1)) {
let ((ax, ay), (bx, by)) = ((a.dot(u), a.dot(w)), (b.dot(u), b.dot(w)));
if (ay > py) != (by > py) && px < ax + (py - ay) / (by - ay) * (bx - ax) {
odd = !odd;
}
}
odd
};
let polys: Vec<Vec<Vec3>> = loops.iter().filter(|l| l.len() >= 3).map(|l| polygon(l)).collect::<Result<_>>()?;
let (outers, holes): (Vec<&Vec<Vec3>>, Vec<&Vec<Vec3>>) = polys.iter().partition(|p| area(p) > 0.0);
let edges = |poly: &[Vec3]| poly.iter().zip(poly.iter().cycle().skip(1)).map(|(a, b)| EdgeSpec::Line { a: *a, b: *b }).collect::<Vec<_>>();
let mut faces: Vec<FaceSpec> = outers.iter().map(|o| FaceSpec { loops: vec![edges(o)], surface: SurfSpec::Plane, probe: None }).collect();
for hole in holes {
let probe = *hole.first().ok_or_else(|| failed("an empty loop"))?;
// The innermost outer loop holding the hole.
let owner = (0..outers.len())
.filter(|i| outers.get(*i).is_some_and(|o| inside(probe, o)))
.min_by(|x, y| outers.get(*x).map_or(0.0, |o| area(o)).total_cmp(&outers.get(*y).map_or(0.0, |o| area(o))))
.ok_or_else(|| failed("a hole in no face"))?;
if let Some(face) = faces.get_mut(owner) {
face.loops.push(edges(hole));
}
}
Ok(faces)
}
/// The tool's history over the mesh: each face from the triangles of its run (`from` gives
/// the face spec each tool face was sewn from, `face_group` the run of each spec); each edge
/// where the runs of the faces either side of it meet. `None` where a face can't be followed.
fn tool_history(tool: &Body, from: &[usize], face_group: &[usize], groups: &[Vec<usize>]) -> Option<History> {
let triangles = |face: usize| -> Option<&Vec<usize>> { groups.get(*face_group.get(*from.get(face)?)?) };
let origins =
|face: usize| -> Option<Vec<FaceOrigin>> { Some(triangles(face)?.iter().map(|t| FaceOrigin::Face { operand: 0, face: *t }).collect()) };
let faces = (0..tool.face_count())
.map(|f| {
let origins = origins(f)?;
let change = if origins.len() == 1 { Change::Kept } else { Change::Merged };
Some(FaceProv { origins, change })
})
.collect::<Option<Vec<_>>>()?;
let record = crate::native::brep_record(tool).ok()?;
let edges = record
.edges
.iter()
.map(|e| {
let mut sides: Vec<usize> = e.uses.iter().map(|u| u.face as usize).collect();
sides.sort_unstable();
sides.dedup();
let meet = match sides.as_slice() {
[f, g] => vec![EdgeOrigin::meet(Side::new(origins(*f)?)?, Side::new(origins(*g)?)?)],
_ => Vec::new(),
};
Some(EdgeProv { faces: sides, origins: meet })
})
.collect::<Option<Vec<_>>>()?;
Some(History { operands: 1, faces, edges })
}