* claim: #8823 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Sheet metal: returns on a notched tray close at the corner away from the notch (#8823) Closing two returns at a corner was refused when either return already lay over another flange in the flat pattern, even far from that corner. On a tray with a notch, the walls on either side of the notch's inner corner both unfold into the notch, so the return on one of them lies over the other there; the return's opposite convex corner was then left open ("closed, the flanges would overlap in the flat pattern") and the two returns ran through each other. A closure is now refused only when it makes the two returns overlap or adds to what either already shares with another flange in the flat. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
+12
-2
@@ -3661,7 +3661,11 @@ impl SheetBody {
|
||||
return Err("the gap would cut a panel away".into());
|
||||
}
|
||||
}
|
||||
// The flat pattern must stay one sheet without overlaps.
|
||||
// The flat pattern must stay one sheet without overlaps: closing must not make the two
|
||||
// overlap, nor add to what either already overlaps of another flange. A flange can lie
|
||||
// over another one in the flat away from this corner (the walls on either side of a
|
||||
// notch's inner corner both unfold into the notch, and a return on one of them lies over
|
||||
// the other), and the corner is still closed then (#8823).
|
||||
let [new_a, new_b] = new;
|
||||
let pieces = |s: &SheetBody, f: &SheetFlange| {
|
||||
let mut v = vec![corners_of(&s.zone(f))];
|
||||
@@ -3671,13 +3675,19 @@ impl SheetBody {
|
||||
v
|
||||
};
|
||||
let mine = [pieces(self, &new_a), pieces(self, &new_b)];
|
||||
let was = [pieces(self, &fa), pieces(self, &fb)];
|
||||
let overlap = |p: &[Vec<Vec2>], q: &[Vec<Vec2>]| p.iter().any(|a| q.iter().any(|b| pieces_overlap(a, b)));
|
||||
let shared = |p: &[Vec<Vec2>], q: &[Vec<Vec2>]| p.iter().map(|a| q.iter().map(|b| convex_overlap(a, b)).sum::<f64>()).sum::<f64>();
|
||||
let perimeter =
|
||||
|p: &[Vec<Vec2>]| p.iter().flat_map(|c| (0..c.len()).filter_map(move |i| Some(c.get(i)?.dist(*c.get((i + 1) % c.len())?)))).sum::<f64>();
|
||||
let [mine_a, mine_b] = &mine;
|
||||
let clash = overlap(mine_a, mine_b)
|
||||
|| self.flanges.iter().enumerate().any(|(j, g)| {
|
||||
j != k.a && j != k.b && g.shape.is_none() && {
|
||||
let other = pieces(self, g);
|
||||
mine.iter().any(|p| overlap(p, &other))
|
||||
mine.iter().zip(&was).any(|(p, q)| {
|
||||
overlap(p, &other) && shared(p, &other) > shared(q, &other) + FLAT_SLIVER * perimeter(p).max(perimeter(&other)).max(1.0)
|
||||
})
|
||||
}
|
||||
});
|
||||
if clash {
|
||||
|
||||
@@ -4932,6 +4932,48 @@ fn returns_follow_the_rules_gap_and_stay_open_with_a_warning_when_it_is_zero() {
|
||||
assert!((lengths[4] - lengths[0]).abs() < 1e-9 && (lengths[0] - (120.0 - 6.0 * 55f64.to_radians().tan())).abs() < 1e-6, "{lengths:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_on_a_notched_tray_close_at_the_corner_away_from_the_notch() {
|
||||
// A 500 x 400 tray (#8823) with a 100 x 100 notch out of one corner: walls 20 high on its six
|
||||
// edges, then returns 15 high turned in on all but the notch's side on x = 400. In the flat,
|
||||
// the walls on either side of the notch's inner corner both unfold into the notch, so the
|
||||
// return on y = 300 lies over the wall on x = 400 there whatever happens at its other end.
|
||||
// That overlap used to keep the return's corner at (500, 300) open ("closed, the flanges
|
||||
// would overlap in the flat pattern"), and the two returns ran through each other there.
|
||||
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}),
|
||||
);
|
||||
let pts: [(f64, f64); 6] = [(0.0, 0.0), (500.0, 0.0), (500.0, 300.0), (400.0, 300.0), (400.0, 400.0), (0.0, 400.0)];
|
||||
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Base"}));
|
||||
run(&mut s, "sketch.line", json!({"points": pts.map(|p| [p.0, p.1]), "closed": true}));
|
||||
run(&mut s, "sketch.finish", json!({}));
|
||||
run(&mut s, "sheet.flange", json!({"sketch": "Base"}));
|
||||
// The middle of edge k, `into` in from it (toward the base) and `z` up.
|
||||
let pick = |k: usize, into: f64, z: f64| {
|
||||
let (a, b) = (pts[k], pts[(k + 1) % pts.len()]);
|
||||
let l = (b.0 - a.0).hypot(b.1 - a.1);
|
||||
json!([(a.0 + b.0) / 2.0 - (b.1 - a.1) / l * into, (a.1 + b.1) / 2.0 + (b.0 - a.0) / l * into, z])
|
||||
};
|
||||
let walls: Vec<Value> = (0..6).map(|k| pick(k, 0.0, 2.0)).collect();
|
||||
run(&mut s, "sheet.flange", json!({"edges": walls, "height": 20, "angle": "90 deg"}));
|
||||
let returns: Vec<Value> = [0, 1, 2, 4, 5].iter().map(|&k| pick(k, 2.0, 20.0)).collect();
|
||||
run(&mut s, "sheet.flange", json!({"edges": returns, "height": 15, "angle": "90 deg"}));
|
||||
let warnings: Vec<String> = s.model.results.iter().filter_map(|r| r.warning.clone()).collect();
|
||||
assert!(s.model.results.iter().all(|r| r.error.is_none()) && warnings.is_empty(), "{warnings:?}");
|
||||
// The returns on x = 500 and y = 300 (z 18 … 20) are mitred on the diagonal through their
|
||||
// corner, the rule's gap apart: open on it, material on either side of it.
|
||||
assert!(!contains(&s, [490.0, 290.0, 19.0]), "the returns run through each other at (500, 300)");
|
||||
assert!(contains(&s, [490.0, 285.0, 19.0]) && contains(&s, [485.0, 290.0, 19.0]));
|
||||
// The other corners close as before, and the part is one valid solid.
|
||||
assert!(!contains(&s, [10.0, 10.0, 19.0]) && !contains(&s, [490.0, 10.0, 19.0]) && !contains(&s, [10.0, 390.0, 19.0]));
|
||||
let state = s.model.state();
|
||||
let body = &state.bodies[0].body;
|
||||
assert!(body.validity().is_empty() && body.shell_count() == 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bad_per_edge_input_is_refused_and_plain_edges_stay_plain() {
|
||||
let mut s = Session::default();
|
||||
|
||||
Reference in New Issue
Block a user