Sheet metal: possible to create flange on a flange (#3274)

This commit is contained in:
Peppe Bergqvist
2026-10-20 04:02:20 +00:00
committed by GitHub
parent c400188778
commit 926a7353a3
4 changed files with 341 additions and 34 deletions
+269 -34
View File
@@ -943,27 +943,32 @@ impl SheetBody {
/// The part of a bend along its parent's edge: where a later flange trimmed that edge back
/// (a corner) or a corner relief cut into it, the bend stops and the flange panel runs on
/// alone.
/// alone. A setback on the flange panel's side also limits the bend to that panel's edge.
pub fn zone_span(&self, f: &SheetFlange) -> (f64, f64) {
if f.parent.is_some() {
return (0.0, f.len);
}
let pts = self.base.outer.ccw().polyline(1e-3);
let m = pts.len();
let mut span: Option<(f64, f64)> = None;
for k in 0..m {
let (Some(&a), Some(&b)) = (pts.get(k), pts.get((k + 1) % m)) else { continue };
let on = (a - f.p).dot(f.n).abs() < 1e-6 && (b - f.p).dot(f.n).abs() < 1e-6;
if !on {
continue;
}
let (ua, ub) = ((a - f.p).dot(f.d), (b - f.p).dot(f.d));
let (lo, hi) = (ua.min(ub).max(0.0), ua.max(ub).min(f.len));
if hi > lo + 1e-9 {
span = Some(span.map_or((lo, hi), |(x, y)| (x.min(lo), y.max(hi))));
let edge_span = |pts: &[Vec2], origin: Vec2| {
let m = pts.len();
let mut span: Option<(f64, f64)> = None;
for k in 0..m {
let (Some(&a), Some(&b)) = (pts.get(k), pts.get((k + 1) % m)) else { continue };
let on = (a - origin).dot(f.n).abs() < 1e-6 && (b - origin).dot(f.n).abs() < 1e-6;
if !on {
continue;
}
let (ua, ub) = ((a - f.p).dot(f.d), (b - f.p).dot(f.d));
let (lo, hi) = (ua.min(ub).max(0.0), ua.max(ub).min(f.len));
if hi > lo + 1e-9 {
span = Some(span.map_or((lo, hi), |(x, y)| (x.min(lo), y.max(hi))));
}
}
span
};
let span = if f.parent.is_none() { edge_span(&self.base.outer.ccw().polyline(1e-3), f.p) } else { None }.unwrap_or((0.0, f.len));
if let Some(shape) = &f.shape
&& let Some((lo, hi)) = edge_span(shape, f.p + f.n * self.allowance(f))
{
return (span.0.max(lo), span.1.min(hi));
}
span.unwrap_or((0.0, f.len))
span
}
fn frame_mat(&self) -> Mat {
@@ -2175,15 +2180,37 @@ impl SheetBody {
self.base = Region2 { outer: exact.unwrap_or_else(|| Loop2::polygon(&cut).ccw()), holes: self.base.holes.clone() };
}
Some(i) => {
// A flange panel: its far edge shortens the leg; side edges are not trimmed.
let original = self.flanges.get(i).ok_or_else(|| DocError::Invalid("flange".into()))?;
let side = inward.dot(original.n * -1.0) <= 0.99;
if inward.dot(original.n) > 0.99 {
return Err(DocError::Invalid("pick a free panel edge, not its connection to the existing bend".into()));
}
if side && (cut_at.0 || cut_at.1) {
return Err(DocError::Invalid("not supported yet: a partial side-edge flange beside a cut-out".into()));
}
let clipped = if side || original.shape.is_some() || original.exact.is_some() {
let region = self.panel(original);
if !region.outer.segs.iter().all(|s| matches!(s, Seg2::Line { .. })) {
return Err(DocError::Invalid("not supported yet: a flange setback on a curved flange panel".into()));
}
let points = clip(&region.outer.ccw().polyline(1e-3), a + inward * by, inward);
if points.len() < 3 {
return Err(DocError::Invalid("the flange's setback removes the whole panel".into()));
}
Some(points)
} else {
None
};
let Some(f) = self.flanges.get_mut(i) else { return Err(DocError::Invalid("flange".into())) };
if inward.dot(f.n * -1.0) > 0.99 {
if !side {
f.leg -= by;
if f.leg < -1e-9 {
return Err(DocError::Invalid("the flange's setback is longer than the panel".into()));
}
} else {
return Err(DocError::Invalid("not supported yet: a flange on the side of another flange".into()));
}
if let Some(points) = clipped {
f.shape = Some(points);
f.exact = None;
}
}
}
@@ -2310,21 +2337,28 @@ impl SheetBody {
.copied()
.ok_or_else(|| DocError::Invalid("the flange's edge was trimmed away".into()))?
}
Some(i) => {
Some(i) if self.flanges.get(i).is_some_and(|f| d.dot(f.d) > 1.0 - 1e-9 && f.shape.is_none()) => {
let f = self.flanges.get(i).ok_or_else(|| DocError::Invalid("flange".into()))?;
let tip = f.p + f.n * (self.allowance(f) + f.leg);
if f.shape.is_some() {
let u0 = (line_o - f.p).dot(f.d).clamp(0.0, f.len);
(tip + f.d * u0, f.len)
} else {
// The panel's far edge, end to end: where a closed corner ran the panel on
// or cut it back (slanted or not), the flange on it follows.
let (lo, hi) = self.far_edge(f);
if !(hi - lo > 1e-9) {
return Err(DocError::Invalid("the flange's edge was trimmed away".into()));
}
(tip + f.d * lo, hi - lo)
let (lo, hi) = self.far_edge(f);
if !(hi - lo > 1e-9) {
return Err(DocError::Invalid("the flange's edge was trimmed away".into()));
}
(tip + f.d * lo, hi - lo)
}
Some(i) => {
let f = self.flanges.get(i).ok_or_else(|| DocError::Invalid("flange".into()))?;
let points = self.panel(f).outer.ccw().polyline(1e-3);
let count = points.len();
(0..count)
.filter_map(|index| {
let (p0, p1) = (*points.get(index)?, *points.get((index + 1) % count)?);
let edge = p1 - p0;
let on = (p0 - line_o).dot(outward).abs() < 1e-6 && (p1 - line_o).dot(outward).abs() < 1e-6;
(on && edge.dot(d) > 1e-9).then_some((p0, edge.len()))
})
.find(|(p0, len)| (p0.dot(d) + len).min(b.dot(d)) - p0.dot(d).max(a.dot(d)) > 1e-9)
.ok_or_else(|| DocError::Invalid("the flange's edge was trimmed away".into()))?
}
};
// Where a cut-out ends the edge, the flange ends with it.
@@ -2367,9 +2401,103 @@ impl SheetBody {
}
notes.extend(self.close_corners(&made, relief));
notes.extend(self.close_return_corners(&made));
notes.extend(self.close_side_corners(&made, relief));
Ok((made, notes))
}
fn close_side_corners(&mut self, made: &[usize], relief: ReliefOverride) -> Vec<String> {
let mut pairs = Vec::new();
for &child in made {
let Some(flange) = self.flanges.get(child) else { continue };
let Some(parent) = flange.parent.and_then(|index| self.flanges.get(index)) else { continue };
if flange.d.dot(parent.d).abs() > 1e-6 {
continue;
}
let allowance = self.allowance(parent);
for (child_end, cb) in [(false, flange.p), (true, flange.p + flange.d * flange.len)] {
if ((cb - parent.p).dot(parent.n) - allowance).abs() > 1e-6 {
continue;
}
let ca = cb - parent.n * allowance;
for &other in made {
let Some(neighbour) = self.flanges.get(other) else { continue };
if other == child || neighbour.parent != parent.parent || neighbour.d.dot(parent.d).abs() > 1e-6 {
continue;
}
for (other_end, end) in [(false, neighbour.p), (true, neighbour.p + neighbour.d * neighbour.len)] {
if end.dist(ca) < 1e-6 {
pairs.push(ReturnCorner { a: other, a_end: other_end, b: child, b_end: child_end, ca, cb });
}
}
}
}
}
let mut notes = Vec::new();
for corner in pairs {
match self.close_returns(&corner) {
Ok(true) => {
if let Err(why) = self.relieve_side_corner(&corner, relief) {
notes.push(format!("no corner relief at {}: {why}", self.shown(corner.ca)));
}
}
Ok(false) => {}
Err(why) => notes.push(format!("the flanges at {} are left open: {why}", self.shown(corner.ca))),
}
}
notes
}
fn relieve_side_corner(&mut self, corner: &ReturnCorner, relief: ReliefOverride) -> std::result::Result<(), String> {
let shape = relief.shape.unwrap_or(self.relief);
if shape == ReliefShape::Notch {
return Ok(());
}
if shape == ReliefShape::Tear {
return Err("a tear across an existing bend is not supported yet; the corner keeps its notch".into());
}
let size = relief.size.unwrap_or(self.relief_size);
if !(size >= MIN_CORNER_RELIEF && size.is_finite()) {
return Err(format!("the relief size {size:.4} mm is below {MIN_CORNER_RELIEF} mm or is not finite"));
}
let (Some(first), Some(second)) = (self.flanges.get(corner.a), self.flanges.get(corner.b)) else {
return Err("a flange is missing".into());
};
let Some(parent) = second.parent.and_then(|index| self.flanges.get(index)) else {
return Err("the supporting bend is missing".into());
};
let radius = size / 2.0;
if radius >= first.len.min(second.len).min(parent.leg) - 1e-6 {
return Err(format!("a relief {size:.3} mm across would take a whole bend or panel away"));
}
let (start, end, along, across) = (corner.ca, corner.cb, parent.n, parent.d);
let outer = match shape {
ReliefShape::Round => Loop2 {
segs: vec![
Seg2::Line { a: start - across * radius, b: end - across * radius },
Seg2::Arc { center: end, radius, start: (across * -1.0).angle(), sweep: std::f64::consts::PI },
Seg2::Line { a: end + across * radius, b: start + across * radius },
Seg2::Arc { center: start, radius, start: across.angle(), sweep: std::f64::consts::PI },
],
}
.ccw(),
ReliefShape::Rectangular => Loop2::polygon(&[
start - across * radius - along * radius,
end - across * radius + along * radius,
end + across * radius + along * radius,
start + across * radius - along * radius,
])
.ccw(),
ReliefShape::Notch | ReliefShape::Tear => return Ok(()),
};
let mut relieved = self.clone();
relieved.holes.push(Region2 { outer, holes: Vec::new() });
if relieved.flat_regions().map_err(|error| error.to_string())?.len() != 1 {
return Err("the relief would split the flat pattern".into());
}
self.holes = relieved.holes;
Ok(())
}
/// Where the bend of flange `i` on the base ends beside more of the base (the flange's edge
/// ends at an inside corner and the base runs on past it), cut the rule's bend relief into
/// the base there: a slot `relief_width` wide beside the bend's end, from `relief_depth`
@@ -5662,6 +5790,113 @@ mod tests {
holds_the_flat_material(&s, "the triangle");
}
#[test]
fn edge_flange_on_a_folded_panels_side_keeps_its_flat_material() {
let base = rect(Vec2::new(0.0, 0.0), Vec2::new(120.0, 0.0), Vec2::new(120.0, 90.0), Vec2::new(0.0, 90.0));
let mut s = base_flange("Body1", "AL2", &alu(), Plane::XY, base);
let angle = std::f64::consts::FRAC_PI_2;
let wall = s.add_flange(Vec3::new(60.0, 0.0, 2.0), 30.0, angle, 1.0, "inside", false).unwrap();
let parent = s.flanges.get(wall).unwrap().clone();
let flat = parent.p + parent.d * parent.len + parent.n * (s.allowance(&parent) + parent.leg * 0.5);
let pick = apply_point(&s.world(Some(wall)), Vec3::new(flat.x, flat.y, s.t));
let child = s.add_flange(pick, 20.0, angle, 1.0, "inside", false).unwrap();
let flange = s.flanges.get(child).unwrap();
assert_eq!(flange.parent, Some(wall));
assert!(flange.d.dot(parent.n).abs() > 0.99);
assert!((flange.len - parent.leg).abs() < 1e-6);
holds_the_flat_material(&s, "a flange on a folded panel's side");
}
#[test]
fn edge_flanges_across_an_existing_bend_close_their_corner() {
for position in ["inside", "outside", "middle"] {
for reverse in [false, true] {
for flip in [false, true] {
for right in [false, true] {
for wall_angle in [60.0_f64, 90.0, 120.0] {
let base = rect(Vec2::new(0.0, 0.0), Vec2::new(120.0, 0.0), Vec2::new(120.0, 90.0), Vec2::new(0.0, 90.0));
let mut s = base_flange("Body1", "AL2", &alu(), Plane::XY, base);
let angle = std::f64::consts::FRAC_PI_2;
let wall = s.add_flange(Vec3::new(60.0, 0.0, 2.0), 60.0, wall_angle.to_radians(), 1.0, "inside", false).unwrap();
let parent = s.flanges.get(wall).unwrap();
let flat =
parent.p + parent.d * if right { parent.len } else { 0.0 } + parent.n * (s.allowance(parent) + parent.leg * 0.5);
let side = apply_point(&s.world(Some(wall)), Vec3::new(flat.x, flat.y, s.t));
let mut picks = [Vec3::new(if right { 120.0 } else { 0.0 }, 45.0, 2.0), side];
if reverse {
picks.reverse();
}
let what = format!("{position}, reverse={reverse}, flip={flip}, right={right}, wall={wall_angle}");
let (made, notes) = s.add_flanges_noted(&picks, 20.0, angle, 1.0, position, flip).unwrap();
if flip && !notes.is_empty() {
assert!(
notes.iter().all(|note| note.contains("overlap in the flat pattern") || note.contains("cut a panel away")),
"{what}: {notes:?}"
);
holds_the_flat_material(&s, &what);
continue;
}
assert!(notes.is_empty(), "{what}: {notes:?}");
assert!(
made.iter().any(|&index| {
let flange = s.flanges.get(index).unwrap();
flange.slope.0.abs() > 0.1 || flange.slope.1.abs() > 0.1
}),
"the corner was not mitred: {what}"
);
holds_the_flat_material(&s, &what);
}
}
}
}
}
}
#[test]
fn a_side_flange_setback_also_limits_the_existing_bend() {
for (position, right) in [("middle", false), ("middle", true), ("inside", false), ("inside", true)] {
let base = rect(Vec2::new(-110.0, -214.0), Vec2::new(110.0, -214.0), Vec2::new(110.0, 73.22), Vec2::new(-110.0, 73.22));
let rule = RuleValues { thickness: 5.0, bend_radius: 5.0, gap: 5.0, k_factor: 0.44, ..alu() };
let mut s = base_flange("Body1", "AL2", &rule, Plane::XY, base);
let angle = std::f64::consts::FRAC_PI_2;
let wall = s.add_flange(Vec3::new(0.0, -214.0, 5.0), 550.0, angle, 5.0, "middle", false).unwrap();
s.add_flanges(&[Vec3::new(110.0, -50.0, 0.0), Vec3::new(-110.0, -50.0, 0.0)], 50.0, angle, 5.0, "middle", false).unwrap();
let parent = s.flanges.get(wall).unwrap();
let point = parent.p + parent.d * if right { parent.len } else { 0.0 } + parent.n * (s.allowance(parent) + parent.leg * 0.5);
let side = apply_point(&s.world(Some(wall)), Vec3::new(point.x, point.y, 0.0));
let (_, notes) = s.add_flanges_noted(&[side], 40.0, angle, 5.0, position, false).unwrap();
assert!(notes.is_empty(), "{notes:?}");
let parent = s.flanges.get(wall).unwrap();
let panel = s.panel(parent).outer.ccw().polyline(1e-3);
let panel_start = panel.iter().map(|point| (*point - parent.p).dot(parent.d)).fold(f64::INFINITY, f64::min);
let panel_end = panel.iter().map(|point| (*point - parent.p).dot(parent.d)).fold(f64::NEG_INFINITY, f64::max);
let (bend_start, bend_end) = s.zone_span(parent);
assert!(bend_start >= panel_start - 1e-6, "{position}: bend starts at {bend_start}, before panel at {panel_start}");
assert!(bend_end <= panel_end + 1e-6, "{position}: bend ends at {bend_end}, beyond panel at {panel_end}");
assert!(s.solid().is_ok());
assert_eq!(s.flat_regions().unwrap().len(), 1);
}
}
#[test]
fn corners_across_a_bend_cut_the_selected_relief_in_the_flat_material() {
for shape in [ReliefShape::Round, ReliefShape::Rectangular] {
let base = rect(Vec2::new(0.0, 0.0), Vec2::new(120.0, 0.0), Vec2::new(120.0, 90.0), Vec2::new(0.0, 90.0));
let mut s = base_flange("Body1", "AL2", &alu(), Plane::XY, base);
let angle = std::f64::consts::FRAC_PI_2;
let wall = s.add_flange(Vec3::new(60.0, 0.0, 2.0), 30.0, angle, 1.0, "inside", false).unwrap();
let parent = s.flanges.get(wall).unwrap();
let point = parent.p + parent.d * parent.len + parent.n * (s.allowance(parent) + parent.leg * 0.5);
let side = apply_point(&s.world(Some(wall)), Vec3::new(point.x, point.y, s.t));
let edges = [Vec3::new(120.0, 45.0, 2.0), side].map(|pick| EdgeFlange { pick, height: 20.0, angle });
let (_, notes) = s.add_flanges_each(&edges, 1.0, "inside", false, ReliefOverride { shape: Some(shape), size: Some(4.0) }).unwrap();
assert!(notes.is_empty(), "{shape:?}: {notes:?}");
assert_eq!(s.holes.len(), 1);
assert!(!s.flat_regions().unwrap().iter().any(|region| region.contains(Vec2::new(116.0, 1.5))));
holds_the_flat_material(&s, &format!("{shape:?} relief across a bend"));
}
}
#[test]
fn a_corner_with_a_flange_of_an_earlier_feature_gets_no_relief() {
// Like the closing, the relief belongs to the corners between the flanges of one feature.
+52
View File
@@ -37,6 +37,58 @@ fn rectangle_tool(s: &mut Session, name: &str, p0: [f64; 2], p1: [f64; 2]) {
run(s, "sketch.finish", json!({}));
}
#[test]
fn side_edge_flanges_across_a_bend_keep_their_relief_through_rebuild_and_reopen() {
use solidcraft_geom::Vec3;
for shape in ["round", "rectangular"] {
for reverse in [false, true] {
let mut s = Session::default();
run(
&mut s,
"sheet.manage_rules",
json!({"name":"AL2","thickness":"2 mm","k_factor":0.5,"bend_radius":"1 mm","gap":"0.5 mm","active":true}),
);
base(&mut s, 120.0, 90.0);
run(&mut s, "sheet.flange", json!({"edges":[[60,0,2]],"height":"30 mm","angle":"90 deg"}));
let sheet = &s.model.state().sheets[0];
let parent = &sheet.flanges[0];
let point = parent.p + parent.d * parent.len + parent.n * (sheet.allowance(parent) + parent.leg * 0.5);
let side = solidcraft_doc::apply_point(&sheet.world(Some(0)), Vec3::new(point.x, point.y, sheet.t));
let mut edges = vec![json!([120, 45, 2]), json!([side.x, side.y, side.z])];
if reverse {
edges.reverse();
}
let before = s.doc.to_json();
run(
&mut s,
"sheet.flange",
json!({"edges":edges,"height":"20 mm","angle":"90 deg","position":"inside","corner_relief_shape":shape,"corner_relief":"4 mm"}),
);
assert!(no_errors_or_warnings(&s), "{shape}, reverse={reverse}: {:?}", s.model.results);
let formed = volume(&mut s);
let pattern = flat(&mut s);
assert_eq!(s.model.state().sheets[0].holes.len(), 1);
let body = &s.model.state().bodies[0].body;
assert!(body.validity().is_empty() && body.shell_count() == 1);
run(&mut s, "edit.undo", json!({}));
assert_eq!(s.doc.to_json(), before);
run(&mut s, "edit.redo", json!({}));
assert!((volume(&mut s) - formed).abs() < 1e-6);
for command in ["sheet.unfold", "sheet.refold"] {
run(&mut s, command, json!({}));
assert!((volume(&mut s) - formed).abs() < formed * 1e-3);
}
let mut reopened = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
assert!(no_errors_or_warnings(&reopened), "{:?}", reopened.model.results);
assert!((volume(&mut reopened) - formed).abs() < 1e-6);
assert_eq!(flat(&mut reopened), pattern);
let dxf = run(&mut reopened, "sheet.export_dxf", json!({}))["dxf"].as_str().unwrap().to_owned();
assert!(!solidcraft_io::read_dxf(&dxf).unwrap().is_empty());
}
}
}
#[test]
fn shallow_sheet_pocket_preserves_material_depth_export_undo_and_reopen() {
let mut s = Session::default();
+11
View File
@@ -136,6 +136,17 @@ are, so the returns on them close over a relieved or torn corner as over a whole
(The four returns of a 120 x 90 tray in 2 mm sheet with 90° walls 20 high: each point is the
middle of a wall's far edge on its inner face, so the returns turn in over the base.)
A flange can stand on a straight side edge of an existing flange as well. Select that edge
and the adjoining edge of its supporting panel in one feature to close the new flanges across
the existing bend. The panels are mitred with the rule's gap; `round` and `rectangular` corner
reliefs cut a rounded or rectangular slot across the existing bend zone in the flat material.
The slot's width is `corner_relief`, and it survives unfolding, refolding and DXF export.
`notch` keeps the gap without another cut. A `tear` across an existing bend is not supported
yet and leaves the notch with a warning. A mitre that would overlap the flat pattern stays
open with a warning. Side-edge setbacks on curved panels or on only part of an edge left by
a cut-out are not supported yet. The edge connecting a panel to its existing bend is not a
free edge. See `examples/regressions/sheet-side-flange-corner.json` for a small reproduction.
**Convert** also takes a solid or a shelled body: pick the face that stays fixed and the sharp
edges that become bends (`bends`; Bend Edges in the dialog). The flat faces reached from the
fixed face across those edges become the sheet. A shelled body keeps its walls and their
@@ -0,0 +1,9 @@
{"commands": [
{"command": "sheet.manage_rules", "params": {"name": "Sheet 2 mm", "thickness": "2 mm", "k_factor": 0.5, "bend_radius": "1 mm", "gap": "0.5 mm", "active": true}},
{"command": "sketch.create", "params": {"plane": "XY", "name": "Base"}},
{"command": "sketch.rectangle.two_point", "params": {"p0": [0, 0], "p1": [120, 90]}},
{"command": "sketch.finish", "params": {}},
{"command": "sheet.flange", "params": {"sketch": "Base"}},
{"command": "sheet.flange", "params": {"edges": [[60, 0, 2]], "height": "30 mm", "angle": "90 deg"}},
{"command": "sheet.flange", "params": {"edges": [[120, 45, 2], [120, 2, 16.5]], "height": "20 mm", "angle": "90 deg", "position": "inside", "corner_relief_shape": "round", "corner_relief": "4 mm"}}
]}