pyfast 4.12.0__cp36-abi3-win_amd64.whl

fast/kernels/Algorithms/MeshToSegmentation/MeshToSegmentation.cl

@@ -0,0 +1,184 @@
+// http://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
+
+int get_line_intersection(float p0_x, float p0_y, float p1_x, float p1_y,
+    float p2_x, float p2_y, float p3_x, float p3_y, float *i_x, float *i_y)
+{
+    float epsilon = 0.001f;
+
+    float s02_x, s02_y, s10_x, s10_y, s32_x, s32_y, s_numer, t_numer, denom, t;
+    s10_x = p1_x - p0_x;
+    s10_y = p1_y - p0_y;
+    s32_x = p3_x - p2_x;
+    s32_y = p3_y - p2_y;
+
+    denom = s10_x * s32_y - s32_x * s10_y;
+    if (denom == 0)
+        return 0; // Collinear
+    bool denomPositive = denom > 0;
+
+    s02_x = p0_x - p2_x;
+    s02_y = p0_y - p2_y;
+    s_numer = s10_x * s02_y - s10_y * s02_x;
+    if ((s_numer < epsilon) == denomPositive)
+        return 0; // No collision
+
+    t_numer = s32_x * s02_y - s32_y * s02_x;
+    if ((t_numer < epsilon) == denomPositive)
+        return 0; // No collision
+
+    if (((s_numer > denom) == denomPositive) || ((t_numer > denom) == denomPositive))
+        return 0; // No collision
+    // Collision detected
+    t = t_numer / denom;
+    *i_x = p0_x + (t * s10_x);
+    *i_y = p0_y + (t * s10_y);
+
+    return 1;
+}
+
+__kernel void mesh_to_segmentation_2d(
+		__global float* coordinates,
+		__global uint2* lines,
+		__private uint nrOfLines,
+		__write_only image2d_t segmentation,
+		__private float spacingX,
+		__private float spacingY
+	) {
+
+	const int2 pos = {get_global_id(0), get_global_id(1)};
+
+	// For each line, check if ray (arbitrary direction) from this pixel intersects
+	// Count number of intersections, if even: not inside, if odd: inside
+	int intersections = 0;
+    float x1 = pos.x*spacingX;
+    float y1 = pos.y*spacingY;
+    const float threshold = 0.00000001;
+    // x2 and y2 is 0
+    float y2 = y1;
+	for(int i = 0; i < nrOfLines; ++i) {
+	    // https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
+	    // http://geomalgorithms.com/a03-_inclusion.html
+	    // Find intersection point
+	    float3 coordinate3 = vload3(lines[i].x, coordinates);
+	    float3 coordinate4 = vload3(lines[i].y, coordinates);
+	    float x3 = coordinate3.x;
+	    float y3 = coordinate3.y;
+	    float x4 = coordinate4.x;
+	    float y4 = coordinate4.y;
+
+	    // Order edge points so that it always point downwards
+	    if(y3 > y4) {
+            // swap y
+	        float tmp = y4;
+	        y4 = y3;
+	        y3 = tmp;
+
+	        // swap x
+	        tmp = x4;
+	        x4 = x3;
+	        x3 = tmp;
+	    }
+
+	    if(y3 == y4) {
+	        // Horizontal edge, drop
+	        continue;
+	    }
+
+        float x, y;
+        if(get_line_intersection(x1, y1, 0, y2, x3, y3, x4, y4, &x, &y) == 1) {
+            // Have we hit an edge point?
+            if(fabs(x-x4) < threshold && fabs(y-y4) < threshold) { // Through a top point
+                //++intersections;
+            } else if(fabs(x-x3) < threshold && fabs(y-y3) < threshold) { // Through a bottom point
+                ++intersections;
+            } else { // Passes through the middle of the line
+                ++intersections;
+            }
+        }
+	}
+
+	write_imageui(segmentation, pos, intersections % 2 == 0 ? 0:1);
+}
+
+int rayIntersectsTriangle(float3 p, float3 d, float3 v0, float3 v1, float3 v2) {
+
+	float3 e1,e2,h,s,q;
+	float a,f,u,v;
+	e1 = v1 - v0;
+	e2 = v2 - v0;
+
+	h = cross(d, e2);
+	a = dot(e1,h);
+
+	if (a > -0.00000000001f && a < 0.00000000001f)
+        return 0;
+
+	f = 1.0f/a;
+	s = p - v0;
+	u = f * (dot(s,h));
+
+	if (u < 0.0 || u > 1.0)
+		return 0;
+
+	q = cross(s,e1);
+	v = f * dot(d,q);
+
+	if (v < 0.0 || u + v > 1.0)
+        return 0;
+
+	// at this stage we can compute t to find out where
+	// the intersection point is on the line
+	float t = f * dot(e2,q);
+
+	if (t > 0.00000001f) { // ray intersection
+        return 1;
+
+	} else { // this means that there is a line intersection
+		 // but not a ray intersection
+		 return 0;
+     }
+
+}
+
+__kernel void mesh_to_segmentation_3d(
+		__global float* coordinates,
+		__global uint* triangles,
+		__private int nrOfTriangles,
+		__global uchar* segmentation,
+		__private float spacingX,
+		__private float spacingY,
+		__private float spacingZ
+	) {
+	const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+
+
+	// For each triangle, check if ray (arbitrary direction) from this pixel intersects
+	// See: http://geomalgorithms.com/a06-_intersect-2.html#intersect3D_RayTriangle()
+	// Count number of intersections, if even: not inside, if odd: inside
+	int intersections = 0;
+
+	// Ray start point
+    float3 P0 = {pos.x*spacingX, pos.y*spacingY, pos.z*spacingZ};
+    if(P0.y == 0) {
+        // There is a strange problem if y component is exactly zero
+        // This is a hack to avoid this
+        P0.y = 0.00001;
+    }
+
+    // Set arbitrarty direction
+    float3 P1 = P0;
+    P1.x += 0.1;
+
+    for(int i = 0; i < nrOfTriangles; ++i) {
+        const uint3 triangle = vload3(i, triangles);
+        const float3 u = vload3(triangle.x, coordinates);
+        const float3 v = vload3(triangle.y, coordinates);
+        const float3 w = vload3(triangle.z, coordinates);
+
+        if(rayIntersectsTriangle(P0, P1, u, v, w) >= 1) {
+            intersections += 1;
+        }
+    }
+
+	segmentation[pos.x + pos.y*get_global_size(0) + pos.z*get_global_size(0)*get_global_size(1)] = intersections % 2 == 0 ? 0:1;
+}

fast/kernels/Algorithms/Morphology/Dilation.cl

@@ -0,0 +1,56 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | 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 dilate3D(
+        __read_only image3d_t volume,
+#ifdef fast_3d_image_writes
+        __write_only image3d_t result,
+#else
+        __global uchar * result,
+#endif
+        __private int size
+    ) {
+    int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+
+    if(read_imageui(volume, sampler, pos).x == 1) {
+        for(int a = -size; a <= size ; a++) {
+            for(int b = -size; b <= size ; b++) {
+                for(int c = -size; c <= size ; c++) {
+                    int4 n = (int4)(a,b,c,0);
+                    if(length(convert_float4(n)) > size)
+                        continue;
+#ifdef fast_3d_image_writes
+                    write_imageui(result, pos + n, 1);
+#else
+                    // Check if in bounds
+                    int4 nPos = pos + n;
+                    if(nPos.x >= 0 && nPos.y >= 0 && nPos.z >= 0 &&
+                        nPos.x < get_global_size(0) && nPos.y < get_global_size(1) && nPos.z < get_global_size(2))
+                    result[LPOS(nPos)] = 1;
+#endif
+                }
+            }
+        }
+    }
+}
+
+__kernel void dilate2D(
+        __read_only image2d_t volume,
+        __write_only image2d_t result,
+        __private int size
+    ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    const int width = get_image_width(result);
+    const int height = get_image_height(result);
+
+    if(read_imageui(volume, sampler, pos).x == 1) {
+        char write = 0;
+        for(int a = -size; a <= size ; a++) {
+            for(int b = -size; b <= size ; b++) {
+                int2 n = (int2)(a,b);
+                if(length(convert_float2(n)) <= size && pos.x+a >= 0 && pos.x+a < width && pos.y+b >= 0 && pos.y+b < height)
+                    write_imageui(result, pos + n, 1);
+            }
+        }
+    }
+}

fast/kernels/Algorithms/Morphology/Erosion.cl

@@ -0,0 +1,64 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | 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 erode3D(
+        __read_only image3d_t volume,
+#ifdef fast_3d_image_writes
+        __write_only image3d_t result,
+#else
+        __global uchar * result,
+#endif
+        __private int size
+    ) {
+    int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+
+    int value = read_imageui(volume, sampler, pos).x;
+    if(value == 1) {
+        bool keep = true;
+        for(int a = -size; a <= size; a++) {
+            for(int b = -size; b <= size; b++) {
+                for(int c = -size; c <= size; c++) {
+                    int4 n = (int4)(a,b,c,0);
+                    if(length(convert_float4(n)) > size)
+                        continue;
+                    keep = (read_imageui(volume, sampler, pos + n).x == 1 && keep);
+                }
+            }
+        }
+#ifdef fast_3d_image_writes
+        write_imageui(result, pos, keep ? 1 : 0);
+    } else {
+        write_imageui(result, pos, 0);
+    }
+#else
+        result[LPOS(pos)] = keep ? 1 : 0;
+    } else {
+        result[LPOS(pos)] = 0;
+    }
+#endif
+}
+
+__kernel void erode2D(
+        __read_only image2d_t volume,
+        __write_only image2d_t result,
+        __private int size
+    ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+
+    int value = read_imageui(volume, sampler, pos).x;
+    if(value == 1) {
+        bool keep = true;
+        for(int a = -size; a <= size; a++) {
+            for(int b = -size; b <= size; b++) {
+                int2 n = (int2)(a,b);
+                if(length(convert_float2(n)) > size)
+                    continue;
+                keep = (read_imageui(volume, sampler, pos + n).x == 1 && keep);
+            }
+        }
+        write_imageui(result, pos, keep ? 1 : 0);
+    } else {
+        write_imageui(result, pos, 0);
+    }
+}

fast/kernels/Algorithms/NeuralNetwork/NeuralNetwork.cl

@@ -0,0 +1,122 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void normalize2DInput(
+	__read_only image2d_t input,
+	__global float* output,
+	__private float scaleFactor,
+	__private float mean,
+	__private float std,
+	__private int signedInputNormalization,
+	__private int horizontalFlip,
+	__private int channels,
+	__private float minIntensity,
+	__private float maxIntensity,
+	__private int clipIntensity,
+	__private int channelFirst
+	) {
+	
+	const int2 pos = {get_global_id(0), get_global_id(1)};
+	const int dataType = get_image_channel_data_type(input);
+	float4 value;
+	if(dataType == CLK_FLOAT) {
+		value = read_imagef(input, sampler, pos);
+	} else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+		value = convert_float4(read_imagei(input, sampler, pos));
+	} else {
+		value = convert_float4(read_imageui(input, sampler, pos));
+	}
+
+	if(clipIntensity)
+	    value = clamp(value, minIntensity, maxIntensity);
+	value = (value - mean)/std;
+    value = value*scaleFactor;
+    if(signedInputNormalization) {
+        value = value*2 - 1;
+	}
+
+    int x;
+	if(horizontalFlip == 1) {
+		x = (get_global_size(0) - pos.x - 1);
+	} else {
+		x = pos.x;
+	}
+	const int width = get_global_size(0);
+	const int height = get_global_size(1);
+    if(channelFirst == 0) {
+        int position = (pos.x + pos.y*width)*channels;
+        output[position] = value.x;
+        if(channels > 1)
+            output[position+1] = value.y;
+        if(channels > 2)
+            output[position+2] = value.z;
+        if(channels > 3)
+            output[position+3] = value.w;
+    } else {
+        int position = pos.x + pos.y*width;
+        output[position] = value.x;
+        if(channels > 1)
+            output[position + 1*width*height] = value.y;
+        if(channels > 2)
+            output[position + 2*width*height] = value.z;
+        if(channels > 3)
+            output[position + 3*width*height] = value.w;
+    }
+}
+
+__kernel void normalize3DInput(
+	__read_only image3d_t input,
+	__global float* output,
+	__private float scaleFactor,
+    __private float mean,
+	__private float std,
+	__private int signedInputNormalization,
+	__private int horizontalFlip,
+	__private int channels,
+	__private float minIntensity,
+	__private float maxIntensity,
+	__private int clipIntensity,
+	__private int channelFirst
+	) {
+
+	const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+	const int dataType = get_image_channel_data_type(input);
+	float4 value;
+	if(dataType == CLK_FLOAT) {
+		value = read_imagef(input, sampler, pos);
+	} else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+		value = convert_float4(read_imagei(input, sampler, pos));
+	} else {
+		value = convert_float4(read_imageui(input, sampler, pos));
+	}
+
+	if(clipIntensity)
+	    value = clamp(value, minIntensity, maxIntensity);
+	value = (value - mean)/std;
+    value = value*scaleFactor;
+    if(signedInputNormalization) {
+        value = value*2 - 1;
+	}
+
+    const int width = get_global_size(0);
+	const int height = get_global_size(1);
+	const int depth = get_global_size(2);
+    if(channelFirst == 0) {
+        int position = (pos.x + pos.y*width + pos.z*width*height)*channels;
+        output[position] = value.x;
+        if(channels > 1)
+            output[position+1] = value.y;
+        if(channels > 2)
+            output[position+2] = value.z;
+        if(channels > 3)
+            output[position+3] = value.w;
+    } else {
+        int position = pos.x + pos.y*width + pos.z*width*height;
+        output[position] = value.x;
+        if(channels > 1)
+            output[position + 1*width*height*depth] = value.y;
+        if(channels > 2)
+            output[position + 2*width*height*depth] = value.z;
+        if(channels > 3)
+            output[position + 3*width*height*depth] = value.w;
+    }
+}

fast/kernels/Algorithms/NeuralNetwork/VertexTensorToSegmentation.cl

@@ -0,0 +1,13 @@
+__const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_NONE;
+
+__kernel void writeSegmentation(
+        __write_only image2d_t current,
+        __read_only image2d_t new,
+        int label
+    ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+
+    if(read_imageui(new, sampler, pos).x > 0) {
+        write_imageui(current, pos, label);
+    }
+}

fast/kernels/Algorithms/NonLocalMeans/NonLocalMeans2D.cl

@@ -0,0 +1,94 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+float calculateDiff(__read_only image2d_t imageInput, int2 pos1, int2 pos2, int filterSize, int iteration) {
+    float res = 0.0f;
+    for(int offset_x = -FILTER_SIZE; offset_x <= FILTER_SIZE; ++offset_x) {
+        for(int offset_y = -FILTER_SIZE; offset_y <= FILTER_SIZE; ++offset_y) {
+            int2 offset = {offset_x, offset_y};
+            float diff = (float)read_imageui(imageInput, sampler, pos1 + offset).x/255.0f - (float)read_imageui(imageInput, sampler, pos2 + offset).x/255.0f;
+            diff = diff*diff;
+            res += diff;
+        }
+    }
+    return res;
+}
+
+uchar findMedian(uchar array[], const int size) {
+    for(uint i = 0; i < size; ++i) {
+        for(uint j = 0; j < i; ++j) {
+            if(array[i] > array[j]) {
+                uchar tmp = array[i];
+                array[i] = array[j];
+                array[j] = tmp;
+            }
+        }
+    }
+
+    if(size % 2 == 0) {
+        return (uchar)round((array[size / 2] + array[size / 2 + 1])*0.5f);
+    } else {
+        return array[size / 2];
+    }
+}
+
+__kernel void preprocess(
+        __read_only image2d_t input,
+        __write_only image2d_t output
+        ) { 
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    // Read neighborhood to thread
+    uchar elements[25];
+    int counter = 0;
+    for(int a = -2; a <= 2; ++a) { 
+        for(int b = -2; b <= 2; ++b) {
+            elements[counter] = read_imageui(input, sampler, pos + (int2)(a,b)).x;
+            ++counter;
+        }
+    }
+    uchar median = findMedian(elements, 25);
+
+    const float threshold = 150.0f; // TODO Set this threshold in a smarter way
+    const float current = read_imageui(input, sampler, pos).x;
+    uchar newPixel = current - max((float)median - current - threshold, 0.0f);
+    write_imageui(output, pos, newPixel);
+}
+
+__kernel void nonLocalMeansFilter(
+        __read_only image2d_t imageInput,
+        __write_only image2d_t imageOutput,
+        __private int searchSize,
+        __private int filterSize,
+        __private float parameterH,
+        __private int iteration
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    float sumBottom = 0.0f;
+    float sumTop = 0.0f;
+
+    // Loop over search region
+    for(int searchOffsetX = -SEARCH_SIZE; searchOffsetX <= SEARCH_SIZE; ++searchOffsetX) {
+        for(int searchOffsetY = -SEARCH_SIZE; searchOffsetY <= SEARCH_SIZE; ++searchOffsetY) {
+            int2 searchOffsetAtScale = {searchOffsetX*(iteration+1), searchOffsetY*(iteration+1)};
+            float diff = calculateDiff(imageInput, pos, pos + searchOffsetAtScale, filterSize, iteration);
+            diff = native_exp(-diff/(2.0f*parameterH*parameterH));// / (2.0f*parameterH*parameterH);
+            sumBottom += diff;
+            sumTop += diff*read_imageui(imageInput, sampler, pos + searchOffsetAtScale).x/255.0f;
+        }
+    }
+
+    write_imageui(imageOutput, pos, (uchar)round(clamp((sumTop/sumBottom)*255.0f, 0.0f, 255.0f)));
+}
+
+__kernel void multiplyWithInput(
+            __read_only image2d_t inputImage,
+            __read_only image2d_t NLMImage,
+            __write_only image2d_t output,
+            __private float multiplicationWeight
+    ) {
+
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    float inputValue = read_imageui(inputImage, sampler, pos).x;
+    float nlmValue = read_imageui(NLMImage, sampler, pos).x;
+
+    write_imageui(output, pos, (uchar)round(sqrt((inputValue*multiplicationWeight + nlmValue*(1.0f-multiplicationWeight))*nlmValue)));
+}

fast/kernels/Algorithms/SeededRegionGrowing/SeededRegionGrowing2D.cl

@@ -0,0 +1,57 @@
+
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_NONE;
+
+#ifdef TYPE_FLOAT
+#define READ_IMAGE(image, pos) read_imagef(image, sampler, pos).x
+#elif TYPE_INT
+#define READ_IMAGE(image, pos) (float)read_imagei(image, sampler, pos).x
+#else
+#define READ_IMAGE(image, pos) (float)read_imageui(image, sampler, pos).x
+#endif
+
+__kernel void seededRegionGrowing(
+        __read_only image2d_t image,
+        __global char* segmentation,
+        __global char* stopGrowing,
+        __private float min,
+        __private float max
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    const uint linearPos = pos.x + pos.y*get_global_size(0);
+    
+    // Define neighborhood offsets
+    int2 offset[8] = {
+            {1,0},
+            {0,1},
+            {1,1},
+            {-1,0},
+            {0,-1},
+            {-1,-1},
+            {-1,1},
+            {1,-1}
+    };
+    
+    if(segmentation[linearPos] == 2) { // pixel is in queue
+        float intensity = READ_IMAGE(image, pos);
+        if(intensity >= min && intensity <= max) {
+            segmentation[linearPos] = 1; // add pixel to segmentation
+            // Add neighbor pixels to queue
+            for(int i = 0; i < 8; i++) {
+                // Out of bounds check
+                int2 neighborPos = pos + offset[i];
+                if(neighborPos.x < 0 || neighborPos.y < 0 || 
+                    neighborPos.x >= get_global_size(0) || neighborPos.y >= get_global_size(1))
+                    continue;
+                uint neighborLinearPos = neighborPos.x + neighborPos.y*get_global_size(0);
+                if(segmentation[neighborLinearPos] == 0) {
+                    segmentation[neighborLinearPos] = 2; // add to queue
+                    stopGrowing[0] = 0;
+                }
+            }
+        } else {
+            segmentation[linearPos] = 0; // Remove pixel
+        }
+    }
+}
+        
+            

fast/kernels/Algorithms/SeededRegionGrowing/SeededRegionGrowing3D.cl

@@ -0,0 +1,58 @@
+
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_NONE;
+
+#ifdef TYPE_FLOAT
+#define READ_IMAGE(image, pos) read_imagef(image, sampler, pos).x
+#elif TYPE_INT
+#define READ_IMAGE(image, pos) (float)read_imagei(image, sampler, pos).x
+#else
+#define READ_IMAGE(image, pos) (float)read_imageui(image, sampler, pos).x
+#endif
+
+
+
+__kernel void seededRegionGrowing(
+        __read_only image3d_t image,
+        __global char* segmentation,
+        __global char* stopGrowing,
+        __private float min,
+        __private float max
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    const uint linearPos = pos.x + pos.y*get_global_size(0) + pos.z*get_global_size(0)*get_global_size(1);
+
+    const int4 offsets[6] = {
+        {0,0,1,0},
+        {0,1,0,0},
+        {1,0,0,0},
+        {0,0,-1,0},
+        {0,-1,0,0},
+        {-1,0,0,0},
+    };
+    
+    if(segmentation[linearPos] == 2) { // pixel is in queue
+        float intensity = READ_IMAGE(image, pos);
+        if(intensity >= min && intensity <= max) {
+            segmentation[linearPos] = 1; // add pixel to segmentation
+            // Add neighbor pixels to queue
+            for(int i = 0; i < 6; i++) {
+                // Out of bounds check. TODO something more efficient
+                int4 neighborPos = pos + offsets[i];
+                if(neighborPos.x < 0 || neighborPos.y < 0 || neighborPos.z < 0 || 
+                    neighborPos.x >= get_global_size(0) || neighborPos.y >= get_global_size(1) ||
+                    neighborPos.z >= get_global_size(2))
+                    continue;
+                uint neighborLinearPos = neighborPos.x + neighborPos.y*get_global_size(0) +
+                        neighborPos.z*get_global_size(0)*get_global_size(1);
+                if(segmentation[neighborLinearPos] == 0) {
+                    segmentation[neighborLinearPos] = 2; // add to queue
+                    stopGrowing[0] = 0;
+                }
+            }
+        } else {
+            segmentation[linearPos] = 0; // Remove pixel
+        }
+    }
+}
+        
+