Differential D7930 Diff 25494 source/blender/editors/transform/transform_convert_tracking.c

Changeset View

Standalone View

source/blender/editors/transform/transform_convert_tracking.c

Show All 30 Lines
#include "BKE_movieclip.h"		#include "BKE_movieclip.h"
#include "BKE_report.h"		#include "BKE_report.h"
#include "BKE_tracking.h"		#include "BKE_tracking.h"

#include "ED_clip.h"		#include "ED_clip.h"

#include "transform.h"		#include "transform.h"
#include "transform_convert.h"		#include "transform_convert.h"
		#include "transform_data.h"

typedef struct TransDataTracking {		typedef struct TransDataTracking {
int mode, flag;		int mode, flag;

/* 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];
Show All 17 Lines	enum transDataTracking_Mode {
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,		static void markerToTransDataInit(const TransData *td,
		const int tdi,
TransData2D *td2d,		TransData2D *td2d,
TransDataTracking *tdt,		TransDataTracking *tdt,
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],
Show All 33 Lines	if (rel) {

copy_v2_v2(tdt->srelative, rel);		copy_v2_v2(tdt->srelative, rel);
}		}

if (off) {		if (off) {
copy_v2_v2(tdt->soffset, off);		copy_v2_v2(tdt->soffset, off);
}		}

td->flag = 0;		td->basic[tdi].flag = 0;
td->loc = td2d->loc;		td->basic[tdi].loc = td2d->loc;
copy_v3_v3(td->iloc, td->loc);		copy_v3_v3(td->basic[tdi].iloc, td->basic[tdi].loc);

// copy_v3_v3(td->center, td->loc);
td->flag \|= TD_INDIVIDUAL_SCALE;
td->center[0] = marker->pos[0] * aspect[0];
td->center[1] = marker->pos[1] * aspect[1];

memset(td->axismtx, 0, sizeof(td->axismtx));
td->axismtx[2][2] = 1.0f;

td->ext = NULL;		// copy_v3_v3(td->center[tdi], td->basic[tdi].loc);
td->val = NULL;		td->basic[tdi].flag \|= TD_INDIVIDUAL_SCALE;
		td->center[tdi][0] = marker->pos[0] * aspect[0];
		td->center[tdi][1] = marker->pos[1] * aspect[1];

td->flag \|= TD_SELECTED;		const float axismtx[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}};
td->dist = 0.0;		copy_m3_m3(td->space[tdi].axismtx, axismtx);

unit_m3(td->mtx);		td->special[tdi].val = NULL;
unit_m3(td->smtx);
		td->basic[tdi].flag \|= TD_SELECTED;
		td->prop[tdi].dist = 0.0;

		unit_m3(td->space[tdi].mtx);
		unit_m3(td->space[tdi].smtx);
}		}

static void trackToTransData(const int framenr,		static void trackToTransData(const int framenr,
TransData *td,		const TransData *td,
		int tdi,
TransData2D *td2d,		TransData2D *td2d,
TransDataTracking *tdt,		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;		tdt->flag = marker->flag;
marker->flag &= ~(MARKER_DISABLED \| MARKER_TRACKED);		marker->flag &= ~(MARKER_DISABLED \| MARKER_TRACKED);

markerToTransDataInit(td++,		markerToTransDataInit(td,
		tdi,
td2d++,		td2d++,
tdt++,		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);
		tdi++;

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

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(td,
		tdi,
td2d++,		td2d++,
tdt++,		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);
		tdi++;
}		}
}		}

if (track->search_flag & SELECT) {		if (track->search_flag & SELECT) {
markerToTransDataInit(td++,		markerToTransDataInit(td,
		tdi,
td2d++,		td2d++,
tdt++,		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);
		tdi++;

markerToTransDataInit(td++,		markerToTransDataInit(td,
		tdi,
td2d++,		td2d++,
tdt++,		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);
}		}
}		}

static void planeMarkerToTransDataInit(TransData *td,		static void planeMarkerToTransDataInit(const TransData *td,
		const int tdi,
TransData2D *td2d,		TransData2D *td2d,
TransDataTracking *tdt,		TransDataTracking *tdt,
MovieTrackingPlaneTrack *plane_track,		MovieTrackingPlaneTrack *plane_track,
float corner[2],		float corner[2],
const float aspect[2])		const float aspect[2])
{		{
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;

td->flag = 0;		td->basic[tdi].flag = 0;
td->loc = td2d->loc;		td->basic[tdi].loc = td2d->loc;
copy_v3_v3(td->iloc, td->loc);		copy_v3_v3(td->basic[tdi].iloc, td->basic[tdi].loc);
copy_v3_v3(td->center, td->loc);		copy_v3_v3(td->center[tdi], td->basic[tdi].loc);

memset(td->axismtx, 0, sizeof(td->axismtx));
td->axismtx[2][2] = 1.0f;

td->ext = NULL;		const float axismtx[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}};
td->val = NULL;		copy_m3_m3(td->space[tdi].axismtx, axismtx);

td->flag \|= TD_SELECTED;		td->special[tdi].val = NULL;
td->dist = 0.0;

unit_m3(td->mtx);		td->basic[tdi].flag \|= TD_SELECTED;
unit_m3(td->smtx);		td->prop[tdi].dist = 0.0;

		unit_m3(td->space[tdi].mtx);
		unit_m3(td->space[tdi].smtx);
}		}

static void planeTrackToTransData(const int framenr,		static void planeTrackToTransData(const int framenr,
TransData *td,		const TransData *td,
		int tdi,
TransData2D *td2d,		TransData2D *td2d,
TransDataTracking *tdt,		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;		int i;

tdt->flag = plane_marker->flag;		tdt->flag = plane_marker->flag;
plane_marker->flag &= ~PLANE_MARKER_TRACKED;		plane_marker->flag &= ~PLANE_MARKER_TRACKED;

for (i = 0; i < 4; i++) {		for (i = 0; i < 4; i++) {
planeMarkerToTransDataInit(td++, td2d++, tdt++, plane_track, plane_marker->corners[i], aspect);		planeMarkerToTransDataInit(
		td, tdi, td2d++, tdt++, plane_track, plane_marker->corners[i], aspect);
		tdi++;
}		}
}		}

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;
TransData2D *td2d;		TransData2D *td2d;
SpaceClip *sc = CTX_wm_space_clip(C);		SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(sc);		MovieClip *clip = ED_space_clip_get_clip(sc);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);		ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(&clip->tracking);		ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(&clip->tracking);
MovieTrackingTrack *track;		MovieTrackingTrack *track;
MovieTrackingPlaneTrack *plane_track;		MovieTrackingPlaneTrack *plane_track;
TransDataTracking *tdt;		TransDataTracking *tdt;
Show All 30 Lines	if (PLANE_TRACK_VIEW_SELECTED(plane_track)) {
tc->data_len += 4;		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");		TransData *td = tc->data = transform_data_alloc(tc->data_len, TD_BASIC_COMP);
		int tdi = 0;
td2d = tc->data_2d = MEM_callocN(tc->data_len * sizeof(TransData2D),		td2d = tc->data_2d = MEM_callocN(tc->data_len * sizeof(TransData2D),
"TransTracking TransData2D");		"TransTracking TransData2D");
tdt = 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 */		/* create actual data */
track = tracksbase->first;		track = tracksbase->first;
while (track) {		while (track) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {		if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
trackToTransData(framenr, td, td2d, tdt, track, t->aspect);		trackToTransData(framenr, td, tdi, td2d, tdt, track, t->aspect);

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

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

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

if (track->search_flag & SELECT) {		if (track->search_flag & SELECT) {
td += 2;		tdi += 2;
td2d += 2;		td2d += 2;
tdt += 2;		tdt += 2;
}		}
}		}

track = track->next;		track = track->next;
}		}

for (plane_track = plane_tracks_base->first; plane_track; plane_track = plane_track->next) {		for (plane_track = plane_tracks_base->first; plane_track; plane_track = plane_track->next) {
if (PLANE_TRACK_VIEW_SELECTED(plane_track)) {		if (PLANE_TRACK_VIEW_SELECTED(plane_track)) {
planeTrackToTransData(framenr, td, td2d, tdt, plane_track, t->aspect);		planeTrackToTransData(framenr, td, tdi, td2d, tdt, plane_track, t->aspect);
td += 4;		tdi += 4;
td2d += 4;		td2d += 4;
tdt += 4;		tdt += 4;
}		}
}		}
}		}

static void markerToTransCurveDataInit(TransData *td,		static void markerToTransCurveDataInit(const TransData *td,
		const int tdi,
TransData2D *td2d,		TransData2D *td2d,
TransDataTracking *tdt,		TransDataTracking *tdt,
MovieTrackingTrack *track,		MovieTrackingTrack *track,
MovieTrackingMarker *marker,		MovieTrackingMarker *marker,
MovieTrackingMarker *prev_marker,		MovieTrackingMarker *prev_marker,
short coord,		short coord,
float size)		float size)
{		{
Show All 10 Lines	static void markerToTransCurveDataInit(const TransData *td,

/* calculate values depending on marker's speed */		/* calculate values depending on marker's speed */
td2d->loc[0] = marker->framenr;		td2d->loc[0] = marker->framenr;
td2d->loc[1] = (marker->pos[coord] - prev_marker->pos[coord]) * size / frames_delta;		td2d->loc[1] = (marker->pos[coord] - prev_marker->pos[coord]) * size / frames_delta;
td2d->loc[2] = 0.0f;		td2d->loc[2] = 0.0f;

td2d->loc2d = marker->pos; /* current location */		td2d->loc2d = marker->pos; /* current location */

td->flag = 0;		td->basic[tdi].flag = 0;
td->loc = td2d->loc;		td->basic[tdi].loc = td2d->loc;
copy_v3_v3(td->center, td->loc);		copy_v3_v3(td->center[tdi], td->basic[tdi].loc);
copy_v3_v3(td->iloc, td->loc);		copy_v3_v3(td->basic[tdi].iloc, td->basic[tdi].loc);

memset(td->axismtx, 0, sizeof(td->axismtx));		const float axismtx[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}};
td->axismtx[2][2] = 1.0f;		copy_m3_m3(td->space[tdi].axismtx, axismtx);

td->ext = NULL;		td->special[tdi].val = NULL;
td->val = NULL;

td->flag \|= TD_SELECTED;		td->basic[tdi].flag \|= TD_SELECTED;
td->dist = 0.0;		td->prop[tdi].dist = 0.0;

unit_m3(td->mtx);		unit_m3(td->space[tdi].mtx);
unit_m3(td->smtx);		unit_m3(td->space[tdi].smtx);
}		}

static void createTransTrackingCurvesData(bContext C, TransInfo t)		static void createTransTrackingCurvesData(bContext C, TransInfo t)
{		{
TransData *td;
TransData2D *td2d;		TransData2D *td2d;
SpaceClip *sc = CTX_wm_space_clip(C);		SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(sc);		MovieClip *clip = ED_space_clip_get_clip(sc);
ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);		ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
MovieTrackingTrack *track;		MovieTrackingTrack *track;
MovieTrackingMarker marker, prev_marker;		MovieTrackingMarker marker, prev_marker;
TransDataTracking *tdt;		TransDataTracking *tdt;
int i, width, height;		int i, width, height;
Show All 32 Lines	while (track) {

track = track->next;		track = track->next;
}		}

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

td = tc->data = MEM_callocN(tc->data_len * sizeof(TransData), "TransTracking TransData");		TransData *td = tc->data = transform_data_alloc(tc->data_len, TD_BASIC_COMP);
		int tdi = 0;
td2d = tc->data_2d = MEM_callocN(tc->data_len * sizeof(TransData2D),		td2d = tc->data_2d = MEM_callocN(tc->data_len * sizeof(TransData2D),
"TransTracking TransData2D");		"TransTracking TransData2D");
tc->custom.type.data = tdt = MEM_callocN(tc->data_len * sizeof(TransDataTracking),		tc->custom.type.data = tdt = 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 */		/* create actual data */
track = tracksbase->first;		track = tracksbase->first;
while (track) {		while (track) {
if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {		if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
for (i = 1; i < track->markersnr; i++) {		for (i = 1; i < track->markersnr; i++) {
marker = &track->markers[i];		marker = &track->markers[i];
prev_marker = &track->markers[i - 1];		prev_marker = &track->markers[i - 1];

if ((marker->flag & MARKER_DISABLED) \|\| (prev_marker->flag & MARKER_DISABLED)) {		if ((marker->flag & MARKER_DISABLED) \|\| (prev_marker->flag & MARKER_DISABLED)) {
continue;		continue;
}		}

if (marker->flag & MARKER_GRAPH_SEL_X) {		if (marker->flag & MARKER_GRAPH_SEL_X) {
markerToTransCurveDataInit(		markerToTransCurveDataInit(
td, td2d, tdt, track, marker, &track->markers[i - 1], 0, width);		td, tdi, td2d, tdt, track, marker, &track->markers[i - 1], 0, width);
td += 1;		tdi++;
td2d += 1;		td2d += 1;
tdt += 1;		tdt += 1;
}		}

if (marker->flag & MARKER_GRAPH_SEL_Y) {		if (marker->flag & MARKER_GRAPH_SEL_Y) {
markerToTransCurveDataInit(		markerToTransCurveDataInit(
td, td2d, tdt, track, marker, &track->markers[i - 1], 1, height);		td, tdi, td2d, tdt, track, marker, &track->markers[i - 1], 1, height);

td += 1;		tdi++;
td2d += 1;		td2d += 1;
tdt += 1;		tdt += 1;
}		}
}		}
}		}

track = track->next;		track = track->next;
}		}
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines

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

void flushTransTracking(TransInfo *t)		void flushTransTracking(TransInfo *t)
{		{
TransData *td;
TransData2D *td2d;		TransData2D *td2d;
TransDataTracking *tdt;		TransDataTracking *tdt;
int a;		int a;

if (t->state == TRANS_CANCEL) {		if (t->state == TRANS_CANCEL) {
cancelTransTracking(t);		cancelTransTracking(t);
}		}

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

/* flush to 2d vector from internally used 3d vector */		/* flush to 2d vector from internally used 3d vector */
for (a = 0, td = tc->data, td2d = tc->data_2d, tdt = tc->custom.type.data; a < tc->data_len;		for (a = 0, td2d = tc->data_2d, tdt = tc->custom.type.data; a < tc->data_len;
a++, td2d++, td++, tdt++) {		a++, td2d++, tdt++) {
if (tdt->mode == transDataTracking_ModeTracks) {		if (tdt->mode == transDataTracking_ModeTracks) {
float loc2d[2];		float loc2d[2];

if (t->mode == TFM_ROTATION && tdt->area == TRACK_AREA_SEARCH) {		if (t->mode == TFM_ROTATION && tdt->area == TRACK_AREA_SEARCH) {
continue;		continue;
}		}

loc2d[0] = td2d->loc[0] / t->aspect[0];		loc2d[0] = td2d->loc[0] / t->aspect[0];
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines