Files
solidcraft/crates/kernel/src/sweep_rails_tests.rs
T
jyvikoandClaude Opus 5.5 ce8981f167 Wave 345/509: Tests: a cylinder's side and a sphere are one face each, as SMLib builds them (and 3 more)
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop.

- 2c341006a jyviko: Tests: a cylinder's side and a sphere are one face each, as SMLib builds them
- 6c9c679dc jyviko: Tests: a revolved sheet over one radian is one face, untrimmed over its whole span
- 8075b8f70 jyviko: Tests: a swept point path is its lines, and rails must turn with a cornered path
- b9d65e6bc jyviko: Tests: thicken across a sharp edge extends the offsets until they meet

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
2026-10-29 00:31:25 -04:00

168 lines
8.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.
//! Guide rails on path sweeps (issue #771), checked against analytic solids: a rail that closes
//! in on the path scales a circle into a cone frustum, a stretching rail widens a square one way
//! only, a helical rail twists a square, two rails carry a line between them; and rails the
//! sweep cannot follow are refused.
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::f64::consts::PI;
use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};
use crate::{RailFit, SweepControl, measure, sweep_path_with};
fn circle(r: f64) -> Region2 {
Region2 { outer: Loop2::circle(Vec2::ZERO, r), holes: Vec::new() }
}
fn square(h: f64) -> Region2 {
Region2 { outer: Loop2::polygon(&[Vec2::new(-h, -h), Vec2::new(h, -h), Vec2::new(h, h), Vec2::new(-h, h)]), holes: Vec::new() }
}
/// The Z axis from 0 to 40.
fn up() -> Vec<Vec3> {
vec![Vec3::ZERO, Vec3::new(0.0, 0.0, 40.0)]
}
fn railed(rails: Vec<Vec<Vec3>>, fit: RailFit) -> SweepControl {
SweepControl { rails, rail_fit: fit, ..SweepControl::default() }
}
fn close(a: f64, b: f64, rel: f64) -> bool {
(a - b).abs() <= rel * b.abs()
}
/// A rail from the circle's edge at radius 10 in to radius 5 at the top scales the circle into
/// a frustum: volume πh(R² + Rr + r²)/3, lateral area π(R + r) times the slant height.
#[test]
fn a_rail_closing_in_scales_a_circle_into_a_frustum() {
let rail = vec![Vec3::new(10.0, 0.0, 0.0), Vec3::new(5.0, 0.0, 40.0)];
let b = sweep_path_with(&Plane::XY, &circle(10.0), &up(), &railed(vec![rail], RailFit::Scale)).unwrap();
let m = measure(&b).unwrap();
let volume = PI * 40.0 / 3.0 * (100.0 + 50.0 + 25.0);
let area = PI * 15.0 * (40.0f64 * 40.0 + 25.0).sqrt() + PI * 100.0 + PI * 25.0;
assert!(close(m.volume, volume, 2e-3), "volume {} vs {volume}", m.volume);
assert!(close(m.area, area, 2e-3), "area {} vs {area}", m.area);
assert!(close(m.bbox.max.z, 40.0, 1e-9), "{:?}", m.bbox);
}
/// A stretching rail from x = 5 out to x = 10 doubles the square's width along X by the top and
/// leaves its depth along Y: sections 10 × 10k with k = 1 + z/40, volume 100 · 40 · 1.5.
#[test]
fn a_stretching_rail_widens_a_square_one_way() {
let rail = vec![Vec3::new(5.0, 0.0, 0.0), Vec3::new(10.0, 0.0, 40.0)];
let b = sweep_path_with(&Plane::XY, &square(5.0), &up(), &railed(vec![rail], RailFit::Stretch)).unwrap();
let m = measure(&b).unwrap();
assert!(close(m.volume, 6000.0, 1e-3), "volume {}", m.volume);
assert!((m.bbox.max.x - 10.0).abs() < 1e-3 && (m.bbox.min.x + 10.0).abs() < 1e-3, "{:?}", m.bbox);
assert!((m.bbox.max.y - 5.0).abs() < 1e-3 && (m.bbox.min.y + 5.0).abs() < 1e-3, "{:?}", m.bbox);
}
/// The same rail scaling evenly: the square grows both ways, sections 100k², volume
/// 100 ∫ (1 + z/40)² dz = 100 · 40 · 7/3.
#[test]
fn a_scaling_rail_grows_a_square_both_ways() {
let rail = vec![Vec3::new(5.0, 0.0, 0.0), Vec3::new(10.0, 0.0, 40.0)];
let b = sweep_path_with(&Plane::XY, &square(5.0), &up(), &railed(vec![rail], RailFit::Scale)).unwrap();
let m = measure(&b).unwrap();
let volume = 100.0 * 40.0 * 7.0 / 3.0;
assert!(close(m.volume, volume, 2e-3), "volume {} vs {volume}", m.volume);
assert!((m.bbox.max.y - 10.0).abs() < 1e-3, "{:?}", m.bbox);
}
/// A helical rail from the square's corner, a quarter turn about the path at the corner's
/// radius, twists the square a quarter turn: the volume stays 4000, halfway up the corners stand
/// on the axes (the box reaches 5√2), and at the top the corner is at (−5, 5).
#[test]
fn a_helical_rail_twists_a_square() {
let r = 50f64.sqrt();
let rail: Vec<Vec3> = (0..=200)
.map(|i| {
let u = i as f64 / 200.0;
let a = PI / 4.0 + u * PI / 2.0;
Vec3::new(r * a.cos(), r * a.sin(), 40.0 * u)
})
.collect();
let b = sweep_path_with(&Plane::XY, &square(5.0), &up(), &railed(vec![rail], RailFit::Scale)).unwrap();
let m = measure(&b).unwrap();
assert!(close(m.volume, 4000.0, 2e-3), "volume {}", m.volume);
assert!((m.bbox.max.x - r).abs() < 0.05 && (m.bbox.max.y - r).abs() < 0.05, "{:?}", m.bbox);
// The edge running up from the corner (5, 5) ends a quarter turn on, at (−5, 5).
let edges = b.edges(0.01).unwrap();
let ends = |e: &crate::EdgeInfo| (e.points.first().copied().unwrap(), e.points.last().copied().unwrap());
let joins = |p: Vec3, q: Vec3| {
edges.iter().any(|e| {
let (a, b) = ends(e);
(a.dist(p) < 1e-3 && b.dist(q) < 1e-3) || (a.dist(q) < 1e-3 && b.dist(p) < 1e-3)
})
};
assert!(joins(Vec3::new(5.0, 5.0, 0.0), Vec3::new(-5.0, 5.0, 40.0)), "{:?}", edges.iter().map(ends).collect::<Vec<_>>());
assert!(!joins(Vec3::new(5.0, 5.0, 0.0), Vec3::new(5.0, 5.0, 40.0)));
}
/// Along a quarter circle of radius 30, a rail keeping 5 mm out from the path (the circle's
/// outer point, on a quarter circle of radius 35) leaves the circle as it is: a quarter torus,
/// volume πr² · R · π/2 (Pappus).
#[test]
fn a_parallel_rail_along_a_curved_path_keeps_the_section() {
let arc = |radius: f64| -> Vec<Vec3> {
(0..=180)
.map(|i| {
let a = PI / 2.0 * i as f64 / 180.0;
Vec3::new(30.0 - radius * a.cos(), 0.0, radius * a.sin())
})
.collect()
};
let b = sweep_path_with(&Plane::XY, &circle(5.0), &arc(30.0), &railed(vec![arc(35.0)], RailFit::Scale)).unwrap();
let m = measure(&b).unwrap();
let volume = PI * 25.0 * 30.0 * PI / 2.0;
assert!(close(m.volume, volume, 2e-3), "volume {} vs {volume}", m.volume);
}
/// Two rails bulging apart along arcs (radius 25 about (∓5, 0, 20), through x = ±10 at z = 0
/// and z = 40) carry a line between them: the sheet lies in the XZ plane between the arcs, area
/// 2(a√(R² − a²) + R² asin(a/R)) − 400 with a = 20.
#[test]
fn two_rails_carry_a_line_between_arcs() {
let arc = |side: f64| -> Vec<Vec3> {
(0..=400)
.map(|i| {
let z = 40.0 * i as f64 / 400.0;
let x = -5.0 + (625.0 - (z - 20.0) * (z - 20.0)).sqrt();
Vec3::new(side * x, 0.0, z)
})
.collect()
};
let line = vec![vec![Seg2::Line { a: Vec2::new(-10.0, 0.0), b: Vec2::new(10.0, 0.0) }]];
for fit in [RailFit::Scale, RailFit::Stretch] {
let ctl = railed(vec![arc(-1.0), arc(1.0)], fit);
let b = crate::sweep_sheet_points_with(&Plane::XY, &line, &up(), &ctl).unwrap();
let m = measure(&b).unwrap();
let area = 2.0 * (20.0 * 15.0 + 625.0 * (0.8f64).asin()) - 400.0;
assert!(close(m.area, area, 1e-3), "{fit:?}: area {} vs {area}", m.area);
assert!(m.bbox.min.y.abs() < 1e-6 && m.bbox.max.y.abs() < 1e-6, "{fit:?}: {:?}", m.bbox);
}
}
/// Rails the sweep cannot follow are refused with a reason, never a panic: three rails, a rail
/// with a bad point, a rail with a twist or scale besides, a rail starting on the path, a rail
/// that stops short, a straight rail along a path with a corner (a rail must turn with the path
/// at its corners).
#[test]
fn rails_the_sweep_cannot_follow_are_refused() {
let rail = vec![Vec3::new(10.0, 0.0, 0.0), Vec3::new(5.0, 0.0, 40.0)];
let refuse = |ctl: SweepControl, path: &[Vec3], why: &str| {
let e = sweep_path_with(&Plane::XY, &circle(10.0), path, &ctl).map(|_| ()).unwrap_err().to_string();
assert!(e.contains(why), "expected `{why}` in `{e}`");
};
refuse(railed(vec![rail.clone(); 3], RailFit::Scale), &up(), "one or two guide rails");
refuse(railed(vec![vec![Vec3::ZERO, Vec3::new(f64::NAN, 0.0, 1.0)]], RailFit::Scale), &up(), "finite points");
refuse(SweepControl { twist: 1.0, ..railed(vec![rail.clone()], RailFit::Scale) }, &up(), "leave the orientation");
refuse(SweepControl { scale: 2.0, ..railed(vec![rail.clone()], RailFit::Scale) }, &up(), "leave the orientation");
refuse(railed(vec![vec![Vec3::ZERO, Vec3::new(5.0, 0.0, 40.0)]], RailFit::Scale), &up(), "starts on the path");
refuse(railed(vec![vec![Vec3::new(10.0, 0.0, 0.0), Vec3::new(8.0, 0.0, 20.0)]], RailFit::Scale), &up(), "whole length");
refuse(railed(vec![rail.clone(), rail.clone()], RailFit::Scale), &up(), "start at the same point");
let bent = vec![Vec3::ZERO, Vec3::new(0.0, 0.0, 20.0), Vec3::new(20.0, 0.0, 20.0)];
refuse(railed(vec![vec![Vec3::new(10.0, 0.0, 0.0), Vec3::new(10.0, 0.0, 30.0)]], RailFit::Scale), &bent, "the guide rails have to turn with it");
}