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
00228 template<typename T> void read_column
00229 (int colnum, std::vector<T> &data, int64 offset=0) const
00230 { read_column_raw (colnum, &(data[0]), data.size(), offset); }
00231
00232 template<typename T> void read_column
00233 (int colnum, T &data, int64 offset=0) const
00234 { read_column_raw (colnum, &data, 1, offset); }
00235
00236
00237 template<typename T> void read_entire_column
00238 (int colnum, arr<T> &data) const
00239 {
00240 data.alloc(safe_cast<tsize>(nelems(colnum)));
00241 read_column (colnum, data);
00242 }
00243
00244
00245 template<typename T> void read_entire_column
00246 (int colnum, std::vector<T> &data) const
00247 {
00248 data.resize(safe_cast<tsize>(nelems(colnum)));
00249 read_column (colnum, data);
00250 }
00251
00252 void write_column_raw_void
00253 (int colnum, const void *data, PDT type, int64 num, int64 offset=0);
00254
00255
00256 template<typename T> void write_column_raw
00257 (int colnum, const T *data, int64 num, int64 offset=0)
00258 { write_column_raw_void (colnum, data, planckType<T>(), num, offset); }
00259
00260
00261 template<typename T> void write_column
00262 (int colnum, const arr<T> &data, int64 offset=0)
00263 { write_column_raw (colnum, &(data[0]), data.size(), offset); }
00264
00265
00266 template<typename T> void write_column
00267 (int colnum, const std::vector<T> &data, int64 offset=0)
00268 { write_column_raw (colnum, &(data[0]), data.size(), offset); }
00269
00270 template<typename T> void write_column
00271 (int colnum, const T &data, int64 offset=0)
00272 { write_column_raw (colnum, &data, 1, offset); }
00273
00274
00275
00276
00277
00278
00279
00280 template<typename T> void read_image (arr2<T> &data) const;
00281
00282 template<typename T> void read_image (arr3<T> &data) const;
00283
00284
00285
00286 template<typename T> void read_subimage
00287 (arr2<T> &data, int xl, int yl) const;
00288 void read_subimage_void (void *data, PDT type, tsize ndata, int64 offset=0)
00289 const;
00290
00291
00292
00293 template<typename T> void read_subimage (arr<T> &data, int64 offset=0)
00294 const
00295 { read_subimage_void (&data[0],planckType<T>(),data.size(),offset); }
00296
00297 void write_image2D_void (const void *data, PDT type, tsize s1,
00298 tsize s2);
00299
00300
00301 template<typename T> void write_image (const arr2<T> &data)
00302 {
00303 write_image2D_void (&data[0][0],planckType<T>(),data.size1(),
00304 data.size2());
00305 }
00306
00307 void write_subimage_void (const void *data, PDT type, tsize sz,
00308 int64 offset);
00309
00310
00311
00312 template<typename T> void write_subimage (const arr<T> &data,
00313 int64 offset=0)
00314 { write_subimage_void(&data[0],planckType<T>(),data.size(),offset); }
00315
00316
00317 };
00318
00319
00320
00321 #endif