IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

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/libfits
Files:
10 added
22 edited

Legend:

Unmodified
Added
Removed

  • 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;
Note: See TracChangeset for help on using the changeset viewer.