xsh_util_ima_arith.c

Go to the documentation of this file.

/* $Id: xsh_util_ima_arith.c,v 1.12 2012-07-26 12:22:31 amodigli Exp $
 *
 * This file is part of the XSHOOTER Pipeline
 * Copyright (C) 2002,2003 European Southern Observatory
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
/*
 * $Author: amodigli $
 * $Date: 2012-07-26 12:22:31 $
 * $Revision: 1.12 $
 * $Name: not supported by cvs2svn $
 */
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
/*-----------------------------------------------------------------------------
                                Includes
 ----------------------------------------------------------------------------*/
#include <string.h>
 
/* cpl */
#include <cpl.h>
 
/* irplib */
//#include <irplib_utils.h>
 
//#include <xsh_tpl_utils.h>
//#include <xsh_pfits.h>
//#include <xsh_tpl_dfs.h>
//#include <xsh_key_names.h>
//#include <xsh_pro_types.h>
//#include <xsh_functions.h>
#include <xsh_dfs.h>
#include <xsh_data_pre.h>
#include <xsh_parameters.h>
#include <xsh_drl.h>
#include <xsh_msg.h>
#include <xsh_pfits.h>
#include <xsh_error.h>
//#include <xsh_utils_wrappers.h>
 
 
/*-----------------------------------------------------------------------------
                               Defines
 ----------------------------------------------------------------------------*/
 
#define XSH_UTL_IMA_ARITH_RECIPE_ID "xsh_util_ima_arith"
#define XSH_UTL_IMA_ARITH_RECIPE_AUTHOR "A.Modigliani"
#define XSH_UTL_IMA_ARITH_RECIPE_CONTACT "Andrea.Modigliani@eso.org"
#define PRO_IMA "PRO_IMA_UVB"
#define KEY_VALUE_HPRO_DID                 "PRO-1.15"
/*-----------------------------------------------------------------------------
                            Functions prototypes
 ----------------------------------------------------------------------------*/
 
static int xsh_util_ima_arith_create(cpl_plugin *) ;
static int xsh_util_ima_arith_exec(cpl_plugin *) ;
static int xsh_util_ima_arith_destroy(cpl_plugin *) ;
static int xsh_util_ima_arith(cpl_parameterlist *, cpl_frameset *) ;
 
/*-----------------------------------------------------------------------------
                            Static variables
 ----------------------------------------------------------------------------*/
 
static char 
xsh_util_ima_arith_description_short[] = "Computes result of ima1 op ima2";
static char xsh_util_ima_arith_description[] =
"This recipe performs image computation.\n"
"The input files are 2 images\n"
"their associated tags should be IMA.\n"
"The output is an image resulting from the IMA op IMA where op indicates\n"
"the operation to be performed specified by the parameter \n"
"xsh.xsh_util_ima_arith.op having alias 'op'\n"
"Information on relevant parameters can be found with\n"
"esorex --params xsh_util_ima_arith\n"
"esorex --help xsh_util_ima_arith\n"
"\n";
 
/*-----------------------------------------------------------------------------
                                Functions code
 ----------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int cpl_plugin_get_info(cpl_pluginlist * list)
{
    cpl_recipe  *   recipe = cpl_calloc(1, sizeof *recipe ) ;
    cpl_plugin  *   plugin = &recipe->interface ;
 
    cpl_plugin_init(plugin,
                    CPL_PLUGIN_API,
                    XSH_BINARY_VERSION,
                    CPL_PLUGIN_TYPE_RECIPE,
                    XSH_UTL_IMA_ARITH_RECIPE_ID,
                    xsh_util_ima_arith_description_short,
                    xsh_util_ima_arith_description,
                    XSH_UTL_IMA_ARITH_RECIPE_AUTHOR,
                    XSH_UTL_IMA_ARITH_RECIPE_CONTACT,
                    xsh_get_license(),
                    xsh_util_ima_arith_create,
                    xsh_util_ima_arith_exec,
                    xsh_util_ima_arith_destroy) ;
 
    cpl_pluginlist_append(list, plugin) ;
    
    return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_ima_arith_create(cpl_plugin * plugin)
{
    cpl_recipe      * recipe ;
    cpl_parameter   * p ;
 
  /* Reset library state */
  xsh_init();
 
    /* Get the recipe out of the plugin */
    if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE) 
        recipe = (cpl_recipe *)plugin ;
    else return -1 ;
    cpl_error_reset();
 
 
    /* Create the parameters list in the cpl_recipe object */
    recipe->parameters = cpl_parameterlist_new() ; 
 
 
    /* Set generic parameters (common to all recipes) */
    check( xsh_parameters_generic(XSH_UTL_IMA_ARITH_RECIPE_ID, 
                  recipe->parameters ) ) ;
    xsh_parameters_decode_bp(XSH_UTL_IMA_ARITH_RECIPE_ID,recipe->parameters,-1);
    /* Fill the parameters list */
    /* --stropt */
    p = cpl_parameter_new_value("xsh.xsh_util_ima_arith.op", 
                                CPL_TYPE_STRING, 
                                "A possible operation", 
                                "xsh.xsh_util_ima_arith","+");
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "op") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 
    /* --doubleopt */
    p = cpl_parameter_new_value("xsh.xsh_util_ima_arith.value", 
            CPL_TYPE_DOUBLE, "a value", "xsh.xsh_util_ima_arith", 9999.) ;
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "value") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 cleanup: 
 
    /* Return */
    return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_ima_arith_exec(cpl_plugin * plugin)
{
    cpl_recipe  *   recipe ;
     int code=0;
     cpl_errorstate initial_errorstate = cpl_errorstate_get();
 
    /* Get the recipe out of the plugin */
    if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE) 
        recipe = (cpl_recipe *)plugin ;
    else return -1 ;
    cpl_error_reset();
 
    code = xsh_util_ima_arith(recipe->parameters, recipe->frames) ;
 
 
    if (!cpl_errorstate_is_equal(initial_errorstate)) {                      
        /* Dump the error history since recipe execution start.                
           At this point the recipe cannot recover from the error */           
        cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);              
    } 
 
    return code ;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_ima_arith_destroy(cpl_plugin * plugin)
{
    cpl_recipe  *   recipe ;
    
    /* Get the recipe out of the plugin */
    if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE) 
        recipe = (cpl_recipe *)plugin ;
    else return -1 ;
 
    cpl_parameterlist_delete(recipe->parameters) ; 
    return 0 ;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int 
xsh_util_ima_arith( cpl_parameterlist   *   parlist, 
        cpl_frameset        *   framelist)
{
    const char* recipe_tags[1] = { XSH_RAW_IMA_SLIT_UVB};
    int recipe_tags_size = 1;
    cpl_parameter       *   param= NULL ;
    const char          *   operation=NULL;
    double                     value=1 ;
    cpl_image           *   ima1=NULL ;
    cpl_image           *   ima2=NULL ;
    int switch_ima2     = 0;
    const char                *   name_o=NULL ;
    cpl_propertylist    *   plist=NULL ;
    cpl_image           *   image=NULL ;
    cpl_frame           *   product_frame=NULL;
    cpl_frameset * raw_set=NULL;
    int nraw=0;
    int n=0;
    xsh_instrument* instrument=NULL;
    cpl_frameset* raws=NULL;
    cpl_frameset* calib=NULL;
    xsh_pre* pre = NULL;
    int pre_overscan_corr=0;
    xsh_msg("Welcome to XSHOOTER Pipeline release %d.%d.%d",
        XSH_MAJOR_VERSION,XSH_MINOR_VERSION,XSH_MICRO_VERSION);
 
    /* HOW TO RETRIEVE INPUT PARAMETERS */
    /* --stropt */
    check(param=cpl_parameterlist_find(parlist, 
                                             "xsh.xsh_util_ima_arith.op"));
    check(operation=cpl_parameter_get_string(param));
 
    /* --boolopt */
    check(param=cpl_parameterlist_find(parlist,
                                             "xsh.xsh_util_ima_arith.value"));
    check(value = cpl_parameter_get_double(param)) ;
  
 
  /**************************************************************************/
  /* DFS management */
  /**************************************************************************/
   
  check( xsh_begin( framelist, parlist, &instrument, &raws, &calib,
                    recipe_tags, recipe_tags_size,
                    XSH_UTL_IMA_ARITH_RECIPE_ID, 
                    XSH_UTL_IMA_ARITH, XSH_BINARY_VERSION,
                    xsh_util_ima_arith_description_short ) ) ;
 
   
    /* Identify the RAW and CALIB frames in the input frameset */
    check_msg(xsh_dfs_set_groups(framelist),
         "Cannot identify RAW and CALIB frames") ;
 
    /* HOW TO ACCESS INPUT DATA */
    n=cpl_frameset_get_size(framelist);
    if(n<1) {
      xsh_msg_error("Empty input frame list!");
      goto cleanup ;
    }
 
    /* HOW TO ACCESS INPUT DATA */
    check_msg(raw_set=xsh_frameset_extract(framelist,XSH_RAW_IMA_SLIT_UVB),
          "Found no input frames with tag %s",XSH_RAW_IMA_SLIT_UVB);
    check(nraw=cpl_frameset_get_size(raw_set));
    if (nraw<1) {
      xsh_msg_error("Found no input frames with tag %s",XSH_RAW_IMA_SLIT_UVB);
      goto cleanup;
    } else {
      check(xsh_prepare(raw_set,NULL, NULL,"RAW_IMA", instrument,pre_overscan_corr,CPL_TRUE));
         check(ima1=cpl_image_load("RAW_IMA_PRE_0.fits",CPL_TYPE_FLOAT,0,0));
     if (nraw>1) {
         check(ima2 = cpl_image_load("RAW_IMA_PRE_1.fits",CPL_TYPE_FLOAT,0,0));
         switch_ima2=1;
      } else if (value == 9999.) {
        xsh_msg_error("Found only one input frames with tag %s",
              XSH_RAW_IMA_SLIT_UVB);
        goto cleanup; 
      } else {
        xsh_msg("Perform image arithmetics on frame %s",
        XSH_RAW_IMA_SLIT_UVB);
      }
    }
 
    xsh_free_frameset(&raw_set);
 
    /* HOW TO GET THE VALUE OF A FITS KEYWORD */
    check_msg(plist=cpl_propertylist_load("RAW_IMA_PRE_0.fits",0),
          "Cannot read the FITS header") ;
 
    /* Now performing the data reduction */
    /* Let's generate one image for the example */
    if (value == 9999.) {
 
      if(ima1 != NULL && ima2 != NULL) {
    xsh_msg("ima1 %s ima2",operation);
    if (strcmp(operation,"+") == 0 ) {
          check_msg(image = cpl_image_add_create(ima1, ima2),
                "Cannot generate the %s image",operation) ;
    } else if (strcmp(operation,"-") == 0 ) {
          check_msg(image = cpl_image_subtract_create(ima1, ima2),               
        "Cannot generate the %s image",operation) ;
    } else if (strcmp(operation,"*") == 0 ) {
          check_msg(image = cpl_image_multiply_create(ima1, ima2),
        "Cannot generate the %s image",operation) ;
    } else if (strcmp(operation,"/") == 0 ) {
      check_msg(image = cpl_image_divide_create(ima1, ima2),
        "Cannot generate the %s image",operation) ;
    } else {
          xsh_msg_error("Operation %s not supported",operation);
          goto cleanup;
    }
      xsh_free_image(&ima1);
      xsh_free_image(&ima2);
 
      }
    
    } else {
      xsh_msg("ima1 %s %f",operation,value);
       
      if(switch_ima2 == 1) {
      xsh_free_image(&ima2);
      }
       
      if (strcmp(operation,"+") == 0 ) {
    check_msg(image = cpl_image_add_scalar_create(ima1, value),
          "Cannot apply the %s operator",operation) ;
      } else if (strcmp(operation,"-") == 0 ) {
    check_msg(image = cpl_image_subtract_scalar_create(ima1, value),
          "Cannot apply the %s operator",operation) ;
      } else if (strcmp(operation,"*") == 0 ) {
    check_msg(image = cpl_image_multiply_scalar_create(ima1, value),
          "Cannot apply the %s operator",operation) ;
      } else if (strcmp(operation,"/") == 0 ) {
    check_msg(image = cpl_image_divide_scalar_create(ima1, value),
          "Cannot apply the %s operator",operation) ;
      } else {
    xsh_msg_error("Operation %s not supported",operation);
    goto cleanup;
      }
    
      xsh_free_image(&ima1);
 
    }
 
 
    /* HOW TO SAVE A PRODUCT ON DISK  */
    /* Set the file name */
    name_o = "ima_res.fits" ;
 
    /* Create product frame */
    check(product_frame = cpl_frame_new());
    check(cpl_frame_set_filename(product_frame, name_o)) ;
    check(cpl_frame_set_tag(product_frame, PRO_IMA)) ;
    check(cpl_frame_set_type(product_frame, CPL_FRAME_TYPE_IMAGE)) ;
    check(cpl_frame_set_group(product_frame, CPL_FRAME_GROUP_PRODUCT)) ;
    check_msg(cpl_frame_set_level(product_frame, CPL_FRAME_LEVEL_FINAL),
      "Error while initialising the product frame") ;
    
    /* Add DataFlow keywords */
    check(cpl_propertylist_erase_regexp(plist, "^ESO PRO CATG",0));
    check_msg(cpl_dfs_setup_product_header(plist, 
                                       product_frame, 
                                       framelist, 
                                       parlist,
                                       "xsh_util_ima_arith", 
                                       "XSHOOTER", 
                                           KEY_VALUE_HPRO_DID,NULL),
      "Problem in the product DFS-compliance") ;
 
    check_msg(cpl_image_save(image, 
                         name_o, 
                         CPL_BPP_IEEE_FLOAT, 
                         plist,
                         CPL_IO_DEFAULT),
      "Could not save product");
    xsh_free_propertylist(&plist) ;
    check(plist=cpl_propertylist_new());
    check( xsh_pfits_set_extname(plist, "ERRS"));
 
    cpl_image_power(image,0.5);
    check_msg(cpl_image_save(image, 
                         name_o, 
                         CPL_BPP_IEEE_FLOAT, 
                         plist,
                         CPL_IO_EXTEND),
      "Could not save product");
    xsh_free_propertylist(&plist) ;
    check(plist=cpl_propertylist_new());
    check( xsh_pfits_set_extname(plist, "QUAL"));
 
 
    cpl_image_divide(image,image);
    check_msg(cpl_image_save(image, 
                         name_o, 
                         CPL_BPP_IEEE_FLOAT, 
                         plist,
                         CPL_IO_EXTEND),
      "Could not save product");
 
 
 
 
    //check(pre=xsh_pre_load(product_frame,instrument));
 
    /* Save the file */
    //check_msg(xsh_pre_save(pre,name_o,0),"Could not save product");
 
    xsh_pre_free(&pre);
 
    xsh_free_propertylist(&plist) ;
    xsh_free_image(&image);
 
    /* Log the saved file in the input frameset */
    check(cpl_frameset_insert(framelist, product_frame)) ;
 
 
 cleanup:
   
    xsh_pre_free(&pre);
    xsh_free_image(&ima1);
    xsh_free_image(&ima2);
    xsh_free_frameset(&raw_set);
    xsh_free_propertylist(&plist) ;
    /* This is usually freed by esorex: but what about if errors occurs?
    xsh_free_frame(&product_frame) ;
    */
    xsh_free_image(&image) ;
 
    if (cpl_error_get_code()) {
        return -1 ;
    } else {
        return 0 ;
    }
 
}