tomo: tomo.py comparison

comparison tomo.py @ 49:26f99fdd8d61 draft

"planemo upload for repository https://github.com/rolfverberg/galaxytools commit 4f7738d02f4a3fd91373f43937ed311b6fe11a12"

author	rv43
date	Thu, 28 Jul 2022 16:05:24 +0000
parents	059819ea1f0e
children	75dd6e15f628

comparison

equal deleted inserted replaced

-:059819ea1f0e
+:26f99fdd8d61
 import os
 import sys
 import getopt
 import re
 import io
-try:
-import pyinputplus as pyip
-except:
-pass
 import argparse
 import numpy as np
 try:
 import numexpr as ne
 except:
 try:
 from skimage.restoration import denoise_tv_chambolle
 except:
 pass
-import msnc_tools as msnc
+from detector import TomoDetectorConfig
+from fit import Fit
+#from msnctools.general import illegal_value, is_int, is_num, is_index_range, get_trailing_int, \
+from general import illegal_value, is_int, is_num, is_index_range, get_trailing_int, \
+input_int, input_num, input_yesno, input_menu, findImageFiles, loadImageStack, clearPlot, \
+draw_mask_1d, quickPlot, clearImshow, quickImshow, combine_tiffs_in_h5, Config
+from general import selectArrayBounds,selectImageRange, selectImageBounds
 # the following tomopy routines don't run with more than 24 cores on Galaxy-Dev
 #   - tomopy.find_center_vo
 #   - tomopy.prep.stripe.remove_stripe_fw
 num_core_tomopy_limit = 24
 logging.debug(f'self.num_core={self.num_core}')
 def __exit__(self, exc_type, exc_value, traceback):
 ne.set_num_threads(self.num_core_org)
-class ConfigTomo(msnc.Config):
+class ConfigTomo(Config):
 """Class for processing a config file.
 """
 def __init__(self, config_file=None, config_dict=None):
 super().__init__(config_file, config_dict)
 # Find tomography bright field images file/folder
 self.tbf_data_path = self.config.get('tbf_data_path')
 # Check number of tomography image stacks
 self.num_tomo_stacks = self.config.get('num_tomo_stacks', 1)
-if not msnc.is_int(self.num_tomo_stacks, 1):
+if not is_int(self.num_tomo_stacks, 1):
 self.num_tomo_stacks = None
-msnc.illegal_value('num_tomo_stacks', self.num_tomo_stacks, 'config file')
+illegal_value(self.num_tomo_stacks, 'num_tomo_stacks', 'config file')
 return False
 logging.info(f'num_tomo_stacks = {self.num_tomo_stacks}')
 # Find tomography images file/folders and stack parameters
 tomo_data_paths_indices = sorted({key:value for key,value in self.config.items()
 if 'tomo_data_path' in key}.items())
 if len(tomo_data_paths_indices) != self.num_tomo_stacks:
 logging.error(f'Incorrect number of tomography data path names in config file')
 is_valid = False
 self.tomo_data_paths = [tomo_data_paths_indices[i][1] for i in range(self.num_tomo_stacks)]
-self.tomo_data_indices = [msnc.get_trailing_int(tomo_data_paths_indices[i][0])
+self.tomo_data_indices = [get_trailing_int(tomo_data_paths_indices[i][0])
-if msnc.get_trailing_int(tomo_data_paths_indices[i][0]) else None
+if get_trailing_int(tomo_data_paths_indices[i][0]) else None
 for i in range(self.num_tomo_stacks)]
 tomo_ref_height_indices = sorted({key:value for key,value in self.config.items()
 if 'z_pos' in key}.items())
 if self.num_tomo_stacks > 1 and len(tomo_ref_height_indices) != self.num_tomo_stacks:
 logging.error(f'Incorrect number of tomography reference heights in config file')
 else:
 self.tomo_ref_heights = [0.0]*self.num_tomo_stacks
 # Check tomo angle (theta) range
 self.start_theta = self.config.get('start_theta', 0.)
-if not msnc.is_num(self.start_theta, 0.):
+if not is_num(self.start_theta, 0.):
-msnc.illegal_value('start_theta', self.start_theta, 'config file')
+illegal_value(self.start_theta, 'start_theta', 'config file')
 is_valid = False
 logging.debug(f'start_theta = {self.start_theta}')
 self.end_theta = self.config.get('end_theta', 180.)
-if not msnc.is_num(self.end_theta, self.start_theta):
+if not is_num(self.end_theta, self.start_theta):
-msnc.illegal_value('end_theta', self.end_theta, 'config file')
+illegal_value(self.end_theta, 'end_theta', 'config file')
 is_valid = False
 logging.debug(f'end_theta = {self.end_theta}')
 self.num_thetas = self.config.get('num_thetas')
-if not (self.num_thetas is None or msnc.is_int(self.num_thetas, 1)):
+if not (self.num_thetas is None or is_int(self.num_thetas, 1)):
-msnc.illegal_value('num_thetas', self.num_thetas, 'config file')
+illegal_value(self.num_thetas, 'num_thetas', 'config file')
 self.num_thetas = None
 is_valid = False
 logging.debug(f'num_thetas = {self.num_thetas}')
 return is_valid
 self.tbf_data_path = self.config['bright_field'].get('data_path')
 # Check number of tomography image stacks
 stack_info = self.config['stack_info']
 self.num_tomo_stacks = stack_info.get('num', 1)
-if not msnc.is_int(self.num_tomo_stacks, 1):
+if not is_int(self.num_tomo_stacks, 1):
 self.num_tomo_stacks = None
-msnc.illegal_value('stack_info:num', self.num_tomo_stacks, 'config file')
+illegal_value(self.num_tomo_stacks, 'num_tomo_stacks', 'config file')
 return False
 logging.info(f'num_tomo_stacks = {self.num_tomo_stacks}')
 # Find tomography images file/folders and stack parameters
 stacks = stack_info.get('stacks')
 if stacks is None or len(stacks) is not self.num_tomo_stacks:
-msnc.illegal_value('stack_info:stacks', stacks, 'config file')
+illegal_value(stacks, 'stacks', 'config file')
 return False
 self.tomo_data_paths = []
 self.tomo_data_indices = []
 self.tomo_ref_heights = []
 for stack in stacks:
 self.start_theta = 0.
 self.end_theta = 180.
 self.num_thetas = None
 else:
 self.start_theta = theta_range.get('start', 0.)
-if not msnc.is_num(self.start_theta, 0.):
+if not is_num(self.start_theta, 0.):
-msnc.illegal_value('theta_range:start', self.start_theta, 'config file')
+illegal_value(self.start_theta, 'theta_range:start', 'config file')
 is_valid = False
 logging.debug(f'start_theta = {self.start_theta}')
 self.end_theta = theta_range.get('end', 180.)
-if not msnc.is_num(self.end_theta, self.start_theta):
+if not is_num(self.end_theta, self.start_theta):
-msnc.illegal_value('theta_range:end', self.end_theta, 'config file')
+illegal_value(self.end_theta, 'theta_range:end', 'config file')
 is_valid = False
 logging.debug(f'end_theta = {self.end_theta}')
 self.num_thetas = theta_range.get('num')
-if self.num_thetas and not msnc.is_int(self.num_thetas, 1):
+if self.num_thetas and not is_int(self.num_thetas, 1):
-msnc.illegal_value('theta_range:num', self.num_thetas, 'config file')
+illegal_value(self.num_thetas, 'theta_range:num', 'config file')
 self.num_thetas = None
 is_valid = False
 logging.debug(f'num_thetas = {self.num_thetas}')
 return is_valid
 is_valid = True
 # Check work_folder (shared by both file formats)
 work_folder = os.path.abspath(self.config.get('work_folder', ''))
 if not os.path.isdir(work_folder):
-msnc.illegal_value('work_folder', work_folder, 'config file')
+illegal_value(work_folder, 'work_folder', 'config file')
 is_valid = False
 logging.info(f'work_folder: {work_folder}')
 # Check data filetype (shared by both file formats)
 self.data_filetype = self.config.get('data_filetype', 'tif')
 if not isinstance(self.data_filetype, str) or (self.data_filetype != 'tif' and
 self.data_filetype != 'h5'):
-msnc.illegal_value('data_filetype', self.data_filetype, 'config file')
+illegal_value(self.data_filetype, 'data_filetype', 'config file')
 if self.suffix == '.yml' or self.suffix == '.yaml':
 is_valid = self._validate_yaml()
 elif self.suffix == '.txt':
 is_valid = self._validate_txt()
 if isinstance(self.tdf_data_path, str):
 if not os.path.isabs(self.tdf_data_path):
 self.tdf_data_path = os.path.abspath(
 f'{work_folder}/{self.tdf_data_path}')
 else:
-msnc.illegal_value('tdf_data_path', tdf_data_fil, 'config file')
+illegal_value(tdf_data_fil, 'tdf_data_path', 'config file')
 is_valid = False
 else:
 if isinstance(self.tdf_data_path, int):
 self.tdf_data_path = os.path.abspath(
 f'{work_folder}/{self.tdf_data_path}/nf')
 elif isinstance(self.tdf_data_path, str):
 if not os.path.isabs(self.tdf_data_path):
 self.tdf_data_path = os.path.abspath(
 f'{work_folder}/{self.tdf_data_path}')
 else:
-msnc.illegal_value('tdf_data_path', self.tdf_data_path, 'config file')
+illegal_value(self.tdf_data_path, 'tdf_data_path', 'config file')
 is_valid = False
 logging.info(f'dark field images path = {self.tdf_data_path}')
 # Find tomography bright field images file/folder
 if self.tbf_data_path:
 if isinstance(self.tbf_data_path, str):
 if not os.path.isabs(self.tbf_data_path):
 self.tbf_data_path = os.path.abspath(
 f'{work_folder}/{self.tbf_data_path}')
 else:
-msnc.illegal_value('tbf_data_path', tbf_data_fil, 'config file')
+illegal_value(tbf_data_fil, 'tbf_data_path', 'config file')
 is_valid = False
 else:
 if isinstance(self.tbf_data_path, int):
 self.tbf_data_path = os.path.abspath(
 f'{work_folder}/{self.tbf_data_path}/nf')
 elif isinstance(self.tbf_data_path, str):
 if not os.path.isabs(self.tbf_data_path):
 self.tbf_data_path = os.path.abspath(
 f'{work_folder}/{self.tbf_data_path}')
 else:
-msnc.illegal_value('tbf_data_path', self.tbf_data_path, 'config file')
+illegal_value(self.tbf_data_path, 'tbf_data_path', 'config file')
 is_valid = False
 logging.info(f'bright field images path = {self.tbf_data_path}')
 # Find tomography images file/folders and stack parameters
 tomo_data_paths = []
 if self.data_filetype == 'h5':
 if isinstance(data_path, str):
 if not os.path.isabs(data_path):
 data_path = os.path.abspath(f'{work_folder}/{data_path}')
 else:
-msnc.illegal_value(f'stack_info:stacks:data_path', data_path, 'config file')
+illegal_value(data_path, 'stack_info:stacks:data_path', 'config file')
 is_valid = False
 data_path = None
 else:
 if isinstance(data_path, int):
 data_path = os.path.abspath(f'{work_folder}/{data_path}/nf')
 elif isinstance(data_path, str):
 if not os.path.isabs(data_path):
 data_path = os.path.abspath(f'{work_folder}/{data_path}')
 else:
-msnc.illegal_value(f'stack_info:stacks:data_path', data_path, 'config file')
+illegal_value(data_path, 'stack_info:stacks:data_path', 'config file')
 is_valid = False
 data_path = None
 tomo_data_paths.append(data_path)
 if index is None:
 if self.num_tomo_stacks > 1:
 is_valid = False
 index = None
 else:
 index = 1
 elif not isinstance(index, int):
-msnc.illegal_value(f'stack_info:stacks:index', index, 'config file')
+illegal_value(index, 'stack_info:stacks:index', 'config file')
 is_valid = False
 index = None
 tomo_data_indices.append(index)
 if ref_height is None:
 if self.num_tomo_stacks > 1:
 logging.error('Missing stack_info:stacks:ref_height in config file')
 is_valid = False
 ref_height = None
 else:
 ref_height = 0.
-elif not msnc.is_num(ref_height):
+elif not is_num(ref_height):
-msnc.illegal_value(f'stack_info:stacks:ref_height', ref_height, 'config file')
+illegal_value(ref_height, 'stack_info:stacks:ref_height', 'config file')
 is_valid = False
 ref_height = None
 # Set reference heights relative to first stack
-if (len(tomo_ref_heights) and msnc.is_num(ref_height) and
+if (len(tomo_ref_heights) and is_num(ref_height) and
-msnc.is_num(tomo_ref_heights[0])):
+is_num(tomo_ref_heights[0])):
 ref_height = (round(ref_height-tomo_ref_heights[0], 3))
 tomo_ref_heights.append(ref_height)
 tomo_ref_heights[0] = 0.0
 logging.info('tomography data paths:')
 for i in range(self.num_tomo_stacks):
 if path and not os.path.isdir(path):
 raise OSError(f'Invalid log_stream path')
 else:
 raise OSError(f'Invalid config_out input {config_out} {type(config_out)}')
 if not os.path.isdir(output_folder):
-raise OSError(f'Invalid output_folder input {output_folder} {type(output_folder)}')
+os.mkdir(os.path.abspath(output_folder))
 if isinstance(log_stream, str):
 path = os.path.split(log_stream)[0]
 if path and not os.path.isdir(path):
 raise OSError(f'Invalid log_stream path')
 if not os.path.isabs(path):
 # Check config file parameters
 self.is_valid =  self.cf.validate()
 # Load detector info file
-df = msnc.Detector(self.cf.config['detector']['id'])
+df = TomoDetectorConfig(self.cf.config['detector']['id'])
 # Check detector info file parameters
-if df.validate():
+if df.valid:
-pixel_size = df.getPixelSize()
+pixel_size = df.pixel_size
-num_rows, num_columns = df.getDimensions()
+num_rows, num_columns = df.dimensions
 if not pixel_size or not num_rows or not num_columns:
 self.is_valid = False
 else:
 pixel_size = None
 num_rows = None
 available_stacks = [False]*stack_info['num']
 # Check number of tomography angles/thetas
 num_thetas = self.config['theta_range'].get('num')
 if num_thetas is None:
-num_thetas = pyip.inputInt('\nEnter the number of thetas (>0): ', greaterThan=0)
+num_thetas = input_int('\nEnter the number of thetas', 1)
-elif not msnc.is_int(num_thetas, 0):
+elif not is_int(num_thetas, 0):
-msnc.illegal_value('num_thetas', num_thetas, 'config file')
+illegal_value(num_thetas, 'num_thetas', 'config file')
 self.is_valid = False
 return
 self.config['theta_range']['num'] = num_thetas
 logging.debug(f'num_thetas = {self.config["theta_range"]["num"]}')
 dark_field = self.config['dark_field']
 img_start = dark_field.get('img_start', -1)
 img_offset = dark_field.get('img_offset', -1)
 num_imgs = dark_field.get('num', 0)
 if not self.test_mode:
-img_start, img_offset, num_imgs = msnc.selectImageRange(img_start, img_offset,
+img_start, img_offset, num_imgs = selectImageRange(img_start, img_offset,
 num_imgs, 'dark field')
 if img_start < 0 or num_imgs < 1:
 logging.error('Unable to find suitable dark field images')
 if dark_field['data_path']:
 self.is_valid = False
 bright_field = self.config['bright_field']
 img_start = bright_field.get('img_start', -1)
 img_offset = bright_field.get('img_offset', -1)
 num_imgs = bright_field.get('num', 0)
 if not self.test_mode:
-img_start, img_offset, num_imgs = msnc.selectImageRange(img_start, img_offset,
+img_start, img_offset, num_imgs = selectImageRange(img_start, img_offset,
 num_imgs, 'bright field')
 if img_start < 0 or num_imgs < 1:
 logging.error('Unable to find suitable bright field images')
 self.is_valid = False
 bright_field['img_start'] = img_start
 index = stack['index']
 img_start = stack.get('img_start', -1)
 img_offset = stack.get('img_offset', -1)
 num_imgs = stack.get('num', 0)
 if not self.test_mode:
-img_start, img_offset, num_imgs = msnc.selectImageRange(img_start, img_offset,
+img_start, img_offset, num_imgs = selectImageRange(img_start, img_offset,
 num_imgs, f'tomography stack {index}', num_thetas)
 if img_start < 0 or num_imgs != num_thetas:
 logging.error('Unable to find suitable tomography images')
 self.is_valid = False
 stack['img_start'] = img_start
 """Generate dark field.
 """
 # Load the dark field images
 logging.debug('Loading dark field...')
 dark_field = self.config['dark_field']
-tdf_stack = msnc.loadImageStack(tdf_files, self.config['data_filetype'],
+tdf_stack = loadImageStack(tdf_files, self.config['data_filetype'],
 dark_field['img_offset'], dark_field['num'])
 # Take median
 self.tdf = np.median(tdf_stack, axis=0)
 del tdf_stack
 tdf_mean = np.nanmean(self.tdf)
 logging.debug(f'tdf_cutoff = {tdf_cutoff}')
 logging.debug(f'tdf_mean = {tdf_mean}')
 np.nan_to_num(self.tdf, copy=False, nan=tdf_mean, posinf=tdf_mean, neginf=0.)
 if self.galaxy_flag:
-msnc.quickImshow(self.tdf, title='dark field', path='setup_pngs',
+quickImshow(self.tdf, title='dark field', path='setup_pngs',
 save_fig=True, save_only=True)
 elif not self.test_mode:
-msnc.quickImshow(self.tdf, title='dark field', path=self.output_folder,
+quickImshow(self.tdf, title='dark field', path=self.output_folder,
 save_fig=self.save_plots, save_only=self.save_plots_only)
 def _genBright(self, tbf_files):
 """Generate bright field.
 """
 # Load the bright field images
 logging.debug('Loading bright field...')
 bright_field = self.config['bright_field']
-tbf_stack = msnc.loadImageStack(tbf_files, self.config['data_filetype'],
+tbf_stack = loadImageStack(tbf_files, self.config['data_filetype'],
 bright_field['img_offset'], bright_field['num'])
 # Take median
 """Median or mean: It may be best to try the median because of some image
 artifacts that arise due to crinkles in the upstream kapton tape windows
 if self.tdf.size:
 self.tbf -= self.tdf
 else:
 logging.warning('Dark field unavailable')
 if self.galaxy_flag:
-msnc.quickImshow(self.tbf, title='bright field', path='setup_pngs',
+quickImshow(self.tbf, title='bright field', path='setup_pngs',
 save_fig=True, save_only=True)
 elif not self.test_mode:
-msnc.quickImshow(self.tbf, title='bright field', path=self.output_folder,
+quickImshow(self.tbf, title='bright field', path=self.output_folder,
 save_fig=self.save_plots, save_only=self.save_plots_only)
 def _setDetectorBounds(self, tomo_stack_files):
 """Set vertical detector bounds for image stack.
 """
 img_x_bounds = [None, None]
 else:
 img_x_bounds = preprocess.get('img_x_bounds', [0, self.tbf.shape[0]])
 if img_x_bounds[0] is not None and img_x_bounds[1] is not None:
 if img_x_bounds[0] < 0:
-msnc.illegal_value('img_x_bounds[0]', img_x_bounds[0], 'config file')
+illegal_value(img_x_bounds[0], 'preprocess:img_x_bounds[0]', 'config file')
 img_x_bounds[0] = 0
-if not msnc.is_index_range(img_x_bounds, 0, self.tbf.shape[0]):
+if not is_index_range(img_x_bounds, 0, self.tbf.shape[0]):
-msnc.illegal_value('img_x_bounds[1]', img_x_bounds[1], 'config file')
+illegal_value(img_x_bounds[1], 'preprocess:img_x_bounds[1]', 'config file')
 img_x_bounds[1] = self.tbf.shape[0]
 if self.test_mode:
 # Update config and save to file
 if preprocess is None:
 self.cf.config['preprocess'] = {'img_x_bounds' : [0, self.tbf.shape[0]]}
 x_sum_min = x_sum.min()
 x_sum_max = x_sum.max()
 x_low = 0
 x_upp = x_sum.size
 if num_x_min is not None:
-fit = msnc.fitStep(y=x_sum, model='rectangle', form='atan')
+fit = Fit.fit_data(np.array(range(len(x_sum))), x_sum, models='rectangle',
-x_low = fit.get('center1', None)
+form='atan', guess=True)
-x_upp = fit.get('center2', None)
+parameters = fit.best_values
-sig_low = fit.get('sigma1', None)
+x_low = parameters.get('center1', None)
-sig_upp = fit.get('sigma2', None)
+x_upp = parameters.get('center2', None)
+sig_low = parameters.get('sigma1', None)
+sig_upp = parameters.get('sigma2', None)
 if (x_low is not None and x_upp is not None and sig_low is not None and
 sig_upp is not None and 0 <= x_low < x_upp <= x_sum.size and
 (sig_low+sig_upp)/(x_upp-x_low) < 0.1):
 if num_tomo_stacks == 1 or num_x_min is None:
 x_low = int(x_low-(x_upp-x_low)/10)
 if x_upp > x_sum.size:
 x_upp = x_sum.size
 else:
 x_low = 0
 x_upp = x_sum.size
-msnc.quickPlot((range(x_sum.size), x_sum),
+quickPlot((range(x_sum.size), x_sum),
 ([x_low, x_low], [x_sum_min, x_sum_max], 'r-'),
 ([x_upp-1, x_upp-1], [x_sum_min, x_sum_max], 'r-'),
 title=f'sum bright field over theta/y (row bounds: [{x_low}, {x_upp}])',
 path='setup_pngs', name='detectorbounds.png', save_fig=True, save_only=True,
 show_grid=True)
 for i,stack in enumerate(stacks):
-tomo_stack = msnc.loadImageStack(tomo_stack_files[i], self.config['data_filetype'],
+tomo_stack = loadImageStack(tomo_stack_files[i], self.config['data_filetype'],
 stack['img_offset'], 1)
 tomo_stack = tomo_stack[0,:,:]
 if num_x_min is not None:
 tomo_stack_max = tomo_stack.max()
 tomo_stack[x_low,:] = tomo_stack_max
 tomo_stack[x_upp-1,:] = tomo_stack_max
 title = f'tomography image at theta={self.config["theta_range"]["start"]}'
-msnc.quickImshow(tomo_stack, title=title, path='setup_pngs',
+quickImshow(tomo_stack, title=title, path='setup_pngs',
 name=f'tomo_{stack["index"]}.png', save_fig=True, save_only=True,
 show_grid=True)
 del tomo_stack
 # Update config and save to file
 del x_sum
 return
 # For one tomography stack only: load the first image
 title = None
-msnc.quickImshow(self.tbf, title='bright field')
+quickImshow(self.tbf, title='bright field')
 if num_tomo_stacks == 1:
-tomo_stack = msnc.loadImageStack(tomo_stack_files[0], self.config['data_filetype'],
+tomo_stack = loadImageStack(tomo_stack_files[0], self.config['data_filetype'],
 stacks[0]['img_offset'], 1)
 title = f'tomography image at theta={self.config["theta_range"]["start"]}'
-msnc.quickImshow(tomo_stack[0,:,:], title=title)
+quickImshow(tomo_stack[0,:,:], title=title)
-tomo_or_bright = pyip.inputNum('\nSelect image bounds from bright field (0) or '+
+tomo_or_bright = input_menu(['bright field', 'first tomography image'],
-'from first tomography image (1): ', min=0, max=1)
+header='\nSelect image bounds from')
 else:
 print('\nSelect image bounds from bright field')
 tomo_or_bright = 0
 if tomo_or_bright:
 x_sum = np.sum(tomo_stack[0,:,:], 1)
-use_bounds = 'no'
+use_bounds = False
 if img_x_bounds[0] is not None and img_x_bounds[1] is not None:
 tmp = np.copy(tomo_stack[0,:,:])
 tmp_max = tmp.max()
 tmp[img_x_bounds[0],:] = tmp_max
 tmp[img_x_bounds[1]-1,:] = tmp_max
 title = f'tomography image at theta={self.config["theta_range"]["start"]}'
-msnc.quickImshow(tmp, title=title)
+quickImshow(tmp, title=title)
 del tmp
 x_sum_min = x_sum.min()
 x_sum_max = x_sum.max()
-msnc.quickPlot((range(x_sum.size), x_sum),
+quickPlot((range(x_sum.size), x_sum),
 ([img_x_bounds[0], img_x_bounds[0]], [x_sum_min, x_sum_max], 'r-'),
 ([img_x_bounds[1]-1, img_x_bounds[1]-1], [x_sum_min, x_sum_max], 'r-'),
 title='sum over theta and y')
 print(f'lower bound = {img_x_bounds[0]} (inclusive)\n'+
 f'upper bound = {img_x_bounds[1]} (exclusive)]')
-use_bounds =  pyip.inputYesNo('Accept these bounds ([y]/n)?: ', blank=True)
+use_bounds =  input_yesno('Accept these bounds (y/n)?', 'y')
-if use_bounds == 'no':
+if not use_bounds:
-img_x_bounds = msnc.selectImageBounds(tomo_stack[0,:,:], 0,
+img_x_bounds = list(selectImageBounds(tomo_stack[0,:,:], 0,
 img_x_bounds[0], img_x_bounds[1], num_x_min,
-f'tomography image at theta={self.config["theta_range"]["start"]}')
+f'tomography image at theta={self.config["theta_range"]["start"]}'))
 if num_x_min is not None and img_x_bounds[1]-img_x_bounds[0]+1 < num_x_min:
 logging.warning('Image bounds and pixel size prevent seamless stacking')
 title = f'tomography image at theta={self.config["theta_range"]["start"]}'
-msnc.quickImshow(tomo_stack[0,:,:], title=title, path=self.output_folder,
+quickImshow(tomo_stack[0,:,:], title=title, path=self.output_folder,
 save_fig=self.save_plots, save_only=True)
-msnc.quickPlot(range(img_x_bounds[0], img_x_bounds[1]),
+quickPlot(range(img_x_bounds[0], img_x_bounds[1]),
 x_sum[img_x_bounds[0]:img_x_bounds[1]],
 title='sum over theta and y', path=self.output_folder,
 save_fig=self.save_plots, save_only=True)
 else:
 x_sum = np.sum(self.tbf, 1)
 x_sum_min = x_sum.min()
 x_sum_max = x_sum.max()
-use_bounds = 'no'
+use_bounds = False
 if img_x_bounds[0] is not None and img_x_bounds[1] is not None:
 tmp = np.copy(self.tbf)
 tmp_max = tmp.max()
 tmp[img_x_bounds[0],:] = tmp_max
 tmp[img_x_bounds[1]-1,:] = tmp_max
 title = 'bright field'
-msnc.quickImshow(tmp, title=title)
+quickImshow(tmp, title=title)
 del tmp
-msnc.quickPlot((range(x_sum.size), x_sum),
+quickPlot((range(x_sum.size), x_sum),
 ([img_x_bounds[0], img_x_bounds[0]], [x_sum_min, x_sum_max], 'r-'),
 ([img_x_bounds[1]-1, img_x_bounds[1]-1], [x_sum_min, x_sum_max], 'r-'),
 title='sum over theta and y')
 print(f'lower bound = {img_x_bounds[0]} (inclusive)\n'+
 f'upper bound = {img_x_bounds[1]} (exclusive)]')
-use_bounds =  pyip.inputYesNo('Accept these bounds ([y]/n)?: ', blank=True)
+use_bounds =  input_yesno('Accept these bounds (y/n)?', 'y')
-if use_bounds == 'no':
+if not use_bounds:
-use_fit = 'no'
+use_fit = False
-fit = msnc.fitStep(y=x_sum, model='rectangle', form='atan')
+fit = Fit.fit_data(np.array(range(len(x_sum))), x_sum, models='rectangle',
-x_low = fit.get('center1', None)
+form='atan', guess=True)
-x_upp = fit.get('center2', None)
+parameters = fit.best_values
-sig_low = fit.get('sigma1', None)
+x_low = parameters.get('center1', None)
-sig_upp = fit.get('sigma2', None)
+x_upp = parameters.get('center2', None)
+sig_low = parameters.get('sigma1', None)
+sig_upp = parameters.get('sigma2', None)
 if (x_low is not None and x_upp is not None and sig_low is not None and
 sig_upp is not None and 0 <= x_low < x_upp <= x_sum.size and
 (sig_low+sig_upp)/(x_upp-x_low) < 0.1):
 if num_tomo_stacks == 1 or num_x_min is None:
 x_low = int(x_low-(x_upp-x_low)/10)
 tmp = np.copy(self.tbf)
 tmp_max = tmp.max()
 tmp[x_low,:] = tmp_max
 tmp[x_upp-1,:] = tmp_max
 title = 'bright field'
-msnc.quickImshow(tmp, title=title)
+quickImshow(tmp, title=title)
 del tmp
-msnc.quickPlot((range(x_sum.size), x_sum),
+quickPlot((range(x_sum.size), x_sum),
 ([x_low, x_low], [x_sum_min, x_sum_max], 'r-'),
 ([x_upp, x_upp], [x_sum_min, x_sum_max], 'r-'),
 title='sum over theta and y')
 print(f'lower bound = {x_low} (inclusive)')
 print(f'upper bound = {x_upp} (exclusive)]')
-use_fit =  pyip.inputYesNo('Accept these bounds ([y]/n)?: ', blank=True)
+use_fit =  input_yesno('Accept these bounds (y/n)?', 'y')
-if use_fit == 'no':
+if use_fit:
-img_x_bounds = msnc.selectArrayBounds(x_sum, img_x_bounds[0], img_x_bounds[1],
+img_x_bounds = [x_low, x_upp]
-num_x_min, 'sum over theta and y')
 else:
-img_x_bounds = [x_low, x_upp]
+accept = False
+while not accept:
+mask, img_x_bounds = draw_mask_1d(x_sum, title='select x data range',
+legend='sum over theta and y')
+print(f'img_x_bounds = {img_x_bounds}')
+while (len(img_x_bounds) != 1 or (len(x_sum) >= num_x_min and
+img_x_bounds[0][1]-img_x_bounds[0][0]+1 < num_x_min)):
+exit('Should not be here')
+print('Please select exactly one continuous range')
+mask, img_x_bounds = draw_mask_1d(x_sum, title='select x data range',
+legend='sum over theta and y')
+img_x_bounds = list(img_x_bounds[0])
+quickPlot(x_sum, vlines=img_x_bounds, title='sum over theta and y')
+print(f'img_x_bounds = {img_x_bounds} (lower bound inclusive, upper bound '+
+'exclusive)')
+accept = input_yesno('Accept these bounds (y/n)?', 'y')
+if not accept:
+img_x_bounds = None
 if num_x_min is not None and img_x_bounds[1]-img_x_bounds[0]+1 < num_x_min:
 logging.warning('Image bounds and pixel size prevent seamless stacking')
-#msnc.quickPlot(range(img_x_bounds[0], img_x_bounds[1]),
+#quickPlot(range(img_x_bounds[0], img_x_bounds[1]),
 #        x_sum[img_x_bounds[0]:img_x_bounds[1]],
 #        title='sum over theta and y', path=self.output_folder,
 #        save_fig=self.save_plots, save_only=True)
-msnc.quickPlot((range(x_sum.size), x_sum),
+quickPlot((range(x_sum.size), x_sum),
 ([img_x_bounds[0], img_x_bounds[0]], [x_sum_min, x_sum_max], 'r-'),
 ([img_x_bounds[1], img_x_bounds[1]], [x_sum_min, x_sum_max], 'r-'),
 title='sum over theta and y', path=self.output_folder,
 save_fig=self.save_plots, save_only=True)
 del x_sum
 for i,stack in enumerate(stacks):
-tomo_stack = msnc.loadImageStack(tomo_stack_files[i], self.config['data_filetype'],
+tomo_stack = loadImageStack(tomo_stack_files[i], self.config['data_filetype'],
 stack['img_offset'], 1)
 tomo_stack = tomo_stack[0,:,:]
 if num_x_min is not None:
 tomo_stack_max = tomo_stack.max()
 tomo_stack[img_x_bounds[0],:] = tomo_stack_max
 tomo_stack[img_x_bounds[1]-1,:] = tomo_stack_max
 title = f'tomography image at theta={self.config["theta_range"]["start"]}'
 if self.galaxy_flag:
-msnc.quickImshow(tomo_stack, title=title, path='setup_pngs',
+quickImshow(tomo_stack, title=title, path='setup_pngs',
 name=f'tomo_{stack["index"]}.png', save_fig=True, save_only=True,
 show_grid=True)
 else:
-msnc.quickImshow(tomo_stack, title=title, path=self.output_folder,
+quickImshow(tomo_stack, title=title, path=self.output_folder,
 name=f'tomo_{stack["index"]}.png', save_fig=self.save_plots,
 save_only=True, show_grid=True)
 del tomo_stack
 logging.debug(f'img_x_bounds: {img_x_bounds}')
 if self.save_plots_only:
-msnc.clearFig('bright field')
+clearImshow('bright field')
-msnc.clearFig('sum over theta and y')
+clearPlot('sum over theta and y')
 if title:
-msnc.clearFig(title)
+clearPlot(title)
 # Update config and save to file
 if preprocess is None:
 self.cf.config['preprocess'] = {'img_x_bounds' : img_x_bounds}
 else:
 """
 preprocess = self.config.get('preprocess')
 zoom_perc = 100
 if not self.galaxy_flag:
 if preprocess is None or 'zoom_perc' not in preprocess:
-if pyip.inputYesNo(
+if input_yesno('\nDo you want to zoom in to reduce memory requirement (y/n)?', 'n'):
-'\nDo you want to zoom in to reduce memory requirement (y/[n])? ',
+zoom_perc = input_int('    Enter zoom percentage', 1, 100)
-blank=True) == 'yes':
-zoom_perc = pyip.inputInt('    Enter zoom percentage [1, 100]: ',
-min=1, max=100)
 else:
 zoom_perc = preprocess['zoom_perc']
-if msnc.is_num(zoom_perc, 1., 100.):
+if is_num(zoom_perc, 1., 100.):
 zoom_perc = int(zoom_perc)
 else:
-msnc.illegal_value('zoom_perc', zoom_perc, 'config file')
+illegal_value(zoom_perc, 'preprocess:zoom_perc', 'config file')
 zoom_perc = 100
 num_theta_skip = 0
 if not self.galaxy_flag:
 if preprocess is None or 'num_theta_skip' not in preprocess:
-if pyip.inputYesNo(
+if input_yesno('Do you want to skip thetas to reduce memory requirement (y/n)?',
-'Do you want to skip thetas to reduce memory requirement (y/[n])? ',
+'n'):
-blank=True) == 'yes':
+num_theta_skip = input_int('    Enter the number skip theta interval', 0,
-num_theta_skip = pyip.inputInt('    Enter the number skip theta interval'+
+self.num_thetas-1)
-f' [0, {self.num_thetas-1}]: ', min=0, max=self.num_thetas-1)
 else:
 num_theta_skip = preprocess['num_theta_skip']
-if not msnc.is_int(num_theta_skip, 0):
+if not is_int(num_theta_skip, 0):
-msnc.illegal_value('num_theta_skip', num_theta_skip, 'config file')
+illegal_value(num_theta_skip, 'preprocess:num_theta_skip', 'config file')
 num_theta_skip = 0
 logging.debug(f'zoom_perc = {zoom_perc}')
 logging.debug(f'num_theta_skip = {num_theta_skip}')
 # Update config and save to file
 title = f'{base_name} fullres'
 else:
 title = f'{base_name} {zoom_perc}p'
 title += f'_{index}'
 tomo_file = re.sub(r"\s+", '_', f'{self.output_folder}/{title}.npy')
-load_flag = 'no'
+load_flag = False
 available = False
 if os.path.isfile(tomo_file):
 available = True
 if required:
-load_flag = 'yes'
+load_flag = True
 else:
-load_flag = pyip.inputYesNo(f'\nDo you want to load {tomo_file} (y/n)? ')
+load_flag = input_yesno(f'\nDo you want to load {tomo_file} (y/n)?')
 stack = np.array([])
-if load_flag == 'yes':
+if load_flag:
 t0 = time()
 logging.info(f'Loading {tomo_file} ...')
 try:
 stack = np.load(tomo_file)
 except IOError or ValueError:
 stack = np.array([])
 logging.error(f'Error loading {tomo_file}')
 logging.info(f'... done in {time()-t0:.2f} seconds!')
 if stack.size:
-msnc.quickImshow(stack[:,0,:], title=title, path=self.output_folder,
+quickImshow(stack[:,0,:], title=title, path=self.output_folder,
 save_fig=self.save_plots, save_only=self.save_plots_only)
 return stack, available
 def _saveTomo(self, base_name, stack, index=None):
 """Save a tomography stack.
 continue
 # Load a stack of tomography images
 index = stack['index']
 t0 = time()
-tomo_stack = msnc.loadImageStack(tomo_stack_files[i], self.config['data_filetype'],
+tomo_stack = loadImageStack(tomo_stack_files[i], self.config['data_filetype'],
 stack['img_offset'], self.config['theta_range']['num'], num_theta_skip,
 img_x_bounds, img_y_bounds)
 tomo_stack = tomo_stack.astype('float64')
 logging.debug(f'loading stack {index} took {time()-t0:.2f} seconds!')
 # Downsize tomography stack to smaller size
 tomo_stack = tomo_stack.astype('float32')
 if not self.galaxy_flag:
 title = f'red stack fullres {index}'
 if not self.test_mode:
-msnc.quickImshow(tomo_stack[0,:,:], title=title, path=self.output_folder,
+quickImshow(tomo_stack[0,:,:], title=title, path=self.output_folder,
 save_fig=self.save_plots, save_only=self.save_plots_only)
 if zoom_perc != 100:
 t0 = time()
 logging.info(f'Zooming in ...')
 tomo_zoom_list = []
 logging.info(f'... done in {time()-t0:.2f} seconds!')
 del tomo_zoom_list
 if not self.galaxy_flag:
 title = f'red stack {zoom_perc}p {index}'
 if not self.test_mode:
-msnc.quickImshow(tomo_stack[0,:,:], title=title, path=self.output_folder,
+quickImshow(tomo_stack[0,:,:], title=title, path=self.output_folder,
 save_fig=self.save_plots, save_only=self.save_plots_only)
 # Convert tomography stack from theta,row,column to row,theta,column
 tomo_stack = np.swapaxes(tomo_stack, 0, 1)
 sinogram = tomo_plane_T[two_offset+dist_from_edge:-dist_from_edge,:]
 else:
 logging.debug(f'sinogram range = [{dist_from_edge}, {two_offset-dist_from_edge}]')
 sinogram = tomo_plane_T[dist_from_edge:two_offset-dist_from_edge,:]
 if plot_sinogram and not self.test_mode:
-msnc.quickImshow(sinogram.T, f'sinogram center offset{center_offset:.2f}',
+quickImshow(sinogram.T, f'sinogram center offset{center_offset:.2f}',
 path=self.output_folder, save_fig=self.save_plots,
 save_only=self.save_plots_only, aspect='auto')
 # Inverting sinogram
 t0 = time()
 # RV parameters for the denoise, gaussian, and ring removal will be different for different feature sizes
 edges = denoise_tv_chambolle(recon_plane, weight = weight)
 vmax = np.max(edges[0,:,:])
 vmin = -vmax
 if self.galaxy_flag:
-msnc.quickImshow(edges[0,:,:], title, path=path, save_fig=True, save_only=True,
+quickImshow(edges[0,:,:], title, path=path, save_fig=True, save_only=True,
 cmap='gray', vmin=vmin, vmax=vmax)
 else:
 if path is None:
 path=self.output_folder
-msnc.quickImshow(edges[0,:,:], f'{title} coolwarm', path=path,
+quickImshow(edges[0,:,:], f'{title} coolwarm', path=path,
 save_fig=self.save_plots, save_only=self.save_plots_only, cmap='coolwarm')
-msnc.quickImshow(edges[0,:,:], f'{title} gray', path=path,
+quickImshow(edges[0,:,:], f'{title} gray', path=path,
 save_fig=self.save_plots, save_only=self.save_plots_only, cmap='gray',
 vmin=vmin, vmax=vmax)
 del edges
 def _findCenterOnePlane(self, sinogram, row, thetas_deg, eff_pixel_size, cross_sectional_dim,
 recon_plane = self._reconstructOnePlane(sinogram_T, tomo_center, thetas_deg,
 eff_pixel_size, cross_sectional_dim, False, num_core)
 title = f'edges row{row} center offset{center_offset_vo:.2f} Vo'
 self._plotEdgesOnePlane(recon_plane, title)
 if not self.galaxy_flag:
-if (pyip.inputYesNo('Try finding center using phase correlation '+
+if input_yesno('Try finding center using phase correlation (y/n)?', 'n'):
-'(y/[n])? ', blank=True) == 'yes'):
 tomo_center = tomopy.find_center_pc(sinogram, sinogram, tol=0.1,
 rotc_guess=tomo_center)
 error = 1.
 while error > tol:
 prev = tomo_center
 print(f'Center at row {row} using phase correlation = {center_offset:.2f}')
 recon_plane = self._reconstructOnePlane(sinogram_T, tomo_center, thetas_deg,
 eff_pixel_size, cross_sectional_dim, False, num_core)
 title = f'edges row{row} center_offset{center_offset:.2f} PC'
 self._plotEdgesOnePlane(recon_plane, title)
-if (pyip.inputYesNo('Accept a center location ([y]) or continue '+
+if input_yesno('Accept a center location (y) or continue search (n)?', 'y'):
-'search (n)? ', blank=True) != 'no'):
+center_offset = input_num('    Enter chosen center offset', -center, center,
-center_offset = pyip.inputNum(
+center_offset_vo)
-f'    Enter chosen center offset [{-int(center)}, {int(center)}] '+
-f'([{center_offset_vo:.2f}])): ', blank=True)
-if center_offset == '':
-center_offset = center_offset_vo
 del sinogram_T
 del recon_plane
 return float(center_offset)
 # perform center finding search
 set_center = center_offset_vo
 if galaxy_param['center_type_selector'] == 'user':
 set_center = galaxy_param['set_center']
 set_range = galaxy_param['set_range']
 center_offset_step = galaxy_param['set_step']
-if (not msnc.is_num(set_range, 0) or not msnc.is_num(center_offset_step) or
+if (not is_num(set_range, 0) or not is_num(center_offset_step) or
 center_offset_step <= 0):
 logging.warning('Illegal center finding search parameter, skip search')
 del sinogram_T
 return float(center_offset_vo)
 set_range = center_offset_step*max(1, int(set_range/center_offset_step))
 center_offset_low = set_center-set_range
 center_offset_upp = set_center+set_range
 else:
-center_offset_low = pyip.inputInt('\nEnter lower bound for center offset '+
+center_offset_low = input_int('\nEnter lower bound for center offset',
-f'[{-int(center)}, {int(center)}]: ', min=-int(center), max=int(center))
+-center, center)
-center_offset_upp = pyip.inputInt('Enter upper bound for center offset '+
+center_offset_upp = input_int('Enter upper bound for center offset',
-f'[{center_offset_low}, {int(center)}]: ',
+center_offset_low, center)
-min=center_offset_low, max=int(center))
 if center_offset_upp == center_offset_low:
 center_offset_step = 1
 else:
-center_offset_step = pyip.inputInt('Enter step size for center offset search '+
+center_offset_step = input_int('Enter step size for center offset search',
-f'[1, {center_offset_upp-center_offset_low}]: ',
+1, center_offset_upp-center_offset_low)
-min=1, max=center_offset_upp-center_offset_low)
 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)
 for center_offset in center_offsets:
 if center_offset == center_offset_vo:
 continue
 title = f'edges row{row} center_offset{center_offset:.2f}'
 if self.galaxy_flag:
 self._plotEdgesOnePlane(recon_plane, title, path='find_center_pngs')
 else:
 self._plotEdgesOnePlane(recon_plane, title)
-if self.galaxy_flag or pyip.inputInt('\nContinue (0) or end the search (1): ',
+if self.galaxy_flag or input_int('\nContinue (0) or end the search (1)', 0, 1):
-min=0, max=1):
 break
 del sinogram_T
 del recon_plane
 if self.galaxy_flag:
 center_offset = center_offset_vo
 else:
-center_offset = pyip.inputNum(f'    Enter chosen center offset '+
+center_offset = input_num('    Enter chosen center offset', -center, center)
-f'[{-int(center)}, {int(center)}]: ', min=-int(center), max=int(center))
 return float(center_offset)
 def _reconstructOneTomoStack(self, tomo_stack, thetas, row_bounds=None,
 center_offsets=[], sigma=0.1, rwidth=30, num_core=1, algorithm='gridrec',
 run_secondary_sirt=False, secondary_iter=100):
 # https://tomopy.readthedocs.io/en/latest/api/tomopy.misc.corr.html
 # RV: Add an option to do (extra) secondary iterations later or to do some sort of convergence test?
 if row_bounds is None:
 row_bounds = [0, tomo_stack.shape[0]]
 else:
-if not msnc.is_index_range(row_bounds, 0, tomo_stack.shape[0]):
+if not is_index_range(row_bounds, 0, tomo_stack.shape[0]):
 raise ValueError('Illegal row bounds in reconstructOneTomoStack')
 if thetas.size != tomo_stack.shape[1]:
 raise ValueError('theta dimension mismatch in reconstructOneTomoStack')
 if not len(center_offsets):
 centers = np.zeros((row_bounds[1]-row_bounds[0]))
 """
 self.is_valid = True
 # Find dark field images
 dark_field = self.config['dark_field']
-img_start, num_imgs, dark_files = msnc.findImageFiles(
+img_start, num_imgs, dark_files = findImageFiles(
 dark_field['data_path'], self.config['data_filetype'], 'dark field')
 if img_start < 0 or num_imgs < 1:
 logging.error('Unable to find suitable dark field images')
 if dark_field['data_path']:
 self.is_valid = False
 if dark_field['data_path']:
 self.is_valid = False
 logging.info(f'Number of dark field images = {dark_field["num"]}')
 logging.info(f'Dark field image start index = {dark_field["img_start"]}')
 if num_imgs and tiff_to_h5_flag and self.config['data_filetype'] == 'tif':
-dark_files = msnc.combine_tiffs_in_h5(dark_files, num_imgs,
+dark_files = combine_tiffs_in_h5(dark_files, num_imgs,
 f'{self.config["work_folder"]}/dark_field.h5')
 dark_field['data_path'] = dark_files[0]
 # Find bright field images
 bright_field = self.config['bright_field']
-img_start, num_imgs, bright_files  = msnc.findImageFiles(
+img_start, num_imgs, bright_files  = findImageFiles(
 bright_field['data_path'], self.config['data_filetype'], 'bright field')
 if img_start < 0 or num_imgs < 1:
 logging.error('Unable to find suitable bright field images')
 self.is_valid = False
 img_start_old = bright_field.get('img_start')
 logging.warning('Inconsistent image start index for bright field images')
 self.is_valid = False
 logging.info(f'Number of bright field images = {bright_field["num"]}')
 logging.info(f'Bright field image start index = {bright_field["img_start"]}')
 if num_imgs and tiff_to_h5_flag and self.config['data_filetype'] == 'tif':
-bright_files = msnc.combine_tiffs_in_h5(bright_files, num_imgs,
+bright_files = combine_tiffs_in_h5(bright_files, num_imgs,
 f'{self.config["work_folder"]}/bright_field.h5')
 bright_field['data_path'] = bright_files[0]
 # Find tomography images
 tomo_stack_files = []
 for stack in self.config['stack_info']['stacks']:
 index = stack['index']
-img_start, num_imgs, tomo_files = msnc.findImageFiles(
+img_start, num_imgs, tomo_files = findImageFiles(
 stack['data_path'], self.config['data_filetype'], f'tomography set {index}')
 if img_start < 0 or num_imgs < 1:
 logging.error('Unable to find suitable tomography images')
 self.is_valid = False
 img_start_old = stack.get('img_start')
 logging.warning('Inconsistent image start index for tomography images')
 self.is_valid = False
 logging.info(f'Number of tomography images for set {index} = {stack["num"]}')
 logging.info(f'Tomography set {index} image start index = {stack["img_start"]}')
 if num_imgs and tiff_to_h5_flag and self.config['data_filetype'] == 'tif':
-tomo_files = msnc.combine_tiffs_in_h5(tomo_files, num_imgs,
+tomo_files = combine_tiffs_in_h5(tomo_files, num_imgs,
 f'{self.config["work_folder"]}/tomo_field_{index}.h5')
 stack['data_path'] = tomo_files[0]
 tomo_stack_files.append(tomo_files)
 del tomo_files
 center_stack_index = None
 if find_center and 'center_stack_index' in find_center:
 center_stack_index = find_center['center_stack_index']
 if (not isinstance(center_stack_index, int) or
 center_stack_index not in available_stacks):
-msnc.illegal_value('center_stack_index', center_stack_index, 'config file')
+illegal_value(center_stack_index, 'find_center:center_stack_index', 'config file')
 else:
 if self.test_mode:
 assert(find_center.get('completed', False) == False)
 else:
 print('\nFound calibration center offset info for stack '+
 f'{center_stack_index}')
-if (pyip.inputYesNo('Do you want to use this again ([y]/n)? ',
+if (input_yesno('Do you want to use this again (y/n)?', 'y')
-blank=True) != 'no' and find_center.get('completed', False) == True):
+and find_center.get('completed', False) == True):
 return
 # Load the required preprocessed stack
 # preprocessed stack order: row,theta,column
 num_tomo_stacks = self.config['stack_info']['num']
 raise OSError('Unable to load the required preprocessed tomography stack')
 assert(stacks[tomo_stack_index].get('preprocessed', False) == True)
 else:
 while True:
 if not center_stack_index:
-center_stack_index = pyip.inputInt('\nEnter tomography stack index to get '
+center_stack_index = input_int('\nEnter tomography stack index to get '
-f'rotation axis centers {available_stacks}: ')
+f'rotation axis centers ({available_stacks})', inset=available_stacks)
 while center_stack_index not in available_stacks:
-center_stack_index = pyip.inputInt('\nEnter tomography stack index to get '
+center_stack_index = input_int('\nEnter tomography stack index to get '
-f'rotation axis centers {available_stacks}: ')
+f'rotation axis centers ({available_stacks})', inset=available_stacks)
 tomo_stack_index = available_stacks.index(center_stack_index)
 if not self.tomo_stacks[tomo_stack_index].size:
 self.tomo_stacks[tomo_stack_index], available = self._loadTomo(
 'red stack', center_stack_index, required=True)
 center_stack = self.tomo_stacks[tomo_stack_index]
 row_bounds[1] = center_stack.shape[0]
 if center_rows[0] == -1:
 center_rows[0] = 0
 if center_rows[1] == -1:
 center_rows[1] = center_stack.shape[0]-1
-if not msnc.is_index_range(row_bounds, 0, center_stack.shape[0]):
+if not is_index_range(row_bounds, 0, center_stack.shape[0]):
-msnc.illegal_value('row_bounds', row_bounds)
+illegal_value(row_bounds, 'row_bounds', 'Tomo:findCenters')
 return
 # Set thetas (in degrees)
 theta_range = self.config['theta_range']
 theta_start = theta_range['start']
 if pixel_size is None:
 raise ValueError('Detector pixel size unavailable')
 eff_pixel_size = 100.*pixel_size/zoom_perc
 logging.debug(f'eff_pixel_size = {eff_pixel_size}')
 if num_tomo_stacks == 1:
-accept = 'yes'
+accept = True
 if not self.test_mode and not self.galaxy_flag:
-accept = 'no'
+accept = False
 print('\nSelect bounds for image reconstruction')
-if msnc.is_index_range(row_bounds, 0, center_stack.shape[0]):
+if is_index_range(row_bounds, 0, center_stack.shape[0]):
 a_tmp = np.copy(center_stack[:,0,:])
 a_tmp_max = a_tmp.max()
 a_tmp[row_bounds[0],:] = a_tmp_max
 a_tmp[row_bounds[1]-1,:] = a_tmp_max
 print(f'lower bound = {row_bounds[0]} (inclusive)')
 print(f'upper bound = {row_bounds[1]} (exclusive)')
-msnc.quickImshow(a_tmp, title=f'center stack theta={theta_start}',
+quickImshow(a_tmp, title=f'center stack theta={theta_start}',
 aspect='auto')
 del a_tmp
-accept = pyip.inputYesNo('Accept these bounds ([y]/n)?: ', blank=True)
+accept = input_yesno('Accept these bounds (y/n)?', 'y')
-if accept == 'no':
+if accept:
-(n1, n2) = msnc.selectImageBounds(center_stack[:,0,:], 0,
-title=f'center stack theta={theta_start}')
-else:
 n1 = row_bounds[0]
 n2 = row_bounds[1]
+else:
+n1, n2 = selectImageBounds(center_stack[:,0,:], 0,
+title=f'center stack theta={theta_start}')
 else:
 tomo_ref_heights = [stack['ref_height'] for stack in stacks]
 n1 = int((1.+(tomo_ref_heights[0]+center_stack.shape[0]*eff_pixel_size-
 tomo_ref_heights[1])/eff_pixel_size)/2)
 n2 = center_stack.shape[0]-n1
 if not self.test_mode and not self.galaxy_flag:
 tmp = center_stack[:,0,:]
 tmp_max = tmp.max()
 tmp[n1,:] = tmp_max
 tmp[n2-1,:] = tmp_max
-if msnc.is_index_range(center_rows, 0, tmp.shape[0]):
+if is_index_range(center_rows, 0, tmp.shape[0]):
 tmp[center_rows[0],:] = tmp_max
 tmp[center_rows[1]-1,:] = tmp_max
 extent = [0, tmp.shape[1], tmp.shape[0], 0]
-msnc.quickImshow(tmp, title=f'center stack theta={theta_start}',
+quickImshow(tmp, title=f'center stack theta={theta_start}',
 path=self.output_folder, extent=extent, save_fig=self.save_plots,
 save_only=self.save_plots_only, aspect='auto')
 del tmp
 #extent = [0, center_stack.shape[2], n2, n1]
-#msnc.quickImshow(center_stack[n1:n2,0,:], title=f'center stack theta={theta_start}',
+#quickImshow(center_stack[n1:n2,0,:], title=f'center stack theta={theta_start}',
 #        path=self.output_folder, extent=extent, save_fig=self.save_plots,
 #        save_only=self.save_plots_only, show_grid=True, aspect='auto')
 # Get cross sectional diameter in mm
 cross_sectional_dim = center_stack.shape[2]*eff_pixel_size
 # Determine center offset at sample row boundaries
 logging.info('Determine center offset at sample row boundaries')
 # Lower row center
-use_row = 'no'
+use_row = False
-use_center = 'no'
+use_center = False
 row = center_rows[0]
 if self.test_mode or self.galaxy_flag:
-assert(msnc.is_int(row, n1, n2-2))
+assert(is_int(row, n1, n2-2))
-if msnc.is_int(row, n1, n2-2):
+if is_int(row, n1, n2-2):
 if self.test_mode or self.galaxy_flag:
-use_row = 'yes'
+use_row = True
 else:
-msnc.quickImshow(center_stack[:,0,:], title=f'theta={theta_start}', aspect='auto')
+quickImshow(center_stack[:,0,:], title=f'theta={theta_start}', aspect='auto')
-use_row = pyip.inputYesNo('\nCurrent row index for lower center = '
+use_row = input_yesno('\nCurrent row index for lower center = '
-f'{row}, use this value ([y]/n)? ', blank=True)
+f'{row}, use this value (y/n)?', 'y')
 if self.save_plots_only:
-msnc.clearFig(f'theta={theta_start}')
+clearImshow(f'theta={theta_start}')
-if use_row != 'no':
+if use_row:
 center_offset = find_center.get('lower_center_offset')
-if msnc.is_num(center_offset):
+if is_num(center_offset):
-use_center = pyip.inputYesNo('Current lower center offset = '+
+use_center = input_yesno('Current lower center offset = '+
-f'{center_offset}, use this value ([y]/n)? ', blank=True)
+f'{center_offset}, use this value (y/n)?', 'y')
-if use_center == 'no':
+if not use_center:
-if use_row == 'no':
+if not use_row:
 if not self.test_mode:
-msnc.quickImshow(center_stack[:,0,:], title=f'theta={theta_start}',
+quickImshow(center_stack[:,0,:], title=f'theta={theta_start}',
 aspect='auto')
-row = pyip.inputInt('\nEnter row index to find lower center '+
+row = input_int('\nEnter row index to find lower center', n1, n2-2, n1)
-f'[[{n1}], {n2-2}]: ', min=n1, max=n2-2, blank=True)
 if row == '':
 row = n1
 if self.save_plots_only:
-msnc.clearFig(f'theta={theta_start}')
+clearImshow(f'theta={theta_start}')
 # center_stack order: row,theta,column
 center_offset = self._findCenterOnePlane(center_stack[row,:,:], row, thetas_deg,
 eff_pixel_size, cross_sectional_dim, num_core=num_core,
 galaxy_param=galaxy_param)
 logging.info(f'lower_center_offset = {center_offset:.2f} {type(center_offset)}')
 find_center['lower_center_offset'] = center_offset
 self.cf.saveFile(self.config_out)
 lower_row = row
 # Upper row center
-use_row = 'no'
+use_row = False
-use_center = 'no'
+use_center = False
 row = center_rows[1]
 if self.test_mode or self.galaxy_flag:
-assert(msnc.is_int(row, lower_row+1, n2-1))
+assert(is_int(row, lower_row+1, n2-1))
-if msnc.is_int(row, lower_row+1, n2-1):
+if is_int(row, lower_row+1, n2-1):
 if self.test_mode or self.galaxy_flag:
-use_row = 'yes'
+use_row = True
 else:
-msnc.quickImshow(center_stack[:,0,:], title=f'theta={theta_start}', aspect='auto')
+quickImshow(center_stack[:,0,:], title=f'theta={theta_start}', aspect='auto')
-use_row = pyip.inputYesNo('\nCurrent row index for upper center = '
+use_row = input_yesno('\nCurrent row index for upper center = '
-f'{row}, use this value ([y]/n)? ', blank=True)
+f'{row}, use this value (y/n)?', 'y')
 if self.save_plots_only:
-msnc.clearFig(f'theta={theta_start}')
+clearImshow(f'theta={theta_start}')
-if use_row != 'no':
+if use_row:
 center_offset = find_center.get('upper_center_offset')
-if msnc.is_num(center_offset):
+if is_num(center_offset):
-use_center = pyip.inputYesNo('Current upper center offset = '+
+use_center = input_yesrnNo('Current upper center offset = '+
-f'{center_offset}, use this value ([y]/n)? ', blank=True)
+f'{center_offset}, use this value (y/n)?', 'y')
-if use_center == 'no':
+if not use_center:
-if use_row == 'no':
+if not use_row:
 if not self.test_mode:
-msnc.quickImshow(center_stack[:,0,:], title=f'theta={theta_start}',
+quickImshow(center_stack[:,0,:], title=f'theta={theta_start}',
 aspect='auto')
-row = pyip.inputInt('\nEnter row index to find upper center '+
+row = input_int('\nEnter row index to find upper center', lower_row+1, n2-1, n2-1)
-f'[{lower_row+1}, [{n2-1}]]: ', min=lower_row+1, max=n2-1, blank=True)
 if row == '':
 row = n2-1
 if self.save_plots_only:
-msnc.clearFig(f'theta={theta_start}')
+clearImshow(f'theta={theta_start}')
 # center_stack order: row,theta,column
 center_offset = self._findCenterOnePlane(center_stack[row,:,:], row, thetas_deg,
 eff_pixel_size, cross_sectional_dim, num_core=num_core,
 galaxy_param=galaxy_param)
 logging.info(f'upper_center_offset = {center_offset:.2f}')
 plane1 = stack1[upper_row,:]
 plane2 = stack2[lower_row,:]
 for i in range(-2, 3):
 shift_i = shift+2*i
 plane1_shifted = spi.shift(plane2, [0, shift_i])
-msnc.quickPlot((plane1[0,:],), (plane1_shifted[0,:],),
+quickPlot((plane1[0,:],), (plane1_shifted[0,:],),
 title=f'stacks {stack1} {stack2} shifted {2*i} theta={self.start_theta}',
 path=self.output_folder, save_fig=self.save_plots,
 save_only=self.save_plots_only)
 if center_stack_index < self.num_tomo_stacks-1:
 stack1 = self.tomo_stacks[center_stack_index]
 plane1 = stack1[upper_row,:]
 plane2 = stack2[lower_row,:]
 for i in range(-2, 3):
 shift_i = -shift+2*i
 plane1_shifted = spi.shift(plane2, [0, shift_i])
-msnc.quickPlot((plane1[0,:],), (plane1_shifted[0,:],),
+quickPlot((plane1[0,:],), (plane1_shifted[0,:],),
 title=f'stacks {stack1} {stack2} shifted {2*i} theta={start_theta}',
 path=self.output_folder, save_fig=self.save_plots,
 save_only=self.save_plots_only)
 del plane1, plane2, plane1_shifted
 # Update config file
-self.config = msnc.update('config.txt', 'check_centers', True, 'find_centers')
+self.config = update('config.txt', 'check_centers', True, 'find_centers')
 def reconstructTomoStacks(self, galaxy_param=None, num_core=None):
 """Reconstruct tomography stacks.
 """
 if num_core is None:
 assert(isinstance(galaxy_param, dict))
 # Get rotation axis centers
 center_offsets = galaxy_param['center_offsets']
 assert(isinstance(center_offsets, list) and len(center_offsets) == 2)
 lower_center_offset = center_offsets[0]
-assert(msnc.is_num(lower_center_offset))
+assert(is_num(lower_center_offset))
 upper_center_offset = center_offsets[1]
-assert(msnc.is_num(upper_center_offset))
+assert(is_num(upper_center_offset))
 else:
 if galaxy_param:
 logging.warning('Ignoring galaxy_param in reconstructTomoStacks (only for Galaxy)')
 galaxy_param = None
 lower_center_offset = None
 logging.debug(f'... _reconstructOneTomoStack took {time()-t0:.2f} seconds!')
 logging.info(f'Reconstruction of stack {index} took {time()-t0:.2f} seconds!')
 if self.galaxy_flag:
 x_slice = int(self.tomo_stacks[i].shape[0]/2)
 title = f'{basetitle} {index} xslice{x_slice}'
-msnc.quickImshow(self.tomo_recon_stacks[i][x_slice,:,:], title=title,
+quickImshow(self.tomo_recon_stacks[i][x_slice,:,:], title=title,
 path='center_slice_pngs', save_fig=True, save_only=True)
 y_slice = int(self.tomo_stacks[i].shape[0]/2)
 title = f'{basetitle} {index} yslice{y_slice}'
-msnc.quickImshow(self.tomo_recon_stacks[i][:,y_slice,:], title=title,
+quickImshow(self.tomo_recon_stacks[i][:,y_slice,:], title=title,
 path='center_slice_pngs', save_fig=True, save_only=True)
 z_slice = int(self.tomo_stacks[i].shape[0]/2)
 title = f'{basetitle} {index} zslice{z_slice}'
-msnc.quickImshow(self.tomo_recon_stacks[i][:,:,z_slice], title=title,
+quickImshow(self.tomo_recon_stacks[i][:,:,z_slice], title=title,
 path='center_slice_pngs', save_fig=True, save_only=True)
 elif not self.test_mode:
 x_slice = int(self.tomo_stacks[i].shape[0]/2)
 title = f'{basetitle} {index} xslice{x_slice}'
-msnc.quickImshow(self.tomo_recon_stacks[i][x_slice,:,:], title=title,
+quickImshow(self.tomo_recon_stacks[i][x_slice,:,:], title=title,
 path=self.output_folder, save_fig=self.save_plots,
 save_only=self.save_plots_only)
-msnc.quickPlot(self.tomo_recon_stacks[i]
+quickPlot(self.tomo_recon_stacks[i]
 [x_slice,int(self.tomo_recon_stacks[i].shape[2]/2),:],
 title=f'{title} cut{int(self.tomo_recon_stacks[i].shape[2]/2)}',
 path=self.output_folder, save_fig=self.save_plots,
 save_only=self.save_plots_only)
 self._saveTomo('recon stack', self.tomo_recon_stacks[i], index)
 # Create cross section profile in yz-plane
 tomosum = 0
 [tomosum := tomosum+np.sum(tomo_recon_stack, axis=(0,2)) for tomo_recon_stack in
 self.tomo_recon_stacks]
-msnc.quickPlot(tomosum, title='recon stack sum yz', path='center_slice_pngs',
+quickPlot(tomosum, title='recon stack sum yz', path='center_slice_pngs',
 save_fig=True, save_only=True)
 # Create cross section profile in xz-plane
 tomosum = 0
 [tomosum := tomosum+np.sum(tomo_recon_stack, axis=(0,1)) for tomo_recon_stack in
 self.tomo_recon_stacks]
-msnc.quickPlot(tomosum, title='recon stack sum xz', path='center_slice_pngs',
+quickPlot(tomosum, title='recon stack sum xz', path='center_slice_pngs',
 save_fig=True, save_only=True)
 # Create cross section profile in xy-plane
 num_tomo_stacks = len(stacks)
 row_bounds = self.config['find_center']['row_bounds']
-if not msnc.is_index_range(row_bounds, 0, self.tomo_recon_stacks[0].shape[0]):
+if not is_index_range(row_bounds, 0, self.tomo_recon_stacks[0].shape[0]):
-msnc.illegal_value('row_bounds', row_bounds, 'config file')
+illegal_value(row_bounds, 'find_center:row_bounds', 'config file')
 return
 if num_tomo_stacks == 1:
 low_bound = row_bounds[0]
 else:
 low_bound = 0
 axis=(1,2)) for i in range(1, num_tomo_stacks-1)])
 if num_tomo_stacks > 1:
 tomosum = np.concatenate([tomosum,
 np.sum(self.tomo_recon_stacks[num_tomo_stacks-1][row_bounds[0]:,:,:],
 axis=(1,2))])
-msnc.quickPlot(tomosum, title='recon stack sum xy', path='center_slice_pngs',
+quickPlot(tomosum, title='recon stack sum xy', path='center_slice_pngs',
 save_fig=True, save_only=True)
 def combineTomoStacks(self, galaxy_param=None):
 """Combine the reconstructed tomography stacks.
 """
 logging.error('Incompatible reconstructed tomography stack dimensions')
 return
 # Get center stack boundaries
 row_bounds = self.config['find_center']['row_bounds']
-if not msnc.is_index_range(row_bounds, 0, self.tomo_recon_stacks[0].shape[0]):
+if not is_index_range(row_bounds, 0, self.tomo_recon_stacks[0].shape[0]):
-msnc.illegal_value('row_bounds', row_bounds, 'config file')
+illegal_value(row_bounds, 'find_center:row_bounds', 'config file')
 return
 # Selecting x bounds (in yz-plane)
 tomosum = 0
 #RV FIX :=
 if self.galaxy_flag:
 if x_bounds[0] == -1:
 x_bounds[0] = 0
 if x_bounds[1] == -1:
 x_bounds[1] = tomosum.size
-if not msnc.is_index_range(x_bounds, 0, tomosum.size):
+if not is_index_range(x_bounds, 0, tomosum.size):
-msnc.illegal_value('x_bounds', x_bounds, 'galaxy input')
+illegal_value(x_bounds, 'x_bounds', 'galaxy input')
 tomosum_min = tomosum.min()
 tomosum_max = tomosum.max()
-msnc.quickPlot((range(tomosum.size), tomosum),
+quickPlot((range(tomosum.size), tomosum),
 ([x_bounds[0], x_bounds[0]], [tomosum_min, tomosum_max], 'r-'),
 ([x_bounds[1]-1, x_bounds[1]-1], [tomosum_min, tomosum_max], 'r-'),
 title=f'recon stack sum yz', path='combine_pngs', save_fig=True, save_only=True)
 else:
 if combine_stacks and 'x_bounds' in combine_stacks:
 x_bounds = combine_stacks['x_bounds']
-if not msnc.is_index_range(x_bounds, 0, tomosum.size):
+if not is_index_range(x_bounds, 0, tomosum.size):
-msnc.illegal_value('x_bounds', x_bounds, 'config file')
+illegal_value(x_bounds, 'combine_stacks:x_bounds', 'config file')
 elif not self.test_mode:
-msnc.quickPlot(tomosum, title='recon stack sum yz')
+accept = False
-if pyip.inputYesNo('\nCurrent image x-bounds: '+
+while not accept:
-f'[{x_bounds[0]}, {x_bounds[1]}], use these values ([y]/n)? ',
+mask, x_bounds = draw_mask_1d(tomosum, current_index_ranges=x_bounds,
-blank=True) == 'no':
+title='select x data range', legend='recon stack sum yz')
-if pyip.inputYesNo(
+while len(x_bounds) != 1:
-'Do you want to change the image x-bounds ([y]/n)? ',
+print('Please select exactly one continuous range')
-blank=True) == 'no':
+mask, x_bounds = draw_mask_1d(tomosum, title='select x data range',
-x_bounds = [0, tomosum.size]
+legend='recon stack sum yz')
-else:
+x_bounds = list(x_bounds[0])
-x_bounds = msnc.selectArrayBounds(tomosum, title='recon stack sum yz')
+quickPlot(tomosum, vlines=x_bounds, title='recon stack sum yz')
-else:
+print(f'x_bounds = {x_bounds} (lower bound inclusive, upper bound '+
-msnc.quickPlot(tomosum, title='recon stack sum yz')
+'exclusive)')
-if pyip.inputYesNo('\nDo you want to change the image x-bounds (y/n)? ') == 'no':
+accept = input_yesno('Accept these bounds (y/n)?', 'y')
+if not accept:
+x_bounds = None
+else:
+if not input_yesno('\nDo you want to change the image x-bounds (y/n)?', 'n'):
 x_bounds = [0, tomosum.size]
 else:
-x_bounds = msnc.selectArrayBounds(tomosum, title='recon stack sum yz')
+accept = False
+while not accept:
+mask, x_bounds = draw_mask_1d(tomosum, title='select x data range',
+legend='recon stack sum yz')
+while len(x_bounds) != 1:
+print('Please select exactly one continuous range')
+mask, x_bounds = draw_mask_1d(tomosum, title='select x data range',
+legend='recon stack sum yz')
+x_bounds = list(x_bounds[0])
+quickPlot(tomosum, vlines=x_bounds, title='recon stack sum yz')
+print(f'x_bounds = {x_bounds} (lower bound inclusive, upper bound '+
+'exclusive)')
+accept = input_yesno('Accept these bounds (y/n)?', 'y')
 if False and self.test_mode:
 np.savetxt(f'{self.output_folder}/recon_stack_sum_yz.txt',
 tomosum[x_bounds[0]:x_bounds[1]], fmt='%.6e')
 if self.save_plots_only:
-msnc.clearFig('recon stack sum yz')
+clearPlot('recon stack sum yz')
 # Selecting y bounds (in xz-plane)
 tomosum = 0
 #RV FIX :=
 [tomosum := tomosum+np.sum(tomo_recon_stack, axis=(0,1)) for tomo_recon_stack in
 if self.galaxy_flag:
 if y_bounds[0] == -1:
 y_bounds[0] = 0
 if y_bounds[1] == -1:
 y_bounds[1] = tomosum.size
-if not msnc.is_index_range(y_bounds, 0, tomosum.size):
+if not is_index_range(y_bounds, 0, tomosum.size):
-msnc.illegal_value('y_bounds', y_bounds, 'galaxy input')
+illegal_value(y_bounds, 'y_bounds', 'galaxy input')
 tomosum_min = tomosum.min()
 tomosum_max = tomosum.max()
-msnc.quickPlot((range(tomosum.size), tomosum),
+quickPlot((range(tomosum.size), tomosum),
 ([y_bounds[0], y_bounds[0]], [tomosum_min, tomosum_max], 'r-'),
 ([y_bounds[1]-1, y_bounds[1]-1], [tomosum_min, tomosum_max], 'r-'),
 title=f'recon stack sum xz', path='combine_pngs', save_fig=True, save_only=True)
 else:
 if combine_stacks and 'y_bounds' in combine_stacks:
 y_bounds = combine_stacks['y_bounds']
-if not msnc.is_index_range(y_bounds, 0, tomosum.size):
+if not is_index_range(y_bounds, 0, tomosum.size):
-msnc.illegal_value('y_bounds', y_bounds, 'config file')
+illegal_value(y_bounds, 'combine_stacks:y_bounds', 'config file')
 elif not self.test_mode:
-msnc.quickPlot(tomosum, title='recon stack sum xz')
+accept = False
-if pyip.inputYesNo('\nCurrent image y-bounds: '+
+while not accept:
-f'[{y_bounds[0]}, {y_bounds[1]}], use these values ([y]/n)? ',
+mask, y_bounds = draw_mask_1d(tomosum, current_index_ranges=y_bounds,
-blank=True) == 'no':
+title='select y data range', legend='recon stack sum xz')
-if pyip.inputYesNo(
+while len(y_bounds) != 1:
-'Do you want to change the image y-bounds ([y]/n)? ',
+print('Please select exactly one continuous range')
-blank=True) == 'no':
+mask, y_bounds = draw_mask_1d(tomosum, title='select y data range',
-y_bounds = [0, tomosum.size]
+legend='recon stack sum xz')
-else:
+y_bounds = list(y_bounds[0])
-y_bounds = msnc.selectArrayBounds(tomosum, title='recon stack sum yz')
+quickPlot(tomosum, vlines=y_bounds, title='recon stack sum xz')
-else:
+print(f'y_bounds = {y_bounds} (lower bound inclusive, upper bound '+
-msnc.quickPlot(tomosum, title='recon stack sum xz')
+'exclusive)')
-if pyip.inputYesNo('\nDo you want to change the image y-bounds (y/n)? ') == 'no':
+accept = input_yesno('Accept these bounds (y/n)?', 'y')
+if not accept:
+y_bounds = None
+else:
+if not input_yesno('\nDo you want to change the image y-bounds (y/n)?', 'n'):
 y_bounds = [0, tomosum.size]
 else:
-y_bounds = msnc.selectArrayBounds(tomosum, title='recon stack sum xz')
+accept = False
+while not accept:
+mask, y_bounds = draw_mask_1d(tomosum, title='select y data range',
+legend='recon stack sum xz')
+while len(y_bounds) != 1:
+print('Please select exactly one continuous range')
+mask, y_bounds = draw_mask_1d(tomosum, title='select y data range',
+legend='recon stack sum xz')
+y_bounds = list(y_bounds[0])
+quickPlot(tomosum, vlines=y_bounds, title='recon stack sum xz')
+print(f'y_bounds = {y_bounds} (lower bound inclusive, upper bound '+
+'exclusive)')
+accept = input_yesno('Accept these bounds (y/n)?', 'y')
 if False and self.test_mode:
 np.savetxt(f'{self.output_folder}/recon_stack_sum_xz.txt',
 tomosum[y_bounds[0]:y_bounds[1]], fmt='%.6e')
 if self.save_plots_only:
-msnc.clearFig('recon stack sum xz')
+clearPlot('recon stack sum xz')
 # Combine reconstructed tomography stacks
 logging.info(f'Combining reconstructed stacks ...')
 t0 = time()
 num_tomo_stacks = len(stacks)
 filename = 'recon combined sum xy'
 if zoom_perc is None or zoom_perc == 100:
 filename += ' fullres.dat'
 else:
 filename += f' {zoom_perc}p.dat'
-msnc.quickPlot(tomosum, title='recon combined sum xy',
+quickPlot(tomosum, title='recon combined sum xy',
 path=self.output_folder, save_fig=self.save_plots,
 save_only=self.save_plots_only)
 if False:
 np.savetxt(f'{self.output_folder}/recon_combined_sum_xy.txt',
 tomosum, fmt='%.6e')
 if self.galaxy_flag:
 if z_bounds[0] == -1:
 z_bounds[0] = 0
 if z_bounds[1] == -1:
 z_bounds[1] = tomosum.size
-if not msnc.is_index_range(z_bounds, 0, tomosum.size):
+if not is_index_range(z_bounds, 0, tomosum.size):
-msnc.illegal_value('z_bounds', z_bounds, 'galaxy input')
+illegal_value(z_bounds, 'z_bounds', 'galaxy input')
 tomosum_min = tomosum.min()
 tomosum_max = tomosum.max()
-msnc.quickPlot((range(tomosum.size), tomosum),
+quickPlot((range(tomosum.size), tomosum),
 ([z_bounds[0], z_bounds[0]], [tomosum_min, tomosum_max], 'r-'),
 ([z_bounds[1]-1, z_bounds[1]-1], [tomosum_min, tomosum_max], 'r-'),
 title=f'recon stack sum xy', path='combine_pngs', save_fig=True, save_only=True)
 else:
-msnc.quickPlot(tomosum, title='recon combined sum xy')
+if not input_yesno('\nDo you want to change the image z-bounds (y/n)?', 'n'):
-if pyip.inputYesNo(
-'\nDo you want to change the image z-bounds (y/[n])? ',
-blank=True) != 'yes':
 z_bounds = [0, tomosum.size]
 else:
-z_bounds = msnc.selectArrayBounds(tomosum, title='recon combined sum xy')
+accept = False
+while not accept:
+mask, z_bounds = draw_mask_1d(tomosum, title='select z data range',
+legend='recon stack sum xy')
+while len(z_bounds) != 1:
+print('Please select exactly one continuous range')
+mask, z_bounds = draw_mask_1d(tomosum, title='select z data range',
+legend='recon stack sum xy')
+z_bounds = list(z_bounds[0])
+quickPlot(tomosum, vlines=z_bounds, title='recon stack sum xy')
+print(f'z_bounds = {z_bounds} (lower bound inclusive, upper bound exclusive)')
+accept = input_yesno('Accept these bounds (y/n)?', 'y')
 if self.save_plots_only:
-msnc.clearFig('recon combined sum xy')
+clearPlot('recon combined sum xy')
 if z_bounds[0] != 0 or z_bounds[1] != tomosum.size:
 tomo_recon_combined = tomo_recon_combined[z_bounds[0]:z_bounds[1],:,:]
 # Plot center slices
 if self.galaxy_flag:
 save_only = True
 else:
 path = self.output_folder
 save_fig = self.save_plots
 save_only = self.save_plots_only
-msnc.quickImshow(tomo_recon_combined[int(tomo_recon_combined.shape[0]/2),:,:],
+quickImshow(tomo_recon_combined[int(tomo_recon_combined.shape[0]/2),:,:],
 title=f'recon combined xslice{int(tomo_recon_combined.shape[0]/2)}',
 path=path, save_fig=save_fig, save_only=save_only)
-msnc.quickImshow(tomo_recon_combined[:,int(tomo_recon_combined.shape[1]/2),:],
+quickImshow(tomo_recon_combined[:,int(tomo_recon_combined.shape[1]/2),:],
 title=f'recon combined yslice{int(tomo_recon_combined.shape[1]/2)}',
 path=path, save_fig=save_fig, save_only=save_only)
-msnc.quickImshow(tomo_recon_combined[:,:,int(tomo_recon_combined.shape[2]/2)],
+quickImshow(tomo_recon_combined[:,:,int(tomo_recon_combined.shape[2]/2)],
 title=f'recon combined zslice{int(tomo_recon_combined.shape[2]/2)}',
 path=path, save_fig=save_fig, save_only=save_only)
 # Save combined reconstructed tomography stack to file
 if self.galaxy_flag:

Mercurial > repos > rv43 > tomo

comparison tomo.py @ 49:26f99fdd8d61 draft