38 #include "vircam_utils.h"
39 #include "vircam_pfits.h"
40 #include "vircam_dfs.h"
41 #include "vircam_mods.h"
42 #include "vircam_stats.h"
43 #include "vircam_fits.h"
44 #include "vircam_mask.h"
45 #include "vircam_channel.h"
46 #include "vircam_dfs.h"
47 #include "vircam_paf.h"
48 #include "vircam_wcsutils.h"
58 static int vircam_dark_combine_create(cpl_plugin *) ;
59 static int vircam_dark_combine_exec(cpl_plugin *) ;
60 static int vircam_dark_combine_destroy(cpl_plugin *) ;
61 static int vircam_dark_combine(cpl_parameterlist *, cpl_frameset *) ;
62 static int vircam_dark_combine_save(cpl_frameset *framelist,
63 cpl_parameterlist *parlist);
64 static void vircam_dark_combine_dummy_products(
void);
65 static void vircam_dark_combine_hotpix(
void);
66 static void vircam_dark_combine_normal(
int jext,
float exptime);
67 static int vircam_dark_combine_lastbit(
int jext, cpl_frameset *framelist,
68 cpl_parameterlist *parlist);
69 static void vircam_dark_combine_init(
void);
70 static void vircam_dark_combine_tidy(
int level);
97 } vircam_dark_combine_config;
102 cpl_frameset *darklist;
107 cpl_frame *master_dark;
108 vir_mask *master_mask;
111 cpl_propertylist *drs;
112 unsigned char *rejmask;
113 unsigned char *rejplus;
116 cpl_table *diffimstats;
117 cpl_propertylist *phupaf;
120 static cpl_frame *product_frame_mean_dark = NULL;
121 static cpl_frame *product_frame_diffimg = NULL;
122 static cpl_frame *product_frame_diffimg_stats = NULL;
124 static int we_expect;
127 static char vircam_dark_combine_description[] =
128 "vircam_dark_combine -- VIRCAM dark combine recipe.\n\n"
129 "Combine a list of dark frames into a mean dark frame. Optionally compare \n"
130 "the output frame to a master dark frame\n\n"
131 "The program accepts the following files in the SOF:\n\n"
133 " -----------------------------------------------------------------------\n"
134 " %-21s A list of raw dark images\n"
135 " %-21s Optional reference dark frame\n"
136 " %-21s Optional master bad pixel map or\n"
137 " %-21s Optional master confidence map\n"
138 " %-21s Optional channel table or\n"
139 " %-21s Optional initial channel table\n"
140 "If no master dark frame is made available, then no comparison will be done\n"
141 "This means there will be no output difference image. If a master dark is\n"
142 "available, but no channel table is, then a difference image will be formed\n"
143 "but no stats will be written."
287 int cpl_plugin_get_info(cpl_pluginlist *list) {
288 cpl_recipe *recipe = cpl_calloc(1,
sizeof(*recipe));
289 cpl_plugin *plugin = &recipe->interface;
290 char alldesc[SZ_ALLDESC];
291 (void)snprintf(alldesc,SZ_ALLDESC,vircam_dark_combine_description,
292 VIRCAM_DARK_RAW,VIRCAM_REF_DARK,VIRCAM_CAL_BPM,
293 VIRCAM_CAL_CONF,VIRCAM_CAL_CHANTAB,VIRCAM_CAL_CHANTAB_INIT);
295 cpl_plugin_init(plugin,
297 VIRCAM_BINARY_VERSION,
298 CPL_PLUGIN_TYPE_RECIPE,
299 "vircam_dark_combine",
300 "VIRCAM dark combination recipe",
305 vircam_dark_combine_create,
306 vircam_dark_combine_exec,
307 vircam_dark_combine_destroy);
309 cpl_pluginlist_append(list,plugin);
325 static int vircam_dark_combine_create(cpl_plugin *plugin) {
331 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
332 recipe = (cpl_recipe *)plugin;
338 recipe->parameters = cpl_parameterlist_new();
342 p = cpl_parameter_new_range(
"vircam.vircam_dark_combine.combtype",
344 "1 == Median,\n 2 == Mean",
345 "vircam.vircam_dark_combine",
347 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"combtype");
348 cpl_parameterlist_append(recipe->parameters,p);
352 p = cpl_parameter_new_range(
"vircam.vircam_dark_combine.scaletype",
354 "0 == none,\n 1 == additive offset,\n 2 == multiplicative offset,\n 3 == exposure time scaling + additive offset",
355 "vircam.vircam_dark_combine",
357 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"scaletype");
358 cpl_parameterlist_append(recipe->parameters,p);
362 p = cpl_parameter_new_value(
"vircam.vircam_dark_combine.xrej",
364 "True if using extra rejection cycle",
365 "vircam.vircam_dark_combine",
367 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"xrej");
368 cpl_parameterlist_append(recipe->parameters,p);
372 p = cpl_parameter_new_value(
"vircam.vircam_dark_combine.thresh",
374 "Rejection threshold in sigma above background",
375 "vircam.vircam_dark_combine",5.0);
376 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"thresh");
377 cpl_parameterlist_append(recipe->parameters,p);
381 p = cpl_parameter_new_enum(
"vircam.vircam_dark_combine.ncells",
383 "Number of cells for data channel stats",
384 "vircam.vircam_dark_combine",8,7,1,2,4,8,
386 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"ncells");
387 cpl_parameterlist_append(recipe->parameters,p);
391 p = cpl_parameter_new_range(
"vircam.vircam_dark_combine.extenum",
393 "Extension number to be done, 0 == all",
394 "vircam.vircam_dark_combine",
396 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"ext");
397 cpl_parameterlist_append(recipe->parameters,p);
413 static int vircam_dark_combine_exec(cpl_plugin *plugin) {
418 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
419 recipe = (cpl_recipe *)plugin;
423 return(vircam_dark_combine(recipe->parameters,recipe->frames));
434 static int vircam_dark_combine_destroy(cpl_plugin *plugin) {
439 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
440 recipe = (cpl_recipe *)plugin;
444 cpl_parameterlist_delete(recipe->parameters);
457 static int vircam_dark_combine(cpl_parameterlist *parlist,
458 cpl_frameset *framelist) {
459 const char *fctid=
"vircam_dark_combine";
461 int j,jst,jfn,retval,status,live,nx,ny;
467 cpl_propertylist *plist;
471 if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
472 cpl_msg_error(fctid,
"Input framelist NULL or has no input data");
479 cpl_msg_error(fctid,
"Input frameset is missing files. Check SOF");
485 vircam_dark_combine_init();
486 we_expect |= MEANDARK;
490 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.combtype");
491 vircam_dark_combine_config.combtype = cpl_parameter_get_int(p);
492 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.scaletype");
493 vircam_dark_combine_config.scaletype = cpl_parameter_get_int(p);
494 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.xrej");
495 vircam_dark_combine_config.xrej = cpl_parameter_get_bool(p);
496 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.thresh");
497 vircam_dark_combine_config.thresh = (float)cpl_parameter_get_double(p);
498 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.ncells");
499 vircam_dark_combine_config.ncells = cpl_parameter_get_int(p);
500 p = cpl_parameterlist_find(parlist,
"vircam.vircam_dark_combine.extenum");
501 vircam_dark_combine_config.extenum = cpl_parameter_get_int(p);
506 cpl_msg_error(fctid,
"Cannot identify RAW and CALIB frames");
507 vircam_dark_combine_tidy(2);
515 cpl_msg_error(fctid,
"Cannot labelise the input frames");
516 vircam_dark_combine_tidy(2);
523 VIRCAM_DARK_RAW)) == NULL) {
524 cpl_msg_error(fctid,
"Cannot find dark frames in input frameset");
525 vircam_dark_combine_tidy(2);
528 ps.ndarks = cpl_frameset_get_size(ps.darklist);
532 fname = cpl_frame_get_filename(cpl_frameset_get_first(ps.darklist));
533 plist = cpl_propertylist_load(fname,0);
535 cpl_msg_warning(fctid,
"Unable to get exposure time for %s",fname);
538 cpl_propertylist_delete(plist);
543 VIRCAM_REF_DARK)) == NULL)
544 cpl_msg_info(fctid,
"No master dark found -- no difference image will be formed");
546 we_expect |= DIFFIMG;
556 VIRCAM_CAL_CHANTAB)) == NULL) {
558 VIRCAM_CAL_CHANTAB_INIT)) == NULL)
559 cpl_msg_info(fctid,
"No channel table found -- no difference image stats will be done");
560 }
else if (we_expect & DIFFIMG)
561 we_expect |= STATS_TAB;
568 (
const cpl_frame *)cpl_frameset_get_frame(ps.darklist,0),
570 if (jst == -1 || jfn == -1) {
571 cpl_msg_error(fctid,
"Unable to continue");
572 vircam_dark_combine_tidy(2);
578 ps.good = cpl_malloc(ps.ndarks*
sizeof(vir_fits *));
582 for (j = jst; j <= jfn; j++) {
585 isfirst = (j == jst);
591 if (ps.darks == NULL) {
593 "Extension %" CPL_SIZE_FORMAT
" darks wouldn't load",
595 retval = vircam_dark_combine_lastbit(j,framelist,parlist);
604 for (i = 0; i < ps.ndarks; i++) {
608 cpl_msg_info(fctid,
"Detector flagged dead %s",
612 ps.good[ps.ngood] = ff;
621 cpl_msg_info(fctid,
"All images flagged bad for this extension");
622 retval = vircam_dark_combine_lastbit(j,framelist,parlist);
633 if (retval == VIR_FATAL) {
635 "Unable to load mask image %s[%" CPL_SIZE_FORMAT
"]",
637 cpl_msg_info(fctid,
"Forcing all pixels to be good from now on");
644 cpl_msg_info(fctid,
"Doing combination for extension %" CPL_SIZE_FORMAT,
647 vircam_dark_combine_config.combtype,
648 vircam_dark_combine_config.scaletype,
649 vircam_dark_combine_config.xrej,
650 vircam_dark_combine_config.thresh,
651 &(ps.outimage),&(ps.rejmask),
652 &(ps.rejplus),&(ps.drs),&status);
653 if (status == VIR_OK) {
655 vircam_dark_combine_hotpix();
656 vircam_dark_combine_normal(j,exptime);
661 retval = vircam_dark_combine_lastbit(j,framelist,parlist);
665 vircam_dark_combine_tidy(2);
679 static int vircam_dark_combine_save(cpl_frameset *framelist,
680 cpl_parameterlist *parlist) {
681 cpl_propertylist *plist,*elist,*p,*pafprop;
683 const char *fctid =
"vircam_dark_combine_save";
684 const char *outfile =
"darkcomb.fits";
685 const char *outdiff =
"darkdiff.fits";
686 const char *outdimst =
"darkdifftab.fits";
687 const char *outfilepaf =
"darkcomb";
688 const char *outdiffpaf =
"darkdiff";
689 const char *recipeid =
"vircam_dark_combine";
697 product_frame_mean_dark = cpl_frame_new();
698 cpl_frame_set_filename(product_frame_mean_dark,outfile);
699 cpl_frame_set_tag(product_frame_mean_dark,VIRCAM_PRO_DARK);
700 cpl_frame_set_type(product_frame_mean_dark,CPL_FRAME_TYPE_IMAGE);
701 cpl_frame_set_group(product_frame_mean_dark,CPL_FRAME_GROUP_PRODUCT);
702 cpl_frame_set_level(product_frame_mean_dark,CPL_FRAME_LEVEL_FINAL);
707 ps.phupaf = vircam_paf_phu_items(plist);
708 if (ps.master_dark != NULL) {
709 cpl_propertylist_update_string(ps.phupaf,
"REF_DARK",
710 cpl_frame_get_filename(ps.master_dark));
711 cpl_propertylist_set_comment(ps.phupaf,
"REF_DARK",
712 "Reference dark used");
716 (
char *)recipeid,
"PRO-1.15",
721 if (cpl_image_save(NULL,outfile,CPL_TYPE_UCHAR,plist,
722 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
723 cpl_msg_error(fctid,
"Cannot save product PHU");
724 cpl_frame_delete(product_frame_mean_dark);
727 cpl_frameset_insert(framelist,product_frame_mean_dark);
731 if (we_expect & DIFFIMG) {
732 product_frame_diffimg = cpl_frame_new();
733 cpl_frame_set_filename(product_frame_diffimg,outdiff);
734 cpl_frame_set_tag(product_frame_diffimg,VIRCAM_PRO_DIFFIMG_DARK);
735 cpl_frame_set_type(product_frame_diffimg,CPL_FRAME_TYPE_IMAGE);
736 cpl_frame_set_group(product_frame_diffimg,CPL_FRAME_GROUP_PRODUCT);
737 cpl_frame_set_level(product_frame_diffimg,CPL_FRAME_LEVEL_FINAL);
749 if (cpl_image_save(NULL,outdiff,CPL_TYPE_UCHAR,plist,
750 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
751 cpl_msg_error(fctid,
"Cannot save product PHU");
752 cpl_frame_delete(product_frame_diffimg);
755 cpl_frameset_insert(framelist,product_frame_diffimg);
761 if (we_expect & STATS_TAB) {
762 product_frame_diffimg_stats = cpl_frame_new();
763 cpl_frame_set_filename(product_frame_diffimg_stats,outdimst);
764 cpl_frame_set_tag(product_frame_diffimg_stats,
765 VIRCAM_PRO_DIFFIMG_DARK_STATS);
766 cpl_frame_set_type(product_frame_diffimg_stats,
767 CPL_FRAME_TYPE_TABLE);
768 cpl_frame_set_group(product_frame_diffimg_stats,
769 CPL_FRAME_GROUP_PRODUCT);
770 cpl_frame_set_level(product_frame_diffimg_stats,
771 CPL_FRAME_LEVEL_FINAL);
777 product_frame_diffimg_stats,
785 p = cpl_propertylist_duplicate(elist);
787 if (! (we_get & STATS_TAB))
798 if (cpl_table_save(ps.diffimstats,plist,p,outdimst,
799 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
800 cpl_msg_error(fctid,
"Cannot save product table extension");
801 cpl_frame_delete(product_frame_diffimg_stats);
802 cpl_propertylist_delete(p);
805 cpl_propertylist_delete(p);
806 cpl_frameset_insert(framelist,product_frame_diffimg_stats);
813 cpl_propertylist_update_int(plist,
"ESO PRO DATANCOM",ps.ngood);
818 p = cpl_propertylist_duplicate(plist);
819 if (! (we_get & MEANDARK))
823 (
char *)recipeid,
"PRO-1.15",NULL);
827 cpl_propertylist_update_float(p,
"ESO QC DARKMED",
828 vircam_dark_combine_config.darkmed);
829 cpl_propertylist_set_comment(p,
"ESO QC DARKMED",
830 "Median of mean dark frame");
831 cpl_propertylist_update_float(p,
"ESO QC DARKRMS",
832 vircam_dark_combine_config.darkrms);
833 cpl_propertylist_set_comment(p,
"ESO QC DARKRMS",
834 "RMS of mean dark frame");
835 cpl_propertylist_update_float(p,
"ESO QC PARTICLE_RATE",
836 vircam_dark_combine_config.particle_rate);
837 cpl_propertylist_set_comment(p,
"ESO QC PARTICLE_RATE",
838 "[N/(detector*sec)] Particle rate");
839 cpl_propertylist_update_float(p,
"ESO QC STRIPERMS",
840 vircam_dark_combine_config.striperms);
841 cpl_propertylist_set_comment(p,
"ESO QC STRIPERMS",
"RMS of stripe pattern");
842 cpl_propertylist_update_int(p,
"ESO QC NHOTPIX",
843 vircam_dark_combine_config.nhot);
844 cpl_propertylist_set_comment(p,
"ESO QC NHOTPIX",
"Number of hot pixels");
845 cpl_propertylist_update_float(p,
"ESO QC HOTFRAC",
846 vircam_dark_combine_config.hotfrac);
847 cpl_propertylist_set_comment(p,
"ESO QC HOTFRAC",
"Hot pixel fraction");
848 cpl_propertylist_update_float(p,
"ESO QC RON12",
849 vircam_dark_combine_config.ron12);
850 cpl_propertylist_set_comment(p,
"ESO QC RON12",
851 "[ADU] Estimate of readnoise + stripe RMS");
852 if (cpl_image_save(ps.outimage,outfile,CPL_TYPE_FLOAT,p,
853 CPL_IO_EXTEND) != CPL_ERROR_NONE) {
854 cpl_msg_error(fctid,
"Cannot save product image extension");
855 cpl_propertylist_delete(p);
861 pafprop = vircam_paf_req_items(p);
863 vircam_paf_append(pafprop,p,
"ESO DET NDIT");
864 vircam_paf_append(pafprop,p,
"ESO PRO CATG");
865 vircam_paf_append(pafprop,p,
"ESO PRO DATANCOM");
866 if (vircam_paf_print((
char *)outfilepaf,
"VIRCAM/vircam_dark_combine",
867 "QC file",pafprop) != VIR_OK)
868 cpl_msg_warning(fctid,
"Unable to save PAF for mean dark");
869 cpl_propertylist_delete(pafprop);
870 cpl_propertylist_delete(p);
874 if (we_expect & DIFFIMG) {
875 p = cpl_propertylist_duplicate(plist);
876 if (! (we_get & DIFFIMG))
878 cpl_propertylist_update_float(p,
"ESO QC DARKDIFF_MED",
879 vircam_dark_combine_config.darkdiff_med);
880 cpl_propertylist_set_comment(p,
"ESO QC DARKDIFF_MED",
881 "Median of dark difference image");
882 cpl_propertylist_update_float(p,
"ESO QC DARKDIFF_RMS",
883 vircam_dark_combine_config.darkdiff_rms);
884 cpl_propertylist_set_comment(p,
"ESO QC DARKDIFF_RMS",
885 "RMS of dark difference image");
890 if (cpl_image_save(ps.diffimg,outdiff,CPL_TYPE_FLOAT,p,
891 CPL_IO_EXTEND) != CPL_ERROR_NONE) {
892 cpl_msg_error(fctid,
"Cannot save product image extension");
893 cpl_propertylist_delete(p);
899 pafprop = vircam_paf_req_items(p);
900 vircam_paf_append(pafprop,p,
"ESO PRO CATG");
902 if (vircam_paf_print((
char *)outdiffpaf,
"VIRCAM/vircam_dark_combine",
903 "QC file",pafprop) != VIR_OK)
904 cpl_msg_warning(fctid,
"Unable to save PAF for difference image");
905 cpl_propertylist_delete(pafprop);
906 cpl_propertylist_delete(p);
911 if (! isfirst && (we_expect & STATS_TAB)) {
912 p = cpl_propertylist_duplicate(plist);
913 if (! (we_get & STATS_TAB))
921 if (cpl_table_save(ps.diffimstats,NULL,p,outdimst,CPL_IO_EXTEND)
923 cpl_msg_error(fctid,
"Cannot save product table extension");
924 cpl_propertylist_delete(p);
927 cpl_propertylist_delete(p);
939 static void vircam_dark_combine_dummy_products(
void) {
943 if (we_get == we_expect)
949 if (! (we_get & MEANDARK)) {
954 vircam_dark_combine_config.particle_rate = 0.0;
955 vircam_dark_combine_config.darkmed = 0.0;
956 vircam_dark_combine_config.darkrms = 0.0;
957 vircam_dark_combine_config.nhot = 0;
958 vircam_dark_combine_config.hotfrac = 0.0;
959 vircam_dark_combine_config.striperms = 0.0;
960 vircam_dark_combine_config.ron12 = 0.0;
965 if ((we_expect & DIFFIMG) && ! (we_get & DIFFIMG)) {
966 vircam_dark_combine_config.darkdiff_med = 0.0;
967 vircam_dark_combine_config.darkdiff_rms = 0.0;
973 if ((we_expect & STATS_TAB) && ! (we_get & STATS_TAB))
985 static void vircam_dark_combine_hotpix(
void) {
986 int i,nx,ny,status,nh,nhot,j;
990 float med,mad,lowcut,highcut,*data;
996 nx = (int)cpl_image_get_size_x(im);
997 ny = (int)cpl_image_get_size_y(im);
998 npts = (long)(nx*ny);
999 bpm = cpl_calloc(npts,
sizeof(*bpm));
1004 for (i = 0; i < ps.ngood; i++) {
1007 cpl_image_subtract(im,ps.outimage);
1011 vircam_dark_combine_config.striperms =
1013 "ESO DRS STRIPERMS");
1022 data = cpl_image_get_data_float(im);
1024 lowcut = med - 1.48*mad*vircam_dark_combine_config.thresh;
1025 highcut = med + 1.48*mad*vircam_dark_combine_config.thresh;
1026 for (j = 0; j < npts; j++)
1027 if (data[j] > highcut || data[j] < lowcut)
1038 nh = (ps.ngood + 1)/2;
1040 for (j = 0; j < npts; j++)
1048 data = cpl_image_get_data_float(im);
1050 mad *= 1.48/CPL_MATH_SQRT2;
1051 vircam_dark_combine_config.ron12 = mad;
1052 cpl_image_delete(im);
1060 vircam_dark_combine_config.nhot = nhot;
1061 vircam_dark_combine_config.hotfrac = (float)nhot/(
float)npts;
1073 static void vircam_dark_combine_normal(
int jext,
float exptime) {
1074 int nx,ny,ndiff,ncells;
1077 float med,sig,*idata,grms,gdiff;
1078 const char *fctid=
"vircam_dark_combine_normal";
1080 cpl_propertylist *p;
1084 nx = (int)cpl_image_get_size_x(ps.outimage);
1085 ny = (int)cpl_image_get_size_y(ps.outimage);
1087 vircam_dark_combine_config.particle_rate = 0;
1094 for (i = 0; i < npi; i++)
1095 if ((ps.rejplus)[i] > 0 && bpm[i] == 0)
1096 ndiff += (ps.rejplus)[i];
1097 vircam_dark_combine_config.particle_rate =
1098 (float)ndiff/(exptime*(
float)(ps.ndarks));
1102 idata = cpl_image_get_data(ps.outimage);
1105 vircam_dark_combine_config.darkmed = med;
1106 vircam_dark_combine_config.darkrms = sig;
1110 if (ps.master_dark != NULL) {
1112 if (ps.mdimage == NULL)
1114 "Master dark extension %" CPL_SIZE_FORMAT
" won't load",
1118 "Master dark extension %" CPL_SIZE_FORMAT
" is a dummy!",
1120 freefits(ps.mdimage);
1127 if (ps.chantab != NULL) {
1128 ctable = cpl_table_load(cpl_frame_get_filename(ps.chantab),jext,0);
1129 if (ctable == NULL) {
1132 "Channel table extension %" CPL_SIZE_FORMAT
" won't load",
1136 "Channel table extension %" CPL_SIZE_FORMAT
" has errors",
1140 p = cpl_propertylist_load(cpl_frame_get_filename(ps.chantab),
1144 "Channel table extensions %" CPL_SIZE_FORMAT
" is a dummy",
1148 freepropertylist(p);
1159 vircam_dark_combine_config.darkdiff_med = 0.0;
1160 vircam_dark_combine_config.darkdiff_rms = 0.0;
1161 ncells = vircam_dark_combine_config.ncells;
1163 ps.outimage,bpm,ctable,ncells,1,
1164 &gdiff,&grms,&(ps.diffimg),
1167 vircam_dark_combine_config.darkdiff_med = gdiff;
1168 vircam_dark_combine_config.darkdiff_rms = grms;
1170 if (ps.diffimg != NULL)
1172 if (ps.diffimstats != NULL)
1173 we_get |= STATS_TAB;
1187 static int vircam_dark_combine_lastbit(
int jext, cpl_frameset *framelist,
1188 cpl_parameterlist *parlist) {
1190 const char *fctid=
"vircam_dark_combine_lastbit";
1194 vircam_dark_combine_dummy_products();
1198 cpl_msg_info(fctid,
"Saving products for extension %" CPL_SIZE_FORMAT,
1200 retval = vircam_dark_combine_save(framelist,parlist);
1202 vircam_dark_combine_tidy(2);
1208 vircam_dark_combine_tidy(1);
1218 static void vircam_dark_combine_init(
void) {
1225 ps.master_dark = NULL;
1226 ps.master_mask = NULL;
1234 ps.diffimstats = NULL;
1246 static void vircam_dark_combine_tidy(
int level) {
1248 freeimage(ps.outimage);
1249 freefitslist(ps.darks,ps.ndarks);
1250 freepropertylist(ps.drs);
1251 freefits(ps.mdimage);
1252 freeimage(ps.diffimg);
1253 freetable(ps.diffimstats);
1254 freespace(ps.rejmask);
1255 freespace(ps.rejplus);
1258 freespace(ps.labels);
1259 freeframeset(ps.darklist);
1261 freeframe(ps.master_dark);
1262 freemask(ps.master_mask);
1263 freeframe(ps.chantab);
1264 freepropertylist(ps.phupaf);
const char * vircam_get_license(void)
void vircam_mask_force(vir_mask *m, int nx, int ny)
int vircam_compare_tags(const cpl_frame *frame1, const cpl_frame *frame2)
int vircam_chantab_verify(cpl_table *intab)
int vircam_is_dummy(cpl_propertylist *p)
void vircam_merge_propertylists(cpl_propertylist *p1, cpl_propertylist *p2)
vir_fits ** vircam_fits_load_list(cpl_frameset *f, cpl_type type, int exten)
cpl_frame * vircam_frameset_subgroup_1(cpl_frameset *frameset, cpl_size *labels, cpl_size nlab, const char *tag)
void vircam_mask_clear(vir_mask *m)
cpl_image * vircam_dummy_image(vir_fits *model)
int vircam_pfits_get_exptime(const cpl_propertylist *plist, float *exptime)
Get the value of exposure time.
void vircam_fits_delete(vir_fits *p)
int vircam_mask_load(vir_mask *m, int nexten, int nx, int ny)
char * vircam_fits_get_fullname(vir_fits *p)
int vircam_destripe(vir_fits *in, vir_mask *inbpm, int *status)
Remove stripes from the background of an image.
unsigned char * vircam_mask_get_data(vir_mask *m)
cpl_image * vircam_fits_get_image(vir_fits *p)
cpl_table * vircam_create_diffimg_stats(int nrows)
cpl_frameset * vircam_frameset_subgroup(cpl_frameset *frameset, cpl_size *labels, cpl_size nlab, const char *tag)
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)
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)
int vircam_fits_set_error(vir_fits *p, int status)
void vircam_medmad(float *data, unsigned char *bpm, long np, float *med, float *mad)
vir_fits * vircam_fits_duplicate(vir_fits *in)
void vircam_dummy_property(cpl_propertylist *p)
cpl_propertylist * vircam_fits_get_phu(vir_fits *p)
vir_fits * vircam_fits_load(cpl_frame *frame, cpl_type type, int nexten)
cpl_propertylist * vircam_fits_get_ehu(vir_fits *p)
int vircam_frameset_fexists(cpl_frameset *frameset)
const char * vircam_mask_get_filename(vir_mask *m)
vir_mask * vircam_mask_define(cpl_frameset *framelist, cpl_size *labels, cpl_size nlab)
int vircam_pfits_get_detlive(const cpl_propertylist *plist, int *detlive)
Get the value of DET_LIVE.
int vircam_imcombine(vir_fits **fset, int nfits, int combtype, int scaletype, int xrej, float thresh, cpl_image **outimage, unsigned char **rejmask, unsigned char **rejplus, cpl_propertylist **drs, int *status)
Stack images into a mean or median image with rejection.
void vircam_exten_range(int inexten, const cpl_frame *fr, int *out1, int *out2)
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_removewcs(cpl_propertylist *p, int *status)
int vircam_dfs_set_groups(cpl_frameset *set)