28#include "hdrl_combine.h"
29#include "hdrl_types.h"
37#define ARRAY_LEN(a) sizeof((a))/sizeof((a)[0])
53#define hdrl_test_abs(a, b, tol, rej) \
55 cpl_test_eq(isnan(a), isnan(b)); \
56 cpl_test(rej == -1 || rej != 0); \
59 cpl_test_abs(a, b, tol); \
65_hdrl_image_get(cpl_image * img, cpl_size x, cpl_size y,
int * rej)
67 double v = cpl_image_get(img, x, y, rej);
69 size_t nx = cpl_image_get_size_x(img);
70 if (cpl_image_get_type(img) == CPL_TYPE_DOUBLE) {
71 v = cpl_image_get_data_double(img)[(y - 1) * nx + (x - 1)];
74 v = cpl_image_get_data_float(img)[(y - 1) * nx + (x - 1)];
93prep_l2v_input(cpl_imagelist * data,
101 size_t n = cpl_imagelist_get_size(data);
102 cpl_image * vimg = cpl_image_new(1, n, HDRL_TYPE_DATA);
103 cpl_image * verr = cpl_image_new(1, n, HDRL_TYPE_ERROR);
104 for (
size_t i = 0; i < n; i++) {
105 cpl_image * img = cpl_imagelist_get(data, i);
106 cpl_image_set(vimg, 1, i + 1, cpl_image_get(img, x, y, &d));
108 cpl_image_reject(vimg, 1, i + 1);
110 img = cpl_imagelist_get(errs, i);
111 cpl_image_set(verr, 1, i + 1, cpl_image_get(img, x, y, &d));
113 cpl_image_reject(verr, 1, i + 1);
116 cpl_imagelist_set(vl, vimg, 0);
117 cpl_imagelist_set(el, verr, 0);
136void test_l2i_and_l2v(cpl_imagelist * data,
137 cpl_imagelist * errs,
138 hdrl_collapse_imagelist_to_image_t * l2im,
139 hdrl_collapse_imagelist_to_vector_t * l2vm,
144 cpl_image * expcontrib)
148 cpl_image * outimg, *outerr, *contrib;
149 hdrl_imagelist_combine(data, errs, l2im, &outimg, &outerr, &contrib);
151 hdrl_test_abs(_hdrl_image_get(outimg, x, y, &d), v.v1, v.v2, d);
152 hdrl_test_abs(_hdrl_image_get(outerr, x, y, &d), e.v1, e.v2, d);
153 cpl_test_image_abs(contrib, expcontrib, 0);
154 cpl_image_delete(outimg);
155 cpl_image_delete(outerr);
156 cpl_image_delete(contrib);
160 cpl_imagelist * vl = cpl_imagelist_new();
161 cpl_imagelist * el = cpl_imagelist_new();
162 prep_l2v_input(data, errs, x, y, vl, el);
165 cpl_vector * voutimg, *vouterr;
166 cpl_array * acontrib;
167 hdrl_collapse_imagelist_to_vector_call(l2vm, vl, el,
168 &voutimg, &vouterr, &acontrib,
170 cpl_imagelist_delete(vl);
171 cpl_imagelist_delete(el);
173 hdrl_test_abs(cpl_vector_get(voutimg, 0), v.v1, v.v2, -1);
174 hdrl_test_abs(cpl_vector_get(vouterr, 0), e.v1, e.v2, -1);
176 cpl_test_abs(cpl_array_get_int(acontrib, 0, NULL),
177 cpl_image_get(expcontrib, x, y, &d), 0);
179 cpl_vector_delete(voutimg);
180 cpl_vector_delete(vouterr);
181 cpl_array_delete(acontrib);
182 hdrl_collapse_imagelist_to_image_delete(l2im);
183 hdrl_collapse_imagelist_to_vector_delete(l2vm);
186void test_parameters(
void)
215 HDRL_COLLAPSE_WEIGHTED_MEAN));
220void test_parlist(
void)
223 hdrl_parameter * hpar;
224 hdrl_parameter * sigclip_def =
226 hdrl_parameter * minmax_def =
228 hdrl_parameter * mode_def =
231 cpl_test_error(CPL_ERROR_NONE);
233 "RECIPE",
"collapse",
"UNKNOWN", sigclip_def, minmax_def, mode_def) ;
234 cpl_test_error(CPL_ERROR_NONE);
237 "RECIPE",
"collapse",
"MEAN", sigclip_def, minmax_def, mode_def) ;
238 cpl_test_error(CPL_ERROR_NONE);
241 "RECIPE",
"collapse",
"WEIGHTED_MEAN", sigclip_def, minmax_def, mode_def) ;
242 cpl_test_error(CPL_ERROR_NONE);
245 "RECIPE",
"collapse",
"MEDIAN", sigclip_def, minmax_def, mode_def) ;
246 cpl_test_error(CPL_ERROR_NONE);
249 "RECIPE",
"collapse",
"SIGCLIP", sigclip_def, minmax_def, mode_def) ;
250 cpl_test_error(CPL_ERROR_NONE);
253 "RECIPE",
"collapse",
"MINMAX", sigclip_def, minmax_def, mode_def) ;
254 cpl_test_error(CPL_ERROR_NONE);
257 "RECIPE",
"collapse",
"MODE", sigclip_def, minmax_def, mode_def) ;
258 cpl_test_error(CPL_ERROR_NONE);
265 cpl_test_eq(cpl_parameterlist_get_size(parlist5), 6 + 5);
283 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
285 cpl_test_error(CPL_ERROR_NONE);
292 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
294 cpl_test_error(CPL_ERROR_NONE);
301 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
303 cpl_test_error(CPL_ERROR_NONE);
310 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
312 cpl_test_error(CPL_ERROR_NONE);
325 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
327 cpl_test_error(CPL_ERROR_NONE);
338 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
340 cpl_test_error(CPL_ERROR_NONE);
353 cpl_parameterlist_delete(parlist );
354 cpl_parameterlist_delete(parlist1);
355 cpl_parameterlist_delete(parlist2);
356 cpl_parameterlist_delete(parlist3);
357 cpl_parameterlist_delete(parlist4);
358 cpl_parameterlist_delete(parlist5);
359 cpl_parameterlist_delete(parlist6);
380 hdrl_collapse_imagelist_to_vector_t * vMethod1;
381 vMethod1 = hdrl_collapse_imagelist_to_vector_mean();
383 void *eout1 = hdrl_collapse_imagelist_to_vector_create_eout(vMethod1, n);
386 hdrl_collapse_imagelist_to_vector_move_eout(vMethod1, eout1, eout2, n);
388 hdrl_collapse_imagelist_to_vector_delete_eout(vMethod1, eout2);
389 hdrl_collapse_imagelist_to_vector_delete_eout(vMethod1, eout1);
390 hdrl_collapse_imagelist_to_vector_delete(vMethod1);
394 hdrl_collapse_imagelist_to_vector_t *vMethod2;
395 vMethod2 = hdrl_collapse_imagelist_to_vector_minmax(3., 3.);
397 void *eout3 = hdrl_collapse_imagelist_to_vector_create_eout(vMethod2, n);
399 hdrl_collapse_imagelist_to_vector_delete_eout(vMethod2, eout3);
400 hdrl_collapse_imagelist_to_vector_delete(vMethod2);
404 hdrl_collapse_imagelist_to_vector_t *vMethod3;
405 vMethod3 = hdrl_collapse_imagelist_to_vector_sigclip(3., 3., 3);
407 void *eout4 = hdrl_collapse_imagelist_to_vector_create_eout(vMethod3, n);
408 void *eout5 = hdrl_collapse_imagelist_to_vector_create_eout(vMethod3, n);
410 hdrl_collapse_imagelist_to_vector_move_eout(vMethod3, NULL, eout5, n);
411 cpl_test_error(CPL_ERROR_NULL_INPUT);
412 hdrl_collapse_imagelist_to_vector_move_eout(vMethod3, eout4, NULL, n);
413 cpl_test_error(CPL_ERROR_NULL_INPUT);
414 hdrl_collapse_imagelist_to_vector_move_eout(vMethod3, eout4, eout4, n);
415 cpl_test_error(CPL_ERROR_ACCESS_OUT_OF_RANGE);
416 hdrl_collapse_imagelist_to_vector_move_eout(vMethod3, eout4, eout5, n);
417 cpl_test_error(CPL_ERROR_ACCESS_OUT_OF_RANGE);
418 hdrl_collapse_imagelist_to_vector_move_eout(vMethod3, eout5, eout4, n);
419 cpl_test_error(CPL_ERROR_ACCESS_OUT_OF_RANGE);
420 hdrl_collapse_imagelist_to_vector_move_eout(vMethod3, eout5, eout5, n);
421 cpl_test_error(CPL_ERROR_ACCESS_OUT_OF_RANGE);
423 hdrl_collapse_imagelist_to_vector_delete_eout(vMethod3, eout4);
424 hdrl_collapse_imagelist_to_vector_delete_eout(vMethod3, eout5);
425 hdrl_collapse_imagelist_to_vector_delete(vMethod3);
429 hdrl_collapse_imagelist_to_image_t *vMethod4;
430 vMethod4 = hdrl_collapse_imagelist_to_image_sigclip(3., 3., 3);
432 cpl_image *img = cpl_image_new(10, 10, CPL_TYPE_DOUBLE);
433 void *eout6 = hdrl_collapse_imagelist_to_image_create_eout(vMethod4, img);
434 cpl_image_delete(img);
436 hdrl_collapse_imagelist_to_image_delete_eout(vMethod4, eout6);
437 hdrl_collapse_imagelist_to_image_delete(vMethod4);
441void test_results(
void)
445 cpl_image_delete(outimg); outimg = NULL; \
446 cpl_image_delete(outerr); outerr = NULL; \
447 cpl_image_delete(contrib); contrib = NULL; \
448 cpl_vector_delete(voutimg); voutimg = NULL; \
449 cpl_vector_delete(vouterr); vouterr = NULL; \
450 cpl_array_delete(acontrib); acontrib = NULL; \
451 hdrl_collapse_imagelist_to_image_delete(method);
454 cpl_imagelist * data = cpl_imagelist_new();
455 cpl_imagelist * errs = cpl_imagelist_new();
459 cpl_image * img = cpl_image_new(nx, ny, CPL_TYPE_DOUBLE);
460 cpl_image * err = cpl_image_new(nx, ny, CPL_TYPE_DOUBLE);
461 cpl_image_add_scalar(img, 5.);
462 cpl_image_add_scalar(err, 2.);
465 cpl_image * expect_err = cpl_image_duplicate(err);
466 cpl_image_divide_scalar(expect_err, sqrt(nz));
467 cpl_image * expect_contrib = cpl_image_new(nx, ny, CPL_TYPE_INT);
468 cpl_image_add_scalar(expect_contrib, nz);
469 for (cpl_size i = 0; i < nz; i++) {
470 cpl_imagelist_set(data, cpl_image_duplicate(img),
471 cpl_imagelist_get_size(data));
472 cpl_imagelist_set(errs, cpl_image_duplicate(err),
473 cpl_imagelist_get_size(errs));
475 cpl_image * outimg, * outerr, * contrib;
477 cpl_vector * expect_vimg = cpl_vector_new(nz);
478 cpl_vector * expect_verr = cpl_vector_new(nz);
479 cpl_array * expect_acontrib = cpl_array_new(nz, CPL_TYPE_INT);
480 cpl_vector * voutimg, * vouterr;
481 cpl_array * acontrib;
482 cpl_vector_fill(expect_vimg, 5.);
483 cpl_vector_fill(expect_verr, 2. / sqrt(nx * ny));
484 cpl_array_fill_window_int(expect_acontrib, 0, nz, nx * ny);
489 hdrl_collapse_imagelist_to_image_t * method =
490 hdrl_collapse_imagelist_to_image_mean();
491 hdrl_collapse_imagelist_to_image_call(method, data, errs,
492 &outimg, &outerr, &contrib,
495 cpl_test_image_abs(outimg, img, HDRL_EPS_DATA);
496 cpl_test_image_abs(outerr, expect_err, HDRL_EPS_ERROR);
497 cpl_test_image_abs(contrib, expect_contrib, 0);
499 hdrl_collapse_imagelist_to_vector_t * vmethod =
500 hdrl_collapse_imagelist_to_vector_mean();
501 hdrl_collapse_imagelist_to_vector_call(vmethod, data, errs,
502 &voutimg, &vouterr, &acontrib,
504 cpl_test_vector_abs(voutimg, expect_vimg, HDRL_EPS_DATA);
505 cpl_test_vector_abs(vouterr, expect_verr, HDRL_EPS_ERROR);
506 cpl_test_array_abs(acontrib, expect_acontrib, 0);
507 hdrl_collapse_imagelist_to_vector_delete(vmethod);
511 method = hdrl_collapse_imagelist_to_image_sigclip(3., 3., 3);
512 hdrl_collapse_imagelist_to_image_call(method, data, errs,
513 &outimg, &outerr, &contrib,
516 cpl_test_image_abs(outimg, img, HDRL_EPS_DATA);
517 cpl_test_image_abs(outerr, expect_err, HDRL_EPS_ERROR);
518 cpl_test_image_abs(contrib, expect_contrib, 0);
521 vmethod = hdrl_collapse_imagelist_to_vector_sigclip(3., 3., 3);
522 hdrl_collapse_imagelist_to_vector_call(vmethod, data, errs,
523 &voutimg, &vouterr, &acontrib,
525 cpl_test_vector_abs(voutimg, expect_vimg, HDRL_EPS_DATA);
526 cpl_test_vector_abs(vouterr, expect_verr, HDRL_EPS_ERROR);
527 cpl_test_array_abs(acontrib, expect_acontrib, 0);
528 hdrl_collapse_imagelist_to_vector_delete(vmethod);
532 method = hdrl_collapse_imagelist_to_image_minmax(0., 0.);
533 hdrl_collapse_imagelist_to_image_call(method, data, errs,
534 &outimg, &outerr, &contrib,
537 cpl_test_image_abs(outimg, img, HDRL_EPS_DATA);
538 cpl_test_image_abs(outerr, expect_err, HDRL_EPS_ERROR);
539 cpl_test_image_abs(contrib, expect_contrib, 0);
542 vmethod = hdrl_collapse_imagelist_to_vector_minmax(0., 0.);
543 hdrl_collapse_imagelist_to_vector_call(vmethod, data, errs,
544 &voutimg, &vouterr, &acontrib,
546 cpl_test_vector_abs(voutimg, expect_vimg, HDRL_EPS_DATA);
547 cpl_test_vector_abs(vouterr, expect_verr, HDRL_EPS_ERROR);
548 cpl_test_array_abs(acontrib, expect_acontrib, 0);
549 hdrl_collapse_imagelist_to_vector_delete(vmethod);
553 method = hdrl_collapse_imagelist_to_image_weighted_mean();
554 hdrl_collapse_imagelist_to_image_call(method, data, errs,
555 &outimg, &outerr, &contrib,
558 cpl_test_image_abs(outimg, img, HDRL_EPS_DATA);
559 cpl_test_image_abs(outerr, expect_err, HDRL_EPS_ERROR);
560 cpl_test_image_abs(contrib, expect_contrib, 0);
564 cpl_image_multiply_scalar(expect_err, sqrt(CPL_MATH_PI_2));
565 method = hdrl_collapse_imagelist_to_image_median();
566 hdrl_collapse_imagelist_to_image_call(method, data, errs,
567 &outimg, &outerr, &contrib,
570 cpl_test_image_abs(outimg, img, HDRL_EPS_DATA);
571 cpl_test_image_abs(outerr, expect_err, HDRL_EPS_ERROR);
572 cpl_test_image_abs(contrib, expect_contrib, 0);
574 cpl_vector_multiply_scalar(expect_verr, sqrt(CPL_MATH_PI_2));
575 vmethod = hdrl_collapse_imagelist_to_vector_median();
576 hdrl_collapse_imagelist_to_vector_call(vmethod, data, errs,
577 &voutimg, &vouterr, &acontrib,
579 cpl_test_vector_abs(voutimg, expect_vimg, HDRL_EPS_DATA);
580 cpl_test_vector_abs(vouterr, expect_verr, HDRL_EPS_ERROR);
581 cpl_test_array_abs(acontrib, expect_acontrib, 0);
582 hdrl_collapse_imagelist_to_vector_delete(vmethod);
587 double v[] = {1, 2, 1, 3, 2};
588 double e[] = {0.5, 0.7, 0.1, 1.0, 0.01};
589 for (cpl_size i = 0; i < nz; i++) {
590 cpl_image * tmp = cpl_imagelist_get(data, i);
591 cpl_image_set(tmp, 1, 1, v[i]);
592 tmp = cpl_imagelist_get(errs, i);
593 cpl_image_set(tmp, 1, 1, e[i]);
595 hdrl_collapse_imagelist_to_image_t * method =
596 hdrl_collapse_imagelist_to_image_mean();
597 hdrl_collapse_imagelist_to_vector_t * vmethod =
598 hdrl_collapse_imagelist_to_vector_mean();
599 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
600 (pair){1.8, HDRL_EPS_DATA},
601 (pair){0.26458269028793246, HDRL_EPS_ERROR},
604 method = hdrl_collapse_imagelist_to_image_sigclip(3., 3., 3);
605 vmethod = hdrl_collapse_imagelist_to_vector_sigclip(3., 3., 3);
606 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
607 (pair){1.8, HDRL_EPS_DATA},
608 (pair){0.26458269028793246, HDRL_EPS_ERROR},
611 method = hdrl_collapse_imagelist_to_image_minmax(1, 1);
612 vmethod = hdrl_collapse_imagelist_to_vector_minmax(1, 1);
613 cpl_image * expect_contrib_minmax =
614 cpl_image_subtract_scalar_create(expect_contrib, 2);
615 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
616 (pair){5. / 3., HDRL_EPS_DATA},
617 (pair){sqrt(0.1 * 0.1 + 0.7 * 0.7 + 0.01 * 0.01) / 3.,
619 expect_contrib_minmax);
620 cpl_image_delete(expect_contrib_minmax);
622 method = hdrl_collapse_imagelist_to_image_weighted_mean();
623 vmethod = hdrl_collapse_imagelist_to_vector_weighted_mean();
624 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
625 (pair){1.9898090843925733, HDRL_EPS_ERROR},
626 (pair){0.0099469054598625289, HDRL_EPS_ERROR},
631 double v[] = {1, 2, 1, 3, 2};
632 double e[] = {0.5, 0.7, 0.1, 1.0, 0.01};
633 for (cpl_size i = 0; i < nz; i++) {
634 cpl_image * tmp = cpl_imagelist_get(data, i);
635 cpl_image_set(tmp, 1, 1, v[i]);
637 cpl_image_reject(tmp, 1, 1);
639 tmp = cpl_imagelist_get(errs, i);
640 cpl_image_set(tmp, 1, 1, e[i]);
642 cpl_image_reject(tmp, 1, 1);
645 cpl_image_delete(expect_contrib);
646 expect_contrib = cpl_image_new_from_accepted(data);
648 hdrl_collapse_imagelist_to_image_t * method =
649 hdrl_collapse_imagelist_to_image_mean();
650 hdrl_collapse_imagelist_to_vector_t * vmethod =
651 hdrl_collapse_imagelist_to_vector_mean();
652 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
653 (pair){1.5, HDRL_EPS_DATA},
654 (pair){0.21652078422174625, HDRL_EPS_ERROR},
657 method = hdrl_collapse_imagelist_to_image_sigclip(3., 3., 3);
658 vmethod = hdrl_collapse_imagelist_to_vector_sigclip(3., 3., 3);
659 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
660 (pair){1.5, HDRL_EPS_DATA},
661 (pair){0.21652078422174625, HDRL_EPS_ERROR},
664 method = hdrl_collapse_imagelist_to_image_minmax(1, 1);
665 vmethod = hdrl_collapse_imagelist_to_vector_minmax(1, 1);
666 cpl_image * expect_contrib_minmax =
667 cpl_image_subtract_scalar_create(expect_contrib, 2);
668 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
669 (pair){3. / 2., HDRL_EPS_DATA},
670 (pair){sqrt(0.1 * 0.1 + 0.01 * 0.01) / 2.,
672 expect_contrib_minmax);
673 cpl_image_delete(expect_contrib_minmax);
675 method = hdrl_collapse_imagelist_to_image_weighted_mean();
676 vmethod = hdrl_collapse_imagelist_to_vector_weighted_mean();
677 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
678 (pair){1.9897091252756485, HDRL_EPS_ERROR},
679 (pair){0.0099473975744101273, HDRL_EPS_ERROR},
684 double v[] = {1, 2, 1, 3, 2};
685 double e[] = {0.5, 0.7, 0.1, 1.0, 0.01};
686 for (cpl_size i = 0; i < nz; i++) {
687 cpl_image * tmp = cpl_imagelist_get(data, i);
688 cpl_image_set(tmp, 1, 1, v[i]);
689 cpl_image_reject(tmp, 1, 1);
690 tmp = cpl_imagelist_get(errs, i);
691 cpl_image_set(tmp, 1, 1, e[i]);
692 cpl_image_reject(tmp, 1, 1);
694 cpl_image_delete(expect_contrib);
695 expect_contrib = cpl_image_new_from_accepted(data);
697 hdrl_collapse_imagelist_to_image_t * img_meth[] = {
698 hdrl_collapse_imagelist_to_image_mean(),
699 hdrl_collapse_imagelist_to_image_sigclip(3., 3., 3),
700 hdrl_collapse_imagelist_to_image_weighted_mean(),
701 hdrl_collapse_imagelist_to_image_median(),
703 hdrl_collapse_imagelist_to_vector_t * vec_meth[] = {
704 hdrl_collapse_imagelist_to_vector_mean(),
705 hdrl_collapse_imagelist_to_vector_sigclip(3., 3., 3),
706 hdrl_collapse_imagelist_to_vector_weighted_mean(),
707 hdrl_collapse_imagelist_to_vector_median(),
710 for (
size_t i = 0; i < ARRAY_LEN(img_meth); i++) {
711 test_l2i_and_l2v(data, errs, img_meth[i], vec_meth[i], 1, 1,
712 (pair){NAN, HDRL_EPS_DATA},
713 (pair){NAN, HDRL_EPS_ERROR},
717 hdrl_collapse_imagelist_to_image_t * method =
718 hdrl_collapse_imagelist_to_image_minmax(1., 1.);
719 hdrl_collapse_imagelist_to_vector_t * vmethod =
720 hdrl_collapse_imagelist_to_vector_minmax(1., 1.);
721 cpl_image * expect_contrib_minmax =
722 cpl_image_subtract_scalar_create(expect_contrib, 2);
723 cpl_image_set(expect_contrib_minmax, 1, 1, 0);
724 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
725 (pair){NAN, HDRL_EPS_DATA},
726 (pair){NAN, HDRL_EPS_ERROR},
727 expect_contrib_minmax);
728 cpl_image_delete(expect_contrib_minmax);
732 for (cpl_size i = 0; i < nz; i++) {
733 cpl_image * tmp = cpl_imagelist_get(data, i);
734 cpl_image_accept_all(tmp);
735 cpl_mask_not(cpl_image_get_bpm(tmp));
737 cpl_image_delete(expect_contrib);
738 expect_contrib = cpl_image_new_from_accepted(data);
740 hdrl_collapse_imagelist_to_image_t * img_meth[] = {
741 hdrl_collapse_imagelist_to_image_mean(),
742 hdrl_collapse_imagelist_to_image_sigclip(3., 3., 3),
743 hdrl_collapse_imagelist_to_image_weighted_mean(),
744 hdrl_collapse_imagelist_to_image_median(),
745 hdrl_collapse_imagelist_to_image_minmax(1., 1.),
747 hdrl_collapse_imagelist_to_vector_t * vec_meth[] = {
748 hdrl_collapse_imagelist_to_vector_mean(),
749 hdrl_collapse_imagelist_to_vector_sigclip(3., 3., 3),
750 hdrl_collapse_imagelist_to_vector_weighted_mean(),
751 hdrl_collapse_imagelist_to_vector_median(),
752 hdrl_collapse_imagelist_to_vector_minmax(1., 1.),
755 for (
size_t i = 0; i < ARRAY_LEN(img_meth); i++) {
756 cpl_image * outimg_loc, *outerr_loc, *contrib_loc;
757 hdrl_imagelist_combine(data, errs, img_meth[i], &outimg_loc, &outerr_loc, &contrib_loc);
759 cpl_test_error(CPL_ERROR_NONE);
761 cpl_test_image_abs(contrib_loc, expect_contrib, 0);
762 cpl_test_eq(cpl_image_count_rejected(outimg_loc), nx *ny);
763 cpl_test_eq(cpl_image_count_rejected(outerr_loc), nx *ny);
764 cpl_image_delete(outimg_loc);
765 cpl_image_delete(outerr_loc);
766 cpl_image_delete(contrib_loc);
769 test_l2i_and_l2v(data, errs, img_meth[i], vec_meth[i], 1, 1,
770 (pair){NAN, HDRL_EPS_DATA},
771 (pair){NAN, HDRL_EPS_ERROR},
773 cpl_test_error(CPL_ERROR_NONE);
779 double v[] = {1, 2, 1, 3, 2};
780 double e[] = {1., 1., 1., 1., 1.};
782 for (cpl_size i = 0; i < nz; i++) {
783 cpl_image * tmp = cpl_imagelist_get(data, i);
784 cpl_image_set(tmp, 1, 1, v[i]);
785 cpl_image_set(tmp, 2, 2, v[i]);
787 cpl_image_reject(tmp, 1, 1);
789 tmp = cpl_imagelist_get(errs, i);
790 cpl_image_set(tmp, 1, 1, e[i]);
791 cpl_image_set(tmp, 2, 2, e[i]);
793 cpl_image_reject(tmp, 1, 1);
796 cpl_image_delete(expect_contrib);
797 expect_contrib = cpl_image_new_from_accepted(data);
799 hdrl_collapse_imagelist_to_image_t * method =
800 hdrl_collapse_imagelist_to_image_median();
801 hdrl_imagelist_combine(data, errs, method, &outimg, &outerr, &contrib);
804 cpl_test_abs(cpl_image_get(outimg, 2, 2, &d), 2., HDRL_EPS_DATA);
805 cpl_test_abs(cpl_image_get(outerr, 2, 2, &d),
806 1. / sqrt(nz) * sqrt(CPL_MATH_PI_2), HDRL_EPS_ERROR);
808 cpl_test_abs(cpl_image_get(outimg, 1, 1, &d), 1.5, HDRL_EPS_DATA);
809 cpl_test_abs(cpl_image_get(outerr, 1, 1, &d), 1. / sqrt(2.), HDRL_EPS_ERROR);
810 cpl_test_image_abs(contrib, expect_contrib, 0);
812 cpl_imagelist * vl = cpl_imagelist_new();
813 cpl_imagelist * el = cpl_imagelist_new();
814 prep_l2v_input(data, errs, 1, 1, vl, el);
815 hdrl_collapse_imagelist_to_vector_t * vmethod =
816 hdrl_collapse_imagelist_to_vector_median();
817 hdrl_collapse_imagelist_to_vector_call(vmethod, vl, el,
818 &voutimg, &vouterr, &acontrib,
821 cpl_test_abs(cpl_vector_get(voutimg, 0), 1.5, HDRL_EPS_DATA);
822 cpl_test_abs(cpl_vector_get(vouterr, 0), 1. / sqrt(2.), HDRL_EPS_ERROR);
824 cpl_test_abs(cpl_array_get_int(acontrib, 0, NULL), 2, 0);
825 cpl_vector_delete(voutimg);
826 cpl_vector_delete(vouterr);
827 cpl_array_delete(acontrib);
828 cpl_imagelist_empty(vl);
829 cpl_imagelist_empty(el);
831 prep_l2v_input(data, errs, 2, 2, vl, el);
832 hdrl_collapse_imagelist_to_vector_call(vmethod, vl, el,
833 &voutimg, &vouterr, &acontrib,
836 cpl_test_abs(cpl_vector_get(voutimg, 0), 2., HDRL_EPS_DATA);
837 cpl_test_abs(cpl_vector_get(vouterr, 0),
838 1. / sqrt(nz) * sqrt(CPL_MATH_PI_2), HDRL_EPS_ERROR);
840 cpl_test_abs(cpl_array_get_int(acontrib, 0, NULL), 5, 0);
841 cpl_imagelist_delete(vl);
842 cpl_imagelist_delete(el);
843 hdrl_collapse_imagelist_to_vector_delete(vmethod);
848 cpl_imagelist_delete(data);
849 cpl_imagelist_delete(errs);
850 cpl_image_delete(expect_err);
851 cpl_image_delete(expect_contrib);
852 cpl_image_delete(img);
853 cpl_image_delete(err);
854 cpl_vector_delete(expect_vimg);
855 cpl_vector_delete(expect_verr);
856 cpl_array_delete(expect_acontrib);
861void test_results_mode(
void)
863#define TST_FREE_MODE \
864 cpl_image_delete(outimg); outimg = NULL; \
865 cpl_image_delete(outerr); outerr = NULL; \
866 cpl_image_delete(contrib); contrib = NULL; \
867 cpl_vector_delete(voutimg); voutimg = NULL; \
868 cpl_vector_delete(vouterr); vouterr = NULL; \
869 cpl_array_delete(acontrib); acontrib = NULL; \
870 hdrl_collapse_imagelist_to_image_delete(method);
873 cpl_imagelist * data = cpl_imagelist_new();
874 cpl_imagelist * errs = cpl_imagelist_new();
878 cpl_image * img = cpl_image_new(nx, ny, CPL_TYPE_DOUBLE);
879 cpl_image * err = cpl_image_new(nx, ny, CPL_TYPE_DOUBLE);
880 cpl_image_add_scalar(img, 3.5);
881 cpl_image_add_scalar(err, 1.5);
884 cpl_image * expect_err = cpl_image_duplicate(err);
885 cpl_image_divide_scalar(expect_err, sqrt(nz));
886 cpl_image * expect_contrib = cpl_image_new(nx, ny, CPL_TYPE_INT);
887 cpl_image_add_scalar(expect_contrib, nz);
888 for (cpl_size i = 0; i < nz; i++) {
889 cpl_imagelist_set(data, cpl_image_duplicate(img),
890 cpl_imagelist_get_size(data));
891 cpl_imagelist_set(errs, cpl_image_duplicate(err),
892 cpl_imagelist_get_size(errs));
894 cpl_image * outimg, * outerr, * contrib;
896 cpl_vector * expect_vimg = cpl_vector_new(nz);
897 cpl_vector * expect_verr = cpl_vector_new(nz);
898 cpl_array * expect_acontrib = cpl_array_new(nz, CPL_TYPE_INT);
899 cpl_vector * voutimg = NULL, * vouterr = NULL;
900 cpl_array * acontrib = NULL;
901 cpl_vector_fill(expect_vimg, 3.5);
902 cpl_vector_fill(expect_verr, 1.5 / sqrt(nx * ny));
903 cpl_array_fill_window_int(expect_acontrib, 0, nz, nx * ny);
909 cpl_image * mode_expect_err = cpl_image_new(nx, ny, CPL_TYPE_DOUBLE);
910 cpl_vector * mode_expect_verr = cpl_vector_new(nz);
911 cpl_vector_fill(mode_expect_verr, 0.);
913 hdrl_collapse_imagelist_to_image_t * method =
914 hdrl_collapse_imagelist_to_image_mode(5, 5, 0, HDRL_MODE_MEDIAN, 20);
915 hdrl_collapse_imagelist_to_image_call(method, data, errs,
916 &outimg, &outerr, &contrib,
919 cpl_test_image_abs(outimg, img, HDRL_EPS_DATA);
920 cpl_test_image_abs(outerr, mode_expect_err, HDRL_EPS_ERROR);
921 cpl_test_image_abs(contrib, expect_contrib, 0);
924 method = hdrl_collapse_imagelist_to_image_mode(3, 4, 1, HDRL_MODE_MEDIAN, 20);
925 hdrl_collapse_imagelist_to_image_call(method, data, errs,
926 &outimg, &outerr, &contrib,
929 cpl_test_image_abs(outimg, img, HDRL_EPS_DATA);
930 cpl_test_image_abs(outerr, mode_expect_err, HDRL_EPS_ERROR);
931 cpl_test_image_abs(contrib, expect_contrib, 0);
932 cpl_image_delete(mode_expect_err);
935 hdrl_collapse_imagelist_to_vector_t * vmethod =
936 hdrl_collapse_imagelist_to_vector_mode(3., 4. ,1., HDRL_MODE_MEDIAN, 20);
937 hdrl_collapse_imagelist_to_vector_call(vmethod, data, errs,
938 &voutimg, &vouterr, &acontrib,
940 cpl_test_vector_abs(voutimg, expect_vimg, HDRL_EPS_DATA);
941 cpl_test_vector_abs(vouterr, mode_expect_verr, HDRL_EPS_ERROR);
942 cpl_test_array_abs(acontrib, expect_acontrib, 0);
943 hdrl_collapse_imagelist_to_vector_delete(vmethod);
944 cpl_vector_delete(mode_expect_verr);
949 mode_expect_err = cpl_image_new(nx, ny, CPL_TYPE_DOUBLE);
950 mode_expect_verr = cpl_vector_new(nz);
951 cpl_vector_fill(mode_expect_verr, 0.);
952 method = hdrl_collapse_imagelist_to_image_mode(5, 5, 0, HDRL_MODE_WEIGHTED, 20);
953 hdrl_collapse_imagelist_to_image_call(method, data, errs,
954 &outimg, &outerr, &contrib,
957 cpl_test_image_abs(outimg, img, HDRL_EPS_DATA * 2);
958 cpl_test_image_abs(outerr, mode_expect_err, HDRL_EPS_ERROR);
959 cpl_test_image_abs(contrib, expect_contrib, 0);
962 method = hdrl_collapse_imagelist_to_image_mode(3., 4., 1, HDRL_MODE_WEIGHTED, 20);
963 hdrl_collapse_imagelist_to_image_call(method, data, errs,
964 &outimg, &outerr, &contrib,
968 cpl_test_image_abs(outimg, img, HDRL_EPS_DATA);
971 cpl_test_image_abs(outerr, mode_expect_err, HDRL_EPS_ERROR);
972 cpl_test_image_abs(contrib, expect_contrib, 0);
973 cpl_image_delete(mode_expect_err);
976 vmethod = hdrl_collapse_imagelist_to_vector_mode(3., 4. ,1., HDRL_MODE_WEIGHTED, 20);
977 hdrl_collapse_imagelist_to_vector_call(vmethod, data, errs,
978 &voutimg, &vouterr, &acontrib,
981 cpl_test_vector_abs(voutimg, expect_vimg, HDRL_EPS_DATA);
983 cpl_test_vector_abs(vouterr, mode_expect_verr, HDRL_EPS_ERROR);
984 cpl_test_array_abs(acontrib, expect_acontrib, 0);
985 hdrl_collapse_imagelist_to_vector_delete(vmethod);
986 cpl_vector_delete(mode_expect_verr);
991 method = hdrl_collapse_imagelist_to_image_mode(5, 5, 0, HDRL_MODE_FIT, 20);
992 hdrl_collapse_imagelist_to_image_call(method, data, errs,
993 &outimg, &outerr, &contrib,
997 cpl_test_eq(cpl_image_count_rejected(outimg), nx * ny);
998 cpl_test_eq(cpl_image_count_rejected(outerr), nx * ny);
999 cpl_test_eq(cpl_image_get_sqflux(contrib), 0);
1002 method = hdrl_collapse_imagelist_to_image_mode(2, 5, 1, HDRL_MODE_FIT, 20);
1003 hdrl_collapse_imagelist_to_image_call(method, data, errs,
1004 &outimg, &outerr, &contrib,
1007 cpl_test_eq(cpl_image_count_rejected(outimg), 0);
1008 cpl_test_eq(cpl_image_count_rejected(outerr), 0);
1009 cpl_test_eq(cpl_image_get_sqflux(contrib), 400.);
1011 vmethod = hdrl_collapse_imagelist_to_vector_mode(2., 5. ,1., HDRL_MODE_FIT, 20);
1012 hdrl_collapse_imagelist_to_vector_call(vmethod, data, errs,
1013 &voutimg, &vouterr, &acontrib,
1017 cpl_test_eq(cpl_image_count_rejected(outimg), 0);
1018 cpl_test_eq(cpl_image_count_rejected(outerr), 0);
1019 cpl_test_eq(cpl_image_get_sqflux(contrib), 400.);
1020 hdrl_collapse_imagelist_to_vector_delete(vmethod);
1026 double v[] = {1.5, 2.5, 2.5, 3.5, 3.5, 3.5, 3.5, 4.5, 4.5, 5.5};
1027 double e[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1028 for (cpl_size i = 0; i < nz; i++) {
1029 cpl_image * tmp = cpl_imagelist_get(data, i);
1030 cpl_image_set(tmp, 1, 1, v[i]);
1031 tmp = cpl_imagelist_get(errs, i);
1032 cpl_image_set(tmp, 1, 1, e[i]);
1039 hdrl_collapse_imagelist_to_image_t * method =
1040 hdrl_collapse_imagelist_to_image_mode(0, 0, 0, HDRL_MODE_MEDIAN, 0);
1041 hdrl_collapse_imagelist_to_vector_t * vmethod =
1042 hdrl_collapse_imagelist_to_vector_mode(0, 0, 0, HDRL_MODE_MEDIAN, 0);
1051 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
1052 (pair){3.5, HDRL_EPS_DATA},
1053 (pair){0.7867957924694431, HDRL_EPS_ERROR},
1057 method = hdrl_collapse_imagelist_to_image_mode(3, 4, 1, HDRL_MODE_MEDIAN, 0);
1058 vmethod = hdrl_collapse_imagelist_to_vector_mode(3, 4, 1, HDRL_MODE_MEDIAN, 0);
1060 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
1061 (pair){3.5, HDRL_EPS_DATA},
1062 (pair){0., HDRL_EPS_ERROR},
1070 hdrl_collapse_imagelist_to_image_mode(0, 0, 1, HDRL_MODE_WEIGHTED, 0);
1072 hdrl_collapse_imagelist_to_vector_mode(0, 0, 1, HDRL_MODE_WEIGHTED, 0);
1080 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
1081 (pair){3.5, HDRL_EPS_DATA},
1082 (pair){0.4330127018922193, HDRL_EPS_ERROR},
1088 method = hdrl_collapse_imagelist_to_image_mode(3, 4, 1, HDRL_MODE_WEIGHTED, 0);
1089 vmethod = hdrl_collapse_imagelist_to_vector_mode(3, 4, 1, HDRL_MODE_WEIGHTED, 0);
1091 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
1092 (pair){3.5, HDRL_EPS_DATA},
1093 (pair){0.1767766952966369, HDRL_EPS_ERROR},
1100 method = hdrl_collapse_imagelist_to_image_mode(2, 5, 1, HDRL_MODE_FIT, 0);
1101 vmethod = hdrl_collapse_imagelist_to_vector_mode(2, 5, 1, HDRL_MODE_FIT, 0);
1103 test_l2i_and_l2v(data, errs, method, vmethod, 1, 1,
1104 (pair){3.6, HDRL_EPS_DATA * 10},
1105 (pair){0.2683281572999749, HDRL_EPS_ERROR * 10.},
1330 cpl_imagelist_delete(data);
1331 cpl_imagelist_delete(errs);
1332 cpl_image_delete(expect_err);
1333 cpl_image_delete(expect_contrib);
1334 cpl_image_delete(img);
1335 cpl_image_delete(err);
1336 cpl_vector_delete(expect_vimg);
1337 cpl_vector_delete(expect_verr);
1338 cpl_array_delete(expect_acontrib);
1351 cpl_test_init(PACKAGE_BUGREPORT, CPL_MSG_WARNING);
1357 test_results_mode();
1358 return cpl_test_end(0);
double hdrl_collapse_mode_parameter_get_bin_size(const hdrl_parameter *p)
get size of the histogram bins
double hdrl_collapse_mode_parameter_get_histo_min(const hdrl_parameter *p)
get min value
cpl_boolean hdrl_collapse_parameter_is_weighted_mean(const hdrl_parameter *self)
check if parameter is a weighted mean parameter
double hdrl_collapse_sigclip_parameter_get_kappa_low(const hdrl_parameter *p)
get low kappa
hdrl_parameter * hdrl_collapse_mean_parameter_create(void)
create a parameter object for mean
hdrl_parameter * hdrl_collapse_sigclip_parameter_create(double kappa_low, double kappa_high, int niter)
create a parameter object for sigclipped mean
hdrl_parameter * hdrl_collapse_weighted_mean_parameter_create(void)
create a parameter object for weighted mean
cpl_boolean hdrl_collapse_parameter_is_mean(const hdrl_parameter *self)
check if parameter is a mean parameter
cpl_boolean hdrl_collapse_parameter_is_median(const hdrl_parameter *self)
check if parameter is a median parameter
double hdrl_collapse_mode_parameter_get_histo_max(const hdrl_parameter *p)
get high value
int hdrl_collapse_sigclip_parameter_get_niter(const hdrl_parameter *p)
get maximum number of clipping iterations
cpl_size hdrl_collapse_mode_parameter_get_error_niter(const hdrl_parameter *p)
get the error type of the mode
cpl_boolean hdrl_collapse_parameter_is_minmax(const hdrl_parameter *self)
check if parameter is a minmax mean parameter
cpl_boolean hdrl_collapse_parameter_is_mode(const hdrl_parameter *self)
check if parameter is a mode parameter
cpl_boolean hdrl_collapse_parameter_is_sigclip(const hdrl_parameter *self)
check if parameter is a sigclip mean parameter
double hdrl_collapse_sigclip_parameter_get_kappa_high(const hdrl_parameter *p)
get high kappa
double hdrl_collapse_minmax_parameter_get_nlow(const hdrl_parameter *p)
get low value
hdrl_parameter * hdrl_collapse_median_parameter_create(void)
create a parameter object for median
hdrl_parameter * hdrl_collapse_mode_parameter_create(double histo_min, double histo_max, double bin_size, hdrl_mode_type mode_method, cpl_size error_niter)
create a parameter object for the mode
cpl_parameterlist * hdrl_collapse_parameter_create_parlist(const char *base_context, const char *prefix, const char *method_def, hdrl_parameter *sigclip_def, hdrl_parameter *minmax_def, hdrl_parameter *mode_def)
Create parameters for the collapse.
hdrl_mode_type hdrl_collapse_mode_parameter_get_method(const hdrl_parameter *p)
get the mode determination method
hdrl_parameter * hdrl_collapse_minmax_parameter_create(double nlow, double nhigh)
create a parameter object for min-max rejected mean
hdrl_parameter * hdrl_collapse_parameter_parse_parlist(const cpl_parameterlist *parlist, const char *prefix)
parse parameterlist for imagelist reduction method
double hdrl_collapse_minmax_parameter_get_nhigh(const hdrl_parameter *p)
get high value
void hdrl_parameter_delete(hdrl_parameter *obj)
shallow delete of a parameter