MUSE Pipeline Reference Manual  2.1.1
muse_exp_align_z.c
1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim:set sw=2 sts=2 et cin: */
3 /*
4  * This file is part of the MUSE Instrument Pipeline
5  * Copyright (C) 2005-2015 European Southern Observatory
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20  */
21 
22 /* This file was automatically generated */
23 
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27 
28 /*----------------------------------------------------------------------------*
29  * Includes *
30  *----------------------------------------------------------------------------*/
31 #include <string.h> /* strcmp(), strstr() */
32 #include <strings.h> /* strcasecmp() */
33 #include <cpl.h>
34 
35 #include "muse_exp_align_z.h" /* in turn includes muse.h */
36 
37 /*----------------------------------------------------------------------------*/
48 /*----------------------------------------------------------------------------*/
51 /*----------------------------------------------------------------------------*
52  * Static variables *
53  *----------------------------------------------------------------------------*/
54 static const char *muse_exp_align_help =
55  "Compute the coordinate offset for each input field-of-view image with respect to a reference. The created list of coordinate offsets can then be used in muse_exp_combine as the field coordinate offsets to properly align the exposures during their combination.";
56 
57 static const char *muse_exp_align_help_esorex =
58  "\n\nInput frames for raw frame tag \"IMAGE_FOV\":\n"
59  "\n Frame tag Type Req #Fr Description"
60  "\n -------------------- ---- --- --- ------------"
61  "\n IMAGE_FOV raw Y >=2 Input field-of-view images"
62  "\n\nProduct frames for raw frame tag \"IMAGE_FOV\":\n"
63  "\n Frame tag Level Description"
64  "\n -------------------- -------- ------------"
65  "\n OFFSET_LIST final List of computed coordinate offsets.";
66 
67 /*----------------------------------------------------------------------------*/
75 /*----------------------------------------------------------------------------*/
76 static cpl_recipeconfig *
77 muse_exp_align_new_recipeconfig(void)
78 {
79  cpl_recipeconfig *recipeconfig = cpl_recipeconfig_new();
80 
81  cpl_recipeconfig_set_tag(recipeconfig, "IMAGE_FOV", 2, -1);
82  cpl_recipeconfig_set_output(recipeconfig, "IMAGE_FOV", "OFFSET_LIST");
83 
84  return recipeconfig;
85 } /* muse_exp_align_new_recipeconfig() */
86 
87 /*----------------------------------------------------------------------------*/
97 /*----------------------------------------------------------------------------*/
98 static cpl_error_code
99 muse_exp_align_prepare_header(const char *aFrametag, cpl_propertylist *aHeader)
100 {
101  cpl_ensure_code(aFrametag, CPL_ERROR_NULL_INPUT);
102  cpl_ensure_code(aHeader, CPL_ERROR_NULL_INPUT);
103  if (!strcmp(aFrametag, "OFFSET_LIST")) {
104  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN NDET[0-9]+",
105  CPL_TYPE_INT,
106  "Number of detected sources for input image i");
107  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN NMATCH[0-9]+",
108  CPL_TYPE_INT,
109  "Median number of matches of input image i with other images");
110  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN NMATCH MIN",
111  CPL_TYPE_INT,
112  "Minimum of the median number of matches for all input images");
113  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN NOMATCH",
114  CPL_TYPE_INT,
115  "Number of input images that do not have any matches with other images");
116  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN OFFSET RA MIN",
117  CPL_TYPE_DOUBLE,
118  "[arcsec] RA minimum offset.");
119  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN OFFSET RA MAX",
120  CPL_TYPE_DOUBLE,
121  "[arcsec] RA maximum offset.");
122  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN OFFSET RA MEAN",
123  CPL_TYPE_DOUBLE,
124  "[arcsec] RA mean offset.");
125  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN OFFSET RA STDEV",
126  CPL_TYPE_DOUBLE,
127  "[arcsec] Standard deviation of RA offsets.");
128  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN OFFSET DEC MIN",
129  CPL_TYPE_DOUBLE,
130  "[arcsec] DEC minimum offset.");
131  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN OFFSET DEC MAX",
132  CPL_TYPE_DOUBLE,
133  "[arcsec] DEC maximum offset.");
134  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN OFFSET DEC MEAN",
135  CPL_TYPE_DOUBLE,
136  "[arcsec] DEC mean offset.");
137  muse_processing_prepare_property(aHeader, "ESO QC EXPALIGN OFFSET DEC STDEV",
138  CPL_TYPE_DOUBLE,
139  "[arcsec] Standard deviation of DEC offsets.");
140  } else {
141  cpl_msg_warning(__func__, "Frame tag %s is not defined", aFrametag);
142  return CPL_ERROR_ILLEGAL_INPUT;
143  }
144  return CPL_ERROR_NONE;
145 } /* muse_exp_align_prepare_header() */
146 
147 /*----------------------------------------------------------------------------*/
156 /*----------------------------------------------------------------------------*/
157 static cpl_frame_level
158 muse_exp_align_get_frame_level(const char *aFrametag)
159 {
160  if (!aFrametag) {
161  return CPL_FRAME_LEVEL_NONE;
162  }
163  if (!strcmp(aFrametag, "OFFSET_LIST")) {
164  return CPL_FRAME_LEVEL_FINAL;
165  }
166  return CPL_FRAME_LEVEL_NONE;
167 } /* muse_exp_align_get_frame_level() */
168 
169 /*----------------------------------------------------------------------------*/
178 /*----------------------------------------------------------------------------*/
179 static muse_frame_mode
180 muse_exp_align_get_frame_mode(const char *aFrametag)
181 {
182  if (!aFrametag) {
183  return MUSE_FRAME_MODE_ALL;
184  }
185  if (!strcmp(aFrametag, "OFFSET_LIST")) {
186  return MUSE_FRAME_MODE_MASTER;
187  }
188  return MUSE_FRAME_MODE_ALL;
189 } /* muse_exp_align_get_frame_mode() */
190 
191 /*----------------------------------------------------------------------------*/
201 /*----------------------------------------------------------------------------*/
202 static int
203 muse_exp_align_create(cpl_plugin *aPlugin)
204 {
205  /* Check that the plugin is part of a valid recipe */
206  cpl_recipe *recipe;
207  if (cpl_plugin_get_type(aPlugin) == CPL_PLUGIN_TYPE_RECIPE) {
208  recipe = (cpl_recipe *)aPlugin;
209  } else {
210  return -1;
211  }
212 
213  /* register the extended processing information (new FITS header creation, *
214  * getting of the frame level for a certain tag) */
216  muse_exp_align_new_recipeconfig(),
217  muse_exp_align_prepare_header,
218  muse_exp_align_get_frame_level,
219  muse_exp_align_get_frame_mode);
220 
221  /* XXX initialize timing in messages *
222  * since at least esorex is too stupid to turn it on, we have to do it */
224  cpl_msg_set_time_on();
225  }
226 
227  /* Create the parameter list in the cpl_recipe object */
228  recipe->parameters = cpl_parameterlist_new();
229  /* Fill the parameters list */
230  cpl_parameter *p;
231 
232  /* --rsearch:
233  Search radius (in arcsec) for each iteration of the offset computation.
234  */
235  p = cpl_parameter_new_value("muse.muse_exp_align.rsearch",
236  CPL_TYPE_STRING,
237  "Search radius (in arcsec) for each iteration of the offset computation.",
238  "muse.muse_exp_align",
239  (const char *)"30.,4.,2.,0.8");
240  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "rsearch");
241  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "rsearch");
242 
243  cpl_parameterlist_append(recipe->parameters, p);
244 
245  /* --nbins:
246  Number of bins to use for 2D histogram on the first iteration of the
247  offset computation.
248  */
249  p = cpl_parameter_new_value("muse.muse_exp_align.nbins",
250  CPL_TYPE_INT,
251  "Number of bins to use for 2D histogram on the first iteration of the offset computation.",
252  "muse.muse_exp_align",
253  (int)60);
254  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "nbins");
255  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "nbins");
256 
257  cpl_parameterlist_append(recipe->parameters, p);
258 
259  /* --weight: Use weighting. */
260  p = cpl_parameter_new_value("muse.muse_exp_align.weight",
261  CPL_TYPE_BOOL,
262  "Use weighting.",
263  "muse.muse_exp_align",
264  (int)TRUE);
265  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "weight");
266  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "weight");
267 
268  cpl_parameterlist_append(recipe->parameters, p);
269 
270  /* --fwhm: FWHM in pixels of the convolution filter. */
271  p = cpl_parameter_new_value("muse.muse_exp_align.fwhm",
272  CPL_TYPE_DOUBLE,
273  "FWHM in pixels of the convolution filter.",
274  "muse.muse_exp_align",
275  (double)5.);
276  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "fwhm");
277  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "fwhm");
278 
279  cpl_parameterlist_append(recipe->parameters, p);
280 
281  /* --threshold:
282  Initial intensity threshold for detecting point sources in sigma
283  above background RMS.
284  */
285  p = cpl_parameter_new_value("muse.muse_exp_align.threshold",
286  CPL_TYPE_DOUBLE,
287  "Initial intensity threshold for detecting point sources in sigma above background RMS.",
288  "muse.muse_exp_align",
289  (double)15.);
290  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "threshold");
291  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "threshold");
292 
293  cpl_parameterlist_append(recipe->parameters, p);
294 
295  /* --step: Increment/decrement of the threshold value in subsequent iterations. */
296  p = cpl_parameter_new_value("muse.muse_exp_align.step",
297  CPL_TYPE_DOUBLE,
298  "Increment/decrement of the threshold value in subsequent iterations.",
299  "muse.muse_exp_align",
300  (double)0.5);
301  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "step");
302  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "step");
303 
304  cpl_parameterlist_append(recipe->parameters, p);
305 
306  /* --iterations: Maximum number of iterations used for detecting sources. */
307  p = cpl_parameter_new_value("muse.muse_exp_align.iterations",
308  CPL_TYPE_INT,
309  "Maximum number of iterations used for detecting sources.",
310  "muse.muse_exp_align",
311  (int)100000);
312  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "iterations");
313  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "iterations");
314 
315  cpl_parameterlist_append(recipe->parameters, p);
316 
317  /* --srcmin: Minimum number of sources which must be found. */
318  p = cpl_parameter_new_value("muse.muse_exp_align.srcmin",
319  CPL_TYPE_INT,
320  "Minimum number of sources which must be found.",
321  "muse.muse_exp_align",
322  (int)5);
323  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "srcmin");
324  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "srcmin");
325 
326  cpl_parameterlist_append(recipe->parameters, p);
327 
328  /* --srcmax: Maximum number of sources which may be found. */
329  p = cpl_parameter_new_value("muse.muse_exp_align.srcmax",
330  CPL_TYPE_INT,
331  "Maximum number of sources which may be found.",
332  "muse.muse_exp_align",
333  (int)80);
334  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "srcmax");
335  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "srcmax");
336 
337  cpl_parameterlist_append(recipe->parameters, p);
338 
339  /* --roundmin: Lower limit of the allowed point-source roundness. */
340  p = cpl_parameter_new_value("muse.muse_exp_align.roundmin",
341  CPL_TYPE_DOUBLE,
342  "Lower limit of the allowed point-source roundness.",
343  "muse.muse_exp_align",
344  (double)-1.);
345  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "roundmin");
346  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "roundmin");
347 
348  cpl_parameterlist_append(recipe->parameters, p);
349 
350  /* --roundmax: Upper limit of the allowed point-source roundness. */
351  p = cpl_parameter_new_value("muse.muse_exp_align.roundmax",
352  CPL_TYPE_DOUBLE,
353  "Upper limit of the allowed point-source roundness.",
354  "muse.muse_exp_align",
355  (double)1.);
356  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "roundmax");
357  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "roundmax");
358 
359  cpl_parameterlist_append(recipe->parameters, p);
360 
361  /* --sharpmin: Lower limit of the allowed point-source sharpness. */
362  p = cpl_parameter_new_value("muse.muse_exp_align.sharpmin",
363  CPL_TYPE_DOUBLE,
364  "Lower limit of the allowed point-source sharpness.",
365  "muse.muse_exp_align",
366  (double)0.2);
367  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "sharpmin");
368  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sharpmin");
369 
370  cpl_parameterlist_append(recipe->parameters, p);
371 
372  /* --sharpmax: Upper limit of the allowed point-source sharpness. */
373  p = cpl_parameter_new_value("muse.muse_exp_align.sharpmax",
374  CPL_TYPE_DOUBLE,
375  "Upper limit of the allowed point-source sharpness.",
376  "muse.muse_exp_align",
377  (double)1.);
378  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "sharpmax");
379  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sharpmax");
380 
381  cpl_parameterlist_append(recipe->parameters, p);
382 
383  return 0;
384 } /* muse_exp_align_create() */
385 
386 /*----------------------------------------------------------------------------*/
397 /*----------------------------------------------------------------------------*/
398 static int
399 muse_exp_align_params_fill(muse_exp_align_params_t *aParams, cpl_parameterlist *aParameters)
400 {
401  cpl_ensure_code(aParams, CPL_ERROR_NULL_INPUT);
402  cpl_ensure_code(aParameters, CPL_ERROR_NULL_INPUT);
403  cpl_parameter *p;
404 
405  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.rsearch");
406  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
407  aParams->rsearch = cpl_parameter_get_string(p);
408 
409  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.nbins");
410  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
411  aParams->nbins = cpl_parameter_get_int(p);
412 
413  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.weight");
414  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
415  aParams->weight = cpl_parameter_get_bool(p);
416 
417  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.fwhm");
418  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
419  aParams->fwhm = cpl_parameter_get_double(p);
420 
421  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.threshold");
422  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
423  aParams->threshold = cpl_parameter_get_double(p);
424 
425  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.step");
426  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
427  aParams->step = cpl_parameter_get_double(p);
428 
429  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.iterations");
430  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
431  aParams->iterations = cpl_parameter_get_int(p);
432 
433  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.srcmin");
434  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
435  aParams->srcmin = cpl_parameter_get_int(p);
436 
437  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.srcmax");
438  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
439  aParams->srcmax = cpl_parameter_get_int(p);
440 
441  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.roundmin");
442  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
443  aParams->roundmin = cpl_parameter_get_double(p);
444 
445  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.roundmax");
446  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
447  aParams->roundmax = cpl_parameter_get_double(p);
448 
449  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.sharpmin");
450  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
451  aParams->sharpmin = cpl_parameter_get_double(p);
452 
453  p = cpl_parameterlist_find(aParameters, "muse.muse_exp_align.sharpmax");
454  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
455  aParams->sharpmax = cpl_parameter_get_double(p);
456 
457  return 0;
458 } /* muse_exp_align_params_fill() */
459 
460 /*----------------------------------------------------------------------------*/
467 /*----------------------------------------------------------------------------*/
468 static int
469 muse_exp_align_exec(cpl_plugin *aPlugin)
470 {
471  if (cpl_plugin_get_type(aPlugin) != CPL_PLUGIN_TYPE_RECIPE) {
472  return -1;
473  }
475  cpl_recipe *recipe = (cpl_recipe *)aPlugin;
476  cpl_msg_set_threadid_on();
477 
478  cpl_frameset *usedframes = cpl_frameset_new(),
479  *outframes = cpl_frameset_new();
481  muse_exp_align_params_fill(&params, recipe->parameters);
482 
483  cpl_errorstate prestate = cpl_errorstate_get();
484 
485  muse_processing *proc = muse_processing_new("muse_exp_align",
486  recipe);
487  int rc = muse_exp_align_compute(proc, &params);
488  cpl_frameset_join(usedframes, proc->usedframes);
489  cpl_frameset_join(outframes, proc->outframes);
491 
492  if (!cpl_errorstate_is_equal(prestate)) {
493  /* dump all errors from this recipe in chronological order */
494  cpl_errorstate_dump(prestate, CPL_FALSE, muse_cplerrorstate_dump_some);
495  /* reset message level to not get the same errors displayed again by esorex */
496  cpl_msg_set_level(CPL_MSG_INFO);
497  }
498  /* clean up duplicates in framesets of used and output frames */
501 
502  /* to get esorex to see our classification (frame groups etc.), *
503  * replace the original frameset with the list of used frames *
504  * before appending product output frames */
505  /* keep the same pointer, so just erase all frames, not delete the frameset */
506  muse_cplframeset_erase_all(recipe->frames);
507  cpl_frameset_join(recipe->frames, usedframes);
508  cpl_frameset_join(recipe->frames, outframes);
509  cpl_frameset_delete(usedframes);
510  cpl_frameset_delete(outframes);
511  return rc;
512 } /* muse_exp_align_exec() */
513 
514 /*----------------------------------------------------------------------------*/
521 /*----------------------------------------------------------------------------*/
522 static int
523 muse_exp_align_destroy(cpl_plugin *aPlugin)
524 {
525  /* Get the recipe from the plugin */
526  cpl_recipe *recipe;
527  if (cpl_plugin_get_type(aPlugin) == CPL_PLUGIN_TYPE_RECIPE) {
528  recipe = (cpl_recipe *)aPlugin;
529  } else {
530  return -1;
531  }
532 
533  /* Clean up */
534  cpl_parameterlist_delete(recipe->parameters);
536  return 0;
537 } /* muse_exp_align_destroy() */
538 
539 /*----------------------------------------------------------------------------*/
549 /*----------------------------------------------------------------------------*/
550 int
551 cpl_plugin_get_info(cpl_pluginlist *aList)
552 {
553  cpl_recipe *recipe = cpl_calloc(1, sizeof *recipe);
554  cpl_plugin *plugin = &recipe->interface;
555 
556  char *helptext;
558  helptext = cpl_sprintf("%s%s", muse_exp_align_help,
559  muse_exp_align_help_esorex);
560  } else {
561  helptext = cpl_sprintf("%s", muse_exp_align_help);
562  }
563 
564  /* Initialize the CPL plugin stuff for this module */
565  cpl_plugin_init(plugin, CPL_PLUGIN_API, MUSE_BINARY_VERSION,
566  CPL_PLUGIN_TYPE_RECIPE,
567  "muse_exp_align",
568  "Create a coordinate offset table to be used to align exposures during exposure combination.",
569  helptext,
570  "Ralf Palsa",
571  "usd-help@eso.org",
573  muse_exp_align_create,
574  muse_exp_align_exec,
575  muse_exp_align_destroy);
576  cpl_pluginlist_append(aList, plugin);
577  cpl_free(helptext);
578 
579  return 0;
580 } /* cpl_plugin_get_info() */
581 
int srcmin
Minimum number of sources which must be found.
void muse_processing_delete(muse_processing *aProcessing)
Free the muse_processing structure.
int weight
Use weighting.
double fwhm
FWHM in pixels of the convolution filter.
muse_cplframework_type muse_cplframework(void)
Return the CPL framework the recipe is run under.
double roundmax
Upper limit of the allowed point-source roundness.
double step
Increment/decrement of the threshold value in subsequent iterations.
cpl_frameset * usedframes
muse_processing * muse_processing_new(const char *aName, cpl_recipe *aRecipe)
Create a new processing structure.
double sharpmax
Upper limit of the allowed point-source sharpness.
const char * muse_get_license(void)
Get the pipeline copyright and license.
Definition: muse_utils.c:83
Structure to hold the parameters of the muse_exp_align recipe.
int srcmax
Maximum number of sources which may be found.
muse_frame_mode
double threshold
Initial intensity threshold for detecting point sources in sigma above background RMS...
cpl_frameset * outframes
int iterations
Maximum number of iterations used for detecting sources.
int nbins
Number of bins to use for 2D histogram on the first iteration of the offset computation.
void muse_cplerrorstate_dump_some(unsigned aCurrent, unsigned aFirst, unsigned aLast)
Dump some CPL errors.
void muse_processinginfo_delete(cpl_recipe *)
Clear all information from the processing info and from the recipe config.
cpl_error_code muse_cplframeset_erase_duplicate(cpl_frameset *aFrames)
Erase all duplicate frames from a frameset.
const char * rsearch
Search radius (in arcsec) for each iteration of the offset computation.
cpl_error_code muse_cplframeset_erase_all(cpl_frameset *aFrames)
Erase all frames in a frameset.
double roundmin
Lower limit of the allowed point-source roundness.
void muse_processinginfo_register(cpl_recipe *, cpl_recipeconfig *, muse_processing_prepare_header_func *, muse_processing_get_frame_level_func *, muse_processing_get_frame_mode_func *)
Register extended functionalities for MUSE recipes.
void muse_processing_recipeinfo(cpl_plugin *)
Output main pipeline configuration, inputs, and parameters.
double sharpmin
Lower limit of the allowed point-source sharpness.
cpl_error_code muse_processing_prepare_property(cpl_propertylist *, const char *, cpl_type, const char *)
Prepare and check the specified property.