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

CHAP/tomo/processor.py

@@ -26,7 +26,6 @@ from CHAP.utils.general import (
     select_image_indices,
     select_roi_1d,
     select_roi_2d,
-    quick_plot,
     quick_imshow,
 )
 from CHAP.utils.fit import Fit
@@ -119,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')
@@ -383,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)
@@ -441,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
@@ -457,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
@@ -494,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})')
@@ -529,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.reduce_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
@@ -668,7 +695,7 @@ class Tomo:
 
     def __init__(
             self, interactive=False, num_core=-1, output_folder='.',
-            save_figs='no', test_mode=False):
+            save_figs='no'):
         """
         Initialize Tomo.
 
@@ -682,9 +709,6 @@ class Tomo:
         :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
@@ -702,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
@@ -738,7 +752,8 @@ class Tomo:
                 f'of available processors and reduced to {cpu_count()}')
             self._num_core = cpu_count()
 
-    def reduce_data(self, nxroot, tool_config=None):
+    def reduce_data(
+            self, nxroot, tool_config=None, calibrate_center_rows=False):
         """
         Reduced the tomography images.
 
@@ -770,7 +785,17 @@ 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:
@@ -798,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)
@@ -820,20 +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, image_key, thetas[0],
-            img_row_bounds=img_row_bounds)
+            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, image_key)
+        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
@@ -866,9 +903,9 @@ 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
 
@@ -895,45 +932,24 @@ class Tomo:
             nxentry = nxroot[nxroot.attrs['default']]
         else:
             raise ValueError(f'Invalid parameter nxroot ({nxroot})')
-        center_rows = tool_config.center_rows
-        center_stack_index = tool_config.center_stack_index
-        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 ValueError(f'Unable to find valid reduced data in {nxentry}.')
 
-        # Get full bright field
-        tbf = np.asarray(nxentry.reduced_data.data.bright_field)
-        tbf_shape = tbf.shape
-
-        # Get image bounds
-        img_row_bounds = tuple(
-            nxentry.reduced_data.get('img_row_bounds', (0, tbf_shape[0])))
-        img_column_bounds = tuple(
-            nxentry.reduced_data.get('img_column_bounds', (0, tbf_shape[1])))
-
-        # 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(img_row_bounds[1] - 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(
@@ -945,44 +961,45 @@ 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)
 
-        # Get effective pixel_size
-        if 'zoom_perc' in nxentry.reduced_data:
-            eff_pixel_size = float(
-                100. * (nxentry.instrument.detector.row_pixel_size
-                         / nxentry.reduced_data.attrs['zoom_perc']))
-        else:
-            eff_pixel_size = float(nxentry.instrument.detector.row_pixel_size)
-
-        # Get cross sectional diameter
-        cross_sectional_dim = img_shape[1]*eff_pixel_size
-        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')
-
         # Select center rows
-        if self._test_mode:
-            center_rows = tuple(self._test_config['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*num_row))
-                    center_rows = (offset, num_row-1-offset)
+                    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 = (0, num_row-1)
+                    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,:,:],
@@ -990,13 +1007,18 @@ class Tomo:
                 b=tbf[img_row_bounds[0]:img_row_bounds[1],
                       img_column_bounds[0]:img_column_bounds[1]], 
                 preselected_indices=center_rows,
-                title='Select or adjust two detector image row indices to '
-                    f'find center axis (in range [0, {num_row-1}])',
+                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] == num_row:
+            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(
@@ -1004,24 +1026,41 @@ class Tomo:
                         self._output_folder, 'center_finding_rows.png'))
             plt.close()
 
+        # Get effective pixel_size
+        if 'zoom_perc' in nxentry.reduced_data:
+            eff_pixel_size = float(
+                100. * (nxentry.instrument.detector.row_pixel_size
+                         / nxentry.reduced_data.attrs['zoom_perc']))
+        else:
+            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 = \
+            eff_pixel_size * nxentry.reduced_data.data.bright_field.shape[1]
+        self._logger.debug(f'cross_sectional_dim = {cross_sectional_dim}')
+
         # Find the center offsets at each of the center rows
+        prev_center_offset = None
         center_offsets = []
-        for i, center_row in enumerate(center_rows):
+        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,:,center_row,:],
-                    center_row, thetas, eff_pixel_size, cross_sectional_dim,
+                        center_stack_index,:,offset_row,:],
+                    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,
+                    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))
+                    ring_width=tool_config.ring_width,
+                    prev_center_offset=prev_center_offset))
             self._logger.info(
-                f'Finding center {i} took {time()-t0:.2f} seconds')
-            self._logger.debug(f'center_row {i} = {center_rows[i]:.2f}')
-            self._logger.debug(f'center_offset {i} = {center_offsets[i]:.2f}')
+                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 = {
             'center_rows': list(center_rows),
@@ -1029,12 +1068,14 @@ class Tomo:
         }
         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
 
@@ -1080,7 +1121,7 @@ class Tomo:
         # Create an NXprocess to store image reconstruction (meta)data
         nxprocess = NXprocess()
 
-        # Get rotation axis rows and centers
+        # 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:
@@ -1106,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
@@ -1143,14 +1187,9 @@ class Tomo:
         # Resize the reconstructed tomography data
         #     reconstructed data order in each stack: row/-z,y,x
         tomo_recon_shape = tomo_recon_stacks[0].shape
-        if self._test_mode:
-            x_bounds = tuple(self._test_config.get('x_bounds'))
-            y_bounds = tuple(self._test_config.get('y_bounds'))
-            z_bounds = (0, tomo_recon_shape[0])
-        else:
-            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)
+        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_shape[2])
             x_slice = int(x_range[1]/2)
@@ -1247,14 +1286,6 @@ class Tomo:
                     title=f'recon {res_title} z={z[z_index]:.4f}',
                     origin='lower', extent=extent, path=self._output_folder,
                     save_fig=True, save_only=True)
-
-            # Save test data to file
-            #     reconstructed data order in each stack: z,y,x
-            if self._test_mode:
-                np.savetxt(
-                    f'{self._output_folder}/recon_stack.txt',
-                    tomo_recon_stacks[z_slice-z_range[0],:,:],
-                    fmt='%.6e')
         else:
             # Plot a few reconstructed image slices
             if self._save_figs:
@@ -1276,15 +1307,6 @@ class Tomo:
                         title=title, path=self._output_folder,
                         save_fig=True, save_only=True)
 
-            # Save test data to file
-            #     reconstructed data order in each stack: row/-z,y,x
-            if self._test_mode:
-                for i in range(tomo_recon_shape[0]):
-                    np.savetxt(
-                        f'{self._output_folder}/recon_stack_{i}.txt',
-                        tomo_recon_stacks[i,z_slice-z_range[0],:,:],
-                        fmt='%.6e')
-
         # Add image reconstruction to reconstructed data NXprocess
         #     reconstructed data order:
         #     - for one stack: z,y,x
@@ -1295,15 +1317,24 @@ class Tomo:
             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.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
@@ -1390,8 +1421,11 @@ class Tomo:
         #     (meta)data
         nxprocess = NXprocess()
 
-        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 nxroot
@@ -1407,19 +1441,16 @@ class Tomo:
         tomo_recon_combined = \
             nxentry.reconstructed_data.data.reconstructed_data[0,:,:,:]
         tomo_recon_combined = np.concatenate(
-            [nxentry.reconstructed_data.data.reconstructed_data[i,:,:,:]
-               for i in range(num_tomo_stacks-1,0,-1)]
-            + [tomo_recon_combined])
+            [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,y,x
-        if self._test_mode:
-            x_bounds = None
-            y_bounds = None
-            z_bounds = tuple(self._test_config.get('z_bounds'))
-        elif self._interactive:
+        if self._interactive:
             x_bounds, y_bounds, z_bounds = self._resize_reconstructed_data(
                 tomo_recon_combined, combine_data=True)
         else:
@@ -1428,41 +1459,41 @@ class Tomo:
                 self._logger.warning(
                     'x_bounds unspecified, reconstruct data for full x-range')
             elif not is_int_pair(
-                    x_bounds, ge=0, le=tomo_recon_combined.shape[2]):
+                    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, le=tomo_recon_combined.shape[1]):
+                    y_bounds, ge=0, le=tomo_shape[1]):
                 raise ValueError(f'Invalid parameter y_bounds ({y_bounds})')
             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_recon_combined.shape[0]):
+                    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[2])
+            x_range = (0, tomo_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_combined.shape[1])
+            y_range = (0, tomo_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_combined.shape[0])
+            z_range = (0, tomo_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_combined.shape[0]
+        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]]
 
@@ -1472,6 +1503,7 @@ class Tomo:
         #     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
@@ -1507,7 +1539,7 @@ class Tomo:
                 y[-1],
                 z[0],
                 z[-1])
-            x_slice = int(tomo_recon_combined.shape[2]/2)
+            x_slice = int(tomo_shape[2]/2)
             quick_imshow(
                 tomo_recon_combined[:,:,x_slice],
                 title=f'recon combined x={x[x_slice]:.4f}', origin='lower',
@@ -1518,7 +1550,7 @@ class Tomo:
                 x[-1],
                 z[0],
                 z[-1])
-            y_slice = int(tomo_recon_combined.shape[1]/2)
+            y_slice = int(tomo_shape[1]/2)
             quick_imshow(
                 tomo_recon_combined[:,y_slice,:],
                 title=f'recon combined y={y[y_slice]:.4f}', origin='lower',
@@ -1529,34 +1561,32 @@ class Tomo:
                 x[-1],
                 y[0],
                 y[-1])
-            z_slice = int(tomo_recon_combined.shape[0]/2)
+            z_slice = int(tomo_shape[0]/2)
             quick_imshow(
                 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)
 
-        # Save test data to file
-        #     combined data order: z,y,x
-        if self._test_mode:
-            z_slice = int(tomo_recon_combined.shape[0]/2)
-            np.savetxt(
-                f'{self._output_folder}/recon_combined.txt',
-                tomo_recon_combined[z_slice,:,:], fmt='%.6e')
-
         # Add image reconstruction to reconstructed data NXprocess
         #     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
             nxprocess.x_bounds.units = 'pixels'
-        if y_bounds is not None:
+            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
             nxprocess.y_bounds.units = 'pixels'
-        if z_bounds is not None:
+            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.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']
@@ -1689,12 +1719,6 @@ 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 -= np.asarray(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
@@ -1712,8 +1736,9 @@ class Tomo:
 
         return reduced_data
 
-    def _set_detector_bounds(self, nxentry, reduced_data, image_key, 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.
@@ -1724,15 +1749,11 @@ class Tomo:
         # 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))
         field_indices_all = [
@@ -1756,79 +1777,105 @@ class Tomo:
             raise RuntimeError('Unable to load the tomography images '
                                f'for stack {i}')
 
-        # Select image bounds
+        # Set initial image bounds or rotation calibration rows
         tbf = np.asarray(reduced_data.data.bright_field)
-        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:
-                    delta_z = (row_upp_fit-row_low_fit) * pixel_size
+        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:
-                    # Set a default range of 1 mm
-                    # RV can we get this from the slits?
-                    delta_z = 1.0
-            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])
-            self._logger.debug(f'delta_z = {delta_z}')
-            num_row_min = int((delta_z + 0.5*pixel_size) / pixel_size)
-            if num_row_min > tbf.shape[0]:
-                self._logger.warning(
-                    'Image bounds and pixel size prevent seamless '
-                    'stacking')
-                row_low = 0
-                row_upp = tbf.shape[0]
-            else:
-                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
+                    # 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)
+                if num_row_min > tbf.shape[0]:
+                    self._logger.warning(
+                        'Image bounds and pixel size prevent seamless '
+                        'stacking')
+                    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
-            img_row_bounds = (row_low, row_upp)
+                    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:
+                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
-            if img_row_bounds is None:
-                if not self._interactive:
-                    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='Select or adjust detector image row bounds for data '
-                  f'reduction (in range {[0, first_image.shape[0]]})',
+            title=title,
             title_a=r'Tomography image at $\theta$ = 'f'{round(theta, 2)+0}',
             title_b='Bright field',
             interactive=self._interactive)
-        if (num_tomo_stacks > 1
+        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(
@@ -1836,8 +1883,12 @@ class Tomo:
 
         # Plot results
         if self._save_figs:
-            fig.savefig(
-                os_path.join(self._output_folder, 'detector_image_bounds.png'))
+            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
@@ -1881,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'):
@@ -1916,38 +1964,58 @@ class Tomo:
 
         return zoom_perc, delta_theta
 
-    def _gen_tomo(self, nxentry, reduced_data, image_key):
+    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)
@@ -1968,11 +2036,14 @@ class Tomo:
             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]
@@ -1997,28 +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 = float(nxentry.instrument.detector.row_pixel_size)
         column_pixel_size = float(
             nxentry.instrument.detector.column_pixel_size)
-        reduced_tomo_stacks = []
+        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, 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(
+            if calibrate_center_rows:
+                tomo_stack = tomo_stack[:,calibrate_center_rows,:].astype(
                         'float64', copy=False)
             else:
-                tomo_stack = tomo_stack.astype('float64', copy=False)
+                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:
@@ -2059,7 +2137,7 @@ 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 = r'Reduced data, $\theta$ = 'f'{theta}'
@@ -2081,24 +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)
-
-            # 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)
@@ -2116,98 +2194,195 @@ 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
 
-        # 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}')
 
+        center_offset_default = None
         if self._interactive or self._save_figs:
 
-            # Reconstruct the plane for Nghia Vo’s center offset
+            # 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, 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')
+                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)]
-            fig, accept, selected_center_offset = self._select_center_offset(
-                recon_edges, row, center_offset_vo)
-            # Plot results
-            if self._save_figs:
-                fig.savefig(
-                    os_path.join(
-                        self._output_folder,
-                        f'edges_default_center_row_{row}.png'))
-            plt.close()
+            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:
+
+            if center_offset_default is None:
+                # Reconstruct the plane at the previous center offset
+                t0 = time()
+                recon_plane = self._reconstruct_one_plane(
+                    sinogram_t, prev_center_offset, thetas, eff_pixel_size,
+                    cross_sectional_dim, False, num_core, gaussian_sigma,
+                    ring_width)
+                self._logger.info(
+                    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
-            center_offsets = [center_offset_vo]
-            step_size = 4
-            indices = 3*[-1]
             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:
-                selected_center_offset = round(selected_center_offset)
-                preselected_offsets = (
-                    selected_center_offset-step_size,
-                    selected_center_offset,
-                    selected_center_offset+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[i] = center_offsets.index(preselected_offset)
+                        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[i] = len(center_offsets)
+                        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, center_offset_vo)
-                index = preselected_offsets.index(selected_center_offset)
-                if index != 1 and prev_index in (None, index) and up:
+                        row, preselected_offsets,
+                        include_all_bad=include_all_bad)
+                if selected_center_offset   == 'all bad':
                     step_size *=2
                 else:
-                    step_size = int(step_size/2)
-                    up = False
-                prev_index = index
+                    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(
@@ -2216,6 +2391,8 @@ class Tomo:
                             f'edges_center_{row}_{min(preselected_offsets)}_'\
                                 f'{max(preselected_offsets)}.png'))
                 plt.close()
+            del sinogram_t
+            del recon_plane
 
         # Select center location
         if self._interactive:
@@ -2223,10 +2400,6 @@ class Tomo:
         else:
             center_offset = center_offset_vo
 
-        del sinogram_t
-        if recon_plane is not None:
-            del recon_plane
-
         return float(center_offset)
 
     def _reconstruct_one_plane(
@@ -2306,8 +2479,8 @@ class Tomo:
         return denoise_tv_chambolle(recon_plane, weight=weight)[0]
 
     def _select_center_offset(
-            self, recon_edges, row, preselected_offsets,
-            center_offset_vo=None):
+            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
@@ -2317,10 +2490,13 @@ class Tomo:
 
         def select_offset(offset):
             """Callback function for the "Select offset" input."""
-            selected_offset.append(
-                ((False,
-                  preselected_offsets[preselected_offsets.index(
-                      float(radio_btn.value_selected))])))
+            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):
@@ -2379,23 +2555,40 @@ class Tomo:
             if not i:
                 ax.set_ylabel('y', fontsize='x-large')
 
-        if len(recon_edges) > 1:
-            fig_title = plt.figtext(
-                *title_pos,
-                f'Reconstructions for row {row} (default center offset: '
-                    f'{center_offset_vo})',
-                **title_props)
+        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)
-        else:
-            fig_title = plt.figtext(
-                *title_pos,
-                'Press "Accept" to accept this value or "Reject" to start a '
-                    'center calibration search',
-                **title_props)
 
         if not self._interactive:
 
@@ -2403,7 +2596,7 @@ class Tomo:
 
         else:
 
-            fig.subplots_adjust(bottom=0.2)
+            fig.subplots_adjust(bottom=0.25, top=0.85)
 
             if num_plots == 1:
 
@@ -2419,9 +2612,16 @@ class Tomo:
                 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 = preselected_offsets, active=1)
+                    labels = labels, active=1)
                 radio_cid = radio_btn.on_clicked(select_offset)
 
             # Setup "Accept" button
@@ -2446,9 +2646,11 @@ class Tomo:
             fig_title.remove()
         else:
             fig_title.set_in_layout(True)
-            fig_subtitle.remove()
             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]
 
@@ -2507,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,
@@ -3070,9 +3271,9 @@ class TomoBrightFieldProcessor(Processor):
                 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
+        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])))