"""
.. figure:: det_streamlines.png
:align: center
**Deterministic streamlines using EuDX (new framework)**
To learn more about this process you could start playing with the number of
seed points or, even better, specify seeds to be in specific regions of interest
in the brain.
Save the resulting streamlines in a Trackvis (.trk) format and FA as
Nifti1 (.nii.gz).
"""
save_trk(Tractogram(streamlines, affine_to_rasmm=img.affine),
'det_streamlines.trk')
save_nifti('fa_map.nii.gz', fa, img.affine)
"""
In Windows if you get a runtime error about frozen executable please start
your script by adding your code above in a ``main`` function and use:
``
if __name__ == '__main__':
import multiprocessing
multiprocessing.freeze_support()
main()
``
References
def dwi_dipy_run(dwi_dir,
node_size,
dir_path,
conn_model,
parc,
atlas_select,
network,
wm_mask=None):
from dipy.reconst.dti import TensorModel, quantize_evecs
from dipy.reconst.csdeconv import ConstrainedSphericalDeconvModel, recursive_response
from dipy.tracking.local import LocalTracking, ActTissueClassifier
from dipy.tracking import utils
from dipy.direction import peaks_from_model
from dipy.tracking.eudx import EuDX
from dipy.data import get_sphere, default_sphere
from dipy.core.gradients import gradient_table
from dipy.io import read_bvals_bvecs
from dipy.tracking.streamline import Streamlines
from dipy.direction import ProbabilisticDirectionGetter, ClosestPeakDirectionGetter, BootDirectionGetter
from nibabel.streamlines import save as save_trk
from nibabel.streamlines import Tractogram
##
dwi_dir = '/Users/PSYC-dap3463/Downloads/bedpostx_s002'
img_pve_csf = nib.load(
'/Users/PSYC-dap3463/Downloads/002_all/tmp/reg_a/t1w_vent_csf_diff_dwi.nii.gz'
)
img_pve_wm = nib.load(
'/Users/PSYC-dap3463/Downloads/002_all/tmp/reg_a/t1w_wm_in_dwi_bin.nii.gz'
)
img_pve_gm = nib.load(
'/Users/PSYC-dap3463/Downloads/002_all/tmp/reg_a/t1w_gm_mask_dwi.nii.gz'
)
labels_img = nib.load(
'/Users/PSYC-dap3463/Downloads/002_all/tmp/reg_a/dwi_aligned_atlas.nii.gz'
)
num_total_samples = 10000
tracking_method = 'boot' # Options are 'boot', 'prob', 'peaks', 'closest'
procmem = [2, 4]
##
if parc is True:
node_size = 'parc'
dwi_img = "%s%s" % (dwi_dir, '/dwi.nii.gz')
nodif_brain_mask_path = "%s%s" % (dwi_dir, '/nodif_brain_mask.nii.gz')
bvals = "%s%s" % (dwi_dir, '/bval')
bvecs = "%s%s" % (dwi_dir, '/bvec')
dwi_img = nib.load(dwi_img)
data = dwi_img.get_data()
[bvals, bvecs] = read_bvals_bvecs(bvals, bvecs)
gtab = gradient_table(bvals, bvecs)
gtab.b0_threshold = min(bvals)
sphere = get_sphere('symmetric724')
# Loads mask and ensures it's a true binary mask
mask_img = nib.load(nodif_brain_mask_path)
mask = mask_img.get_data()
mask = mask > 0
# Fit a basic tensor model first
model = TensorModel(gtab)
ten = model.fit(data, mask)
fa = ten.fa
# Tractography
if conn_model == 'csd':
print('Tracking with csd model...')
elif conn_model == 'tensor':
print('Tracking with tensor model...')
else:
raise RuntimeError("%s%s" % (conn_model, ' is not a valid model.'))
# Combine seed counts from voxel with seed counts total
wm_mask_data = img_pve_wm.get_data()
wm_mask_data[0, :, :] = False
wm_mask_data[:, 0, :] = False
wm_mask_data[:, :, 0] = False
seeds = utils.seeds_from_mask(wm_mask_data,
density=1,
affine=dwi_img.get_affine())
seeds_rnd = utils.random_seeds_from_mask(ten.fa > 0.02,
seeds_count=num_total_samples,
seed_count_per_voxel=True)
seeds_all = np.vstack([seeds, seeds_rnd])
# Load tissue maps and prepare tissue classifier (Anatomically-Constrained Tractography (ACT))
background = np.ones(img_pve_gm.shape)
background[(img_pve_gm.get_data() + img_pve_wm.get_data() +
img_pve_csf.get_data()) > 0] = 0
include_map = img_pve_gm.get_data()
include_map[background > 0] = 1
exclude_map = img_pve_csf.get_data()
act_classifier = ActTissueClassifier(include_map, exclude_map)
if conn_model == 'tensor':
ind = quantize_evecs(ten.evecs, sphere.vertices)
streamline_generator = EuDX(a=fa,
ind=ind,
seeds=seeds_all,
odf_vertices=sphere.vertices,
a_low=0.05,
step_sz=.5)
elif conn_model == 'csd':
print('Tracking with CSD model...')
response = recursive_response(
gtab,
data,
mask=img_pve_wm.get_data().astype('bool'),
sh_order=8,
peak_thr=0.01,
init_fa=0.05,
init_trace=0.0021,
iter=8,
convergence=0.001,
parallel=True)
csd_model = ConstrainedSphericalDeconvModel(gtab, response)
if tracking_method == 'boot':
dg = BootDirectionGetter.from_data(data,
csd_model,
max_angle=30.,
sphere=default_sphere)
elif tracking_method == 'prob':
try:
print(
'First attempting to build the direction getter directly from the spherical harmonic representation of the FOD...'
)
csd_fit = csd_model.fit(
data, mask=img_pve_wm.get_data().astype('bool'))
dg = ProbabilisticDirectionGetter.from_shcoeff(
csd_fit.shm_coeff, max_angle=30., sphere=default_sphere)
except:
print(
'Sphereical harmonic not available for this model. Using peaks_from_model to represent the ODF of the model on a spherical harmonic basis instead...'
)
peaks = peaks_from_model(
csd_model,
data,
default_sphere,
.5,
25,
mask=img_pve_wm.get_data().astype('bool'),
return_sh=True,
parallel=True,
nbr_processes=procmem[0])
dg = ProbabilisticDirectionGetter.from_shcoeff(
peaks.shm_coeff, max_angle=30., sphere=default_sphere)
elif tracking_method == 'peaks':
dg = peaks_from_model(model=csd_model,
data=data,
sphere=default_sphere,
relative_peak_threshold=.5,
min_separation_angle=25,
mask=img_pve_wm.get_data().astype('bool'),
parallel=True,
nbr_processes=procmem[0])
elif tracking_method == 'closest':
csd_fit = csd_model.fit(data,
mask=img_pve_wm.get_data().astype('bool'))
pmf = csd_fit.odf(default_sphere).clip(min=0)
dg = ClosestPeakDirectionGetter.from_pmf(pmf,
max_angle=30.,
sphere=default_sphere)
streamline_generator = LocalTracking(dg,
act_classifier,
seeds_all,
affine=dwi_img.affine,
step_size=0.5)
del dg
try:
del csd_fit
except:
pass
try:
del response
except:
pass
try:
del csd_model
except:
pass
streamlines = Streamlines(streamline_generator, buffer_size=512)
save_trk(Tractogram(streamlines, affine_to_rasmm=dwi_img.affine),
'prob_streamlines.trk')
tracks = [sl for sl in streamlines if len(sl) > 1]
labels_data = labels_img.get_data().astype('int')
labels_affine = labels_img.affine
conn_matrix, grouping = utils.connectivity_matrix(
tracks,
labels_data,
affine=labels_affine,
return_mapping=True,
mapping_as_streamlines=True,
symmetric=True)
conn_matrix[:3, :] = 0
conn_matrix[:, :3] = 0
return conn_matrix
"""
.. figure:: det_streamlines.png
:align: center
**Deterministic streamlines using EuDX (new framework)**
To learn more about this process you could start playing with the number of
seed points or, even better, specify seeds to be in specific regions of interest
in the brain.
Save the resulting streamlines in a Trackvis (.trk) format and FA as
Nifti (.nii.gz).
"""
save_trk(Tractogram(streamlines, affine_to_rasmm=img.affine),
'det_streamlines.trk')
save_nifti('fa_map.nii.gz', fa, img.affine)
"""
In Windows if you get a runtime error about frozen executable please start
your script by adding your code above in a ``main`` function and use::
if __name__ == '__main__':
import multiprocessing
multiprocessing.freeze_support()
main()
References
----------
"""
.. figure:: det_streamlines.png
:align: center
**Deterministic streamlines using EuDX (new framework)**
To learn more about this process you could start playing with the number of
seed points or, even better, specify seeds to be in specific regions of interest
in the brain.
Save the resulting streamlines in a Trackvis (.trk) format and FA as
Nifti1 (.nii.gz).
"""
save_trk(
Tractogram(streamlines, affine_to_rasmm=img.affine),
'/Users/ptm/desktop/Current_working_directory/DIPY/det_streamlines.trk')
save_nifti('/Users/ptm/desktop/Current_working_directory/DIPY/fa_map.nii.gz',
fa, img.affine)
##
##
##
import nibabel as nib
#newImage = join(dname, 'HARDI193_S0.nii.gz')
newImage = '/Users/ptm/desktop/Current_working_directory/DIPY/fa_map.nii.gz'
img = nib.load(newImage)
data = img.get_data()
import matplotlib.pyplot as plt
axial_middle = data.shape[2] // 2