Blender V5.3
tracking.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 <climits>
10#include <cmath>
11#include <cstddef>
12#include <cstdint>
13#include <limits>
14#include <memory.h>
15
16#include "MEM_guardedalloc.h"
17
18#include "DNA_anim_types.h"
19#include "DNA_camera_types.h"
21#include "DNA_movieclip_types.h"
22#include "DNA_object_types.h" /* SELECT */
23#include "DNA_scene_types.h"
24
25#include "BLI_bitmap_draw_2d.hh"
26#include "BLI_ghash.hh"
27#include "BLI_hash.hh"
28#include "BLI_index_range.hh"
29#include "BLI_listbase.hh"
30#include "BLI_math_base_c.hh"
31#include "BLI_math_geom_c.hh"
32#include "BLI_math_matrix_c.hh"
33#include "BLI_math_vector_c.hh"
35#include "BLI_string.hh"
36#include "BLI_string_utf8.hh"
37#include "BLI_string_utils.hh"
38#include "BLI_task.hh"
39#include "BLI_utildefines.hh"
40
41#include "BLT_translation.hh"
42
43#include "BKE_fcurve.hh"
44#include "BKE_lib_id.hh"
45#include "BKE_movieclip.hh"
46#include "BKE_object.hh"
47#include "BKE_scene.hh"
48#include "BKE_tracking.hh"
49
50#include "IMB_imbuf.hh"
51#include "IMB_imbuf_types.hh"
52
53#include "RNA_prototypes.hh"
54
55#include "libmv-capi.h"
56#include "tracking_private.hh"
57
58namespace blender {
59
62 /* Parameters needed for coordinates normalization. */
63 float principal_px[2];
65 float focal;
66};
67
68static struct {
69 ListBaseT<MovieTrackingTrack> tracks;
71
72/* --------------------------------------------------------------------
73 * Common functions.
74 */
75
76/* Free the whole list of tracks, list's head and tail are set to nullptr. */
77static void tracking_tracks_free(ListBaseT<MovieTrackingTrack> *tracks)
78{
79 for (MovieTrackingTrack &track : *tracks) {
81 }
82
83 tracks->free_no_destruct();
84}
85
86/* Free the whole list of plane tracks, list's head and tail are set to nullptr. */
87static void tracking_plane_tracks_free(ListBaseT<MovieTrackingPlaneTrack> *plane_tracks)
88{
89 for (MovieTrackingPlaneTrack &plane_track : *plane_tracks) {
91 }
92
93 plane_tracks->free_no_destruct();
94}
95
96/* Free reconstruction structures, only frees contents of a structure,
97 * (if structure is allocated in heap, it shall be handled outside).
98 *
99 * All the pointers inside structure becomes invalid after this call.
100 */
102{
103 if (reconstruction->cameras) {
104 MEM_delete(reconstruction->cameras);
105 }
106}
107
108/* Free memory used by tracking object, only frees contents of the structure,
109 * (if structure is allocated in heap, it shall be handled outside).
110 *
111 * All the pointers inside structure becomes invalid after this call.
112 */
113static void tracking_object_free(MovieTrackingObject *tracking_object)
114{
115 tracking_tracks_free(&tracking_object->tracks);
116 tracking_plane_tracks_free(&tracking_object->plane_tracks);
118}
119
120/* Free list of tracking objects, list's head and tail is set to nullptr. */
121static void tracking_objects_free(ListBaseT<MovieTrackingObject> *objects)
122{
123 /* Free objects contents. */
124 for (MovieTrackingObject &object : *objects) {
125 tracking_object_free(&object);
126 }
127
128 /* Free objects themselves. */
129 objects->free_no_destruct();
130}
131
132/* Free memory used by a dopesheet, only frees dopesheet contents.
133 * leaving dopesheet crystal clean for further usage.
134 */
136{
138
139 /* Free channel's segments. */
140 channel = dopesheet->channels.first();
141 while (channel) {
142 if (channel->segments) {
143 MEM_delete(channel->segments);
144 }
145
146 channel = channel->next;
147 }
148
149 /* Free lists themselves. */
150 dopesheet->channels.free_no_destruct();
151 dopesheet->coverage_segments.free_no_destruct();
152
153 /* Ensure lists are clean. */
154 dopesheet->channels.clear_no_delete();
155 dopesheet->coverage_segments.clear_no_delete();
156 dopesheet->tot_channel = 0;
157}
158
160{
161 tracking_objects_free(&tracking->objects);
162
163 if (tracking->camera.intrinsics) {
165 }
166
168}
169
171 /* Map from point and plane track pointer from the source object to the destination object. */
174};
175
177{
178 TrackingCopyContext ctx = {};
179 ctx.old_to_new_track_map = MEM_new<Map<MovieTrackingTrack *, MovieTrackingTrack *>>(__func__);
181 MEM_new<Map<MovieTrackingPlaneTrack *, MovieTrackingPlaneTrack *>>(__func__);
182 return ctx;
183}
184
186{
187 MEM_delete(ctx->old_to_new_track_map);
188 MEM_delete(ctx->old_to_new_plane_track_map);
189}
190
191/* Copy the whole list of tracks. */
193 ListBaseT<MovieTrackingTrack> *tracks_dst,
194 const ListBaseT<MovieTrackingTrack> *tracks_src,
195 const int flag)
196{
197 tracks_dst->clear_no_delete();
198
199 for (MovieTrackingTrack &track_src : *tracks_src) {
200 MovieTrackingTrack *track_dst = MEM_new<MovieTrackingTrack>(__func__, track_src);
201 if (track_src.markers) {
202 track_dst->markers = MEM_dupalloc(track_src.markers);
203 }
204 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
205 id_us_plus(&track_dst->gpd->id);
206 }
207 BLI_addtail(tracks_dst, track_dst);
208
209 ctx->old_to_new_track_map->add(&track_src, track_dst);
210 }
211}
212
213/* Copy the whole list of plane tracks
214 * (need whole MovieTracking structures due to embedded pointers to tracks).
215 * WARNING: implies tracking_[dst/src] and their tracks have already been copied. */
218 ListBaseT<MovieTrackingPlaneTrack> *plane_tracks_list_dst,
219 const ListBaseT<MovieTrackingPlaneTrack> *plane_tracks_list_src,
220 const int flag)
221{
222 plane_tracks_list_dst->clear_no_delete();
223
224 for (MovieTrackingPlaneTrack &plane_track_src : *plane_tracks_list_src) {
225 MovieTrackingPlaneTrack *plane_track_dst = MEM_new<MovieTrackingPlaneTrack>(__func__,
226 plane_track_src);
227 if (plane_track_src.markers) {
228 plane_track_dst->markers = static_cast<MovieTrackingPlaneMarker *>(
229 MEM_dupalloc(plane_track_src.markers));
230 }
232 sizeof(*plane_track_dst->point_tracks) * plane_track_dst->point_tracksnr, __func__);
233 for (int i = 0; i < plane_track_dst->point_tracksnr; i++) {
234 plane_track_dst->point_tracks[i] = ctx->old_to_new_track_map->lookup(
235 plane_track_src.point_tracks[i]);
236 BLI_assert(plane_track_dst->point_tracks[i] != nullptr);
237 }
238 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
239 id_us_plus(&plane_track_dst->image->id);
240 }
241 BLI_addtail(plane_tracks_list_dst, plane_track_dst);
242
243 ctx->old_to_new_plane_track_map->add(&plane_track_src, plane_track_dst);
244 }
245}
246
247/* Copy reconstruction structure. */
249 MovieTrackingReconstruction *reconstruction_dst,
250 const MovieTrackingReconstruction *reconstruction_src,
251 const int /*flag*/)
252{
253 *reconstruction_dst = *reconstruction_src;
254 if (reconstruction_src->cameras) {
255 reconstruction_dst->cameras = static_cast<MovieReconstructedCamera *>(
256 MEM_dupalloc(reconstruction_src->cameras));
257 }
258}
259
260/* Copy stabilization structure. */
262 const MovieTrackingStabilization *stabilization_src,
263 const int /*flag*/)
264{
265 *stabilization_dst = *stabilization_src;
266}
267
268/* Copy tracking object. */
269static void tracking_object_copy(MovieTrackingObject *tracking_object_dst,
270 const MovieTrackingObject *tracking_object_src,
271 const int flag)
272{
274
275 *tracking_object_dst = *tracking_object_src;
276
277 tracking_tracks_copy(&ctx, &tracking_object_dst->tracks, &tracking_object_src->tracks, flag);
279 &ctx, &tracking_object_dst->plane_tracks, &tracking_object_src->plane_tracks, flag);
281 &ctx, &tracking_object_dst->reconstruction, &tracking_object_src->reconstruction, flag);
282
283 if (tracking_object_src->active_track) {
284 tracking_object_dst->active_track = ctx.old_to_new_track_map->lookup(
285 tracking_object_src->active_track);
286 BLI_assert(tracking_object_dst->active_track != nullptr);
287 }
288 if (tracking_object_src->active_plane_track) {
289 tracking_object_dst->active_plane_track = ctx.old_to_new_plane_track_map->lookup(
290 tracking_object_src->active_plane_track);
291 BLI_assert(tracking_object_dst->active_plane_track != nullptr);
292 }
293
295}
296
297/* Copy list of tracking objects. */
298static void tracking_objects_copy(ListBaseT<MovieTrackingObject> *tracking_objects_dst,
299 const ListBaseT<MovieTrackingObject> *tracking_objects_src,
300 const int flag)
301{
302 tracking_objects_dst->clear_no_delete();
303
304 for (MovieTrackingObject &tracking_object_src : *tracking_objects_src) {
305 MovieTrackingObject *tracking_object_dst = MEM_new<MovieTrackingObject>(__func__);
306 tracking_object_copy(tracking_object_dst, &tracking_object_src, flag);
307 BLI_addtail(tracking_objects_dst, tracking_object_dst);
308 }
309}
310
312 const MovieTracking *tracking_src,
313 const int flag)
314{
315 *tracking_dst = *tracking_src;
316
317 tracking_stabilization_copy(&tracking_dst->stabilization, &tracking_src->stabilization, flag);
318
319 tracking_objects_copy(&tracking_dst->objects, &tracking_src->objects, flag);
320
321 /* Those remaining are runtime data, they will be reconstructed as needed,
322 * do not bother copying them. */
323 tracking_dst->dopesheet.ok = false;
324 tracking_dst->dopesheet.channels.clear_no_delete();
325 tracking_dst->dopesheet.coverage_segments.clear_no_delete();
326
327 tracking_dst->camera.intrinsics = nullptr;
328 tracking_dst->stats = nullptr;
329}
330
332{
333 tracking->camera.sensor_width = 35.0f;
334 tracking->camera.pixel_aspect = 1.0f;
335 tracking->camera.units = CAMERA_UNITS_MM;
336
338 tracking->settings.default_minimum_correlation = 0.75;
339 tracking->settings.default_pattern_size = 21;
340 tracking->settings.default_search_size = 71;
342 tracking->settings.default_weight = 1.0f;
343 tracking->settings.dist = 1;
344 tracking->settings.object_distance = 1;
346
347 tracking->stabilization.scaleinf = 1.0f;
348 tracking->stabilization.anchor_frame = 1;
350 tracking->stabilization.target_rot = 0.0f;
351 tracking->stabilization.scale = 1.0f;
352
353 tracking->stabilization.act_track = 0;
354 tracking->stabilization.act_rot_track = 0;
355 tracking->stabilization.tot_track = 0;
356 tracking->stabilization.tot_rot_track = 0;
357
358 tracking->stabilization.scaleinf = 1.0f;
359 tracking->stabilization.locinf = 1.0f;
360 tracking->stabilization.rotinf = 1.0f;
361 tracking->stabilization.maxscale = 2.0f;
364
365 /* Descending order of average error: tracks with the highest error are on top. */
368
369 BKE_tracking_object_add(tracking, DATA_("Camera"));
370}
371
372void BKE_tracking_get_camera_object_matrix(const Object *camera_object, float mat[4][4])
373{
374 BLI_assert(camera_object != nullptr);
375 /* NOTE: Construct matrix from scratch rather than using obmat because the camera object here
376 * will have camera solver constraint taken into account. But here we do not want or need it:
377 * object is solved in camera space (as in, camera is stationary and object is moving).
378 *
379 * This will include animation applied on the camera, but not possible camera rig. This isn't
380 * an issue in practice due to the way how VFX is constructed.
381 *
382 * If we ever need to support crazy setups like that one possible solution would be to use
383 * final camera matrix and multiple it by an inverse of solved camera matrix at the current
384 * frame. */
385 BKE_object_where_is_calc_mat4(camera_object, mat);
386}
387
389 MovieTrackingObject *tracking_object,
390 int framenr,
391 int winx,
392 int winy,
393 float mat[4][4])
394{
396 float lens = tracking->camera.focal * tracking->camera.sensor_width / float(winx);
397 float viewfac, pixsize, left, right, bottom, top, clipsta, clipend;
398 float winmat[4][4];
399 float ycor = 1.0f / tracking->camera.pixel_aspect;
400 float shiftx, shifty, winside = float(min_ii(winx, winy));
401
402 BKE_tracking_camera_shift_get(tracking, winx, winy, &shiftx, &shifty);
403
404 clipsta = 0.1f;
405 clipend = 1000.0f;
406
407 if (winx >= winy) {
408 viewfac = (lens * winx) / tracking->camera.sensor_width;
409 }
410 else {
411 viewfac = (ycor * lens * winy) / tracking->camera.sensor_width;
412 }
413
414 pixsize = clipsta / viewfac;
415
416 left = -0.5f * float(winx) + shiftx * winside;
417 bottom = -0.5f * (ycor) * float(winy) + shifty * winside;
418 right = 0.5f * float(winx) + shiftx * winside;
419 top = 0.5f * (ycor) * float(winy) + shifty * winside;
420
421 left *= pixsize;
422 right *= pixsize;
423 bottom *= pixsize;
424 top *= pixsize;
425
426 perspective_m4(winmat, left, right, bottom, top, clipsta, clipend);
427
428 camera = BKE_tracking_camera_get_reconstructed(tracking, tracking_object, framenr);
429
430 if (camera) {
431 float imat[4][4];
432
433 invert_m4_m4(imat, camera->mat);
434 mul_m4_m4m4(mat, winmat, imat);
435 }
436 else {
437 copy_m4_m4(mat, winmat);
438 }
439}
440
441/* --------------------------------------------------------------------
442 * Clipboard.
443 */
444
446{
447 MovieTrackingTrack *track = tracking_clipboard.tracks.first(), *next_track;
448
449 while (track) {
450 next_track = track->next;
451
453 MEM_delete(track);
454
455 track = next_track;
456 }
457
458 tracking_clipboard.tracks.clear_no_delete();
459}
460
462 MovieTrackingObject *tracking_object)
463{
464 /* First drop all tracks from current clipboard. */
466
467 /* Then copy all selected visible tracks to it. */
468 for (MovieTrackingTrack &track : tracking_object->tracks) {
469 if (TRACK_SELECTED(&track) && (track.flag & TRACK_HIDDEN) == 0) {
471
472 BLI_addtail(&tracking_clipboard.tracks, new_track);
473 }
474 }
475}
476
478{
479 return (tracking_clipboard.tracks.is_empty() == false);
480}
481
483 MovieTrackingObject *tracking_object)
484{
485 for (MovieTrackingTrack &track : tracking_clipboard.tracks) {
487
488 /* TODO(sergey): Preserve active track from before the copy. */
489 if (track.prev == nullptr) {
490 tracking_object->active_track = new_track;
491 }
492
493 BLI_addtail(&tracking_object->tracks, new_track);
494 BKE_tracking_track_unique_name(&tracking_object->tracks, new_track);
495 }
496}
497
498/* --------------------------------------------------------------------
499 * Tracks.
500 */
501
503 ListBaseT<MovieTrackingTrack> *tracks_list)
504{
505 const MovieTrackingSettings *settings = &tracking->settings;
506
507 MovieTrackingTrack *track = MEM_new<MovieTrackingTrack>("add_marker_exec track");
509
510 /* Fill track's settings from default settings. */
511 track->motion_model = settings->default_motion_model;
513 track->margin = settings->default_margin;
514 track->pattern_match = settings->default_pattern_match;
515 track->frames_limit = settings->default_frames_limit;
516 track->flag = settings->default_flag;
517 track->algorithm_flag = settings->default_algorithm_flag;
518 track->weight = settings->default_weight;
519 track->weight_stab = settings->default_weight;
520
521 BLI_addtail(tracks_list, track);
522 BKE_tracking_track_unique_name(tracks_list, track);
523
524 return track;
525}
526
528 ListBaseT<MovieTrackingTrack> *tracksbase,
529 float x,
530 float y,
531 int framenr,
532 int width,
533 int height)
534{
535 const MovieTrackingSettings *settings = &tracking->settings;
536
537 MovieTrackingTrack *track = BKE_tracking_track_add_empty(tracking, tracksbase);
538
539 const float half_pattern_px = settings->default_pattern_size / 2.0f;
540 const float half_search_px = settings->default_search_size / 2.0f;
541
542 const float pattern_size[2] = {half_pattern_px / width, half_pattern_px / height};
543 const float search_size[2] = {half_search_px / width, half_search_px / height};
544
545 MovieTrackingMarker marker = {};
546 marker.pos[0] = x;
547 marker.pos[1] = y;
548 marker.framenr = framenr;
549
550 marker.pattern_corners[0][0] = -pattern_size[0];
551 marker.pattern_corners[0][1] = -pattern_size[1];
552
553 marker.pattern_corners[1][0] = pattern_size[0];
554 marker.pattern_corners[1][1] = -pattern_size[1];
555
556 negate_v2_v2(marker.pattern_corners[2], marker.pattern_corners[0]);
557 negate_v2_v2(marker.pattern_corners[3], marker.pattern_corners[1]);
558
559 copy_v2_v2(marker.search_max, search_size);
560 negate_v2_v2(marker.search_min, search_size);
561
562 BKE_tracking_marker_insert(track, &marker);
563
564 return track;
565}
566
568{
569 MovieTrackingTrack *new_track;
570
571 new_track = MEM_new<MovieTrackingTrack>("tracking_track_duplicate new_track");
572
573 *new_track = *track;
574 new_track->next = new_track->prev = nullptr;
575
576 new_track->markers = MEM_dupalloc(new_track->markers);
577
578 /* Prevent duplicate from being used for 2D stabilization.
579 * If necessary, it shall be added explicitly.
580 */
581 new_track->flag &= ~TRACK_USE_2D_STAB;
582 new_track->flag &= ~TRACK_USE_2D_STAB_ROT;
583
584 return new_track;
585}
586
587void BKE_tracking_track_unique_name(ListBaseT<MovieTrackingTrack> *tracksbase,
588 MovieTrackingTrack *track)
589{
590 BLI_uniquename(tracksbase,
591 track,
593 '.',
595 sizeof(track->name));
596}
597
599{
600 if (track->markers) {
601 MEM_delete(track->markers);
602 }
603}
604
606 int *r_first_frame,
607 int *r_last_frame)
608{
609 BLI_assert(track->markersnr > 0);
610 const int last_marker_index = track->markersnr - 1;
611 *r_first_frame = track->markers[0].framenr;
612 *r_last_frame = track->markers[last_marker_index].framenr;
613}
614
616 const int num_tracks,
617 int *r_first_frame,
618 int *r_last_frame)
619{
620 *r_first_frame = INT_MAX;
621 *r_last_frame = INT_MIN;
622 for (int i = 0; i < num_tracks; ++i) {
623 const MovieTrackingTrack *track = tracks[i];
624 int track_first_frame, track_last_frame;
625 BKE_tracking_track_first_last_frame_get(track, &track_first_frame, &track_last_frame);
626 *r_first_frame = min_ii(*r_first_frame, track_first_frame);
627 *r_last_frame = max_ii(*r_last_frame, track_last_frame);
628 }
629}
630
631int BKE_tracking_count_selected_tracks_in_list(const ListBaseT<MovieTrackingTrack> *tracks_list)
632{
633 int num_selected_tracks = 0;
634 for (const MovieTrackingTrack &track : *tracks_list) {
635 if (TRACK_SELECTED(&track)) {
636 ++num_selected_tracks;
637 }
638 }
639 return num_selected_tracks;
640}
641
643{
644 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
645 return BKE_tracking_count_selected_tracks_in_list(&tracking_object->tracks);
646}
647
649 int *r_num_tracks)
650{
651 *r_num_tracks = 0;
652
653 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
654
655 /* Initialize input. */
656 const int num_selected_tracks = BKE_tracking_count_selected_tracks_in_active_object(tracking);
657 if (num_selected_tracks == 0) {
658 return nullptr;
659 }
660
662 num_selected_tracks, "selected tracks array");
663 int source_track_index = 0;
664 for (MovieTrackingTrack &track : tracking_object->tracks) {
665 if (!TRACK_SELECTED(&track)) {
666 continue;
667 }
668 source_tracks[source_track_index] = &track;
669 ++source_track_index;
670 }
671
672 *r_num_tracks = num_selected_tracks;
673
674 return source_tracks;
675}
676
678 eTrackArea area,
680{
681 if (area == TRACK_AREA_NONE) {
682 return;
683 }
684
685 if (area & TRACK_AREA_POINT) {
686 track->flag |= flag;
687 }
688 if (area & TRACK_AREA_PAT) {
689 track->pat_flag |= flag;
690 }
691 if (area & TRACK_AREA_SEARCH) {
692 track->search_flag |= flag;
693 }
694}
695
697 eTrackArea area,
699{
700 if (area == TRACK_AREA_NONE) {
701 return;
702 }
703
704 if (area & TRACK_AREA_POINT) {
705 track->flag &= ~flag;
706 }
707 if (area & TRACK_AREA_PAT) {
708 track->pat_flag &= ~flag;
709 }
710 if (area & TRACK_AREA_SEARCH) {
711 track->search_flag &= ~flag;
712 }
713}
714
716{
717 return BKE_tracking_marker_get_exact(track, framenr) != nullptr;
718}
719
721{
722 MovieTrackingMarker *marker = BKE_tracking_marker_get_exact(track, framenr);
723
724 return marker && (marker->flag & MARKER_DISABLED) == 0;
725}
726
727static void path_clear_remained(MovieTrackingTrack *track, const int ref_frame)
728{
729 for (int a = 1; a < track->markersnr; a++) {
730 if (track->markers[a].framenr > ref_frame) {
731 track->markersnr = a;
733 track->markers, sizeof(MovieTrackingMarker) * track->markersnr));
734
735 break;
736 }
737 }
738
739 if (track->markersnr) {
740 tracking_marker_insert_disabled(track, &track->markers[track->markersnr - 1], false, true);
741 }
742}
743
744static void path_clear_up_to(MovieTrackingTrack *track, const int ref_frame)
745{
746 for (int a = track->markersnr - 1; a >= 0; a--) {
747 if (track->markers[a].framenr <= ref_frame) {
748 memmove(track->markers,
749 track->markers + a,
750 (track->markersnr - a) * sizeof(MovieTrackingMarker));
751
752 track->markersnr = track->markersnr - a;
754 track->markers, sizeof(MovieTrackingMarker) * track->markersnr));
755
756 break;
757 }
758 }
759
760 if (track->markersnr) {
761 tracking_marker_insert_disabled(track, &track->markers[0], true, true);
762 }
763}
764
765static void path_clear_all(MovieTrackingTrack *track, const int ref_frame)
766{
767 MovieTrackingMarker *marker, marker_new;
768
769 marker = BKE_tracking_marker_get(track, ref_frame);
770 marker_new = *marker;
771
772 MEM_delete(track->markers);
773 track->markers = nullptr;
774 track->markersnr = 0;
775
776 BKE_tracking_marker_insert(track, &marker_new);
777
778 tracking_marker_insert_disabled(track, &marker_new, true, true);
779 tracking_marker_insert_disabled(track, &marker_new, false, true);
780}
781
783 const int ref_frame,
784 const eTrackClearAction action)
785{
786 switch (action) {
788 path_clear_remained(track, ref_frame);
789 break;
790 case TRACK_CLEAR_UPTO:
791 path_clear_up_to(track, ref_frame);
792 break;
793 case TRACK_CLEAR_ALL:
794 path_clear_all(track, ref_frame);
795 break;
796 };
797}
798
800 MovieTrackingTrack *dst_track,
801 MovieTrackingTrack *src_track)
802{
803 int i = 0, a = 0, b = 0, tot;
804 MovieTrackingMarker *markers;
805
806 tot = dst_track->markersnr + src_track->markersnr;
807 markers = MEM_new_array<MovieTrackingMarker>(tot, "tmp tracking joined tracks");
808
809 while (a < src_track->markersnr || b < dst_track->markersnr) {
810 if (b >= dst_track->markersnr) {
811 markers[i] = src_track->markers[a++];
812 }
813 else if (a >= src_track->markersnr) {
814 markers[i] = dst_track->markers[b++];
815 }
816 else if (src_track->markers[a].framenr < dst_track->markers[b].framenr) {
817 markers[i] = src_track->markers[a++];
818 }
819 else if (src_track->markers[a].framenr > dst_track->markers[b].framenr) {
820 markers[i] = dst_track->markers[b++];
821 }
822 else {
823 if ((src_track->markers[a].flag & MARKER_DISABLED) == 0) {
824 if ((dst_track->markers[b].flag & MARKER_DISABLED) == 0) {
825 /* both tracks are enabled on this frame, so find the whole segment
826 * on which tracks are intersecting and blend tracks using linear
827 * interpolation to prevent jumps
828 */
829
830 MovieTrackingMarker *marker_a, *marker_b;
831 int start_a = a, start_b = b, len = 0, frame = src_track->markers[a].framenr;
832 int inverse = 0;
833
834 inverse = (b == 0) || (dst_track->markers[b - 1].flag & MARKER_DISABLED) ||
835 (dst_track->markers[b - 1].framenr != frame - 1);
836
837 /* find length of intersection */
838 while (a < src_track->markersnr && b < dst_track->markersnr) {
839 marker_a = &src_track->markers[a];
840 marker_b = &dst_track->markers[b];
841
842 if (marker_a->flag & MARKER_DISABLED || marker_b->flag & MARKER_DISABLED) {
843 break;
844 }
845
846 if (marker_a->framenr != frame || marker_b->framenr != frame) {
847 break;
848 }
849
850 frame++;
851 len++;
852 a++;
853 b++;
854 }
855
856 a = start_a;
857 b = start_b;
858
859 /* linear interpolation for intersecting frames */
860 for (int j = 0; j < len; j++) {
861 float fac = 0.5f;
862
863 if (len > 1) {
864 fac = 1.0f / (len - 1) * j;
865 }
866
867 if (inverse) {
868 fac = 1.0f - fac;
869 }
870
871 marker_a = &src_track->markers[a];
872 marker_b = &dst_track->markers[b];
873
874 markers[i] = dst_track->markers[b];
875 interp_v2_v2v2(markers[i].pos, marker_b->pos, marker_a->pos, fac);
876 a++;
877 b++;
878 i++;
879 }
880
881 /* this values will be incremented at the end of the loop cycle */
882 a--;
883 b--;
884 i--;
885 }
886 else {
887 markers[i] = src_track->markers[a];
888 }
889 }
890 else {
891 markers[i] = dst_track->markers[b];
892 }
893
894 a++;
895 b++;
896 }
897
898 i++;
899 }
900
901 MEM_delete(dst_track->markers);
902
903 dst_track->markers = MEM_new_array<MovieTrackingMarker>(i, "tracking joined tracks");
904 memcpy(dst_track->markers, markers, i * sizeof(MovieTrackingMarker));
905
906 dst_track->markersnr = i;
907
908 MEM_delete(markers);
909
911}
912
914 const MovieTrackingMarker *src_marker)
915{
916 BLI_assert(dst_marker->framenr == src_marker->framenr);
917
918 if (src_marker->flag & MARKER_DISABLED) {
919 return;
920 }
921
922 add_v2_v2(dst_marker->pos, src_marker->pos);
923 for (int corner = 0; corner < 4; ++corner) {
924 add_v2_v2(dst_marker->pattern_corners[corner], src_marker->pattern_corners[corner]);
925 }
926 add_v2_v2(dst_marker->search_min, src_marker->search_min);
927 add_v2_v2(dst_marker->search_max, src_marker->search_max);
928
929 BLI_assert(is_finite_v2(src_marker->search_min));
930 BLI_assert(is_finite_v2(src_marker->search_max));
931
932 dst_marker->flag &= ~MARKER_DISABLED;
933 if ((src_marker->flag & MARKER_TRACKED) == 0) {
934 dst_marker->flag &= ~MARKER_TRACKED;
935 }
936}
937
938static void multiply_marker(MovieTrackingMarker *marker, const float multiplier)
939{
940 mul_v2_fl(marker->pos, multiplier);
941 for (int corner = 0; corner < 4; ++corner) {
942 mul_v2_fl(marker->pattern_corners[corner], multiplier);
943 }
944 mul_v2_fl(marker->search_min, multiplier);
945 mul_v2_fl(marker->search_max, multiplier);
946}
947
948/* Helper function for BKE_tracking_tracks_average which takes care of averaging fields of
949 * markers (position, patterns, ...). */
951 /*const*/ MovieTrackingTrack **src_tracks,
952 const int num_src_tracks)
953{
954 /* Get global range of frames within which averaging would happen. */
955 int first_frame, last_frame;
957 src_tracks, num_src_tracks, &first_frame, &last_frame);
958 if (last_frame < first_frame) {
959 return;
960 }
961 const int num_frames = last_frame - first_frame + 1;
962
963 /* Allocate temporary array where averaging will happen into. */
964 MovieTrackingMarker *accumulator = MEM_new_array<MovieTrackingMarker>(
965 num_frames, "tracks average accumulator");
966 int *counters = MEM_new_array_zeroed<int>(num_frames, "tracks accumulator counters");
967 for (int frame = first_frame; frame <= last_frame; ++frame) {
968 const int frame_index = frame - first_frame;
969 accumulator[frame_index].framenr = frame;
970 accumulator[frame_index].flag |= (MARKER_DISABLED | MARKER_TRACKED);
971 }
972
973 /* Accumulate track markers. */
974 for (int track_index = 0; track_index < num_src_tracks; ++track_index) {
975 /*const*/ MovieTrackingTrack *track = src_tracks[track_index];
976 for (int frame = first_frame; frame <= last_frame; ++frame) {
977 MovieTrackingMarker interpolated_marker;
978 if (!BKE_tracking_marker_get_interpolated(track, frame, &interpolated_marker)) {
979 continue;
980 }
981 const int frame_index = frame - first_frame;
982 accumulate_marker(&accumulator[frame_index], &interpolated_marker);
983 ++counters[frame_index];
984 }
985 }
986
987 /* Average and store the result. */
988 for (int frame = first_frame; frame <= last_frame; ++frame) {
989 /* Average. */
990 const int frame_index = frame - first_frame;
991 if (!counters[frame_index]) {
992 continue;
993 }
994 const float multiplier = 1.0f / float(counters[frame_index]);
995 multiply_marker(&accumulator[frame_index], multiplier);
996 /* Store the result. */
997 BKE_tracking_marker_insert(dst_track, &accumulator[frame_index]);
998 }
999
1000 /* Free memory. */
1001 MEM_delete(accumulator);
1002 MEM_delete(counters);
1003}
1004
1005/* Helper function for BKE_tracking_tracks_average which takes care of averaging fields of
1006 * tracks (track for example, offset). */
1008 /*const*/ MovieTrackingTrack **src_tracks,
1009 const int num_src_tracks)
1010{
1011 /* TODO(sergey): Consider averaging weight, stabilization weight, maybe even bundle position. */
1012 zero_v2(dst_track->offset);
1013 for (int track_index = 0; track_index < num_src_tracks; track_index++) {
1014 add_v2_v2(dst_track->offset, src_tracks[track_index]->offset);
1015 }
1016 mul_v2_fl(dst_track->offset, 1.0f / num_src_tracks);
1017}
1018
1020 /*const*/ MovieTrackingTrack **src_tracks,
1021 const int num_src_tracks)
1022{
1023 if (num_src_tracks == 0) {
1024 return;
1025 }
1026
1027 tracking_average_markers(dst_track, src_tracks, num_src_tracks);
1028 tracking_average_tracks(dst_track, src_tracks, num_src_tracks);
1029}
1030
1032 MovieTracking *tracking, int selection_index, ListBaseT<MovieTrackingTrack> **r_tracksbase)
1033{
1034 int cur = 1;
1035
1036 for (MovieTrackingObject &object : tracking->objects) {
1037 for (MovieTrackingTrack &track : object.tracks) {
1038 if (track.flag & TRACK_HAS_BUNDLE) {
1039 if (cur == selection_index) {
1040 *r_tracksbase = &object.tracks;
1041 return &track;
1042 }
1043
1044 cur++;
1045 }
1046 }
1047 }
1048
1049 *r_tracksbase = nullptr;
1050
1051 return nullptr;
1052}
1053
1055{
1057
1058 if (!track->gpd) {
1059 return nullptr;
1060 }
1061
1062 layer = track->gpd->layers.first();
1063
1064 while (layer) {
1065 if (layer->flag & GP_LAYER_ACTIVE) {
1066 bGPDframe *frame = layer->frames.first();
1067 bool ok = false;
1068
1069 while (frame) {
1070 if (frame->strokes.first()) {
1071 ok = true;
1072 break;
1073 }
1074
1075 frame = frame->next;
1076 }
1077
1078 if (ok) {
1079 return layer;
1080 }
1081 }
1082
1083 layer = layer->next;
1084 }
1085
1086 return nullptr;
1087}
1088
1094
1095static void track_mask_set_pixel_cb(int x, int x_end, int y, void *user_data)
1096{
1097 TrackMaskSetPixelData *data = static_cast<TrackMaskSetPixelData *>(user_data);
1098 size_t index = size_t(y) * data->mask_width + x;
1099 size_t index_end = size_t(y) * data->mask_width + x_end;
1100 do {
1101 data->mask[index] = 1.0f;
1102 } while (++index != index_end);
1103}
1104
1105static void track_mask_gpencil_layer_rasterize(const int frame_width,
1106 const int frame_height,
1107 const float region_min[2],
1108 const bGPDlayer *layer,
1109 float *mask,
1110 const int mask_width,
1111 const int mask_height)
1112{
1113 const bGPDframe *frame = layer->frames.first();
1115
1116 data.mask = mask;
1117 data.mask_width = mask_width;
1118 data.mask_height = mask_height;
1119
1120 while (frame) {
1121 const bGPDstroke *stroke = frame->strokes.first();
1122
1123 while (stroke) {
1124 const bGPDspoint *stroke_points = stroke->points;
1125 if (stroke->flag & GP_STROKE_2DSPACE) {
1126 Array<int2> mask_points(stroke->totpoints);
1127 for (const int i : mask_points.index_range()) {
1128 mask_points[i][0] = stroke_points[i].x * frame_width - region_min[0];
1129 mask_points[i][1] = stroke_points[i].y * frame_height - region_min[1];
1130 }
1131 /* TODO: add an option to control whether AA is enabled or not */
1133 0, 0, mask_width, mask_height, mask_points, track_mask_set_pixel_cb, &data);
1134 }
1135 stroke = stroke->next;
1136 }
1137 frame = frame->next;
1138 }
1139}
1140
1141float *tracking_track_get_mask_for_region(const int frame_width,
1142 const int frame_height,
1143 const float region_min[2],
1144 const float region_max[2],
1145 const MovieTrackingTrack *track)
1146{
1147 float *mask = nullptr;
1149 if (layer != nullptr) {
1150 const int mask_width = region_max[0] - region_min[0];
1151 const int mask_height = region_max[1] - region_min[1];
1152 mask = MEM_new_array_zeroed<float>(mask_width * mask_height, "track mask");
1154 frame_width, frame_height, region_min, layer, mask, mask_width, mask_height);
1155 }
1156 return mask;
1157}
1158
1159float *BKE_tracking_track_get_mask(const int frame_width,
1160 const int frame_height,
1161 const MovieTrackingTrack *track,
1162 const MovieTrackingMarker *marker)
1163{
1164 /* Convert normalized space marker's search area to pixel-space region. */
1165 const float region_min[2] = {
1166 marker->search_min[0] * frame_width,
1167 marker->search_min[1] * frame_height,
1168 };
1169 const float region_max[2] = {
1170 marker->search_max[0] * frame_width,
1171 marker->search_max[1] * frame_height,
1172 };
1174 frame_width, frame_height, region_min, region_max, track);
1175}
1176
1178 MovieTrackingTrack *track,
1179 MovieTrackingMarker *marker)
1180{
1181 const FCurve *weight_fcurve;
1182 float weight = track->weight;
1183
1184 weight_fcurve = id_data_find_fcurve(
1185 &clip->id, track, RNA_MovieTrackingTrack, "weight", 0, nullptr);
1186
1187 if (weight_fcurve) {
1188 int scene_framenr = BKE_movieclip_remap_clip_to_scene_frame(clip, marker->framenr);
1189 weight = evaluate_fcurve(weight_fcurve, scene_framenr);
1190 }
1191
1192 return weight;
1193}
1194
1195void BKE_tracking_track_select(ListBaseT<MovieTrackingTrack> *tracksbase,
1196 MovieTrackingTrack *track,
1197 eTrackArea area,
1198 bool extend)
1199{
1200 if (extend) {
1202 }
1203 else {
1204 MovieTrackingTrack *cur = tracksbase->first();
1205
1206 while (cur) {
1207 if ((cur->flag & TRACK_HIDDEN) == 0) {
1208 if (cur == track) {
1211 }
1212 else {
1214 }
1215 }
1216
1217 cur = cur->next;
1218 }
1219 }
1220}
1221
1226
1227void BKE_tracking_tracks_deselect_all(ListBaseT<MovieTrackingTrack> *tracksbase)
1228{
1229 for (MovieTrackingTrack &track : *tracksbase) {
1230 if ((track.flag & TRACK_HIDDEN) == 0) {
1232 }
1233 }
1234}
1235
1236/* --------------------------------------------------------------------
1237 * Marker.
1238 */
1239
1241 MovieTrackingMarker *marker)
1242{
1243 MovieTrackingMarker *old_marker = nullptr;
1244
1245 if (track->markersnr) {
1246 old_marker = BKE_tracking_marker_get_exact(track, marker->framenr);
1247 }
1248
1249 if (old_marker) {
1250 /* simply replace settings for already allocated marker */
1251 *old_marker = *marker;
1252
1253 return old_marker;
1254 }
1255
1256 int a = track->markersnr;
1257
1258 /* find position in array where to add new marker */
1259 while (a--) {
1260 if (track->markers[a].framenr < marker->framenr) {
1261 break;
1262 }
1263 }
1264
1265 track->markersnr++;
1266
1267 if (track->markers) {
1268 track->markers = static_cast<MovieTrackingMarker *>(
1270 }
1271 else {
1272 track->markers = MEM_new<MovieTrackingMarker>("MovieTracking markers");
1273 }
1274
1275 /* shift array to "free" space for new marker */
1276 memmove(track->markers + a + 2,
1277 track->markers + a + 1,
1278 (track->markersnr - a - 2) * sizeof(MovieTrackingMarker));
1279
1280 /* put new marker */
1281 track->markers[a + 1] = *marker;
1282
1283 return &track->markers[a + 1];
1284}
1285
1287{
1288 int a = 0;
1289
1290 while (a < track->markersnr) {
1291 if (track->markers[a].framenr == framenr) {
1292 if (track->markersnr > 1) {
1293 memmove(track->markers + a,
1294 track->markers + a + 1,
1295 (track->markersnr - a - 1) * sizeof(MovieTrackingMarker));
1296 track->markersnr--;
1298 track->markers, sizeof(MovieTrackingMarker) * track->markersnr));
1299 }
1300 else {
1301 MEM_delete(track->markers);
1302 track->markers = nullptr;
1303 track->markersnr = 0;
1304 }
1305
1306 break;
1307 }
1308
1309 a++;
1310 }
1311}
1312
1314{
1315 float pat_min[2], pat_max[2];
1316 BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
1317
1318 for (int a = 0; a < 2; a++) {
1319 if (pat_min[a] < marker->search_min[a]) {
1320 for (int b = 0; b < 4; b++) {
1321 marker->pattern_corners[b][a] += marker->search_min[a] - pat_min[a];
1322 }
1323 }
1324 if (pat_max[a] > marker->search_max[a]) {
1325 for (int b = 0; b < 4; b++) {
1326 marker->pattern_corners[b][a] -= pat_max[a] - marker->search_max[a];
1327 }
1328 }
1329 }
1330}
1331
1333{
1334 float pat_min[2], pat_max[2];
1335 BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
1336
1337 for (int a = 0; a < 2; a++) {
1338 marker->search_min[a] = min_ff(pat_min[a], marker->search_min[a]);
1339 marker->search_max[a] = max_ff(pat_max[a], marker->search_max[a]);
1340 }
1341}
1342
1344{
1345 float pat_min[2], pat_max[2];
1346 BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
1347
1348 float dim[2];
1349 sub_v2_v2v2(dim, marker->search_max, marker->search_min);
1350
1351 for (int a = 0; a < 2; a++) {
1352 if (marker->search_min[a] > pat_min[a]) {
1353 marker->search_min[a] = pat_min[a];
1354 marker->search_max[a] = marker->search_min[a] + dim[a];
1355 }
1356 if (marker->search_max[a] < pat_max[a]) {
1357 marker->search_max[a] = pat_max[a];
1358 marker->search_min[a] = marker->search_max[a] - dim[a];
1359 }
1360 }
1361}
1362
1364{
1365 const int num_markers = track->markersnr;
1366
1367 if (num_markers == 0) {
1368 BLI_assert_msg(0, "Detected degenerated track, should never happen.");
1369 return nullptr;
1370 }
1371
1372 int left_boundary = 0;
1373 int right_boundary = num_markers;
1374 while (left_boundary < right_boundary) {
1375 const int median_index = (left_boundary + right_boundary) / 2;
1376 MovieTrackingMarker *marker = &track->markers[median_index];
1377
1378 if (marker->framenr == framenr) {
1379 return marker;
1380 }
1381
1382 if (marker->framenr < framenr) {
1383 left_boundary = median_index + 1;
1384 }
1385 else {
1386 BLI_assert(marker->framenr > framenr);
1387 right_boundary = median_index - 1;
1388 }
1389 }
1390
1391 const int closest_index = clamp_i(right_boundary, 0, num_markers - 1);
1392
1393 return &track->markers[closest_index];
1394}
1395
1397{
1398 MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
1399
1400 if (marker->framenr != framenr) {
1401 return nullptr;
1402 }
1403
1404 return marker;
1405}
1406
1408{
1409 MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
1410
1411 if (marker->framenr != framenr) {
1412 MovieTrackingMarker marker_new;
1413
1414 marker_new = *marker;
1415 marker_new.framenr = framenr;
1416
1417 BKE_tracking_marker_insert(track, &marker_new);
1418 marker = BKE_tracking_marker_get(track, framenr);
1419 }
1420
1421 return marker;
1422}
1423
1425 MovieTrackingTrack *track, const MovieTrackingMarker *anchor_marker, const int direction)
1426{
1427 BLI_assert(ELEM(direction, -1, 1));
1428
1429 const MovieTrackingMarker *last_marker = track->markers + track->markersnr - 1;
1430 const MovieTrackingMarker *current_marker = anchor_marker;
1431
1432 while (current_marker >= track->markers && current_marker <= last_marker) {
1433 if ((current_marker->flag & MARKER_DISABLED) == 0) {
1434 return current_marker;
1435 }
1436 current_marker += direction;
1437 }
1438
1439 return nullptr;
1440}
1441
1443 const int framenr,
1444 MovieTrackingMarker *r_marker)
1445{
1446 const MovieTrackingMarker *closest_marker = BKE_tracking_marker_get(track, framenr);
1447 if (closest_marker == nullptr) {
1448 return false;
1449 }
1450 if (closest_marker->framenr == framenr && (closest_marker->flag & MARKER_DISABLED) == 0) {
1451 *r_marker = *closest_marker;
1452 return true;
1453 }
1454
1456 track, closest_marker, -1);
1457 if (left_marker == nullptr) {
1458 return false;
1459 }
1460
1462 track, closest_marker + 1, 1);
1463 if (right_marker == nullptr) {
1464 return false;
1465 }
1466
1467 if (left_marker == right_marker) {
1468 *r_marker = *left_marker;
1469 return true;
1470 }
1471
1472 const float factor = float(framenr - left_marker->framenr) /
1473 (right_marker->framenr - left_marker->framenr);
1474
1475 interp_v2_v2v2(r_marker->pos, left_marker->pos, right_marker->pos, factor);
1476
1477 for (int i = 0; i < 4; i++) {
1478 interp_v2_v2v2(r_marker->pattern_corners[i],
1479 left_marker->pattern_corners[i],
1480 right_marker->pattern_corners[i],
1481 factor);
1482 }
1483
1484 interp_v2_v2v2(r_marker->search_min, left_marker->search_min, right_marker->search_min, factor);
1485 interp_v2_v2v2(r_marker->search_max, left_marker->search_max, right_marker->search_max, factor);
1486
1487 r_marker->framenr = framenr;
1488 r_marker->flag = TrackingMarkerFlag{};
1489
1490 if (framenr == left_marker->framenr) {
1491 r_marker->flag = left_marker->flag;
1492 }
1493 else if (framenr == right_marker->framenr) {
1494 r_marker->flag = right_marker->flag;
1495 }
1496
1497 return true;
1498}
1499
1501 float min[2],
1502 float max[2])
1503{
1505
1506 minmax_v2v2_v2(min, max, marker->pattern_corners[0]);
1507 minmax_v2v2_v2(min, max, marker->pattern_corners[1]);
1508 minmax_v2v2_v2(min, max, marker->pattern_corners[2]);
1509 minmax_v2v2_v2(min, max, marker->pattern_corners[3]);
1510}
1511
1513 float framenr,
1514 float pos[2])
1515{
1516 MovieTrackingMarker *marker = BKE_tracking_marker_get(track, int(framenr));
1517 MovieTrackingMarker *marker_last = track->markers + (track->markersnr - 1);
1518
1519 if (marker != marker_last) {
1520 MovieTrackingMarker *marker_next = marker + 1;
1521
1522 if (marker_next->framenr == marker->framenr + 1) {
1523 /* Currently only do sub-framing inside tracked ranges, do not extrapolate tracked segments
1524 * could be changed when / if mask parent would be interpolating position in-between
1525 * tracked segments. */
1526
1527 float fac = (framenr - int(framenr)) / (marker_next->framenr - marker->framenr);
1528
1529 interp_v2_v2v2(pos, marker->pos, marker_next->pos, fac);
1530 }
1531 else {
1532 copy_v2_v2(pos, marker->pos);
1533 }
1534 }
1535 else {
1536 copy_v2_v2(pos, marker->pos);
1537 }
1538
1539 /* currently track offset is always wanted to be applied here, could be made an option later */
1540 add_v2_v2(pos, track->offset);
1541}
1542
1543/* --------------------------------------------------------------------
1544 * Plane track.
1545 */
1546
1548 MovieTracking *tracking,
1549 ListBaseT<MovieTrackingPlaneTrack> *plane_tracks_base,
1550 ListBaseT<MovieTrackingTrack> *tracks,
1551 int framenr)
1552{
1553 MovieTrackingPlaneTrack *plane_track;
1554 MovieTrackingPlaneMarker plane_marker;
1555 float tracks_min[2], tracks_max[2];
1556 int num_selected_tracks = 0;
1557
1558 (void)tracking; /* Ignored. */
1559
1560 /* Use bounding box of selected markers as an initial size of plane. */
1561 INIT_MINMAX2(tracks_min, tracks_max);
1562 for (MovieTrackingTrack &track : *tracks) {
1563 if (TRACK_SELECTED(&track)) {
1564 MovieTrackingMarker *marker = BKE_tracking_marker_get(&track, framenr);
1565 float pattern_min[2], pattern_max[2];
1566 BKE_tracking_marker_pattern_minmax(marker, pattern_min, pattern_max);
1567 add_v2_v2(pattern_min, marker->pos);
1568 add_v2_v2(pattern_max, marker->pos);
1569 minmax_v2v2_v2(tracks_min, tracks_max, pattern_min);
1570 minmax_v2v2_v2(tracks_min, tracks_max, pattern_max);
1571 num_selected_tracks++;
1572 }
1573 }
1574
1575 if (num_selected_tracks < 4) {
1576 return nullptr;
1577 }
1578
1579 /* Allocate new plane track. */
1580 plane_track = MEM_new<MovieTrackingPlaneTrack>("new plane track");
1581
1582 /* Use some default name. */
1583 STRNCPY_UTF8(plane_track->name, DATA_("Plane Track"));
1584
1585 plane_track->image_opacity = 1.0f;
1586
1587 /* Use selected tracks from given list as a plane. */
1588 plane_track->point_tracks = MEM_new_array_zeroed<MovieTrackingTrack *>(num_selected_tracks,
1589 "new plane tracks array");
1590 int track_index = 0;
1591 for (MovieTrackingTrack &track : *tracks) {
1592 if (TRACK_SELECTED(&track)) {
1593 plane_track->point_tracks[track_index] = &track;
1594 track_index++;
1595 }
1596 }
1597 plane_track->point_tracksnr = num_selected_tracks;
1598
1599 /* Setup new plane marker and add it to the track. */
1600 plane_marker.framenr = framenr;
1601 plane_marker.flag = TrackingPlaneMarkerFlag{};
1602
1603 copy_v2_v2(plane_marker.corners[0], tracks_min);
1604 copy_v2_v2(plane_marker.corners[2], tracks_max);
1605
1606 plane_marker.corners[1][0] = tracks_max[0];
1607 plane_marker.corners[1][1] = tracks_min[1];
1608 plane_marker.corners[3][0] = tracks_min[0];
1609 plane_marker.corners[3][1] = tracks_max[1];
1610
1611 BKE_tracking_plane_marker_insert(plane_track, &plane_marker);
1612
1613 /* Put new plane track to the list, ensure its name is unique. */
1614 BLI_addtail(plane_tracks_base, plane_track);
1615 BKE_tracking_plane_track_unique_name(plane_tracks_base, plane_track);
1616
1617 return plane_track;
1618}
1619
1620void BKE_tracking_plane_track_unique_name(ListBaseT<MovieTrackingPlaneTrack> *plane_tracks_base,
1621 MovieTrackingPlaneTrack *plane_track)
1622{
1623 BLI_uniquename(plane_tracks_base,
1624 plane_track,
1626 '.',
1628 sizeof(plane_track->name));
1629}
1630
1632{
1633 if (plane_track->markers) {
1634 MEM_delete(plane_track->markers);
1635 }
1636
1637 MEM_delete(plane_track->point_tracks);
1638}
1639
1640void BKE_tracking_plane_tracks_deselect_all(ListBaseT<MovieTrackingPlaneTrack> *plane_tracks_base)
1641{
1642 for (MovieTrackingPlaneTrack &plane_track : *plane_tracks_base) {
1643 plane_track.flag &= ~PLANE_TRACK_SELECT;
1644 }
1645}
1646
1648 MovieTrackingTrack *track)
1649{
1650 for (int i = 0; i < plane_track->point_tracksnr; i++) {
1651 if (plane_track->point_tracks[i] == track) {
1652 return true;
1653 }
1654 }
1655 return false;
1656}
1657
1659 MovieTrackingTrack *track)
1660{
1661 if (plane_track->point_tracksnr <= 4) {
1662 return false;
1663 }
1664
1666 plane_track->point_tracksnr - 1, "new point tracks array");
1667
1668 for (int i = 0, track_index = 0; i < plane_track->point_tracksnr; i++) {
1669 if (plane_track->point_tracks[i] != track) {
1670 new_point_tracks[track_index++] = plane_track->point_tracks[i];
1671 }
1672 }
1673
1674 MEM_delete(plane_track->point_tracks);
1675 plane_track->point_tracks = new_point_tracks;
1676 plane_track->point_tracksnr--;
1677
1678 return true;
1679}
1680
1682 MovieTrackingTrack *track)
1683{
1684 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
1685 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks.items_mutable()) {
1686 if (BKE_tracking_plane_track_has_point_track(&plane_track, track)) {
1687 if (!BKE_tracking_plane_track_remove_point_track(&plane_track, track)) {
1688 /* Delete planes with less than 3 point tracks in it. */
1689 BKE_tracking_plane_track_free(&plane_track);
1690 BLI_freelinkN(&tracking_object->plane_tracks, &plane_track);
1691 }
1692 }
1693 }
1694}
1695
1697 MovieTrackingTrack *old_track,
1698 MovieTrackingTrack *new_track)
1699{
1700 for (int i = 0; i < plane_track->point_tracksnr; i++) {
1701 if (plane_track->point_tracks[i] == old_track) {
1702 plane_track->point_tracks[i] = new_track;
1703 break;
1704 }
1705 }
1706}
1707
1709 MovieTrackingTrack *old_track,
1710 MovieTrackingTrack *new_track)
1711{
1712 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
1713 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
1714 if (BKE_tracking_plane_track_has_point_track(&plane_track, old_track)) {
1715 BKE_tracking_plane_track_replace_point_track(&plane_track, old_track, new_track);
1716 }
1717 }
1718}
1719
1720/* --------------------------------------------------------------------
1721 * Plane marker.
1722 */
1723
1725 MovieTrackingPlaneMarker *plane_marker)
1726{
1727 MovieTrackingPlaneMarker *old_plane_marker = nullptr;
1728
1729 if (plane_track->markersnr) {
1730 old_plane_marker = BKE_tracking_plane_marker_get_exact(plane_track, plane_marker->framenr);
1731 }
1732
1733 if (old_plane_marker) {
1734 /* Simply replace settings in existing marker. */
1735 *old_plane_marker = *plane_marker;
1736
1737 return old_plane_marker;
1738 }
1739
1740 int a = plane_track->markersnr;
1741
1742 /* Find position in array where to add new marker. */
1743 /* TODO(sergey): we could use bisect to speed things up. */
1744 while (a--) {
1745 if (plane_track->markers[a].framenr < plane_marker->framenr) {
1746 break;
1747 }
1748 }
1749
1750 plane_track->markersnr++;
1751 plane_track->markers = static_cast<MovieTrackingPlaneMarker *>(MEM_realloc_uninitialized(
1752 plane_track->markers, sizeof(MovieTrackingPlaneMarker) * plane_track->markersnr));
1753
1754 /* Shift array to "free" space for new marker. */
1755 memmove(plane_track->markers + a + 2,
1756 plane_track->markers + a + 1,
1757 (plane_track->markersnr - a - 2) * sizeof(MovieTrackingPlaneMarker));
1758
1759 /* Put new marker to an array. */
1760 plane_track->markers[a + 1] = *plane_marker;
1761
1762 return &plane_track->markers[a + 1];
1763}
1764
1766{
1767 int a = 0;
1768
1769 while (a < plane_track->markersnr) {
1770 if (plane_track->markers[a].framenr == framenr) {
1771 if (plane_track->markersnr > 1) {
1772 memmove(plane_track->markers + a,
1773 plane_track->markers + a + 1,
1774 (plane_track->markersnr - a - 1) * sizeof(MovieTrackingPlaneMarker));
1775 plane_track->markersnr--;
1776 plane_track->markers = static_cast<MovieTrackingPlaneMarker *>(MEM_realloc_uninitialized(
1777 plane_track->markers, sizeof(MovieTrackingMarker) * plane_track->markersnr));
1778 }
1779 else {
1780 MEM_delete(plane_track->markers);
1781 plane_track->markers = nullptr;
1782 plane_track->markersnr = 0;
1783 }
1784
1785 break;
1786 }
1787
1788 a++;
1789 }
1790}
1791
1792/* TODO(sergey): The next couple of functions are really quite the same as point marker version,
1793 * would be nice to de-duplicate them somehow..
1794 */
1795
1797 int framenr)
1798{
1799 int a = plane_track->markersnr - 1;
1800
1801 if (!plane_track->markersnr) {
1802 return nullptr;
1803 }
1804
1805 /* Approximate pre-first framenr marker with first marker. */
1806 if (framenr < plane_track->markers[0].framenr) {
1807 return &plane_track->markers[0];
1808 }
1809
1810 if (plane_track->last_marker < plane_track->markersnr) {
1811 a = plane_track->last_marker;
1812 }
1813
1814 if (plane_track->markers[a].framenr <= framenr) {
1815 while (a < plane_track->markersnr && plane_track->markers[a].framenr <= framenr) {
1816 if (plane_track->markers[a].framenr == framenr) {
1817 plane_track->last_marker = a;
1818
1819 return &plane_track->markers[a];
1820 }
1821 a++;
1822 }
1823
1824 /* If there's no marker for exact position, use nearest marker from left side. */
1825 return &plane_track->markers[a - 1];
1826 }
1827
1828 while (a >= 0 && plane_track->markers[a].framenr >= framenr) {
1829 if (plane_track->markers[a].framenr == framenr) {
1830 plane_track->last_marker = a;
1831
1832 return &plane_track->markers[a];
1833 }
1834
1835 a--;
1836 }
1837
1838 /* If there's no marker for exact position, use nearest marker from left side. */
1839 return &plane_track->markers[a];
1840}
1841
1843 int framenr)
1844{
1845 MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track, framenr);
1846
1847 if (plane_marker->framenr != framenr) {
1848 return nullptr;
1849 }
1850
1851 return plane_marker;
1852}
1853
1855 int framenr)
1856{
1857 MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track, framenr);
1858
1859 if (plane_marker->framenr != framenr) {
1860 MovieTrackingPlaneMarker plane_marker_new;
1861
1862 plane_marker_new = *plane_marker;
1863 plane_marker_new.framenr = framenr;
1864
1865 plane_marker = BKE_tracking_plane_marker_insert(plane_track, &plane_marker_new);
1866 }
1867
1868 return plane_marker;
1869}
1870
1872 float framenr,
1873 float corners[4][2])
1874{
1875 MovieTrackingPlaneMarker *marker = BKE_tracking_plane_marker_get(plane_track, int(framenr));
1876 MovieTrackingPlaneMarker *marker_last = plane_track->markers + (plane_track->markersnr - 1);
1877 if (marker != marker_last) {
1878 MovieTrackingPlaneMarker *marker_next = marker + 1;
1879 if (marker_next->framenr == marker->framenr + 1) {
1880 float fac = (framenr - int(framenr)) / (marker_next->framenr - marker->framenr);
1881 for (int i = 0; i < 4; i++) {
1882 interp_v2_v2v2(corners[i], marker->corners[i], marker_next->corners[i], fac);
1883 }
1884 }
1885 else {
1886 for (int i = 0; i < 4; i++) {
1887 copy_v2_v2(corners[i], marker->corners[i]);
1888 }
1889 }
1890 }
1891 else {
1892 for (int i = 0; i < 4; i++) {
1893 copy_v2_v2(corners[i], marker->corners[i]);
1894 }
1895 }
1896}
1897
1898/* --------------------------------------------------------------------
1899 * Object.
1900 */
1901
1903{
1904 MovieTrackingObject *tracking_object = MEM_new<MovieTrackingObject>("tracking object");
1905
1906 if (tracking->tot_object == 0) {
1907 /* first object is always camera */
1908 STRNCPY_UTF8(tracking_object->name, "Camera");
1909
1910 tracking_object->flag |= TRACKING_OBJECT_CAMERA;
1911 }
1912 else {
1913 STRNCPY_UTF8(tracking_object->name, name);
1914 }
1915
1916 BLI_addtail(&tracking->objects, tracking_object);
1917
1918 tracking->tot_object++;
1919 tracking->objectnr = tracking->objects.count() - 1;
1920
1921 tracking_object->scale = 1.0f;
1922 tracking_object->keyframe1 = 1;
1923 tracking_object->keyframe2 = 30;
1924
1925 BKE_tracking_object_unique_name(tracking, tracking_object);
1927
1928 return tracking_object;
1929}
1930
1932{
1933 const int index = BLI_findindex(&tracking->objects, tracking_object);
1934
1935 if (index == -1) {
1936 return false;
1937 }
1938
1939 if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
1940 /* object used for camera solving can't be deleted */
1941 return false;
1942 }
1943
1944 tracking_object_free(tracking_object);
1945 BLI_freelinkN(&tracking->objects, tracking_object);
1946
1947 tracking->tot_object--;
1948
1949 if (index != 0) {
1950 tracking->objectnr = index - 1;
1951 }
1952 else {
1953 tracking->objectnr = 0;
1954 }
1955
1957
1958 return true;
1959}
1960
1962{
1963 BLI_uniquename(&tracking->objects,
1964 tracking_object,
1965 DATA_("Object"),
1966 '.',
1968 sizeof(tracking_object->name));
1969}
1970
1972{
1973 for (MovieTrackingObject &tracking_object : tracking->objects) {
1974 if (STREQ(tracking_object.name, name)) {
1975 return &tracking_object;
1976 }
1977 }
1978
1979 return nullptr;
1980}
1981
1983{
1984 return static_cast<MovieTrackingObject *>(BLI_findlink(&tracking->objects, tracking->objectnr));
1985}
1986
1988{
1989 for (MovieTrackingObject &tracking_object : tracking->objects) {
1990 if (tracking_object.flag & TRACKING_OBJECT_CAMERA) {
1991 return &tracking_object;
1992 }
1993 }
1994
1995 return nullptr;
1996}
1997
1999 const char *name)
2000{
2001 for (MovieTrackingTrack &track : tracking_object->tracks) {
2002 if (STREQ(track.name, name)) {
2003 return &track;
2004 }
2005 }
2006
2007 return nullptr;
2008}
2009
2011 MovieTrackingObject *tracking_object, const char *name)
2012{
2013 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
2014 if (STREQ(plane_track.name, name)) {
2015 return &plane_track;
2016 }
2017 }
2018
2019 return nullptr;
2020}
2021
2022/* --------------------------------------------------------------------
2023 * Camera.
2024 */
2025
2027 int framenr,
2028 bool nearest)
2029{
2030 MovieReconstructedCamera *cameras = reconstruction->cameras;
2031 int a = 0, d = 1;
2032
2033 if (!reconstruction->camnr) {
2034 return -1;
2035 }
2036
2037 if (framenr < cameras[0].framenr) {
2038 if (nearest) {
2039 return 0;
2040 }
2041
2042 return -1;
2043 }
2044
2045 if (framenr > cameras[reconstruction->camnr - 1].framenr) {
2046 if (nearest) {
2047 return reconstruction->camnr - 1;
2048 }
2049
2050 return -1;
2051 }
2052
2053 if (reconstruction->last_camera < reconstruction->camnr) {
2054 a = reconstruction->last_camera;
2055 }
2056
2057 if (cameras[a].framenr >= framenr) {
2058 d = -1;
2059 }
2060
2061 while (a >= 0 && a < reconstruction->camnr) {
2062 int cfra = cameras[a].framenr;
2063
2064 /* check if needed framenr was "skipped" -- no data for requested frame */
2065
2066 if (d > 0 && cfra > framenr) {
2067 /* interpolate with previous position */
2068 if (nearest) {
2069 return a - 1;
2070 }
2071
2072 break;
2073 }
2074
2075 if (d < 0 && cfra < framenr) {
2076 /* interpolate with next position */
2077 if (nearest) {
2078 return a;
2079 }
2080
2081 break;
2082 }
2083
2084 if (cfra == framenr) {
2085 reconstruction->last_camera = a;
2086
2087 return a;
2088 }
2089
2090 a += d;
2091 }
2092
2093 return -1;
2094}
2095
2096static void reconstructed_camera_scale_set(const MovieTrackingObject *tracking_object,
2097 float mat[4][4])
2098{
2099 if ((tracking_object->flag & TRACKING_OBJECT_CAMERA) == 0) {
2100 float smat[4][4];
2101
2102 scale_m4_fl(smat, 1.0f / tracking_object->scale);
2103 mul_m4_m4m4(mat, mat, smat);
2104 }
2105}
2106
2108 MovieTracking *tracking, int winx, int winy, float *shiftx, float *shifty)
2109{
2110 float principal_px[2];
2112 tracking->camera.principal_point, winx, winy, principal_px);
2113
2114 /* Indeed in both of cases it should be winx -
2115 * it's just how camera shift works for blender's camera. */
2116 *shiftx = (0.5f * winx - principal_px[0]) / winx;
2117 *shifty = (0.5f * winy - principal_px[1]) / winx;
2118}
2119
2121 MovieTracking *tracking, Scene *scene, Camera *camera, int width, int height)
2122{
2123 float focal = tracking->camera.focal;
2124
2125 camera->sensor_x = tracking->camera.sensor_width;
2126 camera->sensor_fit = CAMERA_SENSOR_FIT_HOR;
2127 camera->lens = focal * camera->sensor_x / width;
2128
2129 scene->r.xsch = width;
2130 scene->r.ysch = height;
2131
2132 scene->r.xasp = tracking->camera.pixel_aspect;
2133 scene->r.yasp = 1.0f;
2134
2135 BKE_tracking_camera_shift_get(tracking, width, height, &camera->shiftx, &camera->shifty);
2136}
2137
2139 MovieTracking * /*tracking*/, MovieTrackingObject *tracking_object, int framenr)
2140{
2141 MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
2142 int a = reconstructed_camera_index_get(reconstruction, framenr, false);
2143
2144 if (a == -1) {
2145 return nullptr;
2146 }
2147
2148 return &reconstruction->cameras[a];
2149}
2150
2152 MovieTrackingObject *tracking_object,
2153 float framenr,
2154 float mat[4][4])
2155{
2156 MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
2157 MovieReconstructedCamera *cameras = reconstruction->cameras;
2158
2159 int a = reconstructed_camera_index_get(reconstruction, int(framenr), true);
2160
2161 if (a == -1) {
2162 unit_m4(mat);
2163 return;
2164 }
2165
2166 if ((a < reconstruction->camnr - 1) && (cameras[a].framenr != framenr)) {
2167 float t = (framenr - cameras[a].framenr) / (cameras[a + 1].framenr - cameras[a].framenr);
2168 blend_m4_m4m4(mat, cameras[a].mat, cameras[a + 1].mat, t);
2169 }
2170 else {
2171 copy_m4_m4(mat, cameras[a].mat);
2172 }
2173
2174 reconstructed_camera_scale_set(tracking_object, mat);
2175}
2176
2178 float r_principal_point_pixel[2])
2179{
2180 const MovieTrackingCamera *camera = &clip->tracking.camera;
2181
2182 int frame_width, frame_height;
2183 MovieClipUser user = {};
2184 BKE_movieclip_get_size(clip, &user, &frame_width, &frame_height);
2185
2187 camera->principal_point, frame_width, frame_height, r_principal_point_pixel);
2188}
2189
2191 const float principal_point_pixel[2])
2192{
2194
2195 int frame_width, frame_height;
2196 MovieClipUser user = {};
2197 BKE_movieclip_get_size(clip, &user, &frame_width, &frame_height);
2198
2200 principal_point_pixel, frame_width, frame_height, camera->principal_point);
2201}
2202
2204 const MovieTrackingCamera *b)
2205{
2206 if (a->pixel_aspect != b->pixel_aspect || a->focal != b->focal ||
2207 !equals_v2v2(a->principal_point, b->principal_point))
2208 {
2209 return false;
2210 }
2211
2212 if (a->distortion_model != b->distortion_model) {
2213 return false;
2214 }
2215
2216 switch (a->distortion_model) {
2218 return a->k1 == b->k1 && a->k2 == b->k2 && a->k3 == b->k3;
2220 return a->division_k1 == b->division_k1 && a->division_k2 == b->division_k2;
2222 return a->nuke_k1 == b->nuke_k1 && a->nuke_k2 == b->nuke_k2 && a->nuke_p1 == b->nuke_p1 &&
2223 a->nuke_p2 == b->nuke_p2;
2225 return a->brown_k1 == b->brown_k1 && a->brown_k2 == b->brown_k2 &&
2226 a->brown_k3 == b->brown_k3 && a->brown_k4 == b->brown_k4 &&
2227 a->brown_p1 == b->brown_p1 && a->brown_p2 == b->brown_p2;
2228 }
2229
2231 return false;
2232}
2233
2235{
2236 switch (camera->distortion_model) {
2238 return get_default_hash(camera->distortion_model,
2239 float2(camera->pixel_aspect, camera->focal),
2240 float2(camera->principal_point),
2241 float3(camera->k1, camera->k2, camera->k3));
2243 return get_default_hash(camera->distortion_model,
2244 float2(camera->pixel_aspect, camera->focal),
2245 float2(camera->principal_point),
2246 float2(camera->division_k1, camera->division_k2));
2248 return get_default_hash(
2249 camera->distortion_model,
2250 float2(camera->pixel_aspect, camera->focal),
2251 float2(camera->principal_point),
2252 float4(camera->nuke_k1, camera->nuke_k2, camera->nuke_p1, camera->nuke_p2));
2254 return get_default_hash(
2255 float2(camera->pixel_aspect, camera->focal),
2256 float2(camera->principal_point),
2257 float4(camera->brown_k1, camera->brown_k2, camera->brown_k3, camera->brown_k4),
2258 float2(camera->brown_p1, camera->brown_p2));
2259 }
2260
2262 return 0;
2263}
2264/* --------------------------------------------------------------------
2265 * (Un)distortion.
2266 */
2267
2269 int calibration_width,
2270 int calibration_height)
2271{
2272 MovieDistortion *distortion;
2273 libmv_CameraIntrinsicsOptions camera_intrinsics_options;
2274
2276 tracking, calibration_width, calibration_height, &camera_intrinsics_options);
2277
2278 distortion = MEM_new_zeroed<MovieDistortion>("BKE_tracking_distortion_create");
2279 distortion->intrinsics = libmv_cameraIntrinsicsNew(&camera_intrinsics_options);
2280
2281 const MovieTrackingCamera *camera = &tracking->camera;
2283 calibration_width,
2284 calibration_height,
2285 distortion->principal_px);
2286 distortion->pixel_aspect = camera->pixel_aspect;
2287 distortion->focal = camera->focal;
2288
2289 return distortion;
2290}
2291
2293 MovieTracking *tracking,
2294 int calibration_width,
2295 int calibration_height)
2296{
2297 libmv_CameraIntrinsicsOptions camera_intrinsics_options;
2298
2300 tracking, calibration_width, calibration_height, &camera_intrinsics_options);
2301
2302 const MovieTrackingCamera *camera = &tracking->camera;
2304 calibration_width,
2305 calibration_height,
2306 distortion->principal_px);
2307 distortion->pixel_aspect = camera->pixel_aspect;
2308 distortion->focal = camera->focal;
2309
2310 libmv_cameraIntrinsicsUpdate(&camera_intrinsics_options, distortion->intrinsics);
2311}
2312
2314{
2315 MovieDistortion *new_distortion;
2316
2317 new_distortion = MEM_new_zeroed<MovieDistortion>("BKE_tracking_distortion_create");
2318 *new_distortion = *distortion;
2319 new_distortion->intrinsics = libmv_cameraIntrinsicsCopy(distortion->intrinsics);
2320
2321 return new_distortion;
2322}
2323
2325 MovieTracking *tracking,
2326 ImBuf *ibuf,
2327 int calibration_width,
2328 int calibration_height,
2329 float overscan,
2330 bool undistort)
2331{
2332 ImBuf *resibuf;
2333
2334 BKE_tracking_distortion_update(distortion, tracking, calibration_width, calibration_height);
2335
2336 resibuf = IMB_dupImBuf(ibuf);
2337
2338 if (ibuf->float_data()) {
2339 if (undistort) {
2341 ibuf->float_data(),
2342 ibuf->x,
2343 ibuf->y,
2344 overscan,
2345 ibuf->channels,
2346 resibuf->float_data_for_write());
2347 }
2348 else {
2350 ibuf->float_data_for_write(),
2351 ibuf->x,
2352 ibuf->y,
2353 overscan,
2354 ibuf->channels,
2355 resibuf->float_data_for_write());
2356 }
2357
2359 }
2360 else {
2361 if (undistort) {
2363 ibuf->byte_data(),
2364 ibuf->x,
2365 ibuf->y,
2366 overscan,
2367 ibuf->channels,
2368 resibuf->byte_data_for_write());
2369 }
2370 else {
2372 ibuf->byte_data(),
2373 ibuf->x,
2374 ibuf->y,
2375 overscan,
2376 ibuf->channels,
2377 resibuf->byte_data_for_write());
2378 }
2379 }
2380
2381 return resibuf;
2382}
2383
2385 const float co[2],
2386 float r_co[2])
2387{
2388 const float aspy = 1.0f / distortion->pixel_aspect;
2389
2390 /* Normalize coords. */
2391 float inv_focal = 1.0f / distortion->focal;
2392 double x = (co[0] - distortion->principal_px[0]) * inv_focal,
2393 y = (co[1] - distortion->principal_px[1] * aspy) * inv_focal;
2394
2395 libmv_cameraIntrinsicsApply(distortion->intrinsics, x, y, &x, &y);
2396
2397 /* Result is in image coords already. */
2398 r_co[0] = x;
2399 r_co[1] = y;
2400}
2401
2403 const float co[2],
2404 float r_co[2])
2405{
2406 double x = co[0], y = co[1];
2407 libmv_cameraIntrinsicsInvert(distortion->intrinsics, x, y, &x, &y);
2408
2409 const float aspy = 1.0f / distortion->pixel_aspect;
2410 r_co[0] = float(x) * distortion->focal + distortion->principal_px[0];
2411 r_co[1] = float(y) * distortion->focal + distortion->principal_px[1] * aspy;
2412}
2413
2415{
2417
2418 MEM_delete(distortion);
2419}
2420
2422 MovieTracking *tracking, int image_width, int image_height, const float co[2], float r_co[2])
2423{
2424 const MovieTrackingCamera *camera = &tracking->camera;
2425 const float aspy = 1.0f / tracking->camera.pixel_aspect;
2426
2427 libmv_CameraIntrinsicsOptions camera_intrinsics_options;
2429 tracking, image_width, image_height, &camera_intrinsics_options);
2430 libmv_CameraIntrinsics *intrinsics = libmv_cameraIntrinsicsNew(&camera_intrinsics_options);
2431
2432 float principal_px[2];
2434 tracking->camera.principal_point, image_width, image_height, principal_px);
2435
2436 /* Normalize coordinates. */
2437 double x = (co[0] - principal_px[0]) / camera->focal,
2438 y = (co[1] - principal_px[1] * aspy) / camera->focal;
2439
2440 libmv_cameraIntrinsicsApply(intrinsics, x, y, &x, &y);
2442
2443 /* Result is in image coords already. */
2444 r_co[0] = x;
2445 r_co[1] = y;
2446}
2447
2449 MovieTracking *tracking, int image_width, int image_height, const float co[2], float r_co[2])
2450{
2451 const MovieTrackingCamera *camera = &tracking->camera;
2452 const float aspy = 1.0f / tracking->camera.pixel_aspect;
2453
2454 libmv_CameraIntrinsicsOptions camera_intrinsics_options;
2456 tracking, image_width, image_height, &camera_intrinsics_options);
2457 libmv_CameraIntrinsics *intrinsics = libmv_cameraIntrinsicsNew(&camera_intrinsics_options);
2458
2459 double x = co[0], y = co[1];
2460 libmv_cameraIntrinsicsInvert(intrinsics, x, y, &x, &y);
2462
2463 float principal_px[2];
2465 tracking->camera.principal_point, image_width, image_height, principal_px);
2466
2467 r_co[0] = float(x) * camera->focal + principal_px[0];
2468 r_co[1] = float(y) * camera->focal + principal_px[1] * aspy;
2469}
2470
2472 ImBuf *ibuf,
2473 int calibration_width,
2474 int calibration_height,
2475 float overscan)
2476{
2477 MovieTrackingCamera *camera = &tracking->camera;
2478
2479 if (camera->intrinsics == nullptr) {
2480 camera->intrinsics = BKE_tracking_distortion_new(
2481 tracking, calibration_width, calibration_height);
2482 }
2483
2484 return BKE_tracking_distortion_exec(static_cast<MovieDistortion *>(camera->intrinsics),
2485 tracking,
2486 ibuf,
2487 calibration_width,
2488 calibration_height,
2489 overscan,
2490 true);
2491}
2492
2494 ImBuf *ibuf,
2495 int calibration_width,
2496 int calibration_height,
2497 float overscan)
2498{
2499 MovieTrackingCamera *camera = &tracking->camera;
2500
2501 if (camera->intrinsics == nullptr) {
2502 camera->intrinsics = BKE_tracking_distortion_new(
2503 tracking, calibration_width, calibration_height);
2504 }
2505
2506 return BKE_tracking_distortion_exec(static_cast<MovieDistortion *>(camera->intrinsics),
2507 tracking,
2508 ibuf,
2509 calibration_width,
2510 calibration_height,
2511 overscan,
2512 false);
2513}
2514
2515/* --------------------------------------------------------------------
2516 * Image sampling.
2517 */
2518
2520 const MovieTrackingTrack *track,
2521 const bool grayscale)
2522{
2524 track->flag & TRACK_DISABLE_RED,
2525 track->flag & TRACK_DISABLE_GREEN,
2526 track->flag & TRACK_DISABLE_BLUE,
2527 grayscale);
2528}
2529
2530ImBuf *BKE_tracking_sample_pattern(const int frame_width,
2531 const int frame_height,
2532 const ImBuf *search_ibuf,
2533 const MovieTrackingTrack *track,
2534 const MovieTrackingMarker *marker,
2535 const bool from_anchor,
2536 const bool use_mask,
2537 const int num_samples_x,
2538 const int num_samples_y,
2539 float pos[2])
2540{
2541 ImBuf *pattern_ibuf;
2542 double src_pixel_x[5], src_pixel_y[5];
2543 double warped_position_x, warped_position_y;
2544 float *mask = nullptr;
2545
2546 if (num_samples_x <= 0 || num_samples_y <= 0) {
2547 return nullptr;
2548 }
2549
2550 pattern_ibuf = IMB_allocImBuf(num_samples_x,
2551 num_samples_y,
2552 search_ibuf->float_data() ? ImBufFlags::FloatData :
2554
2556 frame_width, frame_height, marker, src_pixel_x, src_pixel_y);
2557
2558 /* from_anchor means search buffer was obtained for an anchored position,
2559 * which means applying track offset rounded to pixel space (we could not
2560 * store search buffer with sub-pixel precision)
2561 *
2562 * in this case we need to alter coordinates a bit, to compensate rounded
2563 * fractional part of offset
2564 */
2565 if (from_anchor) {
2566 for (int a = 0; a < 5; a++) {
2567 src_pixel_x[a] += double((track->offset[0] * frame_width) -
2568 int(track->offset[0] * frame_width));
2569 src_pixel_y[a] += double((track->offset[1] * frame_height) -
2570 int(track->offset[1] * frame_height));
2571
2572 /* when offset is negative, rounding happens in opposite direction */
2573 if (track->offset[0] < 0.0f) {
2574 src_pixel_x[a] += 1.0;
2575 }
2576 if (track->offset[1] < 0.0f) {
2577 src_pixel_y[a] += 1.0;
2578 }
2579 }
2580 }
2581
2582 if (use_mask) {
2583 mask = BKE_tracking_track_get_mask(frame_width, frame_height, track, marker);
2584 }
2585
2586 if (search_ibuf->float_data()) {
2588 search_ibuf->x,
2589 search_ibuf->y,
2590 4,
2591 src_pixel_x,
2592 src_pixel_y,
2593 num_samples_x,
2594 num_samples_y,
2595 mask,
2596 pattern_ibuf->float_data_for_write(),
2597 &warped_position_x,
2598 &warped_position_y);
2599 }
2600 else {
2602 search_ibuf->x,
2603 search_ibuf->y,
2604 4,
2605 src_pixel_x,
2606 src_pixel_y,
2607 num_samples_x,
2608 num_samples_y,
2609 mask,
2610 pattern_ibuf->byte_data_for_write(),
2611 &warped_position_x,
2612 &warped_position_y);
2613 }
2614
2615 if (pos) {
2616 pos[0] = warped_position_x;
2617 pos[1] = warped_position_y;
2618 }
2619
2620 if (mask) {
2621 MEM_delete(mask);
2622 }
2623
2624 return pattern_ibuf;
2625}
2626
2628 const MovieTrackingTrack *track,
2629 const MovieTrackingMarker *marker,
2630 const bool anchored,
2631 const bool disable_channels)
2632{
2633 ImBuf *pattern_ibuf, *search_ibuf;
2634 float pat_min[2], pat_max[2];
2635 int num_samples_x, num_samples_y;
2636
2637 BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
2638
2639 num_samples_x = (pat_max[0] - pat_min[0]) * ibuf->x;
2640 num_samples_y = (pat_max[1] - pat_min[1]) * ibuf->y;
2641
2642 search_ibuf = BKE_tracking_get_search_imbuf(ibuf, track, marker, anchored, disable_channels);
2643
2644 if (search_ibuf) {
2645 pattern_ibuf = BKE_tracking_sample_pattern(ibuf->x,
2646 ibuf->y,
2647 search_ibuf,
2648 track,
2649 marker,
2650 anchored,
2651 false,
2652 num_samples_x,
2653 num_samples_y,
2654 nullptr);
2655
2656 IMB_freeImBuf(search_ibuf);
2657 }
2658 else {
2659 pattern_ibuf = nullptr;
2660 }
2661
2662 return pattern_ibuf;
2663}
2664
2666 const MovieTrackingTrack *track,
2667 const MovieTrackingMarker *marker,
2668 const bool anchored,
2669 const bool disable_channels)
2670{
2671 ImBuf *searchibuf;
2672 int x, y, w, h;
2673 float search_origin[2];
2674
2675 tracking_get_search_origin_frame_pixel(ibuf->x, ibuf->y, marker, search_origin);
2676
2677 x = search_origin[0];
2678 y = search_origin[1];
2679
2680 if (anchored) {
2681 x += track->offset[0] * ibuf->x;
2682 y += track->offset[1] * ibuf->y;
2683 }
2684
2685 w = (marker->search_max[0] - marker->search_min[0]) * ibuf->x;
2686 h = (marker->search_max[1] - marker->search_min[1]) * ibuf->y;
2687
2688 if (w <= 0 || h <= 0) {
2689 return nullptr;
2690 }
2691
2692 searchibuf = IMB_allocImBuf(
2694
2695 /* Clamp copy region to image bounds. */
2696 int dst_x = 0, dst_y = 0;
2697 if (x < 0) {
2698 dst_x = -x;
2699 w += x;
2700 x = 0;
2701 }
2702 if (y < 0) {
2703 dst_y = -y;
2704 h += y;
2705 y = 0;
2706 }
2707 if (x + w > ibuf->x) {
2708 w = ibuf->x - x;
2709 }
2710 if (y + h > ibuf->y) {
2711 h = ibuf->y - y;
2712 }
2713 if (w > 0 && h > 0) {
2714 IMB_copy_rect(searchibuf, ibuf, int2(x, y), int2(dst_x, dst_y), int2(w, h));
2715 }
2716
2717 if (disable_channels) {
2718 if ((track->flag & TRACK_PREVIEW_GRAYSCALE) || (track->flag & TRACK_DISABLE_RED) ||
2719 (track->flag & TRACK_DISABLE_GREEN) || (track->flag & TRACK_DISABLE_BLUE))
2720 {
2721 disable_imbuf_channels(searchibuf, track, true);
2722 }
2723 }
2724
2725 return searchibuf;
2726}
2727
2729 const float b[2],
2730 const int frame_width,
2731 const int frame_height)
2732{
2733 const float a_px[2] = {a[0] * frame_width, a[1] * frame_height};
2734 const float b_px[2] = {b[0] * frame_width, b[1] * frame_height};
2735
2736 return ceilf(len_v2v2(a_px, b_px));
2737}
2738
2740 const MovieTrackingPlaneMarker *plane_marker)
2741{
2742 /* Alias for corners, allowing shorter access to coordinates. */
2743 const float (*corners)[2] = plane_marker->corners;
2744
2745 /* Dimensions of the frame image in pixels. */
2746 const int frame_width = frame_ibuf->x;
2747 const int frame_height = frame_ibuf->y;
2748
2749 /* Lengths of left and right edges of the plane marker, in pixels. */
2750 const int left_side_len_px = plane_marker_size_len_in_pixels(
2751 corners[0], corners[3], frame_width, frame_height);
2752 const int right_side_len_px = plane_marker_size_len_in_pixels(
2753 corners[1], corners[2], frame_width, frame_height);
2754
2755 /* Lengths of top and bottom edges of the plane marker, in pixels. */
2756 const int top_side_len_px = plane_marker_size_len_in_pixels(
2757 corners[3], corners[2], frame_width, frame_height);
2758 const int bottom_side_len_px = plane_marker_size_len_in_pixels(
2759 corners[0], corners[1], frame_width, frame_height);
2760
2761 /* Choose the number of samples as a maximum of the corresponding sides in pixels. */
2762 const int num_samples_x = max_ii(top_side_len_px, bottom_side_len_px);
2763 const int num_samples_y = max_ii(left_side_len_px, right_side_len_px);
2764
2765 /* Create new result image with the same type of content as the original. */
2766 ImBuf *plane_ibuf = IMB_allocImBuf(num_samples_x,
2767 num_samples_y,
2768 frame_ibuf->float_data() ? ImBufFlags::FloatData :
2770
2771 /* Calculate corner coordinates in pixel space, as separate X/Y arrays. */
2772 const double src_pixel_x[4] = {corners[0][0] * frame_width,
2773 corners[1][0] * frame_width,
2774 corners[2][0] * frame_width,
2775 corners[3][0] * frame_width};
2776 const double src_pixel_y[4] = {corners[0][1] * frame_height,
2777 corners[1][1] * frame_height,
2778 corners[2][1] * frame_height,
2779 corners[3][1] * frame_height};
2780
2781 /* Warped Position is unused but is expected to be provided by the API. */
2782 double warped_position_x, warped_position_y;
2783
2784 /* Actual sampling. */
2785 if (frame_ibuf->float_data() != nullptr) {
2787 frame_ibuf->x,
2788 frame_ibuf->y,
2789 4,
2790 src_pixel_x,
2791 src_pixel_y,
2792 num_samples_x,
2793 num_samples_y,
2794 nullptr,
2795 plane_ibuf->float_data_for_write(),
2796 &warped_position_x,
2797 &warped_position_y);
2798 }
2799 else {
2801 frame_ibuf->x,
2802 frame_ibuf->y,
2803 4,
2804 src_pixel_x,
2805 src_pixel_y,
2806 num_samples_x,
2807 num_samples_y,
2808 nullptr,
2809 plane_ibuf->byte_data_for_write(),
2810 &warped_position_x,
2811 &warped_position_y);
2812 }
2813
2814 plane_ibuf->byte_buffer.colorspace = frame_ibuf->byte_buffer.colorspace;
2815 plane_ibuf->float_buffer.colorspace = frame_ibuf->float_buffer.colorspace;
2816
2817 return plane_ibuf;
2818}
2819
2821 ImBuf *ibuf, bool disable_red, bool disable_green, bool disable_blue, bool grayscale)
2822{
2823 if (!disable_red && !disable_green && !disable_blue && !grayscale) {
2824 return;
2825 }
2826
2827 /* if only some components are selected, it's important to rescale the result
2828 * appropriately so that e.g. if only blue is selected, it's not zeroed out.
2829 */
2830 float scale = (disable_red ? 0.0f : 0.2126f) + (disable_green ? 0.0f : 0.7152f) +
2831 (disable_blue ? 0.0f : 0.0722f);
2832
2833 float *float_data = ibuf->float_data_for_write();
2834 uchar *byte_data = ibuf->byte_data_for_write();
2835 for (int y = 0; y < ibuf->y; y++) {
2836 for (int x = 0; x < ibuf->x; x++) {
2837 int pixel = ibuf->x * y + x;
2838
2839 if (float_data) {
2840 float *rrgbf = float_data + pixel * 4;
2841 float r = disable_red ? 0.0f : rrgbf[0];
2842 float g = disable_green ? 0.0f : rrgbf[1];
2843 float b = disable_blue ? 0.0f : rrgbf[2];
2844
2845 if (grayscale) {
2846 float gray = (0.2126f * r + 0.7152f * g + 0.0722f * b) / scale;
2847
2848 rrgbf[0] = rrgbf[1] = rrgbf[2] = gray;
2849 }
2850 else {
2851 rrgbf[0] = r;
2852 rrgbf[1] = g;
2853 rrgbf[2] = b;
2854 }
2855 }
2856 else {
2857 uchar *rrgb = byte_data + pixel * 4;
2858 uchar r = disable_red ? 0 : rrgb[0];
2859 uchar g = disable_green ? 0 : rrgb[1];
2860 uchar b = disable_blue ? 0 : rrgb[2];
2861
2862 if (grayscale) {
2863 float gray = (0.2126f * r + 0.7152f * g + 0.0722f * b) / scale;
2864
2865 rrgb[0] = rrgb[1] = rrgb[2] = gray;
2866 }
2867 else {
2868 rrgb[0] = r;
2869 rrgb[1] = g;
2870 rrgb[2] = b;
2871 }
2872 }
2873 }
2874 }
2875}
2876
2877/* --------------------------------------------------------------------
2878 * Dope-sheet functions.
2879 */
2880
2881/* ** Channels sort comparators ** */
2882
2883static int channels_alpha_sort(const void *a, const void *b)
2884{
2885 const MovieTrackingDopesheetChannel *channel_a =
2886 static_cast<const MovieTrackingDopesheetChannel *>(a);
2887 const MovieTrackingDopesheetChannel *channel_b =
2888 static_cast<const MovieTrackingDopesheetChannel *>(b);
2889
2890 if (BLI_strcasecmp(channel_a->track->name, channel_b->track->name) > 0) {
2891 return 1;
2892 }
2893
2894 return 0;
2895}
2896
2897static int channels_total_track_sort(const void *a, const void *b)
2898{
2899 const MovieTrackingDopesheetChannel *channel_a =
2900 static_cast<const MovieTrackingDopesheetChannel *>(a);
2901 const MovieTrackingDopesheetChannel *channel_b =
2902 static_cast<const MovieTrackingDopesheetChannel *>(b);
2903
2904 if (channel_a->total_frames > channel_b->total_frames) {
2905 return 1;
2906 }
2907
2908 return 0;
2909}
2910
2911static int channels_longest_segment_sort(const void *a, const void *b)
2912{
2913 const MovieTrackingDopesheetChannel *channel_a =
2914 static_cast<const MovieTrackingDopesheetChannel *>(a);
2915 const MovieTrackingDopesheetChannel *channel_b =
2916 static_cast<const MovieTrackingDopesheetChannel *>(b);
2917
2918 if (channel_a->max_segment > channel_b->max_segment) {
2919 return 1;
2920 }
2921
2922 return 0;
2923}
2924
2925static int channels_average_error_sort(const void *a, const void *b)
2926{
2927 const MovieTrackingDopesheetChannel *channel_a =
2928 static_cast<const MovieTrackingDopesheetChannel *>(a);
2929 const MovieTrackingDopesheetChannel *channel_b =
2930 static_cast<const MovieTrackingDopesheetChannel *>(b);
2931
2932 if (channel_a->track->error > channel_b->track->error) {
2933 return 1;
2934 }
2935
2936 if (channel_a->track->error == channel_b->track->error) {
2937 return channels_alpha_sort(a, b);
2938 }
2939
2940 return 0;
2941}
2942
2944 bool inverse, bool a_markerless, int a_value, bool b_markerless, int b_value)
2945{
2946 if (a_markerless && b_markerless) {
2947 /* Neither channel has not-disabled markers, return whatever. */
2948 return 0;
2949 }
2950 if (a_markerless) {
2951 /* Put the markerless channel first. */
2952 return 0;
2953 }
2954 if (b_markerless) {
2955 /* Put the markerless channel first. */
2956 return 1;
2957 }
2958
2959 /* Both channels have markers. */
2960
2961 if (inverse) {
2962 if (a_value < b_value) {
2963 return 1;
2964 }
2965 return 0;
2966 }
2967
2968 if (a_value > b_value) {
2969 return 1;
2970 }
2971 return 0;
2972}
2973
2974static int channels_start_sort(const void *a, const void *b)
2975{
2976 const MovieTrackingDopesheetChannel *channel_a =
2977 static_cast<const MovieTrackingDopesheetChannel *>(a);
2978 const MovieTrackingDopesheetChannel *channel_b =
2979 static_cast<const MovieTrackingDopesheetChannel *>(b);
2980
2982 channel_a->tot_segment == 0,
2984 channel_b->tot_segment == 0,
2986}
2987
2988static int channels_end_sort(const void *a, const void *b)
2989{
2990 const MovieTrackingDopesheetChannel *channel_a =
2991 static_cast<const MovieTrackingDopesheetChannel *>(a);
2992 const MovieTrackingDopesheetChannel *channel_b =
2993 static_cast<const MovieTrackingDopesheetChannel *>(b);
2994
2996 channel_a->tot_segment == 0,
2998 channel_b->tot_segment == 0,
3000}
3001
3002static int channels_alpha_inverse_sort(const void *a, const void *b)
3003{
3004 if (channels_alpha_sort(a, b)) {
3005 return 0;
3006 }
3007
3008 return 1;
3009}
3010
3011static int channels_total_track_inverse_sort(const void *a, const void *b)
3012{
3013 if (channels_total_track_sort(a, b)) {
3014 return 0;
3015 }
3016
3017 return 1;
3018}
3019
3020static int channels_longest_segment_inverse_sort(const void *a, const void *b)
3021{
3023 return 0;
3024 }
3025
3026 return 1;
3027}
3028
3029static int channels_average_error_inverse_sort(const void *a, const void *b)
3030{
3031 const MovieTrackingDopesheetChannel *channel_a =
3032 static_cast<const MovieTrackingDopesheetChannel *>(a);
3033 const MovieTrackingDopesheetChannel *channel_b =
3034 static_cast<const MovieTrackingDopesheetChannel *>(b);
3035
3036 if (channel_a->track->error < channel_b->track->error) {
3037 return 1;
3038 }
3039
3040 return 0;
3041}
3042
3043static int channels_start_inverse_sort(const void *a, const void *b)
3044{
3045 const MovieTrackingDopesheetChannel *channel_a =
3046 static_cast<const MovieTrackingDopesheetChannel *>(a);
3047 const MovieTrackingDopesheetChannel *channel_b =
3048 static_cast<const MovieTrackingDopesheetChannel *>(b);
3049
3051 channel_a->tot_segment == 0,
3053 channel_b->tot_segment == 0,
3055}
3056
3057static int channels_end_inverse_sort(const void *a, const void *b)
3058{
3059 const MovieTrackingDopesheetChannel *channel_a =
3060 static_cast<const MovieTrackingDopesheetChannel *>(a);
3061 const MovieTrackingDopesheetChannel *channel_b =
3062 static_cast<const MovieTrackingDopesheetChannel *>(b);
3063
3065 channel_a->tot_segment == 0,
3067 channel_b->tot_segment == 0,
3069}
3070
3071/* Calculate frames segments at which track is tracked continuously. */
3073{
3074 MovieTrackingTrack *track = channel->track;
3075 int i, segment;
3076 bool first_not_disabled_marker_framenr_set;
3077
3078 channel->tot_segment = 0;
3079 channel->max_segment = 0;
3080 channel->total_frames = 0;
3081
3084
3085 /* TODO(sergey): looks a bit code-duplicated, need to look into
3086 * logic de-duplication here.
3087 */
3088
3089 /* count */
3090 i = 0;
3091 first_not_disabled_marker_framenr_set = false;
3092 while (i < track->markersnr) {
3093 MovieTrackingMarker *marker = &track->markers[i];
3094
3095 if ((marker->flag & MARKER_DISABLED) == 0) {
3096 int prev_fra = marker->framenr, len = 0;
3097
3098 i++;
3099 while (i < track->markersnr) {
3100 marker = &track->markers[i];
3101
3102 if (marker->framenr != prev_fra + 1) {
3103 break;
3104 }
3105 if (marker->flag & MARKER_DISABLED) {
3106 break;
3107 }
3108
3109 if (!first_not_disabled_marker_framenr_set) {
3110 channel->first_not_disabled_marker_framenr = marker->framenr;
3111 first_not_disabled_marker_framenr_set = true;
3112 }
3113 channel->last_not_disabled_marker_framenr = marker->framenr;
3114
3115 prev_fra = marker->framenr;
3116 len++;
3117 i++;
3118 }
3119
3120 channel->tot_segment++;
3121 (void)len; /* Quiet set-but-unused warning (may be removed). */
3122 }
3123
3124 i++;
3125 }
3126
3127 if (!channel->tot_segment) {
3128 return;
3129 }
3130
3131 channel->segments = MEM_new_array_zeroed<int>(2 * channel->tot_segment,
3132 "tracking channel segments");
3133
3134 /* create segments */
3135 i = 0;
3136 segment = 0;
3137 while (i < track->markersnr) {
3138 MovieTrackingMarker *marker = &track->markers[i];
3139
3140 if ((marker->flag & MARKER_DISABLED) == 0) {
3141 MovieTrackingMarker *start_marker = marker;
3142 int prev_fra = marker->framenr, len = 0;
3143
3144 i++;
3145 while (i < track->markersnr) {
3146 marker = &track->markers[i];
3147
3148 if (marker->framenr != prev_fra + 1) {
3149 break;
3150 }
3151 if (marker->flag & MARKER_DISABLED) {
3152 break;
3153 }
3154
3155 prev_fra = marker->framenr;
3156 channel->total_frames++;
3157 len++;
3158 i++;
3159 }
3160
3161 channel->segments[2 * segment] = start_marker->framenr;
3162 channel->segments[2 * segment + 1] = start_marker->framenr + len;
3163
3164 channel->max_segment = max_ii(channel->max_segment, len);
3165 segment++;
3166 }
3167
3168 i++;
3169 }
3170}
3171
3172/* Create channels for tracks and calculate tracked segments for them. */
3174{
3175 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
3176 MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
3177 MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
3178
3179 bool sel_only = (dopesheet->flag & TRACKING_DOPE_SELECTED_ONLY) != 0;
3180 bool show_hidden = (dopesheet->flag & TRACKING_DOPE_SHOW_HIDDEN) != 0;
3181
3182 for (MovieTrackingTrack &track : tracking_object->tracks) {
3183 if (!show_hidden && (track.flag & TRACK_HIDDEN) != 0) {
3184 continue;
3185 }
3186
3187 if (sel_only && !TRACK_SELECTED(&track)) {
3188 continue;
3189 }
3190
3191 MovieTrackingDopesheetChannel *channel = MEM_new<MovieTrackingDopesheetChannel>(
3192 "tracking dopesheet channel");
3193 channel->track = &track;
3194
3195 if (reconstruction->flag & TRACKING_RECONSTRUCTED) {
3196 SNPRINTF_UTF8(channel->name, "%s (%.4f)", track.name, track.error);
3197 }
3198 else {
3199 STRNCPY_UTF8(channel->name, track.name);
3200 }
3201
3203
3204 BLI_addtail(&dopesheet->channels, channel);
3205 dopesheet->tot_channel++;
3206 }
3207}
3208
3209/* Sot dopesheet channels using given method (name, average error, total coverage,
3210 * longest tracked segment) and could also inverse the list if it's enabled.
3211 */
3213 TrackingDopesheetSort sort_method,
3214 bool inverse)
3215{
3216 MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
3217
3218 if (inverse) {
3219 if (sort_method == TRACKING_DOPE_SORT_NAME) {
3221 }
3222 else if (sort_method == TRACKING_DOPE_SORT_LONGEST) {
3224 }
3225 else if (sort_method == TRACKING_DOPE_SORT_TOTAL) {
3227 }
3228 else if (sort_method == TRACKING_DOPE_SORT_AVERAGE_ERROR) {
3230 }
3231 else if (sort_method == TRACKING_DOPE_SORT_START) {
3233 }
3234 else if (sort_method == TRACKING_DOPE_SORT_END) {
3236 }
3237 }
3238 else {
3239 if (sort_method == TRACKING_DOPE_SORT_NAME) {
3241 }
3242 else if (sort_method == TRACKING_DOPE_SORT_LONGEST) {
3244 }
3245 else if (sort_method == TRACKING_DOPE_SORT_TOTAL) {
3247 }
3248 else if (sort_method == TRACKING_DOPE_SORT_AVERAGE_ERROR) {
3250 }
3251 else if (sort_method == TRACKING_DOPE_SORT_START) {
3253 }
3254 else if (sort_method == TRACKING_DOPE_SORT_END) {
3256 }
3257 }
3258}
3259
3261{
3262 /* Values are actually arbitrary here, probably need to be tweaked. */
3263 if (count < 8) {
3264 return TRACKING_COVERAGE_BAD;
3265 }
3266 if (count < 16) {
3268 }
3269 return TRACKING_COVERAGE_OK;
3270}
3271
3272/* Calculate coverage of frames with tracks, this information
3273 * is used to highlight dopesheet background depending on how
3274 * many tracks exists on the frame.
3275 */
3277{
3278 MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
3279 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
3280 int frames, start_frame = INT_MAX, end_frame = INT_MIN;
3281 int *per_frame_counter;
3282 TrackingCoverage prev_coverage;
3283 int last_segment_frame;
3284
3285 /* find frame boundaries */
3286 for (MovieTrackingTrack &track : tracking_object->tracks) {
3287 start_frame = min_ii(start_frame, track.markers[0].framenr);
3288 end_frame = max_ii(end_frame, track.markers[track.markersnr - 1].framenr);
3289 }
3290
3291 if (start_frame > end_frame) {
3292 /* There are no markers at all, nothing to calculate coverage from. */
3293 return;
3294 }
3295
3296 frames = end_frame - start_frame + 1;
3297
3298 /* this is a per-frame counter of markers (how many markers belongs to the same frame) */
3299 per_frame_counter = MEM_new_array_zeroed<int>(frames, "per frame track counter");
3300
3301 /* find per-frame markers count */
3302 for (MovieTrackingTrack &track : tracking_object->tracks) {
3303 for (int i = 0; i < track.markersnr; i++) {
3304 MovieTrackingMarker *marker = &track.markers[i];
3305
3306 /* TODO: perhaps we need to add check for non-single-frame track here */
3307 if ((marker->flag & MARKER_DISABLED) == 0) {
3308 per_frame_counter[marker->framenr - start_frame]++;
3309 }
3310 }
3311 }
3312
3313 /* convert markers count to coverage and detect segments with the same coverage */
3314 prev_coverage = coverage_from_count(per_frame_counter[0]);
3315 last_segment_frame = start_frame;
3316
3317 /* means only disabled tracks in the beginning, could be ignored */
3318 if (!per_frame_counter[0]) {
3319 prev_coverage = TRACKING_COVERAGE_OK;
3320 }
3321
3322 for (int i = 1; i < frames; i++) {
3323 TrackingCoverage coverage = coverage_from_count(per_frame_counter[i]);
3324
3325 /* means only disabled tracks in the end, could be ignored */
3326 if (i == frames - 1 && !per_frame_counter[i]) {
3327 coverage = TRACKING_COVERAGE_OK;
3328 }
3329
3330 if (coverage != prev_coverage || i == frames - 1) {
3331 MovieTrackingDopesheetCoverageSegment *coverage_segment;
3332 int end_segment_frame = i - 1 + start_frame;
3333
3334 if (end_segment_frame == last_segment_frame) {
3335 end_segment_frame++;
3336 }
3337
3338 coverage_segment = MEM_new<MovieTrackingDopesheetCoverageSegment>(
3339 "tracking coverage segment");
3340 coverage_segment->coverage = prev_coverage;
3341 coverage_segment->start_frame = last_segment_frame;
3342 coverage_segment->end_frame = end_segment_frame;
3343
3344 BLI_addtail(&dopesheet->coverage_segments, coverage_segment);
3345
3346 last_segment_frame = end_segment_frame;
3347 }
3348
3349 prev_coverage = coverage;
3350 }
3351
3352 MEM_delete(per_frame_counter);
3353}
3354
3356{
3357 MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
3358
3359 dopesheet->ok = false;
3360}
3361
3363{
3364 MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
3365
3367 bool inverse = (dopesheet->flag & TRACKING_DOPE_SORT_INVERSE) != 0;
3368
3369 if (dopesheet->ok) {
3370 return;
3371 }
3372
3373 tracking_dopesheet_free(dopesheet);
3374
3375 /* channels */
3377 tracking_dopesheet_channels_sort(tracking, sort_method, inverse);
3378
3379 /* frame coverage */
3381
3382 dopesheet->ok = true;
3383}
3384
3386 const MovieTrackingTrack *track)
3387{
3388 for (MovieTrackingObject &tracking_object : tracking->objects) {
3389 if (BLI_findindex(&tracking_object.tracks, track) != -1) {
3390 return &tracking_object;
3391 }
3392 }
3393 return nullptr;
3394}
3395
3397 const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track)
3398{
3399 for (MovieTrackingObject &tracking_object : tracking->objects) {
3400 if (BLI_findindex(&tracking_object.plane_tracks, plane_track) != -1) {
3401 return &tracking_object;
3402 }
3403 }
3404 return nullptr;
3405}
3406
3408 const MovieTrackingTrack *track,
3409 char *rna_path,
3410 size_t rna_path_maxncpy)
3411{
3412 MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_track(tracking, track);
3413 char track_name_esc[MAX_NAME * 2];
3414 BLI_str_escape(track_name_esc, track->name, sizeof(track_name_esc));
3415 if (tracking_object == nullptr) {
3416 BLI_snprintf_utf8(rna_path, rna_path_maxncpy, "tracking.tracks[\"%s\"]", track_name_esc);
3417 }
3418 else {
3419 char object_name_esc[MAX_NAME * 2];
3420 BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc));
3422 rna_path_maxncpy,
3423 "tracking.objects[\"%s\"].tracks[\"%s\"]",
3424 object_name_esc,
3425 track_name_esc);
3426 }
3427}
3428
3430 const MovieTrackingTrack *track,
3431 char *rna_path,
3432 size_t rna_path_maxncpy)
3433{
3434 MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_track(tracking, track);
3435 if (tracking_object == nullptr) {
3436 BLI_strncpy_utf8(rna_path, "tracking.tracks", rna_path_maxncpy);
3437 }
3438 else {
3439 char object_name_esc[MAX_NAME * 2];
3440 BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc));
3441 BLI_snprintf_utf8(rna_path, rna_path_maxncpy, "tracking.objects[\"%s\"]", object_name_esc);
3442 }
3443}
3444
3446 const MovieTrackingPlaneTrack *plane_track,
3447 char *rna_path,
3448 size_t rna_path_maxncpy)
3449{
3451 plane_track);
3452 char track_name_esc[MAX_NAME * 2];
3453 BLI_str_escape(track_name_esc, plane_track->name, sizeof(track_name_esc));
3454 if (tracking_object == nullptr) {
3455 BLI_snprintf_utf8(rna_path, rna_path_maxncpy, "tracking.plane_tracks[\"%s\"]", track_name_esc);
3456 }
3457 else {
3458 char object_name_esc[MAX_NAME * 2];
3459 BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc));
3461 rna_path_maxncpy,
3462 "tracking.objects[\"%s\"].plane_tracks[\"%s\"]",
3463 object_name_esc,
3464 track_name_esc);
3465 }
3466}
3467
3469 const MovieTrackingPlaneTrack *plane_track,
3470 char *rna_path,
3471 size_t rna_path_maxncpy)
3472{
3474 plane_track);
3475 if (tracking_object == nullptr) {
3476 BLI_strncpy_utf8(rna_path, "tracking.plane_tracks", rna_path_maxncpy);
3477 }
3478 else {
3479 char object_name_esc[MAX_NAME * 2];
3480 BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc));
3482 rna_path, rna_path_maxncpy, "tracking.objects[\"%s\"].plane_tracks", object_name_esc);
3483 }
3484}
3485
3486} // namespace blender
General operations, lookup, etc. for blender objects.
#define TRACK_SELECTED(track)
#define SNPRINTF_UTF8(dst, format,...)
#define STRNCPY_UTF8(dst, src)
#define CTX_DATA_(context, msgid)
#define BLT_I18NCONTEXT_ID_MOVIECLIP
#define DATA_(msgid)
#define MAX_NAME
Definition DNA_defs.h:63
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define INIT_MINMAX2(min, max)
#define BLI_assert_unreachable()
#define BLI_INLINE
#define ELEM(...)
#define BLI_assert_msg(a, msg)
#define STREQ(a, b)
#define MEM_realloc_uninitialized(vmemh, len)
btScalar max
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
IndexRange index_range() const
Definition BLI_array.hh:371
#define offsetof(t, d)
#define INT_MAX
#define layer
MatBase< C, R > inverse(MatBase< C, R >) RET
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
float3x3 scale(float3x3 mat, float2 scale)
void libmv_cameraIntrinsicsUndistortFloat(const libmv_CameraIntrinsics *libmv_intrinsics, const float *source_image, int width, int height, float overscan, int channels, float *destination_image)
void libmv_cameraIntrinsicsDestroy(libmv_CameraIntrinsics *libmv_intrinsics)
libmv_CameraIntrinsics * libmv_cameraIntrinsicsCopy(const libmv_CameraIntrinsics *libmv_intrinsics)
void libmv_cameraIntrinsicsUndistortByte(const libmv_CameraIntrinsics *libmv_intrinsics, const unsigned char *source_image, int width, int height, float overscan, int channels, unsigned char *destination_image)
void libmv_cameraIntrinsicsDistortByte(const struct libmv_CameraIntrinsics *libmv_intrinsics, const unsigned char *source_image, int width, int height, float overscan, int channels, unsigned char *destination_image)
void libmv_cameraIntrinsicsApply(const struct libmv_CameraIntrinsics *libmv_intrinsics, double x, double y, double *x1, double *y1)
void libmv_cameraIntrinsicsDistortFloat(const libmv_CameraIntrinsics *libmv_intrinsics, float *source_image, int width, int height, float overscan, int channels, float *destination_image)
void libmv_cameraIntrinsicsUpdate(const libmv_CameraIntrinsicsOptions *libmv_camera_intrinsics_options, libmv_CameraIntrinsics *libmv_intrinsics)
void libmv_cameraIntrinsicsInvert(const struct libmv_CameraIntrinsics *libmv_intrinsics, double x, double y, double *x1, double *y1)
libmv_CameraIntrinsics * libmv_cameraIntrinsicsNew(const libmv_CameraIntrinsicsOptions *libmv_camera_intrinsics_options)
struct libmv_CameraIntrinsics libmv_CameraIntrinsics
void libmv_samplePlanarPatchFloat(const float *image, int width, int height, int channels, const double *xs, const double *ys, int num_samples_x, int num_samples_y, const float *mask, float *patch, double *warped_position_x, double *warped_position_y)
void libmv_samplePlanarPatchByte(const unsigned char *image, int width, int height, int channels, const double *xs, const double *ys, int num_samples_x, int num_samples_y, const float *mask, unsigned char *patch, double *warped_position_x, double *warped_position_y)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
BMesh Iterators.
MINLINE float min_ff(float a, float b)
void BKE_tracking_plane_tracks_replace_point_track(MovieTracking *tracking, MovieTrackingTrack *old_track, MovieTrackingTrack *new_track)
Definition tracking.cc:1708
float * tracking_track_get_mask_for_region(const int frame_width, const int frame_height, const float region_min[2], const float region_max[2], const MovieTrackingTrack *track)
Definition tracking.cc:1141
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BKE_tracking_track_unique_name(ListBaseT< MovieTrackingTrack > *tracksbase, MovieTrackingTrack *track)
Definition tracking.cc:587
int char char int BLI_strcasecmp(const char *s1, const char *s2) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
size_t size_t size_t BLI_snprintf_utf8(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
void BKE_tracking_track_path_clear(MovieTrackingTrack *track, int ref_frame, eTrackClearAction action)
Definition tracking.cc:782
MovieTrackingMarker * BKE_tracking_marker_get_exact(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1396
MovieDistortion * BKE_tracking_distortion_copy(MovieDistortion *distortion)
Definition tracking.cc:2313
unsigned __int64 uint64_t
Definition BKE_text.h:91
static void tracking_dopesheet_channels_calc(MovieTracking *tracking)
Definition tracking.cc:3173
static int channels_average_error_sort(const void *a, const void *b)
Definition tracking.cc:2925
void BKE_tracking_tracks_first_last_frame_minmax(MovieTrackingTrack **tracks, int num_tracks, int *r_first_frame, int *r_last_frame)
Definition tracking.cc:615
bool BKE_tracking_camera_distortion_equal(const MovieTrackingCamera *a, const MovieTrackingCamera *b)
Definition tracking.cc:2203
static void tracking_plane_tracks_copy(TrackingCopyContext *ctx, ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_list_dst, const ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_list_src, const int flag)
Definition tracking.cc:216
void IMB_free_byte_pixels(ImBuf *ibuf)
@ TRACK_ALGORITHM_FLAG_USE_BRUTE
void BKE_tracking_get_projection_matrix(MovieTracking *tracking, MovieTrackingObject *tracking_object, int framenr, int winx, int winy, float mat[4][4])
Definition tracking.cc:388
void BKE_tracking_marker_clamp_search_size(MovieTrackingMarker *marker)
Definition tracking.cc:1332
void BKE_tracking_copy(MovieTracking *tracking_dst, const MovieTracking *tracking_src, int flag)
Definition tracking.cc:311
void BKE_tracking_camera_principal_point_pixel_get(MovieClip *clip, float r_principal_point_pixel[2])
Definition tracking.cc:2177
void BKE_tracking_camera_shift_get(MovieTracking *tracking, int winx, int winy, float *shiftx, float *shifty)
Definition tracking.cc:2107
void BKE_movieclip_get_size(MovieClip *clip, const MovieClipUser *user, int *r_width, int *r_height)
static void tracking_objects_copy(ListBaseT< MovieTrackingObject > *tracking_objects_dst, const ListBaseT< MovieTrackingObject > *tracking_objects_src, const int flag)
Definition tracking.cc:298
void BKE_tracking_distortion_distort_v2(MovieDistortion *distortion, const float co[2], float r_co[2])
Definition tracking.cc:2384
static void path_clear_all(MovieTrackingTrack *track, const int ref_frame)
Definition tracking.cc:765
void BKE_tracking_marker_get_subframe_position(MovieTrackingTrack *track, float framenr, float pos[2])
Definition tracking.cc:1512
static int channels_start_sort(const void *a, const void *b)
Definition tracking.cc:2974
void BKE_tracking_distortion_undistort_v2(MovieDistortion *distortion, const float co[2], float r_co[2])
Definition tracking.cc:2402
void tracking_get_search_origin_frame_pixel(int frame_width, int frame_height, const MovieTrackingMarker *marker, float frame_pixel[2])
MovieTrackingObject * BKE_tracking_object_add(MovieTracking *tracking, const char *name)
Definition tracking.cc:1902
void BKE_tracking_plane_track_replace_point_track(MovieTrackingPlaneTrack *plane_track, MovieTrackingTrack *old_track, MovieTrackingTrack *new_track)
Definition tracking.cc:1696
void id_us_plus(ID *id)
Definition lib_id.cc:433
void tracking_marker_insert_disabled(MovieTrackingTrack *track, const MovieTrackingMarker *ref_marker, bool before, bool overwrite)
bool BKE_tracking_plane_track_has_point_track(MovieTrackingPlaneTrack *plane_track, MovieTrackingTrack *track)
Definition tracking.cc:1647
void BKE_tracking_plane_tracks_remove_point_track(MovieTracking *tracking, MovieTrackingTrack *track)
Definition tracking.cc:1681
MINLINE void mul_v2_fl(float r[2], float f)
MINLINE void negate_v2_v2(float r[2], const float a[2])
MINLINE void copy_v2_v2(float r[2], const float a[2])
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
Definition tracking.cc:1982
void BKE_tracking_get_rna_path_prefix_for_plane_track(const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track, char *rna_path, size_t rna_path_maxncpy)
Definition tracking.cc:3468
static void tracking_dopesheet_free(MovieTrackingDopesheet *dopesheet)
Definition tracking.cc:135
static int channels_total_track_inverse_sort(const void *a, const void *b)
Definition tracking.cc:3011
@ TRACKING_DISTORTION_MODEL_DIVISION
@ TRACKING_DISTORTION_MODEL_POLYNOMIAL
@ TRACKING_DISTORTION_MODEL_NUKE
@ TRACKING_DISTORTION_MODEL_BROWN
ImBuf * BKE_tracking_undistort_frame(MovieTracking *tracking, ImBuf *ibuf, int calibration_width, int calibration_height, float overscan)
Definition tracking.cc:2471
BLI_INLINE int plane_marker_size_len_in_pixels(const float a[2], const float b[2], const int frame_width, const int frame_height)
Definition tracking.cc:2728
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
ImBuf * BKE_tracking_get_search_imbuf(const ImBuf *ibuf, const MovieTrackingTrack *track, const MovieTrackingMarker *marker, bool anchored, bool disable_channels)
Definition tracking.cc:2665
static int reconstructed_camera_index_get(MovieTrackingReconstruction *reconstruction, int framenr, bool nearest)
Definition tracking.cc:2026
char * BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
MovieTrackingTrack * BKE_tracking_track_add(MovieTracking *tracking, ListBaseT< MovieTrackingTrack > *tracksbase, float x, float y, int framenr, int width, int height)
Definition tracking.cc:527
static int channels_start_inverse_sort(const void *a, const void *b)
Definition tracking.cc:3043
void blend_m4_m4m4(float out[4][4], const float dst[4][4], const float src[4][4], float srcweight)
static void tracking_dopesheet_calc_coverage(MovieTracking *tracking)
Definition tracking.cc:3276
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
static void tracking_average_markers(MovieTrackingTrack *dst_track, MovieTrackingTrack **src_tracks, const int num_src_tracks)
Definition tracking.cc:950
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
void BKE_tracking_tracks_join(MovieTracking *tracking, MovieTrackingTrack *dst_track, MovieTrackingTrack *src_track)
Definition tracking.cc:799
MINLINE int max_ii(int a, int b)
@ CAMERA_SENSOR_FIT_HOR
ImBuf * BKE_tracking_get_plane_imbuf(const ImBuf *frame_ibuf, const MovieTrackingPlaneMarker *plane_marker)
Definition tracking.cc:2739
static void tracking_objects_free(ListBaseT< MovieTrackingObject > *objects)
Definition tracking.cc:121
void BKE_tracking_plane_tracks_deselect_all(ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base)
Definition tracking.cc:1640
static void tracking_copy_context_delete(TrackingCopyContext *ctx)
Definition tracking.cc:185
static void path_clear_remained(MovieTrackingTrack *track, const int ref_frame)
Definition tracking.cc:727
void perspective_m4(float mat[4][4], float left, float right, float bottom, float top, float nearClip, float farClip)
ImBuf * BKE_tracking_distort_frame(MovieTracking *tracking, ImBuf *ibuf, int calibration_width, int calibration_height, float overscan)
Definition tracking.cc:2493
@ LIB_ID_CREATE_NO_USER_REFCOUNT
ImBuf * IMB_dupImBuf(const ImBuf *ibuf1)
MovieTrackingMarker * BKE_tracking_marker_insert(MovieTrackingTrack *track, MovieTrackingMarker *marker)
Definition tracking.cc:1240
static void multiply_marker(MovieTrackingMarker *marker, const float multiplier)
Definition tracking.cc:938
static void tracking_plane_tracks_free(ListBaseT< MovieTrackingPlaneTrack > *plane_tracks)
Definition tracking.cc:87
MINLINE bool is_finite_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
bool BKE_tracking_track_has_enabled_marker_at_frame(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:720
void BKE_tracking_dopesheet_tag_update(MovieTracking *tracking)
Definition tracking.cc:3355
static int channels_alpha_sort(const void *a, const void *b)
Definition tracking.cc:2883
static void tracking_average_tracks(MovieTrackingTrack *dst_track, MovieTrackingTrack **src_tracks, const int num_src_tracks)
Definition tracking.cc:1007
void BKE_tracking_plane_marker_get_subframe_corners(MovieTrackingPlaneTrack *plane_track, float framenr, float corners[4][2])
Definition tracking.cc:1871
void tracking_principal_point_normalized_to_pixel(const float principal_point_normalized[2], int frame_width, int frame_height, float r_principal_point_pixel[2])
VecBase< float, 4 > float4
static TrackingCoverage coverage_from_count(int count)
Definition tracking.cc:3260
MovieTrackingObject * BKE_tracking_find_object_for_plane_track(const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track)
Definition tracking.cc:3396
static int channels_alpha_inverse_sort(const void *a, const void *b)
Definition tracking.cc:3002
void BKE_tracking_get_rna_path_for_plane_track(const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track, char *rna_path, size_t rna_path_maxncpy)
Definition tracking.cc:3445
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
void BKE_tracking_marker_pattern_minmax(const MovieTrackingMarker *marker, float min[2], float max[2])
Definition tracking.cc:1500
bool BKE_tracking_track_has_marker_at_frame(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:715
void BKE_tracking_get_rna_path_for_track(const MovieTracking *tracking, const MovieTrackingTrack *track, char *rna_path, size_t rna_path_maxncpy)
Definition tracking.cc:3407
void BLI_uniquename(const ListBase *list, void *vlink, const char *defname, char delim, int name_offset, size_t name_maxncpy) ATTR_NONNULL(1
static struct blender::@154371266026044376204133125047312012320164166140 tracking_clipboard
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
void BKE_tracking_marker_clamp_pattern_position(MovieTrackingMarker *marker)
Definition tracking.cc:1313
bool BKE_tracking_clipboard_has_tracks()
Definition tracking.cc:477
MovieTrackingTrack * BKE_tracking_track_get_for_selection_index(MovieTracking *tracking, int selection_index, ListBaseT< MovieTrackingTrack > **r_tracksbase)
Definition tracking.cc:1031
@ TRACKING_COVERAGE_ACCEPTABLE
void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *tracking_object)
Definition tracking.cc:1961
static bGPDlayer * track_mask_gpencil_layer_get(const MovieTrackingTrack *track)
Definition tracking.cc:1054
void tracking_cameraIntrinscisOptionsFromTracking(MovieTracking *tracking, int calibration_width, int calibration_height, libmv_CameraIntrinsicsOptions *camera_intrinsics_options)
static int channels_longest_segment_sort(const void *a, const void *b)
Definition tracking.cc:2911
void IMB_freeImBuf(ImBuf *ibuf)
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
static void track_mask_gpencil_layer_rasterize(const int frame_width, const int frame_height, const float region_min[2], const bGPDlayer *layer, float *mask, const int mask_width, const int mask_height)
Definition tracking.cc:1105
static const MovieTrackingMarker * get_usable_marker_for_interpolation(MovieTrackingTrack *track, const MovieTrackingMarker *anchor_marker, const int direction)
Definition tracking.cc:1424
bool BKE_tracking_marker_get_interpolated(MovieTrackingTrack *track, int framenr, MovieTrackingMarker *r_marker)
Definition tracking.cc:1442
void BKE_tracking_disable_channels(ImBuf *ibuf, bool disable_red, bool disable_green, bool disable_blue, bool grayscale)
Definition tracking.cc:2820
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
@ TRACKING_DOPE_SORT_AVERAGE_ERROR
MINLINE void add_v2_v2(float r[2], const float a[2])
MovieTrackingPlaneTrack * BKE_tracking_object_find_plane_track_with_name(MovieTrackingObject *tracking_object, const char *name)
Definition tracking.cc:2010
unsigned char uchar
Definition BKE_text.h:58
void BKE_tracking_undistort_v2(MovieTracking *tracking, int image_width, int image_height, const float co[2], float r_co[2])
Definition tracking.cc:2448
void minmax_v2v2_v2(float min[2], float max[2], const float vec[2])
MovieTrackingMarker * BKE_tracking_marker_ensure(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1407
BMesh const char void * data
int BKE_tracking_count_selected_tracks_in_list(const ListBaseT< MovieTrackingTrack > *tracks_list)
Definition tracking.cc:631
void BLI_bitmap_draw_2d_poly_v2i_n(int xmin, int ymin, int xmax, int ymax, Span< int2 > verts, void(*callback)(int x, int x_end, int y, void *), void *user_data)
MovieTrackingTrack * BKE_tracking_object_find_track_with_name(MovieTrackingObject *tracking_object, const char *name)
Definition tracking.cc:1998
void BKE_tracking_clipboard_free()
Definition tracking.cc:445
void BKE_tracking_clipboard_paste_tracks(MovieTracking *tracking, MovieTrackingObject *tracking_object)
Definition tracking.cc:482
static void tracking_stabilization_copy(MovieTrackingStabilization *stabilization_dst, const MovieTrackingStabilization *stabilization_src, const int)
Definition tracking.cc:261
MovieTrackingTrack ** BKE_tracking_selected_tracks_in_active_object(MovieTracking *tracking, int *r_num_tracks)
Definition tracking.cc:648
static TrackingCopyContext tracking_copy_context_new()
Definition tracking.cc:176
MovieTrackingTrack * BKE_tracking_track_add_empty(MovieTracking *tracking, ListBaseT< MovieTrackingTrack > *tracks_list)
Definition tracking.cc:502
static int channels_total_track_sort(const void *a, const void *b)
Definition tracking.cc:2897
void BKE_tracking_camera_get_reconstructed_interpolate(MovieTracking *tracking, MovieTrackingObject *tracking_object, float framenr, float mat[4][4])
Definition tracking.cc:2151
char char size_t BLI_str_escape(char *__restrict dst, StringRef src, size_t dst_maxncpy) ATTR_NONNULL(1)
MovieTrackingObject * BKE_tracking_object_get_camera(const MovieTracking *tracking)
Definition tracking.cc:1987
static void tracking_dopesheet_channels_sort(MovieTracking *tracking, TrackingDopesheetSort sort_method, bool inverse)
Definition tracking.cc:3212
void BKE_tracking_track_first_last_frame_get(const MovieTrackingTrack *track, int *r_first_frame, int *r_last_frame)
Definition tracking.cc:605
void BKE_object_where_is_calc_mat4(const Object *ob, float r_obmat[4][4])
Definition object.cc:3560
static void accumulate_marker(MovieTrackingMarker *dst_marker, const MovieTrackingMarker *src_marker)
Definition tracking.cc:913
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
void BKE_tracking_settings_init(MovieTracking *tracking)
Definition tracking.cc:331
ImBuf * BKE_tracking_distortion_exec(MovieDistortion *distortion, MovieTracking *tracking, ImBuf *ibuf, int width, int height, float overscan, bool undistort)
Definition tracking.cc:2324
struct MovieReconstructedCamera * BKE_tracking_camera_get_reconstructed(MovieTracking *tracking, MovieTrackingObject *tracking_object, int framenr)
Definition tracking.cc:2138
float * BKE_tracking_track_get_mask(int frame_width, int frame_height, const MovieTrackingTrack *track, const MovieTrackingMarker *marker)
Definition tracking.cc:1159
void unit_m4(float m[4][4])
void BKE_tracking_clipboard_copy_tracks(MovieTracking *tracking, MovieTrackingObject *tracking_object)
Definition tracking.cc:461
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_ensure(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1854
static void tracking_object_copy(MovieTrackingObject *tracking_object_dst, const MovieTrackingObject *tracking_object_src, const int flag)
Definition tracking.cc:269
static void tracking_reconstruction_free(MovieTrackingReconstruction *reconstruction)
Definition tracking.cc:101
static int channels_end_sort(const void *a, const void *b)
Definition tracking.cc:2988
void BKE_tracking_tracks_average(MovieTrackingTrack *dst_track, MovieTrackingTrack **src_tracks, int num_src_tracks)
Definition tracking.cc:1019
void BKE_tracking_get_rna_path_prefix_for_track(const MovieTracking *tracking, const MovieTrackingTrack *track, char *rna_path, size_t rna_path_maxncpy)
Definition tracking.cc:3429
void BKE_tracking_marker_clamp_search_position(MovieTrackingMarker *marker)
Definition tracking.cc:1343
MINLINE bool equals_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
@ TRACK_AREA_NONE
@ TRACK_AREA_SEARCH
@ TRACK_AREA_POINT
int BKE_tracking_count_selected_tracks_in_active_object(MovieTracking *tracking)
Definition tracking.cc:642
void BKE_tracking_tracks_deselect_all(ListBaseT< MovieTrackingTrack > *tracksbase)
Definition tracking.cc:1227
void void BLI_listbase_sort(ListBase *listbase, int(*cmp)(const void *, const void *)) ATTR_NONNULL(1
Definition listbase.cc:319
ImBuf * IMB_allocImBuf(unsigned int x, unsigned int y, ImBufFlags flags)
void BKE_tracking_marker_delete(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1286
void BKE_tracking_track_free(MovieTrackingTrack *track)
Definition tracking.cc:598
void BKE_tracking_distortion_update(MovieDistortion *distortion, MovieTracking *tracking, int calibration_width, int calibration_height)
Definition tracking.cc:2292
MovieTrackingTrack * BKE_tracking_track_duplicate(MovieTrackingTrack *track)
Definition tracking.cc:567
void BKE_tracking_free(MovieTracking *tracking)
Definition tracking.cc:159
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
MovieDistortion * BKE_tracking_distortion_new(MovieTracking *tracking, int calibration_width, int calibration_height)
Definition tracking.cc:2268
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get_exact(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1842
void BKE_tracking_plane_track_free(MovieTrackingPlaneTrack *plane_track)
Definition tracking.cc:1631
void interp_v2_v2v2(float r[2], const float a[2], const float b[2], float t)
@ TRACK_CLEAR_REMAINED
MINLINE float max_ff(float a, float b)
void BKE_tracking_camera_to_blender(MovieTracking *tracking, Scene *scene, Camera *camera, int width, int height)
Definition tracking.cc:2120
void BKE_tracking_distortion_free(MovieDistortion *distortion)
Definition tracking.cc:2414
MINLINE float len_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
bool BKE_tracking_plane_track_remove_point_track(MovieTrackingPlaneTrack *plane_track, MovieTrackingTrack *track)
Definition tracking.cc:1658
static void disable_imbuf_channels(ImBuf *ibuf, const MovieTrackingTrack *track, const bool grayscale)
Definition tracking.cc:2519
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1796
void BKE_tracking_plane_marker_delete(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1765
MovieTrackingObject * BKE_tracking_find_object_for_track(const MovieTracking *tracking, const MovieTrackingTrack *track)
Definition tracking.cc:3385
MovieTrackingPlaneTrack * BKE_tracking_plane_track_add(MovieTracking *tracking, ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base, ListBaseT< MovieTrackingTrack > *tracks, int framenr)
Definition tracking.cc:1547
FCurve * id_data_find_fcurve(ID *id, void *data, StructRNA *type, const char *prop_name, int index, bool *r_driven)
static void tracking_dopesheet_channels_segments_calc(MovieTrackingDopesheetChannel *channel)
Definition tracking.cc:3072
uint64_t BKE_tracking_camera_distortion_hash(const MovieTrackingCamera *camera)
Definition tracking.cc:2234
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_insert(MovieTrackingPlaneTrack *plane_track, MovieTrackingPlaneMarker *plane_marker)
Definition tracking.cc:1724
@ TRACK_MOTION_MODEL_TRANSLATION
float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
MovieTrackingObject * BKE_tracking_object_get_named(MovieTracking *tracking, const char *name)
Definition tracking.cc:1971
void BKE_tracking_track_flag_set(MovieTrackingTrack *track, eTrackArea area, TrackingTrackFlag flag)
Definition tracking.cc:677
static void track_mask_set_pixel_cb(int x, int x_end, int y, void *user_data)
Definition tracking.cc:1095
void BKE_tracking_get_camera_object_matrix(const Object *camera_object, float mat[4][4])
Definition tracking.cc:372
void BKE_tracking_plane_track_unique_name(ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base, MovieTrackingPlaneTrack *plane_track)
Definition tracking.cc:1620
void BKE_tracking_track_deselect(MovieTrackingTrack *track, eTrackArea area)
Definition tracking.cc:1222
@ TRACKING_DOPE_SELECTED_ONLY
static void path_clear_up_to(MovieTrackingTrack *track, const int ref_frame)
Definition tracking.cc:744
void copy_m4_m4(float m1[4][4], const float m2[4][4])
static int compare_firstlast_putting_undefined_first(bool inverse, bool a_markerless, int a_value, bool b_markerless, int b_value)
Definition tracking.cc:2943
static void reconstructed_camera_scale_set(const MovieTrackingObject *tracking_object, float mat[4][4])
Definition tracking.cc:2096
VecBase< float, 3 > float3
void scale_m4_fl(float R[4][4], float scale)
float BKE_tracking_track_get_weight_for_marker(MovieClip *clip, MovieTrackingTrack *track, MovieTrackingMarker *marker)
Definition tracking.cc:1177
static int channels_end_inverse_sort(const void *a, const void *b)
Definition tracking.cc:3057
ImBuf * BKE_tracking_sample_pattern(int frame_width, int frame_height, const ImBuf *search_ib, const MovieTrackingTrack *track, const MovieTrackingMarker *marker, bool from_anchor, bool use_mask, int num_samples_x, int num_samples_y, float pos[2])
Definition tracking.cc:2530
void tracking_principal_point_pixel_to_normalized(const float principal_point_pixel[2], int frame_width, int frame_height, float r_principal_point_normalized[2])
MINLINE int min_ii(int a, int b)
MINLINE int clamp_i(int value, int min, int max)
ImBuf * BKE_tracking_get_pattern_imbuf(const ImBuf *ibuf, const MovieTrackingTrack *track, const MovieTrackingMarker *marker, bool anchored, bool disable_channels)
Definition tracking.cc:2627
static void tracking_reconstruction_copy(TrackingCopyContext *, MovieTrackingReconstruction *reconstruction_dst, const MovieTrackingReconstruction *reconstruction_src, const int)
Definition tracking.cc:248
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
Definition BLI_hash.hh:252
MINLINE void zero_v2(float r[2])
static void tracking_tracks_free(ListBaseT< MovieTrackingTrack > *tracks)
Definition tracking.cc:77
void BKE_tracking_camera_principal_point_pixel_set(MovieClip *clip, const float principal_point_pixel[2])
Definition tracking.cc:2190
static int channels_longest_segment_inverse_sort(const void *a, const void *b)
Definition tracking.cc:3020
void BKE_tracking_dopesheet_update(MovieTracking *tracking)
Definition tracking.cc:3362
void tracking_get_marker_coords_for_tracking(int frame_width, int frame_height, const MovieTrackingMarker *marker, double search_pixel_x[5], double search_pixel_y[5])
void BKE_tracking_distort_v2(MovieTracking *tracking, int image_width, int image_height, const float co[2], float r_co[2])
Definition tracking.cc:2421
static void tracking_tracks_copy(TrackingCopyContext *ctx, ListBaseT< MovieTrackingTrack > *tracks_dst, const ListBaseT< MovieTrackingTrack > *tracks_src, const int flag)
Definition tracking.cc:192
static void tracking_object_free(MovieTrackingObject *tracking_object)
Definition tracking.cc:113
void BKE_tracking_track_flag_clear(MovieTrackingTrack *track, eTrackArea area, TrackingTrackFlag flag)
Definition tracking.cc:696
static int channels_average_error_inverse_sort(const void *a, const void *b)
Definition tracking.cc:3029
void BKE_tracking_track_select(ListBaseT< MovieTrackingTrack > *tracksbase, MovieTrackingTrack *track, eTrackArea area, bool extend)
Definition tracking.cc:1195
bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *tracking_object)
Definition tracking.cc:1931
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void IMB_copy_rect(float *dst, const int2 &dst_size, const float *src, const int2 &src_size, int channels, const int2 &src_rect_pos, const int2 &dst_rect_pos, const int2 &rect_size)
Definition rectop.cc:414
float evaluate_fcurve(const FCurve *fcu, float evaltime)
MovieTrackingMarker * BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1363
#define ceilf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
#define min(a, b)
Definition sort.cc:38
const ColorSpace * colorspace
const ColorSpace * colorspace
ImBufFloatBuffer float_buffer
ImBufByteBuffer byte_buffer
const uint8_t * byte_data() const
uint8_t * byte_data_for_write()
Definition allocimbuf.cc:60
const float * float_data() const
float * float_data_for_write()
Definition allocimbuf.cc:79
struct MovieTracking tracking
libmv_CameraIntrinsics * intrinsics
Definition tracking.cc:61
TrackingDistortionModel distortion_model
struct MovieTrackingDopesheetChannel * next
ListBaseT< MovieTrackingDopesheetCoverageSegment > coverage_segments
ListBaseT< MovieTrackingDopesheetChannel > channels
MovieTrackingPlaneTrack * active_plane_track
MovieTrackingReconstruction reconstruction
ListBaseT< MovieTrackingTrack > tracks
ListBaseT< MovieTrackingPlaneTrack > plane_tracks
MovieTrackingTrack * active_track
MovieTrackingPlaneMarker * markers
struct MovieReconstructedCamera * cameras
TrackingMotionModel default_motion_model
TrackingRefineCameraFlag refine_camera_intrinsics
TrackingAlgorithmFlag default_algorithm_flag
TrackingStabilizationFilter filter
struct MovieTrackingTrack * next
struct MovieTrackingTrack * prev
MovieTrackingMarker * markers
TrackingAlgorithmFlag algorithm_flag
MovieTrackingStats * stats
MovieTrackingCamera camera
MovieTrackingStabilization stabilization
MovieTrackingSettings settings
ListBaseT< MovieTrackingObject > objects
MovieTrackingDopesheet dopesheet
struct RenderData r
Map< MovieTrackingTrack *, MovieTrackingTrack * > * old_to_new_track_map
Definition tracking.cc:172
Map< MovieTrackingPlaneTrack *, MovieTrackingPlaneTrack * > * old_to_new_plane_track_map
Definition tracking.cc:173
ListBaseT< MovieTrackingTrack > tracks
ListBaseT< bGPDstroke > strokes
ListBaseT< bGPDlayer > layers