38 #include <casu_utils.h>
39 #include <casu_mods.h>
40 #include <casu_stats.h>
41 #include <casu_mask.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"
60 static int vircam_dark_combine_create(cpl_plugin *) ;
61 static int vircam_dark_combine_exec(cpl_plugin *) ;
62 static int vircam_dark_combine_destroy(cpl_plugin *) ;
63 static int vircam_dark_combine(cpl_parameterlist *, cpl_frameset *) ;
64 static int vircam_dark_combine_save(cpl_frameset *framelist,
65 cpl_parameterlist *parlist);
66 static void vircam_dark_combine_dummy_products(
void);
67 static void vircam_dark_combine_hotpix(
void);
68 static void vircam_dark_combine_normal(
int jext,
float exptime);
69 static int vircam_dark_combine_lastbit(
int jext, cpl_frameset *framelist,
70 cpl_parameterlist *parlist);
71 static void vircam_dark_combine_init(
void);
72 static 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;
122 static cpl_frame *product_frame_mean_dark = NULL;
123 static cpl_frame *product_frame_diffimg = NULL;
124 static cpl_frame *product_frame_diffimg_stats = NULL;
126 static int we_expect;
129 static 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."
289 int 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);
327 static 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);
415 static 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));
436 static 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);
459 static 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);
675 static 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);
932 static 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))
978 static 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;
1066 static 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;
1180 static 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);
1211 static void vircam_dark_combine_init(
void) {
1218 ps.master_dark = NULL;
1219 ps.master_mask = NULL;
1227 ps.diffimstats = NULL;
1239 static 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(cpl_frame *frame, cpl_type type, int nexten)
casu_fits ** casu_fits_load_list(cpl_frameset *f, cpl_type type, int exten)
char * casu_fits_get_fullname(casu_fits *p)
void casu_fits_delete(casu_fits *p)
casu_fits * casu_fits_duplicate(casu_fits *in)
int casu_fits_set_error(casu_fits *p, int status)
cpl_propertylist * casu_fits_get_phu(casu_fits *p)
cpl_propertylist * casu_fits_get_ehu(casu_fits *p)
void casu_mask_force(casu_mask *m, int nx, int ny)
unsigned char * casu_mask_get_data(casu_mask *m)
const char * casu_mask_get_filename(casu_mask *m)
int casu_mask_load(casu_mask *m, int nexten, int nx, int ny)
casu_mask * casu_mask_define(cpl_frameset *framelist, cpl_size *labels, cpl_size nlab, const char *conftag, const char *bpmtag)
void casu_mask_clear(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)
cpl_image * casu_dummy_image(casu_fits *model)
Create a dummy image of zeros based on a model.
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.
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_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.
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)
const char * vircam_get_license(void)
void vircam_exten_range(int inexten, const cpl_frame *fr, int *out1, int *out2)