def update_output_folder_text(self):
if os.path.isfile(self.selectedDWI.text()) and os.path.isfile(
self.selectedMask.text()):
folder_base = os.path.join(
os.path.dirname(self.selectedDWI.text()), 'output',
split_image_path(self.selectedMask.text())[1])
self.selectedOutputFolder.setText(folder_base)
def generate_roi_mask(self):
kwargs = dict(mask=self.selectedMaskText.text(), output=self.selectedOutputFileText.text(),
dimension=self.dimensionInput.value(), slice=self.sliceInput.value())
self._generate_mask_worker.set_args(**kwargs)
self._computations_thread.start()
self._generate_mask_worker.moveToThread(self._computations_thread)
self._generate_mask_worker.starting.connect(self._computations_thread.starting)
self._generate_mask_worker.finished.connect(self._computations_thread.finished)
self._generate_mask_worker.starting.connect(lambda: self.generateButton.setEnabled(False))
self._generate_mask_worker.finished.connect(lambda: self.generateButton.setEnabled(True))
self._generate_mask_worker.finished.connect(lambda: self.viewButton.setEnabled(True))
image_path = split_image_path(self.selectedOutputFileText.text())
script_basename = os.path.join(image_path[0], 'scripts', 'create_roi_mask_' + image_path[1])
if not os.path.isdir(os.path.join(image_path[0], 'scripts')):
os.makedirs(os.path.join(image_path[0], 'scripts'))
self._generate_mask_worker.finished.connect(
lambda: self._write_python_script_file(script_basename + '.py', **kwargs))
self._generate_mask_worker.finished.connect(
lambda: self._write_bash_script_file(script_basename + '.sh', **kwargs))
self._generate_mask_worker.starting.emit()
def run(self, args, extra_args):
input_file = os.path.realpath(args.input_file)
if args.output_file is None:
dirname, basename, ext = split_image_path(input_file)
output_file = dirname + basename + '_tSNR' + ext
else:
output_file = os.path.realpath(args.output_file)
nifti = mct.load_nifti(input_file)
tsnr = calculate_tsnr(nifti.get_data())
mdt.write_nifti(tsnr, output_file, nifti.get_header())
def update_output_file_text(self):
if os.path.isfile(self.selectedMaskText.text()):
folder, basename, ext = split_image_path(self.selectedMaskText.text())
folder_base = os.path.join(folder, basename)
if self.selectedOutputFileText.text() == '':
self.selectedOutputFileText.setText('{}_{}_{}.nii.gz'.format(folder_base,
self.dimensionInput.value(),
self.sliceInput.value()))
elif self.selectedOutputFileText.text()[0:len(folder_base)] == folder_base:
self.selectedOutputFileText.setText('{}_{}_{}.nii.gz'.format(folder_base,
self.dimensionInput.value(),
self.sliceInput.value()))
def run(self, args, extra_args):
input_file = os.path.realpath(
get_input_file(args.input_file, os.path.realpath('')))
dirname, _, _ = split_image_path(input_file)
if args.output_folder is None:
output_folder = dirname + '/split'
else:
output_folder = os.path.realpath(args.output_folder)
if not os.path.exists(output_folder):
os.makedirs(output_folder)
split_write_volumes(input_file, output_folder, args.axis)
def run(self, args, extra_args):
mask = mdt.load_brain_mask(
nifti_filepath_resolution(os.path.realpath(args.mask)))
file_names = []
for file in args.input_files:
file_names.extend(glob.glob(file))
for file in file_names:
if args.overwrite:
mdt.apply_mask_to_file(file, mask)
else:
folder, basename, ext = split_image_path(
nifti_filepath_resolution(os.path.realpath(file)))
mdt.apply_mask_to_file(file,
mask,
output_fname=os.path.join(
folder, basename + '_masked' + ext))
def _load_niftis(self):
niftis = []
for filename in self._input_filenames:
filename = nifti_filepath_resolution(filename)
_, basename, extension = split_image_path(filename)
if extension.endswith('gz'):
unzipped_nifti_path = os.path.join(self._tmp_dir,
basename + '.nii')
unzip_nifti(filename, unzipped_nifti_path)
self._files_to_remove.append(unzipped_nifti_path)
resolved_path = unzipped_nifti_path
else:
resolved_path = filename
niftis.append(load_nifti(resolved_path))
return niftis
def _select_image(self):
initial_dir = self._shared_state.base_dir
if self.selectedImageText.text() != '':
initial_dir = self.selectedImageText.text()
open_file, used_filter = QFileDialog().getOpenFileName(
caption='Select the 4d diffusion weighted image',
directory=initial_dir,
filter=';;'.join(image_files_filters))
if os.path.isfile(open_file):
self.selectedImageText.setText(open_file)
self._shared_state.base_dir = os.path.dirname(open_file)
if self.selectedOutputText.text() == '':
split_path = split_image_path(open_file)
self.selectedOutputText.setText(
os.path.join(split_path[0],
split_path[1] + '_mask' + split_path[2]))
def split_write_volumes(input_file, output_dir, axis=-1):
"""Split and write the given input volume to separate nifti files.
Args:
input_file (str): the input nifti file to split
output_dir (str): the output directory, this will write the split volumes to that directory
with the same basename as the input file, with the slice index appended
axis (int): the axis to split on
"""
dirname, basename, extension = split_image_path(input_file)
nifti = load_nifti(input_file)
data = nifti.get_data()
header = nifti.get_header()
for ind in range(data.shape[axis]):
index = [slice(None)] * len(data.shape)
index[axis] = ind
mdt.write_nifti(data[index],
'{}/{}_{}.nii'.format(output_dir, basename,
ind), header)
def _get_subject_output_dir(self, subject_id, mask_fname, subject_base_dir=None):
"""Helper function for generating the output directory for a subject.
Args:
subject_id (str): the id of the subject to use
mask_fname (str): the name of the mask we are using for this subject
subject_base_dir (str): the base directory for this subject, defaults to
self._root_dir / subject_id / self.output_base_dir
Returns:
str: the path for the output directory
"""
output_dir = subject_base_dir or os.path.join(self._root_dir, subject_id, self.output_base_dir)
if self.output_sub_dir:
output_dir = os.path.join(output_dir, self.output_sub_dir)
if self._append_mask_name_to_output_sub_dir and mask_fname:
output_dir = os.path.join(output_dir, split_image_path(mask_fname)[1])
return output_dir
def generate_mask(self):
args = (self.selectedImageText.text(),
self.selectedProtocolText.text(),
self.selectedOutputText.text())
kwargs = dict(median_radius=self.medianRadiusInput.value(),
numpass=self.numberOfPassesInput.value(),
mask_threshold=self.finalThresholdInput.value())
self._generate_mask_worker.set_args(*args, **kwargs)
self._computations_thread.start()
self._generate_mask_worker.moveToThread(self._computations_thread)
self._generate_mask_worker.starting.connect(
self._computations_thread.starting)
self._generate_mask_worker.starting.connect(
lambda: self.generateButton.setEnabled(False))
self._generate_mask_worker.finished.connect(
self._computations_thread.finished)
self._generate_mask_worker.finished.connect(
lambda: self.generateButton.setEnabled(True))
self._generate_mask_worker.finished.connect(
lambda: self.viewButton.setEnabled(True))
image_path = split_image_path(self.selectedOutputText.text())
script_basename = os.path.join(image_path[0], 'scripts',
'generate_mask_' + image_path[1])
if not os.path.isdir(os.path.join(image_path[0], 'scripts')):
os.makedirs(os.path.join(image_path[0], 'scripts'))
self._generate_mask_worker.finished.connect(
lambda: self._write_python_script_file(script_basename + '.py', *
args, **kwargs))
self._generate_mask_worker.finished.connect(
lambda: self._write_bash_script_file(script_basename + '.sh', *
args, **kwargs))
self._generate_mask_worker.starting.emit()
def get_name(img_path):
return split_image_path(os.path.basename(img_path))[1]
def _get_subjects(self):
pjoin = mdt.make_path_joiner(self._root_dir)
files = [os.path.basename(f) for f in glob.glob(pjoin('*'))]
basenames = sorted(list({split_image_path(f)[1] for f in files}))
subjects = []
protocol_options = ['TE', 'TR', 'Delta', 'delta', 'maxG']
default_mask = None
if list(glob.glob(pjoin('mask.nii*'))):
default_mask = list(glob.glob(pjoin('mask.nii*')))[0]
for basename in basenames:
dwi_fname = None
if basename + '.nii' in files:
dwi_fname = pjoin(basename + '.nii')
elif basename + '.nii.gz' in files:
dwi_fname = pjoin(basename + '.nii.gz')
elif basename + '.hdr' in files and basename + '.img' in files:
dwi_fname = pjoin(basename + '.hdr')
noise_std = self._autoload_noise_std(basename,
file_path=pjoin(basename +
'.noise_std'))
prtcl_fname = None
if basename + '.prtcl' in files:
prtcl_fname = pjoin(basename + '.prtcl')
bval_fname = None
if basename + '.bval' in files:
bval_fname = pjoin(basename + '.bval')
bvec_fname = None
if basename + '.bvec' in files:
bvec_fname = pjoin(basename + '.bvec')
mask_fname = default_mask
if basename + '_mask.nii' in files:
mask_fname = pjoin(basename + '_mask.nii')
elif basename + '_mask.nii.gz' in files:
mask_fname = pjoin(basename + '_mask.nii.gz')
extra_cols_from_file = {}
for option in protocol_options:
if basename + '.' + option in files:
extra_cols_from_file.update(
{option: pjoin(basename + '.' + option)})
if dwi_fname and (prtcl_fname or (bval_fname and bvec_fname)):
protocol_loader = BatchFitProtocolLoader(
pjoin(),
protocol_fname=prtcl_fname,
bvec_fname=bvec_fname,
bval_fname=bval_fname,
protocol_columns=extra_cols_from_file)
output_dir = self._get_subject_output_dir(
basename, mask_fname, pjoin(self.output_base_dir,
basename))
subjects.append(
SimpleSubjectInfo(basename,
dwi_fname,
protocol_loader,
mask_fname,
output_dir,
noise_std=noise_std))
return subjects
def mask_name(self):
return split_image_path(self.subject_info.get_mask_filename())[1]
def run_model(self):
model = mdt.get_model(self._get_current_model_name())()
if not model.is_input_data_sufficient(
self._input_data_info.build_input_data()):
msg = ProtocolWarningBox(
model.get_input_data_problems(
self._input_data_info.build_input_data()))
msg.exec_()
return
self._run_model_worker.set_args(
model,
self._input_data_info.build_input_data(),
self.selectedOutputFolder.text(),
recalculate=True,
double_precision=self._optim_options.double_precision,
only_recalculate_last=not self._optim_options.recalculate_all,
method=self._optim_options.method)
self._computations_thread.start()
self._run_model_worker.moveToThread(self._computations_thread)
self._run_model_worker.starting.connect(
self._computations_thread.starting)
self._run_model_worker.finished.connect(
self._computations_thread.finished)
self._run_model_worker.starting.connect(
lambda: self.runButton.setEnabled(False))
self._run_model_worker.finished.connect(
lambda: self.runButton.setEnabled(True))
self._run_model_worker.finished.connect(
lambda: self._shared_state.set_output_folder(
self._get_full_model_output_path()))
image_path = split_image_path(self._input_data_info.dwi)
script_basename = os.path.join(
image_path[0], 'scripts', 'fit_model_{}_{}'.format(
self._get_current_model_name().replace('|', '.'),
image_path[1]))
if not os.path.isdir(os.path.join(image_path[0], 'scripts')):
os.makedirs(os.path.join(image_path[0], 'scripts'))
script_info = dict(
optim_options=self._optim_options,
input_data_info=self._input_data_info,
model=self._get_current_model_name(),
output_folder=self.selectedOutputFolder.text(),
recalculate=True,
double_precision=self._optim_options.double_precision,
only_recalculate_last=not self._optim_options.recalculate_all)
self._run_model_worker.finished.connect(
lambda: self._write_python_script_file(script_basename + '.py', **
script_info))
self._run_model_worker.finished.connect(
lambda: self._write_bash_script_file(script_basename + '.sh', **
script_info))
self._run_model_worker.starting.emit()
def run(self, args, extra_args):
file_names = []
images = []
for file in args.input_files:
globbed = glob.glob(file)
if globbed:
for fname in globbed:
file_names.append(fname)
images.append(
mdt.load_nifti(os.path.realpath(fname)).get_data())
else:
file_names.append(file)
images.append(
mdt.load_nifti(os.path.realpath(file)).get_data())
if args.verbose:
print('')
if args.input_4d:
images = self._images_3d_to_4d(images)
context_dict = {'input': images, 'i': images, 'np': np, 'mdt': mdt}
alpha_chars = list('abcdefghjklmnopqrstuvwxyz')
for ind, image in enumerate(images):
context_dict.update({alpha_chars[ind]: image})
if args.verbose:
print('Input {ind} ({alpha}):'.format(ind=ind,
alpha=alpha_chars[ind]))
print(' name: {}'.format(
split_image_path(file_names[ind])[1]))
print(' shape: {}'.format(str(image.shape)))
if args.verbose:
print('')
print("Evaluating: '{expr}'".format(expr=args.expr))
if args.as_expression:
output = eval(args.expr, context_dict)
else:
expr = textwrap.dedent('''
def mdt_image_math():
{}
output = mdt_image_math()
''').format(args.expr)
exec(expr, context_dict)
output = context_dict['output']
if args.verbose:
print('')
if isinstance(output, np.ndarray):
print('Output shape: {shape}'.format(shape=str(output.shape)))
else:
print('Output is single value')
print('Output: ')
print('')
print(output)
else:
if not args.write_output:
print(output)
if args.verbose:
print('')
if args.write_output:
if isinstance(output, Sequence):
if args.output_file:
output_file = os.path.realpath(args.output_file)
dirname, basename, ext = split_image_path(output_file)
for ind, element in enumerate(output):
mdt.write_nifti(
element, dirname + basename + '_' + str(ind) + ext,
mdt.load_nifti(file_names[0]).header)
else:
for ind, element in enumerate(output):
output_file = os.path.realpath(file_names[ind])
mdt.write_nifti(element, output_file,
mdt.load_nifti(file_names[ind]).header)
else:
if args.output_file:
output_file = os.path.realpath(args.output_file)
else:
output_file = os.path.realpath(file_names[0])
mdt.write_nifti(output, output_file,
mdt.load_nifti(file_names[0]).header)
def run(self, args):
write_output = args.output_file is not None
if write_output:
output_file = os.path.realpath(args.output_file)
if os.path.isfile(output_file):
os.remove(output_file)
file_names = []
for file in args.input_files:
file_names.extend(glob.glob(file))
if args.verbose:
print('')
images = [mdt.load_nifti(dwi_image).get_data() for dwi_image in file_names]
if args.input_4d:
images = self._images_3d_to_4d(images)
context_dict = {'input': images, 'i': images, 'np': np, 'mdt': mdt}
alpha_chars = list('abcdefghjklmnopqrstuvwxyz')
for ind, image in enumerate(images):
context_dict.update({alpha_chars[ind]: image})
if args.verbose:
print('Input {ind} ({alpha}):'.format(ind=ind, alpha=alpha_chars[ind]))
print(' name: {}'.format(split_image_path(file_names[ind])[1]))
print(' shape: {}'.format(str(image.shape)))
if args.verbose:
print('')
print("Evaluating: '{expr}'".format(expr=args.expr))
if args.as_expression:
output = eval(args.expr, context_dict)
else:
expr = textwrap.dedent('''
def mdt_image_math():
{}
output = mdt_image_math()
''').format(args.expr)
exec(expr, context_dict)
output = context_dict['output']
if args.verbose:
print('')
if isinstance(output, np.ndarray):
print('Output shape: {shape}'.format(shape=str(output.shape)))
else:
print('Output is single value')
print('Output: ')
print('')
print(output)
else:
if not write_output:
print(output)
if args.verbose:
print('')
if write_output:
mdt.write_image(output_file, output, mdt.load_nifti(file_names[0]).get_header())
