Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

Merge pull request #2340 from vangel76/camtrack-stack-jacobian

BFlat61c3285ea39b
diff --cc crates/track/src/camtrack/bundle.rs
index e03341d14,c3045c51f..b8421f144
--- a/crates/track/src/camtrack/bundle.rs
+++ b/crates/track/src/camtrack/bundle.rs
@@@ -549,75 -509,26 +594,95 @@@ mod tests
use super::*;
use crate::camtrack::geometry::Rng;
+ 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);