sinfo_utl_ima_cube_ks_test.c

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

Generated on 3 Mar 2013 for SINFONI Pipeline Reference Manual by  doxygen 1.6.1