Files
solidcraft/crates/kernel/src/blend_corner.rs
T
f74c6605c4 Fillet: Mitre or Swept corners where two rounds meet (#11498)
* SMLib wrapper: a swept or mitred turn for constant rounds (Turn)

Brep::blend_dropping takes a Turn: Mitre (the default, as before) or Swept,
which sets solidcore's FilletSession::set_swept_turns before the corners are
made. A swept turn solidcore refuses at CreateFilletCorners comes back as
Error::TurnRefused with its reason and place (NoRoom at a concave side edge,
else CornerUnsupported). Swept is for Blend::Round only.

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

* Kernel: fillet rounds turn in a mitre or swept (FilletTurn)

fillet_removing, fillet_max, fillet_max_each and fillet_each take a
FilletTurn and hand it to SMLib, through the reblend of earlier rounds at a
later corner too. A swept corner solidcore does not build is refused as
invalid input with its reason and place: no smaller radius builds it.

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

* Design: a fillet saves its turn, mitre (default) or swept

FeatureKind::Fillet gets `turn` (FilletTurn: mitre, the default and not
saved, or swept), one pending format file. Evaluation hands it to the kernel,
pattern copies included, and refuses a swept turn with a style, fit, corner
or setbacks the kernel's swept corner does not take (SWEPT_TAKES).

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

* solid.fillet: the turn parameter, and the command's input and output schemas

`turn: mitre|swept` on solid.fillet, refused when unknown or with options a
swept corner does not take. solid.fillet now has its contract (FilletParams)
and reply type (FilletResult), registered with checked!, and leaves
schema/unconverted.txt.

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

* Fillet dialog: a Turns choice, Mitre or Swept

A Constant radius fillet's Turns row sends `turn: swept`; choosing a narrowed
radius or a curvature corner puts it back to Mitre, and Swept puts those back.
Its tooltip says what each does where two rounds turn round a corner edge.
New strings in a pending locale file (en, de, ja, ko, zh); glossary entry.

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

* Fillet turn: the schema tests' fixes and the complete catalogs' strings

The no-contract example in the schema tests is solid.chamfer now that
solid.fillet has one; the reply test checks the mid-radii form against the
contract (solidcore refuses that law's corner yet, #430) instead of building
it; Arabic, Hebrew and Vietnamese, complete catalogs, get the new strings.

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

* Fillet schema test: variable and spline forms checked against the contract

solidcore fails a variable round on a box edge at this pin (status 1001, as
variable_radius_on_a_box_edge), so the reply test checks those forms against
the contract instead of building them.

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

* Fillet turn: the swept rig cases pass; the MCP no-contract example is solid.chamfer

cov-fillet-turn-swept-boss-base-r1 and
cov-fillet-turn-swept-pocket-sharp-corner-refused-r1 pass now that
solid.fillet takes `turn`: off the rig's known-failing list. The MCP bridge
test's example of a command without a contract was solid.fillet, which has
one now.

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

---------

Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 20:36:00 -05:00

620 lines
34 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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);
}
}