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_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): 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_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_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)