Merged changes in the trunk up to revision 42116.
[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 "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_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
57 {
58         MovieClip *clip= (MovieClip*)ptr->id.data;
59         rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
60 }
61
62 static void rna_tracking_tracks_add(MovieTracking *tracking, int frame, int number)
63 {
64         int a;
65
66         for(a= 0; a<number; a++)
67                 BKE_tracking_add_track(tracking, 0, 0, frame, 1, 1);
68
69         WM_main_add_notifier(NC_MOVIECLIP|NA_EDITED, NULL);
70 }
71
72 static PointerRNA rna_tracking_active_track_get(PointerRNA *ptr)
73 {
74         MovieClip *clip= (MovieClip*)ptr->id.data;
75
76         return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingTrack, clip->tracking.act_track);
77 }
78
79 static void rna_tracking_active_track_set(PointerRNA *ptr, PointerRNA value)
80 {
81         MovieClip *clip= (MovieClip*)ptr->id.data;
82         MovieTrackingTrack *track= (MovieTrackingTrack *)value.data;
83         int index= BLI_findindex(&clip->tracking.tracks, track);
84
85         if(index>=0) clip->tracking.act_track= track;
86         else clip->tracking.act_track= NULL;
87 }
88
89 void rna_trackingTrack_name_set(PointerRNA *ptr, const char *value)
90 {
91         MovieClip *clip= (MovieClip *)ptr->id.data;
92         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
93         BLI_strncpy(track->name, value, sizeof(track->name));
94
95         BKE_track_unique_name(&clip->tracking, track);
96 }
97
98 static int rna_trackingTrack_select_get(PointerRNA *ptr)
99 {
100         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
101
102         return TRACK_SELECTED(track);
103 }
104
105 static void rna_trackingTrack_select_set(PointerRNA *ptr, int value)
106 {
107         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
108
109         if(value) {
110                 track->flag|= SELECT;
111                 track->pat_flag|= SELECT;
112                 track->search_flag|= SELECT;
113         }
114         else {
115                 track->flag&= ~SELECT;
116                 track->pat_flag&= ~SELECT;
117                 track->search_flag&= ~SELECT;
118         }
119 }
120
121 static void rna_tracking_trackerPattern_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
122 {
123         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
124
125         BKE_tracking_clamp_track(track, CLAMP_PAT_DIM);
126 }
127
128 static void rna_tracking_trackerSearch_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
129 {
130         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
131
132         BKE_tracking_clamp_track(track, CLAMP_SEARCH_DIM);
133 }
134
135 static void rna_tracking_trackerAlgorithm_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
136 {
137         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
138
139         if(track->tracker==TRACKER_KLT)
140           BKE_tracking_clamp_track(track, CLAMP_PYRAMID_LEVELS);
141         else
142           BKE_tracking_clamp_track(track, CLAMP_SEARCH_DIM);
143 }
144
145 static void rna_tracking_trackerPyramid_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
146 {
147         MovieTrackingTrack *track= (MovieTrackingTrack *)ptr->data;
148
149         BKE_tracking_clamp_track(track, CLAMP_PYRAMID_LEVELS);
150 }
151
152 static float rna_trackingCamera_focal_mm_get(PointerRNA *ptr)
153 {
154         MovieClip *clip= (MovieClip*)ptr->id.data;
155         MovieTrackingCamera *camera= &clip->tracking.camera;
156         float val= camera->focal;
157
158         if(clip->lastsize[0])
159                 val= val*camera->sensor_width/(float)clip->lastsize[0];
160
161         return val;
162 }
163
164 static void rna_trackingCamera_focal_mm_set(PointerRNA *ptr, float value)
165 {
166         MovieClip *clip= (MovieClip*)ptr->id.data;
167         MovieTrackingCamera *camera= &clip->tracking.camera;
168
169         if(clip->lastsize[0])
170                 value= clip->lastsize[0]*value/camera->sensor_width;
171
172         if(value>=0.0001)
173                 camera->focal= value;
174 }
175
176 static int rna_track_2d_stabilization(CollectionPropertyIterator *UNUSED(iter), void *data)
177 {
178         MovieTrackingTrack *track= (MovieTrackingTrack*)data;
179
180         if((track->flag&TRACK_USE_2D_STAB)==0)
181                 return 1;
182
183         return 0;
184 }
185
186 static void rna_tracking_stabTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
187 {
188         MovieClip *clip= (MovieClip*)ptr->id.data;
189         rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization);
190 }
191
192 static int rna_tracking_stabTracks_active_index_get(PointerRNA *ptr)
193 {
194         MovieClip *clip= (MovieClip*)ptr->id.data;
195         return clip->tracking.stabilization.act_track;
196 }
197
198 static void rna_tracking_stabTracks_active_index_set(PointerRNA *ptr, int value)
199 {
200         MovieClip *clip= (MovieClip*)ptr->id.data;
201         clip->tracking.stabilization.act_track= value;
202 }
203
204 static void rna_tracking_stabTracks_active_index_range(PointerRNA *ptr, int *min, int *max)
205 {
206         MovieClip *clip= (MovieClip*)ptr->id.data;
207
208         *min= 0;
209         *max= clip->tracking.stabilization.tot_track-1;
210         *max= MAX2(0, *max);
211 }
212
213 static void rna_tracking_flushUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
214 {
215         MovieClip *clip= (MovieClip*)ptr->id.data;
216         MovieTrackingStabilization *stab= &clip->tracking.stabilization;
217
218         stab->ok= 0;
219
220         nodeUpdateID(scene->nodetree, &clip->id);
221
222         WM_main_add_notifier(NC_SCENE|ND_NODES, NULL);
223         DAG_id_tag_update(&clip->id, 0);
224 }
225
226 /* API */
227
228 static MovieTrackingMarker *rna_trackingTrack_marker_find_frame(MovieTrackingTrack *track, int framenr)
229 {
230         return BKE_tracking_get_marker(track, framenr);
231 }
232
233 #else
234
235 static int rna_matrix_dimsize_4x4[]= {4, 4};
236
237 static void rna_def_trackingSettings(BlenderRNA *brna)
238 {
239         StructRNA *srna;
240         PropertyRNA *prop;
241
242         static EnumPropertyItem speed_items[] = {
243                 {0, "FASTEST", 0, "Fastest", "Track as fast as it's possible"},
244             {TRACKING_SPEED_DOUBLE, "DOUBLE", 0, "Double", "Track with double speed"},
245                 {TRACKING_SPEED_REALTIME, "REALTIME", 0, "Realtime", "Track with realtime speed"},
246                 {TRACKING_SPEED_HALF, "HALF", 0, "Half", "Track with half of realtime speed"},
247                 {TRACKING_SPEED_QUARTER, "QUARTER", 0, "Quarter", "Track with quarter of realtime speed"},
248                 {0, NULL, 0, NULL, NULL}};
249
250         static EnumPropertyItem cleanup_items[] = {
251                 {TRACKING_CLEAN_SELECT, "SELECT", 0, "Select", "Select unclean tracks"},
252                 {TRACKING_CLEAN_DELETE_TRACK, "DELETE_TRACK", 0, "Delete Track", "Delete unclean tracks"},
253                 {TRACKING_CLEAN_DELETE_SEGMENT, "DELETE_SEGMENTS", 0, "Delete Segments", "Delete unclean segments of tracks"},
254                 {0, NULL, 0, NULL, NULL}
255         };
256
257         static EnumPropertyItem refine_items[] = {
258                 {0, "NONE", 0, "Nothing", "Do not refine camera intrinsics"},
259                 {REFINE_FOCAL_LENGTH, "FOCAL_LENGTH", 0, "Focal Length", "Refine focal length"},
260                 {REFINE_FOCAL_LENGTH|
261                  REFINE_PRINCIPAL_POINT, "FOCAL_LENGTH_PRINCIPAL_POINT", 0, "Focal Length, Optical Center", "Refine focal length and optical center"},
262                 {REFINE_FOCAL_LENGTH|
263                  REFINE_PRINCIPAL_POINT|
264                  REFINE_RADIAL_DISTORTION_K1|
265                  REFINE_RADIAL_DISTORTION_K2,
266                  "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"},
267                 {REFINE_FOCAL_LENGTH|
268                  REFINE_RADIAL_DISTORTION_K1|
269                  REFINE_RADIAL_DISTORTION_K2, "FOCAL_LENGTH_RADIAL_K1_K2", 0, "Focal length, K1. K2", "Refine focal length and radial distortion K1 and K2"},
270                 {REFINE_FOCAL_LENGTH|REFINE_RADIAL_DISTORTION_K1, "FOCAL_LENGTH_RADIAL_K1", 0, "Focal length, K1", "Refine focal length and radial distortion K1"},
271                 {0, NULL, 0, NULL, NULL}
272         };
273
274         srna= RNA_def_struct(brna, "MovieTrackingSettings", NULL);
275         RNA_def_struct_ui_text(srna, "Movie tracking settings", "Match moving settings");
276
277         /* speed */
278         prop= RNA_def_property(srna, "speed", PROP_ENUM, PROP_NONE);
279         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
280         RNA_def_property_enum_items(prop, speed_items);
281         RNA_def_property_ui_text(prop, "Speed", "Limit speed of tracking to make visual feedback easier (this does not affect the tracking quality)");
282
283         /* limit frames */
284         prop= RNA_def_property(srna, "frames_limit", PROP_INT, PROP_NONE);
285         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
286         RNA_def_property_int_sdna(prop, NULL, "frames_limit");
287         RNA_def_property_range(prop, 0, SHRT_MAX);
288         RNA_def_property_ui_text(prop, "Frames Limit", "Every tracking cycle, this amount of frames are tracked");
289
290         /* adjust frames */
291         prop= RNA_def_property(srna, "frames_adjust", PROP_INT, PROP_NONE);
292         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
293         RNA_def_property_int_sdna(prop, NULL, "adjframes");
294         RNA_def_property_range(prop, 0, INT_MAX);
295         RNA_def_property_ui_text(prop, "Adjust Frames", "Automatically re-adjust marker position using position on each N frames. 0 means only keyframed position is used");
296
297         /* margin */
298         prop= RNA_def_property(srna, "margin", PROP_INT, PROP_NONE);
299         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
300         RNA_def_property_int_sdna(prop, NULL, "margin");
301         RNA_def_property_range(prop, 0, 300);
302         RNA_def_property_ui_text(prop, "Margin", "Distance from image boudary at which marker stops tracking");
303
304         /* keyframe_a */
305         prop= RNA_def_property(srna, "keyframe_a", PROP_INT, PROP_NONE);
306         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
307         RNA_def_property_int_sdna(prop, NULL, "keyframe1");
308         RNA_def_property_ui_text(prop, "Keyframe A", "First keyframe used for reconstruction initialization");
309
310         /* keyframe_b */
311         prop= RNA_def_property(srna, "keyframe_b", PROP_INT, PROP_NONE);
312         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
313         RNA_def_property_int_sdna(prop, NULL, "keyframe2");
314         RNA_def_property_ui_text(prop, "Keyframe B", "Second keyframe used for reconstruction initialization");
315
316         /* intrinsics refinement during bundle adjustment */
317         prop= RNA_def_property(srna, "refine_intrinsics", PROP_ENUM, PROP_NONE);
318         RNA_def_property_enum_sdna(prop, NULL, "refine_camera_intrinsics");
319         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
320         RNA_def_property_enum_items(prop, refine_items);
321         RNA_def_property_ui_text(prop, "Refine", "Refine intrinsics during camera solving");
322
323         /* tool settings */
324
325         /* distance */
326         prop= RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
327         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
328         RNA_def_property_float_sdna(prop, NULL, "dist");
329         RNA_def_property_ui_text(prop, "Distance", "Distance between two bundles used for scene scaling");
330
331         /* frames count */
332         prop= RNA_def_property(srna, "clean_frames", PROP_INT, PROP_NONE);
333         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
334         RNA_def_property_int_sdna(prop, NULL, "clean_frames");
335         RNA_def_property_range(prop, 0, INT_MAX);
336         RNA_def_property_ui_text(prop, "Tracked Frames", "Effect on tracks which are tracked less than the specified amount of frames");
337
338         /* reprojection error */
339         prop= RNA_def_property(srna, "clean_error", PROP_FLOAT, PROP_NONE);
340         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
341         RNA_def_property_float_sdna(prop, NULL, "clean_error");
342         RNA_def_property_range(prop, 0, FLT_MAX);
343         RNA_def_property_ui_text(prop, "Reprojection Error", "Effect on tracks which have a larger reprojection error");
344
345         /* cleanup action */
346         prop= RNA_def_property(srna, "clean_action", PROP_ENUM, PROP_NONE);
347         RNA_def_property_enum_sdna(prop, NULL, "clean_action");
348         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
349         RNA_def_property_enum_items(prop, cleanup_items);
350         RNA_def_property_ui_text(prop, "Action", "Cleanup action to execute");
351 }
352
353 static void rna_def_trackingCamera(BlenderRNA *brna)
354 {
355         StructRNA *srna;
356         PropertyRNA *prop;
357
358         static EnumPropertyItem camera_units_items[] = {
359                 {CAMERA_UNITS_PX, "PIXELS", 0, "px", "Use pixels for units of focal length"},
360                 {CAMERA_UNITS_MM, "MILLIMETERS", 0, "mm", "Use millimeters for units of focal length"},
361                 {0, NULL, 0, NULL, NULL}};
362
363         srna= RNA_def_struct(brna, "MovieTrackingCamera", NULL);
364         RNA_def_struct_ui_text(srna, "Movie tracking camera data", "Match-moving camera data for tracking");
365
366         /* Sensor */
367         prop= RNA_def_property(srna, "sensor_width", PROP_FLOAT, PROP_NONE);
368         RNA_def_property_float_sdna(prop, NULL, "sensor_width");
369         RNA_def_property_range(prop, 0.0f, 500.0f);
370         RNA_def_property_ui_text(prop, "Sensor", "Width of CCD sensor in millimeters");
371         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
372
373         /* Focal Length */
374         prop= RNA_def_property(srna, "focal_length", PROP_FLOAT, PROP_NONE);
375         RNA_def_property_float_sdna(prop, NULL, "focal");
376         RNA_def_property_range(prop, 0.0001f, 5000.0f);
377         RNA_def_property_float_funcs(prop, "rna_trackingCamera_focal_mm_get", "rna_trackingCamera_focal_mm_set", NULL);
378         RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
379         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
380
381         /* Focal Length in pixels */
382         prop= RNA_def_property(srna, "focal_length_pixels", PROP_FLOAT, PROP_NONE);
383         RNA_def_property_float_sdna(prop, NULL, "focal");
384         RNA_def_property_range(prop, 0.0f, 5000.0f);
385         RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
386         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
387
388         /* Units */
389         prop= RNA_def_property(srna, "units", PROP_ENUM, PROP_NONE);
390         RNA_def_property_enum_sdna(prop, NULL, "units");
391         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
392         RNA_def_property_enum_items(prop, camera_units_items);
393         RNA_def_property_ui_text(prop, "Units", "Units used for camera focal length");
394
395         /* Principal Point */
396         prop= RNA_def_property(srna, "principal", PROP_FLOAT, PROP_NONE);
397         RNA_def_property_array(prop, 2);
398         RNA_def_property_float_sdna(prop, NULL, "principal");
399         RNA_def_property_ui_text(prop, "Principal Point", "Optical center of lens");
400         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
401
402         /* Radial distortion parameters */
403         prop= RNA_def_property(srna, "k1", PROP_FLOAT, PROP_NONE);
404         RNA_def_property_float_sdna(prop, NULL, "k1");
405         RNA_def_property_ui_range(prop, -10, 10, .1, 3);
406         RNA_def_property_ui_text(prop, "K1", "First coefficient of third order polynomial radial distortion");
407         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
408
409         prop= RNA_def_property(srna, "k2", PROP_FLOAT, PROP_NONE);
410         RNA_def_property_float_sdna(prop, NULL, "k2");
411         RNA_def_property_ui_range(prop, -10, 10, .1, 3);
412         RNA_def_property_ui_text(prop, "K2", "Second coefficient of third order polynomial radial distortion");
413         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
414
415         prop= RNA_def_property(srna, "k3", PROP_FLOAT, PROP_NONE);
416         RNA_def_property_float_sdna(prop, NULL, "k3");
417         RNA_def_property_ui_range(prop, -10, 10, .1, 3);
418         RNA_def_property_ui_text(prop, "K3", "Third coefficient of third order polynomial radial distortion");
419         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
420
421         /* pixel aspect */
422         prop= RNA_def_property(srna, "pixel_aspect", PROP_FLOAT, PROP_XYZ);
423         RNA_def_property_float_sdna(prop, NULL, "pixel_aspect");
424         RNA_def_property_range(prop, 0.1f, 5000.0f);
425         RNA_def_property_ui_range(prop, 0.1f, 5000.0f, 1, 2);
426         RNA_def_property_ui_text(prop, "Pixel Aspect Ratio", "Pixel aspect ratio");
427         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
428 }
429
430 static void rna_def_trackingMarker(BlenderRNA *brna)
431 {
432         StructRNA *srna;
433         PropertyRNA *prop;
434
435         srna= RNA_def_struct(brna, "MovieTrackingMarker", NULL);
436         RNA_def_struct_ui_text(srna, "Movie tracking marker data", "Match-moving marker data for tracking");
437
438         /* position */
439         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
440         RNA_def_property_array(prop, 2);
441         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 5);
442         RNA_def_property_float_sdna(prop, NULL, "pos");
443         RNA_def_property_ui_text(prop, "Position", "Marker position at frame in normalized coordinates");
444         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
445
446         /* frame */
447         prop= RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
448         RNA_def_property_clear_flag(prop, PROP_EDITABLE);       /* can't be safty edited for now, need to re-sort markers array after change */
449         RNA_def_property_int_sdna(prop, NULL, "framenr");
450         RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
451         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
452
453         /* enable */
454         prop= RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
455         RNA_def_property_boolean_sdna(prop, NULL, "flag", MARKER_DISABLED);
456         RNA_def_property_ui_text(prop, "Mode", "Is marker muted for current frame");
457         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
458 }
459
460 static void rna_def_trackingTrack(BlenderRNA *brna)
461 {
462         StructRNA *srna;
463         PropertyRNA *prop;
464
465         FunctionRNA *func;
466         PropertyRNA *parm;
467
468         static EnumPropertyItem tracker_items[] = {
469                 {TRACKER_KLT, "KLT", 0, "KLT", "Kanade–Lucas–Tomasi tracker which works with most of video clips, a bit slower than SAD"},
470                 {TRACKER_SAD, "SAD", 0, "SAD", "Sum of Absolute Differences tracker which can be used when MLT tracker fails"},
471                 {0, NULL, 0, NULL, NULL}};
472
473         rna_def_trackingMarker(brna);
474
475         srna= RNA_def_struct(brna, "MovieTrackingTrack", NULL);
476         RNA_def_struct_ui_text(srna, "Movie tracking track data", "Match-moving track data for tracking");
477         RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
478
479         /* name */
480         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
481         RNA_def_property_ui_text(prop, "Name", "Unique name of track");
482         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingTrack_name_set");
483         RNA_def_property_string_maxlength(prop, MAX_ID_NAME);
484         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, NULL);
485         RNA_def_struct_name_property(srna, prop);
486
487         /* Pattern */
488         prop= RNA_def_property(srna, "pattern_min", PROP_FLOAT, PROP_TRANSLATION);
489         RNA_def_property_array(prop, 2);
490         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 5);
491         RNA_def_property_float_sdna(prop, NULL, "pat_min");
492         RNA_def_property_ui_text(prop, "Pattern Min", "Left-bottom corner of pattern area in normalized coordinates relative to marker position");
493         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPattern_update");
494
495         prop= RNA_def_property(srna, "pattern_max", PROP_FLOAT, PROP_TRANSLATION);
496         RNA_def_property_array(prop, 2);
497         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 5);
498         RNA_def_property_float_sdna(prop, NULL, "pat_max");
499         RNA_def_property_ui_text(prop, "Pattern Max", "Right-bottom corner of pattern area in normalized coordinates relative to marker position");
500         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPattern_update");
501
502         /* Search */
503         prop= RNA_def_property(srna, "search_min", PROP_FLOAT, PROP_TRANSLATION);
504         RNA_def_property_array(prop, 2);
505         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 5);
506         RNA_def_property_float_sdna(prop, NULL, "search_min");
507         RNA_def_property_ui_text(prop, "Search Min", "Left-bottom corner of search area in normalized coordinates relative to marker position");
508         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerSearch_update");
509
510         prop= RNA_def_property(srna, "search_max", PROP_FLOAT, PROP_TRANSLATION);
511         RNA_def_property_array(prop, 2);
512         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 5);
513         RNA_def_property_float_sdna(prop, NULL, "search_max");
514         RNA_def_property_ui_text(prop, "Search Max", "Right-bottom corner of search area in normalized coordinates relative to marker position");
515         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerSearch_update");
516
517         /* tracking algorithm */
518         prop= RNA_def_property(srna, "tracker", PROP_ENUM, PROP_NONE);
519         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
520         RNA_def_property_enum_items(prop, tracker_items);
521         RNA_def_property_ui_text(prop, "Tracker", "Tracking algorithm to use");
522         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerAlgorithm_update");
523
524         /* pyramid level for pyramid klt tracking */
525         prop= RNA_def_property(srna, "pyramid_levels", PROP_INT, PROP_NONE);
526         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
527         RNA_def_property_int_sdna(prop, NULL, "pyramid_levels");
528         RNA_def_property_range(prop, 1, 16);
529         RNA_def_property_ui_text(prop, "Pyramid levels", "Number of pyramid levels (increase on blurry footage)");
530         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_trackerPyramid_update");
531
532         /* minmal correlation - only used for SAD tracker */
533         prop= RNA_def_property(srna, "correlation_min", PROP_FLOAT, PROP_NONE);
534         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
535         RNA_def_property_float_sdna(prop, NULL, "minimum_correlation");
536         RNA_def_property_range(prop, -1.0f, 1.0f);
537         RNA_def_property_ui_range(prop, -1.0f, 1.0f, 0.1, 3);
538         RNA_def_property_ui_text(prop, "Correlation", "Minimal value of correlation between mathed pattern and reference which is still treated as successful tracking");
539
540         /* markers */
541         prop= RNA_def_property(srna, "markers", PROP_COLLECTION, PROP_NONE);
542         RNA_def_property_struct_type(prop, "MovieTrackingMarker");
543         RNA_def_property_collection_sdna(prop, NULL, "markers", "markersnr");
544         RNA_def_property_ui_text(prop, "Markers", "Collection of markers in track");
545
546         /* ** channels ** */
547
548         /* use_red_channel */
549         prop= RNA_def_property(srna, "use_red_channel", PROP_BOOLEAN, PROP_NONE);
550         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_RED);
551         RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
552         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
553
554         /* use_green_channel */
555         prop= RNA_def_property(srna, "use_green_channel", PROP_BOOLEAN, PROP_NONE);
556         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_GREEN);
557         RNA_def_property_ui_text(prop, "Use Green Channel", "Use green channel from footage for tracking");
558         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
559
560         /* use_blue_channel */
561         prop= RNA_def_property(srna, "use_blue_channel", PROP_BOOLEAN, PROP_NONE);
562         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", TRACK_DISABLE_BLUE);
563         RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
564         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
565
566         /* has bundle */
567         prop= RNA_def_property(srna, "has_bundle", PROP_BOOLEAN, PROP_NONE);
568         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_HAS_BUNDLE);
569         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
570         RNA_def_property_ui_text(prop, "Has Bundle", "True if track has a valid bundle");
571
572         /* bundle position */
573         prop= RNA_def_property(srna, "bundle", PROP_FLOAT, PROP_TRANSLATION);
574         RNA_def_property_array(prop, 3);
575         RNA_def_property_float_sdna(prop, NULL, "bundle_pos");
576         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
577         RNA_def_property_ui_text(prop, "Bundle", "Position of bundle reconstructed from this track");
578
579         /* hide */
580         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
581         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_HIDDEN);
582         RNA_def_property_ui_text(prop, "Hide", "Track is hidden");
583         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
584
585         /* select */
586         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
587         RNA_def_property_boolean_funcs(prop, "rna_trackingTrack_select_get", "rna_trackingTrack_select_set");
588         RNA_def_property_ui_text(prop, "Select", "Track is selected");
589         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
590
591         /* select_anchor */
592         prop= RNA_def_property(srna, "select_anchor", PROP_BOOLEAN, PROP_NONE);
593         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
594         RNA_def_property_ui_text(prop, "Select Anchor", "Track's anchor point is selected");
595         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
596
597         /* select_pattern */
598         prop= RNA_def_property(srna, "select_pattern", PROP_BOOLEAN, PROP_NONE);
599         RNA_def_property_boolean_sdna(prop, NULL, "pat_flag", SELECT);
600         RNA_def_property_ui_text(prop, "Select Pattern", "Track's pattern area is selected");
601         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
602
603         /* select_search */
604         prop= RNA_def_property(srna, "select_search", PROP_BOOLEAN, PROP_NONE);
605         RNA_def_property_boolean_sdna(prop, NULL, "search_flag", SELECT);
606         RNA_def_property_ui_text(prop, "Select Search", "Track's search area is selected");
607         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
608
609         /* locked */
610         prop= RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
611         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_LOCKED);
612         RNA_def_property_ui_text(prop, "Lock", "Track is locked and all changes to it are disabled");
613         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
614
615         /* custom color */
616         prop= RNA_def_property(srna, "use_custom_color", PROP_BOOLEAN, PROP_NONE);
617         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACK_CUSTOMCOLOR);
618         RNA_def_property_ui_text(prop, "Custom Color", "Use custom color instead of theme-defined");
619         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
620
621         /* color */
622         prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
623         RNA_def_property_array(prop, 3);
624         RNA_def_property_range(prop, 0.0f, 1.0f);
625         RNA_def_property_ui_text(prop, "Color", "Color of the track in the Movie Track Editor and the 3D viewport after a solve");
626         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, NULL);
627
628         /* average error */
629         prop= RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
630         RNA_def_property_float_sdna(prop, NULL, "error");
631         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
632         RNA_def_property_ui_text(prop, "Average Error", "Average error of re-projection");
633
634         /* ** api ** */
635
636         func= RNA_def_function(srna, "marker_find_frame", "rna_trackingTrack_marker_find_frame");
637         RNA_def_function_ui_description(func, "Get marker for specified frame");
638         parm= RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "type for the new spline", MINFRAME, MAXFRAME);
639         RNA_def_property_flag(parm, PROP_REQUIRED);
640         parm= RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Marker for specified frame");
641         RNA_def_function_return(func, parm);
642 }
643
644 static void rna_def_trackingStabilization(BlenderRNA *brna)
645 {
646         StructRNA *srna;
647         PropertyRNA *prop;
648
649         srna= RNA_def_struct(brna, "MovieTrackingStabilization", NULL);
650         RNA_def_struct_ui_text(srna, "Movie tracking stabilization data", "Match-moving stabilization data for tracking");
651
652         /* 2d stabilization */
653         prop= RNA_def_property(srna, "use_2d_stabilization", PROP_BOOLEAN, PROP_NONE);
654         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_2D_STABILIZATION);
655         RNA_def_property_ui_text(prop, "Use 2D stabilization", "Use 2D stabilization for footage");
656         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
657
658         /* tracks */
659         prop= RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
660         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);
661         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
662         RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks used for stabilization");
663         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
664
665         /* rotation track */
666         prop= RNA_def_property(srna, "rotation_track", PROP_POINTER, PROP_NONE);
667         RNA_def_property_pointer_sdna(prop, NULL, "rot_track");
668         RNA_def_property_flag(prop, PROP_EDITABLE);
669         RNA_def_property_ui_text(prop, "Rotation Track", "Track used to compensate rotation");
670         RNA_def_property_update(prop, NC_MOVIECLIP|NA_EDITED, "rna_tracking_flushUpdate");
671
672         /* active track index */
673         prop= RNA_def_property(srna, "active_track_index", PROP_INT, PROP_NONE);
674         RNA_def_property_int_sdna(prop, NULL, "act_track");
675         RNA_def_property_int_funcs(prop, "rna_tracking_stabTracks_active_index_get", "rna_tracking_stabTracks_active_index_set", "rna_tracking_stabTracks_active_index_range");
676         RNA_def_property_ui_text(prop, "Active Track Index", "Index of active track in stabilization tracks list");
677
678         /* autoscale */
679         prop= RNA_def_property(srna, "use_autoscale", PROP_BOOLEAN, PROP_NONE);
680         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_AUTOSCALE);
681         RNA_def_property_ui_text(prop, "Autoscale", "Automatically scale footage to cover unfilled areas when stabilizating");
682         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
683
684         /* max scale */
685         prop= RNA_def_property(srna, "scale_max", PROP_FLOAT, PROP_FACTOR);
686         RNA_def_property_float_sdna(prop, NULL, "maxscale");
687         RNA_def_property_range(prop, 0.0f, 10.0f);
688         RNA_def_property_ui_text(prop, "Maximal Scale", "Limits the amount of automatic scaling");
689         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
690
691         /* influence_location */
692         prop= RNA_def_property(srna, "influence_location", PROP_FLOAT, PROP_FACTOR);
693         RNA_def_property_float_sdna(prop, NULL, "locinf");
694         RNA_def_property_range(prop, 0.0f, 1.0f);
695         RNA_def_property_ui_text(prop, "Location Influence", "Influence of stabilization algorithm on footage location");
696         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
697
698         /* influence_scale */
699         prop= RNA_def_property(srna, "influence_scale", PROP_FLOAT, PROP_FACTOR);
700         RNA_def_property_float_sdna(prop, NULL, "scaleinf");
701         RNA_def_property_range(prop, 0.0f, 1.0f);
702         RNA_def_property_ui_text(prop, "Scale Influence", "Influence of stabilization algorithm on footage scale");
703         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
704
705         /* use_stabilize_rotation */
706         prop= RNA_def_property(srna, "use_stabilize_rotation", PROP_BOOLEAN, PROP_NONE);
707         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_STABILIZE_ROTATION);
708         RNA_def_property_ui_text(prop, "Stabilize Rotation", "Stabilize horizon line on the shot");
709         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
710
711         /* influence_rotation */
712         prop= RNA_def_property(srna, "influence_rotation", PROP_FLOAT, PROP_FACTOR);
713         RNA_def_property_float_sdna(prop, NULL, "rotinf");
714         RNA_def_property_range(prop, 0.0f, 1.0f);
715         RNA_def_property_ui_text(prop, "Rotation Influence", "Influence of stabilization algorithm on footage rotation");
716         RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_tracking_flushUpdate");
717 }
718
719 static void rna_def_reconstructedCamera(BlenderRNA *brna)
720 {
721         StructRNA *srna;
722         PropertyRNA *prop;
723
724         srna= RNA_def_struct(brna, "MovieReconstructedCamera", NULL);
725         RNA_def_struct_ui_text(srna, "Movie tracking reconstructed camera data", "Match-moving reconstructed camera data from tracker");
726
727         /* frame */
728         prop= RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
729         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
730         RNA_def_property_int_sdna(prop, NULL, "framenr");
731         RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
732
733         /* matrix */
734         prop= RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
735         RNA_def_property_float_sdna(prop, NULL, "mat");
736         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
737         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
738         RNA_def_property_ui_text(prop, "Matrix", "Worldspace transformation matrix");
739
740         /* average_error */
741         prop= RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
742         RNA_def_property_float_sdna(prop, NULL, "error");
743         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
744         RNA_def_property_ui_text(prop, "Average Error", "Average error of resonctruction");
745 }
746
747 static void rna_def_trackingReconstruction(BlenderRNA *brna)
748 {
749         StructRNA *srna;
750         PropertyRNA *prop;
751
752         rna_def_reconstructedCamera(brna);
753
754         srna= RNA_def_struct(brna, "MovieTrackingReconstruction", NULL);
755         RNA_def_struct_ui_text(srna, "Movie tracking reconstruction data", "Match-moving reconstruction data from tracker");
756
757         /* is_valid */
758         prop= RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
759         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
760         RNA_def_property_boolean_sdna(prop, NULL, "flag", TRACKING_RECONSTRUCTED);
761         RNA_def_property_ui_text(prop, "Reconstructed", "Is tracking data contains valid reconstruction information");
762
763         /* average_error */
764         prop= RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
765         RNA_def_property_float_sdna(prop, NULL, "error");
766         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
767         RNA_def_property_ui_text(prop, "Average Error", "Average error of resonctruction");
768
769         /* cameras */
770         prop= RNA_def_property(srna, "cameras", PROP_COLLECTION, PROP_NONE);
771         RNA_def_property_struct_type(prop, "MovieReconstructedCamera");
772         RNA_def_property_collection_sdna(prop, NULL, "cameras", "camnr");
773         RNA_def_property_ui_text(prop, "Cameras", "Collection of solved cameras");
774 }
775
776 static void rna_def_trackingTracks(BlenderRNA *brna, PropertyRNA *cprop)
777 {
778         StructRNA *srna;
779         FunctionRNA *func;
780         PropertyRNA *prop;
781
782         RNA_def_property_srna(cprop, "MovieTrackingTracks");
783         srna= RNA_def_struct(brna, "MovieTrackingTracks", NULL);
784         RNA_def_struct_sdna(srna, "MovieTracking");
785         RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
786
787         func= RNA_def_function(srna, "add", "rna_tracking_tracks_add");
788         RNA_def_function_ui_description(func, "Add a number of tracks to this movie clip");
789         RNA_def_int(func, "frame", 1, MINFRAME, MAXFRAME, "Frame", "Frame number to add tracks on", MINFRAME, MAXFRAME);
790         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of tracks to add to the movie clip", 0, INT_MAX);
791
792         /* active track */
793         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
794         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
795         RNA_def_property_pointer_funcs(prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", NULL, NULL);
796         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
797         RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
798 }
799
800 static void rna_def_tracking(BlenderRNA *brna)
801 {
802         StructRNA *srna;
803         PropertyRNA *prop;
804
805         rna_def_trackingSettings(brna);
806         rna_def_trackingCamera(brna);
807         rna_def_trackingTrack(brna);
808         rna_def_trackingStabilization(brna);
809         rna_def_trackingReconstruction(brna);
810
811         srna= RNA_def_struct(brna, "MovieTracking", NULL);
812         RNA_def_struct_ui_text(srna, "Movie tracking data", "Match-moving data for tracking");
813
814         /* settings */
815         prop= RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
816         RNA_def_property_struct_type(prop, "MovieTrackingSettings");
817
818         /* camera properties */
819         prop= RNA_def_property(srna, "camera", PROP_POINTER, PROP_NONE);
820         RNA_def_property_struct_type(prop, "MovieTrackingCamera");
821
822         /* tracks */
823         prop= RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
824         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);
825         RNA_def_property_struct_type(prop, "MovieTrackingTrack");
826         RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks in this tracking data object");
827         rna_def_trackingTracks(brna, prop);
828
829         /* stabilization */
830         prop= RNA_def_property(srna, "stabilization", PROP_POINTER, PROP_NONE);
831         RNA_def_property_struct_type(prop, "MovieTrackingStabilization");
832
833         /* reconstruction */
834         prop= RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
835         RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
836 }
837
838 void RNA_def_tracking(BlenderRNA *brna)
839 {
840         rna_def_tracking(brna);
841 }
842
843 #endif