def _run_interface(self, runtime): if not isdefined(self.inputs.out_file): self.inputs.out_file = self._gen_output(self.inputs.in_file) nii2mncNode = nii2mnc() nii2mncNode.inputs.in_file = self.inputs.in_file nii2mncNode.inputs.out_file = os.getcwd() + os.sep + str( np.random.randint(0, 9999999)) + ".mnc" nii2mncNode.run() rsl1 = minc.Resample() rsl1.inputs.input_file = nii2mncNode.inputs.out_file rsl1.inputs.output_file = os.getcwd() + os.sep + str( np.random.randint(0, 9999999)) + ".mnc" rsl1.inputs.like = self.inputs.template print(rsl1.cmdline) rsl1.run() beast = mincbeastCommand() beast.inputs.out_file = os.getcwd() + os.sep + "beast_mask_" + str( np.random.randint(0, 9999999)) + ".mnc" beast.inputs.in_file = rsl1.inputs.output_file beast.inputs.library_dir = self.inputs.library_dir beast.inputs.voxel_size = self.inputs.voxel_size beast.inputs.same_resolution = self.inputs.same_resolution beast.inputs.median = self.inputs.median beast.inputs.fill = self.inputs.fill beast.inputs.configuration = self.inputs.configuration beast.run() rsl2 = minc.Resample() rsl2.inputs.input_file = beast.inputs.out_file rsl2.inputs.like = self.inputs.nii2mncNode.inputs.out_file rsl2.inputs.nearest_neighbour_interpolation = True print(rsl2.cmdline) rsl2.run() mnc2niiNode = mnc2nii() mnc2niiNode.inputs.in_file = rsl2.inputs.output_file mnc2niiNode.inputs.out_file = self.inputs.out_file mnc2niiNode.run() print(resample.cmdline) resample.run() return runtime
def create_alt_template(template, beast_dir, clobber=False): template_rsl = os.path.splitext(template)[0] + '_rsl.mnc' mask = os.path.splitext(template)[0] + '_mask.mnc' mask_rsl_fn = os.path.splitext(template)[0] + '_rsl_mask.mnc' for f in glob.glob(beast_dir + os.sep + "*mnc"): if not os.path.exists(template_rsl) or clobber: rsl = minc.Resample() rsl.inputs.input_file = template rsl.inputs.output_file = template_rsl rsl.inputs.like = f print rsl.cmdline rsl.run() if not os.path.exists(mask_rsl_fn) or clobber: mask_rsl = minc.Resample() mask_rsl.inputs.input_file = mask mask_rsl.inputs.output_file = mask_rsl_fn mask_rsl.inputs.like = f mask_rsl.run() print(mask_rsl.cmdline) break return template_rsl
def ecattomincWorkflow(name): workflow = pe.Workflow(name=name) #Define input node that will receive input from outside of workflow inputNode = pe.Node(niu.IdentityInterface(fields=["in_file", "header"]), name='inputNode') conversionNode = pe.Node(interface=ecattomincCommand(), name="conversionNode") mincConversionNode = pe.Node(interface=mincconvertCommand(), name="mincConversionNode") fixHeaderNode = pe.Node(interface=FixHeaderCommand(), name="fixHeaderNode") paramNode = pe.Node(interface=param2xfmCommand(), name="param2xfmNode") paramNode.inputs.rotation = "0 180 0" resampleNode = pe.Node(interface=minc.Resample(), name="resampleNode") resampleNode.inputs.vio_transform=True outputNode = pe.Node(niu.IdentityInterface(fields=["out_file"]), name='outputNode') workflow.connect(inputNode, 'in_file', conversionNode, 'in_file') workflow.connect(conversionNode, 'out_file', fixHeaderNode, 'in_file') workflow.connect(inputNode, 'header', fixHeaderNode, 'header') workflow.connect(fixHeaderNode, 'out_file', outputNode, 'out_file') return(workflow)
def get_workflow(name, infosource, opts): ''' Create workflow to perform PET to T1 co-registration. 1. PET to T1 coregistration with brain masks 2. PET to T1 coregistration without brain masks (OPTIONAL) 3. Transform T1 MRI brainmask and headmask from MNI 152 to T1 native 4. Resample 4d PET image to T1 space 5. Resample 4d PET image to MNI 152 space :param name: Name for workflow :param infosource: Infosource for basic variables like subject id (sid) and condition id (cid) :param datasink: Node in which output data is sent :param opts: User options :returns: workflow ''' workflow = pe.Workflow(name=name) #Define input node that will receive input from outside of workflow inputnode = pe.Node(niu.IdentityInterface(fields=["pet_volume","pet_volume_4d","nativeT1nuc","t1_headMask","tka_label_img_t1","results_label_img_t1","pvc_label_img_t1", "t1_brain_mask", "xfmT1MNI", "T1Tal", "error", "header" ]), name='inputnode') #Define empty node for output outputnode = pe.Node(niu.IdentityInterface(fields=["petmri_img", "petmri_img_4d","petmni_img_4d","petmri_xfm","mripet_xfm",'petmni_xfm', 'mnipet_xfm' ]), name='outputnode') node_name="pet_brainmask" petMasking = pe.Node(interface=PETheadMasking(), name=node_name) petMasking.inputs.slice_factor = opts.slice_factor petMasking.inputs.total_factor = opts.total_factor workflow.connect(inputnode, 'pet_volume', petMasking, 'in_file') workflow.connect(inputnode, 'header', petMasking, 'in_json') #node_name="pet2mri_withMask" #pet2mri_withMask = pe.Node(interface=PETtoT1LinRegRunning(), name=node_name) #pet2mri_withMask.inputs.clobber = True #pet2mri_withMask.inputs.verbose = opts.verbose #pet2mri_withMask.inputs.lsq="lsq6" #if opts.no_mask : node_name="pet2mri" pet2mri = pe.Node(interface=PETtoT1LinRegRunning(), name=node_name) pet2mri.inputs.clobber = True pet2mri.inputs.verbose = opts.verbose pet2mri.inputs.lsq="lsq6" pet2mri.inputs.metric="mi" #else : #pet2mri = pet2mri_withMask final_pet2mri = pet2mri if isdefined(inputnode.inputs.error) : final_pet2mri.inputs.error = error node_name="t1_brain_mask_pet-space" pet_brain_mask = pe.Node(interface=minc.Resample(), name=node_name) pet_brain_mask.inputs.nearest_neighbour_interpolation = True pet_brain_mask.inputs.clobber = True pet_brain_mask_img = 'output_file' workflow.connect([(inputnode, pet_brain_mask, [('t1_brain_mask', 'input_file' )]), (inputnode, pet_brain_mask, [('pet_volume', 'like')]), (pet2mri, pet_brain_mask, [('out_file_xfm_invert', 'transformation')]) ]) if opts.calculate_t1_pet_space : t1_pet_space = pe.Node(interface=minc.Resample(), name="t1_pet_space") t1_pet_space.inputs.clobber = True workflow.connect([(inputnode, t1_pet_space, [('nativeT1nuc', 'input_file' )]), (inputnode, t1_pet_space, [('pet_volume', 'like')]), (pet2mri, t1_pet_space, [('out_file_xfm_invert', 'transformation')]) ]) #if opts.no_mask : workflow.connect([(inputnode, pet2mri, [('pet_volume', 'in_source_file')]), (inputnode, pet2mri, [('nativeT1nuc', 'in_target_file')])#, #(petMasking, pet2mri, [('out_file', 'in_source_mask')]), #(inputnode, pet2mri, [('pet_volume', 'init_file_xfm')]) #(pet2mri_withMask, pet2mri, [('out_file_xfm', 'init_file_xfm')]) ]) #workflow.connect([(inputnode, pet2mri_withMask, [('pet_volume', 'in_source_file')]), #(petMasking, pet2mri_withMask, [('out_file', 'in_source_mask')]), #(inputnode, pet2mri_withMask, [('nativeT1nuc', 'in_target_file')]) #]) #if opts.coregistration_brain_mask : #workflow.connect(inputnode, 't1_brain_mask', pet2mri_withMask, 'in_target_mask') #workflow.connect(inputnode, 't1_brain_mask', pet2mri, 'in_target_mask') if opts.test_group_qc : ###Create rotation xfm files based on transform error transformNode = pe.Node(interface=rsl.param2xfmInterfaceCommand(), name='transformNode') workflow.connect(inputnode, 'error', transformNode, 'transformation') ### Concatenate pet2mri and misalignment xfm pet2misalign_xfm=pe.Node(interface=ConcatCommand(), name="pet2misalign_xfm") workflow.connect(pet2mri,'out_file_xfm', pet2misalign_xfm, 'in_file') workflow.connect(transformNode,'out_file', pet2misalign_xfm, 'in_file_2') ###Apply transformation to PET file transform_resampleNode=pe.Node(interface=rsl.ResampleCommand(),name="transform_resampleNode") transform_resampleNode.inputs.use_input_sampling=True; workflow.connect(transformNode, 'out_file', transform_resampleNode, 'transformation') workflow.connect(pet2mri, 'out_file_img', transform_resampleNode, 'in_file') #workflow.connect(pet2misalign_xfm, 'out_file', transform_resampleNode, 'transformation') ###Rotate brain mask transform_brainmaskNode=pe.Node(interface=rsl.ResampleCommand(), name="transform_brainmaskNode" ) transform_brainmaskNode.inputs.interpolation='nearest_neighbour' workflow.connect(pet2misalign_xfm, 'out_file', transform_brainmaskNode, 'transformation') workflow.connect(transform_resampleNode, 'out_file', transform_brainmaskNode, 'model_file') workflow.connect(pet_brain_mask, pet_brain_mask_img, transform_brainmaskNode, 'in_file') invert_concat_pet2misalign_xfm=pe.Node(interface=minc.XfmInvert(),name="invert_concat_pet2misalign_xfm") workflow.connect(pet2misalign_xfm,'out_file',invert_concat_pet2misalign_xfm,'input_file') pet2mri = final_pet2mri = pe.Node(interface=niu.IdentityInterface(fields=["out_file_img", "out_file_xfm", "out_file_xfm_invert"]), name="pet2mri_misaligned") workflow.connect(transform_resampleNode, "out_file", final_pet2mri, "out_file_img") workflow.connect(pet2misalign_xfm, "out_file", final_pet2mri, "out_file_xfm") workflow.connect(invert_concat_pet2misalign_xfm, "output_file", final_pet2mri, "out_file_xfm_invert") pet_brain_mask = transform_brainmaskNode pet_brain_mask_img = 'out_file' #Resample 4d PET image to T1 space pettot1_4d = pe.Node(interface=minc.Resample(), name='pettot1_4d') pettot1_4d.inputs.output_file='pet_space-t1_4d.mnc' workflow.connect(inputnode, 'pet_volume_4d', pettot1_4d, 'input_file') workflow.connect(pet2mri, 'out_file_xfm', pettot1_4d, 'transformation') workflow.connect(inputnode, 'nativeT1nuc', pettot1_4d, 'like') #Resample 4d PET image to MNI space PETMNIXfm_node = pe.Node( interface=ConcatCommand(), name="PETMNIXfm_node") workflow.connect(pet2mri, "out_file_xfm", PETMNIXfm_node, "in_file") workflow.connect(inputnode, "xfmT1MNI", PETMNIXfm_node, "in_file_2") MNIPETXfm_node = pe.Node(interface=minc.XfmInvert(), name="MNIPETXfm_node") workflow.connect( PETMNIXfm_node, "out_file", MNIPETXfm_node, 'input_file' ) t1tomni_4d = pe.Node(interface=minc.Resample(), name='t1tomni_4d') workflow.connect(pettot1_4d, 'output_file', t1tomni_4d, 'input_file') workflow.connect(inputnode, "xfmT1MNI", t1tomni_4d, 'transformation') workflow.connect(inputnode, 'T1Tal', t1tomni_4d, 'like') workflow.connect(PETMNIXfm_node, 'out_file', outputnode, 'petmni_xfm' ) workflow.connect(MNIPETXfm_node, 'output_file', outputnode, 'mnipet_xfm' ) workflow.connect(pettot1_4d,'output_file', outputnode, 'petmri_img_4d') workflow.connect(t1tomni_4d,'output_file', outputnode, 'petmni_img_4d') workflow.connect(final_pet2mri, 'out_file_xfm', outputnode, 'petmri_xfm') workflow.connect(final_pet2mri, 'out_file_xfm_invert', outputnode, 'mripet_xfm') workflow.connect(final_pet2mri, 'out_file_img', outputnode, 'petmri_img') workflow.connect(pet_brain_mask, pet_brain_mask_img, outputnode,'pet_brain_mask' ) return workflow
def _run_interface(self, runtime): #tmpDir = tempfile.mkdtemp() tmpDir = os.getcwd() + os.sep + 'tmp_nLinReg' os.mkdir(tmpDir) source = self.inputs.in_source_file target = self.inputs.in_target_file s_base = basename(os.path.splitext(source)[0]) t_base = basename(os.path.splitext(target)[0]) if not isdefined(self.inputs.out_file_xfm): self.inputs.out_file_xfm = fname_presuffix(os.getcwd()+os.sep+s_base+"_TO_"+t_base, suffix=self._suffix+'xfm', use_ext=False) if not isdefined(self.inputs.out_file_img): self.inputs.out_file_img = fname_presuffix(os.getcwd()+os.sep+s_base+"_TO_"+t_base, suffix=self._suffix) prev_xfm = None if self.inputs.init_file_xfm: prev_xfm = self.inputs.init_file_xfm if self.inputs.normalize: inorm_target = tmpDir+"/"+t_base+"_inorm.mnc" inorm_source = tmpDir+"/"+s_base+"_inorm.mnc" run_resample = minc.Resample(); run_resample.inputs.in_file=target run_resample.inputs.out_file=inorm_target run_resample.inputs.like=source if self.inputs.verbose: print run_resample.cmdline if self.inputs.run: run_resample.run() run_inormalize = InormalizeCommand(); run_inormalize.inputs.in_file=source run_inormalize.inputs.out_file=inorm_source run_inormalize.inputs.model_file=inorm_target if self.inputs.verbose: print run_inormalize.cmdline if self.inputs.run: run_inormalize.run() else: inorm_target = target inorm_source = source class tracc_args: def __init__(self, nonlinear, weight, stiffness, similarity, sub_lattice): # self.debug=debug self.nonlinear=nonlinear self.weight=weight self.stiffness=stiffness self.similarity=similarity self.sub_lattice=sub_lattice class conf: def __init__(self, step, blur_fwhm, iterations, lattice_diam): self.step=step self.blur_fwhm=blur_fwhm self.iterations=iterations self.lattice_diam=lattice_diam conf1 = conf(32,16,20,96) conf2 = conf(16,8,20,48) conf3 = conf(12,6,20,36) conf4 = conf(8,4,20,24) conf5 = conf(6,3,20,18) conf6 = conf(4,2,10,12) conf_list = [ conf1, conf2, conf3, conf4, conf5, conf6 ] nonlin_tracc_args = tracc_args('corrcoeff',1.0,1,0.3,6) i=1 for confi in conf_list: tmp_source=tmpDir+"/"+s_base+"_fwhm.mnc" tmp_source_blur_base=tmpDir+"/"+s_base+"_fwhm"+str(confi.blur_fwhm) tmp_source_blur=tmpDir+"/"+s_base+"_fwhm"+str(confi.blur_fwhm)+"_blur.mnc" tmp_target=tmpDir+"/"+t_base+"_fwhm.mnc" tmp_target_blur_base=tmpDir+"/"+t_base+"_fwhm"+str(confi.blur_fwhm) tmp_target_blur=tmpDir+"/"+t_base+"_fwhm"+str(confi.blur_fwhm)+"_blur.mnc" tmp_xfm = tmpDir+"/"+t_base+"_conf"+str(i)+".xfm"; tmp_rspl_vol = tmpDir+"/"+s_base+"_conf"+str(i)+".mnc"; print '-------+------- iteration'+str(i)+' -------+-------' print ' | steps : \t\t'+ str(confi.step) print ' | blur_fwhm : \t\t'+ str(confi.blur_fwhm) print ' | nonlinear : \t\t'+ str(nonlin_tracc_args.nonlinear) print ' | weight : \t\t'+ str(nonlin_tracc_args.weight) print ' | stiffness : \t\t'+ str(nonlin_tracc_args.stiffness) print ' | similarity : \t\t'+ str(nonlin_tracc_args.similarity) print ' | sub_lattice : \t\t'+ str(nonlin_tracc_args.sub_lattice) print ' | source : \t\t'+ tmp_source_blur print ' | target : \t\t'+ tmp_target_blur print ' | xfm : \t\t\t'+ tmp_xfm print ' | out : \t\t\t'+ tmp_rspl_vol print '\n' if self.inputs.in_source_mask and self.inputs.in_target_mask: if os.path.isfile(self.inputs.in_source_mask) and not os.path.exists(tmpDir+"/"+s_base+"_masked.mnc"): source = tmpDir+"/"+s_base+"_masked.mnc" run_calc = minc.Calc(); run_calc.inputs.input_files = [inorm_source, self.inputs.in_source_mask] run_calc.inputs.output_file = source run_calc.inputs.expression='A[1] > 0.5 ? A[0] : A[1]' if self.inputs.verbose: print run_calc.cmdline if self.inputs.run: run_calc.run() if os.path.isfile(self.inputs.in_target_mask) and not os.path.exists(tmpDir+"/"+t_base+"_masked.mnc"): target = tmpDir+"/"+t_base+"_masked.mnc" run_calc.inputs.in_file = [inorm_target, self.inputs.in_target_mask] run_calc.inputs.out_file = target run_calc.inputs.expression='A[1] > 0.5 ? A[0] : A[1]' if self.inputs.verbose: print run_calc.cmdline if self.inputs.run: run_calc.run() else: source = inorm_source target = inorm_target run_smooth = minc.Blur(); run_smooth.inputs.input_file=target run_smooth.inputs.fwhm=confi.blur_fwhm run_smooth.inputs.output_file_base=tmp_target_blur_base if self.inputs.verbose: print run_smooth.cmdline if self.inputs.run: run_smooth.run() run_smooth = minc.Blur(); run_smooth.inputs.input_file=source run_smooth.inputs.fwhm=confi.blur_fwhm run_smooth.inputs.output_file_base=tmp_source_blur_base if self.inputs.verbose: print run_smooth.cmdline if self.inputs.run: run_smooth.run() run_tracc = TraccCommand(); run_tracc.inputs.in_source_file=tmp_source_blur run_tracc.inputs.in_target_file=tmp_target_blur run_tracc.inputs.steps=str(confi.step)+' '+str(confi.step)+' '+str(confi.step) run_tracc.inputs.iterations=confi.iterations run_tracc.inputs.nonlinear=nonlin_tracc_args.nonlinear run_tracc.inputs.weight=nonlin_tracc_args.weight run_tracc.inputs.stiffness=nonlin_tracc_args.stiffness run_tracc.inputs.similarity=nonlin_tracc_args.similarity run_tracc.inputs.sub_lattice=nonlin_tracc_args.sub_lattice run_tracc.inputs.lattice=str(confi.lattice_diam)+' '+str(confi.lattice_diam)+' '+str(confi.lattice_diam) if i == len(conf_list): run_tracc.inputs.out_file_xfm=self.inputs.out_file_xfm else : run_tracc.inputs.out_file_xfm=tmp_xfm print "\nOutput of minctracc:" + run_tracc.inputs.out_file_xfm + "\n" if i == 1: run_tracc.inputs.identity=True if prev_xfm: run_tracc.inputs.transformation=prev_xfm if self.inputs.in_source_mask: run_tracc.inputs.in_source_mask=self.inputs.in_source_mask if self.inputs.in_target_mask: run_tracc.inputs.in_target_mask=self.inputs.in_target_mask if self.inputs.verbose: print run_tracc.cmdline run_tracc.run() if i == len(conf_list): prev_xfm = self.inputs.out_file_xfm else : prev_xfm = tmp_xfm run_resample = minc.Resample(); run_resample.inputs.input_file=source run_resample.inputs.output_file=tmp_rspl_vol run_resample.inputs.like=target run_resample.inputs.transformation=run_tracc.inputs.out_file_xfm if self.inputs.verbose: print run_resample.cmdline if self.inputs.run: run_resample.run() i += 1 if isdefined(self.inputs.init_file_xfm): run_concat = minc.XfmConcat(); run_concat.inputs.input_files=[ self.inputs.init_xfm, prev_xfm ] run_concat.inputs.output_file=self.inputs.out_file_xfm if self.inputs.verbose: print run_concat.cmdline if self.inputs.run: run_concat.run() # else: # if self.inputs.verbose: # cmd=' '.join(['cp', prev_xfm, self.inputs.out_file_xfm]) # print(cmd) # if self.inputs.run: # shutil.copy(prev_xfm, self.inputs.out_file_xfm) print '\n-+- creating '+self.inputs.out_file_img+' using '+self.inputs.out_file_xfm+' -+-\n' run_resample = minc.Resample(); run_resample.inputs.input_file=self.inputs.in_source_file run_resample.inputs.output_file=self.inputs.out_file_img run_resample.inputs.like=self.inputs.in_target_file run_resample.inputs.transformation=self.inputs.out_file_xfm if self.inputs.verbose: print run_resample.cmdline if self.inputs.run: run_resample.run() #shutil.rmtree(tmpDir) return runtime
def _run_interface(self, runtime): #tmpDir = tempfile.mkdtemp() tmpDir = os.getcwd() + os.sep + 'tmp_PETtoT1LinRegRunning' #tempfile.mkdtemp() os.mkdir(tmpDir) source = self.inputs.in_source_file target = self.inputs.in_target_file s_base = basename(os.path.splitext(source)[0]) t_base = basename(os.path.splitext(target)[0]) if not isdefined(self.inputs.out_file_xfm): self.inputs.out_file_xfm = os.getcwd()+os.sep+s_base+self._suffix+'.xfm' if not isdefined(self.inputs.out_file_xfm_invert): self.inputs.out_file_xfm_invert = os.getcwd()+os.sep+t_base+self._suffix+'.xfm' if not isdefined(self.inputs.out_file_img): self.inputs.out_file_img = os.getcwd()+os.sep+s_base+self._suffix+ '.mnc' #print("\n\n\n") #print( self.inputs.out_file_img ) #print("\n\n\n") #exit(0) prev_xfm = None if self.inputs.init_file_xfm: prev_xfm = self.inputs.init_file_xfm source = self.inputs.in_source_file target = self.inputs.in_target_file s_base = basename(os.path.splitext(source)[0]) t_base = basename(os.path.splitext(target)[0]) if self.inputs.in_source_mask and self.inputs.in_target_mask: if os.path.isfile(self.inputs.in_source_mask): source = tmpDir+"/"+s_base+"_masked.mnc" #run_calc = CalcCommand(); run_calc = minc.Calc(); #MIC run_calc.inputs.in_file = [self.inputs.in_source_file, self.inputs.in_source_mask] run_calc.inputs.input_files = [self.inputs.in_source_file, self.inputs.in_source_mask] #MIC run_calc.inputs.out_file = source run_calc.inputs.output_file = source print 'Source Mask:', source # run_calc.inputs.expression='if(A[1]>0.5){out=A[0];}else{out=A[1];}' run_calc.inputs.expression='A[1] > 0.5 ? A[0] : A[1]' if self.inputs.verbose: print run_calc.cmdline if self.inputs.run: run_calc.run() if os.path.isfile(self.inputs.in_target_mask): target = tmpDir+"/"+t_base+"_masked.mnc" run_calc.inputs.input_files = [self.inputs.in_target_file, self.inputs.in_target_mask] #run_calc.inputs.out_file = target run_calc.inputs.output_file = target print 'Target Mask:', target run_calc.inputs.expression='A[1] > 0.5 ? A[0] : A[1]' if self.inputs.verbose: print run_calc.cmdline if self.inputs.run: run_calc.run() class conf: def __init__(self, type_, est, blur_fwhm_target, blur_fwhm_source, steps, tolerance, simplex, lsq, blur_gradient): self.type_=type_ self.est=est self.blur_fwhm_target=blur_fwhm_target self.blur_fwhm_source=blur_fwhm_source self.steps=steps self.tolerance=tolerance self.simplex=simplex self.lsq=lsq self.blur_gradient=blur_gradient if isdefined( self.inputs.lsq ) : lsq0=self.inputs.lsq lsq1=self.inputs.lsq lsq2=self.inputs.lsq lsq3=self.inputs.lsq lsq4=self.inputs.lsq else : lsq0="lsq6" lsq1="lsq6" lsq2="lsq7" lsq3="lsq9" lsq4="lsq12" #conf1 = conf("blur", "-est_translations", 10, 6, "8 8 8", 0.01, 8, lsq1) #conf2 = conf("blur", "", 6, 6, "4 4 4", 0.004, 6, lsq2) #conf3 = conf("blur", "", 4, 4, "2 2 2", 0.002, 4, lsq3) conf0 = conf("blur", "-est_translations", 16, 16, "8 8 8", 0.01, 32, lsq0, False) conf1 = conf("blur", "", 8, 8, "4 4 4", 0.004, 16, lsq1, False) conf2 = conf("blur", "", 4, 4, "4 4 4", 0.004, 8, lsq2, False) conf3 = conf("blur", "", 4, 4, "4 4 4", 0.004, 4, lsq3, True) conf4 = conf("blur", "", 2, 2, "2 2 2", 0.004, 2, lsq4, True) #conf_list = [ conf0 ] #, conf1, conf2, conf3, conf4 ] conf_list = [ conf0, conf1, conf2, conf3, conf4 ] i=1 for confi in conf_list: tmp_source=tmpDir+"/"+s_base+"_fwhm"+str(confi.blur_fwhm_source) tmp_source_blur_base=tmpDir+"/"+s_base+"_fwhm"+str(confi.blur_fwhm_source) tmp_source_blur=tmpDir+"/"+s_base+"_fwhm"+str(confi.blur_fwhm_source)+"_"+confi.type_+".mnc" tmp_target=tmpDir+"/"+t_base+"_fwhm"+str(confi.blur_fwhm_target) tmp_target_blur_base=tmpDir+"/"+t_base+"_fwhm"+str(confi.blur_fwhm_target) tmp_target_blur=tmpDir+"/"+t_base+"_fwhm"+str(confi.blur_fwhm_target)+"_"+confi.type_+".mnc" tmp_xfm = tmpDir+"/"+t_base+"_conf"+str(i)+".xfm"; tmp_rspl_vol = tmpDir+"/"+s_base+"_conf"+str(i)+".mnc"; print '-------+------- iteration'+str(i)+' -------+-------' print ' | steps : \t\t'+ confi.steps print ' | lsq : \t\t'+ confi.lsq print ' | blur_fwhm_mri : \t'+ str(confi.blur_fwhm_target) print ' | blur_fwhm_pet : \t'+ str(confi.blur_fwhm_source) print ' | simplex : \t\t'+ str(confi.simplex) print ' | source : \t\t'+ tmp_source_blur print ' | target : \t\t'+ tmp_target_blur print ' | xfm : \t\t\t'+ tmp_xfm print ' | out : \t\t\t'+ tmp_rspl_vol print '\n' run_smooth = minc.Blur(); run_smooth.inputs.input_file=target run_smooth.inputs.fwhm=confi.blur_fwhm_target run_smooth.inputs.output_file_base=tmp_target_blur_base if confi.blur_gradient : run_smooth.inputs.gradient=True print run_smooth.cmdline run_smooth.run() run_smooth = minc.Blur(); run_smooth.inputs.input_file=source run_smooth.inputs.fwhm=confi.blur_fwhm_source run_smooth.inputs.output_file_base=tmp_source_blur_base if confi.blur_gradient : run_smooth.inputs.gradient=True run_smooth.inputs.no_apodize=True print run_smooth.cmdline run_smooth.run() run_tracc = TraccCommand(); run_tracc.inputs.in_source_file=tmp_source_blur run_tracc.inputs.in_target_file=tmp_target_blur run_tracc.inputs.out_file_xfm=tmp_xfm run_tracc.inputs.objective_func=self.inputs.metric run_tracc.inputs.steps=confi.steps run_tracc.inputs.simplex=confi.simplex run_tracc.inputs.tolerance=confi.tolerance run_tracc.inputs.est=confi.est run_tracc.inputs.lsq=confi.lsq if prev_xfm: run_tracc.inputs.transformation=prev_xfm if self.inputs.in_source_mask: run_tracc.inputs.in_source_mask=self.inputs.in_source_mask if self.inputs.in_target_mask: run_tracc.inputs.in_target_mask=self.inputs.in_target_mask print run_tracc.cmdline if self.inputs.run: run_tracc.run() run_resample = minc.Resample(); run_resample.inputs.input_file=source run_resample.inputs.output_file=tmp_rspl_vol run_resample.inputs.like=target run_resample.inputs.transformation=tmp_xfm if self.inputs.verbose: print run_resample.cmdline if self.inputs.run: run_resample.run() prev_xfm = tmp_xfm i += 1 print '\n' #No need for this because the final xfm file includes the initial one if isdefined(self.inputs.error): ###Create rotation xfm files based on transform error transformNode = pe.Node(interface=rsl.param2xfmInterfaceCommand(), name='transformNode') transformNode.inputs.error = self.inputs.error ### run_concat = minc.ConcatCommand(); run_concat.inputs.in_file=transformNode.inputs.output_file run_concat.inputs.in_file_2=tmp_xfm run_concat.inputs.out_file=self.inputs.out_file_xfm print run_concat.cmdline run_concat.run() tmp_xfm = self.inputs.out_file_xfm misregister_pet = minc.Resample(); misregister_pet.inputs.input_file=self.inputs.out_file_img #misregister_pet.inputs.output_file=tmpDir+os.sep+"temp_pet_4d_misaligned.mnc" misregister_pet.inputs.use_input_sampling=True misregister_pet.inputs.transformation=self.inputs.out_file_xfm shutil.copy(self.inputs.output_file, self.inputs.out_file_img) else : cmd=' '.join(['cp', tmp_xfm, self.inputs.out_file_xfm]) print(cmd) shutil.copy(tmp_xfm, self.inputs.out_file_xfm) #Invert transformation run_xfmpetinvert = minc.XfmInvert(); run_xfmpetinvert.inputs.input_file = self.inputs.out_file_xfm run_xfmpetinvert.inputs.output_file = self.inputs.out_file_xfm_invert if self.inputs.verbose: print run_xfmpetinvert.cmdline if self.inputs.run: run_xfmpetinvert.run() #if self.inputs.out_file_img: print '\n-+- Resample 3d PET image -+-\n' run_resample = minc.Resample(); run_resample.inputs.input_file=self.inputs.in_source_file run_resample.inputs.output_file=self.inputs.out_file_img run_resample.inputs.like=self.inputs.in_target_file run_resample.inputs.transformation=self.inputs.out_file_xfm print '\n\n', self.inputs.out_file_xfm print self.inputs.out_file_xfm_invert print self.inputs.out_file_img, '\n\n' if self.inputs.verbose: print run_resample.cmdline if self.inputs.run: run_resample.run() #shutil.rmtree(tmpDir) return runtime
def get_workflow(name, infosource, opts): ''' Create workflow to perform PET to T1 co-registration. 1. PET to T1 coregistration with brain masks 2. Transform T1 MRI brainmask and headmask from MNI 152 to T1 native :param name: Name for workflow :param infosource: Infosource for basic variables like subject id (sid) and condition id (cid) :param datasink: Node in which output data is sent :param opts: User options :returns: workflow ''' workflow = pe.Workflow(name=name) #bnDefine input node that will receive input from outside of workflow inputnode = pe.Node(niu.IdentityInterface(fields=[ "pet_volume", "pet_volume_4d", "nativeT1nuc", "t1_headMask", "tka_label_img_t1", "results_label_img_t1", "pvc_label_img_t1", "t1_brain_mask", "xfmT1MNI", "T1Tal", "error", "header" ]), name='inputnode') #Define empty node for output outputnode = pe.Node(niu.IdentityInterface(fields=[ "petmri_img", "pet_img_4d", "petmri_xfm", "mripet_xfm", 'petmni_xfm', 'mnipet_xfm' ]), name='outputnode') node_name = "pet_brainmask" petMasking = pe.Node(interface=PETheadMasking(), name=node_name) petMasking.inputs.slice_factor = opts.slice_factor petMasking.inputs.total_factor = opts.total_factor workflow.connect(inputnode, 'pet_volume', petMasking, 'in_file') workflow.connect(inputnode, 'header', petMasking, 'in_json') node_name = "pet2mri" pet2mri = pe.Node(interface=PETtoT1LinRegRunning(), name=node_name) pet2mri.inputs.clobber = True pet2mri.inputs.verbose = opts.verbose pet2mri.inputs.lsq = "lsq6" pet2mri.inputs.metric = "mi" workflow.connect([ (inputnode, pet2mri, [('pet_volume', 'in_source_file')]), (inputnode, pet2mri, [('nativeT1nuc', 'in_target_file')]) #, ]) if opts.test_group_qc: misalign_pet(workflow, inputnode, pet2mri) PETMNIXfm_node = pe.Node(interface=ConcatCommand(), name="PETMNIXfm_node") workflow.connect(pet2mri, "out_file_xfm", PETMNIXfm_node, "in_file") workflow.connect(inputnode, "xfmT1MNI", PETMNIXfm_node, "in_file_2") MNIPETXfm_node = pe.Node(interface=minc.XfmInvert(), name="MNIPETXfm_node") workflow.connect(PETMNIXfm_node, "out_file", MNIPETXfm_node, 'input_file') workflow.connect(PETMNIXfm_node, 'out_file', outputnode, 'petmni_xfm') workflow.connect(MNIPETXfm_node, 'output_file', outputnode, 'mnipet_xfm') #Resample 4d PET image to T1 space if opts.analysis_space == 't1': pettot1_4d = pe.Node(interface=minc.Resample(), name='pet_t1_4d') pettot1_4d.inputs.keep_real_range = True workflow.connect(inputnode, 'pet_volume_4d', pettot1_4d, 'input_file') workflow.connect(pet2mri, 'out_file_xfm', pettot1_4d, 'transformation') workflow.connect(inputnode, 'nativeT1nuc', pettot1_4d, 'like') workflow.connect(pettot1_4d, 'output_file', outputnode, 'pet_img_4d') workflow.connect(inputnode, 'nativeT1nuc', outputnode, 't1_analysis_space') elif opts.analysis_space == "stereo": #Resample 4d PET image to MNI space pettomni_4d = pe.Node(interface=minc.Resample(), name='pet_mni_4d') pettomni_4d.inputs.keep_real_range = True workflow.connect(inputnode, 'pet_volume_4d', pettomni_4d, 'input_file') workflow.connect(PETMNIXfm_node, "out_file", pettomni_4d, 'transformation') workflow.connect(inputnode, 'T1Tal', pettomni_4d, 'like') workflow.connect(pettomni_4d, 'output_file', outputnode, 'pet_img_4d') workflow.connect(pet2mri, 'out_file_xfm', outputnode, 'petmri_xfm') workflow.connect(pet2mri, 'out_file_xfm_invert', outputnode, 'mripet_xfm') workflow.connect(pet2mri, 'out_file_img', outputnode, 'petmri_img') return workflow
def get_workflow(name, valid_args, opts): workflow = pe.Workflow(name=name) in_fields = ['t1'] if opts.user_brainmask: in_fields += ['brain_mask_mni'] if opts.user_t1mni: in_fields += ['xfmT1MNI'] print("In Fields:", in_fields) label_types = [ opts.tka_label_type, opts.pvc_label_type, opts.results_label_type ] stages = ['tka', 'pvc', 'results'] label_imgs = [ opts.tka_label_img[0], opts.results_label_img[0], opts.pvc_label_img[0] ] inputnode = pe.Node(niu.IdentityInterface(fields=in_fields), name="inputnode") out_fields = [ 'xfmT1MNI', 'xfmT1MNI_invert', 'brain_mask_mni', 'brain_mask_t1', 't1_mni' ] for stage, label_type in zip(stages, label_types): print(stage, label_type) if 'internal_cls' == label_type: out_fields += [stage + '_label_img'] print(stage + '_label_img') outputnode = pe.Node(niu.IdentityInterface(fields=out_fields), name='outputnode') if not opts.user_brainmask: if opts.beast_library_dir == None: library_dir = mincbeast_library(opts.template) else: library_dir = opts.beast_library_dir template_rsl = create_alt_template(opts.template, library_dir) #if not opts.user_brainmask : # #Template Brain Mask # template_brain_mask = pe.Node(interface=mincbeastCommand(), name="template_brain_mask") # template_brain_mask.inputs.library_dir = mincbeast_library(opts.template) # template_brain_mask.inputs.configuration = template_brain_mask.inputs.library_dir+os.sep+"default.2mm.conf" # template_brain_mask.inputs.in_file = opts.template # template_brain_mask.inputs.same_resolution = True # template_brain_mask.inputs.voxel_size = 2 # brain_mask_file = "out_file" #else : # template_brain_mask = inputnode # brain_mask_file = "brain_mask_mni" if not opts.user_t1mni: if opts.coreg_method == 'ants': mri2template = pe.Node(interface=mincANTSCommand( args='--float', collapse_output_transforms=True, fixed_image=opts.template, initial_moving_transform_com=True, num_threads=1, output_inverse_warped_image=True, output_warped_image=True, sigma_units=['vox'] * 3, transforms=['Rigid', 'Affine', 'SyN'], terminal_output='file', winsorize_lower_quantile=0.005, winsorize_upper_quantile=0.995, convergence_threshold=[1e-08, 1e-08, -0.01], convergence_window_size=[20, 20, 5], metric=['Mattes', 'Mattes', ['Mattes', 'CC']], metric_weight=[1.0, 1.0, [0.5, 0.5]], number_of_iterations=[[10000, 11110, 11110], [10000, 11110, 11110], [100, 30, 20]], radius_or_number_of_bins=[32, 32, [32, 4]], sampling_percentage=[0.3, 0.3, [None, None]], sampling_strategy=['Regular', 'Regular', [None, None]], shrink_factors=[[3, 2, 1], [3, 2, 1], [4, 2, 1]], smoothing_sigmas=[[4.0, 2.0, 1.0], [4.0, 2.0, 1.0], [1.0, 0.5, 0.0]], transform_parameters=[(0.1, ), (0.1, ), (0.2, 3.0, 0.0)], use_estimate_learning_rate_once=[True] * 3, use_histogram_matching=[False, False, True], write_composite_transform=True), name="mincANTS_registration") mri2template.inputs.write_composite_transform = True #mri2template.inputs.interpolation="" workflow.connect(inputnode, 't1', mri2template, 'moving_image') #workflow.connect(template_brain_mask, brain_mask_file, mri2template, 'fixed_image_mask') t1_mni_file = 'warped_image' t1_mni_node = mri2template tfm_node = mri2template tfm_file = 'composite_transform' else: #mri2template = pe.Node(interface=PETtoT1LinRegRunning(), name="minctracc_registration") #mri2template = pe.Node(interface=beast_normalize(), name="minctracc_registration") mri2template = pe.Node(interface=beast_normalize_with_conversion(), name="mri_normalize") #mri2template.inputs.clobber = True #mri2template.inputs.verbose = opts.verbose template_name = os.path.splitext(os.path.basename(template_rsl))[0] template_dir = os.path.dirname(opts.template) #mri2template.inputs.in_target_file = opts.template mri2template.inputs.modelname = template_name mri2template.inputs.modeldir = template_dir #workflow.connect(inputnode, 't1', mri2template, 'in_source_file') workflow.connect(inputnode, 't1', mri2template, 'in_file') #workflow.connect(template_brain_mask, brain_mask_file, mri2template, 'in_target_mask') t1_mni_file = 'out_file_vol' t1_mni_node = mri2template tfm_node = mri2template tfm_file = 'out_file_xfm' else: transform_t1 = pe.Node(interface=minc.Resample(), name="transform_t1") transform_t1.inputs.two = True workflow.connect(inputnode, 't1', transform_t1, 'input_file') workflow.connect(inputnode, 'xfmT1MNI', transform_t1, 'transformation') transform_t1.inputs.like = opts.template t1_mni_node = transform_t1 t1_mni_file = 'output_file' tfm_node = inputnode tfm_file = 'xfmT1MNI' if not opts.user_brainmask: #Brain Mask MNI-Space t1MNI_brain_mask = pe.Node(interface=mincbeast(), name="t1_mni_brain_mask") t1MNI_brain_mask.inputs.library_dir = library_dir t1MNI_brain_mask.inputs.configuration = t1MNI_brain_mask.inputs.library_dir + os.sep + "default.2mm.conf" t1MNI_brain_mask.inputs.same_resolution = True t1MNI_brain_mask.inputs.median = True t1MNI_brain_mask.inputs.fill = True workflow.connect(t1_mni_node, t1_mni_file, t1MNI_brain_mask, "in_file") brain_mask_node = t1MNI_brain_mask brain_mask_file = 'out_file' else: brain_mask_node = inputnode brain_mask_file = 'brain_mask_mni' transform_brain_mask = pe.Node(interface=minc.Resample(), name="transform_brain_mask") transform_brain_mask.inputs.nearest_neighbour_interpolation = True transform_brain_mask.inputs.invert_transformation = True workflow.connect(brain_mask_node, brain_mask_file, transform_brain_mask, 'input_file') workflow.connect(inputnode, 't1', transform_brain_mask, 'like') workflow.connect(tfm_node, tfm_file, transform_brain_mask, 'transformation') seg = None for stage, label_type, img in zip(stages, label_types, label_imgs): if 'antsAtropos' == img and seg == None: seg = pe.Node(interface=mincAtroposCommand(), name="segmentation_ants") seg.inputs.dimension = 3 seg.inputs.number_of_tissue_classes = 3 #... opts. seg.inputs.initialization = 'Otsu' workflow.connect(t1_mni_node, t1_mni_file, seg, 'intensity_images') #workflow.connect(inputnode,'t1' , seg, 'intensity_images' ) #workflow.connect(transform_brain_mask, 'output_file', seg, 'mask_image' ) workflow.connect(brain_mask_node, brain_mask_file, seg, 'mask_image') if 'antsAtropos' == img: workflow.connect(seg, 'classified_image', outputnode, stage + '_label_img') workflow.connect(brain_mask_node, brain_mask_file, outputnode, 'brain_mask_mni') workflow.connect(tfm_node, tfm_file, outputnode, 'xfmT1MNI') workflow.connect(transform_brain_mask, 'output_file', outputnode, 'brain_mask_t1') workflow.connect(t1_mni_node, t1_mni_file, outputnode, 't1_mni') return (workflow)
def _run_interface(self, runtime): self.inputs.out_file = self._gen_output( self.inputs.label_img, self._suffix + self.inputs.analysis_space) tmpDir = os.getcwd() + os.sep + 'tmp_label' #tempfile.mkdtemp() os.mkdir(tmpDir) out_file_1 = temp_mask = tmpDir + "/mask.mnc" temp_mask_clean = tmpDir + "/mask_clean.mnc" # 1) Select Labels run_calc = minc.Calc( ) #Extract the desired label from the atlas using minccalc. run_calc.inputs.input_files = self.inputs.label_img #The ANIMAL or CIVET classified atlas run_calc.inputs.output_file = temp_mask #Output mask with desired label run_calc.inputs.expression = " || ".join([ '(A[0] > ' + str(label) + '-0.1 && A[0] < ' + str(label) + '+ 0.1 )' for label in self.inputs.labels ]) + ' ? A[0] : 0' run_calc.run() print("Select Labels:\n", run_calc.cmdline) # 2) Erode if int(self.inputs.erode_times) > 0: run_mincmorph = MorphCommand() run_mincmorph.inputs.in_file = temp_mask run_mincmorph.inputs.out_file = temp_mask_clean run_mincmorph.inputs.successive = 'E' * self.inputs.erode_times run_mincmorph.run() out_file_1 = temp_mask_clean out_file_1 = self.inputs.out_file # 3) Co-registration if self.inputs.space == "stereo" and self.inputs.label_type == "atlas-template": if self.inputs.nLinAtlasMNIXfm == '': sourceToModel_xfm = os.getcwd() + os.sep + 'template2mni.xfm' run_nlinreg = reg.nLinRegRunning() run_nlinreg.inputs.in_source_file = self.inputs.label_template run_nlinreg.inputs.in_target_file = self.inputs.mniT1 run_nlinreg.inputs.out_file_xfm = sourceToModel_xfm # xfm file for the transformation from template to subject stereotaxic run_nlinreg.run() mni2target = minc.XfmConcat() mni2target.inputs.input_file_1 = sourceToModel_xfm mni2target.inputs.input_file_2 = self.inputs.mni2target mni2target.run() self.inputs.nLinAtlasMNIXfm = mni2target.inputs.output_file else: sourceToModel_xfm = self.inputs.nLinAtlasMNIXfm else: xfm = self.inputs.LinXfm # 4) Apply transformation like_file = self.inputs.like_file base = splitext(out_file_1) out_file_2 = base[0] + self.inputs.analysis_space + base[1] run_resample = minc.Resample() run_resample.inputs.input_file = self.inputs.label_img run_resample.inputs.output_file = out_file_2 run_resample.inputs.like = like_file run_resample.inputs.transformation = xfm run_resample.inputs.nearest_neighbour_interpolation = True run_resample.run() #if self.inputs.space == "stereo" and self.inputs.label_type == "atlas-template": # 5) Resample 'other' atlas into T1 native space # run_resample = minc.Resample() # run_resample.inputs.input_file = out_file_2 # run_resample.inputs.output_file = self.inputs.LabelsT1 # run_resample.inputs.like = self.inputs.nativeT1 # run_resample.inputs.transformation = self.inputs.LinMNIT1Xfm # run_resample.inputs.nearest_neighbour_interpolation = True # print run_resample.cmdline # run_resample.run() label = run_resample.inputs.output_file #Copy to output shutil.copy(label, self.inputs.out_file) #self.inputs.out_file = run_resample.inputs.output_file # 6) Mask brain for T1 and MNI labels if self.inputs.brain_only: temp_mask = tmpDir + "/mask.mnc" run_calc = minc.Calc( ) #Extract the desired label from the atlas using minccalc. run_calc.inputs.input_files = [label, self.inputs.brainmask] run_calc.inputs.output_file = temp_mask #Output mask with desired label run_calc.inputs.expression = " A[1] == 1 ? A[0] : 0 " run_calc.clobber = True run_calc.run() #shutil.copy(temp_mask, label) shutil.copy(temp_mask, self.inputs.out_file) label = self.inputs.out_file print "Warning: masking labeled image with brain mask." print "Label: ", label if self.inputs.ones_only: temp_mask = tmpDir + "/mask.mnc" run_calc = minc.Calc( ) #Extract the desired label from the atlas using minccalc. run_calc.inputs.input_files = [ label ] #The ANIMAL or CIVET classified atlas run_calc.inputs.output_file = temp_mask #Output mask with desired label run_calc.inputs.expression = " A[0] > 0.1 ? 1 : 0 " run_calc.clobber = True run_calc.run() #shutil.copy(temp_mask, label) shutil.copy(temp_mask, self.inputs.out_file) return runtime
def get_workflow(name, infosource, opts): ''' Create workflow to produce labeled images. 1. Invert T1 Native to MNI 152 transformation 2. Transform 4. Transform brainmask from MNI 152 to T1 native 5. Create PVC labeled image 6. Create quantification labeled image 7. Create results labeled image :param name: Name for workflow :param infosource: Infosource for basic variables like subject id (sid) and condition id (cid) :param datasink: Node in which output data is sent :param opts: User options :returns: workflow ''' workflow = pe.Workflow(name=name) out_list = [ "pet_brainmask", "brain_mask", "results_label_img_t1", "results_label_img_mni" ] in_list = [ "nativeT1", "mniT1", "brainmask", "pet_header_json", "pet_volume", "results_labels", "results_label_template", "results_label_img", 'LinT1MNIXfm', "LinPETMNIXfm", "LinMNIPETXfm", "LinT1PETXfm", "LinPETT1Xfm" ] if not opts.nopvc: out_list += ["pvc_label_img_t1", "pvc_label_img_mni"] in_list += [ "pvc_labels", "pvc_label_space", "pvc_label_img", "pvc_label_template" ] if not opts.tka_method == None: out_list += ["tka_label_img_t1", "tka_label_img_mni"] in_list += [ "tka_labels", "tka_label_space", "tka_label_template", "tka_label_img" ] #Define input node that will receive input from outside of workflow inputnode = pe.Node(niu.IdentityInterface(fields=in_list), name='inputnode') outputnode = pe.Node(niu.IdentityInterface(fields=out_list), name='outputnode') #Define empty node for output MNIT1 = pe.Node(interface=minc.XfmInvert(), name="MNIT1") workflow.connect(inputnode, 'LinT1MNIXfm', MNIT1, 'input_file') MNIPET = pe.Node(interface=minc.XfmInvert(), name="MNIPET") workflow.connect(inputnode, 'LinPETMNIXfm', MNIPET, 'input_file') if not opts.nopvc and not opts.pvc_method == None: pvc_tfm_node, pvc_tfm_file, pvc_tfm_to, pvc_target_file = get_transforms_for_stage( MNIT1, MNIPET, inputnode, opts.pvc_label_space, opts.analysis_space) if not opts.tka_method == None: tka_tfm_node, tka_tfm_file, tka_tfm_to, tka_target_file = get_transforms_for_stage( MNIT1, MNIPET, inputnode, opts.tka_label_space, opts.analysis_space) results_tfm_node, results_tfm_file, results_tfm_to, results_target_file = get_transforms_for_stage( MNIT1, MNIPET, inputnode, opts.results_label_space, opts.analysis_space) brain_mask_tfm_node, brain_mask_tfm_file, brain_mask_tfm_to, brain_mask_target_file = get_transforms_for_stage( MNIT1, MNIPET, inputnode, 'stereo', 'pet') ################### # Brain Mask Node # ################### if opts.analysis_space != "stereo": brain_mask_node = pe.Node(minc.Resample(), "brain_mask_node") brain_mask_node.inputs.nearest_neighbour_interpolation = True #brain_mask_node.inputs.output_file="brain_mask_space-"+opts.analysis_space+".mnc" workflow.connect(inputnode, "brainmask", brain_mask_node, "input_file") if opts.analysis_space == "t1": workflow.connect(MNIT1, "output_file", brain_mask_node, "transformation") like_file = "nativeT1" workflow.connect(inputnode, "nativeT1", brain_mask_node, "like") elif opts.analysis_space == "pet": workflow.connect(MNIPET, "output_file", brain_mask_node, "transformation") workflow.connect(inputnode, "pet_volume", brain_mask_node, "like") like_file = "pet_volume" else: print("Error: Analysis space must be one of pet,stereo,t1 but is", opts.analysis_space) exit(1) else: brain_mask_node = pe.Node( niu.IdentityInterface(fields=["output_file"]), "brain_mask") workflow.connect(inputnode, "brainmask", brain_mask_node, "output_file") like_file = "mniT1" resultsLabels = pe.Node(interface=Labels(), name="resultsLabels") resultsLabels.inputs.analysis_space = opts.analysis_space resultsLabels.inputs.label_type = opts.results_label_type resultsLabels.inputs.space = opts.results_label_space resultsLabels.inputs.erode_times = opts.results_erode_times resultsLabels.inputs.brain_only = opts.results_labels_brain_only resultsLabels.inputs.ones_only = opts.results_labels_ones_only workflow.connect(inputnode, 'results_labels', resultsLabels, 'labels') workflow.connect(inputnode, 'results_label_img', resultsLabels, 'label_img') workflow.connect(inputnode, 'results_label_template', resultsLabels, 'label_template') workflow.connect(inputnode, like_file, resultsLabels, 'like_file') workflow.connect(brain_mask_node, "output_file", resultsLabels, 'brainmask') workflow.connect(results_tfm_node, results_tfm_file, resultsLabels, "LinXfm") if not opts.nopvc and not opts.pvc_method == None: pvcLabels = pe.Node(interface=Labels(), name="pvcLabels") pvcLabels.inputs.analysis_space = opts.analysis_space pvcLabels.inputs.label_type = opts.pvc_label_type pvcLabels.inputs.space = opts.pvc_label_space pvcLabels.inputs.erode_times = opts.pvc_erode_times pvcLabels.inputs.brain_only = opts.pvc_labels_brain_only pvcLabels.inputs.ones_only = opts.pvc_labels_ones_only workflow.connect(inputnode, 'pvc_labels', pvcLabels, 'labels') workflow.connect(inputnode, 'pvc_label_img', pvcLabels, 'label_img') workflow.connect(inputnode, 'pvc_label_template', pvcLabels, 'label_template') workflow.connect(inputnode, like_file, pvcLabels, 'like_file') workflow.connect(brain_mask_node, "output_file", pvcLabels, 'brainmask') workflow.connect(pvc_tfm_node, pvc_tfm_file, pvcLabels, "LinXfm") if not opts.tka_method == None: tkaLabels = pe.Node(interface=Labels(), name="tkaLabels") tkaLabels.inputs.analysis_space = opts.analysis_space tkaLabels.inputs.label_type = opts.tka_label_type tkaLabels.inputs.space = opts.tka_label_space tkaLabels.inputs.erode_times = opts.tka_erode_times tkaLabels.inputs.brain_only = opts.tka_labels_brain_only tkaLabels.inputs.ones_only = opts.tka_labels_ones_only workflow.connect(inputnode, 'tka_labels', tkaLabels, 'labels') workflow.connect(inputnode, 'tka_label_img', tkaLabels, 'label_img') workflow.connect(inputnode, 'tka_label_template', tkaLabels, 'label_template') workflow.connect(inputnode, like_file, tkaLabels, 'like_file') workflow.connect(brain_mask_node, "output_file", tkaLabels, 'brainmask') workflow.connect(tka_tfm_node, tka_tfm_file, tkaLabels, "LinXfm") #workflow.connect(brain_mask_node,"output_file", outputnode, 'brain_mask') return (workflow)
def get_workflow(name, opts): workflow = pe.Workflow(name=name) in_fields = ['t1'] if opts.user_brainmask : in_fields += ['brain_mask_mni'] if opts.user_t1mni : in_fields += ['xfmT1MNI'] print("In Fields:", in_fields) label_types = [opts.tka_label_type, opts.pvc_label_type, opts.results_label_type] stages = ['tka', 'pvc', 'results'] label_imgs= [opts.tka_label_img, opts.results_label_img, opts.pvc_label_img ] inputnode = pe.Node(niu.IdentityInterface(fields=in_fields), name="inputnode") out_fields=['xfmMNIT1', 'xfmT1MNI', 'xfmT1MNI_invert', 'brain_mask_mni', 'brain_mask_t1', 't1_mni', 't1_nat' ] for stage, label_type in zip(stages, label_types): print( stage, label_type ) if 'internal_cls' == label_type : out_fields += [ stage+'_label_img'] print( stage+'_label_img' ) outputnode = pe.Node(niu.IdentityInterface(fields=out_fields), name='outputnode') # # Setup dir for minc beast if not using user provided brain mask # if not opts.user_brainmask : if opts.beast_library_dir == None : library_dir = mincbeast_library(opts.template) else : library_dir = opts.beast_library_dir template_rsl = create_alt_template(opts.template, library_dir) ########################################## # T1 spatial (+ intensity) normalization # ########################################## if not opts.user_t1mni: if opts.coreg_method == 'ants' : mri2template = pe.Node(interface=mincANTSCommand(args='--float', collapse_output_transforms=True, fixed_image=opts.template, initial_moving_transform_com=True, num_threads=1, output_inverse_warped_image=True, output_warped_image=True, sigma_units=['vox']*3, transforms=['Rigid', 'Affine', 'SyN'], terminal_output='file', winsorize_lower_quantile=0.005, winsorize_upper_quantile=0.995, convergence_threshold=[1e-08, 1e-08, -0.01], convergence_window_size=[20, 20, 5], metric=['Mattes', 'Mattes', ['Mattes', 'CC']], metric_weight=[1.0, 1.0, [0.5, 0.5]], number_of_iterations=[[10000, 11110, 11110], [10000, 11110, 11110], [100, 30, 20]], radius_or_number_of_bins=[32, 32, [32, 4]], sampling_percentage=[0.3, 0.3, [None, None]], sampling_strategy=['Regular', 'Regular', [None, None]], shrink_factors=[[3, 2, 1], [3, 2, 1], [4, 2, 1]], smoothing_sigmas=[[4.0, 2.0, 1.0], [4.0, 2.0, 1.0], [1.0, 0.5, 0.0]], transform_parameters=[(0.1,), (0.1,), (0.2, 3.0, 0.0)], use_estimate_learning_rate_once=[True]*3, use_histogram_matching=[False, False, True], write_composite_transform=True), name="mincANTS_registration") mri2template.inputs.write_composite_transform=True workflow.connect(inputnode, 't1', mri2template, 'moving_image') t1_mni_file = 'warped_image' t1_mni_node=mri2template tfm_node= mri2template tfm_file='composite_transform' else : mri2template = pe.Node(interface=beast_normalize_with_conversion(), name="mri_normalize") template_name = os.path.splitext(os.path.basename(template_rsl))[0] template_dir = os.path.dirname(opts.template) mri2template.inputs.modelname = template_name mri2template.inputs.modeldir = template_dir workflow.connect(inputnode, 't1', mri2template, 'in_file') t1_mni_file = 'out_file_vol' t1_mni_node=mri2template tfm_node= mri2template tfm_file='out_file_xfm' else : transform_t1 = pe.Node(interface=minc.Resample(), name="transform_t1" ) transform_t1.inputs.two=True workflow.connect(inputnode, 't1', transform_t1, 'input_file') workflow.connect(inputnode, 'xfmT1MNI', transform_t1, 'transformation') transform_t1.inputs.like = opts.template t1_mni_node = transform_t1 t1_mni_file = 'output_file' tfm_node = inputnode tfm_file = 'xfmT1MNI' # # Invert transformation from T1 to MNI space # xfmMNIT1 = pe.Node(interface=minc.XfmInvert(), name="MNIT1") workflow.connect(tfm_node, tfm_file, xfmMNIT1 , 'input_file') # # 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_t1_nat = pe.Node(interface=copyCommand(), name="t1_nat" ) workflow.connect(inputnode, 't1', copy_t1_nat, 'input_file') #################### # T1 Brain masking # #################### if not opts.user_brainmask : #Brain Mask MNI-Space t1MNI_brain_mask = pe.Node(interface=mincbeast(), name="t1_mni_brain_mask") t1MNI_brain_mask.inputs.library_dir = library_dir t1MNI_brain_mask.inputs.configuration = t1MNI_brain_mask.inputs.library_dir+os.sep+"default.2mm.conf" t1MNI_brain_mask.inputs.same_resolution = True t1MNI_brain_mask.inputs.median = True t1MNI_brain_mask.inputs.fill = True #t1MNI_brain_mask.inputs.voxel_size=opts.beast_voxel_size t1MNI_brain_mask.inputs.median = opts.beast_median workflow.connect(t1_mni_node, t1_mni_file, t1MNI_brain_mask, "in_file" ) brain_mask_node = t1MNI_brain_mask brain_mask_file = 'out_file' else : brain_mask_node = inputnode brain_mask_file = 'brain_mask_mni' # # Transform brain mask from stereotaxic to T1 native space # transform_brain_mask = pe.Node(interface=minc.Resample(), name="transform_brain_mask" ) transform_brain_mask.inputs.nearest_neighbour_interpolation = True transform_brain_mask.inputs.invert_transformation = True workflow.connect(brain_mask_node, brain_mask_file, transform_brain_mask, 'input_file') workflow.connect(inputnode, 't1', transform_brain_mask, 'like') workflow.connect(tfm_node, tfm_file, transform_brain_mask, 'transformation') ################################### # Segment T1 in Stereotaxic space # ################################### seg=None for stage, label_type, img in zip(stages, label_types, label_imgs) : print(img, seg) if 'antsAtropos' == img and seg == None : seg = pe.Node(interface=mincAtroposCommand(), name="segmentation_ants") seg.inputs.dimension=3 seg.inputs.number_of_tissue_classes=3 #... opts. seg.inputs.initialization = 'Otsu' workflow.connect(t1_mni_node, t1_mni_file, seg, 'intensity_images' ) workflow.connect(brain_mask_node, brain_mask_file, seg, 'mask_image' ) if 'antsAtropos' == img : workflow.connect(seg, 'classified_image', outputnode, stage+'_label_img') ############################### # Pass results to output node # ############################### workflow.connect(brain_mask_node, brain_mask_file, outputnode, 'brain_mask_mni') workflow.connect(tfm_node, tfm_file, outputnode, 'xfmT1MNI' ) workflow.connect(xfmMNIT1, 'output_file', outputnode, 'xfmMNIT1' ) workflow.connect(transform_brain_mask, 'output_file', outputnode, 'brain_mask_t1') workflow.connect(t1_mni_node, t1_mni_file, outputnode, 't1_mni') workflow.connect(copy_t1_nat, 'output_file', outputnode, 't1_nat') return(workflow)
def _run_interface(self, runtime): self.inputs.out_file = self._gen_output( self.inputs.label_img, self._suffix + self.inputs.analysis_space) tmpDir = os.getcwd() + os.sep + 'tmp_label' #tempfile.mkdtemp() os.mkdir(tmpDir) out_file_1 = temp_mask = tmpDir + "/mask.mnc" temp_mask_clean = tmpDir + "/mask_clean.mnc" if self.inputs.labels == []: mask = pyminc.volumeFromFile(self.inputs.label_img) mask_flat = mask.data.flatten() labels = [str(int(round(i))) for i in np.unique(mask_flat)] if '0' in labels: labels.remove('0') else: labels = self.inputs.labels # 1) Select Labels run_calc = minc.Calc( ) #Extract the desired label from the atlas using minccalc. run_calc.inputs.input_files = self.inputs.label_img #The ANIMAL or CIVET classified atlas run_calc.inputs.output_file = temp_mask #Output mask with desired label run_calc.inputs.expression = " || ".join([ '(A[0] > ' + str(label) + '-0.1 && A[0] < ' + str(label) + '+ 0.1 )' for label in labels ]) + ' ? A[0] : 0' run_calc.run() # 2) Erode if int(self.inputs.erode_times) > 0: run_mincmorph = MorphCommand() run_mincmorph.inputs.in_file = temp_mask run_mincmorph.inputs.out_file = temp_mask_clean run_mincmorph.inputs.successive = 'E' * self.inputs.erode_times run_mincmorph.run() out_file_1 = temp_mask_clean else: out_file_1 = temp_mask #self.inputs.out_file # 3) Co-registration if self.inputs.space == "stereo" and self.inputs.label_type == "atlas-template": if self.inputs.nLinAtlasMNIXfm == '': sourceToModel_xfm = os.getcwd() + os.sep + 'template2mni.xfm' run_nlinreg = reg.nLinRegRunning() run_nlinreg.inputs.in_source_file = self.inputs.label_template run_nlinreg.inputs.in_target_file = self.inputs.mniT1 run_nlinreg.inputs.out_file_xfm = sourceToModel_xfm # xfm file for the transformation from template to subject stereotaxic run_nlinreg.run() mni2target = minc.XfmConcat() mni2target.inputs.input_file_1 = sourceToModel_xfm mni2target.inputs.input_file_2 = self.inputs.mni2target mni2target.run() xfm = mni2target.inputs.out_file self.inputs.nLinAtlasMNIXfm = mni2target.inputs.output_file else: xfm = self.inputs.nLinAtlasMNIXfm else: xfm = self.inputs.LinXfm # 4) Apply transformation like_file = self.inputs.like_file base = splitext(out_file_1) out_file_2 = base[0] + self.inputs.analysis_space + base[1] run_resample = minc.Resample() run_resample.inputs.input_file = out_file_1 # self.inputs.label_img run_resample.inputs.output_file = out_file_2 run_resample.inputs.like = like_file run_resample.inputs.transformation = xfm run_resample.inputs.nearest_neighbour_interpolation = True run_resample.run() label = run_resample.inputs.output_file #Copy to output shutil.copy(label, self.inputs.out_file) # 6) Mask brain for T1 and MNI labels if self.inputs.brain_only: temp_mask = tmpDir + "/mask.mnc" run_calc = minc.Calc( ) #Extract the desired label from the atlas using minccalc. run_calc.inputs.input_files = [label, self.inputs.brain_mask] run_calc.inputs.output_file = temp_mask #Output mask with desired label run_calc.inputs.expression = " A[1] == 1 ? A[0] : 0 " run_calc.clobber = True run_calc.run() shutil.copy(temp_mask, self.inputs.out_file) label = self.inputs.out_file if self.inputs.ones_only: temp_mask = tmpDir + "/mask.mnc" run_calc = minc.Calc( ) #Extract the desired label from the atlas using minccalc. run_calc.inputs.input_files = [ label ] #The ANIMAL or CIVET classified atlas run_calc.inputs.output_file = temp_mask #Output mask with desired label run_calc.inputs.expression = " A[0] > 0.1 ? 1 : 0 " run_calc.clobber = True run_calc.run() shutil.copy(temp_mask, self.inputs.out_file) return runtime
def get_workflow(name, infosource, opts): ''' Create workflow to produce labeled images. 1. Invert T1 Native to MNI 152 transformation 2. Transform 4. Transform brain_mask from MNI 152 to T1 native 5. Create PVC labeled image 6. Create quantification labeled image 7. Create results labeled image :param name: Name for workflow :param infosource: Infosource for basic variables like subject id (sid) and condition id (cid) :param datasink: Node in which output data is sent :param opts: User options :returns: workflow ''' workflow = pe.Workflow(name=name) out_list = [ "pet_brain_mask", "brain_mask", "results_label_img_t1", "results_label_img_mni" ] in_list = [ "nativeT1", "mniT1", "brain_mask_stereo", "brain_mask_t1", "pet_header_json", "pet_volume", "results_labels", "results_label_template", "results_label_img", 'LinT1MNIXfm', 'LinMNIT1Xfm', "LinPETMNIXfm", "LinMNIPETXfm", 'LinT1MNIXfm', "LinT1PETXfm", "LinPETT1Xfm", "surf_left", 'surf_right' ] if not opts.pvc_method == None: out_list += ["pvc_label_img_t1", "pvc_label_img_mni"] in_list += [ "pvc_labels", "pvc_label_space", "pvc_label_img", "pvc_label_template" ] if not opts.tka_method == None: out_list += ["tka_label_img_t1", "tka_label_img_mni"] in_list += [ "tka_labels", "tka_label_space", "tka_label_template", "tka_label_img" ] #Define input node that will receive input from outside of workflow inputnode = pe.Node(niu.IdentityInterface(fields=in_list), name='inputnode') outputnode = pe.Node(niu.IdentityInterface(fields=out_list), name='outputnode') #Define empty node for output #Create Identity Transform identity_transform = pe.Node(param2xfmCommand(), name="identity_transform") identity_transform.inputs.translation = "0 0 0" identity_transform.inputs.rotation = "0 0 0" identity_transform.inputs.scales = "1 1 1" if not opts.pvc_method == None and not opts.pvc_method == None: pvc_tfm_node, pvc_tfm_file, pvc_target_file = get_transforms_for_stage( inputnode, opts.pvc_label_space, opts.analysis_space, identity_transform) if not opts.tka_method == None: tka_tfm_node, tka_tfm_file, tka_target_file = get_transforms_for_stage( inputnode, opts.tka_label_space, opts.analysis_space, identity_transform) results_tfm_node, results_tfm_file, results_target_file = get_transforms_for_stage( inputnode, opts.results_label_space, opts.analysis_space, identity_transform) ################### # Brain Mask Node # ################### if opts.analysis_space == "stereo": brain_mask_node = pe.Node( niu.IdentityInterface(fields=["output_file"]), "brain_mask") workflow.connect(inputnode, "brain_mask_stereo", brain_mask_node, "output_file") like_file = "mniT1" elif opts.analysis_space == "t1": brain_mask_node = pe.Node( niu.IdentityInterface(fields=["output_file"]), "brain_mask") workflow.connect(inputnode, "brain_mask_t1", brain_mask_node, "output_file") like_file = "nativeT1" elif opts.analysis_space == "pet": brain_mask_node = pe.Node(minc.Resample(), "brain_mask") brain_mask_node.inputs.nearest_neighbour_interpolation = True workflow.connect(inputnode, "brain_mask_stereo", brain_mask_node, "input_file") workflow.connect(inputnode, "LinMNIPETXfm", brain_mask_node, "transformation") workflow.connect(inputnode, "pet_volume", brain_mask_node, "like") like_file = "pet_volume" else: print("Error: Analysis space must be one of pet,stereo,t1 but is", opts.analysis_space) exit(1) ################# # Surface masks # ################# if opts.use_surfaces: if opts.analysis_space != "stereo": surface_left_node = pe.Node(transform_objectCommand(), name="surface_left_node") surface_right_node = pe.Node(transform_objectCommand(), name="surface_right_node") workflow.connect(inputnode, 'surf_left', surface_left_node, 'in_file') workflow.connect(inputnode, 'surf_right', surface_right_node, 'in_file') if opts.analysis_space == "t1": workflow.connect(inputnode, "LinMNIT1Xfm", surface_left_node, 'tfm_file') workflow.connect(inputnode, "LinMNIT1Xfm", surface_right_node, 'tfm_file') elif opts.analysis_space == "pet": workflow.connect(inputnode, 'LinMNIPETXfm', surface_left_node, 'tfm_file') workflow.connect(inputnode, 'LinMNIPETXfm', surface_right_node, 'tfm_file') else: surface_left_node = pe.Node( niu.IdentityInterface(fields=["output_file"]), "surf_left_node") surface_right_node = pe.Node( niu.IdentityInterface(fields=["output_file"]), "surf_right_node") workflow.connect(inputnode, "surf_left", surface_left_node, "output_file") workflow.connect(inputnode, "surf_right", surface_right_node, "output_file") resultsLabels = pe.Node(interface=Labels(), name="resultsLabels") resultsLabels.inputs.analysis_space = opts.analysis_space resultsLabels.inputs.label_type = opts.results_label_type resultsLabels.inputs.space = opts.results_label_space resultsLabels.inputs.erode_times = opts.results_erode_times resultsLabels.inputs.brain_only = opts.results_labels_brain_only resultsLabels.inputs.ones_only = opts.results_labels_ones_only workflow.connect(inputnode, 'results_labels', resultsLabels, 'labels') workflow.connect(inputnode, 'results_label_img', resultsLabels, 'label_img') workflow.connect(inputnode, 'results_label_template', resultsLabels, 'label_template') workflow.connect(inputnode, like_file, resultsLabels, 'like_file') workflow.connect(brain_mask_node, "output_file", resultsLabels, 'brain_mask') workflow.connect(results_tfm_node, results_tfm_file, resultsLabels, "LinXfm") #Setup node for nonlinear alignment of results template to default (icbm152) template if opts.results_label_template != None: results_template_norm = pe.Node(interface=reg.nLinRegRunning(), name="results_template_normalization") results_template_norm.inputs.in_target_file = opts.template results_template_norm.inputs.in_source_file = opts.results_label_template results_template_analysis_space = pe.Node( ConcatNLCommand(), name="results_template_analysis_space") workflow.connect(results_template_norm, 'out_file_xfm', results_template_analysis_space, 'in_file') workflow.connect(results_template_norm, 'out_file_warp', results_template_analysis_space, 'in_warp') workflow.connect(results_tfm_node, results_tfm_file, results_template_analysis_space, 'in_file_2') workflow.connect(results_template_analysis_space, 'out_file', resultsLabels, 'nLinAtlasMNIXfm') workflow.connect(results_template_analysis_space, 'out_warp', resultsLabels, 'warp') workflow.connect(results_template_norm, 'out_file_img', resultsLabels, 'template') if not opts.pvc_method == None and not opts.pvc_method == None: pvcLabels = pe.Node(interface=Labels(), name="pvcLabels") pvcLabels.inputs.analysis_space = opts.analysis_space pvcLabels.inputs.label_type = opts.pvc_label_type pvcLabels.inputs.space = opts.pvc_label_space pvcLabels.inputs.erode_times = opts.pvc_erode_times pvcLabels.inputs.brain_only = opts.pvc_labels_brain_only pvcLabels.inputs.ones_only = opts.pvc_labels_ones_only workflow.connect(inputnode, 'pvc_labels', pvcLabels, 'labels') workflow.connect(inputnode, 'pvc_label_img', pvcLabels, 'label_img') workflow.connect(inputnode, like_file, pvcLabels, 'like_file') workflow.connect(brain_mask_node, "output_file", pvcLabels, 'brain_mask') workflow.connect(pvc_tfm_node, pvc_tfm_file, pvcLabels, "LinXfm") if opts.pvc_label_template != None: pvc_template_norm = pe.Node(interface=reg.nLinRegRunning(), name="pvc_template_normalization") pvc_template_norm.inputs.in_target_file = opts.template pvc_template_norm.inputs.in_source_file = opts.pvc_label_template pvc_template_analysis_space = pe.Node( ConcatNLCommand(), name="pvc_template_analysis_space") workflow.connect(pvc_template_norm, 'out_file_xfm', pvc_template_analysis_space, 'in_file') workflow.connect(pvc_template_norm, 'out_file_warp', pvc_template_analysis_space, 'in_warp') workflow.connect(pvc_tfm_node, pvc_tfm_file, pvc_template_analysis_space, 'in_file_2') workflow.connect(pvc_template_analysis_space, 'out_file', pvcLabels, 'nLinAtlasMNIXfm') workflow.connect(pvc_template_analysis_space, 'out_warp', pvcLabels, 'warp') workflow.connect(pvc_template_norm, 'out_file_img', pvcLabels, 'template') if not opts.tka_method == None: tkaLabels = pe.Node(interface=Labels(), name="tkaLabels") tkaLabels.inputs.analysis_space = opts.analysis_space tkaLabels.inputs.label_type = opts.tka_label_type tkaLabels.inputs.space = opts.tka_label_space tkaLabels.inputs.erode_times = opts.tka_erode_times tkaLabels.inputs.brain_only = opts.tka_labels_brain_only tkaLabels.inputs.ones_only = opts.tka_labels_ones_only workflow.connect(inputnode, 'tka_labels', tkaLabels, 'labels') workflow.connect(inputnode, 'tka_label_img', tkaLabels, 'label_img') workflow.connect(inputnode, like_file, tkaLabels, 'like_file') workflow.connect(brain_mask_node, "output_file", tkaLabels, 'brain_mask') workflow.connect(tka_tfm_node, tka_tfm_file, tkaLabels, "LinXfm") if opts.tka_label_template != None: tka_template_norm = pe.Node(interface=reg.nLinRegRunning(), name="tka_template_normalization") tka_template_norm.inputs.in_source_file = opts.template tka_template_norm.inputs.in_target_file = opts.tka_label_template tka_template_analysis_space = pe.Node( ConcatNLCommand(), name="tka_template_analysis_space") workflow.connect(tka_template_norm, 'out_file_xfm', tka_template_analysis_space, 'in_file') workflow.connect(tka_template_norm, 'out_file_warp', tka_template_analysis_space, 'in_warp') workflow.connect(tka_tfm_node, tka_tfm_file, tka_template_analysis_space, 'in_file_2') workflow.connect(tka_template_analysis_space, 'out_file', tkaLabels, 'nLinAtlasMNIXfm') workflow.connect(tka_template_analysis_space, 'out_warp', tkaLabels, 'warp') workflow.connect(tka_template_norm, 'out_file_img', tkaLabels, 'template') return (workflow)