Synthetic Data API

Synthetic scenes, evaluation metrics and augmentation (the Synthetic submodule), and the Monte Carlo calibration of the uncertainty propagation.

Synthetic Data

VisualGeometryToolkitCore.Synthetic — Module
Synthetic

Synthetic data generation for benchmarking geometric estimators.

Provides ground-truth scene generators with configurable noise and outlier contamination for conic fitting, and evaluation metrics.

Conic Points

pts, mask = ellipse_points(; n=100, outlier_frac=0.3, sigma=0.5, seed=42)

Evaluation

err = imc_pose_error(F_est, K, R_gt, t_gt)
score = mean_average_accuracy(errs; max_error = 10)   # mAA@10°: the threshold is required

See also: VisualGeometryToolkitFeatures for correspondence generators (synthetic_stereo_rig, stereo_correspondences, planar_correspondences).

source
VisualGeometryToolkitCore.Synthetic.ellipse_points — Method
ellipse_points(; cx=50.0, cy=50.0, a=20.0, b=10.0, angle=0.3,
                n=100, outlier_frac=0.0, sigma=0.0, seed=42)

Generate synthetic points on an ellipse with optional noise and outliers.

Points are uniformly sampled in angle around the ellipse. Outliers are uniformly distributed within the bounding box of the ellipse (expanded by 2×).

Returns

  • points::Vector{Point2{Float64}}: Point set (inliers + outliers, shuffled)
  • is_inlier::BitVector: Mask indicating true inlier points

Arguments

  • cx, cy: Ellipse center
  • a, b: Semi-major and semi-minor axes
  • angle: Rotation angle (radians)
  • n::Int=100: Number of inlier points
  • outlier_frac::Real=0.0: Fraction of total that are outliers
  • sigma::Real=0.0: Gaussian noise std added to points
  • seed::Int=42: RNG seed
source
VisualGeometryToolkitCore.Synthetic.imc_pose_error — Method
imc_pose_error(F_est, K, R_gt, t_gt) -> Float64

Image Matching Challenge pose error metric (DEGREES).

Decomposes E = KᵀFK into 4 possible (R, t) solutions, computes max(rotation_error, translation_error) for each, and returns the minimum. This is the coherent (single-decomposition) counterpart to optimistic_pose_error, which takes per-axis minima from possibly different decompositions; both report in degrees.

This is the standard metric from the IMC benchmark: it measures how well an estimated fundamental matrix recovers the true relative pose.

Arguments

  • F_est: Estimated 3×3 fundamental matrix
  • K: Shared 3×3 calibration matrix (or K1, K2 for different intrinsics)
  • R_gt: Ground-truth 3×3 rotation matrix
  • t_gt: Ground-truth 3-vector translation

Returns

  • Float64: Pose error in degrees (max of rotation/translation angular errors, minimized over the 4 essential matrix decompositions)
source
VisualGeometryToolkitCore.Synthetic.imc_pose_error — Method
imc_pose_error(E, R_gt, t_gt) -> Float64

IMC pose error (degrees) of an already-metric essential matrix E against the ground-truth pose — decomposes E directly via motion(E), no calibration. Use the (F, K…) overloads when starting from a fundamental matrix.

source
VisualGeometryToolkitCore.Synthetic.imc_pose_error — Method
imc_pose_error(F_est, rig::StereoRig) -> Float64

IMC pose error using a StereoRig for ground-truth pose and calibration.

Extracts K from the source camera and (R, t) from the rig's extrinsics. Assumes shared intrinsics.

source
VisualGeometryToolkitCore.Synthetic.maa — Method
maa(errors, t) -> Float64

Accuracy at threshold t: the fraction of errors strictly below t. Non-finite entries (failed estimates) never succeed and therefore count as failures in the denominator.

source
VisualGeometryToolkitCore.Synthetic.maa_score — Method
maa_score(e; max_error) -> Float64

Per-item contribution to the continuous mean_average_accuracy: max(0, 1 - min(e, T)/T) with T = max_error, and 0 for non-finite e. Use this per-sample form for bootstrap resampling; mean(e -> maa_score(e; max_error), errors) == mean_average_accuracy(errors; max_error). max_error is required, as for the aggregate.

source
VisualGeometryToolkitCore.Synthetic.mean_average_accuracy — Method
mean_average_accuracy(errors; max_error) -> Float64

THE canonical mAA@max_error (≡ AUC): the normalized area under the empirical CDF of errors from 0 to T = max_error — (1/T)∫₀ᵀ F(t)dt, equivalently mean_p max(0, 1 - min(e_p, T)/T). Non-finite entries (failed estimates) contribute 0 but stay in the denominator. This is the EXACT AUC; the former discrete threshold-average variant is retired — it is strictly coarser (it cannot resolve errors below T/#thresholds). All consumers use this continuous statistic.

max_error is required, in the errors' own units: the threshold is a protocol parameter of the caller's benchmark (the IMC pose-error mAA takes max_error = 10 degrees), never a hidden default.

source
VisualGeometryToolkitCore.Synthetic.optimistic_pose_error — Method
optimistic_pose_error(E::AbstractMatrix, R_gt, t_gt) -> (Δr_deg, Δt_deg)

Lower-bound (per-axis-optimistic) pose error of an essential matrix against a ground-truth pose. Decomposes E into its 4 sign-ambiguous candidates and returns the per-axis minimum errors:

Δr_min = min over decomps k of  rad2deg(rotation_angle(RotMatrix{3}(R_kᵀ R_gt)))
Δt_min = min over decomps k of  rad2deg(translation_angle(t_k, t_gt))

The two minimums may come from different decompositions — the returned tuple does not correspond to any single (R, t) pair, and is therefore unrealizable as a coherent single-decomposition output. It bounds from below what any one decomposition could achieve per axis.

Used by the Shekhovtsov RANSAC-Scoring protocol (per-axis independent min, see RANSAC-Scoring/model_H.py:438-452) and by the pool record Pools.PoolPair, which stores errors_r / errors_t as separate columns.

For a coherent single-decomposition error: select the desired decomposition externally (e.g. via cheirality on real correspondences, or argmin_k max(Δr_k, Δt_k) against the oracle) and call pose_error(R, t, R_gt, t_gt) directly.

See also: pose_error, imc_pose_error.

source
VisualGeometryToolkitCore.Synthetic.optimistic_pose_error — Method
optimistic_pose_error(H::HomographyMat, R_gt, t_gt) -> (Δr_deg, Δt_deg)

Per-axis-optimistic pose error (DEGREES) of a calibrated homography against a ground-truth pose: decomposes H via Malis–Vargas motion(H) and returns the per-axis minima over the (up to 4) (R, t, n) candidates, exactly as the essential-matrix overload does (the two minima may come from different candidates — a per-axis lower bound). Returns (180.0, 180.0) when the decomposition is empty (singular H).

H must already be calibrated; for a pixel-space H_px use the intrinsics form below. Translation error uses translation_angle, which is 0 for a zero-translation (pure-rotation) candidate.

source
VisualGeometryToolkitCore.Synthetic.perturbed_pose — Method
perturbed_pose(rng, R_gt, t_gt, δ) -> (RotMatrix, Vec3)

The protocol's δr = δt = δ perturbation of a ground-truth relative pose: rotation by δ [rad] about a seeded random axis plus a magnitude-δ translation jitter (t re-normalized). The draw order is fixed (axis first, then translation jitter), so a caller-seeded rng reproduces the seed bit-for-bit (ladder convention: one StableRNG(stable_seed(seed, scene, pair, δ)) per (pair, δ), so every arm sees the identical perturbed seed, on every Julia version).

source
VisualGeometryToolkitCore.Synthetic.projective_distance — Method
projective_distance(A, B) -> Float64

Distance between two models known only up to a nonzero scale and a sign (E, F, H, a radial camera's rows, a homogeneous vector): the Euclidean distance between the unit-normalized entries, with B taken in A's sign,

‖â − sign(â·b̂)·b̂‖ = min(‖â − b̂‖, ‖â + b̂‖),   â = vec(A)/‖A‖.

It lies in [0, √2], is 0 exactly when A ∝ B, and is symmetric. For small values it is the angle between the two representatives: 1 − |â·b̂| = d²/2.

source
VisualGeometryToolkitCore.Synthetic.perspective_augmentation — Method
perspective_augmentation(rng, H_wi::SMatrix{3, 3}, extent;
                         strengthen_max = 1.0, jitter_max = 0.1) -> SMatrix{3, 3, Float64}

An image→image homography that strengthens H_wi's perspective and adds a random-direction tilt. extent = (cx, cy, hx, hy) is the target's world bounding box (centre + per-axis half-extent). Strengthening scales the projective row's in-plane entries (the vanishing line) by 1 + γ, γ ~ U(0, strengthen_max), leaving the centroid fixed; the jitter is a tilt of magnitude ~ U(0, jitter_max) in a uniformly random direction, in the normalised frame. Returns the identity on any degeneracy (a singular H_wi), i.e. no augmentation.

source

Monte Carlo calibration of the uncertainty propagation

Public, not exported (Synthetic.run_calibration, or import by name): the scenes, the per-model trials and the coverage tests the stack's propagation calibration items run.

VisualGeometryToolkitCore.Synthetic.F_NORM_SCALE — Constant

Calibration frame for the F cells: pixel coordinates scaled by s = 1/25 about the principal point. The Bartoli–Sturm orthonormal chart is near-GAUGE at both natural frames — raw pixels drive σ₂/σ₁ → ~1e-4 (U/V near-co-rotation gauge; chart-coordinate calibration is numerically meaningless there — REPORTED as a finding by the pixel-frame driver cell), and K-normalized coordinates drive σ → 1 exactly (F → E, the near-essential gauge Bartoli–Sturm §5.1.4). s = 1/25 puts the scene family's σ₂/σ₁ in ~[0.04, 0.95] (median 0.22): generically mid-gauge.

source
VisualGeometryToolkitCore.Synthetic.CalibrationResult — Type

Result of one MC calibration cell.

  • nees_mean, nees_se: sample mean of the NEES and its standard error (χ² theory: sd(mean) = √(2·dof/N) under calibration).
  • coverage: empirical fraction of trials with NEES ≤ χ²(dof) quantile at the levels (0.5, 0.9, 0.95).
  • emp_cov, mean_pred: empirical covariance of the tracked chart errors vs the mean predicted covariance (for eigen-ratio diagnostics).
  • nfail: trials discarded. For the tracking cells this is the DIVERGENCE count (chart-Newton continuation failed to converge — genuinely ill-conditioned at that noise level) plus the rare degenerate-anchor trials (singular ∂v g at θgt); for refit cells it is fit failures.
source
VisualGeometryToolkitCore.Synthetic.ContainmentResult — Type

Result of one output-domain containment cell: rates[i] is the empirical containment fraction of statistic i (H: the 95% transfer ellipse; E/F: [pointwise χ²₁ band, whole-line χ²₂ band]); nfail is the divergence/degeneracy count.

source
VisualGeometryToolkitCore.Synthetic.epipolar_band_trial — Method
epipolar_band_trial(model_class::Symbol; σ_px, f=600.0, regime=:generic,
                    aniso=false, img2_scale=1.0, level=0.95, nspan=40,
                    npts=minimal, estimate=nothing, covariance=nothing)

Criminisi-protocol output-domain trial for the epipolar models (model_class ∈ (:E, :F)): per trial, perturb the minimal computation correspondences in both images, TRACK the ground-truth-anchored solution on the perturbed constraints, perturb a query point x in image 1, form the MC epipolar line l̂ = θ̂·x̃q, and test it against the analytic H–Z envelope band at θgt whose Σl composes the model term ((x̃ᵀ⊗I₃)·Σθ·(x̃⊗I₃)ᵀ) with the query term (F·σ²Σq̃·Fᵀ). Two statistics per trial: `(pointwise, wholeline)— pointwise at one random station on the nominal line against the χ²₁ band; whole-line over the visible span against the χ²₂ band (the H–Z whole-line convention). Returnsnothingon tracking divergence / degenerate anchor / query line missing the view.npts(default 7 for F, 5 for E),estimate,covariance`: the hooks (see the chart-domain section header).

cameras = (cam1, cam2) (:E only) makes the trial camera-aware: the COMPUTATION correspondences are projected through two real cameras, perturbed in PIXELS with σ_px, and handed to the estimate and the covariance (the hooks, or the defaults) as bearings carrying M₁/M₂. See essential_trial for why the noise model must move with them, and use two different focal lengths.

The QUERY does not move. An essential matrix's epipolar line is a calibrated-plane object, so the query point, the line and the band stay there, and the query's noise is carried into that plane through view 1's own linear part. Two σ in one trial is not frame MIXING — it is the rule applied once per frame, which is what "σ moves with the data" requires of a trial spanning two. The default path uses an identity carrier, so it reduces to the original expression exactly — which is what shows the generalisation did not change the case it generalises.

What this trial still CANNOT validate, and why that is a choice

A query point and a band expressed in the z = 1 chart cannot represent a ray at or past 90° from the optical axis — precisely the case the bearing work exists for. So the ESTIMATION side of this trial is now camera-general while its QUERY side remains pinhole-shaped BY CONSTRUCTION, and the harness therefore cannot validate E's output-domain covariance at a fisheye periphery. It is scoped that way deliberately, but it is exactly the kind of gap someone later assumes has been closed because the rest of the trial went camera-aware.

This is the FIFTH site of the calibrated-plane assumption in the stack — after _mapped_bearing, the deleted 2-vector _bearing lift, cheiral_pose_fast and this harness's own correspondence interface — and the first one kept on purpose rather than removed. The generalisation (a spherical band on the bearing's tangent plane) is a post-release item; until it lands, a fisheye claim about this band is unsupported by anything here.

source
VisualGeometryToolkitCore.Synthetic.essential_trial — Method
essential_trial(; σ_px, f=600.0, regime=:generic, aniso=false, img2_scale=1.0,
                npts=5, estimate=nothing, covariance=nothing, cameras=nothing)

Continuation-tracking calibration trial for the 5-dof so(3)⊕T_tS² essential chart covariance.

Default (cameras = nothing): works in K-NORMALIZED coordinates, pixel noise σ_px entering as σ = σ_px/f, as the F and H trials do.

Camera-aware (cameras = (cam1, cam2)): the scene is projected through two real CameraModels, perturbed in PIXELS with σ_px itself, and handed to the estimate and the covariance as BEARING correspondences carrying the M₁/M₂ pixel Jacobians from backproject_with_jacobian — what an essential-matrix problem takes. The default estimate and covariance read those columns (the tangent form of constraint_with_jacobians), so the hooks are optional here as everywhere. The returned covariance is scaled by σ_px², so the noise model moves into the same frame as the data rather than being left behind in calibrated units.

Use two DIFFERENT focal lengths. A per-view M₁/M₂ swap is nearly norm-preserving: measured, it moves a residual by 1.8% at f = 1200/600 but only 0.19% at equal focals, where it would hide inside anything one would call noise.

npts, estimate, covariance: the hooks (see the section header).

source
VisualGeometryToolkitCore.Synthetic.fundmat_trial — Method
fundmat_trial(; σ, regime=:generic, aniso=false, frame=:calibration,
              img2_scale=1.0, f=600.0, npts=7, estimate=nothing, covariance=nothing)

Continuation-tracking calibration trial for the Bartoli–Sturm 7-dof F chart covariance. frame = :calibration (default) runs tracking + provider + chart NEES in the mid-gauge frame fundmat_norm_xform with noise σ·s; frame = :pixel runs raw — kept to DOCUMENT the pixel-frame chart degeneracy (expected miscalibrated at every σ). npts, estimate, covariance: the hooks (see the section header); f the focal length of the scene.

source
VisualGeometryToolkitCore.Synthetic.h_transfer_trial — Method
h_transfer_trial(; σ, regime=:generic, aniso=false, img2_scale=1.0,
                 level=0.95, npts=4, estimate=nothing, covariance=nothing)

Criminisi Table 4.1 for the homography, containment form: per trial, perturb the 4 computation correspondences IN BOTH IMAGES (known per-endpoint covariances), compute the unique minimal H of the perturbed sample, perturb a query point, transfer it, and test the transferred point against the first-order level ellipse whose covariance composes the model term (transform_deriv_params(H, x) propagating the hypothesis covariance at θgt, transported to the ambient space) with the query term (`Jx·σ²Σq·Jxᵀ). Returns(contained::Bool,)ornothing(degenerate solve).npts,estimate,covariance`: the hooks (see the chart-domain section header).

source
VisualGeometryToolkitCore.Synthetic.homography_trial — Method
homography_trial(; σ, regime=:generic, aniso=false, img2_scale=1.0,
                 npts=4, estimate=nothing, covariance=nothing)

Chart-domain calibration trial for the 8-dof sl(3) homography chart covariance: base 4-point sample with θgt as its exact interpolant, known per-point perturbation, then the UNIQUE minimal solution of the perturbed sample (the 4-point problem is single-valued — no tracking device needed), expressed in the chart anchored at θgt and compared against the implicit-function covariance J·Σ̃x·Jᵀ at θgt. npts, estimate, covariance: the hooks (see the section header).

source
VisualGeometryToolkitCore.Synthetic.is_calibrated — Method
is_calibrated(r::CalibrationResult; z=4.0) -> Bool

Statistical gate: NEES mean within z standard errors of dof AND every empirical coverage within z binomial standard errors of nominal. z = 4 keeps the false-alarm rate negligible at harness trial counts while still catching a Σ that is wrong by tens of percent.

source
VisualGeometryToolkitCore.Synthetic.make_point_covs — Method
make_point_covs(rng, k; aniso=false, img2_scale=1.0) -> Vector{SMatrix{4,4}}

Unit-scale 4×4 covariance shapes, one per correspondence, block-diagonal over the TWO endpoint slots — noise is injected in BOTH images, each endpoint with its own independent 2×2 covariance (the real-data structure: per-endpoint precision, e.g. RoMa matcher covariances). aniso=true draws per-ENDPOINT rotated anisotropic 2×2 blocks with trace 2, drawn INDEPENDENTLY for the two endpoints (so the two images' covariances differ; trace 2 keeps the total variance of I₂ and σ retains its meaning); aniso=false returns isotropic blocks. img2_scale multiplies the image-2 endpoint's standard deviation (e.g. img2_scale = 3 → σ₂ = 3σ₁, the unequal-image cells).

source
VisualGeometryToolkitCore.Synthetic.make_query_cov — Method
make_query_cov(rng; aniso=false) -> SMatrix{2,2}

Unit-scale covariance shape for the QUERY point of the output-domain cells (trace-2 rotated-anisotropic when aniso, else I₂) — the observation-point noise of the Criminisi Table 4.1 protocol.

source
VisualGeometryToolkitCore.Synthetic.noise_ladder — Method
noise_ladder(make_trial, rng, ntrials, dof, σs) -> Vector{Pair{Float64,CalibrationResult}}

Run one calibration cell per noise level: make_trial(σ) must return a trial closure. Reports every rung — including the ones past the first-order breakdown (the first rung failing is_calibrated marks it).

source
VisualGeometryToolkitCore.Synthetic.perturb_pairs — Method
perturb_pairs(rng, cs, σ, shapes) -> Vector{Pair}

Add δ ~ N(0, σ²·shapes[i]) to each correspondence: to both endpoints of a two-view pair (4×4 shapes), or to the image point of a pose correspondence X => u (2×2 shapes; the 3D point is exact).

source
VisualGeometryToolkitCore.Synthetic.pnp_trial — Method
pnp_trial(; σ_px, npts, f=600.0, c=250.0, aniso=false, estimate=nothing, covariance=nothing)
p3p_trial(; σ_px, kwargs...) = pnp_trial(; σ_px, npts = 3, kwargs...)

Chart-domain calibration trial for the 6-dof pose covariance: a sample_pose_scene, per-point image noise (unit-scale 2×2 shapes, make_query_cov's law), and the estimate in the chart anchored at θgt. Defaults: the minimal P3P solution TRACKED from θgt (the P3P problem is multi-rooted; tracking keeps the trial single-valued, as for E and F) against the implicit-function covariance; with npts > 3, the tracked reprojection Gauss–Newton solution against implicit_covariance's sandwich. f sets the field of view (f = 2000 narrow, f = 150 wide at c = 250). The hooks as for the two-view trials; estimate(ch, cs_noisy) returns an EuclideanMap.

source
VisualGeometryToolkitCore.Synthetic.reprojection_trial — Method
reprojection_trial(; σ_px, npts=3, f=600.0, c=250.0, aniso=false, level=0.95,
                   estimate=nothing, covariance=nothing)

Criminisi-protocol output-domain trial for the pose: estimate the pose from npts noisy image points (as pnp_trial), then reproject a HELD-OUT 3D point and test its reprojection against its own noisy observation, inside the first-order level ellipse composing the model term (J·σ²Σ̃_v·Jᵀ, J the reprojection's derivative in the pose chart at θgt) with the query term (`σ²Σq). Returns(contained::Bool,)ornothing` (divergence / degenerate anchor).

source
VisualGeometryToolkitCore.Synthetic.run_calibration — Method
run_calibration(trial, rng, ntrials, dof; cond_cap=Inf) -> CalibrationResult

Run ntrials MC trials of trial(rng) -> nothing | (v̂, Σ_pred) and gather NEES / coverage statistics against χ²(dof). See the module header for the trial-closure contract.

cond_cap: with a finite value, the NEES is evaluated on the eigen-subspace of Σpred with λ ≥ λmax/cond_cap and compared against χ²(effective dof) — per trial. This is a numerical safeguard for problems whose predicted chart covariances are anisotropic beyond Float64 reach (predicted standard deviations in the stiffest directions below what the arithmetic of the tracked solve can realize — there the full-dof NEES measures ROUNDOFF, not statistics). The capped statistic states calibration on the numerically representable uncertainty subspace; the discarded-direction count is visible as dof < declared dof.

source
VisualGeometryToolkitCore.Synthetic.sample_homography_scene — Method
sample_homography_scene(rng; regime=:generic, npts=4) -> (H::HomographyMat, cs)

Ground-truth homography + npts source points (the first 4 well-spread, the rest uniform) in a nominal 500×500 image. Regimes: :generic (strong projective part), :near_affine (projective row ~1e-8 — the near-degenerate regime for the 8-dof chart's projective directions).

source
VisualGeometryToolkitCore.Synthetic.sample_pose_scene — Method
sample_pose_scene(rng, n; f = 600.0, c = 250.0) -> (pose::EuclideanMap{3}, cs_nm, cs_px)

A world→camera pose and n world points imaged by K = [f 0 c; 0 f c; 0 0 1]: the first ≤ 9 points one per cell of a 3×3 grid over the 2c × 2c image (as sample_twoview_scene stratifies, and for the same reason), depths 4–8, the rotation uniform. cs_nm pairs X => u with u calibrated (K⁻¹), cs_px with u in pixels. f sets the field of view: f = 2000 is narrow (14° at c = 250), f = 150 wide (118°).

source
VisualGeometryToolkitCore.Synthetic.sample_twoview_scene — Method
sample_twoview_scene(rng, k; regime=:generic, f=600.0, c=250.0)
    -> (R, t, F::FundMat, E::EssentialMat, cs_px, cs_norm, cs_bear)

Two calibrated views (shared K = diag(f, f, 1) + principal point c) observing k random 3D points; returns pixel correspondences (for F), K-normalized GNOMONIC correspondences, and UNIT BEARING correspondences (Vec3 each side, for E).

cs_bear is the calibrated currency of this stack: E, relative pose and PnP act on bearings, never on the z = 1 chart. cs_norm is the chart and is kept only for the Monte-Carlo cells that have not yet moved to the tangent Sampson; those cells migrate with the E gates, and it goes with them. New code should take cs_bear.

Appended rather than substituted on purpose: Julia's destructuring ignores trailing elements, so every existing six-way call site keeps working and nothing silently changes meaning under a positional unpack. Regimes: :generic — baseline 1, depths 4–8, rotation ~10°; :short_baseline — ‖t‖ = 0.02 vs depths 4–8 (near-degenerate E); :near_planar — depth variation 1e-3 about a plane (near-degenerate F); :forward — translation along camera 1's optical axis (t ∝ (0.1·n₁, 0.1·n₂, ±1)), both epipoles inside the 2c × 2c image (geometries resampled until they are), and a point whose PARALLAX — its displacement from the rotation-only image π(K·R·K⁻¹·ũ₁) — is under 1 px resampled: near the epipole a correspondence carries no epipolar information, and a trial built on one fails for reasons that are not the covariance's.

source
VisualGeometryToolkitCore.Synthetic.second_order_moments — Method
second_order_moments(res, out, D, x0, q0, Σδ) -> (Σ1, μ2, Σ2)

First- and second-order propagated moments of the output functional out([v; q]) under the implicitly defined chart solution v(x) of res([v; x]) = 0 (D equations, res([0; x0]) = 0 at the anchor), with Gaussian input δ = (x − x0, q − q0) ~ N(0, Σδ).

Returns the first-order output covariance Σ1 = J·Σδ·Jᵀ, the second-order mean shift μ2[c] = ½·tr(Q_c·Σδ), and the second-order covariance Σ2[c,d] = Σ1[c,d] + ½·tr(Q_c·Σδ·Q_d·Σδ) (Gaussian fourth-moment identity), where Q_c is the full second derivative of output component c with respect to δ, assembled from the implicit first/second derivatives of v(x) (implicit function theorem, differentiated twice) and the ForwardDiff Hessians of res and out.

source
VisualGeometryToolkitCore.Synthetic.track_manifold_solution — Method
track_manifold_solution(ch, cs_clean, cs_noisy;
                     stages=4, tol=1e-11, maxiter=50, min_dt=1/64)
    -> SVector{tangent_size(ch)} | nothing

Damped chart-Newton CONTINUATION of the local constrained solution: the observations are moved from cs_clean (on the constraint variety — the anchor of ch solves g exactly there) to cs_noisy along the linear data homotopy, each stage solved by damped Newton on g(v, xt) = 0 warm-started at the previous stage's solution. The stage size starts at 1/stages and is BISECTED adaptively whenever a stage fails to converge (standard continuation practice — strong constraint curvature shrinks the per-stage Newton basin). Returns the tracked chart coordinates of the local solution of g(v, xnoisy) = 0, or nothing when a stage still fails at min_dt — the DIVERGENCE event reported by the calibration tables: at that noise level the perturbation left the continuation radius of this sample's geometry.

source

Index