pyfast 4.12.0__cp36-abi3-macosx_10_13_x86_64.whl

fast/kernels/Algorithms/UltrasoundImageCropper/UltrasoundImageCropper.cl

@@ -0,0 +1,31 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+
+__kernel void lineSearch(
+        __read_only image2d_t image,
+        __global uint* rays
+        ) {
+    
+    const int i = get_global_id(0);
+    uint result = 0;
+    const int width = get_image_width(image);
+    const int height = get_image_height(image);
+
+    if(i < width) {
+        for(int y = height/6; y < height*5/6; ++y) {
+            int2 position = {i, y};
+            if(read_imageui(image, sampler, position).x > 0) {
+                result += 1;
+            }
+        }
+    } else {
+        for(int x = width/6; x < width*5/6; ++x) {
+            int2 position = {x, i - width};
+            if(read_imageui(image, sampler, position).x > 0) {
+                result += 1;
+            }
+        }
+    }
+
+    rays[i] = result;
+}

fast/kernels/Algorithms/UltrasoundImageEnhancement/UltrasoundImageEnhancement.cl

@@ -0,0 +1,27 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void enhance(
+        __read_only image2d_t input,
+        __write_only image2d_t output,
+        __private int reject
+    ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+
+    float intensity = (float)read_imageui(input, sampler, pos).x;
+    if(intensity < reject)
+        intensity = 0.0f;
+    // Apply a nonlinear S-curve
+    float k = -0.2;
+    intensity = (intensity/255.0f)*2.0f-1.0f;
+    uchar value  = (uchar)round(255*(((intensity - k*intensity)/(k - 2*k*fabs(intensity)+1))+1.0f)/2.0f);
+    //uchar value = intensity;
+    uint4 color = {value, value, value, 255};
+    // Apply a hint of blue
+    if(value > 0) {
+        color.y -= 1;
+        color.z += 4;
+    }
+    color = clamp(color, (uint)0, (uint)255);
+
+    write_imageui(output, pos, color);
+}

fast/kernels/Algorithms/VectorMedianFilter/VectorMedianFilter.cl

@@ -0,0 +1,31 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+__kernel void vectorMedianFilter(
+        __read_only image2d_t input,
+        __write_only image2d_t output,
+        __private int windowHalf
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+
+    float2 bestVector;
+    float bestSum = FLT_MAX;
+    for(int y = -windowHalf; y <= windowHalf; ++y) {
+        for(int x = -windowHalf; x <= windowHalf; ++x) {
+            float2 a_m = read_imagef(input, sampler, pos + (int2)(x, y)).xy;
+            float sum = 0.0f;
+            for(int y2 = -windowHalf; y2 <= windowHalf; ++y2) {
+                for(int x2 = -windowHalf; x2 <= windowHalf; ++x2) {
+                    float2 a_i = read_imagef(input, sampler, pos + (int2)(x2, y2)).xy;
+                    //sum += dot(fabs(a_m - a_i), (float2)(1,1)); // L1 norm
+                    sum += length(a_m - a_i); // L2 norm
+                }
+            }
+            if(sum < bestSum) {
+                bestVector = a_m;
+                bestSum = sum;
+            }
+        }
+    }
+
+    write_imagef(output, pos, bestVector.xyyy);
+}

fast/kernels/ImageFill.cl

@@ -0,0 +1,30 @@
+__kernel void fillImage2D(
+		__write_only image2d_t image,
+		__private float value
+		) {
+	const int2 pos = {get_global_id(0), get_global_id(1)};
+	int dataType = get_image_channel_data_type(image);
+	if(dataType == CLK_FLOAT) {
+		write_imagef(image, pos, (float4)(value, value, value, value));
+	} else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+		write_imagei(image, pos, (int4)(value, value, value, value));
+	} else {
+		write_imageui(image, pos, (uint4)(value, value, value, value));
+	}
+}
+
+/*
+__kernel void fillImage3D(
+		__write_only image3d_t image,
+		float value) {
+	const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+	int dataType = get_image_channel_data_type(image);
+	if(dataType == CLK_FLOAT) {
+		write_imagef(image, pos, (float4)(value, value, value, value));
+	} else if(dataType == CLK_SIGNED_INT8 || dataType == CLK_SIGNED_INT16 || dataType == CLK_SIGNED_INT32) {
+		write_imagei(image, pos, (int4)(value, value, value, value));
+	} else {
+		write_imageui(image, pos, (uint4)(value, value, value, value));
+	}
+}
+*/

fast/kernels/ImageMinMax.cl

@@ -0,0 +1,196 @@
+
+#ifdef TYPE_FLOAT
+#define TYPE float4
+#define BUFFER_TYPE float
+#define READ_IMAGE read_imagef
+#define WRITE_IMAGE write_imagef
+#define MAX_VALUE FLT_MAX
+#define MIN_VALUE FLT_MIN
+#elif TYPE_UINT8
+#define TYPE uint4
+#define BUFFER_TYPE uchar
+#define READ_IMAGE read_imageui
+#define WRITE_IMAGE write_imageui
+#define MAX_VALUE UCHAR_MAX
+#define MIN_VALUE 0
+#elif TYPE_INT8
+#define TYPE int4
+#define BUFFER_TYPE char
+#define READ_IMAGE read_imagei
+#define WRITE_IMAGE write_imagei
+#define MAX_VALUE CHAR_MAX
+#define MIN_VALUE CHAR_MIN
+#elif TYPE_UINT16
+#define TYPE uint4
+#define BUFFER_TYPE ushort
+#define READ_IMAGE read_imageui
+#define WRITE_IMAGE write_imageui
+#define MAX_VALUE USHRT_MAX
+#define MIN_VALUE 0
+#elif TYPE_INT16
+#define TYPE int4
+#define BUFFER_TYPE short
+#define READ_IMAGE read_imagei
+#define WRITE_IMAGE write_imagei
+#define MAX_VALUE SHRT_MAX
+#define MIN_VALUE SHRT_MIN
+#elif TYPE_UINT32
+#define TYPE uint4
+#define BUFFER_TYPE uint
+#define READ_IMAGE read_imageui
+#define WRITE_IMAGE write_imageui
+#define MAX_VALUE UINT_MAX
+#define MIN_VALUE 0
+#else
+#define TYPE int4
+#define BUFFER_TYPE int
+#define READ_IMAGE read_imagei
+#define WRITE_IMAGE write_imagei
+#define MAX_VALUE INT_MAX
+#define MIN_VALUE INT_MIN
+#endif
+
+__constant int2 offset2D[4] = {
+                   {0,0},
+                   {0,1},
+                   {1,0},
+                   {1,1}
+};
+
+__constant int4 offset3D[8] = {
+                   {0,0,0,0},
+                   {1,0,0,0},
+                   {0,1,0,0},
+                   {0,0,1,0},
+                   {1,0,1,0},
+                   {1,1,1,0},
+                   {0,1,1,0},
+                   {1,1,0,0}
+};
+
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void createFirstMinMaxImage2DLevel(
+        __read_only image2d_t image,
+        __write_only image2d_t firstLevel
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    const int2 readPos = pos*2;
+    const int2 size = {get_image_width(image), get_image_height(image)};
+
+    TYPE result = {MAX_VALUE, MIN_VALUE,0,0};
+    for(int i = 0; i < 4; i++) {
+        TYPE temp;
+        temp = READ_IMAGE(image, sampler, select((int2)(0,0), readPos+offset2D[i], readPos+offset2D[i] < size));
+        result.x = min(result.x, temp.x);
+        result.y = max(result.y, temp.x);
+    }
+
+    WRITE_IMAGE(firstLevel, pos, result);
+}
+
+__kernel void createMinMaxImage2DLevel(
+        __read_only image2d_t readLevel,
+        __write_only image2d_t writeLevel
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    const int2 readPos = pos*2;
+
+    TYPE result = {MAX_VALUE, MIN_VALUE,0,0};
+    TYPE temp;
+    temp = READ_IMAGE(readLevel, sampler, readPos + offset2D[0]);
+    result.x = min(result.x, temp.x);
+    result.y = max(result.y, temp.y);
+    temp = READ_IMAGE(readLevel, sampler, readPos + offset2D[1]);
+    result.x = min(result.x, temp.x);
+    result.y = max(result.y, temp.y);
+    temp = READ_IMAGE(readLevel, sampler, readPos + offset2D[2]);
+    result.x = min(result.x, temp.x);
+    result.y = max(result.y, temp.y);
+    temp = READ_IMAGE(readLevel, sampler, readPos + offset2D[3]);
+    result.x = min(result.x, temp.x);
+    result.y = max(result.y, temp.y);
+
+    WRITE_IMAGE(writeLevel, pos, result);
+}
+
+#ifdef fast_3d_image_writes
+__kernel void createFirstMinMaxImage3DLevel(
+        __read_only image3d_t image,
+        __write_only image3d_t firstLevel
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    const int4 readPos = pos*2;
+    const int4 size = {get_image_width(image), get_image_height(image), get_image_depth(image), 1};
+
+    TYPE result = {MAX_VALUE, MIN_VALUE,0,0};
+    for(int i = 0; i < 8; i++) {
+        TYPE temp;
+        temp = READ_IMAGE(image, sampler,  select((int4)(0,0,0,0), readPos+offset3D[i], readPos+offset3D[i] < size));
+        result.x = min(result.x, temp.x);
+        result.y = max(result.y, temp.x);
+    }
+
+    WRITE_IMAGE(firstLevel, pos, result);
+}
+
+__kernel void createMinMaxImage3DLevel(
+        __read_only image3d_t readLevel,
+        __write_only image3d_t writeLevel
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    const int4 readPos = pos*2;
+
+    TYPE result = {MAX_VALUE, MIN_VALUE,0,0};
+    for(int i = 0; i < 8; i++) {
+        TYPE temp;
+        temp = READ_IMAGE(readLevel, sampler, readPos + offset3D[i]);
+        result.x = min(result.x, temp.x);
+        result.y = max(result.y, temp.y);
+    }
+
+
+    WRITE_IMAGE(writeLevel, pos, result);
+}
+#endif
+
+__kernel void reduce(
+        __global BUFFER_TYPE* buffer,
+        __local BUFFER_TYPE* minScratch,
+        __local BUFFER_TYPE* maxScratch,
+        __private int length,
+        __private int X,
+        __global BUFFER_TYPE* result) {
+
+    int global_index = get_global_id(0)*X;
+    BUFFER_TYPE minAccumulator = MAX_VALUE;
+    BUFFER_TYPE maxAccumulator = MIN_VALUE;
+    // Loop sequentially over chunks of input vector
+    for(int i = 0; i < X && global_index < length; i++) {
+        float element = buffer[global_index];
+        minAccumulator = (minAccumulator < element) ? minAccumulator : element;
+        maxAccumulator = (maxAccumulator > element) ? maxAccumulator : element;
+        global_index += 1;
+    }
+
+    // Perform parallel reduction
+    int local_index = get_local_id(0);
+    minScratch[local_index] = minAccumulator;
+    maxScratch[local_index] = maxAccumulator;
+    barrier(CLK_LOCAL_MEM_FENCE);
+    for(int offset = get_local_size(0) / 2; offset > 0; offset = offset / 2) {
+        if(local_index < offset) {
+          BUFFER_TYPE other = minScratch[local_index + offset];
+          BUFFER_TYPE mine = minScratch[local_index];
+          minScratch[local_index] = (mine < other) ? mine : other;
+          other = maxScratch[local_index + offset];
+          mine = maxScratch[local_index];
+          maxScratch[local_index] = (mine > other) ? mine : other;
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+    if(local_index == 0) {
+        result[get_group_id(0)*2] = minScratch[0];
+        result[get_group_id(0)*2+1] = maxScratch[0];
+    }
+}

fast/kernels/ImageSum.cl

@@ -0,0 +1,170 @@
+
+#ifdef TYPE_FLOAT
+#define TYPE float4
+#define BUFFER_TYPE float
+#define READ_IMAGE read_imagef
+#define WRITE_IMAGE write_imagef
+#elif TYPE_UINT8
+#define TYPE uint4
+#define BUFFER_TYPE uchar
+#define READ_IMAGE read_imageui
+#define WRITE_IMAGE write_imageui
+#elif TYPE_INT8
+#define TYPE int4
+#define BUFFER_TYPE char
+#define READ_IMAGE read_imagei
+#define WRITE_IMAGE write_imagei
+#elif TYPE_UINT16
+#define TYPE uint4
+#define BUFFER_TYPE ushort
+#define READ_IMAGE read_imageui
+#define WRITE_IMAGE write_imageui
+#elif TYPE_INT16
+#define TYPE int4
+#define BUFFER_TYPE short
+#define READ_IMAGE read_imagei
+#define WRITE_IMAGE write_imagei
+#elif TYPE_UINT32
+#define TYPE uint4
+#define BUFFER_TYPE uint
+#define READ_IMAGE read_imageui
+#define WRITE_IMAGE write_imageui
+#else
+#define TYPE int4
+#define BUFFER_TYPE int
+#define READ_IMAGE read_imagei
+#define WRITE_IMAGE write_imagei
+#endif
+
+__constant int2 offset2D[4] = {
+                   {0,0},
+                   {0,1},
+                   {1,0},
+                   {1,1}
+};
+
+__constant int4 offset3D[8] = {
+                   {0,0,0,0},
+                   {1,0,0,0},
+                   {0,1,0,0},
+                   {0,0,1,0},
+                   {1,0,1,0},
+                   {1,1,1,0},
+                   {0,1,1,0},
+                   {1,1,0,0}
+};
+
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void createFirstSumImage2DLevel(
+        __read_only image2d_t image,
+        __write_only image2d_t firstLevel
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    const int2 readPos = pos*2;
+    const int2 size = {get_image_width(image), get_image_height(image)};
+
+    float sum = 0.0f;
+    for(int i = 0; i < 4; i++) {
+        int2 nPos = readPos + offset2D[i];
+        if(nPos.x < size.x && nPos.y < size.y) {
+            sum += READ_IMAGE(image, sampler, nPos).x;
+        }
+    }
+
+    write_imagef(firstLevel, pos, sum);
+}
+
+__kernel void createFirstSumImage3DLevel(
+        __read_only image3d_t image,
+        __global float* firstLevel
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    const int4 readPos = pos*2;
+    const int3 size = {get_image_width(image), get_image_height(image), get_image_depth(image)};
+
+    float sum = 0.0f;
+    for(int i = 0; i < 8; ++i) {
+        int4 nPos = readPos + offset3D[i];
+        if(nPos.x < size.x && nPos.y < size.y && nPos.z < size.z) {
+            sum += READ_IMAGE(image, sampler, nPos).x;
+        }
+    }
+
+    firstLevel[pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)] = sum;
+}
+
+__kernel void createSumImage2DLevel(
+        __read_only image2d_t readLevel,
+        __write_only image2d_t writeLevel
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    const int2 readPos = pos*2;
+
+    float sum =
+    read_imagef(readLevel, sampler, readPos + offset2D[0]).x +
+    read_imagef(readLevel, sampler, readPos + offset2D[1]).x +
+    read_imagef(readLevel, sampler, readPos + offset2D[2]).x +
+    read_imagef(readLevel, sampler, readPos + offset2D[3]).x;
+
+    write_imagef(writeLevel, pos, sum);
+}
+
+__kernel void createSumImage3DLevel(
+        __global float* readLevel,
+        __global float* writeLevel
+        ) {
+    const int3 pos = {get_global_id(0), get_global_id(1), get_global_id(2)};
+    const int3 readPos = pos*2;
+    const int3 size = {get_global_size(0), get_global_size(1), get_global_size(2)};
+    const int3 readSize = size*2;
+
+    float sum = 0.0f;
+    for(int i = 0; i < 8; i++) {
+        int3 nPos = readPos + offset3D[i].xyz;
+        sum += readLevel[nPos.x+nPos.y*readSize.x+nPos.z*readSize.x*readSize.y];
+    }
+
+    writeLevel[pos.x+pos.y*size.x+pos.z*size.x*size.y] = sum;
+}
+
+
+__kernel void createFirstStdDevImage2DLevel(
+        __read_only image2d_t image,
+        __write_only image2d_t firstLevel,
+        __private float average
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    const int2 readPos = pos*2;
+    const int2 size = {get_image_width(image), get_image_height(image)};
+
+    float sum = 0.0f;
+    for(int i = 0; i < 4; i++) {
+        int2 nPos = readPos + offset2D[i];
+        if(nPos.x < size.x && nPos.y < size.y) {
+            sum += pow(READ_IMAGE(image, sampler, nPos).x - average, 2.0f);
+        }
+    }
+
+    write_imagef(firstLevel, pos, sum);
+}
+
+__kernel void createFirstStdDevImage3DLevel(
+        __read_only image3d_t image,
+        __global float* firstLevel,
+        __private float average
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    const int4 readPos = pos*2;
+    const int3 size = {get_image_width(image), get_image_height(image), get_image_depth(image)};
+
+    float sum = 0.0f;
+    for(int i = 0; i < 8; i++) {
+        int4 nPos = readPos + offset3D[i];
+        if(nPos.x < size.x && nPos.y < size.y && nPos.z < size.z) {
+            sum += pow(READ_IMAGE(image, sampler, nPos).x - average, 2.0f);
+        }
+    }
+
+    firstLevel[pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1)] = sum;
+}

fast/kernels/Tests/Algorithms/DoubleFilter.cl

@@ -0,0 +1,7 @@
+
+__kernel void doubleFilter(
+        __global TYPE * input,
+        __global TYPE * output
+        ) {
+    output[get_global_id(0)] = input[get_global_id(0)]*2;
+}

fast/kernels/Visualization/BoundingBoxRenderer/BoundingBoxRenderer.frag

@@ -0,0 +1,8 @@
+#version 330 core
+
+in vec4 geomColor;
+out vec4 fragColor;
+
+void main() {
+    fragColor = geomColor;
+}

fast/kernels/Visualization/BoundingBoxRenderer/BoundingBoxRenderer.geom

@@ -0,0 +1,69 @@
+#version 330 core
+
+layout (lines) in;
+layout (triangle_strip, max_vertices=4) out;
+in vec4 vertexColor[];
+out vec4 geomColor;
+
+//uniform float size;
+uniform mat4 perspectiveTransform;
+uniform float borderSize;
+
+void main() {
+    geomColor = vertexColor[0];
+    vec4 first = gl_in[0].gl_Position;
+    vec4 second = gl_in[1].gl_Position;
+    float pixelWidth = perspectiveTransform[0][0];
+    float pixelHeight = perspectiveTransform[1][1];
+    float sizeX = borderSize*pixelWidth;
+    float sizeY = borderSize*pixelHeight;
+
+    // Draw bounding box with triangle strips
+    if(first.x == second.x) {
+        // Vertical line
+        if(first.y < second.y) {
+            gl_Position = first + vec4(sizeX, -sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = second + vec4(sizeX, sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = first + vec4(-sizeX, -sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = second + vec4(-sizeX, sizeY, 0, 0);
+            EmitVertex();
+            EndPrimitive();
+        } else {
+            gl_Position = first + vec4(-sizeX, sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = second + vec4(-sizeX, -sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = first + vec4(sizeX, sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = second + vec4(sizeX, -sizeY, 0, 0);
+            EmitVertex();
+            EndPrimitive();
+        }
+    } else {
+        // Horizontal line
+        if(first.x < second.x) {
+            gl_Position = first + vec4(-sizeX, -sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = second + vec4(sizeX, -sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = first + vec4(-sizeX, sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = second + vec4(sizeX, sizeY, 0, 0);
+            EmitVertex();
+            EndPrimitive();
+        } else {
+            gl_Position = second + vec4(sizeX, sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = first + vec4(-sizeX, sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = second + vec4(sizeX, -sizeY, 0, 0);
+            EmitVertex();
+            gl_Position = first + vec4(-sizeX, -sizeY, 0, 0);
+            EmitVertex();
+            EndPrimitive();
+        }
+    }
+}

fast/kernels/Visualization/BoundingBoxRenderer/BoundingBoxRenderer.vert

@@ -0,0 +1,17 @@
+#version 330 core
+layout (location = 0) in vec3 in_position;
+layout (location = 1) in uint in_label;
+layout (std140) uniform Colors {
+    vec4 color[256];
+};
+
+out vec4 vertexColor;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+
+void main() {
+    gl_Position = perspectiveTransform * viewTransform * transform * vec4(in_position, 1.0);
+    vertexColor = in_label < uint(256) ? color[in_label] : vec4(0.0, 0.0, 0.0, 0.0);
+}

fast/kernels/Visualization/HeatmapRenderer/HeatmapRenderer.cl

@@ -0,0 +1,51 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST;
+
+__kernel void renderToTexture(
+        __global float* inputTensor,
+        __write_only image2d_t output,
+        __constant float* colors,
+        __private float minConfidence,
+        __private float maxOpacity,
+        __private int channels
+) {
+    const int2 position = {get_global_id(0), get_global_id(1)};
+
+    float4 color = {0.0f, 0.0f, 0.0f, 0.0f};
+    for(int channel = 0; channel < channels; ++channel) {
+        float intensity = inputTensor[(position.x + position.y*get_global_size(0))*channels + channel];
+        intensity = clamp(intensity, 0.0f, 1.0f);
+
+        if(intensity >= minConfidence) {
+            float4 colorToUse = vload4(channel, colors);
+            color += colorToUse*intensity;
+        }
+    }
+    color = clamp(color, 0.0f, 1.0f);
+    if(color.w == 0) { // none with intensity >= minConfidence or 0 found
+        color = (float4)(0.0f,0.0f,0.0f,0.0f);
+        // Look for neighbors instead
+        float highestConfidence = minConfidence;
+        for(int a = -1; a <= 1; ++a) {
+            for(int b = -1; b <= 1; ++b) {
+                int2 nPos = {position.x + a, position.y + b};
+                // Out of bounds check:
+                if(nPos.x < 0 || nPos.y < 0 || nPos.x >= get_global_size(0) || nPos.y >= get_global_size(1))
+                    continue;
+                for(int channel = 0; channel < channels; ++channel) {
+                    float intensity = inputTensor[(nPos.x + nPos.y*get_global_size(0))*channels + channel];
+
+                    if(intensity >= highestConfidence) {
+                        float4 colorToUse = vload4(channel, colors);
+                        color = colorToUse;
+                        color.w = 0.0f; // Set opacity to zero
+                        highestConfidence = intensity;
+                    }
+                }
+            }
+        }
+    } else {
+        color.w *= maxOpacity;
+    }
+    write_imagef(output, position, color);
+}
+

fast/kernels/Visualization/ImagePyramidRenderer/ImagePyramidRenderer.frag

@@ -0,0 +1,11 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec2 TexCoord;
+
+uniform sampler2D ourTexture;
+
+void main()
+{
+    FragColor = texture(ourTexture, TexCoord);
+}

fast/kernels/Visualization/ImagePyramidRenderer/ImagePyramidRenderer.vert

@@ -0,0 +1,15 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec2 aTexCoord;
+
+out vec2 TexCoord;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+
+void main()
+{
+    gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0);
+    TexCoord = aTexCoord;
+}

fast/kernels/Visualization/ImageRenderer/ImageRenderer.vert

@@ -0,0 +1,15 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec2 aTexCoord;
+
+out vec2 TexCoord;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+
+void main()
+{
+    gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0);
+    TexCoord = aTexCoord;
+}