← Back to branch summary

~ubuntu-branches/ubuntu/utopic/blender/utopic-proposed

« back to all changes in this revision

Viewing changes to source/blender/editors/space_clip/tracking_select.c

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2014-02-19 11:24:23 UTC
  • mfrom: (14.2.23 sid)
  • Revision ID: package-import@ubuntu.com-20140219112423-rkmaz2m7ha06d4tk
Tags: 2.69-3ubuntu1
* Merge with Debian; remaining changes:
  - Configure without OpenImageIO on armhf, as it is not available on
    Ubuntu.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/editors/space_clip/tracking_select.c
169
169
        return sqrtf(min_ffff(d1, d2, d3, d4));
170
170
}
171
171
 
 
172
/* Distance to quad defined by it's corners, corners are relative to pos */
172
173
static float dist_to_crns(float co[2], float pos[2], float crns[4][2])
173
174
{
174
175
        float d1, d2, d3, d4;
184
185
        return sqrtf(min_ffff(d1, d2, d3, d4));
185
186
}
186
187
 
187
 
static MovieTrackingTrack *find_nearest_track(SpaceClip *sc, ListBase *tracksbase, float co[2])
 
188
/* Same as above, but all the coordinates are absolute */
 
189
static float dist_to_crns_abs(float co[2], float corners[4][2])
 
190
{
 
191
        float d1, d2, d3, d4;
 
192
        float *v1 = corners[0], *v2 = corners[1];
 
193
        float *v3 = corners[2], *v4 = corners[3];
 
194
 
 
195
        d1 = dist_squared_to_line_segment_v2(co, v1, v2);
 
196
        d2 = dist_squared_to_line_segment_v2(co, v2, v3);
 
197
        d3 = dist_squared_to_line_segment_v2(co, v3, v4);
 
198
        d4 = dist_squared_to_line_segment_v2(co, v4, v1);
 
199
 
 
200
        return sqrtf(min_ffff(d1, d2, d3, d4));
 
201
}
 
202
 
 
203
static MovieTrackingTrack *find_nearest_track(SpaceClip *sc, ListBase *tracksbase, float co[2], float *distance_r)
188
204
{
189
205
        MovieTrackingTrack *track = NULL, *cur;
190
206
        float mindist = 0.0f;
221
237
                cur = cur->next;
222
238
        }
223
239
 
 
240
        *distance_r = mindist;
 
241
 
224
242
        return track;
225
243
}
226
244
 
 
245
static MovieTrackingPlaneTrack *find_nearest_plane_track(SpaceClip *sc, ListBase *plane_tracks_base,
 
246
                                                         float co[2], float *distance_r)
 
247
{
 
248
        MovieTrackingPlaneTrack *plane_track = NULL, *current_plane_track;
 
249
        float min_distance = 0.0f;
 
250
        int framenr = ED_space_clip_get_clip_frame_number(sc);
 
251
 
 
252
        for (current_plane_track = plane_tracks_base->first;
 
253
             current_plane_track;
 
254
             current_plane_track = current_plane_track->next)
 
255
        {
 
256
                MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(current_plane_track, framenr);
 
257
 
 
258
                if ((current_plane_track->flag & TRACK_HIDDEN) == 0) {
 
259
                        float distance = dist_to_crns_abs(co, plane_marker->corners);
 
260
                        if (plane_track == NULL || distance < min_distance) {
 
261
                                plane_track = current_plane_track;
 
262
                                min_distance = distance;
 
263
                        }
 
264
                }
 
265
        }
 
266
 
 
267
        *distance_r = min_distance;
 
268
 
 
269
        return plane_track;
 
270
}
 
271
 
 
272
static void delect_all_tracks(ListBase *tracks_base)
 
273
{
 
274
        MovieTrackingTrack *track;
 
275
        for (track = tracks_base->first;
 
276
             track;
 
277
             track = track->next)
 
278
        {
 
279
                BKE_tracking_track_flag_clear(track, TRACK_AREA_ALL, SELECT);
 
280
        }
 
281
}
 
282
 
 
283
static void delect_all_plane_tracks(ListBase *plane_tracks_base)
 
284
{
 
285
        MovieTrackingPlaneTrack *plane_track;
 
286
        for (plane_track = plane_tracks_base->first;
 
287
             plane_track;
 
288
             plane_track = plane_track->next)
 
289
        {
 
290
                plane_track->flag &= ~SELECT;
 
291
        }
 
292
}
 
293
 
227
294
static int mouse_select(bContext *C, float co[2], int extend)
228
295
{
229
296
        SpaceClip *sc = CTX_wm_space_clip(C);
230
297
        MovieClip *clip = ED_space_clip_get_clip(sc);
231
298
        MovieTracking *tracking = &clip->tracking;
232
299
        ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
 
300
        ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
233
301
        MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
234
 
        MovieTrackingTrack *track = NULL;   /* selected marker */
235
 
 
236
 
        track = find_nearest_track(sc, tracksbase, co);
 
302
        MovieTrackingTrack *track;
 
303
        MovieTrackingPlaneTrack *plane_track;
 
304
        float distance_to_track, distance_to_plane_track;
 
305
 
 
306
        track = find_nearest_track(sc, tracksbase, co, &distance_to_track);
 
307
        plane_track = find_nearest_plane_track(sc, plane_tracks_base, co, &distance_to_plane_track);
 
308
 
 
309
        /* Between track and plane we choose closest to the mouse for selection here. */
 
310
        if (track && plane_track) {
 
311
                if (distance_to_track < distance_to_plane_track) {
 
312
                        plane_track = NULL;
 
313
                }
 
314
                else {
 
315
                        track = NULL;
 
316
                }
 
317
        }
 
318
 
 
319
        if (!extend) {
 
320
                delect_all_plane_tracks(plane_tracks_base);
 
321
        }
237
322
 
238
323
        if (track) {
239
324
                int area = track_mouse_area(C, co, track);
242
327
                        area = TRACK_AREA_ALL;
243
328
 
244
329
                if (extend && TRACK_AREA_SELECTED(track, area)) {
245
 
                        if (track == act_track)
 
330
                        if (track == act_track) {
246
331
                                BKE_tracking_track_deselect(track, area);
247
 
                        else
 
332
                        }
 
333
                        else {
248
334
                                clip->tracking.act_track = track;
 
335
                                clip->tracking.act_plane_track = NULL;
 
336
                        }
249
337
                }
250
338
                else {
251
339
                        if (area == TRACK_AREA_POINT)
253
341
 
254
342
                        BKE_tracking_track_select(tracksbase, track, area, extend);
255
343
                        clip->tracking.act_track = track;
256
 
                }
 
344
                        clip->tracking.act_plane_track = NULL;
 
345
                }
 
346
        }
 
347
        else if (plane_track) {
 
348
                if (!extend) {
 
349
                        delect_all_tracks(tracksbase);
 
350
                }
 
351
 
 
352
                if (plane_track->flag & SELECT) {
 
353
                        if (extend) {
 
354
                                plane_track->flag &= ~SELECT;
 
355
                        }
 
356
                }
 
357
                else {
 
358
                        plane_track->flag |= SELECT;
 
359
                }
 
360
 
 
361
                clip->tracking.act_track = NULL;
 
362
                clip->tracking.act_plane_track = plane_track;
257
363
        }
258
364
 
259
365
        if (!extend) {
350
456
        MovieClip *clip = ED_space_clip_get_clip(sc);
351
457
        MovieTracking *tracking = &clip->tracking;
352
458
        MovieTrackingTrack *track;
 
459
        MovieTrackingPlaneTrack *plane_track;
353
460
        ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
 
461
        ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
354
462
        rcti rect;
355
463
        rctf rectf;
356
 
        int change = FALSE, mode, extend;
 
464
        bool change = false;
 
465
        int mode, extend;
357
466
        int framenr = ED_space_clip_get_clip_frame_number(sc);
358
467
 
359
468
        /* get rectangle from operator */
382
491
                                        BKE_tracking_track_flag_clear(track, TRACK_AREA_ALL, SELECT);
383
492
                                }
384
493
 
385
 
                                change = TRUE;
 
494
                                change = true;
386
495
                        }
387
496
                }
388
497
 
389
498
                track = track->next;
390
499
        }
391
500
 
 
501
        for (plane_track = plane_tracks_base->first;
 
502
             plane_track;
 
503
             plane_track = plane_track->next)
 
504
        {
 
505
                if ((plane_track->flag & PLANE_TRACK_HIDDEN) == 0) {
 
506
                        MovieTrackingPlaneMarker *plane_marker =
 
507
                                BKE_tracking_plane_marker_get(plane_track, framenr);
 
508
                        int i;
 
509
 
 
510
                        for (i = 0; i < 4; i++) {
 
511
                                if (BLI_rctf_isect_pt_v(&rectf, plane_marker->corners[i])) {
 
512
                                        if (mode == GESTURE_MODAL_SELECT) {
 
513
                                                plane_track->flag |= SELECT;
 
514
                                        }
 
515
                                        else {
 
516
                                                plane_track->flag &= ~SELECT;
 
517
                                        }
 
518
                                }
 
519
                                else if (!extend) {
 
520
                                        plane_track->flag &= ~SELECT;
 
521
                                }
 
522
                        }
 
523
 
 
524
                        change = true;
 
525
                }
 
526
        }
 
527
 
392
528
        if (change) {
393
529
                BKE_tracking_dopesheet_tag_update(tracking);
394
530
 
430
566
        MovieClip *clip = ED_space_clip_get_clip(sc);
431
567
        MovieTracking *tracking = &clip->tracking;
432
568
        MovieTrackingTrack *track;
 
569
        MovieTrackingPlaneTrack *plane_track;
433
570
        ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
 
571
        ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
434
572
        rcti rect;
435
 
        int change = FALSE;
 
573
        bool change = false;
436
574
        int framenr = ED_space_clip_get_clip_frame_number(sc);
437
575
 
438
576
        /* get rectangle from operator */
459
597
                                                BKE_tracking_track_flag_clear(track, TRACK_AREA_ALL, SELECT);
460
598
                                }
461
599
 
462
 
                                change = TRUE;
 
600
                                change = true;
463
601
                        }
464
602
                }
465
603
 
466
604
                track = track->next;
467
605
        }
468
606
 
 
607
        for (plane_track = plane_tracks_base->first;
 
608
             plane_track;
 
609
             plane_track = plane_track->next)
 
610
        {
 
611
                if ((plane_track->flag & PLANE_TRACK_HIDDEN) == 0) {
 
612
                        MovieTrackingPlaneMarker *plane_marker =
 
613
                                BKE_tracking_plane_marker_get(plane_track, framenr);
 
614
                        int i;
 
615
 
 
616
                        for (i = 0; i < 4; i++) {
 
617
                                float screen_co[2];
 
618
 
 
619
                                /* marker in screen coords */
 
620
                                ED_clip_point_stable_pos__reverse(sc, ar, plane_marker->corners[i], screen_co);
 
621
 
 
622
                                if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&
 
623
                                    BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], V2D_IS_CLIPPED))
 
624
                                {
 
625
                                        if (select) {
 
626
                                                plane_track->flag |= SELECT;
 
627
                                        }
 
628
                                        else {
 
629
                                                plane_track->flag &= ~SELECT;
 
630
                                        }
 
631
                                }
 
632
                        }
 
633
 
 
634
                        change = true;
 
635
                }
 
636
        }
 
637
 
469
638
        if (change) {
470
639
                BKE_tracking_dopesheet_tag_update(tracking);
471
640
 
518
687
 
519
688
/********************** circle select operator *********************/
520
689
 
521
 
static int marker_inside_ellipse(MovieTrackingMarker *marker, float offset[2], float ellipse[2])
 
690
static int point_inside_ellipse(float point[2], float offset[2], float ellipse[2])
522
691
{
523
692
        /* normalized ellipse: ell[0] = scaleX, ell[1] = scaleY */
524
693
        float x, y;
525
694
 
526
 
        x = (marker->pos[0] - offset[0]) * ellipse[0];
527
 
        y = (marker->pos[1] - offset[1]) * ellipse[1];
 
695
        x = (point[0] - offset[0]) * ellipse[0];
 
696
        y = (point[1] - offset[1]) * ellipse[1];
528
697
 
529
698
        return x * x + y * y < 1.0f;
530
699
}
531
700
 
 
701
static int marker_inside_ellipse(MovieTrackingMarker *marker, float offset[2], float ellipse[2])
 
702
{
 
703
        return point_inside_ellipse(marker->pos, offset, ellipse);
 
704
}
 
705
 
532
706
static int circle_select_exec(bContext *C, wmOperator *op)
533
707
{
534
708
        SpaceClip *sc = CTX_wm_space_clip(C);
537
711
        MovieClip *clip = ED_space_clip_get_clip(sc);
538
712
        MovieTracking *tracking = &clip->tracking;
539
713
        MovieTrackingTrack *track;
 
714
        MovieTrackingPlaneTrack *plane_track;
540
715
        ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
541
 
        int x, y, radius, width, height, mode, change = FALSE;
 
716
        ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
 
717
        int x, y, radius, width, height, mode;
 
718
        bool change = false;
542
719
        float zoomx, zoomy, offset[2], ellipse[2];
543
720
        int framenr = ED_space_clip_get_clip_frame_number(sc);
544
721
 
570
747
                                else
571
748
                                        BKE_tracking_track_flag_clear(track, TRACK_AREA_ALL, SELECT);
572
749
 
573
 
                                change = TRUE;
 
750
                                change = true;
574
751
                        }
575
752
                }
576
753
 
577
754
                track = track->next;
578
755
        }
579
756
 
 
757
        for (plane_track = plane_tracks_base->first;
 
758
             plane_track;
 
759
             plane_track = plane_track->next)
 
760
        {
 
761
                if ((plane_track->flag & PLANE_TRACK_HIDDEN) == 0) {
 
762
                        MovieTrackingPlaneMarker *plane_marker =
 
763
                                BKE_tracking_plane_marker_get(plane_track, framenr);
 
764
                        int i;
 
765
 
 
766
                        for (i = 0; i < 4; i++) {
 
767
                                if (point_inside_ellipse(plane_marker->corners[i], offset, ellipse)) {
 
768
                                        if (mode == GESTURE_MODAL_SELECT) {
 
769
                                                plane_track->flag |= SELECT;
 
770
                                        }
 
771
                                        else {
 
772
                                                plane_track->flag &= ~SELECT;
 
773
                                        }
 
774
                                }
 
775
                        }
 
776
 
 
777
                        change = true;
 
778
                }
 
779
        }
 
780
 
580
781
        if (change) {
581
782
                BKE_tracking_dopesheet_tag_update(tracking);
582
783
 
619
820
        MovieClip *clip = ED_space_clip_get_clip(sc);
620
821
        MovieTracking *tracking = &clip->tracking;
621
822
        MovieTrackingTrack *track = NULL;   /* selected track */
 
823
        MovieTrackingPlaneTrack *plane_track = NULL;   /* selected plane track */
622
824
        MovieTrackingMarker *marker;
623
825
        ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
 
826
        ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
624
827
        int action = RNA_enum_get(op->ptr, "action");
625
828
        int framenr = ED_space_clip_get_clip_frame_number(sc);
626
 
        int has_selection = FALSE;
 
829
        bool has_selection = false;
627
830
 
628
831
        if (action == SEL_TOGGLE) {
629
832
                action = SEL_SELECT;
630
 
                track = tracksbase->first;
631
 
                while (track) {
 
833
 
 
834
                for (track = tracksbase->first; track; track = track->next) {
632
835
                        if (TRACK_VIEW_SELECTED(sc, track)) {
633
836
                                marker = BKE_tracking_marker_get(track, framenr);
634
837
 
637
840
                                        break;
638
841
                                }
639
842
                        }
 
843
                }
640
844
 
641
 
                        track = track->next;
 
845
                for (plane_track = plane_tracks_base->first;
 
846
                     plane_track;
 
847
                     plane_track = plane_track->next)
 
848
                {
 
849
                        if (plane_track->flag & SELECT) {
 
850
                                action = SEL_DESELECT;
 
851
                                break;
 
852
                        }
642
853
                }
643
854
        }
644
855
 
645
 
        track = tracksbase->first;
646
 
        while (track) {
 
856
        for (track = tracksbase->first; track; track = track->next) {
647
857
                if ((track->flag & TRACK_HIDDEN) == 0) {
648
858
                        marker = BKE_tracking_marker_get(track, framenr);
649
859
 
669
879
                }
670
880
 
671
881
                if (TRACK_VIEW_SELECTED(sc, track))
672
 
                        has_selection = TRUE;
673
 
 
674
 
                track = track->next;
 
882
                        has_selection = true;
 
883
        }
 
884
 
 
885
        for (plane_track = plane_tracks_base->first;
 
886
             plane_track;
 
887
             plane_track = plane_track->next)
 
888
        {
 
889
                if ((plane_track->flag & PLANE_TRACK_HIDDEN) == 0) {
 
890
                        switch (action) {
 
891
                                case SEL_SELECT:
 
892
                                        plane_track->flag |= SELECT;
 
893
                                        break;
 
894
                                case SEL_DESELECT:
 
895
                                        plane_track->flag &= ~SELECT;
 
896
                                        break;
 
897
                                case SEL_INVERT:
 
898
                                        plane_track->flag ^= SELECT;
 
899
                                        break;
 
900
                        }
 
901
                }
 
902
 
 
903
                if (plane_track->flag & SELECT) {
 
904
                        has_selection = true;
 
905
                }
675
906
        }
676
907
 
677
908
        if (!has_selection)
716
947
 
717
948
        track = tracksbase->first;
718
949
        while (track) {
719
 
                int ok = FALSE;
 
950
                bool ok = false;
720
951
 
721
952
                marker = BKE_tracking_marker_get(track, framenr);
722
953