Blender V5.3
tracking_ops_orient.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
10#include "DNA_object_types.h" /* SELECT */
11#include "DNA_screen_types.h"
12#include "DNA_space_types.h"
13
14#include "BLI_listbase.hh"
15#include "BLI_math_matrix_c.hh"
16#include "BLI_math_vector_c.hh"
17
18#include "BKE_constraint.h"
19#include "BKE_context.hh"
20#include "BKE_layer.hh"
21#include "BKE_object.hh"
22#include "BKE_report.hh"
23#include "BKE_tracking.hh"
24
25#include "DEG_depsgraph.hh"
27
28#include "WM_api.hh"
29#include "WM_types.hh"
30
31#include "ED_clip.hh"
32
33#include "RNA_access.hh"
34#include "RNA_define.hh"
35
36#include "clip_intern.hh"
37
38namespace blender {
39
40/********************** set origin operator *********************/
41
42static Object *get_camera_with_movieclip(Scene *scene, const MovieClip *clip)
43{
44 Object *camera = scene->camera;
45
46 if (camera != nullptr && BKE_object_movieclip_get(scene, camera, false) == clip) {
47 return camera;
48 }
49
50 FOREACH_SCENE_OBJECT_BEGIN (scene, ob) {
51 if (ob->type == OB_CAMERA) {
52 if (BKE_object_movieclip_get(scene, ob, false) == clip) {
53 camera = ob;
54 break;
55 }
56 }
57 }
59
60 return camera;
61}
62
64{
65 const Main *bmain = CTX_data_main(C);
66 Scene *scene = CTX_data_scene(C);
67 ViewLayer *view_layer = CTX_data_view_layer(C);
70 MovieTracking *tracking = &clip->tracking;
71 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
72 Object *object = nullptr;
73
74 if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
75 object = get_camera_with_movieclip(scene, clip);
76 }
77 else {
78 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
79 object = BKE_view_layer_active_object_get(view_layer);
80 }
81
82 if (object != nullptr && object->parent != nullptr) {
83 object = object->parent;
84 }
85
86 return object;
87}
88
90{
92 if (sc != nullptr) {
93 const Main *bmain = CTX_data_main(C);
94 const Scene *scene = CTX_data_scene(C);
95 ViewLayer *view_layer = CTX_data_view_layer(C);
97 if (clip != nullptr) {
98 MovieTracking *tracking = &clip->tracking;
99 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
100 if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
101 return true;
102 }
103 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
104 return BKE_view_layer_active_object_get(view_layer) != nullptr;
105 }
106 }
107 return false;
108}
109
111{
114 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
115 int tot = 0;
116 for (MovieTrackingTrack &track : tracking_object->tracks) {
117 if (TRACK_VIEW_SELECTED(sc, &track) && (track.flag & TRACK_HAS_BUNDLE)) {
118 tot++;
119 }
120 }
121 return tot;
122}
123
124static void object_solver_inverted_matrix(Scene *scene, Object *ob, float invmat[4][4])
125{
126 bool found = false;
127 for (bConstraint &con : ob->constraints) {
129 if (cti == nullptr) {
130 continue;
131 }
134 if (!found) {
135 Object *cam = data->camera ? data->camera : scene->camera;
137 }
138 mul_m4_m4m4(invmat, invmat, data->invmat);
139 found = true;
140 }
141 }
142 if (found) {
143 invert_m4(invmat);
144 }
145 else {
146 unit_m4(invmat);
147 }
148}
149
151{
152 for (bConstraint &con : ob->constraints) {
154 if (cti == nullptr) {
155 continue;
156 }
159 return (data->camera != nullptr) ? data->camera : scene->camera;
160 }
161 }
162 return nullptr;
163}
164
166{
169 MovieTracking *tracking = &clip->tracking;
170 Scene *scene = CTX_data_scene(C);
172 int selected_count = count_selected_bundles(C);
173
174 if (selected_count == 0) {
176 RPT_ERROR,
177 "At least one track with bundle should be selected to "
178 "define origin position");
179
180 return OPERATOR_CANCELLED;
181 }
182
184 if (object == nullptr) {
185 BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");
186 return OPERATOR_CANCELLED;
187 }
188
189 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
190
191 float median[3] = {0.0f, 0.0f, 0.0f};
192 zero_v3(median);
193 for (const MovieTrackingTrack &track : tracking_object->tracks) {
194 if (TRACK_VIEW_SELECTED(sc, &track) && (track.flag & TRACK_HAS_BUNDLE)) {
195 add_v3_v3(median, track.bundle_pos);
196 }
197 }
198 mul_v3_fl(median, 1.0f / selected_count);
199
200 float mat[4][4], vec[3];
202 mul_v3_m4v3(vec, mat, median);
203
204 if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
205 sub_v3_v3(object->loc, vec);
206 }
207 else {
208 object_solver_inverted_matrix(scene, object, mat);
209 mul_v3_m4v3(vec, mat, vec);
210 copy_v3_v3(object->loc, vec);
211 }
212
213 DEG_id_tag_update(&clip->id, 0);
215
218
219 return OPERATOR_FINISHED;
220}
221
223{
224 /* identifiers */
225 ot->name = "Set Origin";
226 ot->description =
227 "Set active marker as origin by moving camera (or its parent if present) in 3D space";
228 ot->idname = "CLIP_OT_set_origin";
229
230 /* API callbacks. */
231 ot->exec = set_origin_exec;
233
234 /* flags */
236
237 /* properties */
239 "use_median",
240 false,
241 "Use Median",
242 "Set origin to median point of selected bundles");
243}
244
245/********************** set floor operator *********************/
246
247static void set_axis(Scene *scene,
248 Object *ob,
249 const MovieClip *clip,
250 const MovieTrackingObject *tracking_object,
251 const MovieTrackingTrack *track,
252 char axis)
253{
255 const bool is_camera = (tracking_object->flag & TRACKING_OBJECT_CAMERA) != 0;
256 bool flip = false;
257 float mat[4][4], vec[3], obmat[4][4], dvec[3];
258
259 BKE_object_to_mat4(ob, obmat);
260
262 mul_v3_m4v3(vec, mat, track->bundle_pos);
263 copy_v3_v3(dvec, vec);
264
265 if (!is_camera) {
266 float imat[4][4];
267
268 object_solver_inverted_matrix(scene, ob, imat);
269 mul_v3_m4v3(vec, imat, vec);
270
271 invert_m4_m4(imat, obmat);
272 mul_v3_m4v3(dvec, imat, vec);
273
274 sub_v3_v3(vec, obmat[3]);
275 }
276
277 if (len_squared_v2(vec) < (1e-3f * 1e-3f)) {
278 return;
279 }
280
281 unit_m4(mat);
282
283 if (axis == 'X') {
284 if (fabsf(dvec[1]) < 1e-3f) {
285 flip = true;
286
287 mat[0][0] = -1.0f;
288 mat[0][1] = 0.0f;
289 mat[0][2] = 0.0f;
290 mat[1][0] = 0.0f;
291 mat[1][1] = -1.0f;
292 mat[1][2] = 0.0f;
293 mat[2][0] = 0.0f;
294 mat[2][1] = 0.0f;
295 mat[2][2] = 1.0f;
296 }
297 else {
298 copy_v3_v3(mat[0], vec);
299
300 if (is_camera || fabsf(vec[2]) < 1e-3f) {
301 mat[0][2] = 0.0f;
302 mat[2][0] = 0.0f;
303 mat[2][1] = 0.0f;
304 mat[2][2] = 1.0f;
305 cross_v3_v3v3(mat[1], mat[2], mat[0]);
306 }
307 else {
308 vec[2] = 0.0f;
309
310 cross_v3_v3v3(mat[1], mat[0], vec);
311 cross_v3_v3v3(mat[2], mat[0], mat[1]);
312 }
313 }
314 }
315 else {
316 if (fabsf(dvec[0]) < 1e-3f) {
317 flip = true;
318
319 mat[0][0] = -1.0f;
320 mat[0][1] = 0.0f;
321 mat[0][2] = 0.0f;
322 mat[1][0] = 0.0f;
323 mat[1][1] = -1.0f;
324 mat[1][2] = 0.0f;
325 mat[2][0] = 0.0f;
326 mat[2][1] = 0.0f;
327 mat[2][2] = 1.0f;
328 }
329 else {
330 copy_v3_v3(mat[1], vec);
331
332 if (is_camera || fabsf(vec[2]) < 1e-3f) {
333 mat[1][2] = 0.0f;
334 mat[2][0] = 0.0f;
335 mat[2][1] = 0.0f;
336 mat[2][2] = 1.0f;
337 cross_v3_v3v3(mat[0], mat[1], mat[2]);
338 }
339 else {
340 vec[2] = 0.0f;
341
342 cross_v3_v3v3(mat[0], vec, mat[1]);
343 cross_v3_v3v3(mat[2], mat[0], mat[1]);
344 }
345 }
346 }
347
348 normalize_v3(mat[0]);
349 normalize_v3(mat[1]);
350 normalize_v3(mat[2]);
351
352 if (is_camera) {
353 invert_m4(mat);
354
355 mul_m4_m4m4(mat, mat, obmat);
356 }
357 else {
358 if (!flip) {
359 float lmat[4][4], ilmat[4][4], rmat[3][3];
360
361 BKE_object_rot_to_mat3(ob, rmat, true);
362 invert_m3(rmat);
363 mul_m4_m4m3(mat, mat, rmat);
364
365 unit_m4(lmat);
366 copy_v3_v3(lmat[3], obmat[3]);
367 invert_m4_m4(ilmat, lmat);
368
369 mul_m4_series(mat, lmat, mat, ilmat, obmat);
370 }
371 else {
372 mul_m4_m4m4(mat, obmat, mat);
373 }
374 }
375
376 BKE_object_apply_mat4(ob, mat, false, false);
377}
378
380{
383 Scene *scene = CTX_data_scene(C);
384 MovieTracking *tracking = &clip->tracking;
385 const MovieTrackingTrack *axis_track = nullptr;
387 int tot = 0;
388 float vec[3][3], mat[4][4], obmat[4][4], newmat[4][4], orig[3] = {0.0f, 0.0f, 0.0f};
389 int plane = RNA_enum_get(op->ptr, "plane");
390 float rot[4][4] = {
391 {0.0f, 0.0f, -1.0f, 0.0f},
392 {0.0f, 1.0f, 0.0f, 0.0f},
393 {1.0f, 0.0f, 0.0f, 0.0f},
394 {0.0f, 0.0f, 0.0f, 1.0f},
395 }; /* 90 degrees Y-axis rotation matrix */
396
397 if (count_selected_bundles(C) != 3) {
398 BKE_report(op->reports, RPT_ERROR, "Three tracks with bundles are needed to orient the floor");
399
400 return OPERATOR_CANCELLED;
401 }
402
403 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
404
406 if (object == nullptr) {
407 BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");
408 return OPERATOR_CANCELLED;
409 }
410
412
413 /* Get 3 bundles to use as reference. */
414 {
415 const MovieTrackingTrack *track = static_cast<const MovieTrackingTrack *>(
416 tracking_object->tracks.first_);
417 while (track && tot < 3) {
418 if (track->flag & TRACK_HAS_BUNDLE && TRACK_VIEW_SELECTED(sc, track)) {
419 mul_v3_m4v3(vec[tot], mat, track->bundle_pos);
420 if (tot == 0 || track == tracking_object->active_track) {
421 copy_v3_v3(orig, vec[tot]);
422 }
423 else {
424 axis_track = track;
425 }
426 tot++;
427 }
428 track = track->next;
429 }
430 }
431
432 sub_v3_v3(vec[1], vec[0]);
433 sub_v3_v3(vec[2], vec[0]);
434
435 /* Construct ortho-normal basis. */
436 unit_m4(mat);
437 if (plane == 0) { /* floor */
438 cross_v3_v3v3(mat[0], vec[1], vec[2]);
439 copy_v3_v3(mat[1], vec[1]);
440 cross_v3_v3v3(mat[2], mat[0], mat[1]);
441 }
442 else if (plane == 1) { /* wall */
443 cross_v3_v3v3(mat[2], vec[1], vec[2]);
444 copy_v3_v3(mat[1], vec[1]);
445 cross_v3_v3v3(mat[0], mat[1], mat[2]);
446 }
447
448 normalize_v3(mat[0]);
449 normalize_v3(mat[1]);
450 normalize_v3(mat[2]);
451
452 /* Move to origin point. */
453 mat[3][0] = orig[0];
454 mat[3][1] = orig[1];
455 mat[3][2] = orig[2];
456
457 if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
458 invert_m4(mat);
459
460 BKE_object_to_mat4(object, obmat);
461 mul_m4_m4m4(mat, mat, obmat);
462 mul_m4_m4m4(newmat, rot, mat);
463 BKE_object_apply_mat4(object, newmat, false, false);
464
465 /* Make camera have positive z-coordinate. */
466 if (object->loc[2] < 0) {
467 invert_m4(rot);
468 mul_m4_m4m4(newmat, rot, mat);
469 BKE_object_apply_mat4(object, newmat, false, false);
470 }
471 }
472 else {
473 BKE_object_apply_mat4(object, mat, false, false);
474 }
475
476 Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
477 Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
478 Object *object_eval = DEG_get_evaluated(depsgraph, object);
479 BKE_object_transform_copy(object_eval, object);
480 BKE_object_where_is_calc(depsgraph, scene_eval, object_eval);
481 BKE_object_transform_copy(object, object_eval);
482
483 set_axis(scene, object, clip, tracking_object, axis_track, 'X');
484
485 DEG_id_tag_update(&clip->id, 0);
487
490
491 return OPERATOR_FINISHED;
492}
493
495{
496 static const EnumPropertyItem plane_items[] = {
497 {0, "FLOOR", 0, "Floor", "Set floor plane"},
498 {1, "WALL", 0, "Wall", "Set wall plane"},
499 {0, nullptr, 0, nullptr, nullptr},
500 };
501
502 /* identifiers */
503 ot->name = "Set Plane";
504 ot->description =
505 "Set plane based on 3 selected bundles by moving camera "
506 "(or its parent if present) in 3D space";
507 ot->idname = "CLIP_OT_set_plane";
508
509 /* API callbacks. */
510 ot->exec = set_plane_exec;
512
513 /* flags */
515
516 /* properties */
517 RNA_def_enum(ot->srna, "plane", plane_items, 0, "Plane", "Plane to be used for orientation");
518}
519
520/********************** set axis operator *********************/
521
523{
526 MovieTracking *tracking = &clip->tracking;
527 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
528 Scene *scene = CTX_data_scene(C);
529 Object *object;
530 int axis = RNA_enum_get(op->ptr, "axis");
531
532 if (count_selected_bundles(C) != 1) {
534 op->reports, RPT_ERROR, "Single track with bundle should be selected to define axis");
535 return OPERATOR_CANCELLED;
536 }
537
538 object = get_orientation_object(C);
539 if (object == nullptr) {
540 BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");
541 return OPERATOR_CANCELLED;
542 }
543
544 const MovieTrackingTrack *track = static_cast<const MovieTrackingTrack *>(
545 tracking_object->tracks.first_);
546 while (track) {
547 if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_HAS_BUNDLE)) {
548 break;
549 }
550 track = track->next;
551 }
552
553 set_axis(scene, object, clip, tracking_object, track, axis == 0 ? 'X' : 'Y');
554
555 DEG_id_tag_update(&clip->id, 0);
557
560
561 return OPERATOR_FINISHED;
562}
563
565{
566 static const EnumPropertyItem axis_actions[] = {
567 {0, "X", 0, "X", "Align bundle to X axis"},
568 {1, "Y", 0, "Y", "Align bundle to Y axis"},
569 {0, nullptr, 0, nullptr, nullptr},
570 };
571
572 /* identifiers */
573 ot->name = "Set Axis";
574 ot->description =
575 "Set the direction of a scene axis by rotating the camera "
576 "(or its parent if present). This assumes that the selected "
577 "track lies on a real axis connecting it to the origin";
578 ot->idname = "CLIP_OT_set_axis";
579
580 /* API callbacks. */
581 ot->exec = set_axis_exec;
583
584 /* flags */
586
587 /* properties */
588 RNA_def_enum(ot->srna, "axis", axis_actions, 0, "Axis", "Axis to use to align bundle along");
589}
590
591/********************** set scale operator *********************/
592
594 wmOperator *op,
595 bool scale_solution,
596 bool apply_scale)
597{
600 MovieTracking *tracking = &clip->tracking;
601 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
602 Scene *scene = CTX_data_scene(C);
603 Object *object = nullptr;
605 int tot = 0;
606 float vec[2][3], mat[4][4], scale;
607 float dist = RNA_float_get(op->ptr, "distance");
608
609 if (count_selected_bundles(C) != 2) {
610 BKE_report(op->reports, RPT_ERROR, "Two tracks with bundles should be selected to set scale");
611 return OPERATOR_CANCELLED;
612 }
613
614 if (!scale_solution && !apply_scale) {
615 object = get_orientation_object(C);
616 if (object == nullptr) {
617 BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");
618 return OPERATOR_CANCELLED;
619 }
620 }
621
623
624 for (MovieTrackingTrack &track : tracking_object->tracks) {
625 if (TRACK_VIEW_SELECTED(sc, &track)) {
626 mul_v3_m4v3(vec[tot], mat, track.bundle_pos);
627 tot++;
628 }
629 }
630
631 sub_v3_v3(vec[0], vec[1]);
632
633 if (len_v3(vec[0]) > 1e-5f) {
634 scale = dist / len_v3(vec[0]);
635 if (apply_scale) {
636 /* Apply scale on reconstructed scene itself. */
637 MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
638 MovieReconstructedCamera *reconstructed_cameras;
639 int i;
640
641 for (MovieTrackingTrack &track : tracking_object->tracks) {
642 mul_v3_fl(track.bundle_pos, scale);
643 }
644
645 reconstructed_cameras = reconstruction->cameras;
646 for (i = 0; i < reconstruction->camnr; i++) {
647 mul_v3_fl(reconstructed_cameras[i].mat[3], scale);
648 }
649
651
654 }
655 else {
656 if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
657 mul_v3_fl(object->scale, scale);
658 mul_v3_fl(object->loc, scale);
659 }
660 else if (!scale_solution) {
661 Object *solver_camera = object_solver_camera(scene, object);
662
663 object->scale[0] = object->scale[1] = object->scale[2] = 1.0f / scale;
664
665 if (solver_camera) {
666 object->scale[0] /= solver_camera->scale[0];
667 object->scale[1] /= solver_camera->scale[1];
668 object->scale[2] /= solver_camera->scale[2];
669 }
670 }
671 else {
672 tracking_object->scale = scale;
673 }
674
675 DEG_id_tag_update(&clip->id, 0);
676
677 if (object) {
679 }
680
683 }
684 }
685
686 return OPERATOR_FINISHED;
687}
688
690{
691 return do_set_scale(C, op, false, false);
692}
693
695{
698
699 if (!RNA_struct_property_is_set(op->ptr, "distance")) {
700 RNA_float_set(op->ptr, "distance", clip->tracking.settings.dist);
701 }
702
703 return set_scale_exec(C, op);
704}
705
707{
708 /* identifiers */
709 ot->name = "Set Scale";
710 ot->description = "Set scale of scene by scaling camera (or its parent if present)";
711 ot->idname = "CLIP_OT_set_scale";
712
713 /* API callbacks. */
714 ot->exec = set_scale_exec;
717
718 /* flags */
720
721 /* properties */
723 "distance",
724 0.0f,
725 -FLT_MAX,
726 FLT_MAX,
727 "Distance",
728 "Distance between selected tracks",
729 -100.0f,
730 100.0f);
731}
732
733/********************** set solution scale operator *********************/
734
736{
738 if (sc != nullptr) {
740 if (clip != nullptr) {
741 MovieTracking *tracking = &clip->tracking;
742 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
743 return (tracking_object->flag & TRACKING_OBJECT_CAMERA) == 0;
744 }
745 }
746 return false;
747}
748
750{
751 return do_set_scale(C, op, true, false);
752}
753
755 wmOperator *op,
756 const wmEvent * /*event*/)
757{
760
761 if (!RNA_struct_property_is_set(op->ptr, "distance")) {
762 RNA_float_set(op->ptr, "distance", clip->tracking.settings.object_distance);
763 }
764
765 return set_solution_scale_exec(C, op);
766}
767
769{
770 /* identifiers */
771 ot->name = "Set Solution Scale";
772 ot->description =
773 "Set object solution scale using distance between "
774 "two selected tracks";
775 ot->idname = "CLIP_OT_set_solution_scale";
776
777 /* API callbacks. */
781
782 /* flags */
784
785 /* properties */
787 "distance",
788 0.0f,
789 -FLT_MAX,
790 FLT_MAX,
791 "Distance",
792 "Distance between selected tracks",
793 -100.0f,
794 100.0f);
795}
796
797/********************** apply solution scale operator *********************/
798
800{
802 if (sc != nullptr) {
804 if (clip != nullptr) {
805 MovieTracking *tracking = &clip->tracking;
806 MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
807 return (tracking_object->flag & TRACKING_OBJECT_CAMERA) != 0;
808 }
809 }
810 return false;
811}
812
814{
815 return do_set_scale(C, op, false, true);
816}
817
819 wmOperator *op,
820 const wmEvent * /*event*/)
821{
824 if (!RNA_struct_property_is_set(op->ptr, "distance")) {
825 RNA_float_set(op->ptr, "distance", clip->tracking.settings.dist);
826 }
827 return apply_solution_scale_exec(C, op);
828}
829
831{
832 /* identifiers */
833 ot->name = "Apply Solution Scale";
834 ot->description =
835 "Apply scale on solution itself to make distance between "
836 "selected tracks equals to desired";
837 ot->idname = "CLIP_OT_apply_solution_scale";
838
839 /* API callbacks. */
843
844 /* flags */
846
847 /* properties */
849 "distance",
850 0.0f,
851 -FLT_MAX,
852 FLT_MAX,
853 "Distance",
854 "Distance between selected tracks",
855 -100.0f,
856 100.0f);
857}
858
859} // namespace blender
#define FOREACH_SCENE_OBJECT_END
#define FOREACH_SCENE_OBJECT_BEGIN(scene, _instance)
General operations, lookup, etc. for blender objects.
#define TRACK_VIEW_SELECTED(sc, track)
#define mul_m4_series(...)
Object is a sort of wrapper for general info.
#define C
Definition RandGen.cpp:29
#define NA_EVALUATED
Definition WM_types.hh:635
#define NC_MOVIECLIP
Definition WM_types.hh:410
#define ND_TRANSFORM
Definition WM_types.hh:475
#define NC_OBJECT
Definition WM_types.hh:392
#define rot(x, k)
#define FLT_MAX
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
float3x3 scale(float3x3 mat, float2 scale)
BMesh Iterators.
static wmOperatorStatus set_solution_scale_exec(bContext *C, wmOperator *op)
static bool apply_solution_scale_poll(bContext *C)
void BKE_object_rot_to_mat3(const Object *ob, float r_mat[3][3], bool use_drot)
Definition object.cc:2906
int RNA_enum_get(PointerRNA *ptr, const char *name)
static wmOperatorStatus apply_solution_scale_invoke(bContext *C, wmOperator *op, const wmEvent *)
Object * BKE_view_layer_active_object_get(const ViewLayer *view_layer)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
static wmOperatorStatus set_scale_exec(bContext *C, wmOperator *op)
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
Definition tracking.cc:1982
static wmOperatorStatus do_set_scale(bContext *C, wmOperator *op, bool scale_solution, bool apply_scale)
SpaceClip * CTX_wm_space_clip(const bContext *C)
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
static wmOperatorStatus set_scale_invoke(bContext *C, wmOperator *op, const wmEvent *)
static wmOperatorStatus apply_solution_scale_exec(bContext *C, wmOperator *op)
static void object_solver_inverted_matrix(Scene *scene, Object *ob, float invmat[4][4])
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
bool invert_m4(float mat[4][4])
void CLIP_OT_set_plane(wmOperatorType *ot)
MovieClip * BKE_object_movieclip_get(Scene *scene, const Object *ob, bool use_default)
Definition object.cc:5154
ViewLayer * CTX_data_view_layer(const bContext *C)
void BKE_object_apply_mat4(Object *ob, const float mat[4][4], bool use_compat, bool use_parent)
Definition object.cc:3663
MINLINE void mul_v3_fl(float r[3], float f)
MINLINE void sub_v3_v3(float r[3], const float a[3])
const bConstraintTypeInfo * BKE_constraint_typeinfo_get(struct bConstraint *con)
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
static wmOperatorStatus set_solution_scale_invoke(bContext *C, wmOperator *op, const wmEvent *)
void CLIP_OT_apply_solution_scale(wmOperatorType *ot)
void mul_m4_m4m3(float R[4][4], const float A[4][4], const float B[3][3])
void BKE_object_to_mat4(const Object *ob, float r_mat[4][4])
Definition object.cc:3125
void DEG_id_tag_update(ID *id, unsigned int flags)
static void set_axis(Scene *scene, Object *ob, const MovieClip *clip, const MovieTrackingObject *tracking_object, const MovieTrackingTrack *track, char axis)
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
BMesh const char void * data
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
static bool set_solution_scale_poll(bContext *C)
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
static int count_selected_bundles(bContext *C)
void BKE_object_where_is_calc_mat4(const Object *ob, float r_obmat[4][4])
Definition object.cc:3560
static Object * object_solver_camera(Scene *scene, Object *ob)
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
static bool set_orientation_poll(bContext *C)
static Object * get_camera_with_movieclip(Scene *scene, const MovieClip *clip)
bool RNA_struct_property_is_set(PointerRNA *ptr, const char *identifier)
void unit_m4(float m[4][4])
MINLINE float len_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void zero_v3(float r[3])
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void RNA_float_set(PointerRNA *ptr, const char *name, float value)
void BKE_object_transform_copy(Object *ob_tar, const Object *ob_src)
Definition object.cc:2648
bool invert_m3(float mat[3][3])
MINLINE float normalize_v3(float n[3])
MINLINE float len_squared_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
MINLINE void add_v3_v3(float r[3], const float a[3])
Main * CTX_data_main(const bContext *C)
MovieClip * ED_space_clip_get_clip(const SpaceClip *sc)
static wmOperatorStatus set_plane_exec(bContext *C, wmOperator *op)
void CLIP_OT_set_origin(wmOperatorType *ot)
void CLIP_OT_set_scale(wmOperatorType *ot)
@ ID_RECALC_TRANSFORM
Definition DNA_ID.h:1054
@ ID_RECALC_SYNC_TO_EVAL
Definition DNA_ID.h:1118
void CLIP_OT_set_solution_scale(wmOperatorType *ot)
Scene * CTX_data_scene(const bContext *C)
void BKE_tracking_get_camera_object_matrix(const Object *camera_object, float mat[4][4])
Definition tracking.cc:372
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
void BKE_object_where_is_calc(Depsgraph *depsgraph, Scene *scene, Object *ob)
Definition object.cc:3577
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
static wmOperatorStatus set_origin_exec(bContext *C, wmOperator *op)
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
void CLIP_OT_set_axis(wmOperatorType *ot)
static Object * get_orientation_object(bContext *C)
float RNA_float_get(PointerRNA *ptr, const char *name)
static wmOperatorStatus set_axis_exec(bContext *C, wmOperator *op)
#define fabsf
struct MovieTracking tracking
MovieTrackingReconstruction reconstruction
ListBaseT< MovieTrackingTrack > tracks
MovieTrackingTrack * active_track
struct MovieReconstructedCamera * cameras
struct MovieTrackingTrack * next
MovieTrackingSettings settings
ListBaseT< bConstraint > constraints
struct Object * camera
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
struct ReportList * reports