#include <stdlib.h>
#include <string.h>
#include <math.h>

int compare(const void* arg1, const void* arg2)
{
  if (*((int*) arg1) < *((int*) arg2))
    return -1;
  else if (*((int*) arg1) > *((int*) arg2))
    return 1;
  else
    return 0;
}

unsigned char* meanFilter(int width, int height, int neighborsRange, unsigned char* imgSrc, unsigned char* imgDest)
{
  unsigned char* result;
  int pixelsAval, i, j, x, y, mean1, mean2, mean3;
  float div;

  if((width <= 0)||(height <= 0)) return NULL;

  if (!imgDest)
  {
    result = (unsigned char*) malloc(3*width*height*sizeof(unsigned char));
    if (!result)
      return NULL;
  }
  else
    result = imgDest;

  pixelsAval = ((2*neighborsRange)+1)*((2*neighborsRange)+1);
  div = 1.0f/(float)pixelsAval;

  // Avaliando Interior
  for (j = 1; j < height-1; j++)
  {
    for (i = 1; i < width-1; i++)
	{
	  mean1=0;
	  mean2=0;
	  mean3=0;
	  for (y = -neighborsRange; y <= neighborsRange; y++)
	  {
  	    for (x = -neighborsRange; x <= neighborsRange; x++)
		{
		  mean1 = mean1 + imgSrc[3*((j+y)*width + (i+x))];	  
		  mean2 = mean2 + imgSrc[3*((j+y)*width + (i+x))+1];	  
		  mean3 = mean3 + imgSrc[3*((j+y)*width + (i+x))+2];	  
		}
	  }
	  mean1 = (int)(mean1*div);
	  mean2 = (int)(mean2*div);
	  mean3 = (int)(mean3*div);
      result[3*(j*width + i)] = (unsigned char) mean1;
      result[3*(j*width + i)+1] = (unsigned char) mean2;
      result[3*(j*width + i)+2] = (unsigned char) mean3;
	}
  }

  // Avaliando Bordas

  return result;
}

unsigned char* gaussianFilter(int width, int height, int nband, int luminance, int nPasses, unsigned char* imgSrc, unsigned char* imgDest)
{
  unsigned char* result;
  unsigned char* temp;
  int kernel[9] = { 1,  2, 1,
	                2, 12, 2,
					1,  2, 1};
  float div = 1.0f/(float)24;
  int n, i, j, band, gaussian;

  if((width <= 0)||(height <= 0)||(nPasses <= 0)) return NULL;

  if (!imgDest)
  {
    result = (unsigned char*) malloc(3*width*height*sizeof(unsigned char));
    if (!result)
      return NULL;
  }
  else
    result = imgDest;

  temp = (unsigned char*) malloc(3*width*height*sizeof(unsigned char));
  
  for (n = 0; n < nPasses; n++)
  {
    // Avaliando Interior
    for (j = 1; j < height-1; j++)
    {
      for (i = 1; i < width-1; i++)
	  {
	    for (band = 0; band < nband; band++)
		{
          gaussian = kernel[0]*imgSrc[3*((j-1)*width + (i-1)) + band];  // 3*((j-1)*width + (i-1))
          gaussian += kernel[1]*imgSrc[3*((j-1)*width + i) + band];     // 3*((j-1)*width + i)
          gaussian += kernel[2]*imgSrc[3*((j-1)*width + (i+1)) + band]; // 3*((j-1)*width + (i+1))

		  gaussian += kernel[3]*imgSrc[3*(j*width + (i-1)) + band]; // 3*(j*width + (i-1))
          gaussian += kernel[4]*imgSrc[3*(j*width + i) + band];     // 3*(j*width + i)
          gaussian += kernel[5]*imgSrc[3*(j*width + (i+1)) + band]; // 3*(j*width + (i+1))

		  gaussian += kernel[6]*imgSrc[3*((j+1)*width + (i-1)) + band]; // 3*((j+1)*width + (i-1))
          gaussian += kernel[7]*imgSrc[3*((j+1)*width + i) + band];     // 3*((j+1)*width + i)
          gaussian += kernel[8]*imgSrc[3*((j+1)*width + (i+1)) + band]; // 3*((j+1)*width + (i+1))

		  result[3*(j*width + i)+ band] = (unsigned char) ((float)gaussian*div);
		}
	  }
    }

	// Avaliando Bordas
	// Borda Superior


	memcpy(temp, result, 3*width*height);
	imgSrc = temp;
  }
  free(temp);
  return result;
}

unsigned char* medianFilter(int width, int height, int neighborsRange, unsigned char* imgSrc, unsigned char* imgDest)
{
  unsigned char* result;
  int* pixelsAval1;
  int* pixelsAval2;
  int* pixelsAval3;
  int i, j, x, y;

  if((width<=0)||(height<=0)) return NULL;

  if (!imgDest)
  {
    result = (unsigned char*) malloc(3*width*height*sizeof(unsigned char));
    if (!result)
      return NULL;
  }
  else
    result = imgDest;

  pixelsAval1 = (int*) malloc(((2*neighborsRange)+1)*((2*neighborsRange)+1)*sizeof(int));
  pixelsAval2 = (int*) malloc(((2*neighborsRange)+1)*((2*neighborsRange)+1)*sizeof(int));
  pixelsAval3 = (int*) malloc(((2*neighborsRange)+1)*((2*neighborsRange)+1)*sizeof(int));

  // Avaliando Interior
  for (j = 1; j < height-1; j++)
  {
    for (i = 1; i < width-1; i++)
	{
	  int count = 0;
	  for (y = -neighborsRange; y <= neighborsRange; y++)
	  {
  	    for (x = -neighborsRange; x <= neighborsRange; x++)
		{
          pixelsAval1[count] = imgSrc[3*((j+y)*width + (i+x))];
          pixelsAval2[count] = imgSrc[3*((j+y)*width + (i+x))+1];
          pixelsAval3[count] = imgSrc[3*((j+y)*width + (i+x))+2];
		  count++;
		}
	  }
   	  qsort(pixelsAval1, count, sizeof(int), compare);
   	  qsort(pixelsAval2, count, sizeof(int), compare);
   	  qsort(pixelsAval3, count, sizeof(int), compare);

      result[3*(j*width + i)] = pixelsAval1[4];
      result[3*(j*width + i)+1] = pixelsAval2[4];
      result[3*(j*width + i)+2] = pixelsAval3[4];
	}
  }

  // Avaliando Bordas

  free(pixelsAval1);
  free(pixelsAval2);
  free(pixelsAval3);

  return result;
}

void medianFilterBoolMask(int width, int height, int neighbors, unsigned char* imgSrc)
{
  int size = width*height;
  int i, j, index, iaux, count;
  unsigned char *bmask;

  bmask = (unsigned char*) malloc(width*height*sizeof(unsigned char));

  for(i=0; i<size; i++)
  {
	iaux = i*3;
	if((imgSrc[iaux]==255)&&(imgSrc[iaux+1]==255)&&(imgSrc[iaux+2]==255))
	{
      bmask[i] = 1;
	} else
	{
      bmask[i] = 0;
	}
  }

  for(i=1; i<width-1; i++)
  {
    for(j=1; j<height-1; j++)
	{
	  index = (j*width+i);
	  iaux = index*3;
	  count = 0;
      if(bmask[index-width-1]) count++;
      if(bmask[index-width  ]) count++;
      if(bmask[index-width+1]) count++;
      if(bmask[index-1]) count++;
      if(bmask[index  ]) count++;
      if(bmask[index+1]) count++;
      if(bmask[index+height-1]) count++;
      if(bmask[index+height  ]) count++;
      if(bmask[index+height+1]) count++;

	  if(count > 4)
	  {
        imgSrc[iaux  ] = 255;
        imgSrc[iaux+1] = 255;
        imgSrc[iaux+2] = 255;
	  } else
	  {
        imgSrc[iaux  ] = 0;
        imgSrc[iaux+1] = 0;
        imgSrc[iaux+2] = 0;
	  }
	}
  }

  free(bmask);
}

void applyMask(int width, int height, unsigned char* imgSrc,  unsigned char* bmask)
{
  int size = width*height*3;
  int i;

  for(i=0; i<size; i++)
  {
	if(bmask[i] == 0) imgSrc[i] = 255;
  }
}