def dcm_to_nifti(dicom_dir, nifti_dir, split=True, tool_used='dcm2niix'): for patient in os.listdir(dicom_dir): path_dicom = os.path.join(dicom_dir, patient) path_nifti = os.path.join(nifti_dir, patient) # make subfolder for each patient if not os.path.exists(path_nifti): os.makedirs(path_nifti) if split == False: if tool_used == 'dcm2niix': converter = Dcm2niix() converter.inputs.source_dir = path_dicom converter.inputs.compression = 5 converter.inputs.merge_imgs = True converter.inputs.out_filename = '%d' converter.inputs.output_dir = path_nifti converter.run() elif tool_used == 'dcm2nii': converter = Dcm2nii() converter.inputs.source_dir = path_dicom converter.inputs.gzip_output = True converter.inputs.output_dir = path_nifti converter.run() else: raise Warning("tool used does not exist, please enter dcm2nii or dcm2niix") else: for s in os.listdir(path_dicom): if tool_used == 'dcm2niix': converter = Dcm2niix() converter.inputs.source_dir = path_dicom + '/' + s converter.inputs.compression = 5 converter.inputs.merge_imgs = True converter.inputs.out_filename = 'x_%d' converter.inputs.output_dir = path_nifti converter.run() elif tool_used == 'dcm2nii': converter = Dcm2nii() converter.inputs.source_dir = path_dicom + '/' + s converter.inputs.gzip_output = True converter.inputs.output_dir = path_nifti converter.run() else: raise Warning("tool used does not exist, please enter dcm2nii or dcm2niix") #dcm_to_nifti(dicom_split_dir, nifti_dir, True, 'dcm2nii') #dcm_to_nifti(dicom_split_dir, nifti_dir, True, 'dcm2niix')
def test_Dcm2nii_inputs(): input_map = dict( anonymize=dict(argstr="-a", usedefault=True), args=dict(argstr="%s"), collapse_folders=dict(argstr="-c", usedefault=True), config_file=dict(argstr="-b %s", genfile=True), convert_all_pars=dict(argstr="-v", usedefault=True), date_in_filename=dict(argstr="-d", usedefault=True), environ=dict(nohash=True, usedefault=True), events_in_filename=dict(argstr="-e", usedefault=True), gzip_output=dict(argstr="-g", usedefault=True), id_in_filename=dict(argstr="-i", usedefault=True), ignore_exception=dict(nohash=True, usedefault=True), nii_output=dict(argstr="-n", usedefault=True), output_dir=dict(argstr="-o %s", genfile=True), protocol_in_filename=dict(argstr="-p", usedefault=True), reorient=dict(argstr="-r"), reorient_and_crop=dict(argstr="-x", usedefault=True), source_dir=dict(argstr="%s", mandatory=True, position=-1, xor=["source_names"]), source_in_filename=dict(argstr="-f", usedefault=True), source_names=dict(argstr="%s", copyfile=False, mandatory=True, position=-1, xor=["source_dir"]), spm_analyze=dict(argstr="-s", xor=["nii_output"]), terminal_output=dict(mandatory=True, nohash=True), ) inputs = Dcm2nii.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 make_and_upload_nifti(subject_name, subject_XNAT, scan_sequence): subject_directory = os.path.join(DICOM_folder, i_subject) dicom_directory = os.path.join(DICOM_folder, i_subject, scan_sequence) converter = Dcm2nii() converter.inputs.source_dir = dicom_directory converter.inputs.gzip_output = True converter.inputs.output_dir = subject_directory converter.inputs.source_in_filename = False converter.inputs.protocol_in_filename = False converter.inputs.date_in_filename = False converter.inputs.events_in_filename = False converter.inputs.id_in_filename = True converter.inputs.terminal_output = 'file' convert_result = converter.run() nifti_file = convert_result.outputs.converted_files shutil.move(nifti_file, os.path.join(subject_directory, scan_sequence + '.nii.gz')) nifti_file = os.path.join(subject_directory, scan_sequence + '.nii.gz') upload_nifti(subject_XNAT, scan_sequence, nifti_file, 'NIFTI', 'image.nii.gz') return
def dcm2nii_converter(source_names=traits.Undefined): """ Create a dcm2nii workflow. It does: - dcm2nii Nipype Inputs ------------- source_names: traits.File path to the DICOM files or series folder. Returns ------- wf: nipype Workflow Note ---- For more info: http://www.mit.edu/~satra/nipype-nightly/interfaces/generated/nipype.interfaces.dcm2nii.html # TODO: an attach function for this node. """ dcm2nii = Dcm2nii() dcm2nii.inputs.gzip_output = True dcm2nii.inputs.output_dir = '.' dcm2nii.inputs.terminal_output = 'file' dcm2nii.inputs.source_names = source_names return dcm2nii
def weird_convert_dti_dcm(in_dcm): import os import numpy as np import re subjid = re.search('R[0-9X]+', in_dcm).group() year = re.search('_201[1234]', in_dcm).group()[1:] visit_dict = {'2012': 1, '2013': 2, '2014': 3, '2011': 4} visit = visit_dict[year] scanid = re.search('S[0-9]+', in_dcm).group() ton_dir = '/data1/cooked/TONf' test_fn = os.path.join(ton_dir, subjid, 'visit_{}'.format(visit), 'DTI', '_'.join([subjid, 'visit', str(visit), 'DTI', scanid])) + '.bvals' if os.path.exists(test_fn): assert np.all(np.loadtxt(test_fn) != 0) converter = Dcm2nii() converter.inputs.source_names = in_dcm converter.inputs.gzip_output = True converter.inputs.output_dir = os.getcwd() converter.run() merger = Merge() merger.inputs.in_files = converter.output_files merger.inputs.dimension = 't' merged_result = merger.run() fn_base = os.path.basename(in_dcm).split('.')[0] merged_file = os.path.join(os.getcwd(), fn_base + '.nii.gz') os.rename(merged_result.outputs.merged_file, merged_file) in_bval = converter.bvals[0] in_bvec = converter.bvecs[0] b0_idx = 0 assert np.all(np.loadtxt(in_bval) != 0) # Load (and transpose!!) bvec_arr = np.loadtxt(in_bvec).T out_bvec = np.zeros((bvec_arr.shape[0] + 1, bvec_arr.shape[1])) out_bvec[:] = np.nan out_bvec[b0_idx, :] = 0 out_bvec[np.where(np.isnan(out_bvec))] = bvec_arr.flatten() bval_arr = np.loadtxt(in_bval) out_bval = np.zeros((bval_arr.shape[0] + 1,)) out_bval[:] = np.nan out_bval[b0_idx] = 0 out_bval[np.isnan(out_bval)] = bval_arr out_bvec_fn = os.path.join(os.getcwd(), fn_base + '.bvecs') np.savetxt(out_bvec_fn, out_bvec, fmt='%.8f') out_bval_fn = os.path.join(os.getcwd(), fn_base + '.bvals') np.savetxt(out_bval_fn, out_bval, fmt='%.6f') return merged_file, out_bvec_fn, out_bval_fn
def __init__(self, source_names=['path'], source_dir='path', **options): from nipype.interfaces.dcm2nii import Dcm2nii self.converter = Dcm2nii() self.converter.inputs.source_names = source_names self.converter.inputs.source_dir = source_dir for ef in options: setattr(self.converter.inputs, ef, options[ef]) self.converter.run()
def __init__(self, source_names=['', '']): from nipype.interfaces.dcm2nii import Dcm2nii converter = Dcm2nii() converter.inputs.source_names = source_names converter.inputs.gzip_output = True converter.inputs.output_dir = '.' converter.cmdline converter.run()
def dcm_to_nifti(dicom_dir, nifti_dir, split=True, tool_used='dcm2niix'): for patient in os.listdir(dicom_dir): path_dicom = os.path.join(dicom_dir, patient) path_nifti = os.path.join(nifti_dir, patient) # make subfolder for each patient if not os.path.exists(path_nifti): os.makedirs(path_nifti) if not split: if tool_used == 'dcm2niix': try: subprocess.call('dcm2niix -z y -f %%d -o %s %s' % (path_nifti, path_dicom), shell=True) except: pass elif tool_used == 'dcm2nii': converter = Dcm2nii() converter.inputs.source_dir = path_dicom converter.inputs.gzip_output = True converter.inputs.output_dir = path_nifti converter.run() else: raise Warning( "tool used does not exist, please enter dcm2nii or dcm2niix" ) else: for i in os.listdir(path_dicom): if tool_used == 'dcm2niix': try: subprocess.call('dcm2niix -z y -f %%d -o %s %s' % (path_nifti, path_dicom + '/' + i), shell=True) except: pass elif tool_used == 'dcm2nii': converter = Dcm2nii() converter.inputs.source_dir = path_dicom + '/' + i converter.inputs.gzip_output = True converter.inputs.output_dir = path_nifti converter.run() else: raise Warning( "tool used does not exist, please enter dcm2nii or dcm2niix" )
def test_Dcm2nii_outputs(): output_map = dict( bvals=dict(), bvecs=dict(), converted_files=dict(), reoriented_and_cropped_files=dict(), reoriented_files=dict() ) outputs = Dcm2nii.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 create_converter_diffusion_pipeline(working_dir, ds_dir, name='converter_diffusion'): # initiate workflow converter_wf = Workflow(name=name) converter_wf.base_dir = os.path.join(working_dir, 'LeiCA_resting') # set fsl output fsl.FSLCommand.set_default_output_type('NIFTI_GZ') # inputnode inputnode = Node(util.IdentityInterface(fields=['dMRI_dicom']), name='inputnode') outputnode = Node(util.IdentityInterface(fields=['dMRI']), name='outputnode') niftisink = Node(nio.DataSink(), name='niftisink') niftisink.inputs.base_directory = os.path.join(ds_dir, 'raw_niftis') ####### converter_dMRI = Node(Dcm2nii(), name="converter_dMRI") converter_dMRI.inputs.gzip_output = True converter_dMRI.inputs.nii_output = True converter_dMRI.inputs.anonymize = False converter_dMRI.plugin_args = {'submit_specs': 'request_memory = 2000'} converter_wf.connect(inputnode, 'dMRI_dicom', converter_dMRI, 'source_names') dMRI_rename = Node(util.Rename(format_string='DTI_mx_137.nii.gz'), name='dMRI_rename') converter_wf.connect(converter_dMRI, 'converted_files', dMRI_rename, 'in_file') bvecs_rename = Node(util.Rename(format_string='DTI_mx_137.bvecs'), name='bvecs_rename') converter_wf.connect(converter_dMRI, 'bvecs', bvecs_rename, 'in_file') bvals_rename = Node(util.Rename(format_string='DTI_mx_137.bvals'), name='bvals_rename') converter_wf.connect(converter_dMRI, "bvals", bvals_rename, 'in_file') # reorient to standard orientation reor_2_std = Node(fsl.Reorient2Std(), name='reor_2_std') converter_wf.connect(dMRI_rename, 'out_file', reor_2_std, 'in_file') converter_wf.connect(reor_2_std, 'out_file', outputnode, 'dMRI') # save original niftis converter_wf.connect(reor_2_std, 'out_file', niftisink, 'dMRI.@dwi') converter_wf.connect(bvals_rename, 'out_file', niftisink, 'dMRI.@bvals') converter_wf.connect(bvecs_rename, 'out_file', niftisink, 'dMRI.@bvecs') converter_wf.write_graph(dotfilename='converter_struct', graph2use='flat', format='pdf') return converter_wf
def test_Dcm2nii_inputs(): input_map = dict(anonymize=dict(argstr='-a', position=2, ), args=dict(argstr='%s', position=9, ), config_file=dict(argstr='-b %s', genfile=True, position=7, ), convert_all_pars=dict(argstr='-v', position=8, ), environ=dict(nohash=True, usedefault=True, ), gzip_output=dict(argstr='-g', position=0, usedefault=True, ), id_in_filename=dict(argstr='-i', position=3, usedefault=True, ), ignore_exception=dict(nohash=True, usedefault=True, ), nii_output=dict(argstr='-n', position=1, usedefault=True, ), output_dir=dict(argstr='-o %s', genfile=True, position=6, ), reorient=dict(argstr='-r', position=4, ), reorient_and_crop=dict(argstr='-x', position=5, ), source_names=dict(argstr='%s', copyfile=False, mandatory=True, position=10, ), terminal_output=dict(mandatory=True, nohash=True, ), ) inputs = Dcm2nii.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 dcm_to_nifti(dicom_dir, nifti_dir, split=True, tool_used='dcm2niix'): for patient in os.listdir(dicom_dir): path_dicom = os.path.join(dicom_dir, patient) path_nifti = os.path.join(nifti_dir, patient) # make subfolder for each patient if not os.path.exists(path_nifti): os.makedirs(path_nifti) if not split: if tool_used == 'dcm2niix': converter = Dcm2niix() converter.inputs.source_dir = path_dicom converter.inputs.compression = 5 converter.inputs.merge_imgs = True converter.inputs.out_filename = '%d' converter.inputs.output_dir = path_nifti converter.run() elif tool_used == 'dcm2nii': converter = Dcm2nii() converter.inputs.source_dir = path_dicom converter.inputs.gzip_output = True converter.inputs.output_dir = path_nifti converter.run() else: raise Warning("tool used does not exist, please enter dcm2nii or dcm2niix") else: for s in os.listdir(path_dicom): if tool_used == 'dcm2niix': try: subprocess.call('/home/harryzhang/toolbox/dcm2niix/console/dcm2niix -m y -5 -f %%d -o %s %s' % (path_nifti, path_dicom + '/'+s), shell=True) except: pass elif tool_used == 'dcm2nii': converter = Dcm2nii() converter.inputs.source_dir = path_dicom + '/' + s converter.inputs.gzip_output = True converter.inputs.output_dir = path_nifti converter.run() else: raise Warning("tool used does not exist, please enter dcm2nii or dcm2niix")
def dcm2nii_wrapper(input_dir, output_dir): converter = Dcm2nii() converter.inputs.source_dir = input_dir converter.inputs.output_dir = output_dir converter.inputs.gzip_output = False converter.inputs.reorient_and_crop = False converter.inputs.reorient = False converter.inputs.events_in_filename = False converter.inputs.date_in_filename = False converter.inputs.protocol_in_filename = True converter.run() return converter.output_files
def test_Dcm2nii_outputs(): output_map = dict(bvals=dict(), bvecs=dict(), converted_files=dict(), reoriented_and_cropped_files=dict(), reoriented_files=dict(), ) outputs = Dcm2nii.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 main(args): print('\n>> CLI Parameters ...\n') print(args) if not os.path.isdir(args.output_dir): os.makedirs(args.output_dir) converter = Dcm2nii() converter.inputs.source_dir = args.source_dir converter.inputs.output_dir = args.output_dir converter.inputs.anonymize = args.anonymize converter.inputs.nii_output = args.nii_output converter.inputs.gzip_output = args.gzip_output print('\n>> Running Dcm2nii ... \n') print(converter.cmdline) converter.run()
def extract_nac_pet(dicom_folder): """ Extract the Non attenuation Corrected PET from a DICOM exam. The function extract the last frame of the DICOM exam. The DICOM exam is expected to be of the dynamic PET scan itself. It also expects the image dimension in the transversal acquisition direction to be of 127 It uses dcm2nii to convert the DICOM subset into a nifti file :param dicom_folder: The input DICOM folder of the dynamic PET scan :return: the nifti converted image file (the last frame of the dynamic PET scan) """ from glob import glob import os import shutil import re from nipype.interfaces.dcm2nii import Dcm2nii def atoi(text): return int(text) if text.isdigit() else text def natural_keys(text): return [atoi(c) for c in re.split('(\d+)', text)] files = glob(os.path.join(os.path.abspath(dicom_folder), '*')) sorted_files = sorted(files, key=natural_keys) nac_pet_files = sorted_files[-127:] for f in nac_pet_files: shutil.copy(f, os.getcwd()) dcm2nii = Dcm2nii() dcm2nii.inputs.source_dir = os.getcwd() nii_outputs = dcm2nii.run().outputs.converted_files print(nii_outputs) return nii_outputs[0]
for subject in subjects_data_list: if not os.path.exists(experiment_dir + '/' + data_dir_name + '/' + subject): os.makedirs(experiment_dir + '/' + data_dir_name + '/' + subject) """ Define nodes to use """ #Node: Infosource - we use IdentityInterface to create our own node, to # specify the list of subjects the pipeline should be # executed on infosource = pe.Node(interface=util.IdentityInterface(fields=['subject_id']), name="infosource") infosource.iterables = [('subject_id', subjects_data_list)] dcm2nii_converter = pe.Node(interface=Dcm2nii(), name='dcm2nii') dcm2nii_converter.inputs.gzip_output = True dcm2nii_converter.inputs.reorient_and_crop = False # Initiation of the preparation pipeline prepareflow = pe.Workflow(name="prepareflow") # Define where the workingdir of the all_consuming_workflow should be stored # at prepareflow.base_dir = experiment_dir + '/workingdir_prepareflow' #Define pathfinder function def pathfinder(subject, experiment_dir, foldername): import os from glob import glob
# Build DICOM scourse Direciry def sourceFinder(subjectname): import os path_to_subject = '/Users/Dalton/Documents/FSL/ValuePilot/RawData' path_to_dicomdir = 'DICOMDIR' return os.path.join(path_to_subject, subjectname, path_to_dicomdir) def outputFinder(subjectname): import os path_to_subject = '/Users/Dalton/Documents/FSL/ValuePilot/RawData' path_to_dicomdir = 'niis' return os.path.join(path_to_subject, subjectname, path_to_dicomdir) converter = pe.Node(Dcm2nii(), name="converter") converter.inputs.args = "-d n" #Initiation of the preparation pipeline prepareflow = pe.Workflow(name="prepareflow") #Define where the workingdir of the all_consuming_workflow should be stored at prepareflow.base_dir = experiment_dir + '/workingdir_prepareflow' prepareflow.connect([(infosource, converter, [(('subject_id', sourceFinder), 'source_names'), (('subject_id', outputFinder), 'output_dir')])]) prepareflow.write_graph(graph2use='orig') prepareflow.run(plugin='MultiProc', plugin_args={'n_procs': 8})
]] datagrabber.inputs.template_args['1400'] = [[ 'subject_id', 'session_1/RfMRI_mx_1400' ]] datagrabber.inputs.template_args['2500'] = [[ 'subject_id', 'session_1/RfMRI_std_2500' ]] datagrabber.inputs.template_args['dwi'] = [[ 'subject_id', ['session_1/DTI_mx_137/*.dcm'] ]] datagrabber.inputs.sort_filelist = True datagrabber.inputs.raise_on_empty = False wf.connect(subjects_infosource, "subject_id", datagrabber, "subject_id") dcm2nii_dwi = pe.Node(Dcm2nii(), name="dcm2nii_dwi") dcm2nii_dwi.inputs.gzip_output = True dcm2nii_dwi.inputs.nii_output = True dcm2nii_dwi.inputs.anonymize = False dcm2nii_dwi.plugin_args = {'submit_specs': 'request_memory = 2000'} wf.connect(datagrabber, "dwi", dcm2nii_dwi, "source_names") dwi_rename = pe.Node(util.Rename(format_string="DTI_mx_137.nii.gz"), name="dwi_rename") wf.connect(dcm2nii_dwi, "converted_files", dwi_rename, "in_file") bvecs_rename = pe.Node(util.Rename(format_string="DTI_mx_137.bvecs"), name="bvecs_rename") wf.connect(dcm2nii_dwi, "bvecs", bvecs_rename, "in_file") bvals_rename = pe.Node(util.Rename(format_string="DTI_mx_137.bvals"),
def convert(items, anonymizer=None, symlink=True, converter=None): prov_files = [] tmpdir = mkdtemp() for item in items: if isinstance(item[1], (list, tuple)): outtypes = item[1] else: outtypes = [item[1]] prefix = item[0] print('Converting %s' % prefix) dirname = os.path.dirname(prefix + '.ext') print(dirname) if not os.path.exists(dirname): os.makedirs(dirname) for outtype in outtypes: print(outtype) if outtype == 'dicom': dicomdir = prefix + '_dicom' if os.path.exists(dicomdir): shutil.rmtree(dicomdir) os.mkdir(dicomdir) for filename in item[2]: outfile = os.path.join(dicomdir, os.path.split(filename)[1]) if not os.path.islink(outfile): if symlink: os.symlink(filename, outfile) else: os.link(filename, outfile) elif outtype in ['nii', 'nii.gz']: outname = prefix + '.' + outtype scaninfo = prefix + '_scaninfo.json' if not os.path.exists(outname): from nipype import config config.enable_provenance() from nipype import Function, Node from nipype.interfaces.base import isdefined print converter if converter == 'mri_convert': from nipype.interfaces.freesurfer.preprocess import MRIConvert convertnode = Node(MRIConvert(), name = 'convert') convertnode.base_dir = tmpdir if outtype == 'nii.gz': convertnode.inputs.out_type = 'niigz' convertnode.inputs.in_file = item[2][0] convertnode.inputs.out_file = outname #cmd = 'mri_convert %s %s' % (item[2][0], outname) #print(cmd) #os.system(cmd) res=convertnode.run() elif converter == 'dcm2nii': from nipype.interfaces.dcm2nii import Dcm2nii convertnode = Node(Dcm2nii(), name='convert') convertnode.base_dir = tmpdir convertnode.inputs.source_names = item[2] convertnode.inputs.gzip_output = outtype == 'nii.gz' convertnode.inputs.terminal_output = 'allatonce' res = convertnode.run() if isinstance(res.outputs.converted_files, list): print("Cannot convert dicom files - series likely has multiple orientations: ", item[2]) continue else: shutil.copyfile(res.outputs.converted_files, outname) if isdefined(res.outputs.bvecs): outname_bvecs = prefix + '.bvecs' outname_bvals = prefix + '.bvals' shutil.copyfile(res.outputs.bvecs, outname_bvecs) shutil.copyfile(res.outputs.bvals, outname_bvals) prov_file = prefix + '_prov.ttl' shutil.copyfile(os.path.join(convertnode.base_dir, convertnode.name, 'provenance.ttl'), prov_file) prov_files.append(prov_file) embedfunc = Node(Function(input_names=['dcmfiles', 'niftifile', 'infofile', 'force'], output_names=['outfile', 'meta'], function=embed_nifti), name='embedder') embedfunc.inputs.dcmfiles = item[2] embedfunc.inputs.niftifile = outname embedfunc.inputs.infofile = scaninfo embedfunc.inputs.force = True embedfunc.base_dir = tmpdir res = embedfunc.run() g = res.provenance.rdf() g.parse(prov_file, format='turtle') g.serialize(prov_file, format='turtle') #out_file, meta_dict = embed_nifti(item[2], outname, force=True) os.chmod(outname, 0440) os.chmod(scaninfo, 0440) os.chmod(prov_file, 0440) shutil.rmtree(tmpdir)
## quick & basic converter for my own MRI files to swap into nifti from dicoms ## I deserve this for sitting in MRI scanner for an hour from nipype.interfaces.dcm2nii import Dcm2nii import networkx converter = Dcm2nii() # throw inputs here converter.inputs.source_names = ['./../ute/E5466S1I1.DCM'] # says this is a good idea online bc of size/compression converter.inputs.gzip_output = True converter.inputs.output_dir = '.' converter.cmdline 'dcm2nii -a y -c y -b config.ini -v y -d y -e y -g y -i n -n y -o . -p y -x n -f n /../ute/E5466S1I1.DCM'
def Couple_Preproc_Pipeline(base_dir=None, output_dir=None, subject_id=None, spm_path=None): """ Create a preprocessing workflow for the Couples Conflict Study using nipype Args: base_dir: path to data folder where raw subject folder is located output_dir: path to where key output files should be saved subject_id: subject_id (str) spm_path: path to spm folder Returns: workflow: a nipype workflow that can be run """ from nipype.interfaces.dcm2nii import Dcm2nii from nipype.interfaces.fsl import Merge, TOPUP, ApplyTOPUP import nipype.interfaces.io as nio import nipype.interfaces.utility as util from nipype.interfaces.utility import Merge as Merge_List from nipype.pipeline.engine import Node, Workflow from nipype.interfaces.fsl.maths import UnaryMaths from nipype.interfaces.nipy.preprocess import Trim from nipype.algorithms.rapidart import ArtifactDetect from nipype.interfaces import spm from nipype.interfaces.spm import Normalize12 from nipype.algorithms.misc import Gunzip from nipype.interfaces.nipy.preprocess import ComputeMask import nipype.interfaces.matlab as mlab from nltools.utils import get_resource_path, get_vox_dims, get_n_volumes from nltools.interfaces import Plot_Coregistration_Montage, PlotRealignmentParameters, Create_Covariates import os import glob ######################################## ## Setup Paths and Nodes ######################################## # Specify Paths canonical_file = os.path.join(spm_path, 'canonical', 'single_subj_T1.nii') template_file = os.path.join(spm_path, 'tpm', 'TPM.nii') # Set the way matlab should be called mlab.MatlabCommand.set_default_matlab_cmd("matlab -nodesktop -nosplash") mlab.MatlabCommand.set_default_paths(spm_path) # Get File Names for different types of scans. Parse into separate processing streams datasource = Node(interface=nio.DataGrabber( infields=['subject_id'], outfields=['struct', 'ap', 'pa']), name='datasource') datasource.inputs.base_directory = base_dir datasource.inputs.template = '*' datasource.inputs.field_template = { 'struct': '%s/Study*/t1w_32ch_mpr_08mm*', 'ap': '%s/Study*/distortion_corr_32ch_ap*', 'pa': '%s/Study*/distortion_corr_32ch_pa*' } datasource.inputs.template_args = { 'struct': [['subject_id']], 'ap': [['subject_id']], 'pa': [['subject_id']] } datasource.inputs.subject_id = subject_id datasource.inputs.sort_filelist = True # iterate over functional scans to define paths scan_file_list = glob.glob( os.path.join(base_dir, subject_id, 'Study*', '*')) func_list = [s for s in scan_file_list if "romcon_ap_32ch_mb8" in s] func_list = [s for s in func_list if "SBRef" not in s] # Exclude sbref for now. func_source = Node(interface=util.IdentityInterface(fields=['scan']), name="func_source") func_source.iterables = ('scan', func_list) # Create Separate Converter Nodes for each different type of file. (dist corr scans need to be done before functional) ap_dcm2nii = Node(interface=Dcm2nii(), name='ap_dcm2nii') ap_dcm2nii.inputs.gzip_output = True ap_dcm2nii.inputs.output_dir = '.' ap_dcm2nii.inputs.date_in_filename = False pa_dcm2nii = Node(interface=Dcm2nii(), name='pa_dcm2nii') pa_dcm2nii.inputs.gzip_output = True pa_dcm2nii.inputs.output_dir = '.' pa_dcm2nii.inputs.date_in_filename = False f_dcm2nii = Node(interface=Dcm2nii(), name='f_dcm2nii') f_dcm2nii.inputs.gzip_output = True f_dcm2nii.inputs.output_dir = '.' f_dcm2nii.inputs.date_in_filename = False s_dcm2nii = Node(interface=Dcm2nii(), name='s_dcm2nii') s_dcm2nii.inputs.gzip_output = True s_dcm2nii.inputs.output_dir = '.' s_dcm2nii.inputs.date_in_filename = False ######################################## ## Setup Nodes for distortion correction ######################################## # merge output files into list merge_to_file_list = Node(interface=Merge_List(2), infields=['in1', 'in2'], name='merge_to_file_list') # fsl merge AP + PA files (depends on direction) merger = Node(interface=Merge(dimension='t'), name='merger') merger.inputs.output_type = 'NIFTI_GZ' # use topup to create distortion correction map topup = Node(interface=TOPUP(), name='topup') topup.inputs.encoding_file = os.path.join(get_resource_path(), 'epi_params_APPA_MB8.txt') topup.inputs.output_type = "NIFTI_GZ" topup.inputs.config = 'b02b0.cnf' # apply topup to all functional images apply_topup = Node(interface=ApplyTOPUP(), name='apply_topup') apply_topup.inputs.in_index = [1] apply_topup.inputs.encoding_file = os.path.join(get_resource_path(), 'epi_params_APPA_MB8.txt') apply_topup.inputs.output_type = "NIFTI_GZ" apply_topup.inputs.method = 'jac' apply_topup.inputs.interp = 'spline' # Clear out Zeros from spline interpolation using absolute value. abs_maths = Node(interface=UnaryMaths(), name='abs_maths') abs_maths.inputs.operation = 'abs' ######################################## ## Preprocessing ######################################## # Trim - remove first 10 TRs n_vols = 10 trim = Node(interface=Trim(), name='trim') trim.inputs.begin_index = n_vols #Realignment - 6 parameters - realign to first image of very first series. realign = Node(interface=spm.Realign(), name="realign") realign.inputs.register_to_mean = True #Coregister - 12 parameters coregister = Node(interface=spm.Coregister(), name="coregister") coregister.inputs.jobtype = 'estwrite' #Plot Realignment plot_realign = Node(interface=PlotRealignmentParameters(), name="plot_realign") #Artifact Detection art = Node(interface=ArtifactDetect(), name="art") art.inputs.use_differences = [True, False] art.inputs.use_norm = True art.inputs.norm_threshold = 1 art.inputs.zintensity_threshold = 3 art.inputs.mask_type = 'file' art.inputs.parameter_source = 'SPM' # Gunzip - unzip the functional and structural images gunzip_struc = Node(Gunzip(), name="gunzip_struc") gunzip_func = Node(Gunzip(), name="gunzip_func") # Normalize - normalizes functional and structural images to the MNI template normalize = Node(interface=Normalize12(jobtype='estwrite', tpm=template_file), name="normalize") #Plot normalization Check plot_normalization_check = Node(interface=Plot_Coregistration_Montage(), name="plot_normalization_check") plot_normalization_check.inputs.canonical_img = canonical_file #Create Mask compute_mask = Node(interface=ComputeMask(), name="compute_mask") #remove lower 5% of histogram of mean image compute_mask.inputs.m = .05 #Smooth #implicit masking (.im) = 0, dtype = 0 smooth = Node(interface=spm.Smooth(), name="smooth") smooth.inputs.fwhm = 6 #Create Covariate matrix make_cov = Node(interface=Create_Covariates(), name="make_cov") # Create a datasink to clean up output files datasink = Node(interface=nio.DataSink(), name='datasink') datasink.inputs.base_directory = output_dir datasink.inputs.container = subject_id ######################################## # Create Workflow ######################################## workflow = Workflow(name='Preprocessed') workflow.base_dir = os.path.join(base_dir, subject_id) workflow.connect([ (datasource, ap_dcm2nii, [('ap', 'source_dir')]), (datasource, pa_dcm2nii, [('pa', 'source_dir')]), (datasource, s_dcm2nii, [('struct', 'source_dir')]), (func_source, f_dcm2nii, [('scan', 'source_dir')]), (ap_dcm2nii, merge_to_file_list, [('converted_files', 'in1')]), (pa_dcm2nii, merge_to_file_list, [('converted_files', 'in2')]), (merge_to_file_list, merger, [('out', 'in_files')]), (merger, topup, [('merged_file', 'in_file')]), (topup, apply_topup, [('out_fieldcoef', 'in_topup_fieldcoef'), ('out_movpar', 'in_topup_movpar')]), (f_dcm2nii, trim, [('converted_files', 'in_file')]), (trim, apply_topup, [('out_file', 'in_files')]), (apply_topup, abs_maths, [('out_corrected', 'in_file')]), (abs_maths, gunzip_func, [('out_file', 'in_file')]), (gunzip_func, realign, [('out_file', 'in_files')]), (s_dcm2nii, gunzip_struc, [('converted_files', 'in_file')]), (gunzip_struc, coregister, [('out_file', 'source')]), (coregister, normalize, [('coregistered_source', 'image_to_align')]), (realign, coregister, [('mean_image', 'target'), ('realigned_files', 'apply_to_files')]), (realign, normalize, [(('mean_image', get_vox_dims), 'write_voxel_sizes')]), (coregister, normalize, [('coregistered_files', 'apply_to_files')]), (normalize, smooth, [('normalized_files', 'in_files')]), (realign, compute_mask, [('mean_image', 'mean_volume')]), (compute_mask, art, [('brain_mask', 'mask_file')]), (realign, art, [('realignment_parameters', 'realignment_parameters'), ('realigned_files', 'realigned_files')]), (realign, plot_realign, [('realignment_parameters', 'realignment_parameters')]), (normalize, plot_normalization_check, [('normalized_files', 'wra_img') ]), (realign, make_cov, [('realignment_parameters', 'realignment_parameters')]), (art, make_cov, [('outlier_files', 'spike_id')]), (normalize, datasink, [('normalized_files', 'structural.@normalize')]), (coregister, datasink, [('coregistered_source', 'structural.@struct') ]), (topup, datasink, [('out_fieldcoef', 'distortion.@fieldcoef')]), (topup, datasink, [('out_movpar', 'distortion.@movpar')]), (smooth, datasink, [('smoothed_files', 'functional.@smooth')]), (plot_realign, datasink, [('plot', 'functional.@plot_realign')]), (plot_normalization_check, datasink, [('plot', 'functional.@plot_normalization')]), (make_cov, datasink, [('covariates', 'functional.@covariates')]) ]) return workflow
def test_Dcm2nii_inputs(): input_map = dict( anonymize=dict( argstr='-a', usedefault=True, ), args=dict(argstr='%s', ), collapse_folders=dict( argstr='-c', usedefault=True, ), config_file=dict( argstr='-b %s', genfile=True, ), convert_all_pars=dict( argstr='-v', usedefault=True, ), date_in_filename=dict( argstr='-d', usedefault=True, ), environ=dict( nohash=True, usedefault=True, ), events_in_filename=dict( argstr='-e', usedefault=True, ), gzip_output=dict( argstr='-g', usedefault=True, ), id_in_filename=dict( argstr='-i', usedefault=True, ), ignore_exception=dict( nohash=True, usedefault=True, ), nii_output=dict( argstr='-n', usedefault=True, ), output_dir=dict( argstr='-o %s', genfile=True, ), protocol_in_filename=dict( argstr='-p', usedefault=True, ), reorient=dict(argstr='-r', ), reorient_and_crop=dict( argstr='-x', usedefault=True, ), source_dir=dict( argstr='%s', mandatory=True, position=-1, xor=['source_names'], ), source_in_filename=dict( argstr='-f', usedefault=True, ), source_names=dict( argstr='%s', copyfile=False, mandatory=True, position=-1, xor=['source_dir'], ), spm_analyze=dict( argstr='-s', xor=['nii_output'], ), terminal_output=dict( mandatory=True, nohash=True, ), ) inputs = Dcm2nii.input_spec() for key, metadata in input_map.items(): for metakey, value in metadata.items(): yield assert_equal, getattr(inputs.traits()[key], metakey), value
### Grey Matter / White Matter post processing pipeline for T1/T2 weighted images ## based on commandline protocol from nipype.interfaces.dcm2nii import Dcm2nii import nipype.interfaces.fsl as fsl import nipype.pipeline.engine as pe import nipype.interfaces.io as nio converter = Dcm2nii() converter.inputs.source_names = ['E5466S1I1.DCM'] convert = pe.MapNode(interface=Dcm2nii(), name='conv', iterfield=['source_names']) # skull stripping bet = pe.MapNode(interface=fsl.BET(), name = 'bet', iterfield=['frac']) bet.inputs.frac = [0.8, 0.5, 0.2] # segmentation fast = pe.MapNode(interface=fsl.FAST(), name='fast', iterfield=['in_files']) # registration flirt = pe.MapNode(interface=fsl.FLIRT(), name='flirt', iterfield=['in_file']) ds = pe.Node(interface=nio.DataSink(), name="ds", iterfield=['in_files']) ds.inputs.base_directory = '.' workflow = pe.Workflow(name='T1_T2_Segmentation') workflow.base_dir = './output'
# <codecell> from glob import glob from nipype.interfaces.dcm2nii import Dcm2nii from nipype.interfaces.fsl import DTIFit, BET import nipype.pipeline.engine as pe # <markdowncell> # ### Version 2: Mapnodes # <codecell> convert = pe.MapNode(Dcm2nii(), name='convert_dicom', iterfield=['source_names']) skull_stripper = pe.MapNode(BET(mask=True), name='skull_stripper', iterfield=['in_file']) dtifit = pe.MapNode(DTIFit(), name='dtifit', iterfield=['dwi', 'bvals', 'bvecs', 'mask']) convert_flow = pe.Workflow(name='convert_and_fit_mapnode') convert_flow.connect([ (convert, dtifit, [('converted_files', 'dwi'), ('bvals', 'bvals'), ('bvecs', 'bvecs')]), (convert, skull_stripper, [('converted_files', 'in_file')]), (skull_stripper, dtifit, [('mask_file', 'mask')])
# Convert the T1 mgz image to nifti format for later usage mriConverter = Node(freesurfer.preprocess.MRIConvert(), name='convertAparcAseg') #convertT1.inputs.out_file = subPath + reconallFolderName + '/mri/aparc+aseg.nii.gz' mriConverter.inputs.out_type = 'niigz' mriConverter.inputs.out_orientation = 'RAS' # ### Diffusion Data (dwMRI) preprocessing # In[ ]: # First extract the diffusion vectors and the pulse intensity (bvec and bval) # Use dcm2nii for this task #dwiFinderNode = t1FinderNode.clone('dwiFinder') dcm2niiNode = Node(Dcm2nii(), name='dcm2niiAndBvecs') dcm2niiNode.inputs.gzip_output = True dcm2niiNode.inputs.date_in_filename = False dcm2niiNode.inputs.events_in_filename = False # Extract the first image of the DTI series i.e. the b0 image extrctB0Node = Node(Function(input_names=['dwMriFile'], output_names=['b0'], function=extractB0), name='Extract_b0') # Perform the registration between subject T1 space and dwMRI space bbregNode = Node(freesurfer.preprocess.BBRegister(), name='BBRegister') bbregNode.inputs.init = "fsl" bbregNode.inputs.contrast_type = "t2" bbregNode.inputs.epi_mask = True
def create_gif_pseudoct_workflow(in_ute_echo2_file, in_ute_umap_dir, in_db_file, cpp_dir, in_t1_file=None, in_t2_file=None, in_mask_file=None, in_nac_pet_dir=None, name='gif_pseudoct'): """create_niftyseg_gif_propagation_pipeline. @param in_ute_echo2_file input UTE echo file @param in_ute_umap_dir input UTE umap file @param in_db_file input database xml file for the GIF algorithm @param cpp_dir cpp directory @param in_t1_file input T1 target file @param in_t2_file input T2 target file @param in_mask_file optional input mask for the target T1 file @param name optional name of the pipeline """ in_file = in_t1_file if in_t1_file else in_t2_file subject_id = split_filename(os.path.basename(in_file))[1] workflow = pe.Workflow(name=name) workflow.base_output_dir = name gif = pe.Node(interface=Gif(database_file=in_db_file, cpp_dir=cpp_dir, lncc_ker=3, regNMI=True, regBE=0.01), name='gif') if in_mask_file: gif.inputs.mask_file = in_mask_file # Create empty masks for the bias correction to cover the full image t1_full_mask = pe.Node(interface=niu.Function(input_names=['in_file'], output_names=['out_file'], function=create_full_mask), name='t1_full_mask') t1_full_mask.inputs.in_file = in_t1_file t2_full_mask = pe.Node(interface=niu.Function(input_names=['in_file'], output_names=['out_file'], function=create_full_mask), name='t2_full_mask') t2_full_mask.inputs.in_file = in_t2_file # Create bias correction nodes that are adapted to our needs. i.e. Boost the T2 bias correction bias_correction_t1 = pe.Node(interface=N4BiasCorrection(), name='bias_correction_t1') if in_t1_file: bias_correction_t1.inputs.in_file = in_t1_file # Create bias correction nodes that are adapted to our needs. i.e. Boost the T2 bias correction bias_correction_t2 = pe.Node(interface=N4BiasCorrection( in_maxiter=300, in_convergence=0.0001), name='bias_correction_t2') if in_t2_file: bias_correction_t2.inputs.in_file = in_t2_file # Only connect the nodes if the input image exist respectively if in_t1_file: workflow.connect(t1_full_mask, 'out_file', bias_correction_t1, 'mask_file') if in_t2_file: workflow.connect(t2_full_mask, 'out_file', bias_correction_t2, 'mask_file') if in_t1_file and in_t2_file: affine_mr_target = pe.Node(interface=niftyreg.RegAladin(maxit_val=10), name='affine_mr_target') workflow.connect(bias_correction_t1, 'out_file', affine_mr_target, 'ref_file') workflow.connect(bias_correction_t2, 'out_file', affine_mr_target, 'flo_file') resample_mr_target = pe.Node( interface=niftyreg.RegResample(pad_val=float('nan')), name='resample_MR_target') workflow.connect(bias_correction_t1, 'out_file', resample_mr_target, 'ref_file') workflow.connect(bias_correction_t2, 'out_file', resample_mr_target, 'flo_file') lister = pe.Node(interface=niu.Merge(2), name='lister') merger = pe.Node(interface=fsl.Merge(dimension='t', output_type='NIFTI_GZ'), name='fsl_merge') workflow.connect(affine_mr_target, 'aff_file', resample_mr_target, 'trans_file') workflow.connect(bias_correction_t1, 'out_file', lister, 'in1') workflow.connect(resample_mr_target, 'out_file', lister, 'in2') workflow.connect(lister, 'out', merger, 'in_files') workflow.connect(merger, 'merged_file', gif, 'in_file') else: if in_t1_file: workflow.connect(bias_correction_t1, 'out_file', gif, 'in_file') if in_t2_file: workflow.connect(bias_correction_t2, 'out_file', gif, 'in_file') pct_hu_to_umap = pe.Node(interface=niu.Function( input_names=['pCT_file', 'structural_mri_file', 'ute_echo2_file'], output_names=['pct_umap_file'], function=convert_pct_hu_to_umap), name='pCT_HU_to_umap') pct_hu_to_umap.inputs.structural_mri_file = in_file pct_hu_to_umap.inputs.ute_echo2_file = in_ute_echo2_file workflow.connect(gif, 'synth_file', pct_hu_to_umap, 'pCT_file') pct2dcm_pct_umap = pe.Node(interface=Pct2Dcm(in_umap_name='pCT_umap'), name='pct2dcm_pct_umap') workflow.connect(pct_hu_to_umap, 'pct_umap_file', pct2dcm_pct_umap, 'in_umap_file') pct2dcm_pct_umap.inputs.in_ute_umap_dir = os.path.abspath(in_ute_umap_dir) merger_output_number = 2 pct2dcm_ute_umap_end = None pct2dcm_pct_umap_end = None if in_nac_pet_dir: ute_umap_dcm2nii = pe.Node( interface=Dcm2nii(source_dir=in_ute_umap_dir), name='ute_umap_dcm2nii') first_item_selector = pe.Node(interface=niu.Select(index=0), name='first_item_selector') workflow.connect(ute_umap_dcm2nii, 'converted_files', first_item_selector, 'inlist') nac_extractor = pe.Node(interface=niu.Function( input_names=['dicom_folder'], output_names=['nifti_file'], function=extract_nac_pet), name='nac_extractor') nac_extractor.inputs.dicom_folder = in_nac_pet_dir ute_to_nac_registration = pe.Node( interface=niftyreg.RegAladin(rig_only_flag=True), name='ute_to_nac_registration') workflow.connect(nac_extractor, 'nifti_file', ute_to_nac_registration, 'ref_file') ute_to_nac_registration.inputs.flo_file = in_ute_echo2_file ute_resample = pe.Node(interface=niftyreg.RegResample(), name='ute_resample') workflow.connect(first_item_selector, 'out', ute_resample, 'ref_file') workflow.connect(first_item_selector, 'out', ute_resample, 'flo_file') workflow.connect(ute_to_nac_registration, 'aff_file', ute_resample, 'aff_file') pct2dcm_ute_umap_end = pe.Node( interface=Pct2Dcm(in_umap_name='UTE_umap_end'), name='pct2dcm_ute_umap_end') workflow.connect(ute_resample, 'res_file', pct2dcm_ute_umap_end, 'in_umap_file') pct2dcm_ute_umap_end.inputs.in_ute_umap_dir = os.path.abspath( in_ute_umap_dir) pct_resample = pe.Node(interface=niftyreg.RegResample(), name='pct_resample') workflow.connect(pct_hu_to_umap, 'pct_umap_file', pct_resample, 'ref_file') workflow.connect(pct_hu_to_umap, 'pct_umap_file', pct_resample, 'flo_file') workflow.connect(ute_to_nac_registration, 'aff_file', pct_resample, 'aff_file') pct2dcm_pct_umap_end = pe.Node( interface=Pct2Dcm(in_umap_name='pCT_umap_end'), name='pct2dcm_pct_umap_end') workflow.connect(pct_resample, 'res_file', pct2dcm_pct_umap_end, 'in_umap_file') pct2dcm_pct_umap_end.inputs.in_ute_umap_dir = os.path.abspath( in_ute_umap_dir) merger_output_number = 4 # merge output output_merger = pe.Node( interface=niu.Merge(numinputs=merger_output_number), name='output_merger') workflow.connect(gif, 'synth_file', output_merger, 'in1') workflow.connect(pct2dcm_pct_umap, 'output_file', output_merger, 'in2') renamer = pe.Node(interface=niu.Rename(format_string=subject_id + "_%(type)s", keep_ext=True), name='renamer') if in_nac_pet_dir: workflow.connect(pct2dcm_ute_umap_end, 'output_file', output_merger, 'in3') workflow.connect(pct2dcm_pct_umap_end, 'output_file', output_merger, 'in4') renamer.inputs.type = ['synth', 'pct', 'ute_end', 'pct_end'] else: renamer.inputs.type = ['synth', 'pct'] workflow.connect(output_merger, 'out', renamer, 'in_file') return workflow
def test_Dcm2nii_inputs(): input_map = dict(anonymize=dict(argstr='-a', usedefault=True, ), args=dict(argstr='%s', ), collapse_folders=dict(argstr='-c', usedefault=True, ), config_file=dict(argstr='-b %s', genfile=True, ), convert_all_pars=dict(argstr='-v', usedefault=True, ), date_in_filename=dict(argstr='-d', usedefault=True, ), environ=dict(nohash=True, usedefault=True, ), events_in_filename=dict(argstr='-e', usedefault=True, ), gzip_output=dict(argstr='-g', usedefault=True, ), id_in_filename=dict(argstr='-i', usedefault=True, ), ignore_exception=dict(nohash=True, usedefault=True, ), nii_output=dict(argstr='-n', usedefault=True, ), output_dir=dict(argstr='-o %s', genfile=True, ), protocol_in_filename=dict(argstr='-p', usedefault=True, ), reorient=dict(argstr='-r', ), reorient_and_crop=dict(argstr='-x', usedefault=True, ), source_dir=dict(argstr='%s', mandatory=True, position=-1, xor=['source_names'], ), source_in_filename=dict(argstr='-f', usedefault=True, ), source_names=dict(argstr='%s', copyfile=False, mandatory=True, position=-1, xor=['source_dir'], ), spm_analyze=dict(argstr='-s', xor=['nii_output'], ), terminal_output=dict(nohash=True, ), ) inputs = Dcm2nii.input_spec() for key, metadata in input_map.items(): for metakey, value in metadata.items(): yield assert_equal, getattr(inputs.traits()[key], metakey), value