def test_Atropos_outputs():
output_map = dict(posteriors=dict(),
classified_image=dict(),
)
outputs = Atropos.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_Atropos_outputs():
output_map = dict(classified_image=dict(),
posteriors=dict(),
)
outputs = Atropos.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 _run_interface(self, runtime):
inputnode = niu.IdentityInterface(
fields=['intensity_image', 'mask_image'])
inputnode.iterables = ('intensity_image', self.inputs.intensity_images)
intensity_nii_list = []
for f in self.inputs.intensity_images:
mult = Math()
mult.inputs.input_files = [f, self.inputs.mask_image]
mult.inputs.output_file = os.getcwd() + os.sep + os.path.basename(
os.path.splitext(f)[0]) + "_brain.mnc"
mult.inputs.calc_mul = True
mult.run()
intensity_mnc2nii_sh = mnc2nii_shCommand()
intensity_mnc2nii_sh.inputs.in_file = mult.inputs.output_file
intensity_mnc2nii_sh.run()
intensity_nii_list += [intensity_mnc2nii_sh.inputs.out_file]
mask_mnc2nii_sh = mnc2nii_shCommand()
mask_mnc2nii_sh.inputs.truncate_path = True
mask_mnc2nii_sh.inputs.in_file = self.inputs.mask_image
mask_mnc2nii_sh.run()
seg = Atropos()
seg.inputs.dimension = self.inputs.dimension
seg.inputs.intensity_images = intensity_nii_list
seg.inputs.mask_image = mask_mnc2nii_sh.inputs.out_file
seg.inputs.initialization = self.inputs.initialization
seg.inputs.prior_probability_images = self.inputs.prior_probability_images
seg.inputs.number_of_tissue_classes = self.inputs.number_of_tissue_classes
seg.inputs.prior_weighting = self.inputs.prior_weighting
seg.inputs.prior_probability_threshold = self.inputs.prior_probability_threshold
seg.inputs.likelihood_model = self.inputs.likelihood_model
seg.inputs.mrf_smoothing_factor = self.inputs.mrf_smoothing_factor
seg.inputs.mrf_radius = self.inputs.mrf_radius
seg.inputs.icm_use_synchronous_update = self.inputs.icm_use_synchronous_update
seg.inputs.maximum_number_of_icm_terations = self.inputs.maximum_number_of_icm_terations
seg.inputs.convergence_threshold = self.inputs.convergence_threshold
seg.inputs.posterior_formulation = self.inputs.posterior_formulation
seg.inputs.use_random_seed = self.inputs.use_random_seed
seg.inputs.use_mixture_model_proportions = self.inputs.use_mixture_model_proportions
seg.inputs.out_classified_image_name = self.inputs.out_classified_image_name
seg.inputs.save_posteriors = self.inputs.save_posteriors
seg.inputs.output_posteriors_name_template = self.inputs.output_posteriors_name_template
print(seg.cmdline)
seg.run()
seg.outputs = seg._list_outputs() #seg._outputs()
classified_nii2mnc_sh = nii2mnc2Command()
classified_nii2mnc_sh.inputs.in_file = seg.outputs["classified_image"]
classified_nii2mnc_sh.inputs.truncate_path = True
classified_nii2mnc_sh.run()
self.inputs.classified_image = classified_nii2mnc_sh.inputs.out_file
return (runtime)
def get_workflow(name, opts):
workflow = pe.Workflow(name=name)
in_fields = ['mri']
if opts.user_brainmask:
in_fields += ['brain_mask_space_stx']
if opts.user_mri_stx:
in_fields += ['tfm_mri_stx', 'tfm_stx_mri']
label_types = [opts.results_label_type]
label_imgs = [opts.results_label_img]
stages = ['results']
if opts.pvc_method != None:
stages += ['pvc']
label_imgs += [opts.pvc_label_img]
label_types += [opts.pvc_label_type]
if opts.quant_method != None:
stages += ['quant']
label_imgs += [opts.results_label_img]
label_types += [opts.results_label_type]
inputnode = pe.Node(niu.IdentityInterface(fields=in_fields),
name="inputnode")
out_fields = [
'tfm_stx_mri', 'tfm_mri_stx', 'brain_mask_space_stx',
'brain_mask_space_mri', 'mri_space_stx', 'mri_space_nat'
]
for stage, label_type in zip(stages, label_types):
if 'internal_cls' == label_type:
out_fields += [stage + '_label_img']
outputnode = pe.Node(niu.IdentityInterface(fields=out_fields),
name='outputnode')
##########################################
# T1 spatial (+ intensity) normalization #
##########################################
if opts.n4_bspline_fitting_distance != 0:
n4 = pe.Node(N4BiasFieldCorrection(), "mri_intensity_normalized")
workflow.connect(inputnode, 'mri', n4, 'input_image')
n4.inputs.dimension = 3
n4.inputs.bspline_fitting_distance = opts.n4_bspline_fitting_distance
n4.inputs.shrink_factor = opts.n4_shrink_factor
n4.inputs.n_iterations = opts.n4_n_iterations
n4.inputs.convergence_threshold = opts.n4_convergence_threshold
else:
n4 = pe.Node(niu.IdentityInterface(fields=["output_image"]),
name='mri_no_intensity_normalization')
workflow.connect(inputnode, 'mri', n4, 'output_image')
if opts.user_mri_stx == '':
mri2template = pe.Node(interface=APPIANRegistration(),
name="mri_spatial_normalized")
mri2template.inputs.moving_image_space = "T1w"
mri2template.inputs.fixed_image_space = "stx"
mri2template.inputs.fixed_image_mask = icbm_default_brain
mri2template.inputs.fixed_image = opts.template
workflow.connect(n4, 'output_image', mri2template, 'moving_image')
if opts.user_ants_command != None:
mri2template.inputs.user_ants_command = opts.user_ants_command
if opts.normalization_type:
mri2template.inputs.normalization_type = opts.normalization_type
mri_stx_file = 'warped_image'
mri_stx_node = mri2template
tfm_node = mri2template
tfm_inv_node = mri2template
if opts.normalization_type == 'nl':
tfm_file = 'composite_transform'
tfm_inv_file = 'inverse_composite_transform'
elif opts.normalization_type == 'affine' or opts.normalization_type == 'rigid':
tfm_file = 'out_matrix'
tfm_inv_file = 'out_matrix_inverse'
else:
print(
"Error: --normalization-type should be either rigid, lin, or nl"
)
exit(1)
else:
transform_mri = pe.Node(interface=APPIANApplyTransforms(),
name="transform_mri")
transform_mri.inputs.target_space = 't1'
workflow.connect(inputnode, 'mri', transform_mri, 'input_image')
workflow.connect(inputnode, 'tfm_mri_stx', transform_mri,
'transform_1')
transform_mri.inputs.reference_image = opts.template
mri_stx_node = transform_mri
mri_stx_file = 'output_image'
tfm_node = inputnode
tfm_file = 'tfm_mri_stx'
tfm_inv_node = inputnode
tfm_inv_file = 'tfm_stx_mri'
#
# T1 in native space will be part of the APPIAN target directory
# and hence it won't be necessary to link to the T1 in the source directory.
#
copy_mri_nat = pe.Node(interface=copyCommand(), name="mri_nat")
workflow.connect(inputnode, 'mri', copy_mri_nat, 'input_file')
###################################
# Segment T1 in Stereotaxic space #
###################################
seg = None
if opts.ants_atropos_priors == [] and opts.template == icbm_default_template:
opts.ants_atropos_priors = file_dir + os.sep + "/atlas/MNI152/mni_icbm152_%02d_tal_nlin_asym_09c.nii.gz"
if opts.ants_atropos_priors == []:
print(
"Warning : user did not provide alternative priors for template. This will affect your T1 MRI segmentation. Check this segmentation visually to make sure it is what you want "
)
for stage, label_type, img in zip(stages, label_types, label_imgs):
if seg == None:
seg = pe.Node(interface=Atropos(), name="segmentation_ants")
seg.inputs.dimension = 3
seg.inputs.number_of_tissue_classes = 3 #len(opts.ants_atropos_priors)
seg.inputs.initialization = 'PriorProbabilityImages'
seg.inputs.prior_weighting = opts.ants_atropos_prior_weighting
seg.inputs.prior_image = opts.ants_atropos_priors
seg.inputs.likelihood_model = 'Gaussian'
seg.inputs.posterior_formulation = 'Socrates'
seg.inputs.use_mixture_model_proportions = True
seg.inputs.args = "-v 1"
workflow.connect(mri_stx_node, mri_stx_file, seg,
'intensity_images')
seg.inputs.mask_image = icbm_default_brain
#workflow.connect(brain_mask_node, brain_mask_file, seg, 'mask_image' )
print(stage, img)
if 'antsAtropos' == img:
workflow.connect(seg, 'classified_image', outputnode,
stage + '_label_img')
####################
# T1 Brain masking #
####################
if not opts.user_brainmask:
# if opts.brain_extraction_method == 'beast':
# #Brain Mask MNI-Space
# mriMNI_brain_mask = pe.Node(interface=beast(), name="mri_stx_brain_mask")
# mriMNI_brain_mask.inputs.library_dir = library_dir
# mriMNI_brain_mask.inputs.template = library_dir+"/margin_mask.mnc"
# mriMNI_brain_mask.inputs.configuration = mriMNI_brain_mask.inputs.library_dir+os.sep+"default.2mm.conf"
# mriMNI_brain_mask.inputs.same_resolution = True
# mriMNI_brain_mask.inputs.median = True
# mriMNI_brain_mask.inputs.fill = True
# mriMNI_brain_mask.inputs.median = True
# workflow.connect(mri_stx_node, mri_stx_file, mriMNI_brain_mask, "in_file" )
# brain_mask_node = mriMNI_brain_mask
# brain_mask_file = 'out_file'
# else :
#mriMNI_brain_mask = pe.Node(interface=BrainExtraction(), name="mri_stx_brain_mask")
#mriMNI_brain_mask.inputs.dimension = 3
#mriMNI_brain_mask.inputs.brain_template = opts.template
#template_base, template_ext = splitext(opts.template)
#mriMNI_brain_mask.inputs.brain_probability_mask =template_base+'_variant-brain_pseg'+template_ext
mriMNI_brain_mask = pe.Node(interface=SegmentationToBrainMask(),
name="mri_stx_brain_mask")
#workflow.connect(mri_stx_node, mri_stx_file, mriMNI_brain_mask, "anatomical_image" )
workflow.connect(seg, 'classified_image', mriMNI_brain_mask,
"seg_file")
brain_mask_node = mriMNI_brain_mask
brain_mask_file = 'output_image'
else:
brain_mask_node = inputnode
brain_mask_file = 'brain_mask_space_stx'
#
# Transform brain mask from stereotaxic to T1 native space
#
transform_brain_mask = pe.Node(interface=APPIANApplyTransforms(),
name="transform_brain_mask")
transform_brain_mask.inputs.interpolation = 'NearestNeighbor'
transform_brain_mask.inputs.target_space = 't1'
workflow.connect(brain_mask_node, brain_mask_file, transform_brain_mask,
'input_image')
workflow.connect(tfm_node, tfm_inv_file, transform_brain_mask,
'transform_1')
workflow.connect(copy_mri_nat, 'output_file', transform_brain_mask,
'reference_image')
###############################
# Pass results to output node #
###############################
workflow.connect(brain_mask_node, brain_mask_file, outputnode,
'brain_mask_space_stx')
workflow.connect(tfm_node, tfm_file, outputnode, 'tfm_mri_stx')
workflow.connect(tfm_node, tfm_inv_file, outputnode, 'tfm_stx_mri')
workflow.connect(transform_brain_mask, 'output_image', outputnode,
'brain_mask_space_mri')
#workflow.connect(mri_stx_node, mri_stx_file, outputnode, 'mri_space_stx')
workflow.connect(copy_mri_nat, 'output_file', outputnode, 'mri_space_nat')
return (workflow)
def test_Atropos_inputs():
input_map = dict(icm_use_synchronous_update=dict(argstr='%s',
),
prior_probability_images=dict(),
intensity_images=dict(mandatory=True,
argstr='--intensity-image %s...',
),
prior_weighting=dict(),
out_classified_image_name=dict(hash_files=False,
genfile=True,
argstr='%s',
),
mrf_smoothing_factor=dict(argstr='%s',
),
convergence_threshold=dict(requires=['n_iterations'],
),
prior_probability_threshold=dict(requires=['prior_weighting'],
),
save_posteriors=dict(),
maximum_number_of_icm_terations=dict(requires=['icm_use_synchronous_update'],
),
use_mixture_model_proportions=dict(requires=['posterior_formulation'],
),
ignore_exception=dict(nohash=True,
usedefault=True,
),
mask_image=dict(mandatory=True,
argstr='--mask-image %s',
),
mrf_radius=dict(requires=['mrf_smoothing_factor'],
),
initialization=dict(mandatory=True,
requires=['number_of_tissue_classes'],
argstr='%s',
),
args=dict(argstr='%s',
),
likelihood_model=dict(argstr='--likelihood-model %s',
),
terminal_output=dict(mandatory=True,
nohash=True,
),
output_posteriors_name_template=dict(usedefault=True,
),
num_threads=dict(nohash=True,
usedefault=True,
),
number_of_tissue_classes=dict(mandatory=True,
),
n_iterations=dict(argstr='%s',
),
environ=dict(nohash=True,
usedefault=True,
),
posterior_formulation=dict(argstr='%s',
),
dimension=dict(usedefault=True,
argstr='--image-dimensionality %d',
),
)
inputs = Atropos.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_Atropos_inputs():
input_map = dict(args=dict(argstr='%s',
),
convergence_threshold=dict(requires=['n_iterations'],
),
dimension=dict(argstr='--image-dimensionality %d',
usedefault=True,
),
environ=dict(nohash=True,
usedefault=True,
),
icm_use_synchronous_update=dict(argstr='%s',
),
ignore_exception=dict(nohash=True,
usedefault=True,
),
initialization=dict(argstr='%s',
mandatory=True,
requires=['number_of_tissue_classes'],
),
intensity_images=dict(argstr='--intensity-image %s...',
mandatory=True,
),
likelihood_model=dict(argstr='--likelihood-model %s',
),
mask_image=dict(argstr='--mask-image %s',
mandatory=True,
),
maximum_number_of_icm_terations=dict(requires=['icm_use_synchronous_update'],
),
mrf_radius=dict(requires=['mrf_smoothing_factor'],
),
mrf_smoothing_factor=dict(argstr='%s',
),
n_iterations=dict(argstr='%s',
),
num_threads=dict(nohash=True,
usedefault=True,
),
number_of_tissue_classes=dict(mandatory=True,
),
out_classified_image_name=dict(argstr='%s',
genfile=True,
hash_files=False,
),
output_posteriors_name_template=dict(usedefault=True,
),
posterior_formulation=dict(argstr='%s',
),
prior_probability_images=dict(),
prior_probability_threshold=dict(requires=['prior_weighting'],
),
prior_weighting=dict(),
save_posteriors=dict(),
terminal_output=dict(mandatory=True,
nohash=True,
),
use_mixture_model_proportions=dict(requires=['posterior_formulation'],
),
)
inputs = Atropos.input_spec()
for key, metadata in input_map.items():
for metakey, value in metadata.items():
yield assert_equal, getattr(inputs.traits()[key], metakey), value
