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.rsindex 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(®ion.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.rsindex 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.mdindex 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 themiddle 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 sharpedges that become bends (`bends`; Bend Edges in the dialog). The flat faces reached from thefixed face across those edges become the sheet. A shelled body keeps its walls and theirdiff --git a/examples/regressions/sheet-side-flange-corner.json b/examples/regressions/sheet-side-flange-corner.jsonnew file mode 100644index 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