def determine(name=None,
data_path=None,
output_path='.',
Threshold=.20,
data_list=None,
seed='.',
minus_ROI_mask='.',
one_node=False,
two_node=False):
time0 = time.time()
print("begin loading data, time:", time.time() - time0)
if data_list == None:
data, affine, img, labels, gtab, head_mask = get_data(name, data_path)
else:
data = data_list['DWI']
affine = data_list['affine']
img = data_list['img']
labels = data_list['labels']
gtab = data_list['gtab']
head_mask = data_list['head_mask']
print(type(seed))
if type(seed) != str:
seed_mask = seed
else:
seed_mask = (labels == 2) * (head_mask == 1)
white_matter = (labels == 2) * (head_mask == 1)
seeds = utils.seeds_from_mask(seed_mask, affine, density=1)
print("begin reconstruction, time:", time.time() - time0)
response, ratio = auto_response_ssst(gtab, data, roi_radii=10, fa_thr=0.7)
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
csd_fit = csd_model.fit(data, mask=white_matter)
csa_model = CsaOdfModel(gtab, sh_order=6)
gfa = csa_model.fit(data, mask=white_matter).gfa
stopping_criterion = ThresholdStoppingCriterion(gfa, Threshold)
#from dipy.data import small_sphere
print("begin tracking, time:", time.time() - time0)
detmax_dg = DeterministicMaximumDirectionGetter.from_shcoeff(
csd_fit.shm_coeff, max_angle=30., sphere=default_sphere)
streamline_generator = LocalTracking(detmax_dg,
stopping_criterion,
seeds,
affine,
step_size=.5)
streamlines = Streamlines(streamline_generator)
sft = StatefulTractogram(streamlines, img, Space.RASMM)
if one_node or two_node:
sft.to_vox()
streamlines = reduct_seed_ROI(sft.streamlines, seed_mask, one_node,
two_node)
if type(minus_ROI_mask) != str:
streamlines = minus_ROI(streamlines=streamlines,
ROI=minus_ROI_mask)
sft = StatefulTractogram(streamlines, img, Space.VOX)
sft._vox_to_rasmm()
print("begin saving, time:", time.time() - time0)
output = output_path + '/tractogram_deterministic_' + name + '.trk'
save_trk(sft, output)
print("finished, time:", time.time() - time0)
voxel in the data set as a collection of small white matter fibers with
different orientations. The density of fibers along each orientation is known
as the Fiber Orientation Distribution (FOD). In order to perform probabilistic
fiber tracking, we pick a fiber from the FOD at random at each new location
along the streamline. Note: one could use this model to perform deterministic
fiber tracking by always tracking along the directions that have the most
fibers.
Let's begin probabilistic fiber tracking by fitting the data to the CSD model.
"""
from dipy.reconst.csdeconv import (ConstrainedSphericalDeconvModel,
auto_response)
response, ratio = auto_response(gtab, data, roi_radius=10, fa_thr=0.7)
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
csd_fit = csd_model.fit(data, mask=white_matter)
"""
Next we'll need to make a ``ProbabilisticDirectionGetter``. Because the CSD
model represents the FOD using the spherical harmonic basis, we can use the
``from_shcoeff`` method to create the direction getter. This direction getter
will randomly sample directions from the FOD each time the tracking algorithm
needs to take another step.
"""
from dipy.direction import ProbabilisticDirectionGetter
prob_dg = ProbabilisticDirectionGetter.from_shcoeff(csd_fit.shm_coeff,
max_angle=30.,
sphere=default_sphere)
"""
def test_recursive_response_calibration():
"""
Test the recursive response calibration method.
"""
SNR = 100
S0 = 1
sh_order = 8
_, fbvals, fbvecs = get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
sphere = get_sphere('symmetric724')
gtab = gradient_table(bvals, bvecs)
evals = np.array([0.0015, 0.0003, 0.0003])
evecs = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]]).T
mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (90, 0)]
where_dwi = lazy_index(~gtab.b0s_mask)
S_cross, sticks_cross = multi_tensor(gtab,
mevals,
S0,
angles=angles,
fractions=[50, 50],
snr=SNR)
S_single = single_tensor(gtab, S0, evals, evecs, snr=SNR)
data = np.concatenate((np.tile(S_cross, (8, 1)), np.tile(S_single,
(2, 1))),
axis=0)
odf_gt_cross = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
odf_gt_single = single_tensor_odf(sphere.vertices, evals, evecs)
response = recursive_response(gtab,
data,
mask=None,
sh_order=8,
peak_thr=0.01,
init_fa=0.05,
init_trace=0.0021,
iter=8,
convergence=0.001,
parallel=False)
csd = ConstrainedSphericalDeconvModel(gtab, response)
csd_fit = csd.fit(data)
assert_equal(np.all(csd_fit.shm_coeff[:, 0] >= 0), True)
fodf = csd_fit.odf(sphere)
directions_gt_single, _, _ = peak_directions(odf_gt_single, sphere)
directions_gt_cross, _, _ = peak_directions(odf_gt_cross, sphere)
directions_single, _, _ = peak_directions(fodf[8, :], sphere)
directions_cross, _, _ = peak_directions(fodf[0, :], sphere)
ang_sim = angular_similarity(directions_cross, directions_gt_cross)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions_cross.shape[0], 2)
assert_equal(directions_gt_cross.shape[0], 2)
ang_sim = angular_similarity(directions_single, directions_gt_single)
assert_equal(ang_sim > 0.9, True)
assert_equal(directions_single.shape[0], 1)
assert_equal(directions_gt_single.shape[0], 1)
sphere = Sphere(xyz=gtab.gradients[where_dwi])
sf = response.on_sphere(sphere)
S = np.concatenate(([response.S0], sf))
tenmodel = dti.TensorModel(gtab, min_signal=0.001)
tenfit = tenmodel.fit(S)
FA = fractional_anisotropy(tenfit.evals)
FA_gt = fractional_anisotropy(evals)
assert_almost_equal(FA, FA_gt, 1)
35:42] """ Enables/disables interactive visualization """ interactive = False """ Fit an initial model to the data, in this case Constrained Spherical Deconvolution is used. """ # Perform CSD on the original data response, ratio = auto_response(gtab, data, roi_radius=10, fa_thr=0.7) csd_model_orig = ConstrainedSphericalDeconvModel(gtab, response) csd_fit_orig = csd_model_orig.fit(data_small) csd_shm_orig = csd_fit_orig.shm_coeff # Perform CSD on the original data + noise response, ratio = auto_response(gtab, data_noisy, roi_radius=10, fa_thr=0.7) csd_model_noisy = ConstrainedSphericalDeconvModel(gtab, response) csd_fit_noisy = csd_model_noisy.fit(data_noisy_small) csd_shm_noisy = csd_fit_noisy.shm_coeff """ Inspired by [Rodrigues2010]_, a lookup-table is created, containing rotated versions of the kernel :math:`P_t` sampled over a discrete set of orientations. In order to ensure rotationally invariant processing, the discrete orientations are required to be equally distributed over a sphere. By default, a sphere with 100 directions is used.
classifier = ThresholdTissueClassifier(csa_peaks.gfa, 0.25)
"""
In order to perform probabilistic fiber tracking we first fit the data to the
Constrained Spherical Deconvolution (CSD) model in DIPY. This model represents
each voxel in the data set as a collection of small white matter fibers with
different orientations. The density of fibers along each orientation is known
as the Fiber Orientation Distribution (FOD), used in the fiber tracking.
"""
# Perform CSD on the original data
from dipy.reconst.csdeconv import auto_response
from dipy.reconst.csdeconv import ConstrainedSphericalDeconvModel
response, ratio = auto_response(gtab, data, roi_radius=10, fa_thr=0.7)
csd_model = ConstrainedSphericalDeconvModel(gtab, response)
csd_fit = csd_model.fit(data_small)
csd_fit_shm = np.lib.pad(csd_fit.shm_coeff,
((xa, dshape[0] - xb), (ya, dshape[1] - yb),
(za, dshape[2] - zb), (0, 0)), 'constant')
# Probabilistic direction getting for fiber tracking
from dipy.direction import ProbabilisticDirectionGetter
prob_dg = ProbabilisticDirectionGetter.from_shcoeff(csd_fit_shm,
max_angle=30.,
sphere=default_sphere)
"""
The optic radiation is reconstructed by tracking fibers from the calcarine
sulcus (visual cortex V1) to the lateral geniculate nucleus (LGN). We seed
from the calcarine sulcus by selecting a region-of-interest (ROI) cube of
def dmri_recon(sid,
data_dir,
out_dir,
resolution,
recon='csd',
dirs='',
num_threads=2):
import tempfile
#tempfile.tempdir = '/om/scratch/Fri/ksitek/'
import os
oldval = None
if 'MKL_NUM_THREADS' in os.environ:
oldval = os.environ['MKL_NUM_THREADS']
os.environ['MKL_NUM_THREADS'] = '%d' % num_threads
ompoldval = None
if 'OMP_NUM_THREADS' in os.environ:
ompoldval = os.environ['OMP_NUM_THREADS']
os.environ['OMP_NUM_THREADS'] = '%d' % num_threads
import nibabel as nib
import numpy as np
from glob import glob
if resolution == '0.2mm':
filename = 'Reg_S64550_nii4d.nii'
#filename = 'angular_resample/dwi_%s.nii.gz'%dirs
fimg = os.path.abspath(glob(os.path.join(data_dir, filename))[0])
else:
filename = 'Reg_S64550_nii4d_resamp-%s.nii.gz' % (resolution)
fimg = os.path.abspath(
glob(os.path.join(data_dir, 'resample', filename))[0])
print("dwi file = %s" % fimg)
fbval = os.path.abspath(
glob(os.path.join(data_dir, 'bvecs', 'camino_120_RAS.bvals'))[0])
print("bval file = %s" % fbval)
fbvec = os.path.abspath(
glob(os.path.join(data_dir, 'bvecs',
'camino_120_RAS_flipped-xy.bvecs'))[0])
# 'angular_resample',
# 'dwi_%s.bvecs'%dirs))[0])
print("bvec file = %s" % fbvec)
img = nib.load(fimg)
data = img.get_fdata()
affine = img.get_affine()
prefix = sid
from dipy.io import read_bvals_bvecs
bvals, bvecs = read_bvals_bvecs(fbval, fbvec)
'''
from dipy.core.gradients import vector_norm
b0idx = []
for idx, val in enumerate(bvals):
if val < 1:
pass
#bvecs[idx] = [1, 0, 0]
else:
b0idx.append(idx)
#print "b0idx=%d"%idx
#print "input bvecs:"
#print bvecs
bvecs[b0idx, :] = bvecs[b0idx, :]/vector_norm(bvecs[b0idx])[:, None]
#print "bvecs after normalization:"
#print bvecs
'''
from dipy.core.gradients import gradient_table
gtab = gradient_table(bvals, bvecs)
gtab.bvecs.shape == bvecs.shape
gtab.bvecs
gtab.bvals.shape == bvals.shape
gtab.bvals
#from dipy.segment.mask import median_otsu
#b0_mask, mask = median_otsu(data[:, :, :, b0idx].mean(axis=3).squeeze(), 4, 4)
if resolution == '0.2mm':
mask_name = 'Reg_S64550_nii_b0-slice_mask.nii.gz'
fmask1 = os.path.join(data_dir, mask_name)
else:
mask_name = 'Reg_S64550_nii_b0-slice_mask_resamp-%s.nii.gz' % (
resolution)
fmask1 = os.path.join(data_dir, 'resample', mask_name)
print("fmask file = %s" % fmask1)
mask = nib.load(fmask1).get_fdata()
''' DTI model & save metrics '''
from dipy.reconst.dti import TensorModel
print("running tensor model")
tenmodel = TensorModel(gtab)
tenfit = tenmodel.fit(data, mask)
from dipy.reconst.dti import fractional_anisotropy
print("running FA")
FA = fractional_anisotropy(tenfit.evals)
FA[np.isnan(FA)] = 0
fa_img = nib.Nifti1Image(FA, img.get_affine())
tensor_fa_file = os.path.abspath('%s_tensor_fa.nii.gz' % (prefix))
nib.save(fa_img, tensor_fa_file)
from dipy.reconst.dti import axial_diffusivity
print("running AD")
AD = axial_diffusivity(tenfit.evals)
AD[np.isnan(AD)] = 0
ad_img = nib.Nifti1Image(AD, img.get_affine())
tensor_ad_file = os.path.abspath('%s_tensor_ad.nii.gz' % (prefix))
nib.save(ad_img, tensor_ad_file)
from dipy.reconst.dti import radial_diffusivity
print("running RD")
RD = radial_diffusivity(tenfit.evals)
RD[np.isnan(RD)] = 0
rd_img = nib.Nifti1Image(RD, img.get_affine())
tensor_rd_file = os.path.abspath('%s_tensor_rd.nii.gz' % (prefix))
nib.save(rd_img, tensor_rd_file)
from dipy.reconst.dti import mean_diffusivity
print("running MD")
MD = mean_diffusivity(tenfit.evals)
MD[np.isnan(MD)] = 0
md_img = nib.Nifti1Image(MD, img.get_affine())
tensor_md_file = os.path.abspath('%s_tensor_md.nii.gz' % (prefix))
nib.save(md_img, tensor_md_file)
evecs = tenfit.evecs
evec_img = nib.Nifti1Image(evecs, img.get_affine())
tensor_evec_file = os.path.abspath('%s_tensor_evec.nii.gz' % (prefix))
nib.save(evec_img, tensor_evec_file)
''' ODF model '''
useFA = True
print("creating %s model" % recon)
if recon == 'csd':
from dipy.reconst.csdeconv import ConstrainedSphericalDeconvModel
from dipy.reconst.csdeconv import auto_response
response, ratio = auto_response(gtab, data, roi_radius=10,
fa_thr=0.5) # 0.7
model = ConstrainedSphericalDeconvModel(gtab, response)
useFA = True
return_sh = True
elif recon == 'csa':
from dipy.reconst.shm import CsaOdfModel, normalize_data
model = CsaOdfModel(gtab, sh_order=8)
useFA = True
return_sh = True
elif recon == 'gqi':
from dipy.reconst.gqi import GeneralizedQSamplingModel
model = GeneralizedQSamplingModel(gtab)
return_sh = False
else:
raise ValueError('only csd, csa supported currently')
from dipy.reconst.dsi import (DiffusionSpectrumDeconvModel,
DiffusionSpectrumModel)
model = DiffusionSpectrumDeconvModel(gtab)
'''reconstruct ODFs'''
from dipy.data import get_sphere
sphere = get_sphere('symmetric724')
#odfs = fit.odf(sphere)
# with CSD/GQI, uses > 50GB per core; don't get greedy with cores!
from dipy.reconst.peaks import peaks_from_model
print("running peaks_from_model")
peaks = peaks_from_model(
model=model,
data=data,
sphere=sphere,
mask=mask,
return_sh=return_sh,
return_odf=False,
normalize_peaks=True,
npeaks=5,
relative_peak_threshold=.5,
min_separation_angle=10, #25,
parallel=num_threads > 1,
nbr_processes=num_threads)
# save the peaks
from dipy.io.peaks import save_peaks
peaks_file = os.path.abspath('%s_peaks.pam5' % (prefix))
save_peaks(peaks_file, peaks)
# save the spherical harmonics
shm_coeff_file = os.path.abspath('%s_shm_coeff.nii.gz' % (prefix))
if return_sh:
shm_coeff = peaks.shm_coeff
nib.save(nib.Nifti1Image(shm_coeff, img.get_affine()), shm_coeff_file)
else:
# if it's not a spherical model, output it as an essentially null file
np.savetxt(shm_coeff_file, [0])
# save the generalized fractional anisotropy image
gfa_img = nib.Nifti1Image(peaks.gfa, img.get_affine())
model_gfa_file = os.path.abspath('%s_%s_gfa.nii.gz' % (prefix, recon))
nib.save(gfa_img, model_gfa_file)
#from dipy.reconst.dti import quantize_evecs
#peak_indices = quantize_evecs(tenfit.evecs, sphere.vertices)
#eu = EuDX(FA, peak_indices, odf_vertices = sphere.vertices,
#a_low=0.2, seeds=10**6, ang_thr=35)
''' probabilistic tracking '''
'''
from dipy.direction import ProbabilisticDirectionGetter
from dipy.tracking.local import LocalTracking
from dipy.tracking.streamline import Streamlines
from dipy.io.streamline import save_trk
prob_dg = ProbabilisticDirectionGetter.from_shcoeff(shm_coeff,
max_angle=45.,
sphere=sphere)
streamlines_generator = LocalTracking(prob_dg,
affine,
step_size=.5,
max_cross=1)
# Generate streamlines object
streamlines = Streamlines(streamlines_generator)
affine = img.get_affine()
vox_size=fa_img.get_header().get_zooms()[:3]
fname = os.path.abspath('%s_%s_prob_streamline.trk' % (prefix, recon))
save_trk(fname, streamlines, affine, vox_size=vox_size)
'''
''' deterministic tracking with EuDX method'''
from dipy.tracking.eudx import EuDX
print("reconstructing with EuDX")
if useFA:
eu = EuDX(
FA,
peaks.peak_indices[..., 0],
odf_vertices=sphere.vertices,
a_low=0.001, # default is 0.0239
seeds=10**6,
ang_thr=75)
else:
eu = EuDX(
peaks.gfa,
peaks.peak_indices[..., 0],
odf_vertices=sphere.vertices,
#a_low=0.1,
seeds=10**6,
ang_thr=45)
sl_fname = os.path.abspath('%s_%s_det_streamline.trk' % (prefix, recon))
# trying new dipy.io.streamline module, per email to neuroimaging list
# 2018.04.05
from nibabel.streamlines import Field
from nibabel.orientations import aff2axcodes
affine = img.get_affine()
vox_size = fa_img.get_header().get_zooms()[:3]
fov_shape = FA.shape[:3]
if vox_size is not None and fov_shape is not None:
hdr = {}
hdr[Field.VOXEL_TO_RASMM] = affine.copy()
hdr[Field.VOXEL_SIZES] = vox_size
hdr[Field.DIMENSIONS] = fov_shape
hdr[Field.VOXEL_ORDER] = "".join(aff2axcodes(affine))
tractogram = nib.streamlines.Tractogram(eu)
tractogram.affine_to_rasmm = affine
trk_file = nib.streamlines.TrkFile(tractogram, header=hdr)
nib.streamlines.save(trk_file, sl_fname)
if oldval:
os.environ['MKL_NUM_THREADS'] = oldval
else:
del os.environ['MKL_NUM_THREADS']
if ompoldval:
os.environ['OMP_NUM_THREADS'] = ompoldval
else:
del os.environ['OMP_NUM_THREADS']
print('all output files created')
return (tensor_fa_file, tensor_evec_file, model_gfa_file, sl_fname, affine,
tensor_ad_file, tensor_rd_file, tensor_md_file, shm_coeff_file,
peaks_file)
def fiber_tracking(subject):
# declare the type of algorithm, \in [deterministic, probabilitic]
algo = 'deterministic'
# algo = 'probabilitic'
'''
@param subject: string represents the subject name
@param algo: the name for the algorithms, \in ['deterministic', 'probabilitic']
@return streamlines: for saving the final results and visualization
'''
print('processing for', subject)
fname, bval_fname, bvec_fname, label_fname = get_file_names(subject)
data, sub_affine, img = load_nifti(fname, return_img=True)
bvals, bvecs = read_bvals_bvecs(bval_fname, bvec_fname)
gtab = gradient_table(bvals, bvecs)
labels = load_nifti_data(label_fname)
print('data loading complete.\n')
##################################################################
# set mask(s) and seed(s)
# global_mask = binary_dilation((data[:, :, :, 0] != 0))
global_mask = binary_dilation((labels == 1) | (labels == 2))
# global_mask = binary_dilation((labels == 2) | (labels == 32) | (labels == 76))
affine = np.eye(4)
seeds = utils.seeds_from_mask(global_mask, affine, density=1)
print('mask(s) and seed(s) set complete.\n')
##################################################################
print('getting directions from diffusion dataset...')
# define tracking mask with Constant Solid Angle (CSA)
csamodel = CsaOdfModel(gtab, 6)
stopping_criterion = BinaryStoppingCriterion(global_mask)
# define direction criterion
direction_criterion = None
print('Compute directions...')
if algo == "deterministic":
# EuDX
direction_criterion = peaks.peaks_from_model(
model=csamodel,
data=data,
sphere=peaks.default_sphere,
relative_peak_threshold=.8,
min_separation_angle=45,
mask=global_mask)
# # Deterministic Algorithm (select direction with max probability)
# direction_criterion = DeterministicMaximumDirectionGetter.from_shcoeff(
# csd_fit.shm_coeff,
# max_angle=30.,
# sphere=default_sphere)
else:
response, ratio = auto_response(gtab, data, roi_radius=10, fa_thr=0.7)
# fit the reconstruction model with Constrained Spherical Deconvolusion (CSD)
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
csd_fit = csd_model.fit(data, mask=global_mask)
# gfa = csamodel.fit(data, mask=global_mask).gfa
# stopping_criterion = ThresholdStoppingCriterion(gfa, .25)
# Probabilitic Algorithm
direction_criterion = ProbabilisticDirectionGetter.from_shcoeff(
csd_fit.shm_coeff, max_angle=30., sphere=default_sphere)
print('direction computation complete.\n')
##################################################################
print('start tracking process...')
# start tracking
streamline_generator = LocalTracking(direction_criterion,
stopping_criterion,
seeds,
affine=affine,
step_size=0.5)
# Generate streamlines object
streamlines = Streamlines(streamline_generator)
sft = StatefulTractogram(streamlines, img, Space.RASMM)
print('traking complete.\n')
##################################################################
return {
"subject": subject,
"streamlines": streamlines,
"sft": sft,
"affine": sub_affine,
"data": data,
"img": img,
"labels": labels
}
def get_csd_streamlines(data_container,
random_seeds=False,
seeds_count=30000,
seeds_per_voxel=False,
step_width=1.0,
roi_r=10,
auto_response_fa_threshold=0.7,
fa_threshold=0.15,
relative_peak_threshold=0.5,
min_separation_angle=25):
"""
Tracks and returns CSD Streamlines for the given DataContainer.
Parameters
----------
data_container
The DataContainer we would like to track streamlines on
random_seeds
A boolean indicating whether we would like to use random seeds
seeds_count
If we use random seeds, this specifies the seed count
seeds_per_voxel
If True, the seed count is specified per voxel
step_width
The step width used while tracking
roi_r
The radii of the cuboid roi for the automatic estimation of single-shell single-tissue response function using FA.
auto_response_fa_threshold
The FA threshold for the automatic estimation of single-shell single-tissue response function using FA.
fa_threshold
The FA threshold to use to stop tracking
relative_peak_threshold
The relative peak threshold to use to get peaks from the CSDModel
min_separation_angle
The minimal separation angle of peaks
Returns
-------
Streamlines
A list of Streamlines
"""
seeds = _get_seeds(data_container, random_seeds, seeds_count,
seeds_per_voxel)
response, _ = auto_response_ssst(data_container.gtab,
data_container.dwi,
roi_radii=roi_r,
fa_thr=auto_response_fa_threshold)
csd_model = ConstrainedSphericalDeconvModel(data_container.gtab, response)
direction_getter = peaks_from_model(
model=csd_model,
data=data_container.dwi,
sphere=get_sphere('symmetric724'),
mask=data_container.binary_mask,
relative_peak_threshold=relative_peak_threshold,
min_separation_angle=min_separation_angle,
parallel=False)
dti_fit = dti.TensorModel(data_container.gtab, fit_method='LS').fit(
data_container.dwi, mask=data_container.binary_mask)
classifier = ThresholdStoppingCriterion(dti_fit.fa, fa_threshold)
streamlines_generator = LocalTracking(direction_getter,
classifier,
seeds,
data_container.aff,
step_size=step_width)
streamlines = Streamlines(streamlines_generator)
return streamlines
def tracking(image,
bvecs,
bvals,
wm,
seeds,
fibers,
prune_length=3,
rseed=42,
plot=False,
proba=False,
verbose=False):
# Pipelines transcribed from:
# https://dipy.org/documentation/1.1.1./examples_built/tracking_introduction_eudx/#example-tracking-introduction-eudx
# https://dipy.org/documentation/1.1.1./examples_built/tracking_probabilistic/
# Load Images
dwi_loaded = nib.load(image)
dwi_data = dwi_loaded.get_fdata()
wm_loaded = nib.load(wm)
wm_data = wm_loaded.get_fdata()
seeds_loaded = nib.load(seeds)
seeds_data = seeds_loaded.get_fdata()
seeds = utils.seeds_from_mask(seeds_data, dwi_loaded.affine, density=2)
# Load B-values & B-vectors
# NB. Use aligned b-vecs if providing eddy-aligned data
bvals, bvecs = read_bvals_bvecs(bvals, bvecs)
gtab = gradient_table(bvals, bvecs)
csa_model = CsaOdfModel(gtab, sh_order=6)
# Set stopping criterion
gfa = csa_model.fit(dwi_data, mask=wm_data).gfa
stop_criterion = ThresholdStoppingCriterion(gfa, .25)
if proba:
# Establish ODF model
response, ratio = auto_response(gtab,
dwi_data,
roi_radius=10,
fa_thr=0.7)
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
csd_fit = csd_model.fit(dwi_data, mask=wm_data)
# Create Probabilisitic direction getter
fod = csd_fit.odf(default_sphere)
pmf = fod.clip(min=0)
prob_dg = ProbabilisticDirectionGetter.from_pmf(pmf,
max_angle=30.,
sphere=default_sphere)
# Use the probabilisitic direction getter as the dg
dg = prob_dg
else:
# Establish ODF model
csa_peaks = peaks_from_model(csa_model,
dwi_data,
default_sphere,
relative_peak_threshold=0.8,
min_separation_angle=45,
mask=wm_data)
# Use the CSA peaks as the dg
dg = csa_peaks
# Create generator and perform tracing
s_generator = LocalTracking(dg,
stop_criterion,
seeds,
dwi_loaded.affine,
0.5,
random_seed=rseed)
streamlines = Streamlines(s_generator)
# Prune streamlines
streamlines = ArraySequence(
[strline for strline in streamlines if len(strline) > prune_length])
sft = StatefulTractogram(streamlines, dwi_loaded, Space.RASMM)
# Save streamlines
save_trk(sft, fibers + ".trk")
# Visualize fibers
if plot and has_fury:
from dipy.viz import window, actor, colormap as cmap
# Create the 3D display.
r = window.Renderer()
r.add(actor.line(streamlines, cmap.line_colors(streamlines)))
window.record(r, out_path=fibers + '.png', size=(800, 800))
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
def main():
parser = _build_arg_parser()
args = parser.parse_args()
logging.basicConfig(level=logging.INFO)
if not args.not_all:
args.fodf = args.fodf or 'fodf.nii.gz'
args.peaks = args.peaks or 'peaks.nii.gz'
args.peak_indices = args.peak_indices or 'peak_indices.nii.gz'
arglist = [args.fodf, args.peaks, args.peak_indices]
if args.not_all and not any(arglist):
parser.error('When using --not_all, you need to specify at least '
'one file to output.')
assert_inputs_exist(parser, [args.input, args.bvals, args.bvecs])
assert_outputs_exists(parser, args, arglist)
nbr_processes = args.nbr_processes
parallel = True
if nbr_processes <= 0:
nbr_processes = None
elif nbr_processes == 1:
parallel = False
# Check for FRF filename
base_odf_name, _ = split_name_with_nii(args.fodf)
frf_filename = base_odf_name + '_frf.txt'
if os.path.isfile(frf_filename) and not args.overwrite:
parser.error('Cannot save frf file, "{0}" already exists. '
'Use -f to overwrite.'.format(frf_filename))
vol = nib.load(args.input)
data = vol.get_data()
bvals, bvecs = read_bvals_bvecs(args.bvals, args.bvecs)
if args.mask_wm is not None:
wm_mask = nib.load(args.mask_wm).get_data().astype('bool')
else:
wm_mask = np.ones_like(data[..., 0], dtype=np.bool)
logging.info(
'No white matter mask specified! mask_data will be used instead, '
'if it has been supplied. \nBe *VERY* careful about the '
'estimation of the fiber response function for the CSD.')
data_in_wm = applymask(data, wm_mask)
if not is_normalized_bvecs(bvecs):
logging.warning('Your b-vectors do not seem normalized...')
bvecs = normalize_bvecs(bvecs)
if bvals.min() != 0:
if bvals.min() > 20:
raise ValueError(
'The minimal bvalue is greater than 20. This is highly '
'suspicious. Please check your data to ensure everything is '
'correct.\nValue found: {}'.format(bvals.min()))
else:
logging.warning(
'Warning: no b=0 image. Setting b0_threshold to '
'bvals.min() = %s', bvals.min())
gtab = gradient_table(bvals, bvecs, b0_threshold=bvals.min())
else:
gtab = gradient_table(bvals, bvecs)
if args.mask is None:
mask = None
else:
mask = nib.load(args.mask).get_data().astype(np.bool)
# Raise warning for sh order if there is not enough DWIs
if data.shape[-1] < (args.sh_order + 1) * (args.sh_order + 2) / 2:
warnings.warn(
'We recommend having at least %s unique DWIs volumes, but you '
'currently have %s volumes. Try lowering the parameter --sh_order '
'in case of non convergence.',
(args.sh_order + 1) * (args.sh_order + 2) / 2), data.shape[-1]
fa_thresh = args.fa_thresh
# If threshold is too high, try lower until enough indices are found
# estimating a response function with fa < 0.5 does not make sense
nvox = 0
while nvox < 300 and fa_thresh > 0.5:
response, ratio, nvox = auto_response(gtab,
data_in_wm,
roi_center=args.roi_center,
roi_radius=args.roi_radius,
fa_thr=fa_thresh,
return_number_of_voxels=True)
logging.info('Number of indices is %s with threshold of %s', nvox,
fa_thresh)
fa_thresh -= 0.05
if fa_thresh <= 0:
raise ValueError(
'Could not find at least 300 voxels for estimating the frf!')
logging.info('Found %s valid voxels for frf estimation.', nvox)
response = list(response)
logging.info('Response function is %s', response)
if args.frf is not None:
l01 = np.array(literal_eval(args.frf), dtype=np.float64)
if not args.no_factor:
l01 *= 10**-4
response[0] = np.array([l01[0], l01[1], l01[1]])
ratio = l01[1] / l01[0]
logging.info("Eigenvalues for the frf of the input data are: %s",
response[0])
logging.info("Ratio for smallest to largest eigen value is %s", ratio)
np.savetxt(frf_filename, response[0])
if not args.frf_only:
reg_sphere = get_sphere('symmetric362')
peaks_sphere = get_sphere('symmetric724')
csd_model = ConstrainedSphericalDeconvModel(gtab,
response,
reg_sphere=reg_sphere,
sh_order=args.sh_order)
peaks_csd = peaks_from_model(model=csd_model,
data=data,
sphere=peaks_sphere,
relative_peak_threshold=.5,
min_separation_angle=25,
mask=mask,
return_sh=True,
sh_basis_type=args.basis,
sh_order=args.sh_order,
normalize_peaks=True,
parallel=parallel,
nbr_processes=nbr_processes)
if args.fodf:
nib.save(
nib.Nifti1Image(peaks_csd.shm_coeff.astype(np.float32),
vol.affine), args.fodf)
if args.peaks:
nib.save(
nib.Nifti1Image(reshape_peaks_for_visualization(peaks_csd),
vol.affine), args.peaks)
if args.peak_indices:
nib.save(nib.Nifti1Image(peaks_csd.peak_indices, vol.affine),
args.peak_indices)
def main():
start = time.time()
with open('config.json') as config_json:
config = json.load(config_json)
# Load the data
dmri_image = nib.load(config['data_file'])
dmri = dmri_image.get_data()
affine = dmri_image.affine
#aparc_im = nib.load(config['freesurfer'])
aparc_im = nib.load('volume.nii.gz')
aparc = aparc_im.get_data()
end = time.time()
print('Loaded Files: ' + str((end - start)))
# Create the white matter and callosal masks
start = time.time()
wm_regions = [
2, 41, 16, 17, 28, 60, 51, 53, 12, 52, 12, 52, 13, 18, 54, 50, 11, 251,
252, 253, 254, 255, 10, 49, 46, 7
]
wm_mask = np.zeros(aparc.shape)
for l in wm_regions:
wm_mask[aparc == l] = 1
# Create the gradient table from the bvals and bvecs
bvals, bvecs = read_bvals_bvecs(config['data_bval'], config['data_bvec'])
gtab = gradient_table(bvals, bvecs, b0_threshold=100)
end = time.time()
print('Created Gradient Table: ' + str((end - start)))
##The probabilistic model##
# Use the Constant Solid Angle (CSA) to find the Orientation Dist. Function
# Helps orient the wm tracts
start = time.time()
csa_model = CsaOdfModel(gtab, sh_order=6)
csa_peaks = peaks_from_model(csa_model,
dmri,
default_sphere,
relative_peak_threshold=.8,
min_separation_angle=45,
mask=wm_mask)
print('Creating CSA Model: ' + str(time.time() - start))
# Begins the seed in the wm tracts
seeds = utils.seeds_from_mask(wm_mask, density=[1, 1, 1], affine=affine)
print('Created White Matter seeds: ' + str(time.time() - start))
# Create a CSD model to measure Fiber Orientation Dist
print('Begin the probabilistic model')
response, ratio = auto_response(gtab, dmri, roi_radius=10, fa_thr=0.7)
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
csd_fit = csd_model.fit(dmri, mask=wm_mask)
print('Created the CSD model: ' + str(time.time() - start))
# Set the Direction Getter to randomly choose directions
prob_dg = ProbabilisticDirectionGetter.from_shcoeff(csd_fit.shm_coeff,
max_angle=30.,
sphere=default_sphere)
print('Created the Direction Getter: ' + str(time.time() - start))
# Restrict the white matter tracking
classifier = ThresholdTissueClassifier(csa_peaks.gfa, .25)
print('Created the Tissue Classifier: ' + str(time.time() - start))
# Create the probabilistic model
streamlines = LocalTracking(prob_dg,
tissue_classifier=classifier,
seeds=seeds,
step_size=.5,
max_cross=1,
affine=affine)
print('Created the probabilistic model: ' + str(time.time() - start))
# Compute streamlines and store as a list.
streamlines = list(streamlines)
print('Computed streamlines: ' + str(time.time() - start))
#from dipy.tracking.streamline import transform_streamlines
#streamlines = transform_streamlines(streamlines, np.linalg.inv(affine))
# Create a tractogram from the streamlines and save it
tractogram = Tractogram(streamlines, affine_to_rasmm=affine)
#tractogram.apply_affine(np.linalg.inv(affine))
save(tractogram, 'track.tck')
end = time.time()
print("Created the tck file: " + str((end - start)))
def track(dwi_file, bval, bvec, mask_file, stop_val=0.1):
# """
# Tracking with basic tensors and basic eudx - experimental
# We now force seeding at every voxel in the provided mask for
# simplicity. Future functionality will extend these options.
# **Positional Arguments:**
# dwi_file:
# - File (registered) to use for tensor/fiber tracking
# mask_file:
# - Brain mask to keep tensors inside the brain
# gtab:
# - dipy formatted bval/bvec Structure
# **Optional Arguments:**
# stop_val:
# - Value to cutoff fiber track
# """
#img = nb.load(dwi_file)
#data = img.get_data()
dwi = dipy.data.load(dwi_file)
data = dwi.get_data()
#img = nb.load(mask_file)
#mask = img.get_data()
dwi_mask = dipy.data.load(mask_file)
mask = dwi_mask.get_data()
gtab = gradient_table(bval, bvec)
affine = dwi.affine
seed_mask = mask
seeds = utils.seeds_from_mask(seed_mask, density=1, affine=affine)
# use all points in mask
seedIdx = np.where(mask > 0) # seed everywhere not equal to zero
seedIdx = np.transpose(seedIdx)
sphere = get_sphere('symmetric724')
csd_model = ConstrainedSphericalDeconvModel(gtab, None, sh_order=6)
csd_fit = csd_model.fit(data, mask=mask)
tensor_model = dti.TensorModel(gtab)
tenfit = tensor_model.fit(data, mask=mask)
FA = fractional_anisotropy(tenfit.evals)
classifier = ThresholdTissueClassifier(FA, 0.1)
dg = DeterministicMaximumDirectionGetter.from_shcoeff(csd_fit.shm_coeff,
max_angle=80.,
sphere=sphere)
streamlines_generator = LocalTracking(dg,
classifier,
seeds,
affine,
step_size=0.5)
streamlines = Streamlines(streamlines_generator)
trk_file = save_trk("deterministic_threshold_DDG_samp_data.trk",
streamlines,
affine=affine,
shape=mask.shape)
def dmri_recon(sid, data_dir, out_dir, resolution, recon='csd', num_threads=2):
import tempfile
#tempfile.tempdir = '/om/scratch/Fri/ksitek/'
import os
oldval = None
if 'MKL_NUM_THREADS' in os.environ:
oldval = os.environ['MKL_NUM_THREADS']
os.environ['MKL_NUM_THREADS'] = '%d' % num_threads
ompoldval = None
if 'OMP_NUM_THREADS' in os.environ:
ompoldval = os.environ['OMP_NUM_THREADS']
os.environ['OMP_NUM_THREADS'] = '%d' % num_threads
import nibabel as nib
import numpy as np
from glob import glob
if resolution == '0.2mm':
filename = 'Reg_S64550_nii4d.nii'
fimg = os.path.abspath(glob(os.path.join(data_dir, filename))[0])
else:
filename = 'Reg_S64550_nii4d_resamp-%s.nii.gz'%(resolution)
fimg = os.path.abspath(glob(os.path.join(data_dir, 'resample', filename))[0])
print("dwi file = %s"%fimg)
fbvec = os.path.abspath(glob(os.path.join(data_dir, 'bvecs',
'camino_120_RAS_flipped-xy.bvecs'))[0])
print("bvec file = %s"%fbvec)
fbval = os.path.abspath(glob(os.path.join(data_dir, 'bvecs',
'camino_120_RAS.bvals'))[0])
print("bval file = %s"%fbval)
img = nib.load(fimg)
data = img.get_data()
affine = img.get_affine()
prefix = sid
from dipy.io import read_bvals_bvecs
from dipy.core.gradients import vector_norm
bvals, bvecs = read_bvals_bvecs(fbval, fbvec)
b0idx = []
for idx, val in enumerate(bvals):
if val < 1:
pass
#bvecs[idx] = [1, 0, 0]
else:
b0idx.append(idx)
#print "b0idx=%d"%idx
#print "input bvecs:"
#print bvecs
bvecs[b0idx, :] = bvecs[b0idx, :]/vector_norm(bvecs[b0idx])[:, None]
#print "bvecs after normalization:"
#print bvecs
from dipy.core.gradients import gradient_table
gtab = gradient_table(bvals, bvecs)
gtab.bvecs.shape == bvecs.shape
gtab.bvecs
gtab.bvals.shape == bvals.shape
gtab.bvals
from dipy.reconst.csdeconv import auto_response
response, ratio = auto_response(gtab, data, roi_radius=10, fa_thr=0.1) # 0.7
#from dipy.segment.mask import median_otsu
#b0_mask, mask = median_otsu(data[:, :, :, b0idx].mean(axis=3).squeeze(), 4, 4)
if resolution == '0.2mm':
mask_name = 'Reg_S64550_nii_b0-slice_mask.nii.gz'
fmask1 = os.path.join(data_dir, mask_name)
else:
mask_name = 'Reg_S64550_nii_b0-slice_mask_resamp-%s.nii.gz'%(resolution)
fmask1 = os.path.join(data_dir, 'resample', mask_name)
print("fmask file = %s"%fmask1)
mask = nib.load(fmask1).get_data()
useFA = True
print("creating model")
if recon == 'csd':
from dipy.reconst.csdeconv import ConstrainedSphericalDeconvModel
model = ConstrainedSphericalDeconvModel(gtab, response)
useFA = True
elif recon == 'csa':
from dipy.reconst.shm import CsaOdfModel, normalize_data
model = CsaOdfModel(gtab, 4)
useFA = False
else:
raise ValueError('only csd, csa supported currently')
from dipy.reconst.dsi import (DiffusionSpectrumDeconvModel,
DiffusionSpectrumModel)
model = DiffusionSpectrumDeconvModel(gtab)
fit = model.fit(data)
from dipy.data import get_sphere
sphere = get_sphere('symmetric724')
#odfs = fit.odf(sphere)
from dipy.reconst.peaks import peaks_from_model
print("running peaks_from_model")
peaks = peaks_from_model(model=model,
data=data,
sphere=sphere,
mask=mask,
return_sh=True,
return_odf=False,
normalize_peaks=True,
npeaks=5,
relative_peak_threshold=.5,
min_separation_angle=25,
parallel=num_threads > 1,
nbr_processes=num_threads)
from dipy.reconst.dti import TensorModel
print("running tensor model")
tenmodel = TensorModel(gtab)
tenfit = tenmodel.fit(data, mask)
from dipy.reconst.dti import fractional_anisotropy
print("running FA")
FA = fractional_anisotropy(tenfit.evals)
FA[np.isnan(FA)] = 0
fa_img = nib.Nifti1Image(FA, img.get_affine())
tensor_fa_file = os.path.abspath('%s_tensor_fa.nii.gz' % (prefix))
nib.save(fa_img, tensor_fa_file)
from dipy.reconst.dti import axial_diffusivity
print("running AD")
AD = axial_diffusivity(tenfit.evals)
AD[np.isnan(AD)] = 0
ad_img = nib.Nifti1Image(AD, img.get_affine())
tensor_ad_file = os.path.abspath('%s_tensor_ad.nii.gz' % (prefix))
nib.save(ad_img, tensor_ad_file)
from dipy.reconst.dti import radial_diffusivity
print("running RD")
RD = radial_diffusivity(tenfit.evals)
RD[np.isnan(RD)] = 0
rd_img = nib.Nifti1Image(RD, img.get_affine())
tensor_rd_file = os.path.abspath('%s_tensor_rd.nii.gz' % (prefix))
nib.save(rd_img, tensor_rd_file)
from dipy.reconst.dti import mean_diffusivity
print("running MD")
MD = mean_diffusivity(tenfit.evals)
MD[np.isnan(MD)] = 0
md_img = nib.Nifti1Image(MD, img.get_affine())
tensor_md_file = os.path.abspath('%s_tensor_md.nii.gz' % (prefix))
nib.save(md_img, tensor_md_file)
evecs = tenfit.evecs
evec_img = nib.Nifti1Image(evecs, img.get_affine())
tensor_evec_file = os.path.abspath('%s_tensor_evec.nii.gz' % (prefix))
nib.save(evec_img, tensor_evec_file)
shm_coeff = fit.shm_coeff
shm_coeff_file = os.path.abspath('%s_shm_coeff.nii.gz' % (prefix))
nib.save(nib.Nifti1Image(shm_coeff, img.get_affine()), shm_coeff_file)
#from dipy.reconst.dti import quantize_evecs
#peak_indices = quantize_evecs(tenfit.evecs, sphere.vertices)
#eu = EuDX(FA, peak_indices, odf_vertices = sphere.vertices,
#a_low=0.2, seeds=10**6, ang_thr=35)
fa_img = nib.Nifti1Image(peaks.gfa, img.get_affine())
model_gfa_file = os.path.abspath('%s_%s_gfa.nii.gz' % (prefix, recon))
nib.save(fa_img, model_gfa_file)
from dipy.tracking.eudx import EuDX
print("reconstructing with EuDX")
if useFA:
eu = EuDX(FA, peaks.peak_indices[..., 0],
odf_vertices = sphere.vertices,
#a_low=0.1,
seeds=10**6,
ang_thr=45)
else:
eu = EuDX(peaks.gfa, peaks.peak_indices[..., 0],
odf_vertices = sphere.vertices,
#a_low=0.1,
seeds=10**6,
ang_thr=45)
sl_fname = os.path.abspath('%s_%s_streamline.trk' % (prefix, recon))
"""
#import dipy.tracking.metrics as dmetrics
streamlines = ((sl, None, None) for sl in eu) # if dmetrics.length(sl) > 15)
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = fa_img.get_header().get_zooms()[:3]
hdr['voxel_order'] = 'RAS' #LAS
hdr['dim'] = FA.shape[:3]
nib.trackvis.write(sl_fname, streamlines, hdr, points_space='voxel')
"""
# trying new dipy.io.streamline module, per email to neuroimaging list
# 2018.04.05
from nibabel.streamlines import Field
from nibabel.orientations import aff2axcodes
affine = img.get_affine()
vox_size=fa_img.get_header().get_zooms()[:3]
fov_shape=FA.shape[:3]
if vox_size is not None and fov_shape is not None:
hdr = {}
hdr[Field.VOXEL_TO_RASMM] = affine.copy()
hdr[Field.VOXEL_SIZES] = vox_size
hdr[Field.DIMENSIONS] = fov_shape
hdr[Field.VOXEL_ORDER] = "".join(aff2axcodes(affine))
tractogram = nib.streamlines.Tractogram(eu)
tractogram.affine_to_rasmm = affine
trk_file = nib.streamlines.TrkFile(tractogram, header=hdr)
nib.streamlines.save(trk_file, sl_fname)
if oldval:
os.environ['MKL_NUM_THREADS'] = oldval
else:
del os.environ['MKL_NUM_THREADS']
if ompoldval:
os.environ['OMP_NUM_THREADS'] = ompoldval
else:
del os.environ['OMP_NUM_THREADS']
assert tensor_fa_file
assert tensor_evec_file
assert model_gfa_file
assert tensor_ad_file
assert tensor_rd_file
assert tensor_md_file
assert shm_coeff_file
print('all output files created')
return tensor_fa_file, tensor_evec_file, model_gfa_file, sl_fname, affine, tensor_ad_file, tensor_rd_file, tensor_md_file, shm_coeff_file
def test_recursive_response_calibration():
"""
Test the recursive response calibration method.
"""
SNR = 100
S0 = 1
_, fbvals, fbvecs = get_fnames('small_64D')
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
sphere = default_sphere
gtab = gradient_table(bvals, bvecs)
evals = np.array([0.0015, 0.0003, 0.0003])
evecs = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]]).T
mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (90, 0)]
where_dwi = lazy_index(~gtab.b0s_mask)
S_cross, _ = multi_tensor(gtab,
mevals,
S0,
angles=angles,
fractions=[50, 50],
snr=SNR)
S_single = single_tensor(gtab, S0, evals, evecs, snr=SNR)
data = np.concatenate((np.tile(S_cross, (8, 1)), np.tile(S_single,
(2, 1))),
axis=0)
odf_gt_cross = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
odf_gt_single = single_tensor_odf(sphere.vertices, evals, evecs)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
response = recursive_response(gtab,
data,
mask=None,
sh_order=8,
peak_thr=0.01,
init_fa=0.05,
init_trace=0.0021,
iter=8,
convergence=0.001,
parallel=False)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
csd = ConstrainedSphericalDeconvModel(gtab, response)
csd_fit = csd.fit(data)
assert_equal(np.all(csd_fit.shm_coeff[:, 0] >= 0), True)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
fodf = csd_fit.odf(sphere)
directions_gt_single, _, _ = peak_directions(odf_gt_single, sphere)
directions_gt_cross, _, _ = peak_directions(odf_gt_cross, sphere)
directions_single, _, _ = peak_directions(fodf[8, :], sphere)
directions_cross, _, _ = peak_directions(fodf[0, :], sphere)
ang_sim = angular_similarity(directions_cross, directions_gt_cross)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions_cross.shape[0], 2)
assert_equal(directions_gt_cross.shape[0], 2)
ang_sim = angular_similarity(directions_single, directions_gt_single)
assert_equal(ang_sim > 0.9, True)
assert_equal(directions_single.shape[0], 1)
assert_equal(directions_gt_single.shape[0], 1)
with warnings.catch_warnings(record=True) as w:
sphere = Sphere(xyz=gtab.gradients[where_dwi])
npt.assert_equal(len(w), 1)
npt.assert_(issubclass(w[0].category, UserWarning))
npt.assert_("Vertices are not on the unit sphere" in str(w[0].message))
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
sf = response.on_sphere(sphere)
S = np.concatenate(([response.S0], sf))
tenmodel = TensorModel(gtab, min_signal=0.001)
tenfit = tenmodel.fit(S)
FA = fractional_anisotropy(tenfit.evals)
FA_gt = fractional_anisotropy(evals)
assert_almost_equal(FA, FA_gt, 1)
def test_boot_pmf():
# This tests the local model used for the bootstrapping.
hsph_updated = HemiSphere.from_sphere(unit_octahedron)
vertices = hsph_updated.vertices
bvecs = vertices
bvals = np.ones(len(vertices)) * 1000
bvecs = np.insert(bvecs, 0, np.array([0, 0, 0]), axis=0)
bvals = np.insert(bvals, 0, 0)
gtab = gradient_table(bvals, bvecs)
voxel = single_tensor(gtab)
data = np.tile(voxel, (3, 3, 3, 1))
point = np.array([1., 1., 1.])
tensor_model = TensorModel(gtab)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
boot_pmf_gen = BootPmfGen(data,
model=tensor_model,
sphere=hsph_updated)
no_boot_pmf = boot_pmf_gen.get_pmf_no_boot(point)
model_pmf = tensor_model.fit(voxel).odf(hsph_updated)
npt.assert_equal(len(hsph_updated.vertices), no_boot_pmf.shape[0])
npt.assert_array_almost_equal(no_boot_pmf, model_pmf)
# test model spherical harmonic order different than bootstrap order
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always", category=UserWarning)
warnings.simplefilter("always", category=PendingDeprecationWarning)
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
# Tests that the first catched warning comes from
# the CSD model constructor
npt.assert_(issubclass(w[0].category, UserWarning))
npt.assert_("Number of parameters required " in str(w[0].message))
# Tests that additional warnings are raised for outdated SH basis
npt.assert_(len(w) > 1)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
boot_pmf_gen_sh4 = BootPmfGen(data,
sphere=hsph_updated,
model=csd_model,
sh_order=4)
pmf_sh4 = boot_pmf_gen_sh4.get_pmf(point)
npt.assert_equal(len(hsph_updated.vertices), pmf_sh4.shape[0])
npt.assert_(np.sum(pmf_sh4.shape) > 0)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
boot_pmf_gen_sh8 = BootPmfGen(data,
model=csd_model,
sphere=hsph_updated,
sh_order=8)
pmf_sh8 = boot_pmf_gen_sh8.get_pmf(point)
npt.assert_equal(len(hsph_updated.vertices), pmf_sh8.shape[0])
npt.assert_(np.sum(pmf_sh8.shape) > 0)
def tracking(folder):
print('Tracking in ' + folder)
output_folder = folder + 'dipy_out/'
# make a folder to save new data into
try:
Path(output_folder).mkdir(parents=True, exist_ok=True)
except OSError:
print('Could not create output dir. Aborting...')
return
# load data
print('Loading data...')
img = nib.load(folder + 'data.nii.gz')
dmri = np.asarray(img.dataobj)
affine = img.affine
mask, _ = load_nifti(folder + 'nodif_brain_mask.nii.gz')
bvals, bvecs = read_bvals_bvecs(folder + 'bvals', folder + 'bvecs')
gtab = gradient_table(bvals, bvecs)
# extract peaksoutput_folder + 'peak_vals.nii.gz'
if Path(output_folder + 'peaks.pam5').exists():
peaks = load_peaks(output_folder + 'peaks.pam5')
else:
print('Extracting peaks...')
response, ration = auto_response(gtab, dmri, roi_radius=10, fa_thr=.7)
csd_model = ConstrainedSphericalDeconvModel(gtab, response)
peaks = peaks_from_model(model=csd_model,
data=dmri,
sphere=default_sphere,
relative_peak_threshold=.5,
min_separation_angle=25,
parallel=True)
save_peaks(output_folder + 'peaks.pam5', peaks, affine)
scaled = peaks.peak_dirs * np.repeat(
np.expand_dims(peaks.peak_values, -1), 3, -1)
cropped = scaled[:, :, :, :3, :].reshape(dmri.shape[:3] + (9, ))
save_nifti(output_folder + 'peaks.nii.gz', cropped, affine)
#save_nifti(output_folder + 'peak_dirs.nii.gz', peaks.peak_dirs, affine)
#save_nifti(output_folder + 'peak_vals.nii.gz', peaks.peak_values, affine)
# tracking
print('Tracking...')
maskdata, mask = median_otsu(dmri,
vol_idx=range(0, dmri.shape[3]),
median_radius=3,
numpass=1,
autocrop=True,
dilate=2)
tensor_model = TensorModel(gtab, fit_method='WLS')
tensor_fit = tensor_model.fit(maskdata)
fa = fractional_anisotropy(tensor_fit.evals)
fa[np.isnan(fa)] = 0
bla = np.average(fa)
tissue_classifier = ThresholdStoppingCriterion(fa, .1)
seeds = random_seeds_from_mask(fa > 1e-5, affine, seeds_count=1)
streamline_generator = LocalTracking(direction_getter=peaks,
stopping_criterion=tissue_classifier,
seeds=seeds,
affine=affine,
step_size=.5)
streamlines = Streamlines(streamline_generator)
save_trk(StatefulTractogram(streamlines, img, Space.RASMM),
output_folder + 'whole_brain.trk')
def compute_tensors(self, dti_vol, atlas_file, gtab):
# WGR:TODO figure out how to organize tensor options and formats
# WGR:TODO figure out how to deal with files on disk vs. in workspace
"""
Takes registered DTI image and produces tensors
**Positional Arguments:**
dti_vol:
- Registered DTI volume, from workspace.
atlas_file:
- File containing an atlas (or brain mask).
gtab:
- Structure containing dipy formatted bval/bvec information
"""
labeldata = nib.load(atlas_file)
label = labeldata.get_data()
"""
Create a brain mask. Here we just threshold labels.
"""
mask = (label > 0)
gtab.info
print data.shape
"""
For the constrained spherical deconvolution we need to estimate the
response function (see :ref:`example_reconst_csd`) and create a model.
"""
response, ratio = auto_response(gtab,
dti_vol,
roi_radius=10,
fa_thr=0.7)
csd_model = ConstrainedSphericalDeconvModel(gtab, response)
"""
Next, we use ``peaks_from_model`` to fit the data and calculated
the fiber directions in all voxels.
"""
sphere = get_sphere('symmetric724')
csd_peaks = peaks_from_model(model=csd_model,
data=data,
sphere=sphere,
mask=mask,
relative_peak_threshold=.5,
min_separation_angle=25,
parallel=True)
"""
For the tracking part, we will use ``csd_model`` fiber directions
but stop tracking where fractional anisotropy (FA) is low (< 0.1).
To derive the FA, used as a stopping criterion, we need to fit a
tensor model first. Here, we use weighted least squares (WLS).
"""
print 'tensors...'
tensor_model = TensorModel(gtab, fit_method='WLS')
tensor_fit = tensor_model.fit(data, mask)
FA = fractional_anisotropy(tensor_fit.evals)
"""
In order for the stopping values to be used with our tracking
algorithm we need to have the same dimensions as the
``csd_peaks.peak_values``. For this reason, we can assign the
same FA value to every peak direction in the same voxel in
the following way.
"""
stopping_values = np.zeros(csd_peaks.peak_values.shape)
stopping_values[:] = FA[..., None]
print datetime.now() - startTime
pass
def main():
parser = _build_arg_parser()
args = parser.parse_args()
logging.basicConfig(level=logging.INFO)
if not args.not_all:
args.fodf = args.fodf or 'fodf.nii.gz'
args.peaks = args.peaks or 'peaks.nii.gz'
args.peak_indices = args.peak_indices or 'peak_indices.nii.gz'
arglist = [args.fodf, args.peaks, args.peak_indices]
if args.not_all and not any(arglist):
parser.error('When using --not_all, you need to specify at least '
'one file to output.')
assert_inputs_exist(parser,
[args.input, args.bvals, args.bvecs, args.frf_file])
assert_outputs_exist(parser, args, arglist)
nbr_processes = args.nbr_processes
parallel = True
if nbr_processes is not None:
if nbr_processes <= 0:
nbr_processes = None
elif nbr_processes == 1:
parallel = False
full_frf = np.loadtxt(args.frf_file)
if not full_frf.shape[0] == 4:
raise ValueError('FRF file did not contain 4 elements. '
'Invalid or deprecated FRF format')
frf = full_frf[0:3]
mean_b0_val = full_frf[3]
vol = nib.load(args.input)
data = vol.get_data()
bvals, bvecs = read_bvals_bvecs(args.bvals, args.bvecs)
if not is_normalized_bvecs(bvecs):
logging.warning('Your b-vectors do not seem normalized...')
bvecs = normalize_bvecs(bvecs)
check_b0_threshold(args.force_b0_threshold, bvals.min())
gtab = gradient_table(bvals, bvecs, b0_threshold=bvals.min())
if args.mask is None:
mask = None
else:
mask = nib.load(args.mask).get_data().astype(np.bool)
# Raise warning for sh order if there is not enough DWIs
if data.shape[-1] < (args.sh_order + 1) * (args.sh_order + 2) / 2:
warnings.warn(
'We recommend having at least {} unique DWIs volumes, but you '
'currently have {} volumes. Try lowering the parameter --sh_order '
'in case of non convergence.'.format(
(args.sh_order + 1) * (args.sh_order + 2) / 2, data.shape[-1]))
reg_sphere = get_sphere('symmetric362')
peaks_sphere = get_sphere('symmetric724')
csd_model = ConstrainedSphericalDeconvModel(gtab, (frf, mean_b0_val),
reg_sphere=reg_sphere,
sh_order=args.sh_order)
peaks_csd = peaks_from_model(model=csd_model,
data=data,
sphere=peaks_sphere,
relative_peak_threshold=.5,
min_separation_angle=25,
mask=mask,
return_sh=True,
sh_basis_type=args.sh_basis,
sh_order=args.sh_order,
normalize_peaks=True,
parallel=parallel,
nbr_processes=nbr_processes)
if args.fodf:
nib.save(
nib.Nifti1Image(peaks_csd.shm_coeff.astype(np.float32),
vol.affine), args.fodf)
if args.peaks:
nib.save(
nib.Nifti1Image(reshape_peaks_for_visualization(peaks_csd),
vol.affine), args.peaks)
if args.peak_indices:
nib.save(nib.Nifti1Image(peaks_csd.peak_indices, vol.affine),
args.peak_indices)
def eudx_advanced(self,
dti_file,
mask_file,
gtab,
seed_num=100000,
stop_val=0.1):
"""
Tracking with more complex tensors - experimental
Initializes the graph with nodes corresponding to the number of ROIs
**Positional Arguments:**
dti_file:
- File (registered) to use for tensor/fiber tracking
mask_file:
- Brain mask to keep tensors inside the brain
gtab:
- dipy formatted bval/bvec Structure
**Optional Arguments:**
seed_num:
- Number of seeds to use for fiber tracking
stop_val:
- Value to cutoff fiber track
"""
img = nb.load(dti_file)
data = img.get_data()
img = nb.load(mask_file)
mask = img.get_data()
mask = mask > 0 # to ensure binary mask
"""
For the constrained spherical deconvolution we need to estimate the
response function (see :ref:`example_reconst_csd`) and create a model.
"""
response, ratio = auto_response(gtab, data, roi_radius=10, fa_thr=0.7)
csd_model = ConstrainedSphericalDeconvModel(gtab, response)
"""
Next, we use ``peaks_from_model`` to fit the data and calculated
the fiber directions in all voxels.
"""
sphere = get_sphere('symmetric724')
csd_peaks = peaks_from_model(model=csd_model,
data=data,
sphere=sphere,
mask=mask,
relative_peak_threshold=.5,
min_separation_angle=25,
parallel=True)
"""
For the tracking part, we will use ``csd_model`` fiber directions
but stop tracking where fractional anisotropy (FA) is low (< 0.1).
To derive the FA, used as a stopping criterion, we need to fit a
tensor model first. Here, we use weighted least squares (WLS).
"""
print 'tensors...'
tensor_model = TensorModel(gtab, fit_method='WLS')
tensor_fit = tensor_model.fit(data, mask)
FA = fractional_anisotropy(tensor_fit.evals)
"""
In order for the stopping values to be used with our tracking
algorithm we need to have the same dimensions as the
``csd_peaks.peak_values``. For this reason, we can assign the
same FA value to every peak direction in the same voxel in
the following way.
"""
stopping_values = np.zeros(csd_peaks.peak_values.shape)
stopping_values[:] = FA[..., None]
streamline_generator = EuDX(stopping_values,
csd_peaks.peak_indices,
seeds=seed_num,
odf_vertices=sphere.vertices,
a_low=stop_val)
streamlines = [streamline for streamline in streamline_generator]
return streamlines
def test_csdeconv():
SNR = 100
S0 = 1
_, fbvals, fbvecs = get_fnames('small_64D')
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
gtab = gradient_table(bvals, bvecs, b0_threshold=0)
mevals = np.array(([0.0015, 0.0003, 0.0003],
[0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (60, 0)]
S, sticks = multi_tensor(gtab, mevals, S0, angles=angles,
fractions=[50, 50], snr=SNR)
sphere = get_sphere('symmetric362')
odf_gt = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
response = (np.array([0.0015, 0.0003, 0.0003]), S0)
csd = ConstrainedSphericalDeconvModel(gtab, response)
csd_fit = csd.fit(S)
assert_equal(csd_fit.shm_coeff[0] > 0, True)
fodf = csd_fit.odf(sphere)
directions, _, _ = peak_directions(odf_gt, sphere)
directions2, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions, directions2)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
assert_equal(directions2.shape[0], 2)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always", category=UserWarning)
_ = ConstrainedSphericalDeconvModel(gtab, response, sh_order=10)
assert_greater(len([lw for lw in w if issubclass(lw.category,
UserWarning)]), 0)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always", category=UserWarning)
ConstrainedSphericalDeconvModel(gtab, response, sh_order=8)
assert_equal(len([lw for lw in w if issubclass(lw.category,
UserWarning)]), 0)
mevecs = []
for s in sticks:
mevecs += [all_tensor_evecs(s).T]
S2 = single_tensor(gtab, 100, mevals[0], mevecs[0], snr=None)
big_S = np.zeros((10, 10, 10, len(S2)))
big_S[:] = S2
aresponse, aratio = auto_response_ssst(gtab, big_S, roi_center=(5, 5, 4),
roi_radii=3, fa_thr=0.5)
assert_array_almost_equal(aresponse[0], response[0])
assert_almost_equal(aresponse[1], 100)
assert_almost_equal(aratio, response[0][1] / response[0][0])
auto_response_ssst(gtab, big_S, roi_radii=3, fa_thr=0.5)
assert_array_almost_equal(aresponse[0], response[0])
for j in range(pmf.shape[1]):
for k in range(pmf.shape[2]):
if fodf_pred_sum[i, j, k] > 0:
pmf[i, j, k, :] /= fodf_pred_sum[i, j, k]
pmf_dl = pmf.copy()
print('Finished estimating FODF with DL, time elapsed (minutes): ' +
str(int((time.time() - t1) / 60)))
if run_dipy_tractography:
print('Estimating FODF with CSD')
t1 = time.time()
csd_model = ConstrainedSphericalDeconvModel(gtab_0_1000,
response_0_1000,
sh_order=6)
csd_fit = csd_model.fit(d_img_0_1000, mask=mask)
fodf_dipy = csd_fit.odf(sphere_fod)
if save_fodf:
h5f = h5py.File(dav_dir + 'fodf_dipy.h5', 'w')
h5f['fodf_dipy'] = fodf_dipy
h5f.close()
'''
h5f = h5py.File( dav_dir + 'fodf_dipy.h5', 'r')
fodf_dipy = h5f['fodf_dipy'][:]
h5f.close()
'''
def main():
parser = _build_arg_parser()
args = parser.parse_args()
logging.basicConfig(level=logging.INFO)
assert_inputs_exist(parser, [args.in_dwi, args.in_bval, args.in_bvec,
args.frf_file])
assert_outputs_exist(parser, args, args.out_fODF)
# Loading data
full_frf = np.loadtxt(args.frf_file)
vol = nib.load(args.in_dwi)
data = vol.get_fdata(dtype=np.float32)
bvals, bvecs = read_bvals_bvecs(args.in_bval, args.in_bvec)
# Checking mask
if args.mask is None:
mask = None
else:
mask = get_data_as_mask(nib.load(args.mask), dtype=bool)
if mask.shape != data.shape[:-1]:
raise ValueError("Mask is not the same shape as data.")
sh_order = args.sh_order
# Checking data and sh_order
b0_thr = check_b0_threshold(
args.force_b0_threshold, bvals.min(), bvals.min())
if data.shape[-1] < (sh_order + 1) * (sh_order + 2) / 2:
logging.warning(
'We recommend having at least {} unique DWI volumes, but you '
'currently have {} volumes. Try lowering the parameter sh_order '
'in case of non convergence.'.format(
(sh_order + 1) * (sh_order + 2) / 2, data.shape[-1]))
# Checking bvals, bvecs values and loading gtab
if not is_normalized_bvecs(bvecs):
logging.warning('Your b-vectors do not seem normalized...')
bvecs = normalize_bvecs(bvecs)
gtab = gradient_table(bvals, bvecs, b0_threshold=b0_thr)
# Checking full_frf and separating it
if not full_frf.shape[0] == 4:
raise ValueError('FRF file did not contain 4 elements. '
'Invalid or deprecated FRF format')
frf = full_frf[0:3]
mean_b0_val = full_frf[3]
# Loading the sphere
reg_sphere = get_sphere('symmetric362')
# Computing CSD
csd_model = ConstrainedSphericalDeconvModel(
gtab, (frf, mean_b0_val),
reg_sphere=reg_sphere,
sh_order=sh_order)
# Computing CSD fit
csd_fit = fit_from_model(csd_model, data,
mask=mask, nbr_processes=args.nbr_processes)
# Saving results
shm_coeff = csd_fit.shm_coeff
if args.sh_basis == 'tournier07':
shm_coeff = convert_sh_basis(shm_coeff, reg_sphere, mask=mask,
nbr_processes=args.nbr_processes)
nib.save(nib.Nifti1Image(shm_coeff.astype(np.float32),
vol.affine), args.out_fODF)
def compute_fodf(data,
bvals,
bvecs,
full_frf,
sh_order=8,
nbr_processes=None,
mask=None,
sh_basis='descoteaux07',
return_sh=True,
n_peaks=5,
force_b0_threshold=False):
"""
Script to compute Constrained Spherical Deconvolution (CSD) fiber ODFs.
By default, will output all possible files, using default names. Specific
names can be specified using the file flags specified in the "File flags"
section.
If --not_all is set, only the files specified explicitly by the flags
will be output.
See [Tournier et al. NeuroImage 2007] and [Cote et al Tractometer MedIA 2013]
for quantitative comparisons with Sharpening Deconvolution Transform (SDT).
Parameters
----------
data: ndarray
4D Input diffusion volume with shape (X, Y, Z, N)
bvals: ndarray
1D bvals array with shape (N,)
bvecs: ndarray
2D (normalized) bvecs array with shape (N, 3)
full_frf: ndarray
frf data, ex, loaded from a frf_file, with shape (4,).
sh_order: int, optional
SH order used for the CSD. (Default: 8)
nbr_processes: int, optional
Number of sub processes to start. Default = none, i.e use the cpu count.
If 0, use all processes.
mask: ndarray, optional
3D mask with shape (X,Y,Z)
Binary mask. Only the data inside the mask will be used for
computations and reconstruction. Useful if no white matter mask is
available.
sh_basis: str, optional
Spherical harmonics basis used for the SH coefficients.Must be either
'descoteaux07' or 'tournier07' (default 'descoteaux07')
- 'descoteaux07': SH basis from the Descoteaux et al. MRM 2007 paper
- 'tournier07': SH basis from the Tournier et al. NeuroImage 2007 paper.
return_sh: bool, optional
If true, returns the sh.
n_peaks: int, optional
Nb of peaks for the fodf. Default: copied dipy's default, i.e. 5.
force_b0_threshold: bool, optional
If True, will continue even if the minimum bvalue is suspiciously high.
Returns
-------
peaks_csd: PeaksAndMetrics
An object with ``gfa``, ``peak_directions``, ``peak_values``,
``peak_indices``, ``odf``, ``shm_coeffs`` as attributes
"""
# Checking data and sh_order
check_b0_threshold(force_b0_threshold, bvals.min())
if data.shape[-1] < (sh_order + 1) * (sh_order + 2) / 2:
logging.warning(
'We recommend having at least {} unique DWI volumes, but you '
'currently have {} volumes. Try lowering the parameter sh_order '
'in case of non convergence.'.format(
(sh_order + 1) * (sh_order + 2) / 2, data.shape[-1]))
# Checking bvals, bvecs values and loading gtab
if not is_normalized_bvecs(bvecs):
logging.warning('Your b-vectors do not seem normalized...')
bvecs = normalize_bvecs(bvecs)
gtab = gradient_table(bvals, bvecs, b0_threshold=bvals.min())
# Checking full_frf and separating it
if not full_frf.shape[0] == 4:
raise ValueError('FRF file did not contain 4 elements. '
'Invalid or deprecated FRF format')
frf = full_frf[0:3]
mean_b0_val = full_frf[3]
# Checking if we will use parallel processing
parallel = True
if nbr_processes is not None:
if nbr_processes == 0: # Will use all processed
nbr_processes = None
elif nbr_processes == 1:
parallel = False
elif nbr_processes < 0:
raise ValueError('nbr_processes should be positive.')
# Checking sh basis
validate_sh_basis_choice(sh_basis)
# Loading the spheres
reg_sphere = get_sphere('symmetric362')
peaks_sphere = get_sphere('symmetric724')
# Computing CSD
csd_model = ConstrainedSphericalDeconvModel(gtab, (frf, mean_b0_val),
reg_sphere=reg_sphere,
sh_order=sh_order)
# Computing peaks. Run in parallel, using the default number of processes
# (default: CPU count)
peaks_csd = peaks_from_model(model=csd_model,
data=data,
sphere=peaks_sphere,
relative_peak_threshold=.5,
min_separation_angle=25,
mask=mask,
return_sh=return_sh,
sh_basis_type=sh_basis,
sh_order=sh_order,
normalize_peaks=True,
npeaks=n_peaks,
parallel=parallel,
nbr_processes=nbr_processes)
return peaks_csd
def run(self,
input_files,
bvalues_files,
bvectors_files,
mask_files,
b0_threshold=0.0,
bvecs_tol=0.01,
roi_center=None,
roi_radius=10,
fa_thr=0.7,
frf=None,
extract_pam_values=False,
sh_order=8,
odf_to_sh_order=8,
out_dir='',
out_pam='peaks.pam5',
out_shm='shm.nii.gz',
out_peaks_dir='peaks_dirs.nii.gz',
out_peaks_values='peaks_values.nii.gz',
out_peaks_indices='peaks_indices.nii.gz',
out_gfa='gfa.nii.gz'):
""" Constrained spherical deconvolution
Parameters
----------
input_files : string
Path to the input volumes. This path may contain wildcards to
process multiple inputs at once.
bvalues_files : string
Path to the bvalues files. This path may contain wildcards to use
multiple bvalues files at once.
bvectors_files : string
Path to the bvectors files. This path may contain wildcards to use
multiple bvectors files at once.
mask_files : string
Path to the input masks. This path may contain wildcards to use
multiple masks at once. (default: No mask used)
b0_threshold : float, optional
Threshold used to find b=0 directions
bvecs_tol : float, optional
Bvecs should be unit vectors. (default:0.01)
roi_center : variable int, optional
Center of ROI in data. If center is None, it is assumed that it is
the center of the volume with shape `data.shape[:3]` (default None)
roi_radius : int, optional
radius of cubic ROI in voxels (default 10)
fa_thr : float, optional
FA threshold for calculating the response function (default 0.7)
frf : variable float, optional
Fiber response function can be for example inputed as 15 4 4
(from the command line) or [15, 4, 4] from a Python script to be
converted to float and mutiplied by 10**-4 . If None
the fiber response function will be computed automatically
(default: None).
extract_pam_values : bool, optional
Save or not to save pam volumes as single nifti files.
sh_order : int, optional
Spherical harmonics order (default 6) used in the CSA fit.
odf_to_sh_order : int, optional
Spherical harmonics order used for peak_from_model to compress
the ODF to spherical harmonics coefficients (default 8)
out_dir : string, optional
Output directory (default input file directory)
out_pam : string, optional
Name of the peaks volume to be saved (default 'peaks.pam5')
out_shm : string, optional
Name of the shperical harmonics volume to be saved
(default 'shm.nii.gz')
out_peaks_dir : string, optional
Name of the peaks directions volume to be saved
(default 'peaks_dirs.nii.gz')
out_peaks_values : string, optional
Name of the peaks values volume to be saved
(default 'peaks_values.nii.gz')
out_peaks_indices : string, optional
Name of the peaks indices volume to be saved
(default 'peaks_indices.nii.gz')
out_gfa : string, optional
Name of the generalise fa volume to be saved (default 'gfa.nii.gz')
References
----------
.. [1] Tournier, J.D., et al. NeuroImage 2007. Robust determination of
the fibre orientation distribution in diffusion MRI: Non-negativity
constrained super-resolved spherical deconvolution.
"""
io_it = self.get_io_iterator()
for (dwi, bval, bvec, maskfile, opam, oshm, opeaks_dir, opeaks_values,
opeaks_indices, ogfa) in io_it:
logging.info('Loading {0}'.format(dwi))
img = nib.load(dwi)
data = img.get_data()
affine = img.affine
bvals, bvecs = read_bvals_bvecs(bval, bvec)
print(b0_threshold, bvals.min())
if b0_threshold < bvals.min():
warn("b0_threshold (value: {0}) is too low, increase your "
"b0_threshold. It should higher than the first b0 value "
"({1}).".format(b0_threshold, bvals.min()))
gtab = gradient_table(bvals,
bvecs,
b0_threshold=b0_threshold,
atol=bvecs_tol)
mask_vol = nib.load(maskfile).get_data().astype(np.bool)
n_params = ((sh_order + 1) * (sh_order + 2)) / 2
if data.shape[-1] < n_params:
raise ValueError('You need at least {0} unique DWI volumes to '
'compute fiber odfs. You currently have: {1}'
' DWI volumes.'.format(
n_params, data.shape[-1]))
if frf is None:
logging.info('Computing response function')
if roi_center is not None:
logging.info(
'Response ROI center:\n{0}'.format(roi_center))
logging.info(
'Response ROI radius:\n{0}'.format(roi_radius))
response, ratio, nvox = auto_response(
gtab,
data,
roi_center=roi_center,
roi_radius=roi_radius,
fa_thr=fa_thr,
return_number_of_voxels=True)
response = list(response)
else:
logging.info('Using response function')
if isinstance(frf, str):
l01 = np.array(literal_eval(frf), dtype=np.float64)
else:
l01 = np.array(frf, dtype=np.float64)
l01 *= 10**-4
response = np.array([l01[0], l01[1], l01[1]])
ratio = l01[1] / l01[0]
response = (response, ratio)
logging.info(
'Eigenvalues for the frf of the input data are :{0}'.format(
response[0]))
logging.info(
'Ratio for smallest to largest eigen value is {0}'.format(
ratio))
peaks_sphere = get_sphere('repulsion724')
logging.info('CSD computation started.')
csd_model = ConstrainedSphericalDeconvModel(gtab,
response,
sh_order=sh_order)
peaks_csd = peaks_from_model(model=csd_model,
data=data,
sphere=peaks_sphere,
relative_peak_threshold=.5,
min_separation_angle=25,
mask=mask_vol,
return_sh=True,
sh_order=sh_order,
normalize_peaks=True,
parallel=False)
peaks_csd.affine = affine
save_peaks(opam, peaks_csd)
logging.info('CSD computation completed.')
if extract_pam_values:
peaks_to_niftis(peaks_csd,
oshm,
opeaks_dir,
opeaks_values,
opeaks_indices,
ogfa,
reshape_dirs=True)
dname_ = os.path.dirname(opam)
if dname_ == '':
logging.info('Pam5 file saved in current directory')
else:
logging.info('Pam5 file saved in {0}'.format(dname_))
return io_it
def csd_mod_est(gtab, data, B0_mask, sh_order=8):
"""
Estimate a Constrained Spherical Deconvolution (CSD) model from dwi data.
Parameters
----------
gtab : Obj
DiPy object storing diffusion gradient information.
data : array
4D numpy array of diffusion image data.
B0_mask : str
File path to B0 brain mask.
sh_order : int
The order of the SH model. Default is 8.
Returns
-------
csd_mod : ndarray
Coefficients of the csd reconstruction.
model : obj
Fitted csd model.
References
----------
.. [1] Tournier, J.D., et al. NeuroImage 2007. Robust determination of
the fibre orientation distribution in diffusion MRI:
Non-negativity constrained super-resolved spherical
deconvolution
.. [2] Descoteaux, M., et al. IEEE TMI 2009. Deterministic and
Probabilistic Tractography Based on Complex Fibre Orientation
Distributions
.. [3] Côté, M-A., et al. Medical Image Analysis 2013. Tractometer:
Towards validation of tractography pipelines
.. [4] Tournier, J.D, et al. Imaging Systems and Technology
2012. MRtrix: Diffusion Tractography in Crossing Fiber Regions
"""
from dipy.reconst.csdeconv import (
ConstrainedSphericalDeconvModel,
recursive_response,
)
print("Fitting CSD model...")
B0_mask_data = np.nan_to_num(np.asarray(
nib.load(B0_mask).dataobj)).astype("bool")
print("Reconstructing...")
response = recursive_response(
gtab,
data,
mask=B0_mask_data,
sh_order=sh_order,
peak_thr=0.01,
init_fa=0.08,
init_trace=0.0021,
iter=8,
convergence=0.001,
parallel=False
)
print(f"CSD Reponse: {response}")
model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=sh_order)
csd_mod = model.fit(data, B0_mask_data).shm_coeff
del response, B0_mask_data
return csd_mod, model
def test_csdeconv():
SNR = 100
S0 = 1
_, fbvals, fbvecs = get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
gtab = gradient_table(bvals, bvecs)
mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (60, 0)]
S, sticks = multi_tensor(gtab,
mevals,
S0,
angles=angles,
fractions=[50, 50],
snr=SNR)
sphere = get_sphere('symmetric362')
odf_gt = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
response = (np.array([0.0015, 0.0003, 0.0003]), S0)
csd = ConstrainedSphericalDeconvModel(gtab, response)
csd_fit = csd.fit(S)
assert_equal(csd_fit.shm_coeff[0] > 0, True)
fodf = csd_fit.odf(sphere)
directions, _, _ = peak_directions(odf_gt, sphere)
directions2, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions, directions2)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
assert_equal(directions2.shape[0], 2)
with warnings.catch_warnings(record=True) as w:
ConstrainedSphericalDeconvModel(gtab, response, sh_order=10)
assert_equal(len(w) > 0, True)
with warnings.catch_warnings(record=True) as w:
ConstrainedSphericalDeconvModel(gtab, response, sh_order=8)
assert_equal(len(w) > 0, False)
mevecs = []
for s in sticks:
mevecs += [all_tensor_evecs(s).T]
S2 = single_tensor(gtab, 100, mevals[0], mevecs[0], snr=None)
big_S = np.zeros((10, 10, 10, len(S2)))
big_S[:] = S2
aresponse, aratio = auto_response(gtab,
big_S,
roi_center=(5, 5, 4),
roi_radius=3,
fa_thr=0.5)
assert_array_almost_equal(aresponse[0], response[0])
assert_almost_equal(aresponse[1], 100)
assert_almost_equal(aratio, response[0][1] / response[0][0])
aresponse2, aratio2 = auto_response(gtab, big_S, roi_radius=3, fa_thr=0.5)
assert_array_almost_equal(aresponse[0], response[0])
_, _, nvoxels = auto_response(gtab,
big_S,
roi_center=(5, 5, 4),
roi_radius=30,
fa_thr=0.5,
return_number_of_voxels=True)
assert_equal(nvoxels, 1000)
_, _, nvoxels = auto_response(gtab,
big_S,
roi_center=(5, 5, 4),
roi_radius=30,
fa_thr=1,
return_number_of_voxels=True)
assert_equal(nvoxels, 0)
def test_csd_predict():
"""
Test prediction API
"""
SNR = 100
S0 = 1
_, fbvals, fbvecs = get_fnames('small_64D')
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
gtab = gradient_table(bvals, bvecs)
mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (60, 0)]
S, _ = multi_tensor(gtab,
mevals,
S0,
angles=angles,
fractions=[50, 50],
snr=SNR)
sphere = small_sphere
multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
response = (np.array([0.0015, 0.0003, 0.0003]), S0)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
csd = ConstrainedSphericalDeconvModel(gtab, response)
csd_fit = csd.fit(S)
# Predicting from a fit should give the same result as predicting from a
# model, S0 is 1 by default
prediction1 = csd_fit.predict()
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
prediction2 = csd.predict(csd_fit.shm_coeff)
npt.assert_array_equal(prediction1, prediction2)
npt.assert_array_equal(prediction1[..., gtab.b0s_mask], 1.)
# Same with a different S0
prediction1 = csd_fit.predict(S0=123.)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
prediction2 = csd.predict(csd_fit.shm_coeff, S0=123.)
npt.assert_array_equal(prediction1, prediction2)
npt.assert_array_equal(prediction1[..., gtab.b0s_mask], 123.)
# For "well behaved" coefficients, the model should be able to find the
# coefficients from the predicted signal.
coeff = np.random.random(csd_fit.shm_coeff.shape) - .5
coeff[..., 0] = 10.
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
S = csd.predict(coeff)
csd_fit = csd.fit(S)
npt.assert_array_almost_equal(coeff, csd_fit.shm_coeff)
# Test predict on nd-data set
S_nd = np.zeros((2, 3, 4, S.size))
S_nd[:] = S
fit = csd.fit(S_nd)
predict1 = fit.predict()
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
predict2 = csd.predict(fit.shm_coeff)
npt.assert_array_almost_equal(predict1, predict2)
def test_bootstap_peak_tracker():
"""This tests that the Bootstrat Peak Direction Getter plays nice
LocalTracking and produces reasonable streamlines in a simple example.
"""
sphere = get_sphere('repulsion100')
# A simple image with three possible configurations, a vertical tract,
# a horizontal tract and a crossing
simple_image = np.array([
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[2, 3, 2, 2, 2, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
])
simple_image = simple_image[..., None]
bvecs = sphere.vertices
bvals = np.ones(len(bvecs)) * 1000
bvecs = np.insert(bvecs, 0, np.array([0, 0, 0]), axis=0)
bvals = np.insert(bvals, 0, 0)
gtab = gradient_table(bvals, bvecs)
angles = [(90, 90), (90, 0)]
fracs = [50, 50]
mevals = np.array([[1.5, 0.4, 0.4], [1.5, 0.4, 0.4]]) * 1e-3
mevecs = [
np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
np.array([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
]
voxel1 = single_tensor(gtab, 1, mevals[0], mevecs[0], snr=None)
voxel2 = single_tensor(gtab, 1, mevals[0], mevecs[1], snr=None)
voxel3, _ = multi_tensor(gtab,
mevals,
fractions=fracs,
angles=angles,
snr=None)
data = np.tile(voxel3, [5, 6, 1, 1])
data[simple_image == 1] = voxel1
data[simple_image == 2] = voxel2
response = (np.array(mevals[1]), 1)
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
seeds = [np.array([0., 1., 0.]), np.array([2., 4., 0.])]
tc = BinaryTissueClassifier((simple_image > 0).astype(float))
sphere = HemiSphere.from_sphere(get_sphere('symmetric724'))
boot_dg = BootDirectionGetter.from_data(data, csd_model, 60, sphere=sphere)
streamlines_generator = LocalTracking(boot_dg, tc, seeds, np.eye(4), 1.)
streamlines = Streamlines(streamlines_generator)
expected = [
np.array([[0., 1., 0.], [1., 1., 0.], [2., 1., 0.], [3., 1., 0.],
[4., 1., 0.]]),
np.array([
[2., 4., 0.],
[2., 3., 0.],
[2., 2., 0.],
[2., 1., 0.],
[2., 0., 0.],
])
]
def allclose(x, y):
return x.shape == y.shape and np.allclose(x, y, atol=0.5)
if not allclose(streamlines[0], expected[0]):
raise AssertionError()
if not allclose(streamlines[1], expected[1]):
raise AssertionError()
def csd(dwi_file, bvals_file, bvecs_file,
outfile_shm=None, roi_center=None, roi_radius=10, fa_threshold=0.75,
outfile_peaks_dir=None, outfile_peaks_val=None, mibrain_file=None,
peak_mask=None, npeaks=5, min_separation=30, normalize=0,
verbose=0):
if verbose:
logging.basicConfig(level=logging.DEBUG)
if roi_center is not None and len(roi_center) != 3:
raise ValueError("roi_center should be a 3-D position")
bvals, bvecs = read_bvals_bvecs(bvals_file, bvecs_file)
gtab = gradient_table(bvals, bvecs, b0_threshold=bvals.min())
diffusion_img = nibabel.load(dwi_file)
diffusion_data = diffusion_img.get_data()
logging.debug("Fitting CSD model")
response, ratio = auto_response(gtab, diffusion_data,
roi_center, roi_radius,
fa_threshold)
logging.debug("Response: {}, ratio: {}".format(response, ratio))
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
if outfile_shm is not None:
csd_fit = csd_model.fit(diffusion_data)
logging.debug("Saving SHM Coefficients")
citrix.save(outfile_shm, csd_fit.shm_coeff,
affine=diffusion_img.affine, header=diffusion_img.header,
version=1)
if outfile_peaks_dir is None and outfile_peaks_val is None and mibrain_file is None:
return
logging.debug("Computing peaks")
sphere = get_sphere()
if peak_mask is not None:
peak_mask = nibabel.load(peak_mask).get_data().astype(bool)
peaks = peaks_from_model(csd_model, diffusion_data, sphere, 0.5,
min_separation, peak_mask,
normalize_peaks=normalize, npeaks=npeaks,
sh_order=6)
logging.debug("Saving peaks")
if outfile_peaks_dir is not None:
citrix.save(outfile_peaks_dir, peaks.peak_dirs,
affine=diffusion_img.affine, header=diffusion_img.header,
version=1)
if outfile_peaks_val is not None:
citrix.save(outfile_peaks_val, peaks.peak_values,
affine=diffusion_img.affine, header=diffusion_img.header,
version=1)
if mibrain_file is not None:
peaks = peaks.peak_dirs * peaks.peak_values[...,None]
peaks = peaks.reshape(*peaks.shape[:-2], -1)
citrix.save(mibrain_file, peaks,
affine=diffusion_img.affine, header=diffusion_img.header,
version=1)
