Fillet fit: an outside round concentric with a wall's inside round is no longer refused (#2852)

* Fillet fit: a round counts only what lies between its edge and its arc

The fit check refused a round when any other face of the body reached into
the wedge between its edge and its two setback lines. A round changes only
the part of that wedge between the edge and its arc: a face on the ball's
side of the arc is left as it is. An outside round concentric with the
inside round of a 3 mm wall (R18 over R15) was refused as too large
(largest 14.21 mm) although it keeps the wall 3 mm thick.

The face check now tests a round's fan of prisms from its edge to its arc
(Frame::pieces, already used for blends that cross), after the wedge as a
quick filter. Chamfers keep the wedge, which is what they change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L15TLCjpXsQdp8ovC4ZacH

* Fillet fit: a curved face clears a round's thin end pieces only by a chord (#324)

The fan test shrank each piece by the curved faces' tolerance; the thin pieces at the
arc's ends vanished, so a hole wall 0.3 mm into a round beside it was missed and the
round failed to build instead of offering the radius that fits (issue_324_tests).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
This commit is contained in:
authored and GitHub committed 2026-10-19 16:08:37 -04:00
1 parent b0b59480eb
commit c1f9224579
2 files changed
+60 -9

No files matched your search

+11 -1
View File
@@ -365,13 +365,19 @@ enum Clash {
/// `strict`, when it comes within the chord of one (the surface may then be inside it).
fn first_clash(sel: &Selection, size: Size, strict: bool) -> Option<Clash> {
let wedges: Vec<Option<Wedge>> = sel.frames.iter().map(|f| f.as_ref().and_then(|f| f.wedge(size))).collect();
// What each blend changes: for a round only the fan between its edge and its arc, a part of
// the wedge. A face inside the wedge but beyond the arc (the inside round of a wall, when the
// outside one is a concentric round) is on the ball's side, left as it is.
let changes: Vec<Option<Vec<Wedge>>> = sel.frames.iter().map(|f| f.as_ref().and_then(|f| f.pieces(size))).collect();
// Planar faces are exact in the mesh; curved ones are within the chord.
let flat = (sel.size * 1e-7).max(1e-9);
let curved = if strict { -sel.chord } else { sel.chord * 2.0 };
// Planar faces beside an edge lie in its wedge's side planes: outside it means further.
let out = (sel.size * 1e-6).max(1e-8);
for (i, (f, w)) in sel.frames.iter().zip(&wedges).enumerate() {
for (i, ((f, w), changed)) in sel.frames.iter().zip(&wedges).zip(&changes).enumerate() {
let (Some(f), Some(w)) = (f, w) else { continue };
// Without its pieces (or for a chamfer, whose one piece is the wedge) the wedge counts.
let changed = changed.as_deref().unwrap_or_default();
let hit = sel.tris.iter().filter(|(_, face)| !f.allowed.contains(face)).any(|(t, face)| {
let eps = if sel.planar.get(*face).copied().unwrap_or(false) { flat } else { curved };
// The other blended edges this face runs along or ends them trim it back.
@@ -383,7 +389,11 @@ fn first_clash(sel: &Selection, size: Size, strict: bool) -> Option<Clash> {
.filter(|(j, (fj, _))| *j != i && fj.as_ref().is_some_and(|fj| fj.allowed.contains(face)))
.filter_map(|(_, (_, wj))| wj.as_ref())
.collect();
// The pieces near the arc's ends are thin: a curved face only goes clear of them
// when its mesh stays a chord outside, or a sliver into the round is missed (#324).
let fan = if sel.planar.get(*face).copied().unwrap_or(false) { flat } else { -sel.chord };
reaches_inside_beyond(t, &w.planes, eps, &trimmed, out)
&& (changed.len() <= 1 || changed.iter().any(|p| reaches_inside_beyond(t, &p.planes, fan, &trimmed, out)))
});
if hit {
return Some(Clash::Face);
+49 -8
View File
@@ -95,21 +95,27 @@ fn a_result_that_removes_more_than_the_blend_is_refused() {
assert!(m.contains("more than the chamfer can"), "{m}");
}
/// #1668: a box shelled outward 2 mm, open at the bottom. R5 on its top outer edge alone would
/// reach past the sharp inside corner 2 mm away; with the inside edge rounded in the same
/// fillet, that corner is filled, and the two build as one feature as they do one after the
/// other: the outer round takes (1 - π/4) · 25 mm² along 104 mm, the inner one adds it along
/// 100 mm.
/// #1668: a box shelled outward 2 mm, open at the bottom. R5 on its top outer edge alone leaves
/// the sharp inside corner 2 mm away on its ball's side, 0.76 mm inside the round; it reaches
/// the corner only past 2√2 / (√2 - 1) ≈ 6.83 mm. With the inside edge rounded in the same
/// fillet, the two build as one feature as they do one after the other: the outer round takes
/// (1 - π/4) · 25 mm² along 104 mm, the inner one adds it along 100 mm.
#[test]
fn rounds_on_both_sides_of_a_wall_build_as_one_fillet() {
let outer = box_solid(Vec3::new(-52.0, -32.0, 0.0), Vec3::new(52.0, 32.0, 42.0)).unwrap();
let shelled = cut(&outer, [-50.0, -30.0, -1.0], [50.0, 30.0, 40.0]);
let (out_edge, in_edge) = (Vec3::new(0.0, 32.0, 42.0), Vec3::new(0.0, 30.0, 40.0));
let m = too_large(crate::fillet(&shelled, &[out_edge], 5.0));
assert!(m.contains("runs past the faces beside the edge"), "{m}");
let section = (1.0 - std::f64::consts::FRAC_PI_4) * 25.0;
let alone = crate::fillet(&shelled, &[out_edge], 5.0).unwrap();
assert!(alone.validity().is_empty(), "{:?}", alone.validity());
let want = shelled.volume_at(0.01).unwrap() - section * 104.0;
assert!((crate::measure(&alone).unwrap().volume - want).abs() < 1e-4 * want);
let m = too_large(crate::fillet(&shelled, &[out_edge], 7.0));
let largest: f64 = m.rsplit("that fits is ").next().and_then(|t| t.trim_end_matches(" mm").parse().ok()).unwrap_or(0.0);
let limit = 2.0 * 2f64.sqrt() / (2f64.sqrt() - 1.0);
assert!(largest <= limit && largest > limit - 0.5, "{m}");
let both = crate::fillet(&shelled, &[out_edge, in_edge], 5.0).unwrap();
assert!(both.validity().is_empty(), "{:?}", both.validity());
let section = (1.0 - std::f64::consts::FRAC_PI_4) * 25.0;
let want = shelled.volume_at(0.01).unwrap() - section * 104.0 + section * 100.0;
let v = crate::measure(&both).unwrap().volume;
assert!((v - want).abs() < 1e-4 * want, "{v} vs {want}");
@@ -119,3 +125,38 @@ fn rounds_on_both_sides_of_a_wall_build_as_one_fillet() {
let m = too_large(crate::fillet(&shelled, &[out_edge, in_edge], 7.0));
assert!(m.contains("the largest radius that fits"), "{m}");
}
/// A shell 3 mm thick bent over like an upside-down U: 60 wide, 20 long, 50 high, its top
/// plate from z = 47 to 50 and its walls from x = 0 to 3 and 57 to 60.
fn bent_shell() -> Body {
let b = box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(60.0, 20.0, 50.0)).unwrap();
cut(&b, [3.0, -1.0, -1.0], [57.0, 21.0, 47.0])
}
/// The corner left by a round of radius `r` on a 90° edge, per unit length.
fn corner(r: f64) -> f64 {
r * r * (1.0 - std::f64::consts::FRAC_PI_4)
}
/// An outside round concentric with the inside one keeps the wall 3 mm thick: the inside round
/// lies inside the outside one's wedge, but on its ball's side of the arc, which the round
/// leaves as it is. It used to be refused as running into other geometry.
#[test]
fn outside_round_concentric_with_the_inside_round_of_a_wall_fits() {
let s = bent_shell();
let inside = [Vec3::new(3.0, 10.0, 47.0), Vec3::new(57.0, 10.0, 47.0)];
let outside = [Vec3::new(0.0, 10.0, 50.0), Vec3::new(60.0, 10.0, 50.0)];
let a = crate::fillet(&s, &inside, 15.0).unwrap();
let b = crate::fillet(&a, &outside, 18.0).unwrap();
assert!(b.validity().is_empty(), "{:?}", b.validity());
// The inside rounds fill their corners, the outside ones take theirs away.
let want = s.volume_at(0.01).unwrap() + 2.0 * 20.0 * (corner(15.0) - corner(18.0));
let got = b.volume_at(0.01).unwrap();
assert!((got - want).abs() < 1e-3 * want, "{got} for {want}");
// Larger, the outside round's centre moves off the inside one's: it runs into the hollow
// where its arc crosses the inside round's, at r = (18√2 - 15) / (√2 - 1) ≈ 25.24 mm.
let m = too_large(crate::fillet(&a, &outside, 30.0));
let largest: f64 = m.rsplit("that fits is ").next().and_then(|t| t.trim_end_matches(" mm").parse().ok()).unwrap_or(0.0);
let limit = (18.0 * 2f64.sqrt() - 15.0) / (2f64.sqrt() - 1.0);
assert!(largest <= limit && largest > limit - 0.5, "{m}");
}