blender
/
blender
136
406
Fork 589
Code Issues 6.3k Pull Requests 766 Projects 19 Wiki Activity

Refactor: Unify storage for motion tracking camera and objects 

Historically tracks and reconstruction for motion tracking camera
object were stored in the motion tracking structure. This is because
the data structures pre-dates object tracking support, and it was
never changed to preserve compatibility.

Now the compatibility code supports more tricks and allows to change
the ownership without breaking any compatibility. This is what this
change does: it moves tracks from motion tracking structure to the
motion tracking camera object, and does it in a way that no
compatibility is broken.

One of the side-effects of this change is that the active track is
now stored on motion tracking object level, which allows to change
active motion tracking object without loosing active track. Other
than that there are no expected user-level changes.
This commit is contained in:
Sergey Sharybin 2022-10-04 17:39:57 +02:00
parent 4d497721ec
commit fe38715600
Notes: blender-bot 2023-05-17 19:03:48 +02:00 
Referenced by commit 9f3b0e41bb, Fix T102887: crash deleting plane track
Referenced by issue #103080, Regression: Setup tracking scene is disabled
Referenced by pull request #108015, Core: Write mesh and movieclip with new format
Referenced by commit 1b63a290c6, Core: Write mesh and movieclip with new format
18 changed files with 321 additions and 321 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -839,7 +839,7 @@ void BKE_tracking_get_rna_path_prefix_for_plane_track(
#define MARKER_VISIBLE(sc, track, marker) \
(((marker)->flag & MARKER_DISABLED) == 0 || ((sc)->flag & SC_HIDE_DISABLED) == 0 || \
((sc)->clip->tracking.act_track == track))
(BKE_tracking_track_get_active(&(sc)->clip->tracking) == track))
#ifdef __cplusplus
}

89
source/blender/blenkernel/intern/movieclip.c
View File

@ -69,6 +69,10 @@
#include "BLO_read_write.h"
/* Convert camera object to legacy format where the camera tracks are stored in the MovieTracking
* structure when saving .blend file. */
#define USE_LEGACY_CAMERA_OBJECT_FORMAT_ON_SAVE 1
static void free_buffers(MovieClip *clip);
static void movie_clip_init_data(ID *id)
@ -117,18 +121,11 @@ static void movie_clip_foreach_id(ID *id, LibraryForeachIDData *data)
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, movie_clip->gpd, IDWALK_CB_USER);
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, track->gpd, IDWALK_CB_USER);
}
LISTBASE_FOREACH (MovieTrackingObject *, object, &tracking->objects) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, track->gpd, IDWALK_CB_USER);
}
}
LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, &tracking->plane_tracks) {
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, plane_track->image, IDWALK_CB_USER);
}
}
static void movie_clip_foreach_cache(ID *id,
@ -200,7 +197,29 @@ static void movieclip_blend_write(BlendWriter *writer, ID *id, const void *id_ad
clip->tracking.stats = NULL;
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *object;
#if USE_LEGACY_CAMERA_OBJECT_FORMAT_ON_SAVE
const bool is_undo = BLO_write_is_undo(writer);
/* When using legacy format for camera object assign the list of camera tracks to the
* MovieTracking object. Do it in-place as it simplifies the code a bit, and it is not
* supposed to cause threading issues as no other code is meant to access the legacy fields. */
if (!is_undo) {
MovieTrackingObject *active_tracking_object = BKE_tracking_object_get_active(tracking);
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(tracking);
BLI_assert(active_tracking_object != NULL);
BLI_assert(tracking_camera_object != NULL);
tracking->tracks_legacy = tracking_camera_object->tracks;
tracking->plane_tracks_legacy = tracking_camera_object->plane_tracks;
/* The active track in the tracking structure used to be shared across all tracking objects. */
tracking->act_track_legacy = active_tracking_object->active_track;
tracking->act_plane_track_legacy = active_tracking_object->active_plane_track;
tracking->reconstruction_legacy = tracking_camera_object->reconstruction;
}
#endif
BLO_write_id_struct(writer, MovieClip, id_address, &clip->id);
BKE_id_blend_write(writer, &clip->id);
@ -209,20 +228,40 @@ static void movieclip_blend_write(BlendWriter *writer, ID *id, const void *id_ad
BKE_animdata_blend_write(writer, clip->adt);
}
write_movieTracks(writer, &tracking->tracks);
write_moviePlaneTracks(writer, &tracking->plane_tracks);
write_movieReconstruction(writer, &tracking->reconstruction);
object = tracking->objects.first;
while (object) {
BLO_write_struct(writer, MovieTrackingObject, object);
LISTBASE_FOREACH (MovieTrackingObject *, object, &tracking->objects) {
#if USE_LEGACY_CAMERA_OBJECT_FORMAT_ON_SAVE
/* When saving camers object in the legacy format clear the list of tracks. This is because the
* tracking object code is generic and assumes object owns the tracks in the list. For the
* camera tracks that is not the case in the legacy format. */
if (!is_undo && (object->flag & TRACKING_OBJECT_CAMERA)) {
MovieTrackingObject legacy_object = *object;
BLI_listbase_clear(&legacy_object.tracks);
BLI_listbase_clear(&legacy_object.plane_tracks);
legacy_object.active_track = NULL;
legacy_object.active_plane_track = NULL;
memset(&legacy_object.reconstruction, 0, sizeof(legacy_object.reconstruction));
BLO_write_struct_at_address(writer, MovieTrackingObject, object, &legacy_object);
}
else
#endif
{
BLO_write_struct(writer, MovieTrackingObject, object);
}
write_movieTracks(writer, &object->tracks);
write_moviePlaneTracks(writer, &object->plane_tracks);
write_movieReconstruction(writer, &object->reconstruction);
object = object->next;
}
#if USE_LEGACY_CAMERA_OBJECT_FORMAT_ON_SAVE
if (!is_undo) {
BLI_listbase_clear(&tracking->tracks_legacy);
BLI_listbase_clear(&tracking->plane_tracks_legacy);
tracking->act_track_legacy = NULL;
tracking->act_plane_track_legacy = NULL;
memset(&tracking->reconstruction_legacy, 0, sizeof(tracking->reconstruction_legacy));
}
#endif
}
static void direct_link_movieReconstruction(BlendDataReader *reader,
@ -262,12 +301,12 @@ static void movieclip_blend_read_data(BlendDataReader *reader, ID *id)
BLO_read_data_address(reader, &clip->adt);
BKE_animdata_blend_read_data(reader, clip->adt);
direct_link_movieTracks(reader, &tracking->tracks);
direct_link_moviePlaneTracks(reader, &tracking->plane_tracks);
direct_link_movieReconstruction(reader, &tracking->reconstruction);
direct_link_movieTracks(reader, &tracking->tracks_legacy);
direct_link_moviePlaneTracks(reader, &tracking->plane_tracks_legacy);
direct_link_movieReconstruction(reader, &tracking->reconstruction_legacy);
BLO_read_data_address(reader, &clip->tracking.act_track);
BLO_read_data_address(reader, &clip->tracking.act_plane_track);
BLO_read_data_address(reader, &clip->tracking.act_track_legacy);
BLO_read_data_address(reader, &clip->tracking.act_plane_track_legacy);
clip->anim = NULL;
clip->tracking_context = NULL;
@ -290,6 +329,9 @@ static void movieclip_blend_read_data(BlendDataReader *reader, ID *id)
direct_link_movieTracks(reader, &object->tracks);
direct_link_moviePlaneTracks(reader, &object->plane_tracks);
direct_link_movieReconstruction(reader, &object->reconstruction);
BLO_read_data_address(reader, &object->active_track);
BLO_read_data_address(reader, &object->active_plane_track);
}
}
@ -316,9 +358,6 @@ static void movieclip_blend_read_lib(BlendLibReader *reader, ID *id)
BLO_read_id_address(reader, clip->id.lib, &clip->gpd);
lib_link_movieTracks(reader, clip, &tracking->tracks);
lib_link_moviePlaneTracks(reader, clip, &tracking->plane_tracks);
LISTBASE_FOREACH (MovieTrackingObject *, object, &tracking->objects) {
lib_link_movieTracks(reader, clip, &object->tracks);
lib_link_moviePlaneTracks(reader, clip, &object->plane_tracks);

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

@ -149,9 +149,6 @@ static void tracking_dopesheet_free(MovieTrackingDopesheet *dopesheet)
void BKE_tracking_free(MovieTracking *tracking)
{
tracking_tracks_free(&tracking->tracks);
tracking_plane_tracks_free(&tracking->plane_tracks);
tracking_reconstruction_free(&tracking->reconstruction);
tracking_objects_free(&tracking->objects);
if (tracking->camera.intrinsics) {
@ -247,8 +244,7 @@ static void tracking_reconstruction_copy(TrackingCopyContext *UNUSED(ctx),
}
/* Copy stabilization structure. */
static void tracking_stabilization_copy(TrackingCopyContext *UNUSED(ctx),
MovieTrackingStabilization *stabilization_dst,
static void tracking_stabilization_copy(MovieTrackingStabilization *stabilization_dst,
const MovieTrackingStabilization *stabilization_src,
const int UNUSED(flag))
{
@ -268,6 +264,17 @@ static void tracking_object_copy(MovieTrackingObject *object_dst,
tracking_reconstruction_copy(
&ctx, &object_dst->reconstruction, &object_src->reconstruction, flag);
if (object_src->active_track) {
object_dst->active_track = BLI_ghash_lookup(ctx.old_to_new_track_map,
object_src->active_track);
BLI_assert(object_dst->active_track != NULL);
}
if (object_src->active_plane_track) {
object_dst->active_plane_track = BLI_ghash_lookup(ctx.old_to_new_track_map,
object_src->active_plane_track);
BLI_assert(object_dst->active_plane_track != NULL);
}
tracking_copy_context_delete(&ctx);
}
@ -291,25 +298,7 @@ void BKE_tracking_copy(MovieTracking *tracking_dst,
{
*tracking_dst = *tracking_src;
TrackingCopyContext ctx = tracking_copy_context_new();
tracking_tracks_copy(&ctx, &tracking_dst->tracks, &tracking_src->tracks, flag);
tracking_plane_tracks_copy(&ctx, &tracking_dst->plane_tracks, &tracking_src->plane_tracks, flag);
tracking_reconstruction_copy(
&ctx, &tracking_dst->reconstruction, &tracking_src->reconstruction, flag);
tracking_stabilization_copy(
&ctx, &tracking_dst->stabilization, &tracking_src->stabilization, flag);
if (tracking_src->act_track) {
tracking_dst->act_track = BLI_ghash_lookup(ctx.old_to_new_track_map, tracking_src->act_track);
BLI_assert(tracking_dst->act_track != NULL);
}
if (tracking_src->act_plane_track) {
tracking_dst->act_plane_track = BLI_ghash_lookup(ctx.old_to_new_track_map,
tracking_src->act_plane_track);
BLI_assert(tracking_dst->act_plane_track != NULL);
}
tracking_copy_context_delete(&ctx);
tracking_stabilization_copy(&tracking_dst->stabilization, &tracking_src->stabilization, flag);
tracking_objects_copy(&tracking_dst->objects, &tracking_src->objects, flag);
@ -367,23 +356,17 @@ void BKE_tracking_settings_init(MovieTracking *tracking)
ListBase *BKE_tracking_get_active_tracks(MovieTracking *tracking)
{
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
BLI_assert(object != NULL);
if (object && (object->flag & TRACKING_OBJECT_CAMERA) == 0) {
return &object->tracks;
}
return &tracking->tracks;
return &object->tracks;
}
ListBase *BKE_tracking_get_active_plane_tracks(MovieTracking *tracking)
{
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
BLI_assert(object != NULL);
if (object && (object->flag & TRACKING_OBJECT_CAMERA) == 0) {
return &object->plane_tracks;
}
return &tracking->plane_tracks;
return &object->plane_tracks;
}
MovieTrackingReconstruction *BKE_tracking_get_active_reconstruction(MovieTracking *tracking)
@ -514,8 +497,10 @@ void BKE_tracking_clipboard_paste_tracks(MovieTracking *tracking, MovieTrackingO
while (track) {
MovieTrackingTrack *new_track = BKE_tracking_track_duplicate(track);
/* TODO(sergey): Preserve active track from before the copy. */
if (track->prev == NULL) {
tracking->act_track = new_track;
object->active_track = new_track;
}
BLI_addtail(tracksbase, new_track);
@ -1109,20 +1094,15 @@ MovieTrackingTrack *BKE_tracking_track_get_indexed(MovieTracking *tracking,
MovieTrackingTrack *BKE_tracking_track_get_active(MovieTracking *tracking)
{
ListBase *tracksbase;
if (!tracking->act_track) {
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
if (tracking_object->active_track == NULL) {
return NULL;
}
tracksbase = BKE_tracking_get_active_tracks(tracking);
/* Perform data consistency check. */
BLI_assert(BLI_findindex(&tracking_object->tracks, tracking_object->active_track) != -1);
/* check that active track is in current tracks list */
if (BLI_findindex(tracksbase, tracking->act_track) != -1) {
return tracking->act_track;
}
return NULL;
return tracking_object->active_track;
}
static bGPDlayer *track_mask_gpencil_layer_get(const MovieTrackingTrack *track)
@ -1738,18 +1718,16 @@ MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_named(MovieTracking *track
MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_active(struct MovieTracking *tracking)
{
if (tracking->act_plane_track == NULL) {
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
if (tracking_object->active_plane_track == NULL) {
return NULL;
}
ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
/* Perform data consistency check. */
BLI_assert(BLI_findindex(&tracking_object->plane_tracks, tracking_object->active_plane_track) !=
-1);
/* Check that active track is in current plane tracks list */
if (BLI_findindex(plane_tracks_base, tracking->act_plane_track) != -1) {
return tracking->act_plane_track;
}
return NULL;
return tracking_object->active_plane_track;
}
void BKE_tracking_plane_tracks_deselect_all(ListBase *plane_tracks_base)
@ -2047,7 +2025,6 @@ MovieTrackingObject *BKE_tracking_object_add(MovieTracking *tracking, const char
bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *object)
{
MovieTrackingTrack *track;
int index = BLI_findindex(&tracking->objects, object);
if (index == -1) {
@ -2059,15 +2036,6 @@ bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *ob
return false;
}
track = object->tracks.first;
while (track) {
if (track == tracking->act_track) {
tracking->act_track = NULL;
}
track = track->next;
}
tracking_object_free(object);
BLI_freelinkN(&tracking->objects, object);
@ -2130,32 +2098,21 @@ MovieTrackingObject *BKE_tracking_object_get_camera(const MovieTracking *trackin
return NULL;
}
ListBase *BKE_tracking_object_get_tracks(MovieTracking *tracking, MovieTrackingObject *object)
ListBase *BKE_tracking_object_get_tracks(MovieTracking *UNUSED(tracking),
MovieTrackingObject *object)
{
if (object->flag & TRACKING_OBJECT_CAMERA) {
return &tracking->tracks;
}
return &object->tracks;
}
ListBase *BKE_tracking_object_get_plane_tracks(MovieTracking *tracking,
ListBase *BKE_tracking_object_get_plane_tracks(MovieTracking *UNUSED(tracking),
MovieTrackingObject *object)
{
if (object->flag & TRACKING_OBJECT_CAMERA) {
return &tracking->plane_tracks;
}
return &object->plane_tracks;
}
MovieTrackingReconstruction *BKE_tracking_object_get_reconstruction(MovieTracking *tracking,
MovieTrackingObject *object)
MovieTrackingReconstruction *BKE_tracking_object_get_reconstruction(
MovieTracking *UNUSED(tracking), MovieTrackingObject *object)
{
if (object->flag & TRACKING_OBJECT_CAMERA) {
return &tracking->reconstruction;
}
return &object->reconstruction;
}
@ -3464,10 +3421,6 @@ void BKE_tracking_dopesheet_update(MovieTracking *tracking)
MovieTrackingObject *BKE_tracking_find_object_for_track(const MovieTracking *tracking,
const MovieTrackingTrack *track)
{
const ListBase *tracksbase = &tracking->tracks;
if (BLI_findindex(tracksbase, track) != -1) {
return NULL;
}
MovieTrackingObject *object = tracking->objects.first;
while (object != NULL) {
if (BLI_findindex(&object->tracks, track) != -1) {
@ -3482,19 +3435,14 @@ ListBase *BKE_tracking_find_tracks_list_for_track(MovieTracking *tracking,
const MovieTrackingTrack *track)
{
MovieTrackingObject *object = BKE_tracking_find_object_for_track(tracking, track);
if (object != NULL) {
return &object->tracks;
}
return &tracking->tracks;
BLI_assert(object != NULL);
return &object->tracks;
}
MovieTrackingObject *BKE_tracking_find_object_for_plane_track(
const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track)
{
const ListBase *plane_tracks_base = &tracking->plane_tracks;
if (BLI_findindex(plane_tracks_base, plane_track) != -1) {
return NULL;
}
MovieTrackingObject *object = tracking->objects.first;
while (object != NULL) {
if (BLI_findindex(&object->plane_tracks, plane_track) != -1) {
@ -3509,10 +3457,9 @@ ListBase *BKE_tracking_find_tracks_list_for_plane_track(MovieTracking *tracking,
const MovieTrackingPlaneTrack *plane_track)
{
MovieTrackingObject *object = BKE_tracking_find_object_for_plane_track(tracking, plane_track);
if (object != NULL) {
return &object->plane_tracks;
}
return &tracking->plane_tracks;
BLI_assert(object != NULL);
return &object->plane_tracks;
}
void BKE_tracking_get_rna_path_for_track(const struct MovieTracking *tracking,

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

@ -40,7 +40,6 @@ typedef struct MovieReconstructContext {
struct libmv_Reconstruction *reconstruction;
char object_name[MAX_NAME];
bool is_camera;
short motion_flag;
libmv_CameraIntrinsicsOptions camera_intrinsics_options;
@ -137,16 +136,10 @@ static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context,
int sfra = context->sfra, efra = context->efra;
float imat[4][4];
if (context->is_camera) {
tracksbase = &tracking->tracks;
reconstruction = &tracking->reconstruction;
}
else {
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name);
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name);
tracksbase = &object->tracks;
reconstruction = &object->reconstruction;
}
tracksbase = &object->tracks;
reconstruction = &object->reconstruction;
unit_m4(imat);
@ -355,7 +348,6 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip
MovieTrackingTrack *track;
BLI_strncpy(context->object_name, object->name, sizeof(context->object_name));
context->is_camera = object->flag & TRACKING_OBJECT_CAMERA;
context->motion_flag = tracking->settings.motion_flag;
context->select_keyframes = (tracking->settings.reconstruction_flag &
@ -364,7 +356,7 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip
tracking_cameraIntrinscisOptionsFromTracking(
tracking, width, height, &context->camera_intrinsics_options);
context->tracks_map = tracks_map_new(context->object_name, context->is_camera, num_tracks, 0);
context->tracks_map = tracks_map_new(context->object_name, num_tracks, 0);
track = tracksbase->first;
while (track) {
@ -526,13 +518,7 @@ bool BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieT
BKE_tracking_dopesheet_tag_update(tracking);
object = BKE_tracking_object_get_named(tracking, context->object_name);
if (context->is_camera) {
reconstruction = &tracking->reconstruction;
}
else {
reconstruction = &object->reconstruction;
}
reconstruction = &object->reconstruction;
/* update keyframe in the interface */
if (context->select_keyframes) {

24
source/blender/blenkernel/intern/tracking_stabilize.c
View File

@ -302,7 +302,9 @@ static void find_next_working_frames(StabContext *ctx,
int *next_lower,
int *next_higher)
{
LISTBASE_FOREACH (MovieTrackingTrack *, track, &ctx->tracking->tracks) {
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(ctx->tracking);
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
if (is_usable_for_stabilization(ctx, track)) {
int startpoint = search_closest_marker_index(track, framenr);
retrieve_next_higher_usable_frame(ctx, track, startpoint, framenr, next_higher);
@ -514,6 +516,7 @@ static bool average_track_contributions(StabContext *ctx,
float weight_sum;
MovieTracking *tracking = ctx->tracking;
MovieTrackingStabilization *stab = &tracking->stabilization;
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(ctx->tracking);
float ref_pos[2];
BLI_assert(stab->flag & TRACKING_2D_STABILIZATION);
@ -525,7 +528,7 @@ static bool average_track_contributions(StabContext *ctx,
ok = false;
weight_sum = 0.0f;
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
if (!is_init_for_stabilization(ctx, track)) {
continue;
}
@ -563,7 +566,7 @@ static bool average_track_contributions(StabContext *ctx,
ok = false;
weight_sum = 0.0f;
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
if (!is_init_for_stabilization(ctx, track)) {
continue;
}
@ -618,11 +621,11 @@ static void average_marker_positions(StabContext *ctx, int framenr, float r_ref_
{
bool ok = false;
float weight_sum;
MovieTracking *tracking = ctx->tracking;
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(ctx->tracking);
zero_v2(r_ref_pos);
weight_sum = 0.0f;
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
if (track->flag & TRACK_USE_2D_STAB) {
float weight = 0.0f;
MovieTrackingMarker *marker = get_tracking_data_point(ctx, track, framenr, &weight);
@ -645,7 +648,7 @@ static void average_marker_positions(StabContext *ctx, int framenr, float r_ref_
int next_lower = MINAFRAME;
int next_higher = MAXFRAME;
use_values_from_fcurves(ctx, true);
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
/* NOTE: we deliberately do not care if this track
* is already initialized for stabilization. */
if (track->flag & TRACK_USE_2D_STAB) {
@ -737,9 +740,10 @@ static int establish_track_initialization_order(StabContext *ctx, TrackInitOrder
{
size_t tracknr = 0;
MovieTracking *tracking = ctx->tracking;
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(tracking);
int anchor_frame = tracking->stabilization.anchor_frame;
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
MovieTrackingMarker *marker;
order[tracknr].data = track;
marker = get_closest_marker(ctx, track, anchor_frame);
@ -847,6 +851,7 @@ static void init_all_tracks(StabContext *ctx, float aspect)
size_t track_len = 0;
MovieClip *clip = ctx->clip;
MovieTracking *tracking = ctx->tracking;
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(tracking);
TrackInitOrder *order;
/* Attempt to start initialization at anchor_frame.
@ -859,7 +864,7 @@ static void init_all_tracks(StabContext *ctx, float aspect)
zero_v2(pivot);
/* Initialize private working data. */
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
TrackStabilizationBase *local_data = access_stabilization_baseline_data(ctx, track);
if (!local_data) {
local_data = MEM_callocN(sizeof(TrackStabilizationBase),
@ -1102,6 +1107,7 @@ static void stabilization_data_to_mat4(float pixel_aspect,
static float calculate_autoscale_factor(StabContext *ctx, int size, float aspect)
{
MovieTrackingStabilization *stab = ctx->stab;
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(ctx->tracking);
float pixel_aspect = ctx->tracking->camera.pixel_aspect;
int height = size, width = aspect * size;
@ -1109,7 +1115,7 @@ static float calculate_autoscale_factor(StabContext *ctx, int size, float aspect
float scale = 1.0f, scale_step = 0.0f;
/* Calculate maximal frame range of tracks where stabilization is active. */
LISTBASE_FOREACH (MovieTrackingTrack *, track, &ctx->tracking->tracks) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
if ((track->flag & TRACK_USE_2D_STAB) ||
((stab->flag & TRACKING_STABILIZE_ROTATION) && (track->flag & TRACK_USE_2D_STAB_ROT))) {
int first_frame = track->markers[0].framenr;

22
source/blender/blenkernel/intern/tracking_util.c
View File

@ -48,15 +48,11 @@
/** \name Tracks Map
* \{ */
TracksMap *tracks_map_new(const char *object_name,
bool is_camera,
int num_tracks,
int customdata_size)
TracksMap *tracks_map_new(const char *object_name, int num_tracks, int customdata_size)
{
TracksMap *map = MEM_callocN(sizeof(TracksMap), "TrackingsMap");
BLI_strncpy(map->object_name, object_name, sizeof(map->object_name));
map->is_camera = is_camera;
map->num_tracks = num_tracks;
map->customdata_size = customdata_size;
@ -114,19 +110,13 @@ void tracks_map_merge(TracksMap *map, MovieTracking *tracking)
ListBase tracks = {NULL, NULL}, new_tracks = {NULL, NULL};
ListBase *old_tracks;
if (map->is_camera) {
old_tracks = &tracking->tracks;
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, map->object_name);
if (!object) {
/* object was deleted by user, create new one */
object = BKE_tracking_object_add(tracking, map->object_name);
}
else {
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, map->object_name);
if (!object) {
/* object was deleted by user, create new one */
object = BKE_tracking_object_add(tracking, map->object_name);
}
old_tracks = &object->tracks;
}
old_tracks = &object->tracks;
/* duplicate currently operating tracks to temporary list.
* this is needed to keep names in unique state and it's faster to change names

6
source/blender/blenkernel/tracking_private.h
View File

@ -26,7 +26,6 @@ struct libmv_CameraIntrinsicsOptions;
typedef struct TracksMap {
char object_name[MAX_NAME];
bool is_camera;
int num_tracks;
int customdata_size;
@ -42,10 +41,7 @@ typedef struct TracksMap {
SpinLock spin_lock;
} TracksMap;
struct TracksMap *tracks_map_new(const char *object_name,
bool is_camera,
int num_tracks,
int customdata_size);
struct TracksMap *tracks_map_new(const char *object_name, int num_tracks, int customdata_size);
int tracks_map_get_size(struct TracksMap *map);
void tracks_map_get_indexed_element(struct TracksMap *map,
int index,

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

@ -856,7 +856,7 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
clip->tracking.camera.pixel_aspect = 1.0f;
}
track = clip->tracking.tracks.first;
track = clip->tracking.tracks_legacy.first;
while (track) {
if (track->minimum_correlation == 0.0f) {
track->minimum_correlation = 0.75f;
@ -1442,7 +1442,7 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
MovieTrackingTrack *track;
track = clip->tracking.tracks.first;
track = clip->tracking.tracks_legacy.first;
while (track) {
do_versions_affine_tracker_track(track);
@ -1738,7 +1738,7 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
MovieTrackingTrack *track;
MovieTrackingObject *object;
for (track = clip->tracking.tracks.first; track; track = track->next) {
for (track = clip->tracking.tracks_legacy.first; track; track = track->next) {
do_versions_affine_tracker_track(track);
}
@ -2459,7 +2459,7 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
MovieClip *clip;
for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
MovieTrackingPlaneTrack *plane_track;
for (plane_track = clip->tracking.plane_tracks.first; plane_track;
for (plane_track = clip->tracking.plane_tracks_legacy.first; plane_track;
plane_track = plane_track->next) {
plane_track->image_opacity = 1.0f;
}

48
source/blender/blenloader/intern/versioning_400.cc
View File

@ -8,8 +8,14 @@
#include "CLG_log.h"
#include "DNA_movieclip_types.h"
#include "BLI_assert.h"
#include "BLI_listbase.h"
#include "BKE_main.h"
#include "BKE_mesh_legacy_convert.h"
#include "BKE_tracking.h"
#include "BLO_readfile.h"
@ -29,6 +35,47 @@ static void version_mesh_legacy_to_struct_of_array_format(Mesh &mesh)
BKE_mesh_legacy_edge_crease_to_layers(&mesh);
}
static void version_motion_tracking_legacy_camera_object(MovieClip &movieclip)
{
MovieTracking &tracking = movieclip.tracking;
MovieTrackingObject *active_tracking_object = BKE_tracking_object_get_active(&tracking);
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&tracking);
/* Sanity check.
* The camera tracking object is not supposed to have tracking and reconstruction read into it
* yet. */
BLI_assert(tracking_camera_object != nullptr);
BLI_assert(BLI_listbase_is_empty(&tracking_camera_object->tracks));
BLI_assert(BLI_listbase_is_empty(&tracking_camera_object->plane_tracks));
BLI_assert(tracking_camera_object->reconstruction.cameras == nullptr);
/* Move storage from tracking to the actual tracking object. */
tracking_camera_object->tracks = tracking.tracks_legacy;
tracking_camera_object->plane_tracks = tracking.plane_tracks_legacy;
tracking_camera_object->reconstruction = tracking.reconstruction_legacy;
memset(&tracking.reconstruction_legacy, 0, sizeof(tracking.reconstruction_legacy));
/* The active track in the tracking structure used to be shared across all tracking objects. */
active_tracking_object->active_track = tracking.act_track_legacy;
active_tracking_object->active_plane_track = tracking.act_plane_track_legacy;
/* Clear pointers in the legacy storage. */
BLI_listbase_clear(&tracking.tracks_legacy);
BLI_listbase_clear(&tracking.plane_tracks_legacy);
tracking.act_track_legacy = nullptr;
tracking.act_plane_track_legacy = nullptr;
}
void version_movieclips_legacy_camera_object(Main *bmain)
{
LISTBASE_FOREACH (MovieClip *, movieclip, &bmain->movieclips) {
version_motion_tracking_legacy_camera_object(*movieclip);
}
}
void blo_do_versions_400(FileData * /*fd*/, Library * /*lib*/, Main *bmain)
{
// if (!MAIN_VERSION_ATLEAST(bmain, 400, 0)) {
@ -38,6 +85,7 @@ void blo_do_versions_400(FileData * /*fd*/, Library * /*lib*/, Main *bmain)
LISTBASE_FOREACH (Mesh *, mesh, &bmain->meshes) {
version_mesh_legacy_to_struct_of_array_format(*mesh);
}
version_movieclips_legacy_camera_object(bmain);
// }
/**

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

@ -86,7 +86,7 @@ static int dopesheet_select_channel_exec(bContext *C, wmOperator *op)
}
if (track->flag & TRACK_DOPE_SEL) {
tracking->act_track = track;
object->active_track = track;
BKE_tracking_track_select(tracksbase, track, TRACK_AREA_ALL, true);
}
else if (show_selected_only == false) {

5
source/blender/editors/space_clip/clip_graph_ops.c
View File

@ -249,10 +249,9 @@ static bool mouse_select_curve(bContext *C, const float co[2], bool extend)
SelectUserData selectdata = {SEL_DESELECT};
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
tracking->act_track = userdata.track;
object->active_track = userdata.track;
if ((sc->flag & SC_SHOW_GRAPH_SEL_ONLY) == 0) {
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
BKE_tracking_track_select(tracksbase, userdata.track, TRACK_AREA_ALL, false);
BKE_tracking_track_select(&object->tracks, userdata.track, TRACK_AREA_ALL, false);
}
/* deselect all knots on newly selected curve */

9
source/blender/editors/space_clip/clip_utils.c
View File

@ -311,13 +311,12 @@ void clip_graph_tracking_iterate(SpaceClip *sc,
void clip_delete_track(bContext *C, MovieClip *clip, MovieTrackingTrack *track)
{
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
bool has_bundle = false;
const bool used_for_stabilization = (track->flag &
(TRACK_USE_2D_STAB | TRACK_USE_2D_STAB_ROT)) != 0;
if (track == act_track) {
tracking->act_track = NULL;
if (track == tracking_object->active_track) {
tracking_object->active_track = NULL;
}
/* Handle reconstruction display in 3d viewport. */
if (track->flag & TRACK_HAS_BUNDLE) {
@ -334,7 +333,7 @@ void clip_delete_track(bContext *C, MovieClip *clip, MovieTrackingTrack *track)
}
/* Delete track itself. */
BKE_tracking_track_free(track);
BLI_freelinkN(tracksbase, track);
BLI_freelinkN(&tracking_object->tracks, track);
/* Send notifiers. */
WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip);
if (used_for_stabilization) {

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

@ -49,8 +49,7 @@ static bool add_marker(const bContext *C, float x, float y)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
MovieTrackingTrack *track;
int width, height;
int framenr = ED_space_clip_get_clip_frame_number(sc);
@ -61,13 +60,13 @@ static bool add_marker(const bContext *C, float x, float y)
return false;
}
track = BKE_tracking_track_add(tracking, tracksbase, x, y, framenr, width, height);
track = BKE_tracking_track_add(tracking, &tracking_object->tracks, x, y, framenr, width, height);
BKE_tracking_track_select(tracksbase, track, TRACK_AREA_ALL, 0);
BKE_tracking_plane_tracks_deselect_all(plane_tracks_base);
BKE_tracking_track_select(&tracking_object->tracks, track, TRACK_AREA_ALL, 0);
BKE_tracking_plane_tracks_deselect_all(&tracking_object->plane_tracks);
clip->tracking.act_track = track;
clip->tracking.act_plane_track = NULL;
tracking_object->active_track = track;
tracking_object->active_plane_track = NULL;
return true;
}
@ -683,9 +682,10 @@ static int slide_marker_invoke(bContext *C, wmOperator *op, const wmEvent *event
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
tracking->act_track = slidedata->track;
tracking->act_plane_track = NULL;
tracking_object->active_track = slidedata->track;
tracking_object->active_plane_track = NULL;
op->customdata = slidedata;
@ -1136,14 +1136,13 @@ static int hide_tracks_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
int unselected;
unselected = RNA_boolean_get(op->ptr, "unselected");
/* Hide point tracks. */
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) {
LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
if (unselected == 0 && TRACK_VIEW_SELECTED(sc, track)) {
track->flag |= TRACK_HIDDEN;
}
@ -1152,15 +1151,13 @@ static int hide_tracks_exec(bContext *C, wmOperator *op)
}
}
if (act_track != NULL && act_track->flag & TRACK_HIDDEN) {
clip->tracking.act_track = NULL;
const MovieTrackingTrack *active_track = tracking_object->active_track;
if (active_track != NULL && active_track->flag & TRACK_HIDDEN) {
tracking_object->active_track = NULL;
}
/* Hide place tracks. */
ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
MovieTrackingPlaneTrack *act_plane_track = BKE_tracking_plane_track_get_active(tracking);
for (MovieTrackingPlaneTrack *plane_track = plane_tracks_base->first; plane_track != NULL;
plane_track = plane_track->next) {
LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, &tracking_object->plane_tracks) {
if (unselected == 0 && plane_track->flag & SELECT) {
plane_track->flag |= PLANE_TRACK_HIDDEN;
}
@ -1168,8 +1165,10 @@ static int hide_tracks_exec(bContext *C, wmOperator *op)
plane_track->flag |= PLANE_TRACK_HIDDEN;
}
}
if (act_plane_track != NULL && act_plane_track->flag & TRACK_HIDDEN) {
clip->tracking.act_plane_track = NULL;
const MovieTrackingPlaneTrack *active_plane_track = tracking_object->active_plane_track;
if (active_plane_track != NULL && active_plane_track->flag & TRACK_HIDDEN) {
tracking_object->active_plane_track = NULL;
}
BKE_tracking_dopesheet_tag_update(tracking);
@ -1261,6 +1260,7 @@ static int frame_jump_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
int pos = RNA_enum_get(op->ptr, "position");
int delta;
@ -1284,16 +1284,15 @@ static int frame_jump_exec(bContext *C, wmOperator *op)
}
}
else { /* to failed frame */
if (tracking->reconstruction.flag & TRACKING_RECONSTRUCTED) {
if (tracking_object->reconstruction.flag & TRACKING_RECONSTRUCTED) {
int framenr = ED_space_clip_get_clip_frame_number(sc);
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
delta = pos == 3 ? 1 : -1;
framenr += delta;
while (framenr + delta >= scene->r.sfra && framenr + delta <= scene->r.efra) {
MovieReconstructedCamera *cam = BKE_tracking_camera_get_reconstructed(
tracking, object, framenr);
tracking, tracking_object, framenr);
if (cam == NULL) {
sc->user.framenr = BKE_movieclip_remap_clip_to_scene_frame(clip, framenr);
@ -1454,6 +1453,7 @@ static int average_tracks_exec(bContext *C, wmOperator *op)
SpaceClip *space_clip = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(space_clip);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
/* Collect source tracks. */
int num_source_tracks;
@ -1465,8 +1465,8 @@ static int average_tracks_exec(bContext *C, wmOperator *op)
/* Create new empty track, which will be the averaged result.
* Makes it simple to average all selection to it. */
ListBase *tracks_list = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *result_track = BKE_tracking_track_add_empty(tracking, tracks_list);
MovieTrackingTrack *result_track = BKE_tracking_track_add_empty(tracking,
&tracking_object->tracks);
/* Perform averaging. */
BKE_tracking_tracks_average(result_track, source_tracks, num_source_tracks);
@ -1481,12 +1481,12 @@ static int average_tracks_exec(bContext *C, wmOperator *op)
/* Update selection, making the result track active and selected. */
/* TODO(sergey): Should become some sort of utility function available for all operators. */
BKE_tracking_track_select(tracks_list, result_track, TRACK_AREA_ALL, 0);
BKE_tracking_track_select(&tracking_object->tracks, result_track, TRACK_AREA_ALL, 0);
ListBase *plane_tracks_list = BKE_tracking_get_active_plane_tracks(tracking);
BKE_tracking_plane_tracks_deselect_all(plane_tracks_list);
clip->tracking.act_track = result_track;
clip->tracking.act_plane_track = NULL;
tracking_object->active_track = result_track;
tracking_object->active_plane_track = NULL;
/* Inform the dependency graph and interface about changes. */
DEG_id_tag_update(&clip->id, 0);
@ -1830,8 +1830,7 @@ static int clean_tracks_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
int frames = RNA_int_get(op->ptr, "frames");
int action = RNA_enum_get(op->ptr, "action");
float error = RNA_float_get(op->ptr, "error");
@ -1840,10 +1839,7 @@ static int clean_tracks_exec(bContext *C, wmOperator *op)
action = TRACKING_CLEAN_DELETE_TRACK;
}
for (MovieTrackingTrack *track = tracksbase->first, *next_track; track != NULL;
track = next_track) {
next_track = track->next;
LISTBASE_FOREACH_MUTABLE (MovieTrackingTrack *, track, &tracking_object->tracks) {
if ((track->flag & TRACK_HIDDEN) == 0 && (track->flag & TRACK_LOCKED) == 0) {
bool ok;
@ -1855,21 +1851,21 @@ static int clean_tracks_exec(bContext *C, wmOperator *op)
BKE_tracking_track_flag_set(track, TRACK_AREA_ALL, SELECT);
}
else if (action == TRACKING_CLEAN_DELETE_TRACK) {
if (track == act_track) {
clip->tracking.act_track = NULL;
if (track == tracking_object->active_track) {
tracking_object->active_track = NULL;
}
BKE_tracking_track_free(track);
BLI_freelinkN(tracksbase, track);
BLI_freelinkN(&tracking_object->tracks, track);
track = NULL;
}
/* Happens when all tracking segments are not long enough. */
if (track && track->markersnr == 0) {
if (track == act_track) {
clip->tracking.act_track = NULL;
if (track == tracking_object->active_track) {
tracking_object->active_track = NULL;
}
BKE_tracking_track_free(track);
BLI_freelinkN(tracksbase, track);
BLI_freelinkN(&tracking_object->tracks, track);
}
}
}
@ -2231,9 +2227,9 @@ static ImBuf *sample_plane_marker_image_for_operator(bContext *C)
MovieClip *clip = ED_space_clip_get_clip(space_clip);
MovieTracking *tracking = &clip->tracking;
MovieTrackingPlaneTrack *plane_track = tracking->act_plane_track;
const MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track,
clip_frame_number);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
const MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(
tracking_object->active_plane_track, clip_frame_number);
ImBuf *frame_ibuf = ED_space_clip_get_buffer(space_clip);
if (frame_ibuf == NULL) {
@ -2256,8 +2252,9 @@ static bool new_image_from_plane_marker_poll(bContext *C)
SpaceClip *space_clip = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(space_clip);
const MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
if (tracking->act_plane_track == NULL) {
if (tracking_object->active_plane_track == NULL) {
return false;
}
@ -2269,7 +2266,8 @@ static int new_image_from_plane_marker_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *space_clip = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(space_clip);
MovieTracking *tracking = &clip->tracking;
MovieTrackingPlaneTrack *plane_track = tracking->act_plane_track;
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
MovieTrackingPlaneTrack *plane_track = tracking_object->active_plane_track;
ImBuf *plane_ibuf = sample_plane_marker_image_for_operator(C);
if (plane_ibuf == NULL) {
@ -2309,12 +2307,14 @@ static bool update_image_from_plane_marker_poll(bContext *C)
SpaceClip *space_clip = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(space_clip);
const MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
if (tracking->act_plane_track == NULL || tracking->act_plane_track->image == NULL) {
if (tracking_object->active_plane_track == NULL ||
tracking_object->active_plane_track->image == NULL) {
return false;
}
const Image *image = tracking->act_plane_track->image;
const Image *image = tracking_object->active_plane_track->image;
return image->type == IMA_TYPE_IMAGE && ELEM(image->source, IMA_SRC_FILE, IMA_SRC_GENERATED);
}
@ -2323,7 +2323,8 @@ static int update_image_from_plane_marker_exec(bContext *C, wmOperator *UNUSED(o
SpaceClip *space_clip = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(space_clip);
MovieTracking *tracking = &clip->tracking;
MovieTrackingPlaneTrack *plane_track = tracking->act_plane_track;
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
MovieTrackingPlaneTrack *plane_track = tracking_object->active_plane_track;
ImBuf *plane_ibuf = sample_plane_marker_image_for_operator(C);
if (plane_ibuf == NULL) {

17
source/blender/editors/space_clip/tracking_ops_plane.c
View File

@ -35,22 +35,22 @@ static int create_plane_track_tracks_exec(bContext *C, wmOperator *op)
MovieClip *clip = ED_space_clip_get_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingPlaneTrack *plane_track;
ListBase *tracks_base = BKE_tracking_get_active_tracks(tracking);
ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
int framenr = ED_space_clip_get_clip_frame_number(sc);
plane_track = BKE_tracking_plane_track_add(tracking, plane_tracks_base, tracks_base, framenr);
plane_track = BKE_tracking_plane_track_add(
tracking, &tracking_object->plane_tracks, &tracking_object->tracks, framenr);
if (plane_track == NULL) {
BKE_report(op->reports, RPT_ERROR, "Need at least 4 selected point tracks to create a plane");
return OPERATOR_CANCELLED;
}
BKE_tracking_tracks_deselect_all(tracks_base);
BKE_tracking_tracks_deselect_all(&tracking_object->tracks);
plane_track->flag |= SELECT;
clip->tracking.act_track = NULL;
clip->tracking.act_plane_track = plane_track;
tracking_object->active_track = NULL;
tracking_object->active_plane_track = plane_track;
/* Compute homoraphies and apply them on marker's corner, so we've got
* quite nice motion from the very beginning.
@ -208,9 +208,10 @@ static int slide_plane_marker_invoke(bContext *C, wmOperator *op, const wmEvent
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
tracking->act_plane_track = slidedata->plane_track;
tracking->act_track = NULL;
tracking_object->active_plane_track = slidedata->plane_track;
tracking_object->active_track = NULL;
op->customdata = slidedata;

35
source/blender/editors/space_clip/tracking_select.c
View File

@ -289,9 +289,7 @@ static int select_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
const bool extend = RNA_boolean_get(op->ptr, "extend");
const bool deselect_all = RNA_boolean_get(op->ptr, "deselect_all");
@ -307,7 +305,7 @@ static int select_exec(bContext *C, wmOperator *op)
if (track != NULL) {
MovieClip *clip_iter = ED_space_clip_get_clip(sc);
clip_iter->tracking.act_track = track;
tracking_object->active_track = track;
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
DEG_id_tag_update(&clip_iter->id, ID_RECALC_SELECT);
@ -318,9 +316,10 @@ static int select_exec(bContext *C, wmOperator *op)
float distance_to_track, distance_to_plane_track;
MovieTrackingTrack *track = find_nearest_track(sc, tracksbase, co, &distance_to_track);
MovieTrackingTrack *track = find_nearest_track(
sc, &tracking_object->tracks, co, &distance_to_track);
MovieTrackingPlaneTrack *plane_track = find_nearest_plane_track(
sc, plane_tracks_base, co, &distance_to_plane_track);
sc, &tracking_object->plane_tracks, co, &distance_to_plane_track);
ClipViewLockState lock_state;
ED_clip_view_lock_state_store(C, &lock_state);
@ -346,7 +345,7 @@ static int select_exec(bContext *C, wmOperator *op)
if (track) {
if (!extend) {
ed_tracking_deselect_all_plane_tracks(plane_tracks_base);
ed_tracking_deselect_all_plane_tracks(&tracking_object->plane_tracks);
}
int area = track_mouse_area(C, co, track);
@ -356,12 +355,12 @@ static int select_exec(bContext *C, wmOperator *op)
}
if (extend && TRACK_AREA_SELECTED(track, area)) {
if (track == act_track) {
if (track == tracking_object->active_track) {
BKE_tracking_track_deselect(track, area);
}
else {
clip->tracking.act_track = track;
clip->tracking.act_plane_track = NULL;
tracking_object->active_track = track;
tracking_object->active_plane_track = NULL;
}
}
else {
@ -369,14 +368,14 @@ static int select_exec(bContext *C, wmOperator *op)
area = TRACK_AREA_ALL;
}
BKE_tracking_track_select(tracksbase, track, area, extend);
clip->tracking.act_track = track;
clip->tracking.act_plane_track = NULL;
BKE_tracking_track_select(&tracking_object->tracks, track, area, extend);
tracking_object->active_track = track;
tracking_object->active_plane_track = NULL;
}
}
else if (plane_track) {
if (!extend) {
ed_tracking_deselect_all_tracks(tracksbase);
ed_tracking_deselect_all_tracks(&tracking_object->tracks);
}
if (PLANE_TRACK_VIEW_SELECTED(plane_track)) {
@ -388,12 +387,12 @@ static int select_exec(bContext *C, wmOperator *op)
plane_track->flag |= SELECT;
}
clip->tracking.act_track = NULL;
clip->tracking.act_plane_track = plane_track;
tracking_object->active_track = NULL;
tracking_object->active_plane_track = plane_track;
}
else if (deselect_all) {
ed_tracking_deselect_all_tracks(tracksbase);
ed_tracking_deselect_all_plane_tracks(plane_tracks_base);
ed_tracking_deselect_all_tracks(&tracking_object->tracks);
ed_tracking_deselect_all_plane_tracks(&tracking_object->plane_tracks);
}
ED_clip_view_lock_state_restore_no_jump(C, &lock_state);

32
source/blender/makesdna/DNA_tracking_types.h
View File

@ -350,10 +350,14 @@ typedef struct MovieTrackingObject {
/** Scale of object solution in camera space. */
float scale;
/** List of tracks use to tracking this object. */
/** Lists of point and plane tracks use to tracking this object. */
ListBase tracks;
/** List of plane tracks used by this object. */
ListBase plane_tracks;
/** Active point and plane tracks. */
MovieTrackingTrack *active_track;
MovieTrackingPlaneTrack *active_plane_track;
/** Reconstruction data for this object. */
MovieTrackingReconstruction reconstruction;
@ -422,18 +426,22 @@ typedef struct MovieTracking {
MovieTrackingSettings settings;
/** Camera intrinsics. */
MovieTrackingCamera camera;
/** List of tracks used for camera object. */
ListBase tracks;
/** List of plane tracks used by camera object. */
ListBase plane_tracks;
/** Reconstruction data for camera object. */
MovieTrackingReconstruction reconstruction;
/** Lists of point and plane tracks used for camera object.
* NOTE: Only left for the versioning purposes. */
ListBase tracks_legacy;
ListBase plane_tracks_legacy;
/** Reconstruction data for camera object.
* NOTE: Only left for the versioning purposes. */
MovieTrackingReconstruction reconstruction_legacy;
/** Stabilization data. */
MovieTrackingStabilization stabilization;
/** Active track. */
MovieTrackingTrack *act_track;
/** Active plane track. */
MovieTrackingPlaneTrack *act_plane_track;
/** Active point and plane tracks.
* NOTE: Only left for the versioning purposes. */
MovieTrackingTrack *act_track_legacy;
MovieTrackingPlaneTrack *act_plane_track_legacy;
ListBase objects;
/** Index of active object and total number of objects. */

5
source/blender/makesdna/intern/dna_rename_defs.h
View File

@ -90,6 +90,11 @@ DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totcagevert, cage_verts_num)
DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totinfluence, influences_num)
DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totvert, verts_num)
DNA_STRUCT_RENAME_ELEM(MovieClip, name, filepath)
DNA_STRUCT_RENAME_ELEM(MovieTracking, tracks, tracks_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTracking, plane_tracks, plane_tracks_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTracking, reconstruction, reconstruction_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTracking, act_track, act_track_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTracking, act_plane_track, act_plane_track_legacy)
DNA_STRUCT_RENAME_ELEM(NodeCryptomatte, num_inputs, inputs_num)
DNA_STRUCT_RENAME_ELEM(Object, col, color)
DNA_STRUCT_RENAME_ELEM(Object, dup_group, instance_collection)

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

@ -87,15 +87,17 @@ static char *rna_trackingTrack_path(const PointerRNA *ptr)
static void rna_trackingTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
MovieClip *clip = (MovieClip *)ptr->owner_id;
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
rna_iterator_listbase_begin(iter, &tracking_camera_object->tracks, NULL);
}
static void rna_trackingPlaneTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
MovieClip *clip = (MovieClip *)ptr->owner_id;
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
rna_iterator_listbase_begin(iter, &clip->tracking.plane_tracks, NULL);
rna_iterator_listbase_begin(iter, &tracking_camera_object->plane_tracks, NULL);
}
static void rna_trackingObjects_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
@ -143,14 +145,15 @@ static void rna_tracking_active_track_set(PointerRNA *ptr,
{
MovieClip *clip = (MovieClip *)ptr->owner_id;
MovieTrackingTrack *track = (MovieTrackingTrack *)value.data;
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
int index = BLI_findindex(tracksbase, track);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
int index = BLI_findindex(&tracking_object->tracks, track);
if (index != -1) {
clip->tracking.act_track = track;
tracking_object->active_track = track;
}
else {
clip->tracking.act_track = NULL;
/* TODO(sergey): Raise an error. */
tracking_object->active_track = NULL;
}
}
@ -168,14 +171,15 @@ static void rna_tracking_active_plane_track_set(PointerRNA *ptr,
{
MovieClip *clip = (MovieClip *)ptr->owner_id;
MovieTrackingPlaneTrack *plane_track = (MovieTrackingPlaneTrack *)value.data;
ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(&clip->tracking);
int index = BLI_findindex(plane_tracks_base, plane_track);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
int index = BLI_findindex(&tracking_object->plane_tracks, plane_track);
if (index != -1) {
clip->tracking.act_plane_track = plane_track;
tracking_object->active_plane_track = plane_track;
}
else {
clip->tracking.act_plane_track = NULL;
/* TODO(sergey): Raise an error. */
tracking_object->active_plane_track = NULL;
}
}
@ -354,7 +358,8 @@ static int rna_track_2d_stabilization_rotation(CollectionPropertyIterator *UNUSE
static void rna_tracking_stabTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
MovieClip *clip = (MovieClip *)ptr->owner_id;
rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization);
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
rna_iterator_listbase_begin(iter, &tracking_camera_object->tracks, rna_track_2d_stabilization);
}
static int rna_tracking_stabTracks_active_index_get(PointerRNA *ptr)
@ -381,7 +386,9 @@ static void rna_tracking_stabTracks_active_index_range(
static void rna_tracking_stabRotTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
MovieClip *clip = (MovieClip *)ptr->owner_id;
rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization_rotation);
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
rna_iterator_listbase_begin(
iter, &tracking_camera_object->tracks, rna_track_2d_stabilization_rotation);
}
static int rna_tracking_stabRotTracks_active_index_get(PointerRNA *ptr)
@ -433,46 +440,21 @@ static void rna_tracking_resetIntrinsics(Main *UNUSED(bmain),
static void rna_trackingObject_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
if (object->flag & TRACKING_OBJECT_CAMERA) {
MovieClip *clip = (MovieClip *)ptr->owner_id;
rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
}
else {
rna_iterator_listbase_begin(iter, &object->tracks, NULL);
}
rna_iterator_listbase_begin(iter, &object->tracks, NULL);
}
static void rna_trackingObject_plane_tracks_begin(CollectionPropertyIterator *iter,
PointerRNA *ptr)
{
MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
if (object->flag & TRACKING_OBJECT_CAMERA) {
MovieClip *clip = (MovieClip *)ptr->owner_id;
rna_iterator_listbase_begin(iter, &clip->tracking.plane_tracks, NULL);
}
else {
rna_iterator_listbase_begin(iter, &object->plane_tracks, NULL);
}
rna_iterator_listbase_begin(iter, &object->plane_tracks, NULL);
}
static PointerRNA rna_trackingObject_reconstruction_get(PointerRNA *ptr)
{
MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
if (object->flag & TRACKING_OBJECT_CAMERA) {
MovieClip *clip = (MovieClip *)ptr->owner_id;
return rna_pointer_inherit_refine(
ptr, &RNA_MovieTrackingReconstruction, &clip->tracking.reconstruction);
}
else {
return rna_pointer_inherit_refine(
ptr, &RNA_MovieTrackingReconstruction, &object->reconstruction);
}
return rna_pointer_inherit_refine(
ptr, &RNA_MovieTrackingReconstruction, &object->reconstruction);
}
static PointerRNA rna_tracking_active_object_get(PointerRNA *ptr)
@ -621,9 +603,11 @@ static MovieTrackingTrack *rna_trackingTracks_new(ID *id,
int frame)
{
MovieClip *clip = (MovieClip *)id;
MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
MovieTrackingTrack *track;
track = add_track_to_base(clip, tracking, &tracking->tracks, name, frame);
track = add_track_to_base(clip, tracking, &tracking_camera_object->tracks, name, frame);
WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, clip);
@ -639,10 +623,6 @@ static MovieTrackingTrack *rna_trackingObject_tracks_new(ID *id,
ListBase *tracksbase = &object->tracks;
MovieTrackingTrack *track;
if (object->flag & TRACKING_OBJECT_CAMERA) {
tracksbase = &clip->tracking.tracks;
}
track = add_track_to_base(clip, &clip->tracking, tracksbase, name, frame);
WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
@ -772,12 +752,7 @@ static MovieTrackingObject *find_object_for_reconstruction(
MovieTrackingObject *object;
for (object = tracking->objects.first; object; object = object->next) {
if (object->flag & TRACKING_OBJECT_CAMERA) {
if (&tracking->reconstruction == reconstruction) {
return object;
}
}
else if (&object->reconstruction == reconstruction) {
if (&object->reconstruction == reconstruction) {
return object;
}
}
@ -2539,6 +2514,7 @@ static void rna_def_tracking(BlenderRNA *brna)
/* reconstruction */
prop = RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "reconstruction_legacy");
RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
/* objects */