Skip to content

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

Fillet fit check: rounds on both sides of a wall in one feature fit as they do one after the other (#1668) (#1720)

Erikas4bacd0cae051
diff --git a/crates/kernel/src/blend_fit.rs b/crates/kernel/src/blend_fit.rs
index f2e553016a..8deb9063d2 100644
--- a/crates/kernel/src/blend_fit.rs
+++ b/crates/kernel/src/blend_fit.rs
@@ -116,9 +116,52 @@ impl Frame {
if !(sa.is_finite() && sb.is_finite() && sa > 0.0 && sb > 0.0) {
return None;
}
+ self.prism(self.ta * sa, self.tb * sb)
+ }
+
+ /// For a round, the arc of its cross-section from the setback on face a to the one on face
+ /// b, in [`ARC_PIECES`] pieces, as offsets from the edge; `None` for a chamfer.
+ fn arc(&self, size: Size) -> Option<Vec<Vec3>> {
+ let Size::Round(r) = size else { return None };
+ let (sa, sb) = self.setbacks(size)?;
+ let half = 0.5 * self.ta.dot(self.tb).clamp(-1.0, 1.0).acos();
+ // The ball's centre, on the bisector, `r` from both faces.
+ let centre = (self.ta + self.tb).normalized()? * (r / half.sin());
+ let (a, b) = (self.ta * sa - centre, self.tb * sb - centre);
+ (0..=ARC_PIECES).map(|k| Some(centre + (a + (b - a) * (k as f64 / ARC_PIECES as f64)).normalized()? * r)).collect()
+ }
+
+ /// What a blend of the edge at `size` changes, within the wedge: for a round, the fan of
+ /// prisms from the edge to the pieces of its arc (between the edge and the arc lies all it
+ /// takes away or fills; the ball's side of the arc is left as it is), for a chamfer the
+ /// wedge itself.
+ fn pieces(&self, size: Size) -> Option<Vec<Wedge>> {
+ match self.arc(size) {
+ Some(arc) => arc.windows(2).map(|w| self.prism(*w.first()?, *w.get(1)?)).collect(),
+ None => Some(vec![self.wedge(size)?]),
+ }
+ }
+
+ /// The blend's own surface at `size`, as polygons: the strips between its arc's pieces, or
+ /// the chamfer's face.
+ fn surface(&self, size: Size) -> Option<Vec<Vec<Vec3>>> {
+ match self.arc(size) {
+ Some(arc) => arc
+ .windows(2)
+ .map(|w| {
+ let (u, v) = (*w.first()?, *w.get(1)?);
+ Some(vec![self.p0 + u, self.p0 + v, self.p1 + v, self.p1 + u])
+ })
+ .collect(),
+ None => Some(vec![self.wedge(size)?.faces.get(2)?.clone()]),
+ }
+ }
+
+ /// The triangle between the edge and the offsets `u` and `w` across it, swept along the edge.
+ fn prism(&self, u: Vec3, w: Vec3) -> Option<Wedge> {
let d = (self.p1 - self.p0).normalized()?;
- let (a0, b0) = (self.p0 + self.ta * sa, self.p0 + self.tb * sb);
- let (a1, b1) = (self.p1 + self.ta * sa, self.p1 + self.tb * sb);
+ let (a0, b0) = (self.p0 + u, self.p0 + w);
+ let (a1, b1) = (self.p1 + u, self.p1 + w);
// Each side's plane, facing away from the triangle's third corner.
let side = |p: Vec3, q: Vec3, opposite: Vec3| -> Option<(Vec3, f64)> {
let mut n = d.cross(q - p).normalized()?;
@@ -130,13 +173,18 @@ impl Frame {
let planes = [side(self.p0, a0, b0)?, side(self.p0, b0, a0)?, side(a0, b0, self.p0)?, (-d, -d.dot(self.p0)), (d, d.dot(self.p1))];
let faces =
vec![vec![self.p0, a0, a1, self.p1], vec![self.p0, b0, b1, self.p1], vec![a0, b0, b1, a1], vec![self.p0, a0, b0], vec![self.p1, a1, b1]];
- let area = 0.5 * (self.ta * sa).cross(self.tb * sb).len();
+ let area = 0.5 * u.cross(w).len();
Some(Wedge { planes, faces, volume: area * self.p0.dist(self.p1) })
}
}
-/// `poly` clipped to the half-spaces, each moved `eps` inwards: is anything left?
-fn reaches_inside(poly: &[Vec3], planes: &[(Vec3, f64)], eps: f64) -> bool {
+/// Pieces a round's arc is divided into for [`Frame::pieces`] and [`Frame::surface`]: each
+/// chord sags under 0.5 % of the radius.
+const ARC_PIECES: usize = 8;
+
+/// `poly` clipped to the half-spaces `n·x <= c`, each moved `eps` inwards (empty when nothing
+/// is left).
+fn clip(poly: &[Vec3], planes: &[(Vec3, f64)], eps: f64) -> Vec<Vec3> {
let mut cur: Vec<Vec3> = poly.to_vec();
for (n, c) in planes {
let c = c - eps;
@@ -152,11 +200,53 @@ fn reaches_inside(poly: &[Vec3], planes: &[(Vec3, f64)], eps: f64) -> bool {
}
}
if next.is_empty() {
- return false;
+ return next;
}
cur = next;
}
- true
+ cur
+}
+
+/// `poly` clipped to the half-spaces, each moved `eps` inwards: is anything left?
+fn reaches_inside(poly: &[Vec3], planes: &[(Vec3, f64)], eps: f64) -> bool {
+ !clip(poly, planes, eps).is_empty()
+}
+
+/// Most polygons [`reaches_inside_beyond`] clips before it gives up and answers yes.
+const MAX_CLIPS: usize = 4096;
+
+/// Whether the part of `poly` outside every one of the wedges `trimmed` (by more than `out`)
+/// reaches inside `planes` (by `eps`). A face beside or at the end of another edge the same
+/// feature blends is trimmed back to that blend, so its part inside that edge's wedge is gone
+/// (#1668).
+fn reaches_inside_beyond(poly: &[Vec3], planes: &[(Vec3, f64)], eps: f64, trimmed: &[&Wedge], out: f64) -> bool {
+ let mut parts = vec![poly.to_vec()];
+ for w in trimmed {
+ // Outside a convex wedge is outside one of its planes (pieces may overlap: only
+ // whether anything is left counts).
+ let mut next = Vec::new();
+ for part in &parts {
+ for (n, c) in &w.planes {
+ let piece = clip(part, &[(-*n, -*c)], out);
+ if !piece.is_empty() {
+ next.push(piece);
+ }
+ }
+ if next.len() > MAX_CLIPS {
+ return true;
+ }
+ }
+ parts = next;
+ }
+ parts.iter().any(|p| reaches_inside(p, planes, eps))
+}
+
+/// Whether two sets of convex prisms overlap (by more than `eps`): a face of one reaches
+/// inside the other.
+fn overlap(a: &[Wedge], b: &[Wedge], eps: f64) -> bool {
+ a.iter().any(|x| {
+ b.iter().any(|y| y.faces.iter().any(|p| reaches_inside(p, &x.planes, eps)) || x.faces.iter().any(|p| reaches_inside(p, &y.planes, eps)))
+ })
}
/// The body's straight edges between planar faces nearest the points (each once; `None` for a
@@ -275,11 +365,22 @@ fn first_clash(sel: &Selection, size: Size) -> Option<Clash> {
// Planar faces are exact in the mesh; curved ones are within the chord.
let flat = (sel.size * 1e-7).max(1e-9);
let curved = sel.chord * 2.0;
- for (f, w) in sel.frames.iter().zip(&wedges) {
+ // 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() {
let (Some(f), Some(w)) = (f, w) else { continue };
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 };
- reaches_inside(t, &w.planes, eps)
+ // The other blended edges this face runs along or ends them trim it back.
+ let trimmed: Vec<&Wedge> = sel
+ .frames
+ .iter()
+ .zip(&wedges)
+ .enumerate()
+ .filter(|(j, (fj, _))| *j != i && fj.as_ref().is_some_and(|fj| fj.allowed.contains(face)))
+ .filter_map(|(_, (_, wj))| wj.as_ref())
+ .collect();
+ reaches_inside_beyond(t, &w.planes, eps, &trimmed, out)
});
if hit {
return Some(Clash::Face);
@@ -295,7 +396,7 @@ fn first_clash(sel: &Selection, size: Size) -> Option<Clash> {
continue;
}
let meet = wj.faces.iter().any(|p| reaches_inside(p, &wi.planes, eps)) || wi.faces.iter().any(|p| reaches_inside(p, &wj.planes, eps));
- if meet {
+ if meet && blends_cross(fi, wi, fj, wj, size, eps) {
return Some(Clash::Blend);
}
}
@@ -303,6 +404,15 @@ fn first_clash(sel: &Selection, size: Size) -> Option<Clash> {
None
}
+/// Two blends whose wedges overlap: do they cross? Rounds on both sides of a wall (the outside
+/// round's wedge reaches past the inside corner, which the inside round fills) need not: they
+/// cross only where what one changes (between its edge and its arc) overlaps what the other
+/// does, or where either's surface runs into the other's wedge (#1668).
+fn blends_cross(fi: &Frame, wi: &Wedge, fj: &Frame, wj: &Wedge, size: Size, eps: f64) -> bool {
+ let (Some(pi), Some(pj), Some(si), Some(sj)) = (fi.pieces(size), fj.pieces(size), fi.surface(size), fj.surface(size)) else { return true };
+ overlap(&pi, &pj, eps) || sj.iter().any(|p| reaches_inside(p, &wi.planes, eps)) || si.iter().any(|p| reaches_inside(p, &wj.planes, eps))
+}
+
/// The step the largest fitting size is given to: three significant digits.
fn step(v: f64) -> f64 {
10f64.powf(v.log10().floor() - 3.0)
diff --git a/crates/kernel/src/issue_1080_tests.rs b/crates/kernel/src/issue_1080_tests.rs
index 914ffa3f54..4d3f66484d 100644
--- a/crates/kernel/src/issue_1080_tests.rs
+++ b/crates/kernel/src/issue_1080_tests.rs
@@ -94,3 +94,28 @@ fn a_result_that_removes_more_than_the_blend_is_refused() {
let m = too_large(crate::blend_fit::check_volume(&b, worse, &e, size));
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.
+#[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 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}");
+ let stepped = crate::fillet(&crate::fillet(&shelled, &[in_edge], 5.0).unwrap(), &[out_edge], 5.0).unwrap();
+ assert!((crate::measure(&stepped).unwrap().volume - v).abs() < 1e-4 * want);
+ // Past the wall's own room they still cross: R7's outer round reaches the inner one's arc.
+ let m = too_large(crate::fillet(&shelled, &[out_edge, in_edge], 7.0));
+ assert!(m.contains("the largest radius that fits"), "{m}");
+}