00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032 #ifndef PLANCK_FITSHANDLE_H
00033 #define PLANCK_FITSHANDLE_H
00034
00035 #include <string>
00036 #include <vector>
00037 #include "arr.h"
00038 #include "datatypes.h"
00039 #include "safe_cast.h"
00040
00041
00042
00043
00044
00045 class fitscolumn
00046 {
00047 private:
00048 std::string name_, unit_;
00049 int64 repcount_;
00050 PDT type_;
00051
00052 public:
00053 fitscolumn();
00054
00055
00056 fitscolumn (const std::string &nm, const std::string &un, int64 rc, PDT tp);
00057 ~fitscolumn();
00058
00059
00060 const std::string &name() const {return name_;}
00061
00062 const std::string &unit() const {return unit_;}
00063
00064 int64 repcount() const {return repcount_;}
00065
00066 PDT type() const {return type_;}
00067 };
00068
00069
00070 class fitshandle
00071 {
00072 private:
00073 enum { INVALID = -4711 };
00074
00075 mutable int status;
00076 void *fptr;
00077 int hdutype_, bitpix_;
00078 std::vector<int64> axes_;
00079 std::vector<fitscolumn> columns_;
00080 int64 nrows_;
00081
00082 void check_errors() const;
00083
00084 void clean_data();
00085 void clean_all();
00086
00087 bool connected() const { return (hdutype_!=INVALID); }
00088 bool table_hdu (tsize col) const;
00089 bool image_hdu () const;
00090
00091 void init_image();
00092 void init_asciitab();
00093 void init_bintab();
00094 void init_data();
00095
00096 void read_col (int colnum, void *data, int64 ndata, PDT type,
00097 int64 offset) const;
00098 void write_col (int colnum, const void *data, int64 ndata, PDT type,
00099 int64 offset);
00100
00101 void getKeyHelper(const std::string &name) const;
00102
00103 public:
00104
00105 enum openmethod { CREATE,
00106 OPEN
00107 };
00108
00109
00110
00111
00112
00113 fitshandle ();
00114
00115 ~fitshandle();
00116
00117
00118 void open (const std::string &fname);
00119
00120 void create (const std::string &fname);
00121
00122 void close () { clean_all(); }
00123
00124 static void delete_file (const std::string &name);
00125
00126 std::string fileName() const;
00127
00128 void goto_hdu (int hdu);
00129
00130 int num_hdus () const;
00131
00132 void assert_pdmtype (const std::string &pdmtype) const;
00133
00134
00135 void insert_bintab (const std::vector<fitscolumn> &cols,
00136 const std::string &extname="xtension");
00137
00138
00139
00140 void insert_asctab (const std::vector<fitscolumn> &cols,
00141 const std::string &extname="xtension");
00142
00143
00144 void insert_image (PDT type, const std::vector<int64> &Axes);
00145
00146
00147 template<typename T>
00148 void insert_image (PDT type, const arr2<T> &data);
00149
00150
00151
00152 void write_checksum();
00153
00154
00155
00156
00157
00158
00159
00160 const std::vector<int64> &axes() const;
00161
00162 const std::string &colname(int i) const;
00163
00164 const std::string &colunit(int i) const;
00165
00166 int64 repcount(int i) const;
00167
00168 PDT coltype(int i) const;
00169
00170 int ncols() const;
00171
00172 int64 nrows() const;
00173
00174
00175 int64 nelems(int i) const;
00176
00177
00178 int64 efficientChunkSize(int i) const;
00179
00180
00181
00182
00183
00184
00185
00186
00187 void get_all_keys (std::vector<std::string> &keys) const;
00188
00189 void set_key_void (const std::string &key, const void *value, PDT type,
00190 const std::string &comment="");
00191
00192 template<typename T> void set_key (const std::string &name,
00193 const T &value, const std::string &comment="")
00194 { set_key_void (name, &value, planckType<T>(), comment); }
00195
00196 void delete_key (const std::string &name);
00197
00198 void add_comment (const std::string &comment);
00199 void get_key_void (const std::string &key, void *value, PDT type) const;
00200
00201 template<typename T> void get_key (const std::string &name, T &value) const
00202 { get_key_void (name,&value,planckType<T>()); }
00203
00204 template<typename T> T get_key (const std::string &name) const
00205 { T tmp; get_key(name, tmp); return tmp; }
00206
00207 bool key_present (const std::string &name) const;
00208
00209
00210
00211
00212
00213
00214 void read_column_raw_void
00215 (int colnum, void *data, PDT type, int64 num, int64 offset=0) const;
00216
00217
00218 template<typename T> void read_column_raw
00219 (int colnum, T *data, int64 num, int64 offset=0) const
00220 { read_column_raw_void (colnum, data, planckType<T>(), num, offset); }
00221
00222
00223 template<typename T> void read_column
00224 (int colnum, arr<T> &data, int64 offset=0) const
00225 { read_column_raw (colnum, &(data[0]), data.size(), offset); }
00226
00227 template<typename T> void read_column
00228 (int colnum, T &data, int64 offset=0) const
00229 { read_column_raw (colnum, &data, 1, offset); }
00230
00231
00232 template<typename T> void read_entire_column
00233 (int colnum, arr<T> &data) const
00234 {
00235 data.alloc(safe_cast<tsize>(nelems(colnum)));
00236 read_column (colnum, data);
00237 }
00238
00239 void write_column_raw_void
00240 (int colnum, const void *data, PDT type, int64 num, int64 offset=0);
00241
00242
00243 template<typename T> void write_column_raw
00244 (int colnum, const T *data, int64 num, int64 offset=0)
00245 { write_column_raw_void (colnum, data, planckType<T>(), num, offset); }
00246
00247
00248 template<typename T> void write_column
00249 (int colnum, const arr<T> &data, int64 offset=0)
00250 { write_column_raw (colnum, &(data[0]), data.size(), offset); }
00251
00252 template<typename T> void write_column
00253 (int colnum, const T &data, int64 offset=0)
00254 { write_column_raw (colnum, &data, 1, offset); }
00255
00256
00257
00258
00259
00260
00261
00262 template<typename T> void read_image (arr2<T> &data) const;
00263
00264 template<typename T> void read_image (arr3<T> &data) const;
00265
00266
00267
00268 template<typename T> void read_subimage
00269 (arr2<T> &data, int xl, int yl) const;
00270 void read_subimage_void (void *data, PDT type, tsize ndata, int64 offset=0)
00271 const;
00272
00273
00274
00275 template<typename T> void read_subimage (arr<T> &data, int64 offset=0)
00276 const
00277 { read_subimage_void (&data[0],planckType<T>(),data.size(),offset); }
00278
00279 void write_image2D_void (const void *data, PDT type, tsize s1,
00280 tsize s2);
00281
00282
00283 template<typename T> void write_image (const arr2<T> &data)
00284 {
00285 write_image2D_void (&data[0][0],planckType<T>(),data.size1(),
00286 data.size2());
00287 }
00288
00289 void write_subimage_void (const void *data, PDT type, tsize sz,
00290 int64 offset);
00291
00292
00293
00294 template<typename T> void write_subimage (const arr<T> &data,
00295 int64 offset=0)
00296 { write_subimage_void(&data[0],planckType<T>(),data.size(),offset); }
00297
00298
00299 };
00300
00301
00302
00303 #endif