static CompBuf *node_composit_get_movieclip(RenderData *rd, MovieClip *clip, MovieClipUser *user)
{
ImBuf *orig_ibuf, *ibuf;
CompBuf *stackbuf;
int type;
float *rect;
int alloc = FALSE;
orig_ibuf = BKE_movieclip_get_ibuf(clip, user);
if (orig_ibuf == NULL || (orig_ibuf->rect == NULL && orig_ibuf->rect_float == NULL)) {
IMB_freeImBuf(orig_ibuf);
return NULL;
}
ibuf = IMB_dupImBuf(orig_ibuf);
IMB_freeImBuf(orig_ibuf);
if (ibuf->rect_float == NULL || (ibuf->userflags & IB_RECT_INVALID)) {
IMB_float_from_rect(ibuf);
ibuf->userflags &= ~IB_RECT_INVALID;
}
/* now we need a float buffer from the image with matching color management */
if (ibuf->channels == 4) {
rect = node_composit_get_float_buffer(rd, ibuf, &alloc);
}
else {
/* non-rgba passes can't use color profiles */
rect = ibuf->rect_float;
}
/* done coercing into the correct color management */
if (!alloc) {
rect = MEM_dupallocN(rect);
alloc = TRUE;
}
type = ibuf->channels;
if (rd->scemode & R_COMP_CROP) {
stackbuf = get_cropped_compbuf(&rd->disprect, rect, ibuf->x, ibuf->y, type);
if (alloc)
MEM_freeN(rect);
}
else {
/* we put imbuf copy on stack, cbuf knows rect is from other ibuf when freed! */
stackbuf = alloc_compbuf(ibuf->x, ibuf->y, type, FALSE);
stackbuf->rect = rect;
stackbuf->malloc = alloc;
}
IMB_freeImBuf(ibuf);
return stackbuf;
}
bool BKE_movieclip_has_frame(MovieClip *clip, MovieClipUser *user)
{
ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
if (ibuf) {
IMB_freeImBuf(ibuf);
return true;
}
return false;
}
int BKE_movieclip_has_frame(MovieClip *clip, MovieClipUser *user)
{
ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
if (ibuf) {
IMB_freeImBuf(ibuf);
return TRUE;
}
return FALSE;
}
static ImBuf *accessor_get_preprocessed_ibuf(TrackingImageAccessor *accessor,
int clip_index,
int frame)
{
MovieClip *clip;
MovieClipUser user;
ImBuf *ibuf;
int scene_frame;
BLI_assert(clip_index < accessor->num_clips);
clip = accessor->clips[clip_index];
scene_frame = BKE_movieclip_remap_clip_to_scene_frame(clip, frame);
BKE_movieclip_user_set_frame(&user, scene_frame);
user.render_size = MCLIP_PROXY_RENDER_SIZE_FULL;
user.render_flag = 0;
ibuf = BKE_movieclip_get_ibuf(clip, &user);
return ibuf;
}
void MovieClipBaseOperation::initExecution()
{
if (this->m_movieClip) {
BKE_movieclip_user_set_frame(this->m_movieClipUser, this->m_framenumber);
ImBuf *ibuf;
if (this->m_cacheFrame)
ibuf = BKE_movieclip_get_ibuf(this->m_movieClip, this->m_movieClipUser);
else
ibuf = BKE_movieclip_get_ibuf_flag(this->m_movieClip, this->m_movieClipUser, this->m_movieClip->flag, MOVIECLIP_CACHE_SKIP);
if (ibuf) {
this->m_movieClipBuffer = ibuf;
if (ibuf->rect_float == NULL || ibuf->userflags & IB_RECT_INVALID) {
IMB_float_from_rect(ibuf);
ibuf->userflags &= ~IB_RECT_INVALID;
}
}
}
}
void BKE_movieclip_get_size(MovieClip *clip, MovieClipUser *user, int *width, int *height)
{
if (user->framenr == clip->lastframe) {
*width = clip->lastsize[0];
*height = clip->lastsize[1];
}
else {
ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
if (ibuf && ibuf->x && ibuf->y) {
real_ibuf_size(clip, user, ibuf, width, height);
}
else {
*width = clip->lastsize[0];
*height = clip->lastsize[1];
}
if (ibuf)
IMB_freeImBuf(ibuf);
}
}
void BKE_movieclip_get_size(MovieClip *clip, MovieClipUser *user, int *width, int *height)
{
#if 0
/* originally was needed to support image sequences with different image dimensions,
* which might be useful for such things as reconstruction of unordered image sequence,
* or painting/rotoscoping of non-equal-sized images, but this ended up in unneeded
* cache lookups and even unwanted non-proxied files loading when doing mask parenting,
* so let's disable this for now and assume image sequence consists of images with
* equal sizes (sergey)
*/
if (user->framenr == clip->lastframe) {
#endif
if (clip->lastsize[0] != 0 && clip->lastsize[1] != 0) {
*width = clip->lastsize[0];
*height = clip->lastsize[1];
}
else {
ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
if (ibuf && ibuf->x && ibuf->y) {
real_ibuf_size(clip, user, ibuf, width, height);
}
else {
*width = clip->lastsize[0];
*height = clip->lastsize[1];
}
if (ibuf)
IMB_freeImBuf(ibuf);
}
}
void BKE_movieclip_get_size_fl(MovieClip *clip, MovieClipUser *user, float size[2])
{
int width, height;
BKE_movieclip_get_size(clip, user, &width, &height);
size[0] = (float)width;
size[1] = (float)height;
}
void BKE_movieclip_update_scopes(MovieClip *clip, MovieClipUser *user, MovieClipScopes *scopes)
{
if (scopes->ok)
return;
if (scopes->track_preview) {
IMB_freeImBuf(scopes->track_preview);
scopes->track_preview = NULL;
}
if (scopes->track_search) {
IMB_freeImBuf(scopes->track_search);
scopes->track_search = NULL;
}
scopes->marker = NULL;
scopes->track = NULL;
scopes->track_locked = true;
if (clip) {
MovieTrackingTrack *act_track = BKE_tracking_track_get_active(&clip->tracking);
if (act_track) {
MovieTrackingTrack *track = act_track;
int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
scopes->marker = marker;
scopes->track = track;
if (marker->flag & MARKER_DISABLED) {
scopes->track_disabled = true;
}
else {
ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
scopes->track_disabled = false;
if (ibuf && (ibuf->rect || ibuf->rect_float)) {
MovieTrackingMarker undist_marker = *marker;
if (user->render_flag & MCLIP_PROXY_RENDER_UNDISTORT) {
int width, height;
float aspy = 1.0f / clip->tracking.camera.pixel_aspect;
BKE_movieclip_get_size(clip, user, &width, &height);
undist_marker.pos[0] *= width;
undist_marker.pos[1] *= height * aspy;
BKE_tracking_undistort_v2(&clip->tracking, undist_marker.pos, undist_marker.pos);
undist_marker.pos[0] /= width;
undist_marker.pos[1] /= height * aspy;
}
scopes->track_search = BKE_tracking_get_search_imbuf(ibuf, track, &undist_marker, true, true);
scopes->undist_marker = undist_marker;
scopes->frame_width = ibuf->x;
scopes->frame_height = ibuf->y;
scopes->use_track_mask = track->flag & TRACK_PREVIEW_ALPHA;
}
IMB_freeImBuf(ibuf);
}
if ((track->flag & TRACK_LOCKED) == 0) {
float pat_min[2], pat_max[2];
scopes->track_locked = false;
/* XXX: would work fine with non-transformed patterns, but would likely fail
* with transformed patterns, but that would be easier to debug when
* we'll have real pattern sampling (at least to test) */
BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
scopes->slide_scale[0] = pat_max[0] - pat_min[0];
scopes->slide_scale[1] = pat_max[1] - pat_min[1];
}
}
}
scopes->framenr = user->framenr;
scopes->ok = true;
}
void MovieClipNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
{
NodeOutput *outputMovieClip = this->getOutputSocket(0);
NodeOutput *alphaMovieClip = this->getOutputSocket(1);
NodeOutput *offsetXMovieClip = this->getOutputSocket(2);
NodeOutput *offsetYMovieClip = this->getOutputSocket(3);
NodeOutput *scaleMovieClip = this->getOutputSocket(4);
NodeOutput *angleMovieClip = this->getOutputSocket(5);
bNode *editorNode = this->getbNode();
MovieClip *movieClip = (MovieClip *)editorNode->id;
MovieClipUser *movieClipUser = (MovieClipUser *)editorNode->storage;
bool cacheFrame = !context.isRendering();
ImBuf *ibuf = NULL;
if (movieClip) {
if (cacheFrame)
ibuf = BKE_movieclip_get_ibuf(movieClip, movieClipUser);
else
ibuf = BKE_movieclip_get_ibuf_flag(movieClip, movieClipUser, movieClip->flag, MOVIECLIP_CACHE_SKIP);
}
// always connect the output image
MovieClipOperation *operation = new MovieClipOperation();
operation->setMovieClip(movieClip);
operation->setMovieClipUser(movieClipUser);
operation->setFramenumber(context.getFramenumber());
operation->setCacheFrame(cacheFrame);
converter.addOperation(operation);
converter.mapOutputSocket(outputMovieClip, operation->getOutputSocket());
converter.addPreview(operation->getOutputSocket());
MovieClipAlphaOperation *alphaOperation = new MovieClipAlphaOperation();
alphaOperation->setMovieClip(movieClip);
alphaOperation->setMovieClipUser(movieClipUser);
alphaOperation->setFramenumber(context.getFramenumber());
alphaOperation->setCacheFrame(cacheFrame);
converter.addOperation(alphaOperation);
converter.mapOutputSocket(alphaMovieClip, alphaOperation->getOutputSocket());
MovieTrackingStabilization *stab = &movieClip->tracking.stabilization;
float loc[2], scale, angle;
loc[0] = 0.0f;
loc[1] = 0.0f;
scale = 1.0f;
angle = 0.0f;
if (ibuf) {
if (stab->flag & TRACKING_2D_STABILIZATION) {
int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movieClip, context.getFramenumber());
BKE_tracking_stabilization_data_get(&movieClip->tracking, clip_framenr, ibuf->x, ibuf->y, loc, &scale, &angle);
}
}
converter.addOutputValue(offsetXMovieClip, loc[0]);
converter.addOutputValue(offsetYMovieClip, loc[1]);
converter.addOutputValue(scaleMovieClip, scale);
converter.addOutputValue(angleMovieClip, angle);
if (ibuf) {
IMB_freeImBuf(ibuf);
}
}
/* reads full rect, converts indices */
uint *ED_view3d_select_id_read(int xmin, int ymin, int xmax, int ymax, uint *r_buf_len)
{
if (UNLIKELY((xmin > xmax) || (ymin > ymax))) {
return NULL;
}
const rcti rect = {
.xmin = xmin,
.xmax = xmax + 1,
.ymin = ymin,
.ymax = ymax + 1,
};
uint buf_len;
uint *buf = ED_view3d_select_id_read_rect(&rect, &buf_len);
if (r_buf_len) {
*r_buf_len = buf_len;
}
return buf;
}
/* ************************************************************* */
static void view3d_stereo_bgpic_setup(Scene *scene, View3D *v3d, Image *ima, ImageUser *iuser)
{
if (BKE_image_is_stereo(ima)) {
iuser->flag |= IMA_SHOW_STEREO;
if ((scene->r.scemode & R_MULTIVIEW) == 0) {
iuser->multiview_eye = STEREO_LEFT_ID;
}
else if (v3d->stereo3d_camera != STEREO_3D_ID) {
/* show only left or right camera */
iuser->multiview_eye = v3d->stereo3d_camera;
}
BKE_image_multiview_index(ima, iuser);
}
else {
iuser->flag &= ~IMA_SHOW_STEREO;
}
}
static void view3d_draw_bgpic(Scene *scene,
Depsgraph *depsgraph,
ARegion *ar,
View3D *v3d,
const bool do_foreground,
const bool do_camera_frame)
{
RegionView3D *rv3d = ar->regiondata;
int fg_flag = do_foreground ? CAM_BGIMG_FLAG_FOREGROUND : 0;
if (v3d->camera == NULL || v3d->camera->type != OB_CAMERA) {
return;
}
Camera *cam = v3d->camera->data;
for (CameraBGImage *bgpic = cam->bg_images.first; bgpic; bgpic = bgpic->next) {
if ((bgpic->flag & CAM_BGIMG_FLAG_FOREGROUND) != fg_flag) {
continue;
}
{
float image_aspect[2];
float x1, y1, x2, y2, centx, centy;
void *lock;
Image *ima = NULL;
/* disable individual images */
if ((bgpic->flag & CAM_BGIMG_FLAG_DISABLED)) {
continue;
}
ImBuf *ibuf = NULL;
ImBuf *freeibuf = NULL;
ImBuf *releaseibuf = NULL;
if (bgpic->source == CAM_BGIMG_SOURCE_IMAGE) {
ima = bgpic->ima;
if (ima == NULL) {
continue;
}
ImageUser iuser = bgpic->iuser;
iuser.scene = scene; /* Needed for render results. */
BKE_image_user_frame_calc(&iuser, (int)DEG_get_ctime(depsgraph));
if (ima->source == IMA_SRC_SEQUENCE && !(iuser.flag & IMA_USER_FRAME_IN_RANGE)) {
ibuf = NULL; /* frame is out of range, dont show */
}
else {
view3d_stereo_bgpic_setup(scene, v3d, ima, &iuser);
ibuf = BKE_image_acquire_ibuf(ima, &iuser, &lock);
releaseibuf = ibuf;
}
image_aspect[0] = ima->aspx;
image_aspect[1] = ima->aspy;
}
else if (bgpic->source == CAM_BGIMG_SOURCE_MOVIE) {
/* TODO: skip drawing when out of frame range (as image sequences do above) */
MovieClip *clip = NULL;
if (bgpic->flag & CAM_BGIMG_FLAG_CAMERACLIP) {
if (scene->camera) {
clip = BKE_object_movieclip_get(scene, scene->camera, true);
}
}
else {
clip = bgpic->clip;
}
if (clip == NULL) {
continue;
}
BKE_movieclip_user_set_frame(&bgpic->cuser, (int)DEG_get_ctime(depsgraph));
ibuf = BKE_movieclip_get_ibuf(clip, &bgpic->cuser);
image_aspect[0] = clip->aspx;
image_aspect[1] = clip->aspy;
/* working with ibuf from image and clip has got different workflow now.
* ibuf acquired from clip is referenced by cache system and should
* be dereferenced after usage. */
freeibuf = ibuf;
}
else {
/* perhaps when loading future files... */
BLI_assert(0);
copy_v2_fl(image_aspect, 1.0f);
}
if (ibuf == NULL) {
continue;
}
if ((ibuf->rect == NULL && ibuf->rect_float == NULL) || ibuf->channels != 4) {
/* invalid image format */
if (freeibuf) {
IMB_freeImBuf(freeibuf);
}
if (releaseibuf) {
BKE_image_release_ibuf(ima, releaseibuf, lock);
}
continue;
}
if (ibuf->rect == NULL) {
IMB_rect_from_float(ibuf);
}
BLI_assert(rv3d->persp == RV3D_CAMOB);
{
if (do_camera_frame) {
rctf vb;
ED_view3d_calc_camera_border(scene, depsgraph, ar, v3d, rv3d, &vb, false);
x1 = vb.xmin;
y1 = vb.ymin;
x2 = vb.xmax;
y2 = vb.ymax;
}
else {
x1 = ar->winrct.xmin;
y1 = ar->winrct.ymin;
x2 = ar->winrct.xmax;
y2 = ar->winrct.ymax;
}
/* apply offset last - camera offset is different to offset in blender units */
/* so this has some sane way of working - this matches camera's shift _exactly_ */
{
const float max_dim = max_ff(x2 - x1, y2 - y1);
const float xof_scale = bgpic->offset[0] * max_dim;
const float yof_scale = bgpic->offset[1] * max_dim;
x1 += xof_scale;
y1 += yof_scale;
x2 += xof_scale;
y2 += yof_scale;
}
centx = (x1 + x2) * 0.5f;
centy = (y1 + y2) * 0.5f;
/* aspect correction */
if (bgpic->flag & CAM_BGIMG_FLAG_CAMERA_ASPECT) {
/* apply aspect from clip */
const float w_src = ibuf->x * image_aspect[0];
const float h_src = ibuf->y * image_aspect[1];
/* destination aspect is already applied from the camera frame */
const float w_dst = x1 - x2;
const float h_dst = y1 - y2;
const float asp_src = w_src / h_src;
const float asp_dst = w_dst / h_dst;
if (fabsf(asp_src - asp_dst) >= FLT_EPSILON) {
if ((asp_src > asp_dst) == ((bgpic->flag & CAM_BGIMG_FLAG_CAMERA_CROP) != 0)) {
/* fit X */
const float div = asp_src / asp_dst;
x1 = ((x1 - centx) * div) + centx;
x2 = ((x2 - centx) * div) + centx;
}
else {
/* fit Y */
const float div = asp_dst / asp_src;
y1 = ((y1 - centy) * div) + centy;
y2 = ((y2 - centy) * div) + centy;
}
}
}
}
/* complete clip? */
rctf clip_rect;
BLI_rctf_init(&clip_rect, x1, x2, y1, y2);
if (bgpic->rotation) {
BLI_rctf_rotate_expand(&clip_rect, &clip_rect, bgpic->rotation);
}
if (clip_rect.xmax < 0 || clip_rect.ymax < 0 || clip_rect.xmin > ar->winx ||
clip_rect.ymin > ar->winy) {
if (freeibuf) {
IMB_freeImBuf(freeibuf);
}
if (releaseibuf) {
BKE_image_release_ibuf(ima, releaseibuf, lock);
}
continue;
}
float zoomx = (x2 - x1) / ibuf->x;
float zoomy = (y2 - y1) / ibuf->y;
/* For some reason; zoom-levels down refuses to use GL_ALPHA_SCALE. */
if (zoomx < 1.0f || zoomy < 1.0f) {
float tzoom = min_ff(zoomx, zoomy);
int mip = 0;
if ((ibuf->userflags & IB_MIPMAP_INVALID) != 0) {
IMB_remakemipmap(ibuf, 0);
ibuf->userflags &= ~IB_MIPMAP_INVALID;
}
else if (ibuf->mipmap[0] == NULL) {
IMB_makemipmap(ibuf, 0);
}
while (tzoom < 1.0f && mip < 8 && ibuf->mipmap[mip]) {
tzoom *= 2.0f;
zoomx *= 2.0f;
zoomy *= 2.0f;
mip++;
}
if (mip > 0) {
ibuf = ibuf->mipmap[mip - 1];
}
}
GPU_depth_test(!do_foreground);
glDepthMask(GL_FALSE);
GPU_blend(true);
GPU_blend_set_func_separate(
GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
GPU_matrix_push_projection();
GPU_matrix_push();
ED_region_pixelspace(ar);
GPU_matrix_translate_2f(centx, centy);
GPU_matrix_scale_1f(bgpic->scale);
GPU_matrix_rotate_2d(RAD2DEGF(-bgpic->rotation));
if (bgpic->flag & CAM_BGIMG_FLAG_FLIP_X) {
zoomx *= -1.0f;
x1 = x2;
}
if (bgpic->flag & CAM_BGIMG_FLAG_FLIP_Y) {
zoomy *= -1.0f;
y1 = y2;
}
float col[4] = {1.0f, 1.0f, 1.0f, bgpic->alpha};
IMMDrawPixelsTexState state = immDrawPixelsTexSetup(GPU_SHADER_2D_IMAGE_COLOR);
immDrawPixelsTex(&state,
x1 - centx,
y1 - centy,
ibuf->x,
ibuf->y,
GL_RGBA,
GL_UNSIGNED_BYTE,
GL_LINEAR,
ibuf->rect,
zoomx,
zoomy,
col);
GPU_matrix_pop_projection();
GPU_matrix_pop();
GPU_blend(false);
glDepthMask(GL_TRUE);
GPU_depth_test(true);
if (freeibuf) {
IMB_freeImBuf(freeibuf);
}
if (releaseibuf) {
BKE_image_release_ibuf(ima, releaseibuf, lock);
}
}
}
}
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);
}
void BKE_movieclip_update_scopes(MovieClip *clip, MovieClipUser *user, MovieClipScopes *scopes)
{
if (scopes->ok)
return;
if (scopes->track_preview) {
IMB_freeImBuf(scopes->track_preview);
scopes->track_preview = NULL;
}
scopes->marker = NULL;
scopes->track = NULL;
if (clip) {
MovieTrackingTrack *act_track = BKE_tracking_active_track(&clip->tracking);
if (act_track) {
MovieTrackingTrack *track = act_track;
MovieTrackingMarker *marker = BKE_tracking_get_marker(track, user->framenr);
if (marker->flag & MARKER_DISABLED) {
scopes->track_disabled = TRUE;
}
else {
ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
scopes->track_disabled = FALSE;
if (ibuf && (ibuf->rect || ibuf->rect_float)) {
ImBuf *tmpibuf;
MovieTrackingMarker undist_marker = *marker;
if (user->render_flag & MCLIP_PROXY_RENDER_UNDISTORT) {
int width, height;
float aspy = 1.0f / clip->tracking.camera.pixel_aspect;
BKE_movieclip_get_size(clip, user, &width, &height);
undist_marker.pos[0] *= width;
undist_marker.pos[1] *= height * aspy;
BKE_tracking_invert_intrinsics(&clip->tracking, undist_marker.pos, undist_marker.pos);
undist_marker.pos[0] /= width;
undist_marker.pos[1] /= height * aspy;
}
/* NOTE: margin should be kept in sync with value from ui_draw_but_TRACKPREVIEW */
tmpibuf = BKE_tracking_get_pattern_imbuf(ibuf, track, &undist_marker, 3 /* margin */,
1 /* anchor */, scopes->track_pos, NULL);
if (tmpibuf->rect_float)
IMB_rect_from_float(tmpibuf);
if (tmpibuf->rect)
scopes->track_preview = tmpibuf;
else
IMB_freeImBuf(tmpibuf);
}
IMB_freeImBuf(ibuf);
}
if ((track->flag & TRACK_LOCKED) == 0) {
scopes->marker = marker;
scopes->track = track;
scopes->slide_scale[0] = track->pat_max[0] - track->pat_min[0];
scopes->slide_scale[1] = track->pat_max[1] - track->pat_min[1];
}
}
}
scopes->framenr = user->framenr;
scopes->ok = TRUE;
}
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;
}