def test_layer_action_menu(qapp):
    """Test the actions in LAYER_ACTIONS."""
    menu = QtActionContextMenu(_LAYER_ACTIONS)
    layer_list = LayerList([])
    menu.update_from_context(layer_list._ctx)
    assert not menu._get_action('napari:convert_to_image').isEnabled()

    layer_list.append(Labels(np.zeros((8, 8), int)))
    menu.update_from_context(layer_list._ctx)
    assert menu._get_action('napari:convert_to_image').isEnabled()
    assert not menu._get_action('napari:convert_to_labels').isEnabled()

    layer_list.append(Image(np.zeros((8, 8))))
    menu.update_from_context(layer_list._ctx)
    assert not menu._get_action('napari:convert_to_image').isEnabled()
    assert menu._get_action('napari:convert_to_labels').isEnabled()
    assert not menu._get_action('napari:link_selected_layers').isEnabled()

    layer_list.select_all()
    menu.update_from_context(layer_list._ctx)
    assert menu._get_action('napari:link_selected_layers').isEnabled()
    assert not menu._get_action('napari:unlink_selected_layers').isEnabled()

    layer_list.link_layers()
    menu.update_from_context(layer_list._ctx)
    assert not menu._get_action('napari:link_selected_layers').isEnabled()
    assert menu._get_action('napari:unlink_selected_layers').isEnabled()
Example #2
0
def test_projections(mode):
    ll = LayerList()
    ll.append(Image(np.random.rand(8, 8, 8)))
    assert len(ll) == 1
    assert ll[-1].data.ndim == 3
    _project(ll, mode=mode)
    assert len(ll) == 2
    # because we use keepdims = True
    assert ll[-1].data.shape == (1, 8, 8)
Example #3
0
def test_convert_layer(input, type_):
    ll = LayerList()
    input.scale *= 1.5
    original_scale = input.scale.copy()
    ll.append(input)
    assert ll[0]._type_string != type_
    _convert(ll, type_)
    assert ll[0]._type_string == type_
    assert np.array_equal(ll[0].scale, original_scale)
def test_layerlist_context():
    assert 'layers_selection_count' in LayerListContextKeys.__members__

    ctx = {}
    llc = LayerListContextKeys(ctx)
    assert llc.layers_selection_count == 0
    assert ctx['layers_selection_count'] == 0

    layers = LayerList()

    layers.selection.events.changed.connect(llc.update)
    layers.append(Points())
    assert llc.layers_selection_count == 1
    assert ctx['layers_selection_count'] == 1
Example #5
0
def test_all_selected_layers_same_type():
    assert 'all_selected_layers_same_type' in LayerListContextKeys.__members__

    ctx = {}
    LLCK = LayerListContextKeys(ctx)
    assert LLCK.all_selected_layers_same_type is False
    assert ctx['all_selected_layers_same_type'] is False

    layer_list = LayerList()
    points_layer1 = Points()
    points_layer2 = Points()
    image_layer = Image(np.zeros((10, 10)))
    layer_list.selection.events.changed.connect(LLCK.update)
    layer_list.append(points_layer1)
    layer_list.append(points_layer2)
    layer_list.append(image_layer)

    layer_list.selection = layer_list[:2]  # two points layers selected
    assert LLCK.all_selected_layers_same_type is True
    assert ctx['all_selected_layers_same_type'] is True

    layer_list.selection = [
        layer_list[0],
        layer_list[2],
    ]  # one points + one image
    assert LLCK.all_selected_layers_same_type is False
    assert ctx['all_selected_layers_same_type'] is False
Example #6
0
def test_layerlist_context():
    assert 'num_selected_layers' in LayerListContextKeys.__members__

    ctx = {}
    LLCK = LayerListContextKeys(ctx)
    assert LLCK.num_selected_layers == 0
    assert ctx['num_selected_layers'] == 0

    layer_list = LayerList()
    points_layer = Points()

    layer_list.selection.events.changed.connect(LLCK.update)
    layer_list.append(points_layer)
    assert LLCK.num_selected_layers == 1
    assert ctx['num_selected_layers'] == 1
Example #7
0
def test_convert_dtype(mode):
    ll = LayerList()
    data = np.zeros((10, 10), dtype=np.int16)
    ll.append(Labels(data))
    assert ll[-1].data.dtype == np.int16

    data[5, 5] = 1000
    assert data[5, 5] == 1000
    if mode == 'int8' or mode == 'uint8':
        # label value 1000 is outside of the target data type range.
        with pytest.raises(AssertionError):
            _convert_dtype(ll, mode=mode)
        assert ll[-1].data.dtype == np.int16
    else:
        _convert_dtype(ll, mode=mode)
        assert ll[-1].data.dtype == np.dtype(mode)

    assert ll[-1].data[5, 5] == 1000
    assert ll[-1].data.flatten().sum() == 1000
Example #8
0
def test_convert_layer(input, type_):
    ll = LayerList()
    ll.append(input)
    assert ll[0]._type_string != type_
    _convert(ll, type_)
    assert ll[0]._type_string == type_