vircam_gaincor.c

00001 /* $Id: vircam_gaincor.c,v 1.8 2012/01/16 14:44:02 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: 2012/01/16 14:44:02 $
00024  * $Revision: 1.8 $
00025  * $Name: vcam-1_3_2 $
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 
00037 #include "vircam_utils.h"
00038 #include "vircam_dfs.h"
00039 #include "vircam_fits.h"
00040 #include "vircam_mods.h"
00041 
00042 /* Function prototypes */
00043 
00044 static int vircam_gaincor_create(cpl_plugin *) ;
00045 static int vircam_gaincor_exec(cpl_plugin *) ;
00046 static int vircam_gaincor_destroy(cpl_plugin *) ;
00047 static int vircam_gaincor_test(cpl_parameterlist *, cpl_frameset *) ;
00048 static int vircam_gaincor_save(cpl_frameset *framelist, 
00049                                cpl_parameterlist *parlist);
00050 static void vircam_gaincor_init(void);
00051 static void vircam_gaincor_tidy(void);
00052 
00053 static struct {
00054 
00055     /* Input */
00056 
00057     int         extenum;
00058 
00059 } vircam_gaincor_config;
00060 
00061 static struct {
00062     cpl_size    *labels;
00063     cpl_frame   *flat;
00064     cpl_frame   *img;
00065     vir_fits    *flatf;
00066     vir_fits    *imgf;
00067     float       *gaincors;
00068 } ps;
00069 
00070 static int isfirst;
00071 static cpl_frame *product_frame = NULL;
00072 
00073 static char vircam_gaincor_description[] =
00074 "vircam_gaincor -- VIRCAM gain correction test recipe.\n\n"
00075 "Gain correct an input frame using a master flat frame\n\n"
00076 "The program accepts the following files in the SOF:\n\n"
00077 "    Tag                   Description\n"
00078 "    -----------------------------------------------------------------------\n"
00079 "    %-21s A input uncorrected image\n"
00080 "    %-21s A master flat field frame\n"
00081 "\n";
00082 
00128 /* Function code */
00129 
00130 /*---------------------------------------------------------------------------*/
00138 /*---------------------------------------------------------------------------*/
00139 
00140 int cpl_plugin_get_info(cpl_pluginlist *list) {
00141     cpl_recipe  *recipe = cpl_calloc(1,sizeof(*recipe));
00142     cpl_plugin  *plugin = &recipe->interface;
00143     char alldesc[SZ_ALLDESC];
00144     (void)snprintf(alldesc,SZ_ALLDESC,vircam_gaincor_description,
00145                    VIRCAM_TEST_SCIENCE_RAW,VIRCAM_CAL_TWILIGHT_FLAT);
00146 
00147     cpl_plugin_init(plugin,
00148                     CPL_PLUGIN_API,
00149                     VIRCAM_BINARY_VERSION,
00150                     CPL_PLUGIN_TYPE_RECIPE,
00151                     "vircam_gaincor",
00152                     "VIRCAM gain correction test recipe [test]",
00153                     alldesc,
00154                     "Jim Lewis",
00155                     "jrl@ast.cam.ac.uk",
00156                     vircam_get_license(),
00157                     vircam_gaincor_create,
00158                     vircam_gaincor_exec,
00159                     vircam_gaincor_destroy);
00160 
00161     cpl_pluginlist_append(list,plugin);
00162 
00163     return(0);
00164 }
00165 
00166 /*---------------------------------------------------------------------------*/
00175 /*---------------------------------------------------------------------------*/
00176 
00177 static int vircam_gaincor_create(cpl_plugin *plugin) {
00178     cpl_recipe      *recipe;
00179     cpl_parameter   *p;
00180 
00181     /* Get the recipe out of the plugin */
00182 
00183     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00184         recipe = (cpl_recipe *)plugin;
00185     else
00186         return(-1);
00187 
00188     /* Create the parameters list in the cpl_recipe object */
00189 
00190     recipe->parameters = cpl_parameterlist_new();
00191 
00192     /* Get the extension number of input frames to use */
00193 
00194     p = cpl_parameter_new_range("vircam.vircam_gaincor.extenum",
00195                                 CPL_TYPE_INT,
00196                                 "Extension number to be done, 0 == all",
00197                                 "vircam.vircam_gaincor",1,0,16);
00198     cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"ext");
00199     cpl_parameterlist_append(recipe->parameters,p);
00200 
00201     /* Get out of here */
00202 
00203     return(0);
00204 }
00205 
00206 /*---------------------------------------------------------------------------*/
00212 /*---------------------------------------------------------------------------*/
00213 
00214 static int vircam_gaincor_exec(cpl_plugin *plugin) {
00215     cpl_recipe  *recipe;
00216 
00217     /* Get the recipe out of the plugin */
00218 
00219     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00220         recipe = (cpl_recipe *)plugin;
00221     else
00222         return(-1);
00223 
00224     return(vircam_gaincor_test(recipe->parameters,recipe->frames));
00225 }
00226 
00227 
00228 /*---------------------------------------------------------------------------*/
00234 /*---------------------------------------------------------------------------*/
00235 
00236 static int vircam_gaincor_destroy(cpl_plugin *plugin) {
00237     cpl_recipe *recipe ;
00238 
00239     /* Get the recipe out of the plugin */
00240 
00241     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00242         recipe = (cpl_recipe *)plugin;
00243     else
00244         return(-1);
00245 
00246     cpl_parameterlist_delete(recipe->parameters);
00247     return(0);
00248 }
00249 
00250 /*---------------------------------------------------------------------------*/
00257 /*---------------------------------------------------------------------------*/
00258 
00259 static int vircam_gaincor_test(cpl_parameterlist *parlist, 
00260                                cpl_frameset *framelist) {
00261     const char *fctid="vircam_gaincor";
00262     cpl_parameter *p;
00263     int jst,jfn,status,j;
00264     cpl_size nlab;
00265     float gaincor_fac;
00266 
00267     /* Check validity of input frameset */
00268 
00269     if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
00270         cpl_msg_error(fctid,"Input framelist NULL or has no input data");
00271         return(-1);
00272     }
00273 
00274     /* Initialise some things */
00275 
00276     vircam_gaincor_init();
00277 
00278     /* Get the parameters */
00279 
00280     p = cpl_parameterlist_find(parlist,"vircam.vircam_gaincor.extenum");
00281     vircam_gaincor_config.extenum = cpl_parameter_get_int(p);
00282 
00283     /* Sort out raw from calib frames */
00284 
00285     if (vircam_dfs_set_groups(framelist) != VIR_OK) {
00286         cpl_msg_error(fctid,"Cannot identify RAW and CALIB frames");
00287         vircam_gaincor_tidy();
00288         return(-1);
00289     }
00290 
00291     /* Get the frames */
00292 
00293     if ((ps.labels = cpl_frameset_labelise(framelist,vircam_compare_tags,
00294                                            &nlab)) == NULL) {
00295         cpl_msg_error(fctid,"Cannot labelise the input frames");
00296         vircam_gaincor_tidy();
00297         return(-1);
00298     }
00299     if ((ps.flat = vircam_frameset_subgroup_1(framelist,ps.labels,nlab,
00300                                               VIRCAM_CAL_TWILIGHT_FLAT)) == NULL) {
00301         cpl_msg_info(fctid,"No master flat found -- cannot continue");
00302         vircam_gaincor_tidy();
00303         return(-1);
00304     }
00305     if ((ps.img = vircam_frameset_subgroup_1(framelist,ps.labels,nlab,
00306                                              VIRCAM_TEST_SCIENCE_RAW)) == NULL) {
00307         cpl_msg_info(fctid,"No raw image found -- cannot continue");
00308         vircam_gaincor_tidy();
00309         return(-1);
00310     }
00311 
00312     /* Get the gain corrections */
00313 
00314     status = VIR_OK;
00315     if (vircam_gaincor_calc(ps.flat,&j,&(ps.gaincors),&status) != VIR_OK) {
00316         cpl_msg_error(fctid,"Error calculating gain corrections");
00317         vircam_gaincor_tidy();
00318         return(-1);
00319     }
00320 
00321     /* Now, how many image extensions do we want to do? If the extension
00322        number is zero, then we loop for all possible extensions. If it
00323        isn't then we just do the extension specified */
00324 
00325     vircam_exten_range(vircam_gaincor_config.extenum,(const cpl_frame *)ps.img,
00326                        &jst,&jfn);
00327     if (jst == -1 || jfn == -1) {
00328         cpl_msg_error(fctid,"Unable to continue");
00329         vircam_gaincor_tidy();
00330         return(-1);
00331     }
00332 
00333     /* Now loop for all the extension... */
00334 
00335     status = VIR_OK;
00336     for (j = jst; j <= jfn; j++) {
00337         isfirst = (j == jst);
00338         gaincor_fac = (ps.gaincors)[j-1];
00339 
00340         /* Load up the images */
00341 
00342         ps.imgf = vircam_fits_load(ps.img,CPL_TYPE_FLOAT,j);
00343         ps.flatf = vircam_fits_load(ps.flat,CPL_TYPE_FLOAT,j);
00344         if (ps.img == NULL || ps.flatf == NULL) {
00345             vircam_gaincor_tidy();
00346             return(-1);
00347         }
00348 
00349         /* Now do the correction */
00350 
00351         cpl_msg_info(fctid,"Doing the flat fielding for extension %" CPL_SIZE_FORMAT,
00352                      (cpl_size)j);
00353         (void)vircam_gaincor(ps.imgf,gaincor_fac,&status);
00354         if (status != VIR_OK) {
00355             vircam_gaincor_tidy();
00356             return(-1);
00357         }
00358 
00359         /* Now save the result */
00360 
00361         cpl_msg_info(fctid,"Saving results for extension %" CPL_SIZE_FORMAT,
00362                      (cpl_size)j);
00363         if (vircam_gaincor_save(framelist,parlist) != 0) {
00364             vircam_gaincor_tidy();
00365             return(-1);
00366         }
00367 
00368         /* Tidy a few things before the next image */
00369 
00370         freefits(ps.imgf);
00371         freefits(ps.flatf);
00372     }
00373     vircam_gaincor_tidy();
00374     return(0);
00375 }
00376 
00377 
00378 /*---------------------------------------------------------------------------*/
00385 /*---------------------------------------------------------------------------*/
00386 
00387 static int vircam_gaincor_save(cpl_frameset *framelist,
00388                                cpl_parameterlist *parlist) {
00389     const char *fctid = "vircam_gaincor_save";
00390     const char *outfile = "gaincor.fits";
00391     const char *recipeid = "vircam_gaincor";
00392     cpl_propertylist *plist;
00393 
00394     /* If we need to make a PHU then do that now based on the first frame
00395        in the input frame list */
00396 
00397     if (isfirst) {
00398 
00399         /* Create a new product frame object and define some tags */
00400 
00401         product_frame = cpl_frame_new();
00402         cpl_frame_set_filename(product_frame,outfile);
00403         cpl_frame_set_tag(product_frame,VIRCAM_PRO_SIMPLE_TEST);
00404         cpl_frame_set_type(product_frame,CPL_FRAME_TYPE_IMAGE);
00405         cpl_frame_set_group(product_frame,CPL_FRAME_GROUP_PRODUCT);
00406         cpl_frame_set_level(product_frame,CPL_FRAME_LEVEL_FINAL);
00407 
00408         /* Set up the product phu */
00409 
00410         plist = vircam_fits_get_phu(ps.imgf);
00411         vircam_dfs_set_product_primary_header(plist,product_frame,framelist,
00412                                               parlist,(char *)recipeid,
00413                                               "?Dictionary?",NULL,0);
00414 
00415         /* 'Save' the PHU image */
00416 
00417         if (cpl_image_save(NULL,outfile,CPL_TYPE_UCHAR,plist,
00418                            CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
00419             cpl_msg_error(fctid,"Cannot save product PHU");
00420             cpl_frame_delete(product_frame);
00421             return(-1);
00422         }
00423         cpl_frameset_insert(framelist,product_frame);
00424     }
00425 
00426     /* Get the extension property list */
00427 
00428     plist = vircam_fits_get_ehu(ps.imgf);
00429 
00430     /* Fiddle with the header now */
00431 
00432     vircam_dfs_set_product_exten_header(plist,product_frame,framelist,parlist,
00433                                         (char *)recipeid,"?Dictionary?",NULL);
00434 
00435     /* Save the image */
00436 
00437     if (cpl_image_save(vircam_fits_get_image(ps.imgf),outfile,CPL_TYPE_FLOAT,
00438                        plist,CPL_IO_EXTEND) != CPL_ERROR_NONE) {
00439         cpl_msg_error(fctid,"Cannot save product image extension");
00440         return(-1);
00441     }
00442 
00443     return(0);
00444 }
00445 
00446 
00447 /*---------------------------------------------------------------------------*/
00451 /*---------------------------------------------------------------------------*/
00452 
00453 static void vircam_gaincor_init(void) {
00454     ps.labels = NULL;
00455     ps.flat = NULL;
00456     ps.flatf = NULL;
00457     ps.img = NULL;
00458     ps.imgf = NULL;
00459     ps.gaincors = NULL;
00460 }
00461 
00462 
00463 /*---------------------------------------------------------------------------*/
00467 /*---------------------------------------------------------------------------*/
00468 
00469 static void vircam_gaincor_tidy(void) {
00470     freespace(ps.labels);
00471     freefits(ps.imgf);
00472     freefits(ps.flatf);
00473     freeframe(ps.flat);
00474     freeframe(ps.img);
00475     freespace(ps.gaincors);
00476 }
00477 
00480 /*
00481 
00482 $Log: vircam_gaincor.c,v $
00483 Revision 1.8  2012/01/16 14:44:02  jim
00484 Fixed test recipes for cpl6 compliance
00485 
00486 Revision 1.7  2012/01/15 17:40:09  jim
00487 Minor modifications to take into accout the changes in cpl API for v6
00488 
00489 Revision 1.6  2009/09/09 09:51:13  jim
00490 modified to use new saving routines so that headers are right
00491 
00492 Revision 1.5  2007/10/19 10:33:20  jim
00493 and again
00494 
00495 Revision 1.4  2007/10/19 10:31:47  jim
00496 typo in call to tidy routine
00497 
00498 Revision 1.3  2007/10/15 12:53:55  jim
00499 Modified for compatibility with cpl_4.0
00500 
00501 Revision 1.2  2007/07/09 13:22:09  jim
00502 Modified to use new version of vircam_exten_range
00503 
00504 Revision 1.1  2007/05/08 21:31:41  jim
00505 initial entry
00506 
00507 
00508 
00509 */
00510 
00511 
00512 
00513 

Generated on 5 Mar 2013 for VIRCAM Pipeline by  doxygen 1.6.1