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