00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifdef HAVE_CONFIG_H
00028 #include <config.h>
00029 #endif
00030
00031
00032
00033
00034 #include <math.h>
00035
00036 #include <xsh_dump.h>
00037 #include <xsh_utils.h>
00038 #include <xsh_error.h>
00039 #include <xsh_msg.h>
00040 #include <xsh_qc_handling.h>
00041 #include <xsh_data_instrument.h>
00042 #include <xsh_pfits.h>
00043 #include <string.h>
00044 #include <cpl.h>
00045 #include <stdbool.h>
00046
00054
00055
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00073
00074 double xsh_pfits_get_geolat(const cpl_propertylist * plist)
00075 {
00076 double returnvalue = 0;
00077 returnvalue=cpl_propertylist_get_double(plist,XSH_GEOLAT);
00078 return returnvalue;
00079 }
00080
00081
00087
00088 double xsh_pfits_get_geolon(const cpl_propertylist * plist)
00089 {
00090 double returnvalue = 0;
00091 returnvalue=cpl_propertylist_get_double(plist,XSH_GEOLON);
00092 return returnvalue;
00093 }
00094
00095
00101
00102 double xsh_pfits_get_utc(const cpl_propertylist * plist)
00103 {
00104 double returnvalue = 0;
00105 returnvalue=cpl_propertylist_get_double(plist,XSH_UTC);
00106 return returnvalue;
00107 }
00108
00109
00110
00111
00117
00118 double xsh_pfits_get_pixscale(const cpl_propertylist * plist)
00119 {
00120 const char* val=NULL;
00121 val=cpl_propertylist_get_string(plist,"ESO INS OPTI1 NAME");
00122 return atof(val);
00123 }
00124
00125
00131
00132 double xsh_pfits_get_posangle(const cpl_propertylist * plist)
00133 {
00134 return cpl_propertylist_get_double(plist,"ESO ADA POSANG");
00135 }
00136
00137
00138
00139
00145
00146 double xsh_pfits_get_mjdobs(const cpl_propertylist * plist)
00147 {
00148 double returnvalue = 0;
00149
00150 check_msg(xsh_get_property_value(plist, XSH_MJDOBS,
00151 CPL_TYPE_DOUBLE, &returnvalue),
00152 "Error reading keyword '%s'", XSH_MJDOBS);
00153
00154 cleanup:
00155 return returnvalue;
00156 }
00157
00158
00159
00160
00161
00167
00168
00169 int xsh_pfits_get_naxis (const cpl_propertylist * plist)
00170 {
00171 int ret = 0;
00172
00173 XSH_PFITS_GET( ret, plist, XSH_NAXIS, CPL_TYPE_INT);
00174
00175 cleanup:
00176 return ret;
00177 }
00178
00179
00185
00186 int
00187 xsh_pfits_get_naxis1 (const cpl_propertylist * plist)
00188 {
00189 int ret = 0;
00190
00191 XSH_PFITS_GET( ret, plist, XSH_NAXIS1, CPL_TYPE_INT);
00192
00193 cleanup:
00194 return ret;
00195 }
00196
00197
00203
00204 int xsh_pfits_get_naxis2 (const cpl_propertylist * plist)
00205 {
00206 int ret = 0;
00207
00208 XSH_PFITS_GET( ret, plist, XSH_NAXIS2, CPL_TYPE_INT);
00209
00210 cleanup:
00211 return ret;
00212 }
00213
00219
00220 int xsh_pfits_get_naxis3(const cpl_propertylist * plist)
00221 {
00222 int ret = 0;
00223
00224 XSH_PFITS_GET( ret, plist, XSH_NAXIS3, CPL_TYPE_INT);
00225
00226 cleanup:
00227 return ret;
00228 }
00229
00230 XSH_ARM xsh_pfits_get_arm( const cpl_propertylist * plist)
00231 {
00232 XSH_ARM ret = XSH_ARM_UNDEFINED;
00233 const char *arm = "";
00234
00235 XSH_PFITS_GET( arm, plist, XSH_SEQ_ARM, CPL_TYPE_STRING ) ;
00236 ret = xsh_arm_get( arm ) ;
00237
00238 cleanup:
00239 return ret ;
00240 }
00241
00242
00248
00249 int xsh_pfits_get_binx(const cpl_propertylist * plist)
00250 {
00251 int ret = 0;
00252
00253 XSH_PFITS_GET( ret, plist, XSH_WIN_BINX, CPL_TYPE_INT);
00254
00255 cleanup:
00256 return ret;
00257 }
00258
00259
00265
00266 int xsh_pfits_get_biny(const cpl_propertylist * plist)
00267 {
00268 int ret = 0;
00269
00270 XSH_PFITS_GET( ret, plist, XSH_WIN_BINY, CPL_TYPE_INT);
00271
00272 cleanup:
00273 return ret;
00274 }
00275
00276
00282
00283 int xsh_pfits_get_chip_nx (const cpl_propertylist * plist)
00284 {
00285 int ret = 0;
00286
00287 XSH_PFITS_GET( ret, plist, XSH_CHIP_NX, CPL_TYPE_INT);
00288
00289 cleanup:
00290 return ret;
00291 }
00292
00293
00299
00300 int xsh_pfits_get_chip_ny (const cpl_propertylist * plist)
00301 {
00302 int ret = 0;
00303
00304 XSH_PFITS_GET( ret, plist, XSH_CHIP_NY, CPL_TYPE_INT);
00305
00306 cleanup:
00307 return ret;
00308 }
00309
00310
00316
00317 int xsh_pfits_get_out_nx (const cpl_propertylist * plist)
00318 {
00319 int ret = 0;
00320
00321 XSH_PFITS_GET( ret, plist, XSH_OUT_NX, CPL_TYPE_INT);
00322
00323 cleanup:
00324 return ret;
00325 }
00326
00327
00333
00334 int xsh_pfits_get_out_ny (const cpl_propertylist * plist)
00335 {
00336 int ret = 0;
00337
00338 XSH_PFITS_GET( ret, plist, XSH_OUT_NY, CPL_TYPE_INT);
00339
00340 cleanup:
00341 return ret;
00342 }
00343
00344
00350
00351 int xsh_pfits_get_ovscx (const cpl_propertylist * plist)
00352 {
00353 int ret = 0;
00354
00355 XSH_PFITS_GET( ret, plist, XSH_OVSCX, CPL_TYPE_INT);
00356
00357 cleanup:
00358 return ret;
00359 }
00360
00361
00367
00368 int xsh_pfits_get_ovscy (const cpl_propertylist * plist)
00369 {
00370 int ret = 0;
00371
00372 XSH_PFITS_GET( ret, plist, XSH_OVSCY, CPL_TYPE_INT);
00373
00374 cleanup:
00375 return ret;
00376 }
00377
00378
00384
00385 int xsh_pfits_get_prscx (const cpl_propertylist * plist)
00386 {
00387 int ret = 0;
00388
00389 XSH_PFITS_GET( ret, plist, XSH_PRSCX, CPL_TYPE_INT);
00390
00391 cleanup:
00392 return ret;
00393 }
00394
00395
00401
00402 int xsh_pfits_get_prscy (const cpl_propertylist * plist)
00403 {
00404 int ret = 0;
00405
00406 XSH_PFITS_GET( ret, plist, XSH_PRSCY, CPL_TYPE_INT);
00407
00408 cleanup:
00409 return ret;
00410 }
00411
00412
00418
00419 double xsh_pfits_get_ron (const cpl_propertylist * plist)
00420 {
00421 double ret = 0;
00422
00423 XSH_PFITS_GET( ret, plist, XSH_RON, CPL_TYPE_DOUBLE);
00424
00425 cleanup:
00426 return ret;
00427 }
00428
00429
00430
00431
00437
00438 double xsh_pfits_get_lst (const cpl_propertylist * plist)
00439 {
00440 double ret = 0;
00441
00442 XSH_PFITS_GET( ret, plist, XSH_LST, CPL_TYPE_DOUBLE);
00443
00444 cleanup:
00445 return ret;
00446 }
00447
00448
00449
00455
00456 double xsh_pfits_get_airm_start (const cpl_propertylist * plist)
00457 {
00458 double ret = 1. ;
00459
00460 xsh_get_property_value( plist, XSH_AIRM_START, CPL_TYPE_DOUBLE, &ret ) ;
00461
00462 return ret;
00463 }
00464
00470
00471 double xsh_pfits_get_airm_mean (const cpl_propertylist * plist)
00472 {
00473 double airmass_start=0;
00474 double airmass_end=0;
00475 airmass_start = xsh_pfits_get_airm_start(plist);
00476 airmass_end = xsh_pfits_get_airm_end(plist);
00477
00478 return 0.5*(airmass_start+airmass_end);
00479 }
00480
00486
00487 double xsh_pfits_get_airm_end (const cpl_propertylist * plist)
00488 {
00489 double ret = 1. ;
00490
00491 xsh_get_property_value( plist, XSH_AIRM_END, CPL_TYPE_DOUBLE, &ret ) ;
00492
00493 return ret;
00494 }
00495
00496
00497
00503
00504 double xsh_pfits_get_seeing_start (const cpl_propertylist * plist)
00505 {
00506 double ret = 0;
00507
00508 XSH_PFITS_GET( ret, plist, XSH_SEEING_START, CPL_TYPE_DOUBLE);
00509
00510 cleanup:
00511 return ret;
00512 }
00513
00514
00520
00521 double xsh_pfits_get_seeing_end (const cpl_propertylist * plist)
00522 {
00523 double ret = 0;
00524
00525 XSH_PFITS_GET( ret, plist, XSH_SEEING_END, CPL_TYPE_DOUBLE);
00526
00527 cleanup:
00528 return ret;
00529 }
00530
00531
00539
00540 double xsh_pfits_get_slit_width (const cpl_propertylist * plist,
00541 xsh_instrument * instrument )
00542 {
00543 char * str =NULL;
00544 double ret = 0;
00545 XSH_ARM arm ;
00546
00547 arm = xsh_instrument_get_arm( instrument ) ;
00548
00549 switch ( arm ) {
00550 case XSH_ARM_UVB:
00551 XSH_PFITS_GET( str, plist, XSH_SLIT_UVB, CPL_TYPE_STRING);
00552 break ;
00553 case XSH_ARM_VIS:
00554 XSH_PFITS_GET( str, plist, XSH_SLIT_VIS, CPL_TYPE_STRING);
00555 break ;
00556 case XSH_ARM_NIR:
00557 XSH_PFITS_GET( str, plist, XSH_SLIT_NIR, CPL_TYPE_STRING);
00558 break ;
00559 case XSH_ARM_UNDEFINED:
00560 xsh_msg("arm undefined");
00561 break;
00562 }
00563 sscanf( str, "%lf", &ret ) ;
00564 cleanup:
00565 return ret;
00566 }
00567
00568
00569
00577
00578 char* xsh_pfits_get_slit_value (const cpl_propertylist * plist,
00579 xsh_instrument * instrument )
00580 {
00581 char * str =NULL;
00582 XSH_ARM arm ;
00583
00584 arm = xsh_instrument_get_arm( instrument ) ;
00585
00586 switch ( arm ) {
00587 case XSH_ARM_UVB:
00588 XSH_PFITS_GET( str, plist, XSH_SLIT_UVB, CPL_TYPE_STRING);
00589 break ;
00590 case XSH_ARM_VIS:
00591 XSH_PFITS_GET( str, plist, XSH_SLIT_VIS, CPL_TYPE_STRING);
00592 break ;
00593 case XSH_ARM_NIR:
00594 XSH_PFITS_GET( str, plist, XSH_SLIT_NIR, CPL_TYPE_STRING);
00595 break ;
00596 case XSH_ARM_UNDEFINED:
00597 xsh_msg("arm undefined");
00598 break;
00599 }
00600
00601 cleanup:
00602 return str;
00603 }
00604
00605
00606
00607
00614
00615 const char* xsh_pfits_get_telescop (const cpl_propertylist * plist)
00616 {
00617 const char * tel =NULL;
00618 check_msg (xsh_get_property_value(plist, XSH_TELESCOP, CPL_TYPE_STRING, &tel),
00619 "Error reading keyword '%s'", XSH_TELESCOP);
00620
00621 cleanup:
00622 return tel;
00623 }
00624
00625
00626
00632
00633 double xsh_pfits_get_gain (const cpl_propertylist * plist)
00634 {
00635 double ret = 0;
00636
00637 XSH_PFITS_GET( ret, plist, XSH_DET_GAIN, CPL_TYPE_DOUBLE);
00638
00639 cleanup:
00640 return ret;
00641 }
00642
00643
00649
00650 double xsh_pfits_get_conad (const cpl_propertylist * plist)
00651 {
00652 double ret = 0;
00653
00654 XSH_PFITS_GET( ret, plist, XSH_CONAD, CPL_TYPE_DOUBLE);
00655
00656 cleanup:
00657 return ret;
00658 }
00659
00660
00669
00670 int xsh_pfits_get_datancom( const cpl_propertylist *plist)
00671 {
00672 int ret = 0;
00673
00674 XSH_PFITS_GET( ret, plist, XSH_DATANCOM, CPL_TYPE_INT);
00675
00676 cleanup:
00677 return ret;
00678 }
00679
00680
00686
00687 double
00688 xsh_pfits_get_det_gain (const cpl_propertylist * plist)
00689 {
00690 double returnvalue = 0;
00691
00692 check_msg (xsh_get_property_value (plist, XSH_DET_GAIN, CPL_TYPE_DOUBLE,
00693 &returnvalue),
00694 "Error reading keyword '%s'", XSH_DET_GAIN);
00695
00696 cleanup:
00697 return returnvalue;
00698 }
00699
00700
00706
00707 double xsh_pfits_get_bias_left_median(cpl_propertylist * plist)
00708 {
00709 double returnvalue = 0;
00710
00711 check_msg (xsh_get_property_value (plist, XSH_BIAS_LEFT_MEDIAN,
00712 CPL_TYPE_DOUBLE,&returnvalue),
00713 "Error reading keyword '%s'", XSH_BIAS_LEFT_MEDIAN);
00714
00715 cleanup:
00716 return returnvalue;
00717 }
00718
00719
00720
00726
00727 double xsh_pfits_get_bias_right_median(cpl_propertylist * plist)
00728 {
00729 double returnvalue = 0;
00730
00731 check_msg (xsh_get_property_value (plist, XSH_BIAS_RIGHT_MEDIAN,
00732 CPL_TYPE_DOUBLE,&returnvalue),
00733 "Error reading keyword '%s'", XSH_BIAS_RIGHT_MEDIAN);
00734
00735 cleanup:
00736 return returnvalue;
00737 }
00738
00739
00745
00746 double xsh_pfits_get_bias_up_median(cpl_propertylist * plist)
00747 {
00748 double returnvalue = 0;
00749
00750 check_msg (xsh_get_property_value (plist, XSH_BIAS_UP_MEDIAN,
00751 CPL_TYPE_DOUBLE,&returnvalue),
00752 "Error reading keyword '%s'", XSH_BIAS_UP_MEDIAN);
00753
00754 cleanup:
00755 return returnvalue;
00756 }
00757
00758
00759
00765
00766 double xsh_pfits_get_bias_down_median(cpl_propertylist * plist)
00767 {
00768 double returnvalue = 0;
00769
00770 check_msg (xsh_get_property_value (plist, XSH_BIAS_DOWN_MEDIAN,
00771 CPL_TYPE_DOUBLE,&returnvalue),
00772 "Error reading keyword '%s'", XSH_BIAS_DOWN_MEDIAN);
00773
00774 cleanup:
00775 return returnvalue;
00776 }
00777
00778
00784
00785
00786 double xsh_pfits_get_bias_left_stdev(cpl_propertylist * plist)
00787 {
00788 double returnvalue = 0;
00789
00790 check_msg (xsh_get_property_value (plist, XSH_BIAS_LEFT_STDEV,
00791 CPL_TYPE_DOUBLE,&returnvalue),
00792 "Error reading keyword '%s'", XSH_BIAS_LEFT_STDEV);
00793
00794 cleanup:
00795 return returnvalue;
00796 }
00797
00798
00804
00805 double xsh_pfits_get_bias_right_stdev(cpl_propertylist * plist)
00806 {
00807 double returnvalue = 0;
00808
00809 check_msg (xsh_get_property_value (plist, XSH_BIAS_RIGHT_STDEV,
00810 CPL_TYPE_DOUBLE,&returnvalue),
00811 "Error reading keyword '%s'", XSH_BIAS_RIGHT_STDEV);
00812
00813 cleanup:
00814 return returnvalue;
00815 }
00816
00817
00823
00824
00825 double xsh_pfits_get_bias_up_stdev(cpl_propertylist * plist)
00826 {
00827 double returnvalue = 0;
00828
00829 check_msg (xsh_get_property_value (plist, XSH_BIAS_UP_STDEV,
00830 CPL_TYPE_DOUBLE,&returnvalue),
00831 "Error reading keyword '%s'", XSH_BIAS_UP_STDEV);
00832
00833 cleanup:
00834 return returnvalue;
00835 }
00836
00837
00843
00844 double xsh_pfits_get_bias_down_stdev(cpl_propertylist * plist)
00845 {
00846 double returnvalue = 0;
00847
00848 check_msg (xsh_get_property_value (plist, XSH_BIAS_DOWN_STDEV,
00849 CPL_TYPE_DOUBLE,&returnvalue),
00850 "Error reading keyword '%s'", XSH_BIAS_DOWN_STDEV);
00851
00852 cleanup:
00853 return returnvalue;
00854 }
00855
00863 cpl_error_code
00864 xsh_frame_force_pro_catg(const char* fname,
00865 const char* tag) {
00866
00867
00868 cpl_propertylist* plist=NULL;
00869 int naxis=0;
00870 int update=0;
00871 const char* current_tag=NULL;
00872 cpl_table* tab=NULL;
00873 cpl_image* ima=NULL;
00874 cpl_imagelist* iml=NULL;
00875
00876
00877
00878 check(plist=cpl_propertylist_load(fname,0));
00879 check(naxis=xsh_pfits_get_naxis(plist));
00880 if(cpl_propertylist_has(plist,XSH_PCATG)) {
00881
00882 check(current_tag=cpl_propertylist_get_string(plist,XSH_PCATG));
00883 if(strcmp(current_tag,tag)!= 0) {
00884 check(cpl_propertylist_set_string(plist,XSH_PCATG,tag)) ;
00885 update=1;
00886 }
00887
00888 } else {
00889 check(cpl_propertylist_append_string(plist,XSH_PCATG,tag)) ;
00890 update=1;
00891 }
00892
00893 if(update) {
00894 check(naxis=xsh_pfits_get_naxis(plist));
00895 switch (naxis) {
00896 case 0:
00897 check(tab=cpl_table_load(fname,1,0));
00898 check(cpl_table_save(tab,plist,NULL,fname,CPL_IO_DEFAULT));
00899 xsh_free_table(&tab);
00900 break;
00901 case 1:
00902 case 2:
00903 check(ima=cpl_image_load(fname,CPL_TYPE_FLOAT,0,0));
00904 check(cpl_image_save(ima,fname,CPL_BPP_IEEE_FLOAT,plist,CPL_IO_DEFAULT));
00905 xsh_free_image(&ima);
00906 break;
00907 case 3:
00908 check(iml=cpl_imagelist_load(fname,CPL_TYPE_FLOAT,0));
00909 check(cpl_image_save(ima,fname,CPL_BPP_IEEE_FLOAT,plist,CPL_IO_DEFAULT));
00910 xsh_free_imagelist(&iml);
00911 break;
00912 default:
00913 xsh_msg_error("naxis=%d not supported",naxis);
00914 }
00915
00916 }
00917
00918 cleanup:
00919 xsh_free_propertylist(&plist);
00920 xsh_free_table(&tab);
00921 xsh_free_image(&ima);
00922 xsh_free_imagelist(&iml);
00923
00924 return cpl_error_get_code();
00925
00926 }
00927
00928
00929
00935
00936 void
00937 xsh_pfits_set_extname (cpl_propertylist * plist, const char *value)
00938 {
00939 check_msg (cpl_propertylist_update_string (plist, XSH_EXTNAME, value),
00940 "Error writing keyword '%s'", XSH_EXTNAME);
00941 cleanup:
00942 return;
00943 }
00944
00945
00946 void xsh_pfits_set_arm( cpl_propertylist * plist, xsh_instrument* instr)
00947 {
00948
00949 const char* value = NULL;
00950
00951 check( value = xsh_instrument_arm_tostring( instr));
00952 check_msg (cpl_propertylist_update_string (plist, XSH_SEQ_ARM, value),
00953 "Error writing keyword '%s'", XSH_SEQ_ARM);
00954
00955 cleanup:
00956 return;
00957 }
00958
00964
00965 void
00966 xsh_pfits_set_pcatg (cpl_propertylist * plist, const char *value)
00967 {
00968 check_msg (cpl_propertylist_update_string (plist, XSH_PCATG, value),
00969 "Error writing keyword '%s'", XSH_PCATG);
00970 cleanup:
00971 return;
00972 }
00973
00974
00975
00981
00982 void
00983 xsh_pfits_set_dpr_type (cpl_propertylist * plist, const char *value)
00984 {
00985 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_TYPE, value),
00986 "Error writing keyword '%s'", XSH_DPR_TYPE);
00987 cleanup:
00988 return;
00989 }
00990
00991
00992
00998
00999 void
01000 xsh_pfits_set_dpr_catg (cpl_propertylist * plist, const char *value)
01001 {
01002 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_CATG, value),
01003 "Error writing keyword '%s'", XSH_DPR_CATG);
01004 cleanup:
01005 return;
01006 }
01007
01008
01009
01015
01016 void
01017 xsh_pfits_set_dpr_tech (cpl_propertylist * plist, const char *value)
01018 {
01019 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_TECH, value),
01020 "Error writing keyword '%s'", XSH_DPR_TECH);
01021 cleanup:
01022 return;
01023 }
01024
01025
01026
01032
01033 void
01034 xsh_pfits_set_nsat(cpl_propertylist * plist, int value)
01035 {
01036 check_msg (cpl_propertylist_update_double
01037 (plist, XSH_QC_NPIXSAT, value),
01038 "Error writing keyword '%s'", XSH_QC_NPIXSAT);
01039 cpl_propertylist_set_comment(plist, XSH_QC_NPIXSAT, XSH_QC_NPIXSAT_C);
01040
01041 cleanup:
01042 return;
01043 }
01044
01045
01046
01052
01053 void
01054 xsh_pfits_set_frac_sat(cpl_propertylist * plist, double value)
01055 {
01056 check_msg (cpl_propertylist_update_double
01057 (plist, XSH_QC_FPIXSAT, value),
01058 "Error writing keyword '%s'", XSH_QC_FPIXSAT);
01059 cpl_propertylist_set_comment(plist, XSH_QC_FPIXSAT, XSH_QC_FPIXSAT_C);
01060 cleanup:
01061 return;
01062 }
01063
01064
01070
01071 void
01072 xsh_pfits_set_n_range_pix(cpl_propertylist * plist, int value)
01073 {
01074 check_msg (cpl_propertylist_update_double
01075 (plist, XSH_QC_NPIXRANGE, value),
01076 "Error writing keyword '%s'", XSH_QC_NPIXRANGE);
01077 cpl_propertylist_set_comment(plist, XSH_QC_NPIXRANGE, XSH_QC_NPIXRANGE_C);
01078
01079 cleanup:
01080 return;
01081 }
01082
01083
01084
01090
01091 void
01092 xsh_pfits_set_frac_range_pix(cpl_propertylist * plist, double value)
01093 {
01094 check_msg (cpl_propertylist_update_double
01095 (plist, XSH_QC_FPIXRANGE, value),
01096 "Error writing keyword '%s'", XSH_QC_FPIXRANGE);
01097 cpl_propertylist_set_comment(plist, XSH_QC_FPIXRANGE, XSH_QC_FPIXRANGE_C);
01098 cleanup:
01099 return;
01100 }
01101
01102
01103
01109
01110 void
01111 xsh_pfits_set_bias_left_median (cpl_propertylist * plist, double value)
01112 {
01113 check_msg (cpl_propertylist_update_double
01114 (plist, XSH_BIAS_LEFT_MEDIAN, value),
01115 "Error writing keyword '%s'", XSH_BIAS_LEFT_MEDIAN);
01116 cleanup:
01117 return;
01118 }
01119
01120
01126
01127 void
01128 xsh_pfits_set_bias_right_median (cpl_propertylist * plist, double value)
01129 {
01130 check_msg (cpl_propertylist_update_double
01131 (plist, XSH_BIAS_RIGHT_MEDIAN, value),
01132 "Error writing keyword '%s'", XSH_BIAS_RIGHT_MEDIAN);
01133 cleanup:
01134 return;
01135 }
01136
01137
01143
01144 void
01145 xsh_pfits_set_bias_up_median (cpl_propertylist * plist, double value)
01146 {
01147 check_msg (cpl_propertylist_update_double
01148 (plist, XSH_BIAS_UP_MEDIAN, value),
01149 "Error writing keyword '%s'", XSH_BIAS_UP_MEDIAN);
01150 cleanup:
01151 return;
01152 }
01153
01154
01155
01156
01157
01158
01159
01160
01161
01162
01163
01164 void
01165 xsh_pfits_set_datancom (cpl_propertylist * plist, int value)
01166 {
01167 check_msg (cpl_propertylist_update_int
01168 (plist, XSH_DATANCOM, value),
01169 "Error writing keyword '%s'", XSH_DATANCOM);
01170 cleanup:
01171 return;
01172 }
01173
01174
01175
01176
01182
01183 void
01184 xsh_pfits_set_bias_down_median (cpl_propertylist * plist, double value)
01185 {
01186 check_msg (cpl_propertylist_update_double
01187 (plist, XSH_BIAS_DOWN_MEDIAN, value),
01188 "Error writing keyword '%s'", XSH_BIAS_DOWN_MEDIAN);
01189 cleanup:
01190 return;
01191 }
01192
01193
01199
01200 void
01201 xsh_pfits_set_bias_left_stdev (cpl_propertylist * plist, double value)
01202 {
01203 check_msg (cpl_propertylist_update_double
01204 (plist, XSH_BIAS_LEFT_STDEV, value), "Error writing keyword '%s'",
01205 XSH_BIAS_LEFT_STDEV);
01206 cleanup:
01207 return;
01208 }
01209
01210
01216
01217 void
01218 xsh_pfits_set_bias_right_stdev (cpl_propertylist * plist, double value)
01219 {
01220 check_msg (cpl_propertylist_update_double
01221 (plist, XSH_BIAS_RIGHT_STDEV, value), "Error writing keyword '%s'",
01222 XSH_BIAS_RIGHT_STDEV);
01223 cleanup:
01224 return;
01225 }
01226
01227
01233
01234 void
01235 xsh_pfits_set_bias_up_stdev (cpl_propertylist * plist, double value)
01236 {
01237 check_msg (cpl_propertylist_update_double
01238 (plist, XSH_BIAS_UP_STDEV, value), "Error writing keyword '%s'",
01239 XSH_BIAS_UP_STDEV);
01240 cleanup:
01241 return;
01242 }
01243
01244
01250
01251 void
01252 xsh_pfits_set_bias_down_stdev (cpl_propertylist * plist, double value)
01253 {
01254 check_msg (cpl_propertylist_update_double
01255 (plist, XSH_BIAS_DOWN_STDEV, value), "Error writing keyword '%s'",
01256 XSH_BIAS_DOWN_STDEV);
01257 cleanup:
01258 return;
01259 }
01260
01266
01267 void
01268 xsh_pfits_set_dit (cpl_propertylist * plist, double dit)
01269 {
01270 check_msg (cpl_propertylist_update_double (plist, XSH_DET_DIT, dit),
01271 "Error writing keyword '%s'", XSH_DET_DIT);
01272
01273 cleanup:
01274 return;
01275 }
01276
01277
01283
01284 void
01285 xsh_pfits_set_ndit (cpl_propertylist * plist, int ndit)
01286 {
01287 check_msg (cpl_propertylist_update_int (plist, XSH_DET_NDIT, ndit),
01288 "Error writing keyword '%s'", XSH_DET_NDIT);
01289
01290 cleanup:
01291 return;
01292 }
01293
01299
01300 double
01301 xsh_pfits_get_win1_dit1 (const cpl_propertylist * plist)
01302 {
01303 double returnvalue = 0;
01304
01305 check_msg (xsh_get_property_value
01306 (plist, XSH_DET_WIN1_DIT1, CPL_TYPE_DOUBLE, &returnvalue),
01307 "Error reading keyword '%s'", XSH_DET_WIN1_DIT1);
01308
01309 cleanup:
01310 return returnvalue;
01311 }
01312
01313
01319
01320 double
01321 xsh_pfits_get_dit (const cpl_propertylist * plist)
01322 {
01323 double returnvalue = 0;
01324
01325 check_msg (xsh_get_property_value
01326 (plist, XSH_DET_DIT, CPL_TYPE_DOUBLE, &returnvalue),
01327 "Error reading keyword '%s'", XSH_DET_DIT);
01328
01329 cleanup:
01330 return returnvalue;
01331 }
01332
01333
01334
01340
01341 int
01342 xsh_pfits_get_ndit (const cpl_propertylist * plist)
01343 {
01344 int returnvalue = 0;
01345
01346 check_msg (xsh_get_property_value
01347 (plist, XSH_DET_NDIT, CPL_TYPE_INT, &returnvalue),
01348 "Error reading keyword '%s'", XSH_DET_NDIT);
01349
01350 cleanup:
01351 return returnvalue;
01352 }
01353
01354
01360
01361 const char *
01362 xsh_pfits_get_raw1name (const cpl_propertylist * plist)
01363 {
01364 const char *returnvalue = "";
01365
01366 check_msg (xsh_get_property_value
01367 (plist, XSH_RAW1_NAME, CPL_TYPE_STRING, &returnvalue),
01368 "Error reading keyword '%s'", XSH_RAW1_NAME);
01369
01370 cleanup:
01371 return returnvalue;
01372 }
01373
01374
01375
01381
01382 const char *
01383 xsh_pfits_get_bunit (const cpl_propertylist * plist)
01384 {
01385 const char *returnvalue = "";
01386
01387 check_msg (xsh_get_property_value
01388 (plist, XSH_BUNIT, CPL_TYPE_STRING, &returnvalue),
01389 "Error reading keyword '%s'", XSH_BUNIT);
01390
01391 cleanup:
01392 return returnvalue;
01393 }
01394
01395
01401
01402 const char *
01403 xsh_pfits_get_cunit1 (const cpl_propertylist * plist)
01404 {
01405 const char *returnvalue = "";
01406
01407 check_msg (xsh_get_property_value
01408 (plist, XSH_CUNIT1, CPL_TYPE_STRING, &returnvalue),
01409 "Error reading keyword '%s'", XSH_CUNIT1);
01410
01411 cleanup:
01412 return returnvalue;
01413 }
01414
01415
01421
01422 const char *
01423 xsh_pfits_get_cunit2 (const cpl_propertylist * plist)
01424 {
01425 const char *returnvalue = "";
01426
01427 check_msg (xsh_get_property_value
01428 (plist, XSH_CUNIT2, CPL_TYPE_STRING, &returnvalue),
01429 "Error reading keyword '%s'", XSH_CUNIT2);
01430
01431 cleanup:
01432 return returnvalue;
01433 }
01434
01435
01441
01442 const char *
01443 xsh_pfits_get_cunit3 (const cpl_propertylist * plist)
01444 {
01445 const char *returnvalue = "";
01446
01447 check_msg (xsh_get_property_value
01448 (plist, XSH_CUNIT3, CPL_TYPE_STRING, &returnvalue),
01449 "Error reading keyword '%s'", XSH_CUNIT3);
01450
01451 cleanup:
01452 return returnvalue;
01453 }
01454
01455
01456
01462
01463 const char *
01464 xsh_pfits_get_raw1catg (const cpl_propertylist * plist)
01465 {
01466 const char *returnvalue = "";
01467
01468 check_msg (xsh_get_property_value
01469 (plist, XSH_RAW1_CATG, CPL_TYPE_STRING, &returnvalue),
01470 "Error reading keyword '%s'", XSH_RAW1_CATG);
01471
01472 cleanup:
01473 return returnvalue;
01474 }
01475
01476
01477
01483
01484 const char *
01485 xsh_pfits_get_obs_targ_name (const cpl_propertylist * plist)
01486 {
01487 const char *returnvalue = "";
01488
01489 check_msg (xsh_get_property_value
01490 (plist, XSH_OBS_TARG_NAME, CPL_TYPE_STRING, &returnvalue),
01491 "Error reading keyword '%s'", XSH_OBS_TARG_NAME);
01492
01493 cleanup:
01494 return returnvalue;
01495 }
01496
01497
01503
01504 const char *
01505 xsh_pfits_get_arcfile (const cpl_propertylist * plist)
01506 {
01507 const char *returnvalue = "";
01508
01509 check_msg (xsh_get_property_value
01510 (plist, XSH_ARCFILE, CPL_TYPE_STRING, &returnvalue),
01511 "Error reading keyword '%s'", XSH_ARCFILE);
01512
01513 cleanup:
01514 return returnvalue;
01515 }
01521
01522 bool
01523 xsh_pfits_get_lamp_on_off (const cpl_propertylist * plist)
01524 {
01525 const char *returnvalue = "";
01526
01527 check_msg (xsh_get_property_value
01528 (plist, XSH_LAMP_ON_OFF, CPL_TYPE_BOOL, &returnvalue),
01529 "Error reading keyword '%s'", XSH_LAMP_ON_OFF);
01530
01531 cleanup:
01532 return returnvalue;
01533 }
01534
01535
01541
01542 const char *
01543 xsh_pfits_get_pcatg (const cpl_propertylist * plist)
01544 {
01545 const char *returnvalue = "";
01546
01547 check_msg (xsh_get_property_value
01548 (plist, XSH_PCATG, CPL_TYPE_STRING, &returnvalue),
01549 "Error reading keyword '%s'", XSH_PCATG);
01550 cleanup:
01551 return returnvalue;
01552 }
01553
01554
01555
01561
01562 const char *
01563 xsh_pfits_get_dpr_tech (const cpl_propertylist * plist)
01564 {
01565 const char *returnvalue = "";
01566
01567 check_msg (xsh_get_property_value
01568 (plist, XSH_DPR_TECH, CPL_TYPE_STRING, &returnvalue),
01569 "Error reading keyword '%s'", XSH_DPR_TECH);
01570 cleanup:
01571 return returnvalue;
01572 }
01573
01574
01575
01581
01582 const char *
01583 xsh_pfits_get_dpr_type (const cpl_propertylist * plist)
01584 {
01585 const char *returnvalue = "";
01586
01587 check_msg (xsh_get_property_value
01588 (plist, XSH_DPR_TYPE, CPL_TYPE_STRING, &returnvalue),
01589 "Error reading keyword '%s'", XSH_DPR_TYPE);
01590 cleanup:
01591 return returnvalue;
01592 }
01593
01594
01595
01596
01602
01603 const char *
01604 xsh_pfits_get_dpr_catg (const cpl_propertylist * plist)
01605 {
01606 const char *returnvalue = "";
01607
01608 check_msg (xsh_get_property_value
01609 (plist, XSH_DPR_CATG, CPL_TYPE_STRING, &returnvalue),
01610 "Error reading keyword '%s'", XSH_DPR_CATG);
01611 cleanup:
01612 return returnvalue;
01613 }
01614
01615
01621
01622 const char *
01623 xsh_pfits_get_extname (const cpl_propertylist * plist)
01624 {
01625 const char *returnvalue = "";
01626
01627 check_msg (xsh_get_property_value
01628 (plist, XSH_EXTNAME, CPL_TYPE_STRING, &returnvalue),
01629 "Error reading keyword '%s'", XSH_EXTNAME);
01630 cleanup:
01631 return returnvalue;
01632 }
01633
01634
01640
01641 const char *
01642 xsh_pfits_get_date (const cpl_propertylist * plist)
01643 {
01644 const char *returnvalue = "";
01645
01646 check_msg (xsh_get_property_value
01647 (plist, XSH_DATE, CPL_TYPE_STRING, &returnvalue),
01648 "Error reading keyword '%s'", XSH_DATE);
01649
01650 cleanup:
01651 return returnvalue;
01652 }
01653
01654
01660
01661 const char *
01662 xsh_pfits_get_date_obs (const cpl_propertylist * plist)
01663 {
01664 const char *returnvalue = "";
01665
01666 check_msg (xsh_get_property_value
01667 (plist, XSH_DATE_OBS, CPL_TYPE_STRING, &returnvalue),
01668 "Error reading keyword '%s'", XSH_DATE_OBS);
01669
01670 cleanup:
01671 return returnvalue;
01672 }
01673
01679
01680 double
01681 xsh_pfits_get_pszx (const cpl_propertylist * plist)
01682 {
01683 double returnvalue = 0.0;
01684
01685 check_msg (xsh_get_property_value (plist, XSH_PSZX, CPL_TYPE_DOUBLE,
01686 &returnvalue),
01687 "Error reading keyword '%s'", XSH_PSZX);
01688
01689 cleanup:
01690 return returnvalue;
01691 }
01692
01698
01699 double
01700 xsh_pfits_get_pszy (const cpl_propertylist * plist)
01701 {
01702 double returnvalue = 0.0;
01703
01704 check_msg (xsh_get_property_value (plist, XSH_PSZY, CPL_TYPE_DOUBLE,
01705 &returnvalue),
01706 "Error reading keyword '%s'", XSH_PSZY);
01707
01708 cleanup:
01709 return returnvalue;
01710 }
01711
01717
01718 double
01719 xsh_pfits_get_det_pxspace(const cpl_propertylist * plist)
01720 {
01721 double returnvalue = 0.0;
01722
01723 check_msg (xsh_get_property_value (plist, XSH_DET_PXSPACE, CPL_TYPE_DOUBLE,
01724 &returnvalue),
01725 "Error reading keyword '%s'", XSH_DET_PXSPACE);
01726
01727 cleanup:
01728 return returnvalue;
01729 }
01730
01731
01732
01733
01739
01740 int xsh_pfits_get_FOCU1ENC (const cpl_propertylist * plist)
01741 {
01742 int returnvalue = 0;
01743
01744 check_msg (xsh_get_property_value (plist, XSH_FOCU1ENC_VAL, CPL_TYPE_INT,
01745 &returnvalue),
01746 "Error reading keyword '%s'", XSH_FOCU1ENC_VAL);
01747
01748 cleanup:
01749 return returnvalue;
01750 }
01751
01752
01753
01754
01760
01761 double xsh_pfits_get_temp5 (const cpl_propertylist * plist)
01762 {
01763 double returnvalue = 0.0;
01764
01765 check_msg (xsh_get_property_value (plist, XSH_TEMP5_VAL, CPL_TYPE_DOUBLE,
01766 &returnvalue),
01767 "Error reading keyword '%s'", XSH_TEMP5_VAL);
01768
01769 cleanup:
01770 return returnvalue;
01771 }
01772
01773
01774
01775
01781
01782 double xsh_pfits_get_temp2 (const cpl_propertylist * plist)
01783 {
01784 double returnvalue = 0.0;
01785
01786 check_msg (xsh_get_property_value (plist, XSH_TEMP2_VAL, CPL_TYPE_DOUBLE,
01787 &returnvalue),
01788 "Error reading keyword '%s'", XSH_TEMP2_VAL);
01789
01790 cleanup:
01791 return returnvalue;
01792 }
01793
01794
01795
01796
01802
01803 double xsh_pfits_get_temp82 (const cpl_propertylist * plist)
01804 {
01805 double returnvalue = 0.0;
01806
01807 check_msg (xsh_get_property_value (plist, XSH_TEMP82_VAL, CPL_TYPE_DOUBLE,
01808 &returnvalue),
01809 "Error reading keyword '%s'", XSH_TEMP82_VAL);
01810
01811 cleanup:
01812 return returnvalue;
01813 }
01814
01815
01816
01822
01823 double xsh_pfits_get_crval1 (const cpl_propertylist * plist)
01824 {
01825 double returnvalue = 0.0;
01826
01827 check_msg (xsh_get_property_value (plist, XSH_CRVAL1, CPL_TYPE_DOUBLE,
01828 &returnvalue),
01829 "Error reading keyword '%s'", XSH_CRVAL1);
01830
01831 cleanup:
01832 return returnvalue;
01833 }
01834
01835
01841
01842 double xsh_pfits_get_crval2 (const cpl_propertylist * plist)
01843 {
01844 double returnvalue = 0.0;
01845
01846 check_msg (xsh_get_property_value (plist, XSH_CRVAL2, CPL_TYPE_DOUBLE,
01847 &returnvalue),
01848 "Error reading keyword '%s'", XSH_CRVAL2);
01849
01850 cleanup:
01851 return returnvalue;
01852 }
01853
01854
01855
01861
01862 double xsh_pfits_get_crval3 (const cpl_propertylist * plist)
01863 {
01864 double returnvalue = 0.0;
01865
01866 check_msg (xsh_get_property_value (plist, XSH_CRVAL3, CPL_TYPE_DOUBLE,
01867 &returnvalue),
01868 "Error reading keyword '%s'", XSH_CRVAL3);
01869
01870 cleanup:
01871 return returnvalue;
01872 }
01873
01874
01875
01880
01881 double xsh_pfits_get_crpix1(const cpl_propertylist * plist)
01882 {
01883 double returnvalue = 0.0;
01884 check_msg (xsh_get_property_value (plist, XSH_CRPIX1, CPL_TYPE_DOUBLE,
01885 &returnvalue),
01886 "Error reading keyword '%s'", XSH_CRPIX1);
01887
01888 cleanup:
01889 return returnvalue;
01890 }
01891
01892
01897
01898 double xsh_pfits_get_crpix2(const cpl_propertylist * plist)
01899 {
01900 double returnvalue = 0.0;
01901 check_msg (xsh_get_property_value (plist, XSH_CRPIX2, CPL_TYPE_DOUBLE,
01902 &returnvalue),
01903 "Error reading keyword '%s'", XSH_CRPIX2);
01904
01905 cleanup:
01906 return returnvalue;
01907 }
01908
01909
01914
01915 double xsh_pfits_get_crpix3(const cpl_propertylist * plist)
01916 {
01917 double returnvalue = 0.0;
01918 check_msg (xsh_get_property_value (plist, XSH_CRPIX3, CPL_TYPE_DOUBLE,
01919 &returnvalue),
01920 "Error reading keyword '%s'", XSH_CRPIX3);
01921
01922 cleanup:
01923 return returnvalue;
01924 }
01925
01926
01932
01933 double xsh_pfits_get_cd11 (const cpl_propertylist * plist)
01934 {
01935 double returnvalue = 0.0;
01936
01937 check_msg (xsh_get_property_value (plist, XSH_CD11, CPL_TYPE_DOUBLE,
01938 &returnvalue),
01939 "Error reading keyword '%s'", XSH_CD11);
01940
01941 cleanup:
01942 return returnvalue;
01943 }
01944
01945
01946
01947
01953
01954 double xsh_pfits_get_cd12 (const cpl_propertylist * plist)
01955 {
01956 double returnvalue = 0.0;
01957
01958 check_msg (xsh_get_property_value (plist, XSH_CD12, CPL_TYPE_DOUBLE,
01959 &returnvalue),
01960 "Error reading keyword '%s'", XSH_CD12);
01961
01962 cleanup:
01963 return returnvalue;
01964 }
01965
01966
01972
01973 double xsh_pfits_get_cd21 (const cpl_propertylist * plist)
01974 {
01975 double returnvalue = 0.0;
01976
01977 check_msg (xsh_get_property_value (plist, XSH_CD21, CPL_TYPE_DOUBLE,
01978 &returnvalue),
01979 "Error reading keyword '%s'", XSH_CD21);
01980
01981 cleanup:
01982 return returnvalue;
01983 }
01984
01985
01986
01992
01993 double xsh_pfits_get_cd22 (const cpl_propertylist * plist)
01994 {
01995 double returnvalue = 0.0;
01996
01997 check_msg (xsh_get_property_value (plist, XSH_CD22, CPL_TYPE_DOUBLE,
01998 &returnvalue),
01999 "Error reading keyword '%s'", XSH_CD22);
02000
02001 cleanup:
02002 return returnvalue;
02003 }
02004
02005
02011
02012 double xsh_pfits_get_cd13 (const cpl_propertylist * plist)
02013 {
02014 double returnvalue = 0.0;
02015
02016 check_msg (xsh_get_property_value (plist, XSH_CD13, CPL_TYPE_DOUBLE,
02017 &returnvalue),
02018 "Error reading keyword '%s'", XSH_CD13);
02019
02020 cleanup:
02021 return returnvalue;
02022 }
02023
02024
02025
02031
02032 double xsh_pfits_get_cd23 (const cpl_propertylist * plist)
02033 {
02034 double returnvalue = 0.0;
02035
02036 check_msg (xsh_get_property_value (plist, XSH_CD23, CPL_TYPE_DOUBLE,
02037 &returnvalue),
02038 "Error reading keyword '%s'", XSH_CD23);
02039
02040 cleanup:
02041 return returnvalue;
02042 }
02043
02044
02045
02051
02052 double xsh_pfits_get_cd33 (const cpl_propertylist * plist)
02053 {
02054 double returnvalue = 0.0;
02055
02056 check_msg (xsh_get_property_value (plist, XSH_CD33, CPL_TYPE_DOUBLE,
02057 &returnvalue),
02058 "Error reading keyword '%s'", XSH_CD33);
02059
02060 cleanup:
02061 return returnvalue;
02062 }
02063
02064
02070
02071 double xsh_pfits_get_cd31 (const cpl_propertylist * plist)
02072 {
02073 double returnvalue = 0.0;
02074
02075 check_msg (xsh_get_property_value (plist, XSH_CD31, CPL_TYPE_DOUBLE,
02076 &returnvalue),
02077 "Error reading keyword '%s'", XSH_CD31);
02078
02079 cleanup:
02080 return returnvalue;
02081 }
02082
02083
02084
02090
02091 double xsh_pfits_get_cd32 (const cpl_propertylist * plist)
02092 {
02093 double returnvalue = 0.0;
02094
02095 check_msg (xsh_get_property_value (plist, XSH_CD32, CPL_TYPE_DOUBLE,
02096 &returnvalue),
02097 "Error reading keyword '%s'", XSH_CD32);
02098
02099 cleanup:
02100 return returnvalue;
02101 }
02102
02103
02104
02105
02111
02112 double xsh_pfits_get_cdelt1 (const cpl_propertylist * plist)
02113 {
02114 double returnvalue = 0.0;
02115
02116 check_msg (xsh_get_property_value (plist, XSH_CDELT1, CPL_TYPE_DOUBLE,
02117 &returnvalue),
02118 "Error reading keyword '%s'", XSH_CDELT1);
02119
02120 cleanup:
02121 return returnvalue;
02122 }
02123
02124
02125
02131
02132 double xsh_pfits_get_cdelt2 (const cpl_propertylist * plist)
02133 {
02134 double returnvalue = 0.0;
02135
02136 check_msg (xsh_get_property_value (plist, XSH_CDELT2, CPL_TYPE_DOUBLE,
02137 &returnvalue),
02138 "Error reading keyword '%s'", XSH_CDELT2);
02139
02140 cleanup:
02141 return returnvalue;
02142 }
02143
02144
02150
02151 double xsh_pfits_get_cdelt3 (const cpl_propertylist * plist)
02152 {
02153 double returnvalue = 0.0;
02154
02155 check_msg (xsh_get_property_value (plist, XSH_CDELT3, CPL_TYPE_DOUBLE,
02156 &returnvalue),
02157 "Error reading keyword '%s'", XSH_CDELT3);
02158
02159 cleanup:
02160 return returnvalue;
02161 }
02162
02163
02169
02170 double xsh_pfits_get_exptime (const cpl_propertylist * plist)
02171 {
02172 double returnvalue = 0.0;
02173
02174 check_msg (xsh_get_property_value (plist, XSH_EXPTIME,CPL_TYPE_DOUBLE,
02175 &returnvalue),
02176 "Error reading keyword '%s'", XSH_EXPTIME);
02177
02178 cleanup:
02179 return returnvalue;
02180 }
02181
02182
02183
02189
02190 double xsh_pfits_get_det_win1_uit1 (const cpl_propertylist * plist)
02191 {
02192 double returnvalue = 0.0;
02193
02194 check_msg (xsh_get_property_value (plist, XSH_DET_WIN1_UIT1,CPL_TYPE_DOUBLE,
02195 &returnvalue),
02196 "Error reading keyword '%s'", XSH_DET_WIN1_UIT1);
02197
02198 cleanup:
02199 return returnvalue;
02200 }
02206
02207 void
02208 xsh_pfits_set_exptime (cpl_propertylist * plist, double value)
02209 {
02210 check_msg (cpl_propertylist_update_double (plist, XSH_EXPTIME, value),
02211 "Error writing keyword '%s'", XSH_EXPTIME);
02212
02213 cleanup:
02214 return;
02215 }
02216
02217
02223
02224 void xsh_pfits_set_cd1(cpl_propertylist * plist, double value)
02225 {
02226 check_msg (cpl_propertylist_update_double (plist, XSH_CD1, value),
02227 "Error writing keyword '%s'", XSH_CD1);
02228 cleanup:
02229 return;
02230 }
02231
02232
02233
02239
02240 void xsh_pfits_set_cd11(cpl_propertylist * plist, double value)
02241 {
02242 check_msg (cpl_propertylist_update_double (plist, XSH_CD11, value),
02243 "Error writing keyword '%s'", XSH_CD11);
02244 cleanup:
02245 return;
02246 }
02247
02248
02254
02255 void xsh_pfits_set_cd12(cpl_propertylist * plist, double value)
02256 {
02257 check_msg (cpl_propertylist_update_double (plist, XSH_CD12, value),
02258 "Error writing keyword '%s'", XSH_CD12);
02259 cleanup:
02260 return;
02261 }
02262
02263
02269
02270 void xsh_pfits_set_cd21(cpl_propertylist * plist, double value)
02271 {
02272 check_msg (cpl_propertylist_update_double (plist, XSH_CD21, value),
02273 "Error writing keyword '%s'", XSH_CD21);
02274 cleanup:
02275 return;
02276 }
02277
02278
02284
02285 void xsh_pfits_set_cd22(cpl_propertylist * plist, double value)
02286 {
02287 check_msg (cpl_propertylist_update_double (plist, XSH_CD22, value),
02288 "Error writing keyword '%s'", XSH_CD22);
02289 cleanup:
02290 return;
02291 }
02292
02293
02299
02300 void xsh_pfits_set_cd13(cpl_propertylist * plist, double value)
02301 {
02302 check_msg (cpl_propertylist_update_double (plist, XSH_CD13, value),
02303 "Error writing keyword '%s'", XSH_CD13);
02304 cleanup:
02305 return;
02306 }
02307
02308
02314
02315 void xsh_pfits_set_cd23(cpl_propertylist * plist, double value)
02316 {
02317 check_msg (cpl_propertylist_update_double (plist, XSH_CD23, value),
02318 "Error writing keyword '%s'", XSH_CD23);
02319 cleanup:
02320 return;
02321 }
02322
02323
02324
02330
02331 void xsh_pfits_set_cd33(cpl_propertylist * plist, double value)
02332 {
02333 check_msg (cpl_propertylist_update_double (plist, XSH_CD33, value),
02334 "Error writing keyword '%s'", XSH_CD33);
02335 cleanup:
02336 return;
02337 }
02338
02339
02345
02346 void xsh_pfits_set_cd32(cpl_propertylist * plist, double value)
02347 {
02348 check_msg (cpl_propertylist_update_double (plist, XSH_CD32, value),
02349 "Error writing keyword '%s'", XSH_CD32);
02350 cleanup:
02351 return;
02352 }
02353
02354
02355
02361
02362 void xsh_pfits_set_cd31(cpl_propertylist * plist, double value)
02363 {
02364 check_msg (cpl_propertylist_update_double (plist, XSH_CD31, value),
02365 "Error writing keyword '%s'", XSH_CD31);
02366 cleanup:
02367 return;
02368 }
02369
02370
02371
02372
02378
02379 void xsh_pfits_set_crpix1(cpl_propertylist * plist, double value)
02380 {
02381 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX1, value),
02382 "Error writing keyword '%s'", XSH_CRPIX1);
02383 cleanup:
02384 return;
02385 }
02386
02387
02388
02389
02395
02396 void xsh_pfits_set_crval1(cpl_propertylist * plist, double value)
02397 {
02398 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL1, value),
02399 "Error writing keyword '%s'", XSH_CRVAL1);
02400 cleanup:
02401 return;
02402 }
02403
02404
02405
02411
02412 void xsh_pfits_set_cdelt1(cpl_propertylist * plist, double value)
02413 {
02414 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT1, value),
02415 "Error writing keyword '%s'", XSH_CDELT1);
02416 cleanup:
02417 return;
02418 }
02419
02420
02421
02422
02428
02429 void xsh_pfits_set_crpix2(cpl_propertylist * plist, double value)
02430 {
02431 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX2, value),
02432 "Error writing keyword '%s'", XSH_CRPIX2);
02433 cleanup:
02434 return;
02435 }
02436
02437
02443
02444 void xsh_pfits_set_crpix3(cpl_propertylist * plist, double value)
02445 {
02446 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX3, value),
02447 "Error writing keyword '%s'", XSH_CRPIX3);
02448 cleanup:
02449 return;
02450 }
02451
02452
02453
02459
02460 void xsh_pfits_set_crval2(cpl_propertylist * plist, double value)
02461 {
02462 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL2, value),
02463 "Error writing keyword '%s'", XSH_CRVAL2);
02464 cleanup:
02465 return;
02466 }
02467
02468
02474
02475 void xsh_pfits_set_crval3(cpl_propertylist * plist, double value)
02476 {
02477 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL3, value),
02478 "Error writing keyword '%s'", XSH_CRVAL3);
02479 cleanup:
02480 return;
02481 }
02482
02483
02484
02490
02491 void xsh_pfits_set_cdelt2(cpl_propertylist * plist, double value)
02492 {
02493 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT2, value),
02494 "Error writing keyword '%s'", XSH_CDELT2);
02495 cleanup:
02496 return;
02497 }
02498
02499
02500
02506
02507 void xsh_pfits_set_cdelt3(cpl_propertylist * plist, double value)
02508 {
02509 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT3, value),
02510 "Error writing keyword '%s'", XSH_CDELT3);
02511 cleanup:
02512 return;
02513 }
02514
02515
02521
02522 void xsh_pfits_set_bunit(cpl_propertylist * plist, const char* value)
02523 {
02524 check_msg (cpl_propertylist_update_string (plist, XSH_BUNIT, value),
02525 "Error writing keyword '%s'", XSH_BUNIT);
02526 cleanup:
02527 return;
02528 }
02529
02530
02531
02537
02538 void xsh_pfits_set_cunit1(cpl_propertylist * plist, const char* value)
02539 {
02540 check_msg (cpl_propertylist_update_string (plist, XSH_CUNIT1, value),
02541 "Error writing keyword '%s'", XSH_CUNIT1);
02542 cleanup:
02543 return;
02544 }
02545
02546
02552
02553 void xsh_pfits_set_cunit2(cpl_propertylist * plist, const char* value)
02554 {
02555 check_msg (cpl_propertylist_update_string (plist, XSH_CUNIT2, value),
02556 "Error writing keyword '%s'", XSH_CUNIT2);
02557 cleanup:
02558 return;
02559 }
02560
02561
02567
02568 void xsh_pfits_set_cunit3(cpl_propertylist * plist, const char* value)
02569 {
02570 check_msg (cpl_propertylist_update_string (plist, XSH_CUNIT3, value),
02571 "Error writing keyword '%s'", XSH_CUNIT3);
02572 cleanup:
02573 return;
02574 }
02575
02576
02582
02583 void xsh_pfits_set_ctype1(cpl_propertylist * plist, const char* value)
02584 {
02585 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE1, value),
02586 "Error writing keyword '%s'", XSH_CTYPE1);
02587 cleanup:
02588 return;
02589 }
02590
02591
02597
02598 void xsh_pfits_set_ctype2(cpl_propertylist * plist, const char* value)
02599 {
02600 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE2, value),
02601 "Error writing keyword '%s'", XSH_CTYPE2);
02602 cleanup:
02603 return;
02604 }
02605
02606
02607
02613
02614 void xsh_pfits_set_ctype3(cpl_propertylist * plist, const char* value)
02615 {
02616 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE3, value),
02617 "Error writing keyword '%s'", XSH_CTYPE3);
02618 cleanup:
02619 return;
02620 }
02621
02622
02628
02629 void xsh_pfits_set_wavesol_lambda_min(cpl_propertylist * plist, double value)
02630 {
02631 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_LAMBDA_MIN,
02632 value),
02633 "Error writing keyword '%s'", XSH_WAVESOL_LAMBDA_MIN);
02634
02635 cleanup:
02636 return;
02637 }
02638
02639
02645
02646 void xsh_pfits_set_wavesol_lambda_max(cpl_propertylist * plist, double value)
02647 {
02648 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_LAMBDA_MAX,
02649 value),
02650 "Error writing keyword '%s'", XSH_WAVESOL_LAMBDA_MAX);
02651
02652 cleanup:
02653 return;
02654 }
02655
02656
02662
02663 void xsh_pfits_set_wavesol_order_min(cpl_propertylist * plist, double value)
02664 {
02665 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_ORDER_MIN,
02666 value),
02667 "Error writing keyword '%s'", XSH_WAVESOL_ORDER_MIN);
02668
02669 cleanup:
02670 return;
02671 }
02672
02673
02679
02680 void xsh_pfits_set_wavesol_order_max(cpl_propertylist * plist, double value)
02681 {
02682 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_ORDER_MAX,
02683 value),
02684 "Error writing keyword '%s'", XSH_WAVESOL_ORDER_MAX);
02685
02686 cleanup:
02687 return;
02688 }
02689
02690
02696
02697 void xsh_pfits_set_wavesol_slit_min(cpl_propertylist * plist, double value)
02698 {
02699 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_SLIT_MIN,
02700 value),
02701 "Error writing keyword '%s'", XSH_WAVESOL_SLIT_MIN);
02702
02703 cleanup:
02704 return;
02705 }
02706
02707
02713
02714 void xsh_pfits_set_wavesol_slit_max(cpl_propertylist * plist, double value)
02715 {
02716 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_SLIT_MAX,
02717 value),
02718 "Error writing keyword '%s'", XSH_WAVESOL_SLIT_MAX);
02719
02720 cleanup:
02721 return;
02722 }
02723
02724
02730
02731 void xsh_pfits_set_extract_slit_min(cpl_propertylist * plist, double value)
02732 {
02733 check_msg (cpl_propertylist_update_double (plist, XSH_EXTRACT_SLIT_MIN,
02734 value),
02735 "Error writing keyword '%s'", XSH_EXTRACT_SLIT_MIN);
02736
02737 cleanup:
02738 return;
02739 }
02740
02741
02742
02743
02749
02750 void xsh_pfits_set_extract_slit_max(cpl_propertylist * plist, double value)
02751 {
02752 check_msg (cpl_propertylist_update_double (plist, XSH_EXTRACT_SLIT_MAX,
02753 value),
02754 "Error writing keyword '%s'", XSH_EXTRACT_SLIT_MAX);
02755
02756 cleanup:
02757 return;
02758 }
02759
02765
02766 void xsh_pfits_set_wavesol_x_min(cpl_propertylist * plist, double value)
02767 {
02768 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_X_MIN,
02769 value),
02770 "Error writing keyword '%s'", XSH_WAVESOL_X_MIN);
02771
02772 cleanup:
02773 return;
02774 }
02775
02776
02782
02783 void xsh_pfits_set_wavesol_x_max(cpl_propertylist * plist, double value)
02784 {
02785 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_X_MAX,
02786 value),
02787 "Error writing keyword '%s'", XSH_WAVESOL_X_MAX);
02788
02789 cleanup:
02790 return;
02791 }
02792
02793
02794
02800
02801 void xsh_pfits_set_wavesol_y_min(cpl_propertylist * plist, double value)
02802 {
02803 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_Y_MIN,
02804 value),
02805 "Error writing keyword '%s'", XSH_WAVESOL_Y_MIN);
02806
02807 cleanup:
02808 return;
02809 }
02810
02811
02817
02818 void xsh_pfits_set_wavesol_y_max(cpl_propertylist * plist, double value)
02819 {
02820 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_Y_MAX,
02821 value),
02822 "Error writing keyword '%s'", XSH_WAVESOL_Y_MAX);
02823
02824 cleanup:
02825 return;
02826 }
02827
02828
02834
02835 double xsh_pfits_get_wavesol_lambda_min(cpl_propertylist * plist)
02836 {
02837 double returnvalue = 0.0;
02838
02839 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_LAMBDA_MIN,
02840 CPL_TYPE_DOUBLE, &returnvalue),
02841 "Error reading keyword '%s'", XSH_WAVESOL_LAMBDA_MIN);
02842
02843 cleanup:
02844 return returnvalue;
02845 }
02846
02847
02853
02854 double xsh_pfits_get_wavesol_lambda_max(cpl_propertylist * plist)
02855 {
02856 double returnvalue = 0.0;
02857
02858 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_LAMBDA_MAX,
02859 CPL_TYPE_DOUBLE, &returnvalue),
02860 "Error reading keyword '%s'", XSH_WAVESOL_LAMBDA_MAX);
02861
02862 cleanup:
02863 return returnvalue;
02864 }
02865
02866
02872
02873 double xsh_pfits_get_wavesol_order_min(cpl_propertylist * plist)
02874 {
02875 double returnvalue = 0.0;
02876
02877 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_ORDER_MIN,
02878 CPL_TYPE_DOUBLE, &returnvalue),
02879 "Error reading keyword '%s'", XSH_WAVESOL_ORDER_MIN);
02880
02881 cleanup:
02882 return returnvalue;
02883 }
02884
02885
02891
02892 double xsh_pfits_get_wavesol_order_max(cpl_propertylist * plist)
02893 {
02894 double returnvalue = 0.0;
02895
02896 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_ORDER_MAX,
02897 CPL_TYPE_DOUBLE, &returnvalue),
02898 "Error reading keyword '%s'", XSH_WAVESOL_ORDER_MAX);
02899
02900 cleanup:
02901 return returnvalue;
02902 }
02903
02904
02910
02911 double xsh_pfits_get_wavesol_slit_min(cpl_propertylist * plist)
02912 {
02913 double returnvalue = 0.0;
02914
02915 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_SLIT_MIN,
02916 CPL_TYPE_DOUBLE, &returnvalue),
02917 "Error reading keyword '%s'", XSH_WAVESOL_SLIT_MIN);
02918
02919 cleanup:
02920 return returnvalue;
02921 }
02922
02923
02929
02930 double xsh_pfits_get_wavesol_slit_max(cpl_propertylist * plist)
02931 {
02932 double returnvalue = 0.0;
02933
02934 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_SLIT_MAX,
02935 CPL_TYPE_DOUBLE, &returnvalue),
02936 "Error reading keyword '%s'", XSH_WAVESOL_SLIT_MAX);
02937
02938 cleanup:
02939 return returnvalue;
02940 }
02941
02942
02948
02949 double xsh_pfits_get_extract_slit_min(cpl_propertylist * plist)
02950 {
02951 double returnvalue = 0.0;
02952
02953 check_msg (xsh_get_property_value (plist, XSH_EXTRACT_SLIT_MIN,
02954 CPL_TYPE_DOUBLE, &returnvalue),
02955 "Error reading keyword '%s'", XSH_EXTRACT_SLIT_MIN);
02956
02957 cleanup:
02958 return returnvalue;
02959 }
02960
02961
02967
02968 double xsh_pfits_get_extract_slit_max(cpl_propertylist * plist)
02969 {
02970 double returnvalue = 0.0;
02971
02972 check_msg (xsh_get_property_value (plist, XSH_EXTRACT_SLIT_MAX,
02973 CPL_TYPE_DOUBLE, &returnvalue),
02974 "Error reading keyword '%s'", XSH_EXTRACT_SLIT_MAX);
02975
02976 cleanup:
02977 return returnvalue;
02978 }
02979
02980
02986
02987 double xsh_pfits_get_wavesol_x_min(cpl_propertylist * plist)
02988 {
02989 double returnvalue = 0.0;
02990
02991 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_X_MIN,
02992 CPL_TYPE_DOUBLE, &returnvalue),
02993 "Error reading keyword '%s'", XSH_WAVESOL_X_MIN);
02994
02995 cleanup:
02996 return returnvalue;
02997 }
02998
02999
03005
03006 double xsh_pfits_get_wavesol_x_max(cpl_propertylist * plist)
03007 {
03008 double returnvalue = 0.0;
03009
03010 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_X_MAX,
03011 CPL_TYPE_DOUBLE, &returnvalue),
03012 "Error reading keyword '%s'", XSH_WAVESOL_X_MAX);
03013
03014 cleanup:
03015 return returnvalue;
03016 }
03017
03018
03024
03025 double xsh_pfits_get_wavesol_y_min(cpl_propertylist * plist)
03026 {
03027 double returnvalue = 0.0;
03028
03029 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_Y_MIN,
03030 CPL_TYPE_DOUBLE, &returnvalue),
03031 "Error reading keyword '%s'", XSH_WAVESOL_Y_MIN);
03032
03033 cleanup:
03034 return returnvalue;
03035 }
03036
03037
03043
03044 double xsh_pfits_get_wavesol_y_max(cpl_propertylist * plist)
03045 {
03046 double returnvalue = 0.0;
03047
03048 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_Y_MAX,
03049 CPL_TYPE_DOUBLE, &returnvalue),
03050 "Error reading keyword '%s'", XSH_WAVESOL_Y_MAX);
03051
03052 cleanup:
03053 return returnvalue;
03054 }
03055
03056
03065
03066 const char *
03067 xsh_pfits_get_wavesoltype( const cpl_propertylist * plist)
03068 {
03069 const char *returnvalue = "";
03070
03071 check_msg (xsh_get_property_value
03072 (plist, XSH_WAVESOLTYPE, CPL_TYPE_STRING, &returnvalue),
03073 "Error reading keyword '%s'", XSH_WAVESOLTYPE);
03074 cleanup:
03075 return returnvalue;
03076 }
03077
03078
03087
03088 void xsh_pfits_set_wavesoltype( cpl_propertylist * plist, const char* value)
03089 {
03090 XSH_REGDEBUG("writing keyword %s = %s", XSH_WAVESOLTYPE, value);
03091 check_msg (cpl_propertylist_update_string (plist, XSH_WAVESOLTYPE, value),
03092 "Error writing keyword '%s'", XSH_WAVESOLTYPE);
03093 cleanup:
03094 return;
03095 }
03096
03097
03103
03104 void xsh_pfits_set_rectify_bin_lambda(cpl_propertylist * plist, double value)
03105 {
03106 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_BIN_LAMBDA,
03107 value),
03108 "Error writing keyword '%s'", XSH_RECTIFY_BIN_LAMBDA);
03109
03110 cleanup:
03111 return;
03112 }
03113
03119
03120 void xsh_pfits_set_rectify_bin_space(cpl_propertylist * plist, double value)
03121 {
03122 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_BIN_SPACE,
03123 value),
03124 "Error writing keyword '%s'", XSH_RECTIFY_BIN_SPACE);
03125
03126 cleanup:
03127 return;
03128 }
03129
03135
03136 void xsh_pfits_set_rectify_lambda_min(cpl_propertylist * plist, double value)
03137 {
03138 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_LAMBDA_MIN,
03139 value),
03140 "Error writing keyword '%s'", XSH_RECTIFY_LAMBDA_MIN);
03141
03142 cleanup:
03143 return;
03144 }
03145
03151
03152 void xsh_pfits_set_rectify_lambda_max(cpl_propertylist * plist, double value)
03153 {
03154 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_LAMBDA_MAX,
03155 value),
03156 "Error writing keyword '%s'", XSH_RECTIFY_LAMBDA_MAX);
03157
03158 cleanup:
03159 return;
03160 }
03161
03167
03168 void xsh_pfits_set_rectify_space_min(cpl_propertylist * plist, double value)
03169 {
03170 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_SPACE_MIN,
03171 value),
03172 "Error writing keyword '%s'", XSH_RECTIFY_SPACE_MIN);
03173
03174 cleanup:
03175 return;
03176 }
03177
03183
03184 void xsh_pfits_set_rectify_space_max(cpl_propertylist * plist, double value)
03185 {
03186 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_SPACE_MAX,
03187 value),
03188 "Error writing keyword '%s'", XSH_RECTIFY_SPACE_MAX);
03189
03190 cleanup:
03191 return;
03192 }
03193
03199
03200 double xsh_pfits_get_rectify_bin_lambda(cpl_propertylist * plist)
03201 {
03202 double returnvalue = 0.0;
03203
03204 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_BIN_LAMBDA,
03205 CPL_TYPE_DOUBLE, &returnvalue),
03206 "Error reading keyword '%s'", XSH_RECTIFY_BIN_LAMBDA);
03207
03208 cleanup:
03209 return returnvalue;
03210 }
03211
03217
03218 double xsh_pfits_get_rectify_bin_space(cpl_propertylist * plist)
03219 {
03220 double returnvalue = 0.0;
03221
03222 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_BIN_SPACE,
03223 CPL_TYPE_DOUBLE, &returnvalue),
03224 "Error reading keyword '%s'", XSH_RECTIFY_BIN_SPACE);
03225
03226 cleanup:
03227 return returnvalue;
03228 }
03229
03235 double xsh_pfits_get_rectify_lambda_min(cpl_propertylist * plist)
03236 {
03237 double returnvalue = 0.0;
03238
03239 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_LAMBDA_MIN,
03240 CPL_TYPE_DOUBLE, &returnvalue),
03241 "Error reading keyword '%s'", XSH_RECTIFY_LAMBDA_MIN);
03242
03243 cleanup:
03244 return returnvalue;
03245 }
03246
03252 double xsh_pfits_get_rectify_lambda_max(cpl_propertylist * plist)
03253 {
03254 double returnvalue = 0.0;
03255
03256 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_LAMBDA_MAX,
03257 CPL_TYPE_DOUBLE, &returnvalue),
03258 "Error reading keyword '%s'", XSH_RECTIFY_LAMBDA_MAX);
03259
03260 cleanup:
03261 return returnvalue;
03262 }
03263
03269 double xsh_pfits_get_rectify_space_min(cpl_propertylist * plist)
03270 {
03271 double returnvalue = 0.0;
03272
03273 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_SPACE_MIN,
03274 CPL_TYPE_DOUBLE, &returnvalue),
03275 "Error reading keyword '%s'", XSH_RECTIFY_SPACE_MIN);
03276
03277 cleanup:
03278 return returnvalue;
03279 }
03280
03286 double xsh_pfits_get_rectify_space_max(cpl_propertylist * plist)
03287 {
03288 double returnvalue = 0.0;
03289
03290 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_SPACE_MAX,
03291 CPL_TYPE_DOUBLE, &returnvalue),
03292 "Error reading keyword '%s'", XSH_RECTIFY_SPACE_MAX);
03293
03294 cleanup:
03295 return returnvalue;
03296 }
03297
03298
03304 int xsh_pfits_get_obs_id(cpl_propertylist * plist)
03305 {
03306 int returnvalue = 0;
03307
03308 check_msg (xsh_get_property_value (plist, XSH_OBS_ID,
03309 CPL_TYPE_INT, &returnvalue),
03310 "Error reading keyword '%s'", XSH_OBS_ID);
03311
03312 cleanup:
03313 return returnvalue;
03314 }
03315
03316
03325 int xsh_pfits_get_nb_pinhole( const cpl_propertylist * plist){
03326 int nb_pinhole=1;
03327 const char* pinhole = NULL;
03328
03329 XSH_ASSURE_NOT_NULL( plist);
03330 check( pinhole = xsh_pfits_get_dpr_tech( plist));
03331
03332 if ( strcmp( pinhole, XSH_DPR_TECH_MULTI_PINHOLE) == 0 ){
03333 nb_pinhole = XSH_NB_PINHOLE;
03334 }
03335 else if (strcmp( pinhole, XSH_DPR_TECH_SINGLE_PINHOLE) == 0){
03336 nb_pinhole = 1;
03337 }
03338 else{
03339 xsh_error_msg( "Undefined pinhole : can't identify DPR keyword %s\n\
03340 Authorized keyword are ( single %s multi %s )", pinhole,
03341 XSH_DPR_TECH_SINGLE_PINHOLE, XSH_DPR_TECH_MULTI_PINHOLE);
03342 }
03343 cleanup:
03344 return nb_pinhole;
03345 }
03346
03355 double xsh_pfits_get_tel_targ_alpha( const cpl_propertylist * plist)
03356 {
03357 double returnvalue = 0. ;
03358
03359 check_msg (xsh_get_property_value (plist, XSH_TEL_TARG_ALPHA,
03360 CPL_TYPE_DOUBLE, &returnvalue),
03361 "Error reading keyword '%s'", XSH_TEL_TARG_ALPHA ) ;
03362
03363 cleanup:
03364 return returnvalue;
03365 }
03366
03375 double xsh_pfits_get_tel_targ_delta( const cpl_propertylist * plist)
03376 {
03377 double returnvalue = 0. ;
03378
03379 check_msg (xsh_get_property_value (plist, XSH_TEL_TARG_DELTA,
03380 CPL_TYPE_DOUBLE, &returnvalue),
03381 "Error reading keyword '%s'", XSH_TEL_TARG_DELTA ) ;
03382
03383 cleanup:
03384 return returnvalue;
03385 }
03386
03395 double xsh_pfits_get_ra( const cpl_propertylist * plist)
03396 {
03397 double returnvalue = 0. ;
03398
03399 check_msg (xsh_get_property_value (plist, XSH_RA,
03400 CPL_TYPE_DOUBLE, &returnvalue),
03401 "Error reading keyword '%s'", XSH_RA ) ;
03402
03403 cleanup:
03404 return returnvalue;
03405 }
03406
03407
03416 double xsh_pfits_get_dec( const cpl_propertylist * plist)
03417 {
03418 double returnvalue = 0. ;
03419
03420 check_msg (xsh_get_property_value (plist, XSH_DEC,
03421 CPL_TYPE_DOUBLE, &returnvalue),
03422 "Error reading keyword '%s'", XSH_DEC ) ;
03423
03424 cleanup:
03425 return returnvalue;
03426 }
03427
03428
03429 double xsh_pfits_get_posang( const cpl_propertylist *plist)
03430 {
03431 double returnvalue = 0. ;
03432
03433 check_msg (xsh_get_property_value (plist, XSH_POSANG,
03434 CPL_TYPE_DOUBLE, &returnvalue),
03435 "Error reading keyword '%s'", XSH_POSANG) ;
03436
03437 cleanup:
03438 return returnvalue;
03439 }
03440
03441
03442
03443
03444 double xsh_pfits_get_ra_reloffset( const cpl_propertylist *plist)
03445 {
03446 double returnvalue = 0. ;
03447
03448 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_RA,
03449 CPL_TYPE_DOUBLE, &returnvalue),
03450 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_RA) ;
03451
03452 cleanup:
03453 return returnvalue;
03454 }
03455
03456
03457
03458
03459 double xsh_pfits_get_dec_reloffset( const cpl_propertylist *plist)
03460 {
03461 double returnvalue = 0. ;
03462
03463 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_DEC,
03464 CPL_TYPE_DOUBLE, &returnvalue),
03465 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_DEC) ;
03466
03467 cleanup:
03468 return returnvalue;
03469 }
03470
03471
03472
03473
03474 double xsh_pfits_get_cumoffsetx( const cpl_propertylist *plist)
03475 {
03476 double returnvalue = 0. ;
03477
03478 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSETX,
03479 CPL_TYPE_DOUBLE, &returnvalue),
03480 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSETX) ;
03481
03482 cleanup:
03483 return returnvalue;
03484 }
03485
03486
03487 double xsh_pfits_get_cumoffsety( const cpl_propertylist *plist)
03488 {
03489 double returnvalue = 0. ;
03490
03491 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSETY,
03492 CPL_TYPE_DOUBLE, &returnvalue),
03493 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSETY) ;
03494
03495 cleanup:
03496 return returnvalue;
03497 }
03498
03499
03500
03501 double xsh_pfits_get_ra_cumoffset( const cpl_propertylist *plist)
03502 {
03503 double returnvalue = 0. ;
03504
03505 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_RA,
03506 CPL_TYPE_DOUBLE, &returnvalue),
03507 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_RA) ;
03508
03509 cleanup:
03510 return returnvalue;
03511 }
03512
03513
03514
03515
03516 double xsh_pfits_get_dec_cumoffset( const cpl_propertylist *plist)
03517 {
03518 double returnvalue = 0. ;
03519
03520 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_DEC,
03521 CPL_TYPE_DOUBLE, &returnvalue),
03522 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_DEC) ;
03523
03524 cleanup:
03525 return returnvalue;
03526 }
03527
03528
03529
03530
03531 double xsh_pfits_get_b_ra_reloffset( const cpl_propertylist *plist)
03532 {
03533 double returnvalue = 0. ;
03534
03535 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_B_OFFSET_RA,
03536 CPL_TYPE_DOUBLE, &returnvalue),
03537 "Error reading keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_RA) ;
03538
03539 cleanup:
03540 return returnvalue;
03541 }
03542
03543
03544
03545
03546 double xsh_pfits_get_b_dec_reloffset( const cpl_propertylist *plist)
03547 {
03548 double returnvalue = 0. ;
03549
03550 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_B_OFFSET_DEC,
03551 CPL_TYPE_DOUBLE, &returnvalue),
03552 "Error reading keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_DEC) ;
03553
03554 cleanup:
03555 return returnvalue;
03556 }
03557
03558
03559
03560
03561 double xsh_pfits_get_b_ra_cumoffset( const cpl_propertylist *plist)
03562 {
03563 double returnvalue = 0. ;
03564
03565 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_B_OFFSET_RA,
03566 CPL_TYPE_DOUBLE, &returnvalue),
03567 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_RA) ;
03568
03569 cleanup:
03570 return returnvalue;
03571 }
03572
03573
03574
03575
03576 double xsh_pfits_get_b_dec_cumoffset( const cpl_propertylist *plist)
03577 {
03578 double returnvalue = 0. ;
03579
03580 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_B_OFFSET_DEC,
03581 CPL_TYPE_DOUBLE, &returnvalue),
03582 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_DEC);
03583
03584 cleanup:
03585 return returnvalue;
03586 }
03587
03588
03589
03590
03591 void xsh_pfits_set_b_ra_reloffset(cpl_propertylist * plist, double value)
03592 {
03593 check_msg( cpl_propertylist_update_double
03594 (plist, XSH_NOD_RELATIVE_B_OFFSET_RA, value),
03595 "Error writing keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_RA);
03596 cleanup:
03597 return;
03598 }
03599
03600
03601
03602
03603 void xsh_pfits_set_b_dec_reloffset(cpl_propertylist * plist, double value)
03604 {
03605 check_msg( cpl_propertylist_update_double
03606 (plist, XSH_NOD_RELATIVE_B_OFFSET_DEC, value),
03607 "Error writing keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_DEC);
03608 cleanup:
03609 return;
03610 }
03611
03612
03613
03614
03615
03616 void xsh_pfits_set_b_ra_cumoffset(cpl_propertylist * plist, double value)
03617 {
03618 check_msg( cpl_propertylist_update_double
03619 (plist, XSH_NOD_CUMULATIVE_B_OFFSET_RA, value),
03620 "Error writing keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_RA);
03621 cleanup:
03622 return;
03623 }
03624
03625
03626
03627
03628 void xsh_pfits_set_b_dec_cumoffset(cpl_propertylist * plist, double value)
03629 {
03630 check_msg( cpl_propertylist_update_double
03631 (plist, XSH_NOD_CUMULATIVE_B_OFFSET_DEC, value),
03632 "Error writing keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_DEC);
03633 cleanup:
03634 return;
03635 }
03636
03637
03638
03639
03640 void xsh_pfits_set_slitmap_order_edgup( cpl_propertylist * plist, int absorder,
03641 double value)
03642 {
03643 char name[256];
03644
03645 sprintf( name, XSH_SLITMAP_ORDER_EDGUP, absorder);
03646
03647 check_msg( cpl_propertylist_update_double
03648 (plist, name, value),
03649 "Error writing keyword '%s'", name);
03650
03651 cleanup:
03652 return;
03653 }
03654
03655
03656
03657
03658 void xsh_pfits_set_slitmap_order_edglo( cpl_propertylist * plist, int absorder,
03659 double value)
03660 {
03661 char name[256];
03662
03663 sprintf( name, XSH_SLITMAP_ORDER_EDGLO, absorder);
03664
03665 check_msg( cpl_propertylist_update_double
03666 (plist, name, value),
03667 "Error writing keyword '%s'", name);
03668
03669 cleanup:
03670 return;
03671 }
03672
03673
03674
03675 void xsh_pfits_set_slitmap_order_slicup( cpl_propertylist * plist, int absorder,
03676 double value)
03677 {
03678 char name[256];
03679
03680 sprintf( name, XSH_SLITMAP_ORDER_SLICUP, absorder);
03681
03682 check_msg( cpl_propertylist_update_double
03683 (plist, name, value),
03684 "Error writing keyword '%s'", name);
03685
03686 cleanup:
03687 return;
03688 }
03689
03690
03691
03692 void xsh_pfits_set_slitmap_order_sliclo( cpl_propertylist * plist, int absorder,
03693 double value)
03694 {
03695 char name[256];
03696
03697 sprintf( name, XSH_SLITMAP_ORDER_SLICLO, absorder);
03698
03699 check_msg( cpl_propertylist_update_double
03700 (plist, name, value),
03701 "Error writing keyword '%s'", name);
03702
03703 cleanup:
03704 return;
03705 }
03706
03707
03708
03709
03710 void xsh_pfits_set_slitmap_order_cen( cpl_propertylist * plist, int absorder,
03711 double value)
03712 {
03713 char name[256];
03714
03715 sprintf( name, XSH_SLITMAP_ORDER_CEN, absorder);
03716
03717 check_msg( cpl_propertylist_update_double
03718 (plist, name, value),
03719 "Error writing keyword '%s'", name);
03720
03721 cleanup:
03722 return;
03723 }
03724
03725
03726
03727
03728
03729 void xsh_pfits_set_slitmap_median_edgup( cpl_propertylist * plist,
03730 double value)
03731 {
03732 const char* name = XSH_SLITMAP_MEDIAN_EDGUP;
03733
03734
03735 check_msg( cpl_propertylist_update_double
03736 (plist, name, value),
03737 "Error writing keyword '%s'", name);
03738
03739 cleanup:
03740 return;
03741 }
03742
03743
03744
03745
03746 void xsh_pfits_set_slitmap_median_edglo( cpl_propertylist * plist,
03747 double value)
03748 {
03749 const char* name = XSH_SLITMAP_MEDIAN_EDGLO;
03750
03751
03752 check_msg( cpl_propertylist_update_double
03753 (plist, name, value),
03754 "Error writing keyword '%s'", name);
03755
03756 cleanup:
03757 return;
03758 }
03759
03760
03761
03762
03763 void xsh_pfits_set_slitmap_median_sliclo( cpl_propertylist * plist,
03764 double value)
03765 {
03766 const char* name = XSH_SLITMAP_MEDIAN_SLICLO;
03767
03768
03769 check_msg( cpl_propertylist_update_double
03770 (plist, name, value),
03771 "Error writing keyword '%s'", name);
03772
03773 cleanup:
03774 return;
03775 }
03776
03777
03778
03779
03780 void xsh_pfits_set_slitmap_median_slicup( cpl_propertylist * plist,
03781 double value)
03782 {
03783 const char* name = XSH_SLITMAP_MEDIAN_SLICUP;
03784
03785
03786 check_msg( cpl_propertylist_update_double
03787 (plist, name, value),
03788 "Error writing keyword '%s'", name);
03789
03790 cleanup:
03791 return;
03792 }
03793
03794
03795
03796
03797 void xsh_pfits_set_slitmap_median_cen( cpl_propertylist * plist,
03798 double value)
03799 {
03800 const char* name = XSH_SLITMAP_MEDIAN_CEN;
03801
03802
03803 check_msg( cpl_propertylist_update_double
03804 (plist, name, value),
03805 "Error writing keyword '%s'", name);
03806
03807 cleanup:
03808 return;
03809 }
03810
03811
03812
03813
03814 double xsh_pfits_get_slitmap_median_edgup(const cpl_propertylist * plist)
03815 {
03816 double returnvalue = 0.;
03817 const char *name = XSH_SLITMAP_MEDIAN_EDGUP;
03818
03819 check_msg( xsh_get_property_value (plist, name,
03820 CPL_TYPE_DOUBLE, &returnvalue),
03821 "Error reading keyword '%s'", name);
03822
03823 cleanup:
03824 return returnvalue;
03825 }
03826
03827
03828
03829
03830 double xsh_pfits_get_slitmap_median_edglo(const cpl_propertylist * plist)
03831 {
03832 double returnvalue = 0.;
03833 const char *name = XSH_SLITMAP_MEDIAN_EDGLO;
03834
03835 check_msg( xsh_get_property_value (plist, name,
03836 CPL_TYPE_DOUBLE, &returnvalue),
03837 "Error reading keyword '%s'", name);
03838
03839 cleanup:
03840 return returnvalue;
03841 }
03842
03843
03844
03845
03846 double xsh_pfits_get_slitmap_median_cen(const cpl_propertylist * plist)
03847 {
03848 double returnvalue = 0.;
03849 const char *name = XSH_SLITMAP_MEDIAN_CEN;
03850
03851 check_msg( xsh_get_property_value (plist, name,
03852 CPL_TYPE_DOUBLE, &returnvalue),
03853 "Error reading keyword '%s'", name);
03854
03855 cleanup:
03856 return returnvalue;
03857 }
03858
03859
03860
03861
03862 double xsh_pfits_get_slitmap_median_slicup(const cpl_propertylist * plist)
03863 {
03864 double returnvalue = 0.;
03865 const char *name = XSH_SLITMAP_MEDIAN_SLICUP;
03866
03867 check_msg( xsh_get_property_value (plist, name,
03868 CPL_TYPE_DOUBLE, &returnvalue),
03869 "Error reading keyword '%s'", name);
03870
03871 cleanup:
03872 return returnvalue;
03873 }
03874
03875
03876
03877
03878 double xsh_pfits_get_slitmap_median_sliclo(const cpl_propertylist * plist)
03879 {
03880 double returnvalue = 0.;
03881 const char *name = XSH_SLITMAP_MEDIAN_SLICLO;
03882
03883 check_msg( xsh_get_property_value (plist, name,
03884 CPL_TYPE_DOUBLE, &returnvalue),
03885 "Error reading keyword '%s'", name);
03886
03887 cleanup:
03888 return returnvalue;
03889 }
03890
03891
03892
03893
03894
03895 void xsh_pfits_set_wavemap_order_lambda_min( cpl_propertylist * plist, int absorder,
03896 double value)
03897 {
03898 char name[256];
03899
03900 sprintf( name, XSH_WAVEMAP_ORDER_LAMBDA_MIN, absorder);
03901
03902 check_msg( cpl_propertylist_update_double
03903 (plist, name, value),
03904 "Error writing keyword '%s'", name);
03905
03906 cleanup:
03907 return;
03908 }
03909
03910
03911
03912
03913 void xsh_pfits_set_wavemap_order_lambda_max( cpl_propertylist * plist, int absorder,
03914 double value)
03915 {
03916 char name[256];
03917
03918 sprintf( name, XSH_WAVEMAP_ORDER_LAMBDA_MAX, absorder);
03919
03920 check_msg( cpl_propertylist_update_double
03921 (plist, name, value),
03922 "Error writing keyword '%s'", name);
03923
03924 cleanup:
03925 return;
03926 }
03927
03928
03929
03930
03931 void xsh_pfits_set_shiftifu_lambdaref( cpl_propertylist * plist,
03932 double value)
03933 {
03934
03935 check_msg( cpl_propertylist_update_double
03936 (plist, XSH_SHIFTIFU_WAVEREF, value),
03937 "Error writing keyword '%s'", XSH_SHIFTIFU_WAVEREF);
03938
03939 cleanup:
03940 return;
03941 }
03942
03943
03944
03945
03946 double xsh_pfits_get_shiftifu_lambdaref( cpl_propertylist * plist)
03947 {
03948 double returnvalue = 0;
03949
03950 check_msg (xsh_get_property_value (plist, XSH_SHIFTIFU_WAVEREF,
03951 CPL_TYPE_DOUBLE, &returnvalue),
03952 "Error reading keyword '%s'", XSH_SHIFTIFU_WAVEREF);
03953 cleanup:
03954 return returnvalue;
03955 }
03956
03957
03958
03959
03960 void xsh_pfits_set_shiftifu_slitref( cpl_propertylist * plist,
03961 double value)
03962 {
03963
03964 check_msg( cpl_propertylist_update_double
03965 (plist, XSH_SHIFTIFU_SLITREF, value),
03966 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITREF);
03967
03968 cleanup:
03969 return;
03970 }
03971
03972
03973
03974
03975 void xsh_pfits_set_shiftifu_slitdownref( cpl_propertylist * plist,
03976 double value)
03977 {
03978
03979 check_msg( cpl_propertylist_update_double
03980 (plist, XSH_SHIFTIFU_SLITDOWNREF, value),
03981 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITDOWNREF);
03982
03983 cleanup:
03984 return;
03985 }
03986
03987
03988
03989
03990 void xsh_pfits_set_shiftifu_slitcenref( cpl_propertylist * plist,
03991 double value)
03992 {
03993
03994 check_msg( cpl_propertylist_update_double
03995 (plist, XSH_SHIFTIFU_SLITCENREF, value),
03996 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITCENREF);
03997
03998 cleanup:
03999 return;
04000 }
04001
04002
04003
04004
04005 void xsh_pfits_set_shiftifu_slitupref( cpl_propertylist * plist,
04006 double value)
04007 {
04008
04009 check_msg( cpl_propertylist_update_double
04010 (plist, XSH_SHIFTIFU_SLITUPREF, value),
04011 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITUPREF);
04012
04013 cleanup:
04014 return;
04015 }
04016
04017
04018
04019
04020 double xsh_pfits_get_shiftifu_slitref( cpl_propertylist * plist)
04021 {
04022 double returnvalue = 0;
04023
04024 check_msg (xsh_get_property_value (plist, XSH_SHIFTIFU_SLITREF,
04025 CPL_TYPE_DOUBLE, &returnvalue),
04026 "Error reading keyword '%s'", XSH_SHIFTIFU_SLITREF);
04027 cleanup:
04028 return returnvalue;
04029 }
04030
04031
04032
04041 double xsh_pfits_get_nod_reloffset( const cpl_propertylist * plist)
04042 {
04043 double returnvalue = 0. ;
04044 double dec = 0., ra = 0. ;
04045
04046 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_DEC,
04047 CPL_TYPE_DOUBLE, &dec),
04048 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_DEC ) ;
04049 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_RA,
04050 CPL_TYPE_DOUBLE, &ra),
04051 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_RA ) ;
04052 returnvalue = sqrt( dec*dec + ra*ra ) ;
04053 xsh_msg_dbg_high( "dec: %lf, ra: %lf, reloffset: %lf", dec, ra, returnvalue ) ;
04054
04055 cleanup:
04056 return returnvalue;
04057 }
04058
04067 double xsh_pfits_get_nod_cumoffset( const cpl_propertylist * plist)
04068 {
04069 double returnvalue = 0 ;
04070 double dec = 0., ra = 0. ;
04071
04072 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_DEC,
04073 CPL_TYPE_DOUBLE, &dec),
04074 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_DEC ) ;
04075 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_RA,
04076 CPL_TYPE_DOUBLE, &ra),
04077 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_RA ) ;
04078 returnvalue = sqrt( dec*dec + ra*ra ) ;
04079 xsh_msg_dbg_high ("dec: %lf, ra: %lf, cumoffset: %lf", dec, ra, returnvalue ) ;
04080
04081 cleanup:
04082 return returnvalue;
04083
04084 }
04085
04094 double xsh_pfits_get_nod_jitterwidth( const cpl_propertylist * plist)
04095 {
04096 double returnvalue = 0 ;
04097
04098 check_msg (xsh_get_property_value (plist, XSH_NOD_JITTER_BOX,
04099 CPL_TYPE_DOUBLE, &returnvalue),
04100 "Error reading keyword '%s'", XSH_NOD_JITTER_BOX );
04101
04102 cleanup:
04103 return returnvalue;
04104
04105 }
04106
04115 double xsh_pfits_get_nodthrow( const cpl_propertylist * plist)
04116 {
04117 double returnvalue = 0 ;
04118
04119 check_msg (xsh_get_property_value (plist, XSH_NOD_THROW,
04120 CPL_TYPE_DOUBLE, &returnvalue),
04121 "Error reading keyword '%s'", XSH_NOD_THROW);
04122
04123 cleanup:
04124 return returnvalue;
04125
04126 }
04127
04128
04137 static cpl_error_code
04138 xsh_plist_set_extra_common_keys(cpl_propertylist* plist)
04139 {
04140
04141 cpl_propertylist_append_string(plist,"HDUCLASS", "ESO") ;
04142 cpl_propertylist_set_comment(plist,"HDUCLASS","hdu classification") ;
04143
04144 cpl_propertylist_append_string(plist,"HDUDOC", "DICD") ;
04145 cpl_propertylist_set_comment(plist,"HDUDOC","hdu reference document") ;
04146
04147 cpl_propertylist_append_string(plist,"HDUVERS", "DICD V6.0") ;
04148 cpl_propertylist_set_comment(plist,"HDUVERS","hdu reference document version") ;
04149
04150 return cpl_error_get_code();
04151 }
04152
04165 cpl_error_code
04166 xsh_plist_set_extra_keys(cpl_propertylist* plist,
04167 const char* hduclas1,
04168 const char* hduclas2,
04169 const char* hduclas3,
04170 const char* scidata,
04171 const char* errdata,
04172 const char* qualdata,
04173 const int type)
04174 {
04175
04176
04177 XSH_ASSURE_NOT_ILLEGAL_MSG(type>=0,"type > 0");
04178
04179 xsh_plist_set_extra_common_keys(plist);
04180
04181 cpl_propertylist_append_string(plist,"HDUCLAS1",hduclas1) ;
04182 cpl_propertylist_set_comment(plist,"HDUCLAS1","hdu format classification") ;
04183
04184 cpl_propertylist_append_string(plist,"HDUCLAS2",hduclas2) ;
04185 cpl_propertylist_set_comment(plist,"HDUCLAS2","hdu type classification") ;
04186
04187 if(type!=0) {
04188 cpl_propertylist_append_string(plist,"HDUCLAS3",hduclas3) ;
04189 cpl_propertylist_set_comment(plist,"HDUCLAS3","hdu info classification") ;
04190 cpl_propertylist_append_string(plist,"SCIDATA",scidata) ;
04191 cpl_propertylist_set_comment(plist,"SCIDATA","name of data extension") ;
04192 }
04193
04194 if(type!=1) {
04195 cpl_propertylist_append_string(plist,"ERRDATA",errdata) ;
04196 cpl_propertylist_set_comment(plist,"ERRDATA","name of errs extension") ;
04197 }
04198
04199 if(type!=2) {
04200 cpl_propertylist_append_string(plist,"QUALDATA",qualdata) ;
04201 cpl_propertylist_set_comment(plist,"QUALDATA","name of qual extension") ;
04202 }
04203 cleanup:
04204 return cpl_error_get_code();
04205 }
04206
04207 cpl_error_code
04208 xsh_pfits_set_wcs(cpl_propertylist* header, const double crpix1,
04209 const double crval1, const double cdelt1, const double crpix2,
04210 const double crval2, const double cdelt2) {
04211 cpl_propertylist_append_double(header, XSH_CRPIX1, crpix1);
04212 cpl_propertylist_append_double(header, XSH_CRVAL1, crval1);
04213 cpl_propertylist_append_double(header, XSH_CDELT1, cdelt1);
04214 cpl_propertylist_append_string(header, XSH_CTYPE1, "LINEAR");
04215
04216 cpl_propertylist_append_double(header, XSH_CRPIX2, crpix2);
04217 cpl_propertylist_append_double(header, XSH_CRVAL2, crval2);
04218 cpl_propertylist_append_double(header, XSH_CDELT2, cdelt2);
04219 cpl_propertylist_append_string(header, XSH_CTYPE2, "LINEAR");
04220
04221 xsh_pfits_set_cd11(header, cdelt1);
04222 xsh_pfits_set_cd12(header, 0);
04223 xsh_pfits_set_cd21(header, 0);
04224 xsh_pfits_set_cd22(header, cdelt2);
04225
04226 return cpl_error_get_code();
04227 }
04228
04229 static cpl_error_code
04230 xsh_key_bin_mult_by_fct(cpl_propertylist** plist,const char* kname,const int fct)
04231 {
04232
04233 int value=0;
04234 if(cpl_propertylist_has(*plist,kname) > 0) {
04235 xsh_get_property_value(*plist,kname,CPL_TYPE_INT,&value);
04236 if(value<2) {
04237 check(cpl_propertylist_set_int(*plist,kname,value*fct));
04238 }
04239 } else {
04240 if(fct>1) {
04241 cpl_propertylist_append_int(*plist,kname,1);
04242 }
04243 }
04244
04245 cleanup:
04246 return cpl_error_get_code();
04247 }
04248
04249 static cpl_error_code
04250 xsh_key_scan_div_by_fct(cpl_propertylist** plist,const char* kname,const int fct)
04251 {
04252
04253 int value=0;
04254 if(cpl_propertylist_has(*plist,kname) > 0) {
04255 xsh_get_property_value(*plist,kname,CPL_TYPE_INT,&value);
04256 if(value<2) {
04257 check(cpl_propertylist_set_int(*plist,kname,value/fct));
04258 }
04259 } else {
04260 if(value>1) {
04261 cpl_propertylist_append_int(*plist,kname,1);
04262 }
04263 }
04264
04265 cleanup:
04266 return cpl_error_get_code();
04267 }
04268
04269
04270 cpl_error_code
04271 xsh_plist_div_by_fct(cpl_propertylist** plist,const int fctx,const int fcty)
04272 {
04273 xsh_key_bin_mult_by_fct(plist,XSH_WIN_BINX,fctx);
04274 xsh_key_bin_mult_by_fct(plist,XSH_WIN_BINY,fcty);
04275
04276 xsh_key_scan_div_by_fct(plist,XSH_PRSCX,fctx);
04277 xsh_key_scan_div_by_fct(plist,XSH_PRSCY,fcty);
04278 xsh_key_scan_div_by_fct(plist,XSH_OVSCX,fctx);
04279 xsh_key_scan_div_by_fct(plist,XSH_OVSCY,fcty);
04280
04281 return cpl_error_get_code();
04282 }