Split the equation texture in two, which speeds up SOR by ~30%.

Fix a NaN issue on Intel.

Pack the gradients and image together into a single 32-bit texture; seems to help ~1.5 ms for flow on NVIDIA.

Remove some redundant glUseProgram() calls.

Remove an unused uniform.

Properly release the flow texture; saves 1 ms (!) on FBO creation.

Compute diffusivity instead of smoothness, which saves a flow-size texture; shaves about 0.2 ms off 720p flow on GTX 950.

Remove some dead code.

Microoptimization in splat.vert.

Share VAOs between all the passes. Much less code, less rebinding overhead.

Fix an issue where we would lose >1 ms for computing flow on NVIDIA, due to lack of fast clears.

Make PersistentFBOSet handle depth.

Remove the rather pointless enable_if tests for now. And move to C++14.

Fix a GLSL syntax error that tripped up NVIDIA.

Disable dither; we don't need it.

When timing a level, print the resolution.

Make a new flag --detailed-timing for microsecond measurements and more.

Move GPUTimers into its own file.

Remove an unused uniform.

Use the same PBO readback system for interpolated images as flows.

Speed up hole filling by ~10%.

Implement hole filling.

Put depth in 0..1; evidently even fp32 depth is clamped in the ARB version.

Start working on interpolation code.

Do RGB -> grayscale conversion on the GPU.

Split texture pooling out from DISComputeFlow into its own class.

Hide the OpenGL window; it is rather annoying.

Remove a TODO.

Making the penalizer smaller (as one should if adjusting it towards
a smaller range, as there's effectively I² numerator and I denominator)
does not seem to have much effect; actually, increasing it to 0.01
seems to give better results on alley-2, but that's the “wrong way”.

Stop leaking texture views (and by extension, textures).

Small code cleanup.

Use textureSize() instead of sending in uniforms manually. Same result, less code, less error-prone.

Remove a TODO; setting up equations is not where our time goes.

Halve the number of motion search iterations, to eight.

The DIS code claims this is allowed after they changed their Sobel code;
for us, seemingly SOR was the breaking point. EPE is hardly moving
(<1% for most Sintel tests I've run), but speed goes up markedly.

Finally get SOR working.

The trick here was something I'd considered for a long time,
namely red-black SOR so that we update only half the values
every iteration. The implementation is annoyingly inefficient,
but convergence is so much better that it's worth it (a few
percent EPE improvement).

Fix a mixup in the variational refinement text.

Close off a TODO.

Rework patch placement. Finally inches our EPE just below the reference code, it seems.

Tweak the default variational refinement weights (optimized on alley_2).

Give the variational refinement terms slightly less mysterious names.

Fix a done TODO (gamma is for E_G, not E_S, and we multiply in the alpha in the smoothness).

Sample gradient as zero outside the image, instead of repeating them. Helps dramatically on edge patches. 20% EPE improvement on alley_2.

Small syntactic tweak.

Fix the patch out-of-bounds check in motion search (it was all broken).

Fix a problem with visualizing flow that goes exactly left.

Use asynchronous readback when doing many flows. Speeds up 50-frame jobs by about 30%; PNG reading is now the dominant cost (60% or so).

Fix some uniforms not getting through to the motion search vertex shader.

Add a debugging flag to disable/ignore variational refinement.

Change the discard condition for motion search.

Fix a typo.

Make motion search happen mostly in pixels; a bit less code that way.

Print EPE on stdout, since it is not an error.

Make flow writing a bit faster.

Print out the first flow pair, too.

Add a --disable-timing flag (less spew, less GPU waiting).

Add support for computing many flows sequentially (reduces startup overhead).

Refactor the flow writing.

Reuse textures between flow invocations.

Make a wrapper class for all the flow logic.

Refactor FBO creation. A step on the way to persistent FBOs and temporary textures.

Small cleanup.

Make the eval tool capable of taking the average over a series of flow files.

Make it possible to set alpha/delta/gamma on the command line, for grid searches.

Add in the relative weighting of the variational refinement terms.

Fix a comment.

Add another missing clear.

Deal with buggy GPU timers that go backwards.

If needed, resize the flow up (bilinearly) to the final size at the end.

Hack around a convergence problem in the SOR code, by stopping the over-relaxation and reverting to pure Gauss-Seidel.

Fix a typo.

Support giving in file names on the command line.

Load arbitrary images through SDL_image, instead of requiring raw grayscale ones.

Pack the two b values in the equations with shared exponent.

Fix an algebra error in the E_I term.

Fix some errors in the smoothness term.

Small notational tweak.

Add some missing clears.

Update .gitignore.

In the variational refinement, change the flow unit from normalized coordinates to pixels.

Add a FIXME on the scissor.

Add much more detailed GPU timers.

Fix flow output after we did normalization in the add step.

Avoid infinities in a uniform.

Finish up the variational refinement, conceptually. Of course, it doesn't work yet.

Implement SOR.

Calculate smoothness and set up the equations. Still fairly buggy (missing 0..1 normalization adjustments, at least).

Also calculate beta_0 when calculating derivatives.

Fix some indentation.

Use textureOffset() wherever possible to save some tedious arithmetic.

Calculate I_x and I_y for variational refinement.

Start working on variational refinement.

Reduce the spam in apitrace a bit.

Do patch normalization in densification.

In densification, grow the patch a bit. Seemingly helps a lot on the EPE.

Correct the sampling of the flow in the densification vertex shader.

Remove an unused sampler.

Fix the texel centers for motion search. Helps a whole lot.

Remove some duplicate vertex attributes.

Use fp16 for the densification output texture; evidently does not matter for quality.

Remove an unused uniform.

Check uniform locations ahead-of-time, for slightly reduced GL overhead.