Blender V5.3
tracking_select.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 <algorithm>
10
11#include "DNA_movieclip_types.h"
12#include "DNA_userdef_types.h"
13
14#include "BLI_lasso_2d.hh"
15#include "BLI_listbase.hh"
16#include "BLI_math_base.hh"
17#include "BLI_math_geom_c.hh"
18#include "BLI_math_vector_c.hh"
20#include "BLI_rect.hh"
21
22#include "BKE_context.hh"
23#include "BKE_tracking.hh"
24
25#include "WM_api.hh"
26#include "WM_types.hh"
27
28#include "ED_clip.hh"
29#include "ED_select_utils.hh"
30
31#include "RNA_access.hh"
32#include "RNA_define.hh"
33
34#include "UI_view2d.hh"
35
36#include "DEG_depsgraph.hh"
37
38#include "clip_intern.hh" /* own include */
39#include "tracking_ops_intern.hh" /* own include */
40
41namespace blender {
42
43/* -------------------------------------------------------------------- */
46
48{
49 PointTrackPick pick = {nullptr};
50
51 pick.area = TRACK_AREA_NONE;
53 pick.corner_index = -1;
55
56 return pick;
57}
58
59static void slide_marker_tilt_slider_relative(const float pattern_corners[4][2], float r_slider[2])
60{
61 add_v2_v2v2(r_slider, pattern_corners[1], pattern_corners[2]);
62}
63
64static void slide_marker_tilt_slider(const float marker_pos[2],
65 const float pattern_corners[4][2],
66 float r_slider[2])
67{
68 slide_marker_tilt_slider_relative(pattern_corners, r_slider);
69 add_v2_v2(r_slider, marker_pos);
70}
71
72static float mouse_to_slide_zone_distance_squared(const float co[2],
73 const float slide_zone[2],
74 int width,
75 int height)
76{
77 const float pixel_co[2] = {co[0] * width, co[1] * height},
78 pixel_slide_zone[2] = {slide_zone[0] * width, slide_zone[1] * height};
79 return square_f(pixel_co[0] - pixel_slide_zone[0]) + square_f(pixel_co[1] - pixel_slide_zone[1]);
80}
81
83 const MovieTrackingMarker *marker, const float co[2], int corner, int width, int height)
84{
85 float side_zone[2];
86 if (corner == 0) {
87 side_zone[0] = marker->pos[0] + marker->search_max[0];
88 side_zone[1] = marker->pos[1] + marker->search_min[1];
89 }
90 else {
91 side_zone[0] = marker->pos[0] + marker->search_min[0];
92 side_zone[1] = marker->pos[1] + marker->search_max[1];
93 }
94 return mouse_to_slide_zone_distance_squared(co, side_zone, width, height);
95}
96
98 const MovieTrackingMarker *marker, const float co[2], int width, int height, int *r_corner)
99{
100 float min_distance_squared = FLT_MAX;
101 for (int i = 0; i < 4; i++) {
102 float corner_co[2];
103 add_v2_v2v2(corner_co, marker->pattern_corners[i], marker->pos);
104 float distance_squared = mouse_to_slide_zone_distance_squared(co, corner_co, width, height);
105 if (distance_squared < min_distance_squared) {
106 min_distance_squared = distance_squared;
107 *r_corner = i;
108 }
109 }
110 return min_distance_squared;
111}
112
114 const MovieTrackingMarker *marker,
115 const float co[2],
116 int width,
117 int height)
118{
119 float pos[2];
120 add_v2_v2v2(pos, marker->pos, track->offset);
121 return mouse_to_slide_zone_distance_squared(co, pos, width, height);
122}
123
125 const float co[2],
126 int width,
127 int height)
128{
129 float slider[2];
130 slide_marker_tilt_slider(marker->pos, marker->pattern_corners, slider);
131 return mouse_to_slide_zone_distance_squared(co, slider, width, height);
132}
133
135 const float corners_offset[2],
136 const float corners[4][2],
137 int width,
138 int height)
139{
140 const float co_px[2] = {co[0] * width, co[1] * height};
141
142 float prev_corner_co_px[2];
143 add_v2_v2v2(prev_corner_co_px, corners_offset, corners[3]);
144 prev_corner_co_px[0] *= width;
145 prev_corner_co_px[1] *= height;
146
147 float min_distance_squared = FLT_MAX;
148
149 for (int i = 0; i < 4; ++i) {
150 float corner_co_px[2];
151 add_v2_v2v2(corner_co_px, corners_offset, corners[i]);
152 corner_co_px[0] *= width;
153 corner_co_px[1] *= height;
154
156 co_px, corner_co_px, prev_corner_co_px);
157
158 min_distance_squared = std::min(distance_squared, min_distance_squared);
159
160 copy_v2_v2(prev_corner_co_px, corner_co_px);
161 }
162
163 return min_distance_squared;
164}
165
167 const float co[2],
168 int width,
169 int height)
170{
172 co, marker->pos, marker->pattern_corners, width, height);
173}
174
176 const float co[2],
177 int width,
178 int height)
179{
180 const float corners[4][2] = {
181 {marker->search_min[0], marker->search_min[1]},
182 {marker->search_max[0], marker->search_min[1]},
183 {marker->search_max[0], marker->search_max[1]},
184 {marker->search_min[0], marker->search_max[1]},
185 };
186
187 return mouse_to_closest_corners_edge_distance_squared(co, marker->pos, corners, width, height);
188}
189
191 bContext *C,
192 const float co[2])
193{
194 SpaceClip *space_clip = CTX_wm_space_clip(C);
195
196 int width, height;
197 ED_space_clip_get_size(space_clip, &width, &height);
198 if (width == 0 || height == 0) {
200 }
201
202 MovieClip *clip = ED_space_clip_get_clip(space_clip);
204
205 const float distance_tolerance_px_squared = math::square(12.0f / space_clip->zoom *
207 const bool are_disabled_markers_visible = (space_clip->flag & SC_HIDE_DISABLED) == 0;
208 const int framenr = ED_space_clip_get_clip_frame_number(space_clip);
209
211
212 for (MovieTrackingTrack &track : tracking_object->tracks) {
213 const bool is_track_selected = TRACK_VIEW_SELECTED(space_clip, &track);
214
215 if (options->selected_only && !is_track_selected) {
216 continue;
217 }
218 if (options->unlocked_only && (track.flag & TRACK_LOCKED)) {
219 continue;
220 }
221
222 MovieTrackingMarker *marker = BKE_tracking_marker_get(&track, framenr);
223 const bool is_marker_enabled = ((marker->flag & MARKER_DISABLED) == 0);
224
225 if (!is_marker_enabled) {
226 if (options->enabled_only) {
227 /* Disabled marker is requested to not be in the pick result, so skip it. */
228 continue;
229 }
230
231 /* See whether the disabled marker is visible.
232 *
233 * If the clip editor is not hiding disabled markers, then all disabled markers are visible.
234 * Otherwise only disabled marker of the active track is visible. */
235 if (!are_disabled_markers_visible && &track != tracking_object->active_track) {
236 continue;
237 }
238 }
239
240 float distance_squared;
241
242 /* Initialize the current pick with the offset point of the track. */
244 current_pick.track = &track;
245 current_pick.marker = marker;
246 current_pick.area = TRACK_AREA_POINT;
248 &track, marker, co, width, height);
249
250 /* If search area is visible, check how close to its sliding zones mouse is.
251 * NOTE: The search area is only visible for selected tracks. */
252 if (is_track_selected && (space_clip->flag & SC_SHOW_MARKER_SEARCH)) {
253 distance_squared = mouse_to_search_corner_distance_squared(marker, co, 1, width, height);
254 if (distance_squared < current_pick.distance_px_squared) {
255 current_pick.area = TRACK_AREA_SEARCH;
258 }
259
260 distance_squared = mouse_to_search_corner_distance_squared(marker, co, 0, width, height);
261 if (distance_squared < current_pick.distance_px_squared) {
262 current_pick.area = TRACK_AREA_SEARCH;
265 }
266 }
267
268 /* If pattern area is visible, check which corner is closest to the mouse. */
269 if (space_clip->flag & SC_SHOW_MARKER_PATTERN) {
270 int current_corner = -1;
272 marker, co, width, height, &current_corner);
273 if (distance_squared < current_pick.distance_px_squared) {
274 current_pick.area = TRACK_AREA_PAT;
276 current_pick.corner_index = current_corner;
278 }
279
280 /* Here we also check whether the mouse is actually closer to the widget which controls scale
281 * and tilt.
282 * NOTE: The tilt control is only visible for selected tracks. */
283 if (is_track_selected) {
284 distance_squared = mouse_to_tilt_distance_squared(marker, co, width, height);
285 if (distance_squared < current_pick.distance_px_squared) {
286 current_pick.area = TRACK_AREA_PAT;
289 }
290 }
291 }
292
293 /* Whenever a manipulation "widgets" are not within distance tolerance test the edges as well.
294 * This allows to pick tracks by clicking on the pattern/search areas edges but prefer to use
295 * more actionable "widget" for sliding. */
296 if (current_pick.distance_px_squared > distance_tolerance_px_squared) {
297 if (is_track_selected && (space_clip->flag & SC_SHOW_MARKER_SEARCH)) {
299 marker, co, width, height);
300 if (distance_squared < current_pick.distance_px_squared) {
301 current_pick.area = TRACK_AREA_SEARCH;
304 }
305 }
306
307 if (space_clip->flag & SC_SHOW_MARKER_PATTERN) {
309 marker, co, width, height);
310 if (distance_squared < current_pick.distance_px_squared) {
311 current_pick.area = TRACK_AREA_PAT;
314 }
315 }
316 }
317
318 if (current_pick.distance_px_squared < pick.distance_px_squared) {
319 pick = current_pick;
320 }
321 }
322
323 if (pick.distance_px_squared > distance_tolerance_px_squared) {
325 }
326
327 return pick;
328}
329
331 const PointTrackPick *pick)
332{
333 if (pick->track == nullptr) {
334 return false;
335 }
336
337 BLI_assert(pick->marker != nullptr);
338
339 if (!TRACK_VIEW_SELECTED(space_clip, pick->track)) {
340 return false;
341 }
342
343 if (pick->track->flag & TRACK_LOCKED) {
344 return false;
345 }
346 if (pick->marker->flag & MARKER_DISABLED) {
347 return false;
348 }
349
351}
352
354
355/* -------------------------------------------------------------------- */
358
360{
361 PlaneTrackPick result = {nullptr};
362
363 result.corner_index = -1;
364 result.distance_px_squared = FLT_MAX;
365
366 return result;
367}
368
369static float mouse_to_plane_slide_zone_distance_squared(const float co[2],
370 const float slide_zone[2],
371 int width,
372 int height)
373{
374 const float pixel_co[2] = {co[0] * width, co[1] * height};
375 const float pixel_slide_zone[2] = {slide_zone[0] * width, slide_zone[1] * height};
376 return square_f(pixel_co[0] - pixel_slide_zone[0]) + square_f(pixel_co[1] - pixel_slide_zone[1]);
377}
378
380 bContext *C,
381 const float co[2])
382{
383 SpaceClip *space_clip = CTX_wm_space_clip(C);
384
385 int width, height;
386 ED_space_clip_get_size(space_clip, &width, &height);
387 if (width == 0 || height == 0) {
389 }
390
391 MovieClip *clip = ED_space_clip_get_clip(space_clip);
393 const int framenr = ED_space_clip_get_clip_frame_number(space_clip);
394
395 const float distance_tolerance_px_squared = math::square(12.0f / space_clip->zoom *
398
399 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
400 if (options->selected_only && !PLANE_TRACK_VIEW_SELECTED(&plane_track)) {
401 continue;
402 }
403
404 MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(&plane_track, framenr);
405
407 current_pick.plane_track = &plane_track;
408 current_pick.plane_marker = plane_marker;
409
410 for (int i = 0; i < 4; i++) {
412 co, plane_marker->corners[i], width, height);
413
414 if (distance_squared < current_pick.distance_px_squared) {
415 current_pick.corner_index = i;
417 }
418 }
419
420 if (current_pick.distance_px_squared > distance_tolerance_px_squared) {
421 const float zero_offset[2] = {0.0f, 0.0f};
423 co, zero_offset, plane_marker->corners, width, height);
424 if (distance_squared < current_pick.distance_px_squared) {
425 current_pick.corner_index = -1;
427 }
428 }
429
430 if (current_pick.distance_px_squared < pick.distance_px_squared) {
431 pick = current_pick;
432 }
433 }
434
435 if (pick.distance_px_squared > distance_tolerance_px_squared) {
437 }
438
439 return pick;
440}
441
443{
444 if (pick->plane_track == nullptr) {
445 return false;
446 }
447
448 BLI_assert(pick->plane_marker != nullptr);
449
451 return false;
452 }
453
454 return pick->corner_index != -1;
455}
456
458
459/* -------------------------------------------------------------------- */
462
464{
466
467 result.point_track_pick = point_track_pick_make_null();
468 result.plane_track_pick = plane_track_pick_make_null();
469
470 return result;
471}
472
474 const PointTrackPick *point_track_pick,
475 const PlaneTrackPick *plane_track_pick)
476{
477 /* Simple case: one of the pick results is empty, so prefer the other one. */
478 if (point_track_pick->track == nullptr) {
479 return false;
480 }
481 if (plane_track_pick->plane_track == nullptr) {
482 return true;
483 }
484
485 SpaceClip *space_clip = CTX_wm_space_clip(C);
486
487 /* If one of the picks can be slid prefer it. */
488 const bool can_slide_point_track = ed_tracking_point_track_pick_can_slide(space_clip,
489 point_track_pick);
490 const bool can_slide_plane_track = ed_tracking_plane_track_pick_can_slide(plane_track_pick);
491 if (can_slide_point_track && !can_slide_plane_track) {
492 return true;
493 }
494 if (!can_slide_point_track && can_slide_plane_track) {
495 return false;
496 }
497
498 /* Prefer the closest pick. */
499 if (point_track_pick->distance_px_squared > plane_track_pick->distance_px_squared) {
500 return false;
501 }
502 return true;
503}
504
523
525
526/* -------------------------------------------------------------------- */
529
530void ed_tracking_deselect_all_tracks(ListBaseT<MovieTrackingTrack> *tracks_base)
531{
532 for (MovieTrackingTrack &track : *tracks_base) {
534 }
535}
536
537void ed_tracking_deselect_all_plane_tracks(ListBaseT<MovieTrackingPlaneTrack> *plane_tracks_base)
538{
539 for (MovieTrackingPlaneTrack &plane_track : *plane_tracks_base) {
540 plane_track.flag &= ~PLANE_TRACK_SELECT;
541 }
542}
543
545
546/* -------------------------------------------------------------------- */
549
550static bool select_poll(bContext *C)
551{
553
554 if (sc) {
555 return sc->clip && sc->view == SC_VIEW_CLIP;
556 }
557
558 return false;
559}
560
562{
565 MovieTracking *tracking = &clip->tracking;
566 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
567 const bool extend = RNA_boolean_get(op->ptr, "extend");
568 const bool deselect_all = RNA_boolean_get(op->ptr, "deselect_all");
569
570 float co[2];
571 RNA_float_get_array(op->ptr, "location", co);
572
575
576 /* Special code which allows to slide a marker which belongs to currently selected but not yet
577 * active track. If such track is found activate it and return pass-though so that marker slide
578 * operator can be used immediately after.
579 * This logic makes it convenient to slide markers when left mouse selection is used. Without it
580 * selection will be lost which causes inconvenience for the VFX artist. */
581 if (!extend && ed_tracking_pick_can_slide(sc, &pick)) {
582 if (pick.point_track_pick.track != nullptr) {
583 tracking_object->active_track = pick.point_track_pick.track;
584 tracking_object->active_plane_track = nullptr;
585 }
586 else {
587 tracking_object->active_track = nullptr;
588 tracking_object->active_plane_track = pick.plane_track_pick.plane_track;
589 }
590
593
595 }
596
597 ClipViewLockState lock_state;
598 ED_clip_view_lock_state_store(C, &lock_state);
599
600 if (pick.point_track_pick.track != nullptr) {
601 if (!extend) {
603 }
604
606 eTrackArea area = pick.point_track_pick.area;
607
608 if (!extend || !TRACK_VIEW_SELECTED(sc, track)) {
609 area = TRACK_AREA_ALL;
610 }
611
612 if (extend && TRACK_AREA_SELECTED(track, area)) {
613 if (track == tracking_object->active_track) {
614 BKE_tracking_track_deselect(track, area);
615 }
616 else {
617 tracking_object->active_track = track;
618 tracking_object->active_plane_track = nullptr;
619 }
620 }
621 else {
622 if (area == TRACK_AREA_POINT) {
623 area = TRACK_AREA_ALL;
624 }
625
626 BKE_tracking_track_select(&tracking_object->tracks, track, area, extend);
627 tracking_object->active_track = track;
628 tracking_object->active_plane_track = nullptr;
629 }
630 }
631 else if (pick.plane_track_pick.plane_track != nullptr) {
632 if (!extend) {
633 ed_tracking_deselect_all_tracks(&tracking_object->tracks);
634 }
635
637
638 if (PLANE_TRACK_VIEW_SELECTED(plane_track)) {
639 if (extend) {
640 plane_track->flag &= ~PLANE_TRACK_SELECT;
641 }
642 }
643 else {
644 plane_track->flag |= PLANE_TRACK_SELECT;
645 }
646
647 tracking_object->active_track = nullptr;
648 tracking_object->active_plane_track = plane_track;
649 }
650 else if (deselect_all) {
651 ed_tracking_deselect_all_tracks(&tracking_object->tracks);
653 }
654
656
658
661
662 /* Pass-through + finished to allow tweak to transform. */
664}
665
667{
669 ARegion *region = CTX_wm_region(C);
670
671 float co[2];
672 ED_clip_mouse_pos(sc, region, event->mval, co);
673 RNA_float_set_array(op->ptr, "location", co);
674
675 return select_exec(C, op);
676}
677
679{
680 /* identifiers */
681 ot->name = "Select";
682 ot->description = "Select tracking markers";
683 ot->idname = "CLIP_OT_select";
684
685 /* API callbacks. */
686 ot->exec = select_exec;
687 ot->invoke = select_invoke;
688 ot->poll = select_poll;
689
690 /* flags */
691 ot->flag = OPTYPE_UNDO;
692
693 /* properties */
694 PropertyRNA *prop;
695 prop = RNA_def_boolean(ot->srna,
696 "extend",
697 false,
698 "Extend",
699 "Extend selection rather than clearing the existing selection");
701 prop = RNA_def_boolean(ot->srna,
702 "deselect_all",
703 false,
704 "Deselect On Nothing",
705 "Deselect all when nothing under the cursor");
707
709 ot->srna,
710 "location",
711 2,
712 nullptr,
713 -FLT_MAX,
714 FLT_MAX,
715 "Location",
716 "Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds",
717 -100.0f,
718 100.0f);
719}
720
722{
723 /* To avoid conflicts with mask select deselect all in empty space. */
724 return select_poll(C);
725}
726
728
729/* -------------------------------------------------------------------- */
732
734{
736 ARegion *region = CTX_wm_region(C);
737
739 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
740 rcti rect;
741 rctf rectf;
742 bool changed = false;
743 int framenr = ED_space_clip_get_clip_frame_number(sc);
744
745 /* get rectangle from operator */
747
748 ED_clip_point_stable_pos(sc, region, rect.xmin, rect.ymin, &rectf.xmin, &rectf.ymin);
749 ED_clip_point_stable_pos(sc, region, rect.xmax, rect.ymax, &rectf.xmax, &rectf.ymax);
750
751 const eSelectOp sel_op = eSelectOp(RNA_enum_get(op->ptr, "mode"));
752 const bool select = (sel_op != SEL_OP_SUB);
753 if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
754 ED_clip_select_all(sc, SEL_DESELECT, nullptr);
755 changed = true;
756 }
757
758 /* do actual selection */
759 for (MovieTrackingTrack &track : tracking_object->tracks) {
760 if (track.flag & TRACK_HIDDEN) {
761 continue;
762 }
763
764 const MovieTrackingMarker *marker = BKE_tracking_marker_get(&track, framenr);
765
766 if (ED_space_clip_marker_is_visible(sc, tracking_object, &track, marker)) {
767 if (BLI_rctf_isect_pt_v(&rectf, marker->pos)) {
768 if (select) {
770 }
771 else {
773 }
774 }
775 changed = true;
776 }
777 }
778
779 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
780 if (plane_track.flag & PLANE_TRACK_HIDDEN) {
781 continue;
782 }
783
784 const MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(&plane_track,
785 framenr);
786
787 for (int i = 0; i < 4; i++) {
788 if (BLI_rctf_isect_pt_v(&rectf, plane_marker->corners[i])) {
789 if (select) {
790 plane_track.flag |= PLANE_TRACK_SELECT;
791 }
792 else {
793 plane_track.flag &= ~PLANE_TRACK_SELECT;
794 }
795 }
796 }
797 changed = true;
798 }
799
800 if (changed) {
802
805
806 return OPERATOR_FINISHED;
807 }
808
809 return OPERATOR_CANCELLED;
810}
811
813{
814 /* identifiers */
815 ot->name = "Box Select";
816 ot->description = "Select markers using box selection";
817 ot->idname = "CLIP_OT_select_box";
818
819 /* API callbacks. */
821 ot->exec = box_select_exec;
824
825 /* flags */
826 ot->flag = OPTYPE_UNDO;
827
828 /* properties */
831}
832
834
835/* -------------------------------------------------------------------- */
838
839static int do_lasso_select_marker(bContext *C, const Span<int2> mcoords, bool select)
840{
842 ARegion *region = CTX_wm_region(C);
843
845 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
846 rcti rect;
847 bool changed = false;
848 const int framenr = ED_space_clip_get_clip_frame_number(sc);
849
850 /* get rectangle from operator */
851 BLI_lasso_boundbox(&rect, mcoords);
852
853 /* do actual selection */
854 for (MovieTrackingTrack &track : tracking_object->tracks) {
855 if (track.flag & TRACK_HIDDEN) {
856 continue;
857 }
858
859 const MovieTrackingMarker *marker = BKE_tracking_marker_get(&track, framenr);
860
861 if (ED_space_clip_marker_is_visible(sc, tracking_object, &track, marker)) {
862 float screen_co[2];
863
864 /* marker in screen coords */
865 ED_clip_point_stable_pos__reverse(sc, region, marker->pos, screen_co);
866
867 if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&
868 BLI_lasso_is_point_inside(mcoords, screen_co[0], screen_co[1], V2D_IS_CLIPPED))
869 {
870 if (select) {
872 }
873 else {
875 }
876 }
877
878 changed = true;
879 }
880 }
881
882 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
883 if (plane_track.flag & PLANE_TRACK_HIDDEN) {
884 continue;
885 }
886
887 const MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(&plane_track,
888 framenr);
889
890 for (int i = 0; i < 4; i++) {
891 float screen_co[2];
892
893 /* marker in screen coords */
894 ED_clip_point_stable_pos__reverse(sc, region, plane_marker->corners[i], screen_co);
895
896 if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&
897 BLI_lasso_is_point_inside(mcoords, screen_co[0], screen_co[1], V2D_IS_CLIPPED))
898 {
899 if (select) {
900 plane_track.flag |= PLANE_TRACK_SELECT;
901 }
902 else {
903 plane_track.flag &= ~PLANE_TRACK_SELECT;
904 }
905 }
906 }
907
908 changed = true;
909 }
910
911 if (changed) {
913
916 }
917
918 return changed;
919}
920
922{
923 const Array<int2> mcoords = WM_gesture_lasso_path_to_array(C, op);
924
925 if (mcoords.is_empty()) {
927 }
928
929 const eSelectOp sel_op = eSelectOp(RNA_enum_get(op->ptr, "mode"));
930 const bool select = (sel_op != SEL_OP_SUB);
931 if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
933 ED_clip_select_all(sc, SEL_DESELECT, nullptr);
934 }
935
937
938 return OPERATOR_FINISHED;
939}
940
942{
943 /* identifiers */
944 ot->name = "Lasso Select";
945 ot->description = "Select markers using lasso selection";
946 ot->idname = "CLIP_OT_select_lasso";
947
948 /* API callbacks. */
954
955 /* flags */
957
958 /* properties */
961}
962
964
965/* -------------------------------------------------------------------- */
968
969static int point_inside_ellipse(const float point[2],
970 const float offset[2],
971 const float ellipse[2])
972{
973 /* normalized ellipse: ell[0] = scaleX, ell[1] = scaleY */
974 float x, y;
975
976 x = (point[0] - offset[0]) * ellipse[0];
977 y = (point[1] - offset[1]) * ellipse[1];
978
979 return x * x + y * y < 1.0f;
980}
981
983 const float offset[2],
984 const float ellipse[2])
985{
986 return point_inside_ellipse(marker->pos, offset, ellipse);
987}
988
990{
992 ARegion *region = CTX_wm_region(C);
993
995 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
996 int width, height;
997 bool changed = false;
998 float zoomx, zoomy, offset[2], ellipse[2];
999 int framenr = ED_space_clip_get_clip_frame_number(sc);
1000
1001 /* get operator properties */
1002 const int x = RNA_int_get(op->ptr, "x");
1003 const int y = RNA_int_get(op->ptr, "y");
1004 const int radius = RNA_int_get(op->ptr, "radius");
1005
1006 const eSelectOp sel_op = ED_select_op_modal(
1007 eSelectOp(RNA_enum_get(op->ptr, "mode")),
1008 WM_gesture_is_modal_first(static_cast<wmGesture *>(op->customdata)));
1009 const bool select = (sel_op != SEL_OP_SUB);
1010 if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
1011 ED_clip_select_all(sc, SEL_DESELECT, nullptr);
1012 changed = true;
1013 }
1014
1015 /* compute ellipse and position in unified coordinates */
1016 ED_space_clip_get_size(sc, &width, &height);
1017 ED_space_clip_get_zoom(sc, region, &zoomx, &zoomy);
1018
1019 ellipse[0] = width * zoomx / radius;
1020 ellipse[1] = height * zoomy / radius;
1021
1022 ED_clip_point_stable_pos(sc, region, x, y, &offset[0], &offset[1]);
1023
1024 /* do selection */
1025 for (MovieTrackingTrack &track : tracking_object->tracks) {
1026 if (track.flag & TRACK_HIDDEN) {
1027 continue;
1028 }
1029
1030 const MovieTrackingMarker *marker = BKE_tracking_marker_get(&track, framenr);
1031
1032 if (ED_space_clip_marker_is_visible(sc, tracking_object, &track, marker) &&
1033 marker_inside_ellipse(marker, offset, ellipse))
1034 {
1035 if (select) {
1037 }
1038 else {
1040 }
1041 changed = true;
1042 }
1043 }
1044
1045 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
1046 if (plane_track.flag & PLANE_TRACK_HIDDEN) {
1047 continue;
1048 }
1049
1050 const MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(&plane_track,
1051 framenr);
1052
1053 for (int i = 0; i < 4; i++) {
1054 if (point_inside_ellipse(plane_marker->corners[i], offset, ellipse)) {
1055 if (select) {
1056 plane_track.flag |= PLANE_TRACK_SELECT;
1057 }
1058 else {
1059 plane_track.flag &= ~PLANE_TRACK_SELECT;
1060 }
1061 }
1062 }
1063
1064 changed = true;
1065 }
1066
1067 if (changed) {
1069
1072
1073 return OPERATOR_FINISHED;
1074 }
1075
1076 return OPERATOR_CANCELLED;
1077}
1078
1080{
1081 /* identifiers */
1082 ot->name = "Circle Select";
1083 ot->description = "Select markers using circle selection";
1084 ot->idname = "CLIP_OT_select_circle";
1085
1086 /* API callbacks. */
1092
1093 /* flags */
1095
1096 /* properties */
1099}
1100
1102
1103/* -------------------------------------------------------------------- */
1106
1108{
1111 MovieTracking *tracking = &clip->tracking;
1112
1113 const int action = RNA_enum_get(op->ptr, "action");
1114
1115 ClipViewLockState lock_state;
1116 ED_clip_view_lock_state_store(C, &lock_state);
1117
1118 bool has_selection = false;
1119 ED_clip_select_all(sc, action, &has_selection);
1120
1121 if (has_selection) {
1123 }
1124
1126
1129
1130 return OPERATOR_FINISHED;
1131}
1132
1134{
1135 /* identifiers */
1136 ot->name = "(De)select All";
1137 ot->description = "Change selection of all tracking markers";
1138 ot->idname = "CLIP_OT_select_all";
1139
1140 /* API callbacks. */
1141 ot->exec = select_all_exec;
1143
1144 /* flags */
1146
1148}
1149
1151
1152/* -------------------------------------------------------------------- */
1155
1157{
1160 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
1161 const int group = RNA_enum_get(op->ptr, "group");
1162 const int framenr = ED_space_clip_get_clip_frame_number(sc);
1163
1164 for (MovieTrackingTrack &track : tracking_object->tracks) {
1165 bool ok = false;
1166
1167 MovieTrackingMarker *marker = BKE_tracking_marker_get(&track, framenr);
1168
1169 if (group == 0) { /* Keyframed */
1170 ok = marker->framenr == framenr && (marker->flag & MARKER_TRACKED) == 0;
1171 }
1172 else if (group == 1) { /* Estimated */
1173 ok = marker->framenr != framenr;
1174 }
1175 else if (group == 2) { /* tracked */
1176 ok = marker->framenr == framenr && (marker->flag & MARKER_TRACKED);
1177 }
1178 else if (group == 3) { /* locked */
1179 ok = track.flag & TRACK_LOCKED;
1180 }
1181 else if (group == 4) { /* disabled */
1182 ok = marker->flag & MARKER_DISABLED;
1183 }
1184 else if (group == 5) { /* color */
1185 const MovieTrackingTrack *act_track = tracking_object->active_track;
1186
1187 if (act_track) {
1188 ok = (track.flag & TRACK_CUSTOMCOLOR) == (act_track->flag & TRACK_CUSTOMCOLOR);
1189
1190 if (ok && track.flag & TRACK_CUSTOMCOLOR) {
1191 ok = equals_v3v3(track.color, act_track->color);
1192 }
1193 }
1194 }
1195 else if (group == 6) { /* failed */
1196 ok = (track.flag & TRACK_HAS_BUNDLE) == 0;
1197 }
1198
1199 if (ok) {
1200 track.flag |= TRACK_SELECT;
1201 if (sc->flag & SC_SHOW_MARKER_PATTERN) {
1202 track.pat_flag |= TRACK_SELECT;
1203 }
1204 if (sc->flag & SC_SHOW_MARKER_SEARCH) {
1205 track.search_flag |= TRACK_SELECT;
1206 }
1207 }
1208 }
1209
1211
1214
1215 return OPERATOR_FINISHED;
1216}
1217
1219{
1220 static const EnumPropertyItem select_group_items[] = {
1221 {0, "KEYFRAMED", 0, "Keyframed Tracks", "Select all keyframed tracks"},
1222 {1, "ESTIMATED", 0, "Estimated Tracks", "Select all estimated tracks"},
1223 {2, "TRACKED", 0, "Tracked Tracks", "Select all tracked tracks"},
1224 {3, "LOCKED", 0, "Locked Tracks", "Select all locked tracks"},
1225 {4, "DISABLED", 0, "Disabled Tracks", "Select all disabled tracks"},
1226 {5,
1227 "COLOR",
1228 0,
1229 "Tracks with Same Color",
1230 "Select all tracks with same color as active track"},
1231 {6, "FAILED", 0, "Failed Tracks", "Select all tracks which failed to be reconstructed"},
1232 {0, nullptr, 0, nullptr, nullptr},
1233 };
1234
1235 /* identifiers */
1236 ot->name = "Select Grouped";
1237 ot->description = "Select all tracks from specified group";
1238 ot->idname = "CLIP_OT_select_grouped";
1239
1240 /* API callbacks. */
1243
1244 /* flags */
1246
1247 /* properties */
1248 RNA_def_enum(ot->srna, "group", select_group_items, 1, "Group", "Select tracks by group");
1249}
1250
1252
1253} // namespace blender
#define PLANE_TRACK_VIEW_SELECTED(plane_track)
#define TRACK_VIEW_SELECTED(sc, track)
#define TRACK_AREA_SELECTED(track, area)
#define UI_SCALE_FAC
#define SEL_OP_USE_PRE_DESELECT(sel_op)
#define C
Definition RandGen.cpp:29
#define V2D_IS_CLIPPED
Definition UI_view2d.hh:46
#define NC_GEOM
Definition WM_types.hh:406
#define ND_DISPLAY
Definition WM_types.hh:534
#define NC_MOVIECLIP
Definition WM_types.hh:410
#define ND_SELECT
Definition WM_types.hh:551
#define BLI_INLINE
bool is_empty() const
Definition BLI_array.hh:275
CCL_NAMESPACE_BEGIN struct Options options
#define FLT_MAX
float distance_squared(VecT a, VecT b)
T square(const T &a)
BMesh Iterators.
BLI_INLINE TrackingPick tracking_pick_make_null()
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)
std::string ED_select_circle_get_name(wmOperatorType *ot, PointerRNA *ptr)
void ED_space_clip_get_size(const SpaceClip *sc, int *r_width, int *r_height)
void WM_operator_properties_gesture_circle(wmOperatorType *ot)
int RNA_enum_get(PointerRNA *ptr, const char *name)
static void slide_marker_tilt_slider(const float marker_pos[2], const float pattern_corners[4][2], float r_slider[2])
bool BLI_rctf_isect_pt_v(const struct rctf *rect, const float xy[2])
static int do_lasso_select_marker(bContext *C, const Span< int2 > mcoords, bool select)
wmOperatorStatus WM_gesture_box_invoke(bContext *C, wmOperator *op, const wmEvent *event)
static float mouse_to_closest_pattern_edge_distance_squared(const MovieTrackingMarker *marker, const float co[2], int width, int height)
eSelectOp ED_select_op_modal(eSelectOp sel_op, bool is_first)
MINLINE void add_v2_v2v2(float r[2], const float a[2], const float b[2])
static void slide_marker_tilt_slider_relative(const float pattern_corners[4][2], float r_slider[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
static wmOperatorStatus circle_select_exec(bContext *C, wmOperator *op)
void WM_gesture_lasso_cancel(bContext *C, wmOperator *op)
static float mouse_to_tilt_distance_squared(const MovieTrackingMarker *marker, const float co[2], int width, int height)
static wmOperatorStatus select_exec(bContext *C, wmOperator *op)
SpaceClip * CTX_wm_space_clip(const bContext *C)
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_select_grouped(wmOperatorType *ot)
void ED_clip_point_stable_pos__reverse(const SpaceClip *sc, const ARegion *region, const float co[2], float r_co[2])
the reverse of ED_clip_point_stable_pos(), gets the marker region coords. better name here?...
int RNA_int_get(PointerRNA *ptr, const char *name)
void ED_clip_point_stable_pos(const SpaceClip *sc, const ARegion *region, float x, float y, float *xr, float *yr)
wmOperatorStatus WM_gesture_lasso_modal(bContext *C, wmOperator *op, const wmEvent *event)
BLI_INLINE PointTrackPick point_track_pick_make_null()
static float mouse_to_slide_zone_distance_squared(const float co[2], const float slide_zone[2], int width, int height)
bool BLI_lasso_is_point_inside(Span< int2 > mcoords, int sx, int sy, int error_value)
Definition lasso_2d.cc:42
void ED_clip_view_lock_state_restore_no_jump(const bContext *C, const ClipViewLockState *state)
void ed_tracking_deselect_all_tracks(ListBaseT< MovieTrackingTrack > *tracks_base)
void WM_operator_properties_select_all(wmOperatorType *ot)
void CLIP_OT_select_lasso(wmOperatorType *ot)
BLI_INLINE bool ED_space_clip_marker_is_visible(const SpaceClip *space_clip, const MovieTrackingObject *tracking_object, const MovieTrackingTrack *track, const MovieTrackingMarker *marker)
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
float dist_squared_to_line_segment_v2(const float p[2], const float l1[2], const float l2[2])
Definition math_geom.cc:307
static wmOperatorStatus clip_lasso_select_exec(bContext *C, wmOperator *op)
MINLINE bool equals_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
PointTrackPick ed_tracking_pick_point_track(const TrackPickOptions *options, bContext *C, const float co[2])
static float mouse_to_closest_pattern_corner_distance_squared(const MovieTrackingMarker *marker, const float co[2], int width, int height, int *r_corner)
bool ed_tracking_point_track_pick_can_slide(const SpaceClip *space_clip, const PointTrackPick *pick)
MINLINE void add_v2_v2(float r[2], const float a[2])
bool ED_clip_can_select(bContext *C)
void DEG_id_tag_update(ID *id, unsigned int flags)
BLI_INLINE TrackPickOptions ed_tracking_pick_options_defaults()
int ED_space_clip_get_clip_frame_number(const SpaceClip *sc)
void WM_operator_properties_border_to_rcti(wmOperator *op, rcti *r_rect)
wmOperatorStatus WM_gesture_circle_invoke(bContext *C, wmOperator *op, const wmEvent *event)
void WM_operator_properties_gesture_box(wmOperatorType *ot)
static float mouse_to_offset_distance_squared(const MovieTrackingTrack *track, const MovieTrackingMarker *marker, const float co[2], int width, int height)
static wmOperatorStatus select_all_exec(bContext *C, wmOperator *op)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void CLIP_OT_select(wmOperatorType *ot)
static bool tracking_should_prefer_point_track(bContext *C, const PointTrackPick *point_track_pick, const PlaneTrackPick *plane_track_pick)
void ED_clip_mouse_pos(const SpaceClip *sc, const ARegion *region, const int mval[2], float r_co[2])
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
@ TRACK_AREA_NONE
@ TRACK_AREA_SEARCH
@ TRACK_AREA_POINT
void CLIP_OT_select_all(wmOperatorType *ot)
BLI_INLINE PlaneTrackPick plane_track_pick_make_null()
PlaneTrackPick ed_tracking_pick_plane_track(const TrackPickOptions *options, struct bContext *C, const float co[2])
static int marker_inside_ellipse(const MovieTrackingMarker *marker, const float offset[2], const float ellipse[2])
wmOperatorStatus WM_gesture_box_modal(bContext *C, wmOperator *op, const wmEvent *event)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
static wmOperatorStatus select_grouped_exec(bContext *C, wmOperator *op)
wmOperatorStatus WM_gesture_lasso_invoke(bContext *C, wmOperator *op, const wmEvent *event)
bool ed_tracking_plane_track_pick_can_slide(const PlaneTrackPick *pick)
MovieClip * ED_space_clip_get_clip(const SpaceClip *sc)
void ED_clip_select_all(const SpaceClip *sc, int action, bool *r_has_selection)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1796
@ ID_RECALC_SELECT
Definition DNA_ID.h:1101
@ PROP_SKIP_SAVE
Definition RNA_types.hh:414
Array< int2 > WM_gesture_lasso_path_to_array(bContext *, wmOperator *op)
MINLINE float square_f(float a)
static float mouse_to_closest_search_edge_distance_squared(const MovieTrackingMarker *marker, const float co[2], int width, int height)
bool ED_space_clip_tracking_poll(bContext *C)
static bool select_poll(bContext *C)
void WM_operator_properties_select_operation_simple(wmOperatorType *ot)
static float mouse_to_search_corner_distance_squared(const MovieTrackingMarker *marker, const float co[2], int corner, int width, int height)
BLI_INLINE bool ed_tracking_pick_can_slide(const SpaceClip *space_clip, const TrackingPick *pick)
void BKE_tracking_track_flag_set(MovieTrackingTrack *track, eTrackArea area, TrackingTrackFlag flag)
Definition tracking.cc:677
void ed_tracking_deselect_all_plane_tracks(ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base)
void BKE_tracking_track_deselect(MovieTrackingTrack *track, eTrackArea area)
Definition tracking.cc:1222
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
@ OPTYPE_DEPENDS_ON_CURSOR
Definition WM_types.hh:228
bool BLI_rcti_isect_pt(const struct rcti *rect, int x, int y)
void ED_clip_view_lock_state_store(const bContext *C, ClipViewLockState *state)
static wmOperatorStatus select_invoke(bContext *C, wmOperator *op, const wmEvent *event)
bool WM_gesture_is_modal_first(const wmGesture *gesture)
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
void CLIP_OT_select_box(wmOperatorType *ot)
wmOperatorStatus WM_gesture_circle_modal(bContext *C, wmOperator *op, const wmEvent *event)
@ TRACK_PICK_AREA_DETAIL_TILT_SIZE
@ TRACK_PICK_AREA_DETAIL_POSITION
@ TRACK_PICK_AREA_DETAIL_OFFSET
ARegion * CTX_wm_region(const bContext *C)
void ED_space_clip_get_zoom(const SpaceClip *sc, const ARegion *region, float *r_zoomx, float *r_zoomy)
static int point_inside_ellipse(const float point[2], const float offset[2], const float ellipse[2])
void BLI_lasso_boundbox(rcti *rect, Span< int2 > mcoords)
Definition lasso_2d.cc:21
static float mouse_to_plane_slide_zone_distance_squared(const float co[2], const float slide_zone[2], int width, int height)
void CLIP_OT_select_circle(wmOperatorType *ot)
void BKE_tracking_track_flag_clear(MovieTrackingTrack *track, eTrackArea area, TrackingTrackFlag flag)
Definition tracking.cc:696
void RNA_float_get_array(PointerRNA *ptr, const char *name, float *values)
static float mouse_to_closest_corners_edge_distance_squared(const float co[2], const float corners_offset[2], const float corners[4][2], int width, int height)
TrackingPick ed_tracking_pick_closest(const TrackPickOptions *options, bContext *C, const float co[2])
void BKE_tracking_track_select(ListBaseT< MovieTrackingTrack > *tracksbase, MovieTrackingTrack *track, eTrackArea area, bool extend)
Definition tracking.cc:1195
void WM_operator_properties_gesture_lasso(wmOperatorType *ot)
static wmOperatorStatus box_select_exec(bContext *C, wmOperator *op)
MovieTrackingMarker * BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1363
struct MovieTracking tracking
MovieTrackingPlaneTrack * active_plane_track
ListBaseT< MovieTrackingTrack > tracks
ListBaseT< MovieTrackingPlaneTrack > plane_tracks
MovieTrackingTrack * active_track
MovieTrackingPlaneMarker * plane_marker
MovieTrackingPlaneTrack * plane_track
eTrackPickAreaDetail area_detail
MovieTrackingMarker * marker
MovieTrackingTrack * track
struct MovieClip * clip
eSpaceClip_Flag flag
eSpaceClip_View view
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
void(*) cancel(bContext *C, wmOperator *op)
Definition WM_types.hh:1149
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
std::string(*) get_name(wmOperatorType *ot, PointerRNA *ptr)
Definition WM_types.hh:1191