Blender V5.3
tracking_ops_solve.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 "DNA_camera_types.h"
12#include "DNA_object_types.h" /* SELECT */
13#include "DNA_screen_types.h"
14#include "DNA_space_types.h"
15
16#include "BLI_listbase.hh"
17#include "BLI_string_utf8.hh"
18
19#include "BKE_context.hh"
20#include "BKE_global.hh"
21#include "BKE_lib_id.hh"
22#include "BKE_movieclip.hh"
23#include "BKE_report.hh"
24#include "BKE_tracking.hh"
25
26#include "DEG_depsgraph.hh"
27
28#include "WM_api.hh"
29#include "WM_types.hh"
30
31#include "ED_clip.hh"
32
33#include "clip_intern.hh"
34
35namespace blender {
36
37/********************** solve camera operator *********************/
38
40 wmWindowManager *wm = nullptr;
41 Scene *scene = nullptr;
42 MovieClip *clip = nullptr;
44
45 ReportList *reports = nullptr;
46
47 char stats_message[256] = "";
48
50};
51
53 bContext *C, SolveCameraJob *scj, wmOperator *op, char *error_msg, int max_error)
54{
57 Scene *scene = CTX_data_scene(C);
58 MovieTracking *tracking = &clip->tracking;
59 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
60 int width, height;
61
62 if (!BKE_tracking_reconstruction_check(tracking, tracking_object, error_msg, max_error)) {
63 return false;
64 }
65
66 /* Could fail if footage uses images with different sizes. */
67 BKE_movieclip_get_size(clip, &sc->user, &width, &height);
68
69 scj->wm = CTX_wm_manager(C);
70 scj->clip = clip;
71 scj->scene = scene;
72 scj->reports = op->reports;
73 scj->user = sc->user;
74
76 tracking_object,
77 tracking_object->keyframe1,
78 tracking_object->keyframe2,
79 width,
80 height);
81
82 tracking->stats = MEM_new<MovieTrackingStats>("solve camera stats");
83
84 WM_locked_interface_set(scj->wm, true);
85
86 return true;
87}
88
89static void solve_camera_updatejob(void *scv)
90{
91 SolveCameraJob *scj = static_cast<SolveCameraJob *>(scv);
92 MovieTracking *tracking = &scj->clip->tracking;
93
94 STRNCPY_UTF8(tracking->stats->message, scj->stats_message);
95}
96
97static void solve_camera_startjob(void *scv, wmJobWorkerStatus *worker_status)
98{
99 SolveCameraJob *scj = static_cast<SolveCameraJob *>(scv);
101 &worker_status->stop,
102 &worker_status->do_update,
103 &worker_status->progress,
104 scj->stats_message,
105 sizeof(scj->stats_message));
106}
107
108static void solve_camera_freejob(void *scv)
109{
110 SolveCameraJob *scj = static_cast<SolveCameraJob *>(scv);
111 MovieTracking *tracking = &scj->clip->tracking;
112 Scene *scene = scj->scene;
113 MovieClip *clip = scj->clip;
114 int solved;
115
116 /* WindowManager is missing in the job when initialization is incomplete.
117 * In this case the interface is not locked either. */
118 if (scj->wm != nullptr) {
119 WM_locked_interface_set(scj->wm, false);
120 }
121
122 if (!scj->context) {
123 /* job weren't fully initialized due to some error */
124 MEM_delete(scj);
125 return;
126 }
127
128 solved = BKE_tracking_reconstruction_finish(scj->context, tracking);
129 if (!solved) {
130 const char *error_message = BKE_tracking_reconstruction_error_message_get(scj->context);
131 if (error_message[0]) {
132 BKE_report(scj->reports, RPT_ERROR, error_message);
133 }
134 else {
136 scj->reports, RPT_WARNING, "Some data failed to reconstruct (see console for details)");
137 }
138 }
139 else {
140 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
141 BKE_reportf(scj->reports,
142 RPT_INFO,
143 "Average re-projection error: %.2f px",
144 tracking_object->reconstruction.error);
145 }
146
147 /* Set currently solved clip as active for scene. */
148 if (scene->clip != nullptr) {
149 id_us_min(&clip->id);
150 }
151 scene->clip = clip;
152 id_us_plus(&clip->id);
153
154 /* Set blender camera focal length so result would look fine there. */
155 if (scene->camera != nullptr && scene->camera->data &&
156 GS(((ID *)scene->camera->data)->name) == ID_CA)
157 {
158 Camera *camera = id_cast<Camera *>(scene->camera->data);
159 int width, height;
160 BKE_movieclip_get_size(clip, &scj->user, &width, &height);
161 BKE_tracking_camera_to_blender(tracking, scene, camera, width, height);
164 }
165
166 MEM_delete(tracking->stats);
167 tracking->stats = nullptr;
168
169 DEG_id_tag_update(&clip->id, 0);
170
173
174 /* Update active clip displayed in scene buttons. */
176
178 MEM_delete(scj);
179}
180
182{
183 SolveCameraJob *scj;
184 char error_msg[256] = "\0";
185 scj = MEM_new<SolveCameraJob>("SolveCameraJob data");
186 if (!solve_camera_initjob(C, scj, op, error_msg, sizeof(error_msg))) {
187 if (error_msg[0]) {
188 BKE_report(op->reports, RPT_ERROR, error_msg);
189 }
191 return OPERATOR_CANCELLED;
192 }
193 wmJobWorkerStatus worker_status = {};
194 solve_camera_startjob(scj, &worker_status);
196 return OPERATOR_FINISHED;
197}
198
200{
201 SolveCameraJob *scj;
204 MovieTracking *tracking = &clip->tracking;
205 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
206 MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
207 wmJob *wm_job;
208 char error_msg[256] = "\0";
209
211 /* only one solve is allowed at a time */
212 return OPERATOR_CANCELLED;
213 }
214
215 scj = MEM_new<SolveCameraJob>("SolveCameraJob data");
216 if (!solve_camera_initjob(C, scj, op, error_msg, sizeof(error_msg))) {
217 if (error_msg[0]) {
218 BKE_report(op->reports, RPT_ERROR, error_msg);
219 }
221 return OPERATOR_CANCELLED;
222 }
223
224 STRNCPY_UTF8(tracking->stats->message, "Solving camera | Preparing solve");
225
226 /* Hide reconstruction statistics from previous solve. */
227 reconstruction->flag &= ~TRACKING_RECONSTRUCTED;
229
230 /* Setup job. */
231 wm_job = WM_jobs_get(CTX_wm_manager(C),
234 "Solving camera...",
238 WM_jobs_timer(wm_job, 0.1, NC_MOVIECLIP | NA_EVALUATED, 0);
240
241 G.is_break = false;
242
244 WM_cursor_wait(false);
245
246 /* add modal handler for ESC */
248
250}
251
253{
254 /* No running solver, remove handler and pass through. */
257 }
258
259 /* Running solver. */
260 switch (event->type) {
261 case EVT_ESCKEY:
263 default: {
264 break;
265 }
266 }
267
269}
270
272{
273 /* identifiers */
274 ot->name = "Solve Camera";
275 ot->description = "Solve camera motion from tracks";
276 ot->idname = "CLIP_OT_solve_camera";
277
278 /* API callbacks. */
283
284 /* flags */
286}
287
288/********************** clear solution operator *********************/
289
291{
295 MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
296
297 for (MovieTrackingTrack &track : tracking_object->tracks) {
298 track.flag &= ~TRACK_HAS_BUNDLE;
299 }
300
301 MEM_SAFE_DELETE(reconstruction->cameras);
302
303 reconstruction->camnr = 0;
304 reconstruction->flag &= ~TRACKING_RECONSTRUCTED;
305
306 DEG_id_tag_update(&clip->id, 0);
307
310
311 return OPERATOR_FINISHED;
312}
313
315{
316 /* identifiers */
317 ot->name = "Clear Solution";
318 ot->description = "Clear all calculated data";
319 ot->idname = "CLIP_OT_clear_solution";
320
321 /* API callbacks. */
324
325 /* flags */
327}
328
329} // namespace blender
#define STRNCPY_UTF8(dst, src)
Object is a sort of wrapper for general info.
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_TRANSFORM
Definition WM_types.hh:475
#define ND_SPACE_VIEW3D
Definition WM_types.hh:571
#define NC_OBJECT
Definition WM_types.hh:392
#define NC_SPACE
Definition WM_types.hh:405
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
BMesh Iterators.
void WM_main_add_notifier(uint type, void *reference)
static wmOperatorStatus solve_camera_modal(bContext *C, wmOperator *, const wmEvent *event)
@ RPT_WARNING
Definition BKE_report.hh:40
void BKE_movieclip_get_size(MovieClip *clip, const MovieClipUser *user, int *r_width, int *r_height)
bool BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieTracking *tracking)
bool BKE_tracking_reconstruction_check(MovieTracking *tracking, MovieTrackingObject *tracking_object, char *error_msg, int error_msg_maxncpy)
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_clear_solution(wmOperatorType *ot)
void id_us_plus(ID *id)
Definition lib_id.cc:433
void CLIP_OT_solve_camera(wmOperatorType *ot)
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
Definition tracking.cc:1982
@ WM_JOB_TYPE_CLIP_SOLVE_CAMERA
Definition WM_api.hh:2030
SpaceClip * CTX_wm_space_clip(const bContext *C)
wmWindow * CTX_wm_window(const bContext *C)
static wmOperatorStatus clear_solution_exec(bContext *C, wmOperator *)
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *customdata))
Definition wm_jobs.cc:377
@ WM_JOB_PROGRESS
Definition WM_api.hh:1997
void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, bool *stop, bool *do_update, float *progress, char *stats_message, int message_size)
static wmOperatorStatus solve_camera_exec(bContext *C, wmOperator *op)
static wmOperatorStatus solve_camera_invoke(bContext *C, wmOperator *op, const wmEvent *)
static void solve_camera_updatejob(void *scv)
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)
MovieReconstructContext * BKE_tracking_reconstruction_context_new(MovieClip *clip, MovieTrackingObject *tracking_object, int keyframe1, int keyframe2, int width, int height)
void DEG_id_tag_update(ID *id, unsigned int flags)
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
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)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
const char * BKE_tracking_reconstruction_error_message_get(const MovieReconstructContext *context)
static void solve_camera_freejob(void *scv)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition report.cc:191
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
void BKE_tracking_camera_to_blender(MovieTracking *tracking, Scene *scene, Camera *camera, int width, int height)
Definition tracking.cc:2120
@ ID_RECALC_SYNC_TO_EVAL
Definition DNA_ID.h:1118
ID_Type GS(const char *name)
Definition DNA_ID.h:410
static bool solve_camera_initjob(bContext *C, SolveCameraJob *scj, wmOperator *op, char *error_msg, int max_error)
static void solve_camera_startjob(void *scv, wmJobWorkerStatus *worker_status)
bool ED_space_clip_tracking_poll(bContext *C)
Scene * CTX_data_scene(const bContext *C)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
void BKE_tracking_reconstruction_context_free(MovieReconstructContext *context)
void WM_cursor_wait(bool val)
void id_us_min(ID *id)
Definition lib_id.cc:441
void WM_jobs_timer(wmJob *wm_job, double time_step, uint note, uint endnote, void(*timer_step)(void *))
Definition wm_jobs.cc:393
struct MovieTracking tracking
MovieTrackingReconstruction reconstruction
ListBaseT< MovieTrackingTrack > tracks
struct MovieReconstructedCamera * cameras
MovieTrackingStats * stats
struct Object * camera
struct MovieClip * clip
MovieReconstructContext * context
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
struct ReportList * reports