void ED_clip_point_undistorted_pos(SpaceClip *sc, const float co[2], float r_co[2])
{
copy_v2_v2(r_co, co);
if (sc->user.render_flag & MCLIP_PROXY_RENDER_UNDISTORT) {
MovieClip *clip = ED_space_clip_get_clip(sc);
float aspy = 1.0f / clip->tracking.camera.pixel_aspect;
int width, height;
BKE_movieclip_get_size(sc->clip, &sc->user, &width, &height);
r_co[0] *= width;
r_co[1] *= height * aspy;
BKE_tracking_undistort_v2(&clip->tracking, r_co, r_co);
r_co[0] /= width;
r_co[1] /= height * aspy;
}
}
void BKE_movieclip_update_scopes(MovieClip *clip, MovieClipUser *user, MovieClipScopes *scopes)
{
if (scopes->ok)
return;
if (scopes->track_preview) {
IMB_freeImBuf(scopes->track_preview);
scopes->track_preview = NULL;
}
if (scopes->track_search) {
IMB_freeImBuf(scopes->track_search);
scopes->track_search = NULL;
}
scopes->marker = NULL;
scopes->track = NULL;
scopes->track_locked = true;
if (clip) {
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_marker_get(track, framenr);
scopes->marker = marker;
scopes->track = track;
if (marker->flag & MARKER_DISABLED) {
scopes->track_disabled = true;
}
else {
ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
scopes->track_disabled = false;
if (ibuf && (ibuf->rect || ibuf->rect_float)) {
MovieTrackingMarker undist_marker = *marker;
if (user->render_flag & MCLIP_PROXY_RENDER_UNDISTORT) {
int width, height;
float aspy = 1.0f / clip->tracking.camera.pixel_aspect;
BKE_movieclip_get_size(clip, user, &width, &height);
undist_marker.pos[0] *= width;
undist_marker.pos[1] *= height * aspy;
BKE_tracking_undistort_v2(&clip->tracking, undist_marker.pos, undist_marker.pos);
undist_marker.pos[0] /= width;
undist_marker.pos[1] /= height * aspy;
}
scopes->track_search = BKE_tracking_get_search_imbuf(ibuf, track, &undist_marker, true, true);
scopes->undist_marker = undist_marker;
scopes->frame_width = ibuf->x;
scopes->frame_height = ibuf->y;
scopes->use_track_mask = track->flag & TRACK_PREVIEW_ALPHA;
}
IMB_freeImBuf(ibuf);
}
if ((track->flag & TRACK_LOCKED) == 0) {
float pat_min[2], pat_max[2];
scopes->track_locked = false;
/* XXX: would work fine with non-transformed patterns, but would likely fail
* with transformed patterns, but that would be easier to debug when
* we'll have real pattern sampling (at least to test) */
BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
scopes->slide_scale[0] = pat_max[0] - pat_min[0];
scopes->slide_scale[1] = pat_max[1] - pat_min[1];
}
}
}
scopes->framenr = user->framenr;
scopes->ok = true;
}
static void draw_distortion(SpaceClip *sc, ARegion *ar, MovieClip *clip,
int width, int height, float zoomx, float zoomy)
{
float x, y;
const int n = 10;
int i, j, a;
float pos[2], tpos[2], grid[11][11][2];
MovieTracking *tracking = &clip->tracking;
bGPdata *gpd = NULL;
float aspy = 1.0f / tracking->camera.pixel_aspect;
float dx = (float)width / n, dy = (float)height / n * aspy;
float offsx = 0.0f, offsy = 0.0f;
if (!tracking->camera.focal)
return;
if ((sc->flag & SC_SHOW_GRID) == 0 && (sc->flag & SC_MANUAL_CALIBRATION) == 0)
return;
UI_view2d_view_to_region_fl(&ar->v2d, 0.0f, 0.0f, &x, &y);
glPushMatrix();
glTranslatef(x, y, 0);
glScalef(zoomx, zoomy, 0);
glMultMatrixf(sc->stabmat);
glScalef(width, height, 0);
/* grid */
if (sc->flag & SC_SHOW_GRID) {
float val[4][2], idx[4][2];
float min[2], max[2];
for (a = 0; a < 4; a++) {
if (a < 2)
val[a][a % 2] = FLT_MAX;
else
val[a][a % 2] = -FLT_MAX;
}
zero_v2(pos);
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
if (i == 0 || j == 0 || i == n || j == n) {
BKE_tracking_distort_v2(tracking, pos, tpos);
for (a = 0; a < 4; a++) {
int ok;
if (a < 2)
ok = tpos[a % 2] < val[a][a % 2];
else
ok = tpos[a % 2] > val[a][a % 2];
if (ok) {
copy_v2_v2(val[a], tpos);
idx[a][0] = j;
idx[a][1] = i;
}
}
}
pos[0] += dx;
}
pos[0] = 0.0f;
pos[1] += dy;
}
INIT_MINMAX2(min, max);
for (a = 0; a < 4; a++) {
pos[0] = idx[a][0] * dx;
pos[1] = idx[a][1] * dy;
BKE_tracking_undistort_v2(tracking, pos, tpos);
minmax_v2v2_v2(min, max, tpos);
}
copy_v2_v2(pos, min);
dx = (max[0] - min[0]) / n;
dy = (max[1] - min[1]) / n;
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
BKE_tracking_distort_v2(tracking, pos, grid[i][j]);
grid[i][j][0] /= width;
grid[i][j][1] /= height * aspy;
pos[0] += dx;
}
pos[0] = min[0];
pos[1] += dy;
}
glColor3f(1.0f, 0.0f, 0.0f);
for (i = 0; i <= n; i++) {
glBegin(GL_LINE_STRIP);
for (j = 0; j <= n; j++) {
glVertex2fv(grid[i][j]);
}
glEnd();
}
for (j = 0; j <= n; j++) {
glBegin(GL_LINE_STRIP);
for (i = 0; i <= n; i++) {
glVertex2fv(grid[i][j]);
}
glEnd();
}
}
if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) {
MovieTrackingTrack *track = BKE_tracking_track_get_active(&sc->clip->tracking);
if (track) {
int framenr = ED_space_clip_get_clip_frame_number(sc);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
offsx = marker->pos[0];
offsy = marker->pos[1];
gpd = track->gpd;
}
}
else {
gpd = clip->gpd;
}
if (sc->flag & SC_MANUAL_CALIBRATION && gpd) {
bGPDlayer *layer = gpd->layers.first;
while (layer) {
bGPDframe *frame = layer->frames.first;
if (layer->flag & GP_LAYER_HIDE) {
layer = layer->next;
continue;
}
glColor4fv(layer->color);
glLineWidth(layer->thickness);
glPointSize((float)(layer->thickness + 2));
while (frame) {
bGPDstroke *stroke = frame->strokes.first;
while (stroke) {
if (stroke->flag & GP_STROKE_2DSPACE) {
if (stroke->totpoints > 1) {
glBegin(GL_LINE_STRIP);
for (i = 0; i < stroke->totpoints - 1; i++) {
float npos[2], dpos[2], len;
int steps;
pos[0] = (stroke->points[i].x + offsx) * width;
pos[1] = (stroke->points[i].y + offsy) * height * aspy;
npos[0] = (stroke->points[i + 1].x + offsx) * width;
npos[1] = (stroke->points[i + 1].y + offsy) * height * aspy;
len = len_v2v2(pos, npos);
steps = ceil(len / 5.0f);
/* we want to distort only long straight lines */
if (stroke->totpoints == 2) {
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_distort_v2(tracking, pos, tpos);
glVertex2f(tpos[0] / width, tpos[1] / (height * aspy));
add_v2_v2(pos, dpos);
}
}
glEnd();
}
else if (stroke->totpoints == 1) {
glBegin(GL_POINTS);
glVertex2f(stroke->points[0].x + offsx, stroke->points[0].y + offsy);
glEnd();
}
}
stroke = stroke->next;
}
frame = frame->next;
}
layer = layer->next;
}
glLineWidth(1.0f);
glPointSize(1.0f);
}
glPopMatrix();
}
