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
00033
00034 #ifndef PLANCK_FITSHANDLE_H
00035 #define PLANCK_FITSHANDLE_H
00036
00037 #include <string>
00038 #include <vector>
00039 #include "fitsio.h"
00040 #include "arr.h"
00041 #include "datatypes.h"
00042
00043
00044
00045
00046 template<typename T> struct FITSUTIL {};
00047
00048 template<> struct FITSUTIL<int>
00049 { enum { DTYPE=TINT }; };
00050 template<> struct FITSUTIL<long>
00051 { enum { DTYPE=TLONG }; };
00052 template<> struct FITSUTIL<float>
00053 { enum { DTYPE=TFLOAT }; };
00054 template<> struct FITSUTIL<double>
00055 { enum { DTYPE=TDOUBLE }; };
00056
00057
00058 class fitscolumn
00059 {
00060 private:
00061 std::string name_, unit_;
00062 long repcount_;
00063 int type_;
00064
00065 public:
00066
00067
00068 fitscolumn (const std::string &nm, const std::string &un, long rc, int tp)
00069 : name_(nm), unit_(un), repcount_(rc), type_(tp) {}
00070
00071
00072 const std::string &name() const {return name_;}
00073
00074 const std::string &unit() const {return unit_;}
00075
00076 long repcount() const {return repcount_;}
00077
00078 int type() const {return type_;}
00079 };
00080
00081
00082 class fitshandle
00083 {
00084 private:
00085 enum { INVALID = -4711 };
00086
00087 int status;
00088 fitsfile *fptr;
00089 int hdutype_, bitpix_;
00090 std::vector<long> axes_;
00091 std::vector<fitscolumn> columns_;
00092 long nrows_;
00093
00094 void check_errors();
00095
00096 void clean_data();
00097 void clean_all();
00098
00099 void assert_connected (const std::string &func) const
00100 {
00101 planck_assert (hdutype_!=INVALID,
00102 func + ": not connected to a HDU");
00103 }
00104 void assert_table_hdu (const std::string &func, unsigned int col) const
00105 {
00106 planck_assert ((hdutype_==ASCII_TBL) || (hdutype_==BINARY_TBL),
00107 func + ": HDU is not a table");
00108 planck_assert (col>0 && col<=columns_.size(),
00109 func + ": column number out of range");
00110 }
00111 void assert_image_hdu (const std::string &func) const
00112 {
00113 planck_assert ((hdutype_==IMAGE_HDU), func + ": HDU is not an image");
00114 }
00115
00116 void init_image();
00117 void init_asciitab();
00118 void init_bintab();
00119 void init_data();
00120
00121 void check_key_present(const std::string &name);
00122
00123 void read_col (int colnum, void *data, long ndata, int dtype,
00124 long offset);
00125 void write_col (int colnum, const void *data, long ndata, int dtype,
00126 long offset);
00127
00128 public:
00129
00130 typedef enum { CREATE,
00131 OPEN
00132 } openmethod;
00133
00134
00135
00136
00137
00138 fitshandle ()
00139 : status(0), fptr(0), hdutype_(INVALID), bitpix_(INVALID), nrows_(0) {}
00140
00141
00142
00143 fitshandle (const std::string &fname, openmethod mode=OPEN,
00144 int rwmode=READONLY)
00145 : status(0), fptr(0), hdutype_(INVALID), bitpix_(INVALID), nrows_(0)
00146 {
00147 if (mode==OPEN)
00148 open (fname, rwmode);
00149 else
00150 create (fname);
00151 }
00152
00153
00154
00155
00156 fitshandle (const std::string &fname, int hdunum, int rwmode=READONLY)
00157 : status(0), fptr(0), hdutype_(INVALID), bitpix_(INVALID), nrows_(0)
00158 {
00159 open (fname, rwmode);
00160 goto_hdu (hdunum);
00161 }
00162
00163
00164 ~fitshandle() { clean_all(); }
00165
00166
00167
00168
00169 void open (const std::string &fname, int rwmode=READONLY);
00170
00171 void create (const std::string &fname);
00172
00173 void close () { clean_all(); }
00174
00175 void goto_hdu (int hdu);
00176
00177 void assert_pdmtype (const std::string &pdmtype);
00178
00179 void insert_bintab (const std::vector<fitscolumn> &cols);
00180
00181
00182 void insert_asctab (const std::vector<fitscolumn> &cols);
00183
00184
00185 void insert_image (int btpx, const std::vector<long> &Axes);
00186
00187
00188 template<typename T>
00189 void insert_image (int btpx, const arr2<T> &data);
00190
00191
00192
00193
00194
00195
00196
00197
00198 int bitpix() const
00199 {
00200 assert_image_hdu ("fitshandle::bitpix()");
00201 return bitpix_;
00202 }
00203
00204 int hdutype() const {return hdutype_;}
00205
00206 const std::vector<long> &axes() const
00207 {
00208 assert_image_hdu ("fitshandle::axes()");
00209 return axes_;
00210 }
00211
00212 const std::string &colname(int i) const
00213 {
00214 assert_table_hdu("fitshandle::colname()",i);
00215 return columns_[i-1].name();
00216 }
00217
00218 const std::string &colunit(int i) const
00219 {
00220 assert_table_hdu("fitshandle::colunit()",i);
00221 return columns_[i-1].unit();
00222 }
00223
00224 long repcount(int i) const
00225 {
00226 assert_table_hdu("fitshandle::repcount()",i);
00227 return columns_[i-1].repcount();
00228 }
00229
00230 int coltype(int i) const
00231 {
00232 assert_table_hdu("fitshandle::coltype()",i);
00233 return columns_[i-1].type();
00234 }
00235
00236 int ncols() const
00237 {
00238 assert_table_hdu("fitshandle::ncols()",1);
00239 return columns_.size();
00240 }
00241
00242 int nrows() const
00243 {
00244 assert_table_hdu("fitshandle::nrows()",1);
00245 return nrows_;
00246 }
00247
00248
00249 long nelems(int i) const
00250 {
00251 assert_table_hdu("fitshandle::nelems()",i);
00252 if (columns_[i-1].type()==TSTRING) return nrows_;
00253 return nrows_*columns_[i-1].repcount();
00254 }
00255
00256
00257
00258
00259
00260
00261
00262
00263 void copy_header (const fitshandle &orig);
00264
00265
00266
00267 void copy_historified_header (const fitshandle &orig);
00268
00269
00270
00271 template<typename T> void add_key (const std::string &name, const T &value,
00272 const std::string &comment="");
00273
00274 template<typename T> void update_key (const std::string &name,
00275 const T &value, const std::string &comment="");
00276
00277 void delete_key (const std::string &name);
00278
00279 void add_comment (const std::string &comment);
00280
00281 template<typename T> void get_key (const std::string &name, T &value);
00282
00283 template<typename T> T get_key (const std::string &name)
00284 { T tmp; get_key(name, tmp); return tmp; }
00285
00286 bool key_present (const std::string &name);
00287
00288
00289
00290
00291
00292
00293 void read_column_raw_void
00294 (int colnum, void *data, int type, long num, long offset=0);
00295
00296
00297 template<typename T> void read_column_raw
00298 (int colnum, T *data, long num, long offset=0)
00299 { read_column_raw_void (colnum, data, typehelper<T>::id, num, offset); }
00300
00301
00302 template<typename T> void read_column
00303 (int colnum, arr<T> &data, long offset=0)
00304 { read_column_raw (colnum, &(data[0]), data.size(), offset); }
00305
00306 template<typename T> void read_column
00307 (int colnum, T &data, long offset=0)
00308 { read_column_raw (colnum, &data, 1, offset); }
00309
00310
00311 template<typename T> void read_entire_column (int colnum, arr<T> &data)
00312 { data.alloc(nelems(colnum)); read_column (colnum, data); }
00313
00314
00315 void write_column_raw_void
00316 (int colnum, const void *data, int type, long num, long offset=0);
00317
00318
00319 template<typename T> void write_column_raw
00320 (int colnum, const T *data, long num, long offset=0)
00321 { write_column_raw_void (colnum, data, typehelper<T>::id, num, offset); }
00322
00323
00324 template<typename T> void write_column
00325 (int colnum, const arr<T> &data, long offset=0)
00326 { write_column_raw (colnum, &(data[0]), data.size(), offset); }
00327
00328 template<typename T> void write_column
00329 (int colnum, const T &data, long offset=0)
00330 { write_column_raw (colnum, &data, 1, offset); }
00331
00332
00333
00334
00335
00336
00337
00338 template<typename T> void read_image (arr2<T> &data);
00339
00340
00341
00342 template<typename T> void read_subimage (arr2<T> &data, int xl, int yl);
00343
00344
00345
00346 template<typename T> void read_subimage (arr<T> &data, long offset=0);
00347
00348
00349 template<typename T> void write_image (const arr2<T> &data);
00350
00351
00352
00353 template<typename T> void write_subimage (const arr<T> &data,
00354 long offset=0);
00355
00356
00357
00358 void add_healpix_keys (int datasize);
00359 };
00360
00361
00362
00363
00364 template<> void fitshandle::add_key(const std::string &name,
00365 const bool &value, const std::string &comment);
00366 template<> void fitshandle::add_key (const std::string &name,
00367 const std::string &value, const std::string &comment);
00368 template<> void fitshandle::update_key(const std::string &name,
00369 const bool &value, const std::string &comment);
00370 template<> void fitshandle::update_key (const std::string &name,
00371 const std::string &value, const std::string &comment);
00372 template<> void fitshandle::get_key(const std::string &name,bool &value);
00373 template<> void fitshandle::get_key (const std::string &name,
00374 std::string &value);
00375
00376 #endif