15#include "RNA_prototypes.hh"
119 if (val !=
nullptr) {
130 RNA_MovieTrackingStabilization,
150 return default_value;
197 if (ctx !=
nullptr) {
211 ctx->
private_track_data = MEM_new<Map<MovieTrackingTrack *, TrackStabilizationBase *>>(
212 "2D stabilization per track private working data");
234 if (ctx !=
nullptr) {
265 return marker - track->
markers;
280 if (i < end && markers[i].framenr < *next_higher) {
282 *next_higher = markers[i].
framenr;
296 if (0 <= i && markers[i].framenr > *next_lower) {
298 *next_lower = markers[i].
framenr;
335 if ((next_higher - ref_frame) < (ref_frame - next_lower)) {
402 float result_offset[2])
447 const float pivot[2],
458 *result_angle =
atan2f(pos[1], pos[0]);
485 const float pivot[2],
486 float result_translation[2])
488 const float origin[2] = {0.5f * aspect * size, 0.5f * size};
489 float intended_pivot[2], rotated_pivot[2];
490 float rotation_mat[2][2];
499 add_v2_v2(result_translation, intended_pivot);
500 sub_v2_v2(result_translation, rotated_pivot);
518 float r_translation[2],
532 *r_scale_step = 0.0f;
551 weight_sum += weight;
553 r_translation[0] += weight * offset[0];
554 r_translation[1] += weight * offset[1];
555 ref_pos[0] += weight * marker->
pos[0];
556 ref_pos[1] += weight * marker->
pos[1];
565 ref_pos[0] /= weight_sum;
566 ref_pos[1] /= weight_sum;
567 r_translation[0] /= weight_sum;
568 r_translation[1] /= weight_sum;
588 float rotation,
scale, quality;
590 stabilization_base, marker, aspect, r_pivot, &rotation, &
scale);
591 const float quality_weight = weight * quality;
592 weight_sum += quality_weight;
593 *r_angle += rotation * quality_weight;
595 *r_scale_step +=
logf(
scale) * quality_weight;
608 *r_scale_step /= weight_sum;
609 *r_angle /= weight_sum;
615 *r_scale_step = 0.0f;
641 weight_sum += weight;
642 r_ref_pos[0] += weight * marker->
pos[0];
643 r_ref_pos[1] += weight * marker->
pos[1];
649 r_ref_pos[0] /= weight_sum;
650 r_ref_pos[1] /= weight_sum;
695 float r_translation[2],
701 float trans_a[2], trans_b[2];
702 float angle_a, angle_b;
703 float scale_a, scale_b;
704 float pivot_a[2], pivot_b[2];
705 bool success =
false;
711 t = (
float(framenr) - frame_a) / (frame_b - frame_a);
715 ctx, frame_a, aspect, trans_a, pivot_a, &angle_a, &scale_a);
720 ctx, frame_b, aspect, trans_b, pivot_b, &angle_b, &scale_b);
727 *r_scale_step = s * scale_a + t * scale_b;
728 *r_angle = s * angle_a + t * angle_b;
756 order[tracknr].
data = &track;
826 const float average_translation[2],
827 const float pivot[2],
828 const float average_angle,
829 const float average_scale_step)
859 size_t track_len = 0;
869 float average_angle = 0, average_scale_step = 0;
870 float average_translation[2], average_pos[2], pivot[2];
879 "2D stabilization per track baseline data");
898 if (track_len == 0) {
906 for (
int i = 0; i < track_len; i++) {
908 if (reference_frame != order[i].reference_frame) {
916 &average_scale_step);
947 float r_translation[2],
952 bool success =
false;
957 *r_scale_step = 0.0f;
963 ctx, framenr, aspect, r_translation, r_pivot, r_angle, r_scale_step);
989 ctx, next_higher, aspect, r_translation, r_pivot, r_angle, r_scale_step);
994 ctx, next_lower, aspect, r_translation, r_pivot, r_angle, r_scale_step);
1018 float r_translation[2],
1023 float target_pos[2], target_scale;
1027 *r_scale =
expf(scale_step * scaleinf);
1044 if (target_scale != 0.0f) {
1045 *r_scale /= target_scale;
1050 r_translation[0] *=
float(size) * aspect;
1051 r_translation[1] *=
float(size);
1052 r_pivot[0] *=
float(size) * aspect;
1053 r_pivot[1] *=
float(size);
1058 if (do_compensate) {
1061 if (*r_scale != 0.0f) {
1062 *r_scale = 1.0f / *r_scale;
1068 const float pivot[2],
1069 const float translation[2],
1074 float translation_mat[4][4], rotation_mat[4][4], scale_mat[4][4], pivot_mat[4][4],
1075 inv_pivot_mat[4][4], aspect_mat[4][4], inv_aspect_mat[4][4];
1076 const float scale_vector[3] = {
scale,
scale, 1.0f};
1086 aspect_mat[0][0] /= pixel_aspect;
1093 add_v2_v2(translation_mat[3], translation);
1120 int height = size, width = aspect * size;
1122 int sfra =
INT_MAX, efra = INT_MIN;
1123 float scale = 1.0f, scale_step = 0.0f;
1132 sfra =
min_ii(sfra, first_frame);
1133 efra =
max_ii(efra, last_frame);
1138 for (
int cfra = sfra; cfra <= efra; cfra++) {
1139 float translation[2], pivot[2],
angle, tmp_scale;
1141 const float points[4][2] = {
1143 const bool do_compensate =
true;
1146 ctx, cfra, aspect, translation, pivot, &
angle, &scale_step);
1166 for (
int edge_index = 0; edge_index < 4; edge_index++) {
1171 float stable_edge_p1[3], stable_edge_p2[3];
1172 copy_v2_v2(stable_edge_p1, points[edge_index]);
1173 copy_v2_v2(stable_edge_p2, points[(edge_index + 1) % 4]);
1174 stable_edge_p1[2] = stable_edge_p2[2] = 0.0f;
1181 for (
int point_index = 0; point_index < 4; point_index++) {
1182 const float point[3] = {points[point_index][0], points[point_index][1], 0.0f};
1186 float stable_edge_vec[3];
1187 sub_v3_v3v3(stable_edge_vec, stable_edge_p2, stable_edge_p1);
1191 float point_to_edge_start_vec[3];
1192 sub_v3_v3v3(point_to_edge_start_vec, point, stable_edge_p1);
1198 if (
cross_v2v2(stable_edge_vec, point_to_edge_start_vec) >= 0.0f) {
1200 float scale_pivot[2];
1216 float real_dist =
dist_to_line_v2(scale_pivot, stable_edge_p1, stable_edge_p2);
1218 const float S = required_dist / real_dist;
1260 float translation[2],
1268 bool do_compensate =
true;
1269 float scale_step = 0.0f;
1271 float aspect =
float(width) * pixel_aspect / height;
1280 ctx, framenr, aspect, translation, pivot,
angle, &scale_step))
1283 ctx, framenr, size, aspect, do_compensate, scale_step, translation, pivot,
scale,
angle);
1311 float vec[3] = {0.0f,
float(
y), 0.0f};
1318 for (
int x = 0;
x < tmpibuf->
x;
x++, dst++) {
1325 for (
int x = 0;
x < tmpibuf->
x;
x++, dst++) {
1333 for (
int x = 0;
x < tmpibuf->
x;
x++, dst++) {
1344 for (
int x = 0;
x < tmpibuf->
x;
x++, dst++) {
1351 for (
int x = 0;
x < tmpibuf->
x;
x++, dst++) {
1359 for (
int x = 0;
x < tmpibuf->
x;
x++, dst++) {
1371 float tloc[2], tscale, tangle;
1375 int width = ibuf->
x, height = ibuf->
y;
1420 ibuf->
x, ibuf->
y, pixel_aspect, tloc, tscale, tangle, mat);
1429 data.tmpibuf = tmpibuf;
1457 float translation[2],
1474 pivot[0] = 0.5f * pixel_aspect * buffer_width;
1475 pivot[1] = 0.5f * buffer_height;
#define mul_m4_series(...)
Read Blender memory allocation and freeing.
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
float3x3 scale(float3x3 mat, float2 scale)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
float4 interpolate_nearest_border_fl(const ImBuf *in, float u, float v)
uchar4 interpolate_nearest_border_byte(const ImBuf *in, float u, float v)
uchar4 interpolate_cubic_bspline_byte(const ImBuf *in, float u, float v)
float4 interpolate_cubic_bspline_fl(const ImBuf *in, float u, float v)
uchar4 interpolate_bilinear_border_byte(const ImBuf *in, float u, float v)
float4 interpolate_bilinear_border_fl(const ImBuf *in, float u, float v)
MINLINE float min_ff(float a, float b)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static float get_animated_rotinf(StabContext *ctx, int framenr)
MovieTrackingMarker * BKE_tracking_marker_get_exact(MovieTrackingTrack *track, int framenr)
VecBase< uint8_t, 4 > uchar4
static float get_animated_scaleinf(StabContext *ctx, int framenr)
static bool interpolate_averaged_track_contributions(StabContext *ctx, int framenr, int frame_a, int frame_b, const float aspect, float r_translation[2], float r_pivot[2], float *r_angle, float *r_scale_step)
static FCurve * retrieve_track_weight_animation(MovieClip *clip, MovieTrackingTrack *track)
static float get_animated_locinf(StabContext *ctx, int framenr)
BLI_INLINE void BLI_parallel_range_settings_defaults(TaskParallelSettings *settings)
MINLINE void add_v2_v2v2(float r[2], const float a[2], const float b[2])
static TrackStabilizationBase * access_stabilization_baseline_data(StabContext *ctx, MovieTrackingTrack *track)
static int establish_track_initialization_order(StabContext *ctx, TrackInitOrder *order)
MINLINE void mul_v2_fl(float r[2], float f)
MINLINE float cross_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
MINLINE void copy_v2_v2(float r[2], const float a[2])
void BKE_tracking_stabilization_data_get(MovieClip *clip, int framenr, int width, int height, float translation[2], float *scale, float *angle)
static bool stabilization_determine_offset_for_frame(StabContext *ctx, int framenr, float aspect, float r_translation[2], float r_pivot[2], float *r_angle, float *r_scale_step)
static bool is_init_for_stabilization(StabContext *ctx, MovieTrackingTrack *track)
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
static float SCALE_ERROR_LIMIT_BIAS
static void average_marker_positions(StabContext *ctx, int framenr, float r_ref_pos[2])
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
bool invert_m4(float mat[4][4])
MINLINE int max_ii(int a, int b)
void BLI_task_parallel_range(int start, int stop, void *userdata, TaskParallelRangeFunc func, const TaskParallelSettings *settings)
void BKE_tracking_stabilization_data_to_mat4(int width, int height, float aspect, float translation[2], float scale, float angle, float mat[4][4])
static float get_animated_target_scale(StabContext *ctx, int framenr)
VecBase< float, 4 > float4
static void setup_pivot(const float ref_pos[2], float r_pivot[2])
void mul_m4_v3(const float M[4][4], float r[3])
void size_to_mat4(float R[4][4], const float size[3])
static float EPSILON_WEIGHT
static float get_animated_weight(StabContext *ctx, MovieTrackingTrack *track, int framenr)
static float calculate_autoscale_factor(StabContext *ctx, int size, float aspect)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
MINLINE void add_v2_v2(float r[2], const float a[2])
static void stabilization_data_to_mat4(float pixel_aspect, const float pivot[2], const float translation[2], float scale, float angle, float r_mat[4][4])
static bool is_effectively_disabled(StabContext *ctx, MovieTrackingTrack *track, MovieTrackingMarker *marker)
BMesh const char void * data
float dist_to_line_v2(const float p[2], const float l1[2], const float l2[2])
MovieTrackingObject * BKE_tracking_object_get_camera(const MovieTracking *tracking)
static void stabilization_calculate_data(StabContext *ctx, int framenr, int size, float aspect, bool do_compensate, float scale_step, float r_translation[2], float r_pivot[2], float *r_scale, float *r_angle)
static float get_animated_target_rot(StabContext *ctx, int framenr)
static bool average_track_contributions(StabContext *ctx, int framenr, float aspect, float r_translation[2], float r_pivot[2], float *r_angle, float *r_scale_step)
static void use_values_from_fcurves(StabContext *ctx, bool toggle)
void unit_m4(float m[4][4])
static StabContext * init_stabilization_working_context(MovieClip *clip)
@ TRACKING_STABILIZE_ROTATION
@ TRACKING_STABILIZE_SCALE
@ TRACKING_2D_STABILIZATION
static MovieTrackingMarker * get_tracking_data_point(StabContext *ctx, MovieTrackingTrack *track, int framenr, float *r_weight)
void mul_m2_v2(const float mat[2][2], float vec[2])
void angle_to_mat2(float R[2][2], float angle)
static void tracking_stabilize_frame_interpolation_cb(void *__restrict userdata, const int y, const TaskParallelTLS *__restrict)
static void discard_stabilization_working_context(StabContext *ctx)
ImBuf * IMB_allocImBuf(unsigned int x, unsigned int y, ImBufFlags flags)
static float fetch_from_fcurve(const FCurve *animationCurve, int framenr, StabContext *ctx, float default_value)
static void discard_stabilization_baseline_data(TrackStabilizationBase *val)
static void init_track_for_stabilization(StabContext *ctx, MovieTrackingTrack *track, int reference_frame, float aspect, const float average_translation[2], const float pivot[2], const float average_angle, const float average_scale_step)
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
static void translation_contribution(TrackStabilizationBase *track_ref, MovieTrackingMarker *marker, float result_offset[2])
void rotate_m4(float mat[4][4], char axis, float angle)
void interp_v2_v2v2(float r[2], const float a[2], const float b[2], float t)
static FCurve * retrieve_stab_animation(MovieClip *clip, const char *data_path, int idx)
MINLINE float max_ff(float a, float b)
static void attach_stabilization_baseline_data(StabContext *ctx, MovieTrackingTrack *track, TrackStabilizationBase *private_data)
FCurve * id_data_find_fcurve(ID *id, void *data, StructRNA *type, const char *prop_name, int index, bool *r_driven)
static void get_animated_target_pos(StabContext *ctx, int framenr, float target_pos[2])
static bool is_usable_for_stabilization(StabContext *ctx, MovieTrackingTrack *track)
ImBuf * BKE_tracking_stabilize_frame(MovieClip *clip, int framenr, ImBuf *ibuf, float translation[2], float *scale, float *angle)
static StabContext * init_stabilizer(MovieClip *clip, int size, float aspect)
static MovieTrackingMarker * get_closest_marker(StabContext *ctx, MovieTrackingTrack *track, int ref_frame)
float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
int BLI_sortutil_cmp_int(const void *a_, const void *b_)
MINLINE void sub_v2_v2(float r[2], const float a[2])
static void find_next_working_frames(StabContext *ctx, int framenr, int *next_lower, int *next_higher)
MINLINE float len_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
TrackingStabilizationFilter
@ TRACKING_FILTER_BILINEAR
@ TRACKING_FILTER_BICUBIC
static void retrieve_next_lower_usable_frame(StabContext *ctx, MovieTrackingTrack *track, int i, int ref_frame, int *next_lower)
MINLINE int min_ii(int a, int b)
static void compensate_rotation_center(const int size, float aspect, const float angle, const float scale, const float pivot[2], float result_translation[2])
static float rotation_contribution(TrackStabilizationBase *track_ref, MovieTrackingMarker *marker, const float aspect, const float pivot[2], float *result_angle, float *result_scale)
MINLINE void zero_v2(float r[2])
static int search_closest_marker_index(MovieTrackingTrack *track, int ref_frame)
static void retrieve_next_higher_usable_frame(StabContext *ctx, MovieTrackingTrack *track, int i, int ref_frame, int *next_higher)
void IMB_colormanagement_copy_settings(ImBuf *ibuf_src, ImBuf *ibuf_dst)
static void init_all_tracks(StabContext *ctx, float aspect)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
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 uint8_t * byte_data() const
uint8_t * byte_data_for_write()
const float * float_data() const
float * float_data_for_write()
struct MovieTracking tracking
ListBaseT< MovieTrackingTrack > tracks
TrackingStabilizationFlag flag
TrackingStabilizationFilter filter
MovieTrackingMarker * markers
MovieTrackingCamera camera
MovieTrackingStabilization stabilization
Map< MovieTrackingTrack *, TrackStabilizationBase * > * private_track_data
MovieTrackingStabilization * stab
MovieTrackingTrack * data
float stabilization_rotation_base[2][2]
bool is_init_for_stabilization
float stabilization_offset_base[2]
float stabilization_scale_base
FCurve * track_weight_curve
TrackingStabilizationFilter tracking_filter