MUSE Pipeline Reference Manual  0.18.1
muse_quick_image_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-2013 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_quick_image_z.h" /* in turn includes muse.h */
36 
37 /*----------------------------------------------------------------------------*/
51 /*----------------------------------------------------------------------------*/
54 /*----------------------------------------------------------------------------*
55  * Static variables *
56  *----------------------------------------------------------------------------*/
57 static const char *muse_quick_image_help =
58  "This recipe is designed for quick operation on the instrument workstation, so it does not e.g. take into account spectral curvature on the CCD. This will create some artifacts on the output image, but these will not affect the use of this quick-look image. Selection of the wavelength range is done using the mask image (see Sect. 5.2 of the DRL Design document for a description of the format).";
59 
60 static const char *muse_quick_image_help_esorex =
61  "\n\nInput frames:\n"
62  "\n Frame tag Type Req #Fr Description"
63  "\n -------------------- ---- --- --- ------------"
64  "\n any raw Y Raw exposure"
65  "\n BIAS raw . 1 Raw data taken with zero exposure time and closed shutter"
66  "\n FLAT raw . 1 Raw exposure of a continuum lamp exposure illuminating the whole field of view"
67  "\n MASK_IMAGE calib Y 1 Image masks for quick image reconstruction"
68  "\n\nProduct frames for raw frame tag \"\":\n"
69  "\n Frame tag Level Description"
70  "\n -------------------- -------- ------------"
71  "\n QUICK_IMAGE final Final quick-look image";
72 
73 /*----------------------------------------------------------------------------*/
81 /*----------------------------------------------------------------------------*/
82 static cpl_recipeconfig *
83 muse_quick_image_new_recipeconfig(void)
84 {
85  cpl_recipeconfig *recipeconfig = cpl_recipeconfig_new();
86  const char *tag;
87 
88  tag = "";
89  cpl_recipeconfig_set_tag(recipeconfig, tag, 1, -1);
90  tag = "BIAS";
91  cpl_recipeconfig_set_tag(recipeconfig, tag, -1, 1);
92  tag = "FLAT";
93  cpl_recipeconfig_set_tag(recipeconfig, tag, -1, 1);
94  cpl_recipeconfig_set_input(recipeconfig, tag, "MASK_IMAGE", 1, 1);
95  cpl_recipeconfig_set_output(recipeconfig, tag, "QUICK_IMAGE");
96 
97  return recipeconfig;
98 } /* muse_quick_image_new_recipeconfig() */
99 
100 /*----------------------------------------------------------------------------*/
110 /*----------------------------------------------------------------------------*/
111 static cpl_error_code
112 muse_quick_image_prepare_header(const char *aFrametag, cpl_propertylist *aHeader)
113 {
114  cpl_ensure_code(aFrametag, CPL_ERROR_NULL_INPUT);
115  cpl_ensure_code(aHeader, CPL_ERROR_NULL_INPUT);
116  if (!strcmp(aFrametag, "QUICK_IMAGE")) {
117  } else {
118  cpl_msg_warning(__func__, "Frame tag %s is not defined", aFrametag);
119  return CPL_ERROR_ILLEGAL_INPUT;
120  }
121  return CPL_ERROR_NONE;
122 } /* muse_quick_image_prepare_header() */
123 
124 /*----------------------------------------------------------------------------*/
133 /*----------------------------------------------------------------------------*/
134 static cpl_frame_level
135 muse_quick_image_get_frame_level(const char *aFrametag)
136 {
137  if (!aFrametag) {
138  return CPL_FRAME_LEVEL_NONE;
139  }
140  if (!strcmp(aFrametag, "QUICK_IMAGE")) {
141  return CPL_FRAME_LEVEL_FINAL;
142  }
143  return CPL_FRAME_LEVEL_NONE;
144 } /* muse_quick_image_get_frame_level() */
145 
146 /*----------------------------------------------------------------------------*/
155 /*----------------------------------------------------------------------------*/
156 static muse_frame_mode
157 muse_quick_image_get_frame_mode(const char *aFrametag)
158 {
159  if (!aFrametag) {
160  return MUSE_FRAME_MODE_ALL;
161  }
162  if (!strcmp(aFrametag, "QUICK_IMAGE")) {
163  return MUSE_FRAME_MODE_ALL;
164  }
165  return MUSE_FRAME_MODE_ALL;
166 } /* muse_quick_image_get_frame_mode() */
167 
168 /*----------------------------------------------------------------------------*/
178 /*----------------------------------------------------------------------------*/
179 static int
180 muse_quick_image_create(cpl_plugin *aPlugin)
181 {
182  /* Check that the plugin is part of a valid recipe */
183  cpl_recipe *recipe;
184  if (cpl_plugin_get_type(aPlugin) == CPL_PLUGIN_TYPE_RECIPE) {
185  recipe = (cpl_recipe *)aPlugin;
186  } else {
187  return -1;
188  }
189 
190  /* register the extended processing information (new FITS header creation, *
191  * getting of the frame level for a certain tag) */
193  muse_quick_image_new_recipeconfig(),
194  muse_quick_image_prepare_header,
195  muse_quick_image_get_frame_level,
196  muse_quick_image_get_frame_mode);
197 
198  /* XXX initialize timing in messages *
199  * since at least esorex is too stupid to turn it on, we have to do it */
201  cpl_msg_set_time_on();
202  }
203 
204  /* Create the parameter list in the cpl_recipe object */
205  recipe->parameters = cpl_parameterlist_new();
206  /* Fill the parameters list */
207  cpl_parameter *p;
208 
209  /* --nifu: IFU to handle. If set to 0, all IFUs are processed serially. If set to -1, all IFUs are processed in parallel. */
210  p = cpl_parameter_new_range("muse.muse_quick_image.nifu",
211  CPL_TYPE_INT,
212  "IFU to handle. If set to 0, all IFUs are processed serially. If set to -1, all IFUs are processed in parallel.",
213  "muse.muse_quick_image",
214  (int)0,
215  (int)-1,
216  (int)24);
217  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "nifu");
218  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "nifu");
219 
220  cpl_parameterlist_append(recipe->parameters, p);
221 
222  return 0;
223 } /* muse_quick_image_create() */
224 
225 /*----------------------------------------------------------------------------*/
236 /*----------------------------------------------------------------------------*/
237 static int
238 muse_quick_image_params_fill(muse_quick_image_params_t *aParams, cpl_parameterlist *aParameters)
239 {
240  cpl_ensure_code(aParams, CPL_ERROR_NULL_INPUT);
241  cpl_ensure_code(aParameters, CPL_ERROR_NULL_INPUT);
242  cpl_parameter *p;
243 
244  p = cpl_parameterlist_find(aParameters, "muse.muse_quick_image.nifu");
245  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
246  aParams->nifu = cpl_parameter_get_int(p);
247 
248  return 0;
249 } /* muse_quick_image_params_fill() */
250 
251 /*----------------------------------------------------------------------------*/
258 /*----------------------------------------------------------------------------*/
259 static int
260 muse_quick_image_exec(cpl_plugin *aPlugin)
261 {
262  if (cpl_plugin_get_type(aPlugin) != CPL_PLUGIN_TYPE_RECIPE) {
263  return -1;
264  }
265  cpl_recipe *recipe = (cpl_recipe *)aPlugin;
266  cpl_msg_set_threadid_on();
267 
268  cpl_frameset *usedframes = cpl_frameset_new(),
269  *outframes = cpl_frameset_new();
271  muse_quick_image_params_fill(&params, recipe->parameters);
272 
273  cpl_errorstate prestate = cpl_errorstate_get();
274 
275  muse_processing *proc = muse_processing_new("muse_quick_image",
276  recipe);
277  int rc = muse_quick_image_compute(proc, &params);
278  cpl_frameset_join(usedframes, proc->usedFrames);
279  cpl_frameset_join(outframes, proc->outputFrames);
281 
282  if (!cpl_errorstate_is_equal(prestate)) {
283  /* dump all errors from this recipe in chronological order */
284  cpl_errorstate_dump(prestate, CPL_FALSE, muse_cplerrorstate_dump_some);
285  /* reset message level to not get the same errors displayed again by esorex */
286  cpl_msg_set_level(CPL_MSG_INFO);
287  }
288  /* clean up duplicates in framesets of used and output frames */
291  /* to get esorex to see our classification (frame groups etc.), *
292  * replace the original frameset with the list of used frames *
293  * before appending product output frames */
294  /* keep the same pointer, so just erase all frames, not delete the frameset */
295  muse_cplframeset_erase_all(recipe->frames);
296  cpl_frameset_join(recipe->frames, usedframes);
297  cpl_frameset_join(recipe->frames, outframes);
298  cpl_frameset_delete(usedframes);
299  cpl_frameset_delete(outframes);
300  return rc;
301 } /* muse_quick_image_exec() */
302 
303 /*----------------------------------------------------------------------------*/
310 /*----------------------------------------------------------------------------*/
311 static int
312 muse_quick_image_destroy(cpl_plugin *aPlugin)
313 {
314  /* Get the recipe from the plugin */
315  cpl_recipe *recipe;
316  if (cpl_plugin_get_type(aPlugin) == CPL_PLUGIN_TYPE_RECIPE) {
317  recipe = (cpl_recipe *)aPlugin;
318  } else {
319  return -1;
320  }
321 
322  /* Clean up */
323  cpl_parameterlist_delete(recipe->parameters);
325  return 0;
326 } /* muse_quick_image_destroy() */
327 
328 /*----------------------------------------------------------------------------*/
338 /*----------------------------------------------------------------------------*/
339 int
340 cpl_plugin_get_info(cpl_pluginlist *aList)
341 {
342  cpl_recipe *recipe = cpl_calloc(1, sizeof *recipe);
343  cpl_plugin *plugin = &recipe->interface;
344 
345  char *helptext;
347  helptext = cpl_sprintf("%s%s", muse_quick_image_help,
348  muse_quick_image_help_esorex);
349  } else {
350  helptext = cpl_sprintf("%s", muse_quick_image_help);
351  }
352 
353  /* Initialize the CPL plugin stuff for this module */
354  cpl_plugin_init(plugin, CPL_PLUGIN_API, MUSE_BINARY_VERSION,
355  CPL_PLUGIN_TYPE_RECIPE,
356  "muse_quick_image",
357  "Carry out quick image reconstruction: create an image of the field of view in the fastest possible way for a visual check of the telescope pointing.",
358  helptext,
359  "Peter Weilbacher (based on Arlette Pecontal's makeima)",
360  "usd-help@eso.org",
362  muse_quick_image_create,
363  muse_quick_image_exec,
364  muse_quick_image_destroy);
365  cpl_pluginlist_append(aList, plugin);
366  cpl_free(helptext);
367 
368  return 0;
369 } /* cpl_plugin_get_info() */
370 
Structure to hold the parameters of the muse_quick_image recipe.
void muse_processing_delete(muse_processing *aProcessing)
Free the muse_processing structure.
muse_cplframework_type muse_cplframework(void)
Return the CPL framework the recipe is run under.
const char * muse_get_license(void)
Get the pipeline copyright and license.
Definition: muse_utils.c:80
muse_processing * muse_processing_new(const char *aRecipeName, cpl_recipe *aRecipe)
Create a new processing structure.
muse_frame_mode
cpl_frameset * outputFrames
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.
cpl_error_code muse_cplframeset_erase_all(cpl_frameset *aFrames)
Erase all frames in a frameset.
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.
cpl_frameset * usedFrames
int nifu
IFU to handle. If set to 0, all IFUs are processed serially. If set to -1, all IFUs are processed in ...