ogl_beamforming

das.glsl (12893B)

---

 /* See LICENSE for license details. */
 #if   DataKind == DataKind_Float32
   #define SAMPLE_TYPE           float
   #define TEXTURE_KIND          r32f
   #define RESULT_TYPE_CAST(a)   (a).x
   #define OUTPUT_TYPE_CAST(a)   vec4((a).x, 0, 0, 0)
   #if !Fast
     #define RESULT_TYPE         vec2
     #define RESULT_LAST_INDEX   1
   #endif
 #elif DataKind == DataKind_Float32Complex
   #define SAMPLE_TYPE           vec2
   #define TEXTURE_KIND          rg32f
   #define RESULT_TYPE_CAST(a)   (a).xy
   #define OUTPUT_TYPE_CAST(a)   vec4((a).xy, 0, 0)
   #if !Fast
     #define RESULT_TYPE         vec3
     #define RESULT_LAST_INDEX   2
   #endif
 #else
   #error DataKind unsupported for DAS
 #endif
 
 layout(std430, binding = 1) readonly restrict buffer buffer_1 {
 	SAMPLE_TYPE rf_data[];
 };
 
 #ifndef RESULT_TYPE
   #define RESULT_TYPE SAMPLE_TYPE
 #endif
 
 #if Fast
   #define RESULT_STORE(a, length_a) RESULT_TYPE(a)
 	layout(TEXTURE_KIND, binding = 0)           restrict uniform image3D  u_out_data_tex;
 #else
   #define RESULT_STORE(a, length_a) RESULT_TYPE(a, length_a)
 	layout(TEXTURE_KIND, binding = 0) writeonly restrict uniform image3D  u_out_data_tex;
 #endif
 
 layout(r16i,  binding = 1) readonly  restrict uniform iimage1D sparse_elements;
 layout(rg32f, binding = 2) readonly  restrict uniform image1D  focal_vectors;
 layout(r8i,   binding = 3) readonly  restrict uniform iimage1D transmit_receive_orientations;
 
 #define RX_ORIENTATION(tx_rx) (((tx_rx) >> 0) & 0x0F)
 #define TX_ORIENTATION(tx_rx) (((tx_rx) >> 4) & 0x0F)
 
 #define C_SPLINE 0.5
 
 #if DataKind == DataKind_Float32Complex
 vec2 rotate_iq(const vec2 iq, const float time)
 {
 	float arg    = radians(360) * DemodulationFrequency * time;
 	mat2  phasor = mat2( cos(arg), sin(arg),
 	                    -sin(arg), cos(arg));
 	vec2 result = phasor * iq;
 	return result;
 }
 #else
   #define rotate_iq(a, b) (a)
 #endif
 
 /* NOTE: See: https://cubic.org/docs/hermite.htm */
 SAMPLE_TYPE cubic(const int base_index, const float t)
 {
 	const mat4 h = mat4(
 		 2, -3,  0, 1,
 		-2,  3,  0, 0,
 		 1, -2,  1, 0,
 		 1, -1,  0, 0
 	);
 
 	SAMPLE_TYPE samples[4] = {
 		rf_data[base_index + 0],
 		rf_data[base_index + 1],
 		rf_data[base_index + 2],
 		rf_data[base_index + 3],
 	};
 
 	vec4        S  = vec4(t * t * t, t * t, t, 1);
 	SAMPLE_TYPE P1 = samples[1];
 	SAMPLE_TYPE P2 = samples[2];
 	SAMPLE_TYPE T1 = C_SPLINE * (P2 - samples[0]);
 	SAMPLE_TYPE T2 = C_SPLINE * (samples[3] - P1);
 
 #if   DataKind == DataKind_Float32
 	vec4 C = vec4(P1.x, P2.x, T1.x, T2.x);
 	float result = dot(S, h * C);
 #elif DataKind == DataKind_Float32Complex
 	mat2x4 C = mat2x4(vec4(P1.x, P2.x, T1.x, T2.x), vec4(P1.y, P2.y, T1.y, T2.y));
 	vec2 result = S * h * C;
 #endif
 	return result;
 }
 
 SAMPLE_TYPE sample_rf(const int rf_offset, const float index)
 {
 	SAMPLE_TYPE result = SAMPLE_TYPE(0);
 	switch (InterpolationMode) {
 	case InterpolationMode_Nearest:{
 		if (int(index) >= 0 && int(round(index)) < SampleCount)
 			result = rotate_iq(rf_data[rf_offset + int(round(index))], index / SamplingFrequency);
 	}break;
 	case InterpolationMode_Linear:{
 		if (int(index) >= 0 && int(index) < SampleCount - 1) {
 			float tk, t = modf(index, tk);
 			int n = rf_offset + int(tk);
 			result = (1 - t) * rf_data[n] + t * rf_data[n + 1];
 			result = rotate_iq(result, index / SamplingFrequency);
 		}
 	}break;
 	case InterpolationMode_Cubic:{
 		if (int(index) > 0 && int(index) < SampleCount - 2) {
 			float tk, t = modf(index, tk);
 			result = rotate_iq(cubic(rf_offset + int(index), t), index / SamplingFrequency);
 		}
 	}break;
 	}
 	return result;
 }
 
 float sample_index(const float distance)
 {
 	float  time = distance / SpeedOfSound + TimeOffset;
 	return time * SamplingFrequency;
 }
 
 float apodize(const float arg)
 {
 	/* IMPORTANT: do not move calculation of arg into this function. It will generate a
 	 * conditional move resulting in cos always being evaluated causing a slowdown */
 
 	/* NOTE: constant F# dynamic receive apodization. This is implemented as:
 	 *
 	 *                  /        |x_e - x_i|\
 	 *    a(x, z) = cos(F# * π * ----------- ) ^ 2
 	 *                  \        |z_e - z_i|/
 	 *
 	 * where x,z_e are transducer element positions and x,z_i are image positions. */
 	float a = cos(radians(180) * arg);
 	return a * a;
 }
 
 vec2 rca_plane_projection(const vec3 point, const bool rows)
 {
 	vec2 result = vec2(point[int(rows)], point[2]);
 	return result;
 }
 
 float plane_wave_transmit_distance(const vec3 point, const float transmit_angle, const bool tx_rows)
 {
 	return dot(rca_plane_projection(point, tx_rows), vec2(sin(transmit_angle), cos(transmit_angle)));
 }
 
 float cylindrical_wave_transmit_distance(const vec3 point, const float focal_depth,
                                          const float transmit_angle, const bool tx_rows)
 {
 	vec2 f = focal_depth * vec2(sin(transmit_angle), cos(transmit_angle));
 	return distance(rca_plane_projection(point, tx_rows), f);
 }
 
 int tx_rx_orientation_for_acquisition(const int acquisition)
 {
 	int result = bool(SingleOrientation) ? TransmitReceiveOrientation : imageLoad(transmit_receive_orientations, acquisition).x;
 	return result;
 }
 
 vec2 focal_vector_for_acquisition(const int acquisition)
 {
 	vec2 result = bool(SingleFocus) ? vec2(TransmitAngle, FocusDepth) : imageLoad(focal_vectors, acquisition).xy;
 	return result;
 }
 
 float rca_transmit_distance(const vec3 world_point, const vec2 focal_vector, const int transmit_receive_orientation)
 {
 	float result = 0;
 	if (TX_ORIENTATION(transmit_receive_orientation) != RCAOrientation_None) {
 		bool  tx_rows        = TX_ORIENTATION(transmit_receive_orientation) == RCAOrientation_Rows;
 		float transmit_angle = radians(focal_vector.x);
 		float focal_depth    = focal_vector.y;
 
 		if (isinf(focal_depth)) {
 			result = plane_wave_transmit_distance(world_point, transmit_angle, tx_rows);
 		} else {
 			result = cylindrical_wave_transmit_distance(world_point, focal_depth, transmit_angle, tx_rows);
 		}
 	}
 	return result;
 }
 
 RESULT_TYPE RCA(const vec3 world_point)
 {
 	const int acquisition_start = bool(Fast)? u_channel     : 0;
 	const int acquisition_end   = bool(Fast)? u_channel + 1 : AcquisitionCount;
 	RESULT_TYPE result = RESULT_TYPE(0);
 	for (int acquisition = acquisition_start; acquisition < acquisition_end; acquisition++) {
 		const int  tx_rx_orientation = tx_rx_orientation_for_acquisition(acquisition);
 		const bool rx_rows           = RX_ORIENTATION(tx_rx_orientation) == RCAOrientation_Rows;
 		const vec2 focal_vector      = focal_vector_for_acquisition(acquisition);
 		vec2  xdc_world_point   = rca_plane_projection((xdc_transform * vec4(world_point, 1)).xyz, rx_rows);
 		float transmit_distance = rca_transmit_distance(world_point, focal_vector, tx_rx_orientation);
 
 		int rf_offset  = acquisition * SampleCount;
 		rf_offset     -= int(InterpolationMode == InterpolationMode_Cubic);
 		for (int rx_channel = 0; rx_channel < ChannelCount; rx_channel++) {
 			vec3  rx_center      = vec3(rx_channel * xdc_element_pitch, 0);
 			vec2  receive_vector = xdc_world_point - rca_plane_projection(rx_center, rx_rows);
 			float a_arg          = abs(FNumber * receive_vector.x / abs(xdc_world_point.y));
 
 			if (a_arg < 0.5f) {
 				float       sidx  = sample_index(transmit_distance + length(receive_vector));
 				SAMPLE_TYPE value = apodize(a_arg) * sample_rf(rf_offset, sidx);
 				result += RESULT_STORE(value, length(value));
 			}
 			rf_offset += SampleCount * AcquisitionCount;
 		}
 	}
 	return result;
 }
 
 RESULT_TYPE HERCULES(const vec3 world_point)
 {
 	const int tx_rx_orientation  = tx_rx_orientation_for_acquisition(0);
 	const bool rx_cols           = RX_ORIENTATION(tx_rx_orientation) == RCAOrientation_Columns;
 	const vec2 focal_vector      = focal_vector_for_acquisition(0);
 	const vec3 xdc_world_point   = (xdc_transform * vec4(world_point, 1)).xyz;
 
 	const float transmit_index   = sample_index(rca_transmit_distance(world_point, focal_vector, tx_rx_orientation));
 	const float z_delta_squared  = xdc_world_point.z * xdc_world_point.z;
 	const float f_number_over_z  = abs(FNumber / xdc_world_point.z);
 	const vec2  xy_world_point   = xdc_world_point.xy;
 	const float apodization_test = 0.25f / (f_number_over_z * f_number_over_z);
 
 	RESULT_TYPE result = RESULT_TYPE(0);
 	#if Fast
 	const int rx_channel = u_channel;
 	#else
 	for (int rx_channel = 0; rx_channel < ChannelCount; rx_channel++)
 	#endif
 	{
 		int rf_offset   = rx_channel * SampleCount * AcquisitionCount + Sparse * SampleCount;
 		rf_offset      -= int(InterpolationMode == InterpolationMode_Cubic);
 
 		// NOTE(rnp): this wouldn't be so messy if we just forced an orientation like with FORCES
 		vec2 element_receive_delta_squared = xy_world_point;
 		if (rx_cols) element_receive_delta_squared.x -= rx_channel * xdc_element_pitch.x;
 		else         element_receive_delta_squared.y -= rx_channel * xdc_element_pitch.y;
 
 		if (rx_cols) element_receive_delta_squared.x *= element_receive_delta_squared.x;
 		else         element_receive_delta_squared.y *= element_receive_delta_squared.y;
 
 		for (int transmit = Sparse; transmit < AcquisitionCount; transmit++) {
 			int tx_channel = bool(Sparse) ? imageLoad(sparse_elements, transmit - Sparse).x : transmit;
 
 			if (rx_cols) element_receive_delta_squared.y  = xy_world_point.y - tx_channel * xdc_element_pitch.y;
 			else         element_receive_delta_squared.x  = xy_world_point.x - tx_channel * xdc_element_pitch.x;
 
 			if (rx_cols) element_receive_delta_squared.y *= element_receive_delta_squared.y;
 			else         element_receive_delta_squared.x *= element_receive_delta_squared.x;
 
 			float element_delta_squared = element_receive_delta_squared.x + element_receive_delta_squared.y;
 			if (element_delta_squared < apodization_test) {
 				/* NOTE: tribal knowledge */
 				float apodization = transmit == 0 ? inversesqrt(float(AcquisitionCount)) : 1.0f;
 				apodization *= apodize(f_number_over_z * sqrt(element_delta_squared));
 
 				float index = transmit_index + sqrt(z_delta_squared + element_delta_squared) * SamplingFrequency / SpeedOfSound;
 				SAMPLE_TYPE value = apodization * sample_rf(rf_offset, index);
 				result += RESULT_STORE(value, length(value));
 			}
 
 			rf_offset += SampleCount;
 		}
 	}
 	return result;
 }
 
 RESULT_TYPE FORCES(const vec3 xdc_world_point)
 {
 	const int rx_channel_start = bool(Fast)? u_channel     : 0;
 	const int rx_channel_end   = bool(Fast)? u_channel + 1 : ChannelCount;
 
 	RESULT_TYPE result = RESULT_TYPE(0);
 
 	float z_delta_squared     = xdc_world_point.z * xdc_world_point.z;
 	float transmit_y_delta    = xdc_world_point.y - xdc_element_pitch.y * ChannelCount / 2;
 	float transmit_yz_squared = transmit_y_delta * transmit_y_delta + z_delta_squared;
 
 	for (int rx_channel = rx_channel_start; rx_channel < rx_channel_end; rx_channel++) {
 		float receive_x_delta = xdc_world_point.x - rx_channel * xdc_element_pitch.x;
 		float a_arg           = abs(FNumber * receive_x_delta / xdc_world_point.z);
 
 		if (a_arg < 0.5f) {
 			int rf_offset  = rx_channel * SampleCount * AcquisitionCount + Sparse * SampleCount;
 			rf_offset     -= int(InterpolationMode == InterpolationMode_Cubic);
 
 			float receive_index = sample_index(sqrt(receive_x_delta * receive_x_delta + z_delta_squared));
 			float apodization   = apodize(a_arg);
 			for (int transmit = Sparse; transmit < AcquisitionCount; transmit++) {
 				int   tx_channel       = bool(Sparse) ? imageLoad(sparse_elements, transmit - Sparse).x : transmit;
 				float transmit_x_delta = xdc_world_point.x - xdc_element_pitch.x * tx_channel;
 				float transmit_index   = sqrt(transmit_yz_squared + transmit_x_delta * transmit_x_delta) * SamplingFrequency / SpeedOfSound;
 
 				SAMPLE_TYPE value = apodization * sample_rf(rf_offset, receive_index + transmit_index);
 				result    += RESULT_STORE(value, length(value));
 				rf_offset += SampleCount;
 			}
 		}
 	}
 	return result;
 }
 
 void main()
 {
 	ivec3 out_voxel    = ivec3(gl_GlobalInvocationID);
 	vec3  image_points = vec3(imageSize(u_out_data_tex)) - 1.0f;
 	if (!all(lessThan(out_voxel, imageSize(u_out_data_tex))))
 		return;
 
 	vec3 point       = vec3(out_voxel) / max(vec3(1.0f), image_points);
 	vec3 world_point = (voxel_transform * vec4(point, 1)).xyz;
 
 	RESULT_TYPE sum;
 	switch (AcquisitionKind) {
 	case AcquisitionKind_FORCES:
 	case AcquisitionKind_UFORCES:
 	{
 		sum = FORCES(world_point);
 	}break;
 	case AcquisitionKind_HERCULES:
 	case AcquisitionKind_UHERCULES:
 	case AcquisitionKind_HERO_PA:
 	{
 		sum = HERCULES(world_point);
 	}break;
 	case AcquisitionKind_Flash:
 	case AcquisitionKind_RCA_TPW:
 	case AcquisitionKind_RCA_VLS:
 	{
 		sum = RCA(world_point);
 	}break;
 	}
 
 	#if Fast
 		sum += RESULT_TYPE_CAST(imageLoad(u_out_data_tex, out_voxel));
 	#endif
 
 	#if CoherencyWeighting
 		/* TODO(rnp): scale such that brightness remains ~constant */
 		float denominator = sum[RESULT_LAST_INDEX] + float(sum[RESULT_LAST_INDEX] == 0);
 		RESULT_TYPE_CAST(sum) *= RESULT_TYPE_CAST(sum) / denominator;
 	#endif
 
 	imageStore(u_out_data_tex, out_voxel, OUTPUT_TYPE_CAST(sum));
 }