filter.c

#include "Filter.h"
#include <math.h>

#define ABS(x)          ((x>0)? x : -x)

typedef union {
	uint8_t pix[4];
	unsigned full;
} OneToFourPixels;

float BOX_BLUR_KERNEL_3[9] = { 1.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0,
							  1.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0,
							  1.0 / 9.0, 1.0 / 9.0, 1.0 / 9.0
};

float BOX_BLUR_KERNEL_5[25] = { 1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0,
		1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0,
		1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0,
		1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0,
		1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0, 1.0 / 25.0,
};

float GAUSSIAN_BLUR_KERNEL[49] = {
			0.00000067,	0.00002292,	0.00019117,	0.00038771,	0.00019117,	0.00002292,	0.00000067,
			0.00002292,	0.00078633,	0.00655965,	0.01330373,	0.00655965,	0.00078633,	0.00002292,
			0.00019117,	0.00655965,	0.05472157,	0.11098164,	0.05472157,	0.00655965,	0.00019117,
			0.00038771,	0.01330373,	0.11098164,	0.22508352,	0.11098164,	0.01330373,	0.00038771,
			0.00019117,	0.00655965,	0.05472157,	0.11098164,	0.05472157,	0.00655965,	0.00019117,
			0.00002292,	0.00078633,	0.00655965,	0.01330373,	0.00655965,	0.00078633,	0.00002292,
			0.00000067,	0.00002292,	0.00019117,	0.00038771,	0.00019117,	0.00002292,	0.00000067
};

int SOBEL_KERNEL_X[9] = { -1.0, 0.0, 1.0,
							  -2.0, 0.0, 2.0,
							  -1.0, 0.0, 1.0,
};

int SOBEL_KERNEL_Y[9] = { -1.0, -2.0, -1.0,
							  0.0, 0.0, 0.0,
							  1.0, 2.0, 1.0,
};

int LAPLACIAN_KERNEL[9] = { 0.0, -1.0, 0.0,
							    -1.0, 4.0, -1.0,
								0.0, -1.0, 0.0
};

int LAPLACIAN_GAUSSIAN_KERNEL[25] = {
		0.0, 0.0, -1.0, 0.0, 0.0,
		0.0, -1.0, -2.0, -1.0, 0.0,
		-1.0, -2.0, 16.0, -2.0, -1.0,
		0.0, -1.0, -2.0, -1.0, 0.0,
		0.0, 0.0, -1.0, 0.0, 0.0,
};

uint8_t filter_operator(const int fullIndex, uint8_t * image)
{
#pragma HLS inline			// Inliner la fonction lui permet d'etre "copie-coller" lorsqu elle est appelle
							// et ainsi faciliter le pipelinage de la boucle principale
	/*la fonction peut avoir 3 signatures différentes, selon vos différentes modifications:
	 * uint8_t filter_operator(const int fullIndex, uint8_t * image)
	 * uint8_t filter_operator(const int fullIndex, uint8_t image[IMG_HEIGHT * IMG_WIDTH])
	 * uint8_t filter_operator(const int col, const int row, uint8_t image[IMG_HEIGHT][IMG_WIDTH])
	 *
	 * Les deux premieres sont assez equivalentes, mais la derniere permet d'acceder à l'image comme un
	 * tableau 2D. Par contre, un tableau 2D doit alors lui etre passe, ce qui n'est pas evident considerant
	 * que les entrees de la fonction filtrer() sont 1D. Cependant, si pour une raison ou une autre
	 * un buffer-cache intermediaire etait utilise, celui-ci pourrait etre 2D...
	 */

	return 0;
}


void filter(uint8_t inter_pix[IMG_WIDTH * IMG_HEIGHT], unsigned out_pix[IMG_WIDTH * IMG_HEIGHT])
{
	/* On demande à HLS de nous synthetiser des maitres AXI que l'on connectera à la memoire principale.
	 * Ainsi, le CPU n'a pas besoin de transferer l'image au filtre: c'est le filtre qui va chercher l'image
	 * dans la memoire principale (DDR de la carte) et ecrit le resultat dans cette meme memoire.
	 * Un esclave AXI-Lite est aussi cree, accessible par le CPU, pour informer le filtre des adresses
	 * auxquelles il doit aller chercher et ecrire l'image, lui dire de demarrer ou d'arreter, etc.
	 */
	// ***** LES 3 LIGNES SUIVANTES DOIVENT ETRE DECOMMENTEES UNE FOIS LES QUESTIONS INITIALES COMPLETE!! ******
#pragma HLS INTERFACE m_axi port=inter_pix offset=slave bundle=gmem0
#pragma HLS INTERFACE m_axi port=out_pix offset=slave bundle=gmem1
#pragma HLS INTERFACE s_axilite port=return
#pragma HLS inline
	OneToFourPixels fourWide;

	for (int i = 0; i < IMG_SIZE; i++) {

		fourWide.pix[0] = applyFilter(inter_pix, i, Sobel);
		fourWide.pix[1] = fourWide.pix[0];
		fourWide.pix[2] = fourWide.pix[0];
		fourWide.pix[3] = fourWide.pix[0];

		out_pix[i] = fourWide.full;
	}
}

float getTangent(float x, float y)
{
#pragma HLS inline

	float val = ABS(x) + ABS(y);

	val = (255 - (uint8_t)(val));
	if (val > 200) {
		val = 255;
	}
	else if (val < 100) {
		val = 0;
	}
	return val;
}

int getFilterSize(enum filter filter)
{
#pragma HLS inline

	switch (filter)
	{
		case BoxBlur3:
			return 3;
		case BoxBlur5:
			return 5;
		case GaussianBlur:
			return 7;
		case Sobel:
			return 3;
		case Laplacian:
			return 3;
		case LaplacianGaussian:
			return 5;
		default:
			return 0;
	}
}

void applyKernel(enum filter filter, uint8_t pixel, int filterPos, float newPixelValue[2])
{
#pragma HLS inline
	switch (filter)
	{
		case BoxBlur3:
			newPixelValue[0] += (float)pixel * BOX_BLUR_KERNEL_3[filterPos];
			break;
		case BoxBlur5:
			newPixelValue[0] += (float)pixel * BOX_BLUR_KERNEL_5[filterPos];
			break;
		case GaussianBlur:
			newPixelValue[0] += (float)pixel * GAUSSIAN_BLUR_KERNEL[filterPos];
			break;
		case Sobel:
			newPixelValue[0] += pixel * SOBEL_KERNEL_X[filterPos];
			newPixelValue[1] += pixel * SOBEL_KERNEL_Y[filterPos];
			break;
		case Laplacian:
			newPixelValue[0] += pixel * LAPLACIAN_KERNEL[filterPos];
			break;
		case LaplacianGaussian:
			newPixelValue[0] += pixel * LAPLACIAN_GAUSSIAN_KERNEL[filterPos];
			break;
		default:
			break;
	}
}

uint8_t applyFilter(uint8_t imageIn[IMG_SIZE], int curIndex, enum filter filter)
{
#pragma HLS inline

	int filterSize = getFilterSize(filter);

	float newPixelValue[2] = { 0.0, 0.0 };
	#pragma HLS ARRAY_PARTITION variable=newPixelValue complete dim=1

	int curImageRow = curIndex / IMG_WIDTH;
	int curImageCol = curIndex - (curImageRow * IMG_WIDTH);

	for (int i = 0; i < filterSize * filterSize; i++)
	{
#pragma HLS unroll factor = 3
		int curFilterRow = i / filterSize;
		int curFilterCol = i - (curFilterRow * filterSize);

		int targetedRow = curImageRow - (filterSize / 2) + curFilterRow;
		int targetedCol = curImageCol - (filterSize / 2) + curFilterCol;

		if (targetedRow >= 0 && targetedRow < IMG_HEIGHT && targetedCol >= 0 && targetedCol < IMG_WIDTH)
		{
			applyKernel(filter, imageIn[(targetedRow * IMG_WIDTH) + targetedCol], (curFilterRow * filterSize) + curFilterCol, newPixelValue);
		}
	}

	uint8_t val = (uint8_t)newPixelValue[0];
	return filter != Sobel ?  val : getTangent(newPixelValue[0], newPixelValue[1]);
}