X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=equations.frag;h=04e5370fd9d53baf5afda39ee140a526d6937945;hb=1aab0848ee4807a0369656edd9eb42ce5adb56ae;hp=6171a3729d6f862490e288e5125152227d6756b1;hpb=f22fffe30b28081f42fc4d5f55c6a6a95fe65c54;p=nageru

diff --git a/equations.frag b/equations.frag
index 6171a37..04e5370 100644
--- a/equations.frag
+++ b/equations.frag
@@ -1,27 +1,83 @@
 #version 450 core
 
-in vec2 tc;
-out uvec4 equation;
+in vec3 tc0, tc_left0, tc_down0;
+in vec3 tc1, tc_left1, tc_down1;
+in float line_offset;
+out uvec4 equation_red, equation_black;
 
-uniform sampler2D I_x_y_tex, I_t_tex;
-uniform sampler2D diff_flow_tex, flow_tex;
-uniform sampler2D beta_0_tex;
-uniform sampler2D smoothness_x_tex, smoothness_y_tex;
+uniform sampler2DArray I_x_y_tex, I_t_tex;
+uniform sampler2DArray diff_flow_tex, base_flow_tex;
+uniform sampler2DArray beta_0_tex;
+uniform sampler2DArray diffusivity_tex;
 
-// TODO: Consider a specialized version for the case where we know that du = dv = 0,
-// since we run so few iterations.
+// Relative weighting of intensity term.
+uniform float delta;
 
-// This must be a macro, since the offset needs to be a constant expression.
-#define get_flow(x_offs, y_offs) \
-	(textureOffset(flow_tex, tc, ivec2((x_offs), (y_offs))).xy + \
-	textureOffset(diff_flow_tex, tc, ivec2((x_offs), (y_offs))).xy)
+// Relative weighting of gradient term.
+uniform float gamma;
 
-void main()
+uniform bool zero_diff_flow;
+
+// Similar to packHalf2x16, but the two values share exponent, and are stored
+// as 12-bit fixed point numbers multiplied by that exponent (the leading one
+// can't be implicit in this kind of format). This allows us to store a much
+// greater range of numbers (8-bit, ie., full fp32 range), and also gives us an
+// extra mantissa bit. (Well, ostensibly two, but because the numbers have to
+// be stored denormalized, we only really gain one.)
+//
+// The price we pay is that if the numbers are of very different magnitudes,
+// the smaller number gets less precision.
+uint pack_floats_shared(float a, float b)
+{
+	float greatest = max(abs(a), abs(b));
+
+	// Find the exponent, increase it by one, and negate it.
+	// E.g., if the nonbiased exponent is 3, the number is between
+	// 2^3 and 2^4, so our normalization factor to get within -1..1
+	// is going to be 2^-4.
+	//
+	// exponent -= 127;
+	// exponent = -(exponent + 1);
+	// exponent += 127;
+	//
+	// is the same as
+	//
+	// exponent = 252 - exponent;
+	uint e = floatBitsToUint(greatest) & 0x7f800000u;
+	float normalizer = uintBitsToFloat((252 << 23) - e);
+
+	// The exponent is the same range as fp32, so just copy it
+	// verbatim, shifted up to where the sign bit used to be.
+	e <<= 1;
+
+	// Quantize to 12 bits.
+	uint qa = uint(int(round(a * (normalizer * 2047.0))));
+	uint qb = uint(int(round(b * (normalizer * 2047.0))));
+
+	return (qa & 0xfffu) | ((qb & 0xfffu) << 12) | e;
+}
+
+float zero_if_outside_border(vec4 val)
+{
+	if (val.w < 1.0f) {
+		// We hit the border (or more like half-way to it), so zero smoothness.
+		return 0.0f;
+	} else {
+		return val.x;
+	}
+}
+
+uvec4 compute_equation(vec3 tc, vec3 tc_left, vec3 tc_down)
 {
 	// Read the flow (on top of the u0/v0 flow).
-	vec2 diff_flow = texture(diff_flow_tex, tc).xy;
-	float du = diff_flow.x;
-	float dv = diff_flow.y;
+	float du, dv;
+	if (zero_diff_flow) {
+		du = dv = 0.0f;
+	} else {
+		vec2 diff_flow = texture(diff_flow_tex, tc).xy;
+		du = diff_flow.x;
+		dv = diff_flow.y;
+	}
 
 	// Read the first derivatives.
 	vec2 I_x_y = texture(I_x_y_tex, tc).xy;
@@ -29,19 +85,16 @@ void main()
 	float I_y = I_x_y.y;
 	float I_t = texture(I_t_tex, tc).x;
 
-	// E_I term. Note that we don't square β_0, in line with DeepFlow,
-	// even though it's probably an error.
-	//
-	// TODO: Evaluate squaring β_0.
-  	// FIXME: Should the penalizer be adjusted for 0..1 intensity range instead of 0..255?
-	// TODO: Multiply by some alpha.
+	// E_I term. Note that we don't square β_0, in line with DeepFlow;
+	// it's probably an error (see variational_refinement.txt),
+	// but squaring it seems to give worse results.
 	float beta_0 = texture(beta_0_tex, tc).x;
-	float k1 = beta_0 * inversesqrt(beta_0 * (I_x * du + I_y * dv + I_t) * (I_x * du + I_y * dv + I_t) + 1e-6);
+	float k1 = delta * beta_0 * inversesqrt(beta_0 * (I_x * du + I_y * dv + I_t) * (I_x * du + I_y * dv + I_t) + 1e-6);
 	float A11 = k1 * I_x * I_x;
 	float A12 = k1 * I_x * I_y;
 	float A22 = k1 * I_y * I_y;
-	float b1 = -k1 * I_t;
-	float b2 = -k1 * I_t;
+	float b1 = -k1 * I_t * I_x;
+	float b2 = -k1 * I_t * I_y;
 
 	// Compute the second derivatives. First I_xx and I_xy.
 	vec2 I_x_y_m2 = textureOffset(I_x_y_tex, tc, ivec2(-2,  0)).xy;
@@ -70,11 +123,10 @@ void main()
 	float I_xt = I_tx_ty.x;
 	float I_yt = I_tx_ty.y;
 
-	// E_G term. Same TODOs as E_I. Same normalization as beta_0
-	// (see derivatives.frag).
+	// E_G term. Same normalization as beta_0 (see derivatives.frag).
 	float beta_x = 1.0 / (I_xx * I_xx + I_xy * I_xy + 1e-7);
 	float beta_y = 1.0 / (I_xy * I_xy + I_yy * I_yy + 1e-7);
-	float k2 = inversesqrt(
+	float k2 = gamma * inversesqrt(
 		beta_x * (I_xx * du + I_xy * dv + I_xt) * (I_xx * du + I_xy * dv + I_xt) +
 		beta_y * (I_xy * du + I_yy * dv + I_yt) * (I_xy * du + I_yy * dv + I_yt) +
 		1e-6);
@@ -87,33 +139,49 @@ void main()
 	b2 -= k_x * I_xy * I_xt + k_y * I_yy * I_yt;
 
 	// E_S term, sans the part on the right-hand side that deals with
-	// the neighboring pixels.
-	// TODO: Multiply by some gamma.
-	float smooth_l = textureOffset(smoothness_x_tex, tc, ivec2(-1,  0)).x;
-	float smooth_r = texture(smoothness_x_tex, tc).x;
-	float smooth_d = textureOffset(smoothness_y_tex, tc, ivec2( 0, -1)).x;
-	float smooth_u = texture(smoothness_y_tex, tc).x;
-	A11 -= smooth_l + smooth_r + smooth_d + smooth_u;
-	A22 -= smooth_l + smooth_r + smooth_d + smooth_u;
-
-	// Laplacian of (u0 + du, v0 + dv), sans the central term.
+	// the neighboring pixels. The gamma is multiplied in in smoothness.frag.
+	//
+	// Note that we sample in-between two texels, which gives us the 0.5 *
+	// (x[-1] + x[0]) part for free. If one of the texels is a border
+	// texel, it will have zero alpha, and zero_if_outside_border() will
+	// set smoothness to zero.
+	float smooth_l = zero_if_outside_border(texture(diffusivity_tex, tc_left));
+	float smooth_r = zero_if_outside_border(textureOffset(diffusivity_tex, tc_left, ivec2(1, 0)));
+	float smooth_d = zero_if_outside_border(texture(diffusivity_tex, tc_down));
+	float smooth_u = zero_if_outside_border(textureOffset(diffusivity_tex, tc_down, ivec2(0, 1)));
+	A11 += smooth_l + smooth_r + smooth_d + smooth_u;
+	A22 += smooth_l + smooth_r + smooth_d + smooth_u;
+
+	// Laplacian of (u0, v0).
 	vec2 laplacian =
-		smooth_l * get_flow(-1, 0) +
-		smooth_r * get_flow(1, 0) +
-		smooth_d * get_flow(0, -1) +
-		smooth_u * get_flow(0, 1);
-	b1 -= laplacian.x;
-	b2 -= laplacian.y;
-
-	// The central term of the Laplacian, for (u0, v0) only.
-	// (The central term for (du, dv) is what we are solving for.)
-	vec2 central = (smooth_l + smooth_r + smooth_d + smooth_u) * texture(flow_tex, tc).xy;
-	b1 += central.x;
-	b2 += central.y;
+		smooth_l * textureOffset(base_flow_tex, tc, ivec2(-1,  0)).xy +
+		smooth_r * textureOffset(base_flow_tex, tc, ivec2( 1,  0)).xy +
+		smooth_d * textureOffset(base_flow_tex, tc, ivec2( 0, -1)).xy +
+		smooth_u * textureOffset(base_flow_tex, tc, ivec2( 0,  1)).xy -
+		(smooth_l + smooth_r + smooth_d + smooth_u) * texture(base_flow_tex, tc).xy;
+	b1 += laplacian.x;
+	b2 += laplacian.y;
 
 	// Encode the equation down into four uint32s.
-	equation.x = floatBitsToUint(1.0 / A11);
-	equation.y = floatBitsToUint(A12);
-	equation.z = floatBitsToUint(1.0 / A22);
-	equation.w = packHalf2x16(vec2(b1, b2));
+	uvec4 ret;
+	ret.x = floatBitsToUint(1.0 / A11);
+	ret.y = floatBitsToUint(A12);
+	ret.z = floatBitsToUint(1.0 / A22);
+	ret.w = pack_floats_shared(b1, b2);
+	return ret;
+}
+
+void main()
+{
+	uvec4 eq0 = compute_equation(tc0, tc_left0, tc_down0);
+	uvec4 eq1 = compute_equation(tc1, tc_left1, tc_down1);
+
+	if ((int(round(line_offset)) & 1) == 1) {
+		// Odd line, so the right value is red.
+		equation_red = eq1;
+		equation_black = eq0;
+	} else {
+		equation_red = eq0;
+		equation_black = eq1;
+	}
 }