Efficiently masking a surface in pygame

Question

I need to draw a circle filled with random gray colors and a black outline using pygame. This is what it should look like:

The radius increases by expansion_speed * dt every frame and the surface is updated 60 times per second, so however this is achieved (if even possible) needs to be fast. I tried masking an stored texture but that was too slow. My next idea was to read the pixels from this stored texture and only replace the difference between the last and current surfaces. I tried this too but was unable to translate the idea to code.

So how can this be done?

Answer 1

See my update to your previous related question. It has some info about performance. You could try to enable hardware acceleration in fullscreen mode, but I never personally tried it, so can't give good advice how to do it properly. Just use two differnt colorkeys for extracting circle from noise and putting the whole surface to the display. Note that if your Noise surface has pixels same as colorkey color then they also become transparent.
This example I think is what you are trying to get, move the circle with mouse and hold CTRL key to change radius.
Images:

import os, pygame
pygame.init()
w = 800
h = 600
DISP = pygame.display.set_mode((w, h), 0, 24)
clock = pygame.time.Clock( ) 

tile1 = pygame.image.load("2xtile1.png").convert()
tile2 = pygame.image.load("2xtile2.png").convert()
tw = tile1.get_width()
th = tile1.get_height()
Noise = pygame.Surface ((w,h))
Background = pygame.Surface ((w,h))
for py in range(0, h/th + 2) :
    for px in range(0, w/tw + 2):
        Noise.blit(tile1, (px*(tw-1), py*(th-1) ) )
        Background.blit(tile2, (px*(tw-1), py*(th-1) ) )

color_key1 = (0, 0, 0)
color_key2 = (1, 1, 1)
Circle = pygame.Surface ((w,h))
Circle.set_colorkey(color_key1)
Mask = pygame.Surface ((w,h))
Mask.fill(color_key1)
Mask.set_colorkey(color_key2)

strokecolor = (10, 10, 10)
DISP.blit(Background,(0,0))

def put_circle(x0, y0, r, stroke):
    pygame.draw.circle(Mask, strokecolor, (x0,y0), r, 0)
    pygame.draw.circle(Mask, color_key2, (x0,y0), r - stroke, 0)
    Circle.blit(Noise,(0,0))
    Circle.blit(Mask,(0,0))
    dirtyrect  = (x0 - r, y0 - r, 2*r, 2*r)
    Mask.fill(color_key1, dirtyrect)
    DISP.blit(Circle, (0,0))

X = w/2
Y = h/2
R = 100
stroke = 2
FPS = 25
MainLoop = True
pygame.mouse.set_visible(False)
pygame.event.set_grab(True)

while MainLoop :
    clock.tick(FPS)
    pygame.event.pump()
    Keys = pygame.key.get_pressed()
    MR  = pygame.mouse.get_rel()        # get mouse shift
    if Keys [pygame.K_ESCAPE] :
        MainLoop = False
    if Keys [pygame.K_LCTRL] :
        R = R + MR[0]
        if R <= stroke : R = stroke
    else :
        X = X + MR[0] 
        Y = Y + MR[1] 
    DISP.blit(Background,(0,0))
    put_circle(X, Y, R, stroke)
    pygame.display.flip( )

pygame.mouse.set_visible(True)
pygame.event.set_grab(False)
pygame.quit( )

Answer 2

Many years ago we had a font rendering challenge with the Pygame project.

Someone created an animated static text for the contest but it was far too slow.

We put our heads together and made a much quicker version. Step one was to create a smallish image with random noise. Something like 64x64. You may need a bigger image if your final image is large enough to notice the tiling.

Every frame you blit the tiled noise using a random offset. Then you take an image with the mask, in your case an inverted circle, and draw that on top. That should give you a final image containing just the unmasked noise.

The results were good. In our case it was not noticeable that the noise was just jittering around. That may be because the text did not have a large unobstrcted area. I'd be concerned your large circle would make the trick appear obvious. i guess if you really had a large enough tiled image it would still work.

The results and final source code are still online at the Pygame website, http://www.pygame.org/pcr/static_text/index.php