PrimaryHDU.h

00001 //      This is version 1.6 release dated Nov 2006
00002 //      Astrophysics Science Division,
00003 //      NASA/ Goddard Space Flight Center
00004 //      HEASARC
00005 //      http://heasarc.gsfc.nasa.gov
00006 //      e-mail: ccfits@legacy.gsfc.nasa.gov
00007 //
00008 //      Original author: Ben Dorman, L3-Communications EER Systems Inc.
00009 
00010 #ifndef PRIMARYHDU_H
00011 #define PRIMARYHDU_H 1
00012 
00013 // valarray
00014 #include <valarray>
00015 // PHDU
00016 #include "PHDU.h"
00017 // HDUCreator
00018 #include "HDUCreator.h"
00019 // Image
00020 #include "Image.h"
00021 // FITS
00022 #include "FITS.h"
00023 #include "CCfits.h"
00024 #include <functional>
00025 #include <numeric>
00026 #include <memory>
00027 
00028 
00029 namespace CCfits {
00030 
00031 
00032 
00033   template <typename T>
00034   class PrimaryHDU : public PHDU  //## Inherits: <unnamed>%394E6F870338
00035   {
00036 
00037     public:
00038         virtual PrimaryHDU<T> * clone (FITSBase* p) const;
00039         //      Read data reads the image if readFlag is true and
00040         //      optional keywords if supplied. Thus, with no arguments,
00041         //      readData() does nothing.
00042         virtual void readData (bool readFlag = false, const std::vector<String>& keys = std::vector<String>());
00043         const std::valarray<T>& image () const;
00044         std::valarray<T>& image ();
00045         void setImage (const std::valarray<T>& inData);
00046         //      Read data reads the image if readFlag is true and
00047         //      optional keywords if supplied. Thus, with no arguments,
00048         //      readData() does nothing.
00049         virtual const std::valarray<T>& readImage (long first, long nElements, T* nullValue);
00050         //      Read data reads the image if readFlag is true and
00051         //      optional keywords if supplied. Thus, with no arguments,
00052         //      readData() does nothing.
00053         virtual const std::valarray<T>& readImage (const std::vector<long>& firstVertex, const std::vector<long>& lastVertex, const std::vector<long>& stride, T* nullValue);
00054         //      Read data reads the image if readFlag is true and
00055         //      optional keywords if supplied. Thus, with no arguments,
00056         //      readData() does nothing.
00057         virtual void writeImage (long first, long nElements, const std::valarray<T>& inData, T* nullValue = 0);
00058         //      Read data reads the image if readFlag is true and
00059         //      optional keywords if supplied. Thus, with no arguments,
00060         //      readData() does nothing.
00061         virtual void writeImage (const std::vector<long>& firstVertex, const std::vector<long>& lastVertex, const std::vector<long>& stride, const std::valarray<T>& inData);
00062 
00063       // Additional Public Declarations
00064 
00065     protected:
00066         //      Constructor for new FITS objects, takes as arguments
00067         //      the required keywords for a primary HDU.
00068         PrimaryHDU (FITSBase* p, const int bitpix, const int naxis, const std::vector<long>& naxes, const std::valarray<T>& data = std::valarray<T>());
00069         //      Custom constructor. Allows specification of data to be read and whether to read data at
00070         //      construction or wait until the image data are requested. The default is 'lazy initialization:'
00071         //      wait until asked.
00072         PrimaryHDU (FITSBase* p, bool readFlag = false, const std::vector<String>& keys = std::vector<String>());
00073 
00074       // Additional Protected Declarations
00075 
00076     private:
00077         PrimaryHDU(const PrimaryHDU< T > &right);
00078         PrimaryHDU< T > & operator=(const PrimaryHDU< T > &right);
00079 
00080         virtual std::ostream & put (std::ostream &s) const;
00081         const Image<T>& data () const;
00082 
00083       // Additional Private Declarations
00084 
00085     private: //## implementation
00086       // Data Members for Associations
00087         Image<T> m_data;
00088 
00089       // Additional Implementation Declarations
00090       friend class HDUCreator;
00091       friend class PHDU;
00092   };
00093 
00094   // Parameterized Class CCfits::PrimaryHDU 
00095 
00096   template <typename T>
00097   inline std::ostream & PrimaryHDU<T>::put (std::ostream &s) const
00098   {
00099   s << "PrimaryHDU:: Simple? " << simple() << " Extend?: " << extend() << 
00100     " Bitpix: " << bitpix() << " naxis = " << axes() << "\n";
00101   s << "Axis Lengths: \n";
00102 
00103 
00104 
00105   for (int i=0; i < axes(); i++)
00106      s  << " axis[" << i << "] " << axis(i) << "\n";
00107 
00108  s << "\nNumber of keywords read: " << keyWord().size() <<  "\n";
00109 
00110   for (std::map<String,Keyword*>::const_iterator ki = keyWord().begin();
00111         ki != keyWord().end(); ki++)
00112   {
00113         s << *((*ki).second) << std::endl;              
00114   }  
00115 
00116 
00117   s << " HISTORY: " << history() << '\n';
00118   s << " COMMENTS: " <<comment() << '\n';
00119   return s;  
00120   }
00121 
00122   template <typename T>
00123   inline const Image<T>& PrimaryHDU<T>::data () const
00124   {
00125     return m_data;
00126   }
00127 
00128   // Parameterized Class CCfits::PrimaryHDU 
00129 
00130   template <typename T>
00131   PrimaryHDU<T>::PrimaryHDU(const PrimaryHDU<T> &right)
00132       : PHDU(right), m_data(right.m_data)
00133   {
00134   }
00135 
00136   template <typename T>
00137   PrimaryHDU<T>::PrimaryHDU (FITSBase* p, const int bitpix, const int naxis, const std::vector<long>& naxes, const std::valarray<T>& data)
00138         : PHDU(p,bitpix,naxis,naxes),m_data(data)
00139   {
00140   }
00141 
00142   template <typename T>
00143   PrimaryHDU<T>::PrimaryHDU (FITSBase* p, bool readFlag, const std::vector<String>& keys)
00144         : PHDU(p), m_data()
00145   {
00146   initRead();
00147 
00148   if (readFlag || keys.size()) readData(readFlag,keys);  
00149 
00150   }
00151 
00152 
00153   template <typename T>
00154   PrimaryHDU<T> * PrimaryHDU<T>::clone (FITSBase* p) const
00155   {
00156   PrimaryHDU<T>* cloned = new PrimaryHDU<T>(*this);
00157   cloned->parent() = p;
00158   return cloned;
00159   }
00160 
00161   template <typename T>
00162   void PrimaryHDU<T>::readData (bool readFlag, const std::vector<String>& keys)
00163   {
00164 
00165   // Default reading mode. Read everything if readFlag is true.
00166   makeThisCurrent();
00167 
00168   if ( keys.size() > 0) 
00169   {
00170         std::list<String> keyList(keys.size());
00171         // keys is converted to a list so that any keys not in the header
00172         // can be easily erased. internally an exception will be thrown,
00173         // on a missing key, and its catch clause will print a message.
00174         std::copy(keys.begin(),keys.end(),keyList.begin());
00175         readKeywords(keyList);
00176   }
00177   // read the entire image, setting null values to the
00178   // return value from FitsNullValue<T>. It would be easy to make the null value
00179   // a user defined input, but that's not implemented yet.
00180   if ( readFlag && (naxis() > 0) )  
00181   {
00182         FITSUtil::FitsNullValue<T> null;
00183         long init(1);
00184         T nulValue(null());
00185         long nelements(std::accumulate(&naxes()[0],&naxes()[naxis()],init,std::multiplies<long>() ));
00186         readImage(1,nelements,&nulValue);
00187 
00188     }
00189   }
00190 
00191   template <typename T>
00192   const std::valarray<T>& PrimaryHDU<T>::image () const
00193   {
00194 
00195     return m_data.image();
00196   }
00197 
00198   template <typename T>
00199   std::valarray<T>& PrimaryHDU<T>::image ()
00200   {
00201 
00202     return m_data.image();
00203   }
00204 
00205   template <typename T>
00206   void PrimaryHDU<T>::setImage (const std::valarray<T>& inData)
00207   {
00208     m_data.image().resize(inData.size());
00209     m_data.setImage(inData);
00210   }
00211 
00212   template <typename T>
00213   const std::valarray<T>& PrimaryHDU<T>::readImage (long first, long nElements, T* nullValue)
00214   {
00215     makeThisCurrent();
00216     return m_data.readImage(fitsPointer(),first,nElements,nullValue,naxes(),anynul());
00217   }
00218 
00219   template <typename T>
00220   const std::valarray<T>& PrimaryHDU<T>::readImage (const std::vector<long>& firstVertex, const std::vector<long>& lastVertex, const std::vector<long>& stride, T* nullValue)
00221   {
00222     makeThisCurrent();
00223     return m_data.readImage(fitsPointer(),firstVertex,lastVertex,stride,nullValue,naxes(),anynul());
00224   }
00225 
00226   template <typename T>
00227   void PrimaryHDU<T>::writeImage (long first, long nElements, const std::valarray<T>& inData, T* nullValue)
00228   {
00229     m_data.writeImage(fitsPointer(),first,nElements,inData,naxes(),nullValue);
00230   }
00231 
00232   template <typename T>
00233   void PrimaryHDU<T>::writeImage (const std::vector<long>& firstVertex, const std::vector<long>& lastVertex, const std::vector<long>& stride, const std::valarray<T>& inData)
00234   {
00235     m_data.writeImage(fitsPointer(),firstVertex,lastVertex,stride,inData,naxes());
00236   }
00237 
00238   // Additional Declarations
00239 
00240 } // namespace CCfits
00241 
00242 
00243 #endif

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