Blender  V3.3
rna_tracking.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 
7 #include <limits.h>
8 #include <stdlib.h>
9 
10 #include "MEM_guardedalloc.h"
11 
12 #include "BKE_movieclip.h"
13 #include "BKE_node_tree_update.h"
14 #include "BKE_tracking.h"
15 
16 #include "RNA_access.h"
17 #include "RNA_define.h"
18 
19 #include "rna_internal.h"
20 
21 #include "DNA_defaults.h"
22 #include "DNA_movieclip_types.h"
23 #include "DNA_object_types.h" /* SELECT */
24 #include "DNA_scene_types.h"
25 
26 #include "WM_types.h"
27 
28 #ifdef RNA_RUNTIME
29 
30 # include "BLI_math.h"
31 
32 # include "DNA_anim_types.h"
33 
34 # include "BKE_anim_data.h"
35 # include "BKE_animsys.h"
36 # include "BKE_node.h"
37 
38 # include "DEG_depsgraph.h"
39 
40 # include "IMB_imbuf.h"
41 
42 # include "WM_api.h"
43 
44 static char *rna_tracking_path(const PointerRNA *UNUSED(ptr))
45 {
46  return BLI_strdup("tracking");
47 }
48 
49 static void rna_tracking_defaultSettings_patternUpdate(Main *UNUSED(bmain),
50  Scene *UNUSED(scene),
51  PointerRNA *ptr)
52 {
53  MovieClip *clip = (MovieClip *)ptr->owner_id;
54  MovieTracking *tracking = &clip->tracking;
55  MovieTrackingSettings *settings = &tracking->settings;
56 
57  if (settings->default_search_size < settings->default_pattern_size) {
58  settings->default_search_size = settings->default_pattern_size;
59  }
60 }
61 
62 static void rna_tracking_defaultSettings_searchUpdate(Main *UNUSED(bmain),
63  Scene *UNUSED(scene),
64  PointerRNA *ptr)
65 {
66  MovieClip *clip = (MovieClip *)ptr->owner_id;
67  MovieTracking *tracking = &clip->tracking;
68  MovieTrackingSettings *settings = &tracking->settings;
69 
70  if (settings->default_pattern_size > settings->default_search_size) {
71  settings->default_pattern_size = settings->default_search_size;
72  }
73 }
74 
75 static char *rna_trackingTrack_path(const PointerRNA *ptr)
76 {
77  MovieClip *clip = (MovieClip *)ptr->owner_id;
79  /* Escaped object name, escaped track name, rest of the path. */
80  char rna_path[MAX_NAME * 4 + 64];
81  BKE_tracking_get_rna_path_for_track(&clip->tracking, track, rna_path, sizeof(rna_path));
82  return BLI_strdup(rna_path);
83 }
84 
85 static void rna_trackingTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
86 {
87  MovieClip *clip = (MovieClip *)ptr->owner_id;
88 
90 }
91 
92 static void rna_trackingPlaneTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
93 {
94  MovieClip *clip = (MovieClip *)ptr->owner_id;
95 
97 }
98 
99 static void rna_trackingObjects_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
100 {
101  MovieClip *clip = (MovieClip *)ptr->owner_id;
102 
104 }
105 
106 static int rna_tracking_active_object_index_get(PointerRNA *ptr)
107 {
108  MovieClip *clip = (MovieClip *)ptr->owner_id;
109 
110  return clip->tracking.objectnr;
111 }
112 
113 static void rna_tracking_active_object_index_set(PointerRNA *ptr, int value)
114 {
115  MovieClip *clip = (MovieClip *)ptr->owner_id;
116 
117  clip->tracking.objectnr = value;
119 }
120 
121 static void rna_tracking_active_object_index_range(
122  PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
123 {
124  MovieClip *clip = (MovieClip *)ptr->owner_id;
125 
126  *min = 0;
127  *max = max_ii(0, clip->tracking.tot_object - 1);
128 }
129 
130 static PointerRNA rna_tracking_active_track_get(PointerRNA *ptr)
131 {
132  MovieClip *clip = (MovieClip *)ptr->owner_id;
134 
135  return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingTrack, act_track);
136 }
137 
138 static void rna_tracking_active_track_set(PointerRNA *ptr,
139  PointerRNA value,
140  struct ReportList *UNUSED(reports))
141 {
142  MovieClip *clip = (MovieClip *)ptr->owner_id;
143  MovieTrackingTrack *track = (MovieTrackingTrack *)value.data;
144  ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
145  int index = BLI_findindex(tracksbase, track);
146 
147  if (index != -1) {
148  clip->tracking.act_track = track;
149  }
150  else {
151  clip->tracking.act_track = NULL;
152  }
153 }
154 
155 static PointerRNA rna_tracking_active_plane_track_get(PointerRNA *ptr)
156 {
157  MovieClip *clip = (MovieClip *)ptr->owner_id;
159 
160  return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingPlaneTrack, act_plane_track);
161 }
162 
163 static void rna_tracking_active_plane_track_set(PointerRNA *ptr,
164  PointerRNA value,
165  struct ReportList *UNUSED(reports))
166 {
167  MovieClip *clip = (MovieClip *)ptr->owner_id;
168  MovieTrackingPlaneTrack *plane_track = (MovieTrackingPlaneTrack *)value.data;
169  ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(&clip->tracking);
170  int index = BLI_findindex(plane_tracks_base, plane_track);
171 
172  if (index != -1) {
173  clip->tracking.act_plane_track = plane_track;
174  }
175  else {
176  clip->tracking.act_plane_track = NULL;
177  }
178 }
179 
180 static void rna_trackingTrack_name_set(PointerRNA *ptr, const char *value)
181 {
182  MovieClip *clip = (MovieClip *)ptr->owner_id;
184  ListBase *tracksbase = BKE_tracking_find_tracks_list_for_track(&clip->tracking, track);
185  /* Store old name, for the animation fix later. */
186  char old_name[sizeof(track->name)];
187  BLI_strncpy(old_name, track->name, sizeof(track->name));
188  /* Update the name, */
189  BLI_strncpy(track->name, value, sizeof(track->name));
190  BKE_tracking_track_unique_name(tracksbase, track);
191  /* Fix animation paths. */
192  AnimData *adt = BKE_animdata_from_id(&clip->id);
193  if (adt != NULL) {
194  char rna_path[MAX_NAME * 2 + 64];
195  BKE_tracking_get_rna_path_prefix_for_track(&clip->tracking, track, rna_path, sizeof(rna_path));
196  BKE_animdata_fix_paths_rename(&clip->id, adt, NULL, rna_path, old_name, track->name, 0, 0, 1);
197  }
198 }
199 
200 static bool rna_trackingTrack_select_get(PointerRNA *ptr)
201 {
203 
204  return TRACK_SELECTED(track);
205 }
206 
207 static void rna_trackingTrack_select_set(PointerRNA *ptr, bool value)
208 {
210 
211  if (value) {
212  track->flag |= SELECT;
213  track->pat_flag |= SELECT;
214  track->search_flag |= SELECT;
215  }
216  else {
217  track->flag &= ~SELECT;
218  track->pat_flag &= ~SELECT;
219  track->search_flag &= ~SELECT;
220  }
221 }
222 
223 static void rna_trackingPlaneMarker_frame_set(PointerRNA *ptr, int value)
224 {
225  MovieClip *clip = (MovieClip *)ptr->owner_id;
226  MovieTracking *tracking = &clip->tracking;
228  MovieTrackingObject *tracking_object;
229  bool found = false;
230  MovieTrackingPlaneTrack *plane_track = NULL;
231 
232  for (tracking_object = tracking->objects.first; tracking_object;
233  tracking_object = tracking_object->next) {
234  ListBase *tracksbase = BKE_tracking_object_get_plane_tracks(tracking, tracking_object);
235 
236  for (plane_track = tracksbase->first; plane_track; plane_track = plane_track->next) {
237  if (plane_marker >= plane_track->markers &&
238  plane_marker < plane_track->markers + plane_track->markersnr) {
239  found = true;
240  break;
241  }
242  }
243 
244  if (found) {
245  break;
246  }
247  }
248 
249  if (found) {
250  MovieTrackingPlaneMarker new_plane_marker = *plane_marker;
251  new_plane_marker.framenr = value;
252 
253  BKE_tracking_plane_marker_delete(plane_track, plane_marker->framenr);
254  BKE_tracking_plane_marker_insert(plane_track, &new_plane_marker);
255  }
256 }
257 
258 static char *rna_trackingPlaneTrack_path(const PointerRNA *ptr)
259 {
260  MovieClip *clip = (MovieClip *)ptr->owner_id;
262  /* Escaped object name, escaped track name, rest of the path. */
263  char rna_path[MAX_NAME * 4 + 64];
265  &clip->tracking, plane_track, rna_path, sizeof(rna_path));
266  return BLI_strdup(rna_path);
267 }
268 
269 static void rna_trackingPlaneTrack_name_set(PointerRNA *ptr, const char *value)
270 {
271  MovieClip *clip = (MovieClip *)ptr->owner_id;
274  plane_track);
275  /* Store old name, for the animation fix later. */
276  char old_name[sizeof(plane_track->name)];
277  BLI_strncpy(old_name, plane_track->name, sizeof(plane_track->name));
278  /* Update the name, */
279  BLI_strncpy(plane_track->name, value, sizeof(plane_track->name));
280  BKE_tracking_plane_track_unique_name(plane_tracks_base, plane_track);
281  /* Fix animation paths. */
282  AnimData *adt = BKE_animdata_from_id(&clip->id);
283  if (adt != NULL) {
284  char rna_path[MAX_NAME * 2 + 64];
286  &clip->tracking, plane_track, rna_path, sizeof(rna_path));
288  &clip->id, adt, NULL, rna_path, old_name, plane_track->name, 0, 0, 1);
289  }
290 }
291 
292 static char *rna_trackingCamera_path(const PointerRNA *UNUSED(ptr))
293 {
294  return BLI_strdup("tracking.camera");
295 }
296 
297 static float rna_trackingCamera_focal_mm_get(PointerRNA *ptr)
298 {
299  MovieClip *clip = (MovieClip *)ptr->owner_id;
301  float val = camera->focal;
302 
303  if (clip->lastsize[0]) {
304  val = val * camera->sensor_width / (float)clip->lastsize[0];
305  }
306 
307  return val;
308 }
309 
310 static void rna_trackingCamera_focal_mm_set(PointerRNA *ptr, float value)
311 {
312  MovieClip *clip = (MovieClip *)ptr->owner_id;
314 
315  if (clip->lastsize[0]) {
316  value = clip->lastsize[0] * value / camera->sensor_width;
317  }
318 
319  if (value >= 0.0001f) {
320  camera->focal = value;
321  }
322 }
323 
324 static char *rna_trackingStabilization_path(const PointerRNA *UNUSED(ptr))
325 {
326  return BLI_strdup("tracking.stabilization");
327 }
328 
329 static int rna_track_2d_stabilization(CollectionPropertyIterator *UNUSED(iter), void *data)
330 {
332 
333  if ((track->flag & TRACK_USE_2D_STAB) == 0) {
334  return 1;
335  }
336 
337  return 0;
338 }
339 
340 static int rna_track_2d_stabilization_rotation(CollectionPropertyIterator *UNUSED(iter),
341  void *data)
342 {
344 
345  if ((track->flag & TRACK_USE_2D_STAB_ROT) == 0) {
346  return 1;
347  }
348 
349  return 0;
350 }
351 
352 static void rna_tracking_stabTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
353 {
354  MovieClip *clip = (MovieClip *)ptr->owner_id;
355  rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization);
356 }
357 
358 static int rna_tracking_stabTracks_active_index_get(PointerRNA *ptr)
359 {
360  MovieClip *clip = (MovieClip *)ptr->owner_id;
361  return clip->tracking.stabilization.act_track;
362 }
363 
364 static void rna_tracking_stabTracks_active_index_set(PointerRNA *ptr, int value)
365 {
366  MovieClip *clip = (MovieClip *)ptr->owner_id;
367  clip->tracking.stabilization.act_track = value;
368 }
369 
370 static void rna_tracking_stabTracks_active_index_range(
371  PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
372 {
373  MovieClip *clip = (MovieClip *)ptr->owner_id;
374 
375  *min = 0;
376  *max = max_ii(0, clip->tracking.stabilization.tot_track - 1);
377 }
378 
379 static void rna_tracking_stabRotTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
380 {
381  MovieClip *clip = (MovieClip *)ptr->owner_id;
382  rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization_rotation);
383 }
384 
385 static int rna_tracking_stabRotTracks_active_index_get(PointerRNA *ptr)
386 {
387  MovieClip *clip = (MovieClip *)ptr->owner_id;
388  return clip->tracking.stabilization.act_rot_track;
389 }
390 
391 static void rna_tracking_stabRotTracks_active_index_set(PointerRNA *ptr, int value)
392 {
393  MovieClip *clip = (MovieClip *)ptr->owner_id;
394  clip->tracking.stabilization.act_rot_track = value;
395 }
396 
397 static void rna_tracking_stabRotTracks_active_index_range(
398  PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
399 {
400  MovieClip *clip = (MovieClip *)ptr->owner_id;
401 
402  *min = 0;
403  *max = max_ii(0, clip->tracking.stabilization.tot_rot_track - 1);
404 }
405 
406 static void rna_tracking_flushUpdate(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
407 {
408  MovieClip *clip = (MovieClip *)ptr->owner_id;
409 
410  BKE_ntree_update_tag_id_changed(bmain, &clip->id);
411  BKE_ntree_update_main(bmain, NULL);
412 
415  DEG_id_tag_update(&clip->id, 0);
416 }
417 
418 static void rna_tracking_resetIntrinsics(Main *UNUSED(bmain),
419  Scene *UNUSED(scene),
420  PointerRNA *ptr)
421 {
422  MovieClip *clip = (MovieClip *)ptr->owner_id;
423  MovieTracking *tracking = &clip->tracking;
424 
425  if (tracking->camera.intrinsics) {
426  BKE_tracking_distortion_free(tracking->camera.intrinsics);
427  tracking->camera.intrinsics = NULL;
428  }
429 }
430 
431 static void rna_trackingObject_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
432 {
434 
435  if (object->flag & TRACKING_OBJECT_CAMERA) {
436  MovieClip *clip = (MovieClip *)ptr->owner_id;
437 
439  }
440  else {
441  rna_iterator_listbase_begin(iter, &object->tracks, NULL);
442  }
443 }
444 
445 static void rna_trackingObject_plane_tracks_begin(CollectionPropertyIterator *iter,
446  PointerRNA *ptr)
447 {
449 
450  if (object->flag & TRACKING_OBJECT_CAMERA) {
451  MovieClip *clip = (MovieClip *)ptr->owner_id;
452 
454  }
455  else {
457  }
458 }
459 
460 static PointerRNA rna_trackingObject_reconstruction_get(PointerRNA *ptr)
461 {
463 
464  if (object->flag & TRACKING_OBJECT_CAMERA) {
465  MovieClip *clip = (MovieClip *)ptr->owner_id;
466 
468  ptr, &RNA_MovieTrackingReconstruction, &clip->tracking.reconstruction);
469  }
470  else {
472  ptr, &RNA_MovieTrackingReconstruction, &object->reconstruction);
473  }
474 }
475 
476 static PointerRNA rna_tracking_active_object_get(PointerRNA *ptr)
477 {
478  MovieClip *clip = (MovieClip *)ptr->owner_id;
480 
481  return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingObject, object);
482 }
483 
484 static void rna_tracking_active_object_set(PointerRNA *ptr,
485  PointerRNA value,
486  struct ReportList *UNUSED(reports))
487 {
488  MovieClip *clip = (MovieClip *)ptr->owner_id;
489  MovieTrackingObject *object = (MovieTrackingObject *)value.data;
490  int index = BLI_findindex(&clip->tracking.objects, object);
491 
492  if (index != -1) {
493  clip->tracking.objectnr = index;
494  }
495  else {
496  clip->tracking.objectnr = 0;
497  }
498 }
499 
500 static void rna_trackingObject_name_set(PointerRNA *ptr, const char *value)
501 {
502  MovieClip *clip = (MovieClip *)ptr->owner_id;
504 
505  BLI_strncpy(object->name, value, sizeof(object->name));
506 
508 }
509 
510 static void rna_trackingObject_flushUpdate(Main *UNUSED(bmain),
511  Scene *UNUSED(scene),
512  PointerRNA *ptr)
513 {
514  MovieClip *clip = (MovieClip *)ptr->owner_id;
515 
517  DEG_id_tag_update(&clip->id, 0);
518 }
519 
520 static void rna_trackingMarker_frame_set(PointerRNA *ptr, int value)
521 {
522  MovieClip *clip = (MovieClip *)ptr->owner_id;
523  MovieTracking *tracking = &clip->tracking;
525  MovieTrackingObject *tracking_object;
526  bool found = false;
527  MovieTrackingTrack *track = NULL;
528 
529  for (tracking_object = tracking->objects.first; tracking_object;
530  tracking_object = tracking_object->next) {
531  ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
532 
533  for (track = tracksbase->first; track; track = track->next) {
534  if (marker >= track->markers && marker < track->markers + track->markersnr) {
535  found = true;
536  break;
537  }
538  }
539 
540  if (found) {
541  break;
542  }
543  }
544 
545  if (found) {
546  MovieTrackingMarker new_marker = *marker;
547  new_marker.framenr = value;
548 
549  BKE_tracking_marker_delete(track, marker->framenr);
550  BKE_tracking_marker_insert(track, &new_marker);
551  }
552 }
553 
554 static void rna_tracking_markerPattern_update(Main *UNUSED(bmain),
555  Scene *UNUSED(scene),
556  PointerRNA *ptr)
557 {
559 
561 }
562 
563 static void rna_tracking_markerSearch_update(Main *UNUSED(bmain),
564  Scene *UNUSED(scene),
565  PointerRNA *ptr)
566 {
568 
570 }
571 
572 static void rna_tracking_markerPattern_boundbox_get(PointerRNA *ptr, float *values)
573 {
575  float min[2], max[2];
576 
578 
579  copy_v2_v2(values, min);
580  copy_v2_v2(values + 2, max);
581 }
582 
583 static void rna_trackingDopesheet_tagUpdate(Main *UNUSED(bmain),
584  Scene *UNUSED(scene),
585  PointerRNA *ptr)
586 {
587  MovieClip *clip = (MovieClip *)ptr->owner_id;
588  MovieTrackingDopesheet *dopesheet = &clip->tracking.dopesheet;
589 
590  dopesheet->ok = 0;
591 }
592 
593 /* API */
594 
595 static MovieTrackingTrack *add_track_to_base(
596  MovieClip *clip, MovieTracking *tracking, ListBase *tracksbase, const char *name, int frame)
597 {
598  int width, height;
600  MovieTrackingTrack *track;
601 
602  user.framenr = 1;
603 
604  BKE_movieclip_get_size(clip, &user, &width, &height);
605 
606  track = BKE_tracking_track_add(tracking, tracksbase, 0, 0, frame, width, height);
607 
608  if (name && name[0]) {
609  BLI_strncpy(track->name, name, sizeof(track->name));
610  BKE_tracking_track_unique_name(tracksbase, track);
611  }
612 
613  return track;
614 }
615 
616 static MovieTrackingTrack *rna_trackingTracks_new(ID *id,
617  MovieTracking *tracking,
618  const char *name,
619  int frame)
620 {
621  MovieClip *clip = (MovieClip *)id;
622  MovieTrackingTrack *track;
623 
624  track = add_track_to_base(clip, tracking, &tracking->tracks, name, frame);
625 
627 
628  return track;
629 }
630 
631 static MovieTrackingTrack *rna_trackingObject_tracks_new(ID *id,
632  MovieTrackingObject *object,
633  const char *name,
634  int frame)
635 {
636  MovieClip *clip = (MovieClip *)id;
637  ListBase *tracksbase = &object->tracks;
638  MovieTrackingTrack *track;
639 
640  if (object->flag & TRACKING_OBJECT_CAMERA) {
641  tracksbase = &clip->tracking.tracks;
642  }
643 
644  track = add_track_to_base(clip, &clip->tracking, tracksbase, name, frame);
645 
647 
648  return track;
649 }
650 
651 static MovieTrackingObject *rna_trackingObject_new(MovieTracking *tracking, const char *name)
652 {
653  MovieTrackingObject *object = BKE_tracking_object_add(tracking, name);
654 
656 
657  return object;
658 }
659 
660 static void rna_trackingObject_remove(MovieTracking *tracking,
661  ReportList *reports,
662  PointerRNA *object_ptr)
663 {
664  MovieTrackingObject *object = object_ptr->data;
665  if (BKE_tracking_object_delete(tracking, object) == false) {
666  BKE_reportf(reports, RPT_ERROR, "MovieTracking '%s' cannot be removed", object->name);
667  return;
668  }
669 
670  RNA_POINTER_INVALIDATE(object_ptr);
671 
673 }
674 
675 static MovieTrackingMarker *rna_trackingMarkers_find_frame(MovieTrackingTrack *track,
676  int framenr,
677  bool exact)
678 {
679  if (exact) {
680  return BKE_tracking_marker_get_exact(track, framenr);
681  }
682  else {
683  return BKE_tracking_marker_get(track, framenr);
684  }
685 }
686 
687 static MovieTrackingMarker *rna_trackingMarkers_insert_frame(MovieTrackingTrack *track,
688  int framenr,
689  float co[2])
690 {
691  MovieTrackingMarker marker, *new_marker;
692 
693  memset(&marker, 0, sizeof(marker));
694  marker.framenr = framenr;
695  copy_v2_v2(marker.pos, co);
696 
697  /* a bit arbitrary, but better than creating markers with zero pattern
698  * which is forbidden actually
699  */
700  copy_v2_v2(marker.pattern_corners[0], track->markers[0].pattern_corners[0]);
701  copy_v2_v2(marker.pattern_corners[1], track->markers[0].pattern_corners[1]);
702  copy_v2_v2(marker.pattern_corners[2], track->markers[0].pattern_corners[2]);
703  copy_v2_v2(marker.pattern_corners[3], track->markers[0].pattern_corners[3]);
704 
705  new_marker = BKE_tracking_marker_insert(track, &marker);
706 
708 
709  return new_marker;
710 }
711 
712 static void rna_trackingMarkers_delete_frame(MovieTrackingTrack *track, int framenr)
713 {
714  if (track->markersnr == 1) {
715  return;
716  }
717 
718  BKE_tracking_marker_delete(track, framenr);
719 
721 }
722 
723 static MovieTrackingPlaneMarker *rna_trackingPlaneMarkers_find_frame(
724  MovieTrackingPlaneTrack *plane_track, int framenr, bool exact)
725 {
726  if (exact) {
727  return BKE_tracking_plane_marker_get_exact(plane_track, framenr);
728  }
729  else {
730  return BKE_tracking_plane_marker_get(plane_track, framenr);
731  }
732 }
733 
734 static MovieTrackingPlaneMarker *rna_trackingPlaneMarkers_insert_frame(
735  MovieTrackingPlaneTrack *plane_track, int framenr)
736 {
737  MovieTrackingPlaneMarker plane_marker, *new_plane_marker;
738 
739  memset(&plane_marker, 0, sizeof(plane_marker));
740  plane_marker.framenr = framenr;
741 
742  /* a bit arbitrary, but better than creating zero markers */
743  copy_v2_v2(plane_marker.corners[0], plane_track->markers[0].corners[0]);
744  copy_v2_v2(plane_marker.corners[1], plane_track->markers[0].corners[1]);
745  copy_v2_v2(plane_marker.corners[2], plane_track->markers[0].corners[2]);
746  copy_v2_v2(plane_marker.corners[3], plane_track->markers[0].corners[3]);
747 
748  new_plane_marker = BKE_tracking_plane_marker_insert(plane_track, &plane_marker);
749 
751 
752  return new_plane_marker;
753 }
754 
755 static void rna_trackingPlaneMarkers_delete_frame(MovieTrackingPlaneTrack *plane_track,
756  int framenr)
757 {
758  if (plane_track->markersnr == 1) {
759  return;
760  }
761 
762  BKE_tracking_plane_marker_delete(plane_track, framenr);
763 
765 }
766 
767 static MovieTrackingObject *find_object_for_reconstruction(
769 {
770  MovieTrackingObject *object;
771 
772  for (object = tracking->objects.first; object; object = object->next) {
773  if (object->flag & TRACKING_OBJECT_CAMERA) {
774  if (&tracking->reconstruction == reconstruction) {
775  return object;
776  }
777  }
778  else if (&object->reconstruction == reconstruction) {
779  return object;
780  }
781  }
782 
783  return NULL;
784 }
785 
786 static MovieReconstructedCamera *rna_trackingCameras_find_frame(
787  ID *id, MovieTrackingReconstruction *reconstruction, int framenr)
788 {
789  MovieClip *clip = (MovieClip *)id;
790  MovieTracking *tracking = &clip->tracking;
791  MovieTrackingObject *object = find_object_for_reconstruction(tracking, reconstruction);
792  return BKE_tracking_camera_get_reconstructed(tracking, object, framenr);
793 }
794 
795 static void rna_trackingCameras_matrix_from_frame(ID *id,
797  int framenr,
798  float matrix[16])
799 {
800  float mat[4][4];
801 
802  MovieClip *clip = (MovieClip *)id;
803  MovieTracking *tracking = &clip->tracking;
804  MovieTrackingObject *object = find_object_for_reconstruction(tracking, reconstruction);
805  BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat);
806 
807  memcpy(matrix, mat, sizeof(float[4][4]));
808 }
809 
810 #else
811 
814  "Perspective",
815  0,
816  "Perspective",
817  "Search for markers that are perspectively deformed (homography) between frames"},
819  "Affine",
820  0,
821  "Affine",
822  "Search for markers that are affine-deformed (t, r, k, and skew) between frames"},
824  "LocRotScale",
825  0,
826  "Location, Rotation & Scale",
827  "Search for markers that are translated, rotated, and scaled between frames"},
829  "LocScale",
830  0,
831  "Location & Scale",
832  "Search for markers that are translated and scaled between frames"},
834  "LocRot",
835  0,
836  "Location & Rotation",
837  "Search for markers that are translated and rotated between frames"},
839  "Loc",
840  0,
841  "Location",
842  "Search for markers that are translated between frames"},
843  {0, NULL, 0, NULL, NULL},
844 };
845 
847  {TRACK_MATCH_KEYFRAME, "KEYFRAME", 0, "Keyframe", "Track pattern from keyframe to next frame"},
849  "PREV_FRAME",
850  0,
851  "Previous frame",
852  "Track pattern from current frame to next frame"},
853  {0, NULL, 0, NULL, NULL},
854 };
855 
857 {
858  StructRNA *srna;
859  PropertyRNA *prop;
860 
861  static const EnumPropertyItem speed_items[] = {
862  {0, "FASTEST", 0, "Fastest", "Track as fast as it's possible"},
863  {TRACKING_SPEED_DOUBLE, "DOUBLE", 0, "Double", "Track with double speed"},
864  {TRACKING_SPEED_REALTIME, "REALTIME", 0, "Realtime", "Track with realtime speed"},
865  {TRACKING_SPEED_HALF, "HALF", 0, "Half", "Track with half of realtime speed"},
866  {TRACKING_SPEED_QUARTER, "QUARTER", 0, "Quarter", "Track with quarter of realtime speed"},
867  {0, NULL, 0, NULL, NULL},
868  };
869 
870  static const EnumPropertyItem cleanup_items[] = {
871  {TRACKING_CLEAN_SELECT, "SELECT", 0, "Select", "Select unclean tracks"},
872  {TRACKING_CLEAN_DELETE_TRACK, "DELETE_TRACK", 0, "Delete Track", "Delete unclean tracks"},
874  "DELETE_SEGMENTS",
875  0,
876  "Delete Segments",
877  "Delete unclean segments of tracks"},
878  {0, NULL, 0, NULL, NULL},
879  };
880 
881  srna = RNA_def_struct(brna, "MovieTrackingSettings", NULL);
882  RNA_def_struct_ui_text(srna, "Movie tracking settings", "Match moving settings");
883 
884  /* speed */
885  prop = RNA_def_property(srna, "speed", PROP_ENUM, PROP_NONE);
887  RNA_def_property_enum_items(prop, speed_items);
889  "Speed",
890  "Limit speed of tracking to make visual feedback easier "
891  "(this does not affect the tracking quality)");
892 
893  /* use keyframe selection */
894  prop = RNA_def_property(srna, "use_keyframe_selection", PROP_BOOLEAN, PROP_NONE);
897  prop, NULL, "reconstruction_flag", TRACKING_USE_KEYFRAME_SELECTION);
899  "Keyframe Selection",
900  "Automatically select keyframes when solving camera/object motion");
901 
902  /* intrinsics refinement during bundle adjustment */
903 
904  prop = RNA_def_property(srna, "refine_intrinsics_focal_length", PROP_BOOLEAN, PROP_NONE);
905  RNA_def_property_boolean_sdna(prop, NULL, "refine_camera_intrinsics", REFINE_FOCAL_LENGTH);
908  prop, "Refine Focal Length", "Refine focal length during camera solving");
909 
910  prop = RNA_def_property(srna, "refine_intrinsics_principal_point", PROP_BOOLEAN, PROP_NONE);
911  RNA_def_property_boolean_sdna(prop, NULL, "refine_camera_intrinsics", REFINE_PRINCIPAL_POINT);
914  prop, "Refine Principal Point", "Refine principal point during camera solving");
915 
916  prop = RNA_def_property(srna, "refine_intrinsics_radial_distortion", PROP_BOOLEAN, PROP_NONE);
917  RNA_def_property_boolean_sdna(prop, NULL, "refine_camera_intrinsics", REFINE_RADIAL_DISTORTION);
920  "Refine Radial",
921  "Refine radial coefficients of distortion model during camera solving");
922 
923  prop = RNA_def_property(
924  srna, "refine_intrinsics_tangential_distortion", PROP_BOOLEAN, PROP_NONE);
926  prop, NULL, "refine_camera_intrinsics", REFINE_TANGENTIAL_DISTORTION);
929  prop,
930  "Refine Tangential",
931  "Refine tangential coefficients of distortion model during camera solving");
932 
933  /* tool settings */
934 
935  /* distance */
936  prop = RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
938  RNA_def_property_float_sdna(prop, NULL, "dist");
939  RNA_def_property_float_default(prop, 1.0f);
941  prop, "Distance", "Distance between two bundles used for scene scaling");
942 
943  /* frames count */
944  prop = RNA_def_property(srna, "clean_frames", PROP_INT, PROP_NONE);
946  RNA_def_property_int_sdna(prop, NULL, "clean_frames");
947  RNA_def_property_range(prop, 0, INT_MAX);
949  prop,
950  "Tracked Frames",
951  "Effect on tracks which are tracked less than the specified amount of frames");
952 
953  /* re-projection error */
954  prop = RNA_def_property(srna, "clean_error", PROP_FLOAT, PROP_NONE);
956  RNA_def_property_float_sdna(prop, NULL, "clean_error");
957  RNA_def_property_range(prop, 0, FLT_MAX);
959  prop, "Reprojection Error", "Effect on tracks which have a larger re-projection error");
960 
961  /* cleanup action */
962  prop = RNA_def_property(srna, "clean_action", PROP_ENUM, PROP_NONE);
963  RNA_def_property_enum_sdna(prop, NULL, "clean_action");
965  RNA_def_property_enum_items(prop, cleanup_items);
966  RNA_def_property_ui_text(prop, "Action", "Cleanup action to execute");
967 
968  /* solver settings */
969  prop = RNA_def_property(srna, "use_tripod_solver", PROP_BOOLEAN, PROP_NONE);
973  prop,
974  "Tripod Motion",
975  "Use special solver to track a stable camera position, such as a tripod");
976 
977  /* default_limit_frames */
978  prop = RNA_def_property(srna, "default_frames_limit", PROP_INT, PROP_NONE);
980  RNA_def_property_int_sdna(prop, NULL, "default_frames_limit");
981  RNA_def_property_range(prop, 0, SHRT_MAX);
983  prop, "Frames Limit", "Every tracking cycle, this number of frames are tracked");
984 
985  /* default_pattern_match */
986  prop = RNA_def_property(srna, "default_pattern_match", PROP_ENUM, PROP_NONE);
988  RNA_def_property_enum_sdna(prop, NULL, "default_pattern_match");
991  prop, "Pattern Match", "Track pattern from given frame when tracking marker to next frame");
992 
993  /* default_margin */
994  prop = RNA_def_property(srna, "default_margin", PROP_INT, PROP_PIXEL);
996  RNA_def_property_int_sdna(prop, NULL, "default_margin");
997  RNA_def_property_range(prop, 0, 300);
999  prop, "Margin", "Default distance from image boundary at which marker stops tracking");
1000 
1001  /* default_tracking_motion_model */
1002  prop = RNA_def_property(srna, "default_motion_model", PROP_ENUM, PROP_NONE);
1005  RNA_def_property_ui_text(prop, "Motion Model", "Default motion model to use for tracking");
1006 
1007  /* default_use_brute */
1008  prop = RNA_def_property(srna, "use_default_brute", PROP_BOOLEAN, PROP_NONE);
1010  prop, NULL, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_BRUTE);
1012  prop, "Prepass", "Use a brute-force translation-only initialization when tracking");
1014 
1015  /* default_use_brute */
1016  prop = RNA_def_property(srna, "use_default_mask", PROP_BOOLEAN, PROP_NONE);
1018  prop, NULL, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_MASK);
1020  prop,
1021  "Use Mask",
1022  "Use a grease pencil data-block as a mask to use only specified areas of pattern "
1023  "when tracking");
1025 
1026  /* default_use_normalization */
1027  prop = RNA_def_property(srna, "use_default_normalization", PROP_BOOLEAN, PROP_NONE);
1029  prop, NULL, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_NORMALIZATION);
1031  prop, "Normalize", "Normalize light intensities while tracking (slower)");
1033 
1034  /* default minimal correlation */
1035  prop = RNA_def_property(srna, "default_correlation_min", PROP_FLOAT, PROP_NONE);
1037  RNA_def_property_float_sdna(prop, NULL, "default_minimum_correlation");
1038  RNA_def_property_range(prop, 0.0f, 1.0f);
1039  RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.05, 3);
1041  prop,
1042  "Correlation",
1043  "Default minimum value of correlation between matched pattern and reference "
1044  "that is still treated as successful tracking");
1045 
1046  /* default pattern size */
1047  prop = RNA_def_property(srna, "default_pattern_size", PROP_INT, PROP_NONE);
1049  RNA_def_property_int_sdna(prop, NULL, "default_pattern_size");
1050  RNA_def_property_range(prop, 5, 1000);
1051  RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_patternUpdate");
1052  RNA_def_property_ui_text(prop, "Pattern Size", "Size of pattern area for newly created tracks");
1053 
1054  /* default search size */
1055  prop = RNA_def_property(srna, "default_search_size", PROP_INT, PROP_NONE);
1057  RNA_def_property_int_sdna(prop, NULL, "default_search_size");
1058  RNA_def_property_range(prop, 5, 1000);
1059  RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_searchUpdate");
1060  RNA_def_property_ui_text(prop, "Search Size", "Size of search area for newly created tracks");
1061 
1062  /* default use_red_channel */
1063  prop = RNA_def_property(srna, "use_default_red_channel", PROP_BOOLEAN, PROP_NONE);
1065  RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
1067 
1068  /* default_use_green_channel */
1069  prop = RNA_def_property(srna, "use_default_green_channel", PROP_BOOLEAN, PROP_NONE);
1072  prop, "Use Green Channel", "Use green channel from footage for tracking");
1074 
1075  /* default_use_blue_channel */
1076  prop = RNA_def_property(srna, "use_default_blue_channel", PROP_BOOLEAN, PROP_NONE);
1078  RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
1080 
1081  prop = RNA_def_property(srna, "default_weight", PROP_FLOAT, PROP_FACTOR);
1082  RNA_def_property_range(prop, 0.0f, 1.0f);
1083  RNA_def_property_ui_text(prop, "Weight", "Influence of newly created track on a final solution");
1084 
1085  /* ** object tracking ** */
1086 
1087  /* object distance */
1088  prop = RNA_def_property(srna, "object_distance", PROP_FLOAT, PROP_NONE);
1090  RNA_def_property_float_sdna(prop, NULL, "object_distance");
1092  prop, "Distance", "Distance between two bundles used for object scaling");
1093  RNA_def_property_range(prop, 0.001, 10000);
1094  RNA_def_property_float_default(prop, 1.0f);
1095  RNA_def_property_ui_range(prop, 0.001, 10000.0, 1, 3);
1096 }
1097 
1099 {
1100  StructRNA *srna;
1101  PropertyRNA *prop;
1102 
1103  static const EnumPropertyItem distortion_model_items[] = {
1105  "POLYNOMIAL",
1106  0,
1107  "Polynomial",
1108  "Radial distortion model which fits common cameras"},
1110  "DIVISION",
1111  0,
1112  "Divisions",
1113  "Division distortion model which "
1114  "better represents wide-angle cameras"},
1115  {TRACKING_DISTORTION_MODEL_NUKE, "NUKE", 0, "Nuke", "Nuke distortion model"},
1116  {TRACKING_DISTORTION_MODEL_BROWN, "BROWN", 0, "Brown", "Brown-Conrady distortion model"},
1117  {0, NULL, 0, NULL, NULL},
1118  };
1119 
1120  static const EnumPropertyItem camera_units_items[] = {
1121  {CAMERA_UNITS_PX, "PIXELS", 0, "px", "Use pixels for units of focal length"},
1122  {CAMERA_UNITS_MM, "MILLIMETERS", 0, "mm", "Use millimeters for units of focal length"},
1123  {0, NULL, 0, NULL, NULL},
1124  };
1125 
1126  srna = RNA_def_struct(brna, "MovieTrackingCamera", NULL);
1127  RNA_def_struct_path_func(srna, "rna_trackingCamera_path");
1129  srna, "Movie tracking camera data", "Match-moving camera data for tracking");
1130 
1131  /* Distortion model */
1132  prop = RNA_def_property(srna, "distortion_model", PROP_ENUM, PROP_NONE);
1134  RNA_def_property_enum_items(prop, distortion_model_items);
1135  RNA_def_property_ui_text(prop, "Distortion Model", "Distortion model used for camera lenses");
1136  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_resetIntrinsics");
1137 
1138  /* Sensor */
1139  prop = RNA_def_property(srna, "sensor_width", PROP_FLOAT, PROP_NONE);
1140  RNA_def_property_float_sdna(prop, NULL, "sensor_width");
1142  RNA_def_property_range(prop, 0.0f, 500.0f);
1143  RNA_def_property_ui_text(prop, "Sensor", "Width of CCD sensor in millimeters");
1145 
1146  /* Focal Length */
1147  prop = RNA_def_property(srna, "focal_length", PROP_FLOAT, PROP_NONE);
1148  RNA_def_property_float_sdna(prop, NULL, "focal");
1150  RNA_def_property_range(prop, 0.0001f, FLT_MAX);
1151  RNA_def_property_ui_range(prop, 0.0001f, 5000.0f, 1, 2);
1153  prop, "rna_trackingCamera_focal_mm_get", "rna_trackingCamera_focal_mm_set", NULL);
1154  RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
1156 
1157  /* Focal Length in pixels */
1158  prop = RNA_def_property(srna, "focal_length_pixels", PROP_FLOAT, PROP_NONE);
1159  RNA_def_property_float_sdna(prop, NULL, "focal");
1161  RNA_def_property_range(prop, 0.0f, FLT_MAX);
1162  RNA_def_property_ui_range(prop, 0.0f, 5000.0f, 1, 2);
1163  RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
1165 
1166  /* Units */
1167  prop = RNA_def_property(srna, "units", PROP_ENUM, PROP_NONE);
1168  RNA_def_property_enum_sdna(prop, NULL, "units");
1170  RNA_def_property_enum_items(prop, camera_units_items);
1171  RNA_def_property_ui_text(prop, "Units", "Units used for camera focal length");
1172 
1173  /* Principal Point */
1174  prop = RNA_def_property(srna, "principal", PROP_FLOAT, PROP_PIXEL);
1175  RNA_def_property_array(prop, 2);
1176  RNA_def_property_float_sdna(prop, NULL, "principal");
1178  RNA_def_property_ui_text(prop, "Principal Point", "Optical center of lens");
1180 
1181  /* Radial distortion parameters */
1182  prop = RNA_def_property(srna, "k1", PROP_FLOAT, PROP_NONE);
1183  RNA_def_property_float_sdna(prop, NULL, "k1");
1185  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1187  prop, "K1", "First coefficient of third order polynomial radial distortion");
1188  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1189 
1190  prop = RNA_def_property(srna, "k2", PROP_FLOAT, PROP_NONE);
1191  RNA_def_property_float_sdna(prop, NULL, "k2");
1193  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1195  prop, "K2", "Second coefficient of third order polynomial radial distortion");
1196  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1197 
1198  prop = RNA_def_property(srna, "k3", PROP_FLOAT, PROP_NONE);
1199  RNA_def_property_float_sdna(prop, NULL, "k3");
1201  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1203  prop, "K3", "Third coefficient of third order polynomial radial distortion");
1204  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1205 
1206  /* Division distortion parameters */
1207  prop = RNA_def_property(srna, "division_k1", PROP_FLOAT, PROP_NONE);
1209  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1210  RNA_def_property_ui_text(prop, "K1", "First coefficient of second order division distortion");
1211  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1212 
1213  prop = RNA_def_property(srna, "division_k2", PROP_FLOAT, PROP_NONE);
1215  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1216  RNA_def_property_ui_text(prop, "K2", "Second coefficient of second order division distortion");
1217  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1218 
1219  /* Nuke distortion parameters */
1220  prop = RNA_def_property(srna, "nuke_k1", PROP_FLOAT, PROP_NONE);
1222  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1223  RNA_def_property_ui_text(prop, "K1", "First coefficient of second order Nuke distortion");
1224  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1225 
1226  prop = RNA_def_property(srna, "nuke_k2", PROP_FLOAT, PROP_NONE);
1228  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1229  RNA_def_property_ui_text(prop, "K2", "Second coefficient of second order Nuke distortion");
1230  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1231 
1232  /* Brown-Conrady distortion parameters */
1233  prop = RNA_def_property(srna, "brown_k1", PROP_FLOAT, PROP_NONE);
1235  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1237  prop, "K1", "First coefficient of fourth order Brown-Conrady radial distortion");
1238  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1239 
1240  prop = RNA_def_property(srna, "brown_k2", PROP_FLOAT, PROP_NONE);
1242  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1244  prop, "K2", "Second coefficient of fourth order Brown-Conrady radial distortion");
1245  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1246 
1247  prop = RNA_def_property(srna, "brown_k3", PROP_FLOAT, PROP_NONE);
1249  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1251  prop, "K3", "Third coefficient of fourth order Brown-Conrady radial distortion");
1252  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1253 
1254  prop = RNA_def_property(srna, "brown_k4", PROP_FLOAT, PROP_NONE);
1256  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1258  prop, "K4", "Fourth coefficient of fourth order Brown-Conrady radial distortion");
1259  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1260 
1261  prop = RNA_def_property(srna, "brown_p1", PROP_FLOAT, PROP_NONE);
1263  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1265  prop, "P1", "First coefficient of second order Brown-Conrady tangential distortion");
1266  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1267 
1268  prop = RNA_def_property(srna, "brown_p2", PROP_FLOAT, PROP_NONE);
1270  RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1272  prop, "P2", "Second coefficient of second order Brown-Conrady tangential distortion");
1273  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1274 
1275  /* pixel aspect */
1276  prop = RNA_def_property(srna, "pixel_aspect", PROP_FLOAT, PROP_XYZ);
1277  RNA_def_property_float_sdna(prop, NULL, "pixel_aspect");
1279  RNA_def_property_range(prop, 0.1f, FLT_MAX);
1280  RNA_def_property_ui_range(prop, 0.1f, 5000.0f, 1, 2);
1281  RNA_def_property_float_default(prop, 1.0f);
1282  RNA_def_property_ui_text(prop, "Pixel Aspect Ratio", "Pixel aspect ratio");
1283  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1284 }
1285 
1287 {
1288  StructRNA *srna;
1289  PropertyRNA *prop;
1290 
1291  static int boundbox_dimsize[] = {2, 2};
1292 
1293  srna = RNA_def_struct(brna, "MovieTrackingMarker", NULL);
1295  srna, "Movie tracking marker data", "Match-moving marker data for tracking");
1296 
1297  /* position */
1298  prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
1299  RNA_def_property_array(prop, 2);
1300  RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1301  RNA_def_property_float_sdna(prop, NULL, "pos");
1302  RNA_def_property_ui_text(prop, "Position", "Marker position at frame in normalized coordinates");
1304 
1305  /* frame */
1306  prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
1307  RNA_def_property_int_sdna(prop, NULL, "framenr");
1308  RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
1309  RNA_def_property_int_funcs(prop, NULL, "rna_trackingMarker_frame_set", NULL);
1311 
1312  /* enable */
1313  prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1315  RNA_def_property_ui_text(prop, "Mode", "Is marker muted for current frame");
1317 
1318  /* pattern */
1319  prop = RNA_def_property(srna, "pattern_corners", PROP_FLOAT, PROP_MATRIX);
1320  RNA_def_property_float_sdna(prop, NULL, "pattern_corners");
1323  RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1325  "Pattern Corners",
1326  "Array of coordinates which represents pattern's corners in "
1327  "normalized coordinates relative to marker position");
1328  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerPattern_update");
1329 
1330  prop = RNA_def_property(srna, "pattern_bound_box", PROP_FLOAT, PROP_NONE);
1331  RNA_def_property_multi_array(prop, 2, boundbox_dimsize);
1333  RNA_def_property_float_funcs(prop, "rna_tracking_markerPattern_boundbox_get", NULL, NULL);
1335  prop, "Pattern Bounding Box", "Pattern area bounding box in normalized coordinates");
1336 
1337  /* search */
1338  prop = RNA_def_property(srna, "search_min", PROP_FLOAT, PROP_TRANSLATION);
1339  RNA_def_property_array(prop, 2);
1340  RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1341  RNA_def_property_float_sdna(prop, NULL, "search_min");
1344  "Search Min",
1345  "Left-bottom corner of search area in normalized coordinates relative "
1346  "to marker position");
1347  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerSearch_update");
1348 
1349  prop = RNA_def_property(srna, "search_max", PROP_FLOAT, PROP_TRANSLATION);
1350  RNA_def_property_array(prop, 2);
1351  RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1352  RNA_def_property_float_sdna(prop, NULL, "search_max");
1355  "Search Max",
1356  "Right-bottom corner of search area in normalized coordinates relative "
1357  "to marker position");
1358  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerSearch_update");
1359 
1360  /* is marker keyframed */
1361  prop = RNA_def_property(srna, "is_keyed", PROP_BOOLEAN, PROP_NONE);
1365  prop, "Keyframed", "Whether the position of the marker is keyframed or tracked");
1366 }
1367 
1369 {
1370  StructRNA *srna;
1371  FunctionRNA *func;
1372  PropertyRNA *parm;
1373 
1374  RNA_def_property_srna(cprop, "MovieTrackingMarkers");
1375  srna = RNA_def_struct(brna, "MovieTrackingMarkers", NULL);
1376  RNA_def_struct_sdna(srna, "MovieTrackingTrack");
1378  srna, "Movie Tracking Markers", "Collection of markers for movie tracking track");
1379 
1380  func = RNA_def_function(srna, "find_frame", "rna_trackingMarkers_find_frame");
1381  RNA_def_function_ui_description(func, "Get marker for specified frame");
1382  parm = RNA_def_int(func,
1383  "frame",
1384  1,
1385  MINFRAME,
1386  MAXFRAME,
1387  "Frame",
1388  "Frame number to find marker for",
1389  MINFRAME,
1390  MAXFRAME);
1392  RNA_def_boolean(func,
1393  "exact",
1394  true,
1395  "Exact",
1396  "Get marker at exact frame number rather than get estimated marker");
1397  parm = RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Marker for specified frame");
1398  RNA_def_function_return(func, parm);
1399 
1400  func = RNA_def_function(srna, "insert_frame", "rna_trackingMarkers_insert_frame");
1401  RNA_def_function_ui_description(func, "Insert a new marker at the specified frame");
1402  parm = RNA_def_int(func,
1403  "frame",
1404  1,
1405  MINFRAME,
1406  MAXFRAME,
1407  "Frame",
1408  "Frame number to insert marker to",
1409  MINFRAME,
1410  MAXFRAME);
1413  func,
1414  "co",
1415  2,
1416  NULL,
1417  -1.0,
1418  1.0,
1419  "Coordinate",
1420  "Place new marker at the given frame using specified in normalized space coordinates",
1421  -1.0,
1422  1.0);
1424  parm = RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Newly created marker");
1425  RNA_def_function_return(func, parm);
1426 
1427  func = RNA_def_function(srna, "delete_frame", "rna_trackingMarkers_delete_frame");
1428  RNA_def_function_ui_description(func, "Delete marker at specified frame");
1429  parm = RNA_def_int(func,
1430  "frame",
1431  1,
1432  MINFRAME,
1433  MAXFRAME,
1434  "Frame",
1435  "Frame number to delete marker from",
1436  MINFRAME,
1437  MAXFRAME);
1439 }
1440 
1442 {
1443  StructRNA *srna;
1444  PropertyRNA *prop;
1445 
1446  rna_def_trackingMarker(brna);
1447 
1448  srna = RNA_def_struct(brna, "MovieTrackingTrack", NULL);
1449  RNA_def_struct_path_func(srna, "rna_trackingTrack_path");
1451  srna, "Movie tracking track data", "Match-moving track data for tracking");
1452  RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
1453 
1454  /* name */
1455  prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1456  RNA_def_property_ui_text(prop, "Name", "Unique name of track");
1457  RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingTrack_name_set");
1460  RNA_def_struct_name_property(srna, prop);
1461 
1462  /* limit frames */
1463  prop = RNA_def_property(srna, "frames_limit", PROP_INT, PROP_NONE);
1465  RNA_def_property_int_sdna(prop, NULL, "frames_limit");
1467  RNA_def_property_range(prop, 0, SHRT_MAX);
1469  prop, "Frames Limit", "Every tracking cycle, this number of frames are tracked");
1470 
1471  /* pattern match */
1472  prop = RNA_def_property(srna, "pattern_match", PROP_ENUM, PROP_NONE);
1474  RNA_def_property_enum_sdna(prop, NULL, "pattern_match");
1478  prop, "Pattern Match", "Track pattern from given frame when tracking marker to next frame");
1479 
1480  /* margin */
1481  prop = RNA_def_property(srna, "margin", PROP_INT, PROP_PIXEL);
1483  RNA_def_property_int_sdna(prop, NULL, "margin");
1485  RNA_def_property_range(prop, 0, 300);
1487  prop, "Margin", "Distance from image boundary at which marker stops tracking");
1488 
1489  /* tracking motion model */
1490  prop = RNA_def_property(srna, "motion_model", PROP_ENUM, PROP_NONE);
1494  RNA_def_property_ui_text(prop, "Motion Model", "Default motion model to use for tracking");
1495 
1496  /* minimum correlation */
1497  prop = RNA_def_property(srna, "correlation_min", PROP_FLOAT, PROP_NONE);
1499  RNA_def_property_float_sdna(prop, NULL, "minimum_correlation");
1500  RNA_def_property_range(prop, 0.0f, 1.0f);
1501  RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.05, 3);
1503  "Correlation",
1504  "Minimal value of correlation between matched pattern and reference "
1505  "that is still treated as successful tracking");
1506 
1507  /* use_brute */
1508  prop = RNA_def_property(srna, "use_brute", PROP_BOOLEAN, PROP_NONE);
1512  prop, "Prepass", "Use a brute-force translation only pre-track before refinement");
1514 
1515  /* use_brute */
1516  prop = RNA_def_property(srna, "use_mask", PROP_BOOLEAN, PROP_NONE);
1519  prop,
1520  "Use Mask",
1521  "Use a grease pencil data-block as a mask to use only specified areas of pattern "
1522  "when tracking");
1524 
1525  /* use_normalization */
1526  prop = RNA_def_property(srna, "use_normalization", PROP_BOOLEAN, PROP_NONE);
1528  prop, NULL, "algorithm_flag", TRACK_ALGORITHM_FLAG_USE_NORMALIZATION);
1531  prop, "Normalize", "Normalize light intensities while tracking. Slower");
1533 
1534  /* markers */
1535  prop = RNA_def_property(srna, "markers", PROP_COLLECTION, PROP_NONE);
1536  RNA_def_property_struct_type(prop, "MovieTrackingMarker");
1537  RNA_def_property_collection_sdna(prop, NULL, "markers", "markersnr");
1538  RNA_def_property_ui_text(prop, "Markers", "Collection of markers in track");
1539  rna_def_trackingMarkers(brna, prop);
1540 
1541  /* ** channels ** */
1542 
1543  /* use_red_channel */
1544  prop = RNA_def_property(srna, "use_red_channel", PROP_BOOLEAN, PROP_NONE);
1547  RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
1549 
1550  /* use_green_channel */
1551  prop = RNA_def_property(srna, "use_green_channel", PROP_BOOLEAN, PROP_NONE);
1555  prop, "Use Green Channel", "Use green channel from footage for tracking");
1557 
1558  /* use_blue_channel */
1559  prop = RNA_def_property(srna, "use_blue_channel", PROP_BOOLEAN, PROP_NONE);
1562  RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
1564 
1565  /* preview_grayscale */
1566  prop = RNA_def_property(srna, "use_grayscale_preview", PROP_BOOLEAN, PROP_NONE);
1570  prop, "Grayscale", "Display what the tracking algorithm sees in the preview");
1572 
1573  /* preview_alpha */
1574  prop = RNA_def_property(srna, "use_alpha_preview", PROP_BOOLEAN, PROP_NONE);
1577  RNA_def_property_ui_text(prop, "Alpha", "Apply track's mask on displaying preview");
1579 
1580  /* has bundle */
1581  prop = RNA_def_property(srna, "has_bundle", PROP_BOOLEAN, PROP_NONE);
1584  RNA_def_property_ui_text(prop, "Has Bundle", "True if track has a valid bundle");
1585 
1586  /* bundle position */
1587  prop = RNA_def_property(srna, "bundle", PROP_FLOAT, PROP_TRANSLATION);
1588  RNA_def_property_array(prop, 3);
1589  RNA_def_property_float_sdna(prop, NULL, "bundle_pos");
1591  RNA_def_property_ui_text(prop, "Bundle", "Position of bundle reconstructed from this track");
1592  RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1593 
1594  /* hide */
1595  prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1598  RNA_def_property_ui_text(prop, "Hide", "Track is hidden");
1600 
1601  /* select */
1602  prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1604  prop, "rna_trackingTrack_select_get", "rna_trackingTrack_select_set");
1605  RNA_def_property_ui_text(prop, "Select", "Track is selected");
1607 
1608  /* select_anchor */
1609  prop = RNA_def_property(srna, "select_anchor", PROP_BOOLEAN, PROP_NONE);
1610  RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1611  RNA_def_property_ui_text(prop, "Select Anchor", "Track's anchor point is selected");
1613 
1614  /* select_pattern */
1615  prop = RNA_def_property(srna, "select_pattern", PROP_BOOLEAN, PROP_NONE);
1616  RNA_def_property_boolean_sdna(prop, NULL, "pat_flag", SELECT);
1617  RNA_def_property_ui_text(prop, "Select Pattern", "Track's pattern area is selected");
1619 
1620  /* select_search */
1621  prop = RNA_def_property(srna, "select_search", PROP_BOOLEAN, PROP_NONE);
1622  RNA_def_property_boolean_sdna(prop, NULL, "search_flag", SELECT);
1623  RNA_def_property_ui_text(prop, "Select Search", "Track's search area is selected");
1625 
1626  /* locked */
1627  prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1630  RNA_def_property_ui_text(prop, "Lock", "Track is locked and all changes to it are disabled");
1632 
1633  /* custom color */
1634  prop = RNA_def_property(srna, "use_custom_color", PROP_BOOLEAN, PROP_NONE);
1637  RNA_def_property_ui_text(prop, "Custom Color", "Use custom color instead of theme-defined");
1639 
1640  /* color */
1641  prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
1642  RNA_def_property_array(prop, 3);
1643  RNA_def_property_range(prop, 0.0f, 1.0f);
1645  prop,
1646  "Color",
1647  "Color of the track in the Movie Clip Editor and the 3D viewport after a solve");
1649 
1650  /* average error */
1651  prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1652  RNA_def_property_float_sdna(prop, NULL, "error");
1654  RNA_def_property_ui_text(prop, "Average Error", "Average error of re-projection");
1655 
1656  /* grease pencil */
1657  prop = RNA_def_property(srna, "grease_pencil", PROP_POINTER, PROP_NONE);
1658  RNA_def_property_pointer_sdna(prop, NULL, "gpd");
1659  RNA_def_property_struct_type(prop, "GreasePencil");
1661  prop, NULL, NULL, NULL, "rna_GPencil_datablocks_annotations_poll");
1663  RNA_def_property_ui_text(prop, "Grease Pencil", "Grease pencil data for this track");
1665 
1666  /* weight */
1667  prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
1668  RNA_def_property_float_sdna(prop, NULL, "weight");
1669  RNA_def_property_range(prop, 0.0f, 1.0f);
1670  RNA_def_property_ui_text(prop, "Weight", "Influence of this track on a final solution");
1671 
1672  /* weight_stab */
1673  prop = RNA_def_property(srna, "weight_stab", PROP_FLOAT, PROP_FACTOR);
1674  RNA_def_property_float_sdna(prop, NULL, "weight_stab");
1675  RNA_def_property_range(prop, 0.0f, 1.0f);
1676  RNA_def_property_ui_text(prop, "Stab Weight", "Influence of this track on 2D stabilization");
1677 
1678  /* offset */
1679  prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_TRANSLATION);
1680  RNA_def_property_array(prop, 2);
1681  RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1682  RNA_def_property_float_sdna(prop, NULL, "offset");
1683  RNA_def_property_ui_text(prop, "Offset", "Offset of track from the parenting point");
1685 }
1686 
1688 {
1689  StructRNA *srna;
1690  PropertyRNA *prop;
1691 
1692  srna = RNA_def_struct(brna, "MovieTrackingPlaneMarker", NULL);
1694  srna, "Movie Tracking Plane Marker Data", "Match-moving plane marker data for tracking");
1695 
1696  /* frame */
1697  prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
1698  RNA_def_property_int_sdna(prop, NULL, "framenr");
1699  RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
1700  RNA_def_property_int_funcs(prop, NULL, "rna_trackingPlaneMarker_frame_set", NULL);
1702 
1703  /* Corners */
1704  prop = RNA_def_property(srna, "corners", PROP_FLOAT, PROP_MATRIX);
1705  RNA_def_property_float_sdna(prop, NULL, "corners");
1708  RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1710  "Corners",
1711  "Array of coordinates which represents UI rectangle corners in "
1712  "frame normalized coordinates");
1714 
1715  /* enable */
1716  prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1718  RNA_def_property_ui_text(prop, "Mode", "Is marker muted for current frame");
1720 }
1721 
1723 {
1724  StructRNA *srna;
1725  FunctionRNA *func;
1726  PropertyRNA *parm;
1727 
1728  RNA_def_property_srna(cprop, "MovieTrackingPlaneMarkers");
1729  srna = RNA_def_struct(brna, "MovieTrackingPlaneMarkers", NULL);
1730  RNA_def_struct_sdna(srna, "MovieTrackingPlaneTrack");
1732  "Movie Tracking Plane Markers",
1733  "Collection of markers for movie tracking plane track");
1734 
1735  func = RNA_def_function(srna, "find_frame", "rna_trackingPlaneMarkers_find_frame");
1736  RNA_def_function_ui_description(func, "Get plane marker for specified frame");
1737  parm = RNA_def_int(func,
1738  "frame",
1739  1,
1740  MINFRAME,
1741  MAXFRAME,
1742  "Frame",
1743  "Frame number to find marker for",
1744  MINFRAME,
1745  MAXFRAME);
1747  RNA_def_boolean(func,
1748  "exact",
1749  true,
1750  "Exact",
1751  "Get plane marker at exact frame number rather than get estimated marker");
1752  parm = RNA_def_pointer(
1753  func, "plane_marker", "MovieTrackingPlaneMarker", "", "Plane marker for specified frame");
1754  RNA_def_function_return(func, parm);
1755 
1756  func = RNA_def_function(srna, "insert_frame", "rna_trackingPlaneMarkers_insert_frame");
1757  RNA_def_function_ui_description(func, "Insert a new plane marker at the specified frame");
1758  parm = RNA_def_int(func,
1759  "frame",
1760  1,
1761  MINFRAME,
1762  MAXFRAME,
1763  "Frame",
1764  "Frame number to insert marker to",
1765  MINFRAME,
1766  MAXFRAME);
1768  parm = RNA_def_pointer(
1769  func, "plane_marker", "MovieTrackingPlaneMarker", "", "Newly created plane marker");
1770  RNA_def_function_return(func, parm);
1771 
1772  func = RNA_def_function(srna, "delete_frame", "rna_trackingPlaneMarkers_delete_frame");
1773  RNA_def_function_ui_description(func, "Delete plane marker at specified frame");
1774  parm = RNA_def_int(func,
1775  "frame",
1776  1,
1777  MINFRAME,
1778  MAXFRAME,
1779  "Frame",
1780  "Frame number to delete plane marker from",
1781  MINFRAME,
1782  MAXFRAME);
1784 }
1785 
1787 {
1788  StructRNA *srna;
1789  PropertyRNA *prop;
1790 
1792 
1793  srna = RNA_def_struct(brna, "MovieTrackingPlaneTrack", NULL);
1794  RNA_def_struct_path_func(srna, "rna_trackingPlaneTrack_path");
1796  srna, "Movie tracking plane track data", "Match-moving plane track data for tracking");
1797  RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
1798 
1799  /* name */
1800  prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1801  RNA_def_property_ui_text(prop, "Name", "Unique name of track");
1802  RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingPlaneTrack_name_set");
1805  RNA_def_struct_name_property(srna, prop);
1806 
1807  /* markers */
1808  prop = RNA_def_property(srna, "markers", PROP_COLLECTION, PROP_NONE);
1809  RNA_def_property_struct_type(prop, "MovieTrackingPlaneMarker");
1810  RNA_def_property_collection_sdna(prop, NULL, "markers", "markersnr");
1811  RNA_def_property_ui_text(prop, "Markers", "Collection of markers in track");
1812  rna_def_trackingPlaneMarkers(brna, prop);
1813 
1814  /* select */
1815  prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1816  RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1817  RNA_def_property_ui_text(prop, "Select", "Plane track is selected");
1819 
1820  /* auto keyframing */
1821  prop = RNA_def_property(srna, "use_auto_keying", PROP_BOOLEAN, PROP_NONE);
1825  prop, "Auto Keyframe", "Automatic keyframe insertion when moving plane corners");
1826  RNA_def_property_ui_icon(prop, ICON_REC, 0);
1827 
1828  /* image */
1829  prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1830  RNA_def_property_struct_type(prop, "Image");
1833  prop, "Image", "Image displayed in the track during editing in clip editor");
1835 
1836  /* image opacity */
1837  prop = RNA_def_property(srna, "image_opacity", PROP_FLOAT, PROP_FACTOR);
1839  RNA_def_property_range(prop, 0.0, 1.0);
1840  RNA_def_property_ui_text(prop, "Image Opacity", "Opacity of the image");
1842 }
1843 
1845 {
1846  StructRNA *srna;
1847  PropertyRNA *prop;
1848 
1849  static const EnumPropertyItem filter_items[] = {
1851  "NEAREST",
1852  0,
1853  "Nearest",
1854  "No interpolation, use nearest neighbor pixel"},
1856  "BILINEAR",
1857  0,
1858  "Bilinear",
1859  "Simple interpolation between adjacent pixels"},
1860  {TRACKING_FILTER_BICUBIC, "BICUBIC", 0, "Bicubic", "High quality pixel interpolation"},
1861  {0, NULL, 0, NULL, NULL},
1862  };
1863 
1864  srna = RNA_def_struct(brna, "MovieTrackingStabilization", NULL);
1865  RNA_def_struct_path_func(srna, "rna_trackingStabilization_path");
1867  srna, "Movie tracking stabilization data", "2D stabilization based on tracking markers");
1868 
1869  /* 2d stabilization */
1870  prop = RNA_def_property(srna, "use_2d_stabilization", PROP_BOOLEAN, PROP_NONE);
1873  RNA_def_property_ui_text(prop, "Use 2D Stabilization", "Use 2D stabilization for footage");
1874  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1875 
1876  /* use_stabilize_rotation */
1877  prop = RNA_def_property(srna, "use_stabilize_rotation", PROP_BOOLEAN, PROP_NONE);
1881  prop, "Stabilize Rotation", "Stabilize detected rotation around center of frame");
1882  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1883 
1884  /* use_stabilize_scale */
1885  prop = RNA_def_property(srna, "use_stabilize_scale", PROP_BOOLEAN, PROP_NONE);
1889  prop, "Stabilize Scale", "Compensate any scale changes relative to center of rotation");
1890  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1891 
1892  /* tracks */
1893  prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1895  "rna_tracking_stabTracks_begin",
1896  "rna_iterator_listbase_next",
1897  "rna_iterator_listbase_end",
1898  "rna_iterator_listbase_get",
1899  NULL,
1900  NULL,
1901  NULL,
1902  NULL);
1903  RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1905  prop, "Translation Tracks", "Collection of tracks used for 2D stabilization (translation)");
1906  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1907 
1908  /* active track index */
1909  prop = RNA_def_property(srna, "active_track_index", PROP_INT, PROP_NONE);
1910  RNA_def_property_int_sdna(prop, NULL, "act_track");
1913  "rna_tracking_stabTracks_active_index_get",
1914  "rna_tracking_stabTracks_active_index_set",
1915  "rna_tracking_stabTracks_active_index_range");
1917  "Active Track Index",
1918  "Index of active track in translation stabilization tracks list");
1919 
1920  /* tracks used for rotation stabilization */
1921  prop = RNA_def_property(srna, "rotation_tracks", PROP_COLLECTION, PROP_NONE);
1923  "rna_tracking_stabRotTracks_begin",
1924  "rna_iterator_listbase_next",
1925  "rna_iterator_listbase_end",
1926  "rna_iterator_listbase_get",
1927  NULL,
1928  NULL,
1929  NULL,
1930  NULL);
1931  RNA_def_property_struct_type(prop, "MovieTrackingTrack");
1933  prop, "Rotation Tracks", "Collection of tracks used for 2D stabilization (translation)");
1934  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1935 
1936  /* active rotation track index */
1937  prop = RNA_def_property(srna, "active_rotation_track_index", PROP_INT, PROP_NONE);
1938  RNA_def_property_int_sdna(prop, NULL, "act_rot_track");
1941  "rna_tracking_stabRotTracks_active_index_get",
1942  "rna_tracking_stabRotTracks_active_index_set",
1943  "rna_tracking_stabRotTracks_active_index_range");
1945  "Active Rotation Track Index",
1946  "Index of active track in rotation stabilization tracks list");
1947 
1948  /* anchor frame */
1949  prop = RNA_def_property(srna, "anchor_frame", PROP_INT, PROP_NONE);
1950  RNA_def_property_int_sdna(prop, NULL, "anchor_frame");
1954  "Anchor Frame",
1955  "Reference point to anchor stabilization "
1956  "(other frames will be adjusted relative to this frame's position)");
1957  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1958 
1959  /* target position */
1960  prop = RNA_def_property(srna, "target_position", PROP_FLOAT, PROP_TRANSLATION);
1961  RNA_def_property_array(prop, 2);
1963  prop, -FLT_MAX, FLT_MAX, 1, 3); /* increment in steps of 0.01 and show 3 digit after point */
1964  RNA_def_property_float_sdna(prop, NULL, "target_pos");
1966  "Expected Position",
1967  "Known relative offset of original shot, will be subtracted "
1968  "(e.g. for panning shot, can be animated)");
1970 
1971  /* target rotation */
1972  prop = RNA_def_property(srna, "target_rotation", PROP_FLOAT, PROP_ANGLE);
1973  RNA_def_property_float_sdna(prop, NULL, "target_rot");
1974  RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1975  RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 10.0f, 3);
1977  prop,
1978  "Expected Rotation",
1979  "Rotation present on original shot, will be compensated (e.g. for deliberate tilting)");
1981 
1982  /* target scale */
1983  prop = RNA_def_property(srna, "target_scale", PROP_FLOAT, PROP_FACTOR);
1984  RNA_def_property_float_sdna(prop, NULL, "scale");
1985  RNA_def_property_range(prop, FLT_EPSILON, FLT_MAX);
1987  prop, 0.01f, 10.0f, 0.001f, 3); /* increment in steps of 0.001. Show 3 digit after point */
1989  "Expected Scale",
1990  "Explicitly scale resulting frame to compensate zoom of original shot");
1991  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1992 
1993  /* Auto-scale. */
1994  prop = RNA_def_property(srna, "use_autoscale", PROP_BOOLEAN, PROP_NONE);
1998  prop, "Autoscale", "Automatically scale footage to cover unfilled areas when stabilizing");
1999  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2000 
2001  /* max scale */
2002  prop = RNA_def_property(srna, "scale_max", PROP_FLOAT, PROP_FACTOR);
2003  RNA_def_property_float_sdna(prop, NULL, "maxscale");
2004  RNA_def_property_range(prop, 0.0f, 10.0f);
2005  RNA_def_property_ui_text(prop, "Maximal Scale", "Limit the amount of automatic scaling");
2006  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2007 
2008  /* influence_location */
2009  prop = RNA_def_property(srna, "influence_location", PROP_FLOAT, PROP_FACTOR);
2010  RNA_def_property_float_sdna(prop, NULL, "locinf");
2011  RNA_def_property_range(prop, 0.0f, 1.0f);
2013  prop, "Location Influence", "Influence of stabilization algorithm on footage location");
2014  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2015 
2016  /* influence_scale */
2017  prop = RNA_def_property(srna, "influence_scale", PROP_FLOAT, PROP_FACTOR);
2018  RNA_def_property_float_sdna(prop, NULL, "scaleinf");
2019  RNA_def_property_range(prop, 0.0f, 1.0f);
2021  prop, "Scale Influence", "Influence of stabilization algorithm on footage scale");
2022  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2023 
2024  /* influence_rotation */
2025  prop = RNA_def_property(srna, "influence_rotation", PROP_FLOAT, PROP_FACTOR);
2026  RNA_def_property_float_sdna(prop, NULL, "rotinf");
2027  RNA_def_property_range(prop, 0.0f, 1.0f);
2029  prop, "Rotation Influence", "Influence of stabilization algorithm on footage rotation");
2030  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2031 
2032  /* filter */
2033  prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
2034  RNA_def_property_enum_sdna(prop, NULL, "filter");
2035  RNA_def_property_enum_items(prop, filter_items);
2037  prop,
2038  "Interpolate",
2039  "Interpolation to use for sub-pixel shifts and rotations due to stabilization");
2040  RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2041 
2042  /* UI display : show participating tracks */
2043  prop = RNA_def_property(srna, "show_tracks_expanded", PROP_BOOLEAN, PROP_NONE);
2047  prop, "Show Tracks", "Show UI list of tracks participating in stabilization");
2048  RNA_def_property_ui_icon(prop, ICON_DISCLOSURE_TRI_RIGHT, 1);
2049 }
2050 
2052 {
2053  StructRNA *srna;
2054  PropertyRNA *prop;
2055 
2056  srna = RNA_def_struct(brna, "MovieReconstructedCamera", NULL);
2058  "Movie tracking reconstructed camera data",
2059  "Match-moving reconstructed camera data from tracker");
2060 
2061  /* frame */
2062  prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
2064  RNA_def_property_int_sdna(prop, NULL, "framenr");
2065  RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
2066 
2067  /* matrix */
2068  prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
2069  RNA_def_property_float_sdna(prop, NULL, "mat");
2072  RNA_def_property_ui_text(prop, "Matrix", "Worldspace transformation matrix");
2073 
2074  /* average_error */
2075  prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
2076  RNA_def_property_float_sdna(prop, NULL, "error");
2078  RNA_def_property_ui_text(prop, "Average Error", "Average error of reconstruction");
2079 }
2080 
2082 {
2083  StructRNA *srna;
2084  FunctionRNA *func;
2085  PropertyRNA *parm;
2086 
2087  srna = RNA_def_struct(brna, "MovieTrackingReconstructedCameras", NULL);
2088  RNA_def_struct_sdna(srna, "MovieTrackingReconstruction");
2089  RNA_def_struct_ui_text(srna, "Reconstructed Cameras", "Collection of solved cameras");
2090 
2091  func = RNA_def_function(srna, "find_frame", "rna_trackingCameras_find_frame");
2093  RNA_def_function_ui_description(func, "Find a reconstructed camera for a give frame number");
2094  RNA_def_int(func,
2095  "frame",
2096  1,
2097  MINFRAME,
2098  MAXFRAME,
2099  "Frame",
2100  "Frame number to find camera for",
2101  MINFRAME,
2102  MAXFRAME);
2103  parm = RNA_def_pointer(
2104  func, "camera", "MovieReconstructedCamera", "", "Camera for a given frame");
2105  RNA_def_function_return(func, parm);
2106 
2107  func = RNA_def_function(srna, "matrix_from_frame", "rna_trackingCameras_matrix_from_frame");
2109  RNA_def_function_ui_description(func, "Return interpolated camera matrix for a given frame");
2110  RNA_def_int(func,
2111  "frame",
2112  1,
2113  MINFRAME,
2114  MAXFRAME,
2115  "Frame",
2116  "Frame number to find camera for",
2117  MINFRAME,
2118  MAXFRAME);
2119  parm = RNA_def_float_matrix(func,
2120  "matrix",
2121  4,
2122  4,
2123  NULL,
2124  -FLT_MAX,
2125  FLT_MAX,
2126  "Matrix",
2127  "Interpolated camera matrix for a given frame",
2128  -FLT_MAX,
2129  FLT_MAX);
2130  RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0); /* needed for string return value */
2131  RNA_def_function_output(func, parm);
2132 }
2133 
2135 {
2136  StructRNA *srna;
2137  PropertyRNA *prop;
2138 
2140 
2141  srna = RNA_def_struct(brna, "MovieTrackingReconstruction", NULL);
2143  srna, "Movie tracking reconstruction data", "Match-moving reconstruction data from tracker");
2144 
2145  /* is_valid */
2146  prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
2150  prop, "Reconstructed", "Is tracking data contains valid reconstruction information");
2151 
2152  /* average_error */
2153  prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
2154  RNA_def_property_float_sdna(prop, NULL, "error");
2156  RNA_def_property_ui_text(prop, "Average Error", "Average error of reconstruction");
2157 
2158  /* cameras */
2159  prop = RNA_def_property(srna, "cameras", PROP_COLLECTION, PROP_NONE);
2160  RNA_def_property_struct_type(prop, "MovieReconstructedCamera");
2161  RNA_def_property_collection_sdna(prop, NULL, "cameras", "camnr");
2162  RNA_def_property_ui_text(prop, "Cameras", "Collection of solved cameras");
2163  RNA_def_property_srna(prop, "MovieTrackingReconstructedCameras");
2164 }
2165 
2167 {
2168  StructRNA *srna;
2169  FunctionRNA *func;
2170  PropertyRNA *prop;
2171  PropertyRNA *parm;
2172 
2173  srna = RNA_def_struct(brna, "MovieTrackingTracks", NULL);
2174  RNA_def_struct_sdna(srna, "MovieTracking");
2175  RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
2176 
2177  func = RNA_def_function(srna, "new", "rna_trackingTracks_new");
2179  RNA_def_function_ui_description(func, "Create new motion track in this movie clip");
2180  RNA_def_string(func, "name", NULL, 0, "", "Name of new track");
2181  RNA_def_int(func,
2182  "frame",
2183  1,
2184  MINFRAME,
2185  MAXFRAME,
2186  "Frame",
2187  "Frame number to add track on",
2188  MINFRAME,
2189  MAXFRAME);
2190  parm = RNA_def_pointer(func, "track", "MovieTrackingTrack", "", "Newly created track");
2191  RNA_def_function_return(func, parm);
2192 
2193  /* active track */
2194  prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2195  RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2197  prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", NULL, NULL);
2199  RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
2200 }
2201 
2203 {
2204  StructRNA *srna;
2205  PropertyRNA *prop;
2206 
2207  srna = RNA_def_struct(brna, "MovieTrackingPlaneTracks", NULL);
2208  RNA_def_struct_sdna(srna, "MovieTracking");
2209  RNA_def_struct_ui_text(srna, "Movie Plane Tracks", "Collection of movie tracking plane tracks");
2210 
2211  /* TODO(sergey): Add API to create new plane tracks */
2212 
2213  /* active plane track */
2214  prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2215  RNA_def_property_struct_type(prop, "MovieTrackingPlaneTrack");
2217  "rna_tracking_active_plane_track_get",
2218  "rna_tracking_active_plane_track_set",
2219  NULL,
2220  NULL);
2223  prop, "Active Plane Track", "Active plane track in this tracking data object");
2224 }
2225 
2227 {
2228  StructRNA *srna;
2229  FunctionRNA *func;
2230  PropertyRNA *prop;
2231  PropertyRNA *parm;
2232 
2233  srna = RNA_def_struct(brna, "MovieTrackingObjectTracks", NULL);
2234  RNA_def_struct_sdna(srna, "MovieTrackingObject");
2235  RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
2236 
2237  func = RNA_def_function(srna, "new", "rna_trackingObject_tracks_new");
2239  RNA_def_function_ui_description(func, "create new motion track in this movie clip");
2240  RNA_def_string(func, "name", NULL, 0, "", "Name of new track");
2241  RNA_def_int(func,
2242  "frame",
2243  1,
2244  MINFRAME,
2245  MAXFRAME,
2246  "Frame",
2247  "Frame number to add tracks on",
2248  MINFRAME,
2249  MAXFRAME);
2250  parm = RNA_def_pointer(func, "track", "MovieTrackingTrack", "", "Newly created track");
2251  RNA_def_function_return(func, parm);
2252 
2253  /* active track */
2254  prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2255  RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2257  prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", NULL, NULL);
2259  RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
2260 }
2261 
2263 {
2264  StructRNA *srna;
2265  PropertyRNA *prop;
2266 
2267  srna = RNA_def_struct(brna, "MovieTrackingObjectPlaneTracks", NULL);
2268  RNA_def_struct_sdna(srna, "MovieTrackingObject");
2269  RNA_def_struct_ui_text(srna, "Plane Tracks", "Collection of tracking plane tracks");
2270 
2271  /* active track */
2272  prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2273  RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2275  "rna_tracking_active_plane_track_get",
2276  "rna_tracking_active_plane_track_set",
2277  NULL,
2278  NULL);
2280  RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
2281 }
2282 
2284 {
2285  StructRNA *srna;
2286  PropertyRNA *prop;
2287 
2288  srna = RNA_def_struct(brna, "MovieTrackingObject", NULL);
2290  srna, "Movie tracking object data", "Match-moving object tracking and reconstruction data");
2291 
2292  /* name */
2293  prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2294  RNA_def_property_ui_text(prop, "Name", "Unique name of object");
2295  RNA_def_property_string_funcs(prop, NULL, NULL, "rna_trackingObject_name_set");
2298  RNA_def_struct_name_property(srna, prop);
2299 
2300  /* is_camera */
2301  prop = RNA_def_property(srna, "is_camera", PROP_BOOLEAN, PROP_NONE);
2304  RNA_def_property_ui_text(prop, "Camera", "Object is used for camera tracking");
2306 
2307  /* tracks */
2308  prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
2310  "rna_trackingObject_tracks_begin",
2311  "rna_iterator_listbase_next",
2312  "rna_iterator_listbase_end",
2313  "rna_iterator_listbase_get",
2314  NULL,
2315  NULL,
2316  NULL,
2317  NULL);
2318  RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2319  RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks in this tracking data object");
2320  RNA_def_property_srna(prop, "MovieTrackingObjectTracks");
2321 
2322  /* plane tracks */
2323  prop = RNA_def_property(srna, "plane_tracks", PROP_COLLECTION, PROP_NONE);
2325  "rna_trackingObject_plane_tracks_begin",
2326  "rna_iterator_listbase_next",
2327  "rna_iterator_listbase_end",
2328  "rna_iterator_listbase_get",
2329  NULL,
2330  NULL,
2331  NULL,
2332  NULL);
2333  RNA_def_property_struct_type(prop, "MovieTrackingPlaneTrack");
2335  prop, "Plane Tracks", "Collection of plane tracks in this tracking data object");
2336  RNA_def_property_srna(prop, "MovieTrackingObjectPlaneTracks");
2337 
2338  /* reconstruction */
2339  prop = RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
2340  RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
2341  RNA_def_property_pointer_funcs(prop, "rna_trackingObject_reconstruction_get", NULL, NULL, NULL);
2342 
2343  /* scale */
2344  prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
2346  RNA_def_property_float_sdna(prop, NULL, "scale");
2347  RNA_def_property_range(prop, 0.0001f, 10000.0f);
2348  RNA_def_property_ui_range(prop, 0.0001f, 10000.0, 1, 4);
2349  RNA_def_property_float_default(prop, 1.0f);
2350  RNA_def_property_ui_text(prop, "Scale", "Scale of object solution in camera space");
2351  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingObject_flushUpdate");
2352 
2353  /* keyframe_a */
2354  prop = RNA_def_property(srna, "keyframe_a", PROP_INT, PROP_NONE);
2356  RNA_def_property_int_sdna(prop, NULL, "keyframe1");
2358  prop, "Keyframe A", "First keyframe used for reconstruction initialization");
2360 
2361  /* keyframe_b */
2362  prop = RNA_def_property(srna, "keyframe_b", PROP_INT, PROP_NONE);
2364  RNA_def_property_int_sdna(prop, NULL, "keyframe2");
2366  prop, "Keyframe B", "Second keyframe used for reconstruction initialization");
2368 }
2369 
2371 {
2372  StructRNA *srna;
2373  PropertyRNA *prop;
2374 
2375  FunctionRNA *func;
2376  PropertyRNA *parm;
2377 
2378  RNA_def_property_srna(cprop, "MovieTrackingObjects");
2379  srna = RNA_def_struct(brna, "MovieTrackingObjects", NULL);
2380  RNA_def_struct_sdna(srna, "MovieTracking");
2381  RNA_def_struct_ui_text(srna, "Movie Objects", "Collection of movie tracking objects");
2382 
2383  func = RNA_def_function(srna, "new", "rna_trackingObject_new");
2384  RNA_def_function_ui_description(func, "Add tracking object to this movie clip");
2385  parm = RNA_def_string(func, "name", NULL, 0, "", "Name of new object");
2387  parm = RNA_def_pointer(func, "object", "MovieTrackingObject", "", "New motion tracking object");
2388  RNA_def_function_return(func, parm);
2389 
2390  func = RNA_def_function(srna, "remove", "rna_trackingObject_remove");
2392  RNA_def_function_ui_description(func, "Remove tracking object from this movie clip");
2393  parm = RNA_def_pointer(
2394  func, "object", "MovieTrackingObject", "", "Motion tracking object to be removed");
2397 
2398  /* active object */
2399  prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2400  RNA_def_property_struct_type(prop, "MovieTrackingObject");
2402  prop, "rna_tracking_active_object_get", "rna_tracking_active_object_set", NULL, NULL);
2404  RNA_def_property_ui_text(prop, "Active Object", "Active object in this tracking data object");
2405 }
2406 
2408 {
2409  StructRNA *srna;
2410  PropertyRNA *prop;
2411 
2412  static const EnumPropertyItem sort_items[] = {
2413  {TRACKING_DOPE_SORT_NAME, "NAME", 0, "Name", "Sort channels by their names"},
2415  "LONGEST",
2416  0,
2417  "Longest",
2418  "Sort channels by longest tracked segment"},
2420  "TOTAL",
2421  0,
2422  "Total",
2423  "Sort channels by overall amount of tracked segments"},
2425  "AVERAGE_ERROR",
2426  0,
2427  "Average Error",
2428  "Sort channels by average reprojection error of tracks after solve"},
2429  {TRACKING_DOPE_SORT_START, "START", 0, "Start Frame", "Sort channels by first frame number"},
2430  {TRACKING_DOPE_SORT_END, "END", 0, "End Frame", "Sort channels by last frame number"},
2431  {0, NULL, 0, NULL, NULL},
2432  };
2433 
2434  srna = RNA_def_struct(brna, "MovieTrackingDopesheet", NULL);
2435  RNA_def_struct_ui_text(srna, "Movie Tracking Dopesheet", "Match-moving dopesheet data");
2436 
2437  /* dopesheet sort */
2438  prop = RNA_def_property(srna, "sort_method", PROP_ENUM, PROP_NONE);
2439  RNA_def_property_enum_sdna(prop, NULL, "sort_method");
2440  RNA_def_property_enum_items(prop, sort_items);
2442  prop, "Dopesheet Sort Field", "Method to be used to sort channels in dopesheet view");
2443  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2444 
2445  /* invert_dopesheet_sort */
2446  prop = RNA_def_property(srna, "use_invert_sort", PROP_BOOLEAN, PROP_NONE);
2449  prop, "Invert Dopesheet Sort", "Invert sort order of dopesheet channels");
2450  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2451 
2452  /* show_only_selected */
2453  prop = RNA_def_property(srna, "show_only_selected", PROP_BOOLEAN, PROP_NONE);
2456  prop, "Only Show Selected", "Only include channels relating to selected objects and data");
2457  RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 0);
2458  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2459 
2460  /* show_hidden */
2461  prop = RNA_def_property(srna, "show_hidden", PROP_BOOLEAN, PROP_NONE);
2464  prop, "Display Hidden", "Include channels from objects/bone that aren't visible");
2465  RNA_def_property_ui_icon(prop, ICON_GHOST_ENABLED, 0);
2466  RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2467 }
2468 
2469 static void rna_def_tracking(BlenderRNA *brna)
2470 {
2471  StructRNA *srna;
2472  PropertyRNA *prop;
2473 
2475  rna_def_trackingCamera(brna);
2476  rna_def_trackingTrack(brna);
2478  rna_def_trackingTracks(brna);
2485  rna_def_trackingObject(brna);
2487 
2488  srna = RNA_def_struct(brna, "MovieTracking", NULL);
2489  RNA_def_struct_path_func(srna, "rna_tracking_path");
2490  RNA_def_struct_ui_text(srna, "Movie tracking data", "Match-moving data for tracking");
2491 
2492  /* settings */
2493  prop = RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
2494  RNA_def_property_struct_type(prop, "MovieTrackingSettings");
2495 
2496  /* camera properties */
2497  prop = RNA_def_property(srna, "camera", PROP_POINTER, PROP_NONE);
2498  RNA_def_property_struct_type(prop, "MovieTrackingCamera");
2499 
2500  /* tracks */
2501  prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
2503  "rna_trackingTracks_begin",
2504  "rna_iterator_listbase_next",
2505  "rna_iterator_listbase_end",
2506  "rna_iterator_listbase_get",
2507  NULL,
2508  NULL,
2509  NULL,
2510  NULL);
2511  RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2512  RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks in this tracking data object");
2513  RNA_def_property_srna(prop, "MovieTrackingTracks");
2514 
2515  /* tracks */
2516  prop = RNA_def_property(srna, "plane_tracks", PROP_COLLECTION, PROP_NONE);
2518  "rna_trackingPlaneTracks_begin",
2519  "rna_iterator_listbase_next",
2520  "rna_iterator_listbase_end",
2521  "rna_iterator_listbase_get",
2522  NULL,
2523  NULL,
2524  NULL,
2525  NULL);
2526  RNA_def_property_struct_type(prop, "MovieTrackingPlaneTrack");
2528  prop, "Plane Tracks", "Collection of plane tracks in this tracking data object");
2529  RNA_def_property_srna(prop, "MovieTrackingPlaneTracks");
2530 
2531  /* stabilization */
2532  prop = RNA_def_property(srna, "stabilization", PROP_POINTER, PROP_NONE);
2533  RNA_def_property_struct_type(prop, "MovieTrackingStabilization");
2534 
2535  /* reconstruction */
2536  prop = RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
2537  RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
2538 
2539  /* objects */
2540  prop = RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
2542  "rna_trackingObjects_begin",
2543  "rna_iterator_listbase_next",
2544  "rna_iterator_listbase_end",
2545  "rna_iterator_listbase_get",
2546  NULL,
2547  NULL,
2548  NULL,
2549  NULL);
2550  RNA_def_property_struct_type(prop, "MovieTrackingObject");
2551  RNA_def_property_ui_text(prop, "Objects", "Collection of objects in this tracking data object");
2552  rna_def_trackingObjects(brna, prop);
2553 
2554  /* active object index */
2555  prop = RNA_def_property(srna, "active_object_index", PROP_INT, PROP_NONE);
2556  RNA_def_property_int_sdna(prop, NULL, "objectnr");
2559  "rna_tracking_active_object_index_get",
2560  "rna_tracking_active_object_index_set",
2561  "rna_tracking_active_object_index_range");
2562  RNA_def_property_ui_text(prop, "Active Object Index", "Index of active object");
2564 
2565  /* dopesheet */
2566  prop = RNA_def_property(srna, "dopesheet", PROP_POINTER, PROP_NONE);
2567  RNA_def_property_struct_type(prop, "MovieTrackingDopesheet");
2568 }
2569 
2571 {
2572  rna_def_tracking(brna);
2573 }
2574 
2575 #endif
typedef float(TangentPoint)[2]
struct AnimData * BKE_animdata_from_id(const struct ID *id)
void BKE_animdata_fix_paths_rename(struct ID *owner_id, struct AnimData *adt, struct ID *ref_id, const char *prefix, const char *oldName, const char *newName, int oldSubscript, int newSubscript, bool verify_paths)
Definition: anim_data.c:958
void BKE_movieclip_get_size(struct MovieClip *clip, struct MovieClipUser *user, int *width, int *height)
Definition: movieclip.c:1520
void BKE_ntree_update_tag_id_changed(struct Main *bmain, struct ID *id)
void BKE_ntree_update_main(struct Main *bmain, struct NodeTreeUpdateExtraParams *params)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
struct MovieTrackingPlaneTrack * BKE_tracking_plane_track_get_active(struct MovieTracking *tracking)
Definition: tracking.c:1718
void BKE_tracking_plane_marker_delete(struct MovieTrackingPlaneTrack *plane_track, int framenr)
Definition: tracking.c:1859
struct ListBase * BKE_tracking_find_tracks_list_for_track(struct MovieTracking *tracking, const struct MovieTrackingTrack *track)
bool BKE_tracking_object_delete(struct MovieTracking *tracking, struct MovieTrackingObject *object)
Definition: tracking.c:2027
struct ListBase * BKE_tracking_get_active_tracks(struct MovieTracking *tracking)
Definition: tracking.c:346
struct MovieTrackingPlaneMarker * BKE_tracking_plane_marker_insert(struct MovieTrackingPlaneTrack *plane_track, struct MovieTrackingPlaneMarker *plane_marker)
Definition: tracking.c:1818
void BKE_tracking_camera_get_reconstructed_interpolate(struct MovieTracking *tracking, struct MovieTrackingObject *object, float framenr, float mat[4][4])
Definition: tracking.c:2269
struct MovieTrackingMarker * BKE_tracking_marker_insert(struct MovieTrackingTrack *track, struct MovieTrackingMarker *marker)
Definition: tracking.c:1302
struct MovieTrackingObject * BKE_tracking_object_add(struct MovieTracking *tracking, const char *name)
Definition: tracking.c:1998
struct MovieReconstructedCamera * BKE_tracking_camera_get_reconstructed(struct MovieTracking *tracking, struct MovieTrackingObject *object, int framenr)
Definition: tracking.c:2252
void BKE_tracking_get_rna_path_for_track(const struct MovieTracking *tracking, const struct MovieTrackingTrack *track, char *rna_path, size_t rna_path_len)
Definition: tracking.c:3495
#define TRACK_SELECTED(track)
Definition: BKE_tracking.h:823
void BKE_tracking_plane_track_unique_name(struct ListBase *plane_tracks_base, struct MovieTrackingPlaneTrack *plane_track)
Definition: tracking.c:1683
void BKE_tracking_get_rna_path_prefix_for_track(const struct MovieTracking *tracking, const struct MovieTrackingTrack *track, char *rna_path, size_t rna_path_len)
Definition: tracking.c:3517
void BKE_tracking_track_unique_name(struct ListBase *tracksbase, struct MovieTrackingTrack *track)
Definition: tracking.c:596
void BKE_tracking_object_unique_name(struct MovieTracking *tracking, struct MovieTrackingObject *object)
Definition: tracking.c:2067
struct MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get(struct MovieTrackingPlaneTrack *plane_track, int framenr)
Definition: tracking.c:1890
struct MovieTrackingTrack * BKE_tracking_track_get_active(struct MovieTracking *tracking)
Definition: tracking.c:1089
void BKE_tracking_dopesheet_tag_update(struct MovieTracking *tracking)
Definition: tracking.c:3411
struct MovieTrackingMarker * BKE_tracking_marker_get_exact(struct MovieTrackingTrack *track, int framenr)
Definition: tracking.c:1457
struct ListBase * BKE_tracking_get_active_plane_tracks(struct MovieTracking *tracking)
Definition: tracking.c:357
struct MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get_exact(struct MovieTrackingPlaneTrack *plane_track, int framenr)
Definition: tracking.c:1938
struct ListBase * BKE_tracking_find_tracks_list_for_plane_track(struct MovieTracking *tracking, const struct MovieTrackingPlaneTrack *plane_track)
void BKE_tracking_get_rna_path_for_plane_track(const struct MovieTracking *tracking, const struct MovieTrackingPlaneTrack *plane_track, char *rna_path, size_t rna_path_len)
Definition: tracking.c:3533
void BKE_tracking_distortion_free(struct MovieDistortion *distortion)
Definition: tracking.c:2450
void BKE_tracking_marker_clamp_search_size(struct MovieTrackingMarker *marker)
Definition: tracking.c:1393
struct ListBase * BKE_tracking_object_get_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object)
Definition: tracking.c:2112
void BKE_tracking_get_rna_path_prefix_for_plane_track(const struct MovieTracking *tracking, const struct MovieTrackingPlaneTrack *plane_track, char *rna_path, size_t rna_path_len)
Definition: tracking.c:3555
void BKE_tracking_marker_pattern_minmax(const struct MovieTrackingMarker *marker, float min[2], float max[2])
struct MovieTrackingTrack * BKE_tracking_track_add(struct MovieTracking *tracking, struct ListBase *tracksbase, float x, float y, int framenr, int width, int height)
Definition: tracking.c:535
struct ListBase * BKE_tracking_object_get_plane_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object)
Definition: tracking.c:2121
struct MovieTrackingMarker * BKE_tracking_marker_get(struct MovieTrackingTrack *track, int framenr)
Definition: tracking.c:1424
void BKE_tracking_marker_delete(struct MovieTrackingTrack *track, int framenr)
Definition: tracking.c:1347
int BLI_findindex(const struct ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void * BLI_findlink(const struct ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
MINLINE int max_ii(int a, int b)
MINLINE void copy_v2_v2(float r[2], const float a[2])
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL() ATTR_MALLOC
Definition: string.c:42
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL()
Definition: string.c:64
#define UNUSED(x)
void DEG_id_tag_update(struct ID *id, int flag)
#define MAX_ID_NAME
Definition: DNA_ID.h:337
#define DNA_struct_default_get(struct_name)
Definition: DNA_defaults.h:29
#define MAX_NAME
Definition: DNA_defs.h:48
Object is a sort of wrapper for general info.
#define MINFRAME
#define MAXFRAME
@ PLANE_MARKER_DISABLED
@ TRACKING_CLEAN_DELETE_SEGMENT
@ TRACKING_CLEAN_SELECT
@ TRACKING_CLEAN_DELETE_TRACK
@ TRACKING_OBJECT_CAMERA
@ TRACKING_SPEED_DOUBLE
@ TRACKING_SPEED_HALF
@ TRACKING_SPEED_QUARTER
@ TRACKING_SPEED_REALTIME
@ TRACKING_AUTOSCALE
@ TRACKING_SHOW_STAB_TRACKS
@ TRACKING_STABILIZE_SCALE
@ TRACKING_STABILIZE_ROTATION
@ TRACKING_2D_STABILIZATION
@ TRACKING_FILTER_BICUBIC
@ TRACKING_FILTER_NEAREST
@ TRACKING_FILTER_BILINEAR
@ TRACK_ALGORITHM_FLAG_USE_NORMALIZATION
@ TRACK_ALGORITHM_FLAG_USE_BRUTE
@ TRACK_ALGORITHM_FLAG_USE_MASK
@ REFINE_PRINCIPAL_POINT
@ REFINE_TANGENTIAL_DISTORTION
@ REFINE_RADIAL_DISTORTION
@ REFINE_FOCAL_LENGTH
@ TRACKING_RECONSTRUCTED
@ PLANE_TRACK_AUTOKEY
@ MARKER_TRACKED
@ MARKER_DISABLED
@ TRACKING_MOTION_TRIPOD
@ TRACK_CUSTOMCOLOR
@ TRACK_PREVIEW_ALPHA
@ TRACK_DISABLE_BLUE
@ TRACK_HIDDEN
@ TRACK_PREVIEW_GRAYSCALE
@ TRACK_LOCKED
@ TRACK_USE_2D_STAB
@ TRACK_HAS_BUNDLE
@ TRACK_USE_2D_STAB_ROT
@ TRACK_DISABLE_RED
@ TRACK_DISABLE_GREEN
@ CAMERA_UNITS_MM
@ CAMERA_UNITS_PX
@ TRACKING_DISTORTION_MODEL_DIVISION
@ TRACKING_DISTORTION_MODEL_POLYNOMIAL
@ TRACKING_DISTORTION_MODEL_NUKE
@ TRACKING_DISTORTION_MODEL_BROWN
@ TRACKING_USE_KEYFRAME_SELECTION
@ TRACKING_DOPE_SELECTED_ONLY
@ TRACKING_DOPE_SORT_INVERSE
@ TRACKING_DOPE_SHOW_HIDDEN
@ TRACK_MOTION_MODEL_TRANSLATION_SCALE
@ TRACK_MOTION_MODEL_TRANSLATION
@ TRACK_MOTION_MODEL_TRANSLATION_ROTATION_SCALE
@ TRACK_MOTION_MODEL_TRANSLATION_ROTATION
@ TRACK_MOTION_MODEL_HOMOGRAPHY
@ TRACK_MOTION_MODEL_AFFINE
@ TRACKING_DOPE_SORT_START
@ TRACKING_DOPE_SORT_AVERAGE_ERROR
@ TRACKING_DOPE_SORT_LONGEST
@ TRACKING_DOPE_SORT_NAME
@ TRACKING_DOPE_SORT_END
@ TRACKING_DOPE_SORT_TOTAL
@ TRACK_MATCH_PREVIOS_FRAME
@ TRACK_MATCH_KEYFRAME
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei height
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei width
Read Guarded memory(de)allocation.
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between camera
#define RNA_POINTER_INVALIDATE(ptr)
Definition: RNA_access.h:744
@ PARM_RNAPTR
Definition: RNA_types.h:354
@ PARM_REQUIRED
Definition: RNA_types.h:352
@ FUNC_USE_REPORTS
Definition: RNA_types.h:663
@ FUNC_USE_SELF_ID
Definition: RNA_types.h:650
@ PROP_FLOAT
Definition: RNA_types.h:61
@ PROP_BOOLEAN
Definition: RNA_types.h:59
@ PROP_ENUM
Definition: RNA_types.h:63
@ PROP_INT
Definition: RNA_types.h:60
@ PROP_STRING
Definition: RNA_types.h:62
@ PROP_POINTER
Definition: RNA_types.h:64
@ PROP_COLLECTION
Definition: RNA_types.h:65
#define RNA_TRANSLATION_PREC_DEFAULT
Definition: RNA_types.h:117
@ PROP_THICK_WRAP
Definition: RNA_types.h:285
@ PROP_ANIMATABLE
Definition: RNA_types.h:202
@ PROP_NEVER_UNLINK
Definition: RNA_types.h:246
@ PROP_EDITABLE
Definition: RNA_types.h:189
@ PROP_NEVER_NULL
Definition: RNA_types.h:239
@ PROP_ID_REFCOUNT
Definition: RNA_types.h:226
@ PROP_MATRIX
Definition: RNA_types.h:158
@ PROP_XYZ
Definition: RNA_types.h:162
@ PROP_PIXEL
Definition: RNA_types.h:141
@ PROP_ANGLE
Definition: RNA_types.h:145
@ PROP_NONE
Definition: RNA_types.h:126
@ PROP_FACTOR
Definition: RNA_types.h:144
@ PROP_COLOR_GAMMA
Definition: RNA_types.h:165
@ PROP_TRANSLATION
Definition: RNA_types.h:154
#define ND_DISPLAY
Definition: WM_types.h:439
#define NC_MOVIECLIP
Definition: WM_types.h:347
#define NC_SCENE
Definition: WM_types.h:328
#define ND_NODES
Definition: WM_types.h:384
#define NA_EDITED
Definition: WM_types.h:523
#define ND_TRANSFORM
Definition: WM_types.h:405
#define NC_OBJECT
Definition: WM_types.h:329
#define SELECT
Scene scene
const vector< Marker > & markers
const ProjectiveReconstruction & reconstruction
Definition: intersect.cc:198
void rna_iterator_listbase_begin(CollectionPropertyIterator *iter, ListBase *lb, IteratorSkipFunc skip)
Definition: rna_access.c:4729
PointerRNA rna_pointer_inherit_refine(PointerRNA *ptr, StructRNA *type, void *data)
Definition: rna_access.c:186
void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
Definition: rna_define.c:2740
void RNA_def_struct_path_func(StructRNA *srna, const char *path)
Definition: rna_define.c:1193
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, bool default_value, const char *ui_name, const char *ui_description)
Definition: rna_define.c:3493
PropertyRNA * RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type, const char *ui_name, const char *ui_description)
Definition: rna_define.c:4170
void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t bit)
Definition: rna_define.c:2236
void RNA_def_parameter_clear_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
Definition: rna_define.c:1526
void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
Definition: rna_define.c:3285
void RNA_def_property_float_default(PropertyRNA *prop, float value)
Definition: rna_define.c:2022
void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
Definition: rna_define.c:4312
PropertyRNA * RNA_def_float_matrix(StructOrFunctionRNA *cont_, const char *identifier, int rows, int columns, const float *default_value, float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
Definition: rna_define.c:3954
void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
Definition: rna_define.c:3126
void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
Definition: rna_define.c:1645
const int rna_matrix_dimsize_4x2[]
Definition: rna_define.c:1596
void RNA_def_property_ui_icon(PropertyRNA *prop, int icon, int consecutive)
Definition: rna_define.c:1653
FunctionRNA * RNA_def_function(StructRNA *srna, const char *identifier, const char *call)
Definition: rna_define.c:4273
void RNA_def_property_srna(PropertyRNA *prop, const char *type)
Definition: rna_define.c:3474
void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *length, const char *lookupint, const char *lookupstring, const char *assignint)
Definition: rna_define.c:3420
void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
Definition: rna_define.c:1237
void RNA_def_function_output(FunctionRNA *UNUSED(func), PropertyRNA *ret)
Definition: rna_define.c:4337
void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
Definition: rna_define.c:2944
void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, const int length[])
Definition: rna_define.c:1598
PropertyRNA * RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value, float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
Definition: rna_define.c:3862
void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
Definition: rna_define.c:1872
void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
Definition: rna_define.c:1048
void RNA_def_property_array(PropertyRNA *prop, int length)
Definition: rna_define.c:1539
void RNA_def_property_range(PropertyRNA *prop, double min, double max)
Definition: rna_define.c:1737
void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
Definition: rna_define.c:1920
void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
Definition: rna_define.c:1772
void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
Definition: rna_define.c:2769
void RNA_def_function_ui_description(FunctionRNA *func, const char *description)
Definition: rna_define.c:4347
void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
Definition: rna_define.c:2900
const int rna_matrix_dimsize_4x4[]
Definition: rna_define.c:1595
PropertyRNA * RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier, int type, int subtype)
Definition: rna_define.c:1257
void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop)
Definition: rna_define.c:1103
void RNA_def_function_flag(FunctionRNA *func, int flag)
Definition: rna_define.c:4342
void RNA_def_property_clear_flag(PropertyRNA *prop, PropertyFlag flag)
Definition: rna_define.c:1495
void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set, const char *type_fn, const char *poll)
Definition: rna_define.c:3385
StructRNA * RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
Definition: rna_define.c:1028
void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
Definition: rna_define.c:2601
void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
Definition: rna_define.c:3028
void RNA_def_struct_ui_icon(StructRNA *srna, int icon)
Definition: rna_define.c:1245
PropertyRNA * RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen, const char *ui_name, const char *ui_description)
Definition: rna_define.c:3687
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
Definition: rna_define.c:1490
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, int default_value, int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
Definition: rna_define.c:3597
void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
Definition: rna_define.c:2493
void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
Definition: rna_define.c:1664
void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
Definition: rna_define.c:2343
void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t booleanbit)
Definition: rna_define.c:2327
void RNA_def_parameter_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
Definition: rna_define.c:1518
static const EnumPropertyItem pattern_match_items[]
Definition: rna_tracking.c:846
static void rna_def_trackingTracks(BlenderRNA *brna)
static void rna_def_trackingMarker(BlenderRNA *brna)
static void rna_def_trackingTrack(BlenderRNA *brna)
static void rna_def_tracking(BlenderRNA *brna)
static void rna_def_trackingStabilization(BlenderRNA *brna)
static const EnumPropertyItem tracker_motion_model[]
Definition: rna_tracking.c:812
static void rna_def_trackingPlaneTrack(BlenderRNA *brna)
static void rna_def_trackingSettings(BlenderRNA *brna)
Definition: rna_tracking.c:856
static void rna_def_trackingReconstructedCameras(BlenderRNA *brna)
static void rna_def_trackingPlaneMarkers(BlenderRNA *brna, PropertyRNA *cprop)
static void rna_def_trackingObjectPlaneTracks(BlenderRNA *brna)
static void rna_def_trackingPlaneTracks(BlenderRNA *brna)
static void rna_def_trackingObjectTracks(BlenderRNA *brna)
static void rna_def_trackingCamera(BlenderRNA *brna)
void RNA_def_tracking(BlenderRNA *brna)
static void rna_def_trackingMarkers(BlenderRNA *brna, PropertyRNA *cprop)
static void rna_def_trackingObjects(BlenderRNA *brna, PropertyRNA *cprop)
static void rna_def_trackingPlaneMarker(BlenderRNA *brna)
static void rna_def_reconstructedCamera(BlenderRNA *brna)
static void rna_def_trackingReconstruction(BlenderRNA *brna)
static void rna_def_trackingObject(BlenderRNA *brna)
static void rna_def_trackingDopesheet(BlenderRNA *brna)
#define min(a, b)
Definition: sort.c:35
Definition: DNA_ID.h:368
void * first
Definition: DNA_listBase.h:31
Definition: BKE_main.h:121
struct MovieTracking tracking
MovieTrackingReconstruction reconstruction
struct MovieTrackingObject * next
struct MovieTrackingPlaneTrack * next
MovieTrackingPlaneMarker * markers
MovieTrackingMarker * markers
struct MovieTrackingTrack * next
MovieTrackingReconstruction reconstruction
MovieTrackingPlaneTrack * act_plane_track
MovieTrackingDopesheet dopesheet
MovieTrackingTrack * act_track
MovieTrackingStabilization stabilization
MovieTrackingCamera camera
void * data
Definition: RNA_types.h:38
struct ID * owner_id
Definition: RNA_types.h:36
float max
void WM_main_add_notifier(unsigned int type, void *reference)
PointerRNA * ptr
Definition: wm_files.c:3480