This is just a post to document an attempt and the difficulties I ran into. Good for me to reference when I try again, or perhaps useful if anyone else takes a peek.

I tried to give (while crossing my fingers) _png.write_png a 32-Bit RGBA bitmap from a numpy array as an experiment:

%matplotlib nbagg

import pylab
from matplotlib.backends.backend_agg import FigureCanvasAgg
from matplotlib import _png
import numpy as np

pylab.plot([1,2,3])

canvas = pylab.get_current_fig_manager().canvas
agg = canvas.switch_backends(FigureCanvasAgg)
agg.draw()

s = agg.buffer_rgba()
# get the width and the height to resize the matrix
l,b,w,h = agg.figure.bbox.bounds
w, h = int(w), int(h)

s = np.array(s.tolist()).reshape((w,h,4)) #Convert to RGBA to np.array

filename_or_obj = 'testwrite.png'
renderer = agg.renderer

with open(filename_or_obj, 'wb') as fn:
    _png.write_png(memoryview(s), fn, agg.figure.dpi)

Get error: IndexError: Unexpected SeqBase<T> length.

I think it has to do with write_png wants s to have a array_view::converter_contiguous method:

Haven't figured a way around that yet. The goal is to then use numpy to flatten RGBA -> RGB to see if something like this would work for making the animations better by default.

EDIT: This error has been fixed. I was referencing github src code for write_png (which wants 2 or 3 arguments) where matplotlib 1.4.3 wanted 5 arguments for width and height. I guess this has changed since. Note, whoever changed the error message to Unexpected SeqBase<T> to write_png wnats at most 3 arguments... kodus 👍

Could you try setting blit=False It looks to me like the issue is that the frames are not blitted correctly and all frames but the first ones are have the text plotted multiple times.

I got the same results with blit=False. I also tried using writer=imagemagick_file to see what frames we are giving imagemagick and here are a few samples:

I used convert's +adjoin argument to deconstruct those frames from the gif and this is what they look like:

It looks like imagemagick really wants to keep the alpha channel (as shown in the first gif), but is then forced to decide between full alpha or no alpha which is what gives the pixelated appearance, and then for the later frames I guess it gives up on the whole alpha channel idea for some reason unknown to me.

Issue update:

I have written some quick code as a possible solution, but I ran into issues with animations in my git-installed version of matplotlib. I will need to figure this out, but here is something I was considering:

    if kwargs.pop('flatten', False):
        bg = mcolors.colorConverter.to_rgb(
                 rcParams.get('savefig.facecolor', 'white'))
        bg = tuple([int(x * 255.0) for x in bg])
        w, h = int(renderer.width), int(renderer.height)

        src_a = renderer.buffer_rgba()
        src_a = np.array(memoryview(src_a))
        src_a = src_a.reshape((w,h,4))

        alpha = src_a[:,:,3]
        src = src_a[:,:,0:3]

        dest = np.empty((w,h,3))  
        dest[:,:,0] = (255 - alpha)*bg[0] + alpha*src[:,:,0]    #Red
        dest[:,:,1] = (255 - alpha)*bg[1] + alpha*src[:,:,1]    #Green
        dest[:,:,2] = (255 - alpha)*bg[2] + alpha*src[:,:,2]    #Blue
        dest = (dest/255).astype(np.uint8)                      #24-bit RGB, flattened

        _png.write_png(dest, filename_or_obj, self.figure.dpi)
    else:
         _png.write_png(renderer._renderer, filename_or_obj, self.figure.dpi)

This would add an flatten kwarg in savefig that can be called when animation.py when it wants it.

Closing, as I don't see the issue with current nbagg and master matplotlib. OTOH, feel free to reopen if I'm in error.