do_optimize_intrinsics_core = True,
do_optimize_intrinsics_distortions = True,
do_optimize_extrinsics = True,
imagersizes = imagersizes,
calibration_object_spacing = object_spacing,
do_apply_regularization = True)
mrcal.optimize(**baseline, do_apply_outlier_rejection=False)
# Done setting up. I'll be looking at tiny motions off the baseline
Nframes = len(frames_ref)
Ncameras = len(intrinsics_ref)
lensmodel = baseline['lensmodel']
Nintrinsics = mrcal.lensmodel_num_params(lensmodel)
Nmeasurements_boards = mrcal.num_measurements_boards(**baseline)
Nmeasurements_regularization = mrcal.num_measurements_regularization(
**baseline)
p0, x0, J0 = mrcal.optimizer_callback(no_factorization=True, **baseline)[:3]
J0 = J0.toarray()
###########################################################################
# First a very basic gradient check. Looking at an arbitrary camera's
# intrinsics. The test-gradients tool does this much more thoroughly
optimization_inputs = copy.deepcopy(baseline)
dp_packed = np.random.randn(len(p0)) * 1e-9
mrcal.ingest_packed_state(p0 + dp_packed, **optimization_inputs)
x1 = mrcal.optimizer_callback(no_factorization=True,
4,
"num_intrinsics_optimization_params()")
testutils.confirm_equal( mrcal.num_states_extrinsics(**optimization_inputs),
6*(Ncameras-1),
"num_states_extrinsics()")
testutils.confirm_equal( mrcal.num_states_frames(**optimization_inputs),
6*Nframes,
"num_states_frames()")
testutils.confirm_equal( mrcal.num_states_points(**optimization_inputs),
0,
"num_states_points()")
testutils.confirm_equal( mrcal.num_states_calobject_warp(**optimization_inputs),
0,
"num_states_calobject_warp()")
testutils.confirm_equal( mrcal.num_measurements_boards(**optimization_inputs),
object_width_n*object_height_n*2*Nframes*Ncameras,
"num_measurements_boards()")
testutils.confirm_equal( mrcal.num_measurements_points(**optimization_inputs),
0,
"num_measurements_points()")
testutils.confirm_equal( mrcal.num_measurements_regularization(**optimization_inputs),
Ncameras * 2,
"num_measurements_regularization()")
optimization_inputs['do_optimize_intrinsics_core'] = True
optimization_inputs['do_optimize_intrinsics_distortions'] = True
optimization_inputs['do_optimize_extrinsics'] = True
optimization_inputs['do_optimize_frames'] = True
optimization_inputs['do_optimize_calobject_warp'] = True
optimization_inputs['do_optimize_calobject_warp'] = False
mrcal.optimize(**optimization_inputs, do_apply_outlier_rejection=True)
testutils.confirm_equal(mrcal.num_states_intrinsics(**optimization_inputs),
4 * Ncameras, "num_states_intrinsics()")
testutils.confirm_equal(mrcal.num_states_extrinsics(**optimization_inputs),
6 * (Ncameras - 1), "num_states_extrinsics()")
testutils.confirm_equal(mrcal.num_states_frames(**optimization_inputs),
6 * Nframes, "num_states_frames()")
testutils.confirm_equal(mrcal.num_states_points(**optimization_inputs), 0,
"num_states_points()")
testutils.confirm_equal(mrcal.num_states_calobject_warp(**optimization_inputs),
0, "num_states_calobject_warp()")
testutils.confirm_equal(
mrcal.num_measurements_boards(**optimization_inputs),
object_width_n * object_height_n * 2 * Nframes * Ncameras,
"num_measurements_boards()")
testutils.confirm_equal(mrcal.num_measurements_points(**optimization_inputs),
0, "num_measurements_points()")
testutils.confirm_equal(
mrcal.num_measurements_regularization(**optimization_inputs), Ncameras * 2,
"num_measurements_regularization()")
optimization_inputs['do_optimize_intrinsics_core'] = True
optimization_inputs['do_optimize_intrinsics_distortions'] = True
optimization_inputs['do_optimize_extrinsics'] = True
optimization_inputs['do_optimize_frames'] = True
optimization_inputs['do_optimize_calobject_warp'] = True
optimization_inputs['calobject_warp'] = np.array((0.001, 0.001))
for ipt in range(Npoints):
dp_triangulated_dq_empirical[ipt,...] = dp_triangulated_dq_empirical_cross_only[ipt,:,ipt,:,:]
dp_triangulated_dq_empirical_cross_only[ipt,:,ipt,:,:] = 0
testutils.confirm_equal(dp_triangulated_dq_empirical_cross_only,
0,
eps = 1e-6,
msg = "Gradient check: dp_triangulated_dq: cross-point terms are 0")
testutils.confirm_equal(dp_triangulated_dq,
dp_triangulated_dq_empirical,
relative = True,
worstcase = True,
eps = 1e-6,
msg = "Gradient check: dp_triangulated_dq")
Nmeasurements_observations = mrcal.num_measurements_boards(**optimization_inputs_baseline)
if Nmeasurements_observations == mrcal.num_measurements(**optimization_inputs_baseline):
# Note the special-case where I'm using all the observations
Nmeasurements_observations = None
# I look at the two triangulated points together. This is a (6,) vector. And I
# pack the denominator by unpacking the numerator
dp0p1_triangulated_dppacked = copy.deepcopy(dp_triangulated_dpstate)
mrcal.unpack_state(dp0p1_triangulated_dppacked, **optimization_inputs_baseline)
dp0p1_triangulated_dppacked = nps.clump(dp0p1_triangulated_dppacked,n=2)
# My input vector, whose noise I'm propagating, is x = [q_calibration
# q_triangulation]: the calibration-time pixel observations and the
# observation-time pixel observations. These are independent, so Var(x) is
# block-diagonal. I want to propagate the noise in x to some function f(x). As