/* MC919 - Prof. Neucimar        */
/* Mauricio Caliggiuri Inforcati */
/* RA 981797                     */
/* 				 */
/* TP1.                 17/03/03 */

/* 2. Filtragem Gaussiana - Mascara nxn*/

#define MAX
#include <stdio.h>
#include <stdlib.h>
#include "lib.h"
#include <math.h>

void filtroGaussiano(IMAGE x, int n);

void filtroGaussiano(IMAGE x, int n)
{
  float ss = 0.0; //ss = sigma*sigma.
  int i , j  = 0; //Limites da imagem.
  int ig, jg = 0; //Limites da máscara gaussiana.
  int ic, jc = 0; //Limites da convolução.
  int divisor = 0; //divisor da máscara;
  float valor, normal = 0.0; //resultado da convolução, normalização,
  float G[n][n];

  printf("\nFiltro Gaussiano\n");
  ss = (float)(n - 1)/4; //4 define 95% de permanência dos pixels.
  printf("Sigma: %f\n", ss);
  ss = ss*ss;
  /* Criando a máscara Gaussiana [n][n]*/
  printf("Máscara de Convolução:\n");
  ig = 0;
  for (ic=-(n/2); ic<=(n/2); ic++)
  {
    jg = 0;
    for (jc=-(n/2); jc<=(n/2); jc++)
    {
      /* Valor da Função Gaussiana para este pixel */
      valor = (float)ss * exp( -((ic*ic) + (jc*jc)) / (2*ss));
      /* Normalização do valor */
      if (ic==-1 && jc==-1 && valor!=0)
        normal=fabs(1/valor);
      valor = (float)normal * valor;
      /* Arredonda para valor inteiro */
      if ( (valor - floor(valor)) > 0.5 || ( ( valor - floor(valor)) < 0 && (valor - floor(valor)) > -0.5 ) )
        valor = floor(valor) + 1;
      else
      	valor = floor(valor);
      /* Escreve a Máscara */
//      G[ig][jg] = 0;
       G[ig][jg] = valor;
      printf("%f ",G[ig][jg]);
      divisor = divisor + valor;
      jg++;
    }
    ig++;
    printf("\n");
  }
  printf("\n");

  /*Convoluindo a máscara sobre a imagem */
  for (i = (n/2); i < x->info->nr - (n/2); i++)
    for (j = (n/2); j < x->info->nc - (n/2); j++)
    {
      ig = 0;
      valor = 0;
      for (ic = -(n/2); ic <= (n/2); ic++)
      {
        jg = 0;
        for (jc = -(n/2); jc <= (n/2); jc++)
        {
          valor = valor + G[ig][jg] * x->data[i+ic][j+jc];
          jg++;
        }
        ig++;
      }
      x->data[i][j] = valor/divisor;
    }

     // x->data[i][j] = valorGaussiano(x,i,j,G);
}


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

  if (argc != 3)
    {
      printf("Uso: fgaussiano <imagem> n\n");
      printf("('n = 4*sigma+1', sigma=> define a máscara do filtro.)\n");
      exit(1);
    }

  sscanf(argv[2], "%d", &n);
  if (n <= 0)
    {
      printf("Mascara invalida.\nUtilize um numero impar.\n");
      exit(2);
    }

  x = Input_PBM(argv[1]);
  if (x == 0)
    {
      printf("Imagem invalida ('%s')\n", argv[1]);
      exit(3);
    }

  filtroGaussiano(x,n);

  Output_PBM(x, "fgaussiano.pgm");
  printf("Arquivo de saida eh 'fgaussiano.pgm'\n");
}