blender-legacy/blender-2.79b/source/blender/blenkernel/intern/tracking_plane_tracker.c

/*
 * ***** 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);
}