diff --git a/crates/kernel/src/heal.rs b/crates/kernel/src/heal.rs index 3b712c0c3..3fde7c24d 100644 --- a/crates/kernel/src/heal.rs +++ b/crates/kernel/src/heal.rs @@ -58,6 +58,6 @@ pub(crate) fn heal(body: &Body, keep: &[Vec]) -> Result { } } let tolerance = record.tolerance * 10.0; - let (healed, history) = crate::offset_backend::run("healing", body, |b| b.merge_faces(&kept, tolerance))?; + let (healed, history) = crate::offset_backend::run("healing", body, None, |b| b.merge_faces(&kept, tolerance))?; Ok(healed.with_checked_history(history, &crate::record::counts(&[body])).with_split_lines(body.splits.clone())) } diff --git a/crates/kernel/src/modify_history_tests.rs b/crates/kernel/src/modify_history_tests.rs index 4dc845d13..89f355277 100644 --- a/crates/kernel/src/modify_history_tests.rs +++ b/crates/kernel/src/modify_history_tests.rs @@ -552,6 +552,17 @@ mod smlib { verified(&r, &plate, reach(2.5 * 1.5)); } + /// A 40 x 40 x 10 plate with an r2 hole 3 from its side, shelled 1.5 open at the top: the + /// hole's offset just reaches the side's, so the walls would meet along a line. Refused, + /// saying so and with the wall, never as SMLib's bare status. + #[test] + fn a_shell_whose_walls_would_meet_is_refused_saying_so() { + let hole = Loop2::circle(Vec2::new(5.0, 20.0), 2.0); + let plate = extrude(&Plane::XY, &[Region2 { outer: square(0.0, 0.0, 40.0, 40.0), holes: vec![hole] }], 0.0, 10.0).unwrap().pop().unwrap(); + let e = offset_backend::shell(&plate, &[Vec3::new(35.0, 20.0, 10.0)], 1.5).unwrap_err().to_string(); + assert!(e.contains("the 1.5 mm walls would meet along a line"), "{e}"); + } + #[test] fn offset_moves_a_face() { let b = ell(); diff --git a/crates/kernel/src/offset_backend.rs b/crates/kernel/src/offset_backend.rs index 5c20eea9c..bf88f4ed2 100644 --- a/crates/kernel/src/offset_backend.rs +++ b/crates/kernel/src/offset_backend.rs @@ -26,10 +26,19 @@ fn failed(op: &str, what: &str, e: impl std::fmt::Display) -> KernelError { KernelError::Failed(format!("SMLib {op}: {what}: {e}")) } -/// The error for SMLib's refusal of `op`, in the words of the operation. -fn refused(op: &str, e: SmError) -> KernelError { +/// The error for SMLib's refusal of `op`, in the words of the operation; `wall` is its wall's +/// thickness, where it has one. +fn refused(op: &str, wall: Option, e: SmError) -> KernelError { match e { SmError::NoRoom => KernelError::Invalid(format!("{op}: the wall is too thick: it leaves no room inside the body")), + // The walls just meet: thinner they stay apart, thicker they cross and merge. + SmError::WallsTouch => { + let wall = wall.map(|t| format!(" {t} mm")).unwrap_or_default(); + KernelError::Invalid(format!( + "{op}: the{wall} walls would meet along a line (between a hole and the side, for example), which leaves no solid there; \ + use a thinner or thicker wall, or move the feature" + )) + } SmError::NoMatch { point } => KernelError::Invalid(format!("{op}: no face at selection point {}", point + 1)), SmError::Ambiguous { point } => KernelError::Invalid(format!("{op}: selection point {} is as near to two faces", point + 1)), SmError::Unsupported => KernelError::Failed(format!("not supported yet: SMLib {op} for this geometry")), @@ -48,12 +57,18 @@ fn points(p: &[Vec3]) -> Vec<[f64; 3]> { } /// Runs `op` on `b` in SMLib, tagged as operand 0, and brings the result back with SMLib's -/// history over `[b]` (none where an order cannot be matched). -pub(crate) fn run(name: &str, b: &Body, op: impl FnOnce(&Brep) -> std::result::Result) -> Result<(Body, Option)> { +/// history over `[b]` (none where an order cannot be matched). `wall`: the operation's wall +/// thickness, for its refusals. +pub(crate) fn run( + name: &str, + b: &Body, + wall: Option, + op: impl FnOnce(&Brep) -> std::result::Result, +) -> Result<(Body, Option)> { b.require_brep(name)?; let (sb, ob) = smlib_body_ordered(b)?; let tagged = sb.tagged(0).map_err(|e| failed(name, "tag", e))?; - let r = op(&tagged).map_err(|e| refused(name, e))?; + let r = op(&tagged).map_err(|e| refused(name, wall, e))?; let check = r.check(CheckLevel::All).map_err(|e| failed(name, "check", e))?; if !check.is_valid() { let input = sb.check(CheckLevel::All).is_ok_and(|c| !c.is_valid()); @@ -84,7 +99,7 @@ pub(crate) fn shell(b: &Body, open: &[Vec3], thickness: f64) -> Result { let opened = crate::offset::with_same_surface(b, &picked); let tol = pick_tolerance(b); let pts = points(&face_points(b, &opened)?); - let (r, h) = run("shell", b, |s| s.shell(&pts, tol, -thickness))?; + let (r, h) = run("shell", b, Some(thickness), |s| s.shell(&pts, tol, -thickness))?; let h = h.and_then(|h| with_offsets(&r, b, h, thickness)); Ok(r.with_checked_history(h, &record::counts(&[b]))) } @@ -96,7 +111,7 @@ pub(crate) fn offset_faces(b: &Body, chosen: &[usize], distance: f64) -> Result< let at = face_points(b, chosen)?; let tol = pick_tolerance(b); let pts = points(&at); - let (r, h) = run("offset faces", b, |s| s.offset_faces(&pts, tol, distance))?; + let (r, h) = run("offset faces", b, None, |s| s.offset_faces(&pts, tol, distance))?; let h = h.map(|mut h| { for f in &mut h.faces { if f.change == Change::Kept && f.origins.iter().any(|o| matches!(o, FaceOrigin::Face { face, .. } if chosen.contains(face))) { @@ -114,7 +129,7 @@ pub(crate) fn thicken(b: &Body, thickness: f64, symmetric: bool) -> Result if !(thickness.is_finite() && thickness.abs() > 1e-9) { return Err(KernelError::Invalid("thickness must be non-zero".into())); } - let (r, h) = run("thicken", b, |s| s.thicken(thickness, symmetric))?; + let (r, h) = run("thicken", b, Some(thickness.abs()), |s| s.thicken(thickness, symmetric))?; let step = if symmetric { thickness.abs() / 2.0 } else { thickness.abs() }; // The walls first, while the sheet's edges still carry their tags on both copies. let h = h.map(with_edge_walls).and_then(|h| with_offsets(&r, b, h, step)); @@ -138,7 +153,7 @@ pub(crate) fn draft(b: &Body, at: &[Vec3], neutral: &solidcraft_geom::Plane, pul let tol = pick_tolerance(b); let pts = points(&face_points(b, &chosen)?); let o = neutral.origin; - let (r, h) = run("draft", b, |s| s.draft(&pts, tol, [o.x, o.y, o.z], [normal.x, normal.y, normal.z], [pull.x, pull.y, pull.z], angle))?; + let (r, h) = run("draft", b, None, |s| s.draft(&pts, tol, [o.x, o.y, o.z], [normal.x, normal.y, normal.z], [pull.x, pull.y, pull.z], angle))?; let h = h.map(|mut h| { for f in &mut h.faces { if f.change == Change::Kept && f.origins.iter().any(|o| matches!(o, FaceOrigin::Face { face, .. } if chosen.contains(face))) { diff --git a/crates/smlib/src/ffi/ops.rs b/crates/smlib/src/ffi/ops.rs index 47c055c6b..1e09aabe8 100644 --- a/crates/smlib/src/ffi/ops.rs +++ b/crates/smlib/src/ffi/ops.rs @@ -19,6 +19,7 @@ pub const ERR_NO_ROOM: i32 = -1103; pub const ERR_NO_CUT: i32 = -1104; pub const ERR_UNSUPPORTED: i32 = -1105; pub const ERR_NO_EFFECT: i32 = -1107; +pub const ERR_WALLS_TOUCH: i32 = -1110; pub const BOOLEAN_UNION: i32 = 0; pub const BOOLEAN_SUBTRACT: i32 = 1; diff --git a/crates/smlib/src/lib.rs b/crates/smlib/src/lib.rs index e36f63c94..557bb7cce 100644 --- a/crates/smlib/src/lib.rs +++ b/crates/smlib/src/lib.rs @@ -52,6 +52,10 @@ pub enum Error { /// No room for the operation: an inward offset (a shell's wall, faces moved in) leaves none /// inside the body, or a blend is larger than the faces it rolls on allow. NoRoom, + /// An offset whose walls would meet (a shell's): the offsets of two faces touch without + /// crossing, a hole's wall offset just reaching a side's, so the result would pinch to + /// nothing along a line. A thinner or a thicker wall builds. + WallsTouch, /// SMLib cannot build this exactly yet (a variable radius whose law has a corner). Unsupported, /// SMLib reported success but the operation did nothing: a blend that made no face, a face @@ -83,6 +87,7 @@ impl std::fmt::Display for Error { Error::NoMatch { point } => write!(f, "selection point {} is not near any edge or face", point + 1), Error::Ambiguous { point } => write!(f, "selection point {} is equally near to two edges or faces", point + 1), Error::NoRoom => write!(f, "there is no room for it: an offset leaves none inside the body, or a blend is larger than its faces allow"), + Error::WallsTouch => write!(f, "the offset's walls would meet along a line, which leaves no solid there"), Error::Unsupported => write!(f, "not supported yet: SMLib cannot build this exactly"), Error::NoEffect => write!(f, "SMLib made no change: it reported success, but the operation did nothing"), Error::NotExact => write!(f, "SMLib cannot build this exactly in the input's geometry"), @@ -114,6 +119,7 @@ fn error(s: i32) -> Error { ffi::ERR_EMPTY => Error::Empty, ffi::ops::ERR_NOT_SOLID => Error::NotSolid, ffi::ops::ERR_NO_ROOM => Error::NoRoom, + ffi::ops::ERR_WALLS_TOUCH => Error::WallsTouch, ffi::ops::ERR_UNSUPPORTED => Error::Unsupported, ffi::ops::ERR_NO_EFFECT => Error::NoEffect, ffi::trim::ERR_NOT_EXACT => Error::NotExact, diff --git a/crates/smlib/src/ops.rs b/crates/smlib/src/ops.rs index b0debecd9..f273409ac 100644 --- a/crates/smlib/src/ops.rs +++ b/crates/smlib/src/ops.rs @@ -182,7 +182,9 @@ impl Brep { /// Hollowed to a wall of `thickness` (negative: inside the original surface, positive: /// outside), open at the faces nearest to `open_faces` (each within `tolerance`); none gives - /// a closed hollow body. An inward wall that leaves no room inside is [`Error::NoRoom`]. + /// a closed hollow body. An inward wall that leaves no room inside is [`Error::NoRoom`]; one + /// whose walls would just meet (a hole exactly twice the wall from a side) is + /// [`Error::WallsTouch`]. pub fn shell(&self, open_faces: &[[f64; 3]], tolerance: f64, thickness: f64) -> Result { self.pick_op(ffi::ops::Pick::Shell, open_faces, tolerance, thickness, true) } diff --git a/crates/smlib/src/ops_tests.rs b/crates/smlib/src/ops_tests.rs index c442a5e2d..cad5ca805 100644 --- a/crates/smlib/src/ops_tests.rs +++ b/crates/smlib/src/ops_tests.rs @@ -223,6 +223,24 @@ fn hostile_inputs_are_errors() { assert_untouched(&c, 8000.0, [6, 12, 8]); } +/// Rig case shell/4711: a 60 x 40 x 10 block with an r3 through hole at (22.5, 7), 4 from the +/// front face, and a 10 x 10 notch on that edge, shelled 2 inward open at the bottom: the hole's +/// offset (r5) is tangent to the front's (y = 2), so the walls meet along a line and the offset +/// bounds no solid there. Refused as such; 1.5 (the walls apart) and 2.5 (crossing, merged) +/// build. +#[test] +fn a_shell_whose_walls_would_meet_is_refused_as_such() { + let block = Brep::make_box([0.0; 3], [60.0, 40.0, 10.0]).unwrap(); + let pin = Brep::make_cylinder([22.5, 7.0, -5.0], 3.0, 20.0).unwrap(); + let notch = Brep::make_box([25.0, -5.0, -5.0], [10.0, 10.0, 20.0]).unwrap(); + let part = block.boolean(&pin, BooleanOp::Subtract).unwrap().unwrap().boolean(¬ch, BooleanOp::Subtract).unwrap().unwrap(); + let bottom = [[50.0, 30.0, 0.0]]; + assert_eq!(part.shell(&bottom, 0.1, -2.0).unwrap_err(), Error::WallsTouch); + for t in [1.5, 2.5] { + shot(&part.shell(&bottom, 0.1, -t).unwrap(), &format!("shell-4711-{t}")); + } +} + #[test] fn boolean_history_through_tagged_operands() { // A slot across the top of the cube: the cube's 6 faces give 7 result faces (the top is cut diff --git a/tests/kernel-cases/shell/4711-shell-block-with-hole-clipped-by-notch/expected.json b/tests/kernel-cases/shell/4711-shell-block-with-hole-clipped-by-notch/expected.json index b24bdcebb..7fd02ee41 100644 --- a/tests/kernel-cases/shell/4711-shell-block-with-hole-clipped-by-notch/expected.json +++ b/tests/kernel-cases/shell/4711-shell-block-with-hole-clipped-by-notch/expected.json @@ -2,9 +2,9 @@ "sources": [ "tangency-labs/solidcraft#4711" ], - "what": "a 2 mm shell, open at the bottom, of a 60x40x10 block whose r3 through hole breaks out into a 10x10 notch at its edge: truck took 75 s and failed ('boolean Cut: no result')", + "what": "a 2 mm shell, open at the bottom, of a 60x40x10 block with an r3 through hole 4 mm from its front face, beside a 10x10 notch at that edge: the walls from the hole and from the front would meet along a line, so the right answer is a refusal that says so (truck took 75 s and failed ('boolean Cut: no result'); SMLib refused it, but as 'status 1027')", "source": "invariants", - "method": "every wall has room for 2 mm (the thinnest, between the hole and the block's side, is 4 mm), so the shell exists: one valid closed body with one shell, open at the bottom. The cavity's corners at the hole's break-out follow the offset surfaces, so the volume is not closed-form (the reporter's script)", - "body_count": 1, - "shells": 1 + "method": "the hole (centre (22.5, 7), r3) is 7 - 3 = 4 mm from the front face y = 0, and two 2 mm walls take 4 = 2 x 2 mm: the hole wall's offset (r 3 + 2 = 5) is tangent to the front's (y = 2) at (22.5, 2), so the cavity pinches to zero thickness along the line x = 22.5, y = 2, which bounds no solid. A thinner wall leaves the walls apart, a thicker one makes them cross and merge; at exactly 2 mm the shell is refused, naming the cause. Expected message: \"shell: the 2 mm walls would meet along a line (between a hole and the side, for example), which leaves no solid there; use a thinner or thicker wall, or move the feature\".", + "outcome": "refused", + "refusal": "shell: the 2 mm walls would meet along a line (between a hole and the side, for example), which leaves no solid there; use a thinner or thicker wall, or move the feature" }