Sheet metal: two corner reliefs that would overlap are both left out (#3421)

The two reliefs that would overlap are still resolved one after the other: the
second one is left out, with a note. The corners come out in flange-index
order, so which of the two keeps its relief depends on the order the flanges
were made in.

Two corners that share an edge never come this far: each relief reaches
exactly r along that edge, and a relief is refused unless 2r fits in it. Two
corners that do not share one can: the square relief at a corner of 120°
reaches 2r from it along the bisector, so at the two 120° corners opposite
each other in a rhombus the two reach each other.

Two reliefs that would overlap are now left out together, each with a note
naming the other, so that which of them is cut does not depend on the order
the flanges were made in.

Fixes #3417.

Co-authored-by: jeremymiribung-blip <jeremymiribung-blip@users.noreply.github.com>
Co-authored-by: Claude Code <noreply@anthropic.com>
This commit is contained in:
authored and GitHub committed 2026-10-20 11:21:29 +00:00
1 parent d60b438f42
commit 3855c4c7e2
2 files changed
+65 -17

No files matched your search

+62 -14
View File
@@ -2955,22 +2955,22 @@ impl SheetBody {
Err(why) => notes.push(format!("no corner relief at {}: {why}", self.shown(k.c))),
}
}
// The reliefs at the two ends of one edge must not overlap: the one planned later
// is left out, with a note.
// Two reliefs must not overlap. Two corners that share an edge never come here:
// each relief reaches exactly `r` along that edge, and `plan_relief` refuses
// unless `2r` fits in it. Two corners that do not share one can: the square
// relief at a corner of 120° reaches `2r` from it, along the bisector. Two that
// would overlap are left out together, each with a note naming the other, so
// that which of them is cut does not depend on the order the corners come in.
let mut kept: Vec<PlannedRelief> = Vec::with_capacity(planned.len());
for p in planned {
let mut clash = None;
for q in &kept {
if convex_overlap(&q.cut, &p.cut) > 1e-9 {
clash = Some(q.corner.c);
break;
}
}
for (i, p) in planned.iter().enumerate() {
let clash = planned.iter().enumerate().find(|(j, q)| *j != i && convex_overlap(&q.cut, &p.cut) > 1e-9);
match clash {
Some(at) => {
notes.push(format!("no corner relief at {}: it would overlap the relief at {}", self.shown(p.corner.c), self.shown(at)))
}
None => kept.push(p),
Some((_, q)) => notes.push(format!(
"no corner relief at {}: it would overlap the relief at {}",
self.shown(p.corner.c),
self.shown(q.corner.c)
)),
None => kept.push(p.clone()),
}
}
for p in &kept {
@@ -5593,6 +5593,54 @@ mod tests {
c + bisector * (s0 / (alpha / 2.0).sin())
}
/// Two corner reliefs that would overlap are both left out. The two corners do not share an
/// edge: they are the 120° ones opposite each other in a rhombus, and the square relief at
/// each reaches 2r from it along the bisector, so the two reach each other.
#[test]
fn two_reliefs_that_would_overlap_are_both_left_out() {
// A rhombus of 120° and 60° corners, with a flange on each of its four edges. The two
// 120° corners are 12 mm apart in the trimmed base; a square relief 8 mm across reaches
// 4 mm along the edge it starts on and 8 mm along the bisector, so the two meet.
let l = 12.0 + 4.0 * 3.0f64.sqrt();
let u = Vec2::from_angle(std::f64::consts::FRAC_PI_3);
let pts = [Vec2::new(0.0, 0.0), Vec2::new(l / 2.0, l * u.y), Vec2::new(l, 0.0), Vec2::new(l / 2.0, -l * u.y)];
let base = || Region2 { outer: Loop2::polygon(&pts).ccw(), holes: vec![] };
let picks = [
Vec3::new(l / 4.0, l * u.y / 2.0, 2.0),
Vec3::new(l * 0.75, l * u.y / 2.0, 2.0),
Vec3::new(l * 0.75, -l * u.y / 2.0, 2.0),
Vec3::new(l / 4.0, -l * u.y / 2.0, 2.0),
];
let flange = |i: usize| EdgeFlange { pick: picks[i], height: 38.6, angle: 90f64.to_radians() };
// The round relief reaches r from its corner and the two are 12 mm apart: it fits at both.
for shape in [ReliefShape::Round, ReliefShape::Rectangular] {
let what = format!("{shape:?} at two corners opposite each other");
let rv = RuleValues { corner_relief_shape: shape, corner_relief: 8.0, ..alu() };
// The same four flanges, made in another order: the corners that keep their relief
// must not depend on it.
for order in [[0, 1, 2, 3], [3, 2, 1, 0]] {
let each: Vec<EdgeFlange> = order.iter().map(|&i| flange(i)).collect();
let (s, notes) = flanges_each(base(), &rv, &each);
if shape == ReliefShape::Round {
assert!(notes.is_empty(), "{what}: {order:?}: {notes:?}");
// A round at each of the four corners.
assert_eq!(s.base.outer.segs.len(), 8, "{what}: {order:?}: {:?}", s.base.outer.segs);
continue;
}
// The two reliefs that would overlap are both left out, each with a note naming
// the other.
assert_eq!(notes.len(), 2, "{what}: {order:?}: {notes:?}");
for n in &notes {
assert!(n.starts_with("no corner relief at (") && n.contains("it would overlap the relief at ("), "{what}: {notes:?}");
}
// The two kites at the 60° corners are cut, the ones at the 120° corners are
// not: the base keeps four of its edges and gains the two kites.
assert_eq!(s.base.outer.segs.len(), 8, "{what}: {order:?}: {:?}", s.base.outer.segs);
holds_the_flat_material(&s, &what);
}
}
}
/// The corner reliefs at the corners that are not square: a 60° and a 120° one, each of the
/// four shapes. The relief is cut `size / 2` from the corner along both edges, the bends stop
/// there, and the flat pattern keeps one clean loop.
+3 -3
View File
@@ -57,9 +57,9 @@ square the round follows the angle of the base and the square becomes a kite, it
square to the edges. Changing the shape in a rule changes the parts made with that rule. A
relief that doesn't fit (under 0.01 mm across, leaving nothing of a bend, or reaching as far
from its corner as another edge of the base is) is left out, and the flange feature reports a
warning saying where. The reliefs at the corners of one edge are cut together, so a corner's
relief does not depend on the order the corners are cut in; two of them that would overlap
leave the second one out, with a warning.
warning saying where. The reliefs at all the corners are cut together, so a corner's relief
does not depend on the order the corners are cut in; two of them that would overlap are both
left out, each with a warning saying which the other is.
```json
{"command":"sheet.manage_rules","params":{"name":"Sheet 2 mm","thickness":"2 mm","k_factor":0.5,