CR2RE Pipeline Reference Manual 1.6.2
cr2res_trace-test.c
1/*
2 * This file is part of the CR2RES Pipeline
3 * Copyright (C) 2002,2003 European Southern Observatory
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02111-1307 USA
18 */
19
20#ifdef HAVE_CONFIG_H
21#include <config.h>
22#endif
23
24/*-----------------------------------------------------------------------------
25 Includes
26 -----------------------------------------------------------------------------*/
27
28#include <stdlib.h>
29#include <string.h>
30#include <cpl.h>
31#include <cr2res_dfs.h>
32#include <cr2res_pfits.h>
33#include <cr2res_trace.h>
34#include <cr2res_trace.c>
35#include "cr2res_io.h"
36
37
38
39
40/*-----------------------------------------------------------------------------
41 Functions prototypes
42 -----------------------------------------------------------------------------*/
43
44static void test_cr2res_trace(void);
45static void test_cr2res_trace_clean(void);
46static void test_cr2res_trace_gen_image(void);
47static void test_cr2res_trace_get_order_idx_values(void);
48static void test_cr2res_trace_get_ycen(void);
49static void test_cr2res_trace_get_height(void);
50static void test_cr2res_trace_compute_middle(void);
51static void test_cr2res_trace_compute_height(void);
52static void test_cr2res_trace_get_trace_ypos(void);
53static void test_cr2res_trace_signal_detect(void);
54static void test_cr2res_trace_fit_traces(void);
55static void test_cr2res_trace_fit_trace(void);
56//static void test_cr2res_trace_convert_cluster_to_labels(void);
57static void test_cr2res_trace_convert_labels_to_cluster(void);
58static void test_cr2res_trace_clean_blobs(void);
59static void test_cr2res_trace_extract_edges(void);
60static void test_cr2res_trace_new_slit_fraction(void);
61static void test_cr2res_trace_add_extra_columns(void);
62static void test_cr2res_get_trace_table_index(void);
63static void test_cr2res_get_trace_wave_poly(void);
64
65/*----------------------------------------------------------------------------*/
70/*----------------------------------------------------------------------------*/
71
73#define WLEN_BEGIN(buffer, i) (sprintf(buffer, CR2RES_HEADER_WLEN_BEGIN, i), buffer)
74#define WLEN_END(buffer, i) (sprintf(buffer, CR2RES_HEADER_WLEN_END, i), buffer)
75#define WLEN_CENY(buffer, i) (sprintf(buffer, CR2RES_HEADER_WLEN_CENY, i), buffer)
76
77
78/*----------------------------------------------------------------------------*/
84/*----------------------------------------------------------------------------*/
85static cpl_table *create_test_table()
86{
87 cpl_table *traces;
88 cpl_array *array, *slit_fraction, *wave, *wave_err, *slit_a, *slit_b,
89 *slit_c;
90 int poly_order, norders;
91 cpl_propertylist *hdr = cpl_propertylist_new();
92 cpl_propertylist *main_header = cpl_propertylist_new();
93 char * extname;
94
95 /* Initialise */
96 poly_order = 2;
97 norders = 9;
98
99 /* NULL Input */
100 traces = cpl_table_new(norders);
101 cpl_table_new_column_array(traces, CR2RES_COL_ALL, CPL_TYPE_DOUBLE,
102 poly_order);
103 cpl_table_new_column_array(traces, CR2RES_COL_UPPER, CPL_TYPE_DOUBLE,
104 poly_order);
105 cpl_table_new_column_array(traces, CR2RES_COL_LOWER, CPL_TYPE_DOUBLE,
106 poly_order);
107 cpl_table_new_column(traces, CR2RES_COL_ORDER, CPL_TYPE_INT);
108 cpl_table_new_column(traces, CR2RES_COL_TRACENB, CPL_TYPE_INT);
109
110 cpl_table_new_column_array(traces, CR2RES_COL_WAVELENGTH, CPL_TYPE_DOUBLE,
111 2);
112 cpl_table_new_column_array(traces, CR2RES_COL_WAVELENGTH_ERROR,
113 CPL_TYPE_DOUBLE, 2);
114 cpl_table_new_column_array(traces, CR2RES_COL_SLIT_CURV_A, CPL_TYPE_DOUBLE,
115 3);
116 cpl_table_new_column_array(traces, CR2RES_COL_SLIT_CURV_B, CPL_TYPE_DOUBLE,
117 3);
118 cpl_table_new_column_array(traces, CR2RES_COL_SLIT_CURV_C, CPL_TYPE_DOUBLE,
119 3);
120 cpl_table_new_column_array(traces, CR2RES_COL_SLIT_FRACTION,
121 CPL_TYPE_DOUBLE, 3);
122
123 /*
124 All| Upper| Lower| Order
125 54.3148, 0.00738623| 110.379, 0.0159501|1.63328, -8.95809e-05| 1
126 226.289, 0.0169145| 311.885, 0.0167957| 139.106, 0.017396| 2
127 437.881, 0.0172448| 524.126, 0.0171958| 350.398, 0.0170009| 3
128 660.954, 0.0178211| 747.931, 0.0179547| 572.986, 0.0177137| 4
129 897.266, 0.0185319| 985.06, 0.0186544| 808.823, 0.0185517| 5
130 1148.31, 0.019388| 1237.01, 0.0193813| 1059.39, 0.0194215| 6
131 1415.88, 0.0202877| 1505.34, 0.0202763| 1326.43, 0.0202534| 7
132 1701.85, 0.021292| 1792.03, 0.0213662| 1611.65, 0.0212178| 8
133 1982.59, 0.0111388|2047.88, 8.66878e-05| 1917.3, 0.0221835| 9
134
135 */
136 double all_1[] = {54.3148, 226.289, 437.881, 660.954, 897.266,
137 1148.31, 1415.88, 1701.85, 1982.59};
138 double all_2[] = {0.00738623, 0.0169145, 0.0172448, 0.0178211,
139 0.0185319, 0.019388, 0.0202877, 0.021292, 0.0111388};
140 double upper_1[] = {110.379, 311.885, 524.126, 747.931, 985.06,
141 1237.01, 1505.34, 1792.03, 2047.88};
142 double upper_2[] = {0.0159501, 0.0167957, 0.0171958, 0.0179547,
143 0.0186544, 0.0193813, 0.0202763, 0.0213662, 8.66878e-05};
144 double lower_1[] = {1.63328, 139.106, 350.398, 572.986, 808.823,
145 1059.39, 1326.43, 1611.65, 1917.3};
146 double lower_2[] = {-8.95809e-05, 0.017396, 0.0170009, 0.0177137,
147 0.0185517, 0.0194215, 0.0202534, 0.0212178, 0.0221835};
148 array = cpl_array_new(poly_order, CPL_TYPE_DOUBLE);
149 slit_fraction = cpl_array_new(3, CPL_TYPE_DOUBLE);
150 cpl_array_set_double(slit_fraction, 0, 0);
151 cpl_array_set_double(slit_fraction, 1, 0.5);
152 cpl_array_set_double(slit_fraction, 2, 1);
153 wave = cpl_array_new(2, CPL_TYPE_DOUBLE);
154 cpl_array_set_double(wave, 0, 9.45e2);
155 cpl_array_set_double(wave, 1, 3.13e-3);
156 wave_err = cpl_array_new(2, CPL_TYPE_DOUBLE);
157 cpl_array_set_double(wave_err, 0, 5e-2);
158 cpl_array_set_double(wave_err, 1, 5e-2);
159
160 slit_a = cpl_array_new(3, CPL_TYPE_DOUBLE);
161 cpl_array_set(slit_a, 0, 0);
162 cpl_array_set(slit_a, 1, 1);
163 cpl_array_set(slit_a, 2, 0);
164 slit_b = cpl_array_new(3, CPL_TYPE_DOUBLE);
165 cpl_array_set(slit_b, 0, 0);
166 cpl_array_set(slit_b, 1, 0);
167 cpl_array_set(slit_b, 2, 0);
168 slit_c = cpl_array_new(3, CPL_TYPE_DOUBLE);
169 cpl_array_set(slit_c, 0, 0);
170 cpl_array_set(slit_c, 1, 0);
171 cpl_array_set(slit_c, 2, 0);
172
173 for (int i = 0; i < norders; i++)
174 {
175 cpl_array_set(array, 0, all_1[i]);
176 cpl_array_set(array, 1, all_2[i]);
177 cpl_table_set_array(traces, CR2RES_COL_ALL, i, array);
178 cpl_array_set(array, 0, upper_1[i]);
179 cpl_array_set(array, 1, upper_2[i]);
180 cpl_table_set_array(traces, CR2RES_COL_UPPER, i, array);
181 cpl_array_set(array, 0, lower_1[i]);
182 cpl_array_set(array, 1, lower_2[i]);
183 cpl_table_set_array(traces, CR2RES_COL_LOWER, i, array);
184 cpl_table_set(traces, CR2RES_COL_ORDER, i,
186 cpl_table_set(traces, CR2RES_COL_TRACENB, i, 1);
187
188 cpl_table_set_array(traces, CR2RES_COL_SLIT_FRACTION, i, slit_fraction);
189 cpl_table_set_array(traces, CR2RES_COL_WAVELENGTH, i, wave);
190 cpl_table_set_array(traces, CR2RES_COL_WAVELENGTH_ERROR, i, wave_err);
191 cpl_table_set_array(traces, CR2RES_COL_SLIT_CURV_A, i, slit_a);
192 cpl_table_set_array(traces, CR2RES_COL_SLIT_CURV_B, i, slit_b);
193 cpl_table_set_array(traces, CR2RES_COL_SLIT_CURV_C, i, slit_c);
194 }
195
196 extname = cr2res_io_create_extname(1, 1);
197 cpl_propertylist_append_string(hdr, CR2RES_HEADER_EXTNAME, extname);
198
199 double ceny[] = {1994.0945859223, 1723.67027599362, 1436.61298619847,
200 1168.0222016174, 915.8934665223831, 678.542785839296,
201 454.468576982434, 242.388497032926, 63.5899165277783};
202 double begin[] = {1756.78720770673, 1703.55123171562, 1653.44678372399,
203 1606.20544704616, 1561.58862907265, 1519.38353098961,
204 1479.3997538583, 1441.46642683629, -1};
205 double end[] = {1768.81709603003, 1715.21657796851, 1664.76903155768,
206 1617.2042020846, 1572.2818631378, 1529.78775872867,
207 1489.53018613055, 1451.3371044349, -1};
208
209 char buffer[20];
210
211 for (int i = 0; i < 9; i++)
212 {
213 cpl_propertylist_append_double(hdr, WLEN_CENY(buffer, i), ceny[i]);
214 cpl_propertylist_append_double(hdr, WLEN_BEGIN(buffer, i), begin[i]);
215 cpl_propertylist_append_double(hdr, WLEN_END(buffer, i), end[i]);
216 }
217
218
219 cpl_propertylist_append_int(main_header, CR2RES_HEADER_DECKER_POS, CR2RES_DECKER_2_4);
220
221 cpl_table_save(traces, main_header, hdr, "TEST_table.fits", CPL_IO_CREATE);
222
223 cpl_array_delete(array);
224 cpl_array_delete(slit_fraction);
225 cpl_array_delete(wave);
226 cpl_array_delete(wave_err);
227 cpl_array_delete(slit_a);
228 cpl_array_delete(slit_b);
229 cpl_array_delete(slit_c);
230
231 cpl_propertylist_delete(hdr);
232 cpl_propertylist_delete(main_header);
233 cpl_free(extname);
234 return traces;
235}
236
237/*----------------------------------------------------------------------------*/
243/*----------------------------------------------------------------------------*/
244static cpl_image *create_test_image(void)
245{
246 cpl_table *traces;
247 cpl_image *trace_ima;
248 traces = create_test_table();
249 trace_ima = cr2res_trace_gen_image(traces, 2048, 2048);
250 cpl_image_add_scalar(trace_ima, 1.);
251 cpl_image_multiply_scalar(trace_ima, 10.);
252 cpl_table_delete(traces);
253 cpl_image_save(trace_ima, "TEST_trace.fits", CPL_TYPE_INT, NULL, CPL_IO_CREATE);
254 return trace_ima;
255}
256#ifdef CR2RES_UNUSED_TESTS
257static cpl_table *create_cluster_table(void)
258{
259 // for each pixel in a cluster
260 // XS, YS - coordinates
261 // Cluster - which cluster that pixel belongs to
262 /*int data[] = {2, 2, 0, 0, 0,
263 0, 0, 0, 1, 1,
264 0, 1, 1, 1, 1,
265 1, 1, 1, 1, 1,
266 1, 1, 1, 1, 0};*/
267 // flip data, so the image will be the same
268 /*int data_inverse[] = {1, 1, 1, 1, 0,
269 1, 1, 1, 1, 1,
270 0, 1, 1, 1, 1,
271 0, 0, 0, 1, 1,
272 2, 2, 0, 0, 0};*/
273
274 int xs[] = {4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2};
275 int ys[] = {4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 5, 5};
276 int clusters[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2};
277
278 cpl_table *cluster = cpl_table_new(17);
279 cpl_table_wrap_int(cluster, xs, CR2RES_COL_XS);
280 cpl_table_wrap_int(cluster, ys, CR2RES_COL_YS);
281 cpl_table_wrap_int(cluster, clusters, CR2RES_COL_CLUSTERS);
282 return cluster;
283}
284#endif
285
286/*----------------------------------------------------------------------------*/
298/*----------------------------------------------------------------------------*/
299static void test_cr2res_trace(void)
300{
301 cpl_image *int_ima = create_test_image();
302 cpl_image *trace_ima = cpl_image_cast(int_ima, CPL_TYPE_DOUBLE);
303 cpl_image_delete(int_ima);
304 cpl_table *out;
305 //const cpl_array *all;
306
307 double threshold = 5;
308
309 cpl_test_null(cr2res_trace(NULL, 1.0, 1.0, threshold, 1, 2, 10));
310 cpl_test_null(cr2res_trace(trace_ima, -1.0, 1.0, threshold, 1, 2, 10));
311 cpl_test_null(cr2res_trace(trace_ima, 1.0, 1.0, threshold, -1, 2, 10));
312 cpl_test_null(cr2res_trace(trace_ima, 1.0, 1.0, threshold, 1, 2, -10));
313
314 cpl_test(out = cr2res_trace(trace_ima, 1.0, 5.0, threshold, 1, 2, 10));
315
316 cpl_table_get_array(out, CR2RES_COL_ALL, 0);
317
318 cpl_table_save(out, NULL, NULL, "TEST_table2.fits", CPL_IO_CREATE);
319 cpl_table_delete(out);
320 cpl_image_delete(trace_ima);
321 return;
322}
323
324/*----------------------------------------------------------------------------*/
328/*----------------------------------------------------------------------------*/
329static void test_cr2res_trace_clean(void)
330{
331
332 /* test_cr2res_trace() ; */
333 /* test_cr2res_trace_clean() ; */
334 cpl_binary data[] = {1, 1, 0, 0, 0, 0,
335 1, 1, 0, 0, 0, 1,
336 0, 0, 0, 0, 0, 0,
337 0, 1, 0, 1, 1, 0,
338 0, 0, 0, 0, 0, 0,
339 1, 0, 0, 0, 1, 1};
340 cpl_mask *mask = cpl_mask_wrap(6, 6, data);
341 int opening = 0;
342 int min_cluster = 3;
343 cpl_mask *res;
344 // without opening:
345 cpl_binary data_cmp[] = {1, 1, 0, 0, 0, 0,
346 1, 1, 0, 0, 0, 0,
347 0, 0, 0, 0, 0, 0,
348 0, 0, 0, 0, 0, 0,
349 0, 0, 0, 0, 0, 0,
350 0, 0, 0, 0, 0, 0};
351
352 // with opening
353 // cpl_binary data_cmp[] = {1, 1, 0, 0, 0, 0,
354 // 1, 1, 0, 0, 0, 0,
355 // 0, 0, 0, 0, 0, 0,
356 // 0, 1, 1, 1, 1, 0,
357 // 0, 0, 0, 0, 0, 0,
358 // 0, 0, 0, 0, 0, 0};
359 cpl_mask *cmp = cpl_mask_wrap(6, 6, data_cmp);
360
361 cpl_test_null(cr2res_trace_clean(NULL, opening, min_cluster));
362 cpl_test(res = cr2res_trace_clean(mask, opening, min_cluster));
363 cpl_mask_save(res, "TEST_res.fits", NULL, CPL_IO_CREATE);
364 cpl_test_eq_mask(cmp, res);
365 cpl_mask_unwrap(mask);
366 cpl_mask_unwrap(cmp);
367 cpl_mask_delete(res);
368}
369
373static void test_cr2res_trace_gen_image(void)
374{
375 int nx = 2048;
376 int ny = 2048;
377 cpl_image *res;
378 cpl_image *extract;
379
380 // order is inversed, first row is lowest in FITS
381 int data[10 * 10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
382 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
383 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
384 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
385 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
386 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
387 -1, -1, -1, -1, -1, -1, -1, 1, 1, 1,
388 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
389 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
390 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
391
392 cpl_image *cmp = cpl_image_wrap(10, 10, CPL_TYPE_INT, data);
393 cpl_table *trace = create_test_table();
394
395 //run test
396 // Null tests
397 cpl_test_null(cr2res_trace_gen_image(NULL, nx, ny));
398 cpl_test_null(cr2res_trace_gen_image(trace, 0, ny));
399 cpl_test_null(cr2res_trace_gen_image(trace, nx, 0));
400 // normal run
401 cpl_test(res = cr2res_trace_gen_image(trace, nx, ny));
402 //test output ?
403 // This is more of a regression test than anything, but the image looks good
404 extract = cpl_image_extract(res, 32, 105, 41, 114);
405 cpl_test_image_abs(extract, cmp, DBL_EPSILON);
406
407 //deallocate memory
408 cpl_image_delete(res);
409 cpl_image_delete(extract);
410 cpl_image_unwrap(cmp);
411 cpl_table_delete(trace);
412}
413
414/*----------------------------------------------------------------------------*/
418/*----------------------------------------------------------------------------*/
419static void test_cr2res_trace_get_order_idx_values(void)
420{
421 //define input
422 cpl_table *trace = create_test_table();
423 int nb_orders;
424 int *res;
425 /* test_cr2res_trace_compute_height() ; */
426 cpl_test_null(cr2res_trace_get_order_idx_values(NULL, &nb_orders));
427 cpl_test_null(cr2res_trace_get_order_idx_values(trace, NULL));
428 cpl_test(res = cr2res_trace_get_order_idx_values(trace, &nb_orders));
429 //test output
430 cpl_test_eq(nb_orders, 9);
431 for (int i = 0; i < 9; i++)
432 {
433 cpl_test_eq(res[i], i + 1);
434 }
435 //deallocate memory
436 cpl_table_delete(trace);
437 cpl_free(res);
438}
439
440/*----------------------------------------------------------------------------*/
444/*----------------------------------------------------------------------------*/
445static void test_cr2res_trace_get_ycen(void)
446{
447 //define input
448 cpl_table *trace = create_test_table();
449 cpl_size order_nb = 3;
450 cpl_size trace_nb = 1;
451 int size = CR2RES_DETECTOR_SIZE;
452 cpl_vector *cmp;
453 cpl_vector *res;
454 //run test
455 cpl_test_null(cr2res_trace_get_ycen(NULL, order_nb, trace_nb, size));
456 cpl_test_null(cr2res_trace_get_ycen(trace, 100, trace_nb, size));
457 cpl_test_null(cr2res_trace_get_ycen(trace, order_nb, 5, size));
458 cpl_test_null(cr2res_trace_get_ycen(trace, order_nb, trace_nb, -1));
459
460 // assemble comparison vector
461 double data[size];
462 for (int i = 0; i < size; i++)
463 {
464 // values from test table
465 data[i] = 437.881 + (i + 1) * 0.0172448;
466 }
467 cmp = cpl_vector_wrap(size, data);
468
469 // Run that should not fail, compare output
470 cpl_test(res = cr2res_trace_get_ycen(trace, order_nb, trace_nb, size));
471 cpl_test_vector_abs(cmp, res, size * DBL_EPSILON);
472
473 //deallocate memory
474 cpl_vector_delete(res);
475 cpl_vector_unwrap(cmp);
476
477 cpl_table_delete(trace);
478}
479
480/*----------------------------------------------------------------------------*/
484/*----------------------------------------------------------------------------*/
485static void test_cr2res_trace_get_height(void)
486{
487 //define input
488 cpl_table *trace = create_test_table();
489 cpl_size order_nb = 3;
490 cpl_size trace_nb = 1;
491 int res;
492
493 //run test
494 cpl_test_eq(cr2res_trace_get_height(NULL, order_nb, trace_nb), -1);
495 cpl_test_eq(cr2res_trace_get_height(trace, 20, trace_nb), -1);
496 cpl_test_eq(cr2res_trace_get_height(trace, order_nb, 5), -1);
497
498 cpl_test(res = cr2res_trace_get_height(trace, order_nb, trace_nb));
499 //test output
500 cpl_test_eq(res, (int) 174.1271552); // value analytically from test table
501
502 //deallocate memory
503 cpl_table_delete(trace);
504}
505
506/*----------------------------------------------------------------------------*/
510/*----------------------------------------------------------------------------*/
511static void test_cr2res_trace_compute_middle(void)
512{
513 //define input
514 cpl_polynomial *trace1 = cpl_polynomial_new(1);
515 cpl_polynomial *trace2 = cpl_polynomial_new(1);
516
517 cpl_size power = 0;
518 cpl_polynomial_set_coeff(trace1, &power, 10.);
519 cpl_polynomial_set_coeff(trace2, &power, 20.);
520
521 power = 1;
522 cpl_polynomial_set_coeff(trace1, &power, 1.);
523 cpl_polynomial_set_coeff(trace2, &power, 3.);
524
525 int vector_size = 10;
526 cpl_vector *res;
527 double data[] = {17., 19., 21., 23., 25., 27., 29., 31., 33., 35.};
528 cpl_vector *cmp = cpl_vector_wrap(10, data);
529
530 // run test
531 cpl_test_null(cr2res_trace_compute_middle(NULL, trace2, vector_size));
532 cpl_test_null(cr2res_trace_compute_middle(trace1, NULL, vector_size));
533 cpl_test_null(cr2res_trace_compute_middle(trace1, trace2, -1));
534
535 cpl_test(res = cr2res_trace_compute_middle(trace1, trace2, vector_size));
536 //test output
537 cpl_test_vector_abs(res, cmp, DBL_EPSILON);
538
539 //deallocate memory
540 cpl_vector_unwrap(cmp);
541 cpl_vector_delete(res);
542 cpl_polynomial_delete(trace1);
543 cpl_polynomial_delete(trace2);
544}
545
546/*----------------------------------------------------------------------------*/
550/*----------------------------------------------------------------------------*/
551static void test_cr2res_trace_compute_height(void)
552{
553 //define input
554 cpl_polynomial *trace1 = cpl_polynomial_new(1);
555 cpl_polynomial *trace2 = cpl_polynomial_new(1);
556
557 cpl_size power = 0;
558 cpl_polynomial_set_coeff(trace1, &power, 10.);
559 cpl_polynomial_set_coeff(trace2, &power, 20.);
560
561 power = 1;
562 cpl_polynomial_set_coeff(trace1, &power, 1.);
563 cpl_polynomial_set_coeff(trace2, &power, 3.);
564
565 int vector_size = 10;
566 int res;
567 int cmp = 21; // 10 + 10.2222
568
569 //run test
570 cpl_test_eq(-1, cr2res_trace_compute_height(NULL, trace2, vector_size));
571 cpl_test_eq(-1, cr2res_trace_compute_height(trace1, NULL, vector_size));
572 cpl_test_eq(-1, cr2res_trace_compute_height(trace1, trace2, 0));
573
574 cpl_test(res = cr2res_trace_compute_height(trace1, trace2, vector_size));
575 //test output
576 cpl_test_eq(res, cmp);
577
578 //deallocate memory
579 cpl_polynomial_delete(trace1);
580 cpl_polynomial_delete(trace2);
581}
582
583/*----------------------------------------------------------------------------*/
587/*----------------------------------------------------------------------------*/
588static void test_cr2res_trace_get_trace_ypos(void)
589{
590 //define input
591 cpl_table *traces = create_test_table();
592 int idx = 1;
593 double res;
594
595 //run test
596 cpl_test_abs(-1.0, cr2res_trace_get_trace_ypos(NULL, idx), DBL_EPSILON);
597 cpl_test_abs(-1.0, cr2res_trace_get_trace_ypos(NULL, -10), DBL_EPSILON);
598 cpl_test_abs(-1.0, cr2res_trace_get_trace_ypos(NULL, 100), DBL_EPSILON);
599
600 cpl_test(res = cr2res_trace_get_trace_ypos(traces, idx));
601 //test output
602 // 226.289 + 1024 * 0.0169145
603 cpl_test_abs(res, 243.609448, DBL_EPSILON);
604 //deallocate memory
605 cpl_table_delete(traces);
606}
607
608/*----------------------------------------------------------------------------*/
616/*----------------------------------------------------------------------------*/
617static void test_cr2res_trace_add_extra_columns(void)
618{
619 // define input
620 cpl_table *traces = create_test_table();
621 // remove columns to fill
622 cpl_table_erase_column(traces, CR2RES_COL_ORDER);
623 cpl_table_erase_column(traces, CR2RES_COL_TRACENB);
624 cpl_table_erase_column(traces, CR2RES_COL_WAVELENGTH);
625 cpl_table_erase_column(traces, CR2RES_COL_WAVELENGTH_ERROR);
626 cpl_table_erase_column(traces, CR2RES_COL_SLIT_FRACTION);
627 cpl_table_erase_column(traces, CR2RES_COL_SLIT_CURV_A);
628 cpl_table_erase_column(traces, CR2RES_COL_SLIT_CURV_B);
629 cpl_table_erase_column(traces, CR2RES_COL_SLIT_CURV_C);
630
631 cpl_table *tmp = cpl_table_duplicate(traces);
632 char *file_for_wl = "TEST_table.fits";
633 int det_nr = 1;
634 double cmp1[] = {-1, 1441.46160481499, 1479.3948049417, 1519.37844831851, 1561.58340521624, 1606.20007393671, 1653.44125258191, 1703.54553296318, 1756.78133086827};
635 double cmp2[] = {0, 0.00482202129878357, 0.00494891659611621, 0.00508267109871028, 0.00522385640701021, 0.00537310944721049, 0.00553114207801171, 0.00569875244401075, 0.00587683845788956};
636
637 //run test
638 cpl_test_eq(-1, cr2res_trace_add_extra_columns(NULL, file_for_wl, det_nr));
639
640 cpl_test_eq(-1, cr2res_trace_add_extra_columns(tmp, "invalid_path", det_nr));
641 cpl_table_delete(tmp);
642 tmp = cpl_table_duplicate(traces);
643
644 cpl_test_eq(-1, cr2res_trace_add_extra_columns(tmp, file_for_wl, 10));
645 cpl_table_delete(tmp);
646 tmp = cpl_table_duplicate(traces);
647
648 cpl_test_eq(-1, cr2res_trace_add_extra_columns(tmp, file_for_wl, -1));
649 cpl_table_delete(tmp);
650 tmp = cpl_table_duplicate(traces);
651
652 cpl_test_eq(0, cr2res_trace_add_extra_columns(tmp, file_for_wl, det_nr));
653 //test output
654 cpl_table_save(tmp, NULL, NULL, "TEST_new_table.fits", CPL_IO_CREATE);
655
656 // Check that all columns are there
657 cpl_test(cpl_table_has_column(tmp, CR2RES_COL_ORDER));
658 cpl_test(cpl_table_has_column(tmp, CR2RES_COL_TRACENB));
659 cpl_test(cpl_table_has_column(tmp, CR2RES_COL_WAVELENGTH));
660 cpl_test(cpl_table_has_column(tmp, CR2RES_COL_WAVELENGTH_ERROR));
661 cpl_test(cpl_table_has_column(tmp, CR2RES_COL_SLIT_FRACTION));
662 cpl_test(cpl_table_has_column(tmp, CR2RES_COL_SLIT_CURV_A));
663 cpl_test(cpl_table_has_column(tmp, CR2RES_COL_SLIT_CURV_B));
664 cpl_test(cpl_table_has_column(tmp, CR2RES_COL_SLIT_CURV_C));
665
666 // Check wavelength
667 for (int i = 0; i < 9; i++)
668 {
669 const cpl_array *wl;
670 wl = cpl_table_get_array(tmp, CR2RES_COL_WAVELENGTH, i);
671 cpl_test_abs(cpl_array_get(wl, 0, 0), cmp1[i], FLT_EPSILON);
672 cpl_test_abs(cpl_array_get(wl, 1, 0), cmp2[i], FLT_EPSILON);
673 }
674
675 // TODO check that original data is the same (tmp == traces)
676 // TODO check other new columns
677
678 //deallocate memory
679 cpl_table_delete(traces);
680 cpl_table_delete(tmp);
681}
682
683/*----------------------------------------------------------------------------*/
687/*----------------------------------------------------------------------------*/
688static void test_cr2res_trace_new_slit_fraction(void)
689{
690 //define input
691 cpl_table *trace_table = create_test_table();
692 int norder = cpl_table_get_nrow(trace_table); // as defined in create test_table
693 cpl_array * new_slit_fraction;
694 cpl_table *res;
695 cpl_array *array;
696 const cpl_array *carray;
697
698 // test for NULL input
699 cpl_test_null(cr2res_trace_new_slit_fraction(trace_table, NULL));
700
701 // test with too small new slit fraction, should get NULL
702 new_slit_fraction = cpl_array_new(1, CPL_TYPE_DOUBLE);
703 cpl_test_null(cr2res_trace_new_slit_fraction(NULL, new_slit_fraction));
704 cpl_test_null(cr2res_trace_new_slit_fraction(trace_table, new_slit_fraction));
705 cpl_array_delete(new_slit_fraction);
706
707
708 // test with new slit fraction == old slit fractions
709 new_slit_fraction = cpl_array_new(3, CPL_TYPE_DOUBLE);
710 cpl_array_set_double(new_slit_fraction, 0, 0);
711 cpl_array_set_double(new_slit_fraction, 1, 0.5);
712 cpl_array_set_double(new_slit_fraction, 2, 1);
713
714 cpl_test(res = cr2res_trace_new_slit_fraction(trace_table, new_slit_fraction));
715 cpl_test_eq(cpl_table_get_nrow(res), norder);
716 for(cpl_size i = 0; i < norder; i++)
717 {
718 cpl_test_array_abs(cpl_table_get_array(res, CR2RES_COL_SLIT_FRACTION, i),
719 cpl_table_get_array(trace_table, CR2RES_COL_SLIT_FRACTION, i), FLT_EPSILON);
720
721 cpl_test_array_abs(cpl_table_get_array(res, CR2RES_COL_UPPER, i),
722 cpl_table_get_array(trace_table, CR2RES_COL_UPPER, i), FLT_EPSILON);
723
724 cpl_test_array_abs(cpl_table_get_array(res, CR2RES_COL_ALL, i),
725 cpl_table_get_array(trace_table, CR2RES_COL_ALL, i), FLT_EPSILON);
726
727 cpl_test_array_abs(cpl_table_get_array(res, CR2RES_COL_LOWER, i),
728 cpl_table_get_array(trace_table, CR2RES_COL_LOWER, i), FLT_EPSILON);
729
730 cpl_test_array_abs(cpl_table_get_array(res, CR2RES_COL_WAVELENGTH, i),
731 cpl_table_get_array(trace_table, CR2RES_COL_WAVELENGTH, i), FLT_EPSILON);
732
733 cpl_test_array_abs(cpl_table_get_array(res, CR2RES_COL_SLIT_CURV_A, i),
734 cpl_table_get_array(trace_table, CR2RES_COL_SLIT_CURV_A, i), FLT_EPSILON);
735
736 cpl_test_array_abs(cpl_table_get_array(res, CR2RES_COL_SLIT_CURV_B, i),
737 cpl_table_get_array(trace_table, CR2RES_COL_SLIT_CURV_B, i), FLT_EPSILON);
738
739
740 cpl_test_array_abs(cpl_table_get_array(res, CR2RES_COL_SLIT_CURV_C, i),
741 cpl_table_get_array(trace_table, CR2RES_COL_SLIT_CURV_C, i), FLT_EPSILON);
742 }
743 cpl_array_delete(new_slit_fraction);
744
745
746 // test with slit fractions other than old ones
747 new_slit_fraction = cpl_array_new(3, CPL_TYPE_DOUBLE);
748 cpl_array_set_double(new_slit_fraction, 0, 0.2);
749 cpl_array_set_double(new_slit_fraction, 1, 0.4);
750 cpl_array_set_double(new_slit_fraction, 2, 0.6);
751
752 // Set the first order of the table to some easy to estimate values, 1, 2, 3
753 array = cpl_array_new(2, CPL_TYPE_DOUBLE);
754 cpl_array_set_double(array, 0, 3);
755 cpl_table_set_array(trace_table, CR2RES_COL_UPPER, 0, array);
756 cpl_array_set_double(array, 0, 2);
757 cpl_table_set_array(trace_table, CR2RES_COL_ALL, 0, array);
758 cpl_array_set_double(array, 0, 1);
759 cpl_table_set_array(trace_table, CR2RES_COL_LOWER, 0, array);
760 cpl_array_delete(array);
761
762 cpl_table_delete(res);
763 cpl_test(res = cr2res_trace_new_slit_fraction(trace_table, new_slit_fraction));
764
765 carray = cpl_table_get_array(res, CR2RES_COL_UPPER, 0);
766 cpl_test_abs(cpl_array_get_double(carray, 0, NULL), 2.2, FLT_EPSILON);
767 cpl_test_abs(cpl_array_get_double(carray, 1, NULL), 0, FLT_EPSILON);
768 carray = cpl_table_get_array(res, CR2RES_COL_ALL, 0);
769 cpl_test_abs(cpl_array_get_double(carray, 0, NULL), 1.8, FLT_EPSILON);
770 cpl_test_abs(cpl_array_get_double(carray, 1, NULL), 0, FLT_EPSILON);
771 carray = cpl_table_get_array(res, CR2RES_COL_LOWER, 0);
772 cpl_test_abs(cpl_array_get_double(carray, 0, NULL), 1.4, FLT_EPSILON);
773 cpl_test_abs(cpl_array_get_double(carray, 1, NULL), 0, FLT_EPSILON);
774
775 // deallocate memory
776 cpl_table_delete(res);
777 cpl_table_delete(trace_table);
778 cpl_array_delete(new_slit_fraction);
779}
780
781
782
783/*----------------------------------------------------------------------------*/
787/*----------------------------------------------------------------------------*/
788static void test_cr2res_trace_signal_detect(void)
789{
790 //define input
791 cpl_image *int_image = create_test_image();
792 cpl_image *image = cpl_image_cast(int_image, CPL_TYPE_DOUBLE);
793 cpl_image_delete(int_image);
794 int trace_sep = 150;
795 double smoothfactor = 1;
796 double thresh = 0.5;
797 cpl_mask *sub;
798
799 cpl_binary data2[10 * 10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
800 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
801 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
802 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
803 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
804 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
805 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
806 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
807 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
808 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
809
810 cpl_mask *cmp = cpl_mask_wrap(10, 10, data2);
811
812 cpl_mask *res;
813
814 //run test
815 cpl_test_null(cr2res_trace_signal_detect(NULL, trace_sep, smoothfactor, thresh));
816 cpl_test_null(cr2res_trace_signal_detect(image, -10, smoothfactor, thresh));
817 cpl_test_null(cr2res_trace_signal_detect(image, trace_sep, -1, thresh));
818 //cpl_test_null(cr2res_trace_signal_detect(image, trace_sep, smoothfactor, 50000));
819
820 cpl_test(res = cr2res_trace_signal_detect(image, trace_sep, smoothfactor, thresh));
821 //test output
822 sub = cpl_mask_extract(res, 32, 105, 41, 114);
823
824
825/* TODO : Why is this failing ? */
826 /* cpl_test_eq_mask(sub, cmp); */
827
828 //deallocate memory
829 cpl_image_delete(image);
830 cpl_mask_delete(res);
831 cpl_mask_unwrap(cmp);
832 cpl_mask_delete(sub);
833}
834
835/*----------------------------------------------------------------------------*/
839/*----------------------------------------------------------------------------*/
840static void test_cr2res_trace_fit_traces(void)
841{
842 //define input
843 int xs[] = {4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2};
844 int ys[] = {4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 5, 5};
845 int clusters[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2};
846
847 cpl_table *cluster = cpl_table_new(17);
848 cpl_table_wrap_int(cluster, xs, CR2RES_COL_XS);
849 cpl_table_wrap_int(cluster, ys, CR2RES_COL_YS);
850 cpl_table_wrap_int(cluster, clusters, CR2RES_COL_CLUSTERS);
851
852 int degree = 1;
853 cpl_table *res;
854 const cpl_array *arr;
855
856 //run test
857 cpl_test_null(cr2res_trace_fit_traces(NULL, degree));
858 cpl_test_null(cr2res_trace_fit_traces(cluster, -5));
859
860 cpl_test(res = cr2res_trace_fit_traces(cluster, degree));
861 //test output
862 // use tolerance * 10, because reading the data in the array is not that precise ?
863
864 arr = cpl_table_get_array(res, CR2RES_COL_UPPER, 0);
865 cpl_test_abs(1.7, cpl_array_get(arr, 0, NULL), DBL_EPSILON * 10);
866 cpl_test_abs(0.5, cpl_array_get(arr, 1, NULL), DBL_EPSILON * 10);
867 arr = cpl_table_get_array(res, CR2RES_COL_UPPER, 1);
868 cpl_test_abs(5, cpl_array_get(arr, 0, NULL), DBL_EPSILON * 10);
869 cpl_test_abs(0, cpl_array_get(arr, 1, NULL), DBL_EPSILON * 10);
870
871 arr = cpl_table_get_array(res, CR2RES_COL_LOWER, 0);
872 cpl_test_abs(0.6, cpl_array_get(arr, 0, NULL), DBL_EPSILON * 10);
873 cpl_test_abs(0.2, cpl_array_get(arr, 1, NULL), DBL_EPSILON * 10);
874 arr = cpl_table_get_array(res, CR2RES_COL_LOWER, 1);
875 cpl_test_abs(5, cpl_array_get(arr, 0, NULL), DBL_EPSILON * 10);
876 cpl_test_abs(0, cpl_array_get(arr, 1, NULL), DBL_EPSILON * 10);
877
878 arr = cpl_table_get_array(res, CR2RES_COL_ALL, 0);
879 cpl_test_abs(1.15151515151515, cpl_array_get(arr, 0, NULL), DBL_EPSILON * 10);
880 cpl_test_abs(0.348484848484849, cpl_array_get(arr, 1, NULL), DBL_EPSILON * 10);
881 arr = cpl_table_get_array(res, CR2RES_COL_ALL, 1);
882 cpl_test_abs(5, cpl_array_get(arr, 0, NULL), DBL_EPSILON * 10);
883 cpl_test_abs(0, cpl_array_get(arr, 1, NULL), DBL_EPSILON * 10);
884
885 //deallocate memory
886 cpl_table_unwrap(cluster, CR2RES_COL_XS);
887 cpl_table_unwrap(cluster, CR2RES_COL_YS);
888 cpl_table_unwrap(cluster, CR2RES_COL_CLUSTERS);
889 cpl_table_delete(cluster);
890 cpl_table_delete(res);
891}
892
893/*----------------------------------------------------------------------------*/
897/*----------------------------------------------------------------------------*/
898static void test_cr2res_trace_fit_trace(void)
899{
900 //define input
901 // use only cluster 3 from test image
902 cpl_image *test_image = create_test_image();
903 cpl_table *all = cr2res_trace_convert_labels_to_cluster(test_image);
904 cpl_table_and_selected_int(all, CR2RES_COL_CLUSTERS, CPL_EQUAL_TO, 30);
905 cpl_table *table = cpl_table_extract_selected(all);
906
907 int degree = 2;
908 cpl_array *res;
909
910 //run test
911 cpl_test_null(cr2res_trace_fit_trace(NULL, degree));
912 cpl_test_null(cr2res_trace_fit_trace(table, -10));
913
914 cpl_test(res = cr2res_trace_fit_trace(table, degree));
915 //test output
916 cpl_array_dump(res, 0, 2, NULL);
917 // input was 437.881, 0.0172448
918 cpl_test_abs(cpl_array_get(res, 0, NULL), 225.007, 1.2);
919 cpl_test_abs(cpl_array_get(res, 1, NULL), 0.0172448, 0.0002);
920
921 //deallocate memory
922 cpl_image_delete(test_image);
923 cpl_table_delete(all);
924 cpl_table_delete(table);
925 cpl_array_delete(res);
926}
927
928/*----------------------------------------------------------------------------*/
932/*----------------------------------------------------------------------------*/
933// static void test_cr2res_trace_convert_cluster_to_labels(void)
934// {
935// //define input
936// //cpl_table *cluster = create_cluster_table();
937
938// int xs[] = {4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2};
939// int ys[] = {4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 5, 5};
940// int clusters[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2};
941
942// cpl_table *cluster = cpl_table_new(17);
943// cpl_table_wrap_int(cluster, xs, CR2RES_COL_XS);
944// cpl_table_wrap_int(cluster, ys, CR2RES_COL_YS);
945// cpl_table_wrap_int(cluster, clusters, CR2RES_COL_CLUSTERS);
946
947// // flip data, so the image will be the same
948// int data_inverse[] = {1, 1, 1, 1, 0,
949// 1, 1, 1, 1, 1,
950// 0, 1, 1, 1, 1,
951// 0, 0, 0, 1, 1,
952// 2, 2, 0, 0, 0};
953
954// int nx = 5;
955// int ny = 5;
956// cpl_image *res;
957// cpl_image *cmp = cpl_image_wrap(nx, ny, CPL_TYPE_INT, data_inverse);
958
959// //run test
960// cpl_test_null(cr2res_trace_convert_cluster_to_labels(NULL, nx, ny));
961// cpl_test_null(cr2res_trace_convert_cluster_to_labels(cluster, 0, ny));
962// cpl_test_null(cr2res_trace_convert_cluster_to_labels(cluster, nx, 0));
963
964// cpl_test(res = cr2res_trace_convert_cluster_to_labels(cluster, nx, ny));
965// //test output
966// //cpl_image_save(res, "TEST_labels.fits", CPL_TYPE_INT, NULL, CPL_IO_CREATE);
967// cpl_test_image_abs(res, cmp, 0);
968
969// //deallocate memory
970// cpl_table_unwrap(cluster, CR2RES_COL_XS);
971// cpl_table_unwrap(cluster, CR2RES_COL_YS);
972// cpl_table_unwrap(cluster, CR2RES_COL_CLUSTERS);
973// cpl_table_delete(cluster);
974// cpl_image_delete(res);
975// cpl_image_unwrap(cmp);
976// }
977
978/*----------------------------------------------------------------------------*/
982/*----------------------------------------------------------------------------*/
983static void test_cr2res_trace_convert_labels_to_cluster(void)
984{
985 //define input
986 int data_inverse[] = {1, 1, 1, 1, 0,
987 1, 1, 1, 1, 1,
988 0, 1, 1, 1, 1,
989 0, 0, 0, 1, 1,
990 2, 2, 0, 0, 0};
991 cpl_image *labels = cpl_image_wrap(5, 5, CPL_TYPE_INT, data_inverse);
992 cpl_table *res;
993
994 int xs[] = {1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3, 4, 5, 4, 5, 1, 2};
995 int ys[] = {1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5};
996 int clusters[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2};
997
998 //run test
999 cpl_test_null(cr2res_trace_convert_labels_to_cluster(NULL));
1000 cpl_test(res = cr2res_trace_convert_labels_to_cluster(labels));
1001 //test output
1002 // cpl_table_save(res, NULL, NULL, "TEST_convert.fits", CPL_IO_CREATE);
1003
1004 for (int i = 0; i < 17; i++)
1005 {
1006 cpl_test_eq(xs[i], cpl_table_get(res, CR2RES_COL_XS, i, NULL));
1007 cpl_test_eq(ys[i], cpl_table_get(res, CR2RES_COL_YS, i, NULL));
1008 cpl_test_eq(clusters[i], cpl_table_get(res, CR2RES_COL_CLUSTERS, i, NULL));
1009 }
1010
1011 //deallocate memory
1012 cpl_image_unwrap(labels);
1013 cpl_table_delete(res);
1014}
1015
1016/*----------------------------------------------------------------------------*/
1021/*----------------------------------------------------------------------------*/
1022static void test_cr2res_trace_clean_blobs(void)
1023{
1024 //define input
1025 cpl_binary data[] = {1, 1, 0, 0,
1026 1, 1, 0, 0,
1027 0, 0, 1, 0,
1028 0, 0, 1, 0};
1029 cpl_mask *mask = cpl_mask_wrap(4, 4, data);
1030 int min_cluster = 3;
1031 cpl_binary data2[] = {1, 1, 0, 0,
1032 1, 1, 0, 0,
1033 0, 0, 0, 0,
1034 0, 0, 0, 0};
1035 cpl_mask *cmp = cpl_mask_wrap(4, 4, data2);
1036 cpl_mask *res;
1037
1038 //run test
1039 cpl_test_null(cr2res_trace_clean_blobs(NULL, min_cluster));
1040 cpl_test_null(cr2res_trace_clean_blobs(mask, -1));
1041
1042 // if min_cluster <= 0 nothing changes
1043 cpl_test(res = cr2res_trace_clean_blobs(mask, 0));
1044 cpl_test_eq_mask(res, mask);
1045 cpl_mask_delete(res);
1046
1047 cpl_test(res = cr2res_trace_clean_blobs(mask, min_cluster));
1048 //test output
1049 //small blob of size 2 removed
1050 cpl_test_eq_mask(res, cmp);
1051
1052 //deallocate memory
1053 cpl_mask_unwrap(mask);
1054 cpl_mask_unwrap(cmp);
1055 cpl_mask_delete(res);
1056}
1057
1058/*----------------------------------------------------------------------------*/
1062/*----------------------------------------------------------------------------*/
1063static void test_cr2res_trace_extract_edges(void)
1064{
1065 //define input
1066 int xs[] = {4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4};
1067 int ys[] = {4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1};
1068 int clusters[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
1069
1070 cpl_table *pixels_table = cpl_table_new(15);
1071 cpl_table_wrap_int(pixels_table, xs, CR2RES_COL_XS);
1072 cpl_table_wrap_int(pixels_table, ys, CR2RES_COL_YS);
1073 cpl_table_wrap_int(pixels_table, clusters, CR2RES_COL_CLUSTERS);
1074
1075 cpl_table *edge_lower_table;
1076 cpl_table *edge_upper_table;
1077
1078 int cmp_xs_lower[] = {5, 1, 2, 3, 4};
1079 int cmp_ys_lower[] = {2, 1, 1, 1, 1};
1080 int cmp_cluster_lower[] = {1, 1, 1, 1, 1};
1081
1082 int cmp_xs_upper[] = {4, 5, 2, 3, 1};
1083 int cmp_ys_upper[] = {4, 4, 3, 3, 2};
1084 int cmp_cluster_upper[] = {1, 1, 1, 1, 1};
1085
1086 //run test
1087 cpl_test_eq(-1, cr2res_trace_extract_edges(NULL, &edge_lower_table, &edge_upper_table));
1088 cpl_test_eq(-1, cr2res_trace_extract_edges(pixels_table, NULL, &edge_upper_table));
1089 cpl_test_eq(-1, cr2res_trace_extract_edges(pixels_table, &edge_lower_table, NULL));
1090
1091 cpl_test_eq(0, cr2res_trace_extract_edges(pixels_table, &edge_lower_table, &edge_upper_table));
1092 //test output
1093 for (int i = 0; i < 5; i++)
1094 {
1095 cpl_test_eq(cpl_table_get(edge_lower_table, CR2RES_COL_XS, i, NULL), cmp_xs_lower[i]);
1096 cpl_test_eq(cpl_table_get(edge_lower_table, CR2RES_COL_YS, i, NULL), cmp_ys_lower[i]);
1097 cpl_test_eq(cpl_table_get(edge_lower_table, CR2RES_COL_CLUSTERS, i, NULL), cmp_cluster_lower[i]);
1098 cpl_test_eq(cpl_table_get(edge_upper_table, CR2RES_COL_XS, i, NULL), cmp_xs_upper[i]);
1099 cpl_test_eq(cpl_table_get(edge_upper_table, CR2RES_COL_YS, i, NULL), cmp_ys_upper[i]);
1100 cpl_test_eq(cpl_table_get(edge_upper_table, CR2RES_COL_CLUSTERS, i, NULL), cmp_cluster_upper[i]);
1101 }
1102
1103 //deallocate memory
1104 cpl_table_unwrap(pixels_table, CR2RES_COL_XS);
1105 cpl_table_unwrap(pixels_table, CR2RES_COL_YS);
1106 cpl_table_unwrap(pixels_table, CR2RES_COL_CLUSTERS);
1107 cpl_table_delete(pixels_table);
1108
1109 cpl_table_delete(edge_lower_table);
1110 cpl_table_delete(edge_upper_table);
1111}
1112
1113/*----------------------------------------------------------------------------*/
1117/*----------------------------------------------------------------------------*/
1118static void test_cr2res_get_trace_table_index(void)
1119{
1120 //define input
1121 int n = 10;
1122 int data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
1123 int data2[] = {1, 1, 1, 1, 1, 1, 2, 1, 1, 1};
1124 cpl_table *trace_wave = cpl_table_new(n);
1125 cpl_table_wrap_int(trace_wave, data, CR2RES_COL_ORDER); //what table do we need ?
1126 cpl_table_wrap_int(trace_wave, data2, CR2RES_COL_TRACENB);
1127
1128 int order = 5;
1129 int trace_nb = 1;
1130 cpl_size res;
1131
1132 //run test
1133 cpl_test_eq(-1, cr2res_get_trace_table_index(NULL, order, trace_nb));
1134 cpl_test_eq(-1, cr2res_get_trace_table_index(trace_wave, -1, trace_nb));
1135 cpl_test_eq(-1, cr2res_get_trace_table_index(trace_wave, order, -50));
1136
1137 cpl_test(res = cr2res_get_trace_table_index(trace_wave, order, trace_nb));
1138 //test output
1139 cpl_test_eq(res, 4);
1140
1141 order = 7;
1142 // trace would be 2, but we just look for 1
1143 //run test
1144 cpl_test(res = cr2res_get_trace_table_index(trace_wave, order, trace_nb));
1145 //test output
1146 cpl_test_eq(res, -1);
1147
1148 order = -10;
1149 // order does not exist
1150 //run test
1151 cpl_test(res = cr2res_get_trace_table_index(trace_wave, order, trace_nb));
1152 //test output
1153 cpl_test_eq(res, -1);
1154
1155 //deallocate memory
1156 cpl_table_unwrap(trace_wave, CR2RES_COL_ORDER);
1157 cpl_table_unwrap(trace_wave, CR2RES_COL_TRACENB);
1158 cpl_table_delete(trace_wave);
1159}
1160
1161/*----------------------------------------------------------------------------*/
1165/*----------------------------------------------------------------------------*/
1166static void test_cr2res_get_trace_wave_poly(void)
1167{
1168 cpl_table *trace_wave = cpl_table_new(1);
1169 cpl_table_new_column_array(trace_wave, CR2RES_COL_WAVELENGTH, CPL_TYPE_DOUBLE, 3);
1170 cpl_table_new_column(trace_wave, CR2RES_COL_ORDER, CPL_TYPE_INT);
1171 cpl_table_new_column(trace_wave, CR2RES_COL_TRACENB, CPL_TYPE_INT);
1172 cpl_table_set(trace_wave, CR2RES_COL_ORDER, 0, 1);
1173 cpl_table_set(trace_wave, CR2RES_COL_TRACENB, 0, 1);
1174 double pdata[] = {1.1, 2.2, 3.3};
1175 cpl_array *parr = cpl_array_wrap_double(pdata, 3);
1176 cpl_table_set_array(trace_wave, CR2RES_COL_WAVELENGTH, 0, parr);
1177
1178 //run test
1179 cpl_polynomial *res_poly;
1180 cpl_test_null(cr2res_get_trace_wave_poly(NULL, CR2RES_COL_WAVELENGTH, 1, 1));
1181 cpl_test_null(cr2res_get_trace_wave_poly(trace_wave, "blub", 1, 1));
1182 cpl_test_null(cr2res_get_trace_wave_poly(trace_wave, CR2RES_COL_WAVELENGTH, 20, 1));
1183 cpl_test_null(cr2res_get_trace_wave_poly(trace_wave, CR2RES_COL_WAVELENGTH, 1, -90));
1184
1185 cpl_test(res_poly = cr2res_get_trace_wave_poly(trace_wave, CR2RES_COL_WAVELENGTH, 1, 1));
1186 //test output
1187 cpl_size power = 0;
1188 cpl_test_abs(1.1, cpl_polynomial_get_coeff(res_poly, &power), DBL_EPSILON);
1189 power = 1;
1190 cpl_test_abs(2.2, cpl_polynomial_get_coeff(res_poly, &power), DBL_EPSILON);
1191 power = 2;
1192 cpl_test_abs(3.3, cpl_polynomial_get_coeff(res_poly, &power), DBL_EPSILON);
1193
1194 cpl_array_unwrap(parr);
1195 cpl_table_delete(trace_wave);
1196 cpl_polynomial_delete(res_poly);
1197}
1198
1199/*----------------------------------------------------------------------------*/
1203/*----------------------------------------------------------------------------*/
1204int main(void)
1205{
1206 cpl_test_init(PACKAGE_BUGREPORT, CPL_MSG_DEBUG);
1207
1208 test_cr2res_trace();
1209 test_cr2res_trace_clean();
1210 test_cr2res_trace_gen_image();
1211 test_cr2res_trace_get_order_idx_values();
1212 test_cr2res_trace_get_ycen();
1213 test_cr2res_trace_get_height();
1214 test_cr2res_trace_compute_middle();
1215 test_cr2res_trace_compute_height();
1216 test_cr2res_trace_get_trace_ypos();
1217 test_cr2res_trace_add_extra_columns();
1218 test_cr2res_trace_signal_detect();
1219 test_cr2res_trace_fit_traces();
1220 test_cr2res_trace_fit_trace();
1221 test_cr2res_trace_convert_labels_to_cluster();
1222 test_cr2res_trace_clean_blobs();
1223 test_cr2res_trace_extract_edges();
1224 test_cr2res_trace_new_slit_fraction();
1225 test_cr2res_get_trace_table_index();
1226 test_cr2res_get_trace_wave_poly();
1227 return cpl_test_end(0);
1228}
char * cr2res_io_create_extname(int detector, int data)
Create Extname.
Definition: cr2res_io.c:618
int cr2res_io_convert_order_idx_to_idxp(int order_idx)
Convert the order_idx to the order_idxp.
Definition: cr2res_io.c:583
int main(void)
Run the Unit tests.
cpl_vector * cr2res_trace_get_ycen(const cpl_table *trace, int order_idx, int trace_nb, int size)
Retrieves the middle (All) polynomial from trace table and evaluates.
Definition: cr2res_trace.c:769
cpl_vector * cr2res_trace_compute_middle(cpl_polynomial *trace1, cpl_polynomial *trace2, int vector_size)
Computes the positions between 2 trace polynomials.
Definition: cr2res_trace.c:851
cpl_image * cr2res_trace_gen_image(cpl_table *trace, int nx, int ny)
Make an image out of the trace solution.
Definition: cr2res_trace.c:362
double cr2res_trace_get_trace_ypos(const cpl_table *traces, int idx)
Compute the y position of the trace.
Definition: cr2res_trace.c:923
int cr2res_trace_get_height(const cpl_table *trace, cpl_size order_idx, cpl_size trace_nb)
Computes the average height (pix) of an order, from trace polys.
Definition: cr2res_trace.c:805
cpl_table * cr2res_trace(cpl_image *ima, int smooth_x, int smooth_y, double threshold, int opening, int degree, int min_cluster)
Main function for running all parts of the trace algorithm.
Definition: cr2res_trace.c:163
cpl_size cr2res_get_trace_table_index(const cpl_table *trace_wave, int order_idx, int trace_nb)
Get the index in a TRACE_WAVE table.
Definition: cr2res_trace.c:652
cpl_table * cr2res_trace_new_slit_fraction(const cpl_table *traces, const cpl_array *new_slit_fraction)
Recompute the traces at a newly specified slit fraction.
int cr2res_trace_compute_height(cpl_polynomial *trace1, cpl_polynomial *trace2, int vector_size)
Computes extraction height between 2 trace polynomials.
Definition: cr2res_trace.c:886
cpl_polynomial * cr2res_get_trace_wave_poly(const cpl_table *trace_wave, const char *poly_column, int order_idx, int trace_nb)
Get a polynomial from a TRACE_WAVE table.
Definition: cr2res_trace.c:685
cpl_mask * cr2res_trace_clean(cpl_mask *mask, int opening, int min_cluster)
Clean small blobs.
Definition: cr2res_trace.c:292
int cr2res_trace_add_extra_columns(cpl_table *traces, const char *infile, int det_nr)
Add extra columns to the plain trace table.
Definition: cr2res_trace.c:972
int * cr2res_trace_get_order_idx_values(const cpl_table *trace, int *nb_order_idx_values)
Count and return the different order_idx values from a TW table.
Definition: cr2res_trace.c:431