ERIS Pipeline Reference Manual 1.9.0
eris_nix_utils.c
1/* $Id$
2 *
3 * This file is part of the ERIS/NIX Pipeline
4 * Copyright (C) 2017 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$
23 * $Date$
24 * $Rev$
25 */
26
27#ifdef HAVE_CONFIG_H
28#include <config.h>
29#endif
30
31/*-----------------------------------------------------------------------------
32 Includes
33 -----------------------------------------------------------------------------*/
34
35#include "eris_nix_utils.h"
36#include "eris_utils.h"
37#include "eris_nix_casu_utils.h"
38#include "eris_nix_dfs.h"
39#include "eris_nix_match.h"
40
41#include <casu_mods.h>
42#include <casu_stats.h>
43#include <hdrl.h>
44#include <libgen.h>
45#include <math.h>
46#include <string.h>
47
48/*----------------------------------------------------------------------------*/
58/*----------------------------------------------------------------------------*/
59
62/*----------------------------------------------------------------------------*/
97/*----------------------------------------------------------------------------*/
98
99cpl_error_code enu_basic_calibrate(located_image * limage,
100 const int read_offsets,
101 const cpl_table * refine_wcs,
102 const master_dark * mdark,
103 const gain_linearity * gain_lin,
104 const master_flat * flatfield_1,
105 const master_flat * flatfield_2,
106 const master_bpm * mbad_pix_map,
107 const int flag_mask,
108 const char * fill_rejected,
109 const double fill_value,
110 const cpl_size x_probe,
111 const cpl_size y_probe) {
112
113 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
114
115 if (limage == NULL) return CPL_ERROR_NONE;
116
117 /* correct the CD matrix if required, same for 'single' or 'cube' data */
118
119 enu_modify_CD_matrix(limage, refine_wcs);
120
121 /* for single images, reduce the image
122 for cube data, reduce each image plane in turn */
123
124 if (limage->himage) {
125 enu_basic_calibrate_himage(limage->himage,
126 limage->confidence,
127 limage->plist,
128 limage->frame,
129 read_offsets,
130 mdark,
131 gain_lin,
132 flatfield_1,
133 flatfield_2,
134 mbad_pix_map,
135 CPL_TRUE,
136 flag_mask,
137 fill_rejected,
138 fill_value,
139 x_probe,
140 y_probe);
141 enu_check_error_code("failure in basic calibration");
142
143 } else if (limage->himagelist) {
144 const cpl_size nplanes = hdrl_imagelist_get_size(limage->himagelist);
145 cpl_error_code didfail = CPL_ERROR_NONE;
146
147#ifdef _OPENMP
148 cpl_errorstate cleanstate = cpl_errorstate_get();
149
150#pragma omp parallel for
151#endif
152 for (cpl_size plane = 0; plane < nplanes; plane++) {
153
154 cpl_error_code errori = cpl_error_get_code();
155
156 /* The total number of iterations must be pre-determined for the
157 parallelism to work. In case of an error we can therefore not
158 break, so instead we skip immediately to the next iteration.
159 FIXME: This check on didfail does not guarantee that only one
160 iteration can cause an error to be dumped, but it is not
161 worse than checking on the thread-local state, errori. */
162 if (didfail) continue;
163
164 do {
165
166 cpl_msg_info(cpl_func, "basic calibrate cube: plane %d",
167 (int)plane);
168
169 /* the confidence array applies to all planes in the cube alike,
170 so only modify it on the first call */
171
172 if (enu_basic_calibrate_himage(hdrl_imagelist_get(limage->himagelist,
173 plane),
174 limage->confidence,
175 limage->plist,
176 limage->frame,
177 read_offsets,
178 mdark,
179 gain_lin,
180 flatfield_1,
181 flatfield_2,
182 mbad_pix_map,
183 (plane == 0),
184 flag_mask,
185 fill_rejected,
186 fill_value,
187 x_probe,
188 y_probe)) {
189 errori = cpl_error_set_message(cpl_func, cpl_error_get_code(),
190 "Cannot process plane %d/%d",
191 (int)plane+1, (int)nplanes);
192 break;
193 }
194 } while (0);
195
196 if (errori) {
197#ifdef _OPENMP
198 /* Cannot access these errors after the join,
199 so dump them now. :-(((((((((((((((((((( */
200 cpl_errorstate_dump(cleanstate, CPL_FALSE, NULL);
201 cpl_errorstate_set(cleanstate);
202
203#pragma omp critical(enu_basic_calibrate)
204#endif
205 didfail = errori;
206 }
207 }
208 if (didfail) (void)cpl_error_set_message(cpl_func, didfail,
209 "Cannot process %d plane(s)",
210 (int)nplanes);
211 }
212
213 cleanup:
214 eris_check_error_code("enu_basic_calibrate");
215 return cpl_error_get_code();
216}
217
218
219/*----------------------------------------------------------------------------*/
255/*----------------------------------------------------------------------------*/
256
257cpl_error_code enu_basic_calibrate_himage(hdrl_image * himage,
258 cpl_image * confidence,
259 cpl_propertylist * plist,
260 const cpl_frame * frame,
261 const int read_offsets,
262 const master_dark * mdark,
263 const gain_linearity * gain_lin,
264 const master_flat * flatfield_1,
265 const master_flat * flatfield_2,
266 const master_bpm * mbad_pix_map,
267 const int set_confidence,
268 const int flag_mask,
269 const char * fill_rejected,
270 const double fill_value,
271 const cpl_size x_probe,
272 const cpl_size y_probe) {
273
274 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
275
276 cpl_ensure_code(himage, CPL_ERROR_NULL_INPUT);
277
278 /* window information */
279
280 cpl_size nx = 0;
281 cpl_size ny = 0;
282 int rot = 0;
283 cpl_size strx = 0;
284 cpl_size stry = 0;
285 cpl_size nx_chip = 0;
286 cpl_size ny_chip = 0;
287 cpl_boolean windowed = 0;
288 enu_get_window_info(&nx,
289 &ny,
290 &rot,
291 &strx,
292 &stry,
293 &nx_chip,
294 &ny_chip,
295 &windowed,
296 plist);
297 enu_check_error_code("failed to read detector window information");
298 if (windowed) {
299 cpl_msg_info(cpl_func, "detector is windowed!");
300 }
301
302 /* is the instrument ERIS or NACO */
303
304 const char * instrume = cpl_propertylist_get_string(plist, "INSTRUME");
305 const cpl_boolean eris = !strcmp(instrume, "ERIS");
306
307 /* probe pixel specified? */
308
309 int probe = CPL_FALSE;
310 if ((x_probe >= 0) && (y_probe >= 0)) {
311 if (x_probe < nx && y_probe < ny) {
312 probe = CPL_TRUE;
313 }
314 }
315
316 if (probe) {
317 int reject = 0;
318 hdrl_value val = hdrl_image_get_pixel(himage,
319 x_probe,
320 y_probe,
321 &reject);
322 cpl_msg_info(cpl_func,
323 "..basic_calibrate probe (%d,%d) entry(v,e,r)=%5.3e %5.3e %d",
324 (int) x_probe, (int)y_probe, val.data, val.error,
325 reject);
326 val = hdrl_image_get_median(himage);
327 cpl_msg_info(cpl_func,
328 "..basic_calibrate probe (median) entry(v,e)=%5.3e %5.3e",
329 val.data, val.error);
330 }
331
332 if (windowed) {
333
334 /* correct wcs centre, this will have to been set assuming the data
335 are full frame */
336
337 cpl_msg_info(cpl_func, "basic calibrate: correcting wcs for windowed data");
338 const double crpix1 = cpl_propertylist_get_double(plist, "CRPIX1");
339 cpl_propertylist_update_double(plist, "CRPIX1",
340 crpix1 - (double)strx + 1.0);
341 const double crpix2 = cpl_propertylist_get_double(plist, "CRPIX2");
342 cpl_propertylist_update_double(plist, "CRPIX2",
343 crpix2 - (double)stry + 1.0);
344 cpl_msg_info(cpl_func, "..crpix %f %f -> %f %f", crpix1, crpix2,
345 crpix1 - (double)strx + 1.0,
346 crpix2 - (double)stry + 1.0);
347 }
348
349 /* read offset removal only applies to ERIS */
350
351 if (read_offsets && eris) {
352 cpl_msg_info(cpl_func, "basic calibrate: removing read-offsets and "
353 "blanking edges");
354 enu_remove_read_offsets(himage, plist, confidence, set_confidence);
355 enu_check_error_code("error removing read-offsets");
356
357 if (probe) {
358 int reject = 0;
359 hdrl_value val = hdrl_image_get_pixel(himage,
360 x_probe,
361 y_probe,
362 &reject);
363 cpl_msg_info(cpl_func,
364 "..basic_calibrate probe (%d,%d) after "
365 "read_offsets(v,e,r)=%5.3e %5.3e %d",
366 (int) x_probe, (int)y_probe,
367 val.data, val.error, reject);
368 val = hdrl_image_get_median(himage);
369 cpl_msg_info(cpl_func,
370 "..basic_calibrate probe (median) after "
371 "read_offsets(v,e)=%5.3e %5.3e", val.data, val.error);
372 }
373 }
374
375 if (mdark) {
376 cpl_msg_info(cpl_func, "basic calibrate: subtracting master dark");
377
378 /* Check that DIT, detector mode and windowing are compatible.
379 Should work for both ERIS and NACO-style keywords */
380
381 int compatible = enu_check_conformance(
382 plist,
383 mdark->plist,
384 "^ESO DET SEQ1 DIT$|"
385 "^ESO DET READ CURNAME$|"
386 "^ESO DET SEQ1 WIN NX$|"
387 "^ESO DET SEQ1 WIN NY$|"
388 "^ESO DET SEQ1 WIN ROT$|"
389 "^ESO DET SEQ1 WIN STRX$|"
390 "^ESO DET SEQ1 WIN STRY$|"
391 "^ESO DET DIT$|"
392 "^ESO DET NCORRS NAME$|"
393 "^ESO DET WIN NX$|"
394 "^ESO DET WIN NY$|"
395 "^ESO DET WIN STARTX$|"
396 "^ESO DET WIN STARTY$");
397 const char * filename = NULL;
398 if (frame) {
399 filename = cpl_frame_get_filename(frame);
400 }
401 if (filename == NULL) {
402 enu_check(compatible, CPL_ERROR_INCOMPATIBLE_INPUT,
403 "MASTER_DARK does not match frame");
404 } else {
405 enu_check(compatible, CPL_ERROR_INCOMPATIBLE_INPUT,
406 "MASTER_DARK does not match %s", filename);
407 }
408
409 /* subtract the dark and copy its gain value to propertylist */
410
411 hdrl_image_sub_image(himage, mdark->dark);
412 double gain = cpl_propertylist_get_double(mdark->plist,
413 "ESO QC GAIN");
414 cpl_propertylist_update_double(plist, "ESO DARK GAIN", gain);
415 cpl_propertylist_set_comment(plist, "ESO DARK GAIN",
416 "GAIN from master_dark [e-/ADU]");
417 enu_check_error_code("error subtracting DARK");
418
419 if (probe) {
420 int reject = 0;
421 hdrl_value val = hdrl_image_get_pixel(himage,
422 x_probe,
423 y_probe,
424 &reject);
425 int reject2 = 0;
426 hdrl_value dark = hdrl_image_get_pixel(mdark->dark,
427 x_probe,
428 y_probe,
429 &reject2);
430 cpl_msg_info(cpl_func,
431 "..basic_calibrate probe (%d,%d) after dark_subtract "
432 "dark(v,e,r)=%5.3e %5.3e %d "
433 "data(v,e,r)=%5.3e %5.3e %d",
434 (int) x_probe, (int)y_probe,
435 dark.data, dark.error, reject2,
436 val.data, val.error, reject);
437 val = hdrl_image_get_median(himage);
438 dark = hdrl_image_get_median(mdark->dark);
439 cpl_msg_info(cpl_func,
440 "..basic_calibrate probe (median) after dark_subtract "
441 "dark(v,e)=%5.3e %5.3e data(v,e)=%5.3e %5.3e",
442 dark.data, dark.error,
443 val.data, val.error);
444 }
445 }
446
447 if (gain_lin) {
448 hdrl_image * himage_copy = NULL;
449
450 /* Apply linearization correction */
451
452 cpl_msg_info(cpl_func, "basic calibrate: linearizing and estimating "
453 "frame variance");
454
455 himage_copy = end_linearize_and_variance_detmon(gain_lin,
456 mdark,
457 himage,
458 plist,
459 x_probe,
460 y_probe);
461 hdrl_image_copy(himage, himage_copy, 1, 1);
462 hdrl_image_delete(himage_copy);
463 enu_check_error_code("error estimating variance");
464
465 /* add saturation level associated with linearisation to the
466 frames propertylists */
467
468 cpl_propertylist_update_double(plist,
469 "ESO DETMON SATURATION",
470 gain_lin->saturation_limit);
471 cpl_propertylist_set_comment(plist,
472 "ESO DETMON SATURATION",
473 "saturation level from "
474 "linearisation [ADU]");
475
476 /* as part of error calculation the data are divided by DIT, so
477 BUNIT -> adu/s */
478
479 cpl_propertylist_update_string(plist, "BUNIT", "adu/s");
480
481 if (probe) {
482 int reject = 0;
483 hdrl_value val = hdrl_image_get_pixel(himage,
484 x_probe,
485 y_probe,
486 &reject);
487 cpl_msg_info(cpl_func,
488 "..basic_calibrate probe (%d,%d) "
489 "after linearize/calc_variance "
490 "data(v,e,r)=%5.3e %5.3e %d",
491 (int) x_probe, (int)y_probe, val.data, val.error,
492 reject);
493 val = hdrl_image_get_median(himage);
494 cpl_msg_info(cpl_func,
495 "..basic_calibrate probe (median) "
496 "after linearize/calc_variance "
497 "data(v,e)=%5.3e %5.3e", val.data, val.error);
498 }
499 }
500
501 if (flatfield_1) {
502 cpl_msg_info(cpl_func, "basic calibrate: dividing by flatfield 1");
503
504 /* the flatfield will cover the full detector, get the part it
505 that covers the detector window of the image */
506
507 /* extract the window */
508
509 hdrl_image * flat_window = !windowed ? NULL :
510 hdrl_image_extract(flatfield_1->flat,
511 strx, stry,
512 strx - 1 + nx,
513 stry - 1 + ny);
514 const hdrl_image * flat_use = !windowed ? flatfield_1->flat
515 : flat_window;
516
517 enu_check_error_code("error extracting window from flatfield 1");
518
519 /* divide by the flat */
520
521 hdrl_image_div_image(himage, flat_use);
522
523 /* update the confidence */
524
525 if (set_confidence) {
526
527 /* copy the confidence array from the flatfield. Set to 0
528 confidence pixels where the image itself is bad. The
529 confidence array itself should have no mask - it and the
530 image mask are 'parallel' descriptions of the bad pixels */
531
532 cpl_image * flat_conf_window = !windowed ? NULL :
533 cpl_image_extract(flatfield_1->confidence,
534 strx, stry,
535 strx - 1 + nx,
536 stry - 1 + ny);
537 const cpl_image * flat_conf_use = !windowed ? flatfield_1->confidence
538 : flat_conf_window;
539
540 enu_check_error_code("error extracting window from flatfield 1 "
541 "confidence");
542 cpl_image_copy(confidence, flat_conf_use, 1, 1);
543 cpl_image_delete(flat_conf_window);
544
545 /* set confidence to 0 where the image mask is already bad */
546 if (cpl_image_get_bpm_const(hdrl_image_get_image(himage))) {
547 cpl_mask * old_mask =
548 cpl_image_set_bpm(confidence,
549 cpl_image_get_bpm(hdrl_image_get_image(himage)));
550 cpl_mask_delete(old_mask);
551 cpl_image_fill_rejected(confidence, 0.0);
552 (void)cpl_image_unset_bpm(confidence);
553 } else {
554 cpl_image_accept_all(confidence); /* FIXME: Is this reachable ? */
555 }
556 }
557
558 enu_check_error_code("error dividing by flatfield 1");
559
560 if (probe) {
561 int reject = 0;
562 hdrl_value val = hdrl_image_get_pixel(himage,
563 x_probe,
564 y_probe,
565 &reject);
566 int reject2 = 0;
567 hdrl_value flat = hdrl_image_get_pixel(flat_use,
568 x_probe,
569 y_probe,
570 &reject2);
571 cpl_msg_info(cpl_func,
572 "..basic_calibrate probe (%d,%d) after flatfield1 "
573 "flat(v,e,r)=%5.3e %5.3e %d "
574 "data(v,e,r)=%5.3e %5.3e %d",
575 (int) x_probe, (int)y_probe,
576 flat.data, flat.error, reject2,
577 val.data, val.error, reject);
578 val = hdrl_image_get_median(himage);
579 flat = hdrl_image_get_median(flat_use);
580 cpl_msg_info(cpl_func,
581 "..basic_calibrate probe (median) after flatfield1 "
582 "flat(v,e)=%5.3e %5.3e data(v,e)=%5.3e %5.3e",
583 flat.data, flat.error,
584 val.data, val.error);
585 }
586
587 hdrl_image_delete(flat_window);
588 }
589
590 if (flatfield_2) {
591 cpl_msg_info(cpl_func, "basic calibrate: dividing by flatfield 2");
592
593 hdrl_image * flat_window = !windowed ? NULL :
594 hdrl_image_extract(flatfield_2->flat,
595 strx, stry,
596 strx - 1 + nx,
597 stry - 1 + ny);
598 const hdrl_image * flat_use = !windowed ? flatfield_2->flat
599 : flat_window;
600
601 enu_check_error_code("error extracting window from flatfield 2");
602
603 hdrl_image_div_image(himage, flat_use);
604
605 if (set_confidence) {
606 cpl_image * flat_conf_window = !windowed ? NULL :
607 cpl_image_extract(flatfield_2->confidence,
608 strx, stry,
609 strx - 1 + nx,
610 stry - 1 + ny);
611 const cpl_image * flat_conf_use = !windowed ? flatfield_2->confidence
612 : flat_conf_window;
613
614 enu_check_error_code("error extracting window from flatfield 1 "
615 "confidence");
616
617 cpl_image_copy(confidence, flat_conf_use, 1, 1);
618 cpl_image_delete(flat_conf_window);
619
620 /* set confidence to 0 where the image mask is already bad */
621 if (cpl_image_get_bpm_const(hdrl_image_get_image(himage))) {
622 cpl_mask * old_mask =
623 cpl_image_set_bpm(confidence,
624 cpl_image_get_bpm(hdrl_image_get_image(himage)));
625 cpl_mask_delete(old_mask);
626 cpl_image_fill_rejected(confidence, 0.0);
627 (void)cpl_image_unset_bpm(confidence);
628 } else {
629 cpl_image_accept_all(confidence); /* FIXME: Is this reachable ? */
630 }
631 }
632
633 enu_check_error_code("error dividing by flatfield 2");
634
635 if (probe) {
636 int reject = 0;
637 hdrl_value val = hdrl_image_get_pixel(himage,
638 x_probe,
639 y_probe,
640 &reject);
641 int reject2 = 0;
642 hdrl_value flat = hdrl_image_get_pixel(flat_use,
643 x_probe,
644 y_probe,
645 &reject2);
646 cpl_msg_info(cpl_func,
647 "..basic_calibrate probe (%d,%d) after flatfield2 "
648 "flat(v,e,r)=%5.3e %5.3e %d "
649 "data(v,e,r)=%5.3e %5.3e %d",
650 (int) x_probe, (int)y_probe,
651 flat.data, flat.error, reject2,
652 val.data, val.error, reject);
653 val = hdrl_image_get_median(himage);
654 flat = hdrl_image_get_median(flat_use);
655 cpl_msg_info(cpl_func,
656 "..basic_calibrate probe (median) after flatfield2 "
657 "flat(v,e)=%5.3e %5.3e data(v,e)=%5.3e %5.3e",
658 flat.data, flat.error,
659 val.data, val.error);
660 }
661 hdrl_image_delete(flat_window);
662 }
663
664 if (mbad_pix_map) {
665 cpl_msg_info(cpl_func, "basic calibrate: associating with master_bpm");
666 cpl_mask * new_mask = en_master_bpm_get_mask(mbad_pix_map, flag_mask);
667
668 /* window the bpm mask appropriate to the image */
669
670 cpl_mask * new_mask_window = !windowed ? NULL :
671 cpl_mask_extract(new_mask,
672 strx, stry,
673 strx - 1 + nx,
674 stry - 1 + ny);
675 const cpl_mask * new_mask_use = !windowed ? new_mask : new_mask_window;
676
677 enu_check_error_code("error extracting window from bpm mask");
678
679 /* 'or' the mbad_pix_map mask with that already on the image */
680
681 cpl_mask * current_mask = hdrl_image_get_mask(himage);
682 cpl_mask_or(current_mask, new_mask_use);
683 enu_check_error_code("error setting new mask");
684
685 if (set_confidence) {
686
687 /* set rejected confidence to zero */
688
689 double * conf_data = cpl_image_get_data(confidence);
690 cpl_binary * mask_data = cpl_mask_get_data(current_mask);
691 cpl_size nx_mask = cpl_mask_get_size_x(current_mask);
692 cpl_size ny_mask = cpl_mask_get_size_y(current_mask);
693 for (cpl_size i = 0; i < nx_mask * ny_mask; i++) {
694 if (mask_data[i] == CPL_BINARY_1) {
695 conf_data[i] = 0.0;
696 }
697 }
698 }
699
700 if (probe) {
701 int reject = 0;
702 hdrl_value val = hdrl_image_get_pixel(himage,
703 x_probe,
704 y_probe,
705 &reject);
706 int ignore = 0;
707 double conf = cpl_image_get(confidence, x_probe, y_probe, &ignore);
708 cpl_msg_info(cpl_func, "..basic_calibrate probe (%d,%d) "
709 "after associate_mask(v,e,r,c)=%5.3e %5.3e %d %5.3e",
710 (int) x_probe, (int)y_probe, val.data, val.error,
711 reject, conf);
712 }
713 cpl_mask_delete(new_mask);
714 cpl_mask_delete(new_mask_window);
715 }
716
717 if (!strcmp(fill_rejected, "noop")) {
718 cpl_msg_info(cpl_func, "not modifying rejected pixels");
719 } else {
720 double fill = 0.0;
721 if (!strcmp(fill_rejected, "set_NaN")) {
722 fill = NAN;
723 cpl_msg_info(cpl_func, "basic calibrate: setting rejected pixels "
724 "to NaN");
725 } else if (!strcmp(fill_rejected, "set_value")) {
726 fill = fill_value;
727 cpl_msg_info(cpl_func, "basic calibrate: setting rejected pixels "
728 "to %f", fill);
729 } else {
730 enu_check(CPL_FALSE, CPL_ERROR_UNSPECIFIED,
731 "bad fill-rejected value: programming error");
732 }
733 cpl_image_fill_rejected(hdrl_image_get_image(himage), fill);
734 cpl_image_fill_rejected(hdrl_image_get_error(himage), fill);
735 enu_check_error_code("error setting rejected pixels to %f",
736 fill_value);
737
738 if (probe) {
739 int reject = 0;
740 hdrl_value val = hdrl_image_get_pixel(himage,
741 x_probe,
742 y_probe,
743 &reject);
744 int ignore = 0;
745 double conf = cpl_image_get(confidence, x_probe, y_probe, &ignore);
746 cpl_msg_info(cpl_func,
747 "..basic_calibrate probe (%d,%d) after "
748 "fill-rejected(v,e,r,c)=%5.3e %5.3e %d %5.3e",
749 (int) x_probe, (int)y_probe, val.data, val.error,
750 reject, conf);
751 }
752 }
753
754 cleanup:
755 eris_check_error_code("enu_basic_calibrate_himage");
756 return cpl_error_get_code();;
757}
758
759
760/*----------------------------------------------------------------------------*/
771/*----------------------------------------------------------------------------*/
772
773hdrl_image * enu_calc_flat(hdrl_imagelist * himlist,
774 const int min_coadds,
775 const hdrl_parameter * collapse_params,
776 const cpl_size filter_size_x,
777 const cpl_size filter_size_y,
778 const hdrl_flat_method method) {
779
780 /* entry check */
781
782 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
783 cpl_ensure(himlist, CPL_ERROR_NULL_INPUT, NULL);
784 cpl_ensure(collapse_params, CPL_ERROR_NULL_INPUT, NULL);
785
786 cpl_image * contribution = NULL;
787 hdrl_parameter * flat_params = NULL;
788 hdrl_image * result = NULL;
789
790 /* verify that we have enough difference results */
791
792 const cpl_size size = hdrl_imagelist_get_size(himlist);
793 enu_check(size >= min_coadds, CPL_ERROR_ILLEGAL_INPUT,
794 "insufficient frames for flat (%d<min:%d)",
795 (int) size, min_coadds);
796
797 /* calculate the flatfield */
798
799 flat_params = hdrl_flat_parameter_create(filter_size_x,
800 filter_size_y,
801 method);
802 if (method == HDRL_FLAT_FREQ_HIGH) {
803 cpl_msg_info(cpl_func, "Calculating high freq flatfield");
804 } else if (method == HDRL_FLAT_FREQ_LOW) {
805 cpl_msg_info(cpl_func, "Calculating low freq flatfield");
806 }
807 cpl_msg_info(cpl_func, "..smoothing filter sizes %d %d",
808 (int)filter_size_x, (int)filter_size_y);
809 hdrl_flat_compute(himlist, NULL, collapse_params,
810 flat_params, &result, &contribution);
811 enu_check_error_code("error computing flat-field");
812
813 cleanup:
814 cpl_image_delete(contribution);
815 hdrl_parameter_delete(flat_params);
816 if (cpl_error_get_code() != CPL_ERROR_NONE) {
817 hdrl_image_delete(result);
818 result = NULL;
819 }
820 eris_check_error_code("enu_calc_flat");
821 return result;
822}
823
824
825/*----------------------------------------------------------------------------*/
836/*----------------------------------------------------------------------------*/
837
838cpl_error_code enu_calc_maglim(const located_image * limage,
839 const double photzp,
840 const double fwhm_pix,
841 double * abmaglim) {
842
843 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
844 cpl_ensure_code(limage, CPL_ERROR_NULL_INPUT);
845 cpl_ensure_code(abmaglim, CPL_ERROR_NULL_INPUT);
846
847 /* bad data in gives bad result */
848 if (fwhm_pix <= 0.0) {
849 *abmaglim = -1.0;
850 return CPL_ERROR_NONE;
851 }
852
853 /* calculate magnitude limit using HDRL */
854 /* ..set mode calculation following HDRL docs example */
855
856 double histo_min = 10.;
857 double histo_max = 1.;
858 histo_min=0;
859 histo_max=0;
860 double bin_size = 0.;
861 cpl_size error_niter = 0;
862 hdrl_mode_type mode_method = HDRL_MODE_MEDIAN;
863 hdrl_parameter * mode_parameter = NULL;
864 mode_parameter = hdrl_collapse_mode_parameter_create(histo_min,
865 histo_max,
866 bin_size,
867 mode_method,
868 error_niter);
869 /* AMO: the following is NOT required */
870 double* pdata = cpl_image_get_data_double(hdrl_image_get_image(limage->himage));
871 double* pconf = cpl_image_get_data_double(limage->confidence);
872 cpl_size sx = hdrl_image_get_size_x(limage->himage);
873 cpl_size sy = hdrl_image_get_size_y(limage->himage);
874 cpl_mask* mask_data = cpl_image_get_bpm(hdrl_image_get_image(limage->himage));
875 cpl_mask* mask_errs = cpl_image_get_bpm(hdrl_image_get_error(limage->himage));
876 cpl_binary* pbpm_data = cpl_mask_get_data(mask_data);
877 cpl_binary* pbpm_errs = cpl_mask_get_data(mask_errs);
878 for(cpl_size indexj = 0; indexj < sy; indexj++) {
879 for(cpl_size indexi = 0; indexi < sx; indexi++) {
880 if(!isfinite(pdata[indexi+indexj*sx]) ) {
881 pbpm_data[indexi+indexj*sx] = CPL_BINARY_1;
882 pbpm_errs[indexi+indexj*sx] = CPL_BINARY_1;
883 pconf[indexi+indexj*sx] = CPL_BINARY_1;
884//cpl_msg_warning(cpl_func,"found bad pixel at : [%lld,%lld]",indexi,indexj);
885 }
886 }
887 }
888
889
890 hdrl_maglim_compute(hdrl_image_get_image(limage->himage),
891 photzp,
892 fwhm_pix,
893 ((int) (3.0 * fwhm_pix) / 2) * 2 + 1,
894 ((int) (3.0 * fwhm_pix) / 2) * 2 + 1,
895 HDRL_IMAGE_EXTEND_MIRROR,
896 mode_parameter,
897 abmaglim);
898 hdrl_parameter_delete(mode_parameter);
899
900 eris_check_error_code("enu_calc_maglim");
901 return cpl_error_get_code();
902}
903
904
905/*----------------------------------------------------------------------------*/
916/*----------------------------------------------------------------------------*/
917
918cpl_error_code enu_calc_pixel_coords(cpl_table * catalogue,
919 const cpl_propertylist * wcs_plist) {
920
921 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
922 cpl_ensure_code(catalogue, CPL_ERROR_NULL_INPUT);
923 cpl_ensure_code(wcs_plist, CPL_ERROR_NULL_INPUT);
924
925 cpl_array * conv_status = NULL;
926 cpl_matrix * ref_phys = NULL;
927 cpl_matrix * ref_world = NULL;
928 cpl_wcs * wcs = NULL;
929
930 /* write files with inputs for regression testing - uncomment if required
931 cpl_propertylist * wcs_plist_copy = cpl_propertylist_duplicate(wcs_plist);
932 cpl_propertylist_erase_regexp(wcs_plist_copy, CPL_WCS_REGEXP, 1);
933 cpl_propertylist_save(wcs_plist_copy, "enu_calc_pixel_coords_test_wcs.fits",
934 CPL_IO_CREATE);
935 cpl_table_save(catalogue, NULL, NULL,
936 "enu_calc_pixel_coords_test_input_table.fits",
937 CPL_IO_CREATE);
938 */
939
940 cpl_size nobj = cpl_table_get_nrow(catalogue);
941 const double * ra = cpl_table_get_data_double_const(catalogue, "RA");
942 const double * dec = NULL;
943// if (cpl_table_has_column(catalogue, "Dec")) {
944// dec = cpl_table_get_data_double_const(catalogue, "Dec");
945// } else if (cpl_table_has_column(catalogue, "DEC")) {
946 if (cpl_table_has_column(catalogue, "DEC")) {
947 dec = cpl_table_get_data_double_const(catalogue, "DEC");
948 }
949 ref_world = cpl_matrix_new(nobj, 2);
950 for (cpl_size iobj = 0; iobj < nobj; iobj++) {
951 cpl_matrix_set(ref_world, iobj, 0, ra[iobj]);
952 cpl_matrix_set(ref_world, iobj, 1, dec[iobj]);
953 }
954
955 wcs = cpl_wcs_new_from_propertylist(wcs_plist);
956
957 cpl_wcs_convert(wcs, ref_world, &ref_phys, &conv_status,
958 CPL_WCS_WORLD2PHYS);
959 enu_check_error_code("failure calculating predicted positions");
960
961 /* Store the predicted positions in columns X_coordinate and
962 Y_coordinate, create thes if necessary */
963
964 if (!cpl_table_has_column(catalogue, "X_coordinate")) {
965 cpl_table_new_column(catalogue, "X_coordinate", CPL_TYPE_DOUBLE);
966 }
967 if (!cpl_table_has_column(catalogue, "Y_coordinate")) {
968 cpl_table_new_column(catalogue, "Y_coordinate", CPL_TYPE_DOUBLE);
969 }
970
971 for (cpl_size iobj = 0; iobj < nobj; iobj++) {
972 cpl_table_set_double(catalogue, "X_coordinate", iobj,
973 cpl_matrix_get(ref_phys, iobj, 0));
974 cpl_table_set_double(catalogue, "Y_coordinate", iobj,
975 cpl_matrix_get(ref_phys, iobj, 1));
976 }
977
978 /* write file with output for regression testing - uncomment if required
979 cpl_table_save(catalogue, NULL, NULL,
980 "enu_calc_pixel_coords_test_output_table.fits",
981 CPL_IO_CREATE);
982 */
983
984 cleanup:
985 cpl_array_delete(conv_status);
986 cpl_matrix_delete(ref_phys);
987 cpl_matrix_delete(ref_world);
988 cpl_wcs_delete(wcs);
989 eris_check_error_code("enu_calc_pixel_coords");
990 return cpl_error_get_code();
991}
992
993
994/*----------------------------------------------------------------------------*/
1009/*----------------------------------------------------------------------------*/
1010
1011hdrl_catalogue_result * enu_catalogue_compute(
1012 const hdrl_image * himage,
1013 const cpl_image * confidence,
1014 const cpl_wcs * wcs,
1015 hdrl_parameter * params) {
1016
1017 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
1018
1019 cpl_ensure(himage, CPL_ERROR_NULL_INPUT, NULL);
1020/*
1021 cpl_ensure(confidence, CPL_ERROR_NULL_INPUT, NULL);
1022*/
1023 cpl_ensure(wcs, CPL_ERROR_NULL_INPUT, NULL);
1024 cpl_ensure(params, CPL_ERROR_NULL_INPUT, NULL);
1025
1026 hdrl_catalogue_result * result = NULL;
1027
1028 if (confidence) {
1029
1030 /* Check that the confidence array for the image is not zero -
1031 this causes a non-obvious error to be generated deep in the
1032 casu routines */
1033
1034 cpl_ensure(cpl_image_get_max(confidence) > 0.0, CPL_ERROR_ILLEGAL_INPUT,
1035 NULL);
1036 }
1037
1038 result = hdrl_catalogue_compute(hdrl_image_get_image_const(himage),
1039 confidence, wcs, params);
1040
1041 /* REMOVE THE FOLLOWING FOR NOW. IT WAS A FUDGE TO TRY AND IMPROVE
1042 SOURCE MATCHING BETWEN JITTERS - BUT BETTER TO LEAVE IT IN AND
1043 FILTER LATER AS REQUIRED */
1044 /* Remove catalogue entries with low Av_conf.
1045 CASU documentation: Av_conf = the average confidence level within the
1046 default rcore aperture useful for
1047 spotting spurious outliers in various
1048 parameter selection spaces.
1049 The NIX detector has patches with a low density of working pixels
1050 which equate to areas of low confidence */
1051/*
1052 cpl_table_and_selected_double(result->catalogue, "Av_conf", CPL_LESS_THAN,
1053 90.);
1054 cpl_table_erase_selected(result->catalogue);
1055*/
1056
1057 if (cpl_error_get_code() != CPL_ERROR_NONE) {
1058
1059 /* Return NULL on error */
1060
1061 hdrl_catalogue_result_delete(result);
1062 result = NULL;
1063
1064 /* but trap case where simply no objects were present
1065 - for our purposes this is not an error */
1066
1067 const char * message = cpl_error_get_message();
1068 cpl_msg_info(cpl_func, "catalogue %s", message);
1069
1070 if (strstr(message, "No objects found in image")) {
1071 cpl_msg_warning(cpl_func, "No objects found in image");
1072 cpl_error_reset();
1073 }
1074 }
1075 eris_check_error_code("enu_catalogue_compute");
1076 return result;
1077}
1078
1079
1080/*----------------------------------------------------------------------------*/
1089/*----------------------------------------------------------------------------*/
1090
1091cpl_vector * enu_bracket_skys(const located_image * target,
1092 const double timerange,
1093 const located_imagelist * pool,
1094 const int debug) {
1095
1096 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
1097
1098 cpl_ensure(target, CPL_ERROR_NULL_INPUT, NULL);
1099 cpl_ensure(timerange > 0.0, CPL_ERROR_ILLEGAL_INPUT, NULL);
1100 cpl_ensure(pool, CPL_ERROR_NULL_INPUT, NULL);
1101
1102 cpl_vector * result = NULL;
1103 cpl_vector * result_diff = NULL;
1104
1105 double target_mjd = cpl_propertylist_get_double(target->plist, "MJD-OBS");
1106
1107 for (cpl_size j = 0; j < pool->size; j++) {
1108 double mjd_j = cpl_propertylist_get_double((pool->limages[j])->
1109 plist, "MJD-OBS");
1110 double diff = (target_mjd - mjd_j) * 3600.0 * 24.0;
1111
1112 if (fabs(diff) < timerange/2.0) {
1113 if (result == NULL) {
1114 result = cpl_vector_new(1);
1115 result_diff = cpl_vector_new(1);
1116 cpl_vector_set(result, 0, (double)j);
1117 cpl_vector_set(result_diff, 0, diff);
1118 } else {
1119 cpl_size size = cpl_vector_get_size(result);
1120 cpl_vector_set_size(result, size + 1);
1121 cpl_vector_set_size(result_diff, size + 1);
1122 cpl_vector_set(result, size, (double)j);
1123 cpl_vector_set(result_diff, size, diff);
1124 }
1125 }
1126 }
1127 enu_check_error_code("error in enu_bracket_skys: %s",
1128 cpl_error_get_message());
1129 enu_check(result && cpl_vector_get_size(result) > 0,
1130 CPL_ERROR_INCOMPATIBLE_INPUT,
1131 "no sky frames found within %f sec of target frame", timerange/2.0);
1132
1133 if (debug) {
1134 cpl_size size = cpl_vector_get_size(result);
1135 if (size > 0) {
1136 cpl_msg_info(" ", ".. enu_bracket_skys: timerange %5.1f", timerange);
1137 cpl_msg_info(" ", ".. j# diff(sec)");
1138 }
1139 for (cpl_size i = 0; i < size; i++) {
1140 int j = cpl_vector_get(result, i);
1141 double diff = cpl_vector_get(result_diff, i);
1142 cpl_msg_info(" ", ".. %3d %7.1f", j, diff);
1143 }
1144 }
1145
1146 cleanup:
1147 if (cpl_error_get_code() != CPL_ERROR_NONE) {
1148 cpl_vector_delete(result);
1149 result = NULL;
1150 }
1151 cpl_vector_delete(result_diff);
1152 eris_check_error_code("enu_bracket_skys");
1153 return result;
1154}
1155
1156
1157/*----------------------------------------------------------------------------*/
1165/*----------------------------------------------------------------------------*/
1166
1167cpl_error_code enu_catalogue_limlist(located_imagelist * limlist,
1168 hdrl_parameter * params) {
1169
1170 cpl_ensure_code(cpl_error_get_code() == CPL_ERROR_NONE,
1171 cpl_error_get_code());
1172 cpl_ensure_code(limlist, CPL_ERROR_NULL_INPUT);
1173 cpl_ensure_code(params, CPL_ERROR_NULL_INPUT);
1174
1175 cpl_size njitters = limlist->size;
1176 cpl_msg_info(cpl_func, "cataloguing %d images", (int) njitters);
1177
1178 for (cpl_size i = 0; i < njitters; i++) {
1179 cpl_wcs * wcs = cpl_wcs_new_from_propertylist
1180 (limlist->limages[i]->plist);
1181 cpl_msg_info(cpl_func, "cataloguing image %d", (int) i);
1182 /* AMO the following is required to handle bad pixels that were not all flagged */
1183 double* pdata = cpl_image_get_data_double(hdrl_image_get_image((limlist->limages[i])->himage));
1184 //double* perrs = cpl_image_get_data_double(hdrl_image_get_error((limlist->limages[i])->himage));
1185 cpl_size sx = hdrl_image_get_size_x(limlist->limages[i]->himage);
1186 cpl_size sy = hdrl_image_get_size_y(limlist->limages[i]->himage);
1187 cpl_mask* mask = cpl_image_get_bpm(hdrl_image_get_image(limlist->limages[i]->himage));
1188 cpl_mask* mskerr = cpl_image_get_bpm(hdrl_image_get_error(limlist->limages[i]->himage));
1189 double* pconf = cpl_image_get_data_double(limlist->limages[i]->confidence);
1190 cpl_binary* pbpm_data = cpl_mask_get_data(mask);
1191 cpl_binary* pbpm_errs = cpl_mask_get_data(mskerr);
1192 for(cpl_size indexj = 0; indexj < sy; indexj++) {
1193 for(cpl_size indexi = 0; indexi < sx; indexi++) {
1194 if(!isfinite(pdata[indexi+indexj*sx]) ) {
1195 pbpm_data[indexi+indexj*sx] = CPL_BINARY_1;
1196 pbpm_errs[indexi+indexj*sx] = CPL_BINARY_1;
1197 pconf[indexi+indexj*sx] = 0;
1198 }
1199 }
1200 }
1201
1202 //TODO AMO: the following call generates a memory leak
1203 limlist->limages[i]->objects = enu_catalogue_compute(
1204 limlist->limages[i]->himage,
1205 limlist->limages[i]->confidence,
1206 wcs,
1207 params);
1208 cpl_wcs_delete(wcs);
1209
1210 if (cpl_error_get_code() != CPL_ERROR_NONE) break;
1211 }
1212 eris_check_error_code("enu_catalogue_limlist");
1213 return cpl_error_get_code();
1214}
1215
1216
1217/*----------------------------------------------------------------------------*/
1232/*----------------------------------------------------------------------------*/
1233
1234int enu_check_conformance(const cpl_propertylist * plist1,
1235 const cpl_propertylist * plist2,
1236 const char * regexp) {
1237
1238 if (cpl_error_get_code() != CPL_ERROR_NONE) return 0;
1239
1240 /* Check parameters not NULL */
1241
1242 cpl_ensure(plist1 && plist2 && regexp, CPL_ERROR_NULL_INPUT, 0);
1243
1244 int result = CPL_TRUE;
1245 char * reason = NULL;
1246
1247 /* Create the two subsets to be compared */
1248
1249 cpl_propertylist * subset1 = cpl_propertylist_new();
1250 cpl_propertylist_copy_property_regexp(subset1, plist1, regexp, 0);
1251 cpl_propertylist * subset2 = cpl_propertylist_new();
1252 cpl_propertylist_copy_property_regexp(subset2, plist2, regexp, 0);
1253 enu_check_error_code("error deriving subset of propertylist");
1254
1255 /* Compare them */
1256
1257 cpl_size size1 = cpl_propertylist_get_size(subset1);
1258 cpl_size size2 = cpl_propertylist_get_size(subset2);
1259 if (size1 != size2) {
1260 result = CPL_FALSE;
1261 reason = cpl_sprintf("propertylist sizes do not match %s", " ");
1262 } else {
1263 for (cpl_size i=0; i<size1; i++) {
1264 const cpl_property * prop1 = cpl_propertylist_get(subset1, i);
1265 const char * name = cpl_property_get_name(prop1);
1266
1267 /* does the second list have a property of that name? */
1268
1269 if (!cpl_propertylist_has(subset2, name)) {
1270 result = CPL_FALSE;
1271 reason = cpl_sprintf("name mismatch: %s", name);
1272 break;
1273 }
1274
1275 /* do the values match? */
1276
1277 const cpl_property * prop2 = cpl_propertylist_get_property_const(
1278 subset2, name);
1279
1280 const cpl_type type1 = cpl_property_get_type(prop1);
1281 const cpl_type type2 = cpl_property_get_type(prop2);
1282 if (type1 != type2) {
1283 result = CPL_FALSE;
1284 reason = cpl_sprintf("type mismatch: name %s: types %s and %s",
1285 name,
1286 cpl_type_get_name(cpl_property_get_type(prop1)),
1287 cpl_type_get_name(cpl_property_get_type(prop2)));
1288 break;
1289 }
1290
1291 int ival1 = 0;
1292 int ival2 = 0;
1293 double dval1 = 0.0;
1294 double dval2 = 0.0;
1295 const char * sval1 = NULL;
1296 const char * sval2 = NULL;
1297
1298 switch (type1) {
1299 case CPL_TYPE_INT:
1300 ival1 = cpl_property_get_int(prop1);
1301 ival2 = cpl_property_get_int(prop2);
1302 if (ival1 != ival2) {
1303 result = CPL_FALSE;
1304 reason = cpl_sprintf("value mismatch: name %s: values "
1305 "%d and %d",
1306 name, ival1, ival2);
1307 }
1308 break;
1309
1310 case CPL_TYPE_DOUBLE:
1311 dval1 = cpl_property_get_double(prop1);
1312 dval2 = cpl_property_get_double(prop2);
1313 if (dval1 != dval2) {
1314 result = CPL_FALSE;
1315 reason = cpl_sprintf("value mismatch: name %s: values "
1316 "%4.2e and %4.2e",
1317 name, dval1, dval2);
1318 }
1319 break;
1320
1321 case CPL_TYPE_STRING:
1322 sval1 = cpl_property_get_string(prop1);
1323 sval2 = cpl_property_get_string(prop2);
1324 if (strcmp(sval1, sval2)) {
1325 result = CPL_FALSE;
1326 reason = cpl_sprintf("value mismatch: name %s: values "
1327 "%s, %s", name, sval1, sval2);
1328 }
1329 break;
1330 default:
1331 cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
1332 "name %s, type not handled %s",
1333 name, cpl_type_get_name(
1334 cpl_property_get_type(prop1)));
1335 break;
1336
1337 if (result == CPL_FALSE) break;
1338 }
1339 }
1340 }
1341
1342cleanup:
1343
1344 cpl_propertylist_delete(subset1);
1345 cpl_propertylist_delete(subset2);
1346
1347
1348 /* Always return False on error */
1349
1350 if (cpl_error_get_code() != CPL_ERROR_NONE) {
1351 result = CPL_FALSE;
1352 } else {
1353 if (result == CPL_FALSE) {
1354 cpl_msg_info(cpl_func, "propertylist match failed: %s", reason);
1355 }
1356 }
1357 cpl_free(reason);
1358 eris_check_error_code("enu_check_conformance");
1359 return result;
1360}
1361
1362
1363/*----------------------------------------------------------------------------*/
1375/*----------------------------------------------------------------------------*/
1376
1377cpl_error_code enu_check_wcs(const located_image * limage) {
1378
1379 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
1380 cpl_ensure_code(limage, CPL_ERROR_NULL_INPUT);
1381
1382 cpl_boolean bad = CPL_FALSE;
1383
1384 if (!cpl_propertylist_has(limage->plist, "CTYPE1")) {
1385 bad = CPL_TRUE;;
1386 }
1387 if (!bad) {
1388 const char * ctype1 = cpl_propertylist_get_string(
1389 limage->plist, "CTYPE1");
1390 if (strstr(ctype1, "PIXEL")) {
1391 bad = CPL_TRUE;
1392 }
1393 }
1394
1395 if (!bad) {
1396 if (!cpl_propertylist_has(limage->plist, "CTYPE2")) {
1397 bad = CPL_TRUE;
1398 }
1399 }
1400 if (!bad) {
1401 const char * ctype2 = cpl_propertylist_get_string(limage->plist,
1402 "CTYPE2");
1403 if (strstr(ctype2, "PIXEL")) {
1404 bad = CPL_TRUE;
1405 }
1406 }
1407
1408 cpl_error_code result = cpl_error_get_code();
1409 if (result == CPL_ERROR_NONE && bad) {
1410 result = cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_INPUT,
1411 "missing or bad WCS keywords in "
1412 "input file %s",
1413 cpl_frame_get_filename(limage->frame));
1414 }
1415 eris_check_error_code("enu_check_wcs");
1416 return result;
1417}
1418
1419
1420/*----------------------------------------------------------------------------*/
1433/*----------------------------------------------------------------------------*/
1434
1435cpl_error_code enu_debug_limlist_save(const int debug,
1436 const located_imagelist * limlist,
1437 const char * nameroot,
1438 const char * recipename,
1439 cpl_frameset * frameset,
1440 const cpl_parameterlist * parlist,
1441 const cpl_frameset * used) {
1442
1443 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
1444 if (!debug) return CPL_ERROR_NONE;
1445 cpl_ensure_code(limlist, CPL_ERROR_NULL_INPUT);
1446 cpl_ensure_code(nameroot, CPL_ERROR_NULL_INPUT);
1447 cpl_ensure_code(recipename, CPL_ERROR_NULL_INPUT);
1448 cpl_ensure_code(frameset, CPL_ERROR_NULL_INPUT);
1449 cpl_ensure_code(parlist, CPL_ERROR_NULL_INPUT);
1450 cpl_ensure_code(used, CPL_ERROR_NULL_INPUT);
1451
1452 char * fname_copy = NULL;
1453 char * out_fname = NULL;
1454
1455 /* loop through images */
1456
1457 cpl_size nimages = limlist->size;
1458 for (cpl_size j = 0; j < nimages; j++) {
1459
1460 /* generate name of output file */
1461
1462 if (limlist->limages[j]->frame) {
1463 const char * fname = cpl_frame_get_filename(
1464 limlist->limages[j]->frame);
1465 fname_copy = cpl_strdup(fname);
1466 } else {
1467 const char * fname = "debug.fits";
1468 fname_copy = cpl_strdup(fname);
1469 }
1470 out_fname = cpl_sprintf("%s_%s", nameroot, basename(fname_copy));
1471
1472 cpl_msg_info(cpl_func, "..(debug) writing %s", out_fname);
1473
1474 /* some dummy info to keep dfs happy */
1475
1476 cpl_propertylist * applist = cpl_propertylist_new();
1477 cpl_propertylist_update_string(applist,
1478 CPL_DFS_PRO_CATG,
1479 "debug");
1480 cpl_propertylist_update_string(applist, "PRODCATG", "ANCILLARY.IMAGE");
1481
1482 cpl_frameset * provenance = cpl_frameset_new();
1483 cpl_frameset_insert(provenance, cpl_frame_duplicate(
1484 limlist->limages[j]->frame));
1485
1486 enu_dfs_save_limage(frameset,
1487 parlist,
1488 provenance,
1489 CPL_TRUE,
1490 limlist->limages[j],
1491 recipename,
1492 limlist->limages[j]->frame,
1493 applist,
1494 "test",
1495 out_fname);
1496
1497 cpl_frameset_delete(provenance);
1498 cpl_propertylist_delete(applist);
1499 }
1500
1501 /* tidy up */
1502
1503 cpl_free(fname_copy);
1504 cpl_free(out_fname);
1505 eris_check_error_code("enu_debug_limlist_save");
1506 return cpl_error_get_code();
1507}
1508
1509
1510/*----------------------------------------------------------------------------*/
1523/*----------------------------------------------------------------------------*/
1524
1525cpl_error_code enu_flat_save(const char * pro_catg,
1526 const hdrl_image * flat,
1527 const cpl_image * confidence,
1528 const cpl_mask * cold_bpm,
1529 cpl_frameset * frameset,
1530 const cpl_parameterlist * parlist,
1531 const char * filename,
1532 const char * recipe_name,
1533 const cpl_propertylist* qclog) {
1534
1535 /* checks */
1536
1537 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
1538 cpl_ensure_code(pro_catg, CPL_ERROR_NULL_INPUT);
1539 cpl_ensure_code(flat, CPL_ERROR_NULL_INPUT);
1540 cpl_ensure_code(frameset, CPL_ERROR_NULL_INPUT);
1541 cpl_ensure_code(parlist, CPL_ERROR_NULL_INPUT);
1542 cpl_ensure_code(filename, CPL_ERROR_NULL_INPUT);
1543
1544 mef_extension_list * mefs = NULL;
1545 cpl_propertylist * plist = NULL;
1546
1547 /* make output propertylist */
1548
1549 plist = cpl_propertylist_new();
1550 cpl_propertylist_append_string(plist, CPL_DFS_PRO_CATG, pro_catg);
1551 cpl_propertylist_update_string(plist, "PRODCATG", "ANCILLARY.IMAGE");
1552
1553 /* add QC parameters */
1554
1555 hdrl_value flat_median = hdrl_image_get_median(flat);
1556 cpl_propertylist_append_double(plist, "ESO QC FLAT MED",
1557 (double) flat_median.data);
1558 cpl_propertylist_set_comment(plist,"ESO QC FLAT MED",
1559 "[ADU] Median flat value");
1560 hdrl_value flat_mean = hdrl_image_get_mean(flat);
1561 cpl_propertylist_append_double(plist, "ESO QC FLAT MEAN",
1562 (double) flat_mean.data);
1563 cpl_propertylist_set_comment(plist,"ESO QC FLAT MEAN",
1564 "[ADU] Mean flat value");
1565 double flat_rms = hdrl_image_get_stdev(flat);
1566 cpl_propertylist_append_double(plist, "ESO QC FLAT RMS", flat_rms);
1567 cpl_propertylist_set_comment(plist,"ESO QC FLAT RMS",
1568 "[ADU] RMS flat value");
1569 /* the normalisation factor is not returned by hdrl_flat_compute,
1570 and is cumbersome to obtain otherwise */
1571
1572 cpl_msg_warning(cpl_func, "TBD: calculate normalisation value");
1573 double norm = -1.0;
1574 cpl_propertylist_append_double(plist, "ESO QC FLAT NORM", norm);
1575 cpl_propertylist_set_comment(plist,"ESO QC FLAT NORM",
1576 "Flat normalisation value");
1577 if(cold_bpm) {
1578 cpl_size ncold = cpl_mask_count(cold_bpm);
1579 cpl_propertylist_append_double(plist, "ESO QC NUMBER COLD PIXELS",
1580 ncold);
1581 cpl_propertylist_set_comment(plist,"ESO QC NUMBER COLD PIXELS",
1582 "Number of cold pixels");
1583 }
1584 enu_check_error_code("error constructing output propertylist");
1585
1586 /* save the flat to a DFS-compliant MEF file */
1587
1588 if (!cold_bpm) {
1589 mefs = enu_mef_extension_list_new(1);
1590 mefs->mef[0] = enu_mef_new_image("CONFIDENCE", confidence, NULL);
1591 } else {
1592 mefs = enu_mef_extension_list_new(2);
1593 mefs->mef[0] = enu_mef_new_mask("COLD_BPM", cold_bpm, NULL);
1594 mefs->mef[1] = enu_mef_new_image("CONFIDENCE", confidence, NULL);
1595 }
1596 if(qclog != NULL) {
1597 cpl_propertylist_append(plist, qclog);
1598 }
1599 enu_dfs_save_himage(frameset,
1600 parlist,
1601 frameset,
1602 CPL_TRUE,
1603 flat,
1604 NULL,
1605 mefs,
1606 recipe_name,
1607 NULL,
1608 plist,
1609 NULL,
1610 PACKAGE "/" PACKAGE_VERSION,
1611 filename);
1612
1613 cleanup:
1614 enu_mef_extension_list_delete(mefs);
1615 cpl_propertylist_delete(plist);
1616 eris_check_error_code("enu_flat_save");
1617 return cpl_error_get_code();
1618}
1619
1620
1621/*----------------------------------------------------------------------------*/
1635/*----------------------------------------------------------------------------*/
1636double enu_get_airmass(const cpl_propertylist * plist) {
1637
1638 if (cpl_error_get_code() != CPL_ERROR_NONE) return 0;
1639
1640 double airmass = 0.0;
1641 if (cpl_propertylist_has(plist, "AIRMASS")) {
1642 /* NACO */
1643 airmass = cpl_propertylist_get_double(plist, "AIRMASS");
1644 } else if (cpl_propertylist_has(plist, "ESO TEL AIRM START")) {
1645 /* NIX */
1646 const double astart = cpl_propertylist_get_double(plist,
1647 "ESO TEL AIRM START");
1648 const double aend = cpl_propertylist_get_double(plist,
1649 "ESO TEL AIRM END");
1650 airmass = (astart + aend) / 2.0;
1651
1652 /* check for failure to set AIRM keywords correctly */
1653 const double alt = cpl_propertylist_get_double(plist,
1654 "ESO TEL ALT");
1655 double airmass_alt = 1.0 /cos ((90.0 - alt) * CPL_MATH_PI / 180.0);
1656 if (fabs(airmass - airmass_alt) > 1.0e-5) {
1657 cpl_msg_warning(cpl_func, "discrepency - airmass %f -> %f", airmass,
1658 airmass_alt);
1659 airmass = airmass_alt;
1660 }
1661 } else {
1662 cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
1663 "unable to find airmass information");
1664 }
1665 eris_check_error_code("enu_get_airmass");
1666 return airmass;
1667}
1668
1669
1670/*----------------------------------------------------------------------------*/
1689/*----------------------------------------------------------------------------*/
1690
1691cpl_error_code enu_get_rcore_and_mesh_size(const char * context,
1692 const cpl_parameterlist * parlist,
1693 const cpl_propertylist * plist,
1694 double * obj_core_radius,
1695 int * bkg_mesh_size) {
1696
1697 char * param_name = NULL;
1698 const cpl_parameter * p = NULL;
1699 cpl_parameter * par = NULL;
1700
1701 cpl_error_code error_code = CPL_ERROR_NONE;
1702
1703 if (cpl_error_get_code() != CPL_ERROR_NONE) return CPL_ERROR_NONE;
1704 cpl_ensure_code(context, CPL_ERROR_NULL_INPUT);
1705 cpl_ensure_code(parlist, CPL_ERROR_NULL_INPUT);
1706 cpl_ensure_code(plist, CPL_ERROR_NULL_INPUT);
1707 cpl_ensure_code(obj_core_radius, CPL_ERROR_NULL_INPUT);
1708 cpl_ensure_code(bkg_mesh_size, CPL_ERROR_NULL_INPUT);
1709
1710 *obj_core_radius = -1.0;
1711 *bkg_mesh_size = -1;
1712
1713 /* find out if to set catalogue.core-radius and mesh-size to defaults
1714 depending on AOMODE, or to read them from parameters */
1715
1716 param_name = cpl_sprintf("%s.catalogue.ao-params", context);
1717 cpl_msg_info(cpl_func, "%s", param_name);
1718 p = cpl_parameterlist_find_const(parlist, param_name);
1719 const char * ao_params = cpl_parameter_get_string(p);
1720 cpl_free(param_name);
1721 enu_check_error_code("failed to read ao-params");
1722
1723 if (!strcmp(ao_params, "auto") &&
1724 cpl_propertylist_has(plist, "ESO OBS AOMODE")) {
1725 const char * aomode = cpl_propertylist_get_string(plist,
1726 "ESO OBS AOMODE");
1727 cpl_msg_info(cpl_func, "AOMODE: %s", aomode);
1728
1729 if (!strcmp(aomode, "FULL_AO")) {
1730 *obj_core_radius = 10.0;
1731 *bkg_mesh_size = 64;
1732 if(!strstr(context,"skysub")) {
1733
1734 param_name = cpl_sprintf("%s.catalogue.obj.core-radius", context);
1735 par = (cpl_parameter*) cpl_parameterlist_find_const(parlist, param_name);
1736 cpl_parameter_set_double(par, *obj_core_radius);
1737 cpl_free(param_name);
1738
1739 }
1740
1741 param_name = cpl_sprintf("%s.catalogue.bkg.mesh-size", context);
1742 par = (cpl_parameter*) cpl_parameterlist_find_const(parlist, param_name);
1743 cpl_parameter_set_int(par, *bkg_mesh_size);
1744 cpl_free(param_name);
1745
1746 } else if (!strcmp(aomode, "NO_AO")) {
1747 *obj_core_radius = 25.0;
1748 *bkg_mesh_size = 128;
1749 if(!strstr(context,"skysub")) {
1750
1751 param_name = cpl_sprintf("%s.catalogue.obj.core-radius", context);
1752 par = (cpl_parameter*) cpl_parameterlist_find_const(parlist, param_name);
1753 cpl_parameter_set_double(par, *obj_core_radius);
1754 cpl_free(param_name);
1755
1756 }
1757 param_name = cpl_sprintf("%s.catalogue.bkg.mesh-size", context);
1758 par = (cpl_parameter*) cpl_parameterlist_find_const(parlist, param_name);
1759 cpl_parameter_set_int(par, *bkg_mesh_size);
1760 cpl_free(param_name);
1761 } else {
1762 error_code = CPL_ERROR_DATA_NOT_FOUND;
1763 }
1764
1765 } else {
1766 if(!strstr(context,"skysub")) {
1767 param_name = cpl_sprintf("%s.catalogue.obj.core-radius", context);
1768 p = cpl_parameterlist_find_const(parlist, param_name);
1769 *obj_core_radius = cpl_parameter_get_double(p);
1770 cpl_free(param_name);
1771 }
1772
1773 param_name = cpl_sprintf("%s.catalogue.bkg.mesh-size", context);
1774 p = cpl_parameterlist_find_const(parlist, param_name);
1775 *bkg_mesh_size = cpl_parameter_get_int(p);
1776 cpl_free(param_name);
1777 }
1778 cpl_msg_info(cpl_func, "catalogue AO-related params: %s %f %d",
1779 ao_params, *obj_core_radius, *bkg_mesh_size);
1780
1781 cleanup:
1782 eris_check_error_code("enu_get_rcore_and_mesh_size");
1783 return error_code;
1784}
1785
1786
1787/*----------------------------------------------------------------------------*/
1798/*----------------------------------------------------------------------------*/
1799double enu_get_tel_alt(const cpl_propertylist * plist) {
1800
1801 if (cpl_error_get_code() != CPL_ERROR_NONE) return 0;
1802
1803 double tel_alt = 0.0;
1804 if (cpl_propertylist_has(plist, "ESO TEL ALT")) {
1805 /* NACO */
1806 tel_alt = cpl_propertylist_get_double(plist, "ESO TEL ALT");
1807 } else {
1808 cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
1809 "unable to find ESO TEL ALT information");
1810 }
1811 eris_check_error_code("enu_get_tel_alt");
1812 return tel_alt;
1813}
1814
1815
1816/*----------------------------------------------------------------------------*/
1828/*----------------------------------------------------------------------------*/
1829double enu_get_dit(const cpl_propertylist * plist) {
1830
1831 if (cpl_error_get_code() != CPL_ERROR_NONE) return 0;
1832
1833 double dit = 0.0;
1834 if (cpl_propertylist_has(plist, "ESO DET DIT")) {
1835 dit = cpl_propertylist_get_double(plist, "ESO DET DIT");
1836 } else if (cpl_propertylist_has(plist, "ESO DET SEQ1 DIT")) {
1837 dit = cpl_propertylist_get_double(plist, "ESO DET SEQ1 DIT");
1838 } else {
1839 cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
1840 "no keyword ESO.DET.DIT or ESO.DET.SEQ1.DIT");
1841 }
1842 eris_check_error_code("enu_get_dit");
1843 return dit;
1844}
1845
1846
1847/*----------------------------------------------------------------------------*/
1859/*----------------------------------------------------------------------------*/
1860const char * enu_get_det_mode(const cpl_propertylist * plist) {
1861
1862 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
1863
1864 const char * result = NULL;
1865 if (cpl_propertylist_has(plist, "ESO DET NCORRS NAME")) {
1866 result = cpl_propertylist_get_string(plist, "ESO DET NCORRS NAME");
1867 } else if (cpl_propertylist_has(plist, "ESO DET READ CURNAME")) {
1868 result = cpl_propertylist_get_string(plist, "ESO DET READ CURNAME");
1869 } else {
1870 cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
1871 "no keyword ESO.DET.NCORRS.NAME or "
1872 "ESO.DET.READ.CURNAME");
1873 }
1874 eris_check_error_code("enu_get_det_mode");
1875 return result;
1876}
1877
1878
1879/*----------------------------------------------------------------------------*/
1895/*----------------------------------------------------------------------------*/
1896const char * enu_get_filter(const cpl_propertylist * plist) {
1897
1898 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
1899 cpl_ensure(plist, CPL_ERROR_NULL_INPUT, NULL);
1900
1901 const char * filter = NULL;
1902
1903 if (cpl_propertylist_has(plist, "FILTER")) {
1904 filter = cpl_propertylist_get_string(plist, "FILTER");
1905 } else if (cpl_propertylist_has(plist, "INSTRUME")) {
1906 const char * instrume = cpl_propertylist_get_string(plist, "INSTRUME");
1907
1908 if (!strcmp(instrume, "NAOS+CONICA")) {
1909 filter = cpl_propertylist_get_string(plist, "ESO INS OPTI4 NAME");
1910 cpl_msg_info(cpl_func, "OPTI4 %s", filter);
1911 if (!strcmp(filter, "clear") || !strcmp(filter, "empty")) {
1912 filter = cpl_propertylist_get_string(plist, "ESO INS OPTI5 NAME");
1913 cpl_msg_info(cpl_func, "OPTI5 %s", filter);
1914 }
1915 if (!strcmp(filter, "clear") || !strcmp(filter, "empty")) {
1916 filter = cpl_propertylist_get_string(plist, "ESO INS OPTI6 NAME");
1917 cpl_msg_info(cpl_func, "OPTI6 %s", filter);
1918 }
1919 } else if (!strcmp(instrume, "ERIS")) {
1920 filter = cpl_propertylist_get_string(plist, "ESO INS2 NXFW NAME");
1921 } else {
1922 cpl_error_set(cpl_func, CPL_ERROR_INCOMPATIBLE_INPUT);
1923 }
1924 } else {
1925 filter = "unknown";
1926 }
1927 eris_check_error_code("enu_get_filter");
1928 return filter;
1929}
1930
1931
1932/*----------------------------------------------------------------------------*/
1945/*----------------------------------------------------------------------------*/
1946
1947double enu_get_filter_wavelength(const char * filter) {
1948
1949 if (cpl_error_get_code() != CPL_ERROR_NONE) return -1.0;
1950 cpl_ensure(filter, CPL_ERROR_NULL_INPUT, -1.0);
1951
1952 double lambda = 1.0;
1953 if (!strcmp(filter, "J")) {
1954 lambda = 1.28;
1955 } else if (!strcmp(filter, "H")) {
1956 lambda = 1.66;
1957 } else if (!strcmp(filter, "Ks")) {
1958 lambda = 2.18;
1959 } else if (!strcmp(filter, "Short-Lp")) {
1960 lambda = 3.32;
1961 } else if (!strcmp(filter, "L-Broad")) {
1962 lambda = 3.57;
1963 } else if (!strcmp(filter, "Lp")) {
1964 lambda = 3.79;
1965 } else if (!strcmp(filter, "Mp")) {
1966 lambda = 4.78;
1967 } else if (!strcmp(filter, "Pa-b")) {
1968 lambda = 1.282;
1969 } else if (!strcmp(filter, "Fe-II")) {
1970 lambda = 1.644;
1971 } else if (!strcmp(filter, "H2-cont")) {
1972 lambda = 2.068;
1973 } else if (!strcmp(filter, "H2-1-0S")) {
1974 lambda = 2.120;
1975 } else if (!strcmp(filter, "Br-g")) {
1976 lambda = 2.172;
1977 } else if (!strcmp(filter, "K-peak")) {
1978 lambda = 2.198;
1979 } else if (!strcmp(filter, "IB-2.42")) {
1980 lambda = 2.420;
1981 } else if (!strcmp(filter, "IB-2.48")) {
1982 lambda = 2.479;
1983 } else if (!strcmp(filter, "Br-a-cont")) {
1984 lambda = 3.965;
1985 } else if (!strcmp(filter, "Br-a")) {
1986 lambda = 4.051;
1987 } else {
1988 cpl_msg_warning(cpl_func, "filter %s not recognized", filter);
1989 }
1990 eris_check_error_code("enu_get_filter_wavelength");
1991 return lambda;
1992}
1993
1994
1995/*----------------------------------------------------------------------------*/
2003/*----------------------------------------------------------------------------*/
2004const char * enu_get_license(void) {
2005
2006 const char * eris_nix_license =
2007 "This file is part of the ERIS/NIX Instrument Pipeline\n"
2008 "Copyright (C) 2017 European Southern Observatory\n"
2009 "\n"
2010 "This program is free software; you can redistribute it and/or modify\n"
2011 "it under the terms of the GNU General Public License as published by\n"
2012 "the Free Software Foundation; either version 2 of the License, or\n"
2013 "(at your option) any later version.\n"
2014 "\n"
2015 "This program is distributed in the hope that it will be useful,\n"
2016 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
2017 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
2018 "GNU General Public License for more details.\n"
2019 "\n"
2020 "You should have received a copy of the GNU General Public License\n"
2021 "along with this program; if not, write to the Free Software\n"
2022 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, \n"
2023 "MA 02110-1301 USA";
2024 return eris_nix_license;
2025}
2026
2027
2028/*----------------------------------------------------------------------------*/
2035/*----------------------------------------------------------------------------*/
2036
2037cpl_error_code enu_get_ra_dec(const cpl_wcs * wcs, double * ra, double * dec) {
2038
2039 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
2040 cpl_ensure(wcs, CPL_ERROR_NULL_INPUT, CPL_ERROR_NULL_INPUT);
2041 cpl_ensure(ra, CPL_ERROR_NULL_INPUT, CPL_ERROR_NULL_INPUT);
2042 cpl_ensure(dec, CPL_ERROR_NULL_INPUT, CPL_ERROR_NULL_INPUT);
2043
2044 /* get the axis centre */
2045
2046 const cpl_array * dims = cpl_wcs_get_image_dims(wcs);
2047 cpl_matrix * from = cpl_matrix_new(1, 2);
2048 int ignore = 0;
2049 double dim = cpl_array_get(dims, 0, &ignore);
2050 cpl_matrix_set(from, 0, 0, dim / 2.0);
2051 dim = cpl_array_get(dims, 1, &ignore);
2052 cpl_matrix_set(from, 0, 1, dim / 2.0);
2053
2054 /* convert to world */
2055
2056 cpl_matrix * to = NULL;
2057 cpl_array * status = NULL;
2058 cpl_wcs_convert(wcs, from, &to, &status, CPL_WCS_PHYS2WORLD);
2059
2060 *ra = cpl_matrix_get(to, 0, 0);
2061 *dec = cpl_matrix_get(to, 0, 1);
2062
2063 /* tidy up */
2064
2065 cpl_matrix_delete(from);
2066 cpl_matrix_delete(to);
2067 cpl_array_delete(status);
2068 eris_check_error_code("enu_get_ra_dec");
2069 return cpl_error_get_code();
2070}
2071
2072#define MJD_OBJ_REF_WINDOW_STRY_POS_FAST_UNCORR 61014.7
2073/*----------------------------------------------------------------------------*/
2091/*----------------------------------------------------------------------------*/
2092cpl_error_code enu_get_window_info(cpl_size * nx, cpl_size * ny, int * rot,
2093 cpl_size * strx, cpl_size * stry,
2094 cpl_size * nx_chip, cpl_size * ny_chip,
2095 cpl_boolean * windowed,
2096 const cpl_propertylist * plist) {
2097
2098 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
2099
2100 cpl_ensure_code(plist, CPL_ERROR_NULL_INPUT);
2101 enu_check(cpl_propertylist_has(plist, "INSTRUME") == 1,
2102 CPL_ERROR_DATA_NOT_FOUND,
2103 "propertylist does not contain INSTRUME keyword");
2104
2105 /* get window information */
2106
2107 const char * instrume = cpl_propertylist_get_string(plist, "INSTRUME");
2108
2109 cpl_size nxw = 0;
2110 cpl_size nyw = 0;
2111 int rotw = 0;
2112 cpl_size strxw = 0;
2113 cpl_size stryw = 0;
2114
2115 if (!strcmp(instrume, "ERIS")) {
2116 nxw = cpl_propertylist_get_int(plist, "ESO DET SEQ1 WIN NX");
2117 nyw = cpl_propertylist_get_int(plist, "ESO DET SEQ1 WIN NY");
2118 rotw = cpl_propertylist_get_int(plist, "ESO DET SEQ1 WIN ROT");
2119 strxw = cpl_propertylist_get_int(plist, "ESO DET SEQ1 WIN STRX");
2120 stryw = cpl_propertylist_get_int(plist, "ESO DET SEQ1 WIN STRY");
2121 } else {
2122 /* for NACO */
2123 /* STARTX,Y can be stored as double or int */
2124 nxw = cpl_propertylist_get_int(plist, "ESO DET WIN NX");
2125 nyw = cpl_propertylist_get_int(plist, "ESO DET WIN NY");
2126 if (cpl_propertylist_get_type(plist, "ESO DET WIN STARTX") ==
2127 CPL_TYPE_DOUBLE) {
2128 strxw = (int) cpl_propertylist_get_double(plist,
2129 "ESO DET WIN STARTX");
2130 stryw = (int) cpl_propertylist_get_double(plist,
2131 "ESO DET WIN STARTY");
2132 } else {
2133 strxw = cpl_propertylist_get_int(plist, "ESO DET WIN STARTX");
2134 stryw = cpl_propertylist_get_int(plist, "ESO DET WIN STARTY");
2135 }
2136 }
2137
2138 cpl_size nx_chipw = 2048;
2139 cpl_size ny_chipw = 2048;
2140
2141 if(cpl_propertylist_has(plist, "ESO DET CHIP NX")) {
2142 nx_chipw = cpl_propertylist_get_int(plist,"ESO DET CHIP NX");
2143 } else {
2144 nx_chipw = cpl_propertylist_get_int(plist,"ESO DET CHIP1 NX");
2145 }
2146
2147 if(cpl_propertylist_has(plist, "ESO DET CHIP NY")) {
2148 ny_chipw = cpl_propertylist_get_int(plist,"ESO DET CHIP NY");
2149 } else {
2150 ny_chipw = cpl_propertylist_get_int(plist,"ESO DET CHIP1 NY");
2151 }
2152
2153 enu_check_error_code("failed to read detector mode information");
2154 enu_check(rotw == 0, CPL_ERROR_UNSUPPORTED_MODE,
2155 "detector window rot must be 0");
2156
2157 cpl_boolean windowedw = (rotw != 0) ||
2158 (strxw != 1) ||
2159 (stryw != 1) ||
2160 (nxw != nx_chipw) ||
2161 (nyw != ny_chipw);
2162 cpl_msg_info(cpl_func, "flatfield rot=%d strx=%d stry=%d nx=%d ny=%d windowedw: %d",
2163 (int)rotw, (int)strxw, (int)stryw, (int)nxw, (int)nyw, windowedw);
2164
2165 if (!strcmp(instrume, "ERIS")) {
2166 /* Handle special case for windowed mode and FAST_UNCORR */
2167 double mjd_obs = MJD_OBJ_REF_WINDOW_STRY_POS_FAST_UNCORR;
2168 if(cpl_propertylist_has(plist,"ESO DET SEQ1 WIN NAME")) {
2169 mjd_obs = cpl_propertylist_get_double(plist,"MJD-OBS");
2170 }
2171
2172 const char * det_mode = "SLOW_GR_UTR";
2173 if(cpl_propertylist_has(plist,"ESO DET READ CURNAME")) {
2174 det_mode = enu_get_det_mode(plist);
2175 }
2176
2177 const char * win_name = "windowF";
2178 if(cpl_propertylist_has(plist,"ESO DET SEQ1 WIN NAME")) {
2179 win_name = cpl_propertylist_get_string(plist,"ESO DET SEQ1 WIN NAME");
2180 }
2181
2182 if ( windowedw && (strcmp(win_name, "windowF") != 0) &&
2183 (strcmp(det_mode, "FAST_UNCORR") == 0) && ((stryw % 2) == 0) && (mjd_obs < MJD_OBJ_REF_WINDOW_STRY_POS_FAST_UNCORR) ){
2184 stryw +=1;
2185 cpl_msg_warning(cpl_func,"windowing special case windowedw: %d win_name: %s", windowedw, win_name);
2186 } else {
2187 cpl_msg_warning(cpl_func,"windowing normal case windowedw: %d win_name: %s", windowedw, win_name);
2188 }
2189
2190 }
2191
2192 /* only now copy to external variables in case these are
2193 all the same - which would have screwed up the logic above */
2194
2195 *nx = nxw;
2196 *ny = nyw;
2197 *rot = rotw;
2198 *strx = strxw;
2199 *stry = stryw;
2200 *nx_chip = nx_chipw;
2201 *ny_chip = ny_chipw;
2202 *windowed = windowedw;
2203
2204 cleanup:
2205 eris_check_error_code("enu_get_window_info");
2206 return cpl_error_get_code();
2207}
2208
2209
2210/*----------------------------------------------------------------------------*/
2216/*----------------------------------------------------------------------------*/
2217hdrl_catalogue_result * enu_hdrl_catalogue_result_duplicate(
2218 const hdrl_catalogue_result * target) {
2219 cpl_ensure(target, CPL_ERROR_NULL_INPUT, NULL);
2220
2221 hdrl_catalogue_result * result = cpl_malloc(sizeof(hdrl_catalogue_result));
2222
2223 result->catalogue = cpl_table_duplicate(target->catalogue);
2224 result->background = cpl_image_duplicate(target->background);
2225 result->segmentation_map = cpl_image_duplicate(target->segmentation_map);
2226 result->qclist = cpl_propertylist_duplicate(target->qclist);
2227
2228 return result;
2229}
2230
2231
2232/*----------------------------------------------------------------------------*/
2243/*----------------------------------------------------------------------------*/
2244
2245cpl_error_code enu_himage_load_from_fits(const char * filename,
2246 hdrl_image ** result,
2247 mef_extension_list ** mef_extensions,
2248 cpl_propertylist ** plist) {
2249
2250 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
2251
2252 cpl_propertylist * plist1 = NULL;
2253 cpl_propertylist * plist2 = NULL;
2254 cpl_propertylist * plist3 = NULL;
2255 cpl_image * data = NULL;
2256 cpl_image * error = NULL;
2257 cpl_mask * bpm = NULL;
2258 cpl_mask * old_bpm = NULL;
2259
2260 /* check parameters */
2261
2262 cpl_ensure_code(filename, CPL_ERROR_NULL_INPUT);
2263
2264 /* check FITS files has enough extensions */
2265
2266 cpl_size size = cpl_fits_count_extensions(filename);
2267 cpl_ensure_code(size >= 3, CPL_ERROR_BAD_FILE_FORMAT);
2268
2269 /* Get main propertylist from HDU 0 in the file */
2270
2271 *plist = cpl_propertylist_load(filename, 0);
2272 enu_check_error_code("accessing HDU 0 header");
2273
2274 /* Access HDU 1 in the file, this should contain the data */
2275
2276 plist1 = cpl_propertylist_load(filename, 1);
2277 enu_check_error_code("accessing HDU 1 header");
2278
2279 const char * extname = cpl_propertylist_get_string(plist1, "EXTNAME");
2280 const char * hduclass = cpl_propertylist_get_string(plist1, "HDUCLASS");
2281 const char * hdudoc = cpl_propertylist_get_string(plist1, "HDUDOC");
2282 //const char * hduvers = cpl_propertylist_get_string(plist1, "HDUVERS");
2283 const char * hduclas1 = cpl_propertylist_get_string(plist1, "HDUCLAS1");
2284 const char * hduclas2 = cpl_propertylist_get_string(plist1, "HDUCLAS2");
2285 enu_check_error_code("accessing HDU 1 propertylist");
2286 enu_check(strstr(extname, "DATA") != NULL &&
2287 strstr(hduclass, "ESO") != NULL &&
2288 strstr(hdudoc, "SDP") != NULL &&
2289 strstr(hduclas1, "IMAGE") != NULL &&
2290 strstr(hduclas2, "DATA") != NULL,
2291 CPL_ERROR_BAD_FILE_FORMAT, "bad HD1 format");
2292 data = cpl_image_load(filename, HDRL_TYPE_DATA, 0, 1);
2293 enu_check_error_code("accessing HDU 1 data");
2294
2295 /* the wcs items are stored with the image planes, merge
2296 them back into plist - order is import for the NAXIS*
2297 keywords so the properties are inserted after NAXIS
2298 in reverse order*/
2299
2300 const char * wcs_items = "NAXIS WCSAXES CRPIX1 CRPIX2 "
2301 "CD1_1 CD1_2 CD2_1 CD2_2 CUNIT1 CUNIT2 "
2302 "CTYPE1 CTYPE2 CRVAL1 CRVAL2 LONPOLE "
2303 "LATPOLE CSYER1 CSYER2 EQUINOX MJD-OBS "
2304 "DATE-OBS NAXIS2 NAXIS1";
2305 cpl_size plist1_size = cpl_propertylist_get_size(plist1);
2306 for (cpl_size ip=plist1_size; ip>0; ip--) {
2307 const cpl_property * newprop = cpl_propertylist_get_const(plist1, ip-1);
2308 const char * name = cpl_property_get_name(newprop);
2309 if (strstr(wcs_items, name) != NULL) {
2310 if (cpl_propertylist_has(*plist, name)) {
2311 cpl_propertylist_copy_property(*plist, plist1, name);
2312 } else {
2313 cpl_propertylist_insert_after_property(*plist, "NAXIS",
2314 newprop);
2315 }
2316 }
2317 }
2318
2319 /* Access HDU 2 in the file, this should contain the data error */
2320
2321 plist2 = cpl_propertylist_load(filename, 2);
2322 enu_check_error_code("accessing HDU 2");
2323 extname = cpl_propertylist_get_string(plist2, "EXTNAME");
2324 hduclass = cpl_propertylist_get_string(plist2, "HDUCLASS");
2325 hdudoc = cpl_propertylist_get_string(plist2, "HDUDOC");
2326 //hduvers = cpl_propertylist_get_string(plist2, "HDUVERS");
2327 hduclas1 = cpl_propertylist_get_string(plist2, "HDUCLAS1");
2328 hduclas2 = cpl_propertylist_get_string(plist2, "HDUCLAS2");
2329 enu_check_error_code("accessing HDU 2 propertylist");
2330 enu_check(strstr(extname, "ERR") != NULL &&
2331 strstr(hduclass, "ESO") != NULL &&
2332 strstr(hdudoc, "SDP") != NULL &&
2333 strstr(hduclas1, "IMAGE") != NULL &&
2334 strstr(hduclas2, "ERROR") != NULL,
2335 CPL_ERROR_BAD_FILE_FORMAT, "bad HD2 format");
2336 error = cpl_image_load(filename, HDRL_TYPE_ERROR, 0, 2);
2337 enu_check_error_code("accessing HDU 1 data error");
2338
2339 /* Access HDU 3 in the file, this should contain the data quality */
2340
2341 plist3 = cpl_propertylist_load(filename, 3);
2342 enu_check_error_code("accessing HDU 3");
2343 extname = cpl_propertylist_get_string(plist3, "EXTNAME");
2344 hduclass = cpl_propertylist_get_string(plist3, "HDUCLASS");
2345 hdudoc = cpl_propertylist_get_string(plist3, "HDUDOC");
2346 //hduvers = cpl_propertylist_get_string(plist3, "HDUVERS");
2347 hduclas1 = cpl_propertylist_get_string(plist3, "HDUCLAS1");
2348 hduclas2 = cpl_propertylist_get_string(plist3, "HDUCLAS2");
2349 enu_check_error_code("accessing HDU 3 propertylist");
2350 enu_check(strstr(extname, "DQ") != NULL &&
2351 strstr(hduclass, "ESO") != NULL &&
2352 strstr(hdudoc, "SDP") != NULL &&
2353 strstr(hduclas1, "IMAGE") != NULL &&
2354 strstr(hduclas2, "QUALITY") != NULL,
2355 CPL_ERROR_BAD_FILE_FORMAT, "bad HD3 format");
2356
2357 /* attach the mask to the data, construct the hdrl image */
2358
2359 bpm = cpl_mask_load(filename, 0, 3);
2360 enu_check_error_code("accessing HDU 3 data mask");
2361 old_bpm = cpl_image_set_bpm(data, bpm);
2362 cpl_mask_delete(old_bpm); old_bpm = NULL;
2363 *result = hdrl_image_create(data, error);
2364
2365 /* Read any further extensions into a mef_extension_list */
2366
2367 int n_ext = size - 3;
2368 *mef_extensions = enu_mef_extension_list_new(n_ext);
2369 for (int ext=0; ext<n_ext; ext++) {
2370
2371 /* get the extension name... */
2372
2373 cpl_propertylist * ext_plist = cpl_propertylist_load(filename, ext+4);
2374 const char * name = cpl_propertylist_get_string(ext_plist, "EXTNAME");
2375 const char * mef_type = cpl_propertylist_get_string(ext_plist,
2376 "ERIS_NIX_MEF_TYPE");
2377
2378 /* ...and value, type keyed on extension name */
2379
2380 if (!strcmp(mef_type, MEF_EXTENSION_CONTAINING_MASK)) {
2381 cpl_mask * mask = cpl_mask_load(filename, 0, ext+4);
2382 mef_extension * new = enu_mef_new_mask(name, mask, NULL);
2383 (*mef_extensions)->mef[ext] = new;
2384 cpl_mask_delete(mask);
2385 } else if (!strcmp(mef_type, MEF_EXTENSION_CONTAINING_IMAGE)) {
2386 cpl_image * image = cpl_image_load(filename, HDRL_TYPE_DATA, 0,
2387 ext+4);
2388 mef_extension * new = enu_mef_new_image(name, image, NULL);
2389 (*mef_extensions)->mef[ext] = new;
2390 cpl_image_delete(image);
2391 } else if (!strcmp(mef_type, MEF_EXTENSION_CONTAINING_TABLE)) {
2392 cpl_table * table = cpl_table_load(filename, ext+4, 0);
2393 mef_extension * new = enu_mef_new_table(name, table, ext_plist);
2394 (*mef_extensions)->mef[ext] = new;
2395 cpl_table_delete(table);
2396 } else {
2397 cpl_error_set_message("enu_himage_load_from_fits",
2398 CPL_ERROR_UNSUPPORTED_MODE,
2399 "unsupported extension name: %s", name);
2400 }
2401
2402 cpl_propertylist_delete(ext_plist);
2403 }
2404
2405 cleanup:
2406 cpl_propertylist_delete(plist1);
2407 cpl_propertylist_delete(plist2);
2408 cpl_propertylist_delete(plist3);
2409 cpl_image_delete(data);
2410 cpl_image_delete(error);
2411 cpl_mask_delete(old_bpm);
2412 if (cpl_error_get_code() != CPL_ERROR_NONE) {
2413 cpl_propertylist_delete(*plist);
2414 *plist = NULL;
2415 hdrl_image_delete(*result);
2416 *result = NULL;
2417 enu_mef_extension_list_delete(*mef_extensions);
2418 *mef_extensions = NULL;
2419 }
2420 eris_check_error_code("enu_himage_load_from_fits");
2421 return cpl_error_get_code();
2422}
2423
2424
2425/*----------------------------------------------------------------------------*/
2440/*----------------------------------------------------------------------------*/
2441
2442located_image * enu_load_limage_from_frame(const cpl_frame * frame,
2443 cpl_image ** pcopyconf,
2444 const cpl_boolean collapse_cube) {
2445
2446 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
2447
2448 cpl_ensure(frame, CPL_ERROR_NULL_INPUT, NULL);
2449 cpl_ensure(cpl_frame_get_filename(frame), CPL_ERROR_NULL_INPUT, NULL);
2450
2451 located_image * result = NULL;
2452 mef_extension_list * mefs = NULL;
2453 cpl_image * data = NULL;
2454 cpl_image * err = NULL;
2455 cpl_image * qual = NULL;
2456 cpl_image * conf = NULL;
2457 cpl_image * bkg = NULL;
2458 cpl_image * bkg_err = NULL;
2459 cpl_image * bkg_conf = NULL;
2460
2461 const char * filename = cpl_frame_get_filename(frame);
2462 cpl_msg_info(cpl_func, "..reading %s", filename);
2463
2464 /* treatment depends on number of extensions, name of first extension, and
2465 ESO DET FRAM FORMAT (single image or cube).
2466 Get this information */
2467
2468 cpl_size next = cpl_fits_count_extensions(filename);
2469
2470 cpl_propertylist * plist = cpl_propertylist_load(filename, 0);
2471
2472 /* is this an ERIS file or NACO */
2473 const char * instrume = cpl_propertylist_get_string(plist, "INSTRUME");
2474 const cpl_boolean eris = !strcmp(instrume, "ERIS");
2475
2476 char * first_ext = NULL;
2477 if (eris && (next > 0)) {
2478 cpl_propertylist * plist1 = cpl_propertylist_load(filename, 1);
2479 if (cpl_propertylist_has(plist1, "EXTNAME")) {
2480 first_ext = cpl_sprintf("%s", cpl_propertylist_get_string(plist1, "EXTNAME"));
2481 }
2482 cpl_propertylist_delete(plist1);
2483 //cpl_msg_info(cpl_func, "extname %s", first_ext);
2484 }
2485
2486 char * frame_format = NULL;
2487 if (cpl_propertylist_has(plist, "ESO DET FRAM FORMAT")) {
2488 frame_format = cpl_sprintf("%s", cpl_propertylist_get_string(plist, "ESO DET FRAM FORMAT"));
2489 cpl_msg_info(cpl_func, "..format %s", frame_format);
2490 }
2491
2492 /* Now read the file appropriately */
2493
2494 if (!eris) {
2495 cpl_msg_info(cpl_func, "NACO data");
2496
2497 /* It is a raw FITS file with header and 2d image data,
2498 plus extensions to be ignored */
2499
2500 data = cpl_image_load(filename, HDRL_TYPE_DATA, 0, 0);
2501 enu_check_error_code("failed to read file: %s", filename);
2502 hdrl_image * himage = hdrl_image_create(data, NULL);
2503 cpl_image_delete(data); data = NULL;
2504 const cpl_size nx = hdrl_image_get_size_x(himage);
2505 const cpl_size ny = hdrl_image_get_size_y(himage);
2506
2507 /* confidence set to 100 everywhere */
2508
2509 cpl_image * confidence;
2510 if (pcopyconf != NULL && *pcopyconf != NULL &&
2511 cpl_image_get_size_x(*pcopyconf) == nx &&
2512 cpl_image_get_size_y(*pcopyconf) == ny) {
2513 confidence = *pcopyconf;
2514 *pcopyconf = NULL;
2515 } else {
2516 confidence = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
2517 cpl_image_fill_window(confidence, 1, 1, nx, ny, 100.0);
2518 }
2519
2520 cpl_frame_dump(frame, NULL);
2521 result = enu_located_image_new(himage,
2522 NULL,
2523 confidence,
2524 NULL,
2525 NULL,
2526 plist,
2527 NULL,
2528 NULL,
2529 NULL,
2530 NULL,
2531 cpl_frame_duplicate(frame));
2532 plist = NULL;
2533
2534 } else if ((next == 0) ||
2535 (next == 1 &&
2536 frame_format &&
2537 !strcmp(first_ext, "ASM_DATA"))) {
2538
2539 if (next == 1) {
2540
2541 /* read IA_FWHM from the ASM table and store it in the
2542 FITS header */
2543
2544 cpl_table * asm_table = cpl_table_load(filename, 1, CPL_TRUE);
2545 cpl_size nrow = cpl_table_get_nrow(asm_table);
2546 if(cpl_table_has_column(asm_table,"IA_FWHM")) {
2547 double * ia_fwhm_data = cpl_table_get_data_double(asm_table,
2548 "IA_FWHM");
2549 cpl_vector * ia_fwhm = cpl_vector_wrap(nrow, ia_fwhm_data);
2550 double ia_fwhm_mean = cpl_vector_get_mean(ia_fwhm);
2551
2552 const char * filter = enu_get_filter(plist);
2553 double lambda = enu_get_filter_wavelength(filter);
2554
2555 /* correct the FWHM for wavelength, check PIPE-10981 docs for
2556 explanation of formula */
2557
2558 double ia_fwhm_corr = ia_fwhm_mean * pow(0.5/lambda, 1./5.);
2559
2560 cpl_propertylist_update_double(plist, "PSF_FWHM", ia_fwhm_corr);
2561 cpl_propertylist_set_comment(plist, "PSF_FWHM", "PSF fwhm derived "
2562 "from AO ASM table [arcsec]");
2563
2564 cpl_vector_unwrap(ia_fwhm);
2565 } else {
2566 cpl_msg_warning(cpl_func,"ASM table miss IA_FWHM column. PSF_FWHM not computed");
2567 }
2568 cpl_table_delete(asm_table);
2569
2570 } else {
2571
2572 /* NO ASM table is present, AO was not used. Estimate the
2573 fwhm from DIMM instead. Again, see PIPE-10981 for background */
2574
2575 if (cpl_propertylist_has(plist, "ESO TEL AMBI FWHM START") &&
2576 cpl_propertylist_has(plist, "ESO TEL AMBI FWHM END") &&
2577 cpl_propertylist_has(plist, "ESO TEL AIRM START") &&
2578 cpl_propertylist_has(plist, "ESO TEL AIRM END")) {
2579
2580 double dimm1 = cpl_propertylist_get_double(plist,
2581 "ESO TEL AMBI FWHM START");
2582 double dimm2 = cpl_propertylist_get_double(plist,
2583 "ESO TEL AMBI FWHM END");
2584 double airmass1 = cpl_propertylist_get_double(plist,
2585 "ESO TEL AIRM START");
2586 double airmass2 = cpl_propertylist_get_double(plist,
2587 "ESO TEL AIRM END");
2588
2589 const char * filter = enu_get_filter(plist);
2590 double lambda = enu_get_filter_wavelength(filter);
2591
2592 /* correct DIMM values for wavelength, then average */
2593
2594 dimm1 = dimm1 *
2595 pow(0.5/lambda, 1./5.) *
2596 pow(airmass1, 3./5.) *
2597 (1. - 78.08 *
2598 (pow(lambda/1.e6, 2./5.) *
2599 pow(airmass1, -1./5.) /
2600 pow(dimm1, 1./3.)
2601 )
2602 );
2603 dimm2 = dimm2 *
2604 pow(0.5/lambda, 1./5.) *
2605 pow(airmass2, 3./5.) *
2606 (1. - 78.08 *
2607 (pow(lambda/1.e6, 2./5.) *
2608 pow(airmass2, -1./5.) /
2609 pow(dimm2, 1./3.)
2610 )
2611 );
2612
2613 cpl_propertylist_update_double(plist, "PSF_FWHM",
2614 (dimm1 + dimm2) / 2.0);
2615 cpl_propertylist_set_comment(plist, "PSF_FWHM",
2616 "PSF fwhm derived "
2617 "from DIMM [arcsec]");
2618 }
2619 }
2620
2621 if (!strcmp(frame_format, "single")) {
2622
2623 /* It is a raw FITS file with header and 2d image data */
2624
2625 data = cpl_image_load(filename, HDRL_TYPE_DATA, 0, 0);
2626 enu_check_error_code("failed to read file: %s", filename);
2627 hdrl_image * himage = hdrl_image_create(data, NULL);
2628 cpl_image_delete(data); data = NULL;
2629 const cpl_size nx = hdrl_image_get_size_x(himage);
2630 const cpl_size ny = hdrl_image_get_size_y(himage);
2631
2632 /* confidence set to 100 everywhere */
2633
2634 cpl_image * confidence;
2635 if (pcopyconf != NULL && *pcopyconf != NULL &&
2636 cpl_image_get_size_x(*pcopyconf) == nx &&
2637 cpl_image_get_size_y(*pcopyconf) == ny) {
2638 confidence = *pcopyconf;
2639 *pcopyconf = NULL;
2640 } else {
2641 confidence = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
2642 cpl_image_fill_window(confidence, 1, 1, nx, ny, 100.0);
2643 }
2644
2645 result = enu_located_image_new(himage,
2646 NULL,
2647 confidence,
2648 NULL,
2649 NULL,
2650 plist,
2651 NULL,
2652 NULL,
2653 NULL,
2654 NULL,
2655 cpl_frame_duplicate(frame));
2656 plist = NULL;
2657
2658 } else if (!strcmp(frame_format, "cube")) {
2659
2660 /* It is a raw FITS file with header and 3d image data (cube) */
2661
2662 cpl_imagelist * datalist = cpl_imagelist_load(filename,
2663 HDRL_TYPE_DATA, 0);
2664 enu_check_error_code("failed to read file: %s", filename);
2665 hdrl_imagelist * himagelist = hdrl_imagelist_create(datalist,
2666 NULL);
2667 cpl_imagelist_delete(datalist); datalist = NULL;
2668 const cpl_size nx = hdrl_imagelist_get_size_x(himagelist);
2669 const cpl_size ny = hdrl_imagelist_get_size_y(himagelist);
2670
2671 /* confidence set to 100 everywhere */
2672
2673 cpl_image * confidence;
2674 if (pcopyconf != NULL && *pcopyconf != NULL &&
2675 cpl_image_get_size_x(*pcopyconf) == nx &&
2676 cpl_image_get_size_y(*pcopyconf) == ny) {
2677 confidence = *pcopyconf;
2678 *pcopyconf = NULL;
2679 } else {
2680 confidence = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
2681 cpl_image_fill_window(confidence, 1, 1, nx, ny, 100.0);
2682 }
2683
2684 if(collapse_cube) {
2685 hdrl_image * himage = NULL;
2686 cpl_image* conf_ima = NULL;
2687 if(collapse_cube == 1) {
2688 hdrl_imagelist_collapse_mean(himagelist,&himage,&conf_ima);
2689 } else if(collapse_cube == 2) {
2690 hdrl_imagelist_collapse_median(himagelist,&himage,&conf_ima);
2691 } else if(collapse_cube == 3) {
2692 hdrl_imagelist_collapse_weighted_mean(himagelist,&himage,&conf_ima);
2693 }
2694 cpl_image_delete(conf_ima);
2695 result = enu_located_image_new(himage,
2696 NULL,
2697 confidence,
2698 NULL,
2699 NULL,
2700 plist,
2701 NULL,
2702 NULL,
2703 NULL,
2704 NULL,
2705 cpl_frame_duplicate(frame));
2706 } else {
2707 result = enu_located_image_new(NULL,
2708 himagelist,
2709 confidence,
2710 NULL,
2711 NULL,
2712 plist,
2713 NULL,
2714 NULL,
2715 NULL,
2716 NULL,
2717 cpl_frame_duplicate(frame));
2718 }
2719 plist = NULL;
2720 }
2721 } else {
2722
2723 /* It is a mef: it should be in ESO Data Products Standard format */
2724
2725 cpl_propertylist_delete(plist);
2726 plist = NULL;
2727 mefs = enu_load_mef_components(filename, &plist);
2728 enu_check_error_code("Unable to load components for file");
2729
2730 /* look in first extension for HDU keywords */
2731
2732 const char * hduclass = cpl_propertylist_get_string(
2733 mefs->mef[0]->plist, "HDUCLASS");
2734 const char * hdudoc = cpl_propertylist_get_string(
2735 mefs->mef[0]->plist, "HDUDOC");
2736 const char * hduvers = cpl_propertylist_get_string(
2737 mefs->mef[0]->plist, "HDUVERS");
2738 enu_check_error_code("Unable to read ESO DPS keywords from header");
2739
2740 enu_check(strstr(hduclass, "ESO") != NULL &&
2741 strstr(hdudoc, "SDP") != NULL &&
2742 strstr(hduvers, "SDP version") != NULL,
2743 CPL_ERROR_BAD_FILE_FORMAT, "file not in ESO DPS format");
2744
2745 /* Read the names of the extensions holding standard data
2746 components */
2747
2748 const char * scidata = NULL;
2749 if (mefs->size > 0 &&
2750 cpl_propertylist_has(mefs->mef[1]->plist, "SCIDATA")){
2751 scidata = cpl_propertylist_get_string(mefs->mef[1]->plist,
2752 "SCIDATA");
2753 }
2754 const char * errdata = NULL;
2755 if (cpl_propertylist_has(mefs->mef[0]->plist, "ERRDATA")){
2756 errdata = cpl_propertylist_get_string(mefs->mef[0]->plist,
2757 "ERRDATA");
2758 }
2759 const char * qualdata = NULL;
2760 if (cpl_propertylist_has(mefs->mef[0]->plist, "QUALDATA")){
2761 qualdata = cpl_propertylist_get_string(mefs->mef[0]->plist,
2762 "QUALDATA");
2763 }
2764 const char * confdata = NULL;
2765 if (cpl_propertylist_has(mefs->mef[0]->plist, "CONFDATA")){
2766 confdata = cpl_propertylist_get_string(mefs->mef[0]->plist,
2767 "CONFDATA");
2768 }
2769 const char * bkgdata = NULL;
2770 if (cpl_propertylist_has(mefs->mef[0]->plist, "BKGDATA")){
2771 bkgdata = cpl_propertylist_get_string(mefs->mef[0]->plist,
2772 "BKGDATA");
2773 }
2774 const char * bkgerr = NULL;
2775 if (cpl_propertylist_has(mefs->mef[0]->plist, "BKGERR")){
2776 bkgerr = cpl_propertylist_get_string(mefs->mef[0]->plist,
2777 "BKGERR");
2778 }
2779 const char * bkgconf = NULL;
2780 if (cpl_propertylist_has(mefs->mef[0]->plist, "BKGCONF")){
2781 bkgconf = cpl_propertylist_get_string(mefs->mef[0]->plist,
2782 "BKGCONF");
2783 }
2784 enu_check_error_code("accessing DPS standard extensions");
2785
2786 /* now loop through extensions filling standard data elements */
2787
2788 for (cpl_size i=0; i<next; i++) {
2789 const char * extname = cpl_propertylist_get_string(
2790 mefs->mef[i]->plist, "EXTNAME");
2791
2792 /* the returned plist is a merge of the plist for the
2793 science image and the header plist.*/
2794
2795 if (scidata && !strcmp(scidata, extname)) {
2796 data = enu_load_component(mefs->mef[i], "SCIDATA",
2797 "IMAGE", "DATA");
2798 enu_check_error_code("accessing SCIDATA extension");
2799
2800 /* Start with the science image plist (for the data and
2801 wcs keywords)*/
2802
2803 cpl_propertylist * primary_plist = plist;
2804
2805 /* remove the SDP7 keywords which were appropriate to
2806 the science data extension but will
2807 confuse the enu_limage_save routine if left in the
2808 main header */
2809
2810 plist = cpl_propertylist_duplicate(mefs->mef[i]->plist);
2811 const char * sdp7_items = " EXTNAME HDUCLAS1 HDUCLAS2"
2812 " HDUCLAS3 ";
2813 cpl_size psize = cpl_propertylist_get_size(plist);
2814 for (cpl_size ip = psize; ip > 0; ip--) {
2815 const cpl_property * prop = cpl_propertylist_get_const(
2816 plist, ip-1);
2817 const char * name = cpl_property_get_name(prop);
2818
2819 /* pad the keyword name with spaces which will
2820 stop strstr misidentifying a keyword that
2821 matches _part_ of an SDP7 keyword */
2822
2823 char * padded_name = cpl_sprintf(" %s ", name);
2824 if (strstr(sdp7_items, padded_name) != NULL) {
2825 cpl_propertylist_erase(plist, name);
2826 }
2827 cpl_free(padded_name);
2828 }
2829
2830 /* merge info from the primary header */
2831
2832 psize = cpl_propertylist_get_size(primary_plist);
2833 for (cpl_size ip = psize; ip > 0; ip--) {
2834 const cpl_property * prop = cpl_propertylist_get_const(
2835 primary_plist, ip-1);
2836 const char * name = cpl_property_get_name(prop);
2837 if (!cpl_propertylist_has(plist, name)) {
2838 cpl_propertylist_copy_property(plist, primary_plist,
2839 name);
2840 }
2841 }
2842 cpl_propertylist_delete(primary_plist);
2843
2844 } else if (errdata && !strcmp(errdata, extname)) {
2845 err = enu_load_component(mefs->mef[i], "SCIERR",
2846 "IMAGE", "ERROR");
2847 enu_check_error_code("accessing SCIERR extension");
2848 } else if (qualdata && !strcmp(qualdata, extname)) {
2849 qual = enu_load_component(mefs->mef[i], "QUALDATA",
2850 "IMAGE", "QUALITY");
2851 enu_check_error_code("accessing QUALDATA extension");
2852 } else if (confdata && !strcmp(confdata, extname)) {
2853 conf = enu_load_component(mefs->mef[i], "CONFDATA",
2854 "IMAGE", "CONF");
2855 enu_check_error_code("accessing CONFDATA extension");
2856 } else if (bkgdata && !strcmp(bkgdata, extname)) {
2857 bkg = enu_load_component(mefs->mef[i], "BKGDATA",
2858 "IMAGE", "BKG_DATA");
2859 enu_check_error_code("accessing BKGDATA extension");
2860 } else if (bkgerr && !strcmp(bkgerr, extname)) {
2861 bkg_err = enu_load_component(mefs->mef[i], "BKGERR",
2862 "IMAGE", "BKG_ERR");
2863 enu_check_error_code("accessing BKGERR extension");
2864 } else if (bkgconf && !strcmp(bkgconf, extname)) {
2865 bkg_conf = enu_load_component(mefs->mef[i], "BKGCONF",
2866 "IMAGE", "BKG_CONF");
2867 enu_check_error_code("accessing BKGCONF extension");
2868 }
2869 }
2870
2871 /* set the data mask from quality, construct the hdrl image */
2872
2873 enu_check(data != NULL, CPL_ERROR_BAD_FILE_FORMAT, "no data in file");
2874 cpl_mask * bpm = cpl_image_get_bpm(data);
2875 cpl_mask_threshold_image(bpm, qual, 0.9, 1.1, CPL_BINARY_1);
2876 bpm = cpl_image_get_bpm(err);
2877 cpl_mask_threshold_image(bpm, qual, 0.9, 1.1, CPL_BINARY_1);
2878 hdrl_image * hdata = hdrl_image_create(data, err);
2879 hdrl_image * hbkg = NULL;
2880 if (bkg) {
2881 hbkg = hdrl_image_create(bkg, bkg_err);
2882 }
2883
2884 result = enu_located_image_new(hdata,
2885 NULL,
2886 conf,
2887 hbkg,
2888 bkg_conf,
2889 plist,
2890 NULL,
2891 NULL,
2892 NULL,
2893 NULL,
2894 cpl_frame_duplicate(frame));
2895
2896 plist = NULL;
2897 cpl_image_delete(data);
2898 cpl_image_delete(err);
2899 cpl_image_delete(qual);
2900 cpl_image_delete(bkg);
2901 cpl_image_delete(bkg_err);
2902 data = NULL;
2903 err = NULL;
2904 qual = NULL;
2905 conf = NULL;
2906 bkg = NULL;
2907 bkg_err = NULL;
2908 bkg_conf = NULL;
2909 }
2910
2911 cleanup:
2912 cpl_free(frame_format);
2913 cpl_free(first_ext);
2914 cpl_propertylist_delete(plist);
2915 cpl_image_delete(data);
2916 cpl_image_delete(err);
2917 cpl_image_delete(qual);
2918 cpl_image_delete(conf);
2919 cpl_image_delete(bkg);
2920 cpl_image_delete(bkg_err);
2921 cpl_image_delete(bkg_conf);
2922 enu_mef_extension_list_delete(mefs);
2923 if (cpl_error_get_code() != CPL_ERROR_NONE) {
2924 enu_located_image_delete(result);
2925 result = NULL;
2926 }
2927
2928 eris_check_error_code("enu_load_limage_from_frame");
2929 return result;
2930}
2931
2932
2933/*----------------------------------------------------------------------------*/
2943/*----------------------------------------------------------------------------*/
2944
2945mef_extension_list * enu_load_mef_components(const char * filename,
2946 cpl_propertylist ** plist) {
2947
2948 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
2949
2950 cpl_ensure(filename, CPL_ERROR_NULL_INPUT, NULL);
2951
2952 /* How many extensions are there, construct result of the correct
2953 size */
2954
2955 cpl_size next = cpl_fits_count_extensions(filename);
2956 mef_extension_list * result = enu_mef_extension_list_new(next);
2957 mef_extension * new = NULL;
2958 cpl_propertylist * eplist = NULL;
2959
2960 /* Read primary HDU header */
2961
2962 *plist = cpl_propertylist_load(filename, 0);
2963 enu_check_error_code("accessing HDU 0 header");
2964
2965 /* Now loop through extensions, loading them in turn */
2966
2967 for (int i=0; i<next; i++) {
2968 int hdu = i + 1;
2969
2970 /* get the extension name... */
2971
2972 cpl_propertylist_delete(eplist);
2973 eplist = cpl_propertylist_load(filename, hdu);
2974 const char * name = cpl_propertylist_get_string(eplist, "EXTNAME");
2975 const char * hduclas1 = cpl_propertylist_get_string(eplist,
2976 "HDUCLAS1");
2977 enu_check_error_code("error accessing keywords in HDU %d", hdu);
2978
2979 /* ...type and value, create appropriate mef_extension */
2980
2981 if (!strcmp(hduclas1, MEF_EXTENSION_CONTAINING_MASK)) {
2982 cpl_mask * mask = cpl_mask_load(filename, 0, hdu);
2983 new = enu_mef_new_mask(name, mask, eplist);
2984 cpl_mask_delete(mask);
2985 } else if (!strcmp(hduclas1, "IMAGE")) {
2986 cpl_image * image = cpl_image_load(filename, HDRL_TYPE_DATA, 0, hdu);
2987 new = enu_mef_new_image(name, image, eplist);
2988 cpl_image_delete(image);
2989 } else if (!strcmp(hduclas1, MEF_EXTENSION_CONTAINING_TABLE)) {
2990 cpl_table * table = cpl_table_load(filename, hdu, 0);
2991 new = enu_mef_new_table(name, table, eplist);
2992 cpl_table_delete(table);
2993 } else {
2994 cpl_error_set_message("enu_load_mef_components",
2995 CPL_ERROR_UNSUPPORTED_MODE,
2996 "extension has unsupported HDUCLAS1: %s %s", name, hduclas1);
2997 }
2998 enu_check_error_code("error accessing HDU %d", hdu);
2999
3000 result->mef[i] = new;
3001 new = NULL;
3002 }
3003
3004 cleanup:
3005 enu_mef_extension_delete(new);
3006 cpl_propertylist_delete(eplist);
3007 if (cpl_error_get_code() != CPL_ERROR_NONE) {
3008 enu_mef_extension_list_delete(result);
3009 result = NULL;
3010 cpl_propertylist_delete(*plist);
3011 *plist = NULL;
3012 }
3013 eris_check_error_code("enu_load_mef_components");
3014 return result;
3015}
3016
3017
3018/*----------------------------------------------------------------------------*/
3025/*----------------------------------------------------------------------------*/
3026
3027void enu_located_image_delete(located_image * limage) {
3028
3029 if (limage) {
3030 hdrl_image_delete(limage->himage);
3031 hdrl_imagelist_delete(limage->himagelist);
3032 cpl_image_delete(limage->confidence);
3033 hdrl_image_delete(limage->bkg);
3034 cpl_image_delete(limage->bkg_confidence);
3035 cpl_propertylist_delete(limage->plist);
3036 hdrl_catalogue_result_delete(limage->objects);
3037 cpl_mask_delete(limage->object_mask);
3038 hdrl_catalogue_result_delete(limage->matchstd_wcs);
3039 hdrl_catalogue_result_delete(limage->matchstd_phot);
3040 cpl_frame_delete(limage->frame);
3041 cpl_free(limage);
3042 }
3043}
3044
3045
3046/*----------------------------------------------------------------------------*/
3054/*----------------------------------------------------------------------------*/
3055
3056located_image * enu_located_image_duplicate(const located_image * limage) {
3057
3058 cpl_ensure(limage, CPL_ERROR_NULL_INPUT, NULL);
3059
3060 /* Watch out for NULL components */
3061
3062 hdrl_image * himage = NULL;
3063 if (limage->himage) {
3064 himage = hdrl_image_duplicate(limage->himage);
3065 }
3066 hdrl_imagelist * himagelist = NULL;
3067 if (limage->himagelist) {
3068 himagelist = hdrl_imagelist_duplicate(limage->himagelist);
3069 }
3070 cpl_image * confidence = NULL;
3071 if (limage->confidence) {
3072 confidence = cpl_image_duplicate(limage->confidence);
3073 }
3074 hdrl_image * bkg = NULL;
3075 if (limage->bkg) {
3076 bkg = hdrl_image_duplicate(limage->bkg);
3077 }
3078 cpl_image * bkg_confidence = NULL;
3079 if (limage->bkg_confidence) {
3080 bkg_confidence = cpl_image_duplicate(limage->bkg_confidence);
3081 }
3082 cpl_propertylist * plist = NULL;
3083 if (limage->plist) {
3084 plist = cpl_propertylist_duplicate(limage->plist);
3085 }
3086 hdrl_catalogue_result * objects = NULL;
3087 if (limage->objects) {
3088 objects = enu_hdrl_catalogue_result_duplicate(limage->objects);
3089 }
3090 cpl_mask * object_mask = NULL;
3091 if (limage->object_mask) {
3092 object_mask = cpl_mask_duplicate(limage->object_mask);
3093 }
3094 hdrl_catalogue_result * matchstd_wcs = NULL;
3095 if (limage->matchstd_wcs) {
3096 matchstd_wcs = enu_hdrl_catalogue_result_duplicate(
3097 limage->matchstd_wcs);
3098 }
3099 hdrl_catalogue_result * matchstd_phot = NULL;
3100 if (limage->matchstd_phot) {
3101 matchstd_phot = enu_hdrl_catalogue_result_duplicate(
3102 limage->matchstd_phot);
3103 }
3104 cpl_frame * frame = NULL;
3105 if (limage->frame) {
3106 frame = cpl_frame_duplicate(limage->frame);
3107 }
3108
3109 located_image * result = enu_located_image_new(himage,
3110 himagelist,
3111 confidence,
3112 bkg,
3113 bkg_confidence,
3114 plist,
3115 objects,
3116 object_mask,
3117 matchstd_wcs,
3118 matchstd_phot,
3119 frame);
3120 eris_check_error_code("enu_located_image_duplicate");
3121
3122 return result;
3123}
3124
3125
3126/*----------------------------------------------------------------------------*/
3146/*----------------------------------------------------------------------------*/
3147
3148located_image * enu_located_image_new(hdrl_image * himage,
3149 hdrl_imagelist * himagelist,
3150 cpl_image * confidence,
3151 hdrl_image * bkg,
3152 cpl_image * bkg_confidence,
3153 cpl_propertylist * plist,
3154 hdrl_catalogue_result * objects,
3155 cpl_mask * object_mask,
3156 hdrl_catalogue_result * wcs,
3157 hdrl_catalogue_result * photom,
3158 cpl_frame * frame) {
3159
3160 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
3161
3162 /* store either image or cube (imagelist) */
3163 cpl_ensure(!(himage && himagelist), CPL_ERROR_ILLEGAL_INPUT, NULL);
3164
3165 located_image * result = cpl_malloc(sizeof(located_image));
3166 result->himage = himage;
3167 result->himagelist = himagelist;
3168 result->confidence = confidence;
3169 result->bkg = bkg;
3170 result->bkg_confidence = bkg_confidence;
3171 result->plist = plist;
3172 result->objects = objects;
3173 result->object_mask = object_mask;
3174 result->matchstd_wcs = wcs;
3175 result->matchstd_phot = photom;
3176 result->frame = frame;
3177
3178 return result;
3179}
3180
3181
3182/*----------------------------------------------------------------------------*/
3193/*----------------------------------------------------------------------------*/
3194
3195located_imagelist * enu_limlist_load_from_frameset(
3196 cpl_frameset * frameset,
3197 const char * tag,
3198 cpl_frameset * used) {
3199
3200 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
3201 cpl_ensure(frameset, CPL_ERROR_NULL_INPUT, NULL);
3202 cpl_ensure(tag, CPL_ERROR_NULL_INPUT, NULL);
3203 cpl_ensure(used, CPL_ERROR_NULL_INPUT, NULL);
3204
3205 located_imagelist * result = NULL;
3206 cpl_frameset_iterator * frameset_iter = NULL;
3207 mef_extension_list * mefs = NULL;
3208 cpl_image * data = NULL;
3209 cpl_image * err = NULL;
3210 cpl_image * qual = NULL;
3211 cpl_image * conf = NULL;
3212 cpl_image * bkg = NULL;
3213 cpl_image * bkg_err = NULL;
3214 cpl_image * bkg_conf = NULL;
3215 cpl_propertylist * plist = NULL;
3216
3217 /* first, find how big the located_imagelist needs to be */
3218
3219 frameset_iter = cpl_frameset_iterator_new(frameset);
3220 cpl_size size = 0;
3221
3222 for (cpl_frame * frame = NULL;
3223 (frame = cpl_frameset_iterator_get(frameset_iter)) &&
3224 (cpl_error_get_code() == CPL_ERROR_NONE);
3225 cpl_frameset_iterator_advance(frameset_iter, 1)) {
3226
3227 const char * frametag = cpl_frame_get_tag(frame);
3228 if (!strcmp(tag, frametag)) {
3229 size++;
3230 }
3231 }
3232 result = enu_located_imagelist_new(size);
3233
3234 /* go through the frameset again and populate the container */
3235
3236 cpl_frameset_iterator_reset(frameset_iter);
3237 cpl_size position = 0;
3238 for (cpl_frame * frame = NULL;
3239 (frame = cpl_frameset_iterator_get(frameset_iter)) &&
3240 (cpl_error_get_code() == CPL_ERROR_NONE);
3241 cpl_frameset_iterator_advance(frameset_iter, 1)) {
3242
3243 /* if frametag is among those wanted, create a located image with
3244 the data and insert it into the located image list */
3245
3246 const char * frametag = cpl_frame_get_tag(frame);
3247
3248 if (!strcmp(tag, frametag)) {
3249
3250 /* we want this file, treatment depends on number of extensions
3251 it has and on the name of the first extension if present */
3252
3253 located_image * limage = enu_load_limage_from_frame(frame,
3254 NULL,
3255 CPL_FALSE);
3256
3257/*
3258 const char * filename = cpl_frame_get_filename(frame);
3259 cpl_msg_info(cpl_func, "..reading %s", filename);
3260 cpl_size next = cpl_fits_count_extensions(filename);
3261 located_image * limage = NULL;
3262
3263 plist = cpl_propertylist_load(filename, 0);
3264
3265 char * first_ext = NULL;
3266 if (next > 0) {
3267 cpl_propertylist * plist1 = cpl_propertylist_load(filename, 1);
3268 if (cpl_propertylist_has(plist1, "EXTNAME")) {
3269 first_ext = cpl_sprintf("%s", cpl_propertylist_get_string(plist1, "EXTNAME"));
3270 }
3271 cpl_propertylist_delete(plist1);
3272 }
3273
3274 char * frame_format = NULL;
3275 if (cpl_propertylist_has(plist, "ESO DET FRAM FORMAT")) {
3276 frame_format = cpl_sprintf("%s", cpl_propertylist_get_string(plist, "ESO DET FRAM FORMAT"));
3277 }
3278
3279 if ((next == 0) ||
3280 (next == 1 &&
3281 !strcmp(first_ext, "ASM_DATA") &&
3282 !strcmp(frame_format, "single"))) {
3283*/
3284 /* raw FITS file with header and 2d image data */
3285/*
3286 data = cpl_image_load(filename, HDRL_TYPE_DATA, 0, 0);
3287 enu_check_error_code("failed to read file: %s", filename);
3288 hdrl_image * himage = hdrl_image_create(data, NULL);
3289 cpl_image_delete(data); data = NULL;
3290 const cpl_size nx = hdrl_image_get_size_x(himage);
3291 const cpl_size ny = hdrl_image_get_size_y(himage);
3292*/
3293 /* confidence set to 100 everywhere */
3294/*
3295 cpl_image * confidence = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
3296 cpl_image_fill_window(confidence, 1, 1, nx, ny, 100.0);
3297
3298 limage = enu_located_image_new(himage, NULL, confidence, NULL,
3299 NULL, plist, NULL, NULL, NULL,
3300 NULL,
3301 cpl_frame_duplicate(frame));
3302 plist = NULL;
3303
3304 } else if (next == 1 &&
3305 !strcmp(first_ext, "ASM_DATA") &&
3306 !strcmp(frame_format, "cube")) {
3307*/
3308 /* raw FITS file with header and 3d image data (cube) */
3309/*
3310 cpl_imagelist * datalist = cpl_imagelist_load(filename,
3311 HDRL_TYPE_DATA,
3312 0);
3313 enu_check_error_code("failed to read file: %s", filename);
3314 hdrl_imagelist * himagelist = hdrl_imagelist_create(datalist,
3315 NULL);
3316 cpl_imagelist_delete(datalist); datalist = NULL;
3317 const cpl_size nx = hdrl_imagelist_get_size_x(himagelist);
3318 const cpl_size ny = hdrl_imagelist_get_size_y(himagelist);
3319*/
3320 /* confidence set to 100 everywhere */
3321/*
3322 cpl_image * confidence = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
3323 cpl_image_fill_window(confidence, 1, 1, nx, ny, 100.0);
3324
3325 limage = enu_located_image_new(NULL, himagelist, confidence,
3326 NULL, NULL, plist, NULL, NULL,
3327 NULL, NULL,
3328 cpl_frame_duplicate(frame));
3329 plist = NULL;
3330
3331 } else {
3332*/
3333 /* If it's a mef it should be in ESO Data Products Standard
3334 format */
3335/*
3336 cpl_propertylist_delete(plist);
3337 plist = NULL;
3338 enu_mef_extension_list_delete(mefs);
3339 mefs = enu_load_mef_components(filename, &plist);
3340 enu_check_error_code("Unable to load components for file");
3341*/
3342 /* look in first extension for HDU keywords */
3343/*
3344 const char * hduclass = cpl_propertylist_get_string(
3345 mefs->mef[0]->plist, "HDUCLASS");
3346 const char * hdudoc = cpl_propertylist_get_string(
3347 mefs->mef[0]->plist, "HDUDOC");
3348 //const char * hduvers = cpl_propertylist_get_string(
3349 // mefs->mef[0]->plist, "HDUVERS");
3350 enu_check_error_code("Unable to read ESO DPS keywords from header");
3351
3352 enu_check(strstr(hduclass, "ESO") != NULL &&
3353 // strstr(hduvers, "SDP version 8") != NULL &&
3354 strstr(hdudoc, "SDP") != NULL,
3355 CPL_ERROR_BAD_FILE_FORMAT, "file not in ESO DPS format");
3356*/
3357 /* now loop through extensions filling standard data elements */
3358/*
3359 for (cpl_size i=0; i<next; i++) {
3360 const char * hduclas2 = cpl_propertylist_get_string(
3361 mefs->mef[i]->plist, "HDUCLAS2");
3362*/
3363 /* the returned plist is a merge of the plist for the
3364 science image and the header plist.*/
3365/*
3366 if (hduclas2 && !strcmp(hduclas2, "DATA")) {
3367 data = enu_load_component(mefs->mef[i], "SCIDATA",
3368 "IMAGE", "DATA");
3369 enu_check_error_code("accessing SCIDATA extension");
3370*/
3371 /* Start with the science image plist (for the data and
3372 wcs keywords)*/
3373/*
3374 cpl_propertylist * primary_plist = plist;
3375*/
3376 /* remove the SDP7 keywords which were appropriate to
3377 the science data extension but will
3378 confuse the enu_limage_save routine if left in the
3379 main header */
3380/*
3381 plist = cpl_propertylist_duplicate(
3382 mefs->mef[i]->plist);
3383 const char * sdp7_items = " EXTNAME HDUCLAS1 HDUCLAS2"
3384 " HDUCLAS3 ";
3385 cpl_size psize = cpl_propertylist_get_size(plist);
3386 for (cpl_size ip=psize; ip>0; ip--) {
3387 const cpl_property * prop =
3388 cpl_propertylist_get_const(
3389 plist, ip-1);
3390 const char * name = cpl_property_get_name(prop);
3391*/
3392 /* pad the keyword name with spaces which will
3393 stop strstr misidentifying a keyword that
3394 matches _part_ of an SDP7 keyword */
3395/*
3396 char * padded_name = cpl_sprintf(" %s ", name);
3397 if (strstr(sdp7_items, padded_name) != NULL) {
3398 cpl_propertylist_erase(plist, name);
3399 }
3400 cpl_free(padded_name);
3401 }
3402*/
3403 /* merge info from the primary header */
3404/*
3405 psize = cpl_propertylist_get_size(primary_plist);
3406 for (cpl_size ip=psize; ip>0; ip--) {
3407 const cpl_property * prop =
3408 cpl_propertylist_get_const(
3409 primary_plist, ip-1);
3410 const char * name = cpl_property_get_name(prop);
3411 if (!cpl_propertylist_has(plist, name)) {
3412 cpl_propertylist_copy_property(plist,
3413 primary_plist,
3414 name);
3415 }
3416 }
3417 cpl_propertylist_delete(primary_plist);
3418
3419 } else if (hduclas2 && !strcmp(hduclas2, "ERROR")) {
3420 err = enu_load_component(mefs->mef[i], "SCIERR",
3421 "IMAGE", "ERROR");
3422 enu_check_error_code("accessing SCIERR extension");
3423 } else if (hduclas2 && !strcmp(hduclas2, "QUALITY")) {
3424 qual = enu_load_component(mefs->mef[i], "QUALDATA",
3425 "IMAGE", "QUALITY");
3426 enu_check_error_code("accessing QUALDATA extension");
3427 } else if (hduclas2 && !strcmp(hduclas2, "CONF")) {
3428 conf = enu_load_component(mefs->mef[i], "CONFDATA",
3429 "IMAGE", "CONF");
3430 enu_check_error_code("accessing CONFDATA extension");
3431 } else if (hduclas2 && !strcmp(hduclas2, "BKG_DATA")) {
3432 bkg = enu_load_component(mefs->mef[i], "BKGDATA",
3433 "IMAGE", "BKG_DATA");
3434 enu_check_error_code("accessing BKGDATA extension");
3435 } else if (hduclas2 && !strcmp(hduclas2, "BKG_ERR")) {
3436 bkg_err = enu_load_component(mefs->mef[i], "BKGERR",
3437 "IMAGE", "BKG_ERR");
3438 enu_check_error_code("accessing BKGERR extension");
3439 } else if (hduclas2 && !strcmp(hduclas2, "BKG_CONF")) {
3440 bkg_conf = enu_load_component(mefs->mef[i], "BKGCONF",
3441 "IMAGE", "BKG_CONF");
3442 enu_check_error_code("accessing BKGCONF extension");
3443 }
3444 }
3445*/
3446 /* set the data mask from quality, construct the hdrl image */
3447/*
3448 enu_check(data != NULL, CPL_ERROR_BAD_FILE_FORMAT,
3449 "no data in file");
3450 cpl_mask * bpm = cpl_image_get_bpm(data);
3451 cpl_mask_threshold_image(bpm, qual, 0.9, 1.1, CPL_BINARY_1);
3452 bpm = cpl_image_get_bpm(err);
3453 cpl_mask_threshold_image(bpm, qual, 0.9, 1.1, CPL_BINARY_1);
3454 hdrl_image * hdata = hdrl_image_create(data, err);
3455 hdrl_image * hbkg = NULL;
3456 if (bkg) {
3457 hbkg = hdrl_image_create(bkg, bkg_err);
3458 }
3459
3460 limage = enu_located_image_new(hdata, NULL, conf, hbkg,
3461 bkg_conf,
3462 plist, NULL, NULL, NULL, NULL,
3463 cpl_frame_duplicate(frame));
3464 plist = NULL;
3465 cpl_image_delete(data);
3466 cpl_image_delete(err);
3467 cpl_image_delete(qual);
3468 cpl_image_delete(bkg);
3469 cpl_image_delete(bkg_err);
3470 data = NULL;
3471 err = NULL;
3472 qual = NULL;
3473 conf = NULL;
3474 bkg = NULL;
3475 bkg_err = NULL;
3476 bkg_conf = NULL;
3477 }
3478 if(frame_format != NULL) {
3479 cpl_free(frame_format);
3480 }
3481 if(first_ext != NULL) {
3482 cpl_free(first_ext);
3483 }
3484*/
3485 /* insert new located_image into list */
3486
3487 enu_located_imagelist_insert(result, limage, position);
3488
3489 /* Update used_frameset */
3490
3491 cpl_frame * dup_frame = cpl_frame_duplicate(frame);
3492 cpl_frameset_insert(used, dup_frame);
3493
3494 position++;
3495 }
3496 }
3497
3498 //cleanup:
3499
3500 cpl_propertylist_delete(plist);
3501 cpl_image_delete(data);
3502 cpl_image_delete(err);
3503 cpl_image_delete(qual);
3504 cpl_image_delete(conf);
3505 cpl_image_delete(bkg);
3506 cpl_image_delete(bkg_err);
3507 cpl_image_delete(bkg_conf);
3508 enu_mef_extension_list_delete(mefs);
3509 cpl_frameset_iterator_delete(frameset_iter);
3510 if (cpl_error_get_code() != CPL_ERROR_NONE) {
3511 enu_located_imagelist_delete(result);
3512 result = NULL;
3513 }
3514 eris_check_error_code("enu_limlist_load_from_frameset");
3515 return result;
3516}
3517
3518
3519/*----------------------------------------------------------------------------*/
3531/*----------------------------------------------------------------------------*/
3532
3533cpl_image * enu_load_component(mef_extension * mef,
3534 const char * dps_name,
3535 const char * hduclas1,
3536 const char * hduclas2) {
3537
3538 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
3539 cpl_ensure(mef, CPL_ERROR_NULL_INPUT, NULL);
3540 cpl_ensure(dps_name, CPL_ERROR_NULL_INPUT, NULL);
3541 cpl_ensure(hduclas1, CPL_ERROR_NULL_INPUT, NULL);
3542 cpl_ensure(hduclas2, CPL_ERROR_NULL_INPUT, NULL);
3543
3544 cpl_image * result = NULL;
3545
3546 cpl_propertylist * plist = mef->plist;
3547 const char * hduclass = cpl_propertylist_get_string(plist, "HDUCLASS");
3548 const char * hdudoc = cpl_propertylist_get_string(plist, "HDUDOC");
3549 //const char * hduvers = cpl_propertylist_get_string(plist, "HDUVERS");
3550 const char * my_hduclas1 = cpl_propertylist_get_string(plist, "HDUCLAS1");
3551 const char * my_hduclas2 = cpl_propertylist_get_string(plist, "HDUCLAS2");
3552
3553 enu_check(strstr(hduclass, "ESO") != NULL &&
3554 strstr(hdudoc, "SDP") != NULL &&
3555 //strstr(hduvers, "SDP version 8") != NULL &&
3556 strstr(my_hduclas1, hduclas1) != NULL &&
3557 strstr(my_hduclas2, hduclas2) != NULL,
3558 CPL_ERROR_BAD_FILE_FORMAT, "bad %s format", dps_name);
3559
3560 result = mef->data;
3561
3562 cleanup:
3563 if (cpl_error_get_code() != CPL_ERROR_NONE) {
3564 result = NULL;
3565 }
3566 if (result != NULL) mef->data = NULL;
3567 eris_check_error_code("enu_load_component");
3568 return result;
3569}
3570
3571
3572/*----------------------------------------------------------------------------*/
3580/*----------------------------------------------------------------------------*/
3581
3582void enu_located_imagelist_delete(located_imagelist * limlist) {
3583
3584 if (limlist) {
3585 for (cpl_size i = 0; i < limlist->size; i++) {
3586 enu_located_image_delete(limlist->limages[i]);
3587 }
3588 cpl_free(limlist->limages);
3589 cpl_free(limlist);
3590 }
3591}
3592
3593
3594/*----------------------------------------------------------------------------*/
3602/*----------------------------------------------------------------------------*/
3603
3604located_imagelist * enu_located_imagelist_duplicate(
3605 const located_imagelist * limlist) {
3606
3607 cpl_ensure(limlist, CPL_ERROR_NULL_INPUT, NULL);
3608
3609 located_imagelist * result = enu_located_imagelist_new(limlist->size);
3610 for (cpl_size i = 0; i < limlist->size; i++) {
3611 enu_located_imagelist_insert(result,
3612 enu_located_image_duplicate(
3613 limlist->limages[i]), i);
3614 }
3615
3616 return result;
3617}
3618
3619
3620/*----------------------------------------------------------------------------*/
3631/*----------------------------------------------------------------------------*/
3632
3633cpl_error_code enu_located_imagelist_insert(located_imagelist * limlist,
3634 located_image * limage,
3635 cpl_size position) {
3636
3637 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
3638
3639 /* position valid? */
3640
3641 cpl_ensure_code(position >= 0 && position < limlist->size,
3642 CPL_ERROR_ACCESS_OUT_OF_RANGE);
3643 limlist->limages[position] = limage;
3644
3645 return cpl_error_get_code();
3646}
3647
3648
3649/*----------------------------------------------------------------------------*/
3658/*----------------------------------------------------------------------------*/
3659
3660located_imagelist * enu_located_imagelist_new(cpl_size size) {
3661
3662 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
3663
3664 located_imagelist * limlist = cpl_malloc(sizeof(located_imagelist));
3665 limlist->size = size;
3666 limlist->limages = cpl_calloc(size, sizeof(located_image));
3667 for (cpl_size i = 0; i < limlist->size; i++) {
3668 limlist->limages[i] = NULL;
3669 }
3670 return limlist;
3671}
3672
3673
3674/*----------------------------------------------------------------------------*/
3682/*----------------------------------------------------------------------------*/
3683
3684void enu_mef_extension_delete(mef_extension * mef) {
3685
3686 if (mef) {
3687 if (!strcmp(mef->data_type, MEF_EXTENSION_CONTAINING_IMAGE)) {
3688 cpl_image_delete((cpl_image *) (mef->data));
3689 } else if (!strcmp(mef->data_type, MEF_EXTENSION_CONTAINING_MASK)) {
3690 cpl_mask_delete((cpl_mask *) mef->data);
3691 } else if (!strcmp(mef->data_type, MEF_EXTENSION_CONTAINING_TABLE)) {
3692 cpl_table_delete((cpl_table *) mef->data);
3693 } else if (!strcmp(mef->data_type, MEF_EXTENSION_CONTAINING_VECTOR)) {
3694 cpl_vector_delete((cpl_vector *) mef->data);
3695 } else {
3696 cpl_error_set("enu_mef_extension_delete",
3697 CPL_ERROR_UNSUPPORTED_MODE);
3698 }
3699 cpl_propertylist_delete(mef->plist);
3700 cpl_free(mef->name);
3701 cpl_free(mef);
3702 }
3703}
3704
3705
3706/*----------------------------------------------------------------------------*/
3714/*----------------------------------------------------------------------------*/
3715
3716void enu_mef_extension_list_delete(mef_extension_list * list) {
3717
3718 if (list) {
3719 for (cpl_size i = 0; i < list->size; i++) {
3720 enu_mef_extension_delete(list->mef[i]);
3721 }
3722 cpl_free(list->mef);
3723 cpl_free(list);
3724 }
3725}
3726
3727
3728/*----------------------------------------------------------------------------*/
3738/*----------------------------------------------------------------------------*/
3739
3740cpl_mask * enu_mef_extension_list_get_mask(mef_extension_list * meflist,
3741 const char * target) {
3742
3743 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
3744
3745 cpl_ensure(meflist, CPL_ERROR_NULL_INPUT, NULL);
3746 cpl_ensure(target, CPL_ERROR_NULL_INPUT, NULL);
3747
3748 /* Search for extension */
3749
3750 cpl_mask * result = NULL;
3751 for (int i=0; i<meflist->size; i++) {
3752 if (!strcmp(meflist->mef[i]->name, target)) {
3753 cpl_ensure(!strcmp(meflist->mef[i]->data_type,
3754 MEF_EXTENSION_CONTAINING_MASK),
3755 CPL_ERROR_INCOMPATIBLE_INPUT, NULL);
3756 result = cpl_mask_duplicate((const cpl_mask *) meflist->mef[i]->data);
3757 break;
3758 }
3759 }
3760
3761 /* Check that the extensions was found */
3762
3763 cpl_ensure(result, CPL_ERROR_DATA_NOT_FOUND, NULL);
3764
3765 return result;
3766}
3767
3768
3769/*----------------------------------------------------------------------------*/
3778/*----------------------------------------------------------------------------*/
3779
3780mef_extension_list * enu_mef_extension_list_new(cpl_size size) {
3781
3782 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
3783
3784 mef_extension_list * mef_list = cpl_malloc(sizeof(mef_extension_list));
3785 mef_list->size = size;
3786 mef_list->mef = cpl_calloc(size, sizeof(mef_extension));
3787 for (cpl_size i = 0; i < size; i++) {
3788 mef_list->mef[i] = NULL;
3789 }
3790
3791 return mef_list;
3792}
3793
3794
3795/*----------------------------------------------------------------------------*/
3809/*----------------------------------------------------------------------------*/
3810
3811mef_extension * enu_mef_new_image(const char * name,
3812 const cpl_image * data,
3813 const cpl_propertylist * plist) {
3814
3815 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
3816
3817 /* check parameters */
3818
3819 cpl_ensure(name && data, CPL_ERROR_NULL_INPUT, NULL);
3820
3821 mef_extension * result = cpl_malloc(sizeof(mef_extension));
3822 result->name = cpl_strdup(name);
3823 result->data = (void *) cpl_image_duplicate(data);
3824 result->data_type = MEF_EXTENSION_CONTAINING_IMAGE;
3825 if (plist) {
3826 result->plist = cpl_propertylist_duplicate(plist);
3827 } else {
3828 result->plist = NULL;
3829 }
3830 return result;
3831}
3832
3833
3834/*----------------------------------------------------------------------------*/
3848/*----------------------------------------------------------------------------*/
3849
3850mef_extension * enu_mef_new_mask(const char * name,
3851 const cpl_mask * data,
3852 const cpl_propertylist * plist) {
3853
3854 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
3855
3856 /* check parameters */
3857
3858 cpl_ensure(name && data, CPL_ERROR_NULL_INPUT, NULL);
3859
3860 mef_extension * result = cpl_malloc(sizeof(mef_extension));
3861 result->name = cpl_strdup(name);
3862 result->data = (void *) cpl_mask_duplicate(data);
3863 result->data_type = MEF_EXTENSION_CONTAINING_MASK;
3864 if (plist) {
3865 result->plist = cpl_propertylist_duplicate(plist);
3866 } else {
3867 result->plist = NULL;
3868 }
3869 return result;
3870}
3871
3872
3873/*----------------------------------------------------------------------------*/
3887/*----------------------------------------------------------------------------*/
3888
3889mef_extension * enu_mef_new_table(const char * name,
3890 const cpl_table * table,
3891 const cpl_propertylist * plist) {
3892
3893 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
3894 cpl_ensure(name, CPL_ERROR_NULL_INPUT, NULL);
3895 cpl_ensure(table, CPL_ERROR_NULL_INPUT, NULL);
3896
3897 mef_extension * result = cpl_malloc(sizeof(mef_extension));
3898 result->name = cpl_strdup(name);
3899 result->data = (void *) cpl_table_duplicate(table);
3900 result->plist = NULL;
3901 if (plist) {
3902 result->plist = cpl_propertylist_duplicate(plist);
3903 } else {
3904 result->plist = NULL;
3905 }
3906 result->data_type = MEF_EXTENSION_CONTAINING_TABLE;
3907
3908 return result;
3909}
3910
3911
3912/*----------------------------------------------------------------------------*/
3926/*----------------------------------------------------------------------------*/
3927
3928mef_extension * enu_mef_new_vector(const char * name,
3929 const cpl_vector * vector,
3930 const cpl_propertylist * plist) {
3931
3932 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
3933 cpl_ensure(name, CPL_ERROR_NULL_INPUT, NULL);
3934 cpl_ensure(vector, CPL_ERROR_NULL_INPUT, NULL);
3935
3936 mef_extension * result = cpl_malloc(sizeof(mef_extension));
3937 result->name = cpl_strdup(name);
3938 result->data = (void *) cpl_vector_duplicate(vector);
3939 result->plist = NULL;
3940 if (plist) {
3941 result->plist = cpl_propertylist_duplicate(plist);
3942 } else {
3943 result->plist = NULL;
3944 }
3945 result->data_type = MEF_EXTENSION_CONTAINING_VECTOR;
3946
3947 return result;
3948}
3949
3950
3951/*----------------------------------------------------------------------------*/
3963/*----------------------------------------------------------------------------*/
3964
3965cpl_error_code enu_mef_extension_save(const mef_extension * mef,
3966 const char * filename,
3967 const cpl_propertylist * plist,
3968 unsigned mode) {
3969
3970 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
3971
3972 cpl_msg_debug(cpl_func, "enu_mef_extension_save entry");
3973
3974 cpl_propertylist * plist_copy = NULL;
3975
3976 /* check parameters, only one of the data types can be set */
3977
3978 cpl_ensure_code(mef, CPL_ERROR_NULL_INPUT);
3979 cpl_ensure_code(filename, CPL_ERROR_NULL_INPUT);
3980 cpl_ensure_code(plist, CPL_ERROR_NULL_INPUT);
3981
3982 plist_copy = cpl_propertylist_duplicate(plist);
3983 cpl_propertylist_update_string(plist_copy, "ERIS_NIX_MEF_TYPE",
3984 mef->data_type);
3985
3986 if (!strcmp(mef->data_type, MEF_EXTENSION_CONTAINING_IMAGE)) {
3987 if (cpl_propertylist_has(plist, "CD3_3")) {
3988 //double cd3_3 = cpl_propertylist_get_double(plist, "CD3_3");
3989
3990 /* the existence of CD3_3 in the header means that this
3991 data has ndim=3. In the LSS case that 3rd
3992 dimension is degenerate but allows the wcs decription to
3993 work.
3994
3995 To get CPL to store NDIM=3 we have to store the
3996 2d data as one image in an imagelist. */
3997
3998 cpl_msg_info(cpl_func, "..saving data with NDIM=3");
3999
4000 cpl_imagelist * imlist = cpl_imagelist_new();
4001 cpl_imagelist_set(imlist, mef->data, 0);
4002 cpl_imagelist_save(imlist,
4003 filename,
4004 CPL_TYPE_UNSPECIFIED,
4005 plist_copy,
4006 mode);
4007 /* let image data be deleted with mef */
4008 cpl_imagelist_unset(imlist, 0);
4009 cpl_imagelist_delete(imlist);
4010
4011 } else {
4012 cpl_image_save((const cpl_image *) (mef->data),
4013 filename,
4014 CPL_TYPE_UNSPECIFIED,
4015 plist_copy,
4016 mode);
4017 }
4018 } else if (!strcmp(mef->data_type, MEF_EXTENSION_CONTAINING_MASK)) {
4019 cpl_mask_save((const cpl_mask *) (mef->data),
4020 filename,
4021 plist_copy,
4022 mode);
4023 } else if (!strcmp(mef->data_type, MEF_EXTENSION_CONTAINING_TABLE)) {
4024 cpl_table_save((const cpl_table *) (mef->data),
4025 NULL,
4026 plist_copy,
4027 filename,
4028 mode);
4029 } else if (!strcmp(mef->data_type, MEF_EXTENSION_CONTAINING_VECTOR)) {
4030 cpl_vector_save((const cpl_vector *) (mef->data),
4031 filename,
4032 CPL_TYPE_DOUBLE,
4033 plist_copy,
4034 mode);
4035 } else {
4036 cpl_error_set_message("enu_mef_extension_save",
4037 CPL_ERROR_UNSUPPORTED_MODE,
4038 "unsupported extension type: %s", mef->data_type);
4039 }
4040
4041 cpl_propertylist_delete(plist_copy);
4042 eris_check_error_code("enu_mef_extension_save");
4043 return cpl_error_get_code();
4044}
4045
4046
4047/*----------------------------------------------------------------------------*/
4061/*----------------------------------------------------------------------------*/
4062
4063cpl_error_code enu_opm_limlist(const int obj_min_pixels,
4064 const double obj_threshold,
4065 const int bkg_mesh_size,
4066 const double bkg_smooth_fwhm,
4067 located_imagelist * limlist) {
4068
4069 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
4070
4071 /* parameter check */
4072
4073 cpl_ensure_code(limlist, CPL_ERROR_NULL_INPUT);
4074
4075 casu_fits ** indata = NULL;
4076 casu_fits ** inconf = NULL;
4077 casu_fits ** invar = NULL;
4078
4079 /* translate located_imagelist to casu_fits components */
4080
4081 encu_limlist_to_casu_fits(limlist, &indata, &inconf, &invar);
4082
4083 /* loop through the located_images, calculate the object mask
4084 for each, copy that mask to the object_mask in the located_image */
4085
4086 int casu_status = CASU_OK;
4087 int niter = 3;
4088
4089 cpl_msg_info(cpl_func, ".. calculating object masks");
4090 for (cpl_size j = 0; j < limlist->size; j++) {
4091 casu_opm(indata[j], inconf[j], obj_min_pixels, obj_threshold,
4092 bkg_mesh_size, bkg_smooth_fwhm, niter, &casu_status);
4093 enu_check(casu_status == CASU_OK, CPL_ERROR_UNSPECIFIED,
4094 "CASU error calculating object mask");
4095 limlist->limages[j]->object_mask = cpl_mask_duplicate(
4096 cpl_image_get_bpm(indata[j]->image));
4097 }
4098
4099 cleanup:
4100
4101 for (cpl_size j = 0; j < limlist->size; j++) {
4102 casu_fits_delete(indata[j]);
4103 casu_fits_delete(inconf[j]);
4104 casu_fits_delete(invar[j]);
4105 }
4106 cpl_free(indata);
4107 cpl_free(inconf);
4108 cpl_free(invar);
4109 eris_check_error_code("enu_opm_limlist");
4110 return cpl_error_get_code();
4111}
4112
4113
4114/*----------------------------------------------------------------------------*/
4130/*----------------------------------------------------------------------------*/
4131
4132cpl_error_code enu_opm_lss_limlist(located_imagelist * limlist,
4133 const int nsigma_cut) {
4134
4135 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
4136 cpl_ensure_code(limlist, CPL_ERROR_NULL_INPUT);
4137
4138 cpl_msg_info(cpl_func, "..calculating LSS object pixel mask");
4139
4140 /* loop through the located_images, calculate the object mask
4141 for each, copy that mask to the object_mask in the located_image */
4142
4143 for (cpl_size j = 0; j < limlist->size; j++) {
4144 cpl_size nx = hdrl_image_get_size_x(limlist->limages[j]->himage);
4145 cpl_size ny = hdrl_image_get_size_y(limlist->limages[j]->himage);
4146 cpl_image * collapsed = cpl_image_collapse_median_create(
4147 hdrl_image_get_image(
4148 limlist->limages[j]->himage), 0, 0, 0);
4149
4150 /* mask for pixels that are unusually high */
4151
4152 double csigma = 0.0;
4153 double cmedian = cpl_image_get_median_dev(collapsed, &csigma);
4154 double maxval = cpl_image_get_max(collapsed);
4155 cpl_mask * collapsed_opm = cpl_mask_threshold_image_create(
4156 collapsed, cmedian + nsigma_cut * csigma,
4157 2.0 * maxval);
4158
4159 /* 'grow' the masked areas to try and catch lower level emission */
4160
4161 cpl_mask * kernel = cpl_mask_new(11, 1);
4162 cpl_mask_not(kernel);
4163 cpl_mask * dilated_collapsed_opm = cpl_mask_new(nx, 1);
4164 cpl_mask_filter(dilated_collapsed_opm, collapsed_opm, kernel,
4165 CPL_FILTER_DILATION, CPL_BORDER_NOP);
4166 cpl_mask_delete(kernel);
4167
4168 /* grow the 1d mask to a 2d image */
4169
4170 const cpl_binary * collapsed_opm_data = cpl_mask_get_data_const(
4171 dilated_collapsed_opm);
4172 cpl_mask * opm = cpl_mask_new(nx, ny);
4173 cpl_binary * opm_data = cpl_mask_get_data(opm);
4174 for (cpl_size iy=0; iy < ny; iy++) {
4175 memcpy(opm_data + iy * (nx * sizeof(*opm_data)),
4176 collapsed_opm_data,
4177 nx * sizeof(*opm_data));
4178 }
4179
4180 /* set the object_mask of the located_image */
4181
4182 cpl_mask_delete(limlist->limages[j]->object_mask);
4183 limlist->limages[j]->object_mask = opm;
4184
4185 cpl_image_delete(collapsed);
4186 cpl_mask_delete(collapsed_opm);
4187 cpl_mask_delete(dilated_collapsed_opm);
4188 }
4189 eris_check_error_code("enu_opm_lss_limlist");
4190 return cpl_error_get_code();
4191}
4192
4193
4194/*----------------------------------------------------------------------------*/
4207/*----------------------------------------------------------------------------*/
4208
4209cpl_error_code enu_correct_wcs(const cpl_table * refcat,
4210 const char * wcs_method,
4211 const char * catalogue,
4212 located_image * limage,
4213 const double match_rad,
4214 cpl_table ** matched_stds,
4215 cpl_matrix ** xy_shift) {
4216
4217 cpl_matrix * celestial = NULL;
4218 cpl_array * colnames = NULL;
4219 cpl_array * conv_status = NULL;
4220 cpl_table * refcat_copy = NULL;
4221 cpl_matrix * ref_phys = NULL;
4222 cpl_matrix * ref_world = NULL;
4223 cpl_matrix * xy = NULL;
4224 cpl_wcs * wcs = NULL;
4225
4226 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
4227
4228 cpl_msg_info(cpl_func, "correcting %s", cpl_frame_get_filename(limage->frame));
4229
4230 *xy_shift = NULL;
4231
4232 cpl_msg_info(cpl_func, " ..%s", cpl_frame_get_filename(limage->frame));
4233
4234 /* calculate predicted positions of refcat objects for this wcs */
4235
4236 cpl_size nref = cpl_table_get_nrow(refcat);
4237 const double * ra = cpl_table_get_data_double_const(refcat, "RA");
4238 const double * dec = NULL;
4239 if (cpl_table_has_column(refcat, "DEC")) {
4240 dec = cpl_table_get_data_double_const(refcat, "DEC");
4241 }
4242 ref_world = cpl_matrix_new(nref, 2);
4243 for (cpl_size iobj = 0; iobj < nref; iobj++) {
4244 cpl_matrix_set(ref_world, iobj, 0, ra[iobj]);
4245 cpl_matrix_set(ref_world, iobj, 1, dec[iobj]);
4246 }
4247 wcs = cpl_wcs_new_from_propertylist(limage->plist);
4248 cpl_wcs_convert(wcs, ref_world, &ref_phys, &conv_status,
4249 CPL_WCS_WORLD2PHYS);
4250 enu_check_error_code("failure calculating predicted positions");
4251
4252 /* Store the predicted positions in columns of a duplicate refcat
4253 but with all columns removed except RA, DEC, 'Std index',
4254 Aper_flux_3 */
4255
4256 refcat_copy = cpl_table_duplicate(refcat);
4257 colnames = cpl_table_get_column_names(refcat_copy);
4258 cpl_size ncol = cpl_array_get_size(colnames);
4259 for (cpl_size ic = 0; ic < ncol; ic++) {
4260 const char * colname = cpl_array_get_string(colnames, ic);
4261 if (strcmp(colname, "RA") &&
4262 strcmp(colname, "DEC") &&
4263 strcmp(colname, "Aper_flux_3") &&
4264 strcmp(colname, "Std index")) {
4265 cpl_table_erase_column(refcat_copy, colname);
4266 }
4267 }
4268
4269 /* add xpredict and ypredict columns */
4270
4271 cpl_table_new_column(refcat_copy, "xpredict", CPL_TYPE_DOUBLE);
4272 cpl_table_new_column(refcat_copy, "ypredict", CPL_TYPE_DOUBLE);
4273 for (cpl_size iobj = 0; iobj < nref; iobj++) {
4274 cpl_table_set_double(refcat_copy, "xpredict", iobj,
4275 cpl_matrix_get(ref_phys, iobj, 0));
4276 cpl_table_set_double(refcat_copy, "ypredict", iobj,
4277 cpl_matrix_get(ref_phys, iobj, 1));
4278 }
4279 enu_check_error_code("failure while creating predicted positions");
4280
4281 /* Match detected sources with refcat_copy */
4282
4283 cpl_msg_info(cpl_func, " ..matching sources");
4284 cpl_size nobj = 0;
4285 if (limage->objects && limage->objects->catalogue) {
4286 nobj = cpl_table_get_nrow(limage->objects->catalogue);
4287 }
4288
4289 if (min(nref, nobj) > 0) {
4290
4291 cpl_msg_info(cpl_func, " ..calling enm_try_all_associations");
4292
4293 enm_try_all_associations(limage->objects->catalogue,
4294 refcat_copy,
4295 match_rad,
4296 matched_stds);
4297 enu_check_error_code("enu_correct_wcs failure at "
4298 "try_all_associations");
4299
4300 enm_correct_crpix(wcs_method,
4301 catalogue,
4302 *matched_stds,
4303 limage,
4304 xy_shift);
4305 enu_check_error_code("failure to correct wcs");
4306
4307 } else {
4308 cpl_msg_info(cpl_func, " ..no catalogued objects, cannot correct wcs");
4309 }
4310
4311 cleanup:
4312 cpl_matrix_delete(celestial);
4313 cpl_array_delete(colnames);
4314 cpl_array_delete(conv_status);
4315 cpl_table_delete(refcat_copy);
4316 cpl_matrix_delete(ref_phys);
4317 cpl_matrix_delete(ref_world);
4318 cpl_matrix_delete(xy);
4319 cpl_wcs_delete(wcs);
4320 eris_check_error_code("enu_correct_wcs");
4321 return cpl_error_get_code();
4322}
4323
4324
4325/*----------------------------------------------------------------------------*/
4335/*----------------------------------------------------------------------------*/
4336
4337cpl_error_code enu_modify_CD_matrix(located_image * limage,
4338 const cpl_table * refine_wcs) {
4339
4340 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
4341 cpl_ensure_code(limage, CPL_ERROR_NULL_INPUT);
4342
4343 if (!refine_wcs) return CPL_ERROR_NONE;
4344
4345 const char * camera = cpl_propertylist_get_string(limage->plist,
4346 "ESO INS2 NXCW NAME");
4347 enu_check(camera != NULL,
4348 CPL_ERROR_ILLEGAL_INPUT,
4349 "failed to read NIX camera from ESO.INS2.NXCW.NAME");
4350
4351 cpl_size nrow = cpl_table_get_nrow(refine_wcs);
4352 cpl_boolean match = CPL_FALSE;
4353
4354 double cd1_1 = 0.0;
4355 double cd1_2 = 0.0;
4356 double cd2_1 = 0.0;
4357 double cd2_2 = 0.0;
4358
4359 for (cpl_size row = 0; row < nrow; row++) {
4360 const char * row_cam = cpl_table_get_string(refine_wcs, "camera", row);
4361
4362 if (!strcmp(camera, row_cam)) {
4363 match = CPL_TRUE;
4364
4365 int ignore = 0;
4366 cd1_1 = cpl_table_get_double(refine_wcs, "CD1_1", row, &ignore);
4367 cd1_2 = cpl_table_get_double(refine_wcs, "CD1_2", row, &ignore);
4368 cd2_1 = cpl_table_get_double(refine_wcs, "CD2_1", row, &ignore);
4369 cd2_2 = cpl_table_get_double(refine_wcs, "CD2_2", row, &ignore);
4370 /*
4371 cpl_msg_info(cpl_func,
4372 "camera %s %s cd1_1 %10.8e cd1_2 %10.8e cd2_1 %10.8e cd2_2 %10.8e",
4373 camera, row_cam, cd1_1, cd1_2, cd2_1, cd2_2);
4374 */
4375 cpl_propertylist_update_double(limage->plist, "CD1_1", cd1_1);
4376 cpl_propertylist_update_double(limage->plist, "CD1_2", cd1_2);
4377 cpl_propertylist_update_double(limage->plist, "CD2_1", cd2_1);
4378 cpl_propertylist_update_double(limage->plist, "CD2_2", cd2_2);
4379 }
4380 }
4381
4382 if (!match) {
4383 cpl_error_set_message(cpl_func,
4384 CPL_ERROR_ILLEGAL_INPUT,
4385 "camera name not matched: %s",
4386 camera);
4387 } else {
4388 cd1_1 = cpl_propertylist_get_double(limage->plist, "CD1_1");
4389 cd1_2 = cpl_propertylist_get_double(limage->plist, "CD1_2");
4390 cd2_1 = cpl_propertylist_get_double(limage->plist, "CD2_1");
4391 cd2_2 = cpl_propertylist_get_double(limage->plist, "CD2_2");
4392 cpl_msg_info(cpl_func, "..set CD matrix cd1_1=%10.8e cd1_2=%10.8e "
4393 "cd_2_1=%10.8e cd2_2=%10.8e",
4394 cd1_1, cd1_2, cd2_1, cd2_2);
4395 }
4396
4397 cleanup:
4398 eris_check_error_code("enu_modify_CD_matrix");
4399 return cpl_error_get_code();
4400}
4401
4402
4403/*----------------------------------------------------------------------------*/
4413/*----------------------------------------------------------------------------*/
4414
4415cpl_error_code enu_normalise_confidence(cpl_image * confidence) {
4416
4417 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
4418 cpl_ensure_code(confidence, CPL_ERROR_NULL_INPUT);
4419
4420 const cpl_size nx = cpl_image_get_size_x(confidence);
4421 const cpl_size ny = cpl_image_get_size_y(confidence);
4422 double * data = cpl_image_get_data_double(confidence);
4423 /* Avoid creation + checking of empty bpm */
4424 const cpl_mask * bpm = cpl_image_get_bpm_const(confidence);
4425 cpl_mask * mask = bpm ? cpl_image_get_bpm(confidence) : NULL;
4426 cpl_binary * mask_data = bpm ? cpl_mask_get_data(mask) : NULL;
4427
4428 double sum = 0.0;
4429 int nonzero = 0;
4430
4431 for (cpl_size i = 0; i < nx*ny; i++) {
4432 if (mask_data != NULL && mask_data[i] == CPL_TRUE) {
4433 mask_data[i] = CPL_FALSE;
4434 data[i] = 0.0;
4435 }
4436 if (data[i] < 0.0) data[i] = 0.0;
4437 sum += data[i];
4438 if (data[i] > 0.0) nonzero++;
4439 }
4440
4441 if (sum > 0.0) {
4442 cpl_image_multiply_scalar(confidence, 100.0 * (double)nonzero / sum);
4443 }
4444 eris_check_error_code("enu_normalise_confidence");
4445 return cpl_error_get_code();
4446}
4447
4448
4449/*----------------------------------------------------------------------------*/
4483/*----------------------------------------------------------------------------*/
4484
4485
4486cpl_error_code enu_remove_read_offsets(hdrl_image * himage,
4487 const cpl_propertylist * plist,
4488 cpl_image * confidence,
4489 const int set_confidence) {
4490
4491 cpl_image * himg = hdrl_image_get_image(himage);
4492 cpl_image * eimg = hdrl_image_get_error(himage);
4493 double * hdata = cpl_image_get_data_double(himg);
4494 double * edata = cpl_image_get_data_double(eimg);
4495 cpl_binary* hbpm = cpl_mask_get_data(cpl_image_get_bpm(himg));
4496 cpl_binary* ebpm = cpl_mask_get_data(cpl_image_get_bpm(eimg));
4497 const int mx = cpl_image_get_size_x(himg);
4498 cpl_boolean is_fast_uncorr = CPL_FALSE;
4499 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
4500
4501 /* check that the image data is double */
4502 cpl_ensure_code(hdata != NULL, CPL_ERROR_UNSUPPORTED_MODE);
4503 cpl_ensure_code(edata != NULL, CPL_ERROR_UNSUPPORTED_MODE);
4504 cpl_ensure_code(hbpm != NULL, CPL_ERROR_UNSUPPORTED_MODE);
4505 cpl_ensure_code(ebpm != NULL, CPL_ERROR_UNSUPPORTED_MODE);
4506
4507 cpl_ensure_code(plist, CPL_ERROR_NULL_INPUT);
4508
4509 /* get window information */
4510
4511 cpl_size nx = 0;
4512 cpl_size ny = 0;
4513 int rot = 0;
4514 cpl_size strx = 0;
4515 cpl_size stry = 0;
4516 cpl_size nx_chip = 0;
4517 cpl_size ny_chip = 0;
4518 cpl_boolean windowed = 0;
4519 enu_get_window_info(&nx,
4520 &ny,
4521 &rot,
4522 &strx,
4523 &stry,
4524 &nx_chip,
4525 &ny_chip,
4526 &windowed,
4527 plist);
4528 enu_check_error_code("failed to read detector window information");
4529
4530 /* determine whether bottom edge of detector is corrupted by
4531 problem with short DITDELAY. Base this on the MJD of the
4532 observation - the fix was applied around 1-Mar-2023 = MJD 60004 */
4533
4534 double mjd = cpl_propertylist_get_double(plist, "MJD-OBS");
4535 enu_check_error_code("failed to read MJD-OBS");
4536 if (mjd <= 60004) {
4537 cpl_msg_info(cpl_func, "PIPE-10417 DITDELAY bug, "
4538 "remove_read_offsets will ignore bottom 4 rows "
4539 "of chip");
4540 }
4541 const char * curr_name = cpl_propertylist_get_string(plist, "ESO DET READ CURNAME");
4542 if (strcmp(curr_name, "FAST_UNCORR") == 0) {
4543 is_fast_uncorr = CPL_TRUE;
4544 }
4545 cpl_size top_width = 4;
4546 cpl_size bottom_width = 4;
4547 cpl_msg_debug(cpl_func,
4548 "..offsets from %d top rows and %d bottom rows of chip",
4549 (int) top_width, (int) bottom_width);
4550
4551 cpl_size nread_chan = nx_chip / 64;
4552
4553 /* Calculate and remove the read offsets */
4554 /* ..loop through the read channels */
4555 cpl_vector* voff = cpl_vector_new(nread_chan);
4556 cpl_size ndata = 0;
4557 double* pvoff = cpl_vector_get_data(voff);
4558 for (cpl_size read_chan = 0; read_chan < nread_chan; read_chan++) {
4559
4560 /* calculate the offsets */
4561
4562 cpl_array * offset_data = cpl_array_new(0, CPL_TYPE_DOUBLE);
4563 ndata = 0;
4564
4565 for (cpl_size x = 64 * read_chan; x < 64 * (read_chan+1); x++) {
4566
4567 /* are we in the x window */
4568 /* window/pixel coords are 1-based, C index 0-based */
4569
4570 if (x+1 >= strx && x+1 < strx+nx) {
4571
4572 for (cpl_size y = 0; y < bottom_width; y++) {
4573
4574 /* are we in the y window */
4575
4576 if (y+1 >= stry && y+1 < stry+ny) {
4577 const int ipos = x-strx+1 + mx * (y-stry+1);
4578
4579 if (!hbpm[ipos]) {
4580 if (mjd > 60004) {
4581 const double pixval = hdata[ipos];
4582 /* bottom channels OK, include them in
4583 offsets */
4584 ndata++;
4585 cpl_array_set_size(offset_data, ndata);
4586 cpl_array_set(offset_data, ndata-1, pixval);
4587 }
4588 /* reject the bottom channels for subsequent use */
4589 hbpm[ipos] = CPL_BINARY_1;
4590 ebpm[ipos] = CPL_BINARY_1;
4591
4592 if (set_confidence && confidence) {
4593 cpl_image_set(confidence,
4594 x-strx+2,
4595 y-stry+2,
4596 0.0);
4597 }
4598 }
4599 }
4600 }
4601
4602 for (cpl_size y = ny_chip-top_width; y < ny_chip; y++) {
4603 if (y+1 >= stry && y+1 < stry+ny) {
4604 const int ipos = x-strx+1 + mx * (y-stry+1);
4605
4606 if (!hbpm[ipos]) {
4607 const double pixval = hdata[ipos];
4608 ndata++;
4609 cpl_array_set_size(offset_data, ndata);
4610 cpl_array_set(offset_data, ndata-1, pixval);
4611 hbpm[ipos] = CPL_BINARY_1;
4612 ebpm[ipos] = CPL_BINARY_1;
4613 if (set_confidence && confidence) {
4614 cpl_image_set(confidence,
4615 x-strx+2,
4616 y-stry+2,
4617 0.0);
4618 }
4619 }
4620 }
4621 }
4622 }
4623 }
4624
4625 /* ..Remove the offset */
4626
4627 hdrl_value offset = {0.0, 0.0};
4628 if (ndata > 0) {
4629 cpl_msg_debug(cpl_func, "read_chan %d", (int)read_chan);
4630 cpl_msg_debug(cpl_func, "ndata %d", (int)ndata);
4631 cpl_msg_debug(cpl_func, "median %f", cpl_array_get_median(offset_data));
4632 cpl_msg_debug(cpl_func, "mean %f", cpl_array_get_mean(offset_data));
4633 cpl_msg_debug(cpl_func, "std %f", cpl_array_get_stdev(offset_data));
4634
4635 /* simple rejection of biggest outliers, there seem to be some
4636 hot pixels even in the unused borders of the chip */
4637
4638 double mean = cpl_array_get_mean(offset_data);
4639 double stdev = cpl_array_get_stdev(offset_data);
4640 int nflagged = 0;
4641 for (cpl_size i = 0; i < cpl_array_get_size(offset_data); i++) {
4642 int invalid = 0;
4643 double datum = cpl_array_get_double(offset_data, i, &invalid);
4644 if (!invalid && fabs(datum - mean) > 5 * stdev) {
4645 cpl_array_set_invalid(offset_data, i);
4646 nflagged++;
4647 }
4648 }
4649
4650 offset.data = cpl_array_get_mean(offset_data);
4651 offset.error = cpl_array_get_stdev(offset_data);
4652 pvoff[read_chan] = offset.data;
4653
4654 cpl_msg_debug(cpl_func, "..removing offset %f (%f) for read "
4655 "channel %d", offset.data, offset.error,
4656 (int) read_chan);
4657
4658 for (cpl_size x = 64 * read_chan; x < 64 * (read_chan+1); x++) {
4659 for (cpl_size y = 0; y < ny_chip; y++) {
4660
4661 if (x+1 >= strx && x+1 < strx+nx &&
4662 y+1 >= stry && y+1 < stry+ny) {
4663 const int ipos = x-strx+1 + mx * (y-stry+1);
4664
4665 if (!hbpm[ipos]) {
4666 hdata[ipos] -= offset.data;
4667 edata[ipos] = hypot(edata[ipos], offset.error);
4668 }
4669 }
4670 }
4671 }
4672 }
4673 cpl_array_delete(offset_data);
4674 }
4675
4676
4677 /* if fast mode add back offset of offsets */
4678 if(is_fast_uncorr && ndata > 0) {
4679 cpl_image_add_scalar(himg,cpl_vector_get_mean(voff));
4680 }
4681
4682 /* reject blanked pixels at left/right edges of detector */
4683
4684 for (cpl_size y = 0; y < ny_chip; y++) {
4685 for (cpl_size x = 0; x < 4; x++) {
4686 /* in window? */
4687 if (x+1 >= strx && x+1 < strx+nx &&
4688 y+1 >= stry && y+1 < stry+ny) {
4689 const int ipos = x-strx+1 + mx * (y-stry+1);
4690
4691 hbpm[ipos] = CPL_BINARY_1;
4692 ebpm[ipos] = CPL_BINARY_1;
4693
4694 if (set_confidence && confidence) {
4695 cpl_image_set(confidence,
4696 x-strx+2,
4697 y-stry+2,
4698 0.0);
4699 }
4700 }
4701 }
4702 }
4703
4704 for (cpl_size y = 0; y < ny_chip; y++) {
4705 for (cpl_size x = nx_chip-4; x < nx_chip; x++) {
4706 /* in window? */
4707 if (x+1 >= strx && x+1 < strx+nx &&
4708 y+1 >= stry && y+1 < stry+ny) {
4709
4710 hdrl_image_reject(himage,
4711 x-strx+2,
4712 y-stry+2);
4713 if (set_confidence && confidence) {
4714 cpl_image_set(confidence,
4715 x-strx+2,
4716 y-stry+2,
4717 0.0);
4718 }
4719 }
4720 }
4721 }
4722
4723 cpl_vector_delete(voff);
4724 /* re-normalise the confidence array after the changes */
4725
4726 if (set_confidence && confidence) {
4727 enu_normalise_confidence(confidence);
4728 }
4729
4730 cleanup:
4731 eris_check_error_code("enu_remove_read_offsets");
4732 return cpl_error_get_code();
4733}
4734
4735
4736/*----------------------------------------------------------------------------*/
4743/*----------------------------------------------------------------------------*/
4744
4745char * enu_repreface(const char * filename,
4746 const char * preface) {
4747
4748 if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
4749
4750 char * in_name = cpl_strdup(filename);
4751
4752 /* expect data files to start with either ERIS.20xx or NACO.20xx */
4753 char * pch = strstr(filename, "ERIS.20");
4754 if (!pch) {
4755 pch = strstr(filename, "NACO.20");
4756 }
4757
4758 char * outname = cpl_sprintf("%s.%s", preface, pch);
4759 cpl_free(in_name);
4760
4761 return outname;
4762}
4763
4764
4765/*----------------------------------------------------------------------------*/
4780/*----------------------------------------------------------------------------*/
4781
4782
4783cpl_error_code enu_sky_backgrounds(const char * method,
4784 const char * select_method,
4785 const double timerange,
4786 const located_imagelist * target_list,
4787 const located_imagelist * sky_list,
4788 const cpl_size x_probe,
4789 const cpl_size y_probe,
4790 hdrl_imagelist ** sky_himagelist,
4791 cpl_imagelist ** sky_confidence_list) {
4792
4793 if (cpl_error_get_code() != CPL_ERROR_NONE) return cpl_error_get_code();
4794
4795 cpl_image * contrib = NULL;
4796 hdrl_imagelist * skylist = NULL;
4797 cpl_image * sky_confidence = NULL;
4798 hdrl_image * sky_himage = NULL;
4799 cpl_vector * sky_indeces = NULL;
4800
4801 cpl_msg_debug(cpl_func, "enu_sky_backgrounds entry");
4802
4803 /* parameter validation */
4804
4805 cpl_ensure_code(method, CPL_ERROR_NULL_INPUT);
4806 cpl_ensure_code(select_method, CPL_ERROR_NULL_INPUT);
4807 cpl_ensure_code(target_list, CPL_ERROR_NULL_INPUT);
4808 cpl_ensure_code(sky_list, CPL_ERROR_NULL_INPUT);
4809 cpl_ensure_code(!strcmp(select_method, "bracket") &&
4810 (timerange > 0.0), CPL_ERROR_ILLEGAL_INPUT);
4811
4812 *sky_himagelist = hdrl_imagelist_new();
4813 *sky_confidence_list = cpl_imagelist_new();
4814
4815 /* some variables used for probe pixel debugging */
4816
4817 int debug = CPL_FALSE;
4818 cpl_vector * data = NULL;
4819 cpl_vector * error = NULL;
4820 cpl_vector * reject = NULL;
4821 cpl_vector * confidence = NULL;
4822
4823 cpl_msg_info(cpl_func, "..calculating skys");
4824
4825 /* loop through target images */
4826
4827 cpl_size njitters = target_list->size;
4828 for (cpl_size j = 0; j < njitters; j++) {
4829
4830 /* Get the indices of relevant sky images */
4831
4832 if (strstr(select_method, "bracket") != NULL) {
4833 sky_indeces = enu_bracket_skys(target_list->limages[j], timerange,
4834 sky_list, x_probe > -1);
4835 }
4836 enu_check_error_code("failure in enu_bracket_skys");
4837
4838 cpl_size skysize = cpl_vector_get_size(sky_indeces);
4839 debug = CPL_FALSE;
4840 if (x_probe > 0 && skysize > 0) {
4841 const cpl_size x_size = hdrl_image_get_size_x(
4842 sky_list->limages[0]->himage);
4843 const cpl_size y_size = hdrl_image_get_size_y(
4844 sky_list->limages[0]->himage);
4845 if (x_probe > 0 && x_probe <= x_size &&
4846 y_probe > 0 && y_probe <= y_size) {
4847 debug = CPL_TRUE;
4848 if (skysize > 0) {
4849 data = cpl_vector_new(skysize);
4850 error = cpl_vector_new(skysize);
4851 reject = cpl_vector_new(skysize);
4852 confidence = cpl_vector_new(skysize);
4853 }
4854 }
4855 }
4856
4857 if (strstr(method, "collapse-median") != NULL) {
4858
4859 /* construct an hdrl_imagelist of the jitters to be combined,
4860 accumulate coadd of confidence arrays, apply object_masks
4861 if such defined in the located_images */
4862
4863 skylist = hdrl_imagelist_new();
4864 for (int k = 0; k < (int)skysize; k++) {
4865 int i = (int)cpl_vector_get(sky_indeces, k);
4866 hdrl_image * imcopy = hdrl_image_duplicate(sky_list->
4867 limages[i]->himage);
4868 cpl_image * confcopy = cpl_image_duplicate(sky_list->
4869 limages[i]->confidence);
4870 if (sky_list->limages[i]->object_mask != NULL) {
4871 cpl_mask_or(cpl_image_get_bpm(hdrl_image_get_image(imcopy)),
4872 sky_list->limages[i]->object_mask);
4873 cpl_mask_or(cpl_image_get_bpm(confcopy),
4874 sky_list->limages[i]->object_mask);
4875 cpl_image_fill_rejected(confcopy, 0.0);
4876 cpl_image_accept_all(confcopy);
4877 }
4878
4879 if (debug) {
4880 int rejected = 1;
4881 hdrl_value himval = hdrl_image_get_pixel(imcopy,
4882 x_probe, y_probe, &rejected);
4883 int ignore = 1;
4884 double conf = cpl_image_get(confcopy,
4885 x_probe, y_probe,
4886 &ignore);
4887 cpl_vector_set(data, k, himval.data);
4888 cpl_vector_set(error, k, himval.error);
4889 cpl_vector_set(reject, k, (double)rejected);
4890 cpl_vector_set(confidence, k, conf);
4891 }
4892
4893 hdrl_imagelist_set(skylist, imcopy,
4894 hdrl_imagelist_get_size(skylist));
4895
4896 if (sky_confidence == NULL) {
4897 sky_confidence = confcopy;
4898 } else {
4899 cpl_image_add(sky_confidence, confcopy);
4900 cpl_image_delete(confcopy);
4901 }
4902 }
4903 cpl_msg_debug(cpl_func, "after skylist %s",
4904 cpl_error_get_message());
4905
4906 /* Combine the images to give the result */
4907
4908 hdrl_imagelist_collapse(skylist, HDRL_COLLAPSE_MEDIAN, &sky_himage,
4909 &contrib);
4910 cpl_image_delete(contrib);
4911 contrib = NULL;
4912 cpl_msg_debug(cpl_func, "after collapse %s",
4913 cpl_error_get_message());
4914
4915 /* Re-normalise the confidence array */
4916
4917 enu_normalise_confidence(sky_confidence);
4918
4919 if (debug) {
4920 cpl_msg_info(" ",
4921 ".. enu_sky_backgrounds: probe pixel %d,%d",
4922 (int)x_probe, (int)y_probe);
4923 cpl_msg_info(" ", ".. jitter %d" , (int)j);
4924 cpl_msg_info(" ", "... j# q c d (e)");
4925
4926 for (cpl_size k = 0; k < skysize; k++) {
4927 cpl_msg_info(" ", "... %3d %3d %3d %8.2f(%4.2f)",
4928 (int)cpl_vector_get(sky_indeces, k),
4929 (int)cpl_vector_get(reject, k),
4930 (int)cpl_vector_get(confidence, k),
4931 cpl_vector_get(data, k),
4932 cpl_vector_get(error, k));
4933 }
4934 int rejected = 0;
4935 int ignore = 0;
4936 hdrl_value hval = hdrl_image_get_pixel(sky_himage,
4937 x_probe, y_probe, &rejected);
4938 double cval = cpl_image_get(sky_confidence, x_probe,
4939 y_probe, &ignore);
4940 cpl_msg_info(" ", "... -> %3d %3d %8.2f(%4.2f)",
4941 rejected, (int)cval, hval.data, hval.error);
4942
4943 cpl_vector_delete(data);
4944 cpl_vector_delete(error);
4945 cpl_vector_delete(reject);
4946 cpl_vector_delete(confidence);
4947 }
4948
4949 hdrl_imagelist_delete(skylist); skylist=NULL;
4950 enu_check_error_code("failure in collapse-median");
4951
4952 } else if (strstr(method, "median-median") != NULL) {
4953
4954 /* construct a CPL array of the median of the jitters
4955 selected */
4956
4957 cpl_array * sky_medians = cpl_array_new(0, CPL_TYPE_DOUBLE);
4958
4959 for (int k = 0; k < (int)skysize; k++) {
4960 int i = (int)cpl_vector_get(sky_indeces, k);
4961
4962 /* get a copy of the image with the object mask applied */
4963
4964 hdrl_image * imcopy = hdrl_image_duplicate(
4965 sky_list->limages[i]->himage);
4966 if (sky_list->limages[i]->object_mask != NULL) {
4967 cpl_mask_or(cpl_image_get_bpm(hdrl_image_get_image(imcopy)),
4968 sky_list->limages[i]->object_mask);
4969 }
4970 hdrl_value bkg = hdrl_image_get_median(imcopy);
4971 hdrl_image_delete(imcopy);
4972
4973 cpl_size asize = cpl_array_get_size(sky_medians);
4974 cpl_array_set_size(sky_medians, asize+1);
4975 cpl_array_set_double(sky_medians, asize, bkg.data);
4976
4977 if (debug) {
4978 cpl_vector_set(data, k, bkg.data);
4979 cpl_vector_set(error, k, bkg.error);
4980 cpl_vector_set(confidence, k, 100.0);
4981 cpl_vector_set(reject, k, 0.0);
4982 }
4983 }
4984
4985 /* The result is an image filled with the median of sky_medians
4986 ..the error plane is the stdev of sky_medians */
4987
4988 double sky_med_med = cpl_array_get_median(sky_medians);
4989 double sky_med_stdev = cpl_array_get_stdev(sky_medians);
4990 cpl_size nx = hdrl_image_get_size_x(sky_list->limages[0]->himage);
4991 cpl_size ny = hdrl_image_get_size_y(sky_list->limages[0]->himage);
4992 cpl_image * sky_data = cpl_image_new(nx, ny, HDRL_TYPE_DATA);
4993 cpl_image_fill_window(sky_data, 1, 1, nx, ny, sky_med_med);
4994 cpl_image * sky_error = cpl_image_new(nx, ny, HDRL_TYPE_ERROR);
4995 cpl_image_fill_window(sky_error, 1, 1, nx, ny, sky_med_stdev);
4996 sky_himage = hdrl_image_create(sky_data, sky_error);
4997 cpl_image_delete(sky_data);
4998 cpl_image_delete(sky_error);
4999
5000 sky_confidence = cpl_image_new(nx, ny, CPL_TYPE_DOUBLE);
5001 cpl_image_fill_window(sky_confidence, 1, 1, nx, ny, 100.0);
5002
5003 cpl_array_delete(sky_medians);
5004
5005 if (debug) {
5006 cpl_msg_info(" ",
5007 ".. enu_sky_backgrounds: median of images");
5008 cpl_msg_info(" ", ".. jitter %d" , (int)j);
5009 cpl_msg_info(" ", "... j# c d (e)");
5010
5011 for (cpl_size k = 0; k < skysize; k++) {
5012 cpl_msg_info(" ", "... %3d %3d %8.2f(%4.2f)",
5013 (int)cpl_vector_get(sky_indeces, k),
5014 (int)cpl_vector_get(confidence, k),
5015 cpl_vector_get(data, k),
5016 cpl_vector_get(error, k));
5017 }
5018 int rejected = 0;
5019 int ignore = 0;
5020 hdrl_value hval = hdrl_image_get_pixel(sky_himage,
5021 1, 1, &rejected);
5022 double cval = cpl_image_get(sky_confidence, 1, 1, &ignore);
5023 cpl_msg_info(" ", "... -> %3d %3d %8.2f(%4.2f)",
5024 rejected, (int)cval, hval.data, hval.error);
5025
5026 cpl_vector_delete(data);
5027 cpl_vector_delete(error);
5028 cpl_vector_delete(confidence);
5029 }
5030 enu_check_error_code("failure in median-median");
5031 }
5032
5033 /* append to lists */
5034
5035 hdrl_imagelist_set(*sky_himagelist, sky_himage,
5036 hdrl_imagelist_get_size(*sky_himagelist));
5037 cpl_imagelist_set(*sky_confidence_list, sky_confidence,
5038 cpl_imagelist_get_size(*sky_confidence_list));
5039 cpl_vector_delete(sky_indeces); sky_indeces = NULL;
5040 }
5041
5042 cleanup:
5043 hdrl_imagelist_delete(skylist);
5044 cpl_vector_delete(sky_indeces);
5045 if (cpl_error_get_code() != CPL_ERROR_NONE) {
5046 hdrl_imagelist_delete(*sky_himagelist);
5047 *sky_himagelist = NULL;
5048 cpl_imagelist_delete(*sky_confidence_list);
5049 *sky_confidence_list = NULL;
5050 }
5051 eris_check_error_code("enu_sky_backgrounds");
5052 return cpl_error_get_code();
5053}
5054
5055
5056/*----------------------------------------------------------------------------*/
5068/*----------------------------------------------------------------------------*/
5069
5070cpl_error_code enu_stack(located_imagelist * limages,
5071 const double stk_lthr, const double stk_hthr,
5072 const char * stk_method, const int stk_fast,
5073 located_image ** result) {
5074
5075 cpl_ensure_code(cpl_error_get_code() == CPL_ERROR_NONE,
5076 cpl_error_get_code());
5077
5078 casu_fits ** indata = NULL;
5079 casu_fits ** inconf = NULL;
5080 casu_fits ** invar = NULL;
5081 casu_fits * out = NULL;
5082 casu_fits * outc = NULL;
5083 casu_fits * outv = NULL;
5084
5085 /* parameter validation */
5086
5087 cpl_ensure_code(limages, CPL_ERROR_NULL_INPUT);
5088 cpl_ensure_code((stk_fast == 0) || (stk_fast == 1),
5089 CPL_ERROR_ILLEGAL_INPUT);
5090
5091 /* parameter translation */
5092
5093 const int casu_stk_method = (!strcmp(stk_method, "nearest") ? 0 : 1);
5094
5095 /* translate located_imagelist to casu_fits components */
5096
5097 encu_limlist_to_casu_fits(limages, &indata, &inconf, &invar);
5098
5099 /* do the stacking */
5100
5101 int njitters = (int) limages->size;
5102 int casu_status = CASU_OK;
5103 casu_imstack(indata, inconf, invar, NULL, (int)njitters, (int)njitters,
5104 stk_lthr, stk_hthr, casu_stk_method, 0, stk_fast, 0,
5105 "ESO DET DIT", &out, &outc, &outv, &casu_status);
5106 *result = enu_located_image_new(hdrl_image_create(out->image, outv->image),
5107 NULL,
5108 cpl_image_duplicate(outc->image),
5109 NULL, NULL,
5110 out->ehu,
5111 NULL, NULL, NULL, NULL, NULL);
5112 freespace(out);
5113 freespace(outc);
5114 freespace(outv);
5115
5116 return cpl_error_get_code();
5117}
5118
5119
5120/*----------------------------------------------------------------------------*/
5133/*----------------------------------------------------------------------------*/
5134
5135cpl_error_code enu_sky_subtract_limlist(const char * method,
5136 const char * select_method,
5137 const double timerange,
5138 const located_imagelist * sky_data,
5139 const cpl_size x_probe,
5140 const cpl_size y_probe,
5141 located_imagelist * target_data) {
5142
5143 cpl_ensure_code(cpl_error_get_code() == CPL_ERROR_NONE,
5144 cpl_error_get_code());
5145 cpl_ensure_code(method, CPL_ERROR_NULL_INPUT);
5146 cpl_ensure_code(select_method, CPL_ERROR_NULL_INPUT);
5147 cpl_ensure_code(target_data, CPL_ERROR_NULL_INPUT);
5148
5149 cpl_imagelist * sky_conf_list = NULL;
5150 hdrl_imagelist * sky_himlist = NULL;
5151
5152 cpl_msg_info(cpl_func,
5153 "enu_sky_subtract called: method=%s, sky_selector=%s, "
5154 "bracket=%6.2f",
5155 method, select_method, timerange);
5156 cpl_size njitters = target_data->size;
5157 cpl_msg_info(cpl_func, "number of jitters to be reduced %d",
5158 (int) njitters);
5159
5160 /* Derive sky backgrounds */
5161
5162 enu_sky_backgrounds(method, select_method, timerange, target_data,
5163 sky_data, x_probe, y_probe, &sky_himlist,
5164 &sky_conf_list);
5165 enu_check_error_code("failure in enu_sky_backgrounds");
5166
5167 /* Subtract the sky backgrounds */
5168
5169 hdrl_value before = {0.0, 0.0};
5170 double bconf = 0.0;
5171 hdrl_value bkg = {0.0, 0.0};
5172 double bkgconf = 0.0;
5173 hdrl_value after = {0.0, 0.0};
5174 double aconf = 0.0;
5175 int brejected = 1;
5176 int bkgrejected = 1;
5177 int arejected = 1;
5178 int ignore = 1;
5179 int header_printed = CPL_FALSE;
5180
5181 for (cpl_size i = 0; i < njitters; i++) {
5182
5183 /* probe pixel debug stuff */
5184
5185 const cpl_size x_size = hdrl_image_get_size_x(
5186 target_data->limages[i]->himage);
5187 const cpl_size y_size = hdrl_image_get_size_y(
5188 target_data->limages[i]->himage);
5189 if (x_probe > 0 && x_probe <= x_size &&
5190 y_probe > 0 && y_probe <= y_size) {
5191 before = hdrl_image_get_pixel(target_data->limages[i]->himage,
5192 x_probe, y_probe, &brejected);
5193 bconf = cpl_image_get(target_data->limages[i]->confidence,
5194 x_probe, y_probe, &ignore);
5195 }
5196
5197 /* this bit does the actual subtraction. */
5198
5199 hdrl_image_sub_image(target_data->limages[i]->himage,
5200 hdrl_imagelist_get_const(sky_himlist, i));
5201 target_data->limages[i]->bkg = hdrl_image_duplicate(
5202 hdrl_imagelist_get(sky_himlist, i));
5203 target_data->limages[i]->bkg_confidence = cpl_image_duplicate(
5204 cpl_imagelist_get(sky_conf_list, i));
5205
5206 /* Confidence array remains that of the target, on the assumption
5207 that the S/N of the 'sky' is much higher */
5208
5209 /* Or could do it this way... */
5210 /* Confidence arrays are combined as if inverse variances */
5211 /* COMMENTED OUT
5212 cpl_image * temp = cpl_image_add_create(
5213 target_data->limages[i]->confidence,
5214 target_data->limages[i]->bkg_confidence);
5215 cpl_image_multiply(target_data->limages[i]->confidence,
5216 target_data->limages[i]->bkg_confidence);
5217 cpl_image_divide(target_data->limages[i]->confidence, temp);
5218 cpl_image_delete(temp);
5219 */
5220
5221 /* normalise the new confidence */
5222
5223 cpl_image_fill_rejected(target_data->limages[i]->confidence, 0.0);
5224 cpl_image_accept_all(target_data->limages[i]->confidence);
5225 enu_normalise_confidence(target_data->limages[i]->confidence);
5226
5227 /* more probe pixel debug stuff */
5228
5229 if (x_probe > 0 && x_probe <= x_size &&
5230 y_probe > 0 && y_probe <= y_size) {
5231 after = hdrl_image_get_pixel(target_data->limages[i]->himage,
5232 x_probe, y_probe, &arejected);
5233 aconf = cpl_image_get(target_data->limages[i]->confidence,
5234 x_probe, y_probe, &ignore);
5235 bkg = hdrl_image_get_pixel(target_data->limages[i]->bkg,
5236 x_probe, y_probe, &bkgrejected);
5237 bkgconf = cpl_image_get(target_data->limages[i]->bkg_confidence,
5238 x_probe, y_probe, &ignore);
5239
5240 if (!header_printed) {
5241 header_printed = CPL_TRUE;
5242 cpl_msg_info(" ", "..Subtracting sky backgrounds: probe pixel %d,%d",
5243 (int)x_probe, (int)y_probe);
5244 cpl_msg_info(" ", " j# before sky after");
5245 cpl_msg_info(" ", " q c d e q c d e q c d e");
5246 }
5247 cpl_msg_info(" ",
5248 "..%3d %d %3.0f %4.2e(%4.2e)) %d %3.0f %4.2e(%4.2e) %d %3.0f %10.2e(%4.2e)",
5249 (int)i,
5250 brejected, bconf, before.data, before.error,
5251 bkgrejected, bkgconf, bkg.data, bkg.error,
5252 arejected, aconf, after.data, after.error);
5253 }
5254 }
5255
5256 cleanup:
5257 cpl_imagelist_delete(sky_conf_list);
5258 hdrl_imagelist_delete(sky_himlist);
5259
5260 return cpl_error_get_code();
5261}
5262
5263
5264/*----------------------------------------------------------------------------*/
5273/*----------------------------------------------------------------------------*/
5274
5275cpl_error_code
5276eris_nix_get_badpix_qc_from_ima(const master_bpm* mbad_pix_map,
5277 cpl_propertylist* qc_list,
5278 const char* prefix)
5279{
5280 cpl_ensure_code(mbad_pix_map != NULL, CPL_ERROR_NULL_INPUT);
5281 cpl_ensure_code(qc_list != NULL, CPL_ERROR_NULL_INPUT);
5282 cpl_ensure_code(prefix != NULL, CPL_ERROR_NULL_INPUT);
5283
5284 int flag_mask = 0;
5285 cpl_mask * bpm_mask = NULL;
5286
5287 flag_mask = ~flag_mask;
5288 bpm_mask = en_master_bpm_get_mask(mbad_pix_map, flag_mask);
5289 int nbad = cpl_mask_count(bpm_mask);
5290 cpl_propertylist_append_int(qc_list, "ESO QC NUMBER BAD PIXELS", nbad);
5291 cpl_size sx = cpl_mask_get_size_x(bpm_mask);
5292 cpl_size sy = cpl_mask_get_size_y(bpm_mask);
5293 double fraction = (double) nbad / (sx * sy);
5294 cpl_propertylist_append_double(qc_list, "ESO QC FRACTION BAD PIXELS",fraction);
5295 return cpl_error_get_code();
5296}
5297
5298
5299/*----------------------------------------------------------------------------*/
5311/*----------------------------------------------------------------------------*/
5312
5313cpl_propertylist*
5314enu_raw_flats_qc(located_imagelist* lamp_on_limlist,
5315 cpl_mask* bp_map_nl_mask,
5316 const cpl_parameterlist* parlist,
5317 const char* context,
5318 const double threshold_pos,
5319 const cpl_boolean verbose,
5320 const cpl_boolean rescale_by_dit){
5321
5322 cpl_ensure(lamp_on_limlist != NULL, CPL_ERROR_NULL_INPUT, NULL);
5323 cpl_ensure(bp_map_nl_mask != NULL, CPL_ERROR_NULL_INPUT, NULL);
5324 cpl_ensure(parlist != NULL, CPL_ERROR_NULL_INPUT, NULL);
5325 cpl_ensure(context != NULL, CPL_ERROR_NULL_INPUT, NULL);
5326
5327
5328 cpl_propertylist* qc;
5329 //located_image* loc_img;
5330 cpl_mask* mask;
5331 double mean = 0;
5332 double median = 0;
5333 double rms = 0;
5334 char* key_name;
5335 char* key_comm;
5336
5337 qc = cpl_propertylist_new();
5338 double threshold_neg = - 4.3e7;
5339 threshold_neg = 300.;
5340 long nthresh_pos = 0;
5341 long nthresh_neg = 0;
5342
5343 const cpl_parameter* param;
5344 char* pname;
5345
5346 /* negative saturation maybe not to be checked as no pixels are sat */
5347 pname = cpl_sprintf("%s%s",context,".saturation_neg");
5348 cpl_msg_warning(cpl_func,"pname: %s",pname);
5349 param = cpl_parameterlist_find_const(parlist,pname);
5350 threshold_neg = cpl_parameter_get_double(param);
5351 cpl_free(pname);
5352 //cpl_msg_info(cpl_func,"threshold_neg: %g",threshold_neg);
5353 //cpl_msg_info(cpl_func,"threshold_pos: %g",threshold_pos);
5354 //char* fname;
5355 cpl_image* ima;
5356 double mean_min = DBL_MAX;
5357 double median_min = DBL_MAX;
5358
5359 double mean_max = -DBL_MIN;
5360 double median_max = -DBL_MIN;
5361 double nthresh_pos_max = 0;
5362 double nthresh_neg_max = 0;
5363 /*
5364 cpl_msg_info(cpl_func,"mean_min: %g",mean_min);
5365 cpl_msg_info(cpl_func,"mean_max: %g",mean_max);
5366 cpl_msg_info(cpl_func,"median_min: %g",median_min);
5367 cpl_msg_info(cpl_func,"median_max: %g",median_max);
5368 */
5369 double dit = 1;
5370 cpl_propertylist* plist = NULL;
5371 for(cpl_size i = 0; i < lamp_on_limlist->size; i++) {
5372 //fname = cpl_sprintf("raw_ima_%lld.fits",i);
5373 mask = hdrl_image_get_mask(lamp_on_limlist->limages[i]->himage);
5374 /*
5375 cpl_image_save(hdrl_image_get_image(lamp_on_limlist->limages[i]->himage),
5376 fname,CPL_TYPE_DOUBLE,NULL,CPL_IO_DEFAULT);
5377 */
5378
5379 cpl_mask_or(mask, bp_map_nl_mask);
5380
5381 hdrl_image_reject_from_mask(lamp_on_limlist->limages[i]->himage, mask);
5382 ima = hdrl_image_get_image(lamp_on_limlist->limages[i]->himage);
5383 plist = lamp_on_limlist->limages[i]->plist;
5384 if(cpl_propertylist_has(plist,"ESO DET SEQ1 DIT")) {
5385 dit = cpl_propertylist_get_double(plist,"ESO DET SEQ1 DIT");
5386 }
5387 nthresh_neg = eris_image_get_threshpix(ima, threshold_neg, CPL_FALSE);
5388 nthresh_pos = eris_image_get_threshpix(ima, threshold_pos, CPL_TRUE);
5389
5390 eris_image_flag_threshpix(&ima, threshold_neg, CPL_FALSE);
5391 mean = cpl_image_get_mean(ima);
5392 median = cpl_image_get_median(ima);
5393 rms = cpl_image_get_stdev(ima);
5394 //cpl_mask_delete(mask);
5395
5396 //nsat = nthresh_neg + nthresh_pos;
5397 //nsat = nthresh_neg;
5398 if(rescale_by_dit) {
5399 mean *= dit;
5400 median *= dit;
5401 rms *= dit;
5402 }
5403 if(verbose) {
5404 key_name = cpl_sprintf("ESO QC FLAT_ON%lld NPOSSAT",i);
5405 key_comm = cpl_sprintf("Number of flat pixels above threshold");
5406 cpl_propertylist_append_int(qc, key_name, nthresh_pos);
5407 cpl_propertylist_set_comment(qc, key_name, key_comm);
5408 cpl_free(key_name);
5409 cpl_free(key_comm);
5410
5411 key_name = cpl_sprintf("ESO QC FLAT_ON%lld NNEGSAT",i);
5412 key_comm = cpl_sprintf("Number of flat pixels below neg threshold");
5413 cpl_propertylist_append_int(qc, key_name, nthresh_neg);
5414 cpl_propertylist_set_comment(qc, key_name, key_comm);
5415 cpl_free(key_name);
5416 cpl_free(key_comm);
5417
5418 key_name = cpl_sprintf("ESO QC FLAT_ON%lld MEAN",i);
5419 key_comm = cpl_sprintf("[ADU] Mean of flat");
5420 cpl_propertylist_append_double(qc, key_name, mean);
5421 cpl_propertylist_set_comment(qc,key_name,key_comm);
5422 cpl_free(key_name);
5423 cpl_free(key_comm);
5424
5425 key_name = cpl_sprintf("ESO QC FLAT_ON%lld MEDIAN",i);
5426 key_comm = cpl_sprintf("[ADU] Median of flat");
5427 cpl_propertylist_append_double(qc, key_name, median);
5428 cpl_propertylist_set_comment(qc,key_name,key_comm);
5429 cpl_free(key_name);
5430 cpl_free(key_comm);
5431
5432 key_name = cpl_sprintf("ESO QC FLAT_ON%lld STDEV",i);
5433 key_comm = cpl_sprintf("[ADU] Stdev of flat");
5434 cpl_propertylist_append_double(qc, key_name, rms);
5435 cpl_propertylist_set_comment(qc,key_name,key_comm);
5436 cpl_free(key_name);
5437 cpl_free(key_comm);
5438 }
5439
5440 if(mean > mean_max) {
5441 mean_max = mean;
5442 }
5443 if(median > median_max) {
5444 median_max = median;
5445 }
5446
5447
5448 if(mean < mean_min) {
5449 mean_min = mean;
5450 }
5451 if(median < median_min) {
5452 median_min = median;
5453 }
5454
5455
5456 if(nthresh_pos > nthresh_pos_max) {
5457 nthresh_pos_max = nthresh_pos;
5458 }
5459 if(nthresh_neg > nthresh_neg_max) {
5460 nthresh_neg_max = nthresh_neg;
5461 }
5462 }
5463 cpl_msg_info(cpl_func,"mean_min: %g",mean_min);
5464 cpl_msg_info(cpl_func,"mean_max: %g",mean_max);
5465 cpl_msg_info(cpl_func,"median_min: %g",median_min);
5466 cpl_msg_info(cpl_func,"median_max: %g",median_max);
5467 cpl_msg_info(cpl_func,"f1: %g",mean_min / mean_max);
5468 cpl_msg_info(cpl_func,"f2: %g",median_min / median_max);
5469
5470 key_name = cpl_sprintf("ESO QC FLAT_ON MEAN MIN");
5471 key_comm = cpl_sprintf("[ADU] Min of Means of flat");
5472 cpl_propertylist_append_double(qc, key_name, mean_min);
5473 cpl_propertylist_set_comment(qc,key_name,key_comm);
5474 cpl_free(key_name);
5475 cpl_free(key_comm);
5476
5477 key_name = cpl_sprintf("ESO QC FLAT_ON MEDIAN MIN");
5478 key_comm = cpl_sprintf("[ADU] Min of Medians of flat");
5479 cpl_propertylist_append_double(qc, key_name, median_min);
5480 cpl_propertylist_set_comment(qc,key_name,key_comm);
5481 cpl_free(key_name);
5482 cpl_free(key_comm);
5483
5484 key_name = cpl_sprintf("ESO QC FLAT_ON MEAN MAX");
5485 key_comm = cpl_sprintf("[ADU] Max of Means of flat");
5486 cpl_propertylist_append_double(qc, key_name, mean_max);
5487 cpl_propertylist_set_comment(qc,key_name,key_comm);
5488 cpl_free(key_name);
5489 cpl_free(key_comm);
5490
5491 key_name = cpl_sprintf("ESO QC FLAT_ON MEDIAN MAX");
5492 key_comm = cpl_sprintf("[ADU] Max of Medians of flat");
5493 cpl_propertylist_append_double(qc, key_name, median_max);
5494 cpl_propertylist_set_comment(qc,key_name,key_comm);
5495 cpl_free(key_name);
5496 cpl_free(key_comm);
5497
5498
5499 key_name = cpl_sprintf("ESO QC FLAT_ON MEAN FRAC");
5500 key_comm = cpl_sprintf("Min/Max of Means of flat");
5501 cpl_propertylist_append_double(qc, key_name, mean_min / mean_max);
5502 cpl_propertylist_set_comment(qc,key_name,key_comm);
5503 cpl_free(key_name);
5504 cpl_free(key_comm);
5505
5506
5507 key_name = cpl_sprintf("ESO QC FLAT_ON MEDIAN FRAC");
5508 key_comm = cpl_sprintf("Min/Max of Medians of flat");
5509 cpl_propertylist_append_double(qc, key_name, median_min / median_max);
5510 cpl_propertylist_set_comment(qc,key_name,key_comm);
5511 cpl_free(key_name);
5512 cpl_free(key_comm);
5513
5514
5515
5516 key_name = cpl_sprintf("ESO QC FLAT_ON NPOSSAT MAX");
5517 key_comm = cpl_sprintf("Max of Number of flat pixels above threshold");
5518 cpl_propertylist_append_int(qc, key_name, nthresh_pos_max);
5519 cpl_propertylist_set_comment(qc, key_name, key_comm);
5520 cpl_free(key_name);
5521 cpl_free(key_comm);
5522
5523 key_name = cpl_sprintf("ESO QC FLAT_ON NNEGSAT MAX");
5524 key_comm = cpl_sprintf("MAX Number of flat pixels below neg threshold");
5525 cpl_propertylist_append_int(qc, key_name, nthresh_neg_max);
5526 cpl_propertylist_set_comment(qc, key_name, key_comm);
5527 cpl_free(key_name);
5528 cpl_free(key_comm);
5529
5530
5531
5532 eris_check_error_code("enu_raw_flats_qc");
5533 return qc;
5534}
encu_limlist_to_casu_fits
cpl_error_code encu_limlist_to_casu_fits(located_imagelist *limlist, casu_fits ***indata, casu_fits ***inconf, casu_fits ***invar)
Translate a located_imagelist to arrays of casu_fits structs.
Definition: eris_nix_casu_utils.c:61
enu_dfs_save_limage
cpl_error_code enu_dfs_save_limage(cpl_frameset *allframes, const cpl_parameterlist *parlist, const cpl_frameset *provenance, const cpl_boolean prov_raw, const located_image *limage, const char *recipe, const cpl_frame *inherit, cpl_propertylist *applist, const char *pipe_id, const char *filename)
Save a located image structure to a MEF.
Definition: eris_nix_dfs.c:909
enu_dfs_save_himage
cpl_error_code enu_dfs_save_himage(cpl_frameset *allframes, const cpl_parameterlist *parlist, const cpl_frameset *provenance, const cpl_boolean prov_raw, const hdrl_image *image, const hdrl_imagelist *imagelist, const mef_extension_list *mefs, const char *recipe, const cpl_frame *inherit_frame, const cpl_propertylist *applist, const cpl_propertylist *wcs_plist, const char *pipe_id, const char *filename)
Save an hdrl_image/imagelist as a DFS-compliant MEF pipeline product.
Definition: eris_nix_dfs.c:423
enm_correct_crpix
cpl_error_code enm_correct_crpix(const char *wcs_method, const char *catalogue, cpl_table *matched_stds, located_image *limage, cpl_matrix **xy_shift)
Apply median offsets from matched standards table to image.
Definition: eris_nix_match.c:278
enm_try_all_associations
cpl_error_code enm_try_all_associations(cpl_table *objtab, cpl_table *stdtab, const double match_rad, cpl_table **matchtab)
Match standards with objects by trying all possibilities and selecting best.
Definition: eris_nix_match.c:400
enu_located_image_duplicate
located_image * enu_located_image_duplicate(const located_image *limage)
Make a deep copy of a located_image and its contents.
Definition: eris_nix_utils.c:3056
enu_mef_extension_list_get_mask
cpl_mask * enu_mef_extension_list_get_mask(mef_extension_list *meflist, const char *target)
Get a cpl_mask from a named mef_extension in a list.
Definition: eris_nix_utils.c:3740
enu_bracket_skys
cpl_vector * enu_bracket_skys(const located_image *target, const double timerange, const located_imagelist *pool, const int debug)
Find images taken within a given time of a target image.
Definition: eris_nix_utils.c:1091
enu_modify_CD_matrix
cpl_error_code enu_modify_CD_matrix(located_image *limage, const cpl_table *refine_wcs)
Update the CD matrix to reduce image distortion and rotation.
Definition: eris_nix_utils.c:4337
enu_located_imagelist_delete
void enu_located_imagelist_delete(located_imagelist *limlist)
Delete a located_imagelist and its contents.
Definition: eris_nix_utils.c:3582
enu_located_imagelist_insert
cpl_error_code enu_located_imagelist_insert(located_imagelist *limlist, located_image *limage, cpl_size position)
Insert a located_image at a specified point in a located_imagelist.
Definition: eris_nix_utils.c:3633
enu_mef_extension_delete
void enu_mef_extension_delete(mef_extension *mef)
Delete a mef_extension and its contents.
Definition: eris_nix_utils.c:3684
eris_nix_get_badpix_qc_from_ima
cpl_error_code eris_nix_get_badpix_qc_from_ima(const master_bpm *mbad_pix_map, cpl_propertylist *qc_list, const char *prefix)
Compute QC on input master bpm.
Definition: eris_nix_utils.c:5276
enu_mef_new_mask
mef_extension * enu_mef_new_mask(const char *name, const cpl_mask *data, const cpl_propertylist *plist)
Create a mef_extension struct holding a cpl_mask.
Definition: eris_nix_utils.c:3850
enu_raw_flats_qc
cpl_propertylist * enu_raw_flats_qc(located_imagelist *lamp_on_limlist, cpl_mask *bp_map_nl_mask, const cpl_parameterlist *parlist, const char *context, const double threshold_pos, const cpl_boolean verbose, const cpl_boolean rescale_by_dit)
Compute QC on input raw flats.
Definition: eris_nix_utils.c:5314
enu_flat_save
cpl_error_code enu_flat_save(const char *pro_catg, const hdrl_image *flat, const cpl_image *confidence, const cpl_mask *cold_bpm, cpl_frameset *frameset, const cpl_parameterlist *parlist, const char *filename, const char *recipe_name, const cpl_propertylist *qclog)
Save a flatfield result.
Definition: eris_nix_utils.c:1525
enu_check_conformance
int enu_check_conformance(const cpl_propertylist *plist1, const cpl_propertylist *plist2, const char *regexp)
Check that the specified subset of two propertylists match.
Definition: eris_nix_utils.c:1234
enu_load_limage_from_frame
located_image * enu_load_limage_from_frame(const cpl_frame *frame, cpl_image **pcopyconf, const cpl_boolean collapse_cube)
Load components of a located_image from a frame.
Definition: eris_nix_utils.c:2442
enu_hdrl_catalogue_result_duplicate
hdrl_catalogue_result * enu_hdrl_catalogue_result_duplicate(const hdrl_catalogue_result *target)
Return a deep copy of the given hdrl_catalogue_result object.
Definition: eris_nix_utils.c:2217
enu_located_imagelist_duplicate
located_imagelist * enu_located_imagelist_duplicate(const located_imagelist *limlist)
Make a deep copy of a located_imagelist and its contents.
Definition: eris_nix_utils.c:3604
enu_calc_maglim
cpl_error_code enu_calc_maglim(const located_image *limage, const double photzp, const double fwhm_pix, double *abmaglim)
Calculate magnitude limit of image.
Definition: eris_nix_utils.c:838
enu_opm_lss_limlist
cpl_error_code enu_opm_lss_limlist(located_imagelist *limlist, const int nsigma_cut)
Calculate object masks for LSS images in a located_imagelist.
Definition: eris_nix_utils.c:4132
enu_get_tel_alt
double enu_get_tel_alt(const cpl_propertylist *plist)
Get telescope altitude of an observation.
Definition: eris_nix_utils.c:1799
enu_mef_new_image
mef_extension * enu_mef_new_image(const char *name, const cpl_image *data, const cpl_propertylist *plist)
Create a mef_extension to hold a cpl_image.
Definition: eris_nix_utils.c:3811
enu_get_ra_dec
cpl_error_code enu_get_ra_dec(const cpl_wcs *wcs, double *ra, double *dec)
Get RA and Dec at centre of image with given wcs.
Definition: eris_nix_utils.c:2037
enu_calc_flat
hdrl_image * enu_calc_flat(hdrl_imagelist *himlist, const int min_coadds, const hdrl_parameter *collapse_params, const cpl_size filter_size_x, const cpl_size filter_size_y, const hdrl_flat_method method)
Calculate a flatfield result.
Definition: eris_nix_utils.c:773
enu_get_window_info
cpl_error_code enu_get_window_info(cpl_size *nx, cpl_size *ny, int *rot, cpl_size *strx, cpl_size *stry, cpl_size *nx_chip, cpl_size *ny_chip, cpl_boolean *windowed, const cpl_propertylist *plist)
Get the detector 'window' information.
Definition: eris_nix_utils.c:2092
enu_basic_calibrate
cpl_error_code enu_basic_calibrate(located_image *limage, const int read_offsets, const cpl_table *refine_wcs, const master_dark *mdark, const gain_linearity *gain_lin, const master_flat *flatfield_1, const master_flat *flatfield_2, const master_bpm *mbad_pix_map, const int flag_mask, const char *fill_rejected, const double fill_value, const cpl_size x_probe, const cpl_size y_probe)
Do basic calibration of located_image (single or cube)
Definition: eris_nix_utils.c:99
enu_catalogue_limlist
cpl_error_code enu_catalogue_limlist(located_imagelist *limlist, hdrl_parameter *params)
Calculate object catalogues for a list of images.
Definition: eris_nix_utils.c:1167
enu_sky_subtract_limlist
cpl_error_code enu_sky_subtract_limlist(const char *method, const char *select_method, const double timerange, const located_imagelist *sky_data, const cpl_size x_probe, const cpl_size y_probe, located_imagelist *target_data)
Estimate and subtract sky backgrounds for a list of target images.
Definition: eris_nix_utils.c:5135
enu_himage_load_from_fits
cpl_error_code enu_himage_load_from_fits(const char *filename, hdrl_image **result, mef_extension_list **mef_extensions, cpl_propertylist **plist)
Load an hdrl_image from a multi-extension FITS file.
Definition: eris_nix_utils.c:2245
enu_debug_limlist_save
cpl_error_code enu_debug_limlist_save(const int debug, const located_imagelist *limlist, const char *nameroot, const char *recipename, cpl_frameset *frameset, const cpl_parameterlist *parlist, const cpl_frameset *used)
Save a list of intermediate image results for use in debugging.
Definition: eris_nix_utils.c:1435
enu_mef_new_table
mef_extension * enu_mef_new_table(const char *name, const cpl_table *table, const cpl_propertylist *plist)
Create a mef_extension struct holding a cpl_table.
Definition: eris_nix_utils.c:3889
enu_mef_extension_list_new
mef_extension_list * enu_mef_extension_list_new(cpl_size size)
Construct a new mef_extension_list.
Definition: eris_nix_utils.c:3780
enu_located_image_new
located_image * enu_located_image_new(hdrl_image *himage, hdrl_imagelist *himagelist, cpl_image *confidence, hdrl_image *bkg, cpl_image *bkg_confidence, cpl_propertylist *plist, hdrl_catalogue_result *objects, cpl_mask *object_mask, hdrl_catalogue_result *wcs, hdrl_catalogue_result *photom, cpl_frame *frame)
Create a located_image structure and initialise the contents.
Definition: eris_nix_utils.c:3148
enu_get_airmass
double enu_get_airmass(const cpl_propertylist *plist)
Get the mean airmass of an observation.
Definition: eris_nix_utils.c:1636
enu_calc_pixel_coords
cpl_error_code enu_calc_pixel_coords(cpl_table *catalogue, const cpl_propertylist *wcs_plist)
Calculate predicted positions of catalogue objects for given wcs.
Definition: eris_nix_utils.c:918
enu_limlist_load_from_frameset
located_imagelist * enu_limlist_load_from_frameset(cpl_frameset *frameset, const char *tag, cpl_frameset *used)
Load tagged data from a frameset into a located_imagelist.
Definition: eris_nix_utils.c:3195
enu_located_image_delete
void enu_located_image_delete(located_image *limage)
Delete a located_image and its contents.
Definition: eris_nix_utils.c:3027
enu_mef_new_vector
mef_extension * enu_mef_new_vector(const char *name, const cpl_vector *vector, const cpl_propertylist *plist)
Create a mef_extension struct holding a cpl_vector.
Definition: eris_nix_utils.c:3928
enu_remove_read_offsets
cpl_error_code enu_remove_read_offsets(hdrl_image *himage, const cpl_propertylist *plist, cpl_image *confidence, const int set_confidence)
Function to remove read offsets from an himage and set blank pixels
Definition: eris_nix_utils.c:4486
enu_normalise_confidence
cpl_error_code enu_normalise_confidence(cpl_image *confidence)
Normalise confidence array so that mean of good pixels is 100.
Definition: eris_nix_utils.c:4415
enu_stack
cpl_error_code enu_stack(located_imagelist *limages, const double stk_lthr, const double stk_hthr, const char *stk_method, const int stk_fast, located_image **result)
Stack a set of images.
Definition: eris_nix_utils.c:5070
enu_correct_wcs
cpl_error_code enu_correct_wcs(const cpl_table *refcat, const char *wcs_method, const char *catalogue, located_image *limage, const double match_rad, cpl_table **matched_stds, cpl_matrix **xy_shift)
Correct the wcs of an image.
Definition: eris_nix_utils.c:4209
enu_basic_calibrate_himage
cpl_error_code enu_basic_calibrate_himage(hdrl_image *himage, cpl_image *confidence, cpl_propertylist *plist, const cpl_frame *frame, const int read_offsets, const master_dark *mdark, const gain_linearity *gain_lin, const master_flat *flatfield_1, const master_flat *flatfield_2, const master_bpm *mbad_pix_map, const int set_confidence, const int flag_mask, const char *fill_rejected, const double fill_value, const cpl_size x_probe, const cpl_size y_probe)
Do basic calibration of an hdrl_image.
Definition: eris_nix_utils.c:257
enu_mef_extension_save
cpl_error_code enu_mef_extension_save(const mef_extension *mef, const char *filename, const cpl_propertylist *plist, unsigned mode)
Save a mef_extension struct to FITS file.
Definition: eris_nix_utils.c:3965
enu_repreface
char * enu_repreface(const char *filename, const char *preface)
Preface a raw filename with a string.
Definition: eris_nix_utils.c:4745
enu_get_license
const char * enu_get_license(void)
Get the pipeline copyright and license.
Definition: eris_nix_utils.c:2004
enu_mef_extension_list_delete
void enu_mef_extension_list_delete(mef_extension_list *list)
Delete a mef_extension_list and its contents.
Definition: eris_nix_utils.c:3716
enu_load_component
cpl_image * enu_load_component(mef_extension *mef, const char *dps_name, const char *hduclas1, const char *hduclas2)
Load data from a MEF component of specified type.
Definition: eris_nix_utils.c:3533
enu_get_filter
const char * enu_get_filter(const cpl_propertylist *plist)
Get the filter used in an observation.
Definition: eris_nix_utils.c:1896
enu_check_wcs
cpl_error_code enu_check_wcs(const located_image *limage)
Check that the image has valid WCS keywords.
Definition: eris_nix_utils.c:1377
enu_get_rcore_and_mesh_size
cpl_error_code enu_get_rcore_and_mesh_size(const char *context, const cpl_parameterlist *parlist, const cpl_propertylist *plist, double *obj_core_radius, int *bkg_mesh_size)
Get catalogue core-radius and mesh-size appropriate to AO mode.
Definition: eris_nix_utils.c:1691
enu_located_imagelist_new
located_imagelist * enu_located_imagelist_new(cpl_size size)
Return a pointer to a new located_imagelist.
Definition: eris_nix_utils.c:3660
enu_catalogue_compute
hdrl_catalogue_result * enu_catalogue_compute(const hdrl_image *himage, const cpl_image *confidence, const cpl_wcs *wcs, hdrl_parameter *params)
Wrapper for hdrl_catalogue_compute.
Definition: eris_nix_utils.c:1011
enu_opm_limlist
cpl_error_code enu_opm_limlist(const int obj_min_pixels, const double obj_threshold, const int bkg_mesh_size, const double bkg_smooth_fwhm, located_imagelist *limlist)
Calculate object masks for images in a located_imagelist.
Definition: eris_nix_utils.c:4063
enu_get_det_mode
const char * enu_get_det_mode(const cpl_propertylist *plist)
Get the detector mode of an integration.
Definition: eris_nix_utils.c:1860
enu_sky_backgrounds
cpl_error_code enu_sky_backgrounds(const char *method, const char *select_method, const double timerange, const located_imagelist *target_list, const located_imagelist *sky_list, const cpl_size x_probe, const cpl_size y_probe, hdrl_imagelist **sky_himagelist, cpl_imagelist **sky_confidence_list)
Get sky backgrounds for a list of target images.
Definition: eris_nix_utils.c:4783
enu_get_dit
double enu_get_dit(const cpl_propertylist *plist)
Get the DIT of an integration.
Definition: eris_nix_utils.c:1829
enu_get_filter_wavelength
double enu_get_filter_wavelength(const char *filter)
Get the effective wavelength of a filter.
Definition: eris_nix_utils.c:1947
enu_load_mef_components
mef_extension_list * enu_load_mef_components(const char *filename, cpl_propertylist **plist)
Load components of a multi-extension FITS file.
Definition: eris_nix_utils.c:2945
eris_check_error_code
cpl_error_code eris_check_error_code(const char *func_id)
handle CPL errors
Definition: eris_utils.c:56
hdrl_catalogue_compute
hdrl_catalogue_result * hdrl_catalogue_compute(const cpl_image *image_, const cpl_image *confidence_map, const cpl_wcs *wcs, hdrl_parameter *param_)
build object catalog
Definition: hdrl_catalogue.c:462
hdrl_catalogue_result_delete
void hdrl_catalogue_result_delete(hdrl_catalogue_result *result)
delete hdrl parameter result object
Definition: hdrl_catalogue.c:439
hdrl_collapse_mode_parameter_create
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
Definition: hdrl_collapse.c:567
hdrl_flat_parameter_create
hdrl_parameter * hdrl_flat_parameter_create(cpl_size filter_size_x, cpl_size filter_size_y, hdrl_flat_method method)
Creates FLAT Parameters object.
Definition: hdrl_flat.c:173
hdrl_flat_compute
cpl_error_code hdrl_flat_compute(hdrl_imagelist *hdrl_data, const cpl_mask *stat_mask, const hdrl_parameter *collapse_params, hdrl_parameter *flat_params, hdrl_image **master, cpl_image **contrib_map)
compute high or low frequency master flat with median filtering
Definition: hdrl_flat.c:405
hdrl_image_get_pixel
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
hdrl_image_sub_image
cpl_error_code hdrl_image_sub_image(hdrl_image *self, const hdrl_image *other)
Subtract two images, store the result in the first image.
Definition: hdrl_image_math.c:137
hdrl_image_reject_from_mask
cpl_error_code hdrl_image_reject_from_mask(hdrl_image *self, const cpl_mask *map)
set bpm of hdrl_image
Definition: hdrl_image.c:407
hdrl_image_get_median
hdrl_value hdrl_image_get_median(const hdrl_image *self)
computes the median and associated error of an image.
Definition: hdrl_image_math.c:501
hdrl_image_div_image
cpl_error_code hdrl_image_div_image(hdrl_image *self, const hdrl_image *other)
Divide two images, store the result in the first image.
Definition: hdrl_image_math.c:273
hdrl_image_duplicate
hdrl_image * hdrl_image_duplicate(const hdrl_image *himg)
copy hdrl_image
Definition: hdrl_image.c:391
hdrl_image_get_stdev
double hdrl_image_get_stdev(const hdrl_image *self)
computes the standard deviation of the data of an image
Definition: hdrl_image_math.c:540
hdrl_image_copy
cpl_error_code hdrl_image_copy(hdrl_image *dst, const hdrl_image *src, cpl_size xpos, cpl_size ypos)
Copy one image into another.
Definition: hdrl_image.c:686
hdrl_image_get_mask
cpl_mask * hdrl_image_get_mask(hdrl_image *himg)
get cpl bad pixel mask from image
Definition: hdrl_image.c:157
hdrl_image_extract
hdrl_image * hdrl_image_extract(const hdrl_image *self, cpl_size llx, cpl_size lly, cpl_size urx, cpl_size ury)
extract copy of window from image
Definition: hdrl_image.c:625
hdrl_image_get_error
cpl_image * hdrl_image_get_error(hdrl_image *himg)
get error as cpl image
Definition: hdrl_image.c:131
hdrl_image_get_mean
hdrl_value hdrl_image_get_mean(const hdrl_image *self)
computes mean pixel value and associated error of an image.
Definition: hdrl_image_math.c:402
hdrl_image_get_size_y
cpl_size hdrl_image_get_size_y(const hdrl_image *self)
return size of Y dimension of image
Definition: hdrl_image.c:540
hdrl_image_get_size_x
cpl_size hdrl_image_get_size_x(const hdrl_image *self)
return size of X dimension of image
Definition: hdrl_image.c:525
hdrl_image_create
hdrl_image * hdrl_image_create(const cpl_image *image, const cpl_image *error)
create a new hdrl_image from to existing images by copying them
Definition: hdrl_image.c:295
hdrl_image_get_image
cpl_image * hdrl_image_get_image(hdrl_image *himg)
get data as cpl image
Definition: hdrl_image.c:105
hdrl_image_reject
cpl_error_code hdrl_image_reject(hdrl_image *self, cpl_size xpos, cpl_size ypos)
mark pixel as bad
Definition: hdrl_image.c:427
hdrl_image_get_image_const
const cpl_image * hdrl_image_get_image_const(const hdrl_image *himg)
get data as cpl image
Definition: hdrl_image.c:118
hdrl_image_delete
void hdrl_image_delete(hdrl_image *himg)
delete hdrl_image
Definition: hdrl_image.c:379
hdrl_imagelist_collapse_mean
cpl_error_code hdrl_imagelist_collapse_mean(const hdrl_imagelist *himlist, hdrl_image **out, cpl_image **contrib)
Mean collapsing of image list.
Definition: hdrl_imagelist_basic.c:470
hdrl_imagelist_set
cpl_error_code hdrl_imagelist_set(hdrl_imagelist *himlist, hdrl_image *himg, cpl_size pos)
Insert an image into an imagelist.
Definition: hdrl_imagelist_io.c:274
hdrl_imagelist_get_size_y
cpl_size hdrl_imagelist_get_size_y(const hdrl_imagelist *himlist)
Get number of rows of images in the imagelist.
Definition: hdrl_imagelist_io.c:188
hdrl_imagelist_create
hdrl_imagelist * hdrl_imagelist_create(cpl_imagelist *imlist, cpl_imagelist *errlist)
Create an hdrl_imagelist out of 2 cpl_imagelist.
Definition: hdrl_imagelist_io.c:102
hdrl_imagelist_delete
void hdrl_imagelist_delete(hdrl_imagelist *himlist)
Free all memory used by a hdrl_imagelist object including the images.
Definition: hdrl_imagelist_io.c:385
hdrl_imagelist_get_const
const hdrl_image * hdrl_imagelist_get_const(const hdrl_imagelist *himlist, cpl_size inum)
Get an image from a list of images.
Definition: hdrl_imagelist_io.c:229
hdrl_imagelist_get_size
cpl_size hdrl_imagelist_get_size(const hdrl_imagelist *himlist)
Get the number of images in the imagelist.
Definition: hdrl_imagelist_io.c:148
hdrl_imagelist_collapse
cpl_error_code hdrl_imagelist_collapse(const hdrl_imagelist *himlist, const hdrl_parameter *param, hdrl_image **out, cpl_image **contrib)
collapsing of image list
Definition: hdrl_imagelist_basic.c:407
hdrl_imagelist_new
hdrl_imagelist * hdrl_imagelist_new(void)
Create an empty imagelist.
Definition: hdrl_imagelist_io.c:84
hdrl_imagelist_collapse_median
cpl_error_code hdrl_imagelist_collapse_median(const hdrl_imagelist *himlist, hdrl_image **out, cpl_image **contrib)
Median collapsing of image list.
Definition: hdrl_imagelist_basic.c:518
hdrl_imagelist_duplicate
hdrl_imagelist * hdrl_imagelist_duplicate(const hdrl_imagelist *himlist)
Duplicate an image list.
Definition: hdrl_imagelist_io.c:440
hdrl_imagelist_get_size_x
cpl_size hdrl_imagelist_get_size_x(const hdrl_imagelist *himlist)
Get number of colums of images in the imagelist.
Definition: hdrl_imagelist_io.c:168
hdrl_imagelist_collapse_weighted_mean
cpl_error_code hdrl_imagelist_collapse_weighted_mean(const hdrl_imagelist *himlist, hdrl_image **out, cpl_image **contrib)
Weighted Mean collapsing of image list.
Definition: hdrl_imagelist_basic.c:494
hdrl_imagelist_get
hdrl_image * hdrl_imagelist_get(const hdrl_imagelist *himlist, cpl_size inum)
Get an image from a list of images.
Definition: hdrl_imagelist_io.c:210
hdrl_maglim_compute
cpl_error_code hdrl_maglim_compute(const cpl_image *image, const double zeropoint, const double fwhm, const cpl_size kernel_size_x, const cpl_size kernel_size_y, const hdrl_image_extend_method image_extend_method, const hdrl_parameter *mode_parameter, double *limiting_magnitude)
Computes the limiting magnitude of an image.
Definition: hdrl_maglim.c:114
hdrl_parameter_delete
void hdrl_parameter_delete(hdrl_parameter *obj)
shallow delete of a parameter
Definition: hdrl_parameter.c:148
fraction
double fraction(double x, double y, double r_out)
Fraction of pixel bounded.
Definition: hdrl_cat_utils.c:49
Generated on Sun Dec 14 2025 21:04:06 for ERIS Pipeline Reference Manual by doxygen 1.9.6