def methods_02_stats(config, verbose=False):
input_dir = config['dirs']['input']
util.mkcd_dir([config['methods']['results']['dir']], True)
command = [
'fslmaths',
os.path.join(config['dirs']['methods']['01-register'],
'nu_brain.nii.gz'), '-bin',
os.path.join(config['dirs']['methods']['results'], 'brain_mask.nii.gz')
]
util.iw_subprocess(command, verbose, verbose, False)
for ii in ['swi', 'swi_magnitude', 'swi_phase']:
command = [
'fslmaths',
os.path.join(config['dirs']['methods']['01-register'],
'swi_Affine_nu__' + ii + '.nii.gz'), '-mas',
'brain_mask.nii.gz', ii + '.nii.gz'
]
util.iw_subprocess(command, verbose, verbose, False)
util.force_hard_link(
os.path.join(config['methods']['input']['dir'], 'nu.nii.gz'),
'nu.nii.gz')
util.force_hard_link(
os.path.join(config['methods']['input']['dir'], 'nu_brain.nii.gz'),
'nu_brain.nii.gz')
def methods_02_lpa(input_dir, verbose):
cenc_dirs = cenc.directories(input_dir)
wm_lesions_dir = cenc_dirs['wmlesions']['dirs']['root']
wm_lesions_lpa_dir = cenc_dirs['wmlesions']['dirs']['lpa']
util.mkcd_dir([cenc_dirs['wmlesions']['dirs']['lpa']], True)
util.copy_inputs([
os.path.join(cenc_dirs['wmlesions']['dirs']['register'],
't2flair_Affine_nu__t2flair_Warped.nii.gz')
], cenc_dirs['wmlesions']['dirs']['lpa'])
glob_files = glob.glob('*.gz')
for ii in glob_files:
os.system('gunzip ' + ii)
os.chmod(str.replace(ii, '.gz', ''),
stat.S_IRUSR | stat.S_IRGRP | stat.S_IWUSR | stat.S_IWGRP)
# Run Matlab
command = ['cenc_wmlesions_run.sh', cenc_dirs['wmlesions']['dirs']['lpa']]
util.iw_subprocess(command, verbose, verbose, False)
os.chdir(cenc_dirs['wmlesions']['dirs']['lpa'])
for ii in glob.glob('*.nii'):
os.system('gzip ' + ii)
os.chmod(str.replace(ii, '.nii', '.nii.gz'),
stat.S_IRUSR | stat.S_IRGRP | stat.S_IWUSR | stat.S_IWGRP)
def ants_apply_transform(input_file):
# This simple command appears to work.
command = [
'antsApplyTransforms', '-d', '3', '-i', input_file + '.nii.gz', '-r',
'nu.nii.gz', '-o', 'swi_Affine_nu__' + input_file + '.nii.gz', '-t',
'swi_Affine_nu__swi_magnitude_0GenericAffine.mat'
]
util.iw_subprocess(command, True, True, False)
def ants_register(input_file):
# This simple command appears to work.
command = [
'antsRegistrationSyNQuick.sh', '-d', '3', '-m', input_file + '.nii.gz',
'-r', 'nu.nii.gz', '-f', 'nu.nii.gz', '-t', 'a', '-o',
'swi_Affine_nu__' + input_file + '_'
]
util.iw_subprocess(command, True, True, False)
def methods_01_register( input_dir, verbose=False):
# Register MT images to nu.nii.gz
cenc_dirs = cenc.directories( input_dir )
mt_link_inputs( input_dir, cenc_dirs['mt']['dirs']['register'] )
ants_register('mt_m0')
ants_register('mt_m1')
# Calculate MTR image
command = ['ImageMath', 3, 'mtr.nii.gz', 'MTR', 'mt_Affine_nu__mt_m0_Warped.nii.gz',
'mt_Affine_nu__mt_m1_Warped.nii.gz', 'nu_brain.nii.gz']
util.iw_subprocess( command, verbose, verbose, False)
return
def recon_all( cenc_participant_id, cenc_freesurfer_dir ):
freesurfer_command = [ 'recon-all', '-sd', cenc_freesurfer_dir,'-subjid', cenc_participant_id,
'-all', '-i', 't1w.nii.gz',
'-T2', 't2tse.nii.gz',
'-FLAIR', 't2flair.nii.gz',
'-qcache',
'-measure', 'thickness',
'-measure', 'curv',
'-measure', 'sulc',
'-measure', 'area',
'-measure', 'jacobian_white'
]
util.iw_subprocess( freesurfer_command, True, True, True)
return
def recon_all( input_dir ):
cenc_dirs = cenc.directories( input_dir )
freesurfer_command = [ 'recon-all', '-sd', cenc_dirs['cenc']['freesurfer_subjects_dir'],'-subjid', cenc_dirs['cenc']['id'],
'-all', '-i', 't1w.nii.gz',
'-T2', 't2tse.nii.gz',
'-FLAIR', 't2flair.nii.gz',
'-qcache',
'-measure', 'thickness',
'-measure', 'curv',
'-measure', 'sulc',
'-measure', 'area',
'-measure', 'jacobian_white'
]
util.iw_subprocess( freesurfer_command, True, True, True)
return
def run(in_filename, out_filename, in_transforms, scale, verbose_flag,
debug_flag):
if type(in_filename) is list:
filename = in_filename
else:
filename = [in_filename]
if type(in_transforms) is list:
transforms = in_transforms
else:
transforms = [in_transforms]
input_files = filename + transforms
if debug_flag:
print input_files
print
util.verify_inputs(input_files)
in_points = ctf.print_points_from_file(in_filename, verbose_flag)
cmd = [
"antsApplyTransformsToPoints", "-d", "3", "-i", in_filename, "-o",
out_filename, "-t"
] + transforms
util.iw_subprocess(cmd, debug_flag, debug_flag)
# Perform scaling
out_points = pd.read_csv(out_filename, sep=',', header=0)
out_points = ctf.scale_points(out_points, scale, debug_flag)
# Fix Comment Column
out_points['comment'] = in_points['comment']
#
ctf.write_points(out_filename, out_points, verbose_flag)
def ants_register(input_file):
# antsRegistration call:
#--------------------------------------------------------------------------------------
if False:
# I am having problems callling the interface. Same problem of bad interface.
command = ['antsRegistration', '--dimensionality', 3, '--float', 0,
'--output', '[', 'mt_Affine_nu__' + input_file +'_,',
'mt_Affine_nu__' + input_file + '_Warped.nii.gz,',
'mt_Affine_nu__' + input_file + '_InverseWarped.nii.gz', ']',
'--interpolation', 'Linear',
'--use-histogram-matching', 0,
'--winsorize-image-intensities', [0.005,0.995],
'--initial-moving-transform', '[', 'nu.nii.gz,' + input_file + '.nii.gz,', 1, ']',
'--transform', 'Rigid[0.1]',
'--metric', 'MI[nu.nii.gz,mt_m1.nii.gz,1,32,Regular,0.25]',
'--convergence', '[1000x500x250x0,1e-6,10]',
'--shrink-factors', '8x4x2x1',
'--smoothing-sigmas', '3x2x1x0vox',
'--transform', 'Affine[0.1]',
'--metric', 'MI[nu.nii.gz,' + input_file + '.nii.gz,1,32,Regular,0.25]',
'--convergence', '[1000x500x250x0,1e-6,10]',
'--shrink-factors', '8x4x2x1',
'--smoothing-sigmas', '3x2x1x0vox'
]
#--------------------------------------------------------------------------------------
# I am having problems callling the interface. Same problem of bad interface.
if False:
reg = Registration()
reg.inputs.fixed_image = 'nu.nii.gz'
reg.inputs.moving_image = input_file + '.nii.gz'
reg.inputs.output_transform_prefix = "mt_Affine_nu__" + input_file + "_"
reg.inputs.transforms = ['Affine']
reg.inputs.transform_parameters = [(2.0,), (0.25, 3.0, 0.0)]
reg.inputs.number_of_iterations = [[1000,500,200,100]]
reg.inputs.dimension = 3
reg.inputs.write_composite_transform = False
reg.inputs.collapse_output_transforms = False
reg.inputs.initialize_transforms_per_stage = False
reg.inputs.metric = ['MI']
reg.inputs.metric_weight = [1]
reg.inputs.radius_or_number_of_bins = [32]
reg.inputs.sampling_strategy = ['Random']
reg.inputs.sampling_percentage = [0.05]
reg.inputs.convergence_threshold = [1.e-10]
reg.inputs.convergence_window_size = [10]
reg.inputs.smoothing_sigmas = [[3,2,1,0]]
reg.inputs.sigma_units = ['vox']
reg.inputs.shrink_factors = [[8,4,2,1]]
reg.inputs.use_estimate_learning_rate_once = [True]
reg.inputs.use_histogram_matching = [True] # This is the default
reg.inputs.output_warped_image = 'mt_Affine_nu__' + input_file + '.nii.gz'
reg.inputs.terminal_output='stream'
print reg.cmdline
# reg.run()
# This simple command appears to work.
command = ['antsRegistrationSyNQuick.sh', '-d', '3', '-m', input_file + '.nii.gz', '-r', 'nu.nii.gz',
'-f', 'nu.nii.gz', '-t', 'a', '-o', 'mt_Affine_nu__' + input_file + '_'
]
util.iw_subprocess( command, True, True, False)
parser.add_argument("-v",
"--verbose",
help="Verbose flag",
action="store_true",
default=False)
inArgs = parser.parse_args()
#
#
#
input_files = [in_filename, iras_To_wras, wras_To_wlps]
util.verify_outputs(input_files)
cmd = [
"antsApplyTransformsToPoints", "-d", "3", "-i", points, "-o",
out_points, "-t"
] + inArgs.transforms
util.iw_subprocess(cmd, inArgs.verbose, inArgs.verbose)
#
#
#
if inArgs.verbose:
in_points = pd.read_csv(in_filename,
names=["x", "y", "z", "t", "label", "comment"])
print in_points
rpa_wras = np.dot(img_affine_matrix_ras, np.concatenate( (rpa_iras, [1]) ))
lpa_wlps = np.dot(affine_wras_to_wlps, lpa_wras )
nas_wlps = np.dot(affine_wras_to_wlps, nas_wras )
rpa_wlps = np.dot(affine_wras_to_wlps, rpa_wras )
[ rotate_ctf, translate_ctf, origin_ctf ] = ctf_calc_rotate_translate_origin( nas_wlps, lpa_wlps, rpa_wlps, ctf_scale)
affine_ctf = ctf_calc_affine( rotate_ctf, translate_ctf, 0*origin_ctf)
if inArgs.verbose:
print
print "Image LPS World to CTF matrix"
print affine_ctf
print
iwUtilities.save_itk_affine_matrix( affine_ctf, inArgs.wlps_to_wctf )
#
# Save MEG Fiducials in LPS World space.
#
iwUtilities.verify_that_file_exists(inArgs.meg_iras)
iwUtilities.verify_that_file_exists(inArgs.iras_to_wras)
iwUtilities.verify_that_file_exists(inArgs.wras_to_wlps)
cmd = [ "antsApplyTransformsToPoints", "-d", "3", "-i", inArgs.meg_iras, "-o", inArgs.meg_wlps, "-t", inArgs.iras_to_wras, inArgs.wras_to_wlps ]
iwUtilities.iw_subprocess(cmd, inArgs.verbose, True )
def results( input_dir, verbose):
cenc_dirs = cenc.directories( input_dir )
cenc_freesurfer_dir = cenc_dirs['freesurfer']['mri']
util.mkcd_dir( [ cenc_dirs['results']['dirs']['root'],
cenc_dirs['results']['dirs']['images'],
cenc_dirs['results']['dirs']['labels']
],
True
)
files_to_convert = [ os.path.join( cenc_freesurfer_dir, 'nu.mgz'),
os.path.join( cenc_freesurfer_dir, 'aseg.mgz'),
os.path.join( cenc_freesurfer_dir, 'brainmask.mgz'),
os.path.join( cenc_freesurfer_dir, 'aparc.a2009s+aseg.mgz'),
os.path.join( cenc_freesurfer_dir, 'wmparc.mgz')
]
# Check if files exist
if util.check_files(files_to_convert, True) == False:
sys.exit()
# Create link to directory
if not os.path.exists(cenc_dirs['freesurfer']['results']):
util.force_symbolic_link( cenc_dirs['freesurfer']['mri'], cenc_dirs['freesurfer']['results'])
# TODO use input node to run this instead of a loop. The trick part is to have the files named correctly.
for ii in files_to_convert:
mc = fs.MRIConvert( in_file = ii,
out_file = os.path.join( cenc_dirs['results']['dirs']['labels'],
str.replace( os.path.basename(ii),'.mgz','.nii.gz')),
out_type = 'niigz'
)
mc.run()
reorient = fsl.Reorient2Std( in_file = mc.inputs.out_file, out_file = mc.inputs.out_file)
reorient.run()
# Link nu.nii.gz to results/native/images
result_files = [ [ os.path.join( cenc_dirs['results']['dirs']['labels'], 'nu.nii.gz'),
os.path.join( cenc_dirs['results']['dirs']['images'], 'nu.nii.gz') ]
]
for ii in result_files:
util.force_hard_link( ii[0], ii[1])
# Create final brain mask.
cenc.create_mask( os.path.join( cenc_dirs['results']['dirs']['labels'], 'brainmask.nii.gz'),
os.path.join( cenc_dirs['results']['dirs']['labels'], 'aparc.a2009s+aseg.nii.gz'),
os.path.join( cenc_dirs['results']['dirs']['labels'], 'mask.nii.gz')
)
# Create macroscopic labels
util.iw_subprocess( ['cenc_aseg_labels.sh'], True, True, False)
def methods_03_stats(input_dir, verbose=False, min_lesion_volume=10):
cenc_dirs = cenc.directories(input_dir)
wm_lesions_dir = cenc_dirs['wmlesions']['dirs']['root']
wm_lesions_lpa_dir = cenc_dirs['wmlesions']['dirs']['lpa']
util.mkcd_dir([cenc_dirs['wmlesions']['dirs']['stats']], True)
wm_lesions_stats_filename = os.path.join(
cenc_dirs['wmlesions']['dirs']['stats'], 'wmlesions_lpa_labels.csv')
# Create labels file from LPA probability map
iw_labels_label.create(
os.path.join(cenc_dirs['wmlesions']['dirs']['lpa'],
'ples_lpa_mt2flair_Affine_nu__t2flair_Warped.nii.gz'),
os.path.join(cenc_dirs['wmlesions']['dirs']['stats'],
'wmlesions_lpa_labels.nii.gz'))
# Measure statistics of labels
iw_labels_stats.measure(
os.path.join(cenc_dirs['wmlesions']['dirs']['stats'],
'wmlesions_lpa_labels.nii.gz'),
None,
False, ['volume_mm3'],
wm_lesions_stats_filename,
limits_volume_voxels=[min_lesion_volume, numpy.inf],
limits_bb_volume_voxels=[0, numpy.inf],
limits_fill_factor=[0, 1],
sort='volume_mm3',
verbose=verbose,
verbose_nlines=20)
# Keep labels greater than 10 mm^3. Limit is set above
iw_labels_keep.keep(
os.path.join(cenc_dirs['wmlesions']['dirs']['stats'],
'wmlesions_lpa_labels.nii.gz'), [],
wm_lesions_stats_filename,
os.path.join(cenc_dirs['wmlesions']['dirs']['stats'],
'wmlesions_lpa_labels.nii.gz'))
# 1)
# 2) Create a WM Lesions mask
# 3)
command = [[
'fslmaths',
os.path.join(cenc_dirs['wmlesions']['dirs']['stats'],
'wmlesions_lpa_labels.nii.gz'), '-bin', '-mul',
os.path.join(cenc_dirs['wmlesions']['dirs']['lpa'],
'ples_lpa_mt2flair_Affine_nu__t2flair_Warped.nii.gz'),
'-mas',
os.path.join(cenc_dirs['wmlesions']['dirs']['input'], 'mask.nii.gz'),
os.path.join(cenc_dirs['wmlesions']['dirs']['stats'],
'wmlesions_lpa_pmap.nii.gz')
],
[
'fslmaths',
os.path.join(cenc_dirs['wmlesions']['dirs']['stats'],
'wmlesions_lpa_labels.nii.gz'), '-bin',
os.path.join(cenc_dirs['wmlesions']['dirs']['stats'],
'wmlesions_lpa_mask.nii.gz')
],
[
'fslmaths',
os.path.join(cenc_dirs['wmlesions']['dirs']['lpa'],
'mt2flair_Affine_nu__t2flair_Warped.nii.gz'),
'-mas',
os.path.join(cenc_dirs['wmlesions']['dirs']['input'],
'mask.nii.gz'),
os.path.join(cenc_dirs['wmlesions']['dirs']['stats'],
'wmlesions_lpa_t2flair.nii.gz')
]]
for ii in command:
util.iw_subprocess(ii, verbose, verbose, False)
# Write out JSON file with RedCap Instrument
methods_write_json_redcap_instrument(input_dir, wm_lesions_stats_filename,
verbose)
util.print_stage('Entering Stage 2 - Transform points and images', inArgs.verbose)
util.verify_inputs(stage2_input_files, inArgs.verbose)
util.mkcd_dir( stage2_directory )
util.link_inputs( stage2_input_files, stage2_directory)
command =['antsApplyTransforms', '-d', '3', '-i', image_native,
'-r', reference_ctf, '-o', out_image_ctf, '-t', affine_wlps_to_wctf ]
subprocess.Popen( " ".join(command), shell=True )
print reference_template, os.path.exists( reference_template )
util.iw_subprocess( ['antsApplyTransforms', '-d', '3', '-i', image_native,
'-r', reference_template, '-o', out_image_template, '-t', warp_native_to_template, affine_native_to_template, '-v'],
inArgs.verbose, inArgs.debug)
util.iw_subprocess( [ 'iwCreateRoi.py', '--image', image_native, '--csv', 'fiducials_native.csv', '-v', '-r', '--roi_prefix', 'fiducials.'],
inArgs.verbose, inArgs.debug)
util.iw_subprocess( [ 'iwCreateRoi.py', '--image', out_image_template, '--csv', 'fiducials_template.csv', '-v', '-r', '--roi_prefix', 'fiducials.'],
inArgs.verbose, inArgs.debug)
util.iw_subprocess( [ 'iwCreateRoi.py', '--image', out_image_ctf, '--csv', 'fiducials_ctf.csv', '-v', '-r', '--roi_prefix', 'fiducials.'],
inArgs.verbose, inArgs.debug)
util.verify_outputs(stage2_output_files, inArgs.verbose)
