00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #ifndef EXTHDUT_H
00013 #define EXTHDUT_H
00014 #include "ImageExt.h"
00015 #include "Table.h"
00016 #include "Column.h"
00017
00018 namespace CCfits
00019 {
00020 template <typename S>
00021 void ExtHDU::read (std::valarray<S>& image)
00022 {
00023 makeThisCurrent();
00024 long init(1);
00025 long nElements(std::accumulate(naxes().begin(),naxes().end(),init,
00026 std::multiplies<long>()));
00027 read(image,1,nElements,static_cast<S*>(0));
00028
00029
00030 }
00031
00032
00033
00034 template <typename S>
00035 void ExtHDU::read (std::valarray<S>& image, long first,long nElements)
00036 {
00037 makeThisCurrent();
00038 read(image, first,nElements,static_cast<S*>(0));
00039 }
00040
00041 template <typename S>
00042 void ExtHDU::read (std::valarray<S>& image, long first, long nElements, S* nulValue)
00043 {
00044
00045 makeThisCurrent();
00046 if ( ImageExt<S>* extimage = dynamic_cast<ImageExt<S>*>(this))
00047 {
00048
00049 const std::valarray<S>& __tmp
00050 = extimage->readImage(first,nElements,nulValue);
00051 image.resize(__tmp.size());
00052 image = __tmp;
00053 }
00054 else
00055 {
00056 if (bitpix() == Ifloat)
00057 {
00058 ImageExt<float>& extimage
00059 = dynamic_cast<ImageExt<float>&>(*this);
00060 float nulVal(0);
00061 if (nulValue) nulVal = static_cast<float>(*nulValue);
00062 FITSUtil::fill(image,
00063 extimage.readImage(first,nElements,&nulVal));
00064 }
00065 else if (bitpix() == Idouble)
00066 {
00067 ImageExt<double>& extimage
00068 = dynamic_cast<ImageExt<double>&>(*this);
00069 double nulVal(0);
00070 if (nulValue) nulVal = static_cast<double>(*nulValue);
00071 FITSUtil::fill(image,
00072 extimage.readImage(first,nElements,&nulVal));
00073 }
00074 else if (bitpix() == Ibyte)
00075 {
00076 ImageExt<unsigned char>& extimage
00077 = dynamic_cast<ImageExt<unsigned char>&>(*this);
00078 unsigned char nulVal(0);
00079 if (nulValue) nulVal = static_cast<unsigned char>(*nulValue);
00080 FITSUtil::fill(image,
00081 extimage.readImage(first,nElements,&nulVal));
00082 }
00083 else if (bitpix() == Ilong)
00084 {
00085 if ( zero() == ULBASE && scale() == 1)
00086 {
00087 ImageExt<unsigned long>& extimage
00088 = dynamic_cast<ImageExt<unsigned long>&>(*this);
00089 unsigned long nulVal(0);
00090 if (nulValue) nulVal
00091 = static_cast<unsigned long>(*nulValue);
00092 FITSUtil::fill(image,
00093 extimage.readImage(first,nElements,&nulVal));
00094 }
00095 else
00096 {
00097 ImageExt<long>& extimage
00098 = dynamic_cast<ImageExt<long>&>(*this);
00099 long nulVal(0);
00100 if (nulValue) nulVal = static_cast<long>(*nulValue);
00101 FITSUtil::fill(image,
00102 extimage.readImage(first,nElements,&nulVal));
00103 }
00104 }
00105 else if (bitpix() == Ishort)
00106 {
00107 if ( zero() == USBASE && scale() == 1)
00108 {
00109 ImageExt<unsigned short>& extimage
00110 = dynamic_cast<ImageExt<unsigned short>&>(*this);
00111 unsigned short nulVal(0);
00112 if (nulValue) nulVal
00113 = static_cast<unsigned short>(*nulValue);
00114 FITSUtil::fill(image,
00115 extimage.readImage(first,nElements,&nulVal));
00116 }
00117 else
00118 {
00119 ImageExt<short>& extimage
00120 = dynamic_cast<ImageExt<short>&>(*this);
00121 short nulVal(0);
00122 if (nulValue) nulVal = static_cast<short>(*nulValue);
00123 FITSUtil::fill(image,
00124 extimage.readImage(first,nElements,&nulVal));
00125 }
00126 }
00127 else
00128 {
00129 throw CCfits::FitsFatal(" casting image types ");
00130 }
00131 }
00132
00133 }
00134
00135 template<typename S>
00136 void ExtHDU::read (std::valarray<S>& image, const std::vector<long>& first,
00137 long nElements,
00138 S* nulValue)
00139 {
00140 makeThisCurrent();
00141 long firstElement(0);
00142 long dimSize(1);
00143 std::vector<long> inputDimensions(naxis(),1);
00144 size_t sNaxis = static_cast<size_t>(naxis());
00145 size_t n(std::min(sNaxis,first.size()));
00146 std::copy(&first[0],&first[n],&inputDimensions[0]);
00147 for (long i = 0; i < naxis(); ++i)
00148 {
00149
00150 firstElement += ((inputDimensions[i] - 1)*dimSize);
00151 dimSize *=naxes(i);
00152 }
00153 ++firstElement;
00154
00155
00156 read(image, firstElement,nElements,nulValue);
00157
00158
00159
00160 }
00161
00162 template<typename S>
00163 void ExtHDU::read (std::valarray<S>& image, const std::vector<long>& first,
00164 long nElements)
00165 {
00166 makeThisCurrent();
00167 read(image, first,nElements,static_cast<S*>(0));
00168
00169 }
00170
00171 template<typename S>
00172 void ExtHDU::read (std::valarray<S>& image, const std::vector<long>& firstVertex,
00173 const std::vector<long>& lastVertex,
00174 const std::vector<long>& stride,
00175 S* nulValue)
00176 {
00177 makeThisCurrent();
00178 if (ImageExt<S>* extimage = dynamic_cast<ImageExt<S>*>(this))
00179 {
00180 const std::valarray<S>& __tmp
00181 = extimage->readImage(firstVertex,lastVertex,stride,nulValue);
00182 image.resize(__tmp.size());
00183 image = __tmp;
00184 }
00185 else
00186 {
00187
00188 if (bitpix() == Ifloat)
00189 {
00190 float nulVal(0);
00191 if (nulValue) nulVal = static_cast<float>(*nulValue);
00192 ImageExt<float>& extimage = dynamic_cast<ImageExt<float>&>(*this);
00193 FITSUtil::fill(image,
00194 extimage.readImage(firstVertex,lastVertex,stride,&nulVal));
00195 }
00196 else if (bitpix() == Idouble)
00197 {
00198 ImageExt<double>& extimage = dynamic_cast<ImageExt<double>&>(*this);
00199 double nulVal(0);
00200 if (nulValue) nulVal = static_cast<double>(*nulValue);
00201 FITSUtil::fill(image,
00202 extimage.readImage(firstVertex,lastVertex,stride,&nulVal));
00203 }
00204 else if (bitpix() == Ibyte)
00205 {
00206 ImageExt<unsigned char>& extimage
00207 = dynamic_cast<ImageExt<unsigned char>&>(*this);
00208 unsigned char nulVal(0);
00209 if (nulValue) nulVal = static_cast<unsigned char>(*nulValue);
00210 FITSUtil::fill(image,
00211 extimage.readImage(firstVertex,lastVertex,stride,&nulVal));
00212 }
00213 else if (bitpix() == Ilong)
00214 {
00215 if ( zero() == ULBASE && scale() == 1)
00216 {
00217 ImageExt<unsigned long>& extimage
00218 = dynamic_cast<ImageExt<unsigned long>&>(*this);
00219 unsigned long nulVal(0);
00220 if (nulValue)
00221 nulVal = static_cast<unsigned long>(*nulValue);
00222 FITSUtil::fill(image,
00223 extimage.readImage(firstVertex,lastVertex,stride,&nulVal));
00224 }
00225 else
00226 {
00227 ImageExt<long>& extimage = dynamic_cast<ImageExt<long>&>(*this);
00228 long nulVal(0);
00229 if (nulValue) nulVal = static_cast<long>(*nulValue);
00230 FITSUtil::fill(image,
00231 extimage.readImage(firstVertex,lastVertex,stride,&nulVal));
00232 }
00233 }
00234 else if (bitpix() == Ishort)
00235 {
00236 if ( zero() == USBASE && scale() == 1)
00237 {
00238 ImageExt<unsigned short>& extimage
00239 = dynamic_cast<ImageExt<unsigned short>&>(*this);
00240 unsigned short nulVal(0);
00241 if (nulValue) nulVal
00242 = static_cast<unsigned short>(*nulValue);
00243 FITSUtil::fill(image,
00244 extimage.readImage(firstVertex,lastVertex,stride,&nulVal));
00245 }
00246 else
00247 {
00248 ImageExt<short>& extimage
00249 = dynamic_cast<ImageExt<short>&>(*this);
00250 short nulVal(0);
00251 if (nulValue) nulVal = static_cast<short>(*nulValue);
00252 FITSUtil::fill(image,
00253 extimage.readImage(firstVertex,lastVertex,stride,&nulVal));
00254 }
00255 }
00256 else
00257 {
00258 throw CCfits::FitsFatal(" casting image types ");
00259 }
00260 }
00261 }
00262
00263 template<typename S>
00264 void ExtHDU::read (std::valarray<S>& image, const std::vector<long>& firstVertex,
00265 const std::vector<long>& lastVertex,
00266 const std::vector<long>& stride)
00267 {
00268 makeThisCurrent();
00269 read(image, firstVertex,lastVertex,stride,static_cast<S*>(0));
00270 }
00271
00272 template <typename S>
00273 void ExtHDU::write(long first,long nElements,const std::valarray<S>& data,S* nulValue)
00274 {
00275
00276 makeThisCurrent();
00277 if (ImageExt<S>* extimage = dynamic_cast<ImageExt<S>*>(this))
00278 {
00279 extimage->writeImage(first,nElements,data,nulValue);
00280 }
00281 else
00282 {
00283 if (bitpix() == Ifloat)
00284 {
00285 std::valarray<float> __tmp;
00286 ImageExt<float>& imageExt = dynamic_cast<ImageExt<float>&>(*this);
00287 FITSUtil::fill(__tmp,data);
00288 imageExt.writeImage(first,nElements,__tmp,
00289 static_cast<float*>(nulValue));
00290 }
00291 else if (bitpix() == Idouble)
00292 {
00293 std::valarray<double> __tmp;
00294 ImageExt<double>& imageExt
00295 = dynamic_cast<ImageExt<double>&>(*this);
00296 FITSUtil::fill(__tmp,data);
00297 imageExt.writeImage(first,nElements,__tmp,static_cast<double*>(nulValue));
00298 }
00299 else if (bitpix() == Ibyte)
00300 {
00301 ImageExt<unsigned char>& imageExt
00302 = dynamic_cast<ImageExt<unsigned char>&>(*this);
00303 std::valarray<unsigned char> __tmp;
00304 unsigned char blankVal(0);
00305 try
00306 {
00307
00308 readKey("BLANK",blankVal);
00309 std::valarray<S> copyData(data);
00310 std::replace(©Data[0],©Data[data.size()],
00311 static_cast<unsigned char>(*nulValue),blankVal);
00312
00313 FITSUtil::fill(__tmp,copyData);
00314
00315 imageExt.writeImage(first,nElements,__tmp); }
00316 catch (HDU::NoSuchKeyword)
00317 {
00318 throw NoNullValue("Primary");
00319 }
00320
00321 }
00322 else if (bitpix() == Ilong)
00323 {
00324 if ( zero() == ULBASE && scale() == 1)
00325 {
00326 ImageExt<unsigned long>& imageExt
00327 = dynamic_cast<ImageExt<unsigned long>&>(*this);
00328 std::valarray<unsigned long> __tmp;
00329 unsigned long blankVal(0);
00330 try
00331 {
00332
00333 readKey("BLANK",blankVal);
00334 std::valarray<S> copyData(data);
00335 std::replace(©Data[0],©Data[data.size()],
00336 static_cast<unsigned long>(*nulValue),blankVal);
00337
00338 FITSUtil::fill(__tmp,copyData);
00339 imageExt.writeImage(first,nElements,__tmp);
00340 }
00341 catch (HDU::NoSuchKeyword)
00342 {
00343 throw NoNullValue("Primary");
00344 }
00345 }
00346 else
00347 {
00348 ImageExt<long>& imageExt
00349 = dynamic_cast<ImageExt<long>&>(*this);
00350 std::valarray<long> __tmp;
00351 long blankVal(0);
00352 try
00353 {
00354
00355 readKey("BLANK",blankVal);
00356 std::valarray<S> copyData(data);
00357 std::replace(©Data[0],©Data[data.size()],
00358 static_cast<long>(*nulValue),blankVal);
00359
00360 FITSUtil::fill(__tmp,copyData);
00361 imageExt.writeImage(first,nElements,__tmp);
00362 }
00363 catch (HDU::NoSuchKeyword)
00364 {
00365 throw NoNullValue("Primary");
00366 }
00367 }
00368 }
00369 else if (bitpix() == Ishort)
00370 {
00371 if ( zero() == USBASE && scale() == 1)
00372 {
00373 ImageExt<unsigned short>& imageExt
00374 = dynamic_cast<ImageExt<unsigned short>&>(*this);
00375 std::valarray<unsigned short> __tmp;
00376 unsigned short blankVal(0);
00377 try
00378 {
00379 readKey("BLANK",blankVal);
00380 std::valarray<S> copyData(data);
00381 std::replace(©Data[0],©Data[data.size()],
00382 static_cast<unsigned short>(*nulValue),blankVal);
00383
00384 FITSUtil::fill(__tmp,copyData);
00385 imageExt.writeImage(first,nElements,__tmp);
00386 }
00387 catch (HDU::NoSuchKeyword)
00388 {
00389 throw NoNullValue("Primary");
00390 }
00391 }
00392 else
00393 {
00394 ImageExt<short>& imageExt
00395 = dynamic_cast<ImageExt<short>&>(*this);
00396 std::valarray<short> __tmp;
00397 short blankVal(0);
00398 try
00399 {
00400 readKey("BLANK",blankVal);
00401 std::valarray<S> copyData(data);
00402 std::replace(©Data[0],©Data[data.size()],
00403 static_cast<short>(*nulValue),blankVal);
00404
00405 FITSUtil::fill(__tmp,copyData);
00406 imageExt.writeImage(first,nElements,__tmp);
00407 }
00408 catch (HDU::NoSuchKeyword)
00409 {
00410 throw NoNullValue("Primary");
00411 }
00412 }
00413 }
00414 else
00415 {
00416 FITSUtil::MatchType<S> errType;
00417 throw FITSUtil::UnrecognizedType(FITSUtil::FITSType2String(errType()));
00418 }
00419 }
00420 }
00421
00422 template <typename S>
00423 void ExtHDU::write(long first,
00424 long nElements,const std::valarray<S>& data)
00425 {
00426
00427 makeThisCurrent();
00428 if (ImageExt<S>* extimage = dynamic_cast<ImageExt<S>*>(this))
00429 {
00430 extimage->writeImage(first,nElements,data);
00431 }
00432 else
00433 {
00434 if (bitpix() == Ifloat)
00435 {
00436 std::valarray<float> __tmp;
00437 ImageExt<float>& imageExt = dynamic_cast<ImageExt<float>&>(*this);
00438 FITSUtil::fill(__tmp,data);
00439 imageExt.writeImage(first,nElements,__tmp);
00440 }
00441 else if (bitpix() == Idouble)
00442 {
00443 std::valarray<double> __tmp;
00444 ImageExt<double>& imageExt
00445 = dynamic_cast<ImageExt<double>&>(*this);
00446 FITSUtil::fill(__tmp,data);
00447 imageExt.writeImage(first,nElements,__tmp);
00448 }
00449 else if (bitpix() == Ibyte)
00450 {
00451 ImageExt<unsigned char>& imageExt
00452 = dynamic_cast<ImageExt<unsigned char>&>(*this);
00453 std::valarray<unsigned char> __tmp;
00454 FITSUtil::fill(__tmp,data);
00455 imageExt.writeImage(first,nElements,__tmp);
00456 }
00457 else if (bitpix() == Ilong)
00458 {
00459 if ( zero() == ULBASE && scale() == 1)
00460 {
00461 ImageExt<unsigned long>& imageExt
00462 = dynamic_cast<ImageExt<unsigned long>&>(*this);
00463 std::valarray<unsigned long> __tmp;
00464 FITSUtil::fill(__tmp,data);
00465 imageExt.writeImage(first,nElements,__tmp);
00466 }
00467 else
00468 {
00469 ImageExt<long>& imageExt
00470 = dynamic_cast<ImageExt<long>&>(*this);
00471 std::valarray<long> __tmp;
00472 FITSUtil::fill(__tmp,data);
00473 imageExt.writeImage(first,nElements,__tmp);
00474 }
00475 }
00476 else if (bitpix() == Ishort)
00477 {
00478 if ( zero() == USBASE && scale() == 1)
00479 {
00480 ImageExt<unsigned short>& imageExt
00481 = dynamic_cast<ImageExt<unsigned short>&>(*this);
00482 std::valarray<unsigned short> __tmp;
00483 FITSUtil::fill(__tmp,data);
00484 imageExt.writeImage(first,nElements,__tmp);
00485 }
00486 else
00487 {
00488 ImageExt<short>& imageExt
00489 = dynamic_cast<ImageExt<short>&>(*this);
00490 std::valarray<short> __tmp;
00491 FITSUtil::fill(__tmp,data);
00492 imageExt.writeImage(first,nElements,__tmp);
00493 }
00494 }
00495 else
00496 {
00497 FITSUtil::MatchType<S> errType;
00498 throw FITSUtil::UnrecognizedType(FITSUtil::FITSType2String(errType()));
00499 }
00500 }
00501 }
00502
00503 template <typename S>
00504 void ExtHDU::write(const std::vector<long>& first,
00505 long nElements,
00506 const std::valarray<S>& data,
00507 S* nulValue)
00508 {
00509
00510 makeThisCurrent();
00511 size_t n(first.size());
00512 long firstElement(0);
00513 long dimSize(1);
00514 for (long i = 0; i < first.size(); ++i)
00515 {
00516 firstElement += ((first[i] - 1)*dimSize);
00517 dimSize *=naxes(i);
00518 }
00519 ++firstElement;
00520
00521 write(firstElement,nElements,data,nulValue);
00522 }
00523
00524 template <typename S>
00525 void ExtHDU::write(const std::vector<long>& first,
00526 long nElements,
00527 const std::valarray<S>& data)
00528 {
00529
00530 makeThisCurrent();
00531 size_t n(first.size());
00532 long firstElement(0);
00533 long dimSize(1);
00534 for (long i = 0; i < first.size(); ++i)
00535 {
00536
00537 firstElement += ((first[i] - 1)*dimSize);
00538 dimSize *=naxes(i);
00539 }
00540 ++firstElement;
00541
00542 write(firstElement,nElements,data);
00543 }
00544
00545
00546 template <typename S>
00547 void ExtHDU::write(const std::vector<long>& firstVertex,
00548 const std::vector<long>& lastVertex,
00549 const std::valarray<S>& data)
00550 {
00551 makeThisCurrent();
00552 if (ImageExt<S>* extimage = dynamic_cast<ImageExt<S>*>(this))
00553 {
00554 extimage->writeImage(firstVertex,lastVertex,data);
00555 }
00556 else
00557 {
00558
00559
00560 if (bitpix() == Ifloat)
00561 {
00562 ImageExt<float>& extimage = dynamic_cast<ImageExt<float>&>(*this);
00563 size_t n(data.size());
00564 std::valarray<float> __tmp(n);
00565 for (size_t j= 0; j < n; ++j) __tmp[j] = data[j];
00566 extimage.writeImage(firstVertex,lastVertex,__tmp);
00567
00568 }
00569 else if (bitpix() == Idouble)
00570 {
00571 ImageExt<double>& extimage
00572 = dynamic_cast<ImageExt<double>&>(*this);
00573 size_t n(data.size());
00574 std::valarray<double> __tmp(n);
00575 for (size_t j= 0; j < n; ++j) __tmp[j] = data[j];
00576 extimage.writeImage(firstVertex,lastVertex,__tmp);
00577 }
00578 else if (bitpix() == Ibyte)
00579 {
00580 ImageExt<unsigned char>& extimage
00581 = dynamic_cast<ImageExt<unsigned char>&>(*this);
00582 size_t n(data.size());
00583 std::valarray<unsigned char> __tmp(n);
00584 for (size_t j= 0; j < n; ++j) __tmp[j] = data[j];
00585 extimage.writeImage(firstVertex,lastVertex,__tmp);
00586 }
00587 else if (bitpix() == Ilong)
00588 {
00589 if ( zero() == ULBASE && scale() == 1)
00590 {
00591 ImageExt<unsigned long>& extimage
00592 = dynamic_cast<ImageExt<unsigned long>&>(*this);
00593 size_t n(data.size());
00594 std::valarray<unsigned long> __tmp(n);
00595 for (size_t j= 0; j < n; ++j) __tmp[j] = data[j];
00596 extimage.writeImage(firstVertex,lastVertex,__tmp);
00597 }
00598 else
00599 {
00600 ImageExt<long>& extimage
00601 = dynamic_cast<ImageExt<long>&>(*this);
00602 size_t n(data.size());
00603 std::valarray<long> __tmp(n);
00604 for (size_t j= 0; j < n; ++j) __tmp[j] = data[j];
00605 extimage.writeImage(firstVertex,lastVertex,__tmp);
00606 }
00607 }
00608 else if (bitpix() == Ishort)
00609 {
00610 if ( zero() == USBASE && scale() == 1)
00611 {
00612 ImageExt<unsigned short>& extimage
00613 = dynamic_cast<ImageExt<unsigned short>&>(*this);
00614 size_t n(data.size());
00615 std::valarray<unsigned short> __tmp(n);
00616 for (size_t j= 0; j < n; ++j) __tmp[j] = data[j];
00617 extimage.writeImage(firstVertex,lastVertex,__tmp);
00618 }
00619 else
00620 {
00621 ImageExt<short>& extimage
00622 = dynamic_cast<ImageExt<short>&>(*this);
00623 size_t n(data.size());
00624 std::valarray<short> __tmp(n);
00625 for (size_t j= 0; j < n; ++j) __tmp[j] = data[j];
00626 extimage.writeImage(firstVertex,lastVertex,__tmp);
00627 }
00628 }
00629 else
00630 {
00631 FITSUtil::MatchType<S> errType;
00632 throw FITSUtil::UnrecognizedType(FITSUtil::FITSType2String(errType()));
00633 }
00634 }
00635 }
00636
00637
00638 }
00639
00640 #endif