ExtHDUT.h

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

Generated on Fri Nov 3 17:09:05 2006 for CCfits by  doxygen 1.4.7