0448d3126f
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - 229739a70 jyviko: Blends: a smooth edge and an unfinished tangent chain are refused saying why; SMLib's unsupported corner is named - 0ec97c570 jyviko: Blends: tangent propagation off blends the picked edges alone; a refusal says how to change it - 94d763c83 jyviko: Tests: a round run on through an earlier one by tangent propagation is matched by the same edges together - a0eaceab5 jyviko: SMLib tests: a round larger than the cube is cut as if its faces went on, at its exact volume Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
421 lines
22 KiB
Rust
421 lines
22 KiB
Rust
//! 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}");
|
||
}
|
||
// A round larger than the cube overflows its faces' far edges, convex, so it is cut as if the
|
||
// faces went on: the r50 cylinder about y = z = -30 uses up both faces of the edge and leaves
|
||
// the part of the cube's 20 x 20 section inside it, from (0, 10) to (10, 0), along x: 20 x
|
||
// that area, 20 (F(40) - F(30) - 300) with F(u) = (u sqrt(2500 - u^2) + 2500 asin(u / 50)) / 2.
|
||
let over = c.fillet(&mid, 0.1, 50.0).unwrap();
|
||
let f = |u: f64| 0.5 * (u * (2500.0 - u * u).sqrt() + 2500.0 * (u / 50.0).asin());
|
||
let want = 20.0 * (f(40.0) - f(30.0) - 300.0);
|
||
assert!((volume(&over) - want).abs() < 1e-6 * want, "radius larger than the cube: {} vs {want}", volume(&over));
|
||
assert_eq!(over.counts().unwrap(), [5, 9, 6], "the two ends, the two far faces and the round");
|
||
// 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(¬ch, 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]);
|
||
}
|
||
|
||
/// The corner of r5 rounds at (60, 40, 20) on a 60 x 40 x 20 box, set back 8 and left open: the
|
||
/// box's six faces and the three rounds (9 faces, 30 edges, 22 vertices), a sheet SMLib's check
|
||
/// passes, and one hole of twelve edges (each section and face curve in two), chained end to
|
||
/// start, each bounding a different face than the patch's neighbours across it.
|
||
#[test]
|
||
fn a_setback_corner_left_open_returns_its_hole() {
|
||
let b = Brep::make_box([0.0; 3], [60.0, 40.0, 20.0]).unwrap();
|
||
let edges = [[30.0, 40.0, 20.0], [60.0, 20.0, 20.0], [60.0, 40.0, 10.0]];
|
||
solidcraft_profile::set_enabled(true);
|
||
let mark = solidcraft_profile::mark();
|
||
let (open, holes) = b.blend_setback_open(Blend::Round, &edges, &[5.0; 3], &[[60.0, 40.0, 20.0]], &[8.0], 0.1).unwrap();
|
||
// The call is a profiler span like every other, timed by the C API.
|
||
let report = mark.report();
|
||
assert!(report.rows.iter().any(|r| r.category == "smlib" && r.name == "smlib_blend_setback_open"), "{report:?}");
|
||
shot(&open, "setback_open");
|
||
assert_eq!(open.counts().unwrap(), [9, 30, 22]);
|
||
assert!(!open.is_manifold_solid().unwrap());
|
||
let [hole] = holes.as_slice() else { panic!("one corner: {holes:?}") };
|
||
assert_eq!(hole.edges.len(), 12);
|
||
let flat = open.export().unwrap();
|
||
let ends = flat.get_i64(crate::flat::EDGE_VERTICES).unwrap();
|
||
let end = |h: &HoleEdge, last: bool| ends[2 * h.edge + usize::from(h.forward == last)];
|
||
for (k, h) in hole.edges.iter().enumerate() {
|
||
let next = &hole.edges[(k + 1) % 12];
|
||
assert_eq!(end(h, true), end(next, false), "edge {k} ends where the next starts");
|
||
assert!(h.face < 9);
|
||
}
|
||
// A corner where an edge is not rounded builds no setback, and the refusal names it.
|
||
let refused = b.blend_setback_open(Blend::Round, &edges[..2], &[5.0; 2], &[[60.0, 40.0, 20.0]], &[8.0], 0.1);
|
||
assert!(matches!(refused, Err(Error::CornerRefused { corner: 0 })), "{refused:?}");
|
||
let refused = b.blend_setback(Blend::Round, &edges[..2], &[5.0; 2], &[[60.0, 40.0, 20.0]], &[8.0], 0.1);
|
||
assert!(matches!(refused, Err(Error::CornerRefused { corner: 0 })), "{refused:?}");
|
||
}
|