Merge pull request #380 from BiAPoL/make-layer-coloring-more-robust

Make layer coloring more robust by adding more test cases

Author: jo-mueller

src/napari_clusters_plotter/_new_plotter_widget.py

@@ -449,33 +449,29 @@ def _apply_layer_color(layer, colors):
     """
     from napari.utils import DirectLabelColormap
 
-    color_mapping = {
-        napari.layers.Points: lambda _layer, _color: setattr(
-            _layer, "face_color", _color
-        ),
-        napari.layers.Vectors: lambda _layer, _color: setattr(
-            _layer, "edge_color", _color
-        ),
-        napari.layers.Surface: lambda _layer, _color: setattr(
-            _layer, "vertex_colors", _color
-        ),
-        napari.layers.Shapes: lambda _layer, _color: setattr(
-            _layer, "face_color", _color
-        ),
-        napari.layers.Labels: lambda _layer, _color: setattr(
-            _layer,
-            "colormap",
-            DirectLabelColormap(
-                color_dict={
-                    label: _color[label] for label in np.unique(_layer.data)
-                }
-            ),
-        ),
-    }
-
-    if type(layer) in color_mapping:
-        if type(layer) is napari.layers.Labels:
-            # add a color for the background at the first index
-            colors = np.insert(colors, 0, [0, 0, 0, 0], axis=0)
-        color_mapping[type(layer)](layer, colors)
-        layer.refresh()
+    if isinstance(layer, napari.layers.Points):
+        layer.face_color = colors
+
+    elif isinstance(layer, napari.layers.Vectors):
+        layer.edge_color = colors
+
+    elif isinstance(layer, napari.layers.Surface):
+        layer.vertex_colors = colors
+
+    elif isinstance(layer, napari.layers.Shapes):
+        layer.face_color = colors
+
+    elif isinstance(layer, napari.layers.Labels):
+
+        colors = np.insert(colors, 0, [0, 0, 0, 0], axis=0)
+        color_dict = dict(zip(np.unique(layer.data), colors))
+
+        # Insert default colors for labels that are not in the color_dict
+        # Relevant for non-sequential label images
+        if max(color_dict.keys()) > len(colors):
+            for i in range(1, max(color_dict.keys()) - 1):
+                color_dict[i] = [0, 0, 0, 0]
+        # Add a color for the background at the first index
+        layer.colormap = DirectLabelColormap(color_dict=color_dict)
+
+    layer.refresh()

src/napari_clusters_plotter/_tests/test_plotter.py

@@ -1,4 +1,5 @@
 import numpy as np
+import pytest
 
 
 def create_multi_point_layer(n_samples: int = 100):
@@ -48,6 +49,151 @@ def create_multi_point_layer(n_samples: int = 100):
     return layer, layer2
 
 
+def create_multi_vectors_layer(n_samples: int = 100):
+    from napari.layers import Vectors
+
+    points1, points2 = create_multi_point_layer(n_samples=n_samples)
+
+    points_direction1 = np.random.normal(size=points1.data.shape)
+    points_direction2 = np.random.normal(size=points2.data.shape)
+
+    # set time index correctly
+    points_direction1[:, 0] = points1.data[:, 0]
+    points_direction2[:, 0] = points2.data[:, 1]
+
+    vectors1 = np.stack([points1.data, points_direction1], axis=1)
+    vectors2 = np.stack([points2.data, points_direction2], axis=1)
+
+    vectors1 = Vectors(vectors1, features=points1.features, name="vectors1")
+    vectors2 = Vectors(vectors2, features=points2.features, name="vectors2")
+
+    return vectors1, vectors2
+
+
+def create_multi_surface_layer(n_samples: int = 100):
+    from napari.layers import Surface
+
+    vertices1, vertices2 = create_multi_point_layer(n_samples=n_samples)
+
+    faces1 = []
+    faces2 = []
+    for t in range(int(vertices1.data[:, 0].max())):
+        vertex_indeces_t = np.argwhere(vertices1.data[:, 0] == t).flatten()
+
+        # draw some random triangles from the indeces
+        _faces = np.random.randint(
+            low=vertex_indeces_t.min(),
+            high=vertex_indeces_t.max(),
+            size=(10, 3),
+        )
+        faces1.append(_faces)
+
+        vertex_indeces_t = np.argwhere(vertices2.data[:, 0] == t).flatten()
+
+        # draw some random triangles from the indeces
+        _faces = np.random.randint(
+            low=vertex_indeces_t.min(),
+            high=vertex_indeces_t.max(),
+            size=(10, 3),
+        )
+        faces2.append(_faces)
+
+    faces1 = np.concatenate(faces1, axis=0)
+    faces2 = np.concatenate(faces2, axis=0)
+
+    surface1 = Surface(
+        (vertices1.data, faces1),
+        features=vertices1.features,
+        name="surface1",
+    )
+
+    surface2 = Surface(
+        (vertices2.data, faces2),
+        features=vertices2.features,
+        name="surface2",
+        translate=(0, 0, 2),
+    )
+    return surface1, surface2
+
+
+def create_multi_shapes_layers(n_samples: int = 100):
+    from napari.layers import Shapes
+
+    points1, points2 = create_multi_point_layer(n_samples=n_samples)
+
+    shapes1, shapes2 = [], []
+    for i in range(len(points1.data)):
+        # create a random shape around the point, whereas the shape consists of the coordinates
+        # of the four corner of the rectangle
+        y, x = points1.data[i, 2], points1.data[i, 3]
+        w, h = np.random.randint(1, 5), np.random.randint(1, 5)
+
+        shape1 = np.array(
+            [
+                [y - h, x - w],
+                [y - h, x + w],
+                [y + h, x + w],
+                [y + h, x - w],
+            ]
+        )
+        shapes1.append(shape1)
+
+    for i in range(len(points2.data)):
+        # create a random shape around the point, whereas the shape consists of the coordinates
+        # of the four corner of the rectangle
+        y, x = points2.data[i, 2], points2.data[i, 3]
+        w, h = np.random.randint(1, 5), np.random.randint(1, 5)
+
+        shape2 = np.array(
+            [
+                [y - h, x - w],
+                [y - h, x + w],
+                [y + h, x + w],
+                [y + h, x - w],
+            ]
+        )
+        shapes2.append(shape2)
+
+    shape1 = Shapes(shapes1, features=points1.features, name="shapes1")
+    shape2 = Shapes(
+        shapes2, features=points2.features, name="shapes2", translate=(0, 2)
+    )
+
+    return shape1, shape2
+
+
+def create_multi_labels_layer():
+    import pandas as pd
+    from napari.layers import Labels
+    from skimage import data, measure
+
+    labels1 = measure.label(data.binary_blobs(length=64, n_dim=2))
+    labels2 = measure.label(data.binary_blobs(length=64, n_dim=2))
+
+    features1 = pd.DataFrame(
+        {
+            "feature1": np.random.normal(size=labels1.max() + 1),
+            "feature2": np.random.normal(size=labels1.max() + 1),
+            "feature3": np.random.normal(size=labels1.max() + 1),
+        }
+    )
+
+    features2 = pd.DataFrame(
+        {
+            "feature1": np.random.normal(size=labels2.max() + 1),
+            "feature2": np.random.normal(size=labels2.max() + 1),
+            "feature3": np.random.normal(size=labels2.max() + 1),
+        }
+    )
+
+    labels1 = Labels(labels1, name="labels1", features=features1)
+    labels2 = Labels(
+        labels2, name="labels2", features=features2, translate=(0, 128)
+    )
+
+    return labels1, labels2
+
+
 def test_mixed_layers(make_napari_viewer):
     from napari_clusters_plotter import PlotterWidget
 
@@ -71,14 +217,22 @@ def test_mixed_layers(make_napari_viewer):
     viewer.add_image(random_image)
     viewer.add_labels(sample_labels)
 
-    #
-
 
-def test_cluster_memorization(make_napari_viewer, n_samples: int = 100):
+@pytest.mark.parametrize(
+    "create_sample_layers",
+    [
+        create_multi_point_layer,
+        create_multi_labels_layer,
+        create_multi_vectors_layer,
+        create_multi_surface_layer,
+        create_multi_shapes_layers,
+    ],
+)
+def test_cluster_memorization(make_napari_viewer, create_sample_layers):
     from napari_clusters_plotter import PlotterWidget
 
     viewer = make_napari_viewer()
-    layer, layer2 = create_multi_point_layer(n_samples=n_samples)
+    layer, layer2 = create_sample_layers()
 
     # add layers to viewer
     viewer.add_layer(layer)
@@ -91,9 +245,8 @@ def test_cluster_memorization(make_napari_viewer, n_samples: int = 100):
     assert "MANUAL_CLUSTER_ID" in layer2.features.columns
 
     plotter_widget._selectors["x"].setCurrentText("feature3")
-    cluster_indeces = np.random.randint(0, 2, len(layer2.data))
-    layer2.features["MANUAL_CLUSTER_ID"] = cluster_indeces
-    plotter_widget._selectors["hue"].setCurrentText("MANUAL_CLUSTER_ID")
+    cluster_indeces = np.random.randint(0, 2, len(layer2.features))
+    plotter_widget._on_finish_draw(cluster_indeces)
 
     # select first layer and make sure that no clusters are selected
     viewer.layers.selection.active = layer
@@ -110,11 +263,21 @@ def test_cluster_memorization(make_napari_viewer, n_samples: int = 100):
     )
 
 
-def test_categorical_handling(make_napari_viewer, n_samples: int = 100):
+@pytest.mark.parametrize(
+    "create_sample_layers",
+    [
+        create_multi_point_layer,
+        create_multi_labels_layer,
+        create_multi_vectors_layer,
+        create_multi_surface_layer,
+        create_multi_shapes_layers,
+    ],
+)
+def test_categorical_handling(make_napari_viewer, create_sample_layers):
     from napari_clusters_plotter import PlotterWidget
 
     viewer = make_napari_viewer()
-    layer, layer2 = create_multi_point_layer(n_samples=n_samples)
+    layer, layer2 = create_sample_layers()
 
     # add layers to viewer
     viewer.add_layer(layer)