#include <assert.h>
#include <stdio.h>
+#include <unistd.h>
+
+#include "util.h"
#include <algorithm>
#include <memory>
// Operating point 3 (10 Hz on CPU, excluding preprocessing).
constexpr float patch_overlap_ratio = 0.75f;
-constexpr unsigned coarsest_level = 0;
-constexpr unsigned finest_level = 0;
+constexpr unsigned coarsest_level = 5;
+constexpr unsigned finest_level = 1;
constexpr unsigned patch_size_pixels = 12;
+// Some global OpenGL objects.
+GLuint nearest_sampler, linear_sampler;
+GLuint vertex_vbo;
+
string read_file(const string &filename)
{
FILE *fp = fopen(filename.c_str(), "r");
return vbo;
}
-void bind_sampler(GLuint program, const char *uniform_name, GLuint texture_unit, GLuint tex, GLuint sampler)
+void bind_sampler(GLuint program, GLint location, GLuint texture_unit, GLuint tex, GLuint sampler)
{
- GLint location = glGetUniformLocation(program, uniform_name);
if (location == -1) {
return;
}
glProgramUniform1i(program, location, texture_unit);
}
-int main(void)
-{
- if (SDL_Init(SDL_INIT_EVERYTHING) == -1) {
- fprintf(stderr, "SDL_Init failed: %s\n", SDL_GetError());
- exit(1);
- }
- SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
- SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
- SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
- SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
- // SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
- SDL_Window *window = SDL_CreateWindow("OpenGL window",
- SDL_WINDOWPOS_UNDEFINED,
- SDL_WINDOWPOS_UNDEFINED,
- 64, 64,
- SDL_WINDOW_OPENGL);
- SDL_GLContext context = SDL_GL_CreateContext(window);
- assert(context != nullptr);
-
- // Load pictures.
- GLuint tex0 = load_texture("test1499.pgm", WIDTH, HEIGHT);
- GLuint tex1 = load_texture("test1500.pgm", WIDTH, HEIGHT);
-
- // Load shaders.
- GLuint motion_vs_obj = compile_shader(read_file("motion_search.vert"), GL_VERTEX_SHADER);
- GLuint motion_fs_obj = compile_shader(read_file("motion_search.frag"), GL_FRAGMENT_SHADER);
- GLuint motion_search_program = link_program(motion_vs_obj, motion_fs_obj);
-
- GLuint sobel_vs_obj = compile_shader(read_file("vs.vert"), GL_VERTEX_SHADER);
- GLuint sobel_fs_obj = compile_shader(read_file("sobel.frag"), GL_FRAGMENT_SHADER);
- GLuint sobel_program = link_program(sobel_vs_obj, sobel_fs_obj);
-
- GLuint densify_vs_obj = compile_shader(read_file("densify.vert"), GL_VERTEX_SHADER);
- GLuint densify_fs_obj = compile_shader(read_file("densify.frag"), GL_FRAGMENT_SHADER);
- GLuint densify_program = link_program(densify_vs_obj, densify_fs_obj);
-
- // Make some samplers.
- GLuint nearest_sampler;
- glCreateSamplers(1, &nearest_sampler);
- glSamplerParameteri(nearest_sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- glSamplerParameteri(nearest_sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- glSamplerParameteri(nearest_sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- glSamplerParameteri(nearest_sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
- GLuint linear_sampler;
- glCreateSamplers(1, &linear_sampler);
- glSamplerParameteri(linear_sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glSamplerParameteri(linear_sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- glSamplerParameteri(linear_sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- glSamplerParameteri(linear_sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+// Compute gradients in every point, used for the motion search.
+// The DIS paper doesn't actually mention how these are computed,
+// but seemingly, a 3x3 Sobel operator is used here (at least in
+// later versions of the code), while a [1 -8 0 8 -1] kernel is
+// used for all the derivatives in the variational refinement part
+// (which borrows code from DeepFlow). This is inconsistent,
+// but I guess we're better off with staying with the original
+// decisions until we actually know having different ones would be better.
+class Sobel {
+public:
+ Sobel();
+ void exec(GLint tex0_view, GLint grad0_tex, int level_width, int level_height);
+
+private:
+ GLuint sobel_vs_obj;
+ GLuint sobel_fs_obj;
+ GLuint sobel_program;
+ GLuint sobel_vao;
- GLuint mipmap_sampler;
- glCreateSamplers(1, &mipmap_sampler);
- glSamplerParameteri(mipmap_sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
- glSamplerParameteri(mipmap_sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- glSamplerParameteri(mipmap_sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- glSamplerParameteri(mipmap_sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
- // Coarsest level.
- int level = coarsest_level;
- int level_width = WIDTH >> level;
- int level_height = HEIGHT >> level;
- float patch_spacing_pixels = patch_size_pixels * (1.0f - patch_overlap_ratio);
- int width_patches = 1 + lrintf((level_width - patch_size_pixels) / patch_spacing_pixels);
- int height_patches = 1 + lrintf((level_height - patch_size_pixels) / patch_spacing_pixels);
-
- // Make sure we always read from the correct level; the chosen
- // mipmapping could otherwise be rather unpredictable, especially
- // during motion search.
- GLuint tex0_view, tex1_view;
- glGenTextures(1, &tex0_view);
- glTextureView(tex0_view, GL_TEXTURE_2D, tex0, GL_R8, level, 1, 0, 1);
- glGenTextures(1, &tex1_view);
- glTextureView(tex1_view, GL_TEXTURE_2D, tex1, GL_R8, level, 1, 0, 1);
-
- // Compute gradients in every point, used for the motion search.
- // The DIS paper doesn't actually mention how these are computed,
- // but seemingly, a 3x3 Sobel operator is used here (at least in
- // later versions of the code), while a [1 -8 0 8 -1] kernel is
- // used for all the derivatives in the variational refinement part
- // (which borrows code from DeepFlow). This is inconsistent,
- // but I guess we're better off with staying with the original
- // decisions until we actually know having different ones would be better.
-
- // Create a new texture; we could be fancy and render use a multi-level
- // texture, but meh.
- GLuint grad0_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &grad0_tex);
- glTextureStorage2D(grad0_tex, 1, GL_RG16F, level_width, level_height);
-
- GLuint grad0_fbo;
- glCreateFramebuffers(1, &grad0_fbo);
- glNamedFramebufferTexture(grad0_fbo, GL_COLOR_ATTACHMENT0, grad0_tex, 0);
+ GLuint uniform_tex, uniform_image_size;
+};
- glUseProgram(sobel_program);
- glBindTextureUnit(0, tex0_view);
- glBindSampler(0, nearest_sampler);
- glProgramUniform1i(sobel_program, glGetUniformLocation(sobel_program, "tex"), 0);
- glProgramUniform1f(sobel_program, glGetUniformLocation(sobel_program, "inv_width"), 1.0f / level_width);
- glProgramUniform1f(sobel_program, glGetUniformLocation(sobel_program, "inv_height"), 1.0f / level_height);
+Sobel::Sobel()
+{
+ sobel_vs_obj = compile_shader(read_file("vs.vert"), GL_VERTEX_SHADER);
+ sobel_fs_obj = compile_shader(read_file("sobel.frag"), GL_FRAGMENT_SHADER);
+ sobel_program = link_program(sobel_vs_obj, sobel_fs_obj);
// Set up the VAO containing all the required position/texcoord data.
- GLuint sobel_vao;
glCreateVertexArrays(1, &sobel_vao);
glBindVertexArray(sobel_vao);
- float vertices[] = {
- 0.0f, 1.0f,
- 0.0f, 0.0f,
- 1.0f, 1.0f,
- 1.0f, 0.0f,
- };
- GLuint vertex_vbo;
- glCreateBuffers(1, &vertex_vbo);
- glNamedBufferData(vertex_vbo, sizeof(vertices), vertices, GL_STATIC_DRAW);
- glBindBuffer(GL_ARRAY_BUFFER, vertex_vbo);
- int position_attrib = glGetAttribLocation(sobel_program, "position");
+ GLint position_attrib = glGetAttribLocation(sobel_program, "position");
glEnableVertexArrayAttrib(sobel_vao, position_attrib);
glVertexAttribPointer(position_attrib, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
- int texcoord_attrib = glGetAttribLocation(sobel_program, "texcoord");
- glEnableVertexArrayAttrib(sobel_vao, texcoord_attrib);
- glVertexAttribPointer(texcoord_attrib, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
+ uniform_tex = glGetUniformLocation(sobel_program, "tex");
+}
- glBindBuffer(GL_ARRAY_BUFFER, 0);
+void Sobel::exec(GLint tex0_view, GLint grad0_tex, int level_width, int level_height)
+{
+ glUseProgram(sobel_program);
+ glBindTextureUnit(0, tex0_view);
+ glBindSampler(0, nearest_sampler);
+ glProgramUniform1i(sobel_program, uniform_tex, 0);
+
+ GLuint grad0_fbo; // TODO: cleanup
+ glCreateFramebuffers(1, &grad0_fbo);
+ glNamedFramebufferTexture(grad0_fbo, GL_COLOR_ATTACHMENT0, grad0_tex, 0);
- // Now finally draw.
glViewport(0, 0, level_width, level_height);
glBindFramebuffer(GL_FRAMEBUFFER, grad0_fbo);
+ glBindVertexArray(sobel_vao);
glUseProgram(sobel_program);
glDisable(GL_BLEND);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+}
- // Motion search to find the initial flow.
-
- // Create a flow texture, initialized to zero.
- GLuint flow_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &flow_tex);
- glTextureStorage2D(flow_tex, 1, GL_RG16F, width_patches, height_patches);
-
- // And an output flow texture. (Well, we could have used texture barriers,
- // but I don't feel lucky today.)
- GLuint flow_out_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &flow_out_tex);
- glTextureStorage2D(flow_out_tex, 1, GL_RG16F, width_patches, height_patches);
-
- GLuint flow_fbo;
- glCreateFramebuffers(1, &flow_fbo);
- glNamedFramebufferTexture(flow_fbo, GL_COLOR_ATTACHMENT0, flow_out_tex, 0);
-
- glUseProgram(motion_search_program);
+// Motion search to find the initial flow. See motion_search.frag for documentation.
+class MotionSearch {
+public:
+ MotionSearch();
+ void exec(GLuint tex0_view, GLuint tex1_view, GLuint grad0_tex, GLuint flow_tex, GLuint flow_out_tex, int level_width, int level_height, int width_patches, int height_patches);
- bind_sampler(motion_search_program, "image0_tex", 0, tex0_view, nearest_sampler);
- bind_sampler(motion_search_program, "image1_tex", 1, tex1_view, linear_sampler);
- bind_sampler(motion_search_program, "grad0_tex", 2, grad0_tex, nearest_sampler);
- bind_sampler(motion_search_program, "flow_tex", 3, flow_tex, nearest_sampler);
+private:
+ GLuint motion_vs_obj;
+ GLuint motion_fs_obj;
+ GLuint motion_search_program;
+ GLuint motion_search_vao;
- glProgramUniform1f(motion_search_program, glGetUniformLocation(motion_search_program, "image_width"), level_width);
- glProgramUniform1f(motion_search_program, glGetUniformLocation(motion_search_program, "image_height"), level_height);
- glProgramUniform1f(motion_search_program, glGetUniformLocation(motion_search_program, "inv_image_width"), 1.0f / level_width);
- glProgramUniform1f(motion_search_program, glGetUniformLocation(motion_search_program, "inv_image_height"), 1.0f / level_height);
+ GLuint uniform_image_size, uniform_inv_image_size;
+ GLuint uniform_image0_tex, uniform_image1_tex, uniform_grad0_tex, uniform_flow_tex;
+};
-// printf("%d x %d patches on this level\n", width_patches, height_patches);
+MotionSearch::MotionSearch()
+{
+ motion_vs_obj = compile_shader(read_file("motion_search.vert"), GL_VERTEX_SHADER);
+ motion_fs_obj = compile_shader(read_file("motion_search.frag"), GL_FRAGMENT_SHADER);
+ motion_search_program = link_program(motion_vs_obj, motion_fs_obj);
// Set up the VAO containing all the required position/texcoord data.
- GLuint motion_search_vao;
glCreateVertexArrays(1, &motion_search_vao);
glBindVertexArray(motion_search_vao);
glBindBuffer(GL_ARRAY_BUFFER, vertex_vbo);
- position_attrib = glGetAttribLocation(motion_search_program, "position");
+ GLint position_attrib = glGetAttribLocation(motion_search_program, "position");
glEnableVertexArrayAttrib(motion_search_vao, position_attrib);
glVertexAttribPointer(position_attrib, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
- texcoord_attrib = glGetAttribLocation(motion_search_program, "texcoord");
- glEnableVertexArrayAttrib(motion_search_vao, texcoord_attrib);
- glVertexAttribPointer(texcoord_attrib, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
+ uniform_image_size = glGetUniformLocation(motion_search_program, "image_size");
+ uniform_inv_image_size = glGetUniformLocation(motion_search_program, "inv_image_size");
+ uniform_image0_tex = glGetUniformLocation(motion_search_program, "image0_tex");
+ uniform_image1_tex = glGetUniformLocation(motion_search_program, "image1_tex");
+ uniform_grad0_tex = glGetUniformLocation(motion_search_program, "grad0_tex");
+ uniform_flow_tex = glGetUniformLocation(motion_search_program, "flow_tex");
+}
- glBindBuffer(GL_ARRAY_BUFFER, 0);
+void MotionSearch::exec(GLuint tex0_view, GLuint tex1_view, GLuint grad0_tex, GLuint flow_tex, GLuint flow_out_tex, int level_width, int level_height, int width_patches, int height_patches)
+{
+ glUseProgram(motion_search_program);
+
+ bind_sampler(motion_search_program, uniform_image0_tex, 0, tex0_view, nearest_sampler);
+ bind_sampler(motion_search_program, uniform_image1_tex, 1, tex1_view, linear_sampler);
+ bind_sampler(motion_search_program, uniform_grad0_tex, 2, grad0_tex, nearest_sampler);
+ bind_sampler(motion_search_program, uniform_flow_tex, 3, flow_tex, linear_sampler);
+
+ glProgramUniform2f(motion_search_program, uniform_image_size, level_width, level_height);
+ glProgramUniform2f(motion_search_program, uniform_inv_image_size, 1.0f / level_width, 1.0f / level_height);
+
+ GLuint flow_fbo; // TODO: cleanup
+ glCreateFramebuffers(1, &flow_fbo);
+ glNamedFramebufferTexture(flow_fbo, GL_COLOR_ATTACHMENT0, flow_out_tex, 0);
- // And draw.
glViewport(0, 0, width_patches, height_patches);
glBindFramebuffer(GL_FRAMEBUFFER, flow_fbo);
+ glBindVertexArray(motion_search_vao);
glUseProgram(motion_search_program);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+}
- // Do “densification”, ie., upsampling of the flow patches to the flow field
- // (the same size as the image at this level). We draw one quad per patch
- // over its entire covered area (using instancing in the vertex shader),
- // and then weight the contributions in the pixel shader by post-warp difference.
- // This is equation (3) in the paper.
- //
- // We accumulate the flow vectors in the R/G channels (for u/v) and the total
- // weight in the B channel. Dividing R and G by B gives the normalized values.
-
- // Set up an output texture.
- GLuint dense_flow_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &dense_flow_tex);
- //glTextureStorage2D(dense_flow_tex, 1, GL_RGB16F, level_width, level_height);
- glTextureStorage2D(dense_flow_tex, 1, GL_RGBA32F, level_width, level_height);
-
- GLuint dense_flow_fbo;
- glCreateFramebuffers(1, &dense_flow_fbo);
- glNamedFramebufferTexture(dense_flow_fbo, GL_COLOR_ATTACHMENT0, dense_flow_tex, 0);
+// Do “densification”, ie., upsampling of the flow patches to the flow field
+// (the same size as the image at this level). We draw one quad per patch
+// over its entire covered area (using instancing in the vertex shader),
+// and then weight the contributions in the pixel shader by post-warp difference.
+// This is equation (3) in the paper.
+//
+// We accumulate the flow vectors in the R/G channels (for u/v) and the total
+// weight in the B channel. Dividing R and G by B gives the normalized values.
+class Densify {
+public:
+ Densify();
+ void exec(GLuint tex0_view, GLuint tex1_view, GLuint flow_tex, GLuint dense_flow_tex, int level_width, int level_height, int width_patches, int height_patches);
+
+private:
+ GLuint densify_vs_obj;
+ GLuint densify_fs_obj;
+ GLuint densify_program;
+ GLuint densify_vao;
+
+ GLuint uniform_width_patches, uniform_patch_size, uniform_patch_spacing;
+ GLuint uniform_image0_tex, uniform_image1_tex, uniform_flow_tex;
+};
+Densify::Densify()
+{
+ densify_vs_obj = compile_shader(read_file("densify.vert"), GL_VERTEX_SHADER);
+ densify_fs_obj = compile_shader(read_file("densify.frag"), GL_FRAGMENT_SHADER);
+ densify_program = link_program(densify_vs_obj, densify_fs_obj);
+
+ // Set up the VAO containing all the required position/texcoord data.
+ glCreateVertexArrays(1, &densify_vao);
+ glBindVertexArray(densify_vao);
+ glBindBuffer(GL_ARRAY_BUFFER, vertex_vbo);
+
+ GLint position_attrib = glGetAttribLocation(densify_program, "position");
+ glEnableVertexArrayAttrib(densify_vao, position_attrib);
+ glVertexAttribPointer(position_attrib, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
+
+ uniform_width_patches = glGetUniformLocation(densify_program, "width_patches");
+ uniform_patch_size = glGetUniformLocation(densify_program, "patch_size");
+ uniform_patch_spacing = glGetUniformLocation(densify_program, "patch_spacing");
+ uniform_image0_tex = glGetUniformLocation(densify_program, "image0_tex");
+ uniform_image1_tex = glGetUniformLocation(densify_program, "image1_tex");
+ uniform_flow_tex = glGetUniformLocation(densify_program, "flow_tex");
+}
+
+void Densify::exec(GLuint tex0_view, GLuint tex1_view, GLuint flow_tex, GLuint dense_flow_tex, int level_width, int level_height, int width_patches, int height_patches)
+{
glUseProgram(densify_program);
- bind_sampler(densify_program, "image0_tex", 0, tex0_view, nearest_sampler);
- bind_sampler(densify_program, "image1_tex", 1, tex1_view, linear_sampler);
- bind_sampler(densify_program, "flow_tex", 2, flow_out_tex, nearest_sampler);
+ bind_sampler(densify_program, uniform_image0_tex, 0, tex0_view, nearest_sampler);
+ bind_sampler(densify_program, uniform_image1_tex, 1, tex1_view, linear_sampler);
+ bind_sampler(densify_program, uniform_flow_tex, 2, flow_tex, nearest_sampler);
- glProgramUniform1i(densify_program, glGetUniformLocation(densify_program, "width_patches"), width_patches);
- glProgramUniform2f(densify_program, glGetUniformLocation(densify_program, "patch_size"),
+ glProgramUniform1i(densify_program, uniform_width_patches, width_patches);
+ glProgramUniform2f(densify_program, uniform_patch_size,
float(patch_size_pixels) / level_width,
float(patch_size_pixels) / level_height);
float patch_spacing_x = float(level_width - patch_size_pixels) / (width_patches - 1);
float patch_spacing_y = float(level_height - patch_size_pixels) / (height_patches - 1);
- glProgramUniform2f(densify_program, glGetUniformLocation(densify_program, "patch_spacing"),
+ glProgramUniform2f(densify_program, uniform_patch_spacing,
patch_spacing_x / level_width,
patch_spacing_y / level_height);
- // Set up the VAO containing all the required position/texcoord data.
- GLuint densify_vao;
- glCreateVertexArrays(1, &densify_vao);
+ GLuint dense_flow_fbo; // TODO: cleanup
+ glCreateFramebuffers(1, &dense_flow_fbo);
+ glNamedFramebufferTexture(dense_flow_fbo, GL_COLOR_ATTACHMENT0, dense_flow_tex, 0);
+
+ glViewport(0, 0, level_width, level_height);
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_ONE, GL_ONE);
glBindVertexArray(densify_vao);
+ glBindFramebuffer(GL_FRAMEBUFFER, dense_flow_fbo);
+ glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, width_patches * height_patches);
+}
+
+// Warp I_1 to I_w, and then compute the mean (I) and difference (I_t) of
+// I_0 and I_w. The prewarping is what enables us to solve the variational
+// flow for du,dv instead of u,v.
+//
+// See variational_refinement.txt for more information.
+class Prewarp {
+public:
+ Prewarp();
+ void exec(GLuint tex0_view, GLuint tex1_view, GLuint flow_tex, GLuint I_tex, GLuint I_t_tex, int level_width, int level_height);
+
+private:
+ GLuint prewarp_vs_obj;
+ GLuint prewarp_fs_obj;
+ GLuint prewarp_program;
+ GLuint prewarp_vao;
+
+ GLuint uniform_image0_tex, uniform_image1_tex, uniform_flow_tex;
+};
+
+Prewarp::Prewarp()
+{
+ prewarp_vs_obj = compile_shader(read_file("vs.vert"), GL_VERTEX_SHADER);
+ prewarp_fs_obj = compile_shader(read_file("prewarp.frag"), GL_FRAGMENT_SHADER);
+ prewarp_program = link_program(prewarp_vs_obj, prewarp_fs_obj);
+
+ // Set up the VAO containing all the required position/texcoord data.
+ glCreateVertexArrays(1, &prewarp_vao);
+ glBindVertexArray(prewarp_vao);
glBindBuffer(GL_ARRAY_BUFFER, vertex_vbo);
- position_attrib = glGetAttribLocation(densify_program, "position");
- glEnableVertexArrayAttrib(densify_vao, position_attrib);
+ GLint position_attrib = glGetAttribLocation(prewarp_program, "position");
+ glEnableVertexArrayAttrib(prewarp_vao, position_attrib);
glVertexAttribPointer(position_attrib, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
- glBindBuffer(GL_ARRAY_BUFFER, 0);
+ uniform_image0_tex = glGetUniformLocation(prewarp_program, "image0_tex");
+ uniform_image1_tex = glGetUniformLocation(prewarp_program, "image1_tex");
+ uniform_flow_tex = glGetUniformLocation(prewarp_program, "flow_tex");
+}
+
+void Prewarp::exec(GLuint tex0_view, GLuint tex1_view, GLuint flow_tex, GLuint I_tex, GLuint I_t_tex, int level_width, int level_height)
+{
+ glUseProgram(prewarp_program);
+
+ bind_sampler(prewarp_program, uniform_image0_tex, 0, tex0_view, nearest_sampler);
+ bind_sampler(prewarp_program, uniform_image1_tex, 1, tex1_view, linear_sampler);
+ bind_sampler(prewarp_program, uniform_flow_tex, 2, flow_tex, nearest_sampler);
+
+ GLuint prewarp_fbo; // TODO: cleanup
+ glCreateFramebuffers(1, &prewarp_fbo);
+ GLenum bufs[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
+ glNamedFramebufferDrawBuffers(prewarp_fbo, 2, bufs);
+ glNamedFramebufferTexture(prewarp_fbo, GL_COLOR_ATTACHMENT0, I_tex, 0);
+ glNamedFramebufferTexture(prewarp_fbo, GL_COLOR_ATTACHMENT1, I_t_tex, 0);
- // And draw.
glViewport(0, 0, level_width, level_height);
- glEnable(GL_BLEND);
- glBlendFunc(GL_ONE, GL_ONE);
- glBindFramebuffer(GL_FRAMEBUFFER, dense_flow_fbo);
- glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, width_patches * height_patches);
+ glDisable(GL_BLEND);
+ glBindVertexArray(prewarp_vao);
+ glBindFramebuffer(GL_FRAMEBUFFER, prewarp_fbo);
+ glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+}
+
+// From I, calculate the partial derivatives I_x and I_y. We use a four-tap
+// central difference filter, since apparently, that's tradition (I haven't
+// measured quality versus a more normal 0.5 (I[x+1] - I[x-1]).)
+// The coefficients come from
+//
+// https://en.wikipedia.org/wiki/Finite_difference_coefficient
+class Derivatives {
+public:
+ Derivatives();
+ void exec(GLuint input_tex, GLuint output_tex, int level_width, int level_height);
+
+private:
+ GLuint derivatives_vs_obj;
+ GLuint derivatives_fs_obj;
+ GLuint derivatives_program;
+ GLuint derivatives_vao;
+
+ GLuint uniform_tex;
+};
+
+Derivatives::Derivatives()
+{
+ derivatives_vs_obj = compile_shader(read_file("vs.vert"), GL_VERTEX_SHADER);
+ derivatives_fs_obj = compile_shader(read_file("derivatives.frag"), GL_FRAGMENT_SHADER);
+ derivatives_program = link_program(derivatives_vs_obj, derivatives_fs_obj);
+
+ // Set up the VAO containing all the required position/texcoord data.
+ glCreateVertexArrays(1, &derivatives_vao);
+ glBindVertexArray(derivatives_vao);
+ glBindBuffer(GL_ARRAY_BUFFER, vertex_vbo);
+
+ GLint position_attrib = glGetAttribLocation(derivatives_program, "position");
+ glEnableVertexArrayAttrib(derivatives_vao, position_attrib);
+ glVertexAttribPointer(position_attrib, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
+
+ uniform_tex = glGetUniformLocation(derivatives_program, "tex");
+}
- // TODO: Variational refinement.
+void Derivatives::exec(GLuint input_tex, GLuint output_tex, int level_width, int level_height)
+{
+ glUseProgram(derivatives_program);
+ bind_sampler(derivatives_program, uniform_tex, 0, input_tex, nearest_sampler);
+
+ GLuint derivatives_fbo; // TODO: cleanup
+ glCreateFramebuffers(1, &derivatives_fbo);
+ glNamedFramebufferTexture(derivatives_fbo, GL_COLOR_ATTACHMENT0, output_tex, 0);
+
+ glViewport(0, 0, level_width, level_height);
+ glDisable(GL_BLEND);
+ glBindVertexArray(derivatives_vao);
+ glBindFramebuffer(GL_FRAMEBUFFER, derivatives_fbo);
+ glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+}
+
+int main(void)
+{
+ if (SDL_Init(SDL_INIT_EVERYTHING) == -1) {
+ fprintf(stderr, "SDL_Init failed: %s\n", SDL_GetError());
+ exit(1);
+ }
+ SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+ SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
+ SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
+ SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
+ // SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
+ SDL_Window *window = SDL_CreateWindow("OpenGL window",
+ SDL_WINDOWPOS_UNDEFINED,
+ SDL_WINDOWPOS_UNDEFINED,
+ 64, 64,
+ SDL_WINDOW_OPENGL);
+ SDL_GLContext context = SDL_GL_CreateContext(window);
+ assert(context != nullptr);
+
+ // Load pictures.
+ GLuint tex0 = load_texture("test1499.pgm", WIDTH, HEIGHT);
+ GLuint tex1 = load_texture("test1500.pgm", WIDTH, HEIGHT);
+
+ // Make some samplers.
+ glCreateSamplers(1, &nearest_sampler);
+ glSamplerParameteri(nearest_sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glSamplerParameteri(nearest_sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glSamplerParameteri(nearest_sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glSamplerParameteri(nearest_sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+ glCreateSamplers(1, &linear_sampler);
+ glSamplerParameteri(linear_sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ glSamplerParameteri(linear_sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glSamplerParameteri(linear_sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glSamplerParameteri(linear_sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+ float vertices[] = {
+ 0.0f, 1.0f,
+ 0.0f, 0.0f,
+ 1.0f, 1.0f,
+ 1.0f, 0.0f,
+ };
+ glCreateBuffers(1, &vertex_vbo);
+ glNamedBufferData(vertex_vbo, sizeof(vertices), vertices, GL_STATIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, vertex_vbo);
+
+ // Initial flow is zero, 1x1.
+ GLuint initial_flow_tex;
+ glCreateTextures(GL_TEXTURE_2D, 1, &initial_flow_tex);
+ glTextureStorage2D(initial_flow_tex, 1, GL_RGB32F, 1, 1);
+
+ GLuint prev_level_flow_tex = initial_flow_tex;
+
+ Sobel sobel;
+ MotionSearch motion_search;
+ Densify densify;
+ Prewarp prewarp;
+ Derivatives derivatives;
+
+ GLuint query;
+ glGenQueries(1, &query);
+ glBeginQuery(GL_TIME_ELAPSED, query);
+
+ for (int level = coarsest_level; level >= int(finest_level); --level) {
+ int level_width = WIDTH >> level;
+ int level_height = HEIGHT >> level;
+ float patch_spacing_pixels = patch_size_pixels * (1.0f - patch_overlap_ratio);
+ int width_patches = 1 + lrintf((level_width - patch_size_pixels) / patch_spacing_pixels);
+ int height_patches = 1 + lrintf((level_height - patch_size_pixels) / patch_spacing_pixels);
+
+ // Make sure we always read from the correct level; the chosen
+ // mipmapping could otherwise be rather unpredictable, especially
+ // during motion search.
+ // TODO: create these beforehand, and stop leaking them.
+ GLuint tex0_view, tex1_view;
+ glGenTextures(1, &tex0_view);
+ glTextureView(tex0_view, GL_TEXTURE_2D, tex0, GL_R8, level, 1, 0, 1);
+ glGenTextures(1, &tex1_view);
+ glTextureView(tex1_view, GL_TEXTURE_2D, tex1, GL_R8, level, 1, 0, 1);
+
+ // Create a new texture; we could be fancy and render use a multi-level
+ // texture, but meh.
+ GLuint grad0_tex;
+ glCreateTextures(GL_TEXTURE_2D, 1, &grad0_tex);
+ glTextureStorage2D(grad0_tex, 1, GL_RG16F, level_width, level_height);
+
+ // Find the derivative.
+ sobel.exec(tex0_view, grad0_tex, level_width, level_height);
+
+ // Motion search to find the initial flow. We use the flow from the previous
+ // level (sampled bilinearly; no fancy tricks) as a guide, then search from there.
+
+ // Create an output flow texture.
+ GLuint flow_out_tex;
+ glCreateTextures(GL_TEXTURE_2D, 1, &flow_out_tex);
+ glTextureStorage2D(flow_out_tex, 1, GL_RGB16F, width_patches, height_patches);
+
+ // And draw.
+ motion_search.exec(tex0_view, tex1_view, grad0_tex, prev_level_flow_tex, flow_out_tex, level_width, level_height, width_patches, height_patches);
+
+ // Densification.
+
+ // Set up an output texture (initially zero).
+ GLuint dense_flow_tex;
+ glCreateTextures(GL_TEXTURE_2D, 1, &dense_flow_tex);
+ glTextureStorage2D(dense_flow_tex, 1, GL_RGB16F, level_width, level_height);
+
+ // And draw.
+ densify.exec(tex0_view, tex1_view, flow_out_tex, dense_flow_tex, level_width, level_height, width_patches, height_patches);
+
+ // Everything below here in the loop belongs to variational refinement.
+ // It is not done yet.
+
+ // Prewarping; create I and I_t.
+ GLuint I_tex, I_t_tex;
+ glCreateTextures(GL_TEXTURE_2D, 1, &I_tex);
+ glCreateTextures(GL_TEXTURE_2D, 1, &I_t_tex);
+ glTextureStorage2D(I_tex, 1, GL_R16F, level_width, level_height);
+ glTextureStorage2D(I_t_tex, 1, GL_R16F, level_width, level_height);
+ prewarp.exec(tex0_view, tex1_view, dense_flow_tex, I_tex, I_t_tex, level_width, level_height);
+
+ // Derivatives of the images. We're only calculating first derivatives;
+ // the others will be taken on-the-fly in order to sample from fewer
+ // textures overall, since sampling from the L1 cache is cheap.
+ // (TODO: Verify that this is indeed faster than making separate
+ // double-derivative textures.)
+
+ // Calculate I_x and I_y.
+ GLuint I_x_y_tex;
+ glCreateTextures(GL_TEXTURE_2D, 1, &I_x_y_tex);
+ glTextureStorage2D(I_x_y_tex, 1, GL_RG16F, level_width, level_height);
+ derivatives.exec(I_tex, I_x_y_tex, level_width, level_height);
+
+ prev_level_flow_tex = dense_flow_tex;
+ }
+ glEndQuery(GL_TIME_ELAPSED);
+
+ GLint available;
+ do {
+ glGetQueryObjectiv(query, GL_QUERY_RESULT_AVAILABLE, &available);
+ usleep(1000);
+ } while (!available);
+ GLuint64 time_elapsed;
+ glGetQueryObjectui64v(query, GL_QUERY_RESULT, &time_elapsed);
+ fprintf(stderr, "GPU time used = %.1f ms\n", time_elapsed / 1e6);
+
+ int level_width = WIDTH >> finest_level;
+ int level_height = HEIGHT >> finest_level;
unique_ptr<float[]> dense_flow(new float[level_width * level_height * 3]);
- glGetTextureImage(dense_flow_tex, 0, GL_RGB, GL_FLOAT, level_width * level_height * 3 * sizeof(float), dense_flow.get());
+ glGetTextureImage(prev_level_flow_tex, 0, GL_RGB, GL_FLOAT, level_width * level_height * 3 * sizeof(float), dense_flow.get());
FILE *fp = fopen("flow.ppm", "wb");
+ FILE *flowfp = fopen("flow.flo", "wb");
fprintf(fp, "P6\n%d %d\n255\n", level_width, level_height);
- for (unsigned y = 0; y < level_height; ++y) {
+ fprintf(flowfp, "FEIH");
+ fwrite(&level_width, 4, 1, flowfp);
+ fwrite(&level_height, 4, 1, flowfp);
+ for (unsigned y = 0; y < unsigned(level_height); ++y) {
int yy = level_height - y - 1;
- for (unsigned x = 0; x < level_width; ++x) {
+ for (unsigned x = 0; x < unsigned(level_width); ++x) {
float du = dense_flow[(yy * level_width + x) * 3 + 0];
float dv = dense_flow[(yy * level_width + x) * 3 + 1];
float w = dense_flow[(yy * level_width + x) * 3 + 2];
- du /= w;
- dv /= w;
-
- float angle = atan2(dv * level_width, du * level_height);
- float magnitude = min(hypot(du * level_width, dv * level_height) / 20.0, 1.0);
-
- // HSV to RGB (from Wikipedia). Saturation is 1.
- float c = magnitude;
- float h = (angle + M_PI) * 6.0 / (2.0 * M_PI);
- float X = c * (1.0 - fabs(fmod(h, 2.0) - 1.0));
- float r = 0.0f, g = 0.0f, b = 0.0f;
- if (h < 1.0f) {
- r = c; g = X;
- } else if (h < 2.0f) {
- r = X; g = c;
- } else if (h < 3.0f) {
- g = c; b = X;
- } else if (h < 4.0f) {
- g = X; b = c;
- } else if (h < 5.0f) {
- r = X; b = c;
- } else if (h < 6.0f) {
- r = c; b = X;
- } else {
- // h is NaN, so black is fine.
- }
- float m = magnitude - c;
- r += m; g += m; b += m;
- r = max(min(r, 1.0f), 0.0f);
- g = max(min(g, 1.0f), 0.0f);
- b = max(min(b, 1.0f), 0.0f);
- putc(lrintf(r * 255.0f), fp);
- putc(lrintf(g * 255.0f), fp);
- putc(lrintf(b * 255.0f), fp);
+ du = (du / w) * level_width;
+ dv = (-dv / w) * level_height;
+
+ fwrite(&du, 4, 1, flowfp);
+ fwrite(&dv, 4, 1, flowfp);
+
+ uint8_t r, g, b;
+ flow2rgb(du, dv, &r, &g, &b);
+ putc(r, fp);
+ putc(g, fp);
+ putc(b, fp);
}
}
fclose(fp);
+ fclose(flowfp);
fprintf(stderr, "err = %d\n", glGetError());
}