Blender V5.3
transform_convert_tracking.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "DNA_space_types.h"
10
11#include "MEM_guardedalloc.h"
12
13#include "BLI_listbase.hh"
14#include "BLI_math_matrix_c.hh"
15#include "BLI_math_vector_c.hh"
16
17#include "BKE_compositor.hh"
18#include "BKE_context.hh"
19#include "BKE_movieclip.hh"
21#include "BKE_tracking.hh"
22
23#include "ED_clip.hh"
24
25#include "WM_api.hh"
26
27#include "transform.hh"
28#include "transform_convert.hh"
29
30namespace blender::ed::transform {
31
33 int mode;
34 int flag;
35
36 /* Tracks transformation from main window. */
37 int area;
38 const float *relative, *loc;
39 float soffset[2], srelative[2];
40 float offset[2];
41
46
49};
50
55
56/* -------------------------------------------------------------------- */
59
62
65
66 /* NOTE: These pointers will be `nullptr` during counting step.
67 * This means, that the transformation data initialization functions are to increment
68 * `tc->data_len` instead of filling in the transformation data when these pointers are
69 * `nullptr`. For simplicity, check the `current.td` against `nullptr`.
70 * Do not `tc->data_len` when filling in the transformation data. */
76};
77
79 MovieTrackingTrack *track,
80 MovieTrackingMarker *marker,
81 eTrackArea area,
82 float loc[2],
83 const float rel[2],
84 const float off[2],
85 const float aspect[2])
86{
87 TransData *td = init_context->current.td;
88 TransData2D *td2d = init_context->current.td2d;
89 TransDataTracking *tdt = init_context->current.tdt;
90
91 if (td == nullptr) {
92 init_context->tc->data_len++;
93 return;
94 }
95
96 int anchor = area == TRACK_AREA_POINT && off;
97
98 tdt->flag = marker->flag;
99 tdt->framenr = marker->framenr;
101
102 if (anchor) {
103 td2d->loc[0] = rel[0] * aspect[0]; /* Hold original location. */
104 td2d->loc[1] = rel[1] * aspect[1];
105
106 tdt->loc = loc;
107 td2d->loc2d = loc; /* Current location. */
108 }
109 else {
110 td2d->loc[0] = loc[0] * aspect[0]; /* Hold original location. */
111 td2d->loc[1] = loc[1] * aspect[1];
112
113 td2d->loc2d = loc; /* Current location. */
114 }
115 td2d->loc[2] = 0.0f;
116
117 tdt->relative = rel;
118 tdt->area = area;
119
120 tdt->markersnr = track->markersnr;
121 tdt->markers = track->markers;
122 tdt->track = track;
123
124 if (rel) {
125 if (!anchor) {
126 td2d->loc[0] += rel[0] * aspect[0];
127 td2d->loc[1] += rel[1] * aspect[1];
128 }
129
130 copy_v2_v2(tdt->srelative, rel);
131 }
132
133 if (off) {
134 copy_v2_v2(tdt->soffset, off);
135 }
136
137 td->flag = 0;
138 td->loc = td2d->loc;
139 copy_v3_v3(td->iloc, td->loc);
140
141 // copy_v3_v3(td->center, td->loc);
143 td->center[0] = marker->pos[0] * aspect[0];
144 td->center[1] = marker->pos[1] * aspect[1];
145
146 memset(td->axismtx, 0, sizeof(td->axismtx));
147 td->axismtx[2][2] = 1.0f;
148
149 td->val = nullptr;
150
151 td->flag |= TD_SELECTED;
152 td->dist = 0.0;
153
154 unit_m3(td->mtx);
155 unit_m3(td->smtx);
156
157 init_context->current.td++;
158 init_context->current.td2d++;
159 init_context->current.tdt++;
160}
161
162static void trackToTransData(TransformInitContext *init_context,
163 const int framenr,
164 MovieTrackingTrack *track,
165 const float aspect[2])
166{
167 MovieTrackingMarker *marker = BKE_tracking_marker_ensure(track, framenr);
168
169 markerToTransDataInit(init_context,
170 track,
171 marker,
173 track->offset,
174 marker->pos,
175 track->offset,
176 aspect);
177
178 if (track->flag & SELECT) {
180 init_context, track, marker, TRACK_AREA_POINT, marker->pos, nullptr, nullptr, aspect);
181 }
182
183 if (track->pat_flag & SELECT) {
184 int a;
185
186 for (a = 0; a < 4; a++) {
187 markerToTransDataInit(init_context,
188 track,
189 marker,
191 marker->pattern_corners[a],
192 marker->pos,
193 nullptr,
194 aspect);
195 }
196 }
197
198 if (track->search_flag & SELECT) {
199 markerToTransDataInit(init_context,
200 track,
201 marker,
203 marker->search_min,
204 marker->pos,
205 nullptr,
206 aspect);
207
208 markerToTransDataInit(init_context,
209 track,
210 marker,
212 marker->search_max,
213 marker->pos,
214 nullptr,
215 aspect);
216 }
217
218 if (init_context->current.td != nullptr) {
219 marker->flag &= ~(MARKER_DISABLED | MARKER_TRACKED);
220 }
221}
222
224 const int framenr,
225 MovieTrackingTrack *track,
226 const float aspect[2])
227{
228 if (!TRACK_VIEW_SELECTED(init_context->space_clip, track)) {
229 return;
230 }
231 if (track->flag & TRACK_LOCKED) {
232 return;
233 }
234 trackToTransData(init_context, framenr, track, aspect);
235}
236
238 MovieTrackingPlaneTrack *plane_track,
239 MovieTrackingPlaneMarker *plane_marker,
240 float corner[2],
241 const float aspect[2])
242{
243 TransData *td = init_context->current.td;
244 TransData2D *td2d = init_context->current.td2d;
245 TransDataTracking *tdt = init_context->current.tdt;
246
247 if (td == nullptr) {
248 init_context->tc->data_len++;
249 return;
250 }
251
252 tdt->flag = plane_marker->flag;
253 tdt->framenr = plane_marker->framenr;
255 tdt->plane_track = plane_track;
256
257 td2d->loc[0] = corner[0] * aspect[0]; /* Hold original location. */
258 td2d->loc[1] = corner[1] * aspect[1];
259
260 td2d->loc2d = corner; /* Current location. */
261 td2d->loc[2] = 0.0f;
262
263 td->flag = 0;
264 td->loc = td2d->loc;
265 copy_v3_v3(td->iloc, td->loc);
266 copy_v3_v3(td->center, td->loc);
267
268 memset(td->axismtx, 0, sizeof(td->axismtx));
269 td->axismtx[2][2] = 1.0f;
270
271 td->val = nullptr;
272
273 td->flag |= TD_SELECTED;
274 td->dist = 0.0;
275
276 unit_m3(td->mtx);
277 unit_m3(td->smtx);
278
279 init_context->current.td++;
280 init_context->current.td2d++;
281 init_context->current.tdt++;
282}
283
285 const int framenr,
286 MovieTrackingPlaneTrack *plane_track,
287 const float aspect[2])
288{
289 MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_ensure(plane_track, framenr);
290
291 for (int i = 0; i < 4; i++) {
293 init_context, plane_track, plane_marker, plane_marker->corners[i], aspect);
294 }
295
296 if (init_context->current.td != nullptr) {
297 plane_marker->flag &= ~PLANE_MARKER_TRACKED;
298 }
299}
300
302 const int framenr,
303 MovieTrackingPlaneTrack *plane_track,
304 const float aspect[2])
305{
306 if (!PLANE_TRACK_VIEW_SELECTED(plane_track)) {
307 return;
308 }
309 planeTrackToTransData(init_context, framenr, plane_track, aspect);
310}
311
313 TransDataContainer * /*tc*/,
314 TransCustomData *custom_data)
315{
316 if (custom_data->data) {
317 TransDataTracking *tdt = static_cast<TransDataTracking *>(custom_data->data);
318 if (tdt->smarkers) {
319 MEM_delete(tdt->smarkers);
320 }
321
322 MEM_delete(tdt);
323 custom_data->data = nullptr;
324 }
325}
326
328{
329 SpaceClip *space_clip = CTX_wm_space_clip(C);
330 MovieClip *clip = ED_space_clip_get_clip(space_clip);
331 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
332 const int framenr = ED_space_clip_get_clip_frame_number(space_clip);
333
335
336 TransformInitContext init_context = {nullptr};
337 init_context.space_clip = space_clip;
338 init_context.t = t;
339 init_context.tc = tc;
340
341 /* Count required transformation data. */
342
343 tc->data_len = 0;
344
345 for (MovieTrackingTrack &track : tracking_object->tracks) {
346 trackToTransDataIfNeeded(&init_context, framenr, &track, t->aspect);
347 }
348
349 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
350 planeTrackToTransDataIfNeeded(&init_context, framenr, &plane_track, t->aspect);
351 }
352
353 if (tc->data_len == 0) {
354 return;
355 }
356
357 tc->data = MEM_new_array_zeroed<TransData>(tc->data_len, "TransTracking TransData");
358 tc->data_2d = MEM_new_array_zeroed<TransData2D>(tc->data_len, "TransTracking TransData2D");
360 tc->data_len, "TransTracking TransDataTracking");
362
363 init_context.current.td = tc->data;
364 init_context.current.td2d = tc->data_2d;
365 init_context.current.tdt = static_cast<TransDataTracking *>(tc->custom.type.data);
366
367 /* Create actual transformation data. */
368
369 for (MovieTrackingTrack &track : tracking_object->tracks) {
370 trackToTransDataIfNeeded(&init_context, framenr, &track, t->aspect);
371 }
372
373 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
374 planeTrackToTransDataIfNeeded(&init_context, framenr, &plane_track, t->aspect);
375 }
376}
377
379{
382 int width, height;
383
385
386 tc->data_len = 0;
387
388 if (!clip) {
389 return;
390 }
391
392 BKE_movieclip_get_size(clip, &sc->user, &width, &height);
393
394 if (width == 0 || height == 0) {
395 return;
396 }
397
399}
400
402
403/* -------------------------------------------------------------------- */
406
408{
410 TransDataTracking *tdt_array = static_cast<TransDataTracking *>(tc->custom.type.data);
411
412 int i = 0;
413 while (i < tc->data_len) {
414 TransDataTracking *tdt = &tdt_array[i];
415
417 MovieTrackingTrack *track = tdt->track;
419
420 BLI_assert(marker != nullptr);
421
422 marker->flag = TrackingMarkerFlag(tdt->flag);
423
424 if (track->flag & TRACK_SELECT) {
425 i++;
426 }
427
428 if (track->pat_flag & SELECT) {
429 i += 4;
430 }
431
432 if (track->search_flag & SELECT) {
433 i += 2;
434 }
435 }
436 else if (tdt->mode == transDataTracking_ModePlaneTracks) {
437 MovieTrackingPlaneTrack *plane_track = tdt->plane_track;
439 tdt->framenr);
440
441 BLI_assert(plane_marker != nullptr);
442
443 plane_marker->flag = TrackingPlaneMarkerFlag(tdt->flag);
444 i += 3;
445 }
446
447 i++;
448 }
449}
450
452{
453 TransData2D *td2d;
455 int td_index;
456
457 if (t->state == TRANS_CANCEL) {
459 }
460
462
463 /* Flush to 2d vector from internally used 3d vector. */
464 for (td_index = 0,
465 td2d = tc->data_2d,
466 tdt = static_cast<TransDataTracking *>(tc->custom.type.data);
467 td_index < tc->data_len;
468 td_index++, td2d++, tdt++)
469 {
471 float loc2d[2];
472
473 if (t->mode == TFM_ROTATION && tdt->area == TRACK_AREA_SEARCH) {
474 continue;
475 }
476
477 loc2d[0] = td2d->loc[0] / t->aspect[0];
478 loc2d[1] = td2d->loc[1] / t->aspect[1];
479
480 if (t->flag & T_ALT_TRANSFORM) {
481 if (t->mode == TFM_RESIZE) {
482 if (tdt->area != TRACK_AREA_PAT && !(t->state == TRANS_CANCEL)) {
483 continue;
484 }
485 }
486 else if (t->mode == TFM_TRANSLATION) {
487 if (tdt->area == TRACK_AREA_POINT && tdt->relative) {
488 float d[2], d2[2];
489
490 if (!tdt->smarkers) {
492 "flushTransTracking markers");
493 for (int a = 0; a < tdt->markersnr; a++) {
494 copy_v2_v2(tdt->smarkers[a], tdt->markers[a].pos);
495 }
496 }
497
498 sub_v2_v2v2(d, loc2d, tdt->soffset);
499 sub_v2_v2(d, tdt->srelative);
500
501 sub_v2_v2v2(d2, loc2d, tdt->srelative);
502
503 for (int a = 0; a < tdt->markersnr; a++) {
504 add_v2_v2v2(tdt->markers[a].pos, tdt->smarkers[a], d2);
505 }
506
507 negate_v2_v2(td2d->loc2d, d);
508 }
509 }
510 }
511
512 if (tdt->area != TRACK_AREA_POINT || tdt->relative == nullptr) {
513 td2d->loc2d[0] = loc2d[0];
514 td2d->loc2d[1] = loc2d[1];
515
516 if (tdt->relative) {
517 sub_v2_v2(td2d->loc2d, tdt->relative);
518 }
519 }
520 }
521 else if (tdt->mode == transDataTracking_ModePlaneTracks) {
522 td2d->loc2d[0] = td2d->loc[0] / t->aspect[0];
523 td2d->loc2d[1] = td2d->loc[1] / t->aspect[1];
524 }
525 }
526}
527
529{
530 SpaceClip *sc = t->area->spacedata.first_as<SpaceClip>();
531
534 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
535 const int framenr = ED_space_clip_get_clip_frame_number(sc);
536
538
539 for (MovieTrackingTrack &track : tracking_object->tracks) {
540 if (TRACK_VIEW_SELECTED(sc, &track) && (track.flag & TRACK_LOCKED) == 0) {
541 MovieTrackingMarker *marker = BKE_tracking_marker_get(&track, framenr);
542
543 if (t->mode == TFM_TRANSLATION) {
544 if (TRACK_AREA_SELECTED(&track, TRACK_AREA_PAT)) {
546 }
549 }
550 }
551 else if (t->mode == TFM_RESIZE) {
552 if (TRACK_AREA_SELECTED(&track, TRACK_AREA_PAT)) {
554 }
557 }
558 }
559 else if (t->mode == TFM_ROTATION) {
560 if (TRACK_AREA_SELECTED(&track, TRACK_AREA_PAT)) {
562 }
563 }
564 }
565 }
566
567 DEG_id_tag_update(&clip->id, 0);
568 }
569}
570
572
573/* -------------------------------------------------------------------- */
576
578{
579 SpaceClip *sc = t->area->spacedata.first_as<SpaceClip>();
581 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
582 const int framenr = ED_space_clip_get_clip_frame_number(sc);
583 /* Update coordinates of modified plane tracks. */
584 for (MovieTrackingPlaneTrack &plane_track : tracking_object->plane_tracks) {
585 bool do_update = false;
586 if (plane_track.flag & PLANE_TRACK_HIDDEN) {
587 continue;
588 }
589 do_update |= PLANE_TRACK_VIEW_SELECTED(&plane_track) != 0;
590 if (do_update == false) {
591 if ((plane_track.flag & PLANE_TRACK_AUTOKEY) == 0) {
592 int i;
593 for (i = 0; i < plane_track.point_tracksnr; i++) {
594 MovieTrackingTrack *track = plane_track.point_tracks[i];
595 if (TRACK_VIEW_SELECTED(sc, track)) {
596 do_update = true;
597 break;
598 }
599 }
600 }
601 }
602 if (do_update) {
604 }
605 }
606
608 /* Tracks can be used for stabilization nodes,
609 * flush update for such nodes.
610 */
611 if (t->context != nullptr) {
612 Main *bmain = CTX_data_main(C);
613 BKE_ntree_update_tag_id_changed(bmain, &clip->id);
614 BKE_ntree_update(*bmain);
616 }
617 }
618}
619
621
623 /*flags*/ (T_POINTS | T_2D_EDIT),
624 /*create_trans_data*/ createTransTrackingData,
625 /*recalc_data*/ recalcData_tracking,
626 /*special_aftertrans_update*/ special_aftertrans_update__movieclip,
627};
628
629} // namespace blender::ed::transform
#define SELECT
Definition BKE_mask.hh:19
#define PLANE_TRACK_VIEW_SELECTED(plane_track)
#define TRACK_VIEW_SELECTED(sc, track)
#define TRACK_AREA_SELECTED(track, area)
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define NC_SCENE
Definition WM_types.hh:391
#define ND_NODES
Definition WM_types.hh:455
bool is_enabled(const Scene &scene, ExecutionMode mode)
static void transDataTrackingFree(TransInfo *, TransDataContainer *, TransCustomData *custom_data)
static void markerToTransDataInit(TransformInitContext *init_context, MovieTrackingTrack *track, MovieTrackingMarker *marker, eTrackArea area, float loc[2], const float rel[2], const float off[2], const float aspect[2])
static void recalcData_tracking(TransInfo *t)
static void special_aftertrans_update__movieclip(bContext *C, TransInfo *t)
static void cancelTransTracking(TransInfo *t)
static void trackToTransData(TransformInitContext *init_context, const int framenr, MovieTrackingTrack *track, const float aspect[2])
static void flushTransTracking(TransInfo *t)
static void createTransTrackingTracksData(bContext *C, TransInfo *t)
static void createTransTrackingData(bContext *C, TransInfo *t)
static void trackToTransDataIfNeeded(TransformInitContext *init_context, const int framenr, MovieTrackingTrack *track, const float aspect[2])
static void planeTrackToTransData(TransformInitContext *init_context, const int framenr, MovieTrackingPlaneTrack *plane_track, const float aspect[2])
TransConvertTypeInfo TransConvertType_Tracking
static void planeMarkerToTransDataInit(TransformInitContext *init_context, MovieTrackingPlaneTrack *plane_track, MovieTrackingPlaneMarker *plane_marker, float corner[2], const float aspect[2])
static void planeTrackToTransDataIfNeeded(TransformInitContext *init_context, const int framenr, MovieTrackingPlaneTrack *plane_track, const float aspect[2])
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
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)
void BKE_ntree_update(Main &bmain, std::optional< Span< bNodeTree * > > modified_trees=std::nullopt, const NodeTreeUpdateExtraParams &params={})
void BKE_tracking_marker_clamp_search_size(MovieTrackingMarker *marker)
Definition tracking.cc:1332
void BKE_movieclip_get_size(MovieClip *clip, const MovieClipUser *user, int *r_width, int *r_height)
MINLINE void copy_v3_v3(float r[3], const float a[3])
MINLINE void add_v2_v2v2(float r[2], const float a[2], const float b[2])
void BKE_ntree_update_tag_id_changed(Main *bmain, ID *id)
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)
Definition tracking.cc:1982
SpaceClip * CTX_wm_space_clip(const bContext *C)
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
bool ED_space_clip_check_show_trackedit(const SpaceClip *sc)
void BKE_tracking_marker_clamp_pattern_position(MovieTrackingMarker *marker)
Definition tracking.cc:1313
void DEG_id_tag_update(ID *id, unsigned int flags)
MovieTrackingMarker * BKE_tracking_marker_ensure(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1407
int ED_space_clip_get_clip_frame_number(const SpaceClip *sc)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_ensure(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1854
void BKE_tracking_marker_clamp_search_position(MovieTrackingMarker *marker)
Definition tracking.cc:1343
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
@ TRACK_AREA_SEARCH
@ TRACK_AREA_POINT
Main * CTX_data_main(const bContext *C)
MovieTrackingPlaneMarker * BKE_tracking_plane_marker_get_exact(MovieTrackingPlaneTrack *plane_track, int framenr)
Definition tracking.cc:1842
void unit_m3(float m[3][3])
MovieClip * ED_space_clip_get_clip(const SpaceClip *sc)
MINLINE void sub_v2_v2(float r[2], const float a[2])
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
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct MovieTracking tracking
ListBaseT< MovieTrackingTrack > tracks
ListBaseT< MovieTrackingPlaneTrack > plane_tracks
MovieTrackingMarker * markers
ListBaseT< SpaceLink > spacedata
struct MovieClipUser user
void(*) free_cb(TransInfo *, TransDataContainer *tc, TransCustomData *custom_data)
Definition transform.hh:655
struct blender::ed::transform::TransformInitContext::@134232104214366301145040363216143134072046124257 current
#define TRANS_DATA_CONTAINER_FIRST_SINGLE(t)
Definition transform.hh:45
conversion and adaptation of different datablocks to a common struct.