Does this replace #30175?

Yes, so I'll close #30175

I've made changes to how the Agg resampler handles affine transforms when using nearest-neighbor interpolation, and now drawing using an affine transform also gives optimal results.

To elaborate, the issue at hand is that the Agg resampler uses an integer-based interpolator for affine resampling (see some details in #30184 (comment)). The resulting inaccuracies can be obvious when using nearest-neighbor interpolation. This PR replaces that interpolator with a floating-point-based interpolator, and qualitatively there is no discernable performance hit.

As a nice benefit of this change, the solution described in #30184 (comment) – falling back to nonaffine resampling under extreme zooms – is no longer necessary to preserve the alignment of pixel edges.

To be safe performance-wise, affine resampling under non-nearest-neighbor interpolation continues to use the integer-based interpolator. Unlike with nearest-neighbor interpolation, it's very difficult to tell if there are slight inaccuracies with the interpolator. This can be revisited in the future.

Even with the fixing the affine resampling, the resampled image continued to sometimes have a gap at the end. It turns out that a rendering box was being applied to affine resampling, even under nearest-neighbor interpolation, and that could hinder the rendering of the edges. Under nearest-neighbor interpolation, the interpolation is now calculated exactly correctly, so there is no longer a need to apply a rendering box, which avoids the occasional appearance of gaps between the image and the axes spines.

The reason for the rendering box was for non-nearest-neighbor interpolation. To resample up to the edge of the image, the code uses the assumption of reflection wrapping on all edges. For nearest-neighbor interpolation, this PR now fills to zero beyond the bounds of the source image instead of reflection wrapping, which allows us to avoid a rendering box.

For arbitrary nonaffine resampling, a rendering box cannot be reliably defined, so nonaffine resampling has had the long-standing bug of always showing the reflection wrapping.

Before this PR

The same removal of reflection wrapping done for affine resampling under nearest-neighbor interpolation can be done for nonaffine resampling under nearest-neighbor interpolation,

After this PR

Fixing the nonaffine resampling under non-nearest-neighbor interpolation is a more challenging problem, and must be deferred to a future effort.

Generating code

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.patches import Rectangle
from matplotlib.transforms import Affine2D, Transform

# Create a nonaffine identity to easily convert an affine transform to its nonaffine equivalent
class NonAffineIdentityTransform(Transform):
    input_dims = 2
    output_dims = 2

    def inverted(self):
        return self
nonaffine_identity = NonAffineIdentityTransform()

fig, axs = plt.subplots(2, 3)

N = 11

interpolation = ['nearest', 'hanning', 'bilinear']

for j in range(3):
    data = np.arange(N**2).reshape((N, N))
    data = data / N**2 + (data % 4) / 6
    rotation = Affine2D().rotate_around(N/2-0.5, N/2-0.5, 1)

    for i in range(2):
        if i == 0:
            axs[i, j].imshow(data, cmap='Grays', interpolation=interpolation[j],
                             transform=rotation + axs[i, j].transData)
            axs[i, j].set_title(f"{interpolation[j]}\naffine")
        else:
            axs[i, j].imshow(data, cmap='Grays', interpolation=interpolation[j],
                             transform=nonaffine_identity + rotation + axs[i, j].transData)
            axs[i, j].set_title('nonaffine')

        axs[i, j].set_axis_off()
        box = Rectangle((-0.5, -0.5), N, N,
                        edgecolor='red', facecolor='none', lw=0.5, ls='dashed',
                        transform=rotation + axs[i, j].transData)
        axs[i, j].add_artist(box)

plt.show()

This PR now also fixes the pixel alignment for PcolorImage and NonUniformImage. The coordinates are specified differently (edges versus centers) for these two image types, so the two types are not supposed to agree. Just look at the pixel alignment to grid lines in the upper right of each panel (away from the yellow/red box).

Before this PR

After this PR

Generating code

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.image import NonUniformImage
from matplotlib.patches import Rectangle

fig, axs = plt.subplots(2, 3)

N = [4, 9, 11]

for j in range(3):
    data = np.arange(N[j]**2).reshape((N[j], N[j])) % 5
    seps = np.arange(-0.5, N[j] + 1)

    x_edges = np.arange(-0.5, N[j])
    x_edges[2:] += 1
    y_edges = np.arange(-0.5, N[j])
    y_edges[3:] += 1

    x_mids = (x_edges[:-1] + x_edges[1:]) / 2
    y_mids = (y_edges[:-1] + y_edges[1:]) / 2

    for i in range(2):
        if i == 0:
            axs[i, j].pcolorfast(x_edges, y_edges, data, cmap='Grays', interpolation='nearest')
            axs[i, j].set_title('PcolorImage')
        else:
            im = NonUniformImage(axs[i, j], interpolation='nearest', cmap='Grays')
            im.set_data(x_mids, y_mids, data)
            axs[i, j].add_image(im)
            axs[i, j].set_title('NonUniformImage')

        axs[i, j].set_aspect('equal')
        axs[i, j].set_axis_off()
        axs[i, j].vlines(seps, -1, N[j] + 1, lw=0.5, color='red', ls='dashed')
        axs[i, j].hlines(seps, -1, N[j] + 1, lw=0.5, color='red', ls='dashed')

        box = Rectangle((0.5, 1.5), 2, 2, edgecolor='yellow', facecolor='none', lw=1)
        axs[i, j].add_artist(box)

plt.show()

please add a bit more context to the commit messages; it is helpful to find out the why of a change without having to search out the PR.

Sure, I've added a bunch of sentences to the commit messages

I'd like to keep the individual commits, so please squash the fixups into the originals. I assume that a lot of the commits affect test images repeatedly, so it's probably fine to keep those updates in a single separate commit.

Sure, I've squashed the commits down to nine commits