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