def __fitting_helper(self, qv_type, echo_inds, tissue, bounds, tc0, decimal_precision, mask_path):
echo_info = [(self.echo_times[i], self.volumes[i]) for i in echo_inds]
# sort by echo time
echo_info = sorted(echo_info, key=lambda x: x[0])
xs = [et for et, _ in echo_info]
ys = [vol for _, vol in echo_info]
# only calculate for focused region if a mask is available, this speeds up computation
mask = tissue.get_mask()
if not mask and mask_path:
mask = fio_utils.generic_load(mask_path, expected_num_volumes=1)
if tuple(np.unique(mask.volume)) != (0, 1):
raise ValueError('mask_filepath must reference binary segmentation volume')
mef = MonoExponentialFit(xs, ys,
mask=mask,
bounds=bounds,
tc0=tc0,
decimal_precision=decimal_precision)
qv_map, r2 = mef.fit()
quant_val_map = qv_type(qv_map)
quant_val_map.add_additional_volume('r2', r2)
tissue.add_quantitative_value(quant_val_map)
return quant_val_map
def load_volume(self, title='Select volume file(s)'):
files = filedialog.askopenfilenames(initialdir=self.__base_filepath,
title=title)
if len(files) == 0:
return
filepath = files[0]
self.__base_filepath = os.path.dirname(filepath)
if filepath.endswith('.dcm'):
filepath = os.path.dirname(filepath)
im = fio_utils.generic_load(filepath, 1)
return im
def load_data(self, load_dirpath):
"""Load information for tissue
All tissue information is based on the mask.
If mask for tissue doesn't exist, there is no information to load.
:param load_dirpath: base path to load data (same as 'save_dirpath' arg input to self.save_data(save_dirpath))
"""
load_dirpath = self.__save_dirpath__(load_dirpath)
mask_filepath = os.path.join(load_dirpath, '%s.nii.gz' % self.STR_ID)
# try to load mask, if file exists
try:
msk = fio_utils.generic_load(mask_filepath, expected_num_volumes=1)
self.set_mask(msk)
except FileNotFoundError:
# do nothing
pass
self.quantitative_values = QuantitativeValue.load_qvs(load_dirpath)
def __dilate_mask__(
self,
mask_path: str,
temp_path: str,
dil_rate: float = defaults.DEFAULT_MASK_DIL_RATE,
dil_threshold: float = defaults.DEFAULT_MASK_DIL_THRESHOLD):
"""Dilate mask using gaussian blur and write to disk to use with elastix
:param mask_path: path to mask to use to use as focus points for registration, mask must be binary
:param temp_path: path to store temporary data
:param dil_rate: dilation rate (sigma)
:param dil_threshold: threshold to binarize dilated mask - float between [0, 1]
:return: the path to the dilated mask
:raise FileNotFoundError:
1. filepath specified by mask_path is not found
:raise ValueError:
1. dil_threshold not in range [0, 1]
"""
if not os.path.isfile(mask_path):
raise FileNotFoundError('File %s not found' % mask_path)
if dil_threshold < 0 or dil_threshold > 1:
raise ValueError('dil_threshold must be in range [0, 1]')
mask = fio_utils.generic_load(mask_path, expected_num_volumes=1)
dilated_mask = sni.gaussian_filter(np.asarray(mask.volume,
dtype=np.float32),
sigma=dil_rate) > dil_threshold
fixed_mask = np.asarray(dilated_mask, dtype=np.int8)
fixed_mask_filepath = os.path.join(io_utils.check_dir(temp_path),
'dilated-mask.nii.gz')
dilated_mask_volume = MedicalVolume(fixed_mask, affine=mask.affine)
dilated_mask_volume.save_volume(fixed_mask_filepath)
return fixed_mask_filepath
def generate_t1_rho_map(self, tissue: Tissue, mask_path: str = None):
"""Generate 3D T1-rho map and r2 fit map using monoexponential fit across subvolumes acquired at different
echo times
:param tissue: A Tissue instance
:return: a T1Rho instance
"""
spin_lock_times = []
subvolumes_list = []
# only calculate for focused region if a mask is available, this speeds up computation
mask = tissue.get_mask()
if (not mask or np.sum(mask.volume) == 0) and mask_path:
mask = fio_utils.generic_load(mask_path, expected_num_volumes=1)
if tuple(np.unique(mask.volume)) != (0, 1):
raise ValueError(
'mask_filepath must reference binary segmentation volume')
sorted_keys = natsorted(list(self.subvolumes.keys()))
for spin_lock_time_index in sorted_keys:
subvolumes_list.append(self.subvolumes[spin_lock_time_index])
spin_lock_times.append(self.spin_lock_times[spin_lock_time_index])
mef = MonoExponentialFit(
spin_lock_times,
subvolumes_list,
mask=mask,
bounds=(__T1_RHO_LOWER_BOUND__, __T1_RHO_UPPER_BOUND__),
tc0=__INITIAL_T1_RHO_VAL__,
decimal_precision=__T1_RHO_DECIMAL_PRECISION__)
t1rho_map, r2 = mef.fit()
quant_val_map = qv.T1Rho(t1rho_map)
quant_val_map.add_additional_volume('r2', r2)
tissue.add_quantitative_value(quant_val_map)
return quant_val_map
def load_data(self, dirpath):
filepath = os.path.join(dirpath, self.NAME, '%s.nii.gz' % self.NAME)
qv_volume = fio_utils.generic_load(filepath, expected_num_volumes=1)
self.volumetric_map = qv_volume
def load_volume(self, title='Select volume file(s)'):
filepath = self.get_volume_filepath(title)
im = fio_utils.generic_load(filepath, 1)
return im