def bench_compress_streamlines():
repeat = 10
fname = get_fnames('fornix')
fornix = load_tractogram(fname, 'same', bbox_valid_check=False).streamlines
streamlines = Streamlines(fornix)
print("Timing compress_streamlines() in Cython"
" ({0} streamlines)".format(len(streamlines)))
cython_time = measure("compress_streamlines(streamlines)", repeat)
print("Cython time: {0:.3}sec".format(cython_time))
del streamlines
streamlines = Streamlines(fornix)
python_time = measure("map(compress_streamlines_python, streamlines)",
repeat)
print("Python time: {0:.2}sec".format(python_time))
print("Speed up of {0}x".format(python_time / cython_time))
del streamlines
def setup():
global DATA
rng = np.random.RandomState(42)
nb_streamlines = 20000
min_nb_points = 2
max_nb_points = 100
DATA['rng'] = rng
DATA['nb_streamlines'] = nb_streamlines
DATA['streamlines'] = generate_streamlines(nb_streamlines,
min_nb_points, max_nb_points,
rng=rng)
DATA['streamlines_arrseq'] = Streamlines(DATA['streamlines'])
def run(self,
streamline_files,
labels_files,
out_dir='',
out_bundle='recognized_orig.trk'):
""" Extract bundles using existing indices (labels)
Parameters
----------
streamline_files : string
The path of streamline files where you want to recognize bundles.
labels_files : string
The path of model bundle files.
out_dir : string, optional
Output directory. (default current directory)
out_bundle : string, optional
Recognized bundle in the space of the model bundle.
References
----------
.. [Garyfallidis17] Garyfallidis et al. Recognition of white matter
bundles using local and global streamline-based registration and
clustering, Neuroimage, 2017.
"""
logging.info('### Labels to Bundles ###')
io_it = self.get_io_iterator()
for f_steamlines, f_labels, out_bundle in io_it:
logging.info(f_steamlines)
sft = load_tractogram(f_steamlines, 'same', bbox_valid_check=False)
streamlines = sft.streamlines
logging.info(f_labels)
location = np.load(f_labels)
if len(location) < 1:
bundle = Streamlines([])
else:
bundle = streamlines[location]
logging.info('Saving output files ...')
new_sft = StatefulTractogram(bundle, sft, Space.RASMM)
save_tractogram(new_sft, out_bundle, bbox_valid_check=False)
logging.info(out_bundle)
def test_length():
# Test length of only one streamline
length_streamline_cython = length(streamline)
length_streamline_python = length_python(streamline)
assert_almost_equal(length_streamline_cython, length_streamline_python)
length_streamline_cython = length(streamline_64bit)
length_streamline_python = length_python(streamline_64bit)
assert_almost_equal(length_streamline_cython, length_streamline_python)
# Test computing length of multiple streamlines of different nb_points
length_streamlines_cython = length(streamlines)
for i, s in enumerate(streamlines):
length_streamline_python = length_python(s)
assert_array_almost_equal(length_streamlines_cython[i],
length_streamline_python)
length_streamlines_cython = length(streamlines_64bit)
for i, s in enumerate(streamlines_64bit):
length_streamline_python = length_python(s)
assert_array_almost_equal(length_streamlines_cython[i],
length_streamline_python)
# ArraySequence
# Test length of only one streamline
length_streamline_cython = length(streamline_64bit)
length_streamline_arrseq = length(Streamlines([streamline]))
assert_almost_equal(length_streamline_arrseq, length_streamline_cython)
length_streamline_cython = length(streamline_64bit)
length_streamline_arrseq = length(Streamlines([streamline_64bit]))
assert_almost_equal(length_streamline_arrseq, length_streamline_cython)
# Test computing length of multiple streamlines of different nb_points
length_streamlines_cython = length(streamlines)
length_streamlines_arrseq = length(Streamlines(streamlines))
assert_array_almost_equal(length_streamlines_arrseq,
length_streamlines_cython)
length_streamlines_cython = length(streamlines_64bit)
length_streamlines_arrseq = length(Streamlines(streamlines_64bit))
assert_array_almost_equal(length_streamlines_arrseq,
length_streamlines_cython)
# Test on a sliced ArraySequence
length_streamlines_cython = length(streamlines_64bit[::2])
length_streamlines_arrseq = length(Streamlines(streamlines_64bit)[::2])
assert_array_almost_equal(length_streamlines_arrseq,
length_streamlines_cython)
length_streamlines_cython = length(streamlines[::-1])
length_streamlines_arrseq = length(Streamlines(streamlines)[::-1])
assert_array_almost_equal(length_streamlines_arrseq,
length_streamlines_cython)
# Test streamlines having mixed dtype
streamlines_mixed_dtype = [
streamline,
streamline.astype(np.float64),
streamline.astype(np.int32),
streamline.astype(np.int64)
]
lengths_mixed_dtype = [length(s) for s in streamlines_mixed_dtype]
assert_array_equal(length(streamlines_mixed_dtype), lengths_mixed_dtype)
# Test streamlines with different shape
length_streamlines_cython = length(heterogeneous_streamlines)
for i, s in enumerate(heterogeneous_streamlines):
length_streamline_python = length_python(s)
assert_array_almost_equal(length_streamlines_cython[i],
length_streamline_python)
# Test streamline having integer dtype
length_streamline = length(streamline.astype('int'))
assert_true(length_streamline.dtype == np.float64)
# Test empty list
assert_equal(length([]), 0.0)
# Test streamline having only one point
assert_equal(length(np.array([[1, 2, 3]])), 0.0)
# We do not support list of lists, it should be numpy ndarray.
streamline_unsupported = [[1, 2, 3], [4, 5, 5], [2, 1, 3], [4, 2, 1]]
assert_raises(AttributeError, length, streamline_unsupported)
# Test setting computing length of a numpy with flag WRITABLE=False
streamlines_readonly = []
for s in streamlines:
streamlines_readonly.append(s.copy())
streamlines_readonly[-1].setflags(write=False)
assert_array_almost_equal(length(streamlines_readonly),
[length_python(s) for s in streamlines_readonly])
streamlines_readonly = []
for s in streamlines_64bit:
streamlines_readonly.append(s.copy())
streamlines_readonly[-1].setflags(write=False)
assert_array_almost_equal(length(streamlines_readonly),
[length_python(s) for s in streamlines_readonly])
def test_set_number_of_points():
# Test resampling of only one streamline
nb_points = 12
new_streamline_cython = set_number_of_points(streamline, nb_points)
new_streamline_python = set_number_of_points_python(streamline, nb_points)
assert_equal(len(new_streamline_cython), nb_points)
# Using a 5 digits precision because of streamline is in float32.
assert_array_almost_equal(new_streamline_cython, new_streamline_python, 5)
new_streamline_cython = set_number_of_points(streamline_64bit, nb_points)
new_streamline_python = set_number_of_points_python(
streamline_64bit, nb_points)
assert_equal(len(new_streamline_cython), nb_points)
assert_array_almost_equal(new_streamline_cython, new_streamline_python)
res = []
simple_streamline = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2]], 'f4')
for nb_points in range(2, 200):
new_streamline_cython = set_number_of_points(simple_streamline,
nb_points)
res.append(nb_points - len(new_streamline_cython))
assert_equal(np.sum(res), 0)
# Test resampling of multiple streamlines of different nb_points
nb_points = 12
new_streamlines_cython = set_number_of_points(streamlines, nb_points)
for i, s in enumerate(streamlines):
new_streamline_python = set_number_of_points_python(s, nb_points)
# Using a 5 digits precision because of streamline is in float32.
assert_array_almost_equal(new_streamlines_cython[i],
new_streamline_python, 5)
# ArraySequence
arrseq = Streamlines(streamlines)
new_streamlines_as_seq_cython = set_number_of_points(arrseq, nb_points)
assert_array_almost_equal(new_streamlines_as_seq_cython,
new_streamlines_cython)
new_streamlines_cython = set_number_of_points(streamlines_64bit, nb_points)
for i, s in enumerate(streamlines_64bit):
new_streamline_python = set_number_of_points_python(s, nb_points)
assert_array_almost_equal(new_streamlines_cython[i],
new_streamline_python)
# ArraySequence
arrseq = Streamlines(streamlines_64bit)
new_streamlines_as_seq_cython = set_number_of_points(arrseq, nb_points)
assert_array_almost_equal(new_streamlines_as_seq_cython,
new_streamlines_cython)
# Test streamlines with mixed dtype
streamlines_mixed_dtype = [
streamline,
streamline.astype(np.float64),
streamline.astype(np.int32),
streamline.astype(np.int64)
]
nb_points_mixed_dtype = [
len(s)
for s in set_number_of_points(streamlines_mixed_dtype, nb_points)
]
assert_array_equal(nb_points_mixed_dtype,
[nb_points] * len(streamlines_mixed_dtype))
# Test streamlines with different shape
new_streamlines_cython = set_number_of_points(heterogeneous_streamlines,
nb_points)
for i, s in enumerate(heterogeneous_streamlines):
new_streamline_python = set_number_of_points_python(s, nb_points)
assert_array_almost_equal(new_streamlines_cython[i],
new_streamline_python)
# Test streamline with integer dtype
new_streamline = set_number_of_points(streamline.astype(np.int32))
assert_true(new_streamline.dtype == np.float32)
new_streamline = set_number_of_points(streamline.astype(np.int64))
assert_true(new_streamline.dtype == np.float64)
# Test empty list
assert_equal(set_number_of_points([]), [])
# Test streamline having only one point
assert_raises(ValueError, set_number_of_points, np.array([[1, 2, 3]]))
# We do not support list of lists, it should be numpy ndarray.
streamline_unsupported = [[1, 2, 3], [4, 5, 5], [2, 1, 3], [4, 2, 1]]
assert_raises(AttributeError, set_number_of_points, streamline_unsupported)
# Test setting number of points of a numpy with flag WRITABLE=False
streamline_readonly = streamline.copy()
streamline_readonly.setflags(write=False)
assert_equal(len(set_number_of_points(streamline_readonly, nb_points=42)),
42)
# Test setting computing length of a numpy with flag WRITABLE=False
streamlines_readonly = []
for s in streamlines:
streamlines_readonly.append(s.copy())
streamlines_readonly[-1].setflags(write=False)
assert_equal(len(set_number_of_points(streamlines_readonly, nb_points=42)),
len(streamlines_readonly))
streamlines_readonly = []
for s in streamlines_64bit:
streamlines_readonly.append(s.copy())
streamlines_readonly[-1].setflags(write=False)
assert_equal(len(set_number_of_points(streamlines_readonly, nb_points=42)),
len(streamlines_readonly))
# Test if nb_points is less than 2
assert_raises(ValueError,
set_number_of_points, [np.ones(
(10, 3)), np.ones((10, 3))],
nb_points=1)