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