Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Kernel: split a body by a plane or another face's surface

bherbruck34be21863955
diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs
index e6c88946bd..4b7480a812 100644
--- a/crates/kernel/src/lib.rs
+++ b/crates/kernel/src/lib.rs
@@ -52,7 +52,7 @@ pub use ops::{BoolOp, boolean, split_by_plane, transform, transform_matrix};
pub use polybool::planar_boolean;
pub use polyhedron::{HalfSpace, convex_polyhedron, draft, offset_faces, shell};
pub use sew::{EdgeSpec, FaceSpec, SurfSpec, sew};
-pub use splitface::{SplitTool, split_faces};
+pub use splitface::{SplitTool, split_body, split_faces};
pub use step::step_export;
pub use step_in::{ImportedBody, StepImport, StepNode, step_import, step_import_shared, step_orientation_errors, step_validate};
pub use step_out::{ExportBody, ExportProduct, StepHeader, step_export_bodies, step_export_products};
diff --git a/crates/kernel/src/splitface.rs b/crates/kernel/src/splitface.rs
index 694765bb23..9e0ae3963d 100644
--- a/crates/kernel/src/splitface.rs
+++ b/crates/kernel/src/splitface.rs
@@ -30,9 +30,23 @@ pub enum SplitTool<'a> {
/// Which side of the tool a point is on (zero on the tool).
enum Field {
- Plane { o: Vec3, n: Vec3 },
+ Plane {
+ o: Vec3,
+ n: Vec3,
+ },
Surface(mt::Surface),
- Curve { plane: Plane, pts: Vec<Vec2> },
+ /// A circular cylinder (radius `r` about the line through `o` along unit `axis`); `out` is
+ /// +1 when the tool's normal points away from the axis.
+ Cylinder {
+ o: Vec3,
+ axis: Vec3,
+ r: f64,
+ out: f64,
+ },
+ Curve {
+ plane: Plane,
+ pts: Vec<Vec2>,
+ },
}
impl Field {
@@ -47,6 +61,11 @@ impl Field {
}
None => f64::NAN,
},
+ Field::Cylinder { o, axis, r, out } => {
+ let v = p - *o;
+ let radial = v - *axis * v.dot(*axis);
+ *out * (radial.len() - *r)
+ }
Field::Curve { plane, pts } => {
let q = plane.to_local(p);
let q = Vec2::new(q.x, q.y);
@@ -214,7 +233,11 @@ fn trace(face: &mt::Face, g: &Field, size: f64) -> Result<Vec<Chain>> {
hi = mid;
}
}
- let uv = f(0.5 * (lo + hi)).1;
+ let (val, uv) = f(0.5 * (lo + hi));
+ // A side whose ends were on the same side after all (a corner exactly on the tool).
+ if !(val.abs() <= size * 1e-7) {
+ return None;
+ }
Some((surface.subs(uv.0, uv.1), uv))
};
// Walk the links into chains.
@@ -629,13 +652,67 @@ fn split_one(faces: &mut Vec<mt::Face>, fi: usize, g: &Field, size: f64, new_edg
Ok((made, count))
}
+/// The plane or circular cylinder a (B-spline) surface is, as a field with the surface's
+/// normal; other surfaces as they are.
+fn surface_field(s: &mt::Surface) -> Field {
+ let (Some((u0, u1)), Some((v0, v1))) = s.try_range_tuple() else { return Field::Surface(s.clone()) };
+ if !matches!(s, mt::Surface::Plane(_) | mt::Surface::BSplineSurface(_) | mt::Surface::NurbsSurface(_)) {
+ return Field::Surface(s.clone());
+ }
+ let at = |a: f64, b: f64| from_p3(s.subs(u0 + (u1 - u0) * a, v0 + (v1 - v0) * b));
+ let nrm = |a: f64, b: f64| {
+ let n = s.normal(u0 + (u1 - u0) * a, v0 + (v1 - v0) * b);
+ Vec3::new(n.x, n.y, n.z)
+ };
+ let grid: Vec<(f64, f64)> = (0..=6).flat_map(|i| (0..=6).map(move |j| (i as f64 / 6.0, j as f64 / 6.0))).collect();
+ let size = grid.iter().map(|(a, b)| at(*a, *b).dist(at(0.0, 0.0))).fold(1e-9, f64::max);
+ let tol = size * 1e-7;
+ // A plane: one normal, every point on it.
+ let n0 = nrm(0.5, 0.5);
+ let o = at(0.5, 0.5);
+ if grid.iter().all(|(a, b)| (at(*a, *b) - o).dot(n0).abs() <= tol) {
+ return Field::Plane { o, n: n0 };
+ }
+ // A cylinder: straight along one parameter, a circle along the other.
+ for along_v in [true, false] {
+ let pt = |t: f64, w: f64| if along_v { at(t, w) } else { at(w, t) };
+ let d = pt(0.0, 1.0) - pt(0.0, 0.0);
+ let Some(axis) = d.normalized() else { continue };
+ let straight = (0..=6).all(|k| {
+ let t = k as f64 / 6.0;
+ (0..=4).all(|m| (pt(t, m as f64 / 4.0) - pt(t, 0.0) - d * (m as f64 / 4.0)).len() <= tol)
+ });
+ if !straight {
+ continue;
+ }
+ let prof: Vec<Vec3> = (0..=8).map(|k| pt(k as f64 / 8.0, 0.0)).collect();
+ let (a, b, c) = (prof[0], prof[3], prof[6]);
+ let (ab, ac) = (b - a, c - a);
+ let nn = ab.cross(ac);
+ let n2 = nn.dot(nn);
+ if !(n2 > 1e-24) {
+ continue;
+ }
+ let centre = a + (nn.cross(ab) * ac.dot(ac) + ac.cross(nn) * ab.dot(ab)) * (0.5 / n2);
+ let r = (a - centre).len();
+ if prof.iter().all(|p| ((*p - centre).len() - r).abs() <= tol) && nn.normalized().is_some_and(|nu| nu.cross(axis).len() < 1e-6) {
+ let mid = pt(0.5, 0.5);
+ let v = mid - centre;
+ let radial = v - axis * v.dot(axis);
+ let out = if nrm(0.5, 0.5).dot(radial) >= 0.0 { 1.0 } else { -1.0 };
+ return Field::Cylinder { o: centre, axis, r, out };
+ }
+ }
+ Field::Surface(s.clone())
+}
+
fn fields(tool: &SplitTool) -> Result<Vec<Field>> {
Ok(match tool {
SplitTool::Plane(p) => vec![Field::Plane { o: p.origin, n: p.normal() }],
SplitTool::Face { body: other, face } => {
other.require_brep("a split tool")?;
let f = other.solid.face_iter().nth(*face).ok_or_else(|| KernelError::Invalid(format!("the tool body has no face {face}")))?;
- vec![Field::Surface(f.oriented_surface())]
+ vec![surface_field(&f.oriented_surface())]
}
SplitTool::Curves { plane, curves } => {
if curves.iter().any(|c| c.len() < 2 || c.iter().any(|p| !(p.x.is_finite() && p.y.is_finite()))) {
@@ -700,6 +777,256 @@ pub fn split_faces(body: &Body, faces: &[usize], tool: &SplitTool) -> Result<Bod
})
}
+/// A point well inside a face (a mesh triangle's centre where the field is largest) and the
+/// field there.
+fn side_of(face: &mt::Face, g: &Field, size: f64) -> Result<f64> {
+ let shell: mt::Shell = vec![face.clone()].into();
+ let meshed = shell.robust_triangulation((size * 2e-3).max(1e-4));
+ let pm = meshed.face_iter().next().and_then(|f| f.surface()).ok_or_else(|| KernelError::Failed("a face could not be meshed".into()))?;
+ let pos = pm.positions();
+ let mut best: f64 = 0.0;
+ for t in pm.faces().triangle_iter() {
+ let c = t.iter().filter_map(|v| pos.get(v.pos)).fold(Vec3::ZERO, |a, p| a + from_p3(*p) / 3.0);
+ let x = g.eval(c);
+ if x.is_finite() && x.abs() > best.abs() {
+ best = x;
+ }
+ }
+ Ok(best)
+}
+
+/// Loops from edges (each used once), chained end to start; edges are turned round as needed.
+fn chain_loops(edges: &[mt::Edge]) -> Result<Vec<Vec<mt::Edge>>> {
+ let mut pool: Vec<mt::Edge> = edges.to_vec();
+ let mut out = Vec::new();
+ while let Some(first) = pool.pop() {
+ let start = first.front().id();
+ let mut at = first.back().clone();
+ let mut lp = vec![first];
+ while at.id() != start {
+ let Some(k) = pool.iter().position(|e| e.front().id() == at.id() || e.back().id() == at.id()) else {
+ return Err(KernelError::Failed("the section through the body does not close".into()));
+ };
+ let e = pool.remove(k);
+ let e = if e.front().id() == at.id() { e } else { e.inverse() };
+ at = e.back().clone();
+ lp.push(e);
+ if lp.len() > 1_000_000 {
+ return Err(KernelError::Failed("section loop too long".into()));
+ }
+ }
+ out.push(lp);
+ }
+ Ok(out)
+}
+
+/// Faces grouped by shared edges (in face order).
+fn components(faces: Vec<mt::Face>) -> Vec<Vec<mt::Face>> {
+ let n = faces.len();
+ let mut by_edge: HashMap<mt::EdgeID, Vec<usize>> = HashMap::new();
+ for (i, f) in faces.iter().enumerate() {
+ for e in f.boundaries().iter().flat_map(|w| w.edge_iter()) {
+ by_edge.entry(e.id()).or_default().push(i);
+ }
+ }
+ let mut comp = vec![usize::MAX; n];
+ let mut count = 0;
+ for s in 0..n {
+ if comp[s] != usize::MAX {
+ continue;
+ }
+ comp[s] = count;
+ let mut stack = vec![s];
+ while let Some(i) = stack.pop() {
+ let Some(f) = faces.get(i) else { continue };
+ for e in f.boundaries().iter().flat_map(|w| w.edge_iter()) {
+ for &j in by_edge.get(&e.id()).into_iter().flatten() {
+ if comp[j] == usize::MAX {
+ comp[j] = count;
+ stack.push(j);
+ }
+ }
+ }
+ }
+ count += 1;
+ }
+ let mut out: Vec<Vec<mt::Face>> = vec![Vec::new(); count];
+ for (f, c) in faces.into_iter().zip(comp) {
+ if let Some(v) = out.get_mut(c) {
+ v.push(f);
+ }
+ }
+ out
+}
+
+/// Split a body into the parts on either side of a tool: a plane, or another face's surface
+/// (extended). Faces are divided where the tool meets them and every part is closed with the
+/// piece of the tool's surface inside the body; parts come in face order, those on the tool's
+/// back first. A body the tool misses comes back whole.
+pub fn split_body(body: &Body, tool: &SplitTool) -> Result<Vec<Body>> {
+ body.require_brep("split body")?;
+ if body.solid.boundaries().len() != 1 {
+ return Err(KernelError::Invalid("not supported yet: splitting a body with voids".into()));
+ }
+ let size = body.size();
+ let fields = fields(tool)?;
+ let [g] = fields.as_slice() else { return Err(KernelError::Invalid("a body is split by a plane or a face".into())) };
+ // The tool surface, with the field's normal.
+ // The tool's whole surface for the section (a sheet that is part of a plane or cylinder
+ // is extended to all of it), with the field's normal.
+ let surface = match g {
+ Field::Plane { o, n } => {
+ let x = (if n.x.abs() < 0.9 { Vec3::X } else { Vec3::Y }).cross(*n).normalized().unwrap_or(Vec3::X);
+ let y = n.cross(x);
+ let o = p3(*o);
+ mt::Surface::Plane(mt::Plane::new(o, o + crate::body::v3(x), o + crate::body::v3(y)))
+ }
+ Field::Cylinder { o, axis, r, out } => {
+ // A line along the axis at radius r, long enough for the body, revolved.
+ let mut lo = f64::INFINITY;
+ let mut hi = f64::NEG_INFINITY;
+ for v in body.solid.vertex_iter() {
+ let t = (from_p3(v.point()) - *o).dot(*axis);
+ lo = lo.min(t);
+ hi = hi.max(t);
+ }
+ let (lo, hi) = (lo - size, hi + size);
+ let x = (if axis.x.abs() < 0.9 { Vec3::X } else { Vec3::Y }).cross(*axis).normalized().unwrap_or(Vec3::X);
+ let (a, b) = (*o + *axis * lo + x * *r, *o + *axis * hi + x * *r);
+ let line = mt::Curve::Line(mt::Line(p3(a), p3(b)));
+ crate::step_in::geom::revolved_oriented(line, p3(*o), crate::body::v3(*axis), 0.5, crate::body::v3(x * *out))
+ }
+ Field::Surface(s) => s.clone(),
+ Field::Curve { .. } => return Err(KernelError::Invalid("a body is split by a plane or a face".into())),
+ };
+ let total = body.solid.face_iter().count();
+ let all: Vec<usize> = (0..total).collect();
+ guard("split body", || {
+ let (shells, new_edges, made) = imprint(body, &all, &fields, size)?;
+ if made == 0 || new_edges.is_empty() {
+ return Ok(vec![body.clone()]);
+ }
+ let faces: Vec<mt::Face> = shells.into_iter().flatten().collect();
+ // The section: loops of the new edges on the tool surface, outer loops counter-clockwise
+ // about its normal and holes inside them.
+ let loops = chain_loops(&new_edges)?;
+ let polys: Vec<Vec<(f64, f64)>> = loops.iter().map(|l| loop_uv(&surface, &l.clone().into())).collect();
+ let signed = |p: &[(f64, f64)]| {
+ (0..p.len())
+ .map(|i| {
+ let (a, b) = (p[i], p[(i + 1) % p.len()]);
+ a.0 * b.1 - b.0 * a.1
+ })
+ .sum::<f64>()
+ };
+ let depth: Vec<usize> = (0..loops.len())
+ .map(|i| {
+ let q = polys.get(i).and_then(|p| p.first()).copied().unwrap_or((0.0, 0.0));
+ (0..loops.len()).filter(|&j| j != i && polys.get(j).is_some_and(|p| inside(p, q))).count()
+ })
+ .collect();
+ let wire = |i: usize, ccw: bool| -> mt::Wire {
+ let w: mt::Wire = loops.get(i).cloned().unwrap_or_default().into();
+ let is_ccw = polys.get(i).is_some_and(|p| signed(p) > 0.0);
+ if is_ccw == ccw { w } else { w.inverse() }
+ };
+ let mut section = Vec::new();
+ // On a surface of revolution, loops that run once round it (a cylinder through a box:
+ // its circles at the top and bottom) bound bands: taken in order along the profile,
+ // each pair is one face, the lower loop running back round and the upper forward.
+ let mut wrapping = vec![false; loops.len()];
+ if let mt::Surface::RevolutedCurve(rc) = &surface {
+ let (o, axis) = (rc.entity().origin(), rc.entity().axis().normalize());
+ let x0 = if axis.x.abs() < 0.9 { mt::Vector3::unit_x() } else { mt::Vector3::unit_y() };
+ let ex = (x0 - axis * x0.dot(axis)).normalize();
+ let ey = axis.cross(ex);
+ let tau = std::f64::consts::TAU;
+ let samples = |w: &mt::Wire| -> Vec<mt::Point3> {
+ w.edge_iter()
+ .flat_map(|e| {
+ let c = e.oriented_curve();
+ let (t0, t1) = c.range_tuple();
+ (0..32).map(move |k| c.subs(t0 + (t1 - t0) * k as f64 / 32.0)).collect::<Vec<_>>()
+ })
+ .collect()
+ };
+ let mut bands: Vec<(f64, usize)> = Vec::new();
+ for (i, l) in loops.iter().enumerate() {
+ let pts = samples(&l.clone().into());
+ let ang = |p: &mt::Point3| (p - o).dot(ey).atan2((p - o).dot(ex));
+ let turn: f64 = (0..pts.len())
+ .map(|k| {
+ let d = ang(&pts[(k + 1) % pts.len()]) - ang(&pts[k]);
+ d - tau * (d / tau).round()
+ })
+ .sum();
+ if (turn.abs() - tau).abs() < 0.1 {
+ let along = pts.iter().map(|p| (p - o).dot(axis)).sum::<f64>() / pts.len().max(1) as f64;
+ bands.push((along, i));
+ if let Some(w) = wrapping.get_mut(i) {
+ *w = true;
+ }
+ }
+ }
+ bands.sort_by(|a, b| a.0.total_cmp(&b.0));
+ // A loop runs so that the band (towards `toward` along the axis) is on its left about
+ // the surface normal.
+ let oriented = |i: usize, toward: f64| -> mt::Wire {
+ let w: mt::Wire = loops.get(i).cloned().unwrap_or_default().into();
+ let pts = samples(&w);
+ let (Some(p), Some(q)) = (pts.first(), pts.get(1)) else { return w };
+ let n = surface.search_nearest_parameter(*p, None, 50).map(|(u, v)| surface.normal(u, v)).unwrap_or(axis);
+ let left = n.cross(q - p);
+ if left.dot(axis) * toward >= 0.0 { w } else { w.inverse() }
+ };
+ for pair in bands.chunks(2) {
+ let [(_, lo), (_, hi)] = pair else { return Err(KernelError::Failed("an unmatched band edge in the section".into())) };
+ section.push(mt::Face::new_unchecked(vec![oriented(*lo, 1.0), oriented(*hi, -1.0)], surface.clone()));
+ }
+ }
+ for (i, d) in depth.iter().enumerate() {
+ if d % 2 != 0 || wrapping.get(i).copied().unwrap_or(false) {
+ continue;
+ }
+ let mut ws = vec![wire(i, true)];
+ for (j, dj) in depth.iter().enumerate() {
+ let q = polys.get(j).and_then(|p| p.first()).copied().unwrap_or((0.0, 0.0));
+ if *dj == d + 1 && polys.get(i).is_some_and(|p| inside(p, q)) {
+ ws.push(wire(j, false));
+ }
+ }
+ section.push(mt::Face::new_unchecked(ws, surface.clone()));
+ }
+ // Each face goes to the side its inside is on.
+ let (mut back, mut front) = (Vec::new(), Vec::new());
+ for f in faces {
+ let x = side_of(&f, g, size)?;
+ if x.abs() <= size * 1e-9 {
+ return Err(KernelError::Invalid("not supported yet: the tool lies along a face of the body".into()));
+ }
+ if x < 0.0 {
+ back.push(f);
+ } else {
+ front.push(f);
+ }
+ }
+ // The section closes the back side facing the tool's normal, the front side facing away.
+ back.extend(section.iter().cloned());
+ front.extend(section.iter().map(|f| f.inverse()));
+ let mut parts = Vec::new();
+ for side in [back, front] {
+ for comp in components(side) {
+ let shell = mt::Shell::from(comp);
+ if shell.shell_condition() != mt::ShellCondition::Closed {
+ return Err(KernelError::Failed("a part of the split does not close".into()));
+ }
+ parts.push(Body::new(mt::Solid::new_unchecked(vec![shell]))?.with_color(body.color));
+ }
+ }
+ Ok(parts)
+ })
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -783,6 +1110,37 @@ mod tests {
assert!(tops.iter().all(|a| rel(*a, half) < 1e-3), "{tops:?}");
}
+ fn volumes(parts: &[Body]) -> Vec<f64> {
+ let mut v: Vec<f64> = parts.iter().map(|b| measure(b).unwrap().volume).collect();
+ v.sort_by(f64::total_cmp);
+ v
+ }
+
+ #[test]
+ fn split_body_by_plane_and_by_a_face() {
+ let b = box_solid(Vec3::ZERO, Vec3::new(10.0, 20.0, 30.0)).unwrap();
+ let pl = Plane::new(Vec3::new(4.0, 0.0, 0.0), Vec3::Y, Vec3::Z).unwrap();
+ let v = volumes(&split_body(&b, &SplitTool::Plane(pl)).unwrap());
+ assert!(v.len() == 2 && rel(v[0], 2400.0) < 1e-9 && rel(v[1], 3600.0) < 1e-9, "{v:?}");
+ // A plate with a hole split through the hole: two equal halves.
+ let plate = box_solid(Vec3::ZERO, Vec3::new(40.0, 30.0, 10.0)).unwrap();
+ let pin = cylinder(Vec3::new(20.0, 15.0, -1.0), Vec3::Z, 5.0, 12.0).unwrap();
+ let holed = crate::boolean(&plate, &pin, crate::BoolOp::Cut).unwrap().unwrap();
+ let pl = Plane::new(Vec3::new(20.0, 0.0, 0.0), Vec3::Y, Vec3::Z).unwrap();
+ let v = volumes(&split_body(&holed, &SplitTool::Plane(pl)).unwrap());
+ let half = (12000.0 - std::f64::consts::PI * 250.0) / 2.0;
+ assert!(v.len() == 2 && rel(v[0], half) < 1e-4 && rel(v[1], half) < 1e-4, "{v:?}");
+ // A box split by a cylinder's side: the core and the rest.
+ let tool = cylinder(Vec3::new(5.0, 10.0, -5.0), Vec3::Z, 4.0, 40.0).unwrap();
+ let side = tool.faces(0.01).unwrap().iter().position(|f| f.plane_normal.is_none()).unwrap();
+ let v = volumes(&split_body(&b, &SplitTool::Face { body: &tool, face: side }).unwrap());
+ let core = std::f64::consts::PI * 16.0 * 30.0;
+ assert!(v.len() == 2 && rel(v[0], core) < 1e-3 && rel(v[1], 6000.0 - core) < 1e-3, "{v:?}");
+ // A plane that misses gives the body back.
+ let far = Plane::new(Vec3::new(50.0, 0.0, 0.0), Vec3::Y, Vec3::Z).unwrap();
+ assert_eq!(split_body(&b, &SplitTool::Plane(far)).unwrap().len(), 1);
+ }
+
#[test]
fn a_tool_that_misses_is_an_error() {
let b = box_solid(Vec3::ZERO, Vec3::new(10.0, 20.0, 30.0)).unwrap();
diff --git a/crates/kernel/src/step_in/geom.rs b/crates/kernel/src/step_in/geom.rs
index cb86728af0..af767dfb57 100644
--- a/crates/kernel/src/step_in/geom.rs
+++ b/crates/kernel/src/step_in/geom.rs
@@ -684,7 +684,7 @@ fn revolved(curve: mt::Curve, o: mt::Point3, axis: mt::Vector3) -> mt::Surface {
/// A surface of revolution whose normal at the profile point `(u, 0)` points along `expected`.
/// The rotation is reversed rather than the surface inverted: truck's inverted `Processor`
/// swaps the parameters but not the search hints, which breaks meshing.
-fn revolved_oriented(curve: mt::Curve, o: mt::Point3, axis: mt::Vector3, u: f64, expected: mt::Vector3) -> mt::Surface {
+pub(crate) fn revolved_oriented(curve: mt::Curve, o: mt::Point3, axis: mt::Vector3, u: f64, expected: mt::Vector3) -> mt::Surface {
let s = revolved(curve.clone(), o, axis);
if s.normal(u, 0.0).dot(expected) >= 0.0 {
return s;