def test_one_map_masked(self):
maps = Maps(self.array,
Ni=self.Ni,
Nj=self.Nj,
Nk=self.Nk,
mask=self.mask)
self.assertTrue(np.array_equal(maps.n_peaks(), self.expected_masked))
def test_array_2D(self):
maps = Maps(self.array2D, Ni=2, Nj=1, Nk=1, affine=self.affine)
img = maps.to_img()
self.assertTrue(
np.array_equal(img.get_fdata(), self.array2D.reshape(
(2, 1, 1, 2))))
self.assertTrue(np.array_equal(img.affine, self.affine))
def test_manual(self):
"""Test copy from Ni Nj Nk."""
maps1 = Maps(Ni=Ni, Nj=Nj, Nk=Nk)
maps2 = Maps.copy_header(maps1)
self.assertEqual(maps1.Ni, maps2.Ni)
self.assertEqual(maps1.Nj, maps2.Nj)
self.assertEqual(maps1.Nk, maps2.Nk)
def test_two_maps_masked(self):
maps2 = Maps(self.array2,
Ni=self.Ni,
Nj=self.Nj,
Nk=self.Nk,
mask=self.mask)
self.assertTrue(np.array_equal(maps2.n_peaks(), self.expected_masked2))
def simulate_maps(coords, sigma, size, random_state=None):
"""
Create maps the same noised activation point
Args:
coords (tuple): Tuple of size 3 storing x y z coordinates.
sigma (float): Standard deviation of the gaussian kernel.
N (int): Number of maps to generate.
Returns:
(Maps): Instance of Maps object containing generated maps.
"""
x, y, z = coords
Ni, Nj, Nk = template.shape
p = Maps.zeros(template=template)
p.set_coord(0, x, y, z, 1)
p.smooth(sigma=sigma, inplace=True)
# plotting.plot_glass_brain(p.to_img())
# plt.show()
# rand_maps = Maps.zeros(Ni*Nj*Nk, template=template)
# rand_maps.randomize(size=10*np.ones(N).astype(int), p=p, inplace=True)
# return rand_maps
return Maps.random(size=size,
p=p,
random_state=random_state,
template=template)
def test_mask_missmatch_manual(self):
with self.assertRaises(ValueError):
maps = Maps(array2D,
Ni=Ni,
Nj=Nj,
Nk=Nk,
affine=affine,
mask=gray_mask_missmatch)
with self.assertRaises(ValueError):
maps = Maps(array3D,
Ni=Ni,
Nj=Nj,
Nk=Nk,
affine=affine,
mask=gray_mask_missmatch)
with self.assertRaises(ValueError):
maps = Maps(array4D_1,
Ni=Ni,
Nj=Nj,
Nk=Nk,
affine=affine,
mask=gray_mask_missmatch)
with self.assertRaises(ValueError):
maps = Maps(array4D_2,
Ni=Ni,
Nj=Nj,
Nk=Nk,
affine=affine,
mask=gray_mask_missmatch)
def test_template(self):
"""Test copy from template."""
maps1 = Maps(template=template)
maps2 = Maps.copy_header(maps1)
self.assertEqual(maps1.Ni, maps2.Ni)
self.assertEqual(maps1.Nj, maps2.Nj)
self.assertEqual(maps1.Nk, maps2.Nk)
self.assertTrue(np.array_equal(maps1.affine, maps2.affine))
def test_array_2D_one(self):
maps = Maps(self.array2D, Ni=2, Nj=1, Nk=1)
self.assertTrue(
np.array_equal(maps.to_array(0),
self.array2D.reshape((2, 1, 1, 2))[:, :, :, 0]))
self.assertTrue(
np.array_equal(maps.to_array(1),
self.array2D.reshape((2, 1, 1, 2))[:, :, :, 1]))
def test_allowed_template_mask_atlas(self):
maps = Maps(df_ex,
template=template,
groupby_col=groupby_col,
mask=gray_mask,
atlas=atlas)
self.assertTrue(maps._has_mask())
self.assertTrue(maps._has_atlas())
def test_p_forbidden(self):
p = np.array([[[1, 0, 0], [0, 1, 0], [0, 0, 0]]])
with self.assertRaises(ValueError):
Maps(Ni=1, Nj=3, Nk=3).randomize(size=(100, 2), p=p)
with self.assertRaises(ValueError):
Maps(Ni=1, Nj=3, Nk=3).randomize(size=np.array([50, 50]), p=p)
def test_two_maps(self):
"""Test two maps."""
maps1 = Maps(self.arr1, Ni=self.Ni, Nj=self.Nj, Nk=self.Nk)
maps2 = Maps(self.arr2, Ni=self.Ni, Nj=self.Nj, Nk=self.Nk)
maps3 = Maps.concatenate((maps1, maps2))
self.assertTrue(np.array_equal(maps3.maps.toarray(), self.arr3))
def test_allowed_manual_atlas(self):
maps = Maps(df_ex,
Ni=Ni,
Nj=Nj,
Nk=Nk,
affine=affine,
groupby_col=groupby_col,
atlas=atlas)
self.assertTrue(maps._has_atlas())
def test_allowed_manual_mask(self):
maps = Maps(df_ex,
Ni=Ni,
Nj=Nj,
Nk=Nk,
affine=affine,
groupby_col=groupby_col,
mask=gray_mask)
self.assertTrue(maps._has_mask())
def test_mask_missmatch_template(self):
with self.assertRaises(ValueError):
maps = Maps(array2D, template=template, mask=gray_mask_missmatch)
with self.assertRaises(ValueError):
maps = Maps(array3D, template=template, mask=gray_mask_missmatch)
with self.assertRaises(ValueError):
maps = Maps(array4D_1, template=template, mask=gray_mask_missmatch)
with self.assertRaises(ValueError):
maps = Maps(array4D_2, template=template, mask=gray_mask_missmatch)
def test_box_missmatch_template(self):
with self.assertRaises(ValueError):
maps = Maps(array2D_missmatch, template=template)
with self.assertRaises(ValueError):
maps = Maps(array3D_missmatch, template=template)
with self.assertRaises(ValueError):
maps = Maps(array4D_1_missmatch, template=template)
with self.assertRaises(ValueError):
maps = Maps(array4D_2_missmatch, template=template)
def test_one_map_masked(self):
maps = Maps(self.array,
Ni=self.Ni,
Nj=self.Nj,
Nk=self.Nk,
mask=self.mask)
self.assertTrue(np.array_equal(maps.max(axis=0),
self.expected_masked1))
self.assertTrue(np.array_equal(maps.max(), 5.))
def test_allowed_manual(self):
maps = Maps(df_ex,
Ni=Ni,
Nj=Nj,
Nk=Nk,
affine=affine,
groupby_col=groupby_col)
self.assertEqual(maps.n_maps, 2)
self.assertFalse(maps._has_mask())
self.assertFalse(maps._has_atlas())
def test_two_maps_masked(self):
maps2 = Maps(self.array2,
Ni=self.Ni,
Nj=self.Nj,
Nk=self.Nk,
mask=self.mask)
self.assertTrue(
np.array_equal(maps2.sum(axis=0, keepdims=True),
self.expected_masked2))
self.assertTrue(np.array_equal(maps2.sum(), 20.))
def test_one_map_masked(self):
maps = Maps(self.array,
Ni=self.Ni,
Nj=self.Nj,
Nk=self.Nk,
mask=self.mask)
self.assertTrue(
np.array_equal(maps.sum(axis=0, keepdims=True),
self.expected_masked1))
self.assertTrue(np.array_equal(maps.sum(), 8.))
def test_mask_init_two_maps(self):
maps2 = Maps(self.array2,
Ni=self.Ni,
Nj=self.Nj,
Nk=self.Nk,
mask=self.mask)
self.assertTrue(
np.array_equal(maps2.to_array(0), self.expected2[:, :, :, 0]))
self.assertTrue(
np.array_equal(maps2.to_array(1), self.expected2[:, :, :, 1]))
def test_array_2D_one(self):
maps = Maps(self.array2D, Ni=2, Nj=1, Nk=1, affine=self.affine)
img0 = maps.to_img(0)
img1 = maps.to_img(1)
self.assertTrue(
np.array_equal(img0.get_fdata(),
self.array2D.reshape((2, 1, 1, 2))[:, :, :, 0]))
self.assertTrue(
np.array_equal(img1.get_fdata(),
self.array2D.reshape((2, 1, 1, 2))[:, :, :, 1]))
self.assertTrue(np.array_equal(img0.affine, self.affine))
self.assertTrue(np.array_equal(img1.affine, self.affine))
def test_box_missmatch_manual(self):
with self.assertRaises(ValueError):
maps = Maps(self.shape1D_missmatch,
Ni=Ni,
Nj=Nj,
Nk=Nk,
affine=affine)
with self.assertRaises(ValueError):
maps = Maps(self.shape2D_missmatch,
Ni=Ni,
Nj=Nj,
Nk=Nk,
affine=affine)
def test_threshold_one_map(self):
maps = Maps(self.array, Ni=self.Ni, Nj=self.Nj, Nk=self.Nk)
maps_ = maps.threshold(2, inplace=False)
maps.threshold(2, inplace=True)
self.assertTrue(np.array_equal(maps.to_array(), self.expected))
self.assertTrue(np.array_equal(maps_.to_array(), self.expected))
def test_array_two_maps_p_mask_override(self):
maps = Maps(Ni=1, Nj=3, Nk=3,
mask=self.mask).randomize(size=np.array([50, 50]),
p=self.p,
override_mask=True)
self.assertEqual(maps.to_array(0)[0, 0, 0], 0)
self.assertTrue(np.array_equal(maps.sum(axis=0), np.array([50, 50])))
def test_array_two_maps_p_mask_2(self):
maps = Maps(Ni=1, Nj=3, Nk=3,
mask=self.mask).randomize(size=np.array([100, 0]),
p=self.p)
self.assertEqual(maps.to_array(0)[0, 0, 0], 0)
self.assertEqual(maps.to_array(0)[0, 1, 1], 100)
self.assertTrue(np.array_equal(maps.sum(axis=0), np.array([100, 0])))
def test_mask_init_one_map(self):
maps = Maps(self.array,
Ni=self.Ni,
Nj=self.Nj,
Nk=self.Nk,
mask=self.mask)
self.assertTrue(np.array_equal(maps.to_array(), self.expected))
def test_one_map(self):
maps = Maps(self.array, Ni=self.Ni, Nj=self.Nj, Nk=self.Nk)
maps_ = maps.shuffle(inplace=False)
maps.shuffle(inplace=True)
self.assertTrue(np.array_equal(maps.to_array(), self.array))
self.assertTrue(np.array_equal(maps_.to_array(), self.array))
def test_one_map_manual(self):
"""Test creating one map from Ni Nj Nk."""
maps = Maps.random(self.size1, Ni=Ni, Nj=Nj, Nk=Nk)
arr = maps.to_array()
self.assertEqual(np.sum(arr), self.size1)
self.assertEqual(maps.n_m, 1)
self.assertEqual(maps.n_v, Ni*Nj*Nk)
def test_normalize_one_map(self):
maps = Maps(self.array, Ni=self.Ni, Nj=self.Nj, Nk=self.Nk)
maps_ = maps.normalize(inplace=False)
maps.normalize(inplace=True)
self.assertTrue(np.array_equal(maps.to_array(), self.expected))
self.assertTrue(np.array_equal(maps_.to_array(), self.expected))
def test_one_map_bis_template(self):
"""Test creating one map from template."""
maps = Maps.random(self.size1_bis, template=template)
arr = maps.to_array()
self.assertEqual(np.sum(arr), self.size1)
self.assertEqual(maps.n_m, 1)
self.assertEqual(maps.n_v, Ni*Nj*Nk)