39 #include <casu_utils.h>
40 #include <casu_mods.h>
41 #include <casu_mask.h>
43 #include "vircam_utils.h"
44 #include "vircam_pfits.h"
45 #include "vircam_dfs.h"
46 #include "vircam_mods.h"
47 #include "vircam_jmp_utils.h"
48 #include "vircam_paf.h"
52 static int vircam_jitter_microstep_process_create(cpl_plugin *);
53 static int vircam_jitter_microstep_process_exec(cpl_plugin *);
54 static int vircam_jitter_microstep_process_destroy(cpl_plugin *);
55 static int vircam_jitter_microstep_process(cpl_parameterlist *,
57 static cpl_propertylist *vircam_jitter_microstep_process_dummyqc(
int type);
60 static char vircam_jitter_microstep_process_description[] =
61 "vircam_jitter_microstep_process -- VIRCAM science product recipe.\n\n"
62 "Process a complete pawprint for VIRCAM data. Remove instrumental\n"
63 "signature, interleave microstep sequences (if done), combine jitters\n"
64 "photometrically and astrometrically calibrate the pawprint image\n\n"
65 "The program accepts the following files in the SOF:\n\n"
67 " -----------------------------------------------------------------------\n"
68 " %-21s A list of raw science images or\n"
69 " %-21s A list of raw science images (extended)\n"
70 " %-21s A list of offset sky exposures (optional)\n"
71 " %-21s A master dark frame\n"
72 " %-21s A master twilight flat frame\n"
73 " %-21s A master sky frame (optional)\n"
74 " %-21s A channel table\n"
75 " %-21s A photometric calibration table\n"
76 " %-21s A readnoise/gain file\n"
77 " %-21s A master confidence map or\n"
78 " %-21s A master bad pixel mask\n"
79 " %-21s A master standard star index\n"
80 "All of the above are required\n"
232 int cpl_plugin_get_info(cpl_pluginlist *list) {
233 cpl_recipe *recipe = cpl_calloc(1,
sizeof(*recipe));
234 cpl_plugin *plugin = &recipe->interface;
235 char alldesc[SZ_ALLDESC];
236 (void)snprintf(alldesc,SZ_ALLDESC,
237 vircam_jitter_microstep_process_description,
238 VIRCAM_SCI_OBJECT_RAW,VIRCAM_SCI_OBJECT_EXT_RAW,
239 VIRCAM_OFFSET_SKY_RAW,VIRCAM_CAL_DARK,
240 VIRCAM_CAL_TWILIGHT_FLAT,VIRCAM_CAL_SKY,VIRCAM_CAL_CHANTAB,
241 VIRCAM_CAL_PHOTTAB,VIRCAM_CAL_READGAINFILE,VIRCAM_CAL_CONF,
242 VIRCAM_CAL_BPM,VIRCAM_CAL_2MASS);
244 cpl_plugin_init(plugin,
246 VIRCAM_BINARY_VERSION,
247 CPL_PLUGIN_TYPE_RECIPE,
248 "vircam_jitter_microstep_process",
249 "VIRCAM jitter microstep recipe",
254 vircam_jitter_microstep_process_create,
255 vircam_jitter_microstep_process_exec,
256 vircam_jitter_microstep_process_destroy);
258 cpl_pluginlist_append(list,plugin);
274 static int vircam_jitter_microstep_process_create(cpl_plugin *plugin) {
280 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
281 recipe = (cpl_recipe *)plugin;
287 recipe->parameters = cpl_parameterlist_new();
291 p = cpl_parameter_new_value(
"vircam.vircam_jitter_microstep_process.ipix",
293 "Minimum pixel area for each detected object",
294 "vircam.vircam_jitter_microstep_process",5);
295 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"ipix");
296 cpl_parameterlist_append(recipe->parameters,p);
300 p = cpl_parameter_new_value(
"vircam.vircam_jitter_microstep_process.thresh",
302 "Detection threshold in sigma above sky",
303 "vircam.vircam_jitter_microstep_process",2.0);
304 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"thr");
305 cpl_parameterlist_append(recipe->parameters,p);
309 p = cpl_parameter_new_value(
"vircam.vircam_jitter_microstep_process.icrowd",
310 CPL_TYPE_BOOL,
"Use deblending?",
311 "vircam.vircam_jitter_microstep_process",1);
312 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"icrowd");
313 cpl_parameterlist_append(recipe->parameters,p);
317 p = cpl_parameter_new_value(
"vircam.vircam_jitter_microstep_process.rcore",
318 CPL_TYPE_DOUBLE,
"Value of Rcore in pixels",
319 "vircam.vircam_jitter_microstep_process",3.0);
320 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"rcore");
321 cpl_parameterlist_append(recipe->parameters,p);
325 p = cpl_parameter_new_value(
"vircam.vircam_jitter_microstep_process.nbsize",
326 CPL_TYPE_INT,
"Background smoothing box size",
327 "vircam.vircam_jitter_microstep_process",64);
328 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"nb");
329 cpl_parameterlist_append(recipe->parameters,p);
333 p = cpl_parameter_new_value(
"vircam.vircam_jitter_microstep_process.savecat",
334 CPL_TYPE_BOOL,
"Save catalogue?",
335 "vircam.vircam_jitter_microstep_process",1);
336 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"savecat");
337 cpl_parameterlist_append(recipe->parameters,p);
342 p = cpl_parameter_new_value(
"vircam.vircam_jitter_microstep_process.destripe",
343 CPL_TYPE_BOOL,
"Destripe images?",
344 "vircam.vircam_jitter_microstep_process",1);
345 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"destripe");
346 cpl_parameterlist_append(recipe->parameters,p);
350 p = cpl_parameter_new_value(
"vircam.vircam_jitter_microstep_process.skycor",
351 CPL_TYPE_BOOL,
"Do a sky subtraction?",
352 "vircam.vircam_jitter_microstep_process",1);
353 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"skycor");
354 cpl_parameterlist_append(recipe->parameters,p);
358 p = cpl_parameter_new_value(
"vircam.vircam_jitter_microstep_process.savesimple",
359 CPL_TYPE_BOOL,
"Save simple images?",
360 "vircam.vircam_jitter_microstep_process",0);
361 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"savesimple");
362 cpl_parameterlist_append(recipe->parameters,p);
366 p = cpl_parameter_new_range(
"vircam.vircam_jitter_microstep_process.extenum",
368 "Extension number to be done, 0 == all",
369 "vircam.vircam_jitter_microstep_process",
371 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"ext");
372 cpl_parameterlist_append(recipe->parameters,p);
388 static int vircam_jitter_microstep_process_exec(cpl_plugin *plugin) {
393 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
394 recipe = (cpl_recipe *)plugin;
398 return(vircam_jitter_microstep_process(recipe->parameters,recipe->frames));
409 static int vircam_jitter_microstep_process_destroy(cpl_plugin *plugin) {
414 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
415 recipe = (cpl_recipe *)plugin;
419 cpl_parameterlist_delete(recipe->parameters);
432 static int vircam_jitter_microstep_process(cpl_parameterlist *parlist,
433 cpl_frameset *framelist) {
434 const char *fctid=
"vircam_jitter_microstep_process";
436 int jst,jfn,status,j,i,retval,nusteps,isconf,live,ndit;
438 float readnoise,gain,gaincor_fac;
441 cpl_propertylist *pp;
446 if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
447 cpl_msg_error(fctid,
"Input framelist NULL or has no input data");
455 vircam_set_recipename(fctid,RECSCI);
463 p = cpl_parameterlist_find(parlist,
464 "vircam.vircam_jitter_microstep_process.ipix");
465 vircam_jmp_set_config_ipix ( cpl_parameter_get_int(p) );
466 p = cpl_parameterlist_find(parlist,
467 "vircam.vircam_jitter_microstep_process.thresh");
468 vircam_jmp_set_config_threshold ( (
float)cpl_parameter_get_double(p) );
469 p = cpl_parameterlist_find(parlist,
470 "vircam.vircam_jitter_microstep_process.icrowd");
471 vircam_jmp_set_config_icrowd ( cpl_parameter_get_bool(p) );
472 p = cpl_parameterlist_find(parlist,
473 "vircam.vircam_jitter_microstep_process.rcore");
474 vircam_jmp_set_config_rcore ( (
float)cpl_parameter_get_double(p) );
475 p = cpl_parameterlist_find(parlist,
476 "vircam.vircam_jitter_microstep_process.nbsize");
477 vircam_jmp_set_config_nbsize ( cpl_parameter_get_int(p) );
478 p = cpl_parameterlist_find(parlist,
479 "vircam.vircam_jitter_microstep_process.savecat");
480 vircam_jmp_set_config_savecat ( cpl_parameter_get_bool(p) );
481 p = cpl_parameterlist_find(parlist,
482 "vircam.vircam_jitter_microstep_process.destripe");
483 vircam_jmp_set_config_destripe ( cpl_parameter_get_bool(p) );
484 p = cpl_parameterlist_find(parlist,
485 "vircam.vircam_jitter_microstep_process.skycor");
486 vircam_jmp_set_config_skycor ( cpl_parameter_get_bool(p) );
487 p = cpl_parameterlist_find(parlist,
488 "vircam.vircam_jitter_microstep_process.savesimple");
489 vircam_jmp_set_config_savesimple ( cpl_parameter_get_bool(p) );
490 p = cpl_parameterlist_find(parlist,
491 "vircam.vircam_jitter_microstep_process.extenum");
492 vircam_jmp_set_config_extenum ( cpl_parameter_get_int(p) );
497 cpl_msg_error(fctid,
"Cannot identify RAW and CALIB frames");
506 cpl_msg_error(fctid,
"Cannot labelise the input frames");
513 if ((ps.science_frames =
515 VIRCAM_SCI_OBJECT_RAW)) == NULL) {
516 if ((ps.science_frames =
518 VIRCAM_SCI_OBJECT_EXT_RAW)) == NULL) {
519 cpl_msg_error(fctid,
"No science images to process!");
528 VIRCAM_CAL_SKY)) == NULL) {
529 if ((ps.offset_skies =
531 VIRCAM_OFFSET_SKY_RAW)) == NULL)
539 vircam_jmp_set_offsky(offsky);
543 if ((ps.master_dark =
545 VIRCAM_CAL_DARK)) == NULL) {
546 cpl_msg_error(fctid,
"No master dark found");
553 if ((ps.master_twilight_flat =
555 VIRCAM_CAL_TWILIGHT_FLAT)) == NULL) {
556 cpl_msg_error(fctid,
"No master twilight flat found");
565 &status) != CASU_OK) {
566 cpl_msg_error(fctid,
"Error calculating gain corrections");
573 if ((ps.readgain_file =
575 VIRCAM_CAL_READGAINFILE)) == NULL) {
576 cpl_msg_error(fctid,
"No master readnoise/gain file found");
586 if ((ps.master_conf =
588 VIRCAM_CAL_CONF)) == NULL) {
590 if ((ps.master_conf =
592 VIRCAM_CAL_BPM)) == NULL) {
593 cpl_msg_error(fctid,
"No master confidence map found");
604 VIRCAM_CAL_CHANTAB)) == NULL) {
605 cpl_msg_error(fctid,
"No channel table found");
613 VIRCAM_CAL_PHOTTAB)) == NULL) {
614 cpl_msg_error(fctid,
"No photometric table found");
618 if ((ps.tphottab = cpl_table_load(cpl_frame_get_filename(ps.phottab),1,0)) == NULL) {
619 cpl_msg_error(fctid,
"Unable to load photometric table");
627 VIRCAM_CAL_2MASS)) == NULL) {
628 cpl_msg_info(fctid,
"No 2MASS index found -- cannot continue");
635 if (
casu_catpars(catindex,&(ps.catpath),&(ps.catname)) == CASU_FATAL) {
637 cpl_frame_delete(catindex);
640 cpl_frame_delete(catindex);
644 (void)strcpy(current_catpath,ps.catpath);
645 (void)strcpy(current_cat,ps.catname);
649 pp = cpl_propertylist_load(cpl_frame_get_filename(cpl_frameset_get_position(ps.science_frames,0)),0);
651 cpl_msg_error(fctid,
"No value for NDIT available");
652 freepropertylist(pp);
656 cpl_propertylist_delete(pp);
663 (
const cpl_frame *)cpl_frameset_get_position(ps.science_frames,0),
665 if (jst == -1 || jfn == -1) {
666 cpl_msg_error(fctid,
"Unable to continue");
674 for (j = jst; j <= jfn; j++) {
675 vircam_jmp_set_isfirst (j == jst);
676 gaincor_fac = (ps.gaincors)[j-1];
677 cpl_msg_info(fctid,
"Beginning extension [%" CPL_SIZE_FORMAT
"]",
684 if (ps.fdark == NULL) {
686 "Error loading master dark %s[%" CPL_SIZE_FORMAT
"]\n%s",
687 cpl_frame_get_filename(ps.master_dark),(cpl_size)j,
688 cpl_error_get_message());
692 ps.fflat =
casu_fits_load(ps.master_twilight_flat,CPL_TYPE_FLOAT,j);
693 if (ps.fflat == NULL) {
695 "Error loading master flat %s[%" CPL_SIZE_FORMAT
"]\n%s",
696 cpl_frame_get_filename(ps.master_twilight_flat),
697 (cpl_size)j,cpl_error_get_message());
702 if (ps.fconf == NULL) {
704 "Error loading master conf %s[%" CPL_SIZE_FORMAT
"]\n%s",
705 cpl_frame_get_filename(ps.master_conf),(cpl_size)j,
706 cpl_error_get_message());
716 "Error loading mask from master conf %s[%" CPL_SIZE_FORMAT
"]\n%s",
717 cpl_frame_get_filename(ps.master_conf),(cpl_size)j,
718 cpl_error_get_message());
724 if (ps.fsky == NULL) {
726 "Error loading master sky %s[%" CPL_SIZE_FORMAT
"]\n%s",
727 cpl_frame_get_filename(ps.master_sky),(cpl_size)j,
728 cpl_error_get_message());
734 if (ps.fchantab == NULL) {
736 "Error loading channel table %s[%" CPL_SIZE_FORMAT
"]\n%s",
737 cpl_frame_get_filename(ps.chantab),(cpl_size)j,
738 cpl_error_get_message());
745 ps.nscience = cpl_frameset_get_size(ps.science_frames);
747 if (ps.sci_fits == NULL) {
749 "Error loading science frames extension %" CPL_SIZE_FORMAT
": %s",
750 (cpl_size)j,cpl_error_get_message());
758 freepropertylist(ps.phupaf);
764 ps.noffsets = cpl_frameset_get_size(ps.offset_skies);
767 if (ps.offsky_fits == NULL) {
769 "Error loading offset skies extension %" CPL_SIZE_FORMAT
": %s",
770 (cpl_size)j,cpl_error_get_message());
776 ps.offsky_fits = NULL;
783 for (i = 0; i < ps.nscience; i++) {
790 cpl_msg_error(fctid,
"Unable to correct CRVAL in %s",
796 for (i = 0; i < ps.noffsets; i++) {
797 ff = ps.offsky_fits[i];
810 cpl_msg_info(fctid,
"Doing stage1 corrections");
811 for (i = 0; i < ps.nscience; i++) {
816 "[e-] Readnoise used in processing");
819 "[e-/adu] Gain used in processing");
821 cpl_msg_info(fctid,
"Detector is flagged dead in %s",
833 for (i = 0; i < ps.noffsets; i++) {
834 ff = ps.offsky_fits[i];
836 cpl_msg_info(fctid,
"Detector is flagged dead in %s",
851 if (vircam_jmp_get_config_skycor()) {
852 cpl_msg_info(fctid,
"Doing sky correction");
855 for (i = 0; i < ps.nscience; i++) {
857 cpl_propertylist_update_string(pp,
"ESO DRS SKYCOR",
"none");
858 cpl_propertylist_set_comment(pp,
"ESO DRS SKYCOR",
859 "Sky correction method");
865 if (vircam_jmp_get_config_destripe()) {
866 for (i = 0; i < ps.nscience; i++) {
871 for (i = 0; i < ps.noffsets; i++) {
872 ff = ps.offsky_fits[i];
884 if (retval != CASU_OK) {
885 cpl_msg_warning(fctid,
"Unable to get nusteps from header.\nAssuming no microstepping");
895 cpl_msg_info(fctid,
"No interleaving will be done");
897 cpl_msg_warning(fctid,
"Illegal number of microsteps: %" CPL_SIZE_FORMAT
"\nNo interleaving will be done",
899 ps.dith_input = cpl_malloc(ps.nscience*
sizeof(casu_fits *));
900 ps.dithc_input = cpl_malloc(
sizeof(casu_fits *));
901 for (i = 0; i < ps.nscience; i++) {
903 ps.dith_input[ps.ndith++] = ps.sci_fits[i];
905 ps.dithc_input[0] = ps.fconf;
914 cpl_msg_info(fctid,
"Interleaving");
921 cpl_msg_info(fctid,
"Working out jitter offsets");
923 cpl_msg_info(fctid,
"Stacking jittered frame");
928 cpl_msg_info(fctid,
"Doing object extraction");
933 cpl_msg_info(fctid,
"Matching objects with 2mass standards");
938 cpl_msg_info(fctid,
"Fitting a WCS");
943 cpl_msg_info(fctid,
"Doing photometric zeropoint calculation");
948 if (vircam_jmp_get_config_savesimple()) {
949 cpl_msg_info(fctid,
"Saving simple images");
956 if (vircam_jmp_get_config_savesimple()) {
957 cpl_msg_info(fctid,
"Saving offset sky simple images");
963 cpl_msg_info(fctid,
"Saving mean offset sky image");
974 cpl_msg_info(fctid,
"Saving superframe images");
983 cpl_msg_info(fctid,
"Saving stacked image");
984 dummyqc = vircam_jitter_microstep_process_dummyqc(1);
987 freepropertylist(dummyqc);
990 freepropertylist(dummyqc);
991 if (vircam_jmp_get_config_savecat()) {
992 cpl_msg_info(fctid,
"Saving stacked image catalogue");
993 dummyqc = vircam_jitter_microstep_process_dummyqc(2);
996 freepropertylist(dummyqc);
999 freepropertylist(dummyqc);
1013 static cpl_propertylist *vircam_jitter_microstep_process_dummyqc(
int type) {
1014 cpl_propertylist *p;
1018 p = cpl_propertylist_new();
1027 cpl_propertylist_update_double(p,
"ESO QC WCS_DCRVAL1",0.0);
1028 cpl_propertylist_set_comment(p,
"ESO QC WCS_DCRVAL1",
1029 "[deg] change in crval1");
1030 cpl_propertylist_update_double(p,
"ESO QC WCS_DCRVAL2",0.0);
1031 cpl_propertylist_set_comment(p,
"ESO QC WCS_DCRVAL2",
1032 "[deg] change in crval2");
1033 cpl_propertylist_update_double(p,
"ESO QC WCS_DTHETA",0.0);
1034 cpl_propertylist_set_comment(p,
"ESO QC WCS_DTHETA",
1035 "[deg] change in rotation");
1036 cpl_propertylist_update_double(p,
"ESO QC WCS_SCALE",0.0);
1037 cpl_propertylist_set_comment(p,
"ESO QC WCS_SCALE",
1038 "[arcsec] mean plate scale");
1039 cpl_propertylist_update_double(p,
"ESO QC WCS_SHEAR",0.0);
1040 cpl_propertylist_set_comment(p,
"ESO QC WCS_SHEAR",
1041 "[deg] abs(xrot) - abs(yrot)");
1042 cpl_propertylist_update_double(p,
"ESO QC WCS_RMS",0.0);
1043 cpl_propertylist_set_comment(p,
"ESO QC WCS_RMS",
1044 "[arcsec] Average error in WCS fit");
1045 cpl_propertylist_update_float(p,
"ESO QC MAGZPT",0.0);
1046 cpl_propertylist_set_comment(p,
"ESO QC MAGZPT",
1047 "[mag] photometric zeropoint");
1048 cpl_propertylist_update_float(p,
"ESO QC MAGZERR",0.0);
1049 cpl_propertylist_set_comment(p,
"ESO QC MAGZERR",
1050 "[mag] photometric zeropoint error");
1051 cpl_propertylist_update_int(p,
"ESO QC MAGNZPT",0);
1052 cpl_propertylist_set_comment(p,
"ESO QC MAGNZPT",
1053 "number of stars in magzpt calc");
1054 cpl_propertylist_update_int(p,
"ESO QC MAGNCUT",0);
1055 cpl_propertylist_set_comment(p,
"ESO QC MAGNCUT",
1056 "number of stars cut from magzpt calc");
1057 cpl_propertylist_update_float(p,
"ESO QC LIMITING_MAG",0.0);
1058 cpl_propertylist_set_comment(p,
"ESO QC LIMITING_MAG",
1059 "[mag] 5 sigma limiting mag");
1065 cpl_propertylist_update_float(p,
"ESO QC SATURATION",0.0);
1066 cpl_propertylist_set_comment(p,
"ESO QC SATURATION",
1067 "[adu] Saturation level");
1068 cpl_propertylist_update_float(p,
"ESO QC MEAN_SKY",0.0);
1069 cpl_propertylist_set_comment(p,
"ESO QC MEAN_SKY",
1070 "[adu] Median sky brightness");
1071 cpl_propertylist_update_float(p,
"ESO QC SKY_NOISE",0.0);
1072 cpl_propertylist_set_comment(p,
"ESO QC SKY_NOISE",
1073 "[adu] Pixel noise at sky level");
1074 cpl_propertylist_update_float(p,
"ESO QC IMAGE_SIZE",0.0);
1075 cpl_propertylist_set_comment(p,
"ESO QC IMAGE_SIZE",
1076 "[pixels] Average FWHM of stellar objects")
1078 cpl_propertylist_update_float(p,
"ESO QC ELLIPTICITY",0.0);
1079 cpl_propertylist_set_comment(p,
"ESO QC ELLIPTICITY",
1080 "Average stellar ellipticity (1-b/a)");
1081 cpl_propertylist_update_float(p,
"ESO QC APERTURE_CORR",0.0);
1082 cpl_propertylist_set_comment(p,
"ESO QC APERTURE_CORR",
1083 "Stellar ap-corr 1x core flux");
1084 cpl_propertylist_update_int(p,
"ESO QC NOISE_OBJ",0);
1085 cpl_propertylist_set_comment(p,
"ESO QC NOISE_OBJ",
1086 "Number of noise objects");
int casu_fits_get_status(casu_fits *p)
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)
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)
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_flatcor(casu_fits *infile, casu_fits *flatsrc, int *status)
Correct input data for flat field response.
int casu_nditcor(casu_fits *infile, int ndit, const char *expkey, int *status)
Correct input data for number of dits.
int casu_darkcor(casu_fits *infile, casu_fits *darksrc, float darkscl, int *status)
Correct input data for dark current.
int casu_gaincor(casu_fits *infile, float gainscl, int *status)
Gain correct input data frame.
casu_tfits * casu_tfits_load(cpl_frame *table, int nexten)
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.
int casu_catpars(cpl_frame *indx, char **catpath, char **catname)
Find the name of the standard catalogue and its location.
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_gaincor_calc(cpl_frame *frame, int *n, float **cors, int *status)
Work out gain corrections.
int vircam_destripe(casu_fits *in, casu_mask *inbpm, int *status)
Remove stripes from the background of an image.
int vircam_lincor(casu_fits *infile, casu_tfits *lchantab, int kconst, int ndit, int *status)
Apply linearity curves to data.
int vircam_dfs_set_groups(cpl_frameset *set)
int vircam_jmp_save_offsky(struct psStruct *ps, cpl_frameset *framelist, cpl_parameterlist *parlist)
void vircam_jmp_dither_images(struct psStruct *ps)
void vircam_jmp_init(struct psStruct *ps)
void vircam_jmp_get_readnoise_gain(struct psStruct *ps, int jext, float *readnoise, float *gain)
void vircam_jmp_matched_stds(struct psStruct *ps, char *cata, char *catapath)
int vircam_jmp_save_super(struct psStruct *ps, cpl_frameset *framelist, cpl_parameterlist *parlist)
void vircam_jmp_bpm2conf(struct psStruct *ps)
int vircam_jmp_save_catalogue(struct psStruct *ps, cpl_frameset *framelist, cpl_parameterlist *parlist, cpl_propertylist *dummyqcprops)
void vircam_jmp_wcsfit(struct psStruct *ps)
void vircam_jmp_photcal(struct psStruct *ps)
int vircam_jmp_save_stack(struct psStruct *ps, cpl_frameset *framelist, cpl_parameterlist *parlist, cpl_propertylist *dummyqcprops)
int vircam_jmp_save_simple_offsets(struct psStruct *ps, cpl_frameset *framelist, cpl_parameterlist *parlist)
void vircam_jmp_dither_offsets(struct psStruct *ps, int inter_lv)
void vircam_jmp_tidy(struct psStruct *ps, int level)
int vircam_jmp_save_simple(struct psStruct *ps, cpl_frameset *framelist, cpl_parameterlist *parlist)
void vircam_jmp_skycor(struct psStruct *ps)
void vircam_jmp_interleave(struct psStruct *ps)
void vircam_jmp_catalogue(struct psStruct *ps, int inter_lv)
int vircam_pfits_get_ndit(const cpl_propertylist *plist, int *ndit)
Get the value of NDIT.
int vircam_pfits_get_detlive(const cpl_propertylist *plist, int *detlive)
Get the value of DET_LIVE.
int vircam_pfits_get_nusteps(const cpl_propertylist *plist, int *nusteps)
Get the value of the number of microsteps in a sequence.
int vircam_check_crval(cpl_propertylist *phu, cpl_propertylist *ehu)
const char * vircam_get_license(void)
void vircam_exten_range(int inexten, const cpl_frame *fr, int *out1, int *out2)