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
00028 #ifdef HAVE_CONFIG_H
00029 #include <config.h>
00030 #endif
00031
00032
00033
00034
00035
00036 #include <math.h>
00037 #include <string.h>
00038 #include <cpl.h>
00039
00040 #include "irplib_utils.h"
00041
00042 #include "hawki_utils.h"
00043 #include "hawki_image_stats.h"
00044 #include "hawki_load.h"
00045 #include "hawki_save.h"
00046 #include "hawki_pfits.h"
00047 #include "hawki_dfs.h"
00048
00049
00050
00051
00052
00053 static int hawki_cal_flat_create(cpl_plugin *) ;
00054 static int hawki_cal_flat_exec(cpl_plugin *) ;
00055 static int hawki_cal_flat_destroy(cpl_plugin *) ;
00056 static int hawki_cal_flat(cpl_parameterlist *, cpl_frameset *) ;
00057
00058 static int hawki_cal_flat_retrieve_input_param
00059 (cpl_parameterlist * parlist);
00060 static cpl_imagelist ** hawki_cal_flat_reduce(
00061 cpl_frameset * flatframes,
00062 const char * dark_file,
00063 cpl_table ** raw_flat_stats,
00064 cpl_table ** raw_flat_odd_column_stats,
00065 cpl_table ** raw_flat_even_column_stats,
00066 cpl_table ** raw_flat_odd_row_stats,
00067 cpl_table ** raw_flat_even_row_stats,
00068 cpl_vector ** selected);
00069 static int hawki_cal_flat_clean_outliers(cpl_image *, cpl_imagelist *,
00070 cpl_imagelist *, cpl_vector *, cpl_image **) ;
00071 static int hawki_cal_flat_save
00072 (cpl_imagelist ** flat,
00073 cpl_table ** raw_flat_stats,
00074 cpl_table ** raw_flat_odd_column_stats,
00075 cpl_table ** raw_flat_even_column_stats,
00076 cpl_table ** raw_flat_odd_row_stats,
00077 cpl_table ** raw_flat_even_row_stats,
00078 cpl_vector ** raw_selected,
00079 int set_nb,
00080 const cpl_frame * bpmdark,
00081 cpl_frameset * flatframes,
00082 cpl_frameset * calibframes,
00083 cpl_parameterlist * parlist,
00084 cpl_frameset * set_tot);
00085 static int hawki_cal_flat_compare(const cpl_frame *, const cpl_frame *) ;
00086 static cpl_imagelist * hawki_cal_flat_merge_bpms
00087 (const cpl_frame * bpm_orig,
00088 cpl_imagelist * bpm_to_add);
00089 static int hawki_cal_flat_select
00090 (cpl_vector * meds,
00091 cpl_vector * rms,
00092 int auto_flag,
00093 int auto_max_bins,
00094 double min_level,
00095 double max_level,
00096 double max_rms,
00097 int min_nframes,
00098 cpl_vector * selection);
00099 static cpl_vector * hawki_cal_flat_extract_vector(cpl_vector *,
00100 cpl_vector *) ;
00101
00102
00103
00104
00105
00106 static struct {
00107
00108 int llx ;
00109 int lly ;
00110 int urx ;
00111 int ury ;
00112 int normalise ;
00113 int second_pass ;
00114 double sigma_badres ;
00115 double sigma_bpm ;
00116 double lowval_bpm ;
00117 double highval_bpm ;
00118 int select_auto ;
00119 int select_auto_max_bins;
00120 double select_min_level[HAWKI_NB_DETECTORS];
00121 double select_max_level[HAWKI_NB_DETECTORS];
00122 double select_max_rms[HAWKI_NB_DETECTORS];
00123 int select_min_nframes ;
00124 int extra_stats;
00125 } hawki_cal_flat_config ;
00126
00127 static struct {
00128
00129 int nb_badpix[HAWKI_NB_DETECTORS];
00130 double norm[HAWKI_NB_DETECTORS];
00131 double med_stdev[HAWKI_NB_DETECTORS];
00132 double med_avg[HAWKI_NB_DETECTORS];
00133 double med_med[HAWKI_NB_DETECTORS];
00134 double med_min[HAWKI_NB_DETECTORS];
00135 double med_max[HAWKI_NB_DETECTORS];
00136 } hawki_cal_flat_outputs;
00137
00138 static char hawki_cal_flat_description[] =
00139 "hawki_cal_flat -- HAWKĪI imaging flat-field creation from twillight images.\n"
00140 "The input of the recipe files listed in the Set Of Frames (sof-file)\n"
00141 "must be tagged as:\n"
00142 "raw-file.fits "HAWKI_CAL_FLAT_RAW" or\n"
00143 "Optional inputs are:\n"
00144 "bpmdark-file.fits "HAWKI_CALPRO_BPM_HOT"\n"
00145 "dark-file.fits "HAWKI_CALPRO_DARK"\n"
00146 "dark_err-file.fits "HAWKI_CALPRO_DARK_ERR"\n"
00147 "The recipe creates as an output:\n"
00148 "hawki_cal_flat_setxx.fits ("HAWKI_CALPRO_FLAT"): Master flat for filter xx\n"
00149 "hawki_cal_flat_err_setxx.fits ("HAWKI_CALPRO_FLAT_ERRMAP"): Master flat residuals\n"
00150 "hawki_cal_flat_bpmflat_setxx.fits ("HAWKI_CALPRO_BPM_COLD"): BPM from the flat\n"
00151 "hawki_cal_flat_stats_setxx.fits ("HAWKI_CALPRO_FLAT_STATS"): Stats of the individual flats\n"
00152 "Optionally it also creates:\n"
00153 "hawki_cal_flat_bpm_setxx.fits ("HAWKI_CALPRO_BPM"): Bad pixel mask combining bpm from dark and flat\n"
00154 "hawki_cal_flat_stats_ec_setxx.fits ("HAWKI_CALPRO_FLAT_STATS_EVEN_COL"): Stats of the individual flats for even columns\n"
00155 "hawki_cal_flat_stats_oc_setxx.fits ("HAWKI_CALPRO_FLAT_STATS_ODD_COL"): Stats of the individual flats for odd columns\n"
00156 "hawki_cal_flat_stats_er_setxx.fits ("HAWKI_CALPRO_FLAT_STATS_EVEN_ROW"): Stats of the individual flats for even rows\n"
00157 "hawki_cal_flat_stats_or_setxx.fits ("HAWKI_CALPRO_FLAT_STATS_ODD_ROW"): Stats of the individual flats for odd rows\n"
00158 "Return code:\n"
00159 "esorex exits with an error code of 0 if the recipe completes successfully\n"
00160 "or 1 otherwise";
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00178
00179 int cpl_plugin_get_info(cpl_pluginlist * list)
00180 {
00181 cpl_recipe * recipe = cpl_calloc(1, sizeof(*recipe)) ;
00182 cpl_plugin * plugin = &recipe->interface ;
00183
00184 cpl_plugin_init(plugin,
00185 CPL_PLUGIN_API,
00186 HAWKI_BINARY_VERSION,
00187 CPL_PLUGIN_TYPE_RECIPE,
00188 "hawki_cal_flat",
00189 "Twillight flat recipe",
00190 hawki_cal_flat_description,
00191 "Cesar Enrique Garcia Dabo",
00192 PACKAGE_BUGREPORT,
00193 hawki_get_license(),
00194 hawki_cal_flat_create,
00195 hawki_cal_flat_exec,
00196 hawki_cal_flat_destroy) ;
00197
00198 cpl_pluginlist_append(list, plugin) ;
00199
00200 return 0;
00201 }
00202
00203
00212
00213 static int hawki_cal_flat_create(cpl_plugin * plugin)
00214 {
00215 cpl_recipe * recipe ;
00216 cpl_parameter * p ;
00217
00218
00219 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00220 recipe = (cpl_recipe *)plugin ;
00221 else return -1 ;
00222
00223
00224 recipe->parameters = cpl_parameterlist_new() ;
00225
00226
00227
00228 p = cpl_parameter_new_value("hawki.hawki_cal_flat.zone",
00229 CPL_TYPE_STRING,
00230 "Stats zone",
00231 "hawki.hawki_cal_flat",
00232 "1,1,2048,2048") ;
00233 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "zone") ;
00234 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00235 cpl_parameterlist_append(recipe->parameters, p) ;
00236
00237
00238 p = cpl_parameter_new_value("hawki.hawki_cal_flat.normalise",
00239 CPL_TYPE_BOOL, "Flag to apply the normalisation",
00240 "hawki.hawki_cal_flat", FALSE) ;
00241 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "normalise") ;
00242 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00243 cpl_parameterlist_append(recipe->parameters, p) ;
00244
00245
00246 p = cpl_parameter_new_value("hawki.hawki_cal_flat.second_pass",
00247 CPL_TYPE_BOOL, "Flag to apply a second pass computation",
00248 "hawki.hawki_cal_flat", TRUE) ;
00249 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "second_pass") ;
00250 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00251 cpl_parameterlist_append(recipe->parameters, p) ;
00252
00253
00254 p = cpl_parameter_new_value("hawki.hawki_cal_flat.sigma_badres",
00255 CPL_TYPE_DOUBLE, "sigma for detection of bad flat results",
00256 "hawki.hawki_cal_flat", 1.0) ;
00257 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sigma_badres") ;
00258 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00259 cpl_parameterlist_append(recipe->parameters, p) ;
00260
00261
00262 p = cpl_parameter_new_value("hawki.hawki_cal_flat.sigma_bpm",
00263 CPL_TYPE_DOUBLE, "sigma for detection of bad pixels",
00264 "hawki.hawki_cal_flat", 10.0) ;
00265 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sigma_bpm") ;
00266 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00267 cpl_parameterlist_append(recipe->parameters, p) ;
00268
00269
00270 p = cpl_parameter_new_value("hawki.hawki_cal_flat.lowval_bpm",
00271 CPL_TYPE_DOUBLE, "values of the flat below this will be included "
00272 "in the bpm. In units of final flat (normalised if normalise is on)",
00273 "hawki.hawki_cal_flat", .1) ;
00274 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "lowval_bpm") ;
00275 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00276 cpl_parameterlist_append(recipe->parameters, p) ;
00277
00278
00279 p = cpl_parameter_new_value("hawki.hawki_cal_flat.highval_bpm",
00280 CPL_TYPE_DOUBLE, "values of the flat above this will be included "
00281 "in the bpm. In units of final flat (normalized if normalise is on)",
00282 "hawki.hawki_cal_flat", 10.0) ;
00283 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "highval_bpm") ;
00284 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00285 cpl_parameterlist_append(recipe->parameters, p) ;
00286
00287
00288 p = cpl_parameter_new_value("hawki.hawki_cal_flat.select_auto",
00289 CPL_TYPE_BOOL, "Flag to automatically select the good input frames",
00290 "hawki.hawki_cal_flat", TRUE);
00291 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "select_auto") ;
00292 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00293 cpl_parameterlist_append(recipe->parameters, p) ;
00294
00295
00296 p = cpl_parameter_new_value("hawki.hawki_cal_flat.select_auto_max_bins",
00297 CPL_TYPE_INT, "Maximum number of frames requested",
00298 "hawki.hawki_cal_flat", 10) ;
00299 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "select_auto_max_bins");
00300 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00301 cpl_parameterlist_append(recipe->parameters, p) ;
00302
00303
00304 p = cpl_parameter_new_value("hawki.hawki_cal_flat.select_min_level",
00305 CPL_TYPE_STRING, "Minimum ADU level for frames selection",
00306 "hawki.hawki_cal_flat", "-1.0") ;
00307 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "select_min_level") ;
00308 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00309 cpl_parameterlist_append(recipe->parameters, p) ;
00310
00311
00312 p = cpl_parameter_new_value("hawki.hawki_cal_flat.select_max_level",
00313 CPL_TYPE_STRING, "Maximum ADU level for frames selection",
00314 "hawki.hawki_cal_flat", "25000");
00315 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "select_max_level");
00316 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
00317 cpl_parameterlist_append(recipe->parameters, p);
00318
00319
00320 p = cpl_parameter_new_value("hawki.hawki_cal_flat.select_max_rms",
00321 CPL_TYPE_STRING, "Maximum RMS for frames selection",
00322 "hawki.hawki_cal_flat", "4000");
00323 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "select_max_rms");
00324 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
00325 cpl_parameterlist_append(recipe->parameters, p);
00326
00327
00328 p = cpl_parameter_new_value("hawki.hawki_cal_flat.select_min_nframes",
00329 CPL_TYPE_INT, "Minimum number of frames requested",
00330 "hawki.hawki_cal_flat", 3);
00331 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "select_min_nframes") ;
00332 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00333 cpl_parameterlist_append(recipe->parameters, p) ;
00334
00335
00336 p = cpl_parameter_new_value("hawki.hawki_cal_flat.extra_stats",
00337 CPL_TYPE_BOOL, "Request for even/odd column/rows statistics",
00338 "hawki.hawki_cal_flat", FALSE) ;
00339 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "extra_stats") ;
00340 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
00341 cpl_parameterlist_append(recipe->parameters, p) ;
00342
00343
00344 return 0;
00345 }
00346
00347
00353
00354 static int hawki_cal_flat_exec(cpl_plugin * plugin)
00355 {
00356 cpl_recipe * recipe ;
00357
00358
00359 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00360 recipe = (cpl_recipe *)plugin ;
00361 else return -1 ;
00362
00363
00364 hawki_print_banner();
00365
00366 return hawki_cal_flat(recipe->parameters, recipe->frames) ;
00367 }
00368
00369
00375
00376 static int hawki_cal_flat_destroy(cpl_plugin * plugin)
00377 {
00378 cpl_recipe * recipe ;
00379
00380
00381 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00382 recipe = (cpl_recipe *)plugin ;
00383 else return -1 ;
00384
00385 cpl_parameterlist_delete(recipe->parameters) ;
00386 return 0 ;
00387 }
00388
00389
00396
00397 static int hawki_cal_flat(
00398 cpl_parameterlist * parlist,
00399 cpl_frameset * framelist)
00400 {
00401 int * labels ;
00402 int nlabels ;
00403 cpl_frameset * flatframes ;
00404 int nflats;
00405 const char * dark ;
00406 const char * dark_err;
00407 const cpl_frame * bpmdark ;
00408 cpl_imagelist ** twflat ;
00409 cpl_table ** raw_flat_stats;
00410 cpl_table ** raw_flat_odd_column_stats = NULL;
00411 cpl_table ** raw_flat_even_column_stats = NULL;
00412 cpl_table ** raw_flat_odd_row_stats = NULL;
00413 cpl_table ** raw_flat_even_row_stats = NULL;
00414 cpl_vector ** raw_selected;
00415 int i, j ;
00416 cpl_errorstate error_prevstate = cpl_errorstate_get();
00417
00418
00419 if(hawki_cal_flat_retrieve_input_param(parlist))
00420 {
00421 cpl_msg_error(__func__, "Wrong parameters");
00422 return -1;
00423 }
00424
00425
00426 if (hawki_dfs_set_groups(framelist)) {
00427 cpl_msg_error(__func__, "Cannot identify RAW and CALIB frames") ;
00428 return -1;
00429 }
00430
00431
00432 if ((flatframes = hawki_extract_frameset(framelist,
00433 HAWKI_CAL_FLAT_RAW)) == NULL) {
00434 cpl_msg_error(__func__, "Cannot find flat frames in the input list (%s)",
00435 HAWKI_CAL_FLAT_RAW);
00436 return -1 ;
00437 }
00438
00439
00440 bpmdark = cpl_frameset_find_const(framelist, HAWKI_CALPRO_BPM_HOT);
00441 dark = hawki_extract_first_filename(framelist, HAWKI_CALPRO_DARK);
00442 dark_err = hawki_extract_first_filename(framelist, HAWKI_CALPRO_DARK_ERR);
00443
00444
00445 labels = cpl_frameset_labelise(flatframes, hawki_cal_flat_compare,
00446 &nlabels);
00447 if (labels == NULL) {
00448 cpl_msg_error(__func__, "Cannot labelise input frames") ;
00449 cpl_frameset_delete(flatframes);
00450 return -1;
00451 }
00452
00453
00454 for (i=0 ; i<nlabels ; i++)
00455 {
00456 cpl_frameset * this_filter_flats;
00457
00458
00459 cpl_msg_info(__func__, "Reduce data set no %d out of %d", i+1, nlabels);
00460 cpl_msg_indent_more() ;
00461 this_filter_flats = cpl_frameset_extract(flatframes, labels, i) ;
00462 nflats = cpl_frameset_get_size(this_filter_flats);
00463
00464
00465 raw_flat_stats = cpl_malloc(HAWKI_NB_DETECTORS*sizeof(cpl_table*));
00466 raw_selected = cpl_malloc(HAWKI_NB_DETECTORS*sizeof(cpl_vector*));
00467 for (j=0 ; j<HAWKI_NB_DETECTORS ; j++)
00468 {
00469 raw_selected[j] = cpl_vector_new(nflats);
00470 raw_flat_stats[j] = cpl_table_new(nflats);
00471 }
00472
00473 hawki_image_stats_initialize(raw_flat_stats);
00474 if(hawki_cal_flat_config.extra_stats)
00475 {
00476 raw_flat_odd_column_stats =
00477 cpl_malloc(HAWKI_NB_DETECTORS*sizeof(cpl_table*));
00478 raw_flat_even_column_stats =
00479 cpl_malloc(HAWKI_NB_DETECTORS*sizeof(cpl_table*));
00480 raw_flat_odd_row_stats =
00481 cpl_malloc(HAWKI_NB_DETECTORS*sizeof(cpl_table*));
00482 raw_flat_even_row_stats =
00483 cpl_malloc(HAWKI_NB_DETECTORS*sizeof(cpl_table*));
00484 for (j=0 ; j<HAWKI_NB_DETECTORS ; j++)
00485 {
00486 raw_flat_odd_column_stats[j] = cpl_table_new(nflats);
00487 raw_flat_even_column_stats[j] = cpl_table_new(nflats);
00488 raw_flat_odd_row_stats[j] = cpl_table_new(nflats);
00489 raw_flat_even_row_stats[j] = cpl_table_new(nflats);
00490 }
00491
00492 hawki_image_stats_initialize(raw_flat_odd_column_stats);
00493 hawki_image_stats_initialize(raw_flat_even_column_stats);
00494 hawki_image_stats_initialize(raw_flat_odd_row_stats);
00495 hawki_image_stats_initialize(raw_flat_even_row_stats);
00496 }
00497
00498
00499 if ((twflat = hawki_cal_flat_reduce
00500 (this_filter_flats,
00501 dark,
00502 raw_flat_stats,
00503 raw_flat_odd_column_stats,
00504 raw_flat_even_column_stats,
00505 raw_flat_odd_row_stats,
00506 raw_flat_even_row_stats,
00507 raw_selected)) == NULL)
00508 {
00509 for (j=0 ; j<HAWKI_NB_DETECTORS ; j++)
00510 {
00511 cpl_table_delete(raw_flat_stats[j]);
00512 cpl_vector_delete(raw_selected[j]);
00513 }
00514 cpl_free(raw_flat_stats);
00515 cpl_free(raw_selected);
00516 if(hawki_cal_flat_config.extra_stats)
00517 {
00518 for (j=0 ; j<HAWKI_NB_DETECTORS ; j++)
00519 {
00520 cpl_table_delete(raw_flat_odd_column_stats[j]);
00521 cpl_table_delete(raw_flat_even_column_stats[j]);
00522 cpl_table_delete(raw_flat_odd_row_stats[j]);
00523 cpl_table_delete(raw_flat_even_row_stats[j]);
00524 }
00525 cpl_free(raw_flat_odd_column_stats);
00526 cpl_free(raw_flat_even_column_stats);
00527 cpl_free(raw_flat_odd_row_stats);
00528 cpl_free(raw_flat_even_row_stats);
00529 }
00530 cpl_frameset_delete(this_filter_flats);
00531 cpl_frameset_delete(flatframes);
00532 cpl_free(labels);
00533 cpl_msg_error(__func__, "Cannot reduce set nb %d", i+1) ;
00534 return 1;
00535
00536 } else {
00537
00538 cpl_frameset * calib_frames;
00539
00540 cpl_msg_info(__func__, "Save the products") ;
00541 calib_frames = cpl_frameset_new();
00542 if(bpmdark)
00543 cpl_frameset_insert(calib_frames, cpl_frame_duplicate(bpmdark));
00544 if(dark)
00545 cpl_frameset_insert(calib_frames,
00546 cpl_frame_duplicate(cpl_frameset_find_const(framelist,
00547 HAWKI_CALPRO_DARK)));
00548 if(dark_err)
00549 cpl_frameset_insert(calib_frames,
00550 cpl_frame_duplicate(cpl_frameset_find_const(framelist,
00551 HAWKI_CALPRO_DARK_ERR)));
00552 hawki_cal_flat_save
00553 (twflat, raw_flat_stats,
00554 raw_flat_odd_column_stats,
00555 raw_flat_even_column_stats,
00556 raw_flat_odd_row_stats,
00557 raw_flat_even_row_stats,
00558 raw_selected,
00559 i+1, bpmdark, this_filter_flats, calib_frames,
00560 parlist, framelist);
00561 cpl_imagelist_delete(twflat[0]);
00562 cpl_imagelist_delete(twflat[1]);
00563 cpl_imagelist_delete(twflat[2]);
00564 if (hawki_cal_flat_config.second_pass)
00565 cpl_imagelist_delete(twflat[3]);
00566 cpl_free(twflat);
00567 for (j=0 ; j<HAWKI_NB_DETECTORS ; j++)
00568 {
00569 cpl_table_delete(raw_flat_stats[j]);
00570 cpl_vector_delete(raw_selected[j]);
00571 }
00572 cpl_free(raw_flat_stats);
00573 cpl_free(raw_selected);
00574 if(hawki_cal_flat_config.extra_stats)
00575 {
00576 for (j=0 ; j<HAWKI_NB_DETECTORS ; j++)
00577 {
00578 cpl_table_delete(raw_flat_odd_column_stats[j]);
00579 cpl_table_delete(raw_flat_even_column_stats[j]);
00580 cpl_table_delete(raw_flat_odd_row_stats[j]);
00581 cpl_table_delete(raw_flat_even_row_stats[j]);
00582 }
00583 cpl_free(raw_flat_odd_column_stats);
00584 cpl_free(raw_flat_even_column_stats);
00585 cpl_free(raw_flat_odd_row_stats);
00586 cpl_free(raw_flat_even_row_stats);
00587 }
00588 cpl_frameset_delete(calib_frames);
00589 }
00590 cpl_msg_indent_less();
00591 cpl_frameset_delete(this_filter_flats);
00592 }
00593
00594 if(!cpl_errorstate_is_equal(error_prevstate))
00595 cpl_msg_warning(__func__,"Probably some data could not be saved. "
00596 "Check permisions or disk space");
00597
00598
00599
00600 cpl_frameset_delete(flatframes);
00601 cpl_free(labels);
00602
00603
00604 if (cpl_error_get_code()) return -1 ;
00605 else return 0;
00606 }
00607
00608
00619
00620 static cpl_imagelist ** hawki_cal_flat_reduce(
00621 cpl_frameset * flatframes,
00622 const char * dark_file,
00623 cpl_table ** raw_flat_stats,
00624 cpl_table ** raw_flat_odd_column_stats,
00625 cpl_table ** raw_flat_even_column_stats,
00626 cpl_table ** raw_flat_odd_row_stats,
00627 cpl_table ** raw_flat_even_row_stats,
00628 cpl_vector ** selected)
00629 {
00630 int nima ;
00631 cpl_image * ima_cur ;
00632 cpl_image * big_ima ;
00633 cpl_image * big_badres ;
00634 cpl_vector * medians[HAWKI_NB_DETECTORS];
00635 cpl_vector * stdevs[HAWKI_NB_DETECTORS];
00636 cpl_vector * sub_medians ;
00637 cpl_imagelist * in_quad ;
00638 cpl_imagelist ** results ;
00639 cpl_imagelist * res_quad[4] ;
00640 cpl_image * err_quad[4] ;
00641 cpl_image * badres_mask[4] ;
00642 cpl_image * flat_image ;
00643 cpl_image * dark ;
00644 cpl_propertylist * plist;
00645 double gradient ;
00646 double flat_dit;
00647 cpl_image * bpmflat;
00648 int j, k ;
00649 int idet;
00650
00651
00652 if (flatframes == NULL) return NULL ;
00653
00654
00655 nima = cpl_frameset_get_size(flatframes) ;
00656 if (nima < 3) {
00657 cpl_msg_error(__func__, "Not enough frames (%d)", nima) ;
00658 return NULL ;
00659 }
00660 for (idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++)
00661 hawki_cal_flat_outputs.norm[idet] = 1.0 ;
00662
00663
00664 cpl_msg_info(__func__, "Compute statistics") ;
00665 cpl_msg_indent_more() ;
00666
00667 for (idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++)
00668 {
00669
00670
00671 cpl_msg_info(__func__, "Chip number %d", idet+1) ;
00672 cpl_msg_info(__func__, "image min max med rms") ;
00673 cpl_msg_info(__func__, "--------------------------------------------") ;
00674 medians[idet] = cpl_vector_new(nima);
00675 stdevs[idet] = cpl_vector_new(nima);
00676 for (j=0 ; j<nima ; j++)
00677 {
00678
00679 ima_cur = hawki_load_image(flatframes, j, idet+1, CPL_TYPE_FLOAT) ;
00680
00681
00682 if(hawki_image_stats_fill_from_image
00683 (raw_flat_stats,
00684 ima_cur,
00685 hawki_cal_flat_config.llx,
00686 hawki_cal_flat_config.lly,
00687 hawki_cal_flat_config.urx,
00688 hawki_cal_flat_config.ury,
00689 idet,
00690 j) !=0 )
00691 {
00692 cpl_msg_error(__func__, "Cannot compute stats on image %d",j+1);
00693 cpl_msg_indent_less() ;
00694 cpl_image_delete(ima_cur);
00695 for (k=0 ; k<=idet ; k++) cpl_vector_delete(medians[k]) ;
00696 for (k=0 ; k<=idet ; k++) cpl_vector_delete(stdevs[k]) ;
00697 return NULL ;
00698 }
00699
00700 if(hawki_cal_flat_config.extra_stats)
00701 {
00702 if(hawki_image_stats_odd_even_column_row_fill_from_image
00703 (raw_flat_odd_column_stats,
00704 raw_flat_even_column_stats,
00705 raw_flat_odd_row_stats,
00706 raw_flat_even_row_stats,
00707 ima_cur,
00708 idet,
00709 j) !=0 )
00710 {
00711 cpl_msg_error(__func__, "Cannot compute extra stats");
00712 cpl_msg_indent_less() ;
00713 cpl_image_delete(ima_cur);
00714 for (k=0 ; k<=idet ; k++) cpl_vector_delete(medians[k]) ;
00715 for (k=0 ; k<=idet ; k++) cpl_vector_delete(stdevs[k]) ;
00716 return NULL ;
00717 }
00718 }
00719 cpl_vector_set(medians[idet], j, cpl_table_get_double
00720 (raw_flat_stats[idet],HAWKI_COL_STAT_MED,j,NULL )) ;
00721 cpl_vector_set(stdevs[idet], j, cpl_table_get_double
00722 (raw_flat_stats[idet],HAWKI_COL_STAT_RMS,j,NULL )) ;
00723 cpl_msg_info(__func__, "%02d %10.2f %10.2f %10.2f %10.2f",
00724 j+1,
00725 cpl_table_get_double(raw_flat_stats[idet],
00726 HAWKI_COL_STAT_MIN,j,NULL ),
00727 cpl_table_get_double(raw_flat_stats[idet],
00728 HAWKI_COL_STAT_MAX,j,NULL ),
00729 cpl_table_get_double(raw_flat_stats[idet],
00730 HAWKI_COL_STAT_MED,j,NULL ),
00731 cpl_table_get_double(raw_flat_stats[idet],
00732 HAWKI_COL_STAT_RMS,j,NULL ));
00733 if (cpl_table_get_double
00734 (raw_flat_stats[idet],HAWKI_COL_STAT_MED,j,NULL ) < 1e-6)
00735 {
00736 cpl_msg_error(__func__, "image %d has negative flux: aborting",
00737 j+1) ;
00738 cpl_msg_indent_less() ;
00739 for (k=0 ; k<=idet ; k++) cpl_vector_delete(medians[k]) ;
00740 for (k=0 ; k<=idet ; k++) cpl_vector_delete(stdevs[k]) ;
00741 return NULL ;
00742 }
00743 cpl_image_delete(ima_cur);
00744 }
00745 cpl_msg_info(__func__, "--------------------------------------------") ;
00746
00747
00748 hawki_cal_flat_outputs.med_min[idet] =
00749 cpl_vector_get_min(medians[idet]);
00750 hawki_cal_flat_outputs.med_max[idet] =
00751 cpl_vector_get_max(medians[idet]);
00752 hawki_cal_flat_outputs.med_avg[idet] =
00753 cpl_vector_get_mean(medians[idet]);
00754 hawki_cal_flat_outputs.med_med[idet] =
00755 cpl_vector_get_median_const(medians[idet]);
00756 hawki_cal_flat_outputs.med_stdev[idet] =
00757 cpl_vector_get_stdev(medians[idet]);
00758
00759
00760 gradient=fabs(hawki_cal_flat_outputs.med_max[idet]/
00761 hawki_cal_flat_outputs.med_min[idet]) ;
00762 if (gradient < 4.0) {
00763
00764 }
00765 }
00766 cpl_msg_indent_less() ;
00767
00768
00769 results = cpl_malloc(4 * sizeof(cpl_imagelist*)) ;
00770 results[0] = cpl_imagelist_new() ;
00771 results[1] = cpl_imagelist_new() ;
00772 results[2] = cpl_imagelist_new() ;
00773 if (hawki_cal_flat_config.second_pass) results[3] = cpl_imagelist_new() ;
00774 else results[3] = NULL ;
00775
00776 cpl_msg_info(__func__, "Compute the flat") ;
00777 cpl_msg_indent_more() ;
00778
00779 for (idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++) {
00780 cpl_msg_info(__func__, "Chip number %d", idet+1) ;
00781 cpl_msg_indent_more() ;
00782
00783
00784 cpl_msg_info(__func__, "Apply the frames selection");
00785 if ((hawki_cal_flat_select(medians[idet],
00786 stdevs[idet],
00787 hawki_cal_flat_config.select_auto,
00788 hawki_cal_flat_config.select_auto_max_bins,
00789 hawki_cal_flat_config.select_min_level[idet],
00790 hawki_cal_flat_config.select_max_level[idet],
00791 hawki_cal_flat_config.select_max_rms[idet],
00792 hawki_cal_flat_config.select_min_nframes,
00793 selected[idet])) == -1)
00794 {
00795 cpl_msg_error(__func__, "Cannot apply the frames selection") ;
00796 cpl_imagelist_delete(results[0]) ;
00797 cpl_imagelist_delete(results[1]) ;
00798 cpl_imagelist_delete(results[2]) ;
00799 if (hawki_cal_flat_config.second_pass)
00800 cpl_imagelist_delete(results[3]) ;
00801 cpl_free(results) ;
00802 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00803 cpl_vector_delete(medians[k]) ;
00804 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00805 cpl_vector_delete(stdevs[k]) ;
00806 return NULL ;
00807 }
00808
00809
00810 sub_medians = hawki_cal_flat_extract_vector
00811 (medians[idet], selected[idet]) ;
00812
00813
00814 for (j=0 ; j<4 ; j++) {
00815
00816 if ((in_quad = hawki_load_quadrants(flatframes, idet+1, j+1,
00817 CPL_TYPE_FLOAT))==NULL) {
00818 cpl_msg_error(__func__, "Cannot load the raw quadrants") ;
00819 cpl_imagelist_delete(results[0]) ;
00820 cpl_imagelist_delete(results[1]) ;
00821 cpl_imagelist_delete(results[2]) ;
00822 if (hawki_cal_flat_config.second_pass)
00823 cpl_imagelist_delete(results[3]) ;
00824 cpl_free(results) ;
00825 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00826 cpl_vector_delete(medians[k]) ;
00827 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00828 cpl_vector_delete(stdevs[k]) ;
00829 cpl_vector_delete(sub_medians) ;
00830 return NULL ;
00831 }
00832
00833
00834 cpl_imagelist_erase(in_quad, selected[idet]);
00835
00836
00837 if (dark_file) {
00838 if (j==0) cpl_msg_info(__func__, "Subtracting dark") ;
00839
00840 if ((dark = hawki_load_quadrant_from_file(dark_file,
00841 idet+1, j+1, CPL_TYPE_FLOAT)) == NULL) {
00842 cpl_msg_error(__func__, "Cannot load the dark quadrants") ;
00843 cpl_imagelist_delete(in_quad) ;
00844 cpl_imagelist_delete(results[0]) ;
00845 cpl_imagelist_delete(results[1]) ;
00846 cpl_imagelist_delete(results[2]) ;
00847 if (hawki_cal_flat_config.second_pass)
00848 cpl_imagelist_delete(results[3]) ;
00849 cpl_free(results) ;
00850 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00851 cpl_vector_delete(medians[k]) ;
00852 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00853 cpl_vector_delete(stdevs[k]) ;
00854 cpl_vector_delete(sub_medians) ;
00855 return NULL ;
00856 }
00857
00858
00859 if ((plist=cpl_propertylist_load
00860 (cpl_frame_get_filename
00861 (cpl_frameset_get_first_const(flatframes)), 0)) == NULL)
00862 {
00863 cpl_msg_error(__func__, "Cannot get header from frame");
00864 cpl_imagelist_delete(in_quad) ;
00865 cpl_imagelist_delete(results[0]) ;
00866 cpl_imagelist_delete(results[1]) ;
00867 cpl_imagelist_delete(results[2]) ;
00868 if (hawki_cal_flat_config.second_pass)
00869 cpl_imagelist_delete(results[3]) ;
00870 cpl_free(results) ;
00871 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00872 cpl_vector_delete(medians[k]) ;
00873 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00874 cpl_vector_delete(stdevs[k]) ;
00875 cpl_vector_delete(sub_medians) ;
00876 cpl_image_delete(dark);
00877 return NULL ;
00878 }
00879 flat_dit = hawki_pfits_get_dit(plist);
00880 cpl_image_multiply_scalar(dark, flat_dit);
00881 cpl_propertylist_delete(plist);
00882
00883
00884 cpl_imagelist_subtract_image(in_quad, dark) ;
00885 cpl_image_delete(dark) ;
00886 if (cpl_error_get_code() != CPL_ERROR_NONE) {
00887 cpl_msg_warning(__func__,"Cannot subtract the dark frame");
00888 cpl_error_reset() ;
00889 }
00890 }
00891
00892
00893 err_quad[j] = cpl_image_duplicate(cpl_imagelist_get(in_quad, 0)) ;
00894 res_quad[j] = cpl_fit_imagelist_polynomial(sub_medians, in_quad,
00895 0, 1, CPL_FALSE, CPL_TYPE_FLOAT, err_quad[j]) ;
00896 if (res_quad[j] == NULL) {
00897 cpl_msg_error(__func__, "Cannot create twilight flat-field") ;
00898 cpl_imagelist_delete(results[0]) ;
00899 cpl_imagelist_delete(results[1]) ;
00900 cpl_imagelist_delete(results[2]) ;
00901 if (hawki_cal_flat_config.second_pass)
00902 cpl_imagelist_delete(results[3]) ;
00903 cpl_free(results) ;
00904 cpl_imagelist_delete(in_quad) ;
00905 for (k=0 ; k<j ; k++) cpl_imagelist_delete(res_quad[k]) ;
00906 for (k=0 ; k<=j ; k++) cpl_image_delete(err_quad[k]) ;
00907 for (k=0 ; k<j ; k++)
00908 if (badres_mask[k]) cpl_image_delete(badres_mask[k]) ;
00909 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00910 cpl_vector_delete(medians[k]) ;
00911 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00912 cpl_vector_delete(stdevs[k]) ;
00913 cpl_vector_delete(sub_medians) ;
00914 return NULL ;
00915 }
00916
00917
00918 badres_mask[j] = NULL ;
00919 if (hawki_cal_flat_config.second_pass) {
00920 if (j==0) cpl_msg_info(__func__,
00921 "Second pass to clean the outliers") ;
00922 if (hawki_cal_flat_clean_outliers(err_quad[j], res_quad[j],
00923 in_quad, sub_medians, &(badres_mask[j])) == -1) {
00924 cpl_msg_error(__func__, "Cannot clean the outliers") ;
00925 cpl_imagelist_delete(results[0]) ;
00926 cpl_imagelist_delete(results[1]) ;
00927 cpl_imagelist_delete(results[2]) ;
00928 cpl_imagelist_delete(results[3]) ;
00929 cpl_free(results) ;
00930 cpl_imagelist_delete(in_quad) ;
00931 for (k=0 ; k<=j ; k++) cpl_imagelist_delete(res_quad[k]) ;
00932 for (k=0 ; k<=j ; k++) cpl_image_delete(err_quad[k]) ;
00933 for (k=0 ; k<=j ; k++) cpl_image_delete(badres_mask[k]) ;
00934 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00935 cpl_vector_delete(medians[k]) ;
00936 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00937 cpl_vector_delete(stdevs[k]) ;
00938 cpl_vector_delete(sub_medians) ;
00939 cpl_msg_indent_less() ;
00940 return NULL ;
00941 }
00942 }
00943 cpl_imagelist_delete(in_quad) ;
00944 }
00945 cpl_vector_delete(sub_medians) ;
00946
00947
00948
00949 big_ima = hawki_rebuild_quadrants(
00950 cpl_imagelist_get(res_quad[0],1),
00951 cpl_imagelist_get(res_quad[1],1),
00952 cpl_imagelist_get(res_quad[2],1),
00953 cpl_imagelist_get(res_quad[3],1)) ;
00954 for (j=0 ; j<4 ; j++) cpl_imagelist_delete(res_quad[j]) ;
00955 cpl_imagelist_set(results[0], big_ima, idet) ;
00956 if (big_ima == NULL) {
00957 cpl_msg_error(__func__, "Cannot rebuild the image") ;
00958 cpl_imagelist_delete(results[0]) ;
00959 cpl_imagelist_delete(results[1]) ;
00960 cpl_imagelist_delete(results[2]) ;
00961 if (hawki_cal_flat_config.second_pass)
00962 cpl_imagelist_delete(results[3]) ;
00963 cpl_free(results) ;
00964 for (j=0 ; j<4 ; j++) cpl_image_delete(err_quad[j]) ;
00965 for (j=0 ; j<4 ; j++)
00966 if (badres_mask[j]) cpl_image_delete(badres_mask[j]) ;
00967 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00968 cpl_vector_delete(medians[k]) ;
00969 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00970 cpl_vector_delete(stdevs[k]) ;
00971 return NULL ;
00972 }
00973
00974
00975 big_ima = hawki_rebuild_quadrants(err_quad[0], err_quad[1],
00976 err_quad[2], err_quad[3]) ;
00977 for (j=0 ; j<4 ; j++) cpl_image_delete(err_quad[j]) ;
00978 if (big_ima == NULL) {
00979 cpl_msg_error(__func__, "Cannot rebuild the image") ;
00980 cpl_imagelist_delete(results[0]) ;
00981 cpl_imagelist_delete(results[1]) ;
00982 cpl_imagelist_delete(results[2]) ;
00983 if (hawki_cal_flat_config.second_pass)
00984 cpl_imagelist_delete(results[3]) ;
00985 cpl_free(results) ;
00986 for (j=0 ; j<4 ; j++)
00987 if (badres_mask[j]) cpl_image_delete(badres_mask[j]) ;
00988 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00989 cpl_vector_delete(medians[k]) ;
00990 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
00991 cpl_vector_delete(stdevs[k]) ;
00992 return NULL ;
00993 }
00994 cpl_imagelist_set(results[1], big_ima, idet) ;
00995
00996
00997 big_badres = hawki_rebuild_quadrants(badres_mask[0], badres_mask[1],
00998 badres_mask[2], badres_mask[3]) ;
00999 if (hawki_cal_flat_config.second_pass) {
01000 for (j=0 ; j<4 ; j++) cpl_image_delete(badres_mask[j]) ;
01001 cpl_imagelist_set(results[3], big_badres, idet) ;
01002 }
01003
01004 if (hawki_cal_flat_config.normalise) {
01005
01006 cpl_msg_info(__func__, "Normalise the flat") ;
01007 flat_image = cpl_imagelist_get(results[0], idet) ;
01008 hawki_cal_flat_outputs.norm[idet] =
01009 cpl_image_get_median(flat_image) ;
01010 cpl_image_divide_scalar
01011 (flat_image, hawki_cal_flat_outputs.norm[idet]);
01012 if (cpl_error_get_code()) {
01013 cpl_msg_error(__func__, "Cannot normalise") ;
01014 cpl_imagelist_delete(results[0]) ;
01015 cpl_imagelist_delete(results[1]) ;
01016 cpl_imagelist_delete(results[2]) ;
01017 if (hawki_cal_flat_config.second_pass)
01018 cpl_imagelist_delete(results[3]) ;
01019 cpl_free(results) ;
01020 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
01021 cpl_vector_delete(medians[k]) ;
01022 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++)
01023 cpl_vector_delete(stdevs[k]) ;
01024 return NULL ;
01025 }
01026 }
01027
01028
01029 cpl_msg_info(__func__, "Compute the BPM from the flat") ;
01030 bpmflat=hawki_compute_flatbpm(cpl_imagelist_get(results[0],idet),
01031 hawki_cal_flat_config.sigma_bpm,
01032 hawki_cal_flat_config.lowval_bpm,
01033 hawki_cal_flat_config.highval_bpm);
01034
01035 cpl_imagelist_set(results[2], bpmflat, idet) ;
01036 hawki_cal_flat_outputs.nb_badpix[idet]=
01037 (int)cpl_image_get_flux(bpmflat);
01038
01039 cpl_msg_indent_less() ;
01040 }
01041 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++) cpl_vector_delete(medians[k]) ;
01042 for (k=0 ; k<HAWKI_NB_DETECTORS ; k++) cpl_vector_delete(stdevs[k]) ;
01043 cpl_msg_indent_less() ;
01044
01045 return results ;
01046 }
01047
01048
01058
01059 static int hawki_cal_flat_clean_outliers(
01060 cpl_image * error,
01061 cpl_imagelist * fit_res,
01062 cpl_imagelist * raw,
01063 cpl_vector * medians,
01064 cpl_image ** recomp_mask)
01065 {
01066 cpl_mask * recompute ;
01067 cpl_binary * precompute ;
01068 double med, stdev, threshold1, threshold2 ;
01069 int nx, ny, pos, nbad, nima, out, ind, pix ;
01070 cpl_image * cur_ima ;
01071 float * pimaf ;
01072 double val, fit_val, a, b, max ;
01073 cpl_vector * z_pix ;
01074 double * pz_pix ;
01075 cpl_image * onepix ;
01076 cpl_vector * med_purged ;
01077 cpl_imagelist * raw_purged ;
01078 cpl_imagelist * fit_one ;
01079 cpl_image * err_one ;
01080 int i, j, k ;
01081
01082
01083 if (error == NULL) return -1 ;
01084 if (fit_res == NULL) return -1 ;
01085 if (raw == NULL) return -1 ;
01086
01087
01088 if (recomp_mask) *recomp_mask = NULL ;
01089
01090
01091 med = cpl_image_get_median_dev(error, &stdev) ;
01092 threshold1 = med - hawki_cal_flat_config.sigma_badres * stdev ;
01093 threshold2 = med + hawki_cal_flat_config.sigma_badres * stdev ;
01094 recompute = cpl_mask_threshold_image_create(error,threshold1,threshold2) ;
01095 cpl_mask_not(recompute) ;
01096
01097 if ((nbad=cpl_mask_count(recompute)) == 0) {
01098 if (recomp_mask)
01099 *recomp_mask = cpl_image_new_from_mask(recompute) ;
01100 cpl_mask_delete(recompute) ;
01101 return 0 ;
01102 }
01103 nx = cpl_image_get_size_x(error) ;
01104 ny = cpl_image_get_size_y(error) ;
01105 nima = cpl_imagelist_get_size(raw) ;
01106
01107
01108 precompute = cpl_mask_get_data(recompute) ;
01109 for (j=0 ; j<ny ; j++) {
01110 for (i=0 ; i<nx ; i++) {
01111 pos = i + j*nx ;
01112
01113 if (precompute[pos] == CPL_BINARY_1) {
01114
01115 z_pix = cpl_vector_new(nima) ;
01116 for (k=0 ; k<nima ; k++) {
01117 cur_ima = cpl_imagelist_get(fit_res, 0) ;
01118 pimaf = cpl_image_get_data_float(cur_ima) ;
01119 a = pimaf[pos] ;
01120 cur_ima = cpl_imagelist_get(fit_res, 1) ;
01121 pimaf = cpl_image_get_data_float(cur_ima) ;
01122 b = pimaf[pos] ;
01123 med = cpl_vector_get(medians, k) ;
01124 fit_val = a + b * med ;
01125 cur_ima = cpl_imagelist_get(raw, k) ;
01126 pimaf = cpl_image_get_data_float(cur_ima) ;
01127 cpl_vector_set(z_pix, k, (double)(pimaf[pos]-fit_val)) ;
01128 }
01129
01130
01131 out = -1 ;
01132 max = -1.0 ;
01133 pz_pix = cpl_vector_get_data(z_pix) ;
01134 for (k=0 ; k<nima ; k++) {
01135 if (fabs(pz_pix[k]) > max) {
01136 max = fabs(pz_pix[k]) ;
01137 out = k ;
01138 }
01139 }
01140 cpl_vector_delete(z_pix) ;
01141
01142
01143 med_purged = cpl_vector_new(nima-1) ;
01144 raw_purged = cpl_imagelist_new() ;
01145 ind = 0 ;
01146 for (k=0 ; k<nima ; k++) {
01147 if (k != out) {
01148
01149 cur_ima = cpl_imagelist_get(raw, k) ;
01150 onepix=cpl_image_extract(cur_ima, i+1, j+1, i+1, j+1) ;
01151 cpl_imagelist_set(raw_purged, onepix, ind) ;
01152
01153 cpl_vector_set(med_purged, ind,
01154 cpl_vector_get(medians, k)) ;
01155 ind ++;
01156 }
01157 }
01158
01159
01160 err_one = cpl_image_duplicate(cpl_imagelist_get(raw_purged,0));
01161 fit_one = cpl_fit_imagelist_polynomial(med_purged, raw_purged,
01162 0, 1, CPL_FALSE, CPL_TYPE_FLOAT, err_one) ;
01163 if (fit_one == NULL) {
01164 cpl_msg_error(__func__, "Cannot fit in second pass") ;
01165 cpl_mask_delete(recompute) ;
01166 cpl_vector_delete(med_purged) ;
01167 cpl_imagelist_delete(raw_purged) ;
01168 cpl_image_delete(err_one) ;
01169 return -1 ;
01170 }
01171 cpl_vector_delete(med_purged) ;
01172 cpl_imagelist_delete(raw_purged) ;
01173
01174
01175 val = cpl_image_get(err_one, 1, 1, &pix) ;
01176 cpl_image_set(error, i+1, j+1, val) ;
01177 cpl_image_delete(err_one) ;
01178
01179 cur_ima = cpl_imagelist_get(fit_one, 0) ;
01180 val = cpl_image_get(cur_ima, 1, 1, &pix) ;
01181 cur_ima = cpl_imagelist_get(fit_res, 0) ;
01182 cpl_image_set(cur_ima, i+1, j+1, val) ;
01183
01184 cur_ima = cpl_imagelist_get(fit_one, 1) ;
01185 val = cpl_image_get(cur_ima, 1, 1, &pix) ;
01186 cur_ima = cpl_imagelist_get(fit_res, 1) ;
01187 cpl_image_set(cur_ima, i+1, j+1, val) ;
01188 cpl_imagelist_delete(fit_one) ;
01189 }
01190 }
01191 }
01192 if (recomp_mask)
01193 *recomp_mask = cpl_image_new_from_mask(recompute) ;
01194 cpl_mask_delete(recompute) ;
01195
01196
01197 if (cpl_error_get_code()) return -1 ;
01198 else return 0 ;
01199 }
01200
01201
01213
01214 static int hawki_cal_flat_save
01215 (cpl_imagelist ** flat,
01216 cpl_table ** raw_flat_stats,
01217 cpl_table ** raw_flat_odd_column_stats,
01218 cpl_table ** raw_flat_even_column_stats,
01219 cpl_table ** raw_flat_odd_row_stats,
01220 cpl_table ** raw_flat_even_row_stats,
01221 cpl_vector ** raw_selected,
01222 int set_nb,
01223 const cpl_frame * bpmdark,
01224 cpl_frameset * flat_frames,
01225 cpl_frameset * calib_frames,
01226 cpl_parameterlist * parlist,
01227 cpl_frameset * set_tot)
01228 {
01229 cpl_propertylist ** qclists ;
01230 cpl_imagelist * bpm ;
01231 const cpl_frame * ref_frame ;
01232 cpl_frameset * used_frames;
01233 char * filename ;
01234 cpl_propertylist * inputlist ;
01235 int ext_nb ;
01236 const char * recipe_name = "hawki_cal_flat" ;
01237 int i ;
01238 int iflat;
01239 int nflat;
01240 int nused;
01241 char key_name[72];
01242
01243
01244 ref_frame = irplib_frameset_get_first_from_group(flat_frames, CPL_FRAME_GROUP_RAW) ;
01245
01246
01247 qclists = cpl_malloc(HAWKI_NB_DETECTORS * sizeof(cpl_propertylist*)) ;
01248 for (i=0 ; i<HAWKI_NB_DETECTORS ; i++) {
01249 qclists[i] = cpl_propertylist_new() ;
01250
01251
01252 nflat = cpl_vector_get_size(raw_selected[i]);
01253 nused = 0;
01254 for(iflat = 0; iflat < nflat; ++iflat)
01255 {
01256 snprintf(key_name, 72, "ESO QC RAW%02d USED", iflat + 1);
01257 cpl_propertylist_append_bool
01258 (qclists[i], key_name,cpl_vector_get(raw_selected[i], iflat));
01259 cpl_table_set_int
01260 (raw_flat_stats[i],HAWKI_COL_STAT_USED, iflat,
01261 cpl_vector_get(raw_selected[i], iflat));
01262 if(hawki_cal_flat_config.extra_stats)
01263 {
01264 cpl_table_set_int
01265 (raw_flat_odd_column_stats[i],HAWKI_COL_STAT_USED, iflat,
01266 cpl_vector_get(raw_selected[i], iflat));
01267 cpl_table_set_int
01268 (raw_flat_even_column_stats[i],HAWKI_COL_STAT_USED, iflat,
01269 cpl_vector_get(raw_selected[i], iflat));
01270 cpl_table_set_int
01271 (raw_flat_odd_row_stats[i],HAWKI_COL_STAT_USED, iflat,
01272 cpl_vector_get(raw_selected[i], iflat));
01273 cpl_table_set_int
01274 (raw_flat_even_row_stats[i],HAWKI_COL_STAT_USED, iflat,
01275 cpl_vector_get(raw_selected[i], iflat));
01276 }
01277 if(cpl_vector_get(raw_selected[i], iflat) == 1)
01278 nused++;
01279 }
01280
01281
01282 cpl_propertylist_append_int(qclists[i], "ESO QC FLAT NBADPIX",
01283 hawki_cal_flat_outputs.nb_badpix[i]);
01284 cpl_propertylist_append_double(qclists[i], "ESO QC FLAT NORM",
01285 hawki_cal_flat_outputs.norm[i]) ;
01286 cpl_propertylist_append_double(qclists[i], "ESO QC FLAT MEDMEAN",
01287 hawki_cal_flat_outputs.med_avg[i]) ;
01288 cpl_propertylist_append_double(qclists[i], "ESO QC FLAT MEDMED",
01289 hawki_cal_flat_outputs.med_med[i]) ;
01290 cpl_propertylist_append_double(qclists[i], "ESO QC FLAT MEDSTDEV",
01291 hawki_cal_flat_outputs.med_stdev[i]) ;
01292 cpl_propertylist_append_double(qclists[i], "ESO QC FLAT MEDMIN",
01293 hawki_cal_flat_outputs.med_min[i]) ;
01294 cpl_propertylist_append_double(qclists[i], "ESO QC FLAT MEDMAX",
01295 hawki_cal_flat_outputs.med_max[i]) ;
01296 cpl_propertylist_append_double(qclists[i], "ESO QC FLAT MEDRANG",
01297 hawki_cal_flat_outputs.med_max[i] -
01298 hawki_cal_flat_outputs.med_min[i]);
01299 cpl_propertylist_append_double(qclists[i], "ESO QC FLAT MEDNRANG",
01300 (hawki_cal_flat_outputs.med_max[i] -
01301 hawki_cal_flat_outputs.med_min[i]) /
01302 hawki_cal_flat_outputs.med_med[i]);
01303 cpl_propertylist_append_int(qclists[i], "ESO QC DATANCOM",
01304 nused) ;
01305
01306
01307 ext_nb = hawki_get_ext_from_detector(
01308 cpl_frame_get_filename(ref_frame), i+1);
01309 inputlist = cpl_propertylist_load_regexp(
01310 cpl_frame_get_filename(ref_frame), ext_nb,
01311 HAWKI_HEADER_EXT_FORWARD, 0) ;
01312 cpl_propertylist_append(qclists[i], inputlist) ;
01313
01314
01315 cpl_propertylist_delete(inputlist) ;
01316 }
01317
01318 hawki_image_stats_stats(raw_flat_stats, qclists);
01319
01320
01321 used_frames = cpl_frameset_duplicate(flat_frames);
01322 for(i = 0; i< cpl_frameset_get_size(calib_frames); ++i)
01323 cpl_frameset_insert(used_frames,
01324 cpl_frame_duplicate(cpl_frameset_get_frame(calib_frames, i)));
01325
01326
01327 filename = cpl_sprintf("hawki_cal_flat_set%02d.fits", set_nb) ;
01328 hawki_imagelist_save(set_tot,
01329 parlist,
01330 used_frames,
01331 flat[0],
01332 recipe_name,
01333 HAWKI_CALPRO_FLAT,
01334 HAWKI_PROTYPE_FLAT,
01335 NULL,
01336 (const cpl_propertylist**)qclists,
01337 filename) ;
01338 cpl_free(filename) ;
01339
01340
01341 filename = cpl_sprintf("hawki_cal_flat_err_set%02d.fits", set_nb) ;
01342 hawki_imagelist_save(set_tot,
01343 parlist,
01344 used_frames,
01345 flat[1],
01346 recipe_name,
01347 HAWKI_CALPRO_FLAT_ERRMAP,
01348 HAWKI_PROTYPE_ERRMAP,
01349 NULL,
01350 (const cpl_propertylist**)qclists,
01351 filename) ;
01352 cpl_free(filename) ;
01353
01354
01355 filename = cpl_sprintf("hawki_cal_flat_bpmflat_set%02d.fits", set_nb) ;
01356 hawki_imagelist_save(set_tot,
01357 parlist,
01358 used_frames,
01359 flat[2],
01360 recipe_name,
01361 HAWKI_CALPRO_BPM_COLD,
01362 HAWKI_PROTYPE_BPM,
01363 NULL,
01364 (const cpl_propertylist**)qclists,
01365 filename) ;
01366 cpl_free(filename) ;
01367
01368 if (flat[3] != NULL) {
01369
01370 filename=cpl_sprintf("hawki_cal_flat_recomputed_set%02d.fits", set_nb) ;
01371 hawki_imagelist_save(set_tot,
01372 parlist,
01373 used_frames,
01374 flat[3],
01375 recipe_name,
01376 HAWKI_CALPRO_FLAT_RECOMPUTED,
01377 HAWKI_PROTYPE_FLAT,
01378 NULL,
01379 (const cpl_propertylist**)qclists,
01380 filename) ;
01381 cpl_free(filename) ;
01382 }
01383
01384
01385 if (bpmdark != NULL) {
01386 if ((bpm = hawki_cal_flat_merge_bpms(bpmdark, flat[2])) == NULL) {
01387 cpl_msg_error(__func__, "Cannot merge bad pixel maps") ;
01388 } else {
01389 filename=cpl_sprintf("hawki_cal_flat_bpm_set%02d.fits", set_nb) ;
01390
01391 hawki_imagelist_save(set_tot,
01392 parlist,
01393 used_frames,
01394 bpm,
01395 recipe_name,
01396 HAWKI_CALPRO_BPM,
01397 HAWKI_PROTYPE_BPM,
01398 NULL,
01399 (const cpl_propertylist**)qclists,
01400 filename) ;
01401 cpl_free(filename) ;
01402 cpl_imagelist_delete(bpm) ;
01403 }
01404 }
01405 cpl_frameset_delete(used_frames);
01406
01407
01408 used_frames = cpl_frameset_duplicate(flat_frames);
01409
01410
01411 filename = cpl_sprintf("hawki_cal_flat_stats_set%02d.fits", set_nb) ;
01412 hawki_tables_save(set_tot,
01413 parlist,
01414 used_frames,
01415 (const cpl_table **)raw_flat_stats,
01416 recipe_name,
01417 HAWKI_CALPRO_FLAT_STATS,
01418 HAWKI_PROTYPE_FLAT_STATS,
01419 NULL,
01420 (const cpl_propertylist **)qclists,
01421 filename) ;
01422 cpl_free(filename) ;
01423
01424 if(hawki_cal_flat_config.extra_stats)
01425 {
01426 filename = cpl_sprintf("hawki_cal_flat_stats_ec_set%02d.fits", set_nb);
01427 hawki_tables_save(set_tot,
01428 parlist,
01429 used_frames,
01430 (const cpl_table **)raw_flat_even_column_stats,
01431 recipe_name,
01432 HAWKI_CALPRO_FLAT_STATS_EVEN_COL,
01433 HAWKI_PROTYPE_FLAT_STATS_EVEN_COL,
01434 NULL,
01435 (const cpl_propertylist **)qclists,
01436 filename) ;
01437 cpl_free(filename) ;
01438 filename = cpl_sprintf("hawki_cal_flat_stats_oc_set%02d.fits", set_nb);
01439 hawki_tables_save(set_tot,
01440 parlist,
01441 used_frames,
01442 (const cpl_table **)raw_flat_odd_column_stats,
01443 recipe_name,
01444 HAWKI_CALPRO_FLAT_STATS_ODD_COL,
01445 HAWKI_PROTYPE_FLAT_STATS_ODD_COL,
01446 NULL,
01447 (const cpl_propertylist **)qclists,
01448 filename) ;
01449 cpl_free(filename) ;
01450 filename = cpl_sprintf("hawki_cal_flat_stats_er_set%02d.fits", set_nb);
01451 hawki_tables_save(set_tot,
01452 parlist,
01453 used_frames,
01454 (const cpl_table **)raw_flat_even_row_stats,
01455 recipe_name,
01456 HAWKI_CALPRO_FLAT_STATS_EVEN_ROW,
01457 HAWKI_PROTYPE_FLAT_STATS_EVEN_ROW,
01458 NULL,
01459 (const cpl_propertylist **)qclists,
01460 filename) ;
01461 cpl_free(filename) ;
01462 filename = cpl_sprintf("hawki_cal_flat_stats_or_set%02d.fits", set_nb);
01463 hawki_tables_save(set_tot,
01464 parlist,
01465 used_frames,
01466 (const cpl_table **)raw_flat_odd_row_stats,
01467 recipe_name,
01468 HAWKI_CALPRO_FLAT_STATS_ODD_ROW,
01469 HAWKI_PROTYPE_FLAT_STATS_ODD_ROW,
01470 NULL,
01471 (const cpl_propertylist **)qclists,
01472 filename) ;
01473 cpl_free(filename) ;
01474 }
01475 cpl_frameset_delete(used_frames);
01476
01477
01478 for (i=0 ; i<HAWKI_NB_DETECTORS ; i++) {
01479 cpl_propertylist_delete(qclists[i]) ;
01480 }
01481 cpl_free(qclists) ;
01482 if (cpl_error_get_code()) return -1 ;
01483 return 0;
01484 }
01485
01486
01493
01494 static int hawki_cal_flat_compare(
01495 const cpl_frame * frame1,
01496 const cpl_frame * frame2)
01497 {
01498 int comparison ;
01499 cpl_propertylist * plist1 ;
01500 cpl_propertylist * plist2 ;
01501 const char * sval1,
01502 * sval2 ;
01503 double dval1, dval2 ;
01504
01505
01506
01507 if (frame1==NULL || frame2==NULL) return -1 ;
01508
01509
01510 if ((plist1=cpl_propertylist_load(cpl_frame_get_filename(frame1),
01511 0)) == NULL) {
01512 cpl_msg_error(__func__, "getting header from reference frame");
01513 return -1 ;
01514 }
01515 if ((plist2=cpl_propertylist_load(cpl_frame_get_filename(frame2),
01516 0)) == NULL) {
01517 cpl_msg_error(__func__, "getting header from reference frame");
01518 cpl_propertylist_delete(plist1) ;
01519 return -1 ;
01520 }
01521
01522
01523 if (cpl_error_get_code()) {
01524 cpl_propertylist_delete(plist1) ;
01525 cpl_propertylist_delete(plist2) ;
01526 return -1 ;
01527 }
01528
01529 comparison = 1 ;
01530
01531
01532 sval1 = hawki_pfits_get_filter(plist1) ;
01533 sval2 = hawki_pfits_get_filter(plist2) ;
01534 if (cpl_error_get_code()) {
01535 cpl_msg_error(__func__, "cannot get the filter");
01536 cpl_propertylist_delete(plist1) ;
01537 cpl_propertylist_delete(plist2) ;
01538 return -1 ;
01539 }
01540 if (strcmp(sval1, sval2)) comparison = 0 ;
01541
01542
01543 dval1 = hawki_pfits_get_dit(plist1) ;
01544 dval2 = hawki_pfits_get_dit(plist2) ;
01545 if (cpl_error_get_code()) {
01546 cpl_msg_error(__func__, "cannot get the DIT");
01547 cpl_propertylist_delete(plist1) ;
01548 cpl_propertylist_delete(plist2) ;
01549 return -1 ;
01550 }
01551 if (fabs(dval1-dval2) > 1e-4) comparison = 0 ;
01552
01553 cpl_propertylist_delete(plist1) ;
01554 cpl_propertylist_delete(plist2) ;
01555 return comparison ;
01556 }
01557
01558
01565
01566 static cpl_imagelist * hawki_cal_flat_merge_bpms
01567 (const cpl_frame * bpm_orig,
01568 cpl_imagelist * bpm_to_merge)
01569 {
01570 cpl_imagelist * merged ;
01571 cpl_imagelist * bpm_orig_im;
01572 cpl_image * tmp ;
01573 int i ;
01574
01575
01576 if (bpm_orig==NULL || bpm_to_merge ==NULL) return NULL ;
01577
01578
01579 merged = cpl_imagelist_new() ;
01580
01581
01582 bpm_orig_im = hawki_load_frame(bpm_orig, CPL_TYPE_INT);
01583 if(bpm_orig_im == NULL)
01584 {
01585 cpl_msg_error(__func__, "Cannot read existing bpm %s",
01586 cpl_frame_get_filename(bpm_orig));
01587 cpl_imagelist_delete(merged);
01588 return NULL;
01589 }
01590
01591
01592 for (i=0 ; i<HAWKI_NB_DETECTORS ; i++) {
01593
01594
01595 tmp = cpl_image_add_create(cpl_imagelist_get(bpm_orig_im, i),
01596 cpl_imagelist_get(bpm_to_merge, i));
01597 cpl_image_multiply(cpl_imagelist_get(bpm_orig_im, i),
01598 cpl_imagelist_get(bpm_to_merge, i));
01599 cpl_image_subtract(tmp, cpl_imagelist_get(bpm_orig_im, i)) ;
01600
01601
01602 cpl_imagelist_set(merged, tmp, i) ;
01603 }
01604
01605
01606 cpl_imagelist_delete(bpm_orig_im);
01607 return merged ;
01608 }
01609
01610
01621
01622 static int hawki_cal_flat_select
01623 (cpl_vector * meds,
01624 cpl_vector * rms,
01625 int auto_flag,
01626 int auto_max_bins,
01627 double min_level,
01628 double max_level,
01629 double max_rms,
01630 int min_nframes,
01631 cpl_vector * selection)
01632 {
01633 double * pselection ;
01634 double * pmeds ;
01635 double * prms ;
01636 int nvals ;
01637 int nsel ;
01638 double first_val, last_val, bin_val, dist, dist_min;
01639 double bin_low_val;
01640 double bin_up_val;
01641 int nbins, ind_closest ;
01642 int ibin;
01643 int ival;
01644
01645
01646 if (meds == NULL) return -1;
01647 if (rms == NULL) return -1;
01648 if (selection == NULL) return -1;
01649 if(cpl_vector_get_size(meds) != cpl_vector_get_size(selection))
01650 {
01651 cpl_msg_error(__func__,
01652 "The meds and selection vectors have not the same size");
01653 return -1;
01654 }
01655
01656
01657 nvals = cpl_vector_get_size(meds);
01658 pmeds = cpl_vector_get_data(meds);
01659 prms = cpl_vector_get_data(rms);
01660 cpl_vector_fill(selection, 1.0);
01661
01662
01663 pselection = cpl_vector_get_data(selection) ;
01664
01665
01666 if (min_level >= 0.0)
01667 {
01668 for (ival=0 ; ival<nvals ; ival++)
01669 {
01670 if (pmeds[ival] < min_level)
01671 pselection[ival] = -1.0 ;
01672 }
01673 }
01674
01675
01676 if (max_level >= 0.0)
01677 {
01678 for (ival=0 ; ival<nvals ; ival++)
01679 {
01680 if (pmeds[ival] > max_level)
01681 pselection[ival] = -1.0 ;
01682 }
01683 }
01684
01685
01686 if (max_rms >= 0.0)
01687 {
01688 for (ival=0 ; ival<nvals ; ival++)
01689 {
01690 if (prms[ival] > max_rms)
01691 pselection[ival] = -1.0 ;
01692 }
01693 }
01694
01695
01696 if (auto_flag)
01697 {
01698
01699 cpl_vector * auto_selection;
01700 auto_selection = cpl_vector_new(nvals);
01701 cpl_vector_fill(auto_selection, -1.0);
01702 cpl_msg_info(__func__, "Automatic dynamic range selection");
01703 first_val = hawki_vector_get_min_select(meds, selection);
01704 last_val = hawki_vector_get_max_select(meds, selection);
01705
01706 nbins = nvals ;
01707 if (auto_max_bins > 0 && auto_max_bins < nvals) nbins = auto_max_bins;
01708 for (ibin=0 ; ibin<nbins ; ibin++)
01709 {
01710 if(ibin == 0)
01711 bin_val = first_val + (last_val-first_val)*(ibin+1)/nbins ;
01712 else if(ibin == nbins - 1)
01713 bin_val = first_val + (last_val-first_val)*(ibin)/nbins ;
01714 else
01715 bin_val = first_val + (last_val-first_val)*(ibin+0.5)/nbins ;
01716 bin_low_val = first_val + (last_val-first_val)*(ibin)/nbins ;
01717 bin_up_val = first_val + (last_val-first_val)*(ibin+1)/nbins ;
01718
01719
01720 dist_min = fabs(pmeds[0] - bin_val) ;
01721 ind_closest = -1;
01722 for (ival=0 ; ival<nvals ; ival++)
01723 {
01724 dist = fabs(pmeds[ival] - bin_val) ;
01725 if (dist < dist_min && pselection[ival] != -1)
01726 {
01727 dist_min = dist;
01728 ind_closest = ival;
01729 }
01730 }
01731 if(ind_closest != -1)
01732 cpl_vector_set(auto_selection, ind_closest, 1.0);
01733 }
01734
01735 cpl_vector_copy(selection, auto_selection);
01736 cpl_vector_delete(auto_selection);
01737 }
01738
01739
01740 nsel = 0;
01741 cpl_msg_indent_more();
01742 for (ival=0 ; ival<nvals ; ival++)
01743 {
01744 if(pselection[ival] != -1)
01745 {
01746 cpl_msg_info(__func__, "Selected frame %d", ival+1) ;
01747 nsel++;
01748 }
01749 }
01750 cpl_msg_indent_less();
01751
01752
01753 if (nsel == 0) {
01754 cpl_msg_error(__func__, "No frame selected. Check selection criteria");
01755 return -1;
01756 }
01757 if (min_nframes >= 0) {
01758 if (nsel < min_nframes) {
01759 cpl_msg_error(__func__, "Not enough selected frames (%d < %d)",
01760 nsel, min_nframes) ;
01761 return -1;
01762 }
01763 }
01764
01765 return 0;
01766 }
01767
01768
01775
01776 static cpl_vector * hawki_cal_flat_extract_vector(
01777 cpl_vector * in,
01778 cpl_vector * selection)
01779 {
01780 int nvals ;
01781 cpl_vector * selected ;
01782 double * pin ;
01783 double * pselection ;
01784 double * pselected ;
01785 int nselected ;
01786 int i ;
01787
01788
01789 if (in == NULL) return NULL ;
01790 if (selection == NULL) return NULL ;
01791
01792
01793 nvals = cpl_vector_get_size(in) ;
01794 nselected = 0 ;
01795 pin = cpl_vector_get_data(in) ;
01796 pselection = cpl_vector_get_data(selection) ;
01797
01798
01799 if (nvals != cpl_vector_get_size(selection)) return NULL ;
01800
01801
01802 for (i=0 ; i<nvals ; i++) {
01803 if (pselection[i] > 0.0) nselected++ ;
01804 }
01805 if (nselected == 0) return NULL ;
01806
01807
01808 selected = cpl_vector_new(nselected) ;
01809 pselected = cpl_vector_get_data(selected) ;
01810
01811 nselected = 0 ;
01812 for (i=0 ; i<nvals ; i++) {
01813 if (pselection[i] > 0.0) {
01814 pselected[nselected] = pin[i] ;
01815 nselected++ ;
01816 }
01817 }
01818 return selected ;
01819 }
01820
01821 static int hawki_cal_flat_retrieve_input_param
01822 (cpl_parameterlist * parlist)
01823 {
01824 const char * sval;
01825 cpl_parameter * par;
01826 int idet;
01827
01828
01829 par = NULL ;
01830 for (idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++) {
01831 hawki_cal_flat_outputs.nb_badpix[idet] = -1 ;
01832 hawki_cal_flat_outputs.med_stdev[idet] = -1.0 ;
01833 hawki_cal_flat_outputs.med_avg[idet] = -1.0 ;
01834 hawki_cal_flat_outputs.med_med[idet] = -1.0 ;
01835 hawki_cal_flat_outputs.med_min[idet] = -1.0 ;
01836 hawki_cal_flat_outputs.med_max[idet] = -1.0 ;
01837 }
01838
01839
01840 par = cpl_parameterlist_find(parlist, "hawki.hawki_cal_flat.zone") ;
01841 sval = cpl_parameter_get_string(par) ;
01842 if (sscanf(sval, "%d,%d,%d,%d",
01843 &hawki_cal_flat_config.llx,
01844 &hawki_cal_flat_config.lly,
01845 &hawki_cal_flat_config.urx,
01846 &hawki_cal_flat_config.ury)!=4)
01847 {
01848 return -1 ;
01849 }
01850 par = cpl_parameterlist_find(parlist, "hawki.hawki_cal_flat.sigma_badres") ;
01851 hawki_cal_flat_config.sigma_badres = cpl_parameter_get_double(par) ;
01852 par = cpl_parameterlist_find(parlist, "hawki.hawki_cal_flat.sigma_bpm") ;
01853 hawki_cal_flat_config.sigma_bpm = cpl_parameter_get_double(par) ;
01854 par = cpl_parameterlist_find(parlist, "hawki.hawki_cal_flat.lowval_bpm") ;
01855 hawki_cal_flat_config.lowval_bpm = cpl_parameter_get_double(par) ;
01856 par = cpl_parameterlist_find(parlist, "hawki.hawki_cal_flat.highval_bpm") ;
01857 hawki_cal_flat_config.highval_bpm = cpl_parameter_get_double(par) ;
01858 par = cpl_parameterlist_find(parlist, "hawki.hawki_cal_flat.normalise") ;
01859 hawki_cal_flat_config.normalise = cpl_parameter_get_bool(par) ;
01860 par = cpl_parameterlist_find(parlist, "hawki.hawki_cal_flat.second_pass") ;
01861 hawki_cal_flat_config.second_pass = cpl_parameter_get_bool(par) ;
01862 par = cpl_parameterlist_find(parlist, "hawki.hawki_cal_flat.select_auto") ;
01863 hawki_cal_flat_config.select_auto = cpl_parameter_get_bool(par) ;
01864 par = cpl_parameterlist_find(parlist,
01865 "hawki.hawki_cal_flat.select_auto_max_bins") ;
01866 hawki_cal_flat_config.select_auto_max_bins = cpl_parameter_get_int(par);
01867 par = cpl_parameterlist_find(parlist,
01868 "hawki.hawki_cal_flat.select_min_level") ;
01869 sval = cpl_parameter_get_string(par);
01870 if (sscanf(sval, "%lf,%lf,%lf,%lf",
01871 &hawki_cal_flat_config.select_min_level[0],
01872 &hawki_cal_flat_config.select_min_level[1],
01873 &hawki_cal_flat_config.select_min_level[2],
01874 &hawki_cal_flat_config.select_min_level[3])!=4)
01875 {
01876 if (sscanf(sval, "%f", &hawki_cal_flat_config.select_min_level[0])!=1)
01877 {
01878 return -1;
01879 }
01880 else
01881 {
01882 hawki_cal_flat_config.select_min_level[1] =
01883 hawki_cal_flat_config.select_min_level[0];
01884 hawki_cal_flat_config.select_min_level[2] =
01885 hawki_cal_flat_config.select_min_level[0];
01886 hawki_cal_flat_config.select_min_level[3] =
01887 hawki_cal_flat_config.select_min_level[0];
01888 }
01889 }
01890 par = cpl_parameterlist_find(parlist,
01891 "hawki.hawki_cal_flat.select_max_level") ;
01892 sval = cpl_parameter_get_string(par);
01893 if (sscanf(sval, "%lf,%lf,%lf,%lf",
01894 &hawki_cal_flat_config.select_max_level[0],
01895 &hawki_cal_flat_config.select_max_level[1],
01896 &hawki_cal_flat_config.select_max_level[2],
01897 &hawki_cal_flat_config.select_max_level[3])!=4)
01898 {
01899 if (sscanf(sval, "%f", &hawki_cal_flat_config.select_max_level[0])!=1)
01900 {
01901 return -1;
01902 }
01903 else
01904 {
01905 hawki_cal_flat_config.select_max_level[1] =
01906 hawki_cal_flat_config.select_max_level[0];
01907 hawki_cal_flat_config.select_max_level[2] =
01908 hawki_cal_flat_config.select_max_level[0];
01909 hawki_cal_flat_config.select_max_level[3] =
01910 hawki_cal_flat_config.select_max_level[0];
01911 }
01912 }
01913 par = cpl_parameterlist_find(parlist,
01914 "hawki.hawki_cal_flat.select_max_rms") ;
01915 sval = cpl_parameter_get_string(par);
01916 if (sscanf(sval, "%lf,%lf,%lf,%lf",
01917 hawki_cal_flat_config.select_max_rms,
01918 hawki_cal_flat_config.select_max_rms+1,
01919 hawki_cal_flat_config.select_max_rms+2,
01920 hawki_cal_flat_config.select_max_rms+3)!=4)
01921 {
01922 if (sscanf(sval, "%f", &hawki_cal_flat_config.select_max_rms[0])!=1)
01923 {
01924 return -1;
01925 }
01926 else
01927 {
01928 hawki_cal_flat_config.select_max_rms[1] =
01929 hawki_cal_flat_config.select_max_rms[0];
01930 hawki_cal_flat_config.select_max_rms[2] =
01931 hawki_cal_flat_config.select_max_rms[0];
01932 hawki_cal_flat_config.select_max_rms[3] =
01933 hawki_cal_flat_config.select_max_rms[0];
01934 }
01935 }
01936 par = cpl_parameterlist_find(parlist,
01937 "hawki.hawki_cal_flat.select_min_nframes") ;
01938 hawki_cal_flat_config.select_min_nframes = cpl_parameter_get_int(par) ;
01939 par = cpl_parameterlist_find(parlist, "hawki.hawki_cal_flat.extra_stats") ;
01940 hawki_cal_flat_config.extra_stats = cpl_parameter_get_bool(par) ;
01941
01942 if(hawki_cal_flat_config.select_auto_max_bins != -1 &&
01943 !hawki_cal_flat_config.select_auto)
01944 {
01945 cpl_msg_error(__func__,"Max bins is only allowed with select_auto");
01946 return -1;
01947 }
01948
01949 return 0;
01950 }