Blender V5.3
tracking_ops_track.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2016 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "MEM_guardedalloc.h"
10
11#include "BLI_listbase.hh"
12#include "BLI_math_base_c.hh"
13#include "BLI_time.hh"
14
15#include "BLT_translation.hh"
16
17#include "BKE_context.hh"
18#include "BKE_global.hh"
19#include "BKE_main.hh"
20#include "BKE_movieclip.hh"
21#include "BKE_tracking.hh"
22
23#include "WM_api.hh"
24#include "WM_types.hh"
25
26#include "ED_clip.hh"
27
28#include "RNA_access.hh"
29#include "RNA_define.hh"
30
31#include "DEG_depsgraph.hh"
32
33#include "clip_intern.hh" /* own include */
35
36namespace blender {
37
38/********************** Track operator *********************/
39
41 AutoTrackContext *context; /* Tracking context */
42 int sfra, efra, lastfra; /* Start, end and recently tracked frames */
43 int backwards; /* Backwards tracking flag */
44 MovieClip *clip; /* Clip which is tracking */
45 float delay; /* Delay in milliseconds to allow
46 * tracking at fixed FPS */
47
52};
53
55{
56 return G.is_break;
57}
58
59static int track_count_markers(SpaceClip *sc, MovieClip *clip, const int framenr)
60{
61 int tot = 0;
62 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
63 for (MovieTrackingTrack &track : tracking_object->tracks) {
64 bool selected = (sc != nullptr) ? TRACK_VIEW_SELECTED(sc, &track) : TRACK_SELECTED(&track);
65 if (selected && (track.flag & TRACK_LOCKED) == 0) {
66 MovieTrackingMarker *marker = BKE_tracking_marker_get(&track, framenr);
67 if (!marker || (marker->flag & MARKER_DISABLED) == 0) {
68 tot++;
69 }
70 }
71 }
72 return tot;
73}
74
76 MovieClip *clip,
77 const int framenr,
78 int *r_frames_limit)
79{
80 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
81 int frames_limit = 0;
82 if (sc != nullptr) {
84 }
85 for (MovieTrackingTrack &track : tracking_object->tracks) {
86 bool selected = (sc != nullptr) ? TRACK_VIEW_SELECTED(sc, &track) : TRACK_SELECTED(&track);
87 if (selected) {
88 if ((track.flag & TRACK_HIDDEN) == 0 && (track.flag & TRACK_LOCKED) == 0) {
89 BKE_tracking_marker_ensure(&track, framenr);
90 if (track.frames_limit) {
91 if (frames_limit == 0) {
92 frames_limit = track.frames_limit;
93 }
94 else {
95 frames_limit = min_ii(frames_limit, int(track.frames_limit));
96 }
97 }
98 }
99 }
100 }
101 *r_frames_limit = frames_limit;
102}
103
104static bool track_markers_check_direction(int backwards, int curfra, int efra)
105{
106 if (backwards) {
107 if (curfra < efra) {
108 return false;
109 }
110 }
111 else {
112 if (curfra > efra) {
113 return false;
114 }
115 }
116
117 return true;
118}
119
120static bool track_markers_initjob(bContext *C, TrackMarkersJob *tmj, bool backwards, bool sequence)
121{
124 Scene *scene = CTX_data_scene(C);
125 MovieTrackingSettings *settings = &clip->tracking.settings;
126 int frames_limit;
127 int framenr = ED_space_clip_get_clip_frame_number(sc);
128
129 track_init_markers(sc, clip, framenr, &frames_limit);
130
131 tmj->sfra = framenr;
132 tmj->clip = clip;
133 tmj->backwards = backwards;
134
135 if (sequence) {
136 if (backwards) {
137 tmj->efra = scene->r.sfra;
138 }
139 else {
140 tmj->efra = scene->r.efra;
141 }
143 }
144 else {
145 if (backwards) {
146 tmj->efra = tmj->sfra - 1;
147 }
148 else {
149 tmj->efra = tmj->sfra + 1;
150 }
151 }
152
153 /* Limit frames to be tracked by user setting. */
154 if (frames_limit) {
155 if (backwards) {
156 tmj->efra = std::max(tmj->efra, tmj->sfra - frames_limit);
157 }
158 else {
159 tmj->efra = std::min(tmj->efra, tmj->sfra + frames_limit);
160 }
161 }
162
163 if (settings->speed != TRACKING_SPEED_FASTEST) {
164 tmj->delay = 1.0f / scene->r.frs_sec * 1000.0f;
165
166 if (settings->speed == TRACKING_SPEED_HALF) {
167 tmj->delay *= 2;
168 }
169 else if (settings->speed == TRACKING_SPEED_QUARTER) {
170 tmj->delay *= 4;
171 }
172 else if (settings->speed == TRACKING_SPEED_DOUBLE) {
173 tmj->delay /= 2;
174 }
175 }
176
177 tmj->context = BKE_autotrack_context_new(clip, &sc->user, backwards);
178
179 clip->tracking_context = tmj->context;
180
181 tmj->lastfra = tmj->sfra;
182
183 /* XXX: silly to store this, but this data is needed to update scene and
184 * movie-clip numbers when tracking is finished. This introduces
185 * better feedback for artists.
186 * Maybe there's another way to solve this problem,
187 * but can't think better way at the moment.
188 * Anyway, this way isn't more unstable as animation rendering
189 * animation which uses the same approach (except storing screen).
190 */
191 tmj->scene = scene;
192 tmj->main = CTX_data_main(C);
193 tmj->screen = CTX_wm_screen(C);
194
195 tmj->wm = CTX_wm_manager(C);
196
197 if (!track_markers_check_direction(backwards, tmj->sfra, tmj->efra)) {
198 return false;
199 }
200
201 WM_locked_interface_set(tmj->wm, true);
202
203 return true;
204}
205
206static void track_markers_startjob(void *tmv, wmJobWorkerStatus *worker_status)
207{
208 TrackMarkersJob *tmj = static_cast<TrackMarkersJob *>(tmv);
209 int framenr = tmj->sfra;
210
212
213 while (framenr != tmj->efra) {
214 if (tmj->delay > 0) {
215 /* Tracking should happen with fixed fps. Calculate time
216 * using current timer value before tracking frame and after.
217 *
218 * Small (and maybe unneeded optimization): do not calculate
219 * exec_time for "Fastest" tracking
220 */
221
222 double start_time = BLI_time_now_seconds(), exec_time;
223
225 break;
226 }
227
228 exec_time = BLI_time_now_seconds() - start_time;
229 if (tmj->delay > float(exec_time)) {
230 BLI_time_sleep_ms(tmj->delay - float(exec_time));
231 }
232 }
233 else if (!BKE_autotrack_context_step(tmj->context)) {
234 break;
235 }
236
237 worker_status->do_update = true;
238 worker_status->progress = float(framenr - tmj->sfra) / (tmj->efra - tmj->sfra);
239
240 if (tmj->backwards) {
241 framenr--;
242 }
243 else {
244 framenr++;
245 }
246
247 tmj->lastfra = framenr;
248
249 if (worker_status->stop || track_markers_testbreak()) {
250 break;
251 }
252 }
253}
254
255static void track_markers_updatejob(void *tmv)
256{
257 TrackMarkersJob *tmj = static_cast<TrackMarkersJob *>(tmv);
259}
260
261static void track_markers_endjob(void *tmv)
262{
263 TrackMarkersJob *tmj = static_cast<TrackMarkersJob *>(tmv);
264 wmWindowManager *wm = tmj->main->wm.first();
265
266 tmj->clip->tracking_context = nullptr;
268 if (wm != nullptr) {
269 /* XXX */
270 // ED_update_for_newframe(tmj->main, tmj->scene);
271 }
272
275
278}
279
280static void track_markers_freejob(void *tmv)
281{
282 TrackMarkersJob *tmj = static_cast<TrackMarkersJob *>(tmv);
283 tmj->clip->tracking_context = nullptr;
284 WM_locked_interface_set(tmj->wm, false);
286 MEM_delete(tmj);
287}
288
290{
291 TrackMarkersJob *tmj;
294 wmJob *wm_job;
295 bool backwards = RNA_boolean_get(op->ptr, "backwards");
296 bool sequence = RNA_boolean_get(op->ptr, "sequence");
297 int framenr = ED_space_clip_get_clip_frame_number(sc);
298
300 /* Only one tracking is allowed at a time. */
301 return OPERATOR_CANCELLED;
302 }
303
304 if (clip->tracking_context) {
305 return OPERATOR_CANCELLED;
306 }
307
308 if (track_count_markers(sc, clip, framenr) == 0) {
309 return OPERATOR_CANCELLED;
310 }
311
312 tmj = MEM_new_zeroed<TrackMarkersJob>("TrackMarkersJob data");
313 if (!track_markers_initjob(C, tmj, backwards, sequence)) {
315 return OPERATOR_CANCELLED;
316 }
317
318 /* Setup job. */
319 if (use_job && sequence) {
320 wm_job = WM_jobs_get(CTX_wm_manager(C),
323 "Tracking markers...",
327
328 /* If there's delay set in tracking job, tracking should happen
329 * with fixed FPS. To deal with editor refresh we have to synchronize
330 * tracks from job and tracks in clip. Do this in timer callback
331 * to prevent threading conflicts. */
332 if (tmj->delay > 0) {
333 WM_jobs_timer(wm_job, tmj->delay / 1000.0f, NC_MOVIECLIP | NA_EVALUATED, 0);
334 }
335 else {
336 WM_jobs_timer(wm_job, 0.2, NC_MOVIECLIP | NA_EVALUATED, 0);
337 }
338
341
342 G.is_break = false;
343
345 WM_cursor_wait(false);
346
347 /* Add modal handler for ESC. */
349
351 }
352
353 wmJobWorkerStatus worker_status = {};
354 track_markers_startjob(tmj, &worker_status);
357 return OPERATOR_FINISHED;
358}
359
361{
362 return track_markers(C, op, false);
363}
364
366 wmOperator *op,
367 const wmEvent * /*event*/)
368{
369 return track_markers(C, op, true);
370}
371
373{
374 /* No running tracking, remove handler and pass through. */
377 }
378
379 /* Running tracking. */
380 switch (event->type) {
381 case EVT_ESCKEY:
383 default: {
384 break;
385 }
386 }
387
389}
390
391static std::string track_markers_get_description(bContext * /*C*/,
392 wmOperatorType * /*ot*/,
393 PointerRNA *ptr)
394{
395 const bool backwards = RNA_boolean_get(ptr, "backwards");
396 const bool sequence = RNA_boolean_get(ptr, "sequence");
397
398 if (backwards && sequence) {
399 return TIP_("Track the selected markers backward for the entire clip");
400 }
401 if (backwards && !sequence) {
402 return TIP_("Track the selected markers backward by one frame");
403 }
404 if (!backwards && sequence) {
405 return TIP_("Track the selected markers forward for the entire clip");
406 }
407 if (!backwards && !sequence) {
408 return TIP_("Track the selected markers forward by one frame");
409 }
410
411 /* Use default description. */
412 return "";
413}
414
416{
417 /* identifiers */
418 ot->name = "Track Markers";
419 ot->description = "Track selected markers";
420 ot->idname = "CLIP_OT_track_markers";
421
422 /* API callbacks. */
428
429 /* flags */
430 ot->flag = OPTYPE_UNDO;
431
432 /* properties */
433 RNA_def_boolean(ot->srna, "backwards", false, "Backwards", "Do backwards tracking");
435 "sequence",
436 false,
437 "Track Sequence",
438 "Track marker during image sequence rather than "
439 "single image");
440}
441
442/********************** Refine track position operator *********************/
443
445{
448 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
449 const bool backwards = RNA_boolean_get(op->ptr, "backwards");
450 const int framenr = ED_space_clip_get_clip_frame_number(sc);
451
452 for (MovieTrackingTrack &track : tracking_object->tracks) {
453 if (TRACK_VIEW_SELECTED(sc, &track)) {
454 MovieTrackingMarker *marker = BKE_tracking_marker_get(&track, framenr);
455 BKE_tracking_refine_marker(clip, &track, marker, backwards);
456 }
457 }
458
461
462 return OPERATOR_FINISHED;
463}
464
466{
467 /* identifiers */
468 ot->name = "Refine Markers";
469 ot->description =
470 "Refine selected markers positions "
471 "by running the tracker from track's reference "
472 "to current frame";
473 ot->idname = "CLIP_OT_refine_markers";
474
475 /* API callbacks. */
478
479 /* flags */
481
482 /* properties */
483 RNA_def_boolean(ot->srna, "backwards", false, "Backwards", "Do backwards tracking");
484}
485
486} // namespace blender
#define TRACK_SELECTED(track)
#define TRACK_VIEW_SELECTED(sc, track)
Platform independent time functions.
#define TIP_(msgid)
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define NA_EVALUATED
Definition WM_types.hh:635
#define NC_MOVIECLIP
Definition WM_types.hh:410
#define NC_SCENE
Definition WM_types.hh:391
#define ND_FRAME
Definition WM_types.hh:453
BMesh Iterators.
void WM_main_add_notifier(uint type, void *reference)
static wmOperatorStatus track_markers_invoke(bContext *C, wmOperator *op, const wmEvent *)
bool BKE_autotrack_context_step(AutoTrackContext *context)
static bool track_markers_initjob(bContext *C, TrackMarkersJob *tmj, bool backwards, bool sequence)
void WM_jobs_callbacks(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *))
Definition wm_jobs.cc:407
void CLIP_OT_track_markers(wmOperatorType *ot)
void BLI_time_sleep_ms(int ms)
Definition time.cc:91
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
Definition tracking.cc:1982
static bool track_markers_testbreak()
@ WM_JOB_TYPE_CLIP_TRACK_MARKERS
Definition WM_api.hh:2029
static void track_markers_freejob(void *tmv)
SpaceClip * CTX_wm_space_clip(const bContext *C)
void BKE_tracking_refine_marker(MovieClip *clip, MovieTrackingTrack *track, MovieTrackingMarker *marker, bool backwards)
wmWindow * CTX_wm_window(const bContext *C)
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *customdata))
Definition wm_jobs.cc:377
static wmOperatorStatus refine_marker_exec(bContext *C, wmOperator *op)
@ WM_JOB_PROGRESS
Definition WM_api.hh:1997
static wmOperatorStatus track_markers(bContext *C, wmOperator *op, bool use_job)
void BKE_autotrack_context_start(AutoTrackContext *context)
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:498
Global G
Definition blender.cc:57
void WM_locked_interface_set(wmWindowManager *wm, bool lock)
static std::string track_markers_get_description(bContext *, wmOperatorType *, PointerRNA *ptr)
static int track_count_markers(SpaceClip *sc, MovieClip *clip, const int framenr)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void DEG_id_tag_update(ID *id, unsigned int flags)
MovieTrackingMarker * BKE_tracking_marker_ensure(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1407
bool WM_jobs_has_running(const wmWindowManager *window_manager, const void *owner, const eWM_JobType type, const eWM_JobFlag exclude_flags)
Definition wm_jobs.cc:809
wmWindowManager * CTX_wm_manager(const bContext *C)
int ED_space_clip_get_clip_frame_number(const SpaceClip *sc)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void BKE_autotrack_context_finish(AutoTrackContext *context)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
float BKE_movieclip_remap_scene_to_clip_frame(const MovieClip *clip, float framenr)
static void track_markers_endjob(void *tmv)
void CLIP_OT_refine_markers(wmOperatorType *ot)
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
Main * CTX_data_main(const bContext *C)
static void track_markers_updatejob(void *tmv)
MovieClip * ED_space_clip_get_clip(const SpaceClip *sc)
wmJob * WM_jobs_get(wmWindowManager *wm, wmWindow *win, const void *owner, const char *name, const eWM_JobFlag flag, const eWM_JobType job_type)
Definition wm_jobs.cc:228
@ ID_RECALC_SYNC_TO_EVAL
Definition DNA_ID.h:1118
struct AutoTrackContext * BKE_autotrack_context_new(MovieClip *clip, MovieClipUser *user, bool is_backwards)
void BKE_autotrack_context_sync(AutoTrackContext *context)
static wmOperatorStatus track_markers_exec(bContext *C, wmOperator *op)
static bool track_markers_check_direction(int backwards, int curfra, int efra)
bool ED_space_clip_tracking_poll(bContext *C)
double BLI_time_now_seconds()
Definition time.cc:30
float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
Scene * CTX_data_scene(const bContext *C)
void clip_tracking_clear_invisible_track_selection(SpaceClip *sc, MovieClip *clip)
bScreen * CTX_wm_screen(const bContext *C)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
static void track_init_markers(SpaceClip *sc, MovieClip *clip, const int framenr, int *r_frames_limit)
void BKE_autotrack_context_free(AutoTrackContext *context)
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
void WM_cursor_wait(bool val)
MINLINE int min_ii(int a, int b)
void WM_jobs_timer(wmJob *wm_job, double time_step, uint note, uint endnote, void(*timer_step)(void *))
Definition wm_jobs.cc:393
static wmOperatorStatus track_markers_modal(bContext *C, wmOperator *, const wmEvent *event)
static void track_markers_startjob(void *tmv, wmJobWorkerStatus *worker_status)
MovieTrackingMarker * BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1363
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
struct MovieTracking tracking
ListBaseT< MovieTrackingTrack > tracks
MovieTrackingSettings settings
struct RenderData r
struct MovieClipUser user
wmEventType type
Definition WM_types.hh:817
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157
std::string(*) get_description(bContext *C, wmOperatorType *ot, PointerRNA *ptr)
Definition WM_types.hh:1197