static void rna_Mask_update_parent(Main *bmain, Scene *scene, PointerRNA *ptr)
{
MaskParent *parent = ptr->data;
if (parent->id) {
if (GS(parent->id->name) == ID_MC) {
MovieClip *clip = (MovieClip *) parent->id;
MovieTracking *tracking = &clip->tracking;
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, parent->parent);
if (object) {
MovieTrackingTrack *track = BKE_tracking_track_get_named(tracking, object, parent->sub_parent);
if (track) {
int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, scene->r.cfra);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_framenr);
float marker_pos_ofs[2], parmask_pos[2];
MovieClipUser user = {0};
BKE_movieclip_user_set_frame(&user, scene->r.cfra);
add_v2_v2v2(marker_pos_ofs, marker->pos, track->offset);
BKE_mask_coord_from_movieclip(clip, &user, parmask_pos, marker_pos_ofs);
copy_v2_v2(parent->parent_orig, parmask_pos);
}
}
}
}
rna_Mask_update_data(bmain, scene, ptr);
}
void PlaneTrackCommonOperation::initExecution()
{
MovieTracking *tracking;
MovieTrackingObject *object;
memset(this->m_corners, 0, sizeof(this->m_corners));
memset(this->m_frameSpaceCorners, 0, sizeof(this->m_frameSpaceCorners));
if (!this->m_movieClip)
return;
tracking = &this->m_movieClip->tracking;
object = BKE_tracking_object_get_named(tracking, this->m_trackingObjectName);
if (object) {
MovieTrackingPlaneTrack *plane_track;
plane_track = BKE_tracking_plane_track_get_named(tracking, object, this->m_planeTrackName);
if (plane_track) {
MovieTrackingPlaneMarker *plane_marker;
int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(this->m_movieClip, this->m_framenumber);
plane_marker = BKE_tracking_plane_marker_get(plane_track, clip_framenr);
memcpy(this->m_corners, plane_marker->corners, sizeof(this->m_corners));
}
}
for (int i = 0; i < 4; i++) {
this->m_frameSpaceCorners[i][0] = this->m_corners[i][0] * this->getWidth();
this->m_frameSpaceCorners[i][1] = this->m_corners[i][1] * this->getHeight();
}
}
/* Finish reconstruction process by copying reconstructed data
* to an actual movie clip datablock.
*/
bool BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieTracking *tracking)
{
MovieTrackingReconstruction *reconstruction;
MovieTrackingObject *object;
tracks_map_merge(context->tracks_map, tracking);
BKE_tracking_dopesheet_tag_update(tracking);
object = BKE_tracking_object_get_named(tracking, context->object_name);
if (context->is_camera)
reconstruction = &tracking->reconstruction;
else
reconstruction = &object->reconstruction;
/* update keyframe in the interface */
if (context->select_keyframes) {
object->keyframe1 = context->keyframe1;
object->keyframe2 = context->keyframe2;
}
reconstruction->error = context->reprojection_error;
reconstruction->flag |= TRACKING_RECONSTRUCTED;
if (!reconstruct_retrieve_libmv(context, tracking))
return false;
return true;
}
void TrackPositionOperation::initExecution()
{
MovieTracking *tracking = NULL;
MovieClipUser user = {0};
MovieTrackingObject *object;
zero_v2(this->m_markerPos);
zero_v2(this->m_relativePos);
if (!this->m_movieClip)
return;
tracking = &this->m_movieClip->tracking;
BKE_movieclip_user_set_frame(&user, this->m_framenumber);
BKE_movieclip_get_size(this->m_movieClip, &user, &this->m_width, &this->m_height);
object = BKE_tracking_object_get_named(tracking, this->m_trackingObjectName);
if (object) {
MovieTrackingTrack *track;
track = BKE_tracking_track_get_named(tracking, object, this->m_trackName);
if (track) {
MovieTrackingMarker *marker;
int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(this->m_movieClip, this->m_framenumber);
marker = BKE_tracking_marker_get(track, clip_framenr);
copy_v2_v2(this->m_markerPos, marker->pos);
if (this->m_position == CMP_TRACKPOS_RELATIVE_START) {
int i;
for (i = 0; i < track->markersnr; i++) {
marker = &track->markers[i];
if ((marker->flag & MARKER_DISABLED) == 0) {
copy_v2_v2(this->m_relativePos, marker->pos);
break;
}
}
}
else if (this->m_position == CMP_TRACKPOS_RELATIVE_FRAME) {
int relative_clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(this->m_movieClip,
this->m_relativeFrame);
marker = BKE_tracking_marker_get(track, relative_clip_framenr);
copy_v2_v2(this->m_relativePos, marker->pos);
}
}
}
}
void TrackPositionOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
{
MovieClipUser user = {0};
MovieTracking *tracking = &movieClip->tracking;
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, this->trackingObject);
MovieTrackingTrack *track;
MovieTrackingMarker *marker;
int width, height;
outputValue[0] = 0.0f;
if (!object)
return;
track = BKE_tracking_track_get_named(tracking, object, this->trackName);
if (!track)
return;
BKE_movieclip_user_set_frame(&user, this->framenumber);
BKE_movieclip_get_size(this->movieClip, &user, &width, &height);
marker = BKE_tracking_marker_get(track, this->framenumber);
outputValue[0] = marker->pos[this->axis];
if (this->relative) {
int i;
for (i = 0; i < track->markersnr; i++) {
marker = &track->markers[i];
if ((marker->flag & MARKER_DISABLED) == 0) {
outputValue[0] -= marker->pos[this->axis];
break;
}
}
}
if (this->axis == 0)
outputValue[0] *= width;
else
outputValue[0] *= height;
}
void tracks_map_merge(TracksMap *map, MovieTracking *tracking)
{
MovieTrackingTrack *track;
ListBase tracks = {NULL, NULL}, new_tracks = {NULL, NULL};
ListBase *old_tracks;
int a;
if (map->is_camera) {
old_tracks = &tracking->tracks;
}
else {
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, map->object_name);
if (!object) {
/* object was deleted by user, create new one */
object = BKE_tracking_object_add(tracking, map->object_name);
}
old_tracks = &object->tracks;
}
/* duplicate currently operating tracks to temporary list.
* this is needed to keep names in unique state and it's faster to change names
* of currently operating tracks (if needed)
*/
for (a = 0; a < map->num_tracks; a++) {
MovieTrackingTrack *old_track;
bool mapped_to_old = false;
track = &map->tracks[a];
/* find original of operating track in list of previously displayed tracks */
old_track = BLI_ghash_lookup(map->hash, track);
if (old_track) {
if (BLI_findindex(old_tracks, old_track) != -1) {
BLI_remlink(old_tracks, old_track);
BLI_spin_lock(&map->spin_lock);
/* Copy flags like selection back to the track map. */
track->flag = old_track->flag;
track->pat_flag = old_track->pat_flag;
track->search_flag = old_track->search_flag;
/* Copy all the rest settings back from the map to the actual tracks. */
MEM_freeN(old_track->markers);
*old_track = *track;
old_track->markers = MEM_dupallocN(old_track->markers);
BLI_spin_unlock(&map->spin_lock);
BLI_addtail(&tracks, old_track);
mapped_to_old = true;
}
}
if (mapped_to_old == false) {
MovieTrackingTrack *new_track = BKE_tracking_track_duplicate(track);
/* Update old-new track mapping */
BLI_ghash_reinsert(map->hash, track, new_track, NULL, NULL);
BLI_addtail(&tracks, new_track);
}
}
/* move all tracks, which aren't operating */
track = old_tracks->first;
while (track) {
MovieTrackingTrack *next = track->next;
BLI_addtail(&new_tracks, track);
track = next;
}
/* now move all tracks which are currently operating and keep their names unique */
track = tracks.first;
while (track) {
MovieTrackingTrack *next = track->next;
BLI_remlink(&tracks, track);
track->next = track->prev = NULL;
BLI_addtail(&new_tracks, track);
BLI_uniquename(&new_tracks, track, CTX_DATA_(BLF_I18NCONTEXT_ID_MOVIECLIP, "Track"), '.',
offsetof(MovieTrackingTrack, name), sizeof(track->name));
track = next;
}
*old_tracks = new_tracks;
}
static void compute_gradient_screen(RenderData *rd, NodeKeyingScreenData *keyingscreen_data, MovieClip *clip, CompBuf *screenbuf)
{
MovieClipUser user = {0};
MovieTracking *tracking = &clip->tracking;
MovieTrackingTrack *track;
VoronoiTriangulationPoint *triangulated_points;
VoronoiSite *sites;
ImBuf *ibuf;
ListBase *tracksbase;
ListBase edges = {NULL, NULL};
int sites_total, triangulated_points_total, triangles_total;
int (*triangles)[3];
int i, x, y;
float *rect = screenbuf->rect;
if (keyingscreen_data->tracking_object[0]) {
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, keyingscreen_data->tracking_object);
if (!object)
return;
tracksbase = BKE_tracking_object_get_tracks(tracking, object);
}
else
tracksbase = BKE_tracking_get_active_tracks(tracking);
sites_total = BLI_countlist(tracksbase);
if (!sites_total)
return;
BKE_movieclip_user_set_frame(&user, rd->cfra);
ibuf = BKE_movieclip_get_ibuf(clip, &user);
sites = MEM_callocN(sizeof(VoronoiSite) * sites_total, "keyingscreen voronoi sites");
track = tracksbase->first;
i = 0;
while (track) {
VoronoiSite *site = &sites[i];
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, rd->cfra);
ImBuf *pattern_ibuf = BKE_tracking_get_pattern_imbuf(ibuf, track, marker, TRUE, FALSE);
int j;
zero_v3(site->color);
if (pattern_ibuf) {
for (j = 0; j < pattern_ibuf->x * pattern_ibuf->y; j++) {
if (pattern_ibuf->rect_float) {
add_v3_v3(site->color, &pattern_ibuf->rect_float[4 * j]);
}
else {
unsigned char *rrgb = (unsigned char *)pattern_ibuf->rect;
site->color[0] += srgb_to_linearrgb((float)rrgb[4 * j + 0] / 255.0f);
site->color[1] += srgb_to_linearrgb((float)rrgb[4 * j + 1] / 255.0f);
site->color[2] += srgb_to_linearrgb((float)rrgb[4 * j + 2] / 255.0f);
}
}
mul_v3_fl(site->color, 1.0f / (pattern_ibuf->x * pattern_ibuf->y));
IMB_freeImBuf(pattern_ibuf);
}
site->co[0] = marker->pos[0] * screenbuf->x;
site->co[1] = marker->pos[1] * screenbuf->y;
track = track->next;
i++;
}
IMB_freeImBuf(ibuf);
BLI_voronoi_compute(sites, sites_total, screenbuf->x, screenbuf->y, &edges);
BLI_voronoi_triangulate(sites, sites_total, &edges, screenbuf->x, screenbuf->y,
&triangulated_points, &triangulated_points_total,
&triangles, &triangles_total);
for (y = 0; y < screenbuf->y; y++) {
for (x = 0; x < screenbuf->x; x++) {
int index = 4 * (y * screenbuf->x + x);
rect[index + 0] = rect[index + 1] = rect[index + 2] = 0.0f;
rect[index + 3] = 1.0f;
for (i = 0; i < triangles_total; i++) {
int *triangle = triangles[i];
VoronoiTriangulationPoint *a = &triangulated_points[triangle[0]],
*b = &triangulated_points[triangle[1]],
*c = &triangulated_points[triangle[2]];
float co[2] = {x, y}, w[3];
if (barycentric_coords_v2(a->co, b->co, c->co, co, w)) {
if (barycentric_inside_triangle_v2(w)) {
rect[index + 0] += a->color[0] * w[0] + b->color[0] * w[1] + c->color[0] * w[2];
rect[index + 1] += a->color[1] * w[0] + b->color[1] * w[1] + c->color[1] * w[2];
rect[index + 2] += a->color[2] * w[0] + b->color[2] * w[1] + c->color[2] * w[2];
}
}
}
}
}
MEM_freeN(triangulated_points);
MEM_freeN(triangles);
MEM_freeN(sites);
BLI_freelistN(&edges);
}
/* Retrieve reconstructed tracks from libmv to blender.
* Actually, this also copies reconstructed cameras
* from libmv to movie clip datablock.
*/
static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context, MovieTracking *tracking)
{
struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction;
MovieTrackingReconstruction *reconstruction = NULL;
MovieReconstructedCamera *reconstructed;
MovieTrackingTrack *track;
ListBase *tracksbase = NULL;
int tracknr = 0, a;
bool ok = true;
bool origin_set = false;
int sfra = context->sfra, efra = context->efra;
float imat[4][4];
if (context->is_camera) {
tracksbase = &tracking->tracks;
reconstruction = &tracking->reconstruction;
}
else {
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name);
tracksbase = &object->tracks;
reconstruction = &object->reconstruction;
}
unit_m4(imat);
track = tracksbase->first;
while (track) {
double pos[3];
if (libmv_reprojectionPointForTrack(libmv_reconstruction, tracknr, pos)) {
track->bundle_pos[0] = pos[0];
track->bundle_pos[1] = pos[1];
track->bundle_pos[2] = pos[2];
track->flag |= TRACK_HAS_BUNDLE;
track->error = libmv_reprojectionErrorForTrack(libmv_reconstruction, tracknr);
}
else {
track->flag &= ~TRACK_HAS_BUNDLE;
ok = false;
printf("Unable to reconstruct position for track #%d '%s'\n", tracknr, track->name);
}
track = track->next;
tracknr++;
}
if (reconstruction->cameras)
MEM_freeN(reconstruction->cameras);
reconstruction->camnr = 0;
reconstruction->cameras = NULL;
reconstructed = MEM_callocN((efra - sfra + 1) * sizeof(MovieReconstructedCamera),
"temp reconstructed camera");
for (a = sfra; a <= efra; a++) {
double matd[4][4];
if (libmv_reprojectionCameraForImage(libmv_reconstruction, a, matd)) {
int i, j;
float mat[4][4];
float error = libmv_reprojectionErrorForImage(libmv_reconstruction, a);
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++)
mat[i][j] = matd[i][j];
}
/* Ensure first camera has got zero rotation and transform.
* This is essential for object tracking to work -- this way
* we'll always know object and environment are properly
* oriented.
*
* There's one weak part tho, which is requirement object
* motion starts at the same frame as camera motion does,
* otherwise that;' be a russian roulette whether object is
* aligned correct or not.
*/
if (!origin_set) {
invert_m4_m4(imat, mat);
unit_m4(mat);
origin_set = true;
}
else {
mul_m4_m4m4(mat, imat, mat);
}
copy_m4_m4(reconstructed[reconstruction->camnr].mat, mat);
reconstructed[reconstruction->camnr].framenr = a;
reconstructed[reconstruction->camnr].error = error;
reconstruction->camnr++;
}
else {
ok = false;
printf("No camera for frame %d\n", a);
}
}
if (reconstruction->camnr) {
int size = reconstruction->camnr * sizeof(MovieReconstructedCamera);
reconstruction->cameras = MEM_callocN(size, "reconstructed camera");
memcpy(reconstruction->cameras, reconstructed, size);
}
if (origin_set) {
track = tracksbase->first;
while (track) {
if (track->flag & TRACK_HAS_BUNDLE)
mul_v3_m4v3(track->bundle_pos, imat, track->bundle_pos);
track = track->next;
}
}
MEM_freeN(reconstructed);
return ok;
}
KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTriangulation()
{
MovieClipUser user = {0};
TriangulationData *triangulation;
MovieTracking *tracking = &this->m_movieClip->tracking;
MovieTrackingTrack *track;
VoronoiSite *sites, *site;
ImBuf *ibuf;
ListBase *tracksbase;
ListBase edges = {NULL, NULL};
int sites_total;
int i;
int width = this->getWidth();
int height = this->getHeight();
int clip_frame = BKE_movieclip_remap_scene_to_clip_frame(this->m_movieClip, this->m_framenumber);
if (this->m_trackingObject[0]) {
MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, this->m_trackingObject);
if (!object)
return NULL;
tracksbase = BKE_tracking_object_get_tracks(tracking, object);
}
else
tracksbase = BKE_tracking_get_active_tracks(tracking);
/* count sites */
for (track = (MovieTrackingTrack *) tracksbase->first, sites_total = 0; track; track = track->next) {
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_frame);
float pos[2];
if (marker->flag & MARKER_DISABLED)
continue;
add_v2_v2v2(pos, marker->pos, track->offset);
if (!IN_RANGE_INCL(pos[0], 0.0f, 1.0f) ||
!IN_RANGE_INCL(pos[1], 0.0f, 1.0f))
{
continue;
}
sites_total++;
}
if (!sites_total)
return NULL;
BKE_movieclip_user_set_frame(&user, clip_frame);
ibuf = BKE_movieclip_get_ibuf(this->m_movieClip, &user);
if (!ibuf)
return NULL;
triangulation = (TriangulationData *) MEM_callocN(sizeof(TriangulationData), "keying screen triangulation data");
sites = (VoronoiSite *) MEM_callocN(sizeof(VoronoiSite) * sites_total, "keyingscreen voronoi sites");
track = (MovieTrackingTrack *) tracksbase->first;
for (track = (MovieTrackingTrack *) tracksbase->first, site = sites; track; track = track->next) {
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_frame);
ImBuf *pattern_ibuf;
int j;
float pos[2];
if (marker->flag & MARKER_DISABLED)
continue;
add_v2_v2v2(pos, marker->pos, track->offset);
if (!IN_RANGE_INCL(pos[0], 0.0f, 1.0f) ||
!IN_RANGE_INCL(pos[1], 0.0f, 1.0f))
{
continue;
}
pattern_ibuf = BKE_tracking_get_pattern_imbuf(ibuf, track, marker, TRUE, FALSE);
zero_v3(site->color);
if (pattern_ibuf) {
for (j = 0; j < pattern_ibuf->x * pattern_ibuf->y; j++) {
if (pattern_ibuf->rect_float) {
add_v3_v3(site->color, &pattern_ibuf->rect_float[4 * j]);
}
else {
unsigned char *rrgb = (unsigned char *)pattern_ibuf->rect;
site->color[0] += srgb_to_linearrgb((float)rrgb[4 * j + 0] / 255.0f);
site->color[1] += srgb_to_linearrgb((float)rrgb[4 * j + 1] / 255.0f);
site->color[2] += srgb_to_linearrgb((float)rrgb[4 * j + 2] / 255.0f);
}
}
mul_v3_fl(site->color, 1.0f / (pattern_ibuf->x * pattern_ibuf->y));
IMB_freeImBuf(pattern_ibuf);
}
site->co[0] = pos[0] * width;
site->co[1] = pos[1] * height;
site++;
}
IMB_freeImBuf(ibuf);
BLI_voronoi_compute(sites, sites_total, width, height, &edges);
BLI_voronoi_triangulate(sites, sites_total, &edges, width, height,
&triangulation->triangulated_points, &triangulation->triangulated_points_total,
&triangulation->triangles, &triangulation->triangles_total);
MEM_freeN(sites);
BLI_freelistN(&edges);
if (triangulation->triangles_total) {
rctf *rect;
rect = triangulation->triangles_AABB =
(rctf *) MEM_callocN(sizeof(rctf) * triangulation->triangles_total, "voronoi triangulation AABB");
for (i = 0; i < triangulation->triangles_total; i++, rect++) {
int *triangle = triangulation->triangles[i];
VoronoiTriangulationPoint *a = &triangulation->triangulated_points[triangle[0]],
*b = &triangulation->triangulated_points[triangle[1]],
*c = &triangulation->triangulated_points[triangle[2]];
float min[2], max[2];
INIT_MINMAX2(min, max);
minmax_v2v2_v2(min, max, a->co);
minmax_v2v2_v2(min, max, b->co);
minmax_v2v2_v2(min, max, c->co);
rect->xmin = min[0];
rect->ymin = min[1];
rect->xmax = max[0];
rect->ymax = max[1];
}
}
return triangulation;
}