sinfo_utl_ima_cube_ks_test.c

00001 /* $Id: sinfo_utl_ima_cube_ks_test.c,v 1.11 2009/11/12 14:49:38 kmirny Exp $
00002  *
00003  * This file is part of the SINFONI Pipeline
00004  * Copyright (C) 2002,2003 European Southern Observatory
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: kmirny $
00023  * $Date: 2009/11/12 14:49:38 $
00024  * $Revision: 1.11 $
00025  * $Name: sinfo-2_2_5 $
00026  * $Log: sinfo_utl_ima_cube_ks_test.c,v $
00027  * Revision 1.11  2009/11/12 14:49:38  kmirny
00028  * changing output message
00029  *
00030  * Revision 1.10  2009/07/27 10:34:54  amodigli
00031  * fixed typo in short description
00032  *
00033  * Revision 1.9  2009/06/03 14:59:31  kmirny
00034  * rollback
00035  *
00036  */
00037 
00038 #ifdef HAVE_CONFIG_H
00039 #include <config.h>
00040 #endif
00041 
00042 /*-----------------------------------------------------------------------------
00043                                 Includes
00044  ----------------------------------------------------------------------------*/
00045 #include <string.h>
00046 
00047 /* cpl */
00048 #include <cpl.h>
00049 #include <math.h>
00050 /* irplib */
00051 #include <irplib_utils.h>
00052 
00053 #include <sinfo_tpl_utils.h>
00054 #include <sinfo_pfits.h>
00055 #include <sinfo_tpl_dfs.h>
00056 #include <sinfo_key_names.h>
00057 #include <sinfo_pro_types.h>
00058 #include <sinfo_pro_save.h>
00059 #include <sinfo_functions.h>
00060 #include <sinfo_msg.h>
00061 #include <sinfo_error.h>
00062 #include <sinfo_utils_wrappers.h>
00063 #include <sinfo_new_cube_ops.h>
00064 
00065 /*-----------------------------------------------------------------------------
00066                             Functions prototypes
00067  ----------------------------------------------------------------------------*/
00068 
00069 static int sinfo_utl_ima_cube_ks_test_create(cpl_plugin *) ;
00070 static int sinfo_utl_ima_cube_ks_test_exec(cpl_plugin *) ;
00071 static int sinfo_utl_ima_cube_ks_test_destroy(cpl_plugin *) ;
00072 static int sinfo_utl_ima_cube_ks_test(cpl_parameterlist *, cpl_frameset *) ;
00073 
00074 
00075 static cpl_imagelist* create_cube_shift(
00076                 int iSizeX,
00077                 int iSizeY,
00078                 int iPlanesNumber,
00079                 int iFWHMX,
00080                 int iFWHMY,
00081                 int shiftX,
00082                 int shiftY,
00083                 double dSignal,
00084                 double dBkgSignal,
00085                 double dNoiseLvl,
00086                 double dSignalDelta,
00087                 int iDefectX,
00088                 int iDefectY,
00089                 double dDefectValue,
00090                 int type
00091         );
00092 
00093 static cpl_image* create_plane(
00094                 int iSizeX,
00095                 int iSizeY,
00096                 int iFWHMX,
00097                 int iFWHMY,
00098                 int shiftX,
00099                 int shiftY,
00100                 double dSignal,
00101                 double dBkgSignal,
00102                 double dNoiseLvl
00103         );
00104 static cpl_image* create_square_plane(
00105                 int iSizeX,
00106                 int iSizeY,
00107                 int iHoleX,
00108                 int iHoleY,
00109                 int shiftX,
00110                 int shiftY,
00111                 double dSignal,
00112                 double dBkgSignal,
00113                 double dNoiseLvl);
00114 
00115 static int put_defect(cpl_image *pPlane, int iDefectX, int iDefectY, double dDefectValue);
00116 void putNAN(cpl_image *pPlane, int iDefectX, int iDefectY);
00117 
00118 
00119 /*-----------------------------------------------------------------------------
00120                             Static variables
00121  ----------------------------------------------------------------------------*/
00122 
00123 static char sinfo_utl_ima_cube_ks_test_description[] =
00124 "This recipe produces a test for kappa-sigma clipping\n"
00125 "Information on relevant parameters can be found with\n"
00126 "esorex --params sinfo_utl_ima_cube_ks_test\n"
00127 "esorex --help sinfo_utl_ima_cube_ks_test\n"
00128 "\n";
00129 
00130 static char PARAM_NAME_SIZE_X[] = "sinfoni.sinfo_utl_ima_cube_ks_test.size_x";
00131 static char PARAM_NAME_SIZE_Y[] = "sinfoni.sinfo_utl_ima_cube_ks_test.size_y";
00132 static char PARAM_NAME_FWHM_X[] = "sinfoni.sinfo_utl_ima_cube_ks_test.fwhm_x";
00133 static char PARAM_NAME_FWHM_Y[] = "sinfoni.sinfo_utl_ima_cube_ks_test.fwhm_y";
00134 static char PARAM_NAME_SIGNAL[] = "sinfoni.sinfo_utl_ima_cube_ks_test.total_signal";
00135 static char PARAM_NAME_SIGNAL_DELTA[] = "sinfoni.sinfo_utl_ima_cube_ks_test.total_signal_delta";
00136 static char PARAM_NAME_BKGSIG[] = "sinfoni.sinfo_utl_ima_cube_ks_test.bkg_signal";
00137 static char PARAM_NAME_NOISEL[] = "sinfoni.sinfo_utl_ima_cube_ks_test.noise_level";
00138 static char PARAM_NAME_DEFECT_X[] = "sinfoni.sinfo_utl_ima_cube_ks_test.defect_x";
00139 static char PARAM_NAME_DEFECT_Y[] = "sinfoni.sinfo_utl_ima_cube_ks_test.defect_y";
00140 static char PARAM_NAME_DEFECT_SIGNAL[] = "sinfoni.sinfo_utl_ima_cube_ks_test.defect_signal";
00141 static char PARAM_NAME_DEFECT_NUMBER[] = "sinfoni.sinfo_utl_ima_cube_ks_test.defect_number";
00142 static char PARAM_NAME_CUBES_NUMBER[] = "sinfoni.sinfo_utl_ima_cube_ks_test.cubes_number";
00143 static char PARAM_NAME_PLANES_NUMBER[] = "sinfoni.sinfo_utl_ima_cube_ks_test.planes_number";
00144 
00145 
00146 static char RECIPE_NAME[] = "sinfoni.sinfo_utl_ima_cube_ks_test";
00147 
00148 /*-----------------------------------------------------------------------------
00149                                 Functions code
00150  ----------------------------------------------------------------------------*/
00151 /*---------------------------------------------------------------------------*/
00155 /*---------------------------------------------------------------------------*/
00156 
00158 /*---------------------------------------------------------------------------*/
00166 /*---------------------------------------------------------------------------*/
00167 int cpl_plugin_get_info(cpl_pluginlist * list)
00168 {
00169     cpl_recipe  *   recipe = cpl_calloc(1, sizeof *recipe ) ;
00170     cpl_plugin  *   plugin = &recipe->interface ;
00171 
00172     cpl_plugin_init(plugin,
00173                     CPL_PLUGIN_API,
00174                     SINFONI_BINARY_VERSION,
00175                     CPL_PLUGIN_TYPE_RECIPE,
00176                     "sinfo_utl_ima_cube_ks_test",
00177                     "Test cube coaddition with kappa-sigma clip of ouliers",
00178                     sinfo_utl_ima_cube_ks_test_description,
00179                     "Konstantin Mirny",
00180                     "kmirny@eso.org",
00181                     sinfo_get_license(),
00182                     sinfo_utl_ima_cube_ks_test_create,
00183                     sinfo_utl_ima_cube_ks_test_exec,
00184                     sinfo_utl_ima_cube_ks_test_destroy) ;
00185 
00186     cpl_pluginlist_append(list, plugin) ;
00187 
00188     return 0;
00189 }
00190 
00191 /*---------------------------------------------------------------------------*/
00200 /*---------------------------------------------------------------------------*/
00201 static int sinfo_utl_ima_cube_ks_test_create(cpl_plugin * plugin)
00202 {
00203     const int CUBES_NUMBER      = 5;
00204     const int PLANES_NUMBER     = 10;
00205     const int SIZE_X_DEFAULT    = 64;
00206     const int SIZE_Y_DEFAULT    = 64;
00207     const int FWHM_X            = 24;
00208     const int FWHM_Y            = 24;
00209     const double TOTAL_SIGNAL   = 1E6;
00210     const double SIGNAL_DELTA   = 1E5;
00211     const double BKG_SIGNAL     = 250.; // 250
00212     const double NOISE_VALUE    = 100;
00213     const int DEFECT_X          = 42;
00214     const int DEFECT_Y          = 42;
00215     const double DEFECT_SIGNAL  = 400;
00216     const int DEFECT_NUMBER     = 1;
00217 
00218     cpl_recipe      * recipe ;
00219     cpl_parameter   * p ;
00220 
00221     /* Get the recipe out of the plugin */
00222     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00223         recipe = (cpl_recipe *)plugin ;
00224     else return -1 ;
00225     cpl_error_reset();
00226     irplib_reset();
00227 
00228     /* Create the parameters list in the cpl_recipe object */
00229     recipe->parameters = cpl_parameterlist_new() ;
00230 
00231     /* Fill the parameters list */
00232     /* --stropt */
00233 /*    p = cpl_parameter_new_value("sinfoni.sinfo_utl_ima_cube_ks_test.op",
00234                                 CPL_TYPE_STRING,
00235                                 "A possible operation",
00236                                 "sinfoni.sinfo_utl_ima_cube_ks_test","+");
00237     cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "op") ;
00238     cpl_parameterlist_append(recipe->parameters, p) ;*/
00239 
00240     /* --size_x */
00241     p = cpl_parameter_new_value(PARAM_NAME_SIZE_X,
00242             CPL_TYPE_INT, "size X axis", RECIPE_NAME, SIZE_X_DEFAULT) ;
00243     cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "size_x") ;
00244     cpl_parameterlist_append(recipe->parameters, p) ;
00245 
00246     /* --size_y */
00247     p = cpl_parameter_new_value(PARAM_NAME_SIZE_Y,
00248             CPL_TYPE_INT, "size Y axis", RECIPE_NAME, SIZE_Y_DEFAULT) ;
00249     cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "size_y") ;
00250     cpl_parameterlist_append(recipe->parameters, p) ;
00251 
00252     /* --fwhm_x */
00253     p = cpl_parameter_new_value(PARAM_NAME_FWHM_X,
00254             CPL_TYPE_INT, "FWHM X axis", RECIPE_NAME, FWHM_X) ;
00255     cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "fwhm_x") ;
00256     cpl_parameterlist_append(recipe->parameters, p) ;
00257 
00258     /* --fwhm_y */
00259     p = cpl_parameter_new_value(PARAM_NAME_FWHM_Y,
00260             CPL_TYPE_INT, "FWHM Y axis", RECIPE_NAME, FWHM_Y) ;
00261     cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "fwhm_y") ;
00262     cpl_parameterlist_append(recipe->parameters, p) ;
00263 
00264     /* --total_signal */
00265     p = cpl_parameter_new_value(PARAM_NAME_SIGNAL,
00266             CPL_TYPE_DOUBLE, "Total signal value", RECIPE_NAME, TOTAL_SIGNAL) ;
00267     cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "total_signal") ;
00268     cpl_parameterlist_append(recipe->parameters, p) ;
00269 
00270     /* --bkg_signal */
00271     p = cpl_parameter_new_value(PARAM_NAME_BKGSIG,
00272             CPL_TYPE_DOUBLE, "background signal level", RECIPE_NAME, BKG_SIGNAL) ;
00273     cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "bkg_signal") ;
00274     cpl_parameterlist_append(recipe->parameters, p) ;
00275 
00276     /* --noise_level */
00277     p = cpl_parameter_new_value(PARAM_NAME_NOISEL,
00278             CPL_TYPE_DOUBLE, "Noise level", RECIPE_NAME, NOISE_VALUE) ;
00279     cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "noise_level") ;
00280     cpl_parameterlist_append(recipe->parameters, p) ;
00281 
00282     /* --cubes_number */
00283     p = cpl_parameter_new_value(PARAM_NAME_CUBES_NUMBER,
00284             CPL_TYPE_INT, "Number of cubes", RECIPE_NAME, CUBES_NUMBER) ;
00285     cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "cubes_number") ;
00286     cpl_parameterlist_append(recipe->parameters, p) ;
00287 
00288     /* --planes_number */
00289     p = cpl_parameter_new_value(PARAM_NAME_PLANES_NUMBER,
00290             CPL_TYPE_INT, "Number of images for each cube", RECIPE_NAME, PLANES_NUMBER) ;
00291     cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "planes_number") ;
00292     cpl_parameterlist_append(recipe->parameters, p) ;
00293 
00294     /* --signal_delta */
00295         p = cpl_parameter_new_value(PARAM_NAME_SIGNAL_DELTA,
00296                 CPL_TYPE_DOUBLE, "Change of the signal for the next plane inside a cube", RECIPE_NAME, SIGNAL_DELTA) ;
00297         cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "total_signal_delta") ;
00298         cpl_parameterlist_append(recipe->parameters, p) ;
00299 
00300     /* --defect_x */
00301         p = cpl_parameter_new_value(PARAM_NAME_DEFECT_X,
00302                 CPL_TYPE_INT, "X position of the bad pixel", RECIPE_NAME, DEFECT_X) ;
00303         cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "defect_x") ;
00304         cpl_parameterlist_append(recipe->parameters, p) ;
00305 
00306     /* --defect_x */
00307         p = cpl_parameter_new_value(PARAM_NAME_DEFECT_Y,
00308                 CPL_TYPE_INT, "Y position of the bad pixel", RECIPE_NAME, DEFECT_Y) ;
00309         cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "defect_y") ;
00310         cpl_parameterlist_append(recipe->parameters, p) ;
00311 
00312     /* --defect_signal */
00313         p = cpl_parameter_new_value(PARAM_NAME_DEFECT_SIGNAL,
00314                 CPL_TYPE_DOUBLE, "signal value of the bad pixel", RECIPE_NAME, DEFECT_SIGNAL) ;
00315         cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "defect_signal") ;
00316         cpl_parameterlist_append(recipe->parameters, p) ;
00317 
00318     /* --defect_number */
00319         p = cpl_parameter_new_value(PARAM_NAME_DEFECT_NUMBER,
00320                 CPL_TYPE_INT, "Number of planes in a cube with a bad pixel", RECIPE_NAME, DEFECT_NUMBER) ;
00321         cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "defect_number") ;
00322         cpl_parameterlist_append(recipe->parameters, p) ;
00323 
00324     /* Return */
00325     return 0;
00326 }
00327 
00328 /*---------------------------------------------------------------------------*/
00334 /*---------------------------------------------------------------------------*/
00335 static int sinfo_utl_ima_cube_ks_test_exec(cpl_plugin * plugin)
00336 {
00337     cpl_recipe  *   recipe ;
00338      int code=0;
00339      cpl_errorstate initial_errorstate = cpl_errorstate_get();
00340 
00341     /* Get the recipe out of the plugin */
00342     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00343         recipe = (cpl_recipe *)plugin ;
00344     else return -1 ;
00345     cpl_error_reset();
00346     irplib_reset();
00347     code = sinfo_utl_ima_cube_ks_test(recipe->parameters, recipe->frames) ;
00348 
00349 
00350     if (!cpl_errorstate_is_equal(initial_errorstate)) {
00351         /* Dump the error history since recipe execution start.
00352            At this point the recipe cannot recover from the error */
00353         cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);
00354     }
00355 
00356     return code ;
00357 }
00358 
00359 /*---------------------------------------------------------------------------*/
00365 /*---------------------------------------------------------------------------*/
00366 static int sinfo_utl_ima_cube_ks_test_destroy(cpl_plugin * plugin)
00367 {
00368     cpl_recipe  *   recipe ;
00369 
00370     /* Get the recipe out of the plugin */
00371     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00372         recipe = (cpl_recipe *)plugin ;
00373     else return -1 ;
00374 
00375     cpl_parameterlist_delete(recipe->parameters) ;
00376     return 0 ;
00377 }
00378 
00379 /*---------------------------------------------------------------------------*/
00386 /*---------------------------------------------------------------------------*/
00387 static int
00388 sinfo_utl_ima_cube_ks_test( cpl_parameterlist   *   parlist,
00389         cpl_frameset        *   framelist)
00390 {
00391     // parameters
00392     int     iSizeX = 0;
00393     int     iSizeY = 0;
00394     int     iFWHMX = 0;
00395     int     iFWHMY = 0;
00396     int     iGlobalSizeX = 0;
00397     int     iGlobalSizeY = 0;
00398     int     shiftMultX = 2;
00399     int     shiftMultY = 2;
00400     int*    pOffsetX = 0;
00401     int*    pOffsetY = 0;
00402     double dSignal = 0;
00403     double dBkgSignal = 0;
00404     double dNoiseLvl = 0;
00405 
00406     double dSignalDelta = 0;
00407     int iDefectX = 0;
00408     int iDefectY = 0;
00409     double dDefectValue = 0;
00410     int iDefectNumber = 0;
00411     int iCubesNumber = 0;
00412     int iPlanesNumber = 0;
00414     int z = 0;
00415     int x = 0;
00416     int y = 0;
00417     const double kappa = 3;
00418     const char          *   name_o = NULL ;
00419     cpl_parameter       *   param = NULL ;
00420     cpl_propertylist    *   plist = NULL ;
00421     cpl_frame           *   product_frame = NULL;
00422     cpl_imagelist       ** ppCubes = NULL;
00423     cpl_imagelist       *  pResult = NULL;
00424     double          *   exptimes = NULL;
00425     cpl_imagelist       *   mask = NULL;
00426     sinfo_msg("Welcome to SINFONI Pipeline release %d.%d.%d",
00427     SINFONI_MAJOR_VERSION,SINFONI_MINOR_VERSION,SINFONI_MICRO_VERSION);
00428     ck0(sinfo_dfs_set_groups(framelist),"Cannot indentify RAW and CALIB frames");
00429 
00430 
00431 /* HOW TO RETRIEVE INPUT PARAMETERS */
00432       /* --size_x */
00433       check_nomsg(param=cpl_parameterlist_find(parlist,
00434                                                PARAM_NAME_SIZE_X));
00435       check_nomsg(iSizeX=cpl_parameter_get_int(param));
00436 
00437       /* --size_y */
00438       check_nomsg(param=cpl_parameterlist_find(parlist,
00439                                                PARAM_NAME_SIZE_Y));
00440       check_nomsg(iSizeY=cpl_parameter_get_int(param));
00441 
00442       /* --fwhm_x */
00443       check_nomsg(param=cpl_parameterlist_find(parlist,
00444                                                PARAM_NAME_FWHM_X));
00445       check_nomsg(iFWHMX=cpl_parameter_get_int(param));
00446 
00447       /* --fwhm_y */
00448       check_nomsg(param=cpl_parameterlist_find(parlist,
00449                                                PARAM_NAME_FWHM_Y));
00450       check_nomsg(iFWHMY=cpl_parameter_get_int(param));
00451 
00452       /* --total_signal */
00453       check_nomsg(param=cpl_parameterlist_find(parlist,
00454                                                PARAM_NAME_SIGNAL));
00455       check_nomsg(dSignal=cpl_parameter_get_double(param));
00456 
00457       /* --bkg_signal */
00458       check_nomsg(param=cpl_parameterlist_find(parlist,
00459                                                PARAM_NAME_BKGSIG));
00460       check_nomsg(dBkgSignal=cpl_parameter_get_double(param));
00461 
00462       /* --noise_level */
00463       check_nomsg(param=cpl_parameterlist_find(parlist,
00464                                                PARAM_NAME_NOISEL));
00465       check_nomsg(dNoiseLvl=cpl_parameter_get_double(param));
00466 
00467       /* --cubes_number */
00468       check_nomsg(param=cpl_parameterlist_find(parlist,
00469                                                PARAM_NAME_CUBES_NUMBER));
00470       check_nomsg(iCubesNumber=cpl_parameter_get_int(param));
00471 
00472       /* --planes_number */
00473       check_nomsg(param=cpl_parameterlist_find(parlist,
00474                                                PARAM_NAME_PLANES_NUMBER));
00475       check_nomsg(iPlanesNumber=cpl_parameter_get_int(param));
00476 
00477       /* -signal_delta */
00478       check_nomsg(param=cpl_parameterlist_find(parlist,
00479                                                PARAM_NAME_SIGNAL_DELTA));
00480       check_nomsg(dSignalDelta=cpl_parameter_get_double(param));
00481 
00482       /* --defect_x */
00483       check_nomsg(param=cpl_parameterlist_find(parlist,
00484                                                PARAM_NAME_DEFECT_X));
00485       check_nomsg(iDefectX=cpl_parameter_get_int(param));
00486 
00487       /* --defect_y */
00488       check_nomsg(param=cpl_parameterlist_find(parlist,
00489                                                PARAM_NAME_DEFECT_Y));
00490       check_nomsg(iDefectY=cpl_parameter_get_int(param));
00491 
00492       /* --defect_value */
00493       check_nomsg(param=cpl_parameterlist_find(parlist,
00494                                                PARAM_NAME_DEFECT_SIGNAL));
00495       check_nomsg(dDefectValue=cpl_parameter_get_double(param));
00496 
00497       /* --defect_number */
00498       check_nomsg(param=cpl_parameterlist_find(parlist,
00499                                                PARAM_NAME_DEFECT_NUMBER));
00500       check_nomsg(iDefectNumber=cpl_parameter_get_int(param));
00501 
00502 
00503     /* HOW TO GET THE VALUE OF A FITS KEYWORD */
00504     check(plist=cpl_propertylist_new(),"Cannot create a Property List");
00505 
00506     /* Now performing the data reduction */
00507     /* Let's generate one image for the example */
00508 
00509     // 1. Create cubes
00510     ppCubes = (cpl_imagelist**)cpl_malloc(sizeof(cpl_imagelist*) * (iCubesNumber + 2)); // +1 for the result, +1 for the mask
00511     pOffsetX = cpl_malloc(sizeof(int) * iCubesNumber);
00512     pOffsetY = cpl_malloc(sizeof(int) * iCubesNumber);
00513 //    iGlobalSizeX = iSizeX + (iCubesNumber-1) * shiftMultX;// it's not a fair calculation - only for test
00514 //    iGlobalSizeY = iSizeY + (iCubesNumber-1) * shiftMultY;
00515     sinfo_msg("Creating cubes....");
00516     for (z = 0; z < iCubesNumber; z++)
00517     {
00518         pOffsetX[z] = shiftMultX*z;// + ((z%3) - 3) * shiftMultX ;
00519         pOffsetY[z] = shiftMultY*z;// + (((z-2)%3) - 1) * shiftMultY / 2;
00520         cpl_msg_warning(cpl_func, "cube [%d] offset[%d:%d]", z,pOffsetX[z], pOffsetY[z] );
00521         cpl_imagelist* pCube =
00522         create_cube_shift(
00523                 iSizeX,
00524                 iSizeY,
00525                 iPlanesNumber,
00526                 iFWHMX,
00527                 iFWHMY,
00528                 -pOffsetX[z],
00529                 -pOffsetY[z],
00530                 dSignal,
00531                 dBkgSignal,
00532                 dNoiseLvl,
00533                 dSignalDelta,
00534                 iDefectX,
00535                 iDefectY,
00536                 (z < iDefectNumber) ? dDefectValue : 0,
00537                 0
00538         );
00539         ppCubes[z] = pCube;
00540 
00541         // fill NAN areas
00542 /*      cpl_image* pImage = cpl_imagelist_get(pCube, 0);
00543         switch(z)
00544         {
00545         case 0:
00546             {
00547                 for (x = 1; x <=iSizeX; x++)
00548                 {
00549                     for (y = 1; y <= 16; y++)
00550                     {
00551                         check_nomsg(cpl_image_set(pImage, x, y, sqrt(-1)));
00552                         check_nomsg(cpl_image_set(pImage, x, y+48, sqrt(-1)));
00553                     }
00554                 }
00555             }
00556             break;
00557         case 1:
00558             {
00559                 for (x = 1; x <=iSizeX; x++)
00560                 {
00561                     for (y = 1; y <= 8; y++)
00562                     {
00563                         check_nomsg(cpl_image_set(pImage, x, y, sqrt(-1)));
00564                     }
00565                     for (y = 24; y <= iSizeY; y++)
00566                     {
00567                         check_nomsg(cpl_image_set(pImage, x, y, sqrt(-1)));
00568 
00569                     }
00570                 }
00571             }
00572             break;
00573         }
00574 */
00575     }
00576     // 2. make a kappa-sigma clipping
00577 /*    pResult =  kappa_sigma(
00578             iSizeX,
00579             iSizeY,
00580             iCubesNumber,
00581             iPlanesNumber,
00582             kappa,
00583             NULL,
00584             ppCubes);*/
00585 
00586     // prepare offset arrays
00587     sinfo_msg("Kappa-sigma....");
00588 
00589     // determine size of the coadded cube
00590     const int BIG_ENOUGH_INT = 65535;
00591     int xmax = -BIG_ENOUGH_INT;
00592     int ymax = -BIG_ENOUGH_INT;
00593     int xmin = BIG_ENOUGH_INT;
00594     int ymin = BIG_ENOUGH_INT;
00595     for (z = 0; z < iCubesNumber; z++)
00596     {
00597 
00598         int localMaxX = iSizeX + pOffsetX[z];
00599         int localMaxY = iSizeY + pOffsetY[z];
00600         int localMinX = pOffsetX[z];
00601         int localMinY = pOffsetY[z];
00602 
00603         if(localMaxX > xmax) xmax = localMaxX;
00604         if(localMaxY > ymax) ymax = localMaxY;
00605 
00606         if(localMinX < xmin) xmin = localMinX;
00607         if(localMinY < ymin) ymin = localMinY;
00608     }
00609 
00610     iGlobalSizeX = xmax - xmin;
00611     iGlobalSizeY = ymax - ymin;
00612     cpl_msg_warning(cpl_func, "iGlobalSize[%d:%d] xmaxmin[%d:%d] ymaxmin[%d:%d]", iGlobalSizeX, iGlobalSizeY, xmin, xmax, ymin, ymax);
00613     pResult = cpl_imagelist_new();
00614     exptimes = cpl_malloc(sizeof(double) * iCubesNumber);
00615     for (z = 0; z < iCubesNumber; z++)
00616     {
00617         exptimes[z] = 10.;
00618     }
00619     mask= cpl_imagelist_new();
00620     for (z = 0; z < iPlanesNumber; z++)
00621     {
00622         cpl_image* imMask = cpl_image_new(iGlobalSizeX, iGlobalSizeY, CPL_TYPE_FLOAT);
00623         cpl_image* imResult = cpl_image_new(iGlobalSizeX, iGlobalSizeY, CPL_TYPE_FLOAT);
00624         for (x = 1; x <= iGlobalSizeX; x++)
00625         {
00626             for (y = 1; y <= iGlobalSizeY; y++)
00627             {
00628                 cpl_image_set(imMask, x, y, 100);
00629             }
00630         }
00631         cpl_imagelist_set(mask, imMask, z);
00632         cpl_imagelist_set(pResult, imResult, z);
00633     }
00634 
00635     sinfo_coadd_with_ks_clip_optimized(
00636                 0,
00637                 iPlanesNumber,
00638                 iSizeX,
00639                 iSizeY,
00640                 iCubesNumber,
00641                 kappa,
00642                 pOffsetX,
00643                 pOffsetY,
00644                 exptimes,
00645                 mask,
00646                 pResult,
00647                 ppCubes);
00648 //    pResult = kappa_sigma_offset(iGlobalSizeX, iGlobalSizeY, iCubesNumber, ppCubes, iCubesNumber, pOffsetY, kappa);
00649 
00650 
00651 
00652     sinfo_msg("Saving results");
00653     ppCubes[iCubesNumber] = pResult;
00654     ppCubes[iCubesNumber + 1] = mask;
00655 
00656     /* HOW TO SAVE A PRODUCT ON DISK  */
00657     /* Set the file name */
00658     name_o = "ima_res_0000.fits" ;
00659 
00660     /* Create product frame */
00661     check_nomsg(product_frame = cpl_frame_new());
00662     check_nomsg(cpl_frame_set_filename(product_frame, name_o)) ;
00663     check_nomsg(cpl_frame_set_tag(product_frame,"image_gauss" )) ;
00664     check_nomsg(cpl_frame_set_type(product_frame, CPL_FRAME_TYPE_IMAGE)) ;
00665     check_nomsg(cpl_frame_set_group(product_frame, CPL_FRAME_GROUP_PRODUCT)) ;
00666     check(cpl_frame_set_level(product_frame, CPL_FRAME_LEVEL_FINAL),
00667       "Error while initialising the product frame") ;
00668 
00669     /* Add DataFlow keywords */
00670     check_nomsg(cpl_propertylist_erase_regexp(plist, "^ESO PRO CATG",0));
00671 //    cpl_frameset_dump(framelist, stdout);
00672     check(cpl_dfs_setup_product_header(plist,
00673                                        product_frame,
00674                                        framelist,
00675                                        parlist,
00676                                        "sinfo_utl_ima_cube_ks_test",
00677                                        "SINFONI",
00678                                        KEY_VALUE_HPRO_DID,NULL),
00679       "Problem in the product DFS-compliance") ;
00680 
00681     /* Save the input images file */
00682 
00683     for (z = 0; z <= iCubesNumber + 1; z++) // the last imagelist is result after kappa-sigma, the very last is the mask
00684     {
00685         char BUF[256];
00686         sprintf(BUF,"out_cube_%d.fits",z);
00687         sinfo_msg("Saving results cube[%d]",z);
00688         check(cpl_imagelist_save(ppCubes[z],
00689                 BUF,
00690                        CPL_BPP_IEEE_FLOAT,
00691                        plist,
00692                        CPL_IO_DEFAULT),
00693             "Could not save product");
00694 
00695         ck0(sinfo_pro_save_ims(ppCubes[z],framelist,framelist,BUF,"CUBE",NULL,
00696                         "sinfo_utl_ima_cube_ks_ex",parlist),
00697             "cannot save cube %s", BUF);
00698     }
00699 
00700     sinfo_free_propertylist(&plist) ;
00701     /* Log the saved file in the input frameset */
00702     check_nomsg(cpl_frameset_insert(framelist, product_frame)) ;
00703 
00704 
00705  cleanup:
00706 
00707 //    sinfo_free_frameset(&raw_set);
00708     sinfo_free_propertylist(&plist) ;
00709     for (z = 0; z <= iCubesNumber + 1; z++) // the last imagelist is result after kappa-sigma, the very last is the mask
00710     {
00711         cpl_imagelist_delete(ppCubes[z]);
00712     }
00713     cpl_free(ppCubes);
00714     /* This is usually freed by esorex: but what about if errors occurs?
00715     sinfo_free_frame(&product_frame) ;
00716     */
00717 
00718     return cpl_error_get_code() ? -1 : 0;
00719 
00720 }
00721 cpl_imagelist* create_cube_shift(
00722                 int iSizeX,
00723                 int iSizeY,
00724                 int iPlanesNumber,
00725                 int iFWHMX,
00726                 int iFWHMY,
00727                 int shiftX,
00728                 int shiftY,
00729                 double dSignal,
00730                 double dBkgSignal,
00731                 double dNoiseLvl,
00732                 double dSignalDelta,
00733                 int iDefectX,
00734                 int iDefectY,
00735                 double dDefectValue,
00736                 int type
00737 )
00738 {
00739     int z = 0;
00740     cpl_image* pPlane = NULL;
00741     cpl_imagelist* pRetval = NULL;
00742     pRetval = cpl_imagelist_new();
00743 
00744     for (z = 0; z < iPlanesNumber; z++)
00745     {
00746         double dSignalValue = dSignal + z * dSignalDelta;
00747         switch (type)
00748         {
00749         case 0:
00750             pPlane = create_plane(
00751                             iSizeX,
00752                             iSizeY,
00753                             iFWHMX,
00754                             iFWHMY,
00755                             shiftX,
00756                             shiftY,
00757                             dSignalValue,
00758                             dBkgSignal,
00759                             dNoiseLvl
00760                         );
00761             break;
00762         case 1:
00763             pPlane = create_square_plane(
00764                             iSizeX,
00765                             iSizeY,
00766                             iFWHMX,
00767                             iFWHMY,
00768                             shiftX,
00769                             shiftY,
00770                             dSignalValue,
00771                             dBkgSignal,
00772                             dNoiseLvl
00773                         );
00774             break;
00775         }
00776 
00777 
00778         if (dDefectValue)
00779         {
00780             put_defect(pPlane, iDefectX, iDefectY, dDefectValue);
00781         }
00782         putNAN(pPlane, iDefectX + shiftX, iDefectY + shiftY);
00783         cpl_imagelist_set(pRetval, pPlane, z);
00784     }
00785     return pRetval;
00786 }
00787 cpl_image* create_plane(
00788                 int iSizeX,
00789                 int iSizeY,
00790                 int iFWHMX,
00791                 int iFWHMY,
00792                 int shiftX,
00793                 int shiftY,
00794                 double dSignal,
00795                 double dBkgSignal,
00796                 double dNoiseLvl
00797 )
00798 {
00799     cpl_image* imNoise = NULL;
00800     cpl_image* imGauss = NULL;
00801     cpl_image* imResult = NULL;
00802     const double K = 2.35482;//1. / (2. * sqrt(2.* ln(2.)));
00803 
00804     imNoise = cpl_image_new(iSizeX, iSizeY, CPL_TYPE_FLOAT);
00805     cpl_image_fill_noise_uniform(imNoise, dBkgSignal - dNoiseLvl, dBkgSignal + dNoiseLvl);
00806     imGauss = cpl_image_new(iSizeX, iSizeY, CPL_TYPE_FLOAT);
00807     sinfo_msg("Generate Gaussian center[%d:%d] signal[%f], sigma[%f:%f]", iSizeX/2 + shiftX, iSizeY/2 + shiftY, dSignal, iFWHMX / K, iFWHMY / K);
00808     cpl_image_fill_gaussian(imGauss, iSizeX/2 + shiftX, iSizeY/2 + shiftY, dSignal, iFWHMX / K, iFWHMY / K);
00809     imResult = cpl_image_add_create(imGauss, imNoise);
00810 
00811     // cleanup
00812     if (imNoise)
00813     {
00814         cpl_image_delete(imNoise);
00815         imNoise = 0;
00816     }
00817     if (imGauss)
00818     {
00819         cpl_image_delete(imGauss);
00820         imGauss = 0;
00821     }
00822     return imResult;
00823 }
00824 cpl_image* create_square_plane(
00825                 int iSizeX,
00826                 int iSizeY,
00827                 int iHoleX,
00828                 int iHoleY,
00829                 int shiftX,
00830                 int shiftY,
00831                 double dSignal,
00832                 double dBkgSignal,
00833                 double dNoiseLvl
00834 )
00835 {
00836     cpl_image* imNoise = NULL;
00837     cpl_image* imHole = NULL;
00838     cpl_image* imResult = NULL;
00839     int x = 0;
00840     int y = 0;
00841     int xHoleInitial = 0;
00842     int yHoleInitial = 0;
00843     imNoise = cpl_image_new(iSizeX, iSizeY, CPL_TYPE_FLOAT);
00844     cpl_image_fill_noise_uniform(imNoise, dBkgSignal - dNoiseLvl, dBkgSignal + dNoiseLvl);
00845     imHole = cpl_image_new(iSizeX, iSizeY, CPL_TYPE_FLOAT);
00846     xHoleInitial = iSizeX / 2 - iHoleX / 2;
00847     yHoleInitial = iSizeY / 2 - iHoleY / 2;
00848     for (x = 0; x <= iHoleX; x++)
00849     {
00850         for (y = 0; y <= iHoleY; y++)
00851         {
00852             int pX = x + xHoleInitial + shiftX ;
00853             int pY = y + yHoleInitial + shiftY;
00854             if ((pX <= iSizeX) &&(pY <= iSizeY))
00855             cpl_image_set(imHole, pX,pY, dSignal);
00856         }
00857     }
00858     //cpl_image_fill_gaussian(imGauss, iSizeX/2 + shiftX, iSizeY/2 + shiftY, dSignal, iFWHMX / K, iFWHMY / K);
00859     imResult = cpl_image_add_create(imHole, imNoise);
00860 
00861     // cleanup
00862     if (imNoise)
00863     {
00864         cpl_image_delete(imNoise);
00865         imNoise = 0;
00866     }
00867     if (imHole)
00868     {
00869         cpl_image_delete(imHole);
00870         imHole = 0;
00871     }
00872     return imResult;
00873 }
00874 int put_defect(cpl_image *pPlane, int iDefectX, int iDefectY, double dDefectValue)
00875 {
00876     sinfo_msg("Set bad pixel x[%d] y[%d] value[%f]", iDefectX, iDefectY, dDefectValue);
00877     if (pPlane)
00878     {
00879         cpl_image_set(pPlane, iDefectX, iDefectY, dDefectValue);
00880         cpl_image_set(pPlane, iDefectX+1, iDefectY+1, dDefectValue);
00881         cpl_image_set(pPlane, iDefectX-1, iDefectY-1, dDefectValue);
00882         cpl_image_set(pPlane, iDefectX+1, iDefectY-1, dDefectValue);
00883         cpl_image_set(pPlane, iDefectX-1, iDefectY+1, dDefectValue);
00884     }
00885     return 0;
00886 }
00887 
00888 void putNAN(cpl_image *pPlane, int iDefectX, int iDefectY)
00889 {
00890     cpl_image_set(pPlane, iDefectX, iDefectY, sqrt(-1));
00891 }
00892 

Generated on 8 Mar 2011 for SINFONI Pipeline Reference Manual by  doxygen 1.6.1