Scale images with PIL preserving transparency and color?

Question

Say you want to scale a transparent image but do not yet know the color(s) of the background you will composite it onto later. Unfortunately PIL seems to incorporate the color v

Answer 1

Maybe you can fill the whole image with the color you want, and only create the shape in the alpha channnel?

Answer 2

It appears that PIL doesn't do alpha pre-multiplication before resizing, which is necessary to get the proper results. Fortunately it's easy to do by brute force. You must then do the reverse to the resized result.

def premultiply(im):
    pixels = im.load()
    for y in range(im.size[1]):
        for x in range(im.size[0]):
            r, g, b, a = pixels[x, y]
            if a != 255:
                r = r * a // 255
                g = g * a // 255
                b = b * a // 255
                pixels[x, y] = (r, g, b, a)

def unmultiply(im):
    pixels = im.load()
    for y in range(im.size[1]):
        for x in range(im.size[0]):
            r, g, b, a = pixels[x, y]
            if a != 255 and a != 0:
                r = 255 if r >= a else 255 * r // a
                g = 255 if g >= a else 255 * g // a
                b = 255 if b >= a else 255 * b // a
                pixels[x, y] = (r, g, b, a)

Result:

Answer 3

sorry for answering myself but this is the only working solution that I know of. It sets the color values of fully transparent pixels to the average of the surrounding non fully transparent pixels to minimize impact of fully transparent pixel colors while resizing. There are special cases where the proper result will not be achieved.

It is very ugly and slow. I'd be happy to accept your answer if you can come up with something better.

# might be possible to speed this up by only processing necessary pixels
#  using scipy dilate, numpy where

import PIL.Image

filename = "trans.png"  # http://qrc-designer.com/stuff/trans.png
size = (25,25)

import numpy as np

im = PIL.Image.open(filename)

npImRgba = np.asarray(im, dtype=np.uint8)
npImRgba2 = np.asarray(im, dtype=np.uint8)
npImRgba2.flags.writeable = True
lenY = npImRgba.shape[0]
lenX = npImRgba.shape[1]
for y in range(npImRgba.shape[0]):
    for x in range(npImRgba.shape[1]):
        if npImRgba[y, x, 3] != 0:  # only change completely transparent pixels
            continue        
        colSum = np.zeros((3), dtype=np.uint16)
        i = 0
        for oy in [-1, 0, 1]:
            for ox in [-1, 0, 1]:
                if not oy and not ox:
                    continue
                iy = y + oy
                if iy < 0:
                    continue
                if iy >= lenY:
                    continue
                ix = x + ox
                if ix < 0:
                    continue
                if ix >= lenX:
                    continue
                col = npImRgba[iy, ix]
                if not col[3]:
                    continue
                colSum += col[:3]
                i += 1
        npImRgba2[y, x, :3] = colSum / i

im = PIL.Image.fromarray(npImRgba2)
im = im.transform(size, PIL.Image.EXTENT, (0,0) + im.size, PIL.Image.LINEAR)
im.save("slime_"+filename)

result:

Answer 4

You can resample each band individually:

im.load()
bands = im.split()
bands = [b.resize(size, Image.LINEAR) for b in bands]
im = Image.merge('RGBA', bands)

EDIT

Maybe by avoiding high transparency values like so (need numpy)

import numpy as np

# ...

im.load()
bands = list(im.split())
a = np.asarray(bands[-1])
a.flags.writeable = True
a[a != 0] = 1
bands[-1] = Image.fromarray(a)
bands = [b.resize(size, Image.LINEAR) for b in bands]
a = np.asarray(bands[-1])
a.flags.writeable = True
a[a != 0] = 255
bands[-1] = Image.fromarray(a)
im = Image.merge('RGBA', bands)