Blender V5.3
clip_utils.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
8
9#include "DNA_scene_types.h"
10
11#include "BLI_listbase.hh"
12#include "BLI_math_matrix_c.hh"
13#include "BLI_math_vector_c.hh"
14#include "BLI_rect.hh"
15#include "BLI_utildefines.hh"
16
17#include "BKE_animsys.hh"
18#include "BKE_context.hh"
19#include "BKE_mask.hh"
20#include "BKE_movieclip.hh"
21#include "BKE_tracking.hh"
22
23#include "DEG_depsgraph.hh"
25
26#include "GPU_immediate.hh"
27#include "GPU_state.hh"
28
29#include "WM_api.hh"
30#include "WM_types.hh"
31
32#include "ED_clip.hh"
33#include "ED_mask.hh"
34
35#include "UI_resources.hh"
36
37#include "clip_intern.hh" /* own include */
38
39namespace blender {
40
42{
44 if ((sc->flag & SC_SHOW_GRAPH_TRACKS_MOTION) == 0) {
45 return false;
46 }
47 }
48 else if (value_source == CLIP_VALUE_SOURCE_REPROJECTION_ERROR) {
49 if ((sc->flag & SC_SHOW_GRAPH_TRACKS_ERROR) == 0) {
50 return false;
51 }
52 }
53 return true;
54}
55
57 SpaceClip *sc,
58 MovieTrackingTrack *track,
59 void *userdata,
63{
65 int width, height, coord;
66
67 BKE_movieclip_get_size(clip, &sc->user, &width, &height);
68
69 for (coord = 0; coord < 2; coord++) {
70 eClipCurveValueSource value_source = (coord == 0) ? CLIP_VALUE_SOURCE_SPEED_X :
72 int i, prevfra = track->markers[0].framenr;
73 bool open = false;
74 float prevval = 0.0f;
75
76 for (i = 0; i < track->markersnr; i++) {
77 MovieTrackingMarker *marker = &track->markers[i];
78 float val;
79
80 if (marker->flag & MARKER_DISABLED) {
81 if (open) {
82 if (segment_end) {
83 segment_end(userdata, value_source);
84 }
85
86 open = false;
87 }
88
89 continue;
90 }
91
92 if (!open) {
93 if (segment_start) {
94 if ((i + 1) == track->markersnr) {
95 segment_start(userdata, track, value_source, true);
96 }
97 else {
98 segment_start(
99 userdata, track, value_source, (track->markers[i + 1].flag & MARKER_DISABLED));
100 }
101 }
102
103 open = true;
104 prevval = marker->pos[coord];
105 }
106
107 /* value is a pixels per frame speed */
108 val = (marker->pos[coord] - prevval) * ((coord == 0) ? (width) : (height));
109 val /= marker->framenr - prevfra;
110
111 if (func) {
112 int scene_framenr = BKE_movieclip_remap_clip_to_scene_frame(clip, marker->framenr);
113
114 func(userdata, track, marker, value_source, scene_framenr, val);
115 }
116
117 prevval = marker->pos[coord];
118 prevfra = marker->framenr;
119 }
120
121 if (open) {
122 if (segment_end) {
123 segment_end(userdata, value_source);
124 }
125 }
126 }
127}
128
130 MovieTracking *tracking,
131 MovieTrackingObject *tracking_object,
132 MovieTrackingTrack *track,
133 MovieTrackingMarker *marker,
134 const int clip_width,
135 const int clip_height,
136 const int scene_framenr)
137{
138 float reprojected_position[4], bundle_position[4], marker_position[2], delta[2];
139 float weight = BKE_tracking_track_get_weight_for_marker(clip, track, marker);
140 const float aspy = 1.0f / tracking->camera.pixel_aspect;
141
142 float projection_matrix[4][4];
144 tracking, tracking_object, scene_framenr, clip_width, clip_height, projection_matrix);
145
146 copy_v3_v3(bundle_position, track->bundle_pos);
147 bundle_position[3] = 1;
148
149 mul_v4_m4v4(reprojected_position, projection_matrix, bundle_position);
150 reprojected_position[0] = (reprojected_position[0] / (reprojected_position[3] * 2.0f) + 0.5f) *
151 clip_width;
152 reprojected_position[1] = (reprojected_position[1] / (reprojected_position[3] * 2.0f) + 0.5f) *
153 clip_height * aspy;
154
156 tracking, clip_width, clip_height, reprojected_position, reprojected_position);
157
158 marker_position[0] = (marker->pos[0] + track->offset[0]) * clip_width;
159 marker_position[1] = (marker->pos[1] + track->offset[1]) * clip_height * aspy;
160
161 sub_v2_v2v2(delta, reprojected_position, marker_position);
162 return len_v2(delta) * weight;
163}
164
166 SpaceClip *sc,
167 MovieTrackingTrack *track,
168 void *userdata,
172{
173 /* Tracks without bundle can not have any reprojection error curve. */
174 if ((track->flag & TRACK_HAS_BUNDLE) == 0) {
175 return;
176 }
177
179 MovieTracking *tracking = &clip->tracking;
180 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
181
182 int clip_width, clip_height;
183 BKE_movieclip_get_size(clip, &sc->user, &clip_width, &clip_height);
184
185 /* Iterate over segments. */
186 bool is_segment_open = false;
187 for (int marker_index = 0; marker_index < track->markersnr; marker_index++) {
188 MovieTrackingMarker *marker = &track->markers[marker_index];
189
190 /* End of tracked segment, no reprojection error can be calculated here since the ground truth
191 * 2D position is not known. */
192 if (marker->flag & MARKER_DISABLED) {
193 if (is_segment_open) {
194 if (segment_end != nullptr) {
195 segment_end(userdata, CLIP_VALUE_SOURCE_REPROJECTION_ERROR);
196 }
197 is_segment_open = false;
198 }
199 continue;
200 }
201
202 /* Begin new segment if it is not open yet. */
203 if (!is_segment_open) {
204 if (segment_start != nullptr) {
205 if ((marker_index + 1) == track->markersnr) {
206 segment_start(userdata, track, CLIP_VALUE_SOURCE_REPROJECTION_ERROR, true);
207 }
208 else {
209 segment_start(userdata,
210 track,
212 (track->markers[marker_index + 1].flag & MARKER_DISABLED));
213 }
214 }
215 is_segment_open = true;
216 }
217
218 if (func != nullptr) {
219 const int scene_framenr = BKE_movieclip_remap_clip_to_scene_frame(clip, marker->framenr);
220 const float reprojection_error = calculate_reprojection_error_at_marker(
221 clip, tracking, tracking_object, track, marker, clip_width, clip_height, scene_framenr);
222 func(userdata,
223 track,
224 marker,
226 scene_framenr,
227 reprojection_error);
228 }
229 }
230
231 if (is_segment_open && segment_end != nullptr) {
232 segment_end(userdata, CLIP_VALUE_SOURCE_REPROJECTION_ERROR);
233 }
234}
235
237 MovieTrackingTrack *track,
238 void *userdata,
242{
244 sc, track, userdata, func, segment_start, segment_end);
245
247 sc, track, userdata, func, segment_start, segment_end);
248}
249
251 bool selected_only,
252 bool include_hidden,
253 void *userdata,
257{
259 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
260
261 for (MovieTrackingTrack &track : tracking_object->tracks) {
262 if (!include_hidden && (track.flag & TRACK_HIDDEN) != 0) {
263 continue;
264 }
265
266 if (selected_only && !TRACK_SELECTED(&track)) {
267 continue;
268 }
269
271 sc, &track, userdata, func, segment_start, segment_end);
272 }
273}
274
276 bool selected_only,
277 bool include_hidden,
278 void *userdata,
279 void (*func)(void *userdata, MovieTrackingMarker *marker))
280{
282 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
283
284 for (MovieTrackingTrack &track : tracking_object->tracks) {
285 if (!include_hidden && (track.flag & TRACK_HIDDEN) != 0) {
286 continue;
287 }
288
289 if (selected_only && !TRACK_SELECTED(&track)) {
290 continue;
291 }
292
293 for (int i = 0; i < track.markersnr; i++) {
294 MovieTrackingMarker *marker = &track.markers[i];
295
296 if (marker->flag & MARKER_DISABLED) {
297 continue;
298 }
299
300 if (func) {
301 func(userdata, marker);
302 }
303 }
304 }
305}
306
308{
309 MovieTracking *tracking = &clip->tracking;
310 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
311 bool has_bundle = false;
312 const bool used_for_stabilization = (track->flag &
314 if (track == tracking_object->active_track) {
315 tracking_object->active_track = nullptr;
316 }
317 /* Handle reconstruction display in 3d viewport. */
318 if (track->flag & TRACK_HAS_BUNDLE) {
319 has_bundle = true;
320 }
321 /* Make sure no plane will use freed track */
323 /* Delete f-curves associated with the track (such as weight, i.e.) */
324 /* Escaped object name, escaped track name, rest of the path. */
325 char rna_path[MAX_NAME * 4 + 64];
326 BKE_tracking_get_rna_path_for_track(tracking, track, rna_path, sizeof(rna_path));
329 }
330 /* Delete track itself. */
332 BLI_freelinkN(&tracking_object->tracks, track);
333 /* Send notifiers. */
335 if (used_for_stabilization) {
337 }
338 /* Inform dependency graph. */
339 DEG_id_tag_update(&clip->id, 0);
340 if (has_bundle) {
342 }
343}
344
346 MovieClip *clip,
347 MovieTrackingTrack *track,
348 MovieTrackingMarker *marker)
349{
350 if (track->markersnr == 1) {
351 clip_delete_track(C, clip, track);
352 }
353 else {
354 BKE_tracking_marker_delete(track, marker->framenr);
355
357 }
358}
359
361{
362 MovieTracking *tracking = &clip->tracking;
364
365 if (plane_track == tracking_object->active_plane_track) {
366 tracking_object->active_plane_track = nullptr;
367 }
368
369 /* Delete f-curves associated with the track (such as weight, i.e.) */
370 /* Escaped object name, escaped track name, rest of the path. */
371 char rna_path[MAX_NAME * 4 + 64];
372 BKE_tracking_get_rna_path_for_plane_track(tracking, plane_track, rna_path, sizeof(rna_path));
375 }
376 /* Delete the plane track itself. */
378 BLI_freelinkN(&tracking_object->plane_tracks, plane_track);
379 /* TODO(sergey): Any notifiers to be sent here? */
380 (void)C;
381 /* Inform dependency graph. */
382 DEG_id_tag_update(&clip->id, 0);
383}
384
386 SpaceClip *sc, const float x, const float y, float *r_offset_x, float *r_offset_y)
387{
388 int width, height;
389 ED_space_clip_get_size(sc, &width, &height);
390
391 float aspx, aspy;
392 ED_space_clip_get_aspect(sc, &aspx, &aspy);
393
394 *r_offset_x = (x - 0.5f) * width * aspx;
395 *r_offset_y = (y - 0.5f) * height * aspy;
396}
397
398void clip_view_center_to_point(SpaceClip *sc, float x, float y)
399{
401}
402
403static bool selected_tracking_boundbox(SpaceClip *sc, float min[2], float max[2])
404{
406 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
407 const int framenr = ED_space_clip_get_clip_frame_number(sc);
408 int width, height;
409 bool ok = false;
410
412
413 ED_space_clip_get_size(sc, &width, &height);
414
415 for (MovieTrackingTrack &track : tracking_object->tracks) {
416 if (TRACK_VIEW_SELECTED(sc, &track)) {
417 MovieTrackingMarker *marker = BKE_tracking_marker_get(&track, framenr);
418
419 if (marker) {
420 float pos[3];
421
422 pos[0] = marker->pos[0] + track.offset[0];
423 pos[1] = marker->pos[1] + track.offset[1];
424 pos[2] = 0.0f;
425
426 /* undistortion happens for normalized coords */
428 /* undistortion happens for normalized coords */
429 ED_clip_point_undistorted_pos(sc, pos, pos);
430 }
431
432 pos[0] *= width;
433 pos[1] *= height;
434
435 mul_v3_m4v3(pos, sc->stabmat, pos);
436
437 minmax_v2v2_v2(min, max, pos);
438
439 ok = true;
440 }
441 }
442 }
443
444 return ok;
445}
446
447static bool tracking_has_selection(SpaceClip *space_clip)
448{
449 MovieClip *clip = ED_space_clip_get_clip(space_clip);
450 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
451 const int framenr = ED_space_clip_get_clip_frame_number(space_clip);
452
453 for (MovieTrackingTrack &track : tracking_object->tracks) {
454 if (!TRACK_VIEW_SELECTED(space_clip, &track)) {
455 continue;
456 }
457 const MovieTrackingMarker *marker = BKE_tracking_marker_get(&track, framenr);
458 if (marker != nullptr) {
459 return true;
460 }
461 }
462
463 return false;
464}
465
466static bool mask_has_selection(const bContext *C)
467{
469 if (mask == nullptr) {
470 return false;
471 }
472
473 for (MaskLayer &mask_layer : mask->masklayers) {
474 if (mask_layer.visibility_flag & (MASK_HIDE_VIEW | MASK_HIDE_SELECT)) {
475 continue;
476 }
477 for (MaskSpline &spline : mask_layer.splines) {
478 for (int i = 0; i < spline.tot_point; i++) {
479 const MaskSplinePoint *point = &spline.points[i];
480 const BezTriple *bezt = &point->bezt;
481 if (!BKE_mask_point_selected(point)) {
482 continue;
483 }
484 if (bezt->f2 & SELECT) {
485 return true;
486 }
487
489 return true;
490 }
491
492 if ((bezt->f1 & SELECT) && (bezt->h1 != HD_VECT)) {
493 return true;
494 }
495 if ((bezt->f3 & SELECT) && (bezt->h2 != HD_VECT)) {
496 return true;
497 }
498 }
499 }
500 }
501
502 return false;
503}
504
505static bool selected_boundbox(const bContext *C, float min[2], float max[2], bool handles_as_knot)
506{
508 if (sc->mode == SC_MODE_TRACKING) {
510 }
511
512 if (ED_mask_selected_minmax(C, min, max, handles_as_knot, false)) {
514 int width, height;
515 ED_space_clip_get_size(sc, &width, &height);
518 min[0] *= width;
519 min[1] *= height;
520 max[0] *= width;
521 max[1] *= height;
522 return true;
523 }
524 return false;
525}
526
528 const bContext *C, bool fit, float *r_offset_x, float *r_offset_y, float *r_zoom)
529{
531
532 int frame_width, frame_height;
533 ED_space_clip_get_size(sc, &frame_width, &frame_height);
534
535 if ((frame_width == 0) || (frame_height == 0) || (sc->clip == nullptr)) {
536 return false;
537 }
538
539 /* NOTE: The `fit` argument is set to truth when doing "View to Selected" operator, and it set to
540 * false when this function is used for Lock-to-Selection functionality. When locking to
541 * selection the handles are to use the knot position.
542 * So we can derive `handles_as_knot` from `fit`.
543 *
544 * TODO(sergey): Make such decision more explicit. Maybe pass use-case for the calculation to
545 * tell operator from lock-to-selection apart. */
546 float min[2], max[2];
547 if (!selected_boundbox(C, min, max, !fit)) {
548 return false;
549 }
550
551 /* center view */
553 (max[0] + min[0]) / (2 * frame_width),
554 (max[1] + min[1]) / (2 * frame_height),
555 r_offset_x,
556 r_offset_y);
557
558 const int w = max[0] - min[0];
559 const int h = max[1] - min[1];
560
561 /* set zoom to see all selection */
562 *r_zoom = sc->zoom;
563 if (w > 0 && h > 0) {
564 ARegion *region = CTX_wm_region(C);
565
566 int width, height;
567 float zoomx, zoomy, newzoom, aspx, aspy;
568
569 ED_space_clip_get_aspect(sc, &aspx, &aspy);
570
571 width = BLI_rcti_size_x(&region->winrct) + 1;
572 height = BLI_rcti_size_y(&region->winrct) + 1;
573
574 zoomx = float(width) / w / aspx;
575 zoomy = float(height) / h / aspy;
576
577 newzoom = 1.0f / power_of_2(1.0f / min_ff(zoomx, zoomy));
578
579 if (fit) {
580 *r_zoom = newzoom;
581 }
582 }
583
584 return true;
585}
586
588{
589 SpaceClip *space_clip = CTX_wm_space_clip(C);
590
591 if ((space_clip->flag & SC_LOCK_SELECTION) == 0) {
592 return false;
593 }
594
595 if (space_clip->mode == SC_MODE_TRACKING) {
596 return tracking_has_selection(space_clip);
597 }
598
599 return mask_has_selection(C);
600}
601
602} // namespace blender
#define SELECT
Definition BKE_mask.hh:19
#define TRACK_SELECTED(track)
#define TRACK_VIEW_SELECTED(sc, track)
#define MAX_NAME
Definition DNA_defs.h:63
#define C
Definition RandGen.cpp:29
#define ND_DISPLAY
Definition WM_types.hh:534
#define NC_MOVIECLIP
Definition WM_types.hh:410
#define NA_EDITED
Definition WM_types.hh:634
#define ND_SPACE_VIEW3D
Definition WM_types.hh:571
#define NC_SPACE
Definition WM_types.hh:405
#define INIT_MINMAX2(min, max)
#define ELEM(...)
btScalar max
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
BMesh Iterators.
MINLINE float min_ff(float a, float b)
void clip_delete_plane_track(bContext *C, MovieClip *clip, MovieTrackingPlaneTrack *plane_track)
void ED_space_clip_get_size(const SpaceClip *sc, int *r_width, int *r_height)
void(*)(void *userdata, eClipCurveValueSource value_source) ClipTrackValueSegmentEndCallback
void BKE_tracking_get_projection_matrix(MovieTracking *tracking, MovieTrackingObject *tracking_object, int framenr, int winx, int winy, float mat[4][4])
Definition tracking.cc:388
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])
void BKE_tracking_plane_tracks_remove_point_track(MovieTracking *tracking, MovieTrackingTrack *track)
Definition tracking.cc:1681
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
Definition tracking.cc:1982
void ED_clip_point_undistorted_pos(const SpaceClip *sc, const float co[2], float r_co[2])
SpaceClip * CTX_wm_space_clip(const bContext *C)
static void clip_graph_tracking_values_iterate_track_reprojection_error_values(SpaceClip *sc, MovieTrackingTrack *track, void *userdata, ClipTrackValueCallback func, ClipTrackValueSegmentStartCallback segment_start, ClipTrackValueSegmentEndCallback segment_end)
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
bool clip_view_calculate_view_selection(const bContext *C, bool fit, float *r_offset_x, float *r_offset_y, float *r_zoom)
static bool mask_has_selection(const bContext *C)
@ MCLIP_PROXY_RENDER_UNDISTORT
static float calculate_reprojection_error_at_marker(MovieClip *clip, MovieTracking *tracking, MovieTrackingObject *tracking_object, MovieTrackingTrack *track, MovieTrackingMarker *marker, const int clip_width, const int clip_height, const int scene_framenr)
bool clip_graph_value_visible(SpaceClip *sc, eClipCurveValueSource value_source)
Definition clip_utils.cc:41
static bool selected_boundbox(const bContext *C, float min[2], float max[2], bool handles_as_knot)
void clip_view_offset_for_center_to_point(SpaceClip *sc, float x, float y, float *r_offset_x, float *r_offset_y)
void clip_graph_tracking_values_iterate_track(SpaceClip *sc, MovieTrackingTrack *track, void *userdata, ClipTrackValueCallback func, ClipTrackValueSegmentStartCallback segment_start, ClipTrackValueSegmentEndCallback segment_end)
bool BKE_animdata_fix_paths_remove(ID *id, const char *prefix)
eClipCurveValueSource
@ CLIP_VALUE_SOURCE_SPEED_Y
@ CLIP_VALUE_SOURCE_SPEED_X
@ CLIP_VALUE_SOURCE_REPROJECTION_ERROR
void clip_delete_track(bContext *C, MovieClip *clip, MovieTrackingTrack *track)
void ED_space_clip_get_aspect(const SpaceClip *sc, float *r_aspx, float *r_aspy)
void BKE_tracking_get_rna_path_for_plane_track(const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track, char *rna_path, size_t rna_path_maxncpy)
Definition tracking.cc:3445
void BKE_tracking_get_rna_path_for_track(const MovieTracking *tracking, const MovieTrackingTrack *track, char *rna_path, size_t rna_path_maxncpy)
Definition tracking.cc:3407
void BKE_mask_coord_to_movieclip(MovieClip *clip, MovieClipUser *user, float r_co[2], const float co[2])
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
Definition BLI_rect.hh:207
@ SC_SHOW_GRAPH_TRACKS_MOTION
@ SC_SHOW_GRAPH_TRACKS_ERROR
bool BKE_mask_point_selected(const MaskSplinePoint *p)
Definition BKE_mask.hh:155
void minmax_v2v2_v2(float min[2], float max[2], const float vec[2])
static bool tracking_has_selection(SpaceClip *space_clip)
void DEG_id_tag_update(ID *id, unsigned int flags)
int ED_space_clip_get_clip_frame_number(const SpaceClip *sc)
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
MINLINE float power_of_2(float f)
bool clip_view_has_locked_selection(const bContext *C)
Mask * CTX_data_edit_mask(const bContext *C)
void clip_graph_tracking_iterate(SpaceClip *sc, bool selected_only, bool include_hidden, void *userdata, void(*func)(void *userdata, MovieTrackingMarker *marker))
static void clip_graph_tracking_values_iterate_track_speed_values(SpaceClip *sc, MovieTrackingTrack *track, void *userdata, ClipTrackValueCallback func, ClipTrackValueSegmentStartCallback segment_start, ClipTrackValueSegmentEndCallback segment_end)
Definition clip_utils.cc:56
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
Definition BLI_rect.hh:203
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void(*)(void *userdata, MovieTrackingTrack *track, eClipCurveValueSource value_source, bool is_point) ClipTrackValueSegmentStartCallback
void BKE_tracking_marker_delete(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1286
void BKE_tracking_track_free(MovieTrackingTrack *track)
Definition tracking.cc:598
void clip_graph_tracking_values_iterate(SpaceClip *sc, bool selected_only, bool include_hidden, void *userdata, ClipTrackValueCallback func, ClipTrackValueSegmentStartCallback segment_start, ClipTrackValueSegmentEndCallback segment_end)
Main * CTX_data_main(const bContext *C)
MovieClip * ED_space_clip_get_clip(const SpaceClip *sc)
void BKE_tracking_plane_track_free(MovieTrackingPlaneTrack *plane_track)
Definition tracking.cc:1631
static bool selected_tracking_boundbox(SpaceClip *sc, float min[2], float max[2])
void clip_delete_marker(bContext *C, MovieClip *clip, MovieTrackingTrack *track, MovieTrackingMarker *marker)
void DEG_relations_tag_update(Main *bmain)
float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
bool ED_mask_selected_minmax(const bContext *C, float min[2], float max[2], bool handles_as_knot, bool handles_as_knot_selected_only)
void(*)(void *userdata, MovieTrackingTrack *track, MovieTrackingMarker *marker, eClipCurveValueSource value_source, int scene_framenr, float val) ClipTrackValueCallback
MINLINE float len_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
float BKE_tracking_track_get_weight_for_marker(MovieClip *clip, MovieTrackingTrack *track, MovieTrackingMarker *marker)
Definition tracking.cc:1177
eMaskhandleMode BKE_mask_point_handles_mode_get(const MaskSplinePoint *point)
ARegion * CTX_wm_region(const bContext *C)
void BKE_tracking_distort_v2(MovieTracking *tracking, int image_width, int image_height, const float co[2], float r_co[2])
Definition tracking.cc:2421
@ MASK_HANDLE_MODE_STICK
Definition BKE_mask.hh:53
void mul_v4_m4v4(float r[4], const float mat[4][4], const float v[4])
void clip_view_center_to_point(SpaceClip *sc, float x, float y)
MovieTrackingMarker * BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
Definition tracking.cc:1363
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
#define min(a, b)
Definition sort.cc:38
eBezTriple_Flag f2
eBezTriple_Handle h2
eBezTriple_Flag f3
eBezTriple_Flag f1
eBezTriple_Handle h1
MaskLayerVisibility visibility_flag
ListBaseT< MaskSpline > splines
MaskSplinePoint * points
eMovieClipProxy_RenderFlag render_flag
struct MovieTracking tracking
MovieTrackingPlaneTrack * active_plane_track
ListBaseT< MovieTrackingTrack > tracks
ListBaseT< MovieTrackingPlaneTrack > plane_tracks
MovieTrackingTrack * active_track
MovieTrackingMarker * markers
MovieTrackingCamera camera
struct MovieClip * clip
eSpaceClip_Flag flag
eSpaceClip_Mode mode
struct MovieClipUser user