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