EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Merge upstream/main into camtrack-matrix-free-schur
vangel7606d5a6fc803a
diff --cc crates/track/src/camtrack/bundle.rsindex 42494be14,b8421f144..a4412dbce--- a/crates/track/src/camtrack/bundle.rs+++ b/crates/track/src/camtrack/bundle.rs@@@ -10,9 -10,9 +10,9 @@@use rayon::prelude::*;- use super::Distortion;use super::geometry::Pose;-use super::linalg::{M3, V3, add, cholesky_solve, dot, inv3, mm, mtv, mv, rodrigues, scale, skew, sub};+use super::linalg::{M3, V3, add, cholesky_solve, conjugate_gradient, dot, inv3, mm, mtv, mv, rodrigues, scale, skew, sub};+ use super::{Distortion, SolveError};/// A camera in the adjustment.#[derive(Clone, Copy, Debug, PartialEq)]@@@ -292,55 -310,12 +405,58 @@@ fn add_focal_prior(cams: &[BaCam], o: &}}+/// Eliminate the points into the camera system explicitly (`S -= W V^-1 W^T`, `rhs -= W V^-1 bp`).+fn reduce_points(systems: &[PtSys], vinv: &[Option<M3>], n: usize, s: &mut [f64], rhs: &mut [f64]) {+ let npts = systems.len();+ let reduce = |range: std::ops::Range<usize>, s: &mut [f64], rhs: &mut [f64]| {+ for j in range {+ let (Some(vi), ps) = (&vinv[j], &systems[j]) else { continue };+ let vb = mv(vi, ps.bp);+ let wv: Vec<V3> = ps.w.iter().map(|(_, w)| mv(vi, *w)).collect();+ for (a, (ia, wa)) in ps.w.iter().enumerate() {+ rhs[*ia] -= dot(*wa, vb);+ for (ib, wb) in &ps.w[a..] {+ let d = dot(wv[a], *wb);+ s[ia * n + ib] -= d;+ if ia != ib {+ s[ib * n + ia] -= d;+ }+ }+ }+ }+ };+ let chunks = rayon::current_num_threads().clamp(1, 8);+ if n <= 1200 && npts >= 64 && chunks > 1 {+ let per = npts.div_ceil(chunks);+ let parts: Vec<(Vec<f64>, Vec<f64>)> = (0..chunks)+ .into_par_iter()+ .map(|t| {+ let (mut ds, mut dr) = (vec![0.0; n * n], vec![0.0; n]);+ reduce(t * per..((t + 1) * per).min(npts), &mut ds, &mut dr);+ (ds, dr)+ })+ .collect();+ for (ds, dr) in parts {+ s.par_iter_mut().zip(ds.par_iter()).for_each(|(x, y)| *x += y);+ for (x, y) in rhs.iter_mut().zip(dr) {+ *x += y;+ }+ }+ } else {+ reduce(0..npts, s, rhs);+ }+}+/// Run Levenberg–Marquardt. `cams` and `pts` are updated in place.- pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) -> BaReport {+ /// Invalid inputs or workspaces exceeding 256 MiB return an error before mutation.+ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) -> Result<BaReport, SolveError> {+ validate(cams, pts, obs, o)?;+ adjust_impl(cams, pts, obs, o, true)+}+- fn adjust_impl(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts, allow_iterative: bool) -> BaReport {++fn adjust_impl(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts, allow_iterative: bool) -> Result<BaReport, SolveError> {let l = layout(cams.len(), o);+ let matrix_len = matrix_len(l.n, pts.len(), obs.len())?;let npts = pts.len();// Observations by point.let mut by_pt: Vec<Vec<u32>> = vec![vec![]; npts];@@@ -363,9 -341,14 +482,9 @@@iters += 1;// ---- Normal equations (Gauss–Newton with IRLS weights).// Per point: V (3×3), bp (3), W entries (cam-side index → 3).- struct PtSys {- v: [[f64; 3]; 3],- bp: V3,- w: Vec<(usize, V3)>,- }let build_point = |j: usize, s_acc: &mut Vec<f64>, bc: &mut Vec<f64>| -> PtSys {let mut ps = PtSys { v: [[0.0; 3]; 3], bp: [0.0; 3], w: vec![] };- let mut jc: Vec<(usize, [f64; 2])> = Vec::with_capacity(8);+ let mut jc = CameraJacobian::new();for &oi in &by_pt[j] {let ob = &obs[oi as usize];let ci = ob.cam as usize;@@@ -585,113 -593,96 +709,202 @@@mod tests {use super::*;use crate::camtrack::geometry::Rng;+ use crate::camtrack::linalg::{I3, log_rot, mt, norm};++ #[test]+ fn long_track_adjustment_matches_direct_reprojections_and_outliers() {+ rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap().install(|| {+ for (focal, fix_centers, distortion) in+ [(FocalMode::Fixed, false, false), (FocalMode::Shared, false, true), (FocalMode::PerCamera(30.0), false, true), (FocalMode::Shared, true, true)]+ {+ let mut rng = Rng(71);+ let mut noise = || (rng.next_u64() % 100_000) as f64 / 100_000.0 - 0.5;+ let truth: Vec<V3> = (0..320).map(|_| [noise() * 8.0, noise() * 5.0, 10.0 + noise() * 5.0]).collect();+ let true_cams: Vec<_> = (0..60)+ .map(|i| BaCam {+ pose: Pose {+ r: rodrigues([0.001 * i as f64, -0.003 * i as f64, 0.0]),+ c: if fix_centers { [0.0; 3] } else { [0.03 * i as f64, 0.01 * (i as f64).sin(), 0.0] },+ },+ f: if matches!(focal, FocalMode::PerCamera(_)) { 900.0 * (1.0 + 0.05 * (i as f64 * 0.07).sin()) } else { 900.0 },+ dist: if distortion { Distortion { k1: 0.015, k2: -0.005, radius: 1100.0 } } else { Distortion::NONE },+ })+ .collect();+ let mut obs = Vec::new();+ for (ci, c) in true_cams.iter().enumerate() {+ for (pi, p) in truth.iter().enumerate() {+ let mut uv = residual(c, *p, [0.0; 2]).unwrap();+ uv[0] += noise() * 0.05;+ uv[1] += noise() * 0.05;+ if (ci * truth.len() + pi).is_multiple_of(37) {+ uv[0] += 25.0;+ uv[1] -= 30.0;+ }+ obs.push(BaObs { cam: ci as u32, pt: pi as u32, uv });+ }+ }+ let mut cams = true_cams.clone();+ for c in cams.iter_mut().skip(2) {+ c.pose.r = mm(&rodrigues([0.001, -0.001, 0.0005]), &c.pose.r);+ if !fix_centers {+ c.pose.c = add(c.pose.c, [0.002, -0.003, 0.001]);+ }+ }+ let mut pts: Vec<_> = truth.iter().map(|p| add(*p, [0.01, -0.01, 0.005])).collect();+ let (mut direct_cams, mut direct_pts) = (cams.clone(), pts.clone());+ let opts = BaOpts { focal, fix_centers, distortion, fixed: (0..60).map(|i| i < 2).collect(), max_iter: 10, ..Default::default() };- let report = adjust(&mut cams, &mut pts, &obs, &opts);- let direct = adjust_impl(&mut direct_cams, &mut direct_pts, &obs, &opts, false);++ let report = adjust(&mut cams, &mut pts, &obs, &opts).unwrap();++ let direct = adjust_impl(&mut direct_cams, &mut direct_pts, &obs, &opts, false).unwrap();+ assert!((report.cost - direct.cost).abs() < 1e-5 * direct.cost.max(1.0));+ for ob in &obs {+ let a = residual(&cams[ob.cam as usize], pts[ob.pt as usize], ob.uv).unwrap();+ let b = residual(&direct_cams[ob.cam as usize], direct_pts[ob.pt as usize], ob.uv).unwrap();+ assert!((a[0] - b[0]).hypot(a[1] - b[1]) < 0.001);+ assert_eq!(a[0].hypot(a[1]) <= 4.0, b[0].hypot(b[1]) <= 4.0);+ }+ for (a, b) in cams.iter().zip(direct_cams) {+ assert!(norm(sub(a.pose.c, b.pose.c)) < 0.001);+ assert!(norm(log_rot(&mm(&a.pose.r, &mt(&b.pose.r)))) < 1e-4);+ assert!((a.f - b.f).abs() < 1e-4 * b.f);+ assert!((a.dist.k1 - b.dist.k1).abs() < 1e-4 && (a.dist.k2 - b.dist.k2).abs() < 1e-4);+ }+ }+ });+ }++ #[test]+ fn matrix_free_schur_matches_explicit_system_and_rejects_bad_preconditioner() {+ let l = layout(20, &BaOpts::default());+ let n = l.n;+ let mut u = vec![0.0; n * n];+ for i in 0..n {+ u[i * n + i] = 10.0;+ }+ let systems: Vec<_> = (0..80)+ .map(|j| PtSys {+ v: I3,+ bp: [0.01, -0.02, 0.03],+ w: (0..n).map(|i| (i, [((j * 13 + i * 7) % 19) as f64 * 0.001 - 0.009, (i % 7) as f64 * 0.001, (j % 11) as f64 * 0.001])).collect(),+ })+ .collect();+ let vinv = vec![Some(I3); systems.len()];+ let rhs: Vec<_> = (0..n).map(|i| (i % 7) as f64 - 3.0).collect();+ let x = iterative_schur(&u, &rhs, &systems, &vinv, &l).unwrap();+ let mut explicit = u.clone();+ let mut reduced_rhs = rhs.clone();+ for ps in &systems {+ for (i, a) in &ps.w {+ reduced_rhs[*i] -= dot(*a, ps.bp);+ for (j, b) in &ps.w {+ explicit[i * n + j] -= dot(*a, *b);+ }+ }+ }+ let mut direct = reduced_rhs.clone();+ let mut factor = explicit.clone();+ assert!(cholesky_solve(&mut factor, n, &mut direct));+ for (a, b) in x.iter().zip(direct) {+ assert!((a - b).abs() < 1e-9);+ }+ let mut error2 = 0.0;+ for (i, row) in explicit.chunks_exact(n).enumerate() {+ let ax: f64 = row.iter().zip(&x).map(|(a, x)| a * x).sum();+ error2 += (ax - reduced_rhs[i]).powi(2);+ }+ assert!(error2 < 1e-18 * reduced_rhs.iter().map(|v| v * v).sum::<f64>());+ u[0] = -1.0;+ assert!(iterative_schur(&u, &rhs, &systems, &vinv, &l).is_none());+ }+ fn test_camera() -> BaCam {+ BaCam { pose: Pose::IDENTITY, f: 900.0, dist: Distortion::NONE }+ }++ #[test]+ fn cost_rejects_invalid_observation_indices() {+ for (cam, pt) in [(1, 0), (0, 1)] {+ let obs = [BaObs { cam, pt, uv: [0.0; 2] }];+ assert!(cost(&[test_camera()], &[[0.0, 0.0, 5.0]], &obs, &BaOpts::default()).is_err());+ }+ }++ #[test]+ fn adjust_rejects_invalid_observation_without_mutating_inputs() {+ for (cam, pt) in [(1, 0), (0, 1)] {+ let mut cams = [test_camera()];+ let mut pts = [[0.0, 0.0, 5.0]];+ let before = (cams, pts);+ let obs = [BaObs { cam, pt, uv: [0.0; 2] }];+ assert!(adjust(&mut cams, &mut pts, &obs, &BaOpts::default()).is_err());+ assert_eq!((cams, pts), before);+ }+ }++ #[test]+ fn residual_rejects_non_finite_inputs_and_projection_overflow() {+ let cam = test_camera();+ assert!(residual(&cam, [0.0, 0.0, f64::NAN], [0.0; 2]).is_none());+ assert!(residual(&cam, [0.0, 0.0, 5.0], [f64::INFINITY, 0.0]).is_none());+ for bad in [+ BaCam { f: f64::NAN, ..cam },+ BaCam { dist: Distortion { k1: f64::INFINITY, ..Distortion::NONE }, ..cam },+ BaCam { pose: Pose { c: [f64::NAN; 3], ..Pose::IDENTITY }, ..cam },+ BaCam { pose: Pose { r: [[f64::INFINITY; 3]; 3], ..Pose::IDENTITY }, ..cam },+ ] {+ assert!(residual(&bad, [0.0, 0.0, 5.0], [0.0; 2]).is_none());+ }+ assert!(residual(&cam, [f64::MAX, 0.0, 1.0], [0.0; 2]).is_none());+ }++ #[test]+ fn adjustment_rejects_non_finite_points_observations_and_options() {+ let cam = test_camera();+ let pts = [[0.0, 0.0, 5.0]];+ let obs = [BaObs { cam: 0, pt: 0, uv: [0.0; 2] }];+ assert!(cost(&[cam], &[[f64::NAN, 0.0, 5.0]], &obs, &BaOpts::default()).is_err());+ assert!(cost(&[cam], &pts, &[BaObs { uv: [f64::NAN; 2], ..obs[0] }], &BaOpts::default()).is_err());+ for opts in [+ BaOpts { huber: f64::NAN, ..Default::default() },+ BaOpts { huber: 0.0, ..Default::default() },+ BaOpts { focal: FocalMode::PerCamera(f64::INFINITY), ..Default::default() },+ BaOpts { max_iter: usize::MAX, ..Default::default() },+ ] {+ let mut trial_pts = pts;+ assert!(adjust(&mut [cam], &mut trial_pts, &obs, &opts).is_err());+ }+ }++ #[test]+ fn matrix_workspace_is_checked_and_bounded_before_allocation() {+ assert!(matrix_len(usize::MAX, 0, 0).is_err());+ assert!(matrix_len(1, usize::MAX, 0).is_err());+ assert!(matrix_len(1, 0, usize::MAX).is_err());+ let mut cams = vec![test_camera(); 1000];+ assert!(adjust(&mut cams, &mut [], &[], &BaOpts::default()).is_err());+ assert!(matrix_len(6, 1000, 1000).is_ok());+ assert!(matrix_len(955, 900, 160 * 900).is_ok());+ }++ #[test]+ fn camera_jacobian_keeps_extra_parameters_and_resets() {+ let mut jac = CameraJacobian::new();+ let count = MAX_CAMERA_JACOBIAN_ENTRIES + 3;+ for i in 0..count {+ jac.push((i, [i as f64, -(i as f64)]));+ }+ assert_eq!(jac.as_slice().iter().count(), count);+ for (i, entry) in jac.as_slice().iter().enumerate() {+ assert_eq!(*entry, (i, [i as f64, -(i as f64)]));+ }+ jac.clear();+ assert_eq!(jac.as_slice().iter().count(), 0);+ for i in 0..MAX_CAMERA_JACOBIAN_ENTRIES {+ jac.push((i, [1.0, 2.0]));+ }+ assert_eq!(jac.as_slice().iter().count(), MAX_CAMERA_JACOBIAN_ENTRIES);+ assert!(jac.overflow.is_empty());+ }+#[test]fn bundle_adjustment_converges_from_noise() {let mut rng = Rng(99);diff --cc crates/track/src/camtrack/linalg.rsindex 1d53aef1d,692eef34e..71e88e109--- a/crates/track/src/camtrack/linalg.rs+++ b/crates/track/src/camtrack/linalg.rs@@@ -482,30 -473,119 +527,143 @@@ pub fn from_euler_xyz(e: V3) -> M3mod tests {use super::*;+ fn dense_cholesky_reference(a: &mut [f64], n: usize, b: &mut [f64]) -> bool {+ for j in 0..n {+ let mut d = a[j * n + j];+ for k in 0..j {+ d -= a[j * n + k] * a[j * n + k];+ }+ if d <= 0.0 || !d.is_finite() {+ return false;+ }+ let d = d.sqrt();+ a[j * n + j] = d;+ let (head, tail) = a.split_at_mut((j + 1) * n);+ let rowj = &head[j * n..j * n + j];+ // Rows below j (sequential: per-column parallel dispatch costs more than it saves).+ for row in tail.chunks_mut(n) {+ row[j] = (row[j] - dot_n(&row[..j], rowj)) / d;+ }+ }+ // Forward: L y = b.+ for i in 0..n {+ let mut s = b[i];+ for k in 0..i {+ s -= a[i * n + k] * b[k];+ }+ b[i] = s / a[i * n + i];+ }+ // Back: Lᵀ x = y.+ for i in (0..n).rev() {+ let mut s = b[i];+ for k in i + 1..n {+ s -= a[k * n + i] * b[k];+ }+ b[i] = s / a[i * n + i];+ }+ b.iter().all(|v| v.is_finite())+ }++ #[test]+ fn banded_cholesky_is_bit_identical_to_dense() {+ for n in [1usize, 2, 3, 4, 5, 6, 7, 8, 13, 31, 65, 127] {+ for width in [0usize, 1, 2, 5, 11, n - 1] {+ for seed in 0..3 {+ for scale in [1.0, 1e-100, 1e100] {+ let mut a = vec![0.0; n * n];+ for i in 0..n {+ for j in 0..i {+ let value = if i - j <= width {+ (((i * 13 + j * 17 + seed) % 23) as f64 - 11.0) / 128.0+ } else if (i + j) % 2 == 0 {+ -0.0+ } else {+ 0.0+ };+ a[i * n + j] = value;+ a[j * n + i] = value;+ }+ }+ for i in 0..n {+ a[i * n + i] = a[i * n..(i + 1) * n].iter().map(|v| v.abs()).sum::<f64>() + 1.0;+ }+ for value in &mut a {+ *value *= scale;+ }+ let mut rhs: Vec<f64> = (0..n).map(|i| if i % 7 == 0 { -0.0 } else { ((i * 5 + seed) % 17) as f64 - 8.0 }).collect();+ let (mut reference_a, mut reference_rhs) = (a.clone(), rhs.clone());+ assert!(dense_cholesky_reference(&mut reference_a, n, &mut reference_rhs));+ assert!(cholesky_solve(&mut a, n, &mut rhs));+ assert_eq!(+ rhs.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),+ reference_rhs.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),+ "n={n} width={width} seed={seed} scale={scale}"+ );+ assert_eq!(+ a.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),+ reference_a.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),+ "factor n={n} width={width}"+ );+ }+ }+ }+ }+ }++ #[test]+ fn banded_cholesky_preserves_underflow_and_signed_zero() {+ let n = 8;+ let mut a = vec![0.0; n * n];+ for i in 0..n {+ for j in 0..n {+ a[i * n + j] = if i == j {+ 1e300+ } else if (i + j) % 2 == 0 {+ -0.0+ } else {+ 0.0+ };+ }+ }+ let mut rhs = vec![-1e-300, 1e-300, -0.0, 0.0, -1e-300, 1e-300, 0.0, -0.0];+ let (mut original, mut expected) = (a.clone(), rhs.clone());+ assert!(dense_cholesky_reference(&mut original, n, &mut expected));+ assert!(cholesky_solve(&mut a, n, &mut rhs));+ assert_eq!(rhs.iter().map(|v| v.to_bits()).collect::<Vec<_>>(), expected.iter().map(|v| v.to_bits()).collect::<Vec<_>>());+ }++ #[test]+ fn cholesky_rejects_invalid_dimensions_without_indexing() {+ assert!(!cholesky_solve(&mut [], usize::MAX, &mut []));+ assert!(!cholesky_solve(&mut [1.0], 2, &mut [1.0, 1.0]));+ assert!(!cholesky_solve(&mut [1.0], 1, &mut []));+ assert!(cholesky_solve(&mut [], 0, &mut []));+ }++ #[test]+ fn conjugate_gradient_checks_residual_and_bad_curvature() {+ let n = 64;+ let rhs: Vec<f64> = (0..n).map(|i| (i % 11) as f64 - 5.0).collect();+ let apply = |x: &[f64], y: &mut [f64]| {+ for i in 0..n {+ y[i] = 4.0 * x[i] + if i > 0 { x[i - 1] } else { 0.0 } + if i + 1 < n { x[i + 1] } else { 0.0 };+ }+ };+ let x = conjugate_gradient(&rhs, apply, |r, z| {+ for (r, z) in r.iter().zip(z) {+ *z = *r / 4.0;+ }+ })+ .unwrap();+ let mut product = vec![0.0; n];+ apply(&x, &mut product);+ let residual: f64 = rhs.iter().zip(product).map(|(b, ax)| (b - ax).powi(2)).sum();+ assert!(residual < 1e-18 * dot_n(&rhs, &rhs));+ assert!(conjugate_gradient(&[1.0], |x, y| y[0] = -x[0], |r, z| z.copy_from_slice(r)).is_none());+ assert!(conjugate_gradient(&[f64::NAN], |_, _| {}, |_, _| {}).is_none());+ assert_eq!(conjugate_gradient(&[0.0], |_, _| {}, |_, _| {}).unwrap(), vec![0.0]);+ }+#[test]fn svd_reconstructs() {let a = [3.0, 1.0, 2.0, -1.0, 4.0, 0.5, 2.0, 2.0, 7.0, 0.1, -3.0, 1.0];