//! Trim: a surface body cut where a tool meets it (a plane, another body's face, or sketch //! curves swept onto it), keeping the side of a point or the regions points pick; and Mutual //! Trim: two surfaces cut by each other, each keeping its picked side, extended to meet first //! when one stops short of the other. use solidcraft_geom::Vec3; use truck_modeling as mt; use crate::body::Body; use crate::record::{Rebuild, rebuilt_body}; use crate::splitface::{SplitTool, ToolSide}; use crate::surface_extend::{ExtendLimit, ExtendMode, ExtendOptions}; use crate::surfaces::surface_body; use crate::{KernelError, Result, guard}; /// Most points one trim picks with. const MAX_PICKS: usize = 10_000; /// What a trim keeps. #[derive(Clone, Copy, Debug)] pub enum TrimKeep<'a> { /// Every piece on the side of the tool this point is on. A tool of several sketch curves /// has no one side: the region the point picks is kept. Side(Vec3), /// The regions the points pick (a region: the pieces that hang together once the tool has /// cut the body, each picked by the piece nearest a point). Regions(&'a [Vec3]), } impl TrimKeep<'_> { fn points(&self) -> &[Vec3] { match self { TrimKeep::Side(p) => std::slice::from_ref(p), TrimKeep::Regions(at) => at, } } fn check(&self) -> Result<()> { let at = self.points(); if at.is_empty() { return Err(KernelError::Invalid("pick what to keep".into())); } if at.len() > MAX_PICKS { return Err(KernelError::Invalid("too many points to keep".into())); } if at.iter().any(|p| !p.is_finite()) { return Err(KernelError::Invalid("a point to keep is not finite".into())); } Ok(()) } } /// A surface body trimmed by a tool: its faces are cut where the tool meets them and the /// pieces on the side of `keep` are kept. The result's history is over `[body]`. pub fn trim(body: &Body, tool: &SplitTool, keep: Vec3) -> Result { trim_keep(body, tool, TrimKeep::Side(keep)) } /// A surface body trimmed by a tool, keeping what `keep` says. Each kept face is the face it is /// a piece of (its history is over `[body]`). pub fn trim_keep(body: &Body, tool: &SplitTool, keep: TrimKeep) -> Result { body.require_brep("trim")?; keep.check()?; let total = body.solid.face_iter().count(); let all: Vec = (0..total).collect(); let (split, _) = crate::splitface::split_any(body, &all, tool)?; let one_side = match keep { TrimKeep::Side(p) if crate::splitface::field_count(tool)? == 1 => Some(crate::splitface::side_of_point(tool, p)?), _ => None, }; let picked = match one_side { Some(_) => Vec::new(), None => nearest_faces(&split, keep.points())?, }; guard("trim", || { let mut kept = Vec::new(); match one_side { Some(side) => { for f in split.solid.face_iter() { let x = crate::splitface::face_side(f, tool, split.size())?; if (x >= 0.0) == (side >= 0.0) { kept.push(f.clone()); } } } None => { let (region, count) = crate::splitface::regions(&split, tool)?; let mut wanted = vec![false; count]; for f in &picked { if let Some(w) = region.get(*f).and_then(|r| wanted.get_mut(*r)) { *w = true; } } for (f, r) in split.solid.face_iter().zip(®ion) { if wanted.get(*r).copied().unwrap_or(false) { kept.push(f.clone()); } } } } if kept.is_empty() { return Err(KernelError::Invalid("nothing is left on that side of the tool".into())); } // The kept pieces are the split's own; its history carries them back to `body`. let trimmed = rebuilt_body(surface_body(kept), &[&split.solid], &Rebuild::default()); Ok(crate::record::after(trimmed, &split, &crate::record::counts(&[body]))) }) } /// For each point, the face of `body` nearest it (over one tessellation). fn nearest_faces(body: &Body, at: &[Vec3]) -> Result> { let m = body.tessellate(body.size() * 2e-3)?; at.iter() .map(|p| { let mut best: Option<(f64, u32)> = None; for (t, f) in m.triangles.iter().zip(&m.tri_face) { let Some([a, b, c]) = m.tri(t) else { continue }; let d = ((a + b + c) / 3.0).dist(*p).min(a.dist(*p)).min(b.dist(*p)).min(c.dist(*p)); if best.is_none_or(|(x, _)| d < x) { best = Some((d, *f)); } } best.map(|(_, f)| f as usize).ok_or_else(|| KernelError::Invalid("no face there".into())) }) .collect() } /// Two surface bodies trimmed by each other: `a` cut where `b`'s surface (extended) meets it, /// keeping what `keep_a` says, and `b` by `a`'s, keeping `keep_b`. A surface that stops short of /// the other is extended to meet it when `extend` is set (naturally, its nearest boundary edge /// up to the other's surface), else that is an error; one that ends on the other is kept whole. /// Each body must be one face (its surface is the other's tool). The results' histories are over /// `[a]` and `[b]`. pub fn mutual_trim(a: &Body, b: &Body, keep_a: TrimKeep, keep_b: TrimKeep, extend: bool) -> Result<(Body, Body)> { for (x, name) in [(a, "first"), (b, "second")] { x.require_brep("trim")?; if !x.is_surface() { return Err(KernelError::Invalid(format!("the {name} body is a solid: a mutual trim takes two surfaces"))); } if x.face_count() != 1 { return Err(KernelError::Invalid(format!( "not supported yet: a mutual trim of a surface of more than one face (the {name} body has {}; trim it by one face instead)", x.face_count() ))); } } keep_a.check()?; keep_b.check()?; let ta = cut_by(a, &SplitTool::Face { body: b, face: 0 }, keep_a, extend, "first")?; let tb = cut_by(b, &SplitTool::Face { body: a, face: 0 }, keep_b, extend, "second")?; Ok((ta, tb)) } /// `x` trimmed by `tool` where the tool crosses it; whole where it ends on the tool; extended to /// the tool first (when `extend`) where it stops short of it. fn cut_by(x: &Body, tool: &SplitTool, keep: TrimKeep, extend: bool, name: &str) -> Result { let side = ToolSide::of(tool)?; let size = x.size(); let touch = size * 1e-6 + 1e-9; let m = x.tessellate(size * 2e-3)?; let (mut lo, mut hi, mut near) = (f64::INFINITY, f64::NEG_INFINITY, f64::INFINITY); for p in &m.positions { let v = side.at(*p); if !v.is_finite() { return Err(KernelError::Failed("the other surface cannot be evaluated over this one".into())); } lo = lo.min(v); hi = hi.max(v); near = near.min(v.abs()); } if lo < -touch && hi > touch { return trim_keep(x, tool, keep); } if near <= touch { return Ok(crate::boolean_record::operand(x, 0, &crate::record::counts(&[x]))); } if !extend { return Err(KernelError::Invalid(format!("the {name} surface does not reach the other one: extend it to meet"))); } let edge = nearest_boundary_edge(x, &side)?; let opts = ExtendOptions { mode: ExtendMode::Natural, limit: ExtendLimit::UpTo(tool), neighbours: true }; crate::extend_surface(x, &[edge], &opts) } /// A point in the middle of the boundary edge of `x` nearest the tool. fn nearest_boundary_edge(x: &Body, side: &ToolSide) -> Result { guard("trim", || { let mut uses: std::collections::HashMap = std::collections::HashMap::new(); for f in x.solid.face_iter() { for e in f.boundaries().iter().flat_map(|w| w.edge_iter()) { uses.entry(e.id()).or_insert((0, e.clone())).0 += 1; } } let mut best: Option<(f64, Vec3)> = None; for (count, e) in uses.values() { if *count != 1 { continue; } use mt::{BoundedCurve, ParametricCurve}; let c = e.curve(); let (t0, t1) = c.range_tuple(); let mid = crate::body::from_p3(c.subs(0.5 * (t0 + t1))); let d = side.at(mid).abs(); if d.is_finite() && best.is_none_or(|(b, _)| d < b) { best = Some((d, mid)); } } best.map(|(_, p)| p).ok_or_else(|| KernelError::Invalid("the surface has no boundary edge to extend".into())) }) } #[cfg(test)] mod tests { use super::*; use crate::history::{Change, FaceOrigin}; use crate::{extrude_sheet, measure, patch_region, stitch}; use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2}; use std::f64::consts::PI; fn rel(a: f64, b: f64) -> f64 { (a - b).abs() / b.abs().max(1e-12) } fn rect(plane: &Plane, u0: f64, v0: f64, u1: f64, v1: f64) -> Body { let outer = Loop2::polygon(&[Vec2::new(u0, v0), Vec2::new(u1, v0), Vec2::new(u1, v1), Vec2::new(u0, v1)]); patch_region(plane, &Region2 { outer, holes: vec![] }).unwrap() } fn area(b: &Body) -> f64 { measure(b).unwrap().area } /// A U-shaped sheet (legs x = 0 and x = 10, 10 high, a base along y = 0, 10 deep in z) cut /// by the plane y = 5: one side keeps both legs' tops, one region pick only one of them, two /// picks both again. #[test] fn regions_keep_what_the_points_pick() { let chain = vec![ Seg2::Line { a: Vec2::new(0.0, 10.0), b: Vec2::new(0.0, 0.0) }, Seg2::Line { a: Vec2::new(0.0, 0.0), b: Vec2::new(10.0, 0.0) }, Seg2::Line { a: Vec2::new(10.0, 0.0), b: Vec2::new(10.0, 10.0) }, ]; let u = extrude_sheet(&Plane::XY, &[chain], 0.0, 10.0).unwrap(); let cut = SplitTool::Plane(Plane::new(Vec3::new(0.0, 5.0, 0.0), Vec3::X, Vec3::Z).unwrap()); let side = trim(&u, &cut, Vec3::new(0.0, 8.0, 5.0)).unwrap(); assert!(rel(area(&side), 100.0) < 1e-9, "{}", area(&side)); let one = trim_keep(&u, &cut, TrimKeep::Regions(&[Vec3::new(0.0, 8.0, 5.0)])).unwrap(); assert!(rel(area(&one), 50.0) < 1e-9, "{}", area(&one)); let both = trim_keep(&u, &cut, TrimKeep::Regions(&[Vec3::new(0.0, 8.0, 5.0), Vec3::new(10.0, 9.0, 2.0)])).unwrap(); assert!(rel(area(&both), 100.0) < 1e-9, "{}", area(&both)); // The base side is one region: its three faces hang together. let base = trim_keep(&u, &cut, TrimKeep::Regions(&[Vec3::new(5.0, 0.0, 5.0)])).unwrap(); assert!(rel(area(&base), 200.0) < 1e-9 && base.face_count() == 3, "{}", area(&base)); // Each kept face is a piece of the face it was cut from. let h = one.history().unwrap(); assert_eq!(h.operands, 1); assert!( h.faces.iter().all(|f| f.change == Change::Modified && matches!(f.origins.as_slice(), [FaceOrigin::Face { operand: 0, .. }])), "{h:?}" ); } /// A 10 × 10 square cut by two sketch lines (x = 3 and x = 7): a side is no answer for two /// curves, so a point picks its region; two picks keep the two outer strips. #[test] fn several_curves_cut_regions() { let sq = rect(&Plane::XY, 0.0, 0.0, 10.0, 10.0); let lines = vec![ vec![Seg2::Line { a: Vec2::new(3.0, -5.0), b: Vec2::new(3.0, 15.0) }], vec![Seg2::Line { a: Vec2::new(7.0, -5.0), b: Vec2::new(7.0, 15.0) }], ]; let tool = SplitTool::Curves { plane: Plane { origin: Vec3::new(0.0, 0.0, 5.0), ..Plane::XY }, curves: lines, along: None }; let mid = trim(&sq, &tool, Vec3::new(5.0, 5.0, 0.0)).unwrap(); assert!(rel(area(&mid), 40.0) < 1e-9, "{}", area(&mid)); let outer = trim_keep(&sq, &tool, TrimKeep::Regions(&[Vec3::new(1.0, 5.0, 0.0), Vec3::new(9.0, 5.0, 0.0)])).unwrap(); assert!(rel(area(&outer), 60.0) < 1e-9 && outer.face_count() == 2, "{}", area(&outer)); } /// A line sketched 10 above a 20 × 20 sheet at x = 5, swept along (1, 0, −1): it meets the /// sheet at x = 15, so the side of x = 0 keeps 15 × 20. A direction along the sketch plane /// is refused. #[test] fn curves_swept_aslant() { let sq = rect(&Plane::XY, 0.0, 0.0, 20.0, 20.0); let plane = Plane { origin: Vec3::new(0.0, 0.0, 10.0), ..Plane::XY }; let curves = vec![vec![Seg2::Line { a: Vec2::new(5.0, -5.0), b: Vec2::new(5.0, 25.0) }]]; let tool = SplitTool::Curves { plane, curves: curves.clone(), along: Some(Vec3::new(1.0, 0.0, -1.0)) }; let t = trim(&sq, &tool, Vec3::new(1.0, 5.0, 0.0)).unwrap(); assert!(rel(area(&t), 300.0) < 1e-9, "{}", area(&t)); let flat = SplitTool::Curves { plane, curves, along: Some(Vec3::X) }; assert!(trim(&sq, &flat, Vec3::new(1.0, 5.0, 0.0)).is_err()); } /// The slot |x| ≤ 3 (a straight run z = 12…28 and round ends) sketched in front of a half /// cylinder (radius 10 about Z, y ≥ 0, 40 high) and swept along the sketch's normal: the /// piece inside it is ∫∫ R / √(R² − x²) dx dz over the slot (the straight run 16 · 2R·asin(3/R), /// the two round ends one disc), the piece outside the rest of 10π · 40. #[test] fn a_slot_projected_onto_a_cylinder() { let r: f64 = 10.0; let half = extrude_sheet(&Plane::XY, &[vec![Seg2::Arc { center: Vec2::ZERO, radius: r, start: 0.0, sweep: PI }]], 0.0, 40.0).unwrap(); let a: f64 = 3.0; let slot = vec![ Seg2::Line { a: Vec2::new(a, 12.0), b: Vec2::new(a, 28.0) }, Seg2::Arc { center: Vec2::new(0.0, 28.0), radius: a, start: 0.0, sweep: PI }, Seg2::Line { a: Vec2::new(-a, 28.0), b: Vec2::new(-a, 12.0) }, Seg2::Arc { center: Vec2::new(0.0, 12.0), radius: a, start: PI, sweep: PI }, ]; let front = Plane { y: Vec3::Z, ..Plane::XZ }; let tool = SplitTool::Curves { plane: front, curves: vec![slot], along: None }; // The round ends: x = a·sin φ, the disc's height 2a·cos φ, dx = a·cos φ dφ (Simpson). let n = 4000; let f = |phi: f64| 2.0 * a * a * phi.cos().powi(2) * r / (r * r - (a * phi.sin()).powi(2)).sqrt(); let h = PI / n as f64; let ends = (0..=n) .map(|k| { let w = if k == 0 || k == n { 1.0 } else if k % 2 == 1 { 4.0 } else { 2.0 }; w * f(-PI / 2.0 + h * k as f64) }) .sum::() * h / 3.0; let inside = 16.0 * 2.0 * r * (a / r).asin() + ends; let on = Vec3::new(0.0, r, 20.0); let kept = trim(&half, &tool, on).unwrap(); eprintln!("slot on the cylinder: {} measured, {inside} analytic", area(&kept)); // (Measured on meshes.) assert!(rel(area(&kept), inside) < 1e-3, "{} vs {inside}", area(&kept)); let rest = trim(&half, &tool, Vec3::new(r, 0.0, 20.0)).unwrap(); let all = PI * r * 40.0; assert!(rel(area(&rest), all - inside) < 1e-3, "{} vs {}", area(&rest), all - inside); let picked = trim_keep(&half, &tool, TrimKeep::Regions(&[on])).unwrap(); assert!(rel(area(&picked), area(&kept)) < 1e-9); } /// Two 20 × 10 sheets crossing at right angles (z = 0 and x = 0, both y = 0…10) trimmed by /// each other, each keeping its x > 0 / z > 0 half, and stitched: an L of two faces sharing /// their edge, 200 in area. #[test] fn crossing_sheets_trim_each_other_into_an_l() { let a = rect(&Plane::XY, -10.0, 0.0, 10.0, 10.0); let yz = Plane::new(Vec3::ZERO, Vec3::Y, Vec3::Z).unwrap(); let b = rect(&yz, 0.0, -10.0, 10.0, 10.0); let (ta, tb) = mutual_trim(&a, &b, TrimKeep::Side(Vec3::new(5.0, 5.0, 0.0)), TrimKeep::Side(Vec3::new(0.0, 5.0, 5.0)), false).unwrap(); assert!(rel(area(&ta), 100.0) < 1e-9 && rel(area(&tb), 100.0) < 1e-9); let l = stitch(&[&ta, &tb], 0.0).unwrap(); assert_eq!((l.face_count(), l.edge_count()), (2, 7), "one shared edge"); assert!(rel(area(&l), 200.0) < 1e-9); assert!(l.is_surface()); let bb = measure(&l).unwrap().bbox; assert!(bb.min.x.abs() < 1e-9 && bb.min.z.abs() < 1e-9 && (bb.max.x - 10.0).abs() < 1e-9 && (bb.max.z - 10.0).abs() < 1e-9, "{bb:?}"); // The pieces are the sheets' faces. for t in [&ta, &tb] { let h = t.history().unwrap(); assert!(matches!(h.faces[0].origins.as_slice(), [FaceOrigin::Face { operand: 0, face: 0 }]) && h.faces[0].change == Change::Modified); } } /// A sheet that stops 3 short of the other (x = 0, z = 3…10) is refused until extended to /// meet it; extended, the two still make the L. #[test] fn a_short_sheet_is_extended_to_meet() { let a = rect(&Plane::XY, -10.0, 0.0, 10.0, 10.0); let yz = Plane::new(Vec3::ZERO, Vec3::Y, Vec3::Z).unwrap(); let b = rect(&yz, 0.0, 3.0, 10.0, 10.0); let (ka, kb) = (TrimKeep::Side(Vec3::new(5.0, 5.0, 0.0)), TrimKeep::Side(Vec3::new(0.0, 5.0, 5.0))); let e = mutual_trim(&a, &b, ka, kb, false).unwrap_err().to_string(); assert!(e.contains("extend"), "{e}"); let (ta, tb) = mutual_trim(&a, &b, ka, kb, true).unwrap(); assert!(rel(area(&ta), 100.0) < 1e-9 && rel(area(&tb), 100.0) < 1e-6, "{} {}", area(&ta), area(&tb)); let l = stitch(&[&ta, &tb], 0.0).unwrap(); assert_eq!((l.face_count(), l.edge_count()), (2, 7)); } #[test] fn hostile_trims_are_refused() { let a = rect(&Plane::XY, 0.0, 0.0, 10.0, 10.0); let cut = SplitTool::Plane(Plane::new(Vec3::new(3.0, 0.0, 0.0), Vec3::Y, Vec3::Z).unwrap()); assert!(trim_keep(&a, &cut, TrimKeep::Regions(&[])).is_err()); assert!(trim_keep(&a, &cut, TrimKeep::Regions(&[Vec3::new(f64::NAN, 0.0, 0.0)])).is_err()); assert!(trim(&a, &cut, Vec3::new(f64::INFINITY, 0.0, 0.0)).is_err()); let many = vec![Vec3::ZERO; MAX_PICKS + 1]; assert!(trim_keep(&a, &cut, TrimKeep::Regions(&many)).is_err()); let solid = crate::box_solid(Vec3::ZERO, Vec3::new(1.0, 1.0, 1.0)).unwrap(); assert!(mutual_trim(&a, &solid, TrimKeep::Side(Vec3::ZERO), TrimKeep::Side(Vec3::ZERO), true).is_err()); let chain = vec![Seg2::Line { a: Vec2::new(0.0, 0.0), b: Vec2::new(5.0, 0.0) }, Seg2::Line { a: Vec2::new(5.0, 0.0), b: Vec2::new(5.0, 5.0) }]; let two = extrude_sheet(&Plane::XY, &[chain], 0.0, 5.0).unwrap(); let e = mutual_trim(&a, &two, TrimKeep::Side(Vec3::ZERO), TrimKeep::Side(Vec3::ZERO), true).unwrap_err().to_string(); assert!(e.contains("not supported yet"), "{e}"); } }