xsh_util_bpmap_coadd.c

Go to the documentation of this file.

/* $Id: xsh_util_bpmap_coadd.c,v 1.17 2012-12-18 14:12:51 amodigli Exp $
 *
 * This file is part of the CPL (Common Pipeline Library)
 * Copyright (C) 2002 European Southern Observatory
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
/*
 * $Author: amodigli $
 * $Date: 2012-12-18 14:12:51 $
 * $Revision: 1.17 $
 * $Name: not supported by cvs2svn $
 */
 
 /****************************************************************
  *           Bad pixel search  (normal method)                  *
  ****************************************************************/
 
/* --------------------------------------------------------------- 
                         INCLUDES
   --------------------------------------------------------------- */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
/* std libraries */
#include <strings.h>
#include <string.h>
#include <stdio.h>
 
/* cpl */
#include <cpl.h>     
/* irplib */
#include <xsh_irplib_utils.h>
 
/* xsh */
#include <xsh_dfs.h>
#include <xsh_pfits.h>
#include <xsh_msg.h>
#include <xsh_error.h>
#include <xsh_utils_wrappers.h>
#include <xsh_parameters.h>
#include <xsh_badpixelmap.h>
 
/* --------------------------------------------------------------- 
                         DEFINES
   --------------------------------------------------------------- */
 
#define RECIPE_ID "xsh_util_bpmap_coadd"
#define RECIPE_AUTHOR "A.Modigliani"
#define RECIPE_CONTACT "amodigli@eso.org"
 
/* --------------------------------------------------------------- 
                         FUNCTIONS PROTOTYPES
   --------------------------------------------------------------- */
 
const char * xsh_get_licence(void);
static int xsh_util_bpmap_coadd_create(cpl_plugin *plugin);
static int xsh_util_bpmap_coadd_exec(cpl_plugin *plugin);
static int xsh_util_bpmap_coadd_destroy(cpl_plugin *plugin);
static int xsh_util_bpmap_coadd(cpl_parameterlist *, cpl_frameset *);
 
/* --------------------------------------------------------------- 
                         STATIC VARIABLES
   --------------------------------------------------------------- */
 
static char xsh_util_bpmap_coadd_description[] =
"This recipe performs bad pixel maps combination via bitwise OR.\n"
"The input files are several (at least 2)  bad pixel masks in the sof file\n"
"Their tab should contain the string BP_MAP.\n"
"The output is an image resulting from the logical operator OR \n"
"applied to all the masks.\n"
"Information on relevant parameters can be found with\n"
"esorex --params xsh_util_bpmap_coadd\n"
"esorex --help xsh_util_bpmap_coadd\n"
"\n";
 
static char xsh_util_bpmap_coadd_description_short[] ="Add bad pixels masks";
 
/* --------------------------------------------------------------- 
                         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_util_bpmap_coadd",
          xsh_util_bpmap_coadd_description_short,
          xsh_util_bpmap_coadd_description,
          "Andrea Modigliani",
          "Andrea.Modigliani@eso.org",
          xsh_get_license(),
          xsh_util_bpmap_coadd_create,
          xsh_util_bpmap_coadd_exec,
          xsh_util_bpmap_coadd_destroy);
 
  cpl_pluginlist_append(list, plugin);
 
  return 0;
 
}
 
/* --------------------------------------------------------------- */
static int
xsh_util_bpmap_coadd_create(cpl_plugin *plugin)
{
  cpl_recipe* recipe=NULL;
 
  /*
   * We have to provide the option we accept to the application.
   * We need to setup our parameter list and hook it into the recipe
   * interface.
   */
 
  /* Reset library state */
  xsh_init();
 
  /* Check input */
  assure( plugin != NULL, CPL_ERROR_NULL_INPUT, "Null plugin");
 
  /* Get the recipe out of the plugin */
  assure( cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE,
          CPL_ERROR_TYPE_MISMATCH,
          "Plugin is not a recipe");
 
  recipe = (cpl_recipe *)plugin;
 
  recipe->parameters = cpl_parameterlist_new();
  if(recipe->parameters == NULL) {
    return 1;
  }
  xsh_parameters_generic( RECIPE_ID, recipe->parameters )  ;
  xsh_parameters_decode_bp(RECIPE_ID,recipe->parameters,-1);
  cpl_error_reset();
  irplib_reset();
 
  /*
   * Fill the parameter list.
   */
 
 cleanup:
    if ( cpl_error_get_code() != CPL_ERROR_NONE ){
      xsh_error_dump(CPL_MSG_ERROR);
      return 1;
    }
    else {
      return 0;
    }
 
}
 
/* --------------------------------------------------------------- */
static int
xsh_util_bpmap_coadd_exec(cpl_plugin *plugin)
{
 
 
  cpl_recipe *recipe = (cpl_recipe *) plugin;
  cpl_errorstate initial_errorstate = cpl_errorstate_get();
  int code=0;
  
  if(recipe->parameters == NULL ) {
    return 1;
  }
  if(recipe->frames == NULL) {
    return 1;
  }
 
  check(code=xsh_util_bpmap_coadd(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);              
  } 
  cleanup:
 
  return code;
 
}
 
/* --------------------------------------------------------------- */
static int
xsh_util_bpmap_coadd_destroy(cpl_plugin *plugin)
{
  cpl_recipe *recipe = (cpl_recipe *) plugin;
  /*
   * We just destroy what was created during the plugin initializzation phase
   * i.e. the parameter list. The frame set is managed by the application which
   * called us, so that we must not touch it.
   */
 
  cpl_parameterlist_delete(recipe->parameters);
  return 0;
 
}
 
/*
 * The actual recipe actually start here.
 */
 
 
/* --------------------------------------------------------------- */
static int
xsh_util_bpmap_coadd(cpl_parameterlist *parameters, cpl_frameset *sof)
{
  const char* recipe_tags[1] = {"xsh_util_bpmap_coadd"};
  int recipe_tags_size = 1;
  cpl_frameset* bpf_set=NULL;
  int n=0;
  cpl_frame* frm=NULL;
  cpl_frame* frm_tmp=NULL;
  char name[256];
  char tag_pro[256];
  const char* tag=NULL;
  const char* filename=NULL;
  int found=false;
  int i=0;
  xsh_instrument* instrument=NULL;
  cpl_frameset* calib=0;
  cpl_frameset* raws=0;
  cpl_frame* msk_frm=NULL;
  cpl_propertylist* plist=NULL;
  cpl_image* ima=NULL;
 
  xsh_msg("Welcome to Shooter Pipeline release %d.%d.%d",
      XSH_MAJOR_VERSION,XSH_MINOR_VERSION,XSH_MICRO_VERSION);
 
 check( xsh_begin( sof, parameters, &instrument, &raws, &calib,
            recipe_tags, recipe_tags_size, RECIPE_ID,
                    XSH_BINARY_VERSION,
            xsh_util_bpmap_coadd_description_short ) ) ;
 
  if(xsh_dfs_set_groups(sof)) {
    xsh_msg_error("Cannot indentify RAW and CALIB frames") ;
  }
 
  n=cpl_frameset_get_size(calib);
  if(n<1) {
    xsh_msg_error("Empty input frame list!");
    goto cleanup ;
  }
  bpf_set=cpl_frameset_new();
  for(i=0;i<n;i++) {
    found=false;
    frm=cpl_frameset_get_frame(calib,i);
    tag=cpl_frame_get_tag(frm);
    if(strstr(tag,XSH_BP_MAP_REF) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_BP_MAP_NL) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_BP_MAP_RP) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_BP_MAP_HP) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_BP_MAP_CP) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_BP_MAP_NP) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_BP_MAP_DP) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_BP_MAP_SP) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_BP_MAP_PN) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_MASTER_BP_MAP_NLIN) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_MASTER_BP_MAP_BIAS) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_MASTER_BP_MAP_DARK) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_MASTER_BP_MAP_FLAT) != NULL) {
      found=true;
    } else if(strstr(tag,XSH_MASTER_BP_MAP) != NULL) {
      found=true;
    } else {
      xsh_msg_warning("Frame with tag %s is not a supported bad pixel map",
              tag);
    }
    if(found) {
      cpl_frameset_insert(bpf_set,cpl_frame_duplicate(frm));
    }
  }
  n=cpl_frameset_get_size(bpf_set);
  for(i=0;i<n;i++) {
    if(i==0) {
      frm=cpl_frameset_get_frame(bpf_set,i);
    } else {
      frm_tmp=cpl_frameset_get_frame(bpf_set,i);
      xsh_msg("combine %s with %s via bitwise OR",
              cpl_frame_get_tag(frm),cpl_frame_get_tag(frm_tmp));
 
      xsh_badpixelmap_coadd(frm,frm_tmp);
    }
  }
 
  sprintf(tag_pro,"%s_%s",XSH_MASTER_BP_MAP,
      xsh_instrument_arm_tostring(instrument));
  sprintf(name,"%s.fits",tag_pro);
  filename=cpl_frame_get_filename(frm);
  ima=cpl_image_load(filename,CPL_TYPE_FLOAT,0,0);
  plist=cpl_propertylist_load(filename,0);
  xsh_pfits_set_pcatg(plist,tag_pro);
  //check(cpl_image_save(ima,name,CPL_BPP_IEEE_FLOAT,plist,CPL_IO_DEFAULT));
 
  check(msk_frm=xsh_frame_product(name,tag_pro,CPL_FRAME_TYPE_IMAGE, 
                  CPL_FRAME_GROUP_PRODUCT,
                  CPL_FRAME_LEVEL_FINAL));
 
  check( xsh_add_product_image(msk_frm, sof, 
                  parameters, RECIPE_ID, instrument,NULL));
 
 cleanup:
  xsh_free_frameset(&bpf_set);
  xsh_free_image(&ima);
  xsh_free_propertylist(&plist);
 
  if (cpl_error_get_code() != CPL_ERROR_NONE) {
    return -1;
  } else {
    return 0;
  }
 
 
 
}