def execute(): import os, shutil from mrtrix3 import app, image, path, run shells = [ int(round(float(x))) for x in image.headerField('dwi.mif', 'shells').split() ] # Get lmax information (if provided) lmax = [ ] if app.args.lmax: lmax = [ int(x.strip()) for x in app.args.lmax.split(',') ] if not len(lmax) == len(shells): app.error('Number of manually-defined lmax\'s (' + str(len(lmax)) + ') does not match number of b-value shells (' + str(len(shells)) + ')') for l in lmax: if l%2: app.error('Values for lmax must be even') if l<0: app.error('Values for lmax must be non-negative') # Do we have directions, or do we need to calculate them? if not os.path.exists('dirs.mif'): run.command('dwi2tensor dwi.mif - -mask in_voxels.mif | tensor2metric - -vector dirs.mif') # Get response function bvalues_option = ' -shell ' + ','.join(map(str,shells)) lmax_option = '' if lmax: lmax_option = ' -lmax ' + ','.join(map(str,lmax)) run.command('amp2response dwi.mif in_voxels.mif dirs.mif response.txt' + bvalues_option + lmax_option) run.function(shutil.copyfile, 'response.txt', path.fromUser(app.args.output, False)) run.function(shutil.copyfile, 'in_voxels.mif', 'voxels.mif')
def execute(): import os, shutil from mrtrix3 import app, image, path, run shells = [ int(round(float(x))) for x in image.headerField('dwi.mif', 'shells').split() ] # Get lmax information (if provided) lmax = [] if app.args.lmax: lmax = [int(x.strip()) for x in app.args.lmax.split(',')] if not len(lmax) == len(shells): app.error('Number of manually-defined lmax\'s (' + str(len(lmax)) + ') does not match number of b-value shells (' + str(len(shells)) + ')') for l in lmax: if l % 2: app.error('Values for lmax must be even') if l < 0: app.error('Values for lmax must be non-negative') # Do we have directions, or do we need to calculate them? if not os.path.exists('dirs.mif'): run.command( 'dwi2tensor dwi.mif - -mask in_voxels.mif | tensor2metric - -vector dirs.mif' ) # Get response function bvalues_option = ' -shell ' + ','.join(map(str, shells)) lmax_option = '' if lmax: lmax_option = ' -lmax ' + ','.join(map(str, lmax)) run.command('amp2response dwi.mif in_voxels.mif dirs.mif response.txt' + bvalues_option + lmax_option) run.function(shutil.copyfile, 'response.txt', path.fromUser(app.args.output, False)) run.function(shutil.copyfile, 'in_voxels.mif', 'voxels.mif')
def execute(): import os, shutil from mrtrix3 import app, image, path, run bvalues = [ int(round(float(x))) for x in image.headerField('dwi.mif', 'shells').split() ] if len(bvalues) < 2: app.error('Need at least 2 unique b-values (including b=0).') lmax_option = '' if app.args.lmax: lmax_option = ' -lmax ' + app.args.lmax if not app.args.mask: run.command('maskfilter mask.mif erode mask_eroded.mif -npass ' + str(app.args.erode)) mask_path = 'mask_eroded.mif' else: mask_path = 'mask.mif' run.command('dwi2tensor dwi.mif -mask ' + mask_path + ' tensor.mif') run.command('tensor2metric tensor.mif -fa fa.mif -vector vector.mif -mask ' + mask_path) if app.args.threshold: run.command('mrthreshold fa.mif voxels.mif -abs ' + str(app.args.threshold)) else: run.command('mrthreshold fa.mif voxels.mif -top ' + str(app.args.number)) run.command('dwiextract dwi.mif - -singleshell -no_bzero | amp2response - voxels.mif vector.mif response.txt' + lmax_option) run.function(shutil.copyfile, 'response.txt', path.fromUser(app.args.output, False))
def execute(): import math, os, shutil from mrtrix3 import app, image, path, run # Get b-values and number of volumes per b-value. bvalues = [ int(round(float(x))) for x in image.headerField('dwi.mif', 'shells').split() ] bvolumes = [ int(x) for x in image.headerField('dwi.mif', 'shellcounts').split() ] app.console(str(len(bvalues)) + ' unique b-value(s) detected: ' + ','.join(map(str,bvalues)) + ' with ' + ','.join(map(str,bvolumes)) + ' volumes.') if len(bvalues) < 2: app.error('Need at least 2 unique b-values (including b=0).') # Get lmax information (if provided). sfwm_lmax = [ ] if app.args.lmax: sfwm_lmax = [ int(x.strip()) for x in app.args.lmax.split(',') ] if not len(sfwm_lmax) == len(bvalues): app.error('Number of lmax\'s (' + str(len(sfwm_lmax)) + ', as supplied to the -lmax option: ' + ','.join(map(str,sfwm_lmax)) + ') does not match number of unique b-values.') for l in sfwm_lmax: if l%2: app.error('Values supplied to the -lmax option must be even.') if l<0: app.error('Values supplied to the -lmax option must be non-negative.') # Erode (brain) mask. if app.args.erode > 0: run.command('maskfilter mask.mif erode eroded_mask.mif -npass ' + str(app.args.erode)) else: run.command('mrconvert mask.mif eroded_mask.mif -datatype bit') # Get volumes, compute mean signal and SDM per b-value; compute overall SDM; get rid of erroneous values. totvolumes = 0 fullsdmcmd = 'mrcalc' errcmd = 'mrcalc' zeropath = 'mean_b' + str(bvalues[0]) + '.mif' for i, b in enumerate(bvalues): meanpath = 'mean_b' + str(b) + '.mif' run.command('dwiextract dwi.mif -shell ' + str(b) + ' - | mrmath - mean ' + meanpath + ' -axis 3') errpath = 'err_b' + str(b) + '.mif' run.command('mrcalc ' + meanpath + ' -finite ' + meanpath + ' 0 -if 0 -le ' + errpath + ' -datatype bit') errcmd += ' ' + errpath if i>0: errcmd += ' -add' sdmpath = 'sdm_b' + str(b) + '.mif' run.command('mrcalc ' + zeropath + ' ' + meanpath + ' -divide -log ' + sdmpath) totvolumes += bvolumes[i] fullsdmcmd += ' ' + sdmpath + ' ' + str(bvolumes[i]) + ' -mult' if i>1: fullsdmcmd += ' -add' fullsdmcmd += ' ' + str(totvolumes) + ' -divide full_sdm.mif' run.command(fullsdmcmd) run.command('mrcalc full_sdm.mif -finite full_sdm.mif 0 -if 0 -le err_sdm.mif -datatype bit') errcmd += ' err_sdm.mif -add 0 eroded_mask.mif -if safe_mask.mif -datatype bit' run.command(errcmd) run.command('mrcalc safe_mask.mif full_sdm.mif 0 -if 10 -min safe_sdm.mif') # Compute FA and principal eigenvectors; crude WM versus GM-CSF separation based on FA. run.command('dwi2tensor dwi.mif - -mask safe_mask.mif | tensor2metric - -fa safe_fa.mif -vector safe_vecs.mif -modulate none -mask safe_mask.mif') run.command('mrcalc safe_mask.mif safe_fa.mif 0 -if ' + str(app.args.fa) + ' -gt crude_wm.mif -datatype bit') run.command('mrcalc crude_wm.mif 0 safe_mask.mif -if _crudenonwm.mif -datatype bit') # Crude GM versus CSF separation based on SDM. crudenonwmmedian = image.statistic('safe_sdm.mif', 'median', '_crudenonwm.mif') run.command('mrcalc _crudenonwm.mif safe_sdm.mif ' + str(crudenonwmmedian) + ' -subtract 0 -if - | mrthreshold - - -mask _crudenonwm.mif | mrcalc _crudenonwm.mif - 0 -if crude_csf.mif -datatype bit') run.command('mrcalc crude_csf.mif 0 _crudenonwm.mif -if crude_gm.mif -datatype bit') # Refine WM: remove high SDM outliers. crudewmmedian = image.statistic('safe_sdm.mif', 'median', 'crude_wm.mif') run.command('mrcalc crude_wm.mif safe_sdm.mif 0 -if ' + str(crudewmmedian) + ' -gt _crudewmhigh.mif -datatype bit') run.command('mrcalc _crudewmhigh.mif 0 crude_wm.mif -if _crudewmlow.mif -datatype bit') crudewmQ1 = float(image.statistic('safe_sdm.mif', 'median', '_crudewmlow.mif')) crudewmQ3 = float(image.statistic('safe_sdm.mif', 'median', '_crudewmhigh.mif')) crudewmoutlthresh = crudewmQ3 + (crudewmQ3 - crudewmQ1) run.command('mrcalc crude_wm.mif safe_sdm.mif 0 -if ' + str(crudewmoutlthresh) + ' -gt _crudewmoutliers.mif -datatype bit') run.command('mrcalc _crudewmoutliers.mif 0 crude_wm.mif -if refined_wm.mif -datatype bit') # Refine GM: separate safer GM from partial volumed voxels. crudegmmedian = image.statistic('safe_sdm.mif', 'median', 'crude_gm.mif') run.command('mrcalc crude_gm.mif safe_sdm.mif 0 -if ' + str(crudegmmedian) + ' -gt _crudegmhigh.mif -datatype bit') run.command('mrcalc _crudegmhigh.mif 0 crude_gm.mif -if _crudegmlow.mif -datatype bit') run.command('mrcalc _crudegmhigh.mif safe_sdm.mif ' + str(crudegmmedian) + ' -subtract 0 -if - | mrthreshold - - -mask _crudegmhigh.mif -invert | mrcalc _crudegmhigh.mif - 0 -if _crudegmhighselect.mif -datatype bit') run.command('mrcalc _crudegmlow.mif safe_sdm.mif ' + str(crudegmmedian) + ' -subtract -neg 0 -if - | mrthreshold - - -mask _crudegmlow.mif -invert | mrcalc _crudegmlow.mif - 0 -if _crudegmlowselect.mif -datatype bit') run.command('mrcalc _crudegmhighselect.mif 1 _crudegmlowselect.mif -if refined_gm.mif -datatype bit') # Refine CSF: recover lost CSF from crude WM SDM outliers, separate safer CSF from partial volumed voxels. crudecsfmin = image.statistic('safe_sdm.mif', 'min', 'crude_csf.mif') run.command('mrcalc _crudewmoutliers.mif safe_sdm.mif 0 -if ' + str(crudecsfmin) + ' -gt 1 crude_csf.mif -if _crudecsfextra.mif -datatype bit') run.command('mrcalc _crudecsfextra.mif safe_sdm.mif ' + str(crudecsfmin) + ' -subtract 0 -if - | mrthreshold - - -mask _crudecsfextra.mif | mrcalc _crudecsfextra.mif - 0 -if refined_csf.mif -datatype bit') # Get final voxels for single-fibre WM response function estimation from WM using 'tournier' algorithm. refwmcount = float(image.statistic('refined_wm.mif', 'count', 'refined_wm.mif')) voxsfwmcount = int(round(refwmcount * app.args.sfwm / 100.0)) app.console('Running \'tournier\' algorithm to select ' + str(voxsfwmcount) + ' single-fibre WM voxels.') cleanopt = '' if not app._cleanup: cleanopt = ' -nocleanup' run.command('dwi2response tournier dwi.mif _respsfwmss.txt -sf_voxels ' + str(voxsfwmcount) + ' -iter_voxels ' + str(voxsfwmcount * 10) + ' -mask refined_wm.mif -voxels voxels_sfwm.mif -tempdir ' + app._tempDir + cleanopt) # Get final voxels for GM response function estimation from GM. refgmmedian = image.statistic('safe_sdm.mif', 'median', 'refined_gm.mif') run.command('mrcalc refined_gm.mif safe_sdm.mif 0 -if ' + str(refgmmedian) + ' -gt _refinedgmhigh.mif -datatype bit') run.command('mrcalc _refinedgmhigh.mif 0 refined_gm.mif -if _refinedgmlow.mif -datatype bit') refgmhighcount = float(image.statistic('_refinedgmhigh.mif', 'count', '_refinedgmhigh.mif')) refgmlowcount = float(image.statistic('_refinedgmlow.mif', 'count', '_refinedgmlow.mif')) voxgmhighcount = int(round(refgmhighcount * app.args.gm / 100.0)) voxgmlowcount = int(round(refgmlowcount * app.args.gm / 100.0)) run.command('mrcalc _refinedgmhigh.mif safe_sdm.mif 0 -if - | mrthreshold - - -bottom ' + str(voxgmhighcount) + ' -ignorezero | mrcalc _refinedgmhigh.mif - 0 -if _refinedgmhighselect.mif -datatype bit') run.command('mrcalc _refinedgmlow.mif safe_sdm.mif 0 -if - | mrthreshold - - -top ' + str(voxgmlowcount) + ' -ignorezero | mrcalc _refinedgmlow.mif - 0 -if _refinedgmlowselect.mif -datatype bit') run.command('mrcalc _refinedgmhighselect.mif 1 _refinedgmlowselect.mif -if voxels_gm.mif -datatype bit') # Get final voxels for CSF response function estimation from CSF. refcsfcount = float(image.statistic('refined_csf.mif', 'count', 'refined_csf.mif')) voxcsfcount = int(round(refcsfcount * app.args.csf / 100.0)) run.command('mrcalc refined_csf.mif safe_sdm.mif 0 -if - | mrthreshold - - -top ' + str(voxcsfcount) + ' -ignorezero | mrcalc refined_csf.mif - 0 -if voxels_csf.mif -datatype bit') # Show summary of voxels counts. textarrow = ' --> ' app.console('Summary of voxel counts:') app.console('Mask: ' + str(int(image.statistic('mask.mif', 'count', 'mask.mif'))) + textarrow + str(int(image.statistic('eroded_mask.mif', 'count', 'eroded_mask.mif'))) + textarrow + str(int(image.statistic('safe_mask.mif', 'count', 'safe_mask.mif')))) app.console('WM: ' + str(int(image.statistic('crude_wm.mif', 'count', 'crude_wm.mif'))) + textarrow + str(int(image.statistic('refined_wm.mif', 'count', 'refined_wm.mif'))) + textarrow + str(int(image.statistic('voxels_sfwm.mif', 'count', 'voxels_sfwm.mif'))) + ' (SF)') app.console('GM: ' + str(int(image.statistic('crude_gm.mif', 'count', 'crude_gm.mif'))) + textarrow + str(int(image.statistic('refined_gm.mif', 'count', 'refined_gm.mif'))) + textarrow + str(int(image.statistic('voxels_gm.mif', 'count', 'voxels_gm.mif')))) app.console('CSF: ' + str(int(image.statistic('crude_csf.mif', 'count', 'crude_csf.mif'))) + textarrow + str(int(image.statistic('refined_csf.mif', 'count', 'refined_csf.mif'))) + textarrow + str(int(image.statistic('voxels_csf.mif', 'count', 'voxels_csf.mif')))) # Generate single-fibre WM, GM and CSF responses bvalues_option = ' -shell ' + ','.join(map(str,bvalues)) sfwm_lmax_option = '' if sfwm_lmax: sfwm_lmax_option = ' -lmax ' + ','.join(map(str,sfwm_lmax)) run.command('amp2response dwi.mif voxels_sfwm.mif safe_vecs.mif response_sfwm.txt' + bvalues_option + sfwm_lmax_option) run.command('amp2response dwi.mif voxels_gm.mif safe_vecs.mif response_gm.txt' + bvalues_option + ' -isotropic') run.command('amp2response dwi.mif voxels_csf.mif safe_vecs.mif response_csf.txt' + bvalues_option + ' -isotropic') run.function(shutil.copyfile, 'response_sfwm.txt', path.fromUser(app.args.out_sfwm, False)) run.function(shutil.copyfile, 'response_gm.txt', path.fromUser(app.args.out_gm, False)) run.function(shutil.copyfile, 'response_csf.txt', path.fromUser(app.args.out_csf, False)) # Generate 4D binary images with voxel selections at major stages in algorithm (RGB as in MSMT-CSD paper). run.command('mrcat crude_csf.mif crude_gm.mif crude_wm.mif crude.mif -axis 3') run.command('mrcat refined_csf.mif refined_gm.mif refined_wm.mif refined.mif -axis 3') run.command('mrcat voxels_csf.mif voxels_gm.mif voxels_sfwm.mif voxels.mif -axis 3')
def runSubject(bids_dir, label, output_prefix): from mrtrix3 import path, run output_dir = os.path.join(output_prefix, label) if os.path.exists(output_dir): shutil.rmtree(output_dir) os.makedirs(output_dir) os.makedirs(os.path.join(output_dir, 'connectome')) os.makedirs(os.path.join(output_dir, 'dwi')) fsl_path = os.environ.get('FSLDIR', '') if not fsl_path: app.error( 'Environment variable FSLDIR is not set; please run appropriate FSL configuration script' ) def findFSLBinary(name): if find_executable(name): return name newname = 'fsl5.0-' + name if find_executable(newname): return newname app.error('Could not find FSL program \'' + name + '\'; please verify FSL install') flirt_cmd = findFSLBinary('flirt') fslanat_cmd = findFSLBinary('fsl_anat') fsl_suffix = fsl.suffix() unring_cmd = 'unring.a64' if not find_executable(unring_cmd): app.console('Command \'' + unring_cmd + '\' not found; cannot perform Gibbs ringing removal') unring_cmd = '' dwibiascorrect_algo = '-ants' if not find_executable('N4BiasFieldCorrection'): # Can't use findFSLBinary() here, since we want to proceed even if it's not found if find_executable('fast') or find_executable('fsl5.0-fast'): dwibiascorrect_algo = '-fsl' app.console('Could not find ANTs program N4BiasFieldCorrection; ' 'using FSL FAST for bias field correction') else: dwibiascorrect_algo = '' app.warn( 'Could not find ANTs program \'N4BiasFieldCorrection\' or FSL program \'fast\'; ' 'will proceed without performing DWI bias field correction') if not app.args.parcellation: app.error( 'For participant-level analysis, desired parcellation must be provided using the -parcellation option' ) parc_image_path = '' parc_lut_file = '' mrtrix_lut_file = os.path.join( os.path.dirname(os.path.abspath(app.__file__)), os.pardir, os.pardir, 'share', 'mrtrix3', 'labelconvert') if app.args.parcellation == 'fs_2005' or app.args.parcellation == 'fs_2009': if not os.environ['FREESURFER_HOME']: app.error( 'Environment variable FREESURFER_HOME not set; please verify FreeSurfer installation' ) if not find_executable('recon-all'): app.error( 'Could not find FreeSurfer script recon-all; please verify FreeSurfer installation' ) parc_lut_file = os.path.join(os.environ['FREESURFER_HOME'], 'FreeSurferColorLUT.txt') if app.args.parcellation == 'fs_2005': mrtrix_lut_file = os.path.join(mrtrix_lut_file, 'fs_default.txt') else: mrtrix_lut_file = os.path.join(mrtrix_lut_file, 'fs_a2009s.txt') if app.args.parcellation == 'aal' or app.args.parcellation == 'aal2': mni152_path = os.path.join(fsl_path, 'data', 'standard', 'MNI152_T1_1mm.nii.gz') if not os.path.isfile(mni152_path): app.error( 'Could not find MNI152 template image within FSL installation (expected location: ' + mni152_path + ')') if app.args.parcellation == 'aal': parc_image_path = os.path.abspath( os.path.join(os.sep, 'opt', 'aal', 'ROI_MNI_V4.nii')) parc_lut_file = os.path.abspath( os.path.join(os.sep, 'opt', 'aal', 'ROI_MNI_V4.txt')) mrtrix_lut_file = os.path.join(mrtrix_lut_file, 'aal.txt') else: parc_image_path = os.path.abspath( os.path.join(os.sep, 'opt', 'aal', 'ROI_MNI_V5.nii')) parc_lut_file = os.path.abspath( os.path.join(os.sep, 'opt', 'aal', 'ROI_MNI_V5.txt')) mrtrix_lut_file = os.path.join(mrtrix_lut_file, 'aal2.txt') if parc_image_path and not os.path.isfile(parc_image_path): if app.args.atlas_path: parc_image_path = [ parc_image_path, os.path.join(os.path.dirname(app.args.atlas_path), os.path.basename(parc_image_path)) ] if os.path.isfile(parc_image_path[1]): parc_image_path = parc_image_path[1] else: app.error( 'Could not find parcellation image (tested locations: ' + str(parc_image_path) + ')') else: app.error( 'Could not find parcellation image (expected location: ' + parc_image_path + ')') if not os.path.isfile(parc_lut_file): if app.args.atlas_path: parc_lut_file = [ parc_lut_file, os.path.join(os.path.dirname(app.args.atlas_path), os.path.basename(parc_lut_file)) ] if os.path.isfile(parc_lut_file[1]): parc_lut_file = parc_lut_file[1] else: app.error( 'Could not find parcellation lookup table file (tested locations: ' + str(parc_lut_file) + ')') else: app.error( 'Could not find parcellation lookup table file (expected location: ' + parc_lut_file + ')') if not os.path.exists(mrtrix_lut_file): app.error( 'Could not find MRtrix3 connectome lookup table file (expected location: ' + mrtrix_lut_file + ')') app.makeTempDir() # Need to perform an initial import of JSON data using mrconvert; so let's grab the diffusion gradient table as well # If no bvec/bval present, need to go down the directory listing # Only try to import JSON file if it's actually present # direction in the acquisition they'll need to be split across multiple files # May need to concatenate more than one input DWI, since if there's more than one phase-encode direction # in the acquired DWIs (i.e. not just those used for estimating the inhomogeneity field), they will # need to be stored as separate NIfTI files in the 'dwi/' directory. dwi_image_list = glob.glob( os.path.join(bids_dir, label, 'dwi', label) + '*_dwi.nii*') dwi_index = 1 for entry in dwi_image_list: # os.path.split() falls over with .nii.gz extensions; only removes the .gz prefix = entry.split(os.extsep)[0] if os.path.isfile(prefix + '.bval') and os.path.isfile(prefix + '.bvec'): prefix = prefix + '.' else: prefix = os.path.join(bids_dir, 'dwi') if not (os.path.isfile(prefix + 'bval') and os.path.isfile(prefix + 'bvec')): app.error( 'Unable to locate valid diffusion gradient table for image \'' + entry + '\'') grad_import_option = ' -fslgrad ' + prefix + 'bvec ' + prefix + 'bval' json_path = prefix + 'json' if os.path.isfile(json_path): json_import_option = ' -json_import ' + json_path else: json_import_option = '' run.command('mrconvert ' + entry + grad_import_option + json_import_option + ' ' + path.toTemp('dwi' + str(dwi_index) + '.mif', True)) dwi_index += 1 # Go hunting for reversed phase-encode data dedicated to field map estimation # TODO Should ideally have compatibility with GE-based fieldmap data also fmap_image_list = [] fmap_dir = os.path.join(bids_dir, label, 'fmap') fmap_index = 1 if os.path.isdir(fmap_dir): if app.args.preprocessed: app.error('fmap/ directory detected for subject \'' + label + '\' despite use of -preprocessed option') fmap_image_list = glob.glob( os.path.join(fmap_dir, label) + '_dir-*_epi.nii*') for entry in fmap_image_list: prefix = entry.split(os.extsep)[0] json_path = prefix + '.json' with open(json_path, 'r') as f: json_elements = json.load(f) if 'IntendedFor' in json_elements and not any( i.endswith(json_elements['IntendedFor']) for i in dwi_image_list): app.console('Image \'' + entry + '\' is not intended for use with DWIs; skipping') continue if os.path.isfile(json_path): json_import_option = ' -json_import ' + json_path # fmap files will not come with any gradient encoding in the JSON; # therefore we need to add it manually ourselves so that mrcat / mrconvert can # appropriately handle the table once these images are concatenated with the DWIs fmap_image_size = [ int(i) for i in image.headerField(entry, 'size').strip().split() ] fmap_image_num_volumes = 1 if len( fmap_image_size) == 3 else fmap_image_size[3] run.command('mrconvert ' + entry + json_import_option + ' -set_property dw_scheme \"' + '\\n'.join(['0,0,1,0'] * fmap_image_num_volumes) + '\" ' + path.toTemp('fmap' + str(fmap_index) + '.mif', True)) fmap_index += 1 else: app.warn('No corresponding .json file found for image \'' + entry + '\'; skipping') fmap_image_list = [ 'fmap' + str(i) + '.mif' for i in range(1, fmap_index) ] # If there's no data in fmap/ directory, need to check to see if there's any phase-encoding # contrast within the input DWI(s) elif len(dwi_image_list) < 2 and not app.args.preprocessed: app.error( 'Inadequate data for pre-processing of subject \'' + label + '\': No phase-encoding contrast in input DWIs or fmap/ directory') dwi_image_list = ['dwi' + str(i) + '.mif' for i in range(1, dwi_index)] # Import anatomical image run.command('mrconvert ' + os.path.join(bids_dir, label, 'anat', label + '_T1w.nii.gz') + ' ' + path.toTemp('T1.mif', True)) cwd = os.getcwd() app.gotoTempDir() dwipreproc_se_epi = '' dwipreproc_se_epi_option = '' # For automated testing, down-sampled images are used. However, this invalidates the requirements of # both MP-PCA denoising and Gibbs ringing removal. In addition, eddy can still take a long time # despite the down-sampling. Therefore, provide images that have been pre-processed to the stage # where it is still only DWI, JSON & bvecs/bvals that need to be provided. if app.args.preprocessed: if len(dwi_image_list) > 1: app.error( 'If DWIs have been pre-processed, then only a single DWI file should need to be provided' ) app.console( 'Skipping MP-PCA denoising, ' + ('Gibbs ringing removal, ' if unring_cmd else '') + 'distortion correction and bias field correction due to use of -preprocessed option' ) run.function(os.rename, dwi_image_list[0], 'dwi.mif') else: # Do initial image pre-processing (denoising, Gibbs ringing removal if available, distortion correction & bias field correction) as normal # Concatenate any SE EPI images with the DWIs before denoising (& unringing), then # separate them again after the fact dwidenoise_input = 'dwidenoise_input.mif' fmap_num_volumes = 0 if len(fmap_image_list): run.command('mrcat ' + ' '.join(fmap_image_list) + ' fmap_cat.mif -axis 3') for i in fmap_image_list: file.delTempFile(i) fmap_num_volumes = int( image.headerField('fmap_cat.mif', 'size').strip().split()[3]) dwidenoise_input = 'all_cat.mif' run.command('mrcat fmap_cat.mif ' + ' '.join(dwi_image_list) + ' ' + dwidenoise_input + ' -axis 3') file.delTempFile('fmap_cat.mif') else: # Even if no explicit fmap images, may still need to concatenate multiple DWI inputs if len(dwi_image_list) > 1: run.command('mrcat ' + ' '.join(dwi_image_list) + ' ' + dwidenoise_input + ' -axis 3') else: run.function(os.move, dwi_image_list[0], dwidenoise_input) for i in dwi_image_list: file.delTempFile(i) # Step 1: Denoise run.command('dwidenoise ' + dwidenoise_input + ' dwi_denoised.' + ('nii' if unring_cmd else 'mif')) if unring_cmd: run.command('mrinfo ' + dwidenoise_input + ' -json_export input.json') file.delTempFile(dwidenoise_input) # Step 2: Gibbs ringing removal (if available) if unring_cmd: run.command('unring.a64 dwi_denoised.nii dwi_unring' + fsl_suffix + ' -n 100') file.delTempFile('dwi_denoised.nii') run.command('mrconvert dwi_unring' + fsl_suffix + ' dwi_unring.mif -json_import input.json') file.delTempFile('dwi_unring' + fsl_suffix) file.delTempFile('input.json') # If fmap images and DWIs have been concatenated, now is the time to split them back apart dwipreproc_input = 'dwi_unring.mif' if unring_cmd else 'dwi_denoised.mif' if fmap_num_volumes: cat_input = 'dwi_unring.mif' if unring_cmd else 'dwi_denoised.mif' dwipreproc_se_epi = 'se_epi.mif' run.command('mrconvert ' + dwipreproc_input + ' ' + dwipreproc_se_epi + ' -coord 3 0:' + str(fmap_num_volumes - 1)) cat_num_volumes = int( image.headerField(dwipreproc_input, 'size').strip().split()[3]) run.command('mrconvert ' + dwipreproc_input + ' dwipreproc_in.mif -coord 3 ' + str(fmap_num_volumes) + ':' + str(cat_num_volumes - 1)) file.delTempFile(dwipreproc_input) dwipreproc_input = 'dwipreproc_in.mif' dwipreproc_se_epi_option = ' -se_epi ' + dwipreproc_se_epi # Step 3: Distortion correction run.command('dwipreproc ' + dwipreproc_input + ' dwi_preprocessed.mif -rpe_header' + dwipreproc_se_epi_option) file.delTempFile(dwipreproc_input) if dwipreproc_se_epi: file.delTempFile(dwipreproc_se_epi) # Step 4: Bias field correction if dwibiascorrect_algo: run.command('dwibiascorrect dwi_preprocessed.mif dwi.mif ' + dwibiascorrect_algo) file.delTempFile('dwi_preprocessed.mif') else: run.function(os.move, 'dwi_preprocessed.mif', 'dwi.mif') # No longer branching based on whether or not -preprocessed was specified # Step 5: Generate a brain mask for DWI run.command('dwi2mask dwi.mif dwi_mask.mif') # Step 6: Perform brain extraction on the T1 image in its original space # (this is necessary for histogram matching prior to registration) # Use fsl_anat script run.command('mrconvert T1.mif T1.nii -stride -1,+2,+3') run.command(fslanat_cmd + ' -i T1.nii --noseg --nosubcortseg') run.command('mrconvert ' + os.path.join('T1.anat', 'T1_biascorr_brain_mask' + fsl_suffix) + ' T1_mask.mif -datatype bit') run.command('mrconvert ' + os.path.join('T1.anat', 'T1_biascorr_brain' + fsl_suffix) + ' T1_biascorr_brain.mif') file.delTempFolder('T1.anat') # Step 7: Generate target images for T1->DWI registration run.command('dwiextract dwi.mif -bzero - | ' 'mrcalc - 0.0 -max - | ' 'mrmath - mean -axis 3 dwi_meanbzero.mif') run.command( 'mrcalc 1 dwi_meanbzero.mif -div dwi_mask.mif -mult - | ' 'mrhistmatch - T1_biascorr_brain.mif dwi_pseudoT1.mif -mask_input dwi_mask.mif -mask_target T1_mask.mif' ) run.command( 'mrcalc 1 T1_biascorr_brain.mif -div T1_mask.mif -mult - | ' 'mrhistmatch - dwi_meanbzero.mif T1_pseudobzero.mif -mask_input T1_mask.mif -mask_target dwi_mask.mif' ) # Step 8: Perform T1->DWI registration # Note that two registrations are performed: Even though we have a symmetric registration, # generation of the two histogram-matched images means that you will get slightly different # answers depending on which synthesized image & original image you use. run.command( 'mrregister T1_biascorr_brain.mif dwi_pseudoT1.mif -type rigid -mask1 T1_mask.mif -mask2 dwi_mask.mif -rigid rigid_T1_to_pseudoT1.txt' ) file.delTempFile('T1_biascorr_brain.mif') run.command( 'mrregister T1_pseudobzero.mif dwi_meanbzero.mif -type rigid -mask1 T1_mask.mif -mask2 dwi_mask.mif -rigid rigid_pseudobzero_to_bzero.txt' ) file.delTempFile('dwi_meanbzero.mif') run.command( 'transformcalc rigid_T1_to_pseudoT1.txt rigid_pseudobzero_to_bzero.txt average rigid_T1_to_dwi.txt' ) file.delTempFile('rigid_T1_to_pseudoT1.txt') file.delTempFile('rigid_pseudobzero_to_bzero.txt') run.command( 'mrtransform T1.mif T1_registered.mif -linear rigid_T1_to_dwi.txt') file.delTempFile('T1.mif') # Note: Since we're using a mask from fsl_anat (which crops the FoV), but using it as input to 5ttge fsl # (which is receiving the raw T1), we need to resample in order to have the same dimensions between these two run.command( 'mrtransform T1_mask.mif T1_mask_registered.mif -linear rigid_T1_to_dwi.txt -template T1_registered.mif -interp nearest' ) file.delTempFile('T1_mask.mif') # Step 9: Generate 5TT image for ACT run.command( '5ttgen fsl T1_registered.mif 5TT.mif -mask T1_mask_registered.mif') file.delTempFile('T1_mask_registered.mif') # Step 10: Estimate response functions for spherical deconvolution run.command( 'dwi2response dhollander dwi.mif response_wm.txt response_gm.txt response_csf.txt -mask dwi_mask.mif' ) # Step 11: Determine whether we are working with single-shell or multi-shell data shells = [ int(round(float(x))) for x in image.headerField('dwi.mif', 'shellvalues').split() ] multishell = (len(shells) > 2) # Step 12: Perform spherical deconvolution # Use a dilated mask for spherical deconvolution as a 'safety margin' - # ACT should be responsible for stopping streamlines before they reach the edge of the DWI mask run.command('maskfilter dwi_mask.mif dilate dwi_mask_dilated.mif -npass 3') if multishell: run.command( 'dwi2fod msmt_csd dwi.mif response_wm.txt FOD_WM.mif response_gm.txt FOD_GM.mif response_csf.txt FOD_CSF.mif ' '-mask dwi_mask_dilated.mif -lmax 10,0,0') file.delTempFile('FOD_GM.mif') file.delTempFile('FOD_CSF.mif') else: # Still use the msmt_csd algorithm with single-shell data: Use hard non-negativity constraint # Also incorporate the CSF response to provide some fluid attenuation run.command( 'dwi2fod msmt_csd dwi.mif response_wm.txt FOD_WM.mif response_csf.txt FOD_CSF.mif ' '-mask dwi_mask_dilated.mif -lmax 10,0') file.delTempFile('FOD_CSF.mif') # Step 13: Generate the grey matter parcellation # The necessary steps here will vary significantly depending on the parcellation scheme selected run.command( 'mrconvert T1_registered.mif T1_registered.nii -stride +1,+2,+3') if app.args.parcellation == 'fs_2005' or app.args.parcellation == 'fs_2009': # Run FreeSurfer pipeline on this subject's T1 image run.command('recon-all -sd ' + app._tempDir + ' -subjid freesurfer -i T1_registered.nii') run.command('recon-all -sd ' + app._tempDir + ' -subjid freesurfer -all') # Grab the relevant parcellation image and target lookup table for conversion parc_image_path = os.path.join('freesurfer', 'mri') if app.args.parcellation == 'fs_2005': parc_image_path = os.path.join(parc_image_path, 'aparc+aseg.mgz') else: parc_image_path = os.path.join(parc_image_path, 'aparc.a2009s+aseg.mgz') # Perform the index conversion run.command('labelconvert ' + parc_image_path + ' ' + parc_lut_file + ' ' + mrtrix_lut_file + ' parc_init.mif') if not app.args.nocleanup: run.function(shutil.rmtree, 'freesurfer') # Fix the sub-cortical grey matter parcellations using FSL FIRST run.command('labelsgmfix parc_init.mif T1_registered.mif ' + mrtrix_lut_file + ' parc.mif') file.delTempFile('parc_init.mif') elif app.args.parcellation == 'aal' or app.args.parcellation == 'aal2': # Can use MNI152 image provided with FSL for registration # TODO Retain bias-corrected & brain-extracted T1, give mrhistmatch the ability to perform linear scaling of # input image only, and use mrregister for this step run.command('flirt -ref ' + mni152_path + ' -in T1_registered.nii -omat T1_to_MNI_FLIRT.mat -dof 12') run.command('transformconvert T1_to_MNI_FLIRT.mat T1_registered.nii ' + mni152_path + ' flirt_import T1_to_MNI_MRtrix.mat') file.delTempFile('T1_to_MNI_FLIRT.mat') run.command( 'transformcalc T1_to_MNI_MRtrix.mat invert MNI_to_T1_MRtrix.mat') file.delTempFile('T1_to_MNI_MRtrix.mat') run.command('mrtransform ' + parc_image_path + ' AAL.mif -linear MNI_to_T1_MRtrix.mat ' '-template T1_registered.mif -interp nearest') file.delTempFile('MNI_to_T1_MRtrix.mat') run.command('labelconvert AAL.mif ' + parc_lut_file + ' ' + mrtrix_lut_file + ' parc.mif') file.delTempFile('AAL.mif') else: app.error('Unknown parcellation scheme requested: ' + app.args.parcellation) file.delTempFile('T1_registered.nii') # Step 14: Generate the tractogram # If not manually specified, determine the appropriate number of streamlines based on the number of nodes in the parcellation: # mean edge weight of 1,000 streamlines # A smaller FOD amplitude threshold of 0.06 (default 0.1) is used for tracking due to the use of the msmt_csd # algorithm, which imposes a hard rather than soft non-negativity constraint num_nodes = int(image.statistic('parc.mif', 'max')) num_streamlines = 1000 * num_nodes * num_nodes if app.args.streamlines: num_streamlines = app.args.streamlines run.command( 'tckgen FOD_WM.mif tractogram.tck -act 5TT.mif -backtrack -crop_at_gmwmi -cutoff 0.06 -maxlength 250 -power 0.33 ' '-select ' + str(num_streamlines) + ' -seed_dynamic FOD_WM.mif') # Step 15: Use SIFT2 to determine streamline weights fd_scale_gm_option = '' if not multishell: fd_scale_gm_option = ' -fd_scale_gm' run.command( 'tcksift2 tractogram.tck FOD_WM.mif weights.csv -act 5TT.mif -out_mu mu.txt' + fd_scale_gm_option) # Step 16: Generate a TDI (to verify that SIFT2 has worked correctly) with open('mu.txt', 'r') as f: mu = float(f.read()) run.command( 'tckmap tractogram.tck -tck_weights_in weights.csv -template FOD_WM.mif -precise - | ' 'mrcalc - ' + str(mu) + ' -mult tdi.mif') # Step 17: Generate the connectome # Only provide the standard density-weighted connectome for now run.command( 'tck2connectome tractogram.tck parc.mif connectome.csv -tck_weights_in weights.csv' ) file.delTempFile('weights.csv') # Move necessary files to output directory run.function( shutil.copy, 'connectome.csv', os.path.join(output_dir, 'connectome', label + '_connectome.csv')) run.command('mrconvert dwi.mif ' + os.path.join(output_dir, 'dwi', label + '_dwi.nii.gz') + ' -export_grad_fsl ' + os.path.join(output_dir, 'dwi', label + '_dwi.bvec') + ' ' + os.path.join(output_dir, 'dwi', label + '_dwi.bval') + ' -json_export ' + os.path.join(output_dir, 'dwi', label + '_dwi.json')) run.command('mrconvert tdi.mif ' + os.path.join(output_dir, 'dwi', label + '_tdi.nii.gz')) run.function(shutil.copy, 'mu.txt', os.path.join(output_dir, 'connectome', label + '_mu.txt')) run.function(shutil.copy, 'response_wm.txt', os.path.join(output_dir, 'dwi', label + '_response.txt')) # TODO Write shell b-values to file; # If these are inconsistent between subjects, the inter-subject intensity normalisation won't work # Manually wipe and zero the temp directory (since we might be processing more than one subject) os.chdir(cwd) if app._cleanup: app.console('Deleting temporary directory ' + app._tempDir) # Can't use run.function() here; it'll try to write to the log file that resides in the temp directory just deleted shutil.rmtree(app._tempDir) else: app.console('Contents of temporary directory kept, location: ' + app._tempDir) app._tempDir = ''
DWIext = [i[1] for i in DWIflist] miflist = [] idxlist = [] dwi_ind_size = [[0, 0, 0, 0]] if len(DWInlist) == 1: run.command('mrconvert -stride -1,2,3,4 -fslgrad ' + ''.join(DWInlist) + '.bvec ' + ''.join(DWInlist) + '.bval ' + ''.join(DWInlist) + ''.join(DWIext) + ' ' + path.toTemp('dwi.mif', True)) else: for idx, i in enumerate(DWInlist): run.command('mrconvert -stride -1,2,3,4 -fslgrad ' + i + '.bvec ' + i + '.bval ' + i + DWIext[idx] + ' ' + path.toTemp('dwi' + str(idx) + '.mif', True)) dwi_ind_size.append([ int(s) for s in image.headerField( path.toTemp('dwi' + str(idx) + '.mif', True), 'size').split() ]) miflist.append(path.toTemp('dwi' + str(idx) + '.mif', True)) DWImif = ' '.join(miflist) run.command('mrcat -axis 3 ' + DWImif + ' ' + path.toTemp('dwi.mif', True)) app.gotoTempDir() # get diffusion header info - check to make sure all values are valid for processing dwi_size = [int(s) for s in image.headerField('dwi.mif', 'size').split()] grad = image.headerField('dwi.mif', 'dwgrad').split('\n') grad = [line.split() for line in grad] grad = [[float(f) for f in line] for line in grad] stride = image.headerField('dwi.mif', 'stride') num_volumes = 1 if len(dwi_size) == 4:
def execute(): import math, os, shutil from mrtrix3 import app, image, path, run # Get b-values and number of volumes per b-value. bvalues = [ int(round(float(x))) for x in image.headerField('dwi.mif', 'shells').split() ] bvolumes = [ int(x) for x in image.headerField('dwi.mif', 'shellcounts').split() ] app.console( str(len(bvalues)) + ' unique b-value(s) detected: ' + ','.join(map(str, bvalues)) + ' with ' + ','.join(map(str, bvolumes)) + ' volumes.') if len(bvalues) < 2: app.error('Need at least 2 unique b-values (including b=0).') # Get lmax information (if provided). sfwm_lmax = [] if app.args.lmax: sfwm_lmax = [int(x.strip()) for x in app.args.lmax.split(',')] if not len(sfwm_lmax) == len(bvalues): app.error('Number of lmax\'s (' + str(len(sfwm_lmax)) + ', as supplied to the -lmax option: ' + ','.join(map(str, sfwm_lmax)) + ') does not match number of unique b-values.') for l in sfwm_lmax: if l % 2: app.error('Values supplied to the -lmax option must be even.') if l < 0: app.error( 'Values supplied to the -lmax option must be non-negative.' ) # Erode (brain) mask. if app.args.erode > 0: run.command('maskfilter mask.mif erode eroded_mask.mif -npass ' + str(app.args.erode)) else: run.command('mrconvert mask.mif eroded_mask.mif -datatype bit') # Get volumes, compute mean signal and SDM per b-value; compute overall SDM; get rid of erroneous values. totvolumes = 0 fullsdmcmd = 'mrcalc' errcmd = 'mrcalc' zeropath = 'mean_b' + str(bvalues[0]) + '.mif' for i, b in enumerate(bvalues): meanpath = 'mean_b' + str(b) + '.mif' run.command('dwiextract dwi.mif -shell ' + str(b) + ' - | mrmath - mean ' + meanpath + ' -axis 3') errpath = 'err_b' + str(b) + '.mif' run.command('mrcalc ' + meanpath + ' -finite ' + meanpath + ' 0 -if 0 -le ' + errpath + ' -datatype bit') errcmd += ' ' + errpath if i > 0: errcmd += ' -add' sdmpath = 'sdm_b' + str(b) + '.mif' run.command('mrcalc ' + zeropath + ' ' + meanpath + ' -divide -log ' + sdmpath) totvolumes += bvolumes[i] fullsdmcmd += ' ' + sdmpath + ' ' + str(bvolumes[i]) + ' -mult' if i > 1: fullsdmcmd += ' -add' fullsdmcmd += ' ' + str(totvolumes) + ' -divide full_sdm.mif' run.command(fullsdmcmd) run.command( 'mrcalc full_sdm.mif -finite full_sdm.mif 0 -if 0 -le err_sdm.mif -datatype bit' ) errcmd += ' err_sdm.mif -add 0 eroded_mask.mif -if safe_mask.mif -datatype bit' run.command(errcmd) run.command('mrcalc safe_mask.mif full_sdm.mif 0 -if 10 -min safe_sdm.mif') # Compute FA and principal eigenvectors; crude WM versus GM-CSF separation based on FA. run.command( 'dwi2tensor dwi.mif - -mask safe_mask.mif | tensor2metric - -fa safe_fa.mif -vector safe_vecs.mif -modulate none -mask safe_mask.mif' ) run.command('mrcalc safe_mask.mif safe_fa.mif 0 -if ' + str(app.args.fa) + ' -gt crude_wm.mif -datatype bit') run.command( 'mrcalc crude_wm.mif 0 safe_mask.mif -if _crudenonwm.mif -datatype bit' ) # Crude GM versus CSF separation based on SDM. crudenonwmmedian = image.statistic('safe_sdm.mif', 'median', '_crudenonwm.mif') run.command( 'mrcalc _crudenonwm.mif safe_sdm.mif ' + str(crudenonwmmedian) + ' -subtract 0 -if - | mrthreshold - - -mask _crudenonwm.mif | mrcalc _crudenonwm.mif - 0 -if crude_csf.mif -datatype bit' ) run.command( 'mrcalc crude_csf.mif 0 _crudenonwm.mif -if crude_gm.mif -datatype bit' ) # Refine WM: remove high SDM outliers. crudewmmedian = image.statistic('safe_sdm.mif', 'median', 'crude_wm.mif') run.command('mrcalc crude_wm.mif safe_sdm.mif 0 -if ' + str(crudewmmedian) + ' -gt _crudewmhigh.mif -datatype bit') run.command( 'mrcalc _crudewmhigh.mif 0 crude_wm.mif -if _crudewmlow.mif -datatype bit' ) crudewmQ1 = float( image.statistic('safe_sdm.mif', 'median', '_crudewmlow.mif')) crudewmQ3 = float( image.statistic('safe_sdm.mif', 'median', '_crudewmhigh.mif')) crudewmoutlthresh = crudewmQ3 + (crudewmQ3 - crudewmQ1) run.command('mrcalc crude_wm.mif safe_sdm.mif 0 -if ' + str(crudewmoutlthresh) + ' -gt _crudewmoutliers.mif -datatype bit') run.command( 'mrcalc _crudewmoutliers.mif 0 crude_wm.mif -if refined_wm.mif -datatype bit' ) # Refine GM: separate safer GM from partial volumed voxels. crudegmmedian = image.statistic('safe_sdm.mif', 'median', 'crude_gm.mif') run.command('mrcalc crude_gm.mif safe_sdm.mif 0 -if ' + str(crudegmmedian) + ' -gt _crudegmhigh.mif -datatype bit') run.command( 'mrcalc _crudegmhigh.mif 0 crude_gm.mif -if _crudegmlow.mif -datatype bit' ) run.command( 'mrcalc _crudegmhigh.mif safe_sdm.mif ' + str(crudegmmedian) + ' -subtract 0 -if - | mrthreshold - - -mask _crudegmhigh.mif -invert | mrcalc _crudegmhigh.mif - 0 -if _crudegmhighselect.mif -datatype bit' ) run.command( 'mrcalc _crudegmlow.mif safe_sdm.mif ' + str(crudegmmedian) + ' -subtract -neg 0 -if - | mrthreshold - - -mask _crudegmlow.mif -invert | mrcalc _crudegmlow.mif - 0 -if _crudegmlowselect.mif -datatype bit' ) run.command( 'mrcalc _crudegmhighselect.mif 1 _crudegmlowselect.mif -if refined_gm.mif -datatype bit' ) # Refine CSF: recover lost CSF from crude WM SDM outliers, separate safer CSF from partial volumed voxels. crudecsfmin = image.statistic('safe_sdm.mif', 'min', 'crude_csf.mif') run.command('mrcalc _crudewmoutliers.mif safe_sdm.mif 0 -if ' + str(crudecsfmin) + ' -gt 1 crude_csf.mif -if _crudecsfextra.mif -datatype bit') run.command( 'mrcalc _crudecsfextra.mif safe_sdm.mif ' + str(crudecsfmin) + ' -subtract 0 -if - | mrthreshold - - -mask _crudecsfextra.mif | mrcalc _crudecsfextra.mif - 0 -if refined_csf.mif -datatype bit' ) # Get final voxels for single-fibre WM response function estimation from WM using 'tournier' algorithm. refwmcount = float( image.statistic('refined_wm.mif', 'count', 'refined_wm.mif')) voxsfwmcount = int(round(refwmcount * app.args.sfwm / 100.0)) app.console('Running \'tournier\' algorithm to select ' + str(voxsfwmcount) + ' single-fibre WM voxels.') cleanopt = '' if not app._cleanup: cleanopt = ' -nocleanup' run.command('dwi2response tournier dwi.mif _respsfwmss.txt -sf_voxels ' + str(voxsfwmcount) + ' -iter_voxels ' + str(voxsfwmcount * 10) + ' -mask refined_wm.mif -voxels voxels_sfwm.mif -tempdir ' + app._tempDir + cleanopt) # Get final voxels for GM response function estimation from GM. refgmmedian = image.statistic('safe_sdm.mif', 'median', 'refined_gm.mif') run.command('mrcalc refined_gm.mif safe_sdm.mif 0 -if ' + str(refgmmedian) + ' -gt _refinedgmhigh.mif -datatype bit') run.command( 'mrcalc _refinedgmhigh.mif 0 refined_gm.mif -if _refinedgmlow.mif -datatype bit' ) refgmhighcount = float( image.statistic('_refinedgmhigh.mif', 'count', '_refinedgmhigh.mif')) refgmlowcount = float( image.statistic('_refinedgmlow.mif', 'count', '_refinedgmlow.mif')) voxgmhighcount = int(round(refgmhighcount * app.args.gm / 100.0)) voxgmlowcount = int(round(refgmlowcount * app.args.gm / 100.0)) run.command( 'mrcalc _refinedgmhigh.mif safe_sdm.mif 0 -if - | mrthreshold - - -bottom ' + str(voxgmhighcount) + ' -ignorezero | mrcalc _refinedgmhigh.mif - 0 -if _refinedgmhighselect.mif -datatype bit' ) run.command( 'mrcalc _refinedgmlow.mif safe_sdm.mif 0 -if - | mrthreshold - - -top ' + str(voxgmlowcount) + ' -ignorezero | mrcalc _refinedgmlow.mif - 0 -if _refinedgmlowselect.mif -datatype bit' ) run.command( 'mrcalc _refinedgmhighselect.mif 1 _refinedgmlowselect.mif -if voxels_gm.mif -datatype bit' ) # Get final voxels for CSF response function estimation from CSF. refcsfcount = float( image.statistic('refined_csf.mif', 'count', 'refined_csf.mif')) voxcsfcount = int(round(refcsfcount * app.args.csf / 100.0)) run.command( 'mrcalc refined_csf.mif safe_sdm.mif 0 -if - | mrthreshold - - -top ' + str(voxcsfcount) + ' -ignorezero | mrcalc refined_csf.mif - 0 -if voxels_csf.mif -datatype bit' ) # Show summary of voxels counts. textarrow = ' --> ' app.console('Summary of voxel counts:') app.console( 'Mask: ' + str(int(image.statistic('mask.mif', 'count', 'mask.mif'))) + textarrow + str(int(image.statistic('eroded_mask.mif', 'count', 'eroded_mask.mif'))) + textarrow + str(int(image.statistic('safe_mask.mif', 'count', 'safe_mask.mif')))) app.console( 'WM: ' + str(int(image.statistic('crude_wm.mif', 'count', 'crude_wm.mif'))) + textarrow + str(int(image.statistic('refined_wm.mif', 'count', 'refined_wm.mif'))) + textarrow + str(int(image.statistic('voxels_sfwm.mif', 'count', 'voxels_sfwm.mif'))) + ' (SF)') app.console( 'GM: ' + str(int(image.statistic('crude_gm.mif', 'count', 'crude_gm.mif'))) + textarrow + str(int(image.statistic('refined_gm.mif', 'count', 'refined_gm.mif'))) + textarrow + str(int(image.statistic('voxels_gm.mif', 'count', 'voxels_gm.mif')))) app.console( 'CSF: ' + str(int(image.statistic('crude_csf.mif', 'count', 'crude_csf.mif'))) + textarrow + str(int(image.statistic('refined_csf.mif', 'count', 'refined_csf.mif'))) + textarrow + str(int(image.statistic('voxels_csf.mif', 'count', 'voxels_csf.mif')))) # Generate single-fibre WM, GM and CSF responses bvalues_option = ' -shell ' + ','.join(map(str, bvalues)) sfwm_lmax_option = '' if sfwm_lmax: sfwm_lmax_option = ' -lmax ' + ','.join(map(str, sfwm_lmax)) run.command( 'amp2response dwi.mif voxels_sfwm.mif safe_vecs.mif response_sfwm.txt' + bvalues_option + sfwm_lmax_option) run.command( 'amp2response dwi.mif voxels_gm.mif safe_vecs.mif response_gm.txt' + bvalues_option + ' -isotropic') run.command( 'amp2response dwi.mif voxels_csf.mif safe_vecs.mif response_csf.txt' + bvalues_option + ' -isotropic') run.function(shutil.copyfile, 'response_sfwm.txt', path.fromUser(app.args.out_sfwm, False)) run.function(shutil.copyfile, 'response_gm.txt', path.fromUser(app.args.out_gm, False)) run.function(shutil.copyfile, 'response_csf.txt', path.fromUser(app.args.out_csf, False)) # Generate 4D binary images with voxel selections at major stages in algorithm (RGB as in MSMT-CSD paper). run.command( 'mrcat crude_csf.mif crude_gm.mif crude_wm.mif crude.mif -axis 3') run.command( 'mrcat refined_csf.mif refined_gm.mif refined_wm.mif refined.mif -axis 3' ) run.command( 'mrcat voxels_csf.mif voxels_gm.mif voxels_sfwm.mif voxels.mif -axis 3' )
def execute(): import math, os, shutil from mrtrix3 import app, image, path, run # Ideally want to use the oversampling-based regridding of the 5TT image from the SIFT model, not mrtransform # May need to commit 5ttregrid... # Verify input 5tt image run.command('5ttcheck 5tt.mif', False) # Get shell information shells = [ int(round(float(x))) for x in image.headerField('dwi.mif', 'shells').split() ] if len(shells) < 3: app.warn( 'Less than three b-value shells; response functions will not be applicable in resolving three tissues using MSMT-CSD algorithm' ) # Get lmax information (if provided) wm_lmax = [] if app.args.lmax: wm_lmax = [int(x.strip()) for x in app.args.lmax.split(',')] if not len(wm_lmax) == len(shells): app.error('Number of manually-defined lmax\'s (' + str(len(wm_lmax)) + ') does not match number of b-value shells (' + str(len(shells)) + ')') for l in wm_lmax: if l % 2: app.error('Values for lmax must be even') if l < 0: app.error('Values for lmax must be non-negative') run.command( 'dwi2tensor dwi.mif - -mask mask.mif | tensor2metric - -fa fa.mif -vector vector.mif' ) if not os.path.exists('dirs.mif'): run.function(shutil.copy, 'vector.mif', 'dirs.mif') run.command( 'mrtransform 5tt.mif 5tt_regrid.mif -template fa.mif -interp linear') # Basic tissue masks run.command( 'mrconvert 5tt_regrid.mif - -coord 3 2 -axes 0,1,2 | mrcalc - ' + str(app.args.pvf) + ' -gt mask.mif -mult wm_mask.mif') run.command( 'mrconvert 5tt_regrid.mif - -coord 3 0 -axes 0,1,2 | mrcalc - ' + str(app.args.pvf) + ' -gt fa.mif ' + str(app.args.fa) + ' -lt -mult mask.mif -mult gm_mask.mif') run.command( 'mrconvert 5tt_regrid.mif - -coord 3 3 -axes 0,1,2 | mrcalc - ' + str(app.args.pvf) + ' -gt fa.mif ' + str(app.args.fa) + ' -lt -mult mask.mif -mult csf_mask.mif') # Revise WM mask to only include single-fibre voxels app.console( 'Calling dwi2response recursively to select WM single-fibre voxels using \'' + app.args.wm_algo + '\' algorithm') recursive_cleanup_option = '' if not app._cleanup: recursive_cleanup_option = ' -nocleanup' run.command( 'dwi2response ' + app.args.wm_algo + ' dwi.mif wm_ss_response.txt -mask wm_mask.mif -voxels wm_sf_mask.mif -tempdir ' + app._tempDir + recursive_cleanup_option) # Check for empty masks wm_voxels = int( image.statistic('wm_sf_mask.mif', 'count', 'wm_sf_mask.mif')) gm_voxels = int(image.statistic('gm_mask.mif', 'count', 'gm_mask.mif')) csf_voxels = int(image.statistic('csf_mask.mif', 'count', 'csf_mask.mif')) empty_masks = [] if not wm_voxels: empty_masks.append('WM') if not gm_voxels: empty_masks.append('GM') if not csf_voxels: empty_masks.append('CSF') if empty_masks: message = ','.join(empty_masks) message += ' tissue mask' if len(empty_masks) > 1: message += 's' message += ' empty; cannot estimate response function' if len(empty_masks) > 1: message += 's' app.error(message) # For each of the three tissues, generate a multi-shell response bvalues_option = ' -shell ' + ','.join(map(str, shells)) sfwm_lmax_option = '' if wm_lmax: sfwm_lmax_option = ' -lmax ' + ','.join(map(str, wm_lmax)) run.command('amp2response dwi.mif wm_sf_mask.mif dirs.mif wm.txt' + bvalues_option + sfwm_lmax_option) run.command('amp2response dwi.mif gm_mask.mif dirs.mif gm.txt' + bvalues_option + ' -isotropic') run.command('amp2response dwi.mif csf_mask.mif dirs.mif csf.txt' + bvalues_option + ' -isotropic') run.function(shutil.copyfile, 'wm.txt', path.fromUser(app.args.out_wm, False)) run.function(shutil.copyfile, 'gm.txt', path.fromUser(app.args.out_gm, False)) run.function(shutil.copyfile, 'csf.txt', path.fromUser(app.args.out_csf, False)) # Generate output 4D binary image with voxel selections; RGB as in MSMT-CSD paper run.command( 'mrcat csf_mask.mif gm_mask.mif wm_sf_mask.mif voxels.mif -axis 3')
def execute(): import math, os, shutil from mrtrix3 import app, image, path, run # Ideally want to use the oversampling-based regridding of the 5TT image from the SIFT model, not mrtransform # May need to commit 5ttregrid... # Verify input 5tt image run.command('5ttcheck 5tt.mif', False) # Get shell information shells = [ int(round(float(x))) for x in image.headerField('dwi.mif', 'shells').split() ] if len(shells) < 3: app.warn('Less than three b-value shells; response functions will not be applicable in resolving three tissues using MSMT-CSD algorithm') # Get lmax information (if provided) wm_lmax = [ ] if app.args.lmax: wm_lmax = [ int(x.strip()) for x in app.args.lmax.split(',') ] if not len(wm_lmax) == len(shells): app.error('Number of manually-defined lmax\'s (' + str(len(wm_lmax)) + ') does not match number of b-value shells (' + str(len(shells)) + ')') for l in wm_lmax: if l%2: app.error('Values for lmax must be even') if l<0: app.error('Values for lmax must be non-negative') run.command('dwi2tensor dwi.mif - -mask mask.mif | tensor2metric - -fa fa.mif -vector vector.mif') if not os.path.exists('dirs.mif'): run.function(shutil.copy, 'vector.mif', 'dirs.mif') run.command('mrtransform 5tt.mif 5tt_regrid.mif -template fa.mif -interp linear') # Basic tissue masks run.command('mrconvert 5tt_regrid.mif - -coord 3 2 -axes 0,1,2 | mrcalc - ' + str(app.args.pvf) + ' -gt mask.mif -mult wm_mask.mif') run.command('mrconvert 5tt_regrid.mif - -coord 3 0 -axes 0,1,2 | mrcalc - ' + str(app.args.pvf) + ' -gt fa.mif ' + str(app.args.fa) + ' -lt -mult mask.mif -mult gm_mask.mif') run.command('mrconvert 5tt_regrid.mif - -coord 3 3 -axes 0,1,2 | mrcalc - ' + str(app.args.pvf) + ' -gt fa.mif ' + str(app.args.fa) + ' -lt -mult mask.mif -mult csf_mask.mif') # Revise WM mask to only include single-fibre voxels app.console('Calling dwi2response recursively to select WM single-fibre voxels using \'' + app.args.wm_algo + '\' algorithm') recursive_cleanup_option='' if not app._cleanup: recursive_cleanup_option = ' -nocleanup' run.command('dwi2response ' + app.args.wm_algo + ' dwi.mif wm_ss_response.txt -mask wm_mask.mif -voxels wm_sf_mask.mif -tempdir ' + app._tempDir + recursive_cleanup_option) # Check for empty masks wm_voxels = int(image.statistic('wm_sf_mask.mif', 'count', 'wm_sf_mask.mif')) gm_voxels = int(image.statistic('gm_mask.mif', 'count', 'gm_mask.mif')) csf_voxels = int(image.statistic('csf_mask.mif', 'count', 'csf_mask.mif')) empty_masks = [ ] if not wm_voxels: empty_masks.append('WM') if not gm_voxels: empty_masks.append('GM') if not csf_voxels: empty_masks.append('CSF') if empty_masks: message = ','.join(empty_masks) message += ' tissue mask' if len(empty_masks) > 1: message += 's' message += ' empty; cannot estimate response function' if len(empty_masks) > 1: message += 's' app.error(message) # For each of the three tissues, generate a multi-shell response bvalues_option = ' -shell ' + ','.join(map(str,shells)) sfwm_lmax_option = '' if wm_lmax: sfwm_lmax_option = ' -lmax ' + ','.join(map(str,wm_lmax)) run.command('amp2response dwi.mif wm_sf_mask.mif dirs.mif wm.txt' + bvalues_option + sfwm_lmax_option) run.command('amp2response dwi.mif gm_mask.mif dirs.mif gm.txt' + bvalues_option + ' -isotropic') run.command('amp2response dwi.mif csf_mask.mif dirs.mif csf.txt' + bvalues_option + ' -isotropic') run.function(shutil.copyfile, 'wm.txt', path.fromUser(app.args.out_wm, False)) run.function(shutil.copyfile, 'gm.txt', path.fromUser(app.args.out_gm, False)) run.function(shutil.copyfile, 'csf.txt', path.fromUser(app.args.out_csf, False)) # Generate output 4D binary image with voxel selections; RGB as in MSMT-CSD paper run.command('mrcat csf_mask.mif gm_mask.mif wm_sf_mask.mif voxels.mif -axis 3')