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