This looks interesting. Thanks for working on it.

Since I’m not into the topic I can dare to ask the stupid questions:

• Is it correct that an Artist and its blend mode define completely how they blend with “the background” I.e. all previously drawn artists? In particular, this does not depend on the blend mode of the other artists.
• Are all these blend modes parameter-less?

• Is it correct that an Artist and its blend mode define completely how they blend with “the background” I.e. all previously drawn artists? In particular, this does not depend on the blend mode of the other artists.

Yup, that is correct: the history of how that "background" was constructed has no bearing on how the next Artist is blended in using its specific blend mode.

It's also important to remember that that the "empty" background of an Axes is solid white, and thus not actually empty as far as these blend modes are concerned. For example, using "screen" to blend in an image on a truly empty background will just return the image, but on a white background will return solid white, which can make it look instead like the image call failed. That's why I turn off the face colors in my example above.

What I still need to investigate is how my changes interact with collections of Artists. A user may want "over" blending (the default) within the collection before using a different blend mode for the collection as a whole.

• Are all these blend modes parameter-less?

Yes. In principle, the transformation functions for the hue/saturation/color/luminosity operators could have more than one possibility, but in practice I think everyone has simply used the same functions for decades (as defined in the PDF specification).

This is pretty cool :-)

It's also important to remember that that the "empty" background of an Axes is solid white, and thus not actually empty as far as these blend modes are concerned. For example, using "screen" to blend in an image on a truly empty background will just return the image, but on a white background will return solid white, which can make it look instead like the image call failed. That's why I turn off the face colors in my example above.

What I still need to investigate is how my changes interact with collections of Artists. A user may want "over" blending (the default) within the collection before using a different blend mode for the collection as a whole.

Actually I suspect that another possibility is to want some nonstandard blending between multiple artists, then "over" blending of the result over the background.

In general I suspect this would be related to adding support for temporary, intermediate rendering buffers, which is also something that would be useful for other purposes e.g. contour label overplotting (#26971 (comment)).

By the way, I decided to rename "over" to "normal". That mode of blending is referred to as "normal" often enough, and it makes it readily apparent to users that it is the standard choice (and the default).

but what I'm currently trying out for plotting-level API is a helper class: ArtistGroup in #31162 (comment),

If I'm following that correctly than the PathCollection would need to get wrapped in an ArtistGroup, so something like splatterplot would be implemented as a standalone method rather than an argument to scatter?

Which is fine/ a good example to post to the gallery, just thinking through where/how this is exposed.

Per the discussion at today's dev meeting, the renderer methods to open/close an isolated transparency group are implemented as new methods open_blend_group()/close_blend_group() rather than expanding the existing methods open_group()/close_group(). The separation is definitely cleaner, especially with the docstring.

My niggling concern is that both open_group() and open_blend_group() accept a string as the sole required argument, a developer could get tripped up by accidentally typing, e.g., open_group("difference") instead of open_blend_group("difference") and being mystified why it's not blending as intended. Do folks think it would be reasonable for me to have open_group() check whether the specified group name is equal to the name of a blend mode, and if it is, emit a warning that the developer that open_blend_group() is probably what was intended to be called?

The problem is that the main(?) point of open_group is to allow naming of svg groups (<g>); I assume that if third-parties are using those the group names tend to be programmatically set (e.g. matching a preexisting object hierarchy) so it would be annoying to hit warnings. If you are really worried about the potential confusion (I'm not so sure about that) I would suggest making the parameters to open_group keyword-only, which should clarify the matter...

Yeah, I think you're right on not putting in a warning. The false positive of emitting a warning when someone legitimately wants to name an SVG group something totally reasonable like "overlay" is not worth mitigating the hypothetical confusion of someone mistakenly calling open_group() instead of open_blend_group(). When the group isn't blending as they desire, hopefully they pull up the docstring on the method they are calling and that will immediately reveal the error to them.

I've implemented two more Porter-Duff compositing operators – "source" and "clear" – for both Agg and Cairo backends, but I think "source" is too confusing of a name. Since "source" provides the similar behavior as a knockout group, I have renamed it "knockout" for blend_mode.

I've now implemented that a blend group can be an isolated group, a knockout group, both, or neither. Isolated groups are supported by all non-PS backends. Knockout groups are supported by only the PDF and PGF backends.

Even though Agg/Cairo do not support proper knockout groups, it is straightforward to simulate an isolated + knockout group by using blend_mode="knockout" instead. A non-isolated + knockout group would be more cumbersome to assemble.

Agg

Top-right panel is not supported

Cairo

Top-right panel is not supported

SVG

Right column is not supported

PDF

Figure_1.pdf

Generating code

import matplotlib
#matplotlib.use('TkCairo')

import numpy as np

import matplotlib.pyplot as plt
from matplotlib.artist import Artist
from matplotlib.patches import Circle
from matplotlib.backends.backend_agg import RendererAgg
from matplotlib.backends.backend_cairo import RendererCairo

class ArtistGroup(Artist):
    def __init__(self, artist_list, *, group_blend_mode=None, group_alpha=1, knockout=False):
        self._artist_list = artist_list
        self._group_blend_mode = group_blend_mode
        self._group_alpha = group_alpha
        self._knockout = knockout
        super().__init__()

    def draw(self, renderer):
        alternate = isinstance(renderer, (RendererAgg, RendererCairo)) and self._knockout and self._group_blend_mode is not None
        knockout = False if alternate else self._knockout
        renderer.open_blend_group(self._group_blend_mode, alpha=self._group_alpha, knockout=knockout)
        for a in self._artist_list:
            if not a.is_transform_set():
                a.set_transform(self.get_transform())
            if alternate:
                saved_blend_mode = a.get_blend_mode()
                a.set_blend_mode('knockout')
            a.draw(renderer)
            if alternate:
                a.set_blend_mode(saved_blend_mode)
        renderer.close_blend_group()


fig, axs = plt.subplots(2, 2, figsize=(6, 6), layout='constrained')
fig.set_facecolor("none")

for i, group_blend_mode in enumerate([None, "normal"]):
    for j, knockout in enumerate([False, True]):
        axs[i, j].set_facecolor("none")
        axs[i, j].set_xlim(-1, 1)
        axs[i, j].set_ylim(-1, 1)
        axs[i, j].set_aspect("equal")

        axs[i, j].imshow(np.arange(20*20).reshape((20, 20)) % 19,
                      cmap='Spectral', extent=[-1, 1, -1, 1])

        left = Circle((-0.25, 0), 0.6, fc='y', alpha=0.75, blend_mode='multiply')
        right = Circle((0.25, 0), 0.6, fc='g', alpha=0.75, blend_mode='multiply')

        both = ArtistGroup([left, right], group_blend_mode=group_blend_mode, knockout=knockout)
        axs[i, j].add_artist(both)

axs[0, 0].set_title('non-knockout')
axs[0, 1].set_title('knockout')
axs[0, 0].set_ylabel('non-isolated')
axs[1, 0].set_ylabel('isolated')

plt.show()