Prepare for variable parameters

src/kernels/CMakeLists.txt

@@ -1,23 +1,25 @@
 cmake_minimum_required(VERSION 2.6)
 
 # make burst backprojection kernels
-set(KERNEL_TEMPLATE templates/ankabackprojectburst.in)
+set(COMMON_TEMPLATE templates/common.in)
+set(Z_TEMPLATE templates/z_template.in)
 set(GENERATOR tools/make_burst_kernels.py)
-set(KERNEL_NAME ankabackprojectburst.cl)
+set(Z_KERNEL z_kernel.cl)
 
 add_custom_command(
-    OUTPUT ${KERNEL_NAME}
+    OUTPUT ${Z_KERNEL}
     COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${GENERATOR} ${GENERATOR}
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${KERNEL_TEMPLATE} ${KERNEL_TEMPLATE}
-    COMMAND python ${GENERATOR} ${KERNEL_TEMPLATE} 1 > ${KERNEL_NAME}
-    COMMAND python ${GENERATOR} ${KERNEL_TEMPLATE} ${BP_BURST} >> ${KERNEL_NAME}
-    DEPENDS ${GENERATOR} ${KERNEL_TEMPLATE}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${COMMON_TEMPLATE} ${COMMON_TEMPLATE}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${Z_TEMPLATE} ${Z_TEMPLATE}
+    COMMAND python ${GENERATOR} ${Z_TEMPLATE} 1 > ${Z_KERNEL}
+    COMMAND python ${GENERATOR} ${Z_TEMPLATE} ${BP_BURST} >> ${Z_KERNEL}
+    DEPENDS ${GENERATOR} ${COMMON_TEMPLATE} ${Z_TEMPLATE}
     COMMENT "Generating burst backprojection kernels")
 
 add_custom_target(burst ALL
-    DEPENDS ankabackprojectburst.cl)
+    DEPENDS ${Z_KERNEL})
 
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${KERNEL_NAME} DESTINATION ${UFO_ANKAFILTERS_KERNELDIR})
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${Z_KERNEL} DESTINATION ${UFO_ANKAFILTERS_KERNELDIR})
 
 # copy kernels
 file(GLOB ufofilter_KERNELS "*.cl")

src/kernels/templates/ankabackprojectburst.in → src/kernels/templates/common.in

@@ -1,18 +1,16 @@
-        pixel.x = mad(voxel.x, cosines{1}, mad(voxel.y, sines{1}, center.x));
-        pixel.y = mad(tmp_x, sines{1}, mad(tmp_y, cosines{1}, tmp));
-        result {2}= read_imagef (projection_{0}, sampler, pixel).x;
-%nl
 kernel void backproject_burst_{0} (
 {1}
                                     global float *volume,
                                     const sampler_t sampler,
                                     const int3 real_size,
-                                    const float2 center,
+                                    const float2 x_center,
+                                    const float y_center,
                                     const float2 x_region,
                                     const float2 y_region,
                                     const float2 z_region,
-                                    const float sin_lamino,
-                                    const float cos_lamino,
+                                    const float2 lamino_region,
+                                    float sin_lamino,
+                                    float cos_lamino,
                                     const float{2} sines,
                                     const float{2} cosines,
                                     const int cumulate)
@@ -25,13 +23,6 @@ kernel void backproject_burst_{0} (
     float3 voxel;
 
     if (idx < real_size.x && idy < real_size.y && idz < real_size.z) {{
-        voxel.x = mad((float) idx, x_region.y, x_region.x);
-        voxel.y = mad((float) idy, y_region.y, y_region.x);
-        voxel.z = mad((float) idz, z_region.y, z_region.x);
-        tmp = mad(voxel.z, sin_lamino, center.y);
-        tmp_x = voxel.x * cos_lamino;
-        tmp_y = -voxel.y * cos_lamino;
-
 {3}
 
         if (cumulate) {{

src/kernels/templates/z_template.in

@@ -0,0 +1,12 @@
+        pixel.x = mad(voxel.x, cosines{1}, mad(voxel.y, sines{1}, x_center.x));
+        pixel.y = mad(tmp_x, sines{1}, mad(tmp_y, cosines{1}, tmp));
+        result {2}= read_imagef (projection_{0}, sampler, pixel).x;
+%nl
+        voxel.x = mad((float) idx, x_region.y, x_region.x);
+        voxel.y = mad((float) idy, y_region.y, y_region.x);
+        voxel.z = mad((float) idz, z_region.y, z_region.x);
+        tmp = mad(voxel.z, sin_lamino, y_center);
+        tmp_x = voxel.x * cos_lamino;
+        tmp_y = -voxel.y * cos_lamino;
+
+{}

src/kernels/tools/make_burst_kernels.py

@@ -1,5 +1,6 @@
 """Generate burst laminographic backprojection OpenCL kernels."""
 import argparse
+import os
 
 
 IDX_TO_VEC_ELEM = dict(zip(range(10), range(10)))
@@ -18,14 +19,15 @@ def fill_compute_template(tmpl, num_items, index):
     return tmpl.format(index, access, operation)
 
 
-def fill_kernel_template(input_tmpl, compute_tmpl, kernel_tmpl, num_items):
+def fill_kernel_template(input_tmpl, compute_tmpl, kernel_outer, kernel_inner, num_items):
     """Construct the whole kernel."""
     vector_length = num_items if num_items > 1 else ''
     computes = '\n'.join([fill_compute_template(compute_tmpl, num_items, i)
                           for i in range(num_items)])
     inputs = '\n'.join([input_tmpl.format(i) for i in range(num_items)])
+    kernel_inner = kernel_inner.format(computes)
 
-    return kernel_tmpl.format(num_items, inputs, vector_length, computes)
+    return kernel_outer.format(num_items, inputs, vector_length, kernel_inner)
 
 
 def parse_args():
@@ -46,8 +48,10 @@ def main():
         raise ValueError('Specified burst mode `{}` must be one of `{}`'.format(args.burst,
                                                                                 allowed_bursts))
     in_tmpl = "read_only image2d_t projection_{},"
-    comp_tmpl, ker_tmpl = open(args.filename, 'r').read().split('\n%nl\n')
-    print fill_kernel_template(in_tmpl, comp_tmpl, ker_tmpl, args.burst)
+    common_filename = os.path.join(os.path.dirname(args.filename), 'common.in')
+    kernel_outer = open(common_filename, 'r').read()
+    comp_tmpl, kernel_inner = open(args.filename, 'r').read().split('\n%nl\n')
+    print fill_kernel_template(in_tmpl, comp_tmpl, kernel_outer, kernel_inner, args.burst)
 
 
 if __name__ == '__main__':