IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 15312


Ignore:
Timestamp:
Oct 14, 2007, 1:54:24 PM (19 years ago)
Author:
eugene
Message:

cleanup libfits header, some apis (gfits_matrix_size to gfits_data_size), adding bits for reading compressed images

Location:
branches/eam_branch_20071015/Ohana/src
Files:
2 added
35 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branch_20071015/Ohana/src/addstar/src/LoadStars.c

    r15275 r15312  
    102102
    103103    // advance to the next header
    104     Nskip = gfits_matrix_size (headers[i]);
     104    Nskip = gfits_data_size (headers[i]);
    105105    fseek (f, Nskip, SEEK_CUR);
    106106    if (i == NHEADERS - 1) {
    … …  
    139139      extsize[0][i] = headers[i][0].size;
    140140    } else {
    141       extsize[0][i] = headers[i][0].size + gfits_matrix_size (headers[i]);
     141      extsize[0][i] = headers[i][0].size + gfits_data_size (headers[i]);
    142142    }
    143143    gfits_scan (headers[i], "EXTTYPE", "%s", 1, exttype);
    … …  
    181181  // extension matched to the header in the PHU
    182182  if (Nimage == 0) {
    183     extsize[0][0] = headers[0][0].size + gfits_matrix_size (headers[0]);
    184     extsize[0][1] = headers[1][0].size + gfits_matrix_size (headers[1]);
     183    extsize[0][0] = headers[0][0].size + gfits_data_size (headers[0]);
     184    extsize[0][1] = headers[1][0].size + gfits_data_size (headers[1]);
    185185    gfits_scan (headers[1], ExtnameKeyword, "%s", 1, extname);
    186186    if (!strcmp (extname, "SMPFILE")) {

  • branches/eam_branch_20071015/Ohana/src/gastro2/src/gstars2.c

    r14590 r15312  
    128128  gfits_scan (&Target[0].header, "NAXIS",  "%t", 1, &naxis);
    129129  if ((naxis == 0) && !TEXTMODE) {
    130     Nskip = gfits_matrix_size (&Target[0].header);
     130    Nskip = gfits_data_size (&Target[0].header);
    131131    fseek (f, Nskip, SEEK_CUR);
    132132    stars = rfits (f, &Nstars);

  • branches/eam_branch_20071015/Ohana/src/getstar/src/ReadImageFiles.c

    r15275 r15312  
    8787  // the first header is already loaded
    8888  headers[0] = header;
    89   Nskip = gfits_matrix_size (header);
     89  Nskip = gfits_data_size (header);
    9090  fseek (f, Nskip, SEEK_CUR);
    9191
    … …  
    9898          done = TRUE;
    9999      } else {
    100           Nskip = gfits_matrix_size (headers[i]);
     100          Nskip = gfits_data_size (headers[i]);
    101101          fseek (f, Nskip, SEEK_CUR);
    102102      }
    … …  
    129129  // now examine the headers, count the table entries, find corresponding headers
    130130  for (i = 0; i < Nheader; i++) {
    131       extsize[i] = headers[i][0].size + gfits_matrix_size (headers[i]);
     131      extsize[i] = headers[i][0].size + gfits_data_size (headers[i]);
    132132      gfits_scan (headers[i], "EXTTYPE", "%s", 1, tmpword);
    133133
    … …  
    163163  // extension matched to the header in the PHU
    164164  if (Nimage == 0) {
    165       extsize[0] = headers[0][0].size + gfits_matrix_size (headers[0]);
    166       extsize[1] = headers[1][0].size + gfits_matrix_size (headers[1]);
     165      extsize[0] = headers[0][0].size + gfits_data_size (headers[0]);
     166      extsize[1] = headers[1][0].size + gfits_data_size (headers[1]);
    167167      gfits_scan (headers[1], "EXTNAME", "%s", 1, tmpword);
    168168      if (!strcmp (tmpword, "SMPFILE")) {

  • branches/eam_branch_20071015/Ohana/src/imregister/imphot/rtext.c

    r7080 r15312  
    4343  gfits_modify (&db[0].theader, "NAXIS2", "%d", 1, Nimage);
    4444  db[0].theader.Naxis[1] = Nimage;
    45   db[0].ftable.size = gfits_matrix_size (&db[0].theader);
     45  db[0].ftable.size = gfits_data_size (&db[0].theader);
    4646 
    4747  return (TRUE);

  • branches/eam_branch_20071015/Ohana/src/libdvo/src/dvo_catalog_mef.c

    r12391 r15312  
    5151    }
    5252  } else {
    53     Nbytes = gfits_matrix_size (&header);
     53    Nbytes = gfits_data_size (&header);
    5454    fseek (f, Nbytes, SEEK_CUR);
    5555  }
    … …  
    7373    }
    7474  } else {
    75     Nbytes = gfits_matrix_size (&header);
     75    Nbytes = gfits_data_size (&header);
    7676    fseek (f, Nbytes, SEEK_CUR);
    7777  }
    … …  
    9494    }
    9595  } else {
    96     Nbytes = gfits_matrix_size (&header);
     96    Nbytes = gfits_data_size (&header);
    9797    fseek (f, Nbytes, SEEK_CUR);
    9898  }
    … …  
    139139  } else {
    140140    /* no real need to skip the data array here... */
    141     Nbytes = gfits_matrix_size (&header);
     141    Nbytes = gfits_data_size (&header);
    142142    fseek (f, Nbytes, SEEK_CUR);
    143143    if (primary != NULL) free (primary);

  • branches/eam_branch_20071015/Ohana/src/libdvo/src/dvo_catalog_split.c

    r13325 r15312  
    585585
    586586    /* skip past matrix (already at end of header) */
    587     Nskip = gfits_matrix_size (&catalog[0].header);
     587    Nskip = gfits_data_size (&catalog[0].header);
    588588    fseek (catalog[0].f, Nskip, SEEK_CUR);
    589589
    … …  
    615615
    616616    /* skip past PHU header and matrix */
    617     Nskip = catfile[0].header.size + gfits_matrix_size (&catfile[0].header);
     617    Nskip = catfile[0].header.size + gfits_data_size (&catfile[0].header);
    618618    fseek (catfile[0].f, Nskip, SEEK_SET);
    619619
    … …  
    642642    header.Naxis[1] = Nlines;
    643643
    644     vtable.size = gfits_matrix_size (&header);
     644    vtable.size = gfits_data_size (&header);
    645645    vtable.Nrow = Nout;
    646646    vtable.pad = vtable.size - Nx*Ny;
    … …  
    705705
    706706    /* skip past PHU header and matrix */
    707     Nskip = catfile[0].header.size + gfits_matrix_size (&catfile[0].header);
     707    Nskip = catfile[0].header.size + gfits_data_size (&catfile[0].header);
    708708    fseek (catfile[0].f, Nskip, SEEK_SET);
    709709

  • branches/eam_branch_20071015/Ohana/src/libdvo/src/dvo_convert.c

    r15275 r15312  
    245245    gfits_modify (theader, "NAXIS2", "%d", 1, Nimage);
    246246    theader[0].Naxis[1] = Nimage;
    247     ftable[0].size = gfits_matrix_size (theader);
     247    ftable[0].size = gfits_data_size (theader);
    248248    return (TRUE);
    249249  }
    … …  
    266266    gfits_modify (theader, "NAXIS2", "%d", 1, Nimage); \
    267267    theader[0].Naxis[1] = Nimage; \
    268     ftable[0].size = gfits_matrix_size (theader); \
     268    ftable[0].size = gfits_data_size (theader); \
    269269    return (TRUE); }
    270270
    … …  
    344344      gfits_modify (theader, "NAXIS2", "%d", 1, Nimage); \
    345345      theader[0].Naxis[1] = Nimage; \
    346       vtable[0].size = gfits_matrix_size (theader); \
     346      vtable[0].size = gfits_data_size (theader); \
    347347      return (TRUE); }
    348348

  • branches/eam_branch_20071015/Ohana/src/libdvo/src/dvo_image_raw.c

    r15275 r15312  
    8888  gfits_modify (&db[0].theader, "NAXIS2", "%d", 1, Nimage);
    8989  db[0].theader.Naxis[1] = Nimage;
    90   db[0].ftable.size = gfits_matrix_size (&db[0].theader);
     90  db[0].ftable.size = gfits_data_size (&db[0].theader);
    9191  db[0].swapped = FALSE;  /* table does not have internal byte-order */
    9292  return (TRUE);

  • branches/eam_branch_20071015/Ohana/src/libdvo/src/fits_db.c

    r13182 r15312  
    126126    }
    127127  } else {
    128     Nskip = gfits_matrix_size (&db[0].header);
     128    Nskip = gfits_data_size (&db[0].header);
    129129    Fseek (db[0].f, Nskip, SEEK_CUR);
    130130  }

  • branches/eam_branch_20071015/Ohana/src/libfits/doc/notes-compress.txt

    r15275 r15312  
     1
     2TFORMn : rPt(e_max)
     3r is 0, 1, or absent
     4P is literal
     5t is datatype character for binary tables
     6e_max is the largest record in the column
     7
     8data column actually contains: 2 32bit values:
     9Length + Offset
     10
     11THEAP : offset from start of data to start of heap
     12(note that the heap starts at NAXIS1 x NAXIS2, not Nx2880 bytes).
     13
     14total size of heap segment (gap + heap data) is PCOUNT
    115
    216I need to implement (at least) support for read of compressed images.
    … …  
    1630    level ones as needed.
    1731
    18 * possible needed APIs:
     32* possible needed APIs & upgrades:
    1933
    2034  - gfits_image_is_compressed (Header *header)
    … …  
    3044    compress the given image returning the table data
    3145
     46  o include PCOUNT in data area size (gfits_matrix_size)
    3247
     48  o read heap when reading table (gfits_fread_table_data)
     49
     50  - void *gfits_varlength_column_pointer (FTable *ftable, VarLengthColumn *column, int row);
     51
     52  o int gfits_varlength_column_define (FTable *ftable, VarLengthColumn *def, int column);
     53
     54

  • branches/eam_branch_20071015/Ohana/src/libfits/header/F_create_H.c

    r7054 r15312  
    2222                                       
    2323  for (i = 0; i < header[0].Naxes; i++) {
    24     sprintf (axis, "NAXIS%d", i + 1);
     24    snprintf (axis, 10, "NAXIS%d", i + 1);
    2525    gfits_modify (header,  axis, "%d", 1, header[0].Naxis[i]);
    2626  }

  • branches/eam_branch_20071015/Ohana/src/libfits/header/F_read_H.c

    r12902 r15312  
    7676  gfits_scan (header, "NAXIS10", "%d", 1, &header[0].Naxis[9]);
    7777
     78  // XXX what about GCOUNT???
     79  if (!gfits_scan (header, "PCOUNT",  "%d", 1, &header[0].pcount)) {
     80    header[0].pcount = 0;
     81  }
     82
    7883  return (TRUE);
    7984

  • branches/eam_branch_20071015/Ohana/src/libfits/header/F_read_XH.c

    r13145 r15312  
    4545    }
    4646
    47     Nmatrix = gfits_matrix_size (&theader);
     47    Nmatrix = gfits_data_size (&theader);
    4848
    4949    /* skip to next header */

  • branches/eam_branch_20071015/Ohana/src/libfits/include/gfitsio.h

    r15275 r15312  
    4848  int                     Naxis[FT_MAX_NAXES];
    4949  int                     size;
     50  int                     pcount;
     51  int                     gcount;
    5052  double                  bzero;
    5153  double                  bscale;
    … …  
    8486} VTable;
    8587
     88typedef struct {
     89  int  length;
     90  int  offset;
     91  int  maxlen;
     92  int  nbytes;
     93  char format;
     94} VarLengthColumn;
     95
    8696# ifndef PROTO
    8797# define PROTO(A) A
    8898# endif
    8999
    90 char *gfits_version                PROTO(());
     100char   *gfits_version                  PROTO((void));
    91101
    92102/******************************* Header functions *************/
    93 int   gfits_read_header            PROTO((char *, Header *));
    94 // int   fits_copy_header            PROTO((Header *, Header *));
    95 int   gfits_copy_header           PROTO((Header *, Header *));
    96 void  gfits_free_header            PROTO((Header *));
    97 int   gfits_write_header           PROTO((char *, Header *));
    98 int   gfits_create_header          PROTO((Header *));
    99 int   gfits_delete                 PROTO((Header *, char *, int));
    100 char *gfits_header_field           PROTO((Header *, char *, int));
    101 int   gfits_read_Xheader           PROTO((char *filename, Header *header, int N));
    102 int   gfits_fread_Xheader          PROTO((FILE *f, Header *header, int N));
    103 int   gfits_load_header            PROTO((FILE *f, Header *header));
    104103
    105 int   gfits_fread_header           PROTO((FILE *, Header *));
    106 int   gfits_fread_Theader          PROTO((FILE *, Header *));
    107 int   gfits_fread_ftable           PROTO((FILE *, FTable *, char *));
    108 int   gfits_fread_vtable_range     PROTO((FILE *f, VTable *table, int start, int Nrows));
    109 int   gfits_fread_vtable           PROTO((FILE *f, VTable *table, char *extname, int Nrow, int *row));
    110 int   gfits_fread_ftable_data      PROTO((FILE *f, FTable *table));
    111 int   gfits_fwrite_header          PROTO((FILE *, Header *));
    112 int   gfits_fwrite_Theader         PROTO((FILE *, Header *));
    113 int   gfits_fwrite_matrix          PROTO((FILE *, Matrix *));     
    114 int   gfits_fwrite_table           PROTO((FILE *, FTable *));
    115 int   gfits_fwrite_vtable          PROTO((FILE *, VTable *));
    116 
    117 int   gfits_matrix_size            PROTO ((Header *));
    118 int   gfits_init_header            PROTO ((Header *));
    119 int   gfits_get_unsign_mode        PROTO (());
    120 int   gfits_set_unsign_mode        PROTO ((int mode));
    121 int   gfits_create_table_header    PROTO ((Header *, char *, char *));
    122 int   gfits_vtable_from_ftable     PROTO ((FTable *ftable, VTable *vtable, int *row, int Nrow));
    123 int   gfits_table_to_vtable        PROTO ((FTable *ftable, VTable *vtable, int start, int Nkeep));
    124 int   gfits_create_table           PROTO ((Header *, FTable *));
    125 int   gfits_vadd_rows              PROTO ((VTable *, char *, int, int));
    126 int   gfits_add_rows               PROTO ((FTable *, char *, int, int));
    127 char *gfits_table_print            PROTO ((FTable *,...));
    128 int   gfits_table_scale_data       PROTO ((FTable *ftable));
    129 int   gfits_table_scale_storage    PROTO ((FTable *ftable));
     104char   *gfits_header_field             PROTO((Header *header, char *field, int N));
     105char   *gfits_keyword_end              PROTO((char *line));
     106int     gfits_copy_header              PROTO((Header *in, Header *out));
     107int     gfits_create_header            PROTO((Header *header));
     108int     gfits_delete_field             PROTO((Header *header, char *field, int N));
     109int     gfits_fread_Xheader            PROTO((FILE *f, Header *header, int N));
     110int     gfits_fread_header             PROTO((FILE *f, Header *header));
     111void    gfits_free_header              PROTO((Header *header));
     112int     gfits_fwrite_header            PROTO((FILE *f, Header *header));
     113int     gfits_get_unsign_mode          PROTO((void));
     114int     gfits_init_header              PROTO((Header *header));
     115int     gfits_load_header              PROTO((FILE *f, Header *header));
     116int     gfits_modify                   PROTO((Header *header, char *field, char *mode, int N,...));
     117int     gfits_print                    PROTO((Header *header, char *field, char *mode, int N,...));
     118int     gfits_read_Xheader             PROTO((char *filename, Header *header, int N));
     119int     gfits_read_header              PROTO((char *filename, Header *header));
     120int     gfits_save_header              PROTO((FILE *f, Header *header));
     121int     gfits_scan                     PROTO((Header *header, char *field, char *mode, int N,...));
     122int     gfits_set_unsign_mode          PROTO((int mode));
     123int     gfits_stripwhite               PROTO((char *string));
     124int     gfits_vscan                    PROTO((Header *header, char *field, char *mode, int N, va_list argp));
     125int     gfits_write_header             PROTO((char *filename, Header *header));
     126int     gfits_matrix_size              PROTO((Header *header));
    130127
    131128/******************************* Matrix functions *************/
    132 int   gfits_read_matrix            PROTO((char *, Matrix *));     
    133 int   gfits_read_portion           PROTO((char *filename, Matrix *matrix, int Nskip, int Npix));
    134 void  gfits_free_matrix            PROTO((Matrix *));
    135 int   gfits_copy_matrix            PROTO((Matrix *, Matrix *));
    136 int   gfits_write_matrix           PROTO((char *,Matrix *));
    137 int   gfits_create_matrix          PROTO((Header *, Matrix *));
    138 double  gfits_get_matrix_value     PROTO((Matrix *, int, int));
    139 void  gfits_set_matrix_value       PROTO((Matrix *, int, int, double));
    140 void  gfits_add_matrix_value       PROTO((Matrix *, int, int, double));
    141 int   gfits_multiply_matrix        PROTO((Matrix *, Matrix *, Matrix *));
    142 int   gfits_divide_matrix          PROTO((Matrix *, Matrix *, Matrix *));
    143 void  gfits_insert_array           PROTO((Matrix *, Matrix *, int, int));
    144 int   gfits_load_matrix            PROTO((FILE *f, Matrix *matrix, Header *header));
    145 int   gfits_fread_matrix           PROTO((FILE *f, Matrix *matrix, Header *header));
    146 int   gfits_read_matrix_segment    PROTO((char *filename, Matrix *matrix, char *region));
    147 int   gfits_fread_matrix_segment   PROTO((FILE *f, Matrix *matrix, Header *header, char *region));
    148 int   gfits_convert_format         PROTO((Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int outUnsign));
     129
     130void    gfits_add_matrix_value         PROTO((Matrix *matrix, int x, int y, double value));
     131int     gfits_convert_format           PROTO((Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int outUnsign));
     132int     gfits_copy_matrix              PROTO((Matrix *in, Matrix *out));
     133int     gfits_create_matrix            PROTO((Header *header, Matrix *matrix));
     134int     gfits_divide_matrix            PROTO((Matrix *M1, Matrix *M2, Matrix *M3));
     135int     gfits_fread_matrix             PROTO((FILE *f, Matrix *matrix, Header *header));
     136int     gfits_fread_matrix_segment     PROTO((FILE *f, Matrix *matrix, Header *header, char *region));
     137void    gfits_free_matrix              PROTO((Matrix *matrix));
     138int     gfits_fwrite_matrix            PROTO((FILE *f, Matrix *matrix));     
     139double  gfits_get_matrix_value         PROTO((Matrix *matrix, int x, int y));
     140void    gfits_insert_array             PROTO((Matrix *matrix, Matrix *array, int x, int y));
     141int     gfits_load_matrix              PROTO((FILE *f, Matrix *matrix, Header *header));
     142int     gfits_multiply_matrix          PROTO((Matrix *M1, Matrix *M2, Matrix *M3));
     143int     gfits_read_matrix              PROTO((char *filename, Matrix *matrix));     
     144int     gfits_read_matrix_segment      PROTO((char *filename, Matrix *matrix, char *region));
     145int     gfits_read_portion             PROTO((char *filename, Matrix *matrix, int Nskip, int Npix));
     146void    gfits_set_matrix_value         PROTO((Matrix *matrix, int x, int y, double value));
     147int     gfits_write_matrix             PROTO((char *filename, Matrix *matrix));
    149148
    150149/******************************* Table functions *************/
    151 int   gfits_load_Theader           PROTO((FILE *f, Header *Theader));
    152 int   gfits_read_Theader           PROTO((char *, Header *));     
    153 int   gfits_read_table             PROTO((char *, FTable *));
    154 int   gfits_read_table             PROTO((char *, FTable *));
    155 int   gfits_write_Theader          PROTO((char *, Header *header));
    156 int   gfits_write_table            PROTO((char *, FTable *));
    157 int   gfits_fwrite_table           PROTO((FILE *f, FTable *table));
    158 int   gfits_fwrite_vtable          PROTO((FILE *f, VTable *table));
    159150
    160 int   gfits_bintable_format        PROTO((char *, char *, int *, int *));
    161 int   gfits_table_format           PROTO((char *, char *, int *, int *));
    162 int   gfits_save_header            PROTO((FILE *, Header *header));
    163 int   gfits_set_bintable_column    PROTO((Header *header, FTable *table, char *, void *, int));
    164 int   gfits_set_table_column       PROTO((Header *header, FTable *table, char *, void *, int));
    165 int   gfits_define_bintable_column PROTO((Header *header, char *, char *, char *, char *, double, double));
    166 int   gfits_define_table_column    PROTO((Header *header, char *, char *, char *, char *));
    167 int   gfits_read_ftable            PROTO((char *filename, FTable *table, char *extname));
     151char   *gfits_table_print              PROTO((FTable *ftable,...));
     152int     gfits_add_rows                 PROTO((FTable *ftable, char *data, int Nrow, int Nbytes));
     153int     gfits_bintable_format          PROTO((char *format, char *type, int *Nval, int *Nbytes));
     154int     gfits_create_table             PROTO((Header *header, FTable *ftable));
     155int     gfits_create_table_header      PROTO((Header *header, char *type, char *extname));
     156int     gfits_define_bintable_column   PROTO((Header *header, char *format, char *label, char *comment, char *unit, double bscale, double bzero));
     157int     gfits_define_table_column      PROTO((Header *header, char *format, char *label, char *comment, char *unit));
     158int     gfits_fread_ftable             PROTO((FILE *f, FTable *ftable, char *extname));
     159int     gfits_fread_ftable_data        PROTO((FILE *f, FTable *ftable));
     160int     gfits_fread_vtable             PROTO((FILE *f, VTable *vtable, char *extname, int Nrow, int *row));
     161int     gfits_fread_vtable_range       PROTO((FILE *f, VTable *vtable, int start, int Nrows));
     162int     gfits_free_table               PROTO((FTable *ftable));
     163int     gfits_free_vtable              PROTO((VTable *vtable));
     164int     gfits_fwrite_table             PROTO((FILE *f, FTable *table));
     165int     gfits_fwrite_vtable            PROTO((FILE *f, VTable *table));
     166int     gfits_get_bintable_column      PROTO((Header *header, FTable *table, char *label, void **data));
     167int     gfits_get_bintable_column_type PROTO((Header *header, char *label, char *type, int *Nval));
     168int     gfits_get_table_column         PROTO((Header *header, FTable *table, char *label, void **data));
     169int     gfits_get_table_column_type    PROTO((Header *header, char *label, char *type));
     170int     gfits_read_ftable              PROTO((char *filename, FTable *table, char *extname));
     171int     gfits_read_table               PROTO((char *filename, FTable *ftable));
     172int     gfits_set_bintable_column      PROTO((Header *header, FTable *table, char *label, void *data, int Nrow));
     173int     gfits_set_table_column         PROTO((Header *header, FTable *table, char *label, void *data, int Nrow));
     174int     gfits_table_column             PROTO((FTable *ftable, char *field, char *mode,...));
     175int     gfits_table_format             PROTO((char *format, char *type, int *Nval, int *Nbytes));
     176int     gfits_table_scale_data         PROTO((FTable *ftable));
     177int     gfits_table_scale_storage      PROTO((FTable *ftable));
     178int     gfits_table_to_vtable          PROTO((FTable *ftable, VTable *vtable, int start, int Nkeep));
     179int     gfits_vadd_rows                PROTO((VTable *vtable, char *data, int Nrow, int Nbytes));
     180int     gfits_vtable_from_ftable       PROTO((FTable *ftable, VTable *vtable, int *row, int Nrow));
     181int     gfits_write_table              PROTO((char *filename, FTable *ftable));
    168182
    169 int   gfits_free_table             PROTO((FTable *table));
    170 int   gfits_free_vtable            PROTO((VTable *table));
    171 int   gfits_create_Theader         PROTO((Header *header, char *type));
    172 
    173 /* prototyping demanded for these four -- could be a problem on non-ANSI comp comp */
    174 int   gfits_scan                   PROTO((Header *, char *, char *, int,...));
    175 int   gfits_print                  PROTO((Header *, char *, char *, int,...));
    176 int   gfits_modify                 PROTO((Header *, char *, char *, int,...));
    177 int   gfits_table_column           PROTO((FTable *, char *, char *,...));
    178 int   gfits_table_column           PROTO((FTable *table, char *, char *,...));
    179 
    180 char *gfits_keyword_end            PROTO((char *line));
    181 int   gfits_vscan                  PROTO((Header *header, char *field, char *mode, int N, va_list argp));
    182 int   gfits_scan                   PROTO((Header *header, char *field, char *mode, int N,...));
    183 int   gfits_stripwhite             PROTO((char *string));
    184 int   gfits_matrix_size            PROTO((Header *header));
    185 
    186 int   gfits_get_bintable_column_type PROTO((Header *header, char *label, char *type, int *Nval));
    187 int   gfits_get_bintable_column    PROTO((Header *header, FTable *table, char *label, void **data));
    188 int   gfits_get_table_column_type  PROTO((Header *header, char *label, char *type));
    189 int   gfits_get_table_column       PROTO((Header *header, FTable *table, char *label, void **data));
     183int     gfits_create_Theader           PROTO((Header *header, char *type));
     184int     gfits_fread_Theader            PROTO((FILE *f, Header *header));
     185int     gfits_fwrite_Theader           PROTO((FILE *f, Header *header));
     186int     gfits_load_Theader             PROTO((FILE *f, Header *header));
     187int     gfits_read_Theader             PROTO((char *filename, Header *header));     
     188int     gfits_write_Theader            PROTO((char *filename, Header *header));
    190189
    191190#endif /* FITSIO */

  • branches/eam_branch_20071015/Ohana/src/libfits/matrix/F_convert_format.c

    r7054 r15312  
    4949  matrix[0].bzero  = header[0].bzero  = outZero;
    5050  matrix[0].unsign = header[0].unsign = outUnsign;
    51   matrix[0].size   = gfits_matrix_size (header);
     51  matrix[0].size   = gfits_data_size (header);
    5252  gfits_modify (header, "BITPIX", "%d", 1, outBitpix);
    5353  gfits_modify (header, "BSCALE", "%lf", 1, outScale);

  • branches/eam_branch_20071015/Ohana/src/libfits/matrix/F_create_M.c

    r7054 r15312  
    1818    matrix[0].Naxis[i] = header[0].Naxis[i];
    1919
    20   Nbytes = gfits_matrix_size (header);
     20  Nbytes = gfits_data_size (header);
    2121  ALLOCATE (matrix[0].buffer, char, MAX (Nbytes, 1));
    2222  bzero (matrix[0].buffer, Nbytes);

  • branches/eam_branch_20071015/Ohana/src/libfits/matrix/F_get_M_value.c

    r7054 r15312  
    33
    44/***************** fits get matrix value ***********************************/
    5 double gfits_get_matrix_value (matrix, x, y)
    6 Matrix *matrix;
    7 int x, y;
    8 {
     5double gfits_get_matrix_value (Matrix *matrix, int x, int y) {
    96
    107  double value;

  • branches/eam_branch_20071015/Ohana/src/libfits/matrix/F_insert_M.c

    r7054 r15312  
    33
    44/*********************** fits insert array ***********************************/
    5 void gfits_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 */

  • branches/eam_branch_20071015/Ohana/src/libfits/matrix/F_load_M.c

    r7054 r15312  
    2525    matrix[0].Naxis[i] = header[0].Naxis[i];
    2626
    27   Nbytes = gfits_matrix_size (header);
     27  Nbytes = gfits_data_size (header);
    2828  ALLOCATE (matrix[0].buffer, char, Nbytes);
    2929  matrix[0].size = Nbytes;

  • branches/eam_branch_20071015/Ohana/src/libfits/matrix/F_matrix.c

    r7054 r15312  
    22# include <gfitsio.h>
    33
    4 int gfits_matrix_size (Header *header) {
     4int gfits_data_size (Header *header) {
    55 
    66  int i, Nrec, size;
    … …  
    1313    size *= header[0].Naxis[i];
    1414
     15  // XXX do I multiply this times gcount?
     16  size += header[0].pcount;
     17
    1518  /* round up to next complete block */
    1619  if (size % FT_RECORD_SIZE) {

  • branches/eam_branch_20071015/Ohana/src/libfits/matrix/F_set_M_value.c

    r7054 r15312  
    33
    44/****************** fits set matrix value ***********************************/
    5 void gfits_set_matrix_value (matrix, x, y, Value)
    6 Matrix *matrix;
    7 int x, y;
    8 double Value;
    9 {
     5void gfits_set_matrix_value (Matrix *matrix, int x, int y, double Value) {
    106
    117  int pixel;

  • branches/eam_branch_20071015/Ohana/src/libfits/table/F_create_T.c

    r7054 r15312  
    1212  table[0].header = header;
    1313 
    14   Nbytes = gfits_matrix_size (header);
     14  Nbytes = gfits_data_size (header);
    1515  ALLOCATE (table[0].buffer, char, MAX (Nbytes, 1));
    1616  if (!strcmp (type, "TABLE")) {
    … …  
    3737  Nx = table[0].header[0].Naxis[0];
    3838  Ny = table[0].header[0].Naxis[0];
    39   table[0].size = gfits_matrix_size (header);
     39  table[0].size = gfits_data_size (header);
    4040  table[0].pad = table[0].size - Nx*Ny;
    4141 

  • branches/eam_branch_20071015/Ohana/src/libfits/table/F_read_T.c

    r7054 r15312  
    4141
    4242    /* skip to next header */
    43     Nbytes = gfits_matrix_size (header);
     43    Nbytes = gfits_data_size (header);
    4444    fseek (f, Nbytes, SEEK_CUR);
    4545    gfits_free_header (header);
    … …  
    5454
    5555  /* find buffer size */
    56   Nbytes = gfits_matrix_size (table[0].header);
     56  Nbytes = gfits_data_size (table[0].header);
    5757  ALLOCATE (table[0].buffer, char, Nbytes);
    5858
    … …  
    7575  Nx = table[0].header[0].Naxis[0];
    7676  Ny = table[0].header[0].Naxis[1];
    77   table[0].size = gfits_matrix_size (table[0].header);
     77  table[0].size = gfits_data_size (table[0].header);
    7878  table[0].pad = table[0].size - Nx*Ny;
    7979
    … …  
    120120
    121121    /* find buffer size */
    122     Nbytes = gfits_matrix_size (header);
     122    Nbytes = gfits_data_size (header);
    123123
    124124    /* check if this is the correct extension or not */
    … …  
    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   = gfits_matrix_size (table[0].header);
     154    table[0].size   = gfits_data_size (table[0].header);
    155155    table[0].pad    = table[0].size - Nx*Ny;
    156156    return (TRUE);
    157157  }
    158158}       
    159 
    160 # if (0)
    161 /*********************** fits read table ***********************************/
    162 /* a poor function: read only the first table, regardless of name */
    163 /* keep until we are sure ohana code does not use it  */
    164 int gfits_read_table (char *filename, FTable *table) {
    165 
    166   FILE *f;
    167   Header header;
    168   int status, i, nbytes, Nbytes, matrix_size;
    169 
    170   if (!gfits_read_header (filename, &header)) {
    171     fprintf (stderr, "error reading header of FITS file %s\n", filename);
    172     return (FALSE);
    173   }
    174 
    175   if (!gfits_read_Theader (filename, &table[0].header)) {
    176     fprintf (stderr, "error reading Theader of FITS file %s\n", filename);
    177     return (FALSE);
    178   }
    179 
    180   if ((f = fopen (filename, "r")) == NULL) {
    181     gfits_free_header (&header);
    182     gfits_free_header (&table[0].header);
    183     return (FALSE);
    184   }
    185 
    186   matrix_size = gfits_matrix_size (&header);
    187 
    188   Nbytes = header.size + matrix_size + table[0].header.size;
    189   fseek (f, Nbytes, 0);
    190   gfits_free_header (&header);
    191  
    192   gfits_scan (&table[0].header, "TFIELDS", "%d", 1, &table[0].Nfields);
    193 
    194   /* place the field sizes in the structure? */
    195   table[0].bitpix = table[0].header.bitpix;
    196   table[0].Naxes  = table[0].header.Naxes;
    197   for (i = 0; i < FT_MAX_NAXES; i++)
    198     table[0].Naxis[i] = table[0].header.Naxis[i];
    199 
    200   Nbytes = gfits_matrix_size (&table[0].header);
    201   ALLOCATE (table[0].buffer, char, Nbytes);
    202   nbytes = fread (table[0].buffer, sizeof(char), Nbytes, f);
    203   if (nbytes != Nbytes) {
    204     fprintf (stderr, "error reading in table data from FITS file %s\n", filename);
    205     fclose (f);
    206     return (FALSE);
    207   }
    208   table[0].size = Nbytes;
    209   fclose (f);
    210   return (TRUE);
    211 }
    212 # endif
    213 
    214159
    215160int gfits_fread_header_extname (FILE *f, Header *header, char *extname) {
    … …  
    223168  if (!strcasecmp (extname, "PHU")) return (TRUE);
    224169
    225   Nbytes = gfits_matrix_size (header);
     170  Nbytes = gfits_data_size (header);
    226171  fseek (f, Nbytes, SEEK_CUR);
    227172
    … …  
    229174    gfits_scan (header, "EXTNAME", "%s", 1, current);
    230175    if (!strcmp (current, extname)) return (TRUE);
    231     Nbytes = gfits_matrix_size (header);
     176    Nbytes = gfits_data_size (header);
    232177    fseek (f, Nbytes, SEEK_CUR);
    233178  }

  • branches/eam_branch_20071015/Ohana/src/libfits/table/F_read_TH.c

    r7054 r15312  
    2222  }
    2323
    24   Nbytes = gfits_matrix_size (&header);
     24  Nbytes = gfits_data_size (&header);
    2525  fseek (f, Nbytes, SEEK_SET);
    2626  gfits_free_header (&header);

  • branches/eam_branch_20071015/Ohana/src/libfits/table/F_set_column.c

    r7054 r15312  
    5252    gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
    5353
    54     nbytes = gfits_matrix_size (header);
     54    nbytes = gfits_data_size (header);
    5555    REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    5656    bzero (table[0].buffer, nbytes);
    … …  
    187187    gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
    188188
    189     nbytes = gfits_matrix_size (header);
     189    nbytes = gfits_data_size (header);
    190190    REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    191191    bzero (table[0].buffer, nbytes);

  • branches/eam_branch_20071015/Ohana/src/libfits/table/F_table_format.c

    r15275 r15312  
    2525  if (*Fchar == 'E') { *Nbytes = 4;  strcpy (type, "float");  *Nval = Nv;               }
    2626  if (*Fchar == 'D') { *Nbytes = 8;  strcpy (type, "double"); *Nval = Nv;               }
    27   if (*Fchar == 'P') { *Nbytes = 8;  strcpy (type, "float");  *Nval = 2*Nv;             }
     27  if (*Fchar == 'P') { *Nbytes = 8;  strcpy (type, "var");    *Nval = 2*Nv;             }
    2828  if (*Fchar == 'C') { *Nbytes = 8;  strcpy (type, "float");  *Nval = 2*Nv;             }
    2929  if (*Fchar == 'M') { *Nbytes = 16; strcpy (type, "double"); *Nval = 2*Nv;             }

  • branches/eam_branch_20071015/Ohana/src/libfits/table/F_table_row.c

    r7054 r15312  
    2525  gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
    2626
    27   nbytes = gfits_matrix_size (header);
     27  nbytes = gfits_data_size (header);
    2828  REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    2929  table[0].size = nbytes;
    … …  
    6666  gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
    6767
    68   table[0].size   = gfits_matrix_size (table[0].header);
     68  table[0].size   = gfits_data_size (table[0].header);
    6969  table[0].pad    = table[0].size - Nx*Ny;
    7070
    … …  
    9999  gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
    100100
    101   nbytes = gfits_matrix_size (header);
     101  nbytes = gfits_data_size (header);
    102102  REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    103103  table[0].size = nbytes;

  • branches/eam_branch_20071015/Ohana/src/opihi/cmd.data/read_vectors.c

    r7917 r15312  
    172172    for (i = 0; i <= Nextend; i++) {
    173173      if (!gfits_load_header (f, &header)) return (FALSE);
    174       Nbytes = gfits_matrix_size (&header);
     174      Nbytes = gfits_data_size (&header);
    175175      /* skip the prior data buffers */
    176176      if (i < Nextend) {

  • branches/eam_branch_20071015/Ohana/src/opihi/dvo/cmpread.c

    r8648 r15312  
    8383  } else {
    8484    gprint (GP_ERR, "reading from FITS cmp file %s\n", argv[2]);
    85     Nbytes = gfits_matrix_size (&header);
     85    Nbytes = gfits_data_size (&header);
    8686    fseek (f, Nbytes, SEEK_CUR);
    8787    stars = cmpReadFits (f, &Nstars);

  • branches/eam_branch_20071015/Ohana/src/opihi/dvo/imbox.c

    r13479 r15312  
    7979    }
    8080  skip:
    81     Nskip = gfits_matrix_size (&header);
     81    Nskip = gfits_data_size (&header);
    8282    fseek (f, Nskip, SEEK_CUR);
    8383    gfits_free_header (&header);

  • branches/eam_branch_20071015/Ohana/src/opihi/pantasks/task_trange.c

    r14590 r15312  
    5757  }
    5858
     59  /* allow a syntax which means something like "every hour at MM:SS"
     60     this could by something like *:MM:SS ? */
     61
    5962  /* test for HH:MM:SS */
    6063  if (hms_to_sec (argv[1], &range.start)) {

  • branches/eam_branch_20071015/Ohana/src/tools/src/ckfits.c

    r12333 r15312  
    2020  }
    2121
    22   Ntotal = gfits_matrix_size (&header);
     22  Ntotal = gfits_data_size (&header);
    2323
    2424  Ndata = abs(header.bitpix / 8);

  • branches/eam_branch_20071015/Ohana/src/tools/src/fields.c

    r12333 r15312  
    8585        }   
    8686   
    87         Nbytes = gfits_matrix_size (&header);
     87        Nbytes = gfits_data_size (&header);
    8888        fseek (f, Nbytes, SEEK_CUR);
    8989        Nextend ++;

  • branches/eam_branch_20071015/Ohana/src/tools/src/ftable.c

    r12399 r15312  
    8787
    8888  /* load table data array */
    89   Nbytes = gfits_matrix_size (table.header);
     89  Nbytes = gfits_data_size (table.header);
    9090  ALLOCATE (table.buffer, char, Nbytes);
    9191  Nread = fread (table.buffer, sizeof (char), Nbytes, f);
    … …  
    175175     exit (1);
    176176     }
    177      Nbytes = gfits_matrix_size (&header);
     177     Nbytes = gfits_data_size (&header);
    178178     fseek (f, Nbytes, SEEK_CUR);
    179179  */
    … …  
    234234    }
    235235
    236     Nbytes = gfits_matrix_size (&header);
     236    Nbytes = gfits_data_size (&header);
    237237    fseek (f, Nbytes, SEEK_CUR);
    238238
    … …  
    270270
    271271  /* skip first data array */
    272   Nbytes = gfits_matrix_size (header);
     272  Nbytes = gfits_data_size (header);
    273273  fseek (f, Nbytes, SEEK_CUR);
    274274
    … …  
    280280    if ((Extname != NULL) && (!strcmp (Extname, extname))) return (f);
    281281
    282     Nbytes = gfits_matrix_size (header);
     282    Nbytes = gfits_data_size (header);
    283283    fseek (f, Nbytes, SEEK_CUR);
    284284    gfits_free_header (header);

  • branches/eam_branch_20071015/Ohana/src/tools/src/mefhead.c

    r12333 r15312  
    4242  }
    4343  /* skip matrix */
    44   Nmatrix = gfits_matrix_size (&header);
     44  Nmatrix = gfits_data_size (&header);
    4545  fseek (g, Nmatrix, SEEK_CUR);
    4646
    … …  
    6464
    6565    /* skip matrix */
    66     Nmatrix = gfits_matrix_size (&header);
     66    Nmatrix = gfits_data_size (&header);
    6767    fseek (g, Nmatrix, SEEK_CUR);
    6868   
Note: See TracChangeset for help on using the changeset viewer.