← Back to branch summary

~ubuntu-branches/ubuntu/saucy/blender/saucy-proposed

« back to all changes in this revision

Viewing changes to source/blender/makesrna/intern/rna_tracking.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/makesrna/intern/rna_tracking.c
35
35
#include "BKE_movieclip.h"
36
36
#include "BKE_tracking.h"
37
37
 
 
38
#include "RNA_access.h"
38
39
#include "RNA_define.h"
39
40
 
40
41
#include "rna_internal.h"
41
42
 
42
43
#include "DNA_movieclip_types.h"
43
 
#include "DNA_object_types.h"   /* SELECT */
 
44
#include "DNA_object_types.h"   /* SELECT */
44
45
#include "DNA_scene_types.h"
45
46
 
46
47
#include "WM_types.h"
59
60
        return BLI_sprintfN("tracking");
60
61
}
61
62
 
62
 
static void rna_tracking_defaultSettings_levelsUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
63
 
{
64
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
65
 
        MovieTracking *tracking = &clip->tracking;
66
 
        MovieTrackingSettings *settings = &tracking->settings;
67
 
 
68
 
        if (settings->default_tracker == TRACKER_KLT) {
69
 
                int max_pyramid_level_factor = 1 << (settings->default_pyramid_levels - 1);
70
 
                float search_ratio = 2.3f * max_pyramid_level_factor;
71
 
 
72
 
                settings->default_search_size = settings->default_pattern_size*search_ratio;
73
 
        }
74
 
}
75
 
 
76
63
static void rna_tracking_defaultSettings_patternUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
77
64
{
78
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
65
        MovieClip *clip = (MovieClip *)ptr->id.data;
79
66
        MovieTracking *tracking = &clip->tracking;
80
67
        MovieTrackingSettings *settings = &tracking->settings;
81
68
 
82
 
        if (settings->default_search_size<settings->default_pattern_size)
 
69
        if (settings->default_search_size < settings->default_pattern_size)
83
70
                settings->default_search_size = settings->default_pattern_size;
84
71
}
85
72
 
86
73
static void rna_tracking_defaultSettings_searchUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
87
74
{
88
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
75
        MovieClip *clip = (MovieClip *)ptr->id.data;
89
76
        MovieTracking *tracking = &clip->tracking;
90
77
        MovieTrackingSettings *settings = &tracking->settings;
91
78
 
92
 
        if (settings->default_pattern_size>settings->default_search_size)
 
79
        if (settings->default_pattern_size > settings->default_search_size)
93
80
                settings->default_pattern_size = settings->default_search_size;
94
81
}
95
82
 
102
89
 
103
90
static void rna_trackingTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
104
91
{
105
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
92
        MovieClip *clip = (MovieClip *)ptr->id.data;
106
93
 
107
94
        rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
108
95
}
109
96
 
110
97
static void rna_trackingObjects_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
111
98
{
112
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
99
        MovieClip *clip = (MovieClip *)ptr->id.data;
113
100
 
114
101
        rna_iterator_listbase_begin(iter, &clip->tracking.objects, NULL);
115
102
}
116
103
 
117
104
static int rna_tracking_active_object_index_get(PointerRNA *ptr)
118
105
{
119
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
106
        MovieClip *clip = (MovieClip *)ptr->id.data;
120
107
 
121
108
        return clip->tracking.objectnr;
122
109
}
123
110
 
124
111
static void rna_tracking_active_object_index_set(PointerRNA *ptr, int value)
125
112
{
126
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
113
        MovieClip *clip = (MovieClip *)ptr->id.data;
127
114
 
128
115
        clip->tracking.objectnr = value;
129
116
}
130
117
 
131
118
static void rna_tracking_active_object_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
132
119
{
133
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
120
        MovieClip *clip = (MovieClip *)ptr->id.data;
134
121
 
135
122
        *min = 0;
136
 
        *max = clip->tracking.tot_object-1;
137
 
        *max = MAX2(0, *max);
 
123
        *max = max_ii(0, clip->tracking.tot_object - 1);
138
124
}
139
125
 
140
126
static PointerRNA rna_tracking_active_track_get(PointerRNA *ptr)
141
127
{
142
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
143
 
        MovieTrackingTrack *act_track = BKE_tracking_active_track(&clip->tracking);
 
128
        MovieClip *clip = (MovieClip *)ptr->id.data;
 
129
        MovieTrackingTrack *act_track = BKE_tracking_track_get_active(&clip->tracking);
144
130
 
145
131
        return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingTrack, act_track);
146
132
}
147
133
 
148
134
static void rna_tracking_active_track_set(PointerRNA *ptr, PointerRNA value)
149
135
{
150
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
136
        MovieClip *clip = (MovieClip *)ptr->id.data;
151
137
        MovieTrackingTrack *track = (MovieTrackingTrack *)value.data;
152
 
        ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
 
138
        ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
153
139
        int index = BLI_findindex(tracksbase, track);
154
140
 
155
141
        if (index >= 0)
158
144
                clip->tracking.act_track = NULL;
159
145
}
160
146
 
161
 
void rna_trackingTrack_name_set(PointerRNA *ptr, const char *value)
 
147
static void rna_trackingTrack_name_set(PointerRNA *ptr, const char *value)
162
148
{
163
149
        MovieClip *clip = (MovieClip *)ptr->id.data;
164
150
        MovieTracking *tracking = &clip->tracking;
183
169
                }
184
170
        }
185
171
 
186
 
        BKE_track_unique_name(tracksbase, track);
 
172
        BKE_tracking_track_unique_name(tracksbase, track);
187
173
}
188
174
 
189
175
static int rna_trackingTrack_select_get(PointerRNA *ptr)
209
195
        }
210
196
}
211
197
 
212
 
static void rna_tracking_trackerPattern_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
213
 
{
214
 
        MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
215
 
 
216
 
        BKE_tracking_clamp_track(track, CLAMP_PAT_DIM);
217
 
}
218
 
 
219
 
static void rna_tracking_trackerSearch_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
220
 
{
221
 
        MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
222
 
 
223
 
        BKE_tracking_clamp_track(track, CLAMP_SEARCH_DIM);
224
 
}
225
 
 
226
 
static void rna_tracking_trackerAlgorithm_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
227
 
{
228
 
        MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
229
 
 
230
 
        if (track->tracker == TRACKER_KLT)
231
 
                BKE_tracking_clamp_track(track, CLAMP_PYRAMID_LEVELS);
232
 
        else
233
 
                BKE_tracking_clamp_track(track, CLAMP_SEARCH_DIM);
234
 
}
235
 
 
236
 
static void rna_tracking_trackerPyramid_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
237
 
{
238
 
        MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
239
 
 
240
 
        BKE_tracking_clamp_track(track, CLAMP_PYRAMID_LEVELS);
241
 
}
242
 
 
243
198
static char *rna_trackingCamera_path(PointerRNA *UNUSED(ptr))
244
199
{
245
200
        return BLI_sprintfN("tracking.camera");
247
202
 
248
203
static float rna_trackingCamera_focal_mm_get(PointerRNA *ptr)
249
204
{
250
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
205
        MovieClip *clip = (MovieClip *)ptr->id.data;
251
206
        MovieTrackingCamera *camera = &clip->tracking.camera;
252
207
        float val = camera->focal;
253
208
 
254
209
        if (clip->lastsize[0])
255
 
                val = val*camera->sensor_width/(float)clip->lastsize[0];
 
210
                val = val * camera->sensor_width / (float)clip->lastsize[0];
256
211
 
257
212
        return val;
258
213
}
259
214
 
260
215
static void rna_trackingCamera_focal_mm_set(PointerRNA *ptr, float value)
261
216
{
262
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
217
        MovieClip *clip = (MovieClip *)ptr->id.data;
263
218
        MovieTrackingCamera *camera = &clip->tracking.camera;
264
219
 
265
220
        if (clip->lastsize[0])
266
 
                value = clip->lastsize[0]*value/camera->sensor_width;
 
221
                value = clip->lastsize[0] * value / camera->sensor_width;
267
222
 
268
 
        if (value >= 0.0001)
 
223
        if (value >= 0.0001f)
269
224
                camera->focal = value;
270
225
}
271
226
 
276
231
 
277
232
static int rna_track_2d_stabilization(CollectionPropertyIterator *UNUSED(iter), void *data)
278
233
{
279
 
        MovieTrackingTrack *track = (MovieTrackingTrack*)data;
 
234
        MovieTrackingTrack *track = (MovieTrackingTrack *)data;
280
235
 
281
 
        if ((track->flag&TRACK_USE_2D_STAB) == 0)
 
236
        if ((track->flag & TRACK_USE_2D_STAB) == 0)
282
237
                return 1;
283
238
 
284
239
        return 0;
286
241
 
287
242
static void rna_tracking_stabTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
288
243
{
289
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
244
        MovieClip *clip = (MovieClip *)ptr->id.data;
290
245
        rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization);
291
246
}
292
247
 
293
248
static int rna_tracking_stabTracks_active_index_get(PointerRNA *ptr)
294
249
{
295
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
250
        MovieClip *clip = (MovieClip *)ptr->id.data;
296
251
        return clip->tracking.stabilization.act_track;
297
252
}
298
253
 
299
254
static void rna_tracking_stabTracks_active_index_set(PointerRNA *ptr, int value)
300
255
{
301
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
256
        MovieClip *clip = (MovieClip *)ptr->id.data;
302
257
        clip->tracking.stabilization.act_track = value;
303
258
}
304
259
 
305
260
static void rna_tracking_stabTracks_active_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
306
261
{
307
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
262
        MovieClip *clip = (MovieClip *)ptr->id.data;
308
263
 
309
264
        *min = 0;
310
 
        *max = clip->tracking.stabilization.tot_track-1;
311
 
        *max = MAX2(0, *max);
 
265
        *max = max_ii(0, clip->tracking.stabilization.tot_track - 1);
312
266
}
313
267
 
314
268
static void rna_tracking_flushUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
315
269
{
316
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
270
        MovieClip *clip = (MovieClip *)ptr->id.data;
317
271
        MovieTrackingStabilization *stab = &clip->tracking.stabilization;
318
272
 
319
273
        stab->ok = 0;
320
274
 
321
275
        nodeUpdateID(scene->nodetree, &clip->id);
322
276
 
323
 
        WM_main_add_notifier(NC_SCENE|ND_NODES, NULL);
 
277
        WM_main_add_notifier(NC_SCENE | ND_NODES, NULL);
324
278
        DAG_id_tag_update(&clip->id, 0);
325
279
}
326
280
 
327
281
static void rna_trackingObject_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
328
282
{
329
 
        MovieTrackingObject *object = (MovieTrackingObject* )ptr->data;
 
283
        MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
330
284
 
331
 
        if (object->flag&TRACKING_OBJECT_CAMERA) {
332
 
                MovieClip *clip = (MovieClip*)ptr->id.data;
 
285
        if (object->flag & TRACKING_OBJECT_CAMERA) {
 
286
                MovieClip *clip = (MovieClip *)ptr->id.data;
333
287
 
334
288
                rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
335
289
        }
338
292
        }
339
293
}
340
294
 
 
295
static PointerRNA rna_trackingObject_reconstruction_get(PointerRNA *ptr)
 
296
{
 
297
        MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
 
298
 
 
299
        if (object->flag & TRACKING_OBJECT_CAMERA) {
 
300
                MovieClip *clip = (MovieClip *)ptr->id.data;
 
301
 
 
302
                return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingReconstruction, &clip->tracking.reconstruction);
 
303
        }
 
304
        else {
 
305
                return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingReconstruction, &object->reconstruction);
 
306
        }
 
307
}
 
308
 
341
309
static PointerRNA rna_tracking_active_object_get(PointerRNA *ptr)
342
310
{
343
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
311
        MovieClip *clip = (MovieClip *)ptr->id.data;
344
312
        MovieTrackingObject *object = BLI_findlink(&clip->tracking.objects, clip->tracking.objectnr);
345
313
 
346
314
        return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingObject, object);
348
316
 
349
317
static void rna_tracking_active_object_set(PointerRNA *ptr, PointerRNA value)
350
318
{
351
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
319
        MovieClip *clip = (MovieClip *)ptr->id.data;
352
320
        MovieTrackingObject *object = (MovieTrackingObject *)value.data;
353
321
        int index = BLI_findindex(&clip->tracking.objects, object);
354
322
 
356
324
        else clip->tracking.objectnr = 0;
357
325
}
358
326
 
359
 
void rna_trackingObject_name_set(PointerRNA *ptr, const char *value)
 
327
static void rna_trackingObject_name_set(PointerRNA *ptr, const char *value)
360
328
{
361
329
        MovieClip *clip = (MovieClip *)ptr->id.data;
362
330
        MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
368
336
 
369
337
static void rna_trackingObject_flushUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
370
338
{
371
 
        MovieClip *clip = (MovieClip*)ptr->id.data;
 
339
        MovieClip *clip = (MovieClip *)ptr->id.data;
372
340
 
373
 
        WM_main_add_notifier(NC_OBJECT|ND_TRANSFORM, NULL);
 
341
        WM_main_add_notifier(NC_OBJECT | ND_TRANSFORM, NULL);
374
342
        DAG_id_tag_update(&clip->id, 0);
375
343
}
376
344
 
383
351
 
384
352
        track = tracking->tracks.first;
385
353
        while (track) {
386
 
                if (marker >= track->markers && marker < track->markers+track->markersnr) {
 
354
                if (marker >= track->markers && marker < track->markers + track->markersnr) {
387
355
                        break;
388
356
                }
389
357
 
394
362
                MovieTrackingMarker new_marker = *marker;
395
363
                new_marker.framenr = value;
396
364
 
397
 
                BKE_tracking_delete_marker(track, marker->framenr);
398
 
                BKE_tracking_insert_marker(track, &new_marker);
 
365
                BKE_tracking_marker_delete(track, marker->framenr);
 
366
                BKE_tracking_marker_insert(track, &new_marker);
399
367
        }
400
368
}
401
369
 
 
370
static void rna_tracking_markerPattern_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
 
371
{
 
372
        MovieTrackingMarker *marker = (MovieTrackingMarker *)ptr->data;
 
373
 
 
374
        BKE_tracking_marker_clamp(marker, CLAMP_PAT_DIM);
 
375
}
 
376
 
 
377
static void rna_tracking_markerSearch_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
 
378
{
 
379
        MovieTrackingMarker *marker = (MovieTrackingMarker *)ptr->data;
 
380
 
 
381
        BKE_tracking_marker_clamp(marker, CLAMP_SEARCH_DIM);
 
382
}
 
383
 
 
384
static void rna_tracking_markerPattern_boundbox_get(PointerRNA *ptr, float *values)
 
385
{
 
386
        MovieTrackingMarker *marker = (MovieTrackingMarker *)ptr->data;
 
387
        float min[2], max[2];
 
388
 
 
389
        BKE_tracking_marker_pattern_minmax(marker, min, max);
 
390
 
 
391
        copy_v2_v2(values, min);
 
392
        copy_v2_v2(values + 2, max);
 
393
}
 
394
 
 
395
static void rna_trackingDopesheet_tagUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
 
396
{
 
397
        MovieClip *clip = (MovieClip *)ptr->id.data;
 
398
        MovieTrackingDopesheet *dopesheet = &clip->tracking.dopesheet;
 
399
 
 
400
        dopesheet->ok = 0;
 
401
}
 
402
 
402
403
/* API */
403
404
 
404
 
static void add_tracks_to_base(MovieClip *clip, MovieTracking *tracking, ListBase *tracksbase, int frame, int number)
 
405
static MovieTrackingTrack *add_track_to_base(MovieClip *clip, MovieTracking *tracking, ListBase *tracksbase, const char *name, int frame)
405
406
{
406
 
        int a, width, height;
 
407
        int width, height;
407
408
        MovieClipUser user = {0};
 
409
        MovieTrackingTrack *track;
408
410
 
409
411
        user.framenr = 1;
410
412
 
411
413
        BKE_movieclip_get_size(clip, &user, &width, &height);
412
414
 
413
 
        for (a = 0; a<number; a++)
414
 
                BKE_tracking_add_track(tracking, tracksbase, 0, 0, frame, width, height);
 
415
        track = BKE_tracking_track_add(tracking, tracksbase, 0, 0, frame, width, height);
 
416
 
 
417
        if (name && name[0]) {
 
418
                BLI_strncpy(track->name, name, sizeof(track->name));
 
419
                BKE_tracking_track_unique_name(tracksbase, track);
 
420
        }
 
421
 
 
422
        return track;
415
423
}
416
424
 
417
 
static void rna_trackingTracks_add(ID *id, MovieTracking *tracking, int frame, int number)
 
425
static MovieTrackingTrack *rna_trackingTracks_new(ID *id, MovieTracking *tracking, const char *name, int frame)
418
426
{
419
427
        MovieClip *clip = (MovieClip *) id;
420
 
 
421
 
        add_tracks_to_base(clip, tracking, &tracking->tracks, frame, number);
422
 
 
423
 
        WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, clip);
 
428
        MovieTrackingTrack *track;
 
429
 
 
430
        track = add_track_to_base(clip, tracking, &tracking->tracks, name, frame);
 
431
 
 
432
        WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, clip);
 
433
 
 
434
        return track;
424
435
}
425
436
 
426
 
static void rna_trackingObject_tracks_add(ID *id, MovieTrackingObject *object, int frame, int number)
 
437
static MovieTrackingTrack *rna_trackingObject_tracks_new(ID *id, MovieTrackingObject *object, const char *name, int frame)
427
438
{
428
439
        MovieClip *clip = (MovieClip *) id;
429
440
        ListBase *tracksbase = &object->tracks;
 
441
        MovieTrackingTrack *track;
430
442
 
431
 
        if (object->flag&TRACKING_OBJECT_CAMERA)
 
443
        if (object->flag & TRACKING_OBJECT_CAMERA)
432
444
                tracksbase = &clip->tracking.tracks;
433
445
 
434
 
        add_tracks_to_base(clip, &clip->tracking, tracksbase, frame, number);
435
 
 
436
 
        WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
 
446
        track = add_track_to_base(clip, &clip->tracking, tracksbase, name, frame);
 
447
 
 
448
        WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
 
449
 
 
450
        return track;
437
451
}
438
452
 
439
453
static MovieTrackingObject *rna_trackingObject_new(MovieTracking *tracking, const char *name)
440
454
{
441
 
        MovieTrackingObject *object = BKE_tracking_new_object(tracking, name);
 
455
        MovieTrackingObject *object = BKE_tracking_object_add(tracking, name);
442
456
 
443
 
        WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
 
457
        WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
444
458
 
445
459
        return object;
446
460
}
447
461
 
448
 
void rna_trackingObject_remove(MovieTracking *tracking, MovieTrackingObject *object)
449
 
{
450
 
        BKE_tracking_remove_object(tracking, object);
451
 
 
452
 
        WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
453
 
}
454
 
 
455
 
static MovieTrackingMarker *rna_trackingMarkers_find_frame(MovieTrackingTrack *track, int framenr)
456
 
{
457
 
        return BKE_tracking_exact_marker(track, framenr);
458
 
}
459
 
 
460
 
static MovieTrackingMarker* rna_trackingMarkers_insert_frame(MovieTrackingTrack *track, int framenr, float *co)
 
462
static void rna_trackingObject_remove(MovieTracking *tracking, ReportList *reports, PointerRNA *object_ptr)
 
463
{
 
464
        MovieTrackingObject *object = object_ptr->data;
 
465
        if (BKE_tracking_object_delete(tracking, object) == FALSE) {
 
466
                BKE_reportf(reports, RPT_ERROR, "MovieTracking '%s' cannot be removed", object->name);
 
467
                return;
 
468
        }
 
469
 
 
470
        RNA_POINTER_INVALIDATE(object_ptr);
 
471
 
 
472
        WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
 
473
}
 
474
 
 
475
static MovieTrackingMarker *rna_trackingMarkers_find_frame(MovieTrackingTrack *track, int framenr, int exact)
 
476
{
 
477
        if (exact)
 
478
                return BKE_tracking_marker_get_exact(track, framenr);
 
479
        else
 
480
                return BKE_tracking_marker_get(track, framenr);
 
481
}
 
482
 
 
483
static MovieTrackingMarker *rna_trackingMarkers_insert_frame(MovieTrackingTrack *track, int framenr, float *co)
461
484
{
462
485
        MovieTrackingMarker marker, *new_marker;
463
486
 
465
488
        marker.framenr = framenr;
466
489
        copy_v2_v2(marker.pos, co);
467
490
 
468
 
        new_marker = BKE_tracking_insert_marker(track, &marker);
469
 
 
470
 
        WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
 
491
        /* a bit arbitrary, but better than creating markers with zero pattern
 
492
         * which is forbidden actually
 
493
         */
 
494
        copy_v2_v2(marker.pattern_corners[0], track->markers[0].pattern_corners[0]);
 
495
        copy_v2_v2(marker.pattern_corners[1], track->markers[0].pattern_corners[1]);
 
496
        copy_v2_v2(marker.pattern_corners[2], track->markers[0].pattern_corners[2]);
 
497
        copy_v2_v2(marker.pattern_corners[3], track->markers[0].pattern_corners[3]);
 
498
 
 
499
        new_marker = BKE_tracking_marker_insert(track, &marker);
 
500
 
 
501
        WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
471
502
 
472
503
        return new_marker;
473
504
}
474
505
 
475
 
void rna_trackingMarkers_delete_frame(MovieTrackingTrack *track, int framenr)
 
506
static void rna_trackingMarkers_delete_frame(MovieTrackingTrack *track, int framenr)
476
507
{
477
508
        if (track->markersnr == 1)
478
509
                return;
479
510
 
480
 
        BKE_tracking_delete_marker(track, framenr);
 
511
        BKE_tracking_marker_delete(track, framenr);
481
512
 
482
 
        WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
 
513
        WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
483
514
}
484
515
 
485
516
#else
486
517
 
487
 
static EnumPropertyItem tracker_items[] = {
488
 
        {TRACKER_KLT, "KLT", 0, "KLT",
489
 
                      "Kanade–Lucas–Tomasi tracker which works with most of video clips, a bit slower than SAD"},
490
 
        {TRACKER_SAD, "SAD", 0, "SAD", "Sum of Absolute Differences tracker which can be used when KLT tracker fails"},
491
 
        {TRACKER_HYBRID, "Hybrid", 0, "Hybrid", "A hybrid tracker that uses SAD for rough tracking, KLT for refinement."},
492
 
        {0, NULL, 0, NULL, NULL}};
 
518
static EnumPropertyItem tracker_motion_model[] = {
 
519
        {TRACK_MOTION_MODEL_HOMOGRAPHY, "Perspective", 0, "Perspective",
 
520
                      "Search for markers that are perspectively deformed (homography) between frames"},
 
521
        {TRACK_MOTION_MODEL_AFFINE, "Affine", 0, "Affine",
 
522
                      "Search for markers that are affine-deformed (t, r, k, and skew) between frames"},
 
523
        {TRACK_MOTION_MODEL_TRANSLATION_ROTATION_SCALE, "LocRotScale", 0, "LocRotScale",
 
524
                      "Search for markers that are translated, rotated, and scaled between frames"},
 
525
        {TRACK_MOTION_MODEL_TRANSLATION_SCALE, "LocScale", 0, "LocScale",
 
526
                      "Search for markers that are translated and scaled between frames"},
 
527
        {TRACK_MOTION_MODEL_TRANSLATION_ROTATION, "LocRot", 0, "LocRot",
 
528
                      "Search for markers that are translated and rotated between frames"},
 
529
        {TRACK_MOTION_MODEL_TRANSLATION, "Loc", 0, "Loc",
 
530
                      "Search for markers that are translated between frames"},
 
531
        {0, NULL, 0, NULL, NULL}
 
532
};
493
533
 
494
534
static EnumPropertyItem pattern_match_items[] = {
495
535
        {TRACK_MATCH_KEYFRAME, "KEYFRAME", 0, "Keyframe", "Track pattern from keyframe to next frame"},
496
536
        {TRACK_MATCH_PREVFRAME, "PREV_FRAME", 0, "Previous frame", "Track pattern from current frame to next frame"},
497
 
        {0, NULL, 0, NULL, NULL}};
 
537
        {0, NULL, 0, NULL, NULL}
 
538
};
498
539
 
499
540
static int rna_matrix_dimsize_4x4[] = {4, 4};
 
541
static int rna_matrix_dimsize_4x2[] = {4, 2};
500
542
 
501
543
static void rna_def_trackingSettings(BlenderRNA *brna)
502
544
{
505
547
 
506
548
        static EnumPropertyItem speed_items[] = {
507
549
                {0, "FASTEST", 0, "Fastest", "Track as fast as it's possible"},
508
 
            {TRACKING_SPEED_DOUBLE, "DOUBLE", 0, "Double", "Track with double speed"},
 
550
                {TRACKING_SPEED_DOUBLE, "DOUBLE", 0, "Double", "Track with double speed"},
509
551
                {TRACKING_SPEED_REALTIME, "REALTIME", 0, "Realtime", "Track with realtime speed"},
510
552
                {TRACKING_SPEED_HALF, "HALF", 0, "Half", "Track with half of realtime speed"},
511
553
                {TRACKING_SPEED_QUARTER, "QUARTER", 0, "Quarter", "Track with quarter of realtime speed"},
512
 
                {0, NULL, 0, NULL, NULL}};
 
554
                {0, NULL, 0, NULL, NULL}
 
555
        };
513
556
 
514
557
        static EnumPropertyItem cleanup_items[] = {
515
558
                {TRACKING_CLEAN_SELECT, "SELECT", 0, "Select", "Select unclean tracks"},
521
564
        static EnumPropertyItem refine_items[] = {
522
565
                {0, "NONE", 0, "Nothing", "Do not refine camera intrinsics"},
523
566
                {REFINE_FOCAL_LENGTH, "FOCAL_LENGTH", 0, "Focal Length", "Refine focal length"},
524
 
                {REFINE_FOCAL_LENGTH|REFINE_RADIAL_DISTORTION_K1, "FOCAL_LENGTH_RADIAL_K1", 0, "Focal length, K1",
525
 
                                                                  "Refine focal length and radial distortion K1"},
526
 
                {REFINE_FOCAL_LENGTH|
527
 
                 REFINE_RADIAL_DISTORTION_K1|
 
567
                {REFINE_FOCAL_LENGTH | REFINE_RADIAL_DISTORTION_K1, "FOCAL_LENGTH_RADIAL_K1", 0, "Focal length, K1",
 
568
                 "Refine focal length and radial distortion K1"},
 
569
                {REFINE_FOCAL_LENGTH |
 
570
                 REFINE_RADIAL_DISTORTION_K1 |
528
571
                 REFINE_RADIAL_DISTORTION_K2, "FOCAL_LENGTH_RADIAL_K1_K2", 0, "Focal length, K1, K2",
529
 
                                              "Refine focal length and radial distortion K1 and K2"},
530
 
                {REFINE_FOCAL_LENGTH|
531
 
                 REFINE_PRINCIPAL_POINT|
532
 
                 REFINE_RADIAL_DISTORTION_K1|
 
572
                 "Refine focal length and radial distortion K1 and K2"},
 
573
                {REFINE_FOCAL_LENGTH |
 
574
                 REFINE_PRINCIPAL_POINT |
 
575
                 REFINE_RADIAL_DISTORTION_K1 |
533
576
                 REFINE_RADIAL_DISTORTION_K2, "FOCAL_LENGTH_PRINCIPAL_POINT_RADIAL_K1_K2", 0,
534
 
                                              "Focal Length, Optical Center, K1, K2",
535
 
                                              "Refine focal length, optical center and radial distortion K1 and K2"},
536
 
                {REFINE_FOCAL_LENGTH|
 
577
                 "Focal Length, Optical Center, K1, K2",
 
578
                 "Refine focal length, optical center and radial distortion K1 and K2"},
 
579
                {REFINE_FOCAL_LENGTH |
537
580
                 REFINE_PRINCIPAL_POINT, "FOCAL_LENGTH_PRINCIPAL_POINT", 0, "Focal Length, Optical Center",
538
 
                                         "Refine focal length and optical center"},
 
581
                 "Refine focal length and optical center"},
539
582
                {0, NULL, 0, NULL, NULL}
540
583
        };
541
584
 
550
593
                                 "Limit speed of tracking to make visual feedback easier "
551
594
                                 "(this does not affect the tracking quality)");
552
595
 
553
 
        /* keyframe_a */
554
 
        prop = RNA_def_property(srna, "keyframe_a", PROP_INT, PROP_NONE);
 
596
        /* reconstruction success_threshold */
 
597
        prop = RNA_def_property(srna, "reconstruction_success_threshold", PROP_FLOAT, PROP_NONE);
555
598
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
556
 
        RNA_def_property_int_sdna(prop, NULL, "keyframe1");
557
 
        RNA_def_property_ui_text(prop, "Keyframe A", "First keyframe used for reconstruction initialization");
 
599
        RNA_def_property_float_default(prop, 0.001f);
 
600
        RNA_def_property_range(prop, 0, FLT_MAX);
 
601
        RNA_def_property_ui_text(prop, "Success Threshold",
 
602
                                 "Threshold value of reconstruction error which is still considered successful");
558
603
 
559
 
        /* keyframe_b */
560
 
        prop = RNA_def_property(srna, "keyframe_b", PROP_INT, PROP_NONE);
 
604
        /* use fallback reconstruction */
 
605
        prop = RNA_def_property(srna, "use_fallback_reconstruction", PROP_BOOLEAN, PROP_NONE);
561
606
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
562
 
        RNA_def_property_int_sdna(prop, NULL, "keyframe2");
563
 
        RNA_def_property_ui_text(prop, "Keyframe B", "Second keyframe used for reconstruction initialization");
 
607
        RNA_def_property_boolean_sdna(prop, NULL, "reconstruction_flag", TRACKING_USE_FALLBACK_RECONSTRUCTION);
 
608
        RNA_def_property_ui_text(prop, "Use Fallback",
 
609
                                 "Use fallback reconstruction algorithm in cases main reconstruction algorithm failed "
 
610
                                 "(could give better solution with bad tracks)");
564
611
 
565
612
        /* intrinsics refinement during bundle adjustment */
566
613
        prop = RNA_def_property(srna, "refine_intrinsics", PROP_ENUM, PROP_NONE);
607
654
        RNA_def_property_ui_text(prop, "Show Expanded", "Show the expanded in the user interface");
608
655
        RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
609
656
 
610
 
        /* limit frames */
 
657
        /* solver settings */
 
658
        prop = RNA_def_property(srna, "use_tripod_solver", PROP_BOOLEAN, PROP_NONE);
 
659
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
660
        RNA_def_property_boolean_sdna(prop, NULL, "motion_flag", TRACKING_MOTION_TRIPOD);
 
661
        RNA_def_property_ui_text(prop, "Tripod Motion",
 
662
                                 "Use special solver to track a stable camera position, such as a tripod");
 
663
 
 
664
        /* default_limit_frames */
611
665
        prop = RNA_def_property(srna, "default_frames_limit", PROP_INT, PROP_NONE);
612
666
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
613
667
        RNA_def_property_int_sdna(prop, NULL, "default_frames_limit");
614
668
        RNA_def_property_range(prop, 0, SHRT_MAX);
615
669
        RNA_def_property_ui_text(prop, "Frames Limit", "Every tracking cycle, this number of frames are tracked");
616
670
 
617
 
        /* pattern match */
 
671
        /* default_pattern_match */
618
672
        prop = RNA_def_property(srna, "default_pattern_match", PROP_ENUM, PROP_NONE);
619
673
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
620
674
        RNA_def_property_enum_sdna(prop, NULL, "default_pattern_match");
622
676
        RNA_def_property_ui_text(prop, "Pattern Match",
623
677
                                 "Track pattern from given frame when tracking marker to next frame");
624
678
 
625
 
        /* margin */
 
679
        /* default_margin */
626
680
        prop = RNA_def_property(srna, "default_margin", PROP_INT, PROP_NONE);
627
681
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
628
682
        RNA_def_property_int_sdna(prop, NULL, "default_margin");
629
683
        RNA_def_property_range(prop, 0, 300);
630
 
        RNA_def_property_ui_text(prop, "Margin", "Default distance from image boudary at which marker stops tracking");
631
 
 
632
 
        /* tracking algorithm */
633
 
        prop = RNA_def_property(srna, "default_tracker", PROP_ENUM, PROP_NONE);
634
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
635
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
636
 
        RNA_def_property_enum_items(prop, tracker_items);
637
 
        RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_levelsUpdate");
638
 
        RNA_def_property_ui_text(prop, "Tracker", "Default tracking algorithm to use");
639
 
 
640
 
        /* pyramid level for pyramid klt tracking */
641
 
        prop = RNA_def_property(srna, "default_pyramid_levels", PROP_INT, PROP_NONE);
642
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
643
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
644
 
        RNA_def_property_int_sdna(prop, NULL, "default_pyramid_levels");
645
 
        RNA_def_property_range(prop, 1, 16);
646
 
        RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_levelsUpdate");
647
 
        RNA_def_property_ui_text(prop, "Pyramid levels", "Default number of pyramid levels (increase on blurry footage)");
648
 
 
649
 
        /* minmal correlation - only used for SAD tracker */
 
684
        RNA_def_property_ui_text(prop, "Margin", "Default distance from image boundary at which marker stops tracking");
 
685
 
 
686
        /* default_tracking_motion_model */
 
687
        prop = RNA_def_property(srna, "default_motion_model", PROP_ENUM, PROP_NONE);
 
688
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
689
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
690
        RNA_def_property_enum_items(prop, tracker_motion_model);
 
691
        RNA_def_property_ui_text(prop, "Motion model", "Default motion model to use for tracking");
 
692
 
 
693
        /* default_use_brute */
 
694
        prop = RNA_def_property(srna, "use_default_brute", PROP_BOOLEAN, PROP_NONE);
 
695
        RNA_def_property_boolean_sdna(prop, NULL, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_BRUTE);
 
696
        RNA_def_property_ui_text(prop, "Prepass", "Use a brute-force translation-only initialization when tracking");
 
697
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
 
698
 
 
699
        /* default_use_brute */
 
700
        prop = RNA_def_property(srna, "use_default_mask", PROP_BOOLEAN, PROP_NONE);
 
701
        RNA_def_property_boolean_sdna(prop, NULL, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_MASK);
 
702
        RNA_def_property_ui_text(prop, "Use Mask",
 
703
                                 "Use a grease pencil datablock as a mask to use only specified areas of pattern "
 
704
                                 "when tracking");
 
705
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
 
706
 
 
707
        /* default_use_normalization */
 
708
        prop = RNA_def_property(srna, "use_default_normalization", PROP_BOOLEAN, PROP_NONE);
 
709
        RNA_def_property_boolean_sdna(prop, NULL, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_NORMALIZATION);
 
710
        RNA_def_property_ui_text(prop, "Normalize", "Normalize light intensities while tracking (slower)");
 
711
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
 
712
 
 
713
        /* default minmal correlation */
650
714
        prop = RNA_def_property(srna, "default_correlation_min", PROP_FLOAT, PROP_NONE);
651
715
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
652
716
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
653
717
        RNA_def_property_float_sdna(prop, NULL, "default_minimum_correlation");
654
 
        RNA_def_property_range(prop, -1.0f, 1.0f);
655
 
        RNA_def_property_ui_range(prop, -1.0f, 1.0f, 0.1, 3);
 
718
        RNA_def_property_range(prop, 0.0f, 1.0f);
 
719
        RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.05, 3);
656
720
        RNA_def_property_ui_text(prop, "Correlation",
657
 
                                 "Default minimal value of correlation between matched pattern and reference "
658
 
                                 "which is still treated as successful tracking");
 
721
                                 "Default minimum value of correlation between matched pattern and reference "
 
722
                                 "that is still treated as successful tracking");
659
723
 
660
724
        /* default pattern size */
661
725
        prop = RNA_def_property(srna, "default_pattern_size", PROP_INT, PROP_NONE);
673
737
        RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_searchUpdate");
674
738
        RNA_def_property_ui_text(prop, "Search Size", "Size of search area for newly created tracks");
675
739
 
676
 
        /* use_red_channel */
 
740
        /* default use_red_channel */
677
741
        prop = RNA_def_property(srna, "use_default_red_channel", PROP_BOOLEAN, PROP_NONE);
678
742
        RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_RED);
679
743
        RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
680
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
744
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
681
745
 
682
 
        /* use_green_channel */
 
746
        /* default_use_green_channel */
683
747
        prop = RNA_def_property(srna, "use_default_green_channel", PROP_BOOLEAN, PROP_NONE);
684
748
        RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_GREEN);
685
749
        RNA_def_property_ui_text(prop, "Use Green Channel", "Use green channel from footage for tracking");
686
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
750
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
687
751
 
688
 
        /* use_blue_channel */
 
752
        /* default_use_blue_channel */
689
753
        prop = RNA_def_property(srna, "use_default_blue_channel", PROP_BOOLEAN, PROP_NONE);
690
754
        RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_BLUE);
691
755
        RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
692
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
756
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
693
757
 
694
758
        /* ** object tracking ** */
695
759
 
711
775
        static EnumPropertyItem camera_units_items[] = {
712
776
                {CAMERA_UNITS_PX, "PIXELS", 0, "px", "Use pixels for units of focal length"},
713
777
                {CAMERA_UNITS_MM, "MILLIMETERS", 0, "mm", "Use millimeters for units of focal length"},
714
 
                {0, NULL, 0, NULL, NULL}};
 
778
                {0, NULL, 0, NULL, NULL}
 
779
        };
715
780
 
716
781
        srna = RNA_def_struct(brna, "MovieTrackingCamera", NULL);
717
782
        RNA_def_struct_path_func(srna, "rna_trackingCamera_path");
723
788
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
724
789
        RNA_def_property_range(prop, 0.0f, 500.0f);
725
790
        RNA_def_property_ui_text(prop, "Sensor", "Width of CCD sensor in millimeters");
726
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
 
791
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
727
792
 
728
793
        /* Focal Length */
729
794
        prop = RNA_def_property(srna, "focal_length", PROP_FLOAT, PROP_NONE);
732
797
        RNA_def_property_range(prop, 0.0001f, 5000.0f);
733
798
        RNA_def_property_float_funcs(prop, "rna_trackingCamera_focal_mm_get", "rna_trackingCamera_focal_mm_set", NULL);
734
799
        RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
735
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
 
800
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
736
801
 
737
802
        /* Focal Length in pixels */
738
803
        prop = RNA_def_property(srna, "focal_length_pixels", PROP_FLOAT, PROP_NONE);
740
805
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
741
806
        RNA_def_property_range(prop, 0.0f, 5000.0f);
742
807
        RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
743
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
 
808
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
744
809
 
745
810
        /* Units */
746
811
        prop = RNA_def_property(srna, "units", PROP_ENUM, PROP_NONE);
756
821
        RNA_def_property_float_sdna(prop, NULL, "principal");
757
822
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
758
823
        RNA_def_property_ui_text(prop, "Principal Point", "Optical center of lens");
759
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
 
824
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
760
825
 
761
826
        /* Radial distortion parameters */
762
827
        prop = RNA_def_property(srna, "k1", PROP_FLOAT, PROP_NONE);
763
828
        RNA_def_property_float_sdna(prop, NULL, "k1");
764
829
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
765
 
        RNA_def_property_ui_range(prop, -10, 10, .1, 3);
 
830
        RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
766
831
        RNA_def_property_ui_text(prop, "K1", "First coefficient of third order polynomial radial distortion");
767
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
 
832
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
768
833
 
769
834
        prop = RNA_def_property(srna, "k2", PROP_FLOAT, PROP_NONE);
770
835
        RNA_def_property_float_sdna(prop, NULL, "k2");
771
836
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
772
 
        RNA_def_property_ui_range(prop, -10, 10, .1, 3);
 
837
        RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
773
838
        RNA_def_property_ui_text(prop, "K2", "Second coefficient of third order polynomial radial distortion");
774
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
 
839
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
775
840
 
776
841
        prop = RNA_def_property(srna, "k3", PROP_FLOAT, PROP_NONE);
777
842
        RNA_def_property_float_sdna(prop, NULL, "k3");
778
843
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
779
 
        RNA_def_property_ui_range(prop, -10, 10, .1, 3);
 
844
        RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
780
845
        RNA_def_property_ui_text(prop, "K3", "Third coefficient of third order polynomial radial distortion");
781
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
 
846
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
782
847
 
783
848
        /* pixel aspect */
784
849
        prop = RNA_def_property(srna, "pixel_aspect", PROP_FLOAT, PROP_XYZ);
788
853
        RNA_def_property_ui_range(prop, 0.1f, 5000.0f, 1, 2);
789
854
        RNA_def_property_float_default(prop, 1.0f);
790
855
        RNA_def_property_ui_text(prop, "Pixel Aspect Ratio", "Pixel aspect ratio");
791
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
 
856
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
792
857
}
793
858
 
794
859
static void rna_def_trackingMarker(BlenderRNA *brna)
796
861
        StructRNA *srna;
797
862
        PropertyRNA *prop;
798
863
 
 
864
        static int boundbox_dimsize[] = {2, 2};
 
865
 
799
866
        srna = RNA_def_struct(brna, "MovieTrackingMarker", NULL);
800
867
        RNA_def_struct_ui_text(srna, "Movie tracking marker data", "Match-moving marker data for tracking");
801
868
 
805
872
        RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
806
873
        RNA_def_property_float_sdna(prop, NULL, "pos");
807
874
        RNA_def_property_ui_text(prop, "Position", "Marker position at frame in normalized coordinates");
808
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
 
875
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
809
876
 
810
877
        /* frame */
811
878
        prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
812
879
        RNA_def_property_int_sdna(prop, NULL, "framenr");
813
880
        RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
814
881
        RNA_def_property_int_funcs(prop, NULL, "rna_trackingMarker_frame_set", NULL);
815
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, 0);
 
882
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, 0);
816
883
 
817
884
        /* enable */
818
885
        prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
819
886
        RNA_def_property_boolean_sdna(prop, NULL, "flag", MARKER_DISABLED);
820
887
        RNA_def_property_ui_text(prop, "Mode", "Is marker muted for current frame");
821
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
 
888
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
 
889
 
 
890
        /* pattern */
 
891
        prop = RNA_def_property(srna, "pattern_corners", PROP_FLOAT, PROP_MATRIX);
 
892
        RNA_def_property_float_sdna(prop, NULL, "pattern_corners");
 
893
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
894
        RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x2);
 
895
        RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
 
896
        RNA_def_property_ui_text(prop, "Pattern Corners",
 
897
                                 "Array of coordinates which represents pattern's corners in "
 
898
                                 "normalized coordinates relative to marker position");
 
899
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerPattern_update");
 
900
 
 
901
        prop = RNA_def_property(srna, "pattern_bound_box", PROP_FLOAT, PROP_NONE);
 
902
        RNA_def_property_multi_array(prop, 2, boundbox_dimsize);
 
903
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 
904
        RNA_def_property_float_funcs(prop, "rna_tracking_markerPattern_boundbox_get", NULL, NULL);
 
905
        RNA_def_property_ui_text(prop, "Pattern Bounding Box", "Pattern area bounding box in normalized coordinates");
 
906
 
 
907
        /* search */
 
908
        prop = RNA_def_property(srna, "search_min", PROP_FLOAT, PROP_TRANSLATION);
 
909
        RNA_def_property_array(prop, 2);
 
910
        RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
 
911
        RNA_def_property_float_sdna(prop, NULL, "search_min");
 
912
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
913
        RNA_def_property_ui_text(prop, "Search Min",
 
914
                                 "Left-bottom corner of search area in normalized coordinates relative "
 
915
                                 "to marker position");
 
916
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerSearch_update");
 
917
 
 
918
        prop = RNA_def_property(srna, "search_max", PROP_FLOAT, PROP_TRANSLATION);
 
919
        RNA_def_property_array(prop, 2);
 
920
        RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
 
921
        RNA_def_property_float_sdna(prop, NULL, "search_max");
 
922
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
923
        RNA_def_property_ui_text(prop, "Search Max",
 
924
                                 "Right-bottom corner of search area in normalized coordinates relative "
 
925
                                 "to marker position");
 
926
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerSearch_update");
822
927
}
823
928
 
824
929
static void rna_def_trackingMarkers(BlenderRNA *brna, PropertyRNA *cprop)
837
942
        parm = RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
838
943
                           "Frame number to find marker for", MINFRAME, MAXFRAME);
839
944
        RNA_def_property_flag(parm, PROP_REQUIRED);
 
945
        RNA_def_boolean(func, "exact", TRUE, "Exact",
 
946
                        "Get marker at exact frame number rather than get estimated marker");
840
947
        parm = RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Marker for specified frame");
841
948
        RNA_def_function_return(func, parm);
842
949
 
875
982
        prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
876
983
        RNA_def_property_ui_text(prop, "Name", "Unique name of track");
877
984
        RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingTrack_name_set");
878
 
        RNA_def_property_string_maxlength(prop, MAX_ID_NAME-2);
879
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
 
985
        RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
 
986
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
880
987
        RNA_def_struct_name_property(srna, prop);
881
988
 
882
 
        /* Pattern */
883
 
        prop = RNA_def_property(srna, "pattern_min", PROP_FLOAT, PROP_TRANSLATION);
884
 
        RNA_def_property_array(prop, 2);
885
 
        RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
886
 
        RNA_def_property_float_sdna(prop, NULL, "pat_min");
887
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
888
 
        RNA_def_property_ui_text(prop, "Pattern Min",
889
 
                                 "Left-bottom corner of pattern area in normalized coordinates relative "
890
 
                                 "to marker position");
891
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPattern_update");
892
 
 
893
 
        prop = RNA_def_property(srna, "pattern_max", PROP_FLOAT, PROP_TRANSLATION);
894
 
        RNA_def_property_array(prop, 2);
895
 
        RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
896
 
        RNA_def_property_float_sdna(prop, NULL, "pat_max");
897
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
898
 
        RNA_def_property_ui_text(prop, "Pattern Max",
899
 
                                 "Right-bottom corner of pattern area in normalized coordinates relative "
900
 
                                 "to marker position");
901
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPattern_update");
902
 
 
903
 
        /* Search */
904
 
        prop = RNA_def_property(srna, "search_min", PROP_FLOAT, PROP_TRANSLATION);
905
 
        RNA_def_property_array(prop, 2);
906
 
        RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
907
 
        RNA_def_property_float_sdna(prop, NULL, "search_min");
908
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
909
 
        RNA_def_property_ui_text(prop, "Search Min",
910
 
                                 "Left-bottom corner of search area in normalized coordinates relative "
911
 
                                 "to marker position");
912
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerSearch_update");
913
 
 
914
 
        prop = RNA_def_property(srna, "search_max", PROP_FLOAT, PROP_TRANSLATION);
915
 
        RNA_def_property_array(prop, 2);
916
 
        RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
917
 
        RNA_def_property_float_sdna(prop, NULL, "search_max");
918
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
919
 
        RNA_def_property_ui_text(prop, "Search Max",
920
 
                                 "Right-bottom corner of search area in normalized coordinates relative "
921
 
                                 "to marker position");
922
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerSearch_update");
923
 
 
924
989
        /* limit frames */
925
990
        prop = RNA_def_property(srna, "frames_limit", PROP_INT, PROP_NONE);
926
991
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
944
1009
        RNA_def_property_int_sdna(prop, NULL, "margin");
945
1010
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
946
1011
        RNA_def_property_range(prop, 0, 300);
947
 
        RNA_def_property_ui_text(prop, "Margin", "Distance from image boudary at which marker stops tracking");
948
 
 
949
 
        /* tracking algorithm */
950
 
        prop = RNA_def_property(srna, "tracker", PROP_ENUM, PROP_NONE);
951
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
952
 
        RNA_def_property_enum_items(prop, tracker_items);
953
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
954
 
        RNA_def_property_ui_text(prop, "Tracker", "Tracking algorithm to use");
955
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerAlgorithm_update");
956
 
 
957
 
        /* pyramid level for pyramid klt tracking */
958
 
        prop = RNA_def_property(srna, "pyramid_levels", PROP_INT, PROP_NONE);
959
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
960
 
        RNA_def_property_int_sdna(prop, NULL, "pyramid_levels");
961
 
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
962
 
        RNA_def_property_range(prop, 1, 16);
963
 
        RNA_def_property_ui_text(prop, "Pyramid levels", "Number of pyramid levels (increase on blurry footage)");
964
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPyramid_update");
965
 
 
966
 
        /* minmal correlation - only used for SAD tracker */
 
1012
        RNA_def_property_ui_text(prop, "Margin", "Distance from image boundary at which marker stops tracking");
 
1013
 
 
1014
        /* tracking motion model */
 
1015
        prop = RNA_def_property(srna, "motion_model", PROP_ENUM, PROP_NONE);
 
1016
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
1017
        RNA_def_property_enum_items(prop, tracker_motion_model);
 
1018
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
1019
        RNA_def_property_ui_text(prop, "Motion model", "Default motion model to use for tracking");
 
1020
 
 
1021
        /* minimum correlation */
967
1022
        prop = RNA_def_property(srna, "correlation_min", PROP_FLOAT, PROP_NONE);
968
1023
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
969
1024
        RNA_def_property_float_sdna(prop, NULL, "minimum_correlation");
970
 
        RNA_def_property_range(prop, -1.0f, 1.0f);
971
 
        RNA_def_property_ui_range(prop, -1.0f, 1.0f, 0.1, 3);
 
1025
        RNA_def_property_range(prop, 0.0f, 1.0f);
 
1026
        RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.05, 3);
972
1027
        RNA_def_property_ui_text(prop, "Correlation",
973
1028
                                 "Minimal value of correlation between matched pattern and reference "
974
 
                                 "which is still treated as successful tracking");
 
1029
                                 "that is still treated as successful tracking");
 
1030
 
 
1031
        /* use_brute */
 
1032
        prop = RNA_def_property(srna, "use_brute", PROP_BOOLEAN, PROP_NONE);
 
1033
        RNA_def_property_boolean_sdna(prop, NULL, "algorithm_flag", TRACK_ALGORITHM_FLAG_USE_BRUTE);
 
1034
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
1035
        RNA_def_property_ui_text(prop, "Prepass", "Use a brute-force translation only pre-track before refinement");
 
1036
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
 
1037
 
 
1038
        /* use_brute */
 
1039
        prop = RNA_def_property(srna, "use_mask", PROP_BOOLEAN, PROP_NONE);
 
1040
        RNA_def_property_boolean_sdna(prop, NULL, "algorithm_flag", TRACK_ALGORITHM_FLAG_USE_MASK);
 
1041
        RNA_def_property_ui_text(prop, "Use Mask",
 
1042
                                 "Use a grease pencil datablock as a mask to use only specified areas of pattern "
 
1043
                                 "when tracking");
 
1044
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
 
1045
 
 
1046
        /* use_normalization */
 
1047
        prop = RNA_def_property(srna, "use_normalization", PROP_BOOLEAN, PROP_NONE);
 
1048
        RNA_def_property_boolean_sdna(prop, NULL, "algorithm_flag", TRACK_ALGORITHM_FLAG_USE_NORMALIZATION);
 
1049
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
1050
        RNA_def_property_ui_text(prop, "Normalize", "Normalize light intensities while tracking. Slower");
 
1051
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
975
1052
 
976
1053
        /* markers */
977
1054
        prop = RNA_def_property(srna, "markers", PROP_COLLECTION, PROP_NONE);
987
1064
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_RED);
988
1065
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
989
1066
        RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
990
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1067
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
991
1068
 
992
1069
        /* use_green_channel */
993
1070
        prop = RNA_def_property(srna, "use_green_channel", PROP_BOOLEAN, PROP_NONE);
994
1071
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_GREEN);
995
1072
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
996
1073
        RNA_def_property_ui_text(prop, "Use Green Channel", "Use green channel from footage for tracking");
997
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1074
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
998
1075
 
999
1076
        /* use_blue_channel */
1000
1077
        prop = RNA_def_property(srna, "use_blue_channel", PROP_BOOLEAN, PROP_NONE);
1001
1078
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_BLUE);
1002
1079
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1003
1080
        RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
1004
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1081
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1005
1082
 
1006
1083
        /* preview_grayscale */
1007
1084
        prop = RNA_def_property(srna, "use_grayscale_preview", PROP_BOOLEAN, PROP_NONE);
1008
1085
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_PREVIEW_GRAYSCALE);
1009
1086
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1010
1087
        RNA_def_property_ui_text(prop, "Grayscale", "Display what the tracking algorithm sees in the preview");
1011
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1088
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
 
1089
 
 
1090
        /* preview_alpha */
 
1091
        prop = RNA_def_property(srna, "use_alpha_preview", PROP_BOOLEAN, PROP_NONE);
 
1092
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_PREVIEW_ALPHA);
 
1093
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
1094
        RNA_def_property_ui_text(prop, "Alpha", "Apply track's mask on displaying preview");
 
1095
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1012
1096
 
1013
1097
        /* has bundle */
1014
1098
        prop = RNA_def_property(srna, "has_bundle", PROP_BOOLEAN, PROP_NONE);
1029
1113
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_HIDDEN);
1030
1114
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1031
1115
        RNA_def_property_ui_text(prop, "Hide", "Track is hidden");
1032
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1116
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1033
1117
 
1034
1118
        /* select */
1035
1119
        prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1036
1120
        RNA_def_property_boolean_funcs(prop, "rna_trackingTrack_select_get", "rna_trackingTrack_select_set");
1037
1121
        RNA_def_property_ui_text(prop, "Select", "Track is selected");
1038
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1122
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1039
1123
 
1040
1124
        /* select_anchor */
1041
1125
        prop = RNA_def_property(srna, "select_anchor", PROP_BOOLEAN, PROP_NONE);
1042
1126
        RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1043
1127
        RNA_def_property_ui_text(prop, "Select Anchor", "Track's anchor point is selected");
1044
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1128
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1045
1129
 
1046
1130
        /* select_pattern */
1047
1131
        prop = RNA_def_property(srna, "select_pattern", PROP_BOOLEAN, PROP_NONE);
1048
1132
        RNA_def_property_boolean_sdna(prop, NULL, "pat_flag", SELECT);
1049
1133
        RNA_def_property_ui_text(prop, "Select Pattern", "Track's pattern area is selected");
1050
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1134
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1051
1135
 
1052
1136
        /* select_search */
1053
1137
        prop = RNA_def_property(srna, "select_search", PROP_BOOLEAN, PROP_NONE);
1054
1138
        RNA_def_property_boolean_sdna(prop, NULL, "search_flag", SELECT);
1055
1139
        RNA_def_property_ui_text(prop, "Select Search", "Track's search area is selected");
1056
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1140
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1057
1141
 
1058
1142
        /* locked */
1059
1143
        prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1060
1144
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_LOCKED);
1061
1145
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1062
1146
        RNA_def_property_ui_text(prop, "Lock", "Track is locked and all changes to it are disabled");
1063
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1147
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1064
1148
 
1065
1149
        /* custom color */
1066
1150
        prop = RNA_def_property(srna, "use_custom_color", PROP_BOOLEAN, PROP_NONE);
1067
1151
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_CUSTOMCOLOR);
1068
1152
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1069
1153
        RNA_def_property_ui_text(prop, "Custom Color", "Use custom color instead of theme-defined");
1070
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1154
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1071
1155
 
1072
1156
        /* color */
1073
1157
        prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
1075
1159
        RNA_def_property_range(prop, 0.0f, 1.0f);
1076
1160
        RNA_def_property_ui_text(prop, "Color",
1077
1161
                                 "Color of the track in the Movie Clip Editor and the 3D viewport after a solve");
1078
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1162
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1079
1163
 
1080
1164
        /* average error */
1081
1165
        prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1082
1166
        RNA_def_property_float_sdna(prop, NULL, "error");
1083
1167
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1084
1168
        RNA_def_property_ui_text(prop, "Average Error", "Average error of re-projection");
 
1169
 
 
1170
        /* grease pencil */
 
1171
        prop = RNA_def_property(srna, "grease_pencil", PROP_POINTER, PROP_NONE);
 
1172
        RNA_def_property_pointer_sdna(prop, NULL, "gpd");
 
1173
        RNA_def_property_flag(prop, PROP_EDITABLE);
 
1174
        RNA_def_property_struct_type(prop, "GreasePencil");
 
1175
        RNA_def_property_ui_text(prop, "Grease Pencil", "Grease pencil data for this track");
 
1176
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1085
1177
}
1086
1178
 
1087
1179
static void rna_def_trackingStabilization(BlenderRNA *brna)
1090
1182
        PropertyRNA *prop;
1091
1183
 
1092
1184
        static EnumPropertyItem filter_items[] = {
1093
 
                {TRACKING_FILTER_NEAREAST, "NEAREST",   0, "Nearest",   ""},
 
1185
                {TRACKING_FILTER_NEAREST, "NEAREST",   0, "Nearest",   ""},
1094
1186
                {TRACKING_FILTER_BILINEAR, "BILINEAR",   0, "Bilinear",   ""},
1095
1187
                {TRACKING_FILTER_BICUBIC, "BICUBIC", 0, "Bicubic", ""},
1096
 
                {0, NULL, 0, NULL, NULL}};
 
1188
                {0, NULL, 0, NULL, NULL}
 
1189
        };
1097
1190
 
1098
1191
        srna = RNA_def_struct(brna, "MovieTrackingStabilization", NULL);
1099
1192
        RNA_def_struct_path_func(srna, "rna_trackingStabilization_path");
1104
1197
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_2D_STABILIZATION);
1105
1198
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1106
1199
        RNA_def_property_ui_text(prop, "Use 2D stabilization", "Use 2D stabilization for footage");
1107
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
 
1200
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1108
1201
 
1109
1202
        /* tracks */
1110
1203
        prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1113
1206
                                          NULL, NULL, NULL, NULL);
1114
1207
        RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1115
1208
        RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks used for stabilization");
1116
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
 
1209
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1117
1210
 
1118
1211
        /* rotation track */
1119
1212
        prop = RNA_def_property(srna, "rotation_track", PROP_POINTER, PROP_NONE);
1120
1213
        RNA_def_property_pointer_sdna(prop, NULL, "rot_track");
1121
1214
        RNA_def_property_flag(prop, PROP_EDITABLE);
1122
1215
        RNA_def_property_ui_text(prop, "Rotation Track", "Track used to compensate rotation");
1123
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
 
1216
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1124
1217
 
1125
1218
        /* active track index */
1126
1219
        prop = RNA_def_property(srna, "active_track_index", PROP_INT, PROP_NONE);
1136
1229
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_AUTOSCALE);
1137
1230
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1138
1231
        RNA_def_property_ui_text(prop, "Autoscale",
1139
 
                                 "Automatically scale footage to cover unfilled areas when stabilizating");
1140
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
 
1232
                                 "Automatically scale footage to cover unfilled areas when stabilizing");
 
1233
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1141
1234
 
1142
1235
        /* max scale */
1143
1236
        prop = RNA_def_property(srna, "scale_max", PROP_FLOAT, PROP_FACTOR);
1144
1237
        RNA_def_property_float_sdna(prop, NULL, "maxscale");
1145
1238
        RNA_def_property_range(prop, 0.0f, 10.0f);
1146
1239
        RNA_def_property_ui_text(prop, "Maximal Scale", "Limit the amount of automatic scaling");
1147
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
 
1240
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1148
1241
 
1149
1242
        /* influence_location */
1150
1243
        prop = RNA_def_property(srna, "influence_location", PROP_FLOAT, PROP_FACTOR);
1151
1244
        RNA_def_property_float_sdna(prop, NULL, "locinf");
1152
1245
        RNA_def_property_range(prop, 0.0f, 1.0f);
1153
1246
        RNA_def_property_ui_text(prop, "Location Influence", "Influence of stabilization algorithm on footage location");
1154
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
 
1247
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1155
1248
 
1156
1249
        /* influence_scale */
1157
1250
        prop = RNA_def_property(srna, "influence_scale", PROP_FLOAT, PROP_FACTOR);
1158
1251
        RNA_def_property_float_sdna(prop, NULL, "scaleinf");
1159
1252
        RNA_def_property_range(prop, 0.0f, 1.0f);
1160
1253
        RNA_def_property_ui_text(prop, "Scale Influence", "Influence of stabilization algorithm on footage scale");
1161
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
 
1254
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1162
1255
 
1163
1256
        /* use_stabilize_rotation */
1164
1257
        prop = RNA_def_property(srna, "use_stabilize_rotation", PROP_BOOLEAN, PROP_NONE);
1165
1258
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1166
1259
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_STABILIZE_ROTATION);
1167
1260
        RNA_def_property_ui_text(prop, "Stabilize Rotation", "Stabilize horizon line on the shot");
1168
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
 
1261
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1169
1262
 
1170
1263
        /* influence_rotation */
1171
1264
        prop = RNA_def_property(srna, "influence_rotation", PROP_FLOAT, PROP_FACTOR);
1172
1265
        RNA_def_property_float_sdna(prop, NULL, "rotinf");
1173
1266
        RNA_def_property_range(prop, 0.0f, 1.0f);
1174
1267
        RNA_def_property_ui_text(prop, "Rotation Influence", "Influence of stabilization algorithm on footage rotation");
1175
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
 
1268
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1176
1269
 
1177
1270
        /* filter */
1178
1271
        prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
1179
1272
        RNA_def_property_enum_sdna(prop, NULL, "filter");
1180
1273
        RNA_def_property_enum_items(prop, filter_items);
1181
1274
        RNA_def_property_ui_text(prop, "Filter", "Method to use to filter stabilization");
1182
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
 
1275
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1183
1276
}
1184
1277
 
1185
1278
static void rna_def_reconstructedCamera(BlenderRNA *brna)
1208
1301
        prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1209
1302
        RNA_def_property_float_sdna(prop, NULL, "error");
1210
1303
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1211
 
        RNA_def_property_ui_text(prop, "Average Error", "Average error of resonctruction");
 
1304
        RNA_def_property_ui_text(prop, "Average Error", "Average error of reconstruction");
1212
1305
}
1213
1306
 
1214
1307
static void rna_def_trackingReconstruction(BlenderRNA *brna)
1232
1325
        prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1233
1326
        RNA_def_property_float_sdna(prop, NULL, "error");
1234
1327
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1235
 
        RNA_def_property_ui_text(prop, "Average Error", "Average error of resonctruction");
 
1328
        RNA_def_property_ui_text(prop, "Average Error", "Average error of reconstruction");
1236
1329
 
1237
1330
        /* cameras */
1238
1331
        prop = RNA_def_property(srna, "cameras", PROP_COLLECTION, PROP_NONE);
1246
1339
        StructRNA *srna;
1247
1340
        FunctionRNA *func;
1248
1341
        PropertyRNA *prop;
 
1342
        PropertyRNA *parm;
1249
1343
 
1250
1344
        srna = RNA_def_struct(brna, "MovieTrackingTracks", NULL);
1251
1345
        RNA_def_struct_sdna(srna, "MovieTracking");
1252
1346
        RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
1253
1347
 
1254
 
        func = RNA_def_function(srna, "add", "rna_trackingTracks_add");
 
1348
        func = RNA_def_function(srna, "new", "rna_trackingTracks_new");
1255
1349
        RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1256
 
        RNA_def_function_ui_description(func, "Add a number of tracks to this movie clip");
1257
 
        RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to add tracks on", MINFRAME, MAXFRAME);
1258
 
        RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of tracks to add to the movie clip", 0, INT_MAX);
 
1350
        RNA_def_function_ui_description(func, "Create new motion track in this movie clip");
 
1351
        RNA_def_string(func, "name", "", 0, "", "Name of new track");
 
1352
        RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to add track on", MINFRAME, MAXFRAME);
 
1353
        parm = RNA_def_pointer(func, "track", "MovieTrackingTrack", "", "Newly created track");
 
1354
        RNA_def_function_return(func, parm);
1259
1355
 
1260
1356
        /* active track */
1261
1357
        prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1262
1358
        RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1263
1359
        RNA_def_property_pointer_funcs(prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", NULL, NULL);
1264
 
        RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
 
1360
        RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
1265
1361
        RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
1266
1362
}
1267
1363
 
1270
1366
        StructRNA *srna;
1271
1367
        FunctionRNA *func;
1272
1368
        PropertyRNA *prop;
 
1369
        PropertyRNA *parm;
1273
1370
 
1274
1371
        srna = RNA_def_struct(brna, "MovieTrackingObjectTracks", NULL);
1275
1372
        RNA_def_struct_sdna(srna, "MovieTrackingObject");
1276
1373
        RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
1277
1374
 
1278
 
        func = RNA_def_function(srna, "add", "rna_trackingObject_tracks_add");
 
1375
        func = RNA_def_function(srna, "new", "rna_trackingObject_tracks_new");
1279
1376
        RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1280
 
        RNA_def_function_ui_description(func, "Add a number of tracks to this movie clip");
 
1377
        RNA_def_function_ui_description(func, "create new motion track in this movie clip");
 
1378
        RNA_def_string(func, "name", "", 0, "", "Name of new track");
1281
1379
        RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to add tracks on", MINFRAME, MAXFRAME);
1282
 
        RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of tracks to add to the movie clip", 0, INT_MAX);
 
1380
        parm = RNA_def_pointer(func, "track", "MovieTrackingTrack", "", "Newly created track");
 
1381
        RNA_def_function_return(func, parm);
1283
1382
 
1284
1383
        /* active track */
1285
1384
        prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1286
1385
        RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1287
1386
        RNA_def_property_pointer_funcs(prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", NULL, NULL);
1288
 
        RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
 
1387
        RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
1289
1388
        RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
1290
1389
}
1291
1390
 
1301
1400
        prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1302
1401
        RNA_def_property_ui_text(prop, "Name", "Unique name of object");
1303
1402
        RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingObject_name_set");
1304
 
        RNA_def_property_string_maxlength(prop, MAX_ID_NAME-2);
1305
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
 
1403
        RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
 
1404
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1306
1405
        RNA_def_struct_name_property(srna, prop);
1307
1406
 
1308
1407
        /* is_camera */
1310
1409
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1311
1410
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_OBJECT_CAMERA);
1312
1411
        RNA_def_property_ui_text(prop, "Camera", "Object is used for camera tracking");
1313
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1412
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1314
1413
 
1315
1414
        /* tracks */
1316
1415
        prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1324
1423
        /* reconstruction */
1325
1424
        prop = RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
1326
1425
        RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
 
1426
        RNA_def_property_pointer_funcs(prop, "rna_trackingObject_reconstruction_get", NULL, NULL, NULL);
1327
1427
 
1328
1428
        /* scale */
1329
1429
        prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
1333
1433
        RNA_def_property_ui_range(prop, 0.0001f, 10000.0, 1, 4);
1334
1434
        RNA_def_property_float_default(prop, 1.0f);
1335
1435
        RNA_def_property_ui_text(prop, "Scale", "Scale of object solution in camera space");
1336
 
        RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_trackingObject_flushUpdate");
 
1436
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingObject_flushUpdate");
 
1437
 
 
1438
        /* keyframe_a */
 
1439
        prop = RNA_def_property(srna, "keyframe_a", PROP_INT, PROP_NONE);
 
1440
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
1441
        RNA_def_property_int_sdna(prop, NULL, "keyframe1");
 
1442
        RNA_def_property_ui_text(prop, "Keyframe A", "First keyframe used for reconstruction initialization");
 
1443
 
 
1444
        /* keyframe_b */
 
1445
        prop = RNA_def_property(srna, "keyframe_b", PROP_INT, PROP_NONE);
 
1446
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 
1447
        RNA_def_property_int_sdna(prop, NULL, "keyframe2");
 
1448
        RNA_def_property_ui_text(prop, "Keyframe B", "Second keyframe used for reconstruction initialization");
1337
1449
}
1338
1450
 
1339
1451
static void rna_def_trackingObjects(BlenderRNA *brna, PropertyRNA *cprop)
1357
1469
        RNA_def_function_return(func, parm);
1358
1470
 
1359
1471
        func = RNA_def_function(srna, "remove", "rna_trackingObject_remove");
 
1472
        RNA_def_function_flag(func, FUNC_USE_REPORTS);
1360
1473
        RNA_def_function_ui_description(func, "Remove tracking object from this movie clip");
1361
 
        RNA_def_pointer(func, "object", "MovieTrackingObject", "", "Motion tracking object to be removed");
 
1474
        parm = RNA_def_pointer(func, "object", "MovieTrackingObject", "", "Motion tracking object to be removed");
 
1475
        RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
 
1476
        RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1362
1477
 
1363
1478
        /* active object */
1364
1479
        prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1365
1480
        RNA_def_property_struct_type(prop, "MovieTrackingObject");
1366
1481
        RNA_def_property_pointer_funcs(prop, "rna_tracking_active_object_get",
1367
1482
                                       "rna_tracking_active_object_set", NULL, NULL);
1368
 
        RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
 
1483
        RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
1369
1484
        RNA_def_property_ui_text(prop, "Active Object", "Active object in this tracking data object");
1370
1485
}
1371
1486
 
 
1487
static void rna_def_trackingDopesheet(BlenderRNA *brna)
 
1488
{
 
1489
        StructRNA *srna;
 
1490
        PropertyRNA *prop;
 
1491
 
 
1492
        static EnumPropertyItem sort_items[] = {
 
1493
                {TRACKING_DOPE_SORT_NAME, "NAME", 0, "Name", "Sort channels by their names"},
 
1494
                {TRACKING_DOPE_SORT_LONGEST, "LONGEST", 0, "Longest", "Sort channels by longest tracked segment"},
 
1495
                {TRACKING_DOPE_SORT_TOTAL, "TOTAL", 0, "Total", "Sort channels by overall amount of tracked segments"},
 
1496
                {TRACKING_DOPE_SORT_AVERAGE_ERROR, "AVERAGE_ERROR", 0, "Average Error",
 
1497
                                                   "Sort channels by average reprojection error of tracks after solve"},
 
1498
                {0, NULL, 0, NULL, NULL}
 
1499
        };
 
1500
 
 
1501
        srna = RNA_def_struct(brna, "MovieTrackingDopesheet", NULL);
 
1502
        RNA_def_struct_ui_text(srna, "Movie Tracking Dopesheet", "Match-moving dopesheet data");
 
1503
 
 
1504
        /* dopesheet sort */
 
1505
        prop = RNA_def_property(srna, "sort_method", PROP_ENUM, PROP_NONE);
 
1506
        RNA_def_property_enum_sdna(prop, NULL, "sort_method");
 
1507
        RNA_def_property_enum_items(prop, sort_items);
 
1508
        RNA_def_property_ui_text(prop, "Dopesheet Sort Field", "Method to be used to sort channels in dopesheet view");
 
1509
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
 
1510
 
 
1511
        /* invert_dopesheet_sort */
 
1512
        prop = RNA_def_property(srna, "use_invert_sort", PROP_BOOLEAN, PROP_NONE);
 
1513
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_DOPE_SORT_INVERSE);
 
1514
        RNA_def_property_ui_text(prop, "Invert Dopesheet Sort", "Invert sort order of dopesheet channels");
 
1515
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
 
1516
 
 
1517
        /* show_only_selected */
 
1518
        prop = RNA_def_property(srna, "show_only_selected", PROP_BOOLEAN, PROP_NONE);
 
1519
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_DOPE_SELECTED_ONLY);
 
1520
        RNA_def_property_ui_text(prop, "Only Selected", "Only include channels relating to selected objects and data");
 
1521
        RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 0);
 
1522
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
 
1523
 
 
1524
        /* show_hidden */
 
1525
        prop = RNA_def_property(srna, "show_hidden", PROP_BOOLEAN, PROP_NONE);
 
1526
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_DOPE_SHOW_HIDDEN);
 
1527
        RNA_def_property_ui_text(prop, "Display Hidden", "Include channels from objects/bone that aren't visible");
 
1528
        RNA_def_property_ui_icon(prop, ICON_GHOST_ENABLED, 0);
 
1529
        RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
 
1530
}
 
1531
 
1372
1532
static void rna_def_tracking(BlenderRNA *brna)
1373
1533
{
1374
1534
        StructRNA *srna;
1382
1542
        rna_def_trackingStabilization(brna);
1383
1543
        rna_def_trackingReconstruction(brna);
1384
1544
        rna_def_trackingObject(brna);
 
1545
        rna_def_trackingDopesheet(brna);
1385
1546
 
1386
1547
        srna = RNA_def_struct(brna, "MovieTracking", NULL);
1387
1548
        RNA_def_struct_path_func(srna, "rna_tracking_path");
1428
1589
        RNA_def_property_int_funcs(prop, "rna_tracking_active_object_index_get", "rna_tracking_active_object_index_set",
1429
1590
                                   "rna_tracking_active_object_index_range");
1430
1591
        RNA_def_property_ui_text(prop, "Active Object Index", "Index of active object");
1431
 
        RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
 
1592
        RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
 
1593
 
 
1594
        /* dopesheet */
 
1595
        prop = RNA_def_property(srna, "dopesheet", PROP_POINTER, PROP_NONE);
 
1596
        RNA_def_property_struct_type(prop, "MovieTrackingDopesheet");
1432
1597
}
1433
1598
 
1434
1599
void RNA_def_tracking(BlenderRNA *brna)