diff options
| -rw-r--r-- | docs/todo.txt | 4 | ||||
| -rw-r--r-- | src/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | src/kernels/meson.build | 1 | ||||
| -rw-r--r-- | src/kernels/roof-ffc.cl | 52 | ||||
| -rw-r--r-- | src/meson.build | 1 | ||||
| -rw-r--r-- | src/ufo-roof-flat-field-correct-task.c | 315 | ||||
| -rw-r--r-- | src/ufo-roof-flat-field-correct-task.h | 67 | ||||
| -rw-r--r-- | tests/roof/config.py | 16 | ||||
| -rw-r--r-- | tests/roof/defaults.py | 8 | ||||
| -rw-r--r-- | tests/roof/graph.py | 23 |
10 files changed, 473 insertions, 15 deletions
diff --git a/docs/todo.txt b/docs/todo.txt index 88b518c..a9ab4c8 100644 --- a/docs/todo.txt +++ b/docs/todo.txt @@ -3,7 +3,9 @@ Main + Add plane/frame-number/broken metadata in the UFO buffers. Check propagation trough standard ufo filters. [ propogates trough processors, but not reductors ] + Plane selector filter - Handle packets with data from multiple datasets - - Try UFO 'flat-field' correction filter + + Try UFO 'flat-field' correction filter [ works to a degree, but possible to make it better + anyway multiple planes will be needed later likely... ] + - Compute flat-/dark-fields per plane. + - Support reading raw sinograms in get_reader (we need to set dimensions like in flat-/dark-fields, but howto handle parallel-sinograms/slices - function in config?) - Cone-beam to parallel-beam resampling ? - Full reconstruction chain - Try UFO visualization filter diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 116b400..bbbc5fb 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -5,6 +5,7 @@ set(ufofilter_SRCS ufo-roof-read-task.c ufo-roof-build-task.c ufo-roof-filter-task.c + ufo-roof-flat-field-correct.c ) set(common_SRCS diff --git a/src/kernels/meson.build b/src/kernels/meson.build index 9803fb9..6472953 100644 --- a/src/kernels/meson.build +++ b/src/kernels/meson.build @@ -1,4 +1,5 @@ kernel_files = [ + 'roof-ffc.cl' ] install_data(kernel_files, diff --git a/src/kernels/roof-ffc.cl b/src/kernels/roof-ffc.cl new file mode 100644 index 0000000..8752990 --- /dev/null +++ b/src/kernels/roof-ffc.cl @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2011-2013 Karlsruhe Institute of Technology + * + * This file is part of Ufo. + * + * This library is free software: you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation, either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see <http://www.gnu.org/licenses/>. + */ + +kernel void +flat_correct (global float *corrected, + global float *data, + global const float *dark, + global const float *flat, + const int sinogram_input, + const int absorptivity, + const int fix_abnormal, + const float dark_scale, + const float flat_scale) +{ + const float eps = 1E-5; + const int gid = get_global_id(1) * get_global_size(0) + get_global_id(0); + const int corr_idx = sinogram_input ? get_global_id(0) : gid; + const float cdark = dark[corr_idx] * dark_scale; + const float cflat = flat[corr_idx] * flat_scale; + float result; + + float nom = data[gid] - cdark; + float denom = cflat - cdark; + + if (nom < eps) nom = eps; +// if (denom < eps) denom = eps; + if (denom < eps) denom = eps; + + result = -log(nom / denom); + + if (fix_abnormal && (isnan (result) || isinf (result))) { + result = 0.0f; + } + + corrected[gid] = result; +} diff --git a/src/meson.build b/src/meson.build index 8f8930a..324c744 100644 --- a/src/meson.build +++ b/src/meson.build @@ -2,6 +2,7 @@ plugins = [ 'roof-read', 'roof-build', 'roof-filter', + 'roof-flat-field-correct' ] roof_common_src = [ diff --git a/src/ufo-roof-flat-field-correct-task.c b/src/ufo-roof-flat-field-correct-task.c new file mode 100644 index 0000000..7c1f9dc --- /dev/null +++ b/src/ufo-roof-flat-field-correct-task.c @@ -0,0 +1,315 @@ +/* + * Copyright (C) 2011-2013 Karlsruhe Institute of Technology + * + * This file is part of Ufo. + * + * This library is free software: you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation, either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef __APPLE__ +#include <OpenCL/cl.h> +#else +#include <CL/cl.h> +#endif +#include <math.h> +#include "ufo-roof-flat-field-correct-task.h" + + +struct _UfoRoofFlatFieldCorrectTaskPrivate { + gboolean fix_nan_and_inf; + gboolean absorptivity; + gboolean sinogram_input; + gfloat dark_scale; + gfloat flat_scale; + cl_kernel kernel; +}; + +static void ufo_task_interface_init (UfoTaskIface *iface); + +G_DEFINE_TYPE_WITH_CODE (UfoRoofFlatFieldCorrectTask, ufo_roof_flat_field_correct_task, UFO_TYPE_TASK_NODE, + G_IMPLEMENT_INTERFACE (UFO_TYPE_TASK, + ufo_task_interface_init)) + +#define UFO_ROOF_FLAT_FIELD_CORRECT_TASK_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), UFO_TYPE_ROOF_FLAT_FIELD_CORRECT_TASK, UfoRoofFlatFieldCorrectTaskPrivate)) + +enum { + PROP_0, + PROP_FIX_NAN_AND_INF, + PROP_ABSORPTIVITY, + PROP_SINOGRAM_INPUT, + PROP_DARK_SCALE, + PROP_FLAT_SCALE, + N_PROPERTIES +}; + +static GParamSpec *properties[N_PROPERTIES] = { NULL, }; + +UfoNode * +ufo_roof_flat_field_correct_task_new (void) +{ + return UFO_NODE (g_object_new (UFO_TYPE_ROOF_FLAT_FIELD_CORRECT_TASK, NULL)); +} + +static void +ufo_roof_flat_field_correct_task_setup (UfoTask *task, + UfoResources *resources, + GError **error) +{ + UfoRoofFlatFieldCorrectTaskPrivate *priv; + + priv = UFO_ROOF_FLAT_FIELD_CORRECT_TASK_GET_PRIVATE (task); + priv->kernel = ufo_resources_get_kernel (resources, "roof-ffc.cl", "flat_correct", NULL, error); + + if (priv->kernel) + UFO_RESOURCES_CHECK_SET_AND_RETURN (clRetainKernel (priv->kernel), error); +} + +static void +ufo_roof_flat_field_correct_task_get_requisition (UfoTask *task, + UfoBuffer **inputs, + UfoRequisition *requisition, + GError **error) +{ + ufo_buffer_get_requisition (inputs[0], requisition); + + if (ufo_buffer_cmp_dimensions (inputs[1], requisition) != 0 || + ufo_buffer_cmp_dimensions (inputs[2], requisition) != 0) { + g_set_error_literal (error, UFO_TASK_ERROR, UFO_TASK_ERROR_GET_REQUISITION, + "flat-field-correct inputs must have the same size"); + } +} + +static guint +ufo_roof_flat_field_correct_task_get_num_inputs (UfoTask *task) +{ + return 3; +} + +static guint +ufo_roof_flat_field_correct_task_get_num_dimensions (UfoTask *task, guint input) +{ + UfoRoofFlatFieldCorrectTaskPrivate *priv; + + priv = UFO_ROOF_FLAT_FIELD_CORRECT_TASK_GET_PRIVATE (task); + g_return_val_if_fail (input <= 2, 0); + + /* A sinogram */ + if (input == 0) + return 2; + + /* A row of dark frame depend on the sinogram_input flag */ + return priv->sinogram_input ? 1 : 2; +} + +static UfoTaskMode +ufo_roof_flat_field_correct_task_get_mode (UfoTask *task) +{ + return UFO_TASK_MODE_PROCESSOR | UFO_TASK_MODE_GPU; +} + +static gboolean +ufo_roof_flat_field_correct_task_process (UfoTask *task, + UfoBuffer **inputs, + UfoBuffer *output, + UfoRequisition *requisition) +{ + UfoRoofFlatFieldCorrectTaskPrivate *priv; + UfoProfiler *profiler; + UfoGpuNode *node; + + cl_command_queue cmd_queue; + cl_mem proj_mem; + cl_mem dark_mem; + cl_mem flat_mem; + cl_mem out_mem; + gint absorptivity, sino_in, fix_nan_and_inf; + + node = UFO_GPU_NODE (ufo_task_node_get_proc_node (UFO_TASK_NODE (task))); + cmd_queue = ufo_gpu_node_get_cmd_queue (node); + proj_mem = ufo_buffer_get_device_array (inputs[0], cmd_queue); + dark_mem = ufo_buffer_get_device_array (inputs[1], cmd_queue); + flat_mem = ufo_buffer_get_device_array (inputs[2], cmd_queue); + out_mem = ufo_buffer_get_device_array (output, cmd_queue); + + priv = UFO_ROOF_FLAT_FIELD_CORRECT_TASK_GET_PRIVATE (task); + absorptivity = (gint) priv->absorptivity; + sino_in = (gint) priv->sinogram_input; + fix_nan_and_inf = (gint) priv->fix_nan_and_inf; + + UFO_RESOURCES_CHECK_CLERR (clSetKernelArg (priv->kernel, 0, sizeof (cl_mem), &out_mem)); + UFO_RESOURCES_CHECK_CLERR (clSetKernelArg (priv->kernel, 1, sizeof (cl_mem), &proj_mem)); + UFO_RESOURCES_CHECK_CLERR (clSetKernelArg (priv->kernel, 2, sizeof (cl_mem), &dark_mem)); + UFO_RESOURCES_CHECK_CLERR (clSetKernelArg (priv->kernel, 3, sizeof (cl_mem), &flat_mem)); + UFO_RESOURCES_CHECK_CLERR (clSetKernelArg (priv->kernel, 4, sizeof (cl_int), &sino_in)); + UFO_RESOURCES_CHECK_CLERR (clSetKernelArg (priv->kernel, 5, sizeof (cl_int), &absorptivity)); + UFO_RESOURCES_CHECK_CLERR (clSetKernelArg (priv->kernel, 6, sizeof (cl_int), &fix_nan_and_inf)); + UFO_RESOURCES_CHECK_CLERR (clSetKernelArg (priv->kernel, 7, sizeof (cl_float), &priv->dark_scale)); + UFO_RESOURCES_CHECK_CLERR (clSetKernelArg (priv->kernel, 8, sizeof (cl_float), &priv->flat_scale)); + + profiler = ufo_task_node_get_profiler (UFO_TASK_NODE (task)); + ufo_profiler_call (profiler, cmd_queue, priv->kernel, 2, requisition->dims, NULL); + + return TRUE; +} + +static void +ufo_roof_flat_field_correct_task_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + UfoRoofFlatFieldCorrectTaskPrivate *priv = UFO_ROOF_FLAT_FIELD_CORRECT_TASK_GET_PRIVATE (object); + + switch (property_id) { + case PROP_FIX_NAN_AND_INF: + priv->fix_nan_and_inf = g_value_get_boolean (value); + break; + case PROP_ABSORPTIVITY: + priv->absorptivity = g_value_get_boolean (value); + break; + case PROP_SINOGRAM_INPUT: + priv->sinogram_input = g_value_get_boolean (value); + break; + case PROP_DARK_SCALE: + priv->dark_scale = g_value_get_float (value); + break; + case PROP_FLAT_SCALE: + priv->flat_scale = g_value_get_float (value); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +ufo_roof_flat_field_correct_task_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + UfoRoofFlatFieldCorrectTaskPrivate *priv = UFO_ROOF_FLAT_FIELD_CORRECT_TASK_GET_PRIVATE (object); + + switch (property_id) { + case PROP_FIX_NAN_AND_INF: + g_value_set_boolean (value, priv->fix_nan_and_inf); + break; + case PROP_ABSORPTIVITY: + g_value_set_boolean (value, priv->absorptivity); + break; + case PROP_SINOGRAM_INPUT: + g_value_set_boolean (value, priv->sinogram_input); + break; + case PROP_DARK_SCALE: + g_value_set_float (value, priv->dark_scale); + break; + case PROP_FLAT_SCALE: + g_value_set_float (value, priv->flat_scale); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +ufo_roof_flat_field_correct_task_finalize (GObject *object) +{ + UfoRoofFlatFieldCorrectTaskPrivate *priv; + + priv = UFO_ROOF_FLAT_FIELD_CORRECT_TASK_GET_PRIVATE (object); + + if (priv->kernel) { + UFO_RESOURCES_CHECK_CLERR (clReleaseKernel (priv->kernel)); + priv->kernel = NULL; + } + + G_OBJECT_CLASS (ufo_roof_flat_field_correct_task_parent_class)->finalize (object); +} + +static void +ufo_task_interface_init (UfoTaskIface *iface) +{ + iface->setup = ufo_roof_flat_field_correct_task_setup; + iface->get_num_inputs = ufo_roof_flat_field_correct_task_get_num_inputs; + iface->get_num_dimensions = ufo_roof_flat_field_correct_task_get_num_dimensions; + iface->get_mode = ufo_roof_flat_field_correct_task_get_mode; + iface->get_requisition = ufo_roof_flat_field_correct_task_get_requisition; + iface->process = ufo_roof_flat_field_correct_task_process; +} + +static void +ufo_roof_flat_field_correct_task_class_init (UfoRoofFlatFieldCorrectTaskClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->set_property = ufo_roof_flat_field_correct_task_set_property; + gobject_class->get_property = ufo_roof_flat_field_correct_task_get_property; + gobject_class->finalize = ufo_roof_flat_field_correct_task_finalize; + + properties[PROP_FIX_NAN_AND_INF] = + g_param_spec_boolean("fix-nan-and-inf", + "Replace NAN and INF values with 0.0", + "Replace NAN and INF values with 0.0", + FALSE, + G_PARAM_READWRITE); + +/* + properties[PROP_ABSORPTIVITY] = + g_param_spec_boolean ("absorption-correct", + "Absorption correct", + "Absorption correct", + FALSE, + G_PARAM_READWRITE); + + properties[PROP_SINOGRAM_INPUT] = + g_param_spec_boolean ("sinogram-input", + "If sinogram-input is True we correct only one line (the sinogram), thus darks are flats are 1D", + "If sinogram-input is True we correct only one line (the sinogram), thus darks are flats are 1D", + FALSE, + G_PARAM_READWRITE); +*/ + + properties[PROP_DARK_SCALE] = + g_param_spec_float ("dark-scale", + "Scale the dark field prior to the flat field correct", + "Scale the dark field prior to the flat field correct", + -G_MAXFLOAT, G_MAXFLOAT, 1.0f, + G_PARAM_READWRITE); + + properties[PROP_FLAT_SCALE] = + g_param_spec_float ("flat-scale", + "Scale the flat field prior to the flat field correct", + "Scale the flat field prior to the flat field correct", + -G_MAXFLOAT, G_MAXFLOAT, 1.0f, + G_PARAM_READWRITE); + + for (guint i = PROP_0 + 1; i < N_PROPERTIES; i++) + g_object_class_install_property (gobject_class, i, properties[i]); + + g_type_class_add_private (gobject_class, sizeof(UfoRoofFlatFieldCorrectTaskPrivate)); +} + +static void +ufo_roof_flat_field_correct_task_init(UfoRoofFlatFieldCorrectTask *self) +{ + self->priv = UFO_ROOF_FLAT_FIELD_CORRECT_TASK_GET_PRIVATE(self); + self->priv->fix_nan_and_inf = FALSE; + self->priv->absorptivity = FALSE; + self->priv->sinogram_input = FALSE; + self->priv->kernel = NULL; + self->priv->dark_scale = 1.0f; + self->priv->flat_scale = 1.0f; +} diff --git a/src/ufo-roof-flat-field-correct-task.h b/src/ufo-roof-flat-field-correct-task.h new file mode 100644 index 0000000..ac82aaa --- /dev/null +++ b/src/ufo-roof-flat-field-correct-task.h @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2011-2013 Karlsruhe Institute of Technology + * + * This file is part of Ufo. + * + * This library is free software: you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation, either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UFO_ROOF_FLAT_FIELD_CORRECT_TASK_H +#define __UFO_ROOF_FLAT_FIELD_CORRECT_TASK_H + +#include <ufo/ufo.h> + +G_BEGIN_DECLS + +#define UFO_TYPE_ROOF_FLAT_FIELD_CORRECT_TASK (ufo_roof_flat_field_correct_task_get_type()) +#define UFO_ROOF_FLAT_FIELD_CORRECT_TASK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), UFO_TYPE_ROOF_FLAT_FIELD_CORRECT_TASK, UfoRoofFlatFieldCorrectTask)) +#define UFO_IS_ROOF_FLAT_FIELD_CORRECT_TASK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), UFO_TYPE_ROOF_FLAT_FIELD_CORRECT_TASK)) +#define UFO_ROOF_FLAT_FIELD_CORRECT_TASK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), UFO_TYPE_ROOF_FLAT_FIELD_CORRECT_TASK, UfoRoofFlatFieldCorrectTaskClass)) +#define UFO_IS_ROOF_FLAT_FIELD_CORRECT_TASK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), UFO_TYPE_ROOF_FLAT_FIELD_CORRECT_TASK)) +#define UFO_ROOF_FLAT_FIELD_CORRECT_TASK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), UFO_TYPE_ROOF_FLAT_FIELD_CORRECT_TASK, UfoRoofFlatFieldCorrectTaskClass)) + +typedef struct _UfoRoofFlatFieldCorrectTask UfoRoofFlatFieldCorrectTask; +typedef struct _UfoRoofFlatFieldCorrectTaskClass UfoRoofFlatFieldCorrectTaskClass; +typedef struct _UfoRoofFlatFieldCorrectTaskPrivate UfoRoofFlatFieldCorrectTaskPrivate; + +/** + * UfoRoofFlatFieldCorrectTask: + * + * [ADD DESCRIPTION HERE]. The contents of the #UfoRoofFlatFieldCorrectTask structure + * are private and should only be accessed via the provided API. + */ +struct _UfoRoofFlatFieldCorrectTask { + /*< private >*/ + UfoTaskNode parent_instance; + + UfoRoofFlatFieldCorrectTaskPrivate *priv; +}; + +/** + * UfoRoofFlatFieldCorrectTaskClass: + * + * #UfoRoofFlatFieldCorrectTask class + */ +struct _UfoRoofFlatFieldCorrectTaskClass { + /*< private >*/ + UfoTaskNodeClass parent_class; +}; + +UfoNode *ufo_roof_flat_field_correct_task_new (void); +GType ufo_roof_flat_field_correct_task_get_type (void); + +G_END_DECLS + +#endif + diff --git a/tests/roof/config.py b/tests/roof/config.py index e085ed8..8f72014 100644 --- a/tests/roof/config.py +++ b/tests/roof/config.py @@ -13,10 +13,15 @@ class RoofConfig: self.path = self.get_opt('data', 'base_path', './') self.planes = self.get_opt('hardware', 'planes', 1) - self.modules = self.get_opt('hardware', 'modules', None) - self.streams = self.get_opt('network', 'streams', 1 if self.modules is None else self.modules) + self.modules = self.get_opt('hardware', 'modules', 0) + self.streams = self.get_opt('network', 'streams', self.modules if self.modules else 1) self.bit_depth = self.get_opt('hardware', 'bit_depth', 8) + self.sample_rate = self.get_opt('hardware', 'sample_rate', 0) + self.imaging_rate = self.get_opt('hardware', 'imaging_rate', 0) + self.fan_bins = self.modules * self.get_opt('hardware', 'channels_per_module', 16) + self.fan_projections = self.get_opt('hardware', 'samples_per_rotation', (self.sample_rate / self.imaging_rate) if (self.imaging_rate and self.sample_rate) else 1000) + if self.args.number is None: self.args.number = 0 if self.args.benchmark else self.planes # Consistency and default mode @@ -46,6 +51,13 @@ class RoofConfig: if subpath is None: raise "Unknown data type %s is requested" % subpath return subpath if subpath.startswith('/') else self.path + '/' + subpath + def get_roof_glob(self, data_type): + path = self.get_roof_path(data_type) + if path is None: return None + + globre = re.compile('%.?(\d+)[luid]') + return globre.sub('*', path) + def get_writer_type(self): return None if self.args.benchmark else self.args.write if self.args.write else 'raw_sinograms' diff --git a/tests/roof/defaults.py b/tests/roof/defaults.py index eed3fe5..f6b67f6 100644 --- a/tests/roof/defaults.py +++ b/tests/roof/defaults.py @@ -15,7 +15,7 @@ roof_default_paths = { #} roof_filters = { - 'correction': [ "flat-field-correct" ], + 'correction': [ "roof-flat-field-correct" ], 'reconstruction': [ "roof-fan2par", "fft", "filter", "ifft", "backproject" ], 'control': [ ], 'visualization': [ ] @@ -23,9 +23,9 @@ roof_filters = { roof_data_types = { 'correction': { - 'flat_fields': 'flat-field-correct', - 'dark_fields': 'flat-field-correct', - 'raw_sinograms': 'flat-field-correct', + 'flat_fields': 'roof-flat-field-correct', + 'dark_fields': 'roof-flat-field-correct', + 'raw_sinograms': 'roof-flat-field-correct', 'fan_sinograms': None }, 'reconstruction': { diff --git a/tests/roof/graph.py b/tests/roof/graph.py index c34a3ed..495c629 100644 --- a/tests/roof/graph.py +++ b/tests/roof/graph.py @@ -39,11 +39,16 @@ class RoofGraph(RoofConfig): if (re.compile('roof').match(name)): kwargs.update(config = self.config_file) return self.save_task(stage, name, self.get_task(name, **kwargs)) + def get_read_task(self, path): + params = { 'raw_width': self.fan_bins, 'raw_height': self.fan_projections, 'raw_bitdepth': self.bit_depth } if re.search('\.raw$', path) else { } + params['path'] = path + return self.get_task('read', **params) + def get_reader(self): first = self.get_opt('data', 'first_file_number', 1) if self.args.read: # Reconstruction from standard UFO files - path = self.get_roof_path(self.args.read) + path = self.get_roof_glob(self.args.read) step = 1 if (self.args.plane is not None) and (self.args.plane > 0): first += self.args.plane - 1; @@ -54,6 +59,7 @@ class RoofGraph(RoofConfig): params['number'] = self.args.number print ("Reading {} data from {}".format(self.args.read,path)) + # FIXME: handle raw data parameters return self.get_task('read', **params) else: path = None @@ -85,16 +91,16 @@ class RoofGraph(RoofConfig): write = self.get_task('write', filename=path) return write - def get_correction_flat_field_correct(self, head): + def get_correction_roof_flat_field_correct(self, head): # Standard UFO reconstruction stack distinguish flat/dark-fields recorded before and after experiment. We only do 'before experiment' part. - darks = self.get_roof_path('dark_fields') + darks = self.get_roof_glob('dark_fields') n_darks = len(get_filenames(darks)) if n_darks == 0: raise FileNotFoundError("Dark fields are not found in {}".format(darks)) - flats = self.get_roof_path('falt_fields') + flats = self.get_roof_glob('flat_fields') n_flats = len(get_filenames(flats)) if n_flats == 0: raise FileNotFoundError("Flat fields are not found in {}".format(flats)) - dark_reader = self.get_task('read', path = darks) - flat_reader = self.get_task('read', path = flats) + dark_reader = self.get_read_task(path = darks) + flat_reader = self.get_read_task(path = flats) # We are using standard get_task here because this is too generic plugin to allow config-based customization mode = self.get_opt('correction', 'aggregation', 'average') @@ -116,7 +122,8 @@ class RoofGraph(RoofConfig): else: raise ValueError('Invalid reduction mode') - ffc = self.get_task('flat-field-correct') # dark_scale=args.dark_scale, absorption_correct=args.absorptivity, fix_nan_and_inf=args.fix_nan_and_inf) + #ffc = self.get_task('flat-field-correct', fix_nan_and_inf=False, absorption_correct=True) + ffc = self.get_task('roof-flat-field-correct', fix_nan_and_inf=False) # absorption_correct=True) self.graph.connect_nodes_full(head, ffc, 0) self.graph.connect_nodes_full(dark_reduced, ffc, 1) self.graph.connect_nodes_full(flat_reduced, ffc, 2) @@ -146,7 +153,7 @@ class RoofGraph(RoofConfig): if method in dir(self): f = getattr(self, method)(head) else: - f = self.get_processor_task(stage, filters[pos]) + f = self.get_processor_task(stage, filters[i]) graph.connect_nodes(head, f) head = f |