ChessAnalysisPipeline 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

CHAP/tomo/processor.py

@@ -19,15 +19,13 @@ import numpy as np
 # Local modules
 from CHAP.utils.general import (
     is_num,
+    is_int_pair,
     input_int,
     input_num,
     input_yesno,
-    select_image_bounds,
-    select_one_image_bound,
-    draw_mask_1d,
-    clear_plot,
-    clear_imshow,
-    quick_plot,
+    select_image_indices,
+    select_roi_1d,
+    select_roi_2d,
     quick_imshow,
 )
 from CHAP.utils.fit import Fit
@@ -39,20 +37,22 @@ NUM_CORE_TOMOPY_LIMIT = 24
 
 def get_nxroot(data, schema=None, remove=True):
     """Look through `data` for an item whose value for the `'schema'`
-    key matches `schema` and whose value for the `'data'` key matches
-    an nexusformat.nexus.NXobject object and return this object.
+    key matches `schema` (if supplied) and whose value for the `'data'`
+    key matches a nexusformat.nexus.NXobject object and return this
+    object.
 
-    :param data: Input list of `PipelineData` objects
+    :param data: Input list of `PipelineData` objects.
     :type data: list[PipelineData]
-    :param schema: name associated with the nexusformat.nexus.NXobject
-         object to match in `data`
+    :param schema: Name associated with the nexusformat.nexus.NXobject
+        object to match in `data`.
     :type schema: str, optional
-    :param remove: if there is a matching entry in `data`, remove
-       it from the list, defaults to `True`.
+    :param remove: Removes the matching entry in `data` when found,
+        defaults to `True`.
     :type remove: bool, optional
-    :raises ValueError: if there's no match for `schema` in `data`
-    :return: object matching with `schema`
-    :rtype: nexusformat.nexus.NXroot
+    :raises ValueError: Found an invalid matching object or multiple
+        matching objects.
+    :return: Object matching with `schema` or None when not found.
+    :rtype: None, nexusformat.nexus.NXroot
     """
     # System modules
     from copy import deepcopy
@@ -94,9 +94,11 @@ class TomoCHESSMapConverter(Processor):
         nexusformat.nexus.NXtomo style format.
 
         :param data: Input map and configuration for tomographic image
-            reduction.
+            reduction/reconstruction.
         :type data: list[PipelineData]
-        :return: NXtomo style tomography input configuration.
+        :raises ValueError: Invalid input or configuration parameter.
+        :return: nexusformat.nexus.NXtomo style tomography input
+            configuration.
         :rtype: nexusformat.nexus.NXroot
         """
         # System modules
@@ -116,6 +118,7 @@ class TomoCHESSMapConverter(Processor):
 
         # Local modules
         from CHAP.common.models.map import MapConfig
+        from CHAP.utils.general import index_nearest
 
         darkfield = get_nxroot(data, 'darkfield')
         brightfield = get_nxroot(data, 'brightfield')
@@ -237,6 +240,10 @@ class TomoCHESSMapConverter(Processor):
                 pixel_size[1]/detector_config.lens_magnification
         nxdetector.row_pixel_size.units = 'mm'
         nxdetector.column_pixel_size.units = 'mm'
+        nxdetector.rows = detector_config.rows
+        nxdetector.columns = detector_config.columns
+        nxdetector.rows.units = 'pixels'
+        nxdetector.columns.units = 'pixels'
 
         # Add an NXsample to NXentry
         # (do not fill in data fields yet)
@@ -376,7 +383,6 @@ class TomoCHESSMapConverter(Processor):
         thetas = np.asarray(tomofields.data.rotation_angles)
 #RV        num_image = len(tomofields.data.rotation_angles)
         assert len(thetas) > 2
-        from CHAP.utils.general import index_nearest
         delta_theta = thetas[1]-thetas[0]
         if thetas[-1]-thetas[0] > 180-delta_theta:
             image_end = index_nearest(thetas, thetas[0]+180)
@@ -434,8 +440,8 @@ class TomoDataProcessor(Processor):
 
     def process(
             self, data, interactive=False, reduce_data=False,
-            find_center=False, reconstruct_data=False, combine_data=False,
-            output_folder='.', save_figs='no', **kwargs):
+            find_center=False, calibrate_center=False, reconstruct_data=False,
+            combine_data=False, output_folder='.', save_figs='no', **kwargs):
         """
         Process the input map or configuration with the step specific
         instructions and return either a dictionary or a
@@ -450,9 +456,12 @@ class TomoDataProcessor(Processor):
         :param reduce_data: Generate reduced tomography images,
             defaults to False.
         :type reduce_data: bool, optional
-        :param find_center: Find the calibrated center axis info,
+        :param find_center: Generate calibrated center axis info,
             defaults to False.
         :type find_center: bool, optional
+        :param calibrate_center: Calibrate the rotation axis,
+            defaults to False.
+        :type calibrate_center: bool, optional
         :param reconstruct_data: Reconstruct the tomography data,
             defaults to False.
         :type reconstruct_data: bool, optional
@@ -464,6 +473,9 @@ class TomoDataProcessor(Processor):
         :param save_figs: Safe figures to file ('yes' or 'only') and/or
             display figures ('yes' or 'no'), defaults to 'no'.
         :type save_figs: Literal['yes', 'no', 'only'], optional
+        :raises ValueError: Invalid input or configuration parameter.
+        :raises RuntimeError: Missing map configuration to generate
+            reduced tomography images.
         :return: Processed (meta)data of the last step.
         :rtype: Union[dict, nexusformat.nexus.NXroot]
         """
@@ -484,6 +496,9 @@ class TomoDataProcessor(Processor):
             raise ValueError(f'Invalid parameter reduce_data ({reduce_data})')
         if not isinstance(find_center, bool):
             raise ValueError(f'Invalid parameter find_center ({find_center})')
+        if not isinstance(calibrate_center, bool):
+            raise ValueError(
+                f'Invalid parameter calibrate_center ({calibrate_center})')
         if not isinstance(reconstruct_data, bool):
             raise ValueError(
                 f'Invalid parameter reconstruct_data ({reconstruct_data})')
@@ -519,14 +534,36 @@ class TomoDataProcessor(Processor):
 
         nxsetconfig(memory=100000)
 
+        # Calibrate the rotation axis
+        if calibrate_center:
+            if (reduce_data or find_center 
+                    or reconstruct_data or reconstruct_data_config is not None
+                    or combine_data or combine_data_config is not None):
+                self._logger.warning('Ignoring any step specific instructions '
+                                    'during center calibration')
+            if nxroot is None:
+                raise RuntimeError('Map info required to calibrate the '
+                                   'rotation axis')
+            if find_center_config is None:
+                find_center_config = TomoFindCenterConfig()
+                calibrate_center_rows = True
+            else:
+                calibrate_center_rows = find_center_config.center_rows
+                if calibrate_center_rows == None:
+                    calibrate_center_rows = True
+            nxroot, calibrate_center_rows = tomo.reduce_data(
+                nxroot, reduce_data_config, calibrate_center_rows)
+            return tomo.find_centers(
+                nxroot, find_center_config, calibrate_center_rows)
+
         # Reduce tomography images
         if reduce_data or reduce_data_config is not None:
             if nxroot is None:
                 raise RuntimeError('Map info required to reduce the '
                                    'tomography images')
-            nxroot = tomo.gen_reduced_data(nxroot, reduce_data_config)
+            nxroot, _ = tomo.reduce_data(nxroot, reduce_data_config)
 
-        # Find rotation axis centers for the tomography stacks
+        # Find calibrated center axis info for the tomography stacks
         center_config = None
         if find_center or find_center_config is not None:
             run_find_centers = False
@@ -534,22 +571,17 @@ class TomoDataProcessor(Processor):
                 find_center_config = TomoFindCenterConfig()
                 run_find_centers = True
             else:
-                if (None in (find_center_config.lower_row,
-                             find_center_config.upper_row)
-                        or find_center_config.lower_center_offset is None
-                        or find_center_config.upper_center_offset is None):
+                if (find_center_config.center_rows is None
+                        or find_center_config.center_offsets is None):
                     run_find_centers = True
             if run_find_centers:
                 center_config = tomo.find_centers(nxroot, find_center_config)
             else:
                 # RV make a convert to dict in basemodel?
                 center_config = {
-                    'lower_row': find_center_config.lower_row,
-                    'lower_center_offset': 
-                        find_center_config.lower_center_offset,
-                    'upper_row': find_center_config.upper_row,
-                    'upper_center_offset':
-                         find_center_config.upper_center_offset,
+                    'center_rows': find_center_config.center_rows,
+                    'center_offsets': 
+                        find_center_config.center_offsets,
                     'center_stack_index':
                          find_center_config.center_stack_index,
                 }
@@ -579,13 +611,13 @@ def nxcopy(nxobject, exclude_nxpaths=None, nxpath_prefix=''):
     Function that returns a copy of a nexus object, optionally exluding
     certain child items.
 
-    :param nxobject: the original nexus object to return a "copy" of
+    :param nxobject: The input nexus object to "copy".
     :type nxobject: nexusformat.nexus.NXobject
-    :param exlude_nxpaths: a list of paths to child nexus objects that
-        should be excluded from the returned "copy", defaults to `[]`
+    :param exlude_nxpaths: A list of paths to child nexus objects that
+        should be excluded from the returned "copy", defaults to `[]`.
     :type exclude_nxpaths: list[str], optional
     :param nxpath_prefix: For use in recursive calls from inside this
-        function only!
+        function only.
     :type nxpath_prefix: str
     :return: Copy of the input `nxobject` with some children optionally
         exluded.
@@ -629,7 +661,7 @@ class SetNumexprThreads:
         Initialize SetNumexprThreads.
 
         :param num_core: Number of processors used by the num_expr
-            package
+            package.
         :type num_core: int
         """
         # System modules
@@ -663,23 +695,21 @@ class Tomo:
 
     def __init__(
             self, interactive=False, num_core=-1, output_folder='.',
-            save_figs='no', test_mode=False):
+            save_figs='no'):
         """
         Initialize Tomo.
 
         :param interactive: Allows for user interactions,
             defaults to False.
         :type interactive: bool, optional
-        :param num_core: Number of processors
+        :param num_core: Number of processors.
         :type num_core: int
         :param output_folder: Output folder name, defaults to '.'.
         :type output_folder:: str, optional
         :param save_figs: Safe figures to file ('yes' or 'only') and/or
             display figures ('yes' or 'no'), defaults to 'no'.
         :type save_figs: Literal['yes', 'no', 'only'], optional
-        :param test_mode: Run in test mode (non-interactively), defaults
-            to False
-        :type test_mode: bool, optional
+        :raises ValueError: Invalid input parameter.
         """
         # System modules
         from logging import getLogger
@@ -696,17 +726,7 @@ class Tomo:
         self._output_folder = os_path.abspath(output_folder)
         if not os_path.isdir(self._output_folder):
             mkdir(self._output_folder)
-        if self._interactive:
-            self._test_mode = False
-        else:
-            if not isinstance(test_mode, bool):
-                raise ValueError(f'Invalid parameter test_mode ({test_mode})')
-            self._test_mode = test_mode
         self._test_config = {}
-        if self._test_mode:
-            if save_figs != 'only':
-                self._logger.warning('Ignoring save_figs in test mode')
-            save_figs = 'only'
         if save_figs == 'only':
             self._save_only = True
             self._save_figs = True
@@ -732,16 +752,18 @@ class Tomo:
                 f'of available processors and reduced to {cpu_count()}')
             self._num_core = cpu_count()
 
-    def gen_reduced_data(self, nxroot, tool_config=None):
+    def reduce_data(
+            self, nxroot, tool_config=None, calibrate_center_rows=False):
         """
-        Generate the reduced tomography images.
+        Reduced the tomography images.
 
         :param nxroot: Data object containing the raw data info and
-            metadata required for a tomography data reduction
+            metadata required for a tomography data reduction.
         :type nxroot: nexusformat.nexus.NXroot
-        :param tool_config: Tool configuration
+        :param tool_config: Tool configuration.
         :type tool_config: CHAP.tomo.models.TomoReduceConfig, optional
-        :return: Reduced tomography data
+        :raises ValueError: Invalid input or configuration parameter.
+        :return: Reduced tomography data.
         :rtype: nexusformat.nexus.NXroot
         """
         # Third party modules
@@ -763,25 +785,36 @@ class Tomo:
             img_row_bounds = None
         else:
             delta_theta = tool_config.delta_theta
-            img_row_bounds = tool_config.img_row_bounds
+            img_row_bounds = tuple(tool_config.img_row_bounds)
+            if img_row_bounds is not None:
+                if (nxentry.instrument.source.attrs['station']
+                        in ('id1a3', 'id3a')):
+                    self._logger.warning('Ignoring parameter img_row_bounds '
+                                        'for id1a3 and id3a')
+                    img_row_bounds = None
+                elif calibrate_center_rows:
+                    self._logger.warning('Ignoring parameter img_row_bounds '
+                                        'during rotation axis calibration')
+                    img_row_bounds = None
 
         image_key = nxentry.instrument.detector.get('image_key', None)
         if image_key is None or 'data' not in nxentry.instrument.detector:
             raise ValueError(f'Unable to find image_key or data in '
                              'instrument.detector '
                              f'({nxentry.instrument.detector.tree})')
+        image_key = np.asarray(image_key)
 
         # Create an NXprocess to store data reduction (meta)data
         reduced_data = NXprocess()
 
         # Generate dark field
-        reduced_data = self._gen_dark(nxentry, reduced_data)
+        reduced_data = self._gen_dark(nxentry, reduced_data, image_key)
 
         # Generate bright field
-        reduced_data = self._gen_bright(nxentry, reduced_data)
+        reduced_data = self._gen_bright(nxentry, reduced_data, image_key)
 
         # Get rotation angles for image stacks
-        thetas = self._gen_thetas(nxentry)
+        thetas = self._gen_thetas(nxentry, image_key)
 
         # Get the image stack mask to remove bad images from stack
         image_mask = None
@@ -790,7 +823,7 @@ class Tomo:
             if delta_theta is not None:
                 delta_theta = None
                 self._logger.warning(
-                    'Ignore delta_theta when an image mask is used')
+                    'Ignoring delta_theta when an image mask is used')
             np.random.seed(0)
             image_mask = np.where(np.random.rand(
                 len(thetas)) < drop_fraction/100, 0, 1).astype(bool)
@@ -812,19 +845,32 @@ class Tomo:
             self._logger.debug(f'image_mask = {image_mask}')
             reduced_data.image_mask = image_mask
             thetas = thetas[image_mask]
-        self._logger.debug(f'thetas = {thetas}')
-        reduced_data.rotation_angle = thetas
-        reduced_data.rotation_angle.units = 'degrees'
 
-        # Set vertical detector bounds for image stack
+        # Set vertical detector bounds for image stack or rotation
+        # axis calibration rows
         img_row_bounds = self._set_detector_bounds(
-            nxentry, reduced_data, thetas[0], img_row_bounds=img_row_bounds)
+            nxentry, reduced_data, image_key, thetas[0],
+            img_row_bounds, calibrate_center_rows)
         self._logger.info(f'img_row_bounds = {img_row_bounds}')
+        if calibrate_center_rows:
+            calibrate_center_rows = tuple(sorted(img_row_bounds))
+            img_row_bounds = None
+        if img_row_bounds is None:
+            tbf_shape = np.asarray(reduced_data.data.bright_field).shape
+            img_row_bounds = (0, tbf_shape[0])
         reduced_data.img_row_bounds = img_row_bounds
         reduced_data.img_row_bounds.units = 'pixels'
+        reduced_data.img_row_bounds.attrs['long_name'] = \
+            'image row boundaries in detector frame of reference'
+
+        # Store rotation angles for image stacks
+        self._logger.debug(f'thetas = {thetas}')
+        reduced_data.rotation_angle = thetas
+        reduced_data.rotation_angle.units = 'degrees'
 
         # Generate reduced tomography fields
-        reduced_data = self._gen_tomo(nxentry, reduced_data)
+        reduced_data = self._gen_tomo(
+            nxentry, reduced_data, image_key, calibrate_center_rows)
 
         # Create a copy of the input Nexus object and remove raw and
         #     any existing reduced data
@@ -857,18 +903,20 @@ class Tomo:
             nxentry.reduced_data.rotation_angle, name='rotation_angle')
         nxentry.data.attrs['signal'] = 'reduced_data'
 
-        return nxroot
+        return nxroot, calibrate_center_rows
 
-    def find_centers(self, nxroot, tool_config):
+    def find_centers(self, nxroot, tool_config, calibrate_center_rows=False):
         """
         Find the calibrated center axis info
 
         :param nxroot: Data object containing the reduced data and
-            metadata required to find the calibrated center axis info
+            metadata required to find the calibrated center axis info.
         :type data: nexusformat.nexus.NXroot
-        :param tool_config: Tool configuration
+        :param tool_config: Tool configuration.
         :type tool_config: CHAP.tomo.models.TomoFindCenterConfig
-        :return: Calibrated center axis info
+        :raises ValueError: Invalid or missing input or configuration
+            parameter.
+        :return: Calibrated center axis info.
         :rtype: dict
         """
         # Third party modules
@@ -884,39 +932,24 @@ class Tomo:
             nxentry = nxroot[nxroot.attrs['default']]
         else:
             raise ValueError(f'Invalid parameter nxroot ({nxroot})')
-        center_rows = (tool_config.lower_row, tool_config.upper_row)
-        center_stack_index = tool_config.center_stack_index
-        if not self._interactive and center_rows == (None, None):
-            self._logger.warning(
-                'center_rows unspecified, find centers at reduced data bounds')
-        if (center_stack_index is not None
-                and (not isinstance(center_stack_index, int)
-                     or center_stack_index < 0)):
-            raise ValueError(
-                'Invalid parameter center_stack_index '
-                f'({center_stack_index})')
 
         # Check if reduced data is available
         if ('reduced_data' not in nxentry
                 or 'reduced_data' not in nxentry.data):
-            raise KeyError(f'Unable to find valid reduced data in {nxentry}.')
+            raise ValueError(f'Unable to find valid reduced data in {nxentry}.')
 
-        # Select the image stack to calibrate the center axis
+        # Select the image stack to find the calibrated center axis
         #     reduced data axes order: stack,theta,row,column
         # Note: Nexus can't follow a link if the data it points to is
         #     too big get the data from the actual place, not from
         #     nxentry.data
         num_tomo_stacks = nxentry.reduced_data.data.tomo_fields.shape[0]
-        img_shape = nxentry.reduced_data.data.bright_field.shape
-        num_row = int(nxentry.reduced_data.img_row_bounds[1]
-                   - nxentry.reduced_data.img_row_bounds[0])
         if num_tomo_stacks == 1:
             center_stack_index = 0
-            default = 'n'
         else:
-            if self._test_mode:
-                # Convert input value to offset 0
-                center_stack_index = self._test_config['center_stack_index']
+            center_stack_index = tool_config.center_stack_index
+            if calibrate_center_rows:
+                center_stack_index = int(num_tomo_stacks/2)
             elif self._interactive:
                 if center_stack_index is None:
                     center_stack_index = input_int(
@@ -928,119 +961,121 @@ class Tomo:
                     center_stack_index = int(num_tomo_stacks/2)
                     self._logger.warning(
                         'center_stack_index unspecified, use stack '
-                        f'{center_stack_index} to find centers')
-            default = 'y'
+                        f'{center_stack_index} to find center axis info')
 
         # Get thetas (in degrees)
         thetas = np.asarray(nxentry.reduced_data.rotation_angle)
 
+        # Select center rows
+        if calibrate_center_rows:
+            center_rows = calibrate_center_rows
+            offset_center_rows = (0, 1)
+        else:
+            # Third party modules
+            import matplotlib.pyplot as plt
+
+            # Get full bright field
+            tbf = np.asarray(nxentry.reduced_data.data.bright_field)
+            tbf_shape = tbf.shape
+
+            # Get image bounds
+            img_row_bounds = nxentry.reduced_data.get(
+                'img_row_bounds', (0, tbf_shape[0]))
+            img_row_bounds = (int(img_row_bounds[0]), int(img_row_bounds[1]))
+            img_column_bounds = nxentry.reduced_data.get(
+                'img_column_bounds', (0, tbf_shape[1]))
+            img_column_bounds = (
+                int(img_column_bounds[0]), int(img_column_bounds[1]))
+
+            center_rows = tool_config.center_rows
+            if center_rows is None:
+                if num_tomo_stacks == 1:
+                    # Add a small margin to avoid edge effects
+                    offset = min(
+                        5, int(0.1*(img_row_bounds[1] - img_row_bounds[0])))
+                    center_rows = (
+                        img_row_bounds[0]+offset, img_row_bounds[1]-1-offset)
+                else:
+                    if not self._interactive:
+                        self._logger.warning('center_rows unspecified, find '
+                                             'centers at reduced data bounds')
+                    center_rows = (img_row_bounds[0], img_row_bounds[1]-1)
+            fig, center_rows = select_image_indices(
+                nxentry.reduced_data.data.tomo_fields[
+                    center_stack_index,0,:,:],
+                0,
+                b=tbf[img_row_bounds[0]:img_row_bounds[1],
+                      img_column_bounds[0]:img_column_bounds[1]], 
+                preselected_indices=center_rows,
+                axis_index_offset=img_row_bounds[0],
+                title='Select two detector image row indices to find center '
+                    f'axis (in range [{img_row_bounds[0]}, '
+                    f'{img_row_bounds[1]-1}])',
+                title_a=r'Tomography image at $\theta$ = '
+                        f'{round(thetas[0], 2)+0}',
+                title_b='Bright field', interactive=self._interactive)
+            if center_rows[1] == img_row_bounds[1]:
+                center_rows = (center_rows[0], center_rows[1]-1)
+            offset_center_rows = (
+                center_rows[0] - img_row_bounds[0],
+                center_rows[1] - img_row_bounds[0])
+            # Plot results
+            if self._save_figs:
+                fig.savefig(
+                    os_path.join(
+                        self._output_folder, 'center_finding_rows.png'))
+            plt.close()
+
         # Get effective pixel_size
         if 'zoom_perc' in nxentry.reduced_data:
-            eff_pixel_size = \
+            eff_pixel_size = float(
                 100. * (nxentry.instrument.detector.row_pixel_size
-                         / nxentry.reduced_data.attrs['zoom_perc'])
+                         / nxentry.reduced_data.attrs['zoom_perc']))
         else:
-            eff_pixel_size = nxentry.instrument.detector.row_pixel_size
+            eff_pixel_size = float(nxentry.instrument.detector.row_pixel_size)
+        self._logger.debug(f'eff_pixel_size = {eff_pixel_size}')
 
         # Get cross sectional diameter
-        cross_sectional_dim = img_shape[1]*eff_pixel_size
+        cross_sectional_dim = \
+            eff_pixel_size * nxentry.reduced_data.data.bright_field.shape[1]
         self._logger.debug(f'cross_sectional_dim = {cross_sectional_dim}')
 
-        # Determine center offset at sample row boundaries
-        self._logger.info('Determine center offset at sample row boundaries')
-
-        # Lower row center
-        if self._test_mode:
-            lower_row = self._test_config['lower_row']
-        elif self._interactive:
-            if center_rows is not None and center_rows[0] is not None:
-                lower_row = center_rows[0]
-                if not 0 <= lower_row < num_row-1:
-                    raise ValueError(
-                        f'Invalid parameter center_rows ({center_rows})')
-            else:
-                lower_row = select_one_image_bound(
-                    nxentry.reduced_data.data.tomo_fields[
-                        center_stack_index,0,:,:],
-                    0, bound=0,
-                    title=f'theta={round(thetas[0], 2)+0}',
-                    bound_name='row index to find lower center',
-                    default=default, raise_error=True)
-        else:
-            if center_rows is None or center_rows[0] is None:
-                lower_row = 0
-            else:
-                lower_row = center_rows[0]
-                if not 0 <= lower_row < num_row-1:
-                    raise ValueError(
-                        f'Invalid parameter center_rows ({center_rows})')
-        t0 = time()
-        lower_center_offset = self._find_center_one_plane(
-            nxentry.reduced_data.data.tomo_fields[
-                center_stack_index,:,lower_row,:],
-            lower_row, thetas, eff_pixel_size, cross_sectional_dim,
-            path=self._output_folder, num_core=self._num_core,
-            search_range=tool_config.search_range,
-            search_step=tool_config.search_step,
-            gaussian_sigma=tool_config.gaussian_sigma,
-            ring_width=tool_config.ring_width)
-        self._logger.info(f'Finding center took {time()-t0:.2f} seconds')
-        self._logger.debug(f'lower_row = {lower_row:.2f}')
-        self._logger.debug(f'lower_center_offset = {lower_center_offset:.2f}')
-
-        # Upper row center
-        if self._test_mode:
-            upper_row = self._test_config['upper_row']
-        elif self._interactive:
-            if center_rows is not None and center_rows[1] is not None:
-                upper_row = center_rows[1]
-                if not lower_row < upper_row < num_row:
-                    raise ValueError(
-                        f'Invalid parameter center_rows ({center_rows})')
-            else:
-                upper_row = select_one_image_bound(
+        # Find the center offsets at each of the center rows
+        prev_center_offset = None
+        center_offsets = []
+        for row, offset_row in zip(center_rows, offset_center_rows):
+            t0 = time()
+            center_offsets.append(
+                self._find_center_one_plane(
                     nxentry.reduced_data.data.tomo_fields[
-                        center_stack_index,0,:,:],
-                    0, bound=num_row-1,
-                    title=f'theta = {round(thetas[0], 2)+0}',
-                    bound_name='row index to find upper center',
-                    default=default, raise_error=True)
-        else:
-            if center_rows is None or center_rows[1] is None:
-                upper_row = num_row-1
-            else:
-                upper_row = center_rows[1]
-                if not lower_row < upper_row < num_row:
-                    raise ValueError(
-                        f'Invalid parameter center_rows ({center_rows})')
-        t0 = time()
-        upper_center_offset = self._find_center_one_plane(
-            nxentry.reduced_data.data.tomo_fields[
-                center_stack_index,:,upper_row,:],
-            upper_row, thetas, eff_pixel_size, cross_sectional_dim,
-            path=self._output_folder, num_core=self._num_core,
-            search_range=tool_config.search_range,
-            search_step=tool_config.search_step,
-            gaussian_sigma=tool_config.gaussian_sigma,
-            ring_width=tool_config.ring_width)
-        self._logger.info(f'Finding center took {time()-t0:.2f} seconds')
-        self._logger.debug(f'upper_row = {upper_row:.2f}')
-        self._logger.debug(f'upper_center_offset = {upper_center_offset:.2f}')
+                        center_stack_index,:,offset_row,:],
+                    row, thetas, eff_pixel_size, cross_sectional_dim,
+                    path=self._output_folder, num_core=self._num_core,
+                    center_offset_min=tool_config.center_offset_min,
+                    center_offset_max=tool_config.center_offset_max,
+                    gaussian_sigma=tool_config.gaussian_sigma,
+                    ring_width=tool_config.ring_width,
+                    prev_center_offset=prev_center_offset))
+            self._logger.info(
+                f'Finding center row {row} took {time()-t0:.2f} seconds')
+            self._logger.debug(f'center_row = {row:.2f}')
+            self._logger.debug(f'center_offset = {center_offsets[-1]:.2f}')
+            prev_center_offset = center_offsets[-1]
 
         center_config = {
-            'lower_row': lower_row,
-            'lower_center_offset': lower_center_offset,
-            'upper_row': upper_row,
-            'upper_center_offset': upper_center_offset,
+            'center_rows': list(center_rows),
+            'center_offsets': center_offsets,
         }
         if num_tomo_stacks > 1:
             center_config['center_stack_index'] = center_stack_index
-
-        # Save test data to file
-        if self._test_mode:
-            with open(f'{self._output_folder}/center_config.yaml', 'w',
-                      encoding='utf8') as f:
-                safe_dump(center_config, f)
+        if tool_config.center_offset_min is not None:
+            center_config['center_offset_min'] = tool_config.center_offset_min
+        if tool_config.center_offset_max is not None:
+            center_config['center_offset_max'] = tool_config.center_offset_max
+        if tool_config.gaussian_sigma is not None:
+            center_config['gaussian_sigma'] = tool_config.gaussian_sigma
+        if tool_config.ring_width is not None:
+            center_config['ring_width'] = tool_config.ring_width
 
         return center_config
 
@@ -1048,13 +1083,16 @@ class Tomo:
         """
         Reconstruct the tomography data.
 
-        :param nxroot: Reduced data
+        :param nxroot: Data object containing the reduced data and
+            metadata required for a tomography data reconstruction.
         :type data: nexusformat.nexus.NXroot
-        :param center_info: Calibrated center axis info
+        :param center_info: Calibrated center axis info.
         :type center_info: dict
-        :param tool_config: Tool configuration
+        :param tool_config: Tool configuration.
         :type tool_config: CHAP.tomo.models.TomoReconstructConfig
-        :return: Reconstructed tomography data
+        :raises ValueError: Invalid or missing input or configuration
+            parameter.
+        :return: Reconstructed tomography data.
         :rtype: nexusformat.nexus.NXroot
         """
         # Third party modules
@@ -1066,9 +1104,6 @@ class Tomo:
             NXroot,
         )
 
-        # Local modules
-        from CHAP.utils.general import is_int_pair
-
         self._logger.info('Reconstruct the tomography data')
 
         if isinstance(nxroot, NXroot):
@@ -1081,30 +1116,27 @@ class Tomo:
         # Check if reduced data is available
         if ('reduced_data' not in nxentry
                 or 'reduced_data' not in nxentry.data):
-            raise KeyError(f'Unable to find valid reduced data in {nxentry}.')
+            raise ValueError(f'Unable to find valid reduced data in {nxentry}.')
 
         # Create an NXprocess to store image reconstruction (meta)data
         nxprocess = NXprocess()
 
-        # Get rotation axis rows and centers
-        lower_row = center_info.get('lower_row')
-        lower_center_offset = center_info.get('lower_center_offset')
-        upper_row = center_info.get('upper_row')
-        upper_center_offset = center_info.get('upper_center_offset')
-        if (lower_row is None or lower_center_offset is None
-                or upper_row is None or upper_center_offset is None):
+        # Get calibrated center axis rows and centers
+        center_rows = center_info.get('center_rows')
+        center_offsets = center_info.get('center_offsets')
+        if center_rows is None or center_offsets is None:
             raise KeyError(
                 'Unable to find valid calibrated center axis info in '
                 f'{center_info}.')
-        center_slope = (upper_center_offset-lower_center_offset) \
-            / (upper_row-lower_row)
+        center_slope = (center_offsets[1]-center_offsets[0]) \
+            / (center_rows[1]-center_rows[0])
 
         # Get thetas (in degrees)
         thetas = np.asarray(nxentry.reduced_data.rotation_angle)
 
         # Reconstruct tomography data
         #     reduced data axes order: stack,theta,row,column
-        #     reconstructed data order in each stack: row/z,x,y
+        #     reconstructed data: row/-z,y,x
         # Note: Nexus can't follow a link if the data it points to is
         #     too big get the data from the actual place, not from
         #     nxentry.data
@@ -1115,6 +1147,9 @@ class Tomo:
         tomo_stacks = np.asarray(nxentry.reduced_data.data.tomo_fields)
         num_tomo_stacks = tomo_stacks.shape[0]
         tomo_recon_stacks = num_tomo_stacks*[np.array([])]
+        img_row_bounds = tuple(nxentry.reduced_data.get(
+            'img_row_bounds', (0, tomo_stacks.shape[2])))
+        center_rows -= img_row_bounds[0]
         for i in range(num_tomo_stacks):
             # Convert reduced data stack from theta,row,column to
             #     row,theta,column
@@ -1130,11 +1165,11 @@ class Tomo:
                     'reconstruction')
             tomo_stack = np.swapaxes(tomo_stack, 0, 1)
             assert len(thetas) == tomo_stack.shape[1]
-            assert 0 <= lower_row < upper_row < tomo_stack.shape[0]
+            assert 0 <= center_rows[0] < center_rows[1] < tomo_stack.shape[0]
             center_offsets = [
-                lower_center_offset-lower_row*center_slope,
-                upper_center_offset + center_slope * (
-                    tomo_stack.shape[0]-1-upper_row),
+                center_offsets[0]-center_rows[0]*center_slope,
+                center_offsets[1] + center_slope * (
+                    tomo_stack.shape[0]-1-center_rows[1]),
             ]
             t0 = time()
             tomo_recon_stack = self._reconstruct_one_tomo_stack(
@@ -1150,124 +1185,181 @@ class Tomo:
             tomo_recon_stacks[i] = tomo_recon_stack
 
         # Resize the reconstructed tomography data
-        #     reconstructed data order in each stack: row/z,x,y
-        if self._test_mode:
-            x_bounds = tuple(self._test_config.get('x_bounds'))
-            y_bounds = tuple(self._test_config.get('y_bounds'))
-            z_bounds = None
-        elif self._interactive:
-            x_bounds, y_bounds, z_bounds = self._resize_reconstructed_data(
-                tomo_recon_stacks, x_bounds=tool_config.x_bounds,
-                y_bounds=tool_config.y_bounds, z_bounds=tool_config.z_bounds)
-        else:
-            x_bounds = tool_config.x_bounds
-            if x_bounds is None:
-                self._logger.warning(
-                    'x_bounds unspecified, reconstruct data for full x-range')
-            elif not is_int_pair(x_bounds, ge=0,
-                                 lt=tomo_recon_stacks[0].shape[1]):
-                raise ValueError(f'Invalid parameter x_bounds ({x_bounds})')
-            y_bounds = tool_config.y_bounds
-            if y_bounds is None:
-                self._logger.warning(
-                    'y_bounds unspecified, reconstruct data for full y-range')
-            elif not is_int_pair(
-                    y_bounds, ge=0, lt=tomo_recon_stacks[0].shape[2]):
-                raise ValueError(f'Invalid parameter y_bounds ({y_bounds})')
-            z_bounds = None
+        #     reconstructed data order in each stack: row/-z,y,x
+        tomo_recon_shape = tomo_recon_stacks[0].shape
+        x_bounds, y_bounds, z_bounds = self._resize_reconstructed_data(
+            tomo_recon_stacks, x_bounds=tool_config.x_bounds,
+            y_bounds=tool_config.y_bounds, z_bounds=tool_config.z_bounds)
         if x_bounds is None:
-            x_range = (0, tomo_recon_stacks[0].shape[1])
+            x_range = (0, tomo_recon_shape[2])
             x_slice = int(x_range[1]/2)
         else:
             x_range = (min(x_bounds), max(x_bounds))
             x_slice = int((x_bounds[0]+x_bounds[1]) / 2)
         if y_bounds is None:
-            y_range = (0, tomo_recon_stacks[0].shape[2])
+            y_range = (0, tomo_recon_shape[1])
             y_slice = int(y_range[1] / 2)
         else:
             y_range = (min(y_bounds), max(y_bounds))
             y_slice = int((y_bounds[0]+y_bounds[1]) / 2)
         if z_bounds is None:
-            z_range = (0, tomo_recon_stacks[0].shape[0])
+            z_range = (0, tomo_recon_shape[0])
             z_slice = int(z_range[1] / 2)
         else:
             z_range = (min(z_bounds), max(z_bounds))
             z_slice = int((z_bounds[0]+z_bounds[1]) / 2)
+        z_dim_org = tomo_recon_shape[0]
         for i, stack in enumerate(tomo_recon_stacks):
             tomo_recon_stacks[i] = stack[
-                z_range[0]:z_range[1],x_range[0]:x_range[1],y_range[0]:y_range[1]]
+                z_range[0]:z_range[1],y_range[0]:y_range[1],
+                x_range[0]:x_range[1]]
         tomo_recon_stacks = np.asarray(tomo_recon_stacks)
 
-        # Plot a few reconstructed image slices
-        if self._save_figs:
-            for i in range(tomo_recon_stacks.shape[0]):
-                if num_tomo_stacks == 1:
-                    basetitle = 'recon'
-                else:
-                    basetitle = f'recon stack {i}'
-                title = f'{basetitle} {res_title} xslice{x_slice}'
-                row_pixel_size = nxentry.instrument.detector.row_pixel_size
-                column_pixel_size = \
-                    nxentry.instrument.detector.column_pixel_size
+        row_pixel_size = float(
+            nxentry.instrument.detector.row_pixel_size)
+        column_pixel_size = float(
+            nxentry.instrument.detector.column_pixel_size)
+        if num_tomo_stacks == 1:
+            # Convert the reconstructed tomography data from internal
+            #     coordinate frame row/-z,y,x with the origin on the
+            #     near-left-top corner to an z,y,x coordinate frame
+            #     with the origin on the par file x,z values, halfway
+            #     in the y-dimension.
+            #     Here x is to the right, y along the beam direction
+            #     and z upwards in the lab frame of reference
+            tomo_recon_stack = np.flip(tomo_recon_stacks[0], 0)
+            z_range = (z_dim_org-z_range[1], z_dim_org-z_range[0])
+
+            # Get coordinate axes
+            x = column_pixel_size * (
+                np.linspace(
+                    x_range[0], x_range[1], x_range[1]-x_range[0], False)
+                - 0.5*nxentry.instrument.detector.columns
+                + 0.5)
+            x = np.asarray(x + nxentry.reduced_data.x_translation[0])
+            y = np.asarray(
+                    column_pixel_size * (
+                    np.linspace(
+                        y_range[0], y_range[1], y_range[1]-y_range[0], False)
+                    - 0.5*nxentry.instrument.detector.columns
+                    + 0.5))
+            z = row_pixel_size*(
+                np.linspace(
+                    z_range[0], z_range[1], z_range[1]-z_range[0], False)
+                + nxentry.instrument.detector.rows
+                - int(nxentry.reduced_data.img_row_bounds[1])
+                + 0.5)
+            z = np.asarray(z + nxentry.reduced_data.z_translation[0])
+
+            # Plot a few reconstructed image slices
+            if self._save_figs:
+                x_index = x_slice-x_range[0]
                 extent = (
-                    0,
-                    float(column_pixel_size*tomo_recon_stacks.shape[3]),
-                    float(row_pixel_size*tomo_recon_stacks.shape[1]),
-                    0)
+                    y[0],
+                    y[-1],
+                    z[0],
+                    z[-1])
                 quick_imshow(
-                    tomo_recon_stacks[i,:,x_slice-x_range[0],:],
-                    title=title, path=self._output_folder, save_fig=True,
-                    save_only=True, extent=extent)
-                title = f'{basetitle} {res_title} yslice{y_slice}'
+                    tomo_recon_stack[:,:,x_index], 
+                    title=f'recon {res_title} x={x[x_index]:.4f}',
+                    origin='lower', extent=extent, path=self._output_folder,
+                    save_fig=True, save_only=True)
+                y_index = y_slice-y_range[0]
                 extent = (
-                    0,
-                    float(column_pixel_size*tomo_recon_stacks.shape[2]),
-                    float(row_pixel_size*tomo_recon_stacks.shape[1]),
-                    0)
+                    x[0],
+                    x[-1],
+                    z[0],
+                    z[-1])
                 quick_imshow(
-                    tomo_recon_stacks[i,:,:,y_slice-y_range[0]],
-                    title=title, path=self._output_folder, save_fig=True,
-                    save_only=True, extent=extent)
-                title = f'{basetitle} {res_title} zslice{z_slice}'
+                    tomo_recon_stack[:,y_index,:],
+                    title=f'recon {res_title} y={y[y_index]:.4f}',
+                    origin='lower', extent=extent, path=self._output_folder,
+                    save_fig=True, save_only=True)
+                z_index = z_slice-z_range[0]
                 extent = (
-                    0,
-                    float(column_pixel_size*tomo_recon_stacks.shape[3]),
-                    float(column_pixel_size*tomo_recon_stacks.shape[2]),
-                    0)
+                    x[0],
+                    x[-1],
+                    y[0],
+                    y[-1])
                 quick_imshow(
-                    tomo_recon_stacks[i,z_slice-z_range[0],:,:],
-                    title=title, path=self._output_folder, save_fig=True,
-                    save_only=True, extent=extent)
-
-        # Save test data to file
-        #     reconstructed data order in each stack: row/z,x,y
-        if self._test_mode:
-            for i in range(tomo_recon_stacks.shape[0]):
-                np.savetxt(
-                    f'{self._output_folder}/recon_stack_{i}.txt',
-                    tomo_recon_stacks[i,z_slice,:,:],
-                    fmt='%.6e')
+                    tomo_recon_stack[z_index,:,:],
+                    title=f'recon {res_title} z={z[z_index]:.4f}',
+                    origin='lower', extent=extent, path=self._output_folder,
+                    save_fig=True, save_only=True)
+        else:
+            # Plot a few reconstructed image slices
+            if self._save_figs:
+                for i in range(tomo_recon_stacks.shape[0]):
+                    basetitle = f'recon stack {i}'
+                    title = f'{basetitle} {res_title} xslice{x_slice}'
+                    quick_imshow(
+                        tomo_recon_stacks[i,:,:,x_slice-x_range[0]],
+                        title=title, path=self._output_folder,
+                        save_fig=True, save_only=True)
+                    title = f'{basetitle} {res_title} yslice{y_slice}'
+                    quick_imshow(
+                        tomo_recon_stacks[i,:,y_slice-y_range[0],:],
+                        title=title, path=self._output_folder,
+                        save_fig=True, save_only=True)
+                    title = f'{basetitle} {res_title} zslice{z_slice}'
+                    quick_imshow(
+                        tomo_recon_stacks[i,z_slice-z_range[0],:,:],
+                        title=title, path=self._output_folder,
+                        save_fig=True, save_only=True)
 
         # Add image reconstruction to reconstructed data NXprocess
-        #     reconstructed data order in each stack: row/z,x,y
+        #     reconstructed data order:
+        #     - for one stack: z,y,x
+        #     - for multiple stacks: row/-z,y,x
         nxprocess.data = NXdata()
         nxprocess.attrs['default'] = 'data'
         for k, v in center_info.items():
             nxprocess[k] = v
+            if k == 'center_rows' or k == 'center_offsets':
+                nxprocess[k].units = 'pixels'
+            if k == 'center_rows':
+                nxprocess[k].attrs['long_name'] = \
+                    'center row indices in detector frame of reference'
         if x_bounds is not None:
             nxprocess.x_bounds = x_bounds
+            nxprocess.x_bounds.units = 'pixels'
+            nxprocess.x_bounds.attrs['long_name'] = \
+                'x range indices in reduced data frame of reference'
         if y_bounds is not None:
             nxprocess.y_bounds = y_bounds
+            nxprocess.y_bounds.units = 'pixels'
+            nxprocess.y_bounds.attrs['long_name'] = \
+                'y range indices in reduced data frame of reference'
         if z_bounds is not None:
             nxprocess.z_bounds = z_bounds
-        nxprocess.data.reconstructed_data = tomo_recon_stacks
+            nxprocess.z_bounds.units = 'pixels'
+            nxprocess.z_bounds.attrs['long_name'] = \
+                'z range indices in reduced data frame of reference'
         nxprocess.data.attrs['signal'] = 'reconstructed_data'
+        if num_tomo_stacks == 1:
+            nxprocess.data.reconstructed_data = tomo_recon_stack
+            nxprocess.data.attrs['axes'] = ['z', 'y', 'x']
+            nxprocess.data.attrs['x_indices'] = 2
+            nxprocess.data.attrs['y_indices'] = 1
+            nxprocess.data.attrs['z_indices'] = 0
+            nxprocess.data.x = x
+            nxprocess.data.x.units = \
+                nxentry.instrument.detector.column_pixel_size.units
+            nxprocess.data.y = y
+            nxprocess.data.y.units = \
+                nxentry.instrument.detector.column_pixel_size.units
+            nxprocess.data.z = z
+            nxprocess.data.z.units = \
+                nxentry.instrument.detector.row_pixel_size.units
+        else:
+            nxprocess.data.reconstructed_data = tomo_recon_stacks
 
         # Create a copy of the input Nexus object and remove reduced
         #     data
         exclude_items = [
             f'{nxentry.nxname}/reduced_data/data',
             f'{nxentry.nxname}/data/reduced_data',
+            f'{nxentry.nxname}/data/rotation_angle',
         ]
         nxroot_copy = nxcopy(nxroot, exclude_nxpaths=exclude_items)
 
@@ -1280,17 +1372,28 @@ class Tomo:
         nxentry_copy.data.makelink(
             nxprocess.data.reconstructed_data, name='reconstructed_data')
         nxentry_copy.data.attrs['signal'] = 'reconstructed_data'
+        if num_tomo_stacks == 1:
+            nxentry_copy.data.attrs['axes'] = ['z', 'y', 'x']
+            nxentry_copy.data.attrs['x_indices'] = 2
+            nxentry_copy.data.attrs['y_indices'] = 1
+            nxentry_copy.data.attrs['z_indices'] = 0
+            nxentry_copy.data.makelink(nxprocess.data.x, name='x')
+            nxentry_copy.data.makelink(nxprocess.data.y, name='y')
+            nxentry_copy.data.makelink(nxprocess.data.z, name='z')
 
         return nxroot_copy
 
     def combine_data(self, nxroot, tool_config):
         """Combine the reconstructed tomography stacks.
 
-        :param nxroot: A stack of reconstructed tomography datasets
+        :param nxroot: Data object containing the reconstructed data
+            and metadata required to combine the tomography stacks.
         :type data: nexusformat.nexus.NXroot
-        :param tool_config: Tool configuration
+        :param tool_config: Tool configuration.
         :type tool_config: CHAP.tomo.models.TomoCombineConfig
-        :return: Combined reconstructed tomography data
+        :raises ValueError: Invalid or missing input or configuration
+            parameter.
+        :return: Combined reconstructed tomography data.
         :rtype: nexusformat.nexus.NXroot
         """
         # Third party modules
@@ -1301,9 +1404,6 @@ class Tomo:
             NXroot,
         )
 
-        # Local modules
-        from CHAP.utils.general import is_int_pair
-
         self._logger.info('Combine the reconstructed tomography stacks')
 
         if isinstance(nxroot, NXroot):
@@ -1321,137 +1421,187 @@ class Tomo:
         #     (meta)data
         nxprocess = NXprocess()
 
-        # Get the reconstructed data
-        #     reconstructed data order: stack,row(z),x,y
-        # Note: Nexus can't follow a link if the data it points to is
-        #     too big. So get the data from the actual place, not from
-        #     nxentry.data
-        num_tomo_stacks = \
-            nxentry.reconstructed_data.data.reconstructed_data.shape[0]
+        if nxentry.reconstructed_data.data.reconstructed_data.ndim == 3:
+            num_tomo_stacks = 1
+        else:
+            num_tomo_stacks = \
+                nxentry.reconstructed_data.data.reconstructed_data.shape[0]
         if num_tomo_stacks == 1:
             self._logger.info('Only one stack available: leaving combine_data')
-            return None
+            return nxroot
 
-        # Combine the reconstructed stacks
+        # Get and combine the reconstructed stacks
+        #     reconstructed data order: stack,row/-z,y,x
+        # Note: Nexus can't follow a link if the data it points to is
+        #     too big. So get the data from the actual place, not from
+        #     nxentry.data
         # (load one stack at a time to reduce risk of hitting Nexus
         #     data access limit)
         t0 = time()
         tomo_recon_combined = \
             nxentry.reconstructed_data.data.reconstructed_data[0,:,:,:]
-        if num_tomo_stacks > 2:
-            tomo_recon_combined = np.concatenate(
-                [tomo_recon_combined]
-                + [nxentry.reconstructed_data.data.reconstructed_data[i,:,:,:]
-                   for i in range(1, num_tomo_stacks-1)])
-        if num_tomo_stacks > 1:
-            tomo_recon_combined = np.concatenate(
-                [tomo_recon_combined]
-                + [nxentry.reconstructed_data.data.reconstructed_data[
-                   num_tomo_stacks-1,:,:,:]])
+        tomo_recon_combined = np.concatenate(
+            [tomo_recon_combined]
+            + [nxentry.reconstructed_data.data.reconstructed_data[i,:,:,:]
+               for i in range(1, num_tomo_stacks)])
         self._logger.info(
             f'Combining the reconstructed stacks took {time()-t0:.2f} seconds')
+        tomo_shape = tomo_recon_combined.shape
 
         # Resize the combined tomography data stacks
-        #     combined data order: row/z,x,y
-        if self._test_mode:
-            x_bounds = None
-            y_bounds = None
-            z_bounds = tuple(self._test_config.get('z_bounds'))
-        elif self._interactive:
+        #     combined data order: row/-z,y,x
+        if self._interactive:
             x_bounds, y_bounds, z_bounds = self._resize_reconstructed_data(
-                tomo_recon_combined, z_only=True)
+                tomo_recon_combined, combine_data=True)
         else:
             x_bounds = tool_config.x_bounds
             if x_bounds is None:
                 self._logger.warning(
                     'x_bounds unspecified, reconstruct data for full x-range')
             elif not is_int_pair(
-                    x_bounds, ge=0, lt=tomo_recon_combined.shape[1]):
+                    x_bounds, ge=0, le=tomo_shape[2]):
                 raise ValueError(f'Invalid parameter x_bounds ({x_bounds})')
             y_bounds = tool_config.y_bounds
             if y_bounds is None:
                 self._logger.warning(
                     'y_bounds unspecified, reconstruct data for full y-range')
             elif not is_int_pair(
-                    y_bounds, ge=0, lt=tomo_recon_combined.shape[2]):
+                    y_bounds, ge=0, le=tomo_shape[1]):
                 raise ValueError(f'Invalid parameter y_bounds ({y_bounds})')
-            z_bounds = None
+            z_bounds = tool_config.z_bounds
+            if z_bounds is None:
+                self._logger.warning(
+                    'z_bounds unspecified, reconstruct data for full z-range')
+            elif not is_int_pair(
+                    z_bounds, ge=0, le=tomo_shape[0]):
+                raise ValueError(f'Invalid parameter z_bounds ({z_bounds})')
         if x_bounds is None:
-            x_range = (0, tomo_recon_combined.shape[1])
+            x_range = (0, tomo_shape[2])
             x_slice = int(x_range[1]/2)
         else:
-            x_range = x_bounds
+            x_range = (min(x_bounds), max(x_bounds))
             x_slice = int((x_bounds[0]+x_bounds[1]) / 2)
         if y_bounds is None:
-            y_range = (0, tomo_recon_combined.shape[2])
+            y_range = (0, tomo_shape[1])
             y_slice = int(y_range[1]/2)
         else:
-            y_range = y_bounds
+            y_range = (min(y_bounds), max(y_bounds))
             y_slice = int((y_bounds[0]+y_bounds[1]) / 2)
         if z_bounds is None:
-            z_range = (0, tomo_recon_combined.shape[0])
+            z_range = (0, tomo_shape[0])
             z_slice = int(z_range[1]/2)
         else:
-            z_range = z_bounds
+            z_range = (min(z_bounds), max(z_bounds))
             z_slice = int((z_bounds[0]+z_bounds[1]) / 2)
+        z_dim_org = tomo_shape[0]
+        tomo_recon_combined = tomo_recon_combined[
+            z_range[0]:z_range[1],y_range[0]:y_range[1],x_range[0]:x_range[1]]
+
+        # Convert the reconstructed tomography data from internal
+        #     coordinate frame row/-z,y,x with the origin on the
+        #     near-left-top corner to an z,y,x coordinate frame.
+        #     Here x is to the right, y along the beam direction
+        #     and z upwards in the lab frame of reference
+        tomo_recon_combined = np.flip(tomo_recon_combined, 0)
+        tomo_shape = tomo_recon_combined.shape
+        z_range = (z_dim_org-z_range[1], z_dim_org-z_range[0])
+
+        # Get coordinate axes
+        row_pixel_size = float(
+            nxentry.instrument.detector.row_pixel_size)
+        column_pixel_size = float(
+            nxentry.instrument.detector.column_pixel_size)
+        x = column_pixel_size * (
+            np.linspace(x_range[0], x_range[1], x_range[1]-x_range[0], False)
+            - 0.5*nxentry.instrument.detector.columns
+            + 0.5)
+        if nxentry.reconstructed_data.get('x_bounds', None) is not None:
+            x += column_pixel_size*nxentry.reconstructed_data.x_bounds[0]
+        x = np.asarray(x + nxentry.reduced_data.x_translation[0])
+        y = column_pixel_size * (
+            np.linspace(y_range[0], y_range[1], y_range[1]-y_range[0], False)
+            - 0.5*nxentry.instrument.detector.columns
+            + 0.5)
+        if nxentry.reconstructed_data.get('y_bounds', None) is not None:
+            y += column_pixel_size*nxentry.reconstructed_data.y_bounds[0]
+        y = np.asarray(y)
+        z = row_pixel_size*(
+            np.linspace(z_range[0], z_range[1], z_range[1]-z_range[0], False)
+            - int(nxentry.reduced_data.img_row_bounds[0])
+            + 0.5*(nxentry.instrument.detector.rows)
+            -0.5)
+        z = np.asarray(z + nxentry.reduced_data.z_translation[0])
 
         # Plot a few combined image slices
         if self._save_figs:
-            row_pixel_size = nxentry.instrument.detector.row_pixel_size
-            column_pixel_size = nxentry.instrument.detector.column_pixel_size
             extent = (
-                0,
-                float(column_pixel_size*tomo_recon_combined.shape[2]),
-                float(row_pixel_size*tomo_recon_combined.shape[0]),
-                0)
+                y[0],
+                y[-1],
+                z[0],
+                z[-1])
+            x_slice = int(tomo_shape[2]/2)
             quick_imshow(
-                tomo_recon_combined[
-                    z_range[0]:z_range[1],x_slice,y_range[0]:y_range[1]],
-                title=f'recon combined xslice{x_slice}', extent=extent,
-                path=self._output_folder, save_fig=True, save_only=True)
+                tomo_recon_combined[:,:,x_slice],
+                title=f'recon combined x={x[x_slice]:.4f}', origin='lower',
+                extent=extent, path=self._output_folder, save_fig=True,
+                save_only=True)
             extent = (
-                0,
-                float(column_pixel_size*tomo_recon_combined.shape[1]),
-                float(row_pixel_size*tomo_recon_combined.shape[0]),
-                0)
+                x[0],
+                x[-1],
+                z[0],
+                z[-1])
+            y_slice = int(tomo_shape[1]/2)
             quick_imshow(
-                tomo_recon_combined[
-                    z_range[0]:z_range[1],x_range[0]:x_range[1],y_slice],
-                title=f'recon combined yslice{y_slice}', extent=extent,
-                path=self._output_folder, save_fig=True, save_only=True)
+                tomo_recon_combined[:,y_slice,:],
+                title=f'recon combined y={y[y_slice]:.4f}', origin='lower',
+                extent=extent, path=self._output_folder, save_fig=True,
+                save_only=True)
             extent = (
-                0,
-                float(column_pixel_size*tomo_recon_combined.shape[2]),
-                float(column_pixel_size*tomo_recon_combined.shape[1]),
-                0)
+                x[0],
+                x[-1],
+                y[0],
+                y[-1])
+            z_slice = int(tomo_shape[0]/2)
             quick_imshow(
-                tomo_recon_combined[
-                    z_slice,x_range[0]:x_range[1],y_range[0]:y_range[1]],
-                title=f'recon combined zslice{z_slice}', extent=extent,
-                path=self._output_folder, save_fig=True, save_only=True)
-
-        # Save test data to file
-        #     combined data order: row/z,x,y
-        if self._test_mode:
-            np.savetxt(
-                f'{self._output_folder}/recon_combined.txt',
-                tomo_recon_combined[
-                    z_slice,x_range[0]:x_range[1],y_range[0]:y_range[1]],
-                fmt='%.6e')
+                tomo_recon_combined[z_slice,:,:],
+                title=f'recon combined z={z[z_slice]:.4f}', origin='lower',
+                extent=extent, path=self._output_folder, save_fig=True,
+                save_only=True)
 
         # Add image reconstruction to reconstructed data NXprocess
-        #     combined data order: row/z,x,y
+        #     combined data order: z,y,x
         nxprocess.data = NXdata()
         nxprocess.attrs['default'] = 'data'
-        if x_bounds is not None:
+        if x_bounds is not None and x_bounds != (0, tomo_shape[2]):
             nxprocess.x_bounds = x_bounds
-        if y_bounds is not None:
+            nxprocess.x_bounds.units = 'pixels'
+            nxprocess.x_bounds.attrs['long_name'] = \
+                'x range indices in reconstructed data frame of reference'
+        if y_bounds is not None and y_bounds != (0, tomo_shape[1]):
             nxprocess.y_bounds = y_bounds
-        if z_bounds is not None:
+            nxprocess.y_bounds.units = 'pixels'
+            nxprocess.y_bounds.attrs['long_name'] = \
+                'y range indices in reconstructed data frame of reference'
+        if z_bounds is not None and z_bounds != (0, tomo_shape[0]):
             nxprocess.z_bounds = z_bounds
-        nxprocess.data.combined_data = tomo_recon_combined[
-            z_range[0]:z_range[1],x_range[0]:x_range[1],y_range[0]:y_range[1]]
+            nxprocess.z_bounds.units = 'pixels'
+            nxprocess.z_bounds.attrs['long_name'] = \
+                'z range indices in reconstructed data frame of reference'
+        nxprocess.data.combined_data = tomo_recon_combined
         nxprocess.data.attrs['signal'] = 'combined_data'
+        nxprocess.data.attrs['axes'] = ['z', 'y', 'x']
+        nxprocess.data.attrs['x_indices'] = 2
+        nxprocess.data.attrs['y_indices'] = 1
+        nxprocess.data.attrs['z_indices'] = 0
+        nxprocess.data.x = x
+        nxprocess.data.x.units = \
+            nxentry.instrument.detector.column_pixel_size.units
+        nxprocess.data.y = y
+        nxprocess.data.y.units = \
+            nxentry.instrument.detector.column_pixel_size.units
+        nxprocess.data.z = z
+        nxprocess.data.z.units = \
+            nxentry.instrument.detector.row_pixel_size.units
 
         # Create a copy of the input Nexus object and remove
         #     reconstructed data
@@ -1470,16 +1620,22 @@ class Tomo:
         nxentry_copy.data.makelink(
             nxprocess.data.combined_data, name='combined_data')
         nxentry_copy.data.attrs['signal'] = 'combined_data'
+        nxentry_copy.data.attrs['axes'] = ['z', 'y', 'x']
+        nxentry_copy.data.attrs['x_indices'] = 2
+        nxentry_copy.data.attrs['y_indices'] = 1
+        nxentry_copy.data.attrs['z_indices'] = 0
+        nxentry_copy.data.makelink(nxprocess.data.x, name='x')
+        nxentry_copy.data.makelink(nxprocess.data.y, name='y')
+        nxentry_copy.data.makelink(nxprocess.data.z, name='z')
 
         return nxroot_copy
 
-    def _gen_dark(self, nxentry, reduced_data):
+    def _gen_dark(self, nxentry, reduced_data, image_key):
         """Generate dark field."""
         # Third party modules
         from nexusformat.nexus import NXdata
 
         # Get the dark field images
-        image_key = nxentry.instrument.detector.get('image_key', None)
         field_indices = [
             index for index, key in enumerate(image_key) if key == 2]
         if field_indices:
@@ -1518,16 +1674,9 @@ class Tomo:
 
         # Plot dark field
         if self._save_figs:
-            extent = (
-                0,
-                float(nxentry.instrument.detector.column_pixel_size
-                      * tdf.shape[1]),
-                float(nxentry.instrument.detector.row_pixel_size
-                      * tdf.shape[0]),
-                0)
             quick_imshow(
-                tdf, title='dark field', path=self._output_folder,
-                extent=extent, save_fig=True, save_only=True)
+                tdf, title='Dark field', name='dark_field',
+                path=self._output_folder, save_fig=True, save_only=True)
 
         # Add dark field to reduced data NXprocess
         reduced_data.data = NXdata()
@@ -1535,13 +1684,12 @@ class Tomo:
 
         return reduced_data
 
-    def _gen_bright(self, nxentry, reduced_data):
+    def _gen_bright(self, nxentry, reduced_data, image_key):
         """Generate bright field."""
         # Third party modules
         from nexusformat.nexus import NXdata
 
         # Get the bright field images
-        image_key = nxentry.instrument.detector.get('image_key', None)
         field_indices = [
             index for index, key in enumerate(image_key) if key == 1]
         if field_indices:
@@ -1571,28 +1719,15 @@ class Tomo:
         else:
             raise RuntimeError(f'Invalid tbf_stack shape ({tbf_stack.shape})')
 
-        # Subtract dark field
-        if 'data' in reduced_data and 'dark_field' in reduced_data.data:
-            tbf -= reduced_data.data.dark_field
-        else:
-            self._logger.warning('Dark field unavailable')
-
         # Set any non-positive values to one
         # (avoid negative bright field values for spikes in dark field)
         tbf[tbf < 1] = 1
 
         # Plot bright field
         if self._save_figs:
-            extent = (
-                0,
-                float(nxentry.instrument.detector.column_pixel_size
-                      * tbf.shape[1]),
-                float(nxentry.instrument.detector.row_pixel_size
-                      * tbf.shape[0]),
-                0)
             quick_imshow(
-                tbf, title='bright field', path=self._output_folder,
-                extent=extent, save_fig=True, save_only=True)
+                tbf, title='Bright field', name='bright_field',
+                path=self._output_folder, save_fig=True, save_only=True)
 
         # Add bright field to reduced data NXprocess
         if 'data' not in reduced_data:
@@ -1601,32 +1736,32 @@ class Tomo:
 
         return reduced_data
 
-    def _set_detector_bounds(self, nxentry, reduced_data, theta,
-            img_row_bounds=None):
+    def _set_detector_bounds(
+            self, nxentry, reduced_data, image_key, theta, img_row_bounds,
+            calibrate_center_rows):
         """
         Set vertical detector bounds for each image stack.Right now the
         range is the same for each set in the image stack.
         """
+        # Third party modules
+        import matplotlib.pyplot as plt
+
         # Local modules
         from CHAP.utils.general import is_index_range
 
-        if self._test_mode:
-            return tuple(self._test_config['img_row_bounds'])
-
         # Get the first tomography image and the reference heights
         image_mask = reduced_data.get('image_mask')
         if image_mask is None:
             first_image_index = 0
         else:
-            raise RuntimeError('image_mask not tested yet')
             image_mask = np.asarray(image_mask)
             first_image_index = int(np.argmax(image_mask))
-        image_key = nxentry.instrument.detector.get('image_key', None)
         field_indices_all = [
             index for index, key in enumerate(image_key) if key == 0]
         if not field_indices_all:
             raise ValueError('Tomography field(s) unavailable')
-        z_translation_all = nxentry.sample.z_translation[field_indices_all]
+        z_translation_all = np.asarray(
+            nxentry.sample.z_translation)[field_indices_all]
         z_translation_levels = sorted(list(set(z_translation_all)))
         num_tomo_stacks = len(z_translation_levels)
         center_stack_index = int(num_tomo_stacks/2)
@@ -1642,173 +1777,129 @@ class Tomo:
             raise RuntimeError('Unable to load the tomography images '
                                f'for stack {i}')
 
-        # Select image bounds
-        title = f'tomography image at theta={round(theta, 2)+0}'
-        if img_row_bounds is not None:
-            if is_index_range(img_row_bounds, ge=0, le=first_image.shape[0]):
-                return img_row_bounds
-            if self._interactive:
-                self._logger.warning(
-                    f'Invalid parameter img_row_bounds ({img_row_bounds}), '
-                    'ignoring img_row_bounds')
-                img_row_bounds = None
-            else:
-                raise ValueError(
-                    f'Invalid parameter img_row_bounds ({img_row_bounds})')
-        if nxentry.instrument.source.attrs['station'] in ('id1a3', 'id3a'):
-            pixel_size = nxentry.instrument.detector.row_pixel_size
-            # Try to get a fit from the bright field
-            tbf = np.asarray(reduced_data.data.bright_field)
-            tbf_shape = tbf.shape
-            row_sum = np.sum(tbf, 1)
-            row_sum_min = row_sum.min()
-            row_sum_max = row_sum.max()
-            fit = Fit.fit_data(
-                row_sum, 'rectangle', x=np.array(range(len(row_sum))),
-                form='atan', guess=True)
-            parameters = fit.best_values
-            row_low_fit = parameters.get('center1', None)
-            row_upp_fit = parameters.get('center2', None)
-            sig_low = parameters.get('sigma1', None)
-            sig_upp = parameters.get('sigma2', None)
-            have_fit = (fit.success and row_low_fit is not None
-                        and row_upp_fit is not None and sig_low is not None
-                        and sig_upp is not None
-                        and 0 <= row_low_fit < row_upp_fit <= row_sum.size
-                        and (sig_low+sig_upp) / (row_upp_fit-row_low_fit) < 0.1)
-            if have_fit:
-                # Set a 5% margin on each side
-                margin = 0.05 * (row_upp_fit-row_low_fit)
-                row_low_fit = max(0, row_low_fit-margin)
-                row_upp_fit = min(tbf_shape[0], row_upp_fit+margin)
-            if num_tomo_stacks == 1:
-                if have_fit:
-                    # Set the default range to enclose the full fitted
-                    #     window
-                    row_low = int(row_low_fit)
-                    row_upp = int(row_upp_fit)
+        # Set initial image bounds or rotation calibration rows
+        tbf = np.asarray(reduced_data.data.bright_field)
+        if (not isinstance(calibrate_center_rows, bool)
+                and is_int_pair(calibrate_center_rows)):
+            img_row_bounds = calibrate_center_rows
+        else:
+            if nxentry.instrument.source.attrs['station'] in ('id1a3', 'id3a'):
+                pixel_size = float(nxentry.instrument.detector.row_pixel_size)
+                # Try to get a fit from the bright field
+                row_sum = np.sum(tbf, 1)
+                fit = Fit.fit_data(
+                    row_sum, 'rectangle', x=np.array(range(len(row_sum))),
+                    form='atan', guess=True)
+                parameters = fit.best_values
+                row_low_fit = parameters.get('center1', None)
+                row_upp_fit = parameters.get('center2', None)
+                sig_low = parameters.get('sigma1', None)
+                sig_upp = parameters.get('sigma2', None)
+                have_fit = (fit.success and row_low_fit is not None
+                    and row_upp_fit is not None and sig_low is not None
+                    and sig_upp is not None
+                    and 0 <= row_low_fit < row_upp_fit <= row_sum.size
+                    and (sig_low+sig_upp) / (row_upp_fit-row_low_fit) < 0.1)
+                if num_tomo_stacks == 1:
+                    if have_fit:
+                        # Add a pixel margin for roundoff effects in fit
+                        row_low_fit += 1
+                        row_upp_fit -= 1
+                        delta_z = (row_upp_fit-row_low_fit) * pixel_size
+                    else:
+                        # Set a default range of 1 mm
+                        # RV can we get this from the slits?
+                        delta_z = 1.0
                 else:
-                    # Center a default range of 1 mm
-                    # RV can we get this from the slits?
-                    num_row_min = int((1. + 0.5*pixel_size) / pixel_size)
-                    row_low = int((tbf_shape[0]-num_row_min) / 2)
-                    row_upp = row_low+num_row_min
-            else:
-                # Get the default range from the reference heights
-                delta_z = z_translation_levels[1]-z_translation_levels[0]
-                for i in range(2, num_tomo_stacks):
-                    delta_z = min(
-                        delta_z,
-                        z_translation_levels[i]-z_translation_levels[i-1])
+                    # Get the default range from the reference heights
+                    delta_z = z_translation_levels[1]-z_translation_levels[0]
+                    for i in range(2, num_tomo_stacks):
+                        delta_z = min(
+                            delta_z,
+                            z_translation_levels[i]-z_translation_levels[i-1])
                 self._logger.debug(f'delta_z = {delta_z}')
                 num_row_min = int((delta_z + 0.5*pixel_size) / pixel_size)
-                self._logger.debug(f'num_row_min = {num_row_min}')
-                if num_row_min > tbf_shape[0]:
+                if num_row_min > tbf.shape[0]:
                     self._logger.warning(
                         'Image bounds and pixel size prevent seamless '
                         'stacking')
-                if have_fit:
-                    # Center the default range relative to the fitted
-                    #     window
-                    row_low = int((row_low_fit+row_upp_fit-num_row_min) / 2)
-                    row_upp = row_low+num_row_min
+                    row_low = 0
+                    row_upp = tbf.shape[0]
                 else:
-                    # Center the default range
-                    row_low = int((tbf_shape[0]-num_row_min) / 2)
-                    row_upp = row_low+num_row_min
-            if not self._interactive:
+                    self._logger.debug(f'num_row_min = {num_row_min}')
+                    if have_fit:
+                        # Center the default range relative to the fitted
+                        #     window
+                        row_low = int((row_low_fit+row_upp_fit-num_row_min) / 2)
+                        row_upp = row_low+num_row_min
+                    else:
+                        # Center the default range
+                        row_low = int((tbf.shape[0]-num_row_min) / 2)
+                        row_upp = row_low+num_row_min
                 img_row_bounds = (row_low, row_upp)
+                if calibrate_center_rows:
+                    # Add a small margin to avoid edge effects
+                    offset = int(min(5, 0.1*(row_upp-row_low)))
+                    img_row_bounds = (row_low+offset, row_upp-1-offset)
             else:
-                tmp = np.copy(tbf)
-                tmp_max = tmp.max()
-                tmp[row_low,:] = tmp_max
-                tmp[row_upp-1,:] = tmp_max
-                quick_imshow(tmp, title='bright field')
-                tmp = np.copy(first_image)
-                tmp_max = tmp.max()
-                tmp[row_low,:] = tmp_max
-                tmp[row_upp-1,:] = tmp_max
-                quick_imshow(tmp, title=title)
-                del tmp
-                quick_plot(
-                    (range(row_sum.size), row_sum),
-                    ([row_low, row_low], [row_sum_min, row_sum_max], 'r-'),
-                    ([row_upp, row_upp], [row_sum_min, row_sum_max], 'r-'),
-                    title='sum over theta and y')
-                print(f'lower bound = {row_low} (inclusive)')
-                print(f'upper bound = {row_upp} (exclusive)]')
-                accept = input_yesno('Accept these bounds (y/n)?', 'y')
-                clear_imshow('bright field')
-                clear_imshow(title)
-                clear_plot('sum over theta and y')
-                if accept:
-                    img_row_bounds = (row_low, row_upp)
-                else:
-                    while True:
-                        _, img_row_bounds = draw_mask_1d(
-                            row_sum, title='select x data range',
-                            ylabel='sum over theta and y')
-                        if len(img_row_bounds) == 1:
-                            break
-                        print('Choose a single connected data range')
-                    img_row_bounds = tuple(img_row_bounds[0])
-            if (num_tomo_stacks > 1
-                    and (img_row_bounds[1]-img_row_bounds[0]+1)
-                         < int((delta_z - 0.5*pixel_size) / pixel_size)):
-                self._logger.warning(
-                    'Image bounds and pixel size prevent seamless stacking')
+                if num_tomo_stacks > 1:
+                    raise NotImplementedError(
+                        'Selecting image bounds or calibrating rotation axis '
+                        'for multiple stacks on FMB')
+                # For FMB: use the first tomography image to select range
+                # RV revisit if they do tomography with multiple stacks
+                if img_row_bounds is None and not self._interactive:
+                    if calibrate_center_rows:
+                        self._logger.warning(
+                            'calibrate_center_rows unspecified, find rotation '
+                            'axis at detector bounds (with a small margin)')
+                        # Add a small margin to avoid edge effects
+                        offset = min(5, 0.1*first_image.shape[0])
+                        img_row_bounds = (
+                            offset, first_image.shape[0]-1-offset)
+                    else:
+                        self._logger.warning(
+                            'img_row_bounds unspecified, reduce data for '
+                            'entire detector range')
+                        img_row_bounds = (0, first_image.shape[0])
+        if calibrate_center_rows:
+            title='Select two detector image row indices to '\
+                  'calibrate rotation axis (in range '\
+                  f'[0, {first_image.shape[0]-1}])'
         else:
-            if num_tomo_stacks > 1:
-                raise NotImplementedError(
-                    'Selecting image bounds for multiple stacks on FMB')
-            # For FMB: use the first tomography image to select range
-            # RV revisit if they do tomography with multiple stacks
-            row_sum = np.sum(first_image, 1)
-            row_sum_min = row_sum.min()
-            row_sum_max = row_sum.max()
-            if self._interactive:
-                print(
-                    'Select vertical data reduction range from first '
-                    'tomography image')
-                img_row_bounds = select_image_bounds(
-                    first_image, 0, title=title)
-                if img_row_bounds is None:
-                    raise RuntimeError('Unable to select image bounds')
-            else:
-                if img_row_bounds is None:
-                    self._logger.warning(
-                        'img_row_bounds unspecified, reduce data for entire '
-                        'detector range')
-                    img_row_bounds = (0, first_image.shape[0])
+            title='Select detector image row bounds for data '\
+                  f'reduction (in range [0, {first_image.shape[0]}])'
+        fig, img_row_bounds = select_image_indices(
+            first_image, 0, b=tbf, preselected_indices=img_row_bounds,
+            title=title,
+            title_a=r'Tomography image at $\theta$ = 'f'{round(theta, 2)+0}',
+            title_b='Bright field',
+            interactive=self._interactive)
+        if not calibrate_center_rows and (num_tomo_stacks > 1
+                and (img_row_bounds[1]-img_row_bounds[0]+1)
+                     < int((delta_z - 0.5*pixel_size) / pixel_size)):
+            self._logger.warning(
+                'Image bounds and pixel size prevent seamless stacking')
 
         # Plot results
         if self._save_figs:
-            row_low = img_row_bounds[0]
-            row_upp = img_row_bounds[1]
-            tmp = np.copy(first_image)
-            tmp_max = tmp.max()
-            tmp[row_low,:] = tmp_max
-            tmp[row_upp-1,:] = tmp_max
-            quick_imshow(
-                tmp, title=title, path=self._output_folder, save_fig=True,
-                save_only=True)
-            quick_plot(
-                (range(row_sum.size), row_sum),
-                ([row_low, row_low], [row_sum_min, row_sum_max], 'r-'),
-                ([row_upp, row_upp], [row_sum_min, row_sum_max], 'r-'),
-                title='sum over theta and y', path=self._output_folder,
-                save_fig=True, save_only=True)
-            del tmp
+            if calibrate_center_rows:
+                fig.savefig(os_path.join(
+                    self._output_folder, 'rotation_calibration_rows.png'))
+            else:
+                fig.savefig(os_path.join(
+                    self._output_folder, 'detector_image_bounds.png'))
+        plt.close()
 
         return img_row_bounds
 
-    def _gen_thetas(self, nxentry):
+    def _gen_thetas(self, nxentry, image_key):
         """Get the rotation angles for the image stacks."""
         # Get the rotation angles
-        image_key = nxentry.instrument.detector.get('image_key', None)
         field_indices_all = [
             index for index, key in enumerate(image_key) if key == 0]
-        z_translation_all = nxentry.sample.z_translation[field_indices_all]
+        z_translation_all = np.asarray(
+            nxentry.sample.z_translation)[field_indices_all]
         z_translation_levels = sorted(list(set(z_translation_all)))
         thetas = None
         for i, z_translation in enumerate(z_translation_levels):
@@ -1816,18 +1907,19 @@ class Tomo:
                 field_indices_all[index]
                 for index, z in enumerate(z_translation_all)
                 if z == z_translation]
-            sequence_numbers = \
-                nxentry.instrument.detector.sequence_number[field_indices]
+            sequence_numbers = np.asarray(
+                nxentry.instrument.detector.sequence_number)[field_indices]
             assert (list(sequence_numbers)
                     == list(range((len(sequence_numbers)))))
             if thetas is None:
                 thetas = np.asarray(
-                    nxentry.sample.rotation_angle[
-                        field_indices])[sequence_numbers]
+                    nxentry.sample.rotation_angle)[
+                        field_indices][sequence_numbers]
             else:
                 assert all(
-                    thetas[i] == nxentry.sample.rotation_angle[
-                        field_indices[index]]
+                    thetas[i] == np.asarray(
+                        nxentry.sample.rotation_angle)[
+                            field_indices[index]]
                     for i, index in enumerate(sequence_numbers))
 
         return thetas
@@ -1840,9 +1932,6 @@ class Tomo:
         # Local modules
         from CHAP.utils.general import index_nearest
 
-        if self._test_mode:
-            return tuple(self._test_config['delta_theta'])
-
 #        if input_yesno(
 #                '\nDo you want to zoom in to reduce memory '
 #                'requirement (y/n)?', 'n'):
@@ -1860,13 +1949,13 @@ class Tomo:
         if self._interactive:
             if delta_theta is None:
                 delta_theta = thetas[1]-thetas[0]
-            print(f'Available theta range: [{thetas[0]}, {thetas[-1]}]')
-            print(f'Current theta interval: {delta_theta}')
+            print(f'Available \u03b8 range: [{thetas[0]}, {thetas[-1]}]')
+            print(f'Current \u03b8 interval: {delta_theta}')
             if input_yesno(
-                    'Do you want to change the theta interval to reduce the '
+                    'Do you want to change the \u03b8 interval to reduce the '
                     'memory requirement (y/n)?', 'n'):
                 delta_theta = input_num(
-                    '    Enter the desired theta interval',
+                    '    Enter the desired \u03b8 interval',
                     ge=thetas[1]-thetas[0], lt=(thetas[-1]-thetas[0])/2)
         if delta_theta is not None:
             delta_theta = index_nearest(thetas, thetas[0]+delta_theta)
@@ -1875,38 +1964,58 @@ class Tomo:
 
         return zoom_perc, delta_theta
 
-    def _gen_tomo(self, nxentry, reduced_data):
+    def _gen_tomo(
+            self, nxentry, reduced_data, image_key, calibrate_center_rows):
         """Generate tomography fields."""
         # Third party modules
         from numexpr import evaluate
         from scipy.ndimage import zoom
 
-        # Get full bright field
+        # Get dark field
+        if 'dark_field' in reduced_data.data:
+            tdf = np.asarray(reduced_data.data.dark_field)
+        else:
+            self._logger.warning('Dark field unavailable')
+            tdf = None
+
+        # Get bright field
         tbf = np.asarray(reduced_data.data.bright_field)
         tbf_shape = tbf.shape
 
+        # Subtract dark field
+        if tdf is not None:
+            try:
+                with SetNumexprThreads(self._num_core):
+                    evaluate('tbf-tdf', out=tbf)
+            except TypeError as e:
+                sys_exit(
+                    f'\nA {type(e).__name__} occured while subtracting '
+                    'the dark field with num_expr.evaluate()'
+                    '\nTry reducing the detector range'
+                    f'\n(currently img_row_bounds = {img_row_bounds}, and '
+                    f'img_column_bounds = {img_column_bounds})\n')
+
         # Get image bounds
-        img_row_bounds = tuple(
-            reduced_data.get('img_row_bounds', (0, tbf_shape[0])))
+        img_row_bounds = tuple(reduced_data.get('img_row_bounds'))
         img_column_bounds = tuple(
             reduced_data.get('img_column_bounds', (0, tbf_shape[1])))
 
-        # Get resized dark field
-        if 'dark_field' in reduced_data.data:
-            tdf = np.asarray(
-                reduced_data.data.dark_field)[
+        # Check if this run is a rotation axis calibration
+        # and resize dark and bright fields accordingly
+        if calibrate_center_rows:
+            if tdf is not None:
+                tdf = tdf[calibrate_center_rows,:]
+            tbf = tbf[calibrate_center_rows,:]
+        else:
+            if (img_row_bounds != (0, tbf.shape[0])
+                    or img_column_bounds != (0, tbf.shape[1])):
+                if tdf is not None:
+                    tdf = tdf[
+                        img_row_bounds[0]:img_row_bounds[1],
+                        img_column_bounds[0]:img_column_bounds[1]]
+                tbf = tbf[
                     img_row_bounds[0]:img_row_bounds[1],
                     img_column_bounds[0]:img_column_bounds[1]]
-        else:
-            self._logger.warning('Dark field unavailable')
-            tdf = None
-
-        # Resize bright field
-        if (img_row_bounds != (0, tbf.shape[0])
-                or img_column_bounds != (0, tbf.shape[1])):
-            tbf = tbf[
-                img_row_bounds[0]:img_row_bounds[1],
-                img_column_bounds[0]:img_column_bounds[1]]
 
         # Get thetas (in degrees)
         thetas = np.asarray(reduced_data.rotation_angle)
@@ -1919,35 +2028,38 @@ class Tomo:
             image_mask = np.asarray(image_mask)
 
         # Get the tomography images
-        image_key = nxentry.instrument.detector.get('image_key', None)
         field_indices_all = [
             index for index, key in enumerate(image_key) if key == 0]
         if not field_indices_all:
             raise ValueError('Tomography field(s) unavailable')
-        z_translation_all = nxentry.sample.z_translation[field_indices_all]
+        z_translation_all = np.asarray(
+            nxentry.sample.z_translation)[field_indices_all]
         z_translation_levels = sorted(list(set(z_translation_all)))
         num_tomo_stacks = len(z_translation_levels)
+        if calibrate_center_rows:
+            center_stack_index = int(num_tomo_stacks/2)
         tomo_stacks = num_tomo_stacks*[np.array([])]
         horizontal_shifts = []
         vertical_shifts = []
-        tomo_stacks = []
         for i, z_translation in enumerate(z_translation_levels):
+            if calibrate_center_rows and i != center_stack_index:
+                continue
             try:
                 field_indices = [
                     field_indices_all[index]
                     for index, z in enumerate(z_translation_all)
                     if z == z_translation]
                 field_indices_masked = np.asarray(field_indices)[image_mask]
-                horizontal_shift = list(set(
-                    nxentry.sample.x_translation[field_indices_masked]))
+                horizontal_shift = list(set(np.asarray(
+                    nxentry.sample.x_translation)[field_indices_masked]))
                 assert len(horizontal_shift) == 1
                 horizontal_shifts += horizontal_shift
-                vertical_shift = list(set(
-                    nxentry.sample.z_translation[field_indices_masked]))
+                vertical_shift = list(set(np.asarray(
+                    nxentry.sample.z_translation)[field_indices_masked]))
                 assert len(vertical_shift) == 1
                 vertical_shifts += vertical_shift
-                sequence_numbers = \
-                    nxentry.instrument.detector.sequence_number[
+                sequence_numbers = np.asarray(
+                    nxentry.instrument.detector.sequence_number)[
                         field_indices]
                 assert (list(sequence_numbers)
                         == list(range((len(sequence_numbers)))))
@@ -1956,27 +2068,35 @@ class Tomo:
             except:
                 raise RuntimeError('Unable to load the tomography images '
                                    f'for stack {i}')
-            tomo_stacks.append(tomo_stack)
-            if not i:
-                tomo_stack_shape = tomo_stack.shape
-            else:
-                assert tomo_stack_shape == tomo_stack.shape
+            tomo_stacks[i] = tomo_stack
+            if not calibrate_center_rows:
+                if not i:
+                    tomo_stack_shape = tomo_stack.shape
+                else:
+                    assert tomo_stack_shape == tomo_stack.shape
 
-        row_pixel_size = nxentry.instrument.detector.row_pixel_size
-        column_pixel_size = nxentry.instrument.detector.column_pixel_size
-        reduced_tomo_stacks = []
+        row_pixel_size = float(nxentry.instrument.detector.row_pixel_size)
+        column_pixel_size = float(
+            nxentry.instrument.detector.column_pixel_size)
+        reduced_tomo_stacks = num_tomo_stacks*[np.array([])]
+        tomo_stack_shape = None
         for i, tomo_stack in enumerate(tomo_stacks):
+            if not tomo_stack.size:
+                continue
             # Resize the tomography images
             # Right now the range is the same for each set in the stack
-            assert len(thetas) == tomo_stack.shape[0]
-            if (img_row_bounds == (0, tbf.shape[0])
-                    and img_column_bounds == (0, tbf.shape[1])):
-                tomo_stack = tomo_stack.astype('float64', copy=False)
-            else:
-                tomo_stack = tomo_stack[
-                    :,img_row_bounds[0]:img_row_bounds[1],
-                    img_column_bounds[0]:img_column_bounds[1]].astype(
+            if calibrate_center_rows:
+                tomo_stack = tomo_stack[:,calibrate_center_rows,:].astype(
                         'float64', copy=False)
+            else:
+                if (img_row_bounds != (0, tomo_stack.shape[1])
+                        or img_column_bounds != (0, tomo_stack.shape[2])):
+                    tomo_stack = tomo_stack[
+                        :,img_row_bounds[0]:img_row_bounds[1],
+                        img_column_bounds[0]:img_column_bounds[1]].astype(
+                            'float64', copy=False)
+                else:
+                    tomo_stack = tomo_stack.astype('float64', copy=False)
 
             # Subtract dark field
             if tdf is not None:
@@ -2017,23 +2137,18 @@ class Tomo:
 
             # Downsize tomography stack to smaller size
             tomo_stack = tomo_stack.astype('float32', copy=False)
-            if not self._test_mode and (self._save_figs or self._save_only):
+            if self._save_figs or self._save_only:
+                theta = round(thetas[0], 2)
                 if len(tomo_stacks) == 1:
-                    title = f'red fullres theta {round(thetas[0], 2)+0}'
+                    title = r'Reduced data, $\theta$ = 'f'{theta}'
+                    name = f'reduced_data_theta_{theta}'
                 else:
-                    title = f'red stack {i} fullres theta ' \
-                        f'{round(thetas[0], 2)+0}'
-                extent = (
-                    0,
-                    float(column_pixel_size*tomo_stack.shape[2]),
-                    float(row_pixel_size*tomo_stack.shape[1]),
-                    0)
+                    title = f'Reduced data stack {i}, 'r'$\theta$ = 'f'{theta}'
+                    name = f'reduced_data_stack_{i}_theta_{theta}'
                 quick_imshow(
-                    tomo_stack[0,:,:], title=title, path=self._output_folder,
-                    save_fig=self._save_figs, save_only=self._save_only,
-                    extent=extent, block=self._block)
-#                if not self._block:
-#                    clear_imshow(title)
+                    tomo_stack[0,:,:], title=title, name=name,
+                    path=self._output_folder, save_fig=self._save_figs,
+                    save_only=self._save_only, block=self._block)
             zoom_perc = 100
             if zoom_perc != 100:
                 t0 = time()
@@ -2044,26 +2159,24 @@ class Tomo:
                     tomo_zoom_list.append(tomo_zoom)
                 tomo_stack = np.stack(tomo_zoom_list)
                 self._logger.info(f'Zooming in took {time()-t0:.2f} seconds')
+                title = f'red stack {zoom_perc}p theta ' \
+                    f'{round(thetas[0], 2)+0}'
+                quick_imshow(
+                    tomo_stack[0,:,:], title=title, 
+                    path=self._output_folder, save_fig=self._save_figs,
+                    save_only=self._save_only, block=self._block)
                 del tomo_zoom_list
-                if not self._test_mode:
-                    title = f'red stack {zoom_perc}p theta ' \
-                        f'{round(thetas[0], 2)+0}'
-                    quick_imshow(
-                        tomo_stack[0,:,:], title=title,
-                        path=self._output_folder, save_fig=self._save_figs,
-                        save_only=self._save_only, block=self._block)
-#                    if not self._block:
-#                        clear_imshow(title)
-
-            # Save test data to file
-            if self._test_mode:
-                row_index = int(tomo_stack.shape[1]/2)
-                np.savetxt(
-                    f'{self._output_folder}/red_stack_{i}.txt',
-                    tomo_stack[:,row_index,:], fmt='%.6e')
 
             # Combine resized stacks
-            reduced_tomo_stacks.append(tomo_stack)
+            reduced_tomo_stacks[i] = tomo_stack
+            if tomo_stack_shape is None:
+                tomo_stack_shape = tomo_stack.shape
+            else:
+                assert tomo_stack_shape == tomo_stack.shape
+
+        for i, stack in enumerate(reduced_tomo_stacks):
+            if not stack.size:
+                reduced_tomo_stacks[i] = np.zeros(tomo_stack_shape)
 
         # Add tomo field info to reduced data NXprocess
         reduced_data.x_translation = np.asarray(horizontal_shifts)
@@ -2081,183 +2194,217 @@ class Tomo:
 
     def _find_center_one_plane(
             self, sinogram, row, thetas, eff_pixel_size, cross_sectional_dim,
-            path=None, num_core=1, search_range=None, search_step=None,
-            gaussian_sigma=None, ring_width=None):
+            path=None, num_core=1, center_offset_min=-50, center_offset_max=50,
+            gaussian_sigma=None, ring_width=None, prev_center_offset=None):
         """Find center for a single tomography plane."""
         # Third party modules
+        import matplotlib.pyplot as plt
         from tomopy import find_center_vo
 
+        # sinogram index order: theta,column
+        sinogram = np.asarray(sinogram)
         if not gaussian_sigma:
             gaussian_sigma = None
         if not ring_width:
             ring_width = None
-        # Try automatic center finding routines for initial value
-        # sinogram index order: theta,column
-        # need column,theta for iradon, so take transpose
-        sinogram = np.asarray(sinogram)
-        sinogram_t = sinogram.T
-        center = sinogram.shape[1]/2
-
-#        quick_imshow(
-#            sinogram_t, f'sinogram row{row}',
-#            aspect='auto', path=self._output_folder,
-#            save_fig=self._save_figs, save_only=self._save_only,
-#            block=self._block)
 
-        # Try using Nghia Vo’s method
+        # Try Nghia Vo's method to get the default center offset
         t0 = time()
+        if center_offset_min is None:
+            center_offset_min = -50
+        if center_offset_max is None:
+            center_offset_max = 50
         if num_core > NUM_CORE_TOMOPY_LIMIT:
             self._logger.debug(
-                f'Running find_center_vo on {NUM_CORE_TOMOPY_LIMIT} cores ...')
+                f'Running find_center_vo on {NUM_CORE_TOMOPY_LIMIT} '
+                'cores ...')
             tomo_center = find_center_vo(
-                sinogram, ncore=NUM_CORE_TOMOPY_LIMIT)
+                sinogram, ncore=NUM_CORE_TOMOPY_LIMIT, smin=center_offset_min,
+                smax=center_offset_max)
         else:
-            tomo_center = find_center_vo(sinogram, ncore=num_core)
+            tomo_center = find_center_vo(
+                sinogram, ncore=num_core, smin=center_offset_min,
+                smax=center_offset_max)
         self._logger.info(
-            f'Finding center using Nghia Vo’s method took {time()-t0:.2f} '
+            f'Finding center using Nghia Vo\'s method took {time()-t0:.2f} '
             'seconds')
-        center_offset_vo = float(tomo_center-center)
+        center_offset_range = sinogram.shape[1]/2
+        center_offset_vo = float(tomo_center-center_offset_range)
         self._logger.info(
-            f'Center at row {row} using Nghia Vo’s method = '
+            f'Center at row {row} using Nghia Vo\'s method = '
             f'{center_offset_vo:.2f}')
 
-        if self._save_figs:
+        center_offset_default = None
+        if self._interactive or self._save_figs:
+
+            # Need column,theta for iradon, so take transpose
+            sinogram_t = sinogram.T
+
+            # Reconstruct the plane for the Nghia Vo's center offset
             t0 = time()
             recon_plane = self._reconstruct_one_plane(
-                sinogram_t, tomo_center, thetas, eff_pixel_size,
+                sinogram_t, center_offset_vo, thetas, eff_pixel_size,
                 cross_sectional_dim, False, num_core, gaussian_sigma,
                 ring_width)
             self._logger.info(
-                f'Reconstructing row {row} took {time()-t0:.2f} seconds')
-            title = f'edges row{row} center offset{center_offset_vo:.2f} Vo'
-            self._plot_edges_one_plane(recon_plane, title, path=path)
-
-        # Try using phase correlation method
-#        if input_yesno('
-#                Try finding center using phase correlation (y/n)?',
-#                'n'):
-#            t0 = time()
-#            tomo_center = find_center_pc(
-#                sinogram, sinogram, tol=0.1, rotc_guess=tomo_center)
-#            error = 1.
-#            while error > tol:
-#                prev = tomo_center
-#                tomo_center = find_center_pc(
-#                    sinogram, sinogram, tol=tol, rotc_guess=tomo_center)
-#                error = np.abs(tomo_center-prev)
-#            self._logger.info(
-#                'Finding center using the phase correlation method '
-#                f'took {time()-t0:.2f} seconds')
-#            center_offset = tomo_center-center
-#            print(
-#                f'Center at row {row} using phase correlation = '
-#                f'{center_offset:.2f}')
-#            t0 = time()
-#            recon_plane = self._reconstruct_one_plane(
-#                sinogram_t, tomo_center, thetas, eff_pixel_size,
-#                cross_sectional_dim, False, num_core, gaussian_sigma, ring_width)
-#            self._logger.info(
-#                f'Reconstructing row {row} took {time()-t0:.2f} seconds')
-#
-#            title = \
-#                f'edges row{row} center_offset{center_offset:.2f} PC'
-#            self._plot_edges_one_plane(recon_plane, title, path=path)
-
-        # Perform center finding search
+                f'Reconstructing row {row} with center at '
+                f'{center_offset_vo} took {time()-t0:.2f} seconds')
+
+            recon_edges = [self._get_edges_one_plane(recon_plane)]
+            if (not self._interactive or prev_center_offset is None
+                    or prev_center_offset == center_offset_vo):
+                fig, accept, center_offset_default = \
+                    self._select_center_offset(
+                        recon_edges, row, center_offset_vo, vo=True)
+                # Plot results
+                if self._save_figs:
+                    fig.savefig(
+                        os_path.join(
+                            self._output_folder,
+                            f'edges_center_row_{row}_vo.png'))
+                plt.close()
+
         if self._interactive:
-            print(
-                f'Center at row {row} using Nghia Vo’s method = '
-                f'{center_offset_vo:.2f}')
-            accept_vo = input_yesno(
-                '\nAccept this center location (y) or perform a search (n)?',
-                'y')
-        elif search_range is not None or search_step is not None:
-            accept_vo = False
-        else:
-            accept_vo = True
-        while not accept_vo:
-            if search_range is None:
-                if search_step is None:
-                    center_offset_low = max(-center, center_offset_vo-10)
-                    center_offset_upp = min(center, center_offset_vo+10)
-                else:
-                    center_offset_low = max(
-                        -center, center_offset_vo-search_step)
-                    center_offset_upp = min(
-                        center, center_offset_vo+search_step)
-            else:
-                center_offset_low = max(-center, center_offset_vo-search_range)
-                center_offset_upp = min(center, center_offset_vo+search_range)
-            if search_step is None:
-                center_offset_step = center_offset_upp-center_offset_vo
-            else:
-                center_offset_step = min(
-                    search_step, center_offset_upp-center_offset_vo)
-            if self._interactive:
-                center_offset_low = input_num(
-                    '\nEnter lower bound for center offset', ge=-int(center),
-                    le=int(center), default=center_offset_low)
-                center_offset_upp = input_num(
-                    'Enter upper bound for center offset',
-                    ge=center_offset_low, le=int(center),
-                    default=center_offset_upp)
-                if search_step is None:
-                    center_offset_step = 1
-                else:
-                    center_offset_step = min(search_range, search_step)
-                if center_offset_upp == center_offset_low:
-                    center_offset_step = 1
-                else:
-                    center_offset_step = input_num(
-                        'Enter step size for center offset search',
-                        ge=1, le=center_offset_upp-center_offset_low,
-                        default=center_offset_step)
-            num_center_offset = 1 + int(
-                (center_offset_upp-center_offset_low) / center_offset_step)
-            center_offsets = np.linspace(
-                center_offset_low, center_offset_upp, num_center_offset)
-            if self._interactive:
-                save_figs = self._save_figs
-                save_only = False
-            else:
-                save_figs = True
-                save_only = True
-            for center_offset in center_offsets:
-                if (not self._interactive and center_offset == center_offset_vo
-                        and self._save_figs):
-                    continue
+
+            if center_offset_default is None:
+                # Reconstruct the plane at the previous center offset
                 t0 = time()
                 recon_plane = self._reconstruct_one_plane(
-                    sinogram_t, center_offset+center, thetas, eff_pixel_size,
+                    sinogram_t, prev_center_offset, thetas, eff_pixel_size,
                     cross_sectional_dim, False, num_core, gaussian_sigma,
                     ring_width)
                 self._logger.info(
-                    f'Reconstructing center_offset {center_offset} took '
-                    'f{time()-t0:.2f} seconds')
-                title = f'edges row{row} center_offset{center_offset:.2f}'
-                self._plot_edges_one_plane(
-                    recon_plane, title, path=path, save_figs=save_figs,
-                    save_only=save_only)
-            if (not self._interactive
-                    or input_yesno('\nEnd the search (y/n)?', 'y')):
-                break
+                    f'Reconstructing row {row} with center at '
+                    f'{prev_center_offset} took {time()-t0:.2f} seconds')
+
+                recon_edges.insert(0, self._get_edges_one_plane(recon_plane))
+                fig, accept, center_offset_default = \
+                    self._select_center_offset(
+                        recon_edges, row,
+                        (prev_center_offset, center_offset_vo),
+                        vo=True, include_all_bad=True)
+                # Plot results
+                if self._save_figs:
+                    fig.savefig(
+                        os_path.join(
+                            self._output_folder,
+                            f'edges_center_row_{row}_'
+                            f'{prev_center_offset}_{center_offset_vo}.png'))
+                plt.close()
+
+                if center_offset_default == center_offset_vo:
+                    recon_edges.pop(0)
+                    fig, accept, _ = self._select_center_offset(
+                        recon_edges, row, center_offset_vo, vo=True)
+                    # Plot results
+                    if self._save_figs:
+                        fig.savefig(
+                            os_path.join(
+                                self._output_folder,
+                                f'edges_center_row_{row}_vo.png'))
+                    plt.close()
+                else:
+                    recon_edges.pop()
+                    if center_offset_default == prev_center_offset:
+                        fig, accept, _ = self._select_center_offset(
+                            recon_edges, row, prev_center_offset, vo=False)
+                        # Plot results
+                        if self._save_figs:
+                            fig.savefig(
+                                os_path.join(
+                                    self._output_folder,
+                                    f'edges_center_row_{row}_'
+                                    f'{prev_center_offset}.png'))
+                        plt.close()
+                    else:
+                        center_offset_default = prev_center_offset
+
+            # Perform center finding search
+            prev_index = None
+            up = True
+            include_all_bad = True
+            selected_center_offset = center_offset_default
+            center_offsets = [center_offset_default]
+            step_size = 4
+            if not accept:
+                max_step_size = min(
+                    center_offset_range+center_offset_default,
+                    center_offset_range-center_offset_default-1)
+                max_step_size = 1 << int(np.log2(max_step_size))-1
+                step_size = input_int(
+                        '\nEnter the intial step size in the center '
+                        'calibration search (will be truncated to the nearest '
+                        'lower power of 2)', ge=2, le=max_step_size,
+                        default=4)
+                step_size = 1 << int(np.log2(step_size))
+            while not accept and step_size:
+                if selected_center_offset == 'all bad':
+                    selected_center_offset = round(center_offset_default)
+                    preselected_offsets = (
+                        selected_center_offset-step_size,
+                        selected_center_offset+step_size)
+                else:
+                    selected_center_offset = round(center_offset_default)
+                    preselected_offsets = (
+                        selected_center_offset-step_size,
+                        selected_center_offset,
+                        selected_center_offset+step_size)
+                indices = []
+                for i, preselected_offset in enumerate(preselected_offsets):
+                    if preselected_offset in center_offsets:
+                        indices.append(
+                            center_offsets.index(preselected_offset))
+                    else:
+                        recon_plane = self._reconstruct_one_plane(
+                            sinogram_t, preselected_offset, thetas,
+                            eff_pixel_size, cross_sectional_dim, False,
+                            num_core, gaussian_sigma, ring_width)
+                        indices.append(len(center_offsets))
+                        center_offsets.append(preselected_offset)
+                        recon_edges.append(
+                            self._get_edges_one_plane(recon_plane))
+                fig, accept, selected_center_offset = \
+                    self._select_center_offset(
+                        [recon_edges[i] for i in indices],
+                        row, preselected_offsets,
+                        include_all_bad=include_all_bad)
+                if selected_center_offset   == 'all bad':
+                    step_size *=2
+                else:
+                    include_all_bad = False
+                    index = preselected_offsets.index(selected_center_offset)
+                    if index != 1 and prev_index in (None, index) and up:
+                        step_size *=2
+                    else:
+                        step_size = int(step_size/2)
+                        up = False
+                    prev_index = index
+                if step_size > max_step_size:
+                    self._logger.warning('Exceeding maximum step size'
+                                         f'of {max_step_size}')
+                    step_size = max_step_size
+                # Plot results
+                if self._save_figs:
+                    fig.savefig(
+                        os_path.join(
+                            self._output_folder,
+                            f'edges_center_{row}_{min(preselected_offsets)}_'\
+                                f'{max(preselected_offsets)}.png'))
+                plt.close()
+            del sinogram_t
+            del recon_plane
 
         # Select center location
-        if not accept_vo and self._interactive:
-            center_offset = input_num(
-                '    Enter chosen center offset', ge=-center, le=center,
-                default=center_offset_vo)
+        if self._interactive:
+            center_offset = selected_center_offset
         else:
             center_offset = center_offset_vo
 
-        del sinogram_t
-        del recon_plane
-
         return float(center_offset)
 
     def _reconstruct_one_plane(
-            self, tomo_plane_t, center, thetas, eff_pixel_size,
-            cross_sectional_dim, plot_sinogram=True, num_core=1,
+            self, tomo_plane_t, center_offset, thetas, eff_pixel_size,
+            cross_sectional_dim, plot_sinogram=False, num_core=1,
             gaussian_sigma=None, ring_width=None):
         """Invert the sinogram for a single tomography plane."""
         # Third party modules
@@ -2266,8 +2413,6 @@ class Tomo:
         from tomopy import misc
 
         # tomo_plane_t index order: column,theta
-        assert 0 <= center < tomo_plane_t.shape[0]
-        center_offset = center-tomo_plane_t.shape[0]/2
         two_offset = 2 * int(np.round(center_offset))
         two_offset_abs = np.abs(two_offset)
         # Add 10% slack to max_rad to avoid edge effects
@@ -2289,10 +2434,11 @@ class Tomo:
             sinogram = tomo_plane_t[dist_from_edge:two_offset-dist_from_edge,:]
         if plot_sinogram:
             quick_imshow(
-                sinogram.T, f'sinogram center offset{center_offset:.2f}',
-                aspect='auto', path=self._output_folder,
-                save_fig=self._save_figs, save_only=self._save_only,
-                block=self._block)
+                sinogram.T,
+                title=f'Sinogram for a center offset of {center_offset:.2f}',
+                name=f'sinogram_center_offset{center_offset:.2f}',
+                path=self._output_folder, save_fig=self._save_figs,
+                save_only=self._save_only, block=self._block, aspect='auto')
 
         # Inverting sinogram
         t0 = time()
@@ -2312,20 +2458,14 @@ class Tomo:
 
         return recon_clean
 
-    def _plot_edges_one_plane(
-            self, recon_plane, title, path=None, save_figs=None,
-            save_only=None):
+    def _get_edges_one_plane(self, recon_plane):
         """
-        Create an "edges plot" for a singled reconstructed tomography
-        data plane.
+        Create an "edges plot" image for a single reconstructed
+        tomography data plane.
         """
         # Third party modules
         from skimage.restoration import denoise_tv_chambolle
 
-        if save_figs is None:
-            save_figs = self._save_figs
-        if save_only is None:
-            save_only = self._save_only
         vis_parameters = None  # self._config.get('vis_parameters')
         if vis_parameters is None:
             weight = 0.1
@@ -2333,22 +2473,186 @@ class Tomo:
             weight = vis_parameters.get('denoise_weight', 0.1)
             if not is_num(weight, ge=0.):
                 self._logger.warning(
-                    f'Invalid weight ({weight}) in _plot_edges_one_plane, '
+                    f'Invalid weight ({weight}) in _get_edges_one_plane, '
                     'set to a default of 0.1')
                 weight = 0.1
-        edges = denoise_tv_chambolle(recon_plane, weight=weight)
-        vmax = np.max(edges[0,:,:])
-        vmin = -vmax
-        if path is None:
-            path = self._output_folder
-        quick_imshow(
-            edges[0,:,:], f'{title} coolwarm', path=path, cmap='coolwarm',
-            save_fig=save_figs, save_only=save_only, block=self._block)
-        quick_imshow(
-            edges[0,:,:], f'{title} gray', path=path, cmap='gray', vmin=vmin,
-            vmax=vmax, save_fig=save_figs, save_only=save_only,
-            block=self._block)
-        del edges
+        return denoise_tv_chambolle(recon_plane, weight=weight)[0]
+
+    def _select_center_offset(
+            self, recon_edges, row, preselected_offsets, vo=False,
+            include_all_bad=False):
+        """Select a center offset value from an "edges plot" image
+        for a single reconstructed tomography data plane."""
+        # Third party modules
+        import matplotlib.pyplot as plt
+        from matplotlib.widgets import RadioButtons, Button
+        from matplotlib.widgets import Button
+
+        def select_offset(offset):
+            """Callback function for the "Select offset" input."""
+            if offset in ('both bad', 'all bad'):
+                selected_offset.append(((False, 'all bad')))
+            else:
+                selected_offset.append(
+                    ((False,
+                      preselected_offsets[preselected_offsets.index(
+                          float(radio_btn.value_selected))])))
+            plt.close()
+
+        def reject(event):
+            """Callback function for the "Reject" button."""
+            selected_offset.append((False, preselected_offsets[0]))
+            plt.close()
+
+        def accept(event):
+            """Callback function for the "Accept" button."""
+            if num_plots == 1:
+                selected_offset.append((True, preselected_offsets[0]))
+            else:
+                selected_offset.append(
+                    ((False,
+                      preselected_offsets[preselected_offsets.index(
+                          float(radio_btn.value_selected))])))
+            plt.close()
+
+        if not isinstance(recon_edges, (tuple, list)):
+            recon_edges = [recon_edges]
+        if not isinstance(preselected_offsets, (tuple, list)):
+            preselected_offsets = [preselected_offsets]
+        assert len(recon_edges) == len(preselected_offsets)
+
+        selected_offset = []
+
+        title_pos = (0.5, 0.95)
+        title_props = {'fontsize': 'xx-large', 'horizontalalignment': 'center',
+                       'verticalalignment': 'bottom'}
+        subtitle_pos = (0.5, 0.90)
+        subtitle_props = {'fontsize': 'xx-large',
+                          'horizontalalignment': 'center',
+                          'verticalalignment': 'bottom'}
+
+        num_plots = len(recon_edges)
+        if num_plots == 1:
+            fig, axs = plt.subplots(figsize=(11, 8.5))
+            axs = [axs]
+            vmax = np.max(recon_edges[0][:,:])
+        else:
+            fig, axs = plt.subplots(ncols=num_plots, figsize=(17, 8.5))
+            axs = list(axs)
+            vmax = np.max(recon_edges[1][:,:])
+        for i, (ax, recon_edge, preselected_offset) in enumerate(zip(
+                axs, recon_edges, preselected_offsets)):
+            ax.imshow(recon_edge, vmin=-vmax, vmax=vmax, cmap='gray')
+            if num_plots == 1:
+                ax.set_title(
+                    f'Reconstruction for row {row}, center offset: ' \
+                    f'{preselected_offset:.2f}', fontsize='x-large')
+            else:
+                ax.set_title(
+                    f'Center offset: {preselected_offset}',
+                    fontsize='x-large')
+            ax.set_xlabel('x', fontsize='x-large')
+            if not i:
+                ax.set_ylabel('y', fontsize='x-large')
+
+        if num_plots == 1:
+            if vo:
+                fig_title = plt.figtext(
+                    *title_pos,
+                    f'Reconstruction for row {row} (Nghia Vo\'s center '
+                    f'offset: {preselected_offsets[0]})',
+                    **title_props)
+            else:
+                fig_title = plt.figtext(
+                    *title_pos,
+                    f'Reconstruction for row {row} (previous center offset: '
+                    f'{preselected_offsets[0]})',
+                    **title_props)
+            fig_subtitle = plt.figtext(
+                *subtitle_pos,
+                'Press "Accept" to accept this value or "Reject" to start a '
+                    'center calibration search',
+                **subtitle_props)
+        else:
+            if vo:
+                fig_title = plt.figtext(
+                    *title_pos,
+                    f'Reconstruction for row {row} (previous center offset: '
+                    f'{preselected_offsets[0]}, Nghia Vo\'s center '
+                    f'offset: {preselected_offsets[1]})',
+                    **title_props)
+            else:
+                fig_title = plt.figtext(
+                    *title_pos, f'Reconstruction for row {row}', **title_props)
+            fig_subtitle = plt.figtext(
+                *subtitle_pos,
+                'Select the best offset or press "Accept" to accept the '
+                f'default value of {preselected_offsets[1]}',
+                **subtitle_props)
+
+        if not self._interactive:
+
+            selected_offset.append((True, preselected_offsets[0]))
+
+        else:
+
+            fig.subplots_adjust(bottom=0.25, top=0.85)
+
+            if num_plots == 1:
+
+                # Setup "Reject" button
+                reject_btn = Button(
+                    plt.axes([0.15, 0.05, 0.15, 0.075]), 'Reject')
+                reject_cid = reject_btn.on_clicked(reject)
+
+
+            else:
+
+                # Setup RadioButtons
+                select_text = plt.figtext(
+                    0.225, 0.175, 'Select offset', fontsize='x-large',
+                    horizontalalignment='center', verticalalignment='center')
+                if include_all_bad:
+                    if num_plots == 2:
+                        labels = (*preselected_offsets, 'both bad')
+                    else:
+                        labels = (*preselected_offsets, 'all bad')
+                else:
+                    labels = preselected_offsets
+                radio_btn = RadioButtons(
+                    plt.axes([0.175, 0.05, 0.1, 0.1]),
+                    labels = labels, active=1)
+                radio_cid = radio_btn.on_clicked(select_offset)
+
+            # Setup "Accept" button
+            accept_btn = Button(
+                plt.axes([0.7, 0.05, 0.15, 0.075]), 'Accept')
+            accept_cid = accept_btn.on_clicked(accept)
+
+            plt.show()
+
+            # Disconnect all widget callbacks when figure is closed
+            # and remove the buttons before returning the figure
+            if num_plots == 1:
+                reject_btn.disconnect(reject_cid)
+                reject_btn.ax.remove()
+            else:
+                radio_btn.disconnect(radio_cid)
+                radio_btn.ax.remove()
+            accept_btn.disconnect(accept_cid)
+            accept_btn.ax.remove()
+
+        if num_plots == 1:
+            fig_title.remove()
+        else:
+            fig_title.set_in_layout(True)
+            select_text.remove()
+        fig_subtitle.remove()
+        fig.tight_layout(rect=(0, 0, 1, 0.95))
+        if not selected_offset and num_plots == 1:
+            selected_offset.append((True, preselected_offsets[0]))
+
+        return fig, *selected_offset[0]
 
     def _reconstruct_one_tomo_stack(
             self, tomo_stack, thetas, center_offsets=None, num_core=1,
@@ -2405,7 +2709,6 @@ class Tomo:
         # RV prep.stripe.remove_stripe_fw seems flawed for hollow brick
         #     accross multiple stacks
         if remove_stripe_sigma is not None and remove_stripe_sigma:
-            self._logger.warning('Ignoring remove_stripe_sigma')
             if num_core > NUM_CORE_TOMOPY_LIMIT:
                 tomo_stack = prep.stripe.remove_stripe_fw(
                     tomo_stack, sigma=remove_stripe_sigma,
@@ -2473,12 +2776,17 @@ class Tomo:
 
     def _resize_reconstructed_data(
             self, data, x_bounds=None, y_bounds=None, z_bounds=None,
-            z_only=False):
+            combine_data=False):
         """Resize the reconstructed tomography data."""
-        # Data order: row(z),x,y or stack,row(z),x,y
+        # Third party modules
+        import matplotlib.pyplot as plt
+
+        # Data order: row/-z,y,x or stack,row/-z,y,x
         if isinstance(data, list):
-            for stack in data:
+            for i, stack in enumerate(data):
                 assert stack.ndim == 3
+                if i:
+                    assert stack.shape[1:] == data[0].shape[1:]
             num_tomo_stacks = len(data)
             tomo_recon_stacks = data
         else:
@@ -2486,84 +2794,91 @@ class Tomo:
             num_tomo_stacks = 1
             tomo_recon_stacks = [data]
 
-        if not z_only and x_bounds is None:
-            # Selecting x bounds (in yz-plane)
-            tomosum = 0
-            for i in range(num_tomo_stacks):
-                tomosum = tomosum + np.sum(tomo_recon_stacks[i], axis=(0,2))
-            select_x_bounds = input_yesno(
-                '\nDo you want to change the image x-bounds (y/n)?', 'y')
-            if not select_x_bounds:
-                x_bounds = None
-            else:
-                accept = False
-                index_ranges = None
-                while not accept:
-                    _, x_bounds = draw_mask_1d(
-                        tomosum, current_index_ranges=index_ranges,
-                        title='select x data range',
-                        ylabel='sum yz')
-                    while len(x_bounds) != 1:
-                        print('Please select exactly one continuous range')
-                        _, x_bounds = draw_mask_1d(
-                            tomosum, title='select x data range',
-                            ylabel='sum yz')
-                    x_bounds = x_bounds[0]
-                    accept = True
-            self._logger.debug(f'x_bounds = {x_bounds}')
-
-        if not z_only and y_bounds is None:
-            # Selecting y bounds (in xz-plane)
-            tomosum = 0
-            for i in range(num_tomo_stacks):
-                tomosum = tomosum + np.sum(tomo_recon_stacks[i], axis=(0,1))
-            select_y_bounds = input_yesno(
-                '\nDo you want to change the image y-bounds (y/n)?', 'y')
-            if not select_y_bounds:
-                y_bounds = None
-            else:
-                accept = False
-                index_ranges = None
-                while not accept:
-                    _, y_bounds = draw_mask_1d(
-                        tomosum, current_index_ranges=index_ranges,
-                        title='select x data range',
-                        ylabel='sum xz')
-                    while len(y_bounds) != 1:
-                        print('Please select exactly one continuous range')
-                        _, y_bounds = draw_mask_1d(
-                            tomosum, title='select x data range',
-                            ylabel='sum xz')
-                    y_bounds = y_bounds[0]
-                    accept = True
-            self._logger.debug(f'y_bounds = {y_bounds}')
+        # Selecting x an y bounds (in z-plane)
+        if x_bounds is None:
+            if not self._interactive:
+                self._logger.warning('x_bounds unspecified, reconstruct '
+                                     'data for full x-range')
+                x_bounds = (0, tomo_recon_stacks[0].shape[2])
+        elif not is_int_pair(
+                x_bounds, ge=0, le=tomo_recon_stacks[0].shape[2]):
+            raise ValueError(f'Invalid parameter x_bounds ({x_bounds})')
+        if y_bounds is None:
+            if not self._interactive:
+                self._logger.warning('y_bounds unspecified, reconstruct '
+                                     'data for full y-range')
+                y_bounds = (0, tomo_recon_stacks[0].shape[1])
+        elif not is_int_pair(
+                y_bounds, ge=0, le=tomo_recon_stacks[0].shape[1]):
+            raise ValueError(f'Invalid parameter y_bounds ({y_bounds})')
+        if x_bounds is None and y_bounds is None:
+            preselected_roi = None
+        elif x_bounds is None:
+            preselected_roi = (
+                0, tomo_recon_stacks[0].shape[2],
+                y_bounds[0], y_bounds[1])
+        elif y_bounds is None:
+            preselected_roi = (
+                x_bounds[0], x_bounds[1],
+                0, tomo_recon_stacks[0].shape[1])
+        else:
+            preselected_roi = (
+                x_bounds[0], x_bounds[1],
+                y_bounds[0], y_bounds[1])
+        tomosum = 0
+        for i in range(num_tomo_stacks):
+            tomosum = tomosum + np.sum(tomo_recon_stacks[i], axis=0)
+        fig, roi = select_roi_2d(
+            tomosum, preselected_roi=preselected_roi,
+            title_a='Reconstructed data summed over z',
+            row_label='y', column_label='x',
+            interactive=self._interactive)
+        if roi is None:
+            x_bounds = (0, tomo_recon_stacks[0].shape[2])
+            y_bounds = (0, tomo_recon_stacks[0].shape[1])
+        else:
+            x_bounds = (int(roi[0]), int(roi[1]))
+            y_bounds = (int(roi[2]), int(roi[3]))
+        self._logger.debug(f'x_bounds = {x_bounds}')
+        self._logger.debug(f'y_bounds = {y_bounds}')
+        # Plot results
+        if self._save_figs:
+            fig.savefig(
+                os_path.join(
+                    self._output_folder, 'reconstructed_data_xy_roi.png'))
+        plt.close()
 
         # Selecting z bounds (in xy-plane)
-        # (only valid for a single image stack)
-        if z_bounds is None and num_tomo_stacks != 1:
+        # (only valid for a single image stack or when combining a stack)
+        if num_tomo_stacks == 1 or combine_data:
+            if z_bounds is None:
+                if not self._interactive:
+                    if combine_data:
+                        self._logger.warning(
+                            'z_bounds unspecified, combine reconstructed data '
+                            'for full z-range')
+                    else:
+                        self._logger.warning(
+                            'z_bounds unspecified, reconstruct data for '
+                            'full z-range')
+                z_bounds = (0, tomo_recon_stacks[0].shape[0])
+            elif not is_int_pair(
+                    z_bounds, ge=0, le=tomo_recon_stacks[0].shape[0]):
+                raise ValueError(f'Invalid parameter z_bounds ({z_bounds})')
             tomosum = 0
             for i in range(num_tomo_stacks):
                 tomosum = tomosum + np.sum(tomo_recon_stacks[i], axis=(1,2))
-            select_z_bounds = input_yesno(
-                'Do you want to change the image z-bounds (y/n)?', 'n')
-            if not select_z_bounds:
-                z_bounds = None
-            else:
-                accept = False
-                index_ranges = None
-                while not accept:
-                    _, z_bounds = draw_mask_1d(
-                        tomosum, current_index_ranges=index_ranges,
-                        title='select x data range',
-                        ylabel='sum xy')
-                    while len(z_bounds) != 1:
-                        print('Please select exactly one continuous range')
-                        _, z_bounds = draw_mask_1d(
-                            tomosum, title='select x data range',
-                            ylabel='sum xy')
-                    z_bounds = z_bounds[0]
-                    accept = True
+            fig, z_bounds = select_roi_1d(
+                tomosum, preselected_roi=z_bounds,
+                xlabel='z', ylabel='Reconstructed data summed over x and y',
+                interactive=self._interactive)
             self._logger.debug(f'z_bounds = {z_bounds}')
+            # Plot results
+            if self._save_figs:
+                fig.savefig(
+                    os_path.join(
+                        self._output_folder, 'reconstructed_data_z_roi.png'))
+            plt.close()
 
         return x_bounds, y_bounds, z_bounds
 
@@ -2583,6 +2898,7 @@ class TomoSimFieldProcessor(Processor):
 
         :param data: Input configuration for the simulation.
         :type data: list[PipelineData]
+        :raises ValueError: Invalid input or configuration parameter.
         :return: Simulated tomographic images.
         :rtype: nexusformat.nexus.NXroot
         """
@@ -2667,7 +2983,7 @@ class TomoSimFieldProcessor(Processor):
         # Get the column coordinates
         img_row_offset = -0.5 * (detector_size[0]*pixel_size[0]
                                + slit_size * (num_tomo_stack-1))
-        img_row_coords = (img_row_offset
+        img_row_coords = np.flip(img_row_offset
             + pixel_size[0] * (0.5 + np.asarray(range(int(detector_size[0])))))
 
         # Get the transmitted intensities
@@ -2678,7 +2994,8 @@ class TomoSimFieldProcessor(Processor):
         intensities_solid = None
         intensities_hollow = None
         for n in range(num_tomo_stack):
-            vertical_shifts.append(img_row_offset + n*slit_size)
+            vertical_shifts.append(img_row_offset + n*slit_size
+                                   + 0.5*detector_size[0]*pixel_size[0])
             tomo_field = beam_intensity * np.ones((num_theta, *img_dim))
             if sample_type == 'square_rod':
                 intensities_solid = \
@@ -2838,6 +3155,8 @@ class TomoDarkFieldProcessor(Processor):
         :type data: list[PipelineData]
         :param num_image: Number of dark field images, defaults to 5.
         :type num_image: int, optional.
+        :raises ValueError: Missing or invalid input or configuration
+            parameter.
         :return: Simulated dark field images.
         :rtype: nexusformat.nexus.NXroot
         """
@@ -2879,7 +3198,7 @@ class TomoDarkFieldProcessor(Processor):
         nxdark.entry.sample = nxroot.entry.sample
         nxinstrument = NXinstrument()
         nxdark.entry.instrument = nxinstrument
-        nxinstrument.source = nxroot.entry.instrument.source
+        nxinstrument.source = source
         nxdetector = NXdetector()
         nxinstrument.detector = nxdetector
         nxdetector.local_name = detector.local_name
@@ -2909,6 +3228,8 @@ class TomoBrightFieldProcessor(Processor):
         :type data: list[PipelineData]
         :param num_image: Number of bright field images, defaults to 5.
         :type num_image: int, optional.
+        :raises ValueError: Missing or invalid input or configuration
+            parameter.
         :return: Simulated bright field images.
         :rtype: nexusformat.nexus.NXroot
         """
@@ -2945,16 +3266,16 @@ class TomoBrightFieldProcessor(Processor):
         bright_field = int(background_intensity+beam_intensity) * np.ones(
             (num_image, detector_size[0], detector_size[1]), dtype=np.int64)
         if num_dummy_start:
-            dummy_fields = background_intensity * np.ones(
+            dummy_fields = int(background_intensity) * np.ones(
                 (num_dummy_start, detector_size[0], detector_size[1]),
                 dtype=np.int64)
             bright_field = np.concatenate((dummy_fields, bright_field))
             num_image += num_dummy_start
-        # Add 10% to slit size to make the bright beam slightly taller
+        # Add 20% to slit size to make the bright beam slightly taller
         #     than the vertical displacements between stacks
-        slit_size = 1.10*source.slit_size
-        if slit_size < detector.row_pixel_size*detector_size[0]:
-            img_row_coords = detector.row_pixel_size \
+        slit_size = 1.2*source.slit_size
+        if slit_size < float(detector.row_pixel_size*detector_size[0]):
+            img_row_coords = float(detector.row_pixel_size) \
                 * (0.5 + np.asarray(range(int(detector_size[0])))
                    - 0.5*detector_size[0])
             outer_indices = np.where(abs(img_row_coords) > slit_size/2)[0]
@@ -2966,7 +3287,7 @@ class TomoBrightFieldProcessor(Processor):
         nxbright.entry.sample = nxroot.entry.sample
         nxinstrument = NXinstrument()
         nxbright.entry.instrument = nxinstrument
-        nxinstrument.source = nxroot.entry.instrument.source
+        nxinstrument.source = source
         nxdetector = NXdetector()
         nxinstrument.detector = nxdetector
         nxdetector.local_name = detector.local_name
@@ -2993,8 +3314,10 @@ class TomoSpecProcessor(Processor):
 
         :param data: Input configuration for the simulation.
         :type data: list[PipelineData]
-        :param scan_numbers: List of SPEC scan numbers, defaults to [1].
+        :param scan_numbers: List of SPEC scan numbers,
+            defaults to [1].
         :type scan_numbers: list[int]
+        :raises ValueError: Invalid input or configuration parameter.
         :return: Simulated SPEC file.
         :rtype: list[str]
         """