Files
solidcraft/crates/kernel/src/issue_1080_tests.rs
T

118 lines
6.4 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.
//! #1080: fillets and chamfers that would run past the faces beside their edge. A convex blend
//! running over a face's far edge into a pocket or a hole (a cliff) is built as if its faces went
//! on and what it removes is cut from the body, so it never bridges the opening (the owner's
//! blend-overflow decision, 237f0ae74); blends that would cross each other are refused as too
//! large, and the largest size that fits is found by searching ([`crate::fillet_max`],
//! [`crate::chamfer_max`]).
use solidcraft_geom::Vec3;
use crate::{Body, BoolOp, ChamferSide, KernelError, build::box_solid, ops::boolean};
fn cut(a: &Body, lo: [f64; 3], hi: [f64; 3]) -> Body {
let t = box_solid(Vec3::new(lo[0], lo[1], lo[2]), Vec3::new(hi[0], hi[1], hi[2])).unwrap();
boolean(a, &t, BoolOp::Cut).unwrap().unwrap()
}
/// A 40 × 20 × 20 block with a 10 × 10 pocket, 10 deep, 4 mm in from its top edge at x = 40.
fn pocketed() -> Body {
let b = box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(40.0, 20.0, 20.0)).unwrap();
cut(&b, [26.0, 5.0, 10.0], [36.0, 15.0, 20.0])
}
const EDGE: Vec3 = Vec3 { x: 40.0, y: 10.0, z: 20.0 };
fn too_large(r: crate::Result<Body>) -> String {
match r {
Err(KernelError::TooLarge(m)) => m,
Err(e) => panic!("refused, but not as too large: {e}"),
Ok(_) => panic!("a blend that runs into another was accepted"),
}
}
/// The pocketed block's volume: 16000 less the 1000 mm³ pocket.
const POCKETED: f64 = 15000.0;
/// The 6 mm chamfer runs 2 mm past the pocket's rim at x = 36: its triangle
/// (40 − x) + (20 − z) <= 6, area 18 along the 20 mm edge, less its part over the pocket
/// (x in [34, 36], z >= 54 − x: area 2, along the pocket's 10 mm), is cut away: 360 − 20.
#[test]
fn chamfer_into_a_pocket_is_cut_by_it() {
let p = pocketed();
let b = crate::chamfer(&p, &[EDGE], 6.0).unwrap();
assert!(b.validity().is_empty(), "{:?}", b.validity());
let v = crate::measure(&b).unwrap().volume;
assert!((v - (POCKETED - 340.0)).abs() < 1e-6, "{v}");
// Up to the pocket's rim it builds: the triangle along the 20 mm edge.
for s in [2.0, 4.0] {
let b = crate::chamfer(&p, &[EDGE], s).unwrap();
let v = b.volume_at(0.01).unwrap();
assert!((p.volume_at(0.01).unwrap() - v - 0.5 * s * s * 20.0).abs() < 1e-6, "{s}: {v}");
}
// Unequal sides, 6 along the top and 2 down the side: the triangle
// (40 − x) / 6 + (20 − z) / 2 <= 1, area 6 along 20, less its part over the pocket
// (x in [34, 36], a triangle 2 by 2/3), along 10: 120 − 20/3. The other way round it stays
// clear of the pocket: 120.
let b = crate::chamfer_sides(&p, &[EDGE], 6.0, ChamferSide::Distance(2.0), false).unwrap();
let v = crate::measure(&b).unwrap().volume;
assert!((v - (POCKETED - (120.0 - 20.0 / 3.0))).abs() < 1e-6, "{v}");
let b = crate::chamfer_sides(&p, &[EDGE], 2.0, ChamferSide::Distance(6.0), false).unwrap();
let v = crate::measure(&b).unwrap().volume;
assert!((v - (POCKETED - 120.0)).abs() < 1e-6, "{v}");
}
/// R5 runs 1 mm past the pocket's rim: the round's section (1 − π/4)·25 along 20, less its part
/// over the pocket, the square [35, 36] × [15, 20] outside the circle about (35, 15) of radius 5,
/// ∫₀¹ (5 − √(25 − t²)) dt = 5 − (√24 / 2 + (25/2)·asin(1/5)), along 10.
#[test]
fn fillet_into_a_pocket_is_cut_by_it_and_one_that_fits_builds() {
let p = pocketed();
let over = 5.0 - (24f64.sqrt() / 2.0 + 12.5 * (0.2f64).asin());
let want = POCKETED - ((1.0 - std::f64::consts::FRAC_PI_4) * 25.0 * 20.0 - over * 10.0);
let b = crate::fillet(&p, &[EDGE], 5.0).unwrap();
assert!(b.validity().is_empty(), "{:?}", b.validity());
let v = crate::measure(&b).unwrap().volume;
assert!((v - want).abs() < 1e-6 * want, "{v} vs {want}");
let b = crate::fillet(&p, &[EDGE], 3.0).unwrap();
assert!(b.validity().is_empty(), "{:?}", b.validity());
assert_eq!(b.face_count(), p.face_count() + 1);
}
/// A rib 4 mm wide: chamfers of its two top edges meet in the middle of its top face at 2 mm;
/// past that they would cross each other. Neither reaches the far side's face below 4 mm,
/// so only the two blends clash: refused as too large, and the largest that fits is 2 mm.
#[test]
fn chamfers_crossing_each_other_are_refused() {
let rib = box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(40.0, 4.0, 20.0)).unwrap();
let edges = [Vec3::new(20.0, 0.0, 20.0), Vec3::new(20.0, 4.0, 20.0)];
too_large(crate::chamfer(&rib, &edges, 3.0));
too_large(crate::fillet(&rib, &edges, 3.0));
assert_eq!(crate::chamfer_max(&rib, &edges, 3.0).unwrap().map(|x| x.0), Some(2.0));
assert_eq!(crate::fillet_max(&rib, &edges, 3.0).unwrap().map(|x| x.0), Some(2.0));
// Below half the width both build.
let b = crate::chamfer(&rib, &edges, 1.5).unwrap();
assert!((b.volume_at(0.01).unwrap() - (3200.0 - 2.0 * 0.5 * 1.5 * 1.5 * 40.0)).abs() < 1e-6);
// Two rounds of radius 1.5 along 40: each removes (1 − π/4)·1.5² of section.
let b = crate::fillet(&rib, &edges, 1.5).unwrap();
let want = 3200.0 - 2.0 * (1.0 - std::f64::consts::FRAC_PI_4) * 2.25 * 40.0;
let v = crate::measure(&b).unwrap().volume;
assert!((v - want).abs() < 1e-6 * want, "{v} vs {want}");
}
/// Edges meeting at a corner mitre: their chamfers overlap there and are not refused for it.
#[test]
fn chamfers_meeting_at_a_corner_still_build() {
let b = box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(20.0, 20.0, 20.0)).unwrap();
let edges = [Vec3::new(10.0, 0.0, 20.0), Vec3::new(20.0, 10.0, 20.0), Vec3::new(10.0, 20.0, 20.0), Vec3::new(0.0, 10.0, 20.0)];
// The chamfers leave the 20 x 20 x 15 block under a frustum from 20 x 20 to 10 x 10, 5 high:
// 6000 + (5/3)(400 + 100 + √(400·100)).
let v = crate::measure(&crate::chamfer(&b, &edges, 5.0).unwrap()).unwrap().volume;
let want = 6000.0 + 5.0 / 3.0 * (400.0 + 100.0 + 200.0);
assert!((v - want).abs() < 1e-6 * want, "{v} vs {want}");
// The rounds: (1 − π/4)·25 of section along each edge's 10 mm between the corners, and in each
// 5 mm corner cube the two cylinders' intersection is kept, ∫₀⁵ (25 − w²) dw = 250/3 of 125.
let v = crate::measure(&crate::fillet(&b, &edges, 5.0).unwrap()).unwrap().volume;
let want = 8000.0 - 4.0 * (1.0 - std::f64::consts::FRAC_PI_4) * 25.0 * 10.0 - 4.0 * (125.0 - 250.0 / 3.0);
assert!((v - want).abs() < 1e-6 * want, "{v} vs {want}");
}