source/blender/makesrna/intern/rna_tracking.c

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