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
00039
00042
00043
00044
00045 #include <xsh_drl.h>
00046 #include <xsh_dfs.h>
00047
00048 #include <xsh_pfits_qc.h>
00049 #include <xsh_utils_wrappers.h>
00050 #include <xsh_pfits.h>
00051 #include <xsh_pfits_qc.h>
00052 #include <xsh_error.h>
00053 #include <xsh_msg.h>
00054 #include <xsh_badpixelmap.h>
00055 #include <xsh_paf_save.h>
00056 #include <xsh_utils_image.h>
00057 #include <xsh_detmon.h>
00058 #include <xsh_irplib_utils.h>
00059 #include <xsh_utils_image.h>
00060 #include <xsh_irplib_mkmaster.h>
00061 #include <math.h>
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071 #define RECIPE_ID "xsh_mbias"
00072 #define HIST_FACT 2.354820045
00073
00074
00075
00076
00077 static cpl_error_code
00078 xsh_compute_ron_mbias(cpl_frameset* raws,
00079 xsh_pre* master,
00080 cpl_parameterlist* parameters);
00081
00082
00083 static cpl_error_code
00084 xsh_compute_fpn_mbias(cpl_frameset* raws,
00085 xsh_pre* master,
00086 xsh_instrument* instrument,
00087 cpl_parameterlist* parameters);
00088
00089 static cpl_error_code
00090 xsh_mbias_get_fpn(const cpl_image* ima,
00091 cpl_parameterlist* parameters,
00092 double* fpn);
00093
00094
00095
00096
00097
00098
00099
00100 static double
00101 xsh_mdark_get_contam(xsh_pre * pre,cpl_parameterlist* drs_params,
00102 xsh_instrument* instr)
00103 {
00104
00105 double contam=0;
00106
00107 int llx_on=0;
00108 int lly_on=0;
00109 int urx_on=0;
00110 int ury_on=0;
00111
00112 int llx_off=0;
00113 int lly_off=0;
00114 int urx_off=0;
00115 int ury_off=0;
00116 if(xsh_parameters_find(drs_params,"xsh_mdark","contam_on_llx")!=NULL){
00117 check(llx_on=xsh_parameters_get_int(drs_params,"xsh_mdark","contam_on_llx"));
00118 check(lly_on=xsh_parameters_get_int(drs_params,"xsh_mdark","contam_on_lly"));
00119 check(urx_on=xsh_parameters_get_int(drs_params,"xsh_mdark","contam_on_urx"));
00120 check(ury_on=xsh_parameters_get_int(drs_params,"xsh_mdark","contam_on_ury"));
00121
00122
00123 check(llx_off=xsh_parameters_get_int(drs_params,"xsh_mdark","contam_off_llx"));
00124 check(lly_off=xsh_parameters_get_int(drs_params,"xsh_mdark","contam_off_lly"));
00125 check(urx_off=xsh_parameters_get_int(drs_params,"xsh_mdark","contam_off_urx"));
00126 check(ury_off=xsh_parameters_get_int(drs_params,"xsh_mdark","contam_off_ury"));
00127
00128 } else {
00129 if(xsh_instrument_get_arm(instr) == XSH_ARM_UVB) {
00130 llx_on =801; lly_on =1058;urx_on =810; ury_on =1067;
00131 llx_off=855; lly_off=1066;urx_off=864; ury_off=1075;
00132 } else if(xsh_instrument_get_arm(instr) == XSH_ARM_VIS) {
00133 llx_on =1672; lly_on =2672;urx_on =1681;ury_on =2681;
00134 llx_off=1926; lly_off=2941;urx_off=1935;ury_off=2950;
00135 } else if(xsh_instrument_get_arm(instr) == XSH_ARM_NIR) {
00136 llx_on =991; lly_on =1083;urx_on =1015;ury_on =1108;
00137 llx_off=1029;lly_off=1075;urx_off=1053;ury_off=1110;
00138 }
00139 }
00140
00141 llx_on=llx_on/pre->binx;
00142 lly_on=lly_on/pre->biny;
00143 urx_on=urx_on/pre->binx;
00144 ury_on=ury_on/pre->biny;
00145
00146 llx_off=llx_off/pre->binx;
00147 lly_off=lly_off/pre->biny;
00148 urx_off=urx_off/pre->binx;
00149 ury_off=ury_off/pre->biny;
00150
00151 check(contam=
00152 cpl_image_get_median_window(pre->data,llx_on,lly_on,urx_on,ury_on)-
00153 cpl_image_get_median_window(pre->data,llx_off,lly_off,urx_off,ury_off));
00154
00155
00156 cleanup:
00157
00158
00159 return contam;
00160
00161
00162 }
00163
00164
00169 cpl_error_code
00170 xsh_mdark_get_median_stdev(xsh_pre* preFrame,cpl_parameterlist* parameters,
00171 cpl_frame* crh_frm, cpl_frame* bpm_frm)
00172 {
00173
00174 int sx=0;
00175 int sy=0;
00176 int ref_llx=-1;
00177 int ref_lly=-1;
00178 int ref_urx=-1;
00179 int ref_ury=-1;
00180 xsh_pre* dup_frm=NULL;
00181 const char* crh_name=NULL;
00182 const char* bpm_name=NULL;
00183 cpl_image* crh_ima=NULL;
00184 cpl_image* bpm_ima=NULL;
00185 int* pcrh=NULL;
00186 int* pbpm=NULL;
00187 int* pqua=NULL;
00188 int i=0;
00189 bool bpm_found=false;
00190 bool crh_found=false;
00191 double avg_value = 0.0;
00192 double median_value = 0.0;
00193 double stdev = 0.0;
00194
00195 check(ref_llx=xsh_parameters_get_int(parameters,"xsh_mdark","ref1_llx"));
00196 check(ref_lly=xsh_parameters_get_int(parameters,"xsh_mdark","ref1_lly"));
00197 check(ref_urx=xsh_parameters_get_int(parameters,"xsh_mdark","ref1_urx"));
00198 check(ref_ury=xsh_parameters_get_int(parameters,"xsh_mdark","ref1_ury"));
00199 sx=cpl_image_get_size_x(preFrame->data);
00200 sy=cpl_image_get_size_y(preFrame->data);
00201
00202
00203
00204 if(ref_llx == -1) ref_llx=1;
00205 if(ref_lly == -1) ref_lly=1;
00206 if(ref_urx == -1) ref_urx=sx;
00207 if(ref_ury == -1) ref_ury=sy;
00208
00209 ref_llx = (ref_llx>0) ? ref_llx : 1;
00210 ref_lly = (ref_lly>0) ? ref_lly : 1;
00211 ref_urx = (ref_urx<sx) ? ref_urx : sx;
00212 ref_ury = (ref_ury<sy) ? ref_ury : sy;
00213
00214
00215
00216
00217
00218
00219
00220
00221 dup_frm=xsh_pre_duplicate(preFrame);
00222
00223 if(crh_frm!=NULL) {
00224 check(crh_name=cpl_frame_get_filename(crh_frm));
00225 check(crh_ima=cpl_image_load(crh_name,XSH_PRE_QUAL_TYPE,0,0));
00226 check(pcrh=cpl_image_get_data_int(crh_ima));
00227 crh_found=true;
00228 }
00229
00230 if(bpm_frm != NULL) {
00231 check(bpm_name=cpl_frame_get_filename(bpm_frm));
00232 check(bpm_ima=cpl_image_load(bpm_name,XSH_PRE_QUAL_TYPE,0,0));
00233 check(pbpm=cpl_image_get_data_int(bpm_ima));
00234 bpm_found=true;
00235 }
00236
00237 if (bpm_found || crh_found) {
00238 int sx_sy=0;
00239 check(pqua=cpl_image_get_data_int( preFrame->qual));
00240 sx = preFrame->nx;
00241 sy = preFrame->ny;
00242 sx_sy=sx*sy;
00243 if (bpm_found && crh_found) {
00244 for (i = 0; i < sx_sy; i++) {
00245 if (pcrh[i] != 0 || pbpm[i] != 0) {
00246 pqua[i] = XSH_GOOD_PIXEL_LEVEL;
00247 }
00248 }
00249 } else if (bpm_found) {
00250 for (i = 0; i < sx_sy; i++) {
00251 if (pbpm[i] != 0) {
00252 pqua[i] = XSH_GOOD_PIXEL_LEVEL;
00253 }
00254 }
00255 } else if (crh_found) {
00256 for (i = 0; i < sx_sy; i++) {
00257 if (pcrh[i] != 0) {
00258 pqua[i] = XSH_GOOD_PIXEL_LEVEL;
00259 }
00260 }
00261 }
00262 }
00263 xsh_free_image(&bpm_ima);
00264 xsh_free_image(&crh_ima);
00265 xsh_pre_free(&dup_frm);
00266
00267 check( xsh_pre_median_mean_stdev_window( preFrame,
00268 &avg_value, &median_value,&stdev,
00269 ref_llx,ref_lly,ref_urx,ref_ury) ) ;
00270
00271 xsh_pfits_set_qc_mdarkavg( preFrame->data_header,avg_value) ;
00272 xsh_pfits_set_qc_mdarkmed( preFrame->data_header,median_value) ;
00273 xsh_pfits_set_qc_mdarkrms( preFrame->data_header,stdev) ;
00274
00275 cleanup:
00276 xsh_free_image(&bpm_ima);
00277 xsh_free_image(&crh_ima);
00278 xsh_pre_free(&dup_frm);
00279 return cpl_error_get_code();
00280 }
00281
00282 static cpl_error_code
00283 xsh_mdark_measure_fpn(xsh_pre* preFrame,cpl_parameterlist* parameters,double exptime)
00284 {
00285
00286 cpl_size zone_fpn[4];
00287 int fpn_llx=-1;
00288 int fpn_lly=-1;
00289 int fpn_urx=-1;
00290 int fpn_ury=-1;
00291 int fpn_nsamp=100;
00292 int fpn_hsize=4;
00293
00294 double qc_fpn_val=0;
00295 double qc_fpn_err=0;
00296 int sx=0;
00297 int sy=0;
00298
00299 check(fpn_llx=xsh_parameters_get_int(parameters,"xsh_mdark","fpn_llx"));
00300 check(fpn_lly=xsh_parameters_get_int(parameters,"xsh_mdark","fpn_lly"));
00301 check(fpn_urx=xsh_parameters_get_int(parameters,"xsh_mdark","fpn_urx"));
00302 check(fpn_ury=xsh_parameters_get_int(parameters,"xsh_mdark","fpn_ury"));
00303 sx=cpl_image_get_size_x(preFrame->data);
00304 sy=cpl_image_get_size_y(preFrame->data);
00305
00306
00307
00308 if(fpn_llx == -1) fpn_llx=1;
00309 if(fpn_lly == -1) fpn_lly=1;
00310 if(fpn_urx == -1) fpn_urx=sx;
00311 if(fpn_ury == -1) fpn_ury=sy;
00312
00313 fpn_llx = (fpn_llx>0) ? fpn_llx : 1;
00314 fpn_lly = (fpn_lly>0) ? fpn_lly : 1;
00315 fpn_urx = (fpn_urx<sx) ? fpn_urx : sx;
00316 fpn_ury = (fpn_ury<sy) ? fpn_ury : sy;
00317
00318 assure(fpn_urx>fpn_llx,CPL_ERROR_ILLEGAL_INPUT,
00319 "Must be fpn_urx (%d) > fpn_llx (%d)",
00320 fpn_urx,fpn_llx);
00321
00322 assure(fpn_ury>fpn_lly,CPL_ERROR_ILLEGAL_INPUT,
00323 "Must be fpn_ury (%d) > fpn_lly (%d)",
00324 fpn_ury,fpn_lly);
00325
00326 zone_fpn[0]=fpn_llx;
00327 zone_fpn[1]=fpn_urx;
00328 zone_fpn[2]=fpn_lly;
00329 zone_fpn[3]=fpn_ury;
00330 check_msg(cpl_flux_get_noise_window(preFrame->data, zone_fpn, fpn_hsize,
00331 fpn_nsamp, &qc_fpn_val, &qc_fpn_err),
00332 "Error computing noise in a window");
00333
00334 xsh_pfits_set_qc_norm_fpn(preFrame->data_header,qc_fpn_val) ;
00335 xsh_pfits_set_qc_norm_fpn_err(preFrame->data_header,qc_fpn_err) ;
00336
00337
00338 qc_fpn_val *= exptime;
00339 qc_fpn_err *= exptime;
00340
00341 xsh_pfits_set_qc_fpn( preFrame->data_header,qc_fpn_val);
00342 xsh_pfits_set_qc_fpn_err(preFrame->data_header,qc_fpn_err) ;
00343
00344
00345 cleanup:
00346 return cpl_error_get_code();
00347 }
00348
00349
00350
00351 cpl_error_code
00352 xsh_mdark_measure_ron(xsh_pre* preFrame,cpl_parameterlist* parameters)
00353 {
00354
00355 int ron_llx=-1;
00356 int ron_lly=-1;
00357 int ron_urx=-1;
00358 int ron_ury=-1;
00359 int ron_nsamp=100;
00360 int ron_hsize=4;
00361 int sx=0;
00362 int sy=0;
00363
00364 check(ron_llx=xsh_parameters_get_int(parameters,"xsh_mdark","ron_llx"));
00365 check(ron_lly=xsh_parameters_get_int(parameters,"xsh_mdark","ron_lly"));
00366 check(ron_urx=xsh_parameters_get_int(parameters,"xsh_mdark","ron_urx"));
00367 check(ron_ury=xsh_parameters_get_int(parameters,"xsh_mdark","ron_ury"));
00368 check(ron_hsize=xsh_parameters_get_int(parameters,"xsh_mdark","ron_hsize"));
00369 check(ron_nsamp=xsh_parameters_get_int(parameters,"xsh_mdark","ron_nsamples"));
00370 sx=cpl_image_get_size_x(preFrame->data);
00371 sy=cpl_image_get_size_y(preFrame->data);
00372
00373
00374 if(ron_llx == -1) ron_llx=1;
00375 if(ron_lly == -1) ron_lly=1;
00376 if(ron_urx == -1) ron_urx=sx;
00377 if(ron_ury == -1) ron_ury=sy;
00378
00379 ron_llx = (ron_llx>0) ? ron_llx : 1;
00380 ron_lly = (ron_lly>0) ? ron_lly : 1;
00381 ron_urx = (ron_urx<sx) ? ron_urx : sx;
00382 ron_ury = (ron_ury<sy) ? ron_ury : sy;
00383
00384 cleanup:
00385 return cpl_error_get_code();
00386 }
00387
00398 static void
00399 set_masterdark_qc (xsh_pre * preFrame,
00400 xsh_instrument * instrument,
00401 cpl_parameterlist* parameters,
00402 double exptime,
00403 cpl_frame* crh_frm, cpl_frame* bpm_frm)
00404 {
00405 int nx =0, ny = 0;
00406
00407
00408 nx = xsh_pre_get_nx (preFrame);
00409 assure (nx != 0, cpl_error_get_code (), "Cant get X size");
00410 ny = xsh_pre_get_ny (preFrame);
00411 assure (ny != 0, cpl_error_get_code (), "Cant get Y size");
00412
00413 check(xsh_mdark_get_median_stdev(preFrame,parameters,crh_frm,bpm_frm));
00414 check(xsh_mdark_measure_fpn(preFrame,parameters,exptime));
00415
00416 {
00417 double contam=0;
00418 check(contam=xsh_mdark_get_contam(preFrame,parameters,instrument));
00419 check(xsh_pfits_set_qc_contamination( preFrame->data_header,contam)) ;
00420 }
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435 cleanup:
00436
00437 return;
00438 }
00439
00440
00441 static cpl_error_code
00442 xsh_mdark_get_fpn(cpl_image* ima,cpl_parameterlist* params,cpl_propertylist* qc_log,const double exptime)
00443 {
00444
00445 int fpn_llx=0;
00446 int fpn_lly=0;
00447 int fpn_urx=0;
00448 int fpn_ury=0;
00449 cpl_size fpn_hsize=0;
00450 cpl_size fpn_nsamp=0;
00451 int sx=0;
00452 int sy=0;
00453 cpl_size zone[4];
00454 double qc_fpn_val=0;
00455 double qc_fpn_err=0;
00456
00457
00458 XSH_ASSURE_NOT_NULL_MSG(ima, "Null input ima");
00459 XSH_ASSURE_NOT_NULL_MSG(params, "Null input parameters");
00460 XSH_ASSURE_NOT_NULL_MSG(qc_log, "Null input QC propertylist");
00461
00462 sx=cpl_image_get_size_x(ima);
00463 sy=cpl_image_get_size_y(ima);
00464
00465
00466 check(fpn_llx=xsh_parameters_get_int(params,"xsh_mdark","fpn_llx"));
00467 check(fpn_lly=xsh_parameters_get_int(params,"xsh_mdark","fpn_lly"));
00468 check(fpn_urx=xsh_parameters_get_int(params,"xsh_mdark","fpn_urx"));
00469 check(fpn_ury=xsh_parameters_get_int(params,"xsh_mdark","fpn_ury"));
00470 check(fpn_hsize=xsh_parameters_get_int(params,"xsh_mdark","fpn_hsize"));
00471 check(fpn_nsamp=xsh_parameters_get_int(params,"xsh_mdark","fpn_nsamples"));
00472
00473
00474
00475
00476 if(fpn_llx == -1) fpn_llx=1;
00477 if(fpn_lly == -1) fpn_lly=1;
00478 if(fpn_urx == -1) fpn_urx=sx;
00479 if(fpn_ury == -1) fpn_ury=sy;
00480
00481 fpn_llx = (fpn_llx>0) ? fpn_llx : 1;
00482 fpn_lly = (fpn_lly>0) ? fpn_lly : 1;
00483 fpn_urx = (fpn_urx<sx) ? fpn_urx : sx;
00484 fpn_ury = (fpn_ury<sy) ? fpn_ury : sy;
00485
00486 assure(fpn_urx>fpn_llx,CPL_ERROR_ILLEGAL_INPUT,
00487 "Must be fpn_urx (%d) > fpn_llx (%d)",
00488 fpn_urx,fpn_llx);
00489
00490 assure(fpn_ury>fpn_lly,CPL_ERROR_ILLEGAL_INPUT,
00491 "Must be fpn_ury (%d) > fpn_lly (%d)",
00492 fpn_ury,fpn_lly);
00493
00494
00495 zone[0]=fpn_llx;
00496 zone[1]=fpn_urx;
00497 zone[2]=fpn_lly;
00498 zone[3]=fpn_ury;
00499
00500 check_msg(cpl_flux_get_noise_window(ima, zone, fpn_hsize,fpn_nsamp,
00501 &qc_fpn_val, &qc_fpn_err),
00502 "Error computing noise in a window");
00503
00504
00505 xsh_pfits_set_qc_fpn(qc_log,qc_fpn_val);
00506 xsh_pfits_set_qc_fpn_err(qc_log,qc_fpn_err) ;
00507
00508
00509
00510
00511 qc_fpn_val /= exptime;
00512 qc_fpn_err /= exptime;
00513
00514 xsh_pfits_set_qc_norm_fpn(qc_log,qc_fpn_val) ;
00515 xsh_pfits_set_qc_norm_fpn_err(qc_log,qc_fpn_err) ;
00516
00517
00518 cleanup:
00519
00520 return cpl_error_get_code();
00521
00522 }
00523
00524
00525 static cpl_error_code
00526 xsh_mdark_compute_fpn(cpl_frameset* raws,cpl_parameterlist* params,
00527 cpl_propertylist* qclog,xsh_instrument* instrument)
00528 {
00529
00530 int nraws=0;
00531 cpl_frame* frm=NULL;
00532 xsh_pre* pre1=NULL;
00533 xsh_pre* pre2=NULL;
00534 double exptime=0;
00535
00536 XSH_ASSURE_NOT_NULL_MSG(raws, "Null input raw frames set");
00537 XSH_ASSURE_NOT_NULL_MSG(params, "Null input parameter list");
00538 XSH_ASSURE_NOT_NULL_MSG(qclog, "Null input qc property list");
00539
00540 nraws=cpl_frameset_get_size(raws);
00541
00542 XSH_ASSURE_NOT_ILLEGAL_MSG(nraws >1,"Min 2 raw darks needed to compute FPN");
00543
00544 frm=cpl_frameset_get_frame(raws,0);
00545 pre1=xsh_pre_load(frm,instrument);
00546
00547 frm=cpl_frameset_get_frame(raws,1);
00548 pre2=xsh_pre_load(frm,instrument);
00549
00550 xsh_pre_subtract(pre1,pre2);
00551 exptime=xsh_pfits_get_exptime(pre1->data_header);
00552 check(xsh_mdark_get_fpn(pre1->data,params,qclog,exptime));
00553
00554 cleanup:
00555 xsh_pre_free(&pre1);
00556 xsh_pre_free(&pre2);
00557
00558 return cpl_error_get_code();
00559
00560 }
00561
00570 cpl_frame *
00571 xsh_create_master_dark2(cpl_frameset * raws,
00572 xsh_stack_param* stack_param,
00573 cpl_parameterlist* drs_params,
00574 cpl_propertylist* qc_log,
00575 xsh_instrument* instr)
00576 {
00577
00578 double mean_exptime=0;
00579 cpl_imagelist* raw_data=NULL;
00580 cpl_imagelist* raw_errs=NULL;
00581 cpl_imagelist* raw_qual=NULL;
00582 cpl_imagelist* iml_errs=NULL;
00583 cpl_imagelist* iml_data=NULL;
00584
00585 cpl_propertylist** raw_headers=NULL;
00586 cpl_frame* mdark=NULL;
00587 cpl_image* mbias=NULL;
00588 xsh_pre* pre=NULL;
00589
00590 cpl_frame* frm=NULL;
00591 char mdark_name[80];
00592 char mdark_tag[80];
00593
00594
00595 int sz=0;
00596 int i=0;
00597
00598
00599 sz=cpl_frameset_get_size(raws);
00600 raw_data=cpl_imagelist_new();
00601 raw_errs=cpl_imagelist_new();
00602 raw_qual=cpl_imagelist_new();
00603 raw_headers=cpl_calloc(sz,sizeof(cpl_propertylist*));
00604
00605 for(i=0;i<sz;i++){
00606 check(frm=cpl_frameset_get_frame(raws,i));
00607 pre=xsh_pre_load(frm,instr);
00608
00609 check(xsh_image_flag_bp(pre->data,pre->qual,instr));
00610 cpl_imagelist_set(raw_data,cpl_image_duplicate(pre->data),i);
00611 cpl_imagelist_set(raw_errs,cpl_image_duplicate(pre->errs),i);
00612 raw_headers[i]=cpl_propertylist_duplicate(pre->data_header);
00613
00614
00615 if (i < (sz-1)) {
00616 xsh_pre_free(&pre);
00617 }
00618 }
00619
00620 iml_data=xsh_irplib_mkmaster_dark_fill_imagelist(raw_data,raw_headers,mbias,&mean_exptime);
00621
00622 iml_errs=xsh_irplib_mkmaster_dark_fill_imagelist(raw_errs,raw_headers,mbias,&mean_exptime);
00623
00624
00625 if (strcmp(stack_param->stack_method, "median") == 0) {
00626 xsh_msg("Calculating stack median");
00627 xsh_free_image(&pre->data);
00628 xsh_free_image(&pre->errs);
00629 pre->data = cpl_imagelist_collapse_median_create(iml_data);
00630 pre->errs = cpl_imagelist_collapse_median_create(iml_errs);
00631 } else {
00632 xsh_msg("Calculating stack mean");
00633 xsh_free_image(&pre->data);
00634 xsh_free_image(&pre->errs);
00635 pre->data=xsh_irplib_mkmaster_mean(iml_data,5.,5,1.e-5,stack_param->klow,stack_param->khigh,stack_param->niter);
00636 pre->errs=xsh_irplib_mkmaster_mean(iml_errs,5.,5,1.e-5,stack_param->klow,stack_param->khigh,stack_param->niter);
00637 }
00638
00639 check(xsh_pfits_set_exptime(pre->data_header, mean_exptime ));
00640
00641 if(qc_log != NULL ) {
00642 xsh_mdark_compute_fpn(raws,drs_params,qc_log,instr);
00643 }
00644 if(qc_log != NULL ) {
00645 cpl_propertylist_append(pre->data_header,qc_log);
00646 }
00647
00648 sprintf(mdark_tag,"%s_%s",XSH_MASTER_DARK,xsh_instrument_arm_tostring(instr));
00649 sprintf(mdark_name,"%s.fits",mdark_tag);
00650
00651 check(mdark = xsh_pre_save( pre,mdark_name,mdark_tag,0));
00652 check(cpl_frame_set_tag(mdark,mdark_tag));
00653
00654 cleanup:
00655 xsh_free_imagelist(&raw_data);
00656 xsh_free_imagelist(&raw_errs);
00657 xsh_free_imagelist(&raw_qual);
00658 xsh_free_imagelist(&iml_data);
00659 xsh_free_imagelist(&iml_errs);
00660 xsh_pre_free(&pre);
00661
00662 for(i=0;i<sz;i++){
00663 xsh_free_propertylist(&raw_headers[i]);
00664 }
00665 cpl_free(raw_headers);
00666 return mdark;
00667 }
00680 cpl_frame *
00681 xsh_create_master_dark (cpl_frame * medFrame, xsh_instrument* instr,
00682 cpl_parameterlist* parameters,
00683 cpl_frame* crh_frm,cpl_frame* bpm_frm)
00684 {
00685
00686
00687
00688
00689
00690 xsh_pre *medPre = NULL;
00691 double exptime = 0.0;
00692 cpl_frame* resFrame = NULL;
00693 const char* tag = XSH_GET_TAG_FROM_ARM (XSH_MASTER_DARK, instr);
00694 char* finalName = NULL;
00695
00696 XSH_ASSURE_NOT_NULL(medFrame);
00697 XSH_ASSURE_NOT_NULL(instr);
00698
00699 check(medPre = xsh_pre_load (medFrame,instr));
00700 XSH_ASSURE_NOT_NULL(medPre);
00701
00702 exptime = medPre->exptime;
00703
00704
00705 if ( instr->arm != XSH_ARM_NIR ) {
00706 check_msg (cpl_image_divide_scalar (medPre->data, exptime),
00707 "Cant divide median image by exptime %lf", exptime);
00708 check_msg (cpl_image_divide_scalar (medPre->errs, exptime),
00709 "Cant divide median image by exptime %lf", exptime);
00710
00711
00712 xsh_msg_dbg_high ("Set EXPTIME = 1.");
00713 check(xsh_pfits_set_exptime (medPre->data_header, (double) 1.));
00714 check(xsh_pfits_set_exptime (medPre->errs_header, (double) 1.));
00715 }
00716
00717
00718 if ( xsh_instrument_get_arm(instr) == XSH_ARM_NIR ) {
00719 check(finalName =cpl_sprintf("%s_%s.fits",XSH_MASTER_DARK,
00720 xsh_instrument_arm_tostring(instr)));
00721 } else {
00722
00723
00724
00725
00726
00727
00728
00729 check(finalName =cpl_sprintf("%s_%s.fits",XSH_MASTER_DARK,
00730 xsh_instrument_arm_tostring(instr)));
00731 }
00732
00733
00734
00735
00736
00737 check(set_masterdark_qc (medPre, instr,parameters,exptime,crh_frm,bpm_frm));
00738
00739
00740 check ( resFrame = xsh_pre_save (medPre, finalName, tag,0 ));
00741
00742 assure (resFrame != NULL, cpl_error_get_code (), "Cant save PRE");
00743 xsh_msg_dbg_high ("PRE frame saved as file %s", finalName);
00744
00745 check(cpl_frame_set_level (resFrame, CPL_FRAME_LEVEL_FINAL));
00746 check(cpl_frame_set_tag (resFrame, tag));
00747
00748 cleanup:
00749 if (cpl_error_get_code() != CPL_ERROR_NONE){
00750 xsh_free_frame(&resFrame);
00751 }
00752 cpl_free(finalName);
00753 xsh_pre_free(&medPre);
00754 return resFrame;
00755 }
00756
00757
00758
00765
00766 static void
00767 reject_lo_hi(cpl_image *image, double min, double max)
00768 {
00769 cpl_mask *mask_lo = NULL;
00770 cpl_mask *mask_hi = NULL;
00771
00772 mask_lo = cpl_mask_threshold_image_create(image, -DBL_MAX, min);
00773 mask_hi = cpl_mask_threshold_image_create(image, max, DBL_MAX);
00774 assure_mem( mask_lo );
00775 assure_mem( mask_hi );
00776
00777 cpl_mask_or(mask_lo, mask_hi);
00778
00779 cpl_image_reject_from_mask(image, mask_lo);
00780
00781 cleanup:
00782 xsh_free_mask(&mask_lo);
00783 xsh_free_mask(&mask_hi);
00784 return;
00785 }
00786
00787 static int
00788 count_good(const cpl_image *image)
00789 {
00790 return
00791 cpl_image_get_size_x(image) * cpl_image_get_size_y(image) -
00792 cpl_image_count_rejected(image);
00793 }
00794
00795 static double
00796 get_masterbias_qc_structure_row_region(cpl_image * tima)
00797 {
00798
00799 cpl_image* avg_row=NULL;
00800 double min=0;
00801 double max=0;
00802 double struct_row=0;
00803
00804
00805
00806 check(avg_row = cpl_image_collapse_create(tima,0));
00807 check(cpl_image_divide_scalar(avg_row,cpl_image_get_size_y(tima)));
00808
00809
00810 min = cpl_image_get_mean(avg_row) - 2;
00811 max = cpl_image_get_mean(avg_row) + 2;
00812
00813
00814
00815
00816 check( reject_lo_hi(avg_row, min, max) );
00817 if (count_good(avg_row) >= 2)
00818 {
00819 check(struct_row = cpl_image_get_stdev(avg_row));
00820 }
00821 else
00822 {
00823 struct_row = -1;
00824 xsh_msg_warning("Only %d good pixels in image. Setting QC parameter to -1",
00825 count_good(avg_row));
00826 }
00827
00828 cleanup:
00829 xsh_free_image(&avg_row);
00830
00831
00832 return struct_row;
00833
00834 }
00835
00836
00837
00838
00839 static double
00840 get_masterbias_qc_structure_col_region(cpl_image * tima)
00841 {
00842
00843
00844 cpl_image* avg_col=NULL;
00845 double min=0;
00846 double max=0;
00847 double struct_col=0;
00848
00849 check(avg_col = cpl_image_collapse_create(tima,1));
00850 check(cpl_image_divide_scalar(avg_col,cpl_image_get_size_x(tima)));
00851
00852
00853 min = cpl_image_get_mean(avg_col) - 2;
00854 max = cpl_image_get_mean(avg_col) + 2;
00855
00856
00857
00858
00859 check( reject_lo_hi(avg_col, min, max) );
00860 if (count_good(avg_col) >= 2)
00861 {
00862 check(struct_col = cpl_image_get_stdev(avg_col));
00863 }
00864 else
00865 {
00866 struct_col = -1;
00867 xsh_msg_warning("Only %d good pixels in image. Setting QC parameter to -1",
00868 count_good(avg_col));
00869 }
00870
00871 cleanup:
00872 xsh_free_image(&avg_col);
00873
00874
00875 return struct_col;
00876
00877 }
00878
00879
00895 static void
00896 set_masterbias_qc_uves_structure_region(xsh_pre * master,
00897 const int llx,
00898 const int lly,
00899 const int urx,
00900 const int ury,
00901 const int ref_x,
00902 const int ref_y,
00903 const int reg_id)
00904 {
00905
00906 cpl_image* xima=NULL;
00907 cpl_image* yima=NULL;
00908 double struct_row=0;
00909 double struct_col=0;
00910
00911 double mean = 0.0;
00912 double median = 0.0;
00913 double stdev = 0.0;
00914
00915 double structx = 0.0;
00916 double structy = 0.0;
00917 int nb_images = 0;
00918
00919 check( xsh_pre_median_mean_stdev_window( master, &mean, &median,&stdev,
00920 llx,lly,urx,ury) ) ;
00921
00922 check(xsh_pfits_set_qc_mbiasavg (master->data_header, mean));
00923 check(xsh_pfits_set_qc_mbiasmed (master->data_header, median));
00924 check(xsh_pfits_set_qc_mbiasrms (master->data_header, stdev));
00925
00926
00927
00928 if(reg_id==1){
00929 check(xima=cpl_image_extract(master->data,llx,lly,urx,ref_y));
00930 } else {
00931 check(xima=cpl_image_extract(master->data,llx,ref_y,urx,ury));
00932 }
00933 if (0) {
00934
00935
00936
00937 check(cpl_image_threshold(xima,
00938 -DBL_MAX,median+3*stdev,
00939 -DBL_MAX,median+3*stdev));
00940 }
00941
00942 if(reg_id==1){
00943 check(yima=cpl_image_extract(master->data,llx,lly,ref_x,ury));
00944 } else {
00945 check(yima=cpl_image_extract(master->data,ref_x,lly,urx,ury));
00946 }
00947 if (0) {
00948
00949
00950
00951 check(cpl_image_threshold(yima,
00952 -DBL_MAX,median+3*stdev,
00953 -DBL_MAX,median+3*stdev));
00954 }
00955
00956 check(struct_row=get_masterbias_qc_structure_row_region(xima));
00957 structx=struct_row;
00958
00959 check(struct_col=get_masterbias_qc_structure_col_region(yima));
00960 structy=struct_col;
00961
00962
00963 if(reg_id==1) {
00964 check(xsh_pfits_set_qc_reg1_structx(master->data_header,structx));
00965 check(xsh_pfits_set_qc_reg1_structy(master->data_header,structy));
00966 } else {
00967 check(xsh_pfits_set_qc_reg2_structx(master->data_header,structx));
00968 check(xsh_pfits_set_qc_reg2_structy(master->data_header,structy));
00969 }
00970
00971 check( nb_images = xsh_pfits_get_datancom( master->data_header));
00972
00973
00974
00975
00976
00977 cleanup:
00978 xsh_free_image(&xima);
00979 xsh_free_image(&yima);
00980 return;
00981
00982 }
00983
00998 static void
00999 set_masterbias_qc_structure_region(xsh_pre * master,
01000 const int llx,
01001 const int lly,
01002 const int urx,
01003 const int ury,
01004 const int ref_x,
01005 const int ref_y,
01006 const int reg_id)
01007 {
01008
01009
01010 check(set_masterbias_qc_uves_structure_region(master,llx,lly,urx,ury,
01011 ref_x,ref_y,reg_id));
01012
01013 cleanup:
01014 return;
01015
01016 }
01017
01018
01026 static void
01027 set_masterbias_qc_structure(xsh_pre * master, cpl_parameterlist* parameters)
01028 {
01029
01030 cpl_parameter* p=NULL;
01031 int ref_x=-1;
01032 int ref_y=-1;
01033
01034 int ref_llx=0;
01035 int ref_lly=0;
01036 int ref_urx=0;
01037 int ref_ury=0;
01038
01039 int sx=0;
01040 int sy=0;
01041 int dlevel=0;
01042
01043 sx=cpl_image_get_size_x(master->data);
01044 sy=cpl_image_get_size_y(master->data);
01045 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.struct_refx"));
01046 check(ref_x = cpl_parameter_get_int(p));
01047
01048 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.struct_refy"));
01049 check(ref_y = cpl_parameter_get_int(p));
01050
01051 check(dlevel=xsh_parameters_debug_level_get("xsh_mbias",parameters));
01052
01053 ref_llx=1;ref_urx=sx;
01054 ref_lly=1;ref_ury=sy;
01055
01056 if(ref_x == -1) {
01057 ref_x=sx/2;
01058 }
01059
01060 if(ref_y == -1) {
01061 ref_y=sy/2;
01062 }
01063
01064 ref_x = (ref_x>0) ? ref_x : 1;
01065 ref_y = (ref_y>0) ? ref_y : 1;
01066 ref_x = (ref_x<sx) ? ref_x : sx;
01067 ref_y = (ref_y<sy) ? ref_y : sy;
01068
01069 set_masterbias_qc_structure_region(master,ref_llx,ref_lly,ref_urx,ref_ury,
01070 ref_x,ref_y,1);
01071
01072
01073 set_masterbias_qc_structure_region(master,ref_llx,ref_lly,ref_urx,ref_ury,
01074 ref_x,ref_y,2);
01075
01076
01077 cleanup:
01078 return;
01079
01080 }
01081
01082
01083
01084
01085
01086
01096 cpl_frame*
01097 xsh_create_master_bias2(cpl_frameset* rawFrames,xsh_stack_param* stack_par,
01098 xsh_instrument* instr,const char* result_tag,
01099 const int method_code)
01100 {
01101 cpl_frame* medFrame = NULL;
01102 cpl_imagelist *dataList = NULL;
01103 cpl_imagelist *errsList = NULL;
01104 int i=0;
01105 int size=0;
01106 xsh_pre* pre = NULL;
01107 cpl_frame *current = NULL;
01108 cpl_mask* badpix_mask = NULL;
01109 char result_name[80];
01110
01111 XSH_ASSURE_NOT_NULL( instr);
01112 XSH_ASSURE_NOT_NULL( rawFrames);
01113 check( size = cpl_frameset_get_size( rawFrames));
01114
01115 XSH_ASSURE_NOT_ILLEGAL( size > 0);
01116
01117 check( dataList = cpl_imagelist_new());
01118 check( errsList = cpl_imagelist_new());
01119
01120
01121 for (i=0;i < size;i++){
01122 check(current = cpl_frameset_get_frame(rawFrames,i));
01123
01124 check(pre = xsh_pre_load(current,instr));
01125
01126 xsh_image_flag_bp(pre->data,pre->qual,instr);
01127 check_msg( cpl_imagelist_set(dataList,cpl_image_duplicate(pre->data),
01128 i),"Cant add Data Image %d to imagelist", i) ;
01129 check_msg( cpl_imagelist_set(errsList,cpl_image_duplicate(pre->errs),
01130 i),"Cant add Data Image %d to imagelist", i) ;
01131
01132
01133
01134 if (i < (size-1)) {
01135 xsh_pre_free(&pre);
01136 }
01137 }
01138
01139 assure (cpl_imagelist_is_uniform (dataList) == 0, CPL_ERROR_ILLEGAL_INPUT,
01140 "Data images are not uniform");
01141 assure (cpl_imagelist_is_uniform (errsList) == 0, CPL_ERROR_ILLEGAL_INPUT,
01142 "Errs images are not uniform");
01143
01144
01145 check(badpix_mask = cpl_mask_duplicate(xsh_pre_get_bpmap(pre)));
01146
01147 xsh_msg ("Nb of Bad Pixels in QUAL: %" CPL_SIZE_FORMAT "",cpl_mask_count(badpix_mask));
01148
01149
01150
01151
01152
01153
01154
01155 xsh_free_image(&pre->data);
01156 if(method_code==0) {
01157 pre->data=xsh_irplib_mkmaster_median(dataList,5.,5,1.e-5);
01158
01159 check( xsh_collapse_errs(pre->errs,errsList, badpix_mask,0));
01160 } else if(method_code==1) {
01161 check(pre->data=xsh_irplib_mkmaster_mean(dataList,5.,5,1.e-5,
01162 stack_par->klow,
01163 stack_par->khigh,
01164 stack_par->niter));
01165
01166 check( xsh_collapse_errs(pre->errs,errsList, badpix_mask,1));
01167 }
01168
01169
01170
01171
01172
01173 check( xsh_pfits_set_datancom( pre->data_header, size));
01174
01175
01176 check ( cpl_propertylist_erase_regexp( pre->data_header, "PRO BIAS *", 0));
01177
01178
01179
01180
01181 sprintf(result_name,"%s.fits",result_tag);
01182
01183 check(medFrame = xsh_pre_save( pre, result_name, result_tag,0));
01184
01185 check(cpl_frame_set_tag(medFrame, result_tag));
01186
01187
01188 cleanup:
01189
01190 if (cpl_error_get_code () != CPL_ERROR_NONE) {
01191 xsh_free_frame(&medFrame);
01192 }
01193 xsh_free_imagelist(&dataList);
01194
01195
01196 xsh_free_mask(&badpix_mask);
01197 xsh_pre_free(&pre);
01198 xsh_free_imagelist(&errsList) ;
01199
01200
01201 return medFrame;
01202
01203 }
01204
01224 cpl_frame *
01225 xsh_compute_qc_on_master_bias (cpl_frameset* raws,
01226 cpl_frame * frame,
01227 xsh_instrument* instr,
01228 cpl_parameterlist* drs_params)
01229 {
01230 xsh_pre *master = NULL;
01231 cpl_frame *masterFrame = NULL;
01232 const char* tag = XSH_GET_TAG_FROM_ARM( XSH_MASTER_BIAS, instr);
01233 char mastername[256];
01234 int binx=0;
01235 int biny=0;
01236
01237 XSH_ASSURE_NOT_NULL(frame);
01238 check(master = xsh_pre_load (frame,instr));
01239
01240 check(xsh_pfits_set_pcatg (master->data_header, tag));
01241
01242 check(binx=xsh_pfits_get_binx(master->data_header));
01243 check(biny=xsh_pfits_get_biny(master->data_header));
01244
01245 if ( drs_params != NULL ) {
01246 check( set_masterbias_qc_structure(master,drs_params));
01247 if(cpl_frameset_get_size(raws) > 1 ) {
01248 check(xsh_compute_ron_mbias(raws,master,drs_params));
01249 check(xsh_compute_fpn_mbias(raws,master,instr,drs_params));
01250 }
01251 }
01252
01253 sprintf(mastername,"MASTER_BIAS_%s.fits",
01254 xsh_instrument_arm_tostring (instr));
01255
01256 xsh_msg ("Create master bias");
01257 check(masterFrame = xsh_pre_save (master, mastername,tag,0 ));
01258 cpl_frame_set_tag (masterFrame, tag);
01259 cpl_frame_set_group(masterFrame,CPL_FRAME_GROUP_CALIB);
01260
01261 cleanup:
01262 xsh_pre_free(&master);
01263 return masterFrame;
01264 }
01265
01266 cpl_frame *
01267 xsh_create_master_flat (cpl_frame *frame, xsh_instrument *instr)
01268 {
01269 xsh_pre *master = NULL;
01270 cpl_frame *masterFrame = NULL;
01271 const char *tag = NULL;
01272 char *name = NULL;
01273 double mean = 0.0;
01274 double median = 0.0;
01275 double stdev = 0.0;
01276
01277
01278 XSH_ASSURE_NOT_NULL( frame);
01279 XSH_ASSURE_NOT_NULL( instr);
01280
01281 check( master = xsh_pre_load( frame, instr));
01282
01283
01284 tag = XSH_GET_TAG_FROM_LAMP( XSH_MASTER_FLAT, instr);
01285 check( xsh_pfits_set_pcatg( master->data_header, tag));
01286
01287 check( xsh_pre_normalize( master));
01288
01289 mean = cpl_image_get_mean( master->data);
01290 median = cpl_image_get_median( master->data);
01291 stdev = cpl_image_get_stdev( master->data);
01292
01293
01294
01295
01296
01297 XSH_NAME_LAMP_MODE_ARM( name, "MASTER_FLAT",".fits",instr);
01298 xsh_msg ("Create master flat %s tag %s", name, tag);
01299
01300 check( masterFrame = xsh_pre_save( master, name, tag,0));
01301 check( cpl_frame_set_tag( masterFrame, tag));
01302 check( cpl_frame_set_group( masterFrame, CPL_FRAME_GROUP_CALIB));
01303
01304 cleanup:
01305 XSH_FREE( name);
01306 xsh_pre_free( &master);
01307 return masterFrame;
01308 }
01309
01310
01311 cpl_frame *
01312 xsh_create_master_dark_bpmap (cpl_frame * mdarkFrame, xsh_instrument* instr)
01313 {
01314
01315
01316
01317
01318
01319 xsh_pre * mdark_pre = NULL ;
01320 cpl_frame* resFrame = NULL;
01321 const char* tag = XSH_GET_TAG_FROM_ARM( XSH_MASTER_BP_MAP_DARK, instr);
01322 char* finalName = NULL;
01323 int i=0, j=0;
01324 int* qual_data = NULL;
01325 int nx,ny;
01326 int nb_flag_pixels = 0;
01327 int error_pixels[32];
01328
01329
01330 XSH_ASSURE_NOT_NULL( mdarkFrame);
01331 XSH_ASSURE_NOT_NULL( instr);
01332
01333
01334 check( mdark_pre = xsh_pre_load( mdarkFrame, instr));
01335
01336 if ( xsh_instrument_get_arm(instr) == XSH_ARM_NIR ) {
01337 check(finalName=cpl_sprintf("%s_%s.fits",XSH_MASTER_BP_MAP_DARK,
01338 xsh_instrument_arm_tostring(instr)));
01339
01340 } else {
01341
01342
01343
01344
01345
01346
01347 check(finalName=cpl_sprintf("%s_%s.fits",XSH_MASTER_BP_MAP_DARK,
01348 xsh_instrument_arm_tostring(instr)));
01349
01350 }
01351
01352 check(resFrame=xsh_frame_product(finalName,tag,
01353 CPL_FRAME_TYPE_IMAGE,
01354 CPL_FRAME_GROUP_PRODUCT,
01355 CPL_FRAME_LEVEL_FINAL));
01356
01357
01358 check( qual_data = cpl_image_get_data_int( mdark_pre->qual));
01359 check( nx = cpl_image_get_size_x( mdark_pre->qual));
01360 check( ny = cpl_image_get_size_y( mdark_pre->qual));
01361
01362
01363 for(j=0; j<32; j++){
01364 error_pixels[j] = 0;
01365 }
01366
01367 for(i=0; i<nx*ny; i++){
01368 if( qual_data[i] > 0){
01369 nb_flag_pixels++;
01370 for( j=0;j<32;j++){
01371 int cmp = pow(2,j);
01372 if ( qual_data[i] & cmp){
01373 error_pixels[j]++;
01374 }
01375 }
01376 }
01377 }
01378
01379
01380
01381 check( xsh_pfits_set_qc_bp_map_ntotal(mdark_pre->qual_header,nb_flag_pixels));
01382
01383 for(i=1; i< 33; i++){
01384 check( xsh_pfits_set_qc_multi( mdark_pre->qual_header,
01385 (void *)&(error_pixels[i-1]), XSH_QC_BP_MAP_NFLAGi, instr, i));
01386 }
01387
01388
01389 check_msg (cpl_image_save (mdark_pre->qual, finalName, XSH_PRE_DATA_BPP,
01390 mdark_pre->qual_header, CPL_IO_DEFAULT),
01391 "Could not save bpmap to %s extension", finalName);
01392
01393
01394 cleanup:
01395 if (cpl_error_get_code() != CPL_ERROR_NONE){
01396 xsh_free_frame(&resFrame);
01397 }
01398 XSH_FREE(finalName);
01399 xsh_pre_free( &mdark_pre);
01400 return resFrame;
01401 }
01402
01403 static cpl_error_code
01404 xsh_compute_ron_mbias(cpl_frameset* raws,
01405 xsh_pre* master,
01406 cpl_parameterlist* parameters)
01407 {
01408
01409
01410 int random_sizex=-1;
01411 int random_nsamples=-1;
01412 double ron=0;
01413 double ron_err=0;
01414
01415
01416 int ref_llx=-1;
01417 int ref_lly=-1;
01418 int ref_urx=-1;
01419 int ref_ury=-1;
01420
01421
01422 int ref2_llx=-1;
01423 int ref2_lly=-1;
01424 int ref2_urx=-1;
01425 int ref2_ury=-1;
01426
01427
01428 cpl_parameter* p=NULL;
01429
01430 const cpl_frame * fr = NULL;
01431
01432 cpl_propertylist * plist = NULL;
01433
01434 int naxis1 = 0;
01435 int naxis2 = 0;
01436
01437
01438
01439
01440
01441 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.random_sizex"));
01442 check(random_sizex = cpl_parameter_get_int(p));
01443
01444 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.random_nsamples"));
01445 check(random_nsamples = cpl_parameter_get_int(p));
01446
01447 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref1_llx"));
01448 check(ref_llx = cpl_parameter_get_int(p));
01449
01450 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref1_lly"));
01451 check(ref_lly = cpl_parameter_get_int(p));
01452
01453 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref1_urx"));
01454 check(ref_urx = cpl_parameter_get_int(p));
01455
01456 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref1_urx"));
01457 check(ref_ury = cpl_parameter_get_int(p));
01458
01459 check(fr=cpl_frameset_get_first_const(raws));
01460
01461 check(plist=cpl_propertylist_load(cpl_frame_get_filename(fr),0));
01462 check(naxis1 = cpl_propertylist_get_int(plist, "NAXIS1"));
01463 check(naxis2 = cpl_propertylist_get_int(plist, "NAXIS2"));
01464
01465
01466 cpl_propertylist_delete(plist);
01467
01468
01469 if(ref_llx == -1) ref_llx = naxis1 / 8;
01470 if(ref_lly == -1) ref_lly = naxis2 / 8;
01471 if(ref_urx == -1) ref_urx = naxis1 * 7 / 8;
01472 if(ref_ury == -1) ref_ury = naxis2 * 7 / 8;
01473
01474 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_llx>0,"Must be ref_llx > 0");
01475 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_lly>0,"Must be ref_lly > 0");
01476 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_urx>0,"Must be ref_urx > 0");
01477 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_ury>0,"Must be ref_ury > 0");
01478
01479 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_llx<naxis1,"Must be ref_llx < frame X size");
01480 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_lly<naxis2,"Must be ref_lly < frame Y size");
01481 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_urx<=naxis1,"Must be ref_urx > frame X size");
01482 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_ury<=naxis2,"Must be ref_ury > frame Y size");
01483
01484 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_urx>ref_llx,"Must be ref_urx > ref_llx");
01485 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_ury>ref_lly,"Must be ref_ury > ref_lly");
01486
01487 XSH_ASSURE_NOT_ILLEGAL_MSG(random_nsamples>0,"Must be random_nsamples > 0");
01488 XSH_ASSURE_NOT_ILLEGAL_MSG(random_nsamples<100000000,"Must be random_nsamples < 100000000");
01489 XSH_ASSURE_NOT_ILLEGAL_MSG(random_sizex>0,"Must be random_sizex > 0");
01490 XSH_ASSURE_NOT_ILLEGAL_MSG(random_sizex<naxis1,"Must be random_sizex < frame X size");
01491 XSH_ASSURE_NOT_ILLEGAL_MSG(random_sizex<naxis2,"Must be random_sizex < frame Y size");
01492
01493 check(xsh_compute_ron(raws,ref_llx,ref_lly,ref_urx,ref_ury,random_nsamples,random_sizex,1,&ron,&ron_err));
01494 xsh_pfits_set_qc_ron1(master->data_header,ron);
01495 xsh_pfits_set_qc_ron1_err(master->data_header,ron_err);
01496
01497 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref2_llx"));
01498 check(ref2_llx = cpl_parameter_get_int(p));
01499
01500 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref2_lly"));
01501 check(ref2_lly = cpl_parameter_get_int(p));
01502
01503 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref2_urx"));
01504 check(ref2_urx = cpl_parameter_get_int(p));
01505
01506 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref2_urx"));
01507 check(ref2_ury = cpl_parameter_get_int(p));
01508
01509
01510 //checking for defaults
01511 if(ref2_llx == -1) ref2_llx = naxis1 / 8;
01512 if(ref2_lly == -1) ref2_lly = naxis2 / 8;
01513 if(ref2_urx == -1) ref2_urx = naxis1 * 7 / 8;
01514 if(ref2_ury == -1) ref2_ury = naxis2 * 7 / 8;
01515
01516
01517 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_llx>0,"Must be ref2_llx > 0");
01518 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_lly>0,"Must be ref2_lly > 0");
01519 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_urx>0,"Must be ref2_urx > 0");
01520 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_ury>0,"Must be ref2_ury > 0");
01521
01522 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_llx<naxis1,"Must be ref2_llx < frame X size");
01523 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_lly<naxis2,"Must be ref2_lly < frame Y size");
01524
01525
01526 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_urx<=naxis1,"Must be ref2_urx <= frame X size");
01527 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_ury<=naxis2,"Must be ref2_ury <= frame Y size");
01528
01529 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_urx>ref2_llx,"Must be ref2_urx > ref2_llx");
01530 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_ury>ref2_lly,"Must be ref2_ury > ref2_lly");
01531
01532 if(
01533 (ref2_llx != ref_llx) ||
01534 (ref2_lly != ref_lly) ||
01535 (ref2_urx != ref_urx) ||
01536 (ref2_ury != ref_ury)
01537 ) {
01538
01539 check(xsh_compute_ron(raws,ref2_llx,ref2_lly,ref2_urx,ref2_ury,random_nsamples,random_sizex,2,&ron,&ron_err));
01540
01541 xsh_pfits_set_qc_ron2(master->data_header,ron);
01542 xsh_pfits_set_qc_ron2_err(master->data_header,ron_err);
01543
01544 }
01545
01546
01547 cleanup:
01548
01549 return cpl_error_get_code();
01550
01551 }
01552
01553
01554 static cpl_error_code
01555 xsh_compute_fpn_mbias(cpl_frameset* raws,
01556 xsh_pre* master,
01557 xsh_instrument* instrument,
01558 cpl_parameterlist* parameters)
01559 {
01560
01561 int nraws=0;
01562 double ron=0;
01563 double fpn=0;
01564 cpl_frame* frm1=NULL;
01565 cpl_frame* frm2=NULL;
01566 cpl_image* ima1=NULL;
01567 cpl_image* ima2=NULL;
01568 cpl_image* ima=NULL;
01569
01570
01571 if ( xsh_instrument_get_arm(instrument) != XSH_ARM_NIR){
01572 nraws=cpl_frameset_get_size(raws);
01573 if(nraws > 1) {
01574 frm1=cpl_frameset_get_first(raws);
01575 frm2=cpl_frameset_get_next(raws);
01576 ima1=cpl_image_load(cpl_frame_get_filename(frm1),CPL_TYPE_FLOAT,0,0);
01577 ima2=cpl_image_load(cpl_frame_get_filename(frm2),CPL_TYPE_FLOAT,0,0);
01578
01579 ima = cpl_image_duplicate(ima1);
01580 check(ron = xsh_image_get_stdev_clean(ima, NULL) / sqrt(2.0));
01581
01582 check(fpn = xsh_fixed_pattern_noise_bias(ima1,ima2,ron));
01583
01584 xsh_pfits_set_qc_ron_master(master->data_header,ron);
01585 xsh_pfits_set_qc_fpn_master(master->data_header,fpn);
01586
01587 xsh_free_image(&ima);
01588 xsh_free_image(&ima1);
01589 xsh_free_image(&ima2);
01590 }
01591 } else {
01592 check(xsh_mbias_get_fpn(master->data,parameters,&fpn));
01593 /* xsh_msg("Fixed Pattern Noise=%f",fpn); */
01594
01595 }
01596
01597 cleanup:
01598 xsh_free_image(&ima);
01599 xsh_free_image(&ima1);
01600 xsh_free_image(&ima2);
01601 return cpl_error_get_code();
01602
01603 }
01604
01605
01606
01607 static cpl_error_code
01608 xsh_mbias_get_fpn(const cpl_image* ima,
01609 cpl_parameterlist* parameters,
01610 double* fpn)
01611 {
01612
01613 int fpn_llx=0;
01614 int fpn_lly=0;
01615 int fpn_urx=0;
01616 int fpn_ury=0;
01617 int fpn_hsize=0;
01618 int fpn_nsamp=0;
01619 cpl_parameter* p=NULL;
01620
01621 cpl_size zone[4];
01622 int sx=0;
01623 int sy=0;
01624
01625 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_llx"));
01626 check(fpn_llx = cpl_parameter_get_int(p));
01627
01628 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_lly"));
01629 check(fpn_lly = cpl_parameter_get_int(p));
01630
01631 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_urx"));
01632 check(fpn_urx = cpl_parameter_get_int(p));
01633
01634 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_ury"));
01635 check(fpn_ury = cpl_parameter_get_int(p));
01636
01637 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_hsize"));
01638 check(fpn_hsize = cpl_parameter_get_int(p));
01639
01640 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_nsamples"));
01641 check(fpn_nsamp = cpl_parameter_get_int(p));
01642
01643 sx=cpl_image_get_size_x(ima);
01644 sy=cpl_image_get_size_y(ima);
01645
01646 fpn_llx=(fpn_llx>0) ? fpn_llx: 0;
01647 fpn_lly=(fpn_lly>0) ? fpn_lly: 0;
01648
01649 fpn_urx=(fpn_urx<sx) ? fpn_urx: sx;
01650 fpn_ury=(fpn_ury<sy) ? fpn_ury: sy;
01651
01652
01653 zone[0]=fpn_llx;
01654 zone[1]=fpn_urx;
01655 zone[2]=fpn_lly;
01656 zone[3]=fpn_ury;
01657
01658
01659 check_msg(cpl_flux_get_noise_window(ima,zone,fpn_hsize,fpn_nsamp,fpn,NULL),
01660 "Error computing noise in a window");
01661
01662 cleanup:
01663 return cpl_error_get_code();
01664
01665 }
01666