pyfast 4.12.0__cp36-abi3-win_amd64.whl

fast/kernels/Algorithms/AirwaySegmentation/AirwaySegmentation.cl

@@ -0,0 +1,85 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+__constant sampler_t sampler2 = 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 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
+}
+
+__kernel void dilate(
+        __read_only image3d_t volume, 
+#ifdef fast_3d_image_writes
+        __write_only image3d_t result
+#else
+        __global uchar * result
+#endif
+    ) {
+    int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+
+    if(read_imageui(volume, sampler, pos).x == 1) {
+    	const int N = 2;
+        for(int a = -N; a <= N; ++a) {
+        for(int b = -N; b <= N; ++b) {
+        for(int c = -N; c <= N; ++c) {
+            int4 nPos = pos + (int4)(a,b,c,0);
+#ifdef fast_3d_image_writes
+            write_imageui(result, nPos, 1);
+#else
+            // Check if in bounds
+            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 erode(
+        __read_only image3d_t volume, 
+#ifdef fast_3d_image_writes
+        __write_only image3d_t result
+#else
+        __global uchar * result
+#endif
+    ) {
+    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;
+    	const int N = 2;
+    	// Check if all pixels in neighborhood is 1
+        for(int a = -N; a <= N; ++a) {
+        for(int b = -N; b <= N; ++b) {
+        for(int c = -N; c <= N; ++c) {
+            keep = (read_imageui(volume, sampler2, pos + (int4)(a,b,c,0)).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
+}

fast/kernels/Algorithms/ApplyColormap/ApplyColormap.cl

@@ -0,0 +1,146 @@
+__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 writeImageAsFloat42D(__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)));
+    }
+}
+
+
+void writeImageAsFloat2D(__write_only image2d_t image, int2 position, float 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 vload4_at_pos(int position, __constant float* data) {
+    return (float4)(data[position], data[position+1], data[position+2], 1.0f);
+}
+
+float4 vload4_at_pos_opacity(int position, __constant float* data) {
+    return (float4)(data[position], data[position+1], data[position+2], data[position+3]);
+}
+
+float getIntensityFromColormap(float intensity, __constant float* colormap, int steps, char interpolate) {
+    float first = colormap[1];
+    float firstIntensity = colormap[0];
+
+    if(intensity <= firstIntensity)
+        return first;
+
+    for(int i = 1; i < steps; ++i) {
+        float second = colormap[i*2+1];
+        float secondIntensity = colormap[i*2];
+        if(intensity <= secondIntensity) {
+            if(interpolate == 1) {
+                return mix(first, second, (intensity - firstIntensity)/(secondIntensity - firstIntensity));
+            } else {
+                // Nearest
+                if(intensity - firstIntensity < secondIntensity - intensity) {
+                    return first;
+                } else {
+                    return second;
+                }
+            }
+        }
+        first = second;
+        firstIntensity = secondIntensity;
+    }
+    return first;
+}
+
+float4 getColorFromColormap(float intensity, __constant float* colormap, int steps, char interpolate, char hasOpacity) {
+    float4 first;
+    if(hasOpacity == 1) {
+        first = vload4_at_pos_opacity(1, colormap);
+    } else {
+        first = vload4_at_pos(1, colormap);
+    }
+    float firstIntensity = colormap[0];
+
+    int values = 4;
+    if(hasOpacity == 1)
+        values = 5;
+
+    if(intensity <= firstIntensity)
+        return first;
+
+    for(int i = 1; i < steps; ++i) {
+        float4 second;
+        if(hasOpacity == 1) {
+            second = vload4_at_pos_opacity(i*values + 1, colormap);
+        } else {
+            second = vload4_at_pos(i*values + 1, colormap);
+        }
+        float secondIntensity = colormap[i*values];
+        if(intensity <= secondIntensity) {
+            if(interpolate == 1) {
+                return mix(first, second, (intensity - firstIntensity)/(secondIntensity - firstIntensity));
+            } else {
+                // Nearest
+                if(intensity - firstIntensity < secondIntensity - intensity) {
+                    return first;
+                } else {
+                    return second;
+                }
+            }
+        }
+        first = second;
+        firstIntensity = secondIntensity;
+    }
+    return first;
+}
+
+__kernel void applyColormap(
+            __read_only image2d_t input,
+            __write_only image2d_t output,
+            __constant float* colormap,
+            __private int steps,
+            __private char interpolate,
+            __private char grayscale,
+            __private char hasOpacity,
+            __private char isIntensityInvariant,
+            __private char isDiverging,
+            __private float minValue,
+            __private float maxValue
+    ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+
+    float4 value = readImageAsFloat2D(input, sampler, pos);
+
+    if(isIntensityInvariant == 1) {
+        if(isDiverging == 1) {
+            value.x = clamp(value.x / max(fabs(minValue), fabs(maxValue)), -1.0f, 1.0f);
+        } else {
+            value.x = clamp((value.x - minValue) / (maxValue - minValue), 0.0f, 1.0f);
+        }
+    }
+
+    if(grayscale == 1) {
+        writeImageAsFloat2D(output, pos, getIntensityFromColormap(value.x, colormap, steps, interpolate));
+    } else {
+        writeImageAsFloat42D(output, pos, getColorFromColormap(value.x, colormap, steps, interpolate, hasOpacity));
+    }
+}

fast/kernels/Algorithms/BinaryThresholding/BinaryThresholding2D.cl

@@ -0,0 +1,61 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+float getIntensity(__read_only image2d_t image, int2 pos) {
+    float value;
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT) {
+        value = read_imagef(image, sampler, pos).x;
+    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        value = read_imageui(image, sampler, pos).x;
+    } else {
+        value = read_imagei(image, sampler, pos).x;
+    }
+    return value;
+}
+
+__kernel void thresholding(
+        __read_only image2d_t image,
+        __write_only image2d_t segmentation,
+        __private float lowerThreshold,
+        __private float upperThreshold
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    
+    const float value = getIntensity(image, pos);
+   
+    uchar writeValue = 0;
+    if(value >= lowerThreshold && value <= upperThreshold) {
+        writeValue = 1;
+    }
+    write_imageui(segmentation, pos, writeValue);
+}
+__kernel void thresholdingWithOnlyLower(
+        __read_only image2d_t image,
+        __write_only image2d_t segmentation,
+        __private float lowerThreshold
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    
+    const float value = getIntensity(image, pos);
+
+    uchar writeValue = 0;
+    if(value >= lowerThreshold) {
+        writeValue = 1;
+    }
+    write_imageui(segmentation, pos, writeValue);
+}
+__kernel void thresholdingWithOnlyUpper(
+        __read_only image2d_t image,
+        __write_only image2d_t segmentation,
+        __private float upperThreshold
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    
+    const float value = getIntensity(image, pos);
+
+    uchar writeValue = 0;
+    if(value <= upperThreshold) {
+        writeValue = 1;
+    }
+    write_imageui(segmentation, pos, writeValue);
+}

fast/kernels/Algorithms/BinaryThresholding/BinaryThresholding3D.cl

@@ -0,0 +1,61 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+float getIntensity(__read_only image3d_t image, int4 pos) {
+    float value;
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT) {
+        value = read_imagef(image, sampler, pos).x;
+    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        value = read_imageui(image, sampler, pos).x;
+    } else {
+        value = read_imagei(image, sampler, pos).x;
+    }
+    return value;
+}
+
+__kernel void thresholding(
+        __read_only image3d_t image,
+        __write_only image3d_t segmentation,
+        __private float lowerThreshold,
+        __private float upperThreshold
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    
+    const float value = getIntensity(image, pos);
+   
+    uchar writeValue = 0;
+    if(value >= lowerThreshold && value <= upperThreshold) {
+        writeValue = 1;
+    }
+    write_imageui(segmentation, pos, writeValue);
+}
+__kernel void thresholdingWithOnlyLower(
+        __read_only image3d_t image,
+        __write_only image3d_t segmentation,
+        __private float lowerThreshold
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    
+    const float value = getIntensity(image, pos);
+
+    uchar writeValue = 0;
+    if(value >= lowerThreshold) {
+        writeValue = 1;
+    }
+    write_imageui(segmentation, pos, writeValue);
+}
+__kernel void thresholdingWithOnlyUpper(
+        __read_only image3d_t image,
+        __write_only image3d_t segmentation,
+        __private float upperThreshold
+        ) {
+    const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
+    
+    const float value = getIntensity(image, pos);
+
+    uchar writeValue = 0;
+    if(value <= upperThreshold) {
+        writeValue = 1;
+    }
+    write_imageui(segmentation, pos, writeValue);
+}

fast/kernels/Algorithms/BlockMatching/BlockMatching.cl

@@ -0,0 +1,257 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST;
+
+float getPixelAsFloat(__read_only image2d_t image, int2 pos) {
+    float value;
+    int dataType = get_image_channel_data_type(image);
+    if(dataType == CLK_FLOAT) {
+        value = read_imagef(image, sampler, pos).x;
+    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        value = read_imageui(image, sampler, pos).x;
+    } else {
+        value = read_imagei(image, sampler, pos).x;
+    }
+    return value;
+}
+
+float calculateMeanIntensity(__read_only image2d_t frame, int2 pos) {
+    float mean = 0.0f;
+    for(int y = pos.y - BLOCK_SIZE; y <= pos.y + BLOCK_SIZE; ++y) {
+        for(int x = pos.x - BLOCK_SIZE; x <= pos.x + BLOCK_SIZE; ++x) {
+            mean += getPixelAsFloat(frame, (int2)(x,y));
+        }
+    }
+
+    return mean/((BLOCK_SIZE*2+1)*(BLOCK_SIZE*2+1));
+}
+
+
+inline float2 findSubpixelMovement(const float2 movement, const float b[GRID_SIZE][GRID_SIZE]) {
+    const int index_x = (int)movement.x + SEARCH_SIZE+1;
+    const int index_y = (int)movement.y + SEARCH_SIZE+1;
+    // Subpixel parabolic fitting
+    const float A =
+            (b[index_x-1][index_y-1] - 2 * b[index_x][index_y-1] + b[index_x+1][index_y-1] + b[index_x-1][index_y] - 2 * b[index_x][index_y] + b[index_x+1][index_y] + b[index_x-1][index_y+1] - 2 * b[index_x][index_y+1] +
+             b[index_x+1][index_y+1]) / 6.0;
+    const float B = (b[index_x-1][index_y-1] - b[index_x+1][index_y-1] - b[index_x-1][index_y+1] + b[index_x+1][index_y+1]) / 4.0;
+    const float C =
+            (b[index_x-1][index_y-1] + b[index_x][index_y-1] + b[index_x+1][index_y-1] - 2 * b[index_x-1][index_y] - 2 * b[index_x][index_y] - 2 * b[index_x+1][index_y] + b[index_x-1][index_y+1] + b[index_x][index_y+1] +
+             b[index_x+1][index_y+1]) / 6.0;
+    const float D = (-b[index_x-1][index_y-1] + b[index_x+1][index_y-1] - b[index_x-1][index_y] + b[index_x+1][index_y] - b[index_x-1][index_y+1] + b[index_x+1][index_y+1]) / 6.0;
+    const float E = (-b[index_x-1][index_y-1] - b[index_x][index_y-1] - b[index_x+1][index_y-1] + b[index_x-1][index_y+1] + b[index_x][index_y+1] + b[index_x+1][index_y+1]) / 6.0;
+    const float F = (-b[index_x-1][index_y-1] + 2 * b[index_x][index_y-1] - b[index_x+1][index_y-1] + 2 * b[index_x-1][index_y] + 5 * b[index_x][index_y] + 2 * b[index_x+1][index_y] - b[index_x-1][index_y+1] +
+                    2 * b[index_x][index_y+1] - b[index_x+1][index_y+1]) / 9.0;
+
+    return (float2)(movement.x + (B * E - 2.0 * C * D) / (4.0 * A * C - B * B),
+                    movement.y + (B * D - 2.0 * A * E) / (4.0 * A * C - B * B));
+}
+
+inline float2 findMovementNCC(
+        __read_only image2d_t previousFrame,
+        __read_only image2d_t currentFrame,
+        const int2 pos,
+        float targetMean
+        ) {
+    // Create grid for subpixel movement calculations
+    float b[GRID_SIZE][GRID_SIZE];
+
+    // For every possible block position
+    float bestScore = -1.0f;
+    float2 movement = {0, 0};
+    for(int y = pos.y - SEARCH_SIZE - 1; y <= pos.y + SEARCH_SIZE + 1; ++y)  {
+        for(int x = pos.x - SEARCH_SIZE - 1; x <= pos.x + SEARCH_SIZE + 1; ++x)  {
+            // previousframe at pos x,y is the current candidate
+            const float candidateMean = calculateMeanIntensity(previousFrame, (int2)(x, y));
+            float upperPart = 0.0f;
+            float lowerPart1 = 0.0f;
+            float lowerPart2 = 0.0f;
+            // Loop over target and candidate block
+            for(int a = -BLOCK_SIZE; a <= BLOCK_SIZE; ++a) {
+                for(int b = -BLOCK_SIZE; b <= BLOCK_SIZE; ++b) {
+                    const float imagePart = getPixelAsFloat(previousFrame, (int2)(x+a, y+b)) - candidateMean;
+                    const float targetPart = getPixelAsFloat(currentFrame, (int2)(pos.x+a, pos.y+b)) - targetMean;
+                    upperPart += imagePart*targetPart;
+                    lowerPart1 += imagePart*imagePart;
+                    lowerPart2 += targetPart*targetPart;
+                }
+            }
+
+            const float result = upperPart / sqrt(lowerPart1*lowerPart2);
+            b[x- pos.x + SEARCH_SIZE + 1][y - pos.y + SEARCH_SIZE + 1] = result;
+            if(result > bestScore && abs(x - pos.x) <= SEARCH_SIZE && abs(y - pos.y) <= SEARCH_SIZE) {
+                bestScore = result;
+                movement = (float2)(x - pos.x, y - pos.y); // Movement is the offset from pos.x, pos.y
+            }
+        }
+    }
+
+    float2 subpixel_movement = findSubpixelMovement(movement, b);
+    return subpixel_movement;
+}
+
+__kernel void normalizedCrossCorrelation(
+        __read_only image2d_t previousFrame,
+        __read_only image2d_t currentFrame,
+        __write_only image2d_t output,
+        __private const float intensityThreshold,
+        __private const float timeLag,
+        __private const char forwardBackward
+    ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+
+    // Template is what we are looking for (target), currentFrame at pos
+    const float targetMean = calculateMeanIntensity(currentFrame, pos);
+    if(targetMean < intensityThreshold) { // if target is all zero/black, just stop here
+        write_imagef(output, pos, (float4)(0, 0, 0, 0));
+        return;
+    }
+
+    float2 movement = findMovementNCC(previousFrame, currentFrame, pos, targetMean);
+    if(forwardBackward == 1) {
+      const float targetMean2 = calculateMeanIntensity(previousFrame, pos);
+      movement = (movement - findMovementNCC(currentFrame, previousFrame, pos, targetMean2))*0.5f;
+    }
+
+    // If movement is larger than SEARCH_SIZE, zero it out
+    if(length(movement) > SEARCH_SIZE + 1)
+        movement = (float2)(0,0);
+
+    write_imagef(output, pos, movement.xyyy / timeLag);
+}
+
+inline float2 findMovementSSD(
+        __read_only image2d_t previousFrame,
+        __read_only image2d_t currentFrame,
+        const int2 pos,
+        float minIntensity,
+        float maxIntensity
+        ) {
+    // Create grid for subpixel movement calculations
+    float b[GRID_SIZE][GRID_SIZE];
+
+    // For every possible block position
+    float bestScore = 0.0f;
+    float2 movement = {0, 0};
+    for(int y = pos.y - SEARCH_SIZE - 1; y <= pos.y + SEARCH_SIZE + 1; ++y)  {
+        for(int x = pos.x - SEARCH_SIZE - 1; x <= pos.x + SEARCH_SIZE + 1; ++x)  {
+            // previousframe at pos x,y is the current candidate
+            float ssd = 0.0f;
+            // Loop over target and candidate block
+            for(int a = -BLOCK_SIZE; a <= BLOCK_SIZE; ++a) {
+                for(int b = -BLOCK_SIZE; b <= BLOCK_SIZE; ++b) {
+                    float val = (getPixelAsFloat(previousFrame, (int2)(x+a,y+b)) - minIntensity)/(maxIntensity - minIntensity) -
+                            (getPixelAsFloat(currentFrame, (int2)(pos.x+a,pos.y+b)) - minIntensity)/(maxIntensity - minIntensity);
+                    ssd += val*val;
+                }
+            }
+
+            const float result = 1.0f - (ssd/((BLOCK_SIZE*2+1)*(BLOCK_SIZE*2+1))); // calculate average and invert
+
+            b[x- pos.x + SEARCH_SIZE + 1][y - pos.y + SEARCH_SIZE + 1] = result;
+            if(result > bestScore && abs(x - pos.x) <= SEARCH_SIZE && abs(y - pos.y) <= SEARCH_SIZE) {
+                bestScore = result;
+                movement = (float2)(x - pos.x, y - pos.y); // Movement is the offset from pos.x, pos.y
+            }
+        }
+    }
+    float2 subpixel_movement = findSubpixelMovement(movement, b);
+    return subpixel_movement;
+}
+
+__kernel void sumOfSquaredDifferences(
+        __read_only image2d_t previousFrame,
+        __read_only image2d_t currentFrame,
+        __write_only image2d_t output,
+        __private const float intensityThreshold,
+        __private const float timeLag,
+        __private const char forwardBackward,
+        __private const float minIntensity,
+        __private const float maxIntensity
+) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+
+    // Template is what we are looking for (target), currentFrame at pos
+    const float targetMean = calculateMeanIntensity(currentFrame, pos);
+    if(targetMean < intensityThreshold) { // if target is all zero/black, just stop here
+        write_imagef(output, pos, (float4)(0, 0, 0, 0));
+        return;
+    }
+
+    float2 movement = findMovementSSD(previousFrame, currentFrame, pos, minIntensity, maxIntensity);
+    if(forwardBackward == 1)
+      movement = (movement - findMovementSSD(currentFrame, previousFrame, pos, minIntensity, maxIntensity))*0.5f;
+
+    // If movement is larger than SEARCH_SIZE, zero it out
+    if(length(movement) > SEARCH_SIZE + 1)
+        movement = (float2)(0,0);
+
+    write_imagef(output, pos, movement.xyyy / timeLag);
+}
+
+inline float2 findMovementSAD(
+        __read_only image2d_t previousFrame,
+        __read_only image2d_t currentFrame,
+        const int2 pos,
+        float minIntensity,
+        float maxIntensity
+        ) {
+    // Create grid for subpixel movement calculations
+    float b[GRID_SIZE][GRID_SIZE];
+
+    // For every possible block position
+    float bestScore = 0.0f;
+    float2 movement = {0, 0};
+    for(int y = pos.y - SEARCH_SIZE - 1; y <= pos.y + SEARCH_SIZE + 1; ++y)  {
+        for(int x = pos.x - SEARCH_SIZE - 1; x <= pos.x + SEARCH_SIZE + 1; ++x)  {
+            // previousframe at pos x,y is the current candidate
+            float sad = 0.0f;
+            // Loop over target and candidate block
+            for(int a = -BLOCK_SIZE; a <= BLOCK_SIZE; ++a) {
+                for(int b = -BLOCK_SIZE; b <= BLOCK_SIZE; ++b) {
+                    sad += fabs((getPixelAsFloat(previousFrame, (int2)(x+a,y+b)) - minIntensity)/(maxIntensity - minIntensity) -
+                            (getPixelAsFloat(currentFrame, (int2)(pos.x+a,pos.y+b)) - minIntensity)/(maxIntensity - minIntensity));
+                }
+            }
+
+            const float result = 1.0f - (sad/((BLOCK_SIZE*2+1)*(BLOCK_SIZE*2+1))); // calculate average and invert
+
+            b[x- pos.x + SEARCH_SIZE + 1][y - pos.y + SEARCH_SIZE + 1] = result;
+            if(result > bestScore && abs(x - pos.x) <= SEARCH_SIZE && abs(y - pos.y) <= SEARCH_SIZE) {
+                bestScore = result;
+                movement = (float2)(x - pos.x, y - pos.y); // Movement is the offset from pos.x, pos.y
+            }
+        }
+    }
+
+    float2 subpixel_movement = findSubpixelMovement(movement, b);
+    return subpixel_movement;
+}
+
+__kernel void sumOfAbsoluteDifferences(
+        __read_only image2d_t previousFrame,
+        __read_only image2d_t currentFrame,
+        __write_only image2d_t output,
+        __private const float intensityThreshold,
+        __private const float timeLag,
+        __private const char forwardBackward,
+        __private const float minIntensity,
+        __private const float maxIntensity
+) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+
+    // Template is what we are looking for (target), currentFrame at pos
+    const float targetMean = calculateMeanIntensity(currentFrame, pos);
+    if(targetMean < intensityThreshold) { // if target is all zero/black, just stop here
+        write_imagef(output, pos, (float4)(0, 0, 0, 0));
+        return;
+    }
+
+    float2 movement = findMovementSAD(previousFrame, currentFrame, pos, minIntensity, maxIntensity);
+    if(forwardBackward == 1)
+      movement = (movement - findMovementSAD(currentFrame, previousFrame, pos, minIntensity, maxIntensity))*0.5f;
+
+    // If movement is larger than SEARCH_SIZE, zero it out
+    if(length(movement) > SEARCH_SIZE + 1)
+        movement = (float2)(0,0);
+
+    write_imagef(output, pos, movement.xyyy / timeLag);
+}