Cr8-xyz/blender
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

code cleanup: camera tracking

Browse Source 
- Moved keyframes and refirement flags into reconstruction options structure
- Moved distortion coefficients and other camera intrinsics into own structure
- Cleaned up reconstruction functions in libmv c-api

---
svn merge -r52853:52854 ^/branches/soc-2011-tomato
This commit is contained in:
Sergey Sharybin
2013-02-25 09:24:31 +00:00
parent 66cca267b1
commit 12baa00b6a
3 changed files with 140 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
extern/libmv/libmv-capi.cpp vendored
View File

@@ -552,40 +552,78 @@ static void libmv_solveRefineIntrinsics(libmv::Tracks *tracks, libmv::CameraIntr
reconstruction, intrinsics); reconstruction, intrinsics);
} }
libmv_Reconstruction *libmv_solveReconstruction(libmv_Tracks *tracks, int keyframe1, int keyframe2, static void cameraIntrinsicsFromOptions(libmv::CameraIntrinsics *camera_intrinsics,
int refine_intrinsics, double focal_length, double principal_x, double principal_y, libmv_cameraIntrinsicsOptions *camera_intrinsics_options)
double k1, double k2, double k3, struct libmv_reconstructionOptions *options, {
reconstruct_progress_update_cb progress_update_callback, void *callback_customdata) camera_intrinsics->SetFocalLength(camera_intrinsics_options->focal_length,
camera_intrinsics_options->focal_length);
camera_intrinsics->SetPrincipalPoint(camera_intrinsics_options->principal_point_x,
camera_intrinsics_options->principal_point_y);
camera_intrinsics->SetRadialDistortion(camera_intrinsics_options->k1,
camera_intrinsics_options->k2,
camera_intrinsics_options->k3);
}
static libmv::Tracks getNormalizedTracks(libmv::Tracks *tracks, libmv::CameraIntrinsics *camera_intrinsics)
{
libmv::vector<libmv::Marker> markers = tracks->AllMarkers();
for (int i = 0; i < markers.size(); ++i) {
camera_intrinsics->InvertIntrinsics(markers[i].x, markers[i].y,
&(markers[i].x), &(markers[i].y));
}
return libmv::Tracks(markers);
}
static void finishReconstruction(libmv::Tracks *tracks, libmv::CameraIntrinsics *camera_intrinsics,
libmv_Reconstruction *libmv_reconstruction,
reconstruct_progress_update_cb progress_update_callback,
void *callback_customdata)
{ {
/* Invert the camera intrinsics. */
libmv::vector<libmv::Marker> markers = ((libmv::Tracks*)tracks)->AllMarkers();
libmv_Reconstruction *libmv_reconstruction = new libmv_Reconstruction();
libmv::EuclideanReconstruction *reconstruction = &libmv_reconstruction->reconstruction; libmv::EuclideanReconstruction *reconstruction = &libmv_reconstruction->reconstruction;
libmv::CameraIntrinsics *intrinsics = &libmv_reconstruction->intrinsics;
libmv::ReconstructionOptions reconstruction_options; /* reprojection error calculation */
progress_update_callback(callback_customdata, 1.0, "Finishing solution");
libmv_reconstruction->tracks = *tracks;
libmv_reconstruction->error = libmv::EuclideanReprojectionError(*tracks, *reconstruction, *camera_intrinsics);
}
libmv_Reconstruction *libmv_solveReconstruction(libmv_Tracks *libmv_tracks,
libmv_cameraIntrinsicsOptions *libmv_camera_intrinsics_options,
libmv_reconstructionOptions *libmv_reconstruction_options,
reconstruct_progress_update_cb progress_update_callback,
void *callback_customdata)
{
libmv_Reconstruction *libmv_reconstruction = new libmv_Reconstruction();
libmv::Tracks *tracks = ((libmv::Tracks *) libmv_tracks);
libmv::EuclideanReconstruction *reconstruction = &libmv_reconstruction->reconstruction;
libmv::CameraIntrinsics *camera_intrinsics = &libmv_reconstruction->intrinsics;
ReconstructUpdateCallback update_callback = ReconstructUpdateCallback update_callback =
ReconstructUpdateCallback(progress_update_callback, callback_customdata); ReconstructUpdateCallback(progress_update_callback, callback_customdata);
intrinsics->SetFocalLength(focal_length, focal_length); cameraIntrinsicsFromOptions(camera_intrinsics, libmv_camera_intrinsics_options);
intrinsics->SetPrincipalPoint(principal_x, principal_y);
intrinsics->SetRadialDistortion(k1, k2, k3);
reconstruction_options.success_threshold = options->success_threshold; /* Invert the camera intrinsics */
reconstruction_options.use_fallback_reconstruction = options->use_fallback_reconstruction; libmv::Tracks normalized_tracks = getNormalizedTracks(tracks, camera_intrinsics);
for (int i = 0; i < markers.size(); ++i) { /* actual reconstruction */
intrinsics->InvertIntrinsics(markers[i].x, libmv::ReconstructionOptions reconstruction_options;
markers[i].y, reconstruction_options.success_threshold = libmv_reconstruction_options->success_threshold;
&(markers[i].x), reconstruction_options.use_fallback_reconstruction = libmv_reconstruction_options->use_fallback_reconstruction;
&(markers[i].y));
}
libmv::Tracks normalized_tracks(markers); int keyframe1 = libmv_reconstruction_options->keyframe1,
keyframe2 = libmv_reconstruction_options->keyframe2;
LG << "frames to init from: " << keyframe1 << " " << keyframe2; LG << "frames to init from: " << keyframe1 << " " << keyframe2;
libmv::vector<libmv::Marker> keyframe_markers = libmv::vector<libmv::Marker> keyframe_markers =
normalized_tracks.MarkersForTracksInBothImages(keyframe1, keyframe2); normalized_tracks.MarkersForTracksInBothImages(keyframe1, keyframe2);
LG << "number of markers for init: " << keyframe_markers.size(); LG << "number of markers for init: " << keyframe_markers.size();
update_callback.invoke(0, "Initial reconstruction"); update_callback.invoke(0, "Initial reconstruction");
@@ -595,49 +633,45 @@ libmv_Reconstruction *libmv_solveReconstruction(libmv_Tracks *tracks, int keyfra
libmv::EuclideanCompleteReconstruction(reconstruction_options, normalized_tracks, libmv::EuclideanCompleteReconstruction(reconstruction_options, normalized_tracks,
reconstruction, &update_callback); reconstruction, &update_callback);
if (refine_intrinsics) { /* refinement */
libmv_solveRefineIntrinsics((libmv::Tracks *)tracks, intrinsics, reconstruction, if (libmv_reconstruction_options->refine_intrinsics) {
refine_intrinsics, progress_update_callback, callback_customdata); libmv_solveRefineIntrinsics((libmv::Tracks *)tracks, camera_intrinsics, reconstruction,
libmv_reconstruction_options->refine_intrinsics,
progress_update_callback, callback_customdata);
} }
progress_update_callback(callback_customdata, 1.0, "Finishing solution"); /* finish reconstruction */
libmv_reconstruction->tracks = *(libmv::Tracks *)tracks; finishReconstruction(tracks, camera_intrinsics, libmv_reconstruction,
libmv_reconstruction->error = libmv::EuclideanReprojectionError(*(libmv::Tracks *)tracks, *reconstruction, *intrinsics); progress_update_callback, callback_customdata);
return (libmv_Reconstruction *)libmv_reconstruction; return (libmv_Reconstruction *)libmv_reconstruction;
} }
struct libmv_Reconstruction *libmv_solveModal(struct libmv_Tracks *tracks, double focal_length, struct libmv_Reconstruction *libmv_solveModal(struct libmv_Tracks *libmv_tracks,
double principal_x, double principal_y, double k1, double k2, double k3, libmv_cameraIntrinsicsOptions *libmv_camera_intrinsics_options,
reconstruct_progress_update_cb progress_update_callback, void *callback_customdata) reconstruct_progress_update_cb progress_update_callback,
void *callback_customdata)
{ {
/* Invert the camera intrinsics. */
libmv::vector<libmv::Marker> markers = ((libmv::Tracks*)tracks)->AllMarkers();
libmv_Reconstruction *libmv_reconstruction = new libmv_Reconstruction(); libmv_Reconstruction *libmv_reconstruction = new libmv_Reconstruction();
libmv::Tracks *tracks = ((libmv::Tracks *) libmv_tracks);
libmv::EuclideanReconstruction *reconstruction = &libmv_reconstruction->reconstruction; libmv::EuclideanReconstruction *reconstruction = &libmv_reconstruction->reconstruction;
libmv::CameraIntrinsics *intrinsics = &libmv_reconstruction->intrinsics; libmv::CameraIntrinsics *camera_intrinsics = &libmv_reconstruction->intrinsics;
ReconstructUpdateCallback update_callback = ReconstructUpdateCallback update_callback =
ReconstructUpdateCallback(progress_update_callback, callback_customdata); ReconstructUpdateCallback(progress_update_callback, callback_customdata);
intrinsics->SetFocalLength(focal_length, focal_length); cameraIntrinsicsFromOptions(camera_intrinsics, libmv_camera_intrinsics_options);
intrinsics->SetPrincipalPoint(principal_x, principal_y);
intrinsics->SetRadialDistortion(k1, k2, k3);
for (int i = 0; i < markers.size(); ++i) { /* Invert the camera intrinsics */
intrinsics->InvertIntrinsics(markers[i].x, libmv::Tracks normalized_tracks = getNormalizedTracks(tracks, camera_intrinsics);
markers[i].y,
&(markers[i].x),
&(markers[i].y));
}
libmv::Tracks normalized_tracks(markers);
/* actual reconstruction */
libmv::ModalSolver(normalized_tracks, reconstruction, &update_callback); libmv::ModalSolver(normalized_tracks, reconstruction, &update_callback);
progress_update_callback(callback_customdata, 1.0, "Finishing solution"); /* finish reconstruction */
libmv_reconstruction->tracks = *(libmv::Tracks *)tracks; finishReconstruction(tracks, camera_intrinsics, libmv_reconstruction,
libmv_reconstruction->error = libmv::EuclideanReprojectionError(*(libmv::Tracks *)tracks, *reconstruction, *intrinsics); progress_update_callback, callback_customdata);
return (libmv_Reconstruction *)libmv_reconstruction; return (libmv_Reconstruction *)libmv_reconstruction;
} }

38
extern/libmv/libmv-capi.h vendored
View File

@@ -86,28 +86,40 @@ void libmv_tracksInsert(struct libmv_Tracks *libmv_tracks, int image, int track,
void libmv_tracksDestroy(struct libmv_Tracks *libmv_tracks); void libmv_tracksDestroy(struct libmv_Tracks *libmv_tracks);
/* Reconstruction solver */ /* Reconstruction solver */
#define LIBMV_REFINE_FOCAL_LENGTH (1<<0)
#define LIBMV_REFINE_PRINCIPAL_POINT (1<<1)
#define LIBMV_REFINE_RADIAL_DISTORTION_K1 (1<<2)
#define LIBMV_REFINE_RADIAL_DISTORTION_K2 (1<<4)
/* TODO: make keyframes/distortion model a part of options? */ #define LIBMV_REFINE_FOCAL_LENGTH (1 << 0)
struct libmv_reconstructionOptions { #define LIBMV_REFINE_PRINCIPAL_POINT (1 << 1)
#define LIBMV_REFINE_RADIAL_DISTORTION_K1 (1 << 2)
#define LIBMV_REFINE_RADIAL_DISTORTION_K2 (1 << 4)
typedef struct libmv_cameraIntrinsicsOptions {
double focal_length;
double principal_point_x, principal_point_y;
double k1, k2, k3;
double p1, p2;
} libmv_cameraIntrinsicsOptions;
typedef struct libmv_reconstructionOptions {
int keyframe1, keyframe2;
int refine_intrinsics;
double success_threshold; double success_threshold;
int use_fallback_reconstruction; int use_fallback_reconstruction;
}; } libmv_reconstructionOptions;
typedef void (*reconstruct_progress_update_cb) (void *customdata, double progress, const char *message); typedef void (*reconstruct_progress_update_cb) (void *customdata, double progress, const char *message);
int libmv_refineParametersAreValid(int parameters); int libmv_refineParametersAreValid(int parameters);
struct libmv_Reconstruction *libmv_solveReconstruction(struct libmv_Tracks *tracks, int keyframe1, int keyframe2, struct libmv_Reconstruction *libmv_solveReconstruction(struct libmv_Tracks *libmv_tracks,
int refine_intrinsics, double focal_length, double principal_x, double principal_y, double k1, double k2, double k3, libmv_cameraIntrinsicsOptions *libmv_camera_intrinsics_options,
struct libmv_reconstructionOptions *options, reconstruct_progress_update_cb progress_update_callback, libmv_reconstructionOptions *libmv_reconstruction_options,
reconstruct_progress_update_cb progress_update_callback,
void *callback_customdata);
struct libmv_Reconstruction *libmv_solveModal(struct libmv_Tracks *libmv_tracks,
libmv_cameraIntrinsicsOptions *libmv_camera_intrinsics_options,
reconstruct_progress_update_cb progress_update_callback,
void *callback_customdata); void *callback_customdata);
struct libmv_Reconstruction *libmv_solveModal(struct libmv_Tracks *tracks, double focal_length,
double principal_x, double principal_y, double k1, double k2, double k3,
reconstruct_progress_update_cb progress_update_callback, void *callback_customdata);
int libmv_reporojectionPointForTrack(struct libmv_Reconstruction *libmv_reconstruction, int track, double pos[3]); int libmv_reporojectionPointForTrack(struct libmv_Reconstruction *libmv_reconstruction, int track, double pos[3]);
double libmv_reporojectionErrorForTrack(struct libmv_Reconstruction *libmv_reconstruction, int track); double libmv_reporojectionErrorForTrack(struct libmv_Reconstruction *libmv_reconstruction, int track);
double libmv_reporojectionErrorForImage(struct libmv_Reconstruction *libmv_reconstruction, int image); double libmv_reporojectionErrorForImage(struct libmv_Reconstruction *libmv_reconstruction, int image);

48
source/blender/blenkernel/intern/tracking.c
View File

@@ -2996,6 +2996,31 @@ static void reconstruct_update_solve_cb(void *customdata, double progress, const
BLI_snprintf(progressdata->stats_message, progressdata->message_size, "Solving camera | %s", message); BLI_snprintf(progressdata->stats_message, progressdata->message_size, "Solving camera | %s", message);
} }
static void camraIntrincicsOptionsFromContext(libmv_cameraIntrinsicsOptions *camera_intrinsics_options,
MovieReconstructContext *context)
{
camera_intrinsics_options->focal_length = context->focal_length;
camera_intrinsics_options->principal_point_x = context->principal_point[0];
camera_intrinsics_options->principal_point_y = context->principal_point[1];
camera_intrinsics_options->k1 = context->k1;
camera_intrinsics_options->k2 = context->k2;
camera_intrinsics_options->k3 = context->k3;
}
static void reconstructionOptionsFromContext(libmv_reconstructionOptions *reconstruction_options,
MovieReconstructContext *context)
{
reconstruction_options->keyframe1 = context->keyframe1;
reconstruction_options->keyframe2 = context->keyframe2;
reconstruction_options->refine_intrinsics = context->refine_flags;
reconstruction_options->success_threshold = context->success_threshold;
reconstruction_options->use_fallback_reconstruction = context->use_fallback_reconstruction;
}
#endif #endif
void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, short *stop, short *do_update, void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, short *stop, short *do_update,
@@ -3006,32 +3031,27 @@ void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, short *
ReconstructProgressData progressdata; ReconstructProgressData progressdata;
libmv_cameraIntrinsicsOptions camera_intrinsics_options;
libmv_reconstructionOptions reconstruction_options;
progressdata.stop = stop; progressdata.stop = stop;
progressdata.do_update = do_update; progressdata.do_update = do_update;
progressdata.progress = progress; progressdata.progress = progress;
progressdata.stats_message = stats_message; progressdata.stats_message = stats_message;
progressdata.message_size = message_size; progressdata.message_size = message_size;
camraIntrincicsOptionsFromContext(&camera_intrinsics_options, context);
reconstructionOptionsFromContext(&reconstruction_options, context);
if (context->motion_flag & TRACKING_MOTION_MODAL) { if (context->motion_flag & TRACKING_MOTION_MODAL) {
context->reconstruction = libmv_solveModal(context->tracks, context->reconstruction = libmv_solveModal(context->tracks,
context->focal_length, &camera_intrinsics_options,
context->principal_point[0], context->principal_point[1],
context->k1, context->k2, context->k3,
reconstruct_update_solve_cb, &progressdata); reconstruct_update_solve_cb, &progressdata);
} }
else { else {
struct libmv_reconstructionOptions options;
options.success_threshold = context->success_threshold;
options.use_fallback_reconstruction = context->use_fallback_reconstruction;
context->reconstruction = libmv_solveReconstruction(context->tracks, context->reconstruction = libmv_solveReconstruction(context->tracks,
context->keyframe1, context->keyframe2, &camera_intrinsics_options,
context->refine_flags, &reconstruction_options,
context->focal_length,
context->principal_point[0], context->principal_point[1],
context->k1, context->k2, context->k3,
&options,
reconstruct_update_solve_cb, &progressdata); reconstruct_update_solve_cb, &progressdata);
} }