/*
 * Realiza a filtragem da media a partir da convolucao entre uma imagem ruidosa
 * com uma mascara de tamanho nxn (n, impar, eh um parametro de entrada)
 *
 * n = 3 (default)
 */
 
#define MAX
#include "lib.h"
#include <math.h>
#include <time.h>

IMAGE mediana(IMAGE x, int n);

unsigned char max(unsigned char a, unsigned char b) {
    if (a > b) return a;
    return b;
}

unsigned char min(unsigned char a, unsigned char b) {
    if (a < b) return a;
    return b;
}

//insertion sort O(n*n)
void sort(unsigned char *o, int length) {
    int i, j;
    unsigned char tmp;
    
    for (i = 1; i < length; i++) {
        //find i place
        for (j = 0; j < i; j++) {
            if (o[j] > o[i]) break;
        }
        if (j < i) {
            tmp = o[i];
            //move tudo
            memcpy(&o[j+1], &o[j], i-j);
            o[j] = tmp;
        }
    }
    
//    printf("Ordenado: \n");
//    for (i = 0; i < length; i++) {
//        printf("%d, ", o[i]);
//    }
}

IMAGE mediana(IMAGE x, int n)
{
	int i,j,mi,mj;
    IMAGE y;
    unsigned char med, *ord;
    
    y = newimage(x->info->nr, x->info->nc);
    ord = (unsigned char *)malloc(n*n);

	for (i = n/2; i < x->info->nr-n/2; i++) {
        for (j = n/2; j < x->info->nc-n/2; j++) {
            //calculation
            for (mi = -n/2; mi <= n/2; mi++) {
                for (mj = -n/2; mj <= n/2; mj++) {
                    ord[(mi + n/2) * n + (mj + n/2)] = x->data[i + mi][j + mj];
                }
            }
            sort(ord, n*n);
            y->data[i][j] = ord[n];
        }
    }
    
    return(y);
}   
 
IMAGE mediana_test() {
    IMAGE x;
    
    //small case test
    x = newimage(3,3);
    x->data[0][0] = 200;
    x->data[0][1] = 150;
    x->data[0][2] = 200;
    x->data[1][0] = 150;
    x->data[1][1] = 200;
    x->data[1][2] = 150;
    x->data[2][0] = 200;
    x->data[2][1] = 150;
    x->data[2][2] = 100;
   
    return(mediana(x, 3));
}

main(int argc, char *argv[])
{
    int n = 3;
	IMAGE x=0;
    time_t t0, t1;

	if (argc < 2)
	{
	  printf("Usage: mediana <image> [<mask_size>]\n");
	  exit(1);
	}

	x = Input_PBM(argv[1]);
	if (x == 0)
	{
	  printf("No input image ('%s')\n", argv[1]);
	  exit(2);
	}

    if (argc > 2) {
        sscanf(argv[2], "%d", &n);
        if (n % 2 <= 0) {
            printf("Mask size must be an odd natural number\n");
            exit(2);
        }
    }

    printf("Average filter with mask of size %d\n", n);

    t0 = time(NULL);
	x = mediana(x, n);
    t1 = time(NULL);

	Output_PBM(x, "mediana.pgm");
	printf("Output is in file 'mediana.pgm'\n");
	printf("Processing time: %lf seconds\n", difftime(t1,t0));
}