← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty-proposed

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2013-08-14 10:43:49 UTC
  • mfrom: (14.2.19 sid)
  • Revision ID: package-import@ubuntu.com-20130814104349-t1d5mtwkphp12dyj
Tags: 2.68a-3
* Upload to unstable
* debian/: python3.3 Depends simplified
  - debian/control: python3.3 Depends dropped
    for blender-data package
  - 0001-blender_thumbnailer.patch refreshed
* debian/control: libavcodec b-dep versioning dropped

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/editors/space_clip/tracking_ops.c
72
72
#include "RNA_access.h"
73
73
#include "RNA_define.h"
74
74
 
 
75
#include "BLF_translation.h"
 
76
 
75
77
#include "PIL_time.h"
76
78
 
77
79
#include "UI_view2d.h"
80
82
 
81
83
/********************** add marker operator *********************/
82
84
 
83
 
static void add_marker(const bContext *C, float x, float y)
 
85
static bool add_marker(const bContext *C, float x, float y)
84
86
{
85
87
        SpaceClip *sc = CTX_wm_space_clip(C);
86
88
        MovieClip *clip = ED_space_clip_get_clip(sc);
92
94
 
93
95
        ED_space_clip_get_size(sc, &width, &height);
94
96
 
 
97
        if (width == 0 || height == 0) {
 
98
                return false;
 
99
        }
 
100
 
95
101
        track = BKE_tracking_track_add(tracking, tracksbase, x, y, framenr, width, height);
96
102
 
97
103
        BKE_tracking_track_select(tracksbase, track, TRACK_AREA_ALL, 0);
98
104
 
99
105
        clip->tracking.act_track = track;
 
106
 
 
107
        return true;
100
108
}
101
109
 
102
110
static int add_marker_exec(bContext *C, wmOperator *op)
104
112
        SpaceClip *sc = CTX_wm_space_clip(C);
105
113
        MovieClip *clip = ED_space_clip_get_clip(sc);
106
114
        float pos[2];
107
 
        int width, height;
108
 
 
109
 
        ED_space_clip_get_size(sc, &width, &height);
110
 
 
111
 
        if (!width || !height)
112
 
                return OPERATOR_CANCELLED;
113
115
 
114
116
        RNA_float_get_array(op->ptr, "location", pos);
115
117
 
116
 
        add_marker(C, pos[0], pos[1]);
 
118
        if (!add_marker(C, pos[0], pos[1])) {
 
119
                return OPERATOR_CANCELLED;
 
120
        }
117
121
 
118
122
        /* reset offset from locked position, so frame jumping wouldn't be so confusing */
119
123
        sc->xlockof = 0;
124
128
        return OPERATOR_FINISHED;
125
129
}
126
130
 
127
 
static int add_marker_invoke(bContext *C, wmOperator *op, wmEvent *event)
 
131
static int add_marker_invoke(bContext *C, wmOperator *op, const wmEvent *event)
128
132
{
129
133
        SpaceClip *sc = CTX_wm_space_clip(C);
130
134
        ARegion *ar = CTX_wm_region(C);
131
135
 
132
 
        float co[2];
133
 
 
134
 
        ED_clip_mouse_pos(sc, ar, event->mval, co);
135
 
 
136
 
        RNA_float_set_array(op->ptr, "location", co);
 
136
        if (!RNA_struct_property_is_set(op->ptr, "location")) {
 
137
                /* If location is not set, use mouse positio nas default. */
 
138
                float co[2];
 
139
                ED_clip_mouse_pos(sc, ar, event->mval, co);
 
140
                RNA_float_set_array(op->ptr, "location", co);
 
141
        }
137
142
 
138
143
        return add_marker_exec(C, op);
139
144
}
158
163
                             "Location", "Location of marker on frame", -1.0f, 1.0f);
159
164
}
160
165
 
 
166
/********************** add marker operator *********************/
 
167
 
 
168
static int add_marker_at_click_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
 
169
{
 
170
        ED_area_headerprint(CTX_wm_area(C), IFACE_("Use LMB click to define location where place the marker"));
 
171
 
 
172
        /* add modal handler for ESC */
 
173
        WM_event_add_modal_handler(C, op);
 
174
 
 
175
        return OPERATOR_RUNNING_MODAL;
 
176
}
 
177
 
 
178
static int add_marker_at_click_modal(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
 
179
{
 
180
        SpaceClip *sc = CTX_wm_space_clip(C);
 
181
        MovieClip *clip = ED_space_clip_get_clip(sc);
 
182
        ARegion *ar = CTX_wm_region(C);
 
183
        float pos[2];
 
184
 
 
185
        switch (event->type) {
 
186
                case MOUSEMOVE:
 
187
                        return OPERATOR_RUNNING_MODAL;
 
188
                        break;
 
189
 
 
190
                case LEFTMOUSE:
 
191
                        ED_area_headerprint(CTX_wm_area(C), NULL);
 
192
 
 
193
                        ED_clip_point_stable_pos(sc, ar,
 
194
                                                 event->x - ar->winrct.xmin,
 
195
                                                 event->y - ar->winrct.ymin,
 
196
                                                 &pos[0], &pos[1]);
 
197
 
 
198
                        if (!add_marker(C, pos[0], pos[1]))
 
199
                                return OPERATOR_CANCELLED;
 
200
 
 
201
                        WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip);
 
202
                        return OPERATOR_FINISHED;
 
203
                        break;
 
204
 
 
205
                case ESCKEY:
 
206
                        ED_area_headerprint(CTX_wm_area(C), NULL);
 
207
                        return OPERATOR_CANCELLED;
 
208
        }
 
209
 
 
210
        return OPERATOR_PASS_THROUGH;
 
211
}
 
212
 
 
213
void CLIP_OT_add_marker_at_click(wmOperatorType *ot)
 
214
{
 
215
        /* identifiers */
 
216
        ot->name = "Add Marker at Click";
 
217
        ot->idname = "CLIP_OT_add_marker_at_click";
 
218
        ot->description = "Place new marker at the desired (clicked) position";
 
219
 
 
220
        /* api callbacks */
 
221
        ot->invoke = add_marker_at_click_invoke;
 
222
        ot->poll = ED_space_clip_tracking_poll;
 
223
        ot->modal = add_marker_at_click_modal;
 
224
 
 
225
        /* flags */
 
226
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING;
 
227
}
 
228
 
161
229
/********************** delete track operator *********************/
162
230
 
163
231
static int delete_track_exec(bContext *C, wmOperator *UNUSED(op))
282
350
}
283
351
 
284
352
static SlideMarkerData *create_slide_marker_data(SpaceClip *sc, MovieTrackingTrack *track,
285
 
                                                 MovieTrackingMarker *marker, wmEvent *event,
 
353
                                                 MovieTrackingMarker *marker, const wmEvent *event,
286
354
                                                 int area, int corner, int action, int width, int height)
287
355
{
288
356
        SlideMarkerData *data = MEM_callocN(sizeof(SlideMarkerData), "slide marker data");
352
420
                               float padding, int width, int height)
353
421
{
354
422
        const float size = 12.0f;
355
 
        int inside = 0;
356
423
        float min[2], max[2];
357
424
        float dx, dy;
358
425
 
377
444
 
378
445
        return IN_RANGE_INCL(co[0], slide_zone[0] - dx, slide_zone[0] + dx) &&
379
446
               IN_RANGE_INCL(co[1], slide_zone[1] - dy, slide_zone[1] + dy);
380
 
 
381
 
        return inside;
382
447
}
383
448
 
384
449
static int mouse_on_corner(SpaceClip *sc, MovieTrackingMarker *marker,
524
589
        WM_cursor_set(win, CURSOR_STD);
525
590
}
526
591
 
527
 
MovieTrackingTrack *tracking_marker_check_slide(bContext *C, wmEvent *event, int *area_r, int *action_r, int *corner_r)
 
592
MovieTrackingTrack *tracking_marker_check_slide(bContext *C, const wmEvent *event, int *area_r, int *action_r, int *corner_r)
528
593
{
529
594
        SpaceClip *sc = CTX_wm_space_clip(C);
530
595
        ARegion *ar = CTX_wm_region(C);
623
688
        return NULL;
624
689
}
625
690
 
626
 
static void *slide_marker_customdata(bContext *C, wmEvent *event)
 
691
static void *slide_marker_customdata(bContext *C, const wmEvent *event)
627
692
{
628
693
        SpaceClip *sc = CTX_wm_space_clip(C);
629
694
        ARegion *ar = CTX_wm_region(C);
652
717
        return customdata;
653
718
}
654
719
 
655
 
static int slide_marker_invoke(bContext *C, wmOperator *op, wmEvent *event)
 
720
static int slide_marker_invoke(bContext *C, wmOperator *op, const wmEvent *event)
656
721
{
657
722
        SlideMarkerData *slidedata = slide_marker_customdata(C, event);
658
723
 
703
768
        MEM_freeN(data);
704
769
}
705
770
 
706
 
static int slide_marker_modal(bContext *C, wmOperator *op, wmEvent *event)
 
771
static int slide_marker_modal(bContext *C, wmOperator *op, const wmEvent *event)
707
772
{
708
773
        SpaceClip *sc = CTX_wm_space_clip(C);
709
774
        ARegion *ar = CTX_wm_region(C);
1228
1293
        return OPERATOR_FINISHED;
1229
1294
}
1230
1295
 
1231
 
static int track_markers_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 
1296
static int track_markers_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1232
1297
{
1233
1298
        TrackMarkersJob *tmj;
1234
1299
        ScrArea *sa = CTX_wm_area(C);
1286
1351
        return OPERATOR_RUNNING_MODAL;
1287
1352
}
1288
1353
 
1289
 
static int track_markers_modal(bContext *C, wmOperator *UNUSED(op), wmEvent *event)
 
1354
static int track_markers_modal(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
1290
1355
{
1291
1356
        /* no running tracking, remove handler and pass through */
1292
1357
        if (0 == WM_jobs_test(CTX_wm_manager(C), CTX_wm_area(C), WM_JOB_TYPE_ANY))
1323
1388
        RNA_def_boolean(ot->srna, "sequence", 0, "Track Sequence", "Track marker during image sequence rather than single image");
1324
1389
}
1325
1390
 
 
1391
/********************** refine track position operator *********************/
 
1392
 
 
1393
static int refine_marker_exec(bContext *C, wmOperator *op)
 
1394
{
 
1395
        SpaceClip *sc = CTX_wm_space_clip(C);
 
1396
        MovieClip *clip = ED_space_clip_get_clip(sc);
 
1397
        MovieTracking *tracking = &clip->tracking;
 
1398
        ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
 
1399
        MovieTrackingTrack *track;
 
1400
        bool backwards = RNA_boolean_get(op->ptr, "backwards");
 
1401
        int framenr = ED_space_clip_get_clip_frame_number(sc);
 
1402
 
 
1403
        for (track = tracksbase->first; track; track = track->next) {
 
1404
                if (TRACK_VIEW_SELECTED(sc, track)) {
 
1405
                        MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
 
1406
 
 
1407
                        BKE_tracking_refine_marker(clip, track, marker, backwards);
 
1408
                }
 
1409
        }
 
1410
 
 
1411
        WM_event_add_notifier(C, NC_MOVIECLIP | NA_EVALUATED, clip);
 
1412
 
 
1413
        return OPERATOR_FINISHED;
 
1414
}
 
1415
 
 
1416
void CLIP_OT_refine_markers(wmOperatorType *ot)
 
1417
{
 
1418
        /* identifiers */
 
1419
        ot->name = "Refine Markers";
 
1420
        ot->description = "Refine selected markers positions "
 
1421
                          "by running the tracker from track's reference to current frame";
 
1422
        ot->idname = "CLIP_OT_refine_markers";
 
1423
 
 
1424
        /* api callbacks */
 
1425
        ot->exec = refine_marker_exec;
 
1426
        ot->poll = ED_space_clip_tracking_poll;
 
1427
 
 
1428
        /* flags */
 
1429
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
1430
 
 
1431
        /* properties */
 
1432
        RNA_def_boolean(ot->srna, "backwards", 0, "Backwards", "Do backwards tracking");
 
1433
}
 
1434
 
1326
1435
/********************** solve camera operator *********************/
1327
1436
 
1328
1437
typedef struct {
1457
1566
        return OPERATOR_FINISHED;
1458
1567
}
1459
1568
 
1460
 
static int solve_camera_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 
1569
static int solve_camera_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1461
1570
{
1462
1571
        SolveCameraJob *scj;
1463
1572
        ScrArea *sa = CTX_wm_area(C);
1507
1616
        return OPERATOR_RUNNING_MODAL;
1508
1617
}
1509
1618
 
1510
 
static int solve_camera_modal(bContext *C, wmOperator *UNUSED(op), wmEvent *event)
 
1619
static int solve_camera_modal(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
1511
1620
{
1512
1621
        /* no running solver, remove handler and pass through */
1513
1622
        if (0 == WM_jobs_test(CTX_wm_manager(C), CTX_wm_area(C), WM_JOB_TYPE_ANY))
1815
1924
                                BKE_object_where_is_calc_mat4(scene, cam, invmat);
1816
1925
                        }
1817
1926
 
1818
 
                        mult_m4_m4m4(invmat, invmat, data->invmat);
 
1927
                        mul_m4_m4m4(invmat, invmat, data->invmat);
1819
1928
 
1820
1929
                        found = TRUE;
1821
1930
                }
2019
2128
        if (is_camera) {
2020
2129
                invert_m4(mat);
2021
2130
 
2022
 
                mult_m4_m4m4(mat, mat, obmat);
 
2131
                mul_m4_m4m4(mat, mat, obmat);
2023
2132
        }
2024
2133
        else {
2025
2134
                if (!flip) {
2036
2145
                        mul_serie_m4(mat, lmat, mat, ilmat, obmat, NULL, NULL, NULL, NULL);
2037
2146
                }
2038
2147
                else {
2039
 
                        mult_m4_m4m4(mat, obmat, mat);
 
2148
                        mul_m4_m4m4(mat, obmat, mat);
2040
2149
                }
2041
2150
        }
2042
2151
 
2128
2237
                invert_m4(mat);
2129
2238
 
2130
2239
                BKE_object_to_mat4(object, obmat);
2131
 
                mult_m4_m4m4(mat, mat, obmat);
2132
 
                mult_m4_m4m4(newmat, rot, mat);
 
2240
                mul_m4_m4m4(mat, mat, obmat);
 
2241
                mul_m4_m4m4(newmat, rot, mat);
2133
2242
                BKE_object_apply_mat4(object, newmat, 0, 0);
2134
2243
 
2135
2244
                /* make camera have positive z-coordinate */
2136
2245
                if (object->loc[2] < 0) {
2137
2246
                        invert_m4(rot);
2138
 
                        mult_m4_m4m4(newmat, rot, mat);
 
2247
                        mul_m4_m4m4(newmat, rot, mat);
2139
2248
                        BKE_object_apply_mat4(object, newmat, 0, 0);
2140
2249
                }
2141
2250
        }
2253
2362
 
2254
2363
/********************** set scale operator *********************/
2255
2364
 
2256
 
static int do_set_scale(bContext *C, wmOperator *op, int scale_solution)
 
2365
static int do_set_scale(bContext *C, wmOperator *op, bool scale_solution, bool apply_scale)
2257
2366
{
2258
2367
        SpaceClip *sc = CTX_wm_space_clip(C);
2259
2368
        MovieClip *clip = ED_space_clip_get_clip(sc);
2274
2383
                return OPERATOR_CANCELLED;
2275
2384
        }
2276
2385
 
2277
 
        object = get_orientation_object(C);
2278
 
        if (!object) {
2279
 
                BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");
 
2386
        if (!scale_solution && !apply_scale) {
 
2387
                object = get_orientation_object(C);
 
2388
                if (!object) {
 
2389
                        BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");
2280
2390
 
2281
 
                return OPERATOR_CANCELLED;
 
2391
                        return OPERATOR_CANCELLED;
 
2392
                }
2282
2393
        }
2283
2394
 
2284
2395
        BKE_tracking_get_camera_object_matrix(scene, camera, mat);
2298
2409
        if (len_v3(vec[0]) > 1e-5f) {
2299
2410
                scale = dist / len_v3(vec[0]);
2300
2411
 
2301
 
                if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
2302
 
                        mul_v3_fl(object->size, scale);
2303
 
                        mul_v3_fl(object->loc, scale);
2304
 
                }
2305
 
                else if (!scale_solution) {
2306
 
                        Object *solver_camera = object_solver_camera(scene, object);
2307
 
 
2308
 
                        object->size[0] = object->size[1] = object->size[2] = 1.0f / scale;
2309
 
 
2310
 
                        if (solver_camera) {
2311
 
                                object->size[0] /= solver_camera->size[0];
2312
 
                                object->size[1] /= solver_camera->size[1];
2313
 
                                object->size[2] /= solver_camera->size[2];
2314
 
                        }
 
2412
                if (apply_scale) {
 
2413
                        /* Apply scale on reconstructed scene itself */
 
2414
                        MovieTrackingReconstruction *reconstruction = BKE_tracking_get_active_reconstruction(tracking);
 
2415
                        MovieReconstructedCamera *reconstructed_cameras;
 
2416
                        int i;
 
2417
 
 
2418
                        for (track = tracksbase->first; track; track = track->next) {
 
2419
                                mul_v3_fl(track->bundle_pos, scale);
 
2420
                        }
 
2421
 
 
2422
                        reconstructed_cameras = reconstruction->cameras;
 
2423
                        for (i = 0; i < reconstruction->camnr; i++) {
 
2424
                                mul_v3_fl(reconstructed_cameras[i].mat[3], scale);
 
2425
                        }
 
2426
 
 
2427
                        WM_event_add_notifier(C, NC_MOVIECLIP | NA_EVALUATED, clip);
 
2428
                        WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
2315
2429
                }
2316
2430
                else {
2317
 
                        tracking_object->scale = scale;
 
2431
                        if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
 
2432
                                mul_v3_fl(object->size, scale);
 
2433
                                mul_v3_fl(object->loc, scale);
 
2434
                        }
 
2435
                        else if (!scale_solution) {
 
2436
                                Object *solver_camera = object_solver_camera(scene, object);
 
2437
 
 
2438
                                object->size[0] = object->size[1] = object->size[2] = 1.0f / scale;
 
2439
 
 
2440
                                if (solver_camera) {
 
2441
                                        object->size[0] /= solver_camera->size[0];
 
2442
                                        object->size[1] /= solver_camera->size[1];
 
2443
                                        object->size[2] /= solver_camera->size[2];
 
2444
                                }
 
2445
                        }
 
2446
                        else {
 
2447
                                tracking_object->scale = scale;
 
2448
                        }
 
2449
 
 
2450
                        DAG_id_tag_update(&clip->id, 0);
 
2451
 
 
2452
                        if (object)
 
2453
                                DAG_id_tag_update(&object->id, OB_RECALC_OB);
 
2454
 
 
2455
                        WM_event_add_notifier(C, NC_MOVIECLIP | NA_EVALUATED, clip);
 
2456
                        WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
2318
2457
                }
2319
 
 
2320
 
                DAG_id_tag_update(&clip->id, 0);
2321
 
 
2322
 
                if (object)
2323
 
                        DAG_id_tag_update(&object->id, OB_RECALC_OB);
2324
 
 
2325
 
                WM_event_add_notifier(C, NC_MOVIECLIP | NA_EVALUATED, clip);
2326
 
                WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
2327
2458
        }
2328
2459
 
2329
2460
        return OPERATOR_FINISHED;
2331
2462
 
2332
2463
static int set_scale_exec(bContext *C, wmOperator *op)
2333
2464
{
2334
 
        return do_set_scale(C, op, 0);
 
2465
        return do_set_scale(C, op, false, false);
2335
2466
}
2336
2467
 
2337
 
static int set_scale_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 
2468
static int set_scale_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2338
2469
{
2339
2470
        SpaceClip *sc = CTX_wm_space_clip(C);
2340
2471
        MovieClip *clip = ED_space_clip_get_clip(sc);
2387
2518
 
2388
2519
static int set_solution_scale_exec(bContext *C, wmOperator *op)
2389
2520
{
2390
 
        return do_set_scale(C, op, 1);
 
2521
        return do_set_scale(C, op, true, false);
2391
2522
}
2392
2523
 
2393
 
static int set_solution_scale_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 
2524
static int set_solution_scale_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2394
2525
{
2395
2526
        SpaceClip *sc = CTX_wm_space_clip(C);
2396
2527
        MovieClip *clip = ED_space_clip_get_clip(sc);
2421
2552
                      "Distance", "Distance between selected tracks", -100.0f, 100.0f);
2422
2553
}
2423
2554
 
 
2555
/********************** apply solution scale operator *********************/
 
2556
 
 
2557
static int apply_solution_scale_poll(bContext *C)
 
2558
{
 
2559
        SpaceClip *sc = CTX_wm_space_clip(C);
 
2560
 
 
2561
        if (sc) {
 
2562
                MovieClip *clip = ED_space_clip_get_clip(sc);
 
2563
 
 
2564
                if (clip) {
 
2565
                        MovieTracking *tracking = &clip->tracking;
 
2566
                        MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
 
2567
 
 
2568
                        return tracking_object->flag & TRACKING_OBJECT_CAMERA;
 
2569
                }
 
2570
        }
 
2571
 
 
2572
        return FALSE;
 
2573
}
 
2574
 
 
2575
static int apply_solution_scale_exec(bContext *C, wmOperator *op)
 
2576
{
 
2577
        return do_set_scale(C, op, false, true);
 
2578
}
 
2579
 
 
2580
static int apply_solution_scale_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
 
2581
{
 
2582
        SpaceClip *sc = CTX_wm_space_clip(C);
 
2583
        MovieClip *clip = ED_space_clip_get_clip(sc);
 
2584
 
 
2585
        if (!RNA_struct_property_is_set(op->ptr, "distance"))
 
2586
                RNA_float_set(op->ptr, "distance", clip->tracking.settings.dist);
 
2587
 
 
2588
        return apply_solution_scale_exec(C, op);
 
2589
}
 
2590
 
 
2591
void CLIP_OT_apply_solution_scale(wmOperatorType *ot)
 
2592
{
 
2593
        /* identifiers */
 
2594
        ot->name = "Apply Solution Scale";
 
2595
        ot->description = "Apply scale on solution itself to make distance between selected tracks equals to desired";
 
2596
        ot->idname = "CLIP_OT_apply_solution_scale";
 
2597
 
 
2598
        /* api callbacks */
 
2599
        ot->exec = apply_solution_scale_exec;
 
2600
        ot->invoke = apply_solution_scale_invoke;
 
2601
        ot->poll = apply_solution_scale_poll;
 
2602
 
 
2603
        /* flags */
 
2604
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
2605
 
 
2606
        /* properties */
 
2607
        RNA_def_float(ot->srna, "distance", 0.0f, -FLT_MAX, FLT_MAX,
 
2608
                      "Distance", "Distance between selected tracks", -100.0f, 100.0f);
 
2609
}
 
2610
 
2424
2611
/********************** set principal center operator *********************/
2425
2612
 
2426
2613
static int set_center_principal_exec(bContext *C, wmOperator *UNUSED(op))
2734
2921
 
2735
2922
        /* api callbacks */
2736
2923
        ot->exec = frame_jump_exec;
2737
 
        ot->poll = ED_space_clip_tracking_poll;
 
2924
        ot->poll = ED_space_clip_poll;
2738
2925
 
2739
2926
        /* flags */
2740
2927
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2892
3079
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2893
3080
 
2894
3081
        /* properties */
2895
 
        RNA_def_enum(ot->srna, "keyframe", keyframe_items, 0, "Keyframe", "keyframe to set");
 
3082
        RNA_def_enum(ot->srna, "keyframe", keyframe_items, 0, "Keyframe", "Keyframe to set");
2896
3083
}
2897
3084
 
2898
3085
/********************** track copy color operator *********************/
3258
3445
                next = track->next;
3259
3446
 
3260
3447
                if ((track->flag & TRACK_HIDDEN) == 0 && (track->flag & TRACK_LOCKED) == 0) {
3261
 
                        int ok = 1;
 
3448
                        bool ok;
3262
3449
 
3263
3450
                        ok = (is_track_clean(track, frames, action == TRACKING_CLEAN_DELETE_SEGMENT)) &&
3264
3451
                             (error == 0.0f || (track->flag & TRACK_HAS_BUNDLE) == 0  || track->error < error);
3295
3482
        return OPERATOR_FINISHED;
3296
3483
}
3297
3484
 
3298
 
static int clean_tracks_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 
3485
static int clean_tracks_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
3299
3486
{
3300
3487
        SpaceClip *sc = CTX_wm_space_clip(C);
3301
3488
        MovieClip *clip = ED_space_clip_get_clip(sc);