Skip to content

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

Kernel: split faces by a plane, another face's surface or sketch curves

bherbruckf8a4ffbc67a2
diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs
index 293d418db0..e6c88946bd 100644
--- a/crates/kernel/src/lib.rs
+++ b/crates/kernel/src/lib.rs
@@ -32,6 +32,7 @@ mod polybool;
mod polyhedron;
mod prism;
mod sew;
+mod splitface;
mod step;
mod step_in;
mod step_out;
@@ -51,6 +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 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
new file mode 100644
index 0000000000..6aa8e0547f
--- /dev/null
+++ b/crates/kernel/src/splitface.rs
@@ -0,0 +1,780 @@
+//! Split Face: divide chosen faces of a body along where a tool meets them (a plane, another
+//! face's surface, or sketch curves swept along the sketch normal), leaving the solid itself
+//! unchanged. Edges the split line ends on are cut in every face that uses them.
+//!
+//! The tool is a signed field (which side of the tool a point is on). Its zero set on a face is
+//! traced on the face's triangulation, every crossing is placed exactly on the surface by
+//! bisection in the face's parameters, and the line ends exactly on the boundary edges.
+
+use std::collections::HashMap;
+
+use mt::{BoundedCurve, InnerSpace, MetricSpace, ParametricCurve, ParametricSurface, ParametricSurface3D, SearchNearestParameter};
+use solvecraft_geom::{Plane, Vec2, Vec3};
+use truck_meshalgo::tessellation::RobustMeshableShape;
+use truck_modeling as mt;
+
+use crate::body::{Body, from_p3, p3};
+use crate::{KernelError, Result, guard};
+
+/// What splits the faces.
+#[derive(Clone, Debug)]
+pub enum SplitTool<'a> {
+ /// A plane (unbounded).
+ Plane(Plane),
+ /// The surface of another body's face (`face` in that body's face order), extended.
+ Face { body: &'a Body, face: usize },
+ /// Sketch curves (2D polylines in `plane`) swept along the plane's normal; each curve
+ /// splits on its own, its end segments extended.
+ Curves { plane: Plane, curves: Vec<Vec<Vec2>> },
+}
+
+/// Which side of the tool a point is on (zero on the tool).
+enum Field {
+ Plane { o: Vec3, n: Vec3 },
+ Surface(mt::Surface),
+ Curve { plane: Plane, pts: Vec<Vec2> },
+}
+
+impl Field {
+ fn eval(&self, p: Vec3) -> f64 {
+ match self {
+ Field::Plane { o, n } => (p - *o).dot(*n),
+ Field::Surface(s) => match s.search_nearest_parameter(p3(p), None, 50) {
+ Some((u, v)) => {
+ let q = from_p3(s.subs(u, v));
+ let n = s.normal(u, v);
+ (p - q).dot(Vec3::new(n.x, n.y, n.z))
+ }
+ None => f64::NAN,
+ },
+ Field::Curve { plane, pts } => {
+ let q = plane.to_local(p);
+ let q = Vec2::new(q.x, q.y);
+ // Signed distance to the polyline, its end segments extended as lines.
+ let n = pts.len();
+ let mut best = (f64::INFINITY, 0.0);
+ for i in 0..n.saturating_sub(1) {
+ let (Some(&a), Some(&b)) = (pts.get(i), pts.get(i + 1)) else { continue };
+ let d = b - a;
+ let l2 = d.dot(d);
+ if !(l2 > 0.0) {
+ continue;
+ }
+ let mut t = (q - a).dot(d) / l2;
+ if i > 0 {
+ t = t.max(0.0);
+ }
+ if i + 2 < n {
+ t = t.min(1.0);
+ }
+ let c = a + d * t;
+ let dist = (q - c).len();
+ if dist < best.0 {
+ let side = d.x * (q.y - a.y) - d.y * (q.x - a.x);
+ best = (dist, if side >= 0.0 { dist } else { -dist });
+ }
+ }
+ best.1
+ }
+ }
+ }
+}
+
+/// A crossing of the split line with a face boundary edge.
+#[derive(Clone)]
+struct Hit {
+ edge: mt::Edge,
+ t: f64,
+ p: mt::Point3,
+}
+
+/// One traced split line on a face: points (exact) with their surface parameters, and whether
+/// it closes on itself.
+struct Chain {
+ pts: Vec<(mt::Point3, (f64, f64))>,
+ closed: bool,
+}
+
+/// Mesh tolerance for tracing a face.
+fn trace_tol(face: &mt::Face, size: f64) -> f64 {
+ let _ = face;
+ (size * 2e-3).max(1e-4)
+}
+
+/// Trace the zero set of `g` over a face: chains of exact points.
+fn trace(face: &mt::Face, g: &Field, size: f64) -> Result<Vec<Chain>> {
+ let tol = trace_tol(face, size);
+ let shell: mt::Shell = vec![face.clone()].into();
+ let meshed = shell.robust_triangulation(tol);
+ let Some(mf) = meshed.face_iter().next() else { return Ok(Vec::new()) };
+ let Some(pm) = mf.surface() else { return Err(KernelError::Failed("the face could not be meshed".into())) };
+ let surface = face.surface();
+ let (pos, uvs) = (pm.positions(), pm.uv_coords());
+ // The face's triangles subdivided in parameter space, finely enough that a small split line
+ // (a hole's circle on a big face) crosses some triangle sides. Corners shared between
+ // triangles are found by their (rounded) parameters.
+ let step = size / 100.0;
+ let mut ids: HashMap<(i64, i64), usize> = HashMap::new();
+ let mut corner_uv: Vec<(f64, f64)> = Vec::new();
+ let (mut umin, mut umax, mut vmin, mut vmax) = (f64::INFINITY, f64::NEG_INFINITY, f64::INFINITY, f64::NEG_INFINITY);
+ for uv in uvs {
+ umin = umin.min(uv.x);
+ umax = umax.max(uv.x);
+ vmin = vmin.min(uv.y);
+ vmax = vmax.max(uv.y);
+ }
+ let qu = ((umax - umin).abs() * 1e-9).max(1e-12);
+ let qv = ((vmax - vmin).abs() * 1e-9).max(1e-12);
+ let mut corner = |uv: (f64, f64)| -> usize {
+ let k = ((uv.0 / qu).round() as i64, (uv.1 / qv).round() as i64);
+ *ids.entry(k).or_insert_with(|| {
+ corner_uv.push(uv);
+ corner_uv.len() - 1
+ })
+ };
+ let mut base: Vec<[((f64, f64), mt::Point3); 3]> = Vec::new();
+ for t in pm.faces().triangle_iter() {
+ let mut c = [((0.0, 0.0), mt::Point3::new(0.0, 0.0, 0.0)); 3];
+ for (k, v) in t.iter().enumerate() {
+ let Some(uv) = v.uv.and_then(|i| uvs.get(i)) else { return Err(KernelError::Failed("mesh without parameters".into())) };
+ let p = pos.get(v.pos).copied().unwrap_or(mt::Point3::new(0.0, 0.0, 0.0));
+ c[k] = ((uv.x, uv.y), p);
+ }
+ base.push(c);
+ }
+ // One division for every triangle, so shared sides divide alike.
+ let longest = base.iter().flat_map(|c| (0..3).map(move |k| c[k].1.distance(c[(k + 1) % 3].1))).fold(0.0, f64::max);
+ let n = ((longest / step).ceil() as usize).clamp(1, 48);
+ let mut tris: Vec<[(usize, (f64, f64)); 3]> = Vec::new();
+ for c in base {
+ let at = |i: usize, j: usize| {
+ let (a, b, cc) = (c[0].0, c[1].0, c[2].0);
+ let (s, t) = (i as f64 / n as f64, j as f64 / n as f64);
+ (a.0 + (b.0 - a.0) * s + (cc.0 - a.0) * t, a.1 + (b.1 - a.1) * s + (cc.1 - a.1) * t)
+ };
+ for i in 0..n {
+ for j in 0..n - i {
+ let (p0, p1, p2) = (at(i, j), at(i + 1, j), at(i, j + 1));
+ tris.push([(corner(p0), p0), (corner(p1), p1), (corner(p2), p2)]);
+ if i + j + 1 < n {
+ let p3 = at(i + 1, j + 1);
+ tris.push([(corner(p1), p1), (corner(p3), p3), (corner(p2), p2)]);
+ }
+ }
+ }
+ if tris.len() > 4_000_000 {
+ return Err(KernelError::Failed("the face is too finely divided to trace".into()));
+ }
+ }
+ let gv: Vec<f64> = corner_uv.iter().map(|uv| g.eval(from_p3(surface.subs(uv.0, uv.1)))).collect();
+ if gv.iter().any(|x| !x.is_finite()) {
+ return Err(KernelError::Failed("the splitting tool cannot be evaluated on the face".into()));
+ }
+ let side = |i: usize| gv.get(i).copied().unwrap_or(0.0) >= 0.0;
+ // Mesh edges crossed by the zero set, and which triangles link them.
+ let key = |a: usize, b: usize| (a.min(b), a.max(b));
+ let mut node_uv: HashMap<(usize, usize), ((f64, f64), (f64, f64))> = HashMap::new();
+ let mut links: HashMap<(usize, usize), Vec<(usize, usize)>> = HashMap::new();
+ let mut edge_tris: HashMap<(usize, usize), usize> = HashMap::new();
+ for t in &tris {
+ for k in 0..3 {
+ let (a, b) = (t[k], t[(k + 1) % 3]);
+ *edge_tris.entry(key(a.0, b.0)).or_default() += 1;
+ }
+ let crossed: Vec<(usize, usize)> = (0..3)
+ .filter_map(|k| {
+ let (a, b) = (t[k], t[(k + 1) % 3]);
+ (side(a.0) != side(b.0)).then(|| {
+ let kk = key(a.0, b.0);
+ let (ua, ub) = if a.0 < b.0 { (a.1, b.1) } else { (b.1, a.1) };
+ node_uv.entry(kk).or_insert((ua, ub));
+ kk
+ })
+ })
+ .collect();
+ if let [x, y] = crossed[..] {
+ links.entry(x).or_default().push(y);
+ links.entry(y).or_default().push(x);
+ }
+ }
+ // Exact point on a crossed mesh edge: bisection along its parameter segment.
+ let exact = |k: (usize, usize)| -> Option<(mt::Point3, (f64, f64))> {
+ let (ua, ub) = *node_uv.get(&k)?;
+ let f = |s: f64| {
+ let uv = (ua.0 + (ub.0 - ua.0) * s, ua.1 + (ub.1 - ua.1) * s);
+ (g.eval(from_p3(surface.subs(uv.0, uv.1))), uv)
+ };
+ let (mut lo, mut hi) = (0.0, 1.0);
+ let s0 = f(0.0).0 >= 0.0;
+ for _ in 0..48 {
+ let mid = 0.5 * (lo + hi);
+ if (f(mid).0 >= 0.0) == s0 {
+ lo = mid;
+ } else {
+ hi = mid;
+ }
+ }
+ let uv = f(0.5 * (lo + hi)).1;
+ Some((surface.subs(uv.0, uv.1), uv))
+ };
+ // Walk the links into chains.
+ let mut seen: std::collections::HashSet<(usize, usize)> = std::collections::HashSet::new();
+ let mut chains = Vec::new();
+ let mut nodes: Vec<(usize, usize)> = links.keys().copied().collect();
+ nodes.sort();
+ // Open chains start at mesh boundary edges (one triangle).
+ nodes.sort_by_key(|k| edge_tris.get(k).copied().unwrap_or(0) != 1);
+ for start in nodes {
+ if seen.contains(&start) {
+ continue;
+ }
+ let mut path = vec![start];
+ seen.insert(start);
+ let mut cur = start;
+ let closed;
+ loop {
+ let next = links.get(&cur).into_iter().flatten().find(|n| !seen.contains(*n)).copied();
+ match next {
+ Some(n) => {
+ seen.insert(n);
+ path.push(n);
+ cur = n;
+ }
+ None => {
+ closed = path.len() > 2 && links.get(&cur).is_some_and(|l| l.contains(&start));
+ break;
+ }
+ }
+ if path.len() > 1_000_000 {
+ return Err(KernelError::Failed("split line too long".into()));
+ }
+ }
+ // Points about a step apart (the ends kept).
+ let all: Vec<_> = path.iter().filter_map(|k| exact(*k)).collect();
+ let mut pts: Vec<(mt::Point3, (f64, f64))> = Vec::new();
+ for (i, p) in all.iter().enumerate() {
+ let keep = i == 0 || i + 1 == all.len() || pts.last().is_none_or(|l| l.0.distance(p.0) >= step * 0.5);
+ if keep {
+ pts.push(*p);
+ }
+ }
+ if pts.len() >= 2 {
+ chains.push(Chain { pts, closed });
+ }
+ }
+ Ok(chains)
+}
+
+/// Where the zero set crosses a boundary edge of the face (exact, by bisection on the curve).
+fn boundary_hits(face: &mt::Face, g: &Field) -> Vec<Hit> {
+ let mut out = Vec::new();
+ for w in face.absolute_boundaries() {
+ for e in w.edge_iter() {
+ let c = e.curve();
+ let (t0, t1) = c.range_tuple();
+ let n = 64;
+ let val = |t: f64| g.eval(from_p3(c.subs(t)));
+ let mut prev = (t0, val(t0));
+ for k in 1..=n {
+ let t = t0 + (t1 - t0) * k as f64 / n as f64;
+ let cur = (t, val(t));
+ if (prev.1 >= 0.0) != (cur.1 >= 0.0) {
+ let (mut lo, mut hi) = (prev.0, cur.0);
+ let s0 = prev.1 >= 0.0;
+ for _ in 0..60 {
+ let mid = 0.5 * (lo + hi);
+ if (val(mid) >= 0.0) == s0 {
+ lo = mid;
+ } else {
+ hi = mid;
+ }
+ }
+ let t = 0.5 * (lo + hi);
+ out.push(Hit { edge: e.clone(), t, p: c.subs(t) });
+ }
+ prev = cur;
+ }
+ }
+ }
+ out
+}
+
+/// A curve through points: a line when they are collinear, else a cubic through every point
+/// (Catmull-Rom tangents; `closed` when the last point repeats the first).
+fn fit(pts: &[mt::Point3], scale: f64) -> Result<mt::Curve> {
+ let (Some(a), Some(b)) = (pts.first(), pts.last()) else { return Err(KernelError::Failed("empty split line".into())) };
+ let d = b - a;
+ let len = d.magnitude();
+ let straight = len > 0.0 && pts.iter().all(|p| (p - a).cross(d).magnitude() / len <= scale * 1e-9);
+ if straight {
+ return Ok(mt::Curve::Line(mt::Line(*a, *b)));
+ }
+ let m = pts.len().saturating_sub(1);
+ if m < 1 {
+ return Err(KernelError::Failed("split line too short".into()));
+ }
+ let closed = a.distance(*b) <= scale * 1e-9 && m >= 3;
+ let at = |i: isize| -> mt::Point3 {
+ let i = if closed { i.rem_euclid(m as isize) as usize } else { i.clamp(0, m as isize) as usize };
+ pts.get(i).copied().unwrap_or(*a)
+ };
+ let mut ctrl = vec![*a];
+ let mut knots = vec![0.0; 4];
+ for i in 0..m as isize {
+ let (p0, p1) = (at(i), at(i + 1));
+ let t0 = (at(i + 1) - at(i - 1)) / 6.0;
+ let t1 = (at(i + 2) - at(i)) / 6.0;
+ ctrl.extend([p0 + t0, p1 - t1, p1]);
+ let k = (i + 1) as f64;
+ knots.extend(if i + 1 == m as isize { [k; 4].to_vec() } else { [k; 3].to_vec() });
+ }
+ let bsp = mt::BSplineCurve::try_new(mt::KnotVec::from(knots), ctrl).map_err(|e| KernelError::Failed(format!("split line: {e}")))?;
+ Ok(mt::Curve::BSplineCurve(bsp))
+}
+
+/// Cut an edge at a parameter (none when the point is already a vertex): the vertex and the
+/// pieces in the edge's absolute direction.
+fn cut_edge(e: &mt::Edge, t: f64, p: mt::Point3, tol: f64) -> Result<(mt::Vertex, Option<(mt::Edge, mt::Edge)>)> {
+ let abs = if e.orientation() { e.clone() } else { e.inverse() };
+ if abs.front().point().distance2(p) <= tol * tol {
+ return Ok((abs.front().clone(), None));
+ }
+ if abs.back().point().distance2(p) <= tol * tol {
+ return Ok((abs.back().clone(), None));
+ }
+ let v = mt::Vertex::new(p);
+ let (a, b) = abs.cut_with_parameter(&v, t).ok_or_else(|| KernelError::Failed("cannot cut an edge at the split line".into()))?;
+ Ok((v, Some((a, b))))
+}
+
+/// Replace cut edges (absolute edge → its two pieces) in a face's loops.
+fn recut(face: &mt::Face, cuts: &[(mt::Edge, (mt::Edge, mt::Edge))]) -> mt::Face {
+ let touches = face.absolute_boundaries().iter().flat_map(|w| w.edge_iter()).any(|e| cuts.iter().any(|(c, _)| c.id() == e.id()));
+ if !touches {
+ return face.clone();
+ }
+ let wires: Vec<mt::Wire> = face
+ .absolute_boundaries()
+ .iter()
+ .map(|w| {
+ let mut out: Vec<mt::Edge> = Vec::new();
+ for e in w.edge_iter() {
+ match cuts.iter().find(|(c, _)| c.id() == e.id()) {
+ Some((c, (a, b))) if c.orientation() == e.orientation() => out.extend([a.clone(), b.clone()]),
+ Some((_, (a, b))) => out.extend([b.inverse(), a.inverse()]),
+ None => out.push(e.clone()),
+ }
+ }
+ out.into()
+ })
+ .collect();
+ let mut f = mt::Face::new_unchecked(wires, face.surface());
+ if !face.orientation() {
+ f.invert();
+ }
+ f
+}
+
+/// A face rebuilt from loops (absolute) on the same surface and orientation as `like`.
+fn face_like(like: &mt::Face, wires: Vec<mt::Wire>) -> mt::Face {
+ let mut f = mt::Face::new_unchecked(wires, like.surface());
+ if !like.orientation() {
+ f.invert();
+ }
+ f
+}
+
+/// Polygon of a loop in the surface's parameters (for inside tests).
+fn loop_uv(s: &mt::Surface, w: &mt::Wire) -> Vec<(f64, f64)> {
+ let mut out = Vec::new();
+ let mut hint = None;
+ for e in w.edge_iter() {
+ let c = e.oriented_curve();
+ let (t0, t1) = c.range_tuple();
+ for k in 0..8 {
+ let p = c.subs(t0 + (t1 - t0) * k as f64 / 8.0);
+ if let Some(uv) = s.search_nearest_parameter(p, hint, 50) {
+ hint = Some(uv);
+ out.push(uv);
+ }
+ }
+ }
+ out
+}
+
+fn inside(poly: &[(f64, f64)], q: (f64, f64)) -> bool {
+ let mut c = false;
+ let n = poly.len();
+ for i in 0..n {
+ let (Some(a), Some(b)) = (poly.get(i), poly.get((i + 1) % n)) else { continue };
+ if (a.1 > q.1) != (b.1 > q.1) && q.0 < a.0 + (b.0 - a.0) * (q.1 - a.1) / (b.1 - a.1) {
+ c = !c;
+ }
+ }
+ c
+}
+
+/// Split one face (index `fi` in `faces`) by one field; `faces` is updated (the face replaced
+/// by its pieces, boundary edges cut in every face).
+fn split_one(faces: &mut Vec<mt::Face>, fi: usize, g: &Field, size: f64) -> Result<usize> {
+ let Some(face) = faces.get(fi).cloned() else { return Ok(0) };
+ let chains = trace(&face, g, size)?;
+ if chains.is_empty() {
+ return Ok(0);
+ }
+ let tol = size * 1e-7 + 1e-9;
+ let snap = size * 1e-3;
+ let hits = boundary_hits(&face, g);
+ // Pieces of the original face as they are split.
+ let mut pieces: Vec<mt::Face> = vec![face.clone()];
+ let mut all_cuts: Vec<(mt::Edge, (mt::Edge, mt::Edge))> = Vec::new();
+ let mut made = 0;
+ for ch in chains {
+ if ch.closed {
+ // A closed line inside the face: a new face inside it and a hole in the piece that holds it.
+ let mut pts: Vec<mt::Point3> = ch.pts.iter().map(|x| x.0).collect();
+ if let Some(first) = pts.first().copied() {
+ pts.push(first);
+ }
+ let curve = fit(&pts, size)?;
+ let Some(&(p0, uv0)) = ch.pts.first() else { continue };
+ let v = mt::Vertex::new(p0);
+ let e = mt::Edge::new_unchecked(&v, &v, curve);
+ let uv: Vec<(f64, f64)> = ch.pts.iter().map(|x| x.1).collect();
+ let area: f64 = (0..uv.len())
+ .map(|i| {
+ let (a, b) = (uv[i], uv[(i + 1) % uv.len()]);
+ a.0 * b.1 - b.0 * a.1
+ })
+ .sum();
+ let s = face.surface();
+ let Some(pi) = pieces.iter().position(|f| {
+ let ws = f.absolute_boundaries();
+ ws.first().is_some_and(|o| inside(&loop_uv(&s, o), uv0)) && !ws.iter().skip(1).any(|h| inside(&loop_uv(&s, h), uv0))
+ }) else {
+ continue;
+ };
+ let Some(host) = pieces.get(pi).cloned() else { continue };
+ // The new loop counter-clockwise in parameters (an outer loop); its reverse a hole.
+ let ccw: mt::Wire = if area > 0.0 { vec![e.clone()].into() } else { vec![e.inverse()].into() };
+ let hole: mt::Wire = ccw.inverse();
+ let ws = host.absolute_boundaries().clone();
+ let mut outer_ws = vec![];
+ let mut inner_ws = vec![ccw.clone()];
+ for (k, w) in ws.iter().enumerate() {
+ let q = loop_uv(&s, w).first().copied();
+ if k > 0 && q.is_some_and(|q| inside(&uv, q)) {
+ inner_ws.push(w.clone());
+ } else {
+ outer_ws.push(w.clone());
+ }
+ }
+ outer_ws.push(hole);
+ let a = face_like(&host, outer_ws);
+ let b = face_like(&host, inner_ws);
+ pieces.splice(pi..=pi, [a, b]);
+ made += 1;
+ continue;
+ }
+ // An open line: it must end on the boundary at two crossings.
+ let (Some(&(pa, _)), Some(&(pb, _))) = (ch.pts.first(), ch.pts.last()) else { continue };
+ let near =
+ |p: mt::Point3| hits.iter().filter(|h| h.p.distance(p) <= snap).min_by(|x, y| x.p.distance(p).total_cmp(&y.p.distance(p))).cloned();
+ let (Some(ha), Some(hb)) = (near(pa), near(pb)) else { continue };
+ // Cut the boundary edges (an edge may already have been cut by an earlier line).
+ let vert = |h: &Hit, cuts: &mut Vec<(mt::Edge, (mt::Edge, mt::Edge))>| -> Result<mt::Vertex> {
+ // The current edge holding the hit: the original, or a piece of it.
+ let mut e = h.edge.clone();
+ for (c, (x, y)) in cuts.iter() {
+ if c.id() == e.id() || c.id() == e.inverse().id() {
+ let on = |pc: &mt::Edge| {
+ let cc = pc.curve();
+ let (t0, t1) = cc.range_tuple();
+ (t0.min(t1) - 1e-12..=t0.max(t1) + 1e-12).contains(&h.t)
+ };
+ e = if on(x) { x.clone() } else { y.clone() };
+ }
+ }
+ let (v, cut) = cut_edge(&e, h.t, h.p, tol)?;
+ if let Some(pair) = cut {
+ let abs = if e.orientation() { e.clone() } else { e.inverse() };
+ cuts.push((abs, pair));
+ }
+ Ok(v)
+ };
+ let va = vert(&ha, &mut all_cuts)?;
+ let vb = vert(&hb, &mut all_cuts)?;
+ if va.id() == vb.id() {
+ continue;
+ }
+ pieces = pieces.iter().map(|f| recut(f, &all_cuts)).collect();
+ let mut pts: Vec<mt::Point3> = ch.pts.iter().map(|x| x.0).collect();
+ if let Some(f) = pts.first_mut() {
+ *f = va.point();
+ }
+ if let Some(l) = pts.last_mut() {
+ *l = vb.point();
+ }
+ // A line from one loop of a piece to another (into a hole): the two loops become one,
+ // joined by the line run both ways; a later line divides it.
+ let in_loop = |w: &mt::Wire, v: &mt::Vertex| w.edge_iter().any(|e| e.front().id() == v.id());
+ if let Some(pi) = pieces.iter().position(|f| {
+ let ws = f.absolute_boundaries();
+ ws.iter().any(|w| in_loop(w, &va)) && ws.iter().any(|w| in_loop(w, &vb)) && !ws.iter().any(|w| in_loop(w, &va) && in_loop(w, &vb))
+ }) && let Some(host) = pieces.get(pi).cloned()
+ {
+ let ws = host.absolute_boundaries().clone();
+ let (Some(wa_i), Some(wb_i)) = (ws.iter().position(|w| in_loop(w, &va)), ws.iter().position(|w| in_loop(w, &vb))) else { continue };
+ let from = |w: &mt::Wire, v: &mt::Vertex| -> Vec<mt::Edge> {
+ let edges: Vec<mt::Edge> = w.edge_iter().cloned().collect();
+ let k = edges.iter().position(|e| e.front().id() == v.id()).unwrap_or(0);
+ edges.iter().skip(k).chain(edges.iter().take(k)).cloned().collect()
+ };
+ let (Some(w1), Some(w2)) = (ws.get(wa_i), ws.get(wb_i)) else { continue };
+ let slit = mt::Edge::new_unchecked(&va, &vb, fit(&pts, size)?);
+ let mut joined = from(w1, &va);
+ joined.push(slit.clone());
+ joined.extend(from(w2, &vb));
+ joined.push(slit.inverse());
+ // The outer loop first.
+ let others = ws.iter().enumerate().filter(|(k, _)| *k != wa_i && *k != wb_i).map(|(_, w)| w.clone());
+ let joined: mt::Wire = joined.into();
+ let loops: Vec<mt::Wire> = if wa_i == 0 || wb_i == 0 {
+ std::iter::once(joined).chain(others).collect()
+ } else {
+ others.chain(std::iter::once(joined)).collect()
+ };
+ pieces.splice(pi..=pi, [face_like(&host, loops)]);
+ continue;
+ }
+ // The piece whose loop passes both vertices.
+ let Some(pi) = pieces.iter().position(|f| {
+ f.absolute_boundaries().iter().any(|w| {
+ let ids: Vec<_> = w.edge_iter().map(|e| e.front().id()).collect();
+ ids.contains(&va.id()) && ids.contains(&vb.id())
+ })
+ }) else {
+ continue;
+ };
+ let Some(host) = pieces.get(pi).cloned() else { continue };
+ let ws = host.absolute_boundaries().clone();
+ let Some(wi) = ws.iter().position(|w| {
+ let ids: Vec<_> = w.edge_iter().map(|e| e.front().id()).collect();
+ ids.contains(&va.id()) && ids.contains(&vb.id())
+ }) else {
+ continue;
+ };
+ let Some(w) = ws.get(wi) else { continue };
+ let edges: Vec<mt::Edge> = w.edge_iter().cloned().collect();
+ let n = edges.len();
+ let (Some(ia), Some(ib)) = (edges.iter().position(|e| e.front().id() == va.id()), edges.iter().position(|e| e.front().id() == vb.id()))
+ else {
+ continue;
+ };
+ let split = mt::Edge::new_unchecked(&va, &vb, fit(&pts, size)?);
+ let run = |from: usize, to: usize| -> Vec<mt::Edge> {
+ let mut out = Vec::new();
+ let mut i = from;
+ while i != to {
+ if let Some(e) = edges.get(i) {
+ out.push(e.clone());
+ }
+ i = (i + 1) % n;
+ }
+ out
+ };
+ // Piece A: a → b along the loop, back along the split. Piece B: b → a, then the split.
+ let mut wa = run(ia, ib);
+ wa.push(split.inverse());
+ let mut wb = run(ib, ia);
+ wb.push(split.clone());
+ let (wa, wb): (mt::Wire, mt::Wire) = (wa.into(), wb.into());
+ if !wa.is_closed() || !wb.is_closed() {
+ return Err(KernelError::Failed("split loops do not close".into()));
+ }
+ // Other loops go to the piece on their side.
+ let s = face.surface();
+ let (pa_poly, pb_poly) = (loop_uv(&s, &wa), loop_uv(&s, &wb));
+ let (mut la, mut lb) = (vec![wa], vec![wb]);
+ for (k, other) in ws.iter().enumerate() {
+ if k == wi {
+ continue;
+ }
+ let q = loop_uv(&s, other).first().copied();
+ match q {
+ Some(q) if inside(&pa_poly, q) => la.push(other.clone()),
+ Some(q) if inside(&pb_poly, q) => lb.push(other.clone()),
+ _ => return Err(KernelError::Failed("a hole meets the split line".into())),
+ }
+ }
+ let (a, b) = (face_like(&host, la), face_like(&host, lb));
+ pieces.splice(pi..=pi, [a, b]);
+ made += 1;
+ }
+ if made == 0 {
+ return Ok(0);
+ }
+ // Neighbours take the cut edges.
+ let rest: Vec<mt::Face> = faces.iter().enumerate().filter(|(k, _)| *k != fi).map(|(_, f)| recut(f, &all_cuts)).collect();
+ let mut out = Vec::with_capacity(rest.len() + pieces.len());
+ out.extend(rest.iter().take(fi).cloned());
+ out.extend(pieces);
+ out.extend(rest.iter().skip(fi).cloned());
+ *faces = out;
+ Ok(made)
+}
+
+/// Split the given faces (indices in `body`'s face order) where the tool meets them. The solid
+/// is unchanged; faces the tool misses stay whole.
+pub fn split_faces(body: &Body, faces: &[usize], tool: &SplitTool) -> Result<Body> {
+ body.require_brep("split face")?;
+ let size = body.size();
+ let fields: Vec<Field> = match tool {
+ SplitTool::Plane(p) => {
+ let n = p.normal();
+ vec![Field::Plane { o: p.origin, n }]
+ }
+ 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())]
+ }
+ SplitTool::Curves { plane, curves } => {
+ if curves.iter().any(|c| c.len() < 2 || c.iter().any(|p| !(p.x.is_finite() && p.y.is_finite()))) {
+ return Err(KernelError::Invalid("split curves need at least two finite points each".into()));
+ }
+ curves.iter().map(|c| Field::Curve { plane: *plane, pts: c.clone() }).collect()
+ }
+ };
+ let total = body.solid.face_iter().count();
+ if faces.iter().any(|f| *f >= total) {
+ return Err(KernelError::Invalid("no such face".into()));
+ }
+ guard("split face", || {
+ let shells: Vec<mt::Shell> = body.solid.boundaries().clone();
+ // Faces to split, by shell, tracked as faces are replaced by pieces.
+ let mut out_shells = Vec::new();
+ let mut base = 0;
+ let mut made = 0;
+ for sh in shells {
+ let mut fs: Vec<mt::Face> = sh.face_iter().cloned().collect();
+ let mut targets: Vec<mt::FaceID> =
+ faces.iter().filter(|f| **f >= base && **f < base + fs.len()).filter_map(|f| fs.get(*f - base).map(mt::Face::id)).collect();
+ base += fs.len();
+ for g in &fields {
+ let mut next_targets = Vec::new();
+ for id in targets.clone() {
+ let Some(fi) = fs.iter().position(|f| f.id() == id) else { continue };
+ let before: Vec<mt::FaceID> = fs.iter().map(mt::Face::id).collect();
+ made += split_one(&mut fs, fi, g, size)?;
+ // The face and any pieces of it stay targets for the next curve.
+ for f in &fs {
+ if !before.contains(&f.id()) || f.id() == id {
+ next_targets.push(f.id());
+ }
+ }
+ }
+ // Recut neighbours change ids too: keep pieces only.
+ targets = next_targets;
+ }
+ out_shells.push(mt::Shell::from(fs));
+ }
+ if made == 0 {
+ return Err(KernelError::Invalid("the tool does not cross the selected faces".into()));
+ }
+ let solid = mt::Solid::new_unchecked(out_shells);
+ Ok(Body { solid: std::sync::Arc::new(solid), mesh: None, color: body.color, paint: None })
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::{box_solid, cylinder, measure};
+
+ fn rel(a: f64, b: f64) -> f64 {
+ (a - b).abs() / b.abs().max(1e-9)
+ }
+
+ fn top(b: &Body, z: f64) -> usize {
+ b.faces(0.01).unwrap().iter().position(|f| (f.centroid.z - z).abs() < 1e-6 && f.plane_normal.is_some()).unwrap()
+ }
+
+ #[test]
+ fn plane_splits_a_box_top() {
+ let b = box_solid(Vec3::ZERO, Vec3::new(10.0, 20.0, 30.0)).unwrap();
+ let m0 = measure(&b).unwrap();
+ let pl = Plane::new(Vec3::new(4.0, 0.0, 0.0), Vec3::Y, Vec3::Z).unwrap();
+ let s = split_faces(&b, &[top(&b, 30.0)], &SplitTool::Plane(pl)).unwrap();
+ assert_eq!(s.face_count(), 7);
+ let m = measure(&s).unwrap();
+ assert!(rel(m.volume, m0.volume) < 1e-9 && rel(m.area, m0.area) < 1e-9);
+ let mut tops: Vec<f64> = s.faces(0.01).unwrap().iter().filter(|f| (f.centroid.z - 30.0).abs() < 1e-6).map(|f| f.area).collect();
+ tops.sort_by(f64::total_cmp);
+ assert!((tops[0] - 80.0).abs() < 1e-6 && (tops[1] - 120.0).abs() < 1e-6, "{tops:?}");
+ // The side faces the line ends on gained a vertex but kept their area.
+ assert!(s.faces(0.01).unwrap().iter().all(|f| f.area > 0.0));
+ // Later features work on the split body: a hole through the split top.
+ let pin = cylinder(Vec3::new(5.0, 10.0, -1.0), Vec3::Z, 2.0, 40.0).unwrap();
+ let holed = crate::boolean(&s, &pin, crate::BoolOp::Cut).unwrap().unwrap();
+ let v = measure(&holed).unwrap().volume;
+ assert!(rel(v, 6000.0 - std::f64::consts::PI * 4.0 * 30.0) < 1e-3, "{v}");
+ }
+
+ #[test]
+ fn sketch_curve_splits_a_cylinder_side_and_a_circle_splits_a_top() {
+ let c = cylinder(Vec3::ZERO, Vec3::Z, 10.0, 20.0).unwrap();
+ let m0 = measure(&c).unwrap();
+ let side = c.faces(0.01).unwrap().iter().position(|f| f.plane_normal.is_none()).unwrap();
+ // A horizontal line seen from the front (XZ sketch) at z = 5, swept along y.
+ let xz = Plane::XZ;
+ let tool = SplitTool::Curves { plane: xz, curves: vec![vec![Vec2::new(-20.0, 5.0), Vec2::new(20.0, 5.0)]] };
+ let s = split_faces(&c, &[side], &tool).unwrap();
+ let m = measure(&s).unwrap();
+ // (Measured on meshes: curved faces agree to about 1e-4.)
+ assert!(rel(m.volume, m0.volume) < 2e-4 && rel(m.area, m0.area) < 2e-4, "{} {} {} {}", m.volume, m0.volume, m.area, m0.area);
+ // The half side face splits at z = 5: a quarter and three quarters of its area.
+ let mut sides: Vec<f64> = s.faces(0.01).unwrap().iter().filter(|f| f.plane_normal.is_none()).map(|f| f.area).collect();
+ sides.sort_by(f64::total_cmp);
+ let half = std::f64::consts::PI * 10.0 * 20.0;
+ assert_eq!(sides.len(), 3);
+ assert!(rel(sides[0], half / 4.0) < 1e-3 && rel(sides[1], half * 0.75) < 1e-3 && rel(sides[2], half) < 1e-3, "{sides:?}");
+ assert!(s.face_count() > c.face_count());
+ // A smaller cylinder's side splits the top in a ring and a disc.
+ let pin = cylinder(Vec3::ZERO, Vec3::Z, 4.0, 40.0).unwrap();
+ let pin_side = pin.faces(0.01).unwrap().iter().position(|f| f.plane_normal.is_none()).unwrap();
+ let s = split_faces(&c, &[top(&c, 20.0)], &SplitTool::Face { body: &pin, face: pin_side }).unwrap();
+ let m = measure(&s).unwrap();
+ assert!(rel(m.volume, m0.volume) < 2e-4 && rel(m.area, m0.area) < 2e-4, "{} {}", m.area, m0.area);
+ let mut tops: Vec<f64> = s.faces(0.01).unwrap().iter().filter(|f| (f.centroid.z - 20.0).abs() < 1e-6).map(|f| f.area).collect();
+ tops.sort_by(f64::total_cmp);
+ let pi = std::f64::consts::PI;
+ assert!(rel(tops[0], pi * 16.0) < 1e-3 && rel(tops[1], pi * 84.0) < 1e-3, "{tops:?}");
+ }
+
+ /// A plane through a hole in a plate's top: the top splits in two, each piece holding
+ /// half of the hole's rim.
+ #[test]
+ fn plane_through_a_hole_splits_the_face() {
+ 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 b = crate::boolean(&plate, &pin, crate::BoolOp::Cut).unwrap().unwrap();
+ let m0 = measure(&b).unwrap();
+ let pl = Plane::new(Vec3::new(20.0, 0.0, 0.0), Vec3::Y, Vec3::Z).unwrap();
+ let s = split_faces(&b, &[top(&b, 10.0)], &SplitTool::Plane(pl)).unwrap();
+ let m = measure(&s).unwrap();
+ assert!(rel(m.volume, m0.volume) < 1e-4 && rel(m.area, m0.area) < 1e-4);
+ let tops: Vec<f64> = s.faces(0.01).unwrap().iter().filter(|f| (f.centroid.z - 10.0).abs() < 1e-6).map(|f| f.area).collect();
+ let half = (1200.0 - std::f64::consts::PI * 25.0) / 2.0;
+ assert_eq!(tops.len(), 2, "{tops:?}");
+ assert!(tops.iter().all(|a| rel(*a, half) < 1e-3), "{tops:?}");
+ }
+
+ #[test]
+ fn a_tool_that_misses_is_an_error() {
+ let b = box_solid(Vec3::ZERO, Vec3::new(10.0, 20.0, 30.0)).unwrap();
+ let pl = Plane::new(Vec3::new(50.0, 0.0, 0.0), Vec3::Y, Vec3::Z).unwrap();
+ assert!(split_faces(&b, &[0], &SplitTool::Plane(pl)).is_err());
+ assert!(split_faces(&b, &[99], &SplitTool::Plane(Plane::XY)).is_err());
+ }
+}