36#include "detmon_ronbias.h"
39#include "irplib_ksigma_clip.h"
40#include "irplib_hist.h"
41#include "irplib_utils.h"
62#define pdist(x1,y1,x2,y2) (((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)))
64#define cpl_drand() ((double)rand()/(double)RAND_MAX)
93 irplib_ronbias_method method_bitmask;
102 cpl_size preoverscan_degree;
111 const char *stacking_method;
113 int stacking_ks_high;
114 int stacking_ks_iter;
123} detmon_ronbias_config;
135detmon_ronbias_retrieve_parlist(
const char *,
137 const cpl_parameterlist *,
141detmon_ronbias_random(
const cpl_imagelist *,
142 const cpl_image *, cpl_propertylist *);
145detmon_ronbias_histo(
const cpl_imagelist *,
146 const cpl_image *, cpl_propertylist *);
149detmon_compute_bias_ron_and_stats_on_preoverscan(
const cpl_imagelist *,
150 cpl_propertylist *, cpl_image **);
153detmon_compute_bias_stats_and_ron_in_region(
const cpl_imagelist *,
154 const cpl_image *, cpl_propertylist *);
157detmon_ronbias_master(
const cpl_imagelist *,
158 cpl_mask **, cpl_mask **, cpl_mask **,
162detmon_ronbias_save(
const cpl_parameterlist *,
167 const cpl_propertylist *,
168 const cpl_propertylist *,
169 const cpl_propertylist *,
170 const cpl_propertylist *,
171 const cpl_propertylist *,
172 const cpl_propertylist *,
173 const cpl_propertylist *,
187detmon_ronbias_dfs_set_groups(cpl_frameset *,
const char *);
190detmon_build_synthetic_from_pre_overscan(
const cpl_image * prescan,
191 const cpl_image * overscan)
195detmon_ronbias_dutycycl(
const cpl_frameset *, cpl_propertylist *);
204irplib_bivector_gen_rect_poisson(
const int *r,
212detmon_ronbias_check_defaults(
const cpl_frameset *,
const int whichext);
233detmon_ronbias_fill_parlist_default(cpl_parameterlist * parlist,
234 const char *recipe_name,
235 const char *pipeline_name)
237 const cpl_error_code error =
238 detmon_ronbias_fill_parlist(parlist, recipe_name, pipeline_name,
262 cpl_ensure_code(!error, error);
264 return cpl_error_get_code();
306detmon_ronbias_fill_parlist(cpl_parameterlist * parlist,
307 const char *recipe_name,
308 const char *pipeline_name,
310 const char * pmethod,
311 const int preoverscan_degree,
312 const int random_nsamples,
313 const int random_sizex,
314 const int random_sizey,
320 const char * stacking_method,
321 const int stacking_ks_low,
322 const int stacking_ks_high,
323 const int stacking_ks_iter,
324 const int master_shift_x,
325 const int master_shift_y,
334 const char * meth_desc_opt =
335 "Method to be used when computing bias. Methods appliable: "
336 "<RANDOM | HISTO | PREOVERSCAN | REGION | ALL>. By default ALL "
337 "methods are applied. More than a method can be chosen; in that "
338 "case selected methods must be separated by a single space and put "
339 "together between inverted commas (ex. --method=\"HISTO REGION\")."
340 "\n RANDOM: Bias is computed as the mean value on a given number "
341 "(--random.nsamples) of boxes (dimensions --random.sizex and "
342 "--random.sizey) randomly taken accross the detector.\n HISTO: "
343 "An histogram of the pixels of the image is built.\n PREOVERSCAN: "
344 "Mean, median and RMS values computed and designated areas. \n "
345 "REGION: Mean, median and RMS values on reference region.";
347 const char * meth_desc_nir =
348 "Method to be used when computing bias. Methods appliable: "
349 "<RANDOM | HISTO | REGION | ALL>. By default ALL "
350 "methods are applied. More than a method can be chosen; in that "
351 "case selected methods must be separated by a single space and put "
352 "together between inverted commas (ex. --method=\"HISTO REGION\")."
353 "\n RANDOM: Bias is computed as the mean value on a given number "
354 "(--random.nsamples) of boxes (dimensions --random.sizex and "
355 "--random.sizey) randomly taken accross the detector.\n HISTO: "
356 "An histogram of the pixels of the image is built.\n "
357 "REGION: Mean, median and RMS values on reference region.";
359 const char * method_desc = opt_nir == OPT ? meth_desc_opt : meth_desc_nir;
361 const cpl_error_code error =
362 detmon_fill_parlist(parlist, recipe_name, pipeline_name, 22,
365 "CPL_TYPE_STRING", method,
368 "Pre-method for RANDOM, HISTO and REGION."
369 "Difference raw frames or not",
370 "CPL_TYPE_STRING", pmethod,
372 "preoverscan.degree",
373 "Degree used for pre-overscan method",
374 "CPL_TYPE_INT", preoverscan_degree,
378 "CPL_TYPE_INT", random_nsamples,
381 "X size of the boxes",
382 "CPL_TYPE_INT", random_sizex,
385 "Y size of the boxes",
386 "CPL_TYPE_INT", random_sizey,
390 "CPL_TYPE_INT", criteria,
393 "x coordinate of the lower-left point "
394 "of the reference region of the frame",
395 "CPL_TYPE_INT", ref_llx,
398 "y coordinate of the lower-left point "
399 "of the reference region of the frame",
400 "CPL_TYPE_INT", ref_lly,
403 "x coordinate of the upper-right point "
404 "of the reference region of the frame",
405 "CPL_TYPE_INT", ref_urx,
408 "y coordinate of the upper-right point "
409 "of the reference region of the frame",
410 "CPL_TYPE_INT", ref_ury,
413 "Method to be used when stacking the master. Posible values < MINMAX | MEAN | MEDIAN | KSIGMA >",
414 "CPL_TYPE_STRING", stacking_method,
417 "Low threshold for kappa-sigma clipping",
418 "CPL_TYPE_INT", stacking_ks_low,
421 "High threshold for kappa-sigma clipping",
422 "CPL_TYPE_INT", stacking_ks_high,
425 "Nb of iterations for kappa-sigma clipping",
426 "CPL_TYPE_INT", stacking_ks_iter,
430 "CPL_TYPE_INT", master_shift_x,
434 "CPL_TYPE_INT", master_shift_y,
437 "x coordinate of the lower-left point "
439 "CPL_TYPE_INT", ron_llx,
442 "y coordinate of the lower-left point "
444 "CPL_TYPE_INT", ron_lly,
447 "x coordinate of the upper-right point "
449 "CPL_TYPE_INT", ron_urx,
452 "y coordinate of the upper-right point "
453 "of the RON frame",
"CPL_TYPE_INT", ron_ury,
456 "Activate the multi-exts option",
457 "CPL_TYPE_INT", exts);
460 cpl_ensure_code(!error, error);
462 return cpl_error_get_code();
467#define DETMON_MAX_PARAM 19
482detmon_ronbias_retrieve_parlist(
const char *pipeline_name,
483 const char *recipe_name,
484 const cpl_parameterlist * parlist,
488 const cpl_parameter *par;
490 char m1[DETMON_MAX_PARAM+1] =
"";
491 char m2[DETMON_MAX_PARAM+1] =
"";
492 char m3[DETMON_MAX_PARAM+1] =
"";
495 par_name = cpl_sprintf(
"%s.%s.method", pipeline_name, recipe_name);
496 assert(par_name != NULL);
497 par = cpl_parameterlist_find_const(parlist, par_name);
498 detmon_ronbias_config.method = cpl_parameter_get_string(par);
501 detmon_ronbias_config.method_bitmask = 0;
503 sscanf(detmon_ronbias_config.method,
504 "%" CPL_STRINGIFY(DETMON_MAX_PARAM)
"s "
505 "%" CPL_STRINGIFY(DETMON_MAX_PARAM)
"s "
506 "%" CPL_STRINGIFY(DETMON_MAX_PARAM)
"s", m1, m2, m3);
508 if(!strcmp(m1,
"RANDOM") || !strcmp(m2,
"RANDOM")
509 || !strcmp(m3,
"RANDOM"))
510 detmon_ronbias_config.method_bitmask += RANDOM;
512 if(!strcmp(m1,
"HISTO") || !strcmp(m2,
"HISTO") || !strcmp(m3,
"HISTO"))
513 detmon_ronbias_config.method_bitmask += HISTO;
515 if(!strcmp(m1,
"PREOVERSCAN") || !strcmp(m2,
"PREOVERSCAN")
516 || !strcmp(m3,
"PREOVERSCAN")) {
517 if (opt_nir == NIR) {
521 cpl_msg_warning(cpl_func,
"PREOVERSCAN is not appliable for NIR");
523 detmon_ronbias_config.method_bitmask += PREOVERSCAN;
526 if(!strcmp(m1,
"REGION") || !strcmp(m2,
"REGION")
527 || !strcmp(m3,
"REGION"))
528 detmon_ronbias_config.method_bitmask += REGION;
530 if(!strcmp(m1,
"ALL")) {
531 if (opt_nir == OPT) {
532 detmon_ronbias_config.method_bitmask =
533 RANDOM | HISTO | PREOVERSCAN | REGION;
535 detmon_ronbias_config.method_bitmask =
536 RANDOM | HISTO | REGION;
541 par_name = cpl_sprintf(
"%s.%s.pmethod", pipeline_name, recipe_name);
542 assert(par_name != NULL);
543 par = cpl_parameterlist_find_const(parlist, par_name);
544 detmon_ronbias_config.pmethod = cpl_parameter_get_string(par);
548 detmon_ronbias_config.preoverscan_degree =
549 detmon_retrieve_par_int(
"preoverscan.degree", pipeline_name,
550 recipe_name, parlist);
553 detmon_ronbias_config.random_nsamples =
554 detmon_retrieve_par_int(
"random.nsamples", pipeline_name,
555 recipe_name, parlist);
558 detmon_ronbias_config.random_sizex =
559 detmon_retrieve_par_int(
"random.sizex", pipeline_name,
560 recipe_name, parlist);
563 detmon_ronbias_config.random_sizey =
564 detmon_retrieve_par_int(
"random.sizey", pipeline_name,
565 recipe_name, parlist);
568 detmon_ronbias_config.criteria =
569 detmon_retrieve_par_int(
"criteria", pipeline_name, recipe_name,
573 detmon_ronbias_config.ref_llx =
574 detmon_retrieve_par_int(
"ref.llx", pipeline_name, recipe_name,
577 detmon_ronbias_config.ref_lly =
578 detmon_retrieve_par_int(
"ref.lly", pipeline_name, recipe_name,
581 detmon_ronbias_config.ref_urx =
582 detmon_retrieve_par_int(
"ref.urx", pipeline_name, recipe_name,
585 detmon_ronbias_config.ref_ury =
586 detmon_retrieve_par_int(
"ref.ury", pipeline_name, recipe_name,
591 cpl_sprintf(
"%s.%s.stacking.method", pipeline_name, recipe_name);
592 assert(par_name != NULL);
593 par = cpl_parameterlist_find_const(parlist, par_name);
594 detmon_ronbias_config.stacking_method = cpl_parameter_get_string(par);
598 detmon_ronbias_config.stacking_ks_low =
599 detmon_retrieve_par_int(
"stacking.ks.low", pipeline_name,
600 recipe_name, parlist);
602 detmon_ronbias_config.stacking_ks_high =
603 detmon_retrieve_par_int(
"stacking.ks.high", pipeline_name,
604 recipe_name, parlist);
606 detmon_ronbias_config.stacking_ks_iter =
607 detmon_retrieve_par_int(
"stacking.ks.iter", pipeline_name,
608 recipe_name, parlist);
610 detmon_ronbias_config.master_shift_x =
611 detmon_retrieve_par_int(
"master.shift.x", pipeline_name,
612 recipe_name, parlist);
614 detmon_ronbias_config.master_shift_y =
615 detmon_retrieve_par_int(
"master.shift.y", pipeline_name,
616 recipe_name, parlist);
618 detmon_ronbias_config.ron_llx =
619 detmon_retrieve_par_int(
"ron.llx", pipeline_name, recipe_name,
622 detmon_ronbias_config.ron_lly =
623 detmon_retrieve_par_int(
"ron.lly", pipeline_name, recipe_name,
626 detmon_ronbias_config.ron_urx =
627 detmon_retrieve_par_int(
"ron.urx", pipeline_name, recipe_name,
630 detmon_ronbias_config.ron_ury =
631 detmon_retrieve_par_int(
"ron.ury", pipeline_name, recipe_name,
634 detmon_ronbias_config.exts =
635 detmon_retrieve_par_int(
"exts", pipeline_name, recipe_name,
638 if(cpl_error_get_code()) {
639 cpl_msg_error(cpl_func,
"Failed to retrieve the input parameters");
640 cpl_ensure_code(0, CPL_ERROR_DATA_NOT_FOUND);
644 return CPL_ERROR_NONE;
658detmon_ronbias_check_defaults(
const cpl_frameset * set,
661 const cpl_frame * fr = cpl_frameset_get_position_const(set, 0);
663 cpl_propertylist * plist =
664 cpl_propertylist_load(cpl_frame_get_filename(fr), whichext);
666 const int naxis1 = cpl_propertylist_get_int(plist,
"NAXIS1");
667 const int naxis2 = cpl_propertylist_get_int(plist,
"NAXIS2");
669 if(detmon_ronbias_config.method_bitmask & PREOVERSCAN)
671 const int nx = cpl_propertylist_get_int(plist,
"ESO DET OUT1 NX");
672 const int ny = cpl_propertylist_get_int(plist,
"ESO DET OUT1 NY");
680 cpl_propertylist_get_int(plist,
"ESO DET OUT1 PRSCX");
682 cpl_propertylist_get_int(plist,
"ESO DET OUT1 OVSCX");
684 cpl_error_ensure(cpl_error_get_code() == CPL_ERROR_NONE, cpl_error_get_code(),
goto cleanup,
"error");
686 detmon_ronbias_config.prescan_llx = 1;
687 detmon_ronbias_config.prescan_lly = 1;
688 detmon_ronbias_config.prescan_urx = prscsize;
689 detmon_ronbias_config.prescan_ury = naxis2;
690 detmon_ronbias_config.overscan_llx = naxis1 - ovscsize;
691 detmon_ronbias_config.overscan_lly = 1;
692 detmon_ronbias_config.overscan_urx = naxis1;
693 detmon_ronbias_config.overscan_ury = naxis2;
694 }
else if (naxis2 != ny)
697 cpl_propertylist_get_int(plist,
"ESO DET OUT1 PRSCY");
699 cpl_propertylist_get_int(plist,
"ESO DET OUT1 OVSCY");
700 cpl_error_ensure(cpl_error_get_code() == CPL_ERROR_NONE, cpl_error_get_code(),
goto cleanup,
"error");
702 detmon_ronbias_config.prescan_llx = 1;
703 detmon_ronbias_config.prescan_lly = 1;
704 detmon_ronbias_config.prescan_urx = naxis1;
705 detmon_ronbias_config.prescan_ury = prscsize;
706 detmon_ronbias_config.overscan_llx = 1;
707 detmon_ronbias_config.overscan_lly = naxis2 - ovscsize;
708 detmon_ronbias_config.overscan_urx = naxis1;
709 detmon_ronbias_config.overscan_ury = naxis2;
712 cpl_msg_error(cpl_func,
713 "No PREOVERSCAN areas found");
714 cpl_error_set(cpl_func, CPL_ERROR_NULL_INPUT);
719 if(detmon_ronbias_config.ref_llx == -1)
720 detmon_ronbias_config.ref_llx = naxis1 / 8;
721 if(detmon_ronbias_config.ref_lly == -1)
722 detmon_ronbias_config.ref_lly = naxis2 / 8;
723 if(detmon_ronbias_config.ref_urx == -1)
724 detmon_ronbias_config.ref_urx = naxis1 * 7 / 8;
725 if(detmon_ronbias_config.ref_ury == -1)
726 detmon_ronbias_config.ref_ury = naxis2 * 7 / 8;
728 if(detmon_ronbias_config.ron_llx == -1)
729 detmon_ronbias_config.ron_llx = 1;
730 if(detmon_ronbias_config.ron_lly == -1)
731 detmon_ronbias_config.ron_lly = 1;
732 if(detmon_ronbias_config.ron_urx == -1)
733 detmon_ronbias_config.ron_urx = naxis1;
734 if(detmon_ronbias_config.ron_ury == -1)
735 detmon_ronbias_config.ron_ury = naxis2;
738 cpl_propertylist_delete(plist);
739 return cpl_error_get_code();
770detmon_ronbias(cpl_frameset * frameset,
771 const cpl_parameterlist * parlist,
773 const char *recipe_name,
774 const char *pipeline_name,
775 const char *pafregexp,
776 const cpl_propertylist * pro_master,
777 const cpl_propertylist * pro_xstr,
778 const cpl_propertylist * pro_ystr,
779 const cpl_propertylist * pro_synth,
780 const cpl_propertylist * pro_bpmhot,
781 const cpl_propertylist * pro_bpmcold,
782 const cpl_propertylist * pro_bpmdev,
784 int (*compare) (
const cpl_frame *,
const cpl_frame *),
791 cpl_size * selection = NULL;
792 cpl_frameset * cur_fset = NULL;
793 cpl_propertylist * qclist = NULL;
794 cpl_image * synthetic = NULL;
795 cpl_image * masterbias = NULL;
796 cpl_imagelist * rawbiases = NULL;
797 cpl_mask * bpmhot = NULL;
798 cpl_mask * bpmcold = NULL;
799 cpl_mask * bpmdev = NULL;
802 cpl_ensure_code(frameset != NULL, CPL_ERROR_NULL_INPUT);
803 cpl_ensure_code(parlist != NULL, CPL_ERROR_NULL_INPUT);
804 cpl_ensure_code(tag != NULL, CPL_ERROR_NULL_INPUT);
805 cpl_ensure_code(recipe_name != NULL, CPL_ERROR_NULL_INPUT);
806 cpl_ensure_code(pipeline_name != NULL, CPL_ERROR_NULL_INPUT);
807 cpl_ensure_code(pro_master != NULL, CPL_ERROR_NULL_INPUT);
808 cpl_ensure_code(pro_bpmhot != NULL, CPL_ERROR_NULL_INPUT);
809 cpl_ensure_code(pro_bpmcold != NULL, CPL_ERROR_NULL_INPUT);
810 cpl_ensure_code(pro_bpmdev != NULL, CPL_ERROR_NULL_INPUT);
811 cpl_ensure_code(package != NULL, CPL_ERROR_NULL_INPUT);
813 if(detmon_ronbias_dfs_set_groups(frameset, tag)) {
814 cpl_msg_error(cpl_func,
"Cannot identify RAW and CALIB frames");
830 detmon_ronbias_retrieve_parlist(pipeline_name,
831 recipe_name, parlist, opt_nir);
834 if(detmon_ronbias_config.method_bitmask & PREOVERSCAN)
835 cpl_ensure_code(pro_synth != NULL, CPL_ERROR_NULL_INPUT);
842 cpl_msg_info(cpl_func,
"Identify the different settings");
843 selection = cpl_frameset_labelise(frameset, compare, &nsets);
844 if(selection == NULL)
845 cpl_msg_error(cpl_func,
"Cannot labelise input frames");
849 for(i = 0; i < nsets; i++) {
854 detmon_ronbias_config.nb_extensions = 1;
857 cpl_msg_info(cpl_func,
"Reduce data set nb %d out of %" CPL_SIZE_FORMAT
"",
860 cur_fset = nsets == 1 ?
861 cpl_frameset_duplicate(frameset) :
862 cpl_frameset_extract(frameset, selection, i);
863 skip_if(cur_fset == NULL);
865 if(detmon_ronbias_config.exts > 0) {
866 first_ext = detmon_ronbias_config.exts;
867 last_ext = first_ext + 1;
868 }
else if(detmon_ronbias_config.exts < 0) {
869 const cpl_frame *cur_frame =
870 cpl_frameset_get_position_const(cur_fset, 0);
872 detmon_ronbias_config.nb_extensions =
873 cpl_frame_get_nextensions(cur_frame);
875 last_ext = detmon_ronbias_config.nb_extensions + 1;
878 if (last_ext - first_ext > 1) {
879 skip_if(detmon_ronbias_save(parlist, frameset,
881 pipeline_name, pafregexp,
882 pro_master, pro_xstr,
885 pro_bpmcold, pro_bpmdev,
886 package, NULL, NULL, NULL,
891 for(j = first_ext; j < last_ext; j++) {
894 qclist = cpl_propertylist_new();
897 = cpl_imagelist_load_frameset(cur_fset,
898 CPL_TYPE_FLOAT, 1, j);
899 skip_if(rawbiases == NULL);
901 skip_if(detmon_ronbias_check_defaults(cur_fset, j));
903 skip_if(detmon_ronbias_dutycycl(cur_fset, qclist));
905 masterbias = detmon_ronbias_master(rawbiases,
908 skip_if(masterbias == NULL);
915 if(detmon_ronbias_config.method_bitmask & RANDOM) {
916 skip_if(detmon_ronbias_random(rawbiases, masterbias,
920 if(detmon_ronbias_config.method_bitmask & HISTO) {
921 skip_if(detmon_ronbias_histo(rawbiases, masterbias,
925 if(detmon_ronbias_config.method_bitmask & PREOVERSCAN) {
926 skip_if(detmon_compute_bias_ron_and_stats_on_preoverscan(rawbiases,
928 qclist, &synthetic));
931 if(detmon_ronbias_config.method_bitmask & REGION) {
932 skip_if(detmon_compute_bias_stats_and_ron_in_region(rawbiases,
942 detmon_ronbias_check(qclist);
948 whichext = first_ext > 1 ? 0 : j;
950 skip_if(detmon_ronbias_save(parlist, frameset,
952 pipeline_name, pafregexp,
953 pro_master, pro_xstr,
956 pro_bpmcold, pro_bpmdev,
957 package, masterbias, synthetic,
958 bpmhot, bpmcold, bpmdev,
959 qclist, 0, 0, cur_fset,
962 cpl_image_delete(synthetic);
963 cpl_image_delete(masterbias);
964 cpl_mask_delete(bpmhot);
965 cpl_mask_delete(bpmcold);
966 cpl_mask_delete(bpmdev);
967 cpl_imagelist_delete(rawbiases);
968 cpl_propertylist_delete(qclist);
979 cpl_frameset_delete(cur_fset);
988 cpl_frameset_delete(cur_fset);
990 cpl_image_delete(synthetic);
991 cpl_image_delete(masterbias);
992 cpl_mask_delete(bpmhot);
993 cpl_mask_delete(bpmcold);
994 cpl_mask_delete(bpmdev);
995 cpl_imagelist_delete(rawbiases);
996 cpl_propertylist_delete(qclist);
998 return cpl_error_get_code();
1011static cpl_error_code
1012detmon_ronbias_random(
const cpl_imagelist * rawbiases,
1013 const cpl_image * masterbias,
1014 cpl_propertylist * qclist)
1016 int nraws = cpl_imagelist_get_size(rawbiases);
1018 double bias = DBL_MAX;
1023 (
double *) cpl_malloc(
sizeof(
double) * nraws);
1027 cpl_error_code error = CPL_ERROR_NONE;
1031 if(!strcmp(detmon_ronbias_config.pmethod,
"DIF"))
1036 for(i = 0; i < nraws; i++)
1038 const cpl_image *c1_raw =
1039 cpl_imagelist_get_const(rawbiases, i);
1040 const cpl_image *c2_raw =
1041 cpl_imagelist_get_const(rawbiases, i + 1);
1043 const cpl_image *c_raw = cpl_image_subtract_create(c1_raw,
1045 error = cpl_flux_get_noise_window(c_raw, NULL,
1046 detmon_ronbias_config.random_sizex / 2,
1047 detmon_ronbias_config.random_nsamples,
1048 ron + i, &ron_error);
1049 cpl_image_delete((cpl_image*)c_raw);
1050 if (error != CPL_ERROR_NONE)
1057 for(i = 0; i < nraws; i++)
1059 const cpl_image *c_raw = cpl_imagelist_get_const(rawbiases, i);
1060 skip_if(cpl_flux_get_noise_window(c_raw, NULL,
1061 detmon_ronbias_config.random_sizex / 2,
1062 detmon_ronbias_config.random_nsamples,
1063 ron + i, &ron_error));
1069 if (error == CPL_ERROR_NONE)
1071 irplib_flux_get_bias_window(masterbias, NULL,
1072 detmon_ronbias_config.random_sizex / 2,
1073 detmon_ronbias_config.random_nsamples,
1074 &bias, &bias_error);
1076 v = cpl_vector_wrap(nraws, ron);
1077 stdev = cpl_vector_get_median_const(v);
1078 cpl_vector_unwrap(v);
1081 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_RANDOM_VAL, bias));
1082 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_RANDOM_VAL,
1083 DETMON_QC_BIAS_RANDOM_VAL_C));
1085 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_RANDOM_RON, stdev));
1086 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_RANDOM_RON,
1087 DETMON_QC_BIAS_RANDOM_RON_C));
1090 irplib_flux_get_bias_window(masterbias, NULL,
1091 detmon_ronbias_config.random_sizex / 2,
1092 detmon_ronbias_config.random_nsamples,
1093 &bias, &bias_error);
1095 v = cpl_vector_wrap(nraws, ron);
1098 stdev = cpl_vector_get_median_const(v);
1099 cpl_vector_unwrap(v);
1102 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_RANDOM_VAL, bias);
1103 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_RANDOM_VAL,
1104 DETMON_QC_BIAS_RANDOM_VAL_C);
1107 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_RANDOM_RON, stdev);
1108 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_RANDOM_RON,
1109 DETMON_QC_BIAS_RANDOM_RON_C);
1114 return cpl_error_get_code();
1124static cpl_error_code
1125detmon_ronbias_histo(
const cpl_imagelist * rawbiases,
1126 const cpl_image * masterbias,
1127 cpl_propertylist * qclist)
1129 int nraws = cpl_imagelist_get_size(rawbiases);
1132 double mbias = DBL_MAX;
1133 double mfwhm = DBL_MAX;
1134 double mmax = DBL_MAX;
1139 double mean_fwhm = DBL_MAX;
1141 if(!strcmp(detmon_ronbias_config.pmethod,
"DIF")) nraws--;
1143 fwhms = cpl_vector_new(nraws);
1144 maxs = cpl_vector_new(nraws);
1146 for(i = 0; i < nraws; i++) {
1148 const cpl_image * c_raw;
1149 double bias = DBL_MAX;
1150 double fwhm = DBL_MAX;
1151 double max = DBL_MAX;
1153 if(strcmp(detmon_ronbias_config.pmethod,
"DIF")) {
1154 c_raw = cpl_imagelist_get_const(rawbiases, i);
1156 const cpl_image *c1_raw = cpl_imagelist_get_const(rawbiases, i);
1157 const cpl_image * c2_raw = cpl_imagelist_get_const(rawbiases, i+1);
1158 c_raw = cpl_image_subtract_create(c1_raw, c2_raw);
1161 skip_if(detmon_ronbias_histo_reduce(c_raw, &bias, &fwhm, &max));
1163 skip_if(bias == DBL_MAX || fwhm == DBL_MAX || max == DBL_MAX);
1165 if(!strcmp(detmon_ronbias_config.pmethod,
"DIF"))
1166 cpl_image_delete((cpl_image *)c_raw);
1168 skip_if(cpl_vector_set(maxs, i, max));
1169 skip_if(cpl_vector_set(fwhms, i, fwhm));
1174 skip_if(cpl_vector_divide_scalar(fwhms, CPL_MATH_FWHM_SIG));
1176 detmon_ronbias_histo_reduce(masterbias, &mbias, &mfwhm, &mmax);
1178 skip_if(mbias == DBL_MAX || mfwhm == DBL_MAX || mmax == DBL_MAX);
1180 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_HISTO_VAL,
1182 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_HISTO_VAL,
1183 DETMON_QC_BIAS_HISTO_VAL_C));
1184 mean_fwhm = cpl_vector_get_mean(fwhms);
1186 skip_if(mean_fwhm == DBL_MAX);
1187 skip_if(cpl_error_get_code());
1189 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_HISTO_RON,
1191 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_HISTO_RON,
1192 DETMON_QC_BIAS_HISTO_RON_C));
1196 cpl_vector_delete(fwhms);
1197 cpl_vector_delete(maxs);
1199 return cpl_error_get_code();
1216detmon_ronbias_histo_reduce(
const cpl_image * c_raw,
1223 unsigned long maxwhere = 0;
1226 unsigned long x1a = 1;
1227 unsigned long x2a = 1;
1232 double maxwhere_interp;
1235 cpl_matrix * coeffs =cpl_matrix_new(3, 3);
1236 cpl_matrix * rhs =cpl_matrix_new(3, 1);
1238 cpl_matrix * result = NULL;
1240 dupi = cpl_image_duplicate(c_raw);
1245 hist = irplib_hist_new();
1246 irplib_hist_fill(hist, dupi);
1248 cpl_image_delete(dupi);
1250 irplib_hist_get_max(hist, &maxwhere);
1252 for( p = 0; p< 3; p++){
1253 unsigned long bi = irplib_hist_get_value(hist, maxwhere-1+p);
1254 cpl_matrix_set(rhs, p, 0, bi);
1255 for( q= 0; q< 3; q++) {
1256 cpl_matrix_set(coeffs, p,q,pow((maxwhere-1+p),q));
1260 result = cpl_matrix_solve(coeffs, rhs);
1262 a = cpl_matrix_get(result, 2, 0);
1263 b = cpl_matrix_get(result, 1, 0);
1264 c = cpl_matrix_get(result, 0, 0);
1266 maxwhere_interp = -0.5 * b / (2 * a);
1267 max_interp = -1 * b * b / (4 * a) + c;
1269 cpl_matrix_delete(coeffs);
1270 cpl_matrix_delete(rhs);
1271 cpl_matrix_delete(result);
1274 for(uj = 0; uj < maxwhere; uj++) {
1275 if(irplib_hist_get_value(hist, uj) <= max_interp / 2 &&
1276 irplib_hist_get_value(hist, uj + 1) > max_interp / 2) {
1280 for(uj = maxwhere; uj < irplib_hist_get_nbins(hist)-1; uj++) {
1281 if(irplib_hist_get_value(hist, uj) >= max_interp / 2 &&
1282 irplib_hist_get_value(hist, uj + 1) < max_interp / 2) {
1287 x1 = (max_interp / 2 - irplib_hist_get_value(hist, x1a)) /
1288 (irplib_hist_get_value(hist, x1a + 1) -
1289 irplib_hist_get_value(hist, x1a)) + x1a;
1290 x2 = (max_interp / 2 - irplib_hist_get_value(hist, x2a)) /
1291 (irplib_hist_get_value(hist, x2a + 1) -
1292 irplib_hist_get_value(hist, x2a)) + x2a;
1294 *fwhm = (x2 - x1) * irplib_hist_get_bin_size(hist);
1298 *bias = maxwhere_interp * irplib_hist_get_bin_size(hist) +
1299 irplib_hist_get_start(hist);
1301 irplib_hist_delete(hist);
1303 return cpl_error_get_code();
1317static cpl_error_code
1318detmon_compute_bias_ron_and_stats_on_preoverscan(
const cpl_imagelist * rawbiases,
1319 cpl_propertylist * qclist,
1320 cpl_image ** synthetic)
1326 cpl_vector *meanspre;
1327 cpl_vector *medspre;
1328 cpl_vector *rmsspre;
1329 cpl_vector *meansover;
1330 cpl_vector *medsover;
1331 cpl_vector *rmssover;
1333 cpl_error_code error;
1335 nraws = cpl_imagelist_get_size(rawbiases);
1336 cpl_ensure_code(nraws != -1, CPL_ERROR_ILLEGAL_INPUT);
1338 nx = cpl_image_get_size_x(cpl_imagelist_get_const(rawbiases, 0));
1339 ny = cpl_image_get_size_y(cpl_imagelist_get_const(rawbiases, 0));
1340 cpl_ensure_code(nx != -1 && ny != -1, CPL_ERROR_ILLEGAL_INPUT);
1342 if(nx < detmon_ronbias_config.prescan_urx ||
1343 nx < detmon_ronbias_config.overscan_urx ||
1344 ny < detmon_ronbias_config.prescan_ury ||
1345 ny < detmon_ronbias_config.overscan_ury) {
1346 cpl_msg_warning(cpl_func,
"PREOVERSCAN method not applied. Given "
1347 "limits of prescan and overscan area "
1348 "exceed image size. Please check and rerun.");
1349 return CPL_ERROR_NONE;
1352 meanspre = cpl_vector_new(nraws);
1353 medspre = cpl_vector_new(nraws);
1354 rmsspre = cpl_vector_new(nraws);
1355 meansover = cpl_vector_new(nraws);
1356 medsover = cpl_vector_new(nraws);
1357 rmssover = cpl_vector_new(nraws);
1359 for(i = 0; i < nraws; i++) {
1362 double median_prescan, median_overscan;
1364 cpl_image *prescan = NULL;
1365 cpl_image *overscan = NULL;
1367 const cpl_image *c_raw = cpl_imagelist_get_const(rawbiases, i);
1369 cpl_ensure_code(c_raw != NULL, CPL_ERROR_ILLEGAL_INPUT);
1372 cpl_image_extract(c_raw,
1373 detmon_ronbias_config.prescan_llx,
1374 detmon_ronbias_config.prescan_lly,
1375 detmon_ronbias_config.prescan_urx,
1376 detmon_ronbias_config.prescan_ury);
1377 cpl_ensure_code(prescan != NULL, CPL_ERROR_ILLEGAL_INPUT);
1379 cpl_image_extract(c_raw,
1380 detmon_ronbias_config.overscan_llx,
1381 detmon_ronbias_config.overscan_lly,
1382 detmon_ronbias_config.overscan_urx,
1383 detmon_ronbias_config.overscan_ury);
1384 cpl_ensure_code(overscan != NULL, CPL_ERROR_ILLEGAL_INPUT);
1387 *synthetic = detmon_build_synthetic_from_pre_overscan(prescan,
1389 cpl_msg_info(cpl_func,
"Creating SYNTHETIC frame");
1390 if(*synthetic == NULL) {
1391 cpl_msg_error(cpl_func,
"Error creating SYNTHETIC frame");
1392 return CPL_ERROR_UNSPECIFIED;
1396 median_prescan = cpl_image_get_median(prescan);
1397 median_overscan = cpl_image_get_median(overscan);
1398 cpl_image_delete(prescan);
1399 cpl_image_delete(overscan);
1401 error = irplib_ksigma_clip(c_raw,
1402 detmon_ronbias_config.
1404 detmon_ronbias_config.
1406 detmon_ronbias_config.
1408 detmon_ronbias_config.
1410 (
double) detmon_ronbias_config.
1412 detmon_ronbias_config.
1413 stacking_ks_iter, 1e-5,
1415 cpl_ensure_code(!error, error);
1417 cpl_ensure_code(mean != 0 && stdev != 0, CPL_ERROR_UNSPECIFIED);
1419 error = cpl_vector_set(medspre, i, median_prescan);
1420 cpl_ensure_code(!error, error);
1422 error = cpl_vector_set(meanspre, i, mean);
1423 cpl_ensure_code(!error, error);
1424 error = cpl_vector_set(rmsspre, i, stdev);
1425 cpl_ensure_code(!error, error);
1426 error = irplib_ksigma_clip(c_raw,
1427 detmon_ronbias_config.
1429 detmon_ronbias_config.
1431 detmon_ronbias_config.
1433 detmon_ronbias_config.
1435 (
double) detmon_ronbias_config.
1437 detmon_ronbias_config.
1438 stacking_ks_iter, 1e-5,
1440 cpl_ensure_code(!error, error);
1442 cpl_ensure_code(mean != 0 && stdev != 0, CPL_ERROR_UNSPECIFIED);
1444 error = cpl_vector_set(medsover, i, median_overscan);
1445 cpl_ensure_code(!error, error);
1447 error = cpl_vector_set(meansover, i, mean);
1448 cpl_ensure_code(!error, error);
1449 error = cpl_vector_set(rmssover, i, stdev);
1450 cpl_ensure_code(!error, error);
1454 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_PRESCAN_MEAN,
1455 cpl_vector_get_mean(meanspre));
1457 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_PRESCAN_MEAN,
1458 DETMON_QC_BIAS_PRESCAN_MEAN_C);
1460 cpl_ensure_code(!error, error);
1461 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_PRESCAN_MED,
1462 cpl_vector_get_mean(medspre));
1463 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_PRESCAN_MED,
1464 DETMON_QC_BIAS_PRESCAN_MED_C);
1466 cpl_ensure_code(!error, error);
1467 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_PRESCAN_RON,
1468 cpl_vector_get_mean(rmsspre));
1470 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_PRESCAN_RON,
1471 DETMON_QC_BIAS_PRESCAN_RON_C);
1472 cpl_ensure_code(!error, error);
1475 cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_OVERSCAN_MEAN,
1476 cpl_vector_get_mean(meansover));
1477 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_OVERSCAN_MEAN,
1478 DETMON_QC_BIAS_OVERSCAN_MEAN_C);
1479 cpl_ensure_code(!error, error);
1480 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_OVERSCAN_MED,
1481 cpl_vector_get_mean(medsover));
1482 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_OVERSCAN_MED,
1483 DETMON_QC_BIAS_OVERSCAN_MED_C);
1484 cpl_ensure_code(!error, error);
1485 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_OVERSCAN_RON,
1486 cpl_vector_get_mean(rmssover));
1487 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_OVERSCAN_RON,
1488 DETMON_QC_BIAS_OVERSCAN_RON_C);
1489 cpl_ensure_code(!error, error);
1527 cpl_vector_delete(meanspre);
1528 cpl_vector_delete(medspre);
1529 cpl_vector_delete(rmsspre);
1530 cpl_vector_delete(meansover);
1531 cpl_vector_delete(medsover);
1532 cpl_vector_delete(rmssover);
1534 return CPL_ERROR_NONE;
1548static cpl_error_code
1549detmon_compute_bias_stats_and_ron_in_region(
const cpl_imagelist * rawbiases,
1550 const cpl_image * masterbias,
1551 cpl_propertylist * qclist)
1554 int nraws = cpl_imagelist_get_size(rawbiases);
1558 cpl_image_get_size_x(cpl_imagelist_get_const(rawbiases, 0));
1560 cpl_image_get_size_y(cpl_imagelist_get_const(rawbiases, 0));
1562 cpl_vector *rmssreg;
1563 cpl_error_code error;
1565 const cpl_image * c_raw;
1566 double median, mbias, mstdev;
1568 if(!strcmp(detmon_ronbias_config.pmethod,
"DIF")) nraws--;
1570 rmssreg = cpl_vector_new(nraws);
1572 if(nx < detmon_ronbias_config.ref_urx ||
1573 ny < detmon_ronbias_config.ref_ury) {
1574 cpl_msg_warning(cpl_func,
"REGION method not applied. Given "
1575 "limits of prescan and overscan area "
1576 "exceed image size. Please check and rerun.");
1577 return CPL_ERROR_NONE;
1580 for(i = 0; i < nraws; i++) {
1583 if(strcmp(detmon_ronbias_config.pmethod,
"DIF")) {
1584 c_raw = cpl_imagelist_get_const(rawbiases, i);
1586 const cpl_image *c1_raw = cpl_imagelist_get_const(rawbiases, i);
1587 const cpl_image * c2_raw = cpl_imagelist_get_const(rawbiases, i+1);
1588 c_raw = cpl_image_subtract_create(c1_raw, c2_raw);
1590 error = irplib_ksigma_clip(c_raw,
1591 detmon_ronbias_config.ref_llx,
1592 detmon_ronbias_config.ref_lly,
1593 detmon_ronbias_config.ref_urx,
1594 detmon_ronbias_config.ref_ury,
1595 (
double) detmon_ronbias_config.
1597 detmon_ronbias_config.
1598 stacking_ks_iter, 1e-5,
1600 cpl_ensure_code(!error, error);
1607 error = cpl_vector_set(rmssreg, i, stdev);
1608 cpl_ensure_code(!error, error);
1609 if(!strcmp(detmon_ronbias_config.pmethod,
"DIF")) cpl_image_delete((cpl_image *)c_raw);
1612 median = cpl_image_get_median_window(masterbias,
1613 detmon_ronbias_config.ref_llx,
1614 detmon_ronbias_config.ref_lly,
1615 detmon_ronbias_config.ref_urx,
1616 detmon_ronbias_config.ref_ury);
1617 error = irplib_ksigma_clip(masterbias,
1618 detmon_ronbias_config.ref_llx,
1619 detmon_ronbias_config.ref_lly,
1620 detmon_ronbias_config.ref_urx,
1621 detmon_ronbias_config.ref_ury,
1622 (
double) detmon_ronbias_config.
1624 detmon_ronbias_config.
1625 stacking_ks_iter, 1e-5,
1628 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_REGION_MED,
1630 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_REGION_MED,
1631 DETMON_QC_BIAS_REGION_MED_C);
1632 cpl_ensure_code(!error, error);
1634 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_REGION_VAL,
1636 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_REGION_VAL,
1637 DETMON_QC_BIAS_REGION_VAL_C);
1638 cpl_ensure_code(!error, error);
1639 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_REGION_RON,
1640 cpl_vector_get_mean(rmssreg));
1641 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_REGION_RON,
1642 DETMON_QC_BIAS_REGION_RON_C);
1643 cpl_ensure_code(!error, error);
1650 cpl_vector_delete(rmssreg);
1652 return cpl_error_get_code();
1669detmon_ronbias_master(
const cpl_imagelist * rawbiases,
1670 cpl_mask ** bpmhot, cpl_mask ** bpmcold,
1671 cpl_mask ** bpmdev, cpl_propertylist * qclist)
1675 cpl_image *masterbias = NULL;
1676 double dark_med, stdev_med,lower, upper;
1677 int hotpix_nb, coldpix_nb, devpix_nb;
1678 cpl_image * stdev_im = NULL;
1680 if(!strcmp(detmon_ronbias_config.stacking_method,
"MEAN"))
1681 masterbias = cpl_imagelist_collapse_create(rawbiases);
1682 if(!strcmp(detmon_ronbias_config.stacking_method,
"MINMAX"))
1684 cpl_imagelist_collapse_minmax_create(rawbiases, 0, 10000);
1685 if(!strcmp(detmon_ronbias_config.stacking_method,
"KSIGMA"))
1687 cpl_imagelist_collapse_sigclip_create(rawbiases, 3.0, 3.0, 0.9,
1688 CPL_COLLAPSE_MEAN, NULL);
1689 if(!strcmp(detmon_ronbias_config.stacking_method,
"MEDIAN"))
1690 masterbias = cpl_imagelist_collapse_median_create(rawbiases);
1692 skip_if(masterbias == NULL);
1694 skip_if(irplib_ksigma_clip(masterbias, 1, 1,
1695 cpl_image_get_size_x(masterbias),
1696 cpl_image_get_size_y(masterbias),
1697 (
double) detmon_ronbias_config.
1699 detmon_ronbias_config.
1700 stacking_ks_iter, 1e-5,
1703 if(irplib_isnan(mean))
1704 cpl_msg_error(cpl_func,
"We have an error in mean");
1705 if(irplib_isnan(stdev))
1706 cpl_msg_error(cpl_func,
"We have an error in stdev");
1708 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_MASTER_MEAN,
1710 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_MASTER_MEAN,
1711 DETMON_QC_MASTER_MEAN_C));
1713 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_MASTER_RMS,
1715 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_MASTER_RMS,
1716 DETMON_QC_MASTER_RMS_C));
1719 dark_med = cpl_image_get_median(masterbias);
1721 lower = dark_med - stdev * detmon_ronbias_config.stacking_ks_low;
1722 upper = dark_med + stdev * detmon_ronbias_config.stacking_ks_high;
1725 cpl_mask_delete(*bpmhot);
1726 irplib_check(*bpmhot = cpl_mask_threshold_image_create(masterbias,
1728 "Cannot compute the hot pixel map");
1729 hotpix_nb = cpl_mask_count(*bpmhot);
1733 cpl_mask_delete(*bpmcold);
1734 irplib_check(*bpmcold = cpl_mask_threshold_image_create(masterbias,
1736 "Cannot compute the cold pixel map");
1737 coldpix_nb = cpl_mask_count(*bpmcold);
1741 stdev_im = irplib_imagelist_collapse_stdev_create(rawbiases);
1742 stdev_med = cpl_image_get_median(stdev_im);
1744 skip_if(irplib_ksigma_clip(stdev_im, 1, 1,
1745 cpl_image_get_size_x(stdev_im),
1746 cpl_image_get_size_y(stdev_im),
1747 (
double) detmon_ronbias_config.
1749 detmon_ronbias_config.
1750 stacking_ks_iter, 1e-5,
1753 lower = stdev_med - stdev * detmon_ronbias_config.stacking_ks_low;
1754 upper = stdev_med + stdev * detmon_ronbias_config.stacking_ks_high;
1756 cpl_mask_delete(*bpmdev);
1757 irplib_check(*bpmdev = cpl_mask_threshold_image_create(stdev_im,
1759 "Cannot compute the cold pixel map");
1760 cpl_mask_not(*bpmdev);
1761 devpix_nb = cpl_mask_count(*bpmdev);
1765 skip_if(cpl_propertylist_append_int(qclist,DETMON_QC_NBCOLDPIX,coldpix_nb));
1766 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_NBCOLDPIX,
1767 DETMON_QC_NBCOLDPIX_C));
1769 skip_if(cpl_propertylist_append_int(qclist,DETMON_QC_NBHOTPIX, hotpix_nb));
1770 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_NBHOTPIX,
1771 DETMON_QC_NBHOTPIX_C));
1773 skip_if(cpl_propertylist_append_int(qclist,DETMON_QC_NBDEVPIX, devpix_nb));
1774 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_NBDEVPIX,
1775 DETMON_QC_NBDEVPIX_C));
1779 cpl_image_delete(stdev_im);
1781 if (cpl_error_get_code()) {
1782 cpl_image_delete(masterbias);
1820static cpl_error_code
1821detmon_ronbias_save(
const cpl_parameterlist * parlist,
1822 cpl_frameset * frameset,
1823 const char *recipe_name,
1824 const char *pipeline_name,
1825 const char *pafregexp,
1826 const cpl_propertylist * pro_master,
1827 const cpl_propertylist * pro_xstr,
1828 const cpl_propertylist * pro_ystr,
1829 const cpl_propertylist * pro_synth,
1830 const cpl_propertylist * pro_bpmhot,
1831 const cpl_propertylist * pro_bpmcold,
1832 const cpl_propertylist * pro_bpmdev,
1833 const char *package,
1834 const cpl_image * masterbias,
1835 const cpl_image * synthetic,
1836 const cpl_mask * bpmhot,
1837 const cpl_mask * bpmcold,
1838 const cpl_mask * bpmdev,
1839 cpl_propertylist * qclist,
1840 const int flag_sets,
1841 const int which_set,
1842 cpl_frameset * usedframes,
1846 cpl_frame *ref_frame;
1847 cpl_propertylist *plist = NULL;
1848 char *name_o = NULL;
1850 cpl_propertylist * paflist = NULL;
1851 cpl_propertylist * mainplist = NULL;
1852 cpl_propertylist * xplist = NULL;
1853 cpl_image * image = NULL;
1855 cpl_propertylist * mypro_master =
1856 cpl_propertylist_duplicate(pro_master);
1858 cpl_propertylist * mypro_synth = NULL;
1859 cpl_propertylist * mypro_bpmhot =
1860 cpl_propertylist_duplicate(pro_bpmhot);
1861 cpl_propertylist * mypro_bpmcold =
1862 cpl_propertylist_duplicate(pro_bpmcold);
1863 cpl_propertylist * mypro_bpmdev =
1864 cpl_propertylist_duplicate(pro_bpmdev);
1866 cpl_ensure_code(parlist != NULL, CPL_ERROR_NULL_INPUT);
1867 cpl_ensure_code(frameset != NULL, CPL_ERROR_NULL_INPUT);
1868 cpl_ensure_code(pafregexp != NULL, CPL_ERROR_NULL_INPUT);
1869 cpl_ensure_code(package != NULL, CPL_ERROR_NULL_INPUT);
1870 cpl_ensure_code(recipe_name != NULL, CPL_ERROR_NULL_INPUT);
1871 cpl_ensure_code(pipeline_name != NULL, CPL_ERROR_NULL_INPUT);
1872 cpl_ensure_code(usedframes != NULL, CPL_ERROR_NULL_INPUT);
1875 mypro_synth = cpl_propertylist_duplicate(pro_synth);
1878 cpl_ensure_code(pro_xstr == NULL && pro_ystr == NULL,
1879 CPL_ERROR_UNSUPPORTED_MODE);
1882 if (detmon_ronbias_config.exts < 0) {
1883 const char * filename =
1884 cpl_frame_get_filename(cpl_frameset_get_position(frameset, 0));
1887 xplist = cpl_propertylist_load_regexp(filename, whichext,
1889 skip_if(cpl_propertylist_append(xplist, qclist));
1892 cpl_msg_info(cpl_func,
"dealing with extention %d",whichext);
1896 ref_frame = cpl_frameset_get_position(frameset, 0);
1897 skip_if(ref_frame == NULL);
1899 skip_if((mainplist =
1900 cpl_propertylist_load(cpl_frame_get_filename(ref_frame),
1909 name_o = cpl_sprintf(
"%s_masterbias.fits", recipe_name);
1910 assert(name_o != NULL);
1913 cpl_sprintf(
"%s_masterbias_set%02d.fits", recipe_name,
1915 assert(name_o != NULL);
1918 if (whichext == 0) {
1919 cpl_propertylist_append(mypro_master, qclist);
1921 skip_if(cpl_dfs_save_image(frameset, NULL, parlist, usedframes, NULL,
1922 masterbias, CPL_BPP_IEEE_FLOAT, recipe_name,
1923 mypro_master, NULL, package, name_o));
1925 skip_if(cpl_image_save(masterbias,
1926 name_o, CPL_BPP_IEEE_FLOAT, xplist,
1939 name_o = cpl_sprintf(
"%s_hotpixmap.fits", recipe_name);
1940 assert(name_o != NULL);
1943 cpl_sprintf(
"%s_hotpixmap_set%02d.fits", recipe_name,
1945 assert(name_o != NULL);
1949 image = cpl_image_new_from_mask(bpmhot);
1952 if (whichext == 0) {
1953 cpl_propertylist_append(mypro_bpmhot, qclist);
1955 skip_if(cpl_dfs_save_image(frameset, NULL, parlist, usedframes, NULL,
1956 image, CPL_BPP_IEEE_FLOAT, recipe_name,
1957 mypro_bpmhot, NULL, package, name_o));
1959 skip_if(cpl_image_save(image,
1960 name_o, CPL_BPP_IEEE_FLOAT, xplist,
1965 cpl_image_delete(image);
1975 name_o = cpl_sprintf(
"%s_coldpixmap.fits", recipe_name);
1976 assert(name_o != NULL);
1979 cpl_sprintf(
"%s_coldpixmap_set%02d.fits", recipe_name,
1981 assert(name_o != NULL);
1985 image = cpl_image_new_from_mask(bpmcold);
1988 if (whichext == 0) {
1989 cpl_propertylist_append(mypro_bpmcold, qclist);
1991 skip_if(cpl_dfs_save_image(frameset, NULL, parlist, usedframes, NULL,
1992 image, CPL_BPP_IEEE_FLOAT, recipe_name,
1993 mypro_bpmcold, NULL, package, name_o));
1995 skip_if(cpl_image_save(image,
1996 name_o, CPL_BPP_IEEE_FLOAT, xplist,
2001 cpl_image_delete(image);
2011 name_o = cpl_sprintf(
"%s_devpixmap.fits", recipe_name);
2012 assert(name_o != NULL);
2015 cpl_sprintf(
"%s_devpixmap_set%02d.fits", recipe_name,
2017 assert(name_o != NULL);
2021 image = cpl_image_new_from_mask(bpmdev);
2024 if (whichext == 0) {
2025 cpl_propertylist_append(mypro_bpmdev, qclist);
2027 skip_if(cpl_dfs_save_image(frameset, NULL,parlist, usedframes, NULL,
2028 image, CPL_BPP_IEEE_FLOAT, recipe_name,
2029 mypro_bpmdev, NULL, package, name_o));
2031 skip_if(cpl_image_save(image,
2032 name_o, CPL_BPP_IEEE_FLOAT, xplist,
2037 cpl_image_delete(image);
2044 if(detmon_ronbias_config.method_bitmask & PREOVERSCAN) {
2047 name_o = cpl_sprintf(
"%s_synthetic.fits", recipe_name);
2048 assert(name_o != NULL);
2051 cpl_sprintf(
"%s_synthetic_set%02d.fits", recipe_name,
2053 assert(name_o != NULL);
2056 if (whichext == 0) {
2058 cpl_propertylist_append(mypro_synth, qclist);
2060 skip_if(cpl_dfs_save_image(frameset, NULL, parlist, usedframes,
2061 NULL,synthetic, CPL_BPP_IEEE_DOUBLE,
2062 recipe_name, mypro_synth, NULL,
2065 skip_if(cpl_image_save(synthetic, name_o, CPL_BPP_IEEE_FLOAT,
2066 xplist, CPL_IO_EXTEND));
2077 paflist = cpl_propertylist_new();
2080 if(detmon_ronbias_config.exts >= 0) {
2082 cpl_propertylist_load(cpl_frame_get_filename(ref_frame),
2083 detmon_ronbias_config.exts)) == NULL);
2086 name_o = cpl_sprintf(
"%s.paf", recipe_name);
2087 assert(name_o != NULL);
2089 name_o = cpl_sprintf(
"%s_set%02d.paf",
2090 recipe_name, which_set);
2091 assert(name_o != NULL);
2095 cpl_propertylist_load(cpl_frame_get_filename(ref_frame),
2096 whichext)) == NULL);
2100 name_o = cpl_sprintf(
"%s_ext%02d.paf",
2101 recipe_name, whichext);
2102 assert(name_o != NULL);
2104 name_o = cpl_sprintf(
"%s_set%02d_ext%02d.paf",
2106 which_set, whichext);
2107 assert(name_o != NULL);
2112 skip_if(cpl_propertylist_copy_property_regexp(paflist, plist,
2114 skip_if(cpl_propertylist_copy_property_regexp(paflist, mainplist,
2117 skip_if(cpl_propertylist_append(paflist, qclist));
2120 skip_if(cpl_dfs_save_paf(pipeline_name, recipe_name, paflist, name_o));
2126 cpl_propertylist_delete(plist);
2127 cpl_propertylist_delete(paflist);
2128 cpl_propertylist_delete(mainplist);
2129 cpl_propertylist_delete(xplist);
2131 cpl_image_delete(image);
2133 cpl_propertylist_delete(mypro_master);
2134 cpl_propertylist_delete(mypro_synth);
2135 cpl_propertylist_delete(mypro_bpmhot);
2136 cpl_propertylist_delete(mypro_bpmcold);
2137 cpl_propertylist_delete(mypro_bpmdev);
2139 return cpl_error_get_code();
2151detmon_ronbias_dfs_set_groups(cpl_frameset * set,
const char *tag)
2163 nframes = cpl_frameset_get_size(set);
2166 for(i = 0; i < nframes; i++) {
2167 cpl_frame* cur_frame = cpl_frameset_get_position(set, i);
2168 const char* cur_tag = cpl_frame_get_tag(cur_frame);
2171 if(!strcmp(cur_tag, tag))
2172 cpl_frame_set_group(cur_frame, CPL_FRAME_GROUP_RAW);
2195detmon_build_synthetic_from_pre_overscan(
const cpl_image * prescan,
2196 const cpl_image * overscan)
2200 int distance = detmon_ronbias_config.overscan_urx -
2201 detmon_ronbias_config.prescan_llx + 1;
2203 double * mean_x = (
double *) cpl_malloc(
sizeof(
double) * distance);
2205 double * xvalues = (
double *) cpl_malloc(
sizeof(
double) * distance);
2207 cpl_vector *x = NULL;
2208 cpl_vector *y = NULL;
2210 cpl_polynomial *poly = NULL;
2211 cpl_polynomial *poly2 = NULL;
2213 cpl_matrix * samppos;
2215 cpl_size pows[2] = { 0, 0 };
2217 cpl_image * synthetic = NULL;
2222 for(j = 0; j < distance; j++) {
2227 for(j = 0; j < cpl_image_get_size_x(prescan); j++) {
2229 cpl_image_get_mean_window(prescan, j + 1, 1, j + 1,
2230 cpl_image_get_size_y(prescan));
2233 for(j = 0; j < cpl_image_get_size_x(overscan); j++) {
2234 *(mean_x + distance - cpl_image_get_size_x(overscan) + j) =
2235 cpl_image_get_mean_window(overscan, j + 1, 1, j + 1,
2236 cpl_image_get_size_y(overscan));
2239 x = cpl_vector_wrap(distance, xvalues);
2240 y = cpl_vector_wrap(distance, mean_x);
2242 poly = cpl_polynomial_new(1);
2244 cpl_matrix_wrap(1, cpl_vector_get_size(x), cpl_vector_get_data(x));
2246 cpl_polynomial_fit(poly, samppos, NULL, y, NULL,
2247 CPL_FALSE, NULL, &detmon_ronbias_config.preoverscan_degree);
2249 cpl_matrix_unwrap(samppos);
2251 cpl_vector_unwrap(x);
2252 cpl_vector_unwrap(y);
2259 poly2 = cpl_polynomial_new(2);
2262 cpl_polynomial_set_coeff(poly2, pows, cpl_polynomial_get_coeff(poly, &j));
2266 cpl_polynomial_set_coeff(poly2, pows, cpl_polynomial_get_coeff(poly, &j));
2268 cpl_polynomial_delete(poly);
2271 cpl_image_new(distance, cpl_image_get_size_y(prescan),
2274 if(cpl_image_fill_polynomial(synthetic, poly2, initial, 1, 1, 1)) {
2275 cpl_msg_error(cpl_func,
"Error creating the synthetic frame");
2276 cpl_polynomial_delete(poly2);
2280 cpl_polynomial_delete(poly2);
2295static cpl_error_code
2296detmon_ronbias_dutycycl(
const cpl_frameset * frameset,
2297 cpl_propertylist * qclist)
2299 const cpl_frame *first = 0;
2300 cpl_propertylist *plistfirst = 0;
2303 const cpl_frame *last = 0;
2304 cpl_propertylist *plistlast = 0;
2307 cpl_error_code error;
2309 first = cpl_frameset_get_position_const(frameset, 0);
2310 plistfirst = cpl_propertylist_load(cpl_frame_get_filename(first), 0);
2311 tfirst = cpl_propertylist_get_double(plistfirst,
"MJD-OBS");
2312 nraws = cpl_frameset_get_size(frameset);
2313 last = cpl_frameset_get_position_const(frameset, nraws - 1);
2314 plistlast = cpl_propertylist_load(cpl_frame_get_filename(last), 0);
2315 tlast = cpl_propertylist_get_double(plistlast,
"MJD-OBS");
2316 dutycycl = (tlast - tfirst) / (nraws - 1);
2318 error = cpl_error_get_code();
2319 if (error != CPL_ERROR_NONE)
2323 cpl_propertylist_append_double(qclist,DETMON_QC_DUTYCYCL, dutycycl);
2324 error = cpl_propertylist_set_comment(qclist,DETMON_QC_DUTYCYCL,
2325 DETMON_QC_DUTYCYCL_C);
2329 cpl_propertylist_delete(plistfirst);
2330 cpl_propertylist_delete(plistlast);
2338#define RECT_RON_HS 4
2339#define RECT_RON_SAMPLES 100
2356irplib_flux_get_bias_window(
const cpl_image * diff,
2357 const int *zone_def,
2359 int ron_nsamp,
double *bias,
double *error)
2361 const int hsize = ron_hsize < 0 ? RECT_RON_HS : ron_hsize;
2362 const int nsamples =
2363 ron_nsamp < 0 ? RECT_RON_SAMPLES : ron_nsamp;
2364 cpl_bivector *sample_reg;
2365 cpl_vector *rms_list;
2374 cpl_ensure_code(diff && bias, CPL_ERROR_NULL_INPUT);
2377 if(zone_def != NULL) {
2378 rect[0] = zone_def[0] + hsize + 1;
2379 rect[1] = zone_def[1] - hsize - 1;
2380 rect[2] = zone_def[2] + hsize + 1;
2381 rect[3] = zone_def[3] - hsize - 1;
2383 rect[0] = hsize + 1;
2384 rect[1] = cpl_image_get_size_x(diff) - hsize - 1;
2385 rect[2] = hsize + 1;
2386 rect[3] = cpl_image_get_size_y(diff) - hsize - 1;
2389 cpl_ensure_code(rect[0] < rect[1] && rect[2] < rect[3],
2390 CPL_ERROR_ILLEGAL_INPUT);
2395 irplib_bivector_gen_rect_poisson(rect, nsamples + 1, nsamples + 1);
2396 cpl_ensure(sample_reg != NULL, CPL_ERROR_ILLEGAL_INPUT,
2397 CPL_ERROR_ILLEGAL_INPUT);
2399 px = cpl_bivector_get_x_data(sample_reg);
2400 py = cpl_bivector_get_y_data(sample_reg);
2404 rms_list = cpl_vector_new(nsamples);
2405 cpl_ensure(rms_list != NULL, CPL_ERROR_NULL_INPUT, CPL_ERROR_NULL_INPUT);
2406 pr = cpl_vector_get_data(rms_list);
2408 for(i = 0; i < nsamples; i++) {
2409 zone[0] = (int) px[i + 1] - hsize;
2410 zone[1] = (int) px[i + 1] + hsize;
2411 zone[2] = (int) py[i + 1] - hsize;
2412 zone[3] = (int) py[i + 1] + hsize;
2413 pr[i] = cpl_image_get_mean_window(diff,
2414 zone[0], zone[2], zone[1], zone[3]);
2416 cpl_bivector_delete(sample_reg);
2420 *error = cpl_vector_get_stdev(rms_list);
2424 *bias = cpl_vector_get_median(rms_list);
2426 cpl_vector_delete(rms_list);
2428 return CPL_ERROR_NONE;
2432#undef RECT_RON_SAMPLES
2445static cpl_bivector *
2446irplib_bivector_gen_rect_poisson(
const int *r,
const int np,
const int homog)
2452 double cand_x, cand_y;
2455 int xmin, xmax, ymin, ymax;
2458 const int homogc = 0 < homog && homog < np ? homog : np;
2463 cpl_ensure(r, CPL_ERROR_NULL_INPUT, NULL);
2464 cpl_ensure(np > 0, CPL_ERROR_ILLEGAL_INPUT, NULL);
2466 list = cpl_bivector_new(np);
2467 cpl_ensure(list, CPL_ERROR_NULL_INPUT, NULL);
2468 px = cpl_bivector_get_x_data(list);
2469 py = cpl_bivector_get_y_data(list);
2477 CPL_MATH_SQRT1_2 * ((xmax - xmin) * (ymax - ymin) / (double) (homogc + 1));
2483 while(gnp < homogc) {
2485 cand_x = cpl_drand() * (xmax - xmin) + xmin;
2486 cand_y = cpl_drand() * (ymax - ymin) + ymin;
2490 for(i = 0; i < gnp; i++) {
2491 if(pdist(cand_x, cand_y, px[i], py[i]) < min_dist) {
2510 cand_x = cpl_drand() * (xmax - xmin) + xmin;
2511 cand_y = cpl_drand() * (ymax - ymin) + ymin;
2515 for(i = 0; i < homogc; i++) {
2518 px[start_ndx + i], py[start_ndx + i]) < min_dist) {
2537 cand_x = cpl_drand() * (xmax - xmin) + xmin;
2538 cand_y = cpl_drand() * (ymax - ymin) + ymin;
2542 for(i = 0; i < homogc; i++) {
2545 px[start_ndx + i], py[start_ndx + i]) < min_dist) {
2584irplib_imagelist_collapse_stdev_create(
const cpl_imagelist * imlist)
2593 cpl_ensure(imlist != NULL, CPL_ERROR_NULL_INPUT, NULL);
2594 cpl_ensure(cpl_imagelist_is_uniform(imlist) == 0, CPL_ERROR_ILLEGAL_INPUT,
2598 cpl_image* mean = cpl_image_duplicate(cpl_imagelist_get_const(imlist, 0));
2599 cpl_image_fill_rejected(mean, 0.0);
2600 cpl_image_accept_all(mean);
2602 cpl_image* stdev = cpl_image_new(cpl_image_get_size_x(mean),
2603 cpl_image_get_size_y(mean),
2606 for (
int i = 1; i < cpl_imagelist_get_size(imlist); i++) {
2607 cpl_image* delta = cpl_image_subtract_create(cpl_imagelist_get_const(imlist, i),
2609 cpl_image_fill_rejected(delta, 0.0);
2610 cpl_image_accept_all(delta);
2612 cpl_image* sq_delta = cpl_image_multiply_create(delta, delta);
2614 cpl_image_multiply_scalar(sq_delta, ((
double) i / (
double)(i+1)));
2615 cpl_image_add(stdev, sq_delta);
2617 cpl_image_divide_scalar(delta, i + 1);
2618 cpl_image_add(mean, delta);
2620 cpl_image_delete(delta);
2621 cpl_image_delete(sq_delta);
2624 cpl_image_divide_scalar(stdev, cpl_imagelist_get_size(imlist) - 1);
2625 cpl_image_power(stdev, 0.5);
2627 cpl_image_delete(mean);