Differential D10300 Diff 33525 source/blender/editors/transform/transform_convert_tracking.c

Changeset View

Standalone View

source/blender/editors/transform/transform_convert_tracking.c

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines	typedef struct TransDataTracking {
/* tracks transformation from main window */		/* tracks transformation from main window */
int area;		int area;
const float relative, loc;		const float relative, loc;
float soffset[2], srelative[2];		float soffset[2], srelative[2];
float offset[2];		float offset[2];

float (*smarkers)[2];		float (*smarkers)[2];
int markersnr;		int markersnr;
		int framenr;
MovieTrackingMarker *markers;		MovieTrackingMarker *markers;

/* marker transformation from curves editor */		/* marker transformation from curves editor */
float *prev_pos, scale;		float *prev_pos, scale;
short coord;		short coord;

MovieTrackingTrack *track;		MovieTrackingTrack *track;
MovieTrackingPlaneTrack *plane_track;		MovieTrackingPlaneTrack *plane_track;
} TransDataTracking;		} TransDataTracking;

enum transDataTracking_Mode {		enum transDataTracking_Mode {
transDataTracking_ModeTracks = 0,		transDataTracking_ModeTracks = 0,
transDataTracking_ModeCurves = 1,		transDataTracking_ModeCurves = 1,
transDataTracking_ModePlaneTracks = 2,		transDataTracking_ModePlaneTracks = 2,
};		};

/* -------------------------------------------------------------------- */		/* -------------------------------------------------------------------- */
/** \name Clip Editor Motion Tracking Transform Creation		/** \name Clip Editor Motion Tracking Transform Creation
*		*
* \{ */		* \{ */

static void markerToTransDataInit(TransData *td,		typedef struct TransformInitContext {
TransData2D *td2d,		SpaceClip *space_clip;
TransDataTracking *tdt,
		TransInfo *t;
		TransDataContainer *tc;

		/* NOTE: These pointers will be `nullptr` during counting step.
		* This means, that the transformation data initialization functions are to increment
		* `tc->data_len` instead of filling in the transformation data when these pointers are
		* `nullptr`. For simplicity, check the `current.td` against `nullptr`.
		* Do not `tc->data_len` when filling in the transformation data. */
		struct {
		TransData *td;
		TransData2D *td2d;
		TransDataTracking *tdt;
		} current;
		} TransformInitContext;

		static void markerToTransDataInit(TransformInitContext *init_context,
MovieTrackingTrack *track,		MovieTrackingTrack *track,
MovieTrackingMarker *marker,		MovieTrackingMarker *marker,
int area,		int area,
float loc[2],		float loc[2],
const float rel[2],		const float rel[2],
const float off[2],		const float off[2],
const float aspect[2])		const float aspect[2])
{		{
		TransData *td = init_context->current.td;
		TransData2D *td2d = init_context->current.td2d;
		TransDataTracking *tdt = init_context->current.tdt;

		if (td == NULL) {
		init_context->tc->data_len++;
		return;
		}

int anchor = area == TRACK_AREA_POINT && off;		int anchor = area == TRACK_AREA_POINT && off;

		tdt->flag = marker->flag;
		tdt->framenr = marker->framenr;
tdt->mode = transDataTracking_ModeTracks;		tdt->mode = transDataTracking_ModeTracks;

if (anchor) {		if (anchor) {
td2d->loc[0] = rel[0] * aspect[0]; /* hold original location */		td2d->loc[0] = rel[0] * aspect[0]; /* hold original location */
td2d->loc[1] = rel[1] * aspect[1];		td2d->loc[1] = rel[1] * aspect[1];

tdt->loc = loc;		tdt->loc = loc;
td2d->loc2d = loc; /* current location */		td2d->loc2d = loc; /* current location */
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines	static void markerToTransDataInit(TransformInitContext *init_context,
td->ext = NULL;		td->ext = NULL;
td->val = NULL;		td->val = NULL;

td->flag \|= TD_SELECTED;		td->flag \|= TD_SELECTED;
td->dist = 0.0;		td->dist = 0.0;

unit_m3(td->mtx);		unit_m3(td->mtx);
unit_m3(td->smtx);		unit_m3(td->smtx);

		init_context->current.td++;
		init_context->current.td2d++;
		init_context->current.tdt++;
}		}

static void trackToTransData(const int framenr,		static void trackToTransData(TransformInitContext *init_context,
TransData *td,		const int framenr,
TransData2D *td2d,
TransDataTracking *tdt,
MovieTrackingTrack *track,		MovieTrackingTrack *track,
const float aspect[2])		const float aspect[2])
{		{
MovieTrackingMarker *marker = BKE_tracking_marker_ensure(track, framenr);		MovieTrackingMarker *marker = BKE_tracking_marker_ensure(track, framenr);

tdt->flag = marker->flag;		markerToTransDataInit(init_context,
marker->flag &= ~(MARKER_DISABLED \| MARKER_TRACKED);

markerToTransDataInit(td++,
td2d++,
tdt++,
track,		track,
marker,		marker,
TRACK_AREA_POINT,		TRACK_AREA_POINT,
track->offset,		track->offset,
marker->pos,		marker->pos,
track->offset,		track->offset,
aspect);		aspect);

if (track->flag & SELECT) {		if (track->flag & SELECT) {
markerToTransDataInit(		markerToTransDataInit(
td++, td2d++, tdt++, track, marker, TRACK_AREA_POINT, marker->pos, NULL, NULL, aspect);		init_context, track, marker, TRACK_AREA_POINT, marker->pos, NULL, NULL, aspect);
}		}

if (track->pat_flag & SELECT) {		if (track->pat_flag & SELECT) {
int a;		int a;

for (a = 0; a < 4; a++) {		for (a = 0; a < 4; a++) {
markerToTransDataInit(td++,		markerToTransDataInit(init_context,
td2d++,
tdt++,
track,		track,
marker,		marker,
TRACK_AREA_PAT,		TRACK_AREA_PAT,
marker->pattern_corners[a],		marker->pattern_corners[a],
marker->pos,		marker->pos,
NULL,		NULL,
aspect);		aspect);
}		}
}		}

if (track->search_flag & SELECT) {		if (track->search_flag & SELECT) {
markerToTransDataInit(td++,		markerToTransDataInit(init_context,
td2d++,
tdt++,
track,		track,
marker,		marker,
TRACK_AREA_SEARCH,		TRACK_AREA_SEARCH,
marker->search_min,		marker->search_min,
marker->pos,		marker->pos,
NULL,		NULL,
aspect);		aspect);

markerToTransDataInit(td++,		markerToTransDataInit(init_context,
td2d++,
tdt++,
track,		track,
marker,		marker,
TRACK_AREA_SEARCH,		TRACK_AREA_SEARCH,
marker->search_max,		marker->search_max,
marker->pos,		marker->pos,
NULL,		NULL,
aspect);		aspect);
}		}

		if (init_context->current.td != NULL) {
		marker->flag &= ~(MARKER_DISABLED \| MARKER_TRACKED);
		}
}		}

static void planeMarkerToTransDataInit(TransData *td,		static void trackToTransDataIfNeeded(TransformInitContext *init_context,
TransData2D *td2d,		const int framenr,
TransDataTracking *tdt,		MovieTrackingTrack *track,
		const float aspect[2])
		{
		if (!TRACK_VIEW_SELECTED(init_context->space_clip, track)) {
		return;
		}
		if (track->flag & TRACK_LOCKED) {
		return;
		}
		trackToTransData(init_context, framenr, track, aspect);
		}

		static void planeMarkerToTransDataInit(TransformInitContext *init_context,
MovieTrackingPlaneTrack *plane_track,		MovieTrackingPlaneTrack *plane_track,
		MovieTrackingPlaneMarker *plane_marker,
float corner[2],		float corner[2],
const float aspect[2])		const float aspect[2])
{		{
		TransData *td = init_context->current.td;
		TransData2D *td2d = init_context->current.td2d;
		TransDataTracking *tdt = init_context->current.tdt;

		if (td == NULL) {
		init_context->tc->data_len++;
		return;
		}

		tdt->flag = plane_marker->flag;
		tdt->framenr = plane_marker->framenr;
tdt->mode = transDataTracking_ModePlaneTracks;		tdt->mode = transDataTracking_ModePlaneTracks;
tdt->plane_track = plane_track;		tdt->plane_track = plane_track;

td2d->loc[0] = corner[0] * aspect[0]; /* hold original location */		td2d->loc[0] = corner[0] * aspect[0]; /* hold original location */
td2d->loc[1] = corner[1] * aspect[1];		td2d->loc[1] = corner[1] * aspect[1];

td2d->loc2d = corner; /* current location */		td2d->loc2d = corner; /* current location */
td2d->loc[2] = 0.0f;		td2d->loc[2] = 0.0f;
Show All 9 Lines	static void planeMarkerToTransDataInit(TransformInitContext *init_context,
td->ext = NULL;		td->ext = NULL;
td->val = NULL;		td->val = NULL;

td->flag \|= TD_SELECTED;		td->flag \|= TD_SELECTED;
td->dist = 0.0;		td->dist = 0.0;

unit_m3(td->mtx);		unit_m3(td->mtx);
unit_m3(td->smtx);		unit_m3(td->smtx);

		init_context->current.td++;
		init_context->current.td2d++;
		init_context->current.tdt++;
}		}

static void planeTrackToTransData(const int framenr,		static void planeTrackToTransData(TransformInitContext *init_context,
TransData *td,		const int framenr,
TransData2D *td2d,
TransDataTracking *tdt,
MovieTrackingPlaneTrack *plane_track,		MovieTrackingPlaneTrack *plane_track,
const float aspect[2])		const float aspect[2])
{		{
MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_ensure(plane_track, framenr);		MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_ensure(plane_track, framenr);
int i;

tdt->flag = plane_marker->flag;		for (int i = 0; i < 4; i++) {
		planeMarkerToTransDataInit(
		init_context, plane_track, plane_marker, plane_marker->corners[i], aspect);
		}

		if (init_context->current.td != NULL) {
plane_marker->flag &= ~PLANE_MARKER_TRACKED;		plane_marker->flag &= ~PLANE_MARKER_TRACKED;
		}
		}

for (i = 0; i < 4; i++) {		static void planeTrackToTransDataIfNeeded(TransformInitContext *init_context,
planeMarkerToTransDataInit(td++, td2d++, tdt++, plane_track, plane_marker->corners[i], aspect);		const int framenr,
		MovieTrackingPlaneTrack *plane_track,
		const float aspect[2])
		{
		if (!PLANE_TRACK_VIEW_SELECTED(plane_track)) {
		return;
}		}
		planeTrackToTransData(init_context, framenr, plane_track, aspect);
}		}

static void transDataTrackingFree(TransInfo *UNUSED(t),		static void transDataTrackingFree(TransInfo *UNUSED(t),
TransDataContainer *UNUSED(tc),		TransDataContainer *UNUSED(tc),
TransCustomData *custom_data)		TransCustomData *custom_data)
{		{
if (custom_data->data) {		if (custom_data->data) {
TransDataTracking *tdt = custom_data->data;		TransDataTracking *tdt = custom_data->data;
if (tdt->smarkers) {		if (tdt->smarkers) {
MEM_freeN(tdt->smarkers);		MEM_freeN(tdt->smarkers);
}		}

MEM_freeN(tdt);		MEM_freeN(tdt);
custom_data->data = NULL;		custom_data->data = NULL;
}		}
}		}

static void createTransTrackingTracksData(bContext C, TransInfo t)		static void createTransTrackingTracksData(bContext C, TransInfo t)
{		{
TransData *td;		SpaceClip *space_clip = CTX_wm_space_clip(C);
TransData2D *td2d;		MovieClip *clip = ED_space_clip_get_clip(space_clip);
SpaceClip *sc = CTX_wm_space_clip(C);		const ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
MovieClip *clip = ED_space_clip_get_clip(sc);		const ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(&clip->tracking);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);		const int framenr = ED_space_clip_get_clip_frame_number(space_clip);
ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(&clip->tracking);
MovieTrackingTrack *track;
MovieTrackingPlaneTrack *plane_track;
TransDataTracking *tdt;
int framenr = ED_space_clip_get_clip_frame_number(sc);

TransDataContainer *tc = TRANS_DATA_CONTAINER_FIRST_SINGLE(t);		TransDataContainer *tc = TRANS_DATA_CONTAINER_FIRST_SINGLE(t);

/* count */		TransformInitContext init_context = {NULL};
tc->data_len = 0;		init_context.space_clip = space_clip;
		init_context.t = t;
track = tracksbase->first;		init_context.tc = tc;
while (track) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
tc->data_len++; /* offset */

if (track->flag & SELECT) {
tc->data_len++;
}

if (track->pat_flag & SELECT) {		/* Count required tranformation data. */
tc->data_len += 4;
}

if (track->search_flag & SELECT) {		tc->data_len = 0;
tc->data_len += 2;
}
}

track = track->next;		LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
		trackToTransDataIfNeeded(&init_context, framenr, track, t->aspect);
}		}

for (plane_track = plane_tracks_base->first; plane_track; plane_track = plane_track->next) {		LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, plane_tracks_base) {
if (PLANE_TRACK_VIEW_SELECTED(plane_track)) {		planeTrackToTransDataIfNeeded(&init_context, framenr, plane_track, t->aspect);
tc->data_len += 4;
}
}		}

if (tc->data_len == 0) {		if (tc->data_len == 0) {
return;		return;
}		}

td = tc->data = MEM_callocN(tc->data_len * sizeof(TransData), "TransTracking TransData");		tc->data = MEM_callocN(tc->data_len * sizeof(TransData), "TransTracking TransData");
td2d = tc->data_2d = MEM_callocN(tc->data_len * sizeof(TransData2D),		tc->data_2d = MEM_callocN(tc->data_len * sizeof(TransData2D), "TransTracking TransData2D");
"TransTracking TransData2D");		tc->custom.type.data = MEM_callocN(tc->data_len * sizeof(TransDataTracking),
tdt = tc->custom.type.data = MEM_callocN(tc->data_len * sizeof(TransDataTracking),
"TransTracking TransDataTracking");		"TransTracking TransDataTracking");

tc->custom.type.free_cb = transDataTrackingFree;		tc->custom.type.free_cb = transDataTrackingFree;

/* create actual data */		init_context.current.td = tc->data;
track = tracksbase->first;		init_context.current.td2d = tc->data_2d;
while (track) {		init_context.current.tdt = tc->custom.type.data;
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
trackToTransData(framenr, td, td2d, tdt, track, t->aspect);

/* offset */
td++;
td2d++;
tdt++;

if (track->flag & SELECT) {
td++;
td2d++;
tdt++;
}

if (track->pat_flag & SELECT) {
td += 4;
td2d += 4;
tdt += 4;
}

if (track->search_flag & SELECT) {		/* Create actual transformation data. */
td += 2;
td2d += 2;
tdt += 2;
}
}

track = track->next;		LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
		trackToTransDataIfNeeded(&init_context, framenr, track, t->aspect);
}		}

for (plane_track = plane_tracks_base->first; plane_track; plane_track = plane_track->next) {		LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, plane_tracks_base) {
if (PLANE_TRACK_VIEW_SELECTED(plane_track)) {		planeTrackToTransDataIfNeeded(&init_context, framenr, plane_track, t->aspect);
planeTrackToTransData(framenr, td, td2d, tdt, plane_track, t->aspect);
td += 4;
td2d += 4;
tdt += 4;
}
}		}
}		}

static void markerToTransCurveDataInit(TransData *td,		static void markerToTransCurveDataInit(TransData *td,
TransData2D *td2d,		TransData2D *td2d,
TransDataTracking *tdt,		TransDataTracking *tdt,
MovieTrackingTrack *track,		MovieTrackingTrack *track,
MovieTrackingMarker *marker,		MovieTrackingMarker *marker,
▲ Show 20 Lines • Show All 165 Lines • ▼ Show 20 Lines
/* -------------------------------------------------------------------- */		/* -------------------------------------------------------------------- */
/** \name recalc Motion Tracking TransData		/** \name recalc Motion Tracking TransData
*		*
* \{ */		* \{ */

static void cancelTransTracking(TransInfo *t)		static void cancelTransTracking(TransInfo *t)
{		{
TransDataContainer *tc = TRANS_DATA_CONTAINER_FIRST_SINGLE(t);		TransDataContainer *tc = TRANS_DATA_CONTAINER_FIRST_SINGLE(t);
SpaceClip *sc = t->area->spacedata.first;
int i, framenr = ED_space_clip_get_clip_frame_number(sc);
TransDataTracking *tdt_array = tc->custom.type.data;		TransDataTracking *tdt_array = tc->custom.type.data;

i = 0;		int i = 0;
while (i < tc->data_len) {		while (i < tc->data_len) {
TransDataTracking *tdt = &tdt_array[i];		TransDataTracking *tdt = &tdt_array[i];

if (tdt->mode == transDataTracking_ModeTracks) {		if (tdt->mode == transDataTracking_ModeTracks) {
MovieTrackingTrack *track = tdt->track;		MovieTrackingTrack *track = tdt->track;
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);		MovieTrackingMarker *marker = BKE_tracking_marker_get_exact(track, tdt->framenr);

		BLI_assert(marker != NULL);

marker->flag = tdt->flag;		marker->flag = tdt->flag;

if (track->flag & SELECT) {		if (track->flag & SELECT) {
i++;		i++;
}		}

if (track->pat_flag & SELECT) {		if (track->pat_flag & SELECT) {
Show All 19 Lines	else if (tdt->mode == transDataTracking_ModeCurves) {

if (marker->flag & (MARKER_GRAPH_SEL_X \| MARKER_GRAPH_SEL_Y)) {		if (marker->flag & (MARKER_GRAPH_SEL_X \| MARKER_GRAPH_SEL_Y)) {
marker->flag = tdt->flag;		marker->flag = tdt->flag;
}		}
}		}
}		}
else if (tdt->mode == transDataTracking_ModePlaneTracks) {		else if (tdt->mode == transDataTracking_ModePlaneTracks) {
MovieTrackingPlaneTrack *plane_track = tdt->plane_track;		MovieTrackingPlaneTrack *plane_track = tdt->plane_track;
MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track, framenr);		MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get_exact(plane_track,
		tdt->framenr);

		BLI_assert(plane_marker != NULL);

plane_marker->flag = tdt->flag;		plane_marker->flag = tdt->flag;
i += 3;		i += 3;
}		}

i++;		i++;
}		}
}		}
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines