…code, cg, electronics, 3d printing…

From over on my PyGame Wiki…

There doesn’t seem to be a built in way in PyGame to ‘blur’ a surface, but you can fake it bay scaling the surface twice: Scale it small once, then scale it back to normal size.

def blurSurf(surface, amt):
    """
    Blur the given surface by the given 'amount'.  Only values 1 and greater
    are valid.  Value 1 = no blur.
    """
    if amt < 1.0:
        raise ValueError("Arg 'amt' must be greater than 1.0, passed in value is %s"%amt)
    scale = 1.0/float(amt)
    surf_size = surface.get_size()
    scale_size = (int(surf_size[0]*scale), int(surf_size[1]*scale))
    surf = pygame.transform.smoothscale(surface, scale_size)
    surf = pygame.transform.smoothscale(surf, surf_size)
    return surf

You can also use pygame.transform.rotozoom() in place of smoothscale. However, they have different effects: smoothscale appears to blur (and push) the pixels ‘outward’ based on the center of the surface, while rotozoom blurs (and pushes) them outward based on the top left corner of the image (0,0), effectively making them translate down and to the right in the process.
http://www.pygame.org/docs/ref/transform.html#pygame.transform.smoothscale
http://www.pygame.org/docs/ref/transform.html#pygame.transform.rotozoom

Other methods I haven’t investigated would involve running a convolve routine on the surface pixels.  As is, I’m not sure how could the performance would be though.

I’d be interested to know what methods others have come up with to solve this problem.  My searching hasn’t come up with much.

Since I never ‘went to school’ for any kind of programming, I’ve had to pick it up as needed throughout my career.  One of the ‘great mysteries’ has been matrix math.  I’m a visual person, and that includes learning math.  Last night, while reading chapter 9 in my PyGame book ‘Beginning Game Development with Python and PyGame: From Novice to Professional‘, the whole ‘matrix thing’ finally made sense in my brain.  So much in fact, I couldn’t fall asleep I was mulling it over so much.  Waking up, I decided to dive into it, and made some psuedo-code showing how matrix multiplication happens.  But it was still really hard to physically visualize what was going on.  So, working in GIMP, I made a graphical layout of what is going on.  It is a work of beauty

Couple things are presumed:  It is a description of multiplying two 4×4 matrices, with their translation along the bottom row, not the right column.  In each of the sixteen blocks, the sub-matrices (‘matrixA’ on the left, ‘matrixB’ on the right) are multiplied left to right, and added top to bottom to get the final result of each block.  Time for a t-shirt!

Click through (twice) for a larger version.
You can find it on flickr here as well.