From 24134d2ed0fa396eebd9f7ff266b8ceb26bdafdc Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Sat, 31 Oct 2026 00:01:07 -0400 Subject: [PATCH] Wave 463/509: kernel: Extend grows a surface of several faces face by face (and 3 more) 4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - dd8867414 jyviko: kernel: Extend grows a surface of several faces face by face - 48a757827 jyviko: kernel: Split Body by a face of a smooth sheet cuts with the whole sheet - 3421a8ef0 jyviko: Tests: a cylinder strip's run-offs are 100 pi + 100 to 1e-6, SMLib's exact area - 20d5d8b13 jyviko: kernel: an extension SMLib cannot make exact says so, naming the length asked Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ --- crates/engine/src/cmd/surface.rs | 11 +- crates/kernel/src/splitface.rs | 154 +++++++++- crates/kernel/src/surface_extend.rs | 273 +++++++++++++++--- crates/kernel/src/surfaces.rs | 2 +- crates/smlib/src/ffi/split.rs | 26 +- crates/smlib/src/split.rs | 15 + .../expected.json | 4 +- tests/kernel-cases/booleans/KNOWN_FAILING | 1 - 8 files changed, 431 insertions(+), 55 deletions(-) diff --git a/crates/engine/src/cmd/surface.rs b/crates/engine/src/cmd/surface.rs index e1c054a71..4d1d01f6a 100644 --- a/crates/engine/src/cmd/surface.rs +++ b/crates/engine/src/cmd/surface.rs @@ -1296,8 +1296,8 @@ mod tests { /// along a straight edge, 20 long: each SMLib's G1 or G2 extension of the surface, so the /// strip stays one face. The distance is measured across the surface (the run-off's section /// is 5 long, whatever its curvature) and the strip is its section swept 20 along z, so each - /// run-off adds 5 × 20: 10 · π/2 · 20 + 100. - /// Undo, redo and reopening; the default saves nothing new. + /// run-off adds 5 × 20: 10 · π/2 · 20 + 100 = 414.159265, exact to 1e-6. Areas are SMLib's, + /// integrated on the exact surfaces. Undo, redo and reopening; the default saves nothing new. #[test] fn extend_a_cylinder_strip_every_way() { let pi = std::f64::consts::PI; @@ -1306,7 +1306,7 @@ mod tests { let top = [10.0 * (pi / 4.0).cos(), 10.0 * (pi / 4.0).sin(), 20.0]; run(&mut s, "surface.extend", json!({"body": "Strip", "edges": [top], "distance": "5 mm", "name": "Up"})); let want = 10.0 * pi / 2.0 * 25.0; - assert!((area(&s, "Strip") - want).abs() < want * 1e-3, "{} vs {want}", area(&s, "Strip")); // (measured on meshes) + assert!((area(&s, "Strip") - want).abs() < want * 1e-3, "{} vs {want}", area(&s, "Strip")); assert_eq!(s.world_state().unwrap().body("Strip").unwrap().body.face_count(), 1); let saved = s.doc.to_json(); assert!(!saved.contains("\"mode\"") && !saved.contains("\"up_to\"") && !saved.contains("\"neighbours\""), "the default saves as before"); @@ -1319,14 +1319,15 @@ mod tests { run(&mut s, "surface.extend", json!({"body": "Strip", "edges": [top], "up_to": {"origin": [0, 0, 30], "normal": [0, 0, 1]}})); let want = 10.0 * pi / 2.0 * 30.0; - assert!((area(&s, "Strip") - want).abs() < want * 1e-3, "{} vs {want}", area(&s, "Strip")); // (measured on meshes) + assert!((area(&s, "Strip") - want).abs() < want * 1e-3, "{} vs {want}", area(&s, "Strip")); run(&mut s, "edit.undo", json!({})); let side = [0.0, 10.0, 10.0]; for mode in ["tangent", "curvature"] { run(&mut s, "surface.extend", json!({"body": "Strip", "edges": [side], "distance": 5, "mode": mode})); let want = 10.0 * pi / 2.0 * 20.0 + 5.0 * 20.0; - assert!((area(&s, "Strip") - want).abs() < want * 1e-3, "{mode}: {} vs {want}", area(&s, "Strip")); // (measured on meshes) + // SMLib's area, integrated on the exact surface to 1e-8: the run-off is exactly 5 long. + assert!((area(&s, "Strip") - want).abs() < want * 1e-6, "{mode}: {} vs {want}", area(&s, "Strip")); let cold = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap()); assert!((area(&cold, "Strip") - area(&s, "Strip")).abs() < 1e-9, "{mode}"); run(&mut s, "edit.undo", json!({})); diff --git a/crates/kernel/src/splitface.rs b/crates/kernel/src/splitface.rs index 219c813a2..ebf9765f9 100644 --- a/crates/kernel/src/splitface.rs +++ b/crates/kernel/src/splitface.rs @@ -33,7 +33,9 @@ use crate::{KernelError, Result, guard, record}; pub enum SplitTool<'a> { /// A plane (unbounded). Plane(Plane), - /// The surface of another body's face (`face` in that body's face order), extended. + /// The surface of another body's face (`face` in that body's face order), extended. Split + /// Body by a face of a surface body joined tangentially to others cuts with their smooth + /// sheet as it is ([`split_body`]). Face { body: &'a Body, face: usize }, /// Sketch curves (chains of segments in `plane`) swept along `along` (none: the plane's /// normal); each curve splits on its own, an open one extended past its ends. @@ -535,29 +537,51 @@ fn new_lines(split: &Body, h: &History) -> Result>> { } /// Split a body into the parts on either side of a tool: a plane, another face's surface -/// (extended), or one sketch line swept along its direction. Every part is closed with the piece +/// (extended; a face of a surface body joined tangentially to others: their smooth sheet as it +/// is, which must cross the body), or one sketch line swept along its direction. Every part is closed with the piece /// of the tool's surface inside the body; parts on the tool's back come first, each side's in /// face order. A body the tool misses comes back whole. Each part's history is over `[body]`: /// its faces the body's (or pieces of them), the section new. pub fn split_body(body: &Body, tool: &SplitTool) -> Result> { let _span = solidcraft_profile::span("kernel", "split_body"); - const NAME: &str = "split body"; - body.require_brep(NAME)?; + body.require_brep(SPLIT_BODY)?; + if let SplitTool::Face { body: sheet, face } = tool { + let faces = smooth_sheet(sheet, *face)?; + if faces.len() > 1 { + return split_by_sheet(body, sheet, *face, &faces); + } + } let reach = reach_of(body); let groups = cutters(tool, &reach)?; let [group] = groups.as_slice() else { return Err(invalid("a body is split by a plane or a face")) }; let [patch] = group.as_slice() else { return Err(invalid("a body is split by a plane, a face or one sketch line")) }; + let Some(surface) = smlib_tools(std::slice::from_ref(group), &reach)?.pop() else { + return Ok(vec![crate::boolean_record::operand(body, 0, &record::counts(&[body]))]); + }; + sliced(body, patch.flip, |sb| sb.split_body(&surface)) +} + +const SPLIT_BODY: &str = "split body"; + +/// `body` cut in two by `cut` (SMLib's slice of its tagged copy, giving the parts behind and in +/// front of the tool's surface), the parts in the tool's order of sides (`flip`: the tool's side +/// is its surface's back), each solid of a part its own body. The body whole where the tool +/// cuts nothing. +fn sliced( + body: &Body, + flip: bool, + cut: impl FnOnce(&solidcraft_smlib::Brep) -> solidcraft_smlib::Result>, +) -> Result> { let counts = record::counts(&[body]); let whole = || crate::boolean_record::operand(body, 0, &counts); - let Some(surface) = smlib_tools(std::slice::from_ref(group), &reach)?.pop() else { return Ok(vec![whole()]) }; - guard(NAME, || { - let (sb, ob) = tagged(NAME, body)?; - let Some((back, front)) = sb.split_body(&surface).map_err(|e| failed(NAME, e))? else { return Ok(vec![whole()]) }; + guard(SPLIT_BODY, || { + let (sb, ob) = tagged(SPLIT_BODY, body)?; + let Some((back, front)) = cut(&sb).map_err(|e| failed(SPLIT_BODY, e))? else { return Ok(vec![whole()]) }; // SMLib's sides are the surface's; the tool's are the face's. - let sides = if patch.flip { [front, back] } else { [back, front] }; + let sides = if flip { [front, back] } else { [back, front] }; let (mut parts, mut cut) = (Vec::new(), false); for side in &sides { - let (part, h) = brought_back(NAME, body, &ob, side)?; + let (part, h) = brought_back(SPLIT_BODY, body, &ob, side)?; // The section comes from no face of the body. cut |= h.faces.iter().any(|f| f.origins.is_empty()); let part = part.with_checked_history(Some(h), &counts); @@ -574,6 +598,61 @@ pub fn split_body(body: &Body, tool: &SplitTool) -> Result> { Ok(if cut { parts } else { vec![whole()] }) }) } + +/// The faces of the surface body `sheet` joined to its face `face` tangentially, through edges +/// along which the faces' normals agree all along ([`crate::tangent_edge`], within the one angle +/// for smooth, [`crate::smooth_edges::ANGLE`]), and through those faces' tangent neighbours in +/// turn: the smooth surface the face is part of, in face order. Only `face` for a closed body +/// (a solid's face splits with its own surface extended). +fn smooth_sheet(sheet: &Body, face: usize) -> Result> { + sheet.require_brep("a split tool")?; + let r = sheet.record(); + if r.faces.get(face).is_none() { + return Err(invalid(format!("the tool body has no face {face}"))); + } + if !r.edges.iter().any(|e| e.uses.len() == 1) { + return Ok(vec![face]); + } + let sides = crate::surfaces::face_sides(r); + let sign = |f: usize| sides.get(f).map(|forward| if *forward { 1.0 } else { -1.0 }); + let mut joined = std::collections::BTreeSet::from([face]); + let mut todo = vec![face]; + while let Some(f) = todo.pop() { + let Some(this) = r.faces.get(f) else { continue }; + for l in &this.loops { + let brep::Loop::Edges { edges } = l else { continue }; + for u in edges { + let e = u.edge as usize; + let Some([a, b]) = r.edges.get(e).map(|edge| edge.uses.as_slice()) else { continue }; + let g = if a.face as usize == f { b.face } else { a.face } as usize; + if g == f || joined.contains(&g) { + continue; + } + if crate::tangent_edge::tangent_all_along(r, sign, e, crate::smooth_edges::ANGLE)? { + joined.insert(g); + todo.push(g); + } + } + } + } + Ok(joined.into_iter().collect()) +} + +/// `body` cut in two by the faces `faces` of the surface body `sheet` as they are (a smooth sheet +/// of several faces, bounded where they end), its sides those of `sheet`'s face `face`: SMLib's +/// slice by the sheet ([`solidcraft_smlib::Brep::split_body_by_sheet`]). A sheet that does not +/// cross the body cuts nothing. +fn split_by_sheet(body: &Body, sheet: &Body, face: usize, faces: &[usize]) -> Result> { + let picked: Vec<(usize, bool)> = faces.iter().map(|f| (*f, false)).collect(); + let c = crate::surfaces::Parts::of(sheet.record(), &picked)?.canonical()?; + let at = c.faces.iter().position(|p| faces.get(*p) == Some(&face)).ok_or_else(|| failed(SPLIT_BODY, "the tool face is not in its sheet"))?; + let (tool, order) = crate::native::smlib_record_ordered(&c.brep)?; + let order = order.ok_or_else(|| failed(SPLIT_BODY, "SMLib numbers the tool sheet's faces unlike its record"))?; + // SMLib's face `i` is the record's `order.faces[i]` (the same where none is given). + let k = if order.faces.is_empty() { Some(at) } else { order.faces.iter().position(|f| *f == at) }; + let k = k.ok_or_else(|| failed(SPLIT_BODY, "the tool face has no SMLib face"))?; + sliced(body, !sheet.face_forward(face), |sb| sb.split_body_by_sheet(&tool, k)) +} #[cfg(test)] mod tests { use super::*; @@ -700,6 +779,61 @@ mod tests { assert!(tops.iter().all(|a| rel(*a, half) < 1e-3), "{tops:?}"); } + /// Cubic spans of a spline, each with its x control points evenly spaced (so x runs linearly + /// along it and y is a cubic in x), meeting tangent, extruded from z = -5 to 15. + fn spans(ys: &[[f64; 4]]) -> Body { + let chain = ys + .iter() + .enumerate() + .map(|(i, y)| { + let x0 = -3.0 + 6.0 * i as f64; + let p = |k: usize| Vec2::new(x0 + 2.0 * k as f64, y[k]); + Seg2::Cubic { p0: p(0), p1: p(1), p2: p(2), p3: p(3) } + }) + .collect(); + crate::extrude_sheet(&Plane::XY, &[chain], -5.0, 15.0).unwrap() + } + + /// The face of `b` farthest to -x (by its centroid). + fn leftmost(b: &Body) -> usize { + let faces = b.faces(0.01).unwrap(); + (0..faces.len()).min_by(|i, j| faces[*i].centroid.x.total_cmp(&faces[*j].centroid.x)).unwrap() + } + + /// Split Body by a face of a smooth sheet cuts with the whole sheet (#3830): three spans + /// meeting tangent cross the cube 0…10, the face of the first alone does not. The part + /// under the spline is 10 ∫ y dx over x 0…10 (y a cubic in x on each span: Gauss–Legendre at + /// three points is exact). Two spans that end inside the cube cut nothing. + #[test] + fn a_face_of_a_smooth_sheet_splits_with_the_whole_sheet() { + let ys = [[5.0, 5.0, 4.0, 4.0], [4.0, 4.0, 6.0, 6.0], [6.0, 6.0, 5.0, 5.0]]; + let bern = |y: &[f64; 4], t: f64| { + let s = 1.0 - t; + y[0] * s * s * s + 3.0 * y[1] * s * s * t + 3.0 * y[2] * s * t * t + y[3] * t * t * t + }; + // ∫ y dx over the span's t0…t1 (dx = 6 dt). + let integral = |y: &[f64; 4], t0: f64, t1: f64| { + let (m, h) = (0.5 * (t0 + t1), 0.5 * (t1 - t0)); + let g = (0.6f64).sqrt(); + 6.0 * h * (5.0 * bern(y, m - h * g) + 8.0 * bern(y, m) + 5.0 * bern(y, m + h * g)) / 9.0 + }; + let under = 10.0 * (integral(&ys[0], 0.5, 1.0) + integral(&ys[1], 0.0, 1.0) + integral(&ys[2], 0.0, 1.0 / 6.0)); + let sheet = spans(&ys); + assert_eq!(sheet.face_count(), 3); + let first = leftmost(&sheet); + let cube = crate::box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 10.0)).unwrap(); + let parts = split_body(&cube, &SplitTool::Face { body: &sheet, face: first }).unwrap(); + let v = volumes(&parts); + assert_eq!(v.len(), 2, "{v:?}"); + assert!(rel(v[0], under) < 1e-6 && rel(v[1], 1000.0 - under) < 1e-6, "{v:?} vs {under}"); + + let short = spans(&ys[..2]); + let first = leftmost(&short); + let nicked = split_body(&cube, &SplitTool::Face { body: &short, face: first }).unwrap(); + let info: Vec<_> = nicked.iter().map(|b| (measure(b).unwrap().volume, b.face_count(), b.lumps().unwrap().len())).collect(); + assert_eq!(nicked.len(), 1, "{info:?}"); + } + fn volumes(parts: &[Body]) -> Vec { let mut v: Vec = parts.iter().map(|b| measure(b).unwrap().volume).collect(); v.sort_by(f64::total_cmp); diff --git a/crates/kernel/src/surface_extend.rs b/crates/kernel/src/surface_extend.rs index f1aea0cde..8315b3b4c 100644 --- a/crates/kernel/src/surface_extend.rs +++ b/crates/kernel/src/surface_extend.rs @@ -11,7 +11,15 @@ //! The face is extended where it is its surface's whole parameter box and the edge is a whole //! side of it: the box grows past that side, the sides next to it continue along the surface's //! parameter lines, and the face stays one face on the extended surface. Edges picked on two -//! sides grow the box on both, meeting at the box's corner. Up to a target, the face is extended +//! sides grow the box on both, meeting at the box's corner. +//! +//! A body of several faces grows face by face, each extended alone as above and the faces sewn +//! back together. A side that lengthens is shared with the face next to it: that face grows too, +//! past its edge continuing the picked one, when the two meet tangent along the side (the faces +//! of one smooth surface, a spline's spans extruded, grow as one); across a crease it grows only +//! when that edge is picked as well, and otherwise the extension is refused (it would run past +//! the face beside it). The lengthened sides must meet again: faces whose extensions part are +//! refused. Up to a target, the face is extended //! past it and trimmed back where the target meets it ([`crate::trim_keep`]: SMLib's exact //! intersection). Back to the bounds is the face untrimmed to its surface's box //! ([`crate::untrim`]). A plane's straight edges pushed out with their neighbours lengthened @@ -19,7 +27,9 @@ //! //! Refused rather than built: edges between two faces, edges of holes, and (not supported yet) //! an edge that is not a whole side of its surface's box (a trimmed edge, whose extension is no -//! curve SMLib holds exactly), or a body of more than one face. +//! curve SMLib holds exactly). + +use std::collections::{BTreeMap, BTreeSet}; use solidcraft_geom::Vec3; use solidcraft_geom::brep::{self, eval::CurveEval}; @@ -29,7 +39,8 @@ use crate::body::Body; use crate::history::{Change, FaceOrigin}; use crate::native::{body_from_smlib_ordered, smlib_body_ordered}; use crate::surface_trim::TrimKeep; -use crate::{KernelError, Result, SplitTool}; +use crate::surfaces::Parts; +use crate::{KernelError, Result, SplitTool, record}; /// Most edge picks. const MAX_PICKS: usize = 10_000; @@ -104,11 +115,14 @@ pub fn extend_surface(body: &Body, at: &[Vec3], opts: &ExtendOptions) -> Result< { return crate::surfaces::extend(body, at, d); } - let faces = picked_faces(&record, body.size(), at)?; + let picked = picked_edges(&record, body.size(), at)?; match opts.limit { - ExtendLimit::Bounds => back_to_bounds(body, &faces), - ExtendLimit::Distance(d) => continued(body, at, d, opts.mode), - ExtendLimit::UpTo(tool) => up_to(body, at, tool, opts.mode), + ExtendLimit::Bounds => { + let faces: BTreeSet = picked.iter().map(|(_, f)| *f).collect(); + back_to_bounds(body, &faces.into_iter().collect::>()) + } + ExtendLimit::Distance(d) => continued(body, at, &picked, d, opts.mode).map(|(out, _)| out), + ExtendLimit::UpTo(tool) => up_to(body, at, &picked, tool, opts.mode), } } @@ -120,10 +134,10 @@ fn plain_planar(record: &brep::Brep) -> bool { && edges.iter().all(|u| record.edges.get(u.edge as usize).is_some_and(|e| matches!(e.curve, brep::Curve::Line { .. }))) } -/// The faces (in face order, each once) of the boundary edges the points pick: for each point, -/// the record edge nearest it (by samples along each edge), within a twentieth of the body's -/// size. An edge two faces share, or one of a hole, is refused. -fn picked_faces(record: &brep::Brep, size: f64, at: &[Vec3]) -> Result> { +/// The boundary edges the points pick, each with its face: for each point, the record edge +/// nearest it (by samples along each edge), within a twentieth of the body's size. An edge two +/// faces share, or one of a hole, is refused. +fn picked_edges(record: &brep::Brep, size: f64, at: &[Vec3]) -> Result> { let curves: Vec = record .edges .iter() @@ -131,7 +145,7 @@ fn picked_faces(record: &brep::Brep, size: f64, at: &[Vec3]) -> Result>()?; let reach = size * 0.05 + 1e-6; - let mut faces = Vec::new(); + let mut picked = Vec::with_capacity(at.len()); for p in at { let mut best: Option<(f64, usize)> = None; for (i, (e, c)) in record.edges.iter().zip(&curves).enumerate() { @@ -144,8 +158,8 @@ fn picked_faces(record: &brep::Brep, size: f64, at: &[Vec3]) -> Result record.edges.get(i), + let (index, edge) = match best { + Some((d, i)) if d <= reach => record.edges.get(i).map(|e| (i, e)), _ => None, } .ok_or_else(|| KernelError::Invalid(format!("no edge at {p:?}")))?; @@ -156,23 +170,163 @@ fn picked_faces(record: &brep::Brep, size: f64, at: &[Vec3]) -> Result Result<(Body, Vec)> { + if body.face_count() == 1 { + return Ok((one_face(body, at, distance, mode)?, vec![0])); + } + let r = body.record(); + let grow = grown(r, picked)?; + let mut pieces = Vec::with_capacity(grow.len() + 1); + for (&f, edges) in &grow { + let alone = crate::surfaces::taken(body, r, &[(f, false)])?; + let points = edges.iter().map(|e| edge_middle(r, *e)).collect::>>()?; + let longer = one_face(&alone, &points, distance, mode)?; + pieces.push((longer.record().clone(), vec![record::from_face(0, f, Change::Modified)])); + } + let rest: Vec<(usize, bool)> = (0..r.faces.len()).filter(|f| !grow.contains_key(f)).map(|f| (f, false)).collect(); + if !rest.is_empty() { + let c = Parts::of(r, &rest)?.canonical()?; + let kept = c + .faces + .iter() + .map(|p| rest.get(*p).map(|(f, _)| record::from_face(0, *f, Change::Kept))) + .collect::>>() + .ok_or_else(|| failed("sew", "a face of the rest of the body is missing"))?; + pieces.push((c.brep, kept)); + } + let out = crate::surfaces::sheet_of(pieces, true, &[body])?; + if (out.face_count(), out.edge_count()) != (body.face_count(), body.edge_count()) { + return Err(KernelError::Invalid( + "the extended faces part along the sides they lengthen: their extensions don't meet again (extend each face on its own)".into(), + )); + } + Ok((out, grow.into_keys().collect())) +} + +/// The boundary edges each face grows past (by face): the `picked` ones (edge, face), and those +/// that continue a grown edge across a side it lengthens onto a face meeting its own tangent +/// there. A side lengthening along a crease onto a face that does not grow past the edge +/// continuing the grown one is refused: the extension would run past that face. +fn grown(r: &brep::Brep, picked: &[(usize, usize)]) -> Result>> { + let sides = crate::surfaces::face_sides(r); + let sign = |f: usize| sides.get(f).map(|forward| if *forward { 1.0 } else { -1.0 }); + let mut grow: BTreeMap> = BTreeMap::new(); + let mut todo = picked.to_vec(); + // (face, its edge that must grow, the creased side between): checked once all have grown. + let mut creased = Vec::new(); + let mut count = 0usize; + while let Some((e, f)) = todo.pop() { + if !grow.entry(f).or_default().insert(e) { + continue; + } + count += 1; + if count > MAX_PICKS { + return Err(KernelError::Invalid("too many edges to extend".into())); + } + for (side, at) in next_to(r, f, e)? { + let uses = &record_edge(r, side)?.uses; + let other = match uses.as_slice() { + [_] => continue, + [a, b] => [a.face, b.face].into_iter().map(|g| g as usize).find(|g| *g != f), + _ => return Err(KernelError::Invalid(format!("not supported yet: extending along edge {side}, which more than two faces share"))), + }; + // A seam: the face lengthens along it on both sides at once. + let Some(g) = other else { continue }; + let cont = continuing(r, g, side, at)?; + if !matches!(record_edge(r, cont)?.uses.as_slice(), [only] if only.r#loop == 0) { + return Err(KernelError::Invalid(format!( + "not supported yet: extending past edge {e}, whose side {side} runs on into the inside of the face next to it" + ))); + } + if crate::tangent_edge::tangent_all_along(r, sign, side, crate::smooth_edges::ANGLE)? { + todo.push((cont, g)); + } else { + creased.push((g, cont, side)); + } } } - faces.sort_unstable(); - Ok(faces) + for (g, cont, side) in creased { + if !grow.get(&g).is_some_and(|edges| edges.contains(&cont)) { + return Err(KernelError::Invalid(format!( + "extending the edge lengthens its face along edge {side}, a crease with the face next to it: pick that face's edge {cont} too" + ))); + } + } + Ok(grow) +} + +fn record_edge(r: &brep::Brep, e: usize) -> Result<&brep::Edge> { + r.edges.get(e).ok_or_else(|| failed("topology", format!("no edge {e}"))) +} + +/// The outer loop of face `f` and where edge `e` is in it. +fn in_outer_loop(r: &brep::Brep, f: usize, e: usize) -> Result<(&[brep::OrientedEdge], usize)> { + let face = r.faces.get(f).ok_or_else(|| failed("topology", format!("no face {f}")))?; + let Some(brep::Loop::Edges { edges }) = face.loops.first() else { return Err(failed("topology", format!("face {f} has no edge loop"))) }; + let i = edges.iter().position(|u| u.edge as usize == e).ok_or_else(|| failed("topology", format!("edge {e} is not on face {f}'s outer loop")))?; + Ok((edges, i)) +} + +/// The vertices edge use `u` runs from and to round its loop. +fn ends(r: &brep::Brep, u: &brep::OrientedEdge) -> Result<[u32; 2]> { + let [a, b] = record_edge(r, u.edge as usize)?.vertices; + Ok(if u.forward { [a, b] } else { [b, a] }) +} + +/// The sides of face `f` next to its edge `e` round its outer loop, each with the vertex it +/// shares with `e`: the edges an extension past `e` lengthens. +fn next_to(r: &brep::Brep, f: usize, e: usize) -> Result> { + let (edges, i) = in_outer_loop(r, f, e)?; + let n = edges.len(); + let (Some(prev), Some(this), Some(next)) = (edges.get((i + n - 1) % n), edges.get(i), edges.get((i + 1) % n)) else { return Ok(Vec::new()) }; + let [from, to] = ends(r, this)?; + let mut out = Vec::with_capacity(2); + for (u, v) in [(prev, from), (next, to)] { + if u.edge as usize != e && !out.iter().any(|(s, _)| *s == u.edge as usize) { + out.push((u.edge as usize, v)); + } + } + Ok(out) +} + +/// The edge of face `g`'s outer loop that meets its side `side` at vertex `at`. +fn continuing(r: &brep::Brep, g: usize, side: usize, at: u32) -> Result { + let (edges, i) = in_outer_loop(r, g, side)?; + let n = edges.len(); + let this = edges.get(i).ok_or_else(|| failed("topology", "a loop position"))?; + let [from, to] = ends(r, this)?; + let k = if from == at { + (i + n - 1) % n + } else if to == at { + (i + 1) % n + } else { + return Err(failed("topology", format!("edge {side} does not end at vertex {at}"))); + }; + match edges.get(k) { + Some(u) if u.edge as usize != side => Ok(u.edge as usize), + _ => Err(KernelError::Invalid(format!("not supported yet: extending along edge {side}, the only side of the face next to it"))), + } +} + +/// The point halfway along record edge `e`. +fn edge_middle(r: &brep::Brep, e: usize) -> Result { + let edge = record_edge(r, e)?; + let c = CurveEval::new(edge.parameters()).map_err(|err| failed("edge", format!("edge {e}'s curve: {err}")))?; + c.point(0.5 * (edge.interval[0] + edge.interval[1])).ok_or_else(|| failed("edge", format!("edge {e} has no middle"))) } /// The one face of `body` continued `distance` past each picked edge, as `mode` says. -fn continued(body: &Body, at: &[Vec3], distance: f64, mode: ExtendMode) -> Result { - if body.face_count() != 1 { - return Err(KernelError::Invalid(format!( - "not supported yet: extending a surface of more than one face (this one has {})", - body.face_count() - ))); - } +fn one_face(body: &Body, at: &[Vec3], distance: f64, mode: ExtendMode) -> Result { let how = match mode { ExtendMode::Natural => Continuation::Natural, ExtendMode::Tangent => Continuation::Tangent, @@ -186,7 +340,9 @@ fn continued(body: &Body, at: &[Vec3], distance: f64, mode: ExtendMode) -> Resul solidcraft_smlib::Error::Unsupported => KernelError::Invalid( "not supported yet: extending an edge that is not a whole side of its surface's parameter box (a trimmed edge)".into(), ), - solidcraft_smlib::Error::NotExact => KernelError::Invalid("the extension would run past a pole of its surface or wrap round it".into()), + solidcraft_smlib::Error::NotExact => KernelError::Invalid(format!( + "the surface cannot be extended exactly {distance} mm there: the extension would run past a pole of its surface, wrap round it, or not reach that length" + )), solidcraft_smlib::Error::NoMatch { .. } => KernelError::Invalid(format!("no edge at {p:?}")), e => failed("extend", e), })?; @@ -207,12 +363,12 @@ fn continued(body: &Body, at: &[Vec3], distance: f64, mode: ExtendMode) -> Resul Ok(out.with_checked_history(history, &crate::record::counts(&[body]))) } -/// The face extended past the target and trimmed back where the target meets it, keeping the -/// piece the face itself lies in. -fn up_to(body: &Body, at: &[Vec3], tool: &SplitTool, mode: ExtendMode) -> Result { - let inside = crate::surface_untrim::face_point(body, 0)?; - let long = continued(body, at, body.size().max(1e-6) * REACH, mode)?; - let cut = crate::trim_keep(&long, tool, TrimKeep::Regions(&[inside]))?; +/// The faces extended past the target and trimmed back where the target meets them, keeping the +/// pieces the faces themselves lie in. +fn up_to(body: &Body, at: &[Vec3], picked: &[(usize, usize)], tool: &SplitTool, mode: ExtendMode) -> Result { + let (long, faces) = continued(body, at, picked, body.size().max(1e-6) * REACH, mode)?; + let inside = faces.iter().map(|f| crate::surface_untrim::face_point(body, *f)).collect::>>()?; + let cut = crate::trim_keep(&long, tool, TrimKeep::Regions(&inside))?; Ok(crate::record::after(cut, &long, &crate::record::counts(&[body]))) } @@ -411,6 +567,57 @@ mod tests { assert!((measure(&back).unwrap().bbox.max.z - 15.0).abs() < 1e-6); } + /// Three cubic spans of a spline meeting tangent, extruded 0…20 along Z: a sheet of three + /// faces, as a fit-point spline's surface is (#3830). + fn spline_spans() -> Body { + let v = Vec2::new; + let c = |p0, p1, p2, p3| Seg2::Cubic { p0, p1, p2, p3 }; + let chain = vec![ + c(v(0.0, 0.0), v(5.0, 0.0), v(10.0, 5.0), v(15.0, 5.0)), + c(v(15.0, 5.0), v(20.0, 5.0), v(25.0, 0.0), v(30.0, 0.0)), + c(v(30.0, 0.0), v(35.0, 0.0), v(40.0, 5.0), v(45.0, 5.0)), + ]; + crate::extrude_sheet(&Plane::XY, &[chain], 0.0, 20.0).unwrap() + } + + /// A sheet of several faces grows face by face (#3830): its end edge (the last span's + /// generator) 10 further, the last span continued, 10 · 20 more; the middle span's top edge + /// 5 up takes its tangent neighbours with it, the whole spline 25 tall. The faces stay three, + /// sewn as before, each the face it was. + #[test] + fn a_sheet_of_tangent_faces_grows_face_by_face() { + let s = spline_spans(); + assert_eq!(s.face_count(), 3); + let base = area(&s); + let end = extend_surface(&s, &[Vec3::new(45.0, 5.0, 10.0)], &natural(10.0)).unwrap(); + assert!(rel(area(&end), base + 200.0) < 1e-4, "{} vs {}", area(&end), base + 200.0); // (measured on meshes) + assert_eq!((end.face_count(), edges(&end)), (3, edges(&s))); + assert!(measure(&end).unwrap().bbox.max.x > 50.0, "{:?}", measure(&end).unwrap().bbox); + let h = end.history().unwrap(); + let changes: Vec = h.faces.iter().map(|f| f.change).collect(); + assert_eq!(changes.iter().filter(|c| **c == Change::Modified).count(), 1, "{changes:?}"); + + let up = extend_surface(&s, &[Vec3::new(22.5, 2.5, 20.0)], &natural(5.0)).unwrap(); + assert!(rel(area(&up), base * 25.0 / 20.0) < 1e-4, "{} vs {}", area(&up), base * 25.0 / 20.0); // (measured on meshes) + assert_eq!((up.face_count(), edges(&up)), (3, edges(&s))); + assert!((measure(&up).unwrap().bbox.max.z - 25.0).abs() < 1e-6); + } + + /// Across a crease the face next door grows only when its edge is picked too: an L of two + /// planes, one top edge refused (it would run past the other wall), both 5 up, 25 · 20. + #[test] + fn a_crease_grows_only_when_both_edges_are_picked() { + let l = + vec![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 s = crate::extrude_sheet(&Plane::XY, &[l], 0.0, 20.0).unwrap(); + assert_eq!(s.face_count(), 2); + let e = extend_surface(&s, &[Vec3::new(5.0, 0.0, 20.0)], &natural(5.0)).unwrap_err(); + assert!(e.to_string().contains("crease"), "{e}"); + let both = extend_surface(&s, &[Vec3::new(5.0, 0.0, 20.0), Vec3::new(10.0, 5.0, 20.0)], &natural(5.0)).unwrap(); + assert!(rel(area(&both), 500.0) < 1e-9, "{}", area(&both)); + assert_eq!((both.face_count(), edges(&both)), (2, edges(&s))); + } + /// Hostile and unsupported requests are refused, never panic. #[test] fn hostile_requests_are_refused() { diff --git a/crates/kernel/src/surfaces.rs b/crates/kernel/src/surfaces.rs index 291de903c..9cd0da5f6 100644 --- a/crates/kernel/src/surfaces.rs +++ b/crates/kernel/src/surfaces.rs @@ -236,7 +236,7 @@ impl Parts { /// Whether each face of `r` is used along its surface's natural normal (by its first oriented /// face). -fn face_sides(r: &Brep) -> Vec { +pub(crate) fn face_sides(r: &Brep) -> Vec { let mut side = vec![None; r.faces.len()]; for s in &r.shells { if let b::Shell::Faces { faces, .. } = s { diff --git a/crates/smlib/src/ffi/split.rs b/crates/smlib/src/ffi/split.rs index 6e07ae3ae..6fb48ba69 100644 --- a/crates/smlib/src/ffi/split.rs +++ b/crates/smlib/src/ffi/split.rs @@ -1,4 +1,5 @@ -//! The split block of `capi/include/smlib.h` (`smlib_split_faces`, `smlib_split_body`; the +//! The split block of `capi/include/smlib.h` (`smlib_split_faces`, `smlib_split_body`, +//! `smlib_split_body_by_sheet`; the //! fork's `capi/src/smlib_split.cpp`), declared by hand. Part of the FFI boundary, like its //! parent: called only through [`crate::split`]. @@ -27,6 +28,7 @@ unsafe extern "C" { made: *mut i64, ) -> i32; fn smlib_split_body(body: *const RawBrep, tool: *const RawSurface, back: *mut *mut RawBrep, front: *mut *mut RawBrep) -> i32; + fn smlib_split_body_by_sheet(body: *const RawBrep, sheet: *const RawBrep, face: i64, back: *mut *mut RawBrep, front: *mut *mut RawBrep) -> i32; } /// `body` with `faces` cut by `tools` in turn, and per face how many faces it became besides @@ -48,10 +50,23 @@ pub fn split_faces(body: &Handle, faces: &[i64], tools: &[&SurfaceHandle]) -> Re /// The parts of `body` behind and in front of `tool`. #[cfg(feature = "native")] pub fn split_body(body: &Handle, tool: &SurfaceHandle) -> Result<(Handle, Handle), i32> { + // SAFETY: the handles are live; the out-pointers are written only on success. + two_parts(|back, front| unsafe { smlib_split_body(body.raw(), tool.raw(), back, front) }) +} + +/// The parts of `body` behind and in front of `sheet`, its sides those of its face `face`. +#[cfg(feature = "native")] +pub fn split_body_by_sheet(body: &Handle, sheet: &Handle, face: i64) -> Result<(Handle, Handle), i32> { + // SAFETY: the handles are live; the out-pointers are written only on success. + two_parts(|back, front| unsafe { smlib_split_body_by_sheet(body.raw(), sheet.raw(), face, back, front) }) +} + +/// The two bodies a call writing a back and a front part gives, owned. +#[cfg(feature = "native")] +fn two_parts(call: impl FnOnce(*mut *mut RawBrep, *mut *mut RawBrep) -> i32) -> Result<(Handle, Handle), i32> { let mut back: *mut RawBrep = std::ptr::null_mut(); let mut front: *mut RawBrep = std::ptr::null_mut(); - // SAFETY: the handles are live; the out-pointers are written only on success. - let s = unsafe { smlib_split_body(body.raw(), tool.raw(), &mut back, &mut front) }; + let s = call(&mut back, &mut front); let (b, f) = (std::ptr::NonNull::new(back), std::ptr::NonNull::new(front)); match (s, b, f) { (OK, Some(b), Some(f)) => Ok((Handle(b), Handle(f))), @@ -74,3 +89,8 @@ pub fn split_faces(_: &Handle, _: &[i64], _: &[&SurfaceHandle]) -> Result<(Handl pub fn split_body(_: &Handle, _: &SurfaceHandle) -> Result<(Handle, Handle), i32> { Err(NOT_BUILT) } + +#[cfg(not(feature = "native"))] +pub fn split_body_by_sheet(_: &Handle, _: &Handle, _: i64) -> Result<(Handle, Handle), i32> { + Err(NOT_BUILT) +} diff --git a/crates/smlib/src/split.rs b/crates/smlib/src/split.rs index 9a818f87d..0ca7b0299 100644 --- a/crates/smlib/src/split.rs +++ b/crates/smlib/src/split.rs @@ -37,4 +37,19 @@ impl Brep { Err(s) => Err(error(s)), } } + + /// The manifold solid `self` cut in two by the sheet `sheet` as it is (its faces joined edge + /// to edge; it must cross the body to cut it), as [`Brep::split_body`] cuts it: its faces' + /// surfaces turned to agree with face `face`'s (in SMLib's face order), the part behind that + /// normal and the part in front. A `sheet` that is no sheet, or a `face` it does not have, is + /// [`Error::Argument`]. + pub fn split_body_by_sheet(&self, sheet: &Brep, face: usize) -> Result> { + init()?; + let face = i64::try_from(face).map_err(|_| Error::Argument)?; + match ffi::split::split_body_by_sheet(&self.0, &sheet.0, face) { + Ok((b, f)) => Ok(Some((Brep(b), Brep(f)))), + Err(ffi::ops::ERR_NO_CUT) => Ok(None), + Err(s) => Err(error(s)), + } + } } diff --git a/tests/kernel-cases/booleans/3830-split-cup-by-extended-spline-surface/expected.json b/tests/kernel-cases/booleans/3830-split-cup-by-extended-spline-surface/expected.json index c77c9cb0a..d9676e22e 100644 --- a/tests/kernel-cases/booleans/3830-split-cup-by-extended-spline-surface/expected.json +++ b/tests/kernel-cases/booleans/3830-split-cup-by-extended-spline-surface/expected.json @@ -4,7 +4,7 @@ ], "what": "split a thin-walled cup (shell of a d30 cylinder) with a surface body: an extruded spline surface, extended at both ends", "source": "analytic", - "method": "cup = cylinder r15 h30 shelled 1 mm inward with its top removed: V = pi*15^2*30 - pi*14^2*29 = 3349.04. The surface crosses the whole cup from above its rim to below its floor, so it splits the cup in two; splitting only divides material: two valid bodies whose volumes add up to 3349.04", - "body_count": 2, + "method": "cup = cylinder r15 h30 shelled 1 mm inward with its top removed: V = pi*15^2*30 - pi*14^2*29 = 3349.04. The surface crosses the whole cup from above its rim to below its floor, so it splits the cup in two; splitting only divides material: two valid bodies whose volumes add up to 3349.04; the surface body that cut it stays, a third body", + "body_count": 3, "volume_mm3": 3348.938 } \ No newline at end of file diff --git a/tests/kernel-cases/booleans/KNOWN_FAILING b/tests/kernel-cases/booleans/KNOWN_FAILING index 199e98213..a71ceae24 100644 --- a/tests/kernel-cases/booleans/KNOWN_FAILING +++ b/tests/kernel-cases/booleans/KNOWN_FAILING @@ -3,4 +3,3 @@ # and on a listed case that passes: a fix removes its line in the same pull request. # Baseline: develop 5ada4fc8a with SMLib 90aabff (the run on 60b1c6a, aarch64 Linux). 3604-cut-with-g2-swept-tool-along-projected-edge step 12 (solid.sweep): the path curves are not connected end to end -3830-split-cup-by-extended-spline-surface not supported yet: surface.extend of a surface of more than one face (this one has 3)