Comment convertir une image PIL en un tableau numpy?

D'accord, je joue avec la conversion d'un objet image PIL d'avant en arrière en un tableau numpy afin que je puisse faire des transformations pixel par pixel plus rapidement que l' PixelAccessobjet PIL ne le permettrait. J'ai compris comment placer les informations sur les pixels dans un tableau numpy 3D utile au moyen de:

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

Mais je n'arrive pas à comprendre comment le recharger dans l'objet PIL après avoir fait toutes mes transformations impressionnantes. Je connais la putdata()méthode, mais je n'arrive pas vraiment à la faire se comporter.

Vous ne dites pas comment putdata()ne se comporte pas exactement . Je suppose que tu fais

>>> 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

En effet, putdataattend une séquence de tuples et vous lui donnez un tableau numpy. Ce

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

fonctionnera mais il est très lent.

Depuis PIL 1.1.6, la manière "correcte" de convertir entre les images et les tableaux numpy est simplement

>>> pix = numpy.array(pic)

bien que le tableau résultant soit dans un format différent du vôtre (tableau 3D ou lignes / colonnes / RVB dans ce cas).

Ensuite, après avoir apporté vos modifications au tableau, vous devriez pouvoir faire l'une pic.putdata(pix)ou l' autre ou créer une nouvelle image avec Image.fromarray(pix).

Ouvrir en Itant que tableau:

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

Faites quelques trucs pour Iensuite le reconvertir en image:

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

Filtrer les images numpy avec FFT, Python

Si vous voulez le faire explicitement pour une raison quelconque, il existe des fonctions pil2array () et array2pil () utilisant getdata () sur cette page dans correlation.zip.

J'utilise Pillow 4.1.1 (le successeur de PIL) dans Python 3.5. La conversion entre Pillow et numpy est simple.

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)

Une chose qui doit être notée est que le style oreiller imest majeur sur colonne tandis que le style numpy im2arrest majeur sur ligne. Cependant, la fonction Image.fromarrayprend déjà cela en considération. C'est-à-dire, arr2im.size == im.sizeet arr2im.mode == im.modedans l'exemple ci-dessus.

Nous devons prendre soin du format de données HxWxC lors du traitement des tableaux numpy transformés, par exemple faire la transformation im2arr = np.rollaxis(im2arr, 2, 0)ou im2arr = np.transpose(im2arr, (2, 0, 1))au format CxHxW.

Vous devez convertir votre image en un tableau numpy de cette façon:

import numpy
import PIL

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

L'exemple que j'ai utilisé aujourd'hui:

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)

Si votre image est stockée au format Blob (c'est-à-dire dans une base de données), vous pouvez utiliser la même technique expliquée par Billal Begueradj pour convertir votre image de Blobs en un tableau d'octets.

Dans mon cas, j'avais besoin que mes images soient stockées dans une colonne blob dans une table db:

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

J'ai ensuite créé une fonction d'aide pour changer mon jeu de données en 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

Après cela, j'ai pu utiliser les byteArrays dans mon réseau de neurones.

plt.imshow(imagesList[0])

Convertir l' Numpy to PILimage etPIL 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()

Vous pouvez transformer l'image en numpy en analysant l'image en fonction numpy () après avoir éliminé les fonctionnalités (dé-normalisation)