Skip to content

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

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

Peppe Bergqvist926a7353a377
diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rs
index d3e5c82ced..ee1492a3ef 100644
--- a/crates/doc/src/sheet.rs
+++ b/crates/doc/src/sheet.rs
@@ -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.
diff --git a/crates/engine/src/cmd/sheet_tests.rs b/crates/engine/src/cmd/sheet_tests.rs
index 881b047f53..0efb477b58 100644
--- a/crates/engine/src/cmd/sheet_tests.rs
+++ b/crates/engine/src/cmd/sheet_tests.rs
@@ -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();
diff --git a/docs/book/src/guide/sheet-metal.md b/docs/book/src/guide/sheet-metal.md
index e3a7c1988a..60374d9832 100644
--- a/docs/book/src/guide/sheet-metal.md
+++ b/docs/book/src/guide/sheet-metal.md
@@ -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
diff --git a/examples/regressions/sheet-side-flange-corner.json b/examples/regressions/sheet-side-flange-corner.json
new file mode 100644
index 0000000000..49eec7084a
--- /dev/null
+++ b/examples/regressions/sheet-side-flange-corner.json
@@ -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"}}
+]}
\ No newline at end of file