def test_largest_cc():
""" Check the extraction of the largest connected component.
"""
a = np.zeros((6, 6, 6))
assert_raises(ValueError, largest_connected_component, a)
a[1:3, 1:3, 1:3] = 1
np.testing.assert_equal(a, largest_connected_component(a))
b = a.copy()
b[5, 5, 5] = 1
np.testing.assert_equal(a, largest_connected_component(b))
def test_largest_cc():
""" Check the extraction of the largest connected component.
"""
a = np.zeros((6, 6, 6))
assert_raises(ValueError, largest_connected_component, a)
a[1:3, 1:3, 1:3] = 1
np.testing.assert_equal(a, largest_connected_component(a))
b = a.copy()
b[5, 5, 5] = 1
np.testing.assert_equal(a, largest_connected_component(b))
# Tests for correct errors, when an image or string are passed.
img = testing.generate_labeled_regions(shape=(10, 11, 12),
n_regions=2)
assert_raises(ValueError, largest_connected_component, img)
assert_raises(ValueError, largest_connected_component, "Test String")
def test_largest_cc():
""" Check the extraction of the largest connected component.
"""
a = np.zeros((6, 6, 6))
pytest.raises(ValueError, largest_connected_component, a)
a[1:3, 1:3, 1:3] = 1
np.testing.assert_equal(a, largest_connected_component(a))
# A simple test with non-native dtype
a_change_type = a.astype('>f8')
np.testing.assert_equal(a, largest_connected_component(a_change_type))
b = a.copy()
b[5, 5, 5] = 1
np.testing.assert_equal(a, largest_connected_component(b))
# A simple test with non-native dtype
b_change_type = b.astype('>f8')
np.testing.assert_equal(a, largest_connected_component(b_change_type))
# Tests for correct errors, when an image or string are passed.
img = data_gen.generate_labeled_regions(shape=(10, 11, 12), n_regions=2)
pytest.raises(ValueError, largest_connected_component, img)
pytest.raises(ValueError, largest_connected_component, "Test String")
def test_largest_cc():
""" Check the extraction of the largest connected component.
"""
a = np.zeros((6, 6, 6))
assert_raises(ValueError, largest_connected_component, a)
a[1:3, 1:3, 1:3] = 1
np.testing.assert_equal(a, largest_connected_component(a))
# A simple test with non-native dtype
a_change_type = a.astype('>f8')
np.testing.assert_equal(a, largest_connected_component(a_change_type))
b = a.copy()
b[5, 5, 5] = 1
np.testing.assert_equal(a, largest_connected_component(b))
# A simple test with non-native dtype
b_change_type = b.astype('>f8')
np.testing.assert_equal(a, largest_connected_component(b_change_type))
# Tests for correct errors, when an image or string are passed.
img = testing.generate_labeled_regions(shape=(10, 11, 12),
n_regions=2)
assert_raises(ValueError, largest_connected_component, img)
assert_raises(ValueError, largest_connected_component, "Test String")
def find_cut_coords(img, mask=None, activation_threshold=None):
import warnings
import numpy as np
from scipy import ndimage
from nilearn._utils import as_ndarray, new_img_like
from nilearn._utils.ndimage import largest_connected_component
from nilearn._utils.extmath import fast_abs_percentile
""" Find the center of the largest activation connected component.
Parameters
-----------
img : 3D Nifti1Image
The brain map.
mask : 3D ndarray, boolean, optional
An optional brain mask.
activation_threshold : float, optional
The lower threshold to the positive activation. If None, the
activation threshold is computed using the 80% percentile of
the absolute value of the map.
Returns
-------
x : float
the x world coordinate.
y : float
the y world coordinate.
z : float
the z world coordinate.
"""
data = img.get_data()
# To speed up computations, we work with partial views of the array,
# and keep track of the offset
offset = np.zeros(3)
# Deal with masked arrays:
if hasattr(data, 'mask'):
not_mask = np.logical_not(data.mask)
if mask is None:
mask = not_mask
else:
mask *= not_mask
data = np.asarray(data)
# Get rid of potential memmapping
data = as_ndarray(data)
my_map = data.copy()
if mask is not None:
slice_x, slice_y, slice_z = ndimage.find_objects(mask)[0]
my_map = my_map[slice_x, slice_y, slice_z]
mask = mask[slice_x, slice_y, slice_z]
my_map *= mask
offset += [slice_x.start, slice_y.start, slice_z.start]
# Testing min and max is faster than np.all(my_map == 0)
if (my_map.max() == 0) and (my_map.min() == 0):
return .5 * np.array(data.shape)
if activation_threshold is None:
activation_threshold = fast_abs_percentile(my_map[my_map != 0].ravel(),
80)
mask = np.abs(my_map) > activation_threshold - 1.e-15
# mask may be zero everywhere in rare cases
if mask.max() == 0:
return .5 * np.array(data.shape)
mask = largest_connected_component(mask)
slice_x, slice_y, slice_z = ndimage.find_objects(mask)[0]
my_map = my_map[slice_x, slice_y, slice_z]
mask = mask[slice_x, slice_y, slice_z]
my_map *= mask
offset += [slice_x.start, slice_y.start, slice_z.start]
# For the second threshold, we use a mean, as it is much faster,
# althought it is less robust
second_threshold = np.abs(np.mean(my_map[mask]))
second_mask = (np.abs(my_map) > second_threshold)
if second_mask.sum() > 50:
my_map *= largest_connected_component(second_mask)
cut_coords = ndimage.center_of_mass(np.abs(my_map))
x_map, y_map, z_map = cut_coords + offset
coords = []
coords.append(x_map)
coords.append(y_map)
coords.append(z_map)
# Return as a list of scalars
return coords
def find_cut_coords(img, mask=None, activation_threshold=None):
import warnings
import numpy as np
from scipy import ndimage
from nilearn._utils import as_ndarray, new_img_like
from nilearn._utils.ndimage import largest_connected_component
from nilearn._utils.extmath import fast_abs_percentile
""" Find the center of the largest activation connected component.
Parameters
-----------
img : 3D Nifti1Image
The brain map.
mask : 3D ndarray, boolean, optional
An optional brain mask.
activation_threshold : float, optional
The lower threshold to the positive activation. If None, the
activation threshold is computed using the 80% percentile of
the absolute value of the map.
Returns
-------
x : float
the x world coordinate.
y : float
the y world coordinate.
z : float
the z world coordinate.
"""
data = img.get_data()
# To speed up computations, we work with partial views of the array,
# and keep track of the offset
offset = np.zeros(3)
# Deal with masked arrays:
if hasattr(data, 'mask'):
not_mask = np.logical_not(data.mask)
if mask is None:
mask = not_mask
else:
mask *= not_mask
data = np.asarray(data)
# Get rid of potential memmapping
data = as_ndarray(data)
my_map = data.copy()
if mask is not None:
slice_x, slice_y, slice_z = ndimage.find_objects(mask)[0]
my_map = my_map[slice_x, slice_y, slice_z]
mask = mask[slice_x, slice_y, slice_z]
my_map *= mask
offset += [slice_x.start, slice_y.start, slice_z.start]
# Testing min and max is faster than np.all(my_map == 0)
if (my_map.max() == 0) and (my_map.min() == 0):
return .5 * np.array(data.shape)
if activation_threshold is None:
activation_threshold = fast_abs_percentile(my_map[my_map != 0].ravel(),
80)
mask = np.abs(my_map) > activation_threshold - 1.e-15
# mask may be zero everywhere in rare cases
if mask.max() == 0:
return .5 * np.array(data.shape)
mask = largest_connected_component(mask)
slice_x, slice_y, slice_z = ndimage.find_objects(mask)[0]
my_map = my_map[slice_x, slice_y, slice_z]
mask = mask[slice_x, slice_y, slice_z]
my_map *= mask
offset += [slice_x.start, slice_y.start, slice_z.start]
# For the second threshold, we use a mean, as it is much faster,
# althought it is less robust
second_threshold = np.abs(np.mean(my_map[mask]))
second_mask = (np.abs(my_map) > second_threshold)
if second_mask.sum() > 50:
my_map *= largest_connected_component(second_mask)
cut_coords = ndimage.center_of_mass(np.abs(my_map))
x_map, y_map, z_map = cut_coords + offset
coords = []
coords.append(x_map)
coords.append(y_map)
coords.append(z_map)
# Return as a list of scalars
return coords
def find_cut_coords(map, mask=None, activation_threshold=None):
""" Find the center of the largest activation connect component.
Parameters
-----------
map : 3D ndarray
The activation map, as a 3D numpy array.
mask : 3D ndarray, boolean, optional
An optional brain mask.
activation_threshold : float, optional
The lower threshold to the positive activation. If None, the
activation threshold is computed using find_activation.
Returns
-------
x: float
the x coordinate in voxels.
y: float
the y coordinate in voxels.
z: float
the z coordinate in voxels.
"""
# To speed up computations, we work with partial views of the array,
# and keep track of the offset
offset = np.zeros(3)
# Deal with masked arrays:
if hasattr(map, 'mask'):
not_mask = np.logical_not(map.mask)
if mask is None:
mask = not_mask
else:
mask *= not_mask
map = np.asarray(map)
my_map = map.copy()
if mask is not None:
slice_x, slice_y, slice_z = ndimage.find_objects(mask)[0]
my_map = my_map[slice_x, slice_y, slice_z]
mask = mask[slice_x, slice_y, slice_z]
my_map *= mask
offset += [slice_x.start, slice_y.start, slice_z.start]
# Testing min and max is faster than np.all(my_map == 0)
if (my_map.max() == 0) and (my_map.min() == 0):
return .5*np.array(map.shape)
if activation_threshold is None:
activation_threshold = stats.scoreatpercentile(
np.abs(my_map[my_map !=0]).ravel(), 80)
mask = np.abs(my_map) > activation_threshold-1.e-15
mask = largest_connected_component(mask)
slice_x, slice_y, slice_z = ndimage.find_objects(mask)[0]
my_map = my_map[slice_x, slice_y, slice_z]
mask = mask[slice_x, slice_y, slice_z]
my_map *= mask
offset += [slice_x.start, slice_y.start, slice_z.start]
# For the second threshold, we use a mean, as it is much faster,
# althought it is less robust
second_threshold = np.abs(np.mean(my_map[mask]))
second_mask = (np.abs(my_map)>second_threshold)
if second_mask.sum() > 50:
my_map *= largest_connected_component(second_mask)
cut_coords = ndimage.center_of_mass(np.abs(my_map))
return cut_coords + offset
