def mgh2nii(filename, path_output, out_type="nii"): """ This function converts a volume file from freesurfer mgh to nifti format. Inputs: *filename: full path of the input file. *path_outupt: path where output is written. *out_type: target type of file. created by Daniel Haenelt Date created: 06-01-2020 Last modified: 24-07-2020 """ import os from nipype.interfaces.freesurfer.preprocess import MRIConvert from lib.io.get_filename import get_filename # get filename path, name, ext = get_filename(filename) # convert volume to nifti format mc = MRIConvert() mc.inputs.in_file = filename mc.inputs.out_file = os.path.join(path_output, name + "." + out_type) mc.inputs.in_type = ext.replace('.', '') mc.inputs.out_type = out_type mc.run()
def upsample_mask_tissues(in_file): """ To upsample the 1,2,3 compartment segmented volume in SPM Args: in_file: a list containing the three compartments Returns: """ import os from nipype.interfaces.freesurfer.preprocess import MRIConvert out_file = [] if isinstance(in_file, basestring): # just one compartment out_mask = os.path.basename(in_file).split('.nii.gz')[0] + '_upsample.nii.gz' mc = MRIConvert() mc.inputs.in_file = in_file mc.inputs.out_file = out_mask mc.inputs.vox_size = (1, 1, 1) mc.run() out_file.append(os.path.abspath(os.path.join(os.getcwd(), out_mask))) else: # more than one compartment for tissue in in_file: out_mask = os.path.basename(tissue).split('.nii.gz')[0] + '_upsample.nii.gz' mc = MRIConvert() mc.inputs.in_file = tissue mc.inputs.out_file = out_mask mc.inputs.vox_size = (1, 1, 1) mc.run() out_file.append(os.path.abspath(os.path.join(os.getcwd(), out_mask))) return out_file
def preprocess(input_file, output_dir, conform=True, bias_correct=True, skullstrip=True): preprocess_flow = Workflow(name='preprocess', base_dir=output_dir) conform = Node(MRIConvert(conform=True, out_type='niigz', out_file='conformed.nii.gz'), name='conform') n4 = Node(N4BiasFieldCorrection(dimension=3, bspline_fitting_distance=300, shrink_factor=3, n_iterations=[50, 50, 30, 20], output_image='n4.nii.gz'), name='n4') robex = Node(ROBEX(seed=1729, stripped_image='brain.nii.gz'), name='robex') preprocess_flow.connect([(conform, n4, [('out_file', 'input_image')]), (n4, robex, [('output_image', 'input_image')])]) preprocess_flow.write_graph(graph2use='orig') conform.inputs.in_file = input_file preprocess_flow.run('MultiProc', plugin_args={'n_procs': 5})
def test_MRIConvert_outputs(): output_map = dict(out_file=dict(), ) outputs = MRIConvert.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 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)
def psacnn_workflow(input_file, output_dir, use_preprocess=True, model_file=None, contrast='t1w', use_gpu=True, gpu_id=0, save_label_image=False, save_prob_image=False, patch_size=96, batch_size=4, sample_rate=20000): subprocess.call(['mkdir', '-p', output_dir]) if use_gpu == False: os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"] = "" gpu_id = -1 batch_size = 16 sample_rate = 40000 else: os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id) batch_size = 4 sample_rate = 20000 if use_preprocess == True: preprocess_flow = Workflow(name='preprocess', base_dir=output_dir) conform = Node(MRIConvert(conform=True, out_type='niigz', out_file='conformed.nii.gz'), name='conform') n4 = Node(N4BiasFieldCorrection(dimension=3, bspline_fitting_distance=300, shrink_factor=3, n_iterations=[50, 50, 30, 20], output_image='n4.nii.gz'), name='n4') robex = Node(ROBEX(seed=1729, stripped_image='brain.nii.gz'), name='robex') psacnn = Node(PSACNN(output_dir=output_dir, contrast=contrast, patch_size=patch_size, batch_size=batch_size, save_label_image=save_label_image, save_prob_image=save_prob_image, sample_rate=sample_rate), name='psacnn') preprocess_flow.connect([ (conform, n4, [('out_file', 'input_image')]), (n4, robex, [('output_image', 'input_image')]), (robex, psacnn, [('stripped_image', 'input_image')]) ]) preprocess_flow.write_graph(graph2use='orig') conform.inputs.in_file = input_file preprocess_flow.run('MultiProc', plugin_args={'n_procs': 16}) else: psacnn = PSACNN(input_image=input_file, output_dir=output_dir, contrast=contrast, patch_size=patch_size, batch_size=batch_size, save_label_image=save_label_image, save_prob_image=save_prob_image, sample_rate=sample_rate) # psacnn.inputs.input_image = input_file # psacnn.inputs.output_dir = output_dir # psacnn.inputs.contrast = contrast # psacnn.inputs.patch_size = patch_size # psacnn.inputs.batch_size = batch_size # psacnn.inputs.save_label_image = save_label_image # psacnn.inputs.save_prob_image = save_prob_image # psacnn.inputs.sample_rate = sample_rate psacnn.run()
def test_MRIConvert_inputs(): input_map = dict(apply_inv_transform=dict(argstr='--apply_inverse_transform %s', ), apply_transform=dict(argstr='--apply_transform %s', ), args=dict(argstr='%s', ), ascii=dict(argstr='--ascii', ), autoalign_matrix=dict(argstr='--autoalign %s', ), color_file=dict(argstr='--color_file %s', ), conform=dict(argstr='--conform', ), conform_min=dict(argstr='--conform_min', ), conform_size=dict(argstr='--conform_size %s', ), crop_center=dict(argstr='--crop %d %d %d', ), crop_gdf=dict(argstr='--crop_gdf', ), crop_size=dict(argstr='--cropsize %d %d %d', ), cut_ends=dict(argstr='--cutends %d', ), devolve_transform=dict(argstr='--devolvexfm %s', ), drop_n=dict(argstr='--ndrop %d', ), environ=dict(nohash=True, usedefault=True, ), fill_parcellation=dict(argstr='--fill_parcellation', ), force_ras=dict(argstr='--force_ras_good', ), frame=dict(argstr='--frame %d', ), frame_subsample=dict(argstr='--fsubsample %d %d %d', ), fwhm=dict(argstr='--fwhm %f', ), ignore_exception=dict(nohash=True, usedefault=True, ), in_center=dict(argstr='--in_center %s', ), in_file=dict(argstr='--input_volume %s', mandatory=True, position=-2, ), in_i_dir=dict(argstr='--in_i_direction %f %f %f', ), in_i_size=dict(argstr='--in_i_size %d', ), in_info=dict(argstr='--in_info', ), in_j_dir=dict(argstr='--in_j_direction %f %f %f', ), in_j_size=dict(argstr='--in_j_size %d', ), in_k_dir=dict(argstr='--in_k_direction %f %f %f', ), in_k_size=dict(argstr='--in_k_size %d', ), in_like=dict(argstr='--in_like %s', ), in_matrix=dict(argstr='--in_matrix', ), in_orientation=dict(argstr='--in_orientation %s', ), in_scale=dict(argstr='--scale %f', ), in_stats=dict(argstr='--in_stats', ), in_type=dict(argstr='--in_type %s', ), invert_contrast=dict(argstr='--invert_contrast %f', ), midframe=dict(argstr='--mid-frame', ), no_change=dict(argstr='--nochange', ), no_scale=dict(argstr='--no_scale 1', ), no_translate=dict(argstr='--no_translate', ), no_write=dict(argstr='--no_write', ), out_center=dict(argstr='--out_center %f %f %f', ), out_datatype=dict(argstr='--out_data_type %s', ), out_file=dict(argstr='--output_volume %s', genfile=True, position=-1, ), out_i_count=dict(argstr='--out_i_count %d', ), out_i_dir=dict(argstr='--out_i_direction %f %f %f', ), out_i_size=dict(argstr='--out_i_size %d', ), out_info=dict(argstr='--out_info', ), out_j_count=dict(argstr='--out_j_count %d', ), out_j_dir=dict(argstr='--out_j_direction %f %f %f', ), out_j_size=dict(argstr='--out_j_size %d', ), out_k_count=dict(argstr='--out_k_count %d', ), out_k_dir=dict(argstr='--out_k_direction %f %f %f', ), out_k_size=dict(argstr='--out_k_size %d', ), out_matrix=dict(argstr='--out_matrix', ), out_orientation=dict(argstr='--out_orientation %s', ), out_scale=dict(argstr='--out-scale %d', ), out_stats=dict(argstr='--out_stats', ), out_type=dict(argstr='--out_type %s', ), parse_only=dict(argstr='--parse_only', ), read_only=dict(argstr='--read_only', ), reorder=dict(argstr='--reorder %d %d %d', ), resample_type=dict(argstr='--resample_type %s', ), reslice_like=dict(argstr='--reslice_like %s', ), sdcm_list=dict(argstr='--sdcmlist %s', ), skip_n=dict(argstr='--nskip %d', ), slice_bias=dict(argstr='--slice-bias %f', ), slice_crop=dict(argstr='--slice-crop %d %d', ), slice_reverse=dict(argstr='--slice-reverse', ), smooth_parcellation=dict(argstr='--smooth_parcellation', ), sphinx=dict(argstr='--sphinx', ), split=dict(argstr='--split', ), status_file=dict(argstr='--status %s', ), subject_name=dict(argstr='--subject_name %s', ), subjects_dir=dict(), template_info=dict(), template_type=dict(argstr='--template_type %s', ), terminal_output=dict(nohash=True, ), unwarp_gradient=dict(argstr='--unwarp_gradient_nonlinearity', ), vox_size=dict(argstr='-voxsize %f %f %f', ), zero_ge_z_offset=dict(argstr='--zero_ge_z_offset', ), zero_outlines=dict(argstr='--zero_outlines', ), ) inputs = MRIConvert.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 create_t1_based_unwarp(name='unwarp'): """ Unwarp an fMRI time series based on non-linear registration to T1. NOTE: AS IT STANDS THIS METHOD DID NOT PRODUCE ACCEPTABLE RESULTS IF BRAIN COVERAGE IS NOT COMPLETE ON THE EPI IMAGE. ALSO: NEED TO ADD AUTOMATIC READING OF EPI RESOLUTION TO GET """ unwarpflow = pe.Workflow(name=name) inputnode = pe.Node( interface=util.IdentityInterface(fields=['epi', 'T1W']), name='inputspec') outputnode = pe.Node(interface=util.IdentityInterface( fields=['unwarped_func', 'warp_files']), name='outputspec') tmedian = pe.Node(interface=ImageMaths(), name='tmedian') tmedian.inputs.op_string = '-Tmedian' epi_brain_ext = pe.Node(interface=util.Function( function=epi_brain_extract, input_names=['in_file'], output_names=['out_vol', 'out_mask']), name='epi_brain_ext') fast_debias = pe.Node(interface=FAST(), name='FAST_debias') fast_debias.inputs.output_biascorrected = True robex = pe.Node(interface=util.Function( function=my_robex, input_names=['in_file'], output_names=['out_file', 'out_mask']), name='robex') downsample_T1 = pe.Node(MRIConvert(), name='downsample_dti') downsample_T1.inputs.vox_size = (3.438, 3.438, 3.000) downsample_T1.inputs.out_type = 'niigz' contrast_invert = pe.Node(interface=util.Function( function=invert_contrast, input_names=['in_t1_brain', 'in_b0_brain'], output_names=['out_fn']), name='contrast_invert') ants_syn = pe.Node(interface=util.Function( function=my_ants_registration_syn, input_names=['in_T1W', 'in_epi'], output_names=['out_transforms']), name='ants_syn') ants_warp = pe.Node(interface=WarpTimeSeriesImageMultiTransform(), name='ants_warp') '''connections''' # unwarpflow.connect(inputnode, 'T1W', robex, 'in_file') unwarpflow.connect(inputnode, 'T1W', fast_debias, 'in_files') # unwarpflow.connect(robex, 'out_file', fast_debias, 'in_files') unwarpflow.connect(fast_debias, 'restored_image', robex, 'in_file') # unwarpflow.connect(fast_debias, 'restored_image', downsample_T1, 'in_file') unwarpflow.connect(robex, 'out_file', downsample_T1, 'in_file') unwarpflow.connect(downsample_T1, 'out_file', contrast_invert, 'in_t1_brain') unwarpflow.connect(inputnode, 'epi', tmedian, 'in_file') unwarpflow.connect(tmedian, 'out_file', epi_brain_ext, 'in_file') unwarpflow.connect(epi_brain_ext, 'out_vol', contrast_invert, 'in_b0_brain') unwarpflow.connect(contrast_invert, 'out_fn', ants_syn, 'in_T1W') unwarpflow.connect(epi_brain_ext, 'out_vol', ants_syn, 'in_epi') unwarpflow.connect(ants_syn, 'out_transforms', outputnode, 'out_transforms') unwarpflow.connect(inputnode, 'epi', ants_warp, 'input_image') unwarpflow.connect(contrast_invert, 'out_fn', ants_warp, 'reference_image') unwarpflow.connect(ants_syn, 'out_transforms', ants_warp, 'transformation_series') unwarpflow.connect(ants_syn, 'out_transforms', outputnode, 'warp_files') unwarpflow.connect(ants_warp, 'output_image', outputnode, 'unwarped_func') return unwarpflow
def get_flash2orig(file_flash, file_inv2, file_orig, path_output, cleanup=False): """ This function computes the deformation field for the registration between a partial coverage GRE image and the freesurfer orig file. The following steps are performed: (1) set output folder structure, (2) get scanner transform GRE <-> inv2 and inv2 -> orig, (3) generate flash cmap, (4) apply scanner transform inv2 -> GRE, (5) get flirt registration GRE -> inv2, (6) apply flirt to GRE cmap, (7) apply scanner transform to GRE cmap, (8) apply final deformation to GRE. The function needs the FSL environment set. Inputs: *file_flash: input path for GRE image. *file_inv2: input path for MP2RAGE INV2 image. *file_orig: input path for freesurfer orig image. *path_output: path where output is saved. *cleanup: delete intermediate files (boolean). created by Daniel Haenelt Date created: 18-04-2019 Last modified: 16-05-2019 """ import os import shutil as sh from nipype.interfaces.fsl import FLIRT from nipype.interfaces.fsl.preprocess import ApplyXFM from nipype.interfaces.freesurfer.preprocess import MRIConvert from nighres.registration import apply_coordinate_mappings from lib.cmap import generate_coordinate_mapping from lib.registration.get_scanner_transform import get_scanner_transform """ set folder structure """ path_temp = os.path.join(path_output, "temp") if not os.path.exists(path_output): os.makedirs(path_output) if not os.path.exists(path_temp): os.makedirs(path_temp) # copy input files sh.copyfile(file_inv2, os.path.join(path_temp, "inv2.nii")) sh.copyfile(file_flash, os.path.join(path_temp, "flash.nii")) """ convert orig to nifti """ mc = MRIConvert() mc.inputs.in_file = file_orig mc.inputs.out_file = os.path.join(path_temp, "orig.nii") mc.inputs.in_type = "mgz" mc.inputs.out_type = "nii" mc.run() """ scanner transformation """ get_scanner_transform(os.path.join(path_temp, "inv2.nii"), os.path.join(path_temp, "flash.nii"), path_temp, False) get_scanner_transform(os.path.join(path_temp, "flash.nii"), os.path.join(path_temp, "inv2.nii"), path_temp, False) get_scanner_transform(os.path.join(path_temp, "inv2.nii"), os.path.join(path_temp, "orig.nii"), path_temp, False) """ generate coordinate mapping """ generate_coordinate_mapping(os.path.join(path_temp, "flash.nii"), 0, path_temp, "flash", False, True) """ scanner transform inv2 to flash """ apply_coordinate_mappings( os.path.join(path_temp, "inv2.nii"), # input os.path.join(path_temp, "inv2_2_flash_scanner.nii"), # cmap interpolation="linear", # nearest or linear padding="zero", # closest, zero or max save_data=True, # save output data to file (boolean) overwrite=True, # overwrite existing results (boolean) output_dir=path_temp, # output directory file_name= "inv2_apply_scanner" # base name with file extension for output ) """ flirt flash to inv2 """ os.chdir(path_temp) flirt = FLIRT() flirt.inputs.cost_func = "mutualinfo" flirt.inputs.dof = 6 flirt.inputs.interp = "trilinear" # trilinear, nearestneighbour, sinc or spline flirt.inputs.in_file = os.path.join(path_temp, "flash.nii") flirt.inputs.reference = os.path.join(path_temp, "inv2_apply_scanner_def-img.nii.gz") flirt.inputs.output_type = "NIFTI_GZ" flirt.inputs.out_file = os.path.join(path_temp, "flash_apply_flirt_def-img.nii.gz") flirt.inputs.out_matrix_file = os.path.join(path_temp, "flirt_matrix.txt") flirt.run() """ apply flirt to flash cmap """ applyxfm = ApplyXFM() applyxfm.inputs.in_file = os.path.join(path_temp, "cmap_flash.nii") applyxfm.inputs.reference = os.path.join(path_temp, "flash.nii") applyxfm.inputs.in_matrix_file = os.path.join(path_temp, "flirt_matrix.txt") applyxfm.inputs.interp = "trilinear" applyxfm.inputs.padding_size = 0 applyxfm.inputs.output_type = "NIFTI_GZ" applyxfm.inputs.out_file = os.path.join(path_temp, "cmap_apply_flirt_def-img.nii.gz") applyxfm.inputs.apply_xfm = True applyxfm.run() """ apply scanner transform to flash cmap """ apply_coordinate_mappings( os.path.join(path_temp, "cmap_apply_flirt_def-img.nii.gz"), os.path.join(path_temp, "flash_2_inv2_scanner.nii"), # cmap 1 os.path.join(path_temp, "inv2_2_orig_scanner.nii"), # cmap 2 interpolation="linear", # nearest or linear padding="zero", # closest, zero or max save_data=True, # save output data to file (boolean) overwrite=True, # overwrite existing results (boolean) output_dir=path_temp, # output directory file_name= "cmap_apply_scanner" # base name with file extension for output ) """ apply deformation to source image """ apply_coordinate_mappings( os.path.join(path_temp, "flash.nii"), # input os.path.join(path_temp, "cmap_apply_scanner_def-img.nii.gz"), interpolation="linear", # nearest or linear padding="zero", # closest, zero or max save_data=True, # save output data to file (boolean) overwrite=True, # overwrite existing results (boolean) output_dir=path_temp, # output directory file_name= "flash_apply_deformation" # base name with file extension for output ) # rename final deformation examples os.rename(os.path.join(path_temp, "cmap_apply_scanner_def-img.nii.gz"), os.path.join(path_output, "flash2orig.nii.gz")) os.rename( os.path.join(path_temp, "flash_apply_deformation_def-img.nii.gz"), os.path.join(path_output, "flash2orig_example.nii.gz")) # clean intermediate files if cleanup: sh.rmtree(path_temp, ignore_errors=True)
datasink = Node(DataSink(base_directory=t2dir, container=output_dir), name="datasink") substitutions = [('_subject_id_', '')] datasink.inputs.substitutions = substitutions # t2dir = '/autofs/space/bhim_001/users/aj660/PSACNN/data/IXI/T2/' # t2_file_list = sorted(glob.glob(os.path.join(t1dir, '*T2.nii.gz'))) # # input_file = '/autofs/space/bhim_001/users/aj660/PSACNN/data/IXI/T2/IXI002-Guys-0828-T2.nii.gz' # output_dir = '/autofs/space/bhim_001/users/aj660/psacnn_brain_segmentation/test_output/IXI002-Guys-0828-T2' # subprocess.call(['mkdir', '-p', output_dir]) preprocess_flow = Workflow(name='preprocess', base_dir=output_dir) conform = Node(MRIConvert(conform=True, out_type='niigz', out_file='conformed.nii.gz'), name='conform') n4 = Node(N4BiasFieldCorrection(dimension=3, bspline_fitting_distance=300, shrink_factor=3, n_iterations=[50, 50, 30, 20], output_image='n4.nii.gz'), name='n4') robex = Node(ROBEX(seed=1729, stripped_image='brain.nii.gz'), name='robex') preprocess_flow.connect([ (infosource, selectfiles, [('subject_id', 'subject_id')]), (selectfiles, conform, [('anat', 'in_file')]), (conform, n4, [('out_file', 'input_image')]), (n4, robex, [('output_image', 'input_image')]),
def get_nuisance_mask(input, pathSPM, deformation, path_output, nerode_white=1, nerode_csf=1, segmentation=True, cleanup=True): """ This function calculates WM and CSF masks in space of the functional time series. It uses SPM to compute WM and CSF probability maps. These maps are masked with a skullstrip mask and transformed to native epi space. Inputs: *input: input anatomy (orig.mgz). *pathSPM: path to spm toolbox. *deformation: coordinate mapping for ana to epi transformation. *path_output: path where output is saved. *nerode_white: number of wm mask eroding steps. *nerode_csf: number of csf mask eroding steps. *segmentation: do not calculate new masks to not rerun everything. *cleanup: delete intermediate files. created by Daniel Haenelt Date created: 01-03-2019 Last modified: 01-03-2019 """ import os import shutil as sh import nibabel as nb from scipy.ndimage.morphology import binary_erosion from nipype.interfaces.fsl import BET from nipype.interfaces.freesurfer.preprocess import MRIConvert from nighres.registration import apply_coordinate_mappings from lib.skullstrip.skullstrip_spm12 import skullstrip_spm12 # make output folder if not os.path.exists(path_output): os.mkdir(path_output) # get filename without file extension of input file file = os.path.splitext(os.path.basename(input))[0] # convert to nifti format mc = MRIConvert() mc.inputs.in_file = input mc.inputs.out_file = os.path.join(path_output, file + ".nii") mc.inputs.out_type = "nii" mc.run() # bet skullstrip mask btr = BET() btr.inputs.in_file = os.path.join(path_output, file + ".nii") btr.inputs.frac = 0.5 btr.inputs.mask = True btr.inputs.no_output = True btr.inputs.out_file = os.path.join(path_output, "bet") btr.inputs.output_type = "NIFTI" btr.run() # segmentation if segmentation: skullstrip_spm12(os.path.join(path_output, file + ".nii"), pathSPM, path_output) # load tissue maps wm_array = nb.load(os.path.join(path_output, "skull", "c2" + file + ".nii")).get_fdata() csf_array = nb.load( os.path.join(path_output, "skull", "c3" + file + ".nii")).get_fdata() mask_array = nb.load(os.path.join(path_output, "bet_mask.nii")).get_fdata() # binarize wm_array[wm_array > 0] = 1 csf_array[csf_array > 0] = 1 # apply brain mask wm_array = wm_array * mask_array csf_array = csf_array * mask_array # erode wm wm_array = binary_erosion( wm_array, structure=None, iterations=nerode_white, mask=None, output=None, border_value=0, origin=0, brute_force=False, ) # erode csf csf_array = binary_erosion( csf_array, structure=None, iterations=nerode_csf, mask=None, output=None, border_value=0, origin=0, brute_force=False, ) # write wm and csf mask data_img = nb.load(input) wm_out = nb.Nifti1Image(wm_array, data_img.affine, data_img.header) nb.save(wm_out, os.path.join(path_output, "wm_mask_orig.nii")) csf_out = nb.Nifti1Image(csf_array, data_img.affine, data_img.header) nb.save(csf_out, os.path.join(path_output, "csf_mask_orig.nii")) # apply deformation to mask apply_coordinate_mappings( os.path.join(path_output, "wm_mask_orig.nii"), # input deformation, # cmap interpolation="nearest", # nearest or linear padding="zero", # closest, zero or max save_data=True, # save output data to file (boolean) overwrite=True, # overwrite existing results (boolean) output_dir=path_output, # output directory file_name="wm_mask" # base name with file extension for output ) apply_coordinate_mappings( os.path.join(path_output, "csf_mask_orig.nii"), # input deformation, # cmap interpolation="nearest", # nearest or linear padding="zero", # closest, zero or max save_data=True, # save output data to file (boolean) overwrite=True, # overwrite existing results (boolean) output_dir=path_output, # output directory file_name="csf_mask" # base name with file extension for output ) # rename transformed masks os.rename(os.path.join(path_output, "wm_mask_def-img.nii.gz"), os.path.join(path_output, "wm_mask.nii.gz")) os.rename(os.path.join(path_output, "csf_mask_def-img.nii.gz"), os.path.join(path_output, "csf_mask.nii.gz")) # cleanup if cleanup: os.remove(os.path.join(path_output, "bet_mask.nii")) os.remove(os.path.join(path_output, "csf_mask_orig.nii")) os.remove(os.path.join(path_output, "wm_mask_orig.nii")) os.remove(os.path.join(path_output, "orig.nii")) sh.rmtree(os.path.join(path_output, "skull"), ignore_errors=True)
def test_MRIConvert_inputs(): input_map = dict( apply_inv_transform=dict(argstr='--apply_inverse_transform %s', ), apply_transform=dict(argstr='--apply_transform %s', ), args=dict(argstr='%s', ), ascii=dict(argstr='--ascii', ), autoalign_matrix=dict(argstr='--autoalign %s', ), color_file=dict(argstr='--color_file %s', ), conform=dict(argstr='--conform', ), conform_min=dict(argstr='--conform_min', ), conform_size=dict(argstr='--conform_size %s', ), crop_center=dict(argstr='--crop %d %d %d', ), crop_gdf=dict(argstr='--crop_gdf', ), crop_size=dict(argstr='--cropsize %d %d %d', ), cut_ends=dict(argstr='--cutends %d', ), devolve_transform=dict(argstr='--devolvexfm %s', ), drop_n=dict(argstr='--ndrop %d', ), environ=dict( nohash=True, usedefault=True, ), fill_parcellation=dict(argstr='--fill_parcellation', ), force_ras=dict(argstr='--force_ras_good', ), frame=dict(argstr='--frame %d', ), frame_subsample=dict(argstr='--fsubsample %d %d %d', ), fwhm=dict(argstr='--fwhm %f', ), ignore_exception=dict( nohash=True, usedefault=True, ), in_center=dict(argstr='--in_center %s', ), in_file=dict( argstr='--input_volume %s', mandatory=True, position=-2, ), in_i_dir=dict(argstr='--in_i_direction %f %f %f', ), in_i_size=dict(argstr='--in_i_size %d', ), in_info=dict(argstr='--in_info', ), in_j_dir=dict(argstr='--in_j_direction %f %f %f', ), in_j_size=dict(argstr='--in_j_size %d', ), in_k_dir=dict(argstr='--in_k_direction %f %f %f', ), in_k_size=dict(argstr='--in_k_size %d', ), in_like=dict(argstr='--in_like %s', ), in_matrix=dict(argstr='--in_matrix', ), in_orientation=dict(argstr='--in_orientation %s', ), in_scale=dict(argstr='--scale %f', ), in_stats=dict(argstr='--in_stats', ), in_type=dict(argstr='--in_type %s', ), invert_contrast=dict(argstr='--invert_contrast %f', ), midframe=dict(argstr='--mid-frame', ), no_change=dict(argstr='--nochange', ), no_scale=dict(argstr='--no_scale 1', ), no_translate=dict(argstr='--no_translate', ), no_write=dict(argstr='--no_write', ), out_center=dict(argstr='--out_center %f %f %f', ), out_datatype=dict(argstr='--out_data_type %s', ), out_file=dict( argstr='--output_volume %s', genfile=True, position=-1, ), out_i_count=dict(argstr='--out_i_count %d', ), out_i_dir=dict(argstr='--out_i_direction %f %f %f', ), out_i_size=dict(argstr='--out_i_size %d', ), out_info=dict(argstr='--out_info', ), out_j_count=dict(argstr='--out_j_count %d', ), out_j_dir=dict(argstr='--out_j_direction %f %f %f', ), out_j_size=dict(argstr='--out_j_size %d', ), out_k_count=dict(argstr='--out_k_count %d', ), out_k_dir=dict(argstr='--out_k_direction %f %f %f', ), out_k_size=dict(argstr='--out_k_size %d', ), out_matrix=dict(argstr='--out_matrix', ), out_orientation=dict(argstr='--out_orientation %s', ), out_scale=dict(argstr='--out-scale %d', ), out_stats=dict(argstr='--out_stats', ), out_type=dict(argstr='--out_type %s', ), parse_only=dict(argstr='--parse_only', ), read_only=dict(argstr='--read_only', ), reorder=dict(argstr='--reorder %d %d %d', ), resample_type=dict(argstr='--resample_type %s', ), reslice_like=dict(argstr='--reslice_like %s', ), sdcm_list=dict(argstr='--sdcmlist %s', ), skip_n=dict(argstr='--nskip %d', ), slice_bias=dict(argstr='--slice-bias %f', ), slice_crop=dict(argstr='--slice-crop %d %d', ), slice_reverse=dict(argstr='--slice-reverse', ), smooth_parcellation=dict(argstr='--smooth_parcellation', ), sphinx=dict(argstr='--sphinx', ), split=dict(argstr='--split', ), status_file=dict(argstr='--status %s', ), subject_name=dict(argstr='--subject_name %s', ), subjects_dir=dict(), template_info=dict(), template_type=dict(argstr='--template_type %s', ), terminal_output=dict(nohash=True, ), unwarp_gradient=dict(argstr='--unwarp_gradient_nonlinearity', ), vox_size=dict(argstr='-voxsize %f %f %f', ), zero_ge_z_offset=dict(argstr='--zero_ge_z_offset', ), zero_outlines=dict(argstr='--zero_outlines', ), ) inputs = MRIConvert.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 t1_b0_registration( participant_id, session_id, caps_directory, working_directory=None, name="t1_b0_registration"): """ Perform rigid registration of the T1-weighted image onto the B0 image. Given a subject, this pipelines performs a registration between its T1-weighted image onto its 1mm upsampled B0 image. Once done, the estimated transformation matrix is used to align the binary mask of the segmentation of the white matter (obtained with FSL fast) from the anatomical space to the diffusion space. The same operation is performed on the Desikan and Destrieux parcellation (obtained with FreeSurfer recon-all) except that these latter are not resliced on the B0 image. These steps enable to prepare the data for the DWI processing pipelines. Args: participant_id (str): Subject (participant) ID in a BIDS format ('sub-<participant_label>'). session_id (str): Session ID in a BIDS format ('ses-<session_label>'). caps_directory (str): Directory where the results are stored in a CAPS hierarchy. working_directory (Optional[str]): Directory where the temporary results are stored. If not specified, it is automatically generated (generally in /tmp/). name (Optional[str]): Name of the pipelines. Inputnode: in_bias_corrected_bet_t1 (str): File containing the bias corrected brain extracted T1-weighted image. It corresponds to the out_brain_extracted file from FSL-T1 pipelines. in_preprocessed_dwi (str): File containing the preprocessed DWI dataset. It assumes that the reference b0 is the first volume in the dataset (which is the case if you are using Clinica). in_b0_mask (str): File containing the mask of the b0 image. It assumes that `in_b0_mask` has the same header as `in_preprocessed_dwi` (which is the case if you are using Clinica). in_white_matter_binary_mask (str): File containing the binary segmentation of the white matter (obtained with FSL fast). You can use the one generated by FreeSurfer recon-all but you must convert your image in FreeSurfer space to Native space first. in_desikan_parcellation (str): File containing the Desikan parcellation (obtained with FreeSurfer recon-all). The file is usually located in ${participant_id}/mri/aparc+aseg.mgz. in_destrieux_parcellation (str): File containing the Destrieux parcellation (obtained with FreeSurfer recon-all). The file is usually located in ${participant_id}/mri/aparc.a2009s+aseg.mgz. Outputnode: out_registered_t1 (str): File containing the registration of the T1-weighted image onto the diffusion space. out_flirt_matrix (str): File containing the transformation matrix estimated by FSL flirt. out_wm_mask_in_diffusion_space (str): File containing the segmentation of the white matter in diffusion space. out_mrtrix_matrix (str): File containing the transformation matrix in MRtrix format (can be used with the mrtransform command). out_desikan_in_diffusion_space (str): File containing the Desikan parcellation in diffusion space. out_destrieux_in_diffusion_space (str): File containing the Desikan parcellation in diffusion space. Example: >>> from clinica.pipelines.dwi.dwi_registration import t1_b0_registration_pipeline >>> t1_b0_registration = t1_b0_registration_pipeline(participant_id='sub-CLNC01', session_id='ses-M00', caps_directory='/path/to/output/results') >>> t1_b0_registration.inputs.inputnode.in_bias_corrected_bet_t1 = 'sub-CLNC01_ses-M00_bias_corrected_brain_extracted_t1.nii' >>> t1_b0_registration.inputs.inputnode.in_preprocessed_dwi = 'sub-CLNC01_ses-M00_preprocessed_dwi.nii' >>> t1_b0_registration.inputs.inputnode.in_b0_mask = 'sub-CLNC01_ses-M00_b0_mask.nii' >>> t1_b0_registration.inputs.inputnode.in_white_matter_binary_mask = 'sub-CLNC01_ses-M00_id_wm_mask.nii' >>> t1_b0_registration.inputs.inputnode.in_desikan_parcellation = 'sub-CLNC01_ses-M00/mri/aparc+aseg.mgz' >>> t1_b0_registration.inputs.inputnode.in_destrieux_parcellation = 'sub-CLNC01_ses-M00/mri/aparc.a2009s+aseg.mgz' >>> t1_b0_registration.run() """ from os.path import join import nipype.interfaces.fsl as fsl import nipype.interfaces.io as nio import nipype.interfaces.utility as niu import nipype.pipeline.engine as pe from nipype.interfaces.freesurfer.preprocess import MRIConvert from clinica.utils.freesurfer import freesurfer_volume_to_native_volume from clinica.utils.mri_registration import convert_flirt_transformation_to_mrtrix_transformation from clinica.utils.mri_registration import apply_mrtrix_transform_without_resampling import tempfile from clinica.utils.check_dependency import check_freesurfer, check_fsl, check_mrtrix if working_directory is None: working_directory = tempfile.mkdtemp() check_freesurfer() check_fsl() check_mrtrix() caps_identifier = participant_id + '_' + session_id inputnode = pe.Node(niu.IdentityInterface( fields=['in_bias_corrected_bet_t1', 'in_preprocessed_dwi', 'in_b0_mask', 'in_white_matter_binary_mask', 'in_desikan_parcellation', 'in_destrieux_parcellation']), name='inputnode') get_b0 = pe.Node(fsl.ExtractROI(args='0 1'), name='get_b0') upsample_b0 = pe.Node( MRIConvert(vox_size=(1, 1, 1), out_type='niigz'), name='upsample_b0') upsample_b0_mask = pe.Node( MRIConvert(vox_size=(1, 1, 1), out_type='niigz'), name='upsample_b0_mask') registration_t1_to_b0 = pe.Node(fsl.FLIRT( dof=6, interp='spline', cost='normmi', cost_func='normmi', out_matrix_file=caps_identifier + '_t1-to-b0_withResampling.mat'), name='registration_t1_to_b0') apply_flirt_registration = pe.Node( fsl.ApplyXfm(apply_xfm=True, interp='spline'), name='apply_flirt_registration') apply_flirt_registration.inputs.out_file = \ caps_identifier + '_binarymask-whitematter_reslicedOnDiffusionSpace.nii.gz' convert_flirt_to_mrtrix = pe.Node(interface=niu.Function( input_names=['in_source_image', 'in_reference_image', 'in_flirt_matrix', 'name_output_matrix'], output_names=['out_mrtrix_matrix'], function=convert_flirt_transformation_to_mrtrix_transformation), name='convert_flirt_to_mrtrix') convert_flirt_to_mrtrix.inputs.name_output_matrix = \ caps_identifier + '_t1-to-b0_withoutResampling.mat' desikan_in_native_space = pe.Node(interface=niu.Function( input_names=['freesurfer_volume', 'native_volume', 'name_output_volume'], output_names=['out_volume'], function=freesurfer_volume_to_native_volume), name='desikan_in_native_space') destrieux_in_native_space = pe.Node(interface=niu.Function( input_names=['freesurfer_volume', 'native_volume', 'name_output_volume'], output_names=['out_volume'], function=freesurfer_volume_to_native_volume), name='destrieux_in_native_space') desikan_in_diffusion_space = pe.Node(interface=niu.Function( input_names=['in_image', 'in_mrtrix_matrix', 'name_output_image'], output_names=['out_deformed_image'], function=apply_mrtrix_transform_without_resampling), name='desikan_in_diffusion_space') desikan_in_diffusion_space.inputs.name_output_image = \ caps_identifier + '_parcellation-desikan_onDiffusionSpace.nii.gz' destrieux_in_diffusion_space = pe.Node(interface=niu.Function( input_names=['in_image', 'in_mrtrix_matrix', 'name_output_image'], output_names=['out_deformed_image'], function=apply_mrtrix_transform_without_resampling), name='destrieux_in_diffusion_space') destrieux_in_diffusion_space.inputs.name_output_image = \ caps_identifier + '_parcellation-destrieux_onDiffusionSpace.nii.gz' outputnode = pe.Node(niu.IdentityInterface( fields=['out_registered_t1', 'out_flirt_matrix', 'out_wm_mask_in_diffusion_space', 'out_mrtrix_matrix', 'out_desikan_in_diffusion_space', 'out_destrieux_in_diffusion_space']), name='outputnode') datasink = pe.Node(nio.DataSink(), name='datasink') datasink.inputs.base_directory = join(caps_directory, 'subjects', participant_id, session_id) # datasink.inputs.substitutions = [('fast_pve_0.nii.gz', caps_identifier + '_binary-csf.nii.gz')] wf = pe.Workflow(name=name) wf.base_dir = working_directory wf.connect([ # Get b0 from DWI: (inputnode, get_b0, [('in_preprocessed_dwi', 'in_file')]), # Upsample at 1mm the b0 image: (get_b0, upsample_b0, [('roi_file', 'in_file')]), # Upsample at 1mm the b0 mask: (inputnode, upsample_b0_mask, [('in_b0_mask', 'in_file')]), # Register the T1 image onto the b0: (inputnode, registration_t1_to_b0, [('in_bias_corrected_bet_t1', 'in_file')]), (upsample_b0, registration_t1_to_b0, [('out_file', 'reference')]), (upsample_b0_mask, registration_t1_to_b0, [('out_file', 'ref_weight')]), # Apply flirt registration to WM mask: (inputnode, apply_flirt_registration, [('in_white_matter_binary_mask', 'in_file')]), (upsample_b0, apply_flirt_registration, [('out_file', 'reference')]), (registration_t1_to_b0, apply_flirt_registration, [('out_matrix_file', 'in_matrix_file')]), # Convert flirt matrix to MRtrix matrix: (inputnode, convert_flirt_to_mrtrix, [('in_bias_corrected_bet_t1', 'in_source_image')]), (upsample_b0, convert_flirt_to_mrtrix, [('out_file', 'in_reference_image')]), (registration_t1_to_b0, convert_flirt_to_mrtrix, [('out_matrix_file', 'in_flirt_matrix')]), # Convert FreeSurfer parcellations into native space: (inputnode, desikan_in_native_space, [('in_desikan_parcellation', 'freesurfer_volume'), ('in_bias_corrected_bet_t1', 'native_volume')]), (inputnode, destrieux_in_native_space, [('in_destrieux_parcellation', 'freesurfer_volume'), ('in_bias_corrected_bet_t1', 'native_volume')]), # Apply registration without resampling on Desikan & Destrieux parcellations: (desikan_in_native_space, desikan_in_diffusion_space, [('out_volume', 'in_image')]), # noqa (convert_flirt_to_mrtrix, desikan_in_diffusion_space, [('out_mrtrix_matrix', 'in_mrtrix_matrix')]), # noqa (destrieux_in_native_space, destrieux_in_diffusion_space, [('out_volume', 'in_image')]), # noqa (convert_flirt_to_mrtrix, destrieux_in_diffusion_space, [('out_mrtrix_matrix', 'in_mrtrix_matrix')]), # noqa # Outputnode: (registration_t1_to_b0, outputnode, [('out_file', 'out_registered_t1')]), # noqa (registration_t1_to_b0, outputnode, [('out_matrix_file', 'out_flirt_matrix')]), # noqa (apply_flirt_registration, outputnode, [('out_file', 'out_wm_mask_in_diffusion_space')]), # noqa (convert_flirt_to_mrtrix, outputnode, [('out_mrtrix_matrix', 'out_mrtrix_matrix')]), # noqa (desikan_in_diffusion_space, outputnode, [('out_deformed_image', 'out_desikan_in_diffusion_space')]), # noqa (destrieux_in_diffusion_space, outputnode, [('out_deformed_image', 'out_destrieux_in_diffusion_space')]), # noqa # Datasink: (registration_t1_to_b0, datasink, [('out_file', 'dwi.@out_registered_t1')]), # noqa (registration_t1_to_b0, datasink, [('out_matrix_file', 'dwi.@out_flirt_matrix')]), # noqa (apply_flirt_registration, datasink, [('out_file', 'dwi.@out_wm_mask_in_diffusion_mask')]), # noqa (convert_flirt_to_mrtrix, datasink, [('out_mrtrix_matrix', 'dwi.@out_mrtrix_matrix')]), # noqa (desikan_in_diffusion_space, datasink, [('out_deformed_image', 'dwi.@out_desikan_in_diffusion_space')]), # noqa (destrieux_in_diffusion_space, datasink, [('out_deformed_image', 'dwi.@out_destrieux_in_diffusion_space')]) # noqa ]) return wf
def map2surface(input_surf, input_vol, hemi, path_output, input_white=None, input_ind=None, cleanup=True): """ This function samples data from the input volume to the input surface and optionally maps those values to a target surface if an index file is given. Inputs: *input_surf: surface mesh onto which volume data is sampled. *input_vol: volume from which data is sampled. *hemi: hemisphere. *path_output: path where to save output. *input_white: white surface in target surface space (only necessary if index file is given). *input_ind: textfile with mapping of vertex indices to target space. *cleanup: remove intermediate files. created by Daniel Haenelt Date created: 06-02-2019 Last modified: 03-08-2020 """ import os import numpy as np import nibabel as nb import shutil as sh from nibabel.freesurfer.io import read_geometry from nipype.interfaces.freesurfer import SampleToSurface from nipype.interfaces.freesurfer.preprocess import MRIConvert # set freesurfer path environment os.environ["SUBJECTS_DIR"] = path_output # freesurfer subject tmp = np.random.randint(0, 10, 5) tmp_string = ''.join(str(i) for i in tmp) sub = "tmp_" + tmp_string # make output folder if not os.path.exists(path_output): os.makedirs(path_output) # mimic freesurfer folder structure (with some additional folder for intermediate files) path_sub = os.path.join(path_output, sub) path_mri = os.path.join(path_sub, "mri") path_surf = os.path.join(path_sub, "surf") os.makedirs(path_sub) os.makedirs(path_mri) os.makedirs(path_surf) # copy input volume as orig.mgz to mimicked freesurfer folder if os.path.splitext(os.path.basename(input_vol))[1] is not ".mgz": mc = MRIConvert() mc.inputs.in_file = input_vol mc.inputs.out_file = os.path.join(path_mri, "orig.mgz") mc.inputs.out_type = 'mgz' mc.run() else: sh.copyfile(input_vol, os.path.join(path_mri, "orig.mgz")) # copy input surface to mimicked freesurfer folder sh.copyfile(input_surf, os.path.join(path_surf, hemi + ".source")) # input volume file name if os.path.splitext(os.path.basename(input_vol))[1] == ".gz": name_vol = os.path.splitext( os.path.splitext(os.path.basename(input_vol))[0])[0] else: name_vol = os.path.splitext(os.path.basename(input_vol))[0] name_surf = os.path.basename(input_surf).split('.')[1] # mri_vol2surf sampler = SampleToSurface() sampler.inputs.subject_id = sub sampler.inputs.reg_header = True sampler.inputs.hemi = hemi sampler.inputs.source_file = input_vol sampler.inputs.surface = "source" sampler.inputs.sampling_method = "point" sampler.inputs.sampling_range = 0 sampler.inputs.sampling_units = "mm" sampler.inputs.interp_method = "nearest" # or trilinear sampler.inputs.out_type = "mgh" sampler.inputs.out_file = os.path.join(path_surf, hemi + "." + "sampled.mgh") sampler.run() if input_ind: # read ind ind_orig = np.loadtxt(input_ind, dtype=int) # read white vtx_orig, _ = read_geometry(input_white) # read sampled morph data vals_img = nb.load(os.path.join(path_surf, hemi + "." + "sampled.mgh")) vals_array = vals_img.get_fdata() # get anzahl der vertices als Nullen in white vals_orig = np.zeros([len(vtx_orig[:, 0]), 1, 1]) # setze sampled data da rein vals_orig[ind_orig] = vals_array # write sampled data in anatomical space vals_img.header["dims"][0] = len(vals_orig[:, 0]) vals_img.header["Mdc"] = np.eye(3) res_img = nb.Nifti1Image(vals_orig, vals_img.affine, vals_img.header) nb.save( res_img, os.path.join( path_output, hemi + "." + name_vol + "_" + name_surf + "_def_trans.mgh")) else: # write sampled data in epi space sh.copyfile( os.path.join(path_surf, hemi + "." + "sampled.mgh"), os.path.join(path_output, hemi + "." + name_vol + "_" + name_surf + "_def.mgh")) # delete intermediate files if cleanup: sh.rmtree(path_sub, ignore_errors=True)
if not os.path.exists(path_syn): os.makedirs(path_syn) # copy input files sh.copyfile(file_orig, os.path.join(path_orig, "orig.mgz")) sh.copyfile(file_mean_epi, os.path.join(path_epi, "epi.nii")) sh.copyfile(file_t1, os.path.join(path_t1, "T1.nii")) """ mask preparation """ # convert to nifti if os.path.splitext(file_mask)[1] == ".mgh": sh.copyfile(file_mask, os.path.join(path_t1, "mask.mgh")) mc = MRIConvert() mc.inputs.in_file = os.path.join(path_t1, "mask.mgh") mc.inputs.out_file = os.path.join(path_t1, "mask.nii") mc.inputs.in_type = "mgh" mc.inputs.out_type = "nii" mc.run() elif os.path.splitext(file_mask)[1] == ".mgz": sh.copyfile(file_mask, os.path.join(path_t1, "mask.mgz")) mc = MRIConvert() mc.inputs.in_file = os.path.join(path_t1, "mask.mgz") mc.inputs.out_file = os.path.join(path_t1, "mask.nii") mc.inputs.in_type = "mgz" mc.inputs.out_type = "nii" mc.run() elif os.path.splitext(file_mask)[1] == ".gz": sh.copyfile(file_mask, os.path.join(path_t1, "mask.nii.gz"))