Again fix translate of overlays (this time with tests)

napari/_vispy/_tests/test_vispy_image_layer.py

@@ -1,6 +1,7 @@
 from itertools import permutations
 
 import numpy as np
+import numpy.testing as npt
 import pytest
 
 from napari._vispy._tests.utils import vispy_image_scene_size
@@ -83,3 +84,118 @@ def test_no_float32_texture_support(monkeypatch):
     )
     image = Image(np.zeros((16, 8, 4, 2), dtype='uint8'), scale=(1, 2, 4, 8))
     VispyImageLayer(image)
+
+
+@pytest.fixture()
+def im_layer() -> Image:
+    return Image(np.zeros((10, 10)))
+
+
+@pytest.fixture()
+def pyramid_layer() -> Image:
+    return Image([np.zeros((20, 20)), np.zeros((10, 10))])
+
+
+def test_base_create(im_layer):
+    VispyImageLayer(im_layer)
+
+
+def set_translate(layer):
+    layer.translate = (10, 10)
+
+
+def set_affine_translate(layer):
+    layer.affine.translate = (10, 10)
+    layer.events.affine()
+
+
+def set_rotate(layer):
+    layer.rotate = 90
+
+
+def set_affine_rotate(layer):
+    layer.affine.rotate = 90
+    layer.events.affine()
+
+
+def no_op(layer):
+    pass
+
+
+@pytest.mark.parametrize(
+    ('translate', 'exp_translate'),
+    [
+        (set_translate, (10, 10)),
+        (set_affine_translate, (10, 10)),
+        (no_op, (0, 0)),
+    ],
+    ids=('translate', 'affine_translate', 'no_op'),
+)
+@pytest.mark.parametrize(
+    ('rotate', 'exp_rotate'),
+    [
+        (set_rotate, ((0, -1), (1, 0))),
+        (set_affine_rotate, ((0, -1), (1, 0))),
+        (no_op, ((1, 0), (0, 1))),
+    ],
+    ids=('rotate', 'affine_rotate', 'no_op'),
+)
+def test_transforming_child_node(
+    im_layer, translate, exp_translate, rotate, exp_rotate
+):
+    layer = VispyImageLayer(im_layer)
+    npt.assert_array_almost_equal(
+        layer.node.transform.matrix[-1][:2], (-0.5, -0.5)
+    )
+    npt.assert_array_almost_equal(
+        layer.node.transform.matrix[:2, :2], ((1, 0), (0, 1))
+    )
+    rotate(im_layer)
+    translate(im_layer)
+    npt.assert_array_almost_equal(
+        layer.node.children[0].transform.matrix[:2, :2], ((1, 0), (0, 1))
+    )
+    npt.assert_array_almost_equal(
+        layer.node.children[0].transform.matrix[-1][:2], (0.5, 0.5)
+    )
+    npt.assert_array_almost_equal(
+        layer.node.transform.matrix[:2, :2], exp_rotate
+    )
+    if translate == set_translate and rotate == set_affine_rotate:
+        npt.assert_array_almost_equal(
+            layer.node.transform.matrix[-1][:2],
+            np.dot(
+                np.linalg.inv(exp_rotate),
+                np.array([-0.5, -0.5]) + exp_translate,
+            ),
+        )
+    else:
+        npt.assert_array_almost_equal(
+            layer.node.transform.matrix[-1][:2],
+            np.dot(np.linalg.inv(exp_rotate), (-0.5, -0.5)) + exp_translate,
+            # np.dot(np.linalg.inv(im_layer.affine.rotate), exp_translate)
+        )
+
+
+def test_transforming_child_node_pyramid(pyramid_layer):
+    layer = VispyImageLayer(pyramid_layer)
+    corner_pixels_world = np.array([[0, 0], [20, 20]])
+    npt.assert_array_almost_equal(
+        layer.node.transform.matrix[-1][:2], (-0.5, -0.5)
+    )
+    npt.assert_array_almost_equal(
+        layer.node.children[0].transform.matrix[-1][:2], (0.5, 0.5)
+    )
+    pyramid_layer.translate = (-10, -10)
+    pyramid_layer._update_draw(
+        scale_factor=1,
+        corner_pixels_displayed=corner_pixels_world,
+        shape_threshold=(10, 10),
+    )
+
+    npt.assert_array_almost_equal(
+        layer.node.transform.matrix[-1][:2], (-0.5, -0.5)
+    )
+    npt.assert_array_almost_equal(
+        layer.node.children[0].transform.matrix[-1][:2], (-9.5, -9.5)
+    )

napari/_vispy/layers/base.py

@@ -214,7 +214,8 @@ def _on_matrix_change(self):
         affine_matrix[: matrix.shape[0], : matrix.shape[1]] = matrix
         affine_matrix[-1, : len(translate)] = translate
 
-        offset = np.zeros(len(self.layer._slice_input.displayed))
+        child_offset = np.zeros(len(self.layer._slice_input.displayed))
+        dims_displayed = self.layer._slice_input.displayed
 
         if self._array_like and self.layer._slice_input.ndisplay == 2:
             # Perform pixel offset to shift origin from top left corner
@@ -230,33 +231,22 @@ def _on_matrix_change(self):
             affine_offset = np.eye(4)
             affine_offset[-1, : len(offset)] = offset[::-1]
             affine_matrix = affine_matrix @ affine_offset
+            if self.layer.multiscale:
+                # Because of performance reason, for multiscale images
+                # we load only visible part of data to GPU.
+                # To place this part of data correctly we update transform,
+                # but this leads to incorrect placement of child layers.
+                # To fix this we need to update child layers transform.
+                child_offset = (
+                    np.ones(offset_matrix.shape[1]) / 2
+                    - self.layer.corner_pixels[0][dims_displayed][::-1]
+                )
+            else:
+                child_offset = np.ones(offset_matrix.shape[1]) / 2
         self._master_transform.matrix = affine_matrix
 
-        # Because of performance reason, for multiscale images
-        # we load only visible part of data to GPU.
-        # To place this part of data correctly we update transform,
-        # but this leads to incorrect placement of child layers.
-        # To fix this we need to update child layers transform.
-        dims_displayed = self.layer._slice_input.displayed
-        simplified_transform = self.layer._transforms.simplified
-        if simplified_transform is None:
-            raise ValueError(
-                'simplified transform is None'
-            )  # pragma: no cover
-        translate_child = (
-            self.layer.translate[dims_displayed]
-            + self.layer.affine.translate[dims_displayed]
-        )[::-1] - offset[::-1]
-        trans_rotate = simplified_transform.rotate[
-            np.ix_(dims_displayed, dims_displayed)
-        ]
-        trans_scale = simplified_transform.scale[dims_displayed][::-1]
-        new_translate = (
-            trans_rotate @ (translate_child - translate) / trans_scale
-        )
-
         child_matrix = np.eye(4)
-        child_matrix[-1, : len(translate)] = new_translate
+        child_matrix[-1, : len(child_offset)] = child_offset
         for child in self.node.children:
             child.transform.matrix = child_matrix