Blender V5.3
tracking_ops.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 "MEM_guardedalloc.h"
10
11#include "DNA_screen_types.h"
12#include "DNA_space_types.h"
13
14#include "BLI_listbase.hh"
15#include "BLI_math_geom_c.hh"
16#include "BLI_math_vector_c.hh"
17#include "BLI_set.hh"
18#include "BLI_utildefines.hh"
19
20#include "BKE_context.hh"
21#include "BKE_image.hh"
22#include "BKE_movieclip.hh"
23#include "BKE_report.hh"
24#include "BKE_tracking.hh"
25
26#include "DEG_depsgraph.hh"
27
28#include "UI_interface_icons.hh"
29#include "UI_resources.hh"
30
31#include "WM_api.hh"
32#include "WM_types.hh"
33
34#include "ED_clip.hh"
35#include "ED_screen.hh"
36
37#include "RNA_access.hh"
38#include "RNA_define.hh"
39
40#include "BLT_translation.hh"
41
42#include "IMB_imbuf.hh"
43#include "IMB_imbuf_types.hh"
44
45#include "clip_intern.hh"
47
48namespace blender {
49
50/* -------------------------------------------------------------------- */
53
54static bool add_marker(const bContext *C, float x, float y)
55{
58 MovieTracking *tracking = &clip->tracking;
59 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
60 MovieTrackingTrack *track;
61 int width, height;
63
64 ED_space_clip_get_size(sc, &width, &height);
65
66 if (width == 0 || height == 0) {
67 return false;
68 }
69
70 track = BKE_tracking_track_add(tracking, &tracking_object->tracks, x, y, framenr, width, height);
71
72 BKE_tracking_track_select(&tracking_object->tracks, track, TRACK_AREA_ALL, false);
74
75 tracking_object->active_track = track;
76 tracking_object->active_plane_track = nullptr;
77
78 return true;
79}
80
82{
85 float pos[2];
86
87 ClipViewLockState lock_state;
88 ED_clip_view_lock_state_store(C, &lock_state);
89
90 RNA_float_get_array(op->ptr, "location", pos);
91
92 if (!add_marker(C, pos[0], pos[1])) {
93 return OPERATOR_CANCELLED;
94 }
95
97
99
100 return OPERATOR_FINISHED;
101}
102
104{
106 ARegion *region = CTX_wm_region(C);
107
108 if (!RNA_struct_property_is_set(op->ptr, "location")) {
109 /* If location is not set, use mouse position as default. */
110 float co[2];
111 ED_clip_mouse_pos(sc, region, event->mval, co);
112 RNA_float_set_array(op->ptr, "location", co);
113 }
114
115 return add_marker_exec(C, op);
116}
117
119{
120 /* identifiers */
121 ot->name = "Add Marker";
122 ot->idname = "CLIP_OT_add_marker";
123 ot->description = "Place new marker at specified location";
124
125 /* API callbacks. */
127 ot->exec = add_marker_exec;
129
130 /* flags */
132
133 /* properties */
135 "location",
136 2,
137 nullptr,
138 -FLT_MAX,
139 FLT_MAX,
140 "Location",
141 "Location of marker on frame",
142 -1.0f,
143 1.0f);
144}
145
147
148/* -------------------------------------------------------------------- */
151
153 wmOperator *op,
154 const wmEvent * /*event*/)
155{
156 WorkspaceStatus status(C);
157 status.item(IFACE_("Cancel"), ICON_EVENT_ESC);
158 status.item(IFACE_("Place Marker"), ICON_MOUSE_LMB);
159
160 /* Add modal handler for ESC. */
162
164}
165
167 wmOperator * /*op*/,
168 const wmEvent *event)
169{
170 switch (event->type) {
171 case MOUSEMOVE:
173
174 case LEFTMOUSE: {
177 ARegion *region = CTX_wm_region(C);
178 float pos[2];
179
180 ED_workspace_status_text(C, nullptr);
181
183 region,
184 event->xy[0] - region->winrct.xmin,
185 event->xy[1] - region->winrct.ymin,
186 &pos[0],
187 &pos[1]);
188
189 if (!add_marker(C, pos[0], pos[1])) {
190 return OPERATOR_CANCELLED;
191 }
192
194 return OPERATOR_FINISHED;
195 }
196
197 case EVT_ESCKEY:
198 ED_workspace_status_text(C, nullptr);
199 return OPERATOR_CANCELLED;
200 default: {
201 break;
202 }
203 }
204
206}
207
209{
210 /* identifiers */
211 ot->name = "Add Marker at Click";
212 ot->idname = "CLIP_OT_add_marker_at_click";
213 ot->description = "Place new marker at the desired (clicked) position";
214
215 /* API callbacks. */
219
220 /* flags */
222}
223
225
226/* -------------------------------------------------------------------- */
229
231{
235 bool changed = false;
236
237 /* Delete selected plane tracks. */
238 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks.items_mutable()) {
239 if (PLANE_TRACK_VIEW_SELECTED(&plane_track)) {
240 clip_delete_plane_track(C, clip, &plane_track);
241 changed = true;
242 }
243 }
244
245 /* Remove selected point tracks (they'll also be removed from planes which uses them). */
246 for (MovieTrackingTrack &track : tracking_object->tracks.items_mutable()) {
247 if (TRACK_VIEW_SELECTED(sc, &track)) {
248 clip_delete_track(C, clip, &track);
249 changed = true;
250 }
251 }
252
253 if (changed) {
255 }
256
257 return OPERATOR_FINISHED;
258}
259
261{
262 if (RNA_boolean_get(op->ptr, "confirm")) {
264 op,
265 IFACE_("Delete selected tracks?"),
266 nullptr,
267 IFACE_("Delete"),
269 false);
270 }
271 return delete_track_exec(C, op);
272}
273
275{
276 /* identifiers */
277 ot->name = "Delete Track";
278 ot->idname = "CLIP_OT_delete_track";
279 ot->description = "Delete selected tracks";
280
281 /* API callbacks. */
285
286 /* flags */
289}
290
292
293/* -------------------------------------------------------------------- */
296
298{
302 const int framenr = ED_space_clip_get_clip_frame_number(sc);
303 bool changed = false;
304
305 for (MovieTrackingTrack &track : tracking_object->tracks.items_mutable()) {
306 if (TRACK_VIEW_SELECTED(sc, &track)) {
307 MovieTrackingMarker *marker = BKE_tracking_marker_get_exact(&track, framenr);
308 if (marker != nullptr) {
309 clip_delete_marker(C, clip, &track, marker);
310 changed = true;
311 }
312 }
313 }
314
315 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks.items_mutable()) {
316 if (PLANE_TRACK_VIEW_SELECTED(&plane_track)) {
318 framenr);
319 if (plane_marker != nullptr) {
320 if (plane_track.markersnr == 1) {
321 BKE_tracking_plane_track_free(&plane_track);
322 BLI_freelinkN(&tracking_object->plane_tracks, &plane_track);
323 }
324 else {
325 BKE_tracking_plane_marker_delete(&plane_track, framenr);
326 }
327 changed = true;
328 }
329 }
330 }
331
332 if (!changed) {
333 return OPERATOR_CANCELLED;
334 }
335
336 return OPERATOR_FINISHED;
337}
338
340 wmOperator *op,
341 const wmEvent * /*event*/)
342{
343 if (RNA_boolean_get(op->ptr, "confirm")) {
345 op,
346 IFACE_("Delete marker for current frame from selected tracks?"),
347 nullptr,
348 IFACE_("Delete"),
350 false);
351 }
352 return delete_marker_exec(C, op);
353}
354
356{
357 /* identifiers */
358 ot->name = "Delete Marker";
359 ot->idname = "CLIP_OT_delete_marker";
360 ot->description = "Delete marker for current frame from selected tracks";
361
362 /* API callbacks. */
366
367 /* flags */
370}
371
373
374/* -------------------------------------------------------------------- */
377
386
388 short area;
392
393 int mval[2];
395 float *min, *max, *pos, (*corners)[2];
396
398
399 /* Data to restore on cancel. */
401 float old_corners[4][2];
403};
404
405static void slide_marker_tilt_slider_relative(const float pattern_corners[4][2], float r_slider[2])
406{
407 add_v2_v2v2(r_slider, pattern_corners[1], pattern_corners[2]);
408}
409
411 MovieTrackingTrack *track,
412 MovieTrackingMarker *marker,
413 const wmEvent *event,
414 eTrackArea area,
415 int corner,
416 eSlideAction action,
417 int width,
418 int height)
419{
421 int framenr = ED_space_clip_get_clip_frame_number(sc);
422
423 marker = BKE_tracking_marker_ensure(track, framenr);
424
425 data->area = area;
426 data->action = action;
427 data->track = track;
428 data->marker = marker;
429
430 if (area == TRACK_AREA_POINT) {
431 data->pos = marker->pos;
432 }
433 else if (area == TRACK_AREA_PAT) {
434 if (action == SLIDE_ACTION_POS) {
435 data->corners = marker->pattern_corners;
436 data->pos = marker->pattern_corners[corner];
437 }
438 else if (action == SLIDE_ACTION_TILT_SIZE) {
439 data->corners = marker->pattern_corners;
440 }
441 }
442 else if (area == TRACK_AREA_SEARCH) {
443 data->min = marker->search_min;
444 data->max = marker->search_max;
445 }
446
447 data->mval[0] = event->mval[0];
448 data->mval[1] = event->mval[1];
449
450 data->width = width;
451 data->height = height;
452
453 if (action == SLIDE_ACTION_SIZE) {
454 data->lock = true;
455 }
456
457 /* Backup marker's settings. */
458 memcpy(data->old_corners, marker->pattern_corners, sizeof(data->old_corners));
459 copy_v2_v2(data->old_search_min, marker->search_min);
460 copy_v2_v2(data->old_search_max, marker->search_max);
461 copy_v2_v2(data->old_pos, marker->pos);
462
463 return data;
464}
465
466static bool slide_check_corners(float (*corners)[2])
467{
468 float cross = 0.0f;
469 const float p[2] = {0.0f, 0.0f};
470
471 if (!isect_point_quad_v2(p, corners[0], corners[1], corners[2], corners[3])) {
472 return false;
473 }
474
475 for (int i = 0; i < 4; i++) {
476 float v1[2], v2[2];
477
478 int next = (i + 1) % 4;
479 int prev = (4 + i - 1) % 4;
480
481 sub_v2_v2v2(v1, corners[i], corners[prev]);
482 sub_v2_v2v2(v2, corners[next], corners[i]);
483
484 float cur_cross = cross_v2v2(v1, v2);
485
486 if (fabsf(cur_cross) > FLT_EPSILON) {
487 if (cross == 0.0f) {
488 cross = cur_cross;
489 }
490 else if (cross * cur_cross < 0.0f) {
491 return false;
492 }
493 }
494 }
495
496 return true;
497}
498
500 bContext *C, const float co[2], eTrackArea *r_area, eSlideAction *r_action, int *r_corner)
501{
502 SpaceClip *space_clip = CTX_wm_space_clip(C);
503
505 options.selected_only = true;
506 options.unlocked_only = true;
507 options.enabled_only = true;
508 const PointTrackPick track_pick = ed_tracking_pick_point_track(&options, C, co);
509
510 if (ed_tracking_point_track_pick_empty(&track_pick) ||
511 !ed_tracking_point_track_pick_can_slide(space_clip, &track_pick))
512 {
513 return nullptr;
514 }
515
516 const eTrackArea area = track_pick.area;
518 int corner = -1;
519
520 switch (area) {
521 case TRACK_AREA_NONE:
522 case TRACK_AREA_ALL:
523 BLI_assert_msg(0, "Expected single track area");
524 return nullptr;
525
526 case TRACK_AREA_POINT:
527 action = SLIDE_ACTION_POS;
528 break;
529
530 case TRACK_AREA_PAT:
532 action = SLIDE_ACTION_TILT_SIZE;
533 }
534 else if (track_pick.area_detail == TRACK_PICK_AREA_DETAIL_POSITION) {
535 action = SLIDE_ACTION_POS;
536 corner = track_pick.corner_index;
537 }
538 else {
539 BLI_assert_msg(0, "Unhandled pattern area");
540 return nullptr;
541 }
542 break;
543
545 if (track_pick.area_detail == TRACK_PICK_AREA_DETAIL_SIZE) {
546 action = SLIDE_ACTION_SIZE;
547 }
548 else if (track_pick.area_detail == TRACK_PICK_AREA_DETAIL_OFFSET) {
549 action = SLIDE_ACTION_OFFSET;
550 }
551 else {
552 BLI_assert_msg(0, "Unhandled search area");
553 return nullptr;
554 }
555 break;
556 }
557
558 if (r_area) {
559 *r_area = area;
560 }
561 if (r_action) {
562 *r_action = action;
563 }
564 if (r_corner) {
565 *r_corner = corner;
566 }
567
568 return track_pick.track;
569}
570
572{
573 return tracking_marker_check_slide(C, co, nullptr, nullptr, nullptr);
574}
575
577{
579 ARegion *region = CTX_wm_region(C);
580
581 MovieTrackingTrack *track;
582 int width, height;
583 float co[2];
584 SlideMarkerData *customdata = nullptr;
585 int framenr = ED_space_clip_get_clip_frame_number(sc);
586 eSlideAction action;
587 eTrackArea area;
588 int corner;
589
590 ED_space_clip_get_size(sc, &width, &height);
591
592 if (width == 0 || height == 0) {
593 return nullptr;
594 }
595
596 ED_clip_mouse_pos(sc, region, event->mval, co);
597
598 track = tracking_marker_check_slide(C, co, &area, &action, &corner);
599 if (track != nullptr) {
600 MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
601 customdata = create_slide_marker_data(
602 sc, track, marker, event, area, corner, action, width, height);
603 }
604
605 return customdata;
606}
607
609{
610 SlideMarkerData *slidedata = slide_marker_customdata(C, event);
611 if (slidedata != nullptr) {
614 MovieTracking *tracking = &clip->tracking;
615 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
616
617 tracking_object->active_track = slidedata->track;
618 tracking_object->active_plane_track = nullptr;
619
620 op->customdata = slidedata;
621
624
626
628 }
629
631}
632
634{
635 MovieTrackingMarker *marker = data->marker;
636
637 memcpy(marker->pattern_corners, data->old_corners, sizeof(marker->pattern_corners));
638 copy_v2_v2(marker->search_min, data->old_search_min);
639 copy_v2_v2(marker->search_max, data->old_search_max);
640 copy_v2_v2(marker->pos, data->old_pos);
641
642 if (data->old_markers != nullptr) {
643 for (int a = 0; a < data->track->markersnr; a++) {
644 copy_v2_v2(data->track->markers[a].pos, data->old_markers[a]);
645 }
646 }
647}
648
650{
651 if (data->area == TRACK_AREA_POINT) {
654 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
655 const int framenr = ED_space_clip_get_clip_frame_number(sc);
656
657 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
658 if ((plane_track.flag & PLANE_TRACK_AUTOKEY) == 0) {
659 if (BKE_tracking_plane_track_has_point_track(&plane_track, data->track)) {
661 }
662 }
663 }
664 }
665}
666
668{
669 if (data->old_markers != nullptr) {
670 MEM_delete(data->old_markers);
671 }
672 MEM_delete(data);
673}
674
676{
678
679 SlideMarkerData *data = static_cast<SlideMarkerData *>(op->customdata);
680 float dx, dy, mdelta[2];
681
682 switch (event->type) {
683 case EVT_LEFTCTRLKEY:
684 case EVT_RIGHTCTRLKEY:
685 case EVT_LEFTSHIFTKEY:
687 if (data->action == SLIDE_ACTION_SIZE) {
689 data->lock = event->val == KM_RELEASE;
690 }
691 }
692
694 data->accurate = event->val == KM_PRESS;
695 }
697 case MOUSEMOVE:
698 mdelta[0] = event->mval[0] - data->mval[0];
699 mdelta[1] = event->mval[1] - data->mval[1];
700
701 dx = mdelta[0] / data->width / sc->zoom;
702
703 if (data->lock) {
704 dy = -dx / data->height * data->width;
705 }
706 else {
707 dy = mdelta[1] / data->height / sc->zoom;
708 }
709
710 if (data->accurate) {
711 dx /= 5.0f;
712 dy /= 5.0f;
713 }
714
715 if (data->area == TRACK_AREA_POINT) {
716 data->pos[0] += dx;
717 data->pos[1] += dy;
718
720 DEG_id_tag_update(&sc->clip->id, 0);
721 }
722 else if (data->area == TRACK_AREA_PAT) {
723 if (data->action == SLIDE_ACTION_POS) {
724 float prev_pos[2];
725 copy_v2_v2(prev_pos, data->pos);
726
727 data->pos[0] += dx;
728 data->pos[1] += dy;
729
730 if (!slide_check_corners(data->corners)) {
731 copy_v2_v2(data->pos, prev_pos);
732 }
733
734 /* Allow pattern to be arbitrary size and resize search area if needed. */
736 }
737 else if (data->action == SLIDE_ACTION_TILT_SIZE) {
738 const float delta[2] = {dx, dy};
739
740 /* Slider position relative to the marker position using current state of pattern
741 * corners. */
742 float slider[2];
743 slide_marker_tilt_slider_relative(data->corners, slider);
744
745 /* Vector which connects marker position with the slider state at the current corners
746 * state.
747 * The coordinate is in the pixel space. */
748 float start_px[2];
749 copy_v2_v2(start_px, slider);
750 start_px[0] *= data->width;
751 start_px[1] *= data->height;
752
753 /* Vector which connects marker position with the slider state with the new mouse delta
754 * taken into account.
755 * The coordinate is in the pixel space. */
756 float end_px[2];
757 add_v2_v2v2(end_px, slider, delta);
758 end_px[0] *= data->width;
759 end_px[1] *= data->height;
760
761 float scale = 1.0f;
762 if (len_squared_v2(start_px) != 0.0f) {
763 scale = len_v2(end_px) / len_v2(start_px);
764
765 if (scale < 0.0f) {
766 scale = 0.0;
767 }
768 }
769
770 const float angle = -angle_signed_v2v2(start_px, end_px);
771
772 for (int a = 0; a < 4; a++) {
773 float vec[2];
774
775 mul_v2_fl(data->corners[a], scale);
776
777 copy_v2_v2(vec, data->corners[a]);
778 vec[0] *= data->width;
779 vec[1] *= data->height;
780
781 data->corners[a][0] = (vec[0] * cosf(angle) - vec[1] * sinf(angle)) / data->width;
782 data->corners[a][1] = (vec[1] * cosf(angle) + vec[0] * sinf(angle)) / data->height;
783 }
784
786 }
787 }
788 else if (data->area == TRACK_AREA_SEARCH) {
789 if (data->action == SLIDE_ACTION_SIZE) {
790 data->min[0] -= dx;
791 data->min[1] += dy;
792
793 data->max[0] += dx;
794 data->max[1] -= dy;
795
797 }
798 else if (data->action == SLIDE_ACTION_OFFSET) {
799 const float delta[2] = {dx, dy};
800 add_v2_v2(data->min, delta);
801 add_v2_v2(data->max, delta);
802
804 }
805 }
806
807 data->marker->flag &= ~MARKER_TRACKED;
808
809 copy_v2_v2_int(data->mval, event->mval);
810
812
813 break;
814
815 case LEFTMOUSE:
816 if (event->val == KM_RELEASE) {
819
821
822 return OPERATOR_FINISHED;
823 }
824
825 break;
826
827 case EVT_ESCKEY:
829
831
833
835
836 return OPERATOR_CANCELLED;
837 default: {
838 break;
839 }
840 }
841
843}
844
846{
847 /* identifiers */
848 ot->name = "Slide Marker";
849 ot->description = "Slide marker areas";
850 ot->idname = "CLIP_OT_slide_marker";
851
852 /* API callbacks. */
856
857 /* flags */
859
860 /* properties */
862 "offset",
863 2,
864 nullptr,
865 -FLT_MAX,
866 FLT_MAX,
867 "Offset",
868 "Offset in floating-point units, 1.0 is the width and height of the image",
869 -FLT_MAX,
870 FLT_MAX);
871}
872
874
875/* -------------------------------------------------------------------- */
878
880{
883 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
884 const eTrackClearAction action = eTrackClearAction(RNA_enum_get(op->ptr, "action"));
885 const bool clear_active = RNA_boolean_get(op->ptr, "clear_active");
886 const int framenr = ED_space_clip_get_clip_frame_number(sc);
887
888 if (clear_active) {
889 if (tracking_object->active_track != nullptr) {
890 BKE_tracking_track_path_clear(tracking_object->active_track, framenr, action);
891 }
892 }
893 else {
894 for (MovieTrackingTrack &track : tracking_object->tracks) {
895 if (TRACK_VIEW_SELECTED(sc, &track)) {
896 BKE_tracking_track_path_clear(&track, framenr, action);
897 }
898 }
899 }
900
903
904 return OPERATOR_FINISHED;
905}
906
908{
909 static const EnumPropertyItem clear_path_actions[] = {
910 {TRACK_CLEAR_UPTO, "UPTO", 0, "Clear Up To", "Clear path up to current frame"},
912 "REMAINED",
913 0,
914 "Clear Remained",
915 "Clear path at remaining frames (after current)"},
916 {TRACK_CLEAR_ALL, "ALL", 0, "Clear All", "Clear the whole path"},
917 {0, nullptr, 0, nullptr, nullptr},
918 };
919
920 /* identifiers */
921 ot->name = "Clear Track Path";
922 ot->description = "Clear tracks after/before current position or clear the whole track";
923 ot->idname = "CLIP_OT_clear_track_path";
924
925 /* API callbacks. */
928
929 /* flags */
931
932 /* properties */
933 RNA_def_enum(ot->srna,
934 "action",
935 clear_path_actions,
937 "Action",
938 "Clear action to execute");
940 "clear_active",
941 false,
942 "Clear Active",
943 "Clear active track only instead of all selected tracks");
944}
945
947
948/* -------------------------------------------------------------------- */
951
952enum {
956};
957
959{
962 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
963 const int action = RNA_enum_get(op->ptr, "action");
964 const int framenr = ED_space_clip_get_clip_frame_number(sc);
965
966 for (MovieTrackingTrack &track : tracking_object->tracks) {
967 if (TRACK_VIEW_SELECTED(sc, &track) && (track.flag & TRACK_LOCKED) == 0) {
968 MovieTrackingMarker *marker = BKE_tracking_marker_ensure(&track, framenr);
969 switch (action) {
971 marker->flag |= MARKER_DISABLED;
972 break;
973 case MARKER_OP_ENABLE:
974 marker->flag &= ~MARKER_DISABLED;
975 break;
976 case MARKER_OP_TOGGLE:
977 marker->flag ^= MARKER_DISABLED;
978 break;
979 }
980 }
981 }
982
983 DEG_id_tag_update(&clip->id, 0);
984
986
987 return OPERATOR_FINISHED;
988}
989
991{
992 static const EnumPropertyItem actions_items[] = {
993 {MARKER_OP_DISABLE, "DISABLE", 0, "Disable", "Disable selected markers"},
994 {MARKER_OP_ENABLE, "ENABLE", 0, "Enable", "Enable selected markers"},
995 {MARKER_OP_TOGGLE, "TOGGLE", 0, "Toggle", "Toggle disabled flag for selected markers"},
996 {0, nullptr, 0, nullptr, nullptr},
997 };
998
999 /* identifiers */
1000 ot->name = "Disable Markers";
1001 ot->description = "Disable/enable selected markers";
1002 ot->idname = "CLIP_OT_disable_markers";
1003
1004 /* API callbacks. */
1007
1008 /* flags */
1010
1011 /* properties */
1012 RNA_def_enum(ot->srna, "action", actions_items, 0, "Action", "Disable action to execute");
1013}
1014
1016
1017/* -------------------------------------------------------------------- */
1020
1022{
1025 MovieTracking *tracking = &clip->tracking;
1026 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
1027 const int unselected = RNA_boolean_get(op->ptr, "unselected");
1028
1029 /* Hide point tracks. */
1030 for (MovieTrackingTrack &track : tracking_object->tracks) {
1031 if (unselected == 0 && TRACK_VIEW_SELECTED(sc, &track)) {
1032 track.flag |= TRACK_HIDDEN;
1033 }
1034 else if (unselected == 1 && !TRACK_VIEW_SELECTED(sc, &track)) {
1035 track.flag |= TRACK_HIDDEN;
1036 }
1037 }
1038
1039 const MovieTrackingTrack *active_track = tracking_object->active_track;
1040 if (active_track != nullptr && active_track->flag & TRACK_HIDDEN) {
1041 tracking_object->active_track = nullptr;
1042 }
1043
1044 /* Hide place tracks. */
1045 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
1046 if (unselected == 0 && plane_track.flag & SELECT) {
1047 plane_track.flag |= PLANE_TRACK_HIDDEN;
1048 }
1049 else if (unselected == 1 && (plane_track.flag & SELECT) == 0) {
1050 plane_track.flag |= PLANE_TRACK_HIDDEN;
1051 }
1052 }
1053
1054 const MovieTrackingPlaneTrack *active_plane_track = tracking_object->active_plane_track;
1055 if (active_plane_track != nullptr && active_plane_track->flag & PLANE_TRACK_HIDDEN) {
1056 tracking_object->active_plane_track = nullptr;
1057 }
1058
1061
1062 return OPERATOR_FINISHED;
1063}
1064
1066{
1067 /* identifiers */
1068 ot->name = "Hide Tracks";
1069 ot->description = "Hide selected tracks";
1070 ot->idname = "CLIP_OT_hide_tracks";
1071
1072 /* API callbacks. */
1073 ot->exec = hide_tracks_exec;
1075
1076 /* flags */
1078
1079 /* properties */
1080 RNA_def_boolean(ot->srna, "unselected", false, "Unselected", "Hide unselected tracks");
1081}
1082
1084
1085/* -------------------------------------------------------------------- */
1088
1090{
1093 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
1094
1095 /* Unhide point tracks. */
1096 for (MovieTrackingTrack &track : tracking_object->tracks) {
1097 track.flag &= ~TRACK_HIDDEN;
1098 }
1099
1100 /* Unhide plane tracks. */
1101 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
1102 plane_track.flag &= ~PLANE_TRACK_HIDDEN;
1103 }
1104
1106
1108
1109 return OPERATOR_FINISHED;
1110}
1111
1113{
1114 /* identifiers */
1115 ot->name = "Hide Tracks Clear";
1116 ot->description = "Clear hide selected tracks";
1117 ot->idname = "CLIP_OT_hide_tracks_clear";
1118
1119 /* API callbacks. */
1122
1123 /* flags */
1125}
1126
1128
1129/* -------------------------------------------------------------------- */
1132
1134{
1135 SpaceClip *space_clip = CTX_wm_space_clip(C);
1136 return space_clip != nullptr && ED_space_clip_get_clip(space_clip) != nullptr;
1137}
1138
1140{
1141 Scene *scene = CTX_data_scene(C);
1144 MovieTracking *tracking = &clip->tracking;
1145 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
1146 int pos = RNA_enum_get(op->ptr, "position");
1147 int delta;
1148
1149 if (pos <= 1) { /* jump to path */
1150 MovieTrackingTrack *active_track = tracking_object->active_track;
1151 if (active_track == nullptr) {
1152 return OPERATOR_CANCELLED;
1153 }
1154
1155 delta = pos == 1 ? 1 : -1;
1156 while (sc->user.framenr + delta >= scene->r.sfra && sc->user.framenr + delta <= scene->r.efra)
1157 {
1158 int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, sc->user.framenr + delta);
1159 MovieTrackingMarker *marker = BKE_tracking_marker_get_exact(active_track, framenr);
1160
1161 if (marker == nullptr || marker->flag & MARKER_DISABLED) {
1162 break;
1163 }
1164
1165 sc->user.framenr += delta;
1166 }
1167 }
1168 else { /* to failed frame */
1169 if (tracking_object->reconstruction.flag & TRACKING_RECONSTRUCTED) {
1170 int framenr = ED_space_clip_get_clip_frame_number(sc);
1171
1172 delta = pos == 3 ? 1 : -1;
1173 framenr += delta;
1174
1175 while (framenr + delta >= scene->r.sfra && framenr + delta <= scene->r.efra) {
1177 tracking, tracking_object, framenr);
1178
1179 if (cam == nullptr) {
1181 break;
1182 }
1183
1184 framenr += delta;
1185 }
1186 }
1187 }
1188
1189 if (scene->r.cfra != sc->user.framenr) {
1190 scene->r.cfra = sc->user.framenr;
1192
1194 }
1195
1197
1198 return OPERATOR_FINISHED;
1199}
1200
1202{
1203 static const EnumPropertyItem position_items[] = {
1204 {0, "PATHSTART", 0, "Path Start", "Jump to start of current path"},
1205 {1, "PATHEND", 0, "Path End", "Jump to end of current path"},
1206 {2, "FAILEDPREV", 0, "Previous Failed", "Jump to previous failed frame"},
1207 {2, "FAILNEXT", 0, "Next Failed", "Jump to next failed frame"},
1208 {0, nullptr, 0, nullptr, nullptr},
1209 };
1210
1211 /* identifiers */
1212 ot->name = "Jump to Frame";
1213 ot->description = "Jump to special frame";
1214 ot->idname = "CLIP_OT_frame_jump";
1215
1216 /* API callbacks. */
1217 ot->exec = frame_jump_exec;
1218 ot->poll = frame_jump_poll;
1219
1220 /* flags */
1222
1223 /* properties */
1224 RNA_def_enum(ot->srna, "position", position_items, 0, "Position", "Position to jump to");
1225}
1226
1228
1229/* -------------------------------------------------------------------- */
1232
1234{
1237 MovieTracking *tracking = &clip->tracking;
1238 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
1239 MovieTrackingStabilization *stabilization = &tracking->stabilization;
1240 bool update_stabilization = false;
1241
1242 MovieTrackingTrack *active_track = tracking_object->active_track;
1243 if (active_track == nullptr) {
1244 BKE_report(op->reports, RPT_ERROR, "No active track to join to");
1245 return OPERATOR_CANCELLED;
1246 }
1247
1248 Set<MovieTrackingPlaneTrack *> point_tracks;
1249
1250 for (MovieTrackingTrack &track : tracking_object->tracks.items_mutable()) {
1251 if (TRACK_VIEW_SELECTED(sc, &track) && &track != active_track) {
1252 BKE_tracking_tracks_join(tracking, active_track, &track);
1253
1254 if (track.flag & TRACK_USE_2D_STAB) {
1255 update_stabilization = true;
1256 if ((active_track->flag & TRACK_USE_2D_STAB) == 0) {
1257 active_track->flag |= TRACK_USE_2D_STAB;
1258 }
1259 else {
1260 stabilization->tot_track--;
1261 }
1262 BLI_assert(0 <= stabilization->tot_track);
1263 }
1264 if (track.flag & TRACK_USE_2D_STAB_ROT) {
1265 update_stabilization = true;
1266 if ((active_track->flag & TRACK_USE_2D_STAB_ROT) == 0) {
1267 active_track->flag |= TRACK_USE_2D_STAB_ROT;
1268 }
1269 else {
1270 stabilization->tot_rot_track--;
1271 }
1272 BLI_assert(0 <= stabilization->tot_rot_track);
1273 }
1274
1275 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
1276 if (BKE_tracking_plane_track_has_point_track(&plane_track, &track)) {
1277 BKE_tracking_plane_track_replace_point_track(&plane_track, &track, active_track);
1278 if ((plane_track.flag & PLANE_TRACK_AUTOKEY) == 0) {
1279 point_tracks.add(&plane_track);
1280 }
1281 }
1282 }
1283
1285 BLI_freelinkN(&tracking_object->tracks, &track);
1286 }
1287 }
1288
1289 if (update_stabilization) {
1291 }
1292
1293 int framenr = ED_space_clip_get_clip_frame_number(sc);
1294 for (MovieTrackingPlaneTrack *plane_track : point_tracks) {
1296 }
1297
1298 DEG_id_tag_update(&clip->id, 0);
1299
1301
1302 return OPERATOR_FINISHED;
1303}
1304
1306{
1307 /* identifiers */
1308 ot->name = "Join Tracks";
1309 ot->description = "Join selected tracks";
1310 ot->idname = "CLIP_OT_join_tracks";
1311
1312 /* API callbacks. */
1313 ot->exec = join_tracks_exec;
1315
1316 /* flags */
1318}
1319
1321
1322/* -------------------------------------------------------------------- */
1325
1327{
1328 SpaceClip *space_clip = CTX_wm_space_clip(C);
1329 MovieClip *clip = ED_space_clip_get_clip(space_clip);
1330 MovieTracking *tracking = &clip->tracking;
1331 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
1332
1333 /* Collect source tracks. */
1334 int num_source_tracks;
1336 tracking, &num_source_tracks);
1337 if (num_source_tracks == 0) {
1338 return OPERATOR_CANCELLED;
1339 }
1340
1341 /* Create new empty track, which will be the averaged result.
1342 * Makes it simple to average all selection to it. */
1343 MovieTrackingTrack *result_track = BKE_tracking_track_add_empty(tracking,
1344 &tracking_object->tracks);
1345
1346 /* Perform averaging. */
1347 BKE_tracking_tracks_average(result_track, source_tracks, num_source_tracks);
1348
1349 const bool keep_original = RNA_boolean_get(op->ptr, "keep_original");
1350 if (!keep_original) {
1351 for (int i = 0; i < num_source_tracks; i++) {
1352 clip_delete_track(C, clip, source_tracks[i]);
1353 }
1354 }
1355
1356 /* Update selection, making the result track active and selected. */
1357 /* TODO(sergey): Should become some sort of utility function available for all operators. */
1358
1359 BKE_tracking_track_select(&tracking_object->tracks, result_track, TRACK_AREA_ALL, false);
1361
1362 tracking_object->active_track = result_track;
1363 tracking_object->active_plane_track = nullptr;
1364
1365 /* Inform the dependency graph and interface about changes. */
1366 DEG_id_tag_update(&clip->id, 0);
1368
1369 /* Free memory. */
1370 MEM_delete(source_tracks);
1371
1372 return OPERATOR_FINISHED;
1373}
1374
1376 wmOperator *op,
1377 const wmEvent * /*event*/)
1378{
1379 PropertyRNA *prop_keep_original = RNA_struct_find_property(op->ptr, "keep_original");
1380 if (!RNA_property_is_set(op->ptr, prop_keep_original)) {
1381 SpaceClip *space_clip = CTX_wm_space_clip(C);
1382 MovieClip *clip = ED_space_clip_get_clip(space_clip);
1383 MovieTracking *tracking = &clip->tracking;
1384
1385 const int num_selected_tracks = BKE_tracking_count_selected_tracks_in_active_object(tracking);
1386
1387 if (num_selected_tracks == 1) {
1388 RNA_property_boolean_set(op->ptr, prop_keep_original, false);
1389 }
1390 }
1391
1392 return average_tracks_exec(C, op);
1393}
1394
1396{
1397 /* Identifiers. */
1398 ot->name = "Average Tracks";
1399 ot->description = "Average selected tracks into active";
1400 ot->idname = "CLIP_OT_average_tracks";
1401
1402 /* API callbacks. */
1406
1407 /* Flags. */
1409
1410 /* Properties. */
1411 PropertyRNA *prop;
1412
1413 prop = RNA_def_boolean(ot->srna, "keep_original", true, "Keep Original", "Keep original tracks");
1416}
1417
1419
1420/* -------------------------------------------------------------------- */
1423
1424enum {
1428};
1429
1431{
1434 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
1435 const int action = RNA_enum_get(op->ptr, "action");
1436
1437 for (MovieTrackingTrack &track : tracking_object->tracks) {
1438 if (TRACK_VIEW_SELECTED(sc, &track)) {
1439 switch (action) {
1440 case TRACK_ACTION_LOCK:
1441 track.flag |= TRACK_LOCKED;
1442 break;
1444 track.flag &= ~TRACK_LOCKED;
1445 break;
1447 track.flag ^= TRACK_LOCKED;
1448 break;
1449 }
1450 }
1451 }
1452
1454
1455 return OPERATOR_FINISHED;
1456}
1457
1459{
1460 static const EnumPropertyItem actions_items[] = {
1461 {TRACK_ACTION_LOCK, "LOCK", 0, "Lock", "Lock selected tracks"},
1462 {TRACK_ACTION_UNLOCK, "UNLOCK", 0, "Unlock", "Unlock selected tracks"},
1463 {TRACK_ACTION_TOGGLE, "TOGGLE", 0, "Toggle", "Toggle locked flag for selected tracks"},
1464 {0, nullptr, 0, nullptr, nullptr},
1465 };
1466
1467 /* identifiers */
1468 ot->name = "Lock Tracks";
1469 ot->description = "Lock/unlock selected tracks";
1470 ot->idname = "CLIP_OT_lock_tracks";
1471
1472 /* API callbacks. */
1473 ot->exec = lock_tracks_exec;
1475
1476 /* flags */
1478
1479 /* properties */
1480 RNA_def_enum(ot->srna, "action", actions_items, 0, "Action", "Lock action to execute");
1481}
1482
1484
1485/* -------------------------------------------------------------------- */
1488
1489enum {
1492};
1493
1495{
1498 MovieTracking *tracking = &clip->tracking;
1499 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
1500 const int keyframe = RNA_enum_get(op->ptr, "keyframe");
1501 const int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, sc->user.framenr);
1502
1503 if (keyframe == SOLVER_KEYFRAME_A) {
1504 tracking_object->keyframe1 = framenr;
1505 }
1506 else {
1507 tracking_object->keyframe2 = framenr;
1508 }
1509
1511
1512 return OPERATOR_FINISHED;
1513}
1514
1516{
1517 static const EnumPropertyItem keyframe_items[] = {
1518 {SOLVER_KEYFRAME_A, "KEYFRAME_A", 0, "Keyframe A", ""},
1519 {SOLVER_KEYFRAME_B, "KEYFRAME_B", 0, "Keyframe B", ""},
1520 {0, nullptr, 0, nullptr, nullptr},
1521 };
1522
1523 /* identifiers */
1524 ot->name = "Set Solver Keyframe";
1525 ot->description = "Set keyframe used by solver";
1526 ot->idname = "CLIP_OT_set_solver_keyframe";
1527
1528 /* API callbacks. */
1531
1532 /* flags */
1534
1535 /* properties */
1536 RNA_def_enum(ot->srna, "keyframe", keyframe_items, 0, "Keyframe", "Keyframe to set");
1537}
1538
1540
1541/* -------------------------------------------------------------------- */
1544
1546{
1549 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
1550
1551 MovieTrackingTrack *active_track = tracking_object->active_track;
1552 if (active_track == nullptr) {
1553 return OPERATOR_CANCELLED;
1554 }
1555
1556 for (MovieTrackingTrack &track : tracking_object->tracks) {
1557 if (TRACK_VIEW_SELECTED(sc, &track) && &track != active_track) {
1558 track.flag &= ~TRACK_CUSTOMCOLOR;
1559 if (active_track->flag & TRACK_CUSTOMCOLOR) {
1560 copy_v3_v3(track.color, active_track->color);
1561 track.flag |= TRACK_CUSTOMCOLOR;
1562 }
1563 }
1564 }
1565
1566 DEG_id_tag_update(&clip->id, 0);
1568
1569 return OPERATOR_FINISHED;
1570}
1571
1573{
1574 /* identifiers */
1575 ot->name = "Copy Color";
1576 ot->description = "Copy color to all selected tracks";
1577 ot->idname = "CLIP_OT_track_copy_color";
1578
1579 /* API callbacks. */
1582
1583 /* flags */
1585}
1586
1588
1589/* -------------------------------------------------------------------- */
1592
1593static bool is_track_clean(MovieTrackingTrack *track, int frames, int del)
1594{
1595 bool ok = true;
1596 int prev = -1, count = 0;
1597 MovieTrackingMarker *markers = track->markers, *new_markers = nullptr;
1598 int start_disabled = 0;
1599 int markersnr = track->markersnr;
1600
1601 if (del) {
1602 new_markers = MEM_new_array<MovieTrackingMarker>(markersnr, "track cleaned markers");
1603 }
1604
1605 for (int a = 0; a < markersnr; a++) {
1606 int end = 0;
1607
1608 if (prev == -1) {
1609 if ((markers[a].flag & MARKER_DISABLED) == 0) {
1610 prev = a;
1611 }
1612 else {
1613 start_disabled = 1;
1614 }
1615 }
1616
1617 if (prev >= 0) {
1618 end = a == markersnr - 1;
1619 end |= (a < markersnr - 1) && (markers[a].framenr != markers[a + 1].framenr - 1 ||
1620 markers[a].flag & MARKER_DISABLED);
1621 }
1622
1623 if (end) {
1624 int segok = 1, len = 0;
1625
1626 if (a != prev && markers[a].framenr != markers[a - 1].framenr + 1) {
1627 len = a - prev;
1628 }
1629 else if (markers[a].flag & MARKER_DISABLED) {
1630 len = a - prev;
1631 }
1632 else {
1633 len = a - prev + 1;
1634 }
1635
1636 if (frames) {
1637 if (len < frames) {
1638 segok = 0;
1639 ok = false;
1640
1641 if (!del) {
1642 break;
1643 }
1644 }
1645 }
1646
1647 if (del) {
1648 if (segok) {
1649 int t = len;
1650
1651 if (markers[a].flag & MARKER_DISABLED) {
1652 t++;
1653 }
1654
1655 /* Place disabled marker in front of current segment. */
1656 if (start_disabled) {
1657 memcpy(new_markers + count, markers + prev, sizeof(MovieTrackingMarker));
1658 new_markers[count].framenr--;
1659 new_markers[count].flag |= MARKER_DISABLED;
1660
1661 count++;
1662 start_disabled = 0;
1663 }
1664
1665 memcpy(new_markers + count, markers + prev, t * sizeof(MovieTrackingMarker));
1666 count += t;
1667 }
1668 else if (markers[a].flag & MARKER_DISABLED) {
1669 /* Current segment which would be deleted was finished by
1670 * disabled marker, so next segment should be started from
1671 * disabled marker.
1672 */
1673 start_disabled = 1;
1674 }
1675 }
1676
1677 prev = -1;
1678 }
1679 }
1680
1681 if (del && count == 0) {
1682 ok = false;
1683 }
1684
1685 if (del) {
1686 MEM_delete(track->markers);
1687
1688 if (count) {
1689 track->markers = new_markers;
1690 }
1691 else {
1692 track->markers = nullptr;
1693 MEM_delete(new_markers);
1694 }
1695
1696 track->markersnr = count;
1697 }
1698
1699 return ok;
1700}
1701
1703{
1706 MovieTracking *tracking = &clip->tracking;
1707 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
1708 int frames = RNA_int_get(op->ptr, "frames");
1710 float error = RNA_float_get(op->ptr, "error");
1711
1712 if (error && action == TrackingCleanAction::DeleteSegment) {
1714 }
1715
1716 for (MovieTrackingTrack &track : tracking_object->tracks.items_mutable()) {
1717 if ((track.flag & TRACK_HIDDEN) == 0 && (track.flag & TRACK_LOCKED) == 0) {
1718 bool ok;
1719
1720 ok = is_track_clean(&track, frames, action == TrackingCleanAction::DeleteSegment) &&
1721 ((error == 0.0f) || (track.flag & TRACK_HAS_BUNDLE) == 0 || (track.error < error));
1722
1723 if (!ok) {
1724 if (action == TrackingCleanAction::Select) {
1726 }
1727 else if (action == TrackingCleanAction::DeleteTrack) {
1728 if (&track == tracking_object->active_track) {
1729 tracking_object->active_track = nullptr;
1730 }
1732 BLI_freelinkN(&tracking_object->tracks, &track);
1733 continue;
1734 }
1735
1736 /* Happens when all tracking segments are not long enough. */
1737 if (track.markersnr == 0) {
1738 if (&track == tracking_object->active_track) {
1739 tracking_object->active_track = nullptr;
1740 }
1742 BLI_freelinkN(&tracking_object->tracks, &track);
1743 continue;
1744 }
1745 }
1746 }
1747 }
1748
1749 DEG_id_tag_update(&clip->id, 0);
1751
1753
1754 return OPERATOR_FINISHED;
1755}
1756
1758{
1761
1762 if (!RNA_struct_property_is_set(op->ptr, "frames")) {
1763 RNA_int_set(op->ptr, "frames", clip->tracking.settings.clean_frames);
1764 }
1765
1766 if (!RNA_struct_property_is_set(op->ptr, "error")) {
1767 RNA_float_set(op->ptr, "error", clip->tracking.settings.clean_error);
1768 }
1769
1770 if (!RNA_struct_property_is_set(op->ptr, "action")) {
1771 RNA_enum_set(op->ptr, "action", clip->tracking.settings.clean_action);
1772 }
1773
1774 return clean_tracks_exec(C, op);
1775}
1776
1778{
1779 static const EnumPropertyItem actions_items[] = {
1780 {int(TrackingCleanAction::Select), "SELECT", 0, "Select", "Select unclean tracks"},
1782 "DELETE_TRACK",
1783 0,
1784 "Delete Track",
1785 "Delete unclean tracks"},
1787 "DELETE_SEGMENTS",
1788 0,
1789 "Delete Segments",
1790 "Delete unclean segments of tracks"},
1791 {0, nullptr, 0, nullptr, nullptr},
1792 };
1793
1794 /* identifiers */
1795 ot->name = "Clean Tracks";
1796 ot->description = "Clean tracks with high error values or few frames";
1797 ot->idname = "CLIP_OT_clean_tracks";
1798
1799 /* API callbacks. */
1800 ot->exec = clean_tracks_exec;
1803
1804 /* flags */
1806
1807 /* properties */
1808 RNA_def_int(ot->srna,
1809 "frames",
1810 0,
1811 0,
1812 INT_MAX,
1813 "Tracked Frames",
1814 "Affect tracks which are tracked less than the "
1815 "specified number of frames",
1816 0,
1817 INT_MAX);
1818 RNA_def_float(ot->srna,
1819 "error",
1820 0.0f,
1821 0.0f,
1822 FLT_MAX,
1823 "Reprojection Error",
1824 "Affect tracks which have a larger reprojection error",
1825 0.0f,
1826 100.0f);
1827 RNA_def_enum(ot->srna, "action", actions_items, 0, "Action", "Cleanup action to execute");
1828}
1829
1831
1832/* -------------------------------------------------------------------- */
1835
1837{
1840 MovieTracking *tracking = &clip->tracking;
1841
1842 BKE_tracking_object_add(tracking, "Object");
1843
1846
1847 return OPERATOR_FINISHED;
1848}
1849
1851{
1852 /* identifiers */
1853 ot->name = "Add Tracking Object";
1854 ot->description = "Add new object for tracking";
1855 ot->idname = "CLIP_OT_tracking_object_new";
1856
1857 /* API callbacks. */
1860
1861 /* flags */
1863}
1864
1866
1867/* -------------------------------------------------------------------- */
1870
1872{
1875 MovieTracking *tracking = &clip->tracking;
1876 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
1877
1878 if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
1879 BKE_report(op->reports, RPT_WARNING, "Object used for camera tracking cannot be deleted");
1880 return OPERATOR_CANCELLED;
1881 }
1882
1883 BKE_tracking_object_delete(tracking, tracking_object);
1884
1887
1888 return OPERATOR_FINISHED;
1889}
1890
1892{
1893 /* identifiers */
1894 ot->name = "Remove Tracking Object";
1895 ot->description = "Remove object for tracking";
1896 ot->idname = "CLIP_OT_tracking_object_remove";
1897
1898 /* API callbacks. */
1901
1902 /* flags */
1904}
1905
1907
1908/* -------------------------------------------------------------------- */
1911
1913{
1916 MovieTracking *tracking = &clip->tracking;
1917 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
1918
1920
1921 BKE_tracking_clipboard_copy_tracks(tracking, tracking_object);
1922
1923 return OPERATOR_FINISHED;
1924}
1925
1927{
1928 /* identifiers */
1929 ot->name = "Copy Tracks";
1930 ot->description = "Copy the selected tracks to the internal clipboard";
1931 ot->idname = "CLIP_OT_copy_tracks";
1932
1933 /* API callbacks. */
1934 ot->exec = copy_tracks_exec;
1936
1937 /* flags */
1938 ot->flag = OPTYPE_REGISTER;
1939}
1940
1942
1943/* -------------------------------------------------------------------- */
1946
1948{
1951 }
1952
1953 return false;
1954}
1955
1957{
1960 MovieTracking *tracking = &clip->tracking;
1961 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
1962
1963 BKE_tracking_tracks_deselect_all(&tracking_object->tracks);
1964 BKE_tracking_clipboard_paste_tracks(tracking, tracking_object);
1965
1967
1968 return OPERATOR_FINISHED;
1969}
1970
1972{
1973 /* identifiers */
1974 ot->name = "Paste Tracks";
1975 ot->description = "Paste tracks from the internal clipboard";
1976 ot->idname = "CLIP_OT_paste_tracks";
1977
1978 /* API callbacks. */
1979 ot->exec = paste_tracks_exec;
1980 ot->poll = paste_tracks_poll;
1981
1982 /* flags */
1984}
1985
1987
1988/* -------------------------------------------------------------------- */
1991
1992static void keyframe_set_flag(bContext *C, bool set)
1993{
1996 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
1997 const int framenr = ED_space_clip_get_clip_frame_number(sc);
1998
1999 for (MovieTrackingTrack &track : tracking_object->tracks) {
2000 if (TRACK_VIEW_SELECTED(sc, &track)) {
2001 if (set) {
2002 MovieTrackingMarker *marker = BKE_tracking_marker_ensure(&track, framenr);
2003 marker->flag &= ~MARKER_TRACKED;
2004 }
2005 else {
2006 MovieTrackingMarker *marker = BKE_tracking_marker_get_exact(&track, framenr);
2007 if (marker != nullptr) {
2008 marker->flag |= MARKER_TRACKED;
2009 }
2010 }
2011 }
2012 }
2013
2014 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
2015 if (PLANE_TRACK_VIEW_SELECTED(&plane_track)) {
2016 if (set) {
2018 framenr);
2019 if (plane_marker->flag & PLANE_MARKER_TRACKED) {
2020 plane_marker->flag &= ~PLANE_MARKER_TRACKED;
2021 BKE_tracking_track_plane_from_existing_motion(&plane_track, plane_marker->framenr);
2022 }
2023 }
2024 else {
2026 framenr);
2027 if (plane_marker) {
2028 if ((plane_marker->flag & PLANE_MARKER_TRACKED) == 0) {
2029 plane_marker->flag |= PLANE_MARKER_TRACKED;
2031 plane_marker->framenr);
2032 }
2033 }
2034 }
2035 }
2036 }
2037
2039}
2040
2042{
2043 keyframe_set_flag(C, true);
2044 return OPERATOR_FINISHED;
2045}
2046
2048{
2049 /* identifiers */
2050 ot->name = "Insert Keyframe";
2051 ot->description = "Insert a keyframe to selected tracks at current frame";
2052 ot->idname = "CLIP_OT_keyframe_insert";
2053
2054 /* API callbacks. */
2057
2058 /* flags */
2060}
2061
2063
2064/* -------------------------------------------------------------------- */
2067
2069{
2070 keyframe_set_flag(C, false);
2071 return OPERATOR_FINISHED;
2072}
2073
2075{
2076 /* identifiers */
2077 ot->name = "Delete Keyframe";
2078 ot->description = "Delete a keyframe from selected tracks at current frame";
2079 ot->idname = "CLIP_OT_keyframe_delete";
2080
2081 /* API callbacks. */
2084
2085 /* flags */
2087}
2088
2090
2091/* -------------------------------------------------------------------- */
2094
2096{
2097 SpaceClip *space_clip = CTX_wm_space_clip(C);
2098 const int clip_frame_number = ED_space_clip_get_clip_frame_number(space_clip);
2099
2100 MovieClip *clip = ED_space_clip_get_clip(space_clip);
2101
2102 MovieTracking *tracking = &clip->tracking;
2103 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
2105 tracking_object->active_plane_track, clip_frame_number);
2106
2107 ImBuf *frame_ibuf = ED_space_clip_get_buffer(space_clip);
2108 if (frame_ibuf == nullptr) {
2109 return nullptr;
2110 }
2111
2112 ImBuf *plane_ibuf = BKE_tracking_get_plane_imbuf(frame_ibuf, plane_marker);
2113
2114 IMB_freeImBuf(frame_ibuf);
2115
2116 return plane_ibuf;
2117}
2118
2120{
2122 return false;
2123 }
2124
2125 SpaceClip *space_clip = CTX_wm_space_clip(C);
2126 MovieClip *clip = ED_space_clip_get_clip(space_clip);
2127 const MovieTracking *tracking = &clip->tracking;
2128 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
2129
2130 if (tracking_object->active_plane_track == nullptr) {
2131 return false;
2132 }
2133
2134 return true;
2135}
2136
2138{
2139 SpaceClip *space_clip = CTX_wm_space_clip(C);
2140 MovieClip *clip = ED_space_clip_get_clip(space_clip);
2141 MovieTracking *tracking = &clip->tracking;
2142 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
2143 MovieTrackingPlaneTrack *plane_track = tracking_object->active_plane_track;
2144
2146 if (plane_ibuf == nullptr) {
2147 return OPERATOR_CANCELLED;
2148 }
2149
2150 plane_track->image = BKE_image_add_from_imbuf(CTX_data_main(C), plane_ibuf, plane_track->name);
2151
2152 IMB_freeImBuf(plane_ibuf);
2153
2155
2156 return OPERATOR_FINISHED;
2157}
2158
2160{
2161 /* identifiers */
2162 ot->name = "New Image from Plane Marker";
2163 ot->description = "Create new image from the content of the plane marker";
2164 ot->idname = "CLIP_OT_new_image_from_plane_marker";
2165
2166 /* API callbacks. */
2169
2170 /* flags */
2172}
2173
2175{
2177 return false;
2178 }
2179
2180 SpaceClip *space_clip = CTX_wm_space_clip(C);
2181 MovieClip *clip = ED_space_clip_get_clip(space_clip);
2182 const MovieTracking *tracking = &clip->tracking;
2183 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
2184
2185 if (tracking_object->active_plane_track == nullptr ||
2186 tracking_object->active_plane_track->image == nullptr)
2187 {
2188 return false;
2189 }
2190
2191 const Image *image = tracking_object->active_plane_track->image;
2192 return image->type == IMA_TYPE_IMAGE && ELEM(image->source, IMA_SRC_FILE, IMA_SRC_GENERATED);
2193}
2194
2196{
2197 SpaceClip *space_clip = CTX_wm_space_clip(C);
2198 MovieClip *clip = ED_space_clip_get_clip(space_clip);
2199 MovieTracking *tracking = &clip->tracking;
2200 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
2201 MovieTrackingPlaneTrack *plane_track = tracking_object->active_plane_track;
2202
2204 if (plane_ibuf == nullptr) {
2205 return OPERATOR_CANCELLED;
2206 }
2207
2208 BKE_image_replace_imbuf(plane_track->image, plane_ibuf);
2209
2210 IMB_freeImBuf(plane_ibuf);
2211
2214
2215 return OPERATOR_FINISHED;
2216}
2217
2219{
2220 /* identifiers */
2221 ot->name = "Update Image from Plane Marker";
2222 ot->description =
2223 "Update current image used by plane marker from the content of the plane marker";
2224 ot->idname = "CLIP_OT_update_image_from_plane_marker";
2225
2226 /* API callbacks. */
2229
2230 /* flags */
2232}
2233
2235
2236} // namespace blender
#define SELECT
Definition BKE_mask.hh:19
#define ATTR_FALLTHROUGH
#define PLANE_TRACK_VIEW_SELECTED(plane_track)
#define TRACK_VIEW_SELECTED(sc, track)
#define IFACE_(msgid)
#define BLT_I18NCONTEXT_ID_MOVIECLIP
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define NC_GEOM
Definition WM_types.hh:406
#define NA_EVALUATED
Definition WM_types.hh:635
#define ND_DISPLAY
Definition WM_types.hh:534
#define NC_MOVIECLIP
Definition WM_types.hh:410
#define NC_SCENE
Definition WM_types.hh:391
#define NA_EDITED
Definition WM_types.hh:634
#define NC_IMAGE
Definition WM_types.hh:397
#define ND_FRAME
Definition WM_types.hh:453
#define ND_SELECT
Definition WM_types.hh:551
#define ND_TRANSFORM
Definition WM_types.hh:475
#define NC_OBJECT
Definition WM_types.hh:392
#define ELEM(...)
#define BLI_assert_msg(a, msg)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
Definition btVector3.h:356
bool add(const Key &key)
Definition BLI_set.hh:248
void item(std::string text, int icon1, int icon2=0)
Definition area.cc:1076
CCL_NAMESPACE_BEGIN struct Options options
#define FLT_MAX
#define INT_MAX
#define FLT_EPSILON
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
float3x3 scale(float3x3 mat, float2 scale)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
BMesh Iterators.
void clip_delete_plane_track(bContext *C, MovieClip *clip, MovieTrackingPlaneTrack *plane_track)
void CLIP_OT_add_marker(wmOperatorType *ot)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void RNA_float_set_array(PointerRNA *ptr, const char *name, const float *values)
void ED_space_clip_get_size(const SpaceClip *sc, int *r_width, int *r_height)
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
static wmOperatorStatus keyframe_delete_exec(bContext *C, wmOperator *)
void CLIP_OT_keyframe_insert(wmOperatorType *ot)
void BKE_tracking_track_plane_from_existing_motion(MovieTrackingPlaneTrack *plane_track, int start_frame)
MINLINE void copy_v2_v2_int(int r[2], const int a[2])
int RNA_enum_get(PointerRNA *ptr, const char *name)
void BKE_tracking_marker_clamp_search_size(MovieTrackingMarker *marker)
Definition tracking.cc:1332
ImBuf * ED_space_clip_get_buffer(const SpaceClip *sc)
@ RPT_WARNING
Definition BKE_report.hh:40
void CLIP_OT_tracking_object_remove(wmOperatorType *ot)
void CLIP_OT_keyframe_delete(wmOperatorType *ot)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
void CLIP_OT_average_tracks(wmOperatorType *ot)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void CLIP_OT_join_tracks(wmOperatorType *ot)
MINLINE void add_v2_v2v2(float r[2], const float a[2], const float b[2])
static wmOperatorStatus add_marker_exec(bContext *C, wmOperator *op)
static void slide_marker_tilt_slider_relative(const float pattern_corners[4][2], float r_slider[2])
MovieTrackingObject * BKE_tracking_object_add(MovieTracking *tracking, const char *name)
Definition tracking.cc:1902
static wmOperatorStatus add_marker_invoke(bContext *C, wmOperator *op, const wmEvent *event)
void BKE_tracking_plane_track_replace_point_track(MovieTrackingPlaneTrack *plane_track, MovieTrackingTrack *old_track, MovieTrackingTrack *new_track)
Definition tracking.cc:1696
bool BKE_tracking_plane_track_has_point_track(MovieTrackingPlaneTrack *plane_track, MovieTrackingTrack *track)
Definition tracking.cc:1647
static wmOperatorStatus keyframe_insert_exec(bContext *C, wmOperator *)
MINLINE void mul_v2_fl(float r[2], float f)
MINLINE float cross_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT
static wmOperatorStatus new_image_from_plane_marker_exec(bContext *C, wmOperator *)
static wmOperatorStatus slide_marker_modal(bContext *C, wmOperator *op, const wmEvent *event)
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 clip_tracking_hide_cursor(bContext *C)
static bool frame_jump_poll(bContext *C)
static wmOperatorStatus delete_track_exec(bContext *C, wmOperator *)
static void free_slide_data(SlideMarkerData *data)
void CLIP_OT_copy_tracks(wmOperatorType *ot)
void RNA_int_set(PointerRNA *ptr, const char *name, int value)
void CLIP_OT_lock_tracks(wmOperatorType *ot)
SpaceClip * CTX_wm_space_clip(const bContext *C)
static wmOperatorStatus delete_marker_exec(bContext *C, wmOperator *)
static bool slide_check_corners(float(*corners)[2])
MovieTrackingTrack * BKE_tracking_track_add(MovieTracking *tracking, ListBaseT< MovieTrackingTrack > *tracksbase, float x, float y, int framenr, int width, int height)
Definition tracking.cc:527
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
void CLIP_OT_hide_tracks(wmOperatorType *ot)
float angle_signed_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
int RNA_int_get(PointerRNA *ptr, const char *name)
void CLIP_OT_slide_marker(wmOperatorType *ot)
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
void ED_clip_point_stable_pos(const SpaceClip *sc, const ARegion *region, float x, float y, float *xr, float *yr)
void BKE_tracking_tracks_join(MovieTracking *tracking, MovieTrackingTrack *dst_track, MovieTrackingTrack *src_track)
Definition tracking.cc:799
void RNA_enum_set(PointerRNA *ptr, const char *name, int value)
static wmOperatorStatus tracking_object_remove_exec(bContext *C, wmOperator *op)
void CLIP_OT_tracking_object_new(wmOperatorType *ot)
ImBuf * BKE_tracking_get_plane_imbuf(const ImBuf *frame_ibuf, const MovieTrackingPlaneMarker *plane_marker)
Definition tracking.cc:2739
static wmOperatorStatus slide_marker_invoke(bContext *C, wmOperator *op, const wmEvent *event)
void BKE_tracking_plane_tracks_deselect_all(ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base)
Definition tracking.cc:1640
void BKE_tracking_retrack_plane_from_existing_motion_at_segment(MovieTrackingPlaneTrack *plane_track, int start_frame)
void CLIP_OT_frame_jump(wmOperatorType *ot)
static wmOperatorStatus clean_tracks_invoke(bContext *C, wmOperator *op, const wmEvent *)
static bool update_image_from_plane_marker_poll(bContext *C)
void BKE_image_replace_imbuf(Image *image, ImBuf *ibuf)
void ED_clip_view_lock_state_restore_no_jump(const bContext *C, const ClipViewLockState *state)
static bool new_image_from_plane_marker_poll(bContext *C)
static void keyframe_set_flag(bContext *C, bool set)
void clip_delete_track(bContext *C, MovieClip *clip, MovieTrackingTrack *track)
PropertyRNA * RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, const int len, const float *default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
void BKE_tracking_dopesheet_tag_update(MovieTracking *tracking)
Definition tracking.cc:3355
void CLIP_OT_add_marker_at_click(wmOperatorType *ot)
@ SLIDE_ACTION_NONE
Definition mask_ops.cc:245
@ SLIDE_ACTION_TILT_SIZE
@ SLIDE_ACTION_SIZE
@ SLIDE_ACTION_OFFSET
static bool add_marker(const bContext *C, float x, float y)
static wmOperatorStatus delete_track_invoke(bContext *C, wmOperator *op, const wmEvent *)
static SlideMarkerData * slide_marker_customdata(bContext *C, const wmEvent *event)
void WM_operator_properties_confirm_or_exec(wmOperatorType *ot)
PointTrackPick ed_tracking_pick_point_track(const TrackPickOptions *options, bContext *C, const float co[2])
bool BKE_tracking_clipboard_has_tracks()
Definition tracking.cc:477
void CLIP_OT_delete_track(wmOperatorType *ot)
static ImBuf * sample_plane_marker_image_for_operator(bContext *C)
void IMB_freeImBuf(ImBuf *ibuf)
MovieTrackingTrack * tracking_find_slidable_track_in_proximity(bContext *C, const float co[2])
bool ed_tracking_point_track_pick_can_slide(const SpaceClip *space_clip, const PointTrackPick *pick)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
MINLINE void add_v2_v2(float r[2], const float a[2])
static wmOperatorStatus hide_tracks_clear_exec(bContext *C, wmOperator *)
void DEG_id_tag_update(ID *id, unsigned int flags)
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
MovieTrackingMarker * BKE_tracking_marker_ensure(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1407
BMesh const char void * data
BLI_INLINE TrackPickOptions ed_tracking_pick_options_defaults()
void BKE_tracking_clipboard_paste_tracks(MovieTracking *tracking, MovieTrackingObject *tracking_object)
Definition tracking.cc:482
MovieTrackingTrack ** BKE_tracking_selected_tracks_in_active_object(MovieTracking *tracking, int *r_num_tracks)
Definition tracking.cc:648
static MovieTrackingTrack * tracking_marker_check_slide(bContext *C, const float co[2], eTrackArea *r_area, eSlideAction *r_action, int *r_corner)
MovieTrackingTrack * BKE_tracking_track_add_empty(MovieTracking *tracking, ListBaseT< MovieTrackingTrack > *tracks_list)
Definition tracking.cc:502
int ED_space_clip_get_clip_frame_number(const SpaceClip *sc)
BLI_INLINE bool ed_tracking_point_track_pick_empty(const PointTrackPick *pick)
static wmOperatorStatus disable_markers_exec(bContext *C, wmOperator *op)
static wmOperatorStatus clean_tracks_exec(bContext *C, wmOperator *op)
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
struct MovieReconstructedCamera * BKE_tracking_camera_get_reconstructed(MovieTracking *tracking, MovieTrackingObject *tracking_object, int framenr)
Definition tracking.cc:2138
bool RNA_struct_property_is_set(PointerRNA *ptr, const char *identifier)
static void cancel_mouse_slide(SlideMarkerData *data)
void BKE_tracking_clipboard_copy_tracks(MovieTracking *tracking, MovieTrackingObject *tracking_object)
Definition tracking.cc:461
Image * BKE_image_add_from_imbuf(Main *bmain, ImBuf *ibuf, const char *name)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_ensure(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1854
int isect_point_quad_v2(const float p[2], const float v1[2], const float v2[2], const float v3[2], const float v4[2])
void CLIP_OT_clear_track_path(wmOperatorType *ot)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
wmOperatorStatus WM_operator_confirm_ex(bContext *C, wmOperator *op, const char *title, const char *message, const char *confirm_text, ui::AlertIcon icon, bool cancel_default)
void BKE_tracking_tracks_average(MovieTrackingTrack *dst_track, MovieTrackingTrack **src_tracks, int num_src_tracks)
Definition tracking.cc:1019
void ED_clip_mouse_pos(const SpaceClip *sc, const ARegion *region, const int mval[2], float r_co[2])
static wmOperatorStatus frame_jump_exec(bContext *C, wmOperator *op)
void BKE_tracking_marker_clamp_search_position(MovieTrackingMarker *marker)
Definition tracking.cc:1343
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void RNA_float_set(PointerRNA *ptr, const char *name, float value)
void clip_tracking_show_cursor(bContext *C)
@ 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
static wmOperatorStatus set_solver_keyframe_exec(bContext *C, wmOperator *op)
static wmOperatorStatus paste_tracks_exec(bContext *C, wmOperator *)
static wmOperatorStatus add_marker_at_click_modal(bContext *C, wmOperator *, const wmEvent *event)
void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
float BKE_movieclip_remap_scene_to_clip_frame(const MovieClip *clip, float framenr)
void BKE_tracking_track_free(MovieTrackingTrack *track)
Definition tracking.cc:598
static wmOperatorStatus tracking_object_new_exec(bContext *C, wmOperator *)
void CLIP_OT_paste_tracks(wmOperatorType *ot)
MINLINE float len_squared_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
static wmOperatorStatus delete_marker_invoke(bContext *C, wmOperator *op, const wmEvent *)
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, const int default_value, const int hardmin, const int hardmax, const char *ui_name, const char *ui_description, const int softmin, const int softmax)
Main * CTX_data_main(const bContext *C)
void CLIP_OT_new_image_from_plane_marker(wmOperatorType *ot)
static wmOperatorStatus update_image_from_plane_marker_exec(bContext *C, wmOperator *)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get_exact(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1842
static wmOperatorStatus join_tracks_exec(bContext *C, wmOperator *op)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
MovieClip * ED_space_clip_get_clip(const SpaceClip *sc)
void BKE_tracking_plane_track_free(MovieTrackingPlaneTrack *plane_track)
Definition tracking.cc:1631
void CLIP_OT_set_solver_keyframe(wmOperatorType *ot)
@ TRACK_CLEAR_REMAINED
static wmOperatorStatus clear_track_path_exec(bContext *C, wmOperator *op)
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
@ ID_RECALC_SYNC_TO_EVAL
Definition DNA_ID.h:1118
@ ID_RECALC_FRAME_CHANGE
Definition DNA_ID.h:1125
@ PROP_SKIP_SAVE
Definition RNA_types.hh:414
static wmOperatorStatus track_copy_color_exec(bContext *C, wmOperator *)
void clip_delete_marker(bContext *C, MovieClip *clip, MovieTrackingTrack *track, MovieTrackingMarker *marker)
static bool paste_tracks_poll(bContext *C)
@ KM_RELEASE
Definition WM_types.hh:325
bool ED_space_clip_tracking_poll(bContext *C)
void CLIP_OT_delete_marker(wmOperatorType *ot)
void CLIP_OT_update_image_from_plane_marker(wmOperatorType *ot)
void CLIP_OT_track_copy_color(wmOperatorType *ot)
float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
void BKE_tracking_track_flag_set(MovieTrackingTrack *track, eTrackArea area, TrackingTrackFlag flag)
Definition tracking.cc:677
void RNA_property_boolean_set(PointerRNA *ptr, PropertyRNA *prop, bool value)
Scene * CTX_data_scene(const bContext *C)
static wmOperatorStatus add_marker_at_click_invoke(bContext *C, wmOperator *op, const wmEvent *)
void clip_tracking_clear_invisible_track_selection(SpaceClip *sc, MovieClip *clip)
static bool is_track_clean(MovieTrackingTrack *track, int frames, int del)
static void apply_mouse_slide(bContext *C, SlideMarkerData *data)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
@ OPTYPE_BLOCKING
Definition WM_types.hh:192
@ OPTYPE_GRAB_CURSOR_XY
Definition WM_types.hh:196
static SlideMarkerData * create_slide_marker_data(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker, const wmEvent *event, eTrackArea area, int corner, eSlideAction action, int width, int height)
MINLINE float len_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
void CLIP_OT_disable_markers(wmOperatorType *ot)
void ED_clip_view_lock_state_store(const bContext *C, ClipViewLockState *state)
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
@ TRACK_ACTION_UNLOCK
@ TRACK_ACTION_TOGGLE
static wmOperatorStatus copy_tracks_exec(bContext *C, wmOperator *)
@ TRACK_PICK_AREA_DETAIL_TILT_SIZE
@ TRACK_PICK_AREA_DETAIL_POSITION
@ TRACK_PICK_AREA_DETAIL_OFFSET
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
void CLIP_OT_clean_tracks(wmOperatorType *ot)
ARegion * CTX_wm_region(const bContext *C)
void ED_workspace_status_text(bContext *C, const char *str)
Definition area.cc:1153
static wmOperatorStatus hide_tracks_exec(bContext *C, wmOperator *op)
float RNA_float_get(PointerRNA *ptr, const char *name)
bool RNA_property_is_set(PointerRNA *ptr, PropertyRNA *prop)
static wmOperatorStatus lock_tracks_exec(bContext *C, wmOperator *op)
static wmOperatorStatus average_tracks_invoke(bContext *C, wmOperator *op, const wmEvent *)
void RNA_float_get_array(PointerRNA *ptr, const char *name, float *values)
@ MARKER_OP_DISABLE
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
static wmOperatorStatus average_tracks_exec(bContext *C, wmOperator *op)
void CLIP_OT_hide_tracks_clear(wmOperatorType *ot)
MovieTrackingMarker * BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1363
#define fabsf
#define sinf
#define cosf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct MovieTracking tracking
MovieTrackingPlaneTrack * active_plane_track
MovieTrackingReconstruction reconstruction
ListBaseT< MovieTrackingTrack > tracks
ListBaseT< MovieTrackingPlaneTrack > plane_tracks
MovieTrackingTrack * active_track
MovieTrackingMarker * markers
MovieTrackingStabilization stabilization
MovieTrackingSettings settings
eTrackPickAreaDetail area_detail
MovieTrackingTrack * track
struct RenderData r
MovieTrackingTrack * track
MovieTrackingMarker * marker
struct MovieClip * clip
struct MovieClipUser user
wmEventType type
Definition WM_types.hh:817
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157
struct ReportList * reports