• Main Page
  • Related Pages
  • Modules
  • Namespaces
  • Classes
  • Files
  • File List

ExtHDUT.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 #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                         // proceed if cast is successful.                  
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                         // FITSutil::fill will take care of sizing.
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                 // throw if we called image read/write operations on a table.
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(&copyData[0],&copyData[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(&copyData[0],&copyData[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(&copyData[0],&copyData[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(&copyData[0],&copyData[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(&copyData[0],&copyData[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                 // throw if we called image read/write operations on a table.
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                 // throw if we called image read/write operations on a table.
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                          // write input type S to Image type...
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 } //namespace CCfits
00636 
00637 #endif

Generated on Thu Nov 18 2010 11:59:59 for CCfits by  doxygen 1.7.2