def test_tractogram_apply_affine(self):
tractogram = DATA["tractogram"].copy()
affine = np.eye(4)
scaling = np.array((1, 2, 3), dtype=float)
affine[range(3), range(3)] = scaling
# Apply the affine to the streamline in a lazy manner.
transformed_tractogram = tractogram.apply_affine(affine, lazy=True)
assert_true(type(transformed_tractogram) is LazyTractogram)
check_tractogram(
transformed_tractogram,
streamlines=[s * scaling for s in DATA["streamlines"]],
data_per_streamline=DATA["data_per_streamline"],
data_per_point=DATA["data_per_point"],
)
assert_array_equal(transformed_tractogram.affine_to_rasmm, np.dot(np.eye(4), np.linalg.inv(affine)))
# Make sure streamlines of the original tractogram have not been
# modified.
assert_arrays_equal(tractogram.streamlines, DATA["streamlines"])
# Apply the affine to the streamlines in-place.
transformed_tractogram = tractogram.apply_affine(affine)
assert_true(transformed_tractogram is tractogram)
check_tractogram(
tractogram,
streamlines=[s * scaling for s in DATA["streamlines"]],
data_per_streamline=DATA["data_per_streamline"],
data_per_point=DATA["data_per_point"],
)
# Apply affine again and check the affine_to_rasmm.
transformed_tractogram = tractogram.apply_affine(affine)
assert_array_equal(
transformed_tractogram.affine_to_rasmm,
np.dot(np.eye(4), np.dot(np.linalg.inv(affine), np.linalg.inv(affine))),
)
# Check that applying an affine and its inverse give us back the
# original streamlines.
tractogram = DATA["tractogram"].copy()
affine = np.random.RandomState(1234).randn(4, 4)
affine[-1] = [0, 0, 0, 1] # Remove perspective projection.
tractogram.apply_affine(affine)
tractogram.apply_affine(np.linalg.inv(affine))
assert_array_almost_equal(tractogram.affine_to_rasmm, np.eye(4))
for s1, s2 in zip(tractogram.streamlines, DATA["streamlines"]):
assert_array_almost_equal(s1, s2)
# Test applying the identity transformation.
tractogram = DATA["tractogram"].copy()
tractogram.apply_affine(np.eye(4))
for s1, s2 in zip(tractogram.streamlines, DATA["streamlines"]):
assert_array_almost_equal(s1, s2)
# Test removing affine_to_rasmm
tractogram = DATA["tractogram"].copy()
tractogram.affine_to_rasmm = None
tractogram.apply_affine(affine)
assert_true(tractogram.affine_to_rasmm is None)
def test_arraysequence_iter(self):
assert_arrays_equal(SEQ_DATA['seq'], SEQ_DATA['data'])
# Try iterating through a corrupted ArraySequence object.
seq = SEQ_DATA['seq'].copy()
seq._lengths = seq._lengths[::2]
assert_raises(ValueError, list, seq)
def test_arraysequence_iter(self):
assert_arrays_equal(SEQ_DATA['seq'], SEQ_DATA['data'])
# Try iterating through a corrupted ArraySequence object.
seq = SEQ_DATA['seq'].copy()
seq._lengths = seq._lengths[::2]
assert_raises(ValueError, list, seq)
def test_tractogram_apply_affine(self):
tractogram = DATA['tractogram'].copy()
affine = np.eye(4)
scaling = np.array((1, 2, 3), dtype=float)
affine[range(3), range(3)] = scaling
# Apply the affine to the streamline in a lazy manner.
transformed_tractogram = tractogram.apply_affine(affine, lazy=True)
assert_true(type(transformed_tractogram) is LazyTractogram)
check_tractogram(
transformed_tractogram,
streamlines=[s * scaling for s in DATA['streamlines']],
data_per_streamline=DATA['data_per_streamline'],
data_per_point=DATA['data_per_point'])
assert_array_equal(transformed_tractogram.affine_to_rasmm,
np.dot(np.eye(4), np.linalg.inv(affine)))
# Make sure streamlines of the original tractogram have not been
# modified.
assert_arrays_equal(tractogram.streamlines, DATA['streamlines'])
# Apply the affine to the streamlines in-place.
transformed_tractogram = tractogram.apply_affine(affine)
assert_true(transformed_tractogram is tractogram)
check_tractogram(
tractogram,
streamlines=[s * scaling for s in DATA['streamlines']],
data_per_streamline=DATA['data_per_streamline'],
data_per_point=DATA['data_per_point'])
# Apply affine again and check the affine_to_rasmm.
transformed_tractogram = tractogram.apply_affine(affine)
assert_array_equal(
transformed_tractogram.affine_to_rasmm,
np.dot(np.eye(4),
np.dot(np.linalg.inv(affine), np.linalg.inv(affine))))
# Check that applying an affine and its inverse give us back the
# original streamlines.
tractogram = DATA['tractogram'].copy()
affine = np.random.RandomState(1234).randn(4, 4)
affine[-1] = [0, 0, 0, 1] # Remove perspective projection.
tractogram.apply_affine(affine)
tractogram.apply_affine(np.linalg.inv(affine))
assert_array_almost_equal(tractogram.affine_to_rasmm, np.eye(4))
for s1, s2 in zip(tractogram.streamlines, DATA['streamlines']):
assert_array_almost_equal(s1, s2)
# Test applying the identity transformation.
tractogram = DATA['tractogram'].copy()
tractogram.apply_affine(np.eye(4))
for s1, s2 in zip(tractogram.streamlines, DATA['streamlines']):
assert_array_almost_equal(s1, s2)
# Test removing affine_to_rasmm
tractogram = DATA['tractogram'].copy()
tractogram.affine_to_rasmm = None
tractogram.apply_affine(affine)
assert_true(tractogram.affine_to_rasmm is None)
def check_tractogram_item(tractogram_item, streamline, data_for_streamline={}, data_for_points={}):
assert_array_equal(tractogram_item.streamline, streamline)
assert_equal(len(tractogram_item.data_for_streamline), len(data_for_streamline))
for key in data_for_streamline.keys():
assert_array_equal(tractogram_item.data_for_streamline[key], data_for_streamline[key])
assert_equal(len(tractogram_item.data_for_points), len(data_for_points))
for key in data_for_points.keys():
assert_arrays_equal(tractogram_item.data_for_points[key], data_for_points[key])
def test_getitem(self):
sdict = PerArrayDict(len(DATA["tractogram"]), DATA["data_per_streamline"])
assert_raises(KeyError, sdict.__getitem__, "invalid")
# Test slicing and advanced indexing.
for k, v in DATA["tractogram"].data_per_streamline.items():
assert_true(k in sdict)
assert_arrays_equal(sdict[k], v)
assert_arrays_equal(sdict[::2][k], v[::2])
assert_arrays_equal(sdict[::-1][k], v[::-1])
assert_arrays_equal(sdict[-1][k], v[-1])
assert_arrays_equal(sdict[[0, -1]][k], v[[0, -1]])
def test_getitem(self):
total_nb_rows = DATA['tractogram'].streamlines.total_nb_rows
sdict = PerArraySequenceDict(total_nb_rows, DATA['data_per_point'])
assert_raises(KeyError, sdict.__getitem__, 'invalid')
# Test slicing and advanced indexing.
for k, v in DATA['tractogram'].data_per_point.items():
assert_true(k in sdict)
assert_arrays_equal(sdict[k], v)
assert_arrays_equal(sdict[::2][k], v[::2])
assert_arrays_equal(sdict[::-1][k], v[::-1])
assert_arrays_equal(sdict[-1][k], v[-1])
assert_arrays_equal(sdict[[0, -1]][k], v[[0, -1]])
def test_getitem(self):
total_nb_rows = DATA['tractogram'].streamlines.total_nb_rows
sdict = PerArraySequenceDict(total_nb_rows, DATA['data_per_point'])
assert_raises(KeyError, sdict.__getitem__, 'invalid')
# Test slicing and advanced indexing.
for k, v in DATA['tractogram'].data_per_point.items():
assert_true(k in sdict)
assert_arrays_equal(sdict[k], v)
assert_arrays_equal(sdict[::2][k], v[::2])
assert_arrays_equal(sdict[::-1][k], v[::-1])
assert_arrays_equal(sdict[-1][k], v[-1])
assert_arrays_equal(sdict[[0, -1]][k], v[[0, -1]])
def test_getitem(self):
sdict = PerArrayDict(len(DATA['tractogram']),
DATA['data_per_streamline'])
assert_raises(KeyError, sdict.__getitem__, 'invalid')
# Test slicing and advanced indexing.
for k, v in DATA['tractogram'].data_per_streamline.items():
assert_true(k in sdict)
assert_arrays_equal(sdict[k], v)
assert_arrays_equal(sdict[::2][k], v[::2])
assert_arrays_equal(sdict[::-1][k], v[::-1])
assert_arrays_equal(sdict[-1][k], v[-1])
assert_arrays_equal(sdict[[0, -1]][k], v[[0, -1]])
def check_tractogram_item(tractogram_item,
streamline,
data_for_streamline={},
data_for_points={}):
assert_array_equal(tractogram_item.streamline, streamline)
assert_equal(len(tractogram_item.data_for_streamline),
len(data_for_streamline))
for key in data_for_streamline.keys():
assert_array_equal(tractogram_item.data_for_streamline[key],
data_for_streamline[key])
assert_equal(len(tractogram_item.data_for_points), len(data_for_points))
for key in data_for_points.keys():
assert_arrays_equal(tractogram_item.data_for_points[key],
data_for_points[key])
def check_arr_seq(seq, arrays):
lengths = list(map(len, arrays))
assert_true(is_array_sequence(seq))
assert_equal(len(seq), len(arrays))
assert_equal(len(seq._offsets), len(arrays))
assert_equal(len(seq._lengths), len(arrays))
assert_equal(seq._data.shape[1:], arrays[0].shape[1:])
assert_equal(seq.common_shape, arrays[0].shape[1:])
assert_arrays_equal(seq, arrays)
# If seq is a view, then order of internal data is not guaranteed.
if seq._is_view:
# The only thing we can check is the _lengths.
assert_array_equal(sorted(seq._lengths), sorted(lengths))
else:
seq.shrink_data()
assert_equal(seq._data.shape[0], sum(lengths))
assert_array_equal(seq._data, np.concatenate(arrays, axis=0))
assert_array_equal(seq._offsets, np.r_[0, np.cumsum(lengths)[:-1]])
assert_array_equal(seq._lengths, lengths)
def check_arr_seq(seq, arrays):
lengths = list(map(len, arrays))
assert_true(is_array_sequence(seq))
assert_equal(len(seq), len(arrays))
assert_equal(len(seq._offsets), len(arrays))
assert_equal(len(seq._lengths), len(arrays))
assert_equal(seq._data.shape[1:], arrays[0].shape[1:])
assert_equal(seq.common_shape, arrays[0].shape[1:])
assert_arrays_equal(seq, arrays)
# If seq is a view, then order of internal data is not guaranteed.
if seq._is_view:
# The only thing we can check is the _lengths.
assert_array_equal(sorted(seq._lengths), sorted(lengths))
else:
seq.shrink_data()
assert_equal(seq._data.shape[0], sum(lengths))
assert_array_equal(seq._data, np.concatenate(arrays, axis=0))
assert_array_equal(seq._offsets, np.r_[0, np.cumsum(lengths)[:-1]])
assert_array_equal(seq._lengths, lengths)
def test_per_array_sequence_dict_creation(self):
# Create a PerArraySequenceDict object using another
# PerArraySequenceDict object.
total_nb_rows = DATA['tractogram'].streamlines.total_nb_rows
data_per_point = DATA['tractogram'].data_per_point
data_dict = PerArraySequenceDict(total_nb_rows, data_per_point)
assert_equal(data_dict.keys(), data_per_point.keys())
for k in data_dict.keys():
assert_arrays_equal(data_dict[k], data_per_point[k])
del data_dict['fa']
assert_equal(len(data_dict),
len(data_per_point)-1)
# Create a PerArraySequenceDict object using an existing dict object.
data_per_point = DATA['data_per_point']
data_dict = PerArraySequenceDict(total_nb_rows, data_per_point)
assert_equal(data_dict.keys(), data_per_point.keys())
for k in data_dict.keys():
assert_arrays_equal(data_dict[k], data_per_point[k])
del data_dict['fa']
assert_equal(len(data_dict), len(data_per_point)-1)
# Create a PerArraySequenceDict object using keyword arguments.
data_per_point = DATA['data_per_point']
data_dict = PerArraySequenceDict(total_nb_rows, **data_per_point)
assert_equal(data_dict.keys(), data_per_point.keys())
for k in data_dict.keys():
assert_arrays_equal(data_dict[k], data_per_point[k])
del data_dict['fa']
assert_equal(len(data_dict), len(data_per_point)-1)
def test_per_array_sequence_dict_creation(self):
# Create a PerArraySequenceDict object using another
# PerArraySequenceDict object.
total_nb_rows = DATA['tractogram'].streamlines.total_nb_rows
data_per_point = DATA['tractogram'].data_per_point
data_dict = PerArraySequenceDict(total_nb_rows, data_per_point)
assert_equal(data_dict.keys(), data_per_point.keys())
for k in data_dict.keys():
assert_arrays_equal(data_dict[k], data_per_point[k])
del data_dict['fa']
assert_equal(len(data_dict),
len(data_per_point)-1)
# Create a PerArraySequenceDict object using an existing dict object.
data_per_point = DATA['data_per_point']
data_dict = PerArraySequenceDict(total_nb_rows, data_per_point)
assert_equal(data_dict.keys(), data_per_point.keys())
for k in data_dict.keys():
assert_arrays_equal(data_dict[k], data_per_point[k])
del data_dict['fa']
assert_equal(len(data_dict), len(data_per_point)-1)
# Create a PerArraySequenceDict object using keyword arguments.
data_per_point = DATA['data_per_point']
data_dict = PerArraySequenceDict(total_nb_rows, **data_per_point)
assert_equal(data_dict.keys(), data_per_point.keys())
for k in data_dict.keys():
assert_arrays_equal(data_dict[k], data_per_point[k])
del data_dict['fa']
assert_equal(len(data_dict), len(data_per_point)-1)
def test_extend(self):
total_nb_rows = DATA['tractogram'].streamlines.total_nb_rows
sdict = PerArraySequenceDict(total_nb_rows, DATA['data_per_point'])
# Test compatible PerArraySequenceDicts.
list_nb_points = [2, 7, 4]
data_per_point_shapes = {"colors": DATA['colors'][0].shape[1:],
"fa": DATA['fa'][0].shape[1:]}
_, new_data, _ = make_fake_tractogram(list_nb_points,
data_per_point_shapes,
rng=DATA['rng'])
sdict2 = PerArraySequenceDict(np.sum(list_nb_points), new_data)
sdict.extend(sdict2)
assert_equal(len(sdict), len(sdict2))
for k in DATA['tractogram'].data_per_point:
assert_arrays_equal(sdict[k][:len(DATA['tractogram'])],
DATA['tractogram'].data_per_point[k])
assert_arrays_equal(sdict[k][len(DATA['tractogram']):],
new_data[k])
# Extending with an empty PerArraySequenceDicts should change nothing.
sdict_orig = copy.deepcopy(sdict)
sdict.extend(PerArraySequenceDict())
for k in sdict_orig.keys():
assert_arrays_equal(sdict[k], sdict_orig[k])
# Test incompatible PerArraySequenceDicts.
# Other dict has more entries.
data_per_point_shapes = {"colors": DATA['colors'][0].shape[1:],
"fa": DATA['fa'][0].shape[1:],
"other": (7,)}
_, new_data, _ = make_fake_tractogram(list_nb_points,
data_per_point_shapes,
rng=DATA['rng'])
sdict2 = PerArraySequenceDict(np.sum(list_nb_points), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
# Other dict has not the same entries (key mistmached).
data_per_point_shapes = {"colors": DATA['colors'][0].shape[1:],
"other": DATA['fa'][0].shape[1:]}
_, new_data, _ = make_fake_tractogram(list_nb_points,
data_per_point_shapes,
rng=DATA['rng'])
sdict2 = PerArraySequenceDict(np.sum(list_nb_points), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
# Other dict has the right number of entries but wrong shape.
data_per_point_shapes = {"colors": DATA['colors'][0].shape[1:],
"fa": DATA['fa'][0].shape[1:] + (3,)}
_, new_data, _ = make_fake_tractogram(list_nb_points,
data_per_point_shapes,
rng=DATA['rng'])
sdict2 = PerArraySequenceDict(np.sum(list_nb_points), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
def test_extend(self):
total_nb_rows = DATA['tractogram'].streamlines.total_nb_rows
sdict = PerArraySequenceDict(total_nb_rows, DATA['data_per_point'])
# Test compatible PerArraySequenceDicts.
list_nb_points = [2, 7, 4]
data_per_point_shapes = {"colors": DATA['colors'][0].shape[1:],
"fa": DATA['fa'][0].shape[1:]}
_, new_data, _ = make_fake_tractogram(list_nb_points,
data_per_point_shapes,
rng=DATA['rng'])
sdict2 = PerArraySequenceDict(np.sum(list_nb_points), new_data)
sdict.extend(sdict2)
assert_equal(len(sdict), len(sdict2))
for k in DATA['tractogram'].data_per_point:
assert_arrays_equal(sdict[k][:len(DATA['tractogram'])],
DATA['tractogram'].data_per_point[k])
assert_arrays_equal(sdict[k][len(DATA['tractogram']):],
new_data[k])
# Extending with an empty PerArraySequenceDicts should change nothing.
sdict_orig = copy.deepcopy(sdict)
sdict.extend(PerArraySequenceDict())
for k in sdict_orig.keys():
assert_arrays_equal(sdict[k], sdict_orig[k])
# Test incompatible PerArraySequenceDicts.
# Other dict has more entries.
data_per_point_shapes = {"colors": DATA['colors'][0].shape[1:],
"fa": DATA['fa'][0].shape[1:],
"other": (7,)}
_, new_data, _ = make_fake_tractogram(list_nb_points,
data_per_point_shapes,
rng=DATA['rng'])
sdict2 = PerArraySequenceDict(np.sum(list_nb_points), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
# Other dict has not the same entries (key mistmached).
data_per_point_shapes = {"colors": DATA['colors'][0].shape[1:],
"other": DATA['fa'][0].shape[1:]}
_, new_data, _ = make_fake_tractogram(list_nb_points,
data_per_point_shapes,
rng=DATA['rng'])
sdict2 = PerArraySequenceDict(np.sum(list_nb_points), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
# Other dict has the right number of entries but wrong shape.
data_per_point_shapes = {"colors": DATA['colors'][0].shape[1:],
"fa": DATA['fa'][0].shape[1:] + (3,)}
_, new_data, _ = make_fake_tractogram(list_nb_points,
data_per_point_shapes,
rng=DATA['rng'])
sdict2 = PerArraySequenceDict(np.sum(list_nb_points), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
def test_extend(self):
sdict = PerArrayDict(len(DATA['tractogram']),
DATA['data_per_streamline'])
new_data = {
'mean_curvature': 2 * np.array(DATA['mean_curvature']),
'mean_torsion': 3 * np.array(DATA['mean_torsion']),
'mean_colors': 4 * np.array(DATA['mean_colors'])
}
sdict2 = PerArrayDict(len(DATA['tractogram']), new_data)
sdict.extend(sdict2)
assert_equal(len(sdict), len(sdict2))
for k in DATA['tractogram'].data_per_streamline:
assert_arrays_equal(sdict[k][:len(DATA['tractogram'])],
DATA['tractogram'].data_per_streamline[k])
assert_arrays_equal(sdict[k][len(DATA['tractogram']):],
new_data[k])
# Extending with an empty PerArrayDict should change nothing.
sdict_orig = copy.deepcopy(sdict)
sdict.extend(PerArrayDict())
for k in sdict_orig.keys():
assert_arrays_equal(sdict[k], sdict_orig[k])
# Test incompatible PerArrayDicts.
# Other dict has more entries.
new_data = {
'mean_curvature': 2 * np.array(DATA['mean_curvature']),
'mean_torsion': 3 * np.array(DATA['mean_torsion']),
'mean_colors': 4 * np.array(DATA['mean_colors']),
'other': 5 * np.array(DATA['mean_colors'])
}
sdict2 = PerArrayDict(len(DATA['tractogram']), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
# Other dict has not the same entries (key mistmached).
new_data = {
'mean_curvature': 2 * np.array(DATA['mean_curvature']),
'mean_torsion': 3 * np.array(DATA['mean_torsion']),
'other': 4 * np.array(DATA['mean_colors'])
}
sdict2 = PerArrayDict(len(DATA['tractogram']), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
# Other dict has the right number of entries but wrong shape.
new_data = {
'mean_curvature': 2 * np.array(DATA['mean_curvature']),
'mean_torsion': 3 * np.array(DATA['mean_torsion']),
'mean_colors': 4 * np.array(DATA['mean_torsion'])
}
sdict2 = PerArrayDict(len(DATA['tractogram']), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
def check_tractogram(tractogram, streamlines=[], data_per_streamline={}, data_per_point={}):
streamlines = list(streamlines)
assert_equal(len(tractogram), len(streamlines))
assert_arrays_equal(tractogram.streamlines, streamlines)
[t for t in tractogram] # Force iteration through tractogram.
assert_equal(len(tractogram.data_per_streamline), len(data_per_streamline))
for key in data_per_streamline.keys():
assert_arrays_equal(tractogram.data_per_streamline[key], data_per_streamline[key])
assert_equal(len(tractogram.data_per_point), len(data_per_point))
for key in data_per_point.keys():
assert_arrays_equal(tractogram.data_per_point[key], data_per_point[key])
def test_extend(self):
sdict = PerArrayDict(len(DATA['tractogram']),
DATA['data_per_streamline'])
new_data = {'mean_curvature': 2 * np.array(DATA['mean_curvature']),
'mean_torsion': 3 * np.array(DATA['mean_torsion']),
'mean_colors': 4 * np.array(DATA['mean_colors'])}
sdict2 = PerArrayDict(len(DATA['tractogram']),
new_data)
sdict.extend(sdict2)
assert_equal(len(sdict), len(sdict2))
for k in DATA['tractogram'].data_per_streamline:
assert_arrays_equal(sdict[k][:len(DATA['tractogram'])],
DATA['tractogram'].data_per_streamline[k])
assert_arrays_equal(sdict[k][len(DATA['tractogram']):],
new_data[k])
# Extending with an empty PerArrayDict should change nothing.
sdict_orig = copy.deepcopy(sdict)
sdict.extend(PerArrayDict())
for k in sdict_orig.keys():
assert_arrays_equal(sdict[k], sdict_orig[k])
# Test incompatible PerArrayDicts.
# Other dict has more entries.
new_data = {'mean_curvature': 2 * np.array(DATA['mean_curvature']),
'mean_torsion': 3 * np.array(DATA['mean_torsion']),
'mean_colors': 4 * np.array(DATA['mean_colors']),
'other': 5 * np.array(DATA['mean_colors'])}
sdict2 = PerArrayDict(len(DATA['tractogram']), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
# Other dict has not the same entries (key mistmached).
new_data = {'mean_curvature': 2 * np.array(DATA['mean_curvature']),
'mean_torsion': 3 * np.array(DATA['mean_torsion']),
'other': 4 * np.array(DATA['mean_colors'])}
sdict2 = PerArrayDict(len(DATA['tractogram']), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
# Other dict has the right number of entries but wrong shape.
new_data = {'mean_curvature': 2 * np.array(DATA['mean_curvature']),
'mean_torsion': 3 * np.array(DATA['mean_torsion']),
'mean_colors': 4 * np.array(DATA['mean_torsion'])}
sdict2 = PerArrayDict(len(DATA['tractogram']), new_data)
assert_raises(ValueError, sdict.extend, sdict2)
def check_tractogram(tractogram,
streamlines=[],
data_per_streamline={},
data_per_point={}):
streamlines = list(streamlines)
assert_equal(len(tractogram), len(streamlines))
assert_arrays_equal(tractogram.streamlines, streamlines)
[t for t in tractogram] # Force iteration through tractogram.
assert_equal(len(tractogram.data_per_streamline), len(data_per_streamline))
for key in data_per_streamline.keys():
assert_arrays_equal(tractogram.data_per_streamline[key],
data_per_streamline[key])
assert_equal(len(tractogram.data_per_point), len(data_per_point))
for key in data_per_point.keys():
assert_arrays_equal(tractogram.data_per_point[key],
data_per_point[key])
