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


//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.
//escreve dados importantes para arquivo


unsigned long int numPixels = 0;

const int SIZE = 30;

const int TRANSLADADAS = 20;

const float limiteDelta = 0.02;


struct matrizes {
           unsigned char posicao[300][300];           /* Pixel values */
	   int i,j;
};

struct dados {
           char nomeImagem[20];           /* Pixel values */
	   float valores[100];
	   int comprimento;
};
IMAGE main_image = 0;



int vezes = 0;
int registros = 0;

char nomeArq[30];

typedef struct matrizes MATRIZES;
typedef struct dados DADOS;
//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;
}


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

 int i,j = 0;
 MATRIZES matriz;

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




void Erode(int tamEE, MATRIZES Matriz[TRANSLADADAS][TRANSLADADAS])
{
int i, j, M, N, linIm, colIm, lin, col, num = 0, max = 0, impressão = 0;
MATRIZES a;
char nomeArqInterno[80] = "Erodido";

printf("Erodindo...\n");

linIm = main_image->info->nr-1;
colIm = main_image->info->nc-1;
// Erosão
for(lin=0;lin<linIm;lin++)
   {
   impressão++;
   if (impressão == 25)
   {
   printf("..................................................\n",lin);
   impressão = 0;
   }
   //printf("Erosão Linha: %d\n",lin);
   for(col=0;col<colIm;col++)
      {
       max = 0;
       //printf("%d ",main_image->data[lin][col]);

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

strncat(nomeArqInterno,nomeArq,30);

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



void Dilata(int tamEE, MATRIZES Matriz[TRANSLADADAS][TRANSLADADAS])
{
int i, j, M, N, linIm, colIm, lin, col, num = 0, min = 0, impressão = 0;
MATRIZES a;
char str[5];
char nomeArqInterno[80] = "/home/marcelo/mc919/TPs/TP2/resultados/";
char nomeArqInterno2[80] = "Erodido";

vezes = vezes + 1;
strncat(nomeArqInterno2,nomeArq,30);
main_image = Input_PBM (nomeArqInterno2);

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

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

// Dilatação
for(lin=0;lin<linIm;lin++)
   {
   impressão++;
   if (impressão ==25)
   {
   printf("..................................................\n",lin);
   impressão = 0;
   }
   for(col=0;col<colIm;col++)
      {
       min = 1000;
       //printf("%d ",main_image->data[lin][col]);

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

printf("\n\n");
gcvt(vezes, 3, str);

strncat(nomeArqInterno,nomeArq,30);

strncat(nomeArqInterno,str,30);

Output_PBM (main_image, nomeArqInterno);
//printf (nomeArqInterno);
//printf ("---------------------------------------------------------------\n\n\n");

}


void SalvaDados(DADOS d, int L)
{
FILE *fp, *fpE;
int i;
char str[10];

printf("Salvando Dados... \n\n");
fp = fopen("TEXTO","a+");
fputs("\n", fp);

fputs(d.nomeImagem, fp);
fputs(" ", fp);

for(i=1;i<=L;i++)
{
   gcvt(d.valores[i], 4, str);
   fputs(str, fp);
   fputs(" ", fp);
}
fputs("\n", fp);
fclose(fp);


fpE = fopen("BINÁRIO","a+b");
fwrite(&d, sizeof(struct dados),1,fpE);
fclose(fpE);

}



DADOS EncontraGranulometria(char caminho[50],int escreve)
{

MATRIZES Matriz[TRANSLADADAS][TRANSLADADAS];
int i, j, M, N, linIm, colIm, tamEE, lin, col, quant = 0, num = 0, max = 0;
int EE[30][30];
float DSM = 0, Delta=1;
IMAGE invertido = 0, invertidoTemp = 0;
IMAGE main_imageTemp=0;
DADOS d;

printf("*********************Granulometria********************* \n");


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

strcpy(d.nomeImagem, caminho);
strcpy(nomeArq, caminho);

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");


//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 ",numPixels);
//DSM = Tamanho da distribuição normalizada. Quando for 1, tudo foi filtrado.
tamEE = 1;
while ((DSM<0.9)&&(Delta>limiteDelta)){

	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.

	quant = 0;
	for(i=0;i<=tamEE;i++)
	{
		for(j=0;j<=tamEE;j++)
		{
                Matriz[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,Matriz);

	Dilata(tamEE,Matriz);



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

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

	//invertido = Inverte(main_image);

	Delta = DSM;
	DSM = EncontraDSM(main_image);

	d.valores[tamEE] = DSM;

	//main_image = Inverte(invertido);


	printf("DSM: %f \n\n", DSM);

        Delta = DSM - Delta;
	printf("Delta: %f \n\n", Delta);

	d.comprimento = tamEE;

	tamEE++;
}

if (escreve){
  SalvaDados(d,tamEE-1);
  }
return d;
}

float CalculaS(DADOS modelo, DADOS armazenado, int duplo)
{
int i, L=0;
float temp=0,S=0;

L = modelo.comprimento;

if (!duplo){
   for(i=0;i<L;i++)
   {
   S = S + modelo.valores[i];
   }
   //printf("Entrou S1 %f \n\n",S);
}

if (duplo){
   for(i=0;i<L;i++)
   {
   temp = modelo.valores[i]*armazenado.valores[i];
   //printf("modelo armazenado temp %f %f %f \n\n",modelo.valores[i],armazenado.valores[i],temp);
   S = S + temp;
   }
   //printf("Entrou S11 %f \n\n",S);
}

return S;
}


float CalculaCorrelacao(DADOS modelo, DADOS armazenado)
{
float S1 = 0, S2 = 0, S11 = 0, S22 = 0, S12 = 0, correlacao = 0;
int L = 0;

L = modelo.comprimento;

S1 = CalculaS(modelo, modelo, 0);
S2 = CalculaS(armazenado, armazenado, 0);
S11 = CalculaS(modelo, modelo, 1);
S22 = CalculaS(armazenado, armazenado, 1);
S12 = CalculaS(modelo, armazenado, 1);

correlacao = (L*S12-S1*S2)/sqrt((L*S11 - S1*S1)*(L*S22-S2*S2));

return correlacao;
}



void SalvaDadosCorrelacao(float correlacao[SIZE], DADOS modelo, DADOS lista[SIZE])
{
FILE *fp;
int i;
char str[10];
int L = 0;

L = modelo.comprimento;

printf("Salvando Dados de correlação... \n\n");
fp = fopen("CORRELAÇÃO","a+");
fputs("\n", fp);

for(i=0;i<registros-1;i++)
{
   fputs(modelo.nomeImagem, fp);
   fputs(" ", fp);
   fputs(lista[i].nomeImagem, fp);
   fputs(" ", fp);
   gcvt(correlacao[i], 4, str);
   fputs(str, fp);
   fputs(" ", fp);
   fputs("\n", fp);
}
fclose(fp);
}

void EncontraMelhorTextura(float correlacao[SIZE], DADOS lista[SIZE], int comprimento)
{
int i = 0;
float Delta = 0, menorDelta = 10;
int menor = 0;
for(i=0;i<registros;i++)
   {
     if (lista[i].comprimento == comprimento)
      {
       if (correlacao[i]<1) Delta = (1 - correlacao[i]);
        else Delta = (correlacao[i] -1);

       if (Delta<menorDelta)
       {
        menor = i;
        menorDelta = Delta;
       }
      }
   }
if (menorDelta==0) printf("A textura de entrada é equivalente a: %s \n\n",lista[menor].nomeImagem);
  else printf("A textura de entrada mais se aproxima de: %s \n\n", lista[menor].nomeImagem);
}



void Analise(char ArquivoModelo[80])
{
FILE *fp;
int i=0;
DADOS d,modelo;
DADOS lista[SIZE];
float correlacao[SIZE];


printf("*********************Análise*********************\n");

//Carrega Arquivo Binário com Banco de Dados
if((fp = fopen("BINÁRIO","rb")) == NULL)
  {
  printf("Arquivo Não Encontrado! \n");
  return;
  }
printf("Abriu Arquivo! \n\n");


//Carrega estruturas do banco de dados
do
{
   fread(&d, sizeof(struct dados),1,fp);
   lista[registros] = d;
   registros++;
   printf("Carregou Registro %s \n\n",d.nomeImagem);
}while ((!feof(fp))&&(i<SIZE));
fclose(fp);



//Faz Análise granulométrica da imagem-modelo
modelo = EncontraGranulometria(ArquivoModelo,0);

for(i=0;i<registros-1;i++)  //Número de registros
   {
   correlacao[i] = CalculaCorrelacao(modelo,lista[i]);
   printf("Correlação %f \n",correlacao[i]);
   }

SalvaDadosCorrelacao(correlacao, modelo, lista);

EncontraMelhorTextura(correlacao, lista, modelo.comprimento);
}


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

if (argc < 3)
{
printf ("Uso: AberturaAnalise <image> <operação> (0 = Análise; 1 = Acrescenta no BD) \n");
exit (1);
}

if (atoi(argv[2]) == 1){
   EncontraGranulometria(argv[1],1);
}
else if (atoi(argv[2]) == 0){
   Analise(argv[1]);
}
}