Blender V5.3
tracking_ops_plane.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 "MEM_guardedalloc.h"
10
11#include "DNA_screen_types.h"
12#include "DNA_space_types.h"
13
14#include "BLI_math_geom_c.hh"
15#include "BLI_math_vector_c.hh"
16#include "BLI_utildefines.hh"
17
18#include "BKE_context.hh"
19#include "BKE_report.hh"
20#include "BKE_tracking.hh"
21
22#include "DEG_depsgraph.hh"
23
24#include "WM_api.hh"
25#include "WM_types.hh"
26
27#include "ED_clip.hh"
28
29#include "clip_intern.hh"
31
32namespace blender {
33
34/********************** Create plane track operator *********************/
35
37{
40 MovieTracking *tracking = &clip->tracking;
41 MovieTrackingPlaneTrack *plane_track;
42 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
44
45 plane_track = BKE_tracking_plane_track_add(
46 tracking, &tracking_object->plane_tracks, &tracking_object->tracks, framenr);
47
48 if (plane_track == nullptr) {
49 BKE_report(op->reports, RPT_ERROR, "Need at least 4 selected point tracks to create a plane");
50 return OPERATOR_CANCELLED;
51 }
52
54
55 plane_track->flag |= PLANE_TRACK_SELECT;
56 tracking_object->active_track = nullptr;
57 tracking_object->active_plane_track = plane_track;
58
59 /* Compute homographies and apply them on marker's corner, so we've got
60 * quite nice motion from the very beginning.
61 */
63
66
67 return OPERATOR_FINISHED;
68}
69
71{
72 /* identifiers */
73 ot->name = "Create Plane Track";
74 ot->description = "Create new plane track out of selected point tracks";
75 ot->idname = "CLIP_OT_create_plane_track";
76
77 /* API callbacks. */
80
81 /* flags */
83}
84
85/********************** Slide plane marker corner operator *********************/
86
99
101 const wmEvent *event,
102 int *r_corner)
103{
104 SpaceClip *space_clip = CTX_wm_space_clip(C);
105 ARegion *region = CTX_wm_region(C);
106
107 float co[2];
108 ED_clip_mouse_pos(space_clip, region, event->mval, co);
109
111 options.selected_only = true;
112 options.unlocked_only = true;
113 options.enabled_only = true;
114 const PlaneTrackPick track_pick = ed_tracking_pick_plane_track(&options, C, co);
115
116 if (ed_tracking_plane_track_pick_empty(&track_pick) ||
118 {
119 return nullptr;
120 }
121
122 if (r_corner != nullptr) {
123 *r_corner = track_pick.corner_index;
124 }
125
126 return track_pick.plane_track;
127}
128
130{
132 ARegion *region = CTX_wm_region(C);
133 MovieTrackingPlaneTrack *plane_track;
134 int width, height;
135 float co[2];
136 SlidePlaneMarkerData *customdata = nullptr;
137 int framenr = ED_space_clip_get_clip_frame_number(sc);
138 int corner;
139
140 ED_space_clip_get_size(sc, &width, &height);
141 if (width == 0 || height == 0) {
142 return nullptr;
143 }
144
145 ED_clip_mouse_pos(sc, region, event->mval, co);
146
147 plane_track = tracking_plane_marker_check_slide(C, event, &corner);
148 if (plane_track) {
149 MovieTrackingPlaneMarker *plane_marker;
150
151 customdata = MEM_new_zeroed<SlidePlaneMarkerData>("slide plane marker data");
152
154
155 plane_marker = BKE_tracking_plane_marker_ensure(plane_track, framenr);
156
157 customdata->plane_track = plane_track;
158 customdata->plane_marker = plane_marker;
159 customdata->width = width;
160 customdata->height = height;
161
162 customdata->previous_mval[0] = event->mval[0];
163 customdata->previous_mval[1] = event->mval[1];
164
165 customdata->corner_index = corner;
166 customdata->corner = plane_marker->corners[corner];
167
168 copy_v2_v2(customdata->previous_corner, customdata->corner);
169 copy_v2_v2(customdata->old_corner, customdata->corner);
170 }
171
172 return customdata;
173}
174
176 wmOperator *op,
177 const wmEvent *event)
178{
180
181 if (slidedata) {
184 MovieTracking *tracking = &clip->tracking;
185 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
186
187 tracking_object->active_plane_track = slidedata->plane_track;
188 tracking_object->active_track = nullptr;
189
190 op->customdata = slidedata;
191
194
196
198 }
199
201}
202
204{
205 copy_v2_v2(data->corner, data->old_corner);
206}
207
209{
210 MEM_delete(data);
211}
212
219
221{
225 float dx, dy, mdelta[2];
226 int next_corner_index, prev_corner_index, diag_corner_index;
227 const float *next_corner, *prev_corner, *diag_corner;
228 float next_edge[2], prev_edge[2], next_diag_edge[2], prev_diag_edge[2];
229
230 switch (event->type) {
231 case EVT_LEFTCTRLKEY:
232 case EVT_RIGHTCTRLKEY:
233 case EVT_LEFTSHIFTKEY:
236 data->accurate = event->val == KM_PRESS;
237 }
239 case MOUSEMOVE:
240 mdelta[0] = event->mval[0] - data->previous_mval[0];
241 mdelta[1] = event->mval[1] - data->previous_mval[1];
242
243 dx = mdelta[0] / data->width / sc->zoom;
244 dy = mdelta[1] / data->height / sc->zoom;
245
246 if (data->accurate) {
247 dx /= 5.0f;
248 dy /= 5.0f;
249 }
250
251 data->corner[0] = data->previous_corner[0] + dx;
252 data->corner[1] = data->previous_corner[1] + dy;
253
254 /*
255 * prev_edge
256 * (Corner 3, current) <----------------------- (Corner 2, previous)
257 * | ^
258 * | |
259 * | |
260 * | |
261 * next_edge | | next_diag_edge
262 * | |
263 * | |
264 * | |
265 * v |
266 * (Corner 0, next) -----------------------> (Corner 1, diagonal)
267 * prev_diag_edge
268 */
269
270 next_corner_index = (data->corner_index + 1) % 4;
271 prev_corner_index = (data->corner_index + 3) % 4;
272 diag_corner_index = (data->corner_index + 2) % 4;
273
274 next_corner = data->plane_marker->corners[next_corner_index];
275 prev_corner = data->plane_marker->corners[prev_corner_index];
276 diag_corner = data->plane_marker->corners[diag_corner_index];
277
278 sub_v2_v2v2(next_edge, next_corner, data->corner);
279 sub_v2_v2v2(prev_edge, data->corner, prev_corner);
280 sub_v2_v2v2(next_diag_edge, prev_corner, diag_corner);
281 sub_v2_v2v2(prev_diag_edge, diag_corner, next_corner);
282
283 if (cross_v2v2(prev_edge, next_edge) < 0.0f) {
284 closest_to_line_v2(data->corner, data->corner, prev_corner, next_corner);
285 }
286
287 if (cross_v2v2(next_diag_edge, prev_edge) < 0.0f) {
288 closest_to_line_v2(data->corner, data->corner, prev_corner, diag_corner);
289 }
290
291 if (cross_v2v2(next_edge, prev_diag_edge) < 0.0f) {
292 closest_to_line_v2(data->corner, data->corner, next_corner, diag_corner);
293 }
294
295 data->previous_mval[0] = event->mval[0];
296 data->previous_mval[1] = event->mval[1];
297 copy_v2_v2(data->previous_corner, data->corner);
298
301
302 break;
303
304 case LEFTMOUSE:
305 case RIGHTMOUSE:
306 if (event->type == data->launch_event && event->val == KM_RELEASE) {
307 /* Marker is now keyframed. */
308 data->plane_marker->flag &= ~PLANE_MARKER_TRACKED;
309
311
313
315
318
319 return OPERATOR_FINISHED;
320 }
321
322 break;
323
324 case EVT_ESCKEY:
326
328
330
332
333 return OPERATOR_CANCELLED;
334 default: {
335 break;
336 }
337 }
338
340}
341
343{
344 /* identifiers */
345 ot->name = "Slide Plane Marker";
346 ot->description = "Slide plane marker areas";
347 ot->idname = "CLIP_OT_slide_plane_marker";
348
349 /* API callbacks. */
353
354 /* flags */
356}
357
358} // namespace blender
#define ATTR_FALLTHROUGH
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define NC_GEOM
Definition WM_types.hh:406
#define NC_MOVIECLIP
Definition WM_types.hh:410
#define NA_EDITED
Definition WM_types.hh:634
#define ND_SELECT
Definition WM_types.hh:551
#define ELEM(...)
CCL_NAMESPACE_BEGIN struct Options options
BMesh Iterators.
void CLIP_OT_create_plane_track(wmOperatorType *ot)
void ED_space_clip_get_size(const SpaceClip *sc, int *r_width, int *r_height)
void BKE_tracking_track_plane_from_existing_motion(MovieTrackingPlaneTrack *plane_track, int start_frame)
MINLINE float cross_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT
static MovieTrackingPlaneTrack * tracking_plane_marker_check_slide(bContext *C, const wmEvent *event, int *r_corner)
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
void clip_tracking_hide_cursor(bContext *C)
SpaceClip * CTX_wm_space_clip(const bContext *C)
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
static SlidePlaneMarkerData * slide_plane_marker_customdata(bContext *C, const wmEvent *event)
static wmOperatorStatus create_plane_track_tracks_exec(bContext *C, wmOperator *op)
void CLIP_OT_slide_plane_marker(wmOperatorType *ot)
static wmOperatorStatus slide_plane_marker_modal(bContext *C, wmOperator *op, const wmEvent *event)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
static void free_slide_plane_marker_data(SlidePlaneMarkerData *data)
void DEG_id_tag_update(ID *id, unsigned int flags)
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
BMesh const char void * data
BLI_INLINE TrackPickOptions ed_tracking_pick_options_defaults()
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 ED_clip_mouse_pos(const SpaceClip *sc, const ARegion *region, const int mval[2], float r_co[2])
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void clip_tracking_show_cursor(bContext *C)
void BKE_tracking_tracks_deselect_all(ListBaseT< MovieTrackingTrack > *tracksbase)
Definition tracking.cc:1227
PlaneTrackPick ed_tracking_pick_plane_track(const TrackPickOptions *options, struct bContext *C, const float co[2])
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
bool ed_tracking_plane_track_pick_can_slide(const PlaneTrackPick *pick)
MovieClip * ED_space_clip_get_clip(const SpaceClip *sc)
static wmOperatorStatus slide_plane_marker_invoke(bContext *C, wmOperator *op, const wmEvent *event)
@ ID_RECALC_SYNC_TO_EVAL
Definition DNA_ID.h:1118
MovieTrackingPlaneTrack * BKE_tracking_plane_track_add(MovieTracking *tracking, ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base, ListBaseT< MovieTrackingTrack > *tracks, int framenr)
Definition tracking.cc:1547
float closest_to_line_v2(float r_close[2], const float p[2], const float l1[2], const float l2[2])
@ KM_RELEASE
Definition WM_types.hh:325
bool ED_space_clip_tracking_poll(bContext *C)
BLI_INLINE bool ed_tracking_plane_track_pick_empty(const PlaneTrackPick *pick)
static void slide_plane_marker_update_homographies(SpaceClip *sc, SlidePlaneMarkerData *data)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
@ OPTYPE_BLOCKING
Definition WM_types.hh:192
@ OPTYPE_GRAB_CURSOR_XY
Definition WM_types.hh:196
static void cancel_mouse_slide_plane_marker(SlidePlaneMarkerData *data)
int WM_userdef_event_type_from_keymap_type(int kmitype)
ARegion * CTX_wm_region(const bContext *C)
struct MovieTracking tracking
MovieTrackingPlaneTrack * active_plane_track
ListBaseT< MovieTrackingTrack > tracks
ListBaseT< MovieTrackingPlaneTrack > plane_tracks
MovieTrackingTrack * active_track
MovieTrackingPlaneTrack * plane_track
MovieTrackingPlaneMarker * plane_marker
MovieTrackingPlaneTrack * plane_track
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
struct ReportList * reports