pyfast 4.12.0__cp36-abi3-win_amd64.whl

fast/kernels/Algorithms/ImageFlipper/ImageFlipper3D.cl

@@ -0,0 +1,51 @@
+const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_NONE;
+
+__kernel void flip3D(
+    __read_only image3d_t input,
+    __global TYPE* output,
+    __private char flipHorizontal,
+    __private char flipVertical,
+    __private char flipDepth,
+    __private int channels
+    ) {
+
+    int4 posInput = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    int3 targetPos = posInput.xyz;
+    int3 size = {get_image_width(input), get_image_height(input), get_image_depth(input)};
+    if(flipHorizontal == 1)
+        targetPos.x = size.x - posInput.x - 1;
+    if(flipVertical == 1)
+        targetPos.y = size.y - posInput.y - 1;
+    if(flipDepth == 1)
+        targetPos.z = size.z - posInput.z - 1;
+
+    int dataType = get_image_channel_data_type(input);
+    if(dataType == CLK_FLOAT) {
+        float4 value = read_imagef(input, sampler, posInput);
+        output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels] = value.x;
+        if(channels > 1)
+		output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels+1] = value.y;
+        if(channels > 2)
+		output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels+2] = value.z;
+        if(channels > 3)
+		output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels+3] = value.w;
+    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        uint4 value = read_imageui(input, sampler, posInput);
+        output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels] = value.x;
+        if(channels > 1)
+		output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels+1] = value.y;
+        if(channels > 2)
+		output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels+2] = value.z;
+        if(channels > 3)
+		output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels+3] = value.w;
+    } else {
+        int4 value = read_imagei(input, sampler, posInput);
+        output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels] = value.x;
+        if(channels > 1)
+		output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels+1] = value.y;
+        if(channels > 2)
+		output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels+2] = value.z;
+        if(channels > 3)
+		output[(targetPos.x + targetPos.y*size.x + targetPos.z*size.x*size.y)*channels+3] = value.w;
+    }
+}

fast/kernels/Algorithms/ImageGradient/ImageGradient.cl

@@ -0,0 +1,71 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST;
+
+
+float readImageAsFloat2D(__read_only image2d_t image, sampler_t sampler, int2 position) {
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT || dataType == CLK_SNORM_INT16 || dataType == CLK_UNORM_INT16) {
+        return read_imagef(image, sampler, position).x;
+    } else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+        return (float)read_imagei(image, sampler, position).x;
+    } else {
+        return (float)read_imageui(image, sampler, position).x;
+    }
+}
+
+float readImageAsFloat3D(__read_only image3d_t image, sampler_t sampler, int4 position) {
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT || dataType == CLK_SNORM_INT16 || dataType == CLK_UNORM_INT16) {
+        return read_imagef(image, sampler, position).x;
+    } else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+        return (float)read_imagei(image, sampler, position).x;
+    } else {
+        return (float)read_imageui(image, sampler, position).x;
+    }
+}
+
+__kernel void gradient2D(
+        __read_only image2d_t input,
+        __write_only image2d_t output
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    
+    // TODO take pixel spacing into account
+    float2 gradient = {
+            (readImageAsFloat2D(input, sampler, pos+(int2)(1,0)) - readImageAsFloat2D(input, sampler, pos-(int2)(1,0)))*0.5f,
+            (readImageAsFloat2D(input, sampler, pos+(int2)(0,1)) - readImageAsFloat2D(input, sampler, pos-(int2)(0,1)))*0.5f
+    };
+    write_imagef(output, pos, gradient.xyyy);
+}
+
+
+#ifdef VECTORS_16BIT
+#define FLOAT_TO_SNORM16_3(vector) convert_short3_sat_rte(vector * 32767.0f)
+#define VECTOR_FIELD_TYPE short
+#else
+#define FLOAT_TO_SNORM16_3(vector) vector
+#define VECTOR_FIELD_TYPE float
+#endif
+
+__kernel void gradient3D(
+        __read_only image3d_t input,
+#ifdef fast_3d_image_writes
+        __write_only image3d_t output
+#else
+        __global VECTOR_FIELD_TYPE* output
+#endif
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    
+    // TODO take pixel spacing into account
+    float3 gradient = {
+            (readImageAsFloat3D(input, sampler, pos+(int4)(1,0,0,0)) - readImageAsFloat3D(input, sampler, pos-(int4)(1,0,0,0)))*0.5f,
+            (readImageAsFloat3D(input, sampler, pos+(int4)(0,1,0,0)) - readImageAsFloat3D(input, sampler, pos-(int4)(0,1,0,0)))*0.5f,
+            (readImageAsFloat3D(input, sampler, pos+(int4)(0,0,1,0)) - readImageAsFloat3D(input, sampler, pos-(int4)(0,0,1,0)))*0.5f
+    };
+#ifdef fast_3d_image_writes
+    write_imagef(output, pos, gradient.xyzz);
+#else 
+    vstore3(FLOAT_TO_SNORM16_3(gradient), pos.x + pos.y*get_global_size(0) + pos.z*get_global_size(0)*get_global_size(1), output);
+#endif
+}
+

fast/kernels/Algorithms/ImageInverter/ImageInverter.cl

@@ -0,0 +1,30 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void invert3D(
+        __read_only image3d_t input,
+        __global DATA_TYPE* output,
+        __private float min,
+        __private float max,
+        __private uint outputChannels
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    int dataType = get_image_channel_data_type(input);
+
+    float4 value;
+    if(dataType == CLK_FLOAT) {
+        value = read_imagef(input, sampler, pos);
+    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        value = convert_float4(read_imageui(input, sampler, pos));
+    } else {
+        value = convert_float4(read_imagei(input, sampler, pos));
+    }
+    value = (max - min) - value;
+
+    output[(pos.x + pos.y*get_image_width(input) + pos.z*get_image_width(input)*get_image_height(input))*outputChannels] = value.x;
+    if(outputChannels > 1)
+        output[(pos.x + pos.y*get_image_width(input) + pos.z*get_image_width(input)*get_image_height(input))*outputChannels + 1] = value.y;
+    if(outputChannels > 2)
+        output[(pos.x + pos.y*get_image_width(input) + pos.z*get_image_width(input)*get_image_height(input))*outputChannels + 2] = value.z;
+    if(outputChannels > 3)
+        output[(pos.x + pos.y*get_image_width(input) + pos.z*get_image_width(input)*get_image_height(input))*outputChannels + 3] = value.w;
+}

fast/kernels/Algorithms/ImageMultiply/ImageMultiply.cl

@@ -0,0 +1,79 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+float4 readImageAsFloat2D(__read_only image2d_t image, sampler_t sampler, int2 position) {
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT || dataType == CLK_SNORM_INT16 || dataType == CLK_UNORM_INT16) {
+        return read_imagef(image, sampler, position);
+    } else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+        return convert_float4(read_imagei(image, sampler, position));
+    } else {
+        return convert_float4(read_imageui(image, sampler, position));
+    }
+}
+
+
+void writeImageAsFloat2D(__write_only image2d_t image, int2 position, float4 value) {
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT || dataType == CLK_SNORM_INT16 || dataType == CLK_UNORM_INT16) {
+        write_imagef(image, position, value);
+    } else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+        write_imagei(image, position, convert_int4(round(value)));
+    } else {
+        write_imageui(image, position, convert_uint4(round(value)));
+    }
+}
+
+float4 readImageAsFloat3D(__read_only image3d_t image, sampler_t sampler, int4 position) {
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT || dataType == CLK_SNORM_INT16 || dataType == CLK_UNORM_INT16) {
+        return read_imagef(image, sampler, position);
+    } else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+        return convert_float4(read_imagei(image, sampler, position));
+    } else {
+        return convert_float4(read_imageui(image, sampler, position));
+    }
+}
+
+__kernel void multiply3D(
+        __read_only image3d_t input1,
+        __read_only image3d_t input2,
+        __global DATA_TYPE* output,
+        __private uint outputChannels
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+
+    float4 value1 = readImageAsFloat3D(input1, sampler, pos);
+    float4 value2 = readImageAsFloat3D(input2, sampler, pos);
+    float4 value = value1*value2;
+
+    output[(pos.x + pos.y*get_image_width(input1) + pos.z*get_image_width(input1)*get_image_height(input1))*outputChannels] = value.x;
+    if(outputChannels > 1)
+        output[(pos.x + pos.y*get_image_width(input1) + pos.z*get_image_width(input1)*get_image_height(input1))*outputChannels + 1] = value.y;
+    if(outputChannels > 2)
+        output[(pos.x + pos.y*get_image_width(input1) + pos.z*get_image_width(input1)*get_image_height(input1))*outputChannels + 2] = value.z;
+    if(outputChannels > 3)
+        output[(pos.x + pos.y*get_image_width(input1) + pos.z*get_image_width(input1)*get_image_height(input1))*outputChannels + 3] = value.w;
+}
+
+__kernel void multiply2D(
+        __read_only image2d_t input1,
+        __read_only image2d_t input2,
+        __write_only image2d_t output,
+        __private uint input1Channels,
+        __private uint input2Channels,
+        __private uint outputChannels
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+
+    float4 value1 = readImageAsFloat2D(input1, sampler, pos);
+    float4 value2 = readImageAsFloat2D(input2, sampler, pos);
+    float4 value;
+    if(input1Channels == input2Channels) {
+        value = value1*value2;
+    } else if(input1Channels == 1) {
+        value = value1.x*value2;
+    } else if(input2Channels == 1) {
+        value = value1*value2.x;
+    }
+    writeImageAsFloat2D(output, pos, value);
+}

fast/kernels/Algorithms/ImagePatch/PatchStitcher2D.cl

@@ -0,0 +1,22 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void applyPatch2D(
+        __read_only image2d_t patch,
+        __write_only image2d_t image,
+        __private int startX,
+        __private int startY,
+        __private int patchOverlapX,
+        __private int patchOverlapY
+    ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)}; // Patch pos
+    const int2 globalPos = {get_global_id(0) + startX, get_global_id(1) + startY};
+    int dataType = get_image_channel_data_type(image);
+    int2 offset = {patchOverlapX, patchOverlapY};
+    if(dataType == CLK_FLOAT) {
+		write_imagef(image, globalPos, read_imagef(patch, sampler, pos + offset));
+	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+		write_imageui(image, globalPos, read_imageui(patch, sampler, pos + offset));
+	} else {
+		write_imagei(image, globalPos, read_imagei(patch, sampler, pos + offset));
+    }
+}

fast/kernels/Algorithms/ImagePatch/PatchStitcher3D.cl

@@ -0,0 +1,95 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+#ifdef fast_3d_image_writes
+__kernel void applyPatch2Dto3D(
+        __read_only image2d_t patch,
+        __write_only image3d_t image,
+        __private int startX,
+        __private int startY,
+        __private int startZ
+    ) {
+    const int4 pos = {get_global_id(0) + startX, get_global_id(1) + startY, get_global_id(2) + startZ, 0};
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT) {
+		write_imagef(image, pos, read_imagef(patch, sampler, pos.xy - (int2)(startX, startY)));
+	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+		write_imageui(image, pos, read_imageui(patch, sampler, pos.xy - (int2)(startX, startY)));
+	} else {
+		write_imagei(image, pos, read_imagei(patch, sampler, pos.xy - (int2)(startX, startY)));
+    }
+}
+__kernel void applyPatch3D(
+        __read_only image3d_t patch,
+        __write_only image3d_t image,
+        __private int startX,
+        __private int startY,
+        __private int startZ
+    ) {
+    const int4 pos = {get_global_id(0) + startX, get_global_id(1) + startY, get_global_id(2) + startZ, 0};
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT) {
+		write_imagef(image, pos, read_imagef(patch, sampler, pos - (int4)(startX, startY, startZ, 0)));
+	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+		write_imageui(image, pos, read_imageui(patch, sampler, pos - (int4)(startX, startY, startZ, 0)));
+	} else {
+		write_imagei(image, pos, read_imagei(patch, sampler, pos - (int4)(startX, startY, startZ, 0)));
+    }
+}
+#else
+__kernel void applyPatch2Dto3D(
+        __read_only image2d_t patch,
+        __global TYPE* image,
+        __private int startX,
+        __private int startY,
+        __private int startZ,
+        __private int width,
+        __private int height,
+        __private int channels
+    ) {
+    const int4 pos = {get_global_id(0) + startX, get_global_id(1) + startY, get_global_id(2) + startZ, 0};
+    int dataType = get_image_channel_data_type(patch);
+    float4 value;
+    if(dataType == CLK_FLOAT) {
+		value = read_imagef(patch, sampler, pos.xy - (int2)(startX, startY));
+	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+		value = convert_float4(read_imageui(patch, sampler, pos.xy - (int2)(startX, startY)));
+	} else {
+		value = convert_float4(read_imagei(patch, sampler, pos.xy - (int2)(startX, startY)));
+    }
+    image[(pos.x + pos.y*width + pos.z*width*height)*channels] = value.x;
+    if(channels > 1)
+        image[(pos.x + pos.y*width + pos.z*width*height)*channels + 1] = value.y;
+    if(channels > 2)
+        image[(pos.x + pos.y*width + pos.z*width*height)*channels + 2] = value.z;
+    if(channels > 3)
+        image[(pos.x + pos.y*width + pos.z*width*height)*channels + 3] = value.w;
+}
+__kernel void applyPatch3D(
+        __read_only image3d_t patch,
+        __global TYPE* image,
+        __private int startX,
+        __private int startY,
+        __private int startZ,
+        __private int width,
+        __private int height,
+        __private int channels
+    ) {
+    const int4 pos = {get_global_id(0) + startX, get_global_id(1) + startY, get_global_id(2) + startZ, 0};
+    int dataType = get_image_channel_data_type(patch);
+    float4 value;
+    if(dataType == CLK_FLOAT) {
+		value = read_imagef(patch, sampler, pos - (int4)(startX, startY, startZ, 0));
+	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+		value = convert_float4(read_imageui(patch, sampler, pos - (int4)(startX, startY, startZ, 0)));
+	} else {
+		value = convert_float4(read_imagei(patch, sampler, pos - (int4)(startX, startY, startZ, 0)));
+    }
+    image[(pos.x + pos.y*width + pos.z*width*height)*channels] = value.x;
+    if(channels > 1)
+        image[(pos.x + pos.y*width + pos.z*width*height)*channels + 1] = value.y;
+    if(channels > 2)
+        image[(pos.x + pos.y*width + pos.z*width*height)*channels + 2] = value.z;
+    if(channels > 3)
+        image[(pos.x + pos.y*width + pos.z*width*height)*channels + 3] = value.w;
+}
+#endif

fast/kernels/Algorithms/ImageResampler/ImageResampler2D.cl

@@ -0,0 +1,40 @@
+__constant sampler_t samplerLinear = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_LINEAR;
+__constant sampler_t samplerNearest = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+float4 readImageAsFloat2D(__read_only image2d_t image, sampler_t sampler, float2 position) {
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT || dataType == CLK_SNORM_INT16 || dataType == CLK_UNORM_INT16) {
+        return read_imagef(image, sampler, position);
+    } else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+        return convert_float4(read_imagei(image, sampler, position));
+    } else {
+        return convert_float4(read_imageui(image, sampler, position));
+    }
+}
+
+__kernel void resample2D(
+        __read_only image2d_t input,
+        __write_only image2d_t output,
+        __private float scaleX,
+        __private float scaleY,
+        __private uchar useInterpolation
+) {
+    const int2 outputPosition = {get_global_id(0), get_global_id(1)};
+    const int2 size = {get_global_size(0), get_global_size(1)};
+    float2 inputPosition = {outputPosition.x*(1.0f/scaleX), outputPosition.y*(1.0f/scaleY)};
+
+    int dataType = get_image_channel_data_type(output);
+    float4 value;
+    if(useInterpolation == 1) {
+        value = readImageAsFloat2D(input, samplerLinear, inputPosition);
+    } else {
+        value = readImageAsFloat2D(input, samplerNearest, inputPosition);
+    }
+    if(dataType == CLK_FLOAT || dataType == CLK_SNORM_INT16 || dataType == CLK_UNORM_INT16) {
+        write_imagef(output, outputPosition, value);
+    } else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+        write_imagei(output, outputPosition, convert_int4(round(value)));
+    } else {
+        write_imageui(output, outputPosition, convert_uint4(round(value)));
+    }
+}

fast/kernels/Algorithms/ImageResampler/ImageResampler3D.cl

@@ -0,0 +1,32 @@
+__constant sampler_t samplerLinear = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | CLK_FILTER_LINEAR;
+__constant sampler_t samplerNearest = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST;
+
+float readImageAsFloat3D(__read_only image3d_t image, sampler_t sampler, float4 position) {
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT || dataType == CLK_SNORM_INT16 || dataType == CLK_UNORM_INT16) {
+        return read_imagef(image, sampler, position).x;
+    } else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+        return (float)read_imagei(image, sampler, position).x;
+    } else {
+        return (float)read_imageui(image, sampler, position).x;
+    }
+}
+
+__kernel void resample3D(
+        __read_only image3d_t input,
+        __global OUTPUT_TYPE* output,
+        __private float scaleX,
+        __private float scaleY,
+        __private float scaleZ,
+        __private uchar useInterpolation
+) {
+    const int4 outputPosition = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    const int3 size = {get_global_size(0), get_global_size(1), get_global_size(2)};
+    float4 inputPosition = {outputPosition.x*(1.0f/scaleX), outputPosition.y*(1.0f/scaleY), outputPosition.z*(1.0f/scaleZ), 0};
+
+    if(useInterpolation == 1) {
+        output[outputPosition.x + outputPosition.y*size.x + outputPosition.z*size.x*size.y] = readImageAsFloat3D(input, samplerLinear, inputPosition);
+    } else {
+        output[outputPosition.x + outputPosition.y*size.x + outputPosition.z*size.x*size.y] = readImageAsFloat3D(input, samplerNearest, inputPosition);
+    }
+}

fast/kernels/Algorithms/ImageResizer/ImageResizer.cl

@@ -0,0 +1,134 @@
+__constant sampler_t samplerLinear = CLK_NORMALIZED_COORDS_TRUE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_LINEAR;
+__constant sampler_t samplerNearest = CLK_NORMALIZED_COORDS_TRUE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+void writeToImage(__write_only image2d_t input, int2 position, float4 value) {
+    int dataType = get_image_channel_data_type(input);
+	if(dataType == CLK_FLOAT) {
+		write_imagef(input, position, value);
+	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+		write_imageui(input, position, convert_uint4(value));
+	} else {
+		write_imagei(input, position, convert_int4(value));
+    }
+}
+
+float4 readFromImage(__read_only image2d_t input, sampler_t sampler, float2 position) {
+    int dataType = get_image_channel_data_type(input);
+	if(dataType == CLK_FLOAT) {
+		return read_imagef(input, sampler, position);
+	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        return convert_float4(read_imageui(input, sampler, position));
+	} else {
+        return convert_float4(read_imagei(input, sampler, position));
+    }
+}
+
+__kernel void resize2DpreserveAspect(
+	__read_only image2d_t input,
+	__write_only image2d_t output,
+    __private int newHeight,
+    __private char useInterpolation
+	) {
+	const int2 position = {get_global_id(0), get_global_id(1)};
+    const float scale = (float)newHeight / get_image_height(input);
+	const float2 readPosition = {((float)position.x + 0.5f) / get_global_size(0), ((float)position.y + 0.5f) / (scale*get_image_height(input))};
+	float4 value;
+    if(useInterpolation == 1) {
+        value = readFromImage(input, samplerLinear, readPosition);
+    } else {
+        value = readFromImage(input, samplerNearest, readPosition);
+    }
+    if(position.y >= newHeight) {
+        writeToImage(output, position, (float4)(0,0,0,0));
+    } else {
+        writeToImage(output, position, value);
+    }
+}
+
+__kernel void resize2D(
+		__read_only image2d_t input,
+		__write_only image2d_t output,
+        __private char useInterpolation
+    ) {
+	const int2 position = {get_global_id(0), get_global_id(1)};
+	const float2 normalizedPosition = {(float)(position.x + 0.5f) / get_global_size(0), (float)(position.y + 0.5f) / get_global_size(1)};
+	int dataType = get_image_channel_data_type(input);
+	float4 value;
+    if(useInterpolation == 1) {
+        value = readFromImage(input, samplerLinear, normalizedPosition);
+    } else {
+        value = readFromImage(input, samplerNearest, normalizedPosition);
+    }
+    writeToImage(output, position, value);
+}
+
+// ================ 3D
+#ifdef fast_3d_image_writes
+void writeToImage3D(__write_only image3d_t input, int4 position, float4 value) {
+    int dataType = get_image_channel_data_type(input);
+	if(dataType == CLK_FLOAT) {
+		write_imagef(input, position, value);
+	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+		write_imageui(input, position, convert_uint4(value));
+	} else {
+		write_imagei(input, position, convert_int4(value));
+    }
+}
+#endif
+
+float4 readFromImage3D(__read_only image3d_t input, sampler_t sampler, float4 position) {
+    int dataType = get_image_channel_data_type(input);
+	if(dataType == CLK_FLOAT) {
+		return read_imagef(input, sampler, position);
+	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        return convert_float4(read_imageui(input, sampler, position));
+	} else {
+        return convert_float4(read_imagei(input, sampler, position));
+    }
+}
+
+__kernel void resize3D(
+		__read_only image3d_t input,
+#ifdef fast_3d_image_writes
+		__write_only image3d_t output,
+#else
+        __global void* output,
+#endif
+        __private char useInterpolation
+    ) {
+	const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+	const float4 normalizedPosition = {
+	        ((float)pos.x + 0.5f) / get_global_size(0),
+            ((float)pos.y + 0.5f) / get_global_size(1),
+            ((float)pos.z + 0.5f) / get_global_size(2),
+            0
+	};
+	int dataType = get_image_channel_data_type(input);
+	float4 value;
+    if(useInterpolation == 1) {
+        value = readFromImage3D(input, samplerLinear, normalizedPosition);
+    } else {
+        value = readFromImage3D(input, samplerNearest, normalizedPosition);
+    }
+
+#ifdef fast_3d_image_writes
+    writeToImage3D(output, pos, value);
+#else
+    // TODO only one channel supported atm
+    if(dataType == CLK_UNSIGNED_INT8) {
+        ((__global uchar*)output)[pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)] = value.x;
+    } else if(dataType == CLK_SIGNED_INT8) {
+        ((__global char*)output)[pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)] = value.x;
+    } else if(dataType == CLK_UNSIGNED_INT16) {
+        ((__global ushort*)output)[pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)] = value.x;
+    } else if(dataType == CLK_SIGNED_INT16) {
+        ((__global short*)output)[pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)] = value.x;
+    } else if(dataType == CLK_UNSIGNED_INT32) {
+        ((__global uint*)output)[pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)] = value.x;
+    } else if(dataType == CLK_SIGNED_INT32) {
+        ((__global int*)output)[pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)] = value.x;
+    } else if(dataType == CLK_FLOAT) {
+        ((__global float*)output)[pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)] = value.x;
+    }
+#endif
+}

fast/kernels/Algorithms/ImageSharpening/ImageSharpening.cl

@@ -0,0 +1,47 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+__kernel void sharpen(
+        __read_only image2d_t input,
+        __write_only image2d_t output,
+        __private float stdDev,
+        __private float gain
+        ) {
+
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+
+    float4 sum = {0.0f, 0.0f, 0.0f, 0.0f};
+    float gaussianSum = 0.0f;
+    const int dataType = get_image_channel_data_type(input);
+    for(int x = -HALF_SIZE; x <= HALF_SIZE; ++x) {
+    for(int y = -HALF_SIZE; y <= HALF_SIZE; ++y) {
+        const int2 offset = {x,y};
+        const float gaussian =  exp(-(float)(x*x+y*y)/(2.0f*stdDev*stdDev));
+        gaussianSum += gaussian;
+        if(dataType == CLK_FLOAT) {
+            sum += gaussian*read_imagef(input, sampler, pos+offset);
+        } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+            sum += gaussian*convert_float4(read_imageui(input, sampler, pos+offset));
+        } else {
+            sum += gaussian*convert_float4(read_imagei(input, sampler, pos+offset));
+        }
+    }}
+    float4 pixel;
+    if(dataType == CLK_FLOAT) {
+        pixel = read_imagef(input, sampler, pos);
+    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        pixel = convert_float4(read_imageui(input, sampler, pos));
+    } else {
+        pixel = convert_float4(read_imagei(input, sampler, pos));
+    }
+
+    float4 result = pixel + gain*(pixel - sum/gaussianSum);
+
+    const int outputDataType = get_image_channel_data_type(output);
+    if(outputDataType == CLK_FLOAT) {
+        write_imagef(output, pos, result);
+    } else if(outputDataType == CLK_UNSIGNED_INT8 || outputDataType == CLK_UNSIGNED_INT16 || outputDataType == CLK_UNSIGNED_INT32) {
+        write_imageui(output, pos, convert_uint4(round(result)));
+    } else {
+        write_imagei(output, pos, convert_int4(round(result)));
+    }
+}