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