Blender V5.3
rna_tracking.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <climits>
10#include <cstdlib>
11
12#include "BLT_translation.hh"
13
14#include "BKE_tracking.hh"
15
16#include "RNA_define.hh"
17#include "RNA_path.hh"
18
19#include "rna_internal.hh"
20
21#include "DNA_movieclip_types.h"
22#include "DNA_object_types.h" /* SELECT */
23#include "DNA_scene_types.h"
24#include "DNA_tracking_types.h"
25
26#include "WM_types.hh"
27
28#ifdef RNA_RUNTIME
29
30# include "BLI_listbase.hh"
31# include "BLI_math_vector_c.hh"
32# include "BLI_string.hh"
33# include "BLI_string_utf8.hh"
34
35# include "BKE_anim_data.hh"
36# include "BKE_animsys.hh"
37# include "BKE_global.hh"
38# include "BKE_movieclip.hh"
40# include "BKE_report.hh"
41
42# include "DEG_depsgraph.hh"
43
44# include "WM_api.hh"
45
46namespace blender {
47
48static std::optional<std::string> rna_tracking_path(const PointerRNA * /*ptr*/)
49{
50 return "tracking";
51}
52
53static std::optional<std::string> rna_trackingSettings_path(const PointerRNA * /*ptr*/)
54{
55 return "tracking.settings";
56}
57
58static void rna_tracking_defaultSettings_patternUpdate(Main * /*bmain*/,
59 Scene * /*scene*/,
60 PointerRNA *ptr)
61{
62 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
63 MovieTracking *tracking = &clip->tracking;
64 MovieTrackingSettings *settings = &tracking->settings;
65
66 if (settings->default_search_size < settings->default_pattern_size) {
67 settings->default_search_size = settings->default_pattern_size;
68 }
69}
70
71static void rna_tracking_defaultSettings_searchUpdate(Main * /*bmain*/,
72 Scene * /*scene*/,
73 PointerRNA *ptr)
74{
75 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
76 MovieTracking *tracking = &clip->tracking;
77 MovieTrackingSettings *settings = &tracking->settings;
78
79 if (settings->default_pattern_size > settings->default_search_size) {
80 settings->default_pattern_size = settings->default_search_size;
81 }
82}
83
84static std::optional<std::string> rna_trackingTrack_path(const PointerRNA *ptr)
85{
86 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
87 MovieTrackingTrack *track = static_cast<MovieTrackingTrack *>(ptr->data);
88 /* Escaped object name, escaped track name, rest of the path. */
89 char rna_path[MAX_NAME * 4 + 64];
90 BKE_tracking_get_rna_path_for_track(&clip->tracking, track, rna_path, sizeof(rna_path));
91 return rna_path;
92}
93
94static void rna_trackingTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
95{
96 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
97 MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
98
99 rna_iterator_listbase_begin(iter, ptr, &tracking_camera_object->tracks, nullptr);
100}
101
102static void rna_trackingPlaneTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
103{
104 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
105 MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
106
107 rna_iterator_listbase_begin(iter, ptr, &tracking_camera_object->plane_tracks, nullptr);
108}
109
110static PointerRNA rna_trackingReconstruction_get(PointerRNA *ptr)
111{
112 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
113 MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
114
116 *ptr, RNA_MovieTrackingReconstruction, &tracking_camera_object->reconstruction);
117}
118
119static void rna_trackingObjects_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
120{
121 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
122
123 rna_iterator_listbase_begin(iter, ptr, &clip->tracking.objects, nullptr);
124}
125
126static int rna_tracking_active_object_index_get(PointerRNA *ptr)
127{
128 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
129
130 return clip->tracking.objectnr;
131}
132
133static void rna_tracking_active_object_index_set(PointerRNA *ptr, int value)
134{
135 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
136
137 clip->tracking.objectnr = value;
138 BKE_tracking_dopesheet_tag_update(&clip->tracking);
139}
140
141static void rna_tracking_active_object_index_range(
142 PointerRNA *ptr, int *min, int *max, int * /*softmin*/, int * /*softmax*/)
143{
144 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
145
146 *min = 0;
147 *max = max_ii(0, clip->tracking.tot_object - 1);
148}
149
150static PointerRNA rna_tracking_active_track_get(PointerRNA *ptr)
151{
152 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
153 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
154
156 *ptr, RNA_MovieTrackingTrack, tracking_object->active_track);
157}
158
159static void rna_tracking_active_track_set(PointerRNA *ptr, PointerRNA value, ReportList *reports)
160{
161 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
162 MovieTrackingTrack *track = static_cast<MovieTrackingTrack *>(value.data);
163 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
164 int index = BLI_findindex(&tracking_object->tracks, track);
165
166 if (index != -1) {
167 tracking_object->active_track = track;
168 }
169 else {
170 BKE_reportf(reports,
171 RPT_ERROR,
172 "Track '%s' is not found in the tracking object %s",
173 track->name,
174 tracking_object->name);
175 }
176}
177
178static PointerRNA rna_tracking_active_plane_track_get(PointerRNA *ptr)
179{
180 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
181 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
182
184 *ptr, RNA_MovieTrackingPlaneTrack, tracking_object->active_plane_track);
185}
186
187static void rna_tracking_active_plane_track_set(PointerRNA *ptr,
188 PointerRNA value,
189 ReportList *reports)
190{
191 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
192 MovieTrackingPlaneTrack *plane_track = static_cast<MovieTrackingPlaneTrack *>(value.data);
193 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
194 int index = BLI_findindex(&tracking_object->plane_tracks, plane_track);
195
196 if (index != -1) {
197 tracking_object->active_plane_track = plane_track;
198 }
199 else {
200 BKE_reportf(reports,
201 RPT_ERROR,
202 "Plane track '%s' is not found in the tracking object %s",
203 plane_track->name,
204 tracking_object->name);
205 }
206}
207
208static PointerRNA rna_tracking_object_active_track_get(PointerRNA *ptr)
209{
210 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
211 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
212
214 *ptr, RNA_MovieTrackingTrack, tracking_object->active_track);
215}
216
217static void rna_tracking_object_active_track_set(PointerRNA *ptr,
218 PointerRNA value,
219 ReportList *reports)
220{
221 MovieTrackingTrack *track = static_cast<MovieTrackingTrack *>(value.data);
222 MovieTrackingObject *tracking_object = static_cast<MovieTrackingObject *>(ptr->data);
223 int index = BLI_findindex(&tracking_object->tracks, track);
224
225 if (index != -1) {
226 tracking_object->active_track = track;
227 }
228 else {
229 BKE_reportf(reports,
230 RPT_ERROR,
231 "Track '%s' is not found in the tracking object %s",
232 track->name,
233 tracking_object->name);
234 }
235}
236
237static PointerRNA rna_tracking_object_active_plane_track_get(PointerRNA *ptr)
238{
239 MovieTrackingObject *tracking_object = static_cast<MovieTrackingObject *>(ptr->data);
240
242 *ptr, RNA_MovieTrackingPlaneTrack, tracking_object->active_plane_track);
243}
244
245static void rna_tracking_object_active_plane_track_set(PointerRNA *ptr,
246 PointerRNA value,
247 ReportList *reports)
248{
249 MovieTrackingPlaneTrack *plane_track = static_cast<MovieTrackingPlaneTrack *>(value.data);
250 MovieTrackingObject *tracking_object = static_cast<MovieTrackingObject *>(ptr->data);
251 int index = BLI_findindex(&tracking_object->plane_tracks, plane_track);
252
253 if (index != -1) {
254 tracking_object->active_plane_track = plane_track;
255 }
256 else {
257 BKE_reportf(reports,
258 RPT_ERROR,
259 "Plane track '%s' is not found in the tracking object %s",
260 plane_track->name,
261 tracking_object->name);
262 }
263}
264
265static void rna_trackingTrack_name_set(PointerRNA *ptr, const char *value)
266{
267 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
268 MovieTrackingTrack *track = static_cast<MovieTrackingTrack *>(ptr->data);
269 MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_track(&clip->tracking,
270 track);
271 /* Store old name, for the animation fix later. */
272 char old_name[sizeof(track->name)];
273 STRNCPY_UTF8(old_name, track->name);
274 /* Update the name, */
275 STRNCPY_UTF8(track->name, value);
276 BKE_tracking_track_unique_name(&tracking_object->tracks, track);
277 /* Fix animation paths. */
278 char rna_path_prefix[MAX_NAME * 2 + 64];
280 &clip->tracking, track, rna_path_prefix, sizeof(rna_path_prefix));
281 BKE_animdata_fix_paths(clip->id,
282 rna_path_prefix,
283 RNA_path_name_to_infix(old_name),
284 RNA_path_name_to_infix(track->name),
285 /* verify_paths= */ true,
286 *G_MAIN);
287}
288
289static bool rna_trackingTrack_select_get(PointerRNA *ptr)
290{
291 MovieTrackingTrack *track = static_cast<MovieTrackingTrack *>(ptr->data);
292
293 return TRACK_SELECTED(track);
294}
295
296static void rna_trackingTrack_select_set(PointerRNA *ptr, bool value)
297{
298 MovieTrackingTrack *track = static_cast<MovieTrackingTrack *>(ptr->data);
299
300 if (value) {
301 track->flag |= TRACK_SELECT;
302 track->pat_flag |= TRACK_SELECT;
303 track->search_flag |= TRACK_SELECT;
304 }
305 else {
306 track->flag &= ~TRACK_SELECT;
307 track->pat_flag &= ~TRACK_SELECT;
308 track->search_flag &= ~TRACK_SELECT;
309 }
310}
311
312static void rna_trackingPlaneMarker_frame_set(PointerRNA *ptr, int value)
313{
314 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
315 MovieTracking *tracking = &clip->tracking;
316 MovieTrackingPlaneMarker *plane_marker = static_cast<MovieTrackingPlaneMarker *>(ptr->data);
317 MovieTrackingPlaneTrack *plane_track_of_marker = nullptr;
318
319 for (MovieTrackingObject &tracking_object : tracking->objects) {
320 for (MovieTrackingPlaneTrack &plane_track : tracking_object.plane_tracks) {
321 if (plane_marker >= plane_track.markers &&
322 plane_marker < plane_track.markers + plane_track.markersnr)
323 {
324 plane_track_of_marker = &plane_track;
325 break;
326 }
327 }
328
329 if (plane_track_of_marker) {
330 break;
331 }
332 }
333
334 if (plane_track_of_marker) {
335 MovieTrackingPlaneMarker new_plane_marker = *plane_marker;
336 new_plane_marker.framenr = value;
337
338 BKE_tracking_plane_marker_delete(plane_track_of_marker, plane_marker->framenr);
339 BKE_tracking_plane_marker_insert(plane_track_of_marker, &new_plane_marker);
340 }
341}
342
343static std::optional<std::string> rna_trackingPlaneTrack_path(const PointerRNA *ptr)
344{
345 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
346 MovieTrackingPlaneTrack *plane_track = static_cast<MovieTrackingPlaneTrack *>(ptr->data);
347 /* Escaped object name, escaped track name, rest of the path. */
348 char rna_path[MAX_NAME * 4 + 64];
350 &clip->tracking, plane_track, rna_path, sizeof(rna_path));
351 return rna_path;
352}
353
354static void rna_trackingPlaneTrack_name_set(PointerRNA *ptr, const char *value)
355{
356 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
357 MovieTrackingPlaneTrack *plane_track = static_cast<MovieTrackingPlaneTrack *>(ptr->data);
358 MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_plane_track(&clip->tracking,
359 plane_track);
360 /* Store old name, for the animation fix later. */
361 char old_name[sizeof(plane_track->name)];
362 STRNCPY(old_name, plane_track->name);
363 /* Update the name, */
364 STRNCPY(plane_track->name, value);
365 BKE_tracking_plane_track_unique_name(&tracking_object->plane_tracks, plane_track);
366 /* Fix animation paths. */
367 char rna_path[MAX_NAME * 2 + 64];
369 &clip->tracking, plane_track, rna_path, sizeof(rna_path));
370 BKE_animdata_fix_paths(clip->id,
371 rna_path,
372 RNA_path_name_to_infix(old_name),
373 RNA_path_name_to_infix(plane_track->name),
374 /* verify_paths= */ true,
375 *G_MAIN);
376}
377
378static std::optional<std::string> rna_trackingCamera_path(const PointerRNA * /*ptr*/)
379{
380 return "tracking.camera";
381}
382
383static float rna_trackingCamera_focal_mm_get(PointerRNA *ptr)
384{
385 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
386 MovieTrackingCamera *camera = &clip->tracking.camera;
387 float val = camera->focal;
388
389 if (clip->lastsize[0]) {
390 val = val * camera->sensor_width / float(clip->lastsize[0]);
391 }
392
393 return val;
394}
395
396static void rna_trackingCamera_focal_mm_set(PointerRNA *ptr, float value)
397{
398 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
399 MovieTrackingCamera *camera = &clip->tracking.camera;
400
401 if (clip->lastsize[0]) {
402 value = clip->lastsize[0] * value / camera->sensor_width;
403 }
404
405 if (value >= 0.0001f) {
406 camera->focal = value;
407 }
408}
409
410static void rna_trackingCamera_principal_point_pixels_get(PointerRNA *ptr,
411 float *r_principal_point_pixels)
412{
413 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
414 BKE_tracking_camera_principal_point_pixel_get(clip, r_principal_point_pixels);
415}
416
417static void rna_trackingCamera_principal_point_pixels_set(PointerRNA *ptr,
418 const float *principal_point_pixels)
419{
420 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
421 BKE_tracking_camera_principal_point_pixel_set(clip, principal_point_pixels);
422}
423
424static std::optional<std::string> rna_trackingStabilization_path(const PointerRNA * /*ptr*/)
425{
426 return "tracking.stabilization";
427}
428
429static bool rna_track_2d_stabilization(CollectionPropertyIterator * /*iter*/, void *data)
430{
431 MovieTrackingTrack *track = static_cast<MovieTrackingTrack *>(data);
432
433 if ((track->flag & TRACK_USE_2D_STAB) == 0) {
434 return true;
435 }
436
437 return false;
438}
439
440static bool rna_track_2d_stabilization_rotation(CollectionPropertyIterator * /*iter*/, void *data)
441{
442 MovieTrackingTrack *track = static_cast<MovieTrackingTrack *>(data);
443
444 if ((track->flag & TRACK_USE_2D_STAB_ROT) == 0) {
445 return true;
446 }
447
448 return false;
449}
450
451static void rna_tracking_stabTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
452{
453 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
454 MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
456 iter, ptr, &tracking_camera_object->tracks, rna_track_2d_stabilization);
457}
458
459static int rna_tracking_stabTracks_active_index_get(PointerRNA *ptr)
460{
461 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
462 return clip->tracking.stabilization.act_track;
463}
464
465static void rna_tracking_stabTracks_active_index_set(PointerRNA *ptr, int value)
466{
467 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
468 clip->tracking.stabilization.act_track = value;
469}
470
471static void rna_tracking_stabTracks_active_index_range(
472 PointerRNA *ptr, int *min, int *max, int * /*softmin*/, int * /*softmax*/)
473{
474 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
475
476 *min = 0;
477 *max = max_ii(0, clip->tracking.stabilization.tot_track - 1);
478}
479
480static void rna_tracking_stabRotTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
481{
482 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
483 MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
485 iter, ptr, &tracking_camera_object->tracks, rna_track_2d_stabilization_rotation);
486}
487
488static int rna_tracking_stabRotTracks_active_index_get(PointerRNA *ptr)
489{
490 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
491 return clip->tracking.stabilization.act_rot_track;
492}
493
494static void rna_tracking_stabRotTracks_active_index_set(PointerRNA *ptr, int value)
495{
496 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
497 clip->tracking.stabilization.act_rot_track = value;
498}
499
500static void rna_tracking_stabRotTracks_active_index_range(
501 PointerRNA *ptr, int *min, int *max, int * /*softmin*/, int * /*softmax*/)
502{
503 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
504
505 *min = 0;
506 *max = max_ii(0, clip->tracking.stabilization.tot_rot_track - 1);
507}
508
509static void rna_tracking_flushUpdate(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
510{
511 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
512
513 BKE_ntree_update_tag_id_changed(bmain, &clip->id);
514 BKE_ntree_update(*bmain);
515
518 DEG_id_tag_update(&clip->id, 0);
519}
520
521static void rna_tracking_resetIntrinsics(Main * /*bmain*/, Scene * /*scene*/, PointerRNA *ptr)
522{
523 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
524 MovieTracking *tracking = &clip->tracking;
525
526 if (tracking->camera.intrinsics) {
527 BKE_tracking_distortion_free(static_cast<MovieDistortion *>(tracking->camera.intrinsics));
528 tracking->camera.intrinsics = nullptr;
529 }
530}
531
532static void rna_trackingObject_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
533{
534 MovieTrackingObject *tracking_object = static_cast<MovieTrackingObject *>(ptr->data);
535 rna_iterator_listbase_begin(iter, ptr, &tracking_object->tracks, nullptr);
536}
537
538static void rna_trackingObject_plane_tracks_begin(CollectionPropertyIterator *iter,
539 PointerRNA *ptr)
540{
541 MovieTrackingObject *tracking_object = static_cast<MovieTrackingObject *>(ptr->data);
542 rna_iterator_listbase_begin(iter, ptr, &tracking_object->plane_tracks, nullptr);
543}
544
545static PointerRNA rna_trackingObject_reconstruction_get(PointerRNA *ptr)
546{
547 MovieTrackingObject *tracking_object = static_cast<MovieTrackingObject *>(ptr->data);
549 *ptr, RNA_MovieTrackingReconstruction, &tracking_object->reconstruction);
550}
551
552static PointerRNA rna_tracking_active_object_get(PointerRNA *ptr)
553{
554 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
555 MovieTrackingObject *tracking_object = static_cast<MovieTrackingObject *>(
556 BLI_findlink(&clip->tracking.objects, clip->tracking.objectnr));
557
558 return RNA_pointer_create_with_parent(*ptr, RNA_MovieTrackingObject, tracking_object);
559}
560
561static void rna_tracking_active_object_set(PointerRNA *ptr,
562 PointerRNA value,
563 ReportList * /*reports*/)
564{
565 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
566 MovieTrackingObject *tracking_object = static_cast<MovieTrackingObject *>(value.data);
567 const int index = BLI_findindex(&clip->tracking.objects, tracking_object);
568
569 if (index != -1) {
570 clip->tracking.objectnr = index;
571 }
572 else {
573 clip->tracking.objectnr = 0;
574 }
575}
576
577static void rna_trackingObject_name_set(PointerRNA *ptr, const char *value)
578{
579 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
580 MovieTrackingObject *tracking_object = static_cast<MovieTrackingObject *>(ptr->data);
581
582 STRNCPY_UTF8(tracking_object->name, value);
583
584 BKE_tracking_object_unique_name(&clip->tracking, tracking_object);
585}
586
587static void rna_trackingObject_flushUpdate(Main * /*bmain*/, Scene * /*scene*/, PointerRNA *ptr)
588{
589 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
590
592 DEG_id_tag_update(&clip->id, 0);
593}
594
595static void rna_trackingMarker_frame_set(PointerRNA *ptr, int value)
596{
597 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
598 MovieTracking *tracking = &clip->tracking;
599 MovieTrackingMarker *marker = static_cast<MovieTrackingMarker *>(ptr->data);
600 MovieTrackingTrack *track_of_marker = nullptr;
601
602 for (MovieTrackingObject &tracking_object : tracking->objects) {
603 for (MovieTrackingTrack &track : tracking_object.tracks) {
604 if (marker >= track.markers && marker < track.markers + track.markersnr) {
605 track_of_marker = &track;
606 break;
607 }
608 }
609
610 if (track_of_marker) {
611 break;
612 }
613 }
614
615 if (track_of_marker) {
616 MovieTrackingMarker new_marker = *marker;
617 new_marker.framenr = value;
618
619 BKE_tracking_marker_delete(track_of_marker, marker->framenr);
620 BKE_tracking_marker_insert(track_of_marker, &new_marker);
621 }
622}
623
624static void rna_tracking_markerPattern_update(Main * /*bmain*/, Scene * /*scene*/, PointerRNA *ptr)
625{
626 MovieTrackingMarker *marker = static_cast<MovieTrackingMarker *>(ptr->data);
627
629}
630
631static void rna_tracking_markerSearch_update(Main * /*bmain*/, Scene * /*scene*/, PointerRNA *ptr)
632{
633 MovieTrackingMarker *marker = static_cast<MovieTrackingMarker *>(ptr->data);
634
636}
637
638static void rna_tracking_markerPattern_boundbox_get(PointerRNA *ptr, float *values)
639{
640 MovieTrackingMarker *marker = static_cast<MovieTrackingMarker *>(ptr->data);
641 float min[2], max[2];
642
644
645 copy_v2_v2(values, min);
646 copy_v2_v2(values + 2, max);
647}
648
649static std::optional<std::string> rna_trackingDopesheet_path(const PointerRNA * /*ptr*/)
650{
651 return "tracking.dopesheet";
652}
653
654static void rna_trackingDopesheet_tagUpdate(Main * /*bmain*/, Scene * /*scene*/, PointerRNA *ptr)
655{
656 MovieClip *clip = id_cast<MovieClip *>(ptr->owner_id);
657 MovieTrackingDopesheet *dopesheet = &clip->tracking.dopesheet;
658
659 dopesheet->ok = 0;
660}
661
662/* API */
663
664static MovieTrackingTrack *add_track_to_base(MovieClip *clip,
665 MovieTracking *tracking,
666 ListBaseT<MovieTrackingTrack> *tracksbase,
667 const char *name,
668 int frame)
669{
670 int width, height;
671 MovieClipUser user = {};
672 MovieTrackingTrack *track;
673
674 user.framenr = 1;
675
676 BKE_movieclip_get_size(clip, &user, &width, &height);
677
678 track = BKE_tracking_track_add(tracking, tracksbase, 0, 0, frame, width, height);
679
680 if (name && name[0]) {
681 STRNCPY_UTF8(track->name, name);
682 BKE_tracking_track_unique_name(tracksbase, track);
683 }
684
685 return track;
686}
687
688static MovieTrackingTrack *rna_trackingTracks_new(ID *id,
689 MovieTracking *tracking,
690 const char *name,
691 int frame)
692{
693 MovieClip *clip = id_cast<MovieClip *>(id);
694 MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
695 MovieTrackingTrack *track = add_track_to_base(
696 clip, tracking, &tracking_camera_object->tracks, name, frame);
697
699
700 return track;
701}
702
703static MovieTrackingTrack *rna_trackingObject_tracks_new(ID *id,
704 MovieTrackingObject *tracking_object,
705 const char *name,
706 int frame)
707{
708 MovieClip *clip = id_cast<MovieClip *>(id);
709 MovieTrackingTrack *track = add_track_to_base(
710 clip, &clip->tracking, &tracking_object->tracks, name, frame);
711
713
714 return track;
715}
716
717static MovieTrackingObject *rna_trackingObject_new(MovieTracking *tracking, const char *name)
718{
719 MovieTrackingObject *tracking_object = BKE_tracking_object_add(tracking, name);
720
722
723 return tracking_object;
724}
725
726static void rna_trackingObject_remove(MovieTracking *tracking,
727 ReportList *reports,
728 PointerRNA *object_ptr)
729{
730 MovieTrackingObject *tracking_object = static_cast<MovieTrackingObject *>(object_ptr->data);
731 if (BKE_tracking_object_delete(tracking, tracking_object) == false) {
732 BKE_reportf(reports, RPT_ERROR, "MovieTracking '%s' cannot be removed", tracking_object->name);
733 return;
734 }
735
736 object_ptr->invalidate();
737
739}
740
741static MovieTrackingMarker *rna_trackingMarkers_find_frame(MovieTrackingTrack *track,
742 int framenr,
743 bool exact)
744{
745 if (exact) {
746 return BKE_tracking_marker_get_exact(track, framenr);
747 }
748 else {
749 return BKE_tracking_marker_get(track, framenr);
750 }
751}
752
753static MovieTrackingMarker *rna_trackingMarkers_insert_frame(MovieTrackingTrack *track,
754 int framenr,
755 const float co[2])
756{
757 MovieTrackingMarker marker = {}, *new_marker;
758
759 marker.framenr = framenr;
760 copy_v2_v2(marker.pos, co);
761
762 /* a bit arbitrary, but better than creating markers with zero pattern
763 * which is forbidden actually
764 */
765 copy_v2_v2(marker.pattern_corners[0], track->markers[0].pattern_corners[0]);
766 copy_v2_v2(marker.pattern_corners[1], track->markers[0].pattern_corners[1]);
767 copy_v2_v2(marker.pattern_corners[2], track->markers[0].pattern_corners[2]);
768 copy_v2_v2(marker.pattern_corners[3], track->markers[0].pattern_corners[3]);
769
770 new_marker = BKE_tracking_marker_insert(track, &marker);
771
773
774 return new_marker;
775}
776
777static void rna_trackingMarkers_delete_frame(MovieTrackingTrack *track, int framenr)
778{
779 if (track->markersnr == 1) {
780 return;
781 }
782
783 BKE_tracking_marker_delete(track, framenr);
784
786}
787
788static MovieTrackingPlaneMarker *rna_trackingPlaneMarkers_find_frame(
789 MovieTrackingPlaneTrack *plane_track, int framenr, bool exact)
790{
791 if (exact) {
792 return BKE_tracking_plane_marker_get_exact(plane_track, framenr);
793 }
794 else {
795 return BKE_tracking_plane_marker_get(plane_track, framenr);
796 }
797}
798
799static MovieTrackingPlaneMarker *rna_trackingPlaneMarkers_insert_frame(
800 MovieTrackingPlaneTrack *plane_track, int framenr)
801{
802 MovieTrackingPlaneMarker plane_marker = {}, *new_plane_marker;
803
804 plane_marker.framenr = framenr;
805
806 /* a bit arbitrary, but better than creating zero markers */
807 copy_v2_v2(plane_marker.corners[0], plane_track->markers[0].corners[0]);
808 copy_v2_v2(plane_marker.corners[1], plane_track->markers[0].corners[1]);
809 copy_v2_v2(plane_marker.corners[2], plane_track->markers[0].corners[2]);
810 copy_v2_v2(plane_marker.corners[3], plane_track->markers[0].corners[3]);
811
812 new_plane_marker = BKE_tracking_plane_marker_insert(plane_track, &plane_marker);
813
815
816 return new_plane_marker;
817}
818
819static void rna_trackingPlaneMarkers_delete_frame(MovieTrackingPlaneTrack *plane_track,
820 int framenr)
821{
822 if (plane_track->markersnr == 1) {
823 return;
824 }
825
826 BKE_tracking_plane_marker_delete(plane_track, framenr);
827
829}
830
831static MovieTrackingObject *find_object_for_reconstruction(
832 MovieTracking *tracking, MovieTrackingReconstruction *reconstruction)
833{
834 for (MovieTrackingObject &tracking_object : tracking->objects) {
835 if (&tracking_object.reconstruction == reconstruction) {
836 return &tracking_object;
837 }
838 }
839
840 return nullptr;
841}
842
843static MovieReconstructedCamera *rna_trackingCameras_find_frame(
844 ID *id, MovieTrackingReconstruction *reconstruction, int framenr)
845{
846 MovieClip *clip = id_cast<MovieClip *>(id);
847 MovieTracking *tracking = &clip->tracking;
848 MovieTrackingObject *tracking_object = find_object_for_reconstruction(tracking, reconstruction);
849 return BKE_tracking_camera_get_reconstructed(tracking, tracking_object, framenr);
850}
851
852static void rna_trackingCameras_matrix_from_frame(ID *id,
853 MovieTrackingReconstruction *reconstruction,
854 int framenr,
855 float matrix[16])
856{
857 float mat[4][4];
858
859 MovieClip *clip = id_cast<MovieClip *>(id);
860 MovieTracking *tracking = &clip->tracking;
861 MovieTrackingObject *tracking_object = find_object_for_reconstruction(tracking, reconstruction);
862 BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, framenr, mat);
863
864 memcpy(matrix, mat, sizeof(float[4][4]));
865}
866
867} // namespace blender
868
869#else
870
871namespace blender {
872
875 "Perspective",
876 0,
877 "Perspective",
878 "Search for markers that are perspectively deformed (homography) between frames"},
880 "Affine",
881 0,
882 "Affine",
883 "Search for markers that are affine-deformed (t, r, k, and skew) between frames"},
885 "LocRotScale",
886 0,
887 "Location, Rotation & Scale",
888 "Search for markers that are translated, rotated, and scaled between frames"},
890 "LocScale",
891 0,
892 "Location & Scale",
893 "Search for markers that are translated and scaled between frames"},
895 "LocRot",
896 0,
897 "Location & Rotation",
898 "Search for markers that are translated and rotated between frames"},
900 "Loc",
901 0,
902 "Location",
903 "Search for markers that are translated between frames"},
904 {0, nullptr, 0, nullptr, nullptr},
905};
906
908 {TRACK_MATCH_KEYFRAME, "KEYFRAME", 0, "Keyframe", "Track pattern from keyframe to next frame"},
910 "PREV_FRAME",
911 0,
912 "Previous frame",
913 "Track pattern from current frame to next frame"},
914 {0, nullptr, 0, nullptr, nullptr},
915};
916
918{
919 StructRNA *srna;
920 PropertyRNA *prop;
921
922 static const EnumPropertyItem speed_items[] = {
923 {0, "FASTEST", 0, "Fastest", "Track as fast as possible"},
924 {TRACKING_SPEED_DOUBLE, "DOUBLE", 0, "Double", "Track with double speed"},
925 {TRACKING_SPEED_REALTIME, "REALTIME", 0, "Realtime", "Track with realtime speed"},
926 {TRACKING_SPEED_HALF, "HALF", 0, "Half", "Track with half of realtime speed"},
927 {TRACKING_SPEED_QUARTER, "QUARTER", 0, "Quarter", "Track with quarter of realtime speed"},
928 {0, nullptr, 0, nullptr, nullptr},
929 };
930
931 static const EnumPropertyItem cleanup_items[] = {
932 {int(TrackingCleanAction::Select), "SELECT", 0, "Select", "Select unclean tracks"},
934 "DELETE_TRACK",
935 0,
936 "Delete Track",
937 "Delete unclean tracks"},
939 "DELETE_SEGMENTS",
940 0,
941 "Delete Segments",
942 "Delete unclean segments of tracks"},
943 {0, nullptr, 0, nullptr, nullptr},
944 };
945
946 srna = RNA_def_struct(brna, "MovieTrackingSettings", nullptr);
947 RNA_def_struct_path_func(srna, "rna_trackingSettings_path");
948 RNA_def_struct_ui_text(srna, "Movie tracking settings", "Match moving settings");
949
950 /* speed */
951 prop = RNA_def_property(srna, "speed", PROP_ENUM, PROP_NONE);
953 RNA_def_property_enum_items(prop, speed_items);
955 "Speed",
956 "Limit speed of tracking to make visual feedback easier "
957 "(this does not affect the tracking quality)");
959
960 /* use keyframe selection */
961 prop = RNA_def_property(srna, "use_keyframe_selection", PROP_BOOLEAN, PROP_NONE);
964 prop, nullptr, "reconstruction_flag", TRACKING_USE_KEYFRAME_SELECTION);
966 "Keyframe Selection",
967 "Automatically select keyframes when solving camera/object motion");
968
969 /* intrinsics refinement during bundle adjustment */
970
971 prop = RNA_def_property(srna, "refine_intrinsics_focal_length", PROP_BOOLEAN, PROP_NONE);
972 RNA_def_property_boolean_sdna(prop, nullptr, "refine_camera_intrinsics", REFINE_FOCAL_LENGTH);
975 prop, "Refine Focal Length", "Refine focal length during camera solving");
976
977 prop = RNA_def_property(srna, "refine_intrinsics_principal_point", PROP_BOOLEAN, PROP_NONE);
978 RNA_def_property_boolean_sdna(prop, nullptr, "refine_camera_intrinsics", REFINE_PRINCIPAL_POINT);
981 prop, "Refine Principal Point", "Refine principal point during camera solving");
982
983 prop = RNA_def_property(srna, "refine_intrinsics_radial_distortion", PROP_BOOLEAN, PROP_NONE);
985 prop, nullptr, "refine_camera_intrinsics", REFINE_RADIAL_DISTORTION);
988 "Refine Radial",
989 "Refine radial coefficients of distortion model during camera solving");
990
991 prop = RNA_def_property(
992 srna, "refine_intrinsics_tangential_distortion", PROP_BOOLEAN, PROP_NONE);
994 prop, nullptr, "refine_camera_intrinsics", REFINE_TANGENTIAL_DISTORTION);
997 prop,
998 "Refine Tangential",
999 "Refine tangential coefficients of distortion model during camera solving");
1000
1001 /* tool settings */
1002
1003 /* distance */
1004 prop = RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
1006 RNA_def_property_float_sdna(prop, nullptr, "dist");
1009 prop, "Distance", "Distance between two bundles used for scene scaling");
1010
1011 /* frames count */
1012 prop = RNA_def_property(srna, "clean_frames", PROP_INT, PROP_NONE);
1014 RNA_def_property_int_sdna(prop, nullptr, "clean_frames");
1017 prop,
1018 "Tracked Frames",
1019 "Effect on tracks which are tracked less than the specified amount of frames");
1020
1021 /* re-projection error */
1022 prop = RNA_def_property(srna, "clean_error", PROP_FLOAT, PROP_NONE);
1024 RNA_def_property_float_sdna(prop, nullptr, "clean_error");
1027 prop, "Reprojection Error", "Effect on tracks which have a larger re-projection error");
1028
1029 /* cleanup action */
1030 prop = RNA_def_property(srna, "clean_action", PROP_ENUM, PROP_NONE);
1031 RNA_def_property_enum_sdna(prop, nullptr, "clean_action");
1033 RNA_def_property_enum_items(prop, cleanup_items);
1034 RNA_def_property_ui_text(prop, "Action", "Cleanup action to execute");
1035
1036 /* solver settings */
1037 prop = RNA_def_property(srna, "use_tripod_solver", PROP_BOOLEAN, PROP_NONE);
1039 RNA_def_property_boolean_sdna(prop, nullptr, "motion_flag", TRACKING_MOTION_TRIPOD);
1041 prop,
1042 "Tripod Motion",
1043 "Use special solver to track a stable camera position, such as a tripod");
1044
1045 /* default_limit_frames */
1046 prop = RNA_def_property(srna, "default_frames_limit", PROP_INT, PROP_NONE);
1048 RNA_def_property_int_sdna(prop, nullptr, "default_frames_limit");
1051 prop, "Frames Limit", "Every tracking cycle, this number of frames are tracked");
1052
1053 /* default_pattern_match */
1054 prop = RNA_def_property(srna, "default_pattern_match", PROP_ENUM, PROP_NONE);
1056 RNA_def_property_enum_sdna(prop, nullptr, "default_pattern_match");
1059 prop, "Pattern Match", "Track pattern from given frame when tracking marker to next frame");
1060
1061 /* default_margin */
1062 prop = RNA_def_property(srna, "default_margin", PROP_INT, PROP_PIXEL);
1064 RNA_def_property_int_sdna(prop, nullptr, "default_margin");
1065 RNA_def_property_range(prop, 0, 300);
1067 prop, "Margin", "Default distance from image boundary at which marker stops tracking");
1068
1069 /* default_tracking_motion_model */
1070 prop = RNA_def_property(srna, "default_motion_model", PROP_ENUM, PROP_NONE);
1073 RNA_def_property_ui_text(prop, "Motion Model", "Default motion model to use for tracking");
1074
1075 /* default_use_brute */
1076 prop = RNA_def_property(srna, "use_default_brute", PROP_BOOLEAN, PROP_NONE);
1078 prop, nullptr, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_BRUTE);
1080 prop, "Prepass", "Use a brute-force translation-only initialization when tracking");
1082
1083 /* default_use_brute */
1084 prop = RNA_def_property(srna, "use_default_mask", PROP_BOOLEAN, PROP_NONE);
1086 prop, nullptr, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_MASK);
1088 prop,
1089 "Use Mask",
1090 "Use a Grease Pencil data-block as a mask to use only specified areas of pattern "
1091 "when tracking");
1093
1094 /* default_use_normalization */
1095 prop = RNA_def_property(srna, "use_default_normalization", PROP_BOOLEAN, PROP_NONE);
1097 prop, nullptr, "default_algorithm_flag", TRACK_ALGORITHM_FLAG_USE_NORMALIZATION);
1099 prop, "Normalize", "Normalize light intensities while tracking (slower)");
1101
1102 /* default minimal correlation */
1103 prop = RNA_def_property(srna, "default_correlation_min", PROP_FLOAT, PROP_NONE);
1105 RNA_def_property_float_sdna(prop, nullptr, "default_minimum_correlation");
1106 RNA_def_property_range(prop, 0.0f, 1.0f);
1107 RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.05, 3);
1109 prop,
1110 "Correlation",
1111 "Default minimum value of correlation between matched pattern and reference "
1112 "that is still treated as successful tracking");
1113
1114 /* default pattern size */
1115 prop = RNA_def_property(srna, "default_pattern_size", PROP_INT, PROP_NONE);
1117 RNA_def_property_int_sdna(prop, nullptr, "default_pattern_size");
1118 RNA_def_property_range(prop, 5, 1000);
1119 RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_patternUpdate");
1120 RNA_def_property_ui_text(prop, "Pattern Size", "Size of pattern area for newly created tracks");
1121
1122 /* default search size */
1123 prop = RNA_def_property(srna, "default_search_size", PROP_INT, PROP_NONE);
1125 RNA_def_property_int_sdna(prop, nullptr, "default_search_size");
1126 RNA_def_property_range(prop, 5, 1000);
1127 RNA_def_property_update(prop, 0, "rna_tracking_defaultSettings_searchUpdate");
1128 RNA_def_property_ui_text(prop, "Search Size", "Size of search area for newly created tracks");
1129
1130 /* default use_red_channel */
1131 prop = RNA_def_property(srna, "use_default_red_channel", PROP_BOOLEAN, PROP_NONE);
1132 RNA_def_property_boolean_negative_sdna(prop, nullptr, "default_flag", TRACK_DISABLE_RED);
1133 RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
1135
1136 /* default_use_green_channel */
1137 prop = RNA_def_property(srna, "use_default_green_channel", PROP_BOOLEAN, PROP_NONE);
1138 RNA_def_property_boolean_negative_sdna(prop, nullptr, "default_flag", TRACK_DISABLE_GREEN);
1140 prop, "Use Green Channel", "Use green channel from footage for tracking");
1142
1143 /* default_use_blue_channel */
1144 prop = RNA_def_property(srna, "use_default_blue_channel", PROP_BOOLEAN, PROP_NONE);
1145 RNA_def_property_boolean_negative_sdna(prop, nullptr, "default_flag", TRACK_DISABLE_BLUE);
1146 RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
1148
1149 prop = RNA_def_property(srna, "default_weight", PROP_FLOAT, PROP_FACTOR);
1150 RNA_def_property_range(prop, 0.0f, 1.0f);
1151 RNA_def_property_ui_text(prop, "Weight", "Influence of newly created track on a final solution");
1152
1153 /* ** object tracking ** */
1154
1155 /* object distance */
1156 prop = RNA_def_property(srna, "object_distance", PROP_FLOAT, PROP_NONE);
1158 RNA_def_property_float_sdna(prop, nullptr, "object_distance");
1160 prop, "Distance", "Distance between two bundles used for object scaling");
1161 RNA_def_property_range(prop, 0.001, 10000);
1163 RNA_def_property_ui_range(prop, 0.001, 10000.0, 1, 3);
1164}
1165
1167{
1168 StructRNA *srna;
1169 PropertyRNA *prop;
1170
1171 static const EnumPropertyItem distortion_model_items[] = {
1173 "POLYNOMIAL",
1174 0,
1175 "Polynomial",
1176 "Radial distortion model which fits common cameras"},
1178 "DIVISION",
1179 0,
1180 "Divisions",
1181 "Division distortion model which "
1182 "better represents wide-angle cameras"},
1183 {TRACKING_DISTORTION_MODEL_NUKE, "NUKE", 0, "Nuke", "Nuke distortion model"},
1184 {TRACKING_DISTORTION_MODEL_BROWN, "BROWN", 0, "Brown", "Brown-Conrady distortion model"},
1185 {0, nullptr, 0, nullptr, nullptr},
1186 };
1187
1188 static const EnumPropertyItem camera_units_items[] = {
1189 {CAMERA_UNITS_PX, "PIXELS", 0, "px", "Use pixels for units of focal length"},
1190 {CAMERA_UNITS_MM, "MILLIMETERS", 0, "mm", "Use millimeters for units of focal length"},
1191 {0, nullptr, 0, nullptr, nullptr},
1192 };
1193
1194 srna = RNA_def_struct(brna, "MovieTrackingCamera", nullptr);
1195 RNA_def_struct_path_func(srna, "rna_trackingCamera_path");
1197 srna, "Movie tracking camera data", "Match-moving camera data for tracking");
1198
1199 /* Distortion model */
1200 prop = RNA_def_property(srna, "distortion_model", PROP_ENUM, PROP_NONE);
1202 RNA_def_property_enum_items(prop, distortion_model_items);
1203 RNA_def_property_ui_text(prop, "Distortion Model", "Distortion model used for camera lenses");
1204 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_resetIntrinsics");
1205
1206 /* Sensor */
1207 prop = RNA_def_property(srna, "sensor_width", PROP_FLOAT, PROP_NONE);
1208 RNA_def_property_float_sdna(prop, nullptr, "sensor_width");
1210 RNA_def_property_range(prop, 0.0f, 500.0f);
1211 RNA_def_property_ui_text(prop, "Sensor", "Width of CCD sensor in millimeters");
1213
1214 /* Focal Length */
1215 prop = RNA_def_property(srna, "focal_length", PROP_FLOAT, PROP_NONE);
1216 RNA_def_property_float_sdna(prop, nullptr, "focal");
1218 RNA_def_property_range(prop, 0.0001f, FLT_MAX);
1219 RNA_def_property_ui_range(prop, 0.0001f, 5000.0f, 1, 2);
1221 prop, "rna_trackingCamera_focal_mm_get", "rna_trackingCamera_focal_mm_set", nullptr);
1222 RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
1224
1225 /* Focal Length in pixels */
1226 prop = RNA_def_property(srna, "focal_length_pixels", PROP_FLOAT, PROP_NONE);
1227 RNA_def_property_float_sdna(prop, nullptr, "focal");
1229 RNA_def_property_range(prop, 0.0f, FLT_MAX);
1230 RNA_def_property_ui_range(prop, 0.0f, 5000.0f, 1, 2);
1231 RNA_def_property_ui_text(prop, "Focal Length", "Camera's focal length");
1233
1234 /* Units */
1235 prop = RNA_def_property(srna, "units", PROP_ENUM, PROP_NONE);
1236 RNA_def_property_enum_sdna(prop, nullptr, "units");
1238 RNA_def_property_enum_items(prop, camera_units_items);
1239 RNA_def_property_ui_text(prop, "Units", "Units used for camera focal length");
1240
1241 /* Principal Point */
1242 prop = RNA_def_property(srna, "principal_point", PROP_FLOAT, PROP_NONE);
1243 RNA_def_property_array(prop, 2);
1244 RNA_def_property_float_sdna(prop, nullptr, "principal_point");
1245 RNA_def_property_range(prop, -1, 1);
1246 RNA_def_property_ui_range(prop, -1, 1, 0.1, 3);
1248 RNA_def_property_ui_text(prop, "Principal Point", "Optical center of lens");
1250
1251 /* Principal Point, in pixels */
1252 prop = RNA_def_property(srna, "principal_point_pixels", PROP_FLOAT, PROP_PIXEL);
1253 RNA_def_property_array(prop, 2);
1256 "rna_trackingCamera_principal_point_pixels_get",
1257 "rna_trackingCamera_principal_point_pixels_set",
1258 nullptr);
1259 RNA_def_property_ui_text(prop, "Principal Point", "Optical center of lens in pixels");
1261
1262 /* Radial distortion parameters */
1263 prop = RNA_def_property(srna, "k1", PROP_FLOAT, PROP_NONE);
1264 RNA_def_property_float_sdna(prop, nullptr, "k1");
1266 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1268 prop, "K1", "First coefficient of third order polynomial radial distortion");
1269 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1270
1271 prop = RNA_def_property(srna, "k2", PROP_FLOAT, PROP_NONE);
1272 RNA_def_property_float_sdna(prop, nullptr, "k2");
1274 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1276 prop, "K2", "Second coefficient of third order polynomial radial distortion");
1277 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1278
1279 prop = RNA_def_property(srna, "k3", PROP_FLOAT, PROP_NONE);
1280 RNA_def_property_float_sdna(prop, nullptr, "k3");
1282 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1284 prop, "K3", "Third coefficient of third order polynomial radial distortion");
1285 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1286
1287 /* Division distortion parameters */
1288 prop = RNA_def_property(srna, "division_k1", PROP_FLOAT, PROP_NONE);
1290 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1291 RNA_def_property_ui_text(prop, "K1", "First coefficient of second order division distortion");
1292 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1293
1294 prop = RNA_def_property(srna, "division_k2", PROP_FLOAT, PROP_NONE);
1296 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1297 RNA_def_property_ui_text(prop, "K2", "Second coefficient of second order division distortion");
1298 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1299
1300 /* Nuke distortion parameters */
1301 prop = RNA_def_property(srna, "nuke_k1", PROP_FLOAT, PROP_NONE);
1303 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1304 RNA_def_property_ui_text(prop, "K1", "First coefficient of second order Nuke distortion");
1305 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1306
1307 prop = RNA_def_property(srna, "nuke_k2", PROP_FLOAT, PROP_NONE);
1309 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1310 RNA_def_property_ui_text(prop, "K2", "Second coefficient of second order Nuke distortion");
1311 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1312
1313 prop = RNA_def_property(srna, "nuke_p1", PROP_FLOAT, PROP_NONE);
1315 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1316 RNA_def_property_ui_text(prop, "P1", "First coefficient of tangential Nuke distortion");
1317 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1318
1319 prop = RNA_def_property(srna, "nuke_p2", PROP_FLOAT, PROP_NONE);
1321 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1322 RNA_def_property_ui_text(prop, "P2", "Second coefficient of tangential Nuke distortion");
1323 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1324
1325 /* Brown-Conrady distortion parameters */
1326 prop = RNA_def_property(srna, "brown_k1", PROP_FLOAT, PROP_NONE);
1328 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1330 prop, "K1", "First coefficient of fourth order Brown-Conrady radial distortion");
1331 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1332
1333 prop = RNA_def_property(srna, "brown_k2", PROP_FLOAT, PROP_NONE);
1335 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1337 prop, "K2", "Second coefficient of fourth order Brown-Conrady radial distortion");
1338 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1339
1340 prop = RNA_def_property(srna, "brown_k3", PROP_FLOAT, PROP_NONE);
1342 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1344 prop, "K3", "Third coefficient of fourth order Brown-Conrady radial distortion");
1345 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1346
1347 prop = RNA_def_property(srna, "brown_k4", PROP_FLOAT, PROP_NONE);
1349 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1351 prop, "K4", "Fourth coefficient of fourth order Brown-Conrady radial distortion");
1352 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1353
1354 prop = RNA_def_property(srna, "brown_p1", PROP_FLOAT, PROP_NONE);
1356 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1358 prop, "P1", "First coefficient of second order Brown-Conrady tangential distortion");
1359 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1360
1361 prop = RNA_def_property(srna, "brown_p2", PROP_FLOAT, PROP_NONE);
1363 RNA_def_property_ui_range(prop, -10, 10, 0.1, 3);
1365 prop, "P2", "Second coefficient of second order Brown-Conrady tangential distortion");
1366 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_flushUpdate");
1367
1368 /* pixel aspect */
1369 prop = RNA_def_property(srna, "pixel_aspect", PROP_FLOAT, PROP_XYZ);
1370 RNA_def_property_float_sdna(prop, nullptr, "pixel_aspect");
1372 RNA_def_property_range(prop, 0.1f, FLT_MAX);
1373 RNA_def_property_ui_range(prop, 0.1f, 5000.0f, 1, 2);
1375 RNA_def_property_ui_text(prop, "Pixel Aspect Ratio", "Pixel aspect ratio");
1376 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1377}
1378
1380{
1381 StructRNA *srna;
1382 PropertyRNA *prop;
1383
1384 static int boundbox_dimsize[] = {2, 2};
1385
1386 srna = RNA_def_struct(brna, "MovieTrackingMarker", nullptr);
1388 srna, "Movie tracking marker data", "Match-moving marker data for tracking");
1389
1390 /* position */
1391 prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
1392 RNA_def_property_array(prop, 2);
1394 RNA_def_property_float_sdna(prop, nullptr, "pos");
1395 RNA_def_property_ui_text(prop, "Position", "Marker position at frame in normalized coordinates");
1397
1398 /* frame */
1399 prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
1400 RNA_def_property_int_sdna(prop, nullptr, "framenr");
1401 RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
1402 RNA_def_property_int_funcs(prop, nullptr, "rna_trackingMarker_frame_set", nullptr);
1404
1405 /* enable */
1406 prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1407 RNA_def_property_boolean_sdna(prop, nullptr, "flag", MARKER_DISABLED);
1408 RNA_def_property_ui_text(prop, "Mode", "Is marker muted for current frame");
1410
1411 /* pattern */
1412 prop = RNA_def_property(srna, "pattern_corners", PROP_FLOAT, PROP_MATRIX);
1413 RNA_def_property_float_sdna(prop, nullptr, "pattern_corners");
1418 "Pattern Corners",
1419 "Array of coordinates which represents pattern's corners in "
1420 "normalized coordinates relative to marker position");
1421 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerPattern_update");
1422
1423 prop = RNA_def_property(srna, "pattern_bound_box", PROP_FLOAT, PROP_NONE);
1424 RNA_def_property_multi_array(prop, 2, boundbox_dimsize);
1426 RNA_def_property_float_funcs(prop, "rna_tracking_markerPattern_boundbox_get", nullptr, nullptr);
1428 prop, "Pattern Bounding Box", "Pattern area bounding box in normalized coordinates");
1429
1430 /* search */
1431 prop = RNA_def_property(srna, "search_min", PROP_FLOAT, PROP_TRANSLATION);
1432 RNA_def_property_array(prop, 2);
1434 RNA_def_property_float_sdna(prop, nullptr, "search_min");
1437 "Search Min",
1438 "Left-bottom corner of search area in normalized coordinates relative "
1439 "to marker position");
1440 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerSearch_update");
1441
1442 prop = RNA_def_property(srna, "search_max", PROP_FLOAT, PROP_TRANSLATION);
1443 RNA_def_property_array(prop, 2);
1445 RNA_def_property_float_sdna(prop, nullptr, "search_max");
1448 "Search Max",
1449 "Right-bottom corner of search area in normalized coordinates relative "
1450 "to marker position");
1451 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_tracking_markerSearch_update");
1452
1453 /* is marker keyframed */
1454 prop = RNA_def_property(srna, "is_keyed", PROP_BOOLEAN, PROP_NONE);
1458 prop, "Keyframed", "Whether the position of the marker is keyframed or tracked");
1459}
1460
1462{
1463 StructRNA *srna;
1464 FunctionRNA *func;
1465 PropertyRNA *parm;
1466
1467 RNA_def_property_srna(cprop, "MovieTrackingMarkers");
1468 srna = RNA_def_struct(brna, "MovieTrackingMarkers", nullptr);
1469 RNA_def_struct_sdna(srna, "MovieTrackingTrack");
1471 srna, "Movie Tracking Markers", "Collection of markers for movie tracking track");
1472
1473 func = RNA_def_function(srna, "find_frame", "rna_trackingMarkers_find_frame");
1474 RNA_def_function_ui_description(func, "Get marker for specified frame");
1475 parm = RNA_def_int(func,
1476 "frame",
1477 1,
1478 MINFRAME,
1479 MAXFRAME,
1480 "Frame",
1481 "Frame number to find marker for",
1482 MINFRAME,
1483 MAXFRAME);
1485 RNA_def_boolean(func,
1486 "exact",
1487 true,
1488 "Exact",
1489 "Get marker at exact frame number rather than get estimated marker");
1490 parm = RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Marker for specified frame");
1491 RNA_def_function_return(func, parm);
1492
1493 func = RNA_def_function(srna, "insert_frame", "rna_trackingMarkers_insert_frame");
1494 RNA_def_function_ui_description(func, "Insert a new marker at the specified frame");
1495 parm = RNA_def_int(func,
1496 "frame",
1497 1,
1498 MINFRAME,
1499 MAXFRAME,
1500 "Frame",
1501 "Frame number to insert marker to",
1502 MINFRAME,
1503 MAXFRAME);
1506 func,
1507 "co",
1508 2,
1509 nullptr,
1510 -1.0,
1511 1.0,
1512 "Coordinate",
1513 "Place new marker at the given frame using specified in normalized space coordinates",
1514 -1.0,
1515 1.0);
1517 parm = RNA_def_pointer(func, "marker", "MovieTrackingMarker", "", "Newly created marker");
1519 RNA_def_function_return(func, parm);
1520
1521 func = RNA_def_function(srna, "delete_frame", "rna_trackingMarkers_delete_frame");
1522 RNA_def_function_ui_description(func, "Delete marker at specified frame");
1523 parm = RNA_def_int(func,
1524 "frame",
1525 1,
1526 MINFRAME,
1527 MAXFRAME,
1528 "Frame",
1529 "Frame number to delete marker from",
1530 MINFRAME,
1531 MAXFRAME);
1533}
1534
1536{
1537 StructRNA *srna;
1538 PropertyRNA *prop;
1539
1541
1542 srna = RNA_def_struct(brna, "MovieTrackingTrack", nullptr);
1543 RNA_def_struct_path_func(srna, "rna_trackingTrack_path");
1545 srna, "Movie tracking track data", "Match-moving track data for tracking");
1546 RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
1547
1548 /* name */
1549 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1550 RNA_def_property_ui_text(prop, "Name", "Unique name of track");
1551 RNA_def_property_string_funcs(prop, nullptr, nullptr, "rna_trackingTrack_name_set");
1554 RNA_def_struct_name_property(srna, prop);
1555
1556 /* limit frames */
1557 prop = RNA_def_property(srna, "frames_limit", PROP_INT, PROP_NONE);
1559 RNA_def_property_int_sdna(prop, nullptr, "frames_limit");
1563 prop, "Frames Limit", "Every tracking cycle, this number of frames are tracked");
1564
1565 /* pattern match */
1566 prop = RNA_def_property(srna, "pattern_match", PROP_ENUM, PROP_NONE);
1568 RNA_def_property_enum_sdna(prop, nullptr, "pattern_match");
1572 prop, "Pattern Match", "Track pattern from given frame when tracking marker to next frame");
1573
1574 /* margin */
1575 prop = RNA_def_property(srna, "margin", PROP_INT, PROP_PIXEL);
1577 RNA_def_property_int_sdna(prop, nullptr, "margin");
1579 RNA_def_property_range(prop, 0, 300);
1581 prop, "Margin", "Distance from image boundary at which marker stops tracking");
1582
1583 /* tracking motion model */
1584 prop = RNA_def_property(srna, "motion_model", PROP_ENUM, PROP_NONE);
1588 RNA_def_property_ui_text(prop, "Motion Model", "Default motion model to use for tracking");
1589
1590 /* minimum correlation */
1591 prop = RNA_def_property(srna, "correlation_min", PROP_FLOAT, PROP_NONE);
1593 RNA_def_property_float_sdna(prop, nullptr, "minimum_correlation");
1594 RNA_def_property_range(prop, 0.0f, 1.0f);
1595 RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.05, 3);
1597 "Correlation",
1598 "Minimal value of correlation between matched pattern and reference "
1599 "that is still treated as successful tracking");
1600
1601 /* use_brute */
1602 prop = RNA_def_property(srna, "use_brute", PROP_BOOLEAN, PROP_NONE);
1603 RNA_def_property_boolean_sdna(prop, nullptr, "algorithm_flag", TRACK_ALGORITHM_FLAG_USE_BRUTE);
1606 prop, "Prepass", "Use a brute-force translation only pre-track before refinement");
1608
1609 /* use_brute */
1610 prop = RNA_def_property(srna, "use_mask", PROP_BOOLEAN, PROP_NONE);
1611 RNA_def_property_boolean_sdna(prop, nullptr, "algorithm_flag", TRACK_ALGORITHM_FLAG_USE_MASK);
1613 prop,
1614 "Use Mask",
1615 "Use a Grease Pencil data-block as a mask to use only specified areas of pattern "
1616 "when tracking");
1618
1619 /* use_normalization */
1620 prop = RNA_def_property(srna, "use_normalization", PROP_BOOLEAN, PROP_NONE);
1622 prop, nullptr, "algorithm_flag", TRACK_ALGORITHM_FLAG_USE_NORMALIZATION);
1625 prop, "Normalize", "Normalize light intensities while tracking (slower)");
1627
1628 /* markers */
1629 prop = RNA_def_property(srna, "markers", PROP_COLLECTION, PROP_NONE);
1630 RNA_def_property_struct_type(prop, "MovieTrackingMarker");
1631 RNA_def_property_collection_sdna(prop, nullptr, "markers", "markersnr");
1632 RNA_def_property_ui_text(prop, "Markers", "Collection of markers in track");
1634 rna_def_trackingMarkers(brna, prop);
1635
1636 /* ** channels ** */
1637
1638 /* use_red_channel */
1639 prop = RNA_def_property(srna, "use_red_channel", PROP_BOOLEAN, PROP_NONE);
1642 RNA_def_property_ui_text(prop, "Use Red Channel", "Use red channel from footage for tracking");
1644
1645 /* use_green_channel */
1646 prop = RNA_def_property(srna, "use_green_channel", PROP_BOOLEAN, PROP_NONE);
1650 prop, "Use Green Channel", "Use green channel from footage for tracking");
1652
1653 /* use_blue_channel */
1654 prop = RNA_def_property(srna, "use_blue_channel", PROP_BOOLEAN, PROP_NONE);
1657 RNA_def_property_ui_text(prop, "Use Blue Channel", "Use blue channel from footage for tracking");
1659
1660 /* preview_grayscale */
1661 prop = RNA_def_property(srna, "use_grayscale_preview", PROP_BOOLEAN, PROP_NONE);
1665 prop, "Grayscale", "Display what the tracking algorithm sees in the preview");
1667
1668 /* preview_alpha */
1669 prop = RNA_def_property(srna, "use_alpha_preview", PROP_BOOLEAN, PROP_NONE);
1670 RNA_def_property_boolean_sdna(prop, nullptr, "flag", TRACK_PREVIEW_ALPHA);
1672 RNA_def_property_ui_text(prop, "Alpha", "Apply track's mask on displaying preview");
1674
1675 /* has bundle */
1676 prop = RNA_def_property(srna, "has_bundle", PROP_BOOLEAN, PROP_NONE);
1677 RNA_def_property_boolean_sdna(prop, nullptr, "flag", TRACK_HAS_BUNDLE);
1679 RNA_def_property_ui_text(prop, "Has Bundle", "True if track has a valid bundle");
1680
1681 /* bundle position */
1682 prop = RNA_def_property(srna, "bundle", PROP_FLOAT, PROP_TRANSLATION);
1683 RNA_def_property_array(prop, 3);
1684 RNA_def_property_float_sdna(prop, nullptr, "bundle_pos");
1686 RNA_def_property_ui_text(prop, "Bundle", "Position of bundle reconstructed from this track");
1689
1690 /* hide */
1691 prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1692 RNA_def_property_boolean_sdna(prop, nullptr, "flag", TRACK_HIDDEN);
1694 RNA_def_property_ui_text(prop, "Hide", "Track is hidden");
1696
1697 /* select */
1698 prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1700 prop, "rna_trackingTrack_select_get", "rna_trackingTrack_select_set");
1701 RNA_def_property_ui_text(prop, "Select", "Track is selected");
1703
1704 /* select_anchor */
1705 prop = RNA_def_property(srna, "select_anchor", PROP_BOOLEAN, PROP_NONE);
1706 RNA_def_property_boolean_sdna(prop, nullptr, "flag", SELECT);
1707 RNA_def_property_ui_text(prop, "Select Anchor", "Track's anchor point is selected");
1709
1710 /* select_pattern */
1711 prop = RNA_def_property(srna, "select_pattern", PROP_BOOLEAN, PROP_NONE);
1712 RNA_def_property_boolean_sdna(prop, nullptr, "pat_flag", SELECT);
1713 RNA_def_property_ui_text(prop, "Select Pattern", "Track's pattern area is selected");
1715
1716 /* select_search */
1717 prop = RNA_def_property(srna, "select_search", PROP_BOOLEAN, PROP_NONE);
1718 RNA_def_property_boolean_sdna(prop, nullptr, "search_flag", SELECT);
1719 RNA_def_property_ui_text(prop, "Select Search", "Track's search area is selected");
1721
1722 /* locked */
1723 prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1724 RNA_def_property_boolean_sdna(prop, nullptr, "flag", TRACK_LOCKED);
1726 RNA_def_property_ui_text(prop, "Lock", "Track is locked and all changes to it are disabled");
1728
1729 /* custom color */
1730 prop = RNA_def_property(srna, "use_custom_color", PROP_BOOLEAN, PROP_NONE);
1731 RNA_def_property_boolean_sdna(prop, nullptr, "flag", TRACK_CUSTOMCOLOR);
1733 RNA_def_property_ui_text(prop, "Custom Color", "Use custom color instead of theme-defined");
1735
1736 /* color */
1737 prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
1738 RNA_def_property_array(prop, 3);
1739 RNA_def_property_range(prop, 0.0f, 1.0f);
1741 prop,
1742 "Color",
1743 "Color of the track in the Movie Clip Editor and the 3D viewport after a solve");
1745
1746 /* average error */
1747 prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
1748 RNA_def_property_float_sdna(prop, nullptr, "error");
1750 RNA_def_property_ui_text(prop, "Average Error", "Average error of re-projection");
1751
1752 /* Annotations */
1753 prop = RNA_def_property(srna, "annotation", PROP_POINTER, PROP_NONE);
1754 RNA_def_property_pointer_sdna(prop, nullptr, "gpd");
1755 RNA_def_property_struct_type(prop, "Annotation");
1757 prop, nullptr, nullptr, nullptr, "rna_GPencil_datablocks_annotations_poll");
1759 RNA_def_property_ui_text(prop, "Annotation", "Annotation data for this track");
1761
1762 /* weight */
1763 prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
1764 RNA_def_property_float_sdna(prop, nullptr, "weight");
1765 RNA_def_property_range(prop, 0.0f, 1.0f);
1766 RNA_def_property_ui_text(prop, "Weight", "Influence of this track on a final solution");
1767
1768 /* weight_stab */
1769 prop = RNA_def_property(srna, "weight_stab", PROP_FLOAT, PROP_FACTOR);
1770 RNA_def_property_float_sdna(prop, nullptr, "weight_stab");
1771 RNA_def_property_range(prop, 0.0f, 1.0f);
1772 RNA_def_property_ui_text(prop, "Stab Weight", "Influence of this track on 2D stabilization");
1773
1774 /* offset */
1775 prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_TRANSLATION);
1776 RNA_def_property_array(prop, 2);
1778 RNA_def_property_float_sdna(prop, nullptr, "offset");
1779 RNA_def_property_ui_text(prop, "Offset", "Offset of track from the parenting point");
1781}
1782
1784{
1785 StructRNA *srna;
1786 PropertyRNA *prop;
1787
1788 srna = RNA_def_struct(brna, "MovieTrackingPlaneMarker", nullptr);
1790 srna, "Movie Tracking Plane Marker Data", "Match-moving plane marker data for tracking");
1791
1792 /* frame */
1793 prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
1794 RNA_def_property_int_sdna(prop, nullptr, "framenr");
1795 RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
1796 RNA_def_property_int_funcs(prop, nullptr, "rna_trackingPlaneMarker_frame_set", nullptr);
1798
1799 /* Corners */
1800 prop = RNA_def_property(srna, "corners", PROP_FLOAT, PROP_MATRIX);
1801 RNA_def_property_float_sdna(prop, nullptr, "corners");
1806 "Corners",
1807 "Array of coordinates which represents UI rectangle corners in "
1808 "frame normalized coordinates");
1810
1811 /* enable */
1812 prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1814 RNA_def_property_ui_text(prop, "Mode", "Is marker muted for current frame");
1816}
1817
1819{
1820 StructRNA *srna;
1821 FunctionRNA *func;
1822 PropertyRNA *parm;
1823
1824 RNA_def_property_srna(cprop, "MovieTrackingPlaneMarkers");
1825 srna = RNA_def_struct(brna, "MovieTrackingPlaneMarkers", nullptr);
1826 RNA_def_struct_sdna(srna, "MovieTrackingPlaneTrack");
1828 "Movie Tracking Plane Markers",
1829 "Collection of markers for movie tracking plane track");
1830
1831 func = RNA_def_function(srna, "find_frame", "rna_trackingPlaneMarkers_find_frame");
1832 RNA_def_function_ui_description(func, "Get plane marker for specified frame");
1833 parm = RNA_def_int(func,
1834 "frame",
1835 1,
1836 MINFRAME,
1837 MAXFRAME,
1838 "Frame",
1839 "Frame number to find marker for",
1840 MINFRAME,
1841 MAXFRAME);
1843 RNA_def_boolean(func,
1844 "exact",
1845 true,
1846 "Exact",
1847 "Get plane marker at exact frame number rather than get estimated marker");
1848 parm = RNA_def_pointer(
1849 func, "plane_marker", "MovieTrackingPlaneMarker", "", "Plane marker for specified frame");
1850 RNA_def_function_return(func, parm);
1851
1852 func = RNA_def_function(srna, "insert_frame", "rna_trackingPlaneMarkers_insert_frame");
1853 RNA_def_function_ui_description(func, "Insert a new plane marker at the specified frame");
1854 parm = RNA_def_int(func,
1855 "frame",
1856 1,
1857 MINFRAME,
1858 MAXFRAME,
1859 "Frame",
1860 "Frame number to insert marker to",
1861 MINFRAME,
1862 MAXFRAME);
1864 parm = RNA_def_pointer(
1865 func, "plane_marker", "MovieTrackingPlaneMarker", "", "Newly created plane marker");
1867 RNA_def_function_return(func, parm);
1868
1869 func = RNA_def_function(srna, "delete_frame", "rna_trackingPlaneMarkers_delete_frame");
1870 RNA_def_function_ui_description(func, "Delete plane marker at specified frame");
1871 parm = RNA_def_int(func,
1872 "frame",
1873 1,
1874 MINFRAME,
1875 MAXFRAME,
1876 "Frame",
1877 "Frame number to delete plane marker from",
1878 MINFRAME,
1879 MAXFRAME);
1881}
1882
1884{
1885 StructRNA *srna;
1886 PropertyRNA *prop;
1887
1889
1890 srna = RNA_def_struct(brna, "MovieTrackingPlaneTrack", nullptr);
1891 RNA_def_struct_path_func(srna, "rna_trackingPlaneTrack_path");
1893 srna, "Movie tracking plane track data", "Match-moving plane track data for tracking");
1894 RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
1895
1896 /* name */
1897 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1898 RNA_def_property_ui_text(prop, "Name", "Unique name of track");
1899 RNA_def_property_string_funcs(prop, nullptr, nullptr, "rna_trackingPlaneTrack_name_set");
1902 RNA_def_struct_name_property(srna, prop);
1903
1904 /* markers */
1905 prop = RNA_def_property(srna, "markers", PROP_COLLECTION, PROP_NONE);
1906 RNA_def_property_struct_type(prop, "MovieTrackingPlaneMarker");
1907 RNA_def_property_collection_sdna(prop, nullptr, "markers", "markersnr");
1908 RNA_def_property_ui_text(prop, "Markers", "Collection of markers in track");
1910 rna_def_trackingPlaneMarkers(brna, prop);
1911
1912 /* select */
1913 prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1914 RNA_def_property_boolean_sdna(prop, nullptr, "flag", SELECT);
1915 RNA_def_property_ui_text(prop, "Select", "Plane track is selected");
1917
1918 /* auto keyframing */
1919 prop = RNA_def_property(srna, "use_auto_keying", PROP_BOOLEAN, PROP_NONE);
1920 RNA_def_property_boolean_sdna(prop, nullptr, "flag", PLANE_TRACK_AUTOKEY);
1923 prop, "Auto Keyframe", "Automatic keyframe insertion when moving plane corners");
1924 RNA_def_property_ui_icon(prop, ICON_REC, 0);
1925
1926 /* image */
1927 prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1928 RNA_def_property_struct_type(prop, "Image");
1931 prop, "Image", "Image displayed in the track during editing in clip editor");
1934 prop, nullptr, nullptr, nullptr, "rna_Image_no_renderresult_or_viewer_poll");
1935
1936 /* image opacity */
1937 prop = RNA_def_property(srna, "image_opacity", PROP_FLOAT, PROP_FACTOR);
1939 RNA_def_property_range(prop, 0.0, 1.0);
1940 RNA_def_property_ui_text(prop, "Image Opacity", "Opacity of the image");
1942}
1943
1945{
1946 StructRNA *srna;
1947 PropertyRNA *prop;
1948
1949 static const EnumPropertyItem filter_items[] = {
1951 "NEAREST",
1952 0,
1953 "Nearest",
1954 "No interpolation, use nearest neighbor pixel"},
1956 "BILINEAR",
1957 0,
1958 "Bilinear",
1959 "Simple interpolation between adjacent pixels"},
1960 {TRACKING_FILTER_BICUBIC, "BICUBIC", 0, "Bicubic", "High quality pixel interpolation"},
1961 {0, nullptr, 0, nullptr, nullptr},
1962 };
1963
1964 srna = RNA_def_struct(brna, "MovieTrackingStabilization", nullptr);
1965 RNA_def_struct_path_func(srna, "rna_trackingStabilization_path");
1967 srna, "Movie tracking stabilization data", "2D stabilization based on tracking markers");
1968
1969 /* 2d stabilization */
1970 prop = RNA_def_property(srna, "use_2d_stabilization", PROP_BOOLEAN, PROP_NONE);
1973 RNA_def_property_ui_text(prop, "Use 2D Stabilization", "Use 2D stabilization for footage");
1974 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1975
1976 /* use_stabilize_rotation */
1977 prop = RNA_def_property(srna, "use_stabilize_rotation", PROP_BOOLEAN, PROP_NONE);
1981 prop, "Stabilize Rotation", "Stabilize detected rotation around center of frame");
1982 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1983
1984 /* use_stabilize_scale */
1985 prop = RNA_def_property(srna, "use_stabilize_scale", PROP_BOOLEAN, PROP_NONE);
1989 prop, "Stabilize Scale", "Compensate any scale changes relative to center of rotation");
1990 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
1991
1992 /* tracks */
1993 prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
1995 "rna_tracking_stabTracks_begin",
1996 "rna_iterator_listbase_next",
1997 "rna_iterator_listbase_end",
1998 "rna_iterator_listbase_get",
1999 nullptr,
2000 nullptr,
2001 nullptr,
2002 nullptr);
2003 RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2005 prop, "Translation Tracks", "Collection of tracks used for 2D stabilization (translation)");
2006 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2007
2008 /* active track index */
2009 prop = RNA_def_property(srna, "active_track_index", PROP_INT, PROP_NONE);
2010 RNA_def_property_int_sdna(prop, nullptr, "act_track");
2013 "rna_tracking_stabTracks_active_index_get",
2014 "rna_tracking_stabTracks_active_index_set",
2015 "rna_tracking_stabTracks_active_index_range");
2017 "Active Track Index",
2018 "Index of active track in translation stabilization tracks list");
2019
2020 /* tracks used for rotation stabilization */
2021 prop = RNA_def_property(srna, "rotation_tracks", PROP_COLLECTION, PROP_NONE);
2023 "rna_tracking_stabRotTracks_begin",
2024 "rna_iterator_listbase_next",
2025 "rna_iterator_listbase_end",
2026 "rna_iterator_listbase_get",
2027 nullptr,
2028 nullptr,
2029 nullptr,
2030 nullptr);
2031 RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2033 prop, "Rotation Tracks", "Collection of tracks used for 2D stabilization (translation)");
2034 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2035
2036 /* active rotation track index */
2037 prop = RNA_def_property(srna, "active_rotation_track_index", PROP_INT, PROP_NONE);
2038 RNA_def_property_int_sdna(prop, nullptr, "act_rot_track");
2041 "rna_tracking_stabRotTracks_active_index_get",
2042 "rna_tracking_stabRotTracks_active_index_set",
2043 "rna_tracking_stabRotTracks_active_index_range");
2045 "Active Rotation Track Index",
2046 "Index of active track in rotation stabilization tracks list");
2047
2048 /* anchor frame */
2049 prop = RNA_def_property(srna, "anchor_frame", PROP_INT, PROP_NONE);
2050 RNA_def_property_int_sdna(prop, nullptr, "anchor_frame");
2054 "Anchor Frame",
2055 "Reference point to anchor stabilization "
2056 "(other frames will be adjusted relative to this frame's position)");
2057 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2058
2059 /* target position */
2060 prop = RNA_def_property(srna, "target_position", PROP_FLOAT, PROP_TRANSLATION);
2061 RNA_def_property_array(prop, 2);
2063 prop, -FLT_MAX, FLT_MAX, 1, 3); /* increment in steps of 0.01 and show 3 digit after point */
2064 RNA_def_property_float_sdna(prop, nullptr, "target_pos");
2066 "Expected Position",
2067 "Known relative offset of original shot, will be subtracted "
2068 "(e.g. for panning shot, can be animated)");
2070
2071 /* target rotation */
2072 prop = RNA_def_property(srna, "target_rotation", PROP_FLOAT, PROP_ANGLE);
2073 RNA_def_property_float_sdna(prop, nullptr, "target_rot");
2075 RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 10.0f, 3);
2077 prop,
2078 "Expected Rotation",
2079 "Rotation present on original shot, will be compensated (e.g. for deliberate tilting)");
2081
2082 /* target scale */
2083 prop = RNA_def_property(srna, "target_scale", PROP_FLOAT, PROP_FACTOR);
2084 RNA_def_property_float_sdna(prop, nullptr, "scale");
2087 prop, 0.01f, 10.0f, 0.001f, 3); /* increment in steps of 0.001. Show 3 digit after point */
2089 "Expected Scale",
2090 "Explicitly scale resulting frame to compensate zoom of original shot");
2091 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2092
2093 /* Auto-scale. */
2094 prop = RNA_def_property(srna, "use_autoscale", PROP_BOOLEAN, PROP_NONE);
2095 RNA_def_property_boolean_sdna(prop, nullptr, "flag", TRACKING_AUTOSCALE);
2098 prop, "Autoscale", "Automatically scale footage to cover unfilled areas when stabilizing");
2099 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2100
2101 /* max scale */
2102 prop = RNA_def_property(srna, "scale_max", PROP_FLOAT, PROP_FACTOR);
2103 RNA_def_property_float_sdna(prop, nullptr, "maxscale");
2104 RNA_def_property_range(prop, 0.0f, 10.0f);
2105 RNA_def_property_ui_text(prop, "Maximal Scale", "Limit the amount of automatic scaling");
2106 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2107
2108 /* influence_location */
2109 prop = RNA_def_property(srna, "influence_location", PROP_FLOAT, PROP_FACTOR);
2110 RNA_def_property_float_sdna(prop, nullptr, "locinf");
2111 RNA_def_property_range(prop, 0.0f, 1.0f);
2113 prop, "Location Influence", "Influence of stabilization algorithm on footage location");
2114 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2115
2116 /* influence_scale */
2117 prop = RNA_def_property(srna, "influence_scale", PROP_FLOAT, PROP_FACTOR);
2118 RNA_def_property_float_sdna(prop, nullptr, "scaleinf");
2119 RNA_def_property_range(prop, 0.0f, 1.0f);
2121 prop, "Scale Influence", "Influence of stabilization algorithm on footage scale");
2122 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2123
2124 /* influence_rotation */
2125 prop = RNA_def_property(srna, "influence_rotation", PROP_FLOAT, PROP_FACTOR);
2126 RNA_def_property_float_sdna(prop, nullptr, "rotinf");
2127 RNA_def_property_range(prop, 0.0f, 1.0f);
2129 prop, "Rotation Influence", "Influence of stabilization algorithm on footage rotation");
2130 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2131
2132 /* filter */
2133 prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
2134 RNA_def_property_enum_sdna(prop, nullptr, "filter");
2135 RNA_def_property_enum_items(prop, filter_items);
2137 prop,
2138 "Interpolate",
2139 "Interpolation to use for sub-pixel shifts and rotations due to stabilization");
2140 RNA_def_property_update(prop, NC_MOVIECLIP | ND_DISPLAY, "rna_tracking_flushUpdate");
2141
2142 /* UI display : show participating tracks */
2143 prop = RNA_def_property(srna, "show_tracks_expanded", PROP_BOOLEAN, PROP_NONE);
2147 prop, "Show Tracks", "Show UI list of tracks participating in stabilization");
2148 RNA_def_property_ui_icon(prop, ICON_RIGHTARROW, 1);
2149}
2150
2152{
2153 StructRNA *srna;
2154 PropertyRNA *prop;
2155
2156 srna = RNA_def_struct(brna, "MovieReconstructedCamera", nullptr);
2158 "Movie tracking reconstructed camera data",
2159 "Match-moving reconstructed camera data from tracker");
2160
2161 /* frame */
2162 prop = RNA_def_property(srna, "frame", PROP_INT, PROP_NONE);
2164 RNA_def_property_int_sdna(prop, nullptr, "framenr");
2165 RNA_def_property_ui_text(prop, "Frame", "Frame number marker is keyframed on");
2166
2167 /* matrix */
2168 prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
2169 RNA_def_property_float_sdna(prop, nullptr, "mat");
2172 RNA_def_property_ui_text(prop, "Matrix", "Worldspace transformation matrix");
2173
2174 /* average_error */
2175 prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
2176 RNA_def_property_float_sdna(prop, nullptr, "error");
2178 RNA_def_property_ui_text(prop, "Average Error", "Average error of reconstruction");
2179}
2180
2182{
2183 StructRNA *srna;
2184 FunctionRNA *func;
2185 PropertyRNA *parm;
2186
2187 srna = RNA_def_struct(brna, "MovieTrackingReconstructedCameras", nullptr);
2188 RNA_def_struct_sdna(srna, "MovieTrackingReconstruction");
2189 RNA_def_struct_ui_text(srna, "Reconstructed Cameras", "Collection of solved cameras");
2190
2191 func = RNA_def_function(srna, "find_frame", "rna_trackingCameras_find_frame");
2193 RNA_def_function_ui_description(func, "Find a reconstructed camera for a give frame number");
2194 RNA_def_int(func,
2195 "frame",
2196 1,
2197 MINFRAME,
2198 MAXFRAME,
2199 "Frame",
2200 "Frame number to find camera for",
2201 MINFRAME,
2202 MAXFRAME);
2203 parm = RNA_def_pointer(
2204 func, "camera", "MovieReconstructedCamera", "", "Camera for a given frame");
2205 RNA_def_function_return(func, parm);
2206
2207 func = RNA_def_function(srna, "matrix_from_frame", "rna_trackingCameras_matrix_from_frame");
2209 RNA_def_function_ui_description(func, "Return interpolated camera matrix for a given frame");
2210 RNA_def_int(func,
2211 "frame",
2212 1,
2213 MINFRAME,
2214 MAXFRAME,
2215 "Frame",
2216 "Frame number to find camera for",
2217 MINFRAME,
2218 MAXFRAME);
2219 parm = RNA_def_float_matrix(func,
2220 "matrix",
2221 4,
2222 4,
2223 nullptr,
2224 -FLT_MAX,
2225 FLT_MAX,
2226 "Matrix",
2227 "Interpolated camera matrix for a given frame",
2228 -FLT_MAX,
2229 FLT_MAX);
2231 parm, PROP_THICK_WRAP, ParameterFlag(0)); /* needed for string return value */
2232 RNA_def_function_output(func, parm);
2233}
2234
2236{
2237 StructRNA *srna;
2238 PropertyRNA *prop;
2239
2241
2242 srna = RNA_def_struct(brna, "MovieTrackingReconstruction", nullptr);
2244 srna, "Movie tracking reconstruction data", "Match-moving reconstruction data from tracker");
2245
2246 /* is_valid */
2247 prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
2251 "Reconstructed",
2252 "Whether the tracking data contains valid reconstruction information");
2253
2254 /* average_error */
2255 prop = RNA_def_property(srna, "average_error", PROP_FLOAT, PROP_NONE);
2256 RNA_def_property_float_sdna(prop, nullptr, "error");
2258 RNA_def_property_ui_text(prop, "Average Error", "Average error of reconstruction");
2259
2260 /* cameras */
2261 prop = RNA_def_property(srna, "cameras", PROP_COLLECTION, PROP_NONE);
2262 RNA_def_property_struct_type(prop, "MovieReconstructedCamera");
2263 RNA_def_property_collection_sdna(prop, nullptr, "cameras", "camnr");
2264 RNA_def_property_ui_text(prop, "Cameras", "Collection of solved cameras");
2265 RNA_def_property_srna(prop, "MovieTrackingReconstructedCameras");
2266}
2267
2269{
2270 StructRNA *srna;
2271 FunctionRNA *func;
2272 PropertyRNA *prop;
2273 PropertyRNA *parm;
2274
2275 srna = RNA_def_struct(brna, "MovieTrackingTracks", nullptr);
2276 RNA_def_struct_sdna(srna, "MovieTracking");
2277 RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
2278
2279 func = RNA_def_function(srna, "new", "rna_trackingTracks_new");
2281 RNA_def_function_ui_description(func, "Create new motion track in this movie clip");
2282 RNA_def_string(func, "name", nullptr, 0, "", "Name of new track");
2283 RNA_def_int(func,
2284 "frame",
2285 1,
2286 MINFRAME,
2287 MAXFRAME,
2288 "Frame",
2289 "Frame number to add track on",
2290 MINFRAME,
2291 MAXFRAME);
2292 parm = RNA_def_pointer(func, "track", "MovieTrackingTrack", "", "Newly created track");
2294 RNA_def_function_return(func, parm);
2295
2296 /* active track */
2297 prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2298 RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2300 prop, "rna_tracking_active_track_get", "rna_tracking_active_track_set", nullptr, nullptr);
2303 "Active Track",
2304 "Active track in this tracking data object. "
2305 "Deprecated, use objects[name].tracks.active");
2308}
2309
2311{
2312 StructRNA *srna;
2313 PropertyRNA *prop;
2314
2315 srna = RNA_def_struct(brna, "MovieTrackingPlaneTracks", nullptr);
2316 RNA_def_struct_sdna(srna, "MovieTracking");
2317 RNA_def_struct_ui_text(srna, "Movie Plane Tracks", "Collection of movie tracking plane tracks");
2318
2319 /* TODO(sergey): Add API to create new plane tracks */
2320
2321 /* active plane track */
2322 prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2323 RNA_def_property_struct_type(prop, "MovieTrackingPlaneTrack");
2325 "rna_tracking_active_plane_track_get",
2326 "rna_tracking_active_plane_track_set",
2327 nullptr,
2328 nullptr);
2331 "Active Plane Track",
2332 "Active plane track in this tracking data object. "
2333 "Deprecated, use objects[name].plane_tracks.active");
2335}
2336
2338{
2339 StructRNA *srna;
2340 FunctionRNA *func;
2341 PropertyRNA *prop;
2342 PropertyRNA *parm;
2343
2344 srna = RNA_def_struct(brna, "MovieTrackingObjectTracks", nullptr);
2345 RNA_def_struct_sdna(srna, "MovieTrackingObject");
2346 RNA_def_struct_ui_text(srna, "Movie Tracks", "Collection of movie tracking tracks");
2347
2348 func = RNA_def_function(srna, "new", "rna_trackingObject_tracks_new");
2350 RNA_def_function_ui_description(func, "create new motion track in this movie clip");
2351 RNA_def_string(func, "name", nullptr, 0, "", "Name of new track");
2352 RNA_def_int(func,
2353 "frame",
2354 1,
2355 MINFRAME,
2356 MAXFRAME,
2357 "Frame",
2358 "Frame number to add tracks on",
2359 MINFRAME,
2360 MAXFRAME);
2361 parm = RNA_def_pointer(func, "track", "MovieTrackingTrack", "", "Newly created track");
2363 RNA_def_function_return(func, parm);
2364
2365 /* active track */
2366 prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2367 RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2369 "rna_tracking_object_active_track_get",
2370 "rna_tracking_object_active_track_set",
2371 nullptr,
2372 nullptr);
2374 RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
2377}
2378
2380{
2381 StructRNA *srna;
2382 PropertyRNA *prop;
2383
2384 srna = RNA_def_struct(brna, "MovieTrackingObjectPlaneTracks", nullptr);
2385 RNA_def_struct_sdna(srna, "MovieTrackingObject");
2386 RNA_def_struct_ui_text(srna, "Plane Tracks", "Collection of tracking plane tracks");
2387
2388 /* active track */
2389 prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2390 RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2392 "rna_tracking_object_active_plane_track_get",
2393 "rna_tracking_object_active_plane_track_set",
2394 nullptr,
2395 nullptr);
2397 RNA_def_property_ui_text(prop, "Active Track", "Active track in this tracking data object");
2400}
2401
2403{
2404 StructRNA *srna;
2405 PropertyRNA *prop;
2406
2407 srna = RNA_def_struct(brna, "MovieTrackingObject", nullptr);
2409 srna, "Movie tracking object data", "Match-moving object tracking and reconstruction data");
2410
2411 /* name */
2412 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2413 RNA_def_property_ui_text(prop, "Name", "Unique name of object");
2414 RNA_def_property_string_funcs(prop, nullptr, nullptr, "rna_trackingObject_name_set");
2417 RNA_def_struct_name_property(srna, prop);
2418
2419 /* is_camera */
2420 prop = RNA_def_property(srna, "is_camera", PROP_BOOLEAN, PROP_NONE);
2423 RNA_def_property_ui_text(prop, "Camera", "Object is used for camera tracking");
2425
2426 /* tracks */
2427 prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
2429 "rna_trackingObject_tracks_begin",
2430 "rna_iterator_listbase_next",
2431 "rna_iterator_listbase_end",
2432 "rna_iterator_listbase_get",
2433 nullptr,
2434 nullptr,
2435 nullptr,
2436 nullptr);
2437 RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2438 RNA_def_property_ui_text(prop, "Tracks", "Collection of tracks in this tracking data object");
2439 RNA_def_property_srna(prop, "MovieTrackingObjectTracks");
2440
2441 /* plane tracks */
2442 prop = RNA_def_property(srna, "plane_tracks", PROP_COLLECTION, PROP_NONE);
2444 "rna_trackingObject_plane_tracks_begin",
2445 "rna_iterator_listbase_next",
2446 "rna_iterator_listbase_end",
2447 "rna_iterator_listbase_get",
2448 nullptr,
2449 nullptr,
2450 nullptr,
2451 nullptr);
2452 RNA_def_property_struct_type(prop, "MovieTrackingPlaneTrack");
2454 prop, "Plane Tracks", "Collection of plane tracks in this tracking data object");
2455 RNA_def_property_srna(prop, "MovieTrackingObjectPlaneTracks");
2456
2457 /* reconstruction */
2458 prop = RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
2459 RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
2461 prop, "rna_trackingObject_reconstruction_get", nullptr, nullptr, nullptr);
2462
2463 /* scale */
2464 prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
2466 RNA_def_property_float_sdna(prop, nullptr, "scale");
2467 RNA_def_property_range(prop, 0.0001f, 10000.0f);
2468 RNA_def_property_ui_range(prop, 0.0001f, 10000.0, 1, 4);
2470 RNA_def_property_ui_text(prop, "Scale", "Scale of object solution in camera space");
2471 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingObject_flushUpdate");
2472
2473 /* keyframe_a */
2474 prop = RNA_def_property(srna, "keyframe_a", PROP_INT, PROP_NONE);
2476 RNA_def_property_int_sdna(prop, nullptr, "keyframe1");
2478 prop, "Keyframe A", "First keyframe used for reconstruction initialization");
2480
2481 /* keyframe_b */
2482 prop = RNA_def_property(srna, "keyframe_b", PROP_INT, PROP_NONE);
2484 RNA_def_property_int_sdna(prop, nullptr, "keyframe2");
2486 prop, "Keyframe B", "Second keyframe used for reconstruction initialization");
2488}
2489
2491{
2492 StructRNA *srna;
2493 PropertyRNA *prop;
2494
2495 FunctionRNA *func;
2496 PropertyRNA *parm;
2497
2498 RNA_def_property_srna(cprop, "MovieTrackingObjects");
2499 srna = RNA_def_struct(brna, "MovieTrackingObjects", nullptr);
2500 RNA_def_struct_sdna(srna, "MovieTracking");
2501 RNA_def_struct_ui_text(srna, "Movie Objects", "Collection of movie tracking objects");
2502
2503 func = RNA_def_function(srna, "new", "rna_trackingObject_new");
2504 RNA_def_function_ui_description(func, "Add tracking object to this movie clip");
2505 parm = RNA_def_string(func, "name", nullptr, 0, "", "Name of new object");
2507 parm = RNA_def_pointer(func, "object", "MovieTrackingObject", "", "New motion tracking object");
2509 RNA_def_function_return(func, parm);
2510
2511 func = RNA_def_function(srna, "remove", "rna_trackingObject_remove");
2513 RNA_def_function_ui_description(func, "Remove tracking object from this movie clip");
2514 parm = RNA_def_pointer(
2515 func, "object", "MovieTrackingObject", "", "Motion tracking object to be removed");
2518
2519 /* active object */
2520 prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2521 RNA_def_property_struct_type(prop, "MovieTrackingObject");
2523 prop, "rna_tracking_active_object_get", "rna_tracking_active_object_set", nullptr, nullptr);
2525 RNA_def_property_ui_text(prop, "Active Object", "Active object in this tracking data object");
2526}
2527
2529{
2530 StructRNA *srna;
2531 PropertyRNA *prop;
2532
2533 static const EnumPropertyItem sort_items[] = {
2534 {TRACKING_DOPE_SORT_NAME, "NAME", 0, "Name", "Sort channels by their names"},
2536 "LONGEST",
2537 0,
2538 "Longest",
2539 "Sort channels by longest tracked segment"},
2541 "TOTAL",
2542 0,
2543 "Total",
2544 "Sort channels by overall amount of tracked segments"},
2546 "AVERAGE_ERROR",
2547 0,
2548 "Average Error",
2549 "Sort channels by average reprojection error of tracks after solve"},
2550 {TRACKING_DOPE_SORT_START, "START", 0, "Start Frame", "Sort channels by first frame number"},
2551 {TRACKING_DOPE_SORT_END, "END", 0, "End Frame", "Sort channels by last frame number"},
2552 {0, nullptr, 0, nullptr, nullptr},
2553 };
2554
2555 srna = RNA_def_struct(brna, "MovieTrackingDopesheet", nullptr);
2556 RNA_def_struct_path_func(srna, "rna_trackingDopesheet_path");
2557 RNA_def_struct_ui_text(srna, "Movie Tracking Dopesheet", "Match-moving dopesheet data");
2558
2559 /* dopesheet sort */
2560 prop = RNA_def_property(srna, "sort_method", PROP_ENUM, PROP_NONE);
2561 RNA_def_property_enum_sdna(prop, nullptr, "sort_method");
2562 RNA_def_property_enum_items(prop, sort_items);
2564 prop, "Dopesheet Sort Field", "Method to be used to sort channels in dopesheet view");
2565 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2566
2567 /* invert_dopesheet_sort */
2568 prop = RNA_def_property(srna, "use_invert_sort", PROP_BOOLEAN, PROP_NONE);
2571 prop, "Invert Dopesheet Sort", "Invert sort order of dopesheet channels");
2572 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2573
2574 /* show_only_selected */
2575 prop = RNA_def_property(srna, "show_only_selected", PROP_BOOLEAN, PROP_NONE);
2578 prop, "Only Show Selected", "Only include channels relating to selected objects and data");
2579 RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 0);
2580 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2581
2582 /* show_hidden */
2583 prop = RNA_def_property(srna, "show_hidden", PROP_BOOLEAN, PROP_NONE);
2586 prop, "Display Hidden", "Include channels from objects/bone that are not visible");
2587 RNA_def_property_ui_icon(prop, ICON_GHOST_ENABLED, 0);
2588 RNA_def_property_update(prop, NC_MOVIECLIP | NA_EDITED, "rna_trackingDopesheet_tagUpdate");
2589}
2590
2592{
2593 StructRNA *srna;
2594 PropertyRNA *prop;
2595
2609
2610 srna = RNA_def_struct(brna, "MovieTracking", nullptr);
2611 RNA_def_struct_path_func(srna, "rna_tracking_path");
2612 RNA_def_struct_ui_text(srna, "Movie tracking data", "Match-moving data for tracking");
2613
2614 /* settings */
2615 prop = RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
2616 RNA_def_property_struct_type(prop, "MovieTrackingSettings");
2617
2618 /* camera properties */
2619 prop = RNA_def_property(srna, "camera", PROP_POINTER, PROP_NONE);
2620 RNA_def_property_struct_type(prop, "MovieTrackingCamera");
2621
2622 /* tracks */
2623 prop = RNA_def_property(srna, "tracks", PROP_COLLECTION, PROP_NONE);
2625 "rna_trackingTracks_begin",
2626 "rna_iterator_listbase_next",
2627 "rna_iterator_listbase_end",
2628 "rna_iterator_listbase_get",
2629 nullptr,
2630 nullptr,
2631 nullptr,
2632 nullptr);
2633 RNA_def_property_struct_type(prop, "MovieTrackingTrack");
2635 "Tracks",
2636 "Collection of tracks in this tracking data object. "
2637 "Deprecated, use objects[name].tracks");
2638 RNA_def_property_srna(prop, "MovieTrackingTracks");
2639
2640 /* tracks */
2641 prop = RNA_def_property(srna, "plane_tracks", PROP_COLLECTION, PROP_NONE);
2643 "rna_trackingPlaneTracks_begin",
2644 "rna_iterator_listbase_next",
2645 "rna_iterator_listbase_end",
2646 "rna_iterator_listbase_get",
2647 nullptr,
2648 nullptr,
2649 nullptr,
2650 nullptr);
2651 RNA_def_property_struct_type(prop, "MovieTrackingPlaneTrack");
2653 "Plane Tracks",
2654 "Collection of plane tracks in this tracking data object. "
2655 "Deprecated, use objects[name].plane_tracks");
2656 RNA_def_property_srna(prop, "MovieTrackingPlaneTracks");
2657
2658 /* stabilization */
2659 prop = RNA_def_property(srna, "stabilization", PROP_POINTER, PROP_NONE);
2660 RNA_def_property_struct_type(prop, "MovieTrackingStabilization");
2661
2662 /* reconstruction */
2663 prop = RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
2664 RNA_def_property_pointer_sdna(prop, nullptr, "reconstruction_legacy");
2666 prop, "rna_trackingReconstruction_get", nullptr, nullptr, nullptr);
2667 RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
2668
2669 /* objects */
2670 prop = RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
2672 "rna_trackingObjects_begin",
2673 "rna_iterator_listbase_next",
2674 "rna_iterator_listbase_end",
2675 "rna_iterator_listbase_get",
2676 nullptr,
2677 nullptr,
2678 nullptr,
2679 nullptr);
2680 RNA_def_property_struct_type(prop, "MovieTrackingObject");
2681 RNA_def_property_ui_text(prop, "Objects", "Collection of objects in this tracking data object");
2682 rna_def_trackingObjects(brna, prop);
2683
2684 /* active object index */
2685 prop = RNA_def_property(srna, "active_object_index", PROP_INT, PROP_NONE);
2686 RNA_def_property_int_sdna(prop, nullptr, "objectnr");
2689 "rna_tracking_active_object_index_get",
2690 "rna_tracking_active_object_index_set",
2691 "rna_tracking_active_object_index_range");
2692 RNA_def_property_ui_text(prop, "Active Object Index", "Index of active object");
2694
2695 /* dopesheet */
2696 prop = RNA_def_property(srna, "dopesheet", PROP_POINTER, PROP_NONE);
2697 RNA_def_property_struct_type(prop, "MovieTrackingDopesheet");
2698}
2699
2701{
2702 rna_def_tracking(brna);
2703}
2704
2705} // namespace blender
2706
2707#endif
#define G_MAIN
#define SELECT
Definition BKE_mask.hh:19
#define TRACK_SELECTED(track)
#define STRNCPY_UTF8(dst, src)
#define BLT_I18NCONTEXT_ID_MOVIECLIP
#define MAX_ID_NAME
Definition DNA_ID.h:367
#define MAX_NAME
Definition DNA_defs.h:63
Object is a sort of wrapper for general info.
#define MINFRAME
#define MAXFRAME
#define RNA_TRANSLATION_PREC_DEFAULT
Definition RNA_types.hh:272
#define ND_DISPLAY
Definition WM_types.hh:534
#define NC_MOVIECLIP
Definition WM_types.hh:410
#define NC_SCENE
Definition WM_types.hh:391
#define ND_NODES
Definition WM_types.hh:455
#define NA_EDITED
Definition WM_types.hh:634
#define ND_SELECT
Definition WM_types.hh:551
#define ND_TRANSFORM
Definition WM_types.hh:475
#define NC_OBJECT
Definition WM_types.hh:392
btScalar max
#define SHRT_MAX
#define FLT_MAX
#define INT_MAX
#define FLT_EPSILON
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
BMesh Iterators.
void WM_main_add_notifier(uint type, void *reference)
static void rna_def_trackingReconstructedCameras(BlenderRNA *brna)
void RNA_def_property_srna(PropertyRNA *prop, const char *type)
void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
void BKE_tracking_track_unique_name(ListBaseT< MovieTrackingTrack > *tracksbase, MovieTrackingTrack *track)
Definition tracking.cc:587
MovieTrackingMarker * BKE_tracking_marker_get_exact(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1396
static void rna_def_trackingTrack(BlenderRNA *brna)
static void rna_def_trackingPlaneTracks(BlenderRNA *brna)
static const EnumPropertyItem tracker_motion_model[]
void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
char * STRNCPY(char(&dst)[N], const char *src)
void RNA_def_struct_ui_icon(StructRNA *srna, int icon)
@ TRACK_ALGORITHM_FLAG_USE_NORMALIZATION
@ TRACK_ALGORITHM_FLAG_USE_MASK
@ TRACK_ALGORITHM_FLAG_USE_BRUTE
void BKE_ntree_update(Main &bmain, std::optional< Span< bNodeTree * > > modified_trees=std::nullopt, const NodeTreeUpdateExtraParams &params={})
void BKE_tracking_marker_clamp_search_size(MovieTrackingMarker *marker)
Definition tracking.cc:1332
PropertyRNA * RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, const int maxlen, const char *ui_name, const char *ui_description)
void RNA_def_function_output(FunctionRNA *, PropertyRNA *ret)
void BKE_tracking_camera_principal_point_pixel_get(MovieClip *clip, float r_principal_point_pixel[2])
Definition tracking.cc:2177
void BKE_movieclip_get_size(MovieClip *clip, const MovieClipUser *user, int *r_width, int *r_height)
void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t booleanbit)
void BKE_ntree_update_tag_id_changed(Main *bmain, ID *id)
void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
MovieTrackingObject * BKE_tracking_object_add(MovieTracking *tracking, const char *name)
Definition tracking.cc:1902
void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set, const char *type_fn, const char *poll)
@ TRACK_MATCH_PREVIOUS_FRAME
void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
MINLINE void copy_v2_v2(float r[2], const float a[2])
void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
Definition tracking.cc:1982
void BKE_tracking_get_rna_path_prefix_for_plane_track(const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track, char *rna_path, size_t rna_path_maxncpy)
Definition tracking.cc:3468
void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, const int length[])
static const EnumPropertyItem pattern_match_items[]
void RNA_def_function_ui_description(FunctionRNA *func, const char *description)
static void rna_def_trackingCamera(BlenderRNA *brna)
@ TRACKING_DISTORTION_MODEL_DIVISION
@ TRACKING_DISTORTION_MODEL_POLYNOMIAL
@ TRACKING_DISTORTION_MODEL_NUKE
@ TRACKING_DISTORTION_MODEL_BROWN
std::string RNA_path_name_to_infix(const StringRefNull string)
Definition rna_path.cc:1419
@ FUNC_USE_REPORTS
@ FUNC_USE_SELF_ID
Definition RNA_types.hh:980
MovieTrackingTrack * BKE_tracking_track_add(MovieTracking *tracking, ListBaseT< MovieTrackingTrack > *tracksbase, float x, float y, int framenr, int width, int height)
Definition tracking.cc:527
static void rna_def_trackingMarker(BlenderRNA *brna)
static void rna_def_trackingObjectTracks(BlenderRNA *brna)
PropertyRNA * RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type, const char *ui_name, const char *ui_description)
static void rna_def_reconstructedCamera(BlenderRNA *brna)
void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
MINLINE int max_ii(int a, int b)
static void rna_def_trackingTracks(BlenderRNA *brna)
static void rna_def_trackingSettings(BlenderRNA *brna)
void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
@ TRACKING_USE_KEYFRAME_SELECTION
void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
MovieTrackingMarker * BKE_tracking_marker_insert(MovieTrackingTrack *track, MovieTrackingMarker *marker)
Definition tracking.cc:1240
void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
PropertyRNA * RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, const int len, const float *default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
void BKE_tracking_dopesheet_tag_update(MovieTracking *tracking)
Definition tracking.cc:3355
void RNA_def_property_float_default(PropertyRNA *prop, float value)
void BKE_animdata_fix_paths(ID &id, StringRef prefix, StringRef old_infix, StringRef new_infix, bool verify_paths, const DriverMap &driver_map)
MovieTrackingObject * BKE_tracking_find_object_for_plane_track(const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track)
Definition tracking.cc:3396
void RNA_def_tracking(BlenderRNA *brna)
PropertyRNA * RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier_c_str, int type, int subtype)
void BKE_tracking_get_rna_path_for_plane_track(const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track, char *rna_path, size_t rna_path_maxncpy)
Definition tracking.cc:3445
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
void BKE_tracking_marker_pattern_minmax(const MovieTrackingMarker *marker, float min[2], float max[2])
Definition tracking.cc:1500
void BKE_tracking_get_rna_path_for_track(const MovieTracking *tracking, const MovieTrackingTrack *track, char *rna_path, size_t rna_path_maxncpy)
Definition tracking.cc:3407
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *tracking_object)
Definition tracking.cc:1961
void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
void RNA_def_parameter_clear_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
@ TRACKING_DOPE_SORT_AVERAGE_ERROR
@ PROP_BOOLEAN
Definition RNA_types.hh:210
@ PROP_POINTER
Definition RNA_types.hh:215
@ PROP_STRING
Definition RNA_types.hh:213
@ PROP_COLLECTION
Definition RNA_types.hh:216
void RNA_def_parameter_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
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)
void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
void DEG_id_tag_update(ID *id, unsigned int flags)
BMesh const char void * data
void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t booleanbit)
void RNA_def_property_range(PropertyRNA *prop, double min, double max)
void BKE_tracking_camera_get_reconstructed_interpolate(MovieTracking *tracking, MovieTrackingObject *tracking_object, float framenr, float mat[4][4])
Definition tracking.cc:2151
MovieTrackingObject * BKE_tracking_object_get_camera(const MovieTracking *tracking)
Definition tracking.cc:1987
static void rna_def_trackingDopesheet(BlenderRNA *brna)
void RNA_def_struct_path_func(StructRNA *srna, const char *path)
void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
struct MovieReconstructedCamera * BKE_tracking_camera_get_reconstructed(MovieTracking *tracking, MovieTrackingObject *tracking_object, int framenr)
Definition tracking.cc:2138
static void rna_def_trackingObject(BlenderRNA *brna)
@ TRACKING_STABILIZE_ROTATION
FunctionRNA * RNA_def_function(StructRNA *srna, const char *identifier_c_str, const char *call)
void BKE_tracking_get_rna_path_prefix_for_track(const MovieTracking *tracking, const MovieTrackingTrack *track, char *rna_path, size_t rna_path_maxncpy)
Definition tracking.cc:3429
@ REFINE_TANGENTIAL_DISTORTION
static void rna_def_trackingObjectPlaneTracks(BlenderRNA *brna)
void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
static void rna_def_trackingMarkers(BlenderRNA *brna, PropertyRNA *cprop)
void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
void RNA_def_property_clear_flag(PropertyRNA *prop, PropertyFlag flag)
const int rna_matrix_dimsize_4x2[]
void BKE_tracking_marker_delete(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1286
void RNA_def_function_flag(FunctionRNA *func, FunctionFlag flag)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, const int default_value, const int hardmin, const int hardmax, const char *ui_name, const char *ui_description, const int softmin, const int softmax)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition report.cc:191
static void rna_def_trackingPlaneMarker(BlenderRNA *brna)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get_exact(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1842
static void rna_def_trackingStabilization(BlenderRNA *brna)
static void rna_def_trackingPlaneTrack(BlenderRNA *brna)
void BKE_tracking_distortion_free(MovieDistortion *distortion)
Definition tracking.cc:2414
StructRNA * RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1796
void BKE_tracking_plane_marker_delete(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1765
MovieTrackingObject * BKE_tracking_find_object_for_track(const MovieTracking *tracking, const MovieTrackingTrack *track)
Definition tracking.cc:3385
@ PROP_EDITABLE
Definition RNA_types.hh:376
@ PROP_THICK_WRAP
Definition RNA_types.hh:493
@ PROP_NEVER_UNLINK
Definition RNA_types.hh:454
@ PROP_ID_REFCOUNT
Definition RNA_types.hh:434
@ PROP_NEVER_NULL
Definition RNA_types.hh:447
@ PROP_ANIMATABLE
Definition RNA_types.hh:389
void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_insert(MovieTrackingPlaneTrack *plane_track, MovieTrackingPlaneMarker *plane_marker)
Definition tracking.cc:1724
PointerRNA RNA_pointer_create_with_parent(const PointerRNA &parent, StructRNA *type, void *data)
@ TRACK_MOTION_MODEL_TRANSLATION_SCALE
@ TRACK_MOTION_MODEL_HOMOGRAPHY
@ TRACK_MOTION_MODEL_TRANSLATION_ROTATION_SCALE
@ TRACK_MOTION_MODEL_TRANSLATION
@ TRACK_MOTION_MODEL_AFFINE
@ TRACK_MOTION_MODEL_TRANSLATION_ROTATION
void BKE_tracking_plane_track_unique_name(ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base, MovieTrackingPlaneTrack *plane_track)
Definition tracking.cc:1620
void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
@ TRACKING_DOPE_SELECTED_ONLY
static void rna_def_trackingReconstruction(BlenderRNA *brna)
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
PropertyRNA * RNA_def_float_matrix(StructOrFunctionRNA *cont_, const char *identifier, const int rows, const int columns, const float *default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
@ PROP_FACTOR
Definition RNA_types.hh:308
@ PROP_TRANSLATION
Definition RNA_types.hh:318
@ PROP_MATRIX
Definition RNA_types.hh:322
@ PROP_COLOR_GAMMA
Definition RNA_types.hh:329
@ PARM_REQUIRED
Definition RNA_types.hh:631
@ PARM_RNAPTR
Definition RNA_types.hh:633
void rna_iterator_listbase_begin(CollectionPropertyIterator *iter, PointerRNA *ptr, ListBase *lb, IteratorSkipFunc skip)
static void rna_def_tracking(BlenderRNA *brna)
void RNA_def_struct_name_property(StructRNA *srna, PropertyRNA *prop, const bool allow_replace)
void RNA_def_property_array(PropertyRNA *prop, int length)
const int rna_matrix_dimsize_4x4[]
void BKE_tracking_camera_principal_point_pixel_set(MovieClip *clip, const float principal_point_pixel[2])
Definition tracking.cc:2190
void RNA_def_property_ui_icon(PropertyRNA *prop, int icon, int consecutive)
static void rna_def_trackingPlaneMarkers(BlenderRNA *brna, PropertyRNA *cprop)
bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *tracking_object)
Definition tracking.cc:1931
static void rna_def_trackingObjects(BlenderRNA *brna, PropertyRNA *cprop)
MovieTrackingMarker * BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1363
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
#define min(a, b)
Definition sort.cc:38