Wave 237/509: kernel, kernel-cases: a convex blend overflowing a cliff is built, with its analytic answer (and 3 more)

4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop.

- 237f0ae74 jyviko: kernel, kernel-cases: a convex blend overflowing a cliff is built, with its analytic answer
- 7d300984b jyviko: kernel, kernel-cases: a shell whose walls would meet is refused, saying so
- 3be6ad433 jyviko: kernel: a tangent chain stops where the edges' convexity flips
- 098fac037 jyviko: geom: a face's loops lie in one turn of its periodic surface

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
jyviko
2026-10-25 19:51:02 -04:00
parent 2c2f2e5140
commit a5fc58bfed
14 changed files with 205 additions and 44 deletions
+26 -3
View File
@@ -319,12 +319,18 @@ const EXTENT_POINTS: usize = 32;
/// The parameter box of a face on `label` over its boundary: each loop's points (`loops`, in
/// order along each loop) projected onto the label, a periodic parameter unwrapped from one point
/// to the next. What the face's NURBS form ([`surface`]) is built over; no pcurve is involved.
/// to the next, and each loop after the first a whole number of periods along where that keeps
/// the box smallest. What the face's NURBS form ([`surface`]) is built over; no pcurve is
/// involved.
pub fn extent(label: &Surface, loops: &[Vec<(&Curve, [f64; 2], bool)>]) -> Option<[[f64; 2]; 2]> {
let eval = super::eval::SurfaceEval::new(label).ok()?;
let period = eval.domain().period;
let (mut lo, mut hi) = ([f64::INFINITY; 2], [f64::NEG_INFINITY; 2]);
for l in loops {
// A loop is unwrapped from its own first point, so it can come out whole periods away
// from the loops before it (a hole beside the seam projects to the seam's other side),
// and a box over both is more than a turn wide.
let (mut l_lo, mut l_hi) = ([f64::INFINITY; 2], [f64::NEG_INFINITY; 2]);
let mut prev: Option<[f64; 2]> = None;
for (c, [t0, t1], forward) in l {
let curve = super::eval::CurveEval::new(c).ok()?;
@@ -343,8 +349,8 @@ pub fn extent(label: &Surface, loops: &[Vec<(&Curve, [f64; 2], bool)>]) -> Optio
let pole = eval.pole(q);
for d in 0..2 {
if !pole.get(d).copied().unwrap_or(false) {
lo[d] = lo[d].min(q[d]);
hi[d] = hi[d].max(q[d]);
l_lo[d] = l_lo[d].min(q[d]);
l_hi[d] = l_hi[d].max(q[d]);
}
}
if !pole.iter().any(|p| *p) {
@@ -352,6 +358,23 @@ pub fn extent(label: &Surface, loops: &[Vec<(&Curve, [f64; 2], bool)>]) -> Optio
}
}
}
for d in 0..2 {
if !(l_lo[d] <= l_hi[d]) {
continue;
}
let shift = match period.get(d) {
Some(Some(per)) if lo[d] <= hi[d] => {
// The whole periods around the ones that bring the loop's middle to the box's,
// the one giving the smallest box.
let k = ((lo[d] + hi[d] - l_lo[d] - l_hi[d]) / (2.0 * per)).round();
let span = |k: f64| hi[d].max(l_hi[d] + k * per) - lo[d].min(l_lo[d] + k * per);
[k, k - 1.0, k + 1.0].into_iter().min_by(|a, b| span(*a).total_cmp(&span(*b))).unwrap_or(k) * per
}
_ => 0.0,
};
lo[d] = lo[d].min(l_lo[d] + shift);
hi[d] = hi[d].max(l_hi[d] + shift);
}
}
// At most one turn round a periodic direction; a boundary that never goes round it (a face
// bounded by its seam alone) covers the whole turn from there.
+27
View File
@@ -802,3 +802,30 @@ fn analytic_records_are_unbounded_with_independent_frames() {
assert!(radius(f64::NAN).is_err());
assert!(surface(&Surface::Torus { frame: a_frame(), major_radius: 1., minor_radius: 2. }, 0, &mut Budget(0)).is_err());
}
/// A cylinder face round its axis with a hole beside its seam: the seam at 350 degrees (so its
/// loop projects from 350 degrees on), the hole at 15..25 degrees (which on its own projects a
/// turn below). The face's box is the outer loop's turn with the hole in it; the hole's own
/// placement made a box from 15 degrees that cut the turn short and left the seam outside it
/// (#4598: a bored rod read back with its bore's pcurve a period off its face).
#[test]
fn a_hole_beside_the_seam_lies_in_its_face_turn() {
let (r, h) = (20.0f64, 60.0);
let cylinder = Surface::Cylinder { frame: Frame { origin: [0.; 3], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] }, radius: r };
let s = -10f64.to_radians();
let at = |a: f64, z: f64| [r * a.cos(), r * a.sin(), z];
let ring = |z: f64| Curve::Circle { frame: Frame { origin: [0., 0., z], x_axis: [s.cos(), s.sin(), 0.], y_axis: [-s.sin(), s.cos(), 0.] }, radius: r };
let (bottom, top) = (ring(0.), ring(h));
let seam = Curve::Line { start: at(s, 0.), end: at(s, h) };
let (a0, a1) = (15f64.to_radians(), 25f64.to_radians());
let hole =
Curve::Spline { knots: vec![0., 0., 1., 2., 3., 4., 4.], points: vec![at(a0, 25.), at(a1, 25.), at(a1, 35.), at(a0, 35.), at(a0, 25.)] };
let outer = vec![(&bottom, [0., TAU], true), (&seam, [0., 1.], true), (&top, [0., TAU], false), (&seam, [0., 1.], false)];
let inner = vec![(&hole, [0., 4.], true)];
let [u, v] = form::extent(&cylinder, &[outer, inner]).expect("an extent");
assert!((u[1] - u[0] - TAU).abs() < 1e-9, "one turn: {u:?}");
assert!((u[0].rem_euclid(TAU) - s.rem_euclid(TAU)).abs() < 1e-9, "from the seam: {u:?}");
let hole_u = a0 + ((u[0] - a0) / TAU).ceil() * TAU;
assert!(hole_u > u[0] && hole_u + (a1 - a0) < u[1], "the hole in the turn: {u:?}");
assert!(v[0].abs() < 1e-9 && (v[1] - h).abs() < 1e-9, "{v:?}");
}
+40 -4
View File
@@ -388,7 +388,10 @@ pub fn chamfer_sides(body: &Body, edges: &[Vec3], d1: f64, side: ChamferSide, fl
/// 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. Picks that find no edge are refused.
/// 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>> {
/// Edges meeting at an angle below this continue one another.
const TANGENT_DEGREES: f64 = 0.5;
@@ -423,6 +426,23 @@ pub fn tangent_chain(body: &Body, picks: &[Vec3]) -> Result<Vec<Vec3>> {
_ => false,
}
};
// 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 };
@@ -435,7 +455,8 @@ pub fn tangent_chain(body: &Body, picks: &[Vec3]) -> Result<Vec<Vec3>> {
if passed_over || chain.contains(&f) || other.uses.len() < 2 || !other.vertices.contains(&v) || smooth(f) {
continue;
}
if leaving(f, v).is_some_and(|g| d.dot(g) < -cos) {
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);
}
}
@@ -610,7 +631,14 @@ mod tests {
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());
assert!(fillet_g2(&body, &edge, 25.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
@@ -813,7 +841,15 @@ mod tests {
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));
}
assert!(chamfer(&body, &pick, 25.0).is_err());
// 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();
+19 -4
View File
@@ -557,8 +557,17 @@ mod tests {
let g = fillet_variable(&b, Vec3::new(10.0, 10.0, 30.0), Vec3::new(10.0, 0.0, 30.0), 3.0, 3.0).unwrap();
let k = crate::fillet(&b, &[Vec3::new(10.0, 10.0, 30.0)], 3.0).unwrap();
assert!(rel(measure(&g).unwrap().volume, measure(&k).unwrap().volume) < 1e-6);
// Too big for the faces: refused.
assert!(fillet_variable(&b, Vec3::new(10.0, 10.0, 30.0), Vec3::new(10.0, 0.0, 30.0), 2.0, 50.0).is_err());
// Wider than the faces: past r = 10 the contact on the top leaves it across its far edge
// x = 0 (past r = 30 the one on the side across its bottom), cliffs. The round is built as
// if the faces went on, and what it removes is cut from the box: at each y the section of
// the r x r square at the edge less the quarter disc about (10 - r, 30 - r), inside
// [0, 10] x [0, 30], in closed form (a, b from the disc's centre: a, b in [0, r],
// a^2 + b^2 >= r^2, a >= r - 10, b >= r - 30), integrated along y by Gauss-Legendre
// between the kinks at r = 10 and 30: 2453.81232061 removed, 3546.18767939 left (to 1e-4,
// as the variable rounds above).
let w = fillet_variable(&b, Vec3::new(10.0, 10.0, 30.0), Vec3::new(10.0, 0.0, 30.0), 2.0, 50.0).unwrap();
let vw = measure(&w).unwrap().volume;
assert!(rel(vw, 3546.1876793935) < 1e-4, "{vw} vs 3546.1876793935");
}
/// A radius through a middle point: straight pieces (exact: each piece removes
@@ -704,9 +713,15 @@ mod tests {
assert!(fillet_variable_spline(&b, at, start, &unclamped).is_err());
let dips = RadiusSpline { radii: vec![2.0, 0.0, 0.0, 3.0, 2.0], ..law.clone() };
assert!(fillet_variable_spline(&b, at, start, &dips).is_err());
// A middle radius beyond the faces: too large.
// A middle radius beyond the faces (up to 21.25 on the top 10 wide): the contact on the top
// leaves it across its far edge, a cliff, and the round is cut as if the top went on: at
// each y the r x r square at the edge less the quarter disc about (10 - r, 30 - r), inside
// [0, 10] x [0, 30], in closed form, integrated along y (Gauss-Legendre, split at the
// knot and where r crosses 10): 726.5334566720 removed.
let big = RadiusSpline { radii: vec![2.0, 2.0, 40.0, 3.0, 2.0], ..law };
assert!(matches!(fillet_variable_spline(&b, at, start, &big), Err(KernelError::TooLarge(_))));
let wide = fillet_variable_spline(&b, at, start, &big).unwrap();
let vw = fine_volume(&wide);
assert!(rel(vw, 6000.0 - 726.5334566720) < 1e-4, "{vw} vs {}", 6000.0 - 726.5334566720);
}
#[test]
+1 -1
View File
@@ -58,6 +58,6 @@ pub(crate) fn heal(body: &Body, keep: &[Vec<Vec3>]) -> Result<Body> {
}
}
let tolerance = record.tolerance * 10.0;
let (healed, history) = crate::offset_backend::run("healing", body, |b| b.merge_faces(&kept, tolerance))?;
let (healed, history) = crate::offset_backend::run("healing", body, None, |b| b.merge_faces(&kept, tolerance))?;
Ok(healed.with_checked_history(history, &crate::record::counts(&[body])).with_split_lines(body.splits.clone()))
}
+11
View File
@@ -552,6 +552,17 @@ mod smlib {
verified(&r, &plate, reach(2.5 * 1.5));
}
/// A 40 x 40 x 10 plate with an r2 hole 3 from its side, shelled 1.5 open at the top: the
/// hole's offset just reaches the side's, so the walls would meet along a line. Refused,
/// saying so and with the wall, never as SMLib's bare status.
#[test]
fn a_shell_whose_walls_would_meet_is_refused_saying_so() {
let hole = Loop2::circle(Vec2::new(5.0, 20.0), 2.0);
let plate = extrude(&Plane::XY, &[Region2 { outer: square(0.0, 0.0, 40.0, 40.0), holes: vec![hole] }], 0.0, 10.0).unwrap().pop().unwrap();
let e = offset_backend::shell(&plate, &[Vec3::new(35.0, 20.0, 10.0)], 1.5).unwrap_err().to_string();
assert!(e.contains("the 1.5 mm walls would meet along a line"), "{e}");
}
#[test]
fn offset_moves_a_face() {
let b = ell();
+24 -9
View File
@@ -26,10 +26,19 @@ fn failed(op: &str, what: &str, e: impl std::fmt::Display) -> KernelError {
KernelError::Failed(format!("SMLib {op}: {what}: {e}"))
}
/// The error for SMLib's refusal of `op`, in the words of the operation.
fn refused(op: &str, e: SmError) -> KernelError {
/// The error for SMLib's refusal of `op`, in the words of the operation; `wall` is its wall's
/// thickness, where it has one.
fn refused(op: &str, wall: Option<f64>, e: SmError) -> KernelError {
match e {
SmError::NoRoom => KernelError::Invalid(format!("{op}: the wall is too thick: it leaves no room inside the body")),
// The walls just meet: thinner they stay apart, thicker they cross and merge.
SmError::WallsTouch => {
let wall = wall.map(|t| format!(" {t} mm")).unwrap_or_default();
KernelError::Invalid(format!(
"{op}: the{wall} walls would meet along a line (between a hole and the side, for example), which leaves no solid there; \
use a thinner or thicker wall, or move the feature"
))
}
SmError::NoMatch { point } => KernelError::Invalid(format!("{op}: no face at selection point {}", point + 1)),
SmError::Ambiguous { point } => KernelError::Invalid(format!("{op}: selection point {} is as near to two faces", point + 1)),
SmError::Unsupported => KernelError::Failed(format!("not supported yet: SMLib {op} for this geometry")),
@@ -48,12 +57,18 @@ fn points(p: &[Vec3]) -> Vec<[f64; 3]> {
}
/// Runs `op` on `b` in SMLib, tagged as operand 0, and brings the result back with SMLib's
/// history over `[b]` (none where an order cannot be matched).
pub(crate) fn run(name: &str, b: &Body, op: impl FnOnce(&Brep) -> std::result::Result<Brep, SmError>) -> Result<(Body, Option<History>)> {
/// history over `[b]` (none where an order cannot be matched). `wall`: the operation's wall
/// thickness, for its refusals.
pub(crate) fn run(
name: &str,
b: &Body,
wall: Option<f64>,
op: impl FnOnce(&Brep) -> std::result::Result<Brep, SmError>,
) -> Result<(Body, Option<History>)> {
b.require_brep(name)?;
let (sb, ob) = smlib_body_ordered(b)?;
let tagged = sb.tagged(0).map_err(|e| failed(name, "tag", e))?;
let r = op(&tagged).map_err(|e| refused(name, e))?;
let r = op(&tagged).map_err(|e| refused(name, wall, e))?;
let check = r.check(CheckLevel::All).map_err(|e| failed(name, "check", e))?;
if !check.is_valid() {
let input = sb.check(CheckLevel::All).is_ok_and(|c| !c.is_valid());
@@ -84,7 +99,7 @@ pub(crate) fn shell(b: &Body, open: &[Vec3], thickness: f64) -> Result<Body> {
let opened = crate::offset::with_same_surface(b, &picked);
let tol = pick_tolerance(b);
let pts = points(&face_points(b, &opened)?);
let (r, h) = run("shell", b, |s| s.shell(&pts, tol, -thickness))?;
let (r, h) = run("shell", b, Some(thickness), |s| s.shell(&pts, tol, -thickness))?;
let h = h.and_then(|h| with_offsets(&r, b, h, thickness));
Ok(r.with_checked_history(h, &record::counts(&[b])))
}
@@ -96,7 +111,7 @@ pub(crate) fn offset_faces(b: &Body, chosen: &[usize], distance: f64) -> Result<
let at = face_points(b, chosen)?;
let tol = pick_tolerance(b);
let pts = points(&at);
let (r, h) = run("offset faces", b, |s| s.offset_faces(&pts, tol, distance))?;
let (r, h) = run("offset faces", b, None, |s| s.offset_faces(&pts, tol, distance))?;
let h = h.map(|mut h| {
for f in &mut h.faces {
if f.change == Change::Kept && f.origins.iter().any(|o| matches!(o, FaceOrigin::Face { face, .. } if chosen.contains(face))) {
@@ -114,7 +129,7 @@ pub(crate) fn thicken(b: &Body, thickness: f64, symmetric: bool) -> Result<Body>
if !(thickness.is_finite() && thickness.abs() > 1e-9) {
return Err(KernelError::Invalid("thickness must be non-zero".into()));
}
let (r, h) = run("thicken", b, |s| s.thicken(thickness, symmetric))?;
let (r, h) = run("thicken", b, Some(thickness.abs()), |s| s.thicken(thickness, symmetric))?;
let step = if symmetric { thickness.abs() / 2.0 } else { thickness.abs() };
// The walls first, while the sheet's edges still carry their tags on both copies.
let h = h.map(with_edge_walls).and_then(|h| with_offsets(&r, b, h, step));
@@ -138,7 +153,7 @@ pub(crate) fn draft(b: &Body, at: &[Vec3], neutral: &solidcraft_geom::Plane, pul
let tol = pick_tolerance(b);
let pts = points(&face_points(b, &chosen)?);
let o = neutral.origin;
let (r, h) = run("draft", b, |s| s.draft(&pts, tol, [o.x, o.y, o.z], [normal.x, normal.y, normal.z], [pull.x, pull.y, pull.z], angle))?;
let (r, h) = run("draft", b, None, |s| s.draft(&pts, tol, [o.x, o.y, o.z], [normal.x, normal.y, normal.z], [pull.x, pull.y, pull.z], angle))?;
let h = h.map(|mut h| {
for f in &mut h.faces {
if f.change == Change::Kept && f.origins.iter().any(|o| matches!(o, FaceOrigin::Face { face, .. } if chosen.contains(face))) {
+11 -8
View File
@@ -396,16 +396,19 @@ fn fillet_max_each_reduces_only_where_the_radius_does_not_fit() {
.unwrap()
.unwrap();
let edges = [Vec3::new(21.0, 15.0, 30.0), Vec3::new(40.0, 0.0, 10.0)];
assert!(matches!(fillet(&body, &edges, 4.0), Err(KernelError::TooLarge(_))));
let (one, _) = fillet_max(&body, &edges, 4.0).unwrap();
// R4 on the fin's top edge runs over the fin's 2 mm top, past its far edge (a cliff): it is
// cut as if the top went on, so both edges take 4. The fin's section loses the 4 x 4 square
// at its edge less the quarter disc about (17, 26), inside the fin (x >= 19): 2 x 4 less the
// disc's part, in closed form; the corner's round (1 − π/4)·16 along 20.
let both = fillet(&body, &edges, 4.0).unwrap();
let (radii, b) = fillet_max_each(&body, &edges, 4.0).unwrap();
assert_eq!(radii.get(1), Some(&4.0), "{radii:?}");
let fin_r = radii.first().copied().unwrap();
assert!(fin_r < 4.0 && (fin_r - one).abs() < 1e-9, "{radii:?}, one radius {one}");
assert_eq!(radii, vec![4.0, 4.0], "{radii:?}");
assert!(b.validity().is_empty(), "{:?}", b.validity());
// Each round takes (1 − π/4)·r² along its edge: the fin's 30 long, the corner's 20.
let removed = (1.0 - PI / 4.0) * (fin_r * fin_r * 30.0 + 16.0 * 20.0);
assert!(rel(measure(&b).unwrap().volume, block + fin - removed) < 2e-4);
let disc = |a: f64| 0.5 * (a * (16.0 - a * a).max(0.0).sqrt() + 16.0 * (a / 4.0).asin());
let fin_section = 2.0 * 4.0 - (disc(4.0) - disc(2.0));
let removed = fin_section * 30.0 + (1.0 - PI / 4.0) * 16.0 * 20.0;
assert!(rel(measure(&both).unwrap().volume, block + fin - removed) < 1e-6, "{}", measure(&both).unwrap().volume);
assert!(rel(measure(&b).unwrap().volume, block + fin - removed) < 1e-6);
// The post's four edges limit each other: one radius, as `fillet_max`.
let post = box_solid(Vec3::new(14.0, 0.0, 0.0), Vec3::new(28.0, 6.0, 10.0)).unwrap();
let mids = [Vec3::new(14.0, 0.0, 5.0), Vec3::new(28.0, 0.0, 5.0), Vec3::new(14.0, 6.0, 5.0), Vec3::new(28.0, 6.0, 5.0)];
+1
View File
@@ -19,6 +19,7 @@ pub const ERR_NO_ROOM: i32 = -1103;
pub const ERR_NO_CUT: i32 = -1104;
pub const ERR_UNSUPPORTED: i32 = -1105;
pub const ERR_NO_EFFECT: i32 = -1107;
pub const ERR_WALLS_TOUCH: i32 = -1110;
pub const BOOLEAN_UNION: i32 = 0;
pub const BOOLEAN_SUBTRACT: i32 = 1;
+6
View File
@@ -52,6 +52,10 @@ pub enum Error {
/// No room for the operation: an inward offset (a shell's wall, faces moved in) leaves none
/// inside the body, or a blend is larger than the faces it rolls on allow.
NoRoom,
/// An offset whose walls would meet (a shell's): the offsets of two faces touch without
/// crossing, a hole's wall offset just reaching a side's, so the result would pinch to
/// nothing along a line. A thinner or a thicker wall builds.
WallsTouch,
/// SMLib cannot build this exactly yet (a variable radius whose law has a corner).
Unsupported,
/// SMLib reported success but the operation did nothing: a blend that made no face, a face
@@ -83,6 +87,7 @@ impl std::fmt::Display for Error {
Error::NoMatch { point } => write!(f, "selection point {} is not near any edge or face", point + 1),
Error::Ambiguous { point } => write!(f, "selection point {} is equally near to two edges or faces", point + 1),
Error::NoRoom => write!(f, "there is no room for it: an offset leaves none inside the body, or a blend is larger than its faces allow"),
Error::WallsTouch => write!(f, "the offset's walls would meet along a line, which leaves no solid there"),
Error::Unsupported => write!(f, "not supported yet: SMLib cannot build this exactly"),
Error::NoEffect => write!(f, "SMLib made no change: it reported success, but the operation did nothing"),
Error::NotExact => write!(f, "SMLib cannot build this exactly in the input's geometry"),
@@ -114,6 +119,7 @@ fn error(s: i32) -> Error {
ffi::ERR_EMPTY => Error::Empty,
ffi::ops::ERR_NOT_SOLID => Error::NotSolid,
ffi::ops::ERR_NO_ROOM => Error::NoRoom,
ffi::ops::ERR_WALLS_TOUCH => Error::WallsTouch,
ffi::ops::ERR_UNSUPPORTED => Error::Unsupported,
ffi::ops::ERR_NO_EFFECT => Error::NoEffect,
ffi::trim::ERR_NOT_EXACT => Error::NotExact,
+3 -1
View File
@@ -182,7 +182,9 @@ impl Brep {
/// Hollowed to a wall of `thickness` (negative: inside the original surface, positive:
/// outside), open at the faces nearest to `open_faces` (each within `tolerance`); none gives
/// a closed hollow body. An inward wall that leaves no room inside is [`Error::NoRoom`].
/// a closed hollow body. An inward wall that leaves no room inside is [`Error::NoRoom`]; one
/// whose walls would just meet (a hole exactly twice the wall from a side) is
/// [`Error::WallsTouch`].
pub fn shell(&self, open_faces: &[[f64; 3]], tolerance: f64, thickness: f64) -> Result<Brep> {
self.pick_op(ffi::ops::Pick::Shell, open_faces, tolerance, thickness, true)
}
+26 -5
View File
@@ -207,12 +207,15 @@ fn hostile_inputs_are_errors() {
assert_eq!(c.shell(&[[10.0, 10.0, 20.0]], 0.1, t).unwrap_err(), Error::Argument, "thickness {t}");
}
// Sizes SMLib cannot build fail as errors, whatever SMLib says.
for (what, r) in [("radius larger than the cube", c.fillet(&mid, 0.1, 50.0)), ("chamfer past the faces", c.chamfer(&mid, 0.1, 30.0))] {
match r {
Ok(b) => panic!("{what}: SMLib built a body of volume {:?}, counts {:?}", b.volume(ACC), b.counts()),
Err(e) => eprintln!("{what}: {e:?}"),
}
match c.fillet(&mid, 0.1, 50.0) {
Ok(b) => panic!("radius larger than the cube: SMLib built a body of volume {:?}, counts {:?}", b.volume(ACC), b.counts()),
Err(e) => eprintln!("radius larger than the cube: {e:?}"),
}
// A chamfer past the faces runs over their far edges, cliffs: it is cut as if the faces went
// on (the plane y + z = 10 through the setbacks 30 back from the edge y = z = 20), leaving the
// triangle y + z <= 10 of the cube's section along x: 50 x 20.
let past = c.chamfer(&mid, 0.1, 30.0).unwrap();
assert!((volume(&past) - 1000.0).abs() < 1e-6 * 1000.0, "{}", volume(&past));
// A wall with no room inside it never reaches SMLib's offset.
assert_eq!(c.shell(&[[10.0, 10.0, 20.0]], 0.1, -15.0).unwrap_err(), Error::NoRoom);
assert_eq!(c.offset_faces(&[[10.0, 10.0, 20.0]], 0.1, -20.0).unwrap_err(), Error::NoRoom);
@@ -220,6 +223,24 @@ fn hostile_inputs_are_errors() {
assert_untouched(&c, 8000.0, [6, 12, 8]);
}
/// Rig case shell/4711: a 60 x 40 x 10 block with an r3 through hole at (22.5, 7), 4 from the
/// front face, and a 10 x 10 notch on that edge, shelled 2 inward open at the bottom: the hole's
/// offset (r5) is tangent to the front's (y = 2), so the walls meet along a line and the offset
/// bounds no solid there. Refused as such; 1.5 (the walls apart) and 2.5 (crossing, merged)
/// build.
#[test]
fn a_shell_whose_walls_would_meet_is_refused_as_such() {
let block = Brep::make_box([0.0; 3], [60.0, 40.0, 10.0]).unwrap();
let pin = Brep::make_cylinder([22.5, 7.0, -5.0], 3.0, 20.0).unwrap();
let notch = Brep::make_box([25.0, -5.0, -5.0], [10.0, 10.0, 20.0]).unwrap();
let part = block.boolean(&pin, BooleanOp::Subtract).unwrap().unwrap().boolean(&notch, BooleanOp::Subtract).unwrap().unwrap();
let bottom = [[50.0, 30.0, 0.0]];
assert_eq!(part.shell(&bottom, 0.1, -2.0).unwrap_err(), Error::WallsTouch);
for t in [1.5, 2.5] {
shot(&part.shell(&bottom, 0.1, -t).unwrap(), &format!("shell-4711-{t}"));
}
}
#[test]
fn boolean_history_through_tagged_operands() {
// A slot across the top of the cube: the cube's 6 faces give 7 result faces (the top is cut
@@ -3,8 +3,9 @@
"tangency-labs/solidcraft#1080",
"tangency-labs/solidcraft#1124"
],
"what": "a 9 mm chamfer on the top front edge of a cube with square openings 5 mm in must be refused: it would cut through the rims of the openings",
"source": "invariants",
"method": "cube 20 with three orthogonal 10x10 through openings; the top face opening starts 5 mm from the front edge and the front opening 5 mm below the top edge, so a 9 mm setback runs past the face between the edge and the openings and the chamfer plane would cross the openings and leave slivers. The right answer is a clean refusal; nothing is built.",
"outcome": "refused"
}
"what": "a 9 mm chamfer on the top front edge of a cube with square openings 5 mm in runs past the 5 mm between the edge and the openings: built as if the faces went on over the openings, then cut by them (cliff overflow); it never bridges an opening",
"source": "analytic",
"method": "cube 20 less three orthogonal 10x10 through openings (cross): V0 = 4000. The chamfer plane takes, of the section, the triangle y + (20 - z) <= 9 (y >= 0, z <= 20), area 40.5, along x: 810; less its parts inside the openings: the x opening (y, z in [5, 15]) misses it (z >= 11 + y >= 16 there), the y opening (z in [5, 15], x in [5, 15]) holds y in [0, 4], z in [11 + y, 15]: area 8, times 10 = 80, the z opening (y in [5, 15], x in [5, 15]) holds y in [5, 9], z in [11 + y, 20]: area 8, times 10 = 80. V = 4000 - (810 - 160) = 3350.",
"body_count": 1,
"volume_mm3": 3350.0
}
@@ -2,9 +2,9 @@
"sources": [
"tangency-labs/solidcraft#4711"
],
"what": "a 2 mm shell, open at the bottom, of a 60x40x10 block whose r3 through hole breaks out into a 10x10 notch at its edge: truck took 75 s and failed ('boolean Cut: no result')",
"what": "a 2 mm shell, open at the bottom, of a 60x40x10 block with an r3 through hole 4 mm from its front face, beside a 10x10 notch at that edge: the walls from the hole and from the front would meet along a line, so the right answer is a refusal that says so (truck took 75 s and failed ('boolean Cut: no result'); SMLib refused it, but as 'status 1027')",
"source": "invariants",
"method": "every wall has room for 2 mm (the thinnest, between the hole and the block's side, is 4 mm), so the shell exists: one valid closed body with one shell, open at the bottom. The cavity's corners at the hole's break-out follow the offset surfaces, so the volume is not closed-form (the reporter's script)",
"body_count": 1,
"shells": 1
"method": "the hole (centre (22.5, 7), r3) is 7 - 3 = 4 mm from the front face y = 0, and two 2 mm walls take 4 = 2 x 2 mm: the hole wall's offset (r 3 + 2 = 5) is tangent to the front's (y = 2) at (22.5, 2), so the cavity pinches to zero thickness along the line x = 22.5, y = 2, which bounds no solid. A thinner wall leaves the walls apart, a thicker one makes them cross and merge; at exactly 2 mm the shell is refused, naming the cause. Expected message: \"shell: the 2 mm walls would meet along a line (between a hole and the side, for example), which leaves no solid there; use a thinner or thicker wall, or move the feature\".",
"outcome": "refused",
"refusal": "shell: the 2 mm walls would meet along a line (between a hole and the side, for example), which leaves no solid there; use a thinner or thicker wall, or move the feature"
}