From e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 17 Apr 2019 06:17:24 +0200 Subject: ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat --- source/blender/blenkernel/intern/tracking_solver.c | 792 +++++++++++---------- 1 file changed, 407 insertions(+), 385 deletions(-) (limited to 'source/blender/blenkernel/intern/tracking_solver.c') diff --git a/source/blender/blenkernel/intern/tracking_solver.c b/source/blender/blenkernel/intern/tracking_solver.c index 51bd4c3c871..c3759fd01bb 100644 --- a/source/blender/blenkernel/intern/tracking_solver.c +++ b/source/blender/blenkernel/intern/tracking_solver.c @@ -47,293 +47,303 @@ #include "tracking_private.h" typedef struct MovieReconstructContext { - struct libmv_Tracks *tracks; - bool select_keyframes; - int keyframe1, keyframe2; - int refine_flags; + struct libmv_Tracks *tracks; + bool select_keyframes; + int keyframe1, keyframe2; + int refine_flags; - struct libmv_Reconstruction *reconstruction; + struct libmv_Reconstruction *reconstruction; - char object_name[MAX_NAME]; - bool is_camera; - short motion_flag; + char object_name[MAX_NAME]; + bool is_camera; + short motion_flag; - libmv_CameraIntrinsicsOptions camera_intrinsics_options; + libmv_CameraIntrinsicsOptions camera_intrinsics_options; - float reprojection_error; + float reprojection_error; - TracksMap *tracks_map; + TracksMap *tracks_map; - int sfra, efra; + int sfra, efra; } MovieReconstructContext; typedef struct ReconstructProgressData { - short *stop; - short *do_update; - float *progress; - char *stats_message; - int message_size; + short *stop; + short *do_update; + float *progress; + char *stats_message; + int message_size; } ReconstructProgressData; /* Create new libmv Tracks structure from blender's tracks list. */ -static struct libmv_Tracks *libmv_tracks_new(MovieClip *clip, ListBase *tracksbase, int width, int height) +static struct libmv_Tracks *libmv_tracks_new(MovieClip *clip, + ListBase *tracksbase, + int width, + int height) { - int tracknr = 0; - MovieTrackingTrack *track; - struct libmv_Tracks *tracks = libmv_tracksNew(); - - track = tracksbase->first; - while (track) { - FCurve *weight_fcurve; - int a = 0; - - weight_fcurve = id_data_find_fcurve(&clip->id, track, &RNA_MovieTrackingTrack, - "weight", 0, NULL); - - for (a = 0; a < track->markersnr; a++) { - MovieTrackingMarker *marker = &track->markers[a]; - - if ((marker->flag & MARKER_DISABLED) == 0) { - float weight = track->weight; - - if (weight_fcurve) { - int scene_framenr = - BKE_movieclip_remap_clip_to_scene_frame(clip, marker->framenr); - weight = evaluate_fcurve(weight_fcurve, scene_framenr); - } - - libmv_tracksInsert(tracks, marker->framenr, tracknr, - (marker->pos[0] + track->offset[0]) * width, - (marker->pos[1] + track->offset[1]) * height, - weight); - } - } - - track = track->next; - tracknr++; - } - - return tracks; + int tracknr = 0; + MovieTrackingTrack *track; + struct libmv_Tracks *tracks = libmv_tracksNew(); + + track = tracksbase->first; + while (track) { + FCurve *weight_fcurve; + int a = 0; + + weight_fcurve = id_data_find_fcurve( + &clip->id, track, &RNA_MovieTrackingTrack, "weight", 0, NULL); + + for (a = 0; a < track->markersnr; a++) { + MovieTrackingMarker *marker = &track->markers[a]; + + if ((marker->flag & MARKER_DISABLED) == 0) { + float weight = track->weight; + + if (weight_fcurve) { + int scene_framenr = BKE_movieclip_remap_clip_to_scene_frame(clip, marker->framenr); + weight = evaluate_fcurve(weight_fcurve, scene_framenr); + } + + libmv_tracksInsert(tracks, + marker->framenr, + tracknr, + (marker->pos[0] + track->offset[0]) * width, + (marker->pos[1] + track->offset[1]) * height, + weight); + } + } + + track = track->next; + tracknr++; + } + + return tracks; } /* Retrieve refined camera intrinsics from libmv to blender. */ -static void reconstruct_retrieve_libmv_intrinsics(MovieReconstructContext *context, MovieTracking *tracking) +static void reconstruct_retrieve_libmv_intrinsics(MovieReconstructContext *context, + MovieTracking *tracking) { - struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction; - struct libmv_CameraIntrinsics *libmv_intrinsics = libmv_reconstructionExtractIntrinsics(libmv_reconstruction); + struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction; + struct libmv_CameraIntrinsics *libmv_intrinsics = libmv_reconstructionExtractIntrinsics( + libmv_reconstruction); - libmv_CameraIntrinsicsOptions camera_intrinsics_options; - libmv_cameraIntrinsicsExtractOptions(libmv_intrinsics, &camera_intrinsics_options); + libmv_CameraIntrinsicsOptions camera_intrinsics_options; + libmv_cameraIntrinsicsExtractOptions(libmv_intrinsics, &camera_intrinsics_options); - tracking_trackingCameraFromIntrinscisOptions(tracking, - &camera_intrinsics_options); + tracking_trackingCameraFromIntrinscisOptions(tracking, &camera_intrinsics_options); } /* Retrieve reconstructed tracks from libmv to blender. * Actually, this also copies reconstructed cameras * from libmv to movie clip datablock. */ -static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context, MovieTracking *tracking) +static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context, + MovieTracking *tracking) { - struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction; - MovieTrackingReconstruction *reconstruction = NULL; - MovieReconstructedCamera *reconstructed; - MovieTrackingTrack *track; - ListBase *tracksbase = NULL; - int tracknr = 0, a; - bool ok = true; - bool origin_set = false; - int sfra = context->sfra, efra = context->efra; - float imat[4][4]; - - if (context->is_camera) { - tracksbase = &tracking->tracks; - reconstruction = &tracking->reconstruction; - } - else { - MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name); - - tracksbase = &object->tracks; - reconstruction = &object->reconstruction; - } - - unit_m4(imat); - - track = tracksbase->first; - while (track) { - double pos[3]; - - if (libmv_reprojectionPointForTrack(libmv_reconstruction, tracknr, pos)) { - track->bundle_pos[0] = pos[0]; - track->bundle_pos[1] = pos[1]; - track->bundle_pos[2] = pos[2]; - - track->flag |= TRACK_HAS_BUNDLE; - track->error = libmv_reprojectionErrorForTrack(libmv_reconstruction, tracknr); - } - else { - track->flag &= ~TRACK_HAS_BUNDLE; - ok = false; - - printf("Unable to reconstruct position for track #%d '%s'\n", tracknr, track->name); - } - - track = track->next; - tracknr++; - } - - if (reconstruction->cameras) - MEM_freeN(reconstruction->cameras); - - reconstruction->camnr = 0; - reconstruction->cameras = NULL; - reconstructed = MEM_callocN((efra - sfra + 1) * sizeof(MovieReconstructedCamera), - "temp reconstructed camera"); - - for (a = sfra; a <= efra; a++) { - double matd[4][4]; - - if (libmv_reprojectionCameraForImage(libmv_reconstruction, a, matd)) { - int i, j; - float mat[4][4]; - float error = libmv_reprojectionErrorForImage(libmv_reconstruction, a); - - for (i = 0; i < 4; i++) { - for (j = 0; j < 4; j++) - mat[i][j] = matd[i][j]; - } - - /* Ensure first camera has got zero rotation and transform. - * This is essential for object tracking to work -- this way - * we'll always know object and environment are properly - * oriented. - * - * There's one weak part tho, which is requirement object - * motion starts at the same frame as camera motion does, - * otherwise that;' be a russian roulette whether object is - * aligned correct or not. - */ - if (!origin_set) { - invert_m4_m4(imat, mat); - unit_m4(mat); - origin_set = true; - } - else { - mul_m4_m4m4(mat, imat, mat); - } - - copy_m4_m4(reconstructed[reconstruction->camnr].mat, mat); - reconstructed[reconstruction->camnr].framenr = a; - reconstructed[reconstruction->camnr].error = error; - reconstruction->camnr++; - } - else { - ok = false; - printf("No camera for frame %d\n", a); - } - } - - if (reconstruction->camnr) { - int size = reconstruction->camnr * sizeof(MovieReconstructedCamera); - reconstruction->cameras = MEM_callocN(size, "reconstructed camera"); - memcpy(reconstruction->cameras, reconstructed, size); - } - - if (origin_set) { - track = tracksbase->first; - while (track) { - if (track->flag & TRACK_HAS_BUNDLE) - mul_v3_m4v3(track->bundle_pos, imat, track->bundle_pos); - - track = track->next; - } - } - - MEM_freeN(reconstructed); - - return ok; + struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction; + MovieTrackingReconstruction *reconstruction = NULL; + MovieReconstructedCamera *reconstructed; + MovieTrackingTrack *track; + ListBase *tracksbase = NULL; + int tracknr = 0, a; + bool ok = true; + bool origin_set = false; + int sfra = context->sfra, efra = context->efra; + float imat[4][4]; + + if (context->is_camera) { + tracksbase = &tracking->tracks; + reconstruction = &tracking->reconstruction; + } + else { + MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name); + + tracksbase = &object->tracks; + reconstruction = &object->reconstruction; + } + + unit_m4(imat); + + track = tracksbase->first; + while (track) { + double pos[3]; + + if (libmv_reprojectionPointForTrack(libmv_reconstruction, tracknr, pos)) { + track->bundle_pos[0] = pos[0]; + track->bundle_pos[1] = pos[1]; + track->bundle_pos[2] = pos[2]; + + track->flag |= TRACK_HAS_BUNDLE; + track->error = libmv_reprojectionErrorForTrack(libmv_reconstruction, tracknr); + } + else { + track->flag &= ~TRACK_HAS_BUNDLE; + ok = false; + + printf("Unable to reconstruct position for track #%d '%s'\n", tracknr, track->name); + } + + track = track->next; + tracknr++; + } + + if (reconstruction->cameras) + MEM_freeN(reconstruction->cameras); + + reconstruction->camnr = 0; + reconstruction->cameras = NULL; + reconstructed = MEM_callocN((efra - sfra + 1) * sizeof(MovieReconstructedCamera), + "temp reconstructed camera"); + + for (a = sfra; a <= efra; a++) { + double matd[4][4]; + + if (libmv_reprojectionCameraForImage(libmv_reconstruction, a, matd)) { + int i, j; + float mat[4][4]; + float error = libmv_reprojectionErrorForImage(libmv_reconstruction, a); + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) + mat[i][j] = matd[i][j]; + } + + /* Ensure first camera has got zero rotation and transform. + * This is essential for object tracking to work -- this way + * we'll always know object and environment are properly + * oriented. + * + * There's one weak part tho, which is requirement object + * motion starts at the same frame as camera motion does, + * otherwise that;' be a russian roulette whether object is + * aligned correct or not. + */ + if (!origin_set) { + invert_m4_m4(imat, mat); + unit_m4(mat); + origin_set = true; + } + else { + mul_m4_m4m4(mat, imat, mat); + } + + copy_m4_m4(reconstructed[reconstruction->camnr].mat, mat); + reconstructed[reconstruction->camnr].framenr = a; + reconstructed[reconstruction->camnr].error = error; + reconstruction->camnr++; + } + else { + ok = false; + printf("No camera for frame %d\n", a); + } + } + + if (reconstruction->camnr) { + int size = reconstruction->camnr * sizeof(MovieReconstructedCamera); + reconstruction->cameras = MEM_callocN(size, "reconstructed camera"); + memcpy(reconstruction->cameras, reconstructed, size); + } + + if (origin_set) { + track = tracksbase->first; + while (track) { + if (track->flag & TRACK_HAS_BUNDLE) + mul_v3_m4v3(track->bundle_pos, imat, track->bundle_pos); + + track = track->next; + } + } + + MEM_freeN(reconstructed); + + return ok; } /* Retrieve all the libmv data from context to blender's side data blocks. */ static int reconstruct_retrieve_libmv(MovieReconstructContext *context, MovieTracking *tracking) { - /* take the intrinsics back from libmv */ - reconstruct_retrieve_libmv_intrinsics(context, tracking); + /* take the intrinsics back from libmv */ + reconstruct_retrieve_libmv_intrinsics(context, tracking); - return reconstruct_retrieve_libmv_tracks(context, tracking); + return reconstruct_retrieve_libmv_tracks(context, tracking); } /* Convert blender's refinement flags to libmv's. */ -static int reconstruct_refine_intrinsics_get_flags(MovieTracking *tracking, MovieTrackingObject *object) +static int reconstruct_refine_intrinsics_get_flags(MovieTracking *tracking, + MovieTrackingObject *object) { - int refine = tracking->settings.refine_camera_intrinsics; - int flags = 0; + int refine = tracking->settings.refine_camera_intrinsics; + int flags = 0; - if ((object->flag & TRACKING_OBJECT_CAMERA) == 0) - return 0; + if ((object->flag & TRACKING_OBJECT_CAMERA) == 0) + return 0; - if (refine & REFINE_FOCAL_LENGTH) - flags |= LIBMV_REFINE_FOCAL_LENGTH; + if (refine & REFINE_FOCAL_LENGTH) + flags |= LIBMV_REFINE_FOCAL_LENGTH; - if (refine & REFINE_PRINCIPAL_POINT) - flags |= LIBMV_REFINE_PRINCIPAL_POINT; + if (refine & REFINE_PRINCIPAL_POINT) + flags |= LIBMV_REFINE_PRINCIPAL_POINT; - if (refine & REFINE_RADIAL_DISTORTION_K1) - flags |= LIBMV_REFINE_RADIAL_DISTORTION_K1; + if (refine & REFINE_RADIAL_DISTORTION_K1) + flags |= LIBMV_REFINE_RADIAL_DISTORTION_K1; - if (refine & REFINE_RADIAL_DISTORTION_K2) - flags |= LIBMV_REFINE_RADIAL_DISTORTION_K2; + if (refine & REFINE_RADIAL_DISTORTION_K2) + flags |= LIBMV_REFINE_RADIAL_DISTORTION_K2; - return flags; + return flags; } /* Count tracks which has markers at both of keyframes. */ -static int reconstruct_count_tracks_on_both_keyframes(MovieTracking *tracking, MovieTrackingObject *object) +static int reconstruct_count_tracks_on_both_keyframes(MovieTracking *tracking, + MovieTrackingObject *object) { - ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object); - int tot = 0; - int frame1 = object->keyframe1, frame2 = object->keyframe2; - MovieTrackingTrack *track; - - track = tracksbase->first; - while (track) { - if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame1)) { - if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame2)) { - tot++; - } - } - - track = track->next; - } - - return tot; + ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object); + int tot = 0; + int frame1 = object->keyframe1, frame2 = object->keyframe2; + MovieTrackingTrack *track; + + track = tracksbase->first; + while (track) { + if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame1)) { + if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame2)) { + tot++; + } + } + + track = track->next; + } + + return tot; } /* Perform early check on whether everything is fine to start reconstruction. */ -bool BKE_tracking_reconstruction_check(MovieTracking *tracking, MovieTrackingObject *object, - char *error_msg, int error_size) +bool BKE_tracking_reconstruction_check(MovieTracking *tracking, + MovieTrackingObject *object, + char *error_msg, + int error_size) { - if (tracking->settings.motion_flag & TRACKING_MOTION_MODAL) { - /* TODO: check for number of tracks? */ - return true; - } - else if ((tracking->settings.reconstruction_flag & TRACKING_USE_KEYFRAME_SELECTION) == 0) { - /* automatic keyframe selection does not require any pre-process checks */ - if (reconstruct_count_tracks_on_both_keyframes(tracking, object) < 8) { - BLI_strncpy(error_msg, - N_("At least 8 common tracks on both keyframes are needed for reconstruction"), - error_size); - - return false; - } - } + if (tracking->settings.motion_flag & TRACKING_MOTION_MODAL) { + /* TODO: check for number of tracks? */ + return true; + } + else if ((tracking->settings.reconstruction_flag & TRACKING_USE_KEYFRAME_SELECTION) == 0) { + /* automatic keyframe selection does not require any pre-process checks */ + if (reconstruct_count_tracks_on_both_keyframes(tracking, object) < 8) { + BLI_strncpy(error_msg, + N_("At least 8 common tracks on both keyframes are needed for reconstruction"), + error_size); + + return false; + } + } #ifndef WITH_LIBMV - BLI_strncpy(error_msg, N_("Blender is compiled without motion tracking library"), error_size); - return false; + BLI_strncpy(error_msg, N_("Blender is compiled without motion tracking library"), error_size); + return false; #endif - return true; + return true; } /* Create context for camera/object motion reconstruction. @@ -341,106 +351,111 @@ bool BKE_tracking_reconstruction_check(MovieTracking *tracking, MovieTrackingObj * clip datablock, so editing this clip is safe during * reconstruction job is in progress. */ -MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip, MovieTrackingObject *object, - int keyframe1, int keyframe2, int width, int height) +MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip, + MovieTrackingObject *object, + int keyframe1, + int keyframe2, + int width, + int height) { - MovieTracking *tracking = &clip->tracking; - MovieReconstructContext *context = MEM_callocN(sizeof(MovieReconstructContext), "MovieReconstructContext data"); - ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object); - float aspy = 1.0f / tracking->camera.pixel_aspect; - int num_tracks = BLI_listbase_count(tracksbase); - int sfra = INT_MAX, efra = INT_MIN; - MovieTrackingTrack *track; + MovieTracking *tracking = &clip->tracking; + MovieReconstructContext *context = MEM_callocN(sizeof(MovieReconstructContext), + "MovieReconstructContext data"); + ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object); + float aspy = 1.0f / tracking->camera.pixel_aspect; + int num_tracks = BLI_listbase_count(tracksbase); + int sfra = INT_MAX, efra = INT_MIN; + MovieTrackingTrack *track; - BLI_strncpy(context->object_name, object->name, sizeof(context->object_name)); - context->is_camera = object->flag & TRACKING_OBJECT_CAMERA; - context->motion_flag = tracking->settings.motion_flag; + BLI_strncpy(context->object_name, object->name, sizeof(context->object_name)); + context->is_camera = object->flag & TRACKING_OBJECT_CAMERA; + context->motion_flag = tracking->settings.motion_flag; - context->select_keyframes = - (tracking->settings.reconstruction_flag & TRACKING_USE_KEYFRAME_SELECTION) != 0; + context->select_keyframes = (tracking->settings.reconstruction_flag & + TRACKING_USE_KEYFRAME_SELECTION) != 0; - tracking_cameraIntrinscisOptionsFromTracking(tracking, - width, height, - &context->camera_intrinsics_options); + tracking_cameraIntrinscisOptionsFromTracking( + tracking, width, height, &context->camera_intrinsics_options); - context->tracks_map = tracks_map_new(context->object_name, context->is_camera, num_tracks, 0); + context->tracks_map = tracks_map_new(context->object_name, context->is_camera, num_tracks, 0); - track = tracksbase->first; - while (track) { - int first = 0, last = track->markersnr - 1; - MovieTrackingMarker *first_marker = &track->markers[0]; - MovieTrackingMarker *last_marker = &track->markers[track->markersnr - 1]; + track = tracksbase->first; + while (track) { + int first = 0, last = track->markersnr - 1; + MovieTrackingMarker *first_marker = &track->markers[0]; + MovieTrackingMarker *last_marker = &track->markers[track->markersnr - 1]; - /* find first not-disabled marker */ - while (first <= track->markersnr - 1 && first_marker->flag & MARKER_DISABLED) { - first++; - first_marker++; - } + /* find first not-disabled marker */ + while (first <= track->markersnr - 1 && first_marker->flag & MARKER_DISABLED) { + first++; + first_marker++; + } - /* find last not-disabled marker */ - while (last >= 0 && last_marker->flag & MARKER_DISABLED) { - last--; - last_marker--; - } + /* find last not-disabled marker */ + while (last >= 0 && last_marker->flag & MARKER_DISABLED) { + last--; + last_marker--; + } - if (first <= track->markersnr - 1) - sfra = min_ii(sfra, first_marker->framenr); + if (first <= track->markersnr - 1) + sfra = min_ii(sfra, first_marker->framenr); - if (last >= 0) - efra = max_ii(efra, last_marker->framenr); + if (last >= 0) + efra = max_ii(efra, last_marker->framenr); - tracks_map_insert(context->tracks_map, track, NULL); + tracks_map_insert(context->tracks_map, track, NULL); - track = track->next; - } + track = track->next; + } - context->sfra = sfra; - context->efra = efra; + context->sfra = sfra; + context->efra = efra; - context->tracks = libmv_tracks_new(clip, tracksbase, width, height * aspy); - context->keyframe1 = keyframe1; - context->keyframe2 = keyframe2; - context->refine_flags = reconstruct_refine_intrinsics_get_flags(tracking, object); + context->tracks = libmv_tracks_new(clip, tracksbase, width, height * aspy); + context->keyframe1 = keyframe1; + context->keyframe2 = keyframe2; + context->refine_flags = reconstruct_refine_intrinsics_get_flags(tracking, object); - return context; + return context; } /* Free memory used by a reconstruction process. */ void BKE_tracking_reconstruction_context_free(MovieReconstructContext *context) { - if (context->reconstruction) - libmv_reconstructionDestroy(context->reconstruction); + if (context->reconstruction) + libmv_reconstructionDestroy(context->reconstruction); - libmv_tracksDestroy(context->tracks); + libmv_tracksDestroy(context->tracks); - tracks_map_free(context->tracks_map, NULL); + tracks_map_free(context->tracks_map, NULL); - MEM_freeN(context); + MEM_freeN(context); } /* Callback which is called from libmv side to update progress in the interface. */ static void reconstruct_update_solve_cb(void *customdata, double progress, const char *message) { - ReconstructProgressData *progressdata = customdata; + ReconstructProgressData *progressdata = customdata; - if (progressdata->progress) { - *progressdata->progress = progress; - *progressdata->do_update = true; - } + if (progressdata->progress) { + *progressdata->progress = progress; + *progressdata->do_update = true; + } - BLI_snprintf(progressdata->stats_message, progressdata->message_size, "Solving camera | %s", message); + BLI_snprintf( + progressdata->stats_message, progressdata->message_size, "Solving camera | %s", message); } /* Fill in reconstruction options structure from reconstruction context. */ static void reconstructionOptionsFromContext(libmv_ReconstructionOptions *reconstruction_options, MovieReconstructContext *context) { - reconstruction_options->select_keyframes = context->select_keyframes; + reconstruction_options->select_keyframes = context->select_keyframes; - reconstruction_options->keyframe1 = context->keyframe1; - reconstruction_options->keyframe2 = context->keyframe2; + reconstruction_options->keyframe1 = context->keyframe1; + reconstruction_options->keyframe2 = context->keyframe2; - reconstruction_options->refine_intrinsics = context->refine_flags; + reconstruction_options->refine_intrinsics = context->refine_flags; } /* Solve camera/object motion and reconstruct 3D markers position @@ -452,45 +467,51 @@ static void reconstructionOptionsFromContext(libmv_ReconstructionOptions *recons * do_update, progress and stat_message are set by reconstruction * callback in libmv side and passing to an interface. */ -void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, short *stop, short *do_update, - float *progress, char *stats_message, int message_size) +void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, + short *stop, + short *do_update, + float *progress, + char *stats_message, + int message_size) { - float error; - - ReconstructProgressData progressdata; - - libmv_ReconstructionOptions reconstruction_options; - - progressdata.stop = stop; - progressdata.do_update = do_update; - progressdata.progress = progress; - progressdata.stats_message = stats_message; - progressdata.message_size = message_size; - - reconstructionOptionsFromContext(&reconstruction_options, context); - - if (context->motion_flag & TRACKING_MOTION_MODAL) { - context->reconstruction = libmv_solveModal(context->tracks, - &context->camera_intrinsics_options, - &reconstruction_options, - reconstruct_update_solve_cb, &progressdata); - } - else { - context->reconstruction = libmv_solveReconstruction(context->tracks, - &context->camera_intrinsics_options, - &reconstruction_options, - reconstruct_update_solve_cb, &progressdata); - - if (context->select_keyframes) { - /* store actual keyframes used for reconstruction to update them in the interface later */ - context->keyframe1 = reconstruction_options.keyframe1; - context->keyframe2 = reconstruction_options.keyframe2; - } - } - - error = libmv_reprojectionError(context->reconstruction); - - context->reprojection_error = error; + float error; + + ReconstructProgressData progressdata; + + libmv_ReconstructionOptions reconstruction_options; + + progressdata.stop = stop; + progressdata.do_update = do_update; + progressdata.progress = progress; + progressdata.stats_message = stats_message; + progressdata.message_size = message_size; + + reconstructionOptionsFromContext(&reconstruction_options, context); + + if (context->motion_flag & TRACKING_MOTION_MODAL) { + context->reconstruction = libmv_solveModal(context->tracks, + &context->camera_intrinsics_options, + &reconstruction_options, + reconstruct_update_solve_cb, + &progressdata); + } + else { + context->reconstruction = libmv_solveReconstruction(context->tracks, + &context->camera_intrinsics_options, + &reconstruction_options, + reconstruct_update_solve_cb, + &progressdata); + + if (context->select_keyframes) { + /* store actual keyframes used for reconstruction to update them in the interface later */ + context->keyframe1 = reconstruction_options.keyframe1; + context->keyframe2 = reconstruction_options.keyframe2; + } + } + + error = libmv_reprojectionError(context->reconstruction); + + context->reprojection_error = error; } /* Finish reconstruction process by copying reconstructed data @@ -498,62 +519,63 @@ void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, short * */ bool BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieTracking *tracking) { - MovieTrackingReconstruction *reconstruction; - MovieTrackingObject *object; + MovieTrackingReconstruction *reconstruction; + MovieTrackingObject *object; - if (!libmv_reconstructionIsValid(context->reconstruction)) { - printf("Failed solve the motion: most likely there are no good keyframes\n"); - return false; - } + if (!libmv_reconstructionIsValid(context->reconstruction)) { + printf("Failed solve the motion: most likely there are no good keyframes\n"); + return false; + } - tracks_map_merge(context->tracks_map, tracking); - BKE_tracking_dopesheet_tag_update(tracking); + tracks_map_merge(context->tracks_map, tracking); + BKE_tracking_dopesheet_tag_update(tracking); - object = BKE_tracking_object_get_named(tracking, context->object_name); + object = BKE_tracking_object_get_named(tracking, context->object_name); - if (context->is_camera) - reconstruction = &tracking->reconstruction; - else - reconstruction = &object->reconstruction; + if (context->is_camera) + reconstruction = &tracking->reconstruction; + else + reconstruction = &object->reconstruction; - /* update keyframe in the interface */ - if (context->select_keyframes) { - object->keyframe1 = context->keyframe1; - object->keyframe2 = context->keyframe2; - } + /* update keyframe in the interface */ + if (context->select_keyframes) { + object->keyframe1 = context->keyframe1; + object->keyframe2 = context->keyframe2; + } - reconstruction->error = context->reprojection_error; - reconstruction->flag |= TRACKING_RECONSTRUCTED; + reconstruction->error = context->reprojection_error; + reconstruction->flag |= TRACKING_RECONSTRUCTED; - if (!reconstruct_retrieve_libmv(context, tracking)) - return false; + if (!reconstruct_retrieve_libmv(context, tracking)) + return false; - return true; + return true; } -static void tracking_scale_reconstruction(ListBase *tracksbase, MovieTrackingReconstruction *reconstruction, +static void tracking_scale_reconstruction(ListBase *tracksbase, + MovieTrackingReconstruction *reconstruction, const float scale[3]) { - MovieTrackingTrack *track; - int i; - float first_camera_delta[3] = {0.0f, 0.0f, 0.0f}; - - if (reconstruction->camnr > 0) { - mul_v3_v3v3(first_camera_delta, reconstruction->cameras[0].mat[3], scale); - } - - for (i = 0; i < reconstruction->camnr; i++) { - MovieReconstructedCamera *camera = &reconstruction->cameras[i]; - mul_v3_v3(camera->mat[3], scale); - sub_v3_v3(camera->mat[3], first_camera_delta); - } - - for (track = tracksbase->first; track; track = track->next) { - if (track->flag & TRACK_HAS_BUNDLE) { - mul_v3_v3(track->bundle_pos, scale); - sub_v3_v3(track->bundle_pos, first_camera_delta); - } - } + MovieTrackingTrack *track; + int i; + float first_camera_delta[3] = {0.0f, 0.0f, 0.0f}; + + if (reconstruction->camnr > 0) { + mul_v3_v3v3(first_camera_delta, reconstruction->cameras[0].mat[3], scale); + } + + for (i = 0; i < reconstruction->camnr; i++) { + MovieReconstructedCamera *camera = &reconstruction->cameras[i]; + mul_v3_v3(camera->mat[3], scale); + sub_v3_v3(camera->mat[3], first_camera_delta); + } + + for (track = tracksbase->first; track; track = track->next) { + if (track->flag & TRACK_HAS_BUNDLE) { + mul_v3_v3(track->bundle_pos, scale); + sub_v3_v3(track->bundle_pos, first_camera_delta); + } + } } /* Apply scale on all reconstructed cameras and bundles, @@ -561,15 +583,15 @@ static void tracking_scale_reconstruction(ListBase *tracksbase, MovieTrackingRec */ void BKE_tracking_reconstruction_scale(MovieTracking *tracking, float scale[3]) { - MovieTrackingObject *object; + MovieTrackingObject *object; - for (object = tracking->objects.first; object; object = object->next) { - ListBase *tracksbase; - MovieTrackingReconstruction *reconstruction; + for (object = tracking->objects.first; object; object = object->next) { + ListBase *tracksbase; + MovieTrackingReconstruction *reconstruction; - tracksbase = BKE_tracking_object_get_tracks(tracking, object); - reconstruction = BKE_tracking_object_get_reconstruction(tracking, object); + tracksbase = BKE_tracking_object_get_tracks(tracking, object); + reconstruction = BKE_tracking_object_get_reconstruction(tracking, object); - tracking_scale_reconstruction(tracksbase, reconstruction, scale); - } + tracking_scale_reconstruction(tracksbase, reconstruction, scale); + } } -- cgit v1.2.3