* 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>
620 lines
34 KiB
Rust
620 lines
34 KiB
Rust
//! 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);
|
||
}
|
||
}
|