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