34#include <cr2res_dfs.h>
35#include <cr2res_calib.h>
37#include "cr2res_pfits.h"
38#include "cr2res_utils.h"
45#define pow2(x) (x) * (x)
46#define detlin(x, a, b, c) (x) * ((a) + (x) * ((b) + (x) * (c)))
47#define deterr(x, a, b, c, sx, sa, sb, sc) sqrt(detlin(pow2(x), pow2(sa), pow2(sb), pow2(sc)) + pow2(sx) * pow2((a) + 2 * (b) * (x) + 3 * (c) * pow2(x)))
51static hdrl_image * cr2res_create_hdrl(
int nx,
int ny,
double value,
double error);
53static void test_cr2res_calib_image(
void);
54static void test_cr2res_calib_cosmic(
void);
55static void test_cr2res_calib_flat(
void);
56static void test_cr2res_calib_dark(
void);
57static void test_cr2res_calib_bpm(
void);
58static void test_cr2res_calib_detlin(
void);
61static void create_empty_fits()
65 char *my_path = cpl_sprintf(
"%s/TEST_empty.fits", localdir);
66 cpl_propertylist * list = cpl_propertylist_new();
67 cpl_propertylist_append_string(list, CR2RES_HEADER_DRS_TYPE,
"DEBUG");
68 cpl_propertylist_save(list, my_path, CPL_IO_CREATE);
69 cpl_propertylist_delete(list);
78static void save_hdrl(
char * filename, hdrl_image * hdrl,
int mode,
double dit)
82 cpl_frame * empty = cpl_frame_new();
84 char *my_path = cpl_sprintf(
"%s/TEST_empty.fits", localdir);
85 cpl_frame_set_filename(empty, my_path);
86 cpl_frame_set_tag(empty,
"DEBUG");
87 cpl_frame_set_group(empty, CPL_FRAME_GROUP_CALIB);
89 cpl_parameterlist * parlist = cpl_parameterlist_new();
90 cpl_propertylist * ext1 = cpl_propertylist_new();
91 cpl_propertylist_append_double(ext1, CR2RES_HEADER_DIT, dit);
92 cpl_propertylist * ext[] = {ext1, NULL, NULL};
95 cpl_frameset * all = cpl_frameset_new();
96 cpl_frameset * in = cpl_frameset_new();
97 cpl_frameset_insert(all, empty);
98 empty = cpl_frame_duplicate(empty);
99 cpl_frameset_insert(in, empty);
101 hdrl_image * list[] = {hdrl, NULL, NULL};
103 if (mode == MODE_FLAT)
105 if (mode == MODE_DARK)
107 if (mode == MODE_BPM)
110 cr2res_io_save_BPM(filename, all, in, parlist, list2, ext1, ext, CR2RES_CAL_FLAT_BPM_PROCATG,
"debug");
112 if (mode == MODE_DETLIN){
118 hdrl_imagelist * list4[] = {list3, NULL, NULL};
127 cpl_frameset_delete(all);
128 cpl_frameset_delete(in);
130 cpl_parameterlist_delete(parlist);
131 cpl_propertylist_delete(ext1);
139static cpl_frame * create_master_flat(
char * filename,
int nx,
int ny,
double value,
double error, cpl_mask ** bpm)
141 cpl_frame * out = cpl_frame_new();
142 cpl_frame_set_filename(out, filename);
143 cpl_frame_set_tag(out,
"FLAT");
144 cpl_frame_set_group(out, CPL_FRAME_GROUP_CALIB);
146 hdrl_image * hdrl = cr2res_create_hdrl(nx, ny, value, error);
153 save_hdrl(filename, hdrl, MODE_FLAT, 0);
164static cpl_frame * create_master_dark(
char * filename,
int nx,
int ny,
double value,
double error,
double dit, cpl_mask ** bpm)
167 cpl_frame * out = cpl_frame_new();
168 cpl_frame_set_filename(out, filename);
169 cpl_frame_set_tag(out,
"DARK");
170 cpl_frame_set_group(out, CPL_FRAME_GROUP_CALIB);
172 hdrl_image * hdrl = cr2res_create_hdrl(nx, ny, value, error);
179 save_hdrl(filename, hdrl, MODE_DARK, dit);
190static cpl_frame * create_bpm(
char * filename,
int nx,
int ny,
double value)
192 cpl_frame * out = cpl_frame_new();
193 cpl_frame_set_filename(out, filename);
194 cpl_frame_set_tag(out,
"BPM");
195 cpl_frame_set_group(out, CPL_FRAME_GROUP_CALIB);
197 hdrl_image * hdrl = cr2res_create_hdrl(nx, ny, value, 0);
198 save_hdrl(filename, hdrl, MODE_BPM, 0);
209static cpl_frame * create_detlin(
char * filename, hdrl_image * a, hdrl_image * b, hdrl_image * c)
211 char *my_path = cpl_sprintf(
"%s/TEST_empty.fits", localdir);
215 cpl_frame * empty = cpl_frame_new();
216 cpl_frame_set_filename(empty, my_path);
217 cpl_frame_set_tag(empty,
"DEBUG");
218 cpl_frame_set_group(empty, CPL_FRAME_GROUP_CALIB);
220 cpl_parameterlist * parlist = cpl_parameterlist_new();
221 cpl_propertylist * ext1 = cpl_propertylist_new();
222 cpl_propertylist * ext[] = {ext1, NULL, NULL};
224 cpl_frameset * all = cpl_frameset_new();
225 cpl_frameset * in = cpl_frameset_new();
226 cpl_frameset_insert(all, empty);
227 empty = cpl_frame_duplicate(empty);
228 cpl_frameset_insert(in, empty);
235 hdrl_imagelist * list4[] = {list3, NULL, NULL};
245 cpl_frameset_delete(all);
246 cpl_frameset_delete(in);
247 cpl_parameterlist_delete(parlist);
248 cpl_propertylist_delete(ext1);
250 cpl_frame * out = cpl_frame_new();
251 cpl_frame_set_filename(out, filename);
252 cpl_frame_set_tag(out,
"DETLIN");
253 cpl_frame_set_group(out, CPL_FRAME_GROUP_CALIB);
265static hdrl_image * cr2res_create_hdrl(
int nx,
int ny,
double value,
double error)
275static double calc_read_noise(
double dit,
int ndit,
int chip)
277 double min_dit = 1.427;
278 double lim_dit = 50.0;
287 return min_rn/CR2RES_GAIN_CHIP1;
288 }
else if(dit >= lim_dit) {
289 return lim_rn/CR2RES_GAIN_CHIP1;
291 double rn = min_rn + (lim_rn-min_rn)*(dit-min_dit)/(lim_dit-min_dit);
292 return rn/CR2RES_GAIN_CHIP1;
296static void add_read_noise(hdrl_image * im,
double dit,
int chip)
298 double read_noise = calc_read_noise(dit, 1, chip);
302static void add_read_noise_cpl(cpl_image * im,
double dit,
int chip)
304 double read_noise = calc_read_noise(dit, 1, chip);
305 cpl_image_add_scalar(im, read_noise);
308static void test_cr2res_calib_image()
314 double img_value = 100;
315 double img_error = 1;
317 hdrl_image * in = cr2res_create_hdrl(nx, ny, img_value, img_error);
320 char *my_path1 = cpl_sprintf(
"%s/TEST_master_flat.fits", localdir);
321 char *my_path2 = cpl_sprintf(
"%s/TEST_master_dark.fits", localdir);
322 char *my_path3 = cpl_sprintf(
"%s/TEST_bpm.fits", localdir);
323 cpl_frame * flat = create_master_flat(my_path1, nx, ny, 1, 0, NULL);
324 cpl_frame * dark = create_master_dark(my_path2, nx, ny, 10, 1, 10, NULL);
325 cpl_frame * bpm = create_bpm(my_path3, nx, ny, 0);
326 cpl_frame * detlin = NULL;
333 out =
cr2res_calib_image(NULL, chip, 0, 0, 1, 0, NULL, NULL, NULL, NULL,dit,1);
336 out =
cr2res_calib_image(in, 0, 0, 0, 1, 0, NULL, NULL, NULL, NULL, dit, 1);
340 NULL, NULL, NULL, NULL, dit, 1);
344 out =
cr2res_calib_image(in, chip, 0, 0, 1, 0, NULL, NULL, NULL, NULL, dit, 1);
345 cpl_test_nonnull(out);
351 add_read_noise(in, dit, chip);
358 cpl_frame_delete(flat);
359 cpl_frame_delete(dark);
360 cpl_frame_delete(bpm);
361 cpl_frame_delete(detlin);
372static void test_cr2res_calib_cosmic()
378 double img_value = 100;
379 double img_error = 1;
383 hdrl_image * in, * out;
389 in = cr2res_create_hdrl(nx, ny, img_value, img_error);
392 out =
cr2res_calib_image(in, chip, 0, 0, 1, 0, NULL, NULL, NULL, NULL, dit, 1);
397 add_read_noise(in, dit, chip);
415static void test_cr2res_calib_flat()
421 double img_value = 100;
422 double img_error = 1;
423 double tmp_error = 0;
424 double out_value, out_error;
425 double flat_value, flat_error;
427 hdrl_image * in, * out, * cmp;
434 in = cr2res_create_hdrl(nx, ny, img_value, img_error);
439 char *my_path1 = cpl_sprintf(
"%s/TEST_master_flat.fits", localdir);
440 flat = create_master_flat(my_path1, nx, ny, flat_value, flat_error, NULL);
441 out =
cr2res_calib_image(in, chip, 0, 0, 1, 0, flat, NULL, NULL, NULL, dit, 1);
443 out_value = img_value / flat_value;
444 out_error = sqrt( pow(img_error / flat_value, 2) + pow(img_value * flat_error/ (flat_value * flat_value), 2));
445 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
449 add_read_noise(cmp, dit, chip);
456 cpl_frame_delete(flat);
461 flat = create_master_flat(my_path1, nx, ny, flat_value, flat_error, NULL);
462 out =
cr2res_calib_image(in, chip, 0, 0, 1, 0, flat, NULL, NULL, NULL, dit, 1);
464 out_value = img_value / flat_value;
465 tmp_error = img_error + sqrt(img_value) / sqrt(CR2RES_GAIN_CHIP1);
467 tmp_error = tmp_error + calc_read_noise(dit, 1, chip);
469 out_error = sqrt( pow(tmp_error / flat_value, 2) + pow(img_value * flat_error/ (flat_value * flat_value), 2));
470 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
477 cpl_frame_delete(flat);
482 flat = create_master_flat(my_path1, nx, ny, flat_value, flat_error, NULL);
483 out =
cr2res_calib_image(in, chip, 0, 0, 1, 0, flat, NULL, NULL, NULL, dit, 1);
488 cpl_frame_delete(flat);
491 flat = cpl_frame_new();
492 cpl_frame_set_filename(flat,
"TEST_tobeornottobe.fits");
493 cpl_frame_set_tag(flat,
"FLAT");
494 cpl_frame_set_group(flat, CPL_FRAME_GROUP_CALIB);
496 out =
cr2res_calib_image(in, chip, 0, 0, 1, 0, flat, NULL, NULL, NULL, dit, 1);
497 cpl_test_error(CPL_ERROR_FILE_IO);
499 cpl_frame_delete(flat);
502 flat = create_master_dark(my_path1, nx, ny, 1, 0, 10, NULL);
503 out =
cr2res_calib_image(in, chip, 0, 0, 1, 0, flat, NULL, NULL, NULL, dit, 1);
505 cpl_frame_delete(flat);
508 flat = cpl_frame_new();
509 out =
cr2res_calib_image(in, chip, 0, 0, 1, 0, flat, NULL, NULL, NULL, dit, 1);
510 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
512 cpl_frame_delete(flat);
515 flat = cpl_frame_new();
516 char *my_path2 = cpl_sprintf(
"%s/TEST_empty.fits", localdir);
517 cpl_frame_set_filename(flat, my_path2);
518 out =
cr2res_calib_image(in, chip, 0, 0, 1, 0, flat, NULL, NULL, NULL, dit, 1);
520 cpl_frame_delete(flat);
540static void test_cr2res_calib_dark()
546 double img_value = 100;
547 double img_error = 1;
548 double tmp_error = 0;
549 double out_value, out_error;
550 double dark_value, dark_error, dark_dit;
552 hdrl_image * in, * out, * cmp;
558 in = cr2res_create_hdrl(nx, ny, img_value, img_error);
559 char *my_path = cpl_sprintf(
"%s/TEST_master_dark.fits", localdir);
560 char *my_path2 = cpl_sprintf(
"%s/TEST_empty.fits", localdir);
567 dark = create_master_dark(my_path, nx, ny, dark_value, dark_error, dark_dit, NULL);
568 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
570 out_value = img_value - dit/dark_dit * dark_value;
571 tmp_error = img_error + sqrt(img_value) / sqrt(CR2RES_GAIN_CHIP1);
572 tmp_error = tmp_error + calc_read_noise(dit, 1, chip);
573 out_error = sqrt(pow(tmp_error, 2) + pow(dit/dark_dit * dark_error, 2));
574 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
581 cpl_frame_delete(dark);
586 dark_dit = dit * 2.3;
587 dark = create_master_dark(my_path, nx, ny, dark_value, dark_error, dark_dit, NULL);
588 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
590 out_value = img_value - dit/dark_dit * dark_value;
591 tmp_error = img_error + sqrt(img_value) / sqrt(CR2RES_GAIN_CHIP1);
592 tmp_error = tmp_error + calc_read_noise(dit, 1, chip);
593 out_error = sqrt(pow(tmp_error, 2) + pow(dit/dark_dit * dark_error, 2));
594 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
601 cpl_frame_delete(dark);
607 dark = create_master_dark(my_path, nx, ny, dark_value, dark_error, dark_dit, NULL);
608 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
610 out_value = img_value - dit/dark_dit * dark_value;
611 tmp_error = img_error + sqrt(img_value) / sqrt(CR2RES_GAIN_CHIP1);
612 tmp_error = tmp_error + calc_read_noise(dit, 1, chip);
613 out_error = sqrt(pow(tmp_error, 2) + pow(dit/dark_dit * dark_error, 2));
614 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
621 cpl_frame_delete(dark);
627 dark = create_master_dark(my_path, nx, ny, dark_value, dark_error, dark_dit, NULL);
628 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
630 out_value = img_value - dit/dark_dit * dark_value;
631 tmp_error = img_error + sqrt(img_value) / sqrt(CR2RES_GAIN_CHIP1);
632 tmp_error = tmp_error + calc_read_noise(dit, 1, chip);
633 out_error = sqrt(pow(tmp_error, 2) + pow(dit/dark_dit * dark_error, 2));
634 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
641 cpl_frame_delete(dark);
646 dark_dit = dit * 2.3;
647 dark = create_master_dark(my_path, nx, ny, dark_value, dark_error, dark_dit, NULL);
648 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
650 out_value = img_value - dit/dark_dit * dark_value;
651 tmp_error = img_error + sqrt(img_value) / sqrt(CR2RES_GAIN_CHIP1);
652 tmp_error = tmp_error + calc_read_noise(dit, 1, chip);
653 out_error = sqrt(pow(tmp_error, 2) + pow(dit/dark_dit * dark_error, 2));
654 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
661 cpl_frame_delete(dark);
666 dark_dit = dit * 2.3;
667 dark = create_master_dark(my_path, nx, ny, dark_value, dark_error, dark_dit, NULL);
668 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
670 out_value = img_value - dit/dark_dit * dark_value;
671 tmp_error = img_error + sqrt(img_value) / sqrt(CR2RES_GAIN_CHIP1);
672 tmp_error = tmp_error + calc_read_noise(dit, 1, chip);
673 out_error = sqrt(pow(tmp_error, 2) + pow(dit/dark_dit * dark_error, 2));
674 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
681 cpl_frame_delete(dark);
686 dark_dit = -dit * 2.3;
687 dark = create_master_dark(my_path, nx, ny, dark_value, dark_error, dark_dit, NULL);
688 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
690 out_value = img_value - dit/dark_dit * dark_value;
691 tmp_error = img_error + sqrt(img_value) / sqrt(CR2RES_GAIN_CHIP1);
692 tmp_error = tmp_error + calc_read_noise(dit, 1, chip);
693 out_error = sqrt(pow(tmp_error, 2) + pow(dit/dark_dit * dark_error, 2));
694 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
701 cpl_frame_delete(dark);
706 dark_dit = -dit * 2.3;
707 dark = create_master_dark(my_path, nx, ny, dark_value, dark_error, dark_dit, NULL);
708 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
710 out_value = img_value - dit/dark_dit * dark_value;
711 tmp_error = img_error + sqrt(img_value) / sqrt(CR2RES_GAIN_CHIP1);
712 tmp_error = tmp_error + calc_read_noise(dit, 1, chip);
713 out_error = sqrt(pow(tmp_error, 2) + pow(dit/dark_dit * dark_error, 2));
714 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
721 cpl_frame_delete(dark);
724 dark = cpl_frame_new();
725 cpl_frame_set_filename(dark,
"TEST_tobeornottobe.fits");
726 cpl_frame_set_tag(dark,
"DARK");
727 cpl_frame_set_group(dark, CPL_FRAME_GROUP_CALIB);
729 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
730 cpl_test_error(CPL_ERROR_FILE_IO);
732 cpl_frame_delete(dark);
735 dark = create_master_flat(my_path, nx, ny, 1, 0, NULL);
736 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
738 cpl_frame_delete(dark);
741 dark = cpl_frame_new();
742 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
743 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
745 cpl_frame_delete(dark);
750 dark = cpl_frame_new();
751 cpl_frame_set_filename(dark, my_path2);
752 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, dark, NULL, NULL, dit, 1);
754 cpl_frame_delete(dark);
775static void test_cr2res_calib_bpm()
781 double img_value = 100;
782 double img_error = 1;
789 hdrl_image * in, * out, * cmp;
794 in = cr2res_create_hdrl(nx, ny, img_value, img_error);
795 value.data = 10; value.error = img_error;
798 char *my_path = cpl_sprintf(
"%s/TEST_master_bpm.fits", localdir);
799 char *my_path2 = cpl_sprintf(
"%s/TEST_empty.fits", localdir);
803 bpm = create_bpm(my_path, nx, ny, 0);
804 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, bpm, NULL, dit, 1);
807 cpl_image_divide_scalar(tmp, sqrt(CR2RES_GAIN_CHIP1));
808 add_read_noise_cpl(tmp, dit, chip);
810 cpl_image_delete(tmp);
814 cpl_frame_delete(bpm);
819 bpm = create_bpm(my_path, nx, ny, 1);
820 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, bpm, NULL, dit, 1);
821 cpl_test_nonnull(out);
823 cpl_frame_delete(bpm);
827 bpm = cpl_frame_new();
828 cpl_frame_set_filename(bpm, my_path);
829 cpl_frame_set_tag(bpm,
"BPM");
830 cpl_frame_set_group(bpm, CPL_FRAME_GROUP_CALIB);
832 hdrl = cr2res_create_hdrl(nx, ny, 0, 0);
835 save_hdrl(my_path, hdrl, MODE_BPM, 0);
838 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, bpm, NULL, dit, 1);
841 cpl_image_divide_scalar(tmp, sqrt(CR2RES_GAIN_CHIP1));
842 add_read_noise_cpl(tmp, dit, chip);
844 cpl_image_delete(tmp);
850 for (
size_t i = 1; i <= (size_t) nx; i++)
852 for (
size_t j = 1; j <= (size_t) ny; j++)
863 cpl_frame_delete(bpm);
868 bpm = cpl_frame_new();
869 cpl_frame_set_filename(bpm, my_path);
870 cpl_frame_set_tag(bpm,
"BPM");
871 cpl_frame_set_group(bpm, CPL_FRAME_GROUP_CALIB);
873 hdrl = cr2res_create_hdrl(nx, ny, 1, 0);
876 save_hdrl(my_path, hdrl, MODE_BPM, 0);
879 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, bpm, NULL, dit, 1);
882 cpl_image_divide_scalar(tmp, sqrt(CR2RES_GAIN_CHIP1));
883 add_read_noise_cpl(tmp, dit, chip);
885 cpl_image_delete(tmp);
891 for (
size_t i = 1; i <= (size_t) nx; i++)
893 for (
size_t j = 1; j <= (size_t) ny; j++)
905 cpl_frame_delete(bpm);
910 bpm = cpl_frame_new();
911 cpl_frame_set_filename(bpm,
"TEST_tobeornottobe.fits");
912 cpl_frame_set_tag(bpm,
"BPM");
913 cpl_frame_set_group(bpm, CPL_FRAME_GROUP_CALIB);
915 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, bpm, NULL, dit, 1);
916 cpl_test_error(CPL_ERROR_FILE_IO);
918 cpl_frame_delete(bpm);
921 bpm = create_master_flat(my_path, nx, ny, 1, 0, NULL);
922 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, bpm, NULL, dit, 1);
924 cpl_frame_delete(bpm);
927 bpm = cpl_frame_new();
928 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, bpm, NULL, dit, 1);
929 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
931 cpl_frame_delete(bpm);
935 bpm = cpl_frame_new();
936 cpl_frame_set_filename(bpm, my_path2);
937 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, bpm, NULL, dit, 1);
939 cpl_frame_delete(bpm);
947static void test_cr2res_calib_detlin()
953 double img_value = 20000;
954 double img_error = 200;
955 double out_value, out_error;
960 hdrl_image * in, * out, * cmp;
961 hdrl_image * ima, * imb, * imc;
962 double a, b, c, sa, sb, sc;
968 in = cr2res_create_hdrl(nx, ny, img_value, img_error);
969 i = img_value; si = img_error;
971 char *my_path = cpl_sprintf(
"%s/TEST_master_detlin.fits", localdir);
972 char *my_path2 = cpl_sprintf(
"%s/TEST_empty.fits", localdir);
982 ima = cr2res_create_hdrl(nx, ny, a, sa);
983 imb = cr2res_create_hdrl(nx, ny, b, sb);
984 imc = cr2res_create_hdrl(nx, ny, c, sc);
986 detlin = create_detlin(my_path, ima, imb, imc);
987 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
990 sqrt(img_value) / sqrt(CR2RES_GAIN_CHIP1));
992 add_read_noise(cmp, dit, chip);
997 cpl_frame_delete(detlin);
1006 ima = cr2res_create_hdrl(nx, ny, a, sa);
1007 imb = cr2res_create_hdrl(nx, ny, b, sb);
1008 imc = cr2res_create_hdrl(nx, ny, c, sc);
1009 detlin = create_detlin(my_path, ima, imb, imc);
1010 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
1011 out_value = detlin(img_value, a, b, c);
1012 out_error = deterr(img_value, a, b, c, img_error, sa, sb, sc);
1013 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
1015 sqrt(out_value)/sqrt(CR2RES_GAIN_CHIP1));
1017 add_read_noise(cmp, dit, chip);
1025 cpl_frame_delete(detlin);
1034 ima = cr2res_create_hdrl(nx, ny, a, sa);
1035 imb = cr2res_create_hdrl(nx, ny, b, sb);
1036 imc = cr2res_create_hdrl(nx, ny, c, sc);
1037 detlin = create_detlin(my_path, ima, imb, imc);
1038 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
1039 cmp = cr2res_create_hdrl(nx, ny, 0, 0);
1040 add_read_noise(cmp, dit, chip);
1048 cpl_frame_delete(detlin);
1056 ima = cr2res_create_hdrl(nx, ny, a, sa);
1057 imb = cr2res_create_hdrl(nx, ny, b, sb);
1058 imc = cr2res_create_hdrl(nx, ny, c, sc);
1059 detlin = create_detlin(my_path, ima, imb, imc);
1060 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
1061 out_value = img_value * a;
1062 out_error = img_error * a;
1063 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
1065 sqrt(out_value)/sqrt(CR2RES_GAIN_CHIP1));
1067 add_read_noise(cmp, dit, chip);
1075 cpl_frame_delete(detlin);
1082 a = 2; b = 0; c = 0;
1084 ima = cr2res_create_hdrl(nx, ny, a, sa);
1085 imb = cr2res_create_hdrl(nx, ny, b, sb);
1086 imc = cr2res_create_hdrl(nx, ny, c, sc);
1087 detlin = create_detlin(my_path, ima, imb, imc);
1088 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
1089 out_value = detlin(i, a, b, c);
1090 out_error = deterr(i, a, b, c, si, sa, sb, sc);
1091 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
1093 sqrt(out_value)/sqrt(CR2RES_GAIN_CHIP1));
1095 add_read_noise(cmp, dit, chip);
1103 cpl_frame_delete(detlin);
1112 ima = cr2res_create_hdrl(nx, ny, a, sa);
1113 imb = cr2res_create_hdrl(nx, ny, b, sb);
1114 imc = cr2res_create_hdrl(nx, ny, c, sc);
1115 detlin = create_detlin(my_path, ima, imb, imc);
1116 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
1117 out_value = detlin(i, a, b, c);
1118 out_error = deterr(i, a, b, c, si, sa, sb, sc);
1119 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
1121 sqrt(out_value)/sqrt(CR2RES_GAIN_CHIP1));
1123 add_read_noise(cmp, dit, chip);
1131 cpl_frame_delete(detlin);
1139 sa = sc = 0; sb = 1;
1140 ima = cr2res_create_hdrl(nx, ny, a, sa);
1141 imb = cr2res_create_hdrl(nx, ny, b, sb);
1142 imc = cr2res_create_hdrl(nx, ny, c, sc);
1143 detlin = create_detlin(my_path, ima, imb, imc);
1144 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
1145 out_value = pow2(img_value);
1146 out_error = deterr(i, a, b, c, si, sa, sb, sc);
1147 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
1149 sqrt(out_value)/sqrt(CR2RES_GAIN_CHIP1));
1151 add_read_noise(cmp, dit, chip);
1157 cpl_frame_delete(detlin);
1163 a = 1; c = 0; b = 1;
1164 sa = 1 ; sc = 0; sb = 1;
1165 ima = cr2res_create_hdrl(nx, ny, a, sa);
1166 imb = cr2res_create_hdrl(nx, ny, b, sb);
1167 imc = cr2res_create_hdrl(nx, ny, c, sc);
1168 detlin = create_detlin(my_path, ima, imb, imc);
1169 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
1170 out_value = detlin(i, a, b, c);
1171 out_error = deterr(i, a, b, c, si, sa, sb, sc);
1172 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
1174 sqrt(out_value / CR2RES_GAIN_CHIP1));
1176 add_read_noise(cmp, dit, chip);
1184 cpl_frame_delete(detlin);
1191 a = 1; c = 1; b = 0;
1192 sa = 1 ; sc = 1; sb = 0;
1193 i = img_value; si = img_error;
1194 ima = cr2res_create_hdrl(nx, ny, a, sa);
1195 imb = cr2res_create_hdrl(nx, ny, b, sb);
1196 imc = cr2res_create_hdrl(nx, ny, c, sc);
1197 detlin = create_detlin(my_path, ima, imb, imc);
1198 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
1199 out_value = detlin(i, a, b, c);
1200 out_error = deterr(i, a, b, c, si, sa, sb, sc);
1201 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
1203 sqrt(out_value)/sqrt(CR2RES_GAIN_CHIP1));
1205 add_read_noise(cmp, dit, chip);
1211 cpl_frame_delete(detlin);
1218 a = 1; c = 1; b = 1;
1219 sa = 1 ; sc = 1; sb = 1;
1220 i = img_value; si = img_error;
1221 ima = cr2res_create_hdrl(nx, ny, a, sa);
1222 imb = cr2res_create_hdrl(nx, ny, b, sb);
1223 imc = cr2res_create_hdrl(nx, ny, c, sc);
1224 detlin = create_detlin(my_path, ima, imb, imc);
1225 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
1226 out_value = detlin(i, a, b, c);
1227 out_error = deterr(i, a, b, c, si, sa, sb, sc);
1228 cmp = cr2res_create_hdrl(nx, ny, out_value, out_error);
1230 sqrt(out_value)/sqrt(CR2RES_GAIN_CHIP1));
1232 add_read_noise(cmp, dit, chip);
1238 cpl_frame_delete(detlin);
1244 detlin = cpl_frame_new();
1245 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
1246 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
1248 cpl_frame_delete(detlin);
1252 detlin = cpl_frame_new();
1253 cpl_frame_set_filename(detlin, my_path2);
1254 out =
cr2res_calib_image(in, chip, 0, 0, 0, 0, NULL, NULL, NULL, detlin, dit, 1);
1256 cpl_frame_delete(detlin);
1273 cpl_test_init(PACKAGE_BUGREPORT, CPL_MSG_DEBUG);
1275 create_empty_fits();
1277 test_cr2res_calib_image();
1278 test_cr2res_calib_cosmic();
1279 test_cr2res_calib_flat();
1280 test_cr2res_calib_dark();
1281 test_cr2res_calib_bpm();
1282 test_cr2res_calib_detlin();
1284 return cpl_test_end(0);
hdrl_image * cr2res_calib_image(const hdrl_image *in, int chip, int clean_bad, int subtract_nolight_rows, int subtract_interorder_column, int cosmics_corr, const cpl_frame *flat, const cpl_frame *dark, const cpl_frame *bpm, const cpl_frame *detlin, double dit, int ndit)
The images calibration routine for a given chip.
int cr2res_io_save_MASTER_FLAT(const char *filename, cpl_frameset *allframes, cpl_frameset *inframes, const cpl_parameterlist *parlist, hdrl_image **master_flats, const cpl_propertylist *qc_list, cpl_propertylist **ext_plist, const char *procatg, const char *recipe)
Save a MASTER_FLAT.
int cr2res_io_save_MASTER_DARK(const char *filename, cpl_frameset *allframes, cpl_frameset *inframes, const cpl_parameterlist *parlist, hdrl_image **master_darks, const cpl_propertylist *qc_list, cpl_propertylist **ext_plist, const char *procatg, const char *recipe)
Save a MASTER_DARK.
int cr2res_io_save_DETLIN_COEFFS(const char *filename, cpl_frameset *allframes, cpl_frameset *inframes, const cpl_parameterlist *parlist, hdrl_imagelist **coeffs, const cpl_propertylist *qc_list, cpl_propertylist **ext_plist, const char *procatg, const char *recipe)
Save a DETLIN COEFFS.
int cr2res_io_save_BPM(const char *filename, cpl_frameset *allframes, cpl_frameset *inframes, const cpl_parameterlist *parlist, cpl_image **bpms, const cpl_propertylist *qc_list, cpl_propertylist **ext_plist, const char *procatg, const char *recipe)
Save a BPM.
int hdrl_image_is_rejected(hdrl_image *self, cpl_size xpos, cpl_size ypos)
return if pixel is marked bad
cpl_error_code hdrl_image_set_pixel(hdrl_image *self, cpl_size xpos, cpl_size ypos, hdrl_value value)
set pixel values of hdrl_image
hdrl_image * hdrl_image_duplicate(const hdrl_image *himg)
copy hdrl_image
cpl_mask * hdrl_image_get_mask(hdrl_image *himg)
get cpl bad pixel mask from image
cpl_error_code hdrl_image_add_scalar(hdrl_image *self, hdrl_value value)
Elementwise addition of a scalar to an image.
cpl_image * hdrl_image_get_error(hdrl_image *himg)
get error as cpl image
cpl_size hdrl_image_count_rejected(const hdrl_image *self)
return number of rejected pixels
cpl_image * hdrl_image_get_image(hdrl_image *himg)
get data as cpl image
cpl_error_code hdrl_image_reject(hdrl_image *self, cpl_size xpos, cpl_size ypos)
mark pixel as bad
hdrl_image * hdrl_image_new(cpl_size nx, cpl_size ny)
create new zero filled hdrl image
void hdrl_image_delete(hdrl_image *himg)
delete hdrl_image
hdrl_image * hdrl_imagelist_unset(hdrl_imagelist *himlist, cpl_size pos)
Remove an image from an imagelist.
cpl_error_code hdrl_imagelist_set(hdrl_imagelist *himlist, hdrl_image *himg, cpl_size pos)
Insert an image into an imagelist.
void hdrl_imagelist_delete(hdrl_imagelist *himlist)
Free all memory used by a hdrl_imagelist object including the images.
hdrl_imagelist * hdrl_imagelist_new(void)
Create an empty imagelist.