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_utils_imagelist.h>
00051 #include <xsh_pfits.h>
00052 #include <xsh_pfits_qc.h>
00053 #include <xsh_error.h>
00054 #include <xsh_msg.h>
00055 #include <xsh_badpixelmap.h>
00056 #include <xsh_paf_save.h>
00057 #include <xsh_utils_image.h>
00058 #include <xsh_detmon.h>
00059 #include <xsh_irplib_utils.h>
00060 #include <xsh_utils_image.h>
00061 #include <xsh_irplib_mkmaster.h>
00062 #include <xsh_data_order.h>
00063 #include <math.h>
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073 #define RECIPE_ID "xsh_mbias"
00074 #define HIST_FACT 2.354820045
00075
00076
00077
00078
00079 static cpl_error_code
00080 xsh_compute_ron_mbias(cpl_frameset* raws,
00081 xsh_pre* master,
00082 cpl_parameterlist* parameters);
00083
00084
00085 static cpl_error_code
00086 xsh_compute_fpn_mbias(cpl_frameset* raws,
00087 xsh_pre* master,
00088 xsh_instrument* instrument,
00089 cpl_parameterlist* parameters);
00090
00091 static cpl_error_code
00092 xsh_mbias_get_fpn(const cpl_image* ima,
00093 cpl_parameterlist* parameters,
00094 double* fpn);
00095
00096
00097
00098
00099
00100
00101
00102 static double
00103 xsh_mdark_get_contam(xsh_pre * pre,cpl_parameterlist* params,
00104 xsh_instrument* instr)
00105 {
00106
00107 double contam=0;
00108
00109 int llx_on=0;
00110 int lly_on=0;
00111 int urx_on=0;
00112 int ury_on=0;
00113
00114 int llx_off=0;
00115 int lly_off=0;
00116 int urx_off=0;
00117 int ury_off=0;
00118 if(xsh_parameters_find(params,"xsh_mdark","contam_on_llx")!=NULL){
00119 check(llx_on=xsh_parameters_get_int(params,"xsh_mdark","contam_on_llx"));
00120 check(lly_on=xsh_parameters_get_int(params,"xsh_mdark","contam_on_lly"));
00121 check(urx_on=xsh_parameters_get_int(params,"xsh_mdark","contam_on_urx"));
00122 check(ury_on=xsh_parameters_get_int(params,"xsh_mdark","contam_on_ury"));
00123
00124
00125 check(llx_off=xsh_parameters_get_int(params,"xsh_mdark","contam_off_llx"));
00126 check(lly_off=xsh_parameters_get_int(params,"xsh_mdark","contam_off_lly"));
00127 check(urx_off=xsh_parameters_get_int(params,"xsh_mdark","contam_off_urx"));
00128 check(ury_off=xsh_parameters_get_int(params,"xsh_mdark","contam_off_ury"));
00129
00130 } else {
00131 if(xsh_instrument_get_arm(instr) == XSH_ARM_UVB) {
00132 llx_on =801; lly_on =1058;urx_on =810; ury_on =1067;
00133 llx_off=855; lly_off=1066;urx_off=864; ury_off=1075;
00134 } else if(xsh_instrument_get_arm(instr) == XSH_ARM_VIS) {
00135 llx_on =1672; lly_on =2672;urx_on =1681;ury_on =2681;
00136 llx_off=1926; lly_off=2941;urx_off=1935;ury_off=2950;
00137 } else if(xsh_instrument_get_arm(instr) == XSH_ARM_NIR) {
00138 llx_on =991; lly_on =1083;urx_on =1015;ury_on =1108;
00139 llx_off=1029;lly_off=1075;urx_off=1053;ury_off=1110;
00140 }
00141 }
00142
00143 llx_on=llx_on/pre->binx;
00144 lly_on=lly_on/pre->biny;
00145 urx_on=urx_on/pre->binx;
00146 ury_on=ury_on/pre->biny;
00147
00148 llx_off=llx_off/pre->binx;
00149 lly_off=lly_off/pre->biny;
00150 urx_off=urx_off/pre->binx;
00151 ury_off=ury_off/pre->biny;
00152
00153 check(contam=
00154 cpl_image_get_median_window(pre->data,llx_on,lly_on,urx_on,ury_on)-
00155 cpl_image_get_median_window(pre->data,llx_off,lly_off,urx_off,ury_off));
00156
00157
00158 cleanup:
00159
00160
00161 return contam;
00162
00163
00164 }
00165
00166
00171 cpl_error_code
00172 xsh_mdark_get_median_stdev(xsh_pre* preFrame,cpl_parameterlist* parameters,
00173 cpl_frame* crh_frm, cpl_frame* bpm_frm)
00174 {
00175
00176 int sx=0;
00177 int sy=0;
00178 int ref_llx=-1;
00179 int ref_lly=-1;
00180 int ref_urx=-1;
00181 int ref_ury=-1;
00182 xsh_pre* dup_frm=NULL;
00183 const char* crh_name=NULL;
00184 const char* bpm_name=NULL;
00185 cpl_image* crh_ima=NULL;
00186 cpl_image* bpm_ima=NULL;
00187 int* pcrh=NULL;
00188 int* pbpm=NULL;
00189 int* pqua=NULL;
00190 int i=0;
00191 bool bpm_found=false;
00192 bool crh_found=false;
00193 double avg_value = 0.0;
00194 double median_value = 0.0;
00195 double stdev = 0.0;
00196
00197 check(ref_llx=xsh_parameters_get_int(parameters,"xsh_mdark","ref1_llx"));
00198 check(ref_lly=xsh_parameters_get_int(parameters,"xsh_mdark","ref1_lly"));
00199 check(ref_urx=xsh_parameters_get_int(parameters,"xsh_mdark","ref1_urx"));
00200 check(ref_ury=xsh_parameters_get_int(parameters,"xsh_mdark","ref1_ury"));
00201 sx=cpl_image_get_size_x(preFrame->data);
00202 sy=cpl_image_get_size_y(preFrame->data);
00203
00204
00205
00206 if(ref_llx == -1) ref_llx=1;
00207 if(ref_lly == -1) ref_lly=1;
00208 if(ref_urx == -1) ref_urx=sx;
00209 if(ref_ury == -1) ref_ury=sy;
00210
00211 ref_llx = (ref_llx>0) ? ref_llx : 1;
00212 ref_lly = (ref_lly>0) ? ref_lly : 1;
00213 ref_urx = (ref_urx<sx) ? ref_urx : sx;
00214 ref_ury = (ref_ury<sy) ? ref_ury : sy;
00215
00216
00217
00218
00219
00220
00221
00222
00223 dup_frm=xsh_pre_duplicate(preFrame);
00224
00225 if(crh_frm!=NULL) {
00226 check(crh_name=cpl_frame_get_filename(crh_frm));
00227 check(crh_ima=cpl_image_load(crh_name,XSH_PRE_QUAL_TYPE,0,0));
00228 check(pcrh=cpl_image_get_data_int(crh_ima));
00229 crh_found=true;
00230 }
00231
00232 if(bpm_frm != NULL) {
00233 check(bpm_name=cpl_frame_get_filename(bpm_frm));
00234 check(bpm_ima=cpl_image_load(bpm_name,XSH_PRE_QUAL_TYPE,0,0));
00235 check(pbpm=cpl_image_get_data_int(bpm_ima));
00236 bpm_found=true;
00237 }
00238
00239 if (bpm_found || crh_found) {
00240 int sx_sy=0;
00241 check(pqua=cpl_image_get_data_int( preFrame->qual));
00242 sx = preFrame->nx;
00243 sy = preFrame->ny;
00244 sx_sy=sx*sy;
00245 if (bpm_found && crh_found) {
00246 for (i = 0; i < sx_sy; i++) {
00247 if (pcrh[i] != 0 || pbpm[i] != 0) {
00248 pqua[i] = XSH_GOOD_PIXEL_LEVEL;
00249 }
00250 }
00251 } else if (bpm_found) {
00252 for (i = 0; i < sx_sy; i++) {
00253 if (pbpm[i] != 0) {
00254 pqua[i] = XSH_GOOD_PIXEL_LEVEL;
00255 }
00256 }
00257 } else if (crh_found) {
00258 for (i = 0; i < sx_sy; i++) {
00259 if (pcrh[i] != 0) {
00260 pqua[i] = XSH_GOOD_PIXEL_LEVEL;
00261 }
00262 }
00263 }
00264 }
00265 xsh_free_image(&bpm_ima);
00266 xsh_free_image(&crh_ima);
00267 xsh_pre_free(&dup_frm);
00268
00269 check( xsh_pre_median_mean_stdev_window( preFrame,
00270 &avg_value, &median_value,&stdev,
00271 ref_llx,ref_lly,ref_urx,ref_ury) ) ;
00272
00273 xsh_pfits_set_qc_mdarkavg( preFrame->data_header,avg_value) ;
00274 xsh_pfits_set_qc_mdarkmed( preFrame->data_header,median_value) ;
00275 xsh_pfits_set_qc_mdarkrms( preFrame->data_header,stdev) ;
00276
00277 cleanup:
00278 xsh_free_image(&bpm_ima);
00279 xsh_free_image(&crh_ima);
00280 xsh_pre_free(&dup_frm);
00281 return cpl_error_get_code();
00282 }
00283
00284 static cpl_error_code
00285 xsh_mdark_measure_fpn(xsh_pre* preFrame,cpl_parameterlist* parameters,xsh_instrument* instrument)
00286 {
00287
00288
00289 cpl_size zone_fpn[4];
00290 int fpn_llx=-1;
00291 int fpn_lly=-1;
00292 int fpn_urx=-1;
00293 int fpn_ury=-1;
00294 int fpn_nsamp=100;
00295 int fpn_hsize=4;
00296 double exptime=preFrame->exptime;
00297 double qc_fpn_val=0;
00298 double qc_fpn_err=0;
00299 int sx=0;
00300 int sy=0;
00301
00302 check(fpn_llx=xsh_parameters_get_int(parameters,"xsh_mdark","fpn_llx"));
00303 check(fpn_lly=xsh_parameters_get_int(parameters,"xsh_mdark","fpn_lly"));
00304 check(fpn_urx=xsh_parameters_get_int(parameters,"xsh_mdark","fpn_urx"));
00305 check(fpn_ury=xsh_parameters_get_int(parameters,"xsh_mdark","fpn_ury"));
00306 sx=cpl_image_get_size_x(preFrame->data);
00307 sy=cpl_image_get_size_y(preFrame->data);
00308
00309
00310
00311 if(fpn_llx == -1) fpn_llx=1;
00312 if(fpn_lly == -1) fpn_lly=1;
00313 if(fpn_urx == -1) fpn_urx=sx;
00314 if(fpn_ury == -1) fpn_ury=sy;
00315
00316 fpn_llx = (fpn_llx>0) ? fpn_llx : 1;
00317 fpn_lly = (fpn_lly>0) ? fpn_lly : 1;
00318 fpn_urx = (fpn_urx<sx) ? fpn_urx : sx;
00319 fpn_ury = (fpn_ury<sy) ? fpn_ury : sy;
00320
00321 assure(fpn_urx>fpn_llx,CPL_ERROR_ILLEGAL_INPUT,
00322 "Must be fpn_urx (%d) > fpn_llx (%d)",
00323 fpn_urx,fpn_llx);
00324
00325 assure(fpn_ury>fpn_lly,CPL_ERROR_ILLEGAL_INPUT,
00326 "Must be fpn_ury (%d) > fpn_lly (%d)",
00327 fpn_ury,fpn_lly);
00328
00329 zone_fpn[0]=fpn_llx;
00330 zone_fpn[1]=fpn_urx;
00331 zone_fpn[2]=fpn_lly;
00332 zone_fpn[3]=fpn_ury;
00333
00334 check_msg(cpl_flux_get_noise_window(preFrame->data, zone_fpn, fpn_hsize,
00335 fpn_nsamp, &qc_fpn_val, &qc_fpn_err),
00336 "Error computing noise in a window");
00337
00338 if ( instrument->arm != XSH_ARM_NIR ) {
00339
00340 xsh_pfits_set_qc_norm_fpn(preFrame->data_header,qc_fpn_val);
00341 xsh_pfits_set_qc_norm_fpn_err(preFrame->data_header,qc_fpn_err);
00342
00343
00344 qc_fpn_val *= exptime;
00345 qc_fpn_err *= exptime;
00346
00347 xsh_pfits_set_qc_fpn( preFrame->data_header,qc_fpn_val);
00348 xsh_pfits_set_qc_fpn_err(preFrame->data_header,qc_fpn_err);
00349
00350 } else {
00351 double median=0;
00352 median=cpl_image_get_median_window(preFrame->data,fpn_llx,fpn_lly,fpn_urx,fpn_ury);
00353
00354 xsh_pfits_set_qc_fpn( preFrame->data_header,qc_fpn_val);
00355 xsh_pfits_set_qc_fpn_err(preFrame->data_header,qc_fpn_err);
00356
00357
00358 qc_fpn_val /= median;
00359 qc_fpn_err /= median;
00360
00361 xsh_pfits_set_qc_norm_fpn(preFrame->data_header,qc_fpn_val);
00362 xsh_pfits_set_qc_norm_fpn_err(preFrame->data_header,qc_fpn_err);
00363 }
00364
00365
00366 cleanup:
00367 return cpl_error_get_code();
00368 }
00369
00370
00371
00372 cpl_error_code
00373 xsh_mdark_measure_ron(xsh_pre* preFrame,cpl_parameterlist* parameters)
00374 {
00375
00376 int ron_llx=-1;
00377 int ron_lly=-1;
00378 int ron_urx=-1;
00379 int ron_ury=-1;
00380
00381
00382 int sx=0;
00383 int sy=0;
00384
00385 check(ron_llx=xsh_parameters_get_int(parameters,"xsh_mdark","ron_llx"));
00386 check(ron_lly=xsh_parameters_get_int(parameters,"xsh_mdark","ron_lly"));
00387 check(ron_urx=xsh_parameters_get_int(parameters,"xsh_mdark","ron_urx"));
00388 check(ron_ury=xsh_parameters_get_int(parameters,"xsh_mdark","ron_ury"));
00389
00390
00391 sx=cpl_image_get_size_x(preFrame->data);
00392 sy=cpl_image_get_size_y(preFrame->data);
00393
00394
00395 if(ron_llx == -1) ron_llx=1;
00396 if(ron_lly == -1) ron_lly=1;
00397 if(ron_urx == -1) ron_urx=sx;
00398 if(ron_ury == -1) ron_ury=sy;
00399
00400 ron_llx = (ron_llx>0) ? ron_llx : 1;
00401 ron_lly = (ron_lly>0) ? ron_lly : 1;
00402 ron_urx = (ron_urx<sx) ? ron_urx : sx;
00403 ron_ury = (ron_ury<sy) ? ron_ury : sy;
00404
00405 cleanup:
00406 return cpl_error_get_code();
00407 }
00408
00419 static void
00420 set_masterdark_qc (xsh_pre * preFrame,
00421 xsh_instrument * instrument,
00422 cpl_parameterlist* parameters,
00423 cpl_frame* crh_frm, cpl_frame* bpm_frm)
00424 {
00425 int nx =0, ny = 0;
00426
00427
00428 nx = xsh_pre_get_nx (preFrame);
00429 assure (nx != 0, cpl_error_get_code (), "Cant get X size");
00430 ny = xsh_pre_get_ny (preFrame);
00431 assure (ny != 0, cpl_error_get_code (), "Cant get Y size");
00432
00433 check(xsh_mdark_get_median_stdev(preFrame,parameters,crh_frm,bpm_frm));
00434 check(xsh_mdark_measure_fpn(preFrame,parameters,instrument));
00435
00436 {
00437 double contam=0;
00438 check(contam=xsh_mdark_get_contam(preFrame,parameters,instrument));
00439 check(xsh_pfits_set_qc_contamination( preFrame->data_header,contam)) ;
00440 }
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455 cleanup:
00456
00457 return;
00458 }
00459
00460
00461 static cpl_error_code
00462 xsh_mdark_get_fpn(cpl_image* ima,cpl_parameterlist* params,cpl_propertylist* qc_log,const double exptime)
00463 {
00464
00465 int fpn_llx=0;
00466 int fpn_lly=0;
00467 int fpn_urx=0;
00468 int fpn_ury=0;
00469 cpl_size fpn_hsize=0;
00470 cpl_size fpn_nsamp=0;
00471 int sx=0;
00472 int sy=0;
00473 cpl_size zone[4];
00474 double qc_fpn_val=0;
00475 double qc_fpn_err=0;
00476
00477
00478 XSH_ASSURE_NOT_NULL_MSG(ima, "Null input ima");
00479 XSH_ASSURE_NOT_NULL_MSG(params, "Null input parameters");
00480 XSH_ASSURE_NOT_NULL_MSG(qc_log, "Null input QC propertylist");
00481
00482 sx=cpl_image_get_size_x(ima);
00483 sy=cpl_image_get_size_y(ima);
00484
00485
00486 check(fpn_llx=xsh_parameters_get_int(params,"xsh_mdark","fpn_llx"));
00487 check(fpn_lly=xsh_parameters_get_int(params,"xsh_mdark","fpn_lly"));
00488 check(fpn_urx=xsh_parameters_get_int(params,"xsh_mdark","fpn_urx"));
00489 check(fpn_ury=xsh_parameters_get_int(params,"xsh_mdark","fpn_ury"));
00490 check(fpn_hsize=xsh_parameters_get_int(params,"xsh_mdark","fpn_hsize"));
00491 check(fpn_nsamp=xsh_parameters_get_int(params,"xsh_mdark","fpn_nsamples"));
00492
00493
00494
00495
00496 if(fpn_llx == -1) fpn_llx=1;
00497 if(fpn_lly == -1) fpn_lly=1;
00498 if(fpn_urx == -1) fpn_urx=sx;
00499 if(fpn_ury == -1) fpn_ury=sy;
00500
00501 fpn_llx = (fpn_llx>0) ? fpn_llx : 1;
00502 fpn_lly = (fpn_lly>0) ? fpn_lly : 1;
00503 fpn_urx = (fpn_urx<sx) ? fpn_urx : sx;
00504 fpn_ury = (fpn_ury<sy) ? fpn_ury : sy;
00505
00506 assure(fpn_urx>fpn_llx,CPL_ERROR_ILLEGAL_INPUT,
00507 "Must be fpn_urx (%d) > fpn_llx (%d)",
00508 fpn_urx,fpn_llx);
00509
00510 assure(fpn_ury>fpn_lly,CPL_ERROR_ILLEGAL_INPUT,
00511 "Must be fpn_ury (%d) > fpn_lly (%d)",
00512 fpn_ury,fpn_lly);
00513
00514
00515 zone[0]=fpn_llx;
00516 zone[1]=fpn_urx;
00517 zone[2]=fpn_lly;
00518 zone[3]=fpn_ury;
00519
00520 check_msg(cpl_flux_get_noise_window(ima, zone, fpn_hsize,fpn_nsamp,
00521 &qc_fpn_val, &qc_fpn_err),
00522 "Error computing noise in a window");
00523
00524
00525 xsh_pfits_set_qc_fpn(qc_log,qc_fpn_val);
00526 xsh_pfits_set_qc_fpn_err(qc_log,qc_fpn_err) ;
00527
00528
00529
00530
00531 qc_fpn_val /= exptime;
00532 qc_fpn_err /= exptime;
00533
00534 xsh_pfits_set_qc_norm_fpn(qc_log,qc_fpn_val) ;
00535 xsh_pfits_set_qc_norm_fpn_err(qc_log,qc_fpn_err) ;
00536
00537
00538 cleanup:
00539
00540 return cpl_error_get_code();
00541
00542 }
00543
00544
00545 static cpl_error_code
00546 xsh_mdark_compute_fpn(cpl_frameset* raws,cpl_parameterlist* params,
00547 cpl_propertylist* qclog,xsh_instrument* instrument)
00548 {
00549
00550 int nraws=0;
00551 cpl_frame* frm=NULL;
00552 xsh_pre* pre1=NULL;
00553 xsh_pre* pre2=NULL;
00554 double exptime=0;
00555
00556 XSH_ASSURE_NOT_NULL_MSG(raws, "Null input raw frames set");
00557 XSH_ASSURE_NOT_NULL_MSG(params, "Null input parameter list");
00558 XSH_ASSURE_NOT_NULL_MSG(qclog, "Null input qc property list");
00559
00560 nraws=cpl_frameset_get_size(raws);
00561
00562 XSH_ASSURE_NOT_ILLEGAL_MSG(nraws >1,"Min 2 raw darks needed to compute FPN");
00563
00564 frm=cpl_frameset_get_frame(raws,0);
00565 pre1=xsh_pre_load(frm,instrument);
00566
00567 frm=cpl_frameset_get_frame(raws,1);
00568 pre2=xsh_pre_load(frm,instrument);
00569
00570 xsh_pre_subtract(pre1,pre2);
00571 exptime=xsh_pfits_get_exptime(pre1->data_header);
00572 check(xsh_mdark_get_fpn(pre1->data,params,qclog,exptime));
00573
00574 cleanup:
00575 xsh_pre_free(&pre1);
00576 xsh_pre_free(&pre2);
00577
00578 return cpl_error_get_code();
00579
00580 }
00581
00590 cpl_frame *
00591 xsh_create_master_dark2(cpl_frameset * raws,
00592 xsh_stack_param* stack_param,
00593 cpl_parameterlist* params,
00594 cpl_propertylist* qc_log,
00595 xsh_instrument* instr)
00596 {
00597
00598 double mean_exptime=0;
00599 cpl_imagelist* raw_data=NULL;
00600 cpl_imagelist* raw_errs=NULL;
00601 cpl_imagelist* iml_errs=NULL;
00602 cpl_imagelist* iml_data=NULL;
00603 cpl_image* qual_comb=NULL;
00604
00605 cpl_propertylist** raw_headers=NULL;
00606 cpl_frame* mdark=NULL;
00607 cpl_image* mbias=NULL;
00608 xsh_pre* pre=NULL;
00609
00610 cpl_frame* frm=NULL;
00611 char mdark_name[256];
00612 char mdark_tag[256];
00613 const double kappa=5.;
00614 const int nclip=5;
00615 const double tolerance=1.e-5;
00616
00617 int sz=0;
00618 int i=0;
00619 int mode_and=0;
00620
00621
00622 sz=cpl_frameset_get_size(raws);
00623 raw_data=cpl_imagelist_new();
00624 raw_errs=cpl_imagelist_new();
00625 raw_headers=cpl_calloc(sz,sizeof(cpl_propertylist*));
00626
00627 for(i=0;i<sz;i++){
00628 check(frm=cpl_frameset_get_frame(raws,i));
00629 pre=xsh_pre_load(frm,instr);
00630
00631 check(xsh_image_flag_bp(pre->data,pre->qual,instr));
00632 check(xsh_image_flag_bp(pre->errs,pre->qual,instr));
00633 cpl_imagelist_set(raw_data,cpl_image_duplicate(pre->data),i);
00634 cpl_imagelist_set(raw_errs,cpl_image_duplicate(pre->errs),i);
00635 raw_headers[i]=cpl_propertylist_duplicate(pre->data_header);
00636 if(i==0) {
00637 qual_comb=cpl_image_duplicate(pre->qual);
00638 } else {
00639 xsh_badpixelmap_image_coadd(&qual_comb,pre->qual,mode_and);
00640 }
00641
00642
00643 if (i < (sz-1)) {
00644 xsh_pre_free(&pre);
00645 }
00646 }
00647
00648 iml_data=xsh_irplib_mkmaster_dark_fill_imagelist(raw_data,raw_headers,mbias,&mean_exptime);
00649
00650 iml_errs=xsh_irplib_mkmaster_dark_fill_imagelist(raw_errs,raw_headers,mbias,&mean_exptime);
00651
00652
00653
00654 xsh_free_image(&pre->data);
00655 xsh_free_image(&pre->qual);
00656
00657
00658 pre->qual=cpl_image_duplicate(qual_comb);
00659
00660
00661 if (strcmp(stack_param->stack_method, "median") == 0) {
00662 xsh_msg("Calculating stack median");
00663
00664 pre->data=xsh_irplib_mkmaster_median(iml_data,kappa,nclip,tolerance);
00665 check( xsh_collapse_errs(pre->errs,iml_errs,0));
00666
00667 } else {
00668 xsh_msg("Calculating stack mean");
00669 pre->data=xsh_irplib_mkmaster_mean(iml_data,kappa,nclip,tolerance,stack_param->klow,stack_param->khigh);
00670
00671 check( xsh_collapse_errs(pre->errs,iml_errs,1));
00672
00673 }
00674
00675
00676
00677
00678 if ( instr->arm != XSH_ARM_NIR ) {
00679
00680 check_msg (cpl_image_divide_scalar (pre->data, mean_exptime),
00681 "Cant divide median image by exptime %lf", mean_exptime);
00682 check_msg (cpl_image_divide_scalar (pre->errs, mean_exptime),
00683 "Cant divide median image by exptime %lf", mean_exptime);
00684
00685
00686 xsh_msg_dbg_high ("Set EXPTIME = 1.");
00687 check(xsh_pfits_set_exptime (pre->data_header, (double) 1.));
00688 check(xsh_pfits_set_exptime (pre->errs_header, (double) 1.));
00689
00690 } else {
00691
00692 check(xsh_pfits_set_exptime(pre->data_header, mean_exptime ));
00693 check(xsh_pfits_set_exptime(pre->errs_header, mean_exptime ));
00694
00695 }
00696 if(qc_log != NULL ) {
00697 if(sz>1) {
00698 xsh_mdark_compute_fpn(raws,params,qc_log,instr);
00699 }
00700 }
00701 if(qc_log != NULL ) {
00702 cpl_propertylist_append(pre->data_header,qc_log);
00703 }
00704
00705 sprintf(mdark_tag,"%s_%s",XSH_MASTER_DARK,xsh_instrument_arm_tostring(instr));
00706 sprintf(mdark_name,"%s.fits",mdark_tag);
00707
00708 check(mdark = xsh_pre_save( pre,mdark_name,mdark_tag,0));
00709 check(cpl_frame_set_tag(mdark,mdark_tag));
00710
00711 cleanup:
00712 xsh_free_imagelist(&raw_data);
00713 xsh_free_imagelist(&raw_errs);
00714 xsh_free_imagelist(&iml_data);
00715 xsh_free_imagelist(&iml_errs);
00716 xsh_free_image(&qual_comb);
00717 xsh_pre_free(&pre);
00718
00719 for(i=0;i<sz;i++){
00720 xsh_free_propertylist(&raw_headers[i]);
00721 }
00722 cpl_free(raw_headers);
00723 return mdark;
00724 }
00737 cpl_frame *
00738 xsh_create_master_dark (cpl_frame * medFrame, xsh_instrument* instr,
00739 cpl_parameterlist* parameters,
00740 cpl_frame* crh_frm,cpl_frame* bpm_frm)
00741 {
00742
00743
00744
00745
00746
00747 xsh_pre *medPre = NULL;
00748 double exptime = 0.0;
00749 cpl_frame* resFrame = NULL;
00750 const char* tag = XSH_GET_TAG_FROM_ARM (XSH_MASTER_DARK, instr);
00751 char* finalName = NULL;
00752
00753 XSH_ASSURE_NOT_NULL(medFrame);
00754 XSH_ASSURE_NOT_NULL(instr);
00755
00756 check(medPre = xsh_pre_load (medFrame,instr));
00757 XSH_ASSURE_NOT_NULL(medPre);
00758
00759 exptime = medPre->exptime;
00760
00761
00762 if ( instr->arm != XSH_ARM_NIR ) {
00763 check_msg (cpl_image_divide_scalar (medPre->data, exptime),
00764 "Cant divide median image by exptime %lf", exptime);
00765 check_msg (cpl_image_divide_scalar (medPre->errs, exptime),
00766 "Cant divide median image by exptime %lf", exptime);
00767
00768
00769 xsh_msg_dbg_high ("Set EXPTIME = 1.");
00770 check(xsh_pfits_set_exptime (medPre->data_header, (double) 1.));
00771 check(xsh_pfits_set_exptime (medPre->errs_header, (double) 1.));
00772 }
00773
00774
00775 if ( xsh_instrument_get_arm(instr) == XSH_ARM_NIR ) {
00776 check(finalName =cpl_sprintf("%s_%s.fits",XSH_MASTER_DARK,
00777 xsh_instrument_arm_tostring(instr)));
00778 } else {
00779
00780
00781
00782
00783
00784
00785
00786 check(finalName =cpl_sprintf("%s_%s.fits",XSH_MASTER_DARK,
00787 xsh_instrument_arm_tostring(instr)));
00788 }
00789
00790
00791
00792
00793
00794 check(set_masterdark_qc (medPre, instr,parameters,crh_frm,bpm_frm));
00795
00796
00797 check ( resFrame = xsh_pre_save (medPre, finalName, tag,0 ));
00798
00799 assure (resFrame != NULL, cpl_error_get_code (), "Cant save PRE");
00800 xsh_msg_dbg_high ("PRE frame saved as file %s", finalName);
00801
00802 check(cpl_frame_set_level (resFrame, CPL_FRAME_LEVEL_FINAL));
00803 check(cpl_frame_set_tag (resFrame, tag));
00804
00805 cleanup:
00806 if (cpl_error_get_code() != CPL_ERROR_NONE){
00807 xsh_free_frame(&resFrame);
00808 }
00809 cpl_free(finalName);
00810 xsh_pre_free(&medPre);
00811 return resFrame;
00812 }
00813
00814
00815
00822
00823 static void
00824 reject_lo_hi(cpl_image *image, double min, double max)
00825 {
00826 cpl_mask *mask_lo = NULL;
00827 cpl_mask *mask_hi = NULL;
00828
00829 mask_lo = cpl_mask_threshold_image_create(image, -DBL_MAX, min);
00830 mask_hi = cpl_mask_threshold_image_create(image, max, DBL_MAX);
00831 assure_mem( mask_lo );
00832 assure_mem( mask_hi );
00833
00834 cpl_mask_or(mask_lo, mask_hi);
00835
00836 cpl_image_reject_from_mask(image, mask_lo);
00837
00838 cleanup:
00839 xsh_free_mask(&mask_lo);
00840 xsh_free_mask(&mask_hi);
00841 return;
00842 }
00843
00844 static int
00845 count_good(const cpl_image *image)
00846 {
00847 return
00848 cpl_image_get_size_x(image) * cpl_image_get_size_y(image) -
00849 cpl_image_count_rejected(image);
00850 }
00851
00852 static double
00853 get_masterbias_qc_structure_row_region(cpl_image * tima)
00854 {
00855
00856 cpl_image* avg_row=NULL;
00857 double min=0;
00858 double max=0;
00859 double struct_row=0;
00860
00861
00862
00863 check(avg_row = cpl_image_collapse_create(tima,0));
00864 check(cpl_image_divide_scalar(avg_row,cpl_image_get_size_y(tima)));
00865
00866
00867 min = cpl_image_get_mean(avg_row) - 2;
00868 max = cpl_image_get_mean(avg_row) + 2;
00869
00870
00871
00872
00873 check( reject_lo_hi(avg_row, min, max) );
00874 if (count_good(avg_row) >= 2)
00875 {
00876 check(struct_row = cpl_image_get_stdev(avg_row));
00877 }
00878 else
00879 {
00880 struct_row = -1;
00881 xsh_msg_warning("Only %d good pixels in image. Setting QC parameter to -1",
00882 count_good(avg_row));
00883 }
00884
00885 cleanup:
00886 xsh_free_image(&avg_row);
00887
00888
00889 return struct_row;
00890
00891 }
00892
00893
00894
00895
00896 static double
00897 get_masterbias_qc_structure_col_region(cpl_image * tima)
00898 {
00899
00900
00901 cpl_image* avg_col=NULL;
00902 double min=0;
00903 double max=0;
00904 double struct_col=0;
00905
00906 check(avg_col = cpl_image_collapse_create(tima,1));
00907 check(cpl_image_divide_scalar(avg_col,cpl_image_get_size_x(tima)));
00908
00909
00910 min = cpl_image_get_mean(avg_col) - 2;
00911 max = cpl_image_get_mean(avg_col) + 2;
00912
00913
00914
00915
00916 check( reject_lo_hi(avg_col, min, max) );
00917 if (count_good(avg_col) >= 2)
00918 {
00919 check(struct_col = cpl_image_get_stdev(avg_col));
00920 }
00921 else
00922 {
00923 struct_col = -1;
00924 xsh_msg_warning("Only %d good pixels in image. Setting QC parameter to -1",
00925 count_good(avg_col));
00926 }
00927
00928 cleanup:
00929 xsh_free_image(&avg_col);
00930
00931
00932 return struct_col;
00933
00934 }
00935
00936
00952 static void
00953 set_masterbias_qc_xsh_structure_region(xsh_pre * master,
00954 const int llx,
00955 const int lly,
00956 const int urx,
00957 const int ury,
00958 const int ref_x,
00959 const int ref_y,
00960 const int reg_id)
00961 {
00962
00963 cpl_image* xima=NULL;
00964 cpl_image* yima=NULL;
00965 double struct_row=0;
00966 double struct_col=0;
00967
00968 double mean = 0.0;
00969 double median = 0.0;
00970 double stdev = 0.0;
00971
00972 double structx = 0.0;
00973 double structy = 0.0;
00974
00975
00976 check( xsh_pre_median_mean_stdev_window( master, &mean, &median,&stdev,
00977 llx,lly,urx,ury) ) ;
00978
00979 check(xsh_pfits_set_qc_mbiasavg (master->data_header, mean));
00980 check(xsh_pfits_set_qc_mbiasmed (master->data_header, median));
00981 check(xsh_pfits_set_qc_mbiasrms (master->data_header, stdev));
00982
00983
00984
00985 if(reg_id==1){
00986 check(xima=cpl_image_extract(master->data,llx,lly,urx,ref_y));
00987 } else {
00988 check(xima=cpl_image_extract(master->data,llx,ref_y,urx,ury));
00989 }
00990 if (0) {
00991
00992
00993
00994 check(cpl_image_threshold(xima,
00995 -DBL_MAX,median+3*stdev,
00996 -DBL_MAX,median+3*stdev));
00997 }
00998
00999 if(reg_id==1){
01000 check(yima=cpl_image_extract(master->data,llx,lly,ref_x,ury));
01001 } else {
01002 check(yima=cpl_image_extract(master->data,ref_x,lly,urx,ury));
01003 }
01004 if (0) {
01005
01006
01007
01008 check(cpl_image_threshold(yima,
01009 -DBL_MAX,median+3*stdev,
01010 -DBL_MAX,median+3*stdev));
01011 }
01012
01013 check(struct_row=get_masterbias_qc_structure_row_region(xima));
01014 structx=struct_row;
01015
01016 check(struct_col=get_masterbias_qc_structure_col_region(yima));
01017 structy=struct_col;
01018
01019
01020 if(reg_id==1) {
01021 check(xsh_pfits_set_qc_reg1_structx(master->data_header,structx));
01022 check(xsh_pfits_set_qc_reg1_structy(master->data_header,structy));
01023 } else {
01024 check(xsh_pfits_set_qc_reg2_structx(master->data_header,structx));
01025 check(xsh_pfits_set_qc_reg2_structy(master->data_header,structy));
01026 }
01027
01028
01029
01030
01031
01032
01033
01034 cleanup:
01035 xsh_free_image(&xima);
01036 xsh_free_image(&yima);
01037 return;
01038
01039 }
01040
01055 static void
01056 set_masterbias_qc_structure_region(xsh_pre * master,
01057 const int llx,
01058 const int lly,
01059 const int urx,
01060 const int ury,
01061 const int ref_x,
01062 const int ref_y,
01063 const int reg_id)
01064 {
01065
01066
01067 check(set_masterbias_qc_xsh_structure_region(master,llx,lly,urx,ury,
01068 ref_x,ref_y,reg_id));
01069
01070 cleanup:
01071 return;
01072
01073 }
01074
01075
01083 static void
01084 set_masterbias_qc_structure(xsh_pre * master, cpl_parameterlist* parameters)
01085 {
01086
01087 cpl_parameter* p=NULL;
01088 int ref_x=-1;
01089 int ref_y=-1;
01090
01091 int ref_llx=0;
01092 int ref_lly=0;
01093 int ref_urx=0;
01094 int ref_ury=0;
01095
01096 int sx=0;
01097 int sy=0;
01098
01099
01100 sx=cpl_image_get_size_x(master->data);
01101 sy=cpl_image_get_size_y(master->data);
01102 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.struct_refx"));
01103 check(ref_x = cpl_parameter_get_int(p));
01104
01105 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.struct_refy"));
01106 check(ref_y = cpl_parameter_get_int(p));
01107
01108
01109
01110 ref_llx=1;ref_urx=sx;
01111 ref_lly=1;ref_ury=sy;
01112
01113 if(ref_x == -1) {
01114 ref_x=sx/2;
01115 }
01116
01117 if(ref_y == -1) {
01118 ref_y=sy/2;
01119 }
01120
01121 ref_x = (ref_x>0) ? ref_x : 1;
01122 ref_y = (ref_y>0) ? ref_y : 1;
01123 ref_x = (ref_x<sx) ? ref_x : sx;
01124 ref_y = (ref_y<sy) ? ref_y : sy;
01125
01126 set_masterbias_qc_structure_region(master,ref_llx,ref_lly,ref_urx,ref_ury,
01127 ref_x,ref_y,1);
01128
01129
01130 set_masterbias_qc_structure_region(master,ref_llx,ref_lly,ref_urx,ref_ury,
01131 ref_x,ref_y,2);
01132
01133
01134 cleanup:
01135 return;
01136
01137 }
01138
01139
01140
01141
01142
01143
01153 cpl_frame*
01154 xsh_create_master_bias2(cpl_frameset* rawFrames,xsh_stack_param* stack_par,
01155 xsh_instrument* instr,const char* result_tag,
01156 const int method_code)
01157 {
01158 cpl_frame* medFrame = NULL;
01159 cpl_imagelist *dataList = NULL;
01160 cpl_imagelist *errsList = NULL;
01161 cpl_image* qual_comb=NULL;
01162 int i=0;
01163 int size=0;
01164 xsh_pre* pre = NULL;
01165 cpl_frame *current = NULL;
01166 char result_name[256];
01167 const int mode_and=0;
01168
01169 XSH_ASSURE_NOT_NULL( instr);
01170 XSH_ASSURE_NOT_NULL( rawFrames);
01171 check( size = cpl_frameset_get_size( rawFrames));
01172
01173 XSH_ASSURE_NOT_ILLEGAL( size > 0);
01174
01175 check( dataList = cpl_imagelist_new());
01176 check( errsList = cpl_imagelist_new());
01177
01178 for (i=0;i < size;i++){
01179 check(current = cpl_frameset_get_frame(rawFrames,i));
01180
01181 check(pre = xsh_pre_load(current,instr));
01182
01183
01184 xsh_image_flag_bp(pre->data,pre->qual,instr);
01185 xsh_image_flag_bp(pre->errs,pre->qual,instr);
01186 check_msg( cpl_imagelist_set(dataList,cpl_image_duplicate(pre->data),
01187 i),"Cant add Data Image %d to imagelist", i) ;
01188 check_msg( cpl_imagelist_set(errsList,cpl_image_duplicate(pre->errs),
01189 i),"Cant add Data Image %d to imagelist", i) ;
01190
01191
01192 if(i==0) {
01193 qual_comb=cpl_image_duplicate(pre->qual);
01194 } else {
01195 xsh_badpixelmap_image_coadd(&qual_comb, pre->qual,mode_and);
01196 }
01197
01198 if (i < (size-1)) {
01199 xsh_pre_free(&pre);
01200 }
01201 }
01202
01203
01204
01205 xsh_free_image(&pre->data);
01206 xsh_free_image(&pre->qual);
01207
01208
01209 pre->qual=cpl_image_duplicate(qual_comb);
01210
01211 xsh_free_image(&qual_comb);
01212
01213
01214 assure (cpl_imagelist_is_uniform (dataList) == 0, CPL_ERROR_ILLEGAL_INPUT,
01215 "Data images are not uniform");
01216 assure (cpl_imagelist_is_uniform (errsList) == 0, CPL_ERROR_ILLEGAL_INPUT,
01217 "Errs images are not uniform");
01218
01219
01220 if(method_code==0) {
01221
01222 pre->data=xsh_irplib_mkmaster_median(dataList,5.,5,1.e-5);
01223 check( xsh_collapse_errs(pre->errs,errsList,0));
01224
01225 } else if(method_code==1) {
01226 check(pre->data=xsh_irplib_mkmaster_mean(dataList,5.,5,1.e-5,
01227 stack_par->klow,
01228 stack_par->khigh));
01229
01230 check( xsh_collapse_errs(pre->errs,errsList,1));
01231
01232 }
01233
01234
01235 check( xsh_pfits_set_datancom( pre->data_header, size));
01236
01237
01238
01239
01240 sprintf(result_name,"%s.fits",result_tag);
01241 check(medFrame = xsh_pre_save( pre, result_name, result_tag,0));
01242
01243 check(cpl_frame_set_tag(medFrame, result_tag));
01244
01245
01246 cleanup:
01247
01248 if (cpl_error_get_code () != CPL_ERROR_NONE) {
01249 xsh_free_frame(&medFrame);
01250 }
01251 xsh_free_imagelist(&dataList);
01252
01253 xsh_pre_free(&pre);
01254 xsh_free_imagelist(&errsList) ;
01255 xsh_free_image(&qual_comb);
01256
01257
01258 return medFrame;
01259
01260 }
01261
01281 cpl_frame *
01282 xsh_compute_qc_on_master_bias (cpl_frameset* raws,
01283 cpl_frame * frame,
01284 xsh_instrument* instr,
01285 cpl_parameterlist* params)
01286 {
01287 xsh_pre *master = NULL;
01288 cpl_frame *masterFrame = NULL;
01289 const char* tag = XSH_GET_TAG_FROM_ARM( XSH_MASTER_BIAS, instr);
01290 char mastername[256];
01291
01292
01293
01294 XSH_ASSURE_NOT_NULL(frame);
01295 check(master = xsh_pre_load (frame,instr));
01296
01297 check(xsh_pfits_set_pcatg (master->data_header, tag));
01298
01299
01300
01301
01302 if ( params != NULL ) {
01303 check( set_masterbias_qc_structure(master,params));
01304 if(cpl_frameset_get_size(raws) > 1 ) {
01305 check(xsh_compute_ron_mbias(raws,master,params));
01306 check(xsh_compute_fpn_mbias(raws,master,instr,params));
01307 }
01308 }
01309
01310 sprintf(mastername,"MASTER_BIAS_%s.fits",
01311 xsh_instrument_arm_tostring (instr));
01312
01313 xsh_msg ("Create master bias");
01314 check(masterFrame = xsh_pre_save (master, mastername,tag,0 ));
01315 cpl_frame_set_tag (masterFrame, tag);
01316 cpl_frame_set_group(masterFrame,CPL_FRAME_GROUP_CALIB);
01317
01318 cleanup:
01319 xsh_pre_free(&master);
01320 return masterFrame;
01321 }
01322
01323 cpl_frame *
01324 xsh_create_master_flat_with_mask (cpl_frame *frame, cpl_frame* edges, xsh_instrument *instr)
01325 {
01326 xsh_pre *master = NULL;
01327 cpl_frame *masterFrame = NULL;
01328 const char *tag = NULL;
01329 char *name = NULL;
01330 xsh_order_list *orderlist = NULL;
01331 int nx = 0;
01332 int ny = 0;
01333 int ord=0;
01334 int y=0;
01335 int x=0;
01336 int x1=0;
01337 int x2=0;
01338 int y1=0;
01339 int y2=0;
01340 int endy=0;
01341 int starty=0;
01342
01343
01344 cpl_image* ima=NULL;
01345
01346
01347
01348 double mean=0;
01349 int hbox=20;
01350
01351
01352 XSH_ASSURE_NOT_NULL( frame);
01353 XSH_ASSURE_NOT_NULL( edges);
01354 XSH_ASSURE_NOT_NULL( instr);
01355 if(xsh_instrument_get_lamp(instr) == XSH_LAMP_D2) {
01356 ord=22;
01357 ord=2;
01358 } else if(xsh_instrument_get_lamp(instr) == XSH_LAMP_QTH) {
01359 ord=16;
01360 ord=4;
01361 } else if (xsh_instrument_get_arm(instr) == XSH_ARM_VIS ) {
01362 ord=24;
01363 ord=6;
01364 } else if (xsh_instrument_get_arm(instr) == XSH_ARM_NIR ) {
01365 ord=18;
01366 ord=8;
01367 }
01368
01369 check( master = xsh_pre_load( frame, instr));
01370 check( orderlist = xsh_order_list_load( edges, instr));
01371
01372 nx = master->nx;
01373 ny = master->ny;
01374
01375 ima=cpl_image_new(nx,ny,CPL_TYPE_FLOAT);
01376 xsh_image_flag_bp(ima,master->qual,instr);
01377
01378
01379
01380 xsh_msg("prepare mask");
01381
01382 starty = orderlist->list[ord-1].starty;
01383 endy = orderlist->list[ord-1].endy;
01384
01385 y=0.5*(starty+endy)/master->biny;
01386 check(x1 = xsh_order_list_eval(orderlist, orderlist->list[ord].edglopoly,y));
01387 check(x2 = xsh_order_list_eval(orderlist, orderlist->list[ord].edguppoly, y));
01388 x=0.5*(x1+x2);
01389 x1=x-hbox;
01390 x2=x+hbox;
01391 y1=y-hbox;
01392 y2=y+hbox;
01393
01394
01395 check(mean=cpl_image_get_median_window(master->data,x1,y1,x2,y2));
01396 xsh_msg("scaling factor mean flat=%g",mean);
01397 XSH_NAME_LAMP_MODE_ARM( name, "MASK_FLAT",".fits",instr);
01398
01399 xsh_free_image(&ima);
01400
01401
01402 tag = XSH_GET_TAG_FROM_LAMP( XSH_MASTER_FLAT, instr);
01403 check( xsh_pfits_set_pcatg( master->data_header, tag));
01404
01405
01406 cpl_image_divide_scalar( master->data, mean);
01407 cpl_image_divide_scalar( master->errs, mean);
01408
01409 XSH_FREE( name);
01410 XSH_NAME_LAMP_MODE_ARM( name, "MASTER_FLAT",".fits",instr);
01411 xsh_msg ("Create master flat %s tag %s", name, tag);
01412
01413 check( masterFrame = xsh_pre_save( master, name, tag,0));
01414 check( cpl_frame_set_tag( masterFrame, tag));
01415 check( cpl_frame_set_group( masterFrame, CPL_FRAME_GROUP_CALIB));
01416
01417 cleanup:
01418 xsh_order_list_free(&orderlist);
01419 XSH_FREE( name);
01420 xsh_pre_free( &master);
01421 return masterFrame;
01422 }
01423
01424
01425 cpl_frame *
01426 xsh_create_master_flat (cpl_frame *frame, xsh_instrument *instr)
01427 {
01428 xsh_pre *master = NULL;
01429 cpl_frame *masterFrame = NULL;
01430 const char *tag = NULL;
01431 char *name = NULL;
01432
01433
01434 XSH_ASSURE_NOT_NULL( frame);
01435 XSH_ASSURE_NOT_NULL( instr);
01436
01437 check( master = xsh_pre_load( frame, instr));
01438
01439
01440 tag = XSH_GET_TAG_FROM_LAMP( XSH_MASTER_FLAT, instr);
01441 check( xsh_pfits_set_pcatg( master->data_header, tag));
01442
01443 check( xsh_pre_normalize( master));
01444
01445 XSH_NAME_LAMP_MODE_ARM( name, "MASTER_FLAT",".fits",instr);
01446 xsh_msg ("Create master flat %s tag %s", name, tag);
01447
01448 check( masterFrame = xsh_pre_save( master, name, tag,0));
01449 check( cpl_frame_set_tag( masterFrame, tag));
01450 check( cpl_frame_set_group( masterFrame, CPL_FRAME_GROUP_CALIB));
01451
01452 cleanup:
01453 XSH_FREE( name);
01454 xsh_pre_free( &master);
01455 return masterFrame;
01456 }
01457
01458
01459 cpl_frame *
01460 xsh_create_master_dark_bpmap (cpl_frame * mdarkFrame, xsh_instrument* instr)
01461 {
01462
01463
01464
01465
01466
01467 xsh_pre * mdark_pre = NULL ;
01468 cpl_frame* resFrame = NULL;
01469 const char* tag = XSH_GET_TAG_FROM_ARM( XSH_MASTER_BP_MAP_DARK, instr);
01470 char* finalName = NULL;
01471 int i=0, j=0;
01472 int* qual_data = NULL;
01473 int nx,ny;
01474 int nb_flag_pixels = 0;
01475 int error_pixels[32];
01476
01477
01478 XSH_ASSURE_NOT_NULL( mdarkFrame);
01479 XSH_ASSURE_NOT_NULL( instr);
01480
01481
01482 check( mdark_pre = xsh_pre_load( mdarkFrame, instr));
01483
01484 if ( xsh_instrument_get_arm(instr) == XSH_ARM_NIR ) {
01485 check(finalName=cpl_sprintf("%s_%s.fits",XSH_MASTER_BP_MAP_DARK,
01486 xsh_instrument_arm_tostring(instr)));
01487
01488 } else {
01489
01490
01491
01492
01493
01494
01495 check(finalName=cpl_sprintf("%s_%s.fits",XSH_MASTER_BP_MAP_DARK,
01496 xsh_instrument_arm_tostring(instr)));
01497
01498 }
01499
01500 check(resFrame=xsh_frame_product(finalName,tag,
01501 CPL_FRAME_TYPE_IMAGE,
01502 CPL_FRAME_GROUP_PRODUCT,
01503 CPL_FRAME_LEVEL_FINAL));
01504
01505
01506 check( qual_data = cpl_image_get_data_int( mdark_pre->qual));
01507 check( nx = cpl_image_get_size_x( mdark_pre->qual));
01508 check( ny = cpl_image_get_size_y( mdark_pre->qual));
01509
01510
01511 for(j=0; j<32; j++){
01512 error_pixels[j] = 0;
01513 }
01514
01515 for(i=0; i<nx*ny; i++){
01516 if( qual_data[i] > 0){
01517 nb_flag_pixels++;
01518 for( j=0;j<32;j++){
01519 int cmp = pow(2,j);
01520 if ( qual_data[i] & cmp){
01521 error_pixels[j]++;
01522 }
01523 }
01524 }
01525 }
01526
01527
01528
01529 check( xsh_pfits_set_qc_bp_map_ntotal(mdark_pre->qual_header,nb_flag_pixels));
01530
01531 for(i=1; i< 33; i++){
01532 check( xsh_pfits_set_qc_multi( mdark_pre->qual_header,
01533 (void *)&(error_pixels[i-1]), XSH_QC_BP_MAP_NFLAGi, instr, i));
01534 }
01535
01536
01537 check_msg (cpl_image_save (mdark_pre->qual, finalName, XSH_PRE_DATA_BPP,
01538 mdark_pre->qual_header, CPL_IO_DEFAULT),
01539 "Could not save bpmap to %s extension", finalName);
01540
01541
01542 cleanup:
01543 if (cpl_error_get_code() != CPL_ERROR_NONE){
01544 xsh_free_frame(&resFrame);
01545 }
01546 XSH_FREE(finalName);
01547 xsh_pre_free( &mdark_pre);
01548 return resFrame;
01549 }
01550
01551 static cpl_error_code
01552 xsh_compute_ron_mbias(cpl_frameset* raws,
01553 xsh_pre* master,
01554 cpl_parameterlist* parameters)
01555 {
01556
01557
01558 int random_sizex=-1;
01559 int random_nsamples=-1;
01560 double ron=0;
01561 double ron_err=0;
01562
01563
01564 int ref_llx=-1;
01565 int ref_lly=-1;
01566 int ref_urx=-1;
01567 int ref_ury=-1;
01568
01569
01570 int ref2_llx=-1;
01571 int ref2_lly=-1;
01572 int ref2_urx=-1;
01573 int ref2_ury=-1;
01574
01575
01576 cpl_parameter* p=NULL;
01577
01578 const cpl_frame * fr = NULL;
01579
01580 cpl_propertylist * plist = NULL;
01581
01582 int naxis1 = 0;
01583 int naxis2 = 0;
01584
01585
01586
01587
01588
01589 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.random_sizex"));
01590 check(random_sizex = cpl_parameter_get_int(p));
01591
01592 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.random_nsamples"));
01593 check(random_nsamples = cpl_parameter_get_int(p));
01594
01595 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref1_llx"));
01596 check(ref_llx = cpl_parameter_get_int(p));
01597
01598 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref1_lly"));
01599 check(ref_lly = cpl_parameter_get_int(p));
01600
01601 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref1_urx"));
01602 check(ref_urx = cpl_parameter_get_int(p));
01603
01604 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref1_urx"));
01605 check(ref_ury = cpl_parameter_get_int(p));
01606
01607 check(fr=cpl_frameset_get_first_const(raws));
01608
01609 check(plist=cpl_propertylist_load(cpl_frame_get_filename(fr),0));
01610 check(naxis1 = cpl_propertylist_get_int(plist, "NAXIS1"));
01611 check(naxis2 = cpl_propertylist_get_int(plist, "NAXIS2"));
01612
01613
01614 cpl_propertylist_delete(plist);
01615
01616
01617 if(ref_llx == -1) ref_llx = naxis1 / 8;
01618 if(ref_lly == -1) ref_lly = naxis2 / 8;
01619 if(ref_urx == -1) ref_urx = naxis1 * 7 / 8;
01620 if(ref_ury == -1) ref_ury = naxis2 * 7 / 8;
01621
01622 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_llx>0,"Must be ref_llx > 0");
01623 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_lly>0,"Must be ref_lly > 0");
01624 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_urx>0,"Must be ref_urx > 0");
01625 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_ury>0,"Must be ref_ury > 0");
01626
01627 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_llx<naxis1,"Must be ref_llx < frame X size");
01628 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_lly<naxis2,"Must be ref_lly < frame Y size");
01629 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_urx<=naxis1,"Must be ref_urx > frame X size");
01630 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_ury<=naxis2,"Must be ref_ury > frame Y size");
01631
01632 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_urx>ref_llx,"Must be ref_urx > ref_llx");
01633 XSH_ASSURE_NOT_ILLEGAL_MSG(ref_ury>ref_lly,"Must be ref_ury > ref_lly");
01634
01635 XSH_ASSURE_NOT_ILLEGAL_MSG(random_nsamples>0,"Must be random_nsamples > 0");
01636 XSH_ASSURE_NOT_ILLEGAL_MSG(random_nsamples<100000000,"Must be random_nsamples < 100000000");
01637 XSH_ASSURE_NOT_ILLEGAL_MSG(random_sizex>0,"Must be random_sizex > 0");
01638 XSH_ASSURE_NOT_ILLEGAL_MSG(random_sizex<naxis1,"Must be random_sizex < frame X size");
01639 XSH_ASSURE_NOT_ILLEGAL_MSG(random_sizex<naxis2,"Must be random_sizex < frame Y size");
01640
01641 check(xsh_compute_ron(raws,ref_llx,ref_lly,ref_urx,ref_ury,random_nsamples,random_sizex,1,&ron,&ron_err));
01642 xsh_pfits_set_qc_ron1(master->data_header,ron);
01643 xsh_pfits_set_qc_ron1_err(master->data_header,ron_err);
01644
01645 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref2_llx"));
01646 check(ref2_llx = cpl_parameter_get_int(p));
01647
01648 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref2_lly"));
01649 check(ref2_lly = cpl_parameter_get_int(p));
01650
01651 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref2_urx"));
01652 check(ref2_urx = cpl_parameter_get_int(p));
01653
01654 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.ref2_urx"));
01655 check(ref2_ury = cpl_parameter_get_int(p));
01656
01657
01658 //checking for defaults
01659 if(ref2_llx == -1) ref2_llx = naxis1 / 8;
01660 if(ref2_lly == -1) ref2_lly = naxis2 / 8;
01661 if(ref2_urx == -1) ref2_urx = naxis1 * 7 / 8;
01662 if(ref2_ury == -1) ref2_ury = naxis2 * 7 / 8;
01663
01664
01665 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_llx>0,"Must be ref2_llx > 0");
01666 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_lly>0,"Must be ref2_lly > 0");
01667 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_urx>0,"Must be ref2_urx > 0");
01668 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_ury>0,"Must be ref2_ury > 0");
01669
01670 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_llx<naxis1,"Must be ref2_llx < frame X size");
01671 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_lly<naxis2,"Must be ref2_lly < frame Y size");
01672
01673
01674 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_urx<=naxis1,"Must be ref2_urx <= frame X size");
01675 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_ury<=naxis2,"Must be ref2_ury <= frame Y size");
01676
01677 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_urx>ref2_llx,"Must be ref2_urx > ref2_llx");
01678 XSH_ASSURE_NOT_ILLEGAL_MSG(ref2_ury>ref2_lly,"Must be ref2_ury > ref2_lly");
01679
01680 if(
01681 (ref2_llx != ref_llx) ||
01682 (ref2_lly != ref_lly) ||
01683 (ref2_urx != ref_urx) ||
01684 (ref2_ury != ref_ury)
01685 ) {
01686
01687 check(xsh_compute_ron(raws,ref2_llx,ref2_lly,ref2_urx,ref2_ury,random_nsamples,random_sizex,2,&ron,&ron_err));
01688
01689 xsh_pfits_set_qc_ron2(master->data_header,ron);
01690 xsh_pfits_set_qc_ron2_err(master->data_header,ron_err);
01691
01692 }
01693
01694
01695 cleanup:
01696
01697 return cpl_error_get_code();
01698
01699 }
01700
01701
01702 static cpl_error_code
01703 xsh_compute_fpn_mbias(cpl_frameset* raws,
01704 xsh_pre* master,
01705 xsh_instrument* instrument,
01706 cpl_parameterlist* parameters)
01707 {
01708
01709 int nraws=0;
01710 double ron=0;
01711 double fpn=0;
01712 cpl_frame* frm1=NULL;
01713 cpl_frame* frm2=NULL;
01714 cpl_image* ima1=NULL;
01715 cpl_image* ima2=NULL;
01716 cpl_image* ima=NULL;
01717
01718
01719 if ( xsh_instrument_get_arm(instrument) != XSH_ARM_NIR){
01720 nraws=cpl_frameset_get_size(raws);
01721 if(nraws > 1) {
01722 frm1=cpl_frameset_get_first(raws);
01723 frm2=cpl_frameset_get_next(raws);
01724 ima1=cpl_image_load(cpl_frame_get_filename(frm1),CPL_TYPE_FLOAT,0,0);
01725 ima2=cpl_image_load(cpl_frame_get_filename(frm2),CPL_TYPE_FLOAT,0,0);
01726
01727 ima = cpl_image_duplicate(ima1);
01728 check(ron = xsh_image_get_stdev_clean(ima, NULL) / sqrt(2.0));
01729
01730 check(fpn = xsh_fixed_pattern_noise_bias(ima1,ima2,ron));
01731
01732 xsh_pfits_set_qc_ron_master(master->data_header,ron);
01733 xsh_pfits_set_qc_fpn_master(master->data_header,fpn);
01734
01735 xsh_free_image(&ima);
01736 xsh_free_image(&ima1);
01737 xsh_free_image(&ima2);
01738 }
01739 } else {
01740 check(xsh_mbias_get_fpn(master->data,parameters,&fpn));
01741 /* xsh_msg("Fixed Pattern Noise=%f",fpn); */
01742
01743 }
01744
01745 cleanup:
01746 xsh_free_image(&ima);
01747 xsh_free_image(&ima1);
01748 xsh_free_image(&ima2);
01749 return cpl_error_get_code();
01750
01751 }
01752
01753
01754
01755 static cpl_error_code
01756 xsh_mbias_get_fpn(const cpl_image* ima,
01757 cpl_parameterlist* parameters,
01758 double* fpn)
01759 {
01760
01761 int fpn_llx=0;
01762 int fpn_lly=0;
01763 int fpn_urx=0;
01764 int fpn_ury=0;
01765 int fpn_hsize=0;
01766 int fpn_nsamp=0;
01767 cpl_parameter* p=NULL;
01768
01769 cpl_size zone[4];
01770 int sx=0;
01771 int sy=0;
01772
01773 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_llx"));
01774 check(fpn_llx = cpl_parameter_get_int(p));
01775
01776 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_lly"));
01777 check(fpn_lly = cpl_parameter_get_int(p));
01778
01779 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_urx"));
01780 check(fpn_urx = cpl_parameter_get_int(p));
01781
01782 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_ury"));
01783 check(fpn_ury = cpl_parameter_get_int(p));
01784
01785 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_hsize"));
01786 check(fpn_hsize = cpl_parameter_get_int(p));
01787
01788 check(p = cpl_parameterlist_find(parameters,"xsh.xsh_mbias.fpn_nsamples"));
01789 check(fpn_nsamp = cpl_parameter_get_int(p));
01790
01791 sx=cpl_image_get_size_x(ima);
01792 sy=cpl_image_get_size_y(ima);
01793
01794 fpn_llx=(fpn_llx>0) ? fpn_llx: 0;
01795 fpn_lly=(fpn_lly>0) ? fpn_lly: 0;
01796
01797 fpn_urx=(fpn_urx<sx) ? fpn_urx: sx;
01798 fpn_ury=(fpn_ury<sy) ? fpn_ury: sy;
01799
01800
01801 zone[0]=fpn_llx;
01802 zone[1]=fpn_urx;
01803 zone[2]=fpn_lly;
01804 zone[3]=fpn_ury;
01805
01806
01807 check_msg(cpl_flux_get_noise_window(ima,zone,fpn_hsize,fpn_nsamp,fpn,NULL),
01808 "Error computing noise in a window");
01809
01810 cleanup:
01811 return cpl_error_get_code();
01812
01813 }
01814
01815
01816
01817
01818
01840 static cpl_image *
01841 xsh_flat_create_normalized_master(cpl_imagelist * flats,
01842 const cpl_table *ordertable,
01843 xsh_order_list* order_locations,
01844 xsh_stack_param* stack_param)
01845 {
01846 int ni;
01847 cpl_image *image=NULL;
01848 cpl_image* master_flat=NULL;
01849 cpl_imagelist* flats_norm=NULL;
01850 int k=0;
01851 int ord_min=0;
01852 int ord_max=0;
01853 int nord=0;
01854 double flux_mean=0;
01855 int nsam=10;
01856 int y_space=10;
01857 int hbox_sx=10;
01858 int hbox_sy=0;
01859 int is=0;
01860 int pos_x=0;
01861 int pos_y=0;
01862 int llx=0;
01863 int lly=0;
01864 int urx=0;
01865 int ury=0;
01866
01867 double x=0;
01868 double y=0;
01869 int sx=0;
01870 int sy=0;
01871 cpl_vector* vec_flux_ord=NULL;
01872 cpl_vector* vec_flux_sam=NULL;
01873 double* pvec_flux_ord=NULL;
01874 double* pvec_flux_sam=NULL;
01875 double tolerance=1.e-5;
01876 //int absord=0;
01877 int ord=0;
01878
01879 XSH_ASSURE_NOT_NULL_MSG(order_locations, "Null input order locations polinomial!");
01880 XSH_ASSURE_NOT_NULL_MSG(flats, "Null input flats imagelist!");
01881
01882 ni = cpl_imagelist_get_size(flats);
01883
01884 image = cpl_image_duplicate(cpl_imagelist_get(flats, 0));
01885 sx = cpl_image_get_size_x(image);
01886 sy = cpl_image_get_size_y(image);
01887
01888 xsh_free_image(&image);
01889 ord_min=cpl_table_get_column_min(ordertable,"ORDER");
01890 ord_max=cpl_table_get_column_max(ordertable,"ORDER");
01891 nord=ord_max-ord_min+1;
01892 vec_flux_ord=cpl_vector_new(nord);
01893 vec_flux_sam=cpl_vector_new(nsam);
01894 pvec_flux_ord=cpl_vector_get_data(vec_flux_ord);
01895 pvec_flux_sam=cpl_vector_get_data(vec_flux_sam);
01896 hbox_sy=(int)((sy-2*y_space)/(2*nsam)+0.5);
01897 flats_norm=cpl_imagelist_new();
01898 int starty=0;
01899 int endy=0;
01900 for(k=0;k<ni;k++) { /* loop over input images */
01901 xsh_free_image(&image);
01902 image = cpl_image_duplicate(cpl_imagelist_get(flats, k));
01903 for(ord=0;ord<nord;ord++) {
01904 //absord=ord+ord_min;
01905 endy=order_locations->list[ord].endy;
01906 starty=order_locations->list[ord].starty;
01907 pos_y=starty-hbox_sy;
01908 hbox_sy=(int)((endy-starty+1-2*y_space)/(2*nsam)+0.5);
01909 for(is=0;is<nsam;is++) {
01910 /* sample flux on nsam rectangular boxes distributed uniformly over the order center traces
01911 * we use a median to be robust to bad pixels */
01912 pos_y+=(2*hbox_sy+y_space);
01913 y=(int)(pos_y+0.5);
01914
01915
01916 check( x=cpl_polynomial_eval_1d(order_locations->list[ord].cenpoly,
01917 (double)y,NULL));
01918
01919 pos_x=(int)(x+0.5);
01920
01921 llx=xsh_max_int(pos_x-hbox_sx,1);
01922 lly=xsh_max_int(pos_y-hbox_sy,1);
01923 llx=xsh_min_int(llx,sx);
01924 lly=xsh_min_int(lly,sy);
01925
01926 urx=xsh_min_int(pos_x+hbox_sx,sx);
01927 ury=xsh_min_int(pos_y+hbox_sy,sy);
01928 urx=xsh_max_int(urx,1);
01929 ury=xsh_max_int(ury,1);
01930
01931 llx=xsh_min_int(llx,urx);
01932 lly=xsh_min_int(lly,ury);
01933 //xsh_msg("ord=%d llx=%d lly=%d urx=%d ury=%d",ord,llx,lly,urx,ury);
01934 check(pvec_flux_sam[is]=cpl_image_get_median_window(image,llx,lly,urx,ury));
01935
01936 }
01937 /* compute mean sampled values for each order */
01938 pvec_flux_ord[ord]=cpl_vector_get_mean(vec_flux_sam);
01939 }
01940 /* compute mean of mean values measured on all orders. Normalizes each flat image to it */
01941 flux_mean=cpl_vector_get_mean(vec_flux_ord);
01942 xsh_msg("Flat %d normalize factor inter1: %g",k,flux_mean);
01943 cpl_image_divide_scalar(image,flux_mean);
01944 cpl_imagelist_set(flats_norm,cpl_image_duplicate(image),k);
01945 }
01946
01947 /* the first master flat is the median of all means */
01948 if (strcmp(stack_param->stack_method, "median") == 0) {
01949 master_flat=xsh_imagelist_collapse_median_create(flats_norm);
01950 } else {
01951 master_flat=cpl_imagelist_collapse_sigclip_create(flats_norm,stack_param->klow,stack_param->khigh,tolerance,CPL_COLLAPSE_MEAN,NULL);
01952 }
01953
01954
01955 cleanup:
01956
01957 xsh_free_vector(&vec_flux_ord);
01958 xsh_free_vector(&vec_flux_sam);
01959 xsh_free_image(&image);
01960 xsh_free_imagelist(&flats_norm);
01961
01962
01963 return master_flat;
01964
01965 }
01966
01967
01968
01989 static cpl_image *
01990 xsh_flat_create_normalized_master2(cpl_imagelist * flats,
01991 const cpl_table *ordertable, xsh_order_list* order_locations,
01992 const cpl_image* mflat,xsh_stack_param* stack_param,cpl_vector** vec_flux_stack) {
01993
01994 cpl_imagelist* flats_norm = NULL;
01995 cpl_imagelist* flats_norm2 = NULL;
01996 cpl_image* master_flat = NULL;
01997
01998 cpl_image* flat = NULL;
01999 cpl_image* flat_mflat = NULL;
02000
02001
02002 cpl_vector* vec_flux = NULL;
02003 double* pvec_flux = NULL;
02004
02005 double* pvec_flux_stack = NULL;
02006
02007 int ni = 0;
02008 int i = 0;
02009 int sx = 0;
02010 int sy = 0;
02011 int ord_min = 0;
02012 int ord_max = 0;
02013 int nord = 0;
02014 int nsam = 10;
02015 int y_space = 10;
02016 int llx = 0;
02017 int lly = 0;
02018 int urx = 0;
02019 int ury = 0;
02020 int hbox_sx = 0;
02021 int hbox_sy = 0;
02022 int ord = 0;
02023 //int absord = 0;
02024 int pos_x = 0;
02025 int pos_y = 0;
02026 double x = 0;
02027 double y = 0;
02028 double flux_median = 0;
02029 double mean_explevel=0;
02030 /* double exptime=0; */
02031 int is = 0;
02032 int k = 0;
02033
02034 int starty=0;
02035 int endy=0;
02036 double tolerance=1.e-5;
02037 ni = cpl_imagelist_get_size(flats);
02038
02039 /* evaluate median on many windows distributed all over orders of flats */
02040 sx = cpl_image_get_size_x(mflat);
02041 sy = cpl_image_get_size_y(mflat);
02042
02043 ord_min = cpl_table_get_column_min(ordertable, "ORDER");
02044 ord_max = cpl_table_get_column_max(ordertable, "ORDER");
02045 nord = ord_max - ord_min + 1;
02046
02047 hbox_sy = (int) ((sy - 2 * y_space) / (2 * nsam) + 0.5);
02048 flats_norm = cpl_imagelist_new();
02049 *vec_flux_stack = cpl_vector_new(ni);
02050 pvec_flux_stack=cpl_vector_get_data(*vec_flux_stack);
02051
02052 for (i = 0; i < ni; i++) {
02053 xsh_free_vector(&vec_flux);
02054 vec_flux = cpl_vector_new(nord * nsam);
02055 pvec_flux = cpl_vector_get_data(vec_flux);
02056
02057
02058
02059
02060
02061 check(flat = cpl_image_duplicate(cpl_imagelist_get(flats, i)));
02062 /* normalize flats by master flat previously computed */
02063 flat_mflat = cpl_image_duplicate(flat);
02064 cpl_image_divide(flat_mflat, mflat);
02065
02066 k = 0;
02067 for (ord = 0; ord < nord; ord++) {
02068 //absord = ord + ord_min;
02069
02070 endy=order_locations->list[ord].endy;
02071 starty=order_locations->list[ord].starty;
02072 pos_y=starty-hbox_sy;
02073 hbox_sy=(int)((endy-starty+1-2*y_space)/(2*nsam)+0.5);
02074
02075 for (is = 0; is < nsam; is++) {
02076 /* sample flux on nsam rectangular boxes distributed uniformly over the order center traces
02077 * we use a median to be robust to bad pixels */
02078
02079 pos_y += (2 * hbox_sy + y_space);
02080 y = (int) (pos_y + 0.5);
02081
02082 check(
02083 x=cpl_polynomial_eval_1d(order_locations->list[ord].cenpoly, (double)y,NULL));
02084
02085 pos_x = (int) (x + 0.5);
02086
02087 check(llx=xsh_max_int(pos_x-hbox_sx,1));
02088 check(lly=xsh_max_int(pos_y-hbox_sy,1));
02089 check(llx=xsh_min_int(llx,sx));
02090 check(lly=xsh_min_int(lly,sy));
02091
02092 check(urx=xsh_min_int(pos_x+hbox_sx,sx));
02093 check(ury=xsh_min_int(pos_y+hbox_sy,sy));
02094 check(urx=xsh_max_int(urx,1));
02095 check(ury=xsh_max_int(ury,1));
02096
02097 check(llx=xsh_min_int(llx,urx));
02098 check(lly=xsh_min_int(lly,ury));
02099
02100 check(pvec_flux[k]=0);
02101
02102 check(
02103 pvec_flux[k]=cpl_image_get_median_window(flat_mflat,llx,lly,urx,ury));
02104
02105 k++;
02106 }
02107
02108 }
02109 /* compute median of median values measured on all orders. Normalizes each flat image to it */
02110 flux_median = cpl_vector_get_median(vec_flux);
02111 pvec_flux_stack[i]= flux_median;
02112 xsh_msg("Flat %d level iter2: %g", i, flux_median);
02113 //xsh_msg("Flat %d level ingested: %g", i, cpl_vector_get(*vec_flux_stack,i));
02114 //cpl_image_divide_scalar(flat, flux_median);
02115 cpl_imagelist_set(flats_norm, cpl_image_duplicate(flat), i);
02116 //xsh_msg("mean flat1=%g",cpl_image_get_median(flat));
02117 mean_explevel+=flux_median;
02118
02119
02120 xsh_free_image(&flat_mflat);
02121 xsh_free_image(&flat);
02122
02123 }
02124
02125 mean_explevel /= ni;
02126 //xsh_msg("mean_exp level: %g",mean_explevel);
02127
02128 cpl_vector_divide_scalar(*vec_flux_stack, mean_explevel);
02129 pvec_flux_stack = cpl_vector_get_data(*vec_flux_stack);
02130 flats_norm2 = cpl_imagelist_new();
02131 for (i = 0; i < ni; i++) {
02132 flat = cpl_imagelist_get(flats_norm, i);
02133 cpl_image_multiply_scalar(flat, 1./pvec_flux_stack[i]);
02134 //xsh_msg("inv factor=%g",pvec_flux_stack[i]);
02135 //xsh_msg("factor=%g",1./pvec_flux_stack[i]);
02136 //xsh_msg("mean flat2=%g",cpl_image_get_median(flat));
02137 cpl_imagelist_set(flats_norm2, cpl_image_duplicate(flat), i);
02138 }
02139
02140 if (strcmp(stack_param->stack_method, "median") == 0) {
02141 master_flat=xsh_imagelist_collapse_median_create(flats_norm2);
02142 } else {
02143 master_flat=cpl_imagelist_collapse_sigclip_create(flats_norm2,stack_param->klow,stack_param->khigh,tolerance,CPL_COLLAPSE_MEAN,NULL);
02144 }
02145
02146 cleanup:
02147
02148 xsh_free_imagelist(&flats_norm);
02149 xsh_free_imagelist(&flats_norm2);
02150 xsh_free_vector(&vec_flux);
02151 xsh_free_image(&flat_mflat);
02152 //xsh_free_image(&flat);
02153
02154 return master_flat;
02155
02156 }
02157
02158 /*----------------------------------------------------------------------------*/
02196 /*----------------------------------------------------------------------------*/
02197 cpl_frame *
02198 xsh_create_master_flat2(cpl_frameset *set,
02199 cpl_frame * order_tab_cen,
02200 xsh_stack_param* stack_par,
02201 xsh_instrument* inst)
02202
02203 {
02204 cpl_imagelist *dataList = NULL;
02205 cpl_imagelist *errsList = NULL;
02206 cpl_imagelist *errsList2 = NULL;
02207 //cpl_imagelist *raw_images_local = NULL;
02208
02209 cpl_image* qual_comb = NULL;
02210 cpl_image* ima=NULL;
02211
02212 cpl_image *master_flat = NULL;
02213 cpl_image *master_flat_tmp = NULL;
02214 cpl_image *current_flat = NULL;
02215
02216 cpl_table* ordertable = NULL;
02217
02218 cpl_vector* vec_flux=NULL;
02219
02220 cpl_frame *current = NULL;
02221
02222 cpl_frame* mflat = NULL;
02223
02224 xsh_pre* pre = NULL;
02225 xsh_order_list *order_centres_list = NULL;
02226
02227 double* pvec_flux=NULL;
02228 const char* fname = NULL;
02229
02230 int i = 0;
02231 int size = 0;
02232
02233 const int mode_and = 0;
02234 char mflat_name[256];
02235 char mflat_tag[256];
02236
02237 /* is input valid? */
02238 XSH_ASSURE_NOT_NULL( inst);
02239 XSH_ASSURE_NOT_NULL( set);
02240 check( size = cpl_frameset_get_size( set));
02241 XSH_ASSURE_NOT_ILLEGAL( size > 0);
02242
02243 fname = cpl_frame_get_filename(order_tab_cen);
02244 ordertable = cpl_table_load(fname, 1, 0);
02245 order_centres_list = xsh_order_list_load(order_tab_cen, inst);
02246
02247 check( dataList = cpl_imagelist_new());
02248 check( errsList = cpl_imagelist_new());
02249
02250 /* Populate image lists with images in frame set */
02251 for (i = 0; i < size; i++) {
02252 check(current = cpl_frameset_get_frame(set,i));
02253 /* Load pre file */
02254 check(pre = xsh_pre_load(current,inst));
02255
02256 /* inject bad pixels to change statistics */
02257 xsh_image_flag_bp(pre->data, pre->qual, inst);
02258 xsh_image_flag_bp(pre->errs, pre->qual, inst);
02259 check_msg( cpl_imagelist_set(dataList,cpl_image_duplicate(pre->data),
02260 i),"Cant add Data Image %d to imagelist", i);
02261 check_msg( cpl_imagelist_set(errsList,cpl_image_duplicate(pre->errs),
02262 i),"Cant add Data Image %d to imagelist", i);
02263
02264 /* combining bad pixels */
02265 if (i == 0) {
02266 qual_comb = cpl_image_duplicate(pre->qual);
02267 } else {
02268 xsh_badpixelmap_image_coadd(&qual_comb, pre->qual, mode_and);
02269 }
02270 /* Free memory */
02271 if (i < (size - 1)) {
02272 xsh_pre_free(&pre);
02273 }
02274 }
02275
02276 /*free memory on product extensions that will be re-allocated later on (errs is only modified) */
02277 xsh_free_image(&pre->data);
02278 xsh_free_image(&pre->qual);
02279
02280 /* store combined bp map in qual extension of result */
02281 pre->qual = cpl_image_duplicate(qual_comb);
02282 xsh_free_image(&qual_comb);
02283
02284 /* Create initial master flat */
02285 xsh_msg("Calculating stack normalized master");
02286 check_msg(
02287 master_flat_tmp = xsh_flat_create_normalized_master(dataList, ordertable, order_centres_list,stack_par),
02288 "Error computing master flat with normalization");
02289 //check(cpl_image_save(master_flat_tmp,"master_flat_tmp.fits",CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_DEFAULT));
02290
02291
02292 /* Create final master flat */
02293
02294 //xsh_free_image(&(pre->data));
02295 check_msg(
02296 pre->data = xsh_flat_create_normalized_master2(dataList, ordertable, order_centres_list, master_flat_tmp,
02297 stack_par,&vec_flux),"Error computing master flat with normalization");
02298 //check(cpl_image_save(pre->data,"master_flat_final.fits",CPL_BPP_IEEE_FLOAT,NULL,CPL_IO_DEFAULT));
02299
02300 xsh_free_image(&master_flat_tmp);
02301 check(pvec_flux=cpl_vector_get_data(vec_flux));
02302 check( errsList2 = cpl_imagelist_new());
02303
02304 for (i = 0; i < size; i++) {
02305 check(ima=cpl_imagelist_get(errsList,i));
02306 check(cpl_image_multiply_scalar(ima,pvec_flux[i]));
02307 check(cpl_imagelist_set(errsList2,cpl_image_duplicate(ima),i));
02308 }
02309
02310 /* Create initial master flat err */
02311 if (strcmp(stack_par->stack_method, "median") == 0) {
02312 check( xsh_collapse_errs(pre->errs,errsList2,0));
02313 } else {
02314 check( xsh_collapse_errs(pre->errs,errsList2,1));
02315 }
02316
02317 /*clean memory and reset local pointers to null */
02318 //raw_images_local = NULL;
02319 if (xsh_instrument_get_arm(inst) == XSH_ARM_UVB) {
02320 sprintf(mflat_tag, "%s_%s_%s", XSH_MASTER_FLAT,
02321 xsh_instrument_lamp_tostring(inst), xsh_instrument_arm_tostring(inst));
02322 } else {
02323 sprintf(mflat_tag, "%s_%s", XSH_MASTER_FLAT,xsh_instrument_arm_tostring(inst));
02324 }
02325 sprintf(mflat_name,"%s.fits",mflat_tag);
02326
02327 check(mflat = xsh_pre_save( pre,mflat_name,mflat_tag,1));
02328 check(cpl_frame_set_tag(mflat,mflat_tag));
02329
02330 cleanup:
02331 xsh_free_imagelist(&dataList);
02332 xsh_free_imagelist(&errsList);
02333 xsh_free_imagelist(&errsList2);
02334 xsh_free_table(&ordertable);
02335 xsh_free_image(¤t_flat);
02336 xsh_order_list_free(&order_centres_list);
02337 xsh_pre_free(&pre);
02338 xsh_free_vector(&vec_flux);
02339
02340 if (cpl_error_get_code() != CPL_ERROR_NONE) {
02341 xsh_free_image(&master_flat);
02342 }
02343
02344 return mflat;
02345 }
02346
02347
02348
02349
02350
02351
02352
02353
02354
02355
02356
02357
02358
02359
02360
02361
02362
02363