Files
solidcraft/crates/smlib/src/ops_tests.rs
T
jyvikoandClaude Opus 5.5 7d300984b2 kernel, kernel-cases: a shell whose walls would meet is refused, saying so
Rig case shell/4711 (a 60 x 40 x 10 block, an r3 through hole at (22.5, 7), a 10 x 10 notch on
the front edge, shelled 2 open at the bottom) failed with "SMLib shell: operation: SMLib failed
(status 1027)". The hole is 4 = 2 x 2 from the front face: the hole wall's offset (r5) is tangent
to the front's at (22.5, 2), the walls meet along a line and the cavity would pinch to zero
thickness there, which is no solid. Refusing it is right; the refusal did not say why.

SMLib now refuses an offset whose walls would meet with its own status, SMLIB_ERR_WALLS_TOUCH
(-1110). The smlib crate reads it as Error::WallsTouch; the kernel's offset backend turns it into
a sentence with the wall, as blends turn NoRoom into one: "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". Thicker builds too (SMLib shells 4711 at 2.5, the walls
crossing and merging between the hole and the front), so the sentence offers both.

4711 expects that refusal and its message ("outcome": "refused", "refusal"), its "what" and
"method" saying why: the wall is 4 = 2 x 2, the walls meet along a line. Tests: the smlib crate
shells 4711 built from primitives (2 refused as WallsTouch, 1.5 and 2.5 valid), the kernel a
plate whose hole is 3 from its side at 1.5 (refused, with "the 1.5 mm walls would meet along a
line").

Results (run-sc.sh against SMLib a759622's code, which differs from the tree run only in
comments and docs; baseline 858f381fc-5448b9a): rig 410/447 (409
before; 4711 fail -> pass as the refusal, nothing else changed), ladder 109/116 (unchanged),
kernel lib 535 passed / 202 failed (one new test; the same failing set), smlib crate 53 / 2
(one new test; the same failing set).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0113gDVmStT5tCGKW9Fxgc5K
2026-10-27 02:28:52 -04:00

383 lines
20 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.
//! The operations against analytic volumes and topology counts (built with SMLib only). `SMLIB_OPS_SHOTS=<dir>` also
//! writes every result there as a native `.smb`, to render.
#![cfg(feature = "native")]
use super::*;
use crate::CheckLevel;
/// Relative accuracy of SMLib's volume integration in these tests.
const ACC: f64 = 1e-7;
fn cube(a: f64) -> Brep {
Brep::make_box([0.0; 3], [a; 3]).unwrap()
}
fn volume(b: &Brep) -> f64 {
b.volume(ACC).unwrap()
}
fn assert_close(got: f64, want: f64, rel: f64, what: &str) {
assert!((got - want).abs() <= rel * want.abs(), "{what}: {got} vs analytic {want} (rel {:.3e})", (got - want).abs() / want.abs());
}
/// SMLib's own check, every test, finds nothing wrong with `b`; then, when `SMLIB_OPS_SHOTS` is
/// set, `b` is written there as `<name>.smb`.
fn shot(b: &Brep, name: &str) {
let report = b.check(CheckLevel::All).unwrap();
assert!(report.is_valid(), "{name}: {} failed validity tests:\n{}", report.failures, report.text);
if let Some(dir) = std::env::var_os("SMLIB_OPS_SHOTS") {
let dir = std::path::PathBuf::from(dir);
std::fs::create_dir_all(&dir).unwrap();
b.write(&dir.join(format!("{name}.smb")), false).unwrap();
}
}
/// The midpoints of the 12 edges of the cube [0, a]³.
fn cube_edge_midpoints(a: f64) -> Vec<[f64; 3]> {
let h = a / 2.0;
let mut v = Vec::new();
for (p, q) in [(0.0, 0.0), (a, 0.0), (0.0, a), (a, a)] {
v.push([h, p, q]);
v.push([p, h, q]);
v.push([p, q, h]);
}
v
}
/// The inputs of an operation are left as they were.
fn assert_untouched(b: &Brep, vol: f64, counts: [usize; 3]) {
assert_close(volume(b), vol, 1e-9, "input volume");
assert_eq!(b.counts().unwrap(), counts, "input counts");
}
#[test]
fn union_of_overlapping_boxes() {
let a = cube(20.0);
let b = Brep::make_box([10.0, 5.0, 5.0], [20.0, 10.0, 10.0]).unwrap();
let u = a.boolean(&b, BooleanOp::Union).unwrap().unwrap();
shot(&u, "union");
// 20³ + 20·10·10 − the 10·10·10 overlap.
assert_close(volume(&u), 9000.0, 1e-9, "union volume");
// A's 6 faces (+x now with a hole) and B's 5 outside it; A's 12 edges, B's 8 outside and the
// 4 where B passes through +x; A's 8 vertices and B's 8 outside.
assert_eq!(u.counts().unwrap(), [11, 24, 16]);
assert_eq!(u.solid_count().unwrap(), 1);
assert_untouched(&a, 8000.0, [6, 12, 8]);
assert_untouched(&b, 2000.0, [6, 12, 8]);
}
#[test]
fn subtract_cuts_a_slot() {
let a = cube(20.0);
// A 10 mm wide, 10 mm deep slot across the top, from y = −1 to 21.
let tool = Brep::make_box([5.0, -1.0, 10.0], [10.0, 22.0, 15.0]).unwrap();
let s = a.boolean(&tool, BooleanOp::Subtract).unwrap().unwrap();
shot(&s, "subtract_slot");
assert_close(volume(&s), 8000.0 - 10.0 * 20.0 * 10.0, 1e-9, "slot volume");
// A prism over a U of 8 corners: 8 sides + 2 ends, 24 edges, 16 vertices.
assert_eq!(s.counts().unwrap(), [10, 24, 16]);
assert_eq!(s.solid_count().unwrap(), 1);
assert_untouched(&a, 8000.0, [6, 12, 8]);
}
#[test]
fn intersect_keeps_the_overlap() {
let a = cube(20.0);
let b = Brep::make_box([10.0, 5.0, 5.0], [20.0, 10.0, 10.0]).unwrap();
let i = a.boolean(&b, BooleanOp::Intersect).unwrap().unwrap();
shot(&i, "intersect");
assert_close(volume(&i), 1000.0, 1e-9, "intersection volume");
assert_eq!(i.counts().unwrap(), [6, 12, 8]);
}
#[test]
fn empty_and_split_boolean_results() {
let a = cube(10.0);
let far = Brep::make_box([50.0, 0.0, 0.0], [10.0, 10.0, 10.0]).unwrap();
assert!(a.boolean(&far, BooleanOp::Intersect).unwrap().is_none(), "disjoint intersection");
let big = Brep::make_box([-5.0; 3], [20.0; 3]).unwrap();
assert!(a.boolean(&big, BooleanOp::Subtract).unwrap().is_none(), "subtracting an enclosing body");
let two = a.boolean(&far, BooleanOp::Union).unwrap().unwrap();
shot(&two, "union_disjoint");
assert_eq!(two.solid_count().unwrap(), 2, "a union of disjoint boxes is two solids in one body");
assert_close(volume(&two), 2000.0, 1e-9, "disjoint union volume");
// A body through a slot splits in two.
let bar = cube(20.0);
let cut = Brep::make_box([8.0, -1.0, -1.0], [4.0, 22.0, 22.0]).unwrap();
let halves = bar.boolean(&cut, BooleanOp::Subtract).unwrap().unwrap();
shot(&halves, "subtract_split");
assert_eq!(halves.solid_count().unwrap(), 2);
assert_close(volume(&halves), 8000.0 - 4.0 * 400.0, 1e-9, "split volume");
}
#[test]
fn fillet_every_edge_of_a_cube() {
let (a, r) = (20.0, 2.0);
let c = cube(a);
let f = c.fillet(&cube_edge_midpoints(a), 0.1, r).unwrap();
shot(&f, "fillet_all_edges");
// The rounded cube is the Minkowski sum of the inner cube b = a − 2r with a ball of radius r:
// b³ (core) + 6·b²·r (face slabs) + 12·(π r²/4)·b (quarter cylinders on the edges)
// + 8·(π r³/6) (sphere octants at the corners) = 7804.6961… for a = 20, r = 2.
let b = a - 2.0 * r;
let pi = std::f64::consts::PI;
let want = b.powi(3) + 6.0 * b * b * r + 3.0 * pi * r * r * b + 4.0 / 3.0 * pi * r.powi(3);
let got = volume(&f);
eprintln!("filleted cube: volume {got} (analytic {want}), counts {:?}", f.counts().unwrap());
assert_close(got, want, 1e-6, "rounded cube volume");
// 6 planar faces, 12 edge rounds, 8 corner patches.
assert_eq!(f.counts().unwrap()[0], 26);
assert_untouched(&c, 8000.0, [6, 12, 8]);
}
#[test]
fn chamfer_one_edge() {
let c = cube(20.0);
// The edge y = 20, z = 20, set back 3 mm along both faces: a prism of 3·3/2 × 20 goes.
let ch = c.chamfer(&[[10.0, 20.0, 20.0]], 0.1, 3.0).unwrap();
shot(&ch, "chamfer_one_edge");
assert_close(volume(&ch), 8000.0 - 4.5 * 20.0, 1e-9, "chamfered volume");
// One face more; the edge becomes two edges joined by two new ones; 2 vertices more.
assert_eq!(ch.counts().unwrap(), [7, 15, 10]);
assert_untouched(&c, 8000.0, [6, 12, 8]);
}
#[test]
fn shell_a_box_open_at_the_top() {
let c = cube(20.0);
let top = [[10.0, 10.0, 20.0]];
let inward = c.shell(&top, 0.1, -2.0).unwrap();
shot(&inward, "shell_inward");
// The cavity is 16 × 16 × 18 (the floor is 2 thick, the top open).
assert_close(volume(&inward), 8000.0 - 16.0 * 16.0 * 18.0, 1e-9, "inward shell volume");
// Outside 5, inside 5, the rim 1.
assert_eq!(inward.counts().unwrap()[0], 11);
let outward = c.shell(&top, 0.1, 2.0).unwrap();
shot(&outward, "shell_outward");
// The outside grows to [−2, 22]² × [−2, 20] around the original box, which becomes the cavity.
assert_close(volume(&outward), 24.0 * 24.0 * 22.0 - 8000.0, 1e-9, "outward shell volume");
let closed = c.shell(&[], 0.1, -2.0).unwrap();
shot(&closed, "shell_closed");
assert_close(volume(&closed), 8000.0 - 16.0f64.powi(3), 1e-9, "closed hollow volume");
assert_untouched(&c, 8000.0, [6, 12, 8]);
}
#[test]
fn fillet_takes_exactly_the_picked_edges() {
// Round the vertical edge x = y = 20 first (r = 5): the top rim is then line, arc, line,
// meeting tangentially.
let c = cube(20.0);
let round = c.fillet(&[[20.0, 20.0, 10.0]], 0.1, 5.0).unwrap();
shot(&round, "fillet_one_edge");
let pi = std::f64::consts::PI;
assert_close(volume(&round), 8000.0 - (1.0 - pi / 4.0) * 25.0 * 20.0, 1e-6, "one rounded edge");
// One point on the straight part of the rim rounds that edge only; the chain is rounded when
// all of its edges are picked.
let one = round.fillet(&[[7.5, 20.0, 20.0]], 0.1, 1.0).unwrap();
shot(&one, "fillet_one_of_a_chain");
let arc = [15.0 + 5.0 * (pi / 4.0).cos(), 15.0 + 5.0 * (pi / 4.0).sin(), 20.0];
let all = round.fillet(&[[7.5, 20.0, 20.0], arc, [20.0, 7.5, 20.0]], 0.1, 1.0).unwrap();
shot(&all, "fillet_chain_picked");
assert_eq!(one.counts().unwrap()[0], round.counts().unwrap()[0] + 1, "one round on the picked edge");
assert_eq!(all.counts().unwrap()[0], round.counts().unwrap()[0] + 3, "three rounds on the chain");
assert!(volume(&all) < volume(&one), "the chain takes more than its one edge");
}
#[test]
fn hostile_inputs_are_errors() {
let c = cube(20.0);
let mid = [[10.0, 20.0, 20.0]];
for r in [f64::NAN, f64::INFINITY, -1.0, 0.0, 1e7] {
assert_eq!(c.fillet(&mid, 0.1, r).unwrap_err(), Error::Argument, "radius {r}");
assert_eq!(c.chamfer(&mid, 0.1, r).unwrap_err(), Error::Argument, "distance {r}");
}
for t in [f64::NAN, 0.0, -1.0, f64::INFINITY] {
assert_eq!(c.fillet(&mid, t, 1.0).unwrap_err(), Error::Argument, "tolerance {t}");
}
assert_eq!(c.fillet(&[[f64::NAN, 0.0, 0.0]], 0.1, 1.0).unwrap_err(), Error::Argument);
assert_eq!(c.fillet(&[], 0.1, 1.0).unwrap_err(), Error::Argument);
assert_eq!(c.fillet(&vec![[10.0, 20.0, 20.0]; MAX_POINTS + 1], 0.1, 1.0).unwrap_err(), Error::Argument);
// A second point far from every edge.
assert_eq!(c.fillet(&[mid[0], [100.0, 100.0, 100.0]], 0.1, 1.0).unwrap_err(), Error::NoMatch { point: 1 });
assert_eq!(c.shell(&[[10.0, 10.0, 25.0]], 0.1, -1.0).unwrap_err(), Error::NoMatch { point: 0 });
// A corner is equally near three edges, an edge equally near two faces.
assert_eq!(c.fillet(&[[20.0, 20.0, 20.0]], 0.1, 1.0).unwrap_err(), Error::Ambiguous { point: 0 });
assert_eq!(c.shell(&mid, 0.1, -1.0).unwrap_err(), Error::Ambiguous { point: 0 });
for t in [0.0, f64::NAN, -1e7] {
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.
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);
assert_eq!(c.thicken(1.0, false).unwrap_err(), Error::Argument, "a solid is no sheet");
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
// in two), the tool gives the slot's 2 walls and floor; no face is new.
let a = cube(20.0).tagged(0).unwrap();
let tool = Brep::make_box([5.0, -1.0, 10.0], [10.0, 22.0, 15.0]).unwrap().tagged(1).unwrap();
let s = a.boolean(&tool, BooleanOp::Subtract).unwrap().unwrap();
shot(&s, "subtract_slot_tagged");
let h = s.history().unwrap();
assert_eq!(h.faces.len(), 10);
let mut from = [0usize; 2];
for f in &h.faces {
assert!(!f.origins.is_empty(), "{f:?}");
for &(operand, _) in &f.origins {
from[operand.min(1)] += 1;
}
}
assert_eq!(from, [7, 3], "{h:?}");
// The 8 edges where the slot's walls and floor meet the top, front and back are new.
assert_eq!(h.edges.iter().filter(|e| e.origins.is_empty()).count(), 8, "{h:?}");
}
/// `blend` gives each picked edge its own size: two parallel top edges of a 20 mm cube rounded at
/// 2 and 3 lose (1 - pi/4) r^2 L each, chamfered r^2 L / 2 each; a chord of 2 sqrt 2 on a right
/// angle is the round of radius 2.
#[test]
fn blends_take_a_size_per_edge() {
let c = cube(20.0);
let tops = [[10.0, 20.0, 20.0], [10.0, 0.0, 20.0]];
let q = 1.0 - std::f64::consts::FRAC_PI_4;
let r = c.blend(Blend::Round, &tops, &[2.0, 3.0], 0.1).unwrap();
shot(&r, "blend-round-2-3");
assert_close(volume(&r), 8000.0 - q * 13.0 * 20.0, 1e-6, "rounds 2 and 3");
let ch = c.blend(Blend::Chamfer, &tops, &[2.0, 3.0], 0.1).unwrap();
shot(&ch, "blend-chamfer-2-3");
assert_close(volume(&ch), 8000.0 - 0.5 * 13.0 * 20.0, 1e-6, "chamfers 2 and 3");
let chord = c.blend(Blend::Chord, &tops[..1], &[2.0 * 2f64.sqrt()], 0.1).unwrap();
assert_close(volume(&chord), 8000.0 - q * 4.0 * 20.0, 2e-6, "chord");
assert!(c.blend(Blend::Round, &tops, &[2.0], 0.1).is_err());
}
/// A radius running linearly from 3 to 1 along a cube edge: (1 - pi/4) L (r0² + r0 r1 + r1²) / 3
/// taken away, whichever end is the start.
#[test]
fn a_variable_round_follows_its_law() {
let c = cube(20.0);
let q = 1.0 - std::f64::consts::FRAC_PI_4;
let knots = [0.0, 0.0, 1.0, 1.0];
let r = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 1, &knots, &[3.0, 1.0]).unwrap();
shot(&r, "variable-3-1");
assert_close(volume(&r), 8000.0 - q * 20.0 * 13.0 / 3.0, 1e-5, "linear law");
let back = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [20.0, 20.0, 20.0], 1, &knots, &[1.0, 3.0]).unwrap();
assert_close(volume(&back), volume(&r), 1e-7, "reversed");
assert!(c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 1, &[0.0, 0.5, 1.0, 1.0], &[3.0, 1.0]).is_err());
assert!(matches!(c.fillet_variable([90.0, 90.0, 90.0], 0.1, [0.0; 3], 1, &knots, &[3.0, 1.0]), Err(Error::NoMatch { .. })));
// A quadratic law with control radii 4, 1, 4: r(t) = 4(1 − t)² + 2t(1 − t) + 4t².
let law = |t: f64| 4.0 * (1.0 - t).powi(2) + 2.0 * t * (1.0 - t) + 4.0 * t * t;
let n = 4000;
let r2 = (0..n).map(|i| law((i as f64 + 0.5) / n as f64).powi(2)).sum::<f64>() / n as f64;
let quad = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 2, &[0.0, 0.0, 0.0, 1.0, 1.0, 1.0], &[4.0, 1.0, 4.0]).unwrap();
shot(&quad, "variable-quadratic");
assert_close(volume(&quad), 8000.0 - q * 20.0 * r2, 1e-5, "quadratic law");
// Down to zero at the far end: the round closes to the edge's end point.
let zero = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 1, &knots, &[4.0, 0.0]).unwrap();
shot(&zero, "variable-to-zero");
assert_close(volume(&zero), 8000.0 - q * 20.0 * 16.0 / 3.0, 1e-5, "down to zero");
// A law with a corner (4 → 2 → 4, straight on both halves): the round turns at the corner,
// each half taking away (1 - pi/4) (L / 2) (16 + 8 + 4) / 3; the same points joined smoothly
// (C1 cubic pieces, as RadiusSpline::through makes them) are built too.
let corner = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[4.0, 2.0, 4.0]).unwrap();
shot(&corner, "variable-corner-4-2-4");
assert_close(volume(&corner), 8000.0 - q * 20.0 * 28.0 / 3.0, 1e-6, "corner law");
// A law down to zero inside the edge would pinch the round to a point: refused.
let pinch = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[4.0, 0.0, 4.0]);
assert!(pinch.is_err(), "a law pinching to zero inside the edge");
let smooth_knots = [0.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 1.0, 1.0];
let smooth = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 3, &smooth_knots, &[4.0, 10.0 / 3.0, 2.0, 2.0, 2.0, 10.0 / 3.0, 4.0]);
shot(&smooth.unwrap(), "variable-smooth-4-2-4");
}
/// Unequal chamfers of a cube's top edge y = 20: 5 back along the face facing `first` most and 2
/// along the other take away a triangle 5 × 2 / 2 along the 20 mm edge, either way round; 5 at
/// 30° to the first face is 5 and 5 tan 30°.
#[test]
fn chamfers_with_two_setbacks() {
let c = cube(20.0);
let top = [[10.0, 20.0, 20.0]];
let up = c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Distance(2.0), [0.0, 0.0, 1.0]).unwrap();
shot(&up, "chamfer-5-2");
assert_close(volume(&up), 8000.0 - 5.0 * 20.0, 1e-9, "5 and 2");
let flipped = c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Distance(2.0), [0.0, 0.0, -1.0]).unwrap();
assert_close(volume(&flipped), volume(&up), 1e-9, "flipped");
// Which face took the 5: the removed prism's centroid lies a third of each setback in from
// the edge, so the result's centroid moves away from it.
let centroid = |b: &Brep| b.mass_properties(ACC).unwrap().centroid;
let left = |dy: f64, dz: f64| [10.0, (8000.0 * 10.0 - 100.0 * (20.0 - dy / 3.0)) / 7900.0, (8000.0 * 10.0 - 100.0 * (20.0 - dz / 3.0)) / 7900.0];
for (b, want, what) in [(&up, left(5.0, 2.0), "5 along the top"), (&flipped, left(2.0, 5.0), "5 down the side")] {
let got = centroid(b);
assert!((0..3).all(|i| (got[i] - want[i]).abs() < 1e-6), "{what}: centroid {got:?}, want {want:?}");
}
let angle = c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Angle(30f64.to_radians()), [0.0, 0.0, 1.0]).unwrap();
shot(&angle, "chamfer-5-at-30");
assert_close(volume(&angle), 8000.0 - 5.0 * 5.0 * 30f64.to_radians().tan() / 2.0 * 20.0, 1e-9, "5 at 30 degrees");
assert_eq!(c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Angle(4.0), [0.0, 0.0, 1.0]).unwrap_err(), Error::Argument);
assert_eq!(c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Distance(2.0), [0.0; 3]).unwrap_err(), Error::Argument);
assert_eq!(c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Distance(-2.0), [0.0, 0.0, 1.0]).unwrap_err(), Error::Argument);
}
#[test]
fn imprint_cuts_faces_where_a_tool_meets_them() {
// A box half sunk into the cube cuts the four side faces it crosses and the top it lies in.
let cube = cube(20.0);
let tool = Brep::make_box([5.0, -1.0, 10.0], [10.0, 22.0, 15.0]).unwrap();
let cut = cube.imprint(&tool).unwrap().unwrap();
assert!(cut.counts().unwrap()[0] > 6);
assert!((cut.volume(1e-7).unwrap() - 8000.0).abs() < 1e-6);
assert_eq!(cube.counts().unwrap()[0], 6);
// A tool that misses cuts nothing.
let far = Brep::make_box([50.0, 0.0, 0.0], [10.0, 10.0, 10.0]).unwrap();
assert!(cube.imprint(&far).unwrap().is_none());
}
#[test]
fn draft_tilts_a_side_about_its_line_on_the_neutral_plane() {
let c = cube(20.0);
let deg = std::f64::consts::PI / 180.0;
let wedge = 0.5 * 20.0 * 20.0 * (5.0 * deg).tan() * 20.0;
let side = [[20.0, 10.0, 10.0]];
let up = [0.0, 0.0, 1.0];
let leaned = c.draft(&side, 0.1, [0.0; 3], up, up, 5.0 * deg).unwrap();
assert!((leaned.volume(ACC).unwrap() - (8000.0 - wedge)).abs() < 1e-6);
let out = c.draft(&side, 0.1, [0.0; 3], up, up, -5.0 * deg).unwrap();
assert!((out.volume(ACC).unwrap() - (8000.0 + wedge)).abs() < 1e-6);
// The top isn't parallel to the pull.
assert_eq!(c.draft(&[[10.0, 10.0, 20.0]], 0.1, [0.0; 3], up, up, 5.0 * deg).unwrap_err(), Error::Unsupported);
assert_eq!(c.draft(&side, 0.1, [0.0; 3], up, up, 0.0).unwrap_err(), Error::Argument);
assert_eq!(c.draft(&[], 0.1, [0.0; 3], up, up, 5.0 * deg).unwrap_err(), Error::Argument);
assert_untouched(&c, 8000.0, [6, 12, 8]);
}