def _spm_linear_coreg_pipeline(self, **name_maps): # @UnusedVariable
"""
Coregisters T2 image to T1 image using SPM's "Register" method.
NB: Default values come from the W2MHS toolbox
"""
pipeline = self.new_pipeline(
'linear_coreg',
name_maps=name_maps,
desc="Coregister T2-weighted images to T1",
citations=[spm_cite])
pipeline.add(
'mag_coreg',
Coregister(
jobtype='estwrite',
cost_function='nmi',
separation=[4, 2],
tolerance=[0.02, 0.02, 0.02, 0.001, 0.001, 0.001, 0.01, 0.01,
0.01, 0.001, 0.001, 0.001],
fwhm=[7, 7],
write_interp=4,
write_wrap=[0, 0, 0],
write_mask=False,
out_prefix='r'),
inputs={
'target': ('coreg_ref', nifti_format),
'source': ('mag_preproc', nifti_format)},
outputs={
'mag_coreg': ('coregistered_source', nifti_format)},
requirements=[spm_req.v(12)],
wall_time=30)
return pipeline
def test_Coregister_outputs():
output_map = dict(coregistered_files=dict(),
coregistered_source=dict(),
)
outputs = Coregister.output_spec()
for key, metadata in output_map.items():
for metakey, value in metadata.items():
yield assert_equal, getattr(outputs.traits()[key], metakey), value
def test_Coregister_outputs():
output_map = dict(
coregistered_files=dict(),
coregistered_source=dict(),
)
outputs = Coregister.output_spec()
for key, metadata in output_map.items():
for metakey, value in metadata.items():
yield assert_equal, getattr(outputs.traits()[key], metakey), value
def test_Coregister_inputs():
input_map = dict(ignore_exception=dict(nohash=True,
usedefault=True,
),
paths=dict(),
write_mask=dict(field='roptions.mask',
),
write_wrap=dict(field='roptions.wrap',
),
write_interp=dict(field='roptions.interp',
),
use_v8struct=dict(min_ver='8',
usedefault=True,
),
cost_function=dict(field='eoptions.cost_fun',
),
use_mcr=dict(),
out_prefix=dict(field='roptions.prefix',
usedefault=True,
),
source=dict(copyfile=True,
mandatory=True,
field='source',
),
mfile=dict(usedefault=True,
),
matlab_cmd=dict(),
tolerance=dict(field='eoptions.tol',
),
separation=dict(field='eoptions.sep',
),
apply_to_files=dict(copyfile=True,
field='other',
),
fwhm=dict(field='eoptions.fwhm',
),
jobtype=dict(usedefault=True,
),
target=dict(copyfile=False,
mandatory=True,
field='ref',
),
)
inputs = Coregister.input_spec()
for key, metadata in input_map.items():
for metakey, value in metadata.items():
yield assert_equal, getattr(inputs.traits()[key], metakey), value
def test_Coregister_inputs():
input_map = dict(
apply_to_files=dict(
copyfile=True,
field='other',
),
cost_function=dict(field='eoptions.cost_fun', ),
fwhm=dict(field='eoptions.fwhm', ),
ignore_exception=dict(
nohash=True,
usedefault=True,
),
jobtype=dict(usedefault=True, ),
matlab_cmd=dict(),
mfile=dict(usedefault=True, ),
out_prefix=dict(
field='roptions.prefix',
usedefault=True,
),
paths=dict(),
separation=dict(field='eoptions.sep', ),
source=dict(
copyfile=True,
field='source',
mandatory=True,
),
target=dict(
copyfile=False,
field='ref',
mandatory=True,
),
tolerance=dict(field='eoptions.tol', ),
use_mcr=dict(),
use_v8struct=dict(
min_ver='8',
usedefault=True,
),
write_interp=dict(field='roptions.interp', ),
write_mask=dict(field='roptions.mask', ),
write_wrap=dict(field='roptions.wrap', ),
)
inputs = Coregister.input_spec()
for key, metadata in input_map.items():
for metakey, value in metadata.items():
yield assert_equal, getattr(inputs.traits()[key], metakey), value
def _spm_coreg_pipeline(self, **kwargs): # @UnusedVariable
"""
Coregisters T2 image to T1 image using SPM's
"Register" method.
NB: Default values come from the W2MHS toolbox
"""
pipeline = self.create_pipeline(
name='registration',
inputs=[
DatasetSpec('t1', nifti_format),
DatasetSpec('t2', nifti_format)
],
outputs=[DatasetSpec('t2_coreg_t1', nifti_format)],
desc="Coregister T2-weighted images to T1",
version=1,
citations=[spm_cite],
**kwargs)
coreg = pipeline.create_node(Coregister(),
name='coreg',
requirements=[spm12_req],
wall_time=30)
coreg.inputs.jobtype = 'estwrite'
coreg.inputs.cost_function = 'nmi'
coreg.inputs.separation = [4, 2]
coreg.inputs.tolerance = [
0.02, 0.02, 0.02, 0.001, 0.001, 0.001, 0.01, 0.01, 0.01, 0.001,
0.001, 0.001
]
coreg.inputs.fwhm = [7, 7]
coreg.inputs.write_interp = 4
coreg.inputs.write_wrap = [0, 0, 0]
coreg.inputs.write_mask = False
coreg.inputs.out_prefix = 'r'
# Connect inputs
pipeline.connect_input('t1', coreg, 'target')
pipeline.connect_input('t2', coreg, 'source')
# Connect outputs
pipeline.connect_output('t2_coreg_t1', coreg, 'coregistered_source')
return pipeline
def genSpmNormalizeDwiWF(name='spmNormalizeDwi',
spm_standalone=None,
mcr=None):
# Setup for SPM standalone
matlab_cmd = ' '.join([spm_standalone, mcr, 'batch', 'script'])
spm.SPMCommand.set_mlab_paths(matlab_cmd=matlab_cmd, use_mcr=True)
# Generate WF
wf = Workflow(name=name)
# InputNode
inputNode = Node(IdentityInterface(
fields=['ref_T1', 'forward_deformation_field', 'ref_dwi', 'apply_to']),
name='inputNode')
# spm Coregister
coreg = Node(Coregister(), name='coreg')
coreg.inputs.use_mcr = True
coreg.inputs.mfile = False
coreg.inputs.cost_function = 'nmi'
coreg.inputs.jobtype = 'estimate'
wf.connect(inputNode, "ref_T1", coreg, "target")
wf.connect(inputNode, "ref_dwi", coreg, "source")
wf.connect(inputNode, "apply_to", coreg, "apply_to_files")
# spm Normalize12
# Node: spmWarpDtiMetricsToStandard
spmWarpToStd111 = Node(Normalize12(), name="spmWarpToStd111")
spmWarpToStd111.inputs.ignore_exception = False
spmWarpToStd111.inputs.jobtype = 'write'
spmWarpToStd111.inputs.use_v8struct = True
spmWarpToStd111.inputs.write_bounding_box = [[-90.0, -126.0, -72.0],
[90.0, 90.0, 108.0]]
spmWarpToStd111.inputs.write_interp = 3
spmWarpToStd111.inputs.use_mcr = True
spmWarpToStd111.inputs.mfile = False
spmWarpToStd111.inputs.write_voxel_sizes = [1.0, 1.0, 1.0]
wf.connect(inputNode, "forward_deformation_field", spmWarpToStd111,
"deformation_file")
wf.connect(coreg, "coregistered_files", spmWarpToStd111, "apply_to_files")
# Node: spmWarpB0ToStandard
spmWarpb0ToStd111 = Node(Normalize12(), name="spmWarpb0ToStd111")
spmWarpb0ToStd111.inputs.ignore_exception = False
spmWarpb0ToStd111.inputs.jobtype = 'write'
spmWarpb0ToStd111.inputs.use_v8struct = True
spmWarpb0ToStd111.inputs.write_bounding_box = [[-90.0, -126.0, -72.0],
[90.0, 90.0, 108.0]]
spmWarpb0ToStd111.inputs.write_interp = 3
spmWarpb0ToStd111.inputs.use_mcr = True
spmWarpb0ToStd111.inputs.mfile = False
spmWarpb0ToStd111.inputs.write_voxel_sizes = [1.0, 1.0, 1.0]
wf.connect(inputNode, "forward_deformation_field", spmWarpb0ToStd111,
"deformation_file")
wf.connect(coreg, "coregistered_source", spmWarpb0ToStd111,
"apply_to_files")
# OutputNode
outputNode = Node(
IdentityInterface(fields=["normalized_files", "normalized_b0"]),
name="outputNode")
wf.connect(spmWarpToStd111, "normalized_files", outputNode,
"normalized_files")
wf.connect(spmWarpb0ToStd111, "normalized_files", outputNode,
"normalized_b0")
return wf
def send_other_modalities_to_t1(self, source_modality, modalities = None, prefix = None, suffix = None):
"""Register other modalities than t1 (supposed to be in single subject space) to t1
Parameters
----------
source_modality: string, the name of the modality to be used as source for the registration (as it
appears in the "other_modalities" directory)
modalities: string or list of strings, the name(s) of the modality(ies) to be registered (as it appears
in the "other_modalities" directory). Note that if you want to only register the source modality you need to
specify once again it here.
prefix: string, part of the filename that appears before the conventional CAT12 prefix (e.g. a0, p1 etc.) to
be discarded when retrieving the subject name (e.g. a0my_prefix_SUBJECTNAME.nii)
suffix: string, part of the filename that appears after the conventional CAT12 prefix (e.g. a0, p1 etc.) to
be discarded when retrieving the subject name (e.g. a0SUBJECTNAME_my_suffix.nii)
"""
value_to_be_zeroed = [8,7]
source_modality_dir = "{}/other_modalities/{}".format(self.main_cat_dir, source_modality)
brain_parcels = sorted(glob("{}/a0*".format(self.main_cat_dir + "/mri")))
for el in brain_parcels:
if prefix == None and suffix == None:
subject = Path(el).stem.split("a0")[1]
elif not(prefix == None) and suffix == None:
subject = Path(el).stem.split("a0")[1].split(prefix)[1]
elif prefix == None and not(suffix == None):
subject = Path(el).stem.split("a0")[1].split(suffix)[0]
else:
subject = Path(el).stem.split("a0")[1].split(prefix)[1].split(suffix)[0]
source = check_for_multiple_match_ask_input("{}/*{}*".format(source_modality_dir, subject))
if source is None:
continue
if source_modality == modalities:
file_to_check = "{}/r{}".format(Path(source).parent,Path(source).stem)
if isfile(file_to_check):
continue
if modalities != source_modality:
images_to_align = []
for mod in modalities:
img_to_append = check_for_multiple_match_ask_input("{}/other_modalities/{}/*{}*".format(self.main_cat_dir, mod, subject))
images_to_align.append(img_to_append)
all_files_to_check = [source] + images_to_align
all_files_to_check = ["{}/r{}.nii".format(Path(el).parent,Path(el).stem) for el in all_files_to_check]
if all([isfile(el) for el in all_files_to_check]):
continue
if not isfile("{}/mri/t1_masked_{}.nii".format(self.main_cat_dir, subject)):
vol_parcel = nib.load(el)
t1 = check_for_multiple_match_ask_input("{}/*{}*.nii".format(self.main_cat_dir, subject))
t1 = load_img(t1)
brain_parcel_array = vol_parcel.get_data()
brain_parcel_array[np.isin(brain_parcel_array, value_to_be_zeroed)] = 0
brain_parcel_array[brain_parcel_array > 0] = 1
t1_array = t1.get_data()
masked_t1_array = t1_array * brain_parcel_array
masked_t1 = nib.Nifti1Image(masked_t1_array, t1.affine, header = t1.header)
masked_t1.to_filename("{}/mri/t1_masked_{}.nii".format(self.main_cat_dir, subject))
crg = Coregister()
crg.inputs.target = "{}/mri/t1_masked_{}.nii".format(self.main_cat_dir, subject)
crg.inputs.source = source
if modalities != source_modality:
crg.inputs.apply_to_files = images_to_align
crg.run()
