SINFONI Pipeline Reference Manual  2.5.2
sinfo_utl_ima_cube_ks_test.c
1 /* $Id: sinfo_utl_ima_cube_ks_test.c,v 1.12 2012-05-04 08:11:55 amodigli Exp $
2  *
3  * This file is part of the SINFONI Pipeline
4  * Copyright (C) 2002,2003 European Southern Observatory
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  */
20 
21 /*
22  * $Author: amodigli $
23  * $Date: 2012-05-04 08:11:55 $
24  * $Revision: 1.12 $
25  * $Name: not supported by cvs2svn $
26  * $Log: not supported by cvs2svn $
27  * Revision 1.11 2009/11/12 14:49:38 kmirny
28  * changing output message
29  *
30  * Revision 1.10 2009/07/27 10:34:54 amodigli
31  * fixed typo in short description
32  *
33  * Revision 1.9 2009/06/03 14:59:31 kmirny
34  * rollback
35  *
36  */
37 
38 #ifdef HAVE_CONFIG_H
39 #include <config.h>
40 #endif
41 
42 /*-----------------------------------------------------------------------------
43  Includes
44  ----------------------------------------------------------------------------*/
45 #include <string.h>
46 
47 /* cpl */
48 #include <cpl.h>
49 #include <math.h>
50 /* irplib */
51 #include <irplib_utils.h>
52 #include <sinfo_globals.h>
53 #include <sinfo_tpl_utils.h>
54 #include <sinfo_pfits.h>
55 #include <sinfo_tpl_dfs.h>
56 #include <sinfo_key_names.h>
57 #include <sinfo_pro_types.h>
58 #include <sinfo_pro_save.h>
59 #include <sinfo_functions.h>
60 #include <sinfo_msg.h>
61 #include <sinfo_error.h>
62 #include <sinfo_utils_wrappers.h>
63 #include <sinfo_new_cube_ops.h>
64 
65 /*-----------------------------------------------------------------------------
66  Functions prototypes
67  ----------------------------------------------------------------------------*/
68 
69 static int sinfo_utl_ima_cube_ks_test_create(cpl_plugin *) ;
70 static int sinfo_utl_ima_cube_ks_test_exec(cpl_plugin *) ;
71 static int sinfo_utl_ima_cube_ks_test_destroy(cpl_plugin *) ;
72 static int sinfo_utl_ima_cube_ks_test(cpl_parameterlist *, cpl_frameset *) ;
73 
74 
75 static cpl_imagelist* create_cube_shift(
76  int iSizeX,
77  int iSizeY,
78  int iPlanesNumber,
79  int iFWHMX,
80  int iFWHMY,
81  int shiftX,
82  int shiftY,
83  double dSignal,
84  double dBkgSignal,
85  double dNoiseLvl,
86  double dSignalDelta,
87  int iDefectX,
88  int iDefectY,
89  double dDefectValue,
90  int type
91 );
92 
93 static cpl_image* create_plane(
94  int iSizeX,
95  int iSizeY,
96  int iFWHMX,
97  int iFWHMY,
98  int shiftX,
99  int shiftY,
100  double dSignal,
101  double dBkgSignal,
102  double dNoiseLvl
103 );
104 static cpl_image* create_square_plane(
105  int iSizeX,
106  int iSizeY,
107  int iHoleX,
108  int iHoleY,
109  int shiftX,
110  int shiftY,
111  double dSignal,
112  double dBkgSignal,
113  double dNoiseLvl);
114 
115 static int put_defect(cpl_image *pPlane, int iDefectX, int iDefectY, double dDefectValue);
116 void putNAN(cpl_image *pPlane, int iDefectX, int iDefectY);
117 
118 
119 /*-----------------------------------------------------------------------------
120  Static variables
121  ----------------------------------------------------------------------------*/
122 
123 static char sinfo_utl_ima_cube_ks_test_description[] =
124  "This recipe produces a test for kappa-sigma clipping\n"
125  "\n";
126 
127 static char PARAM_NAME_SIZE_X[] = "sinfoni.sinfo_utl_ima_cube_ks_test.size_x";
128 static char PARAM_NAME_SIZE_Y[] = "sinfoni.sinfo_utl_ima_cube_ks_test.size_y";
129 static char PARAM_NAME_FWHM_X[] = "sinfoni.sinfo_utl_ima_cube_ks_test.fwhm_x";
130 static char PARAM_NAME_FWHM_Y[] = "sinfoni.sinfo_utl_ima_cube_ks_test.fwhm_y";
131 static char PARAM_NAME_SIGNAL[] = "sinfoni.sinfo_utl_ima_cube_ks_test.total_signal";
132 static char PARAM_NAME_SIGNAL_DELTA[] = "sinfoni.sinfo_utl_ima_cube_ks_test.total_signal_delta";
133 static char PARAM_NAME_BKGSIG[] = "sinfoni.sinfo_utl_ima_cube_ks_test.bkg_signal";
134 static char PARAM_NAME_NOISEL[] = "sinfoni.sinfo_utl_ima_cube_ks_test.noise_level";
135 static char PARAM_NAME_DEFECT_X[] = "sinfoni.sinfo_utl_ima_cube_ks_test.defect_x";
136 static char PARAM_NAME_DEFECT_Y[] = "sinfoni.sinfo_utl_ima_cube_ks_test.defect_y";
137 static char PARAM_NAME_DEFECT_SIGNAL[] = "sinfoni.sinfo_utl_ima_cube_ks_test.defect_signal";
138 static char PARAM_NAME_DEFECT_NUMBER[] = "sinfoni.sinfo_utl_ima_cube_ks_test.defect_number";
139 static char PARAM_NAME_CUBES_NUMBER[] = "sinfoni.sinfo_utl_ima_cube_ks_test.cubes_number";
140 static char PARAM_NAME_PLANES_NUMBER[] = "sinfoni.sinfo_utl_ima_cube_ks_test.planes_number";
141 
142 
143 static char RECIPE_NAME[] = "sinfoni.sinfo_utl_ima_cube_ks_test";
144 
145 /*-----------------------------------------------------------------------------
146  Functions code
147  ----------------------------------------------------------------------------*/
148 /*---------------------------------------------------------------------------*/
152 /*---------------------------------------------------------------------------*/
153 
155 /*---------------------------------------------------------------------------*/
163 /*---------------------------------------------------------------------------*/
164 int cpl_plugin_get_info(cpl_pluginlist * list)
165 {
166  cpl_recipe * recipe = cpl_calloc(1, sizeof *recipe ) ;
167  cpl_plugin * plugin = &recipe->interface ;
168 
169  cpl_plugin_init(plugin,
170  CPL_PLUGIN_API,
171  SINFONI_BINARY_VERSION,
172  CPL_PLUGIN_TYPE_RECIPE,
173  "sinfo_utl_ima_cube_ks_test",
174  "Test cube coaddition with kappa-sigma clip of ouliers",
175  sinfo_utl_ima_cube_ks_test_description,
176  "Konstantin Mirny",
177  "kmirny@eso.org",
178  sinfo_get_license(),
179  sinfo_utl_ima_cube_ks_test_create,
180  sinfo_utl_ima_cube_ks_test_exec,
181  sinfo_utl_ima_cube_ks_test_destroy) ;
182 
183  cpl_pluginlist_append(list, plugin) ;
184 
185  return 0;
186 }
187 
188 /*---------------------------------------------------------------------------*/
197 /*---------------------------------------------------------------------------*/
198 static int sinfo_utl_ima_cube_ks_test_create(cpl_plugin * plugin)
199 {
200  const int CUBES_NUMBER = 5;
201  const int PLANES_NUMBER = 10;
202  const int SIZE_X_DEFAULT = 64;
203  const int SIZE_Y_DEFAULT = 64;
204  const int FWHM_X = 24;
205  const int FWHM_Y = 24;
206  const double TOTAL_SIGNAL = 1E6;
207  const double SIGNAL_DELTA = 1E5;
208  const double BKG_SIGNAL = 250.; // 250
209  const double NOISE_VALUE = 100;
210  const int DEFECT_X = 42;
211  const int DEFECT_Y = 42;
212  const double DEFECT_SIGNAL = 400;
213  const int DEFECT_NUMBER = 1;
214 
215  cpl_recipe * recipe ;
216  cpl_parameter * p ;
217 
218  /* Get the recipe out of the plugin */
219  if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
220  recipe = (cpl_recipe *)plugin ;
221  else return -1 ;
222  cpl_error_reset();
223  irplib_reset();
224 
225  /* Create the parameters list in the cpl_recipe object */
226  recipe->parameters = cpl_parameterlist_new() ;
227 
228  /* Fill the parameters list */
229  /* --stropt */
230  /* p = cpl_parameter_new_value("sinfoni.sinfo_utl_ima_cube_ks_test.op",
231  CPL_TYPE_STRING,
232  "A possible operation",
233  "sinfoni.sinfo_utl_ima_cube_ks_test","+");
234  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "op") ;
235  cpl_parameterlist_append(recipe->parameters, p) ;*/
236 
237  /* --size_x */
238  p = cpl_parameter_new_value(PARAM_NAME_SIZE_X,
239  CPL_TYPE_INT, "size X axis", RECIPE_NAME, SIZE_X_DEFAULT) ;
240  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "size_x") ;
241  cpl_parameterlist_append(recipe->parameters, p) ;
242 
243  /* --size_y */
244  p = cpl_parameter_new_value(PARAM_NAME_SIZE_Y,
245  CPL_TYPE_INT, "size Y axis", RECIPE_NAME, SIZE_Y_DEFAULT) ;
246  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "size_y") ;
247  cpl_parameterlist_append(recipe->parameters, p) ;
248 
249  /* --fwhm_x */
250  p = cpl_parameter_new_value(PARAM_NAME_FWHM_X,
251  CPL_TYPE_INT, "FWHM X axis", RECIPE_NAME, FWHM_X) ;
252  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "fwhm_x") ;
253  cpl_parameterlist_append(recipe->parameters, p) ;
254 
255  /* --fwhm_y */
256  p = cpl_parameter_new_value(PARAM_NAME_FWHM_Y,
257  CPL_TYPE_INT, "FWHM Y axis", RECIPE_NAME, FWHM_Y) ;
258  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "fwhm_y") ;
259  cpl_parameterlist_append(recipe->parameters, p) ;
260 
261  /* --total_signal */
262  p = cpl_parameter_new_value(PARAM_NAME_SIGNAL,
263  CPL_TYPE_DOUBLE, "Total signal value", RECIPE_NAME, TOTAL_SIGNAL) ;
264  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "total_signal") ;
265  cpl_parameterlist_append(recipe->parameters, p) ;
266 
267  /* --bkg_signal */
268  p = cpl_parameter_new_value(PARAM_NAME_BKGSIG,
269  CPL_TYPE_DOUBLE, "background signal level", RECIPE_NAME, BKG_SIGNAL) ;
270  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "bkg_signal") ;
271  cpl_parameterlist_append(recipe->parameters, p) ;
272 
273  /* --noise_level */
274  p = cpl_parameter_new_value(PARAM_NAME_NOISEL,
275  CPL_TYPE_DOUBLE, "Noise level", RECIPE_NAME, NOISE_VALUE) ;
276  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "noise_level") ;
277  cpl_parameterlist_append(recipe->parameters, p) ;
278 
279  /* --cubes_number */
280  p = cpl_parameter_new_value(PARAM_NAME_CUBES_NUMBER,
281  CPL_TYPE_INT, "Number of cubes", RECIPE_NAME, CUBES_NUMBER) ;
282  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "cubes_number") ;
283  cpl_parameterlist_append(recipe->parameters, p) ;
284 
285  /* --planes_number */
286  p = cpl_parameter_new_value(PARAM_NAME_PLANES_NUMBER,
287  CPL_TYPE_INT, "Number of images for each cube", RECIPE_NAME, PLANES_NUMBER) ;
288  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "planes_number") ;
289  cpl_parameterlist_append(recipe->parameters, p) ;
290 
291  /* --signal_delta */
292  p = cpl_parameter_new_value(PARAM_NAME_SIGNAL_DELTA,
293  CPL_TYPE_DOUBLE, "Change of the signal for the next plane inside a cube", RECIPE_NAME, SIGNAL_DELTA) ;
294  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "total_signal_delta") ;
295  cpl_parameterlist_append(recipe->parameters, p) ;
296 
297  /* --defect_x */
298  p = cpl_parameter_new_value(PARAM_NAME_DEFECT_X,
299  CPL_TYPE_INT, "X position of the bad pixel", RECIPE_NAME, DEFECT_X) ;
300  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "defect_x") ;
301  cpl_parameterlist_append(recipe->parameters, p) ;
302 
303  /* --defect_x */
304  p = cpl_parameter_new_value(PARAM_NAME_DEFECT_Y,
305  CPL_TYPE_INT, "Y position of the bad pixel", RECIPE_NAME, DEFECT_Y) ;
306  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "defect_y") ;
307  cpl_parameterlist_append(recipe->parameters, p) ;
308 
309  /* --defect_signal */
310  p = cpl_parameter_new_value(PARAM_NAME_DEFECT_SIGNAL,
311  CPL_TYPE_DOUBLE, "signal value of the bad pixel", RECIPE_NAME, DEFECT_SIGNAL) ;
312  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "defect_signal") ;
313  cpl_parameterlist_append(recipe->parameters, p) ;
314 
315  /* --defect_number */
316  p = cpl_parameter_new_value(PARAM_NAME_DEFECT_NUMBER,
317  CPL_TYPE_INT, "Number of planes in a cube with a bad pixel", RECIPE_NAME, DEFECT_NUMBER) ;
318  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "defect_number") ;
319  cpl_parameterlist_append(recipe->parameters, p) ;
320 
321  /* Return */
322  return 0;
323 }
324 
325 /*---------------------------------------------------------------------------*/
331 /*---------------------------------------------------------------------------*/
332 static int sinfo_utl_ima_cube_ks_test_exec(cpl_plugin * plugin)
333 {
334  cpl_recipe * recipe ;
335  int code=0;
336  cpl_errorstate initial_errorstate = cpl_errorstate_get();
337 
338  /* Get the recipe out of the plugin */
339  if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
340  recipe = (cpl_recipe *)plugin ;
341  else return -1 ;
342  cpl_error_reset();
343  irplib_reset();
344  code = sinfo_utl_ima_cube_ks_test(recipe->parameters, recipe->frames) ;
345 
346 
347  if (!cpl_errorstate_is_equal(initial_errorstate)) {
348  /* Dump the error history since recipe execution start.
349  At this point the recipe cannot recover from the error */
350  cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);
351  }
352 
353  return code ;
354 }
355 
356 /*---------------------------------------------------------------------------*/
362 /*---------------------------------------------------------------------------*/
363 static int sinfo_utl_ima_cube_ks_test_destroy(cpl_plugin * plugin)
364 {
365  cpl_recipe * recipe ;
366 
367  /* Get the recipe out of the plugin */
368  if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
369  recipe = (cpl_recipe *)plugin ;
370  else return -1 ;
371 
372  cpl_parameterlist_delete(recipe->parameters) ;
373  return 0 ;
374 }
375 
376 /*---------------------------------------------------------------------------*/
383 /*---------------------------------------------------------------------------*/
384 static int
385 sinfo_utl_ima_cube_ks_test( cpl_parameterlist * parlist,
386  cpl_frameset * framelist)
387 {
388  // parameters
389  int iSizeX = 0;
390  int iSizeY = 0;
391  int iFWHMX = 0;
392  int iFWHMY = 0;
393  int iGlobalSizeX = 0;
394  int iGlobalSizeY = 0;
395  int shiftMultX = 2;
396  int shiftMultY = 2;
397  int* pOffsetX = NULL;
398  int* pOffsetY = NULL;
399  double dSignal = 0;
400  double dBkgSignal = 0;
401  double dNoiseLvl = 0;
402 
403  double dSignalDelta = 0;
404  int iDefectX = 0;
405  int iDefectY = 0;
406  double dDefectValue = 0;
407  int iDefectNumber = 0;
408  int iCubesNumber = 0;
409  int iPlanesNumber = 0;
411  int z = 0;
412  int x = 0;
413  int y = 0;
414  const double kappa = 3;
415  const char * name_o = NULL ;
416  cpl_parameter * param = NULL ;
417  cpl_propertylist * plist = NULL ;
418  cpl_frame * product_frame = NULL;
419  cpl_imagelist ** ppCubes = NULL;
420  cpl_imagelist * pResult = NULL;
421  double * exptimes = NULL;
422  cpl_imagelist * mask = NULL;
423  sinfo_msg("Welcome to SINFONI Pipeline release %d.%d.%d",
424  SINFONI_MAJOR_VERSION,SINFONI_MINOR_VERSION,SINFONI_MICRO_VERSION);
425  ck0(sinfo_dfs_set_groups(framelist),"Cannot indentify RAW and CALIB frames");
426 
427 
428  /* HOW TO RETRIEVE INPUT PARAMETERS */
429  /* --size_x */
430  check_nomsg(param=cpl_parameterlist_find(parlist,
431  PARAM_NAME_SIZE_X));
432  check_nomsg(iSizeX=cpl_parameter_get_int(param));
433 
434  /* --size_y */
435  check_nomsg(param=cpl_parameterlist_find(parlist,
436  PARAM_NAME_SIZE_Y));
437  check_nomsg(iSizeY=cpl_parameter_get_int(param));
438 
439  /* --fwhm_x */
440  check_nomsg(param=cpl_parameterlist_find(parlist,
441  PARAM_NAME_FWHM_X));
442  check_nomsg(iFWHMX=cpl_parameter_get_int(param));
443 
444  /* --fwhm_y */
445  check_nomsg(param=cpl_parameterlist_find(parlist,
446  PARAM_NAME_FWHM_Y));
447  check_nomsg(iFWHMY=cpl_parameter_get_int(param));
448 
449  /* --total_signal */
450  check_nomsg(param=cpl_parameterlist_find(parlist,
451  PARAM_NAME_SIGNAL));
452  check_nomsg(dSignal=cpl_parameter_get_double(param));
453 
454  /* --bkg_signal */
455  check_nomsg(param=cpl_parameterlist_find(parlist,
456  PARAM_NAME_BKGSIG));
457  check_nomsg(dBkgSignal=cpl_parameter_get_double(param));
458 
459  /* --noise_level */
460  check_nomsg(param=cpl_parameterlist_find(parlist,
461  PARAM_NAME_NOISEL));
462  check_nomsg(dNoiseLvl=cpl_parameter_get_double(param));
463 
464  /* --cubes_number */
465  check_nomsg(param=cpl_parameterlist_find(parlist,
466  PARAM_NAME_CUBES_NUMBER));
467  check_nomsg(iCubesNumber=cpl_parameter_get_int(param));
468 
469  /* --planes_number */
470  check_nomsg(param=cpl_parameterlist_find(parlist,
471  PARAM_NAME_PLANES_NUMBER));
472  check_nomsg(iPlanesNumber=cpl_parameter_get_int(param));
473 
474  /* -signal_delta */
475  check_nomsg(param=cpl_parameterlist_find(parlist,
476  PARAM_NAME_SIGNAL_DELTA));
477  check_nomsg(dSignalDelta=cpl_parameter_get_double(param));
478 
479  /* --defect_x */
480  check_nomsg(param=cpl_parameterlist_find(parlist,
481  PARAM_NAME_DEFECT_X));
482  check_nomsg(iDefectX=cpl_parameter_get_int(param));
483 
484  /* --defect_y */
485  check_nomsg(param=cpl_parameterlist_find(parlist,
486  PARAM_NAME_DEFECT_Y));
487  check_nomsg(iDefectY=cpl_parameter_get_int(param));
488 
489  /* --defect_value */
490  check_nomsg(param=cpl_parameterlist_find(parlist,
491  PARAM_NAME_DEFECT_SIGNAL));
492  check_nomsg(dDefectValue=cpl_parameter_get_double(param));
493 
494  /* --defect_number */
495  check_nomsg(param=cpl_parameterlist_find(parlist,
496  PARAM_NAME_DEFECT_NUMBER));
497  check_nomsg(iDefectNumber=cpl_parameter_get_int(param));
498 
499 
500  /* HOW TO GET THE VALUE OF A FITS KEYWORD */
501  check(plist=cpl_propertylist_new(),"Cannot create a Property List");
502 
503  /* Now performing the data reduction */
504  /* Let's generate one image for the example */
505 
506  // 1. Create cubes
507  ppCubes = (cpl_imagelist**)cpl_malloc(sizeof(cpl_imagelist*) * (iCubesNumber + 2)); // +1 for the result, +1 for the mask
508  pOffsetX = cpl_malloc(sizeof(int) * iCubesNumber);
509  pOffsetY = cpl_malloc(sizeof(int) * iCubesNumber);
510  // iGlobalSizeX = iSizeX + (iCubesNumber-1) * shiftMultX;// it's not a fair calculation - only for test
511  // iGlobalSizeY = iSizeY + (iCubesNumber-1) * shiftMultY;
512  sinfo_msg("Creating cubes....");
513  for (z = 0; z < iCubesNumber; z++)
514  {
515  pOffsetX[z] = shiftMultX*z;// + ((z%3) - 3) * shiftMultX ;
516  pOffsetY[z] = shiftMultY*z;// + (((z-2)%3) - 1) * shiftMultY / 2;
517  cpl_msg_warning(cpl_func, "cube [%d] offset[%d:%d]", z,pOffsetX[z], pOffsetY[z] );
518  cpl_imagelist* pCube =
519  create_cube_shift(
520  iSizeX,
521  iSizeY,
522  iPlanesNumber,
523  iFWHMX,
524  iFWHMY,
525  -pOffsetX[z],
526  -pOffsetY[z],
527  dSignal,
528  dBkgSignal,
529  dNoiseLvl,
530  dSignalDelta,
531  iDefectX,
532  iDefectY,
533  (z < iDefectNumber) ? dDefectValue : 0,
534  0
535  );
536  ppCubes[z] = pCube;
537 
538  // fill NAN areas
539  /* cpl_image* pImage = cpl_imagelist_get(pCube, 0);
540  switch(z)
541  {
542  case 0:
543  {
544  for (x = 1; x <=iSizeX; x++)
545  {
546  for (y = 1; y <= 16; y++)
547  {
548  check_nomsg(cpl_image_set(pImage, x, y, sqrt(-1)));
549  check_nomsg(cpl_image_set(pImage, x, y+48, sqrt(-1)));
550  }
551  }
552  }
553  break;
554  case 1:
555  {
556  for (x = 1; x <=iSizeX; x++)
557  {
558  for (y = 1; y <= 8; y++)
559  {
560  check_nomsg(cpl_image_set(pImage, x, y, sqrt(-1)));
561  }
562  for (y = 24; y <= iSizeY; y++)
563  {
564  check_nomsg(cpl_image_set(pImage, x, y, sqrt(-1)));
565 
566  }
567  }
568  }
569  break;
570  }
571  */
572  }
573  // 2. make a kappa-sigma clipping
574  /* pResult = kappa_sigma(
575  iSizeX,
576  iSizeY,
577  iCubesNumber,
578  iPlanesNumber,
579  kappa,
580  NULL,
581  ppCubes);*/
582 
583  // prepare offset arrays
584  sinfo_msg("Kappa-sigma....");
585 
586  // determine size of the coadded cube
587  const int BIG_ENOUGH_INT = 65535;
588  int xmax = -BIG_ENOUGH_INT;
589  int ymax = -BIG_ENOUGH_INT;
590  int xmin = BIG_ENOUGH_INT;
591  int ymin = BIG_ENOUGH_INT;
592  for (z = 0; z < iCubesNumber; z++)
593  {
594 
595  int localMaxX = iSizeX + pOffsetX[z];
596  int localMaxY = iSizeY + pOffsetY[z];
597  int localMinX = pOffsetX[z];
598  int localMinY = pOffsetY[z];
599 
600  if(localMaxX > xmax) xmax = localMaxX;
601  if(localMaxY > ymax) ymax = localMaxY;
602 
603  if(localMinX < xmin) xmin = localMinX;
604  if(localMinY < ymin) ymin = localMinY;
605  }
606 
607  iGlobalSizeX = xmax - xmin;
608  iGlobalSizeY = ymax - ymin;
609  cpl_msg_warning(cpl_func, "iGlobalSize[%d:%d] xmaxmin[%d:%d] ymaxmin[%d:%d]", iGlobalSizeX, iGlobalSizeY, xmin, xmax, ymin, ymax);
610  pResult = cpl_imagelist_new();
611  exptimes = cpl_malloc(sizeof(double) * iCubesNumber);
612  for (z = 0; z < iCubesNumber; z++)
613  {
614  exptimes[z] = 10.;
615  }
616  mask= cpl_imagelist_new();
617  for (z = 0; z < iPlanesNumber; z++)
618  {
619  cpl_image* imMask = cpl_image_new(iGlobalSizeX, iGlobalSizeY, CPL_TYPE_FLOAT);
620  cpl_image* imResult = cpl_image_new(iGlobalSizeX, iGlobalSizeY, CPL_TYPE_FLOAT);
621  for (x = 1; x <= iGlobalSizeX; x++)
622  {
623  for (y = 1; y <= iGlobalSizeY; y++)
624  {
625  cpl_image_set(imMask, x, y, 100);
626  }
627  }
628  cpl_imagelist_set(mask, imMask, z);
629  cpl_imagelist_set(pResult, imResult, z);
630  }
631 
632  sinfo_coadd_with_ks_clip_optimized(
633  0,
634  iPlanesNumber,
635  iSizeX,
636  iSizeY,
637  iCubesNumber,
638  kappa,
639  pOffsetX,
640  pOffsetY,
641  exptimes,
642  mask,
643  pResult,
644  ppCubes);
645  // pResult = kappa_sigma_offset(iGlobalSizeX, iGlobalSizeY, iCubesNumber, ppCubes, iCubesNumber, pOffsetY, kappa);
646 
647 
648 
649  sinfo_msg("Saving results");
650  ppCubes[iCubesNumber] = pResult;
651  ppCubes[iCubesNumber + 1] = mask;
652 
653  /* HOW TO SAVE A PRODUCT ON DISK */
654  /* Set the file name */
655  name_o = "ima_res_0000.fits" ;
656 
657  /* Create product frame */
658  check_nomsg(product_frame = cpl_frame_new());
659  check_nomsg(cpl_frame_set_filename(product_frame, name_o)) ;
660  check_nomsg(cpl_frame_set_tag(product_frame,"image_gauss" )) ;
661  check_nomsg(cpl_frame_set_type(product_frame, CPL_FRAME_TYPE_IMAGE)) ;
662  check_nomsg(cpl_frame_set_group(product_frame, CPL_FRAME_GROUP_PRODUCT)) ;
663  check(cpl_frame_set_level(product_frame, CPL_FRAME_LEVEL_FINAL),
664  "Error while initialising the product frame") ;
665 
666  /* Add DataFlow keywords */
667  check_nomsg(cpl_propertylist_erase_regexp(plist, "^ESO PRO CATG",0));
668  // cpl_frameset_dump(framelist, stdout);
669  check(cpl_dfs_setup_product_header(plist,
670  product_frame,
671  framelist,
672  parlist,
673  "sinfo_utl_ima_cube_ks_test",
674  "SINFONI",
675  KEY_VALUE_HPRO_DID,NULL),
676  "Problem in the product DFS-compliance") ;
677 
678  /* Save the input images file */
679 
680  for (z = 0; z <= iCubesNumber + 1; z++) // the last imagelist is result after kappa-sigma, the very last is the mask
681  {
682  char BUF[256];
683  sprintf(BUF,"out_cube_%d.fits",z);
684  sinfo_msg("Saving results cube[%d]",z);
685  check(cpl_imagelist_save(ppCubes[z],
686  BUF,
687  CPL_BPP_IEEE_FLOAT,
688  plist,
689  CPL_IO_DEFAULT),
690  "Could not save product");
691 
692  ck0(sinfo_pro_save_ims(ppCubes[z],framelist,framelist,BUF,"CUBE",NULL,
693  "sinfo_utl_ima_cube_ks_ex",parlist),
694  "cannot save cube %s", BUF);
695  }
696 
697  sinfo_free_propertylist(&plist) ;
698  /* Log the saved file in the input frameset */
699  check_nomsg(cpl_frameset_insert(framelist, product_frame)) ;
700 
701 
702  cleanup:
703 
704  // sinfo_free_frameset(&raw_set);
705  sinfo_free_propertylist(&plist) ;
706  for (z = 0; z <= iCubesNumber + 1; z++) // the last imagelist is result after kappa-sigma, the very last is the mask
707  {
708  cpl_imagelist_delete(ppCubes[z]);
709  }
710  cpl_free(ppCubes);
711  /* This is usually freed by esorex: but what about if errors occurs?
712  sinfo_free_frame(&product_frame) ;
713  */
714 
715  return cpl_error_get_code() ? -1 : 0;
716 
717 }
718 cpl_imagelist* create_cube_shift(
719  int iSizeX,
720  int iSizeY,
721  int iPlanesNumber,
722  int iFWHMX,
723  int iFWHMY,
724  int shiftX,
725  int shiftY,
726  double dSignal,
727  double dBkgSignal,
728  double dNoiseLvl,
729  double dSignalDelta,
730  int iDefectX,
731  int iDefectY,
732  double dDefectValue,
733  int type
734 )
735 {
736  int z = 0;
737  cpl_image* pPlane = NULL;
738  cpl_imagelist* pRetval = NULL;
739  pRetval = cpl_imagelist_new();
740 
741  for (z = 0; z < iPlanesNumber; z++)
742  {
743  double dSignalValue = dSignal + z * dSignalDelta;
744  switch (type)
745  {
746  case 0:
747  pPlane = create_plane(
748  iSizeX,
749  iSizeY,
750  iFWHMX,
751  iFWHMY,
752  shiftX,
753  shiftY,
754  dSignalValue,
755  dBkgSignal,
756  dNoiseLvl
757  );
758  break;
759  case 1:
760  pPlane = create_square_plane(
761  iSizeX,
762  iSizeY,
763  iFWHMX,
764  iFWHMY,
765  shiftX,
766  shiftY,
767  dSignalValue,
768  dBkgSignal,
769  dNoiseLvl
770  );
771  break;
772  }
773 
774 
775  if (dDefectValue)
776  {
777  put_defect(pPlane, iDefectX, iDefectY, dDefectValue);
778  }
779  putNAN(pPlane, iDefectX + shiftX, iDefectY + shiftY);
780  cpl_imagelist_set(pRetval, pPlane, z);
781  }
782  return pRetval;
783 }
784 cpl_image* create_plane(
785  int iSizeX,
786  int iSizeY,
787  int iFWHMX,
788  int iFWHMY,
789  int shiftX,
790  int shiftY,
791  double dSignal,
792  double dBkgSignal,
793  double dNoiseLvl
794 )
795 {
796  cpl_image* imNoise = NULL;
797  cpl_image* imGauss = NULL;
798  cpl_image* imResult = NULL;
799  const double K = 2.35482;//1. / (2. * sqrt(2.* ln(2.)));
800 
801  imNoise = cpl_image_new(iSizeX, iSizeY, CPL_TYPE_FLOAT);
802  cpl_image_fill_noise_uniform(imNoise, dBkgSignal - dNoiseLvl, dBkgSignal + dNoiseLvl);
803  imGauss = cpl_image_new(iSizeX, iSizeY, CPL_TYPE_FLOAT);
804  sinfo_msg("Generate Gaussian center[%d:%d] signal[%f], sigma[%f:%f]", iSizeX/2 + shiftX, iSizeY/2 + shiftY, dSignal, iFWHMX / K, iFWHMY / K);
805  cpl_image_fill_gaussian(imGauss, iSizeX/2 + shiftX, iSizeY/2 + shiftY, dSignal, iFWHMX / K, iFWHMY / K);
806  imResult = cpl_image_add_create(imGauss, imNoise);
807 
808  // cleanup
809  if (imNoise)
810  {
811  cpl_image_delete(imNoise);
812  imNoise = 0;
813  }
814  if (imGauss)
815  {
816  cpl_image_delete(imGauss);
817  imGauss = 0;
818  }
819  return imResult;
820 }
821 cpl_image* create_square_plane(
822  int iSizeX,
823  int iSizeY,
824  int iHoleX,
825  int iHoleY,
826  int shiftX,
827  int shiftY,
828  double dSignal,
829  double dBkgSignal,
830  double dNoiseLvl
831 )
832 {
833  cpl_image* imNoise = NULL;
834  cpl_image* imHole = NULL;
835  cpl_image* imResult = NULL;
836  int x = 0;
837  int y = 0;
838  int xHoleInitial = 0;
839  int yHoleInitial = 0;
840  imNoise = cpl_image_new(iSizeX, iSizeY, CPL_TYPE_FLOAT);
841  cpl_image_fill_noise_uniform(imNoise, dBkgSignal - dNoiseLvl, dBkgSignal + dNoiseLvl);
842  imHole = cpl_image_new(iSizeX, iSizeY, CPL_TYPE_FLOAT);
843  xHoleInitial = iSizeX / 2 - iHoleX / 2;
844  yHoleInitial = iSizeY / 2 - iHoleY / 2;
845  for (x = 0; x <= iHoleX; x++)
846  {
847  for (y = 0; y <= iHoleY; y++)
848  {
849  int pX = x + xHoleInitial + shiftX ;
850  int pY = y + yHoleInitial + shiftY;
851  if ((pX <= iSizeX) &&(pY <= iSizeY))
852  cpl_image_set(imHole, pX,pY, dSignal);
853  }
854  }
855  //cpl_image_fill_gaussian(imGauss, iSizeX/2 + shiftX, iSizeY/2 + shiftY, dSignal, iFWHMX / K, iFWHMY / K);
856  imResult = cpl_image_add_create(imHole, imNoise);
857 
858  // cleanup
859  if (imNoise)
860  {
861  cpl_image_delete(imNoise);
862  imNoise = 0;
863  }
864  if (imHole)
865  {
866  cpl_image_delete(imHole);
867  imHole = 0;
868  }
869  return imResult;
870 }
871 int put_defect(cpl_image *pPlane, int iDefectX, int iDefectY, double dDefectValue)
872 {
873  sinfo_msg("Set bad pixel x[%d] y[%d] value[%f]", iDefectX, iDefectY, dDefectValue);
874  if (pPlane)
875  {
876  cpl_image_set(pPlane, iDefectX, iDefectY, dDefectValue);
877  cpl_image_set(pPlane, iDefectX+1, iDefectY+1, dDefectValue);
878  cpl_image_set(pPlane, iDefectX-1, iDefectY-1, dDefectValue);
879  cpl_image_set(pPlane, iDefectX+1, iDefectY-1, dDefectValue);
880  cpl_image_set(pPlane, iDefectX-1, iDefectY+1, dDefectValue);
881  }
882  return 0;
883 }
884 
885 void putNAN(cpl_image *pPlane, int iDefectX, int iDefectY)
886 {
887  cpl_image_set(pPlane, iDefectX, iDefectY, ZERO);
888 }
889