Ответ 1

Здесь версия, которая намного проще - не уверен, насколько она эффективна. Сильно основано на некотором фрагменте django, который я нашел при создании поддержки RGBA -> JPG + BG для сортировки миниатюр.

from PIL import Image

png = Image.open(object.logo.path)
png.load() # required for png.split()

background = Image.new("RGB", png.size, (255, 255, 255))
background.paste(png, mask=png.split()[3]) # 3 is the alpha channel

background.save('foo.jpg', 'JPEG', quality=80)

Результат @80%

Результат @50%

Ответ 2

Используя Image.alpha_composite, решение Yuji 'Tomita' Tomita упрощается. Этот код может избежать ошибки tuple index out of range, если png не имеет альфа-канала.

from PIL import Image

png = Image.open(img_path).convert('RGBA')
background = Image.new('RGBA', png.size, (255,255,255))

alpha_composite = Image.alpha_composite(background, png)
alpha_composite.save('foo.jpg', 'JPEG', quality=80)

Ответ 3

Прозрачные части в основном имеют значение RGBA (0,0,0,0). Поскольку JPG не имеет прозрачности, значение jpeg устанавливается на (0,0,0), что является черным.

Вокруг круглого значка есть пиксели с ненулевыми значениями RGB, где A = 0. Таким образом, они выглядят прозрачными в PNG, но смешными в JPG.

Вы можете установить все пиксели, где A == 0, чтобы иметь R = G = B = 255, используя numpy следующим образом:

import Image
import numpy as np

FNAME = 'logo.png'
img = Image.open(FNAME).convert('RGBA')
x = np.array(img)
r, g, b, a = np.rollaxis(x, axis = -1)
r[a == 0] = 255
g[a == 0] = 255
b[a == 0] = 255
x = np.dstack([r, g, b, a])
img = Image.fromarray(x, 'RGBA')
img.save('/tmp/out.jpg')

Обратите внимание, что логотип также имеет некоторые полупрозрачные пиксели, используемые для сглаживания краев вокруг слов и значков. Сохранение в jpeg игнорирует полупрозрачность, что приводит к тому, что результирующий jpeg выглядит неровно.

Более качественный результат можно сделать с помощью команды imagemagick convert:

convert logo.png -background white -flatten /tmp/out.jpg

Чтобы сделать более качественную смесь с использованием numpy, вы можете использовать альфа-компоновку:

import Image
import numpy as np

def alpha_composite(src, dst):
    '''
    Return the alpha composite of src and dst.

    Parameters:
    src -- PIL RGBA Image object
    dst -- PIL RGBA Image object

    The algorithm comes from http://en.wikipedia.org/wiki/Alpha_compositing
    '''
    # http://stackoverflow.com/a/3375291/190597
    # http://stackoverflow.com/a/9166671/190597
    src = np.asarray(src)
    dst = np.asarray(dst)
    out = np.empty(src.shape, dtype = 'float')
    alpha = np.index_exp[:, :, 3:]
    rgb = np.index_exp[:, :, :3]
    src_a = src[alpha]/255.0
    dst_a = dst[alpha]/255.0
    out[alpha] = src_a+dst_a*(1-src_a)
    old_setting = np.seterr(invalid = 'ignore')
    out[rgb] = (src[rgb]*src_a + dst[rgb]*dst_a*(1-src_a))/out[alpha]
    np.seterr(**old_setting)    
    out[alpha] *= 255
    np.clip(out,0,255)
    # astype('uint8') maps np.nan (and np.inf) to 0
    out = out.astype('uint8')
    out = Image.fromarray(out, 'RGBA')
    return out            

FNAME = 'logo.png'
img = Image.open(FNAME).convert('RGBA')
white = Image.new('RGBA', size = img.size, color = (255, 255, 255, 255))
img = alpha_composite(img, white)
img.save('/tmp/out.jpg')

Ответ 4

Здесь решение в чистом PIL.

def blend_value(under, over, a):
    return (over*a + under*(255-a)) / 255

def blend_rgba(under, over):
    return tuple([blend_value(under[i], over[i], over[3]) for i in (0,1,2)] + [255])

white = (255, 255, 255, 255)

im = Image.open(object.logo.path)
p = im.load()
for y in range(im.size[1]):
    for x in range(im.size[0]):
        p[x,y] = blend_rgba(white, p[x,y])
im.save('/tmp/output.png')

Ответ 5

Это не сломано. Он делает именно то, что вы ему сказали; эти пиксели черные с полной прозрачностью. Вам нужно будет перебирать все пиксели и конвертировать их с полной прозрачностью в белый.

Ответ 6

import numpy as np
import PIL

def convert_image(image_file):
    image = Image.open(image_file) # this could be a 4D array PNG (RGBA)
    original_width, original_height = image.size

    np_image = np.array(image)
    new_image = np.zeros((np_image.shape[0], np_image.shape[1], 3)) 
    # create 3D array

    for each_channel in range(3):
        new_image[:,:,each_channel] = np_image[:,:,each_channel]  
        # only copy first 3 channels.

    # flushing
    np_image = []
    return new_image

Ответ 7

импортировать изображение

def fig2img (fig): "" "@brief Преобразовать рисунок Matplotlib в изображение PIL в формате RGBA и вернуть его @param fig рисунок matplotlib @return изображение библиотеки изображений Python (PIL)" "" # поместить растровое изображение рисунка в пустой массив buf = fig2data (fig) w, h, d = buf.shape return Image.frombytes("RGBA", (w, h), buf.tostring())

def fig2data (fig): "" "@brief Преобразовать фигуру Matplotlib в 4-мерный массив с каналами RGBA и вернуть его. @param fig Фигура matplotlib @вернуть ноль-трехмерный массив значений RGBA" "" # нарисовать рис. canvas.draw()

# Get the RGBA buffer from the figure
w,h = fig.canvas.get_width_height()
buf = np.fromstring ( fig.canvas.tostring_argb(), dtype=np.uint8 )
buf.shape = ( w, h, 4 )

# canvas.tostring_argb give pixmap in ARGB mode. Roll the ALPHA channel to have it in RGBA mode
buf = np.roll ( buf, 3, axis = 2 )
return buf

def rgba2rgb (img, c = (0, 0, 0), path = 'foo.jpg', is_already_saved = False, if_load = True): если не is_already_saved: background = Image.new("RGB", img.size, c) background.paste(img, mask = img.split() [3]) # 3 - альфа-канал

    background.save(path, 'JPEG', quality=100)   
    is_already_saved = True
if if_load:
    if is_already_saved:
        im = Image.open(path)
        return np.array(im)
    else:
        raise ValueError('No image to load.')