def test_resampling_error_checks():
shape = (3, 2, 5, 2)
target_shape = (5, 3, 2)
affine = np.eye(4)
data = np.random.randint(0, 10, shape)
img = Nifti1Image(data, affine)
# Correct parameters: no exception
resample_img(img, target_shape=target_shape, target_affine=affine)
resample_img(img, target_affine=affine)
with testing.write_tmp_imgs(img) as filename:
resample_img(filename, target_shape=target_shape, target_affine=affine)
# Missing parameter
assert_raises(ValueError, resample_img, img, target_shape=target_shape)
# Invalid shape
assert_raises(ValueError,
resample_img,
img,
target_shape=(2, 3),
target_affine=affine)
# Invalid interpolation
interpolation = 'an_invalid_interpolation'
pattern = "interpolation must be either.+{0}".format(interpolation)
testing.assert_raises_regexp(ValueError,
pattern,
resample_img,
img,
target_shape=target_shape,
target_affine=affine,
interpolation="an_invalid_interpolation")
# Noop
target_shape = shape[:3]
img_r = resample_img(img, copy=False)
assert_equal(img_r, img)
img_r = resample_img(img, copy=True)
assert_false(np.may_share_memory(img_r.get_data(), img.get_data()))
np.testing.assert_almost_equal(img_r.get_data(), img.get_data())
np.testing.assert_almost_equal(img_r.get_affine(), img.get_affine())
img_r = resample_img(img,
target_affine=affine,
target_shape=target_shape,
copy=False)
assert_equal(img_r, img)
img_r = resample_img(img,
target_affine=affine,
target_shape=target_shape,
copy=True)
assert_false(np.may_share_memory(img_r.get_data(), img.get_data()))
np.testing.assert_almost_equal(img_r.get_data(), img.get_data())
np.testing.assert_almost_equal(img_r.get_affine(), img.get_affine())
def test_index_img():
img_3d = nibabel.Nifti1Image(np.ones((3, 4, 5)), np.eye(4))
testing.assert_raises_regexp(TypeError, 'Niimg-like object',
image.index_img, img_3d, 0)
affine = np.array([[1., 2., 3., 4.],
[5., 6., 7., 8.],
[9., 10., 11., 12.],
[0., 0., 0., 1.]])
img_4d, _ = testing.generate_fake_fmri(affine=affine)
fourth_dim_size = niimg_conversions._get_shape(img_4d)[3]
tested_indices = (range(fourth_dim_size) +
[slice(2, 8, 2), [1, 2, 3, 2], [],
(np.arange(fourth_dim_size) % 3) == 1])
for i in tested_indices:
this_img = image.index_img(img_4d, i)
expected_data_3d = img_4d.get_data()[..., i]
assert_array_equal(this_img.get_data(),
expected_data_3d)
assert_array_equal(this_img.get_affine(),
img_4d.get_affine())
for i in [fourth_dim_size, - fourth_dim_size - 1,
[0, fourth_dim_size],
np.repeat(True, fourth_dim_size + 1)]:
testing.assert_raises_regexp(
IndexError,
'out of bounds|invalid index|out of range',
image.index_img, img_4d, i)
def test_check_niimg():
# check error for non-forced but necessary resampling
assert_raises_regexp(TypeError, 'image',
_utils.check_niimg, 0)
# check error for non-forced but necessary resampling
assert_raises_regexp(TypeError, 'image',
_utils.check_niimg, [])
# Test ensure_3d
# check error for non-forced but necessary resampling
assert_raises_regexp(TypeError, '3D',
_utils.check_niimg, ['test.nii', ], ensure_3d=True)
# Check that a filename does not raise an error
data = np.zeros((40, 40, 40, 2))
data[20, 20, 20] = 1
data_img = Nifti1Image(data, np.eye(4))
with testing.write_tmp_imgs(data_img, create_files=True) as filename:
_utils.check_niimg(filename)
# Test ensure_3d with a in-memory object
assert_raises_regexp(TypeError, '3D',
_utils.check_niimg, data, ensure_3d=True)
# Test ensure_3d with a non 3D image
assert_raises_regexp(TypeError, '3D',
_utils.check_niimg, data_img, ensure_3d=True)
# Test ensure_3d with a 4D image with a length 1 4th dim
data = np.zeros((40, 40, 40, 1))
data_img = Nifti1Image(data, np.eye(4))
_utils.check_niimg(data_img, ensure_3d=True)
def test_fail_fetch_harvard_oxford():
# specify non-existing atlas item
assert_raises_regexp(ValueError, 'Invalid atlas name',
datasets.fetch_harvard_oxford, 'not_inside')
# specify existing atlas item
target_atlas = 'cort-maxprob-thr0-1mm'
target_atlas_fname = 'HarvardOxford-' + target_atlas + '.nii.gz'
HO_dir = os.path.join(tmpdir, 'harvard_oxford')
os.mkdir(HO_dir)
nifti_dir = os.path.join(HO_dir, 'HarvardOxford')
os.mkdir(nifti_dir)
target_atlas_nii = os.path.join(nifti_dir, target_atlas_fname)
datasets.load_mni152_template().to_filename(target_atlas_nii)
dummy = open(os.path.join(HO_dir, 'HarvardOxford-Cortical.xml'), 'w')
dummy.write("<?xml version='1.0' encoding='us-ascii'?> "
"<metadata>"
"</metadata>")
dummy.close()
out_nii, arr = datasets.fetch_harvard_oxford(target_atlas, data_dir=tmpdir)
assert_true(isinstance(nibabel.load(out_nii), nibabel.Nifti1Image))
assert_true(isinstance(arr, np.ndarray))
def test_filter_and_mask():
data = np.zeros([20, 30, 40, 5])
mask = np.zeros([20, 30, 40, 2])
mask[10, 15, 20, :] = 1
assert_raises_regexp(TypeError, "A 3D image is expected", filter_and_mask,
data, mask, {})
def test_concat_niimgs():
# create images different in affine and 3D/4D shape
shape = (10, 11, 12)
affine = np.eye(4)
img1 = Nifti1Image(np.ones(shape), affine)
img2 = Nifti1Image(np.ones(shape), 2 * affine)
img3 = Nifti1Image(np.zeros(shape), affine)
img4d = Nifti1Image(np.ones(shape + (2, )), affine)
shape2 = (12, 11, 10)
img1b = Nifti1Image(np.ones(shape2), affine)
shape3 = (11, 22, 33)
img1c = Nifti1Image(np.ones(shape2), affine)
# check basic concatenation with equal shape/affine
concatenated = _utils.concat_niimgs((img1, img3, img1),
accept_4d=False)
concatenate_true = np.ones(shape + (3,))
# Smoke-test the accept_4d
assert_raises_regexp(ValueError, 'image',
_utils.concat_niimgs, [img1, img4d])
concatenated = _utils.concat_niimgs([img1, img4d], accept_4d=True)
np.testing.assert_equal(concatenated.get_data(), concatenate_true,
verbose=0)
# smoke-test auto_resample
concatenated = _utils.concat_niimgs((img1, img1b, img1c), accept_4d=False,
auto_resample=True)
assert_true(concatenated.shape == img1.shape + (3, ))
# check error for non-forced but necessary resampling
assert_raises_regexp(ValueError, 'different from reference affine',
_utils.concat_niimgs, [img1, img2],
accept_4d=False)
# Smoke-test the 4d parsing
concatenated = _utils.concat_niimgs([img1, img4d], accept_4d=True)
assert_equal(concatenated.shape[3], 3)
# test list of 4D niimgs as input
_, tmpimg1 = tempfile.mkstemp(suffix='.nii')
_, tmpimg2 = tempfile.mkstemp(suffix='.nii')
try:
nibabel.save(img1, tmpimg1)
nibabel.save(img3, tmpimg2)
concatenated = _utils.concat_niimgs([tmpimg1, tmpimg2],
accept_4d=False)
assert_array_equal(
concatenated.get_data()[..., 0], img1.get_data())
assert_array_equal(
concatenated.get_data()[..., 1], img3.get_data())
finally:
_remove_if_exists(tmpimg1)
_remove_if_exists(tmpimg2)
def test_concat_niimgs():
# create images different in affine and 3D/4D shape
shape = (10, 11, 12)
affine = np.eye(4)
img1 = Nifti1Image(np.ones(shape), affine)
img2 = Nifti1Image(np.ones(shape), 2 * affine)
img3 = Nifti1Image(np.zeros(shape), affine)
img4d = Nifti1Image(np.ones(shape + (2, )), affine)
shape2 = (12, 11, 10)
img1b = Nifti1Image(np.ones(shape2), affine)
shape3 = (11, 22, 33)
img1c = Nifti1Image(np.ones(shape2), affine)
# check basic concatenation with equal shape/affine
concatenated = _utils.concat_niimgs((img1, img3, img1), accept_4d=False)
concatenate_true = np.ones(shape + (3, ))
# Smoke-test the accept_4d
assert_raises_regexp(ValueError, 'image', _utils.concat_niimgs,
[img1, img4d])
concatenated = _utils.concat_niimgs([img1, img4d], accept_4d=True)
np.testing.assert_equal(concatenated.get_data(),
concatenate_true,
verbose=0)
# smoke-test auto_resample
concatenated = _utils.concat_niimgs((img1, img1b, img1c),
accept_4d=False,
auto_resample=True)
assert_true(concatenated.shape == img1.shape + (3, ))
# check error for non-forced but necessary resampling
assert_raises_regexp(ValueError,
'different from reference affine',
_utils.concat_niimgs, [img1, img2],
accept_4d=False)
# Smoke-test the 4d parsing
concatenated = _utils.concat_niimgs([img1, img4d], accept_4d=True)
assert_equal(concatenated.shape[3], 3)
# test list of 4D niimgs as input
_, tmpimg1 = tempfile.mkstemp(suffix='.nii')
_, tmpimg2 = tempfile.mkstemp(suffix='.nii')
try:
nibabel.save(img1, tmpimg1)
nibabel.save(img3, tmpimg2)
concatenated = _utils.concat_niimgs([tmpimg1, tmpimg2],
accept_4d=False)
assert_array_equal(concatenated.get_data()[..., 0], img1.get_data())
assert_array_equal(concatenated.get_data()[..., 1], img3.get_data())
finally:
_remove_if_exists(tmpimg1)
_remove_if_exists(tmpimg2)
def test_raises_upon_3x3_affine_and_no_shape():
img = Nifti1Image(np.zeros([8, 9, 10]), affine=np.eye(4))
exception = ValueError
message = ("Given target shape without anchor "
"vector: Affine shape should be \(4, 4\) and "
"not \(3, 3\)")
testing.assert_raises_regexp(exception,
message,
resample_img,
img,
target_affine=np.eye(3) * 2,
target_shape=(10, 10, 10))
def test_get_dataset_dir():
# testing folder creation under different environments, enforcing
# a custom clean install
os.environ.pop('NILEARN_DATA', None)
os.environ.pop('NILEARN_SHARED_DATA', None)
expected_base_dir = os.path.expanduser('~/nilearn_data')
data_dir = datasets._get_dataset_dir('test', verbose=0)
assert_equal(data_dir, os.path.join(expected_base_dir, 'test'))
assert os.path.exists(data_dir)
shutil.rmtree(data_dir)
expected_base_dir = os.path.join(tmpdir, 'test_nilearn_data')
os.environ['NILEARN_DATA'] = expected_base_dir
data_dir = datasets._get_dataset_dir('test', verbose=0)
assert_equal(data_dir, os.path.join(expected_base_dir, 'test'))
assert os.path.exists(data_dir)
shutil.rmtree(data_dir)
expected_base_dir = os.path.join(tmpdir, 'nilearn_shared_data')
os.environ['NILEARN_SHARED_DATA'] = expected_base_dir
data_dir = datasets._get_dataset_dir('test', verbose=0)
assert_equal(data_dir, os.path.join(expected_base_dir, 'test'))
assert os.path.exists(data_dir)
shutil.rmtree(data_dir)
# Verify exception is raised on read-only directories
no_write = os.path.join(tmpdir, 'no_write')
os.makedirs(no_write)
os.chmod(no_write, 0400)
assert_raises_regexp(OSError,
'Permission denied',
datasets._get_dataset_dir,
'test',
no_write,
verbose=0)
# Verify exception for a path which exists and is a file
test_file = os.path.join(tmpdir, 'some_file')
with open(test_file, 'w') as out:
out.write('abcfeg')
assert_raises_regexp(OSError,
'Not a directory',
datasets._get_dataset_dir,
'test',
test_file,
verbose=0)
def test_3d_images():
# Test that the MultiNiftiMasker works with 3D images
mask_img = Nifti1Image(np.ones((2, 2, 2), dtype=np.int8),
affine=np.diag((4, 4, 4, 1)))
epi_img1 = Nifti1Image(np.ones((2, 2, 2)),
affine=np.diag((4, 4, 4, 1)))
epi_img2 = Nifti1Image(np.ones((2, 2, 2)),
affine=np.diag((2, 2, 2, 1)))
masker = MultiNiftiMasker(mask_img=mask_img)
epis = masker.fit_transform([epi_img1, epi_img2])
# This is mostly a smoke test
assert_equal(len(epis), 2)
# verify that 4D mask arguments are refused
mask_img_4d = Nifti1Image(np.ones((2, 2, 2, 2), dtype=np.int8),
affine=np.diag((4, 4, 4, 1)))
masker2 = MultiNiftiMasker(mask_img=mask_img_4d)
testing.assert_raises_regexp(TypeError, "A 3D image is expected",
masker2.fit)
def test_check_niimg():
# check error for non-forced but necessary resampling
assert_raises_regexp(TypeError, 'image', _utils.check_niimg, 0)
# check error for non-forced but necessary resampling
assert_raises_regexp(TypeError, 'image', _utils.check_niimg, [])
# Test ensure_3d
# check error for non-forced but necessary resampling
assert_raises_regexp(TypeError,
'3D',
_utils.check_niimg, [
'test.nii',
],
ensure_3d=True)
# Check that a filename does not raise an error
data = np.zeros((40, 40, 40, 2))
data[20, 20, 20] = 1
data_img = Nifti1Image(data, np.eye(4))
with testing.write_tmp_imgs(data_img, create_files=True) as filename:
_utils.check_niimg(filename)
# Test ensure_3d with a in-memory object
assert_raises_regexp(TypeError,
'3D',
_utils.check_niimg,
data,
ensure_3d=True)
# Test ensure_3d with a non 3D image
assert_raises_regexp(TypeError,
'3D',
_utils.check_niimg,
data_img,
ensure_3d=True)
# Test ensure_3d with a 4D image with a length 1 4th dim
data = np.zeros((40, 40, 40, 1))
data_img = Nifti1Image(data, np.eye(4))
_utils.check_niimg(data_img, ensure_3d=True)
def test_iter_img():
img_3d = nibabel.Nifti1Image(np.ones((3, 4, 5)), np.eye(4))
testing.assert_raises_regexp(TypeError, 'Niimg-like object',
image.iter_img, img_3d)
affine = np.array([[1., 2., 3., 4.],
[5., 6., 7., 8.],
[9., 10., 11., 12.],
[0., 0., 0., 1.]])
img_4d, _ = testing.generate_fake_fmri(affine=affine)
for i, img in enumerate(image.iter_img(img_4d)):
expected_data_3d = img_4d.get_data()[..., i]
assert_array_equal(img.get_data(),
expected_data_3d)
assert_array_equal(img.get_affine(),
img_4d.get_affine())
with testing.write_tmp_imgs(img_4d) as img_4d_filename:
for i, img in enumerate(image.iter_img(img_4d_filename)):
expected_data_3d = img_4d.get_data()[..., i]
assert_array_equal(img.get_data(),
expected_data_3d)
assert_array_equal(img.get_affine(),
img_4d.get_affine())
img_3d_list = list(image.iter_img(img_4d))
for i, img in enumerate(image.iter_img(img_3d_list)):
expected_data_3d = img_4d.get_data()[..., i]
assert_array_equal(img.get_data(),
expected_data_3d)
assert_array_equal(img.get_affine(),
img_4d.get_affine())
with testing.write_tmp_imgs(*img_3d_list) as img_3d_filenames:
for i, img in enumerate(image.iter_img(img_3d_filenames)):
expected_data_3d = img_4d.get_data()[..., i]
assert_array_equal(img.get_data(),
expected_data_3d)
assert_array_equal(img.get_affine(),
img_4d.get_affine())
def test_raises_bbox_error_if_data_outside_box():
# Make some cases which should raise exceptions
# original image
data = np.zeros([8, 9, 10])
affine = np.eye(4)
affine_offset = np.array([1, 1, 1])
affine[:3, 3] = affine_offset
img = Nifti1Image(data, affine)
# some axis flipping affines
axis_flips = np.array(
map(np.diag, [[-1, 1, 1, 1], [1, -1, 1, 1], [1, 1, -1, 1],
[-1, -1, 1, 1], [-1, 1, -1, 1], [1, -1, -1, 1]]))
# some in plane 90 degree rotations base on these
# (by permuting two lines)
af = axis_flips
rotations = np.array([
af[0][[1, 0, 2, 3]], af[0][[2, 1, 0, 3]], af[1][[1, 0, 2, 3]],
af[1][[0, 2, 1, 3]], af[2][[2, 1, 0, 3]], af[2][[0, 2, 1, 3]]
])
new_affines = np.concatenate([axis_flips, rotations])
new_offset = np.array([0., 0., 0.])
new_affines[:, :3, 3] = new_offset[np.newaxis, :]
for new_affine in new_affines:
exception = BoundingBoxError
message = ("The field of view given "
"by the target affine does "
"not contain any of the data")
testing.assert_raises_regexp(exception,
message,
resample_img,
img,
target_affine=new_affine)
def test_check_niimgs():
assert_raises_regexp(TypeError, 'image',
_utils.check_niimgs, 0)
assert_raises_regexp(TypeError, 'image',
_utils.check_niimgs, [])
affine = np.eye(4)
img_3d = Nifti1Image(np.ones((10, 10, 10)), affine)
# Tests with return_iterator=False
img_4d_1 = _utils.check_niimgs([img_3d, img_3d])
assert_true(img_4d_1.get_data().shape == (10, 10, 10, 2))
assert_array_equal(img_4d_1.get_affine(), affine)
img_4d_2 = _utils.check_niimgs(img_4d_1)
assert_array_equal(img_4d_2.get_data(), img_4d_2.get_data())
assert_array_equal(img_4d_2.get_affine(), img_4d_2.get_affine())
# Tests with return_iterator=True
img_3d_iterator = _utils.check_niimgs([img_3d, img_3d],
return_iterator=True)
img_3d_iterator_length = sum(1 for _ in img_3d_iterator)
assert_true(img_3d_iterator_length == 2)
img_3d_iterator_1 = _utils.check_niimgs([img_3d, img_3d],
return_iterator=True)
img_3d_iterator_2 = _utils.check_niimgs(img_3d_iterator_1,
return_iterator=True)
for img_1, img_2 in itertools.izip(img_3d_iterator_1, img_3d_iterator_2):
assert_true(img_1.get_data().shape == (10, 10, 10))
assert_array_equal(img_1.get_data(), img_2.get_data())
assert_array_equal(img_1.get_affine(), img_2.get_affine())
img_3d_iterator_1 = _utils.check_niimgs([img_3d, img_3d],
return_iterator=True)
img_3d_iterator_2 = _utils.check_niimgs(img_4d_1,
return_iterator=True)
for img_1, img_2 in itertools.izip(img_3d_iterator_1, img_3d_iterator_2):
assert_true(img_1.get_data().shape == (10, 10, 10))
assert_array_equal(img_1.get_data(), img_2.get_data())
assert_array_equal(img_1.get_affine(), img_2.get_affine())
# This should raise an error: a 3D img is given and we want a 4D
assert_raises_regexp(TypeError, 'image',
_utils.check_niimgs, img_3d)
# This shouldn't raise an error
_utils.check_niimgs(img_3d, accept_3d=True)
# Test a Niimage that does not hold a shape attribute
phony_img = PhonyNiimage()
_utils.check_niimgs(phony_img)
def test_check_niimgs():
assert_raises_regexp(TypeError, 'image', _utils.check_niimgs, 0)
assert_raises_regexp(TypeError, 'image', _utils.check_niimgs, [])
affine = np.eye(4)
img_3d = Nifti1Image(np.ones((10, 10, 10)), affine)
# Tests with return_iterator=False
img_4d_1 = _utils.check_niimgs([img_3d, img_3d])
assert_true(img_4d_1.get_data().shape == (10, 10, 10, 2))
assert_array_equal(img_4d_1.get_affine(), affine)
img_4d_2 = _utils.check_niimgs(img_4d_1)
assert_array_equal(img_4d_2.get_data(), img_4d_2.get_data())
assert_array_equal(img_4d_2.get_affine(), img_4d_2.get_affine())
# Tests with return_iterator=True
img_3d_iterator = _utils.check_niimgs([img_3d, img_3d],
return_iterator=True)
img_3d_iterator_length = sum(1 for _ in img_3d_iterator)
assert_true(img_3d_iterator_length == 2)
img_3d_iterator_1 = _utils.check_niimgs([img_3d, img_3d],
return_iterator=True)
img_3d_iterator_2 = _utils.check_niimgs(img_3d_iterator_1,
return_iterator=True)
for img_1, img_2 in itertools.izip(img_3d_iterator_1, img_3d_iterator_2):
assert_true(img_1.get_data().shape == (10, 10, 10))
assert_array_equal(img_1.get_data(), img_2.get_data())
assert_array_equal(img_1.get_affine(), img_2.get_affine())
img_3d_iterator_1 = _utils.check_niimgs([img_3d, img_3d],
return_iterator=True)
img_3d_iterator_2 = _utils.check_niimgs(img_4d_1, return_iterator=True)
for img_1, img_2 in itertools.izip(img_3d_iterator_1, img_3d_iterator_2):
assert_true(img_1.get_data().shape == (10, 10, 10))
assert_array_equal(img_1.get_data(), img_2.get_data())
assert_array_equal(img_1.get_affine(), img_2.get_affine())
# This should raise an error: a 3D img is given and we want a 4D
assert_raises_regexp(TypeError, 'image', _utils.check_niimgs, img_3d)
# This shouldn't raise an error
_utils.check_niimgs(img_3d, accept_3d=True)
# Test a Niimage that does not hold a shape attribute
phony_img = PhonyNiimage()
_utils.check_niimgs(phony_img)
def test_signals_extraction_with_labels():
"""Test conversion between signals and images using regions defined
by labels."""
shape = (8, 9, 10)
n_instants = 11
n_regions = 8 # must be 8
eps = np.finfo(np.float).eps
# data
affine = np.eye(4)
signals = generate_timeseries(n_instants, n_regions)
# mask
mask_data = np.zeros(shape)
mask_data[1:-1, 1:-1, 1:-1] = 1
mask_img = nibabel.Nifti1Image(mask_data, affine)
mask_4d_img = nibabel.Nifti1Image(np.ones(shape + (2, )), affine)
# labels
labels_data = np.zeros(shape, dtype=np.int)
h0 = shape[0] / 2
h1 = shape[1] / 2
h2 = shape[2] / 2
labels_data[:h0, :h1, :h2] = 1
labels_data[:h0, :h1, h2:] = 2
labels_data[:h0, h1:, :h2] = 3
labels_data[:h0, h1:, h2:] = 4
labels_data[h0:, :h1, :h2] = 5
labels_data[h0:, :h1, h2:] = 6
labels_data[h0:, h1:, :h2] = 7
labels_data[h0:, h1:, h2:] = 8
labels_img = nibabel.Nifti1Image(labels_data, affine)
labels_4d_data = np.zeros((shape) + (2, ))
labels_4d_data[..., 0] = labels_data
labels_4d_data[..., 1] = labels_data
labels_4d_img = nibabel.Nifti1Image(labels_4d_data, np.eye(4))
## Without mask
# from labels
data_img = region.signals_to_img_labels(signals, labels_img)
data = data_img.get_data()
assert_true(data_img.shape == (shape + (n_instants, )))
assert_true(np.all(data.std(axis=-1) > 0))
# verify that 4D label images are refused
assert_raises_regexp(TypeError, "A 3D image is expected",
region.img_to_signals_labels, data_img, labels_4d_img)
# There must be non-zero data (safety net)
assert_true(abs(data).max() > 1e-9)
# Check that signals in each region are identical in each voxel
for n in xrange(1, n_regions + 1):
sigs = data[labels_data == n, :]
np.testing.assert_almost_equal(sigs[0, :], signals[:, n - 1])
assert_true(abs(sigs - sigs[0, :]).max() < eps)
# and back
signals_r, labels_r = region.img_to_signals_labels(data_img, labels_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == range(1, 9))
with write_tmp_imgs(data_img) as fname_img:
signals_r, labels_r = region.img_to_signals_labels(
fname_img, labels_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == range(1, 9))
## Same thing, with mask.
assert_raises_regexp(TypeError,
"A 3D image is expected",
region.img_to_signals_labels,
data_img,
labels_img,
mask_img=mask_4d_img)
assert_raises_regexp(TypeError,
"A 3D image is expected",
region.signals_to_img_labels,
data_img,
labels_img,
mask_img=mask_4d_img)
data_img = region.signals_to_img_labels(signals,
labels_img,
mask_img=mask_img)
assert_raises(TypeError,
region.signals_to_img_labels,
data_img,
labels_4d_img,
mask_img=mask_img)
assert_true(data_img.shape == (shape + (n_instants, )))
data = data_img.get_data()
assert_true(abs(data).max() > 1e-9)
# Zero outside of the mask
assert_true(
np.all(data[np.logical_not(mask_img.get_data())].std(axis=-1) < eps))
with write_tmp_imgs(labels_img, mask_img) as filenames:
data_img = region.signals_to_img_labels(signals,
filenames[0],
mask_img=filenames[1])
assert_true(data_img.shape == (shape + (n_instants, )))
data = data_img.get_data()
assert_true(abs(data).max() > 1e-9)
# Zero outside of the mask
assert_true(
np.all(
data[np.logical_not(mask_img.get_data())].std(axis=-1) < eps))
# mask labels before checking
masked_labels_data = labels_data.copy()
masked_labels_data[np.logical_not(mask_img.get_data())] = 0
for n in xrange(1, n_regions + 1):
sigs = data[masked_labels_data == n, :]
np.testing.assert_almost_equal(sigs[0, :], signals[:, n - 1])
assert_true(abs(sigs - sigs[0, :]).max() < eps)
# and back
signals_r, labels_r = region.img_to_signals_labels(data_img,
labels_img,
mask_img=mask_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == range(1, 9))
# Test input validation
data_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 5)), np.eye(4))
good_labels_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), np.eye(4))
bad_labels1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5)), np.eye(4))
bad_labels2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), 2 * np.eye(4))
good_mask_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), np.eye(4))
bad_mask1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5)), np.eye(4))
bad_mask2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), 2 * np.eye(4))
assert_raises(ValueError, region.img_to_signals_labels, data_img,
bad_labels1_img)
assert_raises(ValueError, region.img_to_signals_labels, data_img,
bad_labels2_img)
assert_raises(ValueError,
region.img_to_signals_labels,
data_img,
bad_labels1_img,
mask_img=good_mask_img)
assert_raises(ValueError,
region.img_to_signals_labels,
data_img,
bad_labels2_img,
mask_img=good_mask_img)
assert_raises(ValueError,
region.img_to_signals_labels,
data_img,
good_labels_img,
mask_img=bad_mask1_img)
assert_raises(ValueError,
region.img_to_signals_labels,
data_img,
good_labels_img,
mask_img=bad_mask2_img)
def test_plot_connectome_exceptions():
import pylab as pl
pl.switch_backend('template')
node_coords = np.arange(2 * 3).reshape((2, 3))
# adjacency_matrix is not symmetric
non_symmetric_adjacency_matrix = np.array([[1., 2], [0.4, 1.]])
assert_raises_regexp(ValueError, 'should be symmetric', plot_connectome,
non_symmetric_adjacency_matrix, node_coords)
adjacency_matrix = np.array([[1., 2.], [2., 1.]])
# adjacency_matrix mask is not symmetric
masked_adjacency_matrix = np.ma.masked_array(
adjacency_matrix, [[False, True], [False, False]])
assert_raises_regexp(ValueError, 'non symmetric mask', plot_connectome,
masked_adjacency_matrix, node_coords)
# edges threshold is neither a number nor a string
assert_raises_regexp(TypeError,
'should be either a number or a string',
plot_connectome,
adjacency_matrix,
node_coords,
edge_threshold=object())
# wrong shapes for node_coords or adjacency_matrix
assert_raises_regexp(ValueError,
r'supposed to have shape \(n, n\).+\(1, 2\)',
plot_connectome, adjacency_matrix[:1, :], node_coords)
assert_raises_regexp(ValueError, r'shape \(2, 3\).+\(2,\)',
plot_connectome, adjacency_matrix, node_coords[:, 2])
wrong_adjacency_matrix = np.zeros((3, 3))
assert_raises_regexp(ValueError, r'Shape mismatch.+\(3, 3\).+\(2, 3\)',
plot_connectome, wrong_adjacency_matrix, node_coords)
# a few not correctly formatted strings for 'edge_threshold'
wrong_edge_thresholds = ['0.1', '10', '10.2.3%', 'asdf%']
for wrong_edge_threshold in wrong_edge_thresholds:
assert_raises_regexp(ValueError,
'should be a number followed by the percent sign',
plot_connectome,
adjacency_matrix,
node_coords,
edge_threshold=wrong_edge_threshold)
# specifying node sizes via node_kwargs
assert_raises_regexp(ValueError,
"Please use 'node_size' and not 'node_kwargs'",
plot_connectome,
adjacency_matrix,
node_coords,
node_kwargs={'s': 50})
# specifying node colors via node_kwargs
assert_raises_regexp(ValueError,
"Please use 'node_color' and not 'node_kwargs'",
plot_connectome,
adjacency_matrix,
node_coords,
node_kwargs={'c': 'blue'})
def test_errors():
masker = NiftiSpheresMasker(([1, 2]), radius=.2)
assert_raises_regexp(ValueError, 'Seeds must be a list .+', masker.fit)
def test_nifti_labels_masker():
# Check working of shape/affine checks
shape1 = (13, 11, 12)
affine1 = np.eye(4)
shape2 = (12, 10, 14)
affine2 = np.diag((1, 2, 3, 1))
n_regions = 9
length = 3
fmri11_img, mask11_img = generate_random_img(shape1,
affine=affine1,
length=length)
fmri12_img, mask12_img = generate_random_img(shape1,
affine=affine2,
length=length)
fmri21_img, mask21_img = generate_random_img(shape2,
affine=affine1,
length=length)
labels11_img = testing.generate_labeled_regions(shape1,
affine=affine1,
n_regions=n_regions)
mask_img_4d = nibabel.Nifti1Image(np.ones((2, 2, 2, 2), dtype=np.int8),
affine=np.diag((4, 4, 4, 1)))
# verify that 4D mask arguments are refused
masker = NiftiLabelsMasker(labels11_img, mask_img=mask_img_4d)
testing.assert_raises_regexp(TypeError, "A 3D image is expected",
masker.fit)
# check exception when transform() called without prior fit()
masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None)
testing.assert_raises_regexp(ValueError, 'has not been fitted. ',
masker11.transform, fmri11_img)
# No exception raised here
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
masker11 = NiftiLabelsMasker(labels11_img,
mask_img=mask11_img,
resampling_target=None)
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
# Test all kinds of mismatch between shapes and between affines
masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None)
masker11.fit()
assert_raises(ValueError, masker11.transform, fmri12_img)
assert_raises(ValueError, masker11.transform, fmri21_img)
masker11 = NiftiLabelsMasker(labels11_img,
mask_img=mask12_img,
resampling_target=None)
assert_raises(ValueError, masker11.fit)
masker11 = NiftiLabelsMasker(labels11_img,
mask_img=mask21_img,
resampling_target=None)
assert_raises(ValueError, masker11.fit)
# Transform, with smoothing (smoke test)
masker11 = NiftiLabelsMasker(labels11_img,
smoothing_fwhm=3,
resampling_target=None)
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
masker11 = NiftiLabelsMasker(labels11_img,
smoothing_fwhm=3,
resampling_target=None)
signals11 = masker11.fit_transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
testing.assert_raises_regexp(
ValueError, 'has not been fitted. ',
NiftiLabelsMasker(labels11_img).inverse_transform, signals11)
# Call inverse transform (smoke test)
fmri11_img_r = masker11.inverse_transform(signals11)
assert_equal(fmri11_img_r.shape, fmri11_img.shape)
np.testing.assert_almost_equal(fmri11_img_r.get_affine(),
fmri11_img.get_affine())
def test_reorder_img():
# We need to test on a square array, as rotation does not change
# shape, whereas reordering does.
shape = (5, 5, 5, 2, 2)
rng = np.random.RandomState(42)
data = rng.rand(*shape)
affine = np.eye(4)
affine[:3, -1] = 0.5 * np.array(shape[:3])
ref_img = Nifti1Image(data, affine)
# Test with purely positive matrices and compare to a rotation
for theta, phi in np.random.randint(4, size=(5, 2)):
rot = rotation(theta * np.pi / 2, phi * np.pi / 2)
rot[np.abs(rot) < 0.001] = 0
rot[rot > 0.9] = 1
rot[rot < -0.9] = 1
b = 0.5 * np.array(shape[:3])
new_affine = from_matrix_vector(rot, b)
rot_img = resample_img(ref_img, target_affine=new_affine)
np.testing.assert_array_equal(rot_img.get_affine(), new_affine)
np.testing.assert_array_equal(rot_img.get_data().shape, shape)
reordered_img = reorder_img(rot_img)
np.testing.assert_array_equal(reordered_img.get_affine()[:3, :3],
np.eye(3))
np.testing.assert_almost_equal(reordered_img.get_data(), data)
# Create a non-diagonal affine, and check that we raise a sensible
# exception
affine[1, 0] = 0.1
ref_img = Nifti1Image(data, affine)
testing.assert_raises_regexp(ValueError, 'Cannot reorder the axes',
reorder_img, ref_img)
# Test that no exception is raised when resample='continuous'
reorder_img(ref_img, resample='continuous')
# Test that resample args gets passed to resample_img
interpolation = 'nearest'
reordered_img = reorder_img(ref_img, resample=interpolation)
resampled_img = resample_img(ref_img,
target_affine=reordered_img.get_affine(),
interpolation=interpolation)
np.testing.assert_array_equal(reordered_img.get_data(),
resampled_img.get_data())
# Make sure invalid resample argument is included in the error message
interpolation = 'an_invalid_interpolation'
pattern = "interpolation must be either.+{0}".format(interpolation)
testing.assert_raises_regexp(ValueError,
pattern,
reorder_img,
ref_img,
resample=interpolation)
# Test flipping an axis
data = rng.rand(*shape)
for i in (0, 1, 2):
# Make a diagonal affine with a negative axis, and check that
# can be reordered, also vary the shape
shape = (i + 1, i + 2, 3 - i)
affine = np.eye(4)
affine[i, i] *= -1
img = Nifti1Image(data, affine)
orig_img = copy.copy(img)
#x, y, z = img.get_world_coords()
#sample = img.values_in_world(x, y, z)
img2 = reorder_img(img)
# Check that img has not been changed
np.testing.assert_array_equal(img.get_affine(), orig_img.get_affine())
np.testing.assert_array_equal(img.get_data(), orig_img.get_data())
# Test that the affine is indeed diagonal:
np.testing.assert_array_equal(
img2.get_affine()[:3, :3],
np.diag(np.diag(img2.get_affine()[:3, :3])))
assert_true(np.all(np.diag(img2.get_affine()) >= 0))
def test_signal_extraction_with_maps():
shape = (10, 11, 12)
n_regions = 9
n_instants = 13
# Generate signals
rand_gen = np.random.RandomState(0)
maps_img, mask_img = generate_maps(shape, n_regions, border=1)
maps_data = maps_img.get_data()
data = np.zeros(shape + (n_instants, ), dtype=np.float32)
mask_4d_img = np.ones((shape + (2, )))
signals = np.zeros((n_instants, maps_data.shape[-1]))
for n in xrange(maps_data.shape[-1]):
signals[:, n] = rand_gen.randn(n_instants)
data[maps_data[..., n] > 0, :] = signals[:, n]
img = nibabel.Nifti1Image(data, np.eye(4))
# verify that 4d masks are refused
assert_raises_regexp(TypeError,
"A 3D image is expected",
region.img_to_signals_maps,
img,
maps_img,
mask_img=mask_4d_img)
## Get signals
signals_r, labels = region.img_to_signals_maps(img,
maps_img,
mask_img=mask_img)
# The output must be identical to the input signals, because every region
# is homogeneous: there is the same signal in all voxels of one given
# region (and all maps are uniform).
np.testing.assert_almost_equal(signals, signals_r)
# Same thing without mask (in that case)
signals_r, labels = region.img_to_signals_maps(img, maps_img)
np.testing.assert_almost_equal(signals, signals_r)
## Recover image
img_r = region.signals_to_img_maps(signals, maps_img, mask_img=mask_img)
np.testing.assert_almost_equal(img_r.get_data(), img.get_data())
img_r = region.signals_to_img_maps(signals, maps_img)
np.testing.assert_almost_equal(img_r.get_data(), img.get_data())
# Test input validation
data_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 5)), np.eye(4))
good_maps_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 7)), np.eye(4))
bad_maps1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5, 7)), np.eye(4))
bad_maps2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 7)), 2 * np.eye(4))
good_mask_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), np.eye(4))
bad_mask1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5)), np.eye(4))
bad_mask2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), 2 * np.eye(4))
assert_raises(ValueError, region.img_to_signals_maps, data_img,
bad_maps1_img)
assert_raises(ValueError, region.img_to_signals_maps, data_img,
bad_maps2_img)
assert_raises(ValueError,
region.img_to_signals_maps,
data_img,
bad_maps1_img,
mask_img=good_mask_img)
assert_raises(ValueError,
region.img_to_signals_maps,
data_img,
bad_maps2_img,
mask_img=good_mask_img)
assert_raises(ValueError,
region.img_to_signals_maps,
data_img,
good_maps_img,
mask_img=bad_mask1_img)
assert_raises(ValueError,
region.img_to_signals_maps,
data_img,
good_maps_img,
mask_img=bad_mask2_img)