28#include "RNA_prototypes.hh"
68 ListBaseT<MovieTrackingTrack> *tracksbase,
76 track = tracksbase->first();
79 &clip->
id, track, RNA_MovieTrackingTrack,
"weight", 0,
nullptr);
81 for (
int a = 0; a < track->
markersnr; a++) {
85 float weight = track->
weight;
95 (marker->
pos[0] + track->
offset[0]) * width,
96 (marker->
pos[1] + track->
offset[1]) * height,
114 libmv_reconstruction);
131 bool origin_set =
false;
132 int sfra = context->sfra, efra = context->efra;
136 context->object_name);
143 for (
const auto [track_index, track] : tracking_object->
tracks.enumerate()) {
147 track.bundle_pos[0] = pos[0];
148 track.bundle_pos[1] = pos[1];
149 track.bundle_pos[2] = pos[2];
158 printf(
"Unable to reconstruct position for track #%d '%s'\n", track_index, track.name);
164 MEM_delete(reconstruction->
cameras);
167 reconstruction->
camnr = 0;
168 reconstruction->
cameras =
nullptr;
171 (efra - sfra + 1),
"temp reconstructed camera");
173 for (
int a = sfra; a <= efra; a++) {
181 for (
int i = 0; i < 4; i++) {
182 for (
int j = 0; j < 4; j++) {
183 mat[i][j] = matd[i][j];
207 &reconstructed_cameras[reconstruction->
camnr];
209 reconstructed_camera->
framenr = a;
210 reconstructed_camera->
error = error;
211 reconstruction->
camnr++;
215 printf(
"No camera for frame %d\n", a);
219 if (reconstruction->
camnr) {
221 reconstruction->
cameras = MEM_new_array<MovieReconstructedCamera>(reconstruction->
camnr,
222 "reconstructed camera");
223 memcpy(reconstruction->
cameras, reconstructed_cameras, size);
234 MEM_delete(reconstructed_cameras);
299 int error_msg_maxncpy)
310 N_(
"At least 8 common tracks on both keyframes are needed for reconstruction"),
319 error_msg,
N_(
"Blender is compiled without motion tracking library"), error_msg_maxncpy);
336 "MovieReconstructContext data");
338 const int num_tracks = tracking_object->
tracks.count();
339 int sfra =
INT_MAX, efra = INT_MIN;
348 tracking, width, height, &context->camera_intrinsics_options);
350 context->tracks_map =
tracks_map_new(context->object_name, num_tracks);
353 int first = 0, last = track.
markersnr - 1;
358 while (first <= track.markersnr - 1 && first_marker->flag &
MARKER_DISABLED) {
380 context->sfra = sfra;
381 context->efra = efra;
384 context->keyframe1 = keyframe1;
385 context->keyframe2 = keyframe2;
388 context->error_message[0] =
'\0';
394 const char *error_message)
396 if (context->error_message[0]) {
405 return context->error_message;
410 if (context->reconstruction) {
441 reconstruction_options->
keyframe1 = context->keyframe1;
442 reconstruction_options->
keyframe2 = context->keyframe2;
460 progressdata.
stop = stop;
470 &context->camera_intrinsics_options,
471 &reconstruction_options,
477 &context->camera_intrinsics_options,
478 &reconstruction_options,
482 if (context->select_keyframes) {
484 context->keyframe1 = reconstruction_options.
keyframe1;
485 context->keyframe2 = reconstruction_options.
keyframe2;
491 context->reprojection_error = error;
498 context,
"Failed to solve the motion: most likely there are no good keyframes");
506 context->object_name);
510 if (context->select_keyframes) {
511 tracking_object->
keyframe1 = context->keyframe1;
512 tracking_object->
keyframe2 = context->keyframe2;
515 reconstruction->
error = context->reprojection_error;
527 const float scale[3])
529 float first_camera_delta[3] = {0.0f, 0.0f, 0.0f};
531 if (reconstruction->
camnr > 0) {
535 for (
int i = 0; i < reconstruction->
camnr; i++) {
544 sub_v3_v3(track.bundle_pos, first_camera_delta);
#define STRNCPY_UTF8(dst, src)
Read Blender memory allocation and freeing.
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
float3x3 scale(float3x3 mat, float2 scale)
void libmv_cameraIntrinsicsExtractOptions(const libmv_CameraIntrinsics *libmv_intrinsics, libmv_CameraIntrinsicsOptions *camera_intrinsics_options)
struct libmv_CameraIntrinsics libmv_CameraIntrinsics
libmv_Reconstruction * libmv_solveModal(const libmv_Tracks *libmv_tracks, const libmv_CameraIntrinsicsOptions *libmv_camera_intrinsics_options, const libmv_ReconstructionOptions *libmv_reconstruction_options, reconstruct_progress_update_cb progress_update_callback, void *callback_customdata)
double libmv_reprojectionErrorForImage(const libmv_Reconstruction *libmv_reconstruction, int image)
double libmv_reprojectionError(const libmv_Reconstruction *libmv_reconstruction)
void libmv_reconstructionDestroy(libmv_Reconstruction *libmv_reconstruction)
int libmv_reconstructionIsValid(libmv_Reconstruction *libmv_reconstruction)
int libmv_reprojectionCameraForImage(const libmv_Reconstruction *libmv_reconstruction, int image, double mat[4][4])
libmv_CameraIntrinsics * libmv_reconstructionExtractIntrinsics(libmv_Reconstruction *libmv_reconstruction)
int libmv_reprojectionPointForTrack(const libmv_Reconstruction *libmv_reconstruction, int track, double pos[3])
libmv_Reconstruction * libmv_solveReconstruction(const libmv_Tracks *libmv_tracks, const libmv_CameraIntrinsicsOptions *libmv_camera_intrinsics_options, libmv_ReconstructionOptions *libmv_reconstruction_options, reconstruct_progress_update_cb progress_update_callback, void *callback_customdata)
double libmv_reprojectionErrorForTrack(const libmv_Reconstruction *libmv_reconstruction, int track)
@ LIBMV_REFINE_TANGENTIAL_DISTORTION
@ LIBMV_REFINE_FOCAL_LENGTH
@ LIBMV_REFINE_RADIAL_DISTORTION
@ LIBMV_REFINE_PRINCIPAL_POINT
struct libmv_Tracks libmv_Tracks
void BKE_tracking_reconstruction_report_error_message(MovieReconstructContext *context, const char *error_message)
size_t size_t size_t BLI_snprintf_utf8(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
bool BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieTracking *tracking)
bool BKE_tracking_reconstruction_check(MovieTracking *tracking, MovieTrackingObject *tracking_object, char *error_msg, int error_msg_maxncpy)
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
char * BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
void tracking_trackingCameraFromIntrinscisOptions(MovieTracking *tracking, const libmv_CameraIntrinsicsOptions *camera_intrinsics_options)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
MINLINE int max_ii(int a, int b)
static void tracking_scale_reconstruction(ListBaseT< MovieTrackingTrack > *tracksbase, MovieTrackingReconstruction *reconstruction, const float scale[3])
void tracks_map_insert(TracksMap *map, MovieTrackingTrack *track)
void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, bool *stop, bool *do_update, float *progress, char *stats_message, int message_size)
@ TRACKING_USE_KEYFRAME_SELECTION
bool BKE_tracking_track_has_enabled_marker_at_frame(MovieTrackingTrack *track, int framenr)
void BKE_tracking_dopesheet_tag_update(MovieTracking *tracking)
MINLINE void sub_v3_v3(float r[3], const float a[3])
static int reconstruct_count_tracks_on_both_keyframes(MovieTrackingObject *tracking_object)
void BKE_tracking_reconstruction_scale(MovieTracking *tracking, float scale[3])
void tracking_cameraIntrinscisOptionsFromTracking(MovieTracking *tracking, int calibration_width, int calibration_height, libmv_CameraIntrinsicsOptions *camera_intrinsics_options)
static void reconstruct_update_solve_cb(void *customdata, double progress, const char *message)
MINLINE void mul_v3_v3(float r[3], const float a[3])
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
MovieReconstructContext * BKE_tracking_reconstruction_context_new(MovieClip *clip, MovieTrackingObject *tracking_object, int keyframe1, int keyframe2, int width, int height)
static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context, MovieTracking *tracking)
void unit_m4(float m[4][4])
@ REFINE_RADIAL_DISTORTION
@ REFINE_TANGENTIAL_DISTORTION
void tracks_map_merge(TracksMap *map, MovieTracking *tracking)
void tracks_map_free(TracksMap *map)
static int reconstruct_refine_intrinsics_get_flags(MovieTracking *tracking, MovieTrackingObject *tracking_object)
const char * BKE_tracking_reconstruction_error_message_get(const MovieReconstructContext *context)
TracksMap * tracks_map_new(const char *object_name, int num_tracks)
FCurve * id_data_find_fcurve(ID *id, void *data, StructRNA *type, const char *prop_name, int index, bool *r_driven)
float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
MovieTrackingObject * BKE_tracking_object_get_named(MovieTracking *tracking, const char *name)
static void reconstructionOptionsFromContext(libmv_ReconstructionOptions *reconstruction_options, MovieReconstructContext *context)
void copy_m4_m4(float m1[4][4], const float m2[4][4])
MINLINE void mul_v3_v3v3(float r[3], const float v1[3], const float v2[3])
void BKE_tracking_reconstruction_context_free(MovieReconstructContext *context)
MINLINE int min_ii(int a, int b)
static void reconstruct_retrieve_libmv_intrinsics(MovieReconstructContext *context, MovieTracking *tracking)
static libmv_Tracks * libmv_tracks_new(MovieClip *clip, ListBaseT< MovieTrackingTrack > *tracksbase, int width, int height)
float evaluate_fcurve(const FCurve *fcu, float evaltime)
static int reconstruct_retrieve_libmv(MovieReconstructContext *context, MovieTracking *tracking)
struct MovieTracking tracking
libmv_Reconstruction * reconstruction
libmv_CameraIntrinsicsOptions camera_intrinsics_options
char object_name[MAX_NAME]
TrackingMotionFlag motion_flag
MovieTrackingReconstruction reconstruction
ListBaseT< MovieTrackingTrack > tracks
struct MovieReconstructedCamera * cameras
TrackingReconstructionFlag flag
TrackingRefineCameraFlag refine_camera_intrinsics
TrackingMotionFlag motion_flag
TrackingSettingsReconstructionFlag reconstruction_flag
struct MovieTrackingTrack * next
MovieTrackingMarker * markers
MovieTrackingCamera camera
MovieTrackingSettings settings
ListBaseT< MovieTrackingObject > objects
libmv_Tracks * libmv_tracksNew(void)
void libmv_tracksDestroy(libmv_Tracks *)
void libmv_tracksInsert(libmv_Tracks *, int, int, double, double, double)