Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Sheet metal: a hole leaves sheet parts it cannot reach untouched (#10226)

kaltenbrunnermarkus0d8eebbea6a7
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs
index d6bcc46624..7824a93702 100644
--- a/crates/doc/src/eval.rs
+++ b/crates/doc/src/eval.rs
@@ -4895,11 +4895,17 @@ fn sheet_hole_cut(
_ => done,
};
if done.is_empty() {
+ // A sheet whose box lies clear of the tool's cannot meet it (#10226).
+ let reach = more::body_box(tool);
let mut meets = false;
for sheet in &st.sheets {
- if let Some(mb) = st.body(&sheet.body)
- && kernel::boolean(&mb.body, tool, BoolOp::Intersect)?.is_some()
- {
+ let Some(mb) = st.body(&sheet.body) else { continue };
+ if more::boxes_apart(&more::mesh_box(mb), &reach) {
+ continue;
+ }
+ #[cfg(test)]
+ cost_tests::count(|c| c.cut += 1);
+ if kernel::boolean(&mb.body, tool, BoolOp::Intersect)?.is_some() {
meets = true;
break;
}
diff --git a/crates/doc/src/eval_cost_tests.rs b/crates/doc/src/eval_cost_tests.rs
index 3396f5f7f4..170df145a7 100644
--- a/crates/doc/src/eval_cost_tests.rs
+++ b/crates/doc/src/eval_cost_tests.rs
@@ -1360,6 +1360,15 @@ fn flat_sheet(doc: &mut Document, corner: Vec2, w: f64, h: f64) {
doc.add_feature(FeatureKind::SheetBase { sketch: SketchId(sketch), profiles: ProfileSel::All, rule: None, flip: false }, None).unwrap();
}
+/// A hole of `diameter` at `position`, drilling along `direction` through all.
+fn hole(position: Vec3, direction: Vec3, diameter: f64) -> FeatureKind {
+ serde_json::from_value(serde_json::json!({
+ "type": "hole", "position": [position.x, position.y, position.z], "direction": [direction.x, direction.y, direction.z],
+ "diameter": diameter.to_string(),
+ }))
+ .unwrap()
+}
+
/// The sheet metal bodies of a model.
fn sheet_bodies(model: &Model) -> Vec<String> {
model.state().sheets.iter().map(|s| s.body.clone()).collect()
@@ -1410,3 +1419,43 @@ fn a_tapped_hole_reads_the_bodies_along_its_drill_line() {
assert_eq!(threads[0].body, "Plate");
assert!(threads[0].internal && (threads[0].radius - 2.5).abs() < 1e-6);
}
+
+/// A hole leaves the sheets it cannot reach as they were, without drilling, checking or cutting
+/// each one: in a design of many sheet parts that was most of a hole's time (#10226).
+#[test]
+fn a_hole_leaves_sheets_it_cannot_reach_as_they_were() {
+ let mut doc = Document::new("far sheets");
+ for i in 0..5 {
+ flat_sheet(&mut doc, Vec2::new(200.0 * i as f64, 0.0), 150.0, 100.0);
+ }
+ block(&mut doc, "Plate", Vec3::new(0.0, -200.0, 0.0), [60.0, 60.0, 12.0]);
+ let work = cut_work(&mut doc, hole(Vec3::new(30.0, -170.0, 12.0), Vec3::new(0.0, 0.0, -1.0), 6.0));
+ let sheets = sheet_bodies(&work.model);
+ assert_eq!(sheets.len(), 5);
+ assert_eq!(work.cut, 1, "only the plate goes through a boolean");
+ assert_eq!(work.kept, sheets, "every sheet is left as it was");
+ assert!(volume(&work.model, "Plate") < 43_200.0 - 300.0, "and the plate is drilled");
+}
+
+/// A hole drilled into a sheet's rim still bores that sheet, beside sheets it cannot reach.
+#[test]
+fn a_hole_into_a_rim_still_bores_its_sheet_beside_far_ones() {
+ let mut doc = Document::new("rim");
+ for i in 0..4 {
+ flat_sheet(&mut doc, Vec2::new(200.0 * i as f64, 0.0), 60.0, 40.0);
+ }
+ let mut model = Model::new();
+ model.evaluate(&doc);
+ let near = sheet_bodies(&model)[0].clone();
+ let whole = volume(&model, &near);
+ let d = 1.5;
+ let work = cut_work(&mut doc, hole(Vec3::new(60.0, 20.0, 1.25), Vec3::new(-1.0, 0.0, 0.0), d));
+ assert_eq!(work.cut, 1, "only the sheet the drill meets is bored");
+ assert_eq!(work.kept, sheet_bodies(&work.model)[1..]);
+ let state = work.model.state();
+ let sheet = state.sheets.iter().find(|s| s.body == near).unwrap();
+ assert_eq!(sheet.bores.len(), 1, "kept as a bore of the sheet");
+ let removed = whole - volume(&work.model, &near);
+ let bore = std::f64::consts::PI * (d / 2.0).powi(2) * 60.0;
+ assert!((removed - bore).abs() < 0.02 * bore, "removed {removed} of {bore}");
+}
diff --git a/crates/doc/src/eval_more.rs b/crates/doc/src/eval_more.rs
index 788a03f02c..bb2635ceed 100644
--- a/crates/doc/src/eval_more.rs
+++ b/crates/doc/src/eval_more.rs
@@ -1265,12 +1265,23 @@ pub(super) fn sheet_primitive_cut(
/// panel at an angle).
pub(super) fn sheet_bore_cut(f: &Feature, st: &mut ModelState, prism: PrimitivePrism) -> Result<Option<Vec<String>>> {
let PrimitivePrism::Cylinder { base, axis, radius, height } = prism else { return Ok(None) };
+ // Drilling a sheet builds each of its panels and runs a boolean on it, only to find that a
+ // drill far off meets none (#10226): a sheet whose box lies clear of the drill's is left out.
+ // Both boxes are grown past how far the exact faces curve out from their meshes, as for
+ // the other sheet cuts. A drill a sheet refuses whatever it meets (not a cylinder, or the
+ // sheet holds all the bores it may) is still put to every sheet.
+ let reach = drill_box(base, axis, radius, height);
let mut plans = Vec::new();
for original in &st.sheets {
if !sheet_eligible(f, st, &[], original) {
continue;
}
+ if !original.bores_full() && st.body(&original.body).is_some_and(|mb| boxes_apart(&mesh_box(mb), &reach)) {
+ continue;
+ }
let mut sh = original.clone();
+ #[cfg(test)]
+ super::cost_tests::count(|c| c.cut += 1);
match sh.add_bore(base, axis, radius, height) {
Ok(true) => {}
Ok(false) => continue,
@@ -1297,6 +1308,16 @@ pub(super) fn sheet_bore_cut(f: &Feature, st: &mut ModelState, prism: PrimitiveP
Ok(Some(handled))
}
+/// [`body_box`] of a hole's drill as [`crate::sheet::SheetBody::add_bore`] makes it; None
+/// (never apart) for a drill it refuses.
+fn drill_box(base: Vec3, axis: Vec3, radius: f64, height: f64) -> Option<Aabb3> {
+ let axis = axis.normalized()?;
+ if ![base.x, base.y, base.z, radius, height].iter().all(|v| v.is_finite()) || !(radius > 0.0) || height == 0.0 {
+ return None;
+ }
+ body_box(&kernel::cylinder(base, axis, radius, height).ok()?)
+}
+
/// The most hole tools machined in one pass by [`sheet_drill_cuts`].
const MAX_DRILLS_AT_ONCE: usize = 1000;
diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rs
index 074a2425d5..cfaf9a0017 100644
--- a/crates/doc/src/sheet.rs
+++ b/crates/doc/src/sheet.rs
@@ -1942,6 +1942,11 @@ impl SheetBody {
Ok(body)
}
+ /// Whether the sheet holds all the bores it may: [`Self::add_bore`] refuses any more.
+ pub(crate) fn bores_full(&self) -> bool {
+ self.bores.len() >= MAX_BORES
+ }
+
/// Record a round bore drilled along the sheet (a hole into a rim): the world cylinder from
/// `base` along `axis`, one record per panel whose material it meets. Ok(false) when it
/// meets no material; an error when it meets a bend, or crosses a panel other than along
@@ -1951,7 +1956,7 @@ impl SheetBody {
if ![base.x, base.y, base.z, radius, height].iter().all(|v| v.is_finite()) || !(radius > 0.0) || height == 0.0 {
return Err(DocError::Invalid("invalid sheet bore".into()));
}
- if self.bores.len() >= MAX_BORES {
+ if self.bores_full() {
return Err(flat_budget_error());
}
let mut work = FlatWork::new();