Ignore:
Timestamp:
Nov 13, 2003, 4:49:45 PM (22 years ago)
Author:
cmv
Message:

Restructuration des fits ecriteur et lecteur:

  • en lecture: lecture des images 2D
  • en ecriture: ecriture des images 2D d'ou restructuration des classes avec heritage sur une class FitWriter

Pour demande DY...

cmv 13/11/2003

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaExt/FitsIOServer/fabtwriter.cc

    r2450 r2453  
    66#include "fabtwriter.h"
    77
     8//////////////////////////////////////////////////////////////
     9//////////////////////////////////////////////////////////////
     10//////////////////////////////////////////////////////////////
     11//////////////////////////////////////////////////////////////
     12/*!
     13  \class SOPHYA::FitsWriter
     14  \ingroup FitsIOServer
     15  Class for writing into a FITS file (DO NOT USE)
     16*/
     17
     18/*! Constructor  (DO NOT USE). */
     19FitsWriter::FitsWriter(string fname,int lp)
     20{
     21  cr_or_upd_fits(fname.c_str(),false,lp);
     22}
     23
     24/*! Constructor (DO NOT USE). */
     25FitsWriter::FitsWriter(const char* cfname,int lp)
     26{
     27  cr_or_upd_fits(cfname,false,lp);
     28}
     29
     30/*! Constructor (DO NOT USE). */
     31FitsWriter::FitsWriter(string fname,bool update,int lp)
     32{
     33  cr_or_upd_fits(fname.c_str(),update,lp);
     34}
     35
     36/*! Constructor (DO NOT USE). */
     37FitsWriter::FitsWriter(const char* cfname,bool update,int lp)
     38{
     39  cr_or_upd_fits(cfname,update,lp);
     40}
     41
     42/*! See FitsWriter() */
     43void FitsWriter::cr_or_upd_fits(const char *cfname,bool update,int lp)
     44{
     45 FitsPtr = NULL;
     46 HduType = 0;
     47 SetDebug(lp);
     48 FitsFN = cfname;
     49 NOverFlow = 0;
     50 Update = update;
     51 // Init key structure
     52 DoubleKey.resize(0);
     53 LongKey.resize(0);
     54 StringKey.resize(0);
     55
     56 if(DbgLevel)
     57   cout<<"FitsWriter::cr_or_upd_fits FitsFN="<<FitsFN<<endl;
     58
     59 if(FitsFN.size() <= 0 )
     60   throw ParmError("FitsWriter::cr_or_upd_fits: Fits file name error\n");
     61
     62 // create or update FITS file
     63 int sta=0;
     64 if(Update) {
     65   if(fits_open_file(&FitsPtr,FitsFN.c_str(),READWRITE,&sta)) {
     66     printerror(sta);
     67     throw NullPtrError("FitsWriter::cr_or_upd_fits: Error opening Fits file for update\n");
     68   }
     69   if(DbgLevel) cout<<"FitsWriter::cr_or_upd_fits: fits file has been opened for update"<<endl;
     70 } else {
     71   if(fits_create_file(&FitsPtr,FitsFN.c_str(),&sta)) {
     72     printerror(sta);
     73     throw NullPtrError("FitsWriter::cr_or_upd_fits: Error creating new Fits file\n");
     74   }
     75   if(DbgLevel) cout<<"FitsWriter::cr_or_upd_fits: a new fits file has been created"<<endl;
     76 }
     77
     78 // create d'un Primary HDU
     79 //long naxes[1] = {0};
     80 //if(fits_create_img(FitsPtr,BYTE_IMG,0,naxes,&sta)) {
     81 //  printerror(sta);
     82 //  throw NullPtrError("FitsWriter::cr_or_upd_fits: Error creating Primary extension\n");
     83 //}
     84}
     85
     86/*! Destructor */
     87FitsWriter::~FitsWriter()
     88{
     89 int sta = 0;
     90 writekeys();
     91 if(fits_close_file(FitsPtr,&sta)) printerror(sta);
     92 FitsPtr = NULL;
     93}
     94
     95/*! Flush the FitsIO buffer to set good Fits file in case of problems */
     96void FitsWriter::Flush(void)
     97{
     98 if(FitsPtr==NULL) return;
     99 int sta = 0;
     100 if(fits_flush_file(FitsPtr,&sta)) printerror(sta);
     101}
     102
     103
     104/*! Write a double value into Fits Header */
     105void FitsWriter::WriteKey(const char *keyname,double val,char* comment)
     106{
     107 if(keyname==NULL || strlen(keyname)<=0) return;
     108 KeyDouble k;
     109 k.keyname=keyname;
     110 k.val=val;
     111 if(comment) k.comment=comment; else k.comment="";
     112 DoubleKey.push_back(k);
     113}
     114
     115/*! Write a long value into Fits Header */
     116void FitsWriter::WriteKey(const char *keyname,long val,char* comment)
     117{
     118 if(keyname==NULL || strlen(keyname)<=0) return;
     119 KeyLong k;
     120 k.keyname=keyname;
     121 k.val=val;
     122 if(comment) k.comment=comment; else k.comment="";
     123 LongKey.push_back(k);
     124}
     125
     126/*! Write a string value into Fits Header */
     127void FitsWriter::WriteKey(const char *keyname,string val,char* comment)
     128{
     129 if(keyname==NULL || strlen(keyname)<=0) return;
     130 KeyString k;
     131 k.keyname=keyname;
     132 k.val=val;
     133 if(comment) k.comment=comment; else k.comment="";
     134 StringKey.push_back(k);
     135}
     136
     137void FitsWriter::writekeys(void)
     138// Ecriture effective des clefs
     139{
     140 if(FitsPtr==NULL) return;
     141 int sta=0;
     142 if(DoubleKey.size()>0)
     143   for(unsigned int i=0;i<DoubleKey.size();i++) {
     144     char* key = const_cast<char*>(DoubleKey[i].keyname.c_str());
     145     char* com = const_cast<char*>(DoubleKey[i].comment.c_str());
     146     double val = DoubleKey[i].val;
     147     if(fits_update_key(FitsPtr,TDOUBLE,key,&val,com,&sta))
     148       printerror(sta);
     149   }
     150 if(LongKey.size()>0)
     151   for(unsigned int i=0;i<LongKey.size();i++) {
     152     char* key = const_cast<char*>(LongKey[i].keyname.c_str());
     153     char* com = const_cast<char*>(LongKey[i].comment.c_str());
     154     long val = LongKey[i].val;
     155     if(fits_update_key(FitsPtr,TLONG,key,&val,com,&sta))
     156       printerror(sta);
     157   }
     158 if(StringKey.size()>0)
     159   for(unsigned int i=0;i<StringKey.size();i++) {
     160     char* key = const_cast<char*>(StringKey[i].keyname.c_str());
     161     char* com = const_cast<char*>(StringKey[i].comment.c_str());
     162     char* val = const_cast<char*>(StringKey[i].val.c_str());
     163     if(fits_update_key(FitsPtr,TSTRING,key,val,com,&sta))
     164       printerror(sta);
     165   }
     166 DoubleKey.resize(0);
     167 LongKey.resize(0);
     168 StringKey.resize(0);
     169}
     170
     171void FitsWriter::printerrorwrite(const char* type,int col,long row,int sta)
     172{
     173 if(sta==NUM_OVERFLOW) {NOverFlow++; return;}
     174 printerror(sta);
     175 char str[256];
     176 sprintf(str,"FitsWriter::Write_%s: Error Writing Fits c=%d r=%ld sta=%d"
     177        ,type,col,row,sta);
     178 throw NotAvailableOperation(str);
     179}
     180
     181void FitsWriter::printerror(int sta) const
     182{
     183 int stat = sta;
     184 fits_report_error(stdout,stat);
     185 fflush(stdout);
     186 return;
     187}
     188
     189//////////////////////////////////////////////////////////////////
     190//////////////////////////////////////////////////////////////////
     191//////////////////////////////////////////////////////////////////
     192//////////////////////////////////////////////////////////////////
    8193/*!
    9194  \class SOPHYA::FitsABTWriter
    … …  
    117302*/
    118303FitsABTWriter::FitsABTWriter(string fname,int hdutype,int lp)
    119 {
    120   cr_or_upd_fits(fname.c_str(),false,hdutype,lp);
     304: FitsWriter(fname,lp)
     305{
     306 FirstTime = true;
     307 HduType = hdutype;
     308 if(HduType!=BINARY_TBL && HduType!=ASCII_TBL)
     309   throw
     310     TypeMismatchExc("FitsABTWriter::FitsABTWriter: Only BINARY or ASCII table permitted\n");
    121311}
    122312
    … …  
    128318*/
    129319FitsABTWriter::FitsABTWriter(const char* cfname,int hdutype,int lp)
    130 {
    131   cr_or_upd_fits(cfname,false,hdutype,lp);
     320: FitsWriter(cfname,lp)
     321{
     322 FirstTime = true;
     323 HduType = hdutype;
     324 if(HduType!=BINARY_TBL && HduType!=ASCII_TBL)
     325   throw
     326     TypeMismatchExc("FitsABTWriter::FitsABTWriter: Only BINARY or ASCII table permitted\n");
    132327}
    133328
    … …  
    140335*/
    141336FitsABTWriter::FitsABTWriter(string fname,bool update,int hdutype,int lp)
    142 {
    143   cr_or_upd_fits(fname.c_str(),update,hdutype,lp);
     337: FitsWriter(fname,update,lp)
     338{
     339 FirstTime = true;
     340 HduType = hdutype;
     341 if(HduType!=BINARY_TBL && HduType!=ASCII_TBL)
     342   throw
     343     TypeMismatchExc("FitsABTWriter::FitsABTWriter: Only BINARY or ASCII table permitted\n");
    144344}
    145345
    … …  
    152352*/
    153353FitsABTWriter::FitsABTWriter(const char* cfname,bool update,int hdutype,int lp)
    154 {
    155   cr_or_upd_fits(cfname,update,hdutype,lp);
    156 }
    157 
    158 /*! See FitsABTWriter() */
    159 void FitsABTWriter::cr_or_upd_fits(const char *cfname,bool update,int hdutype,int lp)
     354: FitsWriter(cfname,update,lp)
    160355{
    161356 FirstTime = true;
    162  FitsPtr = NULL;
    163357 HduType = hdutype;
    164  SetDebug(lp);
    165  FitsFN = cfname;
    166  NOverFlow = 0;
    167  Update = update;
    168 
    169  if(DbgLevel)
    170    cout<<"FitsABTWriter::cr_or_upd_fits FitsFN="<<FitsFN
    171        <<" HduType="<<HduType<<endl;
    172 
    173  if(FitsFN.size() <= 0 )
    174    throw ParmError("FitsABTWriter::cr_or_upd_fits: Fits file name error\n");
    175 
    176358 if(HduType!=BINARY_TBL && HduType!=ASCII_TBL)
    177    throw TypeMismatchExc("FitsABTWriter::cr_or_upd_fits: Only BINARY or ASCII table permitted\n");
    178 
    179  // create or update FITS file
    180  int sta=0;
    181  if(Update) {
    182    if(fits_open_file(&FitsPtr,FitsFN.c_str(),READWRITE,&sta)) {
    183      printerror(sta);
    184      throw NullPtrError("FitsABTWriter::cr_or_upd_fits: Error opening Fits file for update\n");
    185    }
    186    if(DbgLevel) cout<<"FitsABTWriter::cr_or_upd_fits: fits file has been opened for update"<<endl;
    187  } else {
    188    if(fits_create_file(&FitsPtr,FitsFN.c_str(),&sta)) {
    189      printerror(sta);
    190      throw NullPtrError("FitsABTWriter::cr_or_upd_fits: Error creating new Fits file\n");
    191    }
    192    if(DbgLevel) cout<<"FitsABTWriter::cr_or_upd_fits: a new fits file has been created"<<endl;
    193  }
    194 
    195  // create d'un Primary HDU
    196  //long naxes[1] = {0};
    197  //if(fits_create_img(FitsPtr,BYTE_IMG,0,naxes,&sta)) {
    198  //  printerror(sta);
    199  //  throw NullPtrError("FitsABTWriter::cr_or_upd_fits: Error creating Primary extension\n");
    200  //}
    201 
     359   throw
     360     TypeMismatchExc("FitsABTWriter::FitsABTWriter: Only BINARY or ASCII table permitted\n");
    202361}
    203362
    … …  
    205364FitsABTWriter::~FitsABTWriter()
    206365{
    207  int sta = 0;
    208  writekeys();
    209  if(fits_close_file(FitsPtr,&sta)) printerror(sta);
    210  FitsPtr = NULL;
    211 }
    212 
    213 /*! Flush the FitsIO buffer to set good Fits file in case of problems */
    214 void FitsABTWriter::Flush(void)
    215 {
    216  if(FitsPtr==NULL) return;
    217  int sta = 0;
    218  if(fits_flush_file(FitsPtr,&sta)) printerror(sta);
    219 }
    220 
    221 /*! Write a double value into Fits Header */
    222 void FitsABTWriter::WriteKey(const char *keyname,double val,char* comment)
    223 {
    224  if(keyname==NULL || strlen(keyname)<=0) return;
    225  KeyDouble k;
    226  k.keyname=keyname;
    227  k.val=val;
    228  if(comment) k.comment=comment; else k.comment="";
    229  DoubleKey.push_back(k);
    230 }
    231 
    232 /*! Write a long value into Fits Header */
    233 void FitsABTWriter::WriteKey(const char *keyname,long val,char* comment)
    234 {
    235  if(keyname==NULL || strlen(keyname)<=0) return;
    236  KeyLong k;
    237  k.keyname=keyname;
    238  k.val=val;
    239  if(comment) k.comment=comment; else k.comment="";
    240  LongKey.push_back(k);
    241 }
    242 
    243 /*! Write a string value into Fits Header */
    244 void FitsABTWriter::WriteKey(const char *keyname,string val,char* comment)
    245 {
    246  if(keyname==NULL || strlen(keyname)<=0) return;
    247  KeyString k;
    248  k.keyname=keyname;
    249  k.val=val;
    250  if(comment) k.comment=comment; else k.comment="";
    251  StringKey.push_back(k);
    252 }
    253 
    254 void FitsABTWriter::writekeys(void)
    255 // Ecriture effective des clefs
    256 {
    257  if(FitsPtr==NULL) return;
    258  int sta=0;
    259  if(DoubleKey.size()>0)
    260    for(unsigned int i=0;i<DoubleKey.size();i++) {
    261      char* key = const_cast<char*>(DoubleKey[i].keyname.c_str());
    262      char* com = const_cast<char*>(DoubleKey[i].comment.c_str());
    263      double val = DoubleKey[i].val;
    264      if(fits_update_key(FitsPtr,TDOUBLE,key,&val,com,&sta))
    265        printerror(sta);
    266    }
    267  if(LongKey.size()>0)
    268    for(unsigned int i=0;i<LongKey.size();i++) {
    269      char* key = const_cast<char*>(LongKey[i].keyname.c_str());
    270      char* com = const_cast<char*>(LongKey[i].comment.c_str());
    271      long val = LongKey[i].val;
    272      if(fits_update_key(FitsPtr,TLONG,key,&val,com,&sta))
    273        printerror(sta);
    274    }
    275  if(StringKey.size()>0)
    276    for(unsigned int i=0;i<StringKey.size();i++) {
    277      char* key = const_cast<char*>(StringKey[i].keyname.c_str());
    278      char* com = const_cast<char*>(StringKey[i].comment.c_str());
    279      char* val = const_cast<char*>(StringKey[i].val.c_str());
    280      if(fits_update_key(FitsPtr,TSTRING,key,val,com,&sta))
    281        printerror(sta);
    282    }
    283  DoubleKey.resize(0);
    284  LongKey.resize(0);
    285  StringKey.resize(0);
    286366}
    287367
    … …  
    303383                         ,const char* tunit,int datatype)
    304384{
    305   if(!FirstTime)
    306     throw AllocationError("FitsABTWriter::addcol: table already created\n");
     385 if(!FirstTime)
     386   throw AllocationError("FitsABTWriter::addcol: table already created\n");
    307387 
    308388 // Gestion auto du tform pour les tables binaires avec le datatype (si non-definie)
    … …  
    402482 }
    403483
    404  // Append Fits key
    405  writekeys();
    406 
    407484 // menage
    408485 if(extname) delete [] extname;
    … …  
    591668}
    592669
    593 //////////////////////////////////////////////////////////////
    594 void FitsABTWriter::printerrorwrite(const char* type,int col,long row,int sta)
    595 {
    596  if(sta==NUM_OVERFLOW) {NOverFlow++; return;}
    597  printerror(sta);
    598  char str[256];
    599  sprintf(str,"FitsABTWriter::Write_%s: Error Writing Fits c=%d r=%ld sta=%d"
    600         ,type,col,row,sta);
    601  throw NotAvailableOperation(str);
    602 }
    603 
    604 /////////////////////////////////////////////////
    605 void FitsABTWriter::printerror(int sta) const
    606 {
    607  int stat = sta;
    608  fits_report_error(stdout,stat);
    609  fflush(stdout);
    610  return;
    611 }
    612 
    613670/////////////////////////////////////////////////
    614671void FitsABTWriter::Print(ostream& os,int lp) const
    … …  
    621678    os<<i<<"... Label="<<Label[i]<<" TForm="<<TForm[i]<<" TUnit="<<TUnit[i]<<endl;
    622679}
     680
     681//////////////////////////////////////////////////////////////////
     682//////////////////////////////////////////////////////////////////
     683//////////////////////////////////////////////////////////////////
     684//////////////////////////////////////////////////////////////////
     685/*!
     686  \class SOPHYA::FitsImg2DWriter
     687  \ingroup FitsIOServer
     688  Class for writing an image into FITS file
     689*/
     690
     691/*!
     692  Constructor.
     693  \param fname : FITS file name to be written (a new fits file is created)
     694  \param bitpix : image type (BYTE_IMG,USHORT_IMG,SHORT_IMG,LONG_IMG,FLOAT_IMG,DOUBLE_IMG)
     695  \param lp : debug level
     696*/
     697FitsImg2DWriter::FitsImg2DWriter(string fname,int bitpix,int lp)
     698: FitsWriter(fname,lp)
     699{
     700 BitPix = bitpix;
     701 HduType = IMAGE_HDU;
     702 FirstTime = true;
     703 Naxis[0] = Naxis[1] = 0;
     704}
     705
     706/*!
     707  Constructor.
     708  \param cfname : FITS file name to be written (a new fits file is created)
     709  \param bitpix : image type (BYTE_IMG,USHORT_IMG,SHORT_IMG,LONG_IMG,FLOAT_IMG,DOUBLE_IMG)
     710  \param lp : debug level
     711*/
     712FitsImg2DWriter::FitsImg2DWriter(const char* cfname,int bitpix,int lp)
     713: FitsWriter(cfname,lp)
     714{
     715 BitPix = bitpix;
     716 HduType = IMAGE_HDU;
     717 FirstTime = true;
     718 Naxis[0] = Naxis[1] = 0;
     719}
     720
     721/*!
     722  Constructor.
     723  \param fname : FITS file name to be written (created or updated)
     724  \param update : file is created if FALSE, open for update if TRUE
     725  \param bitpix : image type (BYTE_IMG,USHORT_IMG,SHORT_IMG,LONG_IMG,FLOAT_IMG,DOUBLE_IMG)
     726  \param lp : debug level
     727*/
     728FitsImg2DWriter::FitsImg2DWriter(string fname,bool update,int bitpix,int lp)
     729: FitsWriter(fname,update,lp)
     730{
     731 BitPix = bitpix;
     732 HduType = IMAGE_HDU;
     733 FirstTime = true;
     734 Naxis[0] = Naxis[1] = 0;
     735}
     736
     737/*!
     738  Constructor.
     739  \param cfname : FITS file name to be written (created or updated)
     740  \param update : file is created if FALSE, open for update if TRUE
     741  \param bitpix : image type (BYTE_IMG,USHORT_IMG,SHORT_IMG,LONG_IMG,FLOAT_IMG,DOUBLE_IMG)
     742  \param lp : debug level
     743*/
     744FitsImg2DWriter::FitsImg2DWriter(const char* cfname,bool update,int bitpix,int lp)
     745: FitsWriter(cfname,update,lp)
     746{
     747 BitPix = bitpix;
     748 HduType = IMAGE_HDU;
     749 FirstTime = true;
     750 Naxis[0] = Naxis[1] = 0;
     751}
     752
     753/*! Destructor */
     754FitsImg2DWriter::~FitsImg2DWriter()
     755{
     756}
     757
     758/*! Create the image. Done at the first write request. */
     759void FitsImg2DWriter::createimg(void)
     760{
     761 if(!FirstTime)
     762   throw NotAvailableOperation("FitsImg2DWriter::createimg: already created image\n");
     763 if(Naxis[0]<=0 || Naxis[1]<=0)
     764   throw ParmError("FitsImg2DWriter::createimg: bad Naxis 1 or 2 value\n");
     765
     766 int sta=0;
     767 if(fits_create_img(FitsPtr,BitPix,2,Naxis,&sta)) {
     768   printerror(sta);
     769   throw NullPtrError("FitsImg2DWriter::createimg: Error creating image extension\n");
     770 }
     771
     772 FirstTime = false;
     773}
     774
     775/*!
     776  Write an image to FITS file.
     777  \warning TMatrix data(Naxis2,Naxis1)
     778*/
     779void FitsImg2DWriter::Write(TMatrix<uint_2>& data)
     780{
     781 Naxis[0]=data.NCols(); Naxis[1]=data.NRows(); createimg();
     782 uint_2* arr = new uint_2[Naxis[0]];
     783
     784 for(int j=0;j<Naxis[1];j++) {
     785   for(int i=0;i<Naxis[0];i++) arr[i] = data(j,i);
     786   long deb = j*Naxis[0]+1, nel = Naxis[0]; int sta=0;
     787   fits_write_img(FitsPtr,TUSHORT,deb,nel,arr,&sta);
     788   if(sta) {
     789     printerror(sta); delete [] arr;
     790     throw
     791       NotAvailableOperation("FitsImg2DRd::Write(TMatrix<uint_2>): Error Writing Fits file\n");
     792   }
     793 }
     794
     795 delete [] arr;
     796}
     797
     798/*! Write an image to FITS file. */
     799void FitsImg2DWriter::Write(TMatrix<int_4>& data)
     800{
     801 int T = (sizeof(long)==4) ? TLONG: TINT;
     802 Naxis[0]=data.NCols(); Naxis[1]=data.NRows(); createimg();
     803 int_4* arr = new int_4[Naxis[0]];
     804
     805 for(int j=0;j<Naxis[1];j++) {
     806   for(int i=0;i<Naxis[0];i++) arr[i] = data(j,i);
     807   long deb = j*Naxis[0]+1, nel = Naxis[0]; int sta=0;
     808   fits_write_img(FitsPtr,T,deb,nel,arr,&sta);
     809   if(sta) {
     810     printerror(sta); delete [] arr;
     811     throw
     812       NotAvailableOperation("FitsImg2DRd::Write(TMatrix<int_4>): Error Writing Fits file\n");
     813   }
     814 }
     815
     816 delete [] arr;
     817}
     818
     819/*! Write an image to FITS file. */
     820void FitsImg2DWriter::Write(TMatrix<float>& data)
     821{
     822 Naxis[0]=data.NCols(); Naxis[1]=data.NRows(); createimg();
     823 float* arr = new float[Naxis[0]];
     824
     825 for(int j=0;j<Naxis[1];j++) {
     826   for(int i=0;i<Naxis[0];i++) arr[i] = data(j,i);
     827   long deb = j*Naxis[0]+1, nel = Naxis[0]; int sta=0;
     828   fits_write_img(FitsPtr,TFLOAT,deb,nel,arr,&sta);
     829   if(sta) {
     830     printerror(sta); delete [] arr;
     831     throw
     832       NotAvailableOperation("FitsImg2DRd::Write(TMatrix<float>): Error Writing Fits file\n");
     833   }
     834 }
     835
     836 delete [] arr;
     837}
     838
     839/*! Write an image to FITS file. */
     840void FitsImg2DWriter::Write(TMatrix<double>& data)
     841{
     842 Naxis[0]=data.NCols(); Naxis[1]=data.NRows(); createimg();
     843 double* arr = new double[Naxis[0]];
     844
     845 for(int j=0;j<Naxis[1];j++) {
     846   for(int i=0;i<Naxis[0];i++) arr[i] = data(j,i);
     847   long deb = j*Naxis[0]+1, nel = Naxis[0]; int sta=0;
     848   fits_write_img(FitsPtr,TDOUBLE,deb,nel,arr,&sta);
     849   if(sta) {
     850     printerror(sta); delete [] arr;
     851     throw
     852       NotAvailableOperation("FitsImg2DRd::Write(TMatrix<double>): Error Writing Fits file\n");
     853   }
     854 }
     855
     856 delete [] arr;
     857}
     858
     859/*! Print infos. */
     860void FitsImg2DWriter::Print(ostream& os) const
     861{
     862os<<"FitsImg2DWriter::Print: FitsFN "<<FitsFN<<endl
     863  <<"  HduType "<<HduType<<"  NOverFlow "<<NOverFlow<<"  BitPix "<<BitPix
     864  <<"  Naxis1 "<<Naxis[0]<<"  Naxis2 "<<Naxis[1]<<endl;
     865}
Note: See TracChangeset for help on using the changeset viewer.