blender
/
blender
136
406
Fork 590
Code Issues 6.2k Pull Requests 764 Projects 19 Wiki Activity

Refactor: Remove trivial accessor functions from tracking

This commit is contained in:
Sergey Sharybin 2022-10-05 15:56:08 +02:00
parent fe38715600
commit 1168665653
Notes: blender-bot 2023-02-14 03:59:42 +01:00 
Referenced by issue #102887, Crash after deleting Plane track
14 changed files with 128 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
source/blender/blenkernel/BKE_tracking.h
View File

@ -451,13 +451,6 @@ struct MovieTrackingObject *BKE_tracking_object_get_named(struct MovieTracking *
struct MovieTrackingObject *BKE_tracking_object_get_active(const struct MovieTracking *tracking);
struct MovieTrackingObject *BKE_tracking_object_get_camera(const struct MovieTracking *tracking);
struct ListBase *BKE_tracking_object_get_tracks(struct MovieTracking *tracking,
struct MovieTrackingObject *object);
struct ListBase *BKE_tracking_object_get_plane_tracks(struct MovieTracking *tracking,
struct MovieTrackingObject *object);
struct MovieTrackingReconstruction *BKE_tracking_object_get_reconstruction(
struct MovieTracking *tracking, struct MovieTrackingObject *object);
/* --------------------------------------------------------------------
* Camera.
*/

106
source/blender/blenkernel/intern/tracking.c
View File

@ -372,8 +372,7 @@ ListBase *BKE_tracking_get_active_plane_tracks(MovieTracking *tracking)
MovieTrackingReconstruction *BKE_tracking_get_active_reconstruction(MovieTracking *tracking)
{
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
return BKE_tracking_object_get_reconstruction(tracking, object);
return &object->reconstruction;
}
void BKE_tracking_get_camera_object_matrix(Object *camera_object, float mat[4][4])
@ -465,23 +464,19 @@ void BKE_tracking_clipboard_free(void)
BLI_listbase_clear(&tracking_clipboard.tracks);
}
void BKE_tracking_clipboard_copy_tracks(MovieTracking *tracking, MovieTrackingObject *object)
void BKE_tracking_clipboard_copy_tracks(MovieTracking *UNUSED(tracking),
MovieTrackingObject *object)
{
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
MovieTrackingTrack *track = tracksbase->first;
/* First drop all tracks from current clipboard. */
BKE_tracking_clipboard_free();
/* Then copy all selected visible tracks to it. */
while (track) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
if (TRACK_SELECTED(track) && (track->flag & TRACK_HIDDEN) == 0) {
MovieTrackingTrack *new_track = BKE_tracking_track_duplicate(track);
BLI_addtail(&tracking_clipboard.tracks, new_track);
}
track = track->next;
}
}
@ -490,12 +485,10 @@ bool BKE_tracking_clipboard_has_tracks(void)
return (BLI_listbase_is_empty(&tracking_clipboard.tracks) == false);
}
void BKE_tracking_clipboard_paste_tracks(MovieTracking *tracking, MovieTrackingObject *object)
void BKE_tracking_clipboard_paste_tracks(MovieTracking *UNUSED(tracking),
MovieTrackingObject *object)
{
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
MovieTrackingTrack *track = tracking_clipboard.tracks.first;
while (track) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_clipboard.tracks) {
MovieTrackingTrack *new_track = BKE_tracking_track_duplicate(track);
/* TODO(sergey): Preserve active track from before the copy. */
@ -503,10 +496,8 @@ void BKE_tracking_clipboard_paste_tracks(MovieTracking *tracking, MovieTrackingO
object->active_track = new_track;
}
BLI_addtail(tracksbase, new_track);
BKE_tracking_track_unique_name(tracksbase, new_track);
track = track->next;
BLI_addtail(&object->tracks, new_track);
BKE_tracking_track_unique_name(&object->tracks, new_track);
}
}
@ -1041,19 +1032,14 @@ void BKE_tracking_tracks_average(MovieTrackingTrack *dst_track,
tracking_average_tracks(dst_track, src_tracks, num_src_tracks);
}
MovieTrackingTrack *BKE_tracking_track_get_named(MovieTracking *tracking,
MovieTrackingTrack *BKE_tracking_track_get_named(MovieTracking *UNUSED(tracking),
MovieTrackingObject *object,
const char *name)
{
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
MovieTrackingTrack *track = tracksbase->first;
while (track) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
if (STREQ(track->name, name)) {
return track;
}
track = track->next;
}
return NULL;
@ -1063,28 +1049,19 @@ MovieTrackingTrack *BKE_tracking_track_get_indexed(MovieTracking *tracking,
int tracknr,
ListBase **r_tracksbase)
{
MovieTrackingObject *object;
int cur = 1;
object = tracking->objects.first;
while (object) {
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
MovieTrackingTrack *track = tracksbase->first;
while (track) {
LISTBASE_FOREACH (MovieTrackingObject *, object, &tracking->objects) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
if (track->flag & TRACK_HAS_BUNDLE) {
if (cur == tracknr) {
*r_tracksbase = tracksbase;
*r_tracksbase = &object->tracks;
return track;
}
cur++;
}
track = track->next;
}
object = object->next;
}
*r_tracksbase = NULL;
@ -1701,13 +1678,11 @@ void BKE_tracking_plane_track_free(MovieTrackingPlaneTrack *plane_track)
MEM_freeN(plane_track->point_tracks);
}
MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_named(MovieTracking *tracking,
MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_named(MovieTracking *UNUSED(tracking),
MovieTrackingObject *object,
const char *name)
{
ListBase *plane_tracks_base = BKE_tracking_object_get_plane_tracks(tracking, object);
LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, plane_tracks_base) {
LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, &object->plane_tracks) {
if (STREQ(plane_track->name, name)) {
return plane_track;
}
@ -2098,24 +2073,6 @@ MovieTrackingObject *BKE_tracking_object_get_camera(const MovieTracking *trackin
return NULL;
}
ListBase *BKE_tracking_object_get_tracks(MovieTracking *UNUSED(tracking),
MovieTrackingObject *object)
{
return &object->tracks;
}
ListBase *BKE_tracking_object_get_plane_tracks(MovieTracking *UNUSED(tracking),
MovieTrackingObject *object)
{
return &object->plane_tracks;
}
MovieTrackingReconstruction *BKE_tracking_object_get_reconstruction(
MovieTracking *UNUSED(tracking), MovieTrackingObject *object)
{
return &object->reconstruction;
}
/* --------------------------------------------------------------------
* Camera.
*/
@ -2227,15 +2184,12 @@ void BKE_tracking_camera_to_blender(
BKE_tracking_camera_shift_get(tracking, width, height, &camera->shiftx, &camera->shifty);
}
MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(MovieTracking *tracking,
MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(MovieTracking *UNUSED(tracking),
MovieTrackingObject *object,
int framenr)
{
MovieTrackingReconstruction *reconstruction;
int a;
reconstruction = BKE_tracking_object_get_reconstruction(tracking, object);
a = reconstructed_camera_index_get(reconstruction, framenr, false);
MovieTrackingReconstruction *reconstruction = &object->reconstruction;
int a = reconstructed_camera_index_get(reconstruction, framenr, false);
if (a == -1) {
return NULL;
@ -2244,18 +2198,15 @@ MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(MovieTracking *t
return &reconstruction->cameras[a];
}
void BKE_tracking_camera_get_reconstructed_interpolate(MovieTracking *tracking,
void BKE_tracking_camera_get_reconstructed_interpolate(MovieTracking *UNUSED(tracking),
MovieTrackingObject *object,
float framenr,
float mat[4][4])
{
MovieTrackingReconstruction *reconstruction;
MovieReconstructedCamera *cameras;
int a;
MovieTrackingReconstruction *reconstruction = &object->reconstruction;
MovieReconstructedCamera *cameras = reconstruction->cameras;
reconstruction = BKE_tracking_object_get_reconstruction(tracking, object);
cameras = reconstruction->cameras;
a = reconstructed_camera_index_get(reconstruction, (int)framenr, true);
int a = reconstructed_camera_index_get(reconstruction, (int)framenr, true);
if (a == -1) {
unit_m4(mat);
@ -3208,14 +3159,12 @@ static void tracking_dopesheet_channels_calc(MovieTracking *tracking)
{
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
MovieTrackingReconstruction *reconstruction = BKE_tracking_object_get_reconstruction(tracking,
object);
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
MovieTrackingReconstruction *reconstruction = &object->reconstruction;
bool sel_only = (dopesheet->flag & TRACKING_DOPE_SELECTED_ONLY) != 0;
bool show_hidden = (dopesheet->flag & TRACKING_DOPE_SHOW_HIDDEN) != 0;
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
if (!show_hidden && (track->flag & TRACK_HIDDEN) != 0) {
continue;
}
@ -3313,13 +3262,12 @@ static void tracking_dopesheet_calc_coverage(MovieTracking *tracking)
{
MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
int frames, start_frame = INT_MAX, end_frame = -INT_MAX;
int *per_frame_counter;
int prev_coverage, last_segment_frame;
/* find frame boundaries */
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
start_frame = min_ii(start_frame, track->markers[0].framenr);
end_frame = max_ii(end_frame, track->markers[track->markersnr - 1].framenr);
}
@ -3335,7 +3283,7 @@ static void tracking_dopesheet_calc_coverage(MovieTracking *tracking)
per_frame_counter = MEM_callocN(sizeof(int) * frames, "per frame track counter");
/* find per-frame markers count */
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
for (int i = 0; i < track->markersnr; i++) {
MovieTrackingMarker *marker = &track->markers[i];

35
source/blender/blenkernel/intern/tracking_solver.c
View File

@ -281,23 +281,17 @@ static int reconstruct_refine_intrinsics_get_flags(MovieTracking *tracking,
}
/* Count tracks which has markers at both of keyframes. */
static int reconstruct_count_tracks_on_both_keyframes(MovieTracking *tracking,
MovieTrackingObject *object)
static int reconstruct_count_tracks_on_both_keyframes(MovieTrackingObject *object)
{
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
int tot = 0;
int frame1 = object->keyframe1, frame2 = object->keyframe2;
MovieTrackingTrack *track;
const int frame1 = object->keyframe1, frame2 = object->keyframe2;
track = tracksbase->first;
while (track) {
int tot = 0;
LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame1)) {
if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame2)) {
tot++;
}
}
track = track->next;
}
return tot;
@ -314,7 +308,7 @@ bool BKE_tracking_reconstruction_check(MovieTracking *tracking,
}
if ((tracking->settings.reconstruction_flag & TRACKING_USE_KEYFRAME_SELECTION) == 0) {
/* automatic keyframe selection does not require any pre-process checks */
if (reconstruct_count_tracks_on_both_keyframes(tracking, object) < 8) {
if (reconstruct_count_tracks_on_both_keyframes(object) < 8) {
BLI_strncpy(error_msg,
N_("At least 8 common tracks on both keyframes are needed for reconstruction"),
error_size);
@ -341,11 +335,9 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip
MovieTracking *tracking = &clip->tracking;
MovieReconstructContext *context = MEM_callocN(sizeof(MovieReconstructContext),
"MovieReconstructContext data");
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
float aspy = 1.0f / tracking->camera.pixel_aspect;
int num_tracks = BLI_listbase_count(tracksbase);
const float aspy = 1.0f / tracking->camera.pixel_aspect;
const int num_tracks = BLI_listbase_count(&object->tracks);
int sfra = INT_MAX, efra = INT_MIN;
MovieTrackingTrack *track;
BLI_strncpy(context->object_name, object->name, sizeof(context->object_name));
context->motion_flag = tracking->settings.motion_flag;
@ -358,8 +350,7 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip
context->tracks_map = tracks_map_new(context->object_name, num_tracks, 0);
track = tracksbase->first;
while (track) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
int first = 0, last = track->markersnr - 1;
MovieTrackingMarker *first_marker = &track->markers[0];
MovieTrackingMarker *last_marker = &track->markers[track->markersnr - 1];
@ -385,14 +376,12 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip
}
tracks_map_insert(context->tracks_map, track, NULL);
track = track->next;
}
context->sfra = sfra;
context->efra = efra;
context->tracks = libmv_tracks_new(clip, tracksbase, width, height * aspy);
context->tracks = libmv_tracks_new(clip, &object->tracks, width, height * aspy);
context->keyframe1 = keyframe1;
context->keyframe2 = keyframe2;
context->refine_flags = reconstruct_refine_intrinsics_get_flags(tracking, object);
@ -563,10 +552,6 @@ static void tracking_scale_reconstruction(ListBase *tracksbase,
void BKE_tracking_reconstruction_scale(MovieTracking *tracking, float scale[3])
{
LISTBASE_FOREACH (MovieTrackingObject *, object, &tracking->objects) {
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
MovieTrackingReconstruction *reconstruction = BKE_tracking_object_get_reconstruction(tracking,
object);
tracking_scale_reconstruction(tracksbase, reconstruction, scale);
tracking_scale_reconstruction(&object->tracks, &object->reconstruction, scale);
}
}

16
source/blender/blenloader/intern/versioning_260.c
View File

@ -2346,15 +2346,13 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
}
if (!DNA_struct_elem_find(fd->filesdna, "MovieTrackingTrack", "float", "weight")) {
MovieClip *clip;
for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object;
for (tracking_object = tracking->objects.first; tracking_object;
tracking_object = tracking_object->next) {
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
MovieTrackingTrack *track;
for (track = tracksbase->first; track; track = track->next) {
LISTBASE_FOREACH (MovieClip *, clip, &bmain->movieclips) {
const MovieTracking *tracking = &clip->tracking;
LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
const ListBase *tracksbase = (tracking_object->flag & TRACKING_OBJECT_CAMERA) ?
&tracking->tracks_legacy :
&tracking_object->tracks;
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
track->weight = 1.0f;
}
}

16
source/blender/blenloader/intern/versioning_270.c
View File

@ -1380,15 +1380,13 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *bmain)
if (!MAIN_VERSION_ATLEAST(bmain, 278, 0)) {
if (!DNA_struct_elem_find(fd->filesdna, "MovieTrackingTrack", "float", "weight_stab")) {
MovieClip *clip;
for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object;
for (tracking_object = tracking->objects.first; tracking_object != NULL;
tracking_object = tracking_object->next) {
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
MovieTrackingTrack *track;
for (track = tracksbase->first; track != NULL; track = track->next) {
LISTBASE_FOREACH (MovieClip *, clip, &bmain->movieclips) {
const MovieTracking *tracking = &clip->tracking;
LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
const ListBase *tracksbase = (tracking_object->flag & TRACKING_OBJECT_CAMERA) ?
&tracking->tracks_legacy :
&tracking_object->tracks;
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
track->weight_stab = track->weight;
}
}

42
source/blender/compositor/operations/COM_KeyingScreenOperation.cc
View File

@ -65,10 +65,7 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::build_voronoi_t
MovieClipUser user = *DNA_struct_default_get(MovieClipUser);
TriangulationData *triangulation;
MovieTracking *tracking = &movie_clip_->tracking;
MovieTrackingTrack *track;
VoronoiSite *sites, *site;
ImBuf *ibuf;
ListBase *tracksbase;
ListBase edges = {nullptr, nullptr};
int sites_total;
int i;
@ -76,29 +73,28 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::build_voronoi_t
int height = this->get_height();
int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(movie_clip_, framenumber_);
const MovieTrackingObject *tracking_object = nullptr;
if (tracking_object_[0]) {
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, tracking_object_);
if (!object) {
tracking_object = BKE_tracking_object_get_named(tracking, tracking_object_);
if (!tracking_object) {
return nullptr;
}
tracksbase = BKE_tracking_object_get_tracks(tracking, object);
}
else {
tracksbase = BKE_tracking_get_active_tracks(tracking);
tracking_object = BKE_tracking_object_get_active(tracking);
}
BLI_assert(tracking_object != 0);
/* count sites */
for (track = (MovieTrackingTrack *)tracksbase->first, sites_total = 0; track;
track = track->next) {
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_frame);
float pos[2];
sites_total = 0;
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
const MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_frame);
if (marker->flag & MARKER_DISABLED) {
continue;
}
float pos[2];
add_v2_v2v2(pos, marker->pos, track->offset);
if (!IN_RANGE_INCL(pos[0], 0.0f, 1.0f) || !IN_RANGE_INCL(pos[1], 0.0f, 1.0f)) {
@ -121,31 +117,29 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::build_voronoi_t
triangulation = MEM_cnew<TriangulationData>("keying screen triangulation data");
sites = (VoronoiSite *)MEM_callocN(sizeof(VoronoiSite) * sites_total,
"keyingscreen voronoi sites");
track = (MovieTrackingTrack *)tracksbase->first;
for (track = (MovieTrackingTrack *)tracksbase->first, site = sites; track; track = track->next) {
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_frame);
ImBuf *pattern_ibuf;
int j;
float pos[2];
VoronoiSite *sites = (VoronoiSite *)MEM_callocN(sizeof(VoronoiSite) * sites_total,
"keyingscreen voronoi sites");
int track_index = 0;
LISTBASE_FOREACH_INDEX (MovieTrackingTrack *, track, &tracking_object->tracks, track_index) {
const MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_frame);
if (marker->flag & MARKER_DISABLED) {
continue;
}
float pos[2];
add_v2_v2v2(pos, marker->pos, track->offset);
if (!IN_RANGE_INCL(pos[0], 0.0f, 1.0f) || !IN_RANGE_INCL(pos[1], 0.0f, 1.0f)) {
continue;
}
pattern_ibuf = BKE_tracking_get_pattern_imbuf(ibuf, track, marker, true, false);
ImBuf *pattern_ibuf = BKE_tracking_get_pattern_imbuf(ibuf, track, marker, true, false);
VoronoiSite *site = &sites[track_index];
zero_v3(site->color);
if (pattern_ibuf) {
for (j = 0; j < pattern_ibuf->x * pattern_ibuf->y; j++) {
for (int j = 0; j < pattern_ibuf->x * pattern_ibuf->y; j++) {
if (pattern_ibuf->rect_float) {
add_v3_v3(site->color, &pattern_ibuf->rect_float[4 * j]);
}

8
source/blender/draw/engines/overlay/overlay_extra.cc
View File

@ -893,8 +893,7 @@ static void camera_view3d_reconstruction(
mul_m4_m4m4(tracking_object_mat, ob->object_to_world, object_imat);
}
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
if ((track->flag & TRACK_HAS_BUNDLE) == 0) {
continue;
}
@ -961,11 +960,10 @@ static void camera_view3d_reconstruction(
if ((v3d->flag2 & V3D_SHOW_CAMERAPATH) && (tracking_object->flag & TRACKING_OBJECT_CAMERA) &&
!is_select) {
MovieTrackingReconstruction *reconstruction;
reconstruction = BKE_tracking_object_get_reconstruction(tracking, tracking_object);
const MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
if (reconstruction->camnr) {
MovieReconstructedCamera *camera = reconstruction->cameras;
const MovieReconstructedCamera *camera = reconstruction->cameras;
float v0[3], v1[3];
for (int a = 0; a < reconstruction->camnr; a++, camera++) {
copy_v3_v3(v0, v1);

6
source/blender/editors/space_clip/clip_dopesheet_ops.c
View File

@ -64,8 +64,6 @@ static int dopesheet_select_channel_exec(bContext *C, wmOperator *op)
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
MovieTrackingDopesheetChannel *channel;
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
float location[2];
const bool extend = RNA_boolean_get(op->ptr, "extend");
int current_channel_index = 0, channel_index;
@ -74,7 +72,7 @@ static int dopesheet_select_channel_exec(bContext *C, wmOperator *op)
RNA_float_get_array(op->ptr, "location", location);
channel_index = -(location[1] - (CHANNEL_FIRST + CHANNEL_HEIGHT_HALF)) / CHANNEL_STEP;
for (channel = dopesheet->channels.first; channel; channel = channel->next) {
LISTBASE_FOREACH (MovieTrackingDopesheetChannel *, channel, &dopesheet->channels) {
MovieTrackingTrack *track = channel->track;
if (current_channel_index == channel_index) {
@ -87,7 +85,7 @@ static int dopesheet_select_channel_exec(bContext *C, wmOperator *op)
if (track->flag & TRACK_DOPE_SEL) {
object->active_track = track;
BKE_tracking_track_select(tracksbase, track, TRACK_AREA_ALL, true);
BKE_tracking_track_select(&object->tracks, track, TRACK_AREA_ALL, true);
}
else if (show_selected_only == false) {
BKE_tracking_track_deselect(track, TRACK_AREA_ALL);

7
source/blender/editors/space_clip/tracking_ops.c
View File

@ -2081,11 +2081,10 @@ static int paste_tracks_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
ListBase *tracks_base = BKE_tracking_object_get_tracks(tracking, object);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
BKE_tracking_tracks_deselect_all(tracks_base);
BKE_tracking_clipboard_paste_tracks(tracking, object);
BKE_tracking_tracks_deselect_all(&tracking_object->tracks);
BKE_tracking_clipboard_paste_tracks(tracking, tracking_object);
WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip);

54
source/blender/editors/space_clip/tracking_ops_orient.cc
View File

@ -37,7 +37,7 @@
/********************** set origin operator *********************/
static Object *get_camera_with_movieclip(Scene *scene, MovieClip *clip)
static Object *get_camera_with_movieclip(Scene *scene, const MovieClip *clip)
{
Object *camera = scene->camera;
@ -182,12 +182,11 @@ static int set_origin_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
float median[3] = {0.0f, 0.0f, 0.0f};
zero_v3(median);
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
LISTBASE_FOREACH (const MovieTrackingTrack *, track, &tracking_object->tracks) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_HAS_BUNDLE)) {
add_v3_v3(median, track->bundle_pos);
}
@ -240,9 +239,9 @@ void CLIP_OT_set_origin(wmOperatorType *ot)
static void set_axis(Scene *scene,
Object *ob,
MovieClip *clip,
MovieTrackingObject *tracking_object,
MovieTrackingTrack *track,
const MovieClip *clip,
const MovieTrackingObject *tracking_object,
const MovieTrackingTrack *track,
char axis)
{
Object *camera = get_camera_with_movieclip(scene, clip);
@ -376,10 +375,7 @@ static int set_plane_exec(bContext *C, wmOperator *op)
MovieClip *clip = ED_space_clip_get_clip(sc);
Scene *scene = CTX_data_scene(C);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object;
MovieTrackingTrack *track, *axis_track = NULL, *act_track;
ListBase *tracksbase;
Object *object;
const MovieTrackingTrack *axis_track = NULL;
Object *camera = get_camera_with_movieclip(scene, clip);
int tot = 0;
float vec[3][3], mat[4][4], obmat[4][4], newmat[4][4], orig[3] = {0.0f, 0.0f, 0.0f};
@ -397,11 +393,10 @@ static int set_plane_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
tracking_object = BKE_tracking_object_get_active(tracking);
tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
act_track = BKE_tracking_track_get_active(tracking);
const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
const MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
object = get_orientation_object(C);
Object *object = get_orientation_object(C);
if (object == NULL) {
BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");
return OPERATOR_CANCELLED;
@ -410,19 +405,22 @@ static int set_plane_exec(bContext *C, wmOperator *op)
BKE_tracking_get_camera_object_matrix(camera, mat);
/* Get 3 bundles to use as reference. */
track = static_cast<MovieTrackingTrack *>(tracksbase->first);
while (track && tot < 3) {
if (track->flag & TRACK_HAS_BUNDLE && TRACK_VIEW_SELECTED(sc, track)) {
mul_v3_m4v3(vec[tot], mat, track->bundle_pos);
if (tot == 0 || track == act_track) {
copy_v3_v3(orig, vec[tot]);
{
const MovieTrackingTrack *track = static_cast<const MovieTrackingTrack *>(
tracking_object->tracks.first);
while (track && tot < 3) {
if (track->flag & TRACK_HAS_BUNDLE && TRACK_VIEW_SELECTED(sc, track)) {
mul_v3_m4v3(vec[tot], mat, track->bundle_pos);
if (tot == 0 || track == act_track) {
copy_v3_v3(orig, vec[tot]);
}
else {
axis_track = track;
}
tot++;
}
else {
axis_track = track;
}
tot++;
track = track->next;
}
track = track->next;
}
sub_v3_v3(vec[1], vec[0]);
@ -537,8 +535,8 @@ static int set_axis_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
MovieTrackingTrack *track = static_cast<MovieTrackingTrack *>(tracksbase->first);
const MovieTrackingTrack *track = static_cast<const MovieTrackingTrack *>(
tracking_object->tracks.first);
while (track) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_HAS_BUNDLE)) {
break;

14
source/blender/editors/space_view3d/view3d_select.cc
View File

@ -2394,20 +2394,10 @@ bool ED_view3d_is_object_under_cursor(bContext *C, const int mval[2])
static void deselect_all_tracks(MovieTracking *tracking)
{
MovieTrackingObject *object;
object = static_cast<MovieTrackingObject *>(tracking->objects.first);
while (object) {
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
MovieTrackingTrack *track = static_cast<MovieTrackingTrack *>(tracksbase->first);
while (track) {
LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
BKE_tracking_track_deselect(track, TRACK_AREA_ALL);
track = track->next;
}
object = object->next;
}
}

17
source/blender/editors/space_view3d/view3d_snap.c
View File

@ -722,8 +722,6 @@ void VIEW3D_OT_snap_cursor_to_grid(wmOperatorType *ot)
static void bundle_midpoint(Scene *scene, Object *ob, float r_vec[3])
{
MovieClip *clip = BKE_object_movieclip_get(scene, ob, false);
MovieTracking *tracking;
MovieTrackingObject *object;
bool ok = false;
float min[3], max[3], mat[4][4], pos[3], cammat[4][4];
@ -731,7 +729,7 @@ static void bundle_midpoint(Scene *scene, Object *ob, float r_vec[3])
return;
}
tracking = &clip->tracking;
MovieTracking *tracking = &clip->tracking;
copy_m4_m4(cammat, ob->object_to_world);
@ -739,31 +737,28 @@ static void bundle_midpoint(Scene *scene, Object *ob, float r_vec[3])
INIT_MINMAX(min, max);
for (object = tracking->objects.first; object; object = object->next) {
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
MovieTrackingTrack *track = tracksbase->first;
LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
float obmat[4][4];
if (object->flag & TRACKING_OBJECT_CAMERA) {
if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
copy_m4_m4(obmat, mat);
}
else {
float imat[4][4];
BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, scene->r.cfra, imat);
BKE_tracking_camera_get_reconstructed_interpolate(
tracking, tracking_object, scene->r.cfra, imat);
invert_m4(imat);
mul_m4_m4m4(obmat, cammat, imat);
}
while (track) {
LISTBASE_FOREACH (const MovieTrackingTrack *, track, &tracking_object->tracks) {
if ((track->flag & TRACK_HAS_BUNDLE) && TRACK_SELECTED(track)) {
ok = 1;
mul_v3_m4v3(pos, obmat, track->bundle_pos);
minmax_v3v3_v3(min, max, pos);
}
track = track->next;
}
}

3
source/blender/editors/transform/transform_snap_object.cc
View File

@ -2467,7 +2467,6 @@ static eSnapMode snapCamera(const SnapObjectContext *sctx,
&neasrest_precalc, sctx->runtime.pmat, sctx->runtime.win_size, sctx->runtime.mval);
LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
float reconstructed_camera_mat[4][4], reconstructed_camera_imat[4][4];
const float(*vertex_obmat)[4];
@ -2478,7 +2477,7 @@ static eSnapMode snapCamera(const SnapObjectContext *sctx,
invert_m4_m4(reconstructed_camera_imat, reconstructed_camera_mat);
}
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
float bundle_pos[3];
if ((track->flag & TRACK_HAS_BUNDLE) == 0) {

42
source/blender/makesrna/intern/rna_tracking.c
View File

@ -231,33 +231,28 @@ static void rna_trackingPlaneMarker_frame_set(PointerRNA *ptr, int value)
MovieClip *clip = (MovieClip *)ptr->owner_id;
MovieTracking *tracking = &clip->tracking;
MovieTrackingPlaneMarker *plane_marker = (MovieTrackingPlaneMarker *)ptr->data;
MovieTrackingObject *tracking_object;
bool found = false;
MovieTrackingPlaneTrack *plane_track = NULL;
MovieTrackingPlaneTrack *plane_track_of_marker = NULL;
for (tracking_object = tracking->objects.first; tracking_object;
tracking_object = tracking_object->next) {
ListBase *tracksbase = BKE_tracking_object_get_plane_tracks(tracking, tracking_object);
for (plane_track = tracksbase->first; plane_track; plane_track = plane_track->next) {
LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, &tracking_object->plane_tracks) {
if (plane_marker >= plane_track->markers &&
plane_marker < plane_track->markers + plane_track->markersnr) {
found = true;
plane_track_of_marker = plane_track;
break;
}
}
if (found) {
if (plane_track_of_marker) {
break;
}
}
if (found) {
if (plane_track_of_marker) {
MovieTrackingPlaneMarker new_plane_marker = *plane_marker;
new_plane_marker.framenr = value;
BKE_tracking_plane_marker_delete(plane_track, plane_marker->framenr);
BKE_tracking_plane_marker_insert(plane_track, &new_plane_marker);
BKE_tracking_plane_marker_delete(plane_track_of_marker, plane_marker->framenr);
BKE_tracking_plane_marker_insert(plane_track_of_marker, &new_plane_marker);
}
}
@ -506,32 +501,27 @@ static void rna_trackingMarker_frame_set(PointerRNA *ptr, int value)
MovieClip *clip = (MovieClip *)ptr->owner_id;
MovieTracking *tracking = &clip->tracking;
MovieTrackingMarker *marker = (MovieTrackingMarker *)ptr->data;
MovieTrackingObject *tracking_object;
bool found = false;
MovieTrackingTrack *track = NULL;
MovieTrackingTrack *track_of_marker = NULL;
for (tracking_object = tracking->objects.first; tracking_object;
tracking_object = tracking_object->next) {
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
for (track = tracksbase->first; track; track = track->next) {
LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
if (marker >= track->markers && marker < track->markers + track->markersnr) {
found = true;
track_of_marker = track;
break;
}
}
if (found) {
if (track_of_marker) {
break;
}
}
if (found) {
if (track_of_marker) {
MovieTrackingMarker new_marker = *marker;
new_marker.framenr = value;
BKE_tracking_marker_delete(track, marker->framenr);
BKE_tracking_marker_insert(track, &new_marker);
BKE_tracking_marker_delete(track_of_marker, marker->framenr);
BKE_tracking_marker_insert(track_of_marker, &new_marker);
}
}