def test_brush_size():
"""Test changing brush size."""
np.random.seed(0)
data = np.random.randint(20, size=(10, 15))
layer = Labels(data)
assert layer.brush_size == 10
layer.brush_size = 20
assert layer.brush_size == 20
def test_xml_list():
"""Test the xml generation."""
np.random.seed(0)
data = np.random.randint(20, size=(30, 30))
layer = Labels(data)
xml = layer.to_xml_list()
assert type(xml) == list
assert len(xml) == 1
assert type(xml[0]) == Element
def test_all_zeros_labels():
"""Test instantiating Labels layer with all zeros data."""
shape = (10, 15)
data = np.zeros(shape, dtype=int)
layer = Labels(data)
assert np.all(layer.data == data)
assert layer.ndim == len(shape)
np.testing.assert_array_equal(layer.extent.data[1] + 1, shape)
assert layer._data_view.shape == shape[-2:]
def test_add_large_colors():
label_array = (5e6 * np.ones((2, 2, 2))).astype(np.uint64)
label_array[0, :, :] = [[0, 1], [2, 3]]
layer = Labels(label_array)
assert len(layer._all_vals) == layer.num_colors
layer.show_selected_label = True
layer.selected_label = int(5e6)
assert layer._all_vals.size < 1026
def test_contiguous():
"""Test changing contiguous."""
np.random.seed(0)
data = np.random.randint(20, size=(10, 15))
layer = Labels(data)
assert layer.contiguous is True
layer.contiguous = False
assert layer.contiguous is False
def test_n_dimensional():
"""Test changing n_dimensional."""
np.random.seed(0)
data = np.random.randint(20, size=(10, 15))
layer = Labels(data)
assert layer.n_dimensional == False
layer.n_dimensional = True
assert layer.n_dimensional == True
def test_paint(MouseEvent):
"""Test painting labels with circle brush."""
data = np.ones((20, 20), dtype=np.int32)
layer = Labels(data)
layer.brush_size = 10
assert layer.cursor_size == 10
layer.mode = 'paint'
layer.selected_label = 3
# Simulate click
event = ReadOnlyWrapper(
MouseEvent(
type='mouse_press',
is_dragging=False,
position=(0, 0),
view_direction=None,
dims_displayed=(0, 1),
dims_point=(0, 0),
)
)
mouse_press_callbacks(layer, event)
# Simulate drag
event = ReadOnlyWrapper(
MouseEvent(
type='mouse_move',
is_dragging=True,
position=(19, 19),
view_direction=None,
dims_displayed=(0, 1),
dims_point=(0, 0),
)
)
mouse_move_callbacks(layer, event)
# Simulate release
event = ReadOnlyWrapper(
MouseEvent(
type='mouse_release',
is_dragging=False,
position=(19, 19),
view_direction=None,
dims_displayed=(0, 1),
dims_point=(0, 0),
)
)
mouse_release_callbacks(layer, event)
# Painting goes from (0, 0) to (19, 19) with a brush size of 10, changing
# all pixels along that path, but none outside it.
assert np.unique(layer.data[:8, :8]) == 3
assert np.unique(layer.data[-8:, -8:]) == 3
assert np.unique(layer.data[:5, -5:]) == 1
assert np.unique(layer.data[-5:, :5]) == 1
assert np.sum(layer.data == 3) == 244
def test_3D_labels():
"""Test instantiating Labels layer with random 3D data."""
shape = (6, 10, 15)
np.random.seed(0)
data = np.random.randint(20, size=shape)
layer = Labels(data)
assert np.all(layer.data == data)
assert layer.ndim == len(shape)
assert layer.shape == shape
assert layer._data_view.shape == shape[-2:]
def test_paint_3d_negative_scale(scale):
labels = np.zeros((3, 5, 11, 11), dtype=int)
labels_layer = Labels(labels,
scale=(1, ) + scale,
translate=(-200, 100, 100))
labels_layer.n_edit_dimensions = 3
labels_layer.brush_size = 8
labels_layer.paint((1, 2, 5, 5), 1)
np.testing.assert_array_equal(np.sum(labels_layer.data, axis=(1, 2, 3)),
[0, 95, 0])
def test_paint_2d_xarray():
"""Test the memory usage of painting an xarray indirectly via timeout."""
data = xr.DataArray(np.zeros((3, 3, 1024, 1024), dtype=np.uint32))
layer = Labels(data)
layer.brush_size = 12
layer.mode = 'paint'
layer.paint((1, 1, 512, 512), 3)
assert isinstance(layer.data, xr.DataArray)
assert layer.data.sum() == 411
def test_label_color():
"""Test getting label color."""
np.random.seed(0)
data = np.random.randint(20, size=(10, 15))
layer = Labels(data)
col = layer.get_color(0)
assert col is None
col = layer.get_color(1)
assert len(col) == 4
def test_negative_label():
"""Test negative label values are supported."""
data = np.random.randint(low=-1, high=20, size=(10, 10))
original_data = np.copy(data)
layer = Labels(data)
layer.selected_label = -1
layer.brush_size = 3
layer.paint((5, 5), -1)
assert np.count_nonzero(layer.data == -1) > np.count_nonzero(
original_data == -1)
def test_default_properties_assignment():
"""Test that the default properties value can be assigned to properties
see https://github.com/napari/napari/issues/2477
"""
np.random.seed(0)
data = np.random.randint(20, size=(10, 15))
layer = Labels(data)
layer.properties = {}
assert layer.properties == {}
def test_colormap():
"""Test colormap."""
np.random.seed(0)
data = np.random.randint(20, size=(10, 15))
layer = Labels(data)
assert isinstance(layer.colormap, Colormap)
assert layer.colormap.name == 'label_colormap'
layer.new_colormap()
assert isinstance(layer.colormap, Colormap)
assert layer.colormap.name == 'label_colormap'
def test_random_labels():
"""Test instantiating Labels layer with random 2D data."""
shape = (10, 15)
np.random.seed(0)
data = np.random.randint(20, size=shape)
layer = Labels(data)
assert np.all(layer.data == data)
assert layer.ndim == len(shape)
np.testing.assert_array_equal(layer.extent.data[1] + 1, shape)
assert layer._data_view.shape == shape[-2:]
assert layer.editable is True
def test_n_edit_dimensions():
"""Test changing the number of editable dimensions."""
np.random.seed(0)
data = np.random.randint(20, size=(5, 10, 15))
layer = Labels(data)
layer.n_edit_dimensions = 2
with pytest.warns(FutureWarning):
assert layer.n_dimensional is False
layer.n_edit_dimensions = 3
with pytest.warns(FutureWarning):
assert layer.n_dimensional is True
def test_random_labels():
"""Test instantiating Labels layer with random 2D data."""
shape = (10, 15)
np.random.seed(0)
data = np.random.randint(20, size=shape)
layer = Labels(data)
assert np.all(layer.data == data)
assert layer.ndim == len(shape)
assert layer.shape == shape
assert layer.range == tuple((0, m, 1) for m in shape)
assert layer._data_view.shape == shape[-2:]
def test_seed():
"""Test setting seed."""
np.random.seed(0)
data = np.random.randint(20, size=(10, 15))
layer = Labels(data)
assert layer.seed == 0.5
layer.seed = 0.9
assert layer.seed == 0.9
layer = Labels(data, seed=0.7)
assert layer.seed == 0.7
# ensure setting seed triggers
# recalculation of _all_vals
_all_vals_07 = layer._all_vals.copy()
layer.seed = 0.4
_all_vals_04 = layer._all_vals.copy()
assert_raises(AssertionError, assert_array_almost_equal, _all_vals_04,
_all_vals_07)
def test_selecting_label():
"""Test selecting label."""
np.random.seed(0)
data = np.random.randint(20, size=(10, 15))
layer = Labels(data)
assert layer.selected_label == 0
assert layer._selected_color is None
layer.selected_label = 1
assert layer.selected_label == 1
assert len(layer._selected_color) == 4
def test_changing_layer_color_mode_updates_combo_box(qtbot):
"""Updating layer color mode changes the combo box selection"""
layer = Labels(_LABELS, color=_COLOR)
qtctrl = QtLabelsControls(layer)
qtbot.addWidget(qtctrl)
original_color_mode = layer.color_mode
assert original_color_mode == qtctrl.colorModeComboBox.currentText()
layer.color_mode = 'auto'
assert layer.color_mode == qtctrl.colorModeComboBox.currentText()
def test_selecting_label():
"""Test changing n_dimensional."""
np.random.seed(0)
data = np.random.randint(20, size=(10, 15))
layer = Labels(data)
assert layer.selected_label == 0
assert layer._selected_color == None
layer.selected_label = 1
assert layer.selected_label == 1
assert len(layer._selected_color) == 4
def test_fill_nD_all(MouseEvent):
"""Test filling label nD."""
data = np.ones((20, 20, 20), dtype=np.int32)
data[:5, :5, :5] = 2
data[0, 8:10, 8:10] = 2
data[-5:, -5:, -5:] = 3
layer = Labels(data)
assert np.unique(layer.data[:5, :5, :5]) == 2
assert np.unique(layer.data[-5:, -5:, -5:]) == 3
assert np.unique(layer.data[:5, -5:, -5:]) == 1
assert np.unique(layer.data[-5:, :5, -5:]) == 1
assert np.unique(layer.data[0, 8:10, 8:10]) == 2
layer.n_edit_dimensions = 3
layer.mode = 'fill'
layer.selected_label = 4
# Simulate click
event = ReadOnlyWrapper(
MouseEvent(
type='mouse_press',
is_dragging=False,
position=(0, 0, 0),
view_direction=(1, 0, 0),
dims_displayed=(0, 1),
dims_point=(0, 0),
)
)
mouse_press_callbacks(layer, event)
assert np.unique(layer.data[:5, :5, :5]) == 4
assert np.unique(layer.data[-5:, -5:, -5:]) == 3
assert np.unique(layer.data[:5, -5:, -5:]) == 1
assert np.unique(layer.data[-5:, :5, -5:]) == 1
assert np.unique(layer.data[0, 8:10, 8:10]) == 2
layer.selected_label = 5
# Simulate click
event = ReadOnlyWrapper(
MouseEvent(
type='mouse_press',
is_dragging=False,
position=(0, 19, 19),
view_direction=(1, 0, 0),
dims_displayed=(0, 1),
dims_point=(0, 0, 0),
)
)
mouse_press_callbacks(layer, event)
assert np.unique(layer.data[:5, :5, :5]) == 4
assert np.unique(layer.data[-5:, -5:, -5:]) == 3
assert np.unique(layer.data[:5, -5:, -5:]) == 5
assert np.unique(layer.data[-5:, :5, -5:]) == 5
assert np.unique(layer.data[0, 8:10, 8:10]) == 2
def test_paint_2d_xarray(brush_shape, expected_sum):
"""Test the memory usage of painting an xarray indirectly via timeout."""
data = xr.DataArray(np.zeros((3, 3, 1024, 1024), dtype=np.uint32))
layer = Labels(data)
layer.brush_size = 12
with pytest.warns(FutureWarning):
layer.brush_shape = brush_shape
layer.mode = 'paint'
layer.paint((1, 1, 512, 512), 3)
assert isinstance(layer.data, xr.DataArray)
assert layer.data.sum() == expected_sum
def test_add_colors():
"""Test adding new colors"""
data = np.random.randint(20, size=(40, 40))
layer = Labels(data)
assert len(layer._all_vals) == layer.num_colors
layer.selected_label = 51
assert len(layer._all_vals) == 52
layer.show_selected_label = True
layer.selected_label = 53
assert len(layer._all_vals) == 54
def test_midpoint_3d_nonempty_ray(make_napari_viewer):
viewer = make_napari_viewer()
viewer.dims.ndisplay = 3
mock_data = np.zeros(shape=(5, 5, 5), dtype="uint8")
mock_data[1:4, 1:4, 1:4] = 1
layer_data = Labels(mock_data)
viewer.add_layer(layer_data)
mouse_event = MockMouseEvent((2, 2, 0), [0, 1, 1])
result = find_midpoint_of_first_segment(layer_data, mouse_event)
np.testing.assert_allclose(result, [2., 3.5, 1.5])
def test_midpoint_3d_empty_ray(make_napari_viewer):
viewer = make_napari_viewer()
viewer.dims.ndisplay = 3
mock_data = np.zeros(shape=(5, 5, 5), dtype="uint8")
layer_data = Labels(mock_data)
mouse_event = MockMouseEvent((2, 2, 0), [1, 0, 0])
viewer.add_layer(layer_data)
result = find_midpoint_of_first_segment(layer_data, mouse_event)
assert result is None
mock_data[1:4, 1:4, 1:4] = 1
layer_data = Labels(mock_data)
mouse_event = MockMouseEvent((2, 2, 0), [1, 0, 0])
viewer.add_layer(layer_data)
result = find_midpoint_of_first_segment(layer_data, mouse_event)
assert result is None
def layer_data_and_types():
np.random.seed(0)
layers = [
Image(np.random.rand(20, 20)),
Labels(np.random.randint(10, size=(20, 2))),
Points(np.random.rand(20, 2)),
Shapes(np.random.rand(10, 2, 2)),
Vectors(np.random.rand(10, 2, 2)),
]
layer_data = [l.as_layer_data_tuple() for l in layers]
layer_types = [ld[2] for ld in layer_data]
return layer_data, layer_types
def test_changing_labels():
"""Test changing Labels data."""
shape_a = (10, 15)
shape_b = (20, 12)
np.random.seed(0)
data_a = np.random.randint(20, size=shape_a)
data_b = np.random.randint(20, size=shape_b)
layer = Labels(data_a)
layer.data = data_b
assert np.all(layer.data == data_b)
assert layer.ndim == len(shape_b)
np.testing.assert_array_equal(layer.extent.data[1] + 1, shape_b)
assert layer._data_view.shape == shape_b[-2:]
def test_fill():
"""Test filling labels with different brush sizes."""
np.random.seed(0)
data = np.random.randint(20, size=(10, 15))
data[:10, :10] = 2
data[:5, :5] = 1
layer = Labels(data)
assert np.unique(layer.data[:5, :5]) == 1
assert np.unique(layer.data[5:10, 5:10]) == 2
layer.fill([0, 0], 1, 3)
assert np.unique(layer.data[:5, :5]) == 3
assert np.unique(layer.data[5:10, 5:10]) == 2
def test_colormap():
"""Test colormap."""
np.random.seed(0)
data = np.random.randint(20, size=(10, 15))
layer = Labels(data)
assert type(layer.colormap) == tuple
assert layer.colormap[0] == 'random'
assert type(layer.colormap[1]) == Colormap
layer.new_colormap()
assert type(layer.colormap) == tuple
assert layer.colormap[0] == 'random'
assert type(layer.colormap[1]) == Colormap
