imageProcessing2

#include <float.h>
#include <stdio.h>
#include <cilk/cilk.h>
#include <cilk/reducer_opadd.h>
#include "ImageProcessing.h"

/**
* @brief Serial version of moving average filter.
* @param inBuffer buffer of input image
* @param outBuffer buffer of output image
* @param width image width
* @param height image height
*/
void filterSerialAvg(int* inBuffer, int* outBuffer, int width, int height)
{
    // loop through pixels
    for (int i = OFFSET; i < width - OFFSET; i++)
    {
        for (int j = OFFSET; j < height - OFFSET; j++)
        {
            // digital convolution - filtering
            for (int m = -OFFSET; m <= OFFSET; m++)
            {
                for (int n = -OFFSET; n <= OFFSET; n++)
                {
                    outBuffer[j * width + i] += inBuffer[(j + n) * width + (i + m)] / KERNEL_SIZE;
                }
            }
        }
    }
}


/**
* @brief Parallel version of moving average filter.
*
* @param inBuffer buffer of input image
* @param outBuffer buffer of output image
* @param width image width
* @param height image height
*/
void filterParallelAvg(int* inBuffer, int* outBuffer, int width, int height)
{
    // loop through pixels
    cilk_for (int i = OFFSET; i < width - OFFSET; i++)
    {
        cilk_for (int j = OFFSET; j < height - OFFSET; j++)
        {
            // digital convolution - filtering
            for (int m = -OFFSET; m <= OFFSET; m++)
            {
                outBuffer[j * width + i] += __sec_reduce_add(inBuffer[(j - m) * width + (i - OFFSET) : KERNEL_LENGTH] / KERNEL_SIZE);
                /*for (int n = -OFFSET; n <= OFFSET; n++)
                {
                    outBuffer[j * width + i] += __sec_reduce_add(inBuffer[(j - m) * width + (i - OFFSET) : KERNEL_LENGTH] / KERNEL_SIZE); inBuffer[(j + n) * width + (i + m)] / KERNEL_SIZE;
                }*/
            }
        }
    }
}


/**
* @brief Serial version of median filter.
* @param inBuffer buffer of input image
* @param outBuffer buffer of output image
* @param width image width
* @param height image height
*/
void filterSerialMed(int *inBuffer, int *outBuffer, int width, int height) {

    int temp[KERNEL_SIZE];
    int offset = KERNEL_LENGTH/2;

    // loop through pixels
    for (int i = offset; i < width - offset; i ++) {
        for (int j = offset; j < height - offset; j++) {

            int idx = 0;
            // extract pixels
            for (int m = -offset; m <= offset; m++) {
                for (int n = -offset; n <= offset; n++) {
                    temp[idx++] = inBuffer[(j + n) * width + (i + m)];
                }
            }

            // sort
            for(idx = 0; idx < KERNEL_SIZE-1; idx++)
            {
                int minIdx = idx;
                for(int sortIdx = idx+1; sortIdx < KERNEL_SIZE; sortIdx++)
                {
                    if(temp[sortIdx]<temp[minIdx]){
                        minIdx = sortIdx;
                    }
                }
                if(idx!=minIdx){
                    int swap = temp[idx];
                    temp[idx] = temp[minIdx];
                    temp[minIdx] = swap;
                }
            }

            // store central pixel
            outBuffer[j * width + i] = temp[KERNEL_SIZE/2];
        }
    }
}


/**
* @brief Parallel version of median filter.
*
* @param inBuffer buffer of input image
* @param outBuffer buffer of output image
* @param width image width
* @param height image height
*/

void parFunc1(int* temp, int* inBuffer, int i, int j, int width, int offset) {
    int idx = 0;
    // extract pixels
    for (int m = -offset; m <= offset; m++) {
        for (int n = -offset; n <= offset; n++) {
            temp[idx++] = inBuffer[(j + n) * width + (i + m)];
        }
    }
}

void parFunc2(int* temp) {
    for (int idx = 0; idx < KERNEL_SIZE - 1; idx++)
    {
        int minIdx = __sec_reduce_min_ind(temp[idx:KERNEL_SIZE - idx]);
        /*for (int sortIdx = idx + 1; sortIdx < KERNEL_SIZE; sortIdx++)
        {
        if (temp[sortIdx]<temp[minIdx]) {
        minIdx = sortIdx;
        }
        }*/
        if (idx != minIdx) {
            int swap = temp[idx];
            temp[idx] = temp[minIdx];
            temp[minIdx] = swap;
        }
    }
}

void filterParallelMed(int* inBuffer, int* outBuffer, int width, int height)
{
    int temp[KERNEL_SIZE];
    int offset = KERNEL_LENGTH / 2;

    // loop through pixels
    for (int i = offset; i < width - offset; i++) {
        for (int j = offset; j < height - offset; j++) {

            parFunc1(temp, inBuffer, i, j, width, offset);

            // sort
            parFunc2(temp);

            // store central pixel
            outBuffer[j * width + i] = temp[KERNEL_SIZE / 2];
        }
    }
}