[Bugfix] For layer_attributes that are dict (like color) do key/value comparisons

.gitignore

@@ -77,3 +77,6 @@ target/
 
 # written by setuptools_scm
 */_version.py
+
+# vscode
+.vscode

napari_animation/_tests/test_animation.py

@@ -2,11 +2,16 @@
 
 import numpy as np
 import pytest
+from napari._tests.utils import (
+    add_layer_by_type,
+    assert_layer_state_equal,
+    layer_test_data,
+)
 
 from napari_animation import Animation, ViewerState
 from napari_animation.utils import make_thumbnail
 
-CAPTURED_LAYER_ATTRIBUTES = [
+CAPTURED_IMAGE_LAYER_ATTRIBUTES = [
     "name",
     "scale",
     "translate",
@@ -17,6 +22,11 @@
     "visible",
 ]
 
+NOT_CAPTURED_LAYER_ATTRIBUTES = [
+    "metadata",
+    "data",
+]
+
 
 def test_animation(make_napari_viewer):
     """Test creation of an animation class."""
@@ -125,7 +135,7 @@ def test_animation_file_metadata(animation_with_key_frames, tmp_path, ext):
     assert b"https://napari.org" in content
 
 
-@pytest.mark.parametrize("attribute", CAPTURED_LAYER_ATTRIBUTES)
+@pytest.mark.parametrize("attribute", CAPTURED_IMAGE_LAYER_ATTRIBUTES)
 def test_layer_attribute_capture(layer_state, attribute):
     """Test that 'attribute' is captured in the layer state dictionary"""
     for layer_state_dict in layer_state.values():
@@ -139,3 +149,41 @@ def test_end_state_reached(image_animation):
     image_animation.capture_keyframe(steps=2)
     last_state = image_animation._frames[-1]
     assert last_state == image_animation.key_frames[-1].viewer_state
+
+
+@pytest.mark.parametrize("layer_class, data, ndim", layer_test_data)
+def test_attributes_for_all_layer_types(
+    make_napari_viewer, layer_class, data, ndim
+):
+    """Test that attributes are in the viewer_state for all napari layer types"""
+    viewer = make_napari_viewer()
+    add_layer_by_type(viewer, layer_class, data, visible=True)
+    layer_animation = Animation(viewer)
+    # get the state of the layer
+    layer_state = viewer.layers[0]._get_state()
+    # remove attributes that are not captured
+    for key in NOT_CAPTURED_LAYER_ATTRIBUTES:
+        layer_state.pop(key)
+
+    layer_animation.capture_keyframe()
+    # get the layer attributes captured to viewer_state
+    animation_state = layer_animation.key_frames[0].viewer_state.layers[
+        viewer.layers[0].name
+    ]
+
+    assert_layer_state_equal(animation_state, layer_state)
+
+
+@pytest.mark.parametrize("layer_class, data, ndim", layer_test_data)
+def test_animating_all_layer_types(
+    make_napari_viewer, layer_class, data, ndim
+):
+    """Test that all napari layer types can be animated"""
+    viewer = make_napari_viewer()
+    add_layer_by_type(viewer, layer_class, data, visible=True)
+    layer_animation = Animation(viewer)
+    layer_animation.capture_keyframe()
+    layer_animation.viewer.camera.zoom *= 2
+    layer_animation.capture_keyframe()
+    # advance the movie frame, simulating slider movement
+    layer_animation.set_movie_frame_index(1)

napari_animation/utils.py

@@ -31,3 +31,18 @@ def pairwise(iterable):
     a, b = itertools.tee(iterable)
     next(b, None)
     return zip(a, b)
+
+
+def layer_attribute_changed(value, original_value):
+    """Recursively check if a layer attribute has changed."""
+    if isinstance(value, dict):
+        if (
+            not isinstance(original_value, dict)
+            or value.keys() != original_value.keys()
+        ):
+            return True
+        return any(
+            layer_attribute_changed(value[key], original_value[key])
+            for key in value.keys()
+        )
+    return not np.array_equal(value, original_value)

napari_animation/viewer_state.py

@@ -3,6 +3,8 @@
 import napari
 import numpy as np
 
+from napari_animation.utils import layer_attribute_changed
+
 
 @dataclass(frozen=True)
 class ViewerState:
@@ -32,7 +34,7 @@ def from_viewer(cls, viewer: napari.viewer.Viewer):
         }
         for layer_attributes in layers.values():
             layer_attributes.pop("metadata")
-            layer_attributes.pop("properties", None)
+
         return cls(
             camera=viewer.camera.dict(), dims=viewer.dims.dict(), layers=layers
         )
@@ -54,9 +56,13 @@ def apply(self, viewer: napari.viewer.Viewer):
             layer_attributes = layer.as_layer_data_tuple()[1]
             for attribute_name, value in layer_state.items():
                 original_value = layer_attributes[attribute_name]
-                # Only set if value differs to avoid expensive redraws
-                if not np.array_equal(original_value, value):
-                    setattr(layer, attribute_name, value)
+                # Only setattr if value has changed to avoid expensive redraws
+                # dicts can hold arrays, e.g. `color`, requiring comparisons of key/value pairs
+                if layer_attribute_changed(value, original_value):
+                    try:
+                        setattr(layer, attribute_name, value)
+                    except AttributeError:
+                        pass
 
     def render(
         self, viewer: napari.viewer.Viewer, canvas_only: bool = True