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