xsh_util_ima_rebin.c

Go to the documentation of this file.

/* $Id: xsh_util_ima_rebin.c,v 1.15 2012-04-26 14:03:50 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-04-26 14:03:50 $
 * $Revision: 1.15 $
 * $Name: not supported by cvs2svn $
 */
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
/*-----------------------------------------------------------------------------
                                Includes
 ----------------------------------------------------------------------------*/
#include <string.h>
 
/* cpl */
#include <cpl.h>
 
#include <xsh_dfs.h>
#include <xsh_data_pre.h>
#include <xsh_utils.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_rebin"
#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_rebin_create(cpl_plugin *) ;
static int xsh_util_ima_rebin_exec(cpl_plugin *) ;
static int xsh_util_ima_rebin_destroy(cpl_plugin *) ;
static int xsh_util_ima_rebin(cpl_parameterlist *, cpl_frameset *) ;
 
/*-----------------------------------------------------------------------------
                            Static variables
 ----------------------------------------------------------------------------*/
 
static char 
xsh_util_ima_rebin_description_short[] = "Rebin images";
static char xsh_util_ima_rebin_description[] =
"This recipe performs image rebinning (no flux conservation).\n"
"The input files should be list in an input file (no need to specify a tag)\n"
"The output are resampled images with filenames\n"
"binX_binY_filename.fits, \n"
"where X and Y are the input binx/y parameters values\n"
"Information on relevant parameters can be found with\n"
"esorex --params xsh_util_ima_rebin\n"
"esorex --help xsh_util_ima_rebin\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_rebin_description_short,
                    xsh_util_ima_rebin_description,
                    XSH_UTL_IMA_ARITH_RECIPE_AUTHOR,
                    XSH_UTL_IMA_ARITH_RECIPE_CONTACT,
                    xsh_get_license(),
                    xsh_util_ima_rebin_create,
                    xsh_util_ima_rebin_exec,
                    xsh_util_ima_rebin_destroy) ;
 
    cpl_pluginlist_append(list, plugin) ;
    
    return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_ima_rebin_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 */
    p = cpl_parameter_new_range("xsh.xsh_util_ima_rebin.binx", 
                                CPL_TYPE_INT, 
                                "Rebinning X factor: pix_size_o/pix_size_i", 
                                "xsh.xsh_util_ima_rebin",1,1,2);
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "binx") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 
 
 
    p = cpl_parameter_new_range("xsh.xsh_util_ima_rebin.biny", 
                                CPL_TYPE_INT, 
                                "Rebinning Y factor: pix_size_o/pix_size_i", 
                                "xsh.xsh_util_ima_rebin",1,1,2);
    cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "biny") ;
    cpl_parameterlist_append(recipe->parameters, p) ;
 
 cleanup: 
 
    /* Return */
    return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_ima_rebin_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_rebin(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_rebin_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_rebin( cpl_parameterlist   *   parlist, 
                    cpl_frameset        *   frames)
{
    cpl_parameter       *   param= NULL ;
    cpl_frame* frm=NULL;
    cpl_image* ima_tot=NULL;
    cpl_image* ima_pre=NULL;
    cpl_image* ima_ove=NULL;
    cpl_image* ima_dat=NULL;
 
    cpl_image* ima_datr=NULL;
    cpl_image* ima_prer=NULL;
    cpl_image* ima_over=NULL;
 
    cpl_image* ima_new=NULL;
    cpl_propertylist* plist=NULL;
    cpl_propertylist* hext=NULL;
 
    int binx=1;
    int biny=1;
    int nfrm=0;
    const char* name=NULL;
    char new_name[256];
    int prscx=0;
    int prscy=0;
    int ovscx=0;
    int ovscy=0;
    int nx=0;
    int ny=0;
 
    int nxpr=0;
    int nypr=0;
    int nxdr=0;
    int nydr=0;
    int nxor=0;
    int nyor=0;
    int next=0;
    int k=0;
    double cdelt1=0;
    double cdelt2=0;
    const char* base_name=NULL;
    int i=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_rebin.binx"));
    check(binx=cpl_parameter_get_int(param));
 
 
    check(param=cpl_parameterlist_find(parlist, 
                    "xsh.xsh_util_ima_rebin.biny"));
    check(biny=cpl_parameter_get_int(param));
    nfrm=cpl_frameset_get_size(frames);
 
 
    for (i = 0; i < nfrm; i++) {
        frm=cpl_frameset_get_frame(frames,i);
 
        check(name=cpl_frame_get_filename(frm));
        next=cpl_frame_get_nextensions(frm);
        check(plist=cpl_propertylist_load(name,0));
 
        check(prscx=xsh_pfits_get_prscx(plist));
        check(prscy=xsh_pfits_get_prscy(plist));
        check(ovscx=xsh_pfits_get_ovscx(plist));
        check(ovscy=xsh_pfits_get_ovscy(plist));
 
        xsh_msg("Prescan: %d,%d Overscan: %d,%d",prscx,prscy,ovscx,ovscy);
 
        if(cpl_propertylist_has(plist,XSH_WIN_BINX) > 0) {
            cpl_propertylist_set_int(plist,XSH_WIN_BINX,binx);
        } else {
            cpl_propertylist_append_int(plist,XSH_WIN_BINX,binx);
        }
 
        if(cpl_propertylist_has(plist,XSH_WIN_BINY) > 0) {
            cpl_propertylist_set_int(plist,XSH_WIN_BINY,biny);
        } else {
            cpl_propertylist_append_int(plist,XSH_WIN_BINY,biny);
        }
 
      xsh_msg("Prescan: %d,%d Overscan: %d,%d",prscx,prscy,ovscx,ovscy);
 
        if(cpl_propertylist_has(plist,XSH_CDELT1) > 0) {
            check(cdelt1=xsh_pfits_get_cdelt1(plist));
            if(cdelt1==1) {
                check(cpl_propertylist_set_double(plist,XSH_CDELT1,cdelt1*binx));
            }
        } else {
            if(cdelt1>1) {
                cpl_propertylist_append_double(plist,XSH_CDELT1,2);
            }
        }
 
 
 
 
        if(cpl_propertylist_has(plist,XSH_CDELT2) > 0) {
            check(cdelt2=xsh_pfits_get_cdelt2(plist));
            if(cdelt2==1) {
                check(cpl_propertylist_set_double(plist,XSH_CDELT2,cdelt2*binx));
            }
        } else {
            if(cdelt2>1) {
                cpl_propertylist_append_double(plist,XSH_CDELT2,2);
            }
        }
 
 
        for(k=0;k<=next;k++) {
            check(ima_tot=cpl_image_load(name,CPL_TYPE_FLOAT,0,k));
            check(hext=cpl_propertylist_load(name,k));
 
            check(nx=cpl_image_get_size_x(ima_tot));
            check(ny=cpl_image_get_size_y(ima_tot));
 
            check(ima_dat=cpl_image_extract(ima_tot,prscx+1,prscy+1,nx-ovscx,ny-ovscy));
            check(ima_pre=cpl_image_extract(ima_tot,1,prscy+1,prscx,ny));
            check(ima_ove=cpl_image_extract(ima_tot,nx-ovscx+1,prscy+1,nx,ny));
            base_name=xsh_get_basename(name);
            sprintf(new_name,"pre_binx%d_biny%d_%s",binx,biny,base_name);
            //check(cpl_image_save(ima_pre,new_name,CPL_BPP_IEEE_FLOAT,plist,
            //                     CPL_IO_DEFAULT));
 
            sprintf(new_name,"ove_binx%d_biny%d_%s",binx,biny,base_name);
            //check(cpl_image_save(ima_ove,new_name,CPL_BPP_IEEE_FLOAT,plist,
            //                     CPL_IO_DEFAULT));
 
            sprintf(new_name,"dat_binx%d_biny%d_%s",binx,biny,base_name);
            //check(cpl_image_save(ima_dat,new_name,CPL_BPP_IEEE_FLOAT,plist,
            //                     CPL_IO_DEFAULT));
 
 
            check(ima_datr=cpl_image_extract_subsample(ima_dat,binx,biny));
            check(ima_prer=cpl_image_extract_subsample(ima_pre,binx,biny));
            check(ima_over=cpl_image_extract_subsample(ima_ove,binx,biny));
 
            check(nxpr=cpl_image_get_size_x(ima_prer));
            check(nypr=cpl_image_get_size_y(ima_prer));
            check(nxor=cpl_image_get_size_x(ima_over));
            check(nyor=cpl_image_get_size_y(ima_over));
            check(nxdr=cpl_image_get_size_x(ima_datr));
            check(nydr=cpl_image_get_size_y(ima_datr));
 
            check(ima_new=cpl_image_new(nxpr+nxdr+nxor,ny/2,
                            CPL_TYPE_FLOAT));
            check(cpl_image_copy(ima_new,ima_prer,1,1));
            check(cpl_image_copy(ima_new,ima_datr,1+nxpr,1));
            check(cpl_image_copy(ima_new,ima_over,1+nxpr+nxdr,1));
 
            sprintf(new_name,"datr_binx%d_biny%d_%s",binx,biny,base_name);
            //check(cpl_image_save(ima_datr,new_name,CPL_BPP_IEEE_FLOAT,plist,
            //                     CPL_IO_DEFAULT));
 
            sprintf(new_name,"binx%d_biny%d_%s",binx,biny,base_name);
            xsh_msg("new_name=%s",new_name);
 
            //check(cpl_image_save(ima_new,new_name,CPL_BPP_16_SIGNED,plist,
            //                     CPL_IO_DEFAULT));
            if(k==0) {
                check(cpl_image_save(ima_new,new_name,XSH_PRE_DATA_BPP,plist,
                                CPL_IO_DEFAULT));
            } else if (k==1) {
                check(cpl_image_save(ima_new,new_name,XSH_PRE_ERRS_BPP,hext,
                                CPL_IO_EXTEND));
            } else if (k==2) {
                check(cpl_image_save(ima_new,new_name,XSH_PRE_QUAL_BPP,hext,
                                CPL_IO_EXTEND));
            }
            xsh_free_image(&ima_tot);
            xsh_free_image(&ima_dat);
            xsh_free_image(&ima_pre);
            xsh_free_image(&ima_ove);
            xsh_free_image(&ima_new);
            xsh_free_propertylist(&plist);
            xsh_free_propertylist(&hext);
        }
    }
 
    cleanup:
    xsh_free_image(&ima_tot);
    xsh_free_image(&ima_dat);
    xsh_free_image(&ima_pre);
    xsh_free_image(&ima_ove);
    xsh_free_image(&ima_new);
 
 
    if (cpl_error_get_code()) {
        return -1 ;
    } else {
        return 0 ;
    }
 
}