#define MAX
#include "lib.h"
#include <math.h>
#define IMAX 40

//Programa realiza aberturas sucessivas até ocorrer filtragem completa ((PixelsOriginais - PixelsFiltrados)/PixelsOriginais = 0).
//Inversão deve deve ser feita. Caso contrário o DSM após a abertura será sempre maior que 1.

unsigned long int numPixels = 0;

struct matriz {
           unsigned char posicao[200][200];           /* Pixel values */
	   int i,j;

};

IMAGE main_image = 0;
IMAGE erodido = 0;
IMAGE aberto = 0;


int vezes = 0;

typedef struct matriz MATRIZ;
typedef MATRIZ MATRIZES[IMAX];
//typedef struct matrizes MATRIZES;

   /*
IMAGE Inverte (IMAGE x)
{
	int i,j ;

	printf ("Invertendo Imagem...  \n\n");

	for (i= 0; i< x->info->nr-1; i++)
	  for (j= 0; j < x->info->nc-1; j++)
	    x->data[i][j] = 255- x->data[i][j] ;
	return x;
}
     */

void Imprime(IMAGE m)
{
 int i,j, maxi,maxj;
 maxi = m->info->nr-1;
 maxj = m->info->nc-1;
 for(i=0;i<maxi;i++)
 {
 	for(j=0;j<maxj;j++)
	{
	   printf("%d ",m -> data[i][j]);
 	}
	printf("LINHA\n");
 }
}

float EncontraDSM(IMAGE m)
{
  int maxj,maxi,i,j = 0;
  unsigned long int numPixelsFiltrado = 0;
  float DSM = 0;

  maxi = m->info->nr-1;
  maxj = m->info->nc-1;

  for(i=0;i<maxi;i++)
  {
   for(j=0;j<maxj;j++)
   {
     numPixelsFiltrado = numPixelsFiltrado + m->data[i][j];
   }
  }
  //printf("Número de Pixels: %d \n\n",numPixelsFiltrado);
  DSM = ((float)numPixels - (float)numPixelsFiltrado)/(float)numPixels;
  //printf("Número de Pixels: %f \n\n",(float)numPixels);
  //printf("Número de Pixels: %f \n\n",(float)numPixelsFiltrado);

  return DSM;
}


MATRIZ TransladaMatriz(int linha, int coluna, int k)
{

 int i,j = 0;
 MATRIZ m;

 for(i=0;i<main_image->info->nr+IMAX;i++)
   {
   for(j=0;j<main_image->info->nc+IMAX;j++)
     {
     m.posicao[i][j] = -1;
     }
   }

 for(i=0;i<main_image->info->nr;i++)
   {
   for(j=0;j<main_image->info->nc;j++)
     {
     if (i < main_image->info->nr)
     if (j < main_image->info->nc)
     	m.posicao[i+linha][j+coluna] = main_image->data[i][j]+k;
     //printf("%d ", matriz.posicao[i+linha][j+coluna]);
     }
     //printf("LINHA\n");
   }
 return m;
}




void Erode(int tamEE, MATRIZES *matrizes)
{
int i, j, M, N, linIm, colIm, lin, col, num = 0, min = 0;
MATRIZ a;

//printf("Erodindo... \n\n");
copy(&erodido, main_image);

linIm = erodido->info->nr-1;
colIm = erodido->info->nc-1;

// Erosão
for(lin=0;lin<linIm;lin++)
   {
   //printf("Linha Erodido: %d \n",lin);
   for(col=0;col<colIm;col++)
      {
       min = 0;
       //printf("%d ",main_image->data[lin][col]);

       for(i=0;i<=tamEE;i++)
         {
          for(j=0;j<=tamEE;j++)
	  {
	    a = matrizes[i][j];
	    num = a.posicao[lin][col];
	    if (num > min){
	      min = num;
	    }
	  }
	 }
       erodido->data[lin][col] = min;
       }
	      //printf("NOVALINHA\n");
  }

Output_PBM (erodido, "ResultadoErodidoAberto.pgm");
//printf ("Arquivo de saída: 'ResultadoErodidoAberto.pgm'\n\n");
}



void Dilata(int tamEE, MATRIZES *matrizes)
{
int i, j, M, N, linIm, colIm, lin, col, num = 0, max = 0;
MATRIZ a;



vezes = vezes + 1;
aberto = Input_PBM ("ResultadoErodidoAberto.pgm");

//printf("Dilatando... \n\n");

linIm = aberto->info->nr-1;
colIm = aberto->info->nc-1;

// Dilatação
for(lin=0;lin<linIm;lin++)
   {
   //printf("Linha aberto: %d \n",lin);
   for(col=0;col<colIm;col++)
      {
       max = 1000;
       //printf("%d ",main_image->data[lin][col]);

       for(i=0;i<=tamEE;i++)
         {
          for(j=0;j<=tamEE;j++)
	  {
	    a = matrizes[i][j];
	    num = a.posicao[lin][col];
	    if (num < max){
	      max = num;
	    }
	  }
	 }
       aberto->data[lin][col] = max;
       }
  }

switch(vezes){
   case 1:
     Output_PBM (aberto, "ResultadoAberto1.pgm");
     ////printf ("Arquivo de saída: 'ResultadoAberto1.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 2:
     Output_PBM (aberto, "ResultadoAberto2.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto2.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 3:
     Output_PBM (aberto, "ResultadoAberto3.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto3.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 4:
     Output_PBM (aberto, "ResultadoAberto4.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto4.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 5:
     Output_PBM (aberto, "ResultadoAberto5.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto5.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 6:
     Output_PBM (aberto, "ResultadoAberto6.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto6.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 7:
     Output_PBM (aberto, "ResultadoAberto7.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto7.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 8:
     Output_PBM (aberto, "ResultadoAberto8.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto8.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 9:
     Output_PBM (aberto, "ResultadoAberto9.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto9.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 10:
     Output_PBM (aberto, "ResultadoAberto10.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto10.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 11:
     Output_PBM (aberto, "ResultadoAberto11.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto11.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 12:
     Output_PBM (aberto, "ResultadoAberto12.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto12.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 13:
     Output_PBM (aberto, "ResultadoAberto13.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto13.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 14:
     Output_PBM (aberto, "ResultadoAberto14.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto14.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 15:
     Output_PBM (aberto, "ResultadoAberto15.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto15.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 16:
     Output_PBM (aberto, "ResultadoAberto16.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto16.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 17:
     Output_PBM (aberto, "ResultadoAberto17.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto17.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 18:
     Output_PBM (aberto, "ResultadoAberto18.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto18.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 19:
     Output_PBM (aberto, "ResultadoAberto19.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto19.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 20:
     Output_PBM (aberto, "ResultadoAberto20.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto20.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 21:
     Output_PBM (aberto, "ResultadoAberto21.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto21.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 22:
     Output_PBM (aberto, "ResultadoAberto22.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto22.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 23:
     Output_PBM (aberto, "ResultadoAberto23.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto23.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 24:
     Output_PBM (aberto, "ResultadoAberto24.pgm");
     //printf ("Arquivo de saída: 'ResultadoAberto24.pgm'\n\n");
     //printf ("---------------------------------------------------------------\n\n\n");
     break;
   case 25:
     Output_PBM (aberto, "ResultadoAberto25.pgm");
     break;
   case 26:
     Output_PBM (aberto, "ResultadoAberto26.pgm");
     break;
   case 27:
     Output_PBM (aberto, "ResultadoAberto27.pgm");
     break;
   case 28:
     Output_PBM (aberto, "ResultadoAberto28.pgm");
     break;
   case 29:
     Output_PBM (aberto, "ResultadoAberto29.pgm");
     break;
   case 30:
     Output_PBM (aberto, "ResultadoAberto30.pgm");
     break;
   case 31:
     Output_PBM (aberto, "ResultadoAberto31.pgm");
     break;
   case 32:
     Output_PBM (aberto, "ResultadoAberto32.pgm");
     break;
   case 33:
     Output_PBM (aberto, "ResultadoAberto33.pgm");
     break;
   case 34:
     Output_PBM (aberto, "ResultadoAberto34.pgm");
     break;
   case 35:
     Output_PBM (aberto, "ResultadoAberto35.pgm");
     break;
   case 36:
     Output_PBM (aberto, "ResultadoAberto36.pgm");
     break;
   case 37:
     Output_PBM (aberto, "ResultadoAberto37.pgm");
     break;
   case 38:
     Output_PBM (aberto, "ResultadoAberto38.pgm");
     break;
   case 39:
     Output_PBM (aberto, "ResultadoAberto39.pgm");
     break;
   case 40:
     Output_PBM (aberto, "ResultadoAberto40.pgm");
     break;
   }
}




int main (int argc, char *argv[])
{

MATRIZES *matrizes;
int i, j, M, N, linIm, colIm, tamEE, lin, col, quant = 0, num = 0, max = 0;
int EE[IMAX][IMAX];
float DSM = 0;

if (argc < 2)
{
printf ("Uso: abertura <image> \n");
exit (1);
}

main_image = Input_PBM (argv[1]);
if (main_image == 0)
{
 printf ("Entre com uma imagem! ('%s')\n", argv[1]);
 exit (2);
}

linIm = main_image->info->nr-1;
colIm = main_image->info->nc-1;

//printf ("-----------------------  \n");
//printf ("Linhas da imagem: %d \n", linIm);
//printf ("Colunas da imagem: %d \n", colIm);
//printf ("-----------------------  \n");


matrizes = (MATRIZES *) malloc(sizeof(MATRIZES)*IMAX);
//invertidoTemp = Inverte(main_imageTemp);

//Imprime(main_image);

//printf("------------------------------------------------------------ \n\n\n");
//Imprime(invertido);



//printf ("Contando Pixels...  \n\n");
for(i=0;i<linIm;i++)
  {
   for(j=0;j<colIm;j++)
   {
     numPixels = numPixels + main_image->data[i][j];
   }
  }
printf("Número de Pixels: %d \n",numPixels);
printf("%s\t",argv[1]);
//DSM = Tamanho da distribuição normalizada. Quando for 1, tudo foi filtrado.
tamEE = 1;
while (tamEE<25){

	for(i=0;i<=tamEE;i++)              //Inicializa elemento estruturante
	{
		for(j=0;j<=tamEE;j++)
		{
		EE[i][j] = 1;
		}
	}
	//printf("Executando operação para elemento estruturante de tamanho: %d \n\n",tamEE);

	//  Cria lista de Matrizes Transladadas. Matriz na posição i,j conterá uma estrutura com uma matriz
	//transladada de acordo com os parâmetros i,j.

	for(i=0;i<=tamEE;i++)
	{
		for(j=0;j<=tamEE;j++)
		{
                matrizes[i][j] = TransladaMatriz(i,j,EE[i][j]);
		//imprime(Matriz[i][j],main_image->info->nr+30,main_image->info->nc+30);
		quant = quant + 1;

		}
	}

	//printf("Fez %d matrizes transladadas \n\n", quant);

	Erode(tamEE,matrizes);

	Dilata(tamEE,matrizes);

	tamEE++;

	//printf("Contando Pixels da Imagem filtrada... \n\n", quant);

	//main_imageTemp = Input_PBM ("ResultadoAberto.pgm");

	//invertido = Inverte(main_image);

	DSM = EncontraDSM(aberto);

	//main_image = Inverte(invertido);

	printf("%f\t", DSM);
	fflush(NULL);
}
}