diff --git a/crates/kernel/src/build.rs b/crates/kernel/src/build.rs index 654bdee2c..716035922 100644 --- a/crates/kernel/src/build.rs +++ b/crates/kernel/src/build.rs @@ -2000,11 +2000,20 @@ fn loft_numbered_wires(sections: &[(Plane, NumberedLoop)], reversed: bool) -> Re // with the most segments. let n0 = ordered.first().map(|(p, _)| p.normal()).unwrap_or(Vec3::Z); let parallel = ordered.iter().all(|(p, _)| p.normal().dot(n0).abs() > 1.0 - 1e-9); + // Whether a section faces the first one's way is followed neighbour to neighbour, not by its + // normal against the first's: planes turning about an axis pass 90 degrees and would be + // flipped, folding the loft (#2847). + let mut facing = true; + let mut before = n0; let oriented: Vec<(Plane, NumberedLoop)> = ordered .iter() .map(|(p, l)| { - let ccw = p.normal().dot(n0) >= 0.0; - (*p, l.oriented(!ccw)) + let n = p.normal(); + if n.dot(before) < 0.0 { + facing = !facing; + } + before = n; + (*p, l.oriented(!facing)) }) .collect(); let lead = oriented.iter().max_by_key(|(_, l)| l.lp.segs.len()).ok_or_else(|| KernelError::Invalid("no sections".into()))?; diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rs index 6a669145f..1daf59bcd 100644 --- a/crates/kernel/src/tests.rs +++ b/crates/kernel/src/tests.rs @@ -2981,6 +2981,37 @@ fn an_attempt_budget_stops_the_boolean_and_is_shared_by_nesting() { assert!(boolean(&a, &b, BoolOp::Intersect).unwrap().is_some()); } +/// #2847: identical elliptic spline sections (3 x 5 mm, 30 mm off the Z axis) on planes turning +/// about Z in 10 degree steps. The start vertex was matched by projecting the lead section's +/// vertex directions onto each plane, which squeezes them as the plane turns (and flips them past +/// 90 degrees), so the sections were paired round the wrong way and the loft folded (6 % of +/// Pappus' volume at 180 degrees). The volume follows Pappus: area x 30 mm x angle. +#[test] +fn loft_through_identical_sections_turning_about_an_axis_keeps_its_volume() { + let pts: Vec = (0..12).map(|a| Vec2::new(30.0 + 3.0 * (a as f64 * PI / 6.0).cos(), 5.0 * (a as f64 * PI / 6.0).sin())).collect(); + // Periodic Catmull-Rom through the points, as cubic Beziers. + let segs: Vec = (0..12) + .map(|i| { + let p = |k: usize| pts[(i + k + 11) % 12]; + let (p0, p1, p2, p3) = (p(0), p(1), p(2), p(3)); + Seg2::Cubic { p0: p1, p1: p1 + (p2 - p0) * (1.0 / 6.0), p2: p2 - (p3 - p1) * (1.0 / 6.0), p3: p2 } + }) + .collect(); + let section = Loop2 { segs }; + let area = section.signed_area().abs(); + for span in [90, 120, 180] { + let secs: Vec<(Plane, Loop2)> = (0..=span / 10) + .map(|i| { + let t = (i as f64 * 10.0).to_radians(); + (Plane { origin: Vec3::ZERO, x: Vec3::new(t.cos(), t.sin(), 0.0), y: Vec3::Z }, section.clone()) + }) + .collect(); + let want = area * 30.0 * (span as f64).to_radians(); + let m = measure(&loft(&secs).unwrap()).unwrap(); + assert!(rel(m.volume, want) < 0.03, "{span} degrees: volume {} vs Pappus {want}", m.volume); + } +} + /// Moving an assembly places every body of it again: a copy placed for showing keeps its /// revolved faces where its source turned them, so placing searches none of them again (that search was most /// of the time an occurrence move took on a large assembly, #3044), and the copy is the same