/* !!! TO CLEAN UP !!! */
/*  Last edited on 2024-12-21 14:03:42 by stolfi */
/*************************************************************************
*                                                                        *
*  Universidade Federal Fluminense                                       *
*  Mestrado em Computacao                                                *
*  Desenvolvido por: Renatha Oliva Capua                                 *
*  Orientadores: Helena Cristina da Gama Leitao                          *
*                Jorge Stolfi                                            *
*                                                                        *
*  matriz.c - Monta uma matriz em tons de cinza como representação dos   *
*  resultados do programa pre.c(preditor)                                *
*************************************************************************/

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

#include "jsfile.h"
#include <rn.h>

#include "dbd_lib.h"

void extrair_prob_exon(double *probs, int tam_probs, double gama, int logaritmica, int **m_cinza);
void extrair_prob_janela(double *probs, int tam_probs_inicio, int tam_probs, double gama, int logaritmica, int **m_cinza);

int retornar_ton_cinza(double valor, double gama, int logaritmica, double maior);

void escrever_matriz(char *nome_arq, int *vet, int tot_col, int tot_lin);

void ler_out_preditor(char *nome_arq, double **probs, int  *tam_probs);

int main(int argc, char **argv){
     int    tam_probs = 0;     /* Quantidade de elementos em probs */
     double *probs_aux = NULL; /* Vetor para guardar as probabilidades(Pr(I), Pr(E), Pr(F) e Pr(G)) das bases previstas pelo preditor */ 
     int    tot_arq;           /* Quantidade de arquivos com saidas do preditor */
     int    cnt;               
     int    *m_cinza_tupla;    /* Vetor com as cores referentes as probabilidades de cada tamanho tupla de uma determinada sequencia  */
     int    *m_cinza_janela;   /* Vetor com as cores referentes as probabilidades considerando as diferentes janelas de leitura da seq.*/
     char   nome_arq[35];

     if (argc < 3) {  
          printf ("\n use: matriz <arq-saida-preditor-1> <arq-saida-preditor-2> ... <arq-saida-preditor-n> <arq-saida>\n");
          return(-1);
     }//end if  
    
     tot_arq = argc - 2;
     for(cnt = 1; cnt <= tot_arq; cnt++){
          int pos_inicio_probs = tam_probs;

          ler_out_preditor(argv[cnt], &probs_aux, &tam_probs); 
	  fprintf(stderr, "Arq:%s\n", argv[cnt]);
	  // fprintf(stderr,"tam_probs_inicio = %d\n", pos_inicio_probs);

	  /* Matriz em tons de cinza para arquivo variando o rotulo de inicio da janela (E, F e G) */
	  extrair_prob_janela(probs_aux, pos_inicio_probs/4, (tam_probs - pos_inicio_probs)/4, 2.0, 1, &m_cinza_janela);
	  sprintf(nome_arq, "m-%s.pgm", argv[cnt]);
	  escrever_matriz(nome_arq, m_cinza_janela ,(tam_probs - pos_inicio_probs)/4 , 3);
     }

     /* Matriz em tons de cinza para todos os tamanhos de tuplas da sequencia */
     extrair_prob_exon(probs_aux, tam_probs/4 ,2.0, 1, &m_cinza_tupla);
     escrever_matriz(argv[argc-1], m_cinza_tupla , ((tam_probs/4)/ tot_arq), tot_arq);

     return(0);
}//end main


/**************************************************************************
* Procedimento que retira de probs somente a probabilidade de ser uma     *
* região codificadora(Pr(E), Pr(F) e Pr(G)).                              *
**************************************************************************/
void extrair_prob_janela(double *probs, int tam_probs_inicio, int tam_probs, double gama, int logaritmica, int **m_cinza){
     int    cnt = 0;
     int    k;
     double maior = 0;
     double menor = 255;
     double *vet;
    
     vet = rn_alloc(tam_probs*3);
     (*m_cinza) = (int *)malloc(tam_probs * 3 * sizeof(int));
    
     vet[cnt] = 0.0; /* inicializa vet */

     int ind_probs = 1;
     /* Calcula a probabilidade de ser codificadora Pr(C) = Pr(E) + Pr(F) + Pr(G) */
     for(cnt = 0; cnt < (tam_probs); cnt++) { /* Para percorrer todo o vetor probs */
          ind_probs = (cnt % 3) + 1; /* Em cada posição de probs há 4 elementos, mas preciso  de 3 (Pr(E), Pr(F) e Pr(G)), 1, 2 e 3*/
	  
          for(k = 0; k < 3; k++) {
	      if (probs[4 * (cnt + tam_probs_inicio) + ind_probs] != 0.0) {
		   vet[tam_probs * k + cnt] =  probs[4 * (cnt + tam_probs_inicio) + ind_probs];
		   
		   if (vet[tam_probs * k + cnt] < menor) { menor = vet[tam_probs * k + cnt]; }
	      }else { vet[tam_probs * k + cnt] =  -1.0; }

	      ind_probs = (ind_probs >= 3 ?  1 : ind_probs + 1);

	      if (vet[tam_probs * k + cnt] > maior) { maior = vet[tam_probs * k + cnt]; }
	  }
     }

     int cnt2 = 0;
     for (cnt = 0; cnt < (tam_probs * 3); cnt++){
       //fprintf(stderr, "%d  %lf \n", cnt2, vet[cnt]);
       cnt2 = (cnt2 == tam_probs ? 0 : cnt2 + 1);
     }

     //     fprintf(stderr, "maior:%lf, menor:%lf\n", maior, menor);

     /* Transforma as probabilidades em tons de cinza */
     for(cnt = 0; cnt < (tam_probs * 3); cnt++){
          (*m_cinza)[cnt] = 255;
	  if (vet[cnt] == -1) { (*m_cinza)[cnt] = 255; }
	  else { (*m_cinza)[cnt] = retornar_ton_cinza(vet[cnt], gama, logaritmica, maior); }
	  //	  fprintf(stderr, "%d %lf\n", cnt, (*m_cinza)[cnt]);
     }

     //     fprintf(stderr, "SAIU DE UM ARQUIVO!!!\n");
}

    
/**************************************************************************
* Procedimento que retira de probs somente a probabilidade de ser uma     *
* região codificadora.                                                    *
**************************************************************************/
void extrair_prob_exon(double *probs, int tam_probs, double gama, int logaritmica, int **m_cinza){
     int    cnt = 0;
     int    k;
     double maior = 0;
     double menor = 255;
     double soma = 0.0;
     double *vet;
    
     vet = rn_alloc(tam_probs);
     (*m_cinza) = (int *)malloc(tam_probs * sizeof(int));
    
     vet[cnt] = 0.0; /* inicializa vet */
     vet[cnt] = soma;

     /* Calcula a probabilidade de ser codificadora Pr(C) = Pr(E) + Pr(F) + Pr(G) */
     for(cnt = 0; cnt < (tam_probs); cnt++){
          for (k = 1; k < 4; k++) { soma = soma + probs[cnt * 4 + k]; }
	  
	  if (soma > maior) { maior = soma; }
    
	  /* Evita que {menor} seja igual ao valor das primeiras posições de vet que sempre é 0.0 */
	  if (soma != 0.0){ if (soma < menor) { menor = soma; }}
	  else { soma = -1; }
    
	  vet[cnt] = 0.0; /* inicializa vet */
	  vet[cnt] = soma;
	  soma = 0.0;
     }

     //     fprintf(stderr, "maior:%lf, menor:%lf\n", maior, menor);

     /* Transforma as probabilidades em tons de cinza */
     for(cnt = 0; cnt < (tam_probs); cnt++){
          (*m_cinza)[cnt] = 255;
	  if (vet[cnt] == -1) { (*m_cinza)[cnt] = 255; }
	  else { (*m_cinza)[cnt] = retornar_ton_cinza(vet[cnt], gama, logaritmica, maior); }
	  // fprintf(stderr, "%d %lf\n", cnt, (*m_cinza)[cnt]);
     }
}
    

/**************************************************************************
* Procedimento que retorna o valor correspondente a um tom de cinza.      *
* Sendo: Branco(255), menor probabilidade de ser éxon e Preto(0) a menor  *
* probabilidade de ser éxon.                                              *
**************************************************************************/    
int retornar_ton_cinza(double valor, double gama, int logaritmica, double maior){
  if (logaritmica)
    {
      double menor = 0.001*maior;
      if (valor > 0.0) { valor = log(valor/menor)/log(maior/menor); }
    }
  // Correção de escala não-linear (gama):
  if (valor > 0.0) { valor = exp(log(valor/maior)/gama); }
  // Limites:
  if (valor < 0.0) { valor = 0.0; }
  if (valor > 1.0) { valor = 1.0; }
  return (int)(valor * 255 + 0.5);
}
    
    
/**************************************************************************
* Procedimento que escreve em um arquivo a matriz em tons de cinza        *
**************************************************************************/
void escrever_matriz(char *nome_arq, int *vet, int tot_col, int tot_lin){
    FILE *pt_matriz;

    int tot_ele_col = 5;  /* Quantidade de repetições do mesmo elemento por coluna */
    int cnt_ele_col ;     /* Contador usado para controlar o número de repetições do mesmo elemento por coluna */
    int cnt_col;          /* Quantidade de colunas - é igual ao número de bases */
    
    int tot_ele_lin = 10; /* Quantidade de repetições da mesma linha */
    int cnt_ele_lin; 
    int cnt_lin;
    
    pt_matriz = open_write(nome_arq, TRUE);    
    
    //fprintf(stderr, "col = %d, lin = %d \n", tot_col * tot_ele_col, tot_lin * tot_ele_lin);
    
    fprintf(pt_matriz, "P2\n");
    fprintf(pt_matriz, "%5d %5d\n", (tot_col * tot_ele_col), (tot_lin* tot_ele_lin));
    fprintf(pt_matriz, "255\n");
    

    for(cnt_lin = 0; cnt_lin < tot_lin; cnt_lin++){  /* O número de linhas é equivalente a quantidade de arquivos */  
      for(cnt_ele_lin = 0; cnt_ele_lin < tot_ele_lin; cnt_ele_lin++){ /* cada linha é repetida um certo número de vezes */
	      for(cnt_col = 0; cnt_col < tot_col; cnt_col++){
		   for(cnt_ele_col = 0; cnt_ele_col < tot_ele_col; cnt_ele_col++){ 
		        fprintf(pt_matriz, "%d ", vet[cnt_col + (cnt_lin* tot_col)]); 		  
		   }
		  
	      }
	      fprintf(pt_matriz,"\n");
	 }
	     
    }
    
    fclose(pt_matriz);
}


/*************************************************************************
* Procedimento que lê o arquivo de saída do preditor                     *
*************************************************************************/
void ler_out_preditor(
   char *nome_arq, 
   double **probs,
   int  *tam_probs
   ){
     
     int  cnt = 0;
     int  pos = 0;
     char letra;
     char prob_aux[10];
     char *prev;
     FILE *pt_pre;
     int  na = (*tam_probs);


     prev = (char*)malloc(5 * sizeof(char));

     if ((*probs) == NULL){
          na = 100;
          (*probs) = rn_alloc(na);
	  (*tam_probs) = 0;
     }

     pt_pre = open_read(nome_arq, TRUE);
     int nl_pre = 1; /* Line number in file. */
     skip_bio_file_header(pt_pre, &nl_pre);

     fscanf(pt_pre, "%d", &pos);

     while (!feof(pt_pre)){
          if ( ((*tam_probs)+ 3) >= na){
	       na = 2 * na;
               int nr = na * sizeof(double);
	       (*probs) = realloc((*probs), nr);
               if ((*probs) == NULL) { fprintf(stderr, "Memoria Esgotada"); exit(1);}
          }

	  fscanf(pt_pre, "%c", &letra); /* Lê um espaço em branco */
	  fscanf(pt_pre, "%c", &letra); /* Lê b - uma base */

	  for (cnt = 0; cnt < 4; cnt++) { (*probs)[(*tam_probs) + cnt] = 0.0; } /* Inicializa probs */
	  for (cnt = 0; cnt < 4; cnt++) {
	       fscanf(pt_pre,"%s", prob_aux); /* Lê as probabilidades: Pr(I), Pr(E), Pr(F) e Pr(G) */
	       
	       if (prob_aux[0] == '*'){ 
		    int k = 0;
		    int tam = strlen(prob_aux);
		    for (k = 0; k < tam; k++) { prob_aux[k] = prob_aux[k+1]; } 
	       }
	      (*probs)[(*tam_probs) + cnt] = atof(prob_aux);
	      strcpy(prob_aux,"\0");
	  }

	  (*tam_probs) += 4;      

	  fscanf(pt_pre, "%s", prev); /* Lê a previsao do preditor*/

	  fscanf(pt_pre, "%s", prob_aux);
	  fscanf(pt_pre, "%s", prob_aux);
	  fscanf(pt_pre, "%s", prob_aux);
	  fscanf(pt_pre, "%s", prob_aux);
	  pos = 0;
	  fscanf(pt_pre, "%d", &pos);
	  strcpy(prob_aux, "\0");

     }
     
     (*probs) = realloc((*probs), ((*tam_probs) + 1 ) *  sizeof(double));
     (*probs)[((*tam_probs))] = -1.0;

     fclose(pt_pre);
}