38#include <casu_utils.h>
40#include <casu_stats.h>
42#include <casu_wcsutils.h>
44#include "vircam_utils.h"
45#include "vircam_pfits.h"
46#include "vircam_dfs.h"
47#include "vircam_mods.h"
48#include "vircam_channel.h"
49#include "vircam_dfs.h"
50#include "vircam_paf.h"
60static int vircam_dark_combine_create(cpl_plugin *) ;
61static int vircam_dark_combine_exec(cpl_plugin *) ;
62static int vircam_dark_combine_destroy(cpl_plugin *) ;
63static int vircam_dark_combine(cpl_parameterlist *, cpl_frameset *) ;
64static int vircam_dark_combine_save(cpl_frameset *framelist,
65 cpl_parameterlist *parlist);
66static void vircam_dark_combine_dummy_products(
void);
67static void vircam_dark_combine_hotpix(
void);
68static void vircam_dark_combine_normal(
int jext,
float exptime);
69static int vircam_dark_combine_lastbit(
int jext, cpl_frameset *framelist,
70 cpl_parameterlist *parlist);
71static void vircam_dark_combine_init(
void);
72static void vircam_dark_combine_tidy(
int level);
99} vircam_dark_combine_config;
104 cpl_frameset *darklist;
109 cpl_frame *master_dark;
110 casu_mask *master_mask;
113 cpl_propertylist *drs;
114 unsigned char *rejmask;
115 unsigned char *rejplus;
118 cpl_table *diffimstats;
119 cpl_propertylist *phupaf;
122static cpl_frame *product_frame_mean_dark = NULL;
123static cpl_frame *product_frame_diffimg = NULL;
124static cpl_frame *product_frame_diffimg_stats = NULL;
129static char vircam_dark_combine_description[] =
130"vircam_dark_combine -- VIRCAM dark combine recipe.\n\n"
131"Combine a list of dark frames into a mean dark frame. Optionally compare \n"
132"the output frame to a master dark frame\n\n"
133"The program accepts the following files in the SOF:\n\n"
135" -----------------------------------------------------------------------\n"
136" %-21s A list of raw dark images\n"
137" %-21s Optional reference dark frame\n"
138" %-21s Optional master bad pixel map or\n"
139" %-21s Optional master confidence map\n"
140" %-21s Optional channel table or\n"
141" %-21s Optional initial channel table\n"
142"If no master dark frame is made available, then no comparison will be done\n"
143"This means there will be no output difference image. If a master dark is\n"
144"available, but no channel table is, then a difference image will be formed\n"
145"but no stats will be written."
289int cpl_plugin_get_info(cpl_pluginlist *list) {
290 cpl_recipe *recipe = cpl_calloc(1,
sizeof(*recipe));
291 cpl_plugin *plugin = &recipe->interface;
292 char alldesc[SZ_ALLDESC];
293 (void)snprintf(alldesc,SZ_ALLDESC,vircam_dark_combine_description,
294 VIRCAM_DARK_RAW,VIRCAM_REF_DARK,VIRCAM_CAL_BPM,
295 VIRCAM_CAL_CONF,VIRCAM_CAL_CHANTAB,VIRCAM_CAL_CHANTAB_INIT);
297 cpl_plugin_init(plugin,
299 VIRCAM_BINARY_VERSION,
300 CPL_PLUGIN_TYPE_RECIPE,
301 "vircam_dark_combine",
302 "VIRCAM dark combination recipe",
307 vircam_dark_combine_create,
308 vircam_dark_combine_exec,
309 vircam_dark_combine_destroy);
311 cpl_pluginlist_append(list,plugin);
327static int vircam_dark_combine_create(cpl_plugin *plugin) {
333 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
334 recipe = (cpl_recipe *)plugin;
340 recipe->parameters = cpl_parameterlist_new();
344 p = cpl_parameter_new_range(
"vircam.vircam_dark_combine.combtype",
346 "1 == Median,\n 2 == Mean",
347 "vircam.vircam_dark_combine",
349 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"combtype");
350 cpl_parameterlist_append(recipe->parameters,p);
354 p = cpl_parameter_new_range(
"vircam.vircam_dark_combine.scaletype",
356 "0 == none,\n 1 == additive offset,\n 2 == multiplicative offset,\n 3 == exposure time scaling + additive offset",
357 "vircam.vircam_dark_combine",
359 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"scaletype");
360 cpl_parameterlist_append(recipe->parameters,p);
364 p = cpl_parameter_new_value(
"vircam.vircam_dark_combine.xrej",
366 "True if using extra rejection cycle",
367 "vircam.vircam_dark_combine",
369 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"xrej");
370 cpl_parameterlist_append(recipe->parameters,p);
374 p = cpl_parameter_new_value(
"vircam.vircam_dark_combine.thresh",
376 "Rejection threshold in sigma above background",
377 "vircam.vircam_dark_combine",5.0);
378 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"thresh");
379 cpl_parameterlist_append(recipe->parameters,p);
383 p = cpl_parameter_new_enum(
"vircam.vircam_dark_combine.ncells",
385 "Number of cells for data channel stats",
386 "vircam.vircam_dark_combine",8,7,1,2,4,8,
388 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"ncells");
389 cpl_parameterlist_append(recipe->parameters,p);
393 p = cpl_parameter_new_range(
"vircam.vircam_dark_combine.extenum",
395 "Extension number to be done, 0 == all",
396 "vircam.vircam_dark_combine",
398 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"ext");
399 cpl_parameterlist_append(recipe->parameters,p);
415static int vircam_dark_combine_exec(cpl_plugin *plugin) {
420 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
421 recipe = (cpl_recipe *)plugin;
425 return(vircam_dark_combine(recipe->parameters,recipe->frames));
436static int vircam_dark_combine_destroy(cpl_plugin *plugin) {
441 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
442 recipe = (cpl_recipe *)plugin;
446 cpl_parameterlist_delete(recipe->parameters);
459static int vircam_dark_combine(cpl_parameterlist *parlist,
460 cpl_frameset *framelist) {
461 const char *fctid=
"vircam_dark_combine";
463 int j,jst,jfn,retval,status,live,nx,ny;
469 cpl_propertylist *plist;
473 if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
474 cpl_msg_error(fctid,
"Input framelist NULL or has no input data");
480 vircam_dark_combine_init();
481 we_expect |= MEANDARK;
485 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.combtype");
486 vircam_dark_combine_config.combtype = cpl_parameter_get_int(p);
487 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.scaletype");
488 vircam_dark_combine_config.scaletype = cpl_parameter_get_int(p);
489 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.xrej");
490 vircam_dark_combine_config.xrej = cpl_parameter_get_bool(p);
491 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.thresh");
492 vircam_dark_combine_config.thresh = (float)cpl_parameter_get_double(p);
493 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.ncells");
494 vircam_dark_combine_config.ncells = cpl_parameter_get_int(p);
495 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.extenum");
496 vircam_dark_combine_config.extenum = cpl_parameter_get_int(p);
501 cpl_msg_error(fctid,
"Cannot identify RAW and CALIB frames");
502 vircam_dark_combine_tidy(2);
510 cpl_msg_error(fctid,
"Cannot labelise the input frames");
511 vircam_dark_combine_tidy(2);
518 VIRCAM_DARK_RAW)) == NULL) {
519 cpl_msg_error(fctid,
"Cannot find dark frames in input frameset");
520 vircam_dark_combine_tidy(2);
523 ps.ndarks = cpl_frameset_get_size(ps.darklist);
527 fname = cpl_frame_get_filename(cpl_frameset_get_position(ps.darklist,0));
528 plist = cpl_propertylist_load(fname,0);
530 cpl_msg_warning(fctid,
"Unable to get exposure time for %s",fname);
533 cpl_propertylist_delete(plist);
538 VIRCAM_REF_DARK)) == NULL)
539 cpl_msg_info(fctid,
"No master dark found -- no difference image will be formed");
541 we_expect |= DIFFIMG;
552 VIRCAM_CAL_CHANTAB)) == NULL) {
554 VIRCAM_CAL_CHANTAB_INIT)) == NULL)
555 cpl_msg_info(fctid,
"No channel table found -- no difference image stats will be done");
556 }
else if (we_expect & DIFFIMG)
557 we_expect |= STATS_TAB;
564 (
const cpl_frame *)cpl_frameset_get_position(ps.darklist,0),
566 if (jst == -1 || jfn == -1) {
567 cpl_msg_error(fctid,
"Unable to continue");
568 vircam_dark_combine_tidy(2);
574 ps.good = cpl_malloc(ps.ndarks*
sizeof(casu_fits *));
578 for (j = jst; j <= jfn; j++) {
581 isfirst = (j == jst);
587 if (ps.darks == NULL) {
589 "Extension %" CPL_SIZE_FORMAT
" darks wouldn't load",
591 retval = vircam_dark_combine_lastbit(j,framelist,parlist);
600 for (i = 0; i < ps.ndarks; i++) {
604 cpl_msg_info(fctid,
"Detector flagged dead %s",
608 ps.good[ps.ngood] = ff;
617 cpl_msg_info(fctid,
"All images flagged bad for this extension");
618 retval = vircam_dark_combine_lastbit(j,framelist,parlist);
629 if (retval == CASU_FATAL) {
631 "Unable to load mask image %s[%" CPL_SIZE_FORMAT
"]",
633 cpl_msg_info(fctid,
"Forcing all pixels to be good from now on");
640 cpl_msg_info(fctid,
"Doing combination for extension %" CPL_SIZE_FORMAT,
643 vircam_dark_combine_config.combtype,
644 vircam_dark_combine_config.scaletype,
645 vircam_dark_combine_config.xrej,
646 vircam_dark_combine_config.thresh,
"EXPTIME",
647 &(ps.outimage),NULL,&(ps.rejmask),
648 &(ps.rejplus),&(ps.drs),&status);
649 if (status == CASU_OK) {
651 vircam_dark_combine_hotpix();
652 vircam_dark_combine_normal(j,exptime);
657 retval = vircam_dark_combine_lastbit(j,framelist,parlist);
661 vircam_dark_combine_tidy(2);
675static int vircam_dark_combine_save(cpl_frameset *framelist,
676 cpl_parameterlist *parlist) {
677 cpl_propertylist *plist,*elist,*p,*pafprop;
678 const char *fctid =
"vircam_dark_combine_save";
679 const char *outfile =
"darkcomb.fits";
680 const char *outdiff =
"darkdiff.fits";
681 const char *outdimst =
"darkdifftab.fits";
682 const char *outfilepaf =
"darkcomb";
683 const char *outdiffpaf =
"darkdiff";
684 const char *recipeid =
"vircam_dark_combine";
692 product_frame_mean_dark = cpl_frame_new();
693 cpl_frame_set_filename(product_frame_mean_dark,outfile);
694 cpl_frame_set_tag(product_frame_mean_dark,VIRCAM_PRO_DARK);
695 cpl_frame_set_type(product_frame_mean_dark,CPL_FRAME_TYPE_IMAGE);
696 cpl_frame_set_group(product_frame_mean_dark,CPL_FRAME_GROUP_PRODUCT);
697 cpl_frame_set_level(product_frame_mean_dark,CPL_FRAME_LEVEL_FINAL);
702 ps.phupaf = vircam_paf_phu_items(plist);
703 if (ps.master_dark != NULL) {
704 cpl_propertylist_update_string(ps.phupaf,
"REF_DARK",
705 cpl_frame_get_filename(ps.master_dark));
706 cpl_propertylist_set_comment(ps.phupaf,
"REF_DARK",
707 "Reference dark used");
711 (
char *)recipeid,
"PRO-1.15",
716 if (cpl_image_save(NULL,outfile,CPL_TYPE_UCHAR,plist,
717 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
718 cpl_msg_error(fctid,
"Cannot save product PHU");
719 cpl_frame_delete(product_frame_mean_dark);
722 cpl_frameset_insert(framelist,product_frame_mean_dark);
726 if (we_expect & DIFFIMG) {
727 product_frame_diffimg = cpl_frame_new();
728 cpl_frame_set_filename(product_frame_diffimg,outdiff);
729 cpl_frame_set_tag(product_frame_diffimg,VIRCAM_PRO_DIFFIMG_DARK);
730 cpl_frame_set_type(product_frame_diffimg,CPL_FRAME_TYPE_IMAGE);
731 cpl_frame_set_group(product_frame_diffimg,CPL_FRAME_GROUP_PRODUCT);
732 cpl_frame_set_level(product_frame_diffimg,CPL_FRAME_LEVEL_FINAL);
744 if (cpl_image_save(NULL,outdiff,CPL_TYPE_UCHAR,plist,
745 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
746 cpl_msg_error(fctid,
"Cannot save product PHU");
747 cpl_frame_delete(product_frame_diffimg);
750 cpl_frameset_insert(framelist,product_frame_diffimg);
756 if (we_expect & STATS_TAB) {
757 product_frame_diffimg_stats = cpl_frame_new();
758 cpl_frame_set_filename(product_frame_diffimg_stats,outdimst);
759 cpl_frame_set_tag(product_frame_diffimg_stats,
760 VIRCAM_PRO_DIFFIMG_DARK_STATS);
761 cpl_frame_set_type(product_frame_diffimg_stats,
762 CPL_FRAME_TYPE_TABLE);
763 cpl_frame_set_group(product_frame_diffimg_stats,
764 CPL_FRAME_GROUP_PRODUCT);
765 cpl_frame_set_level(product_frame_diffimg_stats,
766 CPL_FRAME_LEVEL_FINAL);
772 product_frame_diffimg_stats,
780 p = cpl_propertylist_duplicate(elist);
782 if (! (we_get & STATS_TAB))
792 if (cpl_table_save(ps.diffimstats,plist,p,outdimst,
793 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
794 cpl_msg_error(fctid,
"Cannot save product table extension");
795 cpl_frame_delete(product_frame_diffimg_stats);
796 cpl_propertylist_delete(p);
799 cpl_propertylist_delete(p);
800 cpl_frameset_insert(framelist,product_frame_diffimg_stats);
807 cpl_propertylist_update_int(plist,
"ESO PRO DATANCOM",ps.ngood);
812 p = cpl_propertylist_duplicate(plist);
813 if (! (we_get & MEANDARK))
817 (
char *)recipeid,
"PRO-1.15",NULL);
821 cpl_propertylist_update_float(p,
"ESO QC DARKMED",
822 vircam_dark_combine_config.darkmed);
823 cpl_propertylist_set_comment(p,
"ESO QC DARKMED",
824 "Median of mean dark frame");
825 cpl_propertylist_update_float(p,
"ESO QC DARKRMS",
826 vircam_dark_combine_config.darkrms);
827 cpl_propertylist_set_comment(p,
"ESO QC DARKRMS",
828 "RMS of mean dark frame");
829 cpl_propertylist_update_float(p,
"ESO QC PARTICLE_RATE",
830 vircam_dark_combine_config.particle_rate);
831 cpl_propertylist_set_comment(p,
"ESO QC PARTICLE_RATE",
832 "[N/(detector*sec)] Particle rate");
833 cpl_propertylist_update_float(p,
"ESO QC STRIPERMS",
834 vircam_dark_combine_config.striperms);
835 cpl_propertylist_set_comment(p,
"ESO QC STRIPERMS",
"RMS of stripe pattern");
836 cpl_propertylist_update_int(p,
"ESO QC NHOTPIX",
837 vircam_dark_combine_config.nhot);
838 cpl_propertylist_set_comment(p,
"ESO QC NHOTPIX",
"Number of hot pixels");
839 cpl_propertylist_update_float(p,
"ESO QC HOTFRAC",
840 vircam_dark_combine_config.hotfrac);
841 cpl_propertylist_set_comment(p,
"ESO QC HOTFRAC",
"Hot pixel fraction");
842 cpl_propertylist_update_float(p,
"ESO QC RON12",
843 vircam_dark_combine_config.ron12);
844 cpl_propertylist_set_comment(p,
"ESO QC RON12",
845 "[ADU] Estimate of readnoise + stripe RMS");
846 if (cpl_image_save(ps.outimage,outfile,CPL_TYPE_FLOAT,p,
847 CPL_IO_EXTEND) != CPL_ERROR_NONE) {
848 cpl_msg_error(fctid,
"Cannot save product image extension");
849 cpl_propertylist_delete(p);
855 pafprop = vircam_paf_req_items(p);
857 vircam_paf_append(pafprop,p,
"ESO DET NDIT");
858 vircam_paf_append(pafprop,p,
"ESO PRO CATG");
859 vircam_paf_append(pafprop,p,
"ESO PRO DATANCOM");
860 if (vircam_paf_print((
char *)outfilepaf,
"VIRCAM/vircam_dark_combine",
861 "QC file",pafprop) != CASU_OK)
862 cpl_msg_warning(fctid,
"Unable to save PAF for mean dark");
863 cpl_propertylist_delete(pafprop);
864 cpl_propertylist_delete(p);
868 if (we_expect & DIFFIMG) {
869 p = cpl_propertylist_duplicate(plist);
870 if (! (we_get & DIFFIMG))
872 cpl_propertylist_update_float(p,
"ESO QC DARKDIFF_MED",
873 vircam_dark_combine_config.darkdiff_med);
874 cpl_propertylist_set_comment(p,
"ESO QC DARKDIFF_MED",
875 "Median of dark difference image");
876 cpl_propertylist_update_float(p,
"ESO QC DARKDIFF_RMS",
877 vircam_dark_combine_config.darkdiff_rms);
878 cpl_propertylist_set_comment(p,
"ESO QC DARKDIFF_RMS",
879 "RMS of dark difference image");
884 if (cpl_image_save(ps.diffimg,outdiff,CPL_TYPE_FLOAT,p,
885 CPL_IO_EXTEND) != CPL_ERROR_NONE) {
886 cpl_msg_error(fctid,
"Cannot save product image extension");
887 cpl_propertylist_delete(p);
893 pafprop = vircam_paf_req_items(p);
894 vircam_paf_append(pafprop,p,
"ESO PRO CATG");
896 if (vircam_paf_print((
char *)outdiffpaf,
"VIRCAM/vircam_dark_combine",
897 "QC file",pafprop) != CASU_OK)
898 cpl_msg_warning(fctid,
"Unable to save PAF for difference image");
899 cpl_propertylist_delete(pafprop);
900 cpl_propertylist_delete(p);
905 if (! isfirst && (we_expect & STATS_TAB)) {
906 p = cpl_propertylist_duplicate(plist);
907 if (! (we_get & STATS_TAB))
914 if (cpl_table_save(ps.diffimstats,NULL,p,outdimst,CPL_IO_EXTEND)
916 cpl_msg_error(fctid,
"Cannot save product table extension");
917 cpl_propertylist_delete(p);
920 cpl_propertylist_delete(p);
932static void vircam_dark_combine_dummy_products(
void) {
936 if (we_get == we_expect)
942 if (! (we_get & MEANDARK)) {
947 vircam_dark_combine_config.particle_rate = 0.0;
948 vircam_dark_combine_config.darkmed = 0.0;
949 vircam_dark_combine_config.darkrms = 0.0;
950 vircam_dark_combine_config.nhot = 0;
951 vircam_dark_combine_config.hotfrac = 0.0;
952 vircam_dark_combine_config.striperms = 0.0;
953 vircam_dark_combine_config.ron12 = 0.0;
958 if ((we_expect & DIFFIMG) && ! (we_get & DIFFIMG)) {
959 vircam_dark_combine_config.darkdiff_med = 0.0;
960 vircam_dark_combine_config.darkdiff_rms = 0.0;
966 if ((we_expect & STATS_TAB) && ! (we_get & STATS_TAB))
978static void vircam_dark_combine_hotpix(
void) {
979 int i,nx,ny,status,nh,nhot,j;
983 float med,mad,lowcut,highcut,*data;
989 nx = (int)cpl_image_get_size_x(im);
990 ny = (int)cpl_image_get_size_y(im);
991 npts = (long)(nx*ny);
992 bpm = cpl_calloc(npts,
sizeof(*bpm));
997 for (i = 0; i < ps.ngood; i++) {
1000 cpl_image_subtract(im,ps.outimage);
1004 vircam_dark_combine_config.striperms =
1006 "ESO DRS STRIPERMS");
1015 data = cpl_image_get_data_float(im);
1017 lowcut = med - 1.48*mad*vircam_dark_combine_config.thresh;
1018 highcut = med + 1.48*mad*vircam_dark_combine_config.thresh;
1019 for (j = 0; j < npts; j++)
1020 if (data[j] > highcut || data[j] < lowcut)
1031 nh = (ps.ngood + 1)/2;
1033 for (j = 0; j < npts; j++)
1041 data = cpl_image_get_data_float(im);
1043 mad *= 1.48/CPL_MATH_SQRT2;
1044 vircam_dark_combine_config.ron12 = mad;
1045 cpl_image_delete(im);
1053 vircam_dark_combine_config.nhot = nhot;
1054 vircam_dark_combine_config.hotfrac = (float)nhot/(
float)npts;
1066static void vircam_dark_combine_normal(
int jext,
float exptime) {
1067 int nx,ny,ndiff,ncells;
1070 float med,sig,*idata,grms,gdiff;
1071 const char *fctid=
"vircam_dark_combine_normal";
1073 cpl_propertylist *p;
1077 nx = (int)cpl_image_get_size_x(ps.outimage);
1078 ny = (int)cpl_image_get_size_y(ps.outimage);
1080 vircam_dark_combine_config.particle_rate = 0;
1087 for (i = 0; i < npi; i++)
1088 if ((ps.rejplus)[i] > 0 && bpm[i] == 0)
1089 ndiff += (ps.rejplus)[i];
1090 vircam_dark_combine_config.particle_rate =
1091 (float)ndiff/(exptime*(
float)(ps.ndarks));
1095 idata = cpl_image_get_data(ps.outimage);
1098 vircam_dark_combine_config.darkmed = med;
1099 vircam_dark_combine_config.darkrms = sig;
1103 if (ps.master_dark != NULL) {
1105 if (ps.mdimage == NULL)
1107 "Master dark extension %" CPL_SIZE_FORMAT
" won't load",
1111 "Master dark extension %" CPL_SIZE_FORMAT
" is a dummy!",
1113 freefits(ps.mdimage);
1120 if (ps.chantab != NULL) {
1121 ctable = cpl_table_load(cpl_frame_get_filename(ps.chantab),jext,0);
1122 if (ctable == NULL) {
1125 "Channel table extension %" CPL_SIZE_FORMAT
" won't load",
1129 "Channel table extension %" CPL_SIZE_FORMAT
" has errors",
1133 p = cpl_propertylist_load(cpl_frame_get_filename(ps.chantab),
1137 "Channel table extensions %" CPL_SIZE_FORMAT
" is a dummy",
1141 freepropertylist(p);
1152 vircam_dark_combine_config.darkdiff_med = 0.0;
1153 vircam_dark_combine_config.darkdiff_rms = 0.0;
1154 ncells = vircam_dark_combine_config.ncells;
1156 ps.outimage,bpm,ctable,ncells,1,
1157 &gdiff,&grms,&(ps.diffimg),
1160 vircam_dark_combine_config.darkdiff_med = gdiff;
1161 vircam_dark_combine_config.darkdiff_rms = grms;
1163 if (ps.diffimg != NULL)
1165 if (ps.diffimstats != NULL)
1166 we_get |= STATS_TAB;
1180static int vircam_dark_combine_lastbit(
int jext, cpl_frameset *framelist,
1181 cpl_parameterlist *parlist) {
1183 const char *fctid=
"vircam_dark_combine_lastbit";
1187 vircam_dark_combine_dummy_products();
1191 cpl_msg_info(fctid,
"Saving products for extension %" CPL_SIZE_FORMAT,
1193 retval = vircam_dark_combine_save(framelist,parlist);
1195 vircam_dark_combine_tidy(2);
1201 vircam_dark_combine_tidy(1);
1211static void vircam_dark_combine_init(
void) {
1218 ps.master_dark = NULL;
1219 ps.master_mask = NULL;
1227 ps.diffimstats = NULL;
1239static void vircam_dark_combine_tidy(
int level) {
1241 freeimage(ps.outimage);
1242 freefitslist(ps.darks,ps.ndarks);
1243 freepropertylist(ps.drs);
1244 freefits(ps.mdimage);
1245 freeimage(ps.diffimg);
1246 freetable(ps.diffimstats);
1247 freespace(ps.rejmask);
1248 freespace(ps.rejplus);
1251 freespace(ps.labels);
1252 freeframeset(ps.darklist);
1254 freeframe(ps.master_dark);
1255 freemask(ps.master_mask);
1256 freeframe(ps.chantab);
1257 freepropertylist(ps.phupaf);
cpl_image * casu_fits_get_image(casu_fits *p)
casu_fits ** casu_fits_load_list(cpl_frameset *f, cpl_type type, int exten)
void casu_fits_delete(casu_fits *p)
int casu_fits_set_error(casu_fits *p, int status)
char * casu_fits_get_fullname(casu_fits *p)
casu_fits * casu_fits_duplicate(casu_fits *in)
cpl_propertylist * casu_fits_get_phu(casu_fits *p)
cpl_propertylist * casu_fits_get_ehu(casu_fits *p)
casu_fits * casu_fits_load(cpl_frame *frame, cpl_type type, int nexten)
void casu_mask_force(casu_mask *m, int nx, int ny)
unsigned char * casu_mask_get_data(casu_mask *m)
int casu_mask_load(casu_mask *m, int nexten, int nx, int ny)
void casu_mask_clear(casu_mask *m)
casu_mask * casu_mask_define(cpl_frameset *framelist, cpl_size *labels, cpl_size nlab, const char *conftag, const char *bpmtag)
const char * casu_mask_get_filename(casu_mask *m)
int casu_imcombine(casu_fits **fset, casu_fits **fsetv, int nfits, int combtype, int scaletype, int xrej, float thresh, const char *expkey, cpl_image **outimage, cpl_image **outvimage, unsigned char **rejmask, unsigned char **rejplus, cpl_propertylist **drs, int *status)
Stack images into a mean or median image with rejection.
void casu_medmad(float *data, unsigned char *bpm, long np, float *med, float *mad)
int casu_compare_tags(const cpl_frame *frame1, const cpl_frame *frame2)
Compare input tags.
void casu_merge_propertylists(cpl_propertylist *p1, cpl_propertylist *p2)
Merge two propertylists.
void casu_dummy_property(cpl_propertylist *p)
Set dummy property keyword.
cpl_frame * casu_frameset_subgroup_1(cpl_frameset *frameset, cpl_size *labels, cpl_size nlab, const char *tag)
Extract a frame of a given label from a frameset.
cpl_image * casu_dummy_image(casu_fits *model)
Create a dummy image of zeros based on a model.
cpl_frameset * casu_frameset_subgroup(cpl_frameset *frameset, cpl_size *labels, cpl_size nlab, const char *tag)
Extract a frameset from another frameset.
int casu_removewcs(cpl_propertylist *p, int *status)
int vircam_destripe(casu_fits *in, casu_mask *inbpm, int *status)
Remove stripes from the background of an image.
int vircam_chantab_verify(cpl_table *intab)
int vircam_dfs_set_groups(cpl_frameset *set)
void vircam_dfs_set_product_primary_header(cpl_propertylist *plist, cpl_frame *frame, cpl_frameset *frameset, cpl_parameterlist *parlist, char *recipeid, const char *dict, cpl_frame *inherit, int synch)
void vircam_dfs_set_product_exten_header(cpl_propertylist *plist, cpl_frame *frame, cpl_frameset *frameset, cpl_parameterlist *parlist, char *recipeid, const char *dict, cpl_frame *inherit)
int vircam_pfits_get_detlive(const cpl_propertylist *plist, int *detlive)
Get the value of DET_LIVE.
int vircam_pfits_get_exptime(const cpl_propertylist *plist, float *exptime)
Get the value of exposure time.
const char * vircam_get_license(void)
cpl_table * vircam_create_diffimg_stats(int nrows)
void vircam_difference_image(cpl_image *master, cpl_image *prog, unsigned char *bpm, cpl_table *chantab, int ncells, int oper, float *global_diff, float *global_rms, cpl_image **diffim, cpl_table **diffimstats)
int vircam_is_dummy(cpl_propertylist *p)
void vircam_exten_range(int inexten, const cpl_frame *fr, int *out1, int *out2)