CCfits: PHDUT.h Source File

CCfits 2.7

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List

PHDUT.h

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