Blender V5.3
tracking_region_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
11
12#include "MEM_guardedalloc.h"
13
14#include "DNA_movieclip_types.h"
15
16#include "BKE_movieclip.hh"
17#include "BKE_tracking.hh"
18
19#include "IMB_imbuf.hh"
20#include "IMB_imbuf_types.hh"
21
22#include "libmv-capi.h"
23#include "tracking_private.hh"
24
25namespace blender {
26
27/* **** utility functions for tracking **** */
28
30static void float_rgba_to_gray(const float *rgba,
31 float *gray,
32 int num_pixels,
33 float weight_red,
34 float weight_green,
35 float weight_blue)
36{
37 for (int i = 0; i < num_pixels; i++) {
38 const float *pixel = rgba + 4 * i;
39
40 gray[i] = weight_red * pixel[0] + weight_green * pixel[1] + weight_blue * pixel[2];
41 }
42}
43
44static void uint8_rgba_to_float_gray(const uchar *rgba,
45 float *gray,
46 int num_pixels,
47 float weight_red,
48 float weight_green,
49 float weight_blue)
50{
51 for (int i = 0; i < num_pixels; i++) {
52 const uchar *pixel = rgba + i * 4;
53
54 gray[i] = (weight_red * pixel[0] + weight_green * pixel[1] + weight_blue * pixel[2]) / 255.0f;
55 }
56}
57
59static float *track_get_search_floatbuf(ImBuf *ibuf,
60 MovieTrackingTrack *track,
61 MovieTrackingMarker *marker,
62 int *r_width,
63 int *r_height)
64{
65 ImBuf *searchibuf;
66 float *gray_pixels;
67 int width, height;
68
69 searchibuf = BKE_tracking_get_search_imbuf(ibuf, track, marker, false, true);
70
71 if (!searchibuf) {
72 *r_width = 0;
73 *r_height = 0;
74 return nullptr;
75 }
76
77 width = searchibuf->x;
78 height = searchibuf->y;
79
80 gray_pixels = MEM_new_array_zeroed<float>(width * height, "tracking floatBuf");
81
82 if (searchibuf->float_data()) {
84 searchibuf->float_data(), gray_pixels, width * height, 0.2126f, 0.7152f, 0.0722f);
85 }
86 else {
88 searchibuf->byte_data(), gray_pixels, width * height, 0.2126f, 0.7152f, 0.0722f);
89 }
90
91 IMB_freeImBuf(searchibuf);
92
93 *r_width = width;
94 *r_height = height;
95
96 return gray_pixels;
97}
98
99/* Get image buffer for a given frame
100 *
101 * Frame is in clip space.
102 */
104 MovieClipUser *user,
105 MovieClipFlag clip_flag,
106 int framenr)
107{
108 ImBuf *ibuf;
109 MovieClipUser new_user = *user;
110
111 new_user.framenr = BKE_movieclip_remap_clip_to_scene_frame(clip, framenr);
112
113 ibuf = BKE_movieclip_get_ibuf_flag(clip, &new_user, clip_flag, MovieClipCacheFlag::SkipCache);
114
115 return ibuf;
116}
117
118/* Get image buffer for previous marker's keyframe. */
120 MovieClipUser *user,
121 MovieClipFlag clip_flag,
122 MovieTrackingTrack *track,
123 int curfra,
124 bool backwards,
125 MovieTrackingMarker **r_marker_keyed)
126{
127 MovieTrackingMarker *marker_keyed;
128 int keyed_framenr;
129
130 marker_keyed = tracking_get_keyframed_marker(track, curfra, backwards);
131 if (marker_keyed == nullptr) {
132 return nullptr;
133 }
134
135 keyed_framenr = marker_keyed->framenr;
136
137 *r_marker_keyed = marker_keyed;
138
139 return tracking_context_get_frame_ibuf(clip, user, clip_flag, keyed_framenr);
140}
141
142/* Get image buffer which is used as reference for track. */
144 MovieClipUser *user,
145 MovieClipFlag clip_flag,
146 MovieTrackingTrack *track,
147 int curfra,
148 bool backwards,
149 MovieTrackingMarker **reference_marker)
150{
151 ImBuf *ibuf = nullptr;
152
153 if (track->pattern_match == TRACK_MATCH_KEYFRAME) {
155 clip, user, clip_flag, track, curfra, backwards, reference_marker);
156 }
157 else {
158 ibuf = tracking_context_get_frame_ibuf(clip, user, clip_flag, curfra);
159
160 /* use current marker as keyframed position */
161 *reference_marker = BKE_tracking_marker_get(track, curfra);
162 }
163
164 return ibuf;
165}
166
168 float *mask,
169 const bool is_backwards,
171{
173
174 /* TODO(sergey): Use explicit conversion, so that options are decoupled between the Libmv library
175 * and enumerator values in DNA. */
176 options->motion_model = track->motion_model;
177
178 options->use_brute = ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_BRUTE) != 0);
179
180 options->use_normalization = ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_NORMALIZATION) !=
181 0);
182
183 options->num_iterations = 50;
184 options->minimum_correlation = track->minimum_correlation;
185 options->sigma = 0.9;
186
187 if ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_MASK) != 0) {
188 options->image1_mask = mask;
189 }
190 else {
191 options->image1_mask = nullptr;
192 }
193}
194
195/* Perform tracking from a reference_marker to destination_ibuf.
196 * Uses marker as an initial position guess.
197 *
198 * Returns truth if tracker returned success, puts result
199 * to dst_pixel_x and dst_pixel_y.
200 */
201static bool configure_and_run_tracker(ImBuf *destination_ibuf,
202 MovieTrackingTrack *track,
203 MovieTrackingMarker *reference_marker,
204 MovieTrackingMarker *marker,
205 float *reference_search_area,
206 int reference_search_area_width,
207 int reference_search_area_height,
208 float *mask,
209 const bool is_backward,
210 double dst_pixel_x[5],
211 double dst_pixel_y[5])
212{
213 /* To convert to the x/y split array format for libmv. */
214 double src_pixel_x[5], src_pixel_y[5];
215
216 /* Settings for the tracker */
219
220 float *patch_new;
221
222 int new_search_area_width, new_search_area_height;
223 int frame_width, frame_height;
224
225 bool tracked;
226
227 frame_width = destination_ibuf->x;
228 frame_height = destination_ibuf->y;
229
230 /* for now track to the same search area dimension as marker has got for current frame
231 * will make all tracked markers in currently tracked segment have the same search area
232 * size, but it's quite close to what is actually needed
233 */
234 patch_new = track_get_search_floatbuf(
235 destination_ibuf, track, marker, &new_search_area_width, &new_search_area_height);
236
237 /* configure the tracker */
238 tracking_configure_tracker(track, mask, is_backward, &options);
239
240 /* Convert the marker corners and center into pixel coordinates in the
241 * search/destination images. */
243 frame_width, frame_height, reference_marker, src_pixel_x, src_pixel_y);
245 frame_width, frame_height, marker, dst_pixel_x, dst_pixel_y);
246
247 if (patch_new == nullptr || reference_search_area == nullptr) {
248 return false;
249 }
250
251 /* run the tracker! */
252 tracked = libmv_trackRegion(&options,
253 reference_search_area,
254 reference_search_area_width,
255 reference_search_area_height,
256 patch_new,
257 new_search_area_width,
258 new_search_area_height,
259 src_pixel_x,
260 src_pixel_y,
261 &result,
262 dst_pixel_x,
263 dst_pixel_y);
264
265 MEM_delete(patch_new);
266
267 return tracked;
268}
269
271 MovieTrackingMarker *marker,
272 bool backwards,
273 int *reference_framenr)
274{
275 const MovieTrackingMarker *first_marker = track->markers;
276 const MovieTrackingMarker *last_marker = track->markers + track->markersnr - 1;
277 MovieTrackingMarker *reference = backwards ? marker + 1 : marker - 1;
278
279 while (reference >= first_marker && reference <= last_marker &&
280 (reference->flag & MARKER_DISABLED) != 0)
281 {
282 if (backwards) {
283 reference++;
284 }
285 else {
286 reference--;
287 }
288 }
289
290 if (reference < first_marker || reference > last_marker) {
291 return false;
292 }
293
294 *reference_framenr = reference->framenr;
295 return (reference->flag & MARKER_DISABLED) == 0;
296}
297
299 MovieTrackingTrack *track,
300 MovieTrackingMarker *marker,
301 bool backwards)
302{
303 MovieTrackingMarker *reference_marker = nullptr;
304 ImBuf *reference_ibuf, *destination_ibuf;
305 float *search_area, *mask = nullptr;
306 int frame_width, frame_height;
307 int search_area_height, search_area_width;
309 int reference_framenr;
310 MovieClipUser user = {};
311 double dst_pixel_x[5], dst_pixel_y[5];
312 bool tracked;
313
314 /* Construct a temporary clip used, used to acquire image buffers. */
316
317 BKE_movieclip_get_size(clip, &user, &frame_width, &frame_height);
318
319 /* Get an image buffer for reference frame, also gets reference marker. */
320 if (!refine_marker_reference_frame_get(track, marker, backwards, &reference_framenr)) {
321 return;
322 }
323
325 clip, &user, clip_flag, track, reference_framenr, backwards, &reference_marker);
326 if (reference_ibuf == nullptr) {
327 return;
328 }
329
330 /* Could not refine with self. */
331 if (reference_marker == marker) {
332 return;
333 }
334
335 /* Destination image buffer has got frame number corresponding to refining marker. */
336 destination_ibuf = BKE_movieclip_get_ibuf_flag(
337 clip, &user, clip_flag, MovieClipCacheFlag::SkipCache);
338 if (destination_ibuf == nullptr) {
339 IMB_freeImBuf(reference_ibuf);
340 return;
341 }
342
343 /* Get search area from reference image. */
344 search_area = track_get_search_floatbuf(
345 reference_ibuf, track, reference_marker, &search_area_width, &search_area_height);
346
347 /* If needed, compute track's mask. */
348 if ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_MASK) != 0) {
349 mask = BKE_tracking_track_get_mask(frame_width, frame_height, track, marker);
350 }
351
352 /* Run the tracker from reference frame to current one. */
353 tracked = configure_and_run_tracker(destination_ibuf,
354 track,
355 reference_marker,
356 marker,
357 search_area,
358 search_area_width,
359 search_area_height,
360 mask,
361 backwards,
362 dst_pixel_x,
363 dst_pixel_y);
364
365 /* Refine current marker's position if track was successful. */
366 if (tracked) {
368 frame_width, frame_height, marker, dst_pixel_x, dst_pixel_y);
369 marker->flag |= MARKER_TRACKED;
370 }
371
372 /* Free memory used for refining */
373 MEM_delete(search_area);
374 if (mask) {
375 MEM_delete(mask);
376 }
377 IMB_freeImBuf(reference_ibuf);
378 IMB_freeImBuf(destination_ibuf);
379}
380
381} // namespace blender
Read Blender memory allocation and freeing.
CCL_NAMESPACE_BEGIN struct Options options
@ LIBMV_TRACK_REGION_FORWARD
@ LIBMV_TRACK_REGION_BACKWARD
BMesh Iterators.
@ TRACK_ALGORITHM_FLAG_USE_NORMALIZATION
@ TRACK_ALGORITHM_FLAG_USE_MASK
@ TRACK_ALGORITHM_FLAG_USE_BRUTE
void BKE_movieclip_get_size(MovieClip *clip, const MovieClipUser *user, int *r_width, int *r_height)
static ImBuf * tracking_context_get_reference_ibuf(MovieClip *clip, MovieClipUser *user, MovieClipFlag clip_flag, MovieTrackingTrack *track, int curfra, bool backwards, MovieTrackingMarker **reference_marker)
ImBuf * BKE_tracking_get_search_imbuf(const ImBuf *ibuf, const MovieTrackingTrack *track, const MovieTrackingMarker *marker, bool anchored, bool disable_channels)
Definition tracking.cc:2665
static ImBuf * tracking_context_get_keyframed_ibuf(MovieClip *clip, MovieClipUser *user, MovieClipFlag clip_flag, MovieTrackingTrack *track, int curfra, bool backwards, MovieTrackingMarker **r_marker_keyed)
void BKE_tracking_refine_marker(MovieClip *clip, MovieTrackingTrack *track, MovieTrackingMarker *marker, bool backwards)
static float * track_get_search_floatbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker, int *r_width, int *r_height)
static void uint8_rgba_to_float_gray(const uchar *rgba, float *gray, int num_pixels, float weight_red, float weight_green, float weight_blue)
static bool refine_marker_reference_frame_get(MovieTrackingTrack *track, MovieTrackingMarker *marker, bool backwards, int *reference_framenr)
MovieTrackingMarker * tracking_get_keyframed_marker(MovieTrackingTrack *track, int current_frame, bool backwards)
void IMB_freeImBuf(ImBuf *ibuf)
unsigned char uchar
Definition BKE_text.h:58
static void float_rgba_to_gray(const float *rgba, float *gray, int num_pixels, float weight_red, float weight_green, float weight_blue)
void tracking_set_marker_coords_from_tracking(int frame_width, int frame_height, MovieTrackingMarker *marker, const double search_pixel_x[5], const double search_pixel_y[5])
void tracking_configure_tracker(const MovieTrackingTrack *track, float *mask, bool is_backwards, libmv_TrackRegionOptions *options)
float * BKE_tracking_track_get_mask(int frame_width, int frame_height, const MovieTrackingTrack *track, const MovieTrackingMarker *marker)
Definition tracking.cc:1159
static bool configure_and_run_tracker(ImBuf *destination_ibuf, MovieTrackingTrack *track, MovieTrackingMarker *reference_marker, MovieTrackingMarker *marker, float *reference_search_area, int reference_search_area_width, int reference_search_area_height, float *mask, const bool is_backward, double dst_pixel_x[5], double dst_pixel_y[5])
ImBuf * BKE_movieclip_get_ibuf_flag(MovieClip *clip, const MovieClipUser *user, MovieClipFlag flag, MovieClipCacheFlag cache_flag)
float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
static ImBuf * tracking_context_get_frame_ibuf(MovieClip *clip, MovieClipUser *user, MovieClipFlag clip_flag, int framenr)
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 * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
MovieTrackingMarker * BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1363
const uint8_t * byte_data() const
const float * float_data() const
MovieTrackingMarker * markers
TrackingAlgorithmFlag algorithm_flag
int libmv_trackRegion(const libmv_TrackRegionOptions *, const float *, int, int, const float *, int, int, const double *x1, const double *y1, libmv_TrackRegionResult *result, double *x2, double *y2)
Definition stub.cc:24