Skip to content

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.rs
index 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.rs
index 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) -> M3
mod 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];