Blender V5.3
tracking_plane_tracker.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
10
11#include "MEM_guardedalloc.h"
12
13#include "DNA_tracking_types.h"
14
15#include "BLI_math_matrix_c.hh"
16#include "BLI_math_vector_c.hh"
17
18#include "BKE_tracking.hh"
19
20#include "libmv-capi.h"
21
22namespace blender {
23
24typedef double Vec2[2];
25
27 MovieTrackingPlaneTrack *plane_track, int frame1, int frame2, Vec2 **r_x1, Vec2 **r_x2)
28{
29 Vec2 *x1, *x2;
30
31 *r_x1 = x1 = MEM_new_array_zeroed<Vec2>(plane_track->point_tracksnr, "point correspondences x1");
32 *r_x2 = x2 = MEM_new_array_zeroed<Vec2>(plane_track->point_tracksnr, "point correspondences x2");
33
34 int correspondence_index = 0;
35 for (int i = 0; i < plane_track->point_tracksnr; i++) {
36 MovieTrackingTrack *point_track = plane_track->point_tracks[i];
37 MovieTrackingMarker *point_marker1, *point_marker2;
38
39 point_marker1 = BKE_tracking_marker_get_exact(point_track, frame1);
40 point_marker2 = BKE_tracking_marker_get_exact(point_track, frame2);
41
42 if (point_marker1 != nullptr && point_marker2 != nullptr) {
43 /* Here conversion from float to double happens. */
44 x1[correspondence_index][0] = point_marker1->pos[0];
45 x1[correspondence_index][1] = point_marker1->pos[1];
46
47 x2[correspondence_index][0] = point_marker2->pos[0];
48 x2[correspondence_index][1] = point_marker2->pos[1];
49
50 correspondence_index++;
51 }
52 }
53
54 return correspondence_index;
55}
56
57/* NOTE: frame number should be in clip space, not scene space */
59 int start_frame,
60 int direction,
61 bool retrack)
62{
63 MovieTrackingPlaneMarker *start_plane_marker = BKE_tracking_plane_marker_get(plane_track,
64 start_frame);
65 MovieTrackingPlaneMarker *keyframe_plane_marker = nullptr;
66 MovieTrackingPlaneMarker new_plane_marker;
67 int frame_delta = direction > 0 ? 1 : -1;
68
69 if (plane_track->flag & PLANE_TRACK_AUTOKEY) {
70 /* Find a keyframe in given direction. */
71 for (int current_frame = start_frame;; current_frame += frame_delta) {
73 plane_track, current_frame + frame_delta);
74
75 if (next_plane_marker == nullptr) {
76 break;
77 }
78
79 if ((next_plane_marker->flag & PLANE_MARKER_TRACKED) == 0) {
80 keyframe_plane_marker = next_plane_marker;
81 break;
82 }
83 }
84 }
85 else {
86 start_plane_marker->flag |= PLANE_MARKER_TRACKED;
87 }
88
89 new_plane_marker = *start_plane_marker;
90 new_plane_marker.flag |= PLANE_MARKER_TRACKED;
91
92 for (int current_frame = start_frame;; current_frame += frame_delta) {
94 plane_track, current_frame + frame_delta);
95 Vec2 *x1, *x2;
96 double H_double[3][3];
97 float H[3][3];
98
99 /* As soon as we meet keyframed plane, we stop updating the sequence. */
100 if (next_plane_marker && (next_plane_marker->flag & PLANE_MARKER_TRACKED) == 0) {
101 /* Don't override keyframes if track is in auto-keyframe mode */
102 if (plane_track->flag & PLANE_TRACK_AUTOKEY) {
103 break;
104 }
105 }
106
107 const int num_correspondences = point_markers_correspondences_on_both_image(
108 plane_track, current_frame, current_frame + frame_delta, &x1, &x2);
109 if (num_correspondences < 4) {
110 MEM_delete(x1);
111 MEM_delete(x2);
112 break;
113 }
114
115 libmv_homography2DFromCorrespondencesEuc(x1, x2, num_correspondences, H_double);
116
117 copy_m3_m3d(H, H_double);
118
119 for (int i = 0; i < 4; i++) {
120 float vec[3] = {0.0f, 0.0f, 1.0f}, vec2[3];
121 copy_v2_v2(vec, new_plane_marker.corners[i]);
122
123 /* Apply homography */
124 mul_v3_m3v3(vec2, H, vec);
125
126 /* Normalize. */
127 vec2[0] /= vec2[2];
128 vec2[1] /= vec2[2];
129
130 copy_v2_v2(new_plane_marker.corners[i], vec2);
131 }
132
133 new_plane_marker.framenr = current_frame + frame_delta;
134
135 if (!retrack && keyframe_plane_marker && next_plane_marker &&
136 (plane_track->flag & PLANE_TRACK_AUTOKEY))
137 {
138 float fac = (float(next_plane_marker->framenr) - start_plane_marker->framenr) /
139 (float(keyframe_plane_marker->framenr) - start_plane_marker->framenr);
140
141 fac = 3 * fac * fac - 2 * fac * fac * fac;
142
143 for (int i = 0; i < 4; i++) {
144 interp_v2_v2v2(new_plane_marker.corners[i],
145 new_plane_marker.corners[i],
146 next_plane_marker->corners[i],
147 fac);
148 }
149 }
150
151 BKE_tracking_plane_marker_insert(plane_track, &new_plane_marker);
152
153 MEM_delete(x1);
154 MEM_delete(x2);
155 }
156}
157
159 int start_frame)
160{
161 track_plane_from_existing_motion(plane_track, start_frame, 1, false);
162 track_plane_from_existing_motion(plane_track, start_frame, -1, false);
163}
164
166 int start_frame,
167 int direction)
168{
169 MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track, start_frame);
170 int index = plane_marker - plane_track->markers;
171 int frame_delta = direction > 0 ? 1 : -1;
172
173 while (index >= 0 && index < plane_track->markersnr) {
174 if ((plane_marker->flag & PLANE_MARKER_TRACKED) == 0) {
175 return plane_marker;
176 }
177 plane_marker += frame_delta;
178 }
179
180 return nullptr;
181}
182
184 MovieTrackingPlaneTrack *plane_track, int start_frame)
185{
186 MovieTrackingPlaneMarker *prev_plane_keyframe, *next_plane_keyframe;
187
188 prev_plane_keyframe = find_plane_keyframe(plane_track, start_frame, -1);
189 next_plane_keyframe = find_plane_keyframe(plane_track, start_frame, 1);
190
191 if (prev_plane_keyframe != nullptr && next_plane_keyframe != nullptr) {
192 /* First we track from left keyframe to the right one without any blending. */
193 track_plane_from_existing_motion(plane_track, prev_plane_keyframe->framenr, 1, true);
194
195 /* And then we track from the right keyframe to the left one, so shape blends in nicely */
196 track_plane_from_existing_motion(plane_track, next_plane_keyframe->framenr, -1, false);
197 }
198 else if (prev_plane_keyframe != nullptr) {
199 track_plane_from_existing_motion(plane_track, prev_plane_keyframe->framenr, 1, true);
200 }
201 else if (next_plane_keyframe != nullptr) {
202 track_plane_from_existing_motion(plane_track, next_plane_keyframe->framenr, -1, true);
203 }
204}
205
206BLI_INLINE void float_corners_to_double(/*const*/ float corners[4][2], double double_corners[4][2])
207{
208 copy_v2db_v2fl(double_corners[0], corners[0]);
209 copy_v2db_v2fl(double_corners[1], corners[1]);
210 copy_v2db_v2fl(double_corners[2], corners[2]);
211 copy_v2db_v2fl(double_corners[3], corners[3]);
212}
213
214void BKE_tracking_homography_between_two_quads(/*const*/ float reference_corners[4][2],
215 /*const*/ float corners[4][2],
216 float H[3][3])
217{
218 Vec2 x1[4], x2[4];
219 double H_double[3][3];
220
221 float_corners_to_double(reference_corners, x1);
222 float_corners_to_double(corners, x2);
223
224 libmv_homography2DFromCorrespondencesEuc(x1, x2, 4, H_double);
225
226 copy_m3_m3d(H, H_double);
227}
228
229} // namespace blender
Read Blender memory allocation and freeing.
#define BLI_INLINE
void libmv_homography2DFromCorrespondencesEuc(double(*x1)[2], double(*x2)[2], int num_points, double H[3][3])
#define H(x, y, z)
BMesh Iterators.
MovieTrackingMarker * BKE_tracking_marker_get_exact(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1396
void BKE_tracking_track_plane_from_existing_motion(MovieTrackingPlaneTrack *plane_track, int start_frame)
static int point_markers_correspondences_on_both_image(MovieTrackingPlaneTrack *plane_track, int frame1, int frame2, Vec2 **r_x1, Vec2 **r_x2)
MINLINE void copy_v2_v2(float r[2], const float a[2])
BLI_INLINE void float_corners_to_double(float corners[4][2], double double_corners[4][2])
void BKE_tracking_retrack_plane_from_existing_motion_at_segment(MovieTrackingPlaneTrack *plane_track, int start_frame)
void copy_m3_m3d(float m1[3][3], const double m2[3][3])
static MovieTrackingPlaneMarker * find_plane_keyframe(MovieTrackingPlaneTrack *plane_track, int start_frame, int direction)
void BKE_tracking_homography_between_two_quads(float reference_corners[4][2], float corners[4][2], float H[3][3])
MINLINE void copy_v2db_v2fl(double r[2], const float a[2])
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get_exact(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1842
static void track_plane_from_existing_motion(MovieTrackingPlaneTrack *plane_track, int start_frame, int direction, bool retrack)
void interp_v2_v2v2(float r[2], const float a[2], const float b[2], float t)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1796
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_insert(MovieTrackingPlaneTrack *plane_track, MovieTrackingPlaneMarker *plane_marker)
Definition tracking.cc:1724
void mul_v3_m3v3(float r[3], const float M[3][3], const float a[3])
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
MovieTrackingPlaneMarker * markers