def test_nifti_maps_masker_with_nans():
length = 3
n_regions = 8
fmri_img, mask_img = generate_random_img((13, 11, 12),
affine=np.eye(4),
length=length)
maps_img, maps_mask_img = data_gen.generate_maps((13, 11, 12),
n_regions,
affine=np.eye(4))
# nans
maps_data = maps_img.get_data()
mask_data = mask_img.get_data()
maps_data[:, 9, 9] = np.nan
maps_data[:, 5, 5] = np.inf
mask_data[:, :, 7] = np.nan
mask_data[:, :, 5] = np.inf
maps_img = nibabel.Nifti1Image(maps_data, np.eye(4))
mask_img = nibabel.Nifti1Image(mask_data, np.eye(4))
masker = NiftiMapsMasker(maps_img, mask_img=mask_img)
sig = masker.fit_transform(fmri_img)
assert_equal(sig.shape, (length, n_regions))
assert_true(np.all(np.isfinite(sig)))
def test_nifti_maps_masker_overlap():
# Test resampling in NiftiMapsMasker
affine = np.eye(4)
shape = (5, 5, 5)
length = 10
fmri_img, _ = generate_random_img(shape, affine=affine,
length=length)
non_overlapping_maps = np.zeros(shape + (2,))
non_overlapping_maps[:2, :, :, 0] = 1.
non_overlapping_maps[2:, :, :, 1] = 1.
non_overlapping_maps_img = nibabel.Nifti1Image(non_overlapping_maps,
affine)
overlapping_maps = np.zeros(shape + (2,))
overlapping_maps[:3, :, :, 0] = 1.
overlapping_maps[2:, :, :, 1] = 1.
overlapping_maps_img = nibabel.Nifti1Image(overlapping_maps, affine)
overlapping_masker = NiftiMapsMasker(non_overlapping_maps_img,
allow_overlap=True)
overlapping_masker.fit_transform(fmri_img)
overlapping_masker = NiftiMapsMasker(overlapping_maps_img,
allow_overlap=True)
overlapping_masker.fit_transform(fmri_img)
non_overlapping_masker = NiftiMapsMasker(non_overlapping_maps_img,
allow_overlap=False)
non_overlapping_masker.fit_transform(fmri_img)
non_overlapping_masker = NiftiMapsMasker(overlapping_maps_img,
allow_overlap=False)
assert_raises_regex(ValueError, 'Overlap detected',
non_overlapping_masker.fit_transform, fmri_img)
def test_nifti_maps_masker_with_nans_and_infs_in_data():
"""Apply a NiftiMapsMasker to 4D data containing NaNs and infs.
The masker should replace those NaNs and infs with zeros,
while raising a warning.
"""
length = 3
n_regions = 8
fmri_img, mask_img = generate_random_img((13, 11, 12),
affine=np.eye(4),
length=length)
maps_img, maps_mask_img = data_gen.generate_maps((13, 11, 12),
n_regions,
affine=np.eye(4))
# Add NaNs and infs to data
fmri_data = get_data(fmri_img)
fmri_data[:, 9, 9, :] = np.nan
fmri_data[:, 5, 5, :] = np.inf
fmri_img = nibabel.Nifti1Image(fmri_data, np.eye(4))
masker = NiftiMapsMasker(maps_img, mask_img=mask_img)
with pytest.warns(UserWarning, match="Non-finite values detected."):
sig = masker.fit_transform(fmri_img)
assert sig.shape == (length, n_regions)
assert np.all(np.isfinite(sig))
def test_standardization():
data_shape = (9, 9, 5)
n_samples = 500
signals = np.random.randn(np.prod(data_shape), n_samples)
means = np.random.randn(np.prod(data_shape), 1) * 50 + 1000
signals += means
img = nibabel.Nifti1Image(signals.reshape(data_shape + (n_samples, )),
np.eye(4))
maps, _ = data_gen.generate_maps((9, 9, 5), 10)
# Unstandarized
masker = NiftiMapsMasker(maps, standardize=False)
unstandarized_label_signals = masker.fit_transform(img)
# z-score
masker = NiftiMapsMasker(maps, standardize='zscore')
trans_signals = masker.fit_transform(img)
np.testing.assert_almost_equal(trans_signals.mean(0), 0)
np.testing.assert_almost_equal(trans_signals.std(0), 1)
# psc
masker = NiftiMapsMasker(maps, standardize='psc')
trans_signals = masker.fit_transform(img)
np.testing.assert_almost_equal(trans_signals.mean(0), 0)
np.testing.assert_almost_equal(
trans_signals,
unstandarized_label_signals / unstandarized_label_signals.mean(0) * 100
- 100,
)
def test_3d_images():
# Test that the NiftiMapsMasker works with 3D images
affine = np.eye(4)
n_regions = 3
shape3 = (16, 17, 18)
maps33_img, _ = data_gen.generate_maps(shape3, n_regions)
mask_img = nibabel.Nifti1Image(np.ones(shape3, dtype=np.int8),
affine=affine)
epi_img1 = nibabel.Nifti1Image(np.ones(shape3), affine=affine)
epi_img2 = nibabel.Nifti1Image(np.ones(shape3), affine=affine)
masker = NiftiMapsMasker(maps33_img, mask_img=mask_img)
epis = masker.fit_transform(epi_img1)
assert (epis.shape == (1, 3))
epis = masker.fit_transform([epi_img1, epi_img2])
assert (epis.shape == (2, 3))
def test_nifti_maps_masker_with_nans_and_infs():
"""Apply a NiftiMapsMasker containing NaNs and infs.
The masker should replace those NaNs and infs with zeros,
without raising a warning.
"""
length = 3
n_regions = 8
fmri_img, mask_img = generate_random_img((13, 11, 12),
affine=np.eye(4),
length=length)
maps_img, maps_mask_img = data_gen.generate_maps((13, 11, 12),
n_regions,
affine=np.eye(4))
# Add NaNs and infs to atlas
maps_data = get_data(maps_img).astype(np.float32)
mask_data = get_data(mask_img).astype(np.float32)
maps_data = maps_data * mask_data[..., None]
# Choose a good voxel from the first label
vox_idx = np.where(maps_data[..., 0] > 0)
i1, j1, k1 = vox_idx[0][0], vox_idx[1][0], vox_idx[2][0]
i2, j2, k2 = vox_idx[0][1], vox_idx[1][1], vox_idx[2][1]
maps_data[:, :, :, 0] = np.nan
maps_data[i2, j2, k2, 0] = np.inf
maps_data[i1, j1, k1, 0] = 1
maps_img = nibabel.Nifti1Image(maps_data, np.eye(4))
# No warning, because maps_img is run through clean_img
# *before* _safe_get_data.
masker = NiftiMapsMasker(maps_img, mask_img=mask_img)
sig = masker.fit_transform(fmri_img)
assert sig.shape == (length, n_regions)
assert np.all(np.isfinite(sig))
def test_nifti_maps_masker_with_nans():
length = 3
n_regions = 8
fmri_img, mask_img = generate_random_img((13, 11, 12),
affine=np.eye(4), length=length)
maps_img, maps_mask_img = testing.generate_maps((13, 11, 12), n_regions,
affine=np.eye(4))
# nans
maps_data = maps_img.get_data()
mask_data = mask_img.get_data()
maps_data[:, 9, 9] = np.nan
maps_data[:, 5, 5] = np.inf
mask_data[:, :, 7] = np.nan
mask_data[:, :, 5] = np.inf
maps_img = nibabel.Nifti1Image(maps_data, np.eye(4))
mask_img = nibabel.Nifti1Image(mask_data, np.eye(4))
masker = NiftiMapsMasker(maps_img, mask_img=mask_img)
sig = masker.fit_transform(fmri_img)
assert_equal(sig.shape, (length, n_regions))
assert_true(np.all(np.isfinite(sig)))
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_nifti_maps_masker_overlap():
# Test resampling in NiftiMapsMasker
affine = np.eye(4)
shape = (5, 5, 5)
length = 10
fmri_img, _ = generate_random_img(shape, affine=affine, length=length)
non_overlapping_maps = np.zeros(shape + (2, ))
non_overlapping_maps[:2, :, :, 0] = 1.
non_overlapping_maps[2:, :, :, 1] = 1.
non_overlapping_maps_img = nibabel.Nifti1Image(non_overlapping_maps,
affine)
overlapping_maps = np.zeros(shape + (2, ))
overlapping_maps[:3, :, :, 0] = 1.
overlapping_maps[2:, :, :, 1] = 1.
overlapping_maps_img = nibabel.Nifti1Image(overlapping_maps, affine)
overlapping_masker = NiftiMapsMasker(non_overlapping_maps_img,
allow_overlap=True)
overlapping_masker.fit_transform(fmri_img)
overlapping_masker = NiftiMapsMasker(overlapping_maps_img,
allow_overlap=True)
overlapping_masker.fit_transform(fmri_img)
non_overlapping_masker = NiftiMapsMasker(non_overlapping_maps_img,
allow_overlap=False)
non_overlapping_masker.fit_transform(fmri_img)
non_overlapping_masker = NiftiMapsMasker(overlapping_maps_img,
allow_overlap=False)
assert_raises_regex(ValueError, 'Overlap detected',
non_overlapping_masker.fit_transform, fmri_img)
def test_nifti_maps_masker_2():
# Test resampling in NiftiMapsMasker
affine = np.eye(4)
shape1 = (10, 11, 12) # fmri
shape2 = (13, 14, 15) # mask
shape3 = (16, 17, 18) # maps
n_regions = 9
length = 3
fmri11_img, _ = generate_random_img(shape1, affine=affine, length=length)
_, mask22_img = generate_random_img(shape2, affine=affine, length=length)
maps33_img, _ = \
testing.generate_maps(shape3, n_regions, affine=affine)
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 = NiftiMapsMasker(maps33_img, mask_img=mask_img_4d)
testing.assert_raises_regex(
DimensionError, "Input data has incompatible dimensionality: "
"Expected dimension is 3D and you provided "
"a 4D image.", masker.fit)
# Test error checking
assert_raises(ValueError,
NiftiMapsMasker,
maps33_img,
resampling_target="mask")
assert_raises(ValueError,
NiftiMapsMasker,
maps33_img,
resampling_target="invalid")
# Target: mask
masker = NiftiMapsMasker(maps33_img,
mask_img=mask22_img,
resampling_target="mask")
masker.fit()
np.testing.assert_almost_equal(get_affine(masker.mask_img_),
get_affine(mask22_img))
assert_equal(masker.mask_img_.shape, mask22_img.shape)
np.testing.assert_almost_equal(get_affine(masker.mask_img_),
get_affine(masker.maps_img_))
assert_equal(masker.mask_img_.shape, masker.maps_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.maps_img_))
assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length, )))
# Target: maps
masker = NiftiMapsMasker(maps33_img,
mask_img=mask22_img,
resampling_target="maps")
masker.fit()
np.testing.assert_almost_equal(get_affine(masker.maps_img_),
get_affine(maps33_img))
assert_equal(masker.maps_img_.shape, maps33_img.shape)
np.testing.assert_almost_equal(get_affine(masker.mask_img_),
get_affine(masker.maps_img_))
assert_equal(masker.mask_img_.shape, masker.maps_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.maps_img_))
assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length, )))
# Test with clipped maps: mask does not contain all maps.
# Shapes do matter in that case
affine1 = np.eye(4)
shape1 = (10, 11, 12)
shape2 = (8, 9, 10) # mask
affine2 = np.diag((2, 2, 2, 1)) # just for mask
shape3 = (16, 18, 20) # maps
n_regions = 9
length = 21
fmri11_img, _ = generate_random_img(shape1, affine=affine1, length=length)
_, mask22_img = testing.generate_fake_fmri(shape2,
length=1,
affine=affine2)
# Target: maps
maps33_img, _ = \
testing.generate_maps(shape3, n_regions, affine=affine1)
masker = NiftiMapsMasker(maps33_img,
mask_img=mask22_img,
resampling_target="maps")
masker.fit()
np.testing.assert_almost_equal(get_affine(masker.maps_img_),
get_affine(maps33_img))
assert_equal(masker.maps_img_.shape, maps33_img.shape)
np.testing.assert_almost_equal(get_affine(masker.mask_img_),
get_affine(masker.maps_img_))
assert_equal(masker.mask_img_.shape, masker.maps_img_.shape[:3])
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.maps_img_))
assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length, )))
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)
def test_nifti_maps_masker_2():
# Test resampling in NiftiMapsMasker
affine = np.eye(4)
shape1 = (10, 11, 12) # fmri
shape2 = (13, 14, 15) # mask
shape3 = (16, 17, 18) # maps
n_regions = 9
length = 3
fmri11_img, _ = generate_random_img(shape1, affine=affine,
length=length)
_, mask22_img = generate_random_img(shape2, affine=affine,
length=length)
maps33_img, _ = \
testing.generate_maps(shape3, n_regions, affine=affine)
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 = NiftiMapsMasker(maps33_img, mask_img=mask_img_4d)
testing.assert_raises_regex(DimensionError,
"Input data has incompatible dimensionality: "
"Expected dimension is 3D and you provided "
"a 4D image.",
masker.fit)
# Test error checking
assert_raises(ValueError, NiftiMapsMasker, maps33_img,
resampling_target="mask")
assert_raises(ValueError, NiftiMapsMasker, maps33_img,
resampling_target="invalid")
# Target: mask
masker = NiftiMapsMasker(maps33_img, mask_img=mask22_img,
resampling_target="mask")
masker.fit()
np.testing.assert_almost_equal(get_affine(masker.mask_img_),
get_affine(mask22_img))
assert_equal(masker.mask_img_.shape, mask22_img.shape)
np.testing.assert_almost_equal(get_affine(masker.mask_img_),
get_affine(masker.maps_img_))
assert_equal(masker.mask_img_.shape, masker.maps_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.maps_img_))
assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length,)))
# Target: maps
masker = NiftiMapsMasker(maps33_img, mask_img=mask22_img,
resampling_target="maps")
masker.fit()
np.testing.assert_almost_equal(get_affine(masker.maps_img_),
get_affine(maps33_img))
assert_equal(masker.maps_img_.shape, maps33_img.shape)
np.testing.assert_almost_equal(get_affine(masker.mask_img_),
get_affine(masker.maps_img_))
assert_equal(masker.mask_img_.shape, masker.maps_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.maps_img_))
assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length,)))
# Test with clipped maps: mask does not contain all maps.
# Shapes do matter in that case
affine1 = np.eye(4)
shape1 = (10, 11, 12)
shape2 = (8, 9, 10) # mask
affine2 = np.diag((2, 2, 2, 1)) # just for mask
shape3 = (16, 18, 20) # maps
n_regions = 9
length = 21
fmri11_img, _ = generate_random_img(shape1, affine=affine1, length=length)
_, mask22_img = testing.generate_fake_fmri(shape2, length=1,
affine=affine2)
# Target: maps
maps33_img, _ = \
testing.generate_maps(shape3, n_regions, affine=affine1)
masker = NiftiMapsMasker(maps33_img, mask_img=mask22_img,
resampling_target="maps")
masker.fit()
np.testing.assert_almost_equal(get_affine(masker.maps_img_),
get_affine(maps33_img))
assert_equal(masker.maps_img_.shape, maps33_img.shape)
np.testing.assert_almost_equal(get_affine(masker.mask_img_),
get_affine(masker.maps_img_))
assert_equal(masker.mask_img_.shape, masker.maps_img_.shape[:3])
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.maps_img_))
assert_equal(fmri11_img_r.shape,
(masker.maps_img_.shape[:3] + (length,)))