105 cpl_size filter_size_x ;
106 cpl_size filter_size_y ;
107 hdrl_flat_method method ;
108} hdrl_flat_parameter;
111static hdrl_parameter_typeobj hdrl_flat_parameter_type = {
113 (hdrl_alloc *)&cpl_malloc,
114 (hdrl_free *)&cpl_free,
116 sizeof(hdrl_flat_parameter),
127static cpl_error_code hdrl_flat_parameter_verify(
128 const hdrl_parameter * param)
130 const hdrl_flat_parameter * param_loc = (
const hdrl_flat_parameter *)param ;
132 cpl_error_ensure(param != NULL, CPL_ERROR_NULL_INPUT,
133 return CPL_ERROR_NULL_INPUT,
"NULL Input Parameters");
135 CPL_ERROR_ILLEGAL_INPUT,
return CPL_ERROR_ILLEGAL_INPUT,
136 "Expected FLAT image parameter") ;
138 cpl_error_ensure(param_loc->method == HDRL_FLAT_FREQ_LOW ||
139 param_loc->method == HDRL_FLAT_FREQ_HIGH,
140 CPL_ERROR_ILLEGAL_INPUT,
return CPL_ERROR_ILLEGAL_INPUT,
141 "Unsupported method");
142 cpl_error_ensure(param_loc->filter_size_x > 0,
143 CPL_ERROR_ILLEGAL_INPUT,
return CPL_ERROR_ILLEGAL_INPUT,
144 "filter_size_x must be > 0");
145 cpl_error_ensure(param_loc->filter_size_y > 0,
146 CPL_ERROR_ILLEGAL_INPUT,
return CPL_ERROR_ILLEGAL_INPUT,
147 "filter_size_y must be > 0");
148 cpl_error_ensure((param_loc->filter_size_x % 2) == 1,
149 CPL_ERROR_ILLEGAL_INPUT,
return CPL_ERROR_ILLEGAL_INPUT,
150 "filter_size_x must an odd number");
151 cpl_error_ensure((param_loc->filter_size_y % 2) == 1,
152 CPL_ERROR_ILLEGAL_INPUT,
return CPL_ERROR_ILLEGAL_INPUT,
153 "filter_size_y must an odd number");
154 return CPL_ERROR_NONE ;
174 cpl_size filter_size_x,
175 cpl_size filter_size_y,
176 hdrl_flat_method method)
178 hdrl_flat_parameter * p = (hdrl_flat_parameter *)
179 hdrl_parameter_new(&hdrl_flat_parameter_type);
180 p->filter_size_x = filter_size_x ;
181 p->filter_size_y = filter_size_y ;
183 if (hdrl_flat_parameter_verify((hdrl_parameter *)p) != CPL_ERROR_NONE) {
187 return (hdrl_parameter *)p;
199 return hdrl_parameter_check_type(self, &hdrl_flat_parameter_type);
210 const hdrl_parameter * p)
212 cpl_ensure(p, CPL_ERROR_NULL_INPUT, -1);
213 return ((
const hdrl_flat_parameter *)p)->filter_size_x;
224 const hdrl_parameter * p)
226 cpl_ensure(p, CPL_ERROR_NULL_INPUT, -1);
227 return ((
const hdrl_flat_parameter *)p)->filter_size_y;
238 const hdrl_parameter * p)
240 cpl_ensure(p, CPL_ERROR_NULL_INPUT, -1);
241 return ((
const hdrl_flat_parameter *)p)->method;
259 const char * base_context,
261 const hdrl_parameter * defaults)
263 cpl_ensure(prefix && base_context && defaults, CPL_ERROR_NULL_INPUT, NULL);
265 cpl_parameterlist * parlist = cpl_parameterlist_new();
266 cpl_parameter * par ;
274 cpl_ensure( method_def == HDRL_FLAT_FREQ_LOW || method_def == HDRL_FLAT_FREQ_HIGH,
275 CPL_ERROR_ILLEGAL_INPUT, NULL) ;
277 const char *method_str;
278 if (method_def == HDRL_FLAT_FREQ_LOW) {
280 }
else if (method_def == HDRL_FLAT_FREQ_HIGH) {
287 hdrl_setup_vparameter(parlist, prefix,
".",
"",
"filter-size-x", base_context,
288 "Smoothing filter size in x-direction.", CPL_TYPE_INT,
289 (
int)filter_size_x_def) ;
292 hdrl_setup_vparameter(parlist, prefix,
".",
"",
"filter-size-y", base_context,
293 "Smoothing filter size in y-direction.", CPL_TYPE_INT,
294 (
int)filter_size_y_def) ;
298 par = cpl_parameter_new_enum(name, CPL_TYPE_STRING,
299 "Method to use for the master flatfield calculation", context, method_str,
303 cpl_parameter_set_alias(par, CPL_PARAMETER_MODE_CLI, name);
304 cpl_parameter_disable(par, CPL_PARAMETER_MODE_ENV);
306 cpl_parameterlist_append(parlist, par);
310 if (cpl_error_get_code()) {
311 cpl_parameterlist_delete(parlist);
332 const cpl_parameterlist * parlist,
335 cpl_ensure(prefix && parlist, CPL_ERROR_NULL_INPUT, NULL);
337 const cpl_parameter * par;
338 const char * tmp_str ;
339 cpl_size filter_size_x;
340 cpl_size filter_size_y;
341 hdrl_flat_method method;
345 par=cpl_parameterlist_find_const(parlist, name);
346 filter_size_x = cpl_parameter_get_int(par);
351 par=cpl_parameterlist_find_const(parlist, name);
352 filter_size_y = cpl_parameter_get_int(par);
357 par = cpl_parameterlist_find_const(parlist, name) ;
358 tmp_str = cpl_parameter_get_string(par);
359 if (tmp_str == NULL) {
360 cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
361 "Parameter %s not found", name);
366 if(!strcmp(tmp_str,
"low")) {
367 method = HDRL_FLAT_FREQ_LOW ;
368 }
else if(!strcmp(tmp_str,
"high")) {
369 method = HDRL_FLAT_FREQ_HIGH ;
371 cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_INPUT,
372 "Invalid method: %s", tmp_str);
376 if (cpl_error_get_code()) {
377 cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
378 "Error while parsing parameterlist with prefix %s", prefix);
406 hdrl_imagelist * hdrl_data,
407 const cpl_mask * stat_mask,
408 const hdrl_parameter * collapse_params,
409 hdrl_parameter * flat_params,
410 hdrl_image ** master,
411 cpl_image ** contrib_map)
413 hdrl_image * comb_img = NULL;
414 cpl_image * comb_ctr = NULL;
418 cpl_error_ensure(hdrl_data != NULL, CPL_ERROR_NULL_INPUT,
419 return CPL_ERROR_NULL_INPUT,
"No flatfields found");
420 cpl_error_ensure(collapse_params != NULL, CPL_ERROR_NULL_INPUT,
421 return CPL_ERROR_NULL_INPUT,
"No collapsing parameter");
422 cpl_error_ensure(flat_params != NULL, CPL_ERROR_NULL_INPUT,
423 return CPL_ERROR_NULL_INPUT,
"No flatfield parameter");
425 if (hdrl_flat_parameter_verify(flat_params) != CPL_ERROR_NONE)
426 return cpl_error_get_code();
429 const hdrl_flat_parameter * p_loc = (hdrl_flat_parameter *)flat_params ;
430 cpl_size filter_size_x = p_loc->filter_size_x;
431 cpl_size filter_size_y = p_loc->filter_size_y;
433 if (p_loc->method == HDRL_FLAT_FREQ_LOW) {
435 }
else if (p_loc->method == HDRL_FLAT_FREQ_HIGH) {
439 cpl_mask * kernel = cpl_mask_new(filter_size_x, filter_size_y) ;
440 cpl_mask_not(kernel);
452 cpl_mask *img_mask = cpl_mask_duplicate(cpl_image_get_bpm(img));
453 cpl_mask *img_mask_orig = cpl_mask_duplicate(cpl_image_get_bpm(img));
460 if (stat_mask != NULL) {
461 cpl_mask_or(img_mask, stat_mask);
463 cpl_image_reject_from_mask(img, img_mask);
464 median = cpl_image_get_median(img);
465 cpl_msg_debug(cpl_func,
"Median of the flat: %g", median);
467 cpl_image_reject_from_mask(img, img_mask_orig);
470 median = cpl_image_get_median(img);
471 cpl_msg_debug(cpl_func,
"Median of the flat: %g", median);
473 cpl_image_divide_scalar(img, median);
474 cpl_image_divide_scalar(img_err, median);
477 cpl_image * img_filtered;
478 if (stat_mask != NULL) {
479 cpl_image * img_filtered2;
494 cpl_mask_or(img_mask, stat_mask);
495 cpl_image_reject_from_mask(img, img_mask);
496 img_filtered = hdrl_parallel_filter_image(img, NULL, kernel,
502 cpl_mask_or(cpl_image_get_bpm(img_filtered), stat_mask);
507 cpl_mask * stat_mask_inverted=cpl_mask_duplicate(stat_mask);
508 cpl_mask_not(stat_mask_inverted);
510 cpl_mask_delete(img_mask);
511 img_mask = cpl_mask_duplicate(img_mask_orig);
513 cpl_mask_or(img_mask, stat_mask_inverted);
514 cpl_image_reject_from_mask(img, img_mask);
515 img_filtered2 = hdrl_parallel_filter_image(img, NULL, kernel,
521 cpl_mask_or(cpl_image_get_bpm(img_filtered2),
523 cpl_mask_delete(stat_mask_inverted);
527 cpl_image_fill_rejected(img_filtered, 0.);
528 cpl_image_fill_rejected(img_filtered2, 0.);
530 cpl_mask * img_filtered1_mask =
531 cpl_image_unset_bpm(img_filtered);
532 cpl_mask * img_filtered2_mask =
533 cpl_image_unset_bpm(img_filtered2);
535 cpl_image_add(img_filtered, img_filtered2);
536 cpl_image_delete(img_filtered2);
539 cpl_mask_and(img_filtered1_mask, img_filtered2_mask);
540 assert(memcmp(cpl_mask_get_data(img_filtered1_mask),
541 cpl_mask_get_data(img_mask_orig),
542 hdrl_get_image_npix(img)) == 0);
545 cpl_image_reject_from_mask(img_filtered, img_filtered1_mask);
546 cpl_mask_delete(img_filtered1_mask);
547 cpl_mask_delete(img_filtered2_mask);
551 cpl_image_reject_from_mask(img, img_mask);
553 img_filtered = hdrl_parallel_filter_image(img, NULL, kernel,
558 cpl_image_reject_from_mask(img, img_mask_orig);
559 cpl_image_reject_from_mask(img_err, img_mask_orig);
561 cpl_image_divide(img, img_filtered);
562 cpl_image_divide(img_err, img_filtered);
563 cpl_image_delete(img_filtered);
568 cpl_image_abs(img_err);
570 cpl_mask_delete(img_mask);
571 cpl_mask_delete(img_mask_orig);
574 cpl_msg_info(cpl_func,
"Combining the normalized flatfields generating"
575 " the master-flatfield");
580 cpl_image *img_filtered = hdrl_parallel_filter_image(
583 *contrib_map = comb_ctr;
585 cpl_image_delete(img_filtered);
589 *contrib_map = comb_ctr;
592 cpl_mask_delete(kernel);
593 cpl_msg_indent_less();
594 return cpl_error_get_code();
cpl_size hdrl_flat_parameter_get_filter_size_x(const hdrl_parameter *p)
Access the filter_size_x in the FLAT parameter.
hdrl_parameter * hdrl_flat_parameter_create(cpl_size filter_size_x, cpl_size filter_size_y, hdrl_flat_method method)
Creates FLAT Parameters object.
cpl_size hdrl_flat_parameter_get_filter_size_y(const hdrl_parameter *p)
Access the filter_size_y in the FLAT parameter.
cpl_error_code hdrl_flat_compute(hdrl_imagelist *hdrl_data, const cpl_mask *stat_mask, const hdrl_parameter *collapse_params, hdrl_parameter *flat_params, hdrl_image **master, cpl_image **contrib_map)
compute high or low frequency master flat with median filtering
hdrl_flat_method hdrl_flat_parameter_get_method(const hdrl_parameter *p)
Access the method in the FLAT parameter.
hdrl_parameter * hdrl_flat_parameter_parse_parlist(const cpl_parameterlist *parlist, const char *prefix)
Parse a parameterlist to create input parameters for the FLAT.
cpl_parameterlist * hdrl_flat_parameter_create_parlist(const char *base_context, const char *prefix, const hdrl_parameter *defaults)
Create a parameter list for the FLAT computation.
cpl_boolean hdrl_flat_parameter_check(const hdrl_parameter *self)
Check that the parameter is a FLAT parameter.
cpl_image * hdrl_image_get_error(hdrl_image *himg)
get error as cpl image
hdrl_image * hdrl_image_create(const cpl_image *image, const cpl_image *error)
create a new hdrl_image from to existing images by copying them
cpl_image * hdrl_image_get_image(hdrl_image *himg)
get data as cpl image
const cpl_image * hdrl_image_get_image_const(const hdrl_image *himg)
get data as cpl image
void hdrl_image_delete(hdrl_image *himg)
delete hdrl_image
cpl_size hdrl_imagelist_get_size(const hdrl_imagelist *himlist)
Get the number of images in the imagelist.
cpl_error_code hdrl_imagelist_collapse(const hdrl_imagelist *himlist, const hdrl_parameter *param, hdrl_image **out, cpl_image **contrib)
collapsing of image list
hdrl_image * hdrl_imagelist_get(const hdrl_imagelist *himlist, cpl_size inum)
Get an image from a list of images.
void hdrl_parameter_delete(hdrl_parameter *obj)
shallow delete of a parameter
char * hdrl_join_string(const char *sep_, int n,...)
join strings together