CR2RE Pipeline Reference Manual 1.6.7
hdrl_overscan-test.c
1/*
2 * This file is part of the HDRL
3 * Copyright (C) 2012,2013 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 02110-1301 USA
18 */
19
20#ifdef HAVE_CONFIG_H
21#include <config.h>
22#endif
23
24/*-----------------------------------------------------------------------------
25 Includes
26 -----------------------------------------------------------------------------*/
27
28#include "hdrl.h"
29#include "hdrl_utils.h"
30#include "hdrl_test.h"
31#include "hdrl_overscan_defs.h"
32
33#include "hdrl_collapse.h" //TMP
34#include <cpl.h>
35
36#include <math.h>
37#include <stdlib.h>
38
39/*-----------------------------------------------------------------------------
40 Define
41 -----------------------------------------------------------------------------*/
42
43typedef enum {
44 HDRL_OSCAN_COLLAPSE_TEST_MEAN,
45 HDRL_OSCAN_COLLAPSE_TEST_MEDIAN,
46 HDRL_OSCAN_COLLAPSE_TEST_WEIGHTED_MEAN,
47 HDRL_OSCAN_COLLAPSE_TEST_SIGCLIP,
48 HDRL_OSCAN_COLLAPSE_TEST_MINMAX
49} hdrl_oscan_collapse_test ;
50
51/*----------------------------------------------------------------------------*/
55/*----------------------------------------------------------------------------*/
56
57void test_parlist(void)
58{
59 /* parameter parsing smoketest */
60 hdrl_parameter * hpar;
61 hdrl_parameter * rect_region_def =
63 hdrl_parameter * sigclip_def =
65 hdrl_parameter * minmax_def =
67 hdrl_parameter * mode_def =
68 hdrl_collapse_mode_parameter_create(10., 1., 0., HDRL_MODE_MEDIAN, 0);
69
70 cpl_parameterlist * pos = hdrl_overscan_parameter_create_parlist(
71 "RECIPE", "oscan", "alongX", 10, 10., rect_region_def,
72 "MINMAX", sigclip_def, minmax_def, mode_def);
73 hdrl_parameter_delete(mode_def);
74 hdrl_parameter_delete(sigclip_def);
75 hdrl_parameter_delete(minmax_def);
76 hdrl_parameter_delete(rect_region_def);
77 cpl_test_error(CPL_ERROR_NONE);
78 /*
79 Before adding the mode method:
80 cpl_test_eq(cpl_parameterlist_get_size(pos), 13);
81 */
82
83 cpl_test_eq(cpl_parameterlist_get_size(pos), 13 + 5);
84
85 hpar = hdrl_overscan_parameter_parse_parlist(pos, "RECIPE.invalid");
86 cpl_test_null(hpar);
87 cpl_test_error(CPL_ERROR_DATA_NOT_FOUND);
88
89 hpar = hdrl_overscan_parameter_parse_parlist(pos, "RECIPE.oscan");
90 cpl_parameterlist_delete(pos);
91 cpl_test_error(CPL_ERROR_NONE);
92 {
93 hdrl_parameter * rect = hdrl_overscan_parameter_get_rect_region(hpar);
94 cpl_test_eq(hdrl_rect_region_get_llx(rect), 1);
95 cpl_test_eq(hdrl_rect_region_get_lly(rect), 1);
96 cpl_test_eq(hdrl_rect_region_get_urx(rect), 20);
97 cpl_test_eq(hdrl_rect_region_get_ury(rect), 20);
98 }
99 cpl_test_eq(hdrl_overscan_parameter_get_box_hsize(hpar), 10);
100 cpl_test_eq(hdrl_overscan_parameter_get_ccd_ron(hpar), 10.);
102 HDRL_X_AXIS);
103 {
104 hdrl_parameter * col = hdrl_overscan_parameter_get_collapse(hpar);
106 cpl_test(!hdrl_collapse_parameter_is_mean(col));
107 cpl_test_eq(hdrl_collapse_minmax_parameter_get_nlow(col), 2);
108 cpl_test_eq(hdrl_collapse_minmax_parameter_get_nhigh(col), 3);
109 }
110
112}
113
114/*----------------------------------------------------------------------------*/
119/*----------------------------------------------------------------------------*/
120static cpl_error_code hdrl_overscan_test_null_input(void)
121{
122 hdrl_parameter * os_region;
123 hdrl_parameter * os_collapse;
124 hdrl_parameter * os_param;
125 hdrl_overscan_compute_result * overscan_computation;
126
127 /* Overscan Parameters */
128 os_region = hdrl_rect_region_parameter_create(1, 1, 1, 1) ;
130 os_param = hdrl_overscan_parameter_create(HDRL_Y_AXIS, 1., 1,
131 os_collapse, os_region) ;
132 cpl_test(hdrl_overscan_parameter_check(os_param));
133
134 /* test functionality */
135 overscan_computation = hdrl_overscan_compute(NULL, os_param) ;
136 hdrl_parameter_delete(os_region) ;
137 hdrl_parameter_delete(os_collapse) ;
138 hdrl_parameter_delete(os_param) ;
139
140 cpl_test_null(overscan_computation);
141
142 hdrl_overscan_compute_result_delete(overscan_computation);
143 return cpl_error_get_code();
144}
145
146/*----------------------------------------------------------------------------*/
151/*----------------------------------------------------------------------------*/
152static cpl_error_code hdrl_overscan_test_null_region(void)
153{
154 cpl_image * image_data;
155 hdrl_parameter * os_region = NULL;
156 hdrl_parameter * os_collapse;
157 hdrl_parameter * os_param;
158 hdrl_overscan_compute_result * overscan_computation;
159
160 /* create input structures (on purpose not the input region) */
161 image_data = cpl_image_new(1, 1, CPL_TYPE_DOUBLE);
162
163 /* Overscan Parameters */
165 os_param = hdrl_overscan_parameter_create(HDRL_Y_AXIS, 1., 1,
166 os_collapse, os_region) ;
167
168 /* test functionality */
169 overscan_computation = hdrl_overscan_compute(image_data, os_param);
170 cpl_image_delete(image_data);
171 hdrl_parameter_delete(os_collapse) ;
172 hdrl_parameter_delete(os_param) ;
173 cpl_test_null(overscan_computation);
174
175 hdrl_overscan_compute_result_delete(overscan_computation);
176
177 return cpl_error_get_code();
178}
179
180/*----------------------------------------------------------------------------*/
185/*----------------------------------------------------------------------------*/
186static cpl_error_code hdrl_overscan_test_null_sigclip(void)
187{
188 cpl_image * image_data;
189 hdrl_parameter * os_region;
190 hdrl_parameter * os_collapse = NULL;
191 hdrl_parameter * os_param;
192 hdrl_overscan_compute_result * overscan_computation;
193
194 /* create input structures (on purpose not the input region) */
195 image_data = cpl_image_new(1, 1, CPL_TYPE_DOUBLE);
196
197 /* Overscan Parameters */
198 os_region = hdrl_rect_region_parameter_create(1, 1, 1, 1) ;
199 os_param = hdrl_overscan_parameter_create(HDRL_Y_AXIS, 1., 1,
200 os_collapse, os_region) ;
201
202 /* test functionality */
203 overscan_computation = hdrl_overscan_compute(image_data, os_param);
204 cpl_image_delete(image_data);
205 hdrl_parameter_delete(os_region) ;
206 hdrl_parameter_delete(os_param) ;
207 cpl_test_null(overscan_computation);
208
209 hdrl_overscan_compute_result_delete(overscan_computation);
210
211 return cpl_error_get_code();
212}
213
214/*----------------------------------------------------------------------------*/
219/*----------------------------------------------------------------------------*/
220static cpl_error_code hdrl_overscan_test_null_params(void)
221{
222 cpl_image* image_data = cpl_image_new(1, 1, CPL_TYPE_DOUBLE);
223 hdrl_overscan_compute_result * overscan_computation;
224
225 /* test functionality */
226 overscan_computation = hdrl_overscan_compute(image_data, NULL);
227 cpl_test_null(overscan_computation);
228
229 hdrl_overscan_compute_result_delete(overscan_computation);
230 cpl_image_delete(image_data);
231
232 return cpl_error_get_code();
233}
234
235/*----------------------------------------------------------------------------*/
240/*----------------------------------------------------------------------------*/
241static cpl_error_code hdrl_overscan_test_wrong_region(void)
242{
243 hdrl_parameter * os_region;
244 hdrl_parameter * os_collapse;
245 hdrl_parameter * os_param;
246 cpl_image * image_data;
247 hdrl_overscan_compute_result * computation;
248
249 /* create input image */
250 image_data = cpl_image_new(5, 10, CPL_TYPE_DOUBLE);
251
252 /* Overscan Parameters */
253 /* Initialize a region outside the bounds of the image */
254 os_region = hdrl_rect_region_parameter_create(1, 1, 5, 10) ;
256 os_param = hdrl_overscan_parameter_create(HDRL_Y_AXIS, 1., 1,
257 os_collapse, os_region) ;
258
259 /* Run it and check */
260 hdrl_rect_region_parameter_update(os_region, 0, 2, 4, 2) ;
261
262 computation = hdrl_overscan_compute(image_data, os_param) ;
263 cpl_test_null(computation);
264 cpl_test_eq_error(cpl_error_get_code(), CPL_ERROR_ILLEGAL_INPUT);
265
266 /* Initialize a region with size exceeding the X size of the image */
267 hdrl_rect_region_parameter_update(os_region, 1, 5, 6, 10) ;
268
269 // TODO yves fix and reenable
270 //computation = hdrl_overscan_compute(image_data, os_param) ;
271 //cpl_test_null(computation);
272 //cpl_test_eq_error(cpl_error_get_code(), CPL_ERROR_ILLEGAL_INPUT);
273
274 /* Destroy and return */
275 hdrl_parameter_delete(os_region) ;
276 hdrl_parameter_delete(os_collapse) ;
277 hdrl_parameter_delete(os_param) ;
278 cpl_image_delete(image_data);
279
280 return cpl_error_get_code();
281}
282
283/*----------------------------------------------------------------------------*/
288/*----------------------------------------------------------------------------*/
289static double hdrl_overscan_test_uniform_image(const double inp_value)
290{
291 double out_value = 0;
292 cpl_image * image_data;
293 cpl_image * image_errs;
294 hdrl_image * image;
295 hdrl_overscan_compute_result * comp_res;
296 hdrl_overscan_correct_result * overscan_correction;
297 hdrl_parameter * os_region;
298 hdrl_parameter * os_collapse;
299 hdrl_parameter * os_param;
300
301 /* Create input structures (on purpose not the input region) */
302 image_data = cpl_image_new(100, 100, HDRL_TYPE_DATA);
303 cpl_image_add_scalar(image_data, inp_value);
304 image_errs = cpl_image_new(100, 100, HDRL_TYPE_ERROR);
305 cpl_image_add_scalar(image_errs, inp_value);
306 cpl_image_power(image_errs, 0.5);
307 image = hdrl_image_wrap(image_data, image_errs, NULL, CPL_FALSE);
308
309 /* Overscan Parameters */
310 os_region = hdrl_rect_region_parameter_create(1, 1, 100, 100) ;
312 os_param = hdrl_overscan_parameter_create(HDRL_Y_AXIS, 1., 5,
313 os_collapse, os_region) ;
314
315 /* Compute the Overscan correction */
316 comp_res = hdrl_overscan_compute(image_data, os_param);
317 cpl_test_nonnull(comp_res);
318
319 hdrl_parameter_delete(os_region) ;
320 hdrl_parameter_delete(os_collapse) ;
321 hdrl_parameter_delete(os_param) ;
322
323 out_value = cpl_image_get_mean(
324 hdrl_image_get_image(comp_res->correction));
325 cpl_test_abs(out_value, inp_value, HDRL_EPS_DATA);
326
327 overscan_correction = hdrl_overscan_correct(image, NULL, comp_res);
328 cpl_test_nonnull(overscan_correction);
329
331 hdrl_overscan_correct_result_delete(overscan_correction);
332 hdrl_image_delete(image);
333 return out_value;
334}
335
336/*----------------------------------------------------------------------------*/
341/*----------------------------------------------------------------------------*/
342static cpl_error_code hdrl_overscan_test_dir(cpl_size Nx, cpl_size Ny, int hbox)
343{
344 const double error = 10;
345 hdrl_image * image = hdrl_image_new(Nx, Ny);
346 cpl_image * image_data = hdrl_image_get_image(image);
347 cpl_image * image_errs = hdrl_image_get_error(image);
348 hdrl_parameter * os_region = NULL;
349 hdrl_parameter * os_collapse = NULL;
350 hdrl_parameter * os_param = NULL;
351 hdrl_overscan_compute_result * res_os_comp = NULL;
352 hdrl_overscan_compute_result * res_os_comp_turn = NULL;
353 hdrl_overscan_correct_result * res_os_cor = NULL;
354 hdrl_overscan_correct_result * res_os_cor_turn = NULL;
355 int rej;
356
357 cpl_msg_info(cpl_func, "check mean hbox %d, Nx %ld, Ny %ld",
358 hbox, (long)Nx, (long)Ny);
359
360 /* create image incrementing in x axis, constant in y axis */
361 for (cpl_size x = 0; x < Nx; x++) {
362 for (cpl_size y = 0; y < Ny; y++) {
363 cpl_image_set(image_data, x + 1, y + 1, x);
364 cpl_image_set(image_errs, x + 1, y + 1, x);
365 }
366 }
367 cpl_image_power(image_errs, 0.5);
368
369 /* Overscan Parameters */
370 os_region = hdrl_rect_region_parameter_create(1, 1, Nx, Ny) ;
372 os_param = hdrl_overscan_parameter_create(HDRL_Y_AXIS,
373 error * sqrt(Ny * (1 + 2 * hbox)), hbox, os_collapse, os_region) ;
374
375 /* test compute y direction */
376 res_os_comp = hdrl_overscan_compute(image_data, os_param);
377 cpl_test_error(CPL_ERROR_NONE);
378
379 {
380 /* in y direction overscan has same incremental pattern as input */
381 cpl_image * ex = cpl_image_extract(image_data, 1, 1, Nx, 1);
382 /* cpl mean implementation has a rather large error */
383 cpl_test_image_abs(ex, hdrl_image_get_image(res_os_comp->correction),
384 2 * (1 + 2 * hbox) * Ny * HDRL_EPS_DATA);
385
386 /* perfect match => zero chi2 = 0*/
387 if (hbox == 0) {
388 cpl_image_subtract(ex, ex);
389 cpl_test_image_abs(ex, res_os_comp->red_chi2,
390 2 * (1 + 2 * hbox) * Ny * HDRL_EPS_DATA);
391 }
392
393 /* error constant in middle */
394 cpl_image_subtract(ex, ex);
395 cpl_image_add_scalar(ex, error);
396 /* error larger on boundary */
397 for (int i = 0; i < hbox; i++) {
398 double cor = sqrt((1 + 2. * (hbox)) / (1 + 2 * i));
399 cpl_image_set(ex, 1 + i, 1, error * cor);
400 cpl_image_set(ex, Nx - i, 1, error * cor);
401 }
402 cpl_test_image_abs(ex, hdrl_image_get_error(res_os_comp->correction),
403 Ny * HDRL_EPS_ERROR);
404
405 cpl_image_delete(ex);
406 }
407
408 /* test compute x direction */
409
410 hdrl_parameter_delete(os_param) ;
411 os_param = hdrl_overscan_parameter_create(HDRL_X_AXIS,
412 error * sqrt(Nx * (1 + 2 * hbox)), hbox, os_collapse, os_region) ;
413 res_os_comp_turn = hdrl_overscan_compute(image_data, os_param);
414
415 hdrl_parameter_delete(os_region) ;
416 hdrl_parameter_delete(os_collapse) ;
417 hdrl_parameter_delete(os_param) ;
418
419 cpl_test_error(CPL_ERROR_NONE);
420
421 {
422 /* in x direction overscan is the mean of the sum */
423 cpl_image * ex = cpl_image_new(1, Ny, HDRL_TYPE_DATA);
424 cpl_image_add_scalar(ex, (Nx - 1.) / 2.);
425 cpl_test_image_abs(ex,
426 hdrl_image_get_image(res_os_comp_turn->correction),
427 2 * (1 + 2 * hbox) * Nx * HDRL_EPS_DATA);
428
429 /* reduced chi2 so it should be constant with this pattern */
430 cpl_image_subtract(ex, ex);
431 cpl_image_add_scalar(ex, cpl_image_get(res_os_comp_turn->red_chi2,
432 1, 1, &rej));
433 cpl_test_image_abs(ex, res_os_comp_turn->red_chi2,
434 2 * (1 + 2 * hbox) * Nx * HDRL_EPS_DATA);
435
436 /* error constant in middle */
437 cpl_image_subtract(ex, ex);
438 cpl_image_add_scalar(ex, error);
439 /* error larger on boundary */
440 for (int i = 0; i < hbox; i++) {
441 double cor = sqrt((1 + 2. * (hbox)) / (1 + 2 * i));
442 cpl_image_set(ex, 1, 1 + i, error * cor);
443 cpl_image_set(ex, 1, Ny - i, error * cor);
444 }
445 cpl_test_image_abs(ex,
446 hdrl_image_get_error(res_os_comp_turn->correction),
447 3 * Nx * HDRL_EPS_ERROR);
448
449 cpl_image_delete(ex);
450 }
451
452
453 /* test correct y direction */
454 res_os_cor = hdrl_overscan_correct(image, NULL, res_os_comp);
455 cpl_test_error(CPL_ERROR_NONE);
456
457 {
458 /* corrected y direction is just a zero image */
459 cpl_image * ex = cpl_image_new(Nx, Ny, HDRL_TYPE_DATA);
460
461 cpl_test_image_abs(ex, hdrl_image_get_image(res_os_cor->corrected),
462 2 * (1 + 2 * hbox) * Ny * HDRL_EPS_DATA);
463
464 /* gaussian error */
465 for (cpl_size y = 0; y < Ny; y++) {
466 for (cpl_size x = 0; x < Nx; x++) {
467 double val = cpl_image_get(image_errs, x + 1, y + 1, &rej);
468 cpl_image_set(ex, x + 1, y + 1, hypot(error, val));
469 }
470 /* larger on boundaries */
471 for (int i = 0; i < hbox; i++) {
472 double cor = sqrt((1 + 2. * (hbox)) / (1 + 2 * i));
473 double val = cpl_image_get(image_errs, 1 + i, y + 1, &rej);
474 cpl_image_set(ex, 1 + i, y + 1, hypot(error * cor, val));
475 val = cpl_image_get(image_errs, Nx - i, y + 1, &rej);
476 cpl_image_set(ex, Nx - i, y + 1, hypot(error * cor, val));
477 }
478 }
479
480 cpl_test_image_abs(ex, hdrl_image_get_error(res_os_cor->corrected),
481 Ny * HDRL_EPS_ERROR);
482
483 cpl_image_delete(ex);
484 }
485
486 res_os_cor_turn = hdrl_overscan_correct(image, NULL, res_os_comp_turn);
487 cpl_test_error(CPL_ERROR_NONE);
488
489 {
490 /* overscan in x direction constant over whole axis */
491 cpl_image * ex = cpl_image_duplicate(image_data);
492 cpl_image_subtract_scalar(ex,
493 hdrl_image_get_pixel(res_os_comp_turn->correction, 1, 1,
494 &rej).data);
495 cpl_test_image_abs(ex, hdrl_image_get_image(res_os_cor_turn->corrected),
496 2 * (1 + 2 * hbox) * Nx * HDRL_EPS_DATA);
497
498 /* gaussian error */
499 for (cpl_size x = 0; x < Nx; x++) {
500 for (cpl_size y = 0; y < Ny; y++) {
501 double val = cpl_image_get(image_errs, x + 1, y + 1, &rej);
502 cpl_image_set(ex, x + 1, y + 1, hypot(error, val));
503 }
504 /* larger on boundaries */
505 for (int i = 0; i < hbox; i++) {
506 double cor = sqrt((1 + 2. * (hbox)) / (1 + 2 * i));
507 double val = cpl_image_get(image_errs, 1 + x, 1 + i, &rej);
508 cpl_image_set(ex, x + 1, 1 + i, hypot(error * cor, val));
509 val = cpl_image_get(image_errs, x + 1, Ny - i, &rej);
510 cpl_image_set(ex, x + 1, Ny - i, hypot(error * cor, val));
511 }
512 }
513
514 cpl_test_image_abs(ex,
515 hdrl_image_get_error(res_os_cor_turn->corrected),
516 3 * Nx * HDRL_EPS_ERROR);
517
518 cpl_image_delete(ex);
519 }
520
522 hdrl_overscan_compute_result_delete(res_os_comp_turn);
525 hdrl_image_delete(image);
526
527 return cpl_error_get_code();
528}
529
530/*----------------------------------------------------------------------------*/
535/*----------------------------------------------------------------------------*/
536static cpl_error_code hdrl_overscan_test_full_hbox(
537 cpl_size Nx,
538 cpl_size Ny)
539{
540 const double error = 10;
541 hdrl_image * image = hdrl_image_new(Nx, Ny);
542 cpl_image * image_data = hdrl_image_get_image(image);
543 cpl_image * image_errs = hdrl_image_get_error(image);
544 hdrl_parameter * os_region = NULL;
545 hdrl_parameter * os_collapse = NULL;
546 hdrl_parameter * os_param = NULL;
547 hdrl_overscan_compute_result * res_os_comp;
548 hdrl_overscan_correct_result * res_os_cor = NULL;
549
550 /* sets overscan to use full region and emit single pixel value */
551 cpl_msg_info(cpl_func, "check mean full box, Nx %ld, Ny %ld",
552 (long)Nx, (long)Ny);
553
554 /* create image incrementing in x axis, constant in y axis */
555 for (cpl_size x = 0; x < Nx; x++) {
556 for (cpl_size y = 0; y < Ny; y++) {
557 cpl_image_set(image_data, x + 1, y + 1, x);
558 cpl_image_set(image_errs, x + 1, y + 1, x);
559 }
560 }
561 cpl_image_power(image_errs, 0.5);
562
563 /* Overscan Parameters */
564 os_region = hdrl_rect_region_parameter_create(1, 1, Nx, Ny);
566
567 /* invalid boxsize */
568 os_param = hdrl_overscan_parameter_create(HDRL_Y_AXIS,
569 error * sqrt(Nx * Ny), -2, os_collapse, os_region);
570
571 hdrl_overscan_compute(image_data, os_param);
572 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
573
574 /* test compute y direction */
575 hdrl_parameter_delete(os_param);
576 os_param = hdrl_overscan_parameter_create(HDRL_Y_AXIS,
577 error * sqrt(Nx * Ny),
578 HDRL_OVERSCAN_FULL_BOX,
579 os_collapse, os_region);
580 res_os_comp = hdrl_overscan_compute(image_data, os_param);
581
582 hdrl_parameter_delete(os_region);
583 hdrl_parameter_delete(os_collapse);
584 hdrl_parameter_delete(os_param);
585
586 cpl_test_error(CPL_ERROR_NONE);
587
588 {
589 /* we expect a row with all the same overscan value */
590 hdrl_image * ex = hdrl_image_new(Nx, 1);
591
592 hdrl_image_add_scalar(ex, (hdrl_value){(Nx - 1.) / 2., error});
593
594 /* cpl mean implementation has a rather large error */
595 hdrl_test_image_abs(ex, res_os_comp->correction,
596 2 * Nx * Ny * HDRL_EPS_DATA);
597 hdrl_test_image_abs(ex, res_os_comp->correction,
598 Nx * Ny * HDRL_EPS_DATA);
599
601 }
602
605
606 hdrl_image_delete(image);
607
608 return cpl_error_get_code();
609}
610
611/*----------------------------------------------------------------------------*/
616/*----------------------------------------------------------------------------*/
617static cpl_error_code hdrl_overscan_test_turn_eq(
618 cpl_size Nx,
619 cpl_size Ny,
620 int hbox,
621 hdrl_oscan_collapse_test method)
622{
623 cpl_ensure_code(method == HDRL_OSCAN_COLLAPSE_TEST_MEAN ||
624 method == HDRL_OSCAN_COLLAPSE_TEST_MEDIAN ||
625 method == HDRL_OSCAN_COLLAPSE_TEST_WEIGHTED_MEAN ||
626 method == HDRL_OSCAN_COLLAPSE_TEST_SIGCLIP ||
627 method == HDRL_OSCAN_COLLAPSE_TEST_MINMAX,
628 CPL_ERROR_ILLEGAL_INPUT);
629
630 hdrl_parameter *os_collapse = NULL;
631 if (method == HDRL_OSCAN_COLLAPSE_TEST_MEAN) {
632 cpl_msg_info(cpl_func, "Mean method hbox %d, Nx %ld, Ny %ld",
633 hbox, (long)Nx, (long)Ny);
635 } else if (method == HDRL_OSCAN_COLLAPSE_TEST_MEDIAN) {
636 cpl_msg_info(cpl_func, "Median method hbox %d, Nx %ld, Ny %ld",
637 hbox, (long)Nx, (long)Ny);
639 } else if (method == HDRL_OSCAN_COLLAPSE_TEST_WEIGHTED_MEAN) {
640 cpl_msg_info(cpl_func, "Weighted Median method hbox %d, Nx %ld, Ny %ld",
641 hbox, (long)Nx, (long)Ny);
643 } else if (method == HDRL_OSCAN_COLLAPSE_TEST_SIGCLIP) {
644 cpl_msg_info(cpl_func, "Sigma-Clipping method hbox %d, Nx %ld, Ny %ld",
645 hbox, (long)Nx, (long)Ny);
646 os_collapse = hdrl_collapse_sigclip_parameter_create(3., 3., 3) ;
647 } else if (method == HDRL_OSCAN_COLLAPSE_TEST_MINMAX) {
648 cpl_msg_info(cpl_func, "MinMax method hbox %d, Nx %ld, Ny %ld",
649 hbox, (long)Nx, (long)Ny);
650 os_collapse = hdrl_collapse_minmax_parameter_create(3, 3);
651 }
652
653
654 const double error = 10;
655
656 hdrl_image *image = hdrl_image_new(Nx, Ny);
657 hdrl_image *image_t;
658
659 cpl_image * image_data = hdrl_image_get_image(image);
660 cpl_image * image_errs = hdrl_image_get_error(image);
661
662 hdrl_parameter *os_region = NULL;
663 hdrl_parameter *os_param = NULL;
664
665 hdrl_overscan_compute_result *res_os_comp = NULL;
666 hdrl_overscan_compute_result *res_os_comp_turn = NULL;
667 hdrl_overscan_correct_result *res_os_cor = NULL;
668 hdrl_overscan_correct_result *res_os_cor_turn = NULL;
669
670 for (cpl_size x = 0; x < Nx; x++) {
671 for (cpl_size y = 0; y < Ny; y++) {
672 /* small range due to missing cpl_test_img_rel */
673 double v = (50 - rand() % 100) / (double)((rand() % 50) + 1);
674 cpl_image_set(image_data, x + 1, y + 1, v);
675 cpl_image_set(image_errs, x + 1, y + 1, fabs(v));
676 }
677 }
678 cpl_image_power(image_errs, 0.5);
679 image_t = hdrl_image_duplicate(image);
680 hdrl_image_turn(image_t, +1);
681
682
683
684 /* Overscan Parameters */
685 os_region = hdrl_rect_region_parameter_create(1, 1, Nx, Ny) ;
686 os_param = hdrl_overscan_parameter_create(HDRL_Y_AXIS,
687 error * sqrt(Ny * (1 + 2 * hbox)), hbox, os_collapse, os_region) ;
688
689 /* test compute y direction */
690 res_os_comp = hdrl_overscan_compute(image_data, os_param);
691 cpl_test_error(CPL_ERROR_NONE);
692
693 /* test compute x direction */
694 hdrl_rect_region_parameter_update(os_region, 1, 1, Ny, Nx) ;
695 hdrl_parameter_delete(os_param) ;
696 os_param = hdrl_overscan_parameter_create(HDRL_X_AXIS,
697 error * sqrt(Ny * (1 + 2 * hbox)), hbox, os_collapse, os_region) ;
698 res_os_comp_turn = hdrl_overscan_compute(hdrl_image_get_image(image_t),
699 os_param);
700 cpl_test_error(CPL_ERROR_NONE);
701
702 hdrl_parameter_delete(os_region) ;
703 hdrl_parameter_delete(os_collapse) ;
704 hdrl_parameter_delete(os_param) ;
705
706 {
707 hdrl_image * cor_t = hdrl_image_duplicate(res_os_comp_turn->correction);
708 cpl_image * con_t = cpl_image_duplicate(res_os_comp_turn->contribution);
709 cpl_image * chi_t = cpl_image_duplicate(res_os_comp_turn->red_chi2);
710 hdrl_image_turn(cor_t, -1);
711 cpl_image_turn(con_t, -1);
712 cpl_image_turn(chi_t, -1);
713 hdrl_test_image_abs(res_os_comp->correction,
714 cor_t, (1 + hbox) * Ny * HDRL_EPS_DATA);
715 cpl_test_image_abs(res_os_comp->red_chi2, chi_t,
716 (1 + hbox) * Ny * HDRL_EPS_DATA);
717 cpl_test_image_abs(res_os_comp->contribution, con_t, 0);
718 hdrl_image_delete(cor_t);
719 cpl_image_delete(con_t);
720 cpl_image_delete(chi_t);
721 }
722
723 /* test correct y direction */
724 res_os_cor = hdrl_overscan_correct(image, NULL, res_os_comp);
725 cpl_test_error(CPL_ERROR_NONE);
726
727 res_os_cor_turn = hdrl_overscan_correct(image_t, NULL, res_os_comp_turn);
728 cpl_test_error(CPL_ERROR_NONE);
729
730 hdrl_image_turn(res_os_cor_turn->corrected, -1);
731 hdrl_test_image_abs(res_os_cor->corrected, res_os_cor_turn->corrected,
732 (1 + hbox) * Ny * HDRL_EPS_DATA);
733
734 /* Get corrected */
735 hdrl_image *imgCorrected1 = hdrl_overscan_correct_result_get_corrected(res_os_cor);
736 cpl_test_error(CPL_ERROR_NONE);
737 cpl_test_nonnull(imgCorrected1);
738 hdrl_image *imgCorrected2 = hdrl_overscan_correct_result_unset_corrected(res_os_cor);
739 cpl_test_error(CPL_ERROR_NONE);
740 cpl_test_nonnull(imgCorrected2);
741 hdrl_image_delete(imgCorrected2);
742
743 /* Get badmask */
744 cpl_image *cpImgBadMask_1 = hdrl_overscan_correct_result_get_badmask(res_os_cor);
745 cpl_test_error(CPL_ERROR_NONE);
746 cpl_test_nonnull(cpImgBadMask_1);
747 cpl_image *cpImgBadMask_2 = hdrl_overscan_correct_result_unset_badmask(res_os_cor);
748 cpl_test_error(CPL_ERROR_NONE);
749 cpl_test_nonnull(cpImgBadMask_2);
750 cpl_image_delete(cpImgBadMask_2);
751
752
754 hdrl_overscan_compute_result_delete(res_os_comp_turn);
757 hdrl_image_delete(image);
758 hdrl_image_delete(image_t);
759
760 return cpl_error_get_code();
761}
762
763/*----------------------------------------------------------------------------*/
768/*----------------------------------------------------------------------------*/
769static cpl_error_code hdrl_overscan_test_empty_box(
770 hdrl_oscan_collapse_test method)
771{
772
773 cpl_ensure_code(method == HDRL_OSCAN_COLLAPSE_TEST_MEAN ||
774 method == HDRL_OSCAN_COLLAPSE_TEST_MEDIAN ||
775 method == HDRL_OSCAN_COLLAPSE_TEST_WEIGHTED_MEAN ||
776 method == HDRL_OSCAN_COLLAPSE_TEST_SIGCLIP ||
777 method == HDRL_OSCAN_COLLAPSE_TEST_MINMAX,
778 CPL_ERROR_ILLEGAL_INPUT);
779
780 /* Overscan Parameters */
781 hdrl_parameter *os_collapse = NULL;
782 if(method == HDRL_OSCAN_COLLAPSE_TEST_MEAN) {
783 cpl_msg_info(cpl_func, "check empty box MEAN");
785 } else if (method == HDRL_OSCAN_COLLAPSE_TEST_MEDIAN) {
786 cpl_msg_info(cpl_func, "check empty box MEDIAN");
788 } else if (method == HDRL_OSCAN_COLLAPSE_TEST_WEIGHTED_MEAN) {
789 cpl_msg_info(cpl_func, "check empty box WEIGHTED_MEAN");
791 } else if (method == HDRL_OSCAN_COLLAPSE_TEST_SIGCLIP) {
792 cpl_msg_info(cpl_func, "check empty box SIGCLIP");
793 os_collapse = hdrl_collapse_sigclip_parameter_create(3., 3., 3);
794 } else if (method == HDRL_OSCAN_COLLAPSE_TEST_MINMAX) {
795 cpl_msg_info(cpl_func, "check empty box MINMAX");
796 os_collapse = hdrl_collapse_minmax_parameter_create(3, 3);
797 }
798
799 cpl_size Nx = 10;
800 cpl_size Ny = 10;
801 cpl_image *image_data = cpl_image_new(Nx, Ny, HDRL_TYPE_DATA);
802
803 hdrl_parameter *os_region = hdrl_rect_region_parameter_create(1, 1, Nx, Ny);
804 hdrl_parameter *os_param = hdrl_overscan_parameter_create(
805 HDRL_Y_AXIS, 1., 0, os_collapse, os_region);
806
807 /* reject one row (= one box */
808 for (cpl_size i = 0; i < Ny; i++) cpl_image_reject(image_data, 2, i + 1);
809
810 /* test compute y direction */
811 hdrl_overscan_compute_result *res_os_comp;
812 res_os_comp = hdrl_overscan_compute(image_data, os_param);
813 cpl_test_error(CPL_ERROR_NONE);
814
815
816 hdrl_parameter_delete(os_region);
817 hdrl_parameter_delete(os_collapse);
818 hdrl_parameter_delete(os_param);
819
820
821 int rej;
822 cpl_test_eq(cpl_image_get(res_os_comp->contribution, 2, 1, &rej), 0);
823 cpl_test(hdrl_image_is_rejected(res_os_comp->correction, 2, 1));
824 cpl_test(cpl_image_is_rejected(res_os_comp->red_chi2, 2, 1));
825
826 /* Get correction */
827 hdrl_image *img1 = hdrl_overscan_compute_result_get_correction(res_os_comp);
828 cpl_test_error(CPL_ERROR_NONE);
829 cpl_test_nonnull(img1);
830 hdrl_image *img2 = hdrl_overscan_compute_result_unset_correction(res_os_comp);
831 cpl_test_error(CPL_ERROR_NONE);
832 cpl_test_nonnull(img2);
833 hdrl_image_delete(img2);
834
835 /* Get contribution */
836 cpl_image *cpImg1 = hdrl_overscan_compute_result_get_contribution(res_os_comp);
837 cpl_test_error(CPL_ERROR_NONE);
838 cpl_test_nonnull(cpImg1);
839 cpl_image *cpImg2 = hdrl_overscan_compute_result_unset_contribution(res_os_comp);
840 cpl_test_error(CPL_ERROR_NONE);
841 cpl_test_nonnull(cpImg2);
842 cpl_image_delete(cpImg2);
843
844 /* Get chi2 */
845 cpl_image *cpImgCh2_1 = hdrl_overscan_compute_result_get_chi2(res_os_comp);
846 cpl_test_error(CPL_ERROR_NONE);
847 cpl_test_nonnull(cpImgCh2_1);
848 cpl_image *cpImgCh2_2 = hdrl_overscan_compute_result_unset_chi2(res_os_comp);
849 cpl_test_error(CPL_ERROR_NONE);
850 cpl_test_nonnull(cpImgCh2_2);
851 cpl_image_delete(cpImgCh2_2);
852
853 /* Get red chi2 */
854 cpl_image *cpImgRedCh2_1 = hdrl_overscan_compute_result_get_red_chi2(res_os_comp);
855 cpl_test_error(CPL_ERROR_NONE);
856 cpl_test_nonnull(cpImgRedCh2_1);
857 cpl_image *cpImgRedCh2_2 = hdrl_overscan_compute_result_unset_red_chi2(res_os_comp);
858 cpl_test_error(CPL_ERROR_NONE);
859 cpl_test_nonnull(cpImgRedCh2_2);
860 cpl_image_delete(cpImgRedCh2_2);
861
862
863 /* Overscan Parameters - SigClip and MinMax*/
864
865 if (method == HDRL_OSCAN_COLLAPSE_TEST_SIGCLIP) {
866
867 /* Get overscan SigClip Low */
868 cpl_image *cpImgSGLow_1 = hdrl_overscan_compute_result_get_sigclip_reject_low(res_os_comp);
869 cpl_test_error(CPL_ERROR_NONE);
870 cpl_test_nonnull(cpImgSGLow_1);
871 cpl_image *cpImgSGLow_2 = hdrl_overscan_compute_result_unset_sigclip_reject_low(res_os_comp);
872 cpl_test_error(CPL_ERROR_NONE);
873 cpl_test_nonnull(cpImgSGLow_2);
874 cpl_image_delete(cpImgSGLow_2);
875
876 /* Get overscan SigClip High */
877 cpl_image *cpImgSGHigh_1 = hdrl_overscan_compute_result_get_sigclip_reject_high(res_os_comp);
878 cpl_test_error(CPL_ERROR_NONE);
879 cpl_test_nonnull(cpImgSGHigh_1);
880 cpl_image *cpImgSGHigh_2 = hdrl_overscan_compute_result_unset_sigclip_reject_high(res_os_comp);
881 cpl_test_error(CPL_ERROR_NONE);
882 cpl_test_nonnull(cpImgSGHigh_2);
883 cpl_image_delete(cpImgSGHigh_2);
884
885 } else if (method == HDRL_OSCAN_COLLAPSE_TEST_MINMAX) {
886
887 /* Get overscan MinMax Low */
888 cpl_image *cpImgMMLow_1 = hdrl_overscan_compute_result_get_minmax_reject_low(res_os_comp);
889 cpl_test_error(CPL_ERROR_NONE);
890 cpl_test_nonnull(cpImgMMLow_1);
891 cpl_image *cpImgMMLow_2 = hdrl_overscan_compute_result_unset_minmax_reject_low(res_os_comp);
892 cpl_test_error(CPL_ERROR_NONE);
893 cpl_test_nonnull(cpImgMMLow_2);
894 cpl_image_delete(cpImgMMLow_2);
895
896 /* Get overscan MinMax High */
897 cpl_image *cpImgMMHigh_1 = hdrl_overscan_compute_result_get_minmax_reject_high(res_os_comp);
898 cpl_test_error(CPL_ERROR_NONE);
899 cpl_test_nonnull(cpImgMMHigh_1);
900 cpl_image *cpImgMMHigh_2 = hdrl_overscan_compute_result_unset_minmax_reject_high(res_os_comp);
901 cpl_test_error(CPL_ERROR_NONE);
902 cpl_test_nonnull(cpImgMMHigh_2);
903 cpl_image_delete(cpImgMMHigh_2);
904 }
905
907
908 cpl_image_delete(image_data);
909
910
911 return cpl_error_get_code();
912}
913
914/*----------------------------------------------------------------------------*/
918/*----------------------------------------------------------------------------*/
919int main(void)
920{
921 cpl_test_init(PACKAGE_BUGREPORT, CPL_MSG_WARNING);
922 cpl_error_code code;
923 double inp_value = 0;
924
925 /* parameter parsing tests */
926 test_parlist();
927
928 /* Overscan with NULL input images */
929 code = hdrl_overscan_test_null_input();
930 cpl_test_eq_error(code, CPL_ERROR_NULL_INPUT);
931
932 /* Overscan with NULL region */
933 code = hdrl_overscan_test_null_region();
934 cpl_test_eq_error(code, CPL_ERROR_ILLEGAL_INPUT);
935
936 /* Overscan with NULL sigclip */
937 code = hdrl_overscan_test_null_sigclip();
938 cpl_test_eq_error(code, CPL_ERROR_ILLEGAL_INPUT);
939
940 /* Overscan with NULL control */
941 code = hdrl_overscan_test_null_params();
942 cpl_test_eq_error(code, CPL_ERROR_NULL_INPUT);
943
944 /* Overscan with wrong region */
945 code = hdrl_overscan_test_wrong_region();
946 cpl_test_eq_error(code, CPL_ERROR_NONE);
947
948 /* Check expected results with uniform frame */
949 hdrl_overscan_test_uniform_image(inp_value);
950
951 cpl_size anx[] = {97, 45, 200};
952 cpl_size any[] = {575, 34, 200};
953
954 hdrl_overscan_test_turn_eq(0, 0, 0, -1);
955 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
956
957 for (size_t i = 0; i < sizeof(anx) / sizeof(anx[0]); i++) {
958 cpl_size nx = anx[i];
959 cpl_size ny = any[i];
960
961 for (int hbox = 0; hbox < 12; hbox++) {
962 hdrl_overscan_test_dir(nx, ny, hbox);
963 }
964
965 for (int hbox = 0; hbox < 6; hbox+=2) {
966
967 hdrl_overscan_test_turn_eq(nx, ny, hbox,
968 HDRL_OSCAN_COLLAPSE_TEST_MEAN);
969 cpl_test_error(CPL_ERROR_NONE);
970 hdrl_overscan_test_turn_eq(nx, ny, hbox,
971 HDRL_OSCAN_COLLAPSE_TEST_MEDIAN);
972 cpl_test_error(CPL_ERROR_NONE);
973 hdrl_overscan_test_turn_eq(nx, ny, hbox,
974 HDRL_OSCAN_COLLAPSE_TEST_WEIGHTED_MEAN);
975 cpl_test_error(CPL_ERROR_NONE);
976 hdrl_overscan_test_turn_eq(nx, ny, hbox,
977 HDRL_OSCAN_COLLAPSE_TEST_SIGCLIP);
978 cpl_test_error(CPL_ERROR_NONE);
979 hdrl_overscan_test_turn_eq(nx, ny, hbox,
980 HDRL_OSCAN_COLLAPSE_TEST_MINMAX);
981 cpl_test_error(CPL_ERROR_NONE);
982 }
983
984 hdrl_overscan_test_full_hbox(nx, ny);
985 }
986
987 hdrl_overscan_test_empty_box(-1);
988 cpl_test_error(CPL_ERROR_ILLEGAL_INPUT);
989 hdrl_overscan_test_empty_box(HDRL_OSCAN_COLLAPSE_TEST_MEAN);
990 cpl_test_error(CPL_ERROR_NONE);
991 hdrl_overscan_test_empty_box(HDRL_OSCAN_COLLAPSE_TEST_MEDIAN);
992 cpl_test_error(CPL_ERROR_NONE);
993 hdrl_overscan_test_empty_box(HDRL_OSCAN_COLLAPSE_TEST_WEIGHTED_MEAN);
994 cpl_test_error(CPL_ERROR_NONE);
995 hdrl_overscan_test_empty_box(HDRL_OSCAN_COLLAPSE_TEST_SIGCLIP);
996 cpl_test_error(CPL_ERROR_NONE);
997 hdrl_overscan_test_empty_box(HDRL_OSCAN_COLLAPSE_TEST_MINMAX);
998 cpl_test_error(CPL_ERROR_NONE);
999
1000
1001
1003 //cpl_test(hdrl_overscan_test_uniform_image_and_outliers(),value);
1004
1006 //cpl_test(hdrl_overscan_test_uniform_image_and_noise(),value);
1007
1008 return cpl_test_end(0);
1009}
hdrl_parameter * hdrl_collapse_mean_parameter_create(void)
create a parameter object for mean
hdrl_parameter * hdrl_collapse_sigclip_parameter_create(double kappa_low, double kappa_high, int niter)
create a parameter object for sigclipped mean
hdrl_parameter * hdrl_collapse_weighted_mean_parameter_create(void)
create a parameter object for weighted mean
cpl_boolean hdrl_collapse_parameter_is_mean(const hdrl_parameter *self)
check if parameter is a mean parameter
cpl_boolean hdrl_collapse_parameter_is_minmax(const hdrl_parameter *self)
check if parameter is a minmax mean parameter
double hdrl_collapse_minmax_parameter_get_nlow(const hdrl_parameter *p)
get low value
hdrl_parameter * hdrl_collapse_median_parameter_create(void)
create a parameter object for median
hdrl_parameter * hdrl_collapse_mode_parameter_create(double histo_min, double histo_max, double bin_size, hdrl_mode_type mode_method, cpl_size error_niter)
create a parameter object for the mode
hdrl_parameter * hdrl_collapse_minmax_parameter_create(double nlow, double nhigh)
create a parameter object for min-max rejected mean
double hdrl_collapse_minmax_parameter_get_nhigh(const hdrl_parameter *p)
get high value
hdrl_value hdrl_image_get_pixel(const hdrl_image *self, cpl_size xpos, cpl_size ypos, int *pis_rejected)
get pixel values of hdrl_image
Definition: hdrl_image.c:559
int hdrl_image_is_rejected(hdrl_image *self, cpl_size xpos, cpl_size ypos)
return if pixel is marked bad
Definition: hdrl_image.c:445
cpl_error_code hdrl_image_turn(hdrl_image *self, int rot)
Rotate an image by a multiple of 90 degrees clockwise.
Definition: hdrl_image.c:663
hdrl_image * hdrl_image_duplicate(const hdrl_image *himg)
copy hdrl_image
Definition: hdrl_image.c:391
cpl_error_code hdrl_image_add_scalar(hdrl_image *self, hdrl_value value)
Elementwise addition of a scalar to an image.
cpl_image * hdrl_image_get_error(hdrl_image *himg)
get error as cpl image
Definition: hdrl_image.c:131
cpl_image * hdrl_image_get_image(hdrl_image *himg)
get data as cpl image
Definition: hdrl_image.c:105
hdrl_image * hdrl_image_new(cpl_size nx, cpl_size ny)
create new zero filled hdrl image
Definition: hdrl_image.c:311
void hdrl_image_delete(hdrl_image *himg)
delete hdrl_image
Definition: hdrl_image.c:379
void hdrl_overscan_compute_result_delete(hdrl_overscan_compute_result *result)
Deletes the Overscan Computation Result Structure.
cpl_image * hdrl_overscan_correct_result_get_badmask(const hdrl_overscan_correct_result *res)
Access the bad pixels mask in the Overscan Correction result object.
cpl_image * hdrl_overscan_compute_result_unset_red_chi2(hdrl_overscan_compute_result *res)
Unset the reduced CHI2 in the Overscan Computation result object.
cpl_image * hdrl_overscan_correct_result_unset_badmask(hdrl_overscan_correct_result *res)
Unset the bad pixels mask in the Overscan Correction result object.
cpl_image * hdrl_overscan_compute_result_get_minmax_reject_high(const hdrl_overscan_compute_result *res)
Access the high threshold in the Overscan Computation result object.
cpl_boolean hdrl_overscan_parameter_check(const hdrl_parameter *self)
Check that the parameter is an Overscan parameter.
hdrl_image * hdrl_overscan_correct_result_unset_corrected(hdrl_overscan_correct_result *res)
Unset the corrected image in the Overscan Correction result object.
cpl_image * hdrl_overscan_compute_result_get_red_chi2(const hdrl_overscan_compute_result *res)
Access the reduced CHI2 in the Overscan Computation result object.
cpl_image * hdrl_overscan_compute_result_get_sigclip_reject_low(const hdrl_overscan_compute_result *res)
Access the low threshold in the Overscan Computation result object.
cpl_image * hdrl_overscan_compute_result_get_chi2(const hdrl_overscan_compute_result *res)
Access the CHI2 in the Overscan Computation result object.
hdrl_overscan_compute_result * hdrl_overscan_compute(const cpl_image *source, const hdrl_parameter *params)
Overscan correction computation.
cpl_image * hdrl_overscan_compute_result_unset_chi2(hdrl_overscan_compute_result *res)
Unset the CHI2 in the Overscan Computation result object.
cpl_image * hdrl_overscan_compute_result_unset_minmax_reject_high(hdrl_overscan_compute_result *res)
Unset the high threshold in the Overscan Computation result object.
cpl_image * hdrl_overscan_compute_result_unset_contribution(hdrl_overscan_compute_result *res)
Unset the contribution in the Overscan Computation result object.
cpl_image * hdrl_overscan_compute_result_get_minmax_reject_low(const hdrl_overscan_compute_result *res)
Access the low threshold in the Overscan Computation result object.
hdrl_image * hdrl_overscan_compute_result_unset_correction(hdrl_overscan_compute_result *res)
Unset the correction in the Overscan Computation result object.
hdrl_image * hdrl_overscan_correct_result_get_corrected(const hdrl_overscan_correct_result *res)
Access the corrected image in the Overscan Correction result object.
hdrl_parameter * hdrl_overscan_parameter_get_rect_region(const hdrl_parameter *p)
Access the Overscan Region parameters in the Overscan Parameter.
hdrl_parameter * hdrl_overscan_parameter_get_collapse(const hdrl_parameter *p)
Access the collapse method parameters in the Overscan Parameter.
hdrl_parameter * hdrl_overscan_parameter_create(hdrl_direction correction_direction, double ccd_ron, int box_hsize, hdrl_parameter *collapse, hdrl_parameter *rect_region)
Creates Overscan Parameters object.
hdrl_image * hdrl_overscan_compute_result_get_correction(const hdrl_overscan_compute_result *res)
Access the correction in the Overscan Computation result object.
double hdrl_overscan_parameter_get_ccd_ron(const hdrl_parameter *p)
Access the CCD read out noise in the Overscan Parameter.
hdrl_direction hdrl_overscan_parameter_get_correction_direction(const hdrl_parameter *p)
Access the Correction Direction in the Overscan Parameter.
hdrl_overscan_correct_result * hdrl_overscan_correct(const hdrl_image *source, const hdrl_parameter *region, const hdrl_overscan_compute_result *os_computation)
Overscan correction.
hdrl_parameter * hdrl_overscan_parameter_parse_parlist(const cpl_parameterlist *parlist, const char *prefix)
Parse parameterlist to create input parameters for the Overscan method.
cpl_image * hdrl_overscan_compute_result_get_contribution(const hdrl_overscan_compute_result *res)
Access the contribution in the Overscan Computation result object.
int hdrl_overscan_parameter_get_box_hsize(const hdrl_parameter *p)
Access the Box Half Size in the Overscan Parameter.
cpl_image * hdrl_overscan_compute_result_unset_minmax_reject_low(hdrl_overscan_compute_result *res)
Unset the low threshold in the Overscan Computation result object.
cpl_image * hdrl_overscan_compute_result_get_sigclip_reject_high(const hdrl_overscan_compute_result *res)
Access the high threshold in the Overscan Computation result object.
void hdrl_overscan_correct_result_delete(hdrl_overscan_correct_result *result)
Delete the Overscan Correction Result Structure.
cpl_image * hdrl_overscan_compute_result_unset_sigclip_reject_low(hdrl_overscan_compute_result *res)
Unset the low threshold in the Overscan Computation result object.
cpl_image * hdrl_overscan_compute_result_unset_sigclip_reject_high(hdrl_overscan_compute_result *res)
Unset the high threshold in the Overscan Computation result object.
cpl_parameterlist * hdrl_overscan_parameter_create_parlist(const char *base_context, const char *prefix, const char *corr_dir_def, int box_hsize_def, double ccd_ron_def, hdrl_parameter *rect_region_def, const char *method_def, hdrl_parameter *sigclip_def, hdrl_parameter *minmax_def, hdrl_parameter *mode_def)
Create parameter list for the Overscan computation.
void hdrl_parameter_destroy(hdrl_parameter *obj)
deep delete of a parameter
void hdrl_parameter_delete(hdrl_parameter *obj)
shallow delete of a parameter
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
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
cpl_size hdrl_rect_region_get_ury(const hdrl_parameter *p)
get upper right y coordinate of rectangual region
Definition: hdrl_utils.c:545