53#include "RNA_prototypes.hh"
69 ListBaseT<MovieTrackingTrack>
tracks;
83 tracks->free_no_destruct();
93 plane_tracks->free_no_destruct();
104 MEM_delete(reconstruction->
cameras);
129 objects->free_no_destruct();
140 channel = dopesheet->
channels.first();
146 channel = channel->
next;
150 dopesheet->
channels.free_no_destruct();
154 dopesheet->
channels.clear_no_delete();
181 MEM_new<Map<MovieTrackingPlaneTrack *, MovieTrackingPlaneTrack *>>(__func__);
193 ListBaseT<MovieTrackingTrack> *tracks_dst,
194 const ListBaseT<MovieTrackingTrack> *tracks_src,
197 tracks_dst->clear_no_delete();
201 if (track_src.markers) {
202 track_dst->
markers = MEM_dupalloc(track_src.markers);
218 ListBaseT<MovieTrackingPlaneTrack> *plane_tracks_list_dst,
219 const ListBaseT<MovieTrackingPlaneTrack> *plane_tracks_list_src,
222 plane_tracks_list_dst->clear_no_delete();
227 if (plane_track_src.markers) {
229 MEM_dupalloc(plane_track_src.markers));
235 plane_track_src.point_tracks[i]);
241 BLI_addtail(plane_tracks_list_dst, plane_track_dst);
253 *reconstruction_dst = *reconstruction_src;
254 if (reconstruction_src->
cameras) {
256 MEM_dupalloc(reconstruction_src->
cameras));
265 *stabilization_dst = *stabilization_src;
275 *tracking_object_dst = *tracking_object_src;
299 const ListBaseT<MovieTrackingObject> *tracking_objects_src,
302 tracking_objects_dst->clear_no_delete();
307 BLI_addtail(tracking_objects_dst, tracking_object_dst);
315 *tracking_dst = *tracking_src;
328 tracking_dst->
stats =
nullptr;
397 float viewfac, pixsize, left, right, bottom, top, clipsta, clipend;
400 float shiftx, shifty, winside =
float(
min_ii(winx, winy));
414 pixsize = clipsta / viewfac;
416 left = -0.5f *
float(winx) + shiftx * winside;
417 bottom = -0.5f * (ycor) *
float(winy) + shifty * winside;
418 right = 0.5f *
float(winx) + shiftx * winside;
419 top = 0.5f * (ycor) *
float(winy) + shifty * winside;
426 perspective_m4(winmat, left, right, bottom, top, clipsta, clipend);
450 next_track = track->
next;
489 if (track.
prev ==
nullptr) {
503 ListBaseT<MovieTrackingTrack> *tracks_list)
528 ListBaseT<MovieTrackingTrack> *tracksbase,
542 const float pattern_size[2] = {half_pattern_px / width, half_pattern_px / height};
543 const float search_size[2] = {half_search_px / width, half_search_px / height};
571 new_track = MEM_new<MovieTrackingTrack>(
"tracking_track_duplicate new_track");
574 new_track->
next = new_track->
prev =
nullptr;
595 sizeof(track->
name));
610 const int last_marker_index = track->
markersnr - 1;
616 const int num_tracks,
621 *r_last_frame = INT_MIN;
622 for (
int i = 0; i < num_tracks; ++i) {
624 int track_first_frame, track_last_frame;
626 *r_first_frame =
min_ii(*r_first_frame, track_first_frame);
627 *r_last_frame =
max_ii(*r_last_frame, track_last_frame);
633 int num_selected_tracks = 0;
636 ++num_selected_tracks;
639 return num_selected_tracks;
657 if (num_selected_tracks == 0) {
662 num_selected_tracks,
"selected tracks array");
663 int source_track_index = 0;
668 source_tracks[source_track_index] = &track;
669 ++source_track_index;
672 *r_num_tracks = num_selected_tracks;
674 return source_tracks;
705 track->
flag &= ~flag;
729 for (
int a = 1; a < track->
markersnr; a++) {
746 for (
int a = track->
markersnr - 1; a >= 0; a--) {
770 marker_new = *marker;
803 int i = 0, a = 0,
b = 0, tot;
807 markers = MEM_new_array<MovieTrackingMarker>(tot,
"tmp tracking joined tracks");
811 markers[i] = src_track->
markers[a++];
814 markers[i] = dst_track->
markers[
b++];
817 markers[i] = src_track->
markers[a++];
820 markers[i] = dst_track->
markers[
b++];
839 marker_a = &src_track->
markers[a];
860 for (
int j = 0; j <
len; j++) {
864 fac = 1.0f / (
len - 1) * j;
871 marker_a = &src_track->
markers[a];
887 markers[i] = src_track->
markers[a];
901 MEM_delete(dst_track->
markers);
903 dst_track->
markers = MEM_new_array<MovieTrackingMarker>(i,
"tracking joined tracks");
923 for (
int corner = 0; corner < 4; ++corner) {
941 for (
int corner = 0; corner < 4; ++corner) {
952 const int num_src_tracks)
955 int first_frame, last_frame;
957 src_tracks, num_src_tracks, &first_frame, &last_frame);
958 if (last_frame < first_frame) {
961 const int num_frames = last_frame - first_frame + 1;
965 num_frames,
"tracks average accumulator");
967 for (
int frame = first_frame; frame <= last_frame; ++frame) {
968 const int frame_index = frame - first_frame;
969 accumulator[frame_index].
framenr = frame;
974 for (
int track_index = 0; track_index < num_src_tracks; ++track_index) {
976 for (
int frame = first_frame; frame <= last_frame; ++frame) {
981 const int frame_index = frame - first_frame;
983 ++counters[frame_index];
988 for (
int frame = first_frame; frame <= last_frame; ++frame) {
990 const int frame_index = frame - first_frame;
991 if (!counters[frame_index]) {
994 const float multiplier = 1.0f /
float(counters[frame_index]);
1001 MEM_delete(accumulator);
1002 MEM_delete(counters);
1009 const int num_src_tracks)
1013 for (
int track_index = 0; track_index < num_src_tracks; track_index++) {
1021 const int num_src_tracks)
1023 if (num_src_tracks == 0) {
1032 MovieTracking *tracking,
int selection_index, ListBaseT<MovieTrackingTrack> **r_tracksbase)
1039 if (cur == selection_index) {
1040 *r_tracksbase = &
object.tracks;
1049 *r_tracksbase =
nullptr;
1075 frame = frame->
next;
1099 size_t index_end = size_t(
y) *
data->mask_width + x_end;
1102 }
while (++
index != index_end);
1106 const int frame_height,
1107 const float region_min[2],
1110 const int mask_width,
1111 const int mask_height)
1117 data.mask_width = mask_width;
1118 data.mask_height = mask_height;
1128 mask_points[i][0] = stroke_points[i].
x * frame_width - region_min[0];
1129 mask_points[i][1] = stroke_points[i].
y * frame_height - region_min[1];
1135 stroke = stroke->
next;
1137 frame = frame->
next;
1142 const int frame_height,
1143 const float region_min[2],
1144 const float region_max[2],
1147 float *
mask =
nullptr;
1149 if (
layer !=
nullptr) {
1150 const int mask_width = region_max[0] - region_min[0];
1151 const int mask_height = region_max[1] - region_min[1];
1154 frame_width, frame_height, region_min,
layer,
mask, mask_width, mask_height);
1160 const int frame_height,
1165 const float region_min[2] = {
1169 const float region_max[2] = {
1174 frame_width, frame_height, region_min, region_max, track);
1181 const FCurve *weight_fcurve;
1182 float weight = track->
weight;
1185 &clip->
id, track, RNA_MovieTrackingTrack,
"weight", 0,
nullptr);
1187 if (weight_fcurve) {
1251 *old_marker = *marker;
1272 track->
markers = MEM_new<MovieTrackingMarker>(
"MovieTracking markers");
1276 memmove(track->
markers + a + 2,
1281 track->
markers[a + 1] = *marker;
1283 return &track->
markers[a + 1];
1290 while (a < track->markersnr) {
1315 float pat_min[2], pat_max[2];
1318 for (
int a = 0; a < 2; a++) {
1320 for (
int b = 0;
b < 4;
b++) {
1325 for (
int b = 0;
b < 4;
b++) {
1334 float pat_min[2], pat_max[2];
1337 for (
int a = 0; a < 2; a++) {
1345 float pat_min[2], pat_max[2];
1351 for (
int a = 0; a < 2; a++) {
1365 const int num_markers = track->
markersnr;
1367 if (num_markers == 0) {
1368 BLI_assert_msg(0,
"Detected degenerated track, should never happen.");
1372 int left_boundary = 0;
1373 int right_boundary = num_markers;
1374 while (left_boundary < right_boundary) {
1375 const int median_index = (left_boundary + right_boundary) / 2;
1378 if (marker->
framenr == framenr) {
1382 if (marker->
framenr < framenr) {
1383 left_boundary = median_index + 1;
1387 right_boundary = median_index - 1;
1391 const int closest_index =
clamp_i(right_boundary, 0, num_markers - 1);
1393 return &track->
markers[closest_index];
1400 if (marker->
framenr != framenr) {
1411 if (marker->
framenr != framenr) {
1414 marker_new = *marker;
1432 while (current_marker >= track->
markers && current_marker <= last_marker) {
1434 return current_marker;
1436 current_marker += direction;
1447 if (closest_marker ==
nullptr) {
1451 *r_marker = *closest_marker;
1456 track, closest_marker, -1);
1457 if (left_marker ==
nullptr) {
1462 track, closest_marker + 1, 1);
1463 if (right_marker ==
nullptr) {
1467 if (left_marker == right_marker) {
1468 *r_marker = *left_marker;
1472 const float factor =
float(framenr - left_marker->
framenr) /
1477 for (
int i = 0; i < 4; i++) {
1490 if (framenr == left_marker->
framenr) {
1491 r_marker->
flag = left_marker->
flag;
1493 else if (framenr == right_marker->
framenr) {
1494 r_marker->
flag = right_marker->
flag;
1519 if (marker != marker_last) {
1527 float fac = (framenr - int(framenr)) / (marker_next->
framenr - marker->
framenr);
1549 ListBaseT<MovieTrackingPlaneTrack> *plane_tracks_base,
1550 ListBaseT<MovieTrackingTrack> *tracks,
1555 float tracks_min[2], tracks_max[2];
1556 int num_selected_tracks = 0;
1565 float pattern_min[2], pattern_max[2];
1571 num_selected_tracks++;
1575 if (num_selected_tracks < 4) {
1580 plane_track = MEM_new<MovieTrackingPlaneTrack>(
"new plane track");
1589 "new plane tracks array");
1590 int track_index = 0;
1600 plane_marker.
framenr = framenr;
1606 plane_marker.
corners[1][0] = tracks_max[0];
1607 plane_marker.
corners[1][1] = tracks_min[1];
1608 plane_marker.
corners[3][0] = tracks_min[0];
1609 plane_marker.
corners[3][1] = tracks_max[1];
1628 sizeof(plane_track->
name));
1634 MEM_delete(plane_track->
markers);
1668 for (
int i = 0, track_index = 0; i < plane_track->
point_tracksnr; i++) {
1670 new_point_tracks[track_index++] = plane_track->
point_tracks[i];
1733 if (old_plane_marker) {
1735 *old_plane_marker = *plane_marker;
1737 return old_plane_marker;
1755 memmove(plane_track->
markers + a + 2,
1760 plane_track->
markers[a + 1] = *plane_marker;
1762 return &plane_track->
markers[a + 1];
1769 while (a < plane_track->markersnr) {
1772 memmove(plane_track->
markers + a,
1780 MEM_delete(plane_track->
markers);
1781 plane_track->
markers =
nullptr;
1806 if (framenr < plane_track->markers[0].framenr) {
1807 return &plane_track->
markers[0];
1815 while (a < plane_track->markersnr && plane_track->
markers[a].
framenr <= framenr) {
1819 return &plane_track->
markers[a];
1825 return &plane_track->
markers[a - 1];
1832 return &plane_track->
markers[a];
1839 return &plane_track->
markers[a];
1847 if (plane_marker->
framenr != framenr) {
1851 return plane_marker;
1859 if (plane_marker->
framenr != framenr) {
1862 plane_marker_new = *plane_marker;
1863 plane_marker_new.
framenr = framenr;
1868 return plane_marker;
1873 float corners[4][2])
1877 if (marker != marker_last) {
1880 float fac = (framenr - int(framenr)) / (marker_next->
framenr - marker->
framenr);
1881 for (
int i = 0; i < 4; i++) {
1886 for (
int i = 0; i < 4; i++) {
1892 for (
int i = 0; i < 4; i++) {
1921 tracking_object->
scale = 1.0f;
1928 return tracking_object;
1968 sizeof(tracking_object->
name));
1974 if (
STREQ(tracking_object.
name, name)) {
1975 return &tracking_object;
1991 return &tracking_object;
2015 return &plane_track;
2033 if (!reconstruction->
camnr) {
2037 if (framenr < cameras[0].framenr) {
2045 if (framenr > cameras[reconstruction->
camnr - 1].
framenr) {
2047 return reconstruction->
camnr - 1;
2057 if (cameras[a].framenr >= framenr) {
2061 while (a >= 0 && a < reconstruction->camnr) {
2062 int cfra = cameras[a].
framenr;
2066 if (d > 0 && cfra > framenr) {
2075 if (d < 0 && cfra < framenr) {
2084 if (cfra == framenr) {
2108 MovieTracking *tracking,
int winx,
int winy,
float *shiftx,
float *shifty)
2110 float principal_px[2];
2116 *shiftx = (0.5f * winx - principal_px[0]) / winx;
2117 *shifty = (0.5f * winy - principal_px[1]) / winx;
2129 scene->
r.
xsch = width;
2130 scene->
r.
ysch = height;
2133 scene->
r.
yasp = 1.0f;
2148 return &reconstruction->
cameras[a];
2166 if ((a < reconstruction->camnr - 1) && (cameras[a].framenr != framenr)) {
2167 float t = (framenr - cameras[a].
framenr) / (cameras[a + 1].framenr - cameras[a].framenr);
2178 float r_principal_point_pixel[2])
2182 int frame_width, frame_height;
2187 camera->principal_point, frame_width, frame_height, r_principal_point_pixel);
2191 const float principal_point_pixel[2])
2195 int frame_width, frame_height;
2200 principal_point_pixel, frame_width, frame_height,
camera->principal_point);
2218 return a->
k1 ==
b->k1 && a->
k2 ==
b->k2 && a->
k3 ==
b->k3;
2236 switch (
camera->distortion_model) {
2249 camera->distortion_model,
2269 int calibration_width,
2270 int calibration_height)
2276 tracking, calibration_width, calibration_height, &camera_intrinsics_options);
2294 int calibration_width,
2295 int calibration_height)
2300 tracking, calibration_width, calibration_height, &camera_intrinsics_options);
2318 *new_distortion = *distortion;
2321 return new_distortion;
2327 int calibration_width,
2328 int calibration_height,
2391 float inv_focal = 1.0f / distortion->
focal;
2392 double x = (co[0] - distortion->
principal_px[0]) * inv_focal,
2393 y = (co[1] - distortion->
principal_px[1] * aspy) * inv_focal;
2406 double x = co[0],
y = co[1];
2418 MEM_delete(distortion);
2422 MovieTracking *tracking,
int image_width,
int image_height,
const float co[2],
float r_co[2])
2429 tracking, image_width, image_height, &camera_intrinsics_options);
2432 float principal_px[2];
2437 double x = (co[0] - principal_px[0]) /
camera->focal,
2438 y = (co[1] - principal_px[1] * aspy) /
camera->focal;
2449 MovieTracking *tracking,
int image_width,
int image_height,
const float co[2],
float r_co[2])
2456 tracking, image_width, image_height, &camera_intrinsics_options);
2459 double x = co[0],
y = co[1];
2463 float principal_px[2];
2468 r_co[1] =
float(
y) *
camera->focal + principal_px[1] * aspy;
2473 int calibration_width,
2474 int calibration_height,
2479 if (
camera->intrinsics ==
nullptr) {
2481 tracking, calibration_width, calibration_height);
2495 int calibration_width,
2496 int calibration_height,
2501 if (
camera->intrinsics ==
nullptr) {
2503 tracking, calibration_width, calibration_height);
2521 const bool grayscale)
2531 const int frame_height,
2532 const ImBuf *search_ibuf,
2535 const bool from_anchor,
2536 const bool use_mask,
2537 const int num_samples_x,
2538 const int num_samples_y,
2541 ImBuf *pattern_ibuf;
2542 double src_pixel_x[5], src_pixel_y[5];
2543 double warped_position_x, warped_position_y;
2544 float *
mask =
nullptr;
2546 if (num_samples_x <= 0 || num_samples_y <= 0) {
2556 frame_width, frame_height, marker, src_pixel_x, src_pixel_y);
2566 for (
int a = 0; a < 5; a++) {
2567 src_pixel_x[a] += double((track->
offset[0] * frame_width) -
2568 int(track->
offset[0] * frame_width));
2569 src_pixel_y[a] += double((track->
offset[1] * frame_height) -
2570 int(track->
offset[1] * frame_height));
2573 if (track->
offset[0] < 0.0f) {
2574 src_pixel_x[a] += 1.0;
2576 if (track->
offset[1] < 0.0f) {
2577 src_pixel_y[a] += 1.0;
2598 &warped_position_y);
2612 &warped_position_y);
2616 pos[0] = warped_position_x;
2617 pos[1] = warped_position_y;
2624 return pattern_ibuf;
2630 const bool anchored,
2631 const bool disable_channels)
2633 ImBuf *pattern_ibuf, *search_ibuf;
2634 float pat_min[2], pat_max[2];
2635 int num_samples_x, num_samples_y;
2639 num_samples_x = (pat_max[0] - pat_min[0]) * ibuf->
x;
2640 num_samples_y = (pat_max[1] - pat_min[1]) * ibuf->
y;
2659 pattern_ibuf =
nullptr;
2662 return pattern_ibuf;
2668 const bool anchored,
2669 const bool disable_channels)
2673 float search_origin[2];
2677 x = search_origin[0];
2678 y = search_origin[1];
2688 if (
w <= 0 || h <= 0) {
2696 int dst_x = 0, dst_y = 0;
2707 if (
x +
w > ibuf->
x) {
2710 if (
y + h > ibuf->
y) {
2713 if (
w > 0 && h > 0) {
2717 if (disable_channels) {
2730 const int frame_width,
2731 const int frame_height)
2733 const float a_px[2] = {a[0] * frame_width, a[1] * frame_height};
2734 const float b_px[2] = {
b[0] * frame_width,
b[1] * frame_height};
2746 const int frame_width = frame_ibuf->
x;
2747 const int frame_height = frame_ibuf->
y;
2751 corners[0], corners[3], frame_width, frame_height);
2753 corners[1], corners[2], frame_width, frame_height);
2757 corners[3], corners[2], frame_width, frame_height);
2759 corners[0], corners[1], frame_width, frame_height);
2762 const int num_samples_x =
max_ii(top_side_len_px, bottom_side_len_px);
2763 const int num_samples_y =
max_ii(left_side_len_px, right_side_len_px);
2772 const double src_pixel_x[4] = {corners[0][0] * frame_width,
2773 corners[1][0] * frame_width,
2774 corners[2][0] * frame_width,
2775 corners[3][0] * frame_width};
2776 const double src_pixel_y[4] = {corners[0][1] * frame_height,
2777 corners[1][1] * frame_height,
2778 corners[2][1] * frame_height,
2779 corners[3][1] * frame_height};
2782 double warped_position_x, warped_position_y;
2797 &warped_position_y);
2811 &warped_position_y);
2821 ImBuf *ibuf,
bool disable_red,
bool disable_green,
bool disable_blue,
bool grayscale)
2823 if (!disable_red && !disable_green && !disable_blue && !grayscale) {
2830 float scale = (disable_red ? 0.0f : 0.2126f) + (disable_green ? 0.0f : 0.7152f) +
2831 (disable_blue ? 0.0f : 0.0722f);
2835 for (
int y = 0;
y < ibuf->
y;
y++) {
2836 for (
int x = 0;
x < ibuf->
x;
x++) {
2837 int pixel = ibuf->
x *
y +
x;
2840 float *rrgbf = float_data + pixel * 4;
2841 float r = disable_red ? 0.0f : rrgbf[0];
2842 float g = disable_green ? 0.0f : rrgbf[1];
2843 float b = disable_blue ? 0.0f : rrgbf[2];
2846 float gray = (0.2126f * r + 0.7152f * g + 0.0722f *
b) /
scale;
2848 rrgbf[0] = rrgbf[1] = rrgbf[2] = gray;
2857 uchar *rrgb = byte_data + pixel * 4;
2858 uchar r = disable_red ? 0 : rrgb[0];
2859 uchar g = disable_green ? 0 : rrgb[1];
2860 uchar b = disable_blue ? 0 : rrgb[2];
2863 float gray = (0.2126f * r + 0.7152f * g + 0.0722f *
b) /
scale;
2865 rrgb[0] = rrgb[1] = rrgb[2] = gray;
2944 bool inverse,
bool a_markerless,
int a_value,
bool b_markerless,
int b_value)
2946 if (a_markerless && b_markerless) {
2962 if (a_value < b_value) {
2968 if (a_value > b_value) {
3076 bool first_not_disabled_marker_framenr_set;
3091 first_not_disabled_marker_framenr_set =
false;
3092 while (i < track->markersnr) {
3099 while (i < track->markersnr) {
3102 if (marker->
framenr != prev_fra + 1) {
3109 if (!first_not_disabled_marker_framenr_set) {
3111 first_not_disabled_marker_framenr_set =
true;
3132 "tracking channel segments");
3137 while (i < track->markersnr) {
3145 while (i < track->markersnr) {
3148 if (marker->
framenr != prev_fra + 1) {
3192 "tracking dopesheet channel");
3193 channel->
track = &track;
3280 int frames, start_frame =
INT_MAX, end_frame = INT_MIN;
3281 int *per_frame_counter;
3283 int last_segment_frame;
3291 if (start_frame > end_frame) {
3296 frames = end_frame - start_frame + 1;
3303 for (
int i = 0; i < track.
markersnr; i++) {
3308 per_frame_counter[marker->
framenr - start_frame]++;
3315 last_segment_frame = start_frame;
3318 if (!per_frame_counter[0]) {
3322 for (
int i = 1; i < frames; i++) {
3326 if (i == frames - 1 && !per_frame_counter[i]) {
3330 if (coverage != prev_coverage || i == frames - 1) {
3332 int end_segment_frame = i - 1 + start_frame;
3334 if (end_segment_frame == last_segment_frame) {
3335 end_segment_frame++;
3338 coverage_segment = MEM_new<MovieTrackingDopesheetCoverageSegment>(
3339 "tracking coverage segment");
3340 coverage_segment->
coverage = prev_coverage;
3341 coverage_segment->
start_frame = last_segment_frame;
3342 coverage_segment->
end_frame = end_segment_frame;
3346 last_segment_frame = end_segment_frame;
3349 prev_coverage = coverage;
3352 MEM_delete(per_frame_counter);
3359 dopesheet->
ok =
false;
3369 if (dopesheet->
ok) {
3382 dopesheet->
ok =
true;
3390 return &tracking_object;
3401 return &tracking_object;
3410 size_t rna_path_maxncpy)
3415 if (tracking_object ==
nullptr) {
3419 char object_name_esc[
MAX_NAME * 2];
3423 "tracking.objects[\"%s\"].tracks[\"%s\"]",
3432 size_t rna_path_maxncpy)
3435 if (tracking_object ==
nullptr) {
3439 char object_name_esc[
MAX_NAME * 2];
3448 size_t rna_path_maxncpy)
3454 if (tracking_object ==
nullptr) {
3458 char object_name_esc[
MAX_NAME * 2];
3462 "tracking.objects[\"%s\"].plane_tracks[\"%s\"]",
3471 size_t rna_path_maxncpy)
3475 if (tracking_object ==
nullptr) {
3479 char object_name_esc[
MAX_NAME * 2];
3482 rna_path, rna_path_maxncpy,
"tracking.objects[\"%s\"].plane_tracks", object_name_esc);
General operations, lookup, etc. for blender objects.
#define TRACK_SELECTED(track)
#define SNPRINTF_UTF8(dst, format,...)
#define STRNCPY_UTF8(dst, src)
#define CTX_DATA_(context, msgid)
#define BLT_I18NCONTEXT_ID_MOVIECLIP
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define INIT_MINMAX2(min, max)
#define BLI_assert_unreachable()
#define BLI_assert_msg(a, msg)
#define MEM_realloc_uninitialized(vmemh, len)
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
IndexRange index_range() const
MatBase< C, R > inverse(MatBase< C, R >) RET
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
float3x3 scale(float3x3 mat, float2 scale)
void libmv_cameraIntrinsicsUndistortFloat(const libmv_CameraIntrinsics *libmv_intrinsics, const float *source_image, int width, int height, float overscan, int channels, float *destination_image)
void libmv_cameraIntrinsicsDestroy(libmv_CameraIntrinsics *libmv_intrinsics)
libmv_CameraIntrinsics * libmv_cameraIntrinsicsCopy(const libmv_CameraIntrinsics *libmv_intrinsics)
void libmv_cameraIntrinsicsUndistortByte(const libmv_CameraIntrinsics *libmv_intrinsics, const unsigned char *source_image, int width, int height, float overscan, int channels, unsigned char *destination_image)
void libmv_cameraIntrinsicsDistortByte(const struct libmv_CameraIntrinsics *libmv_intrinsics, const unsigned char *source_image, int width, int height, float overscan, int channels, unsigned char *destination_image)
void libmv_cameraIntrinsicsApply(const struct libmv_CameraIntrinsics *libmv_intrinsics, double x, double y, double *x1, double *y1)
void libmv_cameraIntrinsicsDistortFloat(const libmv_CameraIntrinsics *libmv_intrinsics, float *source_image, int width, int height, float overscan, int channels, float *destination_image)
void libmv_cameraIntrinsicsUpdate(const libmv_CameraIntrinsicsOptions *libmv_camera_intrinsics_options, libmv_CameraIntrinsics *libmv_intrinsics)
void libmv_cameraIntrinsicsInvert(const struct libmv_CameraIntrinsics *libmv_intrinsics, double x, double y, double *x1, double *y1)
libmv_CameraIntrinsics * libmv_cameraIntrinsicsNew(const libmv_CameraIntrinsicsOptions *libmv_camera_intrinsics_options)
struct libmv_CameraIntrinsics libmv_CameraIntrinsics
void libmv_samplePlanarPatchFloat(const float *image, int width, int height, int channels, const double *xs, const double *ys, int num_samples_x, int num_samples_y, const float *mask, float *patch, double *warped_position_x, double *warped_position_y)
void libmv_samplePlanarPatchByte(const unsigned char *image, int width, int height, int channels, const double *xs, const double *ys, int num_samples_x, int num_samples_y, const float *mask, unsigned char *patch, double *warped_position_x, double *warped_position_y)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
MINLINE float min_ff(float a, float b)
void BKE_tracking_plane_tracks_replace_point_track(MovieTracking *tracking, MovieTrackingTrack *old_track, MovieTrackingTrack *new_track)
float * tracking_track_get_mask_for_region(const int frame_width, const int frame_height, const float region_min[2], const float region_max[2], const MovieTrackingTrack *track)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BKE_tracking_track_unique_name(ListBaseT< MovieTrackingTrack > *tracksbase, MovieTrackingTrack *track)
int char char int BLI_strcasecmp(const char *s1, const char *s2) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
size_t size_t size_t BLI_snprintf_utf8(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
void BKE_tracking_track_path_clear(MovieTrackingTrack *track, int ref_frame, eTrackClearAction action)
MovieTrackingMarker * BKE_tracking_marker_get_exact(MovieTrackingTrack *track, int framenr)
MovieDistortion * BKE_tracking_distortion_copy(MovieDistortion *distortion)
unsigned __int64 uint64_t
static void tracking_dopesheet_channels_calc(MovieTracking *tracking)
static int channels_average_error_sort(const void *a, const void *b)
void BKE_tracking_tracks_first_last_frame_minmax(MovieTrackingTrack **tracks, int num_tracks, int *r_first_frame, int *r_last_frame)
bool BKE_tracking_camera_distortion_equal(const MovieTrackingCamera *a, const MovieTrackingCamera *b)
static void tracking_plane_tracks_copy(TrackingCopyContext *ctx, ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_list_dst, const ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_list_src, const int flag)
void IMB_free_byte_pixels(ImBuf *ibuf)
@ TRACK_ALGORITHM_FLAG_USE_BRUTE
void BKE_tracking_get_projection_matrix(MovieTracking *tracking, MovieTrackingObject *tracking_object, int framenr, int winx, int winy, float mat[4][4])
void BKE_tracking_marker_clamp_search_size(MovieTrackingMarker *marker)
void BKE_tracking_copy(MovieTracking *tracking_dst, const MovieTracking *tracking_src, int flag)
void BKE_tracking_camera_principal_point_pixel_get(MovieClip *clip, float r_principal_point_pixel[2])
void BKE_tracking_camera_shift_get(MovieTracking *tracking, int winx, int winy, float *shiftx, float *shifty)
void BKE_movieclip_get_size(MovieClip *clip, const MovieClipUser *user, int *r_width, int *r_height)
static void tracking_objects_copy(ListBaseT< MovieTrackingObject > *tracking_objects_dst, const ListBaseT< MovieTrackingObject > *tracking_objects_src, const int flag)
void BKE_tracking_distortion_distort_v2(MovieDistortion *distortion, const float co[2], float r_co[2])
static void path_clear_all(MovieTrackingTrack *track, const int ref_frame)
@ TRACK_PREVIEW_GRAYSCALE
void BKE_tracking_marker_get_subframe_position(MovieTrackingTrack *track, float framenr, float pos[2])
static int channels_start_sort(const void *a, const void *b)
void BKE_tracking_distortion_undistort_v2(MovieDistortion *distortion, const float co[2], float r_co[2])
void tracking_get_search_origin_frame_pixel(int frame_width, int frame_height, const MovieTrackingMarker *marker, float frame_pixel[2])
MovieTrackingObject * BKE_tracking_object_add(MovieTracking *tracking, const char *name)
void BKE_tracking_plane_track_replace_point_track(MovieTrackingPlaneTrack *plane_track, MovieTrackingTrack *old_track, MovieTrackingTrack *new_track)
void tracking_marker_insert_disabled(MovieTrackingTrack *track, const MovieTrackingMarker *ref_marker, bool before, bool overwrite)
bool BKE_tracking_plane_track_has_point_track(MovieTrackingPlaneTrack *plane_track, MovieTrackingTrack *track)
void BKE_tracking_plane_tracks_remove_point_track(MovieTracking *tracking, MovieTrackingTrack *track)
MINLINE void mul_v2_fl(float r[2], float f)
MINLINE void negate_v2_v2(float r[2], const float a[2])
MINLINE void copy_v2_v2(float r[2], const float a[2])
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
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)
static void tracking_dopesheet_free(MovieTrackingDopesheet *dopesheet)
static int channels_total_track_inverse_sort(const void *a, const void *b)
@ TRACKING_DISTORTION_MODEL_DIVISION
@ TRACKING_DISTORTION_MODEL_POLYNOMIAL
@ TRACKING_DISTORTION_MODEL_NUKE
@ TRACKING_DISTORTION_MODEL_BROWN
ImBuf * BKE_tracking_undistort_frame(MovieTracking *tracking, ImBuf *ibuf, int calibration_width, int calibration_height, float overscan)
BLI_INLINE int plane_marker_size_len_in_pixels(const float a[2], const float b[2], const int frame_width, const int frame_height)
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
ImBuf * BKE_tracking_get_search_imbuf(const ImBuf *ibuf, const MovieTrackingTrack *track, const MovieTrackingMarker *marker, bool anchored, bool disable_channels)
static int reconstructed_camera_index_get(MovieTrackingReconstruction *reconstruction, int framenr, bool nearest)
char * BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
MovieTrackingTrack * BKE_tracking_track_add(MovieTracking *tracking, ListBaseT< MovieTrackingTrack > *tracksbase, float x, float y, int framenr, int width, int height)
static int channels_start_inverse_sort(const void *a, const void *b)
void blend_m4_m4m4(float out[4][4], const float dst[4][4], const float src[4][4], float srcweight)
static void tracking_dopesheet_calc_coverage(MovieTracking *tracking)
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
static void tracking_average_markers(MovieTrackingTrack *dst_track, MovieTrackingTrack **src_tracks, const int num_src_tracks)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
void BKE_tracking_tracks_join(MovieTracking *tracking, MovieTrackingTrack *dst_track, MovieTrackingTrack *src_track)
MINLINE int max_ii(int a, int b)
ImBuf * BKE_tracking_get_plane_imbuf(const ImBuf *frame_ibuf, const MovieTrackingPlaneMarker *plane_marker)
static void tracking_objects_free(ListBaseT< MovieTrackingObject > *objects)
void BKE_tracking_plane_tracks_deselect_all(ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base)
static void tracking_copy_context_delete(TrackingCopyContext *ctx)
static void path_clear_remained(MovieTrackingTrack *track, const int ref_frame)
void perspective_m4(float mat[4][4], float left, float right, float bottom, float top, float nearClip, float farClip)
ImBuf * BKE_tracking_distort_frame(MovieTracking *tracking, ImBuf *ibuf, int calibration_width, int calibration_height, float overscan)
@ LIB_ID_CREATE_NO_USER_REFCOUNT
ImBuf * IMB_dupImBuf(const ImBuf *ibuf1)
MovieTrackingMarker * BKE_tracking_marker_insert(MovieTrackingTrack *track, MovieTrackingMarker *marker)
static void multiply_marker(MovieTrackingMarker *marker, const float multiplier)
static void tracking_plane_tracks_free(ListBaseT< MovieTrackingPlaneTrack > *plane_tracks)
MINLINE bool is_finite_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
bool BKE_tracking_track_has_enabled_marker_at_frame(MovieTrackingTrack *track, int framenr)
void BKE_tracking_dopesheet_tag_update(MovieTracking *tracking)
static int channels_alpha_sort(const void *a, const void *b)
static void tracking_average_tracks(MovieTrackingTrack *dst_track, MovieTrackingTrack **src_tracks, const int num_src_tracks)
void BKE_tracking_plane_marker_get_subframe_corners(MovieTrackingPlaneTrack *plane_track, float framenr, float corners[4][2])
void tracking_principal_point_normalized_to_pixel(const float principal_point_normalized[2], int frame_width, int frame_height, float r_principal_point_pixel[2])
VecBase< float, 4 > float4
static TrackingCoverage coverage_from_count(int count)
MovieTrackingObject * BKE_tracking_find_object_for_plane_track(const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track)
static int channels_alpha_inverse_sort(const void *a, const void *b)
void BKE_tracking_get_rna_path_for_plane_track(const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track, char *rna_path, size_t rna_path_maxncpy)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void BKE_tracking_marker_pattern_minmax(const MovieTrackingMarker *marker, float min[2], float max[2])
bool BKE_tracking_track_has_marker_at_frame(MovieTrackingTrack *track, int framenr)
void BKE_tracking_get_rna_path_for_track(const MovieTracking *tracking, const MovieTrackingTrack *track, char *rna_path, size_t rna_path_maxncpy)
void BLI_uniquename(const ListBase *list, void *vlink, const char *defname, char delim, int name_offset, size_t name_maxncpy) ATTR_NONNULL(1
static struct blender::@154371266026044376204133125047312012320164166140 tracking_clipboard
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void BKE_tracking_marker_clamp_pattern_position(MovieTrackingMarker *marker)
bool BKE_tracking_clipboard_has_tracks()
MovieTrackingTrack * BKE_tracking_track_get_for_selection_index(MovieTracking *tracking, int selection_index, ListBaseT< MovieTrackingTrack > **r_tracksbase)
@ TRACKING_COVERAGE_ACCEPTABLE
void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *tracking_object)
static bGPDlayer * track_mask_gpencil_layer_get(const MovieTrackingTrack *track)
void tracking_cameraIntrinscisOptionsFromTracking(MovieTracking *tracking, int calibration_width, int calibration_height, libmv_CameraIntrinsicsOptions *camera_intrinsics_options)
static int channels_longest_segment_sort(const void *a, const void *b)
void IMB_freeImBuf(ImBuf *ibuf)
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
static void track_mask_gpencil_layer_rasterize(const int frame_width, const int frame_height, const float region_min[2], const bGPDlayer *layer, float *mask, const int mask_width, const int mask_height)
static const MovieTrackingMarker * get_usable_marker_for_interpolation(MovieTrackingTrack *track, const MovieTrackingMarker *anchor_marker, const int direction)
bool BKE_tracking_marker_get_interpolated(MovieTrackingTrack *track, int framenr, MovieTrackingMarker *r_marker)
void BKE_tracking_disable_channels(ImBuf *ibuf, bool disable_red, bool disable_green, bool disable_blue, bool grayscale)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
@ TRACKING_DOPE_SORT_TOTAL
@ TRACKING_DOPE_SORT_AVERAGE_ERROR
@ TRACKING_DOPE_SORT_LONGEST
@ TRACKING_DOPE_SORT_START
@ TRACKING_DOPE_SORT_NAME
MINLINE void add_v2_v2(float r[2], const float a[2])
MovieTrackingPlaneTrack * BKE_tracking_object_find_plane_track_with_name(MovieTrackingObject *tracking_object, const char *name)
void BKE_tracking_undistort_v2(MovieTracking *tracking, int image_width, int image_height, const float co[2], float r_co[2])
void minmax_v2v2_v2(float min[2], float max[2], const float vec[2])
MovieTrackingMarker * BKE_tracking_marker_ensure(MovieTrackingTrack *track, int framenr)
BMesh const char void * data
int BKE_tracking_count_selected_tracks_in_list(const ListBaseT< MovieTrackingTrack > *tracks_list)
void BLI_bitmap_draw_2d_poly_v2i_n(int xmin, int ymin, int xmax, int ymax, Span< int2 > verts, void(*callback)(int x, int x_end, int y, void *), void *user_data)
MovieTrackingTrack * BKE_tracking_object_find_track_with_name(MovieTrackingObject *tracking_object, const char *name)
void BKE_tracking_clipboard_free()
void BKE_tracking_clipboard_paste_tracks(MovieTracking *tracking, MovieTrackingObject *tracking_object)
static void tracking_stabilization_copy(MovieTrackingStabilization *stabilization_dst, const MovieTrackingStabilization *stabilization_src, const int)
MovieTrackingTrack ** BKE_tracking_selected_tracks_in_active_object(MovieTracking *tracking, int *r_num_tracks)
static TrackingCopyContext tracking_copy_context_new()
MovieTrackingTrack * BKE_tracking_track_add_empty(MovieTracking *tracking, ListBaseT< MovieTrackingTrack > *tracks_list)
static int channels_total_track_sort(const void *a, const void *b)
void BKE_tracking_camera_get_reconstructed_interpolate(MovieTracking *tracking, MovieTrackingObject *tracking_object, float framenr, float mat[4][4])
char char size_t BLI_str_escape(char *__restrict dst, StringRef src, size_t dst_maxncpy) ATTR_NONNULL(1)
MovieTrackingObject * BKE_tracking_object_get_camera(const MovieTracking *tracking)
static void tracking_dopesheet_channels_sort(MovieTracking *tracking, TrackingDopesheetSort sort_method, bool inverse)
void BKE_tracking_track_first_last_frame_get(const MovieTrackingTrack *track, int *r_first_frame, int *r_last_frame)
void BKE_object_where_is_calc_mat4(const Object *ob, float r_obmat[4][4])
static void accumulate_marker(MovieTrackingMarker *dst_marker, const MovieTrackingMarker *src_marker)
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void BKE_tracking_settings_init(MovieTracking *tracking)
ImBuf * BKE_tracking_distortion_exec(MovieDistortion *distortion, MovieTracking *tracking, ImBuf *ibuf, int width, int height, float overscan, bool undistort)
struct MovieReconstructedCamera * BKE_tracking_camera_get_reconstructed(MovieTracking *tracking, MovieTrackingObject *tracking_object, int framenr)
float * BKE_tracking_track_get_mask(int frame_width, int frame_height, const MovieTrackingTrack *track, const MovieTrackingMarker *marker)
void unit_m4(float m[4][4])
void BKE_tracking_clipboard_copy_tracks(MovieTracking *tracking, MovieTrackingObject *tracking_object)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_ensure(MovieTrackingPlaneTrack *plane_track, int framenr)
@ TRACKING_SHOW_STAB_TRACKS
static void tracking_object_copy(MovieTrackingObject *tracking_object_dst, const MovieTrackingObject *tracking_object_src, const int flag)
static void tracking_reconstruction_free(MovieTrackingReconstruction *reconstruction)
static int channels_end_sort(const void *a, const void *b)
void BKE_tracking_tracks_average(MovieTrackingTrack *dst_track, MovieTrackingTrack **src_tracks, int num_src_tracks)
void BKE_tracking_get_rna_path_prefix_for_track(const MovieTracking *tracking, const MovieTrackingTrack *track, char *rna_path, size_t rna_path_maxncpy)
void BKE_tracking_marker_clamp_search_position(MovieTrackingMarker *marker)
MINLINE bool equals_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
int BKE_tracking_count_selected_tracks_in_active_object(MovieTracking *tracking)
void BKE_tracking_tracks_deselect_all(ListBaseT< MovieTrackingTrack > *tracksbase)
void void BLI_listbase_sort(ListBase *listbase, int(*cmp)(const void *, const void *)) ATTR_NONNULL(1
ImBuf * IMB_allocImBuf(unsigned int x, unsigned int y, ImBufFlags flags)
void BKE_tracking_marker_delete(MovieTrackingTrack *track, int framenr)
void BKE_tracking_track_free(MovieTrackingTrack *track)
void BKE_tracking_distortion_update(MovieDistortion *distortion, MovieTracking *tracking, int calibration_width, int calibration_height)
MovieTrackingTrack * BKE_tracking_track_duplicate(MovieTrackingTrack *track)
void BKE_tracking_free(MovieTracking *tracking)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
MovieDistortion * BKE_tracking_distortion_new(MovieTracking *tracking, int calibration_width, int calibration_height)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get_exact(MovieTrackingPlaneTrack *plane_track, int framenr)
void BKE_tracking_plane_track_free(MovieTrackingPlaneTrack *plane_track)
void interp_v2_v2v2(float r[2], const float a[2], const float b[2], float t)
MINLINE float max_ff(float a, float b)
void BKE_tracking_camera_to_blender(MovieTracking *tracking, Scene *scene, Camera *camera, int width, int height)
void BKE_tracking_distortion_free(MovieDistortion *distortion)
MINLINE float len_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
bool BKE_tracking_plane_track_remove_point_track(MovieTrackingPlaneTrack *plane_track, MovieTrackingTrack *track)
static void disable_imbuf_channels(ImBuf *ibuf, const MovieTrackingTrack *track, const bool grayscale)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get(MovieTrackingPlaneTrack *plane_track, int framenr)
void BKE_tracking_plane_marker_delete(MovieTrackingPlaneTrack *plane_track, int framenr)
MovieTrackingObject * BKE_tracking_find_object_for_track(const MovieTracking *tracking, const MovieTrackingTrack *track)
MovieTrackingPlaneTrack * BKE_tracking_plane_track_add(MovieTracking *tracking, ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base, ListBaseT< MovieTrackingTrack > *tracks, int framenr)
FCurve * id_data_find_fcurve(ID *id, void *data, StructRNA *type, const char *prop_name, int index, bool *r_driven)
static void tracking_dopesheet_channels_segments_calc(MovieTrackingDopesheetChannel *channel)
uint64_t BKE_tracking_camera_distortion_hash(const MovieTrackingCamera *camera)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_insert(MovieTrackingPlaneTrack *plane_track, MovieTrackingPlaneMarker *plane_marker)
@ TRACK_MOTION_MODEL_TRANSLATION
float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
MovieTrackingObject * BKE_tracking_object_get_named(MovieTracking *tracking, const char *name)
void BKE_tracking_track_flag_set(MovieTrackingTrack *track, eTrackArea area, TrackingTrackFlag flag)
static void track_mask_set_pixel_cb(int x, int x_end, int y, void *user_data)
void BKE_tracking_get_camera_object_matrix(const Object *camera_object, float mat[4][4])
void BKE_tracking_plane_track_unique_name(ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base, MovieTrackingPlaneTrack *plane_track)
void BKE_tracking_track_deselect(MovieTrackingTrack *track, eTrackArea area)
@ TRACKING_DOPE_SELECTED_ONLY
@ TRACKING_DOPE_SORT_INVERSE
@ TRACKING_DOPE_SHOW_HIDDEN
static void path_clear_up_to(MovieTrackingTrack *track, const int ref_frame)
void copy_m4_m4(float m1[4][4], const float m2[4][4])
static int compare_firstlast_putting_undefined_first(bool inverse, bool a_markerless, int a_value, bool b_markerless, int b_value)
static void reconstructed_camera_scale_set(const MovieTrackingObject *tracking_object, float mat[4][4])
VecBase< float, 3 > float3
void scale_m4_fl(float R[4][4], float scale)
float BKE_tracking_track_get_weight_for_marker(MovieClip *clip, MovieTrackingTrack *track, MovieTrackingMarker *marker)
@ TRACKING_FILTER_BILINEAR
static int channels_end_inverse_sort(const void *a, const void *b)
ImBuf * BKE_tracking_sample_pattern(int frame_width, int frame_height, const ImBuf *search_ib, const MovieTrackingTrack *track, const MovieTrackingMarker *marker, bool from_anchor, bool use_mask, int num_samples_x, int num_samples_y, float pos[2])
void tracking_principal_point_pixel_to_normalized(const float principal_point_pixel[2], int frame_width, int frame_height, float r_principal_point_normalized[2])
MINLINE int min_ii(int a, int b)
MINLINE int clamp_i(int value, int min, int max)
ImBuf * BKE_tracking_get_pattern_imbuf(const ImBuf *ibuf, const MovieTrackingTrack *track, const MovieTrackingMarker *marker, bool anchored, bool disable_channels)
static void tracking_reconstruction_copy(TrackingCopyContext *, MovieTrackingReconstruction *reconstruction_dst, const MovieTrackingReconstruction *reconstruction_src, const int)
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
MINLINE void zero_v2(float r[2])
static void tracking_tracks_free(ListBaseT< MovieTrackingTrack > *tracks)
void BKE_tracking_camera_principal_point_pixel_set(MovieClip *clip, const float principal_point_pixel[2])
static int channels_longest_segment_inverse_sort(const void *a, const void *b)
void BKE_tracking_dopesheet_update(MovieTracking *tracking)
void tracking_get_marker_coords_for_tracking(int frame_width, int frame_height, const MovieTrackingMarker *marker, double search_pixel_x[5], double search_pixel_y[5])
void BKE_tracking_distort_v2(MovieTracking *tracking, int image_width, int image_height, const float co[2], float r_co[2])
static void tracking_tracks_copy(TrackingCopyContext *ctx, ListBaseT< MovieTrackingTrack > *tracks_dst, const ListBaseT< MovieTrackingTrack > *tracks_src, const int flag)
static void tracking_object_free(MovieTrackingObject *tracking_object)
void BKE_tracking_track_flag_clear(MovieTrackingTrack *track, eTrackArea area, TrackingTrackFlag flag)
static int channels_average_error_inverse_sort(const void *a, const void *b)
void BKE_tracking_track_select(ListBaseT< MovieTrackingTrack > *tracksbase, MovieTrackingTrack *track, eTrackArea area, bool extend)
bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *tracking_object)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void IMB_copy_rect(float *dst, const int2 &dst_size, const float *src, const int2 &src_size, int channels, const int2 &src_rect_pos, const int2 &dst_rect_pos, const int2 &rect_size)
float evaluate_fcurve(const FCurve *fcu, float evaltime)
MovieTrackingMarker * BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
const ColorSpace * colorspace
const ColorSpace * colorspace
ImBufFloatBuffer float_buffer
ImBufByteBuffer byte_buffer
const uint8_t * byte_data() const
uint8_t * byte_data_for_write()
const float * float_data() const
float * float_data_for_write()
struct MovieTracking tracking
libmv_CameraIntrinsics * intrinsics
TrackingCameraUnits units
TrackingDistortionModel distortion_model
int first_not_disabled_marker_framenr
int last_not_disabled_marker_framenr
MovieTrackingTrack * track
struct MovieTrackingDopesheetChannel * next
TrackingCoverage coverage
ListBaseT< MovieTrackingDopesheetCoverageSegment > coverage_segments
ListBaseT< MovieTrackingDopesheetChannel > channels
TrackingDopesheetFlag flag
TrackingDopesheetSort sort_method
float pattern_corners[4][2]
MovieTrackingPlaneTrack * active_plane_track
MovieTrackingReconstruction reconstruction
ListBaseT< MovieTrackingTrack > tracks
ListBaseT< MovieTrackingPlaneTrack > plane_tracks
MovieTrackingTrack * active_track
TrackingPlaneMarkerFlag flag
MovieTrackingTrack ** point_tracks
MovieTrackingPlaneMarker * markers
struct MovieReconstructedCamera * cameras
TrackingReconstructionFlag flag
TrackingMotionModel default_motion_model
TrackingRefineCameraFlag refine_camera_intrinsics
float default_minimum_correlation
eTrackFrameMatch default_pattern_match
TrackingTrackFlag default_flag
short default_frames_limit
short default_pattern_size
short default_search_size
TrackingAlgorithmFlag default_algorithm_flag
TrackingStabilizationFlag flag
TrackingStabilizationFilter filter
struct MovieTrackingTrack * next
TrackingMotionModel motion_model
struct MovieTrackingTrack * prev
float minimum_correlation
MovieTrackingMarker * markers
TrackingAlgorithmFlag algorithm_flag
TrackingTrackFlag search_flag
TrackingTrackFlag pat_flag
eTrackFrameMatch pattern_match
MovieTrackingStats * stats
MovieTrackingCamera camera
MovieTrackingStabilization stabilization
MovieTrackingSettings settings
ListBaseT< MovieTrackingObject > objects
MovieTrackingDopesheet dopesheet
Map< MovieTrackingTrack *, MovieTrackingTrack * > * old_to_new_track_map
Map< MovieTrackingPlaneTrack *, MovieTrackingPlaneTrack * > * old_to_new_plane_track_map
ListBaseT< MovieTrackingTrack > tracks
ListBaseT< bGPDstroke > strokes
ListBaseT< bGPDlayer > layers