17940dfca921d2822ae0959fe35235c2a4bc75cb
[blender.git] / source / blender / makesrna / intern / rna_tracking.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation,
19  *                 Sergey Sharybin
20  *
21  * ***** END GPL LICENSE BLOCK *****
22  */
23
24 /** \file blender/makesrna/intern/rna_tracking.c
25  *  \ingroup RNA
26  */
27
28
29 #include <stdlib.h>
30 #include <limits.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "BLI_math.h"
35 #include "BKE_movieclip.h"
36 #include "BKE_tracking.h"
37
38 #include "RNA_define.h"
39
40 #include "rna_internal.h"
41
42 #include "DNA_movieclip_types.h"
43 #include "DNA_object_types.h"   /* SELECT */
44 #include "DNA_scene_types.h"
45
46 #include "WM_types.h"
47
48 #ifdef RNA_RUNTIME
49
50 #include "BKE_depsgraph.h"
51 #include "BKE_node.h"
52
53 #include "IMB_imbuf.h"
54
55 #include "WM_api.h"
56
57 static char *rna_tracking_path(PointerRNA *UNUSED(ptr))
58 {
59         return BLI_sprintfN("tracking");
60 }
61
62 static void rna_tracking_defaultSettings_levelsUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
63 {
64         MovieClip *clip = (MovieClip*)ptr->id.data;
65         MovieTracking *tracking = &clip->tracking;
66         MovieTrackingSettings *settings = &tracking->settings;
67
68         if (settings->default_tracker == TRACKER_KLT) {
69                 int max_pyramid_level_factor = 1 << (settings->default_pyramid_levels - 1);
70                 float search_ratio = 2.3f * max_pyramid_level_factor;
71
72                 settings->default_search_size = settings->default_pattern_size*search_ratio;
73         }
74 }
75
76 static void rna_tracking_defaultSettings_patternUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
77 {
78         MovieClip *clip = (MovieClip*)ptr->id.data;
79         MovieTracking *tracking = &clip->tracking;
80         MovieTrackingSettings *settings = &tracking->settings;
81
82         if (settings->default_search_size<settings->default_pattern_size)
83                 settings->default_search_size = settings->default_pattern_size;
84 }
85
86 static void rna_tracking_defaultSettings_searchUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
87 {
88         MovieClip *clip = (MovieClip*)ptr->id.data;
89         MovieTracking *tracking = &clip->tracking;
90         MovieTrackingSettings *settings = &tracking->settings;
91
92         if (settings->default_pattern_size>settings->default_search_size)
93                 settings->default_pattern_size = settings->default_search_size;
94 }
95
96 static char *rna_trackingTrack_path(PointerRNA *ptr)
97 {
98         MovieTrackingTrack *track = (MovieTrackingTrack *) ptr->data;
99
100         return BLI_sprintfN("tracking.tracks[\"%s\"]", track->name);
101 }
102
103 static void rna_trackingTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
104 {
105         MovieClip *clip = (MovieClip*)ptr->id.data;
106
107         rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
108 }
109
110 static void rna_trackingObjects_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
111 {
112         MovieClip *clip = (MovieClip*)ptr->id.data;
113
114         rna_iterator_listbase_begin(iter, &clip->tracking.objects, NULL);
115 }
116
117 static int rna_tracking_active_object_index_get(PointerRNA *ptr)
118 {
119         MovieClip *clip = (MovieClip*)ptr->id.data;
120
121         return clip->tracking.objectnr;
122 }
123
124 static void rna_tracking_active_object_index_set(PointerRNA *ptr, int value)
125 {
126         MovieClip *clip = (MovieClip*)ptr->id.data;
127
128         clip->tracking.objectnr = value;
129 }
130
131 static void rna_tracking_active_object_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
132 {
133         MovieClip *clip = (MovieClip*)ptr->id.data;
134
135         *min = 0;
136         *max = clip->tracking.tot_object-1;
137         *max = MAX2(0, *max);
138 }
139
140 static PointerRNA rna_tracking_active_track_get(PointerRNA *ptr)
141 {
142         MovieClip *clip = (MovieClip*)ptr->id.data;
143         MovieTrackingTrack *act_track = BKE_tracking_active_track(&clip->tracking);
144
145         return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingTrack, act_track);
146 }
147
148 static void rna_tracking_active_track_set(PointerRNA *ptr, PointerRNA value)
149 {
150         MovieClip *clip = (MovieClip*)ptr->id.data;
151         MovieTrackingTrack *track = (MovieTrackingTrack *)value.data;
152         ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
153         int index = BLI_findindex(tracksbase, track);
154
155         if (index >= 0)
156                 clip->tracking.act_track = track;
157         else
158                 clip->tracking.act_track = NULL;
159 }
160
161 void rna_trackingTrack_name_set(PointerRNA *ptr, const char *value)
162 {
163         MovieClip *clip = (MovieClip *)ptr->id.data;
164         MovieTracking *tracking = &clip->tracking;
165         MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
166         ListBase *tracksbase = &tracking->tracks;
167
168         BLI_strncpy(track->name, value, sizeof(track->name));
169
170         /* TODO: it's a bit difficult to find list track came from knowing just
171          *       movie clip ID and MovieTracking structure, so keep this naive
172          *       search for a while */
173         if (BLI_findindex(tracksbase, track) < 0) {
174                 MovieTrackingObject *object = tracking->objects.first;
175
176                 while (object) {
177                         if (BLI_findindex(&object->tracks, track)) {
178                                 tracksbase = &object->tracks;
179                                 break;
180                         }
181
182                         object = object->next;
183                 }
184         }
185
186         BKE_track_unique_name(tracksbase, track);
187 }
188
189 static int rna_trackingTrack_select_get(PointerRNA *ptr)
190 {
191         MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
192
193         return TRACK_SELECTED(track);
194 }
195
196 static void rna_trackingTrack_select_set(PointerRNA *ptr, int value)
197 {
198         MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
199
200         if (value) {
201                 track->flag |= SELECT;
202                 track->pat_flag |= SELECT;
203                 track->search_flag |= SELECT;
204         }
205         else {
206                 track->flag &= ~SELECT;
207                 track->pat_flag &= ~SELECT;
208                 track->search_flag &= ~SELECT;
209         }
210 }
211
212 static void rna_tracking_trackerPattern_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
213 {
214         MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
215
216         BKE_tracking_clamp_track(track, CLAMP_PAT_DIM);
217 }
218
219 static void rna_tracking_trackerSearch_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
220 {
221         MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
222
223         BKE_tracking_clamp_track(track, CLAMP_SEARCH_DIM);
224 }
225
226 static void rna_tracking_trackerAlgorithm_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
227 {
228         MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
229
230         if (track->tracker == TRACKER_KLT)
231                 BKE_tracking_clamp_track(track, CLAMP_PYRAMID_LEVELS);
232         else
233                 BKE_tracking_clamp_track(track, CLAMP_SEARCH_DIM);
234 }
235
236 static void rna_tracking_trackerPyramid_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
237 {
238         MovieTrackingTrack *track = (MovieTrackingTrack *)ptr->data;
239
240         BKE_tracking_clamp_track(track, CLAMP_PYRAMID_LEVELS);
241 }
242
243 static char *rna_trackingCamera_path(PointerRNA *UNUSED(ptr))
244 {
245         return BLI_sprintfN("tracking.camera");
246 }
247
248 static float rna_trackingCamera_focal_mm_get(PointerRNA *ptr)
249 {
250         MovieClip *clip = (MovieClip*)ptr->id.data;
251         MovieTrackingCamera *camera = &clip->tracking.camera;
252         float val = camera->focal;
253
254         if (clip->lastsize[0])
255                 val = val*camera->sensor_width/(float)clip->lastsize[0];
256
257         return val;
258 }
259
260 static void rna_trackingCamera_focal_mm_set(PointerRNA *ptr, float value)
261 {
262         MovieClip *clip = (MovieClip*)ptr->id.data;
263         MovieTrackingCamera *camera = &clip->tracking.camera;
264
265         if (clip->lastsize[0])
266                 value = clip->lastsize[0]*value/camera->sensor_width;
267
268         if (value >= 0.0001f)
269                 camera->focal = value;
270 }
271
272 static char *rna_trackingStabilization_path(PointerRNA *UNUSED(ptr))
273 {
274         return BLI_sprintfN("tracking.stabilization");
275 }
276
277 static int rna_track_2d_stabilization(CollectionPropertyIterator *UNUSED(iter), void *data)
278 {
279         MovieTrackingTrack *track = (MovieTrackingTrack*)data;
280
281         if ((track->flag&TRACK_USE_2D_STAB) == 0)
282                 return 1;
283
284         return 0;
285 }
286
287 static void rna_tracking_stabTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
288 {
289         MovieClip *clip = (MovieClip*)ptr->id.data;
290         rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization);
291 }
292
293 static int rna_tracking_stabTracks_active_index_get(PointerRNA *ptr)
294 {
295         MovieClip *clip = (MovieClip*)ptr->id.data;
296         return clip->tracking.stabilization.act_track;
297 }
298
299 static void rna_tracking_stabTracks_active_index_set(PointerRNA *ptr, int value)
300 {
301         MovieClip *clip = (MovieClip*)ptr->id.data;
302         clip->tracking.stabilization.act_track = value;
303 }
304
305 static void rna_tracking_stabTracks_active_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
306 {
307         MovieClip *clip = (MovieClip*)ptr->id.data;
308
309         *min = 0;
310         *max = clip->tracking.stabilization.tot_track-1;
311         *max = MAX2(0, *max);
312 }
313
314 static void rna_tracking_flushUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
315 {
316         MovieClip *clip = (MovieClip*)ptr->id.data;
317         MovieTrackingStabilization *stab = &clip->tracking.stabilization;
318
319         stab->ok = 0;
320
321         nodeUpdateID(scene->nodetree, &clip->id);
322
323         WM_main_add_notifier(NC_SCENE|ND_NODES, NULL);
324         DAG_id_tag_update(&clip->id, 0);
325 }
326
327 static void rna_trackingObject_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
328 {
329         MovieTrackingObject *object = (MovieTrackingObject* )ptr->data;
330
331         if (object->flag&TRACKING_OBJECT_CAMERA) {
332                 MovieClip *clip = (MovieClip*)ptr->id.data;
333
334                 rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
335         }
336         else {
337                 rna_iterator_listbase_begin(iter, &object->tracks, NULL);
338         }
339 }
340
341 static PointerRNA rna_trackingObject_reconstruction_get(PointerRNA *ptr)
342 {
343         MovieTrackingObject *object = (MovieTrackingObject* )ptr->data;
344
345         if (object->flag & TRACKING_OBJECT_CAMERA) {
346                 MovieClip *clip = (MovieClip*)ptr->id.data;
347
348                 return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingReconstruction, &clip->tracking.reconstruction);
349         }
350         else {
351                 return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingReconstruction, &object->reconstruction);
352         }
353 }
354
355 static PointerRNA rna_tracking_active_object_get(PointerRNA *ptr)
356 {
357         MovieClip *clip = (MovieClip*)ptr->id.data;
358         MovieTrackingObject *object = BLI_findlink(&clip->tracking.objects, clip->tracking.objectnr);
359
360         return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingObject, object);
361 }
362
363 static void rna_tracking_active_object_set(PointerRNA *ptr, PointerRNA value)
364 {
365         MovieClip *clip = (MovieClip*)ptr->id.data;
366         MovieTrackingObject *object = (MovieTrackingObject *)value.data;
367         int index = BLI_findindex(&clip->tracking.objects, object);
368
369         if (index >= 0) clip->tracking.objectnr = index;
370         else clip->tracking.objectnr = 0;
371 }
372
373 void rna_trackingObject_name_set(PointerRNA *ptr, const char *value)
374 {
375         MovieClip *clip = (MovieClip *)ptr->id.data;
376         MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
377
378         BLI_strncpy(object->name, value, sizeof(object->name));
379
380         BKE_tracking_object_unique_name(&clip->tracking, object);
381 }
382
383 static void rna_trackingObject_flushUpdate(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
384 {
385         MovieClip *clip = (MovieClip*)ptr->id.data;
386
387         WM_main_add_notifier(NC_OBJECT|ND_TRANSFORM, NULL);
388         DAG_id_tag_update(&clip->id, 0);
389 }
390
391 static void rna_trackingMarker_frame_set(PointerRNA *ptr, int value)
392 {
393         MovieClip *clip = (MovieClip *) ptr->id.data;
394         MovieTracking *tracking = &clip->tracking;
395         MovieTrackingTrack *track;
396         MovieTrackingMarker *marker = (MovieTrackingMarker *) ptr->data;
397
398         track = tracking->tracks.first;
399         while (track) {
400                 if (marker >= track->markers && marker < track->markers+track->markersnr) {
401                         break;
402                 }
403
404                 track = track->next;
405         }
406
407         if (track) {
408                 MovieTrackingMarker new_marker = *marker;
409                 new_marker.framenr = value;
410
411                 BKE_tracking_delete_marker(track, marker->framenr);
412                 BKE_tracking_insert_marker(track, &new_marker);
413         }
414 }
415
416 /* API */
417
418 static void add_tracks_to_base(MovieClip *clip, MovieTracking *tracking, ListBase *tracksbase, int frame, int number)
419 {
420         int a, width, height;
421         MovieClipUser user = {0};
422
423         user.framenr = 1;
424
425         BKE_movieclip_get_size(clip, &user, &width, &height);
426
427         for (a = 0; a<number; a++)
428                 BKE_tracking_add_track(tracking, tracksbase, 0, 0, frame, width, height);
429 }
430
431 static void rna_trackingTracks_add(ID *id, MovieTracking *tracking, int frame, int number)
432 {
433         MovieClip *clip = (MovieClip *) id;
434
435         add_tracks_to_base(clip, tracking, &tracking->tracks, frame, number);
436
437         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, clip);
438 }
439
440 static void rna_trackingObject_tracks_add(ID *id, MovieTrackingObject *object, int frame, int number)
441 {
442         MovieClip *clip = (MovieClip *) id;
443         ListBase *tracksbase = &object->tracks;
444
445         if (object->flag&TRACKING_OBJECT_CAMERA)
446                 tracksbase = &clip->tracking.tracks;
447
448         add_tracks_to_base(clip, &clip->tracking, tracksbase, frame, number);
449
450         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
451 }
452
453 static MovieTrackingObject *rna_trackingObject_new(MovieTracking *tracking, const char *name)
454 {
455         MovieTrackingObject *object = BKE_tracking_new_object(tracking, name);
456
457         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
458
459         return object;
460 }
461
462 void rna_trackingObject_remove(MovieTracking *tracking, MovieTrackingObject *object)
463 {
464         BKE_tracking_remove_object(tracking, object);
465
466         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
467 }
468
469 static MovieTrackingMarker *rna_trackingMarkers_find_frame(MovieTrackingTrack *track, int framenr)
470 {
471         return BKE_tracking_exact_marker(track, framenr);
472 }
473
474 static MovieTrackingMarker* rna_trackingMarkers_insert_frame(MovieTrackingTrack *track, int framenr, float *co)
475 {
476         MovieTrackingMarker marker, *new_marker;
477
478         memset(&marker, 0, sizeof(marker));
479         marker.framenr = framenr;
480         copy_v2_v2(marker.pos, co);
481
482         new_marker = BKE_tracking_insert_marker(track, &marker);
483
484         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
485
486         return new_marker;
487 }
488
489 void rna_trackingMarkers_delete_frame(MovieTrackingTrack *track, int framenr)
490 {
491         if (track->markersnr == 1)
492                 return;
493
494         BKE_tracking_delete_marker(track, framenr);
495
496         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
497 }
498
499 #else
500
501 static EnumPropertyItem tracker_items[] = {
502         {TRACKER_KLT, "KLT", 0, "KLT",
503                       "Kanade–Lucas–Tomasi tracker which works with most of video clips, a bit slower than SAD"},
504         {TRACKER_SAD, "SAD", 0, "SAD", "Sum of Absolute Differences tracker which can be used when KLT tracker fails"},
505         {TRACKER_HYBRID, "Hybrid", 0, "Hybrid", "A hybrid tracker that uses SAD for rough tracking, KLT for refinement."},
506         {0, NULL, 0, NULL, NULL}};
507
508 static EnumPropertyItem pattern_match_items[] = {
509         {TRACK_MATCH_KEYFRAME, "KEYFRAME", 0, "Keyframe", "Track pattern from keyframe to next frame"},
510         {TRACK_MATCH_PREVFRAME, "PREV_FRAME", 0, "Previous frame", "Track pattern from current frame to next frame"},
511         {0, NULL, 0, NULL, NULL}};
512
513 static int rna_matrix_dimsize_4x4[] = {4, 4};
514
515 static void rna_def_trackingSettings(BlenderRNA *brna)
516 {
517         StructRNA *srna;
518         PropertyRNA *prop;
519
520         static EnumPropertyItem speed_items[] = {
521                 {0, "FASTEST", 0, "Fastest", "Track as fast as it's possible"},
522             {TRACKING_SPEED_DOUBLE, "DOUBLE", 0, "Double", "Track with double speed"},
523                 {TRACKING_SPEED_REALTIME, "REALTIME", 0, "Realtime", "Track with realtime speed"},
524                 {TRACKING_SPEED_HALF, "HALF", 0, "Half", "Track with half of realtime speed"},
525                 {TRACKING_SPEED_QUARTER, "QUARTER", 0, "Quarter", "Track with quarter of realtime speed"},
526                 {0, NULL, 0, NULL, NULL}};
527
528         static EnumPropertyItem cleanup_items[] = {
529                 {TRACKING_CLEAN_SELECT, "SELECT", 0, "Select", "Select unclean tracks"},
530                 {TRACKING_CLEAN_DELETE_TRACK, "DELETE_TRACK", 0, "Delete Track", "Delete unclean tracks"},
531                 {TRACKING_CLEAN_DELETE_SEGMENT, "DELETE_SEGMENTS", 0, "Delete Segments", "Delete unclean segments of tracks"},
532                 {0, NULL, 0, NULL, NULL}
533         };
534
535         static EnumPropertyItem refine_items[] = {
536                 {0, "NONE", 0, "Nothing", "Do not refine camera intrinsics"},
537                 {REFINE_FOCAL_LENGTH, "FOCAL_LENGTH", 0, "Focal Length", "Refine focal length"},
538                 {REFINE_FOCAL_LENGTH|REFINE_RADIAL_DISTORTION_K1, "FOCAL_LENGTH_RADIAL_K1", 0, "Focal length, K1",
539                                                                   "Refine focal length and radial distortion K1"},
540                 {REFINE_FOCAL_LENGTH|
541                  REFINE_RADIAL_DISTORTION_K1|
542                  REFINE_RADIAL_DISTORTION_K2, "FOCAL_LENGTH_RADIAL_K1_K2", 0, "Focal length, K1, K2",
543                                               "Refine focal length and radial distortion K1 and K2"},
544                 {REFINE_FOCAL_LENGTH|
545                  REFINE_PRINCIPAL_POINT|
546                  REFINE_RADIAL_DISTORTION_K1|
547                  REFINE_RADIAL_DISTORTION_K2, "FOCAL_LENGTH_PRINCIPAL_POINT_RADIAL_K1_K2", 0,
548                                               "Focal Length, Optical Center, K1, K2",
549                                               "Refine focal length, optical center and radial distortion K1 and K2"},
550                 {REFINE_FOCAL_LENGTH|
551                  REFINE_PRINCIPAL_POINT, "FOCAL_LENGTH_PRINCIPAL_POINT", 0, "Focal Length, Optical Center",
552                                          "Refine focal length and optical center"},
553                 {0, NULL, 0, NULL, NULL}
554         };
555
556         srna = RNA_def_struct(brna, "MovieTrackingSettings", NULL);
557         RNA_def_struct_ui_text(srna, "Movie tracking settings", "Match moving settings");
558
559         /* speed */
560         prop = RNA_def_property(srna, "speed", PROP_ENUM, PROP_NONE);
561         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
562         RNA_def_property_enum_items(prop, speed_items);
563         RNA_def_property_ui_text(prop, "Speed",
564                                  "Limit speed of tracking to make visual feedback easier "
565                                  "(this does not affect the tracking quality)");
566
567         /* keyframe_a */
568         prop = RNA_def_property(srna, "keyframe_a", PROP_INT, PROP_NONE);
569         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
570         RNA_def_property_int_sdna(prop, NULL, "keyframe1");
571         RNA_def_property_ui_text(prop, "Keyframe A", "First keyframe used for reconstruction initialization");
572
573         /* keyframe_b */
574         prop = RNA_def_property(srna, "keyframe_b", PROP_INT, PROP_NONE);
575         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
576         RNA_def_property_int_sdna(prop, NULL, "keyframe2");
577         RNA_def_property_ui_text(prop, "Keyframe B", "Second keyframe used for reconstruction initialization");
578
579         /* intrinsics refinement during bundle adjustment */
580         prop = RNA_def_property(srna, "refine_intrinsics", PROP_ENUM, PROP_NONE);
581         RNA_def_property_enum_sdna(prop, NULL, "refine_camera_intrinsics");
582         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
583         RNA_def_property_enum_items(prop, refine_items);
584         RNA_def_property_ui_text(prop, "Refine", "Refine intrinsics during camera solving");
585
586         /* tool settings */
587
588         /* distance */
589         prop = RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
590         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
591         RNA_def_property_float_sdna(prop, NULL, "dist");
592         RNA_def_property_float_default(prop, 1.0f);
593         RNA_def_property_ui_text(prop, "Distance", "Distance between two bundles used for scene scaling");
594
595         /* frames count */
596         prop = RNA_def_property(srna, "clean_frames", PROP_INT, PROP_NONE);
597         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
598         RNA_def_property_int_sdna(prop, NULL, "clean_frames");
599         RNA_def_property_range(prop, 0, INT_MAX);
600         RNA_def_property_ui_text(prop, "Tracked Frames",
601                                  "Effect on tracks which are tracked less than the specified amount of frames");
602
603         /* re-projection error */
604         prop = RNA_def_property(srna, "clean_error", PROP_FLOAT, PROP_NONE);
605         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
606         RNA_def_property_float_sdna(prop, NULL, "clean_error");
607         RNA_def_property_range(prop, 0, FLT_MAX);
608         RNA_def_property_ui_text(prop, "Reprojection Error", "Effect on tracks which have a larger re-projection error");
609
610         /* cleanup action */
611         prop = RNA_def_property(srna, "clean_action", PROP_ENUM, PROP_NONE);
612         RNA_def_property_enum_sdna(prop, NULL, "clean_action");
613         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
614         RNA_def_property_enum_items(prop, cleanup_items);
615         RNA_def_property_ui_text(prop, "Action", "Cleanup action to execute");
616
617         /* ** default tracker settings ** */
618         prop = RNA_def_property(srna, "show_default_expanded", PROP_BOOLEAN, PROP_NONE);
619         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
620         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_SETTINGS_SHOW_DEFAULT_EXPANDED);
621         RNA_def_property_ui_text(prop, "Show Expanded", "Show the expanded in the user interface");
622         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
623
624         /* solver settings */
625         prop = RNA_def_property(srna, "use_tripod_solver", PROP_BOOLEAN, PROP_NONE);
626         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
627         RNA_def_property_boolean_sdna(prop, NULL, "motion_flag", TRACKING_MOTION_TRIPOD);
628         RNA_def_property_ui_text(prop, "Tripod Motion", "Use special solver to track a stable camera position, such as a tripod");
629
630         /* limit frames */
631         prop = RNA_def_property(srna, "default_frames_limit", PROP_INT, PROP_NONE);
632         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
633         RNA_def_property_int_sdna(prop, NULL, "default_frames_limit");
634         RNA_def_property_range(prop, 0, SHRT_MAX);
635         RNA_def_property_ui_text(prop, "Frames Limit", "Every tracking cycle, this number of frames are tracked");
636
637         /* pattern match */
638         prop = RNA_def_property(srna, "default_pattern_match", PROP_ENUM, PROP_NONE);
639         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
640         RNA_def_property_enum_sdna(prop, NULL, "default_pattern_match");
641         RNA_def_property_enum_items(prop, pattern_match_items);
642         RNA_def_property_ui_text(prop, "Pattern Match",
643                                  "Track pattern from given frame when tracking marker to next frame");
644
645         /* margin */
646         prop = RNA_def_property(srna, "default_margin", PROP_INT, PROP_NONE);
647         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
648         RNA_def_property_int_sdna(prop, NULL, "default_margin");
649         RNA_def_property_range(prop, 0, 300);
650         RNA_def_property_ui_text(prop, "Margin", "Default distance from image boudary at which marker stops tracking");
651
652         /* tracking algorithm */
653         prop = RNA_def_property(srna, "default_tracker", PROP_ENUM, PROP_NONE);
654         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
655         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
656         RNA_def_property_enum_items(prop, tracker_items);
657         RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_levelsUpdate");
658         RNA_def_property_ui_text(prop, "Tracker", "Default tracking algorithm to use");
659
660         /* pyramid level for pyramid klt tracking */
661         prop = RNA_def_property(srna, "default_pyramid_levels", PROP_INT, PROP_NONE);
662         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
663         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
664         RNA_def_property_int_sdna(prop, NULL, "default_pyramid_levels");
665         RNA_def_property_range(prop, 1, 16);
666         RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_levelsUpdate");
667         RNA_def_property_ui_text(prop, "Pyramid levels", "Default number of pyramid levels (increase on blurry footage)");
668
669         /* minmal correlation - only used for SAD tracker */
670         prop = RNA_def_property(srna, "default_correlation_min", PROP_FLOAT, PROP_NONE);
671         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
672         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
673         RNA_def_property_float_sdna(prop, NULL, "default_minimum_correlation");
674         RNA_def_property_range(prop, -1.0f, 1.0f);
675         RNA_def_property_ui_range(prop, -1.0f, 1.0f, 0.1, 3);
676         RNA_def_property_ui_text(prop, "Correlation",
677                                  "Default minimal value of correlation between matched pattern and reference "
678                                  "which is still treated as successful tracking");
679
680         /* default pattern size */
681         prop = RNA_def_property(srna, "default_pattern_size", PROP_INT, PROP_NONE);
682         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
683         RNA_def_property_int_sdna(prop, NULL, "default_pattern_size");
684         RNA_def_property_range(prop, 5, 1000);
685         RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_patternUpdate");
686         RNA_def_property_ui_text(prop, "Pattern Size", "Size of pattern area for newly created tracks");
687
688         /* default search size */
689         prop = RNA_def_property(srna, "default_search_size", PROP_INT, PROP_NONE);
690         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
691         RNA_def_property_int_sdna(prop, NULL, "default_search_size");
692         RNA_def_property_range(prop, 5, 1000);
693         RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_searchUpdate");
694         RNA_def_property_ui_text(prop, "Search Size", "Size of search area for newly created tracks");
695
696         /* use_red_channel */
697         prop = RNA_def_property(srna, "use_default_red_channel", PROP_BOOLEAN, PROP_NONE);
698         RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_RED);
699         RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
700         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
701
702         /* use_green_channel */
703         prop = RNA_def_property(srna, "use_default_green_channel", PROP_BOOLEAN, PROP_NONE);
704         RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_GREEN);
705         RNA_def_property_ui_text(prop, "Use Green Channel", "Use green channel from footage for tracking");
706         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
707
708         /* use_blue_channel */
709         prop = RNA_def_property(srna, "use_default_blue_channel", PROP_BOOLEAN, PROP_NONE);
710         RNA_def_property_boolean_negative_sdna(prop, NULL, "default_flag", TRACK_DISABLE_BLUE);
711         RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
712         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
713
714         /* ** object tracking ** */
715
716         /* object distance */
717         prop = RNA_def_property(srna, "object_distance", PROP_FLOAT, PROP_NONE);
718         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
719         RNA_def_property_float_sdna(prop, NULL, "object_distance");
720         RNA_def_property_ui_text(prop, "Distance", "Distance between two bundles used for object scaling");
721         RNA_def_property_range(prop, 0.001, 10000);
722         RNA_def_property_float_default(prop, 1.0f);
723         RNA_def_property_ui_range(prop, 0.001, 10000.0, 1, 3);
724 }
725
726 static void rna_def_trackingCamera(BlenderRNA *brna)
727 {
728         StructRNA *srna;
729         PropertyRNA *prop;
730
731         static EnumPropertyItem camera_units_items[] = {
732                 {CAMERA_UNITS_PX, "PIXELS", 0, "px", "Use pixels for units of focal length"},
733                 {CAMERA_UNITS_MM, "MILLIMETERS", 0, "mm", "Use millimeters for units of focal length"},
734                 {0, NULL, 0, NULL, NULL}};
735
736         srna = RNA_def_struct(brna, "MovieTrackingCamera", NULL);
737         RNA_def_struct_path_func(srna, "rna_trackingCamera_path");
738         RNA_def_struct_ui_text(srna, "Movie tracking camera data", "Match-moving camera data for tracking");
739
740         /* Sensor */
741         prop = RNA_def_property(srna, "sensor_width", PROP_FLOAT, PROP_NONE);
742         RNA_def_property_float_sdna(prop, NULL, "sensor_width");
743         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
744         RNA_def_property_range(prop, 0.0f, 500.0f);
745         RNA_def_property_ui_text(prop, "Sensor", "Width of CCD sensor in millimeters");
746         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
747
748         /* Focal Length */
749         prop = RNA_def_property(srna, "focal_length", PROP_FLOAT, PROP_NONE);
750         RNA_def_property_float_sdna(prop, NULL, "focal");
751         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
752         RNA_def_property_range(prop, 0.0001f, 5000.0f);
753         RNA_def_property_float_funcs(prop, "rna_trackingCamera_focal_mm_get", "rna_trackingCamera_focal_mm_set", NULL);
754         RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
755         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
756
757         /* Focal Length in pixels */
758         prop = RNA_def_property(srna, "focal_length_pixels", PROP_FLOAT, PROP_NONE);
759         RNA_def_property_float_sdna(prop, NULL, "focal");
760         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
761         RNA_def_property_range(prop, 0.0f, 5000.0f);
762         RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
763         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
764
765         /* Units */
766         prop = RNA_def_property(srna, "units", PROP_ENUM, PROP_NONE);
767         RNA_def_property_enum_sdna(prop, NULL, "units");
768         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
769         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
770         RNA_def_property_enum_items(prop, camera_units_items);
771         RNA_def_property_ui_text(prop, "Units", "Units used for camera focal length");
772
773         /* Principal Point */
774         prop = RNA_def_property(srna, "principal", PROP_FLOAT, PROP_NONE);
775         RNA_def_property_array(prop, 2);
776         RNA_def_property_float_sdna(prop, NULL, "principal");
777         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
778         RNA_def_property_ui_text(prop, "Principal Point", "Optical center of lens");
779         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
780
781         /* Radial distortion parameters */
782         prop = RNA_def_property(srna, "k1", PROP_FLOAT, PROP_NONE);
783         RNA_def_property_float_sdna(prop, NULL, "k1");
784         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
785         RNA_def_property_ui_range(prop, -10, 10, .1, 3);
786         RNA_def_property_ui_text(prop, "K1", "First coefficient of third order polynomial radial distortion");
787         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
788
789         prop = RNA_def_property(srna, "k2", PROP_FLOAT, PROP_NONE);
790         RNA_def_property_float_sdna(prop, NULL, "k2");
791         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
792         RNA_def_property_ui_range(prop, -10, 10, .1, 3);
793         RNA_def_property_ui_text(prop, "K2", "Second coefficient of third order polynomial radial distortion");
794         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
795
796         prop = RNA_def_property(srna, "k3", PROP_FLOAT, PROP_NONE);
797         RNA_def_property_float_sdna(prop, NULL, "k3");
798         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
799         RNA_def_property_ui_range(prop, -10, 10, .1, 3);
800         RNA_def_property_ui_text(prop, "K3", "Third coefficient of third order polynomial radial distortion");
801         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
802
803         /* pixel aspect */
804         prop = RNA_def_property(srna, "pixel_aspect", PROP_FLOAT, PROP_XYZ);
805         RNA_def_property_float_sdna(prop, NULL, "pixel_aspect");
806         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
807         RNA_def_property_range(prop, 0.1f, 5000.0f);
808         RNA_def_property_ui_range(prop, 0.1f, 5000.0f, 1, 2);
809         RNA_def_property_float_default(prop, 1.0f);
810         RNA_def_property_ui_text(prop, "Pixel Aspect Ratio", "Pixel aspect ratio");
811         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
812 }
813
814 static void rna_def_trackingMarker(BlenderRNA *brna)
815 {
816         StructRNA *srna;
817         PropertyRNA *prop;
818
819         srna = RNA_def_struct(brna, "MovieTrackingMarker", NULL);
820         RNA_def_struct_ui_text(srna, "Movie tracking marker data", "Match-moving marker data for tracking");
821
822         /* position */
823         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
824         RNA_def_property_array(prop, 2);
825         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
826         RNA_def_property_float_sdna(prop, NULL, "pos");
827         RNA_def_property_ui_text(prop, "Position", "Marker position at frame in normalized coordinates");
828         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
829
830         /* frame */
831         prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
832         RNA_def_property_int_sdna(prop, NULL, "framenr");
833         RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
834         RNA_def_property_int_funcs(prop, NULL, "rna_trackingMarker_frame_set", NULL);
835         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, 0);
836
837         /* enable */
838         prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
839         RNA_def_property_boolean_sdna(prop, NULL, "flag", MARKER_DISABLED);
840         RNA_def_property_ui_text(prop, "Mode", "Is marker muted for current frame");
841         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
842 }
843
844 static void rna_def_trackingMarkers(BlenderRNA *brna, PropertyRNA *cprop)
845 {
846         StructRNA *srna;
847         FunctionRNA *func;
848         PropertyRNA *parm;
849
850         RNA_def_property_srna(cprop, "MovieTrackingMarkers");
851         srna = RNA_def_struct(brna, "MovieTrackingMarkers", NULL);
852         RNA_def_struct_sdna(srna, "MovieTrackingTrack");
853         RNA_def_struct_ui_text(srna, "Movie Tracking Markers", "Collection of markers for movie tracking track");
854
855         func = RNA_def_function(srna, "find_frame", "rna_trackingMarkers_find_frame");
856         RNA_def_function_ui_description(func, "Get marker for specified frame");
857         parm = RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
858                            "Frame number to find marker for", MINFRAME, MAXFRAME);
859         RNA_def_property_flag(parm, PROP_REQUIRED);
860         parm = RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Marker for specified frame");
861         RNA_def_function_return(func, parm);
862
863         func = RNA_def_function(srna, "insert_frame", "rna_trackingMarkers_insert_frame");
864         RNA_def_function_ui_description(func, "Add a number of tracks to this movie clip");
865         parm = RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
866                            "Frame number to insert marker to", MINFRAME, MAXFRAME);
867         RNA_def_property_flag(parm, PROP_REQUIRED);
868         RNA_def_float_vector(func, "co", 2, 0, -1.0, 1.0, "Coordinate",
869                              "Place new marker at the given frame using specified in normalized space coordinates",
870                              -1.0, 1.0);
871         RNA_def_property_flag(parm, PROP_REQUIRED);
872         parm = RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Newly created marker");
873         RNA_def_function_return(func, parm);
874
875         func = RNA_def_function(srna, "delete_frame", "rna_trackingMarkers_delete_frame");
876         RNA_def_function_ui_description(func, "Delete marker at specified frame");
877         parm = RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame",
878                            "Frame number to delete marker from", MINFRAME, MAXFRAME);
879         RNA_def_property_flag(parm, PROP_REQUIRED);
880 }
881
882 static void rna_def_trackingTrack(BlenderRNA *brna)
883 {
884         StructRNA *srna;
885         PropertyRNA *prop;
886
887         rna_def_trackingMarker(brna);
888
889         srna = RNA_def_struct(brna, "MovieTrackingTrack", NULL);
890         RNA_def_struct_path_func(srna, "rna_trackingTrack_path");
891         RNA_def_struct_ui_text(srna, "Movie tracking track data", "Match-moving track data for tracking");
892         RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
893
894         /* name */
895         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
896         RNA_def_property_ui_text(prop, "Name", "Unique name of track");
897         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingTrack_name_set");
898         RNA_def_property_string_maxlength(prop, MAX_ID_NAME-2);
899         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
900         RNA_def_struct_name_property(srna, prop);
901
902         /* Pattern */
903         prop = RNA_def_property(srna, "pattern_min", PROP_FLOAT, PROP_TRANSLATION);
904         RNA_def_property_array(prop, 2);
905         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
906         RNA_def_property_float_sdna(prop, NULL, "pat_min");
907         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
908         RNA_def_property_ui_text(prop, "Pattern Min",
909                                  "Left-bottom corner of pattern area in normalized coordinates relative "
910                                  "to marker position");
911         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPattern_update");
912
913         prop = RNA_def_property(srna, "pattern_max", PROP_FLOAT, PROP_TRANSLATION);
914         RNA_def_property_array(prop, 2);
915         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
916         RNA_def_property_float_sdna(prop, NULL, "pat_max");
917         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
918         RNA_def_property_ui_text(prop, "Pattern Max",
919                                  "Right-bottom corner of pattern area in normalized coordinates relative "
920                                  "to marker position");
921         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPattern_update");
922
923         /* Search */
924         prop = RNA_def_property(srna, "search_min", PROP_FLOAT, PROP_TRANSLATION);
925         RNA_def_property_array(prop, 2);
926         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
927         RNA_def_property_float_sdna(prop, NULL, "search_min");
928         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
929         RNA_def_property_ui_text(prop, "Search Min",
930                                  "Left-bottom corner of search area in normalized coordinates relative "
931                                  "to marker position");
932         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerSearch_update");
933
934         prop = RNA_def_property(srna, "search_max", PROP_FLOAT, PROP_TRANSLATION);
935         RNA_def_property_array(prop, 2);
936         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
937         RNA_def_property_float_sdna(prop, NULL, "search_max");
938         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
939         RNA_def_property_ui_text(prop, "Search Max",
940                                  "Right-bottom corner of search area in normalized coordinates relative "
941                                  "to marker position");
942         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerSearch_update");
943
944         /* limit frames */
945         prop = RNA_def_property(srna, "frames_limit", PROP_INT, PROP_NONE);
946         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
947         RNA_def_property_int_sdna(prop, NULL, "frames_limit");
948         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
949         RNA_def_property_range(prop, 0, SHRT_MAX);
950         RNA_def_property_ui_text(prop, "Frames Limit", "Every tracking cycle, this number of frames are tracked");
951
952         /* pattern match */
953         prop = RNA_def_property(srna, "pattern_match", PROP_ENUM, PROP_NONE);
954         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
955         RNA_def_property_enum_sdna(prop, NULL, "pattern_match");
956         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
957         RNA_def_property_enum_items(prop, pattern_match_items);
958         RNA_def_property_ui_text(prop, "Pattern Match",
959                                  "Track pattern from given frame when tracking marker to next frame");
960
961         /* margin */
962         prop = RNA_def_property(srna, "margin", PROP_INT, PROP_NONE);
963         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
964         RNA_def_property_int_sdna(prop, NULL, "margin");
965         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
966         RNA_def_property_range(prop, 0, 300);
967         RNA_def_property_ui_text(prop, "Margin", "Distance from image boudary at which marker stops tracking");
968
969         /* tracking algorithm */
970         prop = RNA_def_property(srna, "tracker", PROP_ENUM, PROP_NONE);
971         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
972         RNA_def_property_enum_items(prop, tracker_items);
973         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
974         RNA_def_property_ui_text(prop, "Tracker", "Tracking algorithm to use");
975         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerAlgorithm_update");
976
977         /* pyramid level for pyramid klt tracking */
978         prop = RNA_def_property(srna, "pyramid_levels", PROP_INT, PROP_NONE);
979         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
980         RNA_def_property_int_sdna(prop, NULL, "pyramid_levels");
981         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
982         RNA_def_property_range(prop, 1, 16);
983         RNA_def_property_ui_text(prop, "Pyramid levels", "Number of pyramid levels (increase on blurry footage)");
984         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPyramid_update");
985
986         /* minmal correlation - only used for SAD tracker */
987         prop = RNA_def_property(srna, "correlation_min", PROP_FLOAT, PROP_NONE);
988         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
989         RNA_def_property_float_sdna(prop, NULL, "minimum_correlation");
990         RNA_def_property_range(prop, -1.0f, 1.0f);
991         RNA_def_property_ui_range(prop, -1.0f, 1.0f, 0.1, 3);
992         RNA_def_property_ui_text(prop, "Correlation",
993                                  "Minimal value of correlation between matched pattern and reference "
994                                  "which is still treated as successful tracking");
995
996         /* markers */
997         prop = RNA_def_property(srna, "markers", PROP_COLLECTION, PROP_NONE);
998         RNA_def_property_struct_type(prop, "MovieTrackingMarker");
999         RNA_def_property_collection_sdna(prop, NULL, "markers", "markersnr");
1000         RNA_def_property_ui_text(prop, "Markers", "Collection of markers in track");
1001         rna_def_trackingMarkers(brna, prop);
1002
1003         /* ** channels ** */
1004
1005         /* use_red_channel */
1006         prop = RNA_def_property(srna, "use_red_channel", PROP_BOOLEAN, PROP_NONE);
1007         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_RED);
1008         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1009         RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
1010         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1011
1012         /* use_green_channel */
1013         prop = RNA_def_property(srna, "use_green_channel", PROP_BOOLEAN, PROP_NONE);
1014         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_GREEN);
1015         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1016         RNA_def_property_ui_text(prop, "Use Green Channel", "Use green channel from footage for tracking");
1017         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1018
1019         /* use_blue_channel */
1020         prop = RNA_def_property(srna, "use_blue_channel", PROP_BOOLEAN, PROP_NONE);
1021         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_BLUE);
1022         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1023         RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
1024         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1025
1026         /* preview_grayscale */
1027         prop = RNA_def_property(srna, "use_grayscale_preview", PROP_BOOLEAN, PROP_NONE);
1028         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_PREVIEW_GRAYSCALE);
1029         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1030         RNA_def_property_ui_text(prop, "Grayscale", "Display what the tracking algorithm sees in the preview");
1031         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1032
1033         /* has bundle */
1034         prop = RNA_def_property(srna, "has_bundle", PROP_BOOLEAN, PROP_NONE);
1035         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_HAS_BUNDLE);
1036         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1037         RNA_def_property_ui_text(prop, "Has Bundle", "True if track has a valid bundle");
1038
1039         /* bundle position */
1040         prop = RNA_def_property(srna, "bundle", PROP_FLOAT, PROP_TRANSLATION);
1041         RNA_def_property_array(prop, 3);
1042         RNA_def_property_float_sdna(prop, NULL, "bundle_pos");
1043         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1044         RNA_def_property_ui_text(prop, "Bundle", "Position of bundle reconstructed from this track");
1045         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1046
1047         /* hide */
1048         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1049         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_HIDDEN);
1050         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1051         RNA_def_property_ui_text(prop, "Hide", "Track is hidden");
1052         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1053
1054         /* select */
1055         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1056         RNA_def_property_boolean_funcs(prop, "rna_trackingTrack_select_get", "rna_trackingTrack_select_set");
1057         RNA_def_property_ui_text(prop, "Select", "Track is selected");
1058         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1059
1060         /* select_anchor */
1061         prop = RNA_def_property(srna, "select_anchor", PROP_BOOLEAN, PROP_NONE);
1062         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1063         RNA_def_property_ui_text(prop, "Select Anchor", "Track's anchor point is selected");
1064         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1065
1066         /* select_pattern */
1067         prop = RNA_def_property(srna, "select_pattern", PROP_BOOLEAN, PROP_NONE);
1068         RNA_def_property_boolean_sdna(prop, NULL, "pat_flag", SELECT);
1069         RNA_def_property_ui_text(prop, "Select Pattern", "Track's pattern area is selected");
1070         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1071
1072         /* select_search */
1073         prop = RNA_def_property(srna, "select_search", PROP_BOOLEAN, PROP_NONE);
1074         RNA_def_property_boolean_sdna(prop, NULL, "search_flag", SELECT);
1075         RNA_def_property_ui_text(prop, "Select Search", "Track's search area is selected");
1076         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1077
1078         /* locked */
1079         prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1080         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_LOCKED);
1081         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1082         RNA_def_property_ui_text(prop, "Lock", "Track is locked and all changes to it are disabled");
1083         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1084
1085         /* custom color */
1086         prop = RNA_def_property(srna, "use_custom_color", PROP_BOOLEAN, PROP_NONE);
1087         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_CUSTOMCOLOR);
1088         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1089         RNA_def_property_ui_text(prop, "Custom Color", "Use custom color instead of theme-defined");
1090         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1091
1092         /* color */
1093         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
1094         RNA_def_property_array(prop, 3);
1095         RNA_def_property_range(prop, 0.0f, 1.0f);
1096         RNA_def_property_ui_text(prop, "Color",
1097                                  "Color of the track in the Movie Clip Editor and the 3D viewport after a solve");
1098         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1099
1100         /* average error */
1101         prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1102         RNA_def_property_float_sdna(prop, NULL, "error");
1103         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1104         RNA_def_property_ui_text(prop, "Average Error", "Average error of re-projection");
1105
1106         /* grease pencil */
1107         prop = RNA_def_property(srna, "grease_pencil", PROP_POINTER, PROP_NONE);
1108         RNA_def_property_pointer_sdna(prop, NULL, "gpd");
1109         RNA_def_property_flag(prop, PROP_EDITABLE);
1110         RNA_def_property_struct_type(prop, "GreasePencil");
1111         RNA_def_property_ui_text(prop, "Grease Pencil", "Grease pencil data for this track");
1112         RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, NULL);
1113 }
1114
1115 static void rna_def_trackingStabilization(BlenderRNA *brna)
1116 {
1117         StructRNA *srna;
1118         PropertyRNA *prop;
1119
1120         static EnumPropertyItem filter_items[] = {
1121                 {TRACKING_FILTER_NEAREAST, "NEAREST",   0, "Nearest",   ""},
1122                 {TRACKING_FILTER_BILINEAR, "BILINEAR",   0, "Bilinear",   ""},
1123                 {TRACKING_FILTER_BICUBIC, "BICUBIC", 0, "Bicubic", ""},
1124                 {0, NULL, 0, NULL, NULL}};
1125
1126         srna = RNA_def_struct(brna, "MovieTrackingStabilization", NULL);
1127         RNA_def_struct_path_func(srna, "rna_trackingStabilization_path");
1128         RNA_def_struct_ui_text(srna, "Movie tracking stabilization data", "Match-moving stabilization data for tracking");
1129
1130         /* 2d stabilization */
1131         prop = RNA_def_property(srna, "use_2d_stabilization", PROP_BOOLEAN, PROP_NONE);
1132         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_2D_STABILIZATION);
1133         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1134         RNA_def_property_ui_text(prop, "Use 2D stabilization", "Use 2D stabilization for footage");
1135         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1136
1137         /* tracks */
1138         prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1139         RNA_def_property_collection_funcs(prop, "rna_tracking_stabTracks_begin", "rna_iterator_listbase_next",
1140                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1141                                           NULL, NULL, NULL, NULL);
1142         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1143         RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks used for stabilization");
1144         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1145
1146         /* rotation track */
1147         prop = RNA_def_property(srna, "rotation_track", PROP_POINTER, PROP_NONE);
1148         RNA_def_property_pointer_sdna(prop, NULL, "rot_track");
1149         RNA_def_property_flag(prop, PROP_EDITABLE);
1150         RNA_def_property_ui_text(prop, "Rotation Track", "Track used to compensate rotation");
1151         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
1152
1153         /* active track index */
1154         prop = RNA_def_property(srna, "active_track_index", PROP_INT, PROP_NONE);
1155         RNA_def_property_int_sdna(prop, NULL, "act_track");
1156         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1157         RNA_def_property_int_funcs(prop, "rna_tracking_stabTracks_active_index_get",
1158                                    "rna_tracking_stabTracks_active_index_set",
1159                                    "rna_tracking_stabTracks_active_index_range");
1160         RNA_def_property_ui_text(prop, "Active Track Index", "Index of active track in stabilization tracks list");
1161
1162         /* autoscale */
1163         prop = RNA_def_property(srna, "use_autoscale", PROP_BOOLEAN, PROP_NONE);
1164         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_AUTOSCALE);
1165         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1166         RNA_def_property_ui_text(prop, "Autoscale",
1167                                  "Automatically scale footage to cover unfilled areas when stabilizating");
1168         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1169
1170         /* max scale */
1171         prop = RNA_def_property(srna, "scale_max", PROP_FLOAT, PROP_FACTOR);
1172         RNA_def_property_float_sdna(prop, NULL, "maxscale");
1173         RNA_def_property_range(prop, 0.0f, 10.0f);
1174         RNA_def_property_ui_text(prop, "Maximal Scale", "Limit the amount of automatic scaling");
1175         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1176
1177         /* influence_location */
1178         prop = RNA_def_property(srna, "influence_location", PROP_FLOAT, PROP_FACTOR);
1179         RNA_def_property_float_sdna(prop, NULL, "locinf");
1180         RNA_def_property_range(prop, 0.0f, 1.0f);
1181         RNA_def_property_ui_text(prop, "Location Influence", "Influence of stabilization algorithm on footage location");
1182         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1183
1184         /* influence_scale */
1185         prop = RNA_def_property(srna, "influence_scale", PROP_FLOAT, PROP_FACTOR);
1186         RNA_def_property_float_sdna(prop, NULL, "scaleinf");
1187         RNA_def_property_range(prop, 0.0f, 1.0f);
1188         RNA_def_property_ui_text(prop, "Scale Influence", "Influence of stabilization algorithm on footage scale");
1189         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1190
1191         /* use_stabilize_rotation */
1192         prop = RNA_def_property(srna, "use_stabilize_rotation", PROP_BOOLEAN, PROP_NONE);
1193         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1194         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_STABILIZE_ROTATION);
1195         RNA_def_property_ui_text(prop, "Stabilize Rotation", "Stabilize horizon line on the shot");
1196         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1197
1198         /* influence_rotation */
1199         prop = RNA_def_property(srna, "influence_rotation", PROP_FLOAT, PROP_FACTOR);
1200         RNA_def_property_float_sdna(prop, NULL, "rotinf");
1201         RNA_def_property_range(prop, 0.0f, 1.0f);
1202         RNA_def_property_ui_text(prop, "Rotation Influence", "Influence of stabilization algorithm on footage rotation");
1203         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1204
1205         /* filter */
1206         prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
1207         RNA_def_property_enum_sdna(prop, NULL, "filter");
1208         RNA_def_property_enum_items(prop, filter_items);
1209         RNA_def_property_ui_text(prop, "Filter", "Method to use to filter stabilization");
1210         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
1211 }
1212
1213 static void rna_def_reconstructedCamera(BlenderRNA *brna)
1214 {
1215         StructRNA *srna;
1216         PropertyRNA *prop;
1217
1218         srna = RNA_def_struct(brna, "MovieReconstructedCamera", NULL);
1219         RNA_def_struct_ui_text(srna, "Movie tracking reconstructed camera data",
1220                                "Match-moving reconstructed camera data from tracker");
1221
1222         /* frame */
1223         prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
1224         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1225         RNA_def_property_int_sdna(prop, NULL, "framenr");
1226         RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
1227
1228         /* matrix */
1229         prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
1230         RNA_def_property_float_sdna(prop, NULL, "mat");
1231         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1232         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1233         RNA_def_property_ui_text(prop, "Matrix", "Worldspace transformation matrix");
1234
1235         /* average_error */
1236         prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1237         RNA_def_property_float_sdna(prop, NULL, "error");
1238         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1239         RNA_def_property_ui_text(prop, "Average Error", "Average error of resonctruction");
1240 }
1241
1242 static void rna_def_trackingReconstruction(BlenderRNA *brna)
1243 {
1244         StructRNA *srna;
1245         PropertyRNA *prop;
1246
1247         rna_def_reconstructedCamera(brna);
1248
1249         srna = RNA_def_struct(brna, "MovieTrackingReconstruction", NULL);
1250         RNA_def_struct_ui_text(srna, "Movie tracking reconstruction data",
1251                                "Match-moving reconstruction data from tracker");
1252
1253         /* is_valid */
1254         prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
1255         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1256         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_RECONSTRUCTED);
1257         RNA_def_property_ui_text(prop, "Reconstructed", "Is tracking data contains valid reconstruction information");
1258
1259         /* average_error */
1260         prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1261         RNA_def_property_float_sdna(prop, NULL, "error");
1262         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1263         RNA_def_property_ui_text(prop, "Average Error", "Average error of resonctruction");
1264
1265         /* cameras */
1266         prop = RNA_def_property(srna, "cameras", PROP_COLLECTION, PROP_NONE);
1267         RNA_def_property_struct_type(prop, "MovieReconstructedCamera");
1268         RNA_def_property_collection_sdna(prop, NULL, "cameras", "camnr");
1269         RNA_def_property_ui_text(prop, "Cameras", "Collection of solved cameras");
1270 }
1271
1272 static void rna_def_trackingTracks(BlenderRNA *brna)
1273 {
1274         StructRNA *srna;
1275         FunctionRNA *func;
1276         PropertyRNA *prop;
1277
1278         srna = RNA_def_struct(brna, "MovieTrackingTracks", NULL);
1279         RNA_def_struct_sdna(srna, "MovieTracking");
1280         RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
1281
1282         func = RNA_def_function(srna, "add", "rna_trackingTracks_add");
1283         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1284         RNA_def_function_ui_description(func, "Add a number of tracks to this movie clip");
1285         RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to add tracks on", MINFRAME, MAXFRAME);
1286         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of tracks to add to the movie clip", 0, INT_MAX);
1287
1288         /* active track */
1289         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1290         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1291         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", NULL, NULL);
1292         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
1293         RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
1294 }
1295
1296 static void rna_def_trackingObjectTracks(BlenderRNA *brna)
1297 {
1298         StructRNA *srna;
1299         FunctionRNA *func;
1300         PropertyRNA *prop;
1301
1302         srna = RNA_def_struct(brna, "MovieTrackingObjectTracks", NULL);
1303         RNA_def_struct_sdna(srna, "MovieTrackingObject");
1304         RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
1305
1306         func = RNA_def_function(srna, "add", "rna_trackingObject_tracks_add");
1307         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1308         RNA_def_function_ui_description(func, "Add a number of tracks to this movie clip");
1309         RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to add tracks on", MINFRAME, MAXFRAME);
1310         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of tracks to add to the movie clip", 0, INT_MAX);
1311
1312         /* active track */
1313         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1314         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1315         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", NULL, NULL);
1316         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
1317         RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
1318 }
1319
1320 static void rna_def_trackingObject(BlenderRNA *brna)
1321 {
1322         StructRNA *srna;
1323         PropertyRNA *prop;
1324
1325         srna = RNA_def_struct(brna, "MovieTrackingObject", NULL);
1326         RNA_def_struct_ui_text(srna, "Movie tracking object data", "Match-moving object tracking and reconstruction data");
1327
1328         /* name */
1329         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1330         RNA_def_property_ui_text(prop, "Name", "Unique name of object");
1331         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingObject_name_set");
1332         RNA_def_property_string_maxlength(prop, MAX_ID_NAME-2);
1333         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
1334         RNA_def_struct_name_property(srna, prop);
1335
1336         /* is_camera */
1337         prop = RNA_def_property(srna, "is_camera", PROP_BOOLEAN, PROP_NONE);
1338         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1339         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_OBJECT_CAMERA);
1340         RNA_def_property_ui_text(prop, "Camera", "Object is used for camera tracking");
1341         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1342
1343         /* tracks */
1344         prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1345         RNA_def_property_collection_funcs(prop, "rna_trackingObject_tracks_begin", "rna_iterator_listbase_next",
1346                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1347                                           NULL, NULL, NULL, NULL);
1348         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1349         RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks in this tracking data object");
1350         RNA_def_property_srna(prop, "MovieTrackingObjectTracks");
1351
1352         /* reconstruction */
1353         prop = RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
1354         RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
1355         RNA_def_property_pointer_funcs(prop, "rna_trackingObject_reconstruction_get", NULL, NULL, NULL);
1356
1357         /* scale */
1358         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
1359         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1360         RNA_def_property_float_sdna(prop, NULL, "scale");
1361         RNA_def_property_range(prop, 0.0001f, 10000.0f);
1362         RNA_def_property_ui_range(prop, 0.0001f, 10000.0, 1, 4);
1363         RNA_def_property_float_default(prop, 1.0f);
1364         RNA_def_property_ui_text(prop, "Scale", "Scale of object solution in camera space");
1365         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_trackingObject_flushUpdate");
1366 }
1367
1368 static void rna_def_trackingObjects(BlenderRNA *brna, PropertyRNA *cprop)
1369 {
1370         StructRNA *srna;
1371         PropertyRNA *prop;
1372
1373         FunctionRNA *func;
1374         PropertyRNA *parm;
1375
1376         RNA_def_property_srna(cprop, "MovieTrackingObjects");
1377         srna = RNA_def_struct(brna, "MovieTrackingObjects", NULL);
1378         RNA_def_struct_sdna(srna, "MovieTracking");
1379         RNA_def_struct_ui_text(srna, "Movie Objects", "Collection of movie trackingobjects");
1380
1381         func = RNA_def_function(srna, "new", "rna_trackingObject_new");
1382         RNA_def_function_ui_description(func, "Add tracking object to this movie clip");
1383         parm = RNA_def_string(func, "name", "", 0, "", "Name of new object");
1384         RNA_def_property_flag(parm, PROP_REQUIRED);
1385         parm = RNA_def_pointer(func, "object", "MovieTrackingObject", "", "New motion tracking object");
1386         RNA_def_function_return(func, parm);
1387
1388         func = RNA_def_function(srna, "remove", "rna_trackingObject_remove");
1389         RNA_def_function_ui_description(func, "Remove tracking object from this movie clip");
1390         RNA_def_pointer(func, "object", "MovieTrackingObject", "", "Motion tracking object to be removed");
1391
1392         /* active object */
1393         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1394         RNA_def_property_struct_type(prop, "MovieTrackingObject");
1395         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_object_get",
1396                                        "rna_tracking_active_object_set", NULL, NULL);
1397         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
1398         RNA_def_property_ui_text(prop, "Active Object", "Active object in this tracking data object");
1399 }
1400
1401 static void rna_def_tracking(BlenderRNA *brna)
1402 {
1403         StructRNA *srna;
1404         PropertyRNA *prop;
1405
1406         rna_def_trackingSettings(brna);
1407         rna_def_trackingCamera(brna);
1408         rna_def_trackingTrack(brna);
1409         rna_def_trackingTracks(brna);
1410         rna_def_trackingObjectTracks(brna);
1411         rna_def_trackingStabilization(brna);
1412         rna_def_trackingReconstruction(brna);
1413         rna_def_trackingObject(brna);
1414
1415         srna = RNA_def_struct(brna, "MovieTracking", NULL);
1416         RNA_def_struct_path_func(srna, "rna_tracking_path");
1417         RNA_def_struct_ui_text(srna, "Movie tracking data", "Match-moving data for tracking");
1418
1419         /* settings */
1420         prop = RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
1421         RNA_def_property_struct_type(prop, "MovieTrackingSettings");
1422
1423         /* camera properties */
1424         prop = RNA_def_property(srna, "camera", PROP_POINTER, PROP_NONE);
1425         RNA_def_property_struct_type(prop, "MovieTrackingCamera");
1426
1427         /* tracks */
1428         prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1429         RNA_def_property_collection_funcs(prop, "rna_trackingTracks_begin", "rna_iterator_listbase_next",
1430                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1431                                           NULL, NULL, NULL, NULL);
1432         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1433         RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks in this tracking data object");
1434         RNA_def_property_srna(prop, "MovieTrackingTracks");
1435
1436         /* stabilization */
1437         prop = RNA_def_property(srna, "stabilization", PROP_POINTER, PROP_NONE);
1438         RNA_def_property_struct_type(prop, "MovieTrackingStabilization");
1439
1440         /* reconstruction */
1441         prop = RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
1442         RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
1443
1444         /* objects */
1445         prop = RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
1446         RNA_def_property_collection_funcs(prop, "rna_trackingObjects_begin", "rna_iterator_listbase_next",
1447                                           "rna_iterator_listbase_end", "rna_iterator_listbase_get",
1448                                           NULL, NULL, NULL, NULL);
1449         RNA_def_property_struct_type(prop, "MovieTrackingObject");
1450         RNA_def_property_ui_text(prop, "Objects", "Collection of objects in this tracking data object");
1451         rna_def_trackingObjects(brna, prop);
1452
1453         /* active object index */
1454         prop = RNA_def_property(srna, "active_object_index", PROP_INT, PROP_NONE);
1455         RNA_def_property_int_sdna(prop, NULL, "objectnr");
1456         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1457         RNA_def_property_int_funcs(prop, "rna_tracking_active_object_index_get", "rna_tracking_active_object_index_set",
1458                                    "rna_tracking_active_object_index_range");
1459         RNA_def_property_ui_text(prop, "Active Object Index", "Index of active object");
1460         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
1461 }
1462
1463 void RNA_def_tracking(BlenderRNA *brna)
1464 {
1465         rna_def_tracking(brna);
1466 }
1467
1468 #endif