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