[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [60214] branches/soc-2013-motion_track/ extern/libmv: Multicamera-ify bundle adjustment
Joseph Mansfield
sftrabbit at gmail.com
Wed Sep 18 03:33:42 CEST 2013
Revision: 60214
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=60214
Author: sftrabbit
Date: 2013-09-18 01:33:40 +0000 (Wed, 18 Sep 2013)
Log Message:
-----------
Multicamera-ify bundle adjustment
Bundle adjustment now uses the appropriate camera intrinsics when calculating the reprojection error for each marker. Refinement options are currently only applied to the camera intrinsics for camera 0 (all other camera intrinsics are made constant).
Modified Paths:
--------------
branches/soc-2013-motion_track/extern/libmv/libmv/simple_pipeline/bundle.cc
branches/soc-2013-motion_track/extern/libmv/libmv/simple_pipeline/bundle.h
branches/soc-2013-motion_track/extern/libmv/libmv/simple_pipeline/keyframe_selection.cc
branches/soc-2013-motion_track/extern/libmv/libmv-capi.cc
Modified: branches/soc-2013-motion_track/extern/libmv/libmv/simple_pipeline/bundle.cc
===================================================================
--- branches/soc-2013-motion_track/extern/libmv/libmv/simple_pipeline/bundle.cc 2013-09-18 01:22:28 UTC (rev 60213)
+++ branches/soc-2013-motion_track/extern/libmv/libmv/simple_pipeline/bundle.cc 2013-09-18 01:33:40 UTC (rev 60214)
@@ -188,57 +188,64 @@
// Pack intrinsics from object to an array for easier
// and faster minimization, constraining the focal length
// according to the given BundleOptions.
-void PackIntrinsicsIntoArray(const CameraIntrinsics &intrinsics,
- const BundleOptions &bundle_options,
- double ceres_intrinsics[8]) {
- if (bundle_options.constraints & BUNDLE_CONSTRAIN_FOCAL_LENGTH) {
- ceres_intrinsics[OFFSET_FOCAL_LENGTH] = ConstrainFocalLength(
- intrinsics.focal_length(),
- bundle_options.focal_length_min,
- bundle_options.focal_length_max);
- } else {
- ceres_intrinsics[OFFSET_FOCAL_LENGTH] = intrinsics.focal_length();
+vector<Vec8> PackIntrinsics(const std::vector<CameraIntrinsics> &intrinsics,
+ const BundleOptions &bundle_options) {
+ int num_intrinsics = intrinsics.size();
+ vector<Vec8> ceres_intrinsics(num_intrinsics);
+
+ for (int i = 0; i < num_intrinsics; ++i) {
+ if (bundle_options.constraints & BUNDLE_CONSTRAIN_FOCAL_LENGTH) {
+ ceres_intrinsics[i][OFFSET_FOCAL_LENGTH] = ConstrainFocalLength(
+ intrinsics[i].focal_length(),
+ bundle_options.focal_length_min,
+ bundle_options.focal_length_max);
+ } else {
+ ceres_intrinsics[i][OFFSET_FOCAL_LENGTH] = intrinsics[i].focal_length();
+ }
+ ceres_intrinsics[i][OFFSET_PRINCIPAL_POINT_X] = intrinsics[i].principal_point_x();
+ ceres_intrinsics[i][OFFSET_PRINCIPAL_POINT_Y] = intrinsics[i].principal_point_y();
+ ceres_intrinsics[i][OFFSET_K1] = intrinsics[i].k1();
+ ceres_intrinsics[i][OFFSET_K2] = intrinsics[i].k2();
+ ceres_intrinsics[i][OFFSET_K3] = intrinsics[i].k3();
+ ceres_intrinsics[i][OFFSET_P1] = intrinsics[i].p1();
+ ceres_intrinsics[i][OFFSET_P2] = intrinsics[i].p2();
}
- ceres_intrinsics[OFFSET_PRINCIPAL_POINT_X] = intrinsics.principal_point_x();
- ceres_intrinsics[OFFSET_PRINCIPAL_POINT_Y] = intrinsics.principal_point_y();
- ceres_intrinsics[OFFSET_K1] = intrinsics.k1();
- ceres_intrinsics[OFFSET_K2] = intrinsics.k2();
- ceres_intrinsics[OFFSET_K3] = intrinsics.k3();
- ceres_intrinsics[OFFSET_P1] = intrinsics.p1();
- ceres_intrinsics[OFFSET_P2] = intrinsics.p2();
-}
-// Unpack intrinsics back from an array to an object.
-void UnpackIntrinsicsFromArray(const double ceres_intrinsics[8],
- CameraIntrinsics *intrinsics) {
+ return ceres_intrinsics;
}
// Unpack intrinsics back from an array to an object, converting
// unconstrained bundle parameter to constrained focal length.
-void UnpackIntrinsicsFromArray(const double ceres_intrinsics[8],
- const BundleOptions &bundle_options,
- CameraIntrinsics *intrinsics) {
- if (bundle_options.constraints & BUNDLE_CONSTRAIN_FOCAL_LENGTH) {
- double focal_length = UnconstrainFocalLength(
- ceres_intrinsics[OFFSET_FOCAL_LENGTH],
- bundle_options.focal_length_min,
- bundle_options.focal_length_max);
- intrinsics->SetFocalLength(focal_length, focal_length);
- } else {
- intrinsics->SetFocalLength(ceres_intrinsics[OFFSET_FOCAL_LENGTH],
- ceres_intrinsics[OFFSET_FOCAL_LENGTH]);
- }
+std::vector<CameraIntrinsics> UnpackIntrinsics(
+ const vector<Vec8> &ceres_intrinsics,
+ const BundleOptions &bundle_options) {
+ int num_intrinsics = ceres_intrinsics.size();
+ std::vector<CameraIntrinsics> intrinsics(num_intrinsics);
- intrinsics->SetPrincipalPoint(ceres_intrinsics[OFFSET_PRINCIPAL_POINT_X],
- ceres_intrinsics[OFFSET_PRINCIPAL_POINT_Y]);
+ for (int i = 0; i < num_intrinsics; ++i) {
+ if (bundle_options.constraints & BUNDLE_CONSTRAIN_FOCAL_LENGTH) {
+ double focal_length = UnconstrainFocalLength(
+ ceres_intrinsics[i][OFFSET_FOCAL_LENGTH],
+ bundle_options.focal_length_min,
+ bundle_options.focal_length_max);
+ intrinsics[i].SetFocalLength(focal_length, focal_length);
+ } else {
+ intrinsics[i].SetFocalLength(ceres_intrinsics[i][OFFSET_FOCAL_LENGTH],
+ ceres_intrinsics[i][OFFSET_FOCAL_LENGTH]);
+ }
- intrinsics->SetRadialDistortion(ceres_intrinsics[OFFSET_K1],
- ceres_intrinsics[OFFSET_K2],
- ceres_intrinsics[OFFSET_K3]);
+ intrinsics[i].SetPrincipalPoint(ceres_intrinsics[i][OFFSET_PRINCIPAL_POINT_X],
+ ceres_intrinsics[i][OFFSET_PRINCIPAL_POINT_Y]);
- intrinsics->SetTangentialDistortion(ceres_intrinsics[OFFSET_P1],
- ceres_intrinsics[OFFSET_P2]);
+ intrinsics[i].SetRadialDistortion(ceres_intrinsics[i][OFFSET_K1],
+ ceres_intrinsics[i][OFFSET_K2],
+ ceres_intrinsics[i][OFFSET_K3]);
+ intrinsics[i].SetTangentialDistortion(ceres_intrinsics[i][OFFSET_P1],
+ ceres_intrinsics[i][OFFSET_P2]);
+ }
+
+ return intrinsics;
}
// Get a vector of camera's rotations denoted by angle axis
@@ -246,13 +253,13 @@
//
// Element with index i matches to a rotation+translation for
// camera at image i.
-vector<Vec6> PackCamerasRotationAndTranslation(
+vector<Vec6> PackViewsRotationAndTranslation(
const Tracks &tracks,
const EuclideanReconstruction &reconstruction) {
- vector<Vec6> all_cameras_R_t;
+ vector<Vec6> all_views_R_t;
int max_image = tracks.MaxImage();
- all_cameras_R_t.resize(max_image + 1);
+ all_views_R_t.resize(max_image + 1);
for (int i = 0; i <= max_image; i++) {
const EuclideanView *view = reconstruction.ViewForImage(i);
@@ -262,16 +269,16 @@
}
ceres::RotationMatrixToAngleAxis(&view->R(0, 0),
- &all_cameras_R_t[i](0));
- all_cameras_R_t[i].tail<3>() = view->t;
+ &all_views_R_t[i](0));
+ all_views_R_t[i].tail<3>() = view->t;
}
- return all_cameras_R_t;
+ return all_views_R_t;
}
// Convert cameras rotations fro mangle axis back to rotation matrix.
-void UnpackCamerasRotationAndTranslation(
+void UnpackViewsRotationAndTranslation(
const Tracks &tracks,
- const vector<Vec6> &all_cameras_R_t,
+ const vector<Vec6> &all_views_R_t,
EuclideanReconstruction *reconstruction) {
int max_image = tracks.MaxImage();
@@ -282,9 +289,9 @@
continue;
}
- ceres::AngleAxisToRotationMatrix(&all_cameras_R_t[i](0),
+ ceres::AngleAxisToRotationMatrix(&all_views_R_t[i](0),
&view->R(0, 0));
- view->t = all_cameras_R_t[i].tail<3>();
+ view->t = all_views_R_t[i].tail<3>();
}
}
@@ -387,11 +394,11 @@
EuclideanReconstruction *reconstruction) {
BundleOptions bundle_options;
- CameraIntrinsics empty_intrinsics;
+ std::vector<CameraIntrinsics> empty_intrinsics(tracks.MaxCamera()+1);
EuclideanBundleCommonIntrinsics(tracks,
bundle_options,
reconstruction,
- &empty_intrinsics);
+ empty_intrinsics);
}
void EuclideanBundleModal(const Tracks &tracks,
@@ -399,22 +406,22 @@
BundleOptions bundle_options;
bundle_options.constraints = libmv::BUNDLE_NO_TRANSLATION;
- CameraIntrinsics empty_intrinsics;
+ std::vector<CameraIntrinsics> empty_intrinsics(tracks.MaxCamera()+1);
EuclideanBundleCommonIntrinsics(tracks,
bundle_options,
reconstruction,
- &empty_intrinsics);
+ empty_intrinsics);
}
void EuclideanBundleCommonIntrinsics(const Tracks &tracks,
const BundleOptions &bundle_options,
EuclideanReconstruction *reconstruction,
- CameraIntrinsics *intrinsics,
+ std::vector<CameraIntrinsics> &intrinsics,
BundleEvaluation *evaluation) {
const int bundle_intrinsics = bundle_options.bundle_intrinsics;
const int bundle_constraints = bundle_options.constraints;
- LG << "Original intrinsics: " << *intrinsics;
+ //LG << "Original intrinsics: " << *intrinsics;
vector<Marker> markers = tracks.AllMarkers();
ceres::Problem::Options problem_options;
@@ -423,18 +430,15 @@
// Residual blocks with 10 parameters are unwieldly with Ceres, so pack the
// intrinsics into a single block and rely on local parameterizations to
// control which intrinsics are allowed to vary.
- double ceres_intrinsics[8];
- PackIntrinsicsIntoArray(*intrinsics,
- bundle_options,
- ceres_intrinsics);
+ vector<Vec8> ceres_intrinsics = PackIntrinsics(intrinsics, bundle_options);
- // Convert cameras rotations to angle axis and merge with translation
+ // Convert views rotations to angle axis and merge with translation
// into single parameter block for maximal minimization speed.
//
// Block for minimization has got the following structure:
// <3 elements for angle-axis> <3 elements for translation>
- vector<Vec6> all_cameras_R_t =
- PackCamerasRotationAndTranslation(tracks, *reconstruction);
+ vector<Vec6> all_views_R_t =
+ PackViewsRotationAndTranslation(tracks, *reconstruction);
// Parameterization used to restrict camera motion for modal solvers.
ceres::SubsetParameterization *constant_translation_parameterization = NULL;
@@ -452,7 +456,7 @@
// Add residual blocks to the problem.
int num_residuals = 0;
- bool have_locked_camera = false;
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list