Tracking: Disable animation of auto-keyframe option
[blender-staging.git] / source / blender / makesrna / intern / rna_tracking.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation,
19  *                 Sergey Sharybin
20  *
21  * ***** END GPL LICENSE BLOCK *****
22  */
23
24 /** \file blender/makesrna/intern/rna_tracking.c
25  *  \ingroup RNA
26  */
27
28
29 #include <stdlib.h>
30 #include <limits.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "BLI_math.h"
35 #include "BKE_movieclip.h"
36 #include "BKE_tracking.h"
37
38 #include "RNA_access.h"
39 #include "RNA_define.h"
40
41 #include "rna_internal.h"
42
43 #include "DNA_movieclip_types.h"
44 #include "DNA_object_types.h"   /* SELECT */
45 #include "DNA_scene_types.h"
46
47 #include "WM_types.h"
48
49 #ifdef RNA_RUNTIME
50
51 #include "BKE_depsgraph.h"
52 #include "BKE_node.h"
53
54 #include "IMB_imbuf.h"
55
56 #include "WM_api.h"
57
58 static char *rna_tracking_path(PointerRNA *UNUSED(ptr))
59 {
60         return BLI_sprintfN("tracking");
61 }
62
63 static void rna_tracking_defaultSettings_patternUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
64 {
65         MovieClip *clip = (MovieClip *)ptr->id.data;
66         MovieTracking *tracking = &clip->tracking;
67         MovieTrackingSettings *settings = &tracking->settings;
68
69         if (settings->default_search_size < settings->default_pattern_size)
70                 settings->default_search_size = settings->default_pattern_size;
71 }
72
73 static void rna_tracking_defaultSettings_searchUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
74 {
75         MovieClip *clip = (MovieClip *)ptr->id.data;
76         MovieTracking *tracking = &clip->tracking;
77         MovieTrackingSettings *settings = &tracking->settings;
78
79         if (settings->default_pattern_size > settings->default_search_size)
80                 settings->default_pattern_size = settings->default_search_size;
81 }
82
83 static char *rna_trackingTrack_path(PointerRNA *ptr)
84 {
85         MovieClip *clip = (MovieClip *)ptr->id.data;
86         MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
87         /* Escaped object name, escaped track name, rest of the path. */
88         char rna_path[MAX_NAME * 4 + 64];
89         BKE_tracking_get_rna_path_for_track(&clip->tracking,
90                                             track,
91                                             rna_path, sizeof(rna_path));
92         return BLI_strdup(rna_path);
93 }
94
95 static void rna_trackingTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
96 {
97         MovieClip *clip = (MovieClip *)ptr->id.data;
98
99         rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
100 }
101
102 static void rna_trackingPlaneTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
103 {
104         MovieClip *clip = (MovieClip *)ptr->id.data;
105
106         rna_iterator_listbase_begin(iter, &clip->tracking.plane_tracks, NULL);
107 }
108
109 static void rna_trackingObjects_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
110 {
111         MovieClip *clip = (MovieClip *)ptr->id.data;
112
113         rna_iterator_listbase_begin(iter, &clip->tracking.objects, NULL);
114 }
115
116 static int rna_tracking_active_object_index_get(PointerRNA *ptr)
117 {
118         MovieClip *clip = (MovieClip *)ptr->id.data;
119
120         return clip->tracking.objectnr;
121 }
122
123 static void rna_tracking_active_object_index_set(PointerRNA *ptr, int value)
124 {
125         MovieClip *clip = (MovieClip *)ptr->id.data;
126
127         clip->tracking.objectnr = value;
128         BKE_tracking_dopesheet_tag_update(&clip->tracking);
129 }
130
131 static void rna_tracking_active_object_index_range(PointerRNA *ptr, int *min, int *max,
132                                                    int *UNUSED(softmin), int *UNUSED(softmax))
133 {
134         MovieClip *clip = (MovieClip *)ptr->id.data;
135
136         *min = 0;
137         *max = max_ii(0, clip->tracking.tot_object - 1);
138 }
139
140 static PointerRNA rna_tracking_active_track_get(PointerRNA *ptr)
141 {
142         MovieClip *clip = (MovieClip *)ptr->id.data;
143         MovieTrackingTrack *act_track = BKE_tracking_track_get_active(&clip->tracking);
144
145         return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingTrack, act_track);
146 }
147
148 static void rna_tracking_active_track_set(PointerRNA *ptr, PointerRNA value)
149 {
150         MovieClip *clip = (MovieClip *)ptr->id.data;
151         MovieTrackingTrack *track = (MovieTrackingTrack *)value.data;
152         ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
153         int index = BLI_findindex(tracksbase, track);
154
155         if (index != -1)
156                 clip->tracking.act_track = track;
157         else
158                 clip->tracking.act_track = NULL;
159 }
160
161 static PointerRNA rna_tracking_active_plane_track_get(PointerRNA *ptr)
162 {
163         MovieClip *clip = (MovieClip *)ptr->id.data;
164         MovieTrackingPlaneTrack *act_plane_track = BKE_tracking_plane_track_get_active(&clip->tracking);
165
166         return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingPlaneTrack, act_plane_track);
167 }
168
169 static void rna_tracking_active_plane_track_set(PointerRNA *ptr, PointerRNA value)
170 {
171         MovieClip *clip = (MovieClip *)ptr->id.data;
172         MovieTrackingPlaneTrack *plane_track = (MovieTrackingPlaneTrack *) value.data;
173         ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(&clip->tracking);
174         int index = BLI_findindex(plane_tracks_base, plane_track);
175
176         if (index != -1)
177                 clip->tracking.act_plane_track = plane_track;
178         else
179                 clip->tracking.act_plane_track = NULL;
180 }
181
182 static void rna_trackingTrack_name_set(PointerRNA *ptr, const char *value)
183 {
184         MovieClip *clip = (MovieClip *)ptr->id.data;
185         MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
186         ListBase *tracksbase =
187                 BKE_tracking_find_tracks_list_for_track(&clip->tracking, track);
188         BLI_strncpy(track->name, value, sizeof(track->name));
189         BKE_tracking_track_unique_name(tracksbase, track);
190 }
191
192 static int rna_trackingTrack_select_get(PointerRNA *ptr)
193 {
194         MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
195
196         return TRACK_SELECTED(track);
197 }
198
199 static void rna_trackingTrack_select_set(PointerRNA *ptr, int value)
200 {
201         MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
202
203         if (value) {
204                 track->flag |= SELECT;
205                 track->pat_flag |= SELECT;
206                 track->search_flag |= SELECT;
207         }
208         else {
209                 track->flag &= ~SELECT;
210                 track->pat_flag &= ~SELECT;
211                 track->search_flag &= ~SELECT;
212         }
213 }
214
215 static void rna_trackingPlaneMarker_frame_set(PointerRNA *ptr, int value)
216 {
217         MovieClip *clip = (MovieClip *) ptr->id.data;
218         MovieTracking *tracking = &clip->tracking;
219         MovieTrackingPlaneMarker *plane_marker = (MovieTrackingPlaneMarker *) ptr->data;
220         MovieTrackingObject *tracking_object;
221         bool found = false;
222         MovieTrackingPlaneTrack *plane_track = NULL;
223
224         for (tracking_object = tracking->objects.first;
225              tracking_object;
226              tracking_object = tracking_object->next)
227         {
228                 ListBase *tracksbase = BKE_tracking_object_get_plane_tracks(tracking, tracking_object);
229
230                 for (plane_track = tracksbase->first;
231                      plane_track;
232                      plane_track = plane_track->next)
233                 {
234                         if (plane_marker >= plane_track->markers && plane_marker < plane_track->markers + plane_track->markersnr) {
235                                 found = true;
236                                 break;
237                         }
238                 }
239
240                 if (found) {
241                         break;
242                 }
243         }
244
245         if (found) {
246                 MovieTrackingPlaneMarker new_plane_marker = *plane_marker;
247                 new_plane_marker.framenr = value;
248
249                 BKE_tracking_plane_marker_delete(plane_track, plane_marker->framenr);
250                 BKE_tracking_plane_marker_insert(plane_track, &new_plane_marker);
251         }
252 }
253
254 static char *rna_trackingPlaneTrack_path(PointerRNA *ptr)
255 {
256         MovieClip *clip = (MovieClip *)ptr->id.data;
257         MovieTrackingPlaneTrack *plane_track = (MovieTrackingPlaneTrack *)ptr->data;
258         /* Escaped object name, escaped track name, rest of the path. */
259         char rna_path[MAX_NAME * 4 + 64];
260         BKE_tracking_get_rna_path_for_plane_track(&clip->tracking,
261                                                   plane_track,
262                                                   rna_path, sizeof(rna_path));
263         return BLI_strdup(rna_path);
264 }
265
266 static void rna_trackingPlaneTrack_name_set(PointerRNA *ptr, const char *value)
267 {
268         MovieClip *clip = (MovieClip *)ptr->id.data;
269         MovieTrackingPlaneTrack *plane_track = (MovieTrackingPlaneTrack *)ptr->data;
270         ListBase *plane_tracks_base =
271                 BKE_tracking_find_tracks_list_for_plane_track(&clip->tracking,
272                                                               plane_track);
273         BLI_strncpy(plane_track->name, value, sizeof(plane_track->name));
274         BKE_tracking_plane_track_unique_name(plane_tracks_base, plane_track);
275 }
276
277 static char *rna_trackingCamera_path(PointerRNA *UNUSED(ptr))
278 {
279         return BLI_sprintfN("tracking.camera");
280 }
281
282 static float rna_trackingCamera_focal_mm_get(PointerRNA *ptr)
283 {
284         MovieClip *clip = (MovieClip *)ptr->id.data;
285         MovieTrackingCamera *camera = &clip->tracking.camera;
286         float val = camera->focal;
287
288         if (clip->lastsize[0])
289                 val = val * camera->sensor_width / (float)clip->lastsize[0];
290
291         return val;
292 }
293
294 static void rna_trackingCamera_focal_mm_set(PointerRNA *ptr, float value)
295 {
296         MovieClip *clip = (MovieClip *)ptr->id.data;
297         MovieTrackingCamera *camera = &clip->tracking.camera;
298
299         if (clip->lastsize[0])
300                 value = clip->lastsize[0] * value / camera->sensor_width;
301
302         if (value >= 0.0001f)
303                 camera->focal = value;
304 }
305
306 static char *rna_trackingStabilization_path(PointerRNA *UNUSED(ptr))
307 {
308         return BLI_sprintfN("tracking.stabilization");
309 }
310
311 static int rna_track_2d_stabilization(CollectionPropertyIterator *UNUSED(iter), void *data)
312 {
313         MovieTrackingTrack *track = (MovieTrackingTrack *)data;
314
315         if ((track->flag & TRACK_USE_2D_STAB) == 0)
316                 return 1;
317
318         return 0;
319 }
320
321 static int rna_track_2d_stabilization_rotation(CollectionPropertyIterator *UNUSED(iter), void *data)
322 {
323         MovieTrackingTrack *track = (MovieTrackingTrack *)data;
324
325         if ((track->flag & TRACK_USE_2D_STAB_ROT) == 0)
326                 return 1;
327
328         return 0;
329 }
330
331 static void rna_tracking_stabTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
332 {
333         MovieClip *clip = (MovieClip *)ptr->id.data;
334         rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization);
335 }
336
337 static int rna_tracking_stabTracks_active_index_get(PointerRNA *ptr)
338 {
339         MovieClip *clip = (MovieClip *)ptr->id.data;
340         return clip->tracking.stabilization.act_track;
341 }
342
343 static void rna_tracking_stabTracks_active_index_set(PointerRNA *ptr, int value)
344 {
345         MovieClip *clip = (MovieClip *)ptr->id.data;
346         clip->tracking.stabilization.act_track = value;
347 }
348
349 static void rna_tracking_stabTracks_active_index_range(PointerRNA *ptr, int *min, int *max,
350                                                        int *UNUSED(softmin), int *UNUSED(softmax))
351 {
352         MovieClip *clip = (MovieClip *)ptr->id.data;
353
354         *min = 0;
355         *max = max_ii(0, clip->tracking.stabilization.tot_track - 1);
356 }
357
358 static void rna_tracking_stabRotTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
359 {
360         MovieClip *clip = (MovieClip *)ptr->id.data;
361         rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization_rotation);
362 }
363
364 static int rna_tracking_stabRotTracks_active_index_get(PointerRNA *ptr)
365 {
366         MovieClip *clip = (MovieClip *)ptr->id.data;
367         return clip->tracking.stabilization.act_rot_track;
368 }
369
370 static void rna_tracking_stabRotTracks_active_index_set(PointerRNA *ptr, int value)
371 {
372         MovieClip *clip = (MovieClip *)ptr->id.data;
373         clip->tracking.stabilization.act_rot_track = value;
374 }
375
376 static void rna_tracking_stabRotTracks_active_index_range(PointerRNA *ptr, int *min, int *max,
377                                                           int *UNUSED(softmin), int *UNUSED(softmax))
378 {
379         MovieClip *clip = (MovieClip *)ptr->id.data;
380
381         *min = 0;
382         *max = max_ii(0, clip->tracking.stabilization.tot_rot_track - 1);
383 }
384
385 static void rna_tracking_flushUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
386 {
387         MovieClip *clip = (MovieClip *)ptr->id.data;
388
389         nodeUpdateID(scene->nodetree, &clip->id);
390
391         WM_main_add_notifier(NC_SCENE | ND_NODES, NULL);
392         WM_main_add_notifier(NC_SCENE, NULL);
393         DAG_id_tag_update(&clip->id, 0);
394 }
395
396 static void rna_tracking_resetIntrinsics(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
397 {
398         MovieClip *clip = (MovieClip *)ptr->id.data;
399         MovieTracking *tracking = &clip->tracking;
400
401         if (tracking->camera.intrinsics) {
402                 BKE_tracking_distortion_free(tracking->camera.intrinsics);
403                 tracking->camera.intrinsics = NULL;
404         }
405 }
406
407 static void rna_trackingObject_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
408 {
409         MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
410
411         if (object->flag & TRACKING_OBJECT_CAMERA) {
412                 MovieClip *clip = (MovieClip *)ptr->id.data;
413
414                 rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
415         }
416         else {
417                 rna_iterator_listbase_begin(iter, &object->tracks, NULL);
418         }
419 }
420
421 static void rna_trackingObject_plane_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
422 {
423         MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
424
425         if (object->flag & TRACKING_OBJECT_CAMERA) {
426                 MovieClip *clip = (MovieClip *)ptr->id.data;
427
428                 rna_iterator_listbase_begin(iter, &clip->tracking.plane_tracks, NULL);
429         }
430         else {
431                 rna_iterator_listbase_begin(iter, &object->plane_tracks, NULL);
432         }
433 }
434
435 static PointerRNA rna_trackingObject_reconstruction_get(PointerRNA *ptr)
436 {
437         MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
438
439         if (object->flag & TRACKING_OBJECT_CAMERA) {
440                 MovieClip *clip = (MovieClip *)ptr->id.data;
441
442                 return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingReconstruction, &clip->tracking.reconstruction);
443         }
444         else {
445                 return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingReconstruction, &object->reconstruction);
446         }
447 }
448
449 static PointerRNA rna_tracking_active_object_get(PointerRNA *ptr)
450 {
451         MovieClip *clip = (MovieClip *)ptr->id.data;
452         MovieTrackingObject *object = BLI_findlink(&clip->tracking.objects, clip->tracking.objectnr);
453
454         return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingObject, object);
455 }
456
457 static void rna_tracking_active_object_set(PointerRNA *ptr, PointerRNA value)
458 {
459         MovieClip *clip = (MovieClip *)ptr->id.data;
460         MovieTrackingObject *object = (MovieTrackingObject *)value.data;
461         int index = BLI_findindex(&clip->tracking.objects, object);
462
463         if (index != -1) clip->tracking.objectnr = index;
464         else clip->tracking.objectnr = 0;
465 }
466
467 static void rna_trackingObject_name_set(PointerRNA *ptr, const char *value)
468 {
469         MovieClip *clip = (MovieClip *)ptr->id.data;
470         MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
471
472         BLI_strncpy(object->name, value, sizeof(object->name));
473
474         BKE_tracking_object_unique_name(&clip->tracking, object);
475 }
476
477 static void rna_trackingObject_flushUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
478 {
479         MovieClip *clip = (MovieClip *)ptr->id.data;
480
481         WM_main_add_notifier(NC_OBJECT | ND_TRANSFORM, NULL);
482         DAG_id_tag_update(&clip->id, 0);
483 }
484
485 static void rna_trackingMarker_frame_set(PointerRNA *ptr, int value)
486 {
487         MovieClip *clip = (MovieClip *) ptr->id.data;
488         MovieTracking *tracking = &clip->tracking;
489         MovieTrackingMarker *marker = (MovieTrackingMarker *) ptr->data;
490         MovieTrackingObject *tracking_object;
491         bool found = false;
492         MovieTrackingTrack *track = NULL;
493
494         for (tracking_object = tracking->objects.first;
495              tracking_object;
496              tracking_object = tracking_object->next)
497         {
498                 ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
499
500                 for (track = tracksbase->first;
501                      track;
502                      track = track->next)
503                 {
504                         if (marker >= track->markers && marker < track->markers + track->markersnr) {
505                                 found = true;
506                                 break;
507                         }
508                 }
509
510                 if (found) {
511                         break;
512                 }
513         }
514
515         if (found) {
516                 MovieTrackingMarker new_marker = *marker;
517                 new_marker.framenr = value;
518
519                 BKE_tracking_marker_delete(track, marker->framenr);
520                 BKE_tracking_marker_insert(track, &new_marker);
521         }
522 }
523
524 static void rna_tracking_markerPattern_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
525 {
526         MovieTrackingMarker *marker = (MovieTrackingMarker *)ptr->data;
527
528         BKE_tracking_marker_clamp(marker, CLAMP_PAT_DIM);
529 }
530
531 static void rna_tracking_markerSearch_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
532 {
533         MovieTrackingMarker *marker = (MovieTrackingMarker *)ptr->data;
534
535         BKE_tracking_marker_clamp(marker, CLAMP_SEARCH_DIM);
536 }
537
538 static void rna_tracking_markerPattern_boundbox_get(PointerRNA *ptr, float *values)
539 {
540         MovieTrackingMarker *marker = (MovieTrackingMarker *)ptr->data;
541         float min[2], max[2];
542
543         BKE_tracking_marker_pattern_minmax(marker, min, max);
544
545         copy_v2_v2(values, min);
546         copy_v2_v2(values + 2, max);
547 }
548
549 static void rna_trackingDopesheet_tagUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
550 {
551         MovieClip *clip = (MovieClip *)ptr->id.data;
552         MovieTrackingDopesheet *dopesheet = &clip->tracking.dopesheet;
553
554         dopesheet->ok = 0;
555 }
556
557 /* API */
558
559 static MovieTrackingTrack *add_track_to_base(MovieClip *clip, MovieTracking *tracking, ListBase *tracksbase,
560                                              const char *name, int frame)
561 {
562         int width, height;
563         MovieClipUser user = {0};
564         MovieTrackingTrack *track;
565
566         user.framenr = 1;
567
568         BKE_movieclip_get_size(clip, &user, &width, &height);
569
570         track = BKE_tracking_track_add(tracking, tracksbase, 0, 0, frame, width, height);
571
572         if (name && name[0]) {
573                 BLI_strncpy(track->name, name, sizeof(track->name));
574                 BKE_tracking_track_unique_name(tracksbase, track);
575         }
576
577         return track;
578 }
579
580 static MovieTrackingTrack *rna_trackingTracks_new(ID *id, MovieTracking *tracking, const char *name, int frame)
581 {
582         MovieClip *clip = (MovieClip *) id;
583         MovieTrackingTrack *track;
584
585         track = add_track_to_base(clip, tracking, &tracking->tracks, name, frame);
586
587         WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, clip);
588
589         return track;
590 }
591
592 static MovieTrackingTrack *rna_trackingObject_tracks_new(ID *id, MovieTrackingObject *object, const char *name,
593                                                          int frame)
594 {
595         MovieClip *clip = (MovieClip *) id;
596         ListBase *tracksbase = &object->tracks;
597         MovieTrackingTrack *track;
598
599         if (object->flag & TRACKING_OBJECT_CAMERA)
600                 tracksbase = &clip->tracking.tracks;
601
602         track = add_track_to_base(clip, &clip->tracking, tracksbase, name, frame);
603
604         WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
605
606         return track;
607 }
608
609 static MovieTrackingObject *rna_trackingObject_new(MovieTracking *tracking, const char *name)
610 {
611         MovieTrackingObject *object = BKE_tracking_object_add(tracking, name);
612
613         WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
614
615         return object;
616 }
617
618 static void rna_trackingObject_remove(MovieTracking *tracking, ReportList *reports, PointerRNA *object_ptr)
619 {
620         MovieTrackingObject *object = object_ptr->data;
621         if (BKE_tracking_object_delete(tracking, object) == false) {
622                 BKE_reportf(reports, RPT_ERROR, "MovieTracking '%s' cannot be removed", object->name);
623                 return;
624         }
625
626         RNA_POINTER_INVALIDATE(object_ptr);
627
628         WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
629 }
630
631 static MovieTrackingMarker *rna_trackingMarkers_find_frame(MovieTrackingTrack *track, int framenr, int exact)
632 {
633         if (exact)
634                 return BKE_tracking_marker_get_exact(track, framenr);
635         else
636                 return BKE_tracking_marker_get(track, framenr);
637 }
638
639 static MovieTrackingMarker *rna_trackingMarkers_insert_frame(MovieTrackingTrack *track, int framenr, float *co)
640 {
641         MovieTrackingMarker marker, *new_marker;
642
643         memset(&marker, 0, sizeof(marker));
644         marker.framenr = framenr;
645         copy_v2_v2(marker.pos, co);
646
647         /* a bit arbitrary, but better than creating markers with zero pattern
648          * which is forbidden actually
649          */
650         copy_v2_v2(marker.pattern_corners[0], track->markers[0].pattern_corners[0]);
651         copy_v2_v2(marker.pattern_corners[1], track->markers[0].pattern_corners[1]);
652         copy_v2_v2(marker.pattern_corners[2], track->markers[0].pattern_corners[2]);
653         copy_v2_v2(marker.pattern_corners[3], track->markers[0].pattern_corners[3]);
654
655         new_marker = BKE_tracking_marker_insert(track, &marker);
656
657         WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
658
659         return new_marker;
660 }
661
662 static void rna_trackingMarkers_delete_frame(MovieTrackingTrack *track, int framenr)
663 {
664         if (track->markersnr == 1)
665                 return;
666
667         BKE_tracking_marker_delete(track, framenr);
668
669         WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
670 }
671
672 static MovieTrackingPlaneMarker *rna_trackingPlaneMarkers_find_frame(MovieTrackingPlaneTrack *plane_track,
673                                                                      int framenr, int exact)
674 {
675         if (exact)
676                 return BKE_tracking_plane_marker_get_exact(plane_track, framenr);
677         else
678                 return BKE_tracking_plane_marker_get(plane_track, framenr);
679 }
680
681 static MovieTrackingPlaneMarker *rna_trackingPlaneMarkers_insert_frame(MovieTrackingPlaneTrack *plane_track,
682                                                                        int framenr)
683 {
684         MovieTrackingPlaneMarker plane_marker, *new_plane_marker;
685
686         memset(&plane_marker, 0, sizeof(plane_marker));
687         plane_marker.framenr = framenr;
688
689         /* a bit arbitrary, but better than creating zero markers */
690         copy_v2_v2(plane_marker.corners[0], plane_track->markers[0].corners[0]);
691         copy_v2_v2(plane_marker.corners[1], plane_track->markers[0].corners[1]);
692         copy_v2_v2(plane_marker.corners[2], plane_track->markers[0].corners[2]);
693         copy_v2_v2(plane_marker.corners[3], plane_track->markers[0].corners[3]);
694
695         new_plane_marker = BKE_tracking_plane_marker_insert(plane_track, &plane_marker);
696
697         WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
698
699         return new_plane_marker;
700 }
701
702 static void rna_trackingPlaneMarkers_delete_frame(MovieTrackingPlaneTrack *plane_track, int framenr)
703 {
704         if (plane_track->markersnr == 1)
705                 return;
706
707         BKE_tracking_plane_marker_delete(plane_track, framenr);
708
709         WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
710 }
711
712 static MovieTrackingObject *find_object_for_reconstruction(MovieTracking *tracking,
713                                                            MovieTrackingReconstruction *reconstruction)
714 {
715         MovieTrackingObject *object;
716
717         for (object = tracking->objects.first; object; object = object->next) {
718                 if (object->flag & TRACKING_OBJECT_CAMERA) {
719                         if (&tracking->reconstruction == reconstruction) {
720                                 return object;
721                         }
722                 }
723                 else if (&object->reconstruction == reconstruction) {
724                         return object;
725                 }
726         }
727
728         return NULL;
729 }
730
731 static MovieReconstructedCamera *rna_trackingCameras_find_frame(ID *id, MovieTrackingReconstruction *reconstruction, int framenr)
732 {
733         MovieClip *clip = (MovieClip *) id;
734         MovieTracking *tracking = &clip->tracking;
735         MovieTrackingObject *object = find_object_for_reconstruction(tracking, reconstruction);
736         return BKE_tracking_camera_get_reconstructed(tracking, object, framenr);
737 }
738
739 static void rna_trackingCameras_matrix_from_frame(ID *id, MovieTrackingReconstruction *reconstruction, int framenr, float matrix[16])
740 {
741         float mat[4][4];
742
743         MovieClip *clip = (MovieClip *) id;
744         MovieTracking *tracking = &clip->tracking;
745         MovieTrackingObject *object = find_object_for_reconstruction(tracking, reconstruction);
746         BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat);
747
748         memcpy(matrix, mat, sizeof(float) * 16);
749 }
750
751 #else
752
753 static const EnumPropertyItem tracker_motion_model[] = {
754         {TRACK_MOTION_MODEL_HOMOGRAPHY, "Perspective", 0, "Perspective",
755                       "Search for markers that are perspectively deformed (homography) between frames"},
756         {TRACK_MOTION_MODEL_AFFINE, "Affine", 0, "Affine",
757                       "Search for markers that are affine-deformed (t, r, k, and skew) between frames"},
758         {TRACK_MOTION_MODEL_TRANSLATION_ROTATION_SCALE, "LocRotScale", 0, "LocRotScale",
759                       "Search for markers that are translated, rotated, and scaled between frames"},
760         {TRACK_MOTION_MODEL_TRANSLATION_SCALE, "LocScale", 0, "LocScale",
761                       "Search for markers that are translated and scaled between frames"},
762         {TRACK_MOTION_MODEL_TRANSLATION_ROTATION, "LocRot", 0, "LocRot",
763                       "Search for markers that are translated and rotated between frames"},
764         {TRACK_MOTION_MODEL_TRANSLATION, "Loc", 0, "Loc",
765                       "Search for markers that are translated between frames"},
766         {0, NULL, 0, NULL, NULL}
767 };
768
769 static const EnumPropertyItem pattern_match_items[] = {
770         {TRACK_MATCH_KEYFRAME, "KEYFRAME", 0, "Keyframe", "Track pattern from keyframe to next frame"},
771         {TRACK_MATCH_PREVFRAME, "PREV_FRAME", 0, "Previous frame", "Track pattern from current frame to next frame"},
772         {0, NULL, 0, NULL, NULL}
773 };
774
775 static void rna_def_trackingSettings(BlenderRNA *brna)
776 {
777         StructRNA *srna;
778         PropertyRNA *prop;
779
780         static const EnumPropertyItem speed_items[] = {
781                 {0, "FASTEST", 0, "Fastest", "Track as fast as it's possible"},
782                 {TRACKING_SPEED_DOUBLE, "DOUBLE", 0, "Double", "Track with double speed"},
783                 {TRACKING_SPEED_REALTIME, "REALTIME", 0, "Realtime", "Track with realtime speed"},
784                 {TRACKING_SPEED_HALF, "HALF", 0, "Half", "Track with half of realtime speed"},
785                 {TRACKING_SPEED_QUARTER, "QUARTER", 0, "Quarter", "Track with quarter of realtime speed"},
786                 {0, NULL, 0, NULL, NULL}
787         };
788
789         static const EnumPropertyItem cleanup_items[] = {
790                 {TRACKING_CLEAN_SELECT, "SELECT", 0, "Select", "Select unclean tracks"},
791                 {TRACKING_CLEAN_DELETE_TRACK, "DELETE_TRACK", 0, "Delete Track", "Delete unclean tracks"},
792                 {TRACKING_CLEAN_DELETE_SEGMENT, "DELETE_SEGMENTS", 0, "Delete Segments", "Delete unclean segments of tracks"},
793                 {0, NULL, 0, NULL, NULL}
794         };
795
796         static const EnumPropertyItem refine_items[] = {
797                 {0, "NONE", 0, "Nothing", "Do not refine camera intrinsics"},
798                 {REFINE_FOCAL_LENGTH, "FOCAL_LENGTH", 0, "Focal Length", "Refine focal length"},
799                 {REFINE_FOCAL_LENGTH | REFINE_RADIAL_DISTORTION_K1, "FOCAL_LENGTH_RADIAL_K1", 0, "Focal length, K1",
800                  "Refine focal length and radial distortion K1"},
801                 {REFINE_FOCAL_LENGTH |
802                  REFINE_RADIAL_DISTORTION_K1 |
803                  REFINE_RADIAL_DISTORTION_K2, "FOCAL_LENGTH_RADIAL_K1_K2", 0, "Focal length, K1, K2",
804                  "Refine focal length and radial distortion K1 and K2"},
805                 {REFINE_FOCAL_LENGTH |
806                  REFINE_PRINCIPAL_POINT |
807                  REFINE_RADIAL_DISTORTION_K1 |
808                  REFINE_RADIAL_DISTORTION_K2, "FOCAL_LENGTH_PRINCIPAL_POINT_RADIAL_K1_K2", 0,
809                  "Focal Length, Optical Center, K1, K2",
810                  "Refine focal length, optical center and radial distortion K1 and K2"},
811                 {REFINE_FOCAL_LENGTH |
812                  REFINE_PRINCIPAL_POINT, "FOCAL_LENGTH_PRINCIPAL_POINT", 0, "Focal Length, Optical Center",
813                  "Refine focal length and optical center"},
814                 {REFINE_RADIAL_DISTORTION_K1 |
815                  REFINE_RADIAL_DISTORTION_K2, "RADIAL_K1_K2", 0, "K1, K2",
816                  "Refine radial distortion K1 and K2"},
817                 {0, NULL, 0, NULL, NULL}
818         };
819
820         srna = RNA_def_struct(brna, "MovieTrackingSettings", NULL);
821         RNA_def_struct_ui_text(srna, "Movie tracking settings", "Match moving settings");
822
823         /* speed */
824         prop = RNA_def_property(srna, "speed", PROP_ENUM, PROP_NONE);
825         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
826         RNA_def_property_enum_items(prop, speed_items);
827         RNA_def_property_ui_text(prop, "Speed",
828                                  "Limit speed of tracking to make visual feedback easier "
829                                  "(this does not affect the tracking quality)");
830
831         /* use keyframe selection */
832         prop = RNA_def_property(srna, "use_keyframe_selection", PROP_BOOLEAN, PROP_NONE);
833         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
834         RNA_def_property_boolean_sdna(prop, NULL, "reconstruction_flag", TRACKING_USE_KEYFRAME_SELECTION);
835         RNA_def_property_ui_text(prop, "Keyframe Selection",
836                                  "Automatically select keyframes when solving camera/object motion");
837
838         /* intrinsics refinement during bundle adjustment */
839         prop = RNA_def_property(srna, "refine_intrinsics", PROP_ENUM, PROP_NONE);
840         RNA_def_property_enum_sdna(prop, NULL, "refine_camera_intrinsics");
841         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
842         RNA_def_property_enum_items(prop, refine_items);
843         RNA_def_property_ui_text(prop, "Refine", "Refine intrinsics during camera solving");
844
845         /* tool settings */
846
847         /* distance */
848         prop = RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
849         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
850         RNA_def_property_float_sdna(prop, NULL, "dist");
851         RNA_def_property_float_default(prop, 1.0f);
852         RNA_def_property_ui_text(prop, "Distance", "Distance between two bundles used for scene scaling");
853
854         /* frames count */
855         prop = RNA_def_property(srna, "clean_frames", PROP_INT, PROP_NONE);
856         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
857         RNA_def_property_int_sdna(prop, NULL, "clean_frames");
858         RNA_def_property_range(prop, 0, INT_MAX);
859         RNA_def_property_ui_text(prop, "Tracked Frames",
860                                  "Effect on tracks which are tracked less than the specified amount of frames");
861
862         /* re-projection error */
863         prop = RNA_def_property(srna, "clean_error", PROP_FLOAT, PROP_NONE);
864         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
865         RNA_def_property_float_sdna(prop, NULL, "clean_error");
866         RNA_def_property_range(prop, 0, FLT_MAX);
867         RNA_def_property_ui_text(prop, "Reprojection Error", "Effect on tracks which have a larger re-projection error");
868
869         /* cleanup action */
870         prop = RNA_def_property(srna, "clean_action", PROP_ENUM, PROP_NONE);
871         RNA_def_property_enum_sdna(prop, NULL, "clean_action");
872         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
873         RNA_def_property_enum_items(prop, cleanup_items);
874         RNA_def_property_ui_text(prop, "Action", "Cleanup action to execute");
875
876         /* ** default tracker settings ** */
877         prop = RNA_def_property(srna, "show_default_expanded", PROP_BOOLEAN, PROP_NONE);
878         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
879         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_SETTINGS_SHOW_DEFAULT_EXPANDED);
880         RNA_def_property_ui_text(prop, "Show Expanded", "Show default options expanded in the user interface");
881         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
882
883         /* ** extra tracker settings ** */
884         prop = RNA_def_property(srna, "show_extra_expanded", PROP_BOOLEAN, PROP_NONE);
885         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
886         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_SETTINGS_SHOW_EXTRA_EXPANDED);
887         RNA_def_property_ui_text(prop, "Show Expanded", "Show extra options expanded in the user interface");
888         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
889
890         /* solver settings */
891         prop = RNA_def_property(srna, "use_tripod_solver", PROP_BOOLEAN, PROP_NONE);
892         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
893         RNA_def_property_boolean_sdna(prop, NULL, "motion_flag", TRACKING_MOTION_TRIPOD);
894         RNA_def_property_ui_text(prop, "Tripod Motion",
895                                  "Use special solver to track a stable camera position, such as a tripod");
896
897         /* default_limit_frames */
898         prop = RNA_def_property(srna, "default_frames_limit", PROP_INT, PROP_NONE);
899         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
900         RNA_def_property_int_sdna(prop, NULL, "default_frames_limit");
901         RNA_def_property_range(prop, 0, SHRT_MAX);
902         RNA_def_property_ui_text(prop, "Frames Limit", "Every tracking cycle, this number of frames are tracked");
903
904         /* default_pattern_match */
905         prop = RNA_def_property(srna, "default_pattern_match", PROP_ENUM, PROP_NONE);
906         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
907         RNA_def_property_enum_sdna(prop, NULL, "default_pattern_match");
908         RNA_def_property_enum_items(prop, pattern_match_items);
909         RNA_def_property_ui_text(prop, "Pattern Match",
910                                  "Track pattern from given frame when tracking marker to next frame");
911
912         /* default_margin */
913         prop = RNA_def_property(srna, "default_margin", PROP_INT, PROP_PIXEL);
914         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
915         RNA_def_property_int_sdna(prop, NULL, "default_margin");
916         RNA_def_property_range(prop, 0, 300);
917         RNA_def_property_ui_text(prop, "Margin", "Default distance from image boundary at which marker stops tracking");
918
919         /* default_tracking_motion_model */
920         prop = RNA_def_property(srna, "default_motion_model", PROP_ENUM, PROP_NONE);
921         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
922         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
923         RNA_def_property_enum_items(prop, tracker_motion_model);
924         RNA_def_property_ui_text(prop, "Motion model", "Default motion model to use for tracking");
925
926         /* default_use_brute */
927         prop = RNA_def_property(srna, "use_default_brute", PROP_BOOLEAN, PROP_NONE);
928         RNA_def_property_boolean_sdna(prop, NULL, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_BRUTE);
929         RNA_def_property_ui_text(prop, "Prepass", "Use a brute-force translation-only initialization when tracking");
930         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
931
932         /* default_use_brute */
933         prop = RNA_def_property(srna, "use_default_mask", PROP_BOOLEAN, PROP_NONE);
934         RNA_def_property_boolean_sdna(prop, NULL, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_MASK);
935         RNA_def_property_ui_text(prop, "Use Mask",
936                                  "Use a grease pencil data-block as a mask to use only specified areas of pattern "
937                                  "when tracking");
938         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
939
940         /* default_use_normalization */
941         prop = RNA_def_property(srna, "use_default_normalization", PROP_BOOLEAN, PROP_NONE);
942         RNA_def_property_boolean_sdna(prop, NULL, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_NORMALIZATION);
943         RNA_def_property_ui_text(prop, "Normalize", "Normalize light intensities while tracking (slower)");
944         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
945
946         /* default minmal correlation */
947         prop = RNA_def_property(srna, "default_correlation_min", PROP_FLOAT, PROP_NONE);
948         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
949         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
950         RNA_def_property_float_sdna(prop, NULL, "default_minimum_correlation");
951         RNA_def_property_range(prop, 0.0f, 1.0f);
952         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.05, 3);
953         RNA_def_property_ui_text(prop, "Correlation",
954                                  "Default minimum value of correlation between matched pattern and reference "
955                                  "that is still treated as successful tracking");
956
957         /* default pattern size */
958         prop = RNA_def_property(srna, "default_pattern_size", PROP_INT, PROP_NONE);
959         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
960         RNA_def_property_int_sdna(prop, NULL, "default_pattern_size");
961         RNA_def_property_range(prop, 5, 1000);
962         RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_patternUpdate");
963         RNA_def_property_ui_text(prop, "Pattern Size", "Size of pattern area for newly created tracks");
964
965         /* default search size */
966         prop = RNA_def_property(srna, "default_search_size", PROP_INT, PROP_NONE);
967         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
968         RNA_def_property_int_sdna(prop, NULL, "default_search_size");
969         RNA_def_property_range(prop, 5, 1000);
970         RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_searchUpdate");
971         RNA_def_property_ui_text(prop, "Search Size", "Size of search area for newly created tracks");
972
973         /* default use_red_channel */
974         prop = RNA_def_property(srna, "use_default_red_channel", PROP_BOOLEAN, PROP_NONE);
975         RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_RED);
976         RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
977         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
978
979         /* default_use_green_channel */
980         prop = RNA_def_property(srna, "use_default_green_channel", PROP_BOOLEAN, PROP_NONE);
981         RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_GREEN);
982         RNA_def_property_ui_text(prop, "Use Green Channel", "Use green channel from footage for tracking");
983         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
984
985         /* default_use_blue_channel */
986         prop = RNA_def_property(srna, "use_default_blue_channel", PROP_BOOLEAN, PROP_NONE);
987         RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_BLUE);
988         RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
989         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
990
991         prop = RNA_def_property(srna, "default_weight", PROP_FLOAT, PROP_FACTOR);
992         RNA_def_property_range(prop, 0.0f, 1.0f);
993         RNA_def_property_ui_text(prop, "Weight", "Influence of newly created track on a final solution");
994
995         /* ** object tracking ** */
996
997         /* object distance */
998         prop = RNA_def_property(srna, "object_distance", PROP_FLOAT, PROP_NONE);
999         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1000         RNA_def_property_float_sdna(prop, NULL, "object_distance");
1001         RNA_def_property_ui_text(prop, "Distance", "Distance between two bundles used for object scaling");
1002         RNA_def_property_range(prop, 0.001, 10000);
1003         RNA_def_property_float_default(prop, 1.0f);
1004         RNA_def_property_ui_range(prop, 0.001, 10000.0, 1, 3);
1005 }
1006
1007 static void rna_def_trackingCamera(BlenderRNA *brna)
1008 {
1009         StructRNA *srna;
1010         PropertyRNA *prop;
1011
1012         static const EnumPropertyItem distortion_model_items[] = {
1013                 {TRACKING_DISTORTION_MODEL_POLYNOMIAL, "POLYNOMIAL", 0, "Polynomial", "Radial distortion model which fits common cameras"},
1014                 {TRACKING_DISTORTION_MODEL_DIVISION, "DIVISION", 0, "Divisions", "Division distortion model which "
1015                                                                                  "better represents wide-angle cameras"},
1016                 {0, NULL, 0, NULL, NULL}
1017         };
1018
1019         static const EnumPropertyItem camera_units_items[] = {
1020                 {CAMERA_UNITS_PX, "PIXELS", 0, "px", "Use pixels for units of focal length"},
1021                 {CAMERA_UNITS_MM, "MILLIMETERS", 0, "mm", "Use millimeters for units of focal length"},
1022                 {0, NULL, 0, NULL, NULL}
1023         };
1024
1025         srna = RNA_def_struct(brna, "MovieTrackingCamera", NULL);
1026         RNA_def_struct_path_func(srna, "rna_trackingCamera_path");
1027         RNA_def_struct_ui_text(srna, "Movie tracking camera data", "Match-moving camera data for tracking");
1028
1029         /* Distortion model */
1030         prop = RNA_def_property(srna, "distortion_model", PROP_ENUM, PROP_NONE);
1031         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1032         RNA_def_property_enum_items(prop, distortion_model_items);
1033         RNA_def_property_ui_text(prop, "Distortion Model", "Distortion model used for camera lenses");
1034         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_resetIntrinsics");
1035
1036         /* Sensor */
1037         prop = RNA_def_property(srna, "sensor_width", PROP_FLOAT, PROP_NONE);
1038         RNA_def_property_float_sdna(prop, NULL, "sensor_width");
1039         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1040         RNA_def_property_range(prop, 0.0f, 500.0f);
1041         RNA_def_property_ui_text(prop, "Sensor", "Width of CCD sensor in millimeters");
1042         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1043
1044         /* Focal Length */
1045         prop = RNA_def_property(srna, "focal_length", PROP_FLOAT, PROP_NONE);
1046         RNA_def_property_float_sdna(prop, NULL, "focal");
1047         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1048         RNA_def_property_range(prop, 0.0001f, FLT_MAX);
1049         RNA_def_property_ui_range(prop, 0.0001f, 5000.0f, 1, 2);
1050         RNA_def_property_float_funcs(prop, "rna_trackingCamera_focal_mm_get", "rna_trackingCamera_focal_mm_set", NULL);
1051         RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
1052         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1053
1054         /* Focal Length in pixels */
1055         prop = RNA_def_property(srna, "focal_length_pixels", PROP_FLOAT, PROP_NONE);
1056         RNA_def_property_float_sdna(prop, NULL, "focal");
1057         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1058         RNA_def_property_range(prop, 0.0f, FLT_MAX);
1059         RNA_def_property_ui_range(prop, 0.0f, 5000.f, 1, 2);
1060         RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
1061         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1062
1063         /* Units */
1064         prop = RNA_def_property(srna, "units", PROP_ENUM, PROP_NONE);
1065         RNA_def_property_enum_sdna(prop, NULL, "units");
1066         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1067         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1068         RNA_def_property_enum_items(prop, camera_units_items);
1069         RNA_def_property_ui_text(prop, "Units", "Units used for camera focal length");
1070
1071         /* Principal Point */
1072         prop = RNA_def_property(srna, "principal", PROP_FLOAT, PROP_PIXEL);
1073         RNA_def_property_array(prop, 2);
1074         RNA_def_property_float_sdna(prop, NULL, "principal");
1075         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1076         RNA_def_property_ui_text(prop, "Principal Point", "Optical center of lens");
1077         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1078
1079         /* Radial distortion parameters */
1080         prop = RNA_def_property(srna, "k1", PROP_FLOAT, PROP_NONE);
1081         RNA_def_property_float_sdna(prop, NULL, "k1");
1082         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1083         RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1084         RNA_def_property_ui_text(prop, "K1", "First coefficient of third order polynomial radial distortion");
1085         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1086
1087         prop = RNA_def_property(srna, "k2", PROP_FLOAT, PROP_NONE);
1088         RNA_def_property_float_sdna(prop, NULL, "k2");
1089         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1090         RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1091         RNA_def_property_ui_text(prop, "K2", "Second coefficient of third order polynomial radial distortion");
1092         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1093
1094         prop = RNA_def_property(srna, "k3", PROP_FLOAT, PROP_NONE);
1095         RNA_def_property_float_sdna(prop, NULL, "k3");
1096         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1097         RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1098         RNA_def_property_ui_text(prop, "K3", "Third coefficient of third order polynomial radial distortion");
1099         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1100
1101         /* Division distortion parameters */
1102         prop = RNA_def_property(srna, "division_k1", PROP_FLOAT, PROP_NONE);
1103         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1104         RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1105         RNA_def_property_ui_text(prop, "K1", "First coefficient of second order division distortion");
1106         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1107
1108         prop = RNA_def_property(srna, "division_k2", PROP_FLOAT, PROP_NONE);
1109         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1110         RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1111         RNA_def_property_ui_text(prop, "K2", "First coefficient of second order division distortion");
1112         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1113
1114         /* pixel aspect */
1115         prop = RNA_def_property(srna, "pixel_aspect", PROP_FLOAT, PROP_XYZ);
1116         RNA_def_property_float_sdna(prop, NULL, "pixel_aspect");
1117         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1118         RNA_def_property_range(prop, 0.1f, FLT_MAX);
1119         RNA_def_property_ui_range(prop, 0.1f, 5000.0f, 1, 2);
1120         RNA_def_property_float_default(prop, 1.0f);
1121         RNA_def_property_ui_text(prop, "Pixel Aspect Ratio", "Pixel aspect ratio");
1122         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1123 }
1124
1125 static void rna_def_trackingMarker(BlenderRNA *brna)
1126 {
1127         StructRNA *srna;
1128         PropertyRNA *prop;
1129
1130         static int boundbox_dimsize[] = {2, 2};
1131
1132         srna = RNA_def_struct(brna, "MovieTrackingMarker", NULL);
1133         RNA_def_struct_ui_text(srna, "Movie tracking marker data", "Match-moving marker data for tracking");
1134
1135         /* position */
1136         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
1137         RNA_def_property_array(prop, 2);
1138         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1139         RNA_def_property_float_sdna(prop, NULL, "pos");
1140         RNA_def_property_ui_text(prop, "Position", "Marker position at frame in normalized coordinates");
1141         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1142
1143         /* frame */
1144         prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
1145         RNA_def_property_int_sdna(prop, NULL, "framenr");
1146         RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
1147         RNA_def_property_int_funcs(prop, NULL, "rna_trackingMarker_frame_set", NULL);
1148         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1149
1150         /* enable */
1151         prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1152         RNA_def_property_boolean_sdna(prop, NULL, "flag", MARKER_DISABLED);
1153         RNA_def_property_ui_text(prop, "Mode", "Is marker muted for current frame");
1154         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1155
1156         /* pattern */
1157         prop = RNA_def_property(srna, "pattern_corners", PROP_FLOAT, PROP_MATRIX);
1158         RNA_def_property_float_sdna(prop, NULL, "pattern_corners");
1159         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1160         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x2);
1161         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1162         RNA_def_property_ui_text(prop, "Pattern Corners",
1163                                  "Array of coordinates which represents pattern's corners in "
1164                                  "normalized coordinates relative to marker position");
1165         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerPattern_update");
1166
1167         prop = RNA_def_property(srna, "pattern_bound_box", PROP_FLOAT, PROP_NONE);
1168         RNA_def_property_multi_array(prop, 2, boundbox_dimsize);
1169         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1170         RNA_def_property_float_funcs(prop, "rna_tracking_markerPattern_boundbox_get", NULL, NULL);
1171         RNA_def_property_ui_text(prop, "Pattern Bounding Box", "Pattern area bounding box in normalized coordinates");
1172
1173         /* search */
1174         prop = RNA_def_property(srna, "search_min", PROP_FLOAT, PROP_TRANSLATION);
1175         RNA_def_property_array(prop, 2);
1176         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1177         RNA_def_property_float_sdna(prop, NULL, "search_min");
1178         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1179         RNA_def_property_ui_text(prop, "Search Min",
1180                                  "Left-bottom corner of search area in normalized coordinates relative "
1181                                  "to marker position");
1182         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerSearch_update");
1183
1184         prop = RNA_def_property(srna, "search_max", PROP_FLOAT, PROP_TRANSLATION);
1185         RNA_def_property_array(prop, 2);
1186         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1187         RNA_def_property_float_sdna(prop, NULL, "search_max");
1188         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1189         RNA_def_property_ui_text(prop, "Search Max",
1190                                  "Right-bottom corner of search area in normalized coordinates relative "
1191                                  "to marker position");
1192         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerSearch_update");
1193
1194         /* is marker keyframed */
1195         prop = RNA_def_property(srna, "is_keyed", PROP_BOOLEAN, PROP_NONE);
1196         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1197         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", MARKER_TRACKED);
1198         RNA_def_property_ui_text(prop, "Keyframed", "Whether the position of the marker is keyframed or tracked");
1199 }
1200
1201 static void rna_def_trackingMarkers(BlenderRNA *brna, PropertyRNA *cprop)
1202 {
1203         StructRNA *srna;
1204         FunctionRNA *func;
1205         PropertyRNA *parm;
1206
1207         RNA_def_property_srna(cprop, "MovieTrackingMarkers");
1208         srna = RNA_def_struct(brna, "MovieTrackingMarkers", NULL);
1209         RNA_def_struct_sdna(srna, "MovieTrackingTrack");
1210         RNA_def_struct_ui_text(srna, "Movie Tracking Markers", "Collection of markers for movie tracking track");
1211
1212         func = RNA_def_function(srna, "find_frame", "rna_trackingMarkers_find_frame");
1213         RNA_def_function_ui_description(func, "Get marker for specified frame");
1214         parm = RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
1215                            "Frame number to find marker for", MINFRAME, MAXFRAME);
1216         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1217         RNA_def_boolean(func, "exact", true, "Exact",
1218                         "Get marker at exact frame number rather than get estimated marker");
1219         parm = RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Marker for specified frame");
1220         RNA_def_function_return(func, parm);
1221
1222         func = RNA_def_function(srna, "insert_frame", "rna_trackingMarkers_insert_frame");
1223         RNA_def_function_ui_description(func, "Insert a new marker at the specified frame");
1224         parm = RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
1225                            "Frame number to insert marker to", MINFRAME, MAXFRAME);
1226         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1227         RNA_def_float_vector(func, "co", 2, NULL, -1.0, 1.0, "Coordinate",
1228                              "Place new marker at the given frame using specified in normalized space coordinates",
1229                              -1.0, 1.0);
1230         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1231         parm = RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Newly created marker");
1232         RNA_def_function_return(func, parm);
1233
1234         func = RNA_def_function(srna, "delete_frame", "rna_trackingMarkers_delete_frame");
1235         RNA_def_function_ui_description(func, "Delete marker at specified frame");
1236         parm = RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
1237                            "Frame number to delete marker from", MINFRAME, MAXFRAME);
1238         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1239 }
1240
1241 static void rna_def_trackingTrack(BlenderRNA *brna)
1242 {
1243         StructRNA *srna;
1244         PropertyRNA *prop;
1245
1246         rna_def_trackingMarker(brna);
1247
1248         srna = RNA_def_struct(brna, "MovieTrackingTrack", NULL);
1249         RNA_def_struct_path_func(srna, "rna_trackingTrack_path");
1250         RNA_def_struct_ui_text(srna, "Movie tracking track data", "Match-moving track data for tracking");
1251         RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
1252
1253         /* name */
1254         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1255         RNA_def_property_ui_text(prop, "Name", "Unique name of track");
1256         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingTrack_name_set");
1257         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
1258         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1259         RNA_def_struct_name_property(srna, prop);
1260
1261         /* limit frames */
1262         prop = RNA_def_property(srna, "frames_limit", PROP_INT, PROP_NONE);
1263         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1264         RNA_def_property_int_sdna(prop, NULL, "frames_limit");
1265         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1266         RNA_def_property_range(prop, 0, SHRT_MAX);
1267         RNA_def_property_ui_text(prop, "Frames Limit", "Every tracking cycle, this number of frames are tracked");
1268
1269         /* pattern match */
1270         prop = RNA_def_property(srna, "pattern_match", PROP_ENUM, PROP_NONE);
1271         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1272         RNA_def_property_enum_sdna(prop, NULL, "pattern_match");
1273         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1274         RNA_def_property_enum_items(prop, pattern_match_items);
1275         RNA_def_property_ui_text(prop, "Pattern Match",
1276                                  "Track pattern from given frame when tracking marker to next frame");
1277
1278         /* margin */
1279         prop = RNA_def_property(srna, "margin", PROP_INT, PROP_PIXEL);
1280         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1281         RNA_def_property_int_sdna(prop, NULL, "margin");
1282         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1283         RNA_def_property_range(prop, 0, 300);
1284         RNA_def_property_ui_text(prop, "Margin", "Distance from image boundary at which marker stops tracking");
1285
1286         /* tracking motion model */
1287         prop = RNA_def_property(srna, "motion_model", PROP_ENUM, PROP_NONE);
1288         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1289         RNA_def_property_enum_items(prop, tracker_motion_model);
1290         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1291         RNA_def_property_ui_text(prop, "Motion model", "Default motion model to use for tracking");
1292
1293         /* minimum correlation */
1294         prop = RNA_def_property(srna, "correlation_min", PROP_FLOAT, PROP_NONE);
1295         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1296         RNA_def_property_float_sdna(prop, NULL, "minimum_correlation");
1297         RNA_def_property_range(prop, 0.0f, 1.0f);
1298         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.05, 3);
1299         RNA_def_property_ui_text(prop, "Correlation",
1300                                  "Minimal value of correlation between matched pattern and reference "
1301                                  "that is still treated as successful tracking");
1302
1303         /* use_brute */
1304         prop = RNA_def_property(srna, "use_brute", PROP_BOOLEAN, PROP_NONE);
1305         RNA_def_property_boolean_sdna(prop, NULL, "algorithm_flag", TRACK_ALGORITHM_FLAG_USE_BRUTE);
1306         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1307         RNA_def_property_ui_text(prop, "Prepass", "Use a brute-force translation only pre-track before refinement");
1308         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1309
1310         /* use_brute */
1311         prop = RNA_def_property(srna, "use_mask", PROP_BOOLEAN, PROP_NONE);
1312         RNA_def_property_boolean_sdna(prop, NULL, "algorithm_flag", TRACK_ALGORITHM_FLAG_USE_MASK);
1313         RNA_def_property_ui_text(prop, "Use Mask",
1314                                  "Use a grease pencil data-block as a mask to use only specified areas of pattern "
1315                                  "when tracking");
1316         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1317
1318         /* use_normalization */
1319         prop = RNA_def_property(srna, "use_normalization", PROP_BOOLEAN, PROP_NONE);
1320         RNA_def_property_boolean_sdna(prop, NULL, "algorithm_flag", TRACK_ALGORITHM_FLAG_USE_NORMALIZATION);
1321         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1322         RNA_def_property_ui_text(prop, "Normalize", "Normalize light intensities while tracking. Slower");
1323         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1324
1325         /* markers */
1326         prop = RNA_def_property(srna, "markers", PROP_COLLECTION, PROP_NONE);
1327         RNA_def_property_struct_type(prop, "MovieTrackingMarker");
1328         RNA_def_property_collection_sdna(prop, NULL, "markers", "markersnr");
1329         RNA_def_property_ui_text(prop, "Markers", "Collection of markers in track");
1330         rna_def_trackingMarkers(brna, prop);
1331
1332         /* ** channels ** */
1333
1334         /* use_red_channel */
1335         prop = RNA_def_property(srna, "use_red_channel", PROP_BOOLEAN, PROP_NONE);
1336         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_RED);
1337         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1338         RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
1339         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1340
1341         /* use_green_channel */
1342         prop = RNA_def_property(srna, "use_green_channel", PROP_BOOLEAN, PROP_NONE);
1343         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_GREEN);
1344         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1345         RNA_def_property_ui_text(prop, "Use Green Channel", "Use green channel from footage for tracking");
1346         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1347
1348         /* use_blue_channel */
1349         prop = RNA_def_property(srna, "use_blue_channel", PROP_BOOLEAN, PROP_NONE);
1350         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_BLUE);
1351         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1352         RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
1353         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1354
1355         /* preview_grayscale */
1356         prop = RNA_def_property(srna, "use_grayscale_preview", PROP_BOOLEAN, PROP_NONE);
1357         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_PREVIEW_GRAYSCALE);
1358         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1359         RNA_def_property_ui_text(prop, "Grayscale", "Display what the tracking algorithm sees in the preview");
1360         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1361
1362         /* preview_alpha */
1363         prop = RNA_def_property(srna, "use_alpha_preview", PROP_BOOLEAN, PROP_NONE);
1364         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_PREVIEW_ALPHA);
1365         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1366         RNA_def_property_ui_text(prop, "Alpha", "Apply track's mask on displaying preview");
1367         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1368
1369         /* has bundle */
1370         prop = RNA_def_property(srna, "has_bundle", PROP_BOOLEAN, PROP_NONE);
1371         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_HAS_BUNDLE);
1372         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1373         RNA_def_property_ui_text(prop, "Has Bundle", "True if track has a valid bundle");
1374
1375         /* bundle position */
1376         prop = RNA_def_property(srna, "bundle", PROP_FLOAT, PROP_TRANSLATION);
1377         RNA_def_property_array(prop, 3);
1378         RNA_def_property_float_sdna(prop, NULL, "bundle_pos");
1379         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1380         RNA_def_property_ui_text(prop, "Bundle", "Position of bundle reconstructed from this track");
1381         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1382
1383         /* hide */
1384         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1385         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_HIDDEN);
1386         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1387         RNA_def_property_ui_text(prop, "Hide", "Track is hidden");
1388         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1389
1390         /* select */
1391         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1392         RNA_def_property_boolean_funcs(prop, "rna_trackingTrack_select_get", "rna_trackingTrack_select_set");
1393         RNA_def_property_ui_text(prop, "Select", "Track is selected");
1394         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1395
1396         /* select_anchor */
1397         prop = RNA_def_property(srna, "select_anchor", PROP_BOOLEAN, PROP_NONE);
1398         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1399         RNA_def_property_ui_text(prop, "Select Anchor", "Track's anchor point is selected");
1400         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1401
1402         /* select_pattern */
1403         prop = RNA_def_property(srna, "select_pattern", PROP_BOOLEAN, PROP_NONE);
1404         RNA_def_property_boolean_sdna(prop, NULL, "pat_flag", SELECT);
1405         RNA_def_property_ui_text(prop, "Select Pattern", "Track's pattern area is selected");
1406         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1407
1408         /* select_search */
1409         prop = RNA_def_property(srna, "select_search", PROP_BOOLEAN, PROP_NONE);
1410         RNA_def_property_boolean_sdna(prop, NULL, "search_flag", SELECT);
1411         RNA_def_property_ui_text(prop, "Select Search", "Track's search area is selected");
1412         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1413
1414         /* locked */
1415         prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1416         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_LOCKED);
1417         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1418         RNA_def_property_ui_text(prop, "Lock", "Track is locked and all changes to it are disabled");
1419         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1420
1421         /* custom color */
1422         prop = RNA_def_property(srna, "use_custom_color", PROP_BOOLEAN, PROP_NONE);
1423         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_CUSTOMCOLOR);
1424         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1425         RNA_def_property_ui_text(prop, "Custom Color", "Use custom color instead of theme-defined");
1426         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1427
1428         /* color */
1429         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
1430         RNA_def_property_array(prop, 3);
1431         RNA_def_property_range(prop, 0.0f, 1.0f);
1432         RNA_def_property_ui_text(prop, "Color",
1433                                  "Color of the track in the Movie Clip Editor and the 3D viewport after a solve");
1434         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1435
1436         /* average error */
1437         prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1438         RNA_def_property_float_sdna(prop, NULL, "error");
1439         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1440         RNA_def_property_ui_text(prop, "Average Error", "Average error of re-projection");
1441
1442         /* grease pencil */
1443         prop = RNA_def_property(srna, "grease_pencil", PROP_POINTER, PROP_NONE);
1444         RNA_def_property_pointer_sdna(prop, NULL, "gpd");
1445         RNA_def_property_struct_type(prop, "GreasePencil");
1446         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
1447         RNA_def_property_ui_text(prop, "Grease Pencil", "Grease pencil data for this track");
1448         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1449
1450         /* weight */
1451         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
1452         RNA_def_property_float_sdna(prop, NULL, "weight");
1453         RNA_def_property_range(prop, 0.0f, 1.0f);
1454         RNA_def_property_ui_text(prop, "Weight", "Influence of this track on a final solution");
1455
1456         /* weight_stab */
1457         prop = RNA_def_property(srna, "weight_stab", PROP_FLOAT, PROP_FACTOR);
1458         RNA_def_property_float_sdna(prop, NULL, "weight_stab");
1459         RNA_def_property_range(prop, 0.0f, 1.0f);
1460         RNA_def_property_ui_text(prop, "Stab Weight", "Influence of this track on 2D stabilization");
1461
1462         /* offset */
1463         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_TRANSLATION);
1464         RNA_def_property_array(prop, 2);
1465         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1466         RNA_def_property_float_sdna(prop, NULL, "offset");
1467         RNA_def_property_ui_text(prop, "Offset", "Offset of track from the parenting point");
1468         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1469 }
1470
1471 static void rna_def_trackingPlaneMarker(BlenderRNA *brna)
1472 {
1473         StructRNA *srna;
1474         PropertyRNA *prop;
1475
1476         srna = RNA_def_struct(brna, "MovieTrackingPlaneMarker", NULL);
1477         RNA_def_struct_ui_text(srna, "Movie Tracking Plane Marker Data", "Match-moving plane marker data for tracking");
1478
1479         /* frame */
1480         prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
1481         RNA_def_property_int_sdna(prop, NULL, "framenr");
1482         RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
1483         RNA_def_property_int_funcs(prop, NULL, "rna_trackingPlaneMarker_frame_set", NULL);
1484         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1485
1486         /* Corners */
1487         prop = RNA_def_property(srna, "corners", PROP_FLOAT, PROP_MATRIX);
1488         RNA_def_property_float_sdna(prop, NULL, "corners");
1489         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1490         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x2);
1491         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1492         RNA_def_property_ui_text(prop, "Corners",
1493                                  "Array of coordinates which represents UI rectangle corners in "
1494                                  "frame normalized coordinates");
1495         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1496
1497         /* enable */
1498         prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1499         RNA_def_property_boolean_sdna(prop, NULL, "flag", PLANE_MARKER_DISABLED);
1500         RNA_def_property_ui_text(prop, "Mode", "Is marker muted for current frame");
1501         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1502 }
1503
1504 static void rna_def_trackingPlaneMarkers(BlenderRNA *brna, PropertyRNA *cprop)
1505 {
1506         StructRNA *srna;
1507         FunctionRNA *func;
1508         PropertyRNA *parm;
1509
1510         RNA_def_property_srna(cprop, "MovieTrackingPlaneMarkers");
1511         srna = RNA_def_struct(brna, "MovieTrackingPlaneMarkers", NULL);
1512         RNA_def_struct_sdna(srna, "MovieTrackingPlaneTrack");
1513         RNA_def_struct_ui_text(srna, "Movie Tracking Plane Markers",
1514                                "Collection of markers for movie tracking plane track");
1515
1516         func = RNA_def_function(srna, "find_frame", "rna_trackingPlaneMarkers_find_frame");
1517         RNA_def_function_ui_description(func, "Get plane marker for specified frame");
1518         parm = RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
1519                            "Frame number to find marker for", MINFRAME, MAXFRAME);
1520         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1521         RNA_def_boolean(func, "exact", true, "Exact",
1522                         "Get plane marker at exact frame number rather than get estimated marker");
1523         parm = RNA_def_pointer(func, "plane_marker", "MovieTrackingPlaneMarker", "", "Plane marker for specified frame");
1524         RNA_def_function_return(func, parm);
1525
1526         func = RNA_def_function(srna, "insert_frame", "rna_trackingPlaneMarkers_insert_frame");
1527         RNA_def_function_ui_description(func, "Insert a new plane marker at the specified frame");
1528         parm = RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
1529                            "Frame number to insert marker to", MINFRAME, MAXFRAME);
1530         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1531         parm = RNA_def_pointer(func, "plane_marker", "MovieTrackingPlaneMarker", "", "Newly created plane marker");
1532         RNA_def_function_return(func, parm);
1533
1534         func = RNA_def_function(srna, "delete_frame", "rna_trackingPlaneMarkers_delete_frame");
1535         RNA_def_function_ui_description(func, "Delete plane marker at specified frame");
1536         parm = RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
1537                            "Frame number to delete plane marker from", MINFRAME, MAXFRAME);
1538         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1539 }
1540
1541 static void rna_def_trackingPlaneTrack(BlenderRNA *brna)
1542 {
1543         StructRNA *srna;
1544         PropertyRNA *prop;
1545
1546         rna_def_trackingPlaneMarker(brna);
1547
1548         srna = RNA_def_struct(brna, "MovieTrackingPlaneTrack", NULL);
1549         RNA_def_struct_path_func(srna, "rna_trackingPlaneTrack_path");
1550         RNA_def_struct_ui_text(srna, "Movie tracking plane track data", "Match-moving plane track data for tracking");
1551         RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
1552
1553         /* name */
1554         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1555         RNA_def_property_ui_text(prop, "Name", "Unique name of track");
1556         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingPlaneTrack_name_set");
1557         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
1558         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1559         RNA_def_struct_name_property(srna, prop);
1560
1561         /* markers */
1562         prop = RNA_def_property(srna, "markers", PROP_COLLECTION, PROP_NONE);
1563         RNA_def_property_struct_type(prop, "MovieTrackingPlaneMarker");
1564         RNA_def_property_collection_sdna(prop, NULL, "markers", "markersnr");
1565         RNA_def_property_ui_text(prop, "Markers", "Collection of markers in track");
1566         rna_def_trackingPlaneMarkers(brna, prop);
1567
1568         /* select */
1569         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1570         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1571         RNA_def_property_ui_text(prop, "Select", "Plane track is selected");
1572         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1573
1574         /* auto keyframing */
1575         prop = RNA_def_property(srna, "use_auto_keying", PROP_BOOLEAN, PROP_NONE);
1576         RNA_def_property_boolean_sdna(prop, NULL, "flag", PLANE_TRACK_AUTOKEY);
1577         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1578         RNA_def_property_ui_text(prop, "Auto Keyframe", "Automatic keyframe insertion when moving plane corners");
1579         RNA_def_property_ui_icon(prop, ICON_REC, 0);
1580
1581         /* image */
1582         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1583         RNA_def_property_struct_type(prop, "Image");
1584         RNA_def_property_flag(prop, PROP_EDITABLE);
1585         RNA_def_property_ui_text(prop, "Image", "Image displayed in the track during editing in clip editor");
1586         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1587
1588         /* image opacity */
1589         prop = RNA_def_property(srna, "image_opacity", PROP_FLOAT, PROP_FACTOR);
1590         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1591         RNA_def_property_range(prop, 0.0, 1.0);
1592         RNA_def_property_ui_text(prop, "Image Opacity", "Opacity of the image");
1593         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1594 }
1595
1596 static void rna_def_trackingStabilization(BlenderRNA *brna)
1597 {
1598         StructRNA *srna;
1599         PropertyRNA *prop;
1600
1601         static const EnumPropertyItem filter_items[] = {
1602                 {TRACKING_FILTER_NEAREST,  "NEAREST",  0, "Nearest",  "No interpolation, use nearest neighbor pixel"},
1603                 {TRACKING_FILTER_BILINEAR, "BILINEAR", 0, "Bilinear", "Simple interpolation between adjacent pixels"},
1604                 {TRACKING_FILTER_BICUBIC,  "BICUBIC",  0, "Bicubic",  "High quality pixel interpolation"},
1605                 {0, NULL, 0, NULL, NULL}
1606         };
1607
1608         srna = RNA_def_struct(brna, "MovieTrackingStabilization", NULL);
1609         RNA_def_struct_path_func(srna, "rna_trackingStabilization_path");
1610         RNA_def_struct_ui_text(srna, "Movie tracking stabilization data", "2D stabilization based on tracking markers");
1611
1612         /* 2d stabilization */
1613         prop = RNA_def_property(srna, "use_2d_stabilization", PROP_BOOLEAN, PROP_NONE);
1614         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_2D_STABILIZATION);
1615         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1616         RNA_def_property_ui_text(prop, "Use 2D stabilization", "Use 2D stabilization for footage");
1617         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1618
1619         /* use_stabilize_rotation */
1620         prop = RNA_def_property(srna, "use_stabilize_rotation", PROP_BOOLEAN, PROP_NONE);
1621         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1622         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_STABILIZE_ROTATION);
1623         RNA_def_property_ui_text(prop, "Stabilize Rotation", "Stabilize detected rotation around center of frame");
1624         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1625
1626         /* use_stabilize_scale */
1627         prop = RNA_def_property(srna, "use_stabilize_scale", PROP_BOOLEAN, PROP_NONE);
1628         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1629         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_STABILIZE_SCALE);
1630         RNA_def_property_ui_text(prop, "Stabilize Scale", "Compensate any scale changes relative to center of rotation");
1631         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1632
1633         /* tracks */
1634         prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1635         RNA_def_property_collection_funcs(prop, "rna_tracking_stabTracks_begin", "rna_iterator_listbase_next",
1636                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1637                                           NULL, NULL, NULL, NULL);
1638         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1639         RNA_def_property_ui_text(prop, "Translation Tracks",
1640                                  "Collection of tracks used for 2D stabilization (translation)");
1641         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1642
1643         /* active track index */
1644         prop = RNA_def_property(srna, "active_track_index", PROP_INT, PROP_NONE);
1645         RNA_def_property_int_sdna(prop, NULL, "act_track");
1646         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1647         RNA_def_property_int_funcs(prop, "rna_tracking_stabTracks_active_index_get",
1648                                    "rna_tracking_stabTracks_active_index_set",
1649                                    "rna_tracking_stabTracks_active_index_range");
1650         RNA_def_property_ui_text(prop, "Active Track Index",
1651                                  "Index of active track in translation stabilization tracks list");
1652
1653         /* tracks used for rotation stabilization */
1654         prop = RNA_def_property(srna, "rotation_tracks", PROP_COLLECTION, PROP_NONE);
1655         RNA_def_property_collection_funcs(prop, "rna_tracking_stabRotTracks_begin", "rna_iterator_listbase_next",
1656                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1657                                           NULL, NULL, NULL, NULL);
1658         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1659         RNA_def_property_ui_text(prop, "Rotation Tracks", "Collection of tracks used for 2D stabilization (translation)");
1660         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1661
1662         /* active rotation track index */
1663         prop = RNA_def_property(srna, "active_rotation_track_index", PROP_INT, PROP_NONE);
1664         RNA_def_property_int_sdna(prop, NULL, "act_rot_track");
1665         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1666         RNA_def_property_int_funcs(prop, "rna_tracking_stabRotTracks_active_index_get",
1667                                    "rna_tracking_stabRotTracks_active_index_set",
1668                                    "rna_tracking_stabRotTracks_active_index_range");
1669         RNA_def_property_ui_text(prop, "Active Rotation Track Index",
1670                                  "Index of active track in rotation stabilization tracks list");
1671
1672         /* anchor frame */
1673         prop = RNA_def_property(srna, "anchor_frame", PROP_INT, PROP_NONE);
1674         RNA_def_property_int_sdna(prop, NULL, "anchor_frame");
1675         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1676         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
1677         RNA_def_property_ui_text(prop, "Anchor Frame",
1678                                  "Reference point to anchor stabilization "
1679                                  "(other frames will be adjusted relative to this frame's position)");
1680         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1681
1682         /* target position */
1683         prop = RNA_def_property(srna, "target_position", PROP_FLOAT, PROP_TRANSLATION);
1684         RNA_def_property_array(prop, 2);
1685         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 3); /* increment in steps of 0.01 and show 3 digit after point */
1686         RNA_def_property_float_sdna(prop, NULL, "target_pos");
1687         RNA_def_property_ui_text(prop, "Expected Position",
1688                                  "Known relative offset of original shot, will be subtracted "
1689                                  "(e.g. for panning shot, can be animated)");
1690         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1691
1692         /* target rotation */
1693         prop = RNA_def_property(srna, "target_rotation", PROP_FLOAT, PROP_ANGLE);
1694         RNA_def_property_float_sdna(prop, NULL, "target_rot");
1695         RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1696         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 10.0f, 3);
1697         RNA_def_property_ui_text(prop, "Expected Rotation",
1698                                  "Rotation present on original shot, will be compensated (e.g. for deliberate tilting)");
1699         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1700
1701         /* target scale */
1702         prop = RNA_def_property(srna, "target_scale", PROP_FLOAT, PROP_FACTOR);
1703         RNA_def_property_float_sdna(prop, NULL, "scale");
1704         RNA_def_property_range(prop, FLT_EPSILON, FLT_MAX);
1705         RNA_def_property_ui_range(prop, 0.01f, 10.0f, 0.001f, 3); /* increment in steps of 0.001. Show 3 digit after point */
1706         RNA_def_property_ui_text(prop, "Expected Scale",
1707                                  "Explicitly scale resulting frame to compensate zoom of original shot");
1708         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1709
1710         /* autoscale */
1711         prop = RNA_def_property(srna, "use_autoscale", PROP_BOOLEAN, PROP_NONE);
1712         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_AUTOSCALE);
1713         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1714         RNA_def_property_ui_text(prop, "Autoscale",
1715                                  "Automatically scale footage to cover unfilled areas when stabilizing");
1716         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1717
1718         /* max scale */
1719         prop = RNA_def_property(srna, "scale_max", PROP_FLOAT, PROP_FACTOR);
1720         RNA_def_property_float_sdna(prop, NULL, "maxscale");
1721         RNA_def_property_range(prop, 0.0f, 10.0f);
1722         RNA_def_property_ui_text(prop, "Maximal Scale", "Limit the amount of automatic scaling");
1723         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1724
1725         /* influence_location */
1726         prop = RNA_def_property(srna, "influence_location", PROP_FLOAT, PROP_FACTOR);
1727         RNA_def_property_float_sdna(prop, NULL, "locinf");
1728         RNA_def_property_range(prop, 0.0f, 1.0f);
1729         RNA_def_property_ui_text(prop, "Location Influence", "Influence of stabilization algorithm on footage location");
1730         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1731
1732         /* influence_scale */
1733         prop = RNA_def_property(srna, "influence_scale", PROP_FLOAT, PROP_FACTOR);
1734         RNA_def_property_float_sdna(prop, NULL, "scaleinf");
1735         RNA_def_property_range(prop, 0.0f, 1.0f);
1736         RNA_def_property_ui_text(prop, "Scale Influence", "Influence of stabilization algorithm on footage scale");
1737         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1738
1739         /* influence_rotation */
1740         prop = RNA_def_property(srna, "influence_rotation", PROP_FLOAT, PROP_FACTOR);
1741         RNA_def_property_float_sdna(prop, NULL, "rotinf");
1742         RNA_def_property_range(prop, 0.0f, 1.0f);
1743         RNA_def_property_ui_text(prop, "Rotation Influence", "Influence of stabilization algorithm on footage rotation");
1744         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1745
1746         /* filter */
1747         prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
1748         RNA_def_property_enum_sdna(prop, NULL, "filter");
1749         RNA_def_property_enum_items(prop, filter_items);
1750         RNA_def_property_ui_text(prop, "Interpolate",
1751                                  "Interpolation to use for sub-pixel shifts and rotations due to stabilization");
1752         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1753
1754         /* UI display : show participating tracks */
1755         prop = RNA_def_property(srna, "show_tracks_expanded", PROP_BOOLEAN, PROP_NONE);
1756         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1757         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_SHOW_STAB_TRACKS);
1758         RNA_def_property_ui_text(prop, "Show Tracks", "Show UI list of tracks participating in stabilization");
1759         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
1760 }
1761
1762 static void rna_def_reconstructedCamera(BlenderRNA *brna)
1763 {
1764         StructRNA *srna;
1765         PropertyRNA *prop;
1766
1767         srna = RNA_def_struct(brna, "MovieReconstructedCamera", NULL);
1768         RNA_def_struct_ui_text(srna, "Movie tracking reconstructed camera data",
1769                                "Match-moving reconstructed camera data from tracker");
1770
1771         /* frame */
1772         prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
1773         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1774         RNA_def_property_int_sdna(prop, NULL, "framenr");
1775         RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
1776
1777         /* matrix */
1778         prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
1779         RNA_def_property_float_sdna(prop, NULL, "mat");
1780         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1781         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1782         RNA_def_property_ui_text(prop, "Matrix", "Worldspace transformation matrix");
1783
1784         /* average_error */
1785         prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1786         RNA_def_property_float_sdna(prop, NULL, "error");
1787         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1788         RNA_def_property_ui_text(prop, "Average Error", "Average error of reconstruction");
1789 }
1790
1791 static void rna_def_trackingReconstructedCameras(BlenderRNA *brna)
1792 {
1793         StructRNA *srna;
1794         FunctionRNA *func;
1795         PropertyRNA *parm;
1796
1797         srna = RNA_def_struct(brna, "MovieTrackingReconstructedCameras", NULL);
1798         RNA_def_struct_sdna(srna, "MovieTrackingReconstruction");
1799         RNA_def_struct_ui_text(srna, "Reconstructed Cameras", "Collection of solved cameras");
1800
1801         func = RNA_def_function(srna, "find_frame", "rna_trackingCameras_find_frame");
1802         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1803         RNA_def_function_ui_description(func, "Find a reconstructed camera for a give frame number");
1804         RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to find camera for", MINFRAME, MAXFRAME);
1805         parm = RNA_def_pointer(func, "camera", "MovieReconstructedCamera", "", "Camera for a given frame");
1806         RNA_def_function_return(func, parm);
1807
1808         func = RNA_def_function(srna, "matrix_from_frame", "rna_trackingCameras_matrix_from_frame");
1809         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1810         RNA_def_function_ui_description(func, "Return interpolated camera matrix for a given frame");
1811         RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to find camera for", MINFRAME, MAXFRAME);
1812         parm = RNA_def_float_matrix(func, "matrix", 4, 4, NULL, -FLT_MAX, FLT_MAX, "Matrix",
1813                                     "Interpolated camera matrix for a given frame", -FLT_MAX, FLT_MAX);
1814         RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);  /* needed for string return value */
1815         RNA_def_function_output(func, parm);
1816 }
1817
1818 static void rna_def_trackingReconstruction(BlenderRNA *brna)
1819 {
1820         StructRNA *srna;
1821         PropertyRNA *prop;
1822
1823         rna_def_reconstructedCamera(brna);
1824
1825         srna = RNA_def_struct(brna, "MovieTrackingReconstruction", NULL);
1826         RNA_def_struct_ui_text(srna, "Movie tracking reconstruction data",
1827                                "Match-moving reconstruction data from tracker");
1828
1829         /* is_valid */
1830         prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
1831         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1832         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_RECONSTRUCTED);
1833         RNA_def_property_ui_text(prop, "Reconstructed", "Is tracking data contains valid reconstruction information");
1834
1835         /* average_error */
1836         prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1837         RNA_def_property_float_sdna(prop, NULL, "error");
1838         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1839         RNA_def_property_ui_text(prop, "Average Error", "Average error of reconstruction");
1840
1841         /* cameras */
1842         prop = RNA_def_property(srna, "cameras", PROP_COLLECTION, PROP_NONE);
1843         RNA_def_property_struct_type(prop, "MovieReconstructedCamera");
1844         RNA_def_property_collection_sdna(prop, NULL, "cameras", "camnr");
1845         RNA_def_property_ui_text(prop, "Cameras", "Collection of solved cameras");
1846         RNA_def_property_srna(prop, "MovieTrackingReconstructedCameras");
1847
1848 }
1849
1850 static void rna_def_trackingTracks(BlenderRNA *brna)
1851 {
1852         StructRNA *srna;
1853         FunctionRNA *func;
1854         PropertyRNA *prop;
1855         PropertyRNA *parm;
1856
1857         srna = RNA_def_struct(brna, "MovieTrackingTracks", NULL);
1858         RNA_def_struct_sdna(srna, "MovieTracking");
1859         RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
1860
1861         func = RNA_def_function(srna, "new", "rna_trackingTracks_new");
1862         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1863         RNA_def_function_ui_description(func, "Create new motion track in this movie clip");
1864         RNA_def_string(func, "name", NULL, 0, "", "Name of new track");
1865         RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to add track on", MINFRAME, MAXFRAME);
1866         parm = RNA_def_pointer(func, "track", "MovieTrackingTrack", "", "Newly created track");
1867         RNA_def_function_return(func, parm);
1868
1869         /* active track */
1870         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1871         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1872         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", NULL, NULL);
1873         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
1874         RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
1875 }
1876
1877 static void rna_def_trackingPlaneTracks(BlenderRNA *brna)
1878 {
1879         StructRNA *srna;
1880         PropertyRNA *prop;
1881
1882         srna = RNA_def_struct(brna, "MovieTrackingPlaneTracks", NULL);
1883         RNA_def_struct_sdna(srna, "MovieTracking");
1884         RNA_def_struct_ui_text(srna, "Movie Plane Tracks", "Collection of movie tracking plane tracks");
1885
1886         /* TODO(sergey): Add API to create new plane tracks */
1887
1888         /* active plane track */
1889         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1890         RNA_def_property_struct_type(prop, "MovieTrackingPlaneTrack");
1891         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_plane_track_get", "rna_tracking_active_plane_track_set",
1892                                        NULL, NULL);
1893         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
1894         RNA_def_property_ui_text(prop, "Active Plane Track", "Active plane track in this tracking data object");
1895 }
1896
1897 static void rna_def_trackingObjectTracks(BlenderRNA *brna)
1898 {
1899         StructRNA *srna;
1900         FunctionRNA *func;
1901         PropertyRNA *prop;
1902         PropertyRNA *parm;
1903
1904         srna = RNA_def_struct(brna, "MovieTrackingObjectTracks", NULL);
1905         RNA_def_struct_sdna(srna, "MovieTrackingObject");
1906         RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
1907
1908         func = RNA_def_function(srna, "new", "rna_trackingObject_tracks_new");
1909         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1910         RNA_def_function_ui_description(func, "create new motion track in this movie clip");
1911         RNA_def_string(func, "name", NULL, 0, "", "Name of new track");
1912         RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to add tracks on", MINFRAME, MAXFRAME);
1913         parm = RNA_def_pointer(func, "track", "MovieTrackingTrack", "", "Newly created track");
1914         RNA_def_function_return(func, parm);
1915
1916         /* active track */
1917         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1918         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1919         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", NULL, NULL);
1920         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
1921         RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
1922 }
1923
1924 static void rna_def_trackingObjectPlaneTracks(BlenderRNA *brna)
1925 {
1926         StructRNA *srna;
1927         PropertyRNA *prop;
1928
1929         srna = RNA_def_struct(brna, "MovieTrackingObjectPlaneTracks", NULL);
1930         RNA_def_struct_sdna(srna, "MovieTrackingObject");
1931         RNA_def_struct_ui_text(srna, "Plane Tracks", "Collection of tracking plane tracks");
1932
1933         /* active track */
1934         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1935         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1936         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_plane_track_get", "rna_tracking_active_plane_track_set",
1937                                        NULL, NULL);
1938         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
1939         RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
1940 }
1941
1942 static void rna_def_trackingObject(BlenderRNA *brna)
1943 {
1944         StructRNA *srna;
1945         PropertyRNA *prop;
1946
1947         srna = RNA_def_struct(brna, "MovieTrackingObject", NULL);
1948         RNA_def_struct_ui_text(srna, "Movie tracking object data", "Match-moving object tracking and reconstruction data");
1949
1950         /* name */
1951         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1952         RNA_def_property_ui_text(prop, "Name", "Unique name of object");
1953         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingObject_name_set");
1954         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
1955         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, NULL);
1956         RNA_def_struct_name_property(srna, prop);
1957
1958         /* is_camera */
1959         prop = RNA_def_property(srna, "is_camera", PROP_BOOLEAN, PROP_NONE);
1960         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1961         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_OBJECT_CAMERA);
1962         RNA_def_property_ui_text(prop, "Camera", "Object is used for camera tracking");
1963         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1964
1965         /* tracks */
1966         prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1967         RNA_def_property_collection_funcs(prop, "rna_trackingObject_tracks_begin", "rna_iterator_listbase_next",
1968                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1969                                           NULL, NULL, NULL, NULL);
1970         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1971         RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks in this tracking data object");
1972         RNA_def_property_srna(prop, "MovieTrackingObjectTracks");
1973
1974         /* plane tracks */
1975         prop = RNA_def_property(srna, "plane_tracks", PROP_COLLECTION, PROP_NONE);
1976         RNA_def_property_collection_funcs(prop, "rna_trackingObject_plane_tracks_begin", "rna_iterator_listbase_next",
1977                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1978                                           NULL, NULL, NULL, NULL);
1979         RNA_def_property_struct_type(prop, "MovieTrackingPlaneTrack");
1980         RNA_def_property_ui_text(prop, "Plane Tracks", "Collection of plane tracks in this tracking data object");
1981         RNA_def_property_srna(prop, "MovieTrackingObjectPlaneTracks");
1982
1983         /* reconstruction */
1984         prop = RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
1985         RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
1986         RNA_def_property_pointer_funcs(prop, "rna_trackingObject_reconstruction_get", NULL, NULL, NULL);
1987
1988         /* scale */
1989         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
1990         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1991         RNA_def_property_float_sdna(prop, NULL, "scale");
1992         RNA_def_property_range(prop, 0.0001f, 10000.0f);
1993         RNA_def_property_ui_range(prop, 0.0001f, 10000.0, 1, 4);
1994         RNA_def_property_float_default(prop, 1.0f);
1995         RNA_def_property_ui_text(prop, "Scale", "Scale of object solution in camera space");
1996         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingObject_flushUpdate");
1997
1998         /* keyframe_a */
1999         prop = RNA_def_property(srna, "keyframe_a", PROP_INT, PROP_NONE);
2000         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2001         RNA_def_property_int_sdna(prop, NULL, "keyframe1");
2002         RNA_def_property_ui_text(prop, "Keyframe A", "First keyframe used for reconstruction initialization");
2003
2004         /* keyframe_b */
2005         prop = RNA_def_property(srna, "keyframe_b", PROP_INT, PROP_NONE);
2006         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2007         RNA_def_property_int_sdna(prop, NULL, "keyframe2");
2008         RNA_def_property_ui_text(prop, "Keyframe B", "Second keyframe used for reconstruction initialization");
2009 }
2010
2011 static void rna_def_trackingObjects(BlenderRNA *brna, PropertyRNA *cprop)
2012 {
2013         StructRNA *srna;
2014         PropertyRNA *prop;
2015
2016         FunctionRNA *func;
2017         PropertyRNA *parm;
2018
2019         RNA_def_property_srna(cprop, "MovieTrackingObjects");
2020         srna = RNA_def_struct(brna, "MovieTrackingObjects", NULL);
2021         RNA_def_struct_sdna(srna, "MovieTracking");
2022         RNA_def_struct_ui_text(srna, "Movie Objects", "Collection of movie tracking objects");
2023
2024         func = RNA_def_function(srna, "new", "rna_trackingObject_new");
2025         RNA_def_function_ui_description(func, "Add tracking object to this movie clip");
2026         parm = RNA_def_string(func, "name", NULL, 0, "", "Name of new object");
2027         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2028         parm = RNA_def_pointer(func, "object", "MovieTrackingObject", "", "New motion tracking object");
2029         RNA_def_function_return(func, parm);
2030
2031         func = RNA_def_function(srna, "remove", "rna_trackingObject_remove");
2032         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2033         RNA_def_function_ui_description(func, "Remove tracking object from this movie clip");
2034         parm = RNA_def_pointer(func, "object", "MovieTrackingObject", "", "Motion tracking object to be removed");
2035         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2036         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2037
2038         /* active object */
2039         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2040         RNA_def_property_struct_type(prop, "MovieTrackingObject");
2041         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_object_get",
2042                                        "rna_tracking_active_object_set", NULL, NULL);
2043         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
2044         RNA_def_property_ui_text(prop, "Active Object", "Active object in this tracking data object");
2045 }
2046
2047 static void rna_def_trackingDopesheet(BlenderRNA *brna)
2048 {
2049         StructRNA *srna;
2050         PropertyRNA *prop;
2051
2052         static const EnumPropertyItem sort_items[] = {
2053                 {TRACKING_DOPE_SORT_NAME, "NAME", 0, "Name", "Sort channels by their names"},
2054                 {TRACKING_DOPE_SORT_LONGEST, "LONGEST", 0, "Longest", "Sort channels by longest tracked segment"},
2055                 {TRACKING_DOPE_SORT_TOTAL, "TOTAL", 0, "Total", "Sort channels by overall amount of tracked segments"},
2056                 {TRACKING_DOPE_SORT_AVERAGE_ERROR, "AVERAGE_ERROR", 0, "Average Error",
2057                                                    "Sort channels by average reprojection error of tracks after solve"},
2058                 {0, NULL, 0, NULL, NULL}
2059         };
2060
2061         srna = RNA_def_struct(brna, "MovieTrackingDopesheet", NULL);
2062         RNA_def_struct_ui_text(srna, "Movie Tracking Dopesheet", "Match-moving dopesheet data");
2063
2064         /* dopesheet sort */
2065         prop = RNA_def_property(srna, "sort_method", PROP_ENUM, PROP_NONE);
2066         RNA_def_property_enum_sdna(prop, NULL, "sort_method");
2067         RNA_def_property_enum_items(prop, sort_items);
2068         RNA_def_property_ui_text(prop, "Dopesheet Sort Field", "Method to be used to sort channels in dopesheet view");
2069         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2070
2071         /* invert_dopesheet_sort */
2072         prop = RNA_def_property(srna, "use_invert_sort", PROP_BOOLEAN, PROP_NONE);
2073         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_DOPE_SORT_INVERSE);
2074         RNA_def_property_ui_text(prop, "Invert Dopesheet Sort", "Invert sort order of dopesheet channels");
2075         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2076
2077         /* show_only_selected */
2078         prop = RNA_def_property(srna, "show_only_selected", PROP_BOOLEAN, PROP_NONE);
2079         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_DOPE_SELECTED_ONLY);
2080         RNA_def_property_ui_text(prop, "Only Selected", "Only include channels relating to selected objects and data");
2081         RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 0);
2082         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2083
2084         /* show_hidden */
2085         prop = RNA_def_property(srna, "show_hidden", PROP_BOOLEAN, PROP_NONE);
2086         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_DOPE_SHOW_HIDDEN);
2087         RNA_def_property_ui_text(prop, "Display Hidden", "Include channels from objects/bone that aren't visible");
2088         RNA_def_property_ui_icon(prop, ICON_GHOST_ENABLED, 0);
2089         RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2090 }
2091
2092 static void rna_def_tracking(BlenderRNA *brna)
2093 {
2094         StructRNA *srna;
2095         PropertyRNA *prop;
2096
2097         rna_def_trackingSettings(brna);
2098         rna_def_trackingCamera(brna);
2099         rna_def_trackingTrack(brna);
2100         rna_def_trackingPlaneTrack(brna);
2101         rna_def_trackingTracks(brna);
2102         rna_def_trackingPlaneTracks(brna);
2103         rna_def_trackingObjectTracks(brna);
2104         rna_def_trackingObjectPlaneTracks(brna);
2105         rna_def_trackingStabilization(brna);
2106         rna_def_trackingReconstructedCameras(brna);
2107         rna_def_trackingReconstruction(brna);
2108         rna_def_trackingObject(brna);
2109         rna_def_trackingDopesheet(brna);
2110
2111         srna = RNA_def_struct(brna, "MovieTracking", NULL);
2112         RNA_def_struct_path_func(srna, "rna_tracking_path");
2113         RNA_def_struct_ui_text(srna, "Movie tracking data", "Match-moving data for tracking");
2114
2115         /* settings */
2116         prop = RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
2117         RNA_def_property_struct_type(prop, "MovieTrackingSettings");
2118
2119         /* camera properties */
2120         prop = RNA_def_property(srna, "camera", PROP_POINTER, PROP_NONE);
2121         RNA_def_property_struct_type(prop, "MovieTrackingCamera");
2122
2123         /* tracks */
2124         prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
2125         RNA_def_property_collection_funcs(prop, "rna_trackingTracks_begin", "rna_iterator_listbase_next",
2126                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
2127                                           NULL, NULL, NULL, NULL);
2128         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2129         RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks in this tracking data object");
2130         RNA_def_property_srna(prop, "MovieTrackingTracks");
2131
2132         /* tracks */
2133         prop = RNA_def_property(srna, "plane_tracks", PROP_COLLECTION, PROP_NONE);
2134         RNA_def_property_collection_funcs(prop, "rna_trackingPlaneTracks_begin", "rna_iterator_listbase_next",
2135                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
2136                                           NULL, NULL, NULL, NULL);
2137         RNA_def_property_struct_type(prop, "MovieTrackingPlaneTrack");
2138         RNA_def_property_ui_text(prop, "Plane Tracks", "Collection of plane tracks in this tracking data object");
2139         RNA_def_property_srna(prop, "MovieTrackingPlaneTracks");
2140
2141         /* stabilization */
2142         prop = RNA_def_property(srna, "stabilization", PROP_POINTER, PROP_NONE);
2143         RNA_def_property_struct_type(prop, "MovieTrackingStabilization");
2144
2145         /* reconstruction */
2146         prop = RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
2147         RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
2148
2149         /* objects */
2150         prop = RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
2151         RNA_def_property_collection_funcs(prop, "rna_trackingObjects_begin", "rna_iterator_listbase_next",
2152                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
2153                                           NULL, NULL, NULL, NULL);
2154         RNA_def_property_struct_type(prop, "MovieTrackingObject");
2155         RNA_def_property_ui_text(prop, "Objects", "Collection of objects in this tracking data object");
2156         rna_def_trackingObjects(brna, prop);
2157
2158         /* active object index */
2159         prop = RNA_def_property(srna, "active_object_index", PROP_INT, PROP_NONE);
2160         RNA_def_property_int_sdna(prop, NULL, "objectnr");
2161         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2162         RNA_def_property_int_funcs(prop, "rna_tracking_active_object_index_get", "rna_tracking_active_object_index_set",
2163                                    "rna_tracking_active_object_index_range");
2164         RNA_def_property_ui_text(prop, "Active Object Index", "Index of active object");
2165         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
2166
2167         /* dopesheet */
2168         prop = RNA_def_property(srna, "dopesheet", PROP_POINTER, PROP_NONE);
2169         RNA_def_property_struct_type(prop, "MovieTrackingDopesheet");
2170 }
2171
2172 void RNA_def_tracking(BlenderRNA *brna)
2173 {
2174         rna_def_tracking(brna);
2175 }
2176
2177 #endif