def test_iter_img():
img_3d = nibabel.Nifti1Image(np.ones((3, 4, 5)), np.eye(4))
testing.assert_raises_regex(TypeError, '4D Niimg-like', 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())
# enables to delete "img_4d_filename" on windows
del img
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())
# enables to delete "img_3d_filename" on windows
del img
def test_iter_img():
img_3d = nibabel.Nifti1Image(np.ones((3, 4, 5)), np.eye(4))
testing.assert_raises_regex(TypeError,
"Input data has incompatible dimensionality: "
"Expected dimension is 4D and you provided "
"a 3D image.",
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(compat.get_affine(img),
compat.get_affine(img_4d))
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(compat.get_affine(img),
compat.get_affine(img_4d))
# enables to delete "img_4d_filename" on windows
del img
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(compat.get_affine(img),
compat.get_affine(img_4d))
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(compat.get_affine(img),
compat.get_affine(img_4d))
# enables to delete "img_3d_filename" on windows
del img
def test_iter_img():
img_3d = nibabel.Nifti1Image(np.ones((3, 4, 5)), np.eye(4))
testing.assert_raises_regex(TypeError,
"Input data has incompatible dimensionality: "
"Expected dimension is 4D and you provided "
"a 3D image.",
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(compat.get_affine(img),
compat.get_affine(img_4d))
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(compat.get_affine(img),
compat.get_affine(img_4d))
# enables to delete "img_4d_filename" on windows
del img
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(compat.get_affine(img),
compat.get_affine(img_4d))
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(compat.get_affine(img),
compat.get_affine(img_4d))
# enables to delete "img_3d_filename" on windows
del img
def test_joblib_cache():
if not LooseVersion(nibabel.__version__) > LooseVersion('1.1.0'):
# Old nibabel do not pickle
raise SkipTest
from sklearn.externals.joblib import hash, Memory
mask = np.zeros((40, 40, 40))
mask[20, 20, 20] = 1
mask_img = Nifti1Image(mask, np.eye(4))
with testing.write_tmp_imgs(mask_img, create_files=True)\
as filename:
masker = NiftiMasker(mask_img=filename)
masker.fit()
mask_hash = hash(masker.mask_img_)
masker.mask_img_.get_data()
assert_true(mask_hash == hash(masker.mask_img_))
# Test a tricky issue with memmapped joblib.memory that makes
# imgs return by inverse_transform impossible to save
cachedir = mkdtemp()
try:
masker.memory = Memory(cachedir=cachedir, mmap_mode='r', verbose=0)
X = masker.transform(mask_img)
# inverse_transform a first time, so that the result is cached
out_img = masker.inverse_transform(X)
out_img = masker.inverse_transform(X)
out_img.to_filename(os.path.join(cachedir, 'test.nii'))
finally:
shutil.rmtree(cachedir, ignore_errors=True)
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_regex(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.affine, img.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.affine, img.affine)
def test_check_niimg_3d():
# check error for non-forced but necessary resampling
assert_raises_regex(TypeError, 'nibabel format',
_utils.check_niimg, 0)
# check error for non-forced but necessary resampling
assert_raises_regex(TypeError, 'empty object',
_utils.check_niimg, [])
# Test dimensionality error
img = Nifti1Image(np.zeros((10, 10, 10)), np.eye(4))
assert_raises_regex(TypeError,
"Input data has incompatible dimensionality: "
"Expected dimension is 3D and you provided a list "
"of 3D images \(4D\).",
_utils.check_niimg_3d, [img, img])
# Check that a filename does not raise an error
data = np.zeros((40, 40, 40, 1))
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_3d(filename)
# check data dtype equal with dtype='auto'
img_check = _utils.check_niimg_3d(img, dtype='auto')
assert_equal(img.get_data().dtype.kind, img_check.get_data().dtype.kind)
def test_check_niimg():
with assert_raises(TypeError) as cm:
_utils.check_niimg(0)
assert_true('image' in cm.exception.message
or 'affine' in cm.exception.message)
with assert_raises(TypeError) as cm:
_utils.check_niimg([])
assert_true('image' in cm.exception.message
or 'affine' in cm.exception.message)
# Test ensure_3d
with assert_raises(TypeError) as cm:
_utils.check_niimg(['test.nii', ], ensure_3d=True)
assert_true('3D' in cm.exception.message)
# 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
with assert_raises(TypeError) as cm:
_utils.check_niimg(data, ensure_3d=True)
assert_true('3D' in cm.exception.message)
# 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_smooth_img():
# This function only checks added functionalities compared
# to _smooth_array()
shapes = ((10, 11, 12), (13, 14, 15))
lengths = (17, 18)
fwhm = (1., 2., 3.)
img1, mask1 = testing.generate_fake_fmri(shape=shapes[0],
length=lengths[0])
img2, mask2 = testing.generate_fake_fmri(shape=shapes[1],
length=lengths[1])
for create_files in (False, True):
with testing.write_tmp_imgs(img1, img2,
create_files=create_files) as imgs:
# List of images as input
out = image.smooth_img(imgs, fwhm)
assert_true(isinstance(out, list))
assert_true(len(out) == 2)
for o, s, l in zip(out, shapes, lengths):
assert_true(o.shape == (s + (l,)))
# Single image as input
out = image.smooth_img(imgs[0], fwhm)
assert_true(isinstance(out, nibabel.Nifti1Image))
assert_true(out.shape == (shapes[0] + (lengths[0],)))
def test_mean_img():
rng = np.random.RandomState(42)
data1 = np.zeros((5, 6, 7))
data2 = rng.rand(5, 6, 7)
data3 = rng.rand(5, 6, 7, 3)
affine = np.diag((4, 3, 2, 1))
img1 = nibabel.Nifti1Image(data1, affine=affine)
img2 = nibabel.Nifti1Image(data2, affine=affine)
img3 = nibabel.Nifti1Image(data3, affine=affine)
for imgs in ([img1, ],
[img1, img2],
[img2, img1, img2],
[img3, img1, img2], # Mixture of 4D and 3D images
):
arrays = list()
# Ground-truth:
for img in imgs:
img = img.get_data()
if img.ndim == 4:
img = np.mean(img, axis=-1)
arrays.append(img)
truth = np.mean(arrays, axis=0)
mean_img = image.mean_img(imgs)
assert_array_equal(mean_img.get_affine(), affine)
assert_array_equal(mean_img.get_data(), truth)
# Test with files
with testing.write_tmp_imgs(*imgs) as imgs:
mean_img = image.mean_img(imgs)
assert_array_equal(mean_img.get_affine(), affine)
assert_array_equal(mean_img.get_data(), truth)
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_joblib_cache():
if not LooseVersion(nibabel.__version__) > LooseVersion('1.1.0'):
# Old nibabel do not pickle
raise SkipTest
from sklearn.externals.joblib import hash, Memory
mask = np.zeros((40, 40, 40))
mask[20, 20, 20] = 1
mask_img = Nifti1Image(mask, np.eye(4))
with testing.write_tmp_imgs(mask_img, create_files=True)\
as filename:
masker = NiftiMasker(mask_img=filename)
masker.fit()
mask_hash = hash(masker.mask_img_)
masker.mask_img_.get_data()
assert_true(mask_hash == hash(masker.mask_img_))
# Test a tricky issue with memmapped joblib.memory that makes
# imgs return by inverse_transform impossible to save
cachedir = mkdtemp()
try:
masker.memory = Memory(cachedir=cachedir, mmap_mode='r',
verbose=0)
X = masker.transform(mask_img)
# inverse_transform a first time, so that the result is cached
out_img = masker.inverse_transform(X)
out_img = masker.inverse_transform(X)
out_img.to_filename(os.path.join(cachedir, 'test.nii'))
finally:
shutil.rmtree(cachedir, ignore_errors=True)
def test_smooth_img():
# This function only checks added functionalities compared
# to _smooth_array()
shapes = ((10, 11, 12), (13, 14, 15))
lengths = (17, 18)
fwhm = (1., 2., 3.)
img1, mask1 = testing.generate_fake_fmri(shape=shapes[0],
length=lengths[0])
img2, mask2 = testing.generate_fake_fmri(shape=shapes[1],
length=lengths[1])
for create_files in (False, True):
with testing.write_tmp_imgs(img1, img2,
create_files=create_files) as imgs:
# List of images as input
out = image.smooth_img(imgs, fwhm)
assert_true(isinstance(out, list))
assert_true(len(out) == 2)
for o, s, l in zip(out, shapes, lengths):
assert_true(o.shape == (s + (l, )))
# Single image as input
out = image.smooth_img(imgs[0], fwhm)
assert_true(isinstance(out, nibabel.Nifti1Image))
assert_true(out.shape == (shapes[0] + (lengths[0], )))
# Check corner case situations when fwhm=0, See issue #1537
# Test whether function smooth_img raises a warning when fwhm=0.
assert_warns(UserWarning, image.smooth_img, img1, fwhm=0.)
# Test output equal when fwhm=None and fwhm=0
out_fwhm_none = image.smooth_img(img1, fwhm=None)
out_fwhm_zero = image.smooth_img(img1, fwhm=0.)
assert_array_equal(out_fwhm_none.get_data(), out_fwhm_zero.get_data())
def test_largest_cc_img():
""" Check the extraction of the largest connected component, for niftis
Similiar to smooth_img tests for largest connected_component_img, here also
only the added features for largest_connected_component are tested.
"""
# Test whether dimension of 3Dimg and list of 3Dimgs are kept.
shapes = ((10, 11, 12), (13, 14, 15))
regions = [1, 3]
img1 = testing.generate_labeled_regions(shape=shapes[0],
n_regions=regions[0])
img2 = testing.generate_labeled_regions(shape=shapes[1],
n_regions=regions[1])
for create_files in (False, True):
with testing.write_tmp_imgs(img1, img2,
create_files=create_files) as imgs:
# List of images as input
out = largest_connected_component_img(imgs)
assert_true(isinstance(out, list))
assert_true(len(out) == 2)
for o, s in zip(out, shapes):
assert_true(o.shape == (s))
# Single image as input
out = largest_connected_component_img(imgs[0])
assert_true(isinstance(out, Nifti1Image))
assert_true(out.shape == (shapes[0]))
# Test whether 4D Nifti throws the right error.
img_4D = testing.generate_fake_fmri(shapes[0], length=17)
assert_raises(DimensionError, largest_connected_component_img, img_4D)
def test_joblib_cache():
from joblib import hash, Memory
mask = np.zeros((40, 40, 40))
mask[20, 20, 20] = 1
mask_img = Nifti1Image(mask, np.eye(4))
with testing.write_tmp_imgs(mask_img, create_files=True) as filename:
masker = NiftiMasker(mask_img=filename)
masker.fit()
mask_hash = hash(masker.mask_img_)
get_data(masker.mask_img_)
assert mask_hash == hash(masker.mask_img_)
# Test a tricky issue with memmapped joblib.memory that makes
# imgs return by inverse_transform impossible to save
cachedir = mkdtemp()
try:
masker.memory = Memory(location=cachedir, mmap_mode='r', verbose=0)
X = masker.transform(mask_img)
# inverse_transform a first time, so that the result is cached
out_img = masker.inverse_transform(X)
out_img = masker.inverse_transform(X)
out_img.to_filename(os.path.join(cachedir, 'test.nii'))
finally:
# enables to delete "filename" on windows
del masker
shutil.rmtree(cachedir, ignore_errors=True)
def test_check_niimg_3d():
# check error for non-forced but necessary resampling
assert_raises_regex(TypeError, 'nibabel format', _utils.check_niimg, 0)
# check error for non-forced but necessary resampling
assert_raises_regex(TypeError, 'empty object', _utils.check_niimg, [])
# Test dimensionality error
img = Nifti1Image(np.zeros((10, 10, 10)), np.eye(4))
assert_raises_regex(
TypeError, "Input data has incompatible dimensionality: "
"Expected dimension is 3D and you provided a list "
"of 3D images \(4D\).", _utils.check_niimg_3d, [img, img])
# Check that a filename does not raise an error
data = np.zeros((40, 40, 40, 1))
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_3d(filename)
# check data dtype equal with dtype='auto'
img_check = _utils.check_niimg_3d(img, dtype='auto')
assert_equal(img.get_data().dtype.kind, img_check.get_data().dtype.kind)
def test_iter_img():
img_3d = nibabel.Nifti1Image(np.ones((3, 4, 5)), np.eye(4))
testing.assert_raises_regex(TypeError, '4D Niimg-like',
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())
# enables to delete "img_4d_filename" on windows
del img
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())
# enables to delete "img_3d_filename" on windows
del img
def test_mask_3d():
# Dummy mask
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:
masker = NiftiMasker(mask_img=filename)
assert_raises(TypeError, masker.fit)
def test_with_files():
# Standard masking
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) as filename:
masker = NiftiMasker()
masker.fit(filename)
masker.transform(filename)
def test_with_files():
# Standard masking
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) as filename:
masker = NiftiMasker()
masker.fit(filename)
masker.transform(filename)
def test_mask_3d():
# Dummy mask
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:
masker = NiftiMasker(mask_img=filename)
assert_raises(TypeError, masker.fit)
def test_check_niimg():
assert_raises(TypeError, _utils.check_niimg, 0)
assert_raises(TypeError, _utils.check_niimg, [])
# 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)
def test_resampling_error_checks():
rng = np.random.RandomState(42)
shape = (3, 2, 5, 2)
target_shape = (5, 3, 2)
affine = np.eye(4)
data = rng.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
pytest.raises(ValueError, resample_img, img, target_shape=target_shape)
# Invalid shape
pytest.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)
with pytest.raises(ValueError, match=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 img_r == img
img_r = resample_img(img, copy=True)
assert not np.may_share_memory(get_data(img_r), get_data(img))
np.testing.assert_almost_equal(get_data(img_r), get_data(img))
np.testing.assert_almost_equal(img_r.affine, img.affine)
img_r = resample_img(img, target_affine=affine, target_shape=target_shape,
copy=False)
assert img_r == img
img_r = resample_img(img, target_affine=affine, target_shape=target_shape,
copy=True)
assert not np.may_share_memory(get_data(img_r), get_data(img))
np.testing.assert_almost_equal(get_data(img_r), get_data(img))
np.testing.assert_almost_equal(img_r.affine, img.affine)
def test_with_globbing_patterns_with_single_subject():
# single subject
data, mask_img, _, _ = _make_canica_test_data(n_subjects=1)
n_components = 3
canica = CanICA(n_components=n_components, mask=mask_img)
with write_tmp_imgs(data[0], create_files=True, use_wildcards=True) as img:
input_image = _tmp_dir() + img
canica.fit(input_image)
components_img = canica.components_img_
assert_true(isinstance(components_img, nibabel.Nifti1Image))
# n_components = 3
check_shape = data[0].shape[:3] + (3,)
assert_true(components_img.shape, check_shape)
def test_with_globbing_patterns_with_single_subject():
# single subject
data, mask_img, _, _ = _make_canica_test_data(n_subjects=1)
n_components = 3
dictlearn = DictLearning(n_components=n_components, mask=mask_img)
with write_tmp_imgs(data[0], create_files=True, use_wildcards=True) as img:
input_image = _tmp_dir() + img
dictlearn.fit(input_image)
components_img = dictlearn.components_img_
assert_true(isinstance(components_img, nibabel.Nifti1Image))
# n_components = 3
check_shape = data[0].shape[:3] + (3,)
assert_true(components_img.shape, check_shape)
def test_math_img():
img1 = Nifti1Image(np.ones((10, 10, 10, 10)), np.eye(4))
img2 = Nifti1Image(np.zeros((10, 10, 10, 10)), np.eye(4))
expected_result = Nifti1Image(np.ones((10, 10, 10)), np.eye(4))
formula = "np.mean(img1, axis=-1) - np.mean(img2, axis=-1)"
for create_files in (True, False):
with testing.write_tmp_imgs(img1, img2,
create_files=create_files) as imgs:
result = math_img(formula, img1=imgs[0], img2=imgs[1])
assert_array_equal(result.get_data(), expected_result.get_data())
assert_array_equal(result.affine, expected_result.affine)
assert_equal(result.shape, expected_result.shape)
def test_math_img():
img1 = Nifti1Image(np.ones((10, 10, 10, 10)), np.eye(4))
img2 = Nifti1Image(np.zeros((10, 10, 10, 10)), np.eye(4))
expected_result = Nifti1Image(np.ones((10, 10, 10)), np.eye(4))
formula = "np.mean(img1, axis=-1) - np.mean(img2, axis=-1)"
for create_files in (True, False):
with testing.write_tmp_imgs(img1, img2,
create_files=create_files) as imgs:
result = math_img(formula, img1=imgs[0], img2=imgs[1])
assert_array_equal(result.get_data(),
expected_result.get_data())
assert_array_equal(result.affine, expected_result.affine)
assert_equal(result.shape, expected_result.shape)
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_regex(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_check_niimg_3d():
# check error for non-forced but necessary resampling
assert_raises_regex(TypeError, 'nibabel format', _utils.check_niimg, 0)
# check error for non-forced but necessary resampling
assert_raises_regex(TypeError, 'empty object', _utils.check_niimg, [])
# Check that a filename does not raise an error
data = np.zeros((40, 40, 40, 1))
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_3d(filename)
def test_joblib_cache():
from sklearn.externals.joblib import hash
# Dummy mask
mask = np.zeros((40, 40, 40))
mask[20, 20, 20] = 1
mask_img = Nifti1Image(mask, np.eye(4))
with write_tmp_imgs(mask_img, create_files=True) as filename:
masker = MultiNiftiMasker(mask_img=filename)
masker.fit()
mask_hash = hash(masker.mask_img_)
masker.mask_img_.get_data()
assert_true(mask_hash == hash(masker.mask_img_))
# enables to delete "filename" on windows
del masker
def test_joblib_cache():
from joblib import hash
# Dummy mask
mask = np.zeros((40, 40, 40))
mask[20, 20, 20] = 1
mask_img = Nifti1Image(mask, np.eye(4))
with write_tmp_imgs(mask_img, create_files=True) as filename:
masker = MultiNiftiMasker(mask_img=filename)
masker.fit()
mask_hash = hash(masker.mask_img_)
get_data(masker.mask_img_)
assert mask_hash == hash(masker.mask_img_)
# enables to delete "filename" on windows
del masker
def test_with_globbing_patterns_with_single_image():
# With single image
data_4d = np.zeros((40, 40, 40, 3))
data_4d[20, 20, 20] = 1
img_4d = nibabel.Nifti1Image(data_4d, affine=np.eye(4))
multi_pca = MultiPCA(n_components=3)
with write_tmp_imgs(img_4d, create_files=True, use_wildcards=True) as img:
input_image = _tmp_dir() + img
multi_pca.fit(input_image)
components_img = multi_pca.components_img_
assert_true(isinstance(components_img, nibabel.Nifti1Image))
# n_components = 3
check_shape = img_4d.shape[:3] + (3, )
assert_equal(components_img.shape, check_shape)
assert_equal(len(components_img.shape), 4)
def test_with_globbing_patterns_with_single_image():
# With single image
data_4d = np.zeros((40, 40, 40, 3))
data_4d[20, 20, 20] = 1
img_4d = nibabel.Nifti1Image(data_4d, affine=np.eye(4))
multi_pca = MultiPCA(n_components=3)
with write_tmp_imgs(img_4d, create_files=True, use_wildcards=True) as img:
input_image = _tmp_dir() + img
multi_pca.fit(input_image)
components_img = multi_pca.components_img_
assert_true(isinstance(components_img, nibabel.Nifti1Image))
# n_components = 3
check_shape = img_4d.shape[:3] + (3,)
assert_equal(components_img.shape, check_shape)
assert_equal(len(components_img.shape), 4)
def test_check_niimg_3d():
# check error for non-forced but necessary resampling
assert_raises_regex(TypeError, 'nibabel format',
_utils.check_niimg, 0)
# check error for non-forced but necessary resampling
assert_raises_regex(TypeError, 'empty object',
_utils.check_niimg, [])
# Check that a filename does not raise an error
data = np.zeros((40, 40, 40, 1))
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_3d(filename)
def test_mean_img():
rng = np.random.RandomState(42)
data1 = np.zeros((5, 6, 7))
data2 = rng.rand(5, 6, 7)
data3 = rng.rand(5, 6, 7, 3)
affine = np.diag((4, 3, 2, 1))
img1 = nibabel.Nifti1Image(data1, affine=affine)
img2 = nibabel.Nifti1Image(data2, affine=affine)
img3 = nibabel.Nifti1Image(data3, affine=affine)
for imgs in (
[
img1,
],
[img1, img2],
[img2, img1, img2],
[img3, img1, img2], # Mixture of 4D and 3D images
):
arrays = list()
# Ground-truth:
for img in imgs:
img = img.get_data()
if img.ndim == 4:
img = np.mean(img, axis=-1)
arrays.append(img)
truth = np.mean(arrays, axis=0)
mean_img = image.mean_img(imgs)
assert_array_equal(mean_img.get_affine(), affine)
assert_array_equal(mean_img.get_data(), truth)
# Test with files
with testing.write_tmp_imgs(*imgs) as imgs:
mean_img = image.mean_img(imgs)
assert_array_equal(mean_img.get_affine(), affine)
if X64:
assert_array_equal(mean_img.get_data(), truth)
else:
# We don't really understand but arrays are not
# exactly equal on 32bit. Given that you can not do
# much real world data analysis with nilearn on a
# 32bit machine it is not worth investigating more
assert_allclose(mean_img.get_data(),
truth,
rtol=np.finfo(truth.dtype).resolution,
atol=0)
def test_joblib_cache():
if not LooseVersion(nibabel.__version__) > LooseVersion('1.1.0'):
# Old nibabel do not pickle
raise SkipTest
from sklearn.externals.joblib import hash
# Dummy mask
mask = np.zeros((40, 40, 40))
mask[20, 20, 20] = 1
mask_img = Nifti1Image(mask, np.eye(4))
with write_tmp_imgs(mask_img, create_files=True)\
as filename:
masker = MultiNiftiMasker(mask_img=filename)
masker.fit()
mask_hash = hash(masker.mask_img_)
masker.mask_img_.get_data()
assert_true(mask_hash == hash(masker.mask_img_))
def test_joblib_cache():
if not LooseVersion(nibabel.__version__) > LooseVersion('1.1.0'):
# Old nibabel do not pickle
raise SkipTest
from sklearn.externals.joblib import hash
# Dummy mask
mask = np.zeros((40, 40, 40))
mask[20, 20, 20] = 1
mask_img = Nifti1Image(mask, np.eye(4))
with write_tmp_imgs(mask_img, create_files=True)\
as filename:
masker = MultiNiftiMasker(mask_img=filename)
masker.fit()
mask_hash = hash(masker.mask_img_)
masker.mask_img_.get_data()
assert_true(mask_hash == hash(masker.mask_img_))
def test_with_globbing_patterns_with_multi_subjects():
# Multi subjects
data, mask_img, _, _ = _make_canica_test_data(n_subjects=3)
n_components = 3
canica = CanICA(n_components=n_components, mask=mask_img)
with write_tmp_imgs(data[0],
data[1],
data[2],
create_files=True,
use_wildcards=True) as img:
input_image = _tmp_dir() + img
canica.fit(input_image)
components_img = canica.components_img_
assert_true(isinstance(components_img, nibabel.Nifti1Image))
# n_components = 3
check_shape = data[0].shape[:3] + (3, )
assert_true(components_img.shape, check_shape)
def test_check_niimg():
with assert_raises(TypeError) as cm:
_utils.check_niimg(0)
assert_true('image' in cm.exception.message
or 'affine' in cm.exception.message)
with assert_raises(TypeError) as cm:
_utils.check_niimg([])
assert_true('image' in cm.exception.message
or 'affine' in cm.exception.message)
# 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)
def test_check_niimg_3d():
# check error for non-forced but necessary resampling
assert_raises_regex(TypeError, "nibabel format", _utils.check_niimg, 0)
# check error for non-forced but necessary resampling
assert_raises_regex(TypeError, "empty object", _utils.check_niimg, [])
# Test dimensionality error
img = Nifti1Image(np.zeros((10, 10, 10)), np.eye(4))
assert_raises_regex(TypeError, "Data must be a 3D", _utils.check_niimg_3d, [img, img])
# Check that a filename does not raise an error
data = np.zeros((40, 40, 40, 1))
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_3d(filename)
def test_smooth_img():
# This function only checks added functionalities compared
# to _smooth_array()
shapes = ((10, 11, 12), (13, 14, 15))
lengths = (17, 18)
fwhm = (1., 2., 3.)
img1, mask1 = data_gen.generate_fake_fmri(shape=shapes[0],
length=lengths[0])
img2, mask2 = data_gen.generate_fake_fmri(shape=shapes[1],
length=lengths[1])
for create_files in (False, True):
with testing.write_tmp_imgs(img1, img2,
create_files=create_files) as imgs:
# List of images as input
out = image.smooth_img(imgs, fwhm)
assert isinstance(out, list)
assert len(out) == 2
for o, s, l in zip(out, shapes, lengths):
assert o.shape == (s + (l, ))
# Single image as input
out = image.smooth_img(imgs[0], fwhm)
assert isinstance(out, nibabel.Nifti1Image)
assert out.shape == (shapes[0] + (lengths[0], ))
# Check corner case situations when fwhm=0, See issue #1537
# Test whether function smooth_img raises a warning when fwhm=0.
with pytest.warns(UserWarning):
image.smooth_img(img1, fwhm=0.)
# Test output equal when fwhm=None and fwhm=0
out_fwhm_none = image.smooth_img(img1, fwhm=None)
out_fwhm_zero = image.smooth_img(img1, fwhm=0.)
assert_array_equal(get_data(out_fwhm_none), get_data(out_fwhm_zero))
data1 = np.zeros((10, 11, 12))
data1[2:4, 1:5, 3:6] = 1
data2 = np.zeros((13, 14, 15))
data2[2:4, 1:5, 3:6] = 9
img1_nifti2 = nibabel.Nifti2Image(data1, affine=np.eye(4))
img2_nifti2 = nibabel.Nifti2Image(data2, affine=np.eye(4))
out = image.smooth_img([img1_nifti2, img2_nifti2], fwhm=1.)
def test_smooth_img():
# This function only checks added functionalities compared
# to _smooth_array()
shapes = ((10, 11, 12), (13, 14, 15))
lengths = (17, 18)
fwhm = (1., 2., 3.)
img1, mask1 = data_gen.generate_fake_fmri(shape=shapes[0],
length=lengths[0])
img2, mask2 = data_gen.generate_fake_fmri(shape=shapes[1],
length=lengths[1])
for create_files in (False, True):
with testing.write_tmp_imgs(img1, img2,
create_files=create_files) as imgs:
# List of images as input
out = image.smooth_img(imgs, fwhm)
assert_true(isinstance(out, list))
assert_true(len(out) == 2)
for o, s, l in zip(out, shapes, lengths):
assert_true(o.shape == (s + (l,)))
# Single image as input
out = image.smooth_img(imgs[0], fwhm)
assert_true(isinstance(out, nibabel.Nifti1Image))
assert_true(out.shape == (shapes[0] + (lengths[0],)))
# Check corner case situations when fwhm=0, See issue #1537
# Test whether function smooth_img raises a warning when fwhm=0.
assert_warns(UserWarning, image.smooth_img, img1, fwhm=0.)
# Test output equal when fwhm=None and fwhm=0
out_fwhm_none = image.smooth_img(img1, fwhm=None)
out_fwhm_zero = image.smooth_img(img1, fwhm=0.)
assert_array_equal(out_fwhm_none.get_data(), out_fwhm_zero.get_data())
data1 = np.zeros((10, 11, 12))
data1[2:4, 1:5, 3:6] = 1
data2 = np.zeros((13, 14, 15))
data2[2:4, 1:5, 3:6] = 9
img1_nifti2 = nibabel.Nifti2Image(data1, affine=np.eye(4))
img2_nifti2 = nibabel.Nifti2Image(data2, affine=np.eye(4))
out = image.smooth_img([img1_nifti2, img2_nifti2], fwhm=1.)
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_mean_img():
rng = np.random.RandomState(42)
data1 = np.zeros((5, 6, 7))
data2 = rng.rand(5, 6, 7)
data3 = rng.rand(5, 6, 7, 3)
affine = np.diag((4, 3, 2, 1))
img1 = nibabel.Nifti1Image(data1, affine=affine)
img2 = nibabel.Nifti1Image(data2, affine=affine)
img3 = nibabel.Nifti1Image(data3, affine=affine)
for imgs in ([img1, ],
[img1, img2],
[img2, img1, img2],
[img3, img1, img2], # Mixture of 4D and 3D images
):
arrays = list()
# Ground-truth:
for img in imgs:
img = img.get_data()
if img.ndim == 4:
img = np.mean(img, axis=-1)
arrays.append(img)
truth = np.mean(arrays, axis=0)
mean_img = image.mean_img(imgs)
assert_array_equal(mean_img.affine, affine)
assert_array_equal(mean_img.get_data(), truth)
# Test with files
with testing.write_tmp_imgs(*imgs) as imgs:
mean_img = image.mean_img(imgs)
assert_array_equal(mean_img.affine, affine)
if X64:
assert_array_equal(mean_img.get_data(), truth)
else:
# We don't really understand but arrays are not
# exactly equal on 32bit. Given that you can not do
# much real world data analysis with nilearn on a
# 32bit machine it is not worth investigating more
assert_allclose(mean_img.get_data(), truth,
rtol=np.finfo(truth.dtype).resolution,
atol=0)
def test_check_niimg():
with assert_raises(TypeError) as cm:
_utils.check_niimg(0)
assert_true('image' in cm.exception.message
or 'affine' in cm.exception.message)
with assert_raises(TypeError) as cm:
_utils.check_niimg([])
assert_true('image' in cm.exception.message
or 'affine' in cm.exception.message)
# Test ensure_3d
with assert_raises(TypeError) as cm:
_utils.check_niimg([
'test.nii',
], ensure_3d=True)
assert_true('3D' in cm.exception.message)
# 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
with assert_raises(TypeError) as cm:
_utils.check_niimg(data, ensure_3d=True)
assert_true('3D' in cm.exception.message)
# Test ensure_3d with a non 3D image
with assert_raises(TypeError) as cm:
_utils.check_niimg(data_img, ensure_3d=True)
assert_true('3D' in cm.exception.message)
# 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_intersect_masks_filename():
# Create dummy masks
mask_a = np.zeros((4, 4, 1), dtype=np.bool)
mask_a[2:4, 2:4] = 1
mask_a_img = Nifti1Image(mask_a.astype(int), np.eye(4))
# +---+---+---+---+
# | | | | |
# +---+---+---+---+
# | | | | |
# +---+---+---+---+
# | | | X | X |
# +---+---+---+---+
# | | | X | X |
# +---+---+---+---+
mask_b = np.zeros((4, 4, 1), dtype=np.bool)
mask_b[1:3, 1:3] = 1
mask_b_img = Nifti1Image(mask_b.astype(int), np.eye(4))
# +---+---+---+---+
# | | | | |
# +---+---+---+---+
# | | X | X | |
# +---+---+---+---+
# | | X | X | |
# +---+---+---+---+
# | | | | |
# +---+---+---+---+
with write_tmp_imgs(mask_a_img, mask_b_img, create_files=True)\
as filenames:
mask_ab = np.zeros((4, 4, 1), dtype=np.bool)
mask_ab[2, 2] = 1
mask_ab_ = intersect_masks(filenames, threshold=1.)
assert_array_equal(mask_ab, get_data(mask_ab_))
def test_intersect_masks_filename():
# Create dummy masks
mask_a = np.zeros((4, 4, 1), dtype=np.bool)
mask_a[2:4, 2:4] = 1
mask_a_img = Nifti1Image(mask_a.astype(int), np.eye(4))
# +---+---+---+---+
# | | | | |
# +---+---+---+---+
# | | | | |
# +---+---+---+---+
# | | | X | X |
# +---+---+---+---+
# | | | X | X |
# +---+---+---+---+
mask_b = np.zeros((4, 4, 1), dtype=np.bool)
mask_b[1:3, 1:3] = 1
mask_b_img = Nifti1Image(mask_b.astype(int), np.eye(4))
# +---+---+---+---+
# | | | | |
# +---+---+---+---+
# | | X | X | |
# +---+---+---+---+
# | | X | X | |
# +---+---+---+---+
# | | | | |
# +---+---+---+---+
with write_tmp_imgs(mask_a_img, mask_b_img, create_files=True)\
as filenames:
mask_ab = np.zeros((4, 4, 1), dtype=np.bool)
mask_ab[2, 2] = 1
mask_ab_ = intersect_masks(filenames, threshold=1.)
assert_array_equal(mask_ab, mask_ab_.get_data())
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 = signal_extraction.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_regex(DimensionError, _TEST_DIM_ERROR_MSG,
signal_extraction.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 range(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 = signal_extraction.img_to_signals_labels(data_img,
labels_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == list(range(1, 9)))
with write_tmp_imgs(data_img) as fname_img:
signals_r, labels_r = signal_extraction.img_to_signals_labels(
fname_img, labels_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == list(range(1, 9)))
# Same thing, with mask.
assert_raises_regex(DimensionError, _TEST_DIM_ERROR_MSG,
signal_extraction.img_to_signals_labels, data_img,
labels_img, mask_img=mask_4d_img)
assert_raises_regex(DimensionError, _TEST_DIM_ERROR_MSG,
signal_extraction.signals_to_img_labels, data_img,
labels_img, mask_img=mask_4d_img)
data_img = signal_extraction.signals_to_img_labels(signals, labels_img,
mask_img=mask_img)
assert_raises(TypeError, signal_extraction.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 = signal_extraction.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 range(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 = signal_extraction.img_to_signals_labels(
data_img, labels_img, mask_img=mask_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == list(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, signal_extraction.img_to_signals_labels,
data_img, bad_labels1_img)
assert_raises(ValueError, signal_extraction.img_to_signals_labels,
data_img, bad_labels2_img)
assert_raises(ValueError, signal_extraction.img_to_signals_labels,
data_img, bad_labels1_img, mask_img=good_mask_img)
assert_raises(ValueError, signal_extraction.img_to_signals_labels,
data_img, bad_labels2_img, mask_img=good_mask_img)
assert_raises(ValueError, signal_extraction.img_to_signals_labels,
data_img, good_labels_img, mask_img=bad_mask1_img)
assert_raises(ValueError, signal_extraction.img_to_signals_labels,
data_img, good_labels_img, mask_img=bad_mask2_img)
def test_nifti_labels_masker_resampling():
# Test resampling in NiftiLabelsMasker
shape1 = (10, 11, 12)
affine = np.eye(4)
# mask
shape2 = (16, 17, 18)
# labels
shape3 = (13, 14, 15)
n_regions = 9
length = 3
# With data of the same affine
fmri11_img, _ = generate_random_img(shape1, affine=affine,
length=length)
_, mask22_img = generate_random_img(shape2, affine=affine,
length=length)
labels33_img = testing.generate_labeled_regions(shape3, n_regions,
affine=affine)
# Test error checking
assert_raises(ValueError, NiftiLabelsMasker, labels33_img,
resampling_target="mask")
assert_raises(ValueError, NiftiLabelsMasker, labels33_img,
resampling_target="invalid")
# Target: labels
masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img,
resampling_target="labels")
masker.fit()
np.testing.assert_almost_equal(masker.labels_img_.get_affine(),
labels33_img.get_affine())
assert_equal(masker.labels_img_.shape, labels33_img.shape)
np.testing.assert_almost_equal(masker.mask_img_.get_affine(),
masker.labels_img_.get_affine())
assert_equal(masker.mask_img_.shape, masker.labels_img_.shape[:3])
transformed = masker.transform(fmri11_img)
assert_equal(transformed.shape, (length, n_regions))
fmri11_img_r = masker.inverse_transform(transformed)
np.testing.assert_almost_equal(fmri11_img_r.get_affine(),
masker.labels_img_.get_affine())
assert_equal(fmri11_img_r.shape,
(masker.labels_img_.shape[:3] + (length,)))
# Test with clipped labels: mask does not contain all labels.
# Shapes do matter in that case, because there is some resampling
# taking place.
shape1 = (10, 11, 12) # fmri
shape2 = (8, 9, 10) # mask
shape3 = (16, 18, 20) # maps
n_regions = 9
length = 21
fmri11_img, _ = generate_random_img(shape1, affine=affine,
length=length)
_, mask22_img = generate_random_img(shape2, affine=affine,
length=length)
# Target: labels
labels33_img = testing.generate_labeled_regions(shape3, n_regions,
affine=affine)
masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img,
resampling_target="labels")
masker.fit()
np.testing.assert_almost_equal(masker.labels_img_.get_affine(),
labels33_img.get_affine())
assert_equal(masker.labels_img_.shape, labels33_img.shape)
np.testing.assert_almost_equal(masker.mask_img_.get_affine(),
masker.labels_img_.get_affine())
assert_equal(masker.mask_img_.shape, masker.labels_img_.shape[:3])
uniq_labels = np.unique(masker.labels_img_.get_data())
assert_equal(uniq_labels[0], 0)
assert_equal(len(uniq_labels) - 1, n_regions)
transformed = masker.transform(fmri11_img)
assert_equal(transformed.shape, (length, n_regions))
# Some regions have been clipped. Resulting signal must be zero
assert_less((transformed.var(axis=0) == 0).sum(), n_regions)
fmri11_img_r = masker.inverse_transform(transformed)
np.testing.assert_almost_equal(fmri11_img_r.get_affine(),
masker.labels_img_.get_affine())
assert_equal(fmri11_img_r.shape,
(masker.labels_img_.shape[:3] + (length,)))
# Test with data and atlas of different shape: the atlas should be
# resampled to the data
shape22 = (5, 5, 6)
affine2 = 2 * np.eye(4)
affine2[-1, -1] = 1
fmri22_img, _ = generate_random_img(shape22, affine=affine2,
length=length)
masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img)
masker.fit_transform(fmri22_img)
np.testing.assert_array_equal(
masker._resampled_labels_img_.get_affine(),
affine2)
# Test with filenames
with testing.write_tmp_imgs(fmri22_img) as filename:
masker = NiftiLabelsMasker(labels33_img, resampling_target='data')
masker.fit_transform(filename)
def test_largest_cc_img():
""" Check the extraction of the largest connected component, for niftis
Similiar to smooth_img tests for largest connected_component_img, here also
only the added features for largest_connected_component are tested.
"""
# Test whether dimension of 3Dimg and list of 3Dimgs are kept.
shapes = ((10, 11, 12), (13, 14, 15))
regions = [1, 3]
img1 = data_gen.generate_labeled_regions(shape=shapes[0],
n_regions=regions[0])
img2 = data_gen.generate_labeled_regions(shape=shapes[1],
n_regions=regions[1])
for create_files in (False, True):
with testing.write_tmp_imgs(img1, img2,
create_files=create_files) as imgs:
# List of images as input
out = largest_connected_component_img(imgs)
assert_true(isinstance(out, list))
assert_true(len(out) == 2)
for o, s in zip(out, shapes):
assert_true(o.shape == (s))
# Single image as input
out = largest_connected_component_img(imgs[0])
assert_true(isinstance(out, Nifti1Image))
assert_true(out.shape == (shapes[0]))
# Test whether 4D Nifti throws the right error.
img_4D = data_gen.generate_fake_fmri(shapes[0], length=17)
assert_raises(DimensionError, largest_connected_component_img, img_4D)
# tests adapted to non-native endian data dtype
img1_change_dtype = nibabel.Nifti1Image(img1.get_data().astype('>f8'),
affine=img1.affine)
img2_change_dtype = nibabel.Nifti1Image(img2.get_data().astype('>f8'),
affine=img2.affine)
for create_files in (False, True):
with testing.write_tmp_imgs(img1_change_dtype, img2_change_dtype,
create_files=create_files) as imgs:
# List of images as input
out = largest_connected_component_img(imgs)
assert_true(isinstance(out, list))
assert_true(len(out) == 2)
for o, s in zip(out, shapes):
assert_true(o.shape == (s))
# Single image as input
out = largest_connected_component_img(imgs[0])
assert_true(isinstance(out, Nifti1Image))
assert_true(out.shape == (shapes[0]))
# Test the output with native and without native
out_native = largest_connected_component_img(img1)
out_non_native = largest_connected_component_img(img1_change_dtype)
np.testing.assert_equal(out_native.get_data(), out_non_native.get_data())
def test_nifti_labels_masker_resampling():
# Test resampling in NiftiLabelsMasker
shape1 = (10, 11, 12)
affine = np.eye(4)
# mask
shape2 = (16, 17, 18)
# labels
shape3 = (13, 14, 15)
n_regions = 9
length = 3
# With data of the same affine
fmri11_img, _ = generate_random_img(shape1, affine=affine, length=length)
_, mask22_img = generate_random_img(shape2, affine=affine, length=length)
labels33_img = testing.generate_labeled_regions(shape3,
n_regions,
affine=affine)
# Test error checking
assert_raises(ValueError,
NiftiLabelsMasker,
labels33_img,
resampling_target="mask")
assert_raises(ValueError,
NiftiLabelsMasker,
labels33_img,
resampling_target="invalid")
# Target: labels
masker = NiftiLabelsMasker(labels33_img,
mask_img=mask22_img,
resampling_target="labels")
masker.fit()
np.testing.assert_almost_equal(get_affine(masker.labels_img_),
get_affine(labels33_img))
assert_equal(masker.labels_img_.shape, labels33_img.shape)
np.testing.assert_almost_equal(get_affine(masker.mask_img_),
get_affine(masker.labels_img_))
assert_equal(masker.mask_img_.shape, masker.labels_img_.shape[:3])
transformed = masker.transform(fmri11_img)
assert_equal(transformed.shape, (length, n_regions))
fmri11_img_r = masker.inverse_transform(transformed)
np.testing.assert_almost_equal(get_affine(fmri11_img_r),
get_affine(masker.labels_img_))
assert_equal(fmri11_img_r.shape,
(masker.labels_img_.shape[:3] + (length, )))
# Test with clipped labels: mask does not contain all labels.
# Shapes do matter in that case, because there is some resampling
# taking place.
shape1 = (10, 11, 12) # fmri
shape2 = (8, 9, 10) # mask
shape3 = (16, 18, 20) # maps
n_regions = 9
length = 21
fmri11_img, _ = generate_random_img(shape1, affine=affine, length=length)
_, mask22_img = generate_random_img(shape2, affine=affine, length=length)
# Target: labels
labels33_img = testing.generate_labeled_regions(shape3,
n_regions,
affine=affine)
masker = NiftiLabelsMasker(labels33_img,
mask_img=mask22_img,
resampling_target="labels")
masker.fit()
np.testing.assert_almost_equal(get_affine(masker.labels_img_),
get_affine(labels33_img))
assert_equal(masker.labels_img_.shape, labels33_img.shape)
np.testing.assert_almost_equal(get_affine(masker.mask_img_),
get_affine(masker.labels_img_))
assert_equal(masker.mask_img_.shape, masker.labels_img_.shape[:3])
uniq_labels = np.unique(masker.labels_img_.get_data())
assert_equal(uniq_labels[0], 0)
assert_equal(len(uniq_labels) - 1, n_regions)
transformed = masker.transform(fmri11_img)
assert_equal(transformed.shape, (length, n_regions))
# Some regions have been clipped. Resulting signal must be zero
assert_less((transformed.var(axis=0) == 0).sum(), n_regions)
fmri11_img_r = masker.inverse_transform(transformed)
np.testing.assert_almost_equal(get_affine(fmri11_img_r),
get_affine(masker.labels_img_))
assert_equal(fmri11_img_r.shape,
(masker.labels_img_.shape[:3] + (length, )))
# Test with data and atlas of different shape: the atlas should be
# resampled to the data
shape22 = (5, 5, 6)
affine2 = 2 * np.eye(4)
affine2[-1, -1] = 1
fmri22_img, _ = generate_random_img(shape22, affine=affine2, length=length)
masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img)
masker.fit_transform(fmri22_img)
np.testing.assert_array_equal(get_affine(masker._resampled_labels_img_),
affine2)
# Test with filenames
with testing.write_tmp_imgs(fmri22_img) as filename:
masker = NiftiLabelsMasker(labels33_img, resampling_target='data')
masker.fit_transform(filename)
def test_apply_mask():
""" Test smoothing of timeseries extraction
"""
# A delta in 3D
# Standard masking
data = np.zeros((40, 40, 40, 2))
data[20, 20, 20] = 1
mask = np.ones((40, 40, 40))
full_mask = np.zeros((40, 40, 40))
for create_files in (False, True):
for affine in (np.eye(4), np.diag((1, 1, -1, 1)),
np.diag((.5, 1, .5, 1))):
data_img = Nifti1Image(data, affine)
mask_img = Nifti1Image(mask, affine)
with write_tmp_imgs(data_img, mask_img, create_files=create_files)\
as filenames:
series = masking.apply_mask(filenames[0], filenames[1],
smoothing_fwhm=9)
series = np.reshape(series[0, :], (40, 40, 40))
vmax = series.max()
# We are expecting a full-width at half maximum of
# 9mm/voxel_size:
above_half_max = series > .5 * vmax
for axis in (0, 1, 2):
proj = np.any(np.any(np.rollaxis(above_half_max,
axis=axis), axis=-1), axis=-1)
np.testing.assert_equal(proj.sum(),
9 / np.abs(affine[axis, axis]))
# Check that NaNs in the data do not propagate
data[10, 10, 10] = np.NaN
data_img = Nifti1Image(data, affine)
mask_img = Nifti1Image(mask, affine)
full_mask_img = Nifti1Image(full_mask, affine)
series = masking.apply_mask(data_img, mask_img, smoothing_fwhm=9)
assert_true(np.all(np.isfinite(series)))
# veriy that 4D masks are rejected
mask_img_4d = Nifti1Image(np.ones((40, 40, 40, 2)), np.eye(4))
assert_raises_regex(DimensionError, "Data must be a 3D",
masking.apply_mask, data_img, mask_img_4d)
# Check that 3D data is accepted
data_3d = Nifti1Image(np.arange(27).reshape((3, 3, 3)), np.eye(4))
mask_data_3d = np.zeros((3, 3, 3))
mask_data_3d[1, 1, 0] = True
mask_data_3d[0, 1, 0] = True
mask_data_3d[0, 1, 1] = True
data_3d = masking.apply_mask(data_3d, Nifti1Image(mask_data_3d, np.eye(4)))
assert_equal(sorted(data_3d.tolist()), [3., 4., 12.])
# Check data shape and affine
assert_raises_regex(DimensionError, "Data must be a 3D",
masking.apply_mask, data_img,
Nifti1Image(mask[20, ...], affine))
assert_raises(ValueError, masking.apply_mask,
data_img, Nifti1Image(mask, affine / 2.))
# Check that full masking raises error
assert_raises(ValueError, masking.apply_mask,
data_img, full_mask_img)
# Check weird values in data
mask[10, 10, 10] = 2
assert_raises(ValueError, masking.apply_mask,
data_img, Nifti1Image(mask, affine))
mask[15, 15, 15] = 3
assert_raises(ValueError, masking.apply_mask,
Nifti1Image(data, affine), mask_img)
def test_unmask():
# A delta in 3D
shape = (10, 20, 30, 40)
generator = np.random.RandomState(42)
data4D = generator.rand(*shape)
data3D = data4D[..., 0]
mask = generator.randint(2, size=shape[:3])
mask_img = Nifti1Image(mask, np.eye(4))
mask = mask.astype(bool)
masked4D = data4D[mask, :].T
unmasked4D = data4D.copy()
unmasked4D[-mask, :] = 0
masked3D = data3D[mask]
unmasked3D = data3D.copy()
unmasked3D[-mask] = 0
# 4D Test, test value ordering at the same time.
t = unmask(masked4D, mask_img, order="C").get_data()
assert_equal(t.ndim, 4)
assert_true(t.flags["C_CONTIGUOUS"])
assert_false(t.flags["F_CONTIGUOUS"])
assert_array_equal(t, unmasked4D)
t = unmask([masked4D], mask_img, order="F")
t = [t_.get_data() for t_ in t]
assert_true(isinstance(t, list))
assert_equal(t[0].ndim, 4)
assert_false(t[0].flags["C_CONTIGUOUS"])
assert_true(t[0].flags["F_CONTIGUOUS"])
assert_array_equal(t[0], unmasked4D)
# 3D Test - check both with Nifti1Image and file
for create_files in (False, True):
with write_tmp_imgs(mask_img, create_files=create_files) as filename:
t = unmask(masked3D, filename, order="C").get_data()
assert_equal(t.ndim, 3)
assert_true(t.flags["C_CONTIGUOUS"])
assert_false(t.flags["F_CONTIGUOUS"])
assert_array_equal(t, unmasked3D)
t = unmask([masked3D], filename, order="F")
t = [t_.get_data() for t_ in t]
assert_true(isinstance(t, list))
assert_equal(t[0].ndim, 3)
assert_false(t[0].flags["C_CONTIGUOUS"])
assert_true(t[0].flags["F_CONTIGUOUS"])
assert_array_equal(t[0], unmasked3D)
# Error test: shape
vec_1D = np.empty((500,), dtype=np.int)
assert_raises(TypeError, unmask, vec_1D, mask_img)
assert_raises(TypeError, unmask, [vec_1D], mask_img)
vec_2D = np.empty((500, 500), dtype=np.float64)
assert_raises(TypeError, unmask, vec_2D, mask_img)
assert_raises(TypeError, unmask, [vec_2D], mask_img)
# Error test: mask type
assert_raises_regex(TypeError, 'mask must be a boolean array',
_unmask_3d, vec_1D, mask.astype(np.int))
assert_raises_regex(TypeError, 'mask must be a boolean array',
_unmask_4d, vec_2D, mask.astype(np.float64))
# Transposed vector
transposed_vector = np.ones((np.sum(mask), 1), dtype=np.bool)
assert_raises_regex(TypeError, 'X must be of shape',
unmask, transposed_vector, mask_img)
def test_nifti_maps_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, labels_mask_img = \
testing.generate_maps(shape1, n_regions, affine=affine1)
# No exception raised here
for create_files in (True, False):
with testing.write_tmp_imgs(labels11_img, create_files=create_files) \
as labels11:
masker11 = NiftiMapsMasker(labels11, resampling_target=None)
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
# enables to delete "labels11" on windows
del masker11
masker11 = NiftiMapsMasker(labels11_img,
mask_img=mask11_img,
resampling_target=None)
testing.assert_raises_regex(ValueError, 'has not been fitted. ',
masker11.transform, fmri11_img)
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
NiftiMapsMasker(labels11_img).fit_transform(fmri11_img)
# Test all kinds of mismatches between shapes and between affines
for create_files in (True, False):
with testing.write_tmp_imgs(labels11_img,
mask12_img,
create_files=create_files) as images:
labels11, mask12 = images
masker11 = NiftiMapsMasker(labels11, resampling_target=None)
masker11.fit()
assert_raises(ValueError, masker11.transform, fmri12_img)
assert_raises(ValueError, masker11.transform, fmri21_img)
masker11 = NiftiMapsMasker(labels11,
mask_img=mask12,
resampling_target=None)
assert_raises(ValueError, masker11.fit)
masker11 = NiftiMapsMasker(labels11_img,
mask_img=mask21_img,
resampling_target=None)
assert_raises(ValueError, masker11.fit)
# Transform, with smoothing (smoke test)
masker11 = NiftiMapsMasker(labels11_img,
smoothing_fwhm=3,
resampling_target=None)
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
masker11 = NiftiMapsMasker(labels11_img,
smoothing_fwhm=3,
resampling_target=None)
signals11 = masker11.fit_transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
testing.assert_raises_regex(
ValueError, 'has not been fitted. ',
NiftiMapsMasker(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(get_affine(fmri11_img_r),
get_affine(fmri11_img))
# Test with data and atlas of different shape: the atlas should be
# resampled to the data
shape22 = (5, 5, 6)
affine2 = 2 * np.eye(4)
affine2[-1, -1] = 1
fmri22_img, _ = generate_random_img(shape22, affine=affine2, length=length)
masker = NiftiMapsMasker(labels11_img, mask_img=mask21_img)
masker.fit_transform(fmri22_img)
np.testing.assert_array_equal(get_affine(masker._resampled_maps_img_),
affine2)
def test_unmask():
# A delta in 3D
shape = (10, 20, 30, 40)
generator = np.random.RandomState(42)
data4D = generator.rand(*shape)
data3D = data4D[..., 0]
mask = generator.randint(2, size=shape[:3])
mask_img = Nifti1Image(mask, np.eye(4))
mask = mask.astype(bool)
masked4D = data4D[mask, :].T
unmasked4D = data4D.copy()
unmasked4D[np.logical_not(mask), :] = 0
masked3D = data3D[mask]
unmasked3D = data3D.copy()
unmasked3D[np.logical_not(mask)] = 0
# 4D Test, test value ordering at the same time.
t = get_data(unmask(masked4D, mask_img, order="C"))
assert_equal(t.ndim, 4)
assert_true(t.flags["C_CONTIGUOUS"])
assert_false(t.flags["F_CONTIGUOUS"])
assert_array_equal(t, unmasked4D)
t = unmask([masked4D], mask_img, order="F")
t = [get_data(t_) for t_ in t]
assert_true(isinstance(t, list))
assert_equal(t[0].ndim, 4)
assert_false(t[0].flags["C_CONTIGUOUS"])
assert_true(t[0].flags["F_CONTIGUOUS"])
assert_array_equal(t[0], unmasked4D)
# 3D Test - check both with Nifti1Image and file
for create_files in (False, True):
with write_tmp_imgs(mask_img, create_files=create_files) as filename:
t = get_data(unmask(masked3D, filename, order="C"))
assert_equal(t.ndim, 3)
assert_true(t.flags["C_CONTIGUOUS"])
assert_false(t.flags["F_CONTIGUOUS"])
assert_array_equal(t, unmasked3D)
t = unmask([masked3D], filename, order="F")
t = [get_data(t_) for t_ in t]
assert_true(isinstance(t, list))
assert_equal(t[0].ndim, 3)
assert_false(t[0].flags["C_CONTIGUOUS"])
assert_true(t[0].flags["F_CONTIGUOUS"])
assert_array_equal(t[0], unmasked3D)
# Error test: shape
vec_1D = np.empty((500, ), dtype=np.int)
assert_raises(TypeError, unmask, vec_1D, mask_img)
assert_raises(TypeError, unmask, [vec_1D], mask_img)
vec_2D = np.empty((500, 500), dtype=np.float64)
assert_raises(TypeError, unmask, vec_2D, mask_img)
assert_raises(TypeError, unmask, [vec_2D], mask_img)
# Error test: mask type
assert_raises_regex(TypeError, 'mask must be a boolean array', _unmask_3d,
vec_1D, mask.astype(np.int))
assert_raises_regex(TypeError, 'mask must be a boolean array', _unmask_4d,
vec_2D, mask.astype(np.float64))
# Transposed vector
transposed_vector = np.ones((np.sum(mask), 1), dtype=np.bool)
assert_raises_regex(TypeError, 'X must be of shape', unmask,
transposed_vector, mask_img)
def test_check_niimg_wildcards():
tmp_dir = tempfile.tempdir + os.sep
nofile_path = "/tmp/nofile"
nofile_path_wildcards = "/tmp/no*file"
wildcards_msg = ("No files matching the entered niimg expression: "
"'%s'.\n You may have left wildcards usage "
"activated: please set the global constant "
"'nilearn.EXPAND_PATH_WILDCARDS' to False to "
"deactivate this behavior.")
file_not_found_msg = "File not found: '%s'"
assert_equal(ni.EXPAND_PATH_WILDCARDS, True)
# Check bad filename
# Non existing file (with no magic) raise a ValueError exception
assert_raises_regex(ValueError, file_not_found_msg % nofile_path,
_utils.check_niimg, nofile_path)
# Non matching wildcard raises a ValueError exception
assert_raises_regex(ValueError,
wildcards_msg % re.escape(nofile_path_wildcards),
_utils.check_niimg, nofile_path_wildcards)
# First create some testing data
data_3d = np.zeros((40, 40, 40))
data_3d[20, 20, 20] = 1
img_3d = Nifti1Image(data_3d, np.eye(4))
data_4d = np.zeros((40, 40, 40, 3))
data_4d[20, 20, 20] = 1
img_4d = Nifti1Image(data_4d, np.eye(4))
#######
# Testing with an existing filename
with testing.write_tmp_imgs(img_3d, create_files=True) as filename:
assert_array_equal(_utils.check_niimg(filename).get_data(),
img_3d.get_data())
# No globbing behavior
with testing.write_tmp_imgs(img_3d, create_files=True) as filename:
assert_array_equal(_utils.check_niimg(filename,
wildcards=False).get_data(),
img_3d.get_data())
#######
# Testing with an existing filename
with testing.write_tmp_imgs(img_4d, create_files=True) as filename:
assert_array_equal(_utils.check_niimg(filename).get_data(),
img_4d.get_data())
# No globbing behavior
with testing.write_tmp_imgs(img_4d, create_files=True) as filename:
assert_array_equal(_utils.check_niimg(filename,
wildcards=False).get_data(),
img_4d.get_data())
#######
# Testing with a glob matching exactly one filename
# Using a glob matching one file containing a 3d image returns a 4d image
# with 1 as last dimension.
with testing.write_tmp_imgs(img_3d,
create_files=True,
use_wildcards=True) as globs:
glob_input = tmp_dir + globs
assert_array_equal(_utils.check_niimg(glob_input).get_data()[..., 0],
img_3d.get_data())
# Disabled globbing behavior should raise an ValueError exception
with testing.write_tmp_imgs(img_3d,
create_files=True,
use_wildcards=True) as globs:
glob_input = tmp_dir + globs
assert_raises_regex(ValueError,
file_not_found_msg % re.escape(glob_input),
_utils.check_niimg,
glob_input,
wildcards=False)
#######
# Testing with a glob matching multiple filenames
img_4d = _utils.check_niimg_4d((img_3d, img_3d))
with testing.write_tmp_imgs(img_3d, img_3d,
create_files=True,
use_wildcards=True) as globs:
assert_array_equal(_utils.check_niimg(glob_input).get_data(),
img_4d.get_data())
#######
# Test when global variable is set to False => no globbing allowed
ni.EXPAND_PATH_WILDCARDS = False
# Non existing filename (/tmp/nofile) could match an existing one through
# globbing but global wildcards variable overrides this feature => raises
# a ValueError
assert_raises_regex(ValueError,
file_not_found_msg % nofile_path,
_utils.check_niimg, nofile_path)
# Verify wildcards function parameter has no effect
assert_raises_regex(ValueError,
file_not_found_msg % nofile_path,
_utils.check_niimg, nofile_path, wildcards=False)
# Testing with an exact filename matching (3d case)
with testing.write_tmp_imgs(img_3d, create_files=True) as filename:
assert_array_equal(_utils.check_niimg(filename).get_data(),
img_3d.get_data())
# Testing with an exact filename matching (4d case)
with testing.write_tmp_imgs(img_4d, create_files=True) as filename:
assert_array_equal(_utils.check_niimg(filename).get_data(),
img_4d.get_data())
# Reverting to default behavior
ni.EXPAND_PATH_WILDCARDS = True
def test_nifti_maps_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, labels_mask_img = \
testing.generate_maps(shape1, n_regions, affine=affine1)
# No exception raised here
for create_files in (True, False):
with testing.write_tmp_imgs(labels11_img, create_files=create_files) \
as labels11:
masker11 = NiftiMapsMasker(labels11, resampling_target=None)
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
# enables to delete "labels11" on windows
del masker11
masker11 = NiftiMapsMasker(labels11_img, mask_img=mask11_img,
resampling_target=None)
testing.assert_raises_regex(
ValueError, 'has not been fitted. ',
masker11.transform, fmri11_img)
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
NiftiMapsMasker(labels11_img).fit_transform(fmri11_img)
# Test all kinds of mismatches between shapes and between affines
for create_files in (True, False):
with testing.write_tmp_imgs(labels11_img, mask12_img,
create_files=create_files) as images:
labels11, mask12 = images
masker11 = NiftiMapsMasker(labels11, resampling_target=None)
masker11.fit()
assert_raises(ValueError, masker11.transform, fmri12_img)
assert_raises(ValueError, masker11.transform, fmri21_img)
masker11 = NiftiMapsMasker(labels11, mask_img=mask12,
resampling_target=None)
assert_raises(ValueError, masker11.fit)
del masker11
masker11 = NiftiMapsMasker(labels11_img, mask_img=mask21_img,
resampling_target=None)
assert_raises(ValueError, masker11.fit)
# Transform, with smoothing (smoke test)
masker11 = NiftiMapsMasker(labels11_img, smoothing_fwhm=3,
resampling_target=None)
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
masker11 = NiftiMapsMasker(labels11_img, smoothing_fwhm=3,
resampling_target=None)
signals11 = masker11.fit_transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
testing.assert_raises_regex(
ValueError, 'has not been fitted. ',
NiftiMapsMasker(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(get_affine(fmri11_img_r),
get_affine(fmri11_img))
# Test with data and atlas of different shape: the atlas should be
# resampled to the data
shape22 = (5, 5, 6)
affine2 = 2 * np.eye(4)
affine2[-1, -1] = 1
fmri22_img, _ = generate_random_img(shape22, affine=affine2,
length=length)
masker = NiftiMapsMasker(labels11_img, mask_img=mask21_img)
masker.fit_transform(fmri22_img)
np.testing.assert_array_equal(
get_affine(masker._resampled_maps_img_),
affine2)
