Come convertire un'immagine PIL in una matrice numpy?

Bene, sto giocando con la conversione di un oggetto immagine PIL avanti e indietro in un array intorpidito in modo da poter effettuare trasformazioni pixel per pixel più veloci di quelle PixelAccessconsentite dall'oggetto PIL . Ho capito come posizionare le informazioni sui pixel in una matrice numpy 3D utile mediante:

pic = Image.open("foo.jpg")
pix = numpy.array(pic.getdata()).reshape(pic.size[0], pic.size[1], 3)

Ma non riesco a capire come caricarlo nuovamente nell'oggetto PIL dopo aver fatto tutte le mie fantastiche trasformazioni. Sono a conoscenza del putdata()metodo, ma non riesco proprio a farlo comportare.

Non stai dicendo come esattamente putdata()non si sta comportando. Suppongo che lo stai facendo

>>> pic.putdata(a)
Traceback (most recent call last):
  File "...blablabla.../PIL/Image.py", line 1185, in putdata
    self.im.putdata(data, scale, offset)
SystemError: new style getargs format but argument is not a tuple

Questo perché si putdataaspetta una sequenza di tuple e gli stai dando un array intorpidito. Questo

>>> data = list(tuple(pixel) for pixel in pix)
>>> pic.putdata(data)

funzionerà ma è molto lento.

A partire da PIL 1.1.6, il modo "corretto" di convertire tra immagini e array intorpiditi è semplicemente

>>> pix = numpy.array(pic)

sebbene l'array risultante sia in un formato diverso dal tuo (array 3-d o righe / colonne / rgb in questo caso).

Quindi, dopo aver apportato le modifiche all'array, dovresti essere in grado di eseguire una pic.putdata(pix)o creare una nuova immagine con Image.fromarray(pix).

Apri Icome un array:

>>> I = numpy.asarray(PIL.Image.open('test.jpg'))

Fai qualcosa per I, poi, convertilo nuovamente in un'immagine:

>>> im = PIL.Image.fromarray(numpy.uint8(I))

Filtra immagini intorpidite con FFT, Python

Se vuoi farlo esplicitamente per qualche motivo, ci sono funzioni pil2array () e array2pil () che usano getdata () in questa pagina in correlation.zip.

Sto usando Pillow 4.1.1 (il successore di PIL) in Python 3.5. La conversione tra cuscino e intorpidimento è semplice.

from PIL import Image
import numpy as np
im = Image.open('1.jpg')
im2arr = np.array(im) # im2arr.shape: height x width x channel
arr2im = Image.fromarray(im2arr)

Una cosa che bisogna notare è che lo stile Pillow imè importante per la colonna mentre lo stile intorpidito im2arrè importante per le file. Tuttavia, la funzione lo Image.fromarraytiene già in considerazione. Cioè, arr2im.size == im.sizee arr2im.mode == im.modenell'esempio sopra.

Dovremmo occuparci del formato dei dati HxWxC durante l'elaborazione delle matrici numpy trasformate, ad es. Fare la trasformazione im2arr = np.rollaxis(im2arr, 2, 0)o im2arr = np.transpose(im2arr, (2, 0, 1))nel formato CxHxW.

È necessario convertire l'immagine in una matrice numpy in questo modo:

import numpy
import PIL

img = PIL.Image.open("foo.jpg").convert("L")
imgarr = numpy.array(img) 

L'esempio che ho usato oggi:

import PIL
import numpy
from PIL import Image

def resize_image(numpy_array_image, new_height):
    # convert nympy array image to PIL.Image
    image = Image.fromarray(numpy.uint8(numpy_array_image))
    old_width = float(image.size[0])
    old_height = float(image.size[1])
    ratio = float( new_height / old_height)
    new_width = int(old_width * ratio)
    image = image.resize((new_width, new_height), PIL.Image.ANTIALIAS)
    # convert PIL.Image into nympy array back again
    return array(image)

Se l'immagine è archiviata in un formato BLOB (ovvero in un database) è possibile utilizzare la stessa tecnica spiegata da Billal Begueradj per convertire l'immagine da BLOB in un array di byte.

Nel mio caso, avevo bisogno che le mie immagini fossero archiviate in una colonna BLOB in una tabella db:

def select_all_X_values(conn):
    cur = conn.cursor()
    cur.execute("SELECT ImageData from PiecesTable")    
    rows = cur.fetchall()    
    return rows

Ho quindi creato una funzione di supporto per modificare il mio set di dati in np.array:

X_dataset = select_all_X_values(conn)
imagesList = convertToByteIO(np.array(X_dataset))

def convertToByteIO(imagesArray):
    """
    # Converts an array of images into an array of Bytes
    """
    imagesList = []

    for i in range(len(imagesArray)):  
        img = Image.open(BytesIO(imagesArray[i])).convert("RGB")
        imagesList.insert(i, np.array(img))

    return imagesList

Successivamente, sono stato in grado di utilizzare i byteArrays nella mia rete neurale.

plt.imshow(imagesList[0])

Converti Numpy to PILimmagine ePIL to Numpy

import numpy as np
from PIL import Image

def pilToNumpy(img):
    return np.array(img)

def NumpyToPil(img):
    return Image.fromarray(img)

def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()

È possibile trasformare l'immagine in numpy analizzando l'immagine in funzione numpy () dopo aver eliminato le funzionalità (non normalizzazione)