matplotlib
diff --git a/‎lib/matplotlib/tests/test_image.py
Lines changed: 37 additions & 2 deletions b/‎lib/matplotlib/tests/test_image.py
Lines changed: 37 additions & 2 deletions
diff --git a/‎src/_image_wrapper.cpp
Lines changed: 2 additions & 2 deletions b/‎src/_image_wrapper.cpp
Lines changed: 2 additions & 2 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]]), mpl._image.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]]), mpl._image.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)
+
+
 def test_axesimage_get_shape():
     # generate dummy image to test get_shape method
     ax = plt.gca()
 
@@ -66,8 +66,8 @@ _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;
+            *p++ = (double)x + 0.5;
+            *p++ = (double)y + 0.5;
         }
     }
Original file line number	Diff line number	Diff line change
`@@ -66,8 +66,8 @@ _get_transform_mesh(const py::object& transform, const py::ssize_t *dims)`
`66`	`66`
`67`	`67`	`for (auto y = 0; y < dims[0]; ++y) {`
`68`	`68`	`for (auto x = 0; x < dims[1]; ++x) {`
`69`		`- *p++ = (double)x;`
`70`		`- *p++ = (double)y;`
	`69`	`+ *p++ = (double)x + 0.5;`
	`70`	`+ *p++ = (double)y + 0.5;`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`