def _write_bash_script_file(self, script_fname, configuration_fname,
output_image_fname, width, height, dpi):
with open(script_fname, 'w') as f:
f.write('#!/usr/bin/env bash\n')
f.write(
dedent('''
{header}
mdt-view-maps \\
{paths} \\
--config "{config}" \\
--to-file "{output_name}" \\
--width {width} \\
--height {height} \\
--dpi {dpi}
''').format(header=get_script_file_header_text(
{'Purpose': 'Generate a results figure'}),
paths=' '.join([
'{el!r}'.format(el=el)
for el in self._get_file_paths()
]),
config=configuration_fname,
output_name=output_image_fname,
width=width,
height=height,
dpi=dpi))
def _write_python_script_file(self, script_fname, configuration_fname,
output_image_fname, width, height, dpi):
with open(script_fname, 'w') as f:
f.write('#!/usr/bin/env python\n')
f.write(
dedent('''
{header}
import mdt
with open({config!r}, 'r') as f:
config = f.read()
mdt.view_maps(
{paths},
config=config,
save_filename={output_name!r},
figure_options={{'width': {width}, 'height': {height}, 'dpi': {dpi}}})
''').format(header=get_script_file_header_text(
{'Purpose': 'Generate a results figure'}),
paths='[' + ', '.join([
'{el!r}'.format(el=el)
for el in self._get_file_paths()
]) + ']',
config=configuration_fname,
output_name=output_image_fname,
width=width,
height=height,
dpi=dpi))
def _write_bash_script_file(self, output_file, **kwargs):
with open(output_file, 'w') as f:
f.write('#!/usr/bin/env bash')
f.write(dedent('''
{header}
mdt-create-roi-slice "{mask}" -d {dimension} -s {slice} -o "{output}"
''').format(header=get_script_file_header_text({'Purpose': 'Generated a slice ROI mask'}),
**kwargs))
def _write_python_script_file(self, output_file, **kwargs):
input_data_info = kwargs['input_data_info']
optim_options = kwargs['optim_options']
all_cl_devices = get_cl_devices()
user_selected_devices = mot.configuration.get_cl_environments()
format_kwargs = dict(
header=get_script_file_header_text({'Purpose': 'Fitting a model'}),
dwi=input_data_info.dwi,
protocol=input_data_info.protocol,
mask=input_data_info.mask,
noise_std=input_data_info.noise_std,
gradient_deviations=input_data_info.gradient_deviations,
extra_protocol=input_data_info.extra_protocol,
model=kwargs['model'],
output_folder=kwargs['output_folder'],
recalculate=kwargs['recalculate'],
double_precision=kwargs['double_precision'],
cl_device_ind=[
ind for ind, device in enumerate(all_cl_devices)
if device in user_selected_devices
],
method=optim_options.method,
patience=optim_options.patience)
with open(output_file, 'w') as f:
f.write('#!/usr/bin/env python\n')
f.write(
dedent('''
{header}
import mdt
input_data = mdt.load_input_data(
{dwi!r},
{protocol!r},
{mask!r},
noise_std={noise_std!r},
gradient_deviations={gradient_deviations!r},
extra_protocol={extra_protocol!r})
mdt.fit_model(
{model!r},
input_data,
{output_folder!r},
recalculate={recalculate!r},
double_precision={double_precision!r},
cl_device_ind={cl_device_ind!r},
use_cascaded_inits=True,
method={method!r},
optimizer_options={{'patience': {patience!r}}})
''').format(**format_kwargs))
def _write_bash_script_file(self, output_file, *args, **kwargs):
input_data_info = kwargs['input_data_info']
optim_options = kwargs['optim_options']
all_cl_devices = get_cl_devices()
user_selected_devices = mot.configuration.get_cl_environments()
with open(output_file, 'w') as f:
f.write('#!/usr/bin/env bash\n')
f.write(
dedent('''
{header}
mdt-model-fit \\
"{model}" \\
"{dwi}" \\
"{protocol}" \\
"{mask}" ''').format(header=get_script_file_header_text(
{'Purpose': 'Fitting a model'}),
model=kwargs['model'],
dwi=input_data_info.dwi,
protocol=input_data_info.protocol,
mask=input_data_info.mask))
def write_new_line(line):
f.write('\\\n' + ' ' * 4 + line + ' ')
write_new_line('-o "{}"'.format(kwargs['output_folder']))
if input_data_info.gradient_deviations:
write_new_line('--gradient-deviations "{}"'.format(
input_data_info.gradient_deviations))
if input_data_info.noise_std:
write_new_line('--noise-std {}'.format(
input_data_info.noise_std))
write_new_line('--cl-device-ind {}'.format(' '.join(
str(ind) for ind, device in enumerate(all_cl_devices)
if device in user_selected_devices)))
write_new_line('--recalculate'
if kwargs['recalculate'] else '--no-recalculate')
write_new_line(
'--double' if kwargs['double_precision'] else '--float')
write_new_line('--method {}'.format(optim_options.method))
write_new_line('--patience {}'.format(optim_options.patience))
write_new_line('--use-cascaded-inits')
if input_data_info.extra_protocol:
write_new_line('--extra-protocol {}'.format(' '.join(
'{}="{}"'.format(key, value)
for key, value in input_data_info.extra_protocol.items())))
def _write_bash_script_file(self, output_file, *args, **kwargs):
with open(output_file, 'w') as f:
f.write('#!/usr/bin/env bash')
f.write(
dedent('''
{header}
mdt-create-mask "{data}" "{prtcl}" -o "{output}" {kwargs}
''').format(header=get_script_file_header_text(
{'Purpose': 'Generated a brain mask'}),
data=args[0],
prtcl=args[1],
output=args[2],
kwargs=' '.join(
'--{} {!r}'.format(el[0].replace('_', '-'), el[1])
for el in kwargs.items())))
def _write_python_script_file(self, output_file, **kwargs):
with open(output_file, 'w') as f:
f.write('#!/usr/bin/env python')
f.write(dedent('''
{header}
import mdt
mdt.write_slice_roi(
{mask!r},
{dimension!r},
{slice!r},
{output!r},
overwrite_if_exists=True)
''').format(header=get_script_file_header_text({'Purpose': 'Generated a slice ROI mask'}),
**kwargs))
def _write_python_script_file(self, output_file, *args, **kwargs):
with open(output_file, 'w') as f:
f.write('#!/usr/bin/env python')
f.write(
dedent('''
{header}
import mdt
mdt.create_median_otsu_brain_mask(
{args},
{kwargs})
''').format(header=get_script_file_header_text(
{'Purpose': 'Generated a brain mask'}),
args=', \n\t'.join("{!r}".format(arg) for arg in args),
kwargs=', \n\t'.join('{}={!r}'.format(*el)
for el in kwargs.items())))
def _write_bash_script_file(self, output_file, *args, **kwargs):
input_data_info = kwargs['input_data_info']
optim_options = kwargs['optim_options']
all_cl_devices = CLEnvironmentFactory.smart_device_selection()
user_selected_devices = mot.configuration.get_cl_environments()
with open(output_file, 'w') as f:
f.write('#!/usr/bin/env bash\n')
f.write(
dedent('''
{header}
mdt-model-fit \\
"{model}" \\
"{dwi}" \\
"{protocol}" \\
"{mask}" ''').format(header=get_script_file_header_text(
{'Purpose': 'Fitting a model'}),
model=kwargs['model'],
dwi=input_data_info.dwi,
protocol=input_data_info.protocol,
mask=input_data_info.mask))
def write_new_line(line):
f.write('\\\n' + ' ' * 4 + line + ' ')
write_new_line('-o "{}"'.format(kwargs['output_folder']))
if input_data_info.gradient_deviations:
write_new_line('--gradient-deviations "{}"'.format(
input_data_info.gradient_deviations))
if input_data_info.noise_std:
write_new_line('--noise-std {}'.format(
input_data_info.noise_std))
write_new_line('--cl-device-ind {}'.format(' '.join(
str(ind) for ind, device in enumerate(all_cl_devices)
if device in user_selected_devices)))
write_new_line('--recalculate'
if kwargs['recalculate'] else '--no-recalculate')
write_new_line(
'--only-recalculate-last'
if kwargs['only_recalculate_last'] else '--recalculate-all')
write_new_line(
'--double' if kwargs['double_precision'] else '--float')
if input_data_info.extra_protocol:
write_new_line('--extra-protocol {}'.format(' '.join(
'{}="{}"'.format(key, value)
for key, value in input_data_info.extra_protocol.items())))
if not optim_options.use_model_default_optimizer:
config = '''
optimization:
general:
name: {}
settings:
patience: {}
'''.format(optim_options.method, optim_options.patience)
config_context = yaml.safe_dump(
yaml.safe_load(config), default_flow_style=True).rstrip()
write_new_line('--config-context "{}"'.format(config_context))
def _write_python_script_file(self, output_file, **kwargs):
input_data_info = kwargs['input_data_info']
optim_options = kwargs['optim_options']
all_cl_devices = CLEnvironmentFactory.smart_device_selection()
user_selected_devices = mot.configuration.get_cl_environments()
format_kwargs = dict(
header=get_script_file_header_text({'Purpose': 'Fitting a model'}),
dwi=input_data_info.dwi,
protocol=input_data_info.protocol,
mask=input_data_info.mask,
noise_std=input_data_info.noise_std,
gradient_deviations=input_data_info.gradient_deviations,
extra_protocol=input_data_info.extra_protocol,
model=kwargs['model'],
output_folder=kwargs['output_folder'],
recalculate=kwargs['recalculate'],
only_recalculate_last=kwargs['only_recalculate_last'],
double_precision=kwargs['double_precision'],
cl_device_ind=[
ind for ind, device in enumerate(all_cl_devices)
if device in user_selected_devices
])
with open(output_file, 'w') as f:
f.write('#!/usr/bin/env python\n')
if optim_options.use_model_default_optimizer:
f.write(
dedent('''
{header}
import mdt
input_data = mdt.load_input_data(
{dwi!r},
{protocol!r},
{mask!r},
noise_std={noise_std!r},
gradient_deviations={gradient_deviations!r},
extra_protocol={extra_protocol!r})
mdt.fit_model(
{model!r},
input_data,
{output_folder!r},
recalculate={recalculate!r},
only_recalculate_last={only_recalculate_last!r},
double_precision={double_precision!r},
cl_device_ind={cl_device_ind!r})
''').format(**format_kwargs))
else:
format_kwargs.update({
'method': optim_options.method,
'patience': optim_options.patience
})
f.write(
dedent('''
{header}
import mdt
from mdt.configuration import SetGeneralOptimizer
input_data = mdt.load_input_data(
{dwi!r},
{protocol!r},
{mask!r},
noise_std={noise_std!r},
gradient_deviations={gradient_deviations!r},
extra_protocol={extra_protocol!r})
with mdt.config_context(SetGeneralOptimizer({method!r}, settings={{'patience': {patience!r}}})):
mdt.fit_model(
{model!r},
input_data,
{output_folder!r},
recalculate={recalculate!r},
only_recalculate_last={only_recalculate_last!r},
double_precision={double_precision!r},
cl_device_ind={cl_device_ind!r})
''').format(**format_kwargs))
