Camera tracking: support of tripod motion solving
authorSergey Sharybin <sergey.vfx@gmail.com>
Sat, 14 Apr 2012 12:02:47 +0000 (12:02 +0000)
committerSergey Sharybin <sergey.vfx@gmail.com>
Sat, 14 Apr 2012 12:02:47 +0000 (12:02 +0000)
Expose option into interface to use modal solver which currently
supports only tripod motion.

This solver requires two tracks at least to reconstruct motion.
Using more tracks aren't improving solution in general, just adds
instability into solution and slows down things a lot.

Refirement of camera intrinsics is supported by this solver.

To use this solver just activate "Tripod Motion" checkbox in
solver panel.

extern/libmv/libmv-capi.cpp
extern/libmv/libmv-capi.h
release/scripts/startup/bl_ui/space_clip.py
source/blender/blenkernel/intern/tracking.c
source/blender/makesdna/DNA_tracking_types.h
source/blender/makesrna/intern/rna_tracking.c

index e4708e5907d125574a742b7a014f2d5900aec952..3f697d487b6234238baad7e240df25027dead697 100644 (file)
@@ -54,6 +54,7 @@
 #include "libmv/simple_pipeline/pipeline.h"
 #include "libmv/simple_pipeline/camera_intrinsics.h"
 #include "libmv/simple_pipeline/rigid_registration.h"
+#include "libmv/simple_pipeline/modal_solver.h"
 
 #include <stdlib.h>
 #include <assert.h>
@@ -384,6 +385,31 @@ int libmv_refineParametersAreValid(int parameters) {
                               LIBMV_REFINE_RADIAL_DISTORTION_K1));
 }
 
+void libmv_solveRefineIntrinsics(libmv::Tracks *tracks, libmv::CameraIntrinsics *intrinsics,
+                       libmv::EuclideanReconstruction *reconstruction, int refine_intrinsics,
+                       reconstruct_progress_update_cb progress_update_callback, void *callback_customdata)
+{
+       /* only a few combinations are supported but trust the caller */
+       int libmv_refine_flags = 0;
+
+       if (refine_intrinsics & LIBMV_REFINE_FOCAL_LENGTH) {
+               libmv_refine_flags |= libmv::BUNDLE_FOCAL_LENGTH;
+       }
+       if (refine_intrinsics & LIBMV_REFINE_PRINCIPAL_POINT) {
+               libmv_refine_flags |= libmv::BUNDLE_PRINCIPAL_POINT;
+       }
+       if (refine_intrinsics & LIBMV_REFINE_RADIAL_DISTORTION_K1) {
+               libmv_refine_flags |= libmv::BUNDLE_RADIAL_K1;
+       }
+       if (refine_intrinsics & LIBMV_REFINE_RADIAL_DISTORTION_K2) {
+               libmv_refine_flags |= libmv::BUNDLE_RADIAL_K2;
+       }
+
+       progress_update_callback(callback_customdata, 1.0, "Refining solution");
+
+       libmv::EuclideanBundleCommonIntrinsics(*(libmv::Tracks *)tracks, libmv_refine_flags,
+               reconstruction, intrinsics);
+}
 
 libmv_Reconstruction *libmv_solveReconstruction(libmv_Tracks *tracks, int keyframe1, int keyframe2,
                        int refine_intrinsics, double focal_length, double principal_x, double principal_y, double k1, double k2, double k3,
@@ -423,24 +449,48 @@ libmv_Reconstruction *libmv_solveReconstruction(libmv_Tracks *tracks, int keyfra
        libmv::EuclideanCompleteReconstruction(normalized_tracks, reconstruction, &update_callback);
 
        if (refine_intrinsics) {
-               /* only a few combinations are supported but trust the caller */
-               int libmv_refine_flags = 0;
-               if (refine_intrinsics & LIBMV_REFINE_FOCAL_LENGTH) {
-                       libmv_refine_flags |= libmv::BUNDLE_FOCAL_LENGTH;
-               }
-               if (refine_intrinsics & LIBMV_REFINE_PRINCIPAL_POINT) {
-                       libmv_refine_flags |= libmv::BUNDLE_PRINCIPAL_POINT;
-               }
-               if (refine_intrinsics & LIBMV_REFINE_RADIAL_DISTORTION_K1) {
-                       libmv_refine_flags |= libmv::BUNDLE_RADIAL_K1;
-               }
-               if (refine_intrinsics & LIBMV_REFINE_RADIAL_DISTORTION_K2) {
-                       libmv_refine_flags |= libmv::BUNDLE_RADIAL_K2;
-               }
+               libmv_solveRefineIntrinsics((libmv::Tracks *)tracks, intrinsics, reconstruction,
+                       refine_intrinsics, progress_update_callback, callback_customdata);
+       }
+
+       progress_update_callback(callback_customdata, 1.0, "Finishing solution");
+       libmv_reconstruction->tracks = *(libmv::Tracks *)tracks;
+       libmv_reconstruction->error = libmv::EuclideanReprojectionError(*(libmv::Tracks *)tracks, *reconstruction, *intrinsics);
+
+       return (libmv_Reconstruction *)libmv_reconstruction;
+}
+
+struct libmv_Reconstruction *libmv_solveModal(struct libmv_Tracks *tracks, int refine_intrinsics, 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)
+{
+       /* 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::CameraIntrinsics *intrinsics = &libmv_reconstruction->intrinsics;
+
+       ReconstructUpdateCallback update_callback =
+               ReconstructUpdateCallback(progress_update_callback, callback_customdata);
+
+       intrinsics->SetFocalLength(focal_length, focal_length);
+       intrinsics->SetPrincipalPoint(principal_x, principal_y);
+       intrinsics->SetRadialDistortion(k1, k2, k3);
+
+       for (int i = 0; i < markers.size(); ++i) {
+               intrinsics->InvertIntrinsics(markers[i].x,
+                       markers[i].y,
+                       &(markers[i].x),
+                       &(markers[i].y));
+       }
+
+       libmv::Tracks normalized_tracks(markers);
+
+       libmv::ModalSolver(normalized_tracks, reconstruction, &update_callback);
 
-               progress_update_callback(callback_customdata, 1.0, "Refining solution");
-               libmv::EuclideanBundleCommonIntrinsics(*(libmv::Tracks *)tracks, libmv_refine_flags,
-                       reconstruction, intrinsics);
+       if (refine_intrinsics) {
+               libmv_solveRefineIntrinsics((libmv::Tracks *)tracks, intrinsics, reconstruction,
+                       refine_intrinsics, progress_update_callback, callback_customdata);
        }
 
        progress_update_callback(callback_customdata, 1.0, "Finishing solution");
index 010198323741176c192f6960b083a8b53495127c..f72a72d494b313673195d6679d07da96ca3322ac 100644 (file)
@@ -68,6 +68,9 @@ int libmv_refineParametersAreValid(int parameters);
 struct libmv_Reconstruction *libmv_solveReconstruction(struct libmv_Tracks *tracks, int keyframe1, int keyframe2,
                        int refine_intrinsics, 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);
+struct libmv_Reconstruction *libmv_solveModal(struct libmv_Tracks *tracks, int refine_intrinsics, 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]);
 double libmv_reporojectionErrorForTrack(struct libmv_Reconstruction *libmv_reconstruction, int track);
 double libmv_reporojectionErrorForImage(struct libmv_Reconstruction *libmv_reconstruction, int image);
index c7ab9de72ac189bcc711a81300787011fcc76291..51a1751bb00925aeaf2d4b629165b2138222c4a8 100644 (file)
@@ -227,7 +227,11 @@ class CLIP_PT_tools_solve(Panel):
                      else "Object Motion")
         col.operator("clip.clear_solution")
 
+        col = layout.column()
+        col.prop(settings, "use_tripod_solver")
+
         col = layout.column(align=True)
+        col.active = not settings.use_tripod_solver
         col.prop(settings, "keyframe_a")
         col.prop(settings, "keyframe_b")
 
index 7654c361d148bedd712da43b514fea955ce80c96..9e3bc2648a5a53361c2d5d97e2cd24a16cd75c1e 100644 (file)
@@ -1523,6 +1523,7 @@ typedef struct MovieReconstructContext {
 #endif
        char object_name[MAX_NAME];
        int is_camera;
+       short motion_flag;
 
        float focal_length;
        float principal_point[2];
@@ -1752,7 +1753,11 @@ int BKE_tracking_can_reconstruct(MovieTracking *tracking, MovieTrackingObject *o
 #if WITH_LIBMV
        ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
 
-       if (count_tracks_on_both_keyframes(tracking, tracksbase)<8) {
+       if (tracking->settings.motion_flag & TRACKING_MOTION_MODAL) {
+               /* TODO: check for number of tracks? */
+               return TRUE;
+       }
+       else if (count_tracks_on_both_keyframes(tracking, tracksbase) < 8) {
                BLI_strncpy(error_msg, "At least 8 common tracks on both of keyframes are needed for reconstruction", error_size);
 
                return FALSE;
@@ -1781,7 +1786,8 @@ MovieReconstructContext* BKE_tracking_reconstruction_context_new(MovieTracking *
        MovieTrackingTrack *track;
 
        BLI_strncpy(context->object_name, object->name, sizeof(context->object_name));
-       context->is_camera = object->flag&TRACKING_OBJECT_CAMERA;
+       context->is_camera = object->flag & TRACKING_OBJECT_CAMERA;
+       context->motion_flag = tracking->settings.motion_flag;
 
        context->tracks_map = tracks_map_new(context->object_name, context->is_camera, num_tracks, 0);
 
@@ -1894,13 +1900,23 @@ void BKE_tracking_solve_reconstruction(MovieReconstructContext *context, short *
        progressdata.stats_message = stats_message;
        progressdata.message_size = message_size;
 
-       context->reconstruction = libmv_solveReconstruction(context->tracks,
-               context->keyframe1, context->keyframe2,
-               context->refine_flags,
-               context->focal_length,
-               context->principal_point[0], context->principal_point[1],
-               context->k1, context->k2, context->k3,
-               solve_reconstruction_update_cb, &progressdata);
+       if (context->motion_flag & TRACKING_MOTION_MODAL) {
+               context->reconstruction = libmv_solveModal(context->tracks,
+                       context->refine_flags,
+                       context->focal_length,
+                       context->principal_point[0], context->principal_point[1],
+                       context->k1, context->k2, context->k3,
+                       solve_reconstruction_update_cb, &progressdata);
+       }
+       else {
+               context->reconstruction = libmv_solveReconstruction(context->tracks,
+                       context->keyframe1, context->keyframe2,
+                       context->refine_flags,
+                       context->focal_length,
+                       context->principal_point[0], context->principal_point[1],
+                       context->k1, context->k2, context->k3,
+                       solve_reconstruction_update_cb, &progressdata);
+       }
 
        error = libmv_reprojectionError(context->reconstruction);
 
index 9c0f63028c11aab10c76a30658a14abcfb7be1e6..2f099ed59f5d1e42595a7d66260c62084fbe7dbe 100644 (file)
@@ -123,7 +123,7 @@ typedef struct MovieTrackingSettings {
        short default_pattern_match;            /* re-adjust every N frames */
        short default_flag;                                     /* default flags like color channels used by default */
 
-       short pod;
+       short motion_flag;              /* flags describes motion type */
 
        /* ** common tracker settings ** */
        short speed;                    /* speed of tracking */
@@ -131,8 +131,8 @@ typedef struct MovieTrackingSettings {
        /* ** reconstruction settings ** */
        int keyframe1, keyframe2;       /* two keyframes for reconstrution initialization */
 
-       /* ** which camera intrinsics to refine. uses on the REFINE_* flags */
-       short refine_camera_intrinsics, pad23;
+       /* which camera intrinsics to refine. uses on the REFINE_* flags */
+       short refine_camera_intrinsics, pad2;
 
        /* ** tool settings ** */
 
@@ -243,6 +243,11 @@ enum {
 /* MovieTrackingSettings->flag */
 #define TRACKING_SETTINGS_SHOW_DEFAULT_EXPANDED        (1<<0)
 
+/* MovieTrackingSettings->motion_flag */
+#define TRACKING_MOTION_TRIPOD         (1<<0)
+
+#define TRACKING_MOTION_MODAL          (TRACKING_MOTION_TRIPOD)
+
 /* MovieTrackingSettings->speed */
 #define TRACKING_SPEED_FASTEST         0
 #define TRACKING_SPEED_REALTIME                1
index 56222c67a2306eba9546dde11379fc1591e06292..13948fde367dab32d5b296f491abba077ba6dde4 100644 (file)
@@ -607,6 +607,12 @@ static void rna_def_trackingSettings(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Show Expanded", "Show the expanded in the user interface");
        RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
 
+       /* solver settings */
+       prop = RNA_def_property(srna, "use_tripod_solver", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+       RNA_def_property_boolean_sdna(prop, NULL, "motion_flag", TRACKING_MOTION_TRIPOD);
+       RNA_def_property_ui_text(prop, "Tripod Motion", "Tracking footage is shooted by tripod camera and should use special sovler for this");
+
        /* limit frames */
        prop = RNA_def_property(srna, "default_frames_limit", PROP_INT, PROP_NONE);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);