ExtHDUT.h

00001 //1
00002 //2
00003 //3
00004 //4
00005 
00006 //      This is version 1.8 dated Oct 2007
00007 
00008 //      Astrophysics Science Division,
00009 //      NASA/ Goddard Space Flight Center
00010 //      HEASARC
00011 //      http://heasarc.gsfc.nasa.gov
00012 //      e-mail: ccfits@legacy.gsfc.nasa.gov
00013 //
00014 //      Original author: Ben Dorman, L3-Communications EER Systems Inc.
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                         // proceed if cast is successful.                  
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                         // FITSutil::fill will take care of sizing.
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                 // throw if we called image read/write operations on a table.
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(&copyData[0],&copyData[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(&copyData[0],&copyData[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(&copyData[0],&copyData[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(&copyData[0],&copyData[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(&copyData[0],&copyData[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                 // throw if we called image read/write operations on a table.
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                 // throw if we called image read/write operations on a table.
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                          // write input type S to Image type...
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 } //namespace CCfits
00643 
00644 #endif

Generated on Fri Oct 12 13:39:38 2007 for CCfits by  doxygen 1.4.7