diff --git a/crates/kernel/src/polyhedron.rs b/crates/kernel/src/polyhedron.rs
index 95f1885fa..22ef37f51 100644
--- a/crates/kernel/src/polyhedron.rs
+++ b/crates/kernel/src/polyhedron.rs
@@ -835,16 +835,14 @@ fn solve3(m: [[f64; 3]; 3], r: [f64; 3]) -> Option<[f64; 3]> {
Some(out)
}
-/// Move the planar faces at the given points along their outward normals by `distance`
-/// (negative: into the body). The body's other faces follow (its topology is kept).
-pub fn offset_faces(b: &Body, at: &[Vec3], distance: f64) -> Result
{
- b.require_brep("offset faces")?;
- if !distance.is_finite() || distance.abs() > 1e6 {
- return Err(KernelError::Invalid("offset distance".into()));
- }
- let healed = crate::boolean_record::healed(b)?.with_split_lines(b.splits.clone());
- let size = healed.size();
- let mesh = healed.tessellate((size * 1e-3).max(1e-3))?;
+/// The faces of `body` the given points pick, each whole (every piece of its surface).
+///
+/// Taken per body rather than once, because an operation may be tried again on the same body
+/// with a face split in two, and the pieces are numbered differently then. The points do not
+/// move, so they pick the same surface either way.
+fn faces_at(body: &Body, at: &[Vec3]) -> Result> {
+ let size = body.size();
+ let mesh = body.tessellate((size * 1e-3).max(1e-3))?;
let mut chosen: Vec = Vec::new();
for p in at {
let near = mesh
@@ -862,13 +860,39 @@ pub fn offset_faces(b: &Body, at: &[Vec3], distance: f64) -> Result {
_ => return Err(KernelError::Invalid(format!("no face at {:?}", [p.x, p.y, p.z]))),
}
}
- let chosen = crate::offset::with_same_surface(&healed, &chosen);
- match offset_planar(&healed, |fi, _| if chosen.contains(&fi) { distance } else { 0.0 }) {
- Ok(r) => Ok(record::after(r, &healed, &record::counts(&[b]))),
- // A piece of a split face (its neighbour stays): the piece swept along its normal
- // joins on (outward) or cuts in, with walls along the split lines.
- Err(e) if !healed.split_keep().is_empty() => press_pieces(&healed, &chosen, distance).map_err(|_| e),
- Err(e) => Err(e),
+ Ok(crate::offset::with_same_surface(body, &chosen))
+}
+
+/// Move the planar faces at the given points along their outward normals by `distance`
+/// (negative: into the body). The body's other faces follow (its topology is kept).
+pub fn offset_faces(b: &Body, at: &[Vec3], distance: f64) -> Result {
+ b.require_brep("offset faces")?;
+ if !distance.is_finite() || distance.abs() > 1e6 {
+ return Err(KernelError::Invalid("offset distance".into()));
+ }
+ // Healing is part of the attempt, not a step before it: a face that runs along a seam edge
+ // twice fails there, and the retry below needs the whole of it to run on the split body.
+ let run = |body: &Body| -> Result {
+ let healed = crate::boolean_record::healed(body)?.with_split_lines(body.splits.clone());
+ let chosen = faces_at(&healed, at)?;
+ match offset_planar(&healed, |fi, _| if chosen.contains(&fi) { distance } else { 0.0 }) {
+ Ok(r) => Ok(record::after(r, &healed, &record::counts(&[body]))),
+ // A piece of a split face (its neighbour stays): the piece swept along its normal
+ // joins on (outward) or cuts in, with walls along the split lines.
+ Err(e) if !healed.split_keep().is_empty() => press_pieces(&healed, &chosen, distance).map_err(|_| e),
+ Err(e) => Err(e),
+ }
+ };
+ match crate::guard("offset faces", || run(b)) {
+ Ok(r) => Ok(r),
+ // A face that runs along a seam edge twice — a hole's wall as a STEP file writes it, one
+ // whole turn bounded by one wire. Healing it, or moving its neighbour, fails where the
+ // same body with that face in two halves works, so split it and ask again, which is what
+ // a boolean already does (`seam_faces`).
+ Err(e) => match crate::seam_faces::one_body(b, "offset faces off their seams", &run) {
+ Some(Ok(r)) => Ok(r),
+ _ => Err(e),
+ },
}
}
diff --git a/crates/kernel/src/seam_faces.rs b/crates/kernel/src/seam_faces.rs
index e68948381..1aa38212e 100644
--- a/crates/kernel/src/seam_faces.rs
+++ b/crates/kernel/src/seam_faces.rs
@@ -48,6 +48,11 @@ pub(crate) fn needed(a: &Body, b: &Body) -> bool {
!a.is_mesh() && !b.is_mesh() && !SPLITTING.with(|c| c.get()) && (next_split(a).is_some() || next_split(b).is_some())
}
+/// Whether `body` has a face for [`one_body`] to split.
+pub(crate) fn needed_one(body: &Body) -> bool {
+ !body.is_mesh() && !SPLITTING.with(|c| c.get()) && next_split(body).is_some()
+}
+
/// `body` with every face that runs along a seam edge twice split in two, and its history over
/// `body`. `None` when a split fails.
fn halved(body: &Body) -> Option<(Body, Option)> {
@@ -86,6 +91,28 @@ pub(crate) fn boolean(a: &Body, b: &Body, op: BoolOp, run: &dyn Fn(&Body, &Body,
})))
}
+/// `run` over `body` with every face that runs along a seam edge twice split in two, for an
+/// operation that takes one body. `None` when the body has no such face, a split fails, or the
+/// run over the split body fails: the caller then keeps the error it had.
+///
+/// The same answer as [`boolean`] gives, for the same reason — an operation that has to divide
+/// such a face can fail where the body with the face in two halves works — and it matters most
+/// to a body read from a STEP file, which is where a whole-turn face comes from. The result's
+/// history is composed back over `body` as it was given, so a caller that knows `body`'s faces
+/// still recognises them: the split is no authored boundary.
+pub(crate) fn one_body(body: &Body, what: &str, run: &dyn Fn(&Body) -> Result) -> Option> {
+ if !needed_one(body) {
+ return None;
+ }
+ let (split, over) = halved(body)?;
+ SPLITTING.with(|c| c.set(true));
+ let result = crate::guard(what, || run(&split));
+ SPLITTING.with(|c| c.set(false));
+ let out = result.ok()?;
+ let history = recorded::through(&out, 0, over.as_ref());
+ Some(Ok(out.with_checked_history(history, &crate::record::counts(&[body]))))
+}
+
#[cfg(test)]
#[path = "seam_faces_tests.rs"]
mod tests;
diff --git a/crates/kernel/src/seam_faces_tests.rs b/crates/kernel/src/seam_faces_tests.rs
index 9bf32aee5..e93145fb4 100644
--- a/crates/kernel/src/seam_faces_tests.rs
+++ b/crates/kernel/src/seam_faces_tests.rs
@@ -59,6 +59,34 @@ fn a_pin_read_from_step_has_one_face_along_its_seam() {
assert!(rel(volume(&halved), PI * R * R * 40.0) < 1e-3);
}
+/// Offset Face on a body read from STEP, where the hole's wall is one face along its seam.
+///
+/// Healing such a body, which Offset Face does before it moves anything, fails inside `truck`
+/// ("This wire is not simple"), so the top could not be moved at all — and importing is how a
+/// part with a hole usually arrives. The offset now splits the face off its seam and asks again,
+/// as a boolean does.
+#[test]
+fn the_top_of_a_read_block_with_a_hole_moves() {
+ // A 20 x 20 x 10 block with a 6 mm hole through the middle of it.
+ let block = box_solid(Vec3::ZERO, Vec3::new(20.0, 20.0, 10.0)).unwrap();
+ let drill = cylinder(Vec3::new(10.0, 10.0, -5.0), Vec3::Z, 3.0, 20.0).unwrap();
+ let built = boolean(&block, &drill, BoolOp::Cut).unwrap().unwrap();
+ let read = through_step(&built);
+ // Read back, the hole's wall is one whole turn instead of the two halves it was built as.
+ assert!(read.face_count() < built.face_count());
+ assert!(super::needed_one(&read) && !super::needed_one(&built));
+
+ // The top, 2 mm up: the part grows by the plate's section, the hole still through it.
+ let section = 400.0 - PI * 9.0;
+ let moved = offset_faces(&read, &[Vec3::new(5.0, 5.0, 10.0)], 2.0).unwrap();
+ assert!(rel(volume(&moved), volume(&read) + section * 2.0) < 1e-3, "{} {}", volume(&moved), volume(&read) + section * 2.0);
+ // The same answer as moving the built body's top, which never needed the split.
+ let straight = offset_faces(&built, &[Vec3::new(5.0, 5.0, 10.0)], 2.0).unwrap();
+ assert!(rel(volume(&moved), volume(&straight)) < 1e-5, "{} {}", volume(&moved), volume(&straight));
+ // And the faces still say where they came from, so names and sketches survive the retry.
+ assert!(moved.history().is_some());
+}
+
#[test]
fn a_block_pressed_into_a_read_pins_side_is_intersected_and_cut_exactly() {
let (read, block) = (through_step(&pin()), block());