imageProcessing

#include <float.h>
#include <stdio.h>
#include <cilk/cilk.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)
{
	cilk_for (unsigned 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; //reduktor
				}
			}
		}
	}
}


/**
* @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 filterParallelMed(int* inBuffer, int* outBuffer, int width, int height)
{
	int offset = KERNEL_LENGTH / 2;

	// loop through pixels
	cilk_for (int i = offset; i < width - offset; i++) {
		int temp[KERNEL_SIZE];
		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; //reduktor
					}
				}
				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];
		}
	}
}

void filterParallelAvg2(int* inBuffer, int* outBuffer, int width, int height)
{
	cilk_for(int i = OFFSET; i < width - OFFSET; i++)
	{
		cilk_for (int j = OFFSET; j < height - OFFSET; j++)
		{
			for (int m = -OFFSET; m <= OFFSET; m++)
			{
				outBuffer[j * width + i] += __sec_reduce_add(inBuffer[(j + m) * width + (i - OFFSET) : KERNEL_LENGTH] / KERNEL_SIZE);
			}
		}
	}
}

void filterParallelMed2(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 minIndex = idx;
				minIndex = __sec_reduce_min_ind(temp[idx:KERNEL_SIZE - idx]);
				if (idx != minIndex) {
					int swap = temp[idx];
					temp[idx] = temp[minIndex];
					temp[minIndex] = swap;
				}
			}

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