def test_signal_extraction_with_maps_and_labels():
shape = (4, 5, 6)
n_regions = 7
length = 8
# Generate labels
labels = list(range(n_regions + 1)) # 0 is background
labels_img = generate_labeled_regions(shape, n_regions, labels=labels)
labels_data = get_data(labels_img)
# Convert to maps
maps_data = np.zeros(shape + (n_regions, ))
for n, l in enumerate(labels):
if n == 0:
continue
maps_data[labels_data == l, n - 1] = 1
maps_img = nibabel.Nifti1Image(maps_data, labels_img.affine)
# Generate fake data
fmri_img, _ = generate_fake_fmri(shape=shape,
length=length,
affine=labels_img.affine)
# Extract signals from maps and labels: results must be identical.
maps_signals, maps_labels = signal_extraction.img_to_signals_maps(
fmri_img, maps_img)
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img)
np.testing.assert_almost_equal(maps_signals, labels_signals)
# Same thing with a mask, containing only 3 regions.
mask_data = (labels_data == 1) + (labels_data == 2) + (labels_data == 5)
mask_img = nibabel.Nifti1Image(mask_data.astype(np.int8),
labels_img.affine)
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img, mask_img=mask_img)
maps_signals, maps_labels = signal_extraction.img_to_signals_maps(
fmri_img, maps_img, mask_img=mask_img)
np.testing.assert_almost_equal(maps_signals, labels_signals)
assert_true(maps_signals.shape[1] == n_regions)
assert_true(maps_labels == list(range(len(maps_labels))))
assert_true(labels_signals.shape == (length, n_regions))
assert_true(labels_labels == labels[1:])
# Inverse operation (mostly smoke test)
labels_img_r = signal_extraction.signals_to_img_labels(labels_signals,
labels_img,
mask_img=mask_img)
assert_true(labels_img_r.shape == shape + (length, ))
maps_img_r = signal_extraction.signals_to_img_maps(maps_signals,
maps_img,
mask_img=mask_img)
assert_true(maps_img_r.shape == shape + (length, ))
# Check that NaNs in regions inside mask are preserved
region1 = labels_data == 2
indices = [ind[:1] for ind in np.where(region1)]
get_data(fmri_img)[indices + [slice(None)]] = float('nan')
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img, mask_img=mask_img)
assert_true(np.all(np.isnan(labels_signals[:, labels_labels.index(2)])))
def test_signal_extraction_with_maps_and_labels():
shape = (4, 5, 6)
n_regions = 7
length = 8
# Generate labels
labels = list(range(n_regions + 1)) # 0 is background
labels_img = generate_labeled_regions(shape, n_regions, labels=labels)
labels_data = labels_img.get_data()
# Convert to maps
maps_data = np.zeros(shape + (n_regions,))
for n, l in enumerate(labels):
if n == 0:
continue
maps_data[labels_data == l, n - 1] = 1
maps_img = nibabel.Nifti1Image(maps_data, labels_img.affine)
# Generate fake data
fmri_img, _ = generate_fake_fmri(shape=shape, length=length,
affine=labels_img.affine)
# Extract signals from maps and labels: results must be identical.
maps_signals, maps_labels = signal_extraction.img_to_signals_maps(
fmri_img, maps_img)
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img)
np.testing.assert_almost_equal(maps_signals, labels_signals)
# Same thing with a mask, containing only 3 regions.
mask_data = (labels_data == 1) + (labels_data == 2) + (labels_data == 5)
mask_img = nibabel.Nifti1Image(mask_data.astype(np.int8),
labels_img.affine)
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img, mask_img=mask_img)
maps_signals, maps_labels = signal_extraction.img_to_signals_maps(
fmri_img, maps_img, mask_img=mask_img)
np.testing.assert_almost_equal(maps_signals, labels_signals)
assert_true(maps_signals.shape[1] == n_regions)
assert_true(maps_labels == list(range(len(maps_labels))))
assert_true(labels_signals.shape == (length, n_regions))
assert_true(labels_labels == labels[1:])
# Inverse operation (mostly smoke test)
labels_img_r = signal_extraction.signals_to_img_labels(
labels_signals, labels_img, mask_img=mask_img)
assert_true(labels_img_r.shape == shape + (length,))
maps_img_r = signal_extraction.signals_to_img_maps(
maps_signals, maps_img, mask_img=mask_img)
assert_true(maps_img_r.shape == shape + (length,))
# Check that NaNs in regions inside mask are preserved
region1 = labels_data == 2
indices = [ind[:1] for ind in np.where(region1)]
fmri_img.get_data()[indices + [slice(None)]] = float('nan')
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img, mask_img=mask_img)
assert_true(np.all(np.isnan(labels_signals[:, labels_labels.index(2)])))
def test_signal_extraction_with_maps():
shape = (10, 11, 12)
n_regions = 9
n_instants = 13
# Generate signals
rand_gen = np.random.RandomState(0)
maps_img, mask_img = generate_maps(shape, n_regions, border=1)
maps_data = get_data(maps_img)
data = np.zeros(shape + (n_instants, ), dtype=np.float32)
mask_4d_img = nibabel.Nifti1Image(np.ones((shape + (2, ))), np.eye(4))
signals = np.zeros((n_instants, maps_data.shape[-1]))
for n in range(maps_data.shape[-1]):
signals[:, n] = rand_gen.randn(n_instants)
data[maps_data[..., n] > 0, :] = signals[:, n]
img = nibabel.Nifti1Image(data, np.eye(4))
# verify that 4d masks are refused
assert_raises_regex(TypeError,
_TEST_DIM_ERROR_MSG,
signal_extraction.img_to_signals_maps,
img,
maps_img,
mask_img=mask_4d_img)
# Get signals
signals_r, labels = signal_extraction.img_to_signals_maps(
img, maps_img, mask_img=mask_img)
# The output must be identical to the input signals, because every region
# is homogeneous: there is the same signal in all voxels of one given
# region (and all maps are uniform).
np.testing.assert_almost_equal(signals, signals_r)
# Same thing without mask (in that case)
signals_r, labels = signal_extraction.img_to_signals_maps(img, maps_img)
np.testing.assert_almost_equal(signals, signals_r)
# Recover image
img_r = signal_extraction.signals_to_img_maps(signals,
maps_img,
mask_img=mask_img)
np.testing.assert_almost_equal(get_data(img_r), get_data(img))
img_r = signal_extraction.signals_to_img_maps(signals, maps_img)
np.testing.assert_almost_equal(get_data(img_r), get_data(img))
# Test input validation
data_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 5)), np.eye(4))
good_maps_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 7)), np.eye(4))
bad_maps1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5, 7)), np.eye(4))
bad_maps2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 7)), 2 * np.eye(4))
good_mask_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), np.eye(4))
bad_mask1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5)), np.eye(4))
bad_mask2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), 2 * np.eye(4))
assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img,
bad_maps1_img)
assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img,
bad_maps2_img)
assert_raises(ValueError,
signal_extraction.img_to_signals_maps,
data_img,
bad_maps1_img,
mask_img=good_mask_img)
assert_raises(ValueError,
signal_extraction.img_to_signals_maps,
data_img,
bad_maps2_img,
mask_img=good_mask_img)
assert_raises(ValueError,
signal_extraction.img_to_signals_maps,
data_img,
good_maps_img,
mask_img=bad_mask1_img)
assert_raises(ValueError,
signal_extraction.img_to_signals_maps,
data_img,
good_maps_img,
mask_img=bad_mask2_img)
def test_signal_extraction_with_maps():
shape = (10, 11, 12)
n_regions = 9
n_instants = 13
# Generate signals
rand_gen = np.random.RandomState(0)
maps_img, mask_img = generate_maps(shape, n_regions, border=1)
maps_data = maps_img.get_data()
data = np.zeros(shape + (n_instants,), dtype=np.float32)
mask_4d_img = nibabel.Nifti1Image(np.ones((shape + (2, ))), np.eye(4))
signals = np.zeros((n_instants, maps_data.shape[-1]))
for n in range(maps_data.shape[-1]):
signals[:, n] = rand_gen.randn(n_instants)
data[maps_data[..., n] > 0, :] = signals[:, n]
img = nibabel.Nifti1Image(data, np.eye(4))
# verify that 4d masks are refused
assert_raises_regex(TypeError, _TEST_DIM_ERROR_MSG,
signal_extraction.img_to_signals_maps, img, maps_img,
mask_img=mask_4d_img)
# Get signals
signals_r, labels = signal_extraction.img_to_signals_maps(
img, maps_img, mask_img=mask_img)
# The output must be identical to the input signals, because every region
# is homogeneous: there is the same signal in all voxels of one given
# region (and all maps are uniform).
np.testing.assert_almost_equal(signals, signals_r)
# Same thing without mask (in that case)
signals_r, labels = signal_extraction.img_to_signals_maps(img, maps_img)
np.testing.assert_almost_equal(signals, signals_r)
# Recover image
img_r = signal_extraction.signals_to_img_maps(signals, maps_img,
mask_img=mask_img)
np.testing.assert_almost_equal(img_r.get_data(), img.get_data())
img_r = signal_extraction.signals_to_img_maps(signals, maps_img)
np.testing.assert_almost_equal(img_r.get_data(), img.get_data())
# Test input validation
data_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 5)), np.eye(4))
good_maps_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 7)), np.eye(4))
bad_maps1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5, 7)), np.eye(4))
bad_maps2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 7)), 2 * np.eye(4))
good_mask_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), np.eye(4))
bad_mask1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5)), np.eye(4))
bad_mask2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), 2 * np.eye(4))
assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img,
bad_maps1_img)
assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img,
bad_maps2_img)
assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img,
bad_maps1_img, mask_img=good_mask_img)
assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img,
bad_maps2_img, mask_img=good_mask_img)
assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img,
good_maps_img, mask_img=bad_mask1_img)
assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img,
good_maps_img, mask_img=bad_mask2_img)