Files
solidcraft/crates/kernel/src/blend.rs
T
jyvikoandClaude Opus 5.5 5547cd98ad Blends: a picked edge is named as the blend takes it, the rim and not the seam
A chamfer picked at (10, 0, 20) on a cylinder's top rim lies on the vertex where SMLib's
cylinder has its seam. The blend takes the rim there (blend_smlib::resolve: a seam or a smooth
join loses a tie), but the name stored with the feature came from the nearest mesh edge, the
seam (`F2:side:c1`). Once the stem grew, the name found the seam and SMLib refused the chamfer
(join_extrude_from_a_chamfered_top_face). edge_names_for names the edge each pick takes as a
blend takes it (kernel::blend_edges), the nearest edge only where that finds none.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 12:05:37 -04:00

1192 lines
61 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.
//! Edge fillets and chamfers. SMLib blends exactly the picked edges in one call
//! ([`crate::blend_smlib`]): the blend faces, the corners where blends meet (a sphere, a patch, a
//! bevel or a mitre, as its fillet corners choose) and the end faces rebuilt round them. A blend
//! whose contact lines would leave the faces it rolls on is SMLib's refusal, reported as
//! [`KernelError::TooLarge`]. A tangent chain is the caller's to select ([`tangent_chain`]).
//!
//! The helpers here read a body's schema 4 record: planar faces' outward normals, the direction
//! into a face across an edge, an edge's tangent at its ends.
use std::collections::BTreeSet;
use solidcraft_geom::Vec3;
use solidcraft_geom::brep::eval::{CurveEval, SurfaceEval};
use solidcraft_geom::brep::{Brep, Curve, Loop, OrientedEdge, Shell, Surface};
use crate::body::Body;
use crate::{KernelError, Result};
pub(crate) fn unsupported(msg: &str) -> KernelError {
KernelError::Failed(format!("not supported yet: {msg}"))
}
/// A blend too large for the faces around it.
pub(crate) fn too_large(msg: &str) -> KernelError {
KernelError::TooLarge(msg.into())
}
fn v3(p: [f64; 3]) -> Vec3 {
Vec3::new(p[0], p[1], p[2])
}
/// A body's record as the blends' checks read it: the record and each face's side in its shell.
pub(crate) struct Faces {
pub(crate) rec: Brep,
/// Whether each face's outward normal is its surface's natural normal (`None`: in no face shell).
forward: Vec<Option<bool>>,
}
impl Faces {
pub(crate) fn of(body: &Body) -> Result<Faces> {
let rec = crate::native::brep_record(body)?;
let mut forward = vec![None; rec.faces.len()];
for sh in &rec.shells {
if let Shell::Faces { faces, .. } = sh {
for f in faces {
if let Some(slot) = forward.get_mut(f.face as usize) {
*slot = Some(f.forward);
}
}
}
}
Ok(Faces { rec, forward })
}
pub(crate) fn point(&self, v: u32) -> Option<Vec3> {
self.rec.vertices.get(v as usize).map(|v| v3(v.point)).filter(|p| p.is_finite())
}
/// The points of the edge's start and end vertices.
pub(crate) fn ends(&self, e: usize) -> Option<(Vec3, Vec3)> {
let [a, b] = self.rec.edges.get(e)?.vertices;
Some((self.point(a)?, self.point(b)?))
}
/// Whether the edge's curve is a straight line.
pub(crate) fn straight(&self, e: usize) -> bool {
self.rec.edges.get(e).is_some_and(|x| matches!(x.curve, Curve::Line { .. }))
}
/// The unit natural normal of a planar face's surface.
fn natural_plane_normal(&self, f: usize) -> Option<Vec3> {
let (du, dv) = match &self.rec.faces.get(f)?.surface {
Surface::Plane { u_axis, v_axis, .. } => (v3(*u_axis), v3(*v_axis)),
Surface::PlaneThrough { origin, u_point, v_point } => (v3(*u_point) - v3(*origin), v3(*v_point) - v3(*origin)),
_ => return None,
};
du.cross(dv).normalized().filter(|n| n.is_finite())
}
/// The side of the face in its shell: 1 where its outward normal is its surface's natural one.
fn side(&self, f: usize) -> Option<f64> {
self.forward.get(f).copied().flatten().map(|fw| if fw { 1.0 } else { -1.0 })
}
/// The outward unit normal of a planar face, if planar.
pub(crate) fn plane_normal(&self, f: usize) -> Option<Vec3> {
Some(self.natural_plane_normal(f)? * self.side(f)?)
}
/// The outward unit normal of face `f` at `p` (a point within `accept` of its surface).
pub(crate) fn normal_at(&self, f: usize, p: Vec3, accept: f64) -> Option<Vec3> {
let s = SurfaceEval::new(self.rec.faces.get(f)?.parameters()).ok()?;
let uv = s.project(p, None, accept)?;
let (_, su, sv) = s.derivs(uv[0], uv[1])?;
Some(su.cross(sv).normalized()? * self.side(f)?)
}
/// Every edge use in the face's loops.
pub(crate) fn uses(&self, f: usize) -> impl Iterator<Item = &OrientedEdge> {
self.rec.faces.get(f).into_iter().flat_map(|face| face.loops.iter()).flat_map(|l| match l {
Loop::Edges { edges } => edges.as_slice(),
Loop::Vertex { .. } => &[],
})
}
/// The faces that use the edge, each once.
pub(crate) fn faces_of(&self, e: usize) -> BTreeSet<u32> {
self.rec.edges.get(e).map(|x| x.uses.iter().map(|u| u.face).collect()).unwrap_or_default()
}
/// The unit direction into planar face `f` across the straight edge of `u`, square to the
/// edge: the face lies to the left of its loop seen from its surface's natural normal.
pub(crate) fn direction_into_face(&self, f: usize, u: &OrientedEdge) -> Option<Vec3> {
let (a, b) = self.ends(u.edge as usize)?;
let dir = if u.forward { b - a } else { a - b };
self.natural_plane_normal(f)?.cross(dir.normalized()?).normalized()
}
/// The edge's unit tangent along its interval (start to end vertex) at its start or end.
pub(crate) fn tangent(&self, e: usize, at_end: bool) -> Option<Vec3> {
let edge = self.rec.edges.get(e)?;
curve_tangent(edge.parameters(), if at_end { edge.interval[1] } else { edge.interval[0] })
}
}
/// The unit tangent of a record curve at `t`, along increasing `t`.
pub(crate) fn curve_tangent(c: &Curve, t: f64) -> Option<Vec3> {
curve_derivative(c, t)?.normalized().filter(|d| d.is_finite())
}
/// The first derivative of a record curve at `t` (of an intersection curve: its unit tangent).
pub(crate) fn curve_derivative(c: &Curve, t: f64) -> Option<Vec3> {
if !t.is_finite() {
return None;
}
let d = match c {
Curve::Line { start, end } => v3(*end) - v3(*start),
Curve::Circle { frame, radius } => {
let (s, co) = t.sin_cos();
(v3(frame.y_axis) * co - v3(frame.x_axis) * s) * *radius
}
Curve::Ellipse { frame, radii } => {
let (s, co) = t.sin_cos();
v3(frame.y_axis) * (radii[1] * co) - v3(frame.x_axis) * (radii[0] * s)
}
Curve::Polyline { points } => {
let last = points.len().checked_sub(2)?;
let i = (t.max(0.0).floor() as usize).min(last);
v3(*points.get(i + 1)?) - v3(*points.get(i)?)
}
Curve::Spline { .. } | Curve::RationalSpline { .. } => match CurveEval::new(c).ok()? {
CurveEval::Spline(s) => s.eval(t)?.1,
_ => return None,
},
Curve::SurfaceIntersection { surfaces, leader, .. } => {
// Along both surfaces: square to both normals, on the leader's side.
let p = CurveEval::new(c).ok()?.point(t)?;
let normal = |s: &Surface| -> Option<Vec3> {
let e = SurfaceEval::new(s).ok()?;
let uv = e.project(p, None, f64::INFINITY)?;
let (_, su, sv) = e.derivs(uv[0], uv[1])?;
Some(su.cross(sv))
};
let along = normal(&surfaces[0])?.cross(normal(&surfaces[1])?);
let along = along.normalized()?;
if along.dot(curve_tangent(leader, t)?) < 0.0 { along * -1.0 } else { along }
}
};
d.is_finite().then_some(d)
}
/// Curvature-continuous (G2) fillets: each section is SMLib's G2 blend curve between the contact
/// lines the round of `radius` has (zero curvature at the contacts on planar faces), not a
/// circle. A configuration SMLib cannot blend so is refused, never given a circular round.
pub fn fillet_g2(body: &Body, edges: &[Vec3], radius: f64) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "fillet_g2");
body.require_brep("G2 fillet")?;
if !(radius.is_finite() && radius > 1e-6 && radius < 1e6) {
return Err(KernelError::Invalid("G2 fillet size must be positive and finite".into()));
}
if edges.is_empty() || edges.len() > 1000 || edges.iter().any(|p| ![p.x, p.y, p.z].into_iter().all(f64::is_finite)) {
return Err(KernelError::Invalid("G2 fillet needs 1 to 1000 finite edge points".into()));
}
let out = crate::blend_smlib::fillet_g2(body, edges, radius)?;
closed(body, out)
}
/// A fillet's result, refused when a face's boundary crosses itself (#871): rounds that
/// overlap where a wall is thinner than both leave such faces, which the topology checks
/// don't see but which show as holes in the model. A fillet either closes the solid or is
/// refused. Faces of `input` that crossed already and that the fillet carried over unchanged
/// (a sliver an earlier boolean left far from the rounds, #1488) are not the fillet's doing.
fn closed(input: &Body, b: Body) -> Result<Body> {
let after = b.crossed_faces()?;
if after.is_empty() {
return Ok(b);
}
let before = input.crossed_faces()?;
let tol = (input.size().max(b.size()) * 1e-6).max(1e-9);
match after.iter().filter(|p| !before.iter().any(|q| q.dist(**p) <= tol)).count() {
0 => Ok(b),
_ => Err(KernelError::Failed(
"fillet: the rounds would leave openings in the surface (they overlap where a wall or a face is narrower than both)".into(),
)),
}
}
/// Constant-radius fillet of the edges nearest to the given points. A radius too large for the
/// faces around the edges is refused with [`KernelError::TooLarge`] ([`fillet_max`] finds the
/// largest that works).
pub fn fillet(body: &Body, edges: &[Vec3], radius: f64) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "fillet");
body.require_brep("fillet")?;
crate::blend_smlib::fillet(body, edges, radius).and_then(|b| closed(body, b))
}
/// [`fillet`] with corner setbacks: each `(at, distance)` sets back the corner at the vertex
/// nearest `at`, a vertex where every edge is rounded, so its patch starts `distance` along
/// each of its edges from the vertex (one distance for all of a corner's edges: SMLib keeps one
/// per corner). The rounds run whole up to their sections there, and the patch between them
/// meets each face in a curve from one round's contact line to the next. The distance must reach
/// past where the rounds would meet without it (past the radius at a square corner); a corner
/// where some edge is not rounded is refused as not supported, a setback as long as an edge at
/// its corner as too large.
pub fn fillet_setback(body: &Body, edges: &[Vec3], radius: f64, setbacks: &[(Vec3, f64)]) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "fillet_setback");
body.require_brep("fillet")?;
setbacks_reach(body, edges, radius, setbacks)?;
crate::blend_smlib::fillet_setback(body, edges, radius, setbacks).and_then(|b| closed(body, b))
}
/// Refuses a setback that does not reach past where its corner's rounds meet without one
/// ([`setback_minimum`]), naming the least it must exceed, at a corner where every edge is one
/// of `edges` (the others are SMLib's to refuse). SMLib fails there with its own status
/// (smlib_blend_setback): its patch does not join contact lines that already cross.
fn setbacks_reach(body: &Body, edges: &[Vec3], radius: f64, setbacks: &[(Vec3, f64)]) -> Result<()> {
let faces = Faces::of(body)?;
let (picked, _) = crate::blend_smlib::picked_edges(body, edges)?;
let picked: BTreeSet<usize> = picked.into_iter().collect();
for (at, distance) in setbacks {
let Some(v) = corner_vertex(body, &faces, *at) else { continue };
let all_rounded = (0..faces.rec.edges.len())
.filter(|e| faces.rec.edges.get(*e).is_some_and(|x| !x.uses.is_empty() && x.vertices.contains(&v)))
.all(|e| picked.contains(&e));
if !all_rounded {
continue;
}
let Some(least) = setback_minimum(&faces, v, radius) else { continue };
if *distance <= least * (1.0 + 1e-9) {
let p = faces.point(v).unwrap_or(*at);
let shown = format!("{:.4}", least).trim_end_matches('0').trim_end_matches('.').to_string();
let why =
if (least - radius).abs() <= radius * 1e-9 { format!("more than the radius ({shown} mm)") } else { format!("more than {shown} mm") };
return Err(KernelError::Invalid(format!(
"the setback must be {why} at the corner ({:.3}, {:.3}, {:.3}): the rounds' contact lines meet {shown} mm from it along its edges, \
and the corner's patch starts past that",
p.x, p.y, p.z
)));
}
}
Ok(())
}
/// The least setback the corner at the vertex nearest `at` takes with rounds of `radius`
/// ([`setback_minimum`]): a setback there must be more than this, or [`fillet_setback`] and
/// [`fillet_g2_corners`] refuse it. `None` where no vertex is near `at`, or at a corner whose
/// least SMLib decides (one with a curved face or edge).
pub fn fillet_least_setback(body: &Body, at: Vec3, radius: f64) -> Result<Option<f64>> {
body.require_brep("fillet")?;
let faces = Faces::of(body)?;
Ok(corner_vertex(body, &faces, at).and_then(|v| setback_minimum(&faces, v, radius)))
}
/// The vertex a setback at `at` names: the nearest, within the reach the setbacks take.
fn corner_vertex(body: &Body, faces: &Faces, at: Vec3) -> Option<u32> {
let reach = body.size() * 0.05 + 1e-3;
(0..faces.rec.vertices.len())
.filter_map(|v| u32::try_from(v).ok())
.filter_map(|v| faces.point(v).map(|p| (p.dist(at), v)))
.filter(|(d, _)| *d <= reach)
.min_by(|a, b| a.0.total_cmp(&b.0))
.map(|(_, v)| v)
}
/// The least setback a corner of rounds of `radius` at `vertex` takes: on each face at the
/// corner, the contact lines (rails) of the two rounded edges beside it cross, and a setback
/// must reach past that crossing along both edges (smlib_blend_setback). A rail lies
/// r tan(psi / 2) from its edge, psi the angle between the outward normals of the edge's two
/// faces (r on faces square to each other); the rails of edges at angle alpha on a face, d1 and
/// d2 from them, cross (d2 + d1 cos alpha) / sin alpha along the first edge from the vertex.
/// Exact for planar faces and straight edges; `None` for a corner with any other (left to SMLib)
/// or one it cannot read.
fn setback_minimum(faces: &Faces, vertex: u32, radius: f64) -> Option<f64> {
let at: Vec<usize> =
(0..faces.rec.edges.len()).filter(|e| faces.rec.edges.get(*e).is_some_and(|x| !x.uses.is_empty() && x.vertices.contains(&vertex))).collect();
if at.len() < 3 {
return None;
}
// Each edge's direction away from the vertex and its rail's distance from it.
let mut away = Vec::with_capacity(at.len());
let mut rail = Vec::with_capacity(at.len());
for e in &at {
let [a, b] = faces.rec.edges.get(*e)?.vertices;
if a == b || !faces.straight(*e) {
return None;
}
let (pa, pb) = faces.ends(*e)?;
away.push(if a == vertex { (pb - pa).normalized()? } else { (pa - pb).normalized()? });
let [f, g]: [u32; 2] = faces.faces_of(*e).into_iter().collect::<Vec<_>>().try_into().ok()?;
let cos = faces.plane_normal(f as usize)?.dot(faces.plane_normal(g as usize)?).clamp(-1.0, 1.0);
rail.push(radius * (cos.acos() / 2.0).tan());
}
let mut least: f64 = 0.0;
let around: BTreeSet<u32> = at.iter().flat_map(|e| faces.faces_of(*e)).collect();
for f in around {
let beside: Vec<usize> = (0..at.len()).filter(|i| at.get(*i).is_some_and(|e| faces.faces_of(*e).contains(&f))).collect();
let [i, j] = beside[..] else { return None };
let cos = away.get(i)?.dot(*away.get(j)?).clamp(-1.0, 1.0);
let sin = (1.0 - cos * cos).sqrt();
if sin <= 1e-9 {
return None;
}
let (di, dj) = (*rail.get(i)?, *rail.get(j)?);
least = least.max((dj + di * cos) / sin).max((di + dj * cos) / sin);
}
(least.is_finite() && least > 0.0).then_some(least)
}
/// [`fillet`] whose corners where three or more rounded edges meet are G2 patches
/// ([`crate::corner_g2`]): each such corner is set back, `setbacks` naming a corner by a point at
/// its vertex and the distance its patch starts along each edge there (the others take
/// [`crate::DEFAULT_SETBACK_FACTOR`] times the radius), SMLib leaves it open, and a patch that
/// meets the rounds and the faces round it to the second order fills it. The faces are sewn
/// into one solid, convex corners and concave ones alike. Without such a corner this is
/// [`fillet`]. Refused: a corner where an edge is not rounded, or whose edges are not all of one
/// convexity (SMLib sets back only corners where all are rounded, alike), a setback that does not reach past
/// where the rounds would meet, a hole that is no height field over its plane or a patch that
/// does not meet its neighbours within the tolerances.
pub fn fillet_g2_corners(body: &Body, edges: &[Vec3], radius: f64, setbacks: &[(Vec3, f64)]) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "fillet_g2_corners");
body.require_brep("fillet")?;
if !(radius.is_finite() && radius > 0.0) {
return Err(KernelError::Invalid("the blend radius must be finite and positive".into()));
}
let (picked, _) = crate::blend_smlib::picked_edges(body, edges)?;
let rec = body.record();
let picked: BTreeSet<usize> = picked.into_iter().collect();
// Each vertex's edges (a closed edge's one vertex once).
let mut at: std::collections::BTreeMap<u32, BTreeSet<usize>> = std::collections::BTreeMap::new();
for (i, e) in rec.edges.iter().enumerate() {
if e.uses.is_empty() {
continue;
}
for v in e.vertices {
at.entry(v).or_default().insert(i);
}
}
let point = |v: u32| rec.vertices.get(v as usize).map(|x| v3(x.point));
let mut corners: Vec<Vec3> = Vec::new();
for (v, around) in &at {
let rounded = around.iter().filter(|e| picked.contains(e)).count();
if rounded < 3 {
continue;
}
let p = point(*v).ok_or_else(|| KernelError::Failed("fillet: a vertex reference".into()))?;
if rounded < around.len() {
return Err(unsupported(&format!(
"a G2 corner at ({:.3}, {:.3}, {:.3}) where an edge is not rounded (the corner is set back, and SMLib sets back only a corner where every edge is)",
p.x, p.y, p.z
)));
}
corners.push(p);
}
if corners.is_empty() {
return fillet(body, edges, radius);
}
// Each corner's setback: the one given at its vertex, else the default.
let reach = body.size() * 0.05 + 1e-3;
let mut distance = vec![crate::corner_g2::DEFAULT_SETBACK_FACTOR * radius; corners.len()];
for (p, d) in setbacks {
let k = corners
.iter()
.enumerate()
.map(|(k, c)| (c.dist(*p), k))
.filter(|(d, _)| *d <= reach)
.min_by(|a, b| a.0.total_cmp(&b.0))
.map(|(_, k)| k)
.ok_or_else(|| {
KernelError::Invalid(format!(
"the setback at ({:.3}, {:.3}, {:.3}) names no G2 corner (a vertex where three or more rounded edges meet)",
p.x, p.y, p.z
))
})?;
if let Some(slot) = distance.get_mut(k) {
*slot = *d;
}
}
let set_back: Vec<(Vec3, f64)> = corners.iter().copied().zip(distance).collect();
setbacks_reach(body, edges, radius, &set_back)?;
let open = crate::blend_smlib::fillet_setback_open(body, edges, radius, &set_back)?;
let mut patches = Vec::with_capacity(open.holes.len());
for hole in &open.holes {
let (patch, _) = crate::corner_g2::corner_patch(&open.sheet, hole, radius)?;
patches.push(patch);
}
let mut parts: Vec<&Body> = vec![&open.sheet];
parts.extend(patches.iter());
let sewn = crate::stitch(&parts, 0.0)?;
let open_shells = sewn.validity();
if !open_shells.is_empty() {
return Err(KernelError::Failed(format!("fillet: the G2 corners do not close the body: {}", open_shells.join("; "))));
}
let history = corner_history(&sewn, body, &open.sheet, &patches);
closed(body, sewn.with_checked_history(history, &crate::record::counts(&[body])))
}
/// The history of the sewn G2-cornered fillet over `[body]`: the sewing's history (over the
/// sheet and the patches) carried through the sheet's (over the body); each patch face made from
/// the edges whose rounds meet at its corner, as SMLib's own corner patch is, each of its edges
/// the sheet's.
fn corner_history(sewn: &Body, body: &Body, sheet: &Body, patches: &[Body]) -> Option<crate::history::History> {
use crate::history::{EdgeOrigin, FaceOrigin};
let outer = sewn.history()?.clone();
let inner = sheet.history()?;
let mut parts = vec![inner.clone()];
for patch in patches {
let own = patch.history()?;
// The patch's face comes from the rounded edges the sheet's faces beside it come from.
let mut origins: BTreeSet<FaceOrigin> = BTreeSet::new();
for e in &own.edges {
for o in &e.origins {
let EdgeOrigin::Edge { edge, .. } = o else { continue };
for f in inner.edges.get(*edge).map(|x| x.faces.as_slice()).unwrap_or_default() {
let beside = inner.faces.get(*f).map(|x| x.origins.as_slice()).unwrap_or_default();
origins.extend(beside.iter().copied().filter(|g| matches!(g, FaceOrigin::Edge { .. })));
}
}
}
let mut h = own.clone().substituted(0, inner).ok()?;
for f in &mut h.faces {
*f = crate::record::generated(origins.iter().copied().collect());
}
parts.push(h);
}
let h = outer.over(&parts.iter().collect::<Vec<_>>()).ok()?;
h.check_counts((sewn.face_count(), sewn.edge_count()), &crate::record::counts(&[body])).ok()?;
Some(h)
}
/// The step of the radius search: three significant digits of the requested radius.
fn radius_step(radius: f64) -> f64 {
10f64.powf(radius.log10().floor() - 3.0)
}
/// The largest radius below `radius` (to three significant digits) at which the fillet of
/// these edges works, with its result; `Ok(None)` when none does. Each candidate is a real fillet
/// of the edges, so the radius returned is one that was built; the search runs up to 16 of
/// them, so it is for an explicit request, not every refusal. Only a refusal as too large
/// ([`KernelError::TooLarge`]) narrows the search: any other failure of a candidate is the
/// search's error, since a smaller radius would not be the largest that fits.
pub fn fillet_max(body: &Body, edges: &[Vec3], radius: f64) -> Result<Option<(f64, Body)>> {
let _span = solidcraft_profile::span("kernel", "fillet_max");
if !(radius.is_finite() && radius > 1e-6) {
return Ok(None);
}
let q = radius_step(radius);
// Radii n·q for n in [0, hi): hi is too large (it is the request, or above it), lo works.
let mut hi = (radius / q).ceil() as u64;
let mut lo = 0u64;
let mut best: Option<Body> = None;
// log2(10⁴) steps reach the step size; the cap keeps a slow body from stalling.
for _ in 0..16 {
if hi - lo <= 1 {
break;
}
let mid = lo + (hi - lo) / 2;
match fillet(body, edges, mid as f64 * q) {
Ok(b) => {
lo = mid;
best = Some(b);
}
Err(KernelError::TooLarge(_)) => hi = mid,
Err(e) => return Err(e),
}
}
Ok(best.map(|b| (lo as f64 * q, b)))
}
/// [`fillet_max`] for each group of the edges that may limit each other's radius (sharing a
/// face or a vertex, directly or through other edges in the group), so a round that fits isn't
/// reduced for a tight edge elsewhere. The radius per edge (in `edges`' order) and the result,
/// `Ok(None)` when no radius fits. One radius for all (as [`fillet_max`]) when the groups,
/// each reduced to fit, are too large together, or there are too many to search (each search is
/// up to 16 fillets, and this runs in the live preview). Any failure other than a refusal as too
/// large is the error.
pub fn fillet_max_each(body: &Body, edges: &[Vec3], radius: f64) -> Result<Option<(Vec<f64>, Body)>> {
let _span = solidcraft_profile::span("kernel", "fillet_max_each");
const MAX_GROUPS: usize = 8;
const MAX_SEARCHES: usize = 2;
let one = || -> Result<Option<(Vec<f64>, Body)>> { Ok(fillet_max(body, edges, radius)?.map(|(r, b)| (vec![r; edges.len()], b))) };
let Some(groups) = interacting_groups(body, edges).filter(|g| g.len() > 1 && g.len() <= MAX_GROUPS) else { return one() };
let mut radii = vec![radius; edges.len()];
let mut searches = 0;
for g in &groups {
let pts: Vec<Vec3> = g.iter().filter_map(|i| edges.get(*i).copied()).collect();
let r = match fillet(body, &pts, radius) {
Ok(_) => continue,
Err(KernelError::TooLarge(_)) if searches < MAX_SEARCHES => {
searches += 1;
match fillet_max(body, &pts, radius)? {
Some((r, _)) => r,
None => return one(),
}
}
Err(KernelError::TooLarge(_)) => return one(),
Err(e) => return Err(e),
};
for i in g {
if let Some(x) = radii.get_mut(*i) {
*x = r;
}
}
}
match fillet_each(body, edges, &radii) {
Ok(b) => Ok(Some((radii, b))),
Err(KernelError::TooLarge(_)) => one(),
Err(e) => Err(e),
}
}
/// The fillet of each edge at its own radius (`radii` in `edges`' order), all in one SMLib
/// blend.
pub fn fillet_each(body: &Body, edges: &[Vec3], radii: &[f64]) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "fillet_each");
if radii.len() != edges.len() {
return Err(KernelError::Invalid("one radius per edge".into()));
}
if let Some(r) = radii.first().filter(|r| radii.iter().all(|x| x.to_bits() == r.to_bits())) {
return fillet(body, edges, *r);
}
body.require_brep("fillet")?;
crate::blend_smlib::fillet_each(body, edges, radii).and_then(|b| closed(body, b))
}
/// The points' edges (each the edge a blend's pick there takes) grouped where they share a face
/// or a vertex, directly or through other points' edges: indices into `pts`. `None` when a point
/// has no edge near it.
fn interacting_groups(body: &Body, pts: &[Vec3]) -> Option<Vec<Vec<usize>>> {
let rec = Faces::of(body).ok()?;
let (picked, _) = crate::blend_smlib::picked_edges(body, pts).ok()?;
// What each point's edge touches: its faces and its ends.
let mut groups: Vec<(BTreeSet<u32>, BTreeSet<u32>, Vec<usize>)> = Vec::new();
for (i, idx) in picked.into_iter().enumerate() {
let mut faces = rec.faces_of(idx);
let mut ends: BTreeSet<u32> = rec.rec.edges.get(idx)?.vertices.into_iter().collect();
let mut members = vec![i];
// Join every group touching one of these faces or ends.
let (meet, rest): (Vec<_>, Vec<_>) = groups.into_iter().partition(|(fs, vs, _)| !fs.is_disjoint(&faces) || !vs.is_disjoint(&ends));
for (fs, vs, ms) in meet {
faces.extend(fs);
ends.extend(vs);
members.extend(ms);
}
groups = rest;
groups.push((faces, ends, members));
}
Some(
groups
.into_iter()
.map(|(_, _, mut ms)| {
ms.sort_unstable();
ms
})
.collect(),
)
}
/// Equal-distance chamfer of the edges nearest to the given points, `distance` back along each
/// face, neighbouring chamfers meeting in a mitre.
pub fn chamfer(body: &Body, edges: &[Vec3], distance: f64) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "chamfer");
body.require_brep("chamfer")?;
if !(distance.is_finite() && distance > 1e-6 && distance < 1e6) {
return Err(KernelError::Invalid("chamfer size must be positive".into()));
}
if edges.is_empty() || edges.len() > 1000 {
return Err(KernelError::Invalid("select 1…1000 edges".into()));
}
crate::blend_smlib::chamfer(body, edges, distance)
}
/// The second side of an unequal chamfer: a distance along the other face, or the angle the
/// chamfer makes with the first face.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ChamferSide {
Distance(f64),
Angle(f64),
}
/// A chamfer with different setbacks on the two faces of each edge: `d1` along the first face
/// (the one facing up most, the other with `flip`), the second side by distance or angle.
pub fn chamfer_sides(body: &Body, edges: &[Vec3], d1: f64, side: ChamferSide, flip: bool) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "chamfer_sides");
body.require_brep("chamfer")?;
let ok = |x: f64| x.is_finite() && x > 1e-6 && x < 1e6;
let valid = ok(d1)
&& match side {
ChamferSide::Distance(d) => ok(d),
ChamferSide::Angle(a) => a.is_finite() && a > 1e-3 && a < std::f64::consts::PI - 1e-3,
};
if !valid {
return Err(KernelError::Invalid("chamfer sizes must be positive (the angle within 0°…180°)".into()));
}
if edges.is_empty() || edges.len() > 1000 {
return Err(KernelError::Invalid("select 1…1000 edges".into()));
}
crate::blend_smlib::chamfer_sides(body, edges, d1, side, flip)
}
/// The edge each pick takes, as a blend takes it (an index in the body's edge order, the order
/// of its mesh's edges): the nearest, and at a vertex where a seam or a smooth join meets a sharp
/// edge (a cylinder's seam at its rim), the sharp edge. Picks that find no edge are refused.
pub fn blend_edges(body: &Body, picks: &[Vec3]) -> Result<Vec<usize>> {
crate::blend_smlib::picked_edges(body, picks).map(|(edges, _)| edges)
}
/// The picked edges' tangent chains, for a blend that is to run along them: `picks` (each the
/// nearest edge of `body` to it), then a point on every other edge that continues one of them
/// tangentially (within 0.5° at a shared vertex), until no more do. Each pick takes its edge as a
/// blend does (a pick at a vertex where a seam meets a rim takes the rim). An edge only one face
/// uses ends a chain, and so do a seam and a smooth edge (its two faces meet tangentially, within
/// 0.5°): they have no corner to round. A chain does not run on into an edge of the other
/// convexity (a boss's concave base running on tangentially as the convex rim of its overhang):
/// a round cannot pass from one side of the faces to the other, so it ends at that vertex.
/// Picks that find no edge are refused.
pub fn tangent_chain(body: &Body, picks: &[Vec3]) -> Result<Vec<Vec3>> {
if picks.is_empty() || picks.len() > 1000 || picks.iter().any(|p| !p.is_finite()) {
return Err(KernelError::Invalid("select 1…1000 edges by finite points".into()));
}
let rec = Faces::of(body)?;
let (seeds, hidden) = crate::blend_smlib::picked_edges(body, picks)?;
let mut picked: Vec<usize> = Vec::new();
for e in seeds {
if !picked.contains(&e) {
picked.push(e);
}
}
let chain = chain_of(&rec, &picked, &hidden);
let mut out = picks.to_vec();
for e in chain.into_iter().skip(picked.len()) {
out.push(edge_middle(&rec, e).ok_or_else(|| KernelError::Failed("a point on a chain edge".into()))?);
}
Ok(out)
}
/// Edges meeting at an angle below this continue one another; faces meeting at an angle below
/// it meet tangentially.
const TANGENT_DEGREES: f64 = 0.5;
/// The point halfway along edge `e`.
fn edge_middle(rec: &Faces, e: usize) -> Option<Vec3> {
let edge = rec.rec.edges.get(e)?;
CurveEval::new(edge.parameters()).ok().and_then(|c| c.point(0.5 * (edge.interval[0] + edge.interval[1])))
}
/// How far from a face's surface a point may lie for its normal there.
fn normal_reach(rec: &Faces) -> f64 {
rec.rec.tolerance.max(1e-7) * 10.0
}
/// Whether edge `e`'s two faces meet tangentially (within [`TANGENT_DEGREES`]) at its start: a
/// smooth edge, with no corner to blend.
fn smooth_join(rec: &Faces, e: usize) -> bool {
let cos = TANGENT_DEGREES.to_radians().cos();
let accept = normal_reach(rec);
let faces: Vec<u32> = rec.faces_of(e).into_iter().collect();
let (Some(&a), Some(&b), Some((p, _))) = (faces.first(), faces.get(1), rec.ends(e)) else { return false };
match (rec.normal_at(a as usize, p, accept), rec.normal_at(b as usize, p, accept)) {
(Some(na), Some(nb)) => faces.len() == 2 && na.dot(nb) > cos,
_ => false,
}
}
/// `seeds` (edges in the record's order, each once), then every other edge that continues one
/// of them tangentially, as [`tangent_chain`] follows them; `hidden` marks the edges a pick
/// passes over.
fn chain_of(rec: &Faces, seeds: &[usize], hidden: &[bool]) -> Vec<usize> {
let mut chain = seeds.to_vec();
// The unit direction edge `e` leaves its end `v` in.
let leaving = |e: usize, v: u32| -> Option<Vec3> {
let [a, b] = rec.rec.edges.get(e)?.vertices;
if a == b {
return None;
}
if a == v { rec.tangent(e, false) } else { rec.tangent(e, true).map(|t| t * -1.0) }
};
let cos = TANGENT_DEGREES.to_radians().cos();
let accept = normal_reach(rec);
// Whether edge `e` is convex at its end `v` (its faces meet at less than 180° inside the
// body): the direction into its second face, square to it, points against its first face's
// outward normal. A face lies to the left of its loop seen from its surface's natural normal.
// None for an edge without exactly two uses, or where a normal cannot be found.
let convex = |e: usize, v: u32| -> Option<bool> {
let edge = rec.rec.edges.get(e)?;
let [ua, ub] = edge.uses.as_slice() else { return None };
let forward_b = match rec.rec.faces.get(ub.face as usize)?.loops.get(ub.r#loop as usize)? {
Loop::Edges { edges } => edges.get(ub.position as usize)?.forward,
Loop::Vertex { .. } => return None,
};
let p = rec.point(v)?;
let along = rec.tangent(e, edge.vertices[0] != v)?;
let natural_b = rec.normal_at(ub.face as usize, p, accept)? * rec.side(ub.face as usize)?;
let into_b = natural_b.cross(if forward_b { along } else { along * -1.0 });
Some(into_b.dot(rec.normal_at(ua.face as usize, p, accept)?) < 0.0)
};
let mut k = 0;
while k < chain.len() {
let Some(&e) = chain.get(k) else { break };
k += 1;
let Some(edge) = rec.rec.edges.get(e) else { continue };
for v in edge.vertices {
let Some(d) = leaving(e, v) else { continue };
for (f, other) in rec.rec.edges.iter().enumerate() {
let passed_over = hidden.get(f).copied().unwrap_or(false);
if passed_over || chain.contains(&f) || other.uses.len() < 2 || !other.vertices.contains(&v) || smooth_join(rec, f) {
continue;
}
let turns_over = matches!((convex(e, v), convex(f, v)), (Some(a), Some(b)) if a != b);
if !turns_over && leaving(f, v).is_some_and(|g| d.dot(g) < -cos) {
chain.push(f);
}
}
}
}
chain
}
/// Before blending exactly `edges` (the record's edges `picks` took, in order): refuses an edge
/// whose faces meet tangentially (a smooth edge, nothing to round), and names the first edge a
/// picked one runs on into tangentially without being blended with it, if any (tangent
/// propagation off). SMLib blends the picked edges alone where it can end a blend there (a round
/// ending on the round it runs into); where it can't, [`with_continuation`] says why.
pub(crate) fn unfinished_chain(body: &Body, picks: &[Vec3], edges: &[usize], hidden: &[bool]) -> Result<Option<Vec3>> {
let rec = Faces::of(body)?;
let at = |i: usize| picks.get(i).map(|p| format!("({:.3}, {:.3}, {:.3})", p.x, p.y, p.z)).unwrap_or_default();
for (i, &e) in edges.iter().enumerate() {
if smooth_join(&rec, e) {
return Err(KernelError::Invalid(format!("the edge at {} is smooth: its faces meet tangentially, so there is nothing to round", at(i))));
}
}
let mut seeds: Vec<usize> = Vec::new();
for &e in edges {
if !seeds.contains(&e) {
seeds.push(e);
}
}
Ok(chain_of(&rec, &seeds, hidden).get(seeds.len()).and_then(|&next| edge_middle(&rec, next)))
}
/// A blend's failure where a picked edge continues tangentially into `next`, an edge left out
/// ([`unfinished_chain`]): SMLib rounds a tangent chain as one sequence and could not end the
/// blend there, so the reason and the way out are named.
pub(crate) fn with_continuation(e: KernelError, next: Option<Vec3>) -> KernelError {
let Some(p) = next else { return e };
let why = format!(
" (a picked edge continues tangentially into the edge at ({:.3}, {:.3}, {:.3}), which is not blended with it, and the blend \
cannot end there: with tangent propagation on, tangent_chain: true, its tangent chain is blended as one)",
p.x, p.y, p.z
);
match e {
KernelError::Invalid(m) => KernelError::Invalid(m + &why),
KernelError::Failed(m) => KernelError::Failed(m + &why),
KernelError::TooLarge(m) => KernelError::TooLarge(m + &why),
e => e,
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use solidcraft_geom::{Loop2, Plane, Region2, Vec2};
/// A round (`round`) or an equal-distance chamfer of the edges nearest `pts`.
fn blend(body: &Body, pts: &[Vec3], size: f64, round: bool) -> Result<Body> {
if round { fillet(body, pts, size) } else { chamfer(body, pts, size) }
}
fn vol(b: &Body) -> f64 {
b.mesh(&crate::MeshTolerance::chord(1e-4)).unwrap().measure().volume
}
/// Whether a vertex of `b` lies within `tol` of `p`.
fn has_vertex(b: &Body, p: Vec3, tol: f64) -> bool {
crate::native::brep_record(b).unwrap().vertices.iter().any(|v| v3(v.point).dist(p) < tol)
}
/// The ladder's 08-chamfers/008: a boss on a block, rounded where it meets the block, picked
/// at the top of its seam. The pick takes the top rim, and the chain keeps to it: it never
/// runs down the seam into the round's own seam, which continues it tangentially.
#[test]
fn a_chain_picked_where_a_seam_meets_a_rim_keeps_to_the_rim() {
let block = crate::build::box_solid(Vec3::ZERO, Vec3::new(40.0, 30.0, 20.0)).unwrap();
let boss = crate::build::cylinder(Vec3::new(15.0, 15.0, 20.0), Vec3::Z, 8.0, 10.0).unwrap();
let joined = crate::boolean(&block, &boss, crate::BoolOp::Union).unwrap().unwrap();
let rec = joined.record();
// The seam: the edge both of whose uses lie on the boss's side.
let seam = rec.edges.iter().find(|e| e.uses.len() == 2 && e.uses[0].face == e.uses[1].face).unwrap();
let ends = seam.vertices.map(|v| v3(rec.vertices[v as usize].point));
let (foot, top) = if ends[0].z < ends[1].z { (ends[0], ends[1]) } else { (ends[1], ends[0]) };
let rounded = fillet(&joined, &[foot], 1.0).unwrap();
let chain = tangent_chain(&rounded, &[top]).unwrap();
assert_eq!(chain, vec![top], "the chain left the top rim");
assert!(chamfer(&rounded, &chain, 1.0).is_ok());
// Even from a pick on the seam itself, the chain takes no seam: the round's continues
// the boss's tangentially but has no corner to blend.
let side = (top + Vec3::new(top.x, top.y, 21.0)) * 0.5;
assert_eq!(tangent_chain(&rounded, &[side]).unwrap(), vec![side], "the chain ran into the round's seam");
}
#[test]
fn g2_fillet_has_the_quintics_area() {
let body = crate::build::box_solid(Vec3::ZERO, Vec3::new(20.0, 20.0, 20.0)).unwrap();
let out = fillet_g2(&body, &[Vec3::new(20.0, 0.0, 10.0)], 2.0).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
assert_eq!(out.face_count(), body.face_count() + 1);
// Independent analytic area: integrating x(t) y'(t) for the quintic
// gives 113/756 times setback² for a right-angle corner.
let volume = out.mesh(&crate::MeshTolerance::chord(0.0001)).unwrap().measure().volume;
let expected = 8000.0 - (113.0 / 756.0) * 4.0 * 20.0;
assert!((volume - expected).abs() < 0.02, "{volume} vs {expected}");
}
#[test]
fn g2_fillet_handles_concave_edges_and_separate_edges() {
let lp = Loop2::polygon(&[
Vec2::new(0.0, 0.0),
Vec2::new(20.0, 0.0),
Vec2::new(20.0, 10.0),
Vec2::new(10.0, 10.0),
Vec2::new(10.0, 20.0),
Vec2::new(0.0, 20.0),
]);
let body = crate::build::extrude(&Plane::XY, &[Region2 { outer: lp, holes: vec![] }], 0.0, 20.0).unwrap().remove(0);
let out = fillet_g2(&body, &[Vec3::new(10.0, 10.0, 10.0)], 2.0).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
let volume = out.mesh(&crate::MeshTolerance::chord(0.0001)).unwrap().measure().volume;
let expected = 6000.0 + (113.0 / 756.0) * 4.0 * 20.0;
assert!((volume - expected).abs() < 0.02, "{volume} vs {expected}");
let body = crate::build::box_solid(Vec3::ZERO, Vec3::new(20.0, 20.0, 20.0)).unwrap();
let out = fillet_g2(&body, &[Vec3::new(20.0, 0.0, 10.0), Vec3::new(0.0, 20.0, 10.0)], 2.0).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
assert_eq!(out.face_count(), body.face_count() + 2);
}
#[test]
fn g2_fillet_refuses_sections_crossing_a_cap_hole() {
// The hole lies inside the setback without touching either side face.
let region = Region2 {
outer: Loop2::polygon(&[Vec2::ZERO, Vec2::new(20.0, 0.0), Vec2::new(20.0, 20.0), Vec2::new(0.0, 20.0)]),
holes: vec![Loop2::circle(Vec2::new(0.5, 0.5), 0.15)],
};
for plane in [Plane::XY, Plane::XZ] {
let body = crate::extrude(&plane, std::slice::from_ref(&region), 0.0, 20.0).unwrap().remove(0);
let pick = plane.to_world(Vec2::ZERO) + plane.normal() * 10.0;
assert_eq!(body.crossed_face_loops().unwrap(), 0);
let out = fillet_g2(&body, &[pick], 0.5).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
assert_eq!(out.crossed_face_loops().unwrap(), 0);
assert_eq!(out.face_count(), body.face_count() + 1);
assert!(fillet_g2(&body, &[pick], 2.0).is_err());
}
}
#[test]
fn g2_fillet_meets_sloped_planar_ends() {
// Inward and outward sloping ends, and one square end, in two orientations (#2708).
for plane in [Plane::XY, Plane::XZ] {
for (left, right) in [(-0.5, -0.5), (0.5, 0.5), (0.0, 0.5), (-0.25, 0.5)] {
let region = Region2 {
outer: Loop2::polygon(&[Vec2::ZERO, Vec2::new(40.0, 0.0), Vec2::new(40.0 - right * 20.0, 20.0), Vec2::new(left * 20.0, 20.0)]),
holes: vec![],
};
let body = crate::extrude(&plane, &[region], 0.0, 20.0).unwrap().pop().unwrap();
let pick = plane.to_world(Vec2::new(20.0, 0.0)) + plane.normal() * 20.0;
let out = fillet_g2(&body, &[pick], 5.0).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
assert_eq!(out.crossed_face_loops().unwrap(), 0);
assert_eq!(out.face_count(), 7);
// Analytic volume: the removed section has area 113 r² / 756
// and first moment ∫y dA = 13711 r³ / 486486. Axial length is 40−(left+right)y.
let removed = 40.0 * 113.0 / 756.0 * 25.0 - (left + right) * 13711.0 / 486486.0 * 125.0;
let expected = 16000.0 - 4000.0 * (left + right) - removed;
let volume = out.mesh(&crate::MeshTolerance::chord(0.0001)).unwrap().measure().volume;
assert!((volume - expected).abs() < 0.05, "{volume} vs {expected}");
}
}
}
#[test]
fn g2_fillet_on_concave_edge_meets_caps_sloped_in_both_directions() {
let region = Region2 {
outer: Loop2::polygon(&[
Vec2::ZERO,
Vec2::new(20.0, 0.0),
Vec2::new(20.0, 10.0),
Vec2::new(10.0, 10.0),
Vec2::new(10.0, 20.0),
Vec2::new(0.0, 20.0),
]),
holes: vec![],
};
let body = crate::extrude(&Plane::XY, &[region], 0.0, 20.0).unwrap().pop().unwrap();
// z -> z + 0.3x + 0.4y tilts both caps while leaving the vertical edge
// and its side planes unchanged. This shear preserves volume.
let body = crate::transform_matrix(&body, [[1.0, 0.0, 0.3, 0.0], [0.0, 1.0, 0.4, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]).unwrap();
let out = fillet_g2(&body, &[Vec3::new(10.0, 10.0, 17.0)], 2.0).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
assert_eq!(out.crossed_face_loops().unwrap(), 0);
let volume = out.mesh(&crate::MeshTolerance::chord(0.0001)).unwrap().measure().volume;
let expected = 6000.0 + 113.0 / 756.0 * 4.0 * 20.0;
assert!((volume - expected).abs() < 0.02, "{volume} vs {expected}");
}
#[test]
fn g2_fillet_refuses_invalid_geometry() {
let body = crate::build::box_solid(Vec3::ZERO, Vec3::new(20.0, 20.0, 20.0)).unwrap();
let edge = [Vec3::new(20.0, 0.0, 10.0)];
for radius in [0.0, -1.0, f64::NAN, f64::INFINITY, 1e7] {
assert!(fillet_g2(&body, &edge, radius).is_err());
}
assert!(fillet_g2(&body, &[], 2.0).is_err());
assert!(fillet_g2(&body, &[Vec3::new(f64::NAN, 0.0, 0.0)], 2.0).is_err());
assert!(fillet_g2(&body, &[Vec3::new(1000.0, 0.0, 0.0)], 2.0).is_err());
// Wider than the faces (20), over their far edges, cliffs: cut as if they went on. The
// section is the quintic from 25 out on each face, its inner control points a third and
// two thirds of the way to the corner; it takes the region between it and the corner
// inside the 20 x 20 section (clipped polygon of the curve, 2e5 pieces), along 20.
let wide = fillet_g2(&body, &edge, 25.0).unwrap();
let v = crate::measure(&wide).unwrap().volume;
assert!((v - 6138.1606889014).abs() < 1e-6 * 6138.1606889014, "{v}");
assert!(wide.validity().is_empty());
}
/// A box with a cylinder joined across one side (#556): the bottom edge of that side runs
/// into the cylinder, which is curved where the edge ends.
fn box_and_boss() -> Body {
let b = crate::build::box_solid(Vec3::ZERO, Vec3::new(40.0, 40.0, 20.0)).unwrap();
let c = crate::build::cylinder(Vec3::new(40.0, 20.0, 0.0), Vec3::Z, 12.0, 40.0).unwrap();
crate::ops::boolean(&b, &c, crate::BoolOp::Union).unwrap().unwrap()
}
#[test]
fn a_blend_runs_into_a_cylinder_at_its_end() {
let body = box_and_boss();
let v0 = vol(&body);
// The edge (40, 0..8, 0) ends in the cylinder wall at y = 8.
let len = 20.0 - (144.0f64 - 0.0).sqrt();
for (round, size, area) in [(true, 0.5, (1.0 - std::f64::consts::PI / 4.0) * 0.25), (false, 0.5, 0.125)] {
let out = blend(&body, &[Vec3::new(40.0, 4.0, 0.0)], size, round).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
let removed = v0 - vol(&out);
// The section runs on a little past y = 8 under the cylinder wall.
assert!(removed > area * len * 0.99 && removed < area * (len + 0.02), "{removed} vs {}", area * len);
assert_eq!(out.face_count(), body.face_count() + 1);
}
}
#[test]
fn a_blend_ends_on_a_hole_wall() {
// A plate with a hole cutting through the middle of its top front edge: each piece of
// that edge ends on the hole's wall.
let plate = crate::build::box_solid(Vec3::ZERO, Vec3::new(40.0, 20.0, 10.0)).unwrap();
let hole = crate::build::cylinder(Vec3::new(20.0, 0.0, -1.0), Vec3::Z, 5.0, 12.0).unwrap();
let body = crate::ops::boolean(&plate, &hole, crate::BoolOp::Cut).unwrap().unwrap();
let v0 = vol(&body);
for (round, area) in [(true, (1.0 - std::f64::consts::PI / 4.0)), (false, 0.5)] {
let out = blend(&body, &[Vec3::new(5.0, 0.0, 10.0)], 1.0, round).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
let removed = v0 - vol(&out);
assert!(removed > area * 14.0 && removed < area * 15.2, "{removed}");
}
}
#[test]
fn a_chamfer_of_a_hole_corner_is_one_bevel() {
let plate = crate::build::box_solid(Vec3::ZERO, Vec3::new(40.0, 40.0, 10.0)).unwrap();
let pocket = crate::build::box_solid(Vec3::new(10.0, 10.0, -1.0), Vec3::new(30.0, 30.0, 12.0)).unwrap();
let body = crate::ops::boolean(&plate, &pocket, crate::BoolOp::Cut).unwrap().unwrap();
let v0 = vol(&body);
let one = chamfer(&body, &[Vec3::new(10.0, 10.0, 5.0)], 2.0).unwrap();
assert!(one.validity().is_empty(), "{:?}", one.validity());
assert_eq!(one.unmeshed_faces(), 0);
let added = vol(&one) - v0;
// The bevel fills the hole corner: a right triangle of legs 2 mm, times the 10 mm edge.
assert!(added > 19.0 && added < 21.0, "added {added}, want 20");
assert_eq!(one.face_count(), body.face_count() + 1, "one bevel face");
let corners = [Vec3::new(10.0, 10.0, 5.0), Vec3::new(30.0, 10.0, 5.0), Vec3::new(30.0, 30.0, 5.0), Vec3::new(10.0, 30.0, 5.0)];
let all = chamfer(&body, &corners, 2.0).unwrap();
assert!(all.validity().is_empty(), "{:?}", all.validity());
let added = vol(&all) - v0;
assert!(added > 76.0 && added < 84.0, "added {added}, want 80");
assert_eq!(all.face_count(), body.face_count() + 4, "one bevel face per corner");
}
#[test]
fn a_chamfer_ends_across_two_faces() {
// A plate's outline chamfered, then the mitre at a corner chamfered: its low end meets
// both side faces, and the chamfer plane cuts back the vertical edge between them.
let k = 5.0;
let b = crate::build::box_solid(Vec3::ZERO, Vec3::new(100.0, 50.0, 20.0)).unwrap();
let outline = [Vec3::new(50.0, 0.0, 20.0), Vec3::new(100.0, 25.0, 20.0), Vec3::new(50.0, 50.0, 20.0), Vec3::new(0.0, 25.0, 20.0)];
let c = chamfer(&b, &outline, k).unwrap();
let out = chamfer(&c, &[Vec3::new(k / 2.0, k / 2.0, 20.0 - k / 2.0)], 1.0).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
assert_eq!(out.lumps().unwrap().len(), 1);
assert_eq!(out.face_count(), c.face_count() + 1);
// About the triangle (sides 1 and 1 at 120°) along the mitre; its ends slant.
let removed = vol(&c) - vol(&out);
let along = 0.5 * 120f64.to_radians().sin() * k * 3f64.sqrt();
assert!(removed > along * 0.8 && removed < along * 1.2, "{removed} vs {along}");
}
#[test]
fn a_curved_edge_blend_ends_in_a_face_at_an_angle() {
// A groove of radius 8 along y with its axis 4 below the top: the arcs where it meets the
// front and back faces end in the top face at 60° to it.
let b = crate::build::box_solid(Vec3::ZERO, Vec3::new(40.0, 20.0, 20.0)).unwrap();
let c = crate::build::cylinder(Vec3::new(20.0, -1.0, 16.0), Vec3::Y, 8.0, 22.0).unwrap();
let body = crate::ops::boolean(&b, &c, crate::BoolOp::Cut).unwrap().unwrap();
let v0 = vol(&body);
for round in [true, false] {
let out = blend(&body, &[Vec3::new(20.0, 0.0, 8.0)], 0.5, round).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
// About the section along the arc (240°, at the section's distance from the axis).
let area = if round { (1.0 - std::f64::consts::PI / 4.0) * 0.25 } else { 0.125 };
let along = 8.2 * 240f64.to_radians();
let removed = v0 - vol(&out);
assert!(removed > area * along * 0.9 && removed < area * along * 1.1, "{removed} vs {}", area * along);
}
}
#[test]
fn a_blend_of_an_edge_running_into_a_rounded_corner_follows_it() {
// A box with one vertical edge rounded: a top edge meeting that round smoothly is blended
// with the round's top arc and the next top edge, as one smooth chain (its tangent chain,
// as the Fillet and Chamfer features ask for it).
let b = crate::build::box_solid(Vec3::ZERO, Vec3::new(40.0, 30.0, 20.0)).unwrap();
let rounded = fillet(&b, &[Vec3::new(40.0, 30.0, 10.0)], 5.0).unwrap();
let chain = tangent_chain(&rounded, &[Vec3::new(20.0, 30.0, 20.0)]).unwrap();
assert_eq!(chain.len(), 3, "the top edge, the round's top arc and the next top edge");
for round in [true, false] {
let out = blend(&rounded, &chain, 1.0, round).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
assert_eq!(out.face_count(), rounded.face_count() + 3);
}
}
#[test]
fn a_blend_ends_where_a_joined_boss_turns_back_round_its_end() {
// The box's top right edge runs into the cylinder at (40, 8, 20): the blend's end lies on
// the cylinder where the box was, now laid bare.
let body = box_and_boss();
let v0 = vol(&body);
for (round, area) in [(true, (1.0 - std::f64::consts::PI / 4.0) * 0.64), (false, 0.32)] {
let out = blend(&body, &[Vec3::new(40.0, 4.0, 20.0)], 0.8, round).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
assert_eq!(out.lumps().unwrap().len(), 1);
let removed = v0 - vol(&out);
assert!((removed - area * 8.0).abs() < area * 8.0 * 1e-3, "{removed} vs {}", area * 8.0);
}
}
#[test]
fn a_blend_along_a_boss_ends_on_the_box_side_beside_it() {
// The boss's bottom edge outside the box (a half circle) ends at the box's side, square to
// it: the side face takes the end section.
let body = box_and_boss();
let v0 = vol(&body);
for (round, area, c) in [
(true, (1.0 - std::f64::consts::PI / 4.0) * 0.64, 0.8 * (10.0 - 3.0 * std::f64::consts::PI) / (3.0 * (4.0 - std::f64::consts::PI))),
(false, 0.32, 0.8 / 3.0),
] {
// The half circle's tangent chain, as the Fillet and Chamfer features ask for it.
let out = blend(&body, &tangent_chain(&body, &[Vec3::new(52.0, 20.0, 0.0)]).unwrap(), 0.8, round).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
// Pappus: the section turned half round the axis at its centroid's radius.
let want = area * std::f64::consts::PI * (12.0 - c);
let removed = v0 - vol(&out);
assert!((removed - want).abs() < want * 2e-3, "{removed} vs {want}");
// The app's planned mesh must also close, with the same analytic removal.
let planned = crate::issue_851_tests::planned_volume(&body) - crate::issue_851_tests::planned_volume(&out);
assert!((planned - want).abs() < want * 2e-3, "display mesh: {planned} vs {want}");
}
}
#[test]
fn a_blend_ends_on_a_face_running_along_its_seam_twice() {
// #691: a pocket's floor edge along its straight wall ends on a boss's cylinder, which a
// STEP file gives as one face running along its seam edge twice.
let b = crate::build::box_solid(Vec3::new(-55.0, -20.0, -30.0), Vec3::new(55.0, 50.0, 0.0)).unwrap();
let boss = crate::build::cylinder(Vec3::new(55.0, 15.0, -50.0), Vec3::Z, 25.0, 50.0).unwrap();
let b = crate::ops::boolean(&b, &boss, crate::BoolOp::Union).unwrap().unwrap();
let pocket = crate::build::box_solid(Vec3::new(-45.0, -21.0, -15.0), Vec3::new(55.0, 10.0, 1.0)).unwrap();
let wall = crate::build::cylinder(Vec3::new(55.0, 15.0, -20.0), Vec3::Z, 25.0, 30.0).unwrap();
let pocket = crate::ops::boolean(&pocket, &wall, crate::BoolOp::Cut).unwrap().unwrap();
let made = crate::ops::boolean(&b, &pocket, crate::BoolOp::Cut).unwrap().unwrap();
let body = crate::step_import(&crate::step_export(&[&made], "test").unwrap()).unwrap().bodies.remove(0).body;
let rec = crate::native::brep_record(&body).unwrap();
let seam_twice = rec.faces.iter().flat_map(|f| f.loops.iter()).any(|l| match l {
Loop::Edges { edges } => edges.iter().enumerate().any(|(k, x)| edges.iter().skip(k + 1).any(|y| y.edge == x.edge)),
Loop::Vertex { .. } => false,
});
assert!(seam_twice);
let v0 = vol(&body);
// The edge runs from x = −45 to where the wall meets the cylinder, x = 55 − √(25² − 5²).
let len = 45.0 + 55.0 - (600f64).sqrt();
for (round, area) in [(true, 1.0 - std::f64::consts::PI / 4.0), (false, 0.5)] {
let out = blend(&body, &[Vec3::new(0.0, 10.0, -15.0)], 1.0, round).unwrap();
assert!(out.validity().is_empty(), "{:?}", out.validity());
// A concave edge: the blend adds material.
let added = vol(&out) - v0;
assert!((added - area * len).abs() < area * len * 0.01, "{added} vs {}", area * len);
}
}
#[test]
fn a_chamfer_meets_sloped_end_planes() {
for slope in [-0.5, 0.5] {
let region = Region2 {
outer: Loop2::polygon(&[Vec2::ZERO, Vec2::new(40.0, 0.0), Vec2::new(40.0 - slope * 20.0, 20.0), Vec2::new(slope * 20.0, 20.0)]),
holes: vec![],
};
let body = crate::extrude(&Plane::XY, &[region], 0.0, 20.0).unwrap().pop().unwrap();
let pick = [Vec3::new(20.0, 0.0, 20.0)];
let result = chamfer(&body, &pick, 2.0).unwrap();
let removed = 2.0 * (40.0 - 2.0 * slope * 2.0 / 3.0);
let actual = crate::measure(&body).unwrap().volume - crate::measure(&result).unwrap().volume;
assert!((actual - removed).abs() < 1e-6, "{actual} vs {removed}");
assert!(result.validity().is_empty());
// The new corner vertices lie on both original end planes.
for point in [Vec3::new(slope * 2.0, 2.0, 20.0), Vec3::new(40.0 - slope * 2.0, 2.0, 20.0)] {
assert!(has_vertex(&result, point, 1e-8));
}
// Past the faces (20 deep, 20 high), over their far edges, cliffs: cut as if the
// faces and the sloped end planes went on. The plane 25 back on each face takes, of
// the section, z >= y - 5 (y, z in [0, 20]), each line of it 40 - 2 slope y long
// between the end planes: 11500 - 4625 slope.
let past = chamfer(&body, &pick, 25.0).unwrap();
let removed = 11500.0 - 4625.0 * slope;
let actual = crate::measure(&body).unwrap().volume - crate::measure(&past).unwrap().volume;
assert!((actual - removed).abs() < 1e-6 * removed, "{actual} vs {removed}");
assert!(past.validity().is_empty());
// A fillet ends in each sloped end plane along an ellipse: the removed section's
// length is taken at its centroid, c from the edge.
let rounded = fillet(&body, &pick, 2.0).unwrap();
let (area, c) =
((1.0 - std::f64::consts::PI / 4.0) * 4.0, 2.0 * (10.0 - 3.0 * std::f64::consts::PI) / (3.0 * (4.0 - std::f64::consts::PI)));
let removed = area * (40.0 - 2.0 * slope * c);
let actual = crate::measure(&body).unwrap().volume - crate::measure(&rounded).unwrap().volume;
assert!((actual - removed).abs() < 1e-3 * removed, "{actual} vs {removed}");
assert!(rounded.validity().is_empty());
}
}
/// A pin standing in a socket, 3.5 mm from two of its walls, in a large block. The cutters
/// for its tip reach several times the chamfer's size past each edge (more on a larger part),
/// into the walls, and their union took bites out of them: 7.2 mm³ instead of the tip's.
/// A cutter whose far corners are in the material is not used; the tip alone is chamfered.
#[test]
fn chamfering_a_pin_in_a_socket_leaves_the_socket_walls() {
let block = crate::build::box_solid(Vec3::new(0.0, 0.0, -135.0), Vec3::new(82.0, 41.0, 19.0)).unwrap();
let socket = crate::build::box_solid(Vec3::new(6.0, 11.5, 0.0), Vec3::new(21.0, 35.5, 25.0)).unwrap();
let pin = crate::build::box_solid(Vec3::new(9.5, 30.5, -1.0), Vec3::new(12.5, 32.0, 10.0)).unwrap();
let cut = crate::boolean(&block, &socket, crate::BoolOp::Cut).unwrap().unwrap();
let body = crate::boolean(&cut, &pin, crate::BoolOp::Union).unwrap().unwrap();
let tip = [Vec3::new(11.0, 30.5, 10.0), Vec3::new(9.5, 31.25, 10.0), Vec3::new(11.0, 32.0, 10.0), Vec3::new(12.5, 31.25, 10.0)];
let d = 0.5;
let out = chamfer(&body, &tip, d).unwrap();
// Four wedges along the tip's edges, less the four corner pyramids each pair shares.
let removed = 0.5 * d * d * 2.0 * (3.0 + 1.5) - 4.0 * d * d * d / 3.0;
let actual = crate::measure(&body).unwrap().volume - crate::measure(&out).unwrap().volume;
assert!((actual - removed).abs() < 1e-3, "{actual} vs {removed}");
assert_eq!(out.face_count(), body.face_count() + 4);
assert!(out.validity().is_empty(), "{:?}", out.validity());
}
}
#[cfg(test)]
#[path = "curvecorner_tests.rs"]
mod corner_tests;