pyfast 4.12.0__cp36-abi3-win_amd64.whl

fast/kernels/Algorithms/ImageSlicer/ImageSlicer.cl

@@ -0,0 +1,77 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST;
+
+__kernel void orthogonalSlicing(
+        __read_only image3d_t input,
+        __write_only image2d_t output,
+        __private int slice,
+        __private int slicePlane
+        ) {
+    const int x = get_global_id(0);
+    const int y = get_global_id(1);
+
+    int4 pos;
+    if(slicePlane == 0) {
+        pos = (int4)(slice,x,y,0);
+    } else if(slicePlane == 1) {
+        pos = (int4)(x,slice,y,0);
+    } else {
+        pos = (int4)(x,y,slice,0);
+    }
+
+    int dataType = get_image_channel_data_type(input);
+    if(dataType == CLK_FLOAT) {
+		float4 value = read_imagef(input, sampler, pos);
+		write_imagef(output, (int2)(x,y), value);
+	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+		uint4 value = read_imageui(input, sampler, pos);
+		write_imageui(output, (int2)(x,y), value);
+	} else {
+		int4 value = read_imagei(input, sampler, pos);
+		write_imagei(output, (int2)(x,y), value);
+    }
+}
+
+float4 transformPosition(__constant float* transform, int2 PBOposition) {
+    float4 position = {PBOposition.x, PBOposition.y, 0, 1};
+    float transformedPosition[4];
+    //printf("PBO pos: %d %d\n", PBOposition.x, PBOposition.y);
+
+    // Multiply with transform
+    // transform is column major
+    for(int i = 0; i < 4; i++) {
+        float sum = 0;
+        sum += transform[i + 0*4]*position.x;
+        sum += transform[i + 1*4]*position.y;
+        sum += transform[i + 2*4]*position.z;
+        sum += transform[i + 3*4]*position.w;
+        transformedPosition[i] = sum;
+    }
+    //printf("Transformed pos: %f %f %f\n", transformedPosition[0], transformedPosition[1], transformedPosition[2]);
+
+    float4 result = {transformedPosition[0], transformedPosition[1], transformedPosition[2], transformedPosition[3]};
+    return result;
+}
+
+__kernel void arbitrarySlicing(
+        __read_only image3d_t input,
+        __write_only image2d_t output,
+        __constant float* transform
+    ) {
+
+    const int2 position = {get_global_id(0), get_global_id(1)};
+
+    float4 imagePosition = transformPosition(transform, position);
+    imagePosition.w = 1;
+
+    int dataType = get_image_channel_data_type(input);
+    if(dataType == CLK_FLOAT) {
+		float4 value = read_imagef(input, sampler, imagePosition);
+		write_imagef(output, position, value);
+	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+		uint4 value = read_imageui(input, sampler, imagePosition);
+		write_imageui(output, position, value);
+	} else {
+		int4 value = read_imagei(input, sampler, imagePosition);
+		write_imagei(output, position, value);
+    }
+}

fast/kernels/Algorithms/ImageTransposer/ImageTransposer2D.cl

@@ -0,0 +1,16 @@
+const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_NONE;
+
+__kernel void transpose2D(
+    __read_only image2d_t input,
+    __write_only image2d_t output
+    ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    int dataType = get_image_channel_data_type(input);
+    if(dataType == CLK_FLOAT) {
+        write_imagef(output, pos.yx, read_imagef(input, sampler, pos));
+    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        write_imageui(output, pos.yx, read_imageui(input, sampler, pos));
+    } else {
+        write_imagei(output, pos.yx, read_imagei(input, sampler, pos));
+    }
+}

fast/kernels/Algorithms/ImageTransposer/ImageTransposer3D.cl

@@ -0,0 +1,45 @@
+const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_NONE;
+
+__kernel void transpose3D(
+    __read_only image3d_t input,
+    __global TYPE* output,
+    __private int axes1,
+    __private int axes2,
+    __private int axes3,
+    __private int channels
+    ) {
+
+    int pos[3] = {get_global_id(0), get_global_id(1), get_global_id(2)};
+    int4 posInput = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    int size[3] = {get_image_width(input), get_image_height(input), get_image_depth(input)};
+
+    int dataType = get_image_channel_data_type(input);
+    if(dataType == CLK_FLOAT) {
+        float4 value = read_imagef(input, sampler, posInput);
+        output[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*channels] = value.x;
+        if(channels > 1)
+            output[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*channels + 1] = value.y;
+        if(channels > 2)
+            output[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*channels + 2] = value.z;
+        if(channels > 3)
+            output[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*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[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*channels] = value.x;
+        if(channels > 1)
+            output[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*channels + 1] = value.y;
+        if(channels > 2)
+            output[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*channels + 2] = value.z;
+        if(channels > 3)
+            output[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*channels + 3] = value.w;
+    } else {
+        int4 value = read_imagei(input, sampler, posInput);
+        output[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*channels] = value.x;
+        if(channels > 1)
+            output[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*channels + 1] = value.y;
+        if(channels > 2)
+            output[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*channels + 2] = value.z;
+        if(channels > 3)
+            output[(pos[axes1] + pos[axes2]*size[axes1] + pos[axes3]*size[axes1]*size[axes2])*channels + 3] = value.w;
+    }
+}

fast/kernels/Algorithms/IntensityClipping/IntensityClipping2D.cl

@@ -0,0 +1,19 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void clip2D(
+        __read_only image2d_t input,
+        __write_only image2d_t output,
+        __private float min,
+        __private float max
+    ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    const int dataType = get_image_channel_data_type(input);
+
+    if(dataType == CLK_FLOAT) {
+        write_imagef(output, pos, clamp(read_imagef(input, sampler, pos), min, max));
+    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        write_imageui(output, pos, clamp(read_imageui(input, sampler, pos), (uint)min, (uint)max));
+    } else {
+        write_imagei(output, pos, clamp(read_imagei(input, sampler, pos), (int)min, (int)max));
+    }
+}

fast/kernels/Algorithms/IntensityClipping/IntensityClipping3D.cl

@@ -0,0 +1,20 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void clip3D(
+        __read_only image3d_t input,
+        __global TYPE* output,
+        __private float min,
+        __private float max
+    ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    const int4 size = {get_global_size(0), get_global_size(1), get_global_size(2), 0};
+    const int dataType = get_image_channel_data_type(input);
+
+    if(dataType == CLK_FLOAT) {
+        output[pos.x + pos.y*size.x + pos.z*size.x*size.y] = clamp(read_imagef(input, sampler, pos).x, min, max);
+    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        output[pos.x + pos.y*size.x + pos.z*size.x*size.y] = clamp(read_imageui(input, sampler, pos).x, (uint)min, (uint)max);
+    } else {
+        output[pos.x + pos.y*size.x + pos.z*size.x*size.y] = clamp(read_imagei(input, sampler, pos).x, (int)min, (int)max);
+    }
+}

fast/kernels/Algorithms/IntensityNormalization/IntensityNormalization.cl

@@ -0,0 +1,85 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void scaleImage2D(
+        __read_only image2d_t input,
+        __write_only image2d_t output,
+        __private float min,
+        __private float max,
+        __private float low,
+        __private float high
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    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 = (value - min) / (max - min);
+    value = value*(high - low) + low;
+    
+    write_imagef(output, pos, value);
+}
+
+#ifdef fast_3d_image_writes
+__kernel void scaleImage3D(
+        __read_only image3d_t input,
+        __write_only image3d_t output,
+        __private float min,
+        __private float max,
+        __private float low,
+        __private float high
+        ) {
+    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 = (value - min) / (max - min);
+    value = value*(high - low) + low;
+    
+    write_imagef(output, pos, value);
+}
+#else
+__kernel void scaleImage3D(
+        __read_only image3d_t input,
+        __global float* output,
+        __private float min,
+        __private float max,
+        __private float low,
+        __private float high,
+        __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 = (value - min) / (max - min);
+    value = value*(high - low) + low;
+    
+    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;
+}
+#endif

fast/kernels/Algorithms/IntensityNormalization/ZeroMeanUnitVariance.cl

@@ -0,0 +1,76 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void normalize2D(
+        __read_only image2d_t input,
+        __write_only image2d_t output,
+        __private float average,
+        __private float std
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    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 = (value - average) / std;
+
+    write_imagef(output, pos, value);
+}
+
+#ifdef fast_3d_image_writes
+__kernel void normalize3D(
+        __read_only image3d_t input,
+        __write_only image3d_t output,
+        __private float average,
+        __private float std
+        ) {
+    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 = (value - average) / std;
+
+    write_imagef(output, pos, value);
+}
+#else
+__kernel void normalize3D(
+        __read_only image3d_t input,
+        __global float* output,
+        __private float average,
+        __private float std,
+        __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 = (value - average) / std;
+
+    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;
+}
+#endif

fast/kernels/Algorithms/KalmanFilterModelSegmentation/AppearanceModels/RidgeEdge/RidgeEdgeModel.cl

@@ -0,0 +1,81 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST;
+
+float3 transform(const float3 position, __constant float* transformationMatrix) {
+    float3 result;
+    result.x = position.x*transformationMatrix[0] + position.y*transformationMatrix[1] + position.z*transformationMatrix[2] + transformationMatrix[3];
+    result.y = position.x*transformationMatrix[4] + position.y*transformationMatrix[5] + position.z*transformationMatrix[6] + transformationMatrix[7];
+    result.z = position.x*transformationMatrix[8] + position.y*transformationMatrix[9] + position.z*transformationMatrix[10] + transformationMatrix[11];
+    return result;
+}
+
+
+__kernel void edgeDetection2D(
+        __read_only image2d_t image,
+        __global float* points,
+        __private float lineSearchDistance,
+        __private float sampleSpacing,
+        __local float* intensityProfile,
+        __global float* results,
+        __private float spacingX,
+        __private float spacingY,
+        __private int size
+        ) {
+    const int sampleNr = get_global_id(0);
+    const int pointNr = get_global_id(1);
+    const int nrOfSamples = get_global_size(0);
+    const float2 position = vload2(pointNr*2, points);
+    const float2 normal = vload2(pointNr*2+1, points);
+    const float distance = -lineSearchDistance/2.0f + sampleNr*sampleSpacing;
+    //printf("s: %d, d: %f \n", sampleNr, distance);
+    float2 samplePosition = position + distance*normal;
+    samplePosition.x /= spacingX;
+    samplePosition.y /= spacingY;
+    //printf("p: %f %f, sp: %f %f, n: %f %f\n", position.x, position.y, samplePosition.x, samplePosition.y, normal.x, normal.y);
+
+    // All read intensity profile into local memory
+    // TODO support for other types of images
+    intensityProfile[sampleNr] = (float)read_imageui(image, sampler, samplePosition).x;
+
+    // TODO how do we deal with out of image/mask here?
+
+    // Synchronize
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    float sumBeforeRidge = 0.0f;
+    float sumInRidge = 0.0f;
+    float sumAfterRidge = 0.0f;
+    int startPos = -1;
+    int endPos = -1;
+    for(int i = 0; i < nrOfSamples; i++) {
+        if(startPos == -1 && intensityProfile[i] > 0)
+            startPos = i;
+        if(startPos >= 0 && intensityProfile[i] == 0) {
+            endPos = i;
+        }
+        if(startPos >= 0 && endPos == -1) {
+            if(i <= sampleNr) {
+                sumBeforeRidge += intensityProfile[i];
+            } else if(i <= sampleNr + size) {
+                sumInRidge += intensityProfile[i];
+            }
+        }
+    }
+    if(endPos < 0)
+        endPos = nrOfSamples - 1;
+
+    // Calculate intensity diffs
+    const float averageBeforeRidge = sumBeforeRidge / (sampleNr+1 - startPos);
+    const float averageInRidge = sumInRidge / size;
+
+    const float intensityDifference = averageInRidge - averageBeforeRidge;
+
+    results[sampleNr + pointNr*nrOfSamples] = intensityDifference;
+
+
+    // TODO
+
+    // Store score and uncertainty in local memory
+    // Use first thread to calculate best score of all samples
+    // Store sampleNr and uncertainty in global memory
+
+}

fast/kernels/Algorithms/LabelModifier/LabelModifier.cl

@@ -0,0 +1,20 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void modifyLabels(
+        __read_only image2d_t input,
+        __write_only image2d_t output,
+        __global uchar* labelChanges,
+        __private int count
+    ) {
+
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    uchar value = read_imageui(input, sampler, pos).x;
+    uchar newValue = value;
+    for(int i = 0; i < count-1; ++i) {
+        if(value == labelChanges[i*2]) {
+            newValue = labelChanges[i*2+1];
+        }
+    }
+
+    write_imageui(output, pos, newValue);
+}

fast/kernels/Algorithms/LaplacianOfGaussian/LaplacianOfGaussian2D.cl

@@ -0,0 +1,27 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST;
+
+__kernel void laplacianOfGaussian(
+        __read_only image2d_t input,
+        __constant float * mask,
+        __write_only image2d_t output,
+        __private unsigned char maskSize
+        ) {
+
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    const unsigned char halfSize = (maskSize-1)/2;
+
+    float sum = 0.0f;
+    for(int x = -halfSize; x <= halfSize; x++) {
+    for(int y = -halfSize; y <= halfSize; y++) {
+        const int2 offset = {x,y};
+#ifdef TYPE_FLOAT
+        sum += mask[x+halfSize+(y+halfSize)*maskSize]*read_imagef(input, sampler, pos+offset).x;
+#elif TYPE_UINT
+        sum += mask[x+halfSize+(y+halfSize)*maskSize]*read_imageui(input, sampler, pos+offset).x;
+#else
+        sum += mask[x+halfSize+(y+halfSize)*maskSize]*read_imagei(input, sampler, pos+offset).x;
+#endif
+    }}
+
+    write_imagef(output, pos, sum);
+}

fast/kernels/Algorithms/LevelSet/LevelSetSegmentation.cl

@@ -0,0 +1,132 @@
+#ifdef fast_3d_image_writes
+#define PHI_WRITE_TYPE __write_only image3d_t
+#define WRITE_RESULT(storage, pos, value) write_imagef(storage, pos, value)
+#else
+#define PHI_WRITE_TYPE __global float *
+#define WRITE_RESULT(storage, pos, value) storage[pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)] = value;
+#endif
+
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+__kernel void updateLevelSetFunction(
+        __read_only image3d_t input,
+        __read_only image3d_t phi_read,
+        PHI_WRITE_TYPE phi_write,
+        __private float threshold,
+        __private float epsilon,
+        __private float alpha,
+        PHI_WRITE_TYPE speedStorage,
+        __private float deltaT
+) {
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+    int z = get_global_id(2);
+    const int4 pos = {x,y,z,0};
+
+    // Calculate all first order derivatives
+    float3 D = {
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x+1,y,z,0)).x-read_imagef(phi_read,sampler,(int4)(x-1,y,z,0)).x),
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x,y+1,z,0)).x-read_imagef(phi_read,sampler,(int4)(x,y-1,z,0)).x),
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x,y,z+1,0)).x-read_imagef(phi_read,sampler,(int4)(x,y,z-1,0)).x)
+    };
+    float3 Dminus = {
+            read_imagef(phi_read,sampler,pos).x-read_imagef(phi_read,sampler,(int4)(x-1,y,z,0)).x,
+            read_imagef(phi_read,sampler,pos).x-read_imagef(phi_read,sampler,(int4)(x,y-1,z,0)).x,
+            read_imagef(phi_read,sampler,pos).x-read_imagef(phi_read,sampler,(int4)(x,y,z-1,0)).x
+    };
+    float3 Dplus = {
+            read_imagef(phi_read,sampler,(int4)(x+1,y,z,0)).x-read_imagef(phi_read,sampler,pos).x,
+            read_imagef(phi_read,sampler,(int4)(x,y+1,z,0)).x-read_imagef(phi_read,sampler,pos).x,
+            read_imagef(phi_read,sampler,(int4)(x,y,z+1,0)).x-read_imagef(phi_read,sampler,pos).x
+    };
+
+    // Calculate gradient
+    float3 gradientMin = {
+            sqrt(pow(min(Dplus.x, 0.0f), 2.0f) + pow(min(-Dminus.x, 0.0f), 2.0f)),
+            sqrt(pow(min(Dplus.y, 0.0f), 2.0f) + pow(min(-Dminus.y, 0.0f), 2.0f)),
+            sqrt(pow(min(Dplus.z, 0.0f), 2.0f) + pow(min(-Dminus.z, 0.0f), 2.0f))
+    };
+    float3 gradientMax = {
+            sqrt(pow(max(Dplus.x, 0.0f), 2.0f) + pow(max(-Dminus.x, 0.0f), 2.0f)),
+            sqrt(pow(max(Dplus.y, 0.0f), 2.0f) + pow(max(-Dminus.y, 0.0f), 2.0f)),
+            sqrt(pow(max(Dplus.z, 0.0f), 2.0f) + pow(max(-Dminus.z, 0.0f), 2.0f))
+    };
+
+    // Calculate all second order derivatives
+    float3 DxMinus = {
+            0.0f,
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x+1,y-1,z,0)).x-read_imagef(phi_read,sampler,(int4)(x-1,y-1,z,0)).x),
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x+1,y,z-1,0)).x-read_imagef(phi_read,sampler,(int4)(x-1,y,z-1,0)).x)
+    };
+    float3 DxPlus = {
+            0.0f,
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x+1,y+1,z,0)).x-read_imagef(phi_read,sampler,(int4)(x-1,y+1,z,0)).x),
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x+1,y,z+1,0)).x-read_imagef(phi_read,sampler,(int4)(x-1,y,z+1,0)).x)
+    };
+    float3 DyMinus = {
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x-1,y+1,z,0)).x-read_imagef(phi_read,sampler,(int4)(x-1,y-1,z,0)).x),
+            0.0f,
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x,y+1,z-1,0)).x-read_imagef(phi_read,sampler,(int4)(x,y-1,z-1,0)).x)
+    };
+    float3 DyPlus = {
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x+1,y+1,z,0)).x-read_imagef(phi_read,sampler,(int4)(x+1,y-1,z,0)).x),
+            0.0f,
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x,y+1,z+1,0)).x-read_imagef(phi_read,sampler,(int4)(x,y-1,z+1,0)).x)
+    };
+    float3 DzMinus = {
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x-1,y,z+1,0)).x-read_imagef(phi_read,sampler,(int4)(x-1,y,z-1,0)).x),
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x,y-1,z+1,0)).x-read_imagef(phi_read,sampler,(int4)(x,y-1,z-1,0)).x),
+            0.0f
+    };
+    float3 DzPlus = {
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x+1,y,z+1,0)).x-read_imagef(phi_read,sampler,(int4)(x+1,y,z-1,0)).x),
+            0.5f*(read_imagef(phi_read,sampler,(int4)(x,y+1,z+1,0)).x-read_imagef(phi_read,sampler,(int4)(x,y+1,z-1,0)).x),
+            0.0f
+    };
+
+    // Calculate curvature
+    float3 nMinus = {
+            Dminus.x / sqrt(FLT_EPSILON+Dminus.x*Dminus.x+pow(0.5f*(DyMinus.x+D.y),2.0f)+pow(0.5f*(DzMinus.x+D.z),2.0f)),
+            Dminus.y / sqrt(FLT_EPSILON+Dminus.y*Dminus.y+pow(0.5f*(DxMinus.y+D.x),2.0f)+pow(0.5f*(DzMinus.y+D.z),2.0f)),
+            Dminus.z / sqrt(FLT_EPSILON+Dminus.z*Dminus.z+pow(0.5f*(DxMinus.z+D.x),2.0f)+pow(0.5f*(DyMinus.z+D.y),2.0f))
+    };
+    float3 nPlus = {
+            Dplus.x / sqrt(FLT_EPSILON+Dplus.x*Dplus.x+pow(0.5f*(DyPlus.x+D.y),2.0f)+pow(0.5f*(DzPlus.x+D.z),2.0f)),
+            Dplus.y / sqrt(FLT_EPSILON+Dplus.y*Dplus.y+pow(0.5f*(DxPlus.y+D.x),2.0f)+pow(0.5f*(DzPlus.y+D.z),2.0f)),
+            Dplus.z / sqrt(FLT_EPSILON+Dplus.z*Dplus.z+pow(0.5f*(DxPlus.z+D.x),2.0f)+pow(0.5f*(DyPlus.z+D.y),2.0f))
+    };
+
+    float curvature = ((nPlus.x-nMinus.x)+(nPlus.y-nMinus.y)+(nPlus.z-nMinus.z))*0.5f;
+
+    // Calculate speed term
+    float speed = -(1.0f-alpha)*max(-epsilon, (epsilon-fabs(threshold-read_imagei(input,sampler,pos).x)))/epsilon + alpha*curvature;
+
+    // Determine gradient based on speed direction
+    float3 gradient;
+    if(speed < 0) {
+        gradient = gradientMin;
+    } else {
+        gradient = gradientMax;
+    }
+    if(length(gradient) > 1.0f)
+        gradient = normalize(gradient);
+
+    // Stability CFL
+    // max(fabs(speed*gradient.length()))
+    WRITE_RESULT(speedStorage, pos, fabs(speed*length(gradient)));
+
+    // Update the level set function phi
+    WRITE_RESULT(phi_write, pos, read_imagef(phi_read,sampler,pos).x + deltaT*speed*length(gradient));
+}
+
+__kernel void initializeLevelSetFunction(
+        PHI_WRITE_TYPE phi,
+        __private int seedX,
+        __private int seedY,
+        __private int seedZ,
+        __private float radius
+) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+
+    WRITE_RESULT(phi, pos, distance((float3)(seedX,seedY,seedZ), convert_float3(pos.xyz)) - radius);
+}

fast/kernels/Algorithms/LungSegmentation/LungSegmentation.cl

@@ -0,0 +1,22 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+#define LPOS(pos) pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)
+
+__kernel void convertToHU(
+	__read_only image3d_t input,
+#ifdef fast_3d_image_writes
+	__write_only image3d_t output
+#else
+	__global short* output
+#endif
+	) {
+	const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+	
+	int value = read_imageui(input, sampler, pos).x;
+	value -= 1024;
+#ifdef fast_3d_image_writes
+	write_imagei(output, pos, value);
+#else
+	output[LPOS(pos)] = value;
+#endif
+}