def test_cascade_of_optimizations_and_threading():
cingulum_bundles = two_cingulum_bundles()
cb1 = cingulum_bundles[0]
cb1 = set_number_of_points(cb1, 20)
test_x0 = np.array([10, 4, 3, 0, 20, 10, 1.5, 1.5, 1.5, 0., 0.2, 0])
cb2 = transform_streamlines(cingulum_bundles[0], compose_matrix44(test_x0))
cb2 = set_number_of_points(cb2, 20)
print('first rigid')
slr = StreamlineLinearRegistration(x0=6, num_threads=1)
slm = slr.optimize(cb1, cb2)
print('then similarity')
slr2 = StreamlineLinearRegistration(x0=7, num_threads=2)
slm2 = slr2.optimize(cb1, cb2, slm.matrix)
print('then affine')
slr3 = StreamlineLinearRegistration(x0=12,
options={'maxiter': 50},
num_threads=None)
slm3 = slr3.optimize(cb1, cb2, slm2.matrix)
assert_(slm2.fopt < slm.fopt)
assert_(slm3.fopt < slm2.fopt)
def test_rigid_real_bundles():
bundle_initial = fornix_streamlines()[:20]
bundle, shift = center_streamlines(bundle_initial)
mat = compose_matrix44([0, 0, 20, 45., 0, 0])
bundle2 = transform_streamlines(bundle, mat)
bundle_sum_distance = BundleSumDistanceMatrixMetric()
srr = StreamlineLinearRegistration(bundle_sum_distance,
x0=np.zeros(6),
method='Powell')
new_bundle2 = srr.optimize(bundle, bundle2).transform(bundle2)
evaluate_convergence(bundle, new_bundle2)
bundle_min_distance = BundleMinDistanceMatrixMetric()
srr = StreamlineLinearRegistration(bundle_min_distance,
x0=np.zeros(6),
method='Powell')
new_bundle2 = srr.optimize(bundle, bundle2).transform(bundle2)
evaluate_convergence(bundle, new_bundle2)
assert_raises(ValueError, StreamlineLinearRegistration, method='Whatever')
def _register_neighb_to_model(self, model_bundle, neighb_streamlines,
metric=None, x0=None, bounds=None,
select_model=400, select_target=600,
method='L-BFGS-B',
nb_pts=20, num_threads=None):
if self.verbose:
print('# Local SLR of neighb_streamlines to model')
t = time()
if metric is None or metric == 'symmetric':
metric = BundleMinDistanceMetric(num_threads=num_threads)
if metric == 'asymmetric':
metric = BundleMinDistanceAsymmetricMetric()
if metric == 'diagonal':
metric = BundleSumDistanceMatrixMetric()
if x0 is None:
x0 = 'similarity'
if bounds is None:
bounds = [(-30, 30), (-30, 30), (-30, 30),
(-45, 45), (-45, 45), (-45, 45), (0.8, 1.2)]
# TODO this can be speeded up by using directly the centroids
static = select_random_set_of_streamlines(model_bundle,
select_model, rng=self.rng)
moving = select_random_set_of_streamlines(neighb_streamlines,
select_target, rng=self.rng)
static = set_number_of_points(static, nb_pts)
moving = set_number_of_points(moving, nb_pts)
slr = StreamlineLinearRegistration(metric=metric, x0=x0,
bounds=bounds,
method=method)
slm = slr.optimize(static, moving)
transf_streamlines = neighb_streamlines.copy()
transf_streamlines._data = apply_affine(
slm.matrix, transf_streamlines._data)
transf_matrix = slm.matrix
slr_bmd = slm.fopt
slr_iterations = slm.iterations
if self.verbose:
print(' Square-root of BMD is %.3f' % (np.sqrt(slr_bmd),))
if slr_iterations is not None:
print(' Number of iterations %d' % (slr_iterations,))
print(' Matrix size {}'.format(slm.matrix.shape))
original = np.get_printoptions()
np.set_printoptions(3, suppress=True)
print(transf_matrix)
print(slm.xopt)
np.set_printoptions(**original)
print(' Duration %0.3f sec. \n' % (time() - t,))
return transf_streamlines, slr_bmd
def runslr(fixed, moving, npts=20):
fixed_subsamp = set_number_of_points(fixed, npts)
moving_subsamp = set_number_of_points(moving, npts)
srr = StreamlineLinearRegistration()
srm = srr.optimize(static=fixed_subsamp, moving=moving_subsamp)
aligned = srm.transform(moving)
return aligned
def runslr(fixed, moving, npts=20, bounds=None, verbose=False):
fixed_subsamp = set_number_of_points(fixed, npts)
moving_subsamp = set_number_of_points(moving, npts)
srr = StreamlineLinearRegistration(bounds=bounds, verbose=verbose)
#print(srr.verbose)
srm = srr.optimize(static=fixed_subsamp, moving=moving_subsamp)
aligned = srm.transform(moving)
return aligned
def test_affine_real_bundles():
bundle_initial = fornix_streamlines()
bundle_initial, shift = center_streamlines(bundle_initial)
bundle = bundle_initial[:20]
xgold = [0, 4, 2, 0, 10, 10, 1.2, 1.1, 1., 0., 0.2, 0.]
mat = compose_matrix44(xgold)
bundle2 = transform_streamlines(bundle_initial[:20], mat)
x0 = np.array([0, 0, 0, 0, 0, 0, 1., 1., 1., 0, 0, 0])
x = 25
bounds = [(-x, x), (-x, x), (-x, x),
(-x, x), (-x, x), (-x, x),
(0.1, 1.5), (0.1, 1.5), (0.1, 1.5),
(-1, 1), (-1, 1), (-1, 1)]
options = {'maxcor': 10, 'ftol': 1e-7, 'gtol': 1e-5, 'eps': 1e-8}
metric = BundleMinDistanceMatrixMetric()
slr = StreamlineLinearRegistration(metric=metric,
x0=x0,
method='L-BFGS-B',
bounds=bounds,
verbose=True,
options=options)
slm = slr.optimize(bundle, bundle2)
new_bundle2 = slm.transform(bundle2)
slr2 = StreamlineLinearRegistration(metric=metric,
x0=x0,
method='Powell',
bounds=None,
verbose=True,
options=None)
slm2 = slr2.optimize(bundle, new_bundle2)
new_bundle2 = slm2.transform(new_bundle2)
evaluate_convergence(bundle, new_bundle2)
def test_stream_rigid():
static = fornix_streamlines()[:20]
moving = fornix_streamlines()[20:40]
center_streamlines(static)
mat = compose_matrix44([0, 0, 0, 0, 40, 0])
moving = transform_streamlines(moving, mat)
srr = StreamlineLinearRegistration()
sr_params = srr.optimize(static, moving)
moved = transform_streamlines(moving, sr_params.matrix)
srr = StreamlineLinearRegistration(verbose=True)
srm = srr.optimize(static, moving)
moved2 = transform_streamlines(moving, srm.matrix)
moved3 = srm.transform(moving)
assert_array_almost_equal(moved[0], moved2[0], decimal=3)
assert_array_almost_equal(moved2[0], moved3[0], decimal=3)
def test_same_number_of_points():
A = [np.random.rand(10, 3), np.random.rand(20, 3)]
B = [np.random.rand(21, 3), np.random.rand(30, 3)]
C = [np.random.rand(10, 3), np.random.rand(10, 3)]
D = [np.random.rand(20, 3), np.random.rand(20, 3)]
slr = StreamlineLinearRegistration()
assert_raises(ValueError, slr.optimize, A, B)
assert_raises(ValueError, slr.optimize, C, D)
assert_raises(ValueError, slr.optimize, C, B)
def make_kesh_template(bundle_list,
keystone_boi,
qb_thresh=5.,
Nsubsamp=20,
clsz_thresh=5,
keystone2MNI_xfm=None,
verbose=False):
'''
bundle_list: list of independent bundles (lists) not assumed to be in the same space
keystone_boi: bundle (list) of streamlines that will be the anchor bundle all
others are registered to for the template
qb_thresh: threshold for quickbundle (determines how finely each bundle is clustered)
Nsubsamp: subsampling for quickbundles and SLR
clsz_thresh: how many streamlines a cluster must have to be included in the template*
keystone2MNI_SLR: streamlinear registration between the whole brain keystone and MNI**
verbose: if you want to print info about each bundle as it runs set this to True
*qb_thresh adn clsz_thresh are related. If you have a fine parcellation
(low qb_thresh) then the clsz_threshold should be quite low since clusters
will be small.
**PROVIDE THIS IF (and only if) YOU WANT THE RESULT TO BE IN MNI SPACE OTHERWISE
IT WILL BE IN KEYSTONE SPACE
'''
kesh_template_sls = []
rejected_sls = []
boi_sls_subsamp = set_number_of_points(keystone_boi, Nsubsamp)
for i, sls in enumerate(bundle_list):
print(len(bundle_list) - i)
sls_subsamp = set_number_of_points(sls, Nsubsamp)
qb = QuickBundles(threshold=qb_thresh)
clusters = qb.cluster(sls)
cluster_sizes = [len(cl) for cl in clusters]
# enforce that clusters smaller than a threshold are not in template
centroids = clusters.centroids
slr = StreamlineLinearRegistration()
srm = slr.optimize(static=boi_sls_subsamp, moving=sls_subsamp)
xfmd_centroids = srm.transform(centroids)
# NOTE: we actually want to upsample the centroids so the template has
# better properties... what's the most efficient way to do that?
for j, b in enumerate(xfmd_centroids):
if cluster_sizes[j] < clsz_thresh:
rejected_sls.append(xfmd_centroids.pop(j))
kesh_template_sls += xfmd_centroids
if verbose:
print('Bundle %i' % i)
print('N centroids: %i' % len(centroids))
print('kept %i rejected %i total %i' %
(len(kesh_template_sls), len(rejected_sls), len(clusters)))
if keystone2MNI_xfm:
print('MNI YAY!')
return kesh_template_sls, rejected_sls
def test_evolution_of_previous_iterations():
static = fornix_streamlines()[:20]
moving = fornix_streamlines()[:20]
moving = [m + np.array([10., 0., 0.]) for m in moving]
slr = StreamlineLinearRegistration(evolution=True)
slm = slr.optimize(static, moving)
assert_equal(len(slm.matrix_history), slm.iterations)
def tractograms_slr(moving_tractogram, static_tractogram):
subjID = ntpath.basename(static_tractogram)[0:6]
exID = ntpath.basename(moving_tractogram)[0:6]
aff_dir = '/N/dc2/projects/lifebid/giulia/data/HCP3-IU-Giulia/derivatives/slr_transformations'
affine_path = '%s/affine_m%s_s%s.npy' % (aff_dir, exID, subjID)
affine_fname = './affine_m%s_s%s.npy' % (exID, subjID)
if isfile(affine_path):
print("Affine already computed. Retrieving past results.")
copyfile(affine_path, affine_fname)
else:
print("Loading tractograms...")
moving_tractogram = nib.streamlines.load(moving_tractogram)
moving_tractogram = moving_tractogram.streamlines
static_tractogram = nib.streamlines.load(static_tractogram)
static_tractogram = static_tractogram.streamlines
print("Set parameters as in Garyfallidis et al. 2015.")
threshold_length = 40.0 # 50mm / 1.25
qb_threshold = 16.0 # 20mm / 1.25
nb_res_points = 20
print("Performing QuickBundles of static tractogram and resampling...")
st = np.array(
[s for s in static_tractogram if len(s) > threshold_length],
dtype=np.object)
qb = QuickBundles(threshold=qb_threshold)
st_clusters = [cluster.centroid for cluster in qb.cluster(st)]
st_clusters = set_number_of_points(st_clusters, nb_res_points)
print("Performing QuickBundles of moving tractogram and resampling...")
mt = np.array(
[s for s in moving_tractogram if len(s) > threshold_length],
dtype=np.object)
qb = QuickBundles(threshold=qb_threshold)
mt_clusters = [cluster.centroid for cluster in qb.cluster(mt)]
mt_clusters = set_number_of_points(mt_clusters, nb_res_points)
print("Performing Linear Registration...")
srr = StreamlineLinearRegistration()
srm = srr.optimize(static=st_clusters, moving=mt_clusters)
print(
"Affine transformation matrix with Streamline Linear Registration:"
)
affine = srm.matrix
print('%s' % affine)
np.save('affine_m%s_s%s.npy' % (exID, subjID), affine)
print("Affine for example %s and target %s saved." % (exID, subjID))
def test_x0_input():
for x0 in [6, 7, 12, "Rigid", 'rigid', "similarity", "Affine"]:
StreamlineLinearRegistration(x0=x0)
for x0 in [np.random.rand(6), np.random.rand(7), np.random.rand(12)]:
StreamlineLinearRegistration(x0=x0)
for x0 in [8, 20, "Whatever", np.random.rand(20), np.random.rand(20, 3)]:
assert_raises(ValueError, StreamlineLinearRegistration, x0=x0)
x0 = np.random.rand(4, 3)
assert_raises(ValueError, StreamlineLinearRegistration, x0=x0)
x0_6 = np.zeros(6)
x0_7 = np.array([0, 0, 0, 0, 0, 0, 1.])
x0_12 = np.array([0, 0, 0, 0, 0, 0, 1., 1., 1., 0, 0, 0])
x0_s = [x0_6, x0_7, x0_12, x0_6, x0_7, x0_12]
for i, x0 in enumerate([6, 7, 12, "Rigid", "similarity", "Affine"]):
slr = StreamlineLinearRegistration(x0=x0)
assert_equal(slr.x0, x0_s[i])
def _affine_slr(sft_bundle, sft_centroid):
x0 = np.zeros((7, ))
bounds_dof = [(-10, 10), (-10, 10), (-10, 10), (-5, 5), (-5, 5), (-5, 5),
(0.95, 1.05)]
metric = BundleMinDistanceMetric(num_threads=1)
slr = StreamlineLinearRegistration(metric=metric,
method="L-BFGS-B",
bounds=bounds_dof,
x0=x0,
num_threads=1)
tmp_bundle = set_number_of_points(sft_bundle.streamlines.copy(), 20)
tmp_centroid = set_number_of_points(sft_centroid.streamlines.copy(), 20)
slm = slr.optimize(tmp_bundle, tmp_centroid)
sft_centroid.streamlines = transform_streamlines(sft_centroid.streamlines,
slm.matrix)
return sft_centroid
def streamline_registration(moving,
static,
n_points=100,
native_resampled=False):
"""
Register two collections of streamlines ('bundles') to each other
Parameters
----------
moving, static : lists of 3 by n, or str
The two bundles to be registered. Given either as lists of arrays with
3D coordinates, or strings containing full paths to these files.
n_points : int, optional
How many points to resample to. Default: 100.
native_resampled : bool, optional
Whether to return the moving bundle in the original space, but
resampled in the static space to n_points.
Returns
-------
aligned : list
Streamlines from the moving group, moved to be closely matched to
the static group.
matrix : array (4, 4)
The affine transformation that takes us from 'moving' to 'static'
"""
# Load the streamlines, if you were given a file-name
if isinstance(moving, str):
moving = load_trk(moving, 'same', bbox_valid_check=False).streamlines
if isinstance(static, str):
static = load_trk(static, 'same', bbox_valid_check=False).streamlines
srr = StreamlineLinearRegistration()
srm = srr.optimize(static=set_number_of_points(static, n_points),
moving=set_number_of_points(moving, n_points))
aligned = srm.transform(moving)
if native_resampled:
aligned = set_number_of_points(aligned, n_points)
aligned = transform_tracking_output(aligned, np.linalg.inv(srm.matrix))
return aligned, srm.matrix
def test_rigid_parallel_lines():
bundle_initial = simulated_bundle()
bundle, shift = center_streamlines(bundle_initial)
mat = compose_matrix44([20, 0, 10, 0, 40, 0])
bundle2 = transform_streamlines(bundle, mat)
bundle_sum_distance = BundleSumDistanceMatrixMetric()
options = {'maxcor': 100, 'ftol': 1e-9, 'gtol': 1e-16, 'eps': 1e-3}
srr = StreamlineLinearRegistration(metric=bundle_sum_distance,
x0=np.zeros(6),
method='L-BFGS-B',
bounds=None,
options=options)
new_bundle2 = srr.optimize(bundle, bundle2).transform(bundle2)
evaluate_convergence(bundle, new_bundle2)
def test_rigid_partial_real_bundles():
static = fornix_streamlines()[:20]
moving = fornix_streamlines()[20:40]
static_center, shift = center_streamlines(static)
moving_center, shift2 = center_streamlines(moving)
print(shift2)
mat = compose_matrix(translate=np.array([0, 0, 0.]),
angles=np.deg2rad([40, 0, 0.]))
moved = transform_streamlines(moving_center, mat)
srr = StreamlineLinearRegistration()
srm = srr.optimize(static_center, moved)
print(srm.fopt)
print(srm.iterations)
print(srm.funcs)
moving_back = srm.transform(moved)
print(srm.matrix)
static_center = set_number_of_points(static_center, 100)
moving_center = set_number_of_points(moving_back, 100)
vol = np.zeros((100, 100, 100))
spts = np.concatenate(static_center, axis=0)
spts = np.round(spts).astype(np.int) + np.array([50, 50, 50])
mpts = np.concatenate(moving_center, axis=0)
mpts = np.round(mpts).astype(np.int) + np.array([50, 50, 50])
for index in spts:
i, j, k = index
vol[i, j, k] = 1
vol2 = np.zeros((100, 100, 100))
for index in mpts:
i, j, k = index
vol2[i, j, k] = 1
overlap = np.sum(np.logical_and(vol, vol2)) / float(np.sum(vol2))
assert_equal(overlap * 100 > 40, True)
def streamline_based_registration(source_tractography_streamlines,
target_tractography_streamlines,
subject_pair):
intersection_voxel_list = []
target_voxel_list = []
n_points = 20
srr = StreamlineLinearRegistration()
SAr = [downsample(i, n_points) for i in source_tractography]
SBr = [downsample(i, n_points) for i in target_tractography]
srm = srr.optimize(static=SBr, moving=SAr)
transformed_tractography = srm.transform(source_tractography)
print len(transformed_tractography)
temp_index = 0
for i in range(len(source_tractography_streamlines)):
voxel_and, voxel_target = voxel_measure(
transformed_tractography[
temp_index:temp_index + source_tractography_streamlines[
source + '_' + subject_tracts[str(subject_pair)][i]][1]],
target_tractography_streamlines[
target + '_' + subject_tracts[str(subject_pair)][i]][0])
temp_index = temp_index + source_tractography_streamlines[
source + '_' + subject_tracts[str(subject_pair)][i]][1]
intersection_voxel_list.append(voxel_and)
target_voxel_list.append(voxel_target)
total_intersection_voxel_list = np.sum(np.array(intersection_voxel_list))
total_target_voxel_list = np.sum(np.array(target_voxel_list))
print "Number of voxel per tract"
print intersection_voxel_list, target_voxel_list
print "Number of voxel"
print total_intersection_voxel_list, total_target_voxel_list
TDA_all_voxel_registration = np.divide(total_intersection_voxel_list,
total_target_voxel_list)
print "Modified-TDR-for-all"
print TDA_all_voxel_registration
def test_similarity_real_bundles():
bundle_initial = fornix_streamlines()
bundle_initial, shift = center_streamlines(bundle_initial)
bundle = bundle_initial[:20]
xgold = [0, 0, 10, 0, 0, 0, 1.5]
mat = compose_matrix44(xgold)
bundle2 = transform_streamlines(bundle_initial[:20], mat)
metric = BundleMinDistanceMatrixMetric()
x0 = np.array([0, 0, 0, 0, 0, 0, 1], 'f8')
slr = StreamlineLinearRegistration(metric=metric,
x0=x0,
method='Powell',
bounds=None,
verbose=False)
slm = slr.optimize(bundle, bundle2)
new_bundle2 = slm.transform(bundle2)
evaluate_convergence(bundle, new_bundle2)
def tractograms_slr(moving_tractogram, static_tractogram):
subjID = ntpath.basename(static_tractogram)[0:6]
exID = ntpath.basename(moving_tractogram)[0:6]
print("Loading tractograms...")
moving_tractogram = nib.streamlines.load(moving_tractogram)
moving_tractogram = moving_tractogram.streamlines
static_tractogram = nib.streamlines.load(static_tractogram)
static_tractogram = static_tractogram.streamlines
print("Set parameters as in Garyfallidis et al. 2015.")
threshold_length = 40.0 # 50mm / 1.25
qb_threshold = 16.0 # 20mm / 1.25
nb_res_points = 20
print("Performing QuickBundles of static tractogram and resampling...")
st = np.array([s for s in static_tractogram if len(s) > threshold_length],
dtype=np.object)
qb = QuickBundles(threshold=qb_threshold)
st_clusters = [cluster.centroid for cluster in qb.cluster(st)]
st_clusters = set_number_of_points(st_clusters, nb_res_points)
print("Performing QuickBundles of moving tractogram and resampling...")
mt = np.array([s for s in moving_tractogram if len(s) > threshold_length],
dtype=np.object)
qb = QuickBundles(threshold=qb_threshold)
mt_clusters = [cluster.centroid for cluster in qb.cluster(mt)]
mt_clusters = set_number_of_points(mt_clusters, nb_res_points)
print("Performing Linear Registration...")
srr = StreamlineLinearRegistration()
srm = srr.optimize(static=st_clusters, moving=mt_clusters)
print("Affine transformation matrix with Streamline Linear Registration:")
affine = srm.matrix
print('%s' % affine)
np.save('affine_m%s_s%s.npy' % (exID, subjID), affine)
print("Affine for example %s and target %s saved." % (exID, subjID))
def bundle_registration(cb_subj1, cb_subj2, pts=12):
"""
Register two bundle from two subjects
directly in the space of streamlines
Parameters
----------
cb_subj1: first subject's bundle
cb_subj2: second subject's bundle
pts: each streamline is divided into sections
Return
------
registration bundle
"""
cb_subj1 = set_number_of_points(cb_subj1, pts)
cb_subj2 = set_number_of_points(cb_subj2, pts)
srr = StreamlineLinearRegistration()
srm = srr.optimize(static=cb_subj1, moving=cb_subj2)
cb_subj2_aligned = srm.transform(cb_subj2)
return cb_subj2_aligned
def register(static, moving, points=20):
r""" Make StreamlineLinearRegistration simpler to use
Parameters:
----------
:param static: List of numpy.ndarray,
it is the target bundle witch will be static during registration
:param moving:List of numpy.ndarray,
it is the target bundle witch will be moving during registration
:param points: int,
The bundles will be divided to this number
:return: List of numpy.ndarray, numpy.array
It return the aligned subject and transformation matrix as well.
"""
cb_subj1 = set_number_of_points(static, points)
cb_subj2 = set_number_of_points(moving, points)
srr = StreamlineLinearRegistration()
srm = srr.optimize(static=cb_subj1, moving=cb_subj2)
del cb_subj1
del cb_subj2
del static
return srm.transform(moving) # , srm.matrix
#X_grid_size=header1['dimensions'][0]
#Y_grid_size=header1['dimensions'][1]
#Z_grid_size=header1['dimensions'][2]
#%% Resample Streamlines
print("setting the same number of points for both the tracts...")
track_moving = set_number_of_points(track_moving, N_points)
track_fixed = set_number_of_points(track_fixed, N_points)
#%% SLR
if SLR_flag:
print("Linear Registration of the tractcs using SLR...")
bounds = [(-np.inf, np.inf), (-np.inf, np.inf), (-np.inf, np.inf), (0, 0),
(0, 0), (0, 0)]
srr = StreamlineLinearRegistration(bounds=bounds)
srm = srr.optimize(static=track_fixed, moving=track_moving)
track_moving = srm.transform(track_moving)
if show_b is True:
show_both_bundles([track_moving, track_fixed],
colors=[window.colors.orange, window.colors.red],
show=True,
fname=save_dir + 'after_registration.png')
track_moving = np.array(track_moving)
track_fixed = np.array(track_fixed)
#%% Sparse
suffix_list = []
col_ind_list = []
if sparse_flag:
def tractograms_slr(moving_tractogram, static_tractogram):
table_filename = 'affine_dictionary.pickle'
if isfile(table_filename):
print("Retrieving past results from %s" % table_filename)
table = pickle.load(open(table_filename))
else:
print("Creating a new table which will be saved in %s" %
table_filename)
table = {}
moving_tractogram_basename = ntpath.basename(moving_tractogram)
static_tractogram_basename = ntpath.basename(static_tractogram)
key = tuple([(moving_tractogram_basename, static_tractogram_basename)])[0]
if table.has_key(key):
print("Affine already exists in %s" % table_filename)
affine = table[moving_tractogram_basename,
static_tractogram_basename].items()[0][1]
else:
print("Loading tractograms...")
moving_tractogram = nib.streamlines.load(moving_tractogram)
moving_tractogram = moving_tractogram.streamlines
static_tractogram = nib.streamlines.load(static_tractogram)
static_tractogram = static_tractogram.streamlines
print("Set parameters as in Garyfallidis et al. 2015.")
threshold_length = 40.0 # 50mm / 1.25
qb_threshold = 16.0 # 20mm / 1.25
nb_res_points = 20
print("Performing QuickBundles of static tractogram and resampling...")
st = np.array(
[s for s in static_tractogram if len(s) > threshold_length],
dtype=np.object)
qb = QuickBundles(threshold=qb_threshold)
st_clusters = [cluster.centroid for cluster in qb.cluster(st)]
st_clusters = set_number_of_points(st_clusters, nb_res_points)
print("Performing QuickBundles of moving tractogram and resampling...")
mt = np.array(
[s for s in moving_tractogram if len(s) > threshold_length],
dtype=np.object)
qb = QuickBundles(threshold=qb_threshold)
mt_clusters = [cluster.centroid for cluster in qb.cluster(mt)]
mt_clusters = set_number_of_points(mt_clusters, nb_res_points)
print("Performing Linear Registration...")
srr = StreamlineLinearRegistration()
srm = srr.optimize(static=st_clusters, moving=mt_clusters)
print(
"Affine transformation matrix with Streamline Linear Registration:"
)
affine = srm.matrix
print('%s' % affine)
print("Fill the dictionary.")
table[moving_tractogram_basename, static_tractogram_basename] = {
'affine': affine
}
pickle.dump(table,
open(table_filename, 'w'),
protocol=pickle.HIGHEST_PROTOCOL)
return affine
def test_wrong_num_threads():
A = [np.random.rand(10, 3), np.random.rand(10, 3)]
B = [np.random.rand(10, 3), np.random.rand(10, 3)]
slr = StreamlineLinearRegistration(num_threads=0)
assert_raises(ValueError, slr.optimize, A, B)
def _register_model_to_neighb(self,
slr_num_thread=1,
select_model=1000,
select_target=1000,
slr_transform_type='scaling'):
"""
Parameters
----------
slr_num_thread : int
Number of threads for SLR.
Should remain 1 for nearly all use-case.
select_model : int
Maximum number of clusters to select from the model.
select_target : int
Maximum number of clusters to select from the neighborhood.
slr_transform_type : str
Define the transformation for the local SLR.
[translation, rigid, similarity, scaling].
Returns
-------
transf_neighbor : list
The neighborhood clusters transformed into model space.
"""
possible_slr_transform_type = {
'translation': 0,
'rigid': 1,
'similarity': 2,
'scaling': 3
}
static = select_random_set_of_streamlines(self.model_centroids,
select_model, self.rng)
moving = select_random_set_of_streamlines(self.neighb_centroids,
select_target, self.rng)
# Tuple 0,1,2 are the min & max bound in x,y,z for translation
# Tuple 3,4,5 are the min & max bound in x,y,z for rotation
# Tuple 6,7,8 are the min & max bound in x,y,z for scaling
# For uniform scaling (similarity), tuple #6 is enough
bounds_dof = [(-20, 20), (-20, 20), (-20, 20), (-10, 10), (-10, 10),
(-10, 10), (0.8, 1.2), (0.8, 1.2), (0.8, 1.2)]
metric = BundleMinDistanceMetric(num_threads=slr_num_thread)
slr_transform_type_id = possible_slr_transform_type[slr_transform_type]
if slr_transform_type_id >= 0:
init_transfo_dof = np.zeros(3)
slr = StreamlineLinearRegistration(metric=metric,
method="Powell",
x0=init_transfo_dof,
bounds=bounds_dof[:3],
num_threads=slr_num_thread)
slm = slr.optimize(static, moving)
if slr_transform_type_id >= 1:
init_transfo_dof = np.zeros(6)
init_transfo_dof[:3] = slm.xopt
slr = StreamlineLinearRegistration(metric=metric,
x0=init_transfo_dof,
bounds=bounds_dof[:6],
num_threads=slr_num_thread)
slm = slr.optimize(static, moving)
if slr_transform_type_id >= 2:
if slr_transform_type_id == 2:
init_transfo_dof = np.zeros(7)
init_transfo_dof[:6] = slm.xopt
init_transfo_dof[6] = 1.
slr = StreamlineLinearRegistration(metric=metric,
x0=init_transfo_dof,
bounds=bounds_dof[:7],
num_threads=slr_num_thread)
slm = slr.optimize(static, moving)
else:
init_transfo_dof = np.zeros(9)
init_transfo_dof[:6] = slm.xopt[:6]
init_transfo_dof[6:] = np.array((slm.xopt[6], ) * 3)
slr = StreamlineLinearRegistration(metric=metric,
x0=init_transfo_dof,
bounds=bounds_dof[:9],
num_threads=slr_num_thread)
slm = slr.optimize(static, moving)
self.model_centroids = transform_streamlines(self.model_centroids,
np.linalg.inv(slm.matrix))
#attach fa information
native_target_streamlines = transform_streamlines(
target_streamlines, np.linalg.inv(affine_fa))
stream_fa = []
stream_point_fa = []
for s in range(len(native_target_streamlines)):
point_fa = [
fa[int(k[0]), int(k[1]), int(k[2])]
for k in native_target_streamlines[s]
]
stream_point_fa.append(point_fa)
stream_fa.append(np.mean(point_fa))
#registration
srr = StreamlineLinearRegistration()
srm = srr.optimize(static=target_clusters_control.centroids,
moving=target_clusters.centroids)
target_str_aligned = srm.transform(target_streamlines)
native_target_stream_aligned = transform_streamlines(
target_str_aligned, np.linalg.inv(affine_fa))
locals()['groupstreamlines' + str(k + 1)].extend(target_str_aligned)
locals()['Nativegroupstreamlines' +
str(k + 1)].extend(native_target_stream_aligned)
locals()['groupLinesFA' + str(k + 1)].extend(stream_fa)
locals()['groupPointsFA' + str(k + 1)].extend(stream_point_fa)
print('NO.' + str(j + 1) + ' ' + runno + " Nb. streamlines:",
len(target_str_aligned))
