From 1817cffaf30778d6af5ab1e76b8f298214cddd11 Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Fri, 30 Oct 2026 02:30:05 -0400 Subject: [PATCH] Shell: a basin shelled past its 4 mm rim measures its exact sharp offset MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit shell_thicker_than_a_rim_is_refused expected the "rim or ledge" refusal from 9508ee749, added because truck's face offset turned the top face inside out and returned a body of about twice the volume. SMLib builds the exact sharp-edged offset, and its volumes are the closed form, so the test now checks those (renamed shell_of_a_basin_past_its_rim_keeps_the_rim_solid). Proof. Slab [0,100]×[0,60]×[0,30]; pocket lofted from x 20..80, y 4..50 at z 30 to x 30..70, y 20..40 at z 10, its sides the planes x + z/2 = 35, x − z/2 = 65, y + 0.8z = 28, y − z/2 = 35 (normal lengths √5/2, √5/2, √1.64, √5/2). Shelled open at z = 0 by t, the cavity is the slab shrunk by t (x t..100−t, y t..60−t, z 0..30−t) less the pocket grown by t (each plane moved out by t·|n|, floor z = 10 − t). For t ≤ 6 the grown pocket stays inside the shrunk slab in x and at the back (50 + 0.618t ≤ 60 − t); its front reaches y = t at z0 = (28 − (1 + √1.64)t)/0.8, below 30 − t from t ≈ 2.70 (the rim stays solid above z0). With W = 30 + z + √5 t, grown(t) = ∫[10−t, z0] W (7 + 1.3z + (√5/2 + √1.64)t) dz + ∫[z0, 30−t] W (35 + z/2 + (√5/2 − 1)t) dz, V(t) = 180000 − grown(0) − (100 − 2t)(60 − 2t)(30 − t) + grown(t), grown(0) = 33866.667, so V(1) = 17105.6240415, V(4) = 63560.2492284, V(6) = 90113.9202101. SMLib measures 17105.6242, 63560.2492, 90113.9203 (≤ 1e-8 relative). The test computes the closed form and checks each shell to 1e-6, with the centroid inside its box and on x = 50 as before. Co-Authored-By: Claude Opus 5.5 --- crates/kernel/src/tests.rs | 43 +++++++++++++++++++++++++++----------- 1 file changed, 31 insertions(+), 12 deletions(-) diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rs index 06ab45c6a..586a77564 100644 --- a/crates/kernel/src/tests.rs +++ b/crates/kernel/src/tests.rs @@ -1474,25 +1474,44 @@ fn shell_non_convex() { assert!(rel(v, outer - cavity) < 1e-6, "{v} vs {}", outer - cavity); } -/// A basin: a slab with a tapered pocket and a 4 mm front rim, shelled from below. A wall -/// thicker than the rim (with the pocket's slope) would turn the top face inside out: refused, -/// not a body with wrong mass properties. +/// A basin: a 100 × 60 × 30 slab with a tapered pocket (60 × 46 at the top, 4 mm from the front, +/// 40 × 20 at its floor 20 down) shelled from below, each wall moved in by t with sharp edges. +/// The cavity is the slab shrunk by t (open at z = 0) less the pocket grown by t, each sloped side +/// moved out along its normal; the volume, slab − pocket − cavity, is a cubic in z integrated by +/// hand. From t ≈ 2.70 the front side's offset passes the front wall's below the 4 mm rim, and +/// the rim stays solid: the cavity's front stops at y = t (from z = (28 − (1 + √1.64) t)/0.8 up). #[test] -fn shell_thicker_than_a_rim_is_refused() { +fn shell_of_a_basin_past_its_rim_keeps_the_rim_solid() { let slab = box_solid(Vec3::ZERO, Vec3::new(100.0, 60.0, 30.0)).unwrap(); let rect = |x0: f64, y0: f64, x1: f64, y1: f64| Loop2::polygon(&[Vec2::new(x0, y0), Vec2::new(x1, y0), Vec2::new(x1, y1), Vec2::new(x0, y1)]); let at = |z: f64| Plane::new(Vec3::new(0.0, 0.0, z), Vec3::X, Vec3::Y).unwrap(); let pocket = loft(&[(at(30.0), rect(20.0, 4.0, 80.0, 50.0)), (at(10.0), rect(30.0, 20.0, 70.0, 40.0))]).unwrap(); let basin = boolean(&slab, &pocket, BoolOp::Cut).unwrap().unwrap(); let open = [Vec3::new(50.0, 30.0, 0.0)]; - let e = shell(&basin, &open, 6.0).unwrap_err().to_string(); - assert!(e.contains("rim or ledge"), "{e}"); - let (whole, thin) = (measure(&basin).unwrap(), measure(&shell(&basin, &open, 1.0).unwrap()).unwrap()); - assert!(thin.volume > 0.0 && thin.volume < whole.volume, "{} vs {}", thin.volume, whole.volume); - let (lo, hi) = (thin.bbox.min, thin.bbox.max); - let c = thin.centroid; - assert!(c.x > lo.x && c.x < hi.x && c.y > lo.y && c.y < hi.y && c.z > lo.z && c.z < hi.z, "{c:?}"); - assert!((c.x - 50.0).abs() < 1e-3, "{c:?}"); + // The pocket grown by t at height z: x from 35 − z/2 − t√5/2 to 65 + z/2 + t√5/2, y from + // 28 − 0.8 z − t√1.64 (or y = t, where that is less) to 35 + z/2 + t√5/2, for + // z = 10 − t … 30 − t; its sides stay inside the shrunk slab in x and at the back for t ≤ 6. + let (r5, r164) = (5f64.sqrt(), 1.64f64.sqrt()); + let integral = |c: [f64; 3], lo: f64, hi: f64| c[0] * (hi - lo) + c[1] * (hi * hi - lo * lo) / 2.0 + c[2] * (hi.powi(3) - lo.powi(3)) / 3.0; + // (w0 + z)(h0 + h1 z) as coefficients in z. + let product = |w0: f64, h0: f64, h1: f64| [w0 * h0, w0 * h1 + h0, h1]; + let grown = |t: f64| { + let (lo, hi, w0) = (10.0 - t, 30.0 - t, 30.0 + r5 * t); + let full = product(w0, 7.0 + t * (r5 / 2.0 + r164), 1.3); + let z0 = ((28.0 - r164 * t - t) / 0.8).clamp(lo, hi); + integral(full, lo, z0) + integral(product(w0, 35.0 + (r5 / 2.0 - 1.0) * t, 0.5), z0, hi) + }; + let volume = |t: f64| 100.0 * 60.0 * 30.0 - grown(0.0) - (100.0 - 2.0 * t) * (60.0 - 2.0 * t) * (30.0 - t) + grown(t); + let whole = measure(&basin).unwrap(); + assert!(rel(whole.volume, 180_000.0 - grown(0.0)) < 1e-9, "{}", whole.volume); + for (t, want) in [(1.0, 17_105.624_041_5), (4.0, 63_560.249_228_4), (6.0, 90_113.920_210_1)] { + assert!(rel(volume(t), want) < 1e-12, "the closed form at {t}: {}", volume(t)); + let m = measure(&shell(&basin, &open, t).unwrap()).unwrap(); + assert!(rel(m.volume, want) < 1e-6, "t {t}: {} vs {want}", m.volume); + let (lo, hi, c) = (m.bbox.min, m.bbox.max, m.centroid); + assert!(c.x > lo.x && c.x < hi.x && c.y > lo.y && c.y < hi.y && c.z > lo.z && c.z < hi.z, "{c:?}"); + assert!((c.x - 50.0).abs() < 1e-3, "{c:?}"); + } } #[test]