def _bundles(row,
wm_labels,
odf_model="DTI",
directions="det",
force_recompute=False):
bundles_file = _get_fname(row,
'%s_%s_bundles.trk' % (odf_model, directions))
if not op.exists(bundles_file) or force_recompute:
streamlines_file = _streamlines(row,
wm_labels,
odf_model=odf_model,
directions=directions,
force_recompute=force_recompute)
tg = nib.streamlines.load(streamlines_file).tractogram
sl = tg.apply_affine(np.linalg.inv(row['dwi_affine'])).streamlines
bundle_dict = make_bundle_dict()
reg_template = dpd.read_mni_template()
mapping = reg.read_mapping(_mapping(row), row['dwi_file'],
reg_template)
bundles = seg.segment(row['dwi_file'],
row['bval_file'],
row['bvec_file'],
sl,
bundle_dict,
reg_template=reg_template,
mapping=mapping)
tgram = _tgramer(bundles, bundle_dict, row['dwi_affine'])
nib.streamlines.save(tgram, bundles_file)
return bundles_file
def test_segment():
dpd.fetch_stanford_hardi()
hardi_dir = op.join(fetcher.dipy_home, "stanford_hardi")
hardi_fdata = op.join(hardi_dir, "HARDI150.nii.gz")
hardi_fbval = op.join(hardi_dir, "HARDI150.bval")
hardi_fbvec = op.join(hardi_dir, "HARDI150.bvec")
file_dict = afd.read_stanford_hardi_tractography()
mapping = file_dict['mapping.nii.gz']
streamlines = file_dict['tractography_subsampled.trk']
templates = afd.read_templates()
bundles = {'CST_L': {'ROIs': [templates['CST_roi1_L'],
templates['CST_roi2_L']],
'rules': [True, True]},
'CST_R': {'ROIs': [templates['CST_roi1_R'],
templates['CST_roi1_R']],
'rules': [True, True]}}
fiber_groups = seg.segment(hardi_fdata,
hardi_fbval,
hardi_fbvec,
streamlines,
bundles,
mapping=mapping,
as_generator=True)
# We asked for 2 fiber groups:
npt.assert_equal(len(fiber_groups), 2)
# There happen to be 8 fibers in the right CST:
CST_R_sl = list(fiber_groups['CST_R'])
npt.assert_equal(len(CST_R_sl), 8)
# Calculate the tract profile for a volume of all-ones:
tract_profile = seg.calculate_tract_profile(
np.ones(nib.load(hardi_fdata).shape[:3]),
CST_R_sl)
npt.assert_equal(tract_profile, np.ones(100))
def _bundles(row, wm_labels, odf_model="DTI", directions="det",
force_recompute=False):
bundles_file = _get_fname(row,
'%s_%s_bundles.trk' % (odf_model,
directions))
if not op.exists(bundles_file) or force_recompute:
streamlines_file = _streamlines(row, wm_labels,
odf_model=odf_model,
directions=directions,
force_recompute=force_recompute)
tg = nib.streamlines.load(streamlines_file).tractogram
sl = tg.apply_affine(np.linalg.inv(row['dwi_affine'])).streamlines
bundle_dict = make_bundle_dict()
reg_template = dpd.read_mni_template()
mapping = reg.read_mapping(_mapping(row), row['dwi_file'],
reg_template)
bundles = seg.segment(row['dwi_file'],
row['bval_file'],
row['bvec_file'],
sl,
bundle_dict,
reg_template=reg_template,
mapping=mapping)
tgram = _tgramer(bundles, bundle_dict, row['dwi_affine'])
nib.streamlines.save(tgram, bundles_file)
return bundles_file
def main():
with open('config.json') as config_json:
config = json.load(config_json)
data_file = str(config['data_file'])
data_bval = str(config['data_bval'])
data_bvec = str(config['data_bvec'])
img = nib.load(data_file)
print("Calculating DTI...")
if not op.exists('./dti_FA.nii.gz'):
dti_params = dti.fit_dti(data_file, data_bval, data_bvec, out_dir='.')
else:
dti_params = {'FA': './dti_FA.nii.gz', 'params': './dti_params.nii.gz'}
tg = nib.streamlines.load('csa_prob.trk').tractogram
streamlines = tg.apply_affine(np.linalg.inv(img.affine)).streamlines
# Use only a small portion of the streamlines, for expedience:
streamlines = streamlines[::100]
templates = afd.read_templates()
bundle_names = ["CST", "ILF"]
bundles = {}
for name in bundle_names:
for hemi in ['_R', '_L']:
bundles[name + hemi] = {
'ROIs': [
templates[name + '_roi1' + hemi],
templates[name + '_roi1' + hemi]
],
'rules': [True, True]
}
print("Registering to template...")
MNI_T2_img = dpd.read_mni_template()
bvals, bvecs = read_bvals_bvecs(data_bval, data_bvec)
gtab = gradient_table(bvals, bvecs, b0_threshold=100)
mapping = reg.syn_register_dwi(data_file, gtab)
reg.write_mapping(mapping, './mapping.nii.gz')
print("Segmenting fiber groups...")
fiber_groups = seg.segment(data_file,
data_bval,
data_bvec,
streamlines,
bundles,
reg_template=MNI_T2_img,
mapping=mapping,
as_generator=False,
affine=img.affine)
"""
def _bundles(row,
wm_labels,
bundle_dict,
reg_template,
odf_model="DTI",
directions="det",
n_seeds=2,
random_seeds=False,
force_recompute=False):
bundles_file = _get_fname(row,
'%s_%s_bundles.trk' % (odf_model, directions))
if not op.exists(bundles_file) or force_recompute:
streamlines_file = _streamlines(row,
wm_labels,
odf_model=odf_model,
directions=directions,
n_seeds=n_seeds,
random_seeds=random_seeds,
force_recompute=force_recompute)
tg = nib.streamlines.load(streamlines_file).tractogram
sl = tg.apply_affine(np.linalg.inv(row['dwi_affine'])).streamlines
reg_prealign = np.load(
_reg_prealign(row, force_recompute=force_recompute))
mapping = reg.read_mapping(_mapping(row, reg_template),
row['dwi_file'],
reg_template,
prealign=np.linalg.inv(reg_prealign))
bundles = seg.segment(row['dwi_file'],
row['bval_file'],
row['bvec_file'],
sl,
bundle_dict,
reg_template=reg_template,
mapping=mapping)
tgram = aus.bundles_to_tgram(bundles, bundle_dict, row['dwi_affine'])
nib.streamlines.save(tgram, bundles_file)
return bundles_file
print("Registering to template...")
MNI_T2_img = dpd.read_mni_template()
if not op.exists('mapping.nii.gz'):
import dipy.core.gradients as dpg
gtab = dpg.gradient_table(hardi_fbval, hardi_fbvec)
mapping = reg.syn_register_dwi(hardi_fdata, gtab)
reg.write_mapping(mapping, './mapping.nii.gz')
else:
mapping = reg.read_mapping('./mapping.nii.gz', img, MNI_T2_img)
print("Segmenting fiber groups...")
fiber_groups = seg.segment(hardi_fdata,
hardi_fbval,
hardi_fbvec,
streamlines,
bundles,
reg_template=MNI_T2_img,
mapping=mapping,
as_generator=False,
affine=img.affine)
FA_img = nib.load(dti_params['FA'])
FA_data = FA_img.get_data()
print("Extracting tract profiles...")
for bundle in bundles:
fig, ax = plt.subplots(1)
profile = seg.calculate_tract_profile(FA_data, fiber_groups[bundle])
ax.plot(profile)
ax.set_title(bundle)
templates["FP_R"]],
'rules': [True, True],
'prob_map': templates['FP_prob_map'],
'cross_midline': True}
bundles["FA"] = {'ROIs': [templates["FA_L"],
templates["FA_R"]],
'rules': [True, True],
'prob_map': templates['FA_prob_map'],
'cross_midline': True}
print("Segmenting fiber groups...")
fiber_groups = seg.segment(fdata,
fbval,
fbvec,
streamlines,
bundles,
reg_template=MNI_T2_img,
mapping=mapping,
affine=img.affine,
clean_threshold=6,
prob_threshold=5)
print("Getting tract profiles")
n_points = 100
dfs = []
for bundle in fiber_groups:
print("Getting profile for: %s" % bundle)
if len(fiber_groups[bundle]) > 0:
bundle_df = pd.DataFrame(data={
'tractID': [bundle] * n_points,
def test_segment():
dpd.fetch_stanford_hardi()
hardi_dir = op.join(fetcher.dipy_home, "stanford_hardi")
hardi_fdata = op.join(hardi_dir, "HARDI150.nii.gz")
hardi_img = nib.load(hardi_fdata)
hardi_fbval = op.join(hardi_dir, "HARDI150.bval")
hardi_fbvec = op.join(hardi_dir, "HARDI150.bvec")
file_dict = afd.read_stanford_hardi_tractography()
mapping = file_dict['mapping.nii.gz']
streamlines = file_dict['tractography_subsampled.trk']
streamlines = dts.Streamlines(
dtu.move_streamlines(streamlines[streamlines._lengths > 10],
np.linalg.inv(hardi_img.affine)))
templates = afd.read_templates()
bundles = {
'CST_L': {
'ROIs': [templates['CST_roi1_L'], templates['CST_roi2_L']],
'rules': [True, True],
'prob_map': templates['CST_L_prob_map'],
'cross_midline': None
},
'CST_R': {
'ROIs': [templates['CST_roi1_R'], templates['CST_roi1_R']],
'rules': [True, True],
'prob_map': templates['CST_R_prob_map'],
'cross_midline': None
}
}
fiber_groups = seg.segment(hardi_fdata, hardi_fbval, hardi_fbvec,
streamlines, bundles, mapping)
# We asked for 2 fiber groups:
npt.assert_equal(len(fiber_groups), 2)
# Here's one of them:
CST_R_sl = fiber_groups['CST_R']
# Let's make sure there are streamlines in there:
npt.assert_(len(CST_R_sl) > 0)
# Calculate the tract profile for a volume of all-ones:
tract_profile = seg.calculate_tract_profile(
np.ones(nib.load(hardi_fdata).shape[:3]), CST_R_sl)
npt.assert_almost_equal(tract_profile, np.ones(100))
# Test providing an array input to calculate_tract_profile:
tract_profile = seg.calculate_tract_profile(
np.ones(nib.load(hardi_fdata).shape[:3]),
seg._resample_bundle(CST_R_sl, 100))
npt.assert_almost_equal(tract_profile, np.ones(100))
clean_sl = seg.clean_fiber_group(CST_R_sl)
# Since there are only 8 streamlines here, nothing should happen:
npt.assert_equal(clean_sl, CST_R_sl)
# Setting minimum number of streamlines to a smaller number and
# threshold to a relatively small number will exclude some streamlines:
clean_sl = seg.clean_fiber_group(CST_R_sl, min_sl=2, clean_threshold=2)
npt.assert_equal(len(clean_sl), 3)
# What if you don't have probability maps?
bundles = {
'CST_L': {
'ROIs': [templates['CST_roi1_L'], templates['CST_roi2_L']],
'rules': [True, True],
'cross_midline': False
},
'CST_R': {
'ROIs': [templates['CST_roi1_R'], templates['CST_roi1_R']],
'rules': [True, True],
'cross_midline': False
}
}
fiber_groups = seg.segment(hardi_fdata, hardi_fbval, hardi_fbvec,
streamlines, bundles, mapping)
# This condition should still hold
npt.assert_equal(len(fiber_groups), 2)
npt.assert_(len(fiber_groups['CST_R']) > 0)
def main():
with open('config.json') as config_json:
config = json.load(config_json)
#Paths to data
data_file = str(config['data_file'])
data_bval = str(config['data_bval'])
data_bvec = str(config['data_bvec'])
img = nib.load(data_file)
"""
print("Calculating DTI...")
if not op.exists('./dti_FA.nii.gz'):
dti_params = dti.fit_dti(data_file, data_bval, data_bvec, out_dir='.')
else:
dti_params = {'FA': './dti_FA.nii.gz',
'params': './dti_params.nii.gz'}
"""
#tg = nib.streamlines.load('track.trk').tractogram
tg = nib.streamlines.load(config['tck_data']).tractogram
streamlines = tg.apply_affine(np.linalg.inv(img.affine)).streamlines
# Use only a small portion of the streamlines, for expedience:
#streamlines = streamlines[::100]
templates = afd.read_templates()
bundle_names = ["CST", "ILF"]
bundles = {}
for name in bundle_names:
for hemi in ['_R', '_L']:
bundles[name + hemi] = {
'ROIs': [
templates[name + '_roi1' + hemi],
templates[name + '_roi1' + hemi]
],
'rules': [True, True]
}
print("Registering to template...")
if not op.exists('mapping.nii.gz'):
gtab = gradient_table(data_bval, data_bvec)
mapping = reg.syn_register_dwi(data_file, gtab)
reg.write_mapping(mapping, './mapping.nii.gz')
else:
mapping = reg.read_mapping('./mapping.nii.gz', img, MNI_T2_img)
"""
MNI_T2_img = dpd.read_mni_template()
bvals, bvecs = read_bvals_bvecs(data_bval, data_bvec)
gtab = gradient_table(bvals, bvecs, b0_threshold=100)
mapping = reg.syn_register_dwi(data_file, gtab)
reg.write_mapping(mapping, './mapping.nii.gz')
"""
print("Segmenting fiber groups...")
fiber_groups = seg.segment(data_file,
data_bval,
data_bvec,
streamlines,
bundles,
reg_template=MNI_T2_img,
mapping=mapping,
as_generator=False,
affine=img.affine)
path = os.getcwd() + '/tract1/'
if not os.path.exists(path):
os.makedirs(path)
for fg in fiber_groups:
streamlines = fiber_groups[fg]
fname = fg + ".tck"
trg = nib.streamlines.Tractogram(streamlines,
affine_to_rasmm=img.affine)
nib.streamlines.save(trg, path + fname)
print("Registering to template...")
MNI_T2_img = dpd.read_mni_template()
if not op.exists('mapping.nii.gz'):
import dipy.core.gradients as dpg
gtab = dpg.gradient_table(hardi_fbval, hardi_fbvec)
mapping = reg.syn_register_dwi(hardi_fdata, gtab)
reg.write_mapping(mapping, './mapping.nii.gz')
else:
mapping = reg.read_mapping('./mapping.nii.gz', img, MNI_T2_img)
print("Segmenting fiber groups...")
fiber_groups = seg.segment(hardi_fdata,
hardi_fbval,
hardi_fbvec,
streamlines,
bundles,
reg_template=MNI_T2_img,
mapping=mapping,
as_generator=False,
affine=img.affine)
print("Cleaning fiber groups...")
for bundle in bundles:
fiber_groups[bundle] = seg.clean_fiber_group(fiber_groups[bundle])
FA_img = nib.load(dti_params['FA'])
FA_data = FA_img.get_data()
print("Extracting tract profiles...")
for bundle in bundles:
def test_segment():
dpd.fetch_stanford_hardi()
hardi_dir = op.join(fetcher.dipy_home, "stanford_hardi")
hardi_fdata = op.join(hardi_dir, "HARDI150.nii.gz")
hardi_fbval = op.join(hardi_dir, "HARDI150.bval")
hardi_fbvec = op.join(hardi_dir, "HARDI150.bvec")
file_dict = afd.read_stanford_hardi_tractography()
mapping = file_dict['mapping.nii.gz']
streamlines = file_dict['tractography_subsampled.trk']
templates = afd.read_templates()
bundles = {'CST_L': {'ROIs': [templates['CST_roi1_L'],
templates['CST_roi2_L']],
'rules': [True, True],
'prob_map': templates['CST_L_prob_map'],
'cross_midline': False},
'CST_R': {'ROIs': [templates['CST_roi1_R'],
templates['CST_roi1_R']],
'rules': [True, True],
'prob_map': templates['CST_R_prob_map'],
'cross_midline': False}}
fiber_groups = seg.segment(hardi_fdata,
hardi_fbval,
hardi_fbvec,
streamlines,
bundles,
mapping=mapping,
as_generator=True)
# We asked for 2 fiber groups:
npt.assert_equal(len(fiber_groups), 2)
# There happen to be 5 fibers in the right CST:
CST_R_sl = fiber_groups['CST_R']
npt.assert_equal(len(CST_R_sl), 5)
# Calculate the tract profile for a volume of all-ones:
tract_profile = seg.calculate_tract_profile(
np.ones(nib.load(hardi_fdata).shape[:3]),
CST_R_sl)
npt.assert_almost_equal(tract_profile, np.ones(100))
# Test providing an array input to calculate_tract_profile:
tract_profile = seg.calculate_tract_profile(
np.ones(nib.load(hardi_fdata).shape[:3]),
seg._resample_bundle(CST_R_sl, 100))
npt.assert_almost_equal(tract_profile, np.ones(100))
clean_sl = seg.clean_fiber_group(CST_R_sl)
# Since there are only 5 streamlines here, nothing should happen:
npt.assert_equal(clean_sl, CST_R_sl)
# Setting minimum number of streamlines to a smaller number and
# threshold to a relatively small number will exclude some streamlines:
clean_sl = seg.clean_fiber_group(CST_R_sl, min_sl=2, clean_threshold=2)
npt.assert_equal(len(clean_sl), 3)
# What if you don't have probability maps?
bundles = {'CST_L': {'ROIs': [templates['CST_roi1_L'],
templates['CST_roi2_L']],
'rules': [True, True],
'cross_midline': False},
'CST_R': {'ROIs': [templates['CST_roi1_R'],
templates['CST_roi1_R']],
'rules': [True, True],
'cross_midline': False}}
fiber_groups = seg.segment(hardi_fdata,
hardi_fbval,
hardi_fbvec,
streamlines,
bundles,
mapping=mapping,
as_generator=True)
# This condition should still hold
npt.assert_equal(len(fiber_groups), 2)
# But one of the streamlines has switched identities without the
# probability map to guide selection
npt.assert_equal(len(fiber_groups['CST_R']), 6)
