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