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(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