matplotlib
diff --git a/‎lib/matplotlib/tests/test_image.py
Copy file name to clipboardExpand all lines: lib/matplotlib/tests/test_image.py
+37-2Lines changed: 37 additions & 2 deletions b/‎lib/matplotlib/tests/test_image.py
Copy file name to clipboardExpand all lines: lib/matplotlib/tests/test_image.py
+37-2Lines changed: 37 additions & 2 deletions
diff --git a/‎src/_image_wrapper.cpp
Copy file name to clipboardExpand all lines: src/_image_wrapper.cpp
+5-3Lines changed: 5 additions & 3 deletions b/‎src/_image_wrapper.cpp
Copy file name to clipboardExpand all lines: src/_image_wrapper.cpp
+5-3Lines changed: 5 additions & 3 deletions
@@ -9,7 +9,7 @@
 import urllib.request
 
 import numpy as np
-from numpy.testing import assert_array_equal
+from numpy.testing import assert_allclose, assert_array_equal
 from PIL import Image
 
 import matplotlib as mpl
@@ -18,7 +18,7 @@
 from matplotlib.image import (AxesImage, BboxImage, FigureImage,
                               NonUniformImage, PcolorImage)
 from matplotlib.testing.decorators import check_figures_equal, image_comparison
-from matplotlib.transforms import Bbox, Affine2D, TransformedBbox
+from matplotlib.transforms import Bbox, Affine2D, Transform, TransformedBbox
 import matplotlib.ticker as mticker
 
 import pytest
@@ -1641,6 +1641,41 @@ def test__resample_valid_output():
         resample(np.zeros((9, 9)), out)
 
 
+@pytest.mark.parametrize("data, interpolation, expected",
+    [(np.array([[0.1, 0.3, 0.2]]), mimage.NEAREST,
+      np.array([[0.1, 0.1, 0.1, 0.3, 0.3, 0.3, 0.3, 0.2, 0.2, 0.2]])),
+     (np.array([[0.1, 0.3, 0.2]]), mimage.BILINEAR,
+      np.array([[0.1, 0.1, 0.15078125, 0.21096191, 0.27033691,
+                 0.28476562, 0.2546875, 0.22460938, 0.20002441, 0.20002441]])),
+    ]
+)
+def test__resample_nonaffine(data, interpolation, expected):
+    # Test that equivalent affine and nonaffine transforms resample the same
+
+    # Create a simple affine transform for scaling the input array
+    affine_transform = Affine2D().scale(sx=expected.shape[1] / data.shape[1], sy=1)
+
+    affine_result = np.empty_like(expected)
+    mpl._image.resample(data, affine_result, affine_transform,
+                        interpolation=interpolation)
+    assert_allclose(affine_result, expected)
+
+    # Create a nonaffine version of the same transform
+    # by compositing with a nonaffine identity transform
+    class NonAffineIdentityTransform(Transform):
+        input_dims = 2
+        output_dims = 2
+
+        def inverted(self):
+           return self
+    nonaffine_transform = NonAffineIdentityTransform() + affine_transform
+
+    nonaffine_result = np.empty_like(expected)
+    mpl._image.resample(data, nonaffine_result, nonaffine_transform,
+                        interpolation=interpolation)
+    assert_allclose(nonaffine_result, expected, atol=5e-3)
+
+
 def test_axesimage_get_shape():
     # generate dummy image to test get_shape method
     ax = plt.gca()
 
@@ -54,7 +54,7 @@ _get_transform_mesh(const py::object& transform, const py::ssize_t *dims)
     /* TODO: Could we get away with float, rather than double, arrays here? */
 
     /* Given a non-affine transform object, create a mesh that maps
-    every pixel in the output image to the input image.  This is used
+    every pixel center in the output image to the input image.  This is used
     as a lookup table during the actual resampling. */
 
     // If attribute doesn't exist, raises Python AttributeError
@@ -66,8 +66,10 @@ _get_transform_mesh(const py::object& transform, const py::ssize_t *dims)
 
     for (auto y = 0; y < dims[0]; ++y) {
         for (auto x = 0; x < dims[1]; ++x) {
-            *p++ = (double)x;
-            *p++ = (double)y;
+            // The convention for the supplied transform is that pixel centers
+	    // are at 0.5, 1.5, 2.5, etc.
+            *p++ = (double)x + 0.5;
+            *p++ = (double)y + 0.5;
         }
     }