Blender V5.3
tracking_auto.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cstdlib>
10
11#include "MEM_guardedalloc.h"
12
13#include "DNA_movieclip_types.h"
14#include "DNA_object_types.h" /* SELECT */
15
16#include "BLI_listbase.hh"
17#include "BLI_math_vector_c.hh"
18#include "BLI_task_c.hh"
19#include "BLI_threads.hh"
20#include "BLI_utildefines.hh"
21
22#include "BKE_movieclip.hh"
23#include "BKE_tracking.hh"
24
25#include "IMB_imbuf.hh"
26#include "IMB_imbuf_types.hh"
27
28#include "libmv-capi.h"
29#include "tracking_private.hh"
30
31namespace blender {
32
35
36 /* Dimensions of movie frame, in pixels.
37 *
38 * NOTE: All frames within a clip are expected to have match3ed dimensions. */
40};
41
43 /* Index of a clip from `AutoTrackContext::autotrack_clips` this track belongs to. */
45
47
48 /* Options for the region tracker. */
50
51 /* Denotes whether this track will be tracked.
52 * Is usually initialized based on track's selection. Non-trackable tracks are still added to the
53 * context to provide AutoTrack all knowledge about what is going on in the scene. */
55};
56
60
61/* Result of tracking step for a single marker.
62 *
63 * On success both marker and result are fully initialized to the position on the new frame.
64 *
65 * On failure marker's frame number is initialized to frame number where it was attempted to be
66 * tracked to. The position and other fields of tracked marker are the same as the input. */
74
76 /* --------------------------------------------------------------------
77 * Invariant part.
78 * Stays unchanged during the tracking process.
79 * If not the initialization process, all the fields here should be treated as `const`.
80 */
81
82 /* Frame at which tracking process started.
83 * NOTE: Measured in scene time frames, */
85
86 /* True when tracking backwards (from higher frame number to lower frame number.) */
88
89 /* Movie clips used during the tracking process. */
92
93 /* Tracks for which the context has been created for.
94 * This is a flat array of all tracks coming from all clips, regardless of whether track is
95 * actually being tracked or not. This allows the AutoTrack to see a big picture of hat is going
96 * on in the scene, and request information it needs.
97 *
98 * Indexed by AutoTrackOptions::track_index. */
101
102 /* Accessor for images of clip. Used by the autotrack context. */
104
105 /* Image buffers acquired for markers which are using keyframe pattern matching.
106 * These image buffers are user-referenced and flagged as persistent so that they don't get
107 * removed from the movie cache during tracking. */
110
111 /* --------------------------------------------------------------------
112 * Variant part.
113 * Denotes tracing state and tracking result.
114 */
115
116 /* Auto-track context.
117 *
118 * NOTE: Is accessed from multiple threads at once. */
120
121 /* Markers from the current frame which will be tracked to the next frame upon the tracking
122 * context step.
123 *
124 * NOTE: This array is re-used across tracking steps, which might make it appear that the array
125 * is over-allocated when some tracks has failed to track. */
128
129 /* Tracking results which are to be synchronized from the AutoTrack context to the Blender's
130 * DNA to make the results visible for users. */
131 ListBaseT<AutoTrackTrackingResult> results_to_sync;
133
135};
136
137/* -------------------------------------------------------------------- */
140
141static void normalized_to_libmv_frame(const float normalized[2],
142 const int frame_dimensions[2],
143 float result[2])
144{
145 result[0] = normalized[0] * frame_dimensions[0] - 0.5f;
146 result[1] = normalized[1] * frame_dimensions[1] - 0.5f;
147}
148
150 const float origin[2],
151 const int frame_dimensions[2],
152 float result[2])
153{
154 result[0] = (normalized[0] + origin[0]) * frame_dimensions[0] - 0.5f;
155 result[1] = (normalized[1] + origin[1]) * frame_dimensions[1] - 0.5f;
156}
157
158static void libmv_frame_to_normalized(const float frame_coord[2],
159 const int frame_dimensions[2],
160 float result[2])
161{
162 result[0] = (frame_coord[0] + 0.5f) / frame_dimensions[0];
163 result[1] = (frame_coord[1] + 0.5f) / frame_dimensions[1];
164}
165
166static void libmv_frame_to_normalized_relative(const float frame_coord[2],
167 const float origin[2],
168 const int frame_dimensions[2],
169 float result[2])
170{
171 result[0] = (frame_coord[0] - origin[0]) / frame_dimensions[0];
172 result[1] = (frame_coord[1] - origin[1]) / frame_dimensions[1];
173}
174
176
177/* -------------------------------------------------------------------- */
180
182 const MovieTrackingMarker &marker,
183 const int clip,
184 const int track_index,
185 const int frame_width,
186 const int frame_height,
187 const bool backwards)
188{
189 libmv_Marker libmv_marker{};
190
191 const int frame_dimensions[2] = {frame_width, frame_height};
192 libmv_marker.clip = clip;
193 libmv_marker.frame = marker.framenr;
194 libmv_marker.track = track_index;
195
196 normalized_to_libmv_frame(marker.pos, frame_dimensions, libmv_marker.center);
197 for (int i = 0; i < 4; i++) {
199 marker.pattern_corners[i], marker.pos, frame_dimensions, libmv_marker.patch[i]);
200 }
201
203 marker.search_min, marker.pos, frame_dimensions, libmv_marker.search_region_min);
204
206 marker.search_max, marker.pos, frame_dimensions, libmv_marker.search_region_max);
207
208 /* NOTE: All the markers does have 1.0 weight.
209 * Might support in the future, but will require more elaborated process which will involve
210 * F-Curve evaluation. */
211 libmv_marker.weight = 1.0f;
212
213 if (marker.flag & MARKER_TRACKED) {
214 libmv_marker.source = LIBMV_MARKER_SOURCE_TRACKED;
215 }
216 else {
217 libmv_marker.source = LIBMV_MARKER_SOURCE_MANUAL;
218 }
219 libmv_marker.status = LIBMV_MARKER_STATUS_UNKNOWN;
221 libmv_marker.model_id = 0;
222
223 /* NOTE: We currently don't support reference marker from different clip. */
224 libmv_marker.reference_clip = clip;
225
226 if (track.pattern_match == TRACK_MATCH_KEYFRAME) {
227 const MovieTrackingMarker *keyframe_marker = tracking_get_keyframed_marker(
228 &track, marker.framenr, backwards);
229 libmv_marker.reference_frame = keyframe_marker->framenr;
230 }
231 else {
232 libmv_marker.reference_frame = backwards ? marker.framenr - 1 : marker.framenr;
233 }
234
235 libmv_marker.disabled_channels =
239
240 return libmv_marker;
241}
242
244 const int frame_width,
245 const int frame_height)
246{
247 MovieTrackingMarker marker{};
248
249 const int frame_dimensions[2] = {frame_width, frame_height};
250 marker.framenr = libmv_marker.frame;
251
252 libmv_frame_to_normalized(libmv_marker.center, frame_dimensions, marker.pos);
253 for (int i = 0; i < 4; i++) {
255 libmv_marker.patch[i], libmv_marker.center, frame_dimensions, marker.pattern_corners[i]);
256 }
257
259 libmv_marker.search_region_min, libmv_marker.center, frame_dimensions, marker.search_min);
260
262 libmv_marker.search_region_max, libmv_marker.center, frame_dimensions, marker.search_max);
263
264 marker.flag = TrackingMarkerFlag{};
265 if (libmv_marker.source == LIBMV_MARKER_SOURCE_TRACKED) {
266 marker.flag |= MARKER_TRACKED;
267 }
268 else {
269 marker.flag &= ~MARKER_TRACKED;
270 }
271
272 return marker;
273}
274
276
277/* -------------------------------------------------------------------- */
282
283/* Returns false if marker crossed margin area from frame bounds. */
284static bool tracking_check_marker_margin(const libmv_Marker &libmv_marker,
285 const int margin,
286 const int frame_width,
287 const int frame_height)
288{
289 float patch_min[2], patch_max[2];
290 float margin_left, margin_top, margin_right, margin_bottom;
291
292 INIT_MINMAX2(patch_min, patch_max);
293 minmax_v2v2_v2(patch_min, patch_max, libmv_marker.patch[0]);
294 minmax_v2v2_v2(patch_min, patch_max, libmv_marker.patch[1]);
295 minmax_v2v2_v2(patch_min, patch_max, libmv_marker.patch[2]);
296 minmax_v2v2_v2(patch_min, patch_max, libmv_marker.patch[3]);
297
298 margin_left = max_ff(libmv_marker.center[0] - patch_min[0], margin);
299 margin_top = max_ff(patch_max[1] - libmv_marker.center[1], margin);
300 margin_right = max_ff(patch_max[0] - libmv_marker.center[0], margin);
301 margin_bottom = max_ff(libmv_marker.center[1] - patch_min[1], margin);
302
303 if (libmv_marker.center[0] < margin_left ||
304 libmv_marker.center[0] > frame_width - margin_right ||
305 libmv_marker.center[1] < margin_bottom || libmv_marker.center[1] > frame_height - margin_top)
306 {
307 return false;
308 }
309
310 return true;
311}
312
314
315/* -------------------------------------------------------------------- */
318
320{
321 if (marker.flag & MARKER_DISABLED) {
322 return false;
323 }
324 return true;
325}
326
328 const AutoTrackTrack *autotrack_track)
329{
330 /*const*/ MovieTrackingTrack *track = autotrack_track->track;
331 if (TRACK_SELECTED(track) && (track->flag & (TRACK_LOCKED | TRACK_HIDDEN)) == 0) {
332 const AutoTrackClip *autotrack_clip = &context->autotrack_clips[autotrack_track->clip_index];
333 MovieClip *clip = autotrack_clip->clip;
334 const int clip_frame_number = BKE_movieclip_remap_scene_to_clip_frame(
335 clip, context->start_scene_frame);
336
337 const MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_frame_number);
338 return autotrack_is_marker_usable(*marker);
339 }
340 return false;
341}
342
344 MovieClip *clip,
345 MovieClipUser *user)
346{
347 /* NOTE: Currently only tracking within a single clip. */
348
349 context->num_clips = 1;
350
351 context->autotrack_clips[0].clip = clip;
353 clip, user, &context->autotrack_clips[0].width, &context->autotrack_clips[0].height);
354}
355
356/* Initialize flat list of tracks for quick index-based access for the specified clip.
357 * All the tracks from this clip are added at the end of the array of already-collected tracks.
358 *
359 * NOTE: Clips should be initialized first. */
360static void autotrack_context_init_tracks_for_clip(AutoTrackContext *context, int clip_index)
361{
362 BLI_assert(clip_index >= 0);
363 BLI_assert(clip_index < context->num_clips);
364
365 const AutoTrackClip *autotrack_clip = &context->autotrack_clips[clip_index];
366 MovieClip *clip = autotrack_clip->clip;
367 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
368
369 const int num_clip_tracks = tracking_object->tracks.count();
370 if (num_clip_tracks == 0) {
371 return;
372 }
373
374 context->all_autotrack_tracks = static_cast<AutoTrackTrack *>(MEM_realloc_uninitialized(
375 context->all_autotrack_tracks,
376 (context->num_all_tracks + num_clip_tracks) * sizeof(AutoTrackTrack)));
377
378 for (MovieTrackingTrack &track : tracking_object->tracks) {
379 AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[context->num_all_tracks++];
380 autotrack_track->clip_index = clip_index;
381 autotrack_track->track = &track;
382 autotrack_track->is_trackable = autotrack_is_track_trackable(context, autotrack_track);
383
385 &track, nullptr, context->is_backwards, &autotrack_track->track_region_options);
386 }
387}
388
389/* Initialize flat list of tracks for quick index-based access for all clips used for tracking.
390 *
391 * NOTE: Clips should be initialized first. */
393{
394 BLI_assert(context->num_clips >= 1);
395
396 for (int clip_index = 0; clip_index < context->num_clips; ++clip_index) {
397 autotrack_context_init_tracks_for_clip(context, clip_index);
398 }
399}
400
401/* NOTE: Clips should be initialized first. */
403{
404 BLI_assert(context->num_clips >= 1);
405
406 /* Planarize arrays of clips and tracks, storing pointers to their base "objects".
407 * This allows image accessor to be independent, but adds some overhead here. Could be solved
408 * by either more strongly coupling accessor API with the AutoTrack, or by giving some functors
409 * to the accessor to access clip/track from their indices. */
410
412 for (int i = 0; i < context->num_clips; ++i) {
413 clips[i] = context->autotrack_clips[i].clip;
414 }
415
417 context->num_all_tracks, "image accessor init tracks");
418 for (int i = 0; i < context->num_all_tracks; ++i) {
419 tracks[i] = context->all_autotrack_tracks[i].track;
420 }
421
422 context->image_accessor = tracking_image_accessor_new(clips, 1, tracks, context->num_all_tracks);
423
424 MEM_delete(tracks);
425}
426
427/* Count markers which are usable to be passed to the AutoTrack context. */
429{
430 size_t num_usable_markers = 0;
431 for (int track_index = 0; track_index < context->num_all_tracks; ++track_index) {
432 const MovieTrackingTrack *track = context->all_autotrack_tracks[track_index].track;
433 for (int marker_index = 0; marker_index < track->markersnr; ++marker_index) {
434 const MovieTrackingMarker &marker = track->markers[marker_index];
435 if (!autotrack_is_marker_usable(marker)) {
436 continue;
437 }
438 num_usable_markers++;
439 }
440 }
441 return num_usable_markers;
442}
443
445{
446 int num_trackable_markers = 0;
447 for (int track_index = 0; track_index < context->num_all_tracks; ++track_index) {
448 const AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[track_index];
449 if (!autotrack_track->is_trackable) {
450 continue;
451 }
452 num_trackable_markers++;
453 }
454 return num_trackable_markers;
455}
456
457/* Provide Libmv side of auto track all information about given tracks.
458 * Information from all clips is passed to the auto tracker.
459 *
460 * NOTE: Clips and all tracks are to be initialized before calling this. */
462{
463 context->autotrack = libmv_autoTrackNew(context->image_accessor->libmv_accessor);
464
465 /* Count number of markers to be put to a context. */
466 const size_t num_trackable_markers = autotrack_count_all_usable_markers(context);
467 if (num_trackable_markers == 0) {
468 return;
469 }
470
471 /* Allocate memory for all the markers. */
472 libmv_Marker *libmv_markers = MEM_new_array_zeroed<libmv_Marker>(num_trackable_markers,
473 "libmv markers array");
474
475 /* Fill in markers array. */
476 int num_filled_libmv_markers = 0;
477 for (int track_index = 0; track_index < context->num_all_tracks; ++track_index) {
478 const AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[track_index];
479 /*const*/ MovieTrackingTrack &track = *autotrack_track->track;
480 for (int marker_index = 0; marker_index < track.markersnr; ++marker_index) {
481 /*const*/ MovieTrackingMarker &marker = track.markers[marker_index];
482 if (!autotrack_is_marker_usable(marker)) {
483 continue;
484 }
485 const AutoTrackClip *autotrack_clip = &context->autotrack_clips[autotrack_track->clip_index];
486 libmv_markers[num_filled_libmv_markers++] = dna_marker_to_libmv_marker(
487 track,
488 marker,
489 autotrack_track->clip_index,
490 track_index,
491 autotrack_clip->width,
492 autotrack_clip->height,
493 context->is_backwards);
494 }
495 }
496
497 /* Add all markers to autotrack. */
498 libmv_autoTrackSetMarkers(context->autotrack, libmv_markers, num_trackable_markers);
499
500 /* Free temporary memory. */
501 MEM_delete(libmv_markers);
502}
503
505{
506 /* Count number of trackable tracks. */
507 context->num_autotrack_markers = autotrack_count_trackable_markers(context);
508 if (context->num_autotrack_markers == 0) {
509 return;
510 }
511
512 /* Allocate required memory. */
513 context->autotrack_markers = MEM_new_array_zeroed<AutoTrackMarker>(
514 context->num_autotrack_markers, "auto track options");
515
516 /* Fill in all the markers. */
517 int autotrack_marker_index = 0;
518 for (int track_index = 0; track_index < context->num_all_tracks; ++track_index) {
519 const AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[track_index];
520 if (!autotrack_track->is_trackable) {
521 continue;
522 }
523
524 const AutoTrackClip *autotrack_clip = &context->autotrack_clips[autotrack_track->clip_index];
525 MovieClip *clip = autotrack_clip->clip;
526 const int clip_frame_number = BKE_movieclip_remap_scene_to_clip_frame(
527 clip, context->start_scene_frame);
528
529 /*const*/ MovieTrackingTrack &track = *context->all_autotrack_tracks[track_index].track;
530 const MovieTrackingMarker &marker = *BKE_tracking_marker_get(&track, clip_frame_number);
531
532 AutoTrackMarker *autotrack_marker = &context->autotrack_markers[autotrack_marker_index++];
533 autotrack_marker->libmv_marker = dna_marker_to_libmv_marker(track,
534 marker,
535 autotrack_track->clip_index,
536 track_index,
537 autotrack_clip->width,
538 autotrack_clip->height,
539 context->is_backwards);
540 }
541}
542
544 MovieClipUser *user,
545 const bool is_backwards)
546{
547 AutoTrackContext *context = MEM_new_zeroed<AutoTrackContext>("autotrack context");
548
549 context->start_scene_frame = user->framenr;
550 context->is_backwards = is_backwards;
551 context->synchronized_scene_frame = context->start_scene_frame;
552
553 autotrack_context_init_clips(context, clip, user);
558
559 BLI_spin_init(&context->spin_lock);
560
561 return context;
562}
563
565
566/* -------------------------------------------------------------------- */
571
573{
574 /* NOTE: This is potentially over-allocating, but it simplifies memory manipulation.
575 * In practice this is unlikely to be noticed in the profiler as the memory footprint of this
576 * data is way less of what the tracking process will use. */
577 context->referenced_image_buffers = MEM_new_array_zeroed<ImBuf *>(context->num_autotrack_markers,
578 __func__);
579
580 context->num_referenced_image_buffers = 0;
581
582 for (int i = 0; i < context->num_autotrack_markers; ++i) {
583 const AutoTrackMarker *autotrack_marker = &context->autotrack_markers[i];
584 const int clip_index = autotrack_marker->libmv_marker.clip;
585 const int track_index = autotrack_marker->libmv_marker.track;
586
587 const AutoTrackClip *autotrack_clip = &context->autotrack_clips[clip_index];
588 const AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[track_index];
589 const MovieTrackingTrack *track = autotrack_track->track;
590
591 if (track->pattern_match != TRACK_MATCH_KEYFRAME) {
592 continue;
593 }
594
595 const int scene_frame = BKE_movieclip_remap_clip_to_scene_frame(
596 autotrack_clip->clip, autotrack_marker->libmv_marker.reference_frame);
597
598 MovieClipUser user_at_keyframe;
599 BKE_movieclip_user_set_frame(&user_at_keyframe, scene_frame);
600 user_at_keyframe.render_size = MCLIP_PROXY_RENDER_SIZE_FULL;
601 user_at_keyframe.render_flag = eMovieClipProxy_RenderFlag{};
602
603 /* Keep reference to the image buffer so that we can manipulate its flags later on.
604 * Also request the movie cache to not remove the image buffer from the cache. */
605 ImBuf *ibuf = BKE_movieclip_get_ibuf(autotrack_clip->clip, &user_at_keyframe);
606 ibuf->userflags |= IB_PERSISTENT;
607
608 context->referenced_image_buffers[context->num_referenced_image_buffers++] = ibuf;
609 }
610}
611
616
618
619/* -------------------------------------------------------------------- */
622
623/* NOTE: This is a TLS in a sense that this struct is never accessed from multiple threads, and
624 * that threads are re-using the struct as much as possible. */
626 ListBaseT<AutoTrackTrackingResult> results;
627};
628
629static void autotrack_context_step_cb(void *__restrict userdata,
630 const int marker_index,
631 const TaskParallelTLS *__restrict tls)
632{
633 AutoTrackContext *context = static_cast<AutoTrackContext *>(userdata);
634 AutoTrackTLS *autotrack_tls = static_cast<AutoTrackTLS *>(tls->userdata_chunk);
635
636 const AutoTrackMarker &autotrack_marker = context->autotrack_markers[marker_index];
637 const libmv_Marker &libmv_current_marker = autotrack_marker.libmv_marker;
638
639 const int frame_delta = context->is_backwards ? -1 : 1;
640 const int clip_index = libmv_current_marker.clip;
641 const int track_index = libmv_current_marker.track;
642
643 const AutoTrackClip &autotrack_clip = context->autotrack_clips[clip_index];
644 const AutoTrackTrack &autotrack_track = context->all_autotrack_tracks[track_index];
645 const MovieTrackingTrack &track = *autotrack_track.track;
646
647 /* Check whether marker is going outside of allowed frame margin. */
649 libmv_current_marker, track.margin, autotrack_clip.width, autotrack_clip.height))
650 {
651 return;
652 }
653
654 const int new_marker_frame = libmv_current_marker.frame + frame_delta;
655
657 "autotrack result");
658 autotrack_result->libmv_marker = libmv_current_marker;
659 autotrack_result->libmv_marker.frame = new_marker_frame;
660
661 /* Update reference frame. */
662 libmv_Marker libmv_reference_marker;
663 if (track.pattern_match == TRACK_MATCH_KEYFRAME) {
664 autotrack_result->libmv_marker.reference_frame = libmv_current_marker.reference_frame;
665 libmv_autoTrackGetMarker(context->autotrack,
666 clip_index,
667 autotrack_result->libmv_marker.reference_frame,
668 track_index,
669 &libmv_reference_marker);
670 }
671 else {
673 autotrack_result->libmv_marker.reference_frame = libmv_current_marker.frame;
674 libmv_reference_marker = libmv_current_marker;
675 }
676
677 /* Perform actual tracking. */
678 autotrack_result->success = libmv_autoTrackMarker(context->autotrack,
679 &autotrack_track.track_region_options,
680 &autotrack_result->libmv_marker,
681 &autotrack_result->libmv_result);
682
683 /* If tracking failed restore initial position.
684 * This is how Blender side is currently expecting failed track to be handled. Without this the
685 * marker is left in an arbitrary position which did not provide good correlation. */
686 if (!autotrack_result->success) {
687 autotrack_result->libmv_marker = libmv_current_marker;
688 autotrack_result->libmv_marker.frame = new_marker_frame;
689 }
690
691 BLI_addtail(&autotrack_tls->results, autotrack_result);
692}
693
694static void autotrack_context_reduce(const void *__restrict /*userdata*/,
695 void *__restrict chunk_join,
696 void *__restrict chunk)
697{
698 AutoTrackTLS *autotrack_tls = static_cast<AutoTrackTLS *>(chunk);
699 if (autotrack_tls->results.is_empty()) {
700 /* Nothing to be joined from. */
701 return;
702 }
703
704 AutoTrackTLS *autotrack_tls_join = static_cast<AutoTrackTLS *>(chunk_join);
705 BLI_movelisttolist(&autotrack_tls_join->results, &autotrack_tls->results);
706}
707
709{
710 if (context->num_autotrack_markers == 0) {
711 return false;
712 }
713
714 AutoTrackTLS tls;
715 tls.results.clear_no_delete();
716
717 TaskParallelSettings settings;
719 settings.use_threading = (context->num_autotrack_markers > 1);
720 settings.userdata_chunk = &tls;
721 settings.userdata_chunk_size = sizeof(AutoTrackTLS);
723
725 0, context->num_autotrack_markers, context, autotrack_context_step_cb, &settings);
726
727 /* Prepare next tracking step by updating the AutoTrack context with new markers and moving
728 * tracked markers as an input for the next iteration. */
729 context->num_autotrack_markers = 0;
730 for (AutoTrackTrackingResult &autotrack_result : tls.results) {
731 if (!autotrack_result.success) {
732 continue;
733 }
734
735 /* Insert tracking results to the AutoTrack context to make them usable for the next frame
736 * tracking iteration. */
737 libmv_autoTrackAddMarker(context->autotrack, &autotrack_result.libmv_marker);
738
739 /* Update the list of markers which will be tracked on the next iteration. */
740 context->autotrack_markers[context->num_autotrack_markers++].libmv_marker =
741 autotrack_result.libmv_marker;
742 }
743
744 BLI_spin_lock(&context->spin_lock);
745 BLI_movelisttolist(&context->results_to_sync, &tls.results);
746 BLI_spin_unlock(&context->spin_lock);
747
748 return true;
749}
750
752
753/* -------------------------------------------------------------------- */
760
762{
763 const int frame_delta = context->is_backwards ? -1 : 1;
764
765 BLI_spin_lock(&context->spin_lock);
766 ListBaseT<AutoTrackTrackingResult> results_to_sync = context->results_to_sync;
767 context->results_to_sync.clear_no_delete();
768 BLI_spin_unlock(&context->spin_lock);
769
770 for (AutoTrackTrackingResult &autotrack_result : results_to_sync.items_mutable()) {
771 const libmv_Marker &libmv_marker = autotrack_result.libmv_marker;
772 const int clip_index = libmv_marker.clip;
773 const int track_index = libmv_marker.track;
774 const AutoTrackClip &autotrack_clip = context->autotrack_clips[clip_index];
775 const MovieClip *clip = autotrack_clip.clip;
776 const AutoTrackTrack &autotrack_track = context->all_autotrack_tracks[track_index];
777 MovieTrackingTrack *track = autotrack_track.track;
778
779 const int start_clip_frame = BKE_movieclip_remap_scene_to_clip_frame(
780 clip, context->start_scene_frame);
781 const int first_result_frame = start_clip_frame + frame_delta;
782
783 /* Insert marker which corresponds to the tracking result. */
785 autotrack_result.libmv_marker, autotrack_clip.width, autotrack_clip.height);
786 if (!autotrack_result.success) {
787 marker.flag |= MARKER_DISABLED;
788 }
789 BKE_tracking_marker_insert(track, &marker);
790
791 /* Insert disabled marker at the end of tracked segment.
792 * When tracking forward the disabled marker is added at the next frame from the result,
793 * when tracking backwards the marker is added at the previous frame. */
794 tracking_marker_insert_disabled(track, &marker, context->is_backwards, false);
795
796 if (marker.framenr == first_result_frame) {
798 track, marker.framenr - frame_delta);
799 BLI_assert(prev_marker != nullptr);
800
801 tracking_marker_insert_disabled(track, prev_marker, !context->is_backwards, false);
802 }
803
804 /* Update synchronized frame to the latest tracked fame from the current results. */
805 const int marker_scene_frame = BKE_movieclip_remap_clip_to_scene_frame(clip, marker.framenr);
806 if (context->is_backwards) {
807 context->synchronized_scene_frame = min_ii(context->synchronized_scene_frame,
808 marker_scene_frame);
809 }
810 else {
811 context->synchronized_scene_frame = max_ii(context->synchronized_scene_frame,
812 marker_scene_frame);
813 }
814
815 MEM_delete(&autotrack_result);
816 }
817
818 for (int clip_index = 0; clip_index < context->num_clips; clip_index++) {
819 MovieTracking *tracking = &context->autotrack_clips[clip_index].clip->tracking;
821 }
822}
823
825{
826 /* TODO(sergey): Find a way to avoid this function,
827 * somehow making all needed logic in #BKE_autotrack_context_sync(). */
828
829 user->framenr = context->synchronized_scene_frame;
830}
831
833
834/* -------------------------------------------------------------------- */
837
839{
840 for (int clip_index = 0; clip_index < context->num_clips; clip_index++) {
841 const AutoTrackClip *autotrack_clip = &context->autotrack_clips[clip_index];
842 MovieClip *clip = autotrack_clip->clip;
843 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
844 const int start_clip_frame = BKE_movieclip_remap_scene_to_clip_frame(
845 clip, context->start_scene_frame);
846
847 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
848 if (plane_track.flag & PLANE_TRACK_AUTOKEY) {
849 continue;
850 }
851 for (int track_index = 0; track_index < context->num_all_tracks; track_index++) {
852 const AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[track_index];
853 if (!autotrack_track->is_trackable) {
854 continue;
855 }
856 MovieTrackingTrack *track = autotrack_track->track;
857 if (BKE_tracking_plane_track_has_point_track(&plane_track, track)) {
858 BKE_tracking_track_plane_from_existing_motion(&plane_track, start_clip_frame);
859 break;
860 }
861 }
862 }
863 }
864}
865
867{
868 for (int i = 0; i < context->num_referenced_image_buffers; ++i) {
869 ImBuf *ibuf = context->referenced_image_buffers[i];
870
871 /* Restore flag. It is not expected that anyone else is setting this flag on image buffers from
872 * movie clip, so can simply clear the flag. */
873 ibuf->userflags &= ~IB_PERSISTENT;
874 IMB_freeImBuf(ibuf);
875 }
876
877 MEM_delete(context->referenced_image_buffers);
878}
879
881{
882 if (context->autotrack != nullptr) {
883 libmv_autoTrackDestroy(context->autotrack);
884 }
885
886 if (context->image_accessor != nullptr) {
887 tracking_image_accessor_destroy(context->image_accessor);
888 }
889
891
892 MEM_SAFE_DELETE(context->all_autotrack_tracks);
893 MEM_SAFE_DELETE(context->autotrack_markers);
894
895 context->results_to_sync.free_no_destruct();
896
897 BLI_spin_end(&context->spin_lock);
898
899 MEM_delete(context);
900}
901
903
904} // namespace blender
#define TRACK_SELECTED(track)
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define INIT_MINMAX2(min, max)
#define MEM_realloc_uninitialized(vmemh, len)
void libmv_autoTrackSetMarkers(libmv_AutoTrack *libmv_autotrack, const libmv_Marker *libmv_marker, size_t num_markers)
libmv_AutoTrack * libmv_autoTrackNew(libmv_FrameAccessor *frame_accessor)
int libmv_autoTrackMarker(libmv_AutoTrack *libmv_autotrack, const libmv_TrackRegionOptions *libmv_options, libmv_Marker *libmv_tracked_marker, libmv_TrackRegionResult *libmv_result)
void libmv_autoTrackDestroy(libmv_AutoTrack *libmv_autotrack)
int libmv_autoTrackGetMarker(libmv_AutoTrack *libmv_autotrack, int clip, int frame, int track, libmv_Marker *libmv_marker)
void libmv_autoTrackAddMarker(libmv_AutoTrack *libmv_autotrack, const libmv_Marker *libmv_marker)
struct libmv_AutoTrack libmv_AutoTrack
ccl_device_inline Quaternion normalized(const Quaternion q)
BMesh Iterators.
static void autotrack_context_init_autotrack(AutoTrackContext *context)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
bool BKE_autotrack_context_step(AutoTrackContext *context)
MovieTrackingMarker * BKE_tracking_marker_get_exact(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1396
void BKE_tracking_track_plane_from_existing_motion(MovieTrackingPlaneTrack *plane_track, int start_frame)
void BKE_movieclip_get_size(MovieClip *clip, const MovieClipUser *user, int *r_width, int *r_height)
static void autotrack_context_step_cb(void *__restrict userdata, const int marker_index, const TaskParallelTLS *__restrict tls)
BLI_INLINE void BLI_parallel_range_settings_defaults(TaskParallelSettings *settings)
static MovieTrackingMarker libmv_marker_to_dna_marker(const libmv_Marker &libmv_marker, const int frame_width, const int frame_height)
pthread_spinlock_t SpinLock
void tracking_marker_insert_disabled(MovieTrackingTrack *track, const MovieTrackingMarker *ref_marker, bool before, bool overwrite)
@ TRACK_MATCH_PREVIOUS_FRAME
static bool autotrack_is_marker_usable(const MovieTrackingMarker &marker)
bool BKE_tracking_plane_track_has_point_track(MovieTrackingPlaneTrack *plane_track, MovieTrackingTrack *track)
Definition tracking.cc:1647
static void autotrack_context_init_clips(AutoTrackContext *context, MovieClip *clip, MovieClipUser *user)
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
Definition tracking.cc:1982
static void libmv_frame_to_normalized(const float frame_coord[2], const int frame_dimensions[2], float result[2])
void void void BLI_movelisttolist(ListBase *dst, ListBase *src) ATTR_NONNULL(1
Definition listbase.cc:32
static void normalized_to_libmv_frame(const float normalized[2], const int frame_dimensions[2], float result[2])
static void libmv_frame_to_normalized_relative(const float frame_coord[2], const float origin[2], const int frame_dimensions[2], float result[2])
static void autotrack_context_reduce(const void *__restrict, void *__restrict chunk_join, void *__restrict chunk)
MINLINE int max_ii(int a, int b)
void BLI_task_parallel_range(int start, int stop, void *userdata, TaskParallelRangeFunc func, const TaskParallelSettings *settings)
static void autotrack_context_init_tracks_for_clip(AutoTrackContext *context, int clip_index)
void BKE_autotrack_context_start(AutoTrackContext *context)
@ MCLIP_PROXY_RENDER_SIZE_FULL
static void autotrack_context_init_markers(AutoTrackContext *context)
MovieTrackingMarker * BKE_tracking_marker_insert(MovieTrackingTrack *track, MovieTrackingMarker *marker)
Definition tracking.cc:1240
void BKE_tracking_dopesheet_tag_update(MovieTracking *tracking)
Definition tracking.cc:3355
MovieTrackingMarker * tracking_get_keyframed_marker(MovieTrackingTrack *track, int current_frame, bool backwards)
void BLI_spin_end(SpinLock *spin)
Definition threads.cc:448
void IMB_freeImBuf(ImBuf *ibuf)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void minmax_v2v2_v2(float min[2], float max[2], const float vec[2])
static void autotrack_context_init_image_accessor(AutoTrackContext *context)
static bool tracking_check_marker_margin(const libmv_Marker &libmv_marker, const int margin, const int frame_width, const int frame_height)
static void reference_keyframed_image_buffers(AutoTrackContext *context)
TrackingImageAccessor * tracking_image_accessor_new(MovieClip *clips[MAX_ACCESSOR_CLIP], int num_clips, MovieTrackingTrack **tracks, int num_tracks)
void tracking_configure_tracker(const MovieTrackingTrack *track, float *mask, bool is_backwards, libmv_TrackRegionOptions *options)
ImBuf * BKE_movieclip_get_ibuf(MovieClip *clip, const MovieClipUser *user)
void BKE_autotrack_context_finish(AutoTrackContext *context)
static void autotrack_context_init_tracks(AutoTrackContext *context)
void BKE_movieclip_user_set_frame(MovieClipUser *user, int framenr)
float BKE_movieclip_remap_scene_to_clip_frame(const MovieClip *clip, float framenr)
void BLI_spin_unlock(SpinLock *spin)
Definition threads.cc:433
void BLI_spin_init(SpinLock *spin)
Definition threads.cc:394
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
MINLINE float max_ff(float a, float b)
static bool autotrack_is_track_trackable(const AutoTrackContext *context, const AutoTrackTrack *autotrack_track)
struct AutoTrackContext * BKE_autotrack_context_new(MovieClip *clip, MovieClipUser *user, bool is_backwards)
static int autotrack_count_trackable_markers(AutoTrackContext *context)
void BKE_autotrack_context_sync(AutoTrackContext *context)
float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
void BKE_autotrack_context_sync_user(AutoTrackContext *context, MovieClipUser *user)
static void release_keyframed_image_buffers(AutoTrackContext *context)
void BKE_autotrack_context_free(AutoTrackContext *context)
MINLINE int min_ii(int a, int b)
static void normalized_relative_to_libmv_frame(const float normalized[2], const float origin[2], const int frame_dimensions[2], float result[2])
void BLI_spin_lock(SpinLock *spin)
Definition threads.cc:408
static libmv_Marker dna_marker_to_libmv_marker(MovieTrackingTrack &track, const MovieTrackingMarker &marker, const int clip, const int track_index, const int frame_width, const int frame_height, const bool backwards)
static size_t autotrack_count_all_usable_markers(AutoTrackContext *context)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void tracking_image_accessor_destroy(TrackingImageAccessor *accessor)
MovieTrackingMarker * BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1363
libmv_AutoTrack * autotrack
AutoTrackTrack * all_autotrack_tracks
ListBaseT< AutoTrackTrackingResult > results_to_sync
AutoTrackMarker * autotrack_markers
AutoTrackClip autotrack_clips[MAX_ACCESSOR_CLIP]
TrackingImageAccessor * image_accessor
ListBaseT< AutoTrackTrackingResult > results
MovieTrackingTrack * track
libmv_TrackRegionOptions track_region_options
libmv_TrackRegionResult libmv_result
AutoTrackTrackingResult * next
AutoTrackTrackingResult * prev
eMovieClipProxy_RenderFlag render_flag
eMovieClipProxy_RenderSize render_size
struct MovieTracking tracking
ListBaseT< MovieTrackingTrack > tracks
ListBaseT< MovieTrackingPlaneTrack > plane_tracks
MovieTrackingMarker * markers
TaskParallelReduceFunc func_reduce
float search_region_max[2]
Definition tracksN.h:54
float center[2]
Definition tracksN.h:51
float search_region_min[2]
Definition tracksN.h:53
int disabled_channels
Definition tracksN.h:62
libmv_MarkerModelType model_type
Definition tracksN.h:60
float patch[4][2]
Definition tracksN.h:52
int reference_frame
Definition tracksN.h:59
int reference_clip
Definition tracksN.h:58
float weight
Definition tracksN.h:55
libmv_MarkerSource source
Definition tracksN.h:56
int model_id
Definition tracksN.h:61
libmv_MarkerStatus status
Definition tracksN.h:57
#define MAX_ACCESSOR_CLIP
@ LIBMV_MARKER_CHANNEL_B
Definition tracksN.h:44
@ LIBMV_MARKER_CHANNEL_G
Definition tracksN.h:43
@ LIBMV_MARKER_CHANNEL_R
Definition tracksN.h:42
@ LIBMV_MARKER_SOURCE_TRACKED
Definition tracksN.h:23
@ LIBMV_MARKER_SOURCE_MANUAL
Definition tracksN.h:21
@ LIBMV_MARKER_STATUS_UNKNOWN
Definition tracksN.h:29
@ LIBMV_MARKER_MODEL_TYPE_POINT
Definition tracksN.h:35