41 #include "vircam_utils.h"
42 #include "vircam_mask.h"
43 #include "vircam_pfits.h"
44 #include "vircam_dfs.h"
45 #include "vircam_mods.h"
46 #include "vircam_fits.h"
47 #include "vircam_tfits.h"
48 #include "vircam_paf.h"
49 #include "vircam_sky.h"
50 #include "vircam_filt.h"
51 #include "vircam_stats.h"
52 #include "vircam_wcsutils.h"
54 #define VIRCAM_PATHSZ 128
55 #define VIRCAM_NEXTN 16
72 } vircam_sci_postproc_config;
74 static char vircam_recipename[VIRCAM_PATHSZ];
75 static char vircam_recipepaf[VIRCAM_PATHSZ];
96 static char vircam_science_postprocess_description[] =
97 "vircam_science_postprocess -- VIRCAM science postprocess recipe.\n\n"
98 "Mosaic a list of vircam stacks and generate a catalogue. Optionally nebulise\n"
99 "before generating the catalogue.\n"
100 "The program accepts the following files in the SOF:\n\n"
102 " -----------------------------------------------------------------------\n"
103 " %-22s A list of science jittered stacks images\n"
104 " %-22s A list of science jittered stack confidence maps\n"
105 " %-22s A list of science jittered stack catalogues\n"
106 " %-22s Northern Schlegel Map\n"
107 " %-22s Southern Schlegel Map\n"
108 " %-22s A master 2MASS index\n"
109 " %-22s A photometric calibration table\n"
110 "All of the above are required\n"
115 static int vircam_science_postprocess_create(cpl_plugin *plugin);
116 static int vircam_science_postprocess_exec(cpl_plugin *plugin);
117 static int vircam_science_postprocess_destroy(cpl_plugin *plugin);
118 static int vircam_science_postprocess(cpl_parameterlist *parlist,
119 cpl_frameset *framelist);
122 static int vircam_sci_postproc_save_image(vir_fits *outim,
123 cpl_frameset *framelist,
124 cpl_parameterlist *parlist,
125 cpl_frame *
template,
int isim);
126 static int vircam_sci_postproc_save_cat(vir_tfits *outcat,
127 cpl_frameset *framelist,
128 cpl_parameterlist *parlist,
129 cpl_frame *
template);
130 static void vircam_sci_postproc_init(
void);
131 static int vircam_sci_testfrm_1(cpl_frame *fr,
int nextn_expected,
int isimg);
132 static void vircam_sci_product_name(
const char *
template,
int producttype,
133 int nametype,
int fnumber,
char *outfname);
134 static void vircam_sci_postproc_tidy(
void);
146 int cpl_plugin_get_info(cpl_pluginlist *list) {
147 cpl_recipe *recipe = cpl_calloc(1,
sizeof(*recipe));
148 cpl_plugin *plugin = &recipe->interface;
149 char alldesc[SZ_ALLDESC];
150 (void)snprintf(alldesc,SZ_ALLDESC,
151 vircam_science_postprocess_description,
152 VIRCAM_PRO_JITTERED_SCI,VIRCAM_PRO_CONF_SCI,
153 VIRCAM_PRO_OBJCAT_SCI,VIRCAM_CAL_SCHL_N,
154 VIRCAM_CAL_SCHL_S,VIRCAM_CAL_2MASS,VIRCAM_CAL_PHOTTAB);
156 cpl_plugin_init(plugin,
158 VIRCAM_BINARY_VERSION,
159 CPL_PLUGIN_TYPE_RECIPE,
160 "vircam_science_postprocess",
161 "VIRCAM science postprocessing recipe",
166 vircam_science_postprocess_create,
167 vircam_science_postprocess_exec,
168 vircam_science_postprocess_destroy);
170 cpl_pluginlist_append(list,plugin);
186 static int vircam_science_postprocess_create(cpl_plugin *plugin) {
192 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
193 recipe = (cpl_recipe *)plugin;
199 recipe->parameters = cpl_parameterlist_new();
203 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.nebulise",
205 "Nebulise the stacks before object detection?",
206 "vircam.vircam_science_postprocess",TRUE);
207 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"nebulise");
208 cpl_parameterlist_append(recipe->parameters,p);
212 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.grout",
214 "Grout the output tile catalogue?",
215 "vircam.vircam_science_postprocess",TRUE);
216 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"grout");
217 cpl_parameterlist_append(recipe->parameters,p);
221 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.minphotom",
223 "Minimum number of stars for photometry solution",
224 "vircam.vircam_science_postprocess",20);
225 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"minphotom");
226 cpl_parameterlist_append(recipe->parameters,p);
230 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.prettynames",
233 "vircam.vircam_science_postprocess",0);
234 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"prettynames");
235 cpl_parameterlist_append(recipe->parameters,p);
239 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.neb_medfilt",
241 "Median filter size for nebuliser",
242 "vircam.vircam_science_postprocess",101);
243 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"neb_medfilt");
244 cpl_parameterlist_append(recipe->parameters,p);
248 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.neb_linfilt",
250 "Median filter size for nebuliser",
251 "vircam.vircam_science_postprocess",33);
252 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"neb_linfilt");
253 cpl_parameterlist_append(recipe->parameters,p);
257 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.cat_ipix",
259 "Minimum pixel area for each detected object",
260 "vircam.vircam_science_postprocess",4);
261 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cat_ipix");
262 cpl_parameterlist_append(recipe->parameters,p);
266 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.cat_thresh",
268 "Detection threshold in sigma above sky",
269 "vircam.vircam_science_postprocess",1.25);
270 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cat_thresh");
271 cpl_parameterlist_append(recipe->parameters,p);
275 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.cat_icrowd",
276 CPL_TYPE_BOOL,
"Use deblending?",
277 "vircam.vircam_science_postprocess",1);
278 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cat_icrowd");
279 cpl_parameterlist_append(recipe->parameters,p);
283 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.cat_rcore",
284 CPL_TYPE_DOUBLE,
"Value of Rcore in pixels",
285 "vircam.vircam_science_postprocess",3.0);
286 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_rcore");
287 cpl_parameterlist_append(recipe->parameters,p);
291 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.cat_nbsize",
292 CPL_TYPE_INT,
"Background smoothing box size",
293 "vircam.vircam_science_postprocess",64);
294 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cat_nbsize");
295 cpl_parameterlist_append(recipe->parameters,p);
310 static int vircam_science_postprocess_exec(cpl_plugin *plugin) {
315 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
316 recipe = (cpl_recipe *)plugin;
320 return(vircam_science_postprocess(recipe->parameters,recipe->frames));
331 static int vircam_science_postprocess_destroy(cpl_plugin *plugin) {
336 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
337 recipe = (cpl_recipe *)plugin;
341 cpl_parameterlist_delete(recipe->parameters);
345 static int vircam_science_postprocess(cpl_parameterlist *parlist,
346 cpl_frameset *framelist) {
347 const char *fctid=
"vircam_scienc_postprocess";
349 int nfail,status,n,i,j;
351 cpl_frameset *tmpframeset;
352 cpl_frame *frm,*frmc,*newfrm;
353 char tmpfilename[VIRCAM_PATHSZ],filt[16];
354 vir_fits *inf,*infc,*tmpoutmos,*tmpoutmosconf,*backmap;
355 vir_tfits *outmoscatg;
356 cpl_table *stdscat,*matchstds;
360 if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
361 cpl_msg_error(fctid,
"Input framelist NULL or has no input data");
367 vircam_sci_postproc_init();
368 (void)strncpy(vircam_recipename,fctid,VIRCAM_PATHSZ);
369 (void)snprintf(vircam_recipepaf,VIRCAM_PATHSZ,
"VIRCAM/%s",fctid);
373 p = cpl_parameterlist_find(parlist,
374 "vircam.vircam_science_postprocess.nebulise");
375 vircam_sci_postproc_config.nebulise = cpl_parameter_get_bool(p);
376 p = cpl_parameterlist_find(parlist,
377 "vircam.vircam_science_postprocess.grout");
378 vircam_sci_postproc_config.grout = cpl_parameter_get_bool(p);
379 p = cpl_parameterlist_find(parlist,
380 "vircam.vircam_science_postprocess.minphotom");
381 vircam_sci_postproc_config.minphotom = cpl_parameter_get_int(p);
382 p = cpl_parameterlist_find(parlist,
383 "vircam.vircam_science_postprocess.prettynames");
384 vircam_sci_postproc_config.prettynames = cpl_parameter_get_bool(p);
385 p = cpl_parameterlist_find(parlist,
386 "vircam.vircam_science_postprocess.neb_medfilt");
387 vircam_sci_postproc_config.neb_medfilt = cpl_parameter_get_int(p);
388 p = cpl_parameterlist_find(parlist,
389 "vircam.vircam_science_postprocess.neb_linfilt");
390 vircam_sci_postproc_config.neb_linfilt = cpl_parameter_get_int(p);
392 p = cpl_parameterlist_find(parlist,
393 "vircam.vircam_science_postprocess.cat_ipix");
394 vircam_sci_postproc_config.cat_ipix = cpl_parameter_get_int(p);
395 p = cpl_parameterlist_find(parlist,
396 "vircam.vircam_science_postprocess.cat_thresh");
397 vircam_sci_postproc_config.cat_thresh = (float)cpl_parameter_get_double(p);
398 p = cpl_parameterlist_find(parlist,
399 "vircam.vircam_science_postprocess.cat_icrowd");
400 vircam_sci_postproc_config.cat_icrowd = cpl_parameter_get_bool(p);
401 p = cpl_parameterlist_find(parlist,
402 "vircam.vircam_science_postprocess.cat_rcore");
403 vircam_sci_postproc_config.cat_rcore = (float)cpl_parameter_get_double(p);
404 p = cpl_parameterlist_find(parlist,
405 "vircam.vircam_science_postprocess.cat_nbsize");
406 vircam_sci_postproc_config.cat_nbsize = cpl_parameter_get_int(p);
411 cpl_msg_error(fctid,
"Cannot identify RAW and CALIB frames");
412 vircam_sci_postproc_tidy();
420 cpl_msg_error(fctid,
"Cannot labelise the input frames");
421 vircam_sci_postproc_tidy();
429 VIRCAM_PRO_JITTERED_SCI)) == NULL) {
430 cpl_msg_error(fctid,
"No science images to process!");
431 vircam_sci_postproc_tidy();
436 VIRCAM_PRO_CONF_SCI)) == NULL) {
437 cpl_msg_error(fctid,
"No science confidence maps to process!");
438 vircam_sci_postproc_tidy();
443 VIRCAM_PRO_OBJCAT_SCI)) == NULL) {
444 cpl_msg_error(fctid,
"No science object catalogues to process!");
445 vircam_sci_postproc_tidy();
453 VIRCAM_CAL_PHOTTAB)) == NULL) {
454 cpl_msg_error(fctid,
"No photometric table found");
455 vircam_sci_postproc_tidy();
458 nfail += vircam_sci_testfrm_1(ps.phottab,1,0);
464 VIRCAM_CAL_2MASS)) == NULL) {
465 cpl_msg_error(fctid,
"No 2MASS index found -- cannot continue");
466 vircam_sci_postproc_tidy();
469 nfail += vircam_sci_testfrm_1(ps.catindex,1,0);
474 VIRCAM_CAL_SCHL_N)) == NULL) {
475 cpl_msg_error(fctid,
"Schlegel North map not found -- cannot continue");
476 vircam_sci_postproc_tidy();
479 nfail += vircam_sci_testfrm_1(ps.schlf_n,0,1);
484 VIRCAM_CAL_SCHL_S)) == NULL) {
485 cpl_msg_error(fctid,
"Schlegel South map not found -- cannot continue");
486 vircam_sci_postproc_tidy();
489 nfail += vircam_sci_testfrm_1(ps.schlf_s,0,1);
497 "There are %" CPL_SIZE_FORMAT
" input file errors -- cannot continue",
499 vircam_sci_postproc_tidy();
505 if (
vircam_catpars(ps.catindex,&(ps.catpath),&(ps.catname)) == VIR_FATAL) {
506 vircam_sci_postproc_tidy();
509 freeframe(ps.catindex);
515 if (vircam_sci_postproc_config.nebulise) {
516 tmpframeset = cpl_frameset_new();
517 n = (int)cpl_frameset_get_size(ps.paws);
518 cpl_msg_info(fctid,
"Nebulising pawprints");
519 cpl_msg_indent_more();
520 for (i = 0; i < n; i++) {
521 cpl_msg_info(fctid,
"Doing pawprint %" CPL_SIZE_FORMAT
"",
523 frm = cpl_frameset_get_frame(ps.paws,(cpl_size)i);
524 frmc = cpl_frameset_get_frame(ps.confs,(cpl_size)i);
525 (void)sprintf(tmpfilename,
"tmp_%s",cpl_frame_get_filename(frm));
526 newfrm = cpl_frame_new();
527 cpl_frame_set_tag(newfrm,VIRCAM_SCI_OBJECT_RAW);
528 cpl_frame_set_filename(newfrm,tmpfilename);
529 cpl_frameset_insert(tmpframeset,newfrm);
530 for (j = 1; j <= VIRCAM_NEXTN; j++) {
534 (void)
vircam_nebuliser(inf,infc,101,33,3,1,0,0,0,0,10.0,3.0,
536 if (status != VIR_OK) {
537 vircam_sci_postproc_tidy();
540 freeframeset(tmpframeset);
544 if (access(tmpfilename,F_OK))
546 cpl_image_save(NULL,tmpfilename,CPL_TYPE_UCHAR,
556 cpl_msg_indent_less();
560 cpl_msg_info(fctid,
"Tiling nebulised pawprints");
561 (void)vircam_mosaic(tmpframeset,ps.confs,1,2,0.0,
"EXPTIME",
562 25,&tmpoutmos,&tmpoutmosconf,&status);
563 if (status != VIR_OK) {
564 vircam_sci_postproc_tidy();
565 freeframeset(tmpframeset);
567 freefits(tmpoutmosconf);
573 for (i = 0; i < n; i++) {
574 frm = cpl_frameset_get_frame(tmpframeset,i);
575 remove(cpl_frame_get_filename(frm));
577 freeframeset(tmpframeset);
581 cpl_msg_info(fctid,
"Creating catalogue from nebulised mosaic");
583 vircam_sci_postproc_config.cat_ipix,
584 vircam_sci_postproc_config.cat_thresh,
585 vircam_sci_postproc_config.cat_icrowd,
586 vircam_sci_postproc_config.cat_rcore,
587 vircam_sci_postproc_config.cat_nbsize,6,
588 2.0,&(ps.outmoscat),&status);
589 if (status != VIR_OK) {
590 vircam_sci_postproc_tidy();
591 freeframeset(tmpframeset);
593 freefits(tmpoutmosconf);
600 freefits(tmpoutmosconf);
604 cpl_msg_info(fctid,
"Creating the real mosaic");
605 (void)vircam_mosaic(ps.paws,ps.confs,1,2,0.0,
"EXPTIME",25,&(ps.outmos),
606 &(ps.outmosconf),&status);
607 if (status != VIR_OK) {
608 vircam_sci_postproc_tidy();
619 cpl_msg_info(fctid,
"Creating the real mosaic");
620 (void)vircam_mosaic(ps.paws,ps.confs,1,2,0.0,
"EXPTIME",25,&(ps.outmos),
621 &(ps.outmosconf),&status);
622 if (status != VIR_OK) {
623 vircam_sci_postproc_tidy();
629 cpl_msg_info(fctid,
"Creating catalogue from mosaic");
631 vircam_sci_postproc_config.cat_ipix,
632 vircam_sci_postproc_config.cat_thresh,
633 vircam_sci_postproc_config.cat_icrowd,
634 vircam_sci_postproc_config.cat_rcore,
635 vircam_sci_postproc_config.cat_nbsize,6,
636 2.0,&(ps.outmoscat),&status);
642 cpl_msg_info(fctid,
"Doing WCS on mosaic");
644 ps.catpath,ps.catname,&stdscat,&status);
650 if (status != VIR_OK) {
652 freetable(matchstds);
653 vircam_sci_postproc_tidy();
660 cpl_msg_info(fctid,
"Doing photometry on mosaic");
661 ps.tphottab = cpl_table_load(cpl_frame_get_filename(ps.phottab),1,0);
663 vircam_photcal_extinct(&(ps.outmos),&matchstds,&(ps.outmoscat),1,
665 vircam_sci_postproc_config.minphotom,
666 ps.schlf_n,ps.schlf_s,&status);
667 if (status != VIR_OK) {
668 freetable(matchstds);
669 vircam_sci_postproc_tidy();
672 freetable(matchstds);
676 if (vircam_sci_postproc_config.grout) {
677 cpl_msg_info(fctid,
"Grouting catalogue");
678 (void)
vircam_grout(ps.outmoscat,ps.cats,ps.confs,&outmoscatg,&status);
679 freetfits(ps.outmoscat);
680 ps.outmoscat = outmoscatg;
685 cpl_msg_info(fctid,
"Saving mosaic, confidence map and catalogue");
686 (void)vircam_sci_postproc_save_image(ps.outmos,framelist,parlist,
687 cpl_frameset_get_frame(ps.paws,0),
689 (void)vircam_sci_postproc_save_image(ps.outmosconf,framelist,parlist,
690 cpl_frameset_get_frame(ps.paws,0),
692 (void)vircam_sci_postproc_save_cat(ps.outmoscat,framelist,parlist,
693 cpl_frameset_get_frame(ps.paws,0));
697 vircam_sci_postproc_tidy();
701 static int vircam_sci_postproc_save_image(vir_fits *outim,
702 cpl_frameset *framelist,
703 cpl_parameterlist *parlist,
704 cpl_frame *
template,
int isim) {
705 char fname[VIRCAM_PATHSZ];
706 cpl_frame *product_frame;
707 cpl_propertylist *plist;
710 const char *fctid=
"vircam_sci_postproc_save_image";
714 ptype = (isim ? 0 : 1);
715 vircam_sci_product_name(cpl_frame_get_filename(
template),ptype,
716 vircam_sci_postproc_config.prettynames,1,fname);
720 if (access(fname,F_OK))
722 product_frame = cpl_frame_new();
723 cpl_frame_set_filename(product_frame,fname);
725 cpl_frame_set_tag(product_frame,VIRCAM_PRO_MOSAIC);
727 cpl_frame_set_tag(product_frame,VIRCAM_PRO_MOSAIC_CONF);
728 cpl_frame_set_type(product_frame,CPL_FRAME_TYPE_IMAGE);
729 cpl_frame_set_group(product_frame,CPL_FRAME_GROUP_PRODUCT);
730 cpl_frame_set_level(product_frame,CPL_FRAME_LEVEL_FINAL);
736 vircam_recipename,
"PRO-1.15",
741 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,plist,
742 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
743 cpl_msg_error(fctid,
"Cannot save product PHU");
744 cpl_frame_delete(product_frame);
747 cpl_frameset_insert(framelist,product_frame);
753 parlist,vircam_recipename,
754 "PRO-1.15",
template);
756 type = CPL_TYPE_FLOAT;
760 plist,CPL_IO_EXTEND) != CPL_ERROR_NONE) {
761 cpl_msg_error(fctid,
"Cannot save product image extension -- %s",
762 cpl_error_get_message());
768 static int vircam_sci_postproc_save_cat(vir_tfits *outcat,
769 cpl_frameset *framelist,
770 cpl_parameterlist *parlist,
771 cpl_frame *
template) {
772 char fname[VIRCAM_PATHSZ];
773 cpl_frame *product_frame;
774 cpl_propertylist *plist;
775 const char *fctid =
"vircam_sci_postproc_save_cat";
779 vircam_sci_product_name(cpl_frame_get_filename(
template),2,
780 vircam_sci_postproc_config.prettynames,1,fname);
784 if (access(fname,F_OK))
786 product_frame = cpl_frame_new();
787 cpl_frame_set_filename(product_frame,fname);
788 cpl_frame_set_tag(product_frame,VIRCAM_PRO_OBJCAT_SCI);
789 cpl_frame_set_type(product_frame,CPL_FRAME_TYPE_TABLE);
790 cpl_frame_set_group(product_frame,CPL_FRAME_GROUP_PRODUCT);
791 cpl_frame_set_level(product_frame,CPL_FRAME_LEVEL_FINAL);
797 vircam_recipename,
"PRO-1.15",NULL,0);
801 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,plist,
802 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
803 cpl_msg_error(fctid,
"Cannot save product PHU");
804 cpl_frame_delete(product_frame);
807 cpl_frameset_insert(framelist,product_frame);
813 parlist,vircam_recipename,
814 "PRO-1.15",
template);
816 CPL_IO_EXTEND) != CPL_ERROR_NONE) {
817 cpl_msg_error(fctid,
"Cannot save product table extension -- %s",
818 cpl_error_get_message());
824 static void vircam_sci_postproc_init(
void) {
837 ps.outmosconf = NULL;
841 static int vircam_sci_testfrm_1(cpl_frame *fr,
int nextn_expected,
int isimg) {
845 const char *fctid=
"vircam_sci_testfrm";
855 nextn = cpl_frame_get_nextensions(fr);
856 if (nextn != nextn_expected) {
857 cpl_msg_error(fctid,
"Frame %s has %" CPL_SIZE_FORMAT
" extensions, expected %" CPL_SIZE_FORMAT
"\n",
858 cpl_frame_get_filename(fr),(cpl_size)nextn,
859 (cpl_size)nextn_expected);
866 for (j = 1; j <= nextn; j++) {
871 "Frame image %s[%" CPL_SIZE_FORMAT
"] won't load\n",
872 cpl_frame_get_filename(fr),(cpl_size)j);
881 "Frame table %s[%" CPL_SIZE_FORMAT
"] won't load\n",
882 cpl_frame_get_filename(fr),(cpl_size)j);
923 static void vircam_sci_product_name(
const char *
template,
int producttype,
924 int nametype,
int fnumber,
char *outfname) {
925 const char *esonames[] = {
"tile_",
"tile_conf_",
"tile_cat"};
926 const char *suffix[] = {
"_tl",
"_tl_conf",
"_tl_cat"};
927 char *fname,*bname,*dot;
934 (void)sprintf(outfname,
"%s%d.fits",esonames[producttype],fnumber);
941 fname = cpl_strdup(
template);
942 bname = basename(fname);
943 (void)sprintf(outfname,
"tmp_%s",bname);
950 fname = cpl_strdup(
template);
951 bname = basename(fname);
952 (void)sprintf(outfname,
"%s",bname);
953 dot = strrchr(outfname,
'.');
954 (void)sprintf(dot,
"%s.fits",suffix[producttype]);
961 (void)strcpy(outfname,
"");
967 static void vircam_sci_postproc_tidy(
void) {
968 freespace(ps.labels);
969 freeframeset(ps.paws);
970 freeframeset(ps.confs);
971 freeframeset(ps.cats);
972 freeframe(ps.phottab);
973 freetable(ps.tphottab);
974 freeframe(ps.catindex);
975 freespace(ps.catpath);
976 freespace(ps.catname);
977 freeframe(ps.schlf_n);
978 freeframe(ps.schlf_s);
980 freefits(ps.outmosconf);
981 freetfits(ps.outmoscat);
const char * vircam_get_license(void)
cpl_table * vircam_tfits_get_table(vir_tfits *p)
int vircam_compare_tags(const cpl_frame *frame1, const cpl_frame *frame2)
int vircam_pfits_get_filter(const cpl_propertylist *plist, char *filt)
Get the name of the current filter.
cpl_frame * vircam_frameset_subgroup_1(cpl_frameset *frameset, cpl_size *labels, cpl_size nlab, const char *tag)
int vircam_grout(vir_tfits *intab, cpl_frameset *input_cats, cpl_frameset *input_confs, vir_tfits **outtab, int *status)
Correct input tile catalogues.
int vircam_nebuliser(vir_fits *infile, vir_fits *inconf, int medfilt, int linfilt, int niter, int axis, int twod, int takeout_sky, int norm, int wantback, float signeg, float sigpos, vir_fits **backmap, int *status)
Remove small scale background variations.
cpl_propertylist * vircam_tfits_get_ehu(vir_tfits *p)
cpl_image * vircam_fits_get_image(vir_fits *p)
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_catpars(cpl_frame *indx, char **catpath, char **catname)
cpl_propertylist * vircam_fits_get_phu(vir_fits *p)
int vircam_platesol(cpl_propertylist *plist, cpl_propertylist *tlist, cpl_table *matchedstds, int nconst, int shiftan, int *status)
Work out a WCS for an image.
vir_fits * vircam_fits_load(cpl_frame *frame, cpl_type type, int nexten)
vir_tfits * vircam_tfits_load(cpl_frame *table, int nexten)
cpl_propertylist * vircam_fits_get_ehu(vir_fits *p)
cpl_propertylist * vircam_tfits_get_phu(vir_tfits *p)
int vircam_getstds(cpl_propertylist *plist, int cache, char *path, char *catname, cpl_table **stds, int *status)
Get a table of standard stars that appear on an image from a catalogue.
int vircam_imcore(vir_fits *infile, vir_fits *conf, int ipix, float threshold, int icrowd, float rcore, int nbsize, int cattyp, float filtfwhm, vir_tfits **outtab, int *status)
Generate object catalogues from input images.
int vircam_matchstds(cpl_table *objtab, cpl_table *stdstab, float srad, cpl_table **outtab, int *status)
Match object and standard star tables by their xy coordinates.
int vircam_dfs_set_groups(cpl_frameset *set)