Split tracking.c into several files

File tracking.c became rather huge and annoying to
maintain and it really contains several independent
areas of motrack pipeline.

Now we've got:

* tracking.c: general-purpose functions which are used
  by blender, clip editor, RNA and so.

* tracking_detect.c: feature detection functions
  (blender-side, logic is still in libmv).

* tracking_plane_tracker.c: blender-side 2D tracking logic.

* tracking_plane_tracker.c: plane track tracker.

* tracking_solver.c: functions for camera solving.

* tracking_stabilize.c: 2D stabilization functions.

* tracking_util.c: utility functions for all those files
  and which shouldn't be public.

1 files changed, 244 insertions, 0 deletions

diff --git a/source/blender/blenkernel/intern/tracking_plane_tracker.c b/source/blender/blenkernel/intern/tracking_plane_tracker.c
new file mode 100644
index 00000000000..b3725b2917b
--- /dev/null
+++ b/source/blender/blenkernel/intern/tracking_plane_tracker.c
@@ -0,0 +1,244 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2011 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Blender Foundation,
+ *                 Sergey Sharybin
+ *                 Keir Mierle
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/blenkernel/intern/tracking_plane_tracker.c
+ *  \ingroup bke
+ *
+ * This file contains implementation of plane tracker.
+ */
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_movieclip_types.h"
+
+#include "BLI_utildefines.h"
+#include "BLI_math.h"
+
+#include "BKE_tracking.h"
+
+#include "libmv-capi.h"
+
+typedef double Vec2[2];
+
+static int point_markers_correspondences_on_both_image(MovieTrackingPlaneTrack *plane_track, int frame1, int frame2,
+                                                       Vec2 **x1_r, Vec2 **x2_r)
+{
+	int i, correspondence_index;
+	Vec2 *x1, *x2;
+
+	*x1_r = x1 = MEM_mallocN(sizeof(*x1) * plane_track->point_tracksnr, "point correspondences x1");
+	*x2_r = x2 = MEM_mallocN(sizeof(*x1) * plane_track->point_tracksnr, "point correspondences x2");
+
+	for (i = 0, correspondence_index = 0; i < plane_track->point_tracksnr; i++) {
+		MovieTrackingTrack *point_track = plane_track->point_tracks[i];
+		MovieTrackingMarker *point_marker1, *point_marker2;
+
+		point_marker1 = BKE_tracking_marker_get_exact(point_track, frame1);
+		point_marker2 = BKE_tracking_marker_get_exact(point_track, frame2);
+
+		if (point_marker1 != NULL && point_marker2 != NULL) {
+			/* Here conversion from float to double happens. */
+			x1[correspondence_index][0] = point_marker1->pos[0];
+			x1[correspondence_index][1] = point_marker1->pos[1];
+
+			x2[correspondence_index][0] = point_marker2->pos[0];
+			x2[correspondence_index][1] = point_marker2->pos[1];
+
+			correspondence_index++;
+		}
+	}
+
+	return correspondence_index;
+}
+
+/* NOTE: frame number should be in clip space, not scene space */
+static void track_plane_from_existing_motion(MovieTrackingPlaneTrack *plane_track, int start_frame,
+                                             int direction, bool retrack)
+{
+	MovieTrackingPlaneMarker *start_plane_marker = BKE_tracking_plane_marker_get(plane_track, start_frame);
+	MovieTrackingPlaneMarker *keyframe_plane_marker = NULL;
+	MovieTrackingPlaneMarker new_plane_marker;
+	int current_frame, frame_delta = direction > 0 ? 1 : -1;
+
+	if (plane_track->flag & PLANE_TRACK_AUTOKEY) {
+		/* Find a keyframe in given direction. */
+		for (current_frame = start_frame; ; current_frame += frame_delta) {
+			MovieTrackingPlaneMarker *next_plane_marker =
+				BKE_tracking_plane_marker_get_exact(plane_track, current_frame + frame_delta);
+
+			if (next_plane_marker == NULL) {
+				break;
+			}
+
+			if ((next_plane_marker->flag & PLANE_MARKER_TRACKED) == 0) {
+				keyframe_plane_marker = next_plane_marker;
+				break;
+			}
+		}
+	}
+	else {
+		start_plane_marker->flag |= PLANE_MARKER_TRACKED;
+	}
+
+	new_plane_marker = *start_plane_marker;
+	new_plane_marker.flag |= PLANE_MARKER_TRACKED;
+
+	for (current_frame = start_frame; ; current_frame += frame_delta) {
+		MovieTrackingPlaneMarker *next_plane_marker =
+			BKE_tracking_plane_marker_get_exact(plane_track, current_frame + frame_delta);
+		Vec2 *x1, *x2;
+		int i, num_correspondences;
+		double H_double[3][3];
+		float H[3][3];
+
+		/* As soon as we meet keyframed plane, we stop updating the sequence. */
+		if (next_plane_marker && (next_plane_marker->flag & PLANE_MARKER_TRACKED) == 0) {
+			/* Don't override keyframes if track is in auto-keyframe mode */
+			if (plane_track->flag & PLANE_TRACK_AUTOKEY) {
+				break;
+			}
+		}
+
+		num_correspondences =
+			point_markers_correspondences_on_both_image(plane_track, current_frame, current_frame + frame_delta,
+			                                            &x1, &x2);
+
+		if (num_correspondences < 4) {
+			MEM_freeN(x1);
+			MEM_freeN(x2);
+
+			break;
+		}
+
+		libmv_homography2DFromCorrespondencesEuc(x1, x2, num_correspondences, H_double);
+
+		copy_m3_m3d(H, H_double);
+
+		for (i = 0; i < 4; i++) {
+			float vec[3] = {0.0f, 0.0f, 1.0f}, vec2[3];
+			copy_v2_v2(vec, new_plane_marker.corners[i]);
+
+			/* Apply homography */
+			mul_v3_m3v3(vec2, H, vec);
+
+			/* Normalize. */
+			vec2[0] /= vec2[2];
+			vec2[1] /= vec2[2];
+
+			copy_v2_v2(new_plane_marker.corners[i], vec2);
+		}
+
+		new_plane_marker.framenr = current_frame + frame_delta;
+
+		if (!retrack && keyframe_plane_marker &&
+		    next_plane_marker &&
+		    (plane_track->flag & PLANE_TRACK_AUTOKEY))
+		{
+			float fac = ((float) next_plane_marker->framenr - start_plane_marker->framenr) /
+			            ((float) keyframe_plane_marker->framenr - start_plane_marker->framenr);
+
+			fac = 3 * fac * fac - 2 * fac * fac * fac;
+
+			for (i = 0; i < 4; i++) {
+				interp_v2_v2v2(new_plane_marker.corners[i], new_plane_marker.corners[i],
+				               next_plane_marker->corners[i], fac);
+			}
+		}
+
+		BKE_tracking_plane_marker_insert(plane_track, &new_plane_marker);
+
+		MEM_freeN(x1);
+		MEM_freeN(x2);
+	}
+}
+
+/* NOTE: frame number should be in clip space, not scene space */
+void BKE_tracking_track_plane_from_existing_motion(MovieTrackingPlaneTrack *plane_track, int start_frame)
+{
+	track_plane_from_existing_motion(plane_track, start_frame, 1, false);
+	track_plane_from_existing_motion(plane_track, start_frame, -1, false);
+}
+
+static MovieTrackingPlaneMarker *find_plane_keyframe(MovieTrackingPlaneTrack *plane_track,
+                                                     int start_frame, int direction)
+{
+	MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track, start_frame);
+	int index = plane_marker - plane_track->markers;
+	int frame_delta = direction > 0 ? 1 : -1;
+
+	while (index >= 0 && index < plane_track->markersnr) {
+		if ((plane_marker->flag & PLANE_MARKER_TRACKED) == 0) {
+			return plane_marker;
+		}
+		plane_marker += frame_delta;
+	}
+
+	return NULL;
+}
+
+void BKE_tracking_retrack_plane_from_existing_motion_at_segment(MovieTrackingPlaneTrack *plane_track, int start_frame)
+{
+	MovieTrackingPlaneMarker *prev_plane_keyframe, *next_plane_keyframe;
+
+	prev_plane_keyframe = find_plane_keyframe(plane_track, start_frame, -1);
+	next_plane_keyframe = find_plane_keyframe(plane_track, start_frame, 1);
+
+	if (prev_plane_keyframe != NULL && next_plane_keyframe != NULL) {
+		/* First we track from left keyframe to the right one without any blending. */
+		track_plane_from_existing_motion(plane_track, prev_plane_keyframe->framenr, 1, true);
+
+		/* And then we track from the right keyframe to the left one, so shape blends in nicely */
+		track_plane_from_existing_motion(plane_track, next_plane_keyframe->framenr, -1, false);
+	}
+	else if (prev_plane_keyframe != NULL) {
+		track_plane_from_existing_motion(plane_track, prev_plane_keyframe->framenr, 1, true);
+	}
+	else if (next_plane_keyframe != NULL) {
+		track_plane_from_existing_motion(plane_track, next_plane_keyframe->framenr, -1, true);
+	}
+}
+
+BLI_INLINE void float_corners_to_double(/*const*/ float corners[4][2], double double_corners[4][2])
+{
+	copy_v2db_v2fl(double_corners[0], corners[0]);
+	copy_v2db_v2fl(double_corners[1], corners[1]);
+	copy_v2db_v2fl(double_corners[2], corners[2]);
+	copy_v2db_v2fl(double_corners[3], corners[3]);
+}
+
+void BKE_tracking_homography_between_two_quads(/*const*/ float reference_corners[4][2], /*const*/ float corners[4][2], float H[3][3])
+{
+	Vec2 x1[4], x2[4];
+	double H_double[3][3];
+
+	float_corners_to_double(reference_corners, x1);
+	float_corners_to_double(corners, x2);
+
+	libmv_homography2DFromCorrespondencesEuc(x1, x2, 4, H_double);
+
+	copy_m3_m3d(H, H_double);
+}