45 #include "detmon_ronbias.h"
47 #include "irplib_ksigma_clip.h"
48 #include "irplib_hist.h"
49 #include "irplib_utils.h"
53 #define pdist(x1,y1,x2,y2) (((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)))
55 #define cpl_drand() ((double)rand()/(double)RAND_MAX)
70 #define HIST_FACT 2.354820045
99 irplib_ronbias_method method_bitmask;
108 cpl_size preoverscan_degree;
117 const char *stacking_method;
119 int stacking_ks_high;
120 int stacking_ks_iter;
129 } detmon_ronbias_config;
140 static cpl_error_code
141 detmon_ronbias_retrieve_parlist(
const char *,
143 const cpl_parameterlist *,
146 static cpl_error_code
147 detmon_ronbias_random(
const cpl_imagelist *,
148 const cpl_image *, cpl_propertylist *);
150 static cpl_error_code
151 detmon_ronbias_histo(
const cpl_imagelist *,
152 const cpl_image *, cpl_propertylist *);
154 static cpl_error_code
155 detmon_compute_bias_ron_and_stats_on_preoverscan(
const cpl_imagelist *,
156 cpl_propertylist *, cpl_image **);
158 static cpl_error_code
159 detmon_compute_bias_stats_and_ron_in_region(
const cpl_imagelist *,
160 const cpl_image *, cpl_propertylist *);
163 detmon_ronbias_master(
const cpl_imagelist *,
164 cpl_mask **, cpl_mask **, cpl_mask **,
167 static cpl_error_code
168 detmon_ronbias_save(
const cpl_parameterlist *,
173 const cpl_propertylist *,
174 const cpl_propertylist *,
175 const cpl_propertylist *,
176 const cpl_propertylist *,
177 const cpl_propertylist *,
178 const cpl_propertylist *,
179 const cpl_propertylist *,
193 detmon_ronbias_dfs_set_groups(cpl_frameset *,
const char *);
196 detmon_build_synthetic_from_pre_overscan(cpl_image * prescan,
197 cpl_image * overscan);
199 static cpl_error_code
200 detmon_ronbias_dutycycl(
const cpl_frameset *, cpl_propertylist *);
208 static cpl_bivector *
209 irplib_bivector_gen_rect_poisson(
const int *r,
217 detmon_ronbias_check_defaults(
const cpl_frameset *,
const int whichext);
238 detmon_ronbias_fill_parlist_default(cpl_parameterlist * parlist,
239 const char *recipe_name,
240 const char *pipeline_name)
242 const cpl_error_code error =
243 detmon_ronbias_fill_parlist(parlist, recipe_name, pipeline_name,
267 cpl_ensure_code(!error, error);
269 return cpl_error_get_code();
311 detmon_ronbias_fill_parlist(cpl_parameterlist * parlist,
312 const char *recipe_name,
313 const char *pipeline_name,
315 const char * pmethod,
316 const int preoverscan_degree,
317 const int random_nsamples,
318 const int random_sizex,
319 const int random_sizey,
325 const char * stacking_method,
326 const int stacking_ks_low,
327 const int stacking_ks_high,
328 const int stacking_ks_iter,
329 const int master_shift_x,
330 const int master_shift_y,
339 const char * meth_desc_opt =
340 "Method to be used when computing bias. Methods appliable: "
341 "<RANDOM | HISTO | PREOVERSCAN | REGION | ALL>. By default ALL "
342 "methods are applied. More than a method can be chosen; in that "
343 "case selected methods must be separated by a single space and put "
344 "together between inverted commas (ex. --method=\"HISTO REGION\")."
345 "\n RANDOM: Bias is computed as the mean value on a given number "
346 "(--random.nsamples) of boxes (dimensions --random.sizex and "
347 "--random.sizey) randomly taken accross the detector.\n HISTO: "
348 "An histogram of the pixels of the image is built.\n PREOVERSCAN: "
349 "Mean, median and RMS values computed and designated areas. \n "
350 "REGION: Mean, median and RMS values on reference region.";
352 const char * meth_desc_nir =
353 "Method to be used when computing bias. Methods appliable: "
354 "<RANDOM | HISTO | REGION | ALL>. By default ALL "
355 "methods are applied. More than a method can be chosen; in that "
356 "case selected methods must be separated by a single space and put "
357 "together between inverted commas (ex. --method=\"HISTO REGION\")."
358 "\n RANDOM: Bias is computed as the mean value on a given number "
359 "(--random.nsamples) of boxes (dimensions --random.sizex and "
360 "--random.sizey) randomly taken accross the detector.\n HISTO: "
361 "An histogram of the pixels of the image is built.\n "
362 "REGION: Mean, median and RMS values on reference region.";
364 const char * method_desc = opt_nir == OPT ? meth_desc_opt : meth_desc_nir;
366 const cpl_error_code error =
367 detmon_fill_parlist(parlist, recipe_name, pipeline_name, 22,
370 "CPL_TYPE_STRING", method,
373 "Pre-method for RANDOM, HISTO and REGION."
374 "Difference raw frames or not",
375 "CPL_TYPE_STRING", pmethod,
377 "preoverscan.degree",
378 "Degree used for pre-overscan method",
379 "CPL_TYPE_INT", preoverscan_degree,
383 "CPL_TYPE_INT", random_nsamples,
386 "X size of the boxes",
387 "CPL_TYPE_INT", random_sizex,
390 "Y size of the boxes",
391 "CPL_TYPE_INT", random_sizey,
395 "CPL_TYPE_INT", criteria,
398 "x coordinate of the lower-left point "
399 "of the reference region of the frame",
400 "CPL_TYPE_INT", ref_llx,
403 "y coordinate of the lower-left point "
404 "of the reference region of the frame",
405 "CPL_TYPE_INT", ref_lly,
408 "x coordinate of the upper-right point "
409 "of the reference region of the frame",
410 "CPL_TYPE_INT", ref_urx,
413 "y coordinate of the upper-right point "
414 "of the reference region of the frame",
415 "CPL_TYPE_INT", ref_ury,
418 "Method to be used when stacking the master. Posible values < MINMAX | MEAN | MEDIAN | KSIGMA >",
419 "CPL_TYPE_STRING", stacking_method,
422 "Low threshold for kappa-sigma clipping",
423 "CPL_TYPE_INT", stacking_ks_low,
426 "High threshold for kappa-sigma clipping",
427 "CPL_TYPE_INT", stacking_ks_high,
430 "Nb of iterations for kappa-sigma clipping",
431 "CPL_TYPE_INT", stacking_ks_iter,
435 "CPL_TYPE_INT", master_shift_x,
439 "CPL_TYPE_INT", master_shift_y,
442 "x coordinate of the lower-left point "
444 "CPL_TYPE_INT", ron_llx,
447 "y coordinate of the lower-left point "
449 "CPL_TYPE_INT", ron_lly,
452 "x coordinate of the upper-right point "
454 "CPL_TYPE_INT", ron_urx,
457 "y coordinate of the upper-right point "
458 "of the RON frame",
"CPL_TYPE_INT", ron_ury,
461 "Activate the multi-exts option",
462 "CPL_TYPE_INT", exts);
465 cpl_ensure_code(!error, error);
467 return cpl_error_get_code();
485 static cpl_error_code
486 detmon_ronbias_retrieve_parlist(
const char *pipeline_name,
487 const char *recipe_name,
488 const cpl_parameterlist * parlist,
499 par_name = cpl_sprintf(
"%s.%s.method", pipeline_name, recipe_name);
500 assert(par_name != NULL);
501 par = cpl_parameterlist_find((cpl_parameterlist *) parlist, par_name);
502 detmon_ronbias_config.method = cpl_parameter_get_string(par);
505 detmon_ronbias_config.method_bitmask = 0;
507 sscanf(detmon_ronbias_config.method,
"%s %s %s", m1, m2, m3);
509 if(!strcmp(m1,
"RANDOM") || !strcmp(m2,
"RANDOM")
510 || !strcmp(m3,
"RANDOM"))
511 detmon_ronbias_config.method_bitmask += RANDOM;
513 if(!strcmp(m1,
"HISTO") || !strcmp(m2,
"HISTO") || !strcmp(m3,
"HISTO"))
514 detmon_ronbias_config.method_bitmask += HISTO;
516 if(!strcmp(m1,
"PREOVERSCAN") || !strcmp(m2,
"PREOVERSCAN")
517 || !strcmp(m3,
"PREOVERSCAN")) {
518 if (opt_nir == NIR) {
522 cpl_msg_warning(cpl_func,
"PREOVERSCAN is not appliable for NIR");
524 detmon_ronbias_config.method_bitmask += PREOVERSCAN;
527 if(!strcmp(m1,
"REGION") || !strcmp(m2,
"REGION")
528 || !strcmp(m3,
"REGION"))
529 detmon_ronbias_config.method_bitmask += REGION;
531 if(!strcmp(m1,
"ALL")) {
532 if (opt_nir == OPT) {
533 detmon_ronbias_config.method_bitmask =
534 RANDOM | HISTO | PREOVERSCAN | REGION;
536 detmon_ronbias_config.method_bitmask =
537 RANDOM | HISTO | REGION;
542 par_name = cpl_sprintf(
"%s.%s.pmethod", pipeline_name, recipe_name);
543 assert(par_name != NULL);
544 par = cpl_parameterlist_find((cpl_parameterlist *) parlist, par_name);
545 detmon_ronbias_config.pmethod = cpl_parameter_get_string(par);
549 detmon_ronbias_config.preoverscan_degree =
550 detmon_retrieve_par_int(
"preoverscan.degree", pipeline_name,
551 recipe_name, parlist);
554 detmon_ronbias_config.random_nsamples =
555 detmon_retrieve_par_int(
"random.nsamples", pipeline_name,
556 recipe_name, parlist);
559 detmon_ronbias_config.random_sizex =
560 detmon_retrieve_par_int(
"random.sizex", pipeline_name,
561 recipe_name, parlist);
564 detmon_ronbias_config.random_sizey =
565 detmon_retrieve_par_int(
"random.sizey", pipeline_name,
566 recipe_name, parlist);
569 detmon_ronbias_config.criteria =
570 detmon_retrieve_par_int(
"criteria", pipeline_name, recipe_name,
574 detmon_ronbias_config.ref_llx =
575 detmon_retrieve_par_int(
"ref.llx", pipeline_name, recipe_name,
578 detmon_ronbias_config.ref_lly =
579 detmon_retrieve_par_int(
"ref.lly", pipeline_name, recipe_name,
582 detmon_ronbias_config.ref_urx =
583 detmon_retrieve_par_int(
"ref.urx", pipeline_name, recipe_name,
586 detmon_ronbias_config.ref_ury =
587 detmon_retrieve_par_int(
"ref.ury", pipeline_name, recipe_name,
592 cpl_sprintf(
"%s.%s.stacking.method", pipeline_name, recipe_name);
593 assert(par_name != NULL);
594 par = cpl_parameterlist_find((cpl_parameterlist *) parlist, par_name);
595 detmon_ronbias_config.stacking_method = cpl_parameter_get_string(par);
599 detmon_ronbias_config.stacking_ks_low =
600 detmon_retrieve_par_int(
"stacking.ks.low", pipeline_name,
601 recipe_name, parlist);
603 detmon_ronbias_config.stacking_ks_high =
604 detmon_retrieve_par_int(
"stacking.ks.high", pipeline_name,
605 recipe_name, parlist);
607 detmon_ronbias_config.stacking_ks_iter =
608 detmon_retrieve_par_int(
"stacking.ks.iter", pipeline_name,
609 recipe_name, parlist);
611 detmon_ronbias_config.master_shift_x =
612 detmon_retrieve_par_int(
"master.shift.x", pipeline_name,
613 recipe_name, parlist);
615 detmon_ronbias_config.master_shift_y =
616 detmon_retrieve_par_int(
"master.shift.y", pipeline_name,
617 recipe_name, parlist);
619 detmon_ronbias_config.ron_llx =
620 detmon_retrieve_par_int(
"ron.llx", pipeline_name, recipe_name,
623 detmon_ronbias_config.ron_lly =
624 detmon_retrieve_par_int(
"ron.lly", pipeline_name, recipe_name,
627 detmon_ronbias_config.ron_urx =
628 detmon_retrieve_par_int(
"ron.urx", pipeline_name, recipe_name,
631 detmon_ronbias_config.ron_ury =
632 detmon_retrieve_par_int(
"ron.ury", pipeline_name, recipe_name,
635 detmon_ronbias_config.exts =
636 detmon_retrieve_par_int(
"exts", pipeline_name, recipe_name,
639 if(cpl_error_get_code()) {
640 cpl_msg_error(cpl_func,
"Failed to retrieve the input parameters");
641 cpl_ensure_code(0, CPL_ERROR_DATA_NOT_FOUND);
645 return CPL_ERROR_NONE;
659 detmon_ronbias_check_defaults(
const cpl_frameset * set,
662 const cpl_frame * fr = cpl_frameset_get_first_const(set);
664 cpl_propertylist * plist =
665 cpl_propertylist_load(cpl_frame_get_filename(fr), whichext);
667 const int naxis1 = cpl_propertylist_get_int(plist,
"NAXIS1");
668 const int naxis2 = cpl_propertylist_get_int(plist,
"NAXIS2");
670 if(detmon_ronbias_config.method_bitmask & PREOVERSCAN)
672 const int nx = cpl_propertylist_get_int(plist,
"ESO DET OUT1 NX");
673 const int ny = cpl_propertylist_get_int(plist,
"ESO DET OUT1 NY");
681 cpl_propertylist_get_int(plist,
"ESO DET OUT1 PRSCX");
683 cpl_propertylist_get_int(plist,
"ESO DET OUT1 OVSCX");
685 cpl_error_ensure(cpl_error_get_code() == CPL_ERROR_NONE, cpl_error_get_code(),
goto cleanup,
"error");
687 detmon_ronbias_config.prescan_llx = 1;
688 detmon_ronbias_config.prescan_lly = 1;
689 detmon_ronbias_config.prescan_urx = prscsize;
690 detmon_ronbias_config.prescan_ury = naxis2;
691 detmon_ronbias_config.overscan_llx = naxis1 - ovscsize;
692 detmon_ronbias_config.overscan_lly = 1;
693 detmon_ronbias_config.overscan_urx = naxis1;
694 detmon_ronbias_config.overscan_ury = naxis2;
695 }
else if (naxis2 != ny)
698 cpl_propertylist_get_int(plist,
"ESO DET OUT1 PRSCY");
700 cpl_propertylist_get_int(plist,
"ESO DET OUT1 OVSCY");
701 cpl_error_ensure(cpl_error_get_code() == CPL_ERROR_NONE, cpl_error_get_code(),
goto cleanup,
"error");
703 detmon_ronbias_config.prescan_llx = 1;
704 detmon_ronbias_config.prescan_lly = 1;
705 detmon_ronbias_config.prescan_urx = naxis1;
706 detmon_ronbias_config.prescan_ury = prscsize;
707 detmon_ronbias_config.overscan_llx = 1;
708 detmon_ronbias_config.overscan_lly = naxis2 - ovscsize;
709 detmon_ronbias_config.overscan_urx = naxis1;
710 detmon_ronbias_config.overscan_ury = naxis2;
713 cpl_msg_error(cpl_func,
714 "No PREOVERSCAN areas found");
715 cpl_error_set(cpl_func, CPL_ERROR_NULL_INPUT);
720 if(detmon_ronbias_config.ref_llx == -1)
721 detmon_ronbias_config.ref_llx = naxis1 / 8;
722 if(detmon_ronbias_config.ref_lly == -1)
723 detmon_ronbias_config.ref_lly = naxis2 / 8;
724 if(detmon_ronbias_config.ref_urx == -1)
725 detmon_ronbias_config.ref_urx = naxis1 * 7 / 8;
726 if(detmon_ronbias_config.ref_ury == -1)
727 detmon_ronbias_config.ref_ury = naxis2 * 7 / 8;
729 if(detmon_ronbias_config.ron_llx == -1)
730 detmon_ronbias_config.ron_llx = 1;
731 if(detmon_ronbias_config.ron_lly == -1)
732 detmon_ronbias_config.ron_lly = 1;
733 if(detmon_ronbias_config.ron_urx == -1)
734 detmon_ronbias_config.ron_urx = naxis1;
735 if(detmon_ronbias_config.ron_ury == -1)
736 detmon_ronbias_config.ron_ury = naxis2;
739 cpl_propertylist_delete(plist);
740 return cpl_error_get_code();
771 detmon_ronbias(cpl_frameset * frameset,
772 const cpl_parameterlist * parlist,
774 const char *recipe_name,
775 const char *pipeline_name,
776 const char *pafregexp,
777 const cpl_propertylist * pro_master,
778 const cpl_propertylist * pro_xstr,
779 const cpl_propertylist * pro_ystr,
780 const cpl_propertylist * pro_synth,
781 const cpl_propertylist * pro_bpmhot,
782 const cpl_propertylist * pro_bpmcold,
783 const cpl_propertylist * pro_bpmdev,
785 int (*compare) (
const cpl_frame *,
const cpl_frame *),
792 cpl_size * selection = NULL;
793 cpl_frameset * cur_fset = NULL;
794 cpl_propertylist * qclist = NULL;
795 cpl_image * synthetic = NULL;
796 cpl_image * masterbias = NULL;
797 cpl_imagelist * rawbiases = NULL;
798 cpl_mask * bpmhot = NULL;
799 cpl_mask * bpmcold = NULL;
800 cpl_mask * bpmdev = NULL;
803 cpl_ensure_code(frameset != NULL, CPL_ERROR_NULL_INPUT);
804 cpl_ensure_code(parlist != NULL, CPL_ERROR_NULL_INPUT);
805 cpl_ensure_code(tag != NULL, CPL_ERROR_NULL_INPUT);
806 cpl_ensure_code(recipe_name != NULL, CPL_ERROR_NULL_INPUT);
807 cpl_ensure_code(pipeline_name != NULL, CPL_ERROR_NULL_INPUT);
808 cpl_ensure_code(pro_master != NULL, CPL_ERROR_NULL_INPUT);
809 cpl_ensure_code(pro_bpmhot != NULL, CPL_ERROR_NULL_INPUT);
810 cpl_ensure_code(pro_bpmcold != NULL, CPL_ERROR_NULL_INPUT);
811 cpl_ensure_code(pro_bpmdev != NULL, CPL_ERROR_NULL_INPUT);
812 cpl_ensure_code(package != NULL, CPL_ERROR_NULL_INPUT);
814 if(detmon_ronbias_dfs_set_groups(frameset, tag)) {
815 cpl_msg_error(cpl_func,
"Cannot identify RAW and CALIB frames");
831 detmon_ronbias_retrieve_parlist(pipeline_name,
832 recipe_name, parlist, opt_nir);
835 if(detmon_ronbias_config.method_bitmask & PREOVERSCAN)
836 cpl_ensure_code(pro_synth != NULL, CPL_ERROR_NULL_INPUT);
843 cpl_msg_info(cpl_func,
"Identify the different settings");
844 selection = cpl_frameset_labelise(frameset, compare, &nsets);
845 if(selection == NULL)
846 cpl_msg_error(cpl_func,
"Cannot labelise input frames");
850 for(i = 0; i < nsets; i++) {
855 detmon_ronbias_config.nb_extensions = 1;
858 cpl_msg_info(cpl_func,
"Reduce data set nb %d out of %" CPL_SIZE_FORMAT
"",
861 cur_fset = nsets == 1 ?
862 cpl_frameset_duplicate(frameset) :
863 cpl_frameset_extract(frameset, selection, i);
864 skip_if(cur_fset == NULL);
866 if(detmon_ronbias_config.exts > 0) {
867 first_ext = detmon_ronbias_config.exts;
868 last_ext = first_ext + 1;
869 }
else if(detmon_ronbias_config.exts < 0) {
870 const cpl_frame *cur_frame =
871 cpl_frameset_get_first_const(cur_fset);
873 detmon_ronbias_config.nb_extensions =
874 cpl_frame_get_nextensions(cur_frame);
876 last_ext = detmon_ronbias_config.nb_extensions + 1;
879 if (last_ext - first_ext > 1) {
880 skip_if(detmon_ronbias_save(parlist, frameset,
882 pipeline_name, pafregexp,
883 pro_master, pro_xstr,
886 pro_bpmcold, pro_bpmdev,
887 package, NULL, NULL, NULL,
892 for(j = first_ext; j < last_ext; j++) {
895 qclist = cpl_propertylist_new();
898 = cpl_imagelist_load_frameset(cur_fset,
899 CPL_TYPE_FLOAT, 1, j);
900 skip_if(rawbiases == NULL);
902 skip_if(detmon_ronbias_check_defaults(cur_fset, j));
904 skip_if(detmon_ronbias_dutycycl(cur_fset, qclist));
906 masterbias = detmon_ronbias_master(rawbiases,
909 skip_if(masterbias == NULL);
916 if(detmon_ronbias_config.method_bitmask & RANDOM) {
917 skip_if(detmon_ronbias_random(rawbiases, masterbias,
921 if(detmon_ronbias_config.method_bitmask & HISTO) {
922 skip_if(detmon_ronbias_histo(rawbiases, masterbias,
926 if(detmon_ronbias_config.method_bitmask & PREOVERSCAN) {
927 skip_if(detmon_compute_bias_ron_and_stats_on_preoverscan(rawbiases,
929 qclist, &synthetic));
932 if(detmon_ronbias_config.method_bitmask & REGION) {
933 skip_if(detmon_compute_bias_stats_and_ron_in_region(rawbiases,
943 detmon_ronbias_check(qclist);
949 whichext = first_ext > 1 ? 0 : j;
951 skip_if(detmon_ronbias_save(parlist, frameset,
953 pipeline_name, pafregexp,
954 pro_master, pro_xstr,
957 pro_bpmcold, pro_bpmdev,
958 package, masterbias, synthetic,
959 bpmhot, bpmcold, bpmdev,
960 qclist, 0, 0, cur_fset,
963 cpl_image_delete(synthetic);
964 cpl_image_delete(masterbias);
965 cpl_mask_delete(bpmhot);
966 cpl_mask_delete(bpmcold);
967 cpl_mask_delete(bpmdev);
968 cpl_imagelist_delete(rawbiases);
969 cpl_propertylist_delete(qclist);
980 cpl_frameset_delete(cur_fset);
989 cpl_frameset_delete(cur_fset);
991 cpl_image_delete(synthetic);
992 cpl_image_delete(masterbias);
993 cpl_mask_delete(bpmhot);
994 cpl_mask_delete(bpmcold);
995 cpl_mask_delete(bpmdev);
996 cpl_imagelist_delete(rawbiases);
997 cpl_propertylist_delete(qclist);
999 return cpl_error_get_code();
1012 static cpl_error_code
1013 detmon_ronbias_random(
const cpl_imagelist * rawbiases,
1014 const cpl_image * masterbias,
1015 cpl_propertylist * qclist)
1017 int nraws = cpl_imagelist_get_size(rawbiases);
1019 double bias = DBL_MAX;
1024 (
double *) cpl_malloc(
sizeof(
double) * nraws);
1028 cpl_error_code error = CPL_ERROR_NONE;
1032 if(!strcmp(detmon_ronbias_config.pmethod,
"DIF"))
1037 for(i = 0; i < nraws; i++)
1039 const cpl_image *c1_raw =
1040 cpl_imagelist_get_const(rawbiases, i);
1041 const cpl_image *c2_raw =
1042 cpl_imagelist_get_const(rawbiases, i + 1);
1044 const cpl_image *c_raw = cpl_image_subtract_create(c1_raw,
1046 error = cpl_flux_get_noise_window(c_raw, NULL,
1047 detmon_ronbias_config.random_sizex / 2,
1048 detmon_ronbias_config.random_nsamples,
1049 ron + i, &ron_error);
1050 cpl_image_delete((cpl_image*)c_raw);
1051 if (error != CPL_ERROR_NONE)
1058 for(i = 0; i < nraws; i++)
1060 const cpl_image *c_raw = cpl_imagelist_get_const(rawbiases, i);
1061 skip_if(cpl_flux_get_noise_window(c_raw, NULL,
1062 detmon_ronbias_config.random_sizex / 2,
1063 detmon_ronbias_config.random_nsamples,
1064 ron + i, &ron_error));
1070 if (error == CPL_ERROR_NONE)
1072 irplib_flux_get_bias_window(masterbias, NULL,
1073 detmon_ronbias_config.random_sizex / 2,
1074 detmon_ronbias_config.random_nsamples,
1075 &bias, &bias_error);
1077 v = cpl_vector_wrap(nraws, ron);
1078 stdev = cpl_vector_get_median_const(v);
1079 cpl_vector_unwrap(v);
1082 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_RANDOM_VAL, bias));
1083 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_RANDOM_VAL,
1084 DETMON_QC_BIAS_RANDOM_VAL_C));
1086 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_RANDOM_RON, stdev));
1087 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_RANDOM_RON,
1088 DETMON_QC_BIAS_RANDOM_RON_C));
1091 irplib_flux_get_bias_window(masterbias, NULL,
1092 detmon_ronbias_config.random_sizex / 2,
1093 detmon_ronbias_config.random_nsamples,
1094 &bias, &bias_error);
1096 v = cpl_vector_wrap(nraws, ron);
1099 stdev = cpl_vector_get_median_const(v);
1100 cpl_vector_unwrap(v);
1103 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_RANDOM_VAL, bias);
1104 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_RANDOM_VAL,
1105 DETMON_QC_BIAS_RANDOM_VAL_C);
1108 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_RANDOM_RON, stdev);
1109 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_RANDOM_RON,
1110 DETMON_QC_BIAS_RANDOM_RON_C);
1115 return cpl_error_get_code();
1125 static cpl_error_code
1126 detmon_ronbias_histo(
const cpl_imagelist * rawbiases,
1127 const cpl_image * masterbias,
1128 cpl_propertylist * qclist)
1130 int nraws = cpl_imagelist_get_size(rawbiases);
1133 double mbias = DBL_MAX;
1134 double mfwhm = DBL_MAX;
1135 double mmax = DBL_MAX;
1140 double mean_fwhm = DBL_MAX;
1142 if(!strcmp(detmon_ronbias_config.pmethod,
"DIF")) nraws--;
1144 fwhms = cpl_vector_new(nraws);
1145 maxs = cpl_vector_new(nraws);
1147 for(i = 0; i < nraws; i++) {
1149 const cpl_image * c_raw;
1150 double bias = DBL_MAX;
1151 double fwhm = DBL_MAX;
1152 double max = DBL_MAX;
1154 if(strcmp(detmon_ronbias_config.pmethod,
"DIF")) {
1155 c_raw = cpl_imagelist_get_const(rawbiases, i);
1157 const cpl_image *c1_raw = cpl_imagelist_get_const(rawbiases, i);
1158 const cpl_image * c2_raw = cpl_imagelist_get_const(rawbiases, i+1);
1159 c_raw = cpl_image_subtract_create(c1_raw, c2_raw);
1162 skip_if(detmon_ronbias_histo_reduce(c_raw, &bias, &fwhm, &max));
1164 skip_if(bias == DBL_MAX || fwhm == DBL_MAX || max == DBL_MAX);
1166 if(!strcmp(detmon_ronbias_config.pmethod,
"DIF"))
1167 cpl_image_delete((cpl_image *)c_raw);
1169 skip_if(cpl_vector_set(maxs, i, max));
1170 skip_if(cpl_vector_set(fwhms, i, fwhm));
1175 skip_if(cpl_vector_divide_scalar(fwhms, HIST_FACT));
1177 detmon_ronbias_histo_reduce(masterbias, &mbias, &mfwhm, &mmax);
1179 skip_if(mbias == DBL_MAX || mfwhm == DBL_MAX || mmax == DBL_MAX);
1181 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_HISTO_VAL,
1183 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_HISTO_VAL,
1184 DETMON_QC_BIAS_HISTO_VAL_C));
1185 mean_fwhm = cpl_vector_get_mean(fwhms);
1187 skip_if(mean_fwhm == DBL_MAX);
1188 skip_if(cpl_error_get_code());
1190 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_HISTO_RON,
1192 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_HISTO_RON,
1193 DETMON_QC_BIAS_HISTO_RON_C));
1197 cpl_vector_delete(fwhms);
1198 cpl_vector_delete(maxs);
1200 return cpl_error_get_code();
1217 detmon_ronbias_histo_reduce(
const cpl_image * c_raw,
1224 unsigned long maxwhere = 0;
1227 unsigned long x1a = 1;
1228 unsigned long x2a = 1;
1233 double maxwhere_interp;
1236 cpl_matrix * coeffs =cpl_matrix_new(3, 3);
1237 cpl_matrix * rhs =cpl_matrix_new(3, 1);
1239 cpl_matrix * result = NULL;
1241 dupi = cpl_image_duplicate(c_raw);
1246 hist = irplib_hist_new();
1247 irplib_hist_fill(hist, dupi);
1249 cpl_image_delete(dupi);
1251 irplib_hist_get_max(hist, &maxwhere);
1253 for( p = 0; p< 3; p++){
1254 unsigned long bi = irplib_hist_get_value(hist, maxwhere-1+p);
1255 cpl_matrix_set(rhs, p, 0, bi);
1256 for( q= 0; q< 3; q++) {
1257 cpl_matrix_set(coeffs, p,q,pow((maxwhere-1+p),q));
1261 result = cpl_matrix_solve(coeffs, rhs);
1263 a = cpl_matrix_get(result, 2, 0);
1264 b = cpl_matrix_get(result, 1, 0);
1265 c = cpl_matrix_get(result, 0, 0);
1267 maxwhere_interp = -0.5 * b / (2 * a);
1268 max_interp = -1 * b * b / (4 * a) + c;
1270 cpl_matrix_delete(coeffs);
1271 cpl_matrix_delete(rhs);
1272 cpl_matrix_delete(result);
1275 for(uj = 0; uj < maxwhere; uj++) {
1276 if(irplib_hist_get_value(hist, uj) <= max_interp / 2 &&
1277 irplib_hist_get_value(hist, uj + 1) > max_interp / 2) {
1281 for(uj = maxwhere; uj < irplib_hist_get_nbins(hist)-1; uj++) {
1282 if(irplib_hist_get_value(hist, uj) >= max_interp / 2 &&
1283 irplib_hist_get_value(hist, uj + 1) < max_interp / 2) {
1288 x1 = (max_interp / 2 - irplib_hist_get_value(hist, x1a)) /
1289 (irplib_hist_get_value(hist, x1a + 1) -
1290 irplib_hist_get_value(hist, x1a)) + x1a;
1291 x2 = (max_interp / 2 - irplib_hist_get_value(hist, x2a)) /
1292 (irplib_hist_get_value(hist, x2a + 1) -
1293 irplib_hist_get_value(hist, x2a)) + x2a;
1295 *fwhm = (x2 - x1) * irplib_hist_get_bin_size(hist);
1299 *bias = maxwhere_interp * irplib_hist_get_bin_size(hist) +
1300 irplib_hist_get_start(hist);
1302 irplib_hist_delete(hist);
1304 return cpl_error_get_code();
1318 static cpl_error_code
1319 detmon_compute_bias_ron_and_stats_on_preoverscan(
const cpl_imagelist * rawbiases,
1320 cpl_propertylist * qclist,
1321 cpl_image ** synthetic)
1327 cpl_vector *meanspre;
1328 cpl_vector *medspre;
1329 cpl_vector *rmsspre;
1330 cpl_vector *meansover;
1331 cpl_vector *medsover;
1332 cpl_vector *rmssover;
1334 cpl_error_code error;
1336 nraws = cpl_imagelist_get_size(rawbiases);
1337 cpl_ensure_code(nraws != -1, CPL_ERROR_ILLEGAL_INPUT);
1339 nx = cpl_image_get_size_x(cpl_imagelist_get_const(rawbiases, 0));
1340 ny = cpl_image_get_size_y(cpl_imagelist_get_const(rawbiases, 0));
1341 cpl_ensure_code(nx != -1 && ny != -1, CPL_ERROR_ILLEGAL_INPUT);
1343 if(nx < detmon_ronbias_config.prescan_urx ||
1344 nx < detmon_ronbias_config.overscan_urx ||
1345 ny < detmon_ronbias_config.prescan_ury ||
1346 ny < detmon_ronbias_config.overscan_ury) {
1347 cpl_msg_warning(cpl_func,
"PREOVERSCAN method not applied. Given "
1348 "limits of prescan and overscan area "
1349 "exceed image size. Please check and rerun.");
1350 return CPL_ERROR_NONE;
1353 meanspre = cpl_vector_new(nraws);
1354 medspre = cpl_vector_new(nraws);
1355 rmsspre = cpl_vector_new(nraws);
1356 meansover = cpl_vector_new(nraws);
1357 medsover = cpl_vector_new(nraws);
1358 rmssover = cpl_vector_new(nraws);
1360 for(i = 0; i < nraws; i++) {
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, overscan);
1388 cpl_msg_info(cpl_func,
"Creating SYNTHETIC frame");
1389 if(*synthetic == NULL) {
1390 cpl_msg_error(cpl_func,
"Error creating SYNTHETIC frame");
1391 return CPL_ERROR_UNSPECIFIED;
1395 error = irplib_ksigma_clip(c_raw,
1396 detmon_ronbias_config.
1398 detmon_ronbias_config.
1400 detmon_ronbias_config.
1402 detmon_ronbias_config.
1404 (
double) detmon_ronbias_config.
1406 detmon_ronbias_config.
1407 stacking_ks_iter, 1e-5,
1409 cpl_ensure_code(!error, error);
1411 cpl_ensure_code(mean != 0 && stdev != 0, CPL_ERROR_UNSPECIFIED);
1413 error = cpl_vector_set(medspre, i, cpl_image_get_median(prescan));
1414 cpl_ensure_code(!error, error);
1416 error = cpl_vector_set(meanspre, i, mean);
1417 cpl_ensure_code(!error, error);
1418 error = cpl_vector_set(rmsspre, i, stdev);
1419 cpl_ensure_code(!error, error);
1420 error = irplib_ksigma_clip(c_raw,
1421 detmon_ronbias_config.
1423 detmon_ronbias_config.
1425 detmon_ronbias_config.
1427 detmon_ronbias_config.
1429 (
double) detmon_ronbias_config.
1431 detmon_ronbias_config.
1432 stacking_ks_iter, 1e-5,
1434 cpl_ensure_code(!error, error);
1436 cpl_ensure_code(mean != 0 && stdev != 0, CPL_ERROR_UNSPECIFIED);
1438 error = cpl_vector_set(medsover, i, cpl_image_get_median(overscan));
1439 cpl_ensure_code(!error, error);
1441 error = cpl_vector_set(meansover, i, mean);
1442 cpl_ensure_code(!error, error);
1443 error = cpl_vector_set(rmssover, i, stdev);
1444 cpl_ensure_code(!error, error);
1446 cpl_image_delete(prescan);
1447 cpl_image_delete(overscan);
1450 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_PRESCAN_MEAN,
1451 cpl_vector_get_mean(meanspre));
1453 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_PRESCAN_MEAN,
1454 DETMON_QC_BIAS_PRESCAN_MEAN_C);
1456 cpl_ensure_code(!error, error);
1457 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_PRESCAN_MED,
1458 cpl_vector_get_mean(medspre));
1459 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_PRESCAN_MED,
1460 DETMON_QC_BIAS_PRESCAN_MED_C);
1462 cpl_ensure_code(!error, error);
1463 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_PRESCAN_RON,
1464 cpl_vector_get_mean(rmsspre));
1466 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_PRESCAN_RON,
1467 DETMON_QC_BIAS_PRESCAN_RON_C);
1468 cpl_ensure_code(!error, error);
1471 cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_OVERSCAN_MEAN,
1472 cpl_vector_get_mean(meansover));
1473 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_OVERSCAN_MEAN,
1474 DETMON_QC_BIAS_OVERSCAN_MEAN_C);
1475 cpl_ensure_code(!error, error);
1476 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_OVERSCAN_MED,
1477 cpl_vector_get_mean(medsover));
1478 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_OVERSCAN_MED,
1479 DETMON_QC_BIAS_OVERSCAN_MED_C);
1480 cpl_ensure_code(!error, error);
1481 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_OVERSCAN_RON,
1482 cpl_vector_get_mean(rmssover));
1483 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_OVERSCAN_RON,
1484 DETMON_QC_BIAS_OVERSCAN_RON_C);
1485 cpl_ensure_code(!error, error);
1523 cpl_vector_delete(meanspre);
1524 cpl_vector_delete(medspre);
1525 cpl_vector_delete(rmsspre);
1526 cpl_vector_delete(meansover);
1527 cpl_vector_delete(medsover);
1528 cpl_vector_delete(rmssover);
1530 return CPL_ERROR_NONE;
1544 static cpl_error_code
1545 detmon_compute_bias_stats_and_ron_in_region(
const cpl_imagelist * rawbiases,
1546 const cpl_image * masterbias,
1547 cpl_propertylist * qclist)
1550 int nraws = cpl_imagelist_get_size(rawbiases);
1554 cpl_image_get_size_x(cpl_imagelist_get_const(rawbiases, 0));
1556 cpl_image_get_size_y(cpl_imagelist_get_const(rawbiases, 0));
1558 cpl_vector *rmssreg;
1559 cpl_error_code error;
1561 const cpl_image * c_raw;
1562 double median, mbias, mstdev;
1564 if(!strcmp(detmon_ronbias_config.pmethod,
"DIF")) nraws--;
1566 rmssreg = cpl_vector_new(nraws);
1568 if(nx < detmon_ronbias_config.ref_urx ||
1569 ny < detmon_ronbias_config.ref_ury) {
1570 cpl_msg_warning(cpl_func,
"REGION method not applied. Given "
1571 "limits of prescan and overscan area "
1572 "exceed image size. Please check and rerun.");
1573 return CPL_ERROR_NONE;
1576 for(i = 0; i < nraws; i++) {
1579 if(strcmp(detmon_ronbias_config.pmethod,
"DIF")) {
1580 c_raw = cpl_imagelist_get_const(rawbiases, i);
1582 const cpl_image *c1_raw = cpl_imagelist_get_const(rawbiases, i);
1583 const cpl_image * c2_raw = cpl_imagelist_get_const(rawbiases, i+1);
1584 c_raw = cpl_image_subtract_create(c1_raw, c2_raw);
1586 error = irplib_ksigma_clip(c_raw,
1587 detmon_ronbias_config.ref_llx,
1588 detmon_ronbias_config.ref_lly,
1589 detmon_ronbias_config.ref_urx,
1590 detmon_ronbias_config.ref_ury,
1591 (
double) detmon_ronbias_config.
1593 detmon_ronbias_config.
1594 stacking_ks_iter, 1e-5,
1596 cpl_ensure_code(!error, error);
1603 error = cpl_vector_set(rmssreg, i, stdev);
1604 cpl_ensure_code(!error, error);
1605 if(!strcmp(detmon_ronbias_config.pmethod,
"DIF")) cpl_image_delete((cpl_image *)c_raw);
1608 median = cpl_image_get_median_window(masterbias,
1609 detmon_ronbias_config.ref_llx,
1610 detmon_ronbias_config.ref_lly,
1611 detmon_ronbias_config.ref_urx,
1612 detmon_ronbias_config.ref_ury);
1613 error = irplib_ksigma_clip(masterbias,
1614 detmon_ronbias_config.ref_llx,
1615 detmon_ronbias_config.ref_lly,
1616 detmon_ronbias_config.ref_urx,
1617 detmon_ronbias_config.ref_ury,
1618 (
double) detmon_ronbias_config.
1620 detmon_ronbias_config.
1621 stacking_ks_iter, 1e-5,
1624 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_REGION_MED,
1626 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_REGION_MED,
1627 DETMON_QC_BIAS_REGION_MED_C);
1628 cpl_ensure_code(!error, error);
1630 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_REGION_VAL,
1632 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_REGION_VAL,
1633 DETMON_QC_BIAS_REGION_VAL_C);
1634 cpl_ensure_code(!error, error);
1635 error = cpl_propertylist_append_double(qclist,DETMON_QC_BIAS_REGION_RON,
1636 cpl_vector_get_mean(rmssreg));
1637 error = cpl_propertylist_set_comment(qclist,DETMON_QC_BIAS_REGION_RON,
1638 DETMON_QC_BIAS_REGION_RON_C);
1639 cpl_ensure_code(!error, error);
1646 cpl_vector_delete(rmssreg);
1648 return cpl_error_get_code();
1665 detmon_ronbias_master(
const cpl_imagelist * rawbiases,
1666 cpl_mask ** bpmhot, cpl_mask ** bpmcold,
1667 cpl_mask ** bpmdev, cpl_propertylist * qclist)
1671 cpl_image *masterbias = NULL;
1672 double dark_med, stdev_med,lower, upper;
1673 int hotpix_nb, coldpix_nb, devpix_nb;
1674 cpl_image * stdev_im = NULL;
1676 if(!strcmp(detmon_ronbias_config.stacking_method,
"MEAN"))
1677 masterbias = cpl_imagelist_collapse_create(rawbiases);
1678 if(!strcmp(detmon_ronbias_config.stacking_method,
"MINMAX"))
1680 cpl_imagelist_collapse_minmax_create(rawbiases, 0, 10000);
1681 if(!strcmp(detmon_ronbias_config.stacking_method,
"KSIGMA"))
1683 cpl_imagelist_collapse_sigclip_create(rawbiases, 3.0, 3.0, 0.9,
1684 CPL_COLLAPSE_MEAN, NULL);
1685 if(!strcmp(detmon_ronbias_config.stacking_method,
"MEDIAN"))
1686 masterbias = cpl_imagelist_collapse_median_create(rawbiases);
1688 skip_if(masterbias == NULL);
1690 skip_if(irplib_ksigma_clip(masterbias, 1, 1,
1691 cpl_image_get_size_x(masterbias),
1692 cpl_image_get_size_y(masterbias),
1693 (
double) detmon_ronbias_config.
1695 detmon_ronbias_config.
1696 stacking_ks_iter, 1e-5,
1699 if(irplib_isnan(mean))
1700 cpl_msg_error(cpl_func,
"We have an error in mean");
1701 if(irplib_isnan(stdev))
1702 cpl_msg_error(cpl_func,
"We have an error in stdev");
1704 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_MASTER_MEAN,
1706 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_MASTER_MEAN,
1707 DETMON_QC_MASTER_MEAN_C));
1709 skip_if(cpl_propertylist_append_double(qclist,DETMON_QC_MASTER_RMS,
1711 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_MASTER_RMS,
1712 DETMON_QC_MASTER_RMS_C));
1715 dark_med = cpl_image_get_median(masterbias);
1717 lower = dark_med - stdev * detmon_ronbias_config.stacking_ks_low;
1718 upper = dark_med + stdev * detmon_ronbias_config.stacking_ks_high;
1721 cpl_mask_delete(*bpmhot);
1722 irplib_check(*bpmhot = cpl_mask_threshold_image_create(masterbias,
1724 "Cannot compute the hot pixel map");
1725 hotpix_nb = cpl_mask_count(*bpmhot);
1729 cpl_mask_delete(*bpmcold);
1730 irplib_check(*bpmcold = cpl_mask_threshold_image_create(masterbias,
1732 "Cannot compute the cold pixel map");
1733 coldpix_nb = cpl_mask_count(*bpmcold);
1737 stdev_im = irplib_imagelist_collapse_stdev_create(rawbiases);
1738 stdev_med = cpl_image_get_median(stdev_im);
1740 skip_if(irplib_ksigma_clip(stdev_im, 1, 1,
1741 cpl_image_get_size_x(stdev_im),
1742 cpl_image_get_size_y(stdev_im),
1743 (
double) detmon_ronbias_config.
1745 detmon_ronbias_config.
1746 stacking_ks_iter, 1e-5,
1749 lower = stdev_med - stdev * detmon_ronbias_config.stacking_ks_low;
1750 upper = stdev_med + stdev * detmon_ronbias_config.stacking_ks_high;
1752 cpl_mask_delete(*bpmdev);
1753 irplib_check(*bpmdev = cpl_mask_threshold_image_create(stdev_im,
1755 "Cannot compute the cold pixel map");
1756 cpl_mask_not(*bpmdev);
1757 devpix_nb = cpl_mask_count(*bpmdev);
1761 skip_if(cpl_propertylist_append_int(qclist,DETMON_QC_NBCOLDPIX,coldpix_nb));
1762 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_NBCOLDPIX,
1763 DETMON_QC_NBCOLDPIX_C));
1765 skip_if(cpl_propertylist_append_int(qclist,DETMON_QC_NBHOTPIX, hotpix_nb));
1766 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_NBHOTPIX,
1767 DETMON_QC_NBHOTPIX_C));
1769 skip_if(cpl_propertylist_append_int(qclist,DETMON_QC_NBDEVPIX, devpix_nb));
1770 skip_if(cpl_propertylist_set_comment(qclist,DETMON_QC_NBDEVPIX,
1771 DETMON_QC_NBDEVPIX_C));
1775 cpl_image_delete(stdev_im);
1777 if (cpl_error_get_code()) {
1778 cpl_image_delete(masterbias);
1816 static cpl_error_code
1817 detmon_ronbias_save(
const cpl_parameterlist * parlist,
1818 cpl_frameset * frameset,
1819 const char *recipe_name,
1820 const char *pipeline_name,
1821 const char *pafregexp,
1822 const cpl_propertylist * pro_master,
1823 const cpl_propertylist * pro_xstr,
1824 const cpl_propertylist * pro_ystr,
1825 const cpl_propertylist * pro_synth,
1826 const cpl_propertylist * pro_bpmhot,
1827 const cpl_propertylist * pro_bpmcold,
1828 const cpl_propertylist * pro_bpmdev,
1829 const char *package,
1830 const cpl_image * masterbias,
1831 const cpl_image * synthetic,
1832 const cpl_mask * bpmhot,
1833 const cpl_mask * bpmcold,
1834 const cpl_mask * bpmdev,
1835 cpl_propertylist * qclist,
1836 const int flag_sets,
1837 const int which_set,
1838 cpl_frameset * usedframes,
1842 cpl_frame *ref_frame;
1843 cpl_propertylist *plist = NULL;
1844 char *name_o = NULL;
1846 cpl_propertylist * paflist = NULL;
1847 cpl_propertylist * mainplist = NULL;
1848 cpl_propertylist * xplist = NULL;
1849 cpl_image * image = NULL;
1851 cpl_propertylist * mypro_master =
1852 cpl_propertylist_duplicate(pro_master);
1854 cpl_propertylist * mypro_synth = NULL;
1855 cpl_propertylist * mypro_bpmhot =
1856 cpl_propertylist_duplicate(pro_bpmhot);
1857 cpl_propertylist * mypro_bpmcold =
1858 cpl_propertylist_duplicate(pro_bpmcold);
1859 cpl_propertylist * mypro_bpmdev =
1860 cpl_propertylist_duplicate(pro_bpmdev);
1862 cpl_ensure_code(parlist != NULL, CPL_ERROR_NULL_INPUT);
1863 cpl_ensure_code(frameset != NULL, CPL_ERROR_NULL_INPUT);
1864 cpl_ensure_code(pafregexp != NULL, CPL_ERROR_NULL_INPUT);
1865 cpl_ensure_code(package != NULL, CPL_ERROR_NULL_INPUT);
1866 cpl_ensure_code(recipe_name != NULL, CPL_ERROR_NULL_INPUT);
1867 cpl_ensure_code(pipeline_name != NULL, CPL_ERROR_NULL_INPUT);
1868 cpl_ensure_code(usedframes != NULL, CPL_ERROR_NULL_INPUT);
1871 mypro_synth = cpl_propertylist_duplicate(pro_synth);
1874 cpl_ensure_code(pro_xstr == NULL && pro_ystr == NULL,
1875 CPL_ERROR_UNSUPPORTED_MODE);
1878 if (detmon_ronbias_config.exts < 0) {
1879 const char * filename =
1880 cpl_frame_get_filename(cpl_frameset_get_first(frameset));
1883 xplist = cpl_propertylist_load_regexp(filename, whichext,
1885 skip_if(cpl_propertylist_append(xplist, qclist));
1888 cpl_msg_info(cpl_func,
"dealing with extention %d",whichext);
1892 ref_frame = cpl_frameset_get_first(frameset);
1893 skip_if(ref_frame == NULL);
1895 skip_if((mainplist =
1896 cpl_propertylist_load(cpl_frame_get_filename(ref_frame),
1905 name_o = cpl_sprintf(
"%s_masterbias.fits", recipe_name);
1906 assert(name_o != NULL);
1909 cpl_sprintf(
"%s_masterbias_set%02d.fits", recipe_name,
1911 assert(name_o != NULL);
1914 if (whichext == 0) {
1915 cpl_propertylist_append(mypro_master, qclist);
1917 skip_if(cpl_dfs_save_image(frameset, NULL, parlist, usedframes, NULL,
1918 masterbias, CPL_BPP_IEEE_FLOAT, recipe_name,
1919 mypro_master, NULL, package, name_o));
1921 skip_if(cpl_image_save(masterbias,
1922 name_o, CPL_BPP_IEEE_FLOAT, xplist,
1935 name_o = cpl_sprintf(
"%s_hotpixmap.fits", recipe_name);
1936 assert(name_o != NULL);
1939 cpl_sprintf(
"%s_hotpixmap_set%02d.fits", recipe_name,
1941 assert(name_o != NULL);
1945 image = cpl_image_new_from_mask(bpmhot);
1948 if (whichext == 0) {
1949 cpl_propertylist_append(mypro_bpmhot, qclist);
1951 skip_if(cpl_dfs_save_image(frameset, NULL, parlist, usedframes, NULL,
1952 image, CPL_BPP_IEEE_FLOAT, recipe_name,
1953 mypro_bpmhot, NULL, package, name_o));
1955 skip_if(cpl_image_save(image,
1956 name_o, CPL_BPP_IEEE_FLOAT, xplist,
1961 cpl_image_delete(image);
1971 name_o = cpl_sprintf(
"%s_coldpixmap.fits", recipe_name);
1972 assert(name_o != NULL);
1975 cpl_sprintf(
"%s_coldpixmap_set%02d.fits", recipe_name,
1977 assert(name_o != NULL);
1981 image = cpl_image_new_from_mask(bpmcold);
1984 if (whichext == 0) {
1985 cpl_propertylist_append(mypro_bpmcold, qclist);
1987 skip_if(cpl_dfs_save_image(frameset, NULL, parlist, usedframes, NULL,
1988 image, CPL_BPP_IEEE_FLOAT, recipe_name,
1989 mypro_bpmcold, NULL, package, name_o));
1991 skip_if(cpl_image_save(image,
1992 name_o, CPL_BPP_IEEE_FLOAT, xplist,
1997 cpl_image_delete(image);
2007 name_o = cpl_sprintf(
"%s_devpixmap.fits", recipe_name);
2008 assert(name_o != NULL);
2011 cpl_sprintf(
"%s_devpixmap_set%02d.fits", recipe_name,
2013 assert(name_o != NULL);
2017 image = cpl_image_new_from_mask(bpmdev);
2020 if (whichext == 0) {
2021 cpl_propertylist_append(mypro_bpmdev, qclist);
2023 skip_if(cpl_dfs_save_image(frameset, NULL,parlist, usedframes, NULL,
2024 image, CPL_BPP_IEEE_FLOAT, recipe_name,
2025 mypro_bpmdev, NULL, package, name_o));
2027 skip_if(cpl_image_save(image,
2028 name_o, CPL_BPP_IEEE_FLOAT, xplist,
2033 cpl_image_delete(image);
2040 if(detmon_ronbias_config.method_bitmask & PREOVERSCAN) {
2043 name_o = cpl_sprintf(
"%s_synthetic.fits", recipe_name);
2044 assert(name_o != NULL);
2047 cpl_sprintf(
"%s_synthetic_set%02d.fits", recipe_name,
2049 assert(name_o != NULL);
2052 if (whichext == 0) {
2054 cpl_propertylist_append(mypro_synth, qclist);
2056 skip_if(cpl_dfs_save_image(frameset, NULL, parlist, usedframes,
2057 NULL,synthetic, CPL_BPP_IEEE_DOUBLE,
2058 recipe_name, mypro_synth, NULL,
2061 skip_if(cpl_image_save(synthetic, name_o, CPL_BPP_IEEE_FLOAT,
2062 xplist, CPL_IO_EXTEND));
2073 paflist = cpl_propertylist_new();
2076 if(detmon_ronbias_config.exts >= 0) {
2078 cpl_propertylist_load(cpl_frame_get_filename(ref_frame),
2079 detmon_ronbias_config.exts)) == NULL);
2082 name_o = cpl_sprintf(
"%s.paf", recipe_name);
2083 assert(name_o != NULL);
2085 name_o = cpl_sprintf(
"%s_set%02d.paf",
2086 recipe_name, which_set);
2087 assert(name_o != NULL);
2091 cpl_propertylist_load(cpl_frame_get_filename(ref_frame),
2092 whichext)) == NULL);
2096 name_o = cpl_sprintf(
"%s_ext%02d.paf",
2097 recipe_name, whichext);
2098 assert(name_o != NULL);
2100 name_o = cpl_sprintf(
"%s_set%02d_ext%02d.paf",
2102 which_set, whichext);
2103 assert(name_o != NULL);
2108 skip_if(cpl_propertylist_copy_property_regexp(paflist, plist,
2110 skip_if(cpl_propertylist_copy_property_regexp(paflist, mainplist,
2113 skip_if(cpl_propertylist_append(paflist, qclist));
2116 skip_if(cpl_dfs_save_paf(pipeline_name, recipe_name, paflist, name_o));
2122 cpl_propertylist_delete(plist);
2123 cpl_propertylist_delete(paflist);
2124 cpl_propertylist_delete(mainplist);
2125 cpl_propertylist_delete(xplist);
2127 cpl_image_delete(image);
2129 cpl_propertylist_delete(mypro_master);
2130 cpl_propertylist_delete(mypro_synth);
2131 cpl_propertylist_delete(mypro_bpmhot);
2132 cpl_propertylist_delete(mypro_bpmcold);
2133 cpl_propertylist_delete(mypro_bpmdev);
2135 return cpl_error_get_code();
2147 detmon_ronbias_dfs_set_groups(cpl_frameset * set,
const char *tag)
2159 nframes = cpl_frameset_get_size(set);
2162 for(i = 0; i < nframes; i++) {
2163 cpl_frame* cur_frame = cpl_frameset_get_frame(set, i);
2164 const char* cur_tag = cpl_frame_get_tag(cur_frame);
2167 if(!strcmp(cur_tag, tag))
2168 cpl_frame_set_group(cur_frame, CPL_FRAME_GROUP_RAW);
2191 detmon_build_synthetic_from_pre_overscan(cpl_image * prescan,
2192 cpl_image * overscan)
2196 int distance = detmon_ronbias_config.overscan_urx -
2197 detmon_ronbias_config.prescan_llx + 1;
2199 double * mean_x = (
double *) cpl_malloc(
sizeof(
double) * distance);
2201 double * xvalues = (
double *) cpl_malloc(
sizeof(
double) * distance);
2203 cpl_vector *x = NULL;
2204 cpl_vector *y = NULL;
2206 cpl_polynomial *poly = NULL;
2207 cpl_polynomial *poly2 = NULL;
2209 cpl_matrix * samppos;
2211 cpl_size pows[2] = { 0, 0 };
2213 cpl_image * synthetic = NULL;
2218 for(j = 0; j < distance; j++) {
2223 for(j = 0; j < cpl_image_get_size_x(prescan); j++) {
2225 cpl_image_get_mean_window(prescan, j + 1, 1, j + 1,
2226 cpl_image_get_size_y(prescan));
2229 for(j = 0; j < cpl_image_get_size_x(overscan); j++) {
2230 *(mean_x + distance - cpl_image_get_size_x(overscan) + j) =
2231 cpl_image_get_mean_window(overscan, j + 1, 1, j + 1,
2232 cpl_image_get_size_y(overscan));
2235 x = cpl_vector_wrap(distance, xvalues);
2236 y = cpl_vector_wrap(distance, mean_x);
2238 poly = cpl_polynomial_new(1);
2240 cpl_matrix_wrap(1, cpl_vector_get_size(x), cpl_vector_get_data(x));
2242 cpl_polynomial_fit(poly, samppos, NULL, y, NULL,
2243 CPL_FALSE, NULL, &detmon_ronbias_config.preoverscan_degree);
2245 cpl_matrix_unwrap(samppos);
2247 cpl_vector_unwrap(x);
2248 cpl_vector_unwrap(y);
2255 poly2 = cpl_polynomial_new(2);
2258 cpl_polynomial_set_coeff(poly2, pows, cpl_polynomial_get_coeff(poly, &j));
2262 cpl_polynomial_set_coeff(poly2, pows, cpl_polynomial_get_coeff(poly, &j));
2264 cpl_polynomial_delete(poly);
2267 cpl_image_new(distance, cpl_image_get_size_y(prescan),
2270 if(cpl_image_fill_polynomial(synthetic, poly2, initial, 1, 1, 1)) {
2271 cpl_msg_error(cpl_func,
"Error creating the synthetic frame");
2272 cpl_polynomial_delete(poly2);
2276 cpl_polynomial_delete(poly2);
2291 static cpl_error_code
2292 detmon_ronbias_dutycycl(
const cpl_frameset * frameset,
2293 cpl_propertylist * qclist)
2295 const cpl_frame *first = 0;
2296 cpl_propertylist *plistfirst = 0;
2299 const cpl_frame *last = 0;
2300 cpl_propertylist *plistlast = 0;
2303 cpl_error_code error;
2305 first = cpl_frameset_get_first_const(frameset);
2306 plistfirst = cpl_propertylist_load(cpl_frame_get_filename(first), 0);
2307 tfirst = cpl_propertylist_get_double(plistfirst,
"MJD-OBS");
2308 nraws = cpl_frameset_get_size(frameset);
2309 last = cpl_frameset_get_frame_const(frameset, nraws - 1);
2310 plistlast = cpl_propertylist_load(cpl_frame_get_filename(last), 0);
2311 tlast = cpl_propertylist_get_double(plistlast,
"MJD-OBS");
2312 dutycycl = (tlast - tfirst) / (nraws - 1);
2314 error = cpl_error_get_code();
2315 if (error != CPL_ERROR_NONE)
2319 cpl_propertylist_append_double(qclist,DETMON_QC_DUTYCYCL, dutycycl);
2320 error = cpl_propertylist_set_comment(qclist,DETMON_QC_DUTYCYCL,
2321 DETMON_QC_DUTYCYCL_C);
2325 cpl_propertylist_delete(plistfirst);
2326 cpl_propertylist_delete(plistlast);
2334 #define RECT_RON_HS 4
2335 #define RECT_RON_SAMPLES 100
2352 irplib_flux_get_bias_window(
const cpl_image * diff,
2353 const int *zone_def,
2355 int ron_nsamp,
double *bias,
double *error)
2357 const int hsize = ron_hsize < 0 ? RECT_RON_HS : ron_hsize;
2358 const int nsamples =
2359 ron_nsamp < 0 ? RECT_RON_SAMPLES : ron_nsamp;
2360 cpl_bivector *sample_reg;
2361 cpl_vector *rms_list;
2370 cpl_ensure_code(diff && bias, CPL_ERROR_NULL_INPUT);
2373 if(zone_def != NULL) {
2374 rect[0] = zone_def[0] + hsize + 1;
2375 rect[1] = zone_def[1] - hsize - 1;
2376 rect[2] = zone_def[2] + hsize + 1;
2377 rect[3] = zone_def[3] - hsize - 1;
2379 rect[0] = hsize + 1;
2380 rect[1] = cpl_image_get_size_x(diff) - hsize - 1;
2381 rect[2] = hsize + 1;
2382 rect[3] = cpl_image_get_size_y(diff) - hsize - 1;
2385 cpl_ensure_code(rect[0] < rect[1] && rect[2] < rect[3],
2386 CPL_ERROR_ILLEGAL_INPUT);
2391 irplib_bivector_gen_rect_poisson(rect, nsamples + 1, nsamples + 1);
2392 cpl_ensure(sample_reg != NULL, CPL_ERROR_ILLEGAL_INPUT,
2393 CPL_ERROR_ILLEGAL_INPUT);
2395 px = cpl_bivector_get_x_data(sample_reg);
2396 py = cpl_bivector_get_y_data(sample_reg);
2400 rms_list = cpl_vector_new(nsamples);
2401 cpl_ensure(rms_list != NULL, CPL_ERROR_NULL_INPUT, CPL_ERROR_NULL_INPUT);
2402 pr = cpl_vector_get_data(rms_list);
2404 for(i = 0; i < nsamples; i++) {
2405 zone[0] = (int) px[i + 1] - hsize;
2406 zone[1] = (int) px[i + 1] + hsize;
2407 zone[2] = (int) py[i + 1] - hsize;
2408 zone[3] = (int) py[i + 1] + hsize;
2409 pr[i] = cpl_image_get_mean_window(diff,
2410 zone[0], zone[2], zone[1], zone[3]);
2412 cpl_bivector_delete(sample_reg);
2416 *error = cpl_vector_get_stdev(rms_list);
2420 *bias = cpl_vector_get_median(rms_list);
2422 cpl_vector_delete(rms_list);
2424 return CPL_ERROR_NONE;
2428 #undef RECT_RON_SAMPLES
2441 static cpl_bivector *
2442 irplib_bivector_gen_rect_poisson(
const int *r,
const int np,
const int homog)
2448 double cand_x, cand_y;
2451 int xmin, xmax, ymin, ymax;
2454 const int homogc = 0 < homog && homog < np ? homog : np;
2459 cpl_ensure(r, CPL_ERROR_NULL_INPUT, NULL);
2460 cpl_ensure(np > 0, CPL_ERROR_ILLEGAL_INPUT, NULL);
2462 list = cpl_bivector_new(np);
2463 cpl_ensure(list, CPL_ERROR_NULL_INPUT, NULL);
2464 px = cpl_bivector_get_x_data(list);
2465 py = cpl_bivector_get_y_data(list);
2473 CPL_MATH_SQRT1_2 * ((xmax - xmin) * (ymax - ymin) / (double) (homogc + 1));
2479 while(gnp < homogc) {
2481 cand_x = cpl_drand() * (xmax - xmin) + xmin;
2482 cand_y = cpl_drand() * (ymax - ymin) + ymin;
2486 for(i = 0; i < gnp; i++) {
2487 if(pdist(cand_x, cand_y, px[i], py[i]) < min_dist) {
2506 cand_x = cpl_drand() * (xmax - xmin) + xmin;
2507 cand_y = cpl_drand() * (ymax - ymin) + ymin;
2511 for(i = 0; i < homogc; i++) {
2514 px[start_ndx + i], py[start_ndx + i]) < min_dist) {
2533 cand_x = cpl_drand() * (xmax - xmin) + xmin;
2534 cand_y = cpl_drand() * (ymax - ymin) + ymin;
2538 for(i = 0; i < homogc; i++) {
2541 px[start_ndx + i], py[start_ndx + i]) < min_dist) {
2580 irplib_imagelist_collapse_stdev_create(
const cpl_imagelist * imlist)
2589 cpl_ensure(imlist != NULL, CPL_ERROR_NULL_INPUT, NULL);
2590 cpl_ensure(cpl_imagelist_is_uniform(imlist) == 0, CPL_ERROR_ILLEGAL_INPUT,
2594 cpl_image* mean = cpl_image_duplicate(cpl_imagelist_get_const(imlist, 0));
2595 cpl_image_fill_rejected(mean, 0.0);
2596 cpl_image_accept_all(mean);
2598 cpl_image* stdev = cpl_image_new(cpl_image_get_size_x(mean),
2599 cpl_image_get_size_y(mean),
2602 for (
int i = 1; i < cpl_imagelist_get_size(imlist); i++) {
2603 cpl_image* delta = cpl_image_subtract_create(cpl_imagelist_get_const(imlist, i),
2605 cpl_image_fill_rejected(delta, 0.0);
2606 cpl_image_accept_all(delta);
2608 cpl_image* sq_delta = cpl_image_multiply_create(delta, delta);
2610 cpl_image_multiply_scalar(sq_delta, ((
double) i / (
double)(i+1)));
2611 cpl_image_add(stdev, sq_delta);
2613 cpl_image_divide_scalar(delta, i + 1);
2614 cpl_image_add(mean, delta);
2616 cpl_image_delete(delta);
2617 cpl_image_delete(sq_delta);
2620 cpl_image_divide_scalar(stdev, cpl_imagelist_get_size(imlist) - 1);
2621 cpl_image_power(stdev, 0.5);
2623 cpl_image_delete(mean);