matplotlib
diff --git a/‎lib/matplotlib/image.py‎
Lines changed: 68 additions & 23 deletions b/‎lib/matplotlib/image.py‎
Lines changed: 68 additions & 23 deletions
diff --git a/‎lib/matplotlib/tests/baseline_images/test_image/nonuniform_and_pcolor.png‎
3.35 KB b/‎lib/matplotlib/tests/baseline_images/test_image/nonuniform_and_pcolor.png‎
3.35 KB
diff --git a/‎lib/matplotlib/tests/test_image.py‎
Lines changed: 16 additions & 0 deletions b/‎lib/matplotlib/tests/test_image.py‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎setupext.py‎
Lines changed: 0 additions & 1 deletion b/‎setupext.py‎
Lines changed: 0 additions & 1 deletion
diff --git a/‎src/_image.cpp‎
Lines changed: 0 additions & 118 deletions b/‎src/_image.cpp‎
Lines changed: 0 additions & 118 deletions
@@ -1052,14 +1052,51 @@ def make_image(self, renderer, magnification=1.0, unsampled=False):
             self._is_grayscale = False
         vl = self.axes.viewLim
         l, b, r, t = self.axes.bbox.extents
-        width = (round(r) + 0.5) - (round(l) - 0.5)
-        height = (round(t) + 0.5) - (round(b) - 0.5)
-        width *= magnification
-        height *= magnification
-        im = _image.pcolor(self._Ax, self._Ay, A,
-                           int(height), int(width),
-                           (vl.x0, vl.x1, vl.y0, vl.y1),
-                           _interpd_[self._interpolation])
+        width = int(((round(r) + 0.5) - (round(l) - 0.5)) * magnification)
+        height = int(((round(t) + 0.5) - (round(b) - 0.5)) * magnification)
+        x_pix = np.linspace(vl.x0, vl.x1, width)
+        y_pix = np.linspace(vl.y0, vl.y1, height)
+        if self._interpolation == "nearest":
+            x_mid = (self._Ax[:-1] + self._Ax[1:]) / 2
+            y_mid = (self._Ay[:-1] + self._Ay[1:]) / 2
+            x_int = x_mid.searchsorted(x_pix)
+            y_int = y_mid.searchsorted(y_pix)
+            # The following is equal to `A[y_int[:, None], x_int[None, :]]`,
+            # but many times faster.  Both casting to uint32 (to have an
+            # effectively 1D array) and manual index flattening matter.
+            im = (
+                np.ascontiguousarray(A).view(np.uint32).ravel()[
+                    np.add.outer(y_int * A.shape[1], x_int)]
+                .view(np.uint8).reshape((height, width, 4)))
+        else:  # self._interpolation == "bilinear"
+            # Use np.interp to compute x_int/x_float has similar speed.
+            x_int = np.clip(
+                self._Ax.searchsorted(x_pix) - 1, 0, len(self._Ax) - 2)
+            y_int = np.clip(
+                self._Ay.searchsorted(y_pix) - 1, 0, len(self._Ay) - 2)
+            idx_int = np.add.outer(y_int * A.shape[1], x_int)
+            x_frac = np.clip(
+                np.divide(x_pix - self._Ax[x_int], np.diff(self._Ax)[x_int],
+                          dtype=np.float32),  # Downcasting helps with speed.
+                0, 1)
+            y_frac = np.clip(
+                np.divide(y_pix - self._Ay[y_int], np.diff(self._Ay)[y_int],
+                          dtype=np.float32),
+                0, 1)
+            f00 = np.outer(1 - y_frac, 1 - x_frac)
+            f10 = np.outer(y_frac, 1 - x_frac)
+            f01 = np.outer(1 - y_frac, x_frac)
+            f11 = np.outer(y_frac, x_frac)
+            im = np.empty((height, width, 4), np.uint8)
+            for chan in range(4):
+                ac = A[:, :, chan].reshape(-1)  # reshape(-1) avoids a copy.
+                # Shifting the buffer start (`ac[offset:]`) avoids an array
+                # addition (`ac[idx_int + offset]`).
+                buf = f00 * ac[idx_int]
+                buf += f10 * ac[A.shape[1]:][idx_int]
+                buf += f01 * ac[1:][idx_int]
+                buf += f11 * ac[A.shape[1] + 1:][idx_int]
+                im[:, :, chan] = buf  # Implicitly casts to uint8.
         return im, l, b, IdentityTransform()
 
     def set_data(self, x, y, A):
@@ -1183,27 +1220,35 @@ def make_image(self, renderer, magnification=1.0, unsampled=False):
             raise RuntimeError('You must first set the image array')
         if unsampled:
             raise ValueError('unsampled not supported on PColorImage')
-        fc = self.axes.patch.get_facecolor()
-        bg = mcolors.to_rgba(fc, 0)
-        bg = (np.array(bg)*255).astype(np.uint8)
-        l, b, r, t = self.axes.bbox.extents
-        width = (round(r) + 0.5) - (round(l) - 0.5)
-        height = (round(t) + 0.5) - (round(b) - 0.5)
-        width = int(round(width * magnification))
-        height = int(round(height * magnification))
+
         if self._rgbacache is None:
             A = self.to_rgba(self._A, bytes=True)
-            self._rgbacache = A
+            padded_A = np.pad(A, [(1, 1), (1, 1), (0, 0)])
+            self._rgbacache = padded_A
             if self._A.ndim == 2:
                 self._is_grayscale = self.cmap.is_gray()
         else:
-            A = self._rgbacache
+            padded_A = self._rgbacache
+        bg = mcolors.to_rgba(self.axes.patch.get_facecolor(), 0)
+        bg = (np.array(bg) * 255).astype(np.uint8)
+        if (padded_A[0, 0] != bg).all():
+            padded_A[[0, -1], :] = padded_A[:, [0, -1]] = bg
+
+        l, b, r, t = self.axes.bbox.extents
+        width = (round(r) + 0.5) - (round(l) - 0.5)
+        height = (round(t) + 0.5) - (round(b) - 0.5)
+        width = int(round(width * magnification))
+        height = int(round(height * magnification))
         vl = self.axes.viewLim
-        im = _image.pcolor2(self._Ax, self._Ay, A,
-                            height,
-                            width,
-                            (vl.x0, vl.x1, vl.y0, vl.y1),
-                            bg)
+
+        x_pix = np.linspace(vl.x0, vl.x1, width)
+        y_pix = np.linspace(vl.y0, vl.y1, height)
+        x_int = self._Ax.searchsorted(x_pix)
+        y_int = self._Ay.searchsorted(y_pix)
+        im = (  # See comment in NonUniformImage.make_image re: performance.
+            padded_A.view(np.uint32).ravel()[
+                np.add.outer(y_int * padded_A.shape[1], x_int)]
+            .view(np.uint8).reshape((height, width, 4)))
         return im, l, b, IdentityTransform()
 
     def _check_unsampled_image(self):
 
@@ -1224,3 +1224,19 @@ def test_huge_range_log(fig_test, fig_ref):
     ax = fig_ref.subplots()
     im = ax.imshow(data, norm=colors.Normalize(vmin=100, vmax=data.max()),
                    interpolation='nearest', cmap=cm)
+
+
+@image_comparison(["nonuniform_and_pcolor.png"], style="mpl20")
+def test_nonuniform_and_pcolor():
+    axs = plt.figure(figsize=(3, 3)).subplots(3, sharex=True, sharey=True)
+    for ax, interpolation in zip(axs, ["nearest", "bilinear"]):
+        im = NonUniformImage(ax, interpolation=interpolation)
+        im.set_data(np.arange(3) ** 2, np.arange(3) ** 2,
+                    np.arange(9).reshape((3, 3)))
+        ax.images.append(im)
+    axs[2].pcolorfast(  # PColorImage
+        np.arange(4) ** 2, np.arange(4) ** 2, np.arange(9).reshape((3, 3)))
+    for ax in axs:
+        ax.set_axis_off()
+        # NonUniformImage "leaks" out of extents, not PColorImage.
+        ax.set(xlim=(0, 10))
@@ -377,7 +377,6 @@ def get_extensions(self):
         # image
         ext = Extension(
             "matplotlib._image", [
-                "src/_image.cpp",
                 "src/mplutils.cpp",
                 "src/_image_wrapper.cpp",
                 "src/py_converters.cpp",