def fiber_tracking(self):
from dipy.data import default_sphere
from dipy.direction import DeterministicMaximumDirectionGetter
from dipy.tracking.streamline import Streamlines
from dipy.tracking.local_tracking import ParticleFilteringTracking
from Tractography.files_saving import save_ft
self.create_model_fit()
detmax_dg = DeterministicMaximumDirectionGetter.from_shcoeff(
self.model_fit.shm_coeff,
max_angle=self.parameters_dict['max_ang'],
sphere=default_sphere)
print(f"Tractography using PFT and {self.sc_method} clasifier")
self.create_classifier()
print('Starting to compute streamlines')
self.streamlines = Streamlines(
ParticleFilteringTracking(
detmax_dg,
self.classifier,
self.seeds,
self.affine,
step_size=self.parameters_dict['step_size'],
maxlen=self.parameters_dict['length_margins'][1],
pft_back_tracking_dist=2,
pft_front_tracking_dist=1,
particle_count=15,
return_all=False))
self._remove_streamlines_outliers()
file_name = f'wb_{self.ft_method}_{self.sc_method}.tck'
save_ft(self.subj_folder, self.streamlines, self.nii_ref, file_name)
def test_save_seeds():
tissue = np.array([[2, 1, 1, 2, 1],
[2, 2, 1, 1, 2],
[1, 1, 1, 1, 1],
[1, 1, 1, 2, 2],
[0, 1, 1, 1, 2],
[0, 1, 1, 0, 2],
[1, 0, 1, 1, 1]])
tissue = tissue[None]
sphere = HemiSphere.from_sphere(unit_octahedron)
pmf_lookup = np.array([[0., 0., 0., ],
[0., 0., 1.]])
pmf = pmf_lookup[(tissue > 0).astype("int")]
# Create a seeds along
x = np.array([0., 0, 0, 0, 0, 0, 0])
y = np.array([0., 1, 2, 3, 4, 5, 6])
z = np.array([1., 1, 1, 0, 1, 1, 1])
seeds = np.column_stack([x, y, z])
# Set up tracking
endpoint_mask = tissue == StreamlineStatus.ENDPOINT
invalidpoint_mask = tissue == StreamlineStatus.INVALIDPOINT
sc = ActStoppingCriterion(endpoint_mask, invalidpoint_mask)
dg = ProbabilisticDirectionGetter.from_pmf(pmf, 60, sphere)
# valid streamlines only
streamlines_generator = LocalTracking(direction_getter=dg,
stopping_criterion=sc,
seeds=seeds,
affine=np.eye(4),
step_size=1.,
return_all=False,
save_seeds=True)
streamlines_not_all = iter(streamlines_generator)
# Verifiy that seeds are returned by the LocalTracker
_, seed = next(streamlines_not_all)
npt.assert_equal(seed, seeds[0])
_, seed = next(streamlines_not_all)
npt.assert_equal(seed, seeds[1])
# Verifiy that seeds are returned by the PFTTracker also
pft_streamlines = ParticleFilteringTracking(direction_getter=dg,
stopping_criterion=sc,
seeds=seeds,
affine=np.eye(4),
step_size=1.,
max_cross=1,
return_all=False,
save_seeds=True)
streamlines = iter(pft_streamlines)
_, seed = next(streamlines)
npt.assert_equal(seed, seeds[0])
_, seed = next(streamlines)
npt.assert_equal(seed, seeds[1])
def PFT_tracking(name=None, data_path=None, output_path='.', Threshold=.20):
time0 = time.time()
print("begin loading data, time:", time.time() - time0)
data, affine, img, labels, gtab, head_mask = get_data(name, data_path)
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)
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)
dg = ProbabilisticDirectionGetter.from_shcoeff(csd_fit.shm_coeff,
max_angle=20.,
sphere=default_sphere)
#seed_mask = (labels == 2)
#seed_mask[pve_wm_data < 0.5] = 0
seeds = utils.seeds_from_mask(seed_mask, affine, density=1)
#voxel_size = np.average(voxel_size[1:4])
step_size = 0.2
#cmc_criterion = CmcStoppingCriterion.from_pve(pve_wm_data,
# pve_gm_data,
# pve_csf_data,
# step_size=step_size,
# average_voxel_size=voxel_size)
# Particle Filtering Tractography
pft_streamline_generator = ParticleFilteringTracking(
dg,
stopping_criterion,
seeds,
affine,
max_cross=1,
step_size=step_size,
maxlen=1000,
pft_back_tracking_dist=2,
pft_front_tracking_dist=1,
particle_count=15,
return_all=False)
streamlines = Streamlines(pft_streamline_generator)
sft = StatefulTractogram(streamlines, img, Space.RASMM)
output = output_path + '/tractogram_pft_' + name + '.trk'
def create_streamlines(model_fit,
seeds,
affine,
gtab=None,
data=None,
white_matter=None,
folder_name=None,
classifier_type="fa"):
from dipy.data import default_sphere
from dipy.direction import DeterministicMaximumDirectionGetter
from dipy.tracking.streamline import Streamlines
from dipy.tracking.local_tracking import (LocalTracking,
ParticleFilteringTracking)
detmax_dg = DeterministicMaximumDirectionGetter.from_shcoeff(
model_fit.shm_coeff, max_angle=30., sphere=default_sphere)
if classifier_type == "fa":
print("Tractography using local tracking and FA clasifier")
classifier = create_fa_classifier(gtab, data, white_matter)[1]
print('Starting to compute streamlines')
streamlines = Streamlines(
LocalTracking(detmax_dg,
classifier,
seeds,
affine,
step_size=1,
return_all=False))
elif classifier_type == "cmc":
print("Tractography using PFT and CMC clasifier")
classifier, step_size = create_cmc_classifier(folder_name)
print('Starting to compute streamlines')
streamlines = Streamlines(
ParticleFilteringTracking(detmax_dg,
classifier,
seeds,
affine,
step_size=step_size,
maxlen=1500,
pft_back_tracking_dist=2,
pft_front_tracking_dist=1,
particle_count=15,
return_all=False))
long_streamlines = np.ones((len(streamlines)), bool)
for i in range(0, len(streamlines)):
if streamlines[i].shape[0] < 100:
long_streamlines[i] = False
streamlines = streamlines[long_streamlines]
return streamlines
voxel_size = np.average(voxel_size[1:4])
step_size = 0.2
cmc_criterion = CmcStoppingCriterion.from_pve(pve_wm_data,
pve_gm_data,
pve_csf_data,
step_size=step_size,
average_voxel_size=voxel_size)
# Particle Filtering Tractography
pft_streamline_generator = ParticleFilteringTracking(dg,
cmc_criterion,
seeds,
affine,
max_cross=1,
step_size=step_size,
maxlen=1000,
pft_back_tracking_dist=2,
pft_front_tracking_dist=1,
particle_count=15,
return_all=False)
streamlines = Streamlines(pft_streamline_generator)
sft = StatefulTractogram(streamlines, hardi_img, Space.RASMM)
save_trk(sft, "tractogram_pft.trk")
if has_fury:
r = window.Renderer()
r.add(actor.line(streamlines, colormap.line_colors(streamlines)))
window.record(r, out_path='tractogram_pft.png', size=(800, 800))
if interactive:
window.show(r)
def test_particle_filtering_tractography():
"""This tests that the ParticleFilteringTracking produces
more streamlines connecting the gray matter than LocalTracking.
"""
sphere = get_sphere('repulsion100')
step_size = 0.2
# Simple tissue masks
simple_wm = np.array([[0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0]])
simple_wm = np.dstack([
np.zeros(simple_wm.shape), simple_wm, simple_wm, simple_wm,
np.zeros(simple_wm.shape)
])
simple_gm = np.array([[1, 1, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 1, 0], [0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0]])
simple_gm = np.dstack([
np.zeros(simple_gm.shape), simple_gm, simple_gm, simple_gm,
np.zeros(simple_gm.shape)
])
simple_csf = np.ones(simple_wm.shape) - simple_wm - simple_gm
sc = ActStoppingCriterion.from_pve(simple_wm, simple_gm, simple_csf)
seeds = seeds_from_mask(simple_wm, np.eye(4), density=2)
# Random pmf in every voxel
shape_img = list(simple_wm.shape)
shape_img.extend([sphere.vertices.shape[0]])
np.random.seed(0) # Random number generator initialization
pmf = np.random.random(shape_img)
# Test that PFT recover equal or more streamlines than localTracking
dg = ProbabilisticDirectionGetter.from_pmf(pmf, 60, sphere)
local_streamlines_generator = LocalTracking(dg,
sc,
seeds,
np.eye(4),
step_size,
max_cross=1,
return_all=False)
local_streamlines = Streamlines(local_streamlines_generator)
pft_streamlines_generator = ParticleFilteringTracking(
dg,
sc,
seeds,
np.eye(4),
step_size,
max_cross=1,
return_all=False,
pft_back_tracking_dist=1,
pft_front_tracking_dist=0.5)
pft_streamlines = Streamlines(pft_streamlines_generator)
npt.assert_(np.array([len(pft_streamlines) > 0]))
npt.assert_(np.array([len(pft_streamlines) >= len(local_streamlines)]))
# Test that all points are equally spaced
for l in [1, 2, 5, 10, 100]:
pft_streamlines = ParticleFilteringTracking(dg,
sc,
seeds,
np.eye(4),
step_size,
max_cross=1,
return_all=True,
maxlen=l)
for s in pft_streamlines:
for i in range(len(s) - 1):
npt.assert_almost_equal(np.linalg.norm(s[i] - s[i + 1]),
step_size)
# Test that all points are within the image volume
seeds = seeds_from_mask(np.ones(simple_wm.shape), np.eye(4), density=1)
pft_streamlines_generator = ParticleFilteringTracking(dg,
sc,
seeds,
np.eye(4),
step_size,
max_cross=1,
return_all=True)
pft_streamlines = Streamlines(pft_streamlines_generator)
for s in pft_streamlines:
npt.assert_(np.all((s + 0.5).astype(int) >= 0))
npt.assert_(np.all((s + 0.5).astype(int) < simple_wm.shape))
# Test that the number of streamline return with return_all=True equal the
# number of seeds places
npt.assert_(np.array([len(pft_streamlines) == len(seeds)]))
# Test non WM seed position
seeds = [[0, 5, 4], [0, 0, 1], [50, 50, 50]]
pft_streamlines_generator = ParticleFilteringTracking(dg,
sc,
seeds,
np.eye(4),
step_size,
max_cross=1,
return_all=True)
pft_streamlines = Streamlines(pft_streamlines_generator)
npt.assert_equal(len(pft_streamlines[0]), 3) # INVALIDPOINT
npt.assert_equal(len(pft_streamlines[1]), 3) # ENDPOINT
npt.assert_equal(len(pft_streamlines[2]), 1) # OUTSIDEIMAGE
# Test with wrong StoppingCriterion type
sc_bin = BinaryStoppingCriterion(simple_wm)
npt.assert_raises(
ValueError, lambda: ParticleFilteringTracking(dg, sc_bin, seeds,
np.eye(4), step_size))
# Test with invalid back/front tracking distances
npt.assert_raises(
ValueError,
lambda: ParticleFilteringTracking(dg,
sc,
seeds,
np.eye(4),
step_size,
pft_back_tracking_dist=0,
pft_front_tracking_dist=0))
npt.assert_raises(
ValueError, lambda: ParticleFilteringTracking(
dg, sc, seeds, np.eye(4), step_size, pft_back_tracking_dist=-1))
npt.assert_raises(
ValueError,
lambda: ParticleFilteringTracking(dg,
sc,
seeds,
np.eye(4),
step_size,
pft_back_tracking_dist=0,
pft_front_tracking_dist=-2))
# Test with invalid affine shape
npt.assert_raises(
ValueError,
lambda: ParticleFilteringTracking(dg, sc, seeds, np.eye(3), step_size))
# Test with invalid maxlen
npt.assert_raises(
ValueError, lambda: ParticleFilteringTracking(
dg, sc, seeds, np.eye(4), step_size, maxlen=0))
npt.assert_raises(
ValueError, lambda: ParticleFilteringTracking(
dg, sc, seeds, np.eye(4), step_size, maxlen=-1))
# Test with invalid particle count
npt.assert_raises(
ValueError, lambda: ParticleFilteringTracking(
dg, sc, seeds, np.eye(4), step_size, particle_count=0))
npt.assert_raises(
ValueError, lambda: ParticleFilteringTracking(
dg, sc, seeds, np.eye(4), step_size, particle_count=-1))
# Test reproducibility
tracking1 = Streamlines(
ParticleFilteringTracking(dg,
sc,
seeds,
np.eye(4),
step_size,
random_seed=0))._data
tracking2 = Streamlines(
ParticleFilteringTracking(dg,
sc,
seeds,
np.eye(4),
step_size,
random_seed=0))._data
npt.assert_equal(tracking1, tracking2)
def run(self,
pam_files,
wm_files,
gm_files,
csf_files,
seeding_files,
step_size=0.2,
seed_density=1,
pmf_threshold=0.1,
max_angle=20.,
pft_back=2,
pft_front=1,
pft_count=15,
out_dir='',
out_tractogram='tractogram.trk',
save_seeds=False):
"""Workflow for Particle Filtering Tracking.
This workflow use a saved peaks and metrics (PAM) file as input.
Parameters
----------
pam_files : string
Path to the peaks and metrics files. This path may contain
wildcards to use multiple masks at once.
wm_files : string
Path to white matter partial volume estimate for tracking (CMC).
gm_files : string
Path to grey matter partial volume estimate for tracking (CMC).
csf_files : string
Path to cerebrospinal fluid partial volume estimate for tracking
(CMC).
seeding_files : string
A binary image showing where we need to seed for tracking.
step_size : float, optional
Step size used for tracking (default 0.2mm).
seed_density : int, optional
Number of seeds per dimension inside voxel (default 1).
For example, seed_density of 2 means 8 regularly distributed
points in the voxel. And seed density of 1 means 1 point at the
center of the voxel.
pmf_threshold : float, optional
Threshold for ODF functions (default 0.1).
max_angle : float, optional
Maximum angle between streamline segments (range [0, 90],
default 20).
pft_back : float, optional
Distance in mm to back track before starting the particle filtering
tractography (default 2mm). The total particle filtering
tractography distance is equal to back_tracking_dist +
front_tracking_dist.
pft_front : float, optional
Distance in mm to run the particle filtering tractography after the
the back track distance (default 1mm). The total particle filtering
tractography distance is equal to back_tracking_dist +
front_tracking_dist.
pft_count : int, optional
Number of particles to use in the particle filter (default 15).
out_dir : string, optional
Output directory (default input file directory)
out_tractogram : string, optional
Name of the tractogram file to be saved (default 'tractogram.trk')
save_seeds : bool, optional
If true, save the seeds associated to their streamline
in the 'data_per_streamline' Tractogram dictionary using
'seeds' as the key
References
----------
Girard, G., Whittingstall, K., Deriche, R., & Descoteaux, M. Towards
quantitative connectivity analysis: reducing tractography biases.
NeuroImage, 98, 266-278, 2014.
"""
io_it = self.get_io_iterator()
for pams_path, wm_path, gm_path, csf_path, seeding_path, out_tract \
in io_it:
logging.info(
'Particle Filtering tracking on {0}'.format(pams_path))
pam = load_peaks(pams_path, verbose=False)
wm, affine, voxel_size = load_nifti(wm_path, return_voxsize=True)
gm, _ = load_nifti(gm_path)
csf, _ = load_nifti(csf_path)
avs = sum(voxel_size) / len(voxel_size) # average_voxel_size
stopping_criterion = CmcStoppingCriterion.from_pve(
wm, gm, csf, step_size=step_size, average_voxel_size=avs)
logging.info('stopping criterion done')
seed_mask, _ = load_nifti(seeding_path)
seeds = utils.seeds_from_mask(
seed_mask,
density=[seed_density, seed_density, seed_density],
affine=affine)
logging.info('seeds done')
dg = ProbabilisticDirectionGetter
direction_getter = dg.from_shcoeff(pam.shm_coeff,
max_angle=max_angle,
sphere=pam.sphere,
pmf_threshold=pmf_threshold)
tracking_result = ParticleFilteringTracking(
direction_getter,
stopping_criterion,
seeds,
affine,
step_size=step_size,
pft_back_tracking_dist=pft_back,
pft_front_tracking_dist=pft_front,
pft_max_trial=20,
particle_count=pft_count,
save_seeds=save_seeds)
logging.info('ParticleFilteringTracking initiated')
if save_seeds:
streamlines, seeds = zip(*tracking_result)
seeds = {'seeds': seeds}
else:
streamlines = list(tracking_result)
seeds = {}
sft = StatefulTractogram(streamlines,
seeding_path,
Space.RASMM,
data_per_streamline=seeds)
save_tractogram(sft, out_tract, bbox_valid_check=False)
logging.info('Saved {0}'.format(out_tract))
def run_tracking(step_curv_combinations,
recon_shelved,
n_seeds_per_iter,
traversal,
maxcrossing,
max_length,
pft_back_tracking_dist,
pft_front_tracking_dist,
particle_count,
roi_neighborhood_tol,
min_length,
track_type,
min_separation_angle,
sphere,
tiss_class,
tissue_shelved,
verbose=False):
"""
Create a density map of the list of streamlines.
Parameters
----------
step_curv_combinations : list
List of tuples representing all pair combinations of step sizes and
curvature thresholds from which to sample streamlines.
recon_path : str
File path to diffusion reconstruction model.
n_seeds_per_iter : int
Number of seeds from which to initiate tracking for each unique
ensemble combination. By default this is set to 250.
directget : str
The statistical approach to tracking. Options are: det (deterministic),
closest (clos), boot (bootstrapped), and prob (probabilistic).
maxcrossing : int
Maximum number if diffusion directions that can be assumed per voxel
while tracking.
max_length : int
Maximum number of steps to restrict tracking.
pft_back_tracking_dist : float
Distance in mm to back track before starting the particle filtering
tractography. The total particle filtering tractography distance is
equal to back_tracking_dist + front_tracking_dist. By default this is
set to 2 mm.
pft_front_tracking_dist : float
Distance in mm to run the particle filtering tractography after the
the back track distance. The total particle filtering tractography
distance is equal to back_tracking_dist + front_tracking_dist. By
default this is set to 1 mm.
particle_count : int
Number of particles to use in the particle filter.
roi_neighborhood_tol : float
Distance (in the units of the streamlines, usually mm). If any
coordinate in the streamline is within this distance from the center
of any voxel in the ROI, the filtering criterion is set to True for
this streamline, otherwise False. Defaults to the distance between
the center of each voxel and the corner of the voxel.
waymask_data : ndarray
Tractography constraint mask array in native diffusion space.
min_length : int
Minimum fiber length threshold in mm to restrict tracking.
track_type : str
Tracking algorithm used (e.g. 'local' or 'particle').
min_separation_angle : float
The minimum angle between directions [0, 90].
sphere : obj
DiPy object for modeling diffusion directions on a sphere.
tiss_class : str
Tissue classification method.
tissue_shelved : str
File path to joblib-shelved 4D T1w tissue segmentations in native
diffusion space.
Returns
-------
streamlines : ArraySequence
DiPy list/array-like object of streamline points from tractography.
"""
import gc
import time
import numpy as np
from dipy.tracking import utils
from dipy.tracking.streamline import select_by_rois
from dipy.tracking.local_tracking import LocalTracking, \
ParticleFilteringTracking
from dipy.direction import (ProbabilisticDirectionGetter,
ClosestPeakDirectionGetter,
DeterministicMaximumDirectionGetter)
from nilearn.image import index_img, math_img
from pynets.dmri.utils import generate_seeds, random_seeds_from_mask
from nibabel.streamlines.array_sequence import ArraySequence
start_time = time.time()
if verbose is True:
print("%s%s%s" % ('Preparing tissue constraints:',
np.round(time.time() - start_time, 1), 's'))
start_time = time.time()
tissue_img = tissue_shelved.get()
# Order:
B0_mask = index_img(tissue_img, 0)
atlas_img = index_img(tissue_img, 1)
t1w2dwi = index_img(tissue_img, 3)
gm_in_dwi = index_img(tissue_img, 4)
vent_csf_in_dwi = index_img(tissue_img, 5)
wm_in_dwi = index_img(tissue_img, 6)
tissue_img.uncache()
tiss_classifier = prep_tissues(t1w2dwi, gm_in_dwi, vent_csf_in_dwi,
wm_in_dwi, tiss_class, B0_mask)
# if verbose is True:
# print("%s%s%s" % (
# 'Fitting tissue classifier:',
# np.round(time.time() - start_time, 1), 's'))
# start_time = time.time()
if verbose is True:
print("%s%s%s" % ('Loading reconstruction:',
np.round(time.time() - start_time, 1), 's'))
start_time = time.time()
print("%s%s" % ("Curvature: ", step_curv_combinations[1]))
# Instantiate DirectionGetter
if traversal.lower() in ["probabilistic", "prob"]:
dg = ProbabilisticDirectionGetter.from_shcoeff(
recon_shelved.get(),
max_angle=float(step_curv_combinations[1]),
sphere=sphere,
min_separation_angle=min_separation_angle,
)
elif traversal.lower() in ["closestpeaks", "cp"]:
dg = ClosestPeakDirectionGetter.from_shcoeff(
recon_shelved.get(),
max_angle=float(step_curv_combinations[1]),
sphere=sphere,
min_separation_angle=min_separation_angle,
)
elif traversal.lower() in ["deterministic", "det"]:
maxcrossing = 1
dg = DeterministicMaximumDirectionGetter.from_shcoeff(
recon_shelved.get(),
max_angle=float(step_curv_combinations[1]),
sphere=sphere,
min_separation_angle=min_separation_angle,
)
else:
raise ValueError("ERROR: No valid direction getter(s) specified.")
if verbose is True:
print("%s%s%s" % ('Extracting directions:',
np.round(time.time() - start_time, 1), 's'))
start_time = time.time()
print("%s%s" % ("Step: ", step_curv_combinations[0]))
# Perform wm-gm interface seeding, using n_seeds at a time
seeds = generate_seeds(
random_seeds_from_mask(np.asarray(
math_img("img > 0.01", img=index_img(
tissue_img, 2)).dataobj).astype("bool").astype("int16") > 0,
seeds_count=n_seeds_per_iter,
random_seed=42))
if verbose is True:
print("%s%s%s" % ('Drawing random seeds:',
np.round(time.time() - start_time, 1), 's'))
start_time = time.time()
# print(seeds)
# Perform tracking
if track_type == "local":
streamline_generator = LocalTracking(dg,
tiss_classifier,
np.stack([i for i in seeds]),
np.eye(4),
max_cross=int(maxcrossing),
maxlen=int(max_length),
step_size=float(
step_curv_combinations[0]),
fixedstep=False,
return_all=True,
random_seed=42)
elif track_type == "particle":
streamline_generator = ParticleFilteringTracking(
dg,
tiss_classifier,
np.stack([i for i in seeds]),
np.eye(4),
max_cross=int(maxcrossing),
step_size=float(step_curv_combinations[0]),
maxlen=int(max_length),
pft_back_tracking_dist=pft_back_tracking_dist,
pft_front_tracking_dist=pft_front_tracking_dist,
pft_max_trial=20,
particle_count=particle_count,
return_all=True,
random_seed=42)
else:
raise ValueError("ERROR: No valid tracking method(s) specified.")
if verbose is True:
print("%s%s%s" % ('Instantiating tracking:',
np.round(time.time() - start_time, 1), 's'))
start_time = time.time()
# print(seeds)
del dg
# Filter resulting streamlines by those that stay entirely
# inside the brain
try:
roi_proximal_streamlines = utils.target(
streamline_generator,
np.eye(4),
np.asarray(B0_mask.dataobj).astype('bool'),
include=True)
except BaseException:
print('No streamlines found inside the brain! ' 'Check registrations.')
#return None
if verbose is True:
print("%s%s%s" % ('Drawing streamlines:',
np.round(time.time() - start_time, 1), 's'))
start_time = time.time()
del seeds, tiss_classifier, streamline_generator
B0_mask.uncache()
atlas_img.uncache()
t1w2dwi.uncache()
gm_in_dwi.uncache()
vent_csf_in_dwi.uncache()
wm_in_dwi.uncache()
gc.collect()
# Filter resulting streamlines by roi-intersection
# characteristics
atlas_data = np.array(atlas_img.dataobj).astype("uint16")
# Build mask vector from atlas for later roi filtering
parcels = [
atlas_data == roi_val
for roi_val in [i for i in np.unique(atlas_data) if i != 0]
]
try:
roi_proximal_streamlines = \
select_by_rois(
roi_proximal_streamlines,
affine=np.eye(4),
rois=parcels,
include=list(np.ones(len(parcels)).astype("bool")),
mode="any",
tol=roi_neighborhood_tol,
)
except BaseException:
print('No streamlines found to connect any parcels! '
'Check registrations.')
#return None
del atlas_data
if verbose is True:
print("%s%s%s" % ('Selecting by parcellation:',
np.round(time.time() - start_time, 1), 's'))
start_time = time.time()
del parcels
gc.collect()
if verbose is True:
print("%s%s%s" % ('Selecting by minimum length criterion:',
np.round(time.time() - start_time, 1), 's'))
gc.collect()
return ArraySequence([
s.astype("float32") for s in roi_proximal_streamlines
if len(s) > float(min_length)
])
def main():
parser = _build_args_parser()
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
assert_inputs_exist(parser, [args.sh_file, args.seed_file,
args.map_include_file,
args.map_exclude_file])
assert_outputs_exist(parser, args, args.output_file)
if not nib.streamlines.is_supported(args.output_file):
parser.error('Invalid output streamline file format (must be trk or ' +
'tck): {0}'.format(args.output_file))
if not args.min_length > 0:
parser.error('minL must be > 0, {}mm was provided.'
.format(args.min_length))
if args.max_length < args.min_length:
parser.error('maxL must be > than minL, (minL={}mm, maxL={}mm).'
.format(args.min_length, args.max_length))
if args.compress:
if args.compress < 0.001 or args.compress > 1:
logging.warning(
'You are using an error rate of {}.\nWe recommend setting it '
'between 0.001 and 1.\n0.001 will do almost nothing to the '
'tracts while 1 will higly compress/linearize the tracts'
.format(args.compress))
if args.particles <= 0:
parser.error('--particles must be >= 1.')
if args.back_tracking <= 0:
parser.error('PFT backtracking distance must be > 0.')
if args.forward_tracking <= 0:
parser.error('PFT forward tracking distance must be > 0.')
if args.npv and args.npv <= 0:
parser.error('Number of seeds per voxel must be > 0.')
if args.nt and args.nt <= 0:
parser.error('Total number of seeds must be > 0.')
fodf_sh_img = nib.load(args.sh_file)
if not np.allclose(np.mean(fodf_sh_img.header.get_zooms()[:3]),
fodf_sh_img.header.get_zooms()[0], atol=1.e-3):
parser.error(
'SH file is not isotropic. Tracking cannot be ran robustly.')
tracking_sphere = HemiSphere.from_sphere(get_sphere('repulsion724'))
# Check if sphere is unit, since we couldn't find such check in Dipy.
if not np.allclose(np.linalg.norm(tracking_sphere.vertices, axis=1), 1.):
raise RuntimeError('Tracking sphere should be unit normed.')
sh_basis = args.sh_basis
if args.algo == 'det':
dgklass = DeterministicMaximumDirectionGetter
else:
dgklass = ProbabilisticDirectionGetter
theta = get_theta(args.theta, args.algo)
# Reminder for the future:
# pmf_threshold == clip pmf under this
# relative_peak_threshold is for initial directions filtering
# min_separation_angle is the initial separation angle for peak extraction
dg = dgklass.from_shcoeff(
fodf_sh_img.get_fdata(dtype=np.double),
max_angle=theta,
sphere=tracking_sphere,
basis_type=sh_basis,
pmf_threshold=args.sf_threshold,
relative_peak_threshold=args.sf_threshold_init)
map_include_img = nib.load(args.map_include_file)
map_exclude_img = nib.load(args.map_exclude_file)
voxel_size = np.average(map_include_img.get_header()['pixdim'][1:4])
if not args.act:
tissue_classifier = CmcStoppingCriterion(map_include_img.get_fdata(),
map_exclude_img.get_fdata(),
step_size=args.step_size,
average_voxel_size=voxel_size)
else:
tissue_classifier = ActStoppingCriterion(map_include_img.get_fdata(),
map_exclude_img.get_fdata())
if args.npv:
nb_seeds = args.npv
seed_per_vox = True
elif args.nt:
nb_seeds = args.nt
seed_per_vox = False
else:
nb_seeds = 1
seed_per_vox = True
voxel_size = fodf_sh_img.header.get_zooms()[0]
vox_step_size = args.step_size / voxel_size
seed_img = nib.load(args.seed_file)
seeds = track_utils.random_seeds_from_mask(
seed_img.get_fdata(),
np.eye(4),
seeds_count=nb_seeds,
seed_count_per_voxel=seed_per_vox,
random_seed=args.seed)
# Note that max steps is used once for the forward pass, and
# once for the backwards. This doesn't, in fact, control the real
# max length
max_steps = int(args.max_length / args.step_size) + 1
pft_streamlines = ParticleFilteringTracking(
dg,
tissue_classifier,
seeds,
np.eye(4),
max_cross=1,
step_size=vox_step_size,
maxlen=max_steps,
pft_back_tracking_dist=args.back_tracking,
pft_front_tracking_dist=args.forward_tracking,
particle_count=args.particles,
return_all=args.keep_all,
random_seed=args.seed,
save_seeds=args.save_seeds)
scaled_min_length = args.min_length / voxel_size
scaled_max_length = args.max_length / voxel_size
if args.save_seeds:
filtered_streamlines, seeds = \
zip(*((s, p) for s, p in pft_streamlines
if scaled_min_length <= length(s) <= scaled_max_length))
data_per_streamlines = {'seeds': lambda: seeds}
else:
filtered_streamlines = \
(s for s in pft_streamlines
if scaled_min_length <= length(s) <= scaled_max_length)
data_per_streamlines = {}
if args.compress:
filtered_streamlines = (
compress_streamlines(s, args.compress)
for s in filtered_streamlines)
tractogram = LazyTractogram(lambda: filtered_streamlines,
data_per_streamlines,
affine_to_rasmm=seed_img.affine)
filetype = nib.streamlines.detect_format(args.output_file)
header = create_header_from_anat(seed_img, base_filetype=filetype)
# Use generator to save the streamlines on-the-fly
nib.streamlines.save(tractogram, args.output_file, header=header)
def run_tracking(step_curv_combinations,
recon_path,
n_seeds_per_iter,
directget,
maxcrossing,
max_length,
pft_back_tracking_dist,
pft_front_tracking_dist,
particle_count,
roi_neighborhood_tol,
waymask,
min_length,
track_type,
min_separation_angle,
sphere,
tiss_class,
tissues4d,
cache_dir,
min_seeds=100):
import gc
import os
import h5py
from dipy.tracking import utils
from dipy.tracking.streamline import select_by_rois
from dipy.tracking.local_tracking import LocalTracking, \
ParticleFilteringTracking
from dipy.direction import (ProbabilisticDirectionGetter,
ClosestPeakDirectionGetter,
DeterministicMaximumDirectionGetter)
from nilearn.image import index_img
from pynets.dmri.track import prep_tissues
from nibabel.streamlines.array_sequence import ArraySequence
from nipype.utils.filemanip import copyfile, fname_presuffix
import uuid
from time import strftime
run_uuid = f"{strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4()}"
recon_path_tmp_path = fname_presuffix(
recon_path,
suffix=f"_{'_'.join([str(i) for i in step_curv_combinations])}_"
f"{run_uuid}",
newpath=cache_dir)
copyfile(recon_path, recon_path_tmp_path, copy=True, use_hardlink=False)
tissues4d_tmp_path = fname_presuffix(
tissues4d,
suffix=f"_{'_'.join([str(i) for i in step_curv_combinations])}_"
f"{run_uuid}",
newpath=cache_dir)
copyfile(tissues4d, tissues4d_tmp_path, copy=True, use_hardlink=False)
if waymask is not None:
waymask_tmp_path = fname_presuffix(
waymask,
suffix=f"_{'_'.join([str(i) for i in step_curv_combinations])}_"
f"{run_uuid}",
newpath=cache_dir)
copyfile(waymask, waymask_tmp_path, copy=True, use_hardlink=False)
else:
waymask_tmp_path = None
tissue_img = nib.load(tissues4d_tmp_path)
# Order:
B0_mask = index_img(tissue_img, 0)
atlas_img = index_img(tissue_img, 1)
seeding_mask = index_img(tissue_img, 2)
t1w2dwi = index_img(tissue_img, 3)
gm_in_dwi = index_img(tissue_img, 4)
vent_csf_in_dwi = index_img(tissue_img, 5)
wm_in_dwi = index_img(tissue_img, 6)
tiss_classifier = prep_tissues(t1w2dwi, gm_in_dwi, vent_csf_in_dwi,
wm_in_dwi, tiss_class, B0_mask)
B0_mask_data = np.asarray(B0_mask.dataobj).astype("bool")
seeding_mask = np.asarray(
seeding_mask.dataobj).astype("bool").astype("int16")
with h5py.File(recon_path_tmp_path, 'r+') as hf:
mod_fit = hf['reconstruction'][:].astype('float32')
print("%s%s" % ("Curvature: ", step_curv_combinations[1]))
# Instantiate DirectionGetter
if directget.lower() in ["probabilistic", "prob"]:
dg = ProbabilisticDirectionGetter.from_shcoeff(
mod_fit,
max_angle=float(step_curv_combinations[1]),
sphere=sphere,
min_separation_angle=min_separation_angle,
)
elif directget.lower() in ["closestpeaks", "cp"]:
dg = ClosestPeakDirectionGetter.from_shcoeff(
mod_fit,
max_angle=float(step_curv_combinations[1]),
sphere=sphere,
min_separation_angle=min_separation_angle,
)
elif directget.lower() in ["deterministic", "det"]:
maxcrossing = 1
dg = DeterministicMaximumDirectionGetter.from_shcoeff(
mod_fit,
max_angle=float(step_curv_combinations[1]),
sphere=sphere,
min_separation_angle=min_separation_angle,
)
else:
raise ValueError("ERROR: No valid direction getter(s) specified.")
print("%s%s" % ("Step: ", step_curv_combinations[0]))
# Perform wm-gm interface seeding, using n_seeds at a time
seeds = utils.random_seeds_from_mask(
seeding_mask > 0,
seeds_count=n_seeds_per_iter,
seed_count_per_voxel=False,
affine=np.eye(4),
)
if len(seeds) < min_seeds:
print(
UserWarning(
f"<{min_seeds} valid seed points found in wm-gm interface..."))
return None
# print(seeds)
# Perform tracking
if track_type == "local":
streamline_generator = LocalTracking(dg,
tiss_classifier,
seeds,
np.eye(4),
max_cross=int(maxcrossing),
maxlen=int(max_length),
step_size=float(
step_curv_combinations[0]),
fixedstep=False,
return_all=True,
random_seed=42)
elif track_type == "particle":
streamline_generator = ParticleFilteringTracking(
dg,
tiss_classifier,
seeds,
np.eye(4),
max_cross=int(maxcrossing),
step_size=float(step_curv_combinations[0]),
maxlen=int(max_length),
pft_back_tracking_dist=pft_back_tracking_dist,
pft_front_tracking_dist=pft_front_tracking_dist,
pft_max_trial=20,
particle_count=particle_count,
return_all=True,
random_seed=42)
else:
raise ValueError("ERROR: No valid tracking method(s) specified.")
# Filter resulting streamlines by those that stay entirely
# inside the brain
try:
roi_proximal_streamlines = utils.target(streamline_generator,
np.eye(4),
B0_mask_data.astype('bool'),
include=True)
except BaseException:
print('No streamlines found inside the brain! ' 'Check registrations.')
return None
del mod_fit, seeds, tiss_classifier, streamline_generator, \
B0_mask_data, seeding_mask, dg
B0_mask.uncache()
atlas_img.uncache()
t1w2dwi.uncache()
gm_in_dwi.uncache()
vent_csf_in_dwi.uncache()
wm_in_dwi.uncache()
atlas_img.uncache()
tissue_img.uncache()
gc.collect()
# Filter resulting streamlines by roi-intersection
# characteristics
atlas_data = np.array(atlas_img.dataobj).astype("uint16")
# Build mask vector from atlas for later roi filtering
parcels = []
i = 0
intensities = [i for i in np.unique(atlas_data) if i != 0]
for roi_val in intensities:
parcels.append(atlas_data == roi_val)
i += 1
parcel_vec = list(np.ones(len(parcels)).astype("bool"))
try:
roi_proximal_streamlines = \
nib.streamlines.array_sequence.ArraySequence(
select_by_rois(
roi_proximal_streamlines,
affine=np.eye(4),
rois=parcels,
include=parcel_vec,
mode="any",
tol=roi_neighborhood_tol,
)
)
print("%s%s" % ("Filtering by: \nNode intersection: ",
len(roi_proximal_streamlines)))
except BaseException:
print('No streamlines found to connect any parcels! '
'Check registrations.')
return None
try:
roi_proximal_streamlines = nib.streamlines. \
array_sequence.ArraySequence(
[
s for s in roi_proximal_streamlines
if len(s) >= float(min_length)
]
)
print(f"Minimum fiber length >{min_length}mm: "
f"{len(roi_proximal_streamlines)}")
except BaseException:
print('No streamlines remaining after minimal length criterion.')
return None
if waymask is not None and os.path.isfile(waymask_tmp_path):
waymask_data = np.asarray(
nib.load(waymask_tmp_path).dataobj).astype("bool")
try:
roi_proximal_streamlines = roi_proximal_streamlines[utils.near_roi(
roi_proximal_streamlines,
np.eye(4),
waymask_data,
tol=int(round(roi_neighborhood_tol * 0.50, 1)),
mode="all")]
print("%s%s" %
("Waymask proximity: ", len(roi_proximal_streamlines)))
del waymask_data
except BaseException:
print('No streamlines remaining in waymask\'s vacinity.')
return None
hf.close()
del parcels, atlas_data
tmp_files = [tissues4d_tmp_path, waymask_tmp_path, recon_path_tmp_path]
for j in tmp_files:
if j is not None:
if os.path.isfile(j):
os.system(f"rm -f {j} &")
if len(roi_proximal_streamlines) > 0:
return ArraySequence(
[s.astype("float32") for s in roi_proximal_streamlines])
else:
return None
def track_ensemble(dwi_data,
target_samples,
atlas_data_wm_gm_int,
parcels,
mod_fit,
tiss_classifier,
sphere,
directget,
curv_thr_list,
step_list,
track_type,
maxcrossing,
max_length,
roi_neighborhood_tol,
min_length,
waymask,
n_seeds_per_iter=100,
pft_back_tracking_dist=2,
pft_front_tracking_dist=1,
particle_count=15):
"""
Perform native-space ensemble tractography, restricted to a vector of ROI masks.
dwi_data : array
4D array of dwi data.
target_samples : int
Total number of streamline samples specified to generate streams.
atlas_data_wm_gm_int : array
3D int32 numpy array of atlas parcellation intensities from Nifti1Image in T1w-warped native diffusion space,
restricted to wm-gm interface.
parcels : list
List of 3D boolean numpy arrays of atlas parcellation ROI masks from a Nifti1Image in T1w-warped native
diffusion space.
mod : obj
Connectivity reconstruction model.
tiss_classifier : str
Tissue classification method.
sphere : obj
DiPy object for modeling diffusion directions on a sphere.
directget : str
The statistical approach to tracking. Options are: det (deterministic), closest (clos), boot (bootstrapped),
and prob (probabilistic).
curv_thr_list : list
List of integer curvature thresholds used to perform ensemble tracking.
step_list : list
List of float step-sizes used to perform ensemble tracking.
track_type : str
Tracking algorithm used (e.g. 'local' or 'particle').
maxcrossing : int
Maximum number if diffusion directions that can be assumed per voxel while tracking.
max_length : int
Maximum fiber length threshold in mm to restrict tracking.
roi_neighborhood_tol : float
Distance (in the units of the streamlines, usually mm). If any
coordinate in the streamline is within this distance from the center
of any voxel in the ROI, the filtering criterion is set to True for
this streamline, otherwise False. Defaults to the distance between
the center of each voxel and the corner of the voxel.
min_length : int
Minimum fiber length threshold in mm.
waymask : str
Path to a Nifti1Image in native diffusion space to constrain tractography.
n_seeds_per_iter : int
Number of seeds from which to initiate tracking for each unique ensemble combination.
By default this is set to 200.
particle_count
pft_back_tracking_dist : float
Distance in mm to back track before starting the particle filtering
tractography. The total particle filtering tractography distance is
equal to back_tracking_dist + front_tracking_dist. By default this is set to 2 mm.
pft_front_tracking_dist : float
Distance in mm to run the particle filtering tractography after the
the back track distance. The total particle filtering tractography
distance is equal to back_tracking_dist + front_tracking_dist. By
default this is set to 1 mm.
particle_count : int
Number of particles to use in the particle filter.
Returns
-------
streamlines : ArraySequence
DiPy list/array-like object of streamline points from tractography.
"""
from colorama import Fore, Style
from dipy.tracking import utils
from dipy.tracking.streamline import Streamlines, select_by_rois
from dipy.tracking.local_tracking import LocalTracking, ParticleFilteringTracking
from dipy.direction import ProbabilisticDirectionGetter, BootDirectionGetter, ClosestPeakDirectionGetter, DeterministicMaximumDirectionGetter
if waymask:
waymask_data = nib.load(waymask).get_fdata().astype('bool')
# Commence Ensemble Tractography
parcel_vec = list(np.ones(len(parcels)).astype('bool'))
streamlines = nib.streamlines.array_sequence.ArraySequence()
ix = 0
circuit_ix = 0
stream_counter = 0
while int(stream_counter) < int(target_samples):
for curv_thr in curv_thr_list:
print("%s%s" % ('Curvature: ', curv_thr))
# Instantiate DirectionGetter
if directget == 'prob':
dg = ProbabilisticDirectionGetter.from_shcoeff(
mod_fit, max_angle=float(curv_thr), sphere=sphere)
elif directget == 'boot':
dg = BootDirectionGetter.from_data(dwi_data,
mod_fit,
max_angle=float(curv_thr),
sphere=sphere)
elif directget == 'clos':
dg = ClosestPeakDirectionGetter.from_shcoeff(
mod_fit, max_angle=float(curv_thr), sphere=sphere)
elif directget == 'det':
dg = DeterministicMaximumDirectionGetter.from_shcoeff(
mod_fit, max_angle=float(curv_thr), sphere=sphere)
else:
raise ValueError(
'ERROR: No valid direction getter(s) specified.')
for step in step_list:
print("%s%s" % ('Step: ', step))
# Perform wm-gm interface seeding, using n_seeds at a time
seeds = utils.random_seeds_from_mask(
atlas_data_wm_gm_int > 0,
seeds_count=n_seeds_per_iter,
seed_count_per_voxel=False,
affine=np.eye(4))
if len(seeds) == 0:
raise RuntimeWarning(
'Warning: No valid seed points found in wm-gm interface...'
)
print(seeds)
# Perform tracking
if track_type == 'local':
streamline_generator = LocalTracking(
dg,
tiss_classifier,
seeds,
np.eye(4),
max_cross=int(maxcrossing),
maxlen=int(max_length),
step_size=float(step),
return_all=True)
elif track_type == 'particle':
streamline_generator = ParticleFilteringTracking(
dg,
tiss_classifier,
seeds,
np.eye(4),
max_cross=int(maxcrossing),
step_size=float(step),
maxlen=int(max_length),
pft_back_tracking_dist=pft_back_tracking_dist,
pft_front_tracking_dist=pft_front_tracking_dist,
particle_count=particle_count,
return_all=True)
else:
raise ValueError(
'ERROR: No valid tracking method(s) specified.')
# Filter resulting streamlines by roi-intersection characteristics
roi_proximal_streamlines = Streamlines(
select_by_rois(streamline_generator,
affine=np.eye(4),
rois=parcels,
include=parcel_vec,
mode='any',
tol=roi_neighborhood_tol))
print("%s%s" %
('Qualifying Streamlines by node intersection: ',
len(roi_proximal_streamlines)))
roi_proximal_streamlines = nib.streamlines.array_sequence.ArraySequence(
[
s for s in roi_proximal_streamlines
if len(s) > float(min_length)
])
print("%s%s" %
('Qualifying Streamlines by minimum length criterion: ',
len(roi_proximal_streamlines)))
if waymask:
roi_proximal_streamlines = roi_proximal_streamlines[
utils.near_roi(roi_proximal_streamlines,
np.eye(4),
waymask_data,
tol=roi_neighborhood_tol,
mode='any')]
print("%s%s" %
('Qualifying Streamlines by waymask proximity: ',
len(roi_proximal_streamlines)))
# Repeat process until target samples condition is met
ix = ix + 1
for s in roi_proximal_streamlines:
stream_counter = stream_counter + len(s)
streamlines.append(s)
if int(stream_counter) >= int(target_samples):
break
else:
continue
# Cleanup memory
del seeds, roi_proximal_streamlines, streamline_generator
del dg
circuit_ix = circuit_ix + 1
print(
"%s%s%s%s%s" %
('Completed hyperparameter circuit: ', circuit_ix,
'...\nCumulative Streamline Count: ', Fore.CYAN, stream_counter))
print(Style.RESET_ALL)
print('\n')
return streamlines
def particle_tracking(self):
self.sphere = get_sphere("repulsion724")
if self.mod_type == "det":
maxcrossing = 1
print("Obtaining peaks from model...")
self.mod_peaks = peaks_from_model(
self.mod,
self.data,
self.sphere,
relative_peak_threshold=0.5,
min_separation_angle=25,
mask=self.wm_in_dwi_data,
npeaks=5,
normalize_peaks=True,
)
qa_tensor.create_qa_figure(self.mod_peaks.peak_dirs,
self.mod_peaks.peak_values,
self.qa_tensor_out, self.mod_func)
self.streamline_generator = ParticleFilteringTracking(
self.mod_peaks,
self.tiss_classifier,
self.seeds,
self.stream_affine,
max_cross=maxcrossing,
step_size=0.5,
maxlen=1000,
pft_back_tracking_dist=2,
pft_front_tracking_dist=1,
particle_count=15,
return_all=True,
)
elif self.mod_type == "prob":
maxcrossing = 2
print("Preparing probabilistic tracking...")
print("Fitting model to data...")
self.mod_fit = self.mod.fit(self.data, self.wm_in_dwi_data)
print("Building direction-getter...")
self.mod_peaks = peaks_from_model(
self.mod,
self.data,
self.sphere,
relative_peak_threshold=0.5,
min_separation_angle=25,
mask=self.wm_in_dwi_data,
npeaks=5,
normalize_peaks=True,
)
qa_tensor.create_qa_figure(self.mod_peaks.peak_dirs,
self.mod_peaks.peak_values,
self.qa_tensor_out, self.mod_func)
try:
print(
"Proceeding using spherical harmonic coefficient from model estimation..."
)
self.pdg = ProbabilisticDirectionGetter.from_shcoeff(
self.mod_fit.shm_coeff, max_angle=60.0, sphere=self.sphere)
except:
print("Proceeding using FOD PMF from model estimation...")
self.fod = self.mod_fit.odf(self.sphere)
self.pmf = self.fod.clip(min=0)
self.pdg = ProbabilisticDirectionGetter.from_pmf(
self.pmf, max_angle=60.0, sphere=self.sphere)
self.streamline_generator = ParticleFilteringTracking(
self.pdg,
self.tiss_classifier,
self.seeds,
self.stream_affine,
max_cross=maxcrossing,
step_size=0.5,
maxlen=1000,
pft_back_tracking_dist=2,
pft_front_tracking_dist=1,
particle_count=15,
return_all=True,
)
print("Reconstructing tractogram streamlines...")
self.streamlines = Streamlines(self.streamline_generator)
return self.streamlines
def track_ensemble(target_samples, atlas_data_wm_gm_int, parcels, mod_fit, tiss_classifier, sphere, directget,
curv_thr_list, step_list, track_type, maxcrossing, roi_neighborhood_tol, min_length, waymask,
B0_mask, max_length=1000, n_seeds_per_iter=500, pft_back_tracking_dist=2, pft_front_tracking_dist=1,
particle_count=15, min_separation_angle=20):
"""
Perform native-space ensemble tractography, restricted to a vector of ROI masks.
target_samples : int
Total number of streamline samples specified to generate streams.
atlas_data_wm_gm_int : array
3D int32 numpy array of atlas parcellation intensities from Nifti1Image in T1w-warped native diffusion space,
restricted to wm-gm interface.
parcels : list
List of 3D boolean numpy arrays of atlas parcellation ROI masks from a Nifti1Image in T1w-warped native
diffusion space.
mod : obj
Connectivity reconstruction model.
tiss_classifier : str
Tissue classification method.
sphere : obj
DiPy object for modeling diffusion directions on a sphere.
directget : str
The statistical approach to tracking. Options are: det (deterministic), closest (clos), boot (bootstrapped),
and prob (probabilistic).
curv_thr_list : list
List of integer curvature thresholds used to perform ensemble tracking.
step_list : list
List of float step-sizes used to perform ensemble tracking.
track_type : str
Tracking algorithm used (e.g. 'local' or 'particle').
maxcrossing : int
Maximum number if diffusion directions that can be assumed per voxel while tracking.
roi_neighborhood_tol : float
Distance (in the units of the streamlines, usually mm). If any
coordinate in the streamline is within this distance from the center
of any voxel in the ROI, the filtering criterion is set to True for
this streamline, otherwise False. Defaults to the distance between
the center of each voxel and the corner of the voxel.
min_length : int
Minimum fiber length threshold in mm.
waymask : str
Path to a Nifti1Image in native diffusion space to constrain tractography.
B0_mask : str
File path to B0 brain mask.
max_length : int
Maximum number of steps to restrict tracking.
n_seeds_per_iter : int
Number of seeds from which to initiate tracking for each unique ensemble combination.
By default this is set to 200.
particle_count
pft_back_tracking_dist : float
Distance in mm to back track before starting the particle filtering
tractography. The total particle filtering tractography distance is
equal to back_tracking_dist + front_tracking_dist. By default this is set to 2 mm.
pft_front_tracking_dist : float
Distance in mm to run the particle filtering tractography after the
the back track distance. The total particle filtering tractography
distance is equal to back_tracking_dist + front_tracking_dist. By
default this is set to 1 mm.
particle_count : int
Number of particles to use in the particle filter.
min_separation_angle : float
The minimum angle between directions [0, 90].
Returns
-------
streamlines : ArraySequence
DiPy list/array-like object of streamline points from tractography.
References
----------
.. [1] Takemura, H., Caiafa, C. F., Wandell, B. A., & Pestilli, F. (2016).
Ensemble Tractography. PLoS Computational Biology.
https://doi.org/10.1371/journal.pcbi.1004692
"""
import gc
import time
from colorama import Fore, Style
from dipy.tracking import utils
from dipy.tracking.streamline import Streamlines, select_by_rois
from dipy.tracking.local_tracking import LocalTracking, ParticleFilteringTracking
from dipy.direction import (ProbabilisticDirectionGetter, ClosestPeakDirectionGetter,
DeterministicMaximumDirectionGetter)
start = time.time()
B0_mask_data = nib.load(B0_mask).get_fdata()
if waymask:
waymask_data = np.asarray(nib.load(waymask).dataobj).astype('bool')
# Commence Ensemble Tractography
parcel_vec = list(np.ones(len(parcels)).astype('bool'))
streamlines = nib.streamlines.array_sequence.ArraySequence()
circuit_ix = 0
stream_counter = 0
while int(stream_counter) < int(target_samples):
for curv_thr in curv_thr_list:
print("%s%s" % ('Curvature: ', curv_thr))
# Instantiate DirectionGetter
if directget == 'prob':
dg = ProbabilisticDirectionGetter.from_shcoeff(mod_fit, max_angle=float(curv_thr), sphere=sphere,
min_separation_angle=min_separation_angle)
elif directget == 'clos':
dg = ClosestPeakDirectionGetter.from_shcoeff(mod_fit, max_angle=float(curv_thr), sphere=sphere,
min_separation_angle=min_separation_angle)
elif directget == 'det':
dg = DeterministicMaximumDirectionGetter.from_shcoeff(mod_fit, max_angle=float(curv_thr), sphere=sphere,
min_separation_angle=min_separation_angle)
else:
raise ValueError('ERROR: No valid direction getter(s) specified.')
for step in step_list:
print("%s%s" % ('Step: ', step))
# Perform wm-gm interface seeding, using n_seeds at a time
seeds = utils.random_seeds_from_mask(atlas_data_wm_gm_int > 0, seeds_count=n_seeds_per_iter,
seed_count_per_voxel=False, affine=np.eye(4))
if len(seeds) == 0:
raise RuntimeWarning('Warning: No valid seed points found in wm-gm interface...')
# print(seeds)
# Perform tracking
if track_type == 'local':
streamline_generator = LocalTracking(dg, tiss_classifier, seeds, np.eye(4),
max_cross=int(maxcrossing), maxlen=int(max_length),
step_size=float(step), fixedstep=False, return_all=True)
elif track_type == 'particle':
streamline_generator = ParticleFilteringTracking(dg, tiss_classifier, seeds, np.eye(4),
max_cross=int(maxcrossing),
step_size=float(step),
maxlen=int(max_length),
pft_back_tracking_dist=pft_back_tracking_dist,
pft_front_tracking_dist=pft_front_tracking_dist,
particle_count=particle_count,
return_all=True)
else:
raise ValueError('ERROR: No valid tracking method(s) specified.')
# Filter resulting streamlines by those that stay entirely inside the brain
roi_proximal_streamlines = utils.target(streamline_generator, np.eye(4), B0_mask_data,
include=True)
# Filter resulting streamlines by roi-intersection characteristics
roi_proximal_streamlines = Streamlines(select_by_rois(roi_proximal_streamlines, affine=np.eye(4),
rois=parcels, include=parcel_vec,
mode='both_end',
tol=roi_neighborhood_tol))
print("%s%s" % ('Filtering by: \nnode intersection: ', len(roi_proximal_streamlines)))
if str(min_length) != '0':
roi_proximal_streamlines = nib.streamlines.array_sequence.ArraySequence([s for s in
roi_proximal_streamlines
if len(s) >=
float(min_length)])
print("%s%s" % ('Minimum length criterion: ', len(roi_proximal_streamlines)))
if waymask:
roi_proximal_streamlines = roi_proximal_streamlines[utils.near_roi(roi_proximal_streamlines,
np.eye(4),
waymask_data,
tol=roi_neighborhood_tol,
mode='any')]
print("%s%s" % ('Waymask proximity: ', len(roi_proximal_streamlines)))
out_streams = [s.astype('float32') for s in roi_proximal_streamlines]
streamlines.extend(out_streams)
stream_counter = stream_counter + len(out_streams)
# Cleanup memory
del seeds, roi_proximal_streamlines, streamline_generator, out_streams
gc.collect()
del dg
circuit_ix = circuit_ix + 1
print("%s%s%s%s%s%s" % ('Completed Hyperparameter Circuit: ', circuit_ix,
'\nCumulative Streamline Count: ', Fore.CYAN, stream_counter, "\n"))
print(Style.RESET_ALL)
print('Tracking Complete:\n', str(time.time() - start))
return streamlines
def run_tracking(step_curv_combinations, recon_path, n_seeds_per_iter,
directget, maxcrossing, max_length, pft_back_tracking_dist,
pft_front_tracking_dist, particle_count, roi_neighborhood_tol,
waymask, min_length, track_type, min_separation_angle, sphere,
tiss_class, tissues4d, cache_dir):
import gc
import os
import h5py
from dipy.tracking import utils
from dipy.tracking.streamline import select_by_rois
from dipy.tracking.local_tracking import LocalTracking, \
ParticleFilteringTracking
from dipy.direction import (ProbabilisticDirectionGetter,
ClosestPeakDirectionGetter,
DeterministicMaximumDirectionGetter)
from nilearn.image import index_img
from pynets.dmri.track import prep_tissues
from nibabel.streamlines.array_sequence import ArraySequence
from nipype.utils.filemanip import copyfile, fname_presuffix
recon_path_tmp_path = fname_presuffix(recon_path,
suffix=f"_{step_curv_combinations}",
newpath=cache_dir)
copyfile(recon_path, recon_path_tmp_path, copy=True, use_hardlink=False)
if waymask is not None:
waymask_tmp_path = fname_presuffix(waymask,
suffix=f"_{step_curv_combinations}",
newpath=cache_dir)
copyfile(waymask, waymask_tmp_path, copy=True, use_hardlink=False)
else:
waymask_tmp_path = None
tissue_img = nib.load(tissues4d)
# Order:
B0_mask = index_img(tissue_img, 0)
atlas_img = index_img(tissue_img, 1)
atlas_data_wm_gm_int = index_img(tissue_img, 2)
t1w2dwi = index_img(tissue_img, 3)
gm_in_dwi = index_img(tissue_img, 4)
vent_csf_in_dwi = index_img(tissue_img, 5)
wm_in_dwi = index_img(tissue_img, 6)
tiss_classifier = prep_tissues(t1w2dwi, gm_in_dwi, vent_csf_in_dwi,
wm_in_dwi, tiss_class, B0_mask)
B0_mask_data = np.asarray(B0_mask.dataobj).astype("bool")
atlas_data = np.array(atlas_img.dataobj).astype("uint16")
atlas_data_wm_gm_int_data = np.asarray(
atlas_data_wm_gm_int.dataobj).astype("bool").astype("int16")
# Build mask vector from atlas for later roi filtering
parcels = []
i = 0
intensities = [i for i in np.unique(atlas_data) if i != 0]
for roi_val in intensities:
parcels.append(atlas_data == roi_val)
i += 1
del atlas_data
parcel_vec = list(np.ones(len(parcels)).astype("bool"))
with h5py.File(recon_path_tmp_path, 'r+') as hf:
mod_fit = hf['reconstruction'][:].astype('float32')
hf.close()
print("%s%s" % ("Curvature: ", step_curv_combinations[1]))
# Instantiate DirectionGetter
if directget == "prob" or directget == "probabilistic":
dg = ProbabilisticDirectionGetter.from_shcoeff(
mod_fit,
max_angle=float(step_curv_combinations[1]),
sphere=sphere,
min_separation_angle=min_separation_angle,
)
elif directget == "clos" or directget == "closest":
dg = ClosestPeakDirectionGetter.from_shcoeff(
mod_fit,
max_angle=float(step_curv_combinations[1]),
sphere=sphere,
min_separation_angle=min_separation_angle,
)
elif directget == "det" or directget == "deterministic":
maxcrossing = 1
dg = DeterministicMaximumDirectionGetter.from_shcoeff(
mod_fit,
max_angle=float(step_curv_combinations[1]),
sphere=sphere,
min_separation_angle=min_separation_angle,
)
else:
raise ValueError("ERROR: No valid direction getter(s) specified.")
print("%s%s" % ("Step: ", step_curv_combinations[0]))
# Perform wm-gm interface seeding, using n_seeds at a time
seeds = utils.random_seeds_from_mask(
atlas_data_wm_gm_int_data > 0,
seeds_count=n_seeds_per_iter,
seed_count_per_voxel=False,
affine=np.eye(4),
)
if len(seeds) == 0:
print(
UserWarning("No valid seed points found in wm-gm "
"interface..."))
return None
# print(seeds)
# Perform tracking
if track_type == "local":
streamline_generator = LocalTracking(
dg,
tiss_classifier,
seeds,
np.eye(4),
max_cross=int(maxcrossing),
maxlen=int(max_length),
step_size=float(step_curv_combinations[0]),
fixedstep=False,
return_all=True,
)
elif track_type == "particle":
streamline_generator = ParticleFilteringTracking(
dg,
tiss_classifier,
seeds,
np.eye(4),
max_cross=int(maxcrossing),
step_size=float(step_curv_combinations[0]),
maxlen=int(max_length),
pft_back_tracking_dist=pft_back_tracking_dist,
pft_front_tracking_dist=pft_front_tracking_dist,
particle_count=particle_count,
return_all=True,
)
else:
try:
raise ValueError("ERROR: No valid tracking method(s) specified.")
except ValueError:
import sys
sys.exit(0)
# Filter resulting streamlines by those that stay entirely
# inside the brain
try:
roi_proximal_streamlines = utils.target(streamline_generator,
np.eye(4),
B0_mask_data,
include=True)
except BaseException:
print('No streamlines found inside the brain! ' 'Check registrations.')
return None
# Filter resulting streamlines by roi-intersection
# characteristics
try:
roi_proximal_streamlines = \
nib.streamlines.array_sequence.ArraySequence(
select_by_rois(
roi_proximal_streamlines,
affine=np.eye(4),
rois=parcels,
include=parcel_vec,
mode="%s" % ("any" if waymask is not None else
"both_end"),
tol=roi_neighborhood_tol,
)
)
print("%s%s" % ("Filtering by: \nNode intersection: ",
len(roi_proximal_streamlines)))
except BaseException:
print('No streamlines found to connect any parcels! '
'Check registrations.')
return None
try:
roi_proximal_streamlines = nib.streamlines. \
array_sequence.ArraySequence(
[
s for s in roi_proximal_streamlines
if len(s) >= float(min_length)
]
)
print(f"Minimum fiber length >{min_length}mm: "
f"{len(roi_proximal_streamlines)}")
except BaseException:
print('No streamlines remaining after minimal length criterion.')
return None
if waymask is not None and os.path.isfile(waymask_tmp_path):
from nilearn.image import math_img
mask = math_img("img > 0.0075", img=nib.load(waymask_tmp_path))
waymask_data = np.asarray(mask.dataobj).astype("bool")
try:
roi_proximal_streamlines = roi_proximal_streamlines[utils.near_roi(
roi_proximal_streamlines,
np.eye(4),
waymask_data,
tol=roi_neighborhood_tol,
mode="all")]
print("%s%s" %
("Waymask proximity: ", len(roi_proximal_streamlines)))
except BaseException:
print('No streamlines remaining in waymask\'s vacinity.')
return None
out_streams = [s.astype("float32") for s in roi_proximal_streamlines]
del dg, seeds, roi_proximal_streamlines, streamline_generator, \
atlas_data_wm_gm_int_data, mod_fit, B0_mask_data
os.remove(recon_path_tmp_path)
gc.collect()
try:
return ArraySequence(out_streams)
except BaseException:
return None
