#include "colorir.h"

/* Funções que não estão na libdados */

/* Ler Matriz */

MatrizL *LerMatriz() 
{
  int l,c,nl,nc;
  MatrizL *m;

  fscanf(stdin,"%d %d",&nl,&nc);
  m = matlCria(nl,nc);
  for (l=0; l < m->nl; l++)
    for (c=0; c < m->nc; c++)
    fscanf(stdin,"%d",&m->info[matlInd(m,l,c)]);
  return(m);
}

/* Grava Matriz */

void GravaMatriz(MatrizL *m) 
{
  int l,c;

  fprintf(stdout,"matriz %dl x %dc:\n", m->nl, m->nc);
  for (l=0; l < m->nl; l++) {
    for (c=0; c < m->nc; c++)
      fprintf(stdout,"%2d ", m->info[matlInd(m,l,c)]);
    fprintf(stdout,"\n");
  }
}

void ImprimeFila(Fila *f)
{
  Fila *g;
  
  if (!filVazia(f)) {
    g = (f->prox)->prox;
    while(g != f) {
      fprintf(stdout,"%d ",g->info);
      g = g->prox;
    }
    fprintf(stdout,"%d\n",g->info);
  }
}

/* Le Imagem */

MatrizL *LeImagem(char *arqimg) 
{
  int l,c,nl,nc,max;
  char type[10];
  unsigned char *img;
  MatrizL *m;
  FILE *ent;
  
  /* Le imagem tipo P5 (PGM BINÁRIA) */

  ent = fopen(arqimg,"rb");
  fscanf(ent,"%s",type);
  fscanf(ent,"%d %d",&nc,&nl);
  fscanf(ent,"%d",&max);
  img = (unsigned char *) calloc(nl*nc,sizeof(unsigned char));
  fread(img,nl*nc,sizeof(unsigned char),ent);
  fclose(ent);
  
  /* copia para matriz */

  m = matlCria(nl,nc);
  for (l=0; l < m->nl; l++)
    for (c=0; c < m->nc; c++)
      m->info[matlInd(m,l,c)] = (int)img[matlInd(m,l,c)]/max;
  free(img);

  return(m);
}

/* Grava Imagem */

void GravaImagem(char *arqimg, MatrizL *m)
{
  int l,c,nl,nc,max,min,inf;
  char type[10];
  unsigned char *img;
  FILE *sai;

  /* grava imagem tipo P5 (PGM BINÁRIA) */

  if (m == NULL) {
    comAviso(AVS1, "GravaImagem");
    exit;
  }

  sai = fopen(arqimg,"w");
  if (sai == NULL) {
    printf("\nErro ao abrir o arquivo '%s'.", arqimg);
    exit(-1);
  }

  nl = m->nl;
  nc = m->nc;
  img = (unsigned char *) calloc(nl*nc,sizeof(unsigned char));

  /* calcula valor max para a matriz */
  max = min = m->info[0];
  for (l=0; l < m->nl; l++)
    for (c=0; c < m->nc; c++) {
      inf = m->info[matlInd(m,l,c)];
      if (max < inf)
	max = inf;
      else if (min > inf)
	min = inf;
    }

  /* copia da matriz (normalizado entre 0 e 255) */
  for (l=0; l < m->nl; l++)
    for (c=0; c < m->nc; c++) {
      inf = m->info[matlInd(m,l,c)];
      img[matlInd(m,l,c)] = (unsigned char) (255 * (inf-min) / (max-min));
    }

  /* Grava o cabecalho do arquivo de imagem PGM */
  max = 255;
  sprintf(type, "P5\n");
  fprintf(sai, "%s", type);
  fprintf(sai, "%d %d\n", nc, nl);
  fprintf(sai, "%d\n", max);

  /* Grava a imagem */
  if ( fwrite(img, sizeof(unsigned char), nl*nc, sai) != (size_t) nl*nc) {
    printf("\nErro na gravacao da imagem.\n");
    fclose(sai);
    exit(-1);
    }
  fprintf(sai, "%c", EOF);
  free(img);
  /* Fecha arquivo de imagem PGM */
  fclose(sai);

}


int main(int argc, char **argv) {
  
  Fila *f,*g;
  int x,i;
  char acao[10]; /* Acao a ser tomada conforme indicado na entrada */
  MatrizL *m1=NULL,*m2=NULL;
  char s[256];

  /* ------------------------------------------------------------

                  VÁLIDO APENAS PARA LINUX

     Declarações para verificação do uso da memória dinâmica.  A
     variável 'lixo' está sendo usada apenas para contornar um
     problema do funcionamento das funções da biblioteca 'malloc': a
     memória por ela apontada é desalocada logo a seguir!
     ------------------------------------------------------------ */
  
  void *lixo = malloc(1);                   /* truque: variável auxiliar */
  
  struct mallinfo info;   
  int MemDinInicial, MemDinFinal;
 
  free(lixo);                              /* truque */
  info = mallinfo();
  MemDinInicial = info.uordblks;
  
  /* ------------------------------------------------------- */


  /* Executa o teste */
  f=filCria();
  fscanf(stdin,"%s",acao);
  while(strcmp(acao,"t")!=0) { 
    switch(*acao) {
    case 'i': /* Insere elemento na fila */
      fscanf(stdin,"%d",&x);
      filInsere(&f,x);
      ImprimeFila(f);
      break;
    case 'r': /* Remove elemento da fila */
      filRemove(&f);
      ImprimeFila(f);
      break;
    case 'b': /* Busca elemento na fila */
      fscanf(stdin,"%d",&x);
      g=filBusca(f,x);
      if (g != NULL) 
	fprintf(stdout,"%d\n",g->info);
      else
	fprintf(stdout,"Não encontrado\n");
      break;
    case 'l': /* Ler matriz */
      if (m1 != NULL) matlDestroi(m1);
      m1 = LerMatriz();
      break;
    case 'g': /* Grava matriz */
      fscanf(stdin,"%d",&i);
      if (i == 1)
	{
	  if (m1==NULL) printf ("Matriz origem nao criada ainda\n");
	  else GravaMatriz(m1);
	}
      else if (i == 2)
        {
	  if (m2==NULL) printf ("Matriz destino nao criada ainda\n");
	  else GravaMatriz(m2);
	}
      else
        printf("Indice Invalido.\n");
      break;
    case 'L': /* Le imagem do arquivo para matriz m1 */
      fscanf(stdin,"%s",s);
      if (m1 != NULL) matlDestroi(m1);
      m1 = LeImagem(s);
      break;
    case 'G': /* Grava martiz m2 para um arquivo de imagem */
      if (m2 != NULL) {
	fscanf(stdin,"%s",s);
	GravaImagem(s, m2);
      }
      break;
    case 'c': /* Colore imagem em m1 gerando m2 */
      if (m1 != NULL) { 
	if (m2 != NULL) matlDestroi(m2);
	m2 = Colore(m1);
      }
      break;
    default:
      fprintf(stderr,"Ação %s inválida\n",acao);
      exit(-1);
    }
    fscanf(stdin,"%s",acao);
  }

  filDestroi(&f);
  if (m1 != NULL) matlDestroi(m1);
  if (m2 != NULL) matlDestroi(m2);

  /* ------------------------------------------------------------
     Verificação do uso da memória dinâmica.
     ------------------------------------------------------------ */

  info = mallinfo();
  MemDinFinal = info.uordblks;
  if (MemDinInicial!=MemDinFinal)
    printf("\n\nMemória dinâmica não foi totalmente liberada (%d,%d)\n",
                      MemDinInicial,MemDinFinal);

  /* ------------------------------------------------------------ */

  printf("\n\nFim da execução.\n\n");
  
  return 0;

} /* testpilha */




/* author: Gustavo Sverzut Barbieri (http://www.gustavobarbieri.com.br) */