SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Join a floor into the hole it fills: grow the boss into the wall around it (#1212) (#1217)
Tobias Brecklea629236650c4
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rsindex 2ad0dbe8c1..9ecfc01a98 100644--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@ -195,6 +195,35 @@ fn join_meeting_nothing_keeps_the_first_body() {assert!(rel(volume(&mut s), 1064.0) < 1e-6);}+/// A 1 mm floor extruded into a through hole, from the sketch the plate was extruded from: the+/// disc's wall lies on the hole's and its foot in the plate's bottom face. A wedge extruded+/// sideways on top keeps the plate from being a prism along Z (the 2D route would take it+/// otherwise), and the join failed with "boolean Union: the operation failed: no result".+#[test]+fn join_a_floor_into_a_through_hole() {+ let mut s = Session::default();+ run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Plate"}));+ run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [100, 60]}));+ run(&mut s, "sketch.circle.center", json!({"center": [60, 30], "radius": 20}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch": "Plate", "profiles": [{"point": [5, 5]}], "distance": 10}));+ run(&mut s, "sketch.create", json!({"plane": "XZ", "name": "Wedge"}));+ run(&mut s, "sketch.line", json!({"points": [[5, -10], [25, -10], [5, -16]], "closed": true}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch": "Wedge", "distance": 40, "operation": "join"}));+ let before = volume(&mut s);+ run(&mut s, "solid.extrude", json!({"sketch": "Plate", "profiles": [{"point": [60, 30]}], "distance": 1, "operation": "join"}));+ let st = s.model.state();+ assert_eq!(st.bodies.len(), 1);+ assert_eq!(st.bodies[0].body.lumps().unwrap().len(), 1);+ assert!(st.bodies[0].body.validity().is_empty(), "{:?}", st.bodies[0].body.validity());+ // Exact: the disc isn't moved to get the bodies to intersect, so the feature has no warning.+ let warning = s.model.results.last().and_then(|r| r.warning.clone());+ assert!(warning.is_none(), "{warning:?}");+ let added = volume(&mut s) - before;+ assert!(rel(added, PI * 400.0) < 1e-3, "{added}");+}+/// Two spheres of one size: the join's contact test tried every pair of their finely meshed/// triangles and refused the join as too much work (#232).#[test]diff --git a/crates/kernel/src/boolean_diagnostics.rs b/crates/kernel/src/boolean_diagnostics.rsindex f29dc10e86..e12e407e4b 100644--- a/crates/kernel/src/boolean_diagnostics.rs+++ b/crates/kernel/src/boolean_diagnostics.rs@@ -14,6 +14,8 @@ pub enum BooleanStrategy {ShiftedOperands,CoplanarSeparation,CommonBore,+ /// A boss in the other body's bore, grown into the material around it (nothing recut).+ GrownBoss,PlanarFallback,ToolNudge,Piecewise,@@ -34,6 +36,15 @@ pub struct BooleanFallback {pub tolerance_mm: f64,}+impl BooleanStrategy {+ /// Whether a result made this way can differ from the exact one: the tool was moved+ /// against the other body, or part of where they meet was ignored. The other retries work+ /// on temporary geometry or tolerances only, and their results are the exact ones.+ pub fn alters_result(self) -> bool {+ matches!(self, BooleanStrategy::ToolNudge | BooleanStrategy::UnverifiedShortcut)+ }+}+impl BooleanFallback {pub(crate) fn new(strategy: BooleanStrategy) -> Self {Self { strategy, translation_mm: 0., rotation_rad: 0., face_shift_mm: 0., tolerance_mm: 0. }@@ -47,6 +58,7 @@ impl BooleanFallback {}BooleanStrategy::CoplanarSeparation => format!("temporary coincident-face separation up to {:.6e} mm per face", self.face_shift_mm),BooleanStrategy::CommonBore => format!("temporary bore offset {:.6e} mm, followed by recutting the original bore", self.face_shift_mm),+ BooleanStrategy::GrownBoss => format!("boss grown {:.6e} mm into the material around the bore it fills", self.face_shift_mm),BooleanStrategy::PlanarFallback => "exact planar fallback (no displacement)".into(),BooleanStrategy::ToolNudge => format!("tool displacement {:.6e} mm, rotation {:.6e} rad", self.translation_mm, self.rotation_rad),BooleanStrategy::Piecewise => "piecewise retry (no displacement)".into(),@@ -79,13 +91,26 @@ impl BooleanDiagnostics {self.events.iter().find(|event| event.strategy == BooleanStrategy::UnverifiedShortcut).map(BooleanFallback::description)}+ /// Every retry the result took, for a message about the boolean (one that failed its+ /// checks lists what was tried).+ pub fn summary(&self) -> Option<String> {+ self.described(&self.events.iter().collect::<Vec<_>>())+ }++ /// The note a feature carries: the retries that can make its result differ from the exact+ /// one ([`BooleanStrategy::alters_result`]). Exact retries are in `events` all the same+ /// (`timeline.inspect`), but they leave the result as it should be: no reason to warn.pub fn warning(&self) -> Option<String> {- if self.events.is_empty() && !self.truncated {+ self.described(&self.events.iter().filter(|e| e.strategy.alters_result()).collect::<Vec<_>>())+ }++ fn described(&self, events: &[&BooleanFallback]) -> Option<String> {+ if events.is_empty() && !self.truncated {return None;}- let mut descriptions: Vec<String> = self.events.iter().take(4).map(BooleanFallback::description).collect();- if self.events.len() > 4 {- descriptions.push(format!("{} additional retries", self.events.len() - 4));+ let mut descriptions: Vec<String> = events.iter().take(4).map(|e| e.description()).collect();+ if events.len() > 4 {+ descriptions.push(format!("{} additional retries", events.len() - 4));}if self.truncated {descriptions.push(format!("report capped at {MAX_EVENTS} retries"));@@ -169,6 +194,26 @@ mod tests {assert!(capture_boolean_diagnostics(|| {}).1.events.is_empty());}+ /// Only retries whose result can differ from the exact one make a warning; the summary+ /// lists every retry.+ #[test]+ fn only_retries_that_alter_the_result_warn() {+ let report = |strategies: &[BooleanStrategy]| {+ capture_boolean_diagnostics(|| {+ for s in strategies {+ record(BooleanFallback::new(*s));+ }+ })+ .1+ };+ let exact = report(&[BooleanStrategy::ShiftedOperands, BooleanStrategy::GrownBoss, BooleanStrategy::CoplanarSeparation]);+ assert!(exact.warning().is_none(), "{exact:?}");+ assert!(exact.summary().is_some_and(|s| s.contains("shifted operands") && s.contains("boss grown")));+ let nudged = report(&[BooleanStrategy::GrownBoss, BooleanStrategy::ToolNudge]);+ let warning = nudged.warning().unwrap();+ assert!(warning.contains("tool displacement") && !warning.contains("boss grown"), "{warning}");+ }+#[test]fn exact_operations_and_failed_calls_have_no_retry_report() {use solidcraft_geom::Vec3;diff --git a/crates/kernel/src/coplanar.rs b/crates/kernel/src/coplanar.rsindex ab0f71edf9..364bc9550e 100644--- a/crates/kernel/src/coplanar.rs+++ b/crates/kernel/src/coplanar.rs@@ -989,6 +989,9 @@ pub(crate) fn has_coincident_cylinders(a: &Body, b: &Body) -> bool {/// This is not a general emptiness or Boolean-equivalence certificate. Each direction/// returns a result only when `accept` takes it; otherwise this returns `None`. The result's/// history is over `[a, b]`.+///+/// A boss standing in the other body's bore on that cylinder (a disc joined into the bottom of+/// a hole it fills) is grown instead ([`grown_boss_union`]).pub(crate) fn bore_union(a: &Body, b: &Body, accept: &dyn Fn(&Body) -> bool) -> Option<Body> {let size = a.size().max(b.size());let tol = (size * 1e-7).max(1e-9) * 10.0;@@ -997,10 +1000,10 @@ pub(crate) fn bore_union(a: &Body, b: &Body, accept: &dyn Fn(&Body) -> bool) ->let (ia, ib) = (ma.inside_index(), mb.inside_index());let empty = |p: Vec3| !ia.contains(p) && !ib.contains(p);let (ca, cb) = (cylinders(a), cylinders(b));- // (body to narrow, its operand number, its mesh and inside test, the other body, their faces- // on the cylinder).- let ways = [(b, 1, &mb, &ib, a, &cb, &ca), (a, 0, &ma, &ia, b, &ca, &cb)];- for (tool, tool_operand, mesh, inside, target, ct, co) in ways {+ // (body to narrow, its operand number, its mesh and inside test, the other body and its+ // inside test, their faces on the cylinder).+ let ways = [(b, 1, &mb, &ib, a, &ia, &cb, &ca), (a, 0, &ma, &ia, b, &ib, &ca, &cb)];+ for (tool, tool_operand, mesh, inside, target, target_inside, ct, co) in ways {for c in ct {if !co.iter().any(|o| same_cylinder(c, o, tol)) {continue;@@ -1032,6 +1035,13 @@ pub(crate) fn bore_union(a: &Body, b: &Body, accept: &dyn Fn(&Body) -> bool) ->let Some(radial) = (q - along).normalized() else { continue };let on = along + radial * c.radius;let e = (c.radius * 0.05).max(size * 1e-4);+ if inside.contains(on - radial * e) && !inside.contains(on + radial * e) {+ let boss = Boss { tool, operand: tool_operand, cylinder: c, faces: &bore, t0, t1 };+ if let Some(r) = grown_boss_union(a, b, &boss, target_inside, size, accept) {+ return Some(r);+ }+ continue;+ }if !(inside.contains(on + radial * e) && !inside.contains(on - radial * e)) {continue;}@@ -1099,6 +1109,127 @@ pub(crate) fn bore_union(a: &Body, b: &Body, accept: &dyn Fn(&Body) -> bool) ->None}+/// A tool (operand `operand`) with faces on a cylinder it shares with the other body, the+/// material inside them (a boss), and its extent `t0..t1` along the axis there.+struct Boss<'a> {+ tool: &'a Body,+ operand: usize,+ cylinder: &'a CylFace,+ faces: &'a [usize],+ t0: f64,+ t1: f64,+}++/// Union of `a` and `b` where one has a boss on a cylinder that is a bore of the other body (a disc joined into the bottom of a hole it fills): the boss's walls+/// coincide with the bore's, which the mesh intersection can't take. Grown outward by a step,+/// the boss reaches into the material around the bore instead, and joining it adds nothing+/// more, provided that material is there all along the boss. The ring the step adds is sampled+/// against the other body for that, and `accept` checks the result as a whole. The result's+/// history is over `[a, b]` (the grown tool keeps the tool's faces and edges).+fn grown_boss_union(+ a: &Body,+ b: &Body,+ boss: &Boss,+ target_inside: &solidcraft_geom::InsideIndex,+ size: f64,+ accept: &dyn Fn(&Body) -> bool,+) -> Option<Body> {+ let c = boss.cylinder;+ let d = (c.radius * 0.2).min(size * 0.01);+ let (u, w) = (c.axis.any_perp(), c.axis.cross(c.axis.any_perp()));+ let at = |s: f64, r: f64, ang: f64| c.origin + c.axis * s + (u * ang.cos() + w * ang.sin()) * r;+ // The other body's material all around the boss, as far out as it grows, over its length.+ let backed = (1..=9).all(|i| {+ let s = boss.t0 + (boss.t1 - boss.t0) * f64::from(i) / 10.0;+ (0..16).all(|k| {+ let ang = f64::from(k) * std::f64::consts::FRAC_PI_8 + 0.3;+ [0.1, 0.5, 0.95].iter().all(|f| target_inside.contains(at(s, c.radius + d * f, ang)))+ })+ });+ if !backed {+ return None;+ }+ // Ends where the bore comes out of the other body and the boss's cap lies flush with the+ // face it comes out of (a floor at the bottom of a through hole): faces in one plane, which+ // the intersection can't take either. There the cap is moved out by the same step, and the+ // stub that leaves past the face is deleted afterwards, the face healing over it.+ let tol = (size * 1e-7).max(1e-9) * 10.0;+ let target = if boss.operand == 1 { a } else { b };+ let along = |p: Vec3| (p - c.origin).dot(c.axis);+ let radial = |p: Vec3| (p - c.origin - c.axis * along(p)).len();+ let plane_at = |body: &Body, i: usize, s: f64, out: f64| {+ matches!(crate::face_surface(body, i), Some(crate::FaceSurface::Plane { normal, point })+ if normal.dot(c.axis) * out > 1.0 - 1e-9 && (along(point) - s).abs() < tol)+ };+ let mut caps: Vec<(usize, f64, f64)> = Vec::new();+ for (s, out) in [(boss.t0, -1.0), (boss.t1, 1.0)] {+ let open = (0..8).all(|k| {+ let ang = f64::from(k) * std::f64::consts::FRAC_PI_4 + 0.3;+ !target_inside.contains(at(s + out * d * 0.5, c.radius + d * 0.5, ang))+ });+ if !open || !(0..target.face_count()).any(|i| plane_at(target, i, s, out)) {+ continue;+ }+ let cap = boss+ .tool+ .solid+ .face_iter()+ .enumerate()+ .position(|(i, f)| plane_at(boss.tool, i, s, out) && f.vertex_iter().all(|v| radial(from_p3(v.point())) < c.radius + tol));+ // A flush end with no cap of its own to move: the faces would stay in one plane.+ caps.push((cap?, s, out));+ }+ let counts = record::counts(&[a, b]);+ let run = || -> Result<Option<Body>> {+ let grown = crate::offset::offset_body(boss.tool, |i, _| if boss.faces.contains(&i) || caps.iter().any(|x| x.0 == i) { d } else { 0.0 })?;+ if !grown.validity().is_empty() {+ return Err(KernelError::Failed("growing a boss: an unsound result".into()));+ }+ // In the operands' order, so the history is over [a, b] once the grown tool's own is+ // composed in.+ let joined = if boss.operand == 1 { crate::ops::boolean(a, &grown, BoolOp::Union)? } else { crate::ops::boolean(&grown, b, BoolOp::Union)? };+ let Some(joined) = joined else { return Ok(None) };+ let joined = {+ let h = crate::boolean_record::through(&joined, boss.operand, grown.history());+ joined.with_checked_history(h, &counts)+ };+ if caps.is_empty() {+ return Ok(Some(joined));+ }+ // The stubs: faces wholly past a flush end, within the grown boss, reaching out to its cap.+ let stubs: Vec<usize> = joined+ .solid+ .face_iter()+ .enumerate()+ .filter(|(_, f)| {+ let ps: Vec<Vec3> = f.vertex_iter().map(|v| from_p3(v.point())).collect();+ caps.iter().any(|&(_, s, out)| {+ let past = |p: &Vec3| (along(*p) - s) * out;+ !ps.is_empty() && ps.iter().all(|p| past(p) > -tol && radial(*p) < c.radius + d * 1.01) && ps.iter().any(|p| past(p) > d * 0.5)+ })+ })+ .map(|(i, _)| i)+ .collect();+ if stubs.is_empty() {+ return Err(KernelError::Failed("growing a boss: no stub past its flush end".into()));+ }+ let healed = crate::delete_faces(&joined, &stubs)?;+ let h = crate::boolean_record::through(&healed, 0, joined.history());+ Ok(Some(healed.with_checked_history(h, &counts)))+ };+ let (result, diagnostics) = crate::capture_boolean_diagnostics(run);+ match result {+ Ok(Some(r)) if accept(&r) => {+ crate::boolean_diagnostics::merge(diagnostics);+ let mut event = crate::BooleanFallback::new(crate::BooleanStrategy::GrownBoss);+ event.face_shift_mm = d;+ crate::boolean_diagnostics::record(event);+ Some(r)+ }+ _ => None,+ }+}+#[cfg(test)]#[path = "coplanar_tests.rs"]mod tests;diff --git a/crates/kernel/src/coplanar_tests.rs b/crates/kernel/src/coplanar_tests.rsindex a93382a12c..a474c03c13 100644--- a/crates/kernel/src/coplanar_tests.rs+++ b/crates/kernel/src/coplanar_tests.rs@@ -75,3 +75,24 @@ fn faces_with_room_are_pushed_apart() {let (added, lumps, how) = change(&block, &pad, BoolOp::Union);assert!((added - 30_000.0).abs() < 1e-6 && lumps == 1 && used(&how, BooleanStrategy::CoplanarSeparation), "{added}, {how:?}");}++/// A disc joined into a round hole it fills (issue: "boolean Union: no result" for a 1 mm+/// floor extruded into a through hole of a part that isn't a prism). The disc's wall lies on+/// the hole's, and at either end its face lies in the block's bottom or top face: it adds its+/// own volume, the block stays one piece, and the hole is closed where the disc is.+#[test]+fn a_disc_joined_into_the_hole_it_fills() {+ let hole = cylinder(Vec3::new(150.0, 50.0, -1.0), Vec3::Z, 20.0, 22.0).unwrap();+ let drilled = boolean(&block(200.0, 100.0, 20.0), &hole, BoolOp::Cut).unwrap().unwrap();+ for (z0, z1) in [(0.0, 1.0), (5.0, 8.0), (19.0, 20.0)] {+ let disc = cylinder(Vec3::new(150.0, 50.0, z0), Vec3::Z, 20.0, z1 - z0).unwrap();+ let want = measure(&disc).unwrap().volume;+ let (r, how) = capture_boolean_diagnostics(|| boolean(&drilled, &disc, BoolOp::Union));+ let r = r.unwrap().unwrap();+ let added = measure(&r).unwrap().volume - measure(&drilled).unwrap().volume;+ assert!((added - want).abs() < want * 1e-3, "{z0}..{z1}: {added} vs {want}, {how:?}");+ assert!(r.lumps().unwrap().len() == 1 && r.validity().is_empty(), "{z0}..{z1}: {:?}", r.validity());+ // Exact: nothing of the tool is moved.+ assert!(used(&how, BooleanStrategy::GrownBoss) && !used(&how, BooleanStrategy::ToolNudge), "{z0}..{z1}: {how:?}");+ }+}diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rsindex 14eaf39611..4ea3dfc444 100644--- a/crates/kernel/src/ops.rs+++ b/crates/kernel/src/ops.rs@@ -362,7 +362,7 @@ fn boolean_via(a: &Body, b: &Body, op: BoolOp, whole: &dyn Fn(&Body, &Body, Bool&& let Ok(result) = &r&& let Err(e) = crate::boolean_guard::check_retry(a, b, op, result.as_ref()){- let tried = diagnostics.warning().unwrap_or_default();+ let tried = diagnostics.summary().unwrap_or_default();r = Err(match e {KernelError::Failed(m) => KernelError::Failed(format!("{m} ({})", tried.trim_start_matches("Boolean retry: "))),other => other,@@ -593,6 +593,18 @@ fn boolean_whole(a: &Body, b: &Body, op: BoolOp) -> Result<Option<Body>> {return Ok(Some(body));}}+ // Bores on a common cylinder (a pad's bore around the hole it is joined over, a disc filling+ // a hole). Asked before faces are pushed apart: that doesn't part walls on one cylinder, and+ // its tries at the general boolean, all failing on those walls, cost seconds.+ if op == BoolOp::Union && !BORES.with(|c| c.get()) && crate::coplanar::has_coincident_cylinders(a, b) {+ BORES.with(|c| c.set(true));+ let (r, diagnostics) = capture_boolean_diagnostics(|| crate::coplanar::bore_union(a, b, &|body| check(body).0));+ BORES.with(|c| c.set(false));+ if let Some(body) = r {+ merge(diagnostics);+ return Ok(Some(body));+ }+ }// Coincident planar faces: push them apart (exactly). Tried once, before the general// boolean; why it failed is reported if everything else fails too.let mut apart_failed = String::new();@@ -646,16 +658,6 @@ fn boolean_whole(a: &Body, b: &Body, op: BoolOp) -> Result<Option<Body>> {{return Ok(Some(body));}- // Bores on a common cylinder (a pad's bore around the hole it is joined over).- if op == BoolOp::Union && !BORES.with(|c| c.get()) && crate::coplanar::has_coincident_cylinders(a, b) {- BORES.with(|c| c.set(true));- let (r, diagnostics) = capture_boolean_diagnostics(|| crate::coplanar::bore_union(a, b, &|body| check(body).0));- BORES.with(|c| c.set(false));- if let Some(body) = r {- merge(diagnostics);- return Ok(Some(body));- }- }// Faces back to back over part of their area: imprinted on each other and glued (exact; held// to the retry guard's checks all the same).if op == BoolOp::Union && crate::coplanar::faces_touch(a, b) {diff --git a/docs/robustness.md b/docs/robustness.mdindex f775f153d5..3516f46837 100644--- a/docs/robustness.md+++ b/docs/robustness.md@@ -56,8 +56,11 @@ The changed seeds and the reason are added to the file's `notes`; say why in the## Successful Boolean retries-When an accepted Boolean result needs a numerical retry, the feature shows a-warning in the timeline. `timeline.inspect` and `doc.inspect` expose its+When an accepted Boolean result needs a retry that can make it differ from the+exact one (a tool nudge, or the unverified shortcut), the feature shows a+warning in the timeline. Every other retry works on temporary geometry or+tolerances and leaves the exact result, so it is recorded but not warned about.+`timeline.inspect` and `doc.inspect` expose every retry in the feature's`boolean_diagnostics`, including the strategy and the applied translation,rotation, face offset and tessellation tolerance in millimetres/radians.@@ -77,7 +80,7 @@ Exact planar and piecewise fallbacks report zero displacement. The existingvolume and spatial acceptance checks still apply to all results.The command that adds a feature carries the same `warning` in its reply, so a-script or an agent sees a retry without asking the timeline.+script or an agent sees such a retry without asking the timeline.A join or a cut that needed any retry is then held to what it can do at all(`crates/kernel/src/boolean_guard.rs`, #616): the result is closed, a join