diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rs index d3e5c82ce..ee1492a3e 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 { + 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 881b047f5..0efb477b5 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 e3a7c1988..60374d983 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 000000000..49eec7084 --- /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