// since we have different normalizations and ranges in some cases.
float vr_gamma = 10.0f, vr_delta = 5.0f, vr_alpha = 10.0f;
+bool enable_timing = true;
+
// Some global OpenGL objects.
+// TODO: These should really be part of DISComputeFlow.
GLuint nearest_sampler, linear_sampler, smoothness_sampler;
GLuint vertex_vbo;
pair<GLuint, GLuint> GPUTimers::begin_timer(const string &name, int level)
{
+ if (!enable_timing) {
+ return make_pair(0, 0);
+ }
+
GLuint queries[2];
glGenQueries(2, queries);
glQueryCounter(queries[0], GL_TIMESTAMP);
void end()
{
- if (!ended) {
+ if (enable_timing && !ended) {
glQueryCounter(query.second, GL_TIMESTAMP);
ended = true;
}
bool ended = false;
};
-int main(int argc, char **argv)
-{
- static const option long_options[] = {
- { "alpha", required_argument, 0, 'a' },
- { "delta", required_argument, 0, 'd' },
- { "gamma", required_argument, 0, 'g' }
- };
+class DISComputeFlow {
+public:
+ DISComputeFlow(int width, int height);
- for ( ;; ) {
- int option_index = 0;
- int c = getopt_long(argc, argv, "a:d:g:", long_options, &option_index);
+ // Returns a texture that must be released with release_texture()
+ // after use.
+ GLuint exec(GLuint tex0, GLuint tex1);
+ void release_texture(GLuint tex);
- if (c == -1) {
- break;
- }
- switch (c) {
- case 'a':
- vr_alpha = atof(optarg);
- break;
- case 'd':
- vr_delta = atof(optarg);
- break;
- case 'g':
- vr_gamma = atof(optarg);
- break;
- default:
- fprintf(stderr, "Unknown option '%s'\n", argv[option_index]);
- exit(1);
- };
- }
-
- 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);
+private:
+ int width, height;
+ GLuint initial_flow_tex;
- 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);
+ // The various passes.
+ Sobel sobel;
+ MotionSearch motion_search;
+ Densify densify;
+ Prewarp prewarp;
+ Derivatives derivatives;
+ ComputeSmoothness compute_smoothness;
+ SetupEquations setup_equations;
+ SOR sor;
+ AddBaseFlow add_base_flow;
+ ResizeFlow resize_flow;
- // Load pictures.
- unsigned width1, height1, width2, height2;
- GLuint tex0 = load_texture(argc >= (optind + 1) ? argv[optind] : "test1499.png", &width1, &height1);
- GLuint tex1 = load_texture(argc >= (optind + 2) ? argv[optind + 1] : "test1500.png", &width2, &height2);
+ struct Texture {
+ GLuint tex_num;
+ GLenum format;
+ GLuint width, height;
+ bool in_use = false;
+ };
+ vector<Texture> textures;
- if (width1 != width2 || height1 != height2) {
- fprintf(stderr, "Image dimensions don't match (%dx%d versus %dx%d)\n",
- width1, height1, width2, height2);
- exit(1);
- }
+ GLuint get_texture(GLenum format, GLuint width, GLuint height);
+};
+DISComputeFlow::DISComputeFlow(int width, int height)
+ : width(width), height(height)
+{
// Make some samplers.
glCreateSamplers(1, &nearest_sampler);
glSamplerParameteri(nearest_sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
float zero[] = { 0.0f, 0.0f, 0.0f, 0.0f };
glSamplerParameterfv(smoothness_sampler, GL_TEXTURE_BORDER_COLOR, zero);
- 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_RG16F, 1, 1);
glClearTexImage(initial_flow_tex, 0, GL_RG, GL_FLOAT, nullptr);
- int prev_level_width = 1, prev_level_height = 1;
-
- GLuint prev_level_flow_tex = initial_flow_tex;
+}
- Sobel sobel;
- MotionSearch motion_search;
- Densify densify;
- Prewarp prewarp;
- Derivatives derivatives;
- ComputeSmoothness compute_smoothness;
- SetupEquations setup_equations;
- SOR sor;
- AddBaseFlow add_base_flow;
- ResizeFlow resize_flow;
+GLuint DISComputeFlow::exec(GLuint tex0, GLuint tex1)
+{
+ for (const Texture &tex : textures) {
+ assert(!tex.in_use);
+ }
- GLuint query;
- glGenQueries(1, &query);
- glBeginQuery(GL_TIME_ELAPSED, query);
+ int prev_level_width = 1, prev_level_height = 1;
+ GLuint prev_level_flow_tex = initial_flow_tex;
GPUTimers timers;
snprintf(timer_name, sizeof(timer_name), "Level %d", level);
ScopedTimer level_timer(timer_name, &total_timer);
- int level_width = width1 >> level;
- int level_height = height1 >> 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);
// 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_tex = get_texture(GL_RG16F, level_width, level_height);
// Find the derivative.
{
// 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);
+ GLuint flow_out_tex = get_texture(GL_RGB16F, width_patches, height_patches);
// And draw.
{
ScopedTimer timer("Motion search", &level_timer);
motion_search.exec(tex0_view, tex1_view, grad0_tex, prev_level_flow_tex, flow_out_tex, level_width, level_height, prev_level_width, prev_level_height, width_patches, height_patches);
}
+ release_texture(grad0_tex);
// 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);
+ GLuint dense_flow_tex = get_texture(GL_RGB16F, level_width, level_height);
glClearTexImage(dense_flow_tex, 0, GL_RGB, GL_FLOAT, nullptr);
// And draw.
ScopedTimer timer("Densification", &level_timer);
densify.exec(tex0_view, tex1_view, flow_out_tex, dense_flow_tex, level_width, level_height, width_patches, height_patches);
}
+ release_texture(flow_out_tex);
// Everything below here in the loop belongs to variational refinement.
ScopedTimer varref_timer("Variational refinement", &level_timer);
// in pixels, not 0..1 normalized OpenGL texture coordinates.
// This is because variational refinement depends so heavily on derivatives,
// which are measured in intensity levels per pixel.
- GLuint I_tex, I_t_tex, base_flow_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &I_tex);
- glCreateTextures(GL_TEXTURE_2D, 1, &I_t_tex);
- glCreateTextures(GL_TEXTURE_2D, 1, &base_flow_tex);
- glTextureStorage2D(I_tex, 1, GL_R16F, level_width, level_height);
- glTextureStorage2D(I_t_tex, 1, GL_R16F, level_width, level_height);
- glTextureStorage2D(base_flow_tex, 1, GL_RG16F, level_width, level_height);
+ GLuint I_tex = get_texture(GL_R16F, level_width, level_height);
+ GLuint I_t_tex = get_texture(GL_R16F, level_width, level_height);
+ GLuint base_flow_tex = get_texture(GL_RG16F, level_width, level_height);
{
ScopedTimer timer("Prewarping", &varref_timer);
prewarp.exec(tex0_view, tex1_view, dense_flow_tex, I_tex, I_t_tex, base_flow_tex, level_width, level_height);
}
+ release_texture(dense_flow_tex);
// Calculate I_x and I_y. 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.)
- GLuint I_x_y_tex, beta_0_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &I_x_y_tex);
- glCreateTextures(GL_TEXTURE_2D, 1, &beta_0_tex);
- glTextureStorage2D(I_x_y_tex, 1, GL_RG16F, level_width, level_height);
- glTextureStorage2D(beta_0_tex, 1, GL_R16F, level_width, level_height);
+ GLuint I_x_y_tex = get_texture(GL_RG16F, level_width, level_height);
+ GLuint beta_0_tex = get_texture(GL_R16F, level_width, level_height);
{
ScopedTimer timer("First derivatives", &varref_timer);
derivatives.exec(I_tex, I_x_y_tex, beta_0_tex, level_width, level_height);
}
+ release_texture(I_tex);
// We need somewhere to store du and dv (the flow increment, relative
// to the non-refined base flow u0 and v0). It starts at zero.
- GLuint du_dv_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &du_dv_tex);
- glTextureStorage2D(du_dv_tex, 1, GL_RG16F, level_width, level_height);
+ GLuint du_dv_tex = get_texture(GL_RG16F, level_width, level_height);
glClearTexImage(du_dv_tex, 0, GL_RG, GL_FLOAT, nullptr);
// And for smoothness.
- GLuint smoothness_x_tex, smoothness_y_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &smoothness_x_tex);
- glCreateTextures(GL_TEXTURE_2D, 1, &smoothness_y_tex);
- glTextureStorage2D(smoothness_x_tex, 1, GL_R16F, level_width, level_height);
- glTextureStorage2D(smoothness_y_tex, 1, GL_R16F, level_width, level_height);
+ GLuint smoothness_x_tex = get_texture(GL_R16F, level_width, level_height);
+ GLuint smoothness_y_tex = get_texture(GL_R16F, level_width, level_height);
// And finally for the equation set. See SetupEquations for
// the storage format.
- GLuint equation_tex;
- glCreateTextures(GL_TEXTURE_2D, 1, &equation_tex);
- glTextureStorage2D(equation_tex, 1, GL_RGBA32UI, level_width, level_height);
+ GLuint equation_tex = get_texture(GL_RGBA32UI, level_width, level_height);
for (int outer_idx = 0; outer_idx < level + 1; ++outer_idx) {
// Calculate the smoothness terms between the neighboring pixels,
}
}
+ release_texture(I_t_tex);
+ release_texture(I_x_y_tex);
+ release_texture(beta_0_tex);
+ release_texture(smoothness_x_tex);
+ release_texture(smoothness_y_tex);
+ release_texture(equation_tex);
+
// Add the differential flow found by the variational refinement to the base flow,
// giving the final flow estimate for this level.
// The output is in diff_flow_tex; we don't need to make a new texture.
ScopedTimer timer("Add differential flow", &varref_timer);
add_base_flow.exec(base_flow_tex, du_dv_tex, level_width, level_height);
}
+ release_texture(du_dv_tex);
+ if (prev_level_flow_tex != initial_flow_tex) {
+ release_texture(prev_level_flow_tex);
+ }
prev_level_flow_tex = base_flow_tex;
prev_level_width = level_width;
prev_level_height = level_height;
timers.print();
// Scale up the flow to the final size (if needed).
- GLuint final_tex;
if (finest_level == 0) {
- final_tex = prev_level_flow_tex;
+ return prev_level_flow_tex;
} else {
- glCreateTextures(GL_TEXTURE_2D, 1, &final_tex);
- glTextureStorage2D(final_tex, 1, GL_RG16F, width1, height1);
- resize_flow.exec(prev_level_flow_tex, final_tex, prev_level_width, prev_level_height, width1, height1);
+ GLuint final_tex = get_texture(GL_RG16F, width, height);
+ resize_flow.exec(prev_level_flow_tex, final_tex, prev_level_width, prev_level_height, width, height);
+ release_texture(prev_level_flow_tex);
+ return final_tex;
}
+}
- unique_ptr<float[]> dense_flow(new float[width1 * height1 * 2]);
- glGetTextureImage(final_tex, 0, GL_RG, GL_FLOAT, width1 * height1 * 2 * sizeof(float), dense_flow.get());
+GLuint DISComputeFlow::get_texture(GLenum format, GLuint width, GLuint height)
+{
+ for (Texture &tex : textures) {
+ if (!tex.in_use && tex.format == format &&
+ tex.width == width && tex.height == height) {
+ tex.in_use = true;
+ return tex.tex_num;
+ }
+ }
- FILE *fp = fopen("flow.ppm", "wb");
- FILE *flowfp = fopen("flow.flo", "wb");
- fprintf(fp, "P6\n%d %d\n255\n", width1, height1);
+ Texture tex;
+ glCreateTextures(GL_TEXTURE_2D, 1, &tex.tex_num);
+ glTextureStorage2D(tex.tex_num, 1, format, width, height);
+ tex.format = format;
+ tex.width = width;
+ tex.height = height;
+ tex.in_use = true;
+ textures.push_back(tex);
+ return tex.tex_num;
+}
+
+void DISComputeFlow::release_texture(GLuint tex_num)
+{
+ for (Texture &tex : textures) {
+ if (tex.tex_num == tex_num) {
+ assert(tex.in_use);
+ tex.in_use = false;
+ return;
+ }
+ }
+ assert(false);
+}
+
+void write_flow(const char *filename, const float *dense_flow, unsigned width, unsigned height)
+{
+ FILE *flowfp = fopen(filename, "wb");
fprintf(flowfp, "FEIH");
- fwrite(&width1, 4, 1, flowfp);
- fwrite(&height1, 4, 1, flowfp);
- for (unsigned y = 0; y < unsigned(height1); ++y) {
- int yy = height1 - y - 1;
- for (unsigned x = 0; x < unsigned(width1); ++x) {
- float du = dense_flow[(yy * width1 + x) * 2 + 0];
- float dv = dense_flow[(yy * width1 + x) * 2 + 1];
+ fwrite(&width, 4, 1, flowfp);
+ fwrite(&height, 4, 1, flowfp);
+ for (unsigned y = 0; y < height; ++y) {
+ int yy = height - y - 1;
+ for (unsigned x = 0; x < unsigned(width); ++x) {
+ float du = dense_flow[(yy * width + x) * 2 + 0];
+ float dv = dense_flow[(yy * width + x) * 2 + 1];
dv = -dv;
fwrite(&du, 4, 1, flowfp);
fwrite(&dv, 4, 1, flowfp);
+ }
+ }
+ fclose(flowfp);
+}
+
+void write_ppm(const char *filename, const float *dense_flow, unsigned width, unsigned height)
+{
+ FILE *fp = fopen(filename, "wb");
+ fprintf(fp, "P6\n%d %d\n255\n", width, height);
+ for (unsigned y = 0; y < unsigned(height); ++y) {
+ int yy = height - y - 1;
+ for (unsigned x = 0; x < unsigned(width); ++x) {
+ float du = dense_flow[(yy * width + x) * 2 + 0];
+ float dv = dense_flow[(yy * width + x) * 2 + 1];
+
+ dv = -dv;
uint8_t r, g, b;
flow2rgb(du, dv, &r, &g, &b);
}
}
fclose(fp);
- fclose(flowfp);
+}
+
+int main(int argc, char **argv)
+{
+ static const option long_options[] = {
+ { "alpha", required_argument, 0, 'a' },
+ { "delta", required_argument, 0, 'd' },
+ { "gamma", required_argument, 0, 'g' },
+ { "disable-timing", no_argument, 0, 1000 }
+ };
+
+ for ( ;; ) {
+ int option_index = 0;
+ int c = getopt_long(argc, argv, "a:d:g:", long_options, &option_index);
+
+ if (c == -1) {
+ break;
+ }
+ switch (c) {
+ case 'a':
+ vr_alpha = atof(optarg);
+ break;
+ case 'd':
+ vr_delta = atof(optarg);
+ break;
+ case 'g':
+ vr_gamma = atof(optarg);
+ break;
+ case 1000:
+ enable_timing = false;
+ break;
+ default:
+ fprintf(stderr, "Unknown option '%s'\n", argv[option_index]);
+ exit(1);
+ };
+ }
+
+ 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);
+
+ const char *filename0 = argc >= (optind + 1) ? argv[optind] : "test1499.png";
+ const char *filename1 = argc >= (optind + 2) ? argv[optind + 1] : "test1500.png";
+ const char *flow_filename = argc >= (optind + 3) ? argv[optind + 2] : "flow.flo";
+ fprintf(stderr, "%s %s -> %s\n", filename0, filename1, flow_filename);
+
+ // Load pictures.
+ unsigned width1, height1, width2, height2;
+ GLuint tex0 = load_texture(filename0, &width1, &height1);
+ GLuint tex1 = load_texture(filename1, &width2, &height2);
+
+ if (width1 != width2 || height1 != height2) {
+ fprintf(stderr, "Image dimensions don't match (%dx%d versus %dx%d)\n",
+ width1, height1, width2, height2);
+ exit(1);
+ }
+
+ // FIXME: Should be part of DISComputeFlow (but needs to be initialized
+ // before all the render passes).
+ 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);
+
+ DISComputeFlow compute_flow(width1, height1);
+ GLuint final_tex = compute_flow.exec(tex0, tex1);
+
+ unique_ptr<float[]> dense_flow(new float[width1 * height1 * 2]);
+ glGetTextureImage(final_tex, 0, GL_RG, GL_FLOAT, width1 * height1 * 2 * sizeof(float), dense_flow.get());
+
+ compute_flow.release_texture(final_tex);
+
+ write_flow(flow_filename, dense_flow.get(), width1, height1);
+ write_ppm("flow.ppm", dense_flow.get(), width1, height1);
+
+ dense_flow.reset();
+
+ // See if there are more flows on the command line (ie., more than three arguments),
+ // and if so, process them.
+ int num_flows = (argc - optind) / 3;
+ for (int i = 1; i < num_flows; ++i) {
+ const char *filename0 = argv[optind + i * 3 + 0];
+ const char *filename1 = argv[optind + i * 3 + 1];
+ const char *flow_filename = argv[optind + i * 3 + 2];
+ fprintf(stderr, "%s %s -> %s\n", filename0, filename1, flow_filename);
+
+ GLuint width, height;
+ GLuint tex0 = load_texture(filename0, &width, &height);
+ if (width != width1 || height != height1) {
+ fprintf(stderr, "%s: Image dimensions don't match (%dx%d versus %dx%d)\n",
+ filename0, width, height, width1, height1);
+ exit(1);
+ }
+
+ GLuint tex1 = load_texture(filename1, &width, &height);
+ if (width != width1 || height != height1) {
+ fprintf(stderr, "%s: Image dimensions don't match (%dx%d versus %dx%d)\n",
+ filename1, width, height, width1, height1);
+ exit(1);
+ }
+
+ GLuint final_tex = compute_flow.exec(tex0, tex1);
+
+ unique_ptr<float[]> dense_flow(new float[width * height * 2]);
+ glGetTextureImage(final_tex, 0, GL_RG, GL_FLOAT, width * height * 2 * sizeof(float), dense_flow.get());
+
+ compute_flow.release_texture(final_tex);
+
+ write_flow(flow_filename, dense_flow.get(), width, height);
+ }
fprintf(stderr, "err = %d\n", glGetError());
}
projects / nageru / blobdiff