pyfast 4.12.0__cp36-abi3-macosx_10_13_x86_64.whl

fast/kernels/Algorithms/CenterlineExtraction/CenterlineExtraction.cl

@@ -0,0 +1,153 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | 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 initialize(
+	__read_only image3d_t input,
+#ifdef fast_3d_image_writes
+	__write_only image3d_t distance
+#else
+	__global short* distance
+#endif
+	) {
+	const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+	
+	uint value = read_imageui(input, sampler, pos).x;
+	if(value == 0) {
+		// Outside
+#ifdef fast_3d_image_writes
+		write_imagei(distance, pos, 0);
+#else
+		distance[LPOS(pos)] = 0;
+#endif
+	} else {
+		// Inside
+		bool atBorder = false;
+        for(int a = -1; a <= 1;  ++a) {
+        for(int b = -1; b <= 1;  ++b) {
+        for(int c = -1; c <= 1;  ++c) {
+        	int4 nPos = (int4)(a,b,c,0) + pos;
+            uint value2 = read_imageui(input, sampler, nPos).x;
+            if(value2 == 0) {
+                atBorder = true;
+            }
+        }}}
+        if(atBorder) {
+#ifdef fast_3d_image_writes
+            write_imagei(distance, pos, -1);
+#else
+			distance[LPOS(pos)] = -1;
+#endif
+        } else {
+#ifdef fast_3d_image_writes
+            write_imagei(distance, pos, -1);
+#else
+			distance[LPOS(pos)] = -1;
+#endif
+        }
+	}
+}
+
+__constant int4 neighbors[] = {
+	{1, 0, 0, 0},
+	{-1, 0, 0, 0},
+	{0, 1, 0, 0},
+	{0, -1, 0, 0},
+	{0, 0, 1, 0},
+	{0, 0, -1, 0}
+};
+
+__kernel void calculateDistance(
+#ifdef fast_3d_image_writes
+	__read_only image3d_t input,
+	__write_only image3d_t output,
+#else
+	__global short* input,
+	__global short* output,
+#endif
+	__global char* changed
+	) {
+	const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+#ifdef fast_3d_image_writes
+	int value = read_imagei(input, sampler, pos).x;
+#else
+	int value = input[LPOS(pos)];
+#endif
+	if(value == -1) { // -1 means no distance calculated yet
+		int minNeighborDistance = 999999;
+        for(int i = 0; i < 6; ++i) {
+        	int4 nPos = neighbors[i] + pos;
+#ifdef fast_3d_image_writes
+			int value2 = read_imagei(input, sampler, nPos).x;
+#else
+			int value2 = input[LPOS(nPos)];
+#endif
+        	if(value2 < minNeighborDistance && value2 >= 0) {
+        		minNeighborDistance = value2;
+        	}
+        }
+        
+        if(minNeighborDistance < 999999) {
+        	// Valid neighbor found
+#ifdef fast_3d_image_writes
+        	write_imagei(output, pos, minNeighborDistance+1);
+#else
+			output[LPOS(pos)] = minNeighborDistance+1;
+#endif
+        	changed[0] = 1;
+        }
+	} else {
+#ifdef fast_3d_image_writes
+        write_imagei(output, pos, value);
+#else
+		output[LPOS(pos)] = value;
+#endif
+    }
+}
+
+__kernel void findCandidateCenterpoints(
+			__read_only image3d_t segmentation,
+			__read_only image3d_t distanceImage,
+#ifdef fast_3d_image_writes
+			__write_only image3d_t output
+#else
+			__global uchar* output
+#endif
+        ) {
+	const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    if(read_imageui(segmentation, sampler, pos).x == 1) {
+        // Inside object
+        short distance = read_imagei(distanceImage, sampler, pos).x;
+
+        // Check if voxel is candidate centerline
+        int N = 4;
+        bool invalid = false;
+        for(int a = -N; a <= N;  ++a) {
+        for(int b = -N; b <= N;  ++b) {
+        for(int c = -N; c <= N;  ++c) {
+            short distance2 = read_imagei(distanceImage, sampler, pos + (int4)(a,b,c,0)).x;
+            if(distance2 > distance) {
+                invalid = true;
+            }
+        }}}
+
+#ifdef fast_3d_image_writes
+        if(!invalid) {
+        	write_imageui(output, pos, 1);
+        } else {
+        	write_imageui(output, pos, 0);
+        }
+    } else {
+        write_imageui(output, pos, 0);
+    }
+#else
+        if(!invalid) {
+			output[LPOS(pos)] = 1;
+        } else {
+			output[LPOS(pos)] = 0;
+        }
+    } else {
+		output[LPOS(pos)] = 0;
+    }
+#endif
+}

fast/kernels/Algorithms/Color/ColorToGrayscale.cl

@@ -0,0 +1,22 @@
+__const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_NONE;
+
+__kernel void convert(
+    __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_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        uint4 value = read_imageui(input, sampler, pos);
+        uint average = round(((float)(value.x + value.y + value.z))/3.0f);
+        write_imageui(output, pos, average);
+    } else if(dataType == CLK_FLOAT) {
+        float4 value = read_imagef(input, sampler, pos);
+        float average = value.x + value.y + value.z;
+        write_imagef(output, pos, average);
+    } else {
+        int4 value = read_imagei(input, sampler, pos);
+        int average = round(((float)(value.x + value.y + value.z))/3.0f);
+        write_imagei(output, pos, average);
+    }
+}

fast/kernels/Algorithms/Color/GrayscaleToColor.cl

@@ -0,0 +1,19 @@
+__const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_NONE;
+
+__kernel void convert(
+    __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_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        uint value = read_imageui(input, sampler, pos).x;
+        write_imageui(output, pos, (uint4)(value, value, value, 255));
+    } else if(dataType == CLK_FLOAT) {
+        float value = read_imagef(input, sampler, pos).x;
+        write_imagef(output, pos, (float4)(value, value, value, 1.0f));
+    } else {
+        int value = read_imagei(input, sampler, pos).x;
+        write_imagei(output, pos, (int4)(value, value, value, 1));
+    }
+}

fast/kernels/Algorithms/GaussianSmoothing/GaussianSmoothing2D.cl

@@ -0,0 +1,35 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+__kernel void gaussianSmoothing(
+        __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;
+    int dataType = get_image_channel_data_type(input);
+    for(int x = -halfSize; x <= halfSize; x++) {
+    for(int y = -halfSize; y <= halfSize; y++) {
+        const int2 offset = {x,y};
+        if(dataType == CLK_FLOAT) {
+            sum += mask[x+halfSize+(y+halfSize)*maskSize]*read_imagef(input, sampler, pos+offset).x;
+        } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+            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;
+        }
+    }}
+
+    int outputDataType = get_image_channel_data_type(output);
+    if(outputDataType == CLK_FLOAT) {
+        write_imagef(output, pos, sum);
+    } else if(outputDataType == CLK_UNSIGNED_INT8 || outputDataType == CLK_UNSIGNED_INT16 || outputDataType == CLK_UNSIGNED_INT32) {
+        write_imageui(output, pos, round(sum));
+    } else {
+        write_imagei(output, pos, round(sum));
+    }
+}

fast/kernels/Algorithms/GaussianSmoothing/GaussianSmoothing3D.cl

@@ -0,0 +1,75 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+#ifdef fast_3d_image_writes
+__kernel void gaussianSmoothing(
+        __read_only image3d_t input,
+        __constant float * mask,
+        __write_only image3d_t output,
+        __private unsigned char maskSize,
+        __private unsigned char direction
+        ) {
+
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    const unsigned char halfSize = (maskSize-1)/2;
+
+    float sum = 0.0f;
+    int dataType = get_image_channel_data_type(input);
+    for(int i = -halfSize; i <= halfSize; ++i) {
+        int4 offset = {0,0,0,0};
+        if(direction == 0) {
+            offset.x = i;
+        } else if(direction == 1) {
+            offset.y = i;
+        } else {
+            offset.z = i;
+        }
+        const uchar maskOffset = halfSize + i;
+        if(dataType == CLK_FLOAT) {
+            sum += mask[maskOffset]*read_imagef(input, sampler, pos+offset).x;
+        } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+            sum += mask[maskOffset]*read_imageui(input, sampler, pos+offset).x;
+        } else {
+            sum += mask[maskOffset]*read_imagei(input, sampler, pos+offset).x;
+        }
+    }
+
+    int outputDataType = get_image_channel_data_type(output);
+    if(outputDataType == CLK_FLOAT) {
+        write_imagef(output, pos, sum);
+    } else if(outputDataType == CLK_UNSIGNED_INT8 || outputDataType == CLK_UNSIGNED_INT16 || outputDataType == CLK_UNSIGNED_INT32) {
+        write_imageui(output, pos, round(sum));
+    } else {
+        write_imagei(output, pos, round(sum));
+    }
+}
+
+#else
+__kernel void gaussianSmoothing(
+        __read_only image3d_t input,
+        __constant float * mask,
+        __global TYPE* output,
+        __private unsigned char maskSize
+        ) {
+
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    const unsigned char halfSize = (maskSize-1)/2;
+
+    float sum = 0.0f;
+    int dataType = get_image_channel_data_type(input);
+    for(int x = -halfSize; x <= halfSize; x++) {
+    for(int y = -halfSize; y <= halfSize; y++) {
+    for(int z = -halfSize; z <= halfSize; z++) {
+        const int4 offset = {x,y,z,0};
+        const uint maskOffset = x+halfSize+(y+halfSize)*maskSize+(z+halfSize)*maskSize*maskSize;
+        if(dataType == CLK_FLOAT) {
+            sum += mask[maskOffset]*read_imagef(input, sampler, pos+offset).x;
+        } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+            sum += mask[maskOffset]*read_imageui(input, sampler, pos+offset).x;
+        } else {
+            sum += mask[maskOffset]*read_imagei(input, sampler, pos+offset).x;
+        }
+    }}}
+
+    output[pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)] = sum;
+}
+#endif

fast/kernels/Algorithms/GradientVectorFlow/EulerGradientVectorFlow.cl

@@ -0,0 +1,174 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+__kernel void GVF2DCopy(__read_only image2d_t input, __write_only image2d_t output) {
+    int2 pos = {get_global_id(0), get_global_id(1)};
+    write_imagef(output, pos, read_imagef(input, sampler, pos)); 
+}
+
+__kernel void GVF2DIteration(__read_only image2d_t init_vector_field, __read_only image2d_t read_vector_field, __write_only image2d_t write_vector_field, __private float mu) {
+
+    int2 writePos = {get_global_id(0), get_global_id(1)};
+
+    // Enforce mirror boundary conditions
+    int2 size = {get_global_size(0), get_global_size(1)};
+    int2 pos = writePos;
+    pos = select(pos, (int2)(2,2), pos == (int2)(0,0));
+    pos = select(pos, size-3, pos >= size-1);
+
+    float2 f = read_imagef(read_vector_field, sampler, pos).xy;
+
+    const float2 init_vector = read_imagef(init_vector_field, sampler, pos).xy;
+
+    const float2 fx1 = read_imagef(read_vector_field, sampler, pos + (int2)(1,0)).xy;
+    const float2 fy1 = read_imagef(read_vector_field, sampler, pos + (int2)(0,1)).xy;
+    const float2 fx_1 = read_imagef(read_vector_field, sampler, pos - (int2)(1,0)).xy;
+    const float2 fy_1 = read_imagef(read_vector_field, sampler, pos - (int2)(0,1)).xy;
+
+    // Update the vector field: Calculate Laplacian using a 3D central difference scheme
+    float2 laplacian = -4*f + fx1 + fx_1 + fy1 + fy_1;
+
+    f += mu * laplacian - (f - init_vector)*(init_vector.x*init_vector.x + init_vector.y*init_vector.y);
+
+    write_imagef(write_vector_field, writePos, (float4)(f.x,f.y,0,0));
+}
+
+
+// If device supports writing to 3D textures
+#ifdef fast_3d_image_writes
+
+__kernel void GVF3DCopy(__read_only image3d_t input, __write_only image3d_t output) {
+    int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    write_imagef(output, pos, read_imagef(input, sampler, pos)); 
+}
+
+__kernel void GVF3DIteration(
+        __read_only image3d_t init_vector_field, 
+        __read_only image3d_t read_vector_field, 
+        __write_only image3d_t write_vector_field, 
+        __private float mu
+    ) {
+
+    int4 writePos = {
+        get_global_id(0),
+        get_global_id(1),
+        get_global_id(2),
+        0
+    };
+    // Enforce mirror boundary conditions
+    int4 size = {get_image_width(init_vector_field), get_image_height(init_vector_field), get_image_depth(init_vector_field), 0};
+    int4 pos = writePos;
+    pos = select(pos, (int4)(2,2,2,0), pos == (int4)(0,0,0,0));
+    pos = select(pos, size-3, pos >= size-1);
+
+    // Load data from memory and do calculations
+    float3 init_vector = read_imagef(init_vector_field, sampler, pos).xyz;
+
+    float3 f = read_imagef(read_vector_field, sampler, pos).xyz;
+    float3 fx1 = read_imagef(read_vector_field, sampler, pos + (int4)(1,0,0,0)).xyz; 
+    float3 fx_1 = read_imagef(read_vector_field, sampler, pos - (int4)(1,0,0,0)).xyz; 
+    float3 fy1 = read_imagef(read_vector_field, sampler, pos + (int4)(0,1,0,0)).xyz; 
+    float3 fy_1 = read_imagef(read_vector_field, sampler, pos - (int4)(0,1,0,0)).xyz; 
+    float3 fz1 = read_imagef(read_vector_field, sampler, pos + (int4)(0,0,1,0)).xyz; 
+    float3 fz_1 = read_imagef(read_vector_field, sampler, pos - (int4)(0,0,1,0)).xyz; 
+    
+    // Update the vector field: Calculate Laplacian using a 3D central difference scheme
+    float3 laplacian = -6*f.xyz + fx1 + fx_1 + fy1 + fy_1 + fz1 + fz_1;
+
+    // NOT ANYMORE: The last component of the input vector is stored in f to save memory (f.w)
+    f += mu * laplacian - (f - init_vector)*
+        (init_vector.x*init_vector.x + init_vector.y*init_vector.y + init_vector.z*init_vector.z);
+
+    write_imagef(write_vector_field, writePos, f.xyzz);
+}
+
+#else
+
+#define LPOS(pos) pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)
+#ifdef VECTORS_16BIT
+#define FLOAT_TO_SNORM16_4(vector) convert_short4_sat_rte(vector * 32767.0f)
+#define SNORM16_TO_FLOAT_4(vector) max(-1.0f, convert_float4(vector) / 32767.0f)
+#define FLOAT_TO_SNORM16_3(vector) convert_short3_sat_rte(vector * 32767.0f)
+#define SNORM16_TO_FLOAT_3(vector) max(-1.0f, convert_float3(vector) / 32767.0f)
+#define FLOAT_TO_SNORM16_2(vector) convert_short2_sat_rte(vector * 32767.0f)
+#define SNORM16_TO_FLOAT_2(vector) max(-1.0f, convert_float2(vector) / 32767.0f)
+#define FLOAT_TO_SNORM16(vector) convert_short_sat_rte(vector * 32767.0f)
+#define SNORM16_TO_FLOAT(vector) max(-1.0f, convert_float(vector) / 32767.0f)
+#define VECTOR_FIELD_TYPE short
+#else
+#define FLOAT_TO_SNORM16_4(vector) vector
+#define SNORM16_TO_FLOAT_4(vector) vector
+#define FLOAT_TO_SNORM16_3(vector) vector
+#define SNORM16_TO_FLOAT_3(vector) vector
+#define FLOAT_TO_SNORM16_2(vector) vector
+#define SNORM16_TO_FLOAT_2(vector) vector
+#define FLOAT_TO_SNORM16(vector) vector
+#define SNORM16_TO_FLOAT(vector) vector
+#define VECTOR_FIELD_TYPE float
+#endif
+
+__kernel void GVF3DIteration(
+        __read_only image3d_t init_vector_field,
+        __global VECTOR_FIELD_TYPE const * restrict read_vector_field,
+        __global VECTOR_FIELD_TYPE * write_vector_field,
+        __private float mu
+        ) {
+    int4 writePos = {
+        get_global_id(0),
+        get_global_id(1),
+        get_global_id(2),
+        0
+    };
+    // Enforce mirror boundary conditions
+    int4 size = {get_global_size(0), get_global_size(1), get_global_size(2), 0};
+    int4 pos = writePos;
+    pos = select(pos, (int4)(2,2,2,0), pos == (int4)(0,0,0,0));
+    pos = select(pos, size-3, pos >= size-1);
+    int offset = pos.x + pos.y*size.x + pos.z*size.x*size.y;
+
+    // Load data from shared memory and do calculations
+    float4 init_vector = read_imagef(init_vector_field, sampler, pos);
+
+    float3 v = SNORM16_TO_FLOAT_3(vload3(offset, read_vector_field));
+    float3 fx1 = SNORM16_TO_FLOAT_3(vload3(offset+1, read_vector_field));
+    float3 fx_1 = SNORM16_TO_FLOAT_3(vload3(offset-1, read_vector_field));
+    float3 fy1 = SNORM16_TO_FLOAT_3(vload3(offset+size.x, read_vector_field));
+    float3 fy_1 = SNORM16_TO_FLOAT_3(vload3(offset-size.x, read_vector_field));
+    float3 fz1 = SNORM16_TO_FLOAT_3(vload3(offset+size.x*size.y, read_vector_field));
+    float3 fz_1 = SNORM16_TO_FLOAT_3(vload3(offset-size.x*size.y, read_vector_field));
+    
+    // Update the vector field: Calculate Laplacian using a 3D central difference scheme
+    float3 v2;
+    v2.x = -6*v.x;
+    v2.y = -6*v.y;
+    v2.z = -6*v.z;
+    float3 laplacian = v2 + fx1 + fx_1 + fy1 + fy_1 + fz1 + fz_1;
+
+    v += mu*laplacian - (v - init_vector.xyz)*(init_vector.x*init_vector.x + init_vector.y*init_vector.y + init_vector.z*init_vector.z);
+
+    vstore3(FLOAT_TO_SNORM16_3(v), writePos.x + writePos.y*size.x + writePos.z*size.x*size.y, write_vector_field);
+}
+
+
+__kernel void GVF3DInit(
+        __read_only image3d_t vectorFieldImage,
+        __global VECTOR_FIELD_TYPE * vectorField
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    vstore3(FLOAT_TO_SNORM16_3(read_imagef(vectorFieldImage, sampler, pos).xyz), LPOS(pos), vectorField);
+}
+
+__kernel void GVF3DFinish(
+        __global VECTOR_FIELD_TYPE * vectorField,
+        //__global VECTOR_FIELD_TYPE * vectorField2
+        __global float * vectorField2
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    float4 v;
+    v.xyz = SNORM16_TO_FLOAT_3(vload3(LPOS(pos), vectorField));
+    v.w = 0;
+    v.w = length(v) > 0.0f ? length(v) : 1.0f;
+    //vstore4(FLOAT_TO_SNORM16_4(v), LPOS(pos), vectorField2);
+    vstore4(v, LPOS(pos), vectorField2);
+}
+
+#endif