Files
solidcraft/crates/kernel/src/surface_trim.rs
T
jyvikoandClaude Opus 5.5 9a508571fd Wave 215/509: brep: an edge on a line, circle or ellipse carries the NURBS form SMLib holds it as (and 1 more)
2 commits, squashed; the originals stay reachable from tag archive/merge-main-develop.

- b1326e48d jyviko: brep: an edge on a line, circle or ellipse carries the NURBS form SMLib holds it as
- 6adba90e2 jyviko: solidcraft-smlib: circle edges on their NURBS form, SMLib's trims kept on them (fork deec9cb)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
2026-10-22 17:35:54 -04:00

396 lines
20 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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 solidcraft_geom::brep::eval::CurveEval;
use crate::body::Body;
use crate::splitface::{SplitTool, ToolSide};
use crate::surface_extend::{ExtendLimit, ExtendMode, ExtendOptions};
use crate::{KernelError, Result};
/// 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<Body> {
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]`).
///
/// The body is split where the tool meets it ([`crate::splitface::split_any`]), each piece's side
/// read at a point inside it ([`face_sides`]), and the pieces not kept are taken away ([`crate::remove_faces`]); both carry their history, so the kept
/// faces are the body's own, cut.
pub fn trim_keep(body: &Body, tool: &SplitTool, keep: TrimKeep) -> Result<Body> {
body.require_brep("trim")?;
keep.check()?;
let all: Vec<usize> = (0..body.face_count()).collect();
let (split, _) = crate::splitface::split_any(body, &all, tool)?;
let kept: Vec<bool> = match keep {
TrimKeep::Side(p) if crate::splitface::field_count(tool)? == 1 => {
let side = ToolSide::of(tool, body)?;
let want = side.at(p);
if !want.is_finite() {
return Err(KernelError::Invalid("the side of the tool the point is on can't be told".into()));
}
face_sides(&split, &side)?.into_iter().map(|x| (x >= 0.0) == (want >= 0.0)).collect()
}
_ => {
let picked = nearest_faces(&split, keep.points())?;
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;
}
}
region.iter().map(|r| wanted.get(*r).copied().unwrap_or(false)).collect()
}
};
if !kept.iter().any(|k| *k) {
return Err(KernelError::Invalid("nothing is left on that side of the tool".into()));
}
let dropped: Vec<usize> = kept.iter().enumerate().filter(|(_, k)| !**k).map(|(i, _)| i).collect();
let trimmed = if dropped.is_empty() { split.clone() } else { crate::remove_faces(&split, &dropped)? };
// The kept pieces are the split's own; its history carries them back to `body`.
Ok(crate::record::after(trimmed, &split, &crate::record::counts(&[body])))
}
/// The side of the tool each face of `body` (in its face order) lies on: the tool's field at a
/// point inside the face, on its surface and inside its trims (SMLib's
/// `CalculateAnInternalPoint`). Once the tool has cut the body each piece lies on one side, so
/// one such point says which.
fn face_sides(body: &Body, side: &ToolSide) -> Result<Vec<f64>> {
let (sm, order) = crate::native::smlib_body_ordered(body)?;
let order = order.ok_or_else(|| KernelError::Failed("trim: SMLib numbers the pieces' faces differently from their record".into()))?;
let points = sm.face_points().map_err(|e| KernelError::Failed(format!("SMLib trim: a point inside each piece: {e}")))?;
let mut sides = vec![f64::NAN; points.len()];
for (i, p) in points.iter().enumerate() {
let face = if order.faces.is_empty() { i } else { order.faces.get(i).copied().unwrap_or(usize::MAX) };
let slot = sides.get_mut(face).ok_or_else(|| KernelError::Failed("trim: a piece's face lies outside the body".into()))?;
*slot = side.at(Vec3::new(p[0], p[1], p[2]));
}
if sides.iter().any(|x| !x.is_finite()) {
return Err(KernelError::Failed("trim: the side of a piece can't be told".into()));
}
Ok(sides)
}
/// For each point, the face of `body` nearest it (over one tessellation).
fn nearest_faces(body: &Body, at: &[Vec3]) -> Result<Vec<usize>> {
let m = body.mesh(&crate::MeshTolerance::chord(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<Body> {
let side = ToolSide::of(tool, x)?;
let size = x.size();
let touch = size * 1e-6 + 1e-9;
let m = x.mesh(&crate::MeshTolerance::chord(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: of the record's edges
/// that one face uses once, the one whose middle (half-way along its interval) is nearest.
fn nearest_boundary_edge(x: &Body, side: &ToolSide) -> Result<Vec3> {
let record = crate::native::brep_record(x)?;
let mut best: Option<(f64, Vec3)> = None;
for e in record.edges.iter().filter(|e| e.uses.len() == 1) {
let curve = CurveEval::new(e.parameters()).map_err(|err| KernelError::Failed(format!("trim: an edge's curve: {err}")))?;
let Some(mid) = curve.point(0.5 * (e.interval[0] + e.interval[1])) else { continue };
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::<f64>()
* 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}");
}
}