/*
 *         ASCII2FITS v0.1
 *
 * Funcao:  Cria um arquivo FITS a partir de um arquivo texto com as 
 *          intensidades de cada pixel. Semelhante ao rtext do IRAF
 *
 * Uso:     basta invocar o nome do arquivo com os dados
 *
 * Depend.: bibliotecas CFITSIO 
 *
 * Autor:   Fabricio Ferrari, jan-fev/2001 
 *                            (modificacoes jan2002)
 *
 * Hist:    v0 jan-fev2001  
 *  
 * 	    v0.1 (jan2002)
 * 	    Parte do pacote (!) Sersic que projeta uma distribuicao de 
 *          brilho.
 *
 *          v0.2  (28set2002) 
 *          Saiu fora do pacote Sersic (EPPC) e adquiriu vida propria. 
 *          Usado tambem para simulacao da IFU/Eucalyptus (SOAR)
 *            
 *          v.025 (29set02)
 *          Tinha um problema na alocacao dinamica das matrizes. O CFITSIO
 *          esperava array[j][i] e estava sendo dados [i][j]. Parece que agora 
 *          esta Ok.
 *
 * FORMATO: v0.1 (ainda dependendo do Sersic - EPPC)
 *          Encontra uma linha no cabecalho do arquivo que contenha
 *          	Passos     : integral=100 projeção=dim=500 
 *          procurando por dim=500. Neste caso so aceita imagens 
 *          quadradas. Depois segue ate que encontra FIM_CABECALHO 
 *          numa linha, a partir da onde comecam os dados, dispostos 
 *          numa coluna, cada linha da imagem uma abaixo da outra.
 *
 *
 *          v0.2 
 *          Procura por um string DIMX=dx DIMY=dy no inicio do arquivo, 
 *          onde dx e dy sao as dimensoes da imagem, respectivamente. Depois 
 *          desta linha segue ate que ache FIM_CABECALHO, a partir de onde
 *          estarao os dados. Fica o FIM_CABECALHO caso seja necessario 
 *          incluir mais alguma informacao sobre o arquivo.
 *
 *
 */ 


#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "fitsio.h"


#define VERSAO 0.26
#define nrand() ((double) rand()/RAND_MAX) /* randomico ate 1     */
#define sq(x) (x*x)                       /* melhor que pow(x,2) */

void descobre_dimensao(FILE *arq_fp);
int dim[2];




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

  int status=0, i, j, k;                        /* contadores, status, dimensao        */
  char buf[255], arqin[255], arqout[255];    /* buffer, nome arq entrada/saida      */
  FILE *in_fp;                               /* Ponteiro arquivo de entrada         */  
  struct stat arqstat;                       /* estrutura com parametros de stat()  */

  double **array;                            /* array com a matriz-imagem           */
  fitsfile *fptr;                            /* File descriptor do arquivo fits     */
  long int fpixel=1, naxis=2, nelements;     /* parametros para a imagem fits       */
  long int naxes[2], exposure=1, airmass=1;  /*                                     */


  /* Advertencia */ 
  fprintf(stderr, "\n\n--==:[ Ascii2Fits conversor ]:==--\n\n" );
  if (argc < 3 ){
    printf("Use:\n\t%s <txt:vetor> <fits:imagem> \n",argv[0]);  
    exit(EXIT_FAILURE);  
  }
  

  /* copia nomes dos arquivos */
  strcpy(arqin,  argv[1]);
  strcpy(arqout, argv[2]);
  if ( ! strcmp(arqin, arqout) ) {
    printf("Arquivo de entrada e saida é o mesmo. Saindo...\n");
    exit(1);
  }


  /* Se EXISTE o arquivo de saida, REMOVE  */
  if (stat(arqout, &arqstat)==0 && S_ISREG(arqstat.st_mode)  ){
    fprintf(stderr, "removendo %s.\n", arqout);
    /* remove o arquivo  */
    if (unlink(arqout) == -1) {
      perror("unlink");
      exit(1);
    }
  }


  /* Associa descritor de arquivo */
  if ( (in_fp=fopen(arqin,"r")) == NULL ) {
    fprintf(stderr, "Arquivo %s não pode ser aberto\n", arqin);
    exit(EXIT_FAILURE);
  }
  fprintf(stderr,"convertendo %s -> %s.\n", arqin, arqout);





  descobre_dimensao(in_fp); // coloca dimensao em dim[2]
  naxes[0]=dim[0]+1;
  naxes[1]=dim[1]+1;


  /*  ALOCA DINAMICAMENTE A MATRIZ DA IMAGEM 
   *
   *  Primeiro alica os dim[1] linhas da matriz 
   *  e depois em cada apontador da linha aloca 
   *  as colunas
   *  exemplo do CFITSIO:
   *  naxes[2] = {300, 200} imagem 300x200
   *  array[200][300]       array p/ esta imagem.
   *
   */  
  array = (double **) malloc( dim[1] * sizeof(double *) );

  for(k=0; k < dim[1] ; k++){
    *(array+k)  = malloc( dim[0] * sizeof(double) );  
  }
  



  /*  Posiciona no incio do arquivo, fseek()
   *  Pula a primeira linha, fgets() e 
   *  anda ante que termine o cabecalho 
   */
  fseek(in_fp, 0, SEEK_SET );
  do {   
    fgets(buf, 255, in_fp);
  }  while ( !strstr(buf, "FIM_CABECALHO") );
  



  /* POPULA A MATRIZ DA IMAGEM */ 
  for(j=0; j < dim[1] ; j++){
    for(i=0; i < dim[0] ; i++){
      // TESTE array[j][i]=i+j;
      fscanf(in_fp, "%lf", &array[j][i]);
      printf("[%d][%d]=%f\n", i, j, array[j][i]);
    }
  }





  /* Cria o arquivo FITS de saida. */
  fits_create_file(&fptr,  arqout , &status);
  fits_create_img(fptr, DOUBLE_IMG, naxis, naxes, &status);
  fits_update_key(fptr, TLONG, "EXPTIME", &exposure, "Total Exposure Time", &status);
  fits_update_key(fptr, TLONG, "AIRMASS", &airmass, "Air Mass", &status);
  fits_report_error(stderr, status);

  fpixel = 1;
  nelements = naxes[0] * naxes[1];
  fits_write_img(fptr, TDOUBLE, fpixel, nelements, array[0], &status);
  fits_close_file(fptr, &status);
  fits_report_error(stderr, status);

  return(status);

} /* Fim MAIN  */













/*      
 *        DESCOBRE_DIM
 *
 *  Analista que abre o arquivo com a saida do eppc e 
 *  descobre a dimensao da imagem 
 */
void descobre_dimensao(FILE *arq_fp){
  

  char buf[255];
  //int dim[2];


  /* Garante que esta no comeco do arquivo */
  fseek(arq_fp, 0, SEEK_SET);

  //  fgets(buf, 255, arq_fp);
  
  do {   
    fgets(buf, 255, arq_fp);
  }  while ( !strstr(buf, "DIM") );

  /*  A linha devera esta assim:
   *
   *       ... DIMX=dx DIMY=dy ...
   * 
   *  onde dx e dy sao numeros
   *  strstr(buf,"DIMX") retorna  'DIMX=777 DIMY=888'
   *  e  strstr(strstr(buf,"DIMX"),"=") ) 
   *  coloca =777 em buf. Dai que (buf+1) é 777
  */
  strcpy( buf,  strstr( strstr(buf,"DIMX") , "=")  ) ;
  dim[0] = atoi((buf+1));

  strcpy( buf,  strstr( strstr(buf,"DIMY") , "=")  ) ;
  dim[1] = atoi((buf+1));

  // close(arq_fp);
  printf("imagem de dimensao (%i, %i)\n", dim[0], dim[1]);


  //return(dim);

}





