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