aff8a85dd2600521854893fe6cd625b4482c5fb6
[blender.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_define.h"
39
40 #include "rna_internal.h"
41
42 #include "DNA_movieclip_types.h"
43 #include "DNA_object_types.h"   /* SELECT */
44 #include "DNA_scene_types.h"
45
46 #include "WM_types.h"
47
48 #ifdef RNA_RUNTIME
49
50 #include "BKE_depsgraph.h"
51 #include "BKE_node.h"
52
53 #include "IMB_imbuf.h"
54
55 #include "WM_api.h"
56
57 static void rna_tracking_defaultSettings_levelsUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
58 {
59         MovieClip *clip= (MovieClip*)ptr->id.data;
60         MovieTracking *tracking= &clip->tracking;
61         MovieTrackingSettings *settings= &tracking->settings;
62
63         if(settings->default_tracker==TRACKER_KLT) {
64                 int max_pyramid_level_factor= 1 << (settings->default_pyramid_levels - 1);
65                 float search_ratio= 2.3f * max_pyramid_level_factor;
66
67                 settings->default_search_size= settings->default_pattern_size*search_ratio;
68         }
69 }
70
71 static void rna_tracking_defaultSettings_patternUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
72 {
73         MovieClip *clip= (MovieClip*)ptr->id.data;
74         MovieTracking *tracking= &clip->tracking;
75         MovieTrackingSettings *settings= &tracking->settings;
76
77         if(settings->default_search_size<settings->default_pattern_size)
78                 settings->default_search_size= settings->default_pattern_size;
79 }
80
81 static void rna_tracking_defaultSettings_searchUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
82 {
83         MovieClip *clip= (MovieClip*)ptr->id.data;
84         MovieTracking *tracking= &clip->tracking;
85         MovieTrackingSettings *settings= &tracking->settings;
86
87         if(settings->default_pattern_size>settings->default_search_size)
88                 settings->default_pattern_size= settings->default_search_size;
89 }
90
91 static void rna_trackingTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
92 {
93         MovieClip *clip= (MovieClip*)ptr->id.data;
94
95         rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
96 }
97
98 static void rna_trackingObjects_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
99 {
100         MovieClip *clip= (MovieClip*)ptr->id.data;
101
102         rna_iterator_listbase_begin(iter, &clip->tracking.objects, NULL);
103 }
104
105 static int rna_tracking_active_object_index_get(PointerRNA *ptr)
106 {
107         MovieClip *clip= (MovieClip*)ptr->id.data;
108
109         return clip->tracking.objectnr;
110 }
111
112 static void rna_tracking_active_object_index_set(PointerRNA *ptr, int value)
113 {
114         MovieClip *clip= (MovieClip*)ptr->id.data;
115
116         clip->tracking.objectnr= value;
117 }
118
119 static void rna_tracking_active_object_index_range(PointerRNA *ptr, int *min, int *max)
120 {
121         MovieClip *clip= (MovieClip*)ptr->id.data;
122
123         *min= 0;
124         *max= clip->tracking.tot_object-1;
125         *max= MAX2(0, *max);
126 }
127
128 static PointerRNA rna_tracking_active_track_get(PointerRNA *ptr)
129 {
130         MovieClip *clip= (MovieClip*)ptr->id.data;
131         MovieTrackingTrack *act_track= BKE_tracking_active_track(&clip->tracking);
132
133         return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingTrack, act_track);
134 }
135
136 static void rna_tracking_active_track_set(PointerRNA *ptr, PointerRNA value)
137 {
138         MovieClip *clip= (MovieClip*)ptr->id.data;
139         MovieTrackingTrack *track= (MovieTrackingTrack *)value.data;
140         ListBase *tracksbase= BKE_tracking_get_tracks(&clip->tracking);
141         int index= BLI_findindex(tracksbase, track);
142
143         if(index>=0)
144                 clip->tracking.act_track= track;
145         else
146                 clip->tracking.act_track= NULL;
147 }
148
149 void rna_trackingTrack_name_set(PointerRNA *ptr, const char *value)
150 {
151         MovieClip *clip= (MovieClip *)ptr->id.data;
152         MovieTracking *tracking= &clip->tracking;
153         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
154         ListBase *tracksbase= &tracking->tracks;
155
156         BLI_strncpy(track->name, value, sizeof(track->name));
157
158         /* TODO: it's a bit difficult to find list track came from knowing just
159                  movie clip ID and MovieTracking structure, so keep this naive
160                          search for a while */
161         if(BLI_findindex(tracksbase, track) < 0) {
162                 MovieTrackingObject *object= tracking->objects.first;
163
164                 while(object) {
165                         if(BLI_findindex(&object->tracks, track)) {
166                                 tracksbase= &object->tracks;
167                                 break;
168                         }
169
170                         object= object->next;
171                 }
172         }
173
174         BKE_track_unique_name(tracksbase, track);
175 }
176
177 static int rna_trackingTrack_select_get(PointerRNA *ptr)
178 {
179         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
180
181         return TRACK_SELECTED(track);
182 }
183
184 static void rna_trackingTrack_select_set(PointerRNA *ptr, int value)
185 {
186         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
187
188         if(value) {
189                 track->flag|= SELECT;
190                 track->pat_flag|= SELECT;
191                 track->search_flag|= SELECT;
192         }
193         else {
194                 track->flag&= ~SELECT;
195                 track->pat_flag&= ~SELECT;
196                 track->search_flag&= ~SELECT;
197         }
198 }
199
200 static void rna_tracking_trackerPattern_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
201 {
202         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
203
204         BKE_tracking_clamp_track(track, CLAMP_PAT_DIM);
205 }
206
207 static void rna_tracking_trackerSearch_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
208 {
209         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
210
211         BKE_tracking_clamp_track(track, CLAMP_SEARCH_DIM);
212 }
213
214 static void rna_tracking_trackerAlgorithm_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
215 {
216         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
217
218         if(track->tracker==TRACKER_KLT)
219           BKE_tracking_clamp_track(track, CLAMP_PYRAMID_LEVELS);
220         else
221           BKE_tracking_clamp_track(track, CLAMP_SEARCH_DIM);
222 }
223
224 static void rna_tracking_trackerPyramid_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
225 {
226         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
227
228         BKE_tracking_clamp_track(track, CLAMP_PYRAMID_LEVELS);
229 }
230
231 static float rna_trackingCamera_focal_mm_get(PointerRNA *ptr)
232 {
233         MovieClip *clip= (MovieClip*)ptr->id.data;
234         MovieTrackingCamera *camera= &clip->tracking.camera;
235         float val= camera->focal;
236
237         if(clip->lastsize[0])
238                 val= val*camera->sensor_width/(float)clip->lastsize[0];
239
240         return val;
241 }
242
243 static void rna_trackingCamera_focal_mm_set(PointerRNA *ptr, float value)
244 {
245         MovieClip *clip= (MovieClip*)ptr->id.data;
246         MovieTrackingCamera *camera= &clip->tracking.camera;
247
248         if(clip->lastsize[0])
249                 value= clip->lastsize[0]*value/camera->sensor_width;
250
251         if(value>=0.0001)
252                 camera->focal= value;
253 }
254
255 static int rna_track_2d_stabilization(CollectionPropertyIterator *UNUSED(iter), void *data)
256 {
257         MovieTrackingTrack *track= (MovieTrackingTrack*)data;
258
259         if((track->flag&TRACK_USE_2D_STAB)==0)
260                 return 1;
261
262         return 0;
263 }
264
265 static void rna_tracking_stabTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
266 {
267         MovieClip *clip= (MovieClip*)ptr->id.data;
268         rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization);
269 }
270
271 static int rna_tracking_stabTracks_active_index_get(PointerRNA *ptr)
272 {
273         MovieClip *clip= (MovieClip*)ptr->id.data;
274         return clip->tracking.stabilization.act_track;
275 }
276
277 static void rna_tracking_stabTracks_active_index_set(PointerRNA *ptr, int value)
278 {
279         MovieClip *clip= (MovieClip*)ptr->id.data;
280         clip->tracking.stabilization.act_track= value;
281 }
282
283 static void rna_tracking_stabTracks_active_index_range(PointerRNA *ptr, int *min, int *max)
284 {
285         MovieClip *clip= (MovieClip*)ptr->id.data;
286
287         *min= 0;
288         *max= clip->tracking.stabilization.tot_track-1;
289         *max= MAX2(0, *max);
290 }
291
292 static void rna_tracking_flushUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
293 {
294         MovieClip *clip= (MovieClip*)ptr->id.data;
295         MovieTrackingStabilization *stab= &clip->tracking.stabilization;
296
297         stab->ok= 0;
298
299         nodeUpdateID(scene->nodetree, &clip->id);
300
301         WM_main_add_notifier(NC_SCENE|ND_NODES, NULL);
302         DAG_id_tag_update(&clip->id, 0);
303 }
304
305 static void rna_trackingObject_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
306 {
307         MovieTrackingObject *object= (MovieTrackingObject* )ptr->data;
308
309         if(object->flag&TRACKING_OBJECT_CAMERA) {
310                 MovieClip *clip= (MovieClip*)ptr->id.data;
311
312                 rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
313         }
314         else {
315                 rna_iterator_listbase_begin(iter, &object->tracks, NULL);
316         }
317 }
318
319 static PointerRNA rna_tracking_active_object_get(PointerRNA *ptr)
320 {
321         MovieClip *clip= (MovieClip*)ptr->id.data;
322         MovieTrackingObject *object= BLI_findlink(&clip->tracking.objects, clip->tracking.objectnr);
323
324         return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingObject, object);
325 }
326
327 static void rna_tracking_active_object_set(PointerRNA *ptr, PointerRNA value)
328 {
329         MovieClip *clip= (MovieClip*)ptr->id.data;
330         MovieTrackingObject *object= (MovieTrackingObject *)value.data;
331         int index= BLI_findindex(&clip->tracking.objects, object);
332
333         if(index>=0) clip->tracking.objectnr= index;
334         else clip->tracking.objectnr= 0;
335 }
336
337 void rna_trackingObject_name_set(PointerRNA *ptr, const char *value)
338 {
339         MovieClip *clip= (MovieClip *)ptr->id.data;
340         MovieTrackingObject *object= (MovieTrackingObject *)ptr->data;
341
342         BLI_strncpy(object->name, value, sizeof(object->name));
343
344         BKE_tracking_object_unique_name(&clip->tracking, object);
345 }
346
347 static void rna_trackingObject_flushUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
348 {
349         MovieClip *clip= (MovieClip*)ptr->id.data;
350
351         WM_main_add_notifier(NC_OBJECT|ND_TRANSFORM, NULL);
352         DAG_id_tag_update(&clip->id, 0);
353 }
354
355 static void rna_trackingMarker_frame_set(PointerRNA *ptr, int value)
356 {
357         MovieClip *clip = (MovieClip *) ptr->id.data;
358         MovieTracking *tracking = &clip->tracking;
359         MovieTrackingTrack *track;
360         MovieTrackingMarker *marker = (MovieTrackingMarker *) ptr->data;
361
362         track = tracking->tracks.first;
363         while (track) {
364                 if (marker >= track->markers && marker < track->markers+track->markersnr) {
365                         break;
366                 }
367
368                 track = track->next;
369         }
370
371         if (track) {
372                 MovieTrackingMarker new_marker = *marker;
373                 new_marker.framenr = value;
374
375                 BKE_tracking_delete_marker(track, marker->framenr);
376                 BKE_tracking_insert_marker(track, &new_marker);
377         }
378 }
379
380 /* API */
381
382 static void add_tracks_to_base(MovieClip *clip, MovieTracking *tracking, ListBase *tracksbase, int frame, int number)
383 {
384         int a, width, height;
385         MovieClipUser user= {0};
386
387         user.framenr= 1;
388
389         BKE_movieclip_get_size(clip, &user, &width, &height);
390
391         for(a= 0; a<number; a++)
392                 BKE_tracking_add_track(tracking, tracksbase, 0, 0, frame, width, height);
393 }
394
395 static void rna_trackingTracks_add(ID *id, MovieTracking *tracking, int frame, int number)
396 {
397         MovieClip *clip= (MovieClip *) id;
398
399         add_tracks_to_base(clip, tracking, &tracking->tracks, frame, number);
400
401         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, clip);
402 }
403
404 static void rna_trackingObject_tracks_add(ID *id, MovieTrackingObject *object, int frame, int number)
405 {
406         MovieClip *clip= (MovieClip *) id;
407         ListBase *tracksbase= &object->tracks;
408
409         if(object->flag&TRACKING_OBJECT_CAMERA)
410                 tracksbase= &clip->tracking.tracks;
411
412         add_tracks_to_base(clip, &clip->tracking, tracksbase, frame, number);
413
414         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
415 }
416
417 static MovieTrackingObject *rna_trackingObject_new(MovieTracking *tracking, const char *name)
418 {
419         MovieTrackingObject *object= BKE_tracking_new_object(tracking, name);
420
421         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
422
423         return object;
424 }
425
426 void rna_trackingObject_remove(MovieTracking *tracking, MovieTrackingObject *object)
427 {
428         BKE_tracking_remove_object(tracking, object);
429
430         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
431 }
432
433 static MovieTrackingMarker *rna_trackingMarkers_find_frame(MovieTrackingTrack *track, int framenr)
434 {
435         return BKE_tracking_exact_marker(track, framenr);
436 }
437
438 static MovieTrackingMarker* rna_trackingMarkers_insert_frame(MovieTrackingTrack *track, int framenr, float *co)
439 {
440         MovieTrackingMarker marker, *new_marker;
441
442         memset(&marker, 0, sizeof(marker));
443         marker.framenr = framenr;
444         copy_v2_v2(marker.pos, co);
445
446         new_marker = BKE_tracking_insert_marker(track, &marker);
447
448         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
449
450         return new_marker;
451 }
452
453 void rna_trackingMarkers_delete_frame(MovieTrackingTrack *track, int framenr)
454 {
455         if(track->markersnr==1)
456                 return;
457
458         BKE_tracking_delete_marker(track, framenr);
459
460         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
461 }
462
463 #else
464
465 static EnumPropertyItem tracker_items[] = {
466         {TRACKER_KLT, "KLT", 0, "KLT", "Kanade–Lucas–Tomasi tracker which works with most of video clips, a bit slower than SAD"},
467         {TRACKER_SAD, "SAD", 0, "SAD", "Sum of Absolute Differences tracker which can be used when KLT tracker fails"},
468         {TRACKER_HYBRID, "Hybrid", 0, "Hybrid", "A hybrid tracker that uses SAD for rough tracking, KLT for refinement."},
469         {0, NULL, 0, NULL, NULL}};
470
471 static EnumPropertyItem pattern_match_items[] = {
472         {TRACK_MATCH_KEYFRAME, "KEYFRAME", 0, "Keyframe", "Track pattern from keyframe to next frame"},
473         {TRACK_MATCH_PREVFRAME, "PREV_FRAME", 0, "Previous frame", "Track pattern from current frame to next frame"},
474         {0, NULL, 0, NULL, NULL}};
475
476 static int rna_matrix_dimsize_4x4[]= {4, 4};
477
478 static void rna_def_trackingSettings(BlenderRNA *brna)
479 {
480         StructRNA *srna;
481         PropertyRNA *prop;
482
483         static EnumPropertyItem speed_items[] = {
484                 {0, "FASTEST", 0, "Fastest", "Track as fast as it's possible"},
485             {TRACKING_SPEED_DOUBLE, "DOUBLE", 0, "Double", "Track with double speed"},
486                 {TRACKING_SPEED_REALTIME, "REALTIME", 0, "Realtime", "Track with realtime speed"},
487                 {TRACKING_SPEED_HALF, "HALF", 0, "Half", "Track with half of realtime speed"},
488                 {TRACKING_SPEED_QUARTER, "QUARTER", 0, "Quarter", "Track with quarter of realtime speed"},
489                 {0, NULL, 0, NULL, NULL}};
490
491         static EnumPropertyItem cleanup_items[] = {
492                 {TRACKING_CLEAN_SELECT, "SELECT", 0, "Select", "Select unclean tracks"},
493                 {TRACKING_CLEAN_DELETE_TRACK, "DELETE_TRACK", 0, "Delete Track", "Delete unclean tracks"},
494                 {TRACKING_CLEAN_DELETE_SEGMENT, "DELETE_SEGMENTS", 0, "Delete Segments", "Delete unclean segments of tracks"},
495                 {0, NULL, 0, NULL, NULL}
496         };
497
498         static EnumPropertyItem refine_items[] = {
499                 {0, "NONE", 0, "Nothing", "Do not refine camera intrinsics"},
500                 {REFINE_FOCAL_LENGTH, "FOCAL_LENGTH", 0, "Focal Length", "Refine focal length"},
501                 {REFINE_FOCAL_LENGTH|REFINE_RADIAL_DISTORTION_K1, "FOCAL_LENGTH_RADIAL_K1", 0, "Focal length, K1", "Refine focal length and radial distortion K1"},
502                 {REFINE_FOCAL_LENGTH|
503                  REFINE_RADIAL_DISTORTION_K1|
504                  REFINE_RADIAL_DISTORTION_K2, "FOCAL_LENGTH_RADIAL_K1_K2", 0, "Focal length, K1, K2", "Refine focal length and radial distortion K1 and K2"},
505                 {REFINE_FOCAL_LENGTH|
506                  REFINE_PRINCIPAL_POINT|
507                  REFINE_RADIAL_DISTORTION_K1|
508                  REFINE_RADIAL_DISTORTION_K2,
509                  "FOCAL_LENGTH_PRINCIPAL_POINT_RADIAL_K1_K2", 0, "Focal Length, Optical Center, K1, K2", "Refine focal length, optical center and radial distortion K1 and K2"},
510                 {REFINE_FOCAL_LENGTH|
511                  REFINE_PRINCIPAL_POINT, "FOCAL_LENGTH_PRINCIPAL_POINT", 0, "Focal Length, Optical Center", "Refine focal length and optical center"},
512                 {0, NULL, 0, NULL, NULL}
513         };
514
515         srna= RNA_def_struct(brna, "MovieTrackingSettings", NULL);
516         RNA_def_struct_ui_text(srna, "Movie tracking settings", "Match moving settings");
517
518         /* speed */
519         prop= RNA_def_property(srna, "speed", PROP_ENUM, PROP_NONE);
520         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
521         RNA_def_property_enum_items(prop, speed_items);
522         RNA_def_property_ui_text(prop, "Speed", "Limit speed of tracking to make visual feedback easier (this does not affect the tracking quality)");
523
524         /* keyframe_a */
525         prop= RNA_def_property(srna, "keyframe_a", PROP_INT, PROP_NONE);
526         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
527         RNA_def_property_int_sdna(prop, NULL, "keyframe1");
528         RNA_def_property_ui_text(prop, "Keyframe A", "First keyframe used for reconstruction initialization");
529
530         /* keyframe_b */
531         prop= RNA_def_property(srna, "keyframe_b", PROP_INT, PROP_NONE);
532         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
533         RNA_def_property_int_sdna(prop, NULL, "keyframe2");
534         RNA_def_property_ui_text(prop, "Keyframe B", "Second keyframe used for reconstruction initialization");
535
536         /* intrinsics refinement during bundle adjustment */
537         prop= RNA_def_property(srna, "refine_intrinsics", PROP_ENUM, PROP_NONE);
538         RNA_def_property_enum_sdna(prop, NULL, "refine_camera_intrinsics");
539         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
540         RNA_def_property_enum_items(prop, refine_items);
541         RNA_def_property_ui_text(prop, "Refine", "Refine intrinsics during camera solving");
542
543         /* tool settings */
544
545         /* distance */
546         prop= RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
547         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
548         RNA_def_property_float_sdna(prop, NULL, "dist");
549         RNA_def_property_float_default(prop, 1.0f);
550         RNA_def_property_ui_text(prop, "Distance", "Distance between two bundles used for scene scaling");
551
552         /* frames count */
553         prop= RNA_def_property(srna, "clean_frames", PROP_INT, PROP_NONE);
554         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
555         RNA_def_property_int_sdna(prop, NULL, "clean_frames");
556         RNA_def_property_range(prop, 0, INT_MAX);
557         RNA_def_property_ui_text(prop, "Tracked Frames", "Effect on tracks which are tracked less than the specified amount of frames");
558
559         /* reprojection error */
560         prop= RNA_def_property(srna, "clean_error", PROP_FLOAT, PROP_NONE);
561         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
562         RNA_def_property_float_sdna(prop, NULL, "clean_error");
563         RNA_def_property_range(prop, 0, FLT_MAX);
564         RNA_def_property_ui_text(prop, "Reprojection Error", "Effect on tracks which have a larger reprojection error");
565
566         /* cleanup action */
567         prop= RNA_def_property(srna, "clean_action", PROP_ENUM, PROP_NONE);
568         RNA_def_property_enum_sdna(prop, NULL, "clean_action");
569         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
570         RNA_def_property_enum_items(prop, cleanup_items);
571         RNA_def_property_ui_text(prop, "Action", "Cleanup action to execute");
572
573         /* ** default tracker settings ** */
574         prop= RNA_def_property(srna, "show_default_expanded", PROP_BOOLEAN, PROP_NONE);
575         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
576         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_SETTINGS_SHOW_DEFAULT_EXPANDED);
577         RNA_def_property_ui_text(prop, "Show Expanded", "Show the expanded in the user interface");
578         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
579
580         /* limit frames */
581         prop= RNA_def_property(srna, "default_frames_limit", PROP_INT, PROP_NONE);
582         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
583         RNA_def_property_int_sdna(prop, NULL, "default_frames_limit");
584         RNA_def_property_range(prop, 0, SHRT_MAX);
585         RNA_def_property_ui_text(prop, "Frames Limit", "Every tracking cycle, this number of frames are tracked");
586
587         /* pattern match */
588         prop= RNA_def_property(srna, "default_pattern_match", PROP_ENUM, PROP_NONE);
589         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
590         RNA_def_property_enum_sdna(prop, NULL, "default_pattern_match");
591         RNA_def_property_enum_items(prop, pattern_match_items);
592         RNA_def_property_ui_text(prop, "Pattern Match", "Track pattern from given frame when tracking marker to next frame");
593
594         /* margin */
595         prop= RNA_def_property(srna, "default_margin", PROP_INT, PROP_NONE);
596         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
597         RNA_def_property_int_sdna(prop, NULL, "default_margin");
598         RNA_def_property_range(prop, 0, 300);
599         RNA_def_property_ui_text(prop, "Margin", "Default distance from image boudary at which marker stops tracking");
600
601         /* tracking algorithm */
602         prop= RNA_def_property(srna, "default_tracker", PROP_ENUM, PROP_NONE);
603         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
604         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
605         RNA_def_property_enum_items(prop, tracker_items);
606         RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_levelsUpdate");
607         RNA_def_property_ui_text(prop, "Tracker", "Default tracking algorithm to use");
608
609         /* pyramid level for pyramid klt tracking */
610         prop= RNA_def_property(srna, "default_pyramid_levels", PROP_INT, PROP_NONE);
611         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
612         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
613         RNA_def_property_int_sdna(prop, NULL, "default_pyramid_levels");
614         RNA_def_property_range(prop, 1, 16);
615         RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_levelsUpdate");
616         RNA_def_property_ui_text(prop, "Pyramid levels", "Default number of pyramid levels (increase on blurry footage)");
617
618         /* minmal correlation - only used for SAD tracker */
619         prop= RNA_def_property(srna, "default_correlation_min", PROP_FLOAT, PROP_NONE);
620         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
621         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
622         RNA_def_property_float_sdna(prop, NULL, "default_minimum_correlation");
623         RNA_def_property_range(prop, -1.0f, 1.0f);
624         RNA_def_property_ui_range(prop, -1.0f, 1.0f, 0.1, 3);
625         RNA_def_property_ui_text(prop, "Correlation", "Default minimal value of correlation between matched pattern and reference which is still treated as successful tracking");
626
627         /* default pattern size */
628         prop= RNA_def_property(srna, "default_pattern_size", PROP_INT, PROP_NONE);
629         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
630         RNA_def_property_int_sdna(prop, NULL, "default_pattern_size");
631         RNA_def_property_range(prop, 5, 1000);
632         RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_patternUpdate");
633         RNA_def_property_ui_text(prop, "Pattern Size", "Size of pattern area for newly created tracks");
634
635         /* default search size */
636         prop= RNA_def_property(srna, "default_search_size", PROP_INT, PROP_NONE);
637         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
638         RNA_def_property_int_sdna(prop, NULL, "default_search_size");
639         RNA_def_property_range(prop, 5, 1000);
640         RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_searchUpdate");
641         RNA_def_property_ui_text(prop, "Search Size", "Size of search area for newly created tracks");
642
643         /* use_red_channel */
644         prop= RNA_def_property(srna, "use_default_red_channel", PROP_BOOLEAN, PROP_NONE);
645         RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_RED);
646         RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
647         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
648
649         /* use_green_channel */
650         prop= RNA_def_property(srna, "use_default_green_channel", PROP_BOOLEAN, PROP_NONE);
651         RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_GREEN);
652         RNA_def_property_ui_text(prop, "Use Green Channel", "Use green channel from footage for tracking");
653         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
654
655         /* use_blue_channel */
656         prop= RNA_def_property(srna, "use_default_blue_channel", PROP_BOOLEAN, PROP_NONE);
657         RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_BLUE);
658         RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
659         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
660
661         /* ** object tracking ** */
662
663         /* object distance */
664         prop= RNA_def_property(srna, "object_distance", PROP_FLOAT, PROP_NONE);
665         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
666         RNA_def_property_float_sdna(prop, NULL, "object_distance");
667         RNA_def_property_ui_text(prop, "Distance", "Distance between two bundles used for object scaling");
668         RNA_def_property_range(prop, 0.001, 10000);
669         RNA_def_property_float_default(prop, 1.0f);
670         RNA_def_property_ui_range(prop, 0.001, 10000.0, 1, 3);
671 }
672
673 static void rna_def_trackingCamera(BlenderRNA *brna)
674 {
675         StructRNA *srna;
676         PropertyRNA *prop;
677
678         static EnumPropertyItem camera_units_items[] = {
679                 {CAMERA_UNITS_PX, "PIXELS", 0, "px", "Use pixels for units of focal length"},
680                 {CAMERA_UNITS_MM, "MILLIMETERS", 0, "mm", "Use millimeters for units of focal length"},
681                 {0, NULL, 0, NULL, NULL}};
682
683         srna= RNA_def_struct(brna, "MovieTrackingCamera", NULL);
684         RNA_def_struct_ui_text(srna, "Movie tracking camera data", "Match-moving camera data for tracking");
685
686         /* Sensor */
687         prop= RNA_def_property(srna, "sensor_width", PROP_FLOAT, PROP_NONE);
688         RNA_def_property_float_sdna(prop, NULL, "sensor_width");
689         RNA_def_property_range(prop, 0.0f, 500.0f);
690         RNA_def_property_ui_text(prop, "Sensor", "Width of CCD sensor in millimeters");
691         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
692
693         /* Focal Length */
694         prop= RNA_def_property(srna, "focal_length", PROP_FLOAT, PROP_NONE);
695         RNA_def_property_float_sdna(prop, NULL, "focal");
696         RNA_def_property_range(prop, 0.0001f, 5000.0f);
697         RNA_def_property_float_funcs(prop, "rna_trackingCamera_focal_mm_get", "rna_trackingCamera_focal_mm_set", NULL);
698         RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
699         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
700
701         /* Focal Length in pixels */
702         prop= RNA_def_property(srna, "focal_length_pixels", PROP_FLOAT, PROP_NONE);
703         RNA_def_property_float_sdna(prop, NULL, "focal");
704         RNA_def_property_range(prop, 0.0f, 5000.0f);
705         RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
706         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
707
708         /* Units */
709         prop= RNA_def_property(srna, "units", PROP_ENUM, PROP_NONE);
710         RNA_def_property_enum_sdna(prop, NULL, "units");
711         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
712         RNA_def_property_enum_items(prop, camera_units_items);
713         RNA_def_property_ui_text(prop, "Units", "Units used for camera focal length");
714
715         /* Principal Point */
716         prop= RNA_def_property(srna, "principal", PROP_FLOAT, PROP_NONE);
717         RNA_def_property_array(prop, 2);
718         RNA_def_property_float_sdna(prop, NULL, "principal");
719         RNA_def_property_ui_text(prop, "Principal Point", "Optical center of lens");
720         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
721
722         /* Radial distortion parameters */
723         prop= RNA_def_property(srna, "k1", PROP_FLOAT, PROP_NONE);
724         RNA_def_property_float_sdna(prop, NULL, "k1");
725         RNA_def_property_ui_range(prop, -10, 10, .1, 3);
726         RNA_def_property_ui_text(prop, "K1", "First coefficient of third order polynomial radial distortion");
727         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
728
729         prop= RNA_def_property(srna, "k2", PROP_FLOAT, PROP_NONE);
730         RNA_def_property_float_sdna(prop, NULL, "k2");
731         RNA_def_property_ui_range(prop, -10, 10, .1, 3);
732         RNA_def_property_ui_text(prop, "K2", "Second coefficient of third order polynomial radial distortion");
733         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
734
735         prop= RNA_def_property(srna, "k3", PROP_FLOAT, PROP_NONE);
736         RNA_def_property_float_sdna(prop, NULL, "k3");
737         RNA_def_property_ui_range(prop, -10, 10, .1, 3);
738         RNA_def_property_ui_text(prop, "K3", "Third coefficient of third order polynomial radial distortion");
739         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
740
741         /* pixel aspect */
742         prop= RNA_def_property(srna, "pixel_aspect", PROP_FLOAT, PROP_XYZ);
743         RNA_def_property_float_sdna(prop, NULL, "pixel_aspect");
744         RNA_def_property_range(prop, 0.1f, 5000.0f);
745         RNA_def_property_ui_range(prop, 0.1f, 5000.0f, 1, 2);
746         RNA_def_property_ui_text(prop, "Pixel Aspect Ratio", "Pixel aspect ratio");
747         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
748 }
749
750 static void rna_def_trackingMarker(BlenderRNA *brna)
751 {
752         StructRNA *srna;
753         PropertyRNA *prop;
754
755         srna= RNA_def_struct(brna, "MovieTrackingMarker", NULL);
756         RNA_def_struct_ui_text(srna, "Movie tracking marker data", "Match-moving marker data for tracking");
757
758         /* position */
759         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
760         RNA_def_property_array(prop, 2);
761         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 5);
762         RNA_def_property_float_sdna(prop, NULL, "pos");
763         RNA_def_property_ui_text(prop, "Position", "Marker position at frame in normalized coordinates");
764         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
765
766         /* frame */
767         prop= RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
768         RNA_def_property_int_sdna(prop, NULL, "framenr");
769         RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
770         RNA_def_property_int_funcs(prop, NULL, "rna_trackingMarker_frame_set", NULL);
771         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, 0);
772
773         /* enable */
774         prop= RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
775         RNA_def_property_boolean_sdna(prop, NULL, "flag", MARKER_DISABLED);
776         RNA_def_property_ui_text(prop, "Mode", "Is marker muted for current frame");
777         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
778 }
779
780 static void rna_def_trackingMarkers(BlenderRNA *brna, PropertyRNA *cprop)
781 {
782         StructRNA *srna;
783         FunctionRNA *func;
784         PropertyRNA *parm;
785
786         RNA_def_property_srna(cprop, "MovieTrackingMarkers");
787         srna= RNA_def_struct(brna, "MovieTrackingMarkers", NULL);
788         RNA_def_struct_sdna(srna, "MovieTrackingTrack");
789         RNA_def_struct_ui_text(srna, "Movie Tracking Markers", "Collection of markers for movie tracking track");
790
791         func= RNA_def_function(srna, "find_frame", "rna_trackingMarkers_find_frame");
792         RNA_def_function_ui_description(func, "Get marker for specified frame");
793         parm= RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
794                          "Frame number to find marker for", MINFRAME, MAXFRAME);
795         RNA_def_property_flag(parm, PROP_REQUIRED);
796         parm= RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Marker for specified frame");
797         RNA_def_function_return(func, parm);
798
799         func= RNA_def_function(srna, "insert_frame", "rna_trackingMarkers_insert_frame");
800         RNA_def_function_ui_description(func, "Add a number of tracks to this movie clip");
801         parm= RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
802                         "Frame number to insert marker to", MINFRAME, MAXFRAME);
803         RNA_def_property_flag(parm, PROP_REQUIRED);
804         RNA_def_float_vector(func, "co", 2, 0, -1.0, 1.0, "Coordinate",
805                         "Place new marker at the given frame using specified in normalized space coordinates", -1.0, 1.0);
806         RNA_def_property_flag(parm, PROP_REQUIRED);
807         parm= RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Newly created marker");
808         RNA_def_function_return(func, parm);
809
810         func= RNA_def_function(srna, "delete_frame", "rna_trackingMarkers_delete_frame");
811         RNA_def_function_ui_description(func, "Delete marker at specified frame");
812         parm= RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
813                         "Frame number to delete marker from", MINFRAME, MAXFRAME);
814         RNA_def_property_flag(parm, PROP_REQUIRED);
815 }
816
817 static void rna_def_trackingTrack(BlenderRNA *brna)
818 {
819         StructRNA *srna;
820         PropertyRNA *prop;
821
822         rna_def_trackingMarker(brna);
823
824         srna= RNA_def_struct(brna, "MovieTrackingTrack", NULL);
825         RNA_def_struct_ui_text(srna, "Movie tracking track data", "Match-moving track data for tracking");
826         RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
827
828         /* name */
829         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
830         RNA_def_property_ui_text(prop, "Name", "Unique name of track");
831         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingTrack_name_set");
832         RNA_def_property_string_maxlength(prop, MAX_ID_NAME-2);
833         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
834         RNA_def_struct_name_property(srna, prop);
835
836         /* Pattern */
837         prop= RNA_def_property(srna, "pattern_min", PROP_FLOAT, PROP_TRANSLATION);
838         RNA_def_property_array(prop, 2);
839         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 5);
840         RNA_def_property_float_sdna(prop, NULL, "pat_min");
841         RNA_def_property_ui_text(prop, "Pattern Min", "Left-bottom corner of pattern area in normalized coordinates relative to marker position");
842         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPattern_update");
843
844         prop= RNA_def_property(srna, "pattern_max", PROP_FLOAT, PROP_TRANSLATION);
845         RNA_def_property_array(prop, 2);
846         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 5);
847         RNA_def_property_float_sdna(prop, NULL, "pat_max");
848         RNA_def_property_ui_text(prop, "Pattern Max", "Right-bottom corner of pattern area in normalized coordinates relative to marker position");
849         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPattern_update");
850
851         /* Search */
852         prop= RNA_def_property(srna, "search_min", PROP_FLOAT, PROP_TRANSLATION);
853         RNA_def_property_array(prop, 2);
854         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 5);
855         RNA_def_property_float_sdna(prop, NULL, "search_min");
856         RNA_def_property_ui_text(prop, "Search Min", "Left-bottom corner of search area in normalized coordinates relative to marker position");
857         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerSearch_update");
858
859         prop= RNA_def_property(srna, "search_max", PROP_FLOAT, PROP_TRANSLATION);
860         RNA_def_property_array(prop, 2);
861         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 5);
862         RNA_def_property_float_sdna(prop, NULL, "search_max");
863         RNA_def_property_ui_text(prop, "Search Max", "Right-bottom corner of search area in normalized coordinates relative to marker position");
864         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerSearch_update");
865
866         /* limit frames */
867         prop= RNA_def_property(srna, "frames_limit", PROP_INT, PROP_NONE);
868         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
869         RNA_def_property_int_sdna(prop, NULL, "frames_limit");
870         RNA_def_property_range(prop, 0, SHRT_MAX);
871         RNA_def_property_ui_text(prop, "Frames Limit", "Every tracking cycle, this number of frames are tracked");
872
873         /* pattern match */
874         prop= RNA_def_property(srna, "pattern_match", PROP_ENUM, PROP_NONE);
875         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
876         RNA_def_property_enum_sdna(prop, NULL, "pattern_match");
877         RNA_def_property_enum_items(prop, pattern_match_items);
878         RNA_def_property_ui_text(prop, "Pattern Match", "Track pattern from given frame when tracking marker to next frame");
879
880         /* margin */
881         prop= RNA_def_property(srna, "margin", PROP_INT, PROP_NONE);
882         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
883         RNA_def_property_int_sdna(prop, NULL, "margin");
884         RNA_def_property_range(prop, 0, 300);
885         RNA_def_property_ui_text(prop, "Margin", "Distance from image boudary at which marker stops tracking");
886
887         /* tracking algorithm */
888         prop= RNA_def_property(srna, "tracker", PROP_ENUM, PROP_NONE);
889         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
890         RNA_def_property_enum_items(prop, tracker_items);
891         RNA_def_property_ui_text(prop, "Tracker", "Tracking algorithm to use");
892         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerAlgorithm_update");
893
894         /* pyramid level for pyramid klt tracking */
895         prop= RNA_def_property(srna, "pyramid_levels", PROP_INT, PROP_NONE);
896         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
897         RNA_def_property_int_sdna(prop, NULL, "pyramid_levels");
898         RNA_def_property_range(prop, 1, 16);
899         RNA_def_property_ui_text(prop, "Pyramid levels", "Number of pyramid levels (increase on blurry footage)");
900         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPyramid_update");
901
902         /* minmal correlation - only used for SAD tracker */
903         prop= RNA_def_property(srna, "correlation_min", PROP_FLOAT, PROP_NONE);
904         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
905         RNA_def_property_float_sdna(prop, NULL, "minimum_correlation");
906         RNA_def_property_range(prop, -1.0f, 1.0f);
907         RNA_def_property_ui_range(prop, -1.0f, 1.0f, 0.1, 3);
908         RNA_def_property_ui_text(prop, "Correlation", "Minimal value of correlation between matched pattern and reference which is still treated as successful tracking");
909
910         /* markers */
911         prop= RNA_def_property(srna, "markers", PROP_COLLECTION, PROP_NONE);
912         RNA_def_property_struct_type(prop, "MovieTrackingMarker");
913         RNA_def_property_collection_sdna(prop, NULL, "markers", "markersnr");
914         RNA_def_property_ui_text(prop, "Markers", "Collection of markers in track");
915         rna_def_trackingMarkers(brna, prop);
916
917         /* ** channels ** */
918
919         /* use_red_channel */
920         prop= RNA_def_property(srna, "use_red_channel", PROP_BOOLEAN, PROP_NONE);
921         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_RED);
922         RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
923         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
924
925         /* use_green_channel */
926         prop= RNA_def_property(srna, "use_green_channel", PROP_BOOLEAN, PROP_NONE);
927         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_GREEN);
928         RNA_def_property_ui_text(prop, "Use Green Channel", "Use green channel from footage for tracking");
929         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
930
931         /* use_blue_channel */
932         prop= RNA_def_property(srna, "use_blue_channel", PROP_BOOLEAN, PROP_NONE);
933         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_BLUE);
934         RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
935         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
936
937         /* preview_grayscale */
938         prop= RNA_def_property(srna, "use_grayscale_preview", PROP_BOOLEAN, PROP_NONE);
939         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_PREVIEW_GRAYSCALE);
940         RNA_def_property_ui_text(prop, "Grayscale", "Display what the tracking algorithm sees in the preview");
941         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
942
943         /* has bundle */
944         prop= RNA_def_property(srna, "has_bundle", PROP_BOOLEAN, PROP_NONE);
945         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_HAS_BUNDLE);
946         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
947         RNA_def_property_ui_text(prop, "Has Bundle", "True if track has a valid bundle");
948
949         /* bundle position */
950         prop= RNA_def_property(srna, "bundle", PROP_FLOAT, PROP_TRANSLATION);
951         RNA_def_property_array(prop, 3);
952         RNA_def_property_float_sdna(prop, NULL, "bundle_pos");
953         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
954         RNA_def_property_ui_text(prop, "Bundle", "Position of bundle reconstructed from this track");
955
956         /* hide */
957         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
958         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_HIDDEN);
959         RNA_def_property_ui_text(prop, "Hide", "Track is hidden");
960         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
961
962         /* select */
963         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
964         RNA_def_property_boolean_funcs(prop, "rna_trackingTrack_select_get", "rna_trackingTrack_select_set");
965         RNA_def_property_ui_text(prop, "Select", "Track is selected");
966         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
967
968         /* select_anchor */
969         prop= RNA_def_property(srna, "select_anchor", PROP_BOOLEAN, PROP_NONE);
970         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
971         RNA_def_property_ui_text(prop, "Select Anchor", "Track's anchor point is selected");
972         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
973
974         /* select_pattern */
975         prop= RNA_def_property(srna, "select_pattern", PROP_BOOLEAN, PROP_NONE);
976         RNA_def_property_boolean_sdna(prop, NULL, "pat_flag", SELECT);
977         RNA_def_property_ui_text(prop, "Select Pattern", "Track's pattern area is selected");
978         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
979
980         /* select_search */
981         prop= RNA_def_property(srna, "select_search", PROP_BOOLEAN, PROP_NONE);
982         RNA_def_property_boolean_sdna(prop, NULL, "search_flag", SELECT);
983         RNA_def_property_ui_text(prop, "Select Search", "Track's search area is selected");
984         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
985
986         /* locked */
987         prop= RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
988         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_LOCKED);
989         RNA_def_property_ui_text(prop, "Lock", "Track is locked and all changes to it are disabled");
990         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
991
992         /* custom color */
993         prop= RNA_def_property(srna, "use_custom_color", PROP_BOOLEAN, PROP_NONE);
994         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_CUSTOMCOLOR);
995         RNA_def_property_ui_text(prop, "Custom Color", "Use custom color instead of theme-defined");
996         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
997
998         /* color */
999         prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
1000         RNA_def_property_array(prop, 3);
1001         RNA_def_property_range(prop, 0.0f, 1.0f);
1002         RNA_def_property_ui_text(prop, "Color", "Color of the track in the Movie Track Editor and the 3D viewport after a solve");
1003         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1004
1005         /* average error */
1006         prop= RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1007         RNA_def_property_float_sdna(prop, NULL, "error");
1008         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1009         RNA_def_property_ui_text(prop, "Average Error", "Average error of re-projection");
1010 }
1011
1012 static void rna_def_trackingStabilization(BlenderRNA *brna)
1013 {
1014         StructRNA *srna;
1015         PropertyRNA *prop;
1016
1017         srna= RNA_def_struct(brna, "MovieTrackingStabilization", NULL);
1018         RNA_def_struct_ui_text(srna, "Movie tracking stabilization data", "Match-moving stabilization data for tracking");
1019
1020         /* 2d stabilization */
1021         prop= RNA_def_property(srna, "use_2d_stabilization", PROP_BOOLEAN, PROP_NONE);
1022         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_2D_STABILIZATION);
1023         RNA_def_property_ui_text(prop, "Use 2D stabilization", "Use 2D stabilization for footage");
1024         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1025
1026         /* tracks */
1027         prop= RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1028         RNA_def_property_collection_funcs(prop, "rna_tracking_stabTracks_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
1029         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1030         RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks used for stabilization");
1031         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1032
1033         /* rotation track */
1034         prop= RNA_def_property(srna, "rotation_track", PROP_POINTER, PROP_NONE);
1035         RNA_def_property_pointer_sdna(prop, NULL, "rot_track");
1036         RNA_def_property_flag(prop, PROP_EDITABLE);
1037         RNA_def_property_ui_text(prop, "Rotation Track", "Track used to compensate rotation");
1038         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
1039
1040         /* active track index */
1041         prop= RNA_def_property(srna, "active_track_index", PROP_INT, PROP_NONE);
1042         RNA_def_property_int_sdna(prop, NULL, "act_track");
1043         RNA_def_property_int_funcs(prop, "rna_tracking_stabTracks_active_index_get", "rna_tracking_stabTracks_active_index_set", "rna_tracking_stabTracks_active_index_range");
1044         RNA_def_property_ui_text(prop, "Active Track Index", "Index of active track in stabilization tracks list");
1045
1046         /* autoscale */
1047         prop= RNA_def_property(srna, "use_autoscale", PROP_BOOLEAN, PROP_NONE);
1048         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_AUTOSCALE);
1049         RNA_def_property_ui_text(prop, "Autoscale", "Automatically scale footage to cover unfilled areas when stabilizating");
1050         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1051
1052         /* max scale */
1053         prop= RNA_def_property(srna, "scale_max", PROP_FLOAT, PROP_FACTOR);
1054         RNA_def_property_float_sdna(prop, NULL, "maxscale");
1055         RNA_def_property_range(prop, 0.0f, 10.0f);
1056         RNA_def_property_ui_text(prop, "Maximal Scale", "Limit the amount of automatic scaling");
1057         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1058
1059         /* influence_location */
1060         prop= RNA_def_property(srna, "influence_location", PROP_FLOAT, PROP_FACTOR);
1061         RNA_def_property_float_sdna(prop, NULL, "locinf");
1062         RNA_def_property_range(prop, 0.0f, 1.0f);
1063         RNA_def_property_ui_text(prop, "Location Influence", "Influence of stabilization algorithm on footage location");
1064         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1065
1066         /* influence_scale */
1067         prop= RNA_def_property(srna, "influence_scale", PROP_FLOAT, PROP_FACTOR);
1068         RNA_def_property_float_sdna(prop, NULL, "scaleinf");
1069         RNA_def_property_range(prop, 0.0f, 1.0f);
1070         RNA_def_property_ui_text(prop, "Scale Influence", "Influence of stabilization algorithm on footage scale");
1071         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1072
1073         /* use_stabilize_rotation */
1074         prop= RNA_def_property(srna, "use_stabilize_rotation", PROP_BOOLEAN, PROP_NONE);
1075         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_STABILIZE_ROTATION);
1076         RNA_def_property_ui_text(prop, "Stabilize Rotation", "Stabilize horizon line on the shot");
1077         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1078
1079         /* influence_rotation */
1080         prop= RNA_def_property(srna, "influence_rotation", PROP_FLOAT, PROP_FACTOR);
1081         RNA_def_property_float_sdna(prop, NULL, "rotinf");
1082         RNA_def_property_range(prop, 0.0f, 1.0f);
1083         RNA_def_property_ui_text(prop, "Rotation Influence", "Influence of stabilization algorithm on footage rotation");
1084         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1085 }
1086
1087 static void rna_def_reconstructedCamera(BlenderRNA *brna)
1088 {
1089         StructRNA *srna;
1090         PropertyRNA *prop;
1091
1092         srna= RNA_def_struct(brna, "MovieReconstructedCamera", NULL);
1093         RNA_def_struct_ui_text(srna, "Movie tracking reconstructed camera data", "Match-moving reconstructed camera data from tracker");
1094
1095         /* frame */
1096         prop= RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
1097         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1098         RNA_def_property_int_sdna(prop, NULL, "framenr");
1099         RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
1100
1101         /* matrix */
1102         prop= RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
1103         RNA_def_property_float_sdna(prop, NULL, "mat");
1104         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1105         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1106         RNA_def_property_ui_text(prop, "Matrix", "Worldspace transformation matrix");
1107
1108         /* average_error */
1109         prop= RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1110         RNA_def_property_float_sdna(prop, NULL, "error");
1111         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1112         RNA_def_property_ui_text(prop, "Average Error", "Average error of resonctruction");
1113 }
1114
1115 static void rna_def_trackingReconstruction(BlenderRNA *brna)
1116 {
1117         StructRNA *srna;
1118         PropertyRNA *prop;
1119
1120         rna_def_reconstructedCamera(brna);
1121
1122         srna= RNA_def_struct(brna, "MovieTrackingReconstruction", NULL);
1123         RNA_def_struct_ui_text(srna, "Movie tracking reconstruction data", "Match-moving reconstruction data from tracker");
1124
1125         /* is_valid */
1126         prop= RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
1127         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1128         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_RECONSTRUCTED);
1129         RNA_def_property_ui_text(prop, "Reconstructed", "Is tracking data contains valid reconstruction information");
1130
1131         /* average_error */
1132         prop= RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1133         RNA_def_property_float_sdna(prop, NULL, "error");
1134         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1135         RNA_def_property_ui_text(prop, "Average Error", "Average error of resonctruction");
1136
1137         /* cameras */
1138         prop= RNA_def_property(srna, "cameras", PROP_COLLECTION, PROP_NONE);
1139         RNA_def_property_struct_type(prop, "MovieReconstructedCamera");
1140         RNA_def_property_collection_sdna(prop, NULL, "cameras", "camnr");
1141         RNA_def_property_ui_text(prop, "Cameras", "Collection of solved cameras");
1142 }
1143
1144 static void rna_def_trackingTracks(BlenderRNA *brna)
1145 {
1146         StructRNA *srna;
1147         FunctionRNA *func;
1148         PropertyRNA *prop;
1149
1150         srna= RNA_def_struct(brna, "MovieTrackingTracks", NULL);
1151         RNA_def_struct_sdna(srna, "MovieTracking");
1152         RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
1153
1154         func= RNA_def_function(srna, "add", "rna_trackingTracks_add");
1155         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1156         RNA_def_function_ui_description(func, "Add a number of tracks to this movie clip");
1157         RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to add tracks on", MINFRAME, MAXFRAME);
1158         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of tracks to add to the movie clip", 0, INT_MAX);
1159
1160         /* active track */
1161         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1162         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1163         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", NULL, NULL);
1164         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
1165         RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
1166 }
1167
1168 static void rna_def_trackingObjectTracks(BlenderRNA *brna)
1169 {
1170         StructRNA *srna;
1171         FunctionRNA *func;
1172         PropertyRNA *prop;
1173
1174         srna= RNA_def_struct(brna, "MovieTrackingObjectTracks", NULL);
1175         RNA_def_struct_sdna(srna, "MovieTrackingObject");
1176         RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
1177
1178         func= RNA_def_function(srna, "add", "rna_trackingObject_tracks_add");
1179         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1180         RNA_def_function_ui_description(func, "Add a number of tracks to this movie clip");
1181         RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to add tracks on", MINFRAME, MAXFRAME);
1182         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of tracks to add to the movie clip", 0, INT_MAX);
1183
1184         /* active track */
1185         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1186         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1187         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", NULL, NULL);
1188         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
1189         RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
1190 }
1191
1192 static void rna_def_trackingObject(BlenderRNA *brna)
1193 {
1194         StructRNA *srna;
1195         PropertyRNA *prop;
1196
1197         srna= RNA_def_struct(brna, "MovieTrackingObject", NULL);
1198         RNA_def_struct_ui_text(srna, "Movie tracking object data", "Match-moving object tracking and reconstruction data");
1199
1200         /* name */
1201         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1202         RNA_def_property_ui_text(prop, "Name", "Unique name of object");
1203         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingObject_name_set");
1204         RNA_def_property_string_maxlength(prop, MAX_ID_NAME-2);
1205         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
1206         RNA_def_struct_name_property(srna, prop);
1207
1208         /* is_camera */
1209         prop= RNA_def_property(srna, "is_camera", PROP_BOOLEAN, PROP_NONE);
1210         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1211         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_OBJECT_CAMERA);
1212         RNA_def_property_ui_text(prop, "Camera", "Object is used for camera tracking");
1213         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1214
1215         /* tracks */
1216         prop= RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1217         RNA_def_property_collection_funcs(prop, "rna_trackingObject_tracks_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
1218         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1219         RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks in this tracking data object");
1220         RNA_def_property_srna(prop, "MovieTrackingObjectTracks");
1221
1222         /* reconstruction */
1223         prop= RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
1224         RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
1225
1226         /* scale */
1227         prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
1228         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1229         RNA_def_property_float_sdna(prop, NULL, "scale");
1230         RNA_def_property_range(prop, 0.0001f, 10000.0f);
1231         RNA_def_property_ui_range(prop, 0.0001f, 10000.0, 1, 4);
1232         RNA_def_property_float_default(prop, 1.0f);
1233         RNA_def_property_ui_text(prop, "Scale", "Scale of object solution in camera space");
1234         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_trackingObject_flushUpdate");
1235 }
1236
1237 static void rna_def_trackingObjects(BlenderRNA *brna, PropertyRNA *cprop)
1238 {
1239         StructRNA *srna;
1240         PropertyRNA *prop;
1241
1242         FunctionRNA *func;
1243         PropertyRNA *parm;
1244
1245         RNA_def_property_srna(cprop, "MovieTrackingObjects");
1246         srna= RNA_def_struct(brna, "MovieTrackingObjects", NULL);
1247         RNA_def_struct_sdna(srna, "MovieTracking");
1248         RNA_def_struct_ui_text(srna, "Movie Objects", "Collection of movie trackingobjects");
1249
1250         func= RNA_def_function(srna, "new", "rna_trackingObject_new");
1251         RNA_def_function_ui_description(func, "Add tracking object to this movie clip");
1252         RNA_def_string(func, "name", "", 0, "", "Name of new object");
1253         parm= RNA_def_pointer(func, "object", "MovieTrackingObject", "", "New motion tracking object");
1254         RNA_def_function_return(func, parm);
1255
1256         func= RNA_def_function(srna, "remove", "rna_trackingObject_remove");
1257         RNA_def_function_ui_description(func, "Remove tracking object from this movie clip");
1258         RNA_def_pointer(func, "object", "MovieTrackingObject", "", "Motion tracking object to be removed");
1259
1260         /* active object */
1261         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1262         RNA_def_property_struct_type(prop, "MovieTrackingObject");
1263         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_object_get", "rna_tracking_active_object_set", NULL, NULL);
1264         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
1265         RNA_def_property_ui_text(prop, "Active Object", "Active object in this tracking data object");
1266 }
1267
1268 static void rna_def_tracking(BlenderRNA *brna)
1269 {
1270         StructRNA *srna;
1271         PropertyRNA *prop;
1272
1273         rna_def_trackingSettings(brna);
1274         rna_def_trackingCamera(brna);
1275         rna_def_trackingTrack(brna);
1276         rna_def_trackingTracks(brna);
1277         rna_def_trackingObjectTracks(brna);
1278         rna_def_trackingStabilization(brna);
1279         rna_def_trackingReconstruction(brna);
1280         rna_def_trackingObject(brna);
1281
1282         srna= RNA_def_struct(brna, "MovieTracking", NULL);
1283         RNA_def_struct_ui_text(srna, "Movie tracking data", "Match-moving data for tracking");
1284
1285         /* settings */
1286         prop= RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
1287         RNA_def_property_struct_type(prop, "MovieTrackingSettings");
1288
1289         /* camera properties */
1290         prop= RNA_def_property(srna, "camera", PROP_POINTER, PROP_NONE);
1291         RNA_def_property_struct_type(prop, "MovieTrackingCamera");
1292
1293         /* tracks */
1294         prop= RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1295         RNA_def_property_collection_funcs(prop, "rna_trackingTracks_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
1296         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1297         RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks in this tracking data object");
1298         RNA_def_property_srna(prop, "MovieTrackingTracks");
1299
1300         /* stabilization */
1301         prop= RNA_def_property(srna, "stabilization", PROP_POINTER, PROP_NONE);
1302         RNA_def_property_struct_type(prop, "MovieTrackingStabilization");
1303
1304         /* reconstruction */
1305         prop= RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
1306         RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
1307
1308         /* objects */
1309         prop= RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
1310         RNA_def_property_collection_funcs(prop, "rna_trackingObjects_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
1311         RNA_def_property_struct_type(prop, "MovieTrackingObject");
1312         RNA_def_property_ui_text(prop, "Objects", "Collection of objects in this tracking data object");
1313         rna_def_trackingObjects(brna, prop);
1314
1315         /* active object index */
1316         prop= RNA_def_property(srna, "active_object_index", PROP_INT, PROP_NONE);
1317         RNA_def_property_int_sdna(prop, NULL, "objectnr");
1318         RNA_def_property_int_funcs(prop, "rna_tracking_active_object_index_get", "rna_tracking_active_object_index_set", "rna_tracking_active_object_index_range");
1319         RNA_def_property_ui_text(prop, "Active Object Index", "Index of active object");
1320         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1321 }
1322
1323 void RNA_def_tracking(BlenderRNA *brna)
1324 {
1325         rna_def_tracking(brna);
1326 }
1327
1328 #endif