IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 7054


Ignore:
Timestamp:
May 3, 2006, 12:01:09 PM (20 years ago)
Author:
eugene
Message:

converted fits_ to gfits_

Location:
trunk/Ohana/src/libfits
Files:
49 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/libfits/doc/ChangeLog.txt

    r5928 r7054  
     1
     2- libfits 1.6
     3  * in order to allow compliation with cfitsio programs, I have changed the
     4    entire namespace to 'gfits' from 'fits'  (actually, only fits_copy_header
     5    was conflicting, but it is better to have a sufficiently different namespace). 
     6    All ohana programs need to migrate to the new version of libfits.
    17
    28- libfits 1.5

  • trunk/Ohana/src/libfits/doc/sample.c

    r7039 r7054  
    2525
    2626  /* create primary header */
    27   fits_init_header (&header);    header.extend = TRUE;
    28   fits_create_header (&header);
    29   fits_create_matrix (&header, &matrix);
    30   fits_print (&header, "NEXTEND", "%d", 1, 2);
     27  gfits_init_header (&header);    header.extend = TRUE;
     28  gfits_create_header (&header);
     29  gfits_create_matrix (&header, &matrix);
     30  gfits_print (&header, "NEXTEND", "%d", 1, 2);
    3131
    3232  /* define bintable header & layout */
    33   fits_create_table_header (&theader1, "BINTABLE", "ZERO_POINTS");
     33  gfits_create_table_header (&theader1, "BINTABLE", "ZERO_POINTS");
    3434
    35   fits_define_bintable_column (&theader1, "E", "ZP_OBS", "measured zero point", "mag", 1.0, 0.0);
    36   fits_define_bintable_column (&theader1, "E", "ZP_REF", "measured zero point", "mag", 1.0, 0.0);
    37   fits_define_bintable_column (&theader1, "J", "TIME",   "time of data", "seconds since Jan 1, 1970 UT", 1.0, 0.0);
    38   fits_define_bintable_column (&theader1, "8A", "TCHAR",   "time of data", "seconds since Jan 1, 1970 UT", 1.0, 0.0);
     35  gfits_define_bintable_column (&theader1, "E", "ZP_OBS", "measured zero point", "mag", 1.0, 0.0);
     36  gfits_define_bintable_column (&theader1, "E", "ZP_REF", "measured zero point", "mag", 1.0, 0.0);
     37  gfits_define_bintable_column (&theader1, "J", "TIME",   "time of data", "seconds since Jan 1, 1970 UT", 1.0, 0.0);
     38  gfits_define_bintable_column (&theader1, "8A", "TCHAR",   "time of data", "seconds since Jan 1, 1970 UT", 1.0, 0.0);
    3939
    4040  /* create table, add data values */
    41   fits_create_table (&theader1, &table1);
     41  gfits_create_table (&theader1, &table1);
    4242
    4343  /* set table column based on array, extend NAXIS2 as needed/appropriate */
    44   fits_set_bintable_column (&theader1, &table1, "ZP_OBS", zpobs, Nrow);
    45   fits_set_bintable_column (&theader1, &table1, "ZP_REF", zpref, Nrow);
    46   fits_set_bintable_column (&theader1, &table1, "TIME",   time,  Nrow);
    47   fits_set_bintable_column (&theader1, &table1, "TCHAR",  tchar,  Nrow);
     44  gfits_set_bintable_column (&theader1, &table1, "ZP_OBS", zpobs, Nrow);
     45  gfits_set_bintable_column (&theader1, &table1, "ZP_REF", zpref, Nrow);
     46  gfits_set_bintable_column (&theader1, &table1, "TIME",   time,  Nrow);
     47  gfits_set_bintable_column (&theader1, &table1, "TCHAR",  tchar,  Nrow);
    4848
    4949  /* define ASCII table header */
    50   fits_create_table_header (&theader2, "TABLE", "ASCII_PTS");
     50  gfits_create_table_header (&theader2, "TABLE", "ASCII_PTS");
    5151
    52   fits_define_table_column (&theader2, "F5.2", "ZP_OBS", "measured zero point", "mag");
    53   fits_define_table_column (&theader2, "F5.2", "ZP_REF", "measured zero point", "mag");
    54   fits_define_table_column (&theader2, "I8", "TIME",    "time of data", "seconds");
    55   fits_define_table_column (&theader2, "A8", "TCHAR",   "time of data", "YYYYMMDD");
     52  gfits_define_table_column (&theader2, "F5.2", "ZP_OBS", "measured zero point", "mag");
     53  gfits_define_table_column (&theader2, "F5.2", "ZP_REF", "measured zero point", "mag");
     54  gfits_define_table_column (&theader2, "I8", "TIME",    "time of data", "seconds");
     55  gfits_define_table_column (&theader2, "A8", "TCHAR",   "time of data", "YYYYMMDD");
    5656
    5757  /* create table, add data values */
    58   fits_create_table (&theader2, &table2);
     58  gfits_create_table (&theader2, &table2);
    5959
    60   fits_set_table_column (&theader2, &table2, "ZP_OBS", zpobs, Nrow);
    61   fits_set_table_column (&theader2, &table2, "ZP_REF", zpref, Nrow);
    62   fits_set_table_column (&theader2, &table2, "TIME",   time,  Nrow);
    63   fits_set_table_column (&theader2, &table2, "TCHAR",  tchar, Nrow);
     60  gfits_set_table_column (&theader2, &table2, "ZP_OBS", zpobs, Nrow);
     61  gfits_set_table_column (&theader2, &table2, "ZP_REF", zpref, Nrow);
     62  gfits_set_table_column (&theader2, &table2, "TIME",   time,  Nrow);
     63  gfits_set_table_column (&theader2, &table2, "TCHAR",  tchar, Nrow);
    6464
    6565  /* write header, matrix, table1, table2 */
    66   fits_write_header  (filename, &header);
    67   fits_write_matrix  (filename, &matrix);
    68   fits_write_Theader (filename, &theader1);
    69   fits_write_table   (filename, &table1);
    70   fits_write_Theader (filename, &theader2);
    71   fits_write_table   (filename, &table2);
     66  gfits_write_header  (filename, &header);
     67  gfits_write_matrix  (filename, &matrix);
     68  gfits_write_Theader (filename, &theader1);
     69  gfits_write_table   (filename, &table1);
     70  gfits_write_Theader (filename, &theader2);
     71  gfits_write_table   (filename, &table2);
    7272
    7373}

  • trunk/Ohana/src/libfits/doc/sample2.c

    r7039 r7054  
    1919
    2020  strcpy (filename, "test.fits");
    21   fits_read_header  (filename, &header);
    22   fits_read_matrix  (filename, &matrix);
    23   fits_read_ftable  (filename, &table1, "ZERO_POINTS");
    24   fits_read_ftable  (filename, &table2, "ASCII_PTS");
     21  gfits_read_header  (filename, &header);
     22  gfits_read_matrix  (filename, &matrix);
     23  gfits_read_ftable  (filename, &table1, "ZERO_POINTS");
     24  gfits_read_ftable  (filename, &table2, "ASCII_PTS");
    2525 
    2626  /* set table column based on array, extend NAXIS2 as needed/appropriate */
    27   fits_get_bintable_column (&theader1, &table1, "ZP_OBS", &zpobs);
    28   fits_get_bintable_column (&theader1, &table1, "ZP_REF", &zpref);
    29   fits_get_bintable_column (&theader1, &table1, "TIME",   &time);
    30   fits_get_bintable_column (&theader1, &table1, "TCHAR",  &tchar);
    31   fits_scan (&theader1, "NAXIS2", "%d", 1, &Nrow);
     27  gfits_get_bintable_column (&theader1, &table1, "ZP_OBS", &zpobs);
     28  gfits_get_bintable_column (&theader1, &table1, "ZP_REF", &zpref);
     29  gfits_get_bintable_column (&theader1, &table1, "TIME",   &time);
     30  gfits_get_bintable_column (&theader1, &table1, "TCHAR",  &tchar);
     31  gfits_scan (&theader1, "NAXIS2", "%d", 1, &Nrow);
    3232
    3333  for (i = 0; i < Nrow; i++) {
    … …  
    3838
    3939  /* set table column based on array, extend NAXIS2 as needed/appropriate */
    40   fits_get_table_column (&theader2, &table2, "ZP_OBS", &zpobs);
    41   fits_get_table_column (&theader2, &table2, "ZP_REF", &zpref);
    42   fits_get_table_column (&theader2, &table2, "TIME",   &time);
    43   fits_get_table_column (&theader2, &table2, "TCHAR",  &tchar);
    44   fits_scan (&theader2, "NAXIS2", "%d", 1, &Nrow);
     40  gfits_get_table_column (&theader2, &table2, "ZP_OBS", &zpobs);
     41  gfits_get_table_column (&theader2, &table2, "ZP_REF", &zpref);
     42  gfits_get_table_column (&theader2, &table2, "TIME",   &time);
     43  gfits_get_table_column (&theader2, &table2, "TCHAR",  &tchar);
     44  gfits_scan (&theader2, "NAXIS2", "%d", 1, &Nrow);
    4545
    4646  for (i = 0; i < Nrow; i++) {
    … …  
    5454
    5555/*
    56   fits_set_table_column (&theader2, &table2, "ZP_OBS", zpobs, Nrow);
    57   fits_set_table_column (&theader2, &table2, "ZP_REF", zpref, Nrow);
    58   fits_set_table_column (&theader2, &table2, "TIME",   time,  Nrow);
    59   fits_set_table_column (&theader2, &table2, "TCHAR",  tchar, Nrow);
     56  gfits_set_table_column (&theader2, &table2, "ZP_OBS", zpobs, Nrow);
     57  gfits_set_table_column (&theader2, &table2, "ZP_REF", zpref, Nrow);
     58  gfits_set_table_column (&theader2, &table2, "TIME",   time,  Nrow);
     59  gfits_set_table_column (&theader2, &table2, "TCHAR",  tchar, Nrow);
    6060*/

  • trunk/Ohana/src/libfits/header/F_H_field.c

    r7039 r7054  
    33
    44/*********************** fits header field ****************************/
    5 char *fits_header_field (Header *header, char *field, int N) {
     5char *gfits_header_field (Header *header, char *field, int N) {
    66
    77  char *buf;

  • trunk/Ohana/src/libfits/header/F_create_H.c

    r7039 r7054  
    44
    55/******************** fits create header ***********************************/
    6 int fits_create_header (Header *header) {
     6int gfits_create_header (Header *header) {
    77
    88  int i;
    … …  
    1717  strncpy (header[0].buffer, "END", 3);
    1818
    19   fits_modify (header, "SIMPLE", "%t", 1, header[0].simple);
    20   fits_modify (header, "BITPIX", "%d", 1, header[0].bitpix);
    21   fits_modify (header, "NAXIS",  "%d", 1, header[0].Naxes);
     19  gfits_modify (header, "SIMPLE", "%t", 1, header[0].simple);
     20  gfits_modify (header, "BITPIX", "%d", 1, header[0].bitpix);
     21  gfits_modify (header, "NAXIS",  "%d", 1, header[0].Naxes);
    2222                                       
    2323  for (i = 0; i < header[0].Naxes; i++) {
    2424    sprintf (axis, "NAXIS%d", i + 1);
    25     fits_modify (header,  axis, "%d", 1, header[0].Naxis[i]);
     25    gfits_modify (header,  axis, "%d", 1, header[0].Naxis[i]);
    2626  }
    2727
    2828  /* PCOUNT & GCOUNT are not implemented, but they are required to be here */
    29   fits_modify (header, "PCOUNT", "%d", 1, 0);
    30   fits_modify (header, "GCOUNT", "%d", 1, 1);
    31   fits_modify (header, "BSCALE", "%lf", 1, header[0].bscale);
    32   fits_modify (header, "BZERO",  "%lf", 1, header[0].bzero);
    33   fits_modify (header, "EXTEND", "%t",  1, header[0].extend);
     29  gfits_modify (header, "PCOUNT", "%d", 1, 0);
     30  gfits_modify (header, "GCOUNT", "%d", 1, 1);
     31  gfits_modify (header, "BSCALE", "%lf", 1, header[0].bscale);
     32  gfits_modify (header, "BZERO",  "%lf", 1, header[0].bzero);
     33  gfits_modify (header, "EXTEND", "%t",  1, header[0].extend);
    3434  return (TRUE);
    3535

  • trunk/Ohana/src/libfits/header/F_delete.c

    r7039 r7054  
    33
    44/*********************** fits delete ****************************/
    5 int fits_delete (Header *header, char *field, int N) {
     5int gfits_delete (Header *header, char *field, int N) {
    66 
    77  int i, Nbytes;
    88  char *p1, *p2;
    99 
    10   p1 = fits_header_field (header, field, N);
     10  p1 = gfits_header_field (header, field, N);
    1111  if (p1 == NULL) return (TRUE);
    1212
    13   p2 = fits_header_field (header, "END", 1);
     13  p2 = gfits_header_field (header, "END", 1);
    1414  if (p2 == NULL) return (FALSE);
    1515
    … …  
    2121    *(p2 + i) = ' ';
    2222
    23   p2 = fits_header_field (header, "END", 1);
     23  p2 = gfits_header_field (header, "END", 1);
    2424  if (header[0].size - (p2 - header[0].buffer + FT_LINE_LENGTH) > FT_RECORD_SIZE) {
    2525    header[0].size -= FT_RECORD_SIZE;

  • trunk/Ohana/src/libfits/header/F_free_H.c

    r7039 r7054  
    33
    44/*********************** fits free header ***********************************/
    5 void fits_free_header (Header *header) {
     5void gfits_free_header (Header *header) {
    66
    77  if (header[0].buffer == (char *) NULL) return;

  • trunk/Ohana/src/libfits/header/F_init_H.c

    r7039 r7054  
    44
    55/*********************** fits read header ***********************************/
    6 int fits_init_header (Header *header) {
     6int gfits_init_header (Header *header) {
    77
    88  int i;

  • trunk/Ohana/src/libfits/header/F_insert_array.c

    r7039 r7054  
    33
    44/*********************** fits insert array ***********************************/
    5 void fits_insert_matrix (matrix, array, x, y)
     5void gfits_insert_matrix (matrix, array, x, y)
    66Matrix *matrix, *array;
    77int x, y;

  • trunk/Ohana/src/libfits/header/F_modify.c

    r7039 r7054  
    22# include <gfitsio.h>
    33
    4 char *fits_keyword_start (char *line);
    5 char *fits_keyword_end (char *line);
     4char *gfits_keyword_start (char *line);
     5char *gfits_keyword_end (char *line);
    66void pad_ending (char *line, char value, int Nbyte);
    77
    8 int fits_modify (Header *header, char *field, char *mode, int N,...) {
     8int gfits_modify (Header *header, char *field, char *mode, int N,...) {
    99 
    1010  /* this function expects one more argument, the value to be written */
    11   /* this function is extremely similar to fits_print, except it allows for changing an existing field. */
     11  /* this function is extremely similar to gfits_print, except it allows for changing an existing field. */
    1212
    1313  char comment[82], string[82], data[82];
    … …  
    2121
    2222  if (mode[0] != '%') {
    23     fprintf (stderr, "fits_print: weird mode:  %s\n", mode);
     23    fprintf (stderr, "gfits_print: weird mode:  %s\n", mode);
    2424    return (FALSE);
    2525  }
    2626
    2727  /* find location of desired entry */
    28   p = fits_header_field (header, field, N);
     28  p = gfits_header_field (header, field, N);
    2929  if (p == NULL)  {
    3030    /* new entry, find the END of the header */
    31     p = fits_header_field (header, "END", 1);
     31    p = gfits_header_field (header, "END", 1);
    3232    if (p == NULL) return (FALSE);
    3333   
    … …  
    3636      header[0].size += FT_RECORD_SIZE;
    3737      REALLOCATE (header[0].buffer, char, header[0].size);
    38       p = fits_header_field (header, "END", 1);
     38      p = gfits_header_field (header, "END", 1);
    3939      if (p == NULL) return (FALSE);
    4040      memset (p + FT_LINE_LENGTH, ' ', FT_RECORD_SIZE);
    … …  
    4646  } else {
    4747    /* old entry, save the comment region (is this skipping a character for non-strings?) */
    48     qe = fits_keyword_end (p);
     48    qe = gfits_keyword_end (p);
    4949    qe += 3;
    5050    qe = MIN (p + 80, qe);
    … …  
    8787  /* just a comment associated with a value.  this is assumes a fixed format position for the comment */
    8888  if (!strcmp (mode, "%C")) {
    89     qe = fits_keyword_end (p);
    90     qs = fits_keyword_start (p);
     89    qe = gfits_keyword_end (p);
     90    qs = gfits_keyword_start (p);
    9191
    9292    /* keep ' on ends, if there */
    … …  
    108108
    109109/* given a FITS card line, return pointer to the start of the data area */
    110 char *fits_keyword_start (char *line) {
     110char *gfits_keyword_start (char *line) {
    111111
    112112  char *c;
    … …  
    127127
    128128/* given a FITS card line, return pointer to the end of the data area */
    129 char *fits_keyword_end (char *line) {
     129char *gfits_keyword_end (char *line) {
    130130
    131131  int done;

  • trunk/Ohana/src/libfits/header/F_print.c

    r7039 r7054  
    22# include <gfitsio.h>
    33
    4 int fits_print (Header *header, char *field, char *mode, int N,...) {
     4int gfits_print (Header *header, char *field, char *mode, int N,...) {
    55 
    66  /* this function expects one more argument, the value to be written */
    … …  
    1414 
    1515  if (mode[0] != '%') {
    16     fprintf (stderr, "fits_print: weird mode:  %s\n", mode);
     16    fprintf (stderr, "gfits_print: weird mode:  %s\n", mode);
    1717    return (FALSE);
    1818  }
    1919
    2020  /* this is supposed to create a new field, not modify an old one.  */
    21   p = fits_header_field (header, field, N);
     21  p = gfits_header_field (header, field, N);
    2222  if (p != NULL) return (FALSE);
    2323
    2424  /* find the END of the header */
    25   p = fits_header_field (header, "END", 1);
     25  p = gfits_header_field (header, "END", 1);
    2626  if (p == NULL) return (FALSE);
    2727
    … …  
    3131    REALLOCATE (header[0].buffer, char, header[0].size);
    3232    /* re-find the "END" marker, in case new memory block is used */
    33     p = fits_header_field (header, "END", 1);
     33    p = gfits_header_field (header, "END", 1);
    3434    if (p == NULL) return (FALSE);
    3535    memset (p + FT_LINE_LENGTH, ' ', FT_RECORD_SIZE);
    … …  
    9090  */
    9191
    92   /* can't write the comment in fits_print - use fits_modify */
     92  /* can't write the comment in gfits_print - use gfits_modify */
    9393  if (!strcmp (mode, "%C")) return (FALSE);
    9494

  • trunk/Ohana/src/libfits/header/F_read_H.c

    r7039 r7054  
    44
    55/*********************** fits read header ***********************************/
    6 int fits_read_header (char *filename, Header *header) {
     6int gfits_read_header (char *filename, Header *header) {
    77 
    88  FILE *f;
    … …  
    1313    return (FALSE);
    1414  }
    15   if (!fits_load_header (f, header)) {
     15  if (!gfits_load_header (f, header)) {
    1616    fclose (f);
    1717    return (FALSE);
    … …  
    2222}       
    2323
    24 int fits_load_header (FILE *f, Header *header) {
     24int gfits_load_header (FILE *f, Header *header) {
    2525
    2626  int i, done, Nbytes, t1, t2;
    … …  
    4646    }
    4747
    48     p = fits_header_field (header, "END", 1);
     48    p = gfits_header_field (header, "END", 1);
    4949    if (p != NULL)
    5050      done = TRUE;
    … …  
    5757    header[0].Naxis[i] = 0;
    5858
    59   fits_scan (header,  "SIMPLE", "%t",   1, &header[0].simple);
    60   fits_scan (header,  "BITPIX", "%d",   1, &header[0].bitpix);
    61   fits_scan (header,  "NAXIS",  "%d",   1, &header[0].Naxes);
     59  gfits_scan (header,  "SIMPLE", "%t",   1, &header[0].simple);
     60  gfits_scan (header,  "BITPIX", "%d",   1, &header[0].bitpix);
     61  gfits_scan (header,  "NAXIS",  "%d",   1, &header[0].Naxes);
    6262                                                           
    63   fits_scan (header,  "EXTEND", "%t",   1, &header[0].extend);
    64   fits_scan (header,  "UNSIGN", "%t",   1, &header[0].unsign);
    65   fits_scan (header,  "BSCALE", "%lf",  1, &header[0].bscale);
    66   fits_scan (header,  "BZERO",  "%lf",  1, &header[0].bzero);
     63  gfits_scan (header,  "EXTEND", "%t",   1, &header[0].extend);
     64  gfits_scan (header,  "UNSIGN", "%t",   1, &header[0].unsign);
     65  gfits_scan (header,  "BSCALE", "%lf",  1, &header[0].bscale);
     66  gfits_scan (header,  "BZERO",  "%lf",  1, &header[0].bzero);
    6767                                       
    68   fits_scan (header,  "NAXIS1", "%d", 1, &header[0].Naxis[0]);
    69   fits_scan (header,  "NAXIS2", "%d", 1, &header[0].Naxis[1]);
    70   fits_scan (header,  "NAXIS3", "%d", 1, &header[0].Naxis[2]);
    71   fits_scan (header,  "NAXIS4", "%d", 1, &header[0].Naxis[3]);
    72   fits_scan (header,  "NAXIS5", "%d", 1, &header[0].Naxis[4]);
    73   fits_scan (header,  "NAXIS6", "%d", 1, &header[0].Naxis[5]);
    74   fits_scan (header,  "NAXIS7", "%d", 1, &header[0].Naxis[6]);
    75   fits_scan (header,  "NAXIS8", "%d", 1, &header[0].Naxis[7]);
    76   fits_scan (header,  "NAXIS9", "%d", 1, &header[0].Naxis[8]);
    77   fits_scan (header, "NAXIS10", "%d", 1, &header[0].Naxis[9]);
     68  gfits_scan (header,  "NAXIS1", "%d", 1, &header[0].Naxis[0]);
     69  gfits_scan (header,  "NAXIS2", "%d", 1, &header[0].Naxis[1]);
     70  gfits_scan (header,  "NAXIS3", "%d", 1, &header[0].Naxis[2]);
     71  gfits_scan (header,  "NAXIS4", "%d", 1, &header[0].Naxis[3]);
     72  gfits_scan (header,  "NAXIS5", "%d", 1, &header[0].Naxis[4]);
     73  gfits_scan (header,  "NAXIS6", "%d", 1, &header[0].Naxis[5]);
     74  gfits_scan (header,  "NAXIS7", "%d", 1, &header[0].Naxis[6]);
     75  gfits_scan (header,  "NAXIS8", "%d", 1, &header[0].Naxis[7]);
     76  gfits_scan (header,  "NAXIS9", "%d", 1, &header[0].Naxis[8]);
     77  gfits_scan (header, "NAXIS10", "%d", 1, &header[0].Naxis[9]);
    7878
    7979  return (TRUE);
    … …  
    8181}
    8282
    83 int fits_fread_header (FILE *f, Header *header) {
     83int gfits_fread_header (FILE *f, Header *header) {
    8484
    8585  int status;
    8686 
    87   status = fits_load_header (f, header);
     87  status = gfits_load_header (f, header);
    8888  return (status);
    8989}

  • trunk/Ohana/src/libfits/header/F_read_XH.c

    r7039 r7054  
    44
    55/*********************** fits read header ***********************************/
    6 int fits_read_Xheader (char *filename, Header *header, int N) {
     6int gfits_read_Xheader (char *filename, Header *header, int N) {
    77 
    88  /* read header for extension number N */
    … …  
    2121  for (j = -1; j < N; j++) {
    2222    /* load data for this header */
    23     if (!fits_load_header (f, &theader)) {
     23    if (!gfits_load_header (f, &theader)) {
    2424      fclose (f);
    2525      return (FALSE);
    2626    }
    2727
    28     Nmatrix = fits_matrix_size (&theader);
     28    Nmatrix = gfits_matrix_size (&theader);
    2929
    3030    /* skip to next header */
    3131    fseek (f, Nmatrix, SEEK_CUR);
    3232    Nskip += (Nmatrix + theader.size);
    33     fits_free_header (&theader);
     33    gfits_free_header (&theader);
    3434  }
    3535 
    36   if (!fits_load_header (f, header)) {
     36  if (!gfits_load_header (f, header)) {
    3737    fclose (f);
    3838    return (FALSE);

  • trunk/Ohana/src/libfits/header/F_scan.c

    r7039 r7054  
    22# include <gfitsio.h>
    33
    4 char *fits_keyword_start (char *line);
    5 char *fits_keyword_end (char *line);
     4char *gfits_keyword_start (char *line);
     5char *gfits_keyword_end (char *line);
    66
    7 int fits_scan (Header *header, char *field, char *mode, int N,...) {
     7int gfits_scan (Header *header, char *field, char *mode, int N,...) {
    88
    99  int status;
    … …  
    1111 
    1212  va_start (argp, N);
    13   status = fits_vscan (header, field, mode, N, argp);
     13  status = gfits_vscan (header, field, mode, N, argp);
    1414  va_end (argp);
    1515  return (status);
    1616}
    1717 
    18 int fits_vscan (Header *header, char *field, char *mode, int N, va_list argp) {
     18int gfits_vscan (Header *header, char *field, char *mode, int N, va_list argp) {
    1919
    2020  char *p, *q, *s, tmp[81];
    … …  
    2323 
    2424  /* find the correct line with field */
    25   p = fits_header_field (header, field, N);
     25  p = gfits_header_field (header, field, N);
    2626  if (p == NULL) return (FALSE);
    2727
    … …  
    3737  /* comment from data line */
    3838  if (!strcmp (mode, "%C")) {
    39     q = fits_keyword_end (p) + 3;
     39    q = gfits_keyword_end (p) + 3;
    4040    q = MIN (p + 80, q);
    4141    bzero (tmp, 81);
    4242    Nchar = MIN (80, p + 80 - q);
    4343    memcpy (tmp, q, Nchar);
    44     fits_stripwhite (tmp);
     44    gfits_stripwhite (tmp);
    4545    strcpy (va_arg (argp, char *), tmp);
    4646    return (TRUE);
    … …  
    4949  /* extract data into char array (exclude containing ' chars) */
    5050  if (!strcmp (mode, "%s")) {
    51     s = fits_keyword_start (p); /* points at first char (not ') */
    52     q = fits_keyword_end (p); /* points at following space or ' */
     51    s = gfits_keyword_start (p); /* points at first char (not ') */
     52    q = gfits_keyword_end (p); /* points at following space or ' */
    5353
    5454    Nchar = MAX (0, (q - s));
    5555    bzero (tmp, 81);
    5656    memcpy (tmp, s, Nchar);
    57     fits_stripwhite (tmp);
     57    gfits_stripwhite (tmp);
    5858    strcpy (va_arg (argp, char *), tmp);
    5959    return (TRUE);
    … …  
    6262  /* boolean data, requires int target */
    6363  if (!strcmp (mode, "%t")) {
    64     s = fits_keyword_start (p);
     64    s = gfits_keyword_start (p);
    6565    if (*s == 'T') {
    6666      *va_arg (argp, int *) = TRUE;
    … …  
    7575  /* remaining options are numerical data */
    7676  /* need to interpret 1.0d5 as 1.0e5 */
    77   s = fits_keyword_start (p); /* points at first char (not ') */
    78   q = fits_keyword_end (p); /* points at following space or ' */
     77  s = gfits_keyword_start (p); /* points at first char (not ') */
     78  q = gfits_keyword_end (p); /* points at following space or ' */
    7979  value = strtod (s, &q);
    8080  if ((*q == 'd') || (*q == 'D'))
    … …  
    100100
    101101/* Strip whitespace from the start and end of STRING. */
    102 int fits_stripwhite (char *string) {
     102int gfits_stripwhite (char *string) {
    103103
    104104  int i;

  • trunk/Ohana/src/libfits/header/F_write_H.c

    r7039 r7054  
    33
    44/*********************** fits write header ***********************************/
    5 int fits_write_header (char *filename, Header *header) {
     5int gfits_write_header (char *filename, Header *header) {
    66
    77  FILE *f;
    … …  
    2525
    2626/*********************** fits write header ***********************************/
    27 int fits_save_header (FILE *f, Header *header) {
     27int gfits_save_header (FILE *f, Header *header) {
    2828
    2929  int Nbytes, status;
    … …  
    4141
    4242
    43 int fits_fwrite_header (FILE *f, Header *header) {
     43int gfits_fwrite_header (FILE *f, Header *header) {
    4444
    4545  int status;
    46   status = fits_save_header (f, header);
     46  status = gfits_save_header (f, header);
    4747  return (status);
    4848}

  • trunk/Ohana/src/libfits/header/version.c

    r7039 r7054  
    33static char *name = "$Name: not supported by cvs2svn $";
    44
    5 char *fits_version () {
     5char *gfits_version () {
    66  return (name);
    77}

  • trunk/Ohana/src/libfits/include/gfitsio.h

    r7039 r7054  
    8686# endif
    8787
    88 char *fits_version                PROTO(());
     88char *gfits_version                PROTO(());
    8989
    9090/******************************* Header functions *************/
    91 int   fits_read_header            PROTO((char *, Header *));
     91int   gfits_read_header            PROTO((char *, Header *));
    9292// int   fits_copy_header            PROTO((Header *, Header *));
    9393int   gfits_copy_header           PROTO((Header *, Header *));
    94 void  fits_free_header            PROTO((Header *));
    95 int   fits_write_header           PROTO((char *, Header *));
    96 int   fits_create_header          PROTO((Header *));
    97 int   fits_delete                 PROTO((Header *, char *, int));
    98 char *fits_header_field           PROTO((Header *, char *, int));
    99 int   fits_read_Xheader           PROTO((char *filename, Header *header, int N));
    100 int   fits_load_header            PROTO((FILE *f, Header *header));
     94void  gfits_free_header            PROTO((Header *));
     95int   gfits_write_header           PROTO((char *, Header *));
     96int   gfits_create_header          PROTO((Header *));
     97int   gfits_delete                 PROTO((Header *, char *, int));
     98char *gfits_header_field           PROTO((Header *, char *, int));
     99int   gfits_read_Xheader           PROTO((char *filename, Header *header, int N));
     100int   gfits_load_header            PROTO((FILE *f, Header *header));
    101101
    102 int   fits_fread_header           PROTO((FILE *, Header *));
    103 int   fits_fread_Theader          PROTO((FILE *, Header *));
    104 int   fits_fread_ftable           PROTO((FILE *, FTable *, char *));
    105 int   fits_fread_vtable_range     PROTO((FILE *f, VTable *table, int start, int Nrows));
    106 int   fits_fread_vtable           PROTO((FILE *f, VTable *table, char *extname, int Nrow, int *row));
    107 int   fits_fread_ftable_data      PROTO((FILE *f, FTable *table));
    108 int   fits_fwrite_header          PROTO((FILE *, Header *));
    109 int   fits_fwrite_Theader         PROTO((FILE *, Header *));
    110 int   fits_fwrite_matrix          PROTO((FILE *, Matrix *));     
    111 int   fits_fwrite_table           PROTO((FILE *, FTable *));
    112 int   fits_fwrite_vtable          PROTO((FILE *, VTable *));
     102int   gfits_fread_header           PROTO((FILE *, Header *));
     103int   gfits_fread_Theader          PROTO((FILE *, Header *));
     104int   gfits_fread_ftable           PROTO((FILE *, FTable *, char *));
     105int   gfits_fread_vtable_range     PROTO((FILE *f, VTable *table, int start, int Nrows));
     106int   gfits_fread_vtable           PROTO((FILE *f, VTable *table, char *extname, int Nrow, int *row));
     107int   gfits_fread_ftable_data      PROTO((FILE *f, FTable *table));
     108int   gfits_fwrite_header          PROTO((FILE *, Header *));
     109int   gfits_fwrite_Theader         PROTO((FILE *, Header *));
     110int   gfits_fwrite_matrix          PROTO((FILE *, Matrix *));     
     111int   gfits_fwrite_table           PROTO((FILE *, FTable *));
     112int   gfits_fwrite_vtable          PROTO((FILE *, VTable *));
    113113
    114 int   fits_matrix_size            PROTO ((Header *));
    115 int   fits_init_header            PROTO ((Header *));
    116 int   fits_create_table_header    PROTO ((Header *, char *, char *));
    117 int   fits_vtable_from_ftable     PROTO ((FTable *ftable, VTable *vtable, int *row, int Nrow));
    118 int   fits_table_to_vtable        PROTO ((FTable *ftable, VTable *vtable, int start, int Nkeep));
    119 int   fits_create_table           PROTO ((Header *, FTable *));
    120 int   fits_vadd_rows              PROTO ((VTable *, char *, int, int));
    121 int   fits_add_rows               PROTO ((FTable *, char *, int, int));
    122 char *fits_table_print            PROTO ((FTable *,...));
     114int   gfits_matrix_size            PROTO ((Header *));
     115int   gfits_init_header            PROTO ((Header *));
     116int   gfits_create_table_header    PROTO ((Header *, char *, char *));
     117int   gfits_vtable_from_ftable     PROTO ((FTable *ftable, VTable *vtable, int *row, int Nrow));
     118int   gfits_table_to_vtable        PROTO ((FTable *ftable, VTable *vtable, int start, int Nkeep));
     119int   gfits_create_table           PROTO ((Header *, FTable *));
     120int   gfits_vadd_rows              PROTO ((VTable *, char *, int, int));
     121int   gfits_add_rows               PROTO ((FTable *, char *, int, int));
     122char *gfits_table_print            PROTO ((FTable *,...));
    123123
    124124/******************************* Matrix functions *************/
    125 int   fits_read_matrix            PROTO((char *, Matrix *));     
    126 int   fits_read_portion           PROTO((char *filename, Matrix *matrix, int Nskip, int Npix));
    127 void  fits_free_matrix            PROTO((Matrix *));
    128 int   fits_copy_matrix            PROTO((Matrix *, Matrix *));
    129 int   fits_write_matrix           PROTO((char *,Matrix *));
    130 int   fits_create_matrix          PROTO((Header *, Matrix *));
    131 double  fits_get_matrix_value     PROTO((Matrix *, int, int));
    132 void  fits_set_matrix_value       PROTO((Matrix *, int, int, double));
    133 void  fits_add_matrix_value       PROTO((Matrix *, int, int, double));
    134 int   fits_multiply_matrix        PROTO((Matrix *, Matrix *, Matrix *));
    135 int   fits_divide_matrix          PROTO((Matrix *, Matrix *, Matrix *));
    136 void  fits_insert_array           PROTO((Matrix *, Matrix *, int, int));
    137 int   fits_load_matrix            PROTO((FILE *f, Matrix *matrix, Header *header));
    138 int   fits_fread_matrix           PROTO((FILE *f, Matrix *matrix, Header *header));
    139 int   fits_read_segment           PROTO((char *filename, Matrix *matrix, char *region));
    140 int   fits_convert_format         PROTO((Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int outUnsign));
     125int   gfits_read_matrix            PROTO((char *, Matrix *));     
     126int   gfits_read_portion           PROTO((char *filename, Matrix *matrix, int Nskip, int Npix));
     127void  gfits_free_matrix            PROTO((Matrix *));
     128int   gfits_copy_matrix            PROTO((Matrix *, Matrix *));
     129int   gfits_write_matrix           PROTO((char *,Matrix *));
     130int   gfits_create_matrix          PROTO((Header *, Matrix *));
     131double  gfits_get_matrix_value     PROTO((Matrix *, int, int));
     132void  gfits_set_matrix_value       PROTO((Matrix *, int, int, double));
     133void  gfits_add_matrix_value       PROTO((Matrix *, int, int, double));
     134int   gfits_multiply_matrix        PROTO((Matrix *, Matrix *, Matrix *));
     135int   gfits_divide_matrix          PROTO((Matrix *, Matrix *, Matrix *));
     136void  gfits_insert_array           PROTO((Matrix *, Matrix *, int, int));
     137int   gfits_load_matrix            PROTO((FILE *f, Matrix *matrix, Header *header));
     138int   gfits_fread_matrix           PROTO((FILE *f, Matrix *matrix, Header *header));
     139int   gfits_read_segment           PROTO((char *filename, Matrix *matrix, char *region));
     140int   gfits_convert_format         PROTO((Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int outUnsign));
    141141
    142142/******************************* Table functions *************/
    143 int   fits_load_Theader           PROTO((FILE *f, Header *Theader));
    144 int   fits_read_Theader           PROTO((char *, Header *));     
    145 int   fits_read_table             PROTO((char *, FTable *));
    146 int   fits_read_table             PROTO((char *, FTable *));
    147 int   fits_write_Theader          PROTO((char *, Header *header));
    148 int   fits_write_table            PROTO((char *, FTable *));
    149 int   fits_fwrite_table           PROTO((FILE *f, FTable *table));
    150 int   fits_fwrite_vtable          PROTO((FILE *f, VTable *table));
     143int   gfits_load_Theader           PROTO((FILE *f, Header *Theader));
     144int   gfits_read_Theader           PROTO((char *, Header *));     
     145int   gfits_read_table             PROTO((char *, FTable *));
     146int   gfits_read_table             PROTO((char *, FTable *));
     147int   gfits_write_Theader          PROTO((char *, Header *header));
     148int   gfits_write_table            PROTO((char *, FTable *));
     149int   gfits_fwrite_table           PROTO((FILE *f, FTable *table));
     150int   gfits_fwrite_vtable          PROTO((FILE *f, VTable *table));
    151151
    152 int   fits_bintable_format        PROTO((char *, char *, int *, int *));
    153 int   fits_table_format           PROTO((char *, char *, int *, int *));
    154 int   fits_save_header            PROTO((FILE *, Header *header));
    155 int   fits_set_bintable_column    PROTO((Header *header, FTable *table, char *, void *, int));
    156 int   fits_set_table_column       PROTO((Header *header, FTable *table, char *, void *, int));
    157 int   fits_define_bintable_column PROTO((Header *header, char *, char *, char *, char *, double, double));
    158 int   fits_define_table_column    PROTO((Header *header, char *, char *, char *, char *));
    159 int   fits_read_ftable            PROTO((char *filename, FTable *table, char *extname));
     152int   gfits_bintable_format        PROTO((char *, char *, int *, int *));
     153int   gfits_table_format           PROTO((char *, char *, int *, int *));
     154int   gfits_save_header            PROTO((FILE *, Header *header));
     155int   gfits_set_bintable_column    PROTO((Header *header, FTable *table, char *, void *, int));
     156int   gfits_set_table_column       PROTO((Header *header, FTable *table, char *, void *, int));
     157int   gfits_define_bintable_column PROTO((Header *header, char *, char *, char *, char *, double, double));
     158int   gfits_define_table_column    PROTO((Header *header, char *, char *, char *, char *));
     159int   gfits_read_ftable            PROTO((char *filename, FTable *table, char *extname));
    160160
    161 int   fits_free_table             PROTO((FTable *table));
    162 int   fits_free_vtable            PROTO((VTable *table));
    163 int   fits_create_Theader         PROTO((Header *header, char *type));
     161int   gfits_free_table             PROTO((FTable *table));
     162int   gfits_free_vtable            PROTO((VTable *table));
     163int   gfits_create_Theader         PROTO((Header *header, char *type));
    164164
    165165/* prototyping demanded for these four -- could be a problem on non-ANSI comp comp */
    166 int   fits_scan                   PROTO((Header *, char *, char *, int,...));
    167 int   fits_print                  PROTO((Header *, char *, char *, int,...));
    168 int   fits_modify                 PROTO((Header *, char *, char *, int,...));
    169 int   fits_table_column           PROTO((FTable *, char *, char *,...));
    170 int   fits_table_column           PROTO((FTable *table, char *, char *,...));
     166int   gfits_scan                   PROTO((Header *, char *, char *, int,...));
     167int   gfits_print                  PROTO((Header *, char *, char *, int,...));
     168int   gfits_modify                 PROTO((Header *, char *, char *, int,...));
     169int   gfits_table_column           PROTO((FTable *, char *, char *,...));
     170int   gfits_table_column           PROTO((FTable *table, char *, char *,...));
    171171
    172 char *fits_keyword_end            PROTO((char *line));
    173 int   fits_vscan                  PROTO((Header *header, char *field, char *mode, int N, va_list argp));
    174 int   fits_scan                   PROTO((Header *header, char *field, char *mode, int N,...));
    175 int   fits_stripwhite             PROTO((char *string));
    176 int   fits_matrix_size            PROTO((Header *header));
     172char *gfits_keyword_end            PROTO((char *line));
     173int   gfits_vscan                  PROTO((Header *header, char *field, char *mode, int N, va_list argp));
     174int   gfits_scan                   PROTO((Header *header, char *field, char *mode, int N,...));
     175int   gfits_stripwhite             PROTO((char *string));
     176int   gfits_matrix_size            PROTO((Header *header));
    177177
    178 int   fits_get_bintable_column_type PROTO((Header *header, char *label, char *type, int *Nval));
    179 int   fits_get_bintable_column    PROTO((Header *header, FTable *table, char *label, void **data));
    180 int   fits_get_table_column_type  PROTO((Header *header, char *label, char *type));
    181 int   fits_get_table_column       PROTO((Header *header, FTable *table, char *label, void **data));
     178int   gfits_get_bintable_column_type PROTO((Header *header, char *label, char *type, int *Nval));
     179int   gfits_get_bintable_column    PROTO((Header *header, FTable *table, char *label, void **data));
     180int   gfits_get_table_column_type  PROTO((Header *header, char *label, char *type));
     181int   gfits_get_table_column       PROTO((Header *header, FTable *table, char *label, void **data));
    182182
    183183#endif /* FITSIO */

  • trunk/Ohana/src/libfits/matrix/F_add_M.c

    r7039 r7054  
    33
    44/*********************** fits insert array ***********************************/
    5 void fits_add_matrix (matrix, array, x, y)
     5void gfits_add_matrix (matrix, array, x, y)
    66Matrix *matrix, *array;
    77int x, y;
    … …  
    2323  for (i = 0; i < array[0].Naxis[0]; i++) {
    2424    for (j = 0; j < array[0].Naxis[1]; j++) {
    25       V = fits_get_matrix_value (array, i, j);
    26       V += fits_get_matrix_value (matrix, x + i, y + j);
    27       fits_set_matrix_value (matrix, x + i, y + j, V);
     25      V = gfits_get_matrix_value (array, i, j);
     26      V += gfits_get_matrix_value (matrix, x + i, y + j);
     27      gfits_set_matrix_value (matrix, x + i, y + j, V);
    2828    }
    2929  }

  • trunk/Ohana/src/libfits/matrix/F_add_M_value.c

    r7039 r7054  
    33
    44/***************** fits add matrix value ***********************************/
    5 void fits_add_matrix_value (matrix, x, y, Value)
     5void gfits_add_matrix_value (matrix, x, y, Value)
    66Matrix *matrix;
    77int x, y;
    … …  
    1111  double value;
    1212
    13   value = fits_get_matrix_value (matrix, x, y);
     13  value = gfits_get_matrix_value (matrix, x, y);
    1414  value += Value;
    15   fits_set_matrix_value (matrix, x, y, value);
     15  gfits_set_matrix_value (matrix, x, y, value);
    1616
    1717}

  • trunk/Ohana/src/libfits/matrix/F_convert_format.c

    r7039 r7054  
    2929
    3030/*********************** fits convert format ***********************************/
    31 int fits_convert_format (Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int outUnsign) {
     31int gfits_convert_format (Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int outUnsign) {
    3232
    3333  unsigned long i, nbytes, Npixels;
    … …  
    4949  matrix[0].bzero  = header[0].bzero  = outZero;
    5050  matrix[0].unsign = header[0].unsign = outUnsign;
    51   matrix[0].size   = fits_matrix_size (header);
    52   fits_modify (header, "BITPIX", "%d", 1, outBitpix);
    53   fits_modify (header, "BSCALE", "%lf", 1, outScale);
    54   fits_modify (header, "BZERO",  "%lf", 1, outZero);
    55   fits_modify (header, "UNSIGN", "%t", 1, outUnsign);
     51  matrix[0].size   = gfits_matrix_size (header);
     52  gfits_modify (header, "BITPIX", "%d", 1, outBitpix);
     53  gfits_modify (header, "BSCALE", "%lf", 1, outScale);
     54  gfits_modify (header, "BZERO",  "%lf", 1, outZero);
     55  gfits_modify (header, "UNSIGN", "%t", 1, outUnsign);
    5656
    5757  Npixels          = header[0].Naxis[0]*header[0].Naxis[1];

  • trunk/Ohana/src/libfits/matrix/F_copy_M.c

    r7039 r7054  
    33
    44/*********************** fits copy header ***********************************/
    5 int fits_copy_matrix (Matrix *matrix1, Matrix *matrix2) {
     5int gfits_copy_matrix (Matrix *matrix1, Matrix *matrix2) {
    66
    77  int i;

  • trunk/Ohana/src/libfits/matrix/F_create_M.c

    r7039 r7054  
    33
    44/*********************** fits create matrix *******************************/
    5 int fits_create_matrix (header, matrix)
     5int gfits_create_matrix (header, matrix)
    66Header *header;
    77Matrix *matrix;
    … …  
    1818    matrix[0].Naxis[i] = header[0].Naxis[i];
    1919
    20   Nbytes = fits_matrix_size (header);
     20  Nbytes = gfits_matrix_size (header);
    2121  ALLOCATE (matrix[0].buffer, char, MAX (Nbytes, 1));
    2222  bzero (matrix[0].buffer, Nbytes);

  • trunk/Ohana/src/libfits/matrix/F_divide_M.c

    r7039 r7054  
    33
    44/********************* fits divide matrix ***********************************/
    5 int fits_divide_matrix (Matrix *M1, Matrix *M2, Matrix *M3) {
     5int gfits_divide_matrix (Matrix *M1, Matrix *M2, Matrix *M3) {
    66
    77  int i,j;
    … …  
    1414  for (i = 0; i < M1[0].Naxis[0]; i++) {
    1515    for (j = 0; j < M1[0].Naxis[1]; j++) {
    16       value = fits_get_matrix_value (M1, i, j);
    17       val2  = fits_get_matrix_value (M2, i, j);
     16      value = gfits_get_matrix_value (M1, i, j);
     17      val2  = gfits_get_matrix_value (M2, i, j);
    1818      if (val2 != 0)
    1919        value = value / val2;
    2020      else
    2121        value = 0.0;
    22       fits_set_matrix_value (M3, i, j, value);
     22      gfits_set_matrix_value (M3, i, j, value);
    2323    }
    2424  }

  • trunk/Ohana/src/libfits/matrix/F_free_M.c

    r7039 r7054  
    33
    44/*********************** fits free matrix ***********************************/
    5 void fits_free_matrix (Matrix *matrix) {
     5void gfits_free_matrix (Matrix *matrix) {
    66
    77  if (matrix[0].buffer == (char *) NULL) return;

  • trunk/Ohana/src/libfits/matrix/F_get_M_value.c

    r7039 r7054  
    33
    44/***************** fits get matrix value ***********************************/
    5 double fits_get_matrix_value (matrix, x, y)
     5double gfits_get_matrix_value (matrix, x, y)
    66Matrix *matrix;
    77int x, y;

  • trunk/Ohana/src/libfits/matrix/F_insert_M.c

    r7039 r7054  
    33
    44/*********************** fits insert array ***********************************/
    5 void fits_insert_matrix (Matrix  *matrix, Matrix *array, int x, int y) {
     5void gfits_insert_matrix (Matrix  *matrix, Matrix *array, int x, int y) {
    66
    77  /* there is no check here to match BITPIX, BZERO, or BSCALE */

  • trunk/Ohana/src/libfits/matrix/F_load_M.c

    r7039 r7054  
    22# include <gfitsio.h>
    33
    4 int fits_fread_matrix (FILE *f, Matrix *matrix, Header *header) {
     4int gfits_fread_matrix (FILE *f, Matrix *matrix, Header *header) {
    55 
    66  int status;
    77 
    8   status = fits_load_matrix (f, matrix, header);
     8  status = gfits_load_matrix (f, matrix, header);
    99  return (status);
    1010}
    1111
    1212/*********************** fits read matrix ***********************************/
    13 int fits_load_matrix (FILE *f, Matrix *matrix, Header *header) {
     13int gfits_load_matrix (FILE *f, Matrix *matrix, Header *header) {
    1414
    1515  int i, nbytes, Nbytes;
    … …  
    2525    matrix[0].Naxis[i] = header[0].Naxis[i];
    2626
    27   Nbytes = fits_matrix_size (header);
     27  Nbytes = gfits_matrix_size (header);
    2828  ALLOCATE (matrix[0].buffer, char, Nbytes);
    2929  matrix[0].size = Nbytes;

  • trunk/Ohana/src/libfits/matrix/F_matrix.c

    r7039 r7054  
    22# include <gfitsio.h>
    33
    4 int fits_matrix_size (Header *header) {
     4int gfits_matrix_size (Header *header) {
    55 
    66  int i, Nrec, size;

  • trunk/Ohana/src/libfits/matrix/F_multiply_M.c

    r7039 r7054  
    33
    44/******************* fits multiply matrix ***********************************/
    5 int fits_multiply_matrix (Matrix *M1, Matrix *M2, Matrix *M3) {
     5int gfits_multiply_matrix (Matrix *M1, Matrix *M2, Matrix *M3) {
    66
    77  int i,j;
    … …  
    1414  for (i = 0; i < M1[0].Naxis[0]; i++) {
    1515    for (j = 0; j < M1[0].Naxis[1]; j++) {
    16       value = fits_get_matrix_value (M1, i, j);
    17       value *= fits_get_matrix_value (M2, i, j);
    18       fits_set_matrix_value (M3, i, j, value);
     16      value = gfits_get_matrix_value (M1, i, j);
     17      value *= gfits_get_matrix_value (M2, i, j);
     18      gfits_set_matrix_value (M3, i, j, value);
    1919    }
    2020  }

  • trunk/Ohana/src/libfits/matrix/F_read_M.c

    r7039 r7054  
    33
    44/*********************** fits read matrix ***********************************/
    5 int fits_read_matrix (char *filename, Matrix *matrix) {
     5int gfits_read_matrix (char *filename, Matrix *matrix) {
    66
    77  FILE *f;
    … …  
    99  int status;
    1010
    11   status = fits_read_header (filename, &header);
     11  status = gfits_read_header (filename, &header);
    1212  if (!status) {
    1313    fprintf (stderr, "error reading header of FITS file %s\n", filename);
    … …  
    2020  fseek (f, header.size, 0);
    2121 
    22   status = fits_load_matrix (f, matrix, &header);
     22  status = gfits_load_matrix (f, matrix, &header);
    2323
    2424  fclose (f);

  • trunk/Ohana/src/libfits/matrix/F_read_portion.c

    r7039 r7054  
    99/*********************** fits read matrix ***********************************/
    1010/** the result of this function is a matrix with dimension Npix * 1 **/
    11 int fits_read_portion (char *filename, Matrix *matrix, int Nskip, int Npix) {
     11int gfits_read_portion (char *filename, Matrix *matrix, int Nskip, int Npix) {
    1212
    1313  FILE *f;
    … …  
    1717  int perpix;
    1818
    19   status = fits_read_header (filename, &header);
     19  status = gfits_read_header (filename, &header);
    2020  if (!status) {
    2121    fprintf (stderr, "error reading header of FITS file %s\n", filename);
    … …  
    9696# endif
    9797
    98   fits_free_header (&header);
     98  gfits_free_header (&header);
    9999
    100100  if (nbytes < Nbytes - 2880) {  /* this is a bad FITS error: image is not OK */

  • trunk/Ohana/src/libfits/matrix/F_read_segment.c

    r7039 r7054  
    66
    77/*********************** fits read matrix ***********************************/
    8 int fits_read_segment (char *filename, Matrix *matrix, char *region) {
     8int gfits_read_segment (char *filename, Matrix *matrix, char *region) {
    99
    1010  FILE *f;
    … …  
    1616  int perpix;
    1717
    18   status = fits_read_header (filename, &header);
     18  status = gfits_read_header (filename, &header);
    1919  if (!status) {
    2020    fprintf (stderr, "error reading header of FITS file %s\n", filename);
    … …  
    128128# endif
    129129
    130   fits_free_header (&header);
     130  gfits_free_header (&header);
    131131
    132132  if (nbytes < Nbytes - 2880) {  /* this is a bad FITS error: image is not OK */

  • trunk/Ohana/src/libfits/matrix/F_set_M_value.c

    r7039 r7054  
    33
    44/****************** fits set matrix value ***********************************/
    5 void fits_set_matrix_value (matrix, x, y, Value)
     5void gfits_set_matrix_value (matrix, x, y, Value)
    66Matrix *matrix;
    77int x, y;

  • trunk/Ohana/src/libfits/matrix/F_write_M.c

    r7039 r7054  
    33
    44/*********************** fits write matrix ***********************************/
    5 int fits_write_matrix (char *filename, Matrix *matrix) {
     5int gfits_write_matrix (char *filename, Matrix *matrix) {
    66
    77  FILE *f;
    … …  
    1313  fseek (f, 0, SEEK_END);  /* write matrix to end of file! */
    1414
    15   status = fits_fwrite_matrix (f, matrix);
     15  status = gfits_fwrite_matrix (f, matrix);
    1616  fclose (f);
    1717  return (status);
    … …  
    1919
    2020/*********************** fits write matrix ***********************************/
    21 int fits_fwrite_matrix (FILE *f, Matrix *matrix) {
     21int gfits_fwrite_matrix (FILE *f, Matrix *matrix) {
    2222
    2323  int i, status, nbytes, Nbytes;

  • trunk/Ohana/src/libfits/table/F_create_T.c

    r7039 r7054  
    33
    44/*********************** fits create table *******************************/
    5 int fits_create_table (Header *header, FTable *table) {
     5int gfits_create_table (Header *header, FTable *table) {
    66
    77  int Nbytes;
    88  char type[80];
    99
    10   fits_scan (header, "XTENSION", "%s", 1, type);
     10  gfits_scan (header, "XTENSION", "%s", 1, type);
    1111
    1212  table[0].header = header;
    1313 
    14   Nbytes = fits_matrix_size (header);
     14  Nbytes = gfits_matrix_size (header);
    1515  ALLOCATE (table[0].buffer, char, MAX (Nbytes, 1));
    1616  if (!strcmp (type, "TABLE")) {
    … …  
    2727
    2828/*********************** fits create table *******************************/
    29 int fits_create_vtable (Header *header, VTable *table, int Nrow) {
     29int gfits_create_vtable (Header *header, VTable *table, int Nrow) {
    3030
    3131  int i, Nx, Ny;
    3232  char type[80];
    3333
    34   fits_scan (header, "XTENSION", "%s", 1, type);
     34  gfits_scan (header, "XTENSION", "%s", 1, type);
    3535
    3636  table[0].header = header;
    3737  Nx = table[0].header[0].Naxis[0];
    3838  Ny = table[0].header[0].Naxis[0];
    39   table[0].size = fits_matrix_size (header);
     39  table[0].size = gfits_matrix_size (header);
    4040  table[0].pad = table[0].size - Nx*Ny;
    4141 

  • trunk/Ohana/src/libfits/table/F_create_TH.c

    r7039 r7054  
    77
    88/*********************** fits create Theader *********************************/
    9 int fits_create_Theader (Header *header, char *type) {
     9int gfits_create_Theader (Header *header, char *type) {
    1010 
    1111  int i;
    … …  
    1919  strncpy (header[0].buffer, "END", 3);
    2020 
    21   fits_modify (header, "XTENSION", "%s", 1, type);
    22   fits_modify (header, "BITPIX", "%d", 1, header[0].bitpix);
    23   fits_modify (header, "NAXIS",  "%d", 1, header[0].Naxes);
     21  gfits_modify (header, "XTENSION", "%s", 1, type);
     22  gfits_modify (header, "BITPIX", "%d", 1, header[0].bitpix);
     23  gfits_modify (header, "NAXIS",  "%d", 1, header[0].Naxes);
    2424 
    2525  for (i = 0; i < header[0].Naxes; i++) {
    2626    sprintf (axis, "NAXIS%d", i + 1);
    27     fits_modify (header,  axis, "%d", 1, header[0].Naxis[i], 1);
     27    gfits_modify (header,  axis, "%d", 1, header[0].Naxis[i], 1);
    2828  }
    2929 
    3030  /* PCOUNT & GCOUNT are not implemented, but they are required to be here */
    31   fits_modify (header, "PCOUNT", "%d", 1, 0);
    32   fits_modify (header, "GCOUNT", "%d", 1, 1);
     31  gfits_modify (header, "PCOUNT", "%d", 1, 0);
     32  gfits_modify (header, "GCOUNT", "%d", 1, 1);
    3333  if (!strcmp (type, "IMAGE")) {
    34     fits_modify (header, "BSCALE", "%lf", 1, header[0].bscale);
    35     fits_modify (header, "BZERO",  "%lf", 1, header[0].bzero);
     34    gfits_modify (header, "BSCALE", "%lf", 1, header[0].bscale);
     35    gfits_modify (header, "BZERO",  "%lf", 1, header[0].bzero);
    3636  }
    3737
    … …  
    4040
    4141/*********************** fits create table header *********************************/
    42 int fits_create_table_header (Header *header, char *type, char *extname) {
     42int gfits_create_table_header (Header *header, char *type, char *extname) {
    4343 
    4444  int i, valid;
    … …  
    7171 
    7272  /* required keywords */
    73   fits_modify (header, "XTENSION", "%s", 1, type);
    74   fits_modify (header, "BITPIX", "%d", 1, header[0].bitpix);
    75   fits_modify (header, "NAXIS",  "%d", 1, header[0].Naxes);
     73  gfits_modify (header, "XTENSION", "%s", 1, type);
     74  gfits_modify (header, "BITPIX", "%d", 1, header[0].bitpix);
     75  gfits_modify (header, "NAXIS",  "%d", 1, header[0].Naxes);
    7676 
    7777  for (i = 0; i < header[0].Naxes; i++) {
    7878    sprintf (axis, "NAXIS%d", i + 1);
    79     fits_modify (header,  axis, "%d", 1, header[0].Naxis[i], 1);
     79    gfits_modify (header,  axis, "%d", 1, header[0].Naxis[i], 1);
    8080  }
    8181 
    8282  /* PCOUNT & GCOUNT are not implemented, but they are required to be here */
    83   fits_modify (header, "PCOUNT", "%d", 1, 0);
    84   fits_modify (header, "GCOUNT", "%d", 1, 1);
     83  gfits_modify (header, "PCOUNT", "%d", 1, 0);
     84  gfits_modify (header, "GCOUNT", "%d", 1, 1);
    8585  if (!strcmp (type, "IMAGE")) {
    86     fits_modify (header, "BSCALE", "%lf", 1, header[0].bscale);
    87     fits_modify (header, "BZERO",  "%lf", 1, header[0].bzero);
     86    gfits_modify (header, "BSCALE", "%lf", 1, header[0].bscale);
     87    gfits_modify (header, "BZERO",  "%lf", 1, header[0].bzero);
    8888  }
    8989
    90   fits_modify (header, "TFIELDS", "%d", 1, 0);
    91   fits_modify (header, "EXTNAME", "%s", 1, extname);
     90  gfits_modify (header, "TFIELDS", "%d", 1, 0);
     91  gfits_modify (header, "EXTNAME", "%s", 1, extname);
    9292 
    9393  return (TRUE);

  • trunk/Ohana/src/libfits/table/F_define_column.c

    r7039 r7054  
    33
    44/***********************/
    5 int fits_define_bintable_column (Header *header, char *format, char *label, char *comment, char *unit, double bscale, double bzero) {
     5int gfits_define_bintable_column (Header *header, char *format, char *label, char *comment, char *unit, double bscale, double bzero) {
    66
    77  int Nfields, Nbytes, Nval, Naxis1;
    88  char type[16], field[16];
    99 
    10   if (!fits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE);
     10  if (!gfits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE);
    1111 
    1212  Nfields = 0;
    13   fits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    14   fits_scan (header, "NAXIS1",  "%d", 1, &Naxis1);
     13  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
     14  gfits_scan (header, "NAXIS1",  "%d", 1, &Naxis1);
    1515  Nfields ++;
    1616  Naxis1 += Nbytes*Nval;
    1717
    1818  sprintf (field, "TTYPE%d", Nfields);
    19   fits_modify (header, field, "%s", 1, label);
    20   fits_modify (header, field, "%C", 1, comment);
     19  gfits_modify (header, field, "%s", 1, label);
     20  gfits_modify (header, field, "%C", 1, comment);
    2121  sprintf (field, "TUNIT%d", Nfields);
    22   fits_modify (header, field, "%s", 1, unit);
     22  gfits_modify (header, field, "%s", 1, unit);
    2323  sprintf (field, "TFORM%d", Nfields);
    24   fits_modify (header, field, "%s", 1, format);
     24  gfits_modify (header, field, "%s", 1, format);
    2525  sprintf (field, "TSCAL%d", Nfields);
    26   fits_modify (header, field, "%lf", 1, bscale);
     26  gfits_modify (header, field, "%lf", 1, bscale);
    2727  sprintf (field, "TZERO%d", Nfields);
    28   fits_modify (header, field, "%lf", 1, bzero);
     28  gfits_modify (header, field, "%lf", 1, bzero);
    2929
    3030  /* update TFIELDS & NAXIS1 */
    31   fits_modify (header, "TFIELDS", "%d", 1, Nfields);
    32   fits_modify (header, "NAXIS1",  "%d", 1, Naxis1);
     31  gfits_modify (header, "TFIELDS", "%d", 1, Nfields);
     32  gfits_modify (header, "NAXIS1",  "%d", 1, Naxis1);
    3333  header[0].Naxis[0] = Naxis1;
    3434
    … …  
    3737
    3838/***********************/
    39 int fits_define_table_column (Header *header, char *format, char *label, char *comment, char *unit) {
     39int gfits_define_table_column (Header *header, char *format, char *label, char *comment, char *unit) {
    4040
    4141  int Nstart, Nfields, Nbytes, Nval, Naxis1;
    … …  
    4343
    4444  strcpy (cformat, format);
    45   if (!fits_table_format (cformat, type, &Nval, &Nbytes)) return (FALSE);
     45  if (!gfits_table_format (cformat, type, &Nval, &Nbytes)) return (FALSE);
    4646
    4747  Nfields = 0;
    48   fits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    49   fits_scan (header, "NAXIS1",  "%d", 1, &Naxis1);
     48  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
     49  gfits_scan (header, "NAXIS1",  "%d", 1, &Naxis1);
    5050  Nstart = Naxis1 + 1;
    5151  Nfields ++;
    … …  
    5353
    5454  sprintf (field, "TTYPE%d", Nfields);
    55   fits_modify (header, field, "%s", 1, label);
    56   fits_modify (header, field, "%C", 1, comment);
     55  gfits_modify (header, field, "%s", 1, label);
     56  gfits_modify (header, field, "%C", 1, comment);
    5757  sprintf (field, "TUNIT%d", Nfields);
    58   fits_modify (header, field, "%s", 1, unit);
     58  gfits_modify (header, field, "%s", 1, unit);
    5959  sprintf (field, "TFORM%d", Nfields);
    60   fits_modify (header, field, "%s", 1, format);
     60  gfits_modify (header, field, "%s", 1, format);
    6161
    6262  sprintf (field, "TBCOL%d", Nfields);
    63   fits_modify (header, field, "%d", 1, Nstart);
     63  gfits_modify (header, field, "%d", 1, Nstart);
    6464
    65   fits_modify (header, "TFIELDS", "%d", 1, Nfields);
    66   fits_modify (header, "NAXIS1",  "%d", 1, Naxis1);
     65  gfits_modify (header, "TFIELDS", "%d", 1, Nfields);
     66  gfits_modify (header, "NAXIS1",  "%d", 1, Naxis1);
    6767  header[0].Naxis[0] = Naxis1;
    6868

  • trunk/Ohana/src/libfits/table/F_free_T.c

    r7039 r7054  
    22# include <gfitsio.h>
    33
    4 int fits_free_table (FTable *table) {
     4int gfits_free_table (FTable *table) {
    55 
    66  if (table[0].buffer == (char *) NULL) return (TRUE);
    … …  
    1010}
    1111
    12 int fits_free_vtable (VTable *table) {
     12int gfits_free_vtable (VTable *table) {
    1313 
    1414  int i;

  • trunk/Ohana/src/libfits/table/F_get_T_column.c

    r7039 r7054  
    33
    44/*********************** fits get table column *****************************/
    5 void fits_get_table_column (table, X, mode, values)
     5void gfits_get_table_column (table, X, mode, values)
    66Table *table;
    77int X;
    … …  
    2323 
    2424  sprintf (field, "TBCOL%d\0", X);
    25   fits_scan (&table[0].header, field, "%d", &start, 1);
     25  gfits_scan (&table[0].header, field, "%d", &start, 1);
    2626  start --;
    2727  sprintf (field, "TFORM%d\0", X);
    28   fits_scan (&table[0].header, field, "%s", Tform, 1);
     28  gfits_scan (&table[0].header, field, "%s", Tform, 1);
    2929  Nchar = atof (&Tform[1]);
    3030 

  • trunk/Ohana/src/libfits/table/F_get_T_value.c

    r7039 r7054  
    44/*********************** fits get table value ********************************/
    55 
    6 void fits_get_table_value (table, X, Y, mode, value)
     6void gfits_get_table_value (table, X, Y, mode, value)
    77Table *table;
    88int X, Y;
    … …  
    1717 
    1818  sprintf (field, "TBCOL%d\0", X);
    19   fits_scan (&table[0].header, field, "%d", &start, 1);
     19  gfits_scan (&table[0].header, field, "%d", &start, 1);
    2020  start --;
    2121 
    2222  sprintf (field, "TFORM%d\0", X);
    23   fits_scan (&table[0].header, field, "%s", Tform, 1);
     23  gfits_scan (&table[0].header, field, "%s", Tform, 1);
    2424  Nchar = atof (&Tform[1]);
    2525 

  • trunk/Ohana/src/libfits/table/F_get_column.c

    r7039 r7054  
    1313
    1414/***********************/
    15 int fits_get_bintable_column_type (Header *header, char *label, char *type, int *Nval) {
     15int gfits_get_bintable_column_type (Header *header, char *label, char *type, int *Nval) {
    1616
    1717  int i, N, Nfields, Nbytes;
    … …  
    2323  /* find label in header */
    2424  tlabel[0] = 0;
    25   fits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    26   for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) {
    27     sprintf (field, "TTYPE%d", i);
    28     fits_scan (header, field, "%s", 1, tlabel);
    29   }
    30   if (strcmp (label, tlabel)) return (FALSE);
    31   N = i - 1;
    32 
    33   sprintf (field, "TFORM%d", N);
    34   fits_scan (header, field, "%s", 1, format);
    35 
    36   if (!fits_bintable_format (format, type, Nval, &Nbytes)) return (FALSE);
    37   return (TRUE);
    38 }
    39 
    40 /***********************/
    41 int fits_get_bintable_column (Header *header, FTable *table, char *label, void **data) {
     25  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
     26  for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) {
     27    sprintf (field, "TTYPE%d", i);
     28    gfits_scan (header, field, "%s", 1, tlabel);
     29  }
     30  if (strcmp (label, tlabel)) return (FALSE);
     31  N = i - 1;
     32
     33  sprintf (field, "TFORM%d", N);
     34  gfits_scan (header, field, "%s", 1, format);
     35
     36  if (!gfits_bintable_format (format, type, Nval, &Nbytes)) return (FALSE);
     37  return (TRUE);
     38}
     39
     40/***********************/
     41int gfits_get_bintable_column (Header *header, FTable *table, char *label, void **data) {
    4242
    4343  int i, N, Nfields, Nval, Nbytes, Nx, Ny, Nstart, Nv, Nb;
    … …  
    5252  /* find label in header */
    5353  tlabel[0] = 0;
    54   fits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    55   for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) {
    56     sprintf (field, "TTYPE%d", i);
    57     fits_scan (header, field, "%s", 1, tlabel);
     54  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
     55  for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) {
     56    sprintf (field, "TTYPE%d", i);
     57    gfits_scan (header, field, "%s", 1, tlabel);
    5858  }
    5959  if (strcmp (label, tlabel)) return (FALSE);
    … …  
    6565  /* interpret format */
    6666  sprintf (field, "TSCAL%d", Nfields);
    67   fits_scan (header, field, "%lf", 1, &Bscale);
     67  gfits_scan (header, field, "%lf", 1, &Bscale);
    6868  sprintf (field, "TZERO%d", Nfields);
    69   fits_scan (header, field, "%lf", 1, &Bzero);
    70   sprintf (field, "TFORM%d", N);
    71   fits_scan (header, field, "%s", 1, format);
    72 
    73   if (!fits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE);
     69  gfits_scan (header, field, "%lf", 1, &Bzero);
     70  sprintf (field, "TFORM%d", N);
     71  gfits_scan (header, field, "%s", 1, format);
     72
     73  if (!gfits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE);
    7474 
    7575  /* check existing table dimensions */
    76   fits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    77   fits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     76  gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
     77  gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
    7878
    7979  /* scan columns to find insert point */
    … …  
    8181  for (i = 1; i < N; i++) {
    8282    sprintf (field, "TFORM%d", i);
    83     fits_scan (header, field, "%s", 1, format);
    84     fits_bintable_format (format, tmpline, &Nv, &Nb);
     83    gfits_scan (header, field, "%s", 1, format);
     84    gfits_bintable_format (format, tmpline, &Nv, &Nb);
    8585    Nstart += Nv*Nb;
    8686  }
    … …  
    163163
    164164/***********************/
    165 int fits_get_table_column_type (Header *header, char *label, char *type) {
     165int gfits_get_table_column_type (Header *header, char *label, char *type) {
    166166
    167167  int i, N, Nfields, Nval, Nbytes;
    … …  
    173173  /* find label in header */
    174174  tlabel[0] = 0;
    175   fits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    176   for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) {
    177     sprintf (field, "TTYPE%d", i);
    178     fits_scan (header, field, "%s", 1, tlabel);
     175  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
     176  for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) {
     177    sprintf (field, "TTYPE%d", i);
     178    gfits_scan (header, field, "%s", 1, tlabel);
    179179  }
    180180  if (strcmp (label, tlabel)) return (FALSE);
    … …  
    183183  /* interpret format */
    184184  sprintf (field, "TFORM%d", N);
    185   fits_scan (header, field, "%s", 1, format);
    186 
    187   if (!fits_table_format (format, type, &Nval, &Nbytes)) return (FALSE);
    188   return (TRUE);
    189 }
    190 
    191 /***********************/
    192 int fits_get_table_column (Header *header, FTable *table, char *label, void **data) {
     185  gfits_scan (header, field, "%s", 1, format);
     186
     187  if (!gfits_table_format (format, type, &Nval, &Nbytes)) return (FALSE);
     188  return (TRUE);
     189}
     190
     191/***********************/
     192int gfits_get_table_column (Header *header, FTable *table, char *label, void **data) {
    193193
    194194  int i, N, Nfields, Nval, Nbytes, Nx, Ny, Nstart, Nv, Nb;
    … …  
    202202  /* find label in header */
    203203  tlabel[0] = 0;
    204   fits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    205   for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) {
    206     sprintf (field, "TTYPE%d", i);
    207     fits_scan (header, field, "%s", 1, tlabel);
     204  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
     205  for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) {
     206    sprintf (field, "TTYPE%d", i);
     207    gfits_scan (header, field, "%s", 1, tlabel);
    208208  }
    209209  if (strcmp (label, tlabel)) return (FALSE);
    … …  
    212212  /* interpret format */
    213213  sprintf (field, "TFORM%d", N);
    214   fits_scan (header, field, "%s", 1, format);
    215 
    216   if (!fits_table_format (format, type, &Nval, &Nbytes)) return (FALSE);
     214  gfits_scan (header, field, "%s", 1, format);
     215
     216  if (!gfits_table_format (format, type, &Nval, &Nbytes)) return (FALSE);
    217217  strcpy (cformat, format);
    218218 
    219219  /* check existing table dimensions */
    220   fits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    221   fits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     220  gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
     221  gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
    222222
    223223  /* scan columns to find insert point */
    … …  
    225225  for (i = 1; i < N; i++) {
    226226    sprintf (field, "TFORM%d", i);
    227     fits_scan (header, field, "%s", 1, format);
    228     fits_table_format (format, tmp, &Nv, &Nb);
     227    gfits_scan (header, field, "%s", 1, format);
     228    gfits_table_format (format, tmp, &Nv, &Nb);
    229229    Nstart += Nv*Nb;
    230230  }

  • trunk/Ohana/src/libfits/table/F_read_T.c

    r7039 r7054  
    33
    44/*********************** fits read table ***********************************/
    5 int fits_read_ftable (char *filename, FTable *table, char *extname) {
     5int gfits_read_ftable (char *filename, FTable *table, char *extname) {
    66
    77  int status;
    … …  
    1111  if (f == NULL) return (FALSE);
    1212
    13   status = fits_fread_ftable (f, table, extname);
     13  status = gfits_fread_ftable (f, table, extname);
    1414  fclose (f);
    1515  return (status);
    … …  
    1717
    1818/*********************** fits read table ***********************************/
    19 int fits_fread_ftable (FILE *f, FTable *table, char *extname) {
     19int gfits_fread_ftable (FILE *f, FTable *table, char *extname) {
    2020
    2121  int j, found, Nbytes;
    … …  
    2929  for (j = -1; !found; j++) {
    3030    /* load data for this header */
    31     if (!fits_load_header (f, header)) return (FALSE);
     31    if (!gfits_load_header (f, header)) return (FALSE);
    3232
    3333    /* check if this is the correct extension or not */
    3434    bzero (tname, 80);
    35     fits_scan (header, "EXTNAME", "%s", 1, tname);
     35    gfits_scan (header, "EXTNAME", "%s", 1, tname);
    3636    if (!strcmp (tname, extname)) {
    37       if (fits_fread_ftable_data (f, table)) return (TRUE);
    38       fits_free_header (header);
     37      if (gfits_fread_ftable_data (f, table)) return (TRUE);
     38      gfits_free_header (header);
    3939      return (FALSE);
    4040    }
    4141
    4242    /* skip to next header */
    43     Nbytes = fits_matrix_size (header);
     43    Nbytes = gfits_matrix_size (header);
    4444    fseek (f, Nbytes, SEEK_CUR);
    45     fits_free_header (header);
     45    gfits_free_header (header);
    4646  }
    4747  return (TRUE);
    … …  
    4949
    5050/*********************** fits read ftable data ***********************************/
    51 int fits_fread_ftable_data (FILE *f, FTable *table) {
     51int gfits_fread_ftable_data (FILE *f, FTable *table) {
    5252
    5353  int Nbytes, Nread;
    5454
    5555  /* find buffer size */
    56   Nbytes = fits_matrix_size (table[0].header);
     56  Nbytes = gfits_matrix_size (table[0].header);
    5757  ALLOCATE (table[0].buffer, char, Nbytes);
    5858
    5959  Nread = fread (table[0].buffer, sizeof (char), Nbytes, f);
    6060  if (Nread != Nbytes) {
    61     fits_free_table  (table);
     61    gfits_free_table  (table);
    6262    return (FALSE);
    6363  }
    … …  
    6767
    6868/*********************** fits read ftable data ***********************************/
    69 int fits_fread_vtable_range (FILE *f, VTable *table, int start, int Nrows) {
     69int gfits_fread_vtable_range (FILE *f, VTable *table, int start, int Nrows) {
    7070
    7171  int i, Nbytes, Nread, Nskip, Nx, Ny;
    … …  
    7575  Nx = table[0].header[0].Naxis[0];
    7676  Ny = table[0].header[0].Naxis[1];
    77   table[0].size = fits_matrix_size (table[0].header);
     77  table[0].size = gfits_matrix_size (table[0].header);
    7878  table[0].pad = table[0].size - Nx*Ny;
    7979
    … …  
    105105
    106106/*********************** fits read virtual table ***********************************/
    107 int fits_fread_vtable (FILE *f, VTable *table, char *extname, int Nrow, int *row) {
     107int gfits_fread_vtable (FILE *f, VTable *table, char *extname, int Nrow, int *row) {
    108108
    109109  int i, j, Nbytes, Nread;
    … …  
    117117  for (j = -1; TRUE; j++) {
    118118    /* load data for this header */
    119     if (!fits_load_header (f, header)) return (FALSE);
     119    if (!gfits_load_header (f, header)) return (FALSE);
    120120
    121121    /* find buffer size */
    122     Nbytes = fits_matrix_size (header);
     122    Nbytes = gfits_matrix_size (header);
    123123
    124124    /* check if this is the correct extension or not */
    125125    bzero (tname, 80);
    126     fits_scan (header, "EXTNAME", "%s", 1, tname);
     126    gfits_scan (header, "EXTNAME", "%s", 1, tname);
    127127    if (strcmp (tname, extname)) {
    128128      /* skip to next header */
    129129      fseek (f, Nbytes, SEEK_CUR);
    130       fits_free_header (header);
     130      gfits_free_header (header);
    131131      continue;
    132132    }
    … …  
    134134    /* file pointer is at beginning of desired table data */
    135135    start = ftell (f);
    136     fits_scan (header, "NAXIS1", "%d", 1, &Nx);
    137     fits_scan (header, "NAXIS2", "%d", 1, &Ny);
     136    gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
     137    gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
    138138    for (i = 0; i < Nrow; i++) {
    139139      if (row[i] > Ny) { return (FALSE); }
    … …  
    152152    ALLOCATE (table[0].row, int, MAX (1, Nrow));   
    153153    for (i = 0; i < Nrow; i++) table[0].row[i] = row[i];
    154     table[0].size   = fits_matrix_size (table[0].header);
     154    table[0].size   = gfits_matrix_size (table[0].header);
    155155    table[0].pad    = table[0].size - Nx*Ny;
    156156    return (TRUE);
    … …  
    162162/* a poor function: read only the first table, regardless of name */
    163163/* keep until we are sure ohana code does not use it  */
    164 int fits_read_table (char *filename, FTable *table) {
     164int gfits_read_table (char *filename, FTable *table) {
    165165
    166166  FILE *f;
    … …  
    168168  int status, i, nbytes, Nbytes, matrix_size;
    169169
    170   if (!fits_read_header (filename, &header)) {
     170  if (!gfits_read_header (filename, &header)) {
    171171    fprintf (stderr, "error reading header of FITS file %s\n", filename);
    172172    return (FALSE);
    173173  }
    174174
    175   if (!fits_read_Theader (filename, &table[0].header)) {
     175  if (!gfits_read_Theader (filename, &table[0].header)) {
    176176    fprintf (stderr, "error reading Theader of FITS file %s\n", filename);
    177177    return (FALSE);
    … …  
    179179
    180180  if ((f = fopen (filename, "r")) == NULL) {
    181     fits_free_header (&header);
    182     fits_free_header (&table[0].header);
    183     return (FALSE);
    184   }
    185 
    186   matrix_size = fits_matrix_size (&header);
     181    gfits_free_header (&header);
     182    gfits_free_header (&table[0].header);
     183    return (FALSE);
     184  }
     185
     186  matrix_size = gfits_matrix_size (&header);
    187187
    188188  Nbytes = header.size + matrix_size + table[0].header.size;
    189189  fseek (f, Nbytes, 0);
    190   fits_free_header (&header);
     190  gfits_free_header (&header);
    191191 
    192   fits_scan (&table[0].header, "TFIELDS", "%d", 1, &table[0].Nfields);
     192  gfits_scan (&table[0].header, "TFIELDS", "%d", 1, &table[0].Nfields);
    193193
    194194  /* place the field sizes in the structure? */
    … …  
    198198    table[0].Naxis[i] = table[0].header.Naxis[i];
    199199
    200   Nbytes = fits_matrix_size (&table[0].header);
     200  Nbytes = gfits_matrix_size (&table[0].header);
    201201  ALLOCATE (table[0].buffer, char, Nbytes);
    202202  nbytes = fread (table[0].buffer, sizeof(char), Nbytes, f);
    … …  
    213213
    214214
    215 int fits_fread_header_extname (FILE *f, Header *header, char *extname) {
     215int gfits_fread_header_extname (FILE *f, Header *header, char *extname) {
    216216
    217217  int Nbytes;
    … …  
    219219
    220220  fseek (f, 0, SEEK_SET);
    221   fits_fread_header (f, header);
     221  gfits_fread_header (f, header);
    222222
    223223  if (!strcasecmp (extname, "PHU")) return (TRUE);
    224224
    225   Nbytes = fits_matrix_size (header);
     225  Nbytes = gfits_matrix_size (header);
    226226  fseek (f, Nbytes, SEEK_CUR);
    227227
    228   while (fits_fread_header (f, header)) {
    229     fits_scan (header, "EXTNAME", "%s", 1, current);
     228  while (gfits_fread_header (f, header)) {
     229    gfits_scan (header, "EXTNAME", "%s", 1, current);
    230230    if (!strcmp (current, extname)) return (TRUE);
    231     Nbytes = fits_matrix_size (header);
     231    Nbytes = gfits_matrix_size (header);
    232232    fseek (f, Nbytes, SEEK_CUR);
    233233  }

  • trunk/Ohana/src/libfits/table/F_read_TH.c

    r7039 r7054  
    33
    44/*********************** fits read Theader ***********************************/
    5 int fits_read_Theader (char *filename, Header *Theader) {
     5int gfits_read_Theader (char *filename, Header *Theader) {
    66 
    77  FILE *f;
    … …  
    99  int status, Nbytes;
    1010 
    11   status = fits_read_header (filename, &header);
     11  status = gfits_read_header (filename, &header);
    1212  if (!status) {
    1313    fprintf (stderr, "error reading header of FITS file %s\n", filename);
    … …  
    1818  if (f == NULL) {
    1919    Theader[0].buffer = NULL;
    20     fits_free_header (&header);
     20    gfits_free_header (&header);
    2121    return (FALSE);
    2222  }
    2323
    24   Nbytes = fits_matrix_size (&header);
     24  Nbytes = gfits_matrix_size (&header);
    2525  fseek (f, Nbytes, SEEK_SET);
    26   fits_free_header (&header);
     26  gfits_free_header (&header);
    2727
    28   status = fits_load_Theader (f, Theader);
     28  status = gfits_load_Theader (f, Theader);
    2929  fclose (f);
    3030  return (status);
    … …  
    3333/* load table from STREAM positioned at beginning of table header */
    3434/*********************** fits load Theader ***********************************/
    35 int fits_load_Theader (FILE *f, Header *Theader) {
     35int gfits_load_Theader (FILE *f, Header *Theader) {
    3636 
    3737  char *p;
    … …  
    4949    if (Nbytes != FT_RECORD_SIZE)
    5050      done = TRUE;
    51     p = fits_header_field (Theader, "END", 1);
     51    p = gfits_header_field (Theader, "END", 1);
    5252    if (p != NULL)
    5353      done = TRUE;
    … …  
    6060
    6161  status = TRUE;
    62   status &= fits_scan (Theader,  "BITPIX", "%d", 1, &Theader[0].bitpix);
    63   status &= fits_scan (Theader,  "NAXIS",  "%d", 1, &Theader[0].Naxes);
     62  status &= gfits_scan (Theader,  "BITPIX", "%d", 1, &Theader[0].bitpix);
     63  status &= gfits_scan (Theader,  "NAXIS",  "%d", 1, &Theader[0].Naxes);
    6464  if (!status) return (FALSE);
    6565                                                           
    66   fits_scan (Theader,  "NAXIS1", "%d", 1, &Theader[0].Naxis[0]);
    67   fits_scan (Theader,  "NAXIS2", "%d", 1, &Theader[0].Naxis[1]);
    68   fits_scan (Theader,  "NAXIS3", "%d", 1, &Theader[0].Naxis[2]);
    69   fits_scan (Theader,  "NAXIS4", "%d", 1, &Theader[0].Naxis[3]);
    70   fits_scan (Theader,  "NAXIS5", "%d", 1, &Theader[0].Naxis[4]);
    71   fits_scan (Theader,  "NAXIS6", "%d", 1, &Theader[0].Naxis[5]);
    72   fits_scan (Theader,  "NAXIS7", "%d", 1, &Theader[0].Naxis[6]);
    73   fits_scan (Theader,  "NAXIS8", "%d", 1, &Theader[0].Naxis[7]);
    74   fits_scan (Theader,  "NAXIS9", "%d", 1, &Theader[0].Naxis[8]);
    75   fits_scan (Theader, "NAXIS10", "%d", 1, &Theader[0].Naxis[9]);
     66  gfits_scan (Theader,  "NAXIS1", "%d", 1, &Theader[0].Naxis[0]);
     67  gfits_scan (Theader,  "NAXIS2", "%d", 1, &Theader[0].Naxis[1]);
     68  gfits_scan (Theader,  "NAXIS3", "%d", 1, &Theader[0].Naxis[2]);
     69  gfits_scan (Theader,  "NAXIS4", "%d", 1, &Theader[0].Naxis[3]);
     70  gfits_scan (Theader,  "NAXIS5", "%d", 1, &Theader[0].Naxis[4]);
     71  gfits_scan (Theader,  "NAXIS6", "%d", 1, &Theader[0].Naxis[5]);
     72  gfits_scan (Theader,  "NAXIS7", "%d", 1, &Theader[0].Naxis[6]);
     73  gfits_scan (Theader,  "NAXIS8", "%d", 1, &Theader[0].Naxis[7]);
     74  gfits_scan (Theader,  "NAXIS9", "%d", 1, &Theader[0].Naxis[8]);
     75  gfits_scan (Theader, "NAXIS10", "%d", 1, &Theader[0].Naxis[9]);
    7676
    7777  return (TRUE);
    … …  
    7979
    8080/*********************** fits fread Theader ***********************************/
    81 int fits_fread_Theader (FILE *f, Header *Theader) {
     81int gfits_fread_Theader (FILE *f, Header *Theader) {
    8282 
    8383  int status;
    8484 
    85   status = fits_load_Theader (f, Theader);
     85  status = gfits_load_Theader (f, Theader);
    8686  return (status);
    8787}

  • trunk/Ohana/src/libfits/table/F_set_column.c

    r7039 r7054  
    1313
    1414/***********************/
    15 int fits_set_bintable_column (Header *header, FTable *table, char *label, void *data, int Nrow) {
     15int gfits_set_bintable_column (Header *header, FTable *table, char *label, void *data, int Nrow) {
    1616
    1717  int i, N, Nfields, Nval, Nbytes, Nx, Ny, nbytes, Nstart, Nv, Nb;
    … …  
    2626  /* find label in header */
    2727  tlabel[0] = 0;
    28   fits_scan (header, "TFIELDS", "%d", 1, &Nfields);
     28  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    2929  for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) {
    3030    sprintf (field, "TTYPE%d", i);
    31     fits_scan (header, field, "%s", 1, tlabel);
     31    gfits_scan (header, field, "%s", 1, tlabel);
    3232  }
    3333  if (strcmp (label, tlabel)) return (FALSE);
    … …  
    3636  /* interpret format */
    3737  sprintf (field, "TSCAL%d", N);
    38   fits_scan (header, field, "%lf", 1, &Bscale);
     38  gfits_scan (header, field, "%lf", 1, &Bscale);
    3939  sprintf (field, "TZERO%d", N);
    40   fits_scan (header, field, "%lf", 1, &Bzero);
     40  gfits_scan (header, field, "%lf", 1, &Bzero);
    4141  sprintf (field, "TFORM%d", N);
    42   fits_scan (header, field, "%s", 1, format);
    43 
    44   if (!fits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE);
     42  gfits_scan (header, field, "%s", 1, format);
     43
     44  if (!gfits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE);
    4545 
    4646  /* check existing table dimensions */
    47   fits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    48   fits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     47  gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
     48  gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
    4949  if (Ny == 0) {
    5050    Ny = Nrow;
    5151    header[0].Naxis[1] = Ny;
    52     fits_modify (header, "NAXIS2",  "%d", 1, Ny);
    53 
    54     nbytes = fits_matrix_size (header);
     52    gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     53
     54    nbytes = gfits_matrix_size (header);
    5555    REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    5656    bzero (table[0].buffer, nbytes);
    … …  
    6363  for (i = 1; i < N; i++) {
    6464    sprintf (field, "TFORM%d", i);
    65     fits_scan (header, field, "%s", 1, format);
    66     fits_bintable_format (format, tmpline, &Nv, &Nb);
     65    gfits_scan (header, field, "%s", 1, format);
     66    gfits_bintable_format (format, tmpline, &Nv, &Nb);
    6767    Nstart += Nv*Nb;
    6868  }
    … …  
    153153
    154154/***********************/
    155 int fits_set_table_column (Header *header, FTable *table, char *label, void *data, int Nrow) {
     155int gfits_set_table_column (Header *header, FTable *table, char *label, void *data, int Nrow) {
    156156
    157157  int i, N, Nfields, Nval, Nbytes, Nx, Ny, nbytes, Nstart, Nv, Nb;
    … …  
    164164  /* find label in header */
    165165  tlabel[0] = 0;
    166   fits_scan (header, "TFIELDS", "%d", 1, &Nfields);
     166  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    167167  for (i = 1; strcmp (label, tlabel) && (i < Nfields + 1); i++) {
    168168    sprintf (field, "TTYPE%d", i);
    169     fits_scan (header, field, "%s", 1, tlabel);
     169    gfits_scan (header, field, "%s", 1, tlabel);
    170170  }
    171171  if (strcmp (label, tlabel)) return (FALSE);
    … …  
    174174  /* interpret format */
    175175  sprintf (field, "TFORM%d", N);
    176   fits_scan (header, field, "%s", 1, format);
    177 
    178   if (!fits_table_format (format, type, &Nval, &Nbytes)) return (FALSE);
     176  gfits_scan (header, field, "%s", 1, format);
     177
     178  if (!gfits_table_format (format, type, &Nval, &Nbytes)) return (FALSE);
    179179  strcpy (cformat, format);
    180180 
    181181  /* check existing table dimensions */
    182   fits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    183   fits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     182  gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
     183  gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
    184184  if (Ny == 0) {
    185185    Ny = Nrow;
    186186    header[0].Naxis[1] = Ny;
    187     fits_modify (header, "NAXIS2",  "%d", 1, Ny);
    188 
    189     nbytes = fits_matrix_size (header);
     187    gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     188
     189    nbytes = gfits_matrix_size (header);
    190190    REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    191191    bzero (table[0].buffer, nbytes);
    … …  
    198198  for (i = 1; i < N; i++) {
    199199    sprintf (field, "TFORM%d", i);
    200     fits_scan (header, field, "%s", 1, format);
    201     fits_table_format (format, tmp, &Nv, &Nb);
     200    gfits_scan (header, field, "%s", 1, format);
     201    gfits_table_format (format, tmp, &Nv, &Nb);
    202202    Nstart += Nv*Nb;
    203203  }

  • trunk/Ohana/src/libfits/table/F_table_column.c

    r7039 r7054  
    33
    44/*********************** fits table column ****************************/
    5 int fits_table_column (Table *table, char *field, char *mode,...) {
     5int gfits_table_column (Table *table, char *field, char *mode,...) {
    66/* we expect one more field: the pointer to the array we read in */
    77
    … …  
    1919  for (i = 0; i < table[0].Nfields; i++) {
    2020    sprintf (string, "TTYPE%d\0", i+1);
    21     fits_scan (&table[0].header, string, "%s", 1, this_field);
     21    gfits_scan (&table[0].header, string, "%s", 1, this_field);
    2222    if (!strcmp (field, this_field)) {
    2323      break;
    … …  
    3333
    3434  sprintf (string, "TBCOL%d\0", N);
    35   fits_scan (&table[0].header, string, "%d", 1, &start);
     35  gfits_scan (&table[0].header, string, "%d", 1, &start);
    3636  sprintf (string, "TFORM%d\0", N);
    37   fits_scan (&table[0].header, string, "%s", 1, form);
     37  gfits_scan (&table[0].header, string, "%s", 1, form);
    3838  /* we could use some error checking from the FITS table form, but
    3939     it is not immediately crucial */
    … …  
    4343  } else {
    4444    sprintf (string, "TBCOL%d\0", N+1);
    45     fits_scan (&table[0].header, string, "%d", 1, &end);
     45    gfits_scan (&table[0].header, string, "%d", 1, &end);
    4646  }
    4747  width = end - start;
    … …  
    8888      break;
    8989    default:
    90       fprintf (stderr, "unknown fits_table_column mode: %s\n", mode);
     90      fprintf (stderr, "unknown gfits_table_column mode: %s\n", mode);
    9191      return (FALSE);
    9292    }

  • trunk/Ohana/src/libfits/table/F_table_format.c

    r7039 r7054  
    33
    44/***********************/
    5 int fits_bintable_format (char *format, char *type, int *Nval, int *Nbytes) {
     5int gfits_bintable_format (char *format, char *type, int *Nval, int *Nbytes) {
    66
    77  char *Lchar, *Fchar;
    … …  
    5353
    5454/***********************/
    55 int fits_table_format (char *format, char *type, int *Nval, int *Nbytes) {
     55int gfits_table_format (char *format, char *type, int *Nval, int *Nbytes) {
    5656
    5757  char Fchar, Size[80], Type;
    … …  
    9090
    9191/** extract a table subset to a vtable ***/
    92 int fits_table_to_vtable (FTable *ftable, VTable *vtable, int start, int Nkeep) {
     92int gfits_table_to_vtable (FTable *ftable, VTable *vtable, int start, int Nkeep) {
    9393
    94   /* fits_table_to_vtable (f, v, 0, Ny - 1) - keep all of table
    95      fits_table_to_vtable (f, v, 0, 0)      - keep none of table
     94  /* gfits_table_to_vtable (f, v, 0, Ny - 1) - keep all of table
     95     gfits_table_to_vtable (f, v, 0, 0)      - keep none of table
    9696  */ 
    9797
    9898  int i, Nx, Ny;
    9999
    100   fits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx);
    101   fits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny);
     100  gfits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx);
     101  gfits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny);
    102102 
    103103  if (start + Nkeep > Ny) return (FALSE);
    … …  
    122122
    123123/** convert specified rows to vtable */
    124 int fits_vtable_from_ftable (FTable *ftable, VTable *vtable, int *row, int Nrow) {
     124int gfits_vtable_from_ftable (FTable *ftable, VTable *vtable, int *row, int Nrow) {
    125125
    126126  int i, N, Nx, Ny;
    127127
    128   fits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx);
    129   fits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny);
     128  gfits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx);
     129  gfits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny);
    130130
    131131  /* make empty vtable from table */
    … …  
    150150
    151151/* use table def to format a complete string */
    152 char *fits_table_print (FTable *table,...) {
     152char *gfits_table_print (FTable *table,...) {
    153153 
    154154  int i, Nx, Nfields;
    … …  
    159159  va_start (argp, table);
    160160
    161   fits_scan (table[0].header, "NAXIS1",  "%d", 1, &Nx);
    162   fits_scan (table[0].header, "TFIELDS", "%d", 1, &Nfields);
     161  gfits_scan (table[0].header, "NAXIS1",  "%d", 1, &Nx);
     162  gfits_scan (table[0].header, "TFIELDS", "%d", 1, &Nfields);
    163163
    164164  ALLOCATE (line, char, Nx + 1);
    … …  
    168168
    169169    sprintf (field, "TFORM%d", i);
    170     fits_scan (table[0].header, field, "%s", 1, format);       /* get field format */
    171     fits_table_format (format, type, &Nval, &Nbytes); /* convert to c-style */
     170    gfits_scan (table[0].header, field, "%s", 1, format);       /* get field format */
     171    gfits_table_format (format, type, &Nval, &Nbytes); /* convert to c-style */
    172172    Nchar = Nval * Nbytes;
    173173    if (!strcmp (type, "int"))   {

  • trunk/Ohana/src/libfits/table/F_table_row.c

    r7039 r7054  
    33
    44/*********************** fits table column ****************************/
    5 int fits_add_rows (FTable *table, char *data, int Nrow, int Nbytes) {
     5int gfits_add_rows (FTable *table, char *data, int Nrow, int Nbytes) {
    66
    77  int Nx, Ny;
    … …  
    1111  header = table[0].header;
    1212
    13   fits_scan (header, "NAXIS1", "%d", 1, &Nx);
    14   fits_scan (header, "NAXIS2", "%d", 1, &Ny);
     13  gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
     14  gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
    1515 
    1616  if (header[0].Naxis[1] != Ny) return (FALSE);
    … …  
    2323  Ny += Nrow;
    2424  header[0].Naxis[1] = Ny;
    25   fits_modify (header, "NAXIS2",  "%d", 1, Ny);
     25  gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
    2626
    27   nbytes = fits_matrix_size (header);
     27  nbytes = gfits_matrix_size (header);
    2828  REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    2929  table[0].size = nbytes;
    … …  
    3535
    3636/*********************** fits add (real) rows to virtual table ****************************/
    37 int fits_vadd_rows (VTable *table, char *data, int Nrow, int Nbytes) {
     37int gfits_vadd_rows (VTable *table, char *data, int Nrow, int Nbytes) {
    3838
    3939  int i, Nx, Ny;
    … …  
    4343  header = table[0].header;
    4444
    45   fits_scan (header, "NAXIS1", "%d", 1, &Nx);
    46   fits_scan (header, "NAXIS2", "%d", 1, &Ny);
     45  gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
     46  gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
    4747 
    4848  if (header[0].Naxis[1] != Ny) return (FALSE);
    … …  
    6464  Ny += Nrow;
    6565  header[0].Naxis[1] = Ny;
    66   fits_modify (header, "NAXIS2",  "%d", 1, Ny);
     66  gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
    6767
    68   table[0].size   = fits_matrix_size (table[0].header);
     68  table[0].size   = gfits_matrix_size (table[0].header);
    6969  table[0].pad    = table[0].size - Nx*Ny;
    7070
    … …  
    7373
    7474/*********************** fits table column ****************************/
    75 int fits_delete_rows (FTable *table, int Nstart, int Nrow) {
     75int gfits_delete_rows (FTable *table, int Nstart, int Nrow) {
    7676
    7777  int Nx, Ny, N0, N1, N2;
    … …  
    8181  header = table[0].header;
    8282
    83   fits_scan (header, "NAXIS1", "%d", 1, &Nx);
    84   fits_scan (header, "NAXIS2", "%d", 1, &Ny);
     83  gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
     84  gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
    8585 
    8686  if (header[0].Naxis[1] != Ny) return (FALSE);
    … …  
    9797  Ny -= Nrow;
    9898  header[0].Naxis[1] = Ny;
    99   fits_modify (header, "NAXIS2",  "%d", 1, Ny);
     99  gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
    100100
    101   nbytes = fits_matrix_size (header);
     101  nbytes = gfits_matrix_size (header);
    102102  REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    103103  table[0].size = nbytes;

  • trunk/Ohana/src/libfits/table/F_write_T.c

    r7039 r7054  
    33
    44/*********************** fits write header *********************************/
    5 int fits_write_table (char *filename, FTable *table) {
     5int gfits_write_table (char *filename, FTable *table) {
    66 
    77  FILE *f;
    … …  
    1414 
    1515  status = fseek (f, 0, SEEK_END);  /* write table to end of file! */
    16   status = fits_fwrite_table (f, table);
     16  status = gfits_fwrite_table (f, table);
    1717
    1818  fclose (f);
    … …  
    2121
    2222/*********************** fits write table *********************************/
    23 int fits_fwrite_table (FILE *f, FTable *table) {
     23int gfits_fwrite_table (FILE *f, FTable *table) {
    2424 
    2525  int Nbytes;
    … …  
    3232
    3333/*********************** fits write virtual table *********************************/
    34 int fits_fwrite_vtable (FILE *f, VTable *table) {
     34int gfits_fwrite_vtable (FILE *f, VTable *table) {
    3535 
    3636  int i, Nx, Ny, Npad, offset, start;
    … …  
    4040  Nrow = table[0].Nrow;
    4141  row = table[0].row;
    42   fits_scan (table[0].header, "NAXIS1", "%d", 1, &Nx);
    43   fits_scan (table[0].header, "NAXIS2", "%d", 1, &Ny);
     42  gfits_scan (table[0].header, "NAXIS1", "%d", 1, &Nx);
     43  gfits_scan (table[0].header, "NAXIS2", "%d", 1, &Ny);
    4444
    4545  /* file pointer is at beginning of desired table data */

  • trunk/Ohana/src/libfits/table/F_write_TH.c

    r7039 r7054  
    33
    44/*********************** fits write header *********************************/
    5 int fits_write_Theader (char *filename, Header *header) {
     5int gfits_write_Theader (char *filename, Header *header) {
    66 
    77  FILE *f;
    … …  
    1414 
    1515  status = fseek (f, 0, SEEK_END);  /* write header to end of file! */
    16   status = fits_fwrite_Theader (f, header);
     16  status = gfits_fwrite_Theader (f, header);
    1717
    1818  fclose (f);
    … …  
    2121
    2222/*********************** fits write header *********************************/
    23 int fits_fwrite_Theader (FILE *f, Header *header) {
     23int gfits_fwrite_Theader (FILE *f, Header *header) {
    2424 
    2525  int Nbytes;
Note: See TracChangeset for help on using the changeset viewer.