vircam_interleave.c

00001 /* $Id: vircam_interleave.c,v 1.20 2010/07/13 11:16:50 jim Exp $
00002  *
00003  * This file is part of the VIRCAM Pipeline
00004  * Copyright (C) 2006 Cambridge Astronomy Survey Unit
00005  *
00006  * This program is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * This program is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this program; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019  */
00020 
00021 /*
00022  * $Author: jim $
00023  * $Date: 2010/07/13 11:16:50 $
00024  * $Revision: 1.20 $
00025  * $Name: v1-1-0 $
00026  */
00027 
00028 /* Includes */
00029 
00030 #ifdef HAVE_CONFIG_H
00031 #include <config.h>
00032 #endif
00033 
00034 #include <stdio.h>
00035 #include <cpl.h>
00036 #include <math.h>
00037 
00038 #include "vircam_utils.h"
00039 #include "vircam_mask.h"
00040 #include "vircam_dfs.h"
00041 #include "vircam_mods.h"
00042 #include "vircam_stats.h"
00043 #include "vircam_fits.h"
00044 #include "vircam_wcsutils.h"
00045 
00046 /* Function prototypes */
00047 
00048 static int vircam_interleave_create(cpl_plugin *) ;
00049 static int vircam_interleave_exec(cpl_plugin *) ;
00050 static int vircam_interleave_destroy(cpl_plugin *) ;
00051 static int vircam_interleave_test(cpl_parameterlist *, cpl_frameset *) ;
00052 static int vircam_interleave_save(cpl_frameset *framelist, 
00053                                   cpl_parameterlist *parlist);
00054 static void vircam_interleave_init(void);
00055 static void vircam_interleave_tidy(void);
00056 
00057 /* Static global variables */
00058 
00059 static struct {
00060 
00061     /* Input */
00062 
00063     int         extenum;
00064 
00065 } vircam_interleave_config;
00066 
00067 
00068 static struct {
00069     int              *labels;
00070     cpl_frameset     *imagelist;
00071     vir_fits         **images;
00072     cpl_frameset     *conflist;
00073     vir_fits         **confs;
00074     int              nimages;
00075     int              nconfs;
00076     cpl_image        *outimage;
00077     cpl_image        *outconf;
00078     cpl_propertylist *plist;
00079 } ps;
00080 
00081 static int isfirst;
00082 static cpl_frame *product_frame = NULL;
00083 static cpl_frame *product_conf = NULL;
00084 
00085 static char vircam_interleave_description[] =
00086 "vircam_interleave -- VIRCAM test interleave recipe.\n\n"
00087 "Interleave a list of frames into an output frame.\n\n"
00088 "The program accepts the following files in the SOF:\n\n"
00089 "    Tag                   Description\n"
00090 "    -----------------------------------------------------------------------\n"
00091 "    %-21s A list of images\n"
00092 "    %-21s A list of confidence maps\n"
00093 "\n";
00094 
00137 /* Function code */
00138 
00139 /*---------------------------------------------------------------------------*/
00147 /*---------------------------------------------------------------------------*/
00148 
00149 int cpl_plugin_get_info(cpl_pluginlist *list) {
00150     cpl_recipe  *recipe = cpl_calloc(1,sizeof(*recipe));
00151     cpl_plugin  *plugin = &recipe->interface;
00152     char alldesc[SZ_ALLDESC];
00153     (void)snprintf(alldesc,SZ_ALLDESC,vircam_interleave_description,
00154                    VIRCAM_TEST_SCIENCE_RAW,VIRCAM_CAL_CONF);
00155 
00156     cpl_plugin_init(plugin,
00157                     CPL_PLUGIN_API,
00158                     VIRCAM_BINARY_VERSION,
00159                     CPL_PLUGIN_TYPE_RECIPE,
00160                     "vircam_interleave",
00161                     "VIRCAM interleaf test recipe [test]",
00162                     alldesc,
00163                     "Jim Lewis",
00164                     "jrl@ast.cam.ac.uk",
00165                     vircam_get_license(),
00166                     vircam_interleave_create,
00167                     vircam_interleave_exec,
00168                     vircam_interleave_destroy);
00169 
00170     cpl_pluginlist_append(list,plugin);
00171 
00172     return(0);
00173 }
00174 
00175 /*---------------------------------------------------------------------------*/
00184 /*---------------------------------------------------------------------------*/
00185 
00186 static int vircam_interleave_create(cpl_plugin *plugin) {
00187     cpl_recipe      *recipe;
00188     cpl_parameter   *p;
00189 
00190     /* Get the recipe out of the plugin */
00191 
00192     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00193         recipe = (cpl_recipe *)plugin;
00194     else 
00195         return(-1);
00196 
00197     /* Create the parameters list in the cpl_recipe object */
00198 
00199     recipe->parameters = cpl_parameterlist_new();
00200 
00201     /* Extension number of input frames to use */
00202 
00203     p = cpl_parameter_new_range("vircam.vircam_interleave.extenum",
00204                                 CPL_TYPE_INT,
00205                                 "Extension number to be done, 0 == all",
00206                                 "vircam.vircam_interleave",
00207                                 1,0,16);
00208     cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"ext");
00209     cpl_parameterlist_append(recipe->parameters,p);
00210         
00211     /* Get out of here */
00212 
00213     return(0);
00214 }
00215     
00216     
00217 /*---------------------------------------------------------------------------*/
00223 /*---------------------------------------------------------------------------*/
00224 
00225 static int vircam_interleave_exec(cpl_plugin *plugin) {
00226     cpl_recipe  *recipe;
00227 
00228     /* Get the recipe out of the plugin */
00229 
00230     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00231         recipe = (cpl_recipe *)plugin;
00232     else 
00233         return(-1);
00234 
00235     return(vircam_interleave_test(recipe->parameters,recipe->frames));
00236 }
00237                                 
00238 /*---------------------------------------------------------------------------*/
00244 /*---------------------------------------------------------------------------*/
00245 
00246 static int vircam_interleave_destroy(cpl_plugin *plugin) {
00247     cpl_recipe *recipe ;
00248 
00249     /* Get the recipe out of the plugin */
00250 
00251     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00252         recipe = (cpl_recipe *)plugin;
00253     else 
00254         return(-1);
00255 
00256     cpl_parameterlist_delete(recipe->parameters);
00257     return(0);
00258 }
00259 
00260 /*---------------------------------------------------------------------------*/
00267 /*---------------------------------------------------------------------------*/
00268 
00269 static int vircam_interleave_test(cpl_parameterlist *parlist, 
00270                                   cpl_frameset *framelist) {
00271     const char *fctid="vircam_interleave";
00272     int nlab,j,jst,jfn,retval,status,i,nstep;
00273     const int *dims;
00274     long npts;
00275     float val;
00276     double refx,refy,refra,refdec,x,y;
00277     cpl_parameter *p;
00278     cpl_image *image;
00279     const cpl_array *a;
00280     cpl_wcs *wcs;
00281     
00282 
00283     /* Check validity of input frameset */
00284 
00285     if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
00286         cpl_msg_error(fctid,"Input framelist NULL or has no input data\n");
00287         return(-1);
00288     }
00289 
00290     /* Initialise some things */
00291 
00292     vircam_interleave_init();
00293 
00294     /* Get the parameters */
00295 
00296     p = cpl_parameterlist_find(parlist,"vircam.vircam_interleave.extenum");
00297     vircam_interleave_config.extenum = cpl_parameter_get_int(p);
00298 
00299     /* Sort out raw from calib frames */
00300 
00301     if (vircam_dfs_set_groups(framelist) != VIR_OK) {
00302         cpl_msg_error(fctid,"Cannot identify RAW and CALIB frames");
00303         vircam_interleave_tidy();
00304         return(-1);
00305     }
00306 
00307     /* Get the frames frames */
00308 
00309     if ((ps.labels = cpl_frameset_labelise(framelist,vircam_compare_tags,
00310                                            &nlab)) == NULL) {
00311         cpl_msg_error(fctid,"Cannot labelise the input frames");
00312         vircam_interleave_tidy();
00313         return(-1);
00314     }
00315     if ((ps.imagelist = vircam_frameset_subgroup(framelist,ps.labels,nlab,
00316                                                 VIRCAM_TEST_SCIENCE_RAW)) == NULL) {
00317         cpl_msg_error(fctid,"Cannot get images in input frameset");
00318         vircam_interleave_tidy();
00319         return(-1);
00320     }
00321     ps.nimages = cpl_frameset_get_size(ps.imagelist);
00322     nstep = (int)sqrt((float)ps.nimages);
00323     if ((ps.conflist = vircam_frameset_subgroup(framelist,ps.labels,nlab,
00324                                                 VIRCAM_CAL_CONF)) == NULL) {
00325         cpl_msg_error(fctid,"Cannot get confidence maps in input frameset");
00326         vircam_interleave_tidy();
00327         return(-1);
00328     }
00329     ps.nconfs = cpl_frameset_get_size(ps.conflist);
00330 
00331     /* Now, how many image extensions do we want to do? If the extension
00332        number is zero, then we loop for all possible extensions. If it
00333        isn't then we just do the extension specified */
00334 
00335     vircam_exten_range(vircam_interleave_config.extenum,
00336                        (const cpl_frame *)cpl_frameset_get_frame(ps.imagelist,0),
00337                        &jst,&jfn);
00338     if (jst == -1 || jfn == -1) {
00339         cpl_msg_error(fctid,"Unable to continue");
00340         vircam_interleave_tidy();
00341         return(-1);
00342     }
00343 
00344     /* Now loop for all the extension... */
00345 
00346     status = VIR_OK;
00347     for (j = jst; j <= jfn; j++) {
00348         isfirst = (j == jst);
00349 
00350         /* Load the images */
00351 
00352         ps.images = vircam_fits_load_list(ps.imagelist,CPL_TYPE_FLOAT,j);
00353         ps.confs = vircam_fits_load_list(ps.conflist,CPL_TYPE_INT,j);
00354 
00355         /* Get some information that you need for the interleaving. Start
00356            by getting the background level add it to the extension property
00357            list */
00358 
00359         refx = 0.0;
00360         refy = 0.0;
00361         for (i = 0; i < ps.nimages; i++) {
00362             image = vircam_fits_get_image(ps.images[i]);
00363             npts = vircam_getnpts(image);
00364             val = vircam_med(cpl_image_get_data_float(image),NULL,npts);
00365             cpl_propertylist_update_float(vircam_fits_get_ehu(ps.images[i]),
00366                                           "ESO DRS BACKMED",val);
00367             wcs = cpl_wcs_new_from_propertylist(vircam_fits_get_ehu(ps.images[i]));
00368             if (i == 0) {
00369                 a = cpl_wcs_get_image_dims(wcs);
00370                 dims = cpl_array_get_data_int_const(a);
00371                 refx = 0.5*(double)dims[0];
00372                 refy = 0.5*(double)dims[1];
00373                 vircam_xytoradec(wcs,refx,refy,&refra,&refdec);
00374             }
00375             vircam_radectoxy(wcs,refra,refdec,&x,&y);
00376             x = refx - x;
00377             y = refy - y;
00378             cpl_propertylist_update_double(vircam_fits_get_ehu(ps.images[i]),
00379                                            "ESO DRS XOFFMICRO",x);
00380             cpl_propertylist_update_double(vircam_fits_get_ehu(ps.images[i]),
00381                                            "ESO DRS YOFFMICRO",y);
00382             cpl_wcs_delete(wcs);
00383         }
00384 
00385         /* Call the interleaf module */
00386 
00387         cpl_msg_info(fctid,"Doing interleaving for extension %d\n",j);
00388         (void)vircam_interleave(ps.images,ps.nimages,ps.confs,ps.nconfs,
00389                                 nstep,&(ps.plist),&(ps.outimage),&(ps.outconf),
00390                                 &status);
00391         if (status != VIR_OK) {
00392             vircam_interleave_tidy();
00393             return(-1);
00394         }
00395 
00396         /* Save everything */
00397 
00398         cpl_msg_info(fctid,"Saving combined image extension %d\n",j);
00399         retval = vircam_interleave_save(framelist,parlist);
00400         if (retval != 0) {
00401             vircam_interleave_tidy();
00402             return(-1);
00403         }
00404         freefitslist(ps.images,ps.nimages);
00405         freefitslist(ps.confs,ps.nconfs);
00406         freeimage(ps.outimage);
00407         freeimage(ps.outconf);
00408         freepropertylist(ps.plist);
00409     }
00410     vircam_interleave_tidy();
00411     return(0);
00412 }
00413 
00414 
00415 /*---------------------------------------------------------------------------*/
00423 /*---------------------------------------------------------------------------*/
00424 
00425 static int vircam_interleave_save(cpl_frameset *framelist, 
00426                                   cpl_parameterlist *parlist) {
00427     cpl_propertylist *plist;
00428     const char *recipeid = "vircam_interleave";
00429     const char *fctid = "vircam_interleave_save";
00430     const char *outfile = "comb.fits";
00431     const char *outconf = "combconf.fits";
00432 
00433     /* If we need to make a PHU then do that now based on the first frame
00434        in the input frame list */
00435 
00436     if (isfirst) {
00437 
00438         /* Create a new product frame object and define some tags */
00439 
00440         product_frame = cpl_frame_new();
00441         cpl_frame_set_filename(product_frame,outfile);
00442         cpl_frame_set_tag(product_frame,VIRCAM_PRO_INTER_TEST);
00443         cpl_frame_set_type(product_frame,CPL_FRAME_TYPE_IMAGE);
00444         cpl_frame_set_group(product_frame,CPL_FRAME_GROUP_PRODUCT);
00445         cpl_frame_set_level(product_frame,CPL_FRAME_LEVEL_FINAL);
00446 
00447         /* Set up header for phu */
00448 
00449         plist = vircam_fits_get_phu(ps.images[0]);
00450         vircam_dfs_set_product_primary_header(plist,product_frame,framelist,
00451                                               parlist,(char *)recipeid,
00452                                               "?Dictionary?",NULL,0);
00453 
00454         /* 'Save' the PHU interleaved image */                   
00455 
00456         if (cpl_image_save(NULL,outfile,CPL_BPP_8_UNSIGNED,plist,
00457                            CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
00458             cpl_msg_error(fctid,"Cannot save product PHU");
00459             cpl_frame_delete(product_frame);
00460             return(-1);
00461         }
00462         cpl_frameset_insert(framelist,product_frame);
00463 
00464         /* Create a new product frame object and define some tags */
00465 
00466         product_conf = cpl_frame_new();
00467         cpl_frame_set_filename(product_conf,outconf);
00468         cpl_frame_set_tag(product_conf,VIRCAM_PRO_CONF_TEST);
00469         cpl_frame_set_type(product_conf,CPL_FRAME_TYPE_IMAGE);
00470         cpl_frame_set_group(product_conf,CPL_FRAME_GROUP_PRODUCT);
00471         cpl_frame_set_level(product_conf,CPL_FRAME_LEVEL_FINAL);
00472 
00473         /* 'Save' the PHU confidence map image */                        
00474 
00475         if (cpl_image_save(NULL,outconf,CPL_BPP_8_UNSIGNED,plist,
00476                            CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
00477             cpl_msg_error(fctid,"Cannot save product PHU");
00478             cpl_frame_delete(product_conf);
00479             return(-1);
00480         }
00481         cpl_frameset_insert(framelist,product_conf);
00482     }
00483 
00484     /* Get the extension property list */
00485 
00486     plist = ps.plist;
00487 
00488     /* Fiddle with the header now */
00489 
00490     vircam_dfs_set_product_exten_header(plist,product_frame,framelist,
00491                                         parlist,(char *)recipeid,
00492                                         "?Dictionary?",NULL);
00493                 
00494     /* Now save the interleaved image extension */
00495 
00496     if (cpl_image_save(ps.outimage,outfile,CPL_BPP_IEEE_FLOAT,plist,
00497                        CPL_IO_EXTEND) != CPL_ERROR_NONE) {
00498         cpl_msg_error(fctid,"Cannot save interleaved image extension");
00499         return(-1);
00500     }
00501 
00502     /* And the confidence map */
00503 
00504     if (cpl_image_save(ps.outconf,outconf,CPL_BPP_16_SIGNED,plist,
00505                        CPL_IO_EXTEND) != CPL_ERROR_NONE) {
00506         cpl_msg_error(fctid,"Cannot save confidence map image extension");
00507         return(-1);
00508     }
00509 
00510     /* Get out of here */
00511 
00512     return(0);
00513 }
00514 
00515 /*---------------------------------------------------------------------------*/
00519 /*---------------------------------------------------------------------------*/
00520 
00521 static void vircam_interleave_init(void) {
00522     ps.labels = NULL;
00523     ps.imagelist = NULL;
00524     ps.images = NULL;
00525     ps.conflist = NULL;
00526     ps.confs = NULL;
00527     ps.outimage = NULL;
00528     ps.outconf = NULL;
00529     ps.plist = NULL;
00530 }
00531 
00532 /*---------------------------------------------------------------------------*/
00536 /*---------------------------------------------------------------------------*/
00537 
00538 static void vircam_interleave_tidy(void) {
00539     freespace(ps.labels);
00540     freeframeset(ps.imagelist);
00541     freefitslist(ps.images,ps.nimages);
00542     freeframeset(ps.conflist);
00543     freefitslist(ps.confs,ps.nconfs);
00544     freeimage(ps.outimage);
00545     freeimage(ps.outconf);
00546     freepropertylist(ps.plist);
00547 }
00548 
00552 /*
00553 
00554 $Log: vircam_interleave.c,v $
00555 Revision 1.20  2010/07/13 11:16:50  jim
00556 A few changes to deal with compiler whinges
00557 
00558 Revision 1.19  2010/06/30 12:42:00  jim
00559 A few fixes to stop compiler compaints
00560 
00561 Revision 1.18  2009/09/09 09:51:13  jim
00562 modified to use new saving routines so that headers are right
00563 
00564 Revision 1.17  2008/07/10 13:01:35  jim
00565 Modified to use v4.2 version of cpl_wcs
00566 
00567 Revision 1.16  2008/06/20 11:13:02  jim
00568 Fixed dodgy call to cpl_wcs_get_image_dims
00569 
00570 Revision 1.15  2008/05/06 08:40:43  jim
00571 Modified to use cpl_wcs interface
00572 
00573 Revision 1.14  2007/10/25 19:38:22  jim
00574 modified to keep lint happy
00575 
00576 Revision 1.13  2007/10/15 12:53:55  jim
00577 Modified for compatibility with cpl_4.0
00578 
00579 Revision 1.12  2007/07/09 13:22:09  jim
00580 Modified to use new version of vircam_exten_range
00581 
00582 Revision 1.11  2007/05/02 12:53:11  jim
00583 typo fixes in docs
00584 
00585 Revision 1.10  2007/04/13 12:27:39  jim
00586 Added some extra docs
00587 
00588 Revision 1.9  2007/04/04 10:36:29  jim
00589 Modified to use new dfs tags
00590 
00591 Revision 1.8  2007/03/02 12:38:33  jim
00592 Fixed small memory leak
00593 
00594 Revision 1.7  2007/03/01 12:42:59  jim
00595 Modified slightly after code checking
00596 
00597 Revision 1.6  2006/07/11 14:59:09  jim
00598 Fixed offsets
00599 
00600 Revision 1.5  2006/06/15 09:58:59  jim
00601 Minor changes to docs
00602 
00603 Revision 1.4  2006/05/15 12:55:42  jim
00604 Fixed a few typos
00605 
00606 Revision 1.3  2006/05/04 11:53:42  jim
00607 Fixed _save routine so that it's more consistent with the standard CPL
00608 way of doing things
00609 
00610 Revision 1.2  2006/04/27 14:22:05  jim
00611 Fixed docs
00612 
00613 Revision 1.1  2006/04/24 10:42:45  jim
00614 New routine
00615 
00616 
00617 */

Generated on 7 Feb 2011 for VIRCAM Pipeline by  doxygen 1.6.1