665bfac0b339
tests.rs
//! Synthetic scenes: random 3D points (or a plane) seen by a known moving camera with a known
//! focal length, projected directly (with sub-pixel noise) into feature tracks.
use super::geometry::Rng;
use super::linalg::*;
use super::*;
const W: f64 = 1280.0;
const H: f64 = 720.0;
struct Truth {
/// Per frame: (R world→cam, centre, focal).
cams: Vec<(M3, V3, f64)>,
}
fn noise(rng: &mut Rng) -> f64 {
// Sum of uniforms ≈ Gaussian, σ ≈ 0.1 px.
let u: f64 = (0..4).map(|_| (rng.next_u64() % 10_000) as f64 / 10_000.0 - 0.5).sum();
u * 0.17
}
/// Project `pts` through the cameras into tracks (a track ends when its point leaves the frame;
/// re-entering starts a new track).
fn tracks_of(pts: &[V3], t: &Truth, seed: u64, noise_on: bool) -> CameraTracks {
let mut rng = Rng(seed);
let mut tracks: Vec<Track2D> = vec![];
for x in pts {
let mut cur: Option<Track2D> = None;
for (k, (r, c, f)) in t.cams.iter().enumerate() {
let p = mv(r, sub(*x, *c));
let uv = (p[2] > 0.1).then(|| [f * p[0] / p[2] + W / 2.0, f * p[1] / p[2] + H / 2.0]);
match uv.filter(|u| u[0] >= 2.0 && u[1] >= 2.0 && u[0] < W - 2.0 && u[1] < H - 2.0) {
Some(u) => {
let (nx, ny) = if noise_on { (noise(&mut rng), noise(&mut rng)) } else { (0.0, 0.0) };
let q = [(u[0] + nx) as f32, (u[1] + ny) as f32];
match &mut cur {
Some(tr) => tr.pts.push(q),
None => cur = Some(Track2D { id: 0, start: k as u32, pts: vec![q] }),
}
}
None => {
if let Some(tr) = cur.take() {
tracks.push(tr);
}
}
}
}
if let Some(tr) = cur.take() {
tracks.push(tr);
}
}
tracks.retain(|t| t.pts.len() >= 3);
for (i, tr) in tracks.iter_mut().enumerate() {
tr.id = i as u32;
}
CameraTracks { version: 1, size: [W, H], start: 0.0, frame_duration: 1.0 / 30.0, frames: t.cams.len() as u32, factor: 1.0, detailed: false, tracks }
}
fn random_points(n: usize, seed: u64, center: V3, ext: V3) -> Vec<V3> {
let mut rng = Rng(seed);
(0..n)
.map(|_| {
let mut u = || (rng.next_u64() % 100_000) as f64 / 100_000.0 - 0.5;
[center[0] + u() * ext[0], center[1] + u() * ext[1], center[2] + u() * ext[2]]
})
.collect()
}
/// A camera dollying sideways and forward while panning to keep the scene in view.
fn moving_camera(frames: usize, f: impl Fn(usize) -> f64) -> Truth {
let cams = (0..frames)
.map(|k| {
let t = k as f64 / (frames - 1) as f64;
let c = [-3.0 + 6.0 * t, -0.6 + 0.8 * t + 0.5 * (std::f64::consts::PI * t).sin(), -1.0 + 2.0 * t - 1.5 * (t - 0.5) * (t - 0.5)];
// Look at the scene centre (0, 0, 10).
let fwd = normalize(sub([0.3 * t, 0.2, 10.0], c));
let right = normalize(cross([0.0, 1.0, 0.0], fwd));
let down = cross(fwd, right);
let r = [right, down, fwd];
// A little roll.
let roll = rodrigues([0.0, 0.0, 0.05 * (t * 6.0).sin()]);
(mm(&roll, &r), c, f(k))
})
.collect();
Truth { cams }
}
/// Align the solved centres to the true ones (similarity) and return the RMS path error
/// relative to the path length, plus the worst rotation error (degrees).
fn path_error(s: &CameraSolve, t: &Truth) -> (f64, f64) {
let solved: Vec<usize> = (0..s.frames.len()).filter(|k| s.frames[*k].solved).collect();
let src: Vec<V3> = solved.iter().map(|k| s.frames[*k].center).collect();
let dst: Vec<V3> = solved.iter().map(|k| t.cams[*k].1).collect();
let sim = umeyama(&src, &dst).expect("alignment");
let len = norm(sub(dst[0], dst[dst.len() - 1])).max(1e-9);
let rms = (src.iter().zip(&dst).map(|(a, b)| dot(sub(sim.apply(*a), *b), sub(sim.apply(*a), *b))).sum::<f64>() / src.len() as f64).sqrt();
// Rotation: R_true ≈ R_solved · simᵀ.
let mut worst: f64 = 0.0;
for k in &solved {
let rs = mm(&s.frames[*k].r(), &mt(&sim.r));
let e = norm(log_rot(&mm(&rs, &mt(&t.cams[*k].0)))).to_degrees();
worst = worst.max(e);
}
(rms / len, worst)
}
fn settings(shot: ShotType, method: SolveMethod) -> SolveSettings {
SolveSettings { shot, hfov: 0.0, method, deleted: vec![], lens_distortion: false }
}
#[test]
fn fixed_angle_solve_recovers_path_and_focal() {
let f = 1100.0;
let t = moving_camera(40, |_| f);
let pts = random_points(400, 1, [0.0, 0.0, 10.0], [14.0, 8.0, 8.0]);
let tr = tracks_of(&pts, &t, 2, true);
let t0 = std::time::Instant::now();
let s = solve(&tr, &settings(ShotType::FixedAngle, SolveMethod::Typical), None).expect("solve");
eprintln!("fixed: {:?} err {:.3} px focal {:.1} in {:?}", s.method_used, s.average_error, s.focal(), t0.elapsed());
assert!(s.frames.iter().all(|c| c.solved));
assert!(s.average_error < 0.5, "{}", s.average_error);
assert!((s.focal() - f).abs() / f < 0.02, "focal {}", s.focal());
let (pe, re) = path_error(&s, &t);
assert!(pe < 0.01, "path {pe}");
assert!(re < 0.5, "rotation {re}");
// Canonical frame: first camera at the origin.
assert!(norm(s.frames[0].center) < 1e-9 && norm(s.frames[0].rot) < 1e-9);
// Serde round trip.
let j = s.to_json();
assert_eq!(CameraSolve::from_json(&j).unwrap().points.len(), s.points.len());
}
#[test]
fn auto_detect_picks_a_general_model_for_a_translating_camera() {
let f = 900.0;
let t = moving_camera(30, |_| f);
let pts = random_points(300, 3, [0.0, 0.0, 10.0], [14.0, 8.0, 8.0]);
let tr = tracks_of(&pts, &t, 4, true);
let s = solve(&tr, &settings(ShotType::FixedAngle, SolveMethod::Auto), None).expect("solve");
assert_eq!(s.method_used, SolveMethod::Typical);
assert!(s.average_error < 0.5);
assert!((s.focal() - f).abs() / f < 0.02, "focal {}", s.focal());
}
#[test]
fn specified_angle_of_view_is_kept() {
let f = 1000.0;
let t = moving_camera(25, |_| f);
let pts = random_points(300, 5, [0.0, 0.0, 10.0], [14.0, 8.0, 8.0]);
let tr = tracks_of(&pts, &t, 6, true);
let hfov = 2.0 * (W * 0.5 / f).atan().to_degrees();
let s =
solve(&tr, &SolveSettings { shot: ShotType::SpecifyAngle, hfov, method: SolveMethod::Typical, deleted: vec![], lens_distortion: false }, None).unwrap();
assert!((s.focal() - f).abs() < 1e-6);
assert!(s.average_error < 0.5);
let (pe, _) = path_error(&s, &t);
assert!(pe < 0.01, "{pe}");
}
#[test]
fn variable_zoom_recovers_per_frame_focal() {
let t = moving_camera(40, |k| 950.0 + 6.0 * k as f64);
let pts = random_points(450, 7, [0.0, 0.0, 10.0], [16.0, 9.0, 8.0]);
let tr = tracks_of(&pts, &t, 8, true);
let s = solve(&tr, &settings(ShotType::VariableZoom, SolveMethod::Typical), None).expect("solve");
eprintln!("variable: err {:.3}", s.average_error);
assert!(s.average_error < 0.5);
for (k, c) in s.frames.iter().enumerate() {
let f = t.cams[k].2;
assert!((c.focal - f).abs() / f < 0.02, "frame {k}: {} vs {f}", c.focal);
}
}
#[test]
fn tripod_pan_solve() {
let f = 1200.0;
let cams = (0..40)
.map(|k| {
let a = -0.4 + 0.8 * k as f64 / 39.0;
(mm(&rodrigues([0.0, 0.0, 0.02]), &mm(&rodrigues([0.05 * a, 0.0, 0.0]), &rodrigues([0.0, a, 0.0]))), [0.0; 3], f)
})
.collect();
let t = Truth { cams };
// Points all around at varying distances (rotation only: depth is unobservable).
let pts = random_points(600, 9, [0.0, 0.0, 0.0], [60.0, 20.0, 60.0]).into_iter().filter(|p| p[2] > 3.0).collect::<Vec<_>>();
let tr = tracks_of(&pts, &t, 10, true);
let s = solve(&tr, &settings(ShotType::FixedAngle, SolveMethod::Auto), None).expect("solve");
eprintln!("tripod: {:?} err {:.3} focal {:.1}", s.method_used, s.average_error, s.focal());
assert_eq!(s.method_used, SolveMethod::TripodPan);
assert!(s.average_error < 0.5);
assert!((s.focal() - f).abs() / f < 0.02, "{}", s.focal());
for (k, c) in s.frames.iter().enumerate() {
assert!(norm(c.center) < 1e-9);
// Relative rotation to frame 0 matches.
let rel_s = mm(&c.r(), &mt(&s.frames[0].r()));
let rel_t = mm(&t.cams[k].0, &mt(&t.cams[0].0));
assert!(norm(log_rot(&mm(&rel_s, &mt(&rel_t)))).to_degrees() < 0.2);
}
}
#[test]
fn mostly_flat_scene_and_ground_plane() {
let f = 1000.0;
// A textured floor y = 2 (below the camera), seen by a camera moving forward and sideways.
let cams = (0..40)
.map(|k| {
let t = k as f64 / 39.0;
let c = [-2.0 + 4.0 * t, -0.3 * (std::f64::consts::PI * t).sin(), 2.0 * t];
let fwd = normalize([0.1 - 0.2 * t, 0.45, 1.0]);
let right = normalize(cross([0.0, 1.0, 0.0], fwd));
let down = cross(fwd, right);
([right, down, fwd], c, f)
})
.collect();
let t = Truth { cams };
let mut rng = Rng(11);
let pts: Vec<V3> = (0..500).map(|_| [((rng.next_u64() % 2000) as f64 / 100.0) - 10.0, 2.0, 2.0 + (rng.next_u64() % 2000) as f64 / 100.0]).collect();
let tr = tracks_of(&pts, &t, 12, true);
for method in [SolveMethod::MostlyFlat, SolveMethod::Auto] {
let s = solve(&tr, &settings(ShotType::FixedAngle, method), None).expect("solve");
eprintln!("flat {method:?}: {:?} err {:.3} focal {:.1}", s.method_used, s.average_error, s.focal());
assert_eq!(s.method_used, SolveMethod::MostlyFlat);
assert!(s.average_error < 0.5, "{}", s.average_error);
assert!((s.focal() - f).abs() / f < 0.02, "{}", s.focal());
let (pe, _) = path_error(&s, &t);
assert!(pe < 0.01, "{pe}");
}
// Ground plane from the solved (coplanar) points: every point lies on it.
let hfov = 2.0 * (W * 0.5 / f).atan().to_degrees();
let mut s =
solve(&tr, &SolveSettings { shot: ShotType::SpecifyAngle, hfov, method: SolveMethod::MostlyFlat, deleted: vec![], lens_distortion: false }, None)
.expect("solve");
let ids: Vec<u32> = s.visible(0).map(|p| p.id).take(12).collect();
let g = s.ground_from(&ids, 0).expect("ground");
let spread = s.points.iter().map(|p| dot(sub(p.pos, g.origin), g.normal).abs()).fold(0.0, f64::max);
let depth = norm(sub(s.frames[0].center, g.origin));
assert!(spread < 0.01 * depth, "{spread}");
// Up points towards the camera.
assert!(dot(sub(s.frames[0].center, g.origin), g.normal) > 0.0);
s.ground = Some(g);
let w = s.world([W, H], 1000.0);
// In the world, ground points have y ≈ 0 and the cameras are above (y < 0).
for p in s.points.iter().take(20) {
assert!(w.apply(p.pos)[1].abs() < 0.01 * 1000.0 * depth, "{:?}", w.apply(p.pos));
}
assert!(w.apply(s.frames[0].center)[1] < 0.0);
assert!(norm(w.apply(g.origin)) < 1e-6);
}
#[test]
fn deleted_tracks_are_ignored_and_cancel_stops() {
let t = moving_camera(20, |_| 1000.0);
let pts = random_points(250, 13, [0.0, 0.0, 10.0], [14.0, 8.0, 8.0]);
let tr = tracks_of(&pts, &t, 14, true);
let deleted: Vec<u32> = (0..40).collect();
let hfov = 2.0 * (W * 0.5 / 1000.0f64).atan().to_degrees();
let s =
solve(&tr, &SolveSettings { shot: ShotType::SpecifyAngle, hfov, method: SolveMethod::Typical, deleted: deleted.clone(), lens_distortion: false }, None)
.unwrap();
assert!(s.points.iter().all(|p| !deleted.contains(&p.id)));
let stop = std::sync::atomic::AtomicBool::new(true);
let r = solve(&tr, &settings(ShotType::FixedAngle, SolveMethod::Typical), Some(&stop));
assert!(r.is_err());
}
/// End to end: rendered frames of a textured scene through the KLT feature tracker.
#[test]
fn rendered_scene_end_to_end() {
use effectcraft_raster::Image;
let (w, h) = (480u32, 270u32);
let f = 420.0;
// Three textured planes at different depths (a floor, a back wall and a box face).
fn tex(u: f64, v: f64) -> f32 {
fn hsh(i: i64, j: i64) -> f64 {
let mut x = (i.wrapping_mul(73856093) ^ j.wrapping_mul(19349663)) as u64;
x ^= x >> 13;
x = x.wrapping_mul(0x5bd1e995);
x ^= x >> 15;
(x % 1000) as f64 / 1000.0
}
fn noise(x: f64, y: f64) -> f64 {
let (i, j) = (x.floor(), y.floor());
let (tx, ty) = (x - i, y - j);
let (sx, sy) = (tx * tx * (3.0 - 2.0 * tx), ty * ty * (3.0 - 2.0 * ty));
let (i, j) = (i as i64, j as i64);
let a = hsh(i, j) + (hsh(i + 1, j) - hsh(i, j)) * sx;
let b = hsh(i, j + 1) + (hsh(i + 1, j + 1) - hsh(i, j + 1)) * sx;
a + (b - a) * sy
}
(0.15 + 0.5 * noise(u * 4.0, v * 4.0) + 0.3 * noise(u * 11.0 + 7.0, v * 11.0 + 3.0)) as f32
}
let frames = 24;
let t = Truth {
cams: (0..frames)
.map(|k| {
let s = k as f64 / (frames - 1) as f64;
let c = [-1.0 + 2.0 * s, -0.2, 0.5 * s];
let fwd = normalize(sub([0.0, 0.3, 8.0], c));
let right = normalize(cross([0.0, 1.0, 0.0], fwd));
([right, cross(fwd, right), fwd], c, f)
})
.collect(),
};
// Planes: (point, normal, u axis, v axis).
let planes: [(V3, V3, V3, V3); 3] = [
([0.0, 1.5, 0.0], [0.0, -1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]),
([0.0, 0.0, 10.0], [0.0, 0.0, -1.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]),
([-1.0, 0.0, 6.0], [0.3, 0.0, -1.0], [1.0, 0.0, 0.3], [0.0, 1.0, 0.0]),
];
let render = |k: usize| {
let (r, c, f) = t.cams[k];
let mut img = Image::new(w, h);
for y in 0..h {
for x in 0..w {
let d = mtv(&r, [(x as f64 + 0.5 - w as f64 / 2.0) / f, (y as f64 + 0.5 - h as f64 / 2.0) / f, 1.0]);
let mut best = (f64::INFINITY, 0.0f32);
for (i, (p0, n, ua, va)) in planes.iter().enumerate() {
let den = dot(*n, d);
if den.abs() < 1e-9 {
continue;
}
let tt = dot(*n, sub(*p0, c)) / den;
let hit = add(c, scale(d, tt));
// The box face is limited in extent.
if i == 2 && (dot(sub(hit, *p0), *ua).abs() > 1.2 || dot(sub(hit, *p0), *va).abs() > 1.0) {
continue;
}
if tt > 0.1 && tt < best.0 {
best = (tt, tex(dot(sub(hit, *p0), *ua) + 10.0 * i as f64, dot(sub(hit, *p0), *va)));
}
}
let v = best.1;
img.set(x, y, [v, v, v, 1.0]);
}
}
img
};
let mut an = TrackAnalyzer::new([w as f64, h as f64], AnalyzeOpts::default());
for k in 0..frames {
let img = render(k);
an.push(&crate::Frame::new(&img));
}
let tr = an.finish(0.0, 1.0 / 24.0);
assert!(tr.tracks.len() > 100, "{}", tr.tracks.len());
let s = solve(&tr, &settings(ShotType::FixedAngle, SolveMethod::Auto), None).expect("solve");
eprintln!("rendered: {:?} err {:.3} focal {:.1} points {}", s.method_used, s.average_error, s.focal(), s.points.len());
assert!(s.average_error < 0.5, "{}", s.average_error);
assert!((s.focal() - f).abs() / f < 0.05, "{}", s.focal());
let (pe, _) = path_error(&s, &t);
assert!(pe < 0.03, "{pe}");
}
/// A long clip (300 frames, ~900 points): `cargo test -p effectcraft-track --release -- --ignored`.
#[test]
#[ignore]
fn perf_long_clip() {
let f = 1100.0;
let t = moving_camera(300, |_| f);
let pts = random_points(900, 21, [0.0, 0.0, 10.0], [16.0, 9.0, 8.0]);
let tr = tracks_of(&pts, &t, 22, true);
let t0 = std::time::Instant::now();
let s = solve(&tr, &settings(ShotType::FixedAngle, SolveMethod::Auto), None).expect("solve");
eprintln!("300 frames, {} tracks: {:?} err {:.3} focal {:.1} in {:?}", tr.tracks.len(), s.method_used, s.average_error, s.focal(), t0.elapsed());
assert!(s.average_error < 0.5);
}
/// Solve tracks saved from the app (`EC_CAMTRACK_FILE=tracks.json cargo test -p effectcraft-track
/// --release solve_saved_tracks -- --ignored --nocapture`): a debugging aid.
#[test]
#[ignore]
fn solve_saved_tracks() {
let Some(path) = std::env::var_os("EC_CAMTRACK_FILE") else { return };
let mut tr = CameraTracks::from_json(&std::fs::read_to_string(path).unwrap()).unwrap();
if let Some(maxy) = std::env::var("EC_CAMTRACK_MAXY").ok().and_then(|v| v.parse::<f32>().ok()) {
tr.tracks.retain(|t| t.pts.iter().all(|p| p[1] < maxy));
}
let shot = if std::env::var_os("EC_CAMTRACK_VARIABLE").is_some() { ShotType::VariableZoom } else { ShotType::FixedAngle };
let t0 = std::time::Instant::now();
// With the true cameras (`[{pos, poi, zoom}]` per frame, two-node), how consistent are the
// tracks themselves?
if let Some(tp) = std::env::var_os("EC_CAMTRACK_TRUTH") {
let v: Vec<serde_json::Value> = serde_json::from_str(&std::fs::read_to_string(tp).unwrap()).unwrap();
let g = |x: &serde_json::Value| -> V3 { [x[0].as_f64().unwrap(), x[1].as_f64().unwrap(), x[2].as_f64().unwrap()] };
let cams: Vec<(super::geometry::Pose, f64)> = v
.iter()
.map(|c| {
let (pos, poi) = (g(&c["pos"]), g(&c["poi"]));
let fwd = normalize(sub(poi, pos));
let d0 = [0.0, 1.0, 0.0];
let down = normalize(sub(d0, scale(fwd, dot(d0, fwd))));
let right = cross(down, fwd);
(super::geometry::Pose { r: [right, down, fwd], c: pos }, c["zoom"].as_f64().unwrap())
})
.collect();
let (w, h) = (tr.size[0], tr.size[1]);
let mut means = vec![];
let mut drop_ids = vec![];
for t in &tr.tracks {
let views: Vec<(super::geometry::Pose, [f64; 2])> = t
.pts
.iter()
.enumerate()
.map(|(i, p)| {
let (pose, z) = cams[t.start as usize + i];
(pose, [(p[0] as f64 - w / 2.0) / z, (p[1] as f64 - h / 2.0) / z])
})
.collect();
let Some(x) = super::geometry::triangulate(&views) else { continue };
let e: Vec<f64> = views.iter().filter_map(|(p, o)| super::geometry::reproj2(p, x, *o).map(|e| e.sqrt() * cams[0].1)).collect();
means.push((e.iter().sum::<f64>() / e.len().max(1) as f64, t.pts[0]));
if std::env::var_os("EC_CAMTRACK_TRUTH_FILTER").is_some() && means.last().unwrap().0 > 1.0 {
drop_ids.push(t.id);
}
}
tr.tracks.retain(|t| !drop_ids.contains(&t.id));
means.sort_by(|a, b| a.0.total_cmp(&b.0));
eprintln!(
"true-camera track errors (px): median {:.2}; quartiles {:?}",
means[means.len() / 2].0,
[means[means.len() / 4].0, means[means.len() * 3 / 4].0]
);
for m in means.iter().step_by(6) {
eprintln!(" {:.2} at {:?}", m.0, m.1);
}
}
let mut st = settings(shot, SolveMethod::Auto);
if let Some(a) = std::env::var("EC_CAMTRACK_AOV").ok().and_then(|v| v.parse::<f64>().ok()) {
st.shot = ShotType::SpecifyAngle;
st.hfov = a;
}
let s = solve(&tr, &st, None).expect("solve");
eprintln!(
"{} frames, {} tracks: {:?} err {:.3} focal {:.1} (hfov {:.1}) points {} in {:?}",
tr.frames,
tr.tracks.len(),
s.method_used,
s.average_error,
s.focal(),
s.hfov(s.focal()),
s.points.len(),
t0.elapsed()
);
}
/// Pass every track position through a lens distortion (around the frame centre).
fn distort_tracks(t: &CameraTracks, d: &Distortion) -> CameraTracks {
let mut t = t.clone();
for tr in t.tracks.iter_mut() {
for p in tr.pts.iter_mut() {
let q = d.distort([p[0] as f64 - W / 2.0, p[1] as f64 - H / 2.0]);
*p = [(q[0] + W / 2.0) as f32, (q[1] + H / 2.0) as f32];
}
}
t
}
#[test]
fn lens_distortion_is_recovered_in_the_bundle_adjustment() {
let f = 1000.0;
let t = moving_camera(36, |_| f);
let pts = random_points(450, 7, [0.0, 0.0, 10.0], [16.0, 9.0, 8.0]);
let truth = Distortion { k1: -0.12, k2: 0.03, radius: 0.5 * W.hypot(H) };
let tr = distort_tracks(&tracks_of(&pts, &t, 8, true), &truth);
let plain = solve(&tr, &settings(ShotType::FixedAngle, SolveMethod::Typical), None).expect("pinhole solve");
let lens = solve(&tr, &SolveSettings { lens_distortion: true, ..settings(ShotType::FixedAngle, SolveMethod::Typical) }, None).expect("lens solve");
let d = lens.distortion.expect("distortion solved");
eprintln!(
"pinhole error {:.3} px (focal {:.1}); with distortion {:.3} px (focal {:.1}), k1 {:.4} k2 {:.4}",
plain.average_error,
plain.focal(),
lens.average_error,
lens.focal(),
d.k1,
d.k2
);
assert!(plain.distortion.is_none());
assert!((d.k1 - truth.k1).abs() < 0.005, "k1 {}", d.k1);
assert!((d.k2 - truth.k2).abs() < 0.01, "k2 {}", d.k2);
// The distortion model explains the tracks: about the noise level, far below the pinhole fit.
assert!(lens.average_error < 0.3, "{}", lens.average_error);
assert!(lens.average_error < 0.5 * plain.average_error, "{} vs {}", lens.average_error, plain.average_error);
assert!((lens.focal() - f).abs() < 0.02 * f, "focal {}", lens.focal());
let (path, rot) = path_error(&lens, &t);
assert!(path < 0.01 && rot < 0.3, "path {path} rot {rot}");
// Projection through the lens lands on the (distorted) tracks; undistorting inverts it.
let p = [100.0, 80.0];
let q = lens.to_image(p);
let back = lens.to_ideal(q);
assert!((back[0] - p[0]).abs() < 1e-6 && (back[1] - p[1]).abs() < 1e-6);
let sp = &lens.points[0];
let k = sp.first as usize;
let obs = tr.track(sp.id).and_then(|t| t.at(k as u32)).expect("observed");
let proj = lens.project(k, sp.pos, false).expect("in front");
assert!((proj[0] - obs[0]).hypot(proj[1] - obs[1]) < 2.0, "{proj:?} vs {obs:?}");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.