SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Fillets with a radius per edge. SMLib rounds every picked edge at its own radius in one
//! blend, with the corners where the rounds meet: an end in the face beyond, two rounds trimming
//! each other, or a corner patch where three meet.
//!
//! A later round at a corner where earlier rounds already meet in a mitre (the owner's ruling of
//! 2026-10-30) makes the corner all of them would have made rounded at once: one smooth patch,
//! the mitre gone. A body made by constant-radius rounds keeps what they were made on and which
//! edges they rounded at which radius ([`Rounds`]); a later round reaching such a corner
//! ([`later_corners`]) blends the earlier rounds' edges, from the earliest of the rounds that
//! meet there on, with the new edges in one SMLib blend of the body before them, and the result's
//! history is put over the body the later round was given ([`rebase`]): an earlier round's face
//! is that face, trimmed anew; the corner patch, and every face the new edges make, is the later
//! round's. The mitre's seam is no edge to round on its own: picked (a tangent chain reaches it
//! from the new edge), it only says the corner is blended again.
use std::collections::BTreeSet;
use solidcore_record::Vec3;
use crate::body::Body;
use crate::history::{Change, EdgeOrigin, EdgeProv, FaceOrigin, FaceProv, History};
use crate::{KernelError, Result};
/// The constant-radius rounds that made a body ([`crate::fillet`], [`fillet_radii`]): the body
/// they were made on, and each edge they rounded (its index in that body's edge order) with its
/// radius. The body's history is over `before`.
#[derive(Clone, Debug)]
pub(crate) struct Rounds {
pub(crate) before: Body,
pub(crate) edges: Vec<(usize, f64)>,
}
/// A later round at corners where earlier rounds meet ([`later_corners`]): what is blended in
/// one go, and what puts its history over the body the later round was given.
pub(crate) struct Later {
/// The body before the earliest of the rounds that meet at the new edges' corners.
pub(crate) base: Body,
/// The edges blended on `base` (its edge order) with their radii: the edges of every round
/// from that earliest on, and the new edges.
pub(crate) edges: Vec<(usize, f64)>,
/// The body over `base`: the histories of those rounds composed.
chain: History,
/// The new edges: each one's index in the body, and in `base`.
new: Vec<(usize, usize)>,
/// The body's mitre seams at the new edges' corners, which the corner patches replace.
seams: Vec<usize>,
}
impl Later {
/// How many of `edges`, the last ones, are the new edges.
pub(crate) fn new_count(&self) -> usize {
self.new.len()
}
}
/// The history of `body` over the body `levels` rounds back ([`Rounds::before`] taken that many
/// times), composed; `None` when a step has no record or history, or for no levels.
fn down(body: &Body, levels: usize) -> Option<History> {
let mut at = body.clone();
let mut composed: Option<History> = None;
for _ in 0..levels {
let rounds = at.rounds.clone()?;
let step = at.history().filter(|h| h.operands == 1)?.clone();
composed = Some(match composed {
None => step,
Some(h) => h.substituted(0, &step).ok()?,
});
at = rounds.before.clone();
}
composed
}
/// The operand edge `edge` of a result comes from, through `h`, when it is (a piece of) one.
fn edge_origin(h: &History, edge: usize) -> Option<usize> {
match h.edges.get(edge).map(|e| e.origins.as_slice()) {
Some([EdgeOrigin::Edge { operand: 0, edge }]) => Some(*edge),
_ => None,
}
}
/// Faces a blend made in place of edges (rounds, their corner patches), through `h`.
fn rounds_of(h: &History) -> Vec<bool> {
h.faces
.iter()
.map(|f| f.change == Change::Generated && !f.origins.is_empty() && f.origins.iter().all(|o| matches!(o, FaceOrigin::Edge { .. })))
.collect()
}
/// Is `edge` (its faces through `h`) where the rounds of different edges meet: between two of
/// `rounds` made in place of edges none of which both are (a mitre, or rounds running on into
/// each other), not between a round and its own end cap or a corner patch it is part of?
fn between_rounds(h: &History, rounds: &[bool], edge: usize) -> bool {
let round = |f: usize| rounds.get(f).copied().unwrap_or(false).then(|| h.faces.get(f)).flatten();
match h.edges.get(edge).map(|e| e.faces.as_slice()) {
Some([f, g]) if f != g => match (round(*f), round(*g)) {
(Some(a), Some(b)) => a.origins.iter().all(|o| !b.origins.contains(o)),
_ => false,
},
_ => false,
}
}
/// The later rounds of `picked` (the body's edges, `sizes` their radii, as the blend resolved
/// them) when one of them reaches a corner where rounds that made the body meet: the blend to
/// make in their place, and the new edges (in the body's edge order, with their radii) the
/// body's record of rounds takes. `Ok(None)` when none does, or when the rounds are not on record
/// down to that corner. A picked seam between earlier rounds is refused unless a new edge of
/// the same radius meets it: it has no round of its own.
pub(crate) fn later_corners(body: &Body, picked: &[usize], sizes: &[f64]) -> Result<Option<(Later, Vec<(usize, f64)>)>> {
// The rounds on record, latest first: each one's body before it and the body over that.
let mut levels: Vec<(Rounds, History)> = Vec::new();
while let Some(h) = down(body, levels.len() + 1) {
let Some(r) = (match levels.last() {
None => body.rounds.as_deref().cloned(),
Some((r, _)) => r.before.rounds.as_deref().cloned(),
}) else {
break;
};
levels.push((r, h));
}
let Some((_, deepest)) = levels.last() else { return Ok(None) };
let rounds = rounds_of(deepest);
let record = body.record();
let ends = |e: usize| record.edges.get(e).map(|e| e.vertices).unwrap_or([u32::MAX; 2]);
let (seam_picks, new): (Vec<(usize, f64)>, Vec<(usize, f64)>) =
picked.iter().copied().zip(sizes.iter().copied()).partition(|(e, _)| between_rounds(deepest, &rounds, *e));
let corners: BTreeSet<u32> = new.iter().flat_map(|(e, _)| ends(*e)).collect();
let seams: Vec<usize> =
(0..record.edges.len()).filter(|e| between_rounds(deepest, &rounds, *e) && ends(*e).iter().any(|v| corners.contains(v))).collect();
for (seam, size) in &seam_picks {
let meets = new.iter().any(|(e, r)| r.to_bits() == size.to_bits() && ends(*e).iter().any(|v| ends(*seam).contains(v)));
if !meets {
return Err(KernelError::Invalid(
"fillet: a picked edge is where earlier rounds meet (a mitre), which has no round of its own: pick the edge that runs \
into that corner, at its radius, and the corner is rounded again with it"
.into(),
));
}
}
if seams.is_empty() {
return Ok(None);
}
// The latest round from which on every seam is between rounds on record.
let Some(level) = levels.iter().position(|(_, h)| {
let rounds = rounds_of(h);
seams.iter().all(|s| between_rounds(h, &rounds, *s))
}) else {
return Ok(None);
};
let Some((base, chain)) = levels.get(level).map(|(r, h)| (r.before.clone(), h.clone())) else { return Ok(None) };
// Every round's edges from that level on, in `base`'s edge order.
let mut edges: Vec<(usize, f64)> = Vec::new();
for (step, (r, _)) in levels.iter().enumerate().take(level + 1) {
let inner = down(&r.before, level - step);
for (e, radius) in &r.edges {
let at = match &inner {
None => Some(*e),
Some(h) => edge_origin(h, *e),
};
let Some(at) = at else { return Ok(None) };
edges.push((at, *radius));
}
}
let mut mapped = Vec::with_capacity(new.len());
for (e, radius) in &new {
let Some(at) = edge_origin(&chain, *e) else { return Ok(None) };
mapped.push((*e, at));
edges.push((at, *radius));
}
Ok(Some((Later { base, edges, chain, new: mapped, seams }, new)))
}
/// The history of `result`, the blend `later` made of its base (`h`, over the base), over the
/// body the later round was given (`body`, `later.chain` over the base): a face of the base's
/// faces is the body's face of them, kept where both kept it, else trimmed anew (split or joined
/// where they are several); an earlier round's face is that round's face in the body; a face
/// made in place of a new edge (its round, and a corner patch where it meets earlier rounds) is
/// new, made in place of the new edges and of the body's seams between the rounds it joins.
/// Each edge is the body's edge between the faces it lies between there, else where its faces
/// meet. `None` where a face has no counterpart.
pub(crate) fn rebase(h: &History, later: &Later, body: &Body) -> Option<History> {
let chain = &later.chain;
let set = |p: &FaceProv| p.origins.iter().copied().collect::<BTreeSet<FaceOrigin>>();
let mut faces = Vec::with_capacity(h.faces.len());
for p in &h.faces {
let origins = set(p);
let new_edges: Vec<FaceOrigin> = later
.new
.iter()
.filter(|(_, at)| origins.contains(&FaceOrigin::Edge { operand: 0, edge: *at }))
.map(|(e, _)| FaceOrigin::Edge { operand: 0, edge: *e })
.collect();
if !new_edges.is_empty() {
// The seams between rounds all of whose origins this face takes up.
let replaced = later.seams.iter().filter(|s| {
chain.edges.get(**s).is_some_and(|e| e.faces.iter().all(|f| chain.faces.get(*f).is_some_and(|f| set(f).is_subset(&origins))))
});
let mut all = new_edges;
all.extend(replaced.map(|s| FaceOrigin::Edge { operand: 0, edge: *s }));
faces.push(crate::record::generated(all));
continue;
}
let candidates: Vec<usize> = if p.change == Change::Generated {
(0..chain.faces.len()).filter(|f| chain.faces.get(*f).is_some_and(|c| c.change == Change::Generated && set(c) == origins)).collect()
} else {
(0..chain.faces.len())
.filter(|f| chain.faces.get(*f).is_some_and(|c| c.change != Change::Generated && c.origins.iter().any(|o| origins.contains(o))))
.collect()
};
let change = match candidates[..] {
[] => return None,
[f] if p.change == Change::Kept && chain.faces.get(f).is_some_and(|c| c.change == Change::Kept) => Change::Kept,
[_] => Change::Modified,
_ => Change::Merged,
};
faces.push(FaceProv { origins: candidates.into_iter().map(|face| FaceOrigin::Face { operand: 0, face }).collect(), change });
}
crate::record::mark_shared_split(&mut faces);
// The body's faces under each result face, and the body's edges by the faces they separate.
let under = |f: usize| -> BTreeSet<usize> {
faces
.get(f)
.filter(|p| p.change != Change::Generated)
.map(|p| p.origins.iter().filter_map(|o| if let FaceOrigin::Face { face, .. } = o { Some(*face) } else { None }).collect())
.unwrap_or_default()
};
let body_edges = crate::history::edge_faces(body.record());
let edges = h
.edges
.iter()
.map(|e| {
let sides: Vec<BTreeSet<usize>> = e.faces.iter().map(|f| under(*f)).collect();
let same: Vec<EdgeOrigin> = if sides.iter().all(|s| !s.is_empty()) {
body_edges
.iter()
.enumerate()
.filter(|(_, between)| {
between.len() == sides.len()
&& (between.iter().zip(&sides).all(|(f, s)| s.contains(f))
|| between.iter().rev().zip(&sides).all(|(f, s)| s.contains(f)))
})
.map(|(edge, _)| EdgeOrigin::Edge { operand: 0, edge })
.collect()
} else {
Vec::new()
};
let origins = if same.is_empty() { crate::record::meeting(&e.faces, &faces) } else { same };
EdgeProv { faces: e.faces.clone(), origins }
})
.collect();
Some(History { operands: 1, faces, edges })
}
/// Fillet each edge nearest a point with its own radius.
pub fn fillet_radii(body: &Body, edges: &[(Vec3, f64)]) -> Result<Body> {
body.require_brep("fillet")?;
if edges.is_empty() || edges.len() > 1000 {
return Err(KernelError::Invalid("select 1…1000 edges".into()));
}
if edges.iter().any(|(p, r)| !(p.is_finite() && r.is_finite() && *r > 1e-6 && *r < 1e6)) {
return Err(KernelError::Invalid("fillet size must be positive".into()));
}
let (points, radii): (Vec<Vec3>, Vec<f64>) = edges.iter().copied().unzip();
crate::blend_smlib::fillet_each(body, &points, &radii, crate::FilletTurn::Mitre)
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use crate::blend::Faces;
use crate::{box_solid, fillet, measure};
use solidcraft_geom::brep::eval::CurveEval;
use solidcraft_geom::prelude::*;
/// The 20 mm box and the three edges at its corner (20, 0, 20): `a` along y, `b` along x,
/// `c` up.
fn setup() -> (Body, Vec3, Vec3, Vec3) {
let b = box_solid(Vec3::ZERO, Vec3::new(20.0, 20.0, 20.0)).unwrap();
(b, Vec3::new(20.0, 10.0, 20.0), Vec3::new(10.0, 0.0, 20.0), Vec3::new(20.0, 0.0, 10.0))
}
fn vol(b: &Body) -> f64 {
measure(b).unwrap().volume
}
/// The body minus the material outside each round (the strips between the faces and the
/// cylinders), for rounds `ra`, `rb`, `rc` on edges a, b, c: the strips integrated exactly
/// and their overlap at the corner numerically.
fn strips(ra: f64, rb: f64, rc: f64) -> f64 {
let len = |d: f64, r: f64| if d < r { r - (r * r - (r - d) * (r - d)).max(0.0).sqrt() } else { 0.0 };
let (n, l) = (800, 5.0);
let hh = l / n as f64;
let (mut union, mut sum) = (0.0, 0.0);
for i in 0..n {
let dx = (i as f64 + 0.5) * hh;
for j in 0..n {
let dy = (j as f64 + 0.5) * hh;
let tc = rc > 0.0 && dx < rc && dy < rc && (rc - dx).powi(2) + (rc - dy).powi(2) > rc * rc;
let (a, b) = (len(dx, ra).min(l), len(dy, rb).min(l));
union += if tc { l } else { a.max(b) };
sum += a + b + if tc { l } else { 0.0 };
}
}
let full = (1.0 - std::f64::consts::FRAC_PI_4) * (ra * ra + rb * rb + rc * rc) * 20.0;
8000.0 - full + (sum - union) * hh * hh
}
/// Largest angle (degrees) between the two faces' normals along edges between curved faces.
fn kink(b: &Body) -> f64 {
let rec = Faces::of(b).unwrap();
let mut worst: f64 = 0.0;
for (i, e) in rec.rec.edges.iter().enumerate() {
let faces: Vec<usize> = rec.faces_of(i).into_iter().map(|f| f as usize).collect();
let [f, g] = faces[..] else { continue };
if rec.plane_normal(f).is_some() || rec.plane_normal(g).is_some() {
continue;
}
let c = CurveEval::new(e.parameters()).unwrap();
let [t0, t1] = e.interval;
for k in 1..10 {
let p = c.point(t0 + (t1 - t0) * k as f64 / 10.0).unwrap();
let (a, bb) = (rec.normal_at(f, p, 1e-3).unwrap(), rec.normal_at(g, p, 1e-3).unwrap());
worst = worst.max(a.dot(bb).abs().min(1.0).acos().to_degrees());
}
}
worst
}
/// The body's vertex points.
fn vertices(b: &Body) -> Vec<Vec3> {
crate::native::brep_record(b).unwrap().vertices.iter().map(|v| Vec3::new(v.point[0], v.point[1], v.point[2])).collect()
}
#[test]
fn analytic_volumes_of_the_reference() {
// One round and the sphere corner of three equal ones.
let one = 8000.0 - (1.0 - std::f64::consts::FRAC_PI_4) * 4.0 * 20.0;
assert!((strips(2.0, 0.0, 0.0) - one).abs() < 1e-6);
// Rounds 2 and 3 on a and b: the overlap is ∫ (2 − √(4 − (z − 18)²))(3 − √(9 − (z − 17)²)) dz
// over z from 18 to 20 (Simpson, 200000 steps).
assert!((strips(2.0, 3.0, 0.0) - 7945.579002).abs() < 1e-3);
}
#[test]
fn a_round_next_to_a_round_of_another_radius() {
let (bx, a, b, _) = setup();
let ra = fillet(&bx, &[a], 2.0).unwrap();
// The round of b ends on the round of a: their cylinders trim each other.
let r = fillet(&ra, &[b], 3.0).unwrap();
assert_eq!(r.face_count(), 8);
assert_eq!(r.unmeshed_faces(), 0);
assert!((vol(&r) - strips(2.0, 3.0, 0.0)).abs() < 0.05, "{} vs {}", vol(&r), strips(2.0, 3.0, 0.0));
// The same in one go with a radius per edge, either way round.
for sel in [[(a, 2.0), (b, 3.0)], [(b, 3.0), (a, 2.0)]] {
let s = fillet_radii(&bx, &sel).unwrap();
assert!((vol(&s) - vol(&r)).abs() < 1e-3);
}
let s = fillet_radii(&bx, &[(a, 3.0), (b, 2.0)]).unwrap();
assert!((vol(&s) - strips(3.0, 2.0, 0.0)).abs() < 0.05);
// Equal radii: the mitre.
let e = fillet(&ra, &[b], 2.0).unwrap();
assert!((vol(&e) - strips(2.0, 2.0, 0.0)).abs() < 0.05);
}
#[test]
fn issue1557_vertical_after_bottom_rounds() {
let b = box_solid(Vec3::ZERO, Vec3::new(25.0, 25.0, 10.0)).unwrap();
let bottom = [Vec3::new(12.5, 0.0, 0.0), Vec3::new(25.0, 12.5, 0.0), Vec3::new(12.5, 25.0, 0.0), Vec3::new(0.0, 12.5, 0.0)];
let rounded = fillet(&b, &bottom, 2.0).unwrap();
let vertical = Vec3::new(25.0, 0.0, 6.0);
let seam = Vec3::new(24.287266336668306, 0.7127336633316916, 0.48266373325510686);
let mut together = bottom.to_vec();
together.push(vertical);
let reference = fillet(&b, &together, 2.0).unwrap();
// The vertical edge, alone or with the seam, with its tangent chain (as the Fillet feature
// asks for it): every pick gives the same body.
for picks in [vec![vertical], vec![vertical, seam], vec![seam, vertical]] {
let result = fillet(&rounded, &crate::tangent_chain(&rounded, &picks).unwrap(), 2.0).unwrap();
assert_eq!(result.face_count(), reference.face_count());
assert_eq!(result.unmeshed_faces(), 0);
assert!(result.validity().is_empty(), "{:?}", result.validity());
assert!((vol(&result) - vol(&reference)).abs() < 0.05);
assert_eq!(result.classify_point(Vec3::new(24.9, 0.1, 5.0)).unwrap(), crate::PointClass::Outside);
assert_eq!(result.classify_point(Vec3::new(24.0, 1.0, 5.0)).unwrap(), crate::PointClass::Inside);
}
}
#[test]
fn issue1557_connected_rounds_keep_their_radii() {
let b = box_solid(Vec3::ZERO, Vec3::new(25.0, 25.0, 10.0)).unwrap();
let bottom = [Vec3::new(12.5, 0.0, 0.0), Vec3::new(25.0, 12.5, 0.0), Vec3::new(12.5, 25.0, 0.0), Vec3::new(0.0, 12.5, 0.0)];
let rounded = fillet(&b, &bottom, 2.0).unwrap();
let vertical = Vec3::new(25.0, 0.0, 6.0);
let seam = Vec3::new(24.287266336668306, 0.7127336633316916, 0.48266373325510686);
for radius in [0.5, 1.0, 3.0] {
let mut together: Vec<_> = bottom.iter().map(|p| (*p, 2.0)).collect();
together.push((vertical, radius));
let reference = fillet_radii(&b, &together).unwrap();
let result = fillet(&rounded, &[seam, vertical], radius).unwrap();
assert!(result.validity().is_empty(), "{:?}", result.validity());
assert!((vol(&result) - vol(&reference)).abs() < 0.05, "radius {radius}");
// The old bottom radius is still 2, away from the newly rounded corner.
assert_eq!(result.classify_point(Vec3::new(12.5, 0.5, 0.5)).unwrap(), crate::PointClass::Outside);
assert_eq!(result.classify_point(Vec3::new(12.5, 1.0, 1.0)).unwrap(), crate::PointClass::Inside);
}
// A tangent boundary of an earlier round is not a sharp edge, and cannot be
// reinterpreted as the sharp edge exposed when that round is taken off.
assert!(fillet(&rounded, &[Vec3::new(12.5, 0.0, 2.0)], 1.0).is_err());
// Consuming a mitre must not silently discard its independently requested radius,
// or turn a mitre-only selection into a different sharp edge.
assert!(fillet_radii(&rounded, &[(vertical, 1.0), (seam, 2.0)]).is_err());
assert!(fillet_radii(&rounded, &[(seam, 2.0)]).is_err());
}
/// A 40 x 80 x 27 box (and the same shelled 1 mm, open at the top) with its bottom edges
/// rounded R2 as four separate fillets (mitred at the bottom corners), then one vertical
/// edge R2: the same solid whichever of its picks comes first. Horizontal sections: below
/// z = r above the bottom, s up, the rectangle moved in by d = r − ρ, ρ = √(r² − (r − s)²),
/// with the rounded corner a quarter disc of radius ρ less than its square (the sphere octant
/// where the three rounds meet); above, the rectangle less that corner at r. With
/// ∫ ρ = π r² / 4, ∫ ρ² = 2 r³ / 3, ∫ d = r² (1 − π/4) and ∫ d² = r³ (5/3 − π/2) over the
/// bottom r. The shell's cavity, 38 x 78 x 26, lies clear of both rounds (the bottom round's
/// arc passes 2 − √2 from the outer corner along the diagonal, the cavity's corner 1).
#[test]
fn issue2422_vertical_after_separate_bottom_rounds() {
use std::f64::consts::{FRAC_PI_2, FRAC_PI_4};
let origin = Vec3::new(-5.0, 7.2, -2.0);
let (l, w, h, r) = (40.0, 80.0, 27.0, 2.0);
let b = box_solid(origin, origin + Vec3::new(l, w, h)).unwrap();
let bottom = [Vec3::new(15.0, 7.2, -2.0), Vec3::new(35.0, 47.2, -2.0), Vec3::new(15.0, 87.2, -2.0), Vec3::new(-5.0, 47.2, -2.0)];
let spandrel = 1.0 - FRAC_PI_4;
let solid = l * w * r - 2.0 * (l + w) * r * r * spandrel + 4.0 * r * r * r * (5.0 / 3.0 - FRAC_PI_2) - spandrel * 2.0 * r * r * r / 3.0
+ (h - r) * (l * w - spandrel * r * r);
let cavity = (l - 2.0) * (w - 2.0) * (h - 1.0);
// The issue has no design attached. Reconstruct its outside corner and bottom mitre,
// using the reported picks, with and without the open cavity visible in the screenshot.
let picks = [Vec3::new(-5.0, 87.2, 12.5), Vec3::new(-4.283446394180081, 86.48344639418008, -1.5001085324947512)];
for (base, want) in [(b.clone(), solid), (crate::shell(&b, &[Vec3::new(15.0, 47.2, 25.0)], 1.0).unwrap(), solid - cavity)] {
// Each fillet with its tangent chain, as the Fillet feature asks for it by default
// (tangent propagation).
let mut rounded = base;
for edge in bottom {
rounded = fillet(&rounded, &crate::tangent_chain(&rounded, &[edge]).unwrap(), 2.0).unwrap();
}
for selection in [&picks[..1], &picks[..], &[picks[1], picks[0]][..]] {
let result = fillet(&rounded, &crate::tangent_chain(&rounded, selection).unwrap(), 2.0).unwrap();
assert!(result.validity().is_empty(), "{:?}", result.validity());
assert!((vol(&result) - want).abs() < 1e-6 * want, "{selection:?}: {} vs {want}", vol(&result));
assert_eq!(result.classify_point(Vec3::new(-4.9, 87.1, 10.0)).unwrap(), crate::PointClass::Outside);
assert_eq!(result.classify_point(Vec3::new(-4.1, 86.3, 10.0)).unwrap(), crate::PointClass::Inside);
}
}
}
#[test]
fn issue1557_all_vertical_corners_match_analytic_volume() {
let origin = Vec3::new(10.0, -5.0, 7.0);
let b = box_solid(origin, origin + Vec3::new(25.0, 25.0, 10.0)).unwrap();
let bottom =
[Vec3::new(12.5, 0.0, 0.0), Vec3::new(25.0, 12.5, 0.0), Vec3::new(12.5, 25.0, 0.0), Vec3::new(0.0, 12.5, 0.0)].map(|p| p + origin);
let vertical =
[Vec3::new(0.0, 0.0, 6.0), Vec3::new(25.0, 0.0, 6.0), Vec3::new(25.0, 25.0, 6.0), Vec3::new(0.0, 25.0, 6.0)].map(|p| p + origin);
let rounded = fillet(&b, &bottom, 2.0).unwrap();
// Each vertical edge with its tangent chain (on through the bottom rounds' corners), as
// the Fillet feature asks for it.
let result = fillet(&rounded, &crate::tangent_chain(&rounded, &vertical).unwrap(), 2.0).unwrap();
assert!(result.validity().is_empty(), "{:?}", result.validity());
assert!(kink(&result) < 0.05);
// Integrate rounded-square horizontal sections. Above z=r the area is
// L²-(4-π)r²; below, a square of side L-2r plus a disk offset of radius
// sqrt(r²-(z-r)²). This includes the four spherical bottom corners.
let (l, h, r) = (25.0, 10.0, 2.0);
let pi = std::f64::consts::PI;
let a = l - 2.0 * r;
let expected = (h - r) * (l * l - (4.0 - pi) * r * r) + a * a * r + pi * a * r * r + 2.0 * pi * r * r * r / 3.0;
assert!((vol(&result) - expected).abs() < 0.1, "{} vs {expected}", vol(&result));
}
#[test]
fn three_rounds_at_a_corner() {
let (bx, a, b, c) = setup();
// Two rounds meeting in a mitre, then the third edge with its tangent chain, as the Fillet
// feature asks for it (84bd2daad): the mitre's seam leaves c's end along c, so the chain
// is c and the seam, and the corner is a sphere octant. The cube less its three rounds
// (each (1 − π/4) r² over its 18 mm straight part) and the corner's 2 mm cube less the
// octant (r³ (1 − π/6)).
let ab = fillet(&bx, &[a, b], 2.0).unwrap();
let r = fillet(&ab, &crate::tangent_chain(&ab, &[c]).unwrap(), 2.0).unwrap();
let sphere = 8000.0 - 3.0 * (1.0 - std::f64::consts::FRAC_PI_4) * 4.0 * 18.0 - 8.0 * (1.0 - std::f64::consts::PI / 6.0);
assert_eq!(r.face_count(), 10);
assert!(r.validity().is_empty(), "{:?}", r.validity());
assert!((vol(&r) - sphere).abs() < 1e-11 * sphere, "{} vs {sphere}", vol(&r));
assert!(kink(&r) < 0.01);
// Different radii: SMLib's setback corner (SmBlendSetback.h). Each round runs whole up to
// its section square to its edge at its setback, the owner's rule's (at least 1.5 r, more
// where the rails beside it cross later, scaled to the least at which the corner's G1 fill
// is certified convex), and the hole between the three sections is filled by the setback
// split: one setback patch per round and the triangle between them in three
// quadrilaterals, so 6 planes, 3 rounds and 6 patches (15 faces), G1 across every seam.
// Outside the box the sections span ([20 - d_b, 20] x [0, d_a] x [20 - d_c, 20], d each
// edge's setback) the body is the three strips', so its volume is theirs within that box's.
// The rounds a and b of one radius lie mirrored about the plane x + y = 20 with c: one
// setback. (2, 2, 3): 3.6155, 3.6155, 4.6485; (2, 3, 4): 4.7745, 5.03975, 6.366 (a, b, c).
for (rs, sel) in [((2.0, 2.0, 3.0), fillet(&ab, &[c], 3.0)), ((2.0, 3.0, 4.0), fillet_radii(&bx, &[(a, 2.0), (b, 3.0), (c, 4.0)]))] {
let r = sel.unwrap();
assert_eq!(r.face_count(), 15);
assert_eq!(r.unmeshed_faces(), 0);
assert!(r.validity().is_empty(), "{:?}", r.validity());
let k = kink(&r);
assert!(k < 0.01, "kink {k}°");
let (ra, rb, rc) = rs;
let vs = vertices(&r);
// An edge's setback: where its round's section meets both faces, at two vertices.
let setback = |at: &dyn Fn(f64) -> [Vec3; 2], r: f64| -> Option<f64> {
vs.iter()
.flat_map(|p| [p.y, 20.0 - p.x, 20.0 - p.z])
.find(|d| *d >= 1.5 * r - 1e-9 && *d < 20.0 && at(*d).iter().all(|q| vs.iter().any(|p| p.dist(*q) < 1e-9)))
};
let da = setback(&|d| [Vec3::new(20.0 - ra, d, 20.0), Vec3::new(20.0, d, 20.0 - ra)], ra);
let db = setback(&|d| [Vec3::new(20.0 - d, 0.0, 20.0 - rb), Vec3::new(20.0 - d, rb, 20.0)], rb);
let dc = setback(&|d| [Vec3::new(20.0 - rc, 0.0, 20.0 - d), Vec3::new(20.0, rc, 20.0 - d)], rc);
eprintln!("{rs:?}: setbacks {da:?} {db:?} {dc:?}");
let (Some(da), Some(db), Some(dc)) = (da, db, dc) else { panic!("{rs:?}: a round's setback section is missing: {da:?} {db:?} {dc:?}") };
if ra == rb {
assert!((da - db).abs() < 1e-9, "{da} vs {db}");
}
let (v, s) = (vol(&r), strips(ra, rb, rc));
assert!((v - s).abs() < db * da * dc, "{v} vs {s}");
}
}
#[test]
fn corners_refuse_what_they_cannot_build() {
let (bx, a, b, _) = setup();
// Not a size: errors, no panic. Large but fitting is fine.
assert!(fillet_radii(&bx, &[(a, 15.0), (b, 2.0)]).is_ok_and(|r| r.unmeshed_faces() == 0));
// R25 on a overflows both its faces and goes first: its circle about (x, z) = (-5, -5)
// takes all of the top, and with it b, which is gone. What is left is R25's alone: the
// square [0, 20]² inside that circle, with t = x + 5, ∫₅^√600 √(625 − t²) dt − 5 (√600 − 5),
// along 20.
let g = |t: f64| 0.5 * (t * (625.0 - t * t).sqrt() + 625.0 * (t / 25.0).asin());
let w = 600f64.sqrt();
let want = 20.0 * (g(w) - g(5.0) - 5.0 * (w - 5.0));
let r = fillet_radii(&bx, &[(a, 25.0), (b, 2.0)]).unwrap();
assert!((vol(&r) - want).abs() < 1e-9 * want, "{} vs {want}", vol(&r));
assert!(fillet_radii(&bx, &[(a, f64::NAN)]).is_err());
assert!(fillet_radii(&bx, &[(a, 0.0)]).is_err());
assert!(fillet_radii(&bx, &[]).is_err());
assert!(fillet_radii(&bx, &[(Vec3::new(500.0, 0.0, 0.0), 1.0)]).is_err());
}
#[test]
fn sloped_basin_rim_fillets() {
use solidcore_record::{Loop2, Plane, Vec2};
let rectangle = |x0, y0, x1, y1| Loop2::polygon(&[Vec2::new(x0, y0), Vec2::new(x1, y0), Vec2::new(x1, y1), Vec2::new(x0, y1)]);
let slab = box_solid(Vec3::ZERO, Vec3::new(100.0, 60.0, 30.0)).unwrap();
let pocket =
crate::loft(&[(Plane::XY.offset(30.0), rectangle(20.0, 4.0, 80.0, 50.0)), (Plane::XY.offset(10.0), rectangle(30.0, 20.0, 70.0, 40.0))])
.unwrap();
let basin = crate::boolean(&slab, &pocket, crate::BoolOp::Cut).unwrap().unwrap();
let picks = [Vec3::new(50.0, 4.0, 30.0), Vec3::new(80.0, 27.0, 30.0), Vec3::new(50.0, 50.0, 30.0), Vec3::new(20.0, 27.0, 30.0)];
for count in 1..=4 {
let result = fillet(&basin, &picks[..count], 2.0).unwrap();
assert!(result.validity().is_empty());
assert_eq!(result.unmeshed_faces(), 0);
assert!(vol(&result) < vol(&basin));
let mesh = result.mesh(&crate::MeshTolerance::chord(0.01)).unwrap();
assert!(mesh.contains(Vec3::new(50.0, 2.0, 27.0)));
assert!(!mesh.contains(Vec3::new(50.0, 3.9, 29.99)));
// The small blend removes only a strip at the rim, and never escapes
// the slab. Topology checks alone do not catch crossed faces.
assert!(vol(&basin) - vol(&result) < 2.0_f64.powi(2) * (60.0 + 46.0) * 2.0);
for p in vertices(&result) {
assert!(p.x >= 0.0 && p.x <= 100.0 && p.y >= 0.0 && p.y <= 60.0 && p.z >= 0.0 && p.z <= 30.0 + 1e-8);
}
}
}
/// A chamfer 2 of a basin's rim loop (walls all sloping 10 over 20, the front rim 1 mm wide)
/// whose front leg runs off the rim over the slab's front edge builds, cut by the front face
/// (the owner's ruling of 2026-10-30, d7: a chamfer that reaches or runs past a rim builds).
/// Sliced at depth t below the top, each chamfer's strip beside its wall is
/// w(t) = d (1 − t/δ) wide, δ = d / √(1 + k²) with k = 1/2 the walls' run over drop; the four
/// meet in mitres at the rim's corners, so the section removed is the pocket's rectangle at t,
/// [20 + t/2, 80 − t/2] × [1 + t/2, 50 − t/2], grown by w(t) on every side and clipped to the
/// slab's front face y >= 0, less that rectangle. Its area is quadratic in t between δ and
/// where the front strip's edge 1 + t/2 − w(t) crosses y = 0, so Simpson's rule is exact on
/// each piece: 375.673069 taken from V0 = 140333.333333 (the prismatoid), 139957.660264.
#[test]
fn a_rim_loop_chamfer_running_off_its_rim_builds() {
use solidcore_record::{Loop2, Plane, Vec2};
let rectangle = |x0, y0, x1, y1| Loop2::polygon(&[Vec2::new(x0, y0), Vec2::new(x1, y0), Vec2::new(x1, y1), Vec2::new(x0, y1)]);
let slab = box_solid(Vec3::ZERO, Vec3::new(100.0, 60.0, 30.0)).unwrap();
let pocket =
crate::loft(&[(Plane::XY.offset(30.0), rectangle(20.0, 1.0, 80.0, 50.0)), (Plane::XY.offset(10.0), rectangle(30.0, 11.0, 70.0, 40.0))])
.unwrap();
let basin = crate::boolean(&slab, &pocket, crate::BoolOp::Cut).unwrap().unwrap();
let picks = [Vec3::new(50.0, 1.0, 30.0), Vec3::new(80.0, 27.0, 30.0), Vec3::new(50.0, 50.0, 30.0), Vec3::new(20.0, 27.0, 30.0)];
let (d, k) = (2.0_f64, 0.5_f64);
let delta = d / (1.0 + k * k).sqrt();
let area = |t: f64| {
let w = d * (1.0 - t / delta);
let (x0, x1, y0, y1) = (20.0 + k * t, 80.0 - k * t, 1.0 + k * t, 50.0 - k * t);
(x1 - x0 + 2.0 * w) * (y1 + w - (y0 - w).max(0.0)) - (x1 - x0) * (y1 - y0)
};
// 1 + k t − d (1 − t/δ) = 0.
let crossing = (d - 1.0) / (k + d / delta);
let removed: f64 =
[(0.0, crossing), (crossing, delta)].iter().map(|&(a, b)| (b - a) / 6.0 * (area(a) + 4.0 * area(0.5 * (a + b)) + area(b))).sum();
assert!((removed - 375.673069).abs() < 1e-6, "{removed}");
let before = crate::measure(&basin).unwrap().volume;
assert!((before - 140333.333333).abs() < 1e-5, "{before}");
let result = crate::chamfer(&basin, &picks, d).unwrap_or_else(|e| panic!("{e}"));
assert!(result.validity().is_empty(), "{:?}", result.validity());
let v = crate::measure(&result).unwrap().volume;
assert!((v - (before - removed)).abs() < 1e-6 * before, "{v} vs {}", before - removed);
}
}