python - recorrer - manipulacion de imagenes con numpy

¿Cómo convierto cualquier imagen en una imagen paletizada de 4 colores usando la Biblioteca de imágenes de Python?

Question

Tengo un dispositivo que admite gráficos de 4 colores (muy parecido a CGA en los viejos tiempos).

Quería usar PIL para leer la imagen y convertirla usando mi paleta de 4 colores (de rojo, verde, amarillo, negro), pero no puedo entender si es siquiera posible. Encontré algunas publicaciones de listas de correo que parecen sugerir que otras personas han intentado hacerlo y han fallado.

¡Un simple ejemplo de pitón sería muy apreciado!

Puntos de bonificación si agrega algo que luego convierte la imagen en una cadena de bytes donde cada byte representa 4 píxeles de datos (con cada dos bits representando un color de 0 a 3)

Answer 1

John, encontré ese primer enlace también, pero no me ayudó directamente con el problema. Sin embargo, me hizo mirar más profundamente en la cuantización.

Ayer se me ocurrió esto antes de acostarme:

import sys

import PIL
import Image

PALETTE = [
    0,   0,   0,  # black,  00
    0,   255, 0,  # green,  01
    255, 0,   0,  # red,    10
    255, 255, 0,  # yellow, 11
] + [0, ] * 252 * 3

# a palette image to use for quant
pimage = Image.new("P", (1, 1), 0)
pimage.putpalette(PALETTE)

# open the source image
image = Image.open(sys.argv[1])
image = image.convert("RGB")

# quantize it using our palette image
imagep = image.quantize(palette=pimage)

# save
imagep.save(''/tmp/cga.png'')

TZ.TZIOY, tu solución parece funcionar según los mismos principios. Felicitaciones, debería haber dejado de trabajar en eso y esperé tu respuesta. El mío es un poco más simple, aunque definitivamente no más lógico que el tuyo. PIL es engorroso de usar. El tuyo explica qué está sucediendo para hacerlo.

Answer 2

Primero: su paleta de cuatro colores (negro, verde, rojo, amarillo) no tiene componente azul. Por lo tanto, debe aceptar que su imagen de salida apenas se aproximará a la imagen de entrada, a menos que no haya un componente azul para comenzar.

Prueba este código:

import Image

def estimate_color(c, bit, c_error):
    c_new= c -  c_error
    if c_new > 127:
        c_bit= bit
        c_error= 255 - c_new
    else:
        c_bit= 0
        c_error= -c_new
    return c_bit, c_error

def image2cga(im):
    "Produce a sequence of CGA pixels from image im"
    im_width= im.size[0]
    for index, (r, g, b) in enumerate(im.getdata()):
        if index % im_width == 0: # start of a line
            r_error= g_error= 0
        r_bit, r_error= estimate_color(r, 1, r_error)
        g_bit, g_error= estimate_color(g, 2, g_error)
        yield r_bit|g_bit

def cvt2cga(imgfn):
    "Convert an RGB image to (K, R, G, Y) CGA image"
    inp_im= Image.open(imgfn) # assume it''s RGB
    out_im= Image.new("P", inp_im.size, None)
    out_im.putpalette( (
        0, 0, 0,
        255, 0, 0,
        0, 255, 0,
        255, 255, 0,
    ) )
    out_im.putdata(list(image2cga(inp_im)))
    return out_im

if __name__ == "__main__":
    import sys, os

    for imgfn in sys.argv[1:]:
        im= cvt2cga(imgfn)
        dirname, filename= os.path.split(imgfn)
        name, ext= os.path.splitext(filename)
        newpathname= os.path.join(dirname, "cga-%s.png" % name)
        im.save(newpathname)

Esto crea una imagen de paleta PNG con solo las primeras cuatro entradas de paleta configuradas a sus colores. Esta imagen de muestra:

http://tzotzioy.googlepages.com/new_pic_baby2.jpg

se convierte

http://tzotzioy.googlepages.com/cga-new_pic_baby2.png

Es trivial tomar la salida de image2cga (produce una secuencia de 0-3 valores) y empacar cada cuatro valores en un byte.

Si necesita ayuda sobre lo que hace el código, pregunte y lo explicaré.

EDIT1: No reinventar la rueda

Por supuesto, resulta que estaba demasiado entusiasta y, como Thomas descubrió, el método Image.quantize puede tomar una imagen de paleta como argumento y hacer la cuantificación con mejores resultados que mi método ad-hoc anterior:

def cga_quantize(image):
    pal_image= Image.new("P", (1,1))
    pal_image.putpalette( (0,0,0, 0,255,0, 255,0,0, 255,255,0) + (0,0,0)*252)
    return image.convert("RGB").quantize(palette=pal_image)

EDIT1, cont: empaqueta los píxeles en bytes

Para "valor agregado", aquí sigue el código para producir la cadena empaquetada (4 píxeles por byte):

import itertools as it

# setup: create a map with tuples [(0,0,0,0)‥(3,3,3,3)] as keys
# and values [chr(0)‥chr(255)], because PIL does not yet support
# 4 colour palette images

TUPLE2CHAR= {}

# Assume (b7, b6) are pixel0, (b5, b4) are pixel1…
# Call it "big endian"

KEY_BUILDER= [
    (0, 64, 128, 192), # pixel0 value used as index
    (0, 16, 32, 48), # pixel1
    (0, 4, 8, 12), # pixel2
    (0, 1, 2, 3), # pixel3
]
# For "little endian", uncomment the following line
## KEY_BUILDER.reverse()

# python2.6 has itertools.product, but for compatibility purposes
# let''s do it verbosely:
for ix0, px0 in enumerate(KEY_BUILDER[0]):
    for ix1, px1 in enumerate(KEY_BUILDER[1]):
        for ix2, px2 in enumerate(KEY_BUILDER[2]):
            for ix3, px3 in enumerate(KEY_BUILDER[3]):
                TUPLE2CHAR[ix0,ix1,ix2,ix3]= chr(px0+px1+px2+px3)

# Another helper function, copied almost verbatim from itertools docs
def grouper(n, iterable, padvalue=None):
    "grouper(3, ''abcdefg'', ''x'') --> (''a'',''b'',''c''), (''d'',''e'',''f''), (''g'',''x'',''x'')"
    return it.izip(*[it.chain(iterable, it.repeat(padvalue, n-1))]*n)

# now the functions
def seq2str(seq):
    """Takes a sequence of [0..3] values and packs them into bytes
    using two bits per value"""
    return ''''.join(
        TUPLE2CHAR[four_pixel]
        for four_pixel in grouper(4, seq, 0))

# and the image related function
# Note that the following function is correct,
# but is not useful for Windows 16 colour bitmaps,
# which start at the *bottom* row…
def image2str(img):
    return seq2str(img.getdata())

Answer 3

Estás tratando de hacer la cuantificación de la imagen. Aquí hay algunos consejos para ese tipo de cosas:

https://web.archive.org/web/20080825200550/http://nadiana.com/pil-tips-converting-png-gif

Answer 4

import sys
import PIL
from PIL import Image

def quantizetopalette(silf, palette, dither=False):
    """Convert an RGB or L mode image to use a given P image''s palette."""

    silf.load()

    # use palette from reference image
    palette.load()
    if palette.mode != "P":
        raise ValueError("bad mode for palette image")
    if silf.mode != "RGB" and silf.mode != "L":
        raise ValueError(
            "only RGB or L mode images can be quantized to a palette"
            )
    im = silf.im.convert("P", 1 if dither else 0, palette.im)
    # the 0 above means turn OFF dithering
    return silf._makeself(im)

if __name__ == "__main__":
    import sys, os

for imgfn in sys.argv[1:]:
    palettedata = [ 0, 0, 0, 0, 255, 0, 255, 0, 0, 255, 255, 0,] 
    palimage = Image.new(''P'', (16, 16))
    palimage.putpalette(palettedata + [0, ] * 252 * 3)
    oldimage = Image.open(sys.argv[1])
    newimage = quantizetopalette(oldimage, palimage, dither=False)
    dirname, filename= os.path.split(imgfn)
    name, ext= os.path.splitext(filename)
    newpathname= os.path.join(dirname, "cga-%s.png" % name)
    newimage.save(newpathname)

Para aquellos que no querían Dithering para obtener colores sólidos. Modded: Convierta la imagen a una paleta específica usando PIL sin difuminado con las dos soluciones en este hilo. Aunque este hilo es antiguo, algunos de nosotros queremos esa información. Kudios