Planar tracking support for motion tracking

===========================================

Major list of changes done in tomato branch:

- Add a planar tracking implementation to libmv
  This adds a new planar tracking implementation to libmv. The
  tracker is based on Ceres[1], the new nonlinear minimizer that
  myself and Sameer released from Google as open source. Since
  the motion model is more involved, the interface is
  different than the RegionTracker interface used previously
  in Blender.

  The start of a C API in libmv-capi.{cpp,h} is also included.

- Migrate from pat_{min,max} for markers to 4 corners representation

  Convert markers in the movie clip editor / 2D tracker from using
  pat_min and pat_max notation to using the a more general, 4-corner
  representation.

  There is still considerable porting work to do; in particular
  sliding from preview widget does not work correct for rotated
  markers.

  All other areas should be ported to new representation:

  * Added support of sliding individual corners. LMB slide + Ctrl
    would scale the whole pattern
  * S would scale the whole marker, S-S would scale pattern only
  * Added support of marker's rotation which is currently rotates
    only patterns around their centers or all markers around median,

    Rotation or other non-translation/scaling transformation of search
    area doesn't make sense.

  * Track Preview widget would display transformed pattern which
    libmv actually operates with.

- "Efficient Second-order Minimization" for the planar tracker

  This implements the "Efficient Second-order Minimization"
  scheme, as supported by the existing translation tracker.
  This increases the amount of per-iteration work, but
  decreases the number of iterations required to converge and
  also increases the size of the basin of attraction for the
  optimization.

- Remove the use of the legacy RegionTracker API from Blender,
  and replaces it with the new TrackRegion API. This also
  adds several features to the planar tracker in libmv:

  * Do a brute-force initialization of tracking similar to "Hybrid"
    mode in the stable release, but using all floats. This is slower
    but more accurate. It is still necessary to evaluate if the
    performance loss is worth it. In particular, this change is
    necessary to support high bit depth imagery.

  * Add support for masks over the search window. This is a step
    towards supporting user-defined tracker masks. The tracker masks
    will make it easy for users to make a mask for e.g. a ball.

    Not exposed into interface yet/

  * Add Pearson product moment correlation coefficient checking (aka
    "Correlation" in the UI. This causes tracking failure if the
    tracked patch is not linearly related to the template.

  * Add support for warping a few points in addition to the supplied
    points. This is useful because the tracking code deliberately
    does not expose the underlying warp representation. Instead,
    warps are specified in an aparametric way via the correspondences.

- Replace the old style tracker configuration panel with the
  new planar tracking panel. From a users perspective, this means:

  * The old "tracking algorithm" picker is gone. There is only 1
    algorithm now. We may revisit this later, but I would much
    prefer to have only 1 algorithm. So far no optimization work
    has been done so the speed is not there yet.

  * There is now a dropdown to select the motion model. Choices:

        * Translation
        * Translation, rotation
        * Translation, scale
        * Translation, rotation, scale
        * Affine
        * Perspective

  * The old "Hybrid" mode is gone; instead there is a toggle to
    enable or disable translation-only tracker initialization. This
    is the equivalent of the hyrbid mode before, but rewritten to work
    with the new planar tracking modes.

  * The pyramid levels setting is gone. At a future date, the planar
    tracker will decide to use pyramids or not automatically. The
    pyramid setting was ultimately a mistake; with the brute force
    initialization it is unnecessary.

- Add light-normalized tracking

  Added the ability to normalize patterns by their average value while
  tracking, to make them invariant to global illumination changes.

Additional details could be found at wiki page [2]

  [1] http://code.google.com/p/ceres-solver
  [2] http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.64/Motion_Tracker

9 files changed, 558 insertions, 345 deletions

diff --git a/source/blender/editors/interface/interface_draw.c b/source/blender/editors/interface/interface_draw.c
index f6339d4456f..f368e7cf4c7 100644
--- a/source/blender/editors/interface/interface_draw.c
+++ b/source/blender/editors/interface/interface_draw.c
@@ -43,6 +43,7 @@
 
 #include "BKE_colortools.h"
 #include "BKE_texture.h"
+#include "BKE_tracking.h"
 
 
 #include "IMB_imbuf.h"
@@ -1507,36 +1508,10 @@ void ui_draw_but_CURVE(ARegion *ar, uiBut *but, uiWidgetColors *wcol, rcti *rect
 	fdrawbox(rect->xmin, rect->ymin, rect->xmax, rect->ymax);
 }
 
-static ImBuf *scale_trackpreview_ibuf(ImBuf *ibuf, float track_pos[2], int width, float height, int margin)
-{
-	ImBuf *scaleibuf;
-	const float scalex = ((float)ibuf->x - 2 * margin) / width;
-	const float scaley = ((float)ibuf->y - 2 * margin) / height;
-	/* NOTE: 1.0f = 0.5f for integer coordinate coorrection (center of pixel vs. left bottom corner of bixel)
-	 *       and 0.5f for centering image in preview (cross is draving at exact center of widget so image
-	 *       should be shifted by half of pixel for correct centering) - sergey */
-	float off_x = (int)track_pos[0] - track_pos[0] + 1.0f;
-	float off_y = (int)track_pos[1] - track_pos[1] + 1.0f;
-	int x, y;
-
-	scaleibuf = IMB_allocImBuf(width, height, 32, IB_rect);
-
-	for (y = 0; y < height; y++) {
-		for (x = 0; x < width; x++) {
-			float src_x = scalex * (x) + margin - off_x;
-			float src_y = scaley * (y) + margin - off_y;
-
-			bicubic_interpolation(ibuf, scaleibuf, src_x, src_y, x, y);
-		}
-	}
-
-	return scaleibuf;
-}
-
 void ui_draw_but_TRACKPREVIEW(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *recti)
 {
 	rctf rect;
-	int ok = 0;
+	int ok = 0, width, height;
 	GLint scissor[4];
 	MovieClipScopes *scopes = (MovieClipScopes *)but->poin;
 
@@ -1545,6 +1520,9 @@ void ui_draw_but_TRACKPREVIEW(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wc
 	rect.ymin = (float)recti->ymin + SCOPE_RESIZE_PAD + 2;
 	rect.ymax = (float)recti->ymax - 1;
 
+	width = rect.xmax - rect.xmin + 1;
+	height = rect.ymax - rect.ymin;
+
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
@@ -1562,40 +1540,53 @@ void ui_draw_but_TRACKPREVIEW(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wc
 
 		ok = 1;
 	}
-	else if (scopes->track_preview) {
-		/* additional margin around image */
-		/* NOTE: should be kept in sync with value from BKE_movieclip_update_scopes */
-		const int margin = 3;
-		float zoomx, zoomy, track_pos[2], off_x, off_y;
-		int a, width, height;
+	else if ((scopes->track_search) &&
+	         ((!scopes->track_preview) ||
+	         (scopes->track_preview->x != width || scopes->track_preview->y != height)))
+	{
+		ImBuf *tmpibuf;
+
+		if (scopes->track_preview)
+			IMB_freeImBuf(scopes->track_preview);
+
+		tmpibuf = BKE_tracking_sample_pattern_imbuf(scopes->frame_width, scopes->frame_height,
+		                                            scopes->track_search, &scopes->undist_marker,
+		                                            width, height, scopes->track_pos);
+
+		if (tmpibuf->rect_float)
+			IMB_rect_from_float(tmpibuf);
+
+		// XXX: for debug only
+		// tmpibuf->ftype = PNG;
+		// IMB_saveiff(tmpibuf, "sample.png", IB_rect);
+
+		if (tmpibuf->rect)
+			scopes->track_preview = tmpibuf;
+		else
+			IMB_freeImBuf(tmpibuf);
+	}
+
+	if (!ok && scopes->track_preview) {
+		float track_pos[2];
+		int a;
 		ImBuf *drawibuf;
 
 		glPushMatrix();
 
-		track_pos[0] = scopes->track_pos[0] - margin;
-		track_pos[1] = scopes->track_pos[1] - margin;
+		track_pos[0] = scopes->track_pos[0];
+		track_pos[1] = scopes->track_pos[1];
 
 		/* draw content of pattern area */
 		glScissor(ar->winrct.xmin + rect.xmin, ar->winrct.ymin + rect.ymin, scissor[2], scissor[3]);
 
-		width = rect.xmax - rect.xmin + 1;
-		height = rect.ymax - rect.ymin;
-
 		if (width > 0 && height > 0) {
-			zoomx = (float)width / (scopes->track_preview->x - 2 * margin);
-			zoomy = (float)height / (scopes->track_preview->y - 2 * margin);
-
-			off_x = ((int)track_pos[0] - track_pos[0] + 0.5f) * zoomx;
-			off_y = ((int)track_pos[1] - track_pos[1] + 0.5f) * zoomy;
-
-			drawibuf = scale_trackpreview_ibuf(scopes->track_preview, track_pos, width, height, margin);
+			drawibuf = scopes->track_preview;
 
 			glaDrawPixelsSafe(rect.xmin, rect.ymin + 1, drawibuf->x, drawibuf->y,
 			                  drawibuf->x, GL_RGBA, GL_UNSIGNED_BYTE, drawibuf->rect);
-			IMB_freeImBuf(drawibuf);
 
 			/* draw cross for pizel position */
-			glTranslatef(off_x + rect.xmin + track_pos[0] * zoomx, off_y + rect.ymin + track_pos[1] * zoomy, 0.f);
+			glTranslatef(rect.xmin + track_pos[0], rect.ymin + track_pos[1], 0.f);
 			glScissor(ar->winrct.xmin + rect.xmin,
 			          ar->winrct.ymin + rect.ymin,
 			          rect.xmax - rect.xmin,
diff --git a/source/blender/editors/space_clip/clip_buttons.c b/source/blender/editors/space_clip/clip_buttons.c
index e69e1f15b6e..ca2ae6e8461 100644
--- a/source/blender/editors/space_clip/clip_buttons.c
+++ b/source/blender/editors/space_clip/clip_buttons.c
@@ -186,12 +186,13 @@ typedef struct {
 	MovieClip *clip;
 	MovieClipUser *user;						/* user of clip */
 	MovieTrackingTrack *track;
+	MovieTrackingMarker *marker;
 
 	int framenr;								/* current frame number */
 	float marker_pos[2];						/* position of marker in pixel coords */
-	float track_pat[2];							/* position and dimensions of marker pattern in pixel coords */
+	float marker_pat[2];							/* position and dimensions of marker pattern in pixel coords */
 	float track_offset[2];						/* offset of "parenting" point */
-	float track_search_pos[2], track_search[2];	/* position and dimensions of marker search in pixel coords */
+	float marker_search_pos[2], marker_search[2];	/* position and dimensions of marker search in pixel coords */
 	int marker_flag;							/* marker's flags */
 } MarkerUpdateCb;
 
@@ -238,60 +239,63 @@ static void marker_block_handler(bContext *C, void *arg_cb, int event)
 		ok = TRUE;
 	}
 	else if (event == B_MARKER_PAT_DIM) {
-		float dim[2], pat_dim[2];
+		float dim[2], pat_dim[2], pat_min[2], pat_max[2];
+		float scale_x, scale_y;
+		int a;
 
-		sub_v2_v2v2(pat_dim, cb->track->pat_max, cb->track->pat_min);
+		BKE_tracking_marker_pattern_minmax(cb->marker, pat_min, pat_max);
 
-		dim[0] = cb->track_pat[0] / width;
-		dim[1] = cb->track_pat[1] / height;
+		sub_v2_v2v2(pat_dim, pat_max, pat_min);
 
-		sub_v2_v2(dim, pat_dim);
-		mul_v2_fl(dim, 0.5f);
+		dim[0] = cb->marker_pat[0] / width;
+		dim[1] = cb->marker_pat[1] / height;
 
-		cb->track->pat_min[0] -= dim[0];
-		cb->track->pat_min[1] -= dim[1];
+		scale_x = dim[0] / pat_dim[0];
+		scale_y = dim[1] / pat_dim[1];
 
-		cb->track->pat_max[0] += dim[0];
-		cb->track->pat_max[1] += dim[1];
+		for (a = 0; a < 4; a++) {
+			cb->marker->pattern_corners[a][0] *= scale_x;
+			cb->marker->pattern_corners[a][1] *= scale_y;
+		}
 
-		BKE_tracking_clamp_track(cb->track, CLAMP_PAT_DIM);
+		BKE_tracking_clamp_marker(cb->marker, CLAMP_PAT_DIM);
 
 		ok = TRUE;
 	}
 	else if (event == B_MARKER_SEARCH_POS) {
 		float delta[2], side[2];
 
-		sub_v2_v2v2(side, cb->track->search_max, cb->track->search_min);
+		sub_v2_v2v2(side, cb->marker->search_max, cb->marker->search_min);
 		mul_v2_fl(side, 0.5f);
 
-		delta[0] = cb->track_search_pos[0] / width;
-		delta[1] = cb->track_search_pos[1] / height;
+		delta[0] = cb->marker_search_pos[0] / width;
+		delta[1] = cb->marker_search_pos[1] / height;
 
-		sub_v2_v2v2(cb->track->search_min, delta, side);
-		add_v2_v2v2(cb->track->search_max, delta, side);
+		sub_v2_v2v2(cb->marker->search_min, delta, side);
+		add_v2_v2v2(cb->marker->search_max, delta, side);
 
-		BKE_tracking_clamp_track(cb->track, CLAMP_SEARCH_POS);
+		BKE_tracking_clamp_marker(cb->marker, CLAMP_SEARCH_POS);
 
 		ok = TRUE;
 	}
 	else if (event == B_MARKER_SEARCH_DIM) {
 		float dim[2], search_dim[2];
 
-		sub_v2_v2v2(search_dim, cb->track->search_max, cb->track->search_min);
+		sub_v2_v2v2(search_dim, cb->marker->search_max, cb->marker->search_min);
 
-		dim[0] = cb->track_search[0] / width;
-		dim[1] = cb->track_search[1] / height;
+		dim[0] = cb->marker_search[0] / width;
+		dim[1] = cb->marker_search[1] / height;
 
 		sub_v2_v2(dim, search_dim);
 		mul_v2_fl(dim, 0.5f);
 
-		cb->track->search_min[0] -= dim[0];
-		cb->track->search_min[1] -= dim[1];
+		cb->marker->search_min[0] -= dim[0];
+		cb->marker->search_min[1] -= dim[1];
 
-		cb->track->search_max[0] += dim[0];
-		cb->track->search_max[1] += dim[1];
+		cb->marker->search_max[0] += dim[0];
+		cb->marker->search_max[1] += dim[1];
 
-		BKE_tracking_clamp_track(cb->track, CLAMP_SEARCH_DIM);
+		BKE_tracking_clamp_marker(cb->marker, CLAMP_SEARCH_DIM);
 
 		ok = TRUE;
 	}
@@ -337,6 +341,7 @@ void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, P
 	MovieTrackingMarker *marker;
 	MarkerUpdateCb *cb;
 	const char *tip;
+	float pat_min[2], pat_max[2];
 
 	if (!ptr->data)
 		return;
@@ -366,6 +371,7 @@ void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, P
 	cb->clip = clip;
 	cb->user = user;
 	cb->track = track;
+	cb->marker = marker;
 	cb->marker_flag = marker->flag;
 	cb->framenr = user->framenr;
 
@@ -383,7 +389,7 @@ void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, P
 	}
 	else {
 		int width, height, step, digits;
-		float pat_dim[2], pat_pos[2], search_dim[2], search_pos[2];
+		float pat_dim[2], search_dim[2], search_pos[2];
 		uiLayout *col;
 
 		BKE_movieclip_get_size(clip, user, &width, &height);
@@ -399,19 +405,18 @@ void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, P
 		step = 100;
 		digits = 2;
 
-		sub_v2_v2v2(pat_dim, track->pat_max, track->pat_min);
-		sub_v2_v2v2(search_dim, track->search_max, track->search_min);
+		BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
 
-		add_v2_v2v2(search_pos, track->search_max, track->search_min);
-		mul_v2_fl(search_pos, 0.5);
+		sub_v2_v2v2(pat_dim, pat_max, pat_min);
+		sub_v2_v2v2(search_dim, marker->search_max, marker->search_min);
 
-		add_v2_v2v2(pat_pos, track->pat_max, track->pat_min);
-		mul_v2_fl(pat_pos, 0.5);
+		add_v2_v2v2(search_pos, marker->search_max, marker->search_min);
+		mul_v2_fl(search_pos, 0.5);
 
 		to_pixel_space(cb->marker_pos, marker->pos, width, height);
-		to_pixel_space(cb->track_pat, pat_dim, width, height);
-		to_pixel_space(cb->track_search, search_dim, width, height);
-		to_pixel_space(cb->track_search_pos, search_pos, width, height);
+		to_pixel_space(cb->marker_pat, pat_dim, width, height);
+		to_pixel_space(cb->marker_search, search_dim, width, height);
+		to_pixel_space(cb->marker_search_pos, search_pos, width, height);
 		to_pixel_space(cb->track_offset, track->offset, width, height);
 
 		cb->marker_flag = marker->flag;
@@ -447,19 +452,19 @@ void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, P
 			-10*height, 10.0*height, step, digits, "Y-offset to parenting point");
 
 		uiDefBut(block, LABEL, 0, "Pattern Area:", 0, 114, 300, 19, NULL, 0, 0, 0, 0, "");
-		uiDefButF(block, NUM, B_MARKER_PAT_DIM, "Width:", 10, 95, 300, 19, &cb->track_pat[0], 3.0f,
+		uiDefButF(block, NUM, B_MARKER_PAT_DIM, "Width:", 10, 95, 300, 19, &cb->marker_pat[0], 3.0f,
 			10.0*width, step, digits, "Width of marker's pattern in screen coordinates");
-		uiDefButF(block, NUM, B_MARKER_PAT_DIM, "Height:", 10, 76, 300, 19, &cb->track_pat[1], 3.0f,
+		uiDefButF(block, NUM, B_MARKER_PAT_DIM, "Height:", 10, 76, 300, 19, &cb->marker_pat[1], 3.0f,
 			10.0*height, step, digits, "Height of marker's pattern in screen coordinates");
 
 		uiDefBut(block, LABEL, 0, "Search Area:", 0, 57, 300, 19, NULL, 0, 0, 0, 0, "");
-		uiDefButF(block, NUM, B_MARKER_SEARCH_POS, "X:", 10, 38, 145, 19, &cb->track_search_pos[0],
+		uiDefButF(block, NUM, B_MARKER_SEARCH_POS, "X:", 10, 38, 145, 19, &cb->marker_search_pos[0],
 			-width, width, step, digits, "X-position of search at frame relative to marker's position");
-		uiDefButF(block, NUM, B_MARKER_SEARCH_POS, "Y:", 165, 38, 145, 19, &cb->track_search_pos[1],
+		uiDefButF(block, NUM, B_MARKER_SEARCH_POS, "Y:", 165, 38, 145, 19, &cb->marker_search_pos[1],
 			-height, height, step, digits, "X-position of search at frame relative to marker's position");
-		uiDefButF(block, NUM, B_MARKER_SEARCH_DIM, "Width:", 10, 19, 300, 19, &cb->track_search[0], 3.0f,
+		uiDefButF(block, NUM, B_MARKER_SEARCH_DIM, "Width:", 10, 19, 300, 19, &cb->marker_search[0], 3.0f,
 			10.0*width, step, digits, "Width of marker's search in screen soordinates");
-		uiDefButF(block, NUM, B_MARKER_SEARCH_DIM, "Height:", 10, 0, 300, 19, &cb->track_search[1], 3.0f,
+		uiDefButF(block, NUM, B_MARKER_SEARCH_DIM, "Height:", 10, 0, 300, 19, &cb->marker_search[1], 3.0f,
 			10.0*height, step, digits, "Height of marker's search in screen soordinates");
 
 		uiBlockEndAlign(block);
diff --git a/source/blender/editors/space_clip/clip_draw.c b/source/blender/editors/space_clip/clip_draw.c
index 93a32fb06fc..9332413b33b 100644
--- a/source/blender/editors/space_clip/clip_draw.c
+++ b/source/blender/editors/space_clip/clip_draw.c
@@ -456,14 +456,17 @@ static void draw_marker_outline(SpaceClip *sc, MovieTrackingTrack *track, MovieT
 
 	if ((marker->flag & MARKER_DISABLED) == 0) {
 		float pos[2];
-		rctf r;
+		float p[2];
 
-		BLI_init_rctf(&r, track->pat_min[0], track->pat_max[0], track->pat_min[1], track->pat_max[1]);
 		add_v2_v2v2(pos, marker->pos, track->offset);
 
 		ED_clip_point_undistorted_pos(sc, pos, pos);
 
-		if (BLI_in_rctf(&r, pos[0] - marker_pos[0], pos[1] - marker_pos[1])) {
+		sub_v2_v2v2(p, pos, marker_pos);
+
+		if (isect_point_quad_v2(p, marker->pattern_corners[0], marker->pattern_corners[1],
+		                        marker->pattern_corners[2], marker->pattern_corners[3]))
+		{
 			if (tiny) glPointSize(3.0f);
 			else glPointSize(4.0f);
 			glBegin(GL_POINTS);
@@ -499,10 +502,10 @@ static void draw_marker_outline(SpaceClip *sc, MovieTrackingTrack *track, MovieT
 
 	if (sc->flag & SC_SHOW_MARKER_PATTERN) {
 		glBegin(GL_LINE_LOOP);
-			glVertex2f(track->pat_min[0], track->pat_min[1]);
-			glVertex2f(track->pat_max[0], track->pat_min[1]);
-			glVertex2f(track->pat_max[0], track->pat_max[1]);
-			glVertex2f(track->pat_min[0], track->pat_max[1]);
+			glVertex2fv(marker->pattern_corners[0]);
+			glVertex2fv(marker->pattern_corners[1]);
+			glVertex2fv(marker->pattern_corners[2]);
+			glVertex2fv(marker->pattern_corners[3]);
 		glEnd();
 	}
 
@@ -510,10 +513,10 @@ static void draw_marker_outline(SpaceClip *sc, MovieTrackingTrack *track, MovieT
 	              ((marker->flag & MARKER_DISABLED) == 0 || (sc->flag & SC_SHOW_MARKER_PATTERN) == 0);
 	if (sc->flag & SC_SHOW_MARKER_SEARCH && show_search) {
 		glBegin(GL_LINE_LOOP);
-			glVertex2f(track->search_min[0], track->search_min[1]);
-			glVertex2f(track->search_max[0], track->search_min[1]);
-			glVertex2f(track->search_max[0], track->search_max[1]);
-			glVertex2f(track->search_min[0], track->search_max[1]);
+			glVertex2f(marker->search_min[0], marker->search_min[1]);
+			glVertex2f(marker->search_max[0], marker->search_min[1]);
+			glVertex2f(marker->search_max[0], marker->search_max[1]);
+			glVertex2f(marker->search_min[0], marker->search_max[1]);
 		glEnd();
 	}
 	glPopMatrix();
@@ -556,8 +559,7 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 
 	/* marker position and offset position */
 	if ((track->flag & SELECT) == sel && (marker->flag & MARKER_DISABLED) == 0) {
-		float pos[2];
-		rctf r;
+		float pos[2], p[2];
 
 		if (track->flag & TRACK_LOCKED) {
 			if (act)
@@ -574,11 +576,14 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 				glColor3fv(col);
 		}
 
-		BLI_init_rctf(&r, track->pat_min[0], track->pat_max[0], track->pat_min[1], track->pat_max[1]);
 		add_v2_v2v2(pos, marker->pos, track->offset);
 		ED_clip_point_undistorted_pos(sc, pos, pos);
 
-		if (BLI_in_rctf(&r, pos[0] - marker_pos[0], pos[1] - marker_pos[1])) {
+		sub_v2_v2v2(p, pos, marker_pos);
+
+		if (isect_point_quad_v2(p, marker->pattern_corners[0], marker->pattern_corners[1],
+		                        marker->pattern_corners[2], marker->pattern_corners[3]))
+		{
 			if (!tiny)
 				glPointSize(2.0f);
 
@@ -651,10 +656,10 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 		}
 
 		glBegin(GL_LINE_LOOP);
-			glVertex2f(track->pat_min[0], track->pat_min[1]);
-			glVertex2f(track->pat_max[0], track->pat_min[1]);
-			glVertex2f(track->pat_max[0], track->pat_max[1]);
-			glVertex2f(track->pat_min[0], track->pat_max[1]);
+			glVertex2fv(marker->pattern_corners[0]);
+			glVertex2fv(marker->pattern_corners[1]);
+			glVertex2fv(marker->pattern_corners[2]);
+			glVertex2fv(marker->pattern_corners[3]);
 		glEnd();
 	}
 
@@ -684,70 +689,82 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 		}
 
 		glBegin(GL_LINE_LOOP);
-			glVertex2f(track->search_min[0], track->search_min[1]);
-			glVertex2f(track->search_max[0], track->search_min[1]);
-			glVertex2f(track->search_max[0], track->search_max[1]);
-			glVertex2f(track->search_min[0], track->search_max[1]);
+			glVertex2f(marker->search_min[0], marker->search_min[1]);
+			glVertex2f(marker->search_max[0], marker->search_min[1]);
+			glVertex2f(marker->search_max[0], marker->search_max[1]);
+			glVertex2f(marker->search_min[0], marker->search_max[1]);
 		glEnd();
 	}
 
-	/* pyramid */
-	if (sel && TRACK_VIEW_SELECTED(sc, track) &&
-	    (track->tracker == TRACKER_KLT) &&
-		(marker->flag & MARKER_DISABLED) == 0)
-	{
-		if (track->flag & TRACK_LOCKED) {
-			if (act)
-				UI_ThemeColor(TH_ACT_MARKER);
-			else if (track->pat_flag & SELECT)
-				UI_ThemeColorShade(TH_LOCK_MARKER, 64);
-			else UI_ThemeColor(TH_LOCK_MARKER);
-		}
-		else if (marker->flag & MARKER_DISABLED) {
-			if (act)
-				UI_ThemeColor(TH_ACT_MARKER);
-			else if (track->pat_flag & SELECT)
-				UI_ThemeColorShade(TH_DIS_MARKER, 128);
-			else UI_ThemeColor(TH_DIS_MARKER);
-		}
-		else {
-			if (track->pat_flag & SELECT)
-				glColor3fv(scol);
-			else
-				glColor3fv(col);
-		}
-
-		{
-			int i = 0;
-			glPushMatrix();
-			glEnable(GL_LINE_STIPPLE);
-			for (i = 1; i < track->pyramid_levels; ++i) {
-				glScalef(2.0f, 2.0f, 1.0);
-			}
-			/* only draw a pattern for the coarsest level */
-			glBegin(GL_LINE_LOOP);
-				glVertex2f(track->pat_min[0], track->pat_min[1]);
-				glVertex2f(track->pat_max[0], track->pat_min[1]);
-				glVertex2f(track->pat_max[0], track->pat_max[1]);
-				glVertex2f(track->pat_min[0], track->pat_max[1]);
-			glEnd();
-			glDisable(GL_LINE_STIPPLE);
-			glPopMatrix();
-		}
-	}
-
 	if (tiny)
 		glDisable(GL_LINE_STIPPLE);
 
 	glPopMatrix();
 }
 
+static float get_shortest_pattern_side(MovieTrackingMarker *marker)
+{
+	int i, next;
+	float len = FLT_MAX;
+
+	for (i = 0; i < 4; i++) {
+		float cur_len;
+
+		next = (i + 1) % 4;
+
+		cur_len = len_v2v2(marker->pattern_corners[i], marker->pattern_corners[next]);
+
+		len = MIN2(cur_len, len);
+	}
+
+	return len;
+}
+
+static void draw_marker_slide_square(float x, float y, float dx, float dy, int outline, float px[2])
+{
+	float tdx, tdy;
+
+	tdx = dx;
+	tdy = dy;
+
+	if (outline) {
+		tdx += px[0];
+		tdy += px[1];
+	}
+
+	glBegin(GL_QUADS);
+		glVertex3f(x - tdx, y + tdy, 0.0f);
+		glVertex3f(x + tdx, y + tdy, 0.0f);
+		glVertex3f(x + tdx, y - tdy, 0.0f);
+		glVertex3f(x - tdx, y - tdy, 0.0f);
+	glEnd();
+}
+
+static void draw_marker_slide_triangle(float x, float y, float dx, float dy, int outline, float px[2])
+{
+	float tdx, tdy;
+
+	tdx = dx * 2.0f;
+	tdy = dy * 2.0f;
+
+	if (outline) {
+		tdx += px[0];
+		tdy += px[1];
+	}
+
+	glBegin(GL_TRIANGLES);
+		glVertex3f(x,       y,       0.0f);
+		glVertex3f(x - tdx, y,       0.0f);
+		glVertex3f(x,       y + tdy, 0.0f);
+	glEnd();
+}
+
 static void draw_marker_slide_zones(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker,
                                     float marker_pos[2], int outline, int sel, int act, int width, int height)
 {
-	float x, y, dx, dy, patdx, patdy, searchdx, searchdy, tdx, tdy;
+	float dx, dy, patdx, patdy, searchdx, searchdy;
 	int tiny = sc->flag & SC_SHOW_TINY_MARKER;
-	float col[3], scol[3], px[2];
+	float col[3], scol[3], px[2], side;
 
 	if ((tiny && outline) || (marker->flag & MARKER_DISABLED))
 		return;
@@ -768,11 +785,12 @@ static void draw_marker_slide_zones(SpaceClip *sc, MovieTrackingTrack *track, Mo
 	dx = 6.0f / width / sc->zoom;
 	dy = 6.0f / height / sc->zoom;
 
-	patdx = MIN2(dx * 2.0f / 3.0f, (track->pat_max[0] - track->pat_min[0]) / 6.0f);
-	patdy = MIN2(dy * 2.0f / 3.0f, (track->pat_max[1] - track->pat_min[1]) / 6.0f);
+	side = get_shortest_pattern_side(marker);
+	patdx = MIN2(dx * 2.0f / 3.0f, side / 6.0f);
+	patdy = MIN2(dy * 2.0f / 3.0f, side * width / height / 6.0f);
 
-	searchdx = MIN2(dx, (track->search_max[0] - track->search_min[0]) / 6.0f);
-	searchdy = MIN2(dy, (track->search_max[1] - track->search_min[1]) / 6.0f);
+	searchdx = MIN2(dx, (marker->search_max[0] - marker->search_min[0]) / 6.0f);
+	searchdy = MIN2(dy, (marker->search_max[1] - marker->search_min[1]) / 6.0f);
 
 	px[0] = 1.0f / sc->zoom / width / sc->scale;
 	px[1] = 1.0f / sc->zoom / height / sc->scale;
@@ -786,41 +804,10 @@ static void draw_marker_slide_zones(SpaceClip *sc, MovieTrackingTrack *track, Mo
 		}
 
 		/* search offset square */
-		x = track->search_min[0];
-		y = track->search_max[1];
-
-		tdx = searchdx;
-		tdy = searchdy;
-
-		if (outline) {
-			tdx += px[0];
-			tdy += px[1];
-		}
-
-		glBegin(GL_QUADS);
-			glVertex3f(x - tdx, y + tdy, 0);
-			glVertex3f(x + tdx, y + tdy, 0);
-			glVertex3f(x + tdx, y - tdy, 0);
-			glVertex3f(x - tdx, y - tdy, 0);
-		glEnd();
+		draw_marker_slide_square(marker->search_min[0], marker->search_max[1], searchdx, searchdy, outline, px);
 
 		/* search re-sizing triangle */
-		x = track->search_max[0];
-		y = track->search_min[1];
-
-		tdx = searchdx * 2.0f;
-		tdy = searchdy * 2.0f;
-
-		if (outline) {
-			tdx += px[0];
-			tdy += px[1];
-		}
-
-		glBegin(GL_TRIANGLES);
-			glVertex3f(x, y, 0);
-			glVertex3f(x - tdx, y, 0);
-			glVertex3f(x, y + tdy, 0);
-		glEnd();
+		draw_marker_slide_triangle(marker->search_max[0], marker->search_min[1], searchdx, searchdy, outline, px);
 	}
 
 	if ((sc->flag & SC_SHOW_MARKER_PATTERN) && ((track->pat_flag & SELECT) == sel || outline)) {
@@ -831,42 +818,26 @@ static void draw_marker_slide_zones(SpaceClip *sc, MovieTrackingTrack *track, Mo
 				glColor3fv(col);
 		}
 
-		/* pattern offset square */
-		x = track->pat_min[0];
-		y = track->pat_max[1];
+		/* XXX: need to be real check if affine tracking is enabled, but for now not
+		 *      sure how to do this, so assume affine tracker is always enabled */
+		if (TRUE) {
+			int i;
 
-		tdx = patdx;
-		tdy = patdy;
-
-		if (outline) {
-			tdx += px[0];
-			tdy += px[1];
+			/* pattern's corners sliding squares */
+			for (i = 0; i < 4; i++) {
+				draw_marker_slide_square(marker->pattern_corners[i][0], marker->pattern_corners[i][1],
+				                         patdx / 1.5f, patdy / 1.5f, outline, px);
+			}
 		}
+		else {
+			/* pattern offset square */
+			draw_marker_slide_square(marker->pattern_corners[3][0], marker->pattern_corners[3][1],
+			                         patdx, patdy, outline, px);
 
-		glBegin(GL_QUADS);
-			glVertex3f(x - tdx, y + tdy, 0);
-			glVertex3f(x + tdx, y + tdy, 0);
-			glVertex3f(x + tdx, y - tdy, 0);
-			glVertex3f(x - tdx, y - tdy, 0);
-		glEnd();
-
-		/* pattern re-sizing triangle */
-		x = track->pat_max[0];
-		y = track->pat_min[1];
-
-		tdx = patdx*2.0f;
-		tdy = patdy*2.0f;
-
-		if (outline) {
-			tdx += px[0];
-			tdy += px[1];
+			/* pattern re-sizing triangle */
+			draw_marker_slide_triangle(marker->pattern_corners[1][0], marker->pattern_corners[1][1],
+			                           patdx, patdy, outline, px);
 		}
-
-		glBegin(GL_TRIANGLES);
-			glVertex3f(x, y, 0);
-			glVertex3f(x - tdx, y, 0);
-			glVertex3f(x, y + tdy, 0);
-		glEnd();
 	}
 
 	glPopMatrix();
@@ -905,12 +876,15 @@ static void draw_marker_texts(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 	if ((sc->flag & SC_SHOW_MARKER_SEARCH) &&
 	   ((marker->flag & MARKER_DISABLED) == 0 || (sc->flag & SC_SHOW_MARKER_PATTERN) == 0))
 	{
-		dx = track->search_min[0];
-		dy = track->search_min[1];
+		dx = marker->search_min[0];
+		dy = marker->search_min[1];
 	}
 	else if (sc->flag & SC_SHOW_MARKER_PATTERN) {
-		dx = track->pat_min[0];
-		dy = track->pat_min[1];
+		float pat_min[2], pat_max[2];
+
+		BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
+		dx = pat_min[0];
+		dy = pat_min[1];
 	}
 
 	pos[0] = (marker_pos[0] + dx) * width;
diff --git a/source/blender/editors/space_clip/space_clip.c b/source/blender/editors/space_clip/space_clip.c
index a49319abd20..54724881e37 100644
--- a/source/blender/editors/space_clip/space_clip.c
+++ b/source/blender/editors/space_clip/space_clip.c
@@ -306,6 +306,9 @@ static void clip_free(SpaceLink *sl)
 	if (sc->scopes.track_preview)
 		IMB_freeImBuf(sc->scopes.track_preview);
 
+	if (sc->scopes.track_search)
+		IMB_freeImBuf(sc->scopes.track_search);
+
 	ED_space_clip_free_texture_buffer(sc);
 }
 
@@ -323,6 +326,7 @@ static SpaceLink *clip_duplicate(SpaceLink *sl)
 	SpaceClip *scn = MEM_dupallocN(sl);
 
 	/* clear or remove stuff from old */
+	scn->scopes.track_search = NULL;
 	scn->scopes.track_preview = NULL;
 	scn->scopes.ok = FALSE;
 	scn->draw_context = NULL;
diff --git a/source/blender/editors/space_clip/tracking_ops.c b/source/blender/editors/space_clip/tracking_ops.c
index 08fc84d193c..f6e9622f0a5 100644
--- a/source/blender/editors/space_clip/tracking_ops.c
+++ b/source/blender/editors/space_clip/tracking_ops.c
@@ -79,6 +79,8 @@
 
 #include "clip_intern.h"	// own include
 
+static float dist_to_crns(float co[2], float pos[2], float crns[4][2]);
+
 /********************** add marker operator *********************/
 
 static void add_marker(SpaceClip *sc, float x, float y)
@@ -260,15 +262,16 @@ typedef struct {
 
 	int mval[2];
 	int width, height;
-	float *min, *max, *pos, *offset;
-	float smin[2], smax[2], spos[2], soff[2];
+	float *min, *max, *pos, *offset, (*corners)[2];
+	float smin[2], smax[2], spos[2], soff[2], scorners[4][2];
 	float (*smarkers)[2];
 
-	int lock, accurate;
+	int lock, accurate, scale;
 } SlideMarkerData;
 
 static SlideMarkerData *create_slide_marker_data(SpaceClip *sc, MovieTrackingTrack *track,
-			MovieTrackingMarker *marker, wmEvent *event, int area, int action, int width, int height)
+                                                 MovieTrackingMarker *marker, wmEvent *event,
+												 int area, int corner, int action, int width, int height)
 {
 	SlideMarkerData *data = MEM_callocN(sizeof(SlideMarkerData), "slide marker data");
 	int framenr = ED_space_clip_clip_framenr(sc);
@@ -288,10 +291,9 @@ static SlideMarkerData *create_slide_marker_data(SpaceClip *sc, MovieTrackingTra
 	}
 	else if (area == TRACK_AREA_PAT) {
 		if (action == SLIDE_ACTION_SIZE) {
-			data->min = track->pat_min;
-			data->max = track->pat_max;
+			data->corners = marker->pattern_corners;
 		}
-		else {
+		else if (action == SLIDE_ACTION_OFFSET) {
 			int a;
 
 			data->pos = marker->pos;
@@ -303,15 +305,28 @@ static SlideMarkerData *create_slide_marker_data(SpaceClip *sc, MovieTrackingTra
 			for (a = 0; a < track->markersnr; a++)
 				copy_v2_v2(data->smarkers[a], track->markers[a].pos);
 		}
+		else if (action == SLIDE_ACTION_POS) {
+			data->corners = marker->pattern_corners;
+			data->pos = marker->pattern_corners[corner];
+
+			copy_v2_v2(data->spos, data->pos);
+		}
 	}
 	else if (area == TRACK_AREA_SEARCH) {
-		data->min = track->search_min;
-		data->max = track->search_max;
+		data->min = marker->search_min;
+		data->max = marker->search_max;
 	}
 
-	if (area == TRACK_AREA_SEARCH || (area == TRACK_AREA_PAT && action != SLIDE_ACTION_OFFSET)) {
-		copy_v2_v2(data->smin, data->min);
-		copy_v2_v2(data->smax, data->max);
+	if ((area == TRACK_AREA_SEARCH) ||
+		(area == TRACK_AREA_PAT && action != SLIDE_ACTION_OFFSET))
+	{
+		if (data->corners) {
+			memcpy(data->scorners, data->corners, sizeof(data->scorners));
+		}
+		else {
+			copy_v2_v2(data->smin, data->min);
+			copy_v2_v2(data->smax, data->max);
+		}
 	}
 
 	data->mval[0] = event->mval[0];
@@ -326,9 +341,7 @@ static SlideMarkerData *create_slide_marker_data(SpaceClip *sc, MovieTrackingTra
 	return data;
 }
 
-/* corner = 0: right-bottom corner,
- * corner = 1: left-top corner */
-static int mouse_on_corner(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker,
+static int mouse_on_corner(SpaceClip *sc, MovieTrackingMarker *marker,
                            int area, float co[2], int corner, int width, int height)
 {
 	int inside = 0;
@@ -337,12 +350,11 @@ static int mouse_on_corner(SpaceClip *sc, MovieTrackingTrack *track, MovieTracki
 	float crn[2], dx, dy, tdx, tdy;
 
 	if (area == TRACK_AREA_SEARCH) {
-		copy_v2_v2(min, track->search_min);
-		copy_v2_v2(max, track->search_max);
+		copy_v2_v2(min, marker->search_min);
+		copy_v2_v2(max, marker->search_max);
 	}
 	else {
-		copy_v2_v2(min, track->pat_min);
-		copy_v2_v2(max, track->pat_max);
+		BKE_tracking_marker_pattern_minmax(marker, min, max);
 	}
 
 	dx = size / width / sc->zoom;
@@ -370,22 +382,95 @@ static int mouse_on_corner(SpaceClip *sc, MovieTrackingTrack *track, MovieTracki
 	return inside;
 }
 
+static int get_mouse_pattern_corner(SpaceClip *sc, MovieTrackingMarker *marker, float co[2], int width, int height)
+{
+	int i, next;
+	float len = FLT_MAX, dx, dy;
+
+	for (i = 0; i < 4; i++) {
+		float cur_len;
+
+		next = (i + 1) % 4;
+
+		cur_len = len_v2v2(marker->pattern_corners[i], marker->pattern_corners[next]);
+
+		len = MIN2(cur_len, len);
+	}
+
+	dx = 6.0f / width / sc->zoom;
+	dy = 6.0f / height / sc->zoom;
+
+	dx = MIN2(dx * 2.0f / 3.0f, len / 6.0f);
+	dy = MIN2(dy * 2.0f / 3.0f, len * width / height / 6.0f);
+
+	for (i = 0; i < 4; i++) {
+		float crn[2];
+		int inside;
+
+		add_v2_v2v2(crn, marker->pattern_corners[i], marker->pos);
+
+		inside = IN_RANGE_INCL(co[0], crn[0] - dx, crn[0] + dx) &&
+		         IN_RANGE_INCL(co[1], crn[1] - dy, crn[1] + dy);
+
+		if (inside)
+			return i;
+	}
+
+	return -1;
+}
+
 static int mouse_on_offset(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-			float co[2], int width, int height)
+                           float co[2], int width, int height)
 {
 	float pos[2], dx, dy;
+	float pat_min[2], pat_max[2];
+
+	BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
 
 	add_v2_v2v2(pos, marker->pos, track->offset);
 
 	dx = 12.0f / width / sc->zoom;
 	dy = 12.0f / height / sc->zoom;
 
-	dx = MIN2(dx, (track->pat_max[0] - track->pat_min[0]) / 2.0f);
-	dy = MIN2(dy, (track->pat_max[1] - track->pat_min[1]) / 2.0f);
+	dx = MIN2(dx, (pat_max[0] - pat_min[0]) / 2.0f);
+	dy = MIN2(dy, (pat_max[1] - pat_min[1]) / 2.0f);
 
 	return co[0] >= pos[0] - dx && co[0] <= pos[0] + dx && co[1] >= pos[1] - dy && co[1] <= pos[1] + dy;
 }
 
+static int slide_check_corners(float (*corners)[2])
+{
+	int i, next, prev;
+	float cross = 0.0f;
+	float p[2] = {0.0f, 0.0f};
+
+	if (!isect_point_quad_v2(p, corners[0], corners[1], corners[2], corners[3]))
+		return FALSE;
+
+	for (i = 0; i < 4; i++) {
+		float v1[2], v2[2], cur_cross;
+
+		next = (i + 1) % 4;
+		prev = (4 + i - 1) % 4;
+
+		sub_v2_v2v2(v1, corners[i], corners[prev]);
+		sub_v2_v2v2(v2, corners[next], corners[i]);
+
+		cur_cross = cross_v2v2(v1, v2);
+
+		if (fabsf(cur_cross) > FLT_EPSILON) {
+			if (cross == 0.0f) {
+				cross = cur_cross;
+			}
+			else if (cross * cur_cross < 0.0f) {
+				return FALSE;
+			}
+		}
+	}
+
+	return TRUE;
+}
+
 static void hide_cursor(bContext *C)
 {
 	wmWindow *win = CTX_wm_window(C);
@@ -424,28 +509,45 @@ static void *slide_marker_customdata(bContext *C, wmEvent *event)
 			MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
 
 			if ((marker->flag & MARKER_DISABLED) == 0) {
-				if (!customdata)
+				if (!customdata) {
 					if (mouse_on_offset(sc, track, marker, co, width, height))
-						customdata = create_slide_marker_data(sc, track, marker, event, TRACK_AREA_POINT,
+						customdata = create_slide_marker_data(sc, track, marker, event, TRACK_AREA_POINT, 0,
 						                                      SLIDE_ACTION_POS, width, height);
+				}
 
 				if (sc->flag & SC_SHOW_MARKER_SEARCH) {
-					if (mouse_on_corner(sc, track, marker, TRACK_AREA_SEARCH, co, 1, width, height))
-						customdata = create_slide_marker_data(sc, track, marker, event, TRACK_AREA_SEARCH,
+					if (mouse_on_corner(sc, marker, TRACK_AREA_SEARCH, co, 1, width, height)) {
+						customdata = create_slide_marker_data(sc, track, marker, event, TRACK_AREA_SEARCH, 0,
 						                                      SLIDE_ACTION_OFFSET, width, height);
-					else if (mouse_on_corner(sc, track, marker, TRACK_AREA_SEARCH, co, 0, width, height))
-						customdata = create_slide_marker_data(sc, track, marker, event, TRACK_AREA_SEARCH,
+					}
+					else if (mouse_on_corner(sc, marker, TRACK_AREA_SEARCH, co, 0, width, height)) {
+						customdata = create_slide_marker_data(sc, track, marker, event, TRACK_AREA_SEARCH, 0,
 						                                      SLIDE_ACTION_SIZE, width, height);
+					}
 				}
 
 				if (!customdata && (sc->flag & SC_SHOW_MARKER_PATTERN)) {
-					if (mouse_on_corner(sc, track, marker, TRACK_AREA_PAT, co, 1,  width, height))
-						customdata = create_slide_marker_data(sc, track, marker, event, TRACK_AREA_PAT,
-                                                              SLIDE_ACTION_OFFSET, width, height);
-
-					if (!customdata && mouse_on_corner(sc, track, marker, TRACK_AREA_PAT, co, 0, width, height))
-						customdata = create_slide_marker_data(sc, track, marker, event, TRACK_AREA_PAT,
-						                                      SLIDE_ACTION_SIZE, width, height);
+					/* XXX: need to be real check if affine tracking is enabled, but for now not
+					 *      sure how to do this, so assume affine tracker is always enabled */
+					if (TRUE) {
+						int corner = get_mouse_pattern_corner(sc, marker, co, width, height);
+
+						if (corner != -1) {
+							customdata = create_slide_marker_data(sc, track, marker, event, TRACK_AREA_PAT, corner,
+							                                      SLIDE_ACTION_POS, width, height);
+						}
+					}
+					else {
+						if (mouse_on_corner(sc, marker, TRACK_AREA_PAT, co, 1,  width, height)) {
+							customdata = create_slide_marker_data(sc, track, marker, event, TRACK_AREA_PAT, 0,
+							                                      SLIDE_ACTION_OFFSET, width, height);
+						}
+
+						if (!customdata && mouse_on_corner(sc, marker, TRACK_AREA_PAT, co, 0, width, height)) {
+							customdata = create_slide_marker_data(sc, track, marker, event, TRACK_AREA_PAT, 0,
+							                                      SLIDE_ACTION_SIZE, width, height);
+						}
+					}
 				}
 
 				if (customdata)
@@ -493,9 +595,16 @@ static void cancel_mouse_slide(SlideMarkerData *data)
 			copy_v2_v2(data->pos, data->spos);
 	}
 	else {
-		if (data->action == SLIDE_ACTION_SIZE) {
-			copy_v2_v2(data->min, data->smin);
-			copy_v2_v2(data->max, data->smax);
+		if ((data->action == SLIDE_ACTION_SIZE) ||
+		    (data->action == SLIDE_ACTION_POS && data->area == TRACK_AREA_PAT))
+		{
+			if (data->corners) {
+				memcpy(data->corners, data->scorners, sizeof(data->scorners));
+			}
+			else {
+				copy_v2_v2(data->min, data->smin);
+				copy_v2_v2(data->max, data->smax);
+			}
 		}
 		else {
 			int a;
@@ -531,6 +640,10 @@ static int slide_marker_modal(bContext *C, wmOperator *op, wmEvent *event)
 				if (ELEM(event->type, LEFTCTRLKEY, RIGHTCTRLKEY))
 					data->lock = event->val == KM_RELEASE;
 
+			if (data->action == SLIDE_ACTION_POS)
+				if (ELEM(event->type, LEFTCTRLKEY, RIGHTCTRLKEY))
+					data->scale = event->val == KM_PRESS;
+
 			if (ELEM(event->type, LEFTSHIFTKEY, RIGHTSHIFTKEY))
 				data->accurate = event->val == KM_PRESS;
 
@@ -560,8 +673,6 @@ static int slide_marker_modal(bContext *C, wmOperator *op, wmEvent *event)
 				else {
 					data->pos[0] = data->spos[0] + dx;
 					data->pos[1] = data->spos[1] + dy;
-
-					data->marker->flag &= ~MARKER_TRACKED;
 				}
 
 				WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
@@ -569,18 +680,33 @@ static int slide_marker_modal(bContext *C, wmOperator *op, wmEvent *event)
 			}
 			else {
 				if (data->action == SLIDE_ACTION_SIZE) {
-					data->min[0] = data->smin[0] - dx;
-					data->max[0] = data->smax[0] + dx;
+					if (data->corners) {
+						data->corners[0][0] = data->scorners[0][0] - dx;
+						data->corners[0][1] = data->scorners[0][1] + dy;
+
+						data->corners[1][0] = data->scorners[1][0] + dx;
+						data->corners[1][1] = data->scorners[1][1] + dy;
 
-					data->min[1] = data->smin[1] + dy;
-					data->max[1] = data->smax[1] - dy;
+						data->corners[2][0] = data->scorners[2][0] + dx;
+						data->corners[2][1] = data->scorners[2][1] - dy;
+
+						data->corners[3][0] = data->scorners[3][0] - dx;
+						data->corners[3][1] = data->scorners[3][1] - dy;
+					}
+					else {
+						data->min[0] = data->smin[0] - dx;
+						data->max[0] = data->smax[0] + dx;
+
+						data->min[1] = data->smin[1] + dy;
+						data->max[1] = data->smax[1] - dy;
+					}
 
 					if (data->area == TRACK_AREA_SEARCH)
-						BKE_tracking_clamp_track(data->track, CLAMP_SEARCH_DIM);
+						BKE_tracking_clamp_marker(data->marker, CLAMP_SEARCH_DIM);
 					else
-						BKE_tracking_clamp_track(data->track, CLAMP_PAT_DIM);
+						BKE_tracking_clamp_marker(data->marker, CLAMP_PAT_DIM);
 				}
-				else {
+				else if (data->action == SLIDE_ACTION_OFFSET) {
 					float d[2] = {dx, dy};
 
 					if (data->area == TRACK_AREA_SEARCH) {
@@ -597,10 +723,43 @@ static int slide_marker_modal(bContext *C, wmOperator *op, wmEvent *event)
 					}
 
 					if (data->area == TRACK_AREA_SEARCH)
-						BKE_tracking_clamp_track(data->track, CLAMP_SEARCH_POS);
+						BKE_tracking_clamp_marker(data->marker, CLAMP_SEARCH_POS);
+				}
+				else if (data->action == SLIDE_ACTION_POS) {
+					if (data->scale) {
+						float scale = 1.0f + 10.0f * (dx - dy);
+
+						if (scale > 0.0f) {
+							int a;
+
+							for (a = 0; a < 4; a++) {
+								mul_v2_v2fl(data->corners[a], data->scorners[a], scale);
+							}
+						}
+					}
+					else {
+						float spos[2];
+
+						copy_v2_v2(spos, data->pos);
+
+						/* corners might've been scaled before, restore their original position */
+						memcpy(data->corners, data->scorners, sizeof(data->scorners));
+
+						data->pos[0] = data->spos[0] + dx;
+						data->pos[1] = data->spos[1] + dy;
+
+						if (!slide_check_corners(data->corners)) {
+							copy_v2_v2(data->pos, spos);
+						}
+					}
+
+					/* currently only patterns are allowed to have such combination of event and data */
+					BKE_tracking_clamp_marker(data->marker, CLAMP_PAT_DIM);
 				}
 			}
 
+			data->marker->flag &= ~MARKER_TRACKED;
+
 			WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, NULL);
 
 			break;
@@ -673,31 +832,41 @@ static int mouse_on_rect(float co[2], float pos[2], float min[2], float max[2],
 	       mouse_on_side(co, pos[0] + max[0], pos[1] + min[1], pos[0] + max[0], pos[1] + max[1], epsx, epsy);
 }
 
+static int mouse_on_crns(float co[2], float pos[2], float crns[4][2], float epsx, float epsy)
+{
+	float dist = dist_to_crns(co, pos, crns);
+
+	return dist < MAX2(epsx, epsy);
+}
+
 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);
+	float pat_min[2], pat_max[2];
 	float epsx, epsy;
 	int width, height;
 
 	ED_space_clip_size(sc, &width, &height);
 
-	epsx = MIN4(track->pat_min[0] - track->search_min[0], track->search_max[0] - track->pat_max[0],
-	           fabsf(track->pat_min[0]), fabsf(track->pat_max[0])) / 2;
-	epsy = MIN4(track->pat_min[1] - track->search_min[1], track->search_max[1] - track->pat_max[1],
-	           fabsf(track->pat_min[1]), fabsf(track->pat_max[1])) / 2;
+	BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
+
+	epsx = MIN4(pat_min[0] - marker->search_min[0], marker->search_max[0] - pat_max[0],
+	            fabsf(pat_min[0]), fabsf(pat_max[0])) / 2;
+	epsy = MIN4(pat_min[1] - marker->search_min[1], marker->search_max[1] - pat_max[1],
+	            fabsf(pat_min[1]), fabsf(pat_max[1])) / 2;
 
 	epsx = MAX2(epsx, 2.0f / width);
 	epsy = MAX2(epsy, 2.0f / height);
 
 	if (sc->flag & SC_SHOW_MARKER_SEARCH) {
-		if (mouse_on_rect(co, marker->pos, track->search_min, track->search_max, epsx, epsy))
+		if (mouse_on_rect(co, marker->pos, marker->search_min, marker->search_max, epsx, epsy))
 			return TRACK_AREA_SEARCH;
 	}
 
 	if ((marker->flag & MARKER_DISABLED) == 0) {
 		if (sc->flag & SC_SHOW_MARKER_PATTERN)
-			if (mouse_on_rect(co, marker->pos, track->pat_min, track->pat_max, epsx, epsy))
+			if (mouse_on_crns(co, marker->pos, marker->pattern_corners, epsx, epsy))
 				return TRACK_AREA_PAT;
 
 		epsx = 12.0f / width;
@@ -728,6 +897,21 @@ static float dist_to_rect(float co[2], float pos[2], float min[2], float max[2])
 	return MIN4(d1, d2, d3, d4);
 }
 
+static float dist_to_crns(float co[2], float pos[2], float crns[4][2])
+{
+	float d1, d2, d3, d4;
+	float p[2] = {co[0] - pos[0], co[1] - pos[1]};
+	float *v1 = crns[0], *v2 = crns[1],
+	      *v3 = crns[2], *v4 = crns[3];
+
+	d1 = dist_to_line_segment_v2(p, v1, v2);
+	d2 = dist_to_line_segment_v2(p, v2, v3);
+	d3 = dist_to_line_segment_v2(p, v3, v4);
+	d4 = dist_to_line_segment_v2(p, v4, v1);
+
+	return MIN4(d1, d2, d3, d4);
+}
+
 static MovieTrackingTrack *find_nearest_track(SpaceClip *sc, ListBase *tracksbase, float co[2])
 {
 	MovieTrackingTrack *track = NULL, *cur;
@@ -743,15 +927,15 @@ static MovieTrackingTrack *find_nearest_track(SpaceClip *sc, ListBase *tracksbas
 
 			/* distance to marker point */
 			d1 = sqrtf((co[0] - marker->pos[0] - cur->offset[0]) * (co[0] - marker->pos[0] - cur->offset[0]) +
-					  (co[1] - marker->pos[1] - cur->offset[1]) * (co[1] - marker->pos[1] - cur->offset[1]));
+					   (co[1] - marker->pos[1] - cur->offset[1]) * (co[1] - marker->pos[1] - cur->offset[1]));
 
 			/* distance to pattern boundbox */
 			if (sc->flag & SC_SHOW_MARKER_PATTERN)
-				d2 = dist_to_rect(co, marker->pos, cur->pat_min, cur->pat_max);
+				d2 = dist_to_crns(co, marker->pos, marker->pattern_corners);
 
 			/* distance to search boundbox */
 			if (sc->flag & SC_SHOW_MARKER_SEARCH && TRACK_VIEW_SELECTED(sc, cur))
-				d3 = dist_to_rect(co, marker->pos, cur->search_min, cur->search_max);
+				d3 = dist_to_rect(co, marker->pos, marker->search_min, marker->search_max);
 
 			/* choose minimal distance. useful for cases of overlapped markers. */
 			dist = MIN3(d1, d2, d3);
@@ -861,7 +1045,8 @@ void CLIP_OT_select(wmOperatorType *ot)
 	/* api callbacks */
 	ot->exec = select_exec;
 	ot->invoke = select_invoke;
-	ot->poll = ED_space_clip_tracking_poll;
+	//ot->poll = ED_space_clip_tracking_poll; // so mask view can Ctrl+RMB markers
+	ot->poll = ED_space_clip_view_clip_poll;
 
 	/* flags */
 	ot->flag = OPTYPE_UNDO;
diff --git a/source/blender/editors/transform/transform.c b/source/blender/editors/transform/transform.c
index ea86083fac4..d41294c7875 100644
--- a/source/blender/editors/transform/transform.c
+++ b/source/blender/editors/transform/transform.c
@@ -815,6 +815,14 @@ int transformEvent(TransInfo *t, wmEvent *event)
 					initSnapping(t, NULL); // need to reinit after mode change
 					t->redraw |= TREDRAW_HARD;
 				}
+				else if (t->mode == TFM_RESIZE) {
+					if (t->options & CTX_MOVIECLIP) {
+						restoreTransObjects(t);
+
+						t->flag ^= T_ALT_TRANSFORM;
+						t->redraw |= TREDRAW_HARD;
+					}
+				}
 				break;
 				
 			case TFM_MODAL_SNAP_INV_ON:
@@ -2730,6 +2738,9 @@ static void ElementResize(TransInfo *t, TransData *td, float mat[3][3])
 	{
 		copy_v3_v3(center, td->center);
 	}
+	else if (t->options & CTX_MOVIECLIP) {
+		copy_v3_v3(center, td->center);
+	}
 	else {
 		copy_v3_v3(center, t->center);
 	}
@@ -3103,6 +3114,10 @@ static void ElementRotation(TransInfo *t, TransData *td, float mat[3][3], short
 		{
 			center = td->center;
 		}
+
+		if (t->options & CTX_MOVIECLIP) {
+			center = td->center;
+		}
 	}
 
 	if (t->flag & T_POINTS) {
diff --git a/source/blender/editors/transform/transform_conversions.c b/source/blender/editors/transform/transform_conversions.c
index ce65127c896..007ec3c5250 100644
--- a/source/blender/editors/transform/transform_conversions.c
+++ b/source/blender/editors/transform/transform_conversions.c
@@ -5588,23 +5588,24 @@ typedef struct TransDataTracking {
 	short coord;
 } TransDataTracking;
 
-static void markerToTransDataInit(TransData *td, TransData2D *td2d, TransDataTracking *tdt, MovieTrackingTrack *track,
-                                  int area, float loc[2], float rel[2], const float off[2])
+static void markerToTransDataInit(TransData *td, TransData2D *td2d, TransDataTracking *tdt,
+                                  MovieTrackingTrack *track, MovieTrackingMarker *marker,
+                                  int area, float loc[2], float rel[2], const float off[2], float aspx, float aspy)
 {
 	int anchor = area == TRACK_AREA_POINT && off;
 
 	tdt->mode = transDataTracking_ModeTracks;
 
 	if (anchor) {
-		td2d->loc[0] = rel[0]; /* hold original location */
-		td2d->loc[1] = rel[1];
+		td2d->loc[0] = rel[0] * aspx; /* hold original location */
+		td2d->loc[1] = rel[1] * aspy;
 
 		tdt->loc= loc;
 		td2d->loc2d = loc; /* current location */
 	}
 	else {
-		td2d->loc[0] = loc[0]; /* hold original location */
-		td2d->loc[1] = loc[1];
+		td2d->loc[0] = loc[0] * aspx; /* hold original location */
+		td2d->loc[1] = loc[1] * aspy;
 
 		td2d->loc2d = loc; /* current location */
 	}
@@ -5618,8 +5619,8 @@ static void markerToTransDataInit(TransData *td, TransData2D *td2d, TransDataTra
 
 	if (rel) {
 		if (!anchor) {
-			td2d->loc[0] += rel[0];
-			td2d->loc[1] += rel[1];
+			td2d->loc[0] += rel[0] * aspx;
+			td2d->loc[1] += rel[1] * aspy;
 		}
 
 		copy_v2_v2(tdt->srelative, rel);
@@ -5630,9 +5631,12 @@ static void markerToTransDataInit(TransData *td, TransData2D *td2d, TransDataTra
 
 	td->flag = 0;
 	td->loc = td2d->loc;
-	copy_v3_v3(td->center, td->loc);
 	copy_v3_v3(td->iloc, td->loc);
 
+	//copy_v3_v3(td->center, td->loc);
+	td->center[0] = marker->pos[0] * aspx;
+	td->center[1] = marker->pos[1] * aspy;
+
 	memset(td->axismtx, 0, sizeof(td->axismtx));
 	td->axismtx[2][2] = 1.0f;
 
@@ -5647,27 +5651,37 @@ static void markerToTransDataInit(TransData *td, TransData2D *td2d, TransDataTra
 }
 
 static void trackToTransData(SpaceClip *sc, TransData *td, TransData2D *td2d,
-                             TransDataTracking *tdt, MovieTrackingTrack *track)
+                             TransDataTracking *tdt, MovieTrackingTrack *track, float aspx, float aspy)
 {
 	int framenr = ED_space_clip_clip_framenr(sc);
 	MovieTrackingMarker *marker = BKE_tracking_ensure_marker(track, framenr);
 
 	tdt->flag = marker->flag;
-	marker->flag &= ~(MARKER_DISABLED|MARKER_TRACKED);
+	marker->flag &= ~(MARKER_DISABLED | MARKER_TRACKED);
 
-	markerToTransDataInit(td++, td2d++, tdt++, track, TRACK_AREA_POINT, track->offset, marker->pos, track->offset);
+	markerToTransDataInit(td++, td2d++, tdt++, track, marker, TRACK_AREA_POINT,
+	                      track->offset, marker->pos, track->offset, aspx, aspy);
 
-	if (track->flag & SELECT)
-		markerToTransDataInit(td++, td2d++, tdt++, track, TRACK_AREA_POINT, marker->pos, NULL, NULL);
+	if (track->flag & SELECT) {
+		markerToTransDataInit(td++, td2d++, tdt++, track, marker, TRACK_AREA_POINT,
+		                      marker->pos, NULL, NULL, aspx, aspy);
+	}
 
 	if (track->pat_flag & SELECT) {
-		markerToTransDataInit(td++, td2d++, tdt++, track, TRACK_AREA_PAT, track->pat_min, marker->pos, NULL);
-		markerToTransDataInit(td++, td2d++, tdt++, track, TRACK_AREA_PAT, track->pat_max, marker->pos, NULL);
+		int a;
+
+		for (a = 0; a < 4; a++) {
+			markerToTransDataInit(td++, td2d++, tdt++, track, marker, TRACK_AREA_PAT,
+			                      marker->pattern_corners[a], marker->pos, NULL, aspx, aspy);
+		}
 	}
 
 	if (track->search_flag & SELECT) {
-		markerToTransDataInit(td++, td2d++, tdt++, track, TRACK_AREA_SEARCH, track->search_min, marker->pos, NULL);
-		markerToTransDataInit(td++, td2d++, tdt++, track, TRACK_AREA_SEARCH, track->search_max, marker->pos, NULL);
+		markerToTransDataInit(td++, td2d++, tdt++, track, marker, TRACK_AREA_SEARCH,
+		                      marker->search_min, marker->pos, NULL, aspx, aspy);
+
+		markerToTransDataInit(td++, td2d++, tdt++, track, marker, TRACK_AREA_SEARCH,
+		                      marker->search_max, marker->pos, NULL, aspx, aspy);
 	}
 }
 
@@ -5694,6 +5708,7 @@ static void createTransTrackingTracksData(bContext *C, TransInfo *t)
 	MovieTrackingMarker *marker;
 	TransDataTracking *tdt;
 	int framenr = ED_space_clip_clip_framenr(sc);
+	float aspx, aspy;
 
 	/* count */
 	t->total = 0;
@@ -5709,7 +5724,7 @@ static void createTransTrackingTracksData(bContext *C, TransInfo *t)
 				t->total++;
 
 			if (track->pat_flag & SELECT)
-				t->total+= 2;
+				t->total+= 4;
 
 			if (track->search_flag & SELECT)
 				t->total+= 2;
@@ -5721,6 +5736,8 @@ static void createTransTrackingTracksData(bContext *C, TransInfo *t)
 	if (t->total == 0)
 		return;
 
+	ED_space_clip_aspect_dimension_aware(sc, &aspx, &aspy);
+
 	td = t->data = MEM_callocN(t->total*sizeof(TransData), "TransTracking TransData");
 	td2d = t->data2d = MEM_callocN(t->total*sizeof(TransData2D), "TransTracking TransData2D");
 	tdt = t->customData = MEM_callocN(t->total*sizeof(TransDataTracking), "TransTracking TransDataTracking");
@@ -5733,25 +5750,23 @@ static void createTransTrackingTracksData(bContext *C, TransInfo *t)
 		if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_LOCKED) == 0) {
 			marker = BKE_tracking_get_marker(track, framenr);
 
-			trackToTransData(sc, td, td2d, tdt, track);
+			trackToTransData(sc, td, td2d, tdt, track, aspx, aspy);
 
 			/* offset */
 			td++;
 			td2d++;
 			tdt++;
 
-			if ((marker->flag & MARKER_DISABLED) == 0) {
-				if (track->flag & SELECT) {
-					td++;
-					td2d++;
-					tdt++;
-				}
+			if (track->flag & SELECT) {
+				td++;
+				td2d++;
+				tdt++;
+			}
 
-				if (track->pat_flag & SELECT) {
-					td += 2;
-					td2d += 2;
-					tdt +=2;
-				}
+			if (track->pat_flag & SELECT) {
+				td += 4;
+				td2d += 4;
+				tdt += 4;
 			}
 
 			if (track->search_flag & SELECT) {
@@ -5903,9 +5918,6 @@ static void createTransTrackingData(bContext *C, TransInfo *t)
 	if (!clip || width == 0 || height == 0)
 		return;
 
-	if (!ELEM(t->mode, TFM_RESIZE, TFM_TRANSLATION))
-		return;
-
 	if (ar->regiontype == RGN_TYPE_PREVIEW) {
 		/* transformation was called from graph editor */
 		createTransTrackingCurvesData(C, t);
@@ -5973,10 +5985,14 @@ static void cancelTransTracking(TransInfo *t)
 
 void flushTransTracking(TransInfo *t)
 {
+	SpaceClip *sc = t->sa->spacedata.first;
 	TransData *td;
 	TransData2D *td2d;
 	TransDataTracking *tdt;
 	int a;
+	float aspx, aspy;
+
+	ED_space_clip_aspect_dimension_aware(sc, &aspx, &aspy);
 
 	if (t->state == TRANS_CANCEL)
 		cancelTransTracking(t);
@@ -5984,31 +6000,46 @@ void flushTransTracking(TransInfo *t)
 	/* flush to 2d vector from internally used 3d vector */
 	for (a=0, td= t->data, td2d= t->data2d, tdt= t->customData; a<t->total; a++, td2d++, td++, tdt++) {
 		if (tdt->mode == transDataTracking_ModeTracks) {
-			if (t->flag & T_ALT_TRANSFORM) {
-				if (tdt->area == TRACK_AREA_POINT && tdt->relative) {
-					float d[2], d2[2];
+			float loc2d[2];
 
-					if (!tdt->smarkers) {
-						tdt->smarkers = MEM_callocN(sizeof(*tdt->smarkers)*tdt->markersnr, "flushTransTracking markers");
-						for (a = 0; a < tdt->markersnr; a++)
-							copy_v2_v2(tdt->smarkers[a], tdt->markers[a].pos);
-					}
+			if (t->mode == TFM_ROTATION && tdt->area == TRACK_AREA_SEARCH) {
+				continue;
+			}
+
+			loc2d[0] = td2d->loc[0] / aspx;
+			loc2d[1] = td2d->loc[1] / aspy;
+
+			if (t->flag & T_ALT_TRANSFORM) {
+				if (t->mode == TFM_RESIZE) {
+					if (tdt->area != TRACK_AREA_PAT)
+						continue;
+				}
+				else if (t->mode == TFM_TRANSLATION) {
+					if (tdt->area == TRACK_AREA_POINT && tdt->relative) {
+						float d[2], d2[2];
+
+						if (!tdt->smarkers) {
+							tdt->smarkers = MEM_callocN(sizeof(*tdt->smarkers)*tdt->markersnr, "flushTransTracking markers");
+							for (a = 0; a < tdt->markersnr; a++)
+								copy_v2_v2(tdt->smarkers[a], tdt->markers[a].pos);
+						}
 
-					sub_v2_v2v2(d, td2d->loc, tdt->soffset);
-					sub_v2_v2(d, tdt->srelative);
+						sub_v2_v2v2(d, loc2d, tdt->soffset);
+						sub_v2_v2(d, tdt->srelative);
 
-					sub_v2_v2v2(d2, td2d->loc, tdt->srelative);
+						sub_v2_v2v2(d2, loc2d, tdt->srelative);
 
-					for (a= 0; a<tdt->markersnr; a++)
-						add_v2_v2v2(tdt->markers[a].pos, tdt->smarkers[a], d2);
+						for (a= 0; a<tdt->markersnr; a++)
+							add_v2_v2v2(tdt->markers[a].pos, tdt->smarkers[a], d2);
 
-					negate_v2_v2(td2d->loc2d, d);
+						negate_v2_v2(td2d->loc2d, d);
+					}
 				}
 			}
 
 			if (tdt->area!=TRACK_AREA_POINT || tdt->relative==0) {
-				td2d->loc2d[0] = td2d->loc[0];
-				td2d->loc2d[1] = td2d->loc[1];
+				td2d->loc2d[0] = loc2d[0];
+				td2d->loc2d[1] = loc2d[1];
 
 				if (tdt->relative)
 					sub_v2_v2(td2d->loc2d, tdt->relative);
diff --git a/source/blender/editors/transform/transform_generics.c b/source/blender/editors/transform/transform_generics.c
index e0920e323aa..1b8cc14ecac 100644
--- a/source/blender/editors/transform/transform_generics.c
+++ b/source/blender/editors/transform/transform_generics.c
@@ -643,23 +643,30 @@ static void recalcData_spaceclip(TransInfo *t)
 		MovieClip *clip = ED_space_clip(sc);
 		ListBase *tracksbase = BKE_tracking_get_tracks(&clip->tracking);
 		MovieTrackingTrack *track;
+		int framenr = sc->user.framenr;
 
 		flushTransTracking(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);
+
 				if (t->mode == TFM_TRANSLATION) {
 					if (TRACK_AREA_SELECTED(track, TRACK_AREA_PAT))
-						BKE_tracking_clamp_track(track, CLAMP_PAT_POS);
+						BKE_tracking_clamp_marker(marker, CLAMP_PAT_POS);
 					if (TRACK_AREA_SELECTED(track, TRACK_AREA_SEARCH))
-						BKE_tracking_clamp_track(track, CLAMP_SEARCH_POS);
+						BKE_tracking_clamp_marker(marker, CLAMP_SEARCH_POS);
 				}
 				else if (t->mode == TFM_RESIZE) {
 					if (TRACK_AREA_SELECTED(track, TRACK_AREA_PAT))
-						BKE_tracking_clamp_track(track, CLAMP_PAT_DIM);
+						BKE_tracking_clamp_marker(marker, CLAMP_PAT_DIM);
 					if (TRACK_AREA_SELECTED(track, TRACK_AREA_SEARCH))
-						BKE_tracking_clamp_track(track, CLAMP_SEARCH_DIM);
+						BKE_tracking_clamp_marker(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);
 				}
 			}
 
diff --git a/source/blender/editors/transform/transform_ops.c b/source/blender/editors/transform/transform_ops.c
index e4c85309081..52b32ae66fc 100644
--- a/source/blender/editors/transform/transform_ops.c
+++ b/source/blender/editors/transform/transform_ops.c
@@ -1025,6 +1025,7 @@ void transform_keymap_for_space(wmKeyConfig *keyconf, wmKeyMap *keymap, int spac
 			WM_keymap_add_item(keymap, OP_TRANSLATION, GKEY, KM_PRESS, 0, 0);
 			WM_keymap_add_item(keymap, OP_TRANSLATION, EVT_TWEAK_S, KM_ANY, 0, 0);
 			WM_keymap_add_item(keymap, OP_RESIZE, SKEY, KM_PRESS, 0, 0);
+			WM_keymap_add_item(keymap, OP_ROTATION, RKEY, KM_PRESS, 0, 0);
 			break;
 		default:
 			break;