41 #include <casu_utils.h>
42 #include <casu_mods.h>
43 #include <casu_mask.h>
45 #include <casu_filt.h>
46 #include <casu_wcsutils.h>
47 #include <casu_stats.h>
49 #include "vircam_utils.h"
50 #include "vircam_pfits.h"
51 #include "vircam_dfs.h"
52 #include "vircam_mods.h"
53 #include "vircam_paf.h"
54 #include "vircam_sky.h"
75 } vircam_sci_postproc_config;
77 static char vircam_recipename[VIRCAM_PATHSZ];
78 static char vircam_recipepaf[VIRCAM_PATHSZ];
95 casu_fits *outmosconf;
96 casu_tfits *outmoscat;
101 static int vircam_science_postprocess_create(cpl_plugin *plugin);
102 static int vircam_science_postprocess_exec(cpl_plugin *plugin);
103 static int vircam_science_postprocess_destroy(cpl_plugin *plugin);
104 static int vircam_science_postprocess(cpl_parameterlist *parlist,
105 cpl_frameset *framelist);
108 static int vircam_sci_postproc_save_image(casu_fits *outim,
109 cpl_frameset *framelist,
110 cpl_parameterlist *parlist,
111 cpl_frame *
template,
int isim);
112 static int vircam_sci_postproc_save_cat(casu_tfits *outcat,
113 cpl_frameset *framelist,
114 cpl_parameterlist *parlist,
115 cpl_frame *
template);
116 static void vircam_sci_postproc_init(
void);
117 static int vircam_sci_testfrm_1(cpl_frame *fr,
int nextn_expected,
int isimg);
118 static void vircam_sci_product_name(
const char *
template,
int producttype,
119 int nametype,
int fnumber,
char *outfname);
120 static void vircam_sci_postproc_tidy(
void);
122 static char vircam_science_postprocess_description[] =
123 "vircam_science_postprocess -- VIRCAM science postprocess recipe.\n\n"
124 "Mosaic a list of vircam stacks and generate a catalogue. Optionally nebulise\n"
125 "before generating the catalogue.\n"
126 "The program accepts the following files in the SOF:\n\n"
128 " -----------------------------------------------------------------------\n"
129 " %-22s A list of science jittered stacks images\n"
130 " %-22s A list of science jittered stack confidence maps\n"
131 " %-22s A list of science jittered stack catalogues\n"
132 " %-22s Northern Schlegel Map\n"
133 " %-22s Southern Schlegel Map\n"
134 " %-22s A master 2MASS index\n"
135 " %-22s A photometric calibration table\n"
136 "All of the above are required\n"
281 int cpl_plugin_get_info(cpl_pluginlist *list) {
282 cpl_recipe *recipe = cpl_calloc(1,
sizeof(*recipe));
283 cpl_plugin *plugin = &recipe->interface;
284 char alldesc[SZ_ALLDESC];
285 (void)snprintf(alldesc,SZ_ALLDESC,
286 vircam_science_postprocess_description,
287 VIRCAM_PRO_JITTERED_SCI,VIRCAM_PRO_CONF_SCI,
288 VIRCAM_PRO_OBJCAT_SCI,VIRCAM_CAL_SCHL_N,
289 VIRCAM_CAL_SCHL_S,VIRCAM_CAL_2MASS,VIRCAM_CAL_PHOTTAB);
291 cpl_plugin_init(plugin,
293 VIRCAM_BINARY_VERSION,
294 CPL_PLUGIN_TYPE_RECIPE,
295 "vircam_science_postprocess",
296 "VIRCAM science postprocessing recipe",
301 vircam_science_postprocess_create,
302 vircam_science_postprocess_exec,
303 vircam_science_postprocess_destroy);
305 cpl_pluginlist_append(list,plugin);
321 static int vircam_science_postprocess_create(cpl_plugin *plugin) {
327 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
328 recipe = (cpl_recipe *)plugin;
334 recipe->parameters = cpl_parameterlist_new();
338 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.nebulise",
340 "Nebulise the stacks before object detection?",
341 "vircam.vircam_science_postprocess",FALSE);
342 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"nebulise");
343 cpl_parameterlist_append(recipe->parameters,p);
347 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.grout",
349 "Grout the output tile catalogue?",
350 "vircam.vircam_science_postprocess",TRUE);
351 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"grout");
352 cpl_parameterlist_append(recipe->parameters,p);
356 p = cpl_parameter_new_range(
"vircam.vircam_science_postprocess.minphotom",
358 "Minimum number of stars for photometry solution",
359 "vircam.vircam_science_postprocess",20,1,
361 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"minphotom");
362 cpl_parameterlist_append(recipe->parameters,p);
366 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.prettynames",
369 "vircam.vircam_science_postprocess",FALSE);
370 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"prettynames");
371 cpl_parameterlist_append(recipe->parameters,p);
375 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.cdssearch",
376 CPL_TYPE_BOOL,
"Use CDS for 2MASS standards?",
377 "vircam.vircam_science_postprocess",FALSE);
378 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cdssearch");
379 cpl_parameterlist_append(recipe->parameters,p);
383 p = cpl_parameter_new_range(
"vircam.vircam_science_postprocess.neb_medfilt",
385 "Median filter size for nebuliser",
386 "vircam.vircam_science_postprocess",101,11,
388 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"neb_medfilt");
389 cpl_parameterlist_append(recipe->parameters,p);
393 p = cpl_parameter_new_range(
"vircam.vircam_science_postprocess.neb_linfilt",
395 "Linear filter size for nebuliser",
396 "vircam.vircam_science_postprocess",33,3,2047);
397 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"neb_linfilt");
398 cpl_parameterlist_append(recipe->parameters,p);
402 p = cpl_parameter_new_range(
"vircam.vircam_science_postprocess.cat_ipix",
404 "Minimum pixel area for each detected object",
405 "vircam.vircam_science_postprocess",4,1,100000);
406 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cat_ipix");
407 cpl_parameterlist_append(recipe->parameters,p);
411 p = cpl_parameter_new_range(
"vircam.vircam_science_postprocess.cat_thresh",
413 "Detection threshold in sigma above sky",
414 "vircam.vircam_science_postprocess",1.25,
416 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cat_thresh");
417 cpl_parameterlist_append(recipe->parameters,p);
421 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.cat_icrowd",
422 CPL_TYPE_BOOL,
"Use deblending?",
423 "vircam.vircam_science_postprocess",TRUE);
424 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cat_icrowd");
425 cpl_parameterlist_append(recipe->parameters,p);
429 p = cpl_parameter_new_range(
"vircam.vircam_science_postprocess.cat_rcore",
430 CPL_TYPE_DOUBLE,
"Value of Rcore in pixels",
431 "vircam.vircam_science_postprocess",3.0,1.0e-6,
433 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cat_rcore");
434 cpl_parameterlist_append(recipe->parameters,p);
438 p = cpl_parameter_new_range(
"vircam.vircam_science_postprocess.cat_nbsize",
439 CPL_TYPE_INT,
"Background smoothing box size",
440 "vircam.vircam_science_postprocess",64,1,2048);
441 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cat_nbsize");
442 cpl_parameterlist_append(recipe->parameters,p);
446 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.cacheloc",
448 "Location for standard star cache",
449 "vircam.vircam_science_postprocess",
".");
450 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cacheloc");
451 cpl_parameterlist_append(recipe->parameters,p);
455 p = cpl_parameter_new_value(
"vircam.vircam_science_postprocess.magerrcut",
457 "Magnitude error cut",
458 "vircam.vircam_science_postprocess",100.0);
459 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"magerrcut");
460 cpl_parameterlist_append(recipe->parameters,p);
475 static int vircam_science_postprocess_exec(cpl_plugin *plugin) {
480 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
481 recipe = (cpl_recipe *)plugin;
485 return(vircam_science_postprocess(recipe->parameters,recipe->frames));
496 static int vircam_science_postprocess_destroy(cpl_plugin *plugin) {
501 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
502 recipe = (cpl_recipe *)plugin;
506 cpl_parameterlist_delete(recipe->parameters);
519 static int vircam_science_postprocess(cpl_parameterlist *parlist,
520 cpl_frameset *framelist) {
521 const char *fctid=
"vircam_scienc_postprocess";
523 int nfail,status,n,i,j;
525 cpl_frameset *tmpframeset;
526 cpl_frame *frm,*frmc,*newfrm;
527 char tmpfilename[VIRCAM_PATHSZ],filt[16];
528 casu_fits *inf,*infc,*tmpoutmos,*tmpoutmosconf,*backmap;
529 casu_tfits *outmoscatg,*matchstds;
530 cpl_table *stdscat,*tab;
535 if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
536 cpl_msg_error(fctid,
"Input framelist NULL or has no input data");
542 vircam_sci_postproc_init();
543 (void)strncpy(vircam_recipename,fctid,VIRCAM_PATHSZ);
544 (void)snprintf(vircam_recipepaf,VIRCAM_PATHSZ,
"VIRCAM/%s",fctid);
548 p = cpl_parameterlist_find(parlist,
549 "vircam.vircam_science_postprocess.nebulise");
550 vircam_sci_postproc_config.nebulise = cpl_parameter_get_bool(p);
551 p = cpl_parameterlist_find(parlist,
552 "vircam.vircam_science_postprocess.grout");
553 vircam_sci_postproc_config.grout = cpl_parameter_get_bool(p);
554 p = cpl_parameterlist_find(parlist,
555 "vircam.vircam_science_postprocess.minphotom");
556 vircam_sci_postproc_config.minphotom = cpl_parameter_get_int(p);
557 p = cpl_parameterlist_find(parlist,
558 "vircam.vircam_science_postprocess.prettynames");
559 vircam_sci_postproc_config.prettynames = cpl_parameter_get_bool(p);
560 p = cpl_parameterlist_find(parlist,
561 "vircam.vircam_science_postprocess.cdssearch");
562 vircam_sci_postproc_config.cdssearch = (cpl_parameter_get_bool(p) ? 1 : 0);
563 p = cpl_parameterlist_find(parlist,
564 "vircam.vircam_science_postprocess.neb_medfilt");
565 vircam_sci_postproc_config.neb_medfilt = cpl_parameter_get_int(p);
566 p = cpl_parameterlist_find(parlist,
567 "vircam.vircam_science_postprocess.neb_linfilt");
568 vircam_sci_postproc_config.neb_linfilt = cpl_parameter_get_int(p);
570 p = cpl_parameterlist_find(parlist,
571 "vircam.vircam_science_postprocess.cat_ipix");
572 vircam_sci_postproc_config.cat_ipix = cpl_parameter_get_int(p);
573 p = cpl_parameterlist_find(parlist,
574 "vircam.vircam_science_postprocess.cat_thresh");
575 vircam_sci_postproc_config.cat_thresh = (float)cpl_parameter_get_double(p);
576 p = cpl_parameterlist_find(parlist,
577 "vircam.vircam_science_postprocess.cat_icrowd");
578 vircam_sci_postproc_config.cat_icrowd = cpl_parameter_get_bool(p);
579 p = cpl_parameterlist_find(parlist,
580 "vircam.vircam_science_postprocess.cat_rcore");
581 vircam_sci_postproc_config.cat_rcore = (float)cpl_parameter_get_double(p);
582 p = cpl_parameterlist_find(parlist,
583 "vircam.vircam_science_postprocess.cat_nbsize");
584 vircam_sci_postproc_config.cat_nbsize = cpl_parameter_get_int(p);
588 p = cpl_parameterlist_find(parlist,
589 "vircam.vircam_science_postprocess.cacheloc");
590 vircam_sci_postproc_config.cacheloc = (
char *)cpl_parameter_get_string(p);
594 p = cpl_parameterlist_find(parlist,
595 "vircam.vircam_science_postprocess.magerrcut");
596 vircam_sci_postproc_config.magerrcut = (float)cpl_parameter_get_double(p);
601 cpl_msg_error(fctid,
"Cannot identify RAW and CALIB frames");
602 vircam_sci_postproc_tidy();
610 cpl_msg_error(fctid,
"Cannot labelise the input frames");
611 vircam_sci_postproc_tidy();
619 VIRCAM_PRO_JITTERED_SCI)) == NULL) {
620 cpl_msg_error(fctid,
"No science images to process!");
621 vircam_sci_postproc_tidy();
626 VIRCAM_PRO_CONF_SCI)) == NULL) {
627 cpl_msg_error(fctid,
"No science confidence maps to process!");
628 vircam_sci_postproc_tidy();
633 VIRCAM_PRO_OBJCAT_SCI)) == NULL) {
634 cpl_msg_error(fctid,
"No science object catalogues to process!");
635 vircam_sci_postproc_tidy();
643 VIRCAM_CAL_PHOTTAB)) == NULL) {
644 cpl_msg_error(fctid,
"No photometric table found");
645 vircam_sci_postproc_tidy();
648 n = cpl_frame_get_nextensions(ps.phottab);
649 nfail += vircam_sci_testfrm_1(ps.phottab,n,0);
654 if (vircam_sci_postproc_config.cdssearch == 0) {
656 VIRCAM_CAL_2MASS)) == NULL) {
657 cpl_msg_error(fctid,
"No 2MASS index found -- cannot continue");
658 vircam_sci_postproc_tidy();
661 nfail += vircam_sci_testfrm_1(ps.catindex,1,0);
667 VIRCAM_CAL_SCHL_N)) == NULL) {
668 cpl_msg_error(fctid,
"Schlegel North map not found -- cannot continue");
669 vircam_sci_postproc_tidy();
672 nfail += vircam_sci_testfrm_1(ps.schlf_n,0,1);
677 VIRCAM_CAL_SCHL_S)) == NULL) {
678 cpl_msg_error(fctid,
"Schlegel South map not found -- cannot continue");
679 vircam_sci_postproc_tidy();
682 nfail += vircam_sci_testfrm_1(ps.schlf_s,0,1);
686 if (access(vircam_sci_postproc_config.cacheloc,R_OK+W_OK+X_OK) != 0) {
687 cpl_msg_error(fctid,
"Cache location %s inacessible",
688 vircam_sci_postproc_config.cacheloc);
698 "There are %" CPL_SIZE_FORMAT
" input file errors -- cannot continue",
700 vircam_sci_postproc_tidy();
706 if (ps.catindex != NULL) {
707 if (
casu_catpars(ps.catindex,&(ps.catpath),&(ps.catname)) == CASU_FATAL) {
708 vircam_sci_postproc_tidy();
711 freeframe(ps.catindex);
718 if (vircam_sci_postproc_config.nebulise) {
719 tmpframeset = cpl_frameset_new();
720 n = (int)cpl_frameset_get_size(ps.paws);
721 cpl_msg_info(fctid,
"Nebulising pawprints");
722 cpl_msg_indent_more();
723 for (i = 0; i < n; i++) {
724 cpl_msg_info(fctid,
"Doing pawprint %" CPL_SIZE_FORMAT
"",
726 frm = cpl_frameset_get_position(ps.paws,(cpl_size)i);
727 frmc = cpl_frameset_get_position(ps.confs,(cpl_size)i);
728 (void)sprintf(tmpfilename,
"tmp_%s",basename((
char *)cpl_frame_get_filename(frm)));
729 newfrm = cpl_frame_new();
730 cpl_frame_set_tag(newfrm,VIRCAM_SCI_OBJECT_RAW);
731 cpl_frame_set_filename(newfrm,tmpfilename);
732 cpl_frameset_insert(tmpframeset,newfrm);
733 for (j = 1; j <= VIRCAM_NEXTN; j++) {
737 (void)
casu_nebuliser(inf,infc,101,33,3,1,0,0,0,0,10.0,3.0,
739 if (status != CASU_OK) {
740 vircam_sci_postproc_tidy();
743 freeframeset(tmpframeset);
747 if (access(tmpfilename,F_OK))
749 cpl_image_save(NULL,tmpfilename,CPL_TYPE_UCHAR,
759 cpl_msg_indent_less();
763 cpl_msg_info(fctid,
"Tiling nebulised pawprints");
765 25,&tmpoutmos,&tmpoutmosconf,&status);
766 if (status != CASU_OK) {
767 vircam_sci_postproc_tidy();
768 freeframeset(tmpframeset);
770 freefits(tmpoutmosconf);
776 for (i = 0; i < n; i++) {
777 frm = cpl_frameset_get_position(tmpframeset,i);
778 remove(cpl_frame_get_filename(frm));
780 freeframeset(tmpframeset);
784 cpl_msg_info(fctid,
"Creating catalogue from nebulised mosaic");
787 vircam_sci_postproc_config.cat_ipix,
788 vircam_sci_postproc_config.cat_thresh,
789 vircam_sci_postproc_config.cat_icrowd,
790 vircam_sci_postproc_config.cat_rcore,
791 vircam_sci_postproc_config.cat_nbsize,6,
792 2.0,&(ps.outmoscat),gain,&status);
793 if (status != CASU_OK) {
794 vircam_sci_postproc_tidy();
795 freeframeset(tmpframeset);
797 freefits(tmpoutmosconf);
804 freefits(tmpoutmosconf);
808 cpl_msg_info(fctid,
"Creating the real mosaic");
809 (void)
vircam_mosaic(ps.paws,ps.confs,1,2,0.0,
"EXPTIME",25,&(ps.outmos),
810 &(ps.outmosconf),&status);
811 if (status != CASU_OK) {
812 vircam_sci_postproc_tidy();
823 cpl_msg_info(fctid,
"Creating the real mosaic");
824 (void)
vircam_mosaic(ps.paws,ps.confs,1,2,0.0,
"EXPTIME",25,&(ps.outmos),
825 &(ps.outmosconf),&status);
826 if (status != CASU_OK) {
827 vircam_sci_postproc_tidy();
833 cpl_msg_info(fctid,
"Creating catalogue from mosaic");
836 vircam_sci_postproc_config.cat_ipix,
837 vircam_sci_postproc_config.cat_thresh,
838 vircam_sci_postproc_config.cat_icrowd,
839 vircam_sci_postproc_config.cat_rcore,
840 vircam_sci_postproc_config.cat_nbsize,6,
841 2.0,&(ps.outmoscat),gain,&status);
847 cpl_msg_info(fctid,
"Doing WCS on mosaic");
849 ps.catpath,ps.catname,
850 vircam_sci_postproc_config.cdssearch,
851 vircam_sci_postproc_config.cacheloc,&stdscat,&status);
857 if (status != CASU_OK) {
860 vircam_sci_postproc_tidy();
867 if (vircam_sci_postproc_config.grout) {
868 n = (int)cpl_frameset_get_size(ps.paws);
871 "Only %" CPL_SIZE_FORMAT
" paws. No grout possible",
874 cpl_msg_info(fctid,
"Grouting catalogue");
875 (void)
vircam_grout(ps.outmoscat,ps.cats,ps.confs,&outmoscatg,
877 freetfits(ps.outmoscat);
878 ps.outmoscat = outmoscatg;
884 cpl_msg_info(fctid,
"Doing photometry on mosaic");
888 ps.tphottab = cpl_table_load(cpl_frame_get_filename(ps.phottab),1,0);
893 vircam_sci_postproc_config.minphotom,
894 ps.schlf_n,ps.schlf_s,
"EXPTIME",
"ESO TEL AIRM START",
895 vircam_sci_postproc_config.magerrcut,&status);
896 cpl_table_save(tab,NULL,NULL,
"mstds.fits",CPL_IO_DEFAULT);
897 if (status != CASU_OK) {
898 freetfits(matchstds);
899 vircam_sci_postproc_tidy();
902 freetfits(matchstds);
906 cpl_msg_info(fctid,
"Saving mosaic, confidence map and catalogue");
907 (void)vircam_sci_postproc_save_image(ps.outmos,framelist,parlist,
908 cpl_frameset_get_position(ps.paws,0),
910 (void)vircam_sci_postproc_save_image(ps.outmosconf,framelist,parlist,
911 cpl_frameset_get_position(ps.paws,0),
913 (void)vircam_sci_postproc_save_cat(ps.outmoscat,framelist,parlist,
914 cpl_frameset_get_position(ps.paws,0));
918 vircam_sci_postproc_tidy();
949 static int vircam_sci_postproc_save_image(casu_fits *outim,
950 cpl_frameset *framelist,
951 cpl_parameterlist *parlist,
952 cpl_frame *
template,
int isim) {
953 char fname[VIRCAM_PATHSZ];
954 cpl_frame *product_frame;
955 cpl_propertylist *plist,*plist2;
958 const char *fctid=
"vircam_sci_postproc_save_image";
962 ptype = (isim ? 0 : 1);
963 vircam_sci_product_name(cpl_frame_get_filename(
template),ptype,
964 vircam_sci_postproc_config.prettynames,1,fname);
968 if (access(fname,F_OK))
970 product_frame = cpl_frame_new();
971 cpl_frame_set_filename(product_frame,fname);
973 cpl_frame_set_tag(product_frame,VIRCAM_PRO_MOSAIC);
975 cpl_frame_set_tag(product_frame,VIRCAM_PRO_MOSAIC_CONF);
976 cpl_frame_set_type(product_frame,CPL_FRAME_TYPE_IMAGE);
977 cpl_frame_set_group(product_frame,CPL_FRAME_GROUP_PRODUCT);
978 cpl_frame_set_level(product_frame,CPL_FRAME_LEVEL_FINAL);
985 freepropertylist(plist2);
987 vircam_recipename,
"PRO-1.15",
993 type = CPL_TYPE_FLOAT;
997 plist,CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
998 cpl_msg_error(fctid,
"Cannot save product image extension -- %s",
999 cpl_error_get_message());
1002 cpl_frameset_insert(framelist,product_frame);
1003 freepropertylist(plist);
1032 static int vircam_sci_postproc_save_cat(casu_tfits *outcat,
1033 cpl_frameset *framelist,
1034 cpl_parameterlist *parlist,
1035 cpl_frame *
template) {
1036 char fname[VIRCAM_PATHSZ];
1037 cpl_frame *product_frame;
1038 cpl_propertylist *plist;
1039 const char *fctid =
"vircam_sci_postproc_save_cat";
1043 vircam_sci_product_name(cpl_frame_get_filename(
template),2,
1044 vircam_sci_postproc_config.prettynames,1,fname);
1048 if (access(fname,F_OK))
1050 product_frame = cpl_frame_new();
1051 cpl_frame_set_filename(product_frame,fname);
1052 cpl_frame_set_tag(product_frame,VIRCAM_PRO_OBJCAT_SCI);
1053 cpl_frame_set_type(product_frame,CPL_FRAME_TYPE_TABLE);
1054 cpl_frame_set_group(product_frame,CPL_FRAME_GROUP_PRODUCT);
1055 cpl_frame_set_level(product_frame,CPL_FRAME_LEVEL_FINAL);
1061 vircam_recipename,
"PRO-1.15",NULL,0);
1065 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,plist,
1066 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
1067 cpl_msg_error(fctid,
"Cannot save product PHU");
1068 cpl_frame_delete(product_frame);
1071 cpl_frameset_insert(framelist,product_frame);
1077 parlist,vircam_recipename,
1078 "PRO-1.15",
template);
1080 CPL_IO_EXTEND) != CPL_ERROR_NONE) {
1081 cpl_msg_error(fctid,
"Cannot save product table extension -- %s",
1082 cpl_error_get_message());
1112 static int vircam_sci_testfrm_1(cpl_frame *fr,
int nextn_expected,
int isimg) {
1116 const char *fctid=
"vircam_sci_testfrm";
1126 nextn = cpl_frame_get_nextensions(fr);
1127 if (nextn != nextn_expected) {
1128 cpl_msg_error(fctid,
"Frame %s has %" CPL_SIZE_FORMAT
" extensions, expected %" CPL_SIZE_FORMAT
"\n",
1129 cpl_frame_get_filename(fr),(cpl_size)nextn,
1130 (cpl_size)nextn_expected);
1137 for (j = 1; j <= nextn; j++) {
1141 cpl_msg_error(fctid,
1142 "Frame image %s[%" CPL_SIZE_FORMAT
"] won't load\n",
1143 cpl_frame_get_filename(fr),(cpl_size)j);
1150 if (testt == NULL) {
1151 cpl_msg_error(fctid,
1152 "Frame table %s[%" CPL_SIZE_FORMAT
"] won't load\n",
1153 cpl_frame_get_filename(fr),(cpl_size)j);
1194 static void vircam_sci_product_name(
const char *
template,
int producttype,
1195 int nametype,
int fnumber,
char *outfname) {
1196 const char *esonames[] = {
"tile_",
"tile_conf_",
"tile_cat_"};
1197 const char *suffix[] = {
"_tl",
"_tl_conf",
"_tl_cat"};
1198 char *fname,*bname,*dot;
1205 (void)sprintf(outfname,
"%s%d.fits",esonames[producttype],fnumber);
1212 fname = cpl_strdup(
template);
1213 bname = basename(fname);
1214 (void)sprintf(outfname,
"tmp_%s",bname);
1221 fname = cpl_strdup(
template);
1222 bname = basename(fname);
1223 (void)sprintf(outfname,
"%s",bname);
1224 dot = strrchr(outfname,
'.');
1225 (void)sprintf(dot,
"%s.fits",suffix[producttype]);
1232 (void)strcpy(outfname,
"");
1257 static void vircam_sci_postproc_init(
void) {
1270 ps.outmosconf = NULL;
1271 ps.outmoscat = NULL;
1291 static void vircam_sci_postproc_tidy(
void) {
1292 freespace(ps.labels);
1293 freeframeset(ps.paws);
1294 freeframeset(ps.confs);
1295 freeframeset(ps.cats);
1296 freeframe(ps.phottab);
1297 freetable(ps.tphottab);
1298 freeframe(ps.catindex);
1299 freespace(ps.catpath);
1300 freespace(ps.catname);
1301 freeframe(ps.schlf_n);
1302 freeframe(ps.schlf_s);
1303 freefits(ps.outmos);
1304 freefits(ps.outmosconf);
1305 freetfits(ps.outmoscat);
cpl_image * casu_fits_get_image(casu_fits *p)
casu_fits * casu_fits_load(cpl_frame *frame, cpl_type type, int nexten)
cpl_propertylist * casu_fits_get_phu(casu_fits *p)
cpl_propertylist * casu_fits_get_ehu(casu_fits *p)
int casu_imcore(casu_fits *infile, casu_fits *conf, int ipix, float threshold, int icrowd, float rcore, int nbsize, int cattype, float filtfwhm, casu_tfits **outtab, float gainloc, int *status)
Generate object catalogues from input images.
int casu_nebuliser(casu_fits *infile, casu_fits *inconf, int medfilt, int linfilt, int niter, int axis, int twod, int takeout_sky, int norm, int wantback, float signeg, float sigpos, casu_fits **backmap, int *status)
Remove small scale background variations.
int casu_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 casu_photcal_extinct(casu_fits **images, casu_tfits **mstds, casu_tfits **cats, int nimages, char *filt, cpl_table *phottab, int minstars, cpl_frame *schlf_n, cpl_frame *schlf_s, const char *expkey, const char *amkey, float magerrcut, int *status)
Do photometric calibration.
int casu_platesol(cpl_propertylist *plist, cpl_propertylist *tlist, cpl_table *matchedstds, int nconst, int shiftan, int *status)
Work out a WCS for an image.
int casu_getstds(cpl_propertylist *plist, int cache, char *path, char *catname, int cdssearch, char *cacheloc, cpl_table **stds, int *status)
Get a table of standard stars that appear on an image from a catalogue.
cpl_table * casu_tfits_get_table(casu_tfits *p)
cpl_propertylist * casu_tfits_get_phu(casu_tfits *p)
cpl_propertylist * casu_tfits_get_ehu(casu_tfits *p)
casu_tfits * casu_tfits_load(cpl_frame *table, int nexten)
casu_tfits * casu_tfits_wrap(cpl_table *tab, casu_tfits *model, cpl_propertylist *phu, cpl_propertylist *ehu)
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.
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 vircam_mosaic(cpl_frameset *infiles, cpl_frameset *inconf, int interp, int skyflag, float skywish_in, const char *expkey, int conflim, casu_fits **out, casu_fits **outc, int *status)
Create a vircam mosaic.
int vircam_grout(casu_tfits *intab, cpl_frameset *input_cats, cpl_frameset *input_confs, casu_tfits **outtab, int *status)
Correct input tile catalogues.
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_gain(const cpl_propertylist *plist, float *gain)
Get the value of the detector gain.
int vircam_pfits_get_filter(const cpl_propertylist *plist, char *filt)
Get the name of the current filter.
const char * vircam_get_license(void)