SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 329/509: Tests: the sample-aliasing trap aliases by its knots, within the degree a record holds (and 3 more)
jyvikoe794c6b6e488
diff --git a/crates/kernel/src/face_source_tests.rs b/crates/kernel/src/face_source_tests.rsindex c46f0008bf..2ba51f6c18 100644--- a/crates/kernel/src/face_source_tests.rs+++ b/crates/kernel/src/face_source_tests.rs@@ -100,7 +100,14 @@ fn construction_planes_follow_reflected_and_sheared_affine_images() {[[-1., 0., 0., 0.], [0.4, 2., 0., 0.], [0., 0.3, 1., 0.], [8., 9., 10., 1.]],] {let placed = transform_matrix(&body, m).unwrap();- for (original, transformed) in body.face_sources().unwrap().iter().zip(placed.face_sources().unwrap()) {+ // SMLib numbers the placed faces afresh: each is matched with the face its history names.+ let history = placed.history().unwrap();+ let originals = body.face_sources().unwrap();+ for (f, transformed) in placed.face_sources().unwrap().iter().enumerate() {+ let [crate::history::FaceOrigin::Face { operand: 0, face }] = history.faces[f].origins.as_slice() else {+ panic!("face {f} has no one origin")+ };+ let original = &originals[*face];let (Some(FaceSource::Box { producer: a, axis: aa, high: ah, plane: ap }),Some(FaceSource::Box { producer: b, axis: ba, high: bh, plane: bp }),diff --git a/crates/kernel/src/issue_2005_tests.rs b/crates/kernel/src/issue_2005_tests.rsindex 532a07b436..98c67eda9d 100644--- a/crates/kernel/src/issue_2005_tests.rs+++ b/crates/kernel/src/issue_2005_tests.rs@@ -31,8 +31,10 @@ fn circle_path() -> [PathSeg; 2] {fn tube(body: &Body, volume: f64, genus: usize) {let m = measure(body).unwrap();assert!((m.volume - volume).abs() < volume * 0.01, "{m:?}, expected {volume}");- // A closed orientable tube has Euler characteristic 2 - 2g. Coincident caps gave 2.- assert_eq!(m.vertices + m.faces + 2 * genus, m.edges + 2, "{m:?}");+ // A closed orientable tube of genus g: V - E + F - (L - F) = 2 - 2g (Euler-Poincare, L the+ // loops: an annular face has two). Coincident caps gave 2 - 2g + 2.+ let loops: usize = body.record().faces.iter().map(|f| f.loops.len()).sum();+ assert_eq!(m.vertices + 2 * m.faces + 2 * genus, m.edges + loops + 2, "{m:?}, {loops} loops");// Every shell closed: each edge bounds two faces.assert!(body.record().edges.iter().all(|e| e.uses.len() >= 2));let h = body.history().expect("sweep provenance");diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rsindex fe9b33ad2d..053368f669 100644--- a/crates/kernel/src/ops.rs+++ b/crates/kernel/src/ops.rs@@ -141,15 +141,44 @@ pub fn transform_matrix(body: &Body, m: [[f64; 4]; 4]) -> Result<Body> {return placed.with_history(history, &[body]);}let sources = body.transformed_sources(m)?;- let placed = match Rigid::of_matrix(&m) {+ let (placed, sources, paint) = match Rigid::of_matrix(&m) {Some(motion) => {let moved = Body::from_record(body.record().moved(&motion))?;let history = History::identity(&moved);- moved.with_history(history, &[body])?+ (moved.with_history(history, &[body])?, sources, body.paint().cloned())+ }+ None => {+ // SMLib numbers the moved body's faces afresh: each face's source and paint follow it+ // by the history (a face whose origin is not known keeps no source; with no history+ // the paint stays as it was).+ let placed = transformed(body, &m)?;+ let origin: Vec<Option<usize>> = (0..placed.face_count()).map(|f| moved_from(placed.history(), f)).collect();+ let sources = sources.map(|s| std::sync::Arc::new(origin.iter().map(|o| o.and_then(|j| s.get(j).cloned().flatten())).collect()));+ let paint = body.paint().cloned().map(|mut p| {+ if placed.history().is_none() {+ return p;+ }+ p.faces = p+ .faces+ .iter()+ .flat_map(|fp| {+ origin.iter().enumerate().filter(|(_, o)| **o == Some(fp.face)).map(|(face, _)| crate::FacePaint { face, ..fp.clone() })+ })+ .collect();+ p+ });+ (placed, sources, paint)}- None => transformed(body, &m)?,};- Ok(placed.with_color(body.color()).with_paint(body.paint().cloned()).with_face_sources(sources).inherit_regularization_protection(body))+ Ok(placed.with_color(body.color()).with_paint(paint).with_face_sources(sources).inherit_regularization_protection(body))+}++/// The face of the operand that face `f` of a moved body is, by the move's history.+fn moved_from(history: Option<&History>, f: usize) -> Option<usize> {+ match history?.faces.get(f)?.origins.as_slice() {+ [crate::history::FaceOrigin::Face { operand: 0, face }] => Some(*face),+ _ => None,+ }}/// `body` moved by a matrix that is not a rigid motion, in SMLib, its history from SMLib's tags.diff --git a/crates/kernel/src/prism_curve.rs b/crates/kernel/src/prism_curve.rsindex 611ffc3e2e..508ef1f060 100644--- a/crates/kernel/src/prism_curve.rs+++ b/crates/kernel/src/prism_curve.rs@@ -578,14 +578,35 @@ mod tests {}out}- fn trap() -> Vec<f64> {- let mut p = vec![1.];- for k in 0..=16 {- p = multiply(&p, &[-(k as f64) / 16., 1.]);+ /// The power basis `p` (in t) over the span t = a + h s, in s.+ fn shifted(p: &[f64], a: f64, h: f64) -> Vec<f64> {+ let mut out = vec![0.];+ for c in p.iter().rev() {+ out = multiply(&out, &[a, h]);+ out[0] += c;}- let mid = (0..=16).map(|k| 1. / 32. - k as f64 / 16.).product::<f64>();- p.iter_mut().for_each(|v| *v /= mid);- p+ out+ }+ /// A spline of `degree` over spans [k/16, (k+1)/16] (k = 0..16), joined C0 (each interior+ /// knot `degree` times), whose homogeneous `x`, `y`, `w` are the power bases `f(k)` gives+ /// in the span's own parameter s ∈ [0, 1]: a curve that bends only between the knots.+ fn spans(degree: usize, f: impl Fn(usize) -> [Vec<f64>; 3]) -> Curve {+ let mut knots = vec![0.; degree + 1];+ let mut homogeneous: Vec<[f64; 4]> = Vec::new();+ for k in 0..16 {+ let [x, y, w] = f(k);+ let (x, y, w) = (bernstein(&x, degree), bernstein(&y, degree), bernstein(&w, degree));+ let controls = x.iter().zip(y).zip(w).map(|((x, y), w)| [*x, y, 0., w]);+ homogeneous.extend(controls.skip(usize::from(k > 0)));+ knots.extend(std::iter::repeat_n((k + 1) as f64 / 16., degree));+ }+ knots.push(1.);+ Curve::RationalSpline { knots, homogeneous }+ }+ /// The bump s (1 - s) / (1/4) in the span's own parameter: 0 at both its ends (every old+ /// sample location k/16 is a knot), 1 half way along the first span (t = 1/32).+ fn bump(k: usize) -> Vec<f64> {+ if k == 0 { vec![0., 4., -4.] } else { vec![0.] }}fn bezier_knots(degree: usize) -> Vec<f64> {std::iter::repeat_n(0., degree + 1).chain(std::iter::repeat_n(1., degree + 1)).collect()@@ -615,27 +636,37 @@ mod tests {Curve::RationalSpline { knots: bezier_knots(2), homogeneous: vec![[10., 0., 0., 1.], [10. * w, 10. * w, 0., w], [0., 10., 0., 1.]] }}+ /// Sampling must not certify a spline cap that merely passes through the sample points.+ /// Once that took a single polynomial of degree 17 with a root at each of the 17 old sample+ /// locations k/16, more than a B-rep record holds (MAX_SPLINE_DEGREE 16); here the aliasing is+ /// in the knots instead: a C0 quadratic spline with a knot at every k/16, on the line (or+ /// the circle) at each of them, and bowing off it between (by 1 mm, 1/32 along).#[test]fn sample_aliasing_does_not_certify_spline_caps() {- let e = curve(&[0., 10.], &trap(), &[1.], 17);+ let e = spans(2, |k| {+ let h = 1. / 16.;+ [shifted(&[0., 10.], k as f64 * h, h), bump(k), vec![1.]]+ });for k in 0..=16 {- assert!(at(&e, k as f64 / 16.).y.abs() < 1e-4, "old sample locations must see a line");+ assert!(at(&e, k as f64 / 16.).y.abs() < 1e-12, "old sample locations must see a line");}- assert!((at(&e, 1. / 32.).y - 1.).abs() < 1e-6);+ assert!((at(&e, 1. / 32.).y - 1.).abs() < 1e-12);assert!(segment(&run(&e, true), &Plane::XY, 1e-3, &mut 2_000_000).is_none());- let q = trap();- let mut perturb = q.iter().map(|v| v * 0.1).collect::<Vec<_>>();- perturb[0] += 1.;+ // The quarter circle of radius 10, its homogeneous coordinates scaled by 1 + bump / 10 but+ // its weight not: radius 10 at every k/16, 11 at 1/32.let w = std::f64::consts::FRAC_1_SQRT_2;- let x = multiply(&[10., 20. * (w - 1.), 10. * (1. - 2. * w)], &perturb);- let y = multiply(&[0., 20. * w, 10. * (1. - 2. * w)], &perturb);- let circle = curve(&x, &y, &[1., 2. * (w - 1.), 2. * (1. - w)], 19);+ let (x, y, wt) = ([10., 20. * (w - 1.), 10. * (1. - 2. * w)], [0., 20. * w, 10. * (1. - 2. * w)], [1., 2. * (w - 1.), 2. * (1. - w)]);+ let circle = spans(4, |k| {+ let (a, h) = (k as f64 / 16., 1. / 16.);+ let scale: Vec<f64> = bump(k).iter().enumerate().map(|(i, v)| v / 10. + if i == 0 { 1. } else { 0. }).collect();+ [multiply(&shifted(&x, a, h), &scale), multiply(&shifted(&y, a, h), &scale), shifted(&wt, a, h)]+ });for k in 0..=16 {let p = at(&circle, k as f64 / 16.);- assert!((p.x.hypot(p.y) - 10.).abs() < 1e-3, "old sample locations must see a circle");+ assert!((p.x.hypot(p.y) - 10.).abs() < 1e-9, "old sample locations must see a circle");}let p = at(&circle, 1. / 32.);- assert!((p.x.hypot(p.y) - 11.).abs() < 1e-5);+ assert!((p.x.hypot(p.y) - 11.).abs() < 1e-9);assert!(segment(&run(&circle, true), &Plane::XY, 1e-3, &mut 2_000_000).is_none());}@@ -649,7 +680,8 @@ mod tests {assert!((sweep.abs() - std::f64::consts::FRAC_PI_2).abs() < 1e-8);assert_eq!(sweep > 0., forward);}- let line = curve(&[0., 10.], &[0.], &[1.], 17);+ // A line written at the highest degree a B-rep record holds (MAX_SPLINE_DEGREE).+ let line = curve(&[0., 10.], &[0.], &[1.], solidcraft_geom::bspline::MAX_SPLINE_DEGREE);assert!(matches!(segment(&run(&line, true), &Plane::XY, 1e-5, &mut 2_000_000).unwrap()[0], Seg2::Line { .. }));// The longitudinal derivative is negative at t=1/3, independently// establishing genuine retracing rather than a stationary tangent.diff --git a/crates/kernel/src/record_tests.rs b/crates/kernel/src/record_tests.rsindex 54ac6c1946..3590a7dca6 100644--- a/crates/kernel/src/record_tests.rs+++ b/crates/kernel/src/record_tests.rs@@ -439,13 +439,13 @@ fn check_sweep(b: &Body, plane: &Plane, r: &Region2, faces_per_segment: Option<u#[test]fn sweeps_along_paths() {let r = Region2 { outer: rotated(&rect(-2.0, -2.0, 2.0, 2.0).reversed(), 1), holes: vec![] };- // A line then a quarter turn (two parts): three faces per segment.+ // A line then a quarter turn: a face per segment along each path segment.let path = [PathSeg::Line { a: Vec3::ZERO, b: Vec3::new(0.0, 0.0, 10.0) },PathSeg::Arc { a: Vec3::new(0.0, 0.0, 10.0), center: Vec3::new(20.0, 0.0, 10.0), axis: Vec3::Y, angle: FRAC_PI_2 },];let b = crate::sweep(&Plane::XY, &r, &path).unwrap();- check_sweep(&b, &Plane::XY, &r, Some(3));+ check_sweep(&b, &Plane::XY, &r, Some(2));// Along a smooth 3D path: one wall per segment.let curve: Vec<Vec3> = (0..=40).map(|i| {diff --git a/crates/kernel/src/smlib_sweeps.rs b/crates/kernel/src/smlib_sweeps.rsindex 679a3630c6..62386961f3 100644--- a/crates/kernel/src/smlib_sweeps.rs+++ b/crates/kernel/src/smlib_sweeps.rs@@ -565,9 +565,18 @@ mod imp {if runs.len() > 1 {return cornered(plane, pieces, path, &runs, translate);}- let (brep, _) = swept(plane, pieces, path, translate)?;+ let (brep, [_, middle, last]) = swept(plane, pieces, path, translate)?;let body = body_of(&brep, "sweep")?;- let roles = roles(&body, plane, None, &seeds(plane, pieces, |q| q), &[], true)?;+ // The walls known by the profile carried half way (past the start's edges: a wall the+ // start touches by no edge, as round a closed path, and walls along later path segments).+ let inside = seeds(plane, pieces, |q| apply(&middle, q));+ let start = path.first().map(crate::PathSeg::start);+ let end = path.last().map(seg_ends).transpose()?.map(|(_, b)| b);+ let roles = match (start, end) {+ // Round a closed path there are no caps, and the start holds seams only.+ (Some(a), Some(b)) if a.dist(b) <= 1e-6 => roles(&body, &plane.offset(body.size().max(1e-9) * 10.0), None, &[], &inside, false)?,+ _ => roles(&body, plane, Some(&placed(plane, &last)), &seeds(plane, pieces, |q| q), &inside, false)?,+ };with_history(body, &roles, pieces)}