tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Internal refactoring of tracking module, should be no functional changes 

- Re-arrange functions in headers and implementation file to make them
  more grouped by entity they're operating with. Also order of functions
  in implementation file should match order of functions in header for
  easier navigation.

- Rename some functions to match conventions of naming public functions.
- Some code de-duplication, still some room for improvements tho.
- Split main 2D tracking functions into smaller steps to make it more clear.

Accidentally OpenMP was disabled in some of previous commits, re-enable it.
This commit is contained in:
Sergey Sharybin 2012-06-15 11:03:23 +00:00
parent 6a8fceb8b8
commit f0c724219d
38 changed files with 2252 additions and 2127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -47,127 +47,159 @@ struct Camera;
struct Object;
struct Scene;
void BKE_tracking_init_settings(struct MovieTracking *tracking);
void BKE_tracking_clamp_marker(struct MovieTrackingMarker *marker, int event);
void BKE_tracking_track_flag(struct MovieTrackingTrack *track, int area, int flag, int clear);
/* **** Common functions **** */
struct MovieTrackingTrack *BKE_tracking_add_track(struct MovieTracking *tracking, struct ListBase *tracksbase,
float x, float y, int framenr, int width, int height);
struct MovieTrackingMarker *BKE_tracking_insert_marker(struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker);
void BKE_tracking_delete_marker(struct MovieTrackingTrack *track, int framenr);
void BKE_tracking_marker_pattern_minmax(const struct MovieTrackingMarker *marker, float min[2], float max[2]);
struct MovieTrackingMarker *BKE_tracking_get_marker(struct MovieTrackingTrack *track, int framenr);
struct MovieTrackingMarker *BKE_tracking_ensure_marker(struct MovieTrackingTrack *track, int framenr);
struct MovieTrackingMarker *BKE_tracking_exact_marker(struct MovieTrackingTrack *track, int framenr);
int BKE_tracking_has_marker(struct MovieTrackingTrack *track, int framenr);
int BKE_tracking_has_enabled_marker(struct MovieTrackingTrack *track, int framenr);
void BKE_tracking_free_track(struct MovieTrackingTrack *track);
void BKE_tracking_clear_path(struct MovieTrackingTrack *track, int ref_frame, int action);
void BKE_tracking_join_tracks(struct MovieTrackingTrack *dst_track, struct MovieTrackingTrack *src_track);
void BKE_tracking_free(struct MovieTracking *tracking);
struct ImBuf *BKE_tracking_sample_pattern_imbuf(int frame_width, int frame_height,
struct ImBuf *struct_ibuf, struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker, int use_mask,
int num_samples_x, int num_samples_y, float pos[2]);
struct ImBuf *BKE_tracking_get_pattern_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker, int anchored, int disable_channels);
struct ImBuf *BKE_tracking_get_search_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker, int anchored, int disable_channels);
float *BKE_tracking_track_mask_get(int frame_width, int frame_height, struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker);
void BKE_tracking_settings_init(struct MovieTracking *tracking);
void BKE_track_unique_name(struct ListBase *tracksbase, struct MovieTrackingTrack *track);
struct ListBase *BKE_tracking_get_active_tracks(struct MovieTracking *tracking);
struct MovieTrackingReconstruction *BKE_tracking_get_active_reconstruction(struct MovieTracking *tracking);
struct MovieTrackingTrack *BKE_tracking_named_track(struct MovieTracking *tracking, struct MovieTrackingObject *object, const char *name);
struct MovieTrackingTrack *BKE_tracking_indexed_track(struct MovieTracking *tracking, int tracknr, struct ListBase **tracksbase_r);
/* matrices for constraints and drawing */
void BKE_tracking_get_camera_object_matrix(struct Scene *scene, struct Object *ob, float mat[4][4]);
void BKE_tracking_get_projection_matrix(struct MovieTracking *tracking, struct MovieTrackingObject *object,
int framenr, int winx, int winy, float mat[4][4]);
void BKE_tracking_camera_shift(struct MovieTracking *tracking, int winx, int winy, float *shiftx, float *shifty);
void BKE_tracking_camera_to_blender(struct MovieTracking *tracking, struct Scene *scene, struct Camera *camera, int width, int height);
void BKE_get_tracking_mat(struct Scene *scene, struct Object *ob, float mat[4][4]);
void BKE_tracking_projection_matrix(struct MovieTracking *tracking, struct MovieTrackingObject *object,
int framenr, int winx, int winy, float mat[4][4]);
struct ListBase *BKE_tracking_get_tracks(struct MovieTracking *tracking);
struct MovieTrackingReconstruction *BKE_tracking_get_reconstruction(struct MovieTracking *tracking);
struct MovieTrackingTrack *BKE_tracking_active_track(struct MovieTracking *tracking);
struct MovieTrackingObject *BKE_tracking_active_object(struct MovieTracking *tracking);
struct MovieTrackingObject *BKE_tracking_get_camera_object(struct MovieTracking *tracking);
struct ListBase *BKE_tracking_object_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
struct MovieTrackingReconstruction *BKE_tracking_object_reconstruction(struct MovieTracking *tracking,
struct MovieTrackingObject *object);
void BKE_tracking_disable_imbuf_channels(struct ImBuf *ibuf, int disable_red, int disable_green, int disable_blue, int grayscale);
/* clipboard */
void BKE_tracking_free_clipboard(void);
/* **** Clipboard **** */
void BKE_tracking_clipboard_free(void);
void BKE_tracking_clipboard_copy_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
int BKE_tracking_clipboard_has_tracks(void);
void BKE_tracking_clipboard_paste_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
/* 2D tracking */
/* **** Track **** */
struct MovieTrackingTrack *BKE_tracking_track_add(struct MovieTracking *tracking, struct ListBase *tracksbase,
float x, float y, int framenr, int width, int height);
void BKE_tracking_track_unique_name(struct ListBase *tracksbase, struct MovieTrackingTrack *track);
void BKE_tracking_track_free(struct MovieTrackingTrack *track);
void BKE_tracking_track_flag_set(struct MovieTrackingTrack *track, int area, int flag);
void BKE_tracking_track_flag_clear(struct MovieTrackingTrack *track, int area, int flag);
int BKE_tracking_track_has_marker_at_frame(struct MovieTrackingTrack *track, int framenr);
int BKE_tracking_track_has_enabled_marker_at_frame(struct MovieTrackingTrack *track, int framenr);
void BKE_tracking_track_path_clear(struct MovieTrackingTrack *track, int ref_frame, int action);
void BKE_tracking_tracks_join(struct MovieTrackingTrack *dst_track, struct MovieTrackingTrack *src_track);
struct MovieTrackingTrack *BKE_tracking_track_get_named(struct MovieTracking *tracking,
struct MovieTrackingObject *object,
const char *name);
struct MovieTrackingTrack *BKE_tracking_track_get_indexed(struct MovieTracking *tracking, int tracknr,
struct ListBase **tracksbase_r);
struct MovieTrackingTrack *BKE_tracking_track_get_active(struct MovieTracking *tracking);
float *BKE_tracking_track_get_mask(int frame_width, int frame_height, struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker);
/* selection */
void BKE_tracking_track_select(struct ListBase *tracksbase, struct MovieTrackingTrack *track, int area, int extend);
void BKE_tracking_track_deselect(struct MovieTrackingTrack *track, int area);
/* **** Marker **** */
struct MovieTrackingMarker *BKE_tracking_marker_insert(struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker);
void BKE_tracking_marker_delete(struct MovieTrackingTrack *track, int framenr);
void BKE_tracking_marker_clamp(struct MovieTrackingMarker *marker, int event);
struct MovieTrackingMarker *BKE_tracking_marker_get(struct MovieTrackingTrack *track, int framenr);
struct MovieTrackingMarker *BKE_tracking_marker_get_exact(struct MovieTrackingTrack *track, int framenr);
struct MovieTrackingMarker *BKE_tracking_marker_ensure(struct MovieTrackingTrack *track, int framenr);
void BKE_tracking_marker_pattern_minmax(const struct MovieTrackingMarker *marker, float min[2], float max[2]);
/* **** Object **** */
struct MovieTrackingObject *BKE_tracking_object_add(struct MovieTracking *tracking, const char *name);
void BKE_tracking_object_delete(struct MovieTracking *tracking, struct MovieTrackingObject *object);
void BKE_tracking_object_unique_name(struct MovieTracking *tracking, struct MovieTrackingObject *object);
struct MovieTrackingObject *BKE_tracking_object_get_named(struct MovieTracking *tracking, const char *name);
struct MovieTrackingObject *BKE_tracking_object_get_active(struct MovieTracking *tracking);
struct MovieTrackingObject *BKE_tracking_object_get_camera(struct MovieTracking *tracking);
struct ListBase *BKE_tracking_object_get_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
struct MovieTrackingReconstruction *BKE_tracking_object_get_reconstruction(struct MovieTracking *tracking,
struct MovieTrackingObject *object);
/* **** Camera **** */
void BKE_tracking_camera_shift_get(struct MovieTracking *tracking, int winx, int winy, float *shiftx, float *shifty);
void BKE_tracking_camera_to_blender(struct MovieTracking *tracking, struct Scene *scene,
struct Camera *camera, int width, int height);
struct MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(struct MovieTracking *tracking,
struct MovieTrackingObject *object,
int framenr);
void BKE_tracking_camera_get_reconstructed_interpolate(struct MovieTracking *tracking,
struct MovieTrackingObject *object,
int framenr, float mat[4][4]);
/* **** Distortion/Undistortion **** */
struct MovieDistortion *BKE_tracking_distortion_new(void);
void BKE_tracking_distortion_update(struct MovieDistortion *distortion, struct MovieTracking *tracking,
int calibration_width, int calibration_height);
struct MovieDistortion *BKE_tracking_distortion_copy(struct MovieDistortion *distortion);
struct ImBuf *BKE_tracking_distortion_exec(struct MovieDistortion *distortion, struct MovieTracking *tracking,
struct ImBuf *ibuf, int width, int height, float overscan, int undistort);
void BKE_tracking_distortion_free(struct MovieDistortion *distortion);
void BKE_tracking_distort_v2(struct MovieTracking *tracking, float co[2], float nco[2]);
void BKE_tracking_undistort_v2(struct MovieTracking *tracking, float co[2], float nco[2]);
struct ImBuf *BKE_tracking_undistort_frame(struct MovieTracking *tracking, struct ImBuf *ibuf,
int calibration_width, int calibration_height, float overscan);
struct ImBuf *BKE_tracking_distort_frame(struct MovieTracking *tracking, struct ImBuf *ibuf,
int calibration_width, int calibration_height, float overscan);
/* **** Image sampling **** */
struct ImBuf *BKE_tracking_sample_pattern(int frame_width, int frame_height,
struct ImBuf *struct_ibuf, struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker, int use_mask,
int num_samples_x, int num_samples_y, float pos[2]);
struct ImBuf *BKE_tracking_get_pattern_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker, int anchored, int disable_channels);
struct ImBuf *BKE_tracking_get_search_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker, int anchored, int disable_channels);
void BKE_tracking_disable_channels(struct ImBuf *ibuf, int disable_red, int disable_green,
int disable_blue, int grayscale);
/* **** 2D tracking **** */
struct MovieTrackingContext *BKE_tracking_context_new(struct MovieClip *clip, struct MovieClipUser *user,
short backwards, short sequence);
void BKE_tracking_context_free(struct MovieTrackingContext *context);
void BKE_tracking_sync(struct MovieTrackingContext *context);
void BKE_tracking_sync_user(struct MovieClipUser *user, struct MovieTrackingContext *context);
int BKE_tracking_next(struct MovieTrackingContext *context);
void BKE_tracking_context_sync(struct MovieTrackingContext *context);
void BKE_tracking_context_sync_user(const struct MovieTrackingContext *context, struct MovieClipUser *user);
int BKE_tracking_context_step(struct MovieTrackingContext *context);
/* Camera solving */
int BKE_tracking_can_reconstruct(struct MovieTracking *tracking, struct MovieTrackingObject *object,
char *error_msg, int error_size);
/* **** Camera solving **** */
int BKE_tracking_reconstruction_check(struct MovieTracking *tracking, struct MovieTrackingObject *object,
char *error_msg, int error_size);
struct MovieReconstructContext *BKE_tracking_reconstruction_context_new(struct MovieTracking *tracking,
struct MovieTrackingObject *object, int keyframe1, int keyframe2, int width, int height);
struct MovieTrackingObject *object,
int keyframe1, int keyframe2,
int width, int height);
void BKE_tracking_reconstruction_context_free(struct MovieReconstructContext *context);
void BKE_tracking_solve_reconstruction(struct MovieReconstructContext *context, short *stop, short *do_update,
void BKE_tracking_reconstruction_solve(struct MovieReconstructContext *context, short *stop, short *do_update,
float *progress, char *stats_message, int message_size);
int BKE_tracking_finish_reconstruction(struct MovieReconstructContext *context, struct MovieTracking *tracking);
int BKE_tracking_reconstruction_finish(struct MovieReconstructContext *context, struct MovieTracking *tracking);
struct MovieReconstructedCamera *BKE_tracking_get_reconstructed_camera(struct MovieTracking *tracking,
struct MovieTrackingObject *object, int framenr);
void BKE_tracking_get_interpolated_camera(struct MovieTracking *tracking, struct MovieTrackingObject *object,
int framenr, float mat[4][4]);
/* Feature detection */
/* **** Feature detection **** */
void BKE_tracking_detect_fast(struct MovieTracking *tracking, struct ListBase *tracksbase, struct ImBuf *imbuf,
int framenr, int margin, int min_trackness, int min_distance, struct bGPDlayer *layer,
int place_outside_layer);
/* 2D stabilization */
void BKE_tracking_stabilization_data(struct MovieTracking *tracking, int framenr, int width, int height, float loc[2], float *scale, float *angle);
struct ImBuf *BKE_tracking_stabilize(struct MovieTracking *tracking, int framenr, struct ImBuf *ibuf, float loc[2], float *scale, float *angle);
void BKE_tracking_stabdata_to_mat4(int width, int height, float aspect, float loc[2], float scale, float angle, float mat[4][4]);
/* Distortion/Undistortion */
void BKE_tracking_apply_intrinsics(struct MovieTracking *tracking, float co[2], float nco[2]);
void BKE_tracking_invert_intrinsics(struct MovieTracking *tracking, float co[2], float nco[2]);
struct MovieDistortion *BKE_tracking_distortion_create(void);
struct MovieDistortion *BKE_tracking_distortion_copy(struct MovieDistortion *distortion);
struct ImBuf *BKE_tracking_distortion_exec(struct MovieDistortion *distortion, struct MovieTracking *tracking,
struct ImBuf *ibuf, int width, int height, float overscan, int undistort);
void BKE_tracking_distortion_destroy(struct MovieDistortion *distortion);
struct ImBuf *BKE_tracking_undistort(struct MovieTracking *tracking, struct ImBuf *ibuf, int width, int height, float overscan);
struct ImBuf *BKE_tracking_distort(struct MovieTracking *tracking, struct ImBuf *ibuf, int width, int height, float overscan);
/* Object tracking */
struct MovieTrackingObject *BKE_tracking_new_object(struct MovieTracking *tracking, const char *name);
void BKE_tracking_remove_object(struct MovieTracking *tracking, struct MovieTrackingObject *object);
void BKE_tracking_object_unique_name(struct MovieTracking *tracking, struct MovieTrackingObject *object);
struct MovieTrackingObject *BKE_tracking_named_object(struct MovieTracking *tracking, const char *name);
/* Select */
void BKE_tracking_select_track(struct ListBase *tracksbase, struct MovieTrackingTrack *track, int area, int extend);
void BKE_tracking_deselect_track(struct MovieTrackingTrack *track, int area);
/* **** 2D stabilization **** */
void BKE_tracking_stabilization_data_get(struct MovieTracking *tracking, int framenr, int width, int height,
float loc[2], float *scale, float *angle);
struct ImBuf *BKE_tracking_stabilize_frame(struct MovieTracking *tracking, int framenr, struct ImBuf *ibuf,
float loc[2], float *scale, float *angle);
void BKE_tracking_stabilization_data_to_mat4(int width, int height, float aspect, float loc[2],
float scale, float angle, float mat[4][4]);
/* Dopesheet */
void BKE_tracking_dopesheet_tag_update(struct MovieTracking *tracking);

20
source/blender/blenkernel/intern/constraint.c
View File

@ -3917,14 +3917,14 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
tracking = &clip->tracking;
if (data->object[0])
tracking_object = BKE_tracking_named_object(tracking, data->object);
tracking_object = BKE_tracking_object_get_named(tracking, data->object);
else
tracking_object = BKE_tracking_get_camera_object(tracking);
tracking_object = BKE_tracking_object_get_camera(tracking);
if (!tracking_object)
return;
track = BKE_tracking_named_track(tracking, tracking_object, data->track);
track = BKE_tracking_track_get_named(tracking, tracking_object, data->track);
if (!track)
return;
@ -3942,14 +3942,14 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
copy_m4_m4(mat, camob->obmat);
BKE_tracking_get_interpolated_camera(tracking, tracking_object, framenr, imat);
BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, framenr, imat);
invert_m4(imat);
mul_serie_m4(cob->matrix, obmat, mat, imat, NULL, NULL, NULL, NULL, NULL);
translate_m4(cob->matrix, track->bundle_pos[0], track->bundle_pos[1], track->bundle_pos[2]);
}
else {
BKE_get_tracking_mat(cob->scene, camob, mat);
BKE_tracking_get_camera_object_matrix(cob->scene, camob, mat);
mult_m4_m4m4(cob->matrix, obmat, mat);
translate_m4(cob->matrix, track->bundle_pos[0], track->bundle_pos[1], track->bundle_pos[2]);
@ -3981,7 +3981,7 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
CameraParams params;
float pos[2], rmat[4][4];
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
add_v2_v2v2(pos, marker->pos, track->offset);
@ -4103,10 +4103,10 @@ static void camerasolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
if (clip) {
float mat[4][4], obmat[4][4];
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *object = BKE_tracking_get_camera_object(tracking);
MovieTrackingObject *object = BKE_tracking_object_get_camera(tracking);
int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, scene->r.cfra);
BKE_tracking_get_interpolated_camera(tracking, object, framenr, mat);
BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat);
copy_m4_m4(obmat, cob->matrix);
@ -4165,7 +4165,7 @@ static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *object;
object = BKE_tracking_named_object(tracking, data->object);
object = BKE_tracking_object_get_named(tracking, data->object);
if (object) {
float mat[4][4], obmat[4][4], imat[4][4], cammat[4][4], camimat[4][4], parmat[4][4];
@ -4173,7 +4173,7 @@ static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
BKE_object_where_is_calc_mat4(scene, camob, cammat);
BKE_tracking_get_interpolated_camera(tracking, object, framenr, mat);
BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat);
invert_m4_m4(camimat, cammat);
mult_m4_m4m4(parmat, cammat, data->invmat);

6
source/blender/blenkernel/intern/mask.c
View File

@ -1156,16 +1156,16 @@ static int BKE_mask_evaluate_parent(MaskParent *parent, float ctime, float r_co[
if (parent->id) {
MovieClip *clip = (MovieClip *) parent->id;
MovieTracking *tracking = (MovieTracking *) &clip->tracking;
MovieTrackingObject *ob = BKE_tracking_named_object(tracking, parent->parent);
MovieTrackingObject *ob = BKE_tracking_object_get_named(tracking, parent->parent);
if (ob) {
MovieTrackingTrack *track = BKE_tracking_named_track(tracking, ob, parent->sub_parent);
MovieTrackingTrack *track = BKE_tracking_track_get_named(tracking, ob, parent->sub_parent);
MovieClipUser user = {0};
user.framenr = ctime;
if (track) {
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, ctime);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, ctime);
float marker_pos_ofs[2];
add_v2_v2v2(marker_pos_ofs, marker->pos, track->offset);
BKE_mask_coord_from_movieclip(clip, &user, r_co, marker_pos_ofs);

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

@ -436,7 +436,7 @@ static MovieClip *movieclip_alloc(const char *name)
clip->aspx = clip->aspy = 1.0f;
BKE_tracking_init_settings(&clip->tracking);
BKE_tracking_settings_init(&clip->tracking);
clip->proxy.build_size_flag = IMB_PROXY_25;
clip->proxy.build_tc_flag = IMB_TC_RECORD_RUN |
@ -548,7 +548,7 @@ static ImBuf *get_undistorted_ibuf(MovieClip *clip, struct MovieDistortion *dist
if (distortion)
undistibuf = BKE_tracking_distortion_exec(distortion, &clip->tracking, ibuf, ibuf->x, ibuf->y, 0.0f, 1);
else
undistibuf = BKE_tracking_undistort(&clip->tracking, ibuf, ibuf->x, ibuf->y, 0.0f);
undistibuf = BKE_tracking_undistort_frame(&clip->tracking, ibuf, ibuf->x, ibuf->y, 0.0f);
if (undistibuf->userflags & IB_RECT_INVALID) {
ibuf->userflags &= ~IB_RECT_INVALID;
@ -678,7 +678,7 @@ static ImBuf *put_postprocessed_frame_to_cache(MovieClip *clip, MovieClipUser *u
postproc_ibuf = IMB_dupImBuf(ibuf);
if (disable_red || disable_green || disable_blue || grayscale)
BKE_tracking_disable_imbuf_channels(postproc_ibuf, disable_red, disable_green, disable_blue, 1);
BKE_tracking_disable_channels(postproc_ibuf, disable_red, disable_green, disable_blue, 1);
}
IMB_refImBuf(postproc_ibuf);
@ -799,7 +799,7 @@ static ImBuf *get_stable_cached_frame(MovieClip *clip, MovieClipUser *user, int
stableibuf = cache->stabilized.ibuf;
BKE_tracking_stabilization_data(&clip->tracking, framenr, stableibuf->x, stableibuf->y, tloc, &tscale, &tangle);
BKE_tracking_stabilization_data_get(&clip->tracking, framenr, stableibuf->x, stableibuf->y, tloc, &tscale, &tangle);
/* check for stabilization parameters */
if (tscale != cache->stabilized.scale ||
@ -825,7 +825,7 @@ static ImBuf *put_stabilized_frame_to_cache(MovieClip *clip, MovieClipUser *user
if (cache->stabilized.ibuf)
IMB_freeImBuf(cache->stabilized.ibuf);
stableibuf = BKE_tracking_stabilize(&clip->tracking, framenr, ibuf, tloc, &tscale, &tangle);
stableibuf = BKE_tracking_stabilize_frame(&clip->tracking, framenr, ibuf, tloc, &tscale, &tangle);
cache->stabilized.ibuf = stableibuf;
@ -1043,12 +1043,12 @@ void BKE_movieclip_update_scopes(MovieClip *clip, MovieClipUser *user, MovieClip
scopes->track_locked = TRUE;
if (clip) {
MovieTrackingTrack *act_track = BKE_tracking_active_track(&clip->tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(&clip->tracking);
if (act_track) {
MovieTrackingTrack *track = act_track;
int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
if (marker->flag & MARKER_DISABLED) {
scopes->track_disabled = TRUE;
@ -1073,7 +1073,7 @@ void BKE_movieclip_update_scopes(MovieClip *clip, MovieClipUser *user, MovieClip
undist_marker.pos[0] *= width;
undist_marker.pos[1] *= height * aspy;
BKE_tracking_invert_intrinsics(&clip->tracking, undist_marker.pos, undist_marker.pos);
BKE_tracking_undistort_v2(&clip->tracking, undist_marker.pos, undist_marker.pos);
undist_marker.pos[0] /= width;
undist_marker.pos[1] /= height * aspy;

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

File diff suppressed because it is too large Load Diff

2
source/blender/blenloader/intern/readfile.c
View File

@ -7260,7 +7260,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
tracking->settings.object_distance = 1.0f;
if (tracking->objects.first == NULL)
BKE_tracking_new_object(tracking, "Camera");
BKE_tracking_object_add(tracking, "Camera");
while (tracking_object) {
if (!tracking_object->scale)

2
source/blender/compositor/nodes/COM_MovieClipNode.cpp
View File

@ -91,7 +91,7 @@ void MovieClipNode::convertToOperations(ExecutionSystem *graph, CompositorContex
if (ibuf) {
if (stab->flag&TRACKING_2D_STABILIZATION) {
BKE_tracking_stabilization_data(&movieClip->tracking, context->getFramenumber(), ibuf->x, ibuf->y, loc, &scale, &angle);
BKE_tracking_stabilization_data_get(&movieClip->tracking, context->getFramenumber(), ibuf->x, ibuf->y, loc, &scale, &angle);
}
}

8
source/blender/compositor/operations/COM_KeyingScreenOperation.cpp
View File

@ -87,15 +87,15 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri
int height = this->getHeight();
if (this->trackingObject[0]) {
MovieTrackingObject *object = BKE_tracking_named_object(tracking, this->trackingObject);
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, this->trackingObject);
if (!object)
return NULL;
tracksbase = BKE_tracking_object_tracks(tracking, object);
tracksbase = BKE_tracking_object_get_tracks(tracking, object);
}
else
tracksbase = BKE_tracking_get_tracks(tracking);
tracksbase = BKE_tracking_get_active_tracks(tracking);
sites_total = BLI_countlist(tracksbase);
@ -115,7 +115,7 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri
i = 0;
while (track) {
VoronoiSite *site = &sites[i];
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenumber);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenumber);
ImBuf *pattern_ibuf = BKE_tracking_get_pattern_imbuf(ibuf, track, marker, TRUE, FALSE);
int j;

2
source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp
View File

@ -41,7 +41,7 @@ void MovieClipAttributeOperation::executePixel(float *outputValue, float x, floa
scale = 1.0f;
angle = 0.0f;
if (clip) {
BKE_tracking_stabilization_data(&clip->tracking, framenumber, getWidth(), getHeight(), loc, &scale, &angle);
BKE_tracking_stabilization_data_get(&clip->tracking, framenumber, getWidth(), getHeight(), loc, &scale, &angle);
}
switch (this->attribute) {
case MCA_SCALE:

4
source/blender/compositor/operations/COM_MovieDistortionOperation.h
View File

@ -99,10 +99,10 @@ public:
in[1] = (y /* - 0.5 * overscan * h */) / aspy / this->pixel_aspect;
if (inverted) {
BKE_tracking_invert_intrinsics(trackingData, in, out);
BKE_tracking_undistort_v2(trackingData, in, out);
}
else {
BKE_tracking_apply_intrinsics(trackingData, in, out);
BKE_tracking_distort_v2(trackingData, in, out);
}
buffer[offset2] = out[0] * aspx /* + 0.5 * overscan * w */;

2
source/blender/editors/gpencil/gpencil_edit.c
View File

@ -150,7 +150,7 @@ bGPdata **gpencil_data_get_pointers(const bContext *C, PointerRNA *ptr)
if (clip) {
if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) {
MovieTrackingTrack *track = BKE_tracking_active_track(&clip->tracking);
MovieTrackingTrack *track = BKE_tracking_track_get_active(&clip->tracking);
if (!track)
return NULL;

4
source/blender/editors/gpencil/gpencil_paint.c
View File

@ -1033,8 +1033,8 @@ static int gp_session_initdata(bContext *C, tGPsdata *p)
if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) {
int framenr = sc->user.framenr;
MovieTrackingTrack *track = BKE_tracking_active_track(&sc->clip->tracking);
MovieTrackingMarker *marker = BKE_tracking_exact_marker(track, framenr);
MovieTrackingTrack *track = BKE_tracking_track_get_active(&sc->clip->tracking);
MovieTrackingMarker *marker = BKE_tracking_marker_get_exact(track, framenr);
p->imat[3][0] -= marker->pos[0];
p->imat[3][1] -= marker->pos[1];

2
source/blender/editors/interface/interface_draw.c
View File

@ -1549,7 +1549,7 @@ void ui_draw_but_TRACKPREVIEW(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wc
if (scopes->track_preview)
IMB_freeImBuf(scopes->track_preview);
tmpibuf = BKE_tracking_sample_pattern_imbuf(scopes->frame_width, scopes->frame_height,
tmpibuf = BKE_tracking_sample_pattern(scopes->frame_width, scopes->frame_height,
scopes->track_search, scopes->track,
&scopes->undist_marker, scopes->use_track_mask,
width, height, scopes->track_pos);

2
source/blender/editors/interface/interface_handlers.c
View File

@ -4203,7 +4203,7 @@ static int ui_numedit_but_TRACKPREVIEW(bContext *C, uiBut *but, uiHandleButtonDa
else {
if (!scopes->track_locked) {
if (scopes->marker->framenr != scopes->framenr)
scopes->marker = BKE_tracking_ensure_marker(scopes->track, scopes->framenr);
scopes->marker = BKE_tracking_marker_ensure(scopes->track, scopes->framenr);
scopes->marker->flag &= ~(MARKER_DISABLED | MARKER_TRACKED);
scopes->marker->pos[0] += -dx * scopes->slide_scale[0] / (but->block->maxx - but->block->minx);

4
source/blender/editors/mask/mask_relationships.c
View File

@ -113,8 +113,8 @@ static int mask_parent_set_exec(bContext *C, wmOperator *UNUSED(op))
if ((NULL == (sc = CTX_wm_space_clip(C))) ||
(NULL == (clip = sc->clip)) ||
(NULL == (track = clip->tracking.act_track)) ||
(NULL == (marker = BKE_tracking_get_marker(track, sc->user.framenr))) ||
(NULL == (tracking = BKE_tracking_active_object(&clip->tracking))))
(NULL == (marker = BKE_tracking_marker_get(track, sc->user.framenr))) ||
(NULL == (tracking = BKE_tracking_object_get_active(&clip->tracking))))
{
return OPERATOR_CANCELLED;
}

6
source/blender/editors/object/object_constraint.c
View File

@ -418,15 +418,15 @@ static void test_constraints(Object *owner, bPoseChannel *pchan)
MovieTrackingObject *tracking_object;
if (data->object[0])
tracking_object = BKE_tracking_named_object(tracking, data->object);
tracking_object = BKE_tracking_object_get_named(tracking, data->object);
else
tracking_object = BKE_tracking_get_camera_object(tracking);
tracking_object = BKE_tracking_object_get_camera(tracking);
if (!tracking_object) {
curcon->flag |= CONSTRAINT_DISABLE;
}
else {
if (!BKE_tracking_named_track(tracking, tracking_object, data->track))
if (!BKE_tracking_track_get_named(tracking, tracking_object, data->track))
curcon->flag |= CONSTRAINT_DISABLE;
}
}

12
source/blender/editors/space_clip/clip_buttons.c
View File

@ -211,7 +211,7 @@ static void marker_update_cb(bContext *C, void *arg_cb, void *UNUSED(arg))
if (!cb->compact)
return;
marker = BKE_tracking_ensure_marker(cb->track, cb->framenr);
marker = BKE_tracking_marker_ensure(cb->track, cb->framenr);
marker->flag = cb->marker_flag;
@ -226,7 +226,7 @@ static void marker_block_handler(bContext *C, void *arg_cb, int event)
BKE_movieclip_get_size(cb->clip, cb->user, &width, &height);
marker = BKE_tracking_ensure_marker(cb->track, cb->framenr);
marker = BKE_tracking_marker_ensure(cb->track, cb->framenr);
if (event == B_MARKER_POS) {
marker->pos[0] = cb->marker_pos[0] / width;
@ -258,7 +258,7 @@ static void marker_block_handler(bContext *C, void *arg_cb, int event)
cb->marker->pattern_corners[a][1] *= scale_y;
}
BKE_tracking_clamp_marker(cb->marker, CLAMP_PAT_DIM);
BKE_tracking_marker_clamp(cb->marker, CLAMP_PAT_DIM);
ok = TRUE;
}
@ -274,7 +274,7 @@ static void marker_block_handler(bContext *C, void *arg_cb, int event)
sub_v2_v2v2(cb->marker->search_min, delta, side);
add_v2_v2v2(cb->marker->search_max, delta, side);
BKE_tracking_clamp_marker(cb->marker, CLAMP_SEARCH_POS);
BKE_tracking_marker_clamp(cb->marker, CLAMP_SEARCH_POS);
ok = TRUE;
}
@ -295,7 +295,7 @@ static void marker_block_handler(bContext *C, void *arg_cb, int event)
cb->marker->search_max[0] += dim[0];
cb->marker->search_max[1] += dim[1];
BKE_tracking_clamp_marker(cb->marker, CLAMP_SEARCH_DIM);
BKE_tracking_marker_clamp(cb->marker, CLAMP_SEARCH_DIM);
ok = TRUE;
}
@ -364,7 +364,7 @@ void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, P
user = userptr->data;
track = trackptr->data;
marker = BKE_tracking_get_marker(track, user->framenr);
marker = BKE_tracking_marker_get(track, user->framenr);
cb = MEM_callocN(sizeof(MarkerUpdateCb), "uiTemplateMarker update_cb");
cb->compact = compact;

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

@ -93,10 +93,10 @@ static int dopesheet_select_channel_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *object = BKE_tracking_active_object(tracking);
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
MovieTrackingDopesheetChannel *channel;
ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
float location[2];
int extend = RNA_boolean_get(op->ptr, "extend");
int current_channel_index = 0, channel_index;
@ -115,7 +115,7 @@ static int dopesheet_select_channel_exec(bContext *C, wmOperator *op)
if (track->flag & TRACK_DOPE_SEL) {
tracking->act_track = track;
BKE_tracking_select_track(tracksbase, track, TRACK_AREA_ALL, TRUE);
BKE_tracking_track_select(tracksbase, track, TRACK_AREA_ALL, TRUE);
}
}
else if (!extend)

56
source/blender/editors/space_clip/clip_draw.c
View File

@ -98,8 +98,8 @@ static void draw_movieclip_cache(SpaceClip *sc, ARegion *ar, MovieClip *clip, Sc
float x;
int *points, totseg, i, a;
float sfra = SFRA, efra = EFRA, framelen = ar->winx / (efra - sfra + 1);
MovieTrackingTrack *act_track = BKE_tracking_active_track(&clip->tracking);
MovieTrackingReconstruction *reconstruction = BKE_tracking_get_reconstruction(&clip->tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(&clip->tracking);
MovieTrackingReconstruction *reconstruction = BKE_tracking_get_active_reconstruction(&clip->tracking);
glEnable(GL_BLEND);
@ -346,14 +346,14 @@ static void draw_track_path(SpaceClip *sc, MovieClip *UNUSED(clip), MovieTrackin
start_frame = framenr = ED_space_clip_clip_framenr(sc);
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
if (marker->framenr != framenr || marker->flag & MARKER_DISABLED)
return;
a = count;
i = framenr - 1;
while (i >= framenr - count) {
marker = BKE_tracking_get_marker(track, i);
marker = BKE_tracking_marker_get(track, i);
if (!marker || marker->flag & MARKER_DISABLED)
break;
@ -375,7 +375,7 @@ static void draw_track_path(SpaceClip *sc, MovieClip *UNUSED(clip), MovieTrackin
b = count;
i = framenr;
while (i <= framenr + count) {
marker = BKE_tracking_get_marker(track, i);
marker = BKE_tracking_marker_get(track, i);
if (!marker || marker->flag & MARKER_DISABLED)
break;
@ -943,7 +943,7 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
{
float x, y;
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track, *act_track;
MovieTrackingMarker *marker;
int framenr = ED_space_clip_clip_framenr(sc);
@ -967,7 +967,7 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
glMultMatrixf(sc->stabmat);
glScalef(width, height, 0);
act_track = BKE_tracking_active_track(tracking);
act_track = BKE_tracking_track_get_active(tracking);
if (sc->user.render_flag & MCLIP_PROXY_RENDER_UNDISTORT) {
int count = 0;
@ -976,7 +976,7 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
track = tracksbase->first;
while (track) {
if ((track->flag & TRACK_HIDDEN) == 0) {
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
if (MARKER_VISIBLE(sc, track, marker))
count++;
@ -993,7 +993,7 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
fp = marker_pos;
while (track) {
if ((track->flag & TRACK_HIDDEN) == 0) {
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
if (MARKER_VISIBLE(sc, track, marker)) {
ED_clip_point_undistorted_pos(sc, marker->pos, fp);
@ -1025,7 +1025,7 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
fp = marker_pos;
while (track) {
if ((track->flag & TRACK_HIDDEN) == 0) {
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
if (MARKER_VISIBLE(sc, track, marker)) {
copy_v2_v2(cur_pos, fp ? fp : marker->pos);
@ -1050,7 +1050,7 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
while (track) {
if ((track->flag & TRACK_HIDDEN) == 0) {
int act = track == act_track;
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
if (MARKER_VISIBLE(sc, track, marker)) {
if (!act) {
@ -1071,7 +1071,7 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
/* active marker would be displayed on top of everything else */
if (act_track) {
if ((act_track->flag & TRACK_HIDDEN) == 0) {
marker = BKE_tracking_get_marker(act_track, framenr);
marker = BKE_tracking_marker_get(act_track, framenr);
if (MARKER_VISIBLE(sc, act_track, marker)) {
copy_v2_v2(cur_pos, active_pos ? active_pos : marker->pos);
@ -1083,19 +1083,19 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
}
if (sc->flag & SC_SHOW_BUNDLES) {
MovieTrackingObject *object = BKE_tracking_active_object(tracking);
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
float pos[4], vec[4], mat[4][4], aspy;
glEnable(GL_POINT_SMOOTH);
glPointSize(3.0f);
aspy = 1.0f / clip->tracking.camera.pixel_aspect;
BKE_tracking_projection_matrix(tracking, object, framenr, width, height, mat);
BKE_tracking_get_projection_matrix(tracking, object, framenr, width, height, mat);
track = tracksbase->first;
while (track) {
if ((track->flag & TRACK_HIDDEN) == 0 && track->flag & TRACK_HAS_BUNDLE) {
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
if (MARKER_VISIBLE(sc, track, marker)) {
float npos[2];
@ -1107,7 +1107,7 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
pos[0] = (pos[0] / (pos[3] * 2.0f) + 0.5f) * width;
pos[1] = (pos[1] / (pos[3] * 2.0f) + 0.5f) * height * aspy;
BKE_tracking_apply_intrinsics(tracking, pos, npos);
BKE_tracking_distort_v2(tracking, pos, npos);
if (npos[0] >= 0.0f && npos[1] >= 0.0f && npos[0] <= width && npos[1] <= height * aspy) {
vec[0] = (marker->pos[0] + track->offset[0]) * width;
@ -1145,7 +1145,7 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
fp = marker_pos;
while (track) {
if ((track->flag & TRACK_HIDDEN) == 0) {
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
if (MARKER_VISIBLE(sc, track, marker)) {
int act = track == act_track;
@ -1215,7 +1215,7 @@ static void draw_distortion(SpaceClip *sc, ARegion *ar, MovieClip *clip,
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
if (i == 0 || j == 0 || i == n || j == n) {
BKE_tracking_apply_intrinsics(tracking, pos, tpos);
BKE_tracking_distort_v2(tracking, pos, tpos);
for (a = 0; a < 4; a++) {
int ok;
@ -1246,7 +1246,7 @@ static void draw_distortion(SpaceClip *sc, ARegion *ar, MovieClip *clip,
pos[0] = idx[a][0] * dx;
pos[1] = idx[a][1] * dy;
BKE_tracking_invert_intrinsics(tracking, pos, tpos);
BKE_tracking_undistort_v2(tracking, pos, tpos);
DO_MINMAX2(tpos, min, max);
}
@ -1257,7 +1257,7 @@ static void draw_distortion(SpaceClip *sc, ARegion *ar, MovieClip *clip,
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
BKE_tracking_apply_intrinsics(tracking, pos, grid[i][j]);
BKE_tracking_distort_v2(tracking, pos, grid[i][j]);
grid[i][j][0] /= width;
grid[i][j][1] /= height * aspy;
@ -1289,11 +1289,11 @@ static void draw_distortion(SpaceClip *sc, ARegion *ar, MovieClip *clip,
}
if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) {
MovieTrackingTrack *track = BKE_tracking_active_track(&sc->clip->tracking);
MovieTrackingTrack *track = BKE_tracking_track_get_active(&sc->clip->tracking);
if (track) {
int framenr = sc->user.framenr;
MovieTrackingMarker *marker = BKE_tracking_exact_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get_exact(track, framenr);
offsx = marker->pos[0];
offsy = marker->pos[1];
@ -1343,15 +1343,15 @@ static void draw_distortion(SpaceClip *sc, ARegion *ar, MovieClip *clip,
/* we want to distort only long straight lines */
if (stroke->totpoints == 2) {
BKE_tracking_invert_intrinsics(tracking, pos, pos);
BKE_tracking_invert_intrinsics(tracking, npos, npos);
BKE_tracking_undistort_v2(tracking, pos, pos);
BKE_tracking_undistort_v2(tracking, npos, npos);
}
sub_v2_v2v2(dpos, npos, pos);
mul_v2_fl(dpos, 1.0f / steps);
for (j = 0; j <= steps; j++) {
BKE_tracking_apply_intrinsics(tracking, pos, tpos);
BKE_tracking_distort_v2(tracking, pos, tpos);
glVertex2f(tpos[0] / width, tpos[1] / (height * aspy));
add_v2_v2(pos, dpos);
@ -1410,7 +1410,7 @@ void clip_draw_main(SpaceClip *sc, ARegion *ar, Scene *scene)
else
copy_v2_v2(loc, sc->loc);
BKE_tracking_stabdata_to_mat4(width, height, aspect, loc, sc->scale, sc->angle, sc->stabmat);
BKE_tracking_stabilization_data_to_mat4(width, height, aspect, loc, sc->scale, sc->angle, sc->stabmat);
unit_m4(smat);
smat[0][0] = 1.0f / width;
@ -1463,12 +1463,12 @@ void clip_draw_grease_pencil(bContext *C, int onlyv2d)
glMultMatrixf(sc->unistabmat);
if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) {
MovieTrackingTrack *track = BKE_tracking_active_track(&sc->clip->tracking);
MovieTrackingTrack *track = BKE_tracking_track_get_active(&sc->clip->tracking);
if (track) {
int framenr = sc->user.framenr;
/* don't get the exact marker since it may not exist for the frame */
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
if (marker) {
glTranslatef(marker->pos[0], marker->pos[1], 0.0f);
}

8
source/blender/editors/space_clip/clip_editor.c
View File

@ -342,7 +342,7 @@ static int selected_boundbox(SpaceClip *sc, float min[2], float max[2])
MovieClip *clip = ED_space_clip(sc);
MovieTrackingTrack *track;
int width, height, ok = FALSE;
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
INIT_MINMAX2(min, max);
@ -351,7 +351,7 @@ static int selected_boundbox(SpaceClip *sc, float min[2], float max[2])
track = tracksbase->first;
while (track) {
if (TRACK_VIEW_SELECTED(sc, track)) {
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, sc->user.framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, sc->user.framenr);
if (marker) {
float pos[3];
@ -439,7 +439,7 @@ void ED_clip_point_undistorted_pos(SpaceClip *sc, const float co[2], float r_co[
r_co[0] *= width;
r_co[1] *= height * aspy;
BKE_tracking_invert_intrinsics(&clip->tracking, r_co, r_co);
BKE_tracking_undistort_v2(&clip->tracking, r_co, r_co);
r_co[0] /= width;
r_co[1] /= height * aspy;
@ -474,7 +474,7 @@ void ED_clip_point_stable_pos(bContext *C, float x, float y, float *xr, float *y
float aspy = 1.0f / tracking->camera.pixel_aspect;
float tmp[2] = {*xr * width, *yr * height * aspy};
BKE_tracking_apply_intrinsics(tracking, tmp, tmp);
BKE_tracking_distort_v2(tracking, tmp, tmp);
*xr = tmp[0] / width;
*yr = tmp[1] / (height * aspy);

4
source/blender/editors/space_clip/clip_graph_draw.c
View File

@ -148,7 +148,7 @@ static void draw_tracks_curves(View2D *v2d, SpaceClip *sc)
{
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
int width, height;
struct { MovieTrackingTrack *act_track; int sel; float xscale, yscale, hsize; } userdata;
@ -182,7 +182,7 @@ static void draw_frame_curves(SpaceClip *sc)
{
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingReconstruction *reconstruction = BKE_tracking_get_reconstruction(tracking);
MovieTrackingReconstruction *reconstruction = BKE_tracking_get_active_reconstruction(tracking);
int i, lines = 0, prevfra = 0;
glColor3f(0.0f, 0.0f, 1.0f);

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

@ -170,7 +170,7 @@ static int mouse_select_knot(bContext *C, float co[2], int extend)
ARegion *ar = CTX_wm_region(C);
View2D *v2d = &ar->v2d;
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
static const int delta = 6;
if (act_track) {
@ -213,7 +213,7 @@ static int mouse_select_curve(bContext *C, float co[2], int extend)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
MouseSelectUserData userdata;
mouse_select_init_data(&userdata, co);
@ -230,11 +230,11 @@ static int mouse_select_curve(bContext *C, float co[2], int extend)
}
else if (act_track != userdata.track) {
SelectUserData selectdata = {SEL_DESELECT};
MovieTrackingObject *object = BKE_tracking_active_object(tracking);
ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
tracking->act_track = userdata.track;
BKE_tracking_select_track(tracksbase, userdata.track, TRACK_AREA_ALL, TRUE);
BKE_tracking_track_select(tracksbase, userdata.track, TRACK_AREA_ALL, TRUE);
/* deselect all knots on newly selected curve */
clip_graph_tracking_iterate(sc, sc->flag & SC_SHOW_GRAPH_SEL_ONLY,
@ -347,7 +347,7 @@ static int border_select_graph_exec(bContext *C, wmOperator *op)
ARegion *ar = CTX_wm_region(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
BorderSelectuserData userdata;
rcti rect;
@ -402,7 +402,7 @@ static int graph_select_all_markers_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
MovieTrackingMarker *marker;
int action = RNA_enum_get(op->ptr, "action");
int a;
@ -468,8 +468,8 @@ static int delete_curve_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
if (act_track)
clip_delete_track(C, clip, tracksbase, act_track);
@ -500,8 +500,8 @@ static int delete_knot_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
if (act_track) {
int a = 0;
@ -650,7 +650,7 @@ static int graph_disable_markers_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
MovieTrackingMarker *marker;
int action = RNA_enum_get(op->ptr, "action");
int a;

4
source/blender/editors/space_clip/clip_ops.c
View File

@ -986,7 +986,7 @@ static void proxy_startjob(void *pjv, short *stop, short *do_update, float *prog
}
if (build_undistort_count)
distortion = BKE_tracking_distortion_create();
distortion = BKE_tracking_distortion_new();
for (cfra = sfra; cfra <= efra; cfra++) {
if (clip->source != MCLIP_SRC_MOVIE)
@ -1003,7 +1003,7 @@ static void proxy_startjob(void *pjv, short *stop, short *do_update, float *prog
}
if (distortion)
BKE_tracking_distortion_destroy(distortion);
BKE_tracking_distortion_free(distortion);
if (*stop)
pj->stop = 1;

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

@ -128,7 +128,7 @@ void clip_graph_tracking_values_iterate(SpaceClip *sc, int selected_only, int in
{
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track;
for (track = tracksbase->first; track; track = track->next) {
@ -147,7 +147,7 @@ void clip_graph_tracking_iterate(SpaceClip *sc, int selected_only, int include_h
{
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track;
for (track = tracksbase->first; track; track = track->next) {
@ -175,7 +175,7 @@ void clip_delete_track(bContext *C, MovieClip *clip, ListBase *tracksbase, Movie
{
MovieTracking *tracking = &clip->tracking;
MovieTrackingStabilization *stab = &tracking->stabilization;
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
int has_bundle = FALSE, update_stab = FALSE;
@ -192,7 +192,7 @@ void clip_delete_track(bContext *C, MovieClip *clip, ListBase *tracksbase, Movie
if (track->flag & TRACK_HAS_BUNDLE)
has_bundle = TRUE;
BKE_tracking_free_track(track);
BKE_tracking_track_free(track);
BLI_freelinkN(tracksbase, track);
WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip);
@ -215,7 +215,7 @@ void clip_delete_marker(bContext *C, MovieClip *clip, ListBase *tracksbase,
clip_delete_track(C, clip, tracksbase, track);
}
else {
BKE_tracking_delete_marker(track, marker->framenr);
BKE_tracking_marker_delete(track, marker->framenr);
WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip);
}

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

@ -1084,7 +1084,7 @@ static void clip_main_area_draw(const bContext *C, ARegion *ar)
/* if tracking is in progress, we should synchronize framenr from clipuser
* so latest tracked frame would be shown */
if (clip && clip->tracking_context)
BKE_tracking_sync_user(&sc->user, clip->tracking_context);
BKE_tracking_context_sync_user(clip->tracking_context, &sc->user);
if (sc->flag & SC_LOCK_SELECTION) {
ImBuf *tmpibuf = NULL;

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

@ -87,16 +87,16 @@ static void add_marker(SpaceClip *sc, float x, float y)
{
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track;
int width, height;
int framenr = ED_space_clip_clip_framenr(sc);
ED_space_clip_size(sc, &width, &height);
track = BKE_tracking_add_track(tracking, tracksbase, x, y, framenr, width, height);
track = BKE_tracking_track_add(tracking, tracksbase, x, y, framenr, width, height);
BKE_tracking_select_track(tracksbase, track, TRACK_AREA_ALL, 0);
BKE_tracking_track_select(tracksbase, track, TRACK_AREA_ALL, 0);
clip->tracking.act_track = track;
}
@ -164,7 +164,7 @@ static int delete_track_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track = tracksbase->first, *next;
while (track) {
@ -204,7 +204,7 @@ static int delete_marker_exec(bContext *C, wmOperator *UNUSED(op))
{
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
MovieTrackingTrack *track = tracksbase->first, *next;
int framenr = ED_space_clip_clip_framenr(sc);
int has_selection = 0;
@ -213,7 +213,7 @@ static int delete_marker_exec(bContext *C, wmOperator *UNUSED(op))
next = track->next;
if (TRACK_VIEW_SELECTED(sc, track)) {
MovieTrackingMarker *marker = BKE_tracking_exact_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get_exact(track, framenr);
if (marker) {
has_selection |= track->markersnr > 1;
@ -276,7 +276,7 @@ static SlideMarkerData *create_slide_marker_data(SpaceClip *sc, MovieTrackingTra
SlideMarkerData *data = MEM_callocN(sizeof(SlideMarkerData), "slide marker data");
int framenr = ED_space_clip_clip_framenr(sc);
marker = BKE_tracking_ensure_marker(track, framenr);
marker = BKE_tracking_marker_ensure(track, framenr);
data->area = area;
data->action = action;
@ -493,7 +493,7 @@ static void *slide_marker_customdata(bContext *C, wmEvent *event)
int width, height;
float co[2];
void *customdata = NULL;
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
int framenr = ED_space_clip_clip_framenr(sc);
ED_space_clip_size(sc, &width, &height);
@ -506,7 +506,7 @@ static void *slide_marker_customdata(bContext *C, wmEvent *event)
track = tracksbase->first;
while (track) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
if ((marker->flag & MARKER_DISABLED) == 0) {
if (!customdata) {
@ -702,9 +702,9 @@ static int slide_marker_modal(bContext *C, wmOperator *op, wmEvent *event)
}
if (data->area == TRACK_AREA_SEARCH)
BKE_tracking_clamp_marker(data->marker, CLAMP_SEARCH_DIM);
BKE_tracking_marker_clamp(data->marker, CLAMP_SEARCH_DIM);
else
BKE_tracking_clamp_marker(data->marker, CLAMP_PAT_DIM);
BKE_tracking_marker_clamp(data->marker, CLAMP_PAT_DIM);
}
else if (data->action == SLIDE_ACTION_OFFSET) {
float d[2] = {dx, dy};
@ -723,7 +723,7 @@ static int slide_marker_modal(bContext *C, wmOperator *op, wmEvent *event)
}
if (data->area == TRACK_AREA_SEARCH)
BKE_tracking_clamp_marker(data->marker, CLAMP_SEARCH_POS);
BKE_tracking_marker_clamp(data->marker, CLAMP_SEARCH_POS);
}
else if (data->action == SLIDE_ACTION_POS) {
if (data->scale) {
@ -754,7 +754,7 @@ static int slide_marker_modal(bContext *C, wmOperator *op, wmEvent *event)
}
/* currently only patterns are allowed to have such combination of event and data */
BKE_tracking_clamp_marker(data->marker, CLAMP_PAT_DIM);
BKE_tracking_marker_clamp(data->marker, CLAMP_PAT_DIM);
}
}
@ -842,7 +842,7 @@ static int mouse_on_crns(float co[2], float pos[2], float crns[4][2], float epsx
static int track_mouse_area(SpaceClip *sc, float co[2], MovieTrackingTrack *track)
{
int framenr = ED_space_clip_clip_framenr(sc);
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
float pat_min[2], pat_max[2];
float epsx, epsy;
int width, height;
@ -920,7 +920,7 @@ static MovieTrackingTrack *find_nearest_track(SpaceClip *sc, ListBase *tracksbas
cur = tracksbase->first;
while (cur) {
MovieTrackingMarker *marker = BKE_tracking_get_marker(cur, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(cur, framenr);
if (((cur->flag & TRACK_HIDDEN) == 0) && MARKER_VISIBLE(sc, cur, marker)) {
float dist, d1, d2 = FLT_MAX, d3 = FLT_MAX;
@ -957,8 +957,8 @@ static int mouse_select(bContext *C, float co[2], int extend)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
MovieTrackingTrack *track = NULL; /* selected marker */
track = find_nearest_track(sc, tracksbase, co);
@ -971,7 +971,7 @@ static int mouse_select(bContext *C, float co[2], int extend)
if (extend && TRACK_AREA_SELECTED(track, area)) {
if (track == act_track)
BKE_tracking_deselect_track(track, area);
BKE_tracking_track_deselect(track, area);
else
clip->tracking.act_track = track;
}
@ -979,7 +979,7 @@ static int mouse_select(bContext *C, float co[2], int extend)
if (area == TRACK_AREA_POINT)
area = TRACK_AREA_ALL;
BKE_tracking_select_track(tracksbase, track, area, extend);
BKE_tracking_track_select(tracksbase, track, area, extend);
clip->tracking.act_track = track;
}
}
@ -1066,7 +1066,7 @@ static int border_select_exec(bContext *C, wmOperator *op)
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *track;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
rcti rect;
rctf rectf;
int change = FALSE, mode, extend;
@ -1088,14 +1088,17 @@ static int border_select_exec(bContext *C, wmOperator *op)
track = tracksbase->first;
while (track) {
if ((track->flag & TRACK_HIDDEN) == 0) {
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
if (MARKER_VISIBLE(sc, track, marker)) {
if (BLI_in_rctf(&rectf, marker->pos[0], marker->pos[1])) {
BKE_tracking_track_flag(track, TRACK_AREA_ALL, SELECT, mode != GESTURE_MODAL_SELECT);
if (mode == GESTURE_MODAL_SELECT)
BKE_tracking_track_flag_set(track, TRACK_AREA_ALL, SELECT);
else
BKE_tracking_track_flag_clear(track, TRACK_AREA_ALL, SELECT);
}
else if (!extend) {
BKE_tracking_track_flag(track, TRACK_AREA_ALL, SELECT, 1);
BKE_tracking_track_flag_clear(track, TRACK_AREA_ALL, SELECT);
}
change = TRUE;
@ -1144,7 +1147,7 @@ static int do_lasso_select_marker(bContext *C, int mcords[][2], short moves, sho
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *track;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
rcti rect;
int change = FALSE;
int framenr = ED_space_clip_clip_framenr(sc);
@ -1156,7 +1159,7 @@ static int do_lasso_select_marker(bContext *C, int mcords[][2], short moves, sho
track = tracksbase->first;
while (track) {
if ((track->flag & TRACK_HIDDEN) == 0) {
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
if (MARKER_VISIBLE(sc, track, marker)) {
float screen_co[2];
@ -1167,7 +1170,10 @@ static int do_lasso_select_marker(bContext *C, int mcords[][2], short moves, sho
if (BLI_in_rcti(&rect, screen_co[0], screen_co[1]) &&
BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], V2D_IS_CLIPPED))
{
BKE_tracking_track_flag(track, TRACK_AREA_ALL, SELECT, !select);
if (select)
BKE_tracking_track_flag_set(track, TRACK_AREA_ALL, SELECT);
else
BKE_tracking_track_flag_clear(track, TRACK_AREA_ALL, SELECT);
}
change = TRUE;
@ -1247,7 +1253,7 @@ static int circle_select_exec(bContext *C, wmOperator *op)
ARegion *ar = CTX_wm_region(C);
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *track;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
int x, y, radius, width, height, mode, change = FALSE;
float zoomx, zoomy, offset[2], ellipse[2];
int framenr = ED_space_clip_clip_framenr(sc);
@ -1272,10 +1278,13 @@ static int circle_select_exec(bContext *C, wmOperator *op)
track = tracksbase->first;
while (track) {
if ((track->flag & TRACK_HIDDEN) == 0) {
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
if (MARKER_VISIBLE(sc, track, marker) && marker_inside_ellipse(marker, offset, ellipse)) {
BKE_tracking_track_flag(track, TRACK_AREA_ALL, SELECT, mode != GESTURE_MODAL_SELECT);
if (mode == GESTURE_MODAL_SELECT)
BKE_tracking_track_flag_set(track, TRACK_AREA_ALL, SELECT);
else
BKE_tracking_track_flag_clear(track, TRACK_AREA_ALL, SELECT);
change = TRUE;
}
@ -1327,7 +1336,7 @@ static int select_all_exec(bContext *C, wmOperator *op)
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *track = NULL; /* selected track */
MovieTrackingMarker *marker;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
int action = RNA_enum_get(op->ptr, "action");
int framenr = ED_space_clip_clip_framenr(sc);
int has_selection = FALSE;
@ -1337,7 +1346,7 @@ static int select_all_exec(bContext *C, wmOperator *op)
track = tracksbase->first;
while (track) {
if (TRACK_VIEW_SELECTED(sc, track)) {
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
if (MARKER_VISIBLE(sc, track, marker)) {
action = SEL_DESELECT;
@ -1352,7 +1361,7 @@ static int select_all_exec(bContext *C, wmOperator *op)
track = tracksbase->first;
while (track) {
if ((track->flag & TRACK_HIDDEN) == 0) {
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
if (MARKER_VISIBLE(sc, track, marker)) {
switch (action) {
@ -1417,7 +1426,7 @@ static int select_groped_exec(bContext *C, wmOperator *op)
MovieTrackingTrack *track;
MovieTrackingMarker *marker;
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
int group = RNA_enum_get(op->ptr, "group");
int framenr = ED_space_clip_clip_framenr(sc);
@ -1425,7 +1434,7 @@ static int select_groped_exec(bContext *C, wmOperator *op)
while (track) {
int ok = FALSE;
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
if (group == 0) { /* Keyframed */
ok = marker->framenr == framenr && (marker->flag & MARKER_TRACKED) == 0;
@ -1443,7 +1452,7 @@ static int select_groped_exec(bContext *C, wmOperator *op)
ok = marker->flag & MARKER_DISABLED;
}
else if (group == 5) { /* color */
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
if (act_track) {
ok = (track->flag & TRACK_CUSTOMCOLOR) == (act_track->flag & TRACK_CUSTOMCOLOR);
@ -1525,14 +1534,14 @@ static int track_markers_testbreak(void)
static int track_count_markers(SpaceClip *sc, MovieClip *clip)
{
int tot = 0;
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
MovieTrackingTrack *track;
int framenr = ED_space_clip_clip_framenr(sc);
track = tracksbase->first;
while (track) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
if (!marker || (marker->flag & MARKER_DISABLED) == 0)
tot++;
@ -1546,7 +1555,7 @@ static int track_count_markers(SpaceClip *sc, MovieClip *clip)
static void clear_invisible_track_selection(SpaceClip *sc, MovieClip *clip)
{
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
int hidden = 0;
if ((sc->flag & SC_SHOW_MARKER_PATTERN) == 0)
@ -1560,7 +1569,7 @@ static void clear_invisible_track_selection(SpaceClip *sc, MovieClip *clip)
while (track) {
if ((track->flag & TRACK_HIDDEN) == 0)
BKE_tracking_track_flag(track, hidden, SELECT, 1);
BKE_tracking_track_flag_clear(track, hidden, SELECT);
track = track->next;
}
@ -1569,7 +1578,7 @@ static void clear_invisible_track_selection(SpaceClip *sc, MovieClip *clip)
static void track_init_markers(SpaceClip *sc, MovieClip *clip, int *frames_limit_r)
{
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
MovieTrackingTrack *track;
int framenr = ED_space_clip_clip_framenr(sc);
int frames_limit = 0;
@ -1580,7 +1589,7 @@ static void track_init_markers(SpaceClip *sc, MovieClip *clip, int *frames_limit
while (track) {
if (TRACK_VIEW_SELECTED(sc, track)) {
if ((track->flag & TRACK_HIDDEN) == 0 && (track->flag & TRACK_LOCKED) == 0) {
BKE_tracking_ensure_marker(track, framenr);
BKE_tracking_marker_ensure(track, framenr);
if (track->frames_limit) {
if (frames_limit == 0)
@ -1685,14 +1694,14 @@ static void track_markers_startjob(void *tmv, short *stop, short *do_update, flo
double start_time = PIL_check_seconds_timer(), exec_time;
if (!BKE_tracking_next(tmj->context))
if (!BKE_tracking_context_step(tmj->context))
break;
exec_time = PIL_check_seconds_timer() - start_time;
if (tmj->delay > (float)exec_time)
PIL_sleep_ms(tmj->delay - (float)exec_time);
}
else if (!BKE_tracking_next(tmj->context))
else if (!BKE_tracking_context_step(tmj->context))
break;
*do_update = TRUE;
@ -1716,7 +1725,7 @@ static void track_markers_updatejob(void *tmv)
{
TrackMarkersJob *tmj = (TrackMarkersJob *)tmv;
BKE_tracking_sync(tmj->context);
BKE_tracking_context_sync(tmj->context);
}
static void track_markers_freejob(void *tmv)
@ -1727,7 +1736,7 @@ static void track_markers_freejob(void *tmv)
tmj->scene->r.cfra = BKE_movieclip_remap_clip_to_scene_frame(tmj->clip, tmj->lastfra);
ED_update_for_newframe(tmj->main, tmj->scene, 0);
BKE_tracking_sync(tmj->context);
BKE_tracking_context_sync(tmj->context);
BKE_tracking_context_free(tmj->context);
MEM_freeN(tmj);
@ -1774,7 +1783,7 @@ static int track_markers_exec(bContext *C, wmOperator *op)
context = BKE_tracking_context_new(clip, &sc->user, backwards, sequence);
while (framenr != efra) {
if (!BKE_tracking_next(context))
if (!BKE_tracking_context_step(context))
break;
if (backwards) framenr--;
@ -1784,7 +1793,7 @@ static int track_markers_exec(bContext *C, wmOperator *op)
break;
}
BKE_tracking_sync(context);
BKE_tracking_context_sync(context);
BKE_tracking_context_free(context);
/* update scene current frame to the lastes tracked frame */
@ -1911,10 +1920,10 @@ static int solve_camera_initjob(bContext *C, SolveCameraJob *scj, wmOperator *op
Scene *scene = CTX_data_scene(C);
MovieTracking *tracking = &clip->tracking;
MovieTrackingSettings *settings = &clip->tracking.settings;
MovieTrackingObject *object = BKE_tracking_active_object(tracking);
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
int width, height;
if (!BKE_tracking_can_reconstruct(tracking, object, error_msg, max_error))
if (!BKE_tracking_reconstruction_check(tracking, object, error_msg, max_error))
return 0;
/* could fail if footage uses images with different sizes */
@ -1945,7 +1954,7 @@ static void solve_camera_startjob(void *scv, short *stop, short *do_update, floa
{
SolveCameraJob *scj = (SolveCameraJob *)scv;
BKE_tracking_solve_reconstruction(scj->context, stop, do_update, progress,
BKE_tracking_reconstruction_solve(scj->context, stop, do_update, progress,
scj->stats_message, sizeof(scj->stats_message));
}
@ -1963,7 +1972,7 @@ static void solve_camera_freejob(void *scv)
return;
}
solved = BKE_tracking_finish_reconstruction(scj->context, tracking);
solved = BKE_tracking_reconstruction_finish(scj->context, tracking);
if (!solved)
BKE_report(scj->reports, RPT_WARNING, "Some data failed to reconstruct, see console for details");
@ -2033,7 +2042,7 @@ static int solve_camera_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(even
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingReconstruction *reconstruction = BKE_tracking_get_reconstruction(tracking);
MovieTrackingReconstruction *reconstruction = BKE_tracking_get_active_reconstruction(tracking);
wmJob *steve;
char error_msg[256] = "\0";
@ -2115,8 +2124,8 @@ static int clear_solution_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
MovieTrackingReconstruction *reconstruction = BKE_tracking_get_reconstruction(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
MovieTrackingReconstruction *reconstruction = BKE_tracking_get_active_reconstruction(tracking);
MovieTrackingTrack *track = tracksbase->first;
while (track) {
@ -2163,20 +2172,20 @@ static int clear_track_path_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTrackingTrack *track;
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
int action = RNA_enum_get(op->ptr, "action");
int clear_active = RNA_boolean_get(op->ptr, "clear_active");
int framenr = ED_space_clip_clip_framenr(sc);
if (clear_active) {
track = BKE_tracking_active_track(&clip->tracking);
BKE_tracking_clear_path(track, framenr, action);
track = BKE_tracking_track_get_active(&clip->tracking);
BKE_tracking_track_path_clear(track, framenr, action);
}
else {
track = tracksbase->first;
while (track) {
if (TRACK_VIEW_SELECTED(sc, track))
BKE_tracking_clear_path(track, framenr, action);
BKE_tracking_track_path_clear(track, framenr, action);
track = track->next;
}
@ -2220,14 +2229,14 @@ static int disable_markers_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track = tracksbase->first;
int action = RNA_enum_get(op->ptr, "action");
int framenr = ED_space_clip_clip_framenr(sc);
while (track) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
MovieTrackingMarker *marker = BKE_tracking_ensure_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_ensure(track, framenr);
if (action == 0)
marker->flag |= MARKER_DISABLED;
@ -2302,7 +2311,7 @@ static Object *get_orientation_object(bContext *C)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_active_object(tracking);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
Object *object = NULL;
if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
@ -2328,7 +2337,7 @@ static int set_orientation_poll(bContext *C)
if (clip) {
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_active_object(tracking);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
return TRUE;
@ -2346,7 +2355,7 @@ static int count_selected_bundles(bContext *C)
{
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
MovieTrackingTrack *track;
int tot = 0;
@ -2440,9 +2449,9 @@ static int set_origin_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
tracking_object = BKE_tracking_active_object(tracking);
tracking_object = BKE_tracking_object_get_active(tracking);
tracksbase = BKE_tracking_object_tracks(tracking, tracking_object);
tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
track = tracksbase->first;
zero_v3(median);
@ -2455,7 +2464,7 @@ static int set_origin_exec(bContext *C, wmOperator *op)
}
mul_v3_fl(median, 1.0f / selected_count);
BKE_get_tracking_mat(scene, camera, mat);
BKE_tracking_get_camera_object_matrix(scene, camera, mat);
mul_v3_m4v3(vec, mat, median);
@ -2507,7 +2516,7 @@ static void set_axis(Scene *scene, Object *ob, MovieClip *clip, MovieTrackingOb
BKE_object_to_mat4(ob, obmat);
BKE_get_tracking_mat(scene, camera, mat);
BKE_tracking_get_camera_object_matrix(scene, camera, mat);
mul_v3_m4v3(vec, mat, track->bundle_pos);
copy_v3_v3(dvec, vec);
@ -2633,9 +2642,9 @@ static int set_plane_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
tracking_object = BKE_tracking_active_object(tracking);
tracksbase = BKE_tracking_object_tracks(tracking, tracking_object);
act_track = BKE_tracking_active_track(tracking);
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);
object = get_orientation_object(C);
if (!object) {
@ -2644,7 +2653,7 @@ static int set_plane_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
BKE_get_tracking_mat(scene, camera, mat);
BKE_tracking_get_camera_object_matrix(scene, camera, mat);
/* get 3 bundles to use as reference */
track = tracksbase->first;
@ -2751,7 +2760,7 @@ static int set_axis_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_active_object(tracking);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
MovieTrackingTrack *track;
Scene *scene = CTX_data_scene(C);
Object *object;
@ -2771,7 +2780,7 @@ static int set_axis_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
tracksbase = BKE_tracking_object_tracks(tracking, tracking_object);
tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
track = tracksbase->first;
while (track) {
@ -2823,12 +2832,12 @@ static int do_set_scale(bContext *C, wmOperator *op, int scale_solution)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_active_object(tracking);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
MovieTrackingTrack *track;
Scene *scene = CTX_data_scene(C);
Object *object = NULL;
Object *camera = get_camera_with_movieclip(scene, clip);
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
int tot = 0;
float vec[2][3], mat[4][4], scale;
float dist = RNA_float_get(op->ptr, "distance");
@ -2846,7 +2855,7 @@ static int do_set_scale(bContext *C, wmOperator *op, int scale_solution)
return OPERATOR_CANCELLED;
}
BKE_get_tracking_mat(scene, camera, mat);
BKE_tracking_get_camera_object_matrix(scene, camera, mat);
track = tracksbase->first;
while (track) {
@ -2941,7 +2950,7 @@ static int set_solution_scale_poll(bContext *C)
if (clip) {
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *tracking_object = BKE_tracking_active_object(tracking);
MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
return (tracking_object->flag & TRACKING_OBJECT_CAMERA) == 0;
}
@ -3030,8 +3039,8 @@ static int hide_tracks_exec(bContext *C, wmOperator *op)
MovieClip *clip = ED_space_clip(sc);
MovieTrackingTrack *track;
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
int unselected;
unselected = RNA_boolean_get(op->ptr, "unselected");
@ -3088,7 +3097,7 @@ static int hide_tracks_clear_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track;
track = tracksbase->first;
@ -3147,7 +3156,7 @@ static int detect_features_exec(bContext *C, wmOperator *op)
int clip_flag = clip->flag & MCLIP_TIMECODE_FLAGS;
ImBuf *ibuf = BKE_movieclip_get_ibuf_flag(clip, &sc->user, clip_flag, MOVIECLIP_CACHE_SKIP);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track = tracksbase->first;
int placement = RNA_enum_get(op->ptr, "placement");
int margin = RNA_int_get(op->ptr, "margin");
@ -3226,7 +3235,7 @@ static int frame_jump_exec(bContext *C, wmOperator *op)
int delta;
if (pos <= 1) { /* jump to path */
track = BKE_tracking_active_track(&clip->tracking);
track = BKE_tracking_track_get_active(&clip->tracking);
if (!track)
return OPERATOR_CANCELLED;
@ -3235,7 +3244,7 @@ static int frame_jump_exec(bContext *C, wmOperator *op)
while (sc->user.framenr + delta >= SFRA && sc->user.framenr + delta <= EFRA) {
int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, sc->user.framenr + delta);
MovieTrackingMarker *marker = BKE_tracking_exact_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get_exact(track, framenr);
if (!marker || marker->flag & MARKER_DISABLED)
break;
@ -3247,7 +3256,7 @@ static int frame_jump_exec(bContext *C, wmOperator *op)
if (clip->tracking.reconstruction.flag & TRACKING_RECONSTRUCTED) {
int a = ED_space_clip_clip_framenr(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *object = BKE_tracking_active_object(tracking);
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
delta = pos == 3 ? 1 : -1;
@ -3256,7 +3265,7 @@ static int frame_jump_exec(bContext *C, wmOperator *op)
while (a + delta >= SFRA && a + delta <= EFRA) {
MovieReconstructedCamera *cam;
cam = BKE_tracking_get_reconstructed_camera(tracking, object, a);
cam = BKE_tracking_camera_get_reconstructed(tracking, object, a);
if (!cam) {
sc->user.framenr = BKE_movieclip_remap_clip_to_scene_frame(clip, a);
@ -3314,10 +3323,10 @@ static int join_tracks_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *act_track, *track, *next;
act_track = BKE_tracking_active_track(tracking);
act_track = BKE_tracking_track_get_active(tracking);
if (!act_track) {
BKE_report(op->reports, RPT_ERROR, "No active track to join to");
@ -3329,12 +3338,12 @@ static int join_tracks_exec(bContext *C, wmOperator *op)
next = track->next;
if (TRACK_VIEW_SELECTED(sc, track) && track != act_track) {
BKE_tracking_join_tracks(act_track, track);
BKE_tracking_tracks_join(act_track, track);
if (tracking->stabilization.rot_track == track)
tracking->stabilization.rot_track = act_track;
BKE_tracking_free_track(track);
BKE_tracking_track_free(track);
BLI_freelinkN(tracksbase, track);
}
@ -3368,7 +3377,7 @@ static int lock_tracks_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track = tracksbase->first;
int action = RNA_enum_get(op->ptr, "action");
@ -3421,8 +3430,8 @@ static int track_copy_color_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
MovieTrackingTrack *track, *act_track = BKE_tracking_active_track(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track, *act_track = BKE_tracking_track_get_active(tracking);
if (!act_track)
return OPERATOR_CANCELLED;
@ -3468,7 +3477,7 @@ static int stabilize_2d_add_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track;
MovieTrackingStabilization *stab = &tracking->stabilization;
int update = 0;
@ -3518,7 +3527,7 @@ static int stabilize_2d_remove_exec(bContext *C, wmOperator *UNUSED(op))
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingStabilization *stab = &tracking->stabilization;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track;
int a = 0, update = 0;
@ -3577,14 +3586,14 @@ static int stabilize_2d_select_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track;
int update = 0;
track = tracksbase->first;
while (track) {
if (track->flag & TRACK_USE_2D_STAB) {
BKE_tracking_track_flag(track, TRACK_AREA_ALL, SELECT, 0);
BKE_tracking_track_flag_set(track, TRACK_AREA_ALL, SELECT);
update = 1;
}
@ -3620,7 +3629,7 @@ static int stabilize_2d_set_rotation_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
if (act_track) {
MovieTrackingStabilization *stab = &tracking->stabilization;
@ -3750,8 +3759,8 @@ static int clean_tracks_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
MovieTrackingTrack *track, *next, *act_track = BKE_tracking_active_track(tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
MovieTrackingTrack *track, *next, *act_track = BKE_tracking_track_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");
@ -3771,13 +3780,13 @@ static int clean_tracks_exec(bContext *C, wmOperator *op)
if (!ok) {
if (action == TRACKING_CLEAN_SELECT) {
BKE_tracking_track_flag(track, TRACK_AREA_ALL, SELECT, 0);
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;
BKE_tracking_free_track(track);
BKE_tracking_track_free(track);
BLI_freelinkN(tracksbase, track);
track = NULL;
}
@ -3787,7 +3796,7 @@ static int clean_tracks_exec(bContext *C, wmOperator *op)
if (track == act_track)
clip->tracking.act_track = NULL;
BKE_tracking_free_track(track);
BKE_tracking_track_free(track);
BLI_freelinkN(tracksbase, track);
}
}
@ -3856,7 +3865,7 @@ static int tracking_object_new_exec(bContext *C, wmOperator *UNUSED(op))
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
BKE_tracking_new_object(tracking, "Object");
BKE_tracking_object_add(tracking, "Object");
WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip);
@ -3887,14 +3896,14 @@ static int tracking_object_remove_exec(bContext *C, wmOperator *op)
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *object;
object = BKE_tracking_active_object(tracking);
object = BKE_tracking_object_get_active(tracking);
if (object->flag & TRACKING_OBJECT_CAMERA) {
BKE_report(op->reports, RPT_WARNING, "Object used for camera tracking can't be deleted");
return OPERATOR_CANCELLED;
}
BKE_tracking_remove_object(tracking, object);
BKE_tracking_object_delete(tracking, object);
WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip);
@ -3923,7 +3932,7 @@ static int copy_tracks_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *object = BKE_tracking_active_object(tracking);
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
clear_invisible_track_selection(sc, clip);
@ -3963,7 +3972,7 @@ static int paste_tracks_exec(bContext *C, wmOperator *UNUSED(op))
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *object = BKE_tracking_active_object(tracking);
MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
BKE_tracking_clipboard_paste_tracks(tracking, object);

8
source/blender/editors/space_view3d/drawobject.c
View File

@ -1566,12 +1566,12 @@ static void draw_viewport_object_reconstruction(Scene *scene, Base *base, View3D
float mat[4][4], imat[4][4];
unsigned char col[4], scol[4];
int tracknr = *global_track_index;
ListBase *tracksbase = BKE_tracking_object_tracks(tracking, tracking_object);
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
UI_GetThemeColor4ubv(TH_TEXT, col);
UI_GetThemeColor4ubv(TH_SELECT, scol);
BKE_get_tracking_mat(scene, base->object, mat);
BKE_tracking_get_camera_object_matrix(scene, base->object, mat);
glPushMatrix();
@ -1587,7 +1587,7 @@ static void draw_viewport_object_reconstruction(Scene *scene, Base *base, View3D
else {
float obmat[4][4];
BKE_tracking_get_interpolated_camera(tracking, tracking_object, scene->r.cfra, obmat);
BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, scene->r.cfra, obmat);
invert_m4_m4(imat, obmat);
glMultMatrixf(imat);
@ -1685,7 +1685,7 @@ static void draw_viewport_object_reconstruction(Scene *scene, Base *base, View3D
if ((dflag & DRAW_PICKING) == 0) {
if ((v3d->flag2 & V3D_SHOW_CAMERAPATH) && (tracking_object->flag & TRACKING_OBJECT_CAMERA)) {
MovieTrackingReconstruction *reconstruction;
reconstruction = BKE_tracking_object_reconstruction(tracking, tracking_object);
reconstruction = BKE_tracking_object_get_reconstruction(tracking, tracking_object);
if (reconstruction->camnr) {
MovieReconstructedCamera *camera = reconstruction->cameras;

10
source/blender/editors/space_view3d/view3d_select.c
View File

@ -1303,11 +1303,11 @@ static void deselect_all_tracks(MovieTracking *tracking)
object = tracking->objects.first;
while (object) {
ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
MovieTrackingTrack *track = tracksbase->first;
while (track) {
BKE_tracking_deselect_track(track, TRACK_AREA_ALL);
BKE_tracking_track_deselect(track, TRACK_AREA_ALL);
track = track->next;
}
@ -1408,18 +1408,18 @@ static int mouse_select(bContext *C, const int mval[2], short extend, short dese
ListBase *tracksbase;
MovieTrackingTrack *track;
track = BKE_tracking_indexed_track(&clip->tracking, hitresult >> 16, &tracksbase);
track = BKE_tracking_track_get_indexed(&clip->tracking, hitresult >> 16, &tracksbase);
if (TRACK_SELECTED(track) && extend) {
changed = 0;
BKE_tracking_deselect_track(track, TRACK_AREA_ALL);
BKE_tracking_track_deselect(track, TRACK_AREA_ALL);
}
else {
int oldsel = TRACK_SELECTED(track) ? 1 : 0;
if (!extend)
deselect_all_tracks(tracking);
BKE_tracking_select_track(tracksbase, track, TRACK_AREA_ALL, extend);
BKE_tracking_track_select(tracksbase, track, TRACK_AREA_ALL, extend);
if (oldsel != (TRACK_SELECTED(track) ? 1 : 0))
changed = 1;

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

@ -831,12 +831,12 @@ static void bundle_midpoint(Scene *scene, Object *ob, float vec[3])
copy_m4_m4(cammat, ob->obmat);
BKE_get_tracking_mat(scene, ob, mat);
BKE_tracking_get_camera_object_matrix(scene, ob, mat);
INIT_MINMAX(min, max);
for (object = tracking->objects.first; object; object = object->next) {
ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
MovieTrackingTrack *track = tracksbase->first;
float obmat[4][4];
@ -846,7 +846,7 @@ static void bundle_midpoint(Scene *scene, Object *ob, float vec[3])
else {
float imat[4][4];
BKE_tracking_get_interpolated_camera(tracking, object, scene->r.cfra, imat);
BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, scene->r.cfra, imat);
invert_m4(imat);
mult_m4_m4m4(obmat, cammat, imat);

14
source/blender/editors/transform/transform_conversions.c
View File

@ -5654,7 +5654,7 @@ static void trackToTransData(SpaceClip *sc, TransData *td, TransData2D *td2d,
TransDataTracking *tdt, MovieTrackingTrack *track, float aspx, float aspy)
{
int framenr = ED_space_clip_clip_framenr(sc);
MovieTrackingMarker *marker = BKE_tracking_ensure_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_ensure(track, framenr);
tdt->flag = marker->flag;
marker->flag &= ~(MARKER_DISABLED | MARKER_TRACKED);
@ -5703,7 +5703,7 @@ static void createTransTrackingTracksData(bContext *C, TransInfo *t)
TransData2D *td2d;
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
MovieTrackingTrack *track;
MovieTrackingMarker *marker;
TransDataTracking *tdt;
@ -5716,7 +5716,7 @@ static void createTransTrackingTracksData(bContext *C, TransInfo *t)
track = tracksbase->first;
while (track) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
t->total++; /* offset */
@ -5748,7 +5748,7 @@ static void createTransTrackingTracksData(bContext *C, TransInfo *t)
track = tracksbase->first;
while (track) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
trackToTransData(sc, td, td2d, tdt, track, aspx, aspy);
@ -5831,7 +5831,7 @@ static void createTransTrackingCurvesData(bContext *C, TransInfo *t)
TransData2D *td2d;
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip(sc);
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
MovieTrackingTrack *track;
MovieTrackingMarker *marker, *prev_marker;
TransDataTracking *tdt;
@ -5932,7 +5932,7 @@ static void cancelTransTracking(TransInfo *t)
TransDataTracking *tdt = t->customData;
SpaceClip *sc = t->sa->spacedata.first;
MovieClip *clip = ED_space_clip(sc);
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
MovieTrackingTrack *track;
MovieTrackingMarker *marker;
int a, framenr = ED_space_clip_clip_framenr(sc);
@ -5941,7 +5941,7 @@ static void cancelTransTracking(TransInfo *t)
track = tracksbase->first;
while (track) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
marker = BKE_tracking_get_marker(track, framenr);
marker = BKE_tracking_marker_get(track, framenr);
marker->flag = tdt->flag;
tdt++;

14
source/blender/editors/transform/transform_generics.c
View File

@ -641,7 +641,7 @@ static void recalcData_spaceclip(TransInfo *t)
if (ED_space_clip_show_trackedit(sc)) {
MovieClip *clip = ED_space_clip(sc);
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
MovieTrackingTrack *track;
int framenr = sc->user.framenr;
@ -650,23 +650,23 @@ static void recalcData_spaceclip(TransInfo *t)
track = tracksbase->first;
while (track) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
if (t->mode == TFM_TRANSLATION) {
if (TRACK_AREA_SELECTED(track, TRACK_AREA_PAT))
BKE_tracking_clamp_marker(marker, CLAMP_PAT_POS);
BKE_tracking_marker_clamp(marker, CLAMP_PAT_POS);
if (TRACK_AREA_SELECTED(track, TRACK_AREA_SEARCH))
BKE_tracking_clamp_marker(marker, CLAMP_SEARCH_POS);
BKE_tracking_marker_clamp(marker, CLAMP_SEARCH_POS);
}
else if (t->mode == TFM_RESIZE) {
if (TRACK_AREA_SELECTED(track, TRACK_AREA_PAT))
BKE_tracking_clamp_marker(marker, CLAMP_PAT_DIM);
BKE_tracking_marker_clamp(marker, CLAMP_PAT_DIM);
if (TRACK_AREA_SELECTED(track, TRACK_AREA_SEARCH))
BKE_tracking_clamp_marker(marker, CLAMP_SEARCH_DIM);
BKE_tracking_marker_clamp(marker, CLAMP_SEARCH_DIM);
}
else if (t->mode == TFM_ROTATION) {
if (TRACK_AREA_SELECTED(track, TRACK_AREA_PAT))
BKE_tracking_clamp_marker(marker, CLAMP_PAT_POS);
BKE_tracking_marker_clamp(marker, CLAMP_PAT_POS);
}
}

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

@ -126,7 +126,7 @@ static void rna_tracking_active_object_index_range(PointerRNA *ptr, int *min, in
static PointerRNA rna_tracking_active_track_get(PointerRNA *ptr)
{
MovieClip *clip = (MovieClip *)ptr->id.data;
MovieTrackingTrack *act_track = BKE_tracking_active_track(&clip->tracking);
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(&clip->tracking);
return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingTrack, act_track);
}
@ -135,7 +135,7 @@ static void rna_tracking_active_track_set(PointerRNA *ptr, PointerRNA value)
{
MovieClip *clip = (MovieClip *)ptr->id.data;
MovieTrackingTrack *track = (MovieTrackingTrack *)value.data;
ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
int index = BLI_findindex(tracksbase, track);
if (index >= 0)
@ -169,7 +169,7 @@ void rna_trackingTrack_name_set(PointerRNA *ptr, const char *value)
}
}
BKE_track_unique_name(tracksbase, track);
BKE_tracking_track_unique_name(tracksbase, track);
}
static int rna_trackingTrack_select_get(PointerRNA *ptr)
@ -363,8 +363,8 @@ static void rna_trackingMarker_frame_set(PointerRNA *ptr, int value)
MovieTrackingMarker new_marker = *marker;
new_marker.framenr = value;
BKE_tracking_delete_marker(track, marker->framenr);
BKE_tracking_insert_marker(track, &new_marker);
BKE_tracking_marker_delete(track, marker->framenr);
BKE_tracking_marker_insert(track, &new_marker);
}
}
@ -372,14 +372,14 @@ static void rna_tracking_markerPattern_update(Main *UNUSED(bmain), Scene *UNUSED
{
MovieTrackingMarker *marker = (MovieTrackingMarker *)ptr->data;
BKE_tracking_clamp_marker(marker, CLAMP_PAT_DIM);
BKE_tracking_marker_clamp(marker, CLAMP_PAT_DIM);
}
static void rna_tracking_markerSearch_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
{
MovieTrackingMarker *marker = (MovieTrackingMarker *)ptr->data;
BKE_tracking_clamp_marker(marker, CLAMP_SEARCH_DIM);
BKE_tracking_marker_clamp(marker, CLAMP_SEARCH_DIM);
}
static void rna_trackingDopesheet_tagUpdate(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
@ -402,7 +402,7 @@ static void add_tracks_to_base(MovieClip *clip, MovieTracking *tracking, ListBas
BKE_movieclip_get_size(clip, &user, &width, &height);
for (a = 0; a < number; a++)
BKE_tracking_add_track(tracking, tracksbase, 0, 0, frame, width, height);
BKE_tracking_track_add(tracking, tracksbase, 0, 0, frame, width, height);
}
static void rna_trackingTracks_add(ID *id, MovieTracking *tracking, int frame, int number)
@ -429,7 +429,7 @@ static void rna_trackingObject_tracks_add(ID *id, MovieTrackingObject *object, i
static MovieTrackingObject *rna_trackingObject_new(MovieTracking *tracking, const char *name)
{
MovieTrackingObject *object = BKE_tracking_new_object(tracking, name);
MovieTrackingObject *object = BKE_tracking_object_add(tracking, name);
WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
@ -438,14 +438,14 @@ static MovieTrackingObject *rna_trackingObject_new(MovieTracking *tracking, cons
void rna_trackingObject_remove(MovieTracking *tracking, MovieTrackingObject *object)
{
BKE_tracking_remove_object(tracking, object);
BKE_tracking_object_delete(tracking, object);
WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
}
static MovieTrackingMarker *rna_trackingMarkers_find_frame(MovieTrackingTrack *track, int framenr)
{
return BKE_tracking_exact_marker(track, framenr);
return BKE_tracking_marker_get_exact(track, framenr);
}
static MovieTrackingMarker *rna_trackingMarkers_insert_frame(MovieTrackingTrack *track, int framenr, float *co)
@ -456,7 +456,7 @@ static MovieTrackingMarker *rna_trackingMarkers_insert_frame(MovieTrackingTrack
marker.framenr = framenr;
copy_v2_v2(marker.pos, co);
new_marker = BKE_tracking_insert_marker(track, &marker);
new_marker = BKE_tracking_marker_insert(track, &marker);
WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
@ -468,7 +468,7 @@ void rna_trackingMarkers_delete_frame(MovieTrackingTrack *track, int framenr)
if (track->markersnr == 1)
return;
BKE_tracking_delete_marker(track, framenr);
BKE_tracking_marker_delete(track, framenr);
WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
}

2
source/blender/nodes/composite/node_composite_tree.c
View File

@ -222,7 +222,7 @@ static void local_merge(bNodeTree *localtree, bNodeTree *ntree)
copied back to original node */
if (lnode->storage) {
if (lnode->new_node->storage)
BKE_tracking_distortion_destroy(lnode->new_node->storage);
BKE_tracking_distortion_free(lnode->new_node->storage);
lnode->new_node->storage= BKE_tracking_distortion_copy(lnode->storage);
}

8
source/blender/nodes/composite/nodes/node_composite_keyingscreen.c
View File

@ -67,15 +67,15 @@ static void compute_gradient_screen(RenderData *rd, NodeKeyingScreenData *keying
float *rect = screenbuf->rect;
if (keyingscreen_data->tracking_object[0]) {
MovieTrackingObject *object = BKE_tracking_named_object(tracking, keyingscreen_data->tracking_object);
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, keyingscreen_data->tracking_object);
if (!object)
return;
tracksbase = BKE_tracking_object_tracks(tracking, object);
tracksbase = BKE_tracking_object_get_tracks(tracking, object);
}
else
tracksbase = BKE_tracking_get_tracks(tracking);
tracksbase = BKE_tracking_get_active_tracks(tracking);
sites_total = BLI_countlist(tracksbase);
@ -90,7 +90,7 @@ static void compute_gradient_screen(RenderData *rd, NodeKeyingScreenData *keying
i = 0;
while (track) {
VoronoiSite *site = &sites[i];
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, rd->cfra);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, rd->cfra);
ImBuf *pattern_ibuf = BKE_tracking_get_pattern_imbuf(ibuf, track, marker, TRUE, FALSE);
int j;

2
source/blender/nodes/composite/nodes/node_composite_movieclip.c
View File

@ -121,7 +121,7 @@ static void node_composit_exec_movieclip(void *data, bNode *node, bNodeStack **U
if (stab->flag & TRACKING_2D_STABILIZATION) {
float loc[2], scale, angle;
BKE_tracking_stabilization_data(&clip->tracking, rd->cfra, stackbuf->x, stackbuf->y,
BKE_tracking_stabilization_data_get(&clip->tracking, rd->cfra, stackbuf->x, stackbuf->y,
loc, &scale, &angle);
out[1]->vec[0] = loc[0];

4
source/blender/nodes/composite/nodes/node_composite_moviedistortion.c
View File

@ -73,7 +73,7 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
BKE_movieclip_get_size(clip, &user, &width, &height);
if (!node->storage)
node->storage = BKE_tracking_distortion_create();
node->storage = BKE_tracking_distortion_new();
if (node->custom1 == 0)
obuf = BKE_tracking_distortion_exec(node->storage, tracking, ibuf, width, height, overscan, 1);
@ -116,7 +116,7 @@ static const char *label(bNode *node)
static void storage_free(bNode *node)
{
if (node->storage)
BKE_tracking_distortion_destroy(node->storage);
BKE_tracking_distortion_free(node->storage);
node->storage = NULL;
}

2
source/blender/nodes/composite/nodes/node_composite_stabilize2d.c
View File

@ -54,7 +54,7 @@ static void node_composit_exec_stabilize2d(void *data, bNode *node, bNodeStack *
CompBuf *stackbuf;
float loc[2], scale, angle;
BKE_tracking_stabilization_data(&clip->tracking, rd->cfra, cbuf->x, cbuf->y, loc, &scale, &angle);
BKE_tracking_stabilization_data_get(&clip->tracking, rd->cfra, cbuf->x, cbuf->y, loc, &scale, &angle);
stackbuf = node_composit_transform(cbuf, loc[0], loc[1], angle, scale, node->custom1);

2
source/blender/windowmanager/intern/wm_init_exit.c
View File

@ -373,7 +373,7 @@ void WM_exit_ext(bContext *C, const short do_python)
wm_free_reports(C); /* before free_blender! - since the ListBases get freed there */
seq_free_clipboard(); /* sequencer.c */
BKE_tracking_free_clipboard();
BKE_tracking_clipboard_free();
free_blender(); /* blender.c, does entire library and spacetypes */
// free_matcopybuf();