fitshead.c

00001 /*******************************************************************************
00002 * E.S.O. - VLT project
00003 *
00004 *
00005 *
00006 * who       when      what
00007 * --------  --------  ----------------------------------------------
00008 * schreib  19/02/02  created
00009 */
00010 
00011 /************************************************************************
00012 *   NAME
00013 *        fitshead.c -
00014 *        routines to read fits header keywords
00015 *
00016 *   SYNOPSIS
00017 *   #include "fitshead.h"
00018 *
00019 *   1) float spiffi_get_exptime ( char * filename )
00020 *   2) int spiffi_get_skyspiderposindex ( char * filename, int * posindicator )
00021 *   3) float spiffi_get_cumoffsetx ( char * filename )
00022 *   4) float spiffi_get_cumoffsety ( char * filename )
00023 *   5) float spiffi_get_pixelscale ( char * filename )
00024 *   6) float spiffi_get_RA ( char * filename )
00025 *   7) float spiffi_get_DEC ( char * filename )
00026 *   8) float spiffi_get_posangle ( char * filename )
00027 *   9) float spiffi_get_cenpix ( char * filename )
00028 *  10) float spiffi_get_cenLambda ( char * filename )
00029 *  11) float spiffi_get_dispersion ( char * filename )
00030 *
00031 *
00032 *   DESCRIPTION
00033 *   1) reads the exposure time keyword in the FITS-header 
00034 *   2) reads sky spider keyword HIERARCH ESO INS MIRR1 NAME in the FITS-header 
00035 *   3) reads keyword HIERARCH ESO SEQ CUMOFFSETX in the FITS-header 
00036 *   4) reads keyword HIERARCH ESO SEQ CUMOFFSETY in the FITS-header 
00037 *   5) reads keyword HIERARCH ESO INS OPTI Name (pixelscale) in the FITS-header 
00038 *   6) reads keyword RA in the FITS-header 
00039 *   7) reads keyword DEC in the FITS-header 
00040 *   8) reads keyword HIERARCH ESO ADA POSANG in the FITS-header 
00041 *   9) reads keyword CRPIX3 in the FITS-header 
00042 *  10) reads keyword CRVAL3 in the FITS-header 
00043 *  11) reads keyword CDELT3 in the FITS-header 
00044 *
00045 *
00046 *   FILES
00047 *
00048 *   ENVIRONMENT
00049 *
00050 *   RETURN VALUES
00051 *
00052 *   CAUTIONS
00053 *
00054 *   EXAMPLES
00055 *
00056 *   SEE ALSO
00057 *
00058 *   BUGS
00059 *
00060 *------------------------------------------------------------------------
00061 */
00062 
00063 #include "vltPort.h"
00064 
00065 
00066 
00067 
00068 /*
00069  * System Headers
00070  */
00071 
00072 /*
00073  * Local Headers
00074  */
00075 
00076 #include "fitshead.h"
00077 
00078 /*----------------------------------------------------------------------------
00079  *                              Defines
00080  *--------------------------------------------------------------------------*/
00081 
00082 /*----------------------------------------------------------------------------
00083  *                                 Local variables
00084  *--------------------------------------------------------------------------*/
00085 
00086 /*----------------------------------------------------------------------------
00087  *                  Functions private to this module
00088  *--------------------------------------------------------------------------*/
00089 
00090 /*----------------------------------------------------------------------------
00091  *                          Function codes
00092  *--------------------------------------------------------------------------*/
00093 /*----------------------------------------------------------------------------
00094    Function     :       spiffi_get_ditndit()
00095    In           :       fits file name
00096    Out          :       total integration time in sec
00097    Job          :       reads the product dit*ndit from the FITS-header 
00098  ---------------------------------------------------------------------------*/
00099 float spiffi_get_ditndit ( char * filename )
00100 {
00101   const char* _id="spiffi_get_ditndit";
00102   char * val;
00103   float dit=0. ;
00104   int ndit=0;
00105   if ( NULL != (val = qfits_query_hdr(filename, "DET.DIT")) ) {
00106     dit = atof(val);
00107   } else {
00108     cpl_msg_error(_id,"Cannot read keyword DET.DIT");
00109     return FLAG ;
00110   }
00111   if ( NULL != (val = qfits_query_hdr(filename, "DET.NDIT")) ) {
00112     ndit = atoi(val);
00113   } else {
00114     cpl_msg_error(_id,"Cannot read keyword DET.NDIT");
00115     return FLAG ;
00116   }
00117   return dit*ndit ;
00118 
00119 }
00120 
00121 
00122 /*----------------------------------------------------------------------------
00123    Function     :       spiffi_get_ditndit()
00124    In           :       fits file name
00125    Out          :       total integration time in sec
00126    Job          :       reads the DIT keyword from the FITS-header 
00127  ---------------------------------------------------------------------------*/
00128 
00129 float spiffi_get_dit ( char * filename )
00130 {
00131   const char* _id="spiffi_get_dit";
00132   char * val;
00133   float dit=0. ;
00134 
00135   if ( NULL != (val = qfits_query_hdr(filename, "DET.DIT")) ) {
00136     dit = atof(val);
00137   } else {
00138     cpl_msg_error(_id,"Cannot read keyword DET.DIT");
00139     return FLAG ;
00140   }
00141   return dit;
00142 
00143 }
00144 
00145 /*----------------------------------------------------------------------------
00146    Function     :       spiffi_get_exptime()
00147    In           :       fits file name
00148    Out          :       total integration time in sec
00149    Job          :       reads the exposure time keyword in the FITS-header 
00150  ---------------------------------------------------------------------------*/
00151 float spiffi_get_exptime ( char * filename )
00152 {
00153   const char* _id="spiffi_get_exptime";
00154   char * val;
00155   float exptime ;
00156   if ( NULL != (val = qfits_query_hdr(filename, "EXPTIME")) ) {
00157     exptime = atof(val);
00158   } else {
00159     cpl_msg_error(_id,"Cannot read keyword EXPTIME");
00160     return FLAG ;
00161   }
00162   return exptime ;
00163 
00164 }
00165 
00166 /*----------------------------------------------------------------------------
00167    Function     :","      spiffi_get_skyspiderposindex()
00168    In           :       fits file name
00169    Out          :       position index of the sky spider wheel
00170                         posindicator: integer indicating the place of the 4 possible
00171                                       image edges where the sky is placed.
00172    Job          :       reads sky spider keyword HIERARCH ESO INS MIRR1 NAME in the FITS-header 
00173  ---------------------------------------------------------------------------*/
00174 int * spiffi_get_skyspiderposindex ( char * filename, int * posindicator )
00175 {
00176     fits_header * hdr ;
00177     char        * posindex ;
00178     int         * position ;
00179     char        * mirror ;
00180     char        * mir ;
00181     char        * pos ;
00182     char        * preo ;
00183     int         mi, po ;
00184    
00185     /* allocate memory */
00186     if ( NULL == ( position = (int*)cpl_calloc(2, sizeof(int) ) ) )
00187     {
00188         cpl_msg_error ("spiffi_get_skyspiderposindex:","could not allocate memory\n") ;
00189         return NULL ;
00190     }
00191 
00192     if ( NULL == (hdr = fits_read_header( filename )) ) 
00193     {
00194         cpl_msg_error ("spiffi_get_skyspiderposindex:","cannot read fits header and allocate data structure\n") ;
00195     cpl_free(position) ;
00196         return NULL ;
00197     }
00198     if ( NULL == (posindex = fits_header_getstr(hdr, "HIERARCH ESO INS MIRR1 NAME")) )
00199     {
00200         cpl_msg_error ("spiffi_get_skyspiderposindex:","cannot get position index\n") ;
00201     cpl_free(position) ;
00202         fits_header_destroy(hdr) ;
00203         return NULL ;
00204     }
00205 
00206     if (posindex == "Ref")
00207     {
00208         fits_header_destroy(hdr) ;
00209         return position ;
00210     }
00211         
00212     /* disentangle the position out of the header keyword */
00213     /* first split the string in two parts */
00214     if ( NULL == (mirror = strtok(posindex, "_")) ) 
00215     {
00216         cpl_msg_error ("spiffi_get_skyspiderposindex:","cannot get mirror index\n") ;
00217         fits_header_destroy(hdr) ;
00218         return NULL ;
00219     }
00220     if ( NULL == (preo = strtok(NULL, "_")) ) 
00221     {
00222         cpl_msg_error ("spiffi_get_skyspiderposindex:","cannot get preoptics name\n") ;
00223         fits_header_destroy(hdr) ;
00224         return NULL ;
00225     }
00226     if ( NULL == (pos = strtok(NULL, "_")) ) 
00227     {
00228         cpl_msg_error ("spiffi_get_skyspiderposindex:","cannot get pixel position\n") ;
00229         fits_header_destroy(hdr) ;
00230         return NULL ;
00231     }
00232     if ( NULL == (mir = strtok(mirror, "s")) ) 
00233     {
00234         cpl_msg_error ("spiffi_get_skyspiderposindex:","cannot get mirror index\n") ;
00235         fits_header_destroy(hdr) ;
00236         return NULL ;
00237     }
00238 
00239     if ( mir == "c" )
00240     {
00241         cpl_msg_warning ("spiffi_get_skyspiderposindex:","coronographic mode of sky spider used\n") ;
00242         fits_header_destroy(hdr) ;
00243         return position ;
00244     }
00245     mi = atoi (mir) ;
00246     po = atoi (pos) ;
00247     
00248     if ( po == 0 )
00249     {
00250         fits_header_destroy(hdr) ;
00251         return position ;
00252     }
00253       
00254     switch (mi)
00255     {
00256         case 45:
00257             /* -----------------------------------------------------------------------
00258              * lower right edge 
00259              * convert to image coordinates
00260              */
00261             position[0] = SLITLENGTH - po ;     /* x-axis */
00262             position[1] = po ;             /* y-axis */
00263             *posindicator = 1 ;
00264             break ;
00265         case 15:
00266             /* -----------------------------------------------------------------------
00267              * upper right edge 
00268              * convert to image coordinates
00269              */
00270             position[0] = SLITLENGTH - po ;     /* x-axis */  
00271             position[1] = SLITLENGTH - po ;     /* y-axis */
00272             *posindicator = 2 ;
00273             break ;
00274         case 30:
00275             /* -----------------------------------------------------------------------
00276              * upper left edge 
00277              * convert to image coordinates
00278              */
00279             position[0] = po ;             /* x-axis */
00280             position[1] = SLITLENGTH - po ;    /* y-axis */
00281             *posindicator = 3 ;
00282             break ;
00283         default:
00284             cpl_msg_error ("spiffi_get_skyspiderposindex:","unknown sky spider mirror index!\n") ;
00285             *posindicator = 0 ;
00286         cpl_free(position) ;
00287             fits_header_destroy(hdr) ;
00288             return NULL ;
00289             break ;
00290     }
00291     
00292     fits_header_destroy(hdr) ;
00293     return position ;
00294 }
00295 
00296 /*----------------------------------------------------------------------------
00297    Function     :       spiffi_get_cumoffsetx()
00298    In           :       fits file name
00299    Out          :       magnitude of guide star 
00300    Job          :       reads keyword HIERARCH ESO AOS RTC GUIDESTAR MAGNITUDE in the FITS-header 
00301  ---------------------------------------------------------------------------*/
00302 float spiffi_get_magnitude ( char * filename )
00303 {
00304   const char* _id="spiffi_get_magnitude";
00305   char * val;
00306   float mag ;
00307   if ( NULL != (val = qfits_query_hdr(filename, "AOS.RTC.GUIDESTAR.MAGNITUDE")) ) {
00308     mag = atof(val);
00309   } else {
00310     cpl_msg_error(_id,"Cannot read keyword AOS.RTC.GUIDESTAR.MAGNITUDE");
00311     return FLAG ;
00312   }
00313   return mag ;
00314 
00315 }
00316 
00317        
00318 /*----------------------------------------------------------------------------
00319    Function     :       spiffi_get_cumoffsetx()
00320    In           :       fits file name
00321    Out          :       relative pixel offset of a sequence of jittered exposures 
00322                         in x-direction w.r.t the first frame
00323    Job          :       reads keyword HIERARCH ESO SEQ CUMOFFSETX in the FITS-header 
00324  ---------------------------------------------------------------------------*/
00325 float spiffi_get_cumoffsetx ( char * filename )
00326 {
00327   const char* _id="spiffi_get_cumoffsetx";
00328   char * val;
00329   float cumoffsetx ;
00330   if ( NULL != (val = qfits_query_hdr(filename, "SEQ.CUMOFFSETX")) ) {
00331     cumoffsetx = atof(val);
00332   } else {
00333     cpl_msg_warning(_id,"Cannot read keyword SEQ.CUMOFFSETX");
00334     return FLAG ;
00335   }
00336   return cumoffsetx ;
00337 
00338 }
00339 
00340 
00341 
00342 /*----------------------------------------------------------------------------
00343    Function     :       spiffi_get_cumoffseta()
00344    In           :       fits file name
00345    Out          :       relative pixel offset of a sequence of jittered exposures 
00346                         in x-direction w.r.t the first frame
00347    Job          :       reads keyword HIERARCH ESO SEQ CUMOFFSETA in the FITS-header 
00348  ---------------------------------------------------------------------------*/
00349 float spiffi_get_cumoffseta ( char * filename )
00350 {
00351   const char* _id="spiffi_get_cumoffseta";
00352   char * val;
00353   float cumoffseta ;
00354   if ( NULL != (val = qfits_query_hdr(filename, "SEQ.CUMOFFSETA")) ) {
00355     cumoffseta = atof(val);
00356   } else {
00357     cpl_msg_warning(_id,"Cannot read keyword SEQ.CUMOFFSETA");
00358     return FLAG ;
00359   }
00360   return cumoffseta ;
00361 
00362 }
00363 
00364 
00365 /*----------------------------------------------------------------------------
00366    Function     :       spiffi_get_cumoffsetd()
00367    In           :       fits file name
00368    Out          :       relative pixel offset of a sequence of jittered exposures 
00369                         in x-direction w.r.t the first frame
00370    Job          :       reads keyword HIERARCH ESO SEQ CUMOFFSETD in the FITS-header 
00371  ---------------------------------------------------------------------------*/
00372 float spiffi_get_cumoffsetd ( char * filename )
00373 {
00374   const char* _id="spiffi_get_cumoffsetd";
00375   char * val;
00376   float cumoffsetd ;
00377   if ( NULL != (val = qfits_query_hdr(filename, "SEQ.CUMOFFSETD")) ) {
00378     cumoffsetd = atof(val);
00379   } else {
00380     cpl_msg_warning(_id,"Cannot read keyword SEQ.CUMOFFSETD");
00381     return FLAG ;
00382   }
00383   return cumoffsetd ;
00384 
00385 }
00386 
00387 /*----------------------------------------------------------------------------
00388    Function     :       spiffi_get_reloffsetx()
00389    In           :       fits file name
00390    Out          :       relative pixel offset of a sequence of jittered exposures 
00391                         in x-direction w.r.t the first frame
00392    Job          :       reads keyword HIERARCH ESO SEQ RELOFFSETRA in the FITS-header 
00393  ---------------------------------------------------------------------------*/
00394 float spiffi_get_reloffsetx ( char * filename )
00395 {
00396   const char* _id="spiffi_get_reloffsetx";
00397   char * val;
00398   float reloffsetx ;
00399   if ( NULL != (val = qfits_query_hdr(filename, "SEQ.RELOFFSETRA")) ) {
00400     reloffsetx = atof(val);
00401   } else {
00402     cpl_msg_error(_id,"Cannot read keyword SEQ.RELOFFSETRA");
00403     return FLAG ;
00404   }
00405   return reloffsetx ;
00406 
00407 }
00408 
00409 /*----------------------------------------------------------------------------
00410    Function     :       spiffi_get_cumoffsety()
00411    In           :       fits file name
00412    Out          :       relative pixel offset of a sequence of jittered exposures in 
00413                         y-direction w.r.t. the first frame
00414    Job          :       reads keyword HIERARCH ESO SEQ CUMOFFSETY in the FITS-header 
00415  ---------------------------------------------------------------------------*/
00416 float spiffi_get_cumoffsety ( char * filename )
00417 {
00418   const char* _id="spiffi_get_cumoffsety";
00419   char * val;
00420   float cumoffsety ;
00421   if ( NULL != (val = qfits_query_hdr(filename, "SEQ.CUMOFFSETY")) ) {
00422     cumoffsety = atof(val);
00423   } else {
00424     cpl_msg_warning(_id,"Cannot read keyword SEQ.CUMOFFSETY");
00425     return FLAG ;
00426   }
00427   return cumoffsety ;
00428 
00429 }
00430 
00431 /*----------------------------------------------------------------------------
00432    Function     :       spiffi_get_reloffsety()
00433    In           :       fits file name
00434    Out          :       relative pixel offset of a sequence of jittered exposures in 
00435                         y-direction w.r.t. the first frame
00436    Job          :       reads keyword HIERARCH ESO SEQ RELOFFSETDEC in the FITS-header 
00437  ---------------------------------------------------------------------------*/
00438 float spiffi_get_reloffsety ( char * filename )
00439 {
00440   const char* _id="spiffi_get_reloffsety";
00441   char * val;
00442   float reloffsety ;
00443   if ( NULL != (val = qfits_query_hdr(filename, "SEQ.RELOFFSETDEC")) ) {
00444     reloffsety = atof(val);
00445   } else {
00446     cpl_msg_error(_id,"Cannot read keyword SEQ.RELOFFSETDEC");
00447     return FLAG ;
00448   }
00449   return reloffsety ;
00450 
00451 }
00452 
00453 /*----------------------------------------------------------------------------
00454    Function     :       spiffi_get_pixelscale()
00455    In           :       fits file name
00456    Out          :       pixel scale, if open or ref position of preoptics wheel-> 0 
00457    Job          :       reads keyword HIERARCH ESO INS OPTI1 NAME in the FITS-header 
00458  ---------------------------------------------------------------------------*/
00459 float spiffi_get_pixelscale ( char * filename )
00460 {
00461     fits_header * hdr ;
00462     float pixelscale ;
00463     char * pixscale ;
00464     char * scale ;
00465     
00466     if ( NULL == (hdr = fits_read_header( filename )) ) 
00467     {
00468         cpl_msg_error ("spiffi_get_pixelscale:","cannot read fits header and allocate data structure\n") ;
00469         return 1. ;
00470     }
00471 
00472     if ( NULL == (pixscale = fits_header_getstr(hdr, "HIERARCH ESO INS OPTI1 NAME")) )
00473     {
00474         cpl_msg_error ("spiffi_get_pixelscale:","cannot get preoptics name from header\n") ;
00475         fits_header_destroy(hdr) ;
00476         return 1. ;
00477     }
00478 
00479     if ( NULL == (scale = strchr(pixscale, '0')) )
00480     {
00481         fits_header_destroy(hdr) ;
00482         return 1. ;
00483     }
00484     pixelscale = atof(scale) ;
00485 
00486     fits_header_destroy(hdr) ;
00487     return pixelscale ;
00488 }
00489 
00490 /*----------------------------------------------------------------------------
00491    Function     :       spiffi_get_RA()
00492    In           :       fits file name
00493    Out          :       RA of pointing
00494    Job          :       reads keyword RA in the FITS-header 
00495  ---------------------------------------------------------------------------*/
00496 float spiffi_get_RA ( char * filename )
00497 {
00498   const char* _id="spiffi_get_RA";
00499   char * val;
00500   float ra ;
00501   if ( NULL != (val = qfits_query_hdr(filename, "RA")) ) {
00502     ra = atof(val);
00503   } else {
00504     cpl_msg_warning(_id,"Cannot read keyword RA");
00505     return 1 ;
00506   }
00507   return ra ;
00508 
00509 }
00510 
00511 /*----------------------------------------------------------------------------
00512    Function     :       spiffi_get_DEC()
00513    In           :       fits file name
00514    Out          :       DEC of pointing
00515    Job          :       reads keyword DEC in the FITS-header 
00516  ---------------------------------------------------------------------------*/
00517 float spiffi_get_DEC ( char * filename )
00518 {
00519   const char* _id="spiffi_get_RA";
00520   char * val;
00521   float dec ;
00522   if ( NULL != (val = qfits_query_hdr(filename, "DEC")) ) {
00523     dec = atof(val);
00524   } else {
00525     cpl_msg_warning(_id,"Cannot read keyword DEC");
00526     return 1 ;
00527   }
00528   return dec ;
00529 
00530 }
00531 
00532 /*----------------------------------------------------------------------------
00533    Function     :       spiffi_get_posangle()
00534    In           :       fits file name
00535    Out          :       position angle of rotator
00536    Job          :       reads keyword HIERARCH ESO ADA POSANG in the FITS-header 
00537  ---------------------------------------------------------------------------*/
00538 float spiffi_get_posangle ( char * filename )
00539 {
00540   const char* _id="spiffi_get_posangle";
00541   char * val;
00542   float posangle ;
00543   if ( NULL != (val = qfits_query_hdr(filename, "ADA.POSANG")) ) {
00544     posangle = atof(val);
00545   } else {
00546     cpl_msg_warning(_id,"Cannot read keyword ADA.POSANG");
00547     return 0. ;
00548   }
00549   return posangle ;
00550 
00551 }
00552 
00553 /*----------------------------------------------------------------------------
00554    Function     :       spiffi_get_cenpix()
00555    In           :       fits file name
00556    Out          :       reference pixel of wavelength axis
00557    Job          :       reads keyword CRPIX3 in the FITS-header 
00558  ---------------------------------------------------------------------------*/
00559 float spiffi_get_cenpix ( char * filename )
00560 {
00561   const char* _id="spiffi_get_cenpix";
00562   char * val;
00563   float cenpix ;
00564   if ( NULL != (val = qfits_query_hdr(filename, "CRPIX3")) ) {
00565     cenpix = atof(val);
00566   } else {
00567     cpl_msg_error(_id,"Cannot read keyword CRPIX3");
00568     return 1. ;
00569   }
00570   return cenpix ;
00571 
00572 }
00573 
00574 
00575 /*----------------------------------------------------------------------------
00576    Function     :       spiffi_get_cenLambda()
00577    In           :       fits file name
00578    Out          :       central wavelength
00579    Job          :       reads keyword CRVAL3 in the FITS-header 
00580  ---------------------------------------------------------------------------*/
00581 double spiffi_get_cenLambda ( char * filename )
00582 {
00583   const char* _id="spiffi_get_cenLambda";
00584   char * val;
00585   double cenLambda ;
00586   if ( NULL != (val = qfits_query_hdr(filename, "CRVAL3")) ) {
00587     cenLambda = atof(val);
00588   } else {
00589     cpl_msg_error(_id,"Cannot read keyword CRVAL3");
00590     return 1. ;
00591   }
00592   return cenLambda ;
00593 
00594 }
00595 
00596 /*----------------------------------------------------------------------------
00597    Function     :       spiffi_get_dispersion()
00598    In           :       fits file name
00599    Out          :       microns/pixel
00600    Job          :       reads keyword CDELT3 in the FITS-header 
00601  ---------------------------------------------------------------------------*/
00602 double spiffi_get_dispersion ( char * filename )
00603 {
00604   const char* _id="spiffi_get_dispersion";
00605   char * val;
00606   double dispersion ;
00607   if ( NULL != (val = qfits_query_hdr(filename, "CDELT3")) ) {
00608     dispersion = atof(val);
00609   } else {
00610     cpl_msg_error(_id,"Cannot read keyword CDELT3");
00611     return 1. ;
00612   }
00613   return dispersion ;
00614 
00615 }
00616 
00617 /*--------------------------------------------------------------------------*/
00618 
00619 /*----------------------------------------------------------------------------
00620    Function     :       spiffi_get_naxis1()
00621    In           :       fits file name
00622    Out          :       reference pixel of wavelength axis
00623    Job          :       reads keyword NAXIS1 in the FITS-header
00624  ---------------------------------------------------------------------------*/
00625 float spiffi_get_naxis1 ( char * filename )
00626 {
00627   const char* _id="spiffi_get_naxis1";
00628   char * val;
00629   int naxis1 ;
00630   if ( NULL != (val = qfits_query_hdr(filename, "NAXIS1")) ) {
00631     naxis1 = atoi(val);
00632   } else {
00633     cpl_msg_error(_id,"Cannot read keyword NAXIS1");
00634     return 1. ;
00635   }
00636   return naxis1 ;
00637 
00638 }
00639 
00640 /*----------------------------------------------------------------------------
00641    Function     :       spiffi_get_naxis2()
00642    In           :       fits file name
00643    Out          :       reference pixel of wavelength axis
00644    Job          :       reads keyword CRPIX3 in the FITS-header
00645  ---------------------------------------------------------------------------*/
00646 float spiffi_get_naxis2 ( char * filename )
00647 {
00648   const char* _id="spiffi_get_naxis2";
00649   char * val;
00650   int naxis2 ;
00651   if ( NULL != (val = qfits_query_hdr(filename, "NAXIS2")) ) {
00652     naxis2 = atoi(val);
00653   } else {
00654     cpl_msg_error(_id,"Cannot read keyword NAXIS2");
00655     return 1. ;
00656   }
00657   return naxis2 ;
00658 
00659 }
00660 
00661 
00662 /*----------------------------------------------------------------------------
00663    Function     :       spiffi_get_naxis3()
00664    In           :       fits file name
00665    Out          :       reference pixel of wavelength axis
00666    Job          :       reads keyword CRPIX3 in the FITS-header
00667  ---------------------------------------------------------------------------*/
00668 float spiffi_get_naxis3 ( char * filename )
00669 {
00670   const char* _id="spiffi_get_naxis3";
00671   char * val;
00672   int naxis3 ;
00673   if ( NULL != (val = qfits_query_hdr(filename, "NAXIS3")) ) {
00674     naxis3 = atoi(val);
00675   } else {
00676     cpl_msg_error(_id,"Cannot read keyword NAXIS3");
00677     return 1. ;
00678   }
00679   return naxis3 ;
00680 
00681 }
00682 
00683 

Generated on Wed Oct 26 13:08:52 2005 for SINFONI Pipeline Reference Manual by doxygen1.2.13.1 written by Dimitri van Heesch, © 1997-2001