Jak przekonwertować obraz PIL na tablicę numpy?

W porządku, bawię się z konwertowaniem obiektu obrazu PIL tam iz powrotem na tablicę numpy, dzięki czemu mogę wykonywać szybsze transformacje piksel po pikselu, niż PixelAccesspozwala obiekt PIL . Nauczyłem się, jak umieszczać informacje o pikselach w przydatnej macierzy liczb 3D w następujący sposób:

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

Ale nie potrafię wymyślić, jak załadować go z powrotem do obiektu PIL po wykonaniu wszystkich moich niesamowitych transformacji. Zdaję sobie sprawę z tej putdata()metody, ale nie wydaje mi się, żeby mogła się zachowywać.

Nie mówisz, jak dokładnie putdata()się nie zachowuje. Zakładam, że robisz

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

Wynika to z faktu, putdataże oczekuje sekwencji krotek, a Ty dajesz jej tablicę numpy. To

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

będzie działać, ale jest bardzo wolny.

Od PIL 1.1.6 „właściwym” sposobem konwersji między obrazami a tablicami liczbowymi jest po prostu

>>> pix = numpy.array(pic)

chociaż wynikowa tablica ma inny format niż twój (w tym przypadku tablica 3-d lub wiersze / kolumny / rgb).

Następnie, po dokonaniu zmian w tablicy, powinieneś być w stanie zrobić albo pic.putdata(pix)utworzyć nowy obraz za pomocą Image.fromarray(pix).

Otwórz Ijako tablicę:

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

Zrób kilka rzeczy I, a następnie przekonwertuj go z powrotem na obraz:

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

Filtruj niezliczone obrazy za pomocą FFT, Python

Jeśli z jakiegoś powodu chcesz to zrobić jawnie, istnieją funkcje pil2array () i array2pil () za pomocą getdata () na tej stronie w correlation.zip.

Korzystam z Pillow 4.1.1 (następca PIL) w Pythonie 3.5. Konwersja między Pillow a Numpy jest prosta.

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)

Jedną rzeczą, na którą należy zwrócić uwagę, jest to, że styl Poduszki imjest major-kolumna, podczas gdy styl numpy im2arr-dur-dur. Jednak funkcja Image.fromarrayjuż to uwzględnia. Oznacza to, że arr2im.size == im.sizei arr2im.mode == im.modew powyższym przykładzie.

Podczas przetwarzania transformowanych tablic numpy, np. Przeprowadzania transformacji im2arr = np.rollaxis(im2arr, 2, 0)lub im2arr = np.transpose(im2arr, (2, 0, 1))do formatu CxHxW, powinniśmy zadbać o format danych HxWxC.

Musisz przekonwertować obraz na tablicę numpy w następujący sposób:

import numpy
import PIL

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

Przykład, którego użyłem dzisiaj:

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)

Jeśli twój obraz jest przechowywany w formacie Blob (tj. W bazie danych), możesz użyć tej samej techniki objaśnionej przez Billal Begueradj, aby przekonwertować swój obraz z obiektów Blob do tablicy bajtów.

W moim przypadku potrzebowałem obrazów, które były przechowywane w kolumnie obiektów blob w tabeli db:

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

Następnie utworzyłem funkcję pomocnika, aby zmienić mój zestaw danych na 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

Po tym byłem w stanie używać byteArrays w mojej sieci neuronowej.

plt.imshow(imagesList[0])

Konwertuj Numpy to PILobraz iPIL 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()

Możesz przekształcić obraz w numpy, parsując obraz w funkcję numpy () po wycięciu funkcji (nienormalizacja)