CR2RE Pipeline Reference Manual 1.6.8
hdrl_utils-test.c
1/* $Id: hdrl_utils-test.c,v 1.11 2013-10-23 10:49:28 jtaylor Exp $
2 *
3 * This file is part of the HDRL
4 * Copyright (C) 2013 European Southern Observatory
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21/*
22 * $Author: jtaylor $
23 * $Date: 2013-10-23 10:49:28 $
24 * $Revision: 1.11 $
25 * $Name: not supported by cvs2svn $
26 */
27
28#ifdef HAVE_CONFIG_H
29#include <config.h>
30#endif
31
32/*-----------------------------------------------------------------------------
33 Includes
34 -----------------------------------------------------------------------------*/
35
36#include "hdrl_utils.h"
37#include "hdrl_collapse.h"
38#include "hdrl_bpm_utils.h"
39
40#include <cpl.h>
41
42#include <math.h>
43#include <stdlib.h>
44#include <stdio.h>
45#include <string.h>
46
47#ifndef ARRAY_LEN
48#define ARRAY_LEN(a) sizeof((a))/sizeof((a)[0])
49#endif
50
51
52/*----------------------------------------------------------------------------*/
56/*----------------------------------------------------------------------------*/
57static cpl_error_code hdrl_image_to_vector_test(void)
58{
59
60 {
61 cpl_vector * v = hdrl_image_to_vector(NULL, NULL);
62 cpl_test_error(CPL_ERROR_NULL_INPUT);
63 cpl_test_null(v);
64 v = hdrl_image_to_vector(NULL, (void*)1);
65 cpl_test_error(CPL_ERROR_NULL_INPUT);
66 cpl_test_null(v);
67 }
68 {
69 cpl_image * img = cpl_image_new(5, 6, CPL_TYPE_INT);
70 cpl_vector * v = hdrl_image_to_vector(img, NULL);
71 cpl_test_error(CPL_ERROR_NONE);
72 cpl_test_eq(cpl_vector_get_size(v), 5 * 6);
73 cpl_image_delete(img);
74 cpl_vector_delete(v);
75 }
76 /* empty result */
77 {
78 cpl_image * img = cpl_image_new(1, 1, CPL_TYPE_INT);
79 cpl_image_reject(img, 1, 1);
80 cpl_vector * v = hdrl_image_to_vector(img, NULL);
81 cpl_test_error(CPL_ERROR_NONE);
82 cpl_test_null(v);
83 cpl_image_delete(img);
84 }
85 /* bad pixel in image bpm */
86 {
87 cpl_image * img = cpl_image_new(5, 6, CPL_TYPE_INT);
88 cpl_image_set(img, 3, 5, 100);
89 cpl_image_reject(img, 3, 5);
90 cpl_vector * v = hdrl_image_to_vector(img, NULL);
91 cpl_test_error(CPL_ERROR_NONE);
92 cpl_test_eq(cpl_vector_get_size(v), 5 * 6 - 1);
93 cpl_test_eq(cpl_vector_get_sum(v), 0);
94 cpl_image_delete(img);
95 cpl_vector_delete(v);
96 }
97 /* bad pixel in external bpm */
98 {
99 cpl_image * img = cpl_image_new(5, 6, CPL_TYPE_INT);
100 cpl_mask * m = cpl_mask_new(5, 6);
101 cpl_image_set(img, 2, 5, 100);
102 cpl_image_set(img, 3, 5, 100);
103 cpl_mask_set(m, 3, 5, CPL_BINARY_1);
104 cpl_vector * v = hdrl_image_to_vector(img, m);
105 cpl_test_error(CPL_ERROR_NONE);
106 cpl_test_eq(cpl_vector_get_size(v), 5 * 6 - 1);
107 cpl_test_eq(cpl_vector_get_sum(v), 100);
108 cpl_image_delete(img);
109 cpl_mask_delete(m);
110 cpl_vector_delete(v);
111 }
112 /* no cast bad pixel in external bpm */
113 {
114 cpl_image * img = cpl_image_new(5, 6, CPL_TYPE_DOUBLE);
115 cpl_mask * m = cpl_mask_new(5, 6);
116 cpl_image_set(img, 2, 5, 100.);
117 cpl_image_set(img, 3, 5, 100.);
118 cpl_mask_set(m, 3, 5, CPL_BINARY_1);
119 cpl_vector * v = hdrl_image_to_vector(img, m);
120 cpl_test_error(CPL_ERROR_NONE);
121 cpl_test_eq(cpl_vector_get_size(v), 5 * 6 - 1);
122 cpl_test_eq(cpl_vector_get_sum(v), 100);
123 cpl_image_delete(img);
124 cpl_mask_delete(m);
125 cpl_vector_delete(v);
126 }
127 return cpl_error_get_code();
128}
129
130
131static cpl_error_code hdrl_imagelist_to_vector_test(void)
132{
133 {
134 cpl_imagelist * list = cpl_imagelist_new();
135 cpl_vector * v = hdrl_imagelist_to_vector(NULL, 1, 1);
136 cpl_test_error(CPL_ERROR_NULL_INPUT);
137 cpl_test_null(v);
138 v = hdrl_imagelist_to_vector(list, 1, 1);
139 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
140 cpl_test_null(v);
141 cpl_imagelist_set(list, cpl_image_new(5, 5, CPL_TYPE_INT), 0);
142 v = hdrl_imagelist_to_vector(list, 0, 0);
143 cpl_test_error(CPL_ERROR_ACCESS_OUT_OF_RANGE);
144 cpl_test_null(v);
145 v = hdrl_imagelist_to_vector(list, 0, 1);
146 cpl_test_error(CPL_ERROR_ACCESS_OUT_OF_RANGE);
147 cpl_test_null(v);
148 v = hdrl_imagelist_to_vector(list, 1, 0);
149 cpl_test_error(CPL_ERROR_ACCESS_OUT_OF_RANGE);
150 cpl_test_null(v);
151 v = hdrl_imagelist_to_vector(list, 10, 3);
152 cpl_test_error(CPL_ERROR_ACCESS_OUT_OF_RANGE);
153 cpl_test_null(v);
154 v = hdrl_imagelist_to_vector(list, 3, 10);
155 cpl_test_error(CPL_ERROR_ACCESS_OUT_OF_RANGE);
156 cpl_test_null(v);
157 v = hdrl_imagelist_to_vector(list, 10, 10);
158 cpl_test_error(CPL_ERROR_ACCESS_OUT_OF_RANGE);
159 cpl_test_null(v);
160 cpl_imagelist_delete(list);
161 }
162 {
163 cpl_imagelist * list = cpl_imagelist_new();
164 cpl_imagelist_set(list, cpl_image_new(5, 6, CPL_TYPE_INT), 0);
165 cpl_vector * v = hdrl_imagelist_to_vector(list, 1, 1);
166 cpl_test_error(CPL_ERROR_NONE);
167 cpl_test_eq(cpl_vector_get_size(v), 1);
168 cpl_vector_delete(v);
169 cpl_imagelist_set(list, cpl_image_new(5, 6, CPL_TYPE_INT), 1);
170 v = hdrl_imagelist_to_vector(list, 1, 1);
171 cpl_test_error(CPL_ERROR_NONE);
172 cpl_test_eq(cpl_vector_get_size(v), 2);
173 cpl_imagelist_delete(list);
174 cpl_vector_delete(v);
175 }
176 /* empty result */
177 {
178 cpl_imagelist * list = cpl_imagelist_new();
179 cpl_image * img = cpl_image_new(5, 6, CPL_TYPE_INT);
180 cpl_image_reject(img, 2, 1);
181 cpl_imagelist_set(list, img, 0);
182 cpl_imagelist_set(list, cpl_image_duplicate(img), 1);
183 cpl_vector * v = hdrl_imagelist_to_vector(list, 2, 1);
184 cpl_test_error(CPL_ERROR_NONE);
185 cpl_test_null(v);
186 cpl_imagelist_delete(list);
187 cpl_vector_delete(v);
188 }
189 /* bad pixel in image bpm */
190 {
191 cpl_imagelist * list = cpl_imagelist_new();
192 cpl_image * img = cpl_image_new(5, 6, CPL_TYPE_INT);
193 cpl_image_set(img, 2, 1, 100);
194 cpl_imagelist_set(list, cpl_image_duplicate(img), 0);
195 cpl_imagelist_set(list, cpl_image_duplicate(img), 1);
196 cpl_image_reject(img, 2, 1);
197 cpl_imagelist_set(list, img, 2);
198 /* add a good image so potential uninitialized memory is included */
199 cpl_imagelist_set(list, cpl_image_new(5, 6, CPL_TYPE_INT), 3);
200 cpl_vector * v = hdrl_imagelist_to_vector(list, 2, 1);
201 cpl_test_error(CPL_ERROR_NONE);
202 cpl_test_eq(cpl_vector_get_size(v), 3);
203 cpl_test_eq(cpl_vector_get_sum(v), 200);
204 cpl_imagelist_delete(list);
205 cpl_vector_delete(v);
206 }
207 /* no cast bad pixel in image bpm */
208 {
209 cpl_imagelist * list = cpl_imagelist_new();
210 cpl_image * img = cpl_image_new(5, 6, CPL_TYPE_DOUBLE);
211 cpl_image_add_scalar(img, 37);
212 cpl_image_set(img, 5, 6, 100);
213 cpl_imagelist_set(list, cpl_image_duplicate(img), 0);
214 cpl_imagelist_set(list, cpl_image_duplicate(img), 1);
215 cpl_image_reject(img, 5, 6);
216 cpl_imagelist_set(list, img, 2);
217 /* add a good image so potential uninitialized memory is included */
218 cpl_imagelist_set(list, cpl_image_new(5, 6, CPL_TYPE_DOUBLE), 3);
219 cpl_vector * v = hdrl_imagelist_to_vector(list, 5, 6);
220 cpl_test_error(CPL_ERROR_NONE);
221 cpl_test_eq(cpl_vector_get_size(v), 3);
222 cpl_test_eq(cpl_vector_get_sum(v), 200);
223 cpl_imagelist_delete(list);
224 cpl_vector_delete(v);
225 }
226 /* no cast bad pixel in image bpm, full row test */
227 {
228 cpl_imagelist * list = cpl_imagelist_new();
229 cpl_image * img = cpl_image_new(5, 6, CPL_TYPE_DOUBLE);
230 cpl_image_add_scalar(img, 37);
231 cpl_image_set(img, 5, 6, 100);
232 cpl_imagelist_set(list, cpl_image_duplicate(img), 0);
233 cpl_imagelist_set(list, cpl_image_duplicate(img), 1);
234 cpl_image_reject(img, 5, 6);
235 cpl_imagelist_set(list, img, 2);
236 /* add a good image so potential uninitialized memory is included */
237 cpl_imagelist_set(list, cpl_image_new(5, 6, CPL_TYPE_DOUBLE), 3);
238 cpl_vector * o[5];
239 hdrl_imagelist_to_vector_row(list, 6, o, NULL);
240 cpl_test_error(CPL_ERROR_NONE);
241 cpl_test_eq(cpl_vector_get_size(o[4]), 3);
242 cpl_test_eq(cpl_vector_get_sum(o[4]), 200);
243 cpl_imagelist_delete(list);
244 for (size_t i = 0; i < 5; i++) {
245 cpl_vector_delete(o[i]);
246 }
247 }
248 /* no cast bad pixel in image bpm, full row test non-double */
249 {
250 cpl_imagelist * list = cpl_imagelist_new();
251 cpl_image * img = cpl_image_new(5, 6, CPL_TYPE_INT);
252 cpl_image_add_scalar(img, 37);
253 cpl_image_set(img, 5, 6, 100);
254 cpl_imagelist_set(list, cpl_image_duplicate(img), 0);
255 cpl_imagelist_set(list, cpl_image_duplicate(img), 1);
256 cpl_image_reject(img, 5, 6);
257 cpl_imagelist_set(list, img, 2);
258 /* add a good image so potential uninitialized memory is included */
259 cpl_imagelist_set(list, cpl_image_new(5, 6, CPL_TYPE_INT), 3);
260 cpl_vector * o[5];
261 hdrl_imagelist_to_vector_row(list, 6, o, NULL);
262 cpl_test_error(CPL_ERROR_NONE);
263 cpl_test_eq(cpl_vector_get_size(o[4]), 3);
264 cpl_test_eq(cpl_vector_get_sum(o[4]), 200);
265 cpl_imagelist_delete(list);
266 for (size_t i = 0; i < 5; i++) {
267 cpl_vector_delete(o[i]);
268 }
269 }
270 return cpl_error_get_code();
271}
272
273static cpl_error_code hdrl_imagelist_cplwrap(void)
274{
275 hdrl_imagelist *list = NULL;
276 cpl_imagelist *data = NULL;
277 cpl_imagelist *errs = NULL;
278
279 /* Test list null */
280 hdrl_imagelist_to_cplwrap(list, &data, &errs);
281 cpl_test_error(CPL_ERROR_NULL_INPUT);
282
283 /* new list and new data and errs */
284 list = hdrl_imagelist_new();
285 hdrl_imagelist_to_cplwrap(list, &data, &errs);
286 cpl_test_error(CPL_ERROR_NONE);
287 cpl_imagelist_unwrap(data);
288 cpl_imagelist_unwrap(errs);
289
290 /* Not create new data and errs */
291 hdrl_imagelist_to_cplwrap(list, &data, &errs);
292 cpl_test_error(CPL_ERROR_NONE);
293 cpl_imagelist_unwrap(data);
294 cpl_imagelist_unwrap(errs);
295
297
298
299 return cpl_error_get_code();
300}
301
302static cpl_error_code hdrl_normalize_test(void)
303{
304 cpl_imagelist * data = cpl_imagelist_new();
305 cpl_imagelist * errs = cpl_imagelist_new();
306 cpl_vector * vnorm_d, * vnorm_e;
307 cpl_array * acontrib;
308
309 const size_t nz = 23;
310 const size_t nx = 41;
311 const size_t ny = 17;
312 for (size_t i = 0; i < nz; i++) {
313 cpl_image * img = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
314 cpl_image_add_scalar(img, i + 1);
315 cpl_image * err = cpl_image_new(nx, ny, HDRL_TYPE_ERROR);
316 cpl_image_add_scalar(err, i + 1);
317 cpl_image_divide_scalar(err, 3.);
318 cpl_imagelist_set(data, img, i);
319 cpl_imagelist_set(errs, err, i);
320 }
321
322
323 hdrl_collapse_imagelist_to_vector_t * vmethod =
324 hdrl_collapse_imagelist_to_vector_mean();
325 hdrl_collapse_imagelist_to_vector_call(vmethod, data, errs,
326 &vnorm_d, &vnorm_e, &acontrib,
327 NULL);
328 cpl_array_delete(acontrib);
329
330 /* Unknown mode */
331 {
332 cpl_imagelist * ndata = cpl_imagelist_duplicate(data);
333 cpl_imagelist * nerrs = cpl_imagelist_duplicate(errs);
334 hdrl_normalize_imagelist_by_vector(vnorm_d, vnorm_e,
335 -1, ndata, nerrs);
336 cpl_test_error(CPL_ERROR_UNSUPPORTED_MODE);
337 cpl_imagelist_delete(ndata);
338 cpl_imagelist_delete(nerrs);
339 }
340
341 /* additive */
342 {
343 cpl_imagelist * ndata = cpl_imagelist_duplicate(data);
344 cpl_imagelist * nerrs = cpl_imagelist_duplicate(errs);
345 hdrl_normalize_imagelist_by_vector(vnorm_d, vnorm_e,
346 HDRL_SCALE_ADDITIVE,
347 ndata, nerrs);
348 cpl_test_error(CPL_ERROR_NONE);
349
350 cpl_test_image_abs(cpl_imagelist_get_const(data, 0),
351 cpl_imagelist_get_const(ndata, 0), HDRL_EPS_DATA);
352 cpl_test_image_abs(cpl_imagelist_get_const(errs, 0),
353 cpl_imagelist_get_const(nerrs, 0), HDRL_EPS_ERROR);
354 for (size_t i = 1; i < nz; i++) {
355 cpl_image * expect_d = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
356 cpl_image * expect_e = cpl_image_new(nx, ny, HDRL_TYPE_ERROR);
357 double escale = hypot(((i + 1) / 3.) / sqrt(nx * ny),
358 (1. / 3.) / sqrt(nx * ny));
359 cpl_image_add_scalar(expect_e, hypot(escale, (i + 1) / 3.));
360 cpl_image_add_scalar(expect_d, 1);
361 cpl_test_image_abs(expect_d, cpl_imagelist_get_const(ndata, i),
362 HDRL_EPS_DATA);
363 cpl_test_image_abs(expect_e, cpl_imagelist_get_const(nerrs, i),
364 HDRL_EPS_ERROR * 4);
365 cpl_image_delete(expect_d);
366 cpl_image_delete(expect_e);
367 }
368 cpl_imagelist_delete(ndata);
369 cpl_imagelist_delete(nerrs);
370 }
371
372 /* multiplicative */
373 {
374 cpl_imagelist *ndata = cpl_imagelist_duplicate(data);
375 cpl_imagelist *nerrs = cpl_imagelist_duplicate(errs);
376
377
378 /* Simulate scale error (emit warnings) */
379 cpl_vector *fake1 = cpl_vector_duplicate(vnorm_d);
380 cpl_vector *fake2 = cpl_vector_duplicate(vnorm_e);
381 cpl_imagelist *fake3 = cpl_imagelist_duplicate(ndata);
382 cpl_imagelist *fake4 = cpl_imagelist_duplicate(nerrs);
383 cpl_vector_set(fake1, 1, 0.);
384 cpl_vector_set(fake2, 1, 0.);
385 hdrl_normalize_imagelist_by_vector(fake1, fake2,
386 HDRL_SCALE_MULTIPLICATIVE, fake3, fake4);
387 cpl_vector_delete(fake1);
388 cpl_vector_delete(fake2);
389 cpl_imagelist_delete(fake3);
390 cpl_imagelist_delete(fake4);
391
392
393 /* Normal work */
394 hdrl_normalize_imagelist_by_vector(vnorm_d, vnorm_e,
395 HDRL_SCALE_MULTIPLICATIVE,
396 ndata, nerrs);
397 cpl_test_error(CPL_ERROR_NONE);
398
399 cpl_test_image_abs(cpl_imagelist_get_const(data, 0),
400 cpl_imagelist_get_const(ndata, 0), HDRL_EPS_DATA);
401 cpl_test_image_abs(cpl_imagelist_get_const(errs, 0),
402 cpl_imagelist_get_const(nerrs, 0), HDRL_EPS_ERROR);
403 for (size_t i = 1; i < nz; i++) {
404 cpl_image * expect_d = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
405 cpl_image * expect_e = cpl_image_new(nx, ny, HDRL_TYPE_ERROR);
406 /* off by about 10e-4 due to missing correlation */
407 cpl_image_add_scalar(expect_e, 0.3338112308308246);
408 cpl_image_add_scalar(expect_d, 1.);
409 cpl_test_image_abs(expect_d, cpl_imagelist_get_const(ndata, i),
410 HDRL_EPS_DATA);
411 cpl_test_image_abs(expect_e, cpl_imagelist_get_const(nerrs, i),
412 HDRL_EPS_ERROR * 4);
413 cpl_image_delete(expect_d);
414 cpl_image_delete(expect_e);
415 }
416 cpl_imagelist_delete(ndata);
417 cpl_imagelist_delete(nerrs);
418 }
419
420 cpl_imagelist_delete(data);
421 cpl_imagelist_delete(errs);
422 cpl_vector_delete(vnorm_d);
423 cpl_vector_delete(vnorm_e);
424 hdrl_collapse_imagelist_to_vector_delete(vmethod);
425
426 return cpl_error_get_code();
427}
428
429
430static cpl_error_code hdrl_normalize_image_test(void)
431{
432 cpl_imagelist * data = cpl_imagelist_new();
433 cpl_imagelist * errs = cpl_imagelist_new();
434 cpl_imagelist * vnorm_d = cpl_imagelist_new();
435 cpl_imagelist * vnorm_e = cpl_imagelist_new();
436 cpl_vector * vnorm_d_, * vnorm_e_;
437 cpl_array * acontrib;
438
439 const size_t nz = 23;
440 const size_t nx = 41;
441 const size_t ny = 17;
442 for (size_t i = 0; i < nz; i++) {
443 cpl_image * img = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
444 cpl_image_add_scalar(img, i + 1);
445 cpl_image * err = cpl_image_new(nx, ny, HDRL_TYPE_ERROR);
446 cpl_image_add_scalar(err, i + 1);
447 cpl_image_divide_scalar(err, 3.);
448 cpl_imagelist_set(data, img, i);
449 cpl_imagelist_set(errs, err, i);
450 }
451
452
453 hdrl_collapse_imagelist_to_vector_t * vmethod =
454 hdrl_collapse_imagelist_to_vector_mean();
455 hdrl_collapse_imagelist_to_vector_call(vmethod, data, errs,
456 &vnorm_d_, &vnorm_e_, &acontrib,
457 NULL);
458 cpl_array_delete(acontrib);
459 for (cpl_size i = 0; i < cpl_vector_get_size(vnorm_d_); i++) {
460 cpl_image * dimg = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
461 cpl_image * eimg = cpl_image_new(nx, ny, HDRL_TYPE_ERROR);
462 cpl_image_add_scalar(dimg, cpl_vector_get(vnorm_d_, i));
463 cpl_image_add_scalar(eimg, cpl_vector_get(vnorm_e_, i));
464 cpl_imagelist_set(vnorm_d, dimg, i);
465 cpl_imagelist_set(vnorm_e, eimg, i);
466 }
467 cpl_vector_delete(vnorm_d_);
468 cpl_vector_delete(vnorm_e_);
469
470
471 /* Unknown mode */
472 {
473 cpl_imagelist * ndata = cpl_imagelist_duplicate(data);
474 cpl_imagelist * nerrs = cpl_imagelist_duplicate(errs);
475 hdrl_normalize_imagelist_by_imagelist(vnorm_d, vnorm_e,
476 -1, ndata, nerrs);
477 cpl_test_error(CPL_ERROR_UNSUPPORTED_MODE);
478 cpl_imagelist_delete(ndata);
479 cpl_imagelist_delete(nerrs);
480 }
481
482 /* additive */
483 {
484 cpl_imagelist * ndata = cpl_imagelist_duplicate(data);
485 cpl_imagelist * nerrs = cpl_imagelist_duplicate(errs);
486 hdrl_normalize_imagelist_by_imagelist(vnorm_d, vnorm_e,
487 HDRL_SCALE_ADDITIVE,
488 ndata, nerrs);
489 cpl_test_error(CPL_ERROR_NONE);
490
491 cpl_test_image_abs(cpl_imagelist_get_const(data, 0),
492 cpl_imagelist_get_const(ndata, 0), HDRL_EPS_DATA);
493 cpl_test_image_abs(cpl_imagelist_get_const(errs, 0),
494 cpl_imagelist_get_const(nerrs, 0), HDRL_EPS_ERROR);
495 for (size_t i = 1; i < nz; i++) {
496 cpl_image * expect_d = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
497 cpl_image * expect_e = cpl_image_new(nx, ny, HDRL_TYPE_ERROR);
498 double escale = hypot(((i + 1) / 3.) / sqrt(nx * ny),
499 (1. / 3.) / sqrt(nx * ny));
500 cpl_image_add_scalar(expect_e, hypot(escale, (i + 1) / 3.));
501 cpl_image_add_scalar(expect_d, 1);
502 cpl_test_image_abs(expect_d, cpl_imagelist_get_const(ndata, i),
503 HDRL_EPS_DATA);
504 cpl_test_image_abs(expect_e, cpl_imagelist_get_const(nerrs, i),
505 HDRL_EPS_ERROR * 4);
506 cpl_image_delete(expect_d);
507 cpl_image_delete(expect_e);
508 }
509 cpl_imagelist_delete(ndata);
510 cpl_imagelist_delete(nerrs);
511 }
512
513 /* multiplicative */
514 {
515 cpl_imagelist * ndata = cpl_imagelist_duplicate(data);
516 cpl_imagelist * nerrs = cpl_imagelist_duplicate(errs);
517 hdrl_normalize_imagelist_by_imagelist(vnorm_d, vnorm_e,
518 HDRL_SCALE_MULTIPLICATIVE,
519 ndata, nerrs);
520 cpl_test_error(CPL_ERROR_NONE);
521
522 cpl_test_image_abs(cpl_imagelist_get_const(data, 0),
523 cpl_imagelist_get_const(ndata, 0), HDRL_EPS_DATA);
524 cpl_test_image_abs(cpl_imagelist_get_const(errs, 0),
525 cpl_imagelist_get_const(nerrs, 0), HDRL_EPS_ERROR);
526 for (size_t i = 1; i < nz; i++) {
527 cpl_image * expect_d = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
528 cpl_image * expect_e = cpl_image_new(nx, ny, HDRL_TYPE_ERROR);
529 /* off by about 10e-4 due to missing correlation */
530 cpl_image_add_scalar(expect_e, 0.3338112308308246);
531 cpl_image_add_scalar(expect_d, 1.);
532 cpl_test_image_abs(expect_d, cpl_imagelist_get_const(ndata, i),
533 HDRL_EPS_DATA);
534 cpl_test_image_abs(expect_e, cpl_imagelist_get_const(nerrs, i),
535 HDRL_EPS_ERROR * 4);
536 cpl_image_delete(expect_d);
537 cpl_image_delete(expect_e);
538 }
539 cpl_imagelist_delete(ndata);
540 cpl_imagelist_delete(nerrs);
541 }
542
543 cpl_imagelist_delete(data);
544 cpl_imagelist_delete(errs);
545 cpl_imagelist_delete(vnorm_d);
546 cpl_imagelist_delete(vnorm_e);
547 hdrl_collapse_imagelist_to_vector_delete(vmethod);
548
549 return cpl_error_get_code();
550}
551
552
553
554/* path related smoke tests */
555void hdrl_path_test(void)
556{
557 char * cwd;
558 int fd;
559
560 cwd = hdrl_get_cwd();
561 cpl_test_nonnull(cwd);
562
563 fd = hdrl_get_tempfile(NULL, CPL_TRUE);
564 cpl_test(fd >= 0);
565 close(fd);
566
567/*
568 fd = hdrl_get_tempfile(NULL, CPL_FALSE);
569 cpl_test(fd >= 0);
570*/
571
572 fd = hdrl_get_tempfile(cwd, CPL_TRUE);
573 cpl_test(fd >= 0);
574
575/*
576 fd = hdrl_get_tempfile(cwd, CPL_FALSE);
577 cpl_test(fd >= 0);
578*/
579
580 cpl_free(cwd);
581}
582
583void hdrl_string_test(void)
584{
585 char * dummy = NULL;
586 char * s;
587 int result;
588
589 s = hdrl_join_string(NULL, 0, "test");
590 cpl_test_null(s);
591 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
592
593 s = hdrl_join_string(NULL, 1, "test");
594 result = strcmp(s, "test");
595 cpl_test_zero(result);
596 cpl_free(s);
597
598 s = hdrl_join_string(NULL, 2, "test", "bla");
599 result = strcmp(s, "testbla");
600 cpl_test_zero(result);
601 cpl_free(s);
602
603 s = hdrl_join_string(".", 1, "test");
604 result = strcmp(s, "test");
605 cpl_test_zero(result);
606 cpl_free(s);
607
608 s = hdrl_join_string(".", 2, "test", "bla");
609 result = strcmp(s, "test.bla");
610 cpl_test_zero(result);
611 cpl_free(s);
612
613 s = hdrl_join_string("--", 3, "test", "bla", "val");
614 result = strcmp(s, "test--bla--val");
615 cpl_test_zero(result);
616 cpl_free(s);
617
618 s = hdrl_join_string("--", 3, "", "bla", "val");
619 result = strcmp(s, "bla--val");
620 cpl_test_zero(result);
621 cpl_free(s);
622
623 s = hdrl_join_string("--", 3, "test", "", "val");
624 result = strcmp(s, "test--val");
625 cpl_test_zero(result);
626 cpl_free(s);
627
628 s = hdrl_join_string(",", 3, "test", dummy, "val");
629 result = strcmp(s, "test,val");
630 cpl_test_zero(result);
631 cpl_free(s);
632
633 s = hdrl_join_string("--", 4, "", dummy, "val", "test");
634 result = strcmp(s, "val--test");
635 cpl_test_zero(result);
636 cpl_free(s);
637
638 s = hdrl_join_string("--", 3, dummy, "bla", "val");
639 result = strcmp(s, "bla--val");
640 cpl_test_zero(result);
641 cpl_free(s);
642
643 s = hdrl_join_string("--", 3, "test", "bla", "");
644 result = strcmp(s, "test--bla");
645 cpl_test_zero(result);
646 cpl_free(s);
647
648 s = hdrl_join_string("--", 3, "test", "bla", dummy);
649 result = strcmp(s, "test--bla");
650 cpl_test_zero(result);
651 cpl_free(s);
652}
653
654
655void hdrl_pfilter_test(void)
656{
657 cpl_imagelist * list1 = cpl_imagelist_new();
658 cpl_imagelist_set(list1, cpl_image_new(5, 5, CPL_TYPE_INT), 0);
659 cpl_imagelist_set(list1, cpl_image_new(5, 5, CPL_TYPE_INT), 1);
660
661 cpl_imagelist *list2;
662
663 list2 = hdrl_bpm_filter_list(NULL, 5, 5, CPL_FILTER_MEDIAN);
664 cpl_test_error(CPL_ERROR_NULL_INPUT);
665 cpl_test_null(list2);
666
667 list2 = hdrl_bpm_filter_list(list1, 5, 5, CPL_FILTER_MEDIAN);
668 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
669 cpl_test_null(list2);
670
671 cpl_imagelist_delete(list2);
672 cpl_imagelist_delete(list1);
673
674 size_t nx = 100;
675 size_t any[] = {13, 22, 47, 100, 103, 104, 202, 203, 204,
676 542, 1034, 1239};
677 size_t amx[] = {1, 1, 3, 3, 5, 7, 13};
678 size_t amy[] = {1, 3, 1, 3, 5, 7, 13};
679 for (size_t j = 0; j < ARRAY_LEN(amx); j++) {
680 cpl_mask * m = cpl_mask_new(amx[j], amy[j]);
681 cpl_matrix * k = cpl_matrix_new(amx[j], amy[j]);
682 cpl_mask_not(m);
683 cpl_matrix_add_scalar(k, 1);
684 for (size_t i = 0; i < ARRAY_LEN(any); i++) {
685 size_t ny = any[i];
686 cpl_msg_info(cpl_func, "Testing ny %zu mask %zu,%zu", ny,
687 amx[j], amy[j]);
688 cpl_image * img = cpl_image_new(nx, ny, CPL_TYPE_DOUBLE);
689 double * d = cpl_image_get_data_double(img);
690 for (size_t kindex = 0; kindex < nx * ny; kindex++) {
691 d[kindex] = kindex + rand() % 100;
692 if (i % 2 == 0 && ((int)d[kindex] % 20) == 0) {
693 cpl_image_reject(img, (rand() % nx) + 1, (rand() % ny) + 1);
694 }
695 }
696 cpl_image * orig_inp = cpl_image_duplicate(img);
697 cpl_image * ro = cpl_image_duplicate(img);
698 cpl_image * rp;
699
700 cpl_image_filter_mask(ro, img, m, CPL_FILTER_MEDIAN, CPL_BORDER_FILTER);
701 rp = hdrl_parallel_filter_image(img, NULL, m, CPL_FILTER_MEDIAN);
702 cpl_test_image_abs(rp, ro, 0);
703 /* input unchanged */
704 cpl_test_image_abs(img, orig_inp, 0);
705 cpl_image_delete(rp);
706
707 cpl_image_filter(ro, img, k, CPL_FILTER_LINEAR, CPL_BORDER_FILTER);
708 rp = hdrl_parallel_filter_image(img, k, NULL, CPL_FILTER_LINEAR);
709 cpl_test_image_abs(rp, ro, 0);
710 /* input unchanged */
711 cpl_test_image_abs(img, orig_inp, 0);
712 cpl_image_delete(rp);
713
714 cpl_image_delete(ro);
715 cpl_image_delete(img);
716 cpl_image_delete(orig_inp);
717 }
718 cpl_mask_delete(m);
719 cpl_matrix_delete(k);
720 }
721}
722
723void hdrl_pconvert_test(void)
724{
725 cpl_size nx = 223;
726 cpl_size ny = 223;
727 cpl_propertylist * plist = cpl_propertylist_new();
728 cpl_propertylist_update_int(plist, "NAXIS", 2);
729 cpl_propertylist_update_int(plist, "NAXIS1", nx);
730 cpl_propertylist_update_int(plist, "NAXIS2", ny);
731 cpl_propertylist_update_string(plist, "CTYPE1", "RA---ZPN");
732 cpl_propertylist_update_string(plist, "CTYPE2", "DEC--ZPN");
733 cpl_propertylist_update_double(plist, "CRVAL1", 149.947);
734 cpl_propertylist_update_double(plist, "CRVAL2", 2.205);
735 cpl_propertylist_update_double(plist, "CRPIX1", 5401.42);
736 cpl_propertylist_update_double(plist, "CRPIX2", 6834.89);
737 cpl_propertylist_update_double(plist, "CD1_1", 1.8072e-07);
738 cpl_propertylist_update_double(plist, "CD1_2", 9.4796e-05);
739 cpl_propertylist_update_double(plist, "CD2_1", -9.4820e-05);
740 cpl_propertylist_update_double(plist, "CD2_2", 2.0167e-07);
741 cpl_propertylist_update_double(plist, "PV2_1", 1.);
742 cpl_propertylist_update_double(plist, "PV2_2", 0.);
743 cpl_propertylist_update_double(plist, "PV2_3", 44.);
744 cpl_propertylist_update_double(plist, "PV2_4", 0.);
745 cpl_propertylist_update_double(plist, "PV2_5", -10300.);
746 cpl_propertylist_update_string(plist, "CUNIT1", "deg");
747 cpl_propertylist_update_string(plist, "CUNIT2", "deg");
748
749 cpl_wcs * wcs = cpl_wcs_new_from_propertylist(plist);
750 cpl_matrix * from = cpl_matrix_new(nx * ny, 2);
751 for (cpl_size y = 0; y < ny; y++) {
752 for (cpl_size x = 0; x < nx; x++) {
753 cpl_matrix_set(from, (y * nx) + x, 0, x);
754 cpl_matrix_set(from, (y * nx) + x, 1, y);
755 }
756 }
757 cpl_matrix * to, *to2, *toc, *toc2;
758 cpl_array * status, *statusc;
759 hdrl_wcs_convert(wcs, from, &to, &status, CPL_WCS_PHYS2WORLD);
760 cpl_test_error(CPL_ERROR_NONE);
761 cpl_wcs_convert(wcs, from, &toc, &statusc, CPL_WCS_PHYS2WORLD);
762
763 cpl_test_matrix_abs(to, toc, 0.);
764 cpl_test_array_abs(status, statusc, 0.);
765 cpl_array_delete(status);
766 cpl_array_delete(statusc);
767
768 hdrl_wcs_convert(wcs, to, &to2, &status, CPL_WCS_WORLD2PHYS);
769 cpl_test_error(CPL_ERROR_NONE);
770 cpl_wcs_convert(wcs, to, &toc2, &statusc, CPL_WCS_WORLD2PHYS);
771
772 cpl_test_matrix_abs(to2, toc2, 0.);
773 cpl_test_array_abs(status, statusc, 0.);
774
775 cpl_matrix_delete(to);
776 cpl_matrix_delete(toc);
777 cpl_matrix_delete(to2);
778 cpl_matrix_delete(toc2);
779 cpl_array_delete(status);
780 cpl_array_delete(statusc);
781
782 /* invalid phys as world input */
783 hdrl_wcs_convert(wcs, from, &to, &status, CPL_WCS_WORLD2PHYS);
784 cpl_test_error(CPL_ERROR_UNSPECIFIED);
785 cpl_wcs_convert(wcs, from, &toc, &statusc, CPL_WCS_WORLD2PHYS);
786 cpl_test_array_abs(status, statusc, 0.);
787
788 cpl_matrix_delete(to);
789 cpl_matrix_delete(toc);
790 cpl_array_delete(status);
791 cpl_array_delete(statusc);
792
793 /* check error */
794 hdrl_wcs_convert(NULL, NULL, NULL, NULL, CPL_WCS_PHYS2WORLD);
795 cpl_test_error(CPL_ERROR_NULL_INPUT);
796
797 hdrl_wcs_convert(wcs, from, &to, &status, (cpl_wcs_trans_mode)1421);
798 cpl_test_error(CPL_ERROR_UNSUPPORTED_MODE);
799
800 cpl_propertylist_erase(plist, "NAXIS2");
801 cpl_wcs_delete(wcs);
802 wcs = cpl_wcs_new_from_propertylist(plist);
803 hdrl_wcs_convert(wcs, from, &to, &status, CPL_WCS_PHYS2WORLD);
804 cpl_test_error(CPL_ERROR_UNSPECIFIED);
805 cpl_matrix_delete(to);
806 cpl_array_delete(status);
807
808 cpl_propertylist_delete(plist);
809 cpl_wcs_delete(wcs);
810 cpl_matrix_delete(from);
811}
812
813static cpl_error_code hdrl_airmass_test(void){
814
815 cpl_errorstate prestate = cpl_errorstate_get();
816
817 /* Temporary variables */
818 hdrl_value airmass, airmass1, airmass2, airmass3;
819
820 /* Aproximation methods */
821 hdrl_airmass_approx typeAirmassAprox1 = HDRL_AIRMASS_APPROX_HARDIE;
822 hdrl_airmass_approx typeAirmassAprox2 = HDRL_AIRMASS_APPROX_YOUNG_IRVINE;
823 hdrl_airmass_approx typeAirmassAprox3 = HDRL_AIRMASS_APPROX_YOUNG;
824
825
826 /* Input parameters based in MUSE data */
827
828 hdrl_value ra1 = { 122.994945, 0.};
829 hdrl_value dec1 = {74.95304, 0.};
830 hdrl_value lst1 = {25407.072748, 0.};
831 hdrl_value exptime1 = {120., 0.};
832 hdrl_value geolat1 = {37.2236, 0.};
833
834 hdrl_value ra2 = {238.071555, 0.};
835 hdrl_value dec2 = {32.92533, 0.};
836 hdrl_value lst2 = {60515.584209, 0.};
837 hdrl_value exptime2 = {300., 0.};
838 hdrl_value geolat2 = {37.2236, 0.};
839
840 hdrl_value ra3 = {0.125, 0.};
841 hdrl_value dec3 = {-30., 0.};
842 hdrl_value lst3 = {69446.2765265328, 0.};
843 hdrl_value exptime3 = {3600., 0.};
844 hdrl_value geolat3 = {-24.625278, 0.};
845
846
847 /******** Tests of failure cases (HARDIE approx method) ****************/
848
849 /* Not valid Ra */
850 airmass = hdrl_utils_airmass((hdrl_value){-1.,0.}, dec1, lst1, exptime1, geolat1, typeAirmassAprox1);
851 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
852 cpl_test(airmass.data == -1.);
853
854 /* Not valid Dec */
855 airmass = hdrl_utils_airmass(ra1, (hdrl_value){180.,0.}, lst1, exptime1, geolat1, typeAirmassAprox1);
856 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
857 cpl_test(airmass.data == -1.);
858
859 /* Not valid Lst */
860 airmass = hdrl_utils_airmass(ra1, dec1, (hdrl_value){-1.,0.}, exptime1, geolat1, typeAirmassAprox1);
861 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
862 cpl_test(airmass.data == -1.);
863
864 /* Not valid Exptime */
865 airmass = hdrl_utils_airmass(ra1, dec1, lst1, (hdrl_value){-1.,0.}, geolat1, typeAirmassAprox1);
866 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
867 cpl_test(airmass.data == -1.);
868
869 /* Not valid Geolat */
870 airmass = hdrl_utils_airmass(ra1, dec1, lst1, exptime1, (hdrl_value){180.,0.}, typeAirmassAprox1);
871 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
872 cpl_test(airmass.data == -1.);
873
874 /* Not valid Airmass Approximation method */
875 airmass = hdrl_utils_airmass(ra1, dec1, lst1, exptime1, geolat1, 0);
876 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
877 cpl_test(airmass.data == -1.);
878
879
880 /***** Test without error propagation (HARDIE approx method) ***********/
881
882 airmass1 = hdrl_utils_airmass(ra1, dec1, lst1, exptime1, geolat1, typeAirmassAprox1);
883 cpl_test(cpl_errorstate_is_equal(prestate) == CPL_TRUE);
884
885 airmass2 = hdrl_utils_airmass(ra2, dec2, lst2, exptime2, geolat2, typeAirmassAprox1);
886 cpl_test(cpl_errorstate_is_equal(prestate) == CPL_TRUE);
887
888 airmass3 = hdrl_utils_airmass(ra3, dec3, lst3, exptime3, geolat3, typeAirmassAprox1);
889 cpl_test(cpl_errorstate_is_equal(prestate) == CPL_TRUE);
890
891 /* check the result without error propagation */
892
893 cpl_test(airmass1.data > 1.27803 - 0.001);
894 cpl_test(airmass1.data < 1.27803 + 0.001);
895
896 cpl_test(airmass2.data > 1.02529 - 0.001);
897 cpl_test(airmass2.data < 1.02529 + 0.001);
898
899 cpl_test(airmass3.data > 1.79364 - 0.001);
900 cpl_test(airmass3.data < 1.79364 + 0.001);
901
902
903 /****** Tests with error propagation (HARDIE approx method) ************/
904
905 double delta = 1e-2;
906 double deltaRa = delta;
907 double deltaDec = delta;
908 double deltaLst = delta;
909 double deltaExptime = delta;
910 double deltaGeolat = delta;
911
912 ra1.error = deltaRa * fabs(ra1.data);
913 dec1.error = deltaDec * fabs(dec1.data);
914 lst1.error = deltaLst * fabs(lst1.data);
915 exptime1.error = deltaExptime * fabs(exptime1.data);
916 geolat1.error = deltaGeolat * fabs(geolat1.data);
917
918 ra2.error = deltaRa * fabs(ra2.data);
919 dec2.error = deltaDec * fabs(dec2.data);
920 lst2.error = deltaLst * fabs(lst2.data);
921 exptime2.error = deltaExptime * fabs(exptime2.data);
922 geolat2.error = deltaGeolat * fabs(geolat2.data);
923
924 ra3.error = deltaRa * fabs(ra3.data);
925 dec3.error = deltaDec * fabs(dec3.data);
926 lst3.error = deltaLst * fabs(lst3.data);
927 exptime3.error = deltaExptime * fabs(exptime3.data);
928 geolat3.error = deltaGeolat * fabs(geolat3.data);
929
930 airmass1 = hdrl_utils_airmass(ra1, dec1, lst1, exptime1, geolat1, typeAirmassAprox1);
931 cpl_test(cpl_errorstate_is_equal(prestate) == CPL_TRUE);
932
933 airmass2 = hdrl_utils_airmass(ra2, dec2, lst2, exptime2, geolat2, typeAirmassAprox1);
934 cpl_test(cpl_errorstate_is_equal(prestate) == CPL_TRUE);
935
936 airmass3 = hdrl_utils_airmass(ra3, dec3, lst3, exptime3, geolat3, typeAirmassAprox1);
937 cpl_test(cpl_errorstate_is_equal(prestate) == CPL_TRUE);
938
939 /* check the result with error propagation */
940
941 cpl_test(airmass1.data > 1.27803 - 0.001 );
942 cpl_test(airmass1.data < 1.27803 + 0.001 );
943 cpl_test(airmass1.error > 0.0136602 - 0.0001);
944 cpl_test(airmass1.error < 0.0136602 + 0.0001);
945
946 cpl_test(airmass2.data > 1.02529 - 0.001 );
947 cpl_test(airmass2.data < 1.02529 + 0.001 );
948 cpl_test(airmass2.error > 0.0216347 - 0.0001);
949 cpl_test(airmass2.error < 0.0216347 + 0.0001);
950
951 cpl_test(airmass3.data > 1.79364 - 0.001 );
952 cpl_test(airmass3.data < 1.79364 + 0.001 );
953 cpl_test(airmass3.error > 0.128632 - 0.0001);
954 cpl_test(airmass3.error < 0.128631 + 0.0001);
955
956
957 /*** Test with different kinds of approximation and error propagation ***/
958
959 airmass1 = hdrl_utils_airmass(ra1, dec1, lst1, exptime1, geolat1, typeAirmassAprox1);
960 cpl_test(cpl_errorstate_is_equal(prestate) == CPL_TRUE);
961
962 airmass2 = hdrl_utils_airmass(ra1, dec1, lst1, exptime1, geolat1, typeAirmassAprox2);
963 cpl_test(cpl_errorstate_is_equal(prestate) == CPL_TRUE);
964
965 airmass3 = hdrl_utils_airmass(ra1, dec1, lst1, exptime1, geolat1, typeAirmassAprox3);
966 cpl_test(cpl_errorstate_is_equal(prestate) == CPL_TRUE);
967
968
969 /* check the result with error propagation and different approximations */
970
971 cpl_test(airmass1.data > 1.27803 - 0.001 );
972 cpl_test(airmass1.data < 1.27803 + 0.001 );
973 cpl_test(airmass1.error > 0.0136602 - 0.0001);
974 cpl_test(airmass1.error < 0.0136602 + 0.0001);
975
976 cpl_test(airmass2.data > 1.2778 - 0.001 );
977 cpl_test(airmass2.data < 1.2778 + 0.001 );
978 cpl_test(airmass2.error > 0.0135473 - 0.0001);
979 cpl_test(airmass2.error < 0.0135473 + 0.0001);
980
981 cpl_test(airmass3.data > 1.27755 - 0.001 );
982 cpl_test(airmass3.data < 1.27755 + 0.001 );
983 cpl_test(airmass3.error > 0.0135339 - 0.0001);
984 cpl_test(airmass3.error < 0.0135339 + 0.0001);
985
986
987 return cpl_error_get_code();
988}
989
990static cpl_error_code hdrl_license_test(void)
991{
992 const char* str = hdrl_get_license();
993 cpl_test_nonnull(str);
994
995 return cpl_error_get_code();
996}
997
998static cpl_error_code hdrl_region_test(void)
999{
1000 /* Test wrong hdrl_parameter */
1001 hdrl_parameter* pFake = hdrl_collapse_mean_parameter_create();
1002 hdrl_rect_region_parameter_verify(pFake, 10, 10);
1003 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
1004
1005 /* Test error verify */
1006 hdrl_parameter* pErr1 = hdrl_rect_region_parameter_create( 0, 1, 10, 10);
1007 hdrl_parameter* pErr2 = hdrl_rect_region_parameter_create( 1, 0, 10, 10);
1008 hdrl_parameter* pErr3 = hdrl_rect_region_parameter_create( 1, 1, 0, 10);
1009 hdrl_parameter* pErr4 = hdrl_rect_region_parameter_create( 1, 1, 10, 0);
1010 hdrl_parameter* pErr5 = hdrl_rect_region_parameter_create(10, 1, 1, 10);
1011 hdrl_parameter* pErr6 = hdrl_rect_region_parameter_create( 1, 10, 10, 1);
1012 cpl_test_error(CPL_ERROR_NONE);
1013
1015 cpl_test_error(CPL_ERROR_NULL_INPUT);
1016
1017 hdrl_rect_region_parameter_verify(pErr1, 10, 10);
1018 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
1019
1020 hdrl_rect_region_parameter_verify(pErr2, 10, 10);
1021 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
1022
1023 hdrl_rect_region_parameter_verify(pErr3, 10, 10);
1024 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
1025
1026 hdrl_rect_region_parameter_verify(pErr4, 10, 10);
1027 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
1028
1029 hdrl_rect_region_parameter_verify(pErr5, 10, 10);
1030 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
1031
1032 hdrl_rect_region_parameter_verify(pErr6, 10, 10);
1033 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
1034
1035
1036 /* Correct verify */
1037 hdrl_parameter* p = hdrl_rect_region_parameter_create(1, 1, 10, 10);
1038 cpl_test_error(CPL_ERROR_NONE);
1039 cpl_test_nonnull(p);
1040
1042 cpl_test_error(CPL_ERROR_NONE);
1043
1044 hdrl_rect_region_parameter_update(p, 1, 1, 20, 20);
1045 cpl_test_error(CPL_ERROR_NONE);
1046
1048 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
1049
1051 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
1052
1054 cpl_test_error(CPL_ERROR_NULL_INPUT);
1055 cpl_size llx = hdrl_rect_region_get_llx(p);
1056 cpl_test_eq(llx, 1);
1057
1059 cpl_test_error(CPL_ERROR_NULL_INPUT);
1060 cpl_size lly = hdrl_rect_region_get_lly(p);
1061 cpl_test_eq(lly, 1);
1062
1064 cpl_test_error(CPL_ERROR_NULL_INPUT);
1065 cpl_size urx = hdrl_rect_region_get_urx(p);
1066 cpl_test_eq(urx, 20);
1067
1069 cpl_test_error(CPL_ERROR_NULL_INPUT);
1070 cpl_size ury = hdrl_rect_region_get_ury(p);
1071 cpl_test_eq(ury, 20);
1072
1073
1074
1075 /* Test null parameters */
1076
1077 cpl_parameterlist *plist = hdrl_rect_region_parameter_create_parlist(
1078 NULL, "test", "region-", p);
1079 cpl_test_error(CPL_ERROR_NULL_INPUT);
1080 cpl_test_null(plist);
1081
1083 "RECIPE", NULL, "region-", p);
1084 cpl_test_error(CPL_ERROR_NULL_INPUT);
1085 cpl_test_null(plist);
1086
1088 "RECIPE", "test", NULL, p);
1089 cpl_test_error(CPL_ERROR_NULL_INPUT);
1090 cpl_test_null(plist);
1091
1093 "RECIPE", "test", "region-", NULL);
1094 cpl_test_error(CPL_ERROR_NULL_INPUT);
1095 cpl_test_null(plist);
1096
1097
1098 /* Wrong parse */
1099 cpl_parameterlist *plFake = hdrl_rect_region_parameter_create_parlist(
1100 "RECIPE", "test", "region-", pFake);
1101 cpl_test_error(CPL_ERROR_INCOMPATIBLE_INPUT);
1102 cpl_test_null(plFake);
1103 hdrl_parameter_delete(pFake);
1104
1105
1106 cpl_parameterlist *plist1 = hdrl_rect_region_parameter_create_parlist(
1107 "RECIPE", "test", "region-", p);
1108 cpl_test_error(CPL_ERROR_NONE);
1109 cpl_test_nonnull(plist1);
1110
1111 hdrl_parameter *out1 = hdrl_rect_region_parameter_parse_parlist(
1112 NULL, "test", "region-");
1113 cpl_test_error(CPL_ERROR_NULL_INPUT);
1114 cpl_test_null(out1);
1115
1117 plist1, NULL, "region-");
1118 cpl_test_error(CPL_ERROR_NULL_INPUT);
1119 cpl_test_null(out1);
1120
1122 plist1, "test", NULL);
1123 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
1124 cpl_test_null(out1);
1125
1127 plist1, "test", "region-");
1128 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
1129 cpl_test_null(out1);
1130
1131
1132 /* Right parse */
1133 cpl_parameterlist *plist2 = hdrl_rect_region_parameter_create_parlist(
1134 "test", "", "region-", p);
1135 cpl_test_error(CPL_ERROR_NONE);
1136 cpl_test_nonnull(plist2);
1137
1138 hdrl_parameter *out2 = hdrl_rect_region_parameter_parse_parlist(
1139 plist2, "test", "region-");
1140 cpl_test_error(CPL_ERROR_NONE);
1141 cpl_test_nonnull(out2);
1142
1143
1144 /* Region Fix negatives */
1145
1146 hdrl_rect_region_fix_negatives(NULL, 10, 10);
1147 cpl_test_error(CPL_ERROR_NULL_INPUT);
1148
1149 hdrl_parameter* pFake2 = hdrl_collapse_mean_parameter_create();
1150 hdrl_rect_region_fix_negatives(pFake2, 10, 10);
1151 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
1152 hdrl_parameter_delete(pFake2);
1153
1155 cpl_test_error(CPL_ERROR_NONE);
1156
1157 hdrl_parameter* pErr = hdrl_rect_region_parameter_create(-1, -1, -1, -1);
1158
1160 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
1161
1163 cpl_test_error(CPL_ERROR_NONE);
1164
1165
1166 /* Clean up */
1167 cpl_parameterlist_delete(plist1);
1168 cpl_parameterlist_delete(plist2);
1169
1170 hdrl_parameter_delete(pErr1);
1171 hdrl_parameter_delete(pErr2);
1172 hdrl_parameter_delete(pErr3);
1173 hdrl_parameter_delete(pErr4);
1174 hdrl_parameter_delete(pErr5);
1175 hdrl_parameter_delete(pErr6);
1177
1181
1182 return cpl_error_get_code();
1183}
1184
1185/*----------------------------------------------------------------------------*/
1189/*----------------------------------------------------------------------------*/
1190int main(void)
1191{
1192 cpl_test_init(PACKAGE_BUGREPORT, CPL_MSG_WARNING);
1193
1194 hdrl_image_to_vector_test();
1195 hdrl_imagelist_to_vector_test();
1196 hdrl_imagelist_cplwrap();
1197 hdrl_normalize_test();
1198 hdrl_normalize_image_test();
1199 hdrl_path_test();
1200 hdrl_string_test();
1201 hdrl_pfilter_test();
1202 hdrl_pconvert_test();
1203 hdrl_airmass_test();
1204 hdrl_license_test();
1205 hdrl_region_test();
1206
1207 return cpl_test_end(0);
1208}
cpl_imagelist * hdrl_bpm_filter_list(const cpl_imagelist *inlist, cpl_size kernel_nx, cpl_size kernel_ny, cpl_filter_mode filter)
Wrapper around hdrl_bpm_filter() to filter list of images.
hdrl_parameter * hdrl_collapse_mean_parameter_create(void)
create a parameter object for mean
void hdrl_imagelist_delete(hdrl_imagelist *himlist)
Free all memory used by a hdrl_imagelist object including the images.
hdrl_imagelist * hdrl_imagelist_new(void)
Create an empty imagelist.
void hdrl_parameter_delete(hdrl_parameter *obj)
shallow delete of a parameter
const char * hdrl_get_license(void)
Get the pipeline copyright and license.
Definition: hdrl_utils.c:68
hdrl_value hdrl_utils_airmass(hdrl_value aRA, hdrl_value aDEC, hdrl_value aLST, hdrl_value aExptime, hdrl_value aLatitude, hdrl_airmass_approx type)
Compute the effective airmass of an observation. Takes in count the error propagation if you enter th...
Definition: hdrl_utils.c:2069
cpl_error_code hdrl_rect_region_parameter_verify(const hdrl_parameter *param, const cpl_size max_x, const cpl_size max_y)
Verify basic correctness of the parameters.
Definition: hdrl_utils.c:560
cpl_error_code hdrl_rect_region_parameter_update(hdrl_parameter *rect_region, cpl_size llx, cpl_size lly, cpl_size urx, cpl_size ury)
Update Rect Region Parameters object.
Definition: hdrl_utils.c:485
cpl_parameterlist * hdrl_rect_region_parameter_create_parlist(const char *base_context, const char *prefix, const char *name_prefix, const hdrl_parameter *defaults)
Create parameter list for hdrl_rect_region.
Definition: hdrl_utils.c:615
cpl_error_code hdrl_rect_region_fix_negatives(hdrl_parameter *rect_region, const cpl_size nx, const cpl_size ny)
wrap negative or zero coordinates around full image size
Definition: hdrl_utils.c:715
hdrl_parameter * hdrl_rect_region_parameter_create(cpl_size llx, cpl_size lly, cpl_size urx, cpl_size ury)
Creates Rect Region Parameters object.
Definition: hdrl_utils.c:459
cpl_size hdrl_rect_region_get_llx(const hdrl_parameter *p)
get lower left x coordinate of rectangual region
Definition: hdrl_utils.c:518
cpl_size hdrl_rect_region_get_urx(const hdrl_parameter *p)
get upper right x coordinate of rectangular region
Definition: hdrl_utils.c:536
cpl_size hdrl_rect_region_get_lly(const hdrl_parameter *p)
get lower left y coordinate of rectangual region
Definition: hdrl_utils.c:527
char * hdrl_join_string(const char *sep_, int n,...)
join strings together
Definition: hdrl_utils.c:812
cpl_size hdrl_rect_region_get_ury(const hdrl_parameter *p)
get upper right y coordinate of rectangual region
Definition: hdrl_utils.c:545
hdrl_parameter * hdrl_rect_region_parameter_parse_parlist(const cpl_parameterlist *parlist, const char *base_context, const char *name_prefix)
parse parameterlist for rectangle parameters
Definition: hdrl_utils.c:674
cpl_boolean hdrl_rect_region_parameter_check(const hdrl_parameter *self)
Check that the parameter is hdrl_rect_region parameter.
Definition: hdrl_utils.c:506