SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sheet metal: material joined in the plane of a panel is kept (#6843) (#6855)
NOWN-DEV9432cdfee8dd
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex b274092259..f0159c7370 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -5741,7 +5741,9 @@ fn feature_tools_with_constructor(let start = if hi > 0.0 { lo + off } else { hi + off };tools = trim_to_body(tools, tb, |q: Vec3| ((q - ss.plane.origin).dot(n) - start).abs())?;}- if untrimmed {+ // A join's profile grows into the material it joins; its sketch plane and depth as drawn+ // still serve a join into sheet metal (`sheet_join`), which takes the sketch's regions.+ if untrimmed || (*operation == Operation::Join && curved.is_none()) {*constructor = Some(ExtrudeConstructor { plane: ss.plane, interval: (lo + off, hi + off) });}// A Join tool's faces outlive the boolean where they stay on the result, so they are@@ -7653,6 +7655,14 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:return apply_beside_sheet_cut(doc, st, f, tools, *operation, &crate::plain(targets), &handled);}}+ // A join one sheet thick in the plane of a panel becomes part of that panel. A Join to an+ // object (#6424) is left to the generic path below, which joins the object as well.+ if *operation == Operation::Join && to_body.is_none() && matches!(f.kind, FeatureKind::Extrude { .. }) && !st.sheets.is_empty() {+ let bodies: Vec<Body> = tools.iter().map(|t| t.body.clone()).collect();+ if !more::sheet_join(f, st, &bodies, &crate::plain(targets), constructor.as_ref())?.is_empty() {+ return Ok(());+ }+ }// A Join extrude to an object joins that object too (#6424): the tool and the body// it runs to are one body, not only the body the profile was sketched on.let extra: Vec<String> = if *operation == Operation::Join { to_body.into_iter().collect() } else { Vec::new() };diff --git a/crates/doc/src/eval_more.rs b/crates/doc/src/eval_more.rsindex 29c9fbbb95..788a03f02c 100644--- a/crates/doc/src/eval_more.rs+++ b/crates/doc/src/eval_more.rs@@ -1034,6 +1034,164 @@ fn extrude_cut(st: &ModelState, f: &Feature) -> Result<Option<ExtrudeCut>> {Ok(Some(ExtrudeCut { plane: ss.plane, regions, text, operation: *operation, bound: extent.to.is_some() }))}+/// An untapered extrude join one sheet thick in the plane of a panel of sheet metal (the base or+/// a flange's panel, unfolded or folded) that touches that panel and nothing else of the sheet:+/// the material becomes part of the panel's outline, so the flat pattern, its DXF and a refold+/// keep it, and it follows its sketch's parameters as a cut made there does. Cut-outs it covers+/// are filled. Returns the sheets it took; none (and the generic path's warning) for any other+/// join: another depth, out of every panel's plane, reaching into a bend zone or another panel,+/// apart from the sheet, or over a pocket, label, bore or perforation.+pub(super) fn sheet_join(+ f: &Feature,+ st: &mut ModelState,+ tools: &[Body],+ targets: &[String],+ constructor: Option<&ExtrudeConstructor>,+) -> Result<Vec<String>> {+ let FeatureKind::Extrude { sketch, profiles, operation: Operation::Join, extent, .. } = &f.kind else { return Ok(Vec::new()) };+ if extent.taper.is_some() || tools.is_empty() || !any_eligible_sheet(f, st, targets) {+ return Ok(Vec::new());+ }+ let Some(ss) = st.sketch(sketch.0).cloned() else { return Ok(Vec::new()) };+ // The depth the extrude was given, along its sketch's normal: only an untrimmed extrude has one.+ let Some(c) = constructor.filter(|c| c.plane == ss.plane) else { return Ok(Vec::new()) };+ let regions = solidcraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);+ let plane = ss.plane;+ let n = plane.normal();+ let (lo, hi) = (c.interval.0.min(c.interval.1), c.interval.0.max(c.interval.1));+ let roundoff = 128.0 * f64::EPSILON * (plane.origin.len() + lo.abs() + hi.abs()).max(1.0);+ let mut work = sheet::FlatWork::new();+ let mut plans = Vec::new();+ for original in &st.sheets {+ if !sheet_eligible(f, st, targets, original) {+ continue;+ }+ let Some(sh) = sheet_join_one(original, &plane, n, ®ions, (lo, hi, roundoff), &mut work)? else { return Ok(Vec::new()) };+ let body = sh.solid()?;+ plans.push((sh, body));+ }+ let handled = plans.iter().map(|(sh, _)| sh.body.clone()).collect();+ for (sh, body) in plans {+ if let Some(mb) = st.bodies.iter_mut().find(|b| b.name == sh.body) {+ replace_sheet_body(mb, body);+ }+ if let Some(target) = st.sheets.iter_mut().find(|s| s.body == sh.body) {+ *target = sh;+ }+ }+ Ok(handled)+}++/// [`sheet_join`] on one sheet: the sheet with each of the join's `regions` (in `plane`, the+/// depth `span` along its normal `n`) taken into the one panel it fits, or None where one of them+/// fits none.+fn sheet_join_one(+ original: &sheet::SheetBody,+ plane: &Plane,+ n: Vec3,+ regions: &[Region2],+ span: (f64, f64, f64),+ work: &mut sheet::FlatWork,+) -> Result<Option<sheet::SheetBody>> {+ let (lo, hi, roundoff) = span;+ let sh = original;+ let region_of = |pi: Option<usize>| match pi {+ None => Some(sh.base.clone()),+ Some(i) => sh.flanges.get(i).map(|f| sh.panel(f)),+ };+ let all: Vec<Option<usize>> = std::iter::once(None).chain((0..sh.flanges.len()).map(Some)).collect();+ // The panels whose faces are the sheet's thickness apart along the sketch's normal, the join+ // filling exactly that slab.+ let pieces: Vec<Option<usize>> = all+ .iter()+ .copied()+ .filter(|&pi| {+ let w = sh.world(pi);+ let sign = crate::apply_vector(&w, Vec3::Z).dot(n);+ if sign.abs() < 1.0 - 1e-9 {+ return false;+ }+ let zorigin = (apply_point(&w, Vec3::ZERO) - plane.origin).dot(n);+ let (a, b) = ((lo - zorigin) / sign, (hi - zorigin) / sign);+ let tol = 1e-6 + roundoff;+ a.min(b).abs() <= tol && (a.max(b) - sh.t).abs() <= tol+ })+ .collect();+ let zones: Vec<Region2> = sh.flanges.iter().map(|f| sh.zone(f)).collect();+ let touches = |a: &Region2, b: &Region2, work: &mut sheet::FlatWork| -> Result<bool> {+ Ok(sheet::material_boolean(std::slice::from_ref(a), std::slice::from_ref(b), kernel::BoolOp::Union, work)?.len() == 1)+ };+ // Each region joins the one panel it is one piece with, apart from every bend zone and the+ // other panels (touching one along an edge, the flat pattern would lose the cut between them).+ let mut fits: Vec<(Option<usize>, Region2)> = Vec::new();+ for r in regions {+ let mut found = None;+ for &pi in &pieces {+ let Some(piece) = region_of(pi) else { continue };+ let flat = sh.region_to_flat(pi, plane, r)?;+ if !touches(&piece, &flat, work)? {+ continue;+ }+ let mut apart = true;+ for other in zones.iter().cloned().chain(all.iter().filter(|&&q| q != pi).filter_map(|&q| region_of(q))) {+ if touches(&other, &flat, work)? {+ apart = false;+ break;+ }+ }+ if !apart {+ continue;+ }+ if found.is_some() {+ // Two panels in the plane both take it.+ return Ok(None);+ }+ found = Some((pi, flat));+ }+ let Some(fit) = found else { return Ok(None) };+ fits.push(fit);+ }+ // Pockets, labels, bores and perforations keep their own outlines: not under a join yet.+ if !sh.bores.is_empty() || !sh.perforations.is_empty() {+ return Ok(None);+ }+ let flats: Vec<Region2> = fits.iter().map(|(_, r)| r.clone()).collect();+ let covered: f64 = {+ let kept: Vec<Region2> = sh.pockets.iter().map(|p| p.region.clone()).chain(sh.labels.iter().cloned()).collect();+ sheet::material_boolean(&kept, &flats, kernel::BoolOp::Intersect, work)?.iter().map(Region2::area).sum()+ };+ if covered > 1e-9 {+ return Ok(None);+ }+ let mut sh = original.clone();+ for &pi in &all {+ let mine: Vec<Region2> = fits.iter().filter(|(q, _)| *q == pi).map(|(_, r)| r.clone()).collect();+ if mine.is_empty() {+ continue;+ }+ let Some(piece) = region_of(pi) else { return Ok(None) };+ let joined = sheet::material_boolean(std::slice::from_ref(&piece), &mine, kernel::BoolOp::Union, work)?;+ let [one] = joined.as_slice() else { return Ok(None) };+ match pi {+ None => sh.base = one.clone(),+ Some(i) => {+ if !one.holes.is_empty() {+ return Ok(None);+ }+ let Some(f) = sh.flanges.get_mut(i) else { return Ok(None) };+ f.exact = Some(one.outer.clone());+ }+ }+ }+ // Cut-outs it covers are filled.+ let mut holes = Vec::with_capacity(sh.holes.len());+ for h in &sh.holes {+ holes.extend(sheet::material_boolean(std::slice::from_ref(h), &flats, kernel::BoolOp::Cut, work)?);+ }+ sh.holes = holes;+ Ok(Some(sh))+}+/// Whether a cut of `f` with these targets (else its participants, else its component's/// bodies) machines the sheet `original`.fn sheet_eligible(f: &Feature, st: &ModelState, targets: &[String], original: &crate::sheet::SheetBody) -> bool {diff --git a/crates/engine/src/cmd/sheet_tests.rs b/crates/engine/src/cmd/sheet_tests.rsindex 45fa6a3324..38aa771f1f 100644--- a/crates/engine/src/cmd/sheet_tests.rs+++ b/crates/engine/src/cmd/sheet_tests.rs@@ -839,6 +839,99 @@ fn a_pattern_of_a_cut_in_the_flat_is_kept_like_the_cut() {assert!(rel(volume(&mut s), folded - 4.0 * each) < 1e-9, "{} vs {}", volume(&mut s), folded - 4.0 * each);}+/// Material joined in the flat, one sheet thick in the plane of a panel, becomes part of that+/// panel as a cut made there does: kept in the flat pattern and refolded, its size following a+/// parameter. A tab on the base's free edge and one beside the flange's panel. A join that+/// reaches into the bend zone keeps the warning that the flat pattern can't include it.+#[test]+fn a_join_in_the_flat_is_kept_like_a_cut() {+ // The rule's 2.5 mm sheet, R 2.5, K 0.44: the flange on y = 50 sets the base back to y = 45 and+ // bends across BA = π/2·(2.5 + 0.44·2.5); its panel runs on from y = 45 + BA, x 0 to 80.+ let (t, ba) = (2.5, FRAC_PI_2 * (2.5 + 0.44 * 2.5));+ let tab = |s: &mut Session, name: &str, points: Value| {+ run(s, "sketch.create", json!({"plane": "XY", "name": name}));+ run(s, "sketch.line", json!({"points": points, "closed": true}));+ run(s, "sketch.finish", json!({}));+ run(s, "solid.extrude", json!({"sketch": name, "distance": t, "operation": "join", "name": format!("{name}_Join")}))+ };+ let mut s = Session::default();+ run(&mut s, "parameters.add", json!({"name": "TabW", "expression": "10 mm"}));+ base(&mut s, 80.0, 50.0);+ run(&mut s, "sheet.flange", json!({"edges": [[40, 50, 2.5]], "height": 20}));+ let folded = volume(&mut s);+ run(&mut s, "sheet.unfold", json!({}));+ let unfolded = volume(&mut s);+ // 15 x TabW on the base's free edge at x = 80.+ let out = tab(&mut s, "Base_Tab", json!([["80 mm", "10 mm"], ["95 mm", "10 mm"], ["95 mm", "10 mm + TabW"], ["80 mm", "10 mm + TabW"]]));+ assert!(out["warning"].is_null(), "{out}");+ assert!(rel(volume(&mut s), unfolded + 15.0 * 10.0 * t) < 1e-9, "{}", volume(&mut s));+ // 10 x 5 beside the flange's panel, 3 mm past its bend.+ let y = 45.0 + ba + 3.0;+ let out = tab(&mut s, "Panel_Tab", json!([[80, y], [90, y], [90, y + 5.0], [80, y + 5.0]]));+ assert!(out["warning"].is_null(), "{out}");+ let added = |w: f64| 15.0 * w * t + 10.0 * 5.0 * t;+ assert!(rel(volume(&mut s), unfolded + added(10.0)) < 1e-9, "{}", volume(&mut s));+ assert!((flat(&mut s)["flat_size_mm"][0].as_f64().unwrap_or(0.0) - 95.0).abs() < 1e-9);+ run(&mut s, "sheet.refold", json!({}));+ assert!(rel(volume(&mut s), folded + added(10.0)) < 1e-9, "{} vs {}", volume(&mut s), folded + added(10.0));+ run(&mut s, "parameters.change", json!({"name": "TabW", "expression": "20 mm"}));+ assert!(rel(volume(&mut s), folded + added(20.0)) < 1e-9, "{} vs {}", volume(&mut s), folded + added(20.0));+ // One join with a tab on each: each joins the panel it is beside.+ let mut s = Session::default();+ base(&mut s, 80.0, 50.0);+ run(&mut s, "sheet.flange", json!({"edges": [[40, 50, 2.5]], "height": 20}));+ let folded = volume(&mut s);+ run(&mut s, "sheet.unfold", json!({}));+ run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Tabs"}));+ run(&mut s, "sketch.line", json!({"points": [[80, 10], [95, 10], [95, 20], [80, 20]], "closed": true}));+ run(&mut s, "sketch.line", json!({"points": [[80, y], [90, y], [90, y + 5.0], [80, y + 5.0]], "closed": true}));+ run(&mut s, "sketch.finish", json!({}));+ let out = run(&mut s, "solid.extrude", json!({"sketch": "Tabs", "distance": t, "operation": "join"}));+ assert!(out["warning"].is_null(), "{out}");+ run(&mut s, "sheet.refold", json!({}));+ assert!(rel(volume(&mut s), folded + added(10.0)) < 1e-9, "{} vs {}", volume(&mut s), folded + added(10.0));+ // Into the bend zone (it starts at y = 45): the generic path, with its warning.+ let mut s = Session::default();+ base(&mut s, 80.0, 50.0);+ run(&mut s, "sheet.flange", json!({"edges": [[40, 50, 2.5]], "height": 20}));+ run(&mut s, "sheet.unfold", json!({}));+ let out = tab(&mut s, "Zone_Tab", json!([[80, 40], [90, 40], [90, 48], [80, 48]]));+ assert!(out["warning"].as_str().is_some_and(|w| w.contains("can't include this change")), "{out}");+ // The same two tabs in a 1 mm sheet (R 1.18) and a 3 mm one (R 3), each joined one sheet+ // thick: kept, refolded and following the parameter alike.+ for (t, r) in [(1.0, 1.18), (3.0, 3.0)] {+ let what = format!("T {t} R {r}");+ let ba = FRAC_PI_2 * (r + 0.44 * t);+ let mut s = Session::default();+ run(&mut s, "parameters.add", json!({"name": "TabW", "expression": "10 mm"}));+ let rule = json!({"name": "Rule", "active": true, "thickness": format!("{t} mm"), "k_factor": "0.44", "bend_radius": format!("{r} mm")});+ run(&mut s, "sheet.manage_rules", rule);+ base(&mut s, 80.0, 50.0);+ run(&mut s, "sheet.flange", json!({"edges": [[40, 50, t]], "height": 20}));+ let folded = volume(&mut s);+ run(&mut s, "sheet.unfold", json!({}));+ let unfolded = volume(&mut s);+ let join = |s: &mut Session, name: &str, points: Value| {+ run(s, "sketch.create", json!({"plane": "XY", "name": name}));+ run(s, "sketch.line", json!({"points": points, "closed": true}));+ run(s, "sketch.finish", json!({}));+ run(s, "solid.extrude", json!({"sketch": name, "distance": t, "operation": "join"}))+ };+ let out = join(&mut s, "Base_Tab", json!([["80 mm", "10 mm"], ["95 mm", "10 mm"], ["95 mm", "10 mm + TabW"], ["80 mm", "10 mm + TabW"]]));+ assert!(out["warning"].is_null(), "{what}: {out}");+ // The panel starts BA past the base, set back R + T from y = 50.+ let y = 50.0 - (r + t) + ba + 3.0;+ let out = join(&mut s, "Panel_Tab", json!([[80, y], [90, y], [90, y + 5.0], [80, y + 5.0]]));+ assert!(out["warning"].is_null(), "{what}: {out}");+ let added = |w: f64| 15.0 * w * t + 10.0 * 5.0 * t;+ assert!(rel(volume(&mut s), unfolded + added(10.0)) < 1e-9, "{what}: {}", volume(&mut s));+ run(&mut s, "sheet.refold", json!({}));+ assert!(rel(volume(&mut s), folded + added(10.0)) < 1e-9, "{what}: {} vs {}", volume(&mut s), folded + added(10.0));+ run(&mut s, "parameters.change", json!({"name": "TabW", "expression": "20 mm"}));+ assert!(rel(volume(&mut s), folded + added(20.0)) < 1e-9, "{what}: {} vs {}", volume(&mut s), folded + added(20.0));+ }+}+/// A plate (15, -20) (0, 0) (-100, 0) (-100, -20) with a 20 mm inside flange on its slanted edge/// (2 mm sheet, R 2, K 0.5: the folded sheet holds its flat area times the thickness), unfolded,/// and a triangle cut out with a corner on the bend line: where the line ends on the plate's@@ -5860,9 +5953,10 @@ fn flat_exports(s: &mut Session) -> Vec<std::result::Result<Value, String>> {calls.iter().map(|(id, p)| s.execute(id, p).map_err(|e| e.to_string())).collect()}-/// A mirror combined into a sheet, or a tab extruded onto it and joined, makes a part its-/// flat pattern does not have (the mirrored half, the tab): the flat pattern, the DXF and the-/// bend table are refused with the feature's name instead of writing the sheet without it.+/// A mirror combined into a sheet, or a block extruded onto it and joined, makes a part its+/// flat pattern does not have (the mirrored half, the block): the flat pattern, the DXF and the+/// bend table are refused with the feature's name instead of writing the sheet without it. (A+/// tab joined in the sheet's own plane becomes part of it: `a_join_in_the_flat_is_kept_like_a_cut`.)#[test]fn a_mirror_or_a_join_into_a_sheet_refuses_its_flat_pattern_naming_the_feature() {let mut s = Session::default();@@ -5878,12 +5972,21 @@ fn a_mirror_or_a_join_into_a_sheet_refuses_its_flat_pattern_naming_the_feature()let mut s = Session::default();base(&mut s, 100.0, 60.0);- rectangle_tool(&mut s, "Tab", [40.0, 60.0], [60.0, 75.0]);- run(&mut s, "solid.extrude", json!({"sketch": "Tab", "distance": 2.5, "operation": "join"}));+ run(&mut s, "sketch.create", json!({"plane": "XY", "offset": 2.5, "name": "Block"}));+ run(&mut s, "sketch.rectangle.two_point", json!({"p0": [40, 20], "p1": [60, 35]}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch": "Block", "distance": 10, "operation": "join"}));for result in flat_exports(&mut s) {- let error = result.expect_err("a joined tab the flat pattern lacks");+ let error = result.expect_err("a joined block the flat pattern lacks");assert!(error.contains("can't include Extrude1"), "{error}");}+ // The tab beside the base's edge, joined in its plane, is in the flat pattern.+ let mut s = Session::default();+ base(&mut s, 100.0, 60.0);+ rectangle_tool(&mut s, "Tab", [40.0, 60.0], [60.0, 75.0]);+ run(&mut s, "solid.extrude", json!({"sketch": "Tab", "distance": 2.5, "operation": "join"}));+ assert!(flat_exports(&mut s).into_iter().all(|r| r.is_ok()));+ assert!((flat(&mut s)["flat_size_mm"][1].as_f64().unwrap_or(0.0) - 75.0).abs() < 1e-9);}/// A fillet on a sheet's corner is refused in the flat pattern until a sheet metal feature