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