Sheet metal: material joined in the plane of a panel is kept (#6843) (#6855)

* claim: #6843

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PsiqyXWBFGTCX9J51bhysc

* Sheet metal: material joined in the plane of a panel is kept (#6843)

An extrude join through sheet metal went through the generic boolean:
the body grew, but the sheet model didn't, so the flat pattern, DXF and
bend table were refused, and the next sheet feature (a refold) dropped
the material ("what ... changed is not kept").

An untapered extrude join one sheet thick in the plane of a panel (the
base or a flange's panel, unfolded or folded) now joins the sheet model:
each region of its sketch becomes part of the one panel it is one piece
with, apart from every bend zone and the other panels, 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. A
join of another depth, out of every panel's plane, touching a bend zone
or another panel, or over a pocket, label, bore or perforation keeps the
generic path and its warning.

The extrude records its sketch plane and depth for a join too (its
profile grows into the material it joins, so it never counted as
untrimmed). The test that refused a joined tab beside a plain base now
refuses a block standing on the sheet instead; the tab is kept.

Fixes #6843.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
NOWN-DEVandClaude Opus 5.5 authored and GitHub committed 2026-11-02 18:31:33 +00:00
1 parent 4a680d17ba
commit 9432cdfee8
3 files changed
+278 -7

No files matched your search

+11 -1
View File
@@ -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() };
+158
View File
@@ -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, &regions, (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 {
+109 -6
View File
@@ -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