Skip to content

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

fix: edge flanges trim the base along their own edge and relieve bends that end beside it (#634)

NOWN-DEV90869732a3ec
diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rs
index 86b187f1a1..eddac9765e 100644
--- a/crates/doc/src/sheet.rs
+++ b/crates/doc/src/sheet.rs
@@ -382,6 +382,9 @@ pub struct SheetBody {
/// (the rule's `corner_relief_shape` and `corner_relief`).
pub relief: ReliefShape,
pub relief_size: f64,
+ /// The rule's bend relief (`relief_width`, `relief_depth`), cut into the base where a
+ /// flange's bend ends beside more of the base.
+ pub bend_relief: (f64, f64),
/// The base sketch's lines (id, ends in flat coordinates), naming the base panel's edges.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub base_curves: Vec<(String, Vec2, Vec2)>,
@@ -536,6 +539,9 @@ const MIN_CORNER_GAP: f64 = 0.01;
/// The smallest corner relief (across) that is cut: a smaller one would leave hairline edges.
const MIN_CORNER_RELIEF: f64 = 0.01;
+/// The narrowest bend relief that is cut: a narrower one would leave hairline edges.
+const MIN_BEND_RELIEF: f64 = 0.01;
+
/// Two bends on the base meeting at a corner (see [`SheetBody::corners`]): flanges `a` and `b`,
/// which end of each (false = the end at `p`), and the corner point (flat coordinates).
#[derive(Clone, Copy, Debug)]
@@ -1455,21 +1461,29 @@ impl SheetBody {
let o = a + inward * by;
let mut cut = clip(&pts, o, inward);
// Only the material along this edge goes: other parts of the outline past the
- // line (tabs side by side on one line) stay.
+ // line (tabs side by side on one line) stay, and so does the base where it runs
+ // on past the edge's own line (beyond an inside corner at the edge's end).
let mut work = FlatWork::new();
let off = merge_loops(&[clip(&pts, o, inward * -1.0)], &mut work)?;
- if off.len() > 1 {
- let mid = (a + b) * 0.5;
- let touches = |p: &Vec<Vec2>| {
- let m = p.len();
- (0..m).filter_map(|i| Some((*p.get(i)?, *p.get((i + 1) % m)?))).any(|(p0, p1)| {
- let e = p1 - p0;
- let t = if e.len2() > 1e-18 { ((mid - p0).dot(e) / e.len2()).clamp(0.0, 1.0) } else { 0.0 };
- (p0 + e * t).dist(mid) < 1e-6
- })
- };
- let mut keep = vec![cut];
- keep.extend(off.into_iter().filter(|p| !touches(p)));
+ let mid = (a + b) * 0.5;
+ let touches = |p: &Vec<Vec2>| {
+ let m = p.len();
+ (0..m).filter_map(|i| Some((*p.get(i)?, *p.get((i + 1) % m)?))).any(|(p0, p1)| {
+ let e = p1 - p0;
+ let t = if e.len2() > 1e-18 { ((mid - p0).dot(e) / e.len2()).clamp(0.0, 1.0) } else { 0.0 };
+ (p0 + e * t).dist(mid) < 1e-6
+ })
+ };
+ let mut keep = Vec::new();
+ for p in off {
+ if touches(&p) {
+ keep.extend(kept_past_edge(&p, a, b, &mut work)?);
+ } else {
+ keep.push(p);
+ }
+ }
+ if !keep.is_empty() {
+ keep.insert(0, cut);
cut = match merge_loops(&keep, &mut work)?.as_slice() {
[one] => one.clone(),
_ => return Err(DocError::Invalid("not supported yet: a flange setback that splits the sheet".into())),
@@ -1530,7 +1544,9 @@ impl SheetBody {
/// leg), so unequal flanges close like equal ones. A flange on another flange's far edge (a
/// return) runs along that edge end to end, following its parent's closed end; two of them
/// whose parents meet at a corner are closed toward each other as well, and one alone at a
- /// corner is kept clear of the flange beside its parent (`close_return_corners`).
+ /// corner is kept clear of the flange beside its parent (`close_return_corners`). A bend on
+ /// the base that ends beside more of the base gets the rule's bend relief there
+ /// (`relieve_bend_ends`).
pub fn add_flanges_each(&mut self, edges: &[EdgeFlange], radius: f64, position: &str, flip: bool) -> Result<(Vec<usize>, Vec<String>)> {
if edges.is_empty() || edges.len() > 1000 {
return Err(DocError::Invalid("pick 1…1000 edges".into()));
@@ -1629,11 +1645,61 @@ impl SheetBody {
});
made.push(self.flanges.len() - 1);
}
- let mut notes = self.close_corners(&made);
+ let mut notes = Vec::new();
+ for &i in &made {
+ notes.extend(self.relieve_bend_ends(i));
+ }
+ notes.extend(self.close_corners(&made));
notes.extend(self.close_return_corners(&made));
Ok((made, notes))
}
+ /// 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`
+ /// before the bend line to `relief_width` past the flange's far edge in the flat pattern,
+ /// so that the bend and the flange come free of the base, folded and flat. Returns a note
+ /// for every such end left as it is.
+ fn relieve_bend_ends(&mut self, i: usize) -> Vec<String> {
+ let Some(f) = self.flanges.get(i).cloned() else { return Vec::new() };
+ if f.parent.is_some() || f.shape.is_some() {
+ return Vec::new();
+ }
+ let (width, depth) = (self.bend_relief.0, self.bend_relief.1.max(0.0));
+ let reach = self.allowance(&f) + f.leg;
+ let (u0, u1) = self.zone_span(&f);
+ let mut notes = Vec::new();
+ for (u, s) in [(u0, -1.0), (u1, 1.0)] {
+ // `du` past this end of the bend, `dv` past the bend line (into the flange).
+ let at = |du: f64, dv: f64| f.p + f.d * (u + s * du) + f.n * dv;
+ if !self.base.contains(at(1e-4, 1e-4)) {
+ continue;
+ }
+ let cut = if !(width >= MIN_BEND_RELIEF) {
+ Err(format!("the relief width {width:.4} mm is below {MIN_BEND_RELIEF} mm"))
+ } else if !self.base.contains(at(width + 1e-4, 1e-4)) {
+ Err(format!("a relief {width:.3} mm wide would take away all of the base beside the bend"))
+ } else {
+ let relief = rect(at(0.0, -depth), at(width, -depth), at(width, reach + width), at(0.0, reach + width));
+ planar_region(&self.base)
+ .and_then(|base| material_boolean(&[base], &[relief], kernel::BoolOp::Cut, &mut FlatWork::new()))
+ .map_err(|e| e.to_string())
+ .and_then(|mut left| match (left.pop(), left.is_empty()) {
+ (Some(base), true) if base.holes.is_empty() => Ok(base),
+ _ => Err("it would not leave the base in one piece".to_string()),
+ })
+ };
+ match cut {
+ Ok(base) => self.base = base,
+ Err(why) => {
+ let w = apply_point(&self.frame_mat(), v3(at(0.0, 0.0)));
+ notes.push(format!("no bend relief at ({:.3}, {:.3}, {:.3}): {why}", w.x, w.y, w.z));
+ }
+ }
+ }
+ notes
+ }
+
/// Flanges on the base that meet at a convex corner of it, at least one of them among `among`:
/// (a, a_end, b, b_end, the corner). Their bend lines cross at the corner and both bends end
/// there, or both the same distance short of it: where a corner relief was cut, or where the
@@ -2946,6 +3012,42 @@ fn clear_of(a: Vec2, d: Vec2, len: f64, cuts: &[Region2]) -> Vec<(f64, f64)> {
out
}
+/// What stays of `piece` (counter-clockwise), the part of a base that trimming its edge a→b back
+/// along the edge's whole line would take: where the base runs on past the edge's own line
+/// (beyond an inside corner at an end of the edge), that material and the strip beneath it, up
+/// to the corner. Nothing where the base ends at the line.
+fn kept_past_edge(piece: &[Vec2], a: Vec2, b: Vec2, work: &mut FlatWork) -> Result<Vec<Vec<Vec2>>> {
+ let Some(d) = (b - a).normalized() else { return Ok(Vec::new()) };
+ let outward = Vec2::new(d.y, -d.x);
+ let mut kept = merge_loops(&[clip(piece, a, outward)], work)?;
+ // Where that material stands on the edge's line, nearest the edge's middle on either side.
+ let um = a.dist(b) / 2.0;
+ let (mut lo, mut hi) = (f64::NEG_INFINITY, f64::INFINITY);
+ for q in &kept {
+ let m = q.len();
+ for i in 0..m {
+ let (Some(&p0), Some(&p1)) = (q.get(i), q.get((i + 1) % m)) else { continue };
+ if (p0 - a).dot(outward).abs() > 1e-6 || (p1 - a).dot(outward).abs() > 1e-6 {
+ continue;
+ }
+ let (u0, u1) = ((p0 - a).dot(d), (p1 - a).dot(d));
+ if u0.max(u1) <= um {
+ lo = lo.max(u0.max(u1));
+ } else if u0.min(u1) >= um {
+ hi = hi.min(u0.min(u1));
+ }
+ }
+ }
+ let strip = clip(piece, a, outward * -1.0);
+ if lo.is_finite() {
+ kept.push(clip(&strip, a + d * lo, d * -1.0));
+ }
+ if hi.is_finite() {
+ kept.push(clip(&strip, a + d * hi, d));
+ }
+ Ok(kept)
+}
+
/// Do two polygons' edges cross?
fn polys_cross(a: &[Vec2], b: &[Vec2]) -> bool {
let seg = |p: &[Vec2], i: usize| -> Option<(Vec2, Vec2)> { Some((*p.get(i)?, *p.get((i + 1) % p.len())?)) };
@@ -2983,6 +3085,7 @@ pub fn base_flange(body: &str, rule: &str, rv: &RuleValues, plane: Plane, region
gap: rv.gap,
relief: rv.corner_relief_shape,
relief_size: rv.corner_relief,
+ bend_relief: (rv.relief_width, rv.relief_depth),
base_curves: Vec::new(),
}
}
@@ -3037,6 +3140,7 @@ pub fn contour_flange(body: &str, rule: &str, rv: &RuleValues, plane: &Plane, pt
gap: rv.gap,
relief: rv.corner_relief_shape,
relief_size: rv.corner_relief,
+ bend_relief: (rv.relief_width, rv.relief_depth),
base_curves: Vec::new(),
};
let (y0, y1) = if ysign > 0.0 { (0.0, width) } else { (-width, 0.0) };
@@ -4109,6 +4213,154 @@ mod tests {
}
}
+ /// A 160 x 30 bar with a leg 20 wide standing `leg` past its top edge at the left end: the
+ /// top edge (x 20…160) ends at an inside corner of the base.
+ fn bar_with_leg(rv: &RuleValues, leg: f64) -> SheetBody {
+ let pts = [(0.0, 0.0), (160.0, 0.0), (160.0, 30.0), (20.0, 30.0), (20.0, 30.0 + leg), (0.0, 30.0 + leg)].map(|(x, y)| Vec2::new(x, y));
+ base_flange("Body1", "AL2", rv, Plane::XY, Region2 { outer: Loop2::polygon(&pts).ccw(), holes: vec![] })
+ }
+
+ /// The base's outline has these corners, and their polygon's area.
+ fn base_is(s: &SheetBody, want: &[(f64, f64)], what: &str) {
+ let want: Vec<Vec2> = want.iter().map(|&(x, y)| Vec2::new(x, y)).collect();
+ let got = corners_of(&s.base);
+ for p in &want {
+ assert!(got.iter().any(|q| q.dist(*p) < 1e-9), "{what}: {p:?} not in {got:?}");
+ }
+ let area = signed_area(&want).abs();
+ assert!((s.base.area() - area).abs() < 1e-9, "{what}: {} vs {area}", s.base.area());
+ }
+
+ #[test]
+ fn a_flange_beside_a_leg_of_the_base_trims_its_own_edge_and_gets_a_bend_relief() {
+ // A 90° flange 15 high on the bar's top edge: setback s0 = (R + T)·tan 45° = 3 inside,
+ // half of it in the middle, none outside; bend allowance BA = (π/2)·(R + K·T) = π; panel
+ // 15 − s0 = 12. Only the strip under that edge goes, so the bend runs from x = 160 to the
+ // leg at x = 20 and the leg stays. Beside the bend's end the rule's relief (2 wide, 1 deep)
+ // is cut into the leg: x 18…20, from 1 before the bend line to 2 past the flange's far
+ // edge in the flat (BA + 12 past the line), or to the leg's end where that comes first.
+ let rv = alu();
+ let (ba, panel) = (std::f64::consts::PI, 12.0);
+ for leg in [30.0, 10.0] {
+ for (position, line) in [("inside", 27.0), ("middle", 28.5), ("outside", 30.0)] {
+ let what = format!("{position}, leg {leg}");
+ let mut s = bar_with_leg(&rv, leg);
+ let (made, notes) =
+ s.add_flanges_noted(&[Vec3::new(90.0, 30.0, 2.0)], 15.0, std::f64::consts::FRAC_PI_2, 1.0, position, false).unwrap();
+ assert!(notes.is_empty(), "{what}: {notes:?}");
+ let (top, end) = (30.0 + leg, line + ba + panel + 2.0);
+ let mut want = vec![(0.0, 0.0), (160.0, 0.0), (160.0, line), (20.0, line), (20.0, line - 1.0), (18.0, line - 1.0)];
+ if end < top {
+ want.extend([(18.0, end), (20.0, end), (20.0, top), (0.0, top)]);
+ } else {
+ want.extend([(18.0, top), (0.0, top)]);
+ }
+ base_is(&s, &want, &what);
+ let f = &s.flanges[made[0]];
+ assert!(f.p.dist(Vec2::new(160.0, line)) < 1e-9 && (f.len - 140.0).abs() < 1e-9, "{what}: {f:?}");
+ assert!((s.bends()[0].length - 140.0).abs() < 1e-9, "{what}: {:?}", s.bends());
+ // The flat pattern is the base and 140 × (BA + 12) of flange in one piece; folded,
+ // the part is one valid shell holding the same material.
+ let base = 160.0 * line + 20.0 * (top - line) - 2.0 * (end.min(top) - (line - 1.0));
+ assert!((flat_area(&s) - (base + 140.0 * (ba + panel))).abs() < 1e-6, "{what}: {}", flat_area(&s));
+ holds_the_flat_material(&s, &what);
+ }
+ }
+ }
+
+ #[test]
+ fn flanges_on_both_sides_of_a_leg_each_trim_their_own_edge() {
+ // A 160 x 30 bar with a 20 x 10 leg in the middle of its top edge, and flanges on the two
+ // parts of that edge (x 0…70 and 90…160) in one call: each takes the strip under its own
+ // part, and the leg gets a relief on either side (x 70…72 and 88…90) up to its end.
+ let pts = [(0.0, 0.0), (160.0, 0.0), (160.0, 30.0), (90.0, 30.0), (90.0, 40.0), (70.0, 40.0), (70.0, 30.0), (0.0, 30.0)];
+ let outer = Loop2::polygon(&pts.map(|(x, y)| Vec2::new(x, y))).ccw();
+ let mut s = base_flange("Body1", "AL2", &alu(), Plane::XY, Region2 { outer, holes: vec![] });
+ let picks = [Vec3::new(125.0, 30.0, 2.0), Vec3::new(35.0, 30.0, 2.0)];
+ let (made, notes) = s.add_flanges_noted(&picks, 15.0, std::f64::consts::FRAC_PI_2, 1.0, "inside", false).unwrap();
+ assert!(notes.is_empty() && s.corners(&made).is_empty(), "{notes:?}");
+ let right = [(0.0, 0.0), (160.0, 0.0), (160.0, 27.0), (90.0, 27.0), (90.0, 26.0), (88.0, 26.0), (88.0, 40.0)];
+ let left = [(72.0, 40.0), (72.0, 26.0), (70.0, 26.0), (70.0, 27.0), (0.0, 27.0)];
+ base_is(&s, &[&right[..], &left[..]].concat(), "tee");
+ assert!(s.flanges.iter().all(|f| (f.len - 70.0).abs() < 1e-9), "{:?}", s.flanges);
+ holds_the_flat_material(&s, "tee");
+ }
+
+ #[test]
+ fn a_flange_on_the_side_of_a_leg_leaves_the_base_the_leg_stands_on() {
+ // The leg's right side (x = 20, y 30…60): past that edge's line the whole bar runs on. The
+ // setback takes x 17…20 of the leg alone, and the relief goes into the bar beside the
+ // bend's end at y = 30: y 28…30, from x = 16 (1 before the bend line) to 2 past the
+ // flange's far edge in the flat at x = 17 + BA + 12.
+ let mut s = bar_with_leg(&alu(), 30.0);
+ let (made, notes) = s.add_flanges_noted(&[Vec3::new(20.0, 45.0, 2.0)], 15.0, std::f64::consts::FRAC_PI_2, 1.0, "inside", false).unwrap();
+ assert!(notes.is_empty(), "{notes:?}");
+ let end = 17.0 + std::f64::consts::PI + 12.0 + 2.0;
+ let want =
+ [(0.0, 0.0), (160.0, 0.0), (160.0, 30.0), (end, 30.0), (end, 28.0), (16.0, 28.0), (16.0, 30.0), (17.0, 30.0), (17.0, 60.0), (0.0, 60.0)];
+ base_is(&s, &want, "side");
+ let f = &s.flanges[made[0]];
+ assert!(f.p.dist(Vec2::new(17.0, 30.0)) < 1e-9 && (f.len - 30.0).abs() < 1e-9, "{f:?}");
+ holds_the_flat_material(&s, "side");
+ }
+
+ #[test]
+ fn a_bend_relief_at_one_end_leaves_the_corner_at_the_other_as_it_was() {
+ // Flanges on the bar's top and right edges in one call: their bends meet at (157, 27),
+ // where the corner is closed and relieved by the rule's shape, and the top one ends
+ // beside the leg at (20, 27), where it gets the bend relief. Against the bar without
+ // the leg, the same corner and all, the flat pattern gains the leg from the bend line
+ // up, 20 × (60 − 27), less the relief, 2 × (1 + BA + 12 + 2), and loses 20 of the top
+ // flange's length, 20 × (BA + 12).
+ let (ba, panel) = (std::f64::consts::PI, 12.0);
+ let picks = [Vec3::new(90.0, 30.0, 2.0), Vec3::new(160.0, 15.0, 2.0)];
+ for shape in [ReliefShape::Notch, ReliefShape::Round, ReliefShape::Rectangular] {
+ let what = format!("{shape:?}");
+ let rv = RuleValues { corner_relief_shape: shape, ..alu() };
+ let bar = rect(Vec2::new(0.0, 0.0), Vec2::new(160.0, 0.0), Vec2::new(160.0, 30.0), Vec2::new(0.0, 30.0));
+ let mut plain = base_flange("Body1", "AL2", &rv, Plane::XY, bar);
+ let (_, notes) = plain.add_flanges_noted(&picks, 15.0, std::f64::consts::FRAC_PI_2, 1.0, "inside", false).unwrap();
+ assert!(notes.is_empty(), "{what}, no leg: {notes:?}");
+ let mut s = bar_with_leg(&rv, 30.0);
+ let (made, notes) = s.add_flanges_noted(&picks, 15.0, std::f64::consts::FRAC_PI_2, 1.0, "inside", false).unwrap();
+ assert!(notes.is_empty() && made.len() == 2, "{what}: {notes:?}");
+ // The corner's relief reaches 4 along both bends (8 across); the notch none.
+ let cut = if shape == ReliefShape::Notch { 0.0 } else { 4.0 };
+ let lengths: Vec<f64> = s.bends().iter().map(|b| b.length).collect();
+ assert!((lengths[0] - (137.0 - cut)).abs() < 1e-9 && (lengths[1] - (27.0 - cut)).abs() < 1e-9, "{what}: {lengths:?}");
+ let got = corners_of(&s.base);
+ let end = 27.0 + ba + panel + 2.0;
+ for p in [(20.0, 27.0), (20.0, 26.0), (18.0, 26.0), (18.0, end), (20.0, end), (20.0, 60.0), (0.0, 60.0)] {
+ assert!(got.iter().any(|q| q.dist(Vec2::new(p.0, p.1)) < 1e-9), "{what}: {p:?} not in {got:?}");
+ }
+ let want = flat_area(&plain) + 20.0 * 33.0 - 2.0 * (ba + panel + 3.0) - 20.0 * (ba + panel);
+ assert!((flat_area(&s) - want).abs() < 1e-6, "{what}: {} vs {want}", flat_area(&s));
+ holds_the_flat_material(&s, &what);
+ }
+ }
+
+ #[test]
+ fn a_bend_relief_that_cannot_be_cut_is_left_out_with_a_note() {
+ let leg = [(20.0, 60.0), (0.0, 60.0)];
+ // The same leg held by a neck 2 wide: a notch from the left (x 0…18, y 43…45) under its end.
+ let neck = [(20.0, 60.0), (0.0, 60.0), (0.0, 45.0), (18.0, 45.0), (18.0, 43.0), (0.0, 43.0)];
+ // No width to cut; a relief wider than the leg, which would take the leg away; and a
+ // relief through the neck, which would cut the leg's end off.
+ for (width, top, why) in [(0.0, &leg[..], "relief width"), (25.0, &leg[..], "beside the bend"), (2.0, &neck[..], "one piece")] {
+ let rv = RuleValues { relief_width: width, ..alu() };
+ let outline = |line: f64| [&[(0.0, 0.0), (160.0, 0.0), (160.0, line), (20.0, line)][..], top].concat();
+ let pts: Vec<Vec2> = outline(30.0).iter().map(|&(x, y)| Vec2::new(x, y)).collect();
+ let mut s = base_flange("Body1", "AL2", &rv, Plane::XY, Region2 { outer: Loop2::polygon(&pts).ccw(), holes: vec![] });
+ let (_, notes) = s.add_flanges_noted(&[Vec3::new(90.0, 30.0, 2.0)], 15.0, std::f64::consts::FRAC_PI_2, 1.0, "inside", false).unwrap();
+ assert!(
+ notes.len() == 1 && notes[0].starts_with("no bend relief at (20.000, 27.000, 0.000)") && notes[0].contains(why),
+ "{why}: {notes:?}"
+ );
+ // The flange still took its own edge only.
+ base_is(&s, &outline(27.0), why);
+ }
+ }
+
/// Edge flanges on `base`, each with its own height and angle, added in one call. Returns the
/// sheet and the notes on corners left open.
fn flanges_each(base: Region2, rv: &RuleValues, each: &[EdgeFlange]) -> (SheetBody, Vec<String>) {
diff --git a/crates/engine/src/cmd/sheet_tests.rs b/crates/engine/src/cmd/sheet_tests.rs
index fc4e917713..629a937a80 100644
--- a/crates/engine/src/cmd/sheet_tests.rs
+++ b/crates/engine/src/cmd/sheet_tests.rs
@@ -1940,6 +1940,72 @@ fn edge_flanges_on_two_collinear_tab_ends_in_one_feature() {
assert!(rel(volume(&mut s), volume(&mut separate)) < 1e-6);
}
+/// A 160 x 30 bar with a 20 x 30 leg standing past its top edge at the left end (2 mm, R 1,
+/// K 0.5, so folding keeps the volume): a base flange, or a plate converted to sheet metal.
+fn bar_with_leg(s: &mut Session, converted: bool) {
+ run(s, "sheet.manage_rules", json!({"name": "AL2", "thickness": "2 mm", "k_factor": 0.5, "bend_radius": "1 mm", "active": true}));
+ run(s, "sketch.create", json!({"plane": "XY", "name": "Bar"}));
+ run(s, "sketch.line", json!({"points": [[0, 0], [160, 0], [160, 30], [20, 30], [20, 60], [0, 60]], "closed": true}));
+ run(s, "sketch.finish", json!({}));
+ if converted {
+ run(s, "solid.extrude", json!({"sketch": "Bar", "distance": 2, "body_name": "Plate"}));
+ run(s, "sheet.convert", json!({"body": "Plate", "face": [80, 15, 2]}));
+ } else {
+ run(s, "sheet.flange", json!({"sketch": "Bar"}));
+ }
+}
+
+/// An edge flange takes its setback off its own edge only: the leg standing past the edge's end
+/// stays, and the rule's bend relief frees the bend and the flange from it.
+#[test]
+fn an_edge_flange_beside_a_leg_of_the_base_trims_its_own_edge_and_relieves_its_bend() {
+ // Bend allowance (π/2)·(R + K·T) = π; the rule's relief is Thickness wide, half of it deep.
+ let (ba, width, depth) = (PI, 2.0, 1.0);
+ for (converted, position, setback) in [(false, "inside", 3.0), (false, "outside", 0.0), (true, "inside", 3.0)] {
+ let what = format!("converted {converted}, {position}");
+ let mut s = Session::default();
+ bar_with_leg(&mut s, converted);
+ // Where the sheet's bottom face lies.
+ let z0 = bbox(&mut s)["min"][2].as_f64().unwrap_or(f64::NAN);
+ // A 90° flange 15 high on the bar's top edge (x 20…160); the leg stands past its left end.
+ run(&mut s, "sheet.flange", json!({"edges": [[90, 30, z0 + 2.0]], "height": 15, "angle": 90, "position": position}));
+ assert!(no_errors_or_warnings(&s), "{what}: {:?}", s.model.results);
+ // By hand: the base loses the setback under that edge alone, and the relief beside the
+ // bend's end at x = 20, from `depth` before the bend line to `width` past the flange's
+ // far edge in the flat (BA and the 12 mm panel past the line).
+ let (line, panel) = (30.0 - setback, 12.0);
+ let relief = width * (depth + ba + panel + width);
+ let base = 160.0 * 30.0 + 20.0 * 30.0 - 140.0 * setback - relief;
+ let want = 2.0 * (base + 140.0 * (ba + panel));
+ assert!(rel(volume(&mut s), want) < 1e-5, "{what}: {} vs {want}", volume(&mut s));
+ assert!(contains(&s, [10.0, 50.0, z0 + 1.0]), "{what}: the leg is kept");
+ assert!(!contains(&s, [19.0, line + 0.5, z0 + 1.0]), "{what}: the relief is cut");
+ assert!(contains(&s, [17.0, line + 0.5, z0 + 1.0]), "{what}: the leg beside the relief stays");
+ assert!(contains(&s, [19.0, 50.0, z0 + 1.0]), "{what}: the leg past the relief's end stays");
+ // The flange's mid plane is R + T/2 = 2 past the bend line; it ends at the leg.
+ assert!(contains(&s, [90.0, line + 2.0, z0 + 10.0]), "{what}: the flange stands");
+ assert!(!contains(&s, [10.0, line + 2.0, z0 + 10.0]), "{what}: the flange ends at the leg");
+ let f = flat(&mut s);
+ assert_eq!(f["outline"].as_array().map(Vec::len), Some(1), "{what}: {f}");
+ assert_eq!(f["cutouts"].as_array().map(Vec::len), Some(0), "{what}: {f}");
+ assert!((f["bends"][0]["length"].as_f64().unwrap_or(f64::NAN) - 140.0).abs() < 1e-9, "{what}: {f}");
+ run(&mut s, "sheet.unfold", json!({}));
+ assert!(rel(volume(&mut s), want) < 1e-9, "{what}: flat {} vs {want}", volume(&mut s));
+ }
+}
+
+/// A bend relief the rule makes too narrow to cut is left out, and the flange says where.
+#[test]
+fn a_bend_relief_left_out_is_reported_on_the_flange() {
+ let mut s = Session::default();
+ bar_with_leg(&mut s, false);
+ run(&mut s, "sheet.manage_rules", json!({"name": "AL2", "relief_width": "0 mm"}));
+ run(&mut s, "sheet.flange", json!({"edges": [[90, 30, 2]], "height": 15, "angle": 90}));
+ let w = s.model.results.last().and_then(|r| r.warning.clone()).unwrap_or_default();
+ assert!(w.contains("no bend relief at (20.000, 27.000, 0.000)") && w.contains("relief width"), "{w}");
+ assert!(contains(&s, [10.0, 50.0, 1.0]), "the leg is kept");
+}
+
/// `fixed` inside a cut-out touches no material: the fold must refuse it or say which side it kept (#263).
#[test]
fn fold_fixed_point_off_the_sheet_is_not_silently_ignored() {
diff --git a/docs/book/src/guide/sheet-metal.md b/docs/book/src/guide/sheet-metal.md
index 54121504c9..a0da2967df 100644
--- a/docs/book/src/guide/sheet-metal.md
+++ b/docs/book/src/guide/sheet-metal.md
@@ -14,6 +14,16 @@ The SHEET METAL tab builds parts from a sheet of constant thickness under a **sh
Bends follow the rule's K-factor, so flat lengths match what a press brake will make. Tests
check flat lengths against hand-computed bend allowances.
+An edge flange takes its setback off its own edge only. Where that edge ends at an inside
+corner of the base (the base runs on past it, like the leg of an L), the rest of the base
+stays, and the rule's **bend relief** (`relief_width` and `relief_depth`; Relief Width and
+Relief Depth in Sheet Metal Rules) is cut into it beside the bend's end: a slot the relief
+width wide, from the relief depth before the bend line to the relief width past the flange's
+far edge in the flat pattern. The bend and the flange are then free of the base, folded and
+flat. A relief that can't be cut (a width under 0.01 mm, one as wide as the base beside the
+bend, or a slot that would cut the base apart) is left out, and the flange feature reports a
+warning saying where.
+
Where two bends of one edge flange feature meet at a corner of the base, the rule's **corner
relief shape** (`corner_relief_shape`; Corner Relief Shape in Sheet Metal Rules) says what is
cut there. `notch`, the default, cuts nothing more: the bends end square at the corner. `round`