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