IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 15487


Ignore:
Timestamp:
Nov 6, 2007, 5:09:52 PM (19 years ago)
Author:
eugene
Message:

merging changes from eam_branch_20071015 (read compressed images, clean addstar I/O, other minor issues)

Location:
trunk/Ohana/src
Files:
11 added
53 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/addstar/src/FilterStars.c

    r15038 r15487  
    4545    stars[N].dt      = MTIME;
    4646
    47     stars[N].M       = MIN (stars[N].M + MTIME, NO_MAG);
     47    if ((stars[N].M > 25.0) && (stars[N].M < 32.0)) {
     48      fprintf (stderr, "*");
     49    }
     50
     51    if (stars[N].M >= 0.001*NO_MAG) {
     52      stars[N].M       = 0.001*NO_MAG;
     53    } else {
     54      stars[N].M       = stars[N].M + MTIME;
     55    }
     56
     57    if (stars[N].M > 32.77) {
     58      fprintf (stderr, "*");
     59    }
     60
    4861    stars[N].dM      = MIN (stars[N].dM, NO_ERR);
    4962
    50     stars[N].Mgal    = MIN (stars[N].Mgal + MTIME, NO_MAG);
     63    stars[N].Mgal    = MIN (stars[N].Mgal + MTIME, 0.001*NO_MAG);
    5164   
    5265    if (SUBPIX) {

  • trunk/Ohana/src/addstar/src/LoadStars.c

    r15210 r15487  
    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")) {

  • trunk/Ohana/src/addstar/src/ReadStarsFITS.c

    r15038 r15487  
    9696    stars[i].dX      = ps1data[i].dX;
    9797    stars[i].dY      = ps1data[i].dY;
    98     stars[i].M       = ps1data[i].M + ZeroPt;
     98    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
     99        stars[i].M   = 0.001*NO_MAG;
     100    } else {
     101        stars[i].M   = ps1data[i].M + ZeroPt;
     102    }
    99103    stars[i].dM      = ps1data[i].dM;
    100104    stars[i].Mpeak   = ps1data[i].Mpeak;
    … …  
    134138
    135139    /* these are not used */
    136     stars[i].Map     = NO_MAG;
    137     stars[i].Mgal    = NO_MAG;
     140    stars[i].Map     = 0.001*NO_MAG;
     141    stars[i].Mgal    = 0.001*NO_MAG;
    138142    stars[i].dophot  = 0;
    139143  }   
    … …  
    160164    stars[i].dX      = ps1data[i].dX;
    161165    stars[i].dY      = ps1data[i].dY;
    162     stars[i].M       = ps1data[i].M + ZeroPt;
     166    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
     167        stars[i].M   = 0.001*NO_MAG;
     168    } else {
     169        stars[i].M   = ps1data[i].M + ZeroPt;
     170    }
    163171    stars[i].dM      = ps1data[i].dM;
    164172    stars[i].Mpeak   = ps1data[i].Mpeak;
    … …  
    205213
    206214    /* these are not used */
    207     stars[i].Map     = NO_MAG;
    208     stars[i].Mgal    = NO_MAG;
     215    stars[i].Map     = 0.001*NO_MAG;
     216    stars[i].Mgal    = 0.001*NO_MAG;
    209217    stars[i].dophot  = 0;
    210218  }   

  • trunk/Ohana/src/gastro2/src/gstars2.c

    r14590 r15487  
    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);

  • trunk/Ohana/src/getstar/src/ReadImageFiles.c

    r15037 r15487  
    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")) {

  • trunk/Ohana/src/imregister/imphot/rtext.c

    r7080 r15487  
    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);

  • trunk/Ohana/src/libdvo/src/dvo_catalog_mef.c

    r12391 r15487  
    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);

  • trunk/Ohana/src/libdvo/src/dvo_catalog_split.c

    r13325 r15487  
    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

  • trunk/Ohana/src/libdvo/src/dvo_convert.c

    r15035 r15487  
    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

  • trunk/Ohana/src/libdvo/src/dvo_convert_elixir.c

    r15038 r15487  
    6363    out[i].dD      = in[i].dD * 100.0;
    6464    out[i].M       = in[i].M  * 1000.0;
     65    if (out[i].M < 0) {
     66        fprintf (stderr, ".");
     67    }
    6568    out[i].dM      = in[i].dM * 1000.0;
    6669    out[i].dt      = in[i].dt * 1000.0;

  • trunk/Ohana/src/libdvo/src/dvo_image_raw.c

    r15035 r15487  
    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);

  • trunk/Ohana/src/libdvo/src/fits_db.c

    r13182 r15487  
    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  }

  • trunk/Ohana/src/libfits/Makefile

    r12879 r15487  
    1010MATR    =       $(HOME)/matrix
    1111TABL    =       $(HOME)/table
     12EXT     =       $(HOME)/extern
    1213INC     =       $(HOME)/include
    1314MAN     =       $(HOME)/doc
    … …  
    1516
    1617# programs may add their own internal requirements here
    17 FULL_CFLAGS   = $(BASE_CFLAGS) -fPIC
    18 FULL_CPPFLAGS = $(BASE_CPPFLAGS)
     18FULL_CFLAGS   = $(BASE_CFLAGS) -fPIC -Wall -Werror
     19FULL_CPPFLAGS = $(BASE_CPPFLAGS) -I$(EXT)
    1920FULL_LDFLAGS  = $(BASE_LDFLAGS)
    2021
    … …  
    3233$(HEAD)/F_copy_H.$(ARCH).o                      $(HEAD)/F_delete.$(ARCH).o    \
    3334$(HEAD)/F_read_XH.$(ARCH).o                     $(HEAD)/F_init_H.$(ARCH).o    \
    34 $(HEAD)/version.$(ARCH).o
     35$(HEAD)/F_convert_H.$(ARCH).o                   $(HEAD)/version.$(ARCH).o
    3536
    3637MATRIX_OBJ = \
    … …  
    4344$(MATR)/F_convert_format.$(ARCH).o              $(MATR)/F_read_segment.$(ARCH).o \
    4445$(MATR)/F_read_portion.$(ARCH).o                $(MATR)/F_load_M.$(ARCH).o       \
    45 $(MATR)/F_matrix.$(ARCH).o
     46$(MATR)/F_matrix.$(ARCH).o                      $(MATR)/F_compress_M.$(ARCH).o   \
     47$(MATR)/F_uncompress_data.$(ARCH).o
    4648
    4749TABLE_OBJ = \
    … …  
    5153$(TABL)/F_define_column.$(ARCH).o               $(TABL)/F_table_format.$(ARCH).o \
    5254$(TABL)/F_set_column.$(ARCH).o                  $(TABL)/F_get_column.$(ARCH).o   \
    53 $(TABL)/F_table_row.$(ARCH).o                   $(TABL)/F_free_T.$(ARCH).o
     55$(TABL)/F_table_row.$(ARCH).o                   $(TABL)/F_free_T.$(ARCH).o       \
     56$(TABL)/F_table_varlength.$(ARCH).o
    5457
    55 OBJS = $(HEADER_OBJ) $(MATRIX_OBJ) $(TABLE_OBJ)
     58EXTERN_OBJ = \
     59$(EXT)/fits_hcompress.$(ARCH).o \
     60$(EXT)/fits_hdecompress.$(ARCH).o \
     61$(EXT)/pliocomp.$(ARCH).o \
     62$(EXT)/ricecomp.$(ARCH).o
     63
     64OBJS = $(HEADER_OBJ) $(MATRIX_OBJ) $(TABLE_OBJ) $(EXTERN_OBJ)
     65
     66extern: $(EXTERN_OBJ)
    5667
    5768$(OBJS): $(INCS)

  • trunk/Ohana/src/libfits/doc/notes-compress.txt

    r15240 r15487  
     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

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

    r7039 r15487  
    88
    99  out[0].simple = in[0].simple;
     10  out[0].unsign = in[0].unsign;
     11  out[0].extend = in[0].extend;
    1012  out[0].bitpix = in[0].bitpix;
    11   out[0].extend = in[0].extend;
    12   out[0].unsign = in[0].unsign;
    13   out[0].size   = in[0].size;
    14   out[0].bscale = in[0].bscale;
    15   out[0].bzero  = in[0].bzero;
     13
    1614  out[0].Naxes  = in[0].Naxes;
    1715  for (i = 0; i < FT_MAX_NAXES; i++)
    1816    out[0].Naxis[i] = in[0].Naxis[i];
     17
     18  out[0].size   = in[0].size;
     19
     20  out[0].pcount = in[0].pcount;
     21  out[0].gcount = in[0].gcount;
     22  out[0].bzero  = in[0].bzero;
     23  out[0].bscale = in[0].bscale;
    1924
    2025  ALLOCATE (out[0].buffer, char, out[0].size);

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

    r7054 r15487  
    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  }
    2727
    28   /* PCOUNT & GCOUNT are not implemented, but they are required to be here */
    29   gfits_modify (header, "PCOUNT", "%d", 1, 0);
    30   gfits_modify (header, "GCOUNT", "%d", 1, 1);
     28  gfits_modify (header, "PCOUNT", "%d",  1, header[0].pcount);
     29  gfits_modify (header, "GCOUNT", "%d",  1, header[0].gcount);
    3130  gfits_modify (header, "BSCALE", "%lf", 1, header[0].bscale);
    3231  gfits_modify (header, "BZERO",  "%lf", 1, header[0].bzero);

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

    r12902 r15487  
    1111  header[0].extend = FALSE;
    1212  header[0].unsign = FALSE;
    13   header[0].bscale = 1;
    14   header[0].bzero  = 0;
     13  header[0].pcount = 0;
     14  header[0].gcount = 1;
     15  header[0].bscale = 1.0;
     16  header[0].bzero  = 0.0;
    1517  header[0].bitpix = 8;
    1618  header[0].Naxes  = 0;

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

    r12902 r15487  
    7676  gfits_scan (header, "NAXIS10", "%d", 1, &header[0].Naxis[9]);
    7777
     78  if (!gfits_scan (header, "PCOUNT",  "%d", 1, &header[0].pcount)) {
     79    header[0].pcount = 0;
     80  }
     81  if (!gfits_scan (header, "GCOUNT",  "%d", 1, &header[0].gcount)) {
     82    header[0].gcount = 1;
     83  }
     84
    7885  return (TRUE);
    7986

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

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

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

    r15038 r15487  
    11/* FITS specific macros and structures */
     2
     3# include <assert.h>
    24
    35# ifndef GFITSIO
    … …  
    4850  int                     Naxis[FT_MAX_NAXES];
    4951  int                     size;
     52  int                     pcount;
     53  int                     gcount;
    5054  double                  bzero;
    5155  double                  bscale;
    … …  
    8488} VTable;
    8589
     90typedef struct {
     91  int  maxlen;                // max size of all table rows
     92  int  nbytes;                // number of bytes per column element
     93  int  Nstart;                // byte offset of this column
     94  int  heap_start;            // byte offset to start of HEAP
     95  char format;                // data format character (one of: XLABIJEDCM)
     96} VarLengthColumn;
     97
    8698# ifndef PROTO
    8799# define PROTO(A) A
    88100# endif
    89101
    90 char *gfits_version                PROTO(());
     102char   *gfits_version                  PROTO((void));
    91103
    92104/******************************* 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));
    104 
    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));
     105
     106char   *gfits_header_field             PROTO((Header *header, char *field, int N));
     107char   *gfits_keyword_end              PROTO((char *line));
     108int     gfits_copy_header              PROTO((Header *in, Header *out));
     109int     gfits_create_header            PROTO((Header *header));
     110int     gfits_delete                   PROTO((Header *header, char *field, int N));
     111int     gfits_fread_Xheader            PROTO((FILE *f, Header *header, int N));
     112int     gfits_fread_header             PROTO((FILE *f, Header *header));
     113void    gfits_free_header              PROTO((Header *header));
     114int     gfits_fwrite_header            PROTO((FILE *f, Header *header));
     115int     gfits_get_unsign_mode          PROTO((void));
     116int     gfits_init_header              PROTO((Header *header));
     117int     gfits_load_header              PROTO((FILE *f, Header *header));
     118int     gfits_modify                   PROTO((Header *header, char *field, char *mode, int N,...));
     119int     gfits_print                    PROTO((Header *header, char *field, char *mode, int N,...));
     120int     gfits_read_Xheader             PROTO((char *filename, Header *header, int N));
     121int     gfits_read_header              PROTO((char *filename, Header *header));
     122int     gfits_save_header              PROTO((FILE *f, Header *header));
     123int     gfits_scan                     PROTO((Header *header, char *field, char *mode, int N,...));
     124int     gfits_set_unsign_mode          PROTO((int mode));
     125int     gfits_stripwhite               PROTO((char *string));
     126int     gfits_vscan                    PROTO((Header *header, char *field, char *mode, int N, va_list argp));
     127int     gfits_write_header             PROTO((char *filename, Header *header));
     128int     gfits_data_size                PROTO((Header *header));
     129int     gfits_extended_to_primary      PROTO((Header *header, int simple, char *comment));
     130int     gfits_primary_to_extended      PROTO((Header *header, char *exttype, char *comment));
     131int     gfits_modify_extended          PROTO((Header *header, char *exttype, char *comment));
     132
    130133
    131134/******************************* 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));
     135
     136void    gfits_add_matrix_value         PROTO((Matrix *matrix, int x, int y, double value));
     137int     gfits_convert_format           PROTO((Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int outUnsign));
     138int     gfits_copy_matrix              PROTO((Matrix *in, Matrix *out));
     139int     gfits_create_matrix            PROTO((Header *header, Matrix *matrix));
     140int     gfits_divide_matrix            PROTO((Matrix *M1, Matrix *M2, Matrix *M3));
     141int     gfits_fread_matrix             PROTO((FILE *f, Matrix *matrix, Header *header));
     142int     gfits_fread_matrix_segment     PROTO((FILE *f, Matrix *matrix, Header *header, char *region));
     143void    gfits_free_matrix              PROTO((Matrix *matrix));
     144int     gfits_fwrite_matrix            PROTO((FILE *f, Matrix *matrix));     
     145double  gfits_get_matrix_value         PROTO((Matrix *matrix, int x, int y));
     146void    gfits_insert_array             PROTO((Matrix *matrix, Matrix *array, int x, int y));
     147int     gfits_load_matrix              PROTO((FILE *f, Matrix *matrix, Header *header));
     148int     gfits_multiply_matrix          PROTO((Matrix *M1, Matrix *M2, Matrix *M3));
     149int     gfits_read_matrix              PROTO((char *filename, Matrix *matrix));     
     150int     gfits_read_matrix_segment      PROTO((char *filename, Matrix *matrix, char *region));
     151int     gfits_read_portion             PROTO((char *filename, Matrix *matrix, int Nskip, int Npix));
     152void    gfits_set_matrix_value         PROTO((Matrix *matrix, int x, int y, double value));
     153int     gfits_write_matrix             PROTO((char *filename, Matrix *matrix));
     154int     gfits_uncompress_image         PROTO((Header *header, Matrix *matrix, FTable *ftable, int primary));
     155int     gfits_uncompress_data          PROTO((char *zdata, int Nzdata, char *cmptype, char **optname, char **optvalue, int Nopt, char *outdata, int *Nout, int out_pixsize));
     156int     gfits_distribute_data          PROTO((Matrix *matrix, int bitpix, char *data, int Ndata, int *otile, int *ztile, float zscale, float zzero));
     157int     gfits_byteswap_zdata           PROTO((char *zdata, int Nzdata, int bitpix));
     158int     gfits_extension_is_compressed  PROTO((Header *header));
     159int     gfits_tile_size                PROTO((Matrix *matrix, int *otile, int *ztile));
    149160
    150161/******************************* 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));
    159 
    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));
    168 
    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));
     162
     163char   *gfits_table_print              PROTO((FTable *ftable,...));
     164int     gfits_add_rows                 PROTO((FTable *ftable, char *data, int Nrow, int Nbytes));
     165int     gfits_bintable_format          PROTO((char *format, char *type, int *Nval, int *Nbytes));
     166int     gfits_create_table             PROTO((Header *header, FTable *ftable));
     167int     gfits_create_table_header      PROTO((Header *header, char *type, char *extname));
     168int     gfits_define_bintable_column   PROTO((Header *header, char *format, char *label, char *comment, char *unit, double bscale, double bzero));
     169int     gfits_define_table_column      PROTO((Header *header, char *format, char *label, char *comment, char *unit));
     170int     gfits_fread_ftable             PROTO((FILE *f, FTable *ftable, char *extname));
     171int     gfits_fread_ftable_data        PROTO((FILE *f, FTable *ftable));
     172int     gfits_fread_vtable             PROTO((FILE *f, VTable *vtable, char *extname, int Nrow, int *row));
     173int     gfits_fread_vtable_range       PROTO((FILE *f, VTable *vtable, int start, int Nrows));
     174int     gfits_free_table               PROTO((FTable *ftable));
     175int     gfits_free_vtable              PROTO((VTable *vtable));
     176int     gfits_fwrite_table             PROTO((FILE *f, FTable *table));
     177int     gfits_fwrite_vtable            PROTO((FILE *f, VTable *table));
     178int     gfits_get_bintable_column      PROTO((Header *header, FTable *table, char *label, void **data));
     179int     gfits_get_bintable_column_type PROTO((Header *header, char *label, char *type, int *Nval));
     180int     gfits_get_table_column         PROTO((Header *header, FTable *table, char *label, void **data));
     181int     gfits_get_table_column_type    PROTO((Header *header, char *label, char *type));
     182int     gfits_read_ftable              PROTO((char *filename, FTable *table, char *extname));
     183int     gfits_read_table               PROTO((char *filename, FTable *ftable));
     184int     gfits_set_bintable_column      PROTO((Header *header, FTable *table, char *label, void *data, int Nrow));
     185int     gfits_set_table_column         PROTO((Header *header, FTable *table, char *label, void *data, int Nrow));
     186int     gfits_table_column             PROTO((FTable *ftable, char *field, char *mode,...));
     187int     gfits_table_format             PROTO((char *format, char *type, int *Nval, int *Nbytes));
     188int     gfits_table_scale_data         PROTO((FTable *ftable));
     189int     gfits_table_scale_storage      PROTO((FTable *ftable));
     190int     gfits_table_to_vtable          PROTO((FTable *ftable, VTable *vtable, int start, int Nkeep));
     191int     gfits_vadd_rows                PROTO((VTable *vtable, char *data, int Nrow, int Nbytes));
     192int     gfits_vtable_from_ftable       PROTO((FTable *ftable, VTable *vtable, int *row, int Nrow));
     193int     gfits_write_table              PROTO((char *filename, FTable *ftable));
     194
     195int     gfits_create_Theader           PROTO((Header *header, char *type));
     196int     gfits_fread_Theader            PROTO((FILE *f, Header *header));
     197int     gfits_fwrite_Theader           PROTO((FILE *f, Header *header));
     198int     gfits_load_Theader             PROTO((FILE *f, Header *header));
     199int     gfits_read_Theader             PROTO((char *filename, Header *header));     
     200int     gfits_write_Theader            PROTO((char *filename, Header *header));
     201
     202int     gfits_varlength_column_define  PROTO((FTable *ftable, VarLengthColumn *def, int column));
     203void   *gfits_varlength_column_pointer PROTO((FTable *ftable, VarLengthColumn *column, int row, int *length));
    190204
    191205#endif /* FITSIO */

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

    r7054 r15487  
    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);

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

    r7054 r15487  
    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);

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

    r7054 r15487  
    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;

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

    r7054 r15487  
    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 */

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

    r7054 r15487  
    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;

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

    r7054 r15487  
    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) {

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

    r7054 r15487  
    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;

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

    r7054 r15487  
    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 

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

    r7054 r15487  
    11# include <ohana.h>
    22# include <gfitsio.h>
     3# define NBYTES 2880
    34
    45/* a basic table header (extension) is different from a primary header
    … …  
    1213  char axis[10];
    1314 
    14   header[0].size = 2880;
    15   ALLOCATE (header[0].buffer, char, 2880);
     15  header[0].size = NBYTES;
     16
     17  ALLOCATE (header[0].buffer, char, NBYTES);
    1618 
    17   for (i = 0; i < 2880; i++)
     19  for (i = 0; i < NBYTES; i++)
    1820  header[0].buffer[i] = ' ';
    1921  strncpy (header[0].buffer, "END", 3);
    2022 
    2123  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);
     24  gfits_modify (header, "BITPIX",   "%d", 1, header[0].bitpix);
     25  gfits_modify (header, "NAXIS",    "%d", 1, header[0].Naxes);
    2426 
    2527  for (i = 0; i < header[0].Naxes; i++) {
    … …  
    2830  }
    2931 
    30   /* PCOUNT & GCOUNT are not implemented, but they are required to be here */
    31   gfits_modify (header, "PCOUNT", "%d", 1, 0);
    32   gfits_modify (header, "GCOUNT", "%d", 1, 1);
     32  gfits_modify (header, "PCOUNT", "%d", 1, header[0].pcount);
     33  gfits_modify (header, "GCOUNT", "%d", 1, header[0].gcount);
    3334  if (!strcmp (type, "IMAGE")) {
    3435    gfits_modify (header, "BSCALE", "%lf", 1, header[0].bscale);
    … …  
    4344 
    4445  int i, valid;
    45   char axis[10];
    4646
    4747  /* check valid table types */
    … …  
    5151  if (!valid) return (FALSE);
    5252
    53   /* create empty header buffer */
    54   header[0].size = 2880;
    55   ALLOCATE (header[0].buffer, char, 2880);
    56  
    57   for (i = 0; i < 2880; i++)
    58   header[0].buffer[i] = ' ';
    59   strncpy (header[0].buffer, "END", 3);
     53  gfits_init_header (header);
    6054
    61   /* a table has BITPIX = 8, NAXIS = 2 */
    6255  header[0].simple = FALSE;
    63   header[0].unsign = FALSE;
    64   header[0].extend = FALSE;
    65   header[0].bitpix = 8;
    66   header[0].bscale = 1;
    67   header[0].bzero  = 0;
    6856  header[0].Naxes  = 2;
    6957  for (i = 0; i < FT_MAX_NAXES; i++)
    7058    header[0].Naxis[i] = 0;
    71  
    72   /* required keywords */
    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);
    76  
    77   for (i = 0; i < header[0].Naxes; i++) {
    78     sprintf (axis, "NAXIS%d", i + 1);
    79     gfits_modify (header,  axis, "%d", 1, header[0].Naxis[i], 1);
    80   }
    81  
    82   /* PCOUNT & GCOUNT are not implemented, but they are required to be here */
    83   gfits_modify (header, "PCOUNT", "%d", 1, 0);
    84   gfits_modify (header, "GCOUNT", "%d", 1, 1);
    85   if (!strcmp (type, "IMAGE")) {
    86     gfits_modify (header, "BSCALE", "%lf", 1, header[0].bscale);
    87     gfits_modify (header, "BZERO",  "%lf", 1, header[0].bzero);
    88   }
     59
     60  gfits_create_Theader (header, type);
    8961
    9062  gfits_modify (header, "TFIELDS", "%d", 1, 0);

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

    r7054 r15487  
    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  }

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

    r7054 r15487  
    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);

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

    r7054 r15487  
    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);

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

    r15038 r15487  
    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;             }
    … …  
    194194  int i, j, n, Nx, Ny, Nfields;
    195195  int off, Nchar, Nval, Nbytes, status;
    196   char *line, format[64], field[16], type[16];
     196  char format[64], field[16], type[16];
    197197  double tzero, tscale;
    198198  char *tmpChar;
    … …  
    233233      for (j = 0; j < Ny; j++) {
    234234        for (n = 0; n < Nval; n++) {
    235           tmpChar = (int *)&ftable[0].buffer[j*Nx + n*Nbytes + off];
     235          tmpChar = (char *)&ftable[0].buffer[j*Nx + n*Nbytes + off];
    236236          *tmpChar = *tmpChar * tscale + tzero;
    237237        }
    … …  
    241241      for (j = 0; j < Ny; j++) {
    242242        for (n = 0; n < Nval; n++) {
    243           tmpShort = (int *)&ftable[0].buffer[j*Nx + n*Nbytes + off];
     243          tmpShort = (short *)&ftable[0].buffer[j*Nx + n*Nbytes + off];
    244244          *tmpShort = *tmpShort * tscale + tzero;
    245245        }
    … …  
    264264  int i, j, n, Nx, Ny, Nfields;
    265265  int off, Nchar, Nval, Nbytes, status;
    266   char *line, format[64], field[16], type[16];
     266  char format[64], field[16], type[16];
    267267  double tzero, tscale;
    268268  char *tmpChar;
    … …  
    303303      for (j = 0; j < Ny; j++) {
    304304        for (n = 0; n < Nval; n++) {
    305           tmpChar = (int *)&ftable[0].buffer[j*Nx + n*Nbytes + off];
     305          tmpChar = (char *)&ftable[0].buffer[j*Nx + n*Nbytes + off];
    306306          *tmpChar = (*tmpChar - tzero) / tscale;
    307307        }
    … …  
    311311      for (j = 0; j < Ny; j++) {
    312312        for (n = 0; n < Nval; n++) {
    313           tmpShort = (int *)&ftable[0].buffer[j*Nx + n*Nbytes + off];
     313          tmpShort = (short *)&ftable[0].buffer[j*Nx + n*Nbytes + off];
    314314          *tmpShort = (*tmpShort - tzero) / tscale;
    315315        }

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

    r7054 r15487  
    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;

  • trunk/Ohana/src/misc/src/fakedist.c

    r7080 r15487  
    265265  double value;
    266266
     267  gfits_init_header (&header);
    267268  header.bitpix = -32;
    268269  header.Naxes = 7;

  • trunk/Ohana/src/misc/src/fakedump.c

    r7080 r15487  
    4444  }
    4545
     46  gfits_init_header (&out_h);
    4647  out_h.bitpix = -32;
    4748  out_h.Naxes = 2;

  • trunk/Ohana/src/misc/src/smaeder.c

    r7080 r15487  
    318318  age_h.extend = FALSE;
    319319
     320  gfits_init_header (&mass_h);
    320321  gfits_create_header (&mass_h);
    321322  gfits_create_matrix (&mass_h, &mass_i);
     323
     324  gfits_init_header (&age_h);
    322325  gfits_create_header (&age_h);
    323326  gfits_create_matrix (&age_h, &age_i);
     327
    324328  fprintf (stderr, "created FITS buffers\n");
    325329

  • trunk/Ohana/src/misc/src/usmaeder.c

    r7080 r15487  
    7575  UV_h.extend = FALSE;
    7676
     77  gfits_init_header (&V_h);
    7778  gfits_create_header (&V_h);
    7879  gfits_create_matrix (&V_h, &V_i);
     80
     81  gfits_init_header (&UV_h);
    7982  gfits_create_header (&UV_h);
    8083  gfits_create_matrix (&UV_h, &UV_i);

  • trunk/Ohana/src/mosastro/src/mkheader.c

    r7080 r15487  
    77  ALLOCATE (header, Header, 1);
    88
    9   header[0].simple = TRUE;
     9  gfits_init_header (header);
    1010  header[0].bitpix = -32;
    11   header[0].unsign = FALSE;
    12   header[0].bscale = 1.0;
    13   header[0].bzero  = 0.0;
    1411  header[0].Naxes = 2;
    1512  header[0].Naxis[0] = Nx;

  • trunk/Ohana/src/mosastro/src/mkmosaic.c

    r7080 r15487  
    1515  ALLOCATE (header, Header, 1);
    1616
     17  gfits_init_header (header);
     18
    1719  header[0].bitpix = -32;
    18   header[0].unsign = FALSE;
    19   header[0].extend = FALSE;
    20   header[0].bscale = 1.0;
    21   header[0].bzero  = 0.0;
    2220  header[0].Naxes = 2;
    2321  header[0].Naxis[0] = Xmax - Xmin;

  • trunk/Ohana/src/opihi/cmd.data/rd.c

    r13479 r15487  
    55 
    66  int i, N, status, plane, Nplane, extend, Nextend, Nskip, JustHead;
    7   int ccdsel, done;
     7  int ccdsel, done, Nword, IsCompressed;
    88  char region[512], *ccdid, *filename;
    99  FILE *f;
    … …  
    8585      return (FALSE);
    8686    }
     87    if (gfits_extension_is_compressed (&buf[0].header)) {
     88        IsCompressed = TRUE;
     89    }
    8790  }
     91
    8892  /* FITS extension by name */
    8993  if (ccdsel) {
    … …  
    9296    CCDKeyword = get_variable ("CCDKEYWORD");
    9397    if (CCDKeyword == (char *) NULL) {
    94       gprint (GP_ERR, "CCDKEYWORD variable is not set; ");
    95       gprint (GP_ERR, "using EXTNAME as default\n");
     98      // gprint (GP_ERR, "CCDKEYWORD variable is not set; ");
     99      // gprint (GP_ERR, "using EXTNAME as default\n");
    96100      CCDKeyword = strcreate ("EXTNAME");
    97101    }
    … …  
    106110        return (FALSE);
    107111      }
    108       if (!gfits_scan (&buf[0].header, CCDKeyword, "%s", 1, ID)) {
     112
     113      // for compressed data tables, EXTNAME may be duplicated, with the first one containing the
     114      // word 'COMPRESSED_IMAGE'.  in this case, check the second EXTNAME, if CCDKeyword == EXTNAME
     115      // this may have to be a more obscure test specifically for 'imcopy' data...
     116      // need to check each header, since file may contain a mix
     117     
     118      Nword = 1;
     119      IsCompressed = FALSE;
     120      if (gfits_extension_is_compressed (&buf[0].header)) {
     121        if (!strcmp (CCDKeyword, "EXTNAME")) Nword = 2;
     122        IsCompressed = TRUE;
     123      }
     124      if (!gfits_scan (&buf[0].header, CCDKeyword, "%s", Nword, ID)) {
    109125        gprint (GP_ERR, "%s not in header\n", CCDKeyword);
    110126        DeleteBuffer (buf);
    … …  
    123139  /* fix up header, if needed */
    124140  if (extend || ccdsel) {
    125     static char simple[] = "SIMPLE  =                    T / Standard FITS";
    126     int Ns, No;
    127 
    128     Ns = strlen (simple);
    129     No = 80 - Ns;
    130     strncpy (buf[0].header.buffer, simple, Ns);
    131     memset (&buf[0].header.buffer[Ns], ' ', No);
     141    if (!IsCompressed) {
     142      gfits_extended_to_primary (&buf[0].header, TRUE, "Standard FITS");
     143    }
    132144  } else {
    133145      gfits_fread_header (f, &buf[0].header);
    … …  
    135147
    136148  /* for JustHead, we skip reading the data segment */
     149  // XXX for compressed data, we need to convert the header to the equivalent uncompressed version
    137150  if (JustHead) {
    138     /* should be in CreateMatrix / CreateBuffer function */
     151    // XXX what are we doing here exactly?
    139152    buf[0].header.Naxes = 0;
    140153    ALLOCATE (buf[0].matrix.buffer, char, 1);
    … …  
    164177
    165178  /* load matrix data */
    166   sprintf (region, "-1 -1 -1 -1 %d %d", (plane - 1), plane);
    167   status = gfits_fread_matrix_segment (f, &buf[0].matrix, &buf[0].header, region);
    168   fclose (f);
     179  if (IsCompressed) {
     180    FTable ftable;
     181    Header theader;
     182    ftable.header = &theader;
     183    gfits_copy_header (&buf[0].header, ftable.header);
     184    status = gfits_fread_ftable_data (f, &ftable);  // XXX does this do more than read the bytes?
     185    status = gfits_uncompress_image (&buf[0].header, &buf[0].matrix, &ftable, !(ccdsel || extend));
     186    gfits_free_table (&ftable);
     187    // XXX this currently does not work for a cube (we get a cube back, not a specific plane)
     188  } else {
     189    sprintf (region, "-1 -1 -1 -1 %d %d", (plane - 1), plane);
     190    status = gfits_fread_matrix_segment (f, &buf[0].matrix, &buf[0].header, region);
     191    fclose (f);
     192  }
    169193
    170194  if (!status) {

  • trunk/Ohana/src/opihi/cmd.data/read_vectors.c

    r7917 r15487  
    150150int read_table_vectors (int argc, char **argv, char *extname) {
    151151
    152   int i, j, k, Nbytes, Nread, Nextend, Ny, Binary;
    153   char type[16];
     152  int i, j, k, N, Nbytes, Nread, Nextend, Ny, Binary;
     153  char type[16], ID[80], *CCDKeyword;
    154154  FTable table;
    155155  Header header;
    156156  Vector **vec;
    157157
     158  table.buffer = NULL;
     159  header.buffer = NULL;
     160
     161  CCDKeyword = NULL;
     162  if ((N = get_argument (argc, argv, "-keyword"))) {
     163    remove_argument (N, &argc, argv);
     164    CCDKeyword = strcreate (argv[N]);
     165    remove_argument (N, &argc, argv);
     166  }
     167
     168  Nextend = -1;
     169  if ((N = get_argument (argc, argv, "-extnum"))) {
     170    remove_argument (N, &argc, argv);
     171    Nextend = atoi (extname);
     172  }
     173
    158174  if (argc < 2) {
    159     gprint (GP_ERR, "USAGE: read -fits extension name name ...\n");
     175    gprint (GP_ERR, "USAGE: read -fits extension [-extnum] [-keyword key] name name ...\n");
    160176    gprint (GP_ERR, "  ('extension' may be a name or number)\n");
    161     return (FALSE);
    162   }
    163 
    164   if (f == (FILE *) NULL) return (FALSE);
     177    goto escape;
     178  }
     179
     180  if (f == (FILE *) NULL) goto escape;
    165181  fseek (f, 0, SEEK_SET);
    166182  table.header = &header;
    167183
    168184  /* load appropriate extension (if extname is a number, use count) */
    169   if (isdigit(extname[0])) {
    170     Nextend = atoi (extname);
    171 
    172     for (i = 0; i <= Nextend; i++) {
    173       if (!gfits_load_header (f, &header)) return (FALSE);
    174       Nbytes = gfits_matrix_size (&header);
     185  if (Nextend > -1) {
     186    // first extension is PHU, cannot be a table.
     187    // Nextend counts from 0 for first extension
     188    if (!gfits_load_header (f, &header)) goto escape;
     189    Nbytes = gfits_data_size (&header);
     190    fseek (f, Nbytes, SEEK_CUR);
     191    gfits_free_header (&header);
     192
     193    for (i = 0; i < Nextend; i++) {
     194      if (!gfits_load_header (f, &header)) goto escape;
     195      Nbytes = gfits_data_size (&header);
    175196      /* skip the prior data buffers */
    176       if (i < Nextend) {
     197      fseek (f, Nbytes, SEEK_CUR);
     198      gfits_free_header (&header);
     199    }
     200    if (!gfits_load_header (f, &header)) goto escape;
     201    if (!gfits_fread_ftable_data (f, &table)) goto escape;
     202
     203  } else {
     204    if (CCDKeyword == NULL) {
     205      CCDKeyword = get_variable ("CCDKEYWORD");
     206    }
     207    if (CCDKeyword == NULL) {
     208      CCDKeyword = strcreate ("EXTNAME");
     209    }
     210
     211    while (1) {
     212      if (!gfits_load_header (f, &header)) goto escape;
     213      Nbytes = gfits_data_size (&header);
     214
     215      if (!gfits_scan (&header, CCDKeyword, "%s", 1, ID)) {
    177216        fseek (f, Nbytes, SEEK_CUR);
    178217        gfits_free_header (&header);
    179218        continue;
    180219      }
    181       /* on the desired header, load buffer */
    182       ALLOCATE (table.buffer, char, Nbytes);
    183       Nread = fread (table.buffer, sizeof (char), Nbytes, f);
    184       if (Nread != Nbytes) {
    185         gfits_free_table  (&table);
     220      if (strcmp (ID, extname)) {
     221        fseek (f, Nbytes, SEEK_CUR);
    186222        gfits_free_header (&header);
    187         return (FALSE);
    188       }
    189       table.size = Nbytes;
    190     }
    191   } else {
    192     if (!gfits_fread_ftable (f, &table, extname)) return (FALSE);
     223        continue;
     224      }
     225      if (!gfits_fread_ftable_data (f, &table)) goto escape;
     226      break;
     227    }
    193228  }
    194229
    … …  
    196231  Binary = FALSE;
    197232  gfits_scan (&header, "XTENSION", "%s", 1, type);
    198   if (!strcmp (type, "BINTABLE")) {
    199     Binary = TRUE;
    200   }
     233  if (strcmp (type, "BINTABLE") && strcmp (type, "TABLE")) {
     234    gprint (GP_ERR, "specified extension (%s) is not a table\n", extname);
     235    goto escape;
     236  }
     237  Binary = !strcmp (type, "BINTABLE");
    201238  Ny = header.Naxis[1];
    202239
    … …  
    214251    Nval = 0;
    215252    if (Binary) {
    216       if (!gfits_get_bintable_column_type (&header, argv[i], type, &Nval)) return (FALSE);
    217       if (!gfits_get_bintable_column (&header, &table, argv[i], &data)) return (FALSE);
     253      if (!gfits_get_bintable_column_type (&header, argv[i], type, &Nval)) goto escape;
     254      if (!gfits_get_bintable_column (&header, &table, argv[i], &data)) goto escape;
    218255    } else {
    219       if (!gfits_get_table_column_type (&header, argv[i], type)) return (FALSE);
    220       if (!gfits_get_table_column (&header, &table, argv[i], &data)) return (FALSE);
    221     }
    222     if (Nval == 0) return (FALSE);
     256      if (!gfits_get_table_column_type (&header, argv[i], type)) goto escape;
     257      if (!gfits_get_table_column (&header, &table, argv[i], &data)) goto escape;
     258    }
     259    if (Nval == 0) goto escape;
    223260
    224261    ALLOCATE (vec, Vector *, Nval);
    … …  
    228265      else
    229266        sprintf (name, "%s:%d", argv[i], j);
    230       if ((vec[j] = SelectVector (name, ANYVECTOR, TRUE)) == NULL) return (FALSE);   
     267      if ((vec[j] = SelectVector (name, ANYVECTOR, TRUE)) == NULL) goto escape;
    231268      REALLOCATE (vec[j][0].elements, float, MAX (Ny,1));
    232269      vec[j][0].Nelements = Ny;
    … …  
    276313    free (vec);
    277314  }
     315  if (CCDKeyword != NULL) free (CCDKeyword);
    278316  gfits_free_table (&table);
    279317  gfits_free_header (&header);
    280318  return (TRUE);
     319
     320escape:
     321  if (CCDKeyword != NULL) free (CCDKeyword);
     322  gfits_free_table  (&table);
     323  gfits_free_header (&header);
     324  return (FALSE);
    281325}

  • trunk/Ohana/src/opihi/cmd.data/wd.c

    r11887 r15487  
    9191    if (!gfits_read_header (argv[2], &Xhead)) {
    9292
    93       Xhead.simple = TRUE;
     93      gfits_init_header (&Xhead);
    9494      Xhead.bitpix = 16;
    95       Xhead.Naxes = 0;
    96      
    9795      Xhead.extend = TRUE;
    98       Xhead.bscale = 1.0;
    99       Xhead.bzero  = 0.0;
    100       Xhead.unsign = FALSE;
    101      
    10296      gfits_create_header (&Xhead);
     97
    10398      gfits_modify (&Xhead, "NEXTEND", "%d", 1, 0);
    10499      f = fopen (argv[2], "w");

  • trunk/Ohana/src/opihi/dimm/Image.c

    r7080 r15487  
    5555  Matrix matrix;
    5656
     57  gfits_init_header (&header);
     58
    5759  header.Naxes = 2;
    5860  header.Naxis[0] = image[0].Nx;
    5961  header.Naxis[1] = image[0].Ny;
    6062  header.bitpix = 16;
    61   header.bzero = 0;
    62   header.bscale = 1;
    6363
    6464  gfits_create_header (&header);

  • trunk/Ohana/src/opihi/dvo/cmpread.c

    r8648 r15487  
    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);

  • trunk/Ohana/src/opihi/dvo/imbox.c

    r13479 r15487  
    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);

  • trunk/Ohana/src/opihi/lib.shell/BufferOps.c

    r13479 r15487  
    7676  /* assign the necessary internal values */
    7777  buf[0].header.bitpix   = -32;
    78   buf[0].header.unsign   = FALSE;
    79   buf[0].header.bzero    = 0;
    80   buf[0].header.bscale   = 1;
    81  
    8278  buf[0].header.Naxes = 2;
    8379  buf[0].header.Naxis[0] = Nx;
    … …  
    8581
    8682  buf[0].bitpix = bitpix;
    87   buf[0].unsign = FALSE;
    8883  buf[0].bzero  = bzero;
    8984  buf[0].bscale = bscale;

  • trunk/Ohana/src/opihi/pantasks/task_trange.c

    r14590 r15487  
    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)) {

  • trunk/Ohana/src/tools/Makefile

    r12842 r15487  
    1010BIN     =       $(HOME)/bin
    1111INC     =       $(HOME)/include
    12 
    13 FULL_CFLAGS   = $(CFLAGS)
    14 FULL_CPPFLAGS = $(CPPFLAGS) -I$(INC) -I$(DESTINC) $(INCDIRS) -D$(ARCH)
    15 FULL_LDFLAGS  = $(LDFLAGS) -L$(LIB) -L$(DESTLIB) $(LIBDIRS) -ldvo -lFITS -lohana $(LIBFLAGS)
    16 
    17 # these are all programs which just depend on a single c file: foo : foo.c
    18 # we use a special set of rules in this directory which expect this simplification
     12# include ../../Makefile.Common
    1913
    2014PROGRAMS = gconfig fhead ftable fields list_astro glockfile \
    … …  
    2216medianfilter mefhead ckfits
    2317
    24 tools: $(PROGRAMS)
     18all tools: $(PROGRAMS)
    2519
    26 $(PROGRAMS): % : $(BIN)/%.$(ARCH)
     20BASE_CFLAGS   = $(CFLAGS)
     21BASE_CPPFLAGS = $(CPPFLAGS) -I$(INC) -I$(DESTINC) $(INCDIRS) -D$(ARCH)
     22BASE_LDFLAGS  = $(LDFLAGS) -L$(LIB) -L$(DESTLIB) $(LIBDIRS) $(LIBFLAGS)
    2723
    28 # copied from Makefile.Common : use a single c file: foo : foo.c
    29 .PRECIOUS: %.$(ARCH).o
    30 .PRECIOUS: $(BIN)/%.$(ARCH)
     24FULL_CFLAGS   = $(BASE_CFLAGS)
     25FULL_CPPFLAGS = $(BASE_CPPFLAGS)
     26FULL_LDFLAGS  = -ldvo -lFITS -lohana $(BASE_LDFLAGS)
     27
     28# these are all programs which just depend on a single c file: foo : foo.c
     29# we use a special set of rules in this directory which expect this simplification
    3130
    3231%.$(ARCH).o : %.c
    3332        $(CC) $(FULL_CFLAGS) $(FULL_CPPFLAGS) -c $< -o $@
     33        @echo "compiled $<"
     34        @echo ""
    3435
    3536$(BIN)/%.$(ARCH) : $(SRC)/%.$(ARCH).o
    3637        @if [ ! -d $(BIN) ]; then mkdir -p $(BIN); fi
    3738        $(CC) $(FULL_CFLAGS) -o $@ $^ $(FULL_LDFLAGS)
     39        @echo "compiled $*"
     40        @echo ""
    3841
    3942$(DESTBIN)/%: $(BIN)/%.$(ARCH)
    … …  
    4144        rm -f $(DESTBIN)/$*
    4245        cp $(BIN)/$*.$(ARCH) $(DESTBIN)/$*
     46        @echo "installed $*"
     47        @echo ""
     48
     49$(PROGRAMS) : % : $(BIN)/%.$(ARCH)
     50
     51%.clean:
     52        rm -f $(SRC)/$*.$(ARCH).o
     53        rm -f $(BIN)/$*.$(ARCH)
    4354
    4455%.install:
    … …  
    4859        for i in $(PROGRAMS); do make $$i.install || exit; done
    4960
    50 %.clean:
    51         rm -f $(SRC)/$*.$(ARCH).o
    52         rm -f $(BIN)/$*.$(ARCH)
    5361
    5462clean:
    … …  
    6169        rm -rf $(BIN)
    6270        rm -rf $(LIB)
     71
     72# $@ : target filename
     73# $* : matched word (%)
     74# $< : first prereq
     75# $^ : all prereqs
     76
     77.PRECIOUS: %.$(ARCH).o
     78.PRECIOUS: $(BIN)/%.$(ARCH)
     79

  • trunk/Ohana/src/tools/src/ckfits.c

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

  • trunk/Ohana/src/tools/src/fields.c

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

  • trunk/Ohana/src/tools/src/ftable.c

    r12399 r15487  
    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);

  • trunk/Ohana/src/tools/src/mefhead.c

    r12333 r15487  
    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.