28#include "hdrl_spectrum.h"
29#include "hdrl_spectrumlist.h"
30#include "hdrl_spectrum_resample.h"
31#include "hdrl_DER_SNR.h"
42#define HDRL_DELTA_COMPARE_VALUE CPL_MAX(HDRL_EPS_DATA, HDRL_EPS_ERROR) * 1.
43#define HDRL_DELTA_COMPARE_VALUE_ABS CPL_MAX(HDRL_EPS_DATA, HDRL_EPS_ERROR) * 4.
45#define LENGTH_ARRAY(a) ((cpl_size)(sizeof((a))/sizeof((a[0]))))
51static inline cpl_image * get_random_1d_img(cpl_size length,
52 double min,
double max, cpl_type type);
54static inline void set_1d_bpm(cpl_image * img);
56static inline cpl_array * get_wavelength(cpl_size length, cpl_type type);
58static inline cpl_boolean are_hdrl_eq(
const hdrl_image* flux_compound,
59 const cpl_image * flux,
const cpl_image * flux_e);
61static inline cpl_error_code get_error_code_and_reset();
63static inline double rand_0_to_1();
65static inline hdrl_spectrum1D *
66get_random_spectrum(
int length, hdrl_spectrum1D_wave_scale scale);
68typedef hdrl_spectrum1D * (* operate_spectra_create)
69 (
const hdrl_spectrum1D * self,
70 const hdrl_spectrum1D * other);
72typedef cpl_error_code (* operate_spectra)(hdrl_spectrum1D * self,
73 const hdrl_spectrum1D * other);
75static inline void test_error_create_func(
const hdrl_spectrum1D * s1,
76 const hdrl_spectrum1D * s2, operate_spectra_create f);
79test_calc_creat_error(operate_spectra_create f);
81static inline void test_calc_error(operate_spectra f);
83static inline hdrl_spectrum1D * get_spectrum1D_sin_shuffled
84(cpl_size sz,
int start, cpl_boolean add_peak, cpl_array ** unshuffled_lambda);
89 cpl_boolean is_internal;
92hdrl_spectrum1D * select_window(hdrl_spectrum1D * s,
const sel_window w){
94 cpl_bivector * vec = cpl_bivector_new(1);
96 cpl_vector_set(cpl_bivector_get_x(vec), 0, w.lambda_min);
97 cpl_vector_set(cpl_bivector_get_y(vec), 0, w.lambda_max);
100 cpl_bivector_delete(vec);
111void test_spectrum1D_constructor(cpl_type type){
113 const cpl_size sz = 40;
114 cpl_image * spectrum1d = get_random_1d_img(sz, 0.0f, 128.0f, type);
115 cpl_image * spectrum1d_error = get_random_1d_img(sz, 0.0f, 1.0f,type);
116 set_1d_bpm(spectrum1d);
117 cpl_array * wavelengths = get_wavelength(sz,type);
120 hdrl_spectrum1D * spec;
123 spectrum1d, spectrum1d_error,
124 wavelengths, hdrl_spectrum1D_wave_scale_linear);
127 cpl_boolean are_equal = are_hdrl_eq(
130 cpl_test_eq(are_equal, CPL_TRUE);
135 const cpl_size wn = 10;
140 wavelengths, hdrl_spectrum1D_wave_scale_linear);
141 cpl_test_nonnull(spec);
144 cpl_image * flux_casted = cpl_image_cast(spectrum1d, HDRL_TYPE_DATA);
145 const hdrl_data_t * flux =
146 (
const hdrl_data_t *) cpl_image_get_data_const(flux_casted);
147 const cpl_mask *msk_in = cpl_image_get_bpm_const(flux_casted);
148 const cpl_binary *msk_bn = cpl_mask_get_data_const(msk_in);
153 cpl_image_delete(flux_casted);
155 cpl_mask * msk = cpl_image_unset_bpm(noise);
156 cpl_mask_delete(cpl_image_set_bpm(spectrum1d, msk));
161 wavelengths, hdrl_spectrum1D_wave_scale_linear);
163 const cpl_image * flux2 =
166 const cpl_image * flux2_e =
169 cpl_boolean are_equal2 =
171 cpl_test_eq(are_equal2, CPL_TRUE);
174 cpl_test_null(spec2);
181 spectrum1d, wavelengths, hdrl_spectrum1D_wave_scale_linear);
182 cpl_test_nonnull(spec);
184 cpl_size not_rej = 0;
185 for(cpl_size i = 0; i < sz; ++i){
189 cpl_test_eq(v.error, 0.0);
192 cpl_test(not_rej > 0);
194 cpl_array_delete(wavelengths);
195 cpl_image_delete(spectrum1d);
196 cpl_image_delete(noise);
197 cpl_image_delete(spectrum1d_error);
213hdrl_value test_val(hdrl_data_t lambda){
214 return (hdrl_value){lambda * 2.0, lambda *3.0};
217void test_spectrum1D_constructor_analytical(
void){
220 cpl_array * wav = cpl_array_new(sz, CPL_TYPE_DOUBLE);
222 for(cpl_size i = 0; i < sz; i++){
223 cpl_array_set(wav, i, (1 + i) * 10.0);
227 (test_val, wav, hdrl_spectrum1D_wave_scale_linear);
229 for(cpl_size i = 0; i < sz; i++){
233 cpl_test_abs(v.data, (1 + i) * 20.0, 1e-3);
234 cpl_test_abs(v.error, (1 + i) * 30.0, 1e-3);
237 hdrl_data_t ww = cpl_array_get(wav, i, NULL);
238 cpl_test_abs(ws, ww, 1e-3);
241 cpl_test_eq(hdrl_spectrum1D_wave_scale_linear,
244 cpl_array_delete(wav);
255void test_spectrum1D_constructor_error(
void){
257 cpl_image * spectrum1d_40 =
258 get_random_1d_img(40, 0.0f, 128.0f, CPL_TYPE_DOUBLE);
259 cpl_image * spectrum1d_error_40 =
260 get_random_1d_img(40, 0.0f, 1.0f,CPL_TYPE_DOUBLE);
261 set_1d_bpm(spectrum1d_40);
262 cpl_array * wavelengths_40 = get_wavelength(40,CPL_TYPE_DOUBLE);
264 cpl_image * spectrum1d_42 =
265 get_random_1d_img(42, 0.0f, 128.0f, CPL_TYPE_DOUBLE);
266 cpl_image * spectrum1d_error_42 =
267 get_random_1d_img(42, 0.0f, 1.0f,CPL_TYPE_DOUBLE);
268 set_1d_bpm(spectrum1d_42);
269 cpl_array * wavelengths_42 = get_wavelength(42,CPL_TYPE_DOUBLE);
273 hdrl_spectrum1D_wave_scale_linear);
276 cpl_test_eq(get_error_code_and_reset(), CPL_ERROR_NULL_INPUT);
281 NULL, hdrl_spectrum1D_wave_scale_linear);
284 cpl_test_eq(get_error_code_and_reset(), CPL_ERROR_NULL_INPUT);
289 wavelengths_40, hdrl_spectrum1D_wave_scale_linear);
292 cpl_test_eq(get_error_code_and_reset(), CPL_ERROR_INCOMPATIBLE_INPUT);
295 wavelengths_40, hdrl_spectrum1D_wave_scale_linear);
298 cpl_test_eq(get_error_code_and_reset(), CPL_ERROR_INCOMPATIBLE_INPUT);
301 wavelengths_42, hdrl_spectrum1D_wave_scale_linear);
304 cpl_test_eq(get_error_code_and_reset(), CPL_ERROR_INCOMPATIBLE_INPUT);
306 double el0 = cpl_array_get(wavelengths_40, 0, NULL);
307 cpl_array_set(wavelengths_40, 1, el0);
310 wavelengths_40, hdrl_spectrum1D_wave_scale_linear);
311 cpl_test_nonnull(spec);
312 cpl_test_eq(get_error_code_and_reset(), CPL_ERROR_NONE);
316 cpl_array_delete(wavelengths_40);
317 cpl_image_delete(spectrum1d_40);
318 cpl_image_delete(spectrum1d_error_40);
320 cpl_array_delete(wavelengths_42);
321 cpl_image_delete(spectrum1d_42);
322 cpl_image_delete(spectrum1d_error_42);
332void test_spectrum1D_duplication(
void){
334 cpl_image * spectrum1d =
335 get_random_1d_img(140, 0.0f, 128.0f, CPL_TYPE_DOUBLE);
336 cpl_image * spectrum1d_error =
337 get_random_1d_img(140, 0.0f, 1.0f,CPL_TYPE_DOUBLE);
338 set_1d_bpm(spectrum1d);
339 cpl_array * wavelengths = get_wavelength(140, CPL_TYPE_DOUBLE);
343 wavelengths, hdrl_spectrum1D_wave_scale_linear);
352 cpl_test_null(should_be_null);
354 cpl_array_delete(wavelengths);
355 cpl_image_delete(spectrum1d);
356 cpl_image_delete(spectrum1d_error);
365void test_spectrum1D_calculation_scalar(
void){
367 cpl_image * spectrum1d =
368 get_random_1d_img(40, 0.0f, 128.0f, CPL_TYPE_DOUBLE);
369 cpl_image * spectrum1d_error =
370 get_random_1d_img(40, 0.0f, 1.0f, CPL_TYPE_DOUBLE);
371 set_1d_bpm(spectrum1d);
372 cpl_array * wavelengths = get_wavelength(40, CPL_TYPE_DOUBLE);
374 cpl_image_set(spectrum1d, 3, 1, 5.0);
375 cpl_image_set(spectrum1d_error, 3, 1, 2.1);
378 spectrum1d, spectrum1d_error,
379 wavelengths, hdrl_spectrum1D_wave_scale_linear);
381 hdrl_value vs = {1.5, 0.3};
440 pow(5.0, 2.0), 1e-3);
444 pow(5.0, 2.0), 1e-3);
451 wavelengths, hdrl_spectrum1D_wave_scale_linear);
458 pow(2.0, 5.0), 1e-3);
462 pow(2.0, 5.0), 1e-3);
467 cpl_array_delete(wavelengths);
468 cpl_image_delete(spectrum1d);
469 cpl_image_delete(spectrum1d_error);
474 hdrl_value v = {100.0, 5.0};
496void test_spectrum1D_calculation(
void){
498 cpl_image * spectrum1d1 =
499 get_random_1d_img(40, 1.0f, 128.0f, CPL_TYPE_DOUBLE);
500 cpl_image * spectrum1d2 =
501 get_random_1d_img(40, 1.0f, 128.0f, CPL_TYPE_DOUBLE);
503 cpl_image * spectrum1d_error1 =
504 get_random_1d_img(40, 0.5f, 2.0f, CPL_TYPE_DOUBLE);
505 cpl_image * spectrum1d_error2 =
506 get_random_1d_img(40, 0.5f, 2.0f, CPL_TYPE_DOUBLE);
507 set_1d_bpm(spectrum1d1);
508 cpl_array * wavelengths = get_wavelength(40, CPL_TYPE_DOUBLE);
510 cpl_image_set(spectrum1d1, 15, 1, 8.0);
511 cpl_image_set(spectrum1d2, 15, 1, 4.0);
512 cpl_image_set(spectrum1d_error1, 15, 1, 2.0);
513 cpl_image_set(spectrum1d_error2, 15, 1, 1.0);
516 spectrum1d1, spectrum1d_error1,
517 wavelengths, hdrl_spectrum1D_wave_scale_linear);
520 spectrum1d2, spectrum1d_error2,
521 wavelengths, hdrl_spectrum1D_wave_scale_linear);
582 cpl_array_delete(wavelengths);
583 cpl_image_delete(spectrum1d1);
584 cpl_image_delete(spectrum1d2);
585 cpl_image_delete(spectrum1d_error1);
586 cpl_image_delete(spectrum1d_error2);
596void test_spectrum1D_calculation_error(
void){
616void test_spectrum1D_conversion_wavelength_scale(
void){
618 cpl_image * spectrum1d =
619 get_random_1d_img(40, 1.0f, 128.0f, CPL_TYPE_DOUBLE);
621 cpl_image * spectrum1d_error1 =
622 get_random_1d_img(40, 0.5f, 2.0f, CPL_TYPE_DOUBLE);
624 set_1d_bpm(spectrum1d);
625 cpl_array * wavelengths = get_wavelength(40, CPL_TYPE_DOUBLE);
628 spectrum1d, spectrum1d_error1,
629 wavelengths, hdrl_spectrum1D_wave_scale_linear);
631 hdrl_data_t w1 = cpl_array_get(wavelengths, 4, NULL);
632 hdrl_data_t w2 = cpl_array_get(wavelengths, 6, NULL);
634 hdrl_spectrum1D * s_lg =
636 hdrl_spectrum1D_wavelength w_lg =
639 cpl_test_eq(w_lg.scale, hdrl_spectrum1D_wave_scale_log);
641 cpl_test_abs(log(w1), cpl_array_get(w_lg.wavelength, 4, NULL), 1e-3);
642 cpl_test_abs(log(w2), cpl_array_get(w_lg.wavelength, 6, NULL), 1e-3);
644 hdrl_spectrum1D * s_lin =
647 cpl_test_eq(w_lin.scale, hdrl_spectrum1D_wave_scale_linear);
649 cpl_test_abs(w1, cpl_array_get(w_lin.wavelength, 4, NULL), 1e-3);
650 cpl_test_abs(w2, cpl_array_get(w_lin.wavelength, 6, NULL), 1e-3);
655 hdrl_spectrum1D * s_lg2 =
658 cpl_test_eq(w_lg2.scale, hdrl_spectrum1D_wave_scale_log);
659 cpl_test_noneq_ptr(s_lg2, s_lg);
661 hdrl_spectrum1D * s_lin2 =
664 cpl_test_eq(w_lin2.scale, hdrl_spectrum1D_wave_scale_linear);
665 cpl_test_noneq_ptr(s_lin2, s_lin);
676 cpl_test_eq(e, CPL_ERROR_NONE);
680 cpl_test_eq(sp_w_lg.scale, hdrl_spectrum1D_wave_scale_log);
681 cpl_test_abs(log(w1), cpl_array_get(sp_w_lg.wavelength, 4, NULL), 1e-3);
682 cpl_test_abs(log(w2), cpl_array_get(sp_w_lg.wavelength, 6, NULL), 1e-3);
686 cpl_test_eq(e, CPL_ERROR_NONE);
690 cpl_test_eq(sp_w_lg.scale, hdrl_spectrum1D_wave_scale_log);
691 cpl_test_abs(log(w1), cpl_array_get(sp_w_lg.wavelength, 4, NULL), 1e-3);
692 cpl_test_abs(log(w2), cpl_array_get(sp_w_lg.wavelength, 6, NULL), 1e-3);
696 cpl_test_eq(e, CPL_ERROR_NONE);
699 cpl_test_eq(sp_w_lin.scale, hdrl_spectrum1D_wave_scale_linear);
700 cpl_test_abs(w1, cpl_array_get(sp_w_lin.wavelength, 4, NULL), 1e-3);
701 cpl_test_abs(w2, cpl_array_get(sp_w_lin.wavelength, 6, NULL), 1e-3);
705 cpl_test_eq(e, CPL_ERROR_NONE);
708 cpl_test_eq(sp_w_lin.scale, hdrl_spectrum1D_wave_scale_linear);
709 cpl_test_abs(w1, cpl_array_get(sp_w_lin.wavelength, 4, NULL), 1e-3);
710 cpl_test_abs(w2, cpl_array_get(sp_w_lin.wavelength, 6, NULL), 1e-3);
713 cpl_array_delete(wavelengths);
714 cpl_image_delete(spectrum1d_error1);
715 cpl_image_delete(spectrum1d);
735void test_spectrum1D_mul_wavelength(
void){
737 cpl_image * spectrum1d =
738 get_random_1d_img(40, 1.0f, 128.0f, CPL_TYPE_DOUBLE);
740 cpl_image * spectrum1d_error1 =
741 get_random_1d_img(40, 0.5f, 2.0f, CPL_TYPE_DOUBLE);
743 set_1d_bpm(spectrum1d);
744 cpl_array * wavelengths = get_wavelength(40, CPL_TYPE_DOUBLE);
747 spectrum1d, spectrum1d_error1,
748 wavelengths, hdrl_spectrum1D_wave_scale_linear);
750 hdrl_data_t w1 = cpl_array_get(wavelengths, 4, NULL);
751 hdrl_data_t w2 = cpl_array_get(wavelengths, 6, NULL);
756 cpl_test_eq(e, CPL_ERROR_NONE);
760 cpl_test_abs(w1 * 1e3, cpl_array_get(sp_mul_1e3.wavelength, 4, NULL), 1e-3);
761 cpl_test_abs(w2 * 1e3, cpl_array_get(sp_mul_1e3.wavelength, 6, NULL), 1e-3);
764 cpl_test_eq(e, CPL_ERROR_NONE);
769 cpl_test_eq(e, CPL_ERROR_NONE);
773 cpl_test_abs(log(w1 * 1e3), cpl_array_get(sp_mul_log.wavelength, 4, NULL),
775 cpl_test_abs(log(w2 * 1e3), cpl_array_get(sp_mul_log.wavelength, 6, NULL),
782 spectrum1d, spectrum1d_error1,
783 wavelengths, hdrl_spectrum1D_wave_scale_linear);
785 hdrl_spectrum1D * sp_lin =
788 hdrl_spectrum1D * sp_log =
795 cpl_test_abs(w1 * 1e-4, cpl_array_get(sp_mul_1e3.wavelength, 4, NULL), 1e-6);
796 cpl_test_abs(w2 * 1e-4, cpl_array_get(sp_mul_1e3.wavelength, 6, NULL), 1e-6);
799 log(w1 * 1e-4), cpl_array_get(sp_mul_log.wavelength, 4, NULL), 1e-6);
801 log(w2 * 1e-4), cpl_array_get(sp_mul_log.wavelength, 6, NULL), 1e-6);
805 cpl_test_noneq(get_error_code_and_reset(), CPL_ERROR_NONE);
809 cpl_test_noneq(get_error_code_and_reset(), CPL_ERROR_NONE);
813 cpl_array_delete(wavelengths);
814 cpl_image_delete(spectrum1d_error1);
815 cpl_image_delete(spectrum1d);
829void test_spectrum1D_shift_wavelength(
void){
831 cpl_image * spectrum1d =
832 get_random_1d_img(40, 1.0f, 128.0f, CPL_TYPE_DOUBLE);
834 cpl_image * spectrum1d_error1 =
835 get_random_1d_img(40, 0.5f, 2.0f, CPL_TYPE_DOUBLE);
837 set_1d_bpm(spectrum1d);
838 cpl_array * wavelengths = get_wavelength(40, CPL_TYPE_DOUBLE);
840 hdrl_data_t w1 = cpl_array_get(wavelengths, 4, NULL);
841 hdrl_data_t w2 = cpl_array_get(wavelengths, 6, NULL);
844 spectrum1d, spectrum1d_error1,
845 wavelengths, hdrl_spectrum1D_wave_scale_linear);
848 spectrum1d, spectrum1d_error1,
849 wavelengths, hdrl_spectrum1D_wave_scale_log);
853 cpl_test_eq(err, CPL_ERROR_NONE);
856 cpl_test_eq(err, CPL_ERROR_NONE);
861 cpl_test_abs(w1 + 3.0, cpl_array_get(sp_p_3.wavelength, 4, NULL), 1e-3);
862 cpl_test_abs(w2 + 3.0, cpl_array_get(sp_p_3.wavelength, 6, NULL), 1e-3);
864 cpl_test_abs(w1 - 3.0, cpl_array_get(sp_m_3.wavelength, 4, NULL), 1e-3);
865 cpl_test_abs(w2 - 3.0, cpl_array_get(sp_m_3.wavelength, 6, NULL), 1e-3);
867 hdrl_spectrum1D* sp_new_1 =
869 hdrl_spectrum1D* sp_new_2 =
875 hdrl_spectrum1D_wavelength sp_n_1_w =
877 hdrl_spectrum1D_wavelength sp_n_2_w =
880 cpl_test_abs(w1, cpl_array_get(sp_n_1_w.wavelength, 4, NULL), 1e-3);
881 cpl_test_abs(w2, cpl_array_get(sp_n_1_w.wavelength, 6, NULL), 1e-3);
882 cpl_test_abs(w1, cpl_array_get(sp_n_2_w.wavelength, 4, NULL), 1e-3);
883 cpl_test_abs(w2, cpl_array_get(sp_n_2_w.wavelength, 6, NULL), 1e-3);
890 cpl_test_eq(err, CPL_ERROR_NONE);
891 hdrl_spectrum1D * should_be_null =
893 cpl_test_null(should_be_null);
895 cpl_array_delete(wavelengths);
896 cpl_image_delete(spectrum1d_error1);
897 cpl_image_delete(spectrum1d);
905void test_spectrum1D_table_conversion(
void){
907 const cpl_size sz_ori = 17;
908 cpl_array * unshuffled_lambda = NULL;
909 hdrl_spectrum1D * sp1 = get_spectrum1D_sin_shuffled(sz_ori, 2, CPL_TRUE,
911 cpl_array_delete(unshuffled_lambda);
914 "lambdas",
"flux_e",
"flux_bpm");
917 cpl_table_set_int(tab,
"flux_bpm", 0, 1);
918 cpl_table_set_int(tab,
"flux_bpm", sz_ori - 1, 1);
921 (tab,
"flux",
"lambdas",
"flux_e",
"flux_bpm",
922 hdrl_spectrum1D_wave_scale_linear);
924 const cpl_image * flux1 =
926 const cpl_image * flux1_e =
931 const cpl_image * flux2 =
933 const cpl_image * flux2_e =
937 const cpl_size sz_x = cpl_image_get_size_x(flux1);
938 const cpl_size sz_y = cpl_image_get_size_y(flux1);
939 const cpl_size sz = cpl_array_get_size(lambdas1);
941 cpl_test_eq(sz_x, cpl_image_get_size_x(flux2));
942 cpl_test_eq(sz_y, cpl_image_get_size_y(flux2));
943 cpl_test_eq(sz, cpl_array_get_size(lambdas2));
945 for(cpl_size i = 1; i < sz - 1; i++){
949 const double flx1 = cpl_image_get(flux1, i + 1, 1, &rej1);
950 const double flx2 = cpl_image_get(flux2, i + 1, 1, &rej2);
953 cpl_test_abs(flx1, flx2, 1e-3);
954 cpl_test_eq(rej1, rej2);
957 const double flx1_e = cpl_image_get(flux1_e, i + 1, 1, &rej1);
958 const double flx2_e = cpl_image_get(flux2_e, i + 1, 1, &rej2);
960 cpl_test_abs(flx1_e, flx2_e, 1e-3);
961 cpl_test_eq(rej1, rej2);
965 const double l1 = cpl_array_get(lambdas1, i, &rej1);
966 const double l2 = cpl_array_get(lambdas2, i, &rej2);
968 cpl_test_abs(l1, l2, 1e-3);
969 cpl_test_eq(rej1, rej2);
972 cpl_test(cpl_image_is_rejected(flux2, 1, 1));
973 cpl_test(cpl_image_is_rejected(flux2, sz_ori, 1));
977 "flux2",
"lambdas2", NULL,
"flux2_bpm");
979 for(cpl_size i = 0; i < sz; i++){
983 const int bpm1 = cpl_table_get_int(tab,
"flux_bpm", i, &rej);
984 const int bpm2 = cpl_table_get_int(tab,
"flux2_bpm", i, &rej);
985 cpl_test_eq(bpm1, bpm2);
989 const double flx1 = cpl_table_get(tab,
"flux", i, &rej);
990 const double flx2 = cpl_table_get(tab,
"flux2", i, &rej);
991 cpl_test_abs(flx1, flx2, 1e-3);
993 const double l1 = cpl_table_get(tab,
"lambdas", i, &rej);
994 const double l2 = cpl_table_get(tab,
"lambdas2", i, &rej);
995 cpl_test_abs(l1, l2, 1e-3);
1000 (tab,
"flux",
"lambdas", NULL, NULL,
1001 hdrl_spectrum1D_wave_scale_linear);
1004 const char* filename =
"check_spectrum1D.fits";
1005 hdrl_spectrum1D_save(sp2, filename);
1016 cpl_test_eq(fx2_e, 0.0);
1017 cpl_test_abs(fx1, fx2, 1e-3);
1021 cpl_table_delete(tab);
1023 cpl_table * f_only =
1025 cpl_table * l_only =
1027 cpl_table * f_and_e =
1035 const double f1 = cpl_table_get(f_only,
"flux", i, NULL);
1036 const double f2 = cpl_table_get(f_and_e,
"flux", i, NULL);
1040 const double w1 = cpl_table_get(l_only,
"wav", i, NULL);
1043 const double e1 = cpl_table_get(f_and_e,
"error", i, NULL);
1049 cpl_table_delete(f_only);
1050 cpl_table_delete(l_only);
1051 cpl_table_delete(f_and_e);
1059void test_spectrum1D_resample_spectrum(cpl_boolean add_peak){
1062 cpl_array * unshuffled_lambda = NULL;
1063 hdrl_spectrum1D * sp = get_spectrum1D_sin_shuffled(17, 2, add_peak, &unshuffled_lambda);
1067 cpl_array * new_lambda = cpl_array_new(sz, HDRL_TYPE_DATA);
1068 for(cpl_size i = 0; i < sz; i++){
1069 double d = cpl_array_get(unshuffled_lambda, i, NULL)
1070 + cpl_array_get(unshuffled_lambda, CPL_MIN(sz - 1, i + 1), NULL);
1071 cpl_array_set(new_lambda, i, d/2);
1074 wl.wavelength = new_lambda;
1079 hdrl_parameter *pars;
1080 hdrl_spectrum1D *resampled_lambda;
1087 const double data2_fit = add_peak ? 116.368 : 209.577;
1088 const double data3_fit = add_peak ? 303.376 : 199.524;
1101 const double data2_interp = add_peak ? 208.699 : 209.65;
1102 const double data3_interp = add_peak ? 247.949 : 199.585;
1115 const double data2_integrate = 207.878;
1116 const double data3_integrate = add_peak ? 245.443 : 197.992;
1127 cpl_array_delete(new_lambda);
1128 cpl_array_delete(unshuffled_lambda);
1138void test_spectrum1D_resample_spectrum_private_funcs(
void){
1140 double testValue1 = 2.1;
1141 double testValue2 = 3.5;
1142 double testValue3 = 5.5;
1145 double x[] = {3, 2.1, 5.5, 8.7, 3.3, 5.6, 2.1};
1146 double y1[] = {11, 88, -22, 56, 4, 22, 23};
1147 double y2[] = { 2, 55, 2, 27, 23, 1, 5};
1149 double x_sorted[] = {2.1, 2.1, 3, 3.3, 5.5, 5.6, 8.7};
1150 double y1_sorted[] = {88, 23, 11, 4, -22, 22, 56};
1151 double y2_sorted[] = {55, 5, 2, 23, 2, 1, 27};
1153 const cpl_size l = LENGTH_ARRAY(x);
1157 cpl_test_eq(x[0], testValue1);
1158 cpl_test_eq(x[1], testValue1);
1161 cpl_test(y1[1] != y1[0]);
1162 cpl_test(y2[1] != y2[0]);
1164 for(cpl_size i = 2; i < l; ++i){
1165 cpl_test_eq(x[i], x_sorted[i]);
1166 cpl_test_eq(y1[i], y1_sorted[i]);
1167 cpl_test_eq(y2[i], y2_sorted[i]);
1172 double x[] = {3, 2.1, 5.5, 8.7, 3.3, 5.6, 2.1};
1173 double y2[] = { 2, 55, 2, 27, 23, 1, 5};
1175 double x_sorted[] = {2.1, 2.1, 3, 3.3, 5.5, 5.6, 8.7};
1176 double y2_sorted[] = {55, 5, 2, 23, 2, 1, 27};
1178 const cpl_size l = LENGTH_ARRAY(x);
1182 cpl_test_eq(x[0], testValue1);
1183 cpl_test_eq(x[1], testValue1);
1185 cpl_test(y2[1] != y2[0]);
1187 for(cpl_size i = 2; i < l; ++i){
1188 cpl_test_eq(x[i], x_sorted[i]);
1189 cpl_test_eq(y2[i], y2_sorted[i]);
1194 double x[] = {3, 2.1, 5.5, 8.7, 3.3, 5.6, 2.1};
1195 double y1[] = {11, 88, -22, 56, 4, 22, 23};
1197 double x_sorted[] = {2.1, 2.1, 3, 3.3, 5.5, 5.6, 8.7};
1198 double y1_sorted[] = {88, 23, 11, 4, -22, 22, 56};
1200 const cpl_size l = LENGTH_ARRAY(x);
1204 cpl_test_eq(x[0], testValue1);
1205 cpl_test_eq(x[1], testValue1);
1208 cpl_test(y1[1] != y1[0]);
1210 for(cpl_size i = 2; i < l; ++i){
1211 cpl_test_eq(x[i], x_sorted[i]);
1212 cpl_test_eq(y1[i], y1_sorted[i]);
1219 double x[] = {1,1,1,1,1};
1220 double y1[] = {5,4,3,2,5};
1221 double y2[] = {8,7,5,2,6};
1223 cpl_size l = LENGTH_ARRAY(x);
1225 l = hdrl_spectrum1D_resample_filter_dups_and_substitute_with_median
1229 cpl_test_eq(x[0], 1);
1230 cpl_test_eq(y1[0], 4);
1231 cpl_test_eq(y2[0], 6);
1236 double x[] = {1,1,1,1,1,1};
1237 double y1[] = {5,4,3,2,5,2.5};
1238 double y2[] = {8,7,5,2,6,4.6};
1240 cpl_size l = LENGTH_ARRAY(x);
1242 l = hdrl_spectrum1D_resample_filter_dups_and_substitute_with_median
1246 cpl_test_eq(x[0], 1);
1247 cpl_test_eq(y1[0], testValue2);
1248 cpl_test_eq(y2[0], testValue3);
1254 double x[] = {1,2,2,2,2,2};
1255 double y1[] = {55,5,4,3,2,5};
1256 double y2[] = {88,8,7,5,2,6};
1258 cpl_size l = LENGTH_ARRAY(x);
1260 l = hdrl_spectrum1D_resample_filter_dups_and_substitute_with_median
1264 cpl_test_eq(x[1], 2);
1265 cpl_test_eq(y1[1], 4);
1266 cpl_test_eq(y2[1], 6);
1267 cpl_test_eq(x[0], 1);
1268 cpl_test_eq(y1[0], 55);
1269 cpl_test_eq(y2[0], 88);
1274 double x[] = {1, 1, 1, 1, 1, 1, 8};
1275 double y1[] = {5, 4, 3, 2, 5, 2.5, 77};
1276 double y2[] = {8, 7, 5, 2, 6, 4.6, 96};
1278 cpl_size l = LENGTH_ARRAY(x);
1280 l = hdrl_spectrum1D_resample_filter_dups_and_substitute_with_median
1284 cpl_test_eq(x[0] , 1);
1285 cpl_test_eq(y1[0], testValue2);
1286 cpl_test_eq(y2[0], testValue3);
1288 cpl_test_eq(x[1] , 8);
1289 cpl_test_eq(y1[1], 77);
1290 cpl_test_eq(y2[1], 96);
1296 double x[] = {1, 2, 2, 3, 3, 3, 5, 6, 7, 7, 8, 9, 10, 10, 10, 11};
1297 double y1[] = {4, 3, 7, 8, 9, 4, 3, 7, 2, 4, 5, 2, 8, 7, 1, 12};
1298 double y2[] = {3, 6, 7, 8, 4, 5, 8, 3, 5, 1, 3, 8, 44, 33, 55, 45};
1300 double x_f[] = {1, 2, 3, 5, 6, 7, 8, 9, 10, 11};
1301 double y1_f[] = {4, 5, 8, 3, 7, 3, 5, 2, 7, 12};
1302 double y2_f[] = {3, 6.5, 5, 8, 3, 3, 3, 8, 44, 45};
1304 cpl_size l = LENGTH_ARRAY(x);
1306 l = hdrl_spectrum1D_resample_filter_dups_and_substitute_with_median
1311 for(cpl_size i = 0; i < l; ++i){
1312 cpl_test_eq(x[i], x_f[i]);
1313 cpl_test_eq(y1[i], y1_f[i]);
1314 cpl_test_eq(y2[i], y2_f[i]);
1322 double x[] = {1, 2, 2, 3, 3, 3, 5, 6, 7, 7, 8, 9, 10, 10, 10, 11, 11};
1323 double y1[] = {4, 3, 7, 8, 9, 4, 3, 7, 2, 4, 5, 2, 8, 7, 1, 12, 2};
1324 double y2[] = {3, 6, 7, 8, 4, 5, 8, 3, 5, 1, 3, 8, 44, 33, 55, 45, 5};
1326 double x_f[] = {1, 2, 3, 5, 6, 7, 8, 9, 10, 11};
1327 double y1_f[] = {4, 5, 8, 3, 7, 3, 5, 2, 7, 7};
1328 double y2_f[] = {3, 6.5, 5, 8, 3, 3, 3, 8, 44, 25};
1330 cpl_size l = LENGTH_ARRAY(x);
1332 l = hdrl_spectrum1D_resample_filter_dups_and_substitute_with_median
1337 for(cpl_size i = 0; i < l; ++i){
1338 cpl_test_eq(x[i], x_f[i]);
1339 cpl_test_eq(y1[i], y1_f[i]);
1340 cpl_test_eq(y2[i], y2_f[i]);
1348 double x[] = {1, 1, 2, 2, 3, 3, 3, 5, 6, 7, 7, 8, 9, 10, 10, 10, 11};
1349 double y1[] = {5, 7, 3, 7, 8, 9, 4, 3, 7, 2, 4, 5, 2, 8, 7, 1, 12};
1350 double y2[] = {1, 3, 6, 7, 8, 4, 5, 8, 3, 5, 1, 3, 8, 44, 33, 55, 45};
1352 double x_f[] = {1, 2, 3, 5, 6, 7, 8, 9, 10, 11};
1353 double y1_f[] = {6, 5, 8, 3, 7, 3, 5, 2, 7, 12};
1354 double y2_f[] = {2, 6.5, 5, 8, 3, 3, 3, 8, 44, 45};
1356 cpl_size l = LENGTH_ARRAY(x);
1358 l = hdrl_spectrum1D_resample_filter_dups_and_substitute_with_median
1363 for(cpl_size i = 0; i < l; ++i){
1364 cpl_test_eq(x[i], x_f[i]);
1365 cpl_test_eq(y1[i], y1_f[i]);
1366 cpl_test_eq(y2[i], y2_f[i]);
1378void test_spectrum1D_resample_spectrum_interpolation_error_test(
void){
1380 double y[] = { 0, 1, 2, 1, 0, -1, -2, -1, 0, 1, 2, 1, 0, -1};
1381 double y_e[] = {.1, .2, .3, .4, .5, .6, .7, .8, .9, 1, 1.1, 1.2, 1.3, 1.4};
1382 double x[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
1385 {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.9, 11.1, 12.2, 13.9};
1387 cpl_size closer_idx[] =
1388 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
1390 const cpl_size l = LENGTH_ARRAY(y);
1391 const cpl_size l2 = LENGTH_ARRAY(x_r);
1392 cpl_test_eq(LENGTH_ARRAY(y), LENGTH_ARRAY(y_e));
1393 cpl_test_eq(LENGTH_ARRAY(y), LENGTH_ARRAY(x));
1395 cpl_image * flux = cpl_image_new(l, 1, CPL_TYPE_DOUBLE);
1396 cpl_image * flux_e = cpl_image_new(l, 1, CPL_TYPE_DOUBLE);
1397 cpl_array * wavelengths = cpl_array_new(l, CPL_TYPE_DOUBLE);
1398 cpl_array * wavelengths_resamp = cpl_array_new(l2, CPL_TYPE_DOUBLE);
1400 for(cpl_size i = 0; i < l; ++i){
1401 cpl_image_set(flux, i + 1, 1, y[i]);
1402 cpl_image_set(flux_e, i + 1, 1, y_e[i]);
1403 cpl_array_set(wavelengths, i, x[i]);
1406 for(cpl_size i = 0; i < l2; ++i){
1407 cpl_array_set(wavelengths_resamp, i, x_r[i]);
1411 hdrl_spectrum1D_wave_scale_linear);
1413 cpl_array_delete(wavelengths);
1414 cpl_image_delete(flux);
1415 cpl_image_delete(flux_e);
1419 wl.wavelength = wavelengths_resamp;
1423 (hdrl_spectrum1D_interp_akima);
1430 for(cpl_size i = 0; i < l2; ++i){
1433 const cpl_size idx = closer_idx[i];
1434 hdrl_error_t err_ori = pow(y_e[idx], 2.0) * fabs(x[idx + 1] - x_r[i]) +
1435 pow(y_e[idx + 1], 2.0) * fabs(x[idx] - x_r[i]);
1437 err_ori = sqrt(err_ori);
1439 cpl_test_abs(err, err_ori, HDRL_DELTA_COMPARE_VALUE_ABS);
1441 cpl_test_abs(w, x_r[i], HDRL_DELTA_COMPARE_VALUE_ABS);
1446 cpl_array_delete(wavelengths_resamp);
1455void test_spectrum1D_resample_spectrum_fit_error_test_error_interpol(
void){
1457 double y[] = { 0, 1, 2, 1, 0, -1, -2, -1, 0, 1, 2, 1, 0, -1};
1458 double y_e[] = {.1, .2, .3, .4, .5, .6, .7, .8, .9, 1, 1.1, 1.2, 1.3, 1.4};
1459 double x[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
1462 {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.9, 11.1, 12.2, 13.9};
1464 cpl_size closer_idx[] =
1465 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
1467 const cpl_size l = LENGTH_ARRAY(y);
1468 const cpl_size l2 = LENGTH_ARRAY(x_r);
1469 cpl_test_eq(LENGTH_ARRAY(y), LENGTH_ARRAY(y_e));
1470 cpl_test_eq(LENGTH_ARRAY(y), LENGTH_ARRAY(x));
1472 cpl_image * flux = cpl_image_new(l, 1, CPL_TYPE_DOUBLE);
1473 cpl_image * flux_e = cpl_image_new(l, 1, CPL_TYPE_DOUBLE);
1474 cpl_array * wavelengths = cpl_array_new(l, CPL_TYPE_DOUBLE);
1475 cpl_array * wavelengths_resamp = cpl_array_new(l2, CPL_TYPE_DOUBLE);
1477 for(cpl_size i = 0; i < l; ++i){
1478 cpl_image_set(flux, i + 1, 1, y[i]);
1479 cpl_image_set(flux_e, i + 1, 1, y_e[i]);
1480 cpl_array_set(wavelengths, i, x[i]);
1483 for(cpl_size i = 0; i < l2; ++i){
1484 cpl_array_set(wavelengths_resamp, i, x_r[i]);
1488 hdrl_spectrum1D_wave_scale_linear);
1490 cpl_array_delete(wavelengths);
1491 cpl_image_delete(flux);
1492 cpl_image_delete(flux_e);
1496 wl.wavelength = wavelengths_resamp;
1507 for(cpl_size i = 0; i < l2; ++i){
1510 const cpl_size idx = closer_idx[i];
1511 hdrl_error_t err_ori = pow(y_e[idx], 2.0) * fabs(x[idx + 1] - x_r[i]) +
1512 pow(y_e[idx + 1], 2.0) * fabs(x[idx] - x_r[i]);
1514 err_ori = sqrt(err_ori);
1516 cpl_test_abs(err, err_ori, HDRL_DELTA_COMPARE_VALUE_ABS);
1518 cpl_test_abs(w, x_r[i], HDRL_DELTA_COMPARE_VALUE_ABS);
1523 cpl_array_delete(wavelengths_resamp);
1533void test_spectrum1D_resample_spectrum_bpm(cpl_boolean interpolate){
1535 double x[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1539 {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.9, 11.1, 12.2, 13.9, 14.1};
1541 const cpl_size l = LENGTH_ARRAY(x);
1542 const cpl_size l2 = LENGTH_ARRAY(x_r);
1544 cpl_image * flux = cpl_image_new(l, 1, CPL_TYPE_DOUBLE);
1545 cpl_array * wavelengths = cpl_array_new(l, CPL_TYPE_DOUBLE);
1546 cpl_array * wavelengths_resamp = cpl_array_new(l2, CPL_TYPE_DOUBLE);
1549 for(cpl_size i = 0; i < l; ++i){
1551 cpl_image_set(flux, i + 1, 1, 10);
1552 cpl_array_set(wavelengths, i, x[i]);
1555 for(cpl_size i = 0; i < l; i+=2)
1556 cpl_image_reject(flux, i + 1, 1);
1558 for(cpl_size i = 0; i < l2; ++i){
1559 cpl_array_set(wavelengths_resamp, i, x_r[i]);
1564 hdrl_spectrum1D_wave_scale_linear);
1566 cpl_array_delete(wavelengths);
1567 cpl_image_delete(flux);
1571 wl.wavelength = wavelengths_resamp;
1574 hdrl_parameter * pars = NULL;
1577 (hdrl_spectrum1D_interp_akima);
1590 cpl_test_eq(rej, 1);
1594 cpl_test_eq(rej, 1);
1598 for(cpl_size i = 1; i < l2 - 1; ++i){
1602 cpl_test_rel(data, 0.0, 1e-6);
1607 cpl_array_delete(wavelengths_resamp);
1619void test_spectrum1D_resample_spectrum_fit_error_test_shift(cpl_boolean is_error_free){
1621 const hdrl_spectrum1D_wave_scale scale = hdrl_spectrum1D_wave_scale_linear;
1622 double y[] = { 0, 1, 2, 1, 0, -1, -2, -1, 0, 1, 2, 1, 0, -1};
1623 double y_e[] = {.1, .2, .3, .2, .1, .2, .3, .2, .1, .2, .3, .2, .1, .2};
1624 double x[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
1626 const cpl_size l = LENGTH_ARRAY(x);
1628 cpl_image * flux = cpl_image_new(l, 1, CPL_TYPE_DOUBLE);
1629 cpl_image * flux_e = cpl_image_new(l, 1, CPL_TYPE_DOUBLE);
1630 cpl_array * wavelengths = cpl_array_new(l, CPL_TYPE_DOUBLE);
1633 for(cpl_size i = 0; i < l; ++i){
1634 cpl_image_set(flux, i + 1, 1, y[i]);
1636 cpl_image_set(flux_e, i + 1, 1, y_e[i]);
1637 cpl_array_set(wavelengths, i, x[i]);
1640 cpl_array * wavelengths_resampled1 = cpl_array_new(l - 1, CPL_TYPE_DOUBLE);
1641 cpl_array * wavelengths_resampled2 = cpl_array_new(l - 2, CPL_TYPE_DOUBLE);
1643 for(cpl_size i = 0; i < l - 1; ++i){
1644 const double d = cpl_array_get(wavelengths, i, NULL) + .2;
1645 cpl_array_set(wavelengths_resampled1, i, d);
1648 for(cpl_size i = 1; i < l - 1; ++i){
1649 const double d = cpl_array_get(wavelengths, i, NULL);
1650 cpl_array_set(wavelengths_resampled2, i - 1, d);
1654 wavelengths, scale);
1655 cpl_test_nonnull(sp1);
1657 const hdrl_spectrum1D_wavelength wl1 = {wavelengths_resampled1, NULL, scale};
1658 const hdrl_spectrum1D_wavelength wl2 = {wavelengths_resampled2, NULL, scale};
1660 hdrl_parameter * pars =
1664 cpl_test_nonnull(sp2);
1667 cpl_test_nonnull(sp3);
1669 for(cpl_size i = 1; i < l - 2; ++i){
1670 const hdrl_value v1 =
1672 const hdrl_value v3 =
1675 cpl_test_eq(v1.error, v3.error);
1676 cpl_test_abs(v1.data, v3.data, .5);
1680 cpl_image_delete(flux);
1681 cpl_image_delete(flux_e);
1682 cpl_array_delete(wavelengths);
1683 cpl_array_delete(wavelengths_resampled1);
1684 cpl_array_delete(wavelengths_resampled2);
1694 double x = sin(10.0 * t);
1703void test_spectrum1D_resample_spectrum_fit_windowed(
void){
1705 const cpl_size nblocks = 5e2;
1706 const cpl_size length = 100e3;
1707 const cpl_size window = length / nblocks;
1709 const double dt = 1.0 / (length - 1);
1711 const hdrl_spectrum1D_wave_scale scale = hdrl_spectrum1D_wave_scale_linear;
1713 hdrl_parameter * pars_no_win =
1716 hdrl_parameter * pars_win =
1718 (4, 6, window, 1.2);
1720 cpl_array * lambdas = cpl_array_new(length, CPL_TYPE_DOUBLE);
1721 cpl_array * lambdas_resampled = cpl_array_new(length - 2, CPL_TYPE_DOUBLE);
1723 cpl_image * flux = cpl_image_new(length, 1, CPL_TYPE_DOUBLE);
1724 cpl_image * flux_real = cpl_image_new(length - 2, 1, CPL_TYPE_DOUBLE);
1726 for(cpl_size i = 0; i < length; ++i){
1727 const double d = i * dt;
1728 cpl_array_set(lambdas, i, d);
1729 cpl_image_set(flux, i + 1, 1, func(d));
1732 for(cpl_size i = 0; i < length - 2; ++i){
1733 const double d = (i + .5) * dt;
1734 cpl_array_set(lambdas_resampled, i, d);
1735 cpl_image_set(flux_real, i + 1, 1, func(d));
1738 hdrl_spectrum1D_wavelength wav = {lambdas_resampled, NULL, scale};
1740 hdrl_spectrum1D * sp_source =
1743 hdrl_spectrum1D * sp_ideal_resampled =
1745 (flux_real, lambdas_resampled, scale);
1748 (sp_source, &wav, pars_win);
1751 (sp_source, &wav, pars_no_win);
1753 for(cpl_size i = 0; i < length - 2; ++i){
1755 (sp_ideal_resampled, i, NULL).data;
1757 (sp_win_resampled, i, NULL).data;
1759 (sp_resampled, i, NULL).data;
1761 cpl_test_rel(v_ideal, v_win, 1.5e-1);
1762 cpl_test_rel(v_ideal, v_no_win, 1.5e-1);
1768 cpl_array_delete(lambdas);
1769 cpl_array_delete(lambdas_resampled);
1771 cpl_image_delete(flux);
1772 cpl_image_delete(flux_real);
1784void test_spectrum1D_wavelength_select(
void){
1786 const hdrl_spectrum1D_wave_scale scale = hdrl_spectrum1D_wave_scale_linear;
1787 double y[] = { 0, 1, 2, 1, 0, -1, -2, -1, 0, 1, 2, 1, 0, -1};
1788 double y_e[] = {.1, .2, .3, .2, .1, .2, .3, .2, .1, .2, .3, .2, .1, .2};
1789 double x[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
1791 const cpl_size l = LENGTH_ARRAY(x);
1793 cpl_image * flux = cpl_image_new(l, 1, CPL_TYPE_DOUBLE);
1794 cpl_image * flux_e = cpl_image_new(l, 1, CPL_TYPE_DOUBLE);
1795 cpl_array * wavelengths = cpl_array_new(l, CPL_TYPE_DOUBLE);
1798 for(cpl_size i = 0; i < l; ++i){
1799 cpl_image_set(flux, i + 1, 1, y[i]);
1800 cpl_image_set(flux_e, i + 1, 1, y_e[i]);
1801 cpl_array_set(wavelengths, i, x[i]);
1804 cpl_image_reject(flux, 5, 1);
1806 hdrl_spectrum1D * sp1 =
1809 hdrl_spectrum1D * sp2 = select_window(sp1, (sel_window){3, 10, CPL_TRUE});
1815 cpl_test_eq(rej, 1);
1818 for(cpl_size i = 0; i < l2; ++i){
1820 if(i == 2)
continue;
1825 const hdrl_data_t w1 =
1827 const hdrl_data_t w2 =
1830 cpl_test_eq(rej1_1, 0);
1831 cpl_test_eq(rej2_1, 0);
1833 cpl_test_eq(w1, w2);
1840 cpl_test_eq(rej1_2, 0);
1841 cpl_test_eq(rej2_2, 0);
1843 cpl_test_rel(s1.data, s2.data, HDRL_DELTA_COMPARE_VALUE);
1844 cpl_test_rel(s1.error, s2.error, HDRL_DELTA_COMPARE_VALUE);
1849 hdrl_spectrum1D * sp3 = select_window(sp1, (sel_window){3, 10, CPL_FALSE});
1853 cpl_size idxes[] = {0, 1, 10, 11, 12, 13};
1855 for(cpl_size i = 0; i < 6; ++i){
1860 const hdrl_data_t w1 =
1862 const hdrl_data_t w2 =
1865 cpl_test_eq(rej1_1, 0);
1866 cpl_test_eq(rej2_1, 0);
1868 cpl_test_eq(w1, w2);
1872 const hdrl_value s1 =
1876 cpl_test_eq(rej1_2, 0);
1877 cpl_test_eq(rej2_2, 0);
1879 cpl_test_rel(s1.data, s2.data, HDRL_DELTA_COMPARE_VALUE);
1880 cpl_test_rel(s1.error, s2.error, HDRL_DELTA_COMPARE_VALUE);
1885 cpl_image_delete(flux);
1886 cpl_image_delete(flux_e);
1887 cpl_array_delete(wavelengths);
1890 const cpl_size sz = 10;
1892 hdrl_spectrum1D * sp =
1893 get_spectrum1D_sin_shuffled(sz, 3, CPL_FALSE, NULL);
1895 cpl_array * arr = cpl_array_new(sz, CPL_TYPE_INT);
1897 for(cpl_size i = 0; i < sz; i++){
1898 cpl_array_set(arr, i, i % 2);
1901 hdrl_spectrum1D * sp_r1 =
1904 for(cpl_size i = 0; i < sz; i++){
1913 cpl_test_rel(d.data, d1.data, HDRL_EPS_DATA);
1914 cpl_test_rel(d.error, d1.error, HDRL_EPS_DATA);
1918 cpl_array_delete(arr);
1928void test_spectrum1D_test_uniformly_sampled(
void){
1930 const hdrl_spectrum1D_wave_scale scale = hdrl_spectrum1D_wave_scale_linear;
1932 const cpl_size sz = 100;
1933 hdrl_spectrum1D * sp =
1934 get_spectrum1D_sin_shuffled(sz, 3, CPL_FALSE, NULL);
1940 cpl_test_abs(delta, 2 * CPL_MATH_PI / sz, HDRL_EPS_DATA);
1944 cpl_array * arr = cpl_array_new(sz, CPL_TYPE_DOUBLE);
1945 cpl_image * flx = cpl_image_new(sz, 1, CPL_TYPE_DOUBLE);
1946 for(cpl_size i = 0; i < sz; ++i){
1947 cpl_array_set(arr, i, i + 1);
1948 cpl_image_set(flx, i + 1, 1, .1);
1951 cpl_array_set(arr, 4, 5.1);
1957 cpl_array_set(arr, 4, 5);
1961 cpl_test_rel(delta, 1.0, HDRL_EPS_DATA);
1964 cpl_image_delete(flx);
1965 cpl_array_delete(arr);
1973void test_spectrum1Dlist(
void){
1980 const cpl_size sz = 40;
1984 hdrl_spectrum1D * s1 =
1985 get_spectrum1D_sin_shuffled(sz, 4, CPL_TRUE, NULL);
1986 hdrl_spectrum1D * s2 =
1987 get_spectrum1D_sin_shuffled(sz, 4, CPL_TRUE, NULL);
1988 hdrl_spectrum1D * s3 =
1989 get_spectrum1D_sin_shuffled(sz, 4, CPL_TRUE, NULL);
1996 cpl_test_eq(list->capacity, 4);
2001 cpl_test_eq_ptr(s2, s22);
2002 cpl_test_eq_ptr(s2, s22_c);
2005 cpl_test_eq_ptr(s22_u, s22_c);
2016 cpl_test_eq_ptr(s, s1);
2018 cpl_test_eq_ptr(s, s3);
2025 cpl_test_eq(list->capacity, 0);
2026 cpl_test_eq_ptr(list->spectra, NULL);
2032static inline cpl_array *
2033get_waves(
double start_wave, cpl_size sz,
double step){
2035 cpl_array * to_ret = cpl_array_new(sz, HDRL_TYPE_DATA);
2037 for(cpl_size i = 0; i < sz; ++i){
2038 cpl_array_set(to_ret, i, start_wave + step * i);
2044static inline hdrl_spectrum1D *
2045generate_stair_spectrum(
int start,
int stop,
double start_wave,
double step_wave){
2047 const cpl_size sz = stop - start + 1;
2048 cpl_array * wave = get_waves(start_wave, sz, step_wave);
2049 cpl_image * flx = cpl_image_new(sz, 1, CPL_TYPE_DOUBLE);
2050 cpl_image * flx_e = cpl_image_new(sz, 1, CPL_TYPE_DOUBLE);
2053 for(cpl_size i = 0; i < sz; ++i){
2054 const double f = start + i;
2055 cpl_image_set(flx, i + 1, 1, f);
2056 cpl_image_set(flx_e, i + 1, 1, f / 10.0);
2060 hdrl_spectrum1D_wave_scale_linear);
2062 cpl_image_delete(flx);
2063 cpl_image_delete(flx_e);
2064 cpl_array_delete(wave);
2070cpl_boolean contains(
const cpl_array * arr, cpl_size idx){
2071 for(cpl_size i = 0; i < cpl_array_get_size(arr); ++i){
2072 const cpl_size this_idx = (cpl_size)cpl_array_get(arr, i, NULL);
2073 if(this_idx == idx)
return CPL_TRUE;
2078static inline hdrl_spectrum1D *
2079generate_bad_stair_spectrum(
int start,
int stop,
double start_wave,
2080 double step_wave, cpl_array * bad_idxes){
2082 const cpl_size sz = stop - start + 1;
2083 cpl_array * wave = get_waves(start_wave, sz, step_wave);
2084 cpl_image * flx = cpl_image_new(sz, 1, CPL_TYPE_DOUBLE);
2085 cpl_image * flx_e = cpl_image_new(sz, 1, CPL_TYPE_DOUBLE);
2088 for(cpl_size i = 0; i < sz; ++i){
2090 if(contains(bad_idxes, i))
2092 cpl_image_reject(flx, i + 1, 1);
2093 cpl_image_reject(flx_e, i + 1, 1);
2097 const double f = start + i;
2098 cpl_image_set(flx, i + 1, 1, f);
2099 cpl_image_set(flx_e, i + 1, 1, f / 10.0);
2103 hdrl_spectrum1D_wave_scale_linear);
2105 cpl_image_delete(flx);
2106 cpl_image_delete(flx_e);
2107 cpl_array_delete(wave);
2114static inline hdrl_spectrum1D *
2115generate_stair_spectrum_shuffled(
int start,
int stop,
double start_wave,
2116 double step_wave, cpl_size * idxes){
2118 const cpl_size sz = stop - start + 1;
2119 cpl_array * wave = get_waves(start_wave, sz, step_wave);
2120 cpl_array * wave_s = cpl_array_duplicate(wave);
2122 cpl_image * flx = cpl_image_new(sz, 1, CPL_TYPE_DOUBLE);
2123 cpl_image * flx_e = cpl_image_new(sz, 1, CPL_TYPE_DOUBLE);
2125 for(cpl_size i = 0; i < sz; ++i){
2126 const double f = start + i;
2127 const cpl_size dest_idx = idxes[i];
2128 cpl_image_set(flx, dest_idx + 1, 1, f);
2129 cpl_image_set(flx_e, dest_idx + 1, 1, f / 10.0);
2131 const double w = cpl_array_get(wave, i, NULL);
2132 cpl_array_set(wave_s, dest_idx, w);
2136 hdrl_spectrum1D_wave_scale_linear);
2138 cpl_image_delete(flx);
2139 cpl_image_delete(flx_e);
2140 cpl_array_delete(wave);
2141 cpl_array_delete(wave_s);
2149 hdrl_spectrum1D * ori_s = generate_stair_spectrum(1, 8, 20.0, 2.0);
2151 cpl_array * wavs_integrate = get_waves(21, 9, 1);
2152 hdrl_spectrum1D * integrated_s =
2160 cpl_test_eq(rej, 0);
2161 cpl_test_rel(f.data, 2.0, HDRL_DELTA_COMPARE_VALUE);
2162 cpl_test_rel(f.error, f.data / 10.0, HDRL_DELTA_COMPARE_VALUE);
2165 const cpl_size int_size = cpl_array_get_size(wavs_integrate);
2172 cpl_test_eq(rej, 0);
2173 cpl_test_rel(f.data, 5.0, HDRL_DELTA_COMPARE_VALUE);
2174 cpl_test_rel(f.error, f.data / 10.0, HDRL_DELTA_COMPARE_VALUE);
2177 double src_flx = 2.0;
2178 for(cpl_size i = 1; i < int_size - 1; ++i){
2183 cpl_test_eq(rej, 0);
2187 cpl_test_rel(f.data, src_flx, HDRL_DELTA_COMPARE_VALUE);
2188 cpl_test_rel(f.error, src_flx / 10.0, HDRL_DELTA_COMPARE_VALUE);
2193 const double el = src_flx + .5;
2194 cpl_test_rel(f.data, el, HDRL_DELTA_COMPARE_VALUE);
2196 const double el_e = pow(src_flx, 2.0) + pow((src_flx + 1.0), 2.0);
2197 cpl_test_rel(f.error, sqrt(el_e) / (10.0 * sqrt(2.0)), HDRL_DELTA_COMPARE_VALUE);
2205 cpl_array_delete(wavs_integrate);
2212 hdrl_spectrum1D * ori_s = generate_stair_spectrum(1, 8, 20.0, 2.0);
2214 cpl_array * wavs_integrate = get_waves(20, 15, 1);
2215 hdrl_spectrum1D * integrated_s =
2218 const cpl_size int_size = cpl_array_get_size(wavs_integrate);
2220 double src_flx = 1.0;
2221 for(cpl_size i = 0; i < int_size; ++i){
2226 cpl_test_eq(rej, 0);
2230 cpl_test_rel(f.data, src_flx, HDRL_DELTA_COMPARE_VALUE);
2231 cpl_test_rel(f.error, src_flx / 10.0, HDRL_DELTA_COMPARE_VALUE);
2236 const double el = src_flx + .5;
2237 cpl_test_rel(f.data, el, HDRL_DELTA_COMPARE_VALUE);
2239 const double el_e = pow(src_flx, 2.0) + pow((src_flx + 1.0), 2.0);
2240 cpl_test_rel(f.error, sqrt(el_e) / (10.0 * sqrt(2.0)), HDRL_DELTA_COMPARE_VALUE);
2248 cpl_array_delete(wavs_integrate);
2255 hdrl_spectrum1D * ori_s = generate_stair_spectrum(1, 8, 20.0, 2.0);
2257 cpl_array * wavs_integrate = get_waves(19, 17, 1);
2258 hdrl_spectrum1D * integrated_s =
2261 const cpl_size int_size = cpl_array_get_size(wavs_integrate);
2264 for(cpl_size i = 0; i < 2; ++i){
2267 cpl_test_eq(rej, 1);
2268 cpl_test(isnan(f.data));
2269 cpl_test(isnan(f.error));
2273 for(cpl_size i = int_size - 2; i < int_size; ++i){
2276 cpl_test_eq(rej, 1);
2277 cpl_test(isnan(f.data));
2278 cpl_test(isnan(f.error));
2281 double src_flx = 1.0;
2282 for(cpl_size i = 2; i < int_size - 2; ++i){
2287 cpl_test_eq(rej, 0);
2291 cpl_test_rel(f.data, src_flx, HDRL_DELTA_COMPARE_VALUE);
2292 cpl_test_rel(f.error, src_flx / 10.0, HDRL_DELTA_COMPARE_VALUE);
2297 const double el = src_flx + .5;
2298 cpl_test_rel(f.data, el, HDRL_DELTA_COMPARE_VALUE);
2300 const double el_e = pow(src_flx, 2.0) + pow((src_flx + 1.0), 2.0);
2301 cpl_test_rel(f.error, sqrt(el_e) / (10.0 * sqrt(2.0)), HDRL_DELTA_COMPARE_VALUE);
2309 cpl_array_delete(wavs_integrate);
2312static inline cpl_array *
2313shuffle(
const cpl_array * ori,
const cpl_size * idxes){
2314 cpl_array * to_ret = cpl_array_duplicate(ori);
2315 cpl_size sz = cpl_array_get_size(ori);
2316 for(cpl_size i = 0; i < sz; ++i){
2317 const double w = cpl_array_get(ori, i, NULL);
2318 cpl_array_set(to_ret, idxes[i], w);
2326 hdrl_spectrum1D * ori_s = generate_stair_spectrum(1, 8, 20.0, 2.0);
2328 hdrl_spectrum1D * ori_s_shuffled = generate_stair_spectrum_shuffled(1, 8, 20.0, 2.0,
2329 (cpl_size[]){3, 2, 1, 4, 7, 6, 0, 5});
2331 cpl_array * wavs_integrate = get_waves(21, 9, 1);
2333 cpl_size shuffles[] = {1, 3, 5, 0, 8, 7, 6, 2, 4};
2334 cpl_array * wavs_integrate_shuffle = shuffle(wavs_integrate,
2337 hdrl_spectrum1D * integrated_s_shuffled =
2340 hdrl_spectrum1D * integrated_s=
2344 cpl_test_eq(sz, cpl_array_get_size(wavs_integrate));
2347 for(cpl_size i = 0; i < sz; ++i){
2350 const double wav = cpl_array_get(wavs_integrate, i, NULL);
2351 cpl_test_rel(wav_s, wav, HDRL_DELTA_COMPARE_VALUE);
2354 for(cpl_size i = 0; i < sz; ++i){
2357 const double wav = cpl_array_get(wavs_integrate_shuffle, i, NULL);
2358 cpl_test_rel(wav_s, wav, HDRL_DELTA_COMPARE_VALUE);
2361 for(cpl_size i = 0; i < sz; ++i){
2362 int rej = 0, rej_shuffled = 0;
2367 shuffles[i], &rej_shuffled);
2375 cpl_test_rel(wav, wav_shuffled, HDRL_DELTA_COMPARE_VALUE);
2376 cpl_test_eq(rej, rej_shuffled);
2377 cpl_test_rel(flx.data, flx_shuffled.data, HDRL_DELTA_COMPARE_VALUE);
2378 cpl_test_rel(flx.error, flx_shuffled.error, HDRL_DELTA_COMPARE_VALUE);
2386 cpl_array_delete(wavs_integrate);
2387 cpl_array_delete(wavs_integrate_shuffle);
2394 cpl_array * bad_idxes = cpl_array_new(4, CPL_TYPE_INT);
2396 cpl_array_set(bad_idxes, 0, 0);
2397 cpl_array_set(bad_idxes, 1, 7);
2398 cpl_array_set(bad_idxes, 2, 2);
2399 cpl_array_set(bad_idxes, 3, 5);
2401 hdrl_spectrum1D * ori_s = generate_bad_stair_spectrum(1, 8, 20.0, 2.0 , bad_idxes);
2403 cpl_array * wavs_integrate = get_waves(19, 17, 1);
2404 hdrl_spectrum1D * integrated_s =
2407 const cpl_size int_size = cpl_array_get_size(wavs_integrate);
2411 for(cpl_size i = 0; i < 3; ++i){
2414 cpl_test_eq(rej, 1);
2415 cpl_test(isnan(f.data));
2416 cpl_test(isnan(f.error));
2421 for(cpl_size i = int_size - 3; i < int_size; ++i){
2424 cpl_test_eq(rej, 1);
2425 cpl_test(isnan(f.data));
2426 cpl_test(isnan(f.error));
2429 double src_flx = 2.0;
2430 for(cpl_size i = 3; i < int_size - 3; ++i){
2433 if((i >=4 && i <= 6) || (i >= 10 && i <= 12)){
2436 cpl_test_eq(rej, 1);
2437 cpl_test(isnan(f.data));
2438 cpl_test(isnan(f.error));
2440 if((i % 2) == 0) src_flx++;
2448 cpl_test_eq(rej, 0);
2452 cpl_test_rel(f.data, src_flx, HDRL_DELTA_COMPARE_VALUE);
2453 cpl_test_rel(f.error, src_flx / 10.0, HDRL_DELTA_COMPARE_VALUE);
2458 const double el = src_flx + .5;
2459 cpl_test_rel(f.data, el, HDRL_DELTA_COMPARE_VALUE);
2461 const double el_e = pow(src_flx, 2.0) + pow((src_flx + 1.0), 2.0);
2462 cpl_test_rel(f.error, sqrt(el_e) / (10.0 * sqrt(2.0)), HDRL_DELTA_COMPARE_VALUE);
2470 cpl_array_delete(wavs_integrate);
2471 cpl_array_delete(bad_idxes);
2478 hdrl_spectrum1D * ori_s = generate_stair_spectrum(1, 8, 20.0, 2.0);
2480 cpl_array * wavs_integrate = get_waves(20.5, 15, 1);
2481 hdrl_spectrum1D * integrated_s =
2484 double src_flx = 1.0;
2486 for(cpl_size i = 0; i < cpl_array_get_size(wavs_integrate) - 1; ++i){
2489 cpl_test_eq(rej, 0);
2490 cpl_test_rel(f.data, src_flx, HDRL_DELTA_COMPARE_VALUE);
2491 cpl_test_rel(f.error, src_flx / 10.0, HDRL_DELTA_COMPARE_VALUE);
2492 src_flx = src_flx + ((i+1) % 2);
2497 cpl_array_get_size(wavs_integrate) - 1, &rej);
2498 cpl_test_eq(rej, 1);
2499 cpl_test(isnan(f.data));
2500 cpl_test(isnan(f.error));
2505 cpl_array_delete(wavs_integrate);
2512 cpl_array * bads = cpl_array_new(3, CPL_TYPE_INT);
2514 cpl_array_set(bads, 0, 0);
2515 cpl_array_set(bads, 1, 7);
2516 cpl_array_set(bads, 2, 4);
2518 hdrl_spectrum1D * ori_s = generate_bad_stair_spectrum(1, 8, 20.0, 2.0, bads);
2520 cpl_array * wavs_integrate = get_waves(20.5, 15, 1);
2521 hdrl_spectrum1D * integrated_s =
2524 double src_flx = 1.0;
2526 for(cpl_size i = 0; i < cpl_array_get_size(wavs_integrate); ++i){
2530 if(i == 0 || i == 7 || i == 8 || i >= 13){
2531 cpl_test_eq(rej, 1);
2532 cpl_test(isnan(f.data));
2533 cpl_test(isnan(f.error));
2536 cpl_test_eq(rej, 0);
2537 cpl_test_rel(f.data, src_flx, HDRL_DELTA_COMPARE_VALUE);
2538 cpl_test_rel(f.error, src_flx / 10.0, HDRL_DELTA_COMPARE_VALUE);
2540 src_flx = src_flx + ((i+1) % 2);
2546 cpl_array_delete(wavs_integrate);
2547 cpl_array_delete(bads);
2554 hdrl_spectrum1D * ori_s = generate_stair_spectrum(1, 8, 20.0, 1.0);
2556 cpl_array * wavs_integrate = get_waves(21, 3, 2);
2557 hdrl_spectrum1D * integrated_s =
2560 double res_flx[] = {2.5, 4, 5.5};
2561 double res_flx_e[] = {sqrt(6.5), sqrt(16.5), sqrt(30.5)};
2563 for(cpl_size i = 0; i < 3; ++i){
2568 cpl_test_eq(rej, 0);
2569 cpl_test_rel(f.data, res_flx[i], HDRL_DELTA_COMPARE_VALUE);
2570 cpl_test_rel(f.error, res_flx_e[i] / 10.0, HDRL_DELTA_COMPARE_VALUE);
2576 cpl_array_delete(wavs_integrate);
2582 hdrl_spectrum1D * ori_s = generate_stair_spectrum(1, 8, 20.0, 1.0);
2584 cpl_array * wavs_integrate = get_waves(19, 5, 2);
2585 hdrl_spectrum1D * integrated_s =
2592 cpl_test(isnan(f.data));
2593 cpl_test(isnan(f.error));
2596 double res_flx[] = {2, 4, 6, 7.5};
2597 for(cpl_size i = 1; i <= 4; ++i){
2602 cpl_test_eq(rej, 0);
2603 cpl_test_rel(f.data, res_flx[i - 1], HDRL_DELTA_COMPARE_VALUE);
2609 cpl_array_delete(wavs_integrate);
2616 hdrl_spectrum1D * ori_s = generate_stair_spectrum(1, 8, 20.0, 1.0);
2618 cpl_array * wavs_integrate = get_waves(19, 6, 2);
2619 hdrl_spectrum1D * integrated_s =
2625 cpl_test(isnan(f.data));
2626 cpl_test(isnan(f.error));
2629 double res_flx[] = {2, 4, 6};
2630 for(cpl_size i = 1; i <= 3; ++i){
2635 cpl_test_eq(rej, 0);
2636 cpl_test_rel(f.data, res_flx[i - 1], HDRL_DELTA_COMPARE_VALUE);
2639 for(cpl_size i = 4; i < 6; ++i){
2643 cpl_test(isnan(f.data));
2644 cpl_test(isnan(f.error));
2650 cpl_array_delete(wavs_integrate);
2657 cpl_array * bads = cpl_array_new(1, CPL_TYPE_INT);
2659 cpl_array_set(bads, 0, 3);
2661 hdrl_spectrum1D * ori_s = generate_bad_stair_spectrum(1, 8, 20.0, 1.0, bads);
2663 cpl_array * wavs_integrate = get_waves(19, 6, 2);
2664 hdrl_spectrum1D * integrated_s =
2670 cpl_test(isnan(f.data));
2671 cpl_test(isnan(f.error));
2674 double res_flx[] = {2, 4, 6};
2675 for(cpl_size i = 1; i <= 3; ++i){
2682 cpl_test(isnan(f.data));
2683 cpl_test(isnan(f.error));
2687 cpl_test_eq(rej, 0);
2688 cpl_test_rel(f.data, res_flx[i - 1], HDRL_DELTA_COMPARE_VALUE);
2691 for(cpl_size i = 4; i < 6; ++i){
2695 cpl_test(isnan(f.data));
2696 cpl_test(isnan(f.error));
2702 cpl_array_delete(wavs_integrate);
2703 cpl_array_delete(bads);
2709 cpl_array * bads = cpl_array_new(1, CPL_TYPE_INT);
2711 cpl_array_set(bads, 0, 4);
2713 hdrl_spectrum1D * ori_s = generate_bad_stair_spectrum(1, 8, 20.0, 1.0, bads);
2715 cpl_array * wavs_integrate = get_waves(19, 6, 2);
2716 hdrl_spectrum1D * integrated_s =
2723 cpl_test(isnan(f.data));
2724 cpl_test(isnan(f.error));
2727 double res_flx[] = {2, 4, 6};
2728 for(cpl_size i = 1; i <= 3; ++i){
2733 if(i == 2 || i == 3){
2735 cpl_test(isnan(f.data));
2736 cpl_test(isnan(f.error));
2740 cpl_test_eq(rej, 0);
2741 cpl_test_rel(f.data, res_flx[i - 1], HDRL_DELTA_COMPARE_VALUE);
2744 for(cpl_size i = 4; i < 6; ++i){
2748 cpl_test(isnan(f.data));
2749 cpl_test(isnan(f.error));
2755 cpl_array_delete(wavs_integrate);
2756 cpl_array_delete(bads);
2763 cpl_array * bads = cpl_array_new(2, CPL_TYPE_INT);
2765 cpl_array_set(bads, 0, 0);
2766 cpl_array_set(bads, 1, 7);
2768 hdrl_spectrum1D * ori_s = generate_bad_stair_spectrum(1, 8, 20.0, 1.0, bads);
2770 cpl_array * wavs_integrate = get_waves(19, 6, 2);
2771 hdrl_spectrum1D * integrated_s =
2777 cpl_test(isnan(f.data));
2778 cpl_test(isnan(f.error));
2781 double res_flx[] = {2, 4, 6};
2782 for(cpl_size i = 0; i <= 3; ++i){
2787 if(i == 0 || i == 1){
2789 cpl_test(isnan(f.data));
2790 cpl_test(isnan(f.error));
2794 cpl_test_eq(rej, 0);
2795 cpl_test_rel(f.data, res_flx[i - 1], HDRL_DELTA_COMPARE_VALUE);
2798 for(cpl_size i = 4; i < 6; ++i){
2802 cpl_test(isnan(f.data));
2803 cpl_test(isnan(f.error));
2809 cpl_array_delete(wavs_integrate);
2810 cpl_array_delete(bads);
2817 cpl_array * bads = cpl_array_new(2, CPL_TYPE_INT);
2819 cpl_array_set(bads, 0, 0);
2820 cpl_array_set(bads, 1, 4);
2822 hdrl_spectrum1D * ori_s = generate_bad_stair_spectrum(1, 9, 20.5, 1.0, bads);
2824 cpl_array * wavs_integrate = get_waves(21, 5, 2);
2825 hdrl_spectrum1D * integrated_s =
2829 double res_flx[] = {2, 3.5, 4.5, 7.5};
2831 for(cpl_size i = 0; i < cpl_array_get_size(wavs_integrate) - 1; ++i){
2837 cpl_test(isnan(f.data));
2838 cpl_test(isnan(f.error));
2842 cpl_test_eq(rej, 0);
2843 cpl_test_rel(f.data, res_flx[i], HDRL_DELTA_COMPARE_VALUE);
2848 cpl_array_get_size(wavs_integrate) - 1, &rej);
2850 cpl_test(isnan(f.data));
2851 cpl_test(isnan(f.error));
2856 cpl_array_delete(wavs_integrate);
2857 cpl_array_delete(bads);
2864 hdrl_spectrum1D * ori_s = generate_stair_spectrum(1, 3, 20.5, 1.0);
2867 cpl_test_rel(wa_mx, 22.5, HDRL_DELTA_COMPARE_VALUE);
2869 cpl_array * wavs_integrate = get_waves(22.5, 5, 2);
2870 hdrl_spectrum1D * integrated_s =
2873 for(cpl_size i = 0; i < cpl_array_get_size(wavs_integrate); ++i){
2877 cpl_test(isnan(f.data));
2878 cpl_test(isnan(f.error));
2884 cpl_array_delete(wavs_integrate);
2891 hdrl_spectrum1D * ori_s = generate_stair_spectrum(1, 3, 20.5, 1.0);
2893 cpl_array * wavs_integrate = get_waves(14.5, 4, 2);
2895 double wa_mx = cpl_array_get(wavs_integrate, 3, NULL);
2896 cpl_test_rel(wa_mx, 20.5, HDRL_DELTA_COMPARE_VALUE);
2898 hdrl_spectrum1D * integrated_s =
2901 for(cpl_size i = 0; i < cpl_array_get_size(wavs_integrate); ++i){
2905 cpl_test(isnan(f.data));
2906 cpl_test(isnan(f.error));
2912 cpl_array_delete(wavs_integrate);
2918 cpl_array * bads = cpl_array_new(3, CPL_TYPE_INT);
2920 cpl_array_set(bads, 0, 0);
2921 cpl_array_set(bads, 1, 4);
2922 cpl_array_set(bads, 2, 7);
2924 hdrl_spectrum1D * ori_s = generate_bad_stair_spectrum(1, 8, 20.5, 1.0, bads);
2926 const cpl_array * wavs_integrate =
2929 hdrl_spectrum1D * integrated_s =
2932 for(cpl_size i = 0; i < cpl_array_get_size(wavs_integrate); ++i){
2939 cpl_test_eq(ori_rej, int_rej);
2940 if(ori_rej)
continue;
2942 cpl_test_rel(ori_flx.data, int_flx.data, HDRL_DELTA_COMPARE_VALUE);
2943 cpl_test_rel(ori_flx.error, int_flx.error, HDRL_DELTA_COMPARE_VALUE);
2949 cpl_array_delete(bads);
2952double get_bin_size(
const hdrl_spectrum1D * s,
const cpl_size i){
2957 return (w0 + w1) / 2 - w0;
2964 return (w0 + w1) / 2 - w0;
2969 return (w0 + w1) / 2 - w0;
2972double calc_total_flux(
const hdrl_spectrum1D * s){
2975 for(cpl_size i = 0; i < sz; ++i)
2986 hdrl_spectrum1D * ori_s = generate_stair_spectrum(1, 4, 20.0, 2.0);
2988 cpl_array * wavs_integrate = get_waves(20, 3, 3);
2990 hdrl_spectrum1D * integrated_s =
2993 cpl_test_rel(calc_total_flux(ori_s), 15.0, HDRL_DELTA_COMPARE_VALUE);
2995 cpl_test_rel(calc_total_flux(ori_s), calc_total_flux(integrated_s), HDRL_DELTA_COMPARE_VALUE);
3000 cpl_array_delete(wavs_integrate);
3008void test_spectrum1D_resample_spectrum_integrate(
void){
3065 cpl_test_eq(cpl_error_get_code(), CPL_ERROR_NONE);
3068void test_parlist(
void)
3071 const char *base_context =
"RECIPE";
3072 const char *prefix =
"test";
3073 const char *method_def =
"LINEAR";
3075 cpl_parameterlist *pos;
3076 pos = hdrl_spectrum1D_resample_interpolate_parameter_create_parlist(base_context, prefix, method_def);
3077 cpl_test_error(CPL_ERROR_NONE);
3079 hdrl_parameter *hpar;
3080 hpar = hdrl_spectrum1D_resample_interpolate_parameter_parse_parlist(
3081 pos,
"RECIPE.test");
3082 cpl_test_error(CPL_ERROR_NONE);
3086 cpl_parameterlist_delete(pos);
3096 cpl_test_init(PACKAGE_BUGREPORT, CPL_MSG_WARNING);
3102 test_spectrum1D_constructor(CPL_TYPE_DOUBLE);
3103 test_spectrum1D_constructor(CPL_TYPE_FLOAT);
3104 test_spectrum1D_constructor_error();
3105 test_spectrum1D_constructor_analytical();
3106 test_spectrum1D_duplication();
3109 test_spectrum1D_calculation_scalar();
3111 test_spectrum1D_calculation();
3112 test_spectrum1D_calculation_error();
3114 test_spectrum1D_conversion_wavelength_scale();
3115 test_spectrum1D_mul_wavelength();
3116 test_spectrum1D_shift_wavelength();
3118 test_spectrum1D_wavelength_select();
3120 test_spectrum1D_resample_spectrum(CPL_TRUE);
3121 test_spectrum1D_resample_spectrum(CPL_FALSE);
3122 test_spectrum1D_resample_spectrum_private_funcs();
3123 test_spectrum1D_resample_spectrum_bpm(CPL_TRUE);
3124 test_spectrum1D_resample_spectrum_bpm(CPL_FALSE);
3125 test_spectrum1D_resample_spectrum_interpolation_error_test();
3126 test_spectrum1D_resample_spectrum_fit_error_test_shift(CPL_TRUE);
3127 test_spectrum1D_resample_spectrum_fit_error_test_shift(CPL_FALSE);
3128 test_spectrum1D_resample_spectrum_fit_error_test_error_interpol();
3129 test_spectrum1D_resample_spectrum_fit_windowed();
3131 test_spectrum1D_resample_spectrum_integrate();
3133 test_spectrum1D_table_conversion();
3135 test_spectrum1D_test_uniformly_sampled();
3137 test_spectrum1Dlist();
3139 return cpl_test_end(0);
3148static inline cpl_image * get_random_1d_img(cpl_size length,
3149 double min,
double max, cpl_type type){
3150 cpl_image * to_ret = cpl_image_new(length, 1, type);
3152 for(cpl_size i = 0; i < length; i++){
3153 double d = rand_0_to_1() * (max - min) + min;
3154 cpl_image_set(to_ret, i + 1, 1, d);
3159static inline void set_1d_bpm(cpl_image * img){
3161 int sz_x = cpl_image_get_size_x(img);
3162 int sz_y = cpl_image_get_size_y(img);
3164 cpl_mask * msk = cpl_image_get_bpm(img);
3166 for(cpl_size x = 0; x < sz_x; x++){
3167 for(cpl_size y = 0; y < sz_y; y++){
3168 cpl_mask_set(msk, x + 1, y + 1, rand_0_to_1() > .5);
3174static inline cpl_array * get_wavelength(cpl_size length, cpl_type type){
3176 cpl_array * to_ret = cpl_array_new(length, type);
3177 double d = rand_0_to_1();
3179 for(cpl_size i = 0; i < length; i++){
3180 cpl_array_set(to_ret, i, d);
3181 d += 1.0 + rand_0_to_1();
3186static inline cpl_boolean are_cpl_img_eq(
3187 const cpl_image *im1,
const cpl_image *im2){
3189 if (cpl_image_get_size_x(im1) != cpl_image_get_size_x(im2) ||
3190 cpl_image_get_size_y(im1) != cpl_image_get_size_y(im2) ){
3194 cpl_size sz_x = cpl_image_get_size_x(im1);
3195 cpl_size sz_y = cpl_image_get_size_y(im1);
3200 for(cpl_size x = 0; x < sz_x; x++){
3201 for(cpl_size y = 0; y < sz_y; y++){
3202 double px1 = cpl_image_get(im1, x + 1, y + 1, &rej1);
3203 double px2 = cpl_image_get(im2, x + 1, y + 1, &rej2);
3205 if(px1 != px2 || rej1 != rej2) {
3214static inline cpl_boolean are_hdrl_eq(
const hdrl_image* flux_compound,
3215 const cpl_image * flux,
const cpl_image * flux_e){
3217 if (cpl_image_get_size_x(flux) != cpl_image_get_size_x(flux_e) ||
3218 cpl_image_get_size_y(flux) != cpl_image_get_size_y(flux_e) ||
3229 cpl_boolean is_success =
3240static inline cpl_error_code get_error_code_and_reset(
void){
3242 cpl_error_code err = cpl_error_get_code();
3247static inline double rand_0_to_1(
void){
3253static inline hdrl_spectrum1D *
3254get_random_spectrum(
int length, hdrl_spectrum1D_wave_scale scale){
3256 cpl_image * spectrum1d =
3257 get_random_1d_img(length, 1.0f, 128.0f, CPL_TYPE_DOUBLE);
3258 cpl_image * spectrum1d_error =
3259 get_random_1d_img(length, 0.5f, 2.0f, CPL_TYPE_DOUBLE);
3261 set_1d_bpm(spectrum1d);
3262 cpl_array * wavelengths = get_wavelength(length, CPL_TYPE_DOUBLE);
3265 spectrum1d, spectrum1d_error,
3266 wavelengths, scale);
3268 cpl_array_delete(wavelengths);
3269 cpl_image_delete(spectrum1d);
3270 cpl_image_delete(spectrum1d_error);
3277test_error_create_func(
const hdrl_spectrum1D * s1,
const hdrl_spectrum1D * s2,
3278 operate_spectra_create f){
3280 hdrl_spectrum1D * res = f(s1, s2);
3282 const cpl_error_code cd = get_error_code_and_reset();
3283 cpl_test_noneq(cd, CPL_ERROR_NONE);
3287test_error_mutate_func(hdrl_spectrum1D * s1,
const hdrl_spectrum1D * s2,
3290 const cpl_error_code res = f(s1, s2);
3291 cpl_test_noneq(res, CPL_ERROR_NONE);
3293 const cpl_error_code cd = get_error_code_and_reset();
3294 cpl_test_noneq(cd, CPL_ERROR_NONE);
3298test_calc_creat_error(operate_spectra_create f){
3300 hdrl_spectrum1D * spec_l40_linear =
3301 get_random_spectrum(40, hdrl_spectrum1D_wave_scale_linear);
3302 hdrl_spectrum1D * spec_l40_log =
3303 get_random_spectrum(40, hdrl_spectrum1D_wave_scale_log);
3305 hdrl_spectrum1D * spec_l41_linear =
3306 get_random_spectrum(41, hdrl_spectrum1D_wave_scale_linear);
3307 hdrl_spectrum1D * spec_l41_log =
3308 get_random_spectrum(41, hdrl_spectrum1D_wave_scale_log);
3310 test_error_create_func
3311 (spec_l40_linear, spec_l40_log, f);
3312 test_error_create_func
3313 (spec_l41_linear, spec_l40_linear, f);
3314 test_error_create_func
3315 (spec_l40_log, spec_l40_linear, f);
3316 test_error_create_func
3317 (spec_l40_linear, spec_l41_linear, f);
3319 test_error_create_func
3320 (NULL, spec_l40_log, f);
3321 test_error_create_func
3322 (spec_l41_linear, NULL, f);
3323 test_error_create_func(NULL, NULL, f);
3334static inline void test_calc_error(operate_spectra f){
3336 hdrl_spectrum1D * spec_l40_linear =
3337 get_random_spectrum(40, hdrl_spectrum1D_wave_scale_linear);
3338 hdrl_spectrum1D * spec_l40_log =
3339 get_random_spectrum(40, hdrl_spectrum1D_wave_scale_log);
3341 hdrl_spectrum1D * spec_l41_linear =
3342 get_random_spectrum(41, hdrl_spectrum1D_wave_scale_linear);
3343 hdrl_spectrum1D * spec_l41_log =
3344 get_random_spectrum(41, hdrl_spectrum1D_wave_scale_log);
3346 test_error_mutate_func
3347 (spec_l40_linear, spec_l40_log, f);
3348 test_error_mutate_func
3349 (spec_l41_linear, spec_l40_linear, f);
3350 test_error_mutate_func
3351 (spec_l40_log, spec_l40_linear, f);
3352 test_error_mutate_func
3353 (spec_l40_linear, spec_l41_linear, f);
3355 test_error_mutate_func
3356 (NULL, spec_l40_log, f);
3357 test_error_mutate_func
3358 (spec_l41_linear, NULL, f);
3359 test_error_mutate_func(NULL, NULL, f);
3368static inline hdrl_spectrum1D * get_spectrum1D_sin_shuffled(cpl_size sz,
int start,
3369 cpl_boolean add_peak, cpl_array ** unshuffled_lambda){
3371 static const double peak = 100.0;
3372 const double delta = 2 * CPL_MATH_PI / sz;
3374 cpl_array * lambda = cpl_array_new(sz, HDRL_TYPE_DATA);
3375 cpl_image * flux = cpl_image_new(sz, 1, HDRL_TYPE_DATA);
3377 for(cpl_size i = 0; i < sz; i++){
3378 double l = delta * (i + start);
3379 double f = fabs(peak * (sin(l) + 1.1));
3381 if(i == 4 && add_peak) f *= 1.5;
3383 cpl_array_set(lambda, i, l);
3384 cpl_image_set(flux, i + 1, 1, f);
3387 if(unshuffled_lambda)
3388 *unshuffled_lambda = cpl_array_duplicate(lambda);
3391 for(cpl_size i1 = 0; i1 < sz; i1++){
3393 double l1 = cpl_array_get(lambda, i1, &rej);
3394 double f1 = cpl_image_get(flux, i1 + 1, 1, &rej);
3396 cpl_size i2 = (cpl_size)(rand_0_to_1() * (sz - 1));
3398 double l2 = cpl_array_get(lambda, i2, &rej);
3399 double f2 = cpl_image_get(flux, i2 + 1, 1, &rej);
3401 cpl_array_set(lambda, i1, l2);
3402 cpl_image_set(flux, i1 + 1, 1, f2);
3404 cpl_array_set(lambda, i2, l1);
3405 cpl_image_set(flux, i2 + 1, 1, f1);
3409 hdrl_spectrum1D * sp =
3411 (flux, 10, lambda, hdrl_spectrum1D_wave_scale_linear);
3413 cpl_test_nonnull(sp);
3414 cpl_test_eq(get_error_code_and_reset(), CPL_ERROR_NONE);
3417 cpl_array_delete(lambda);
3418 cpl_image_delete(flux);
cpl_size hdrl_image_get_size_y(const hdrl_image *self)
return size of Y dimension of image
cpl_size hdrl_image_get_size_x(const hdrl_image *self)
return size of X dimension of image
const cpl_image * hdrl_image_get_error_const(const hdrl_image *himg)
get error as cpl image
hdrl_image * hdrl_image_create(const cpl_image *image, const cpl_image *error)
create a new hdrl_image from to existing images by copying them
const cpl_image * hdrl_image_get_image_const(const hdrl_image *himg)
get data as cpl image
void hdrl_image_delete(hdrl_image *himg)
delete hdrl_image
void hdrl_parameter_delete(hdrl_parameter *obj)
shallow delete of a parameter
hdrl_spectrum1D * hdrl_spectrum1D_pow_scalar_create(const hdrl_spectrum1D *self, hdrl_value scalar_operator)
subtract a scalar from a spectrum
const hdrl_image * hdrl_spectrum1D_get_flux(const hdrl_spectrum1D *self)
hdrl_spectrum1D getter flux
cpl_error_code hdrl_spectrum1D_mul_scalar(hdrl_spectrum1D *self, hdrl_value scalar_operator)
computes the elementwise multiplication of a spectrum by a scalar, the self parameter is modified
cpl_error_code hdrl_spectrum1D_wavelength_mult_scalar_linear(hdrl_spectrum1D *self, hdrl_data_t scale_linear)
computes the elementwise multiplication of the scalar for the wavelength. The scalar is assumed to be...
cpl_error_code hdrl_spectrum1D_wavelength_convert_to_linear(hdrl_spectrum1D *self)
converts the wavelength scale to linear.
hdrl_spectrum1D * hdrl_spectrum1D_sub_spectrum_create(const hdrl_spectrum1D *f1, const hdrl_spectrum1D *f2)
subtract two spectra
cpl_error_code hdrl_spectrum1D_wavelength_shift(hdrl_spectrum1D *self, hdrl_data_t shift)
computes the elementwise shift of the wavelength by the shift parameter. The self parameter is modifi...
cpl_size hdrl_spectrum1Dlist_get_size(const hdrl_spectrum1Dlist *l)
hdrl_spectrum1Dlist getter for size
hdrl_spectrum1D * hdrl_spectrum1D_resample(const hdrl_spectrum1D *self, const hdrl_spectrum1D_wavelength *waves, const hdrl_parameter *par)
resample a hdrl_spectrum1D on the wavelengths contained in waves
cpl_error_code hdrl_spectrum1D_div_spectrum(hdrl_spectrum1D *self, const hdrl_spectrum1D *other)
divide one spectrum by another spectrum
hdrl_spectrum1Dlist * hdrl_spectrum1Dlist_new(void)
hdrl_spectrum1Dlist default constructor
cpl_error_code hdrl_spectrum1D_pow_scalar(hdrl_spectrum1D *self, hdrl_value scalar_operator)
computes the elementwise power of the flux to the scalar, the self parameter is modified
hdrl_spectrum1D * hdrl_spectrum1D_mul_spectrum_create(const hdrl_spectrum1D *f1, const hdrl_spectrum1D *f2)
multiply one spectrum by another spectrum
hdrl_parameter * hdrl_spectrum1D_resample_interpolate_parameter_create(const hdrl_spectrum1D_interpolation_method method)
constructor for the hdrl_parameter in the case of interpolation
hdrl_spectrum1D * hdrl_spectrum1D_duplicate(const hdrl_spectrum1D *self)
hdrl_spectrum1D copy constructor
cpl_size hdrl_spectrum1D_get_size(const hdrl_spectrum1D *self)
hdrl_spectrum1D getter for size
hdrl_spectrum1D * hdrl_spectrum1Dlist_unset(hdrl_spectrum1Dlist *self, const cpl_size idx)
hdrl_spectrum1Dlist remove of the i-th element
void hdrl_spectrum1D_delete(hdrl_spectrum1D **p_self)
hdrl_spectrum1D destructor
cpl_error_code hdrl_spectrum1D_mul_spectrum(hdrl_spectrum1D *self, const hdrl_spectrum1D *other)
multiply one spectrum by another spectrum
cpl_error_code hdrl_spectrum1D_wavelength_convert_to_log(hdrl_spectrum1D *self)
converts the wavelength scale to log. If the spectrum is already in log scale nothing is done.
hdrl_spectrum1D * hdrl_spectrum1D_div_spectrum_create(const hdrl_spectrum1D *num, const hdrl_spectrum1D *den)
divide one spectrum by another spectrum
cpl_error_code hdrl_spectrum1D_exp_scalar(hdrl_spectrum1D *self, hdrl_value scalar_operator)
computes the elementwise power of the scalar to the flux, the self parameter is modified
hdrl_spectrum1D * hdrl_spectrum1D_mul_scalar_create(const hdrl_spectrum1D *self, hdrl_value scalar_operator)
multiply a spectrum by a scalar
cpl_error_code hdrl_spectrum1D_sub_spectrum(hdrl_spectrum1D *self, const hdrl_spectrum1D *other)
subtract two spectra
cpl_error_code hdrl_spectrum1Dlist_set(hdrl_spectrum1Dlist *self, hdrl_spectrum1D *s, const cpl_size idx)
hdrl_spectrum1Dlist setter of the i-th element
hdrl_parameter * hdrl_spectrum1D_resample_fit_parameter_create(const int k, const int nCoeff)
constructor for the hdrl_parameter in the case of interpolation
void hdrl_spectrum1Dlist_delete(hdrl_spectrum1Dlist *l)
hdrl_spectrum1Dlist destructor
hdrl_spectrum1D * hdrl_spectrum1D_wavelength_shift_create(const hdrl_spectrum1D *self, hdrl_data_t shift)
computes the elementwise shift of the wavelength by the shift parameter.
hdrl_spectrum1D * hdrl_spectrum1D_div_scalar_create(const hdrl_spectrum1D *self, hdrl_value scalar_operator)
divide a spectrum by a scalar
hdrl_spectrum1D * hdrl_spectrum1D_create_error_DER_SNR(const cpl_image *arg_flux, cpl_size half_window, const cpl_array *wavelength, hdrl_spectrum1D_wave_scale scale)
hdrl_spectrum1D constructor when no error information is available, in this case we use DER_SNR to es...
hdrl_spectrum1D * hdrl_spectrum1Dlist_get(hdrl_spectrum1Dlist *self, const cpl_size idx)
hdrl_spectrum1Dlist getter of the i-th element
hdrl_spectrum1D * hdrl_spectrum1D_convert_from_table(const cpl_table *self, const char *flux_col_name, const char *wavelength_col_name, const char *flux_e_col_name, const char *flux_bpm_col_name, hdrl_spectrum1D_wave_scale scale)
convert a table to a spectrum
hdrl_spectrum1D * hdrl_spectrum1D_wavelength_convert_to_log_create(const hdrl_spectrum1D *self)
converts the wavelength scale to log. It returns a modified version of self. self is not modified....
const hdrl_spectrum1D * hdrl_spectrum1Dlist_get_const(const hdrl_spectrum1Dlist *self, const cpl_size idx)
hdrl_spectrum1Dlist getter of the i-th element
cpl_error_code hdrl_spectrum1D_sub_scalar(hdrl_spectrum1D *self, hdrl_value scalar_operator)
computes the elementwise subtraction of a spectrum by a scalar, the self parameter is modified
cpl_boolean hdrl_spectrum1D_is_uniformly_sampled(const hdrl_spectrum1D *self, double *bin)
checks if the spectrum is defined on uniformly sampled wavelengths.
hdrl_spectrum1D * hdrl_spectrum1D_create(const cpl_image *arg_flux, const cpl_image *arg_flux_e, const cpl_array *wavelength, hdrl_spectrum1D_wave_scale wave_scale)
hdrl_spectrum1D default constructor
cpl_error_code hdrl_spectrum1D_add_scalar(hdrl_spectrum1D *self, hdrl_value scalar_operator)
computes the elementwise addition of a spectrum by a scalar, the self parameter is modified
hdrl_spectrum1D * hdrl_spectrum1D_resample_on_array(const hdrl_spectrum1D *self, const cpl_array *waves, const hdrl_parameter *par)
resample a hdrl_spectrum1D on the wavelengths contained in waves
cpl_error_code hdrl_spectrum1D_add_spectrum(hdrl_spectrum1D *self, const hdrl_spectrum1D *other)
sum two spectra
hdrl_spectrum1D * hdrl_spectrum1D_exp_scalar_create(const hdrl_spectrum1D *self, hdrl_value scalar_operator)
subtract a scalar from a spectrum
hdrl_spectrum1D * hdrl_spectrum1D_sub_scalar_create(const hdrl_spectrum1D *self, hdrl_value scalar_operator)
subtract a scalar from a spectrum
hdrl_spectrum1D * hdrl_spectrum1D_wavelength_mult_scalar_linear_create(const hdrl_spectrum1D *self, hdrl_data_t scale_linear)
computes the elementwise multiplication of the scalar for the wavelength. The scalar is assumed to be...
hdrl_spectrum1D_wave_scale hdrl_spectrum1D_get_scale(const hdrl_spectrum1D *self)
hdrl_spectrum1D getter for scale
hdrl_spectrum1D_wavelength hdrl_spectrum1D_get_wavelength(const hdrl_spectrum1D *self)
hdrl_spectrum1D getter for wavelengths
hdrl_spectrum1D * hdrl_spectrum1D_create_error_free(const cpl_image *arg_flux, const cpl_array *wavelength, hdrl_spectrum1D_wave_scale scale)
hdrl_spectrum1D constructor in the case of error-free spectrum (i.e. the error on the flux is zero fo...
hdrl_spectrum1D * hdrl_spectrum1D_add_scalar_create(const hdrl_spectrum1D *self, hdrl_value scalar_operator)
add a scalar to a spectrum
hdrl_data_t hdrl_spectrum1D_get_wavelength_value(const hdrl_spectrum1D *self, int idx, int *rej)
hdrl_spectrum1D getter for a wavelength value
hdrl_parameter * hdrl_spectrum1D_resample_fit_windowed_parameter_create(const int k, const int nCoeff, const long window, const double factor)
constructor for the hdrl_parameter in the case of interpolation
hdrl_spectrum1D * hdrl_spectrum1D_create_analytic(calculate_analytic_spectrum_point func, const cpl_array *wavelength, hdrl_spectrum1D_wave_scale scale)
hdrl_spectrum1D constructor in the case of a spectrum defined by an analytical function
cpl_error_code hdrl_spectrum1D_append_to_table(const hdrl_spectrum1D *self, cpl_table *dest, const char *flux_col_name, const char *wavelength_col_name, const char *flux_e_col_name, const char *flux_bpm_col_name)
append a spectrum to a table.
hdrl_spectrum1D * hdrl_spectrum1D_wavelength_convert_to_linear_create(const hdrl_spectrum1D *self)
converts the wavelength scale to linear.
cpl_table * hdrl_spectrum1D_convert_to_table(const hdrl_spectrum1D *self, const char *flux_col_name, const char *wavelength_col_name, const char *flux_e_col_name, const char *flux_bpm_col_name)
converts a spectrum in a table.
hdrl_spectrum1D * hdrl_spectrum1D_select_wavelengths(const hdrl_spectrum1D *self, const cpl_bivector *windows, const cpl_boolean is_internal)
the function selects or discards flux values according to whether the value of the corresponding wave...
hdrl_spectrum1D * hdrl_spectrum1D_add_spectrum_create(const hdrl_spectrum1D *f1, const hdrl_spectrum1D *f2)
sum one spectrum to another spectrum
cpl_error_code hdrl_spectrum1D_div_scalar(hdrl_spectrum1D *self, hdrl_value scalar_operator)
computes the elementwise division of a spectrum by a scalar, the self parameter is modified
cpl_image * estimate_noise_DER_SNR(const hdrl_data_t *flux_in, const cpl_binary *msk_in, const cpl_array *wavelengths, const cpl_size length, const cpl_size half_window)
For every pixel in position i in img_arg, the function estimates the noise using the pixels in the wi...
hdrl_parameter * hdrl_spectrum1D_resample_integrate_parameter_create(void)
constructor for the hdrl_parameter in the case of integration
hdrl_spectrum1D * hdrl_spectrum1D_reject_pixels(const hdrl_spectrum1D *self, const cpl_array *bad_samples)
For every i-th element in bad_samples having value CPL_TRUE, the i-th pixel in the 1D spectrum is mar...
hdrl_value hdrl_spectrum1D_get_flux_value(const hdrl_spectrum1D *self, int idx, int *rej)
hdrl_spectrum1D getter for a flux value
void hdrl_sort_on_x(double *x, double *y1, double *y2, const cpl_size sample_len, const cpl_boolean sort_decreasing)
sort in increasing or decreasing order x. Keep aligned with y1 and y2.