Come elaborare le immagini con NumPy e Python

Una guida per principianti all'elaborazione delle immagini utilizzando NumPy.

Poiché le immagini possono anche essere considerate come costituite da array, possiamo utilizzare NumPy per eseguire diverse attività di elaborazione delle immagini anche da zero. In questo articolo, impareremo le attività di elaborazione delle immagini che possono essere eseguite solo utilizzando NumPy.

Come elaborare le immagini con NumPy e Python

Per lo più troviamo gli usi di NumPy nei problemi in cui ci viene richiesto di eseguire operazioni matematiche e logiche su diverse dimensioni di array. Poiché le immagini possono anche essere considerate come costituite da array, possiamo utilizzare NumPy per eseguire diverse attività di elaborazione delle immagini anche da zero. In questo articolo, impareremo le attività di elaborazione delle immagini che possono essere eseguite solo utilizzando NumPy. Questo sarà utile per i principianti per comprendere l'elaborazione delle immagini dalle sue basi.

Qui sotto troverai un sommario che ricapitola tutto ciò di cui parleremo in questo articolo

Sommario di Come elaborare le immagini con NumPy e Python

1. Caricamento dell'immagine

2. Ritaglio dell'immagine

3. Separazione dei colori

4. Trasformazione

5. Conversione in scala di grigi

6. Segmentazione dell'immagine

Questi 6 step solitamente sono i più comuni e quotidianamente usati da chi lavora in ambito computer vision.

Come sempre oltre alla parte teorica ci teniamo che tu segua passo passo l'articolo, per questo cliccando su questo Link (poi clicca in basso a destra "crea nuovo blocco note") e copiando e incollando il codice passo passo potrai seguirci senza difficoltà.

Che altro dire, iniziamo con l'importazione delle librerie e il caricamento di un'immagine casuale.

Caricamento dell'immagine

import numpy as np
import urllib.request as url
stream = url.urlopen("http://matplotlib.sourceforge.net/_static/logo2.png")
import matplotlib.pylab as plt
%matplotlib inline

image = plt.imread(stream)
print(image)

Output:

 [[0. 0. 0. 0.]
 [0. 0. 0. 0.]   
 [0. 0. 0. 0.]   
 ...   
 [0. 0. 0. 0.]   
 [0. 0. 0. 0.]   
 [0. 0. 0. 0.]]   
 ...   
 [[0. 0. 0. 0.]   
 [0. 0. 0. 0.]   
 [0. 0. 0. 0.]

Qui possiamo vedere la forma grezza dell'immagine. Poiché matematicamente le immagini sono costituite da valori di pixel nell'output sopra, possiamo vedere che abbiamo alcuni numeri che definiscono i colori nell'immagine e l'immagine è fondamentalmente un array o un array NumPy. Possiamo anche mostrare l'immagine usando la libreria matplotlib .

imgplot = plt.imshow(image)

Output:

Ritaglio dell'immagine

Dopo aver caricato l'immagine siamo pronti per eseguire azioni sull'immagine. Come molto semplice, possiamo eseguire operazioni di ritaglio di base sulla nostra immagine. Per NumPy, l'operazione di ritaglio può essere eseguita tagliando l'array.

crop_img = image[20:199,:200,:]    
imgplot = plt.imshow(crop_img)

Output :

Qui possiamo vedere che abbiamo ritagliato la nostra immagine. Ora possiamo passare alla nostra prossima fase di elaborazione delle immagini.

Separazione dei colori

Poiché sappiamo che ogni immagine è composta da valori di pixel e questi valori di pixel rappresentano tre numeri interi noti come valore RGB del suo colore . Per separare l'immagine in questi colori è necessario estrarre la fetta corretta dell'array di immagini.

fig, axs = plt.subplots(nrows=1, ncols=3, figsize=(20,8))
 
for c, ax in zip(range(3), axs):
    rgb_img = np.zeros(image.shape, dtype="uint8")
    rgb_img[:,:,c] = image[:,:,c]
    ax.imshow(rgb_img)
    ax.set_axis_off()

Qui nell'output, potremmo vedere che abbiamo separato l'RGB dell'immagine per questo abbiamo mappato i valori nell'intervallo da 0 a 1 e cast per digitare uint8. Passiamo alla fase successiva dell'elaborazione delle immagini.

Trasformazioni

In questo passaggio, eseguiremo la trasformazione del colore. A questo scopo, possiamo trattare il pixel dell'immagine come un punto nello spazio. Trattare in questo modo i pixel dell'immagine ci consente di eseguire una trasformazione nel punto di colore. La rotazione del punto di colore può essere un esempio dell'affermazione precedente. Qui stiamo applicando la funzione di notazione di Einstein di Numpy, che è un metodo per applicare una matrice di rotazione, in pixel, all'immagine.

def do_normalise(image):
    return -np.log(1/((1 + image)/257) - 1)
def undo_normalise(image):
    return (1 + 1/(np.exp(-image) + 1) * 257).astype("uint8")
def rotation_matrix(theta):
    return np.c_[
        [1,0,0],
        [0,np.cos(theta),-np.sin(theta)],
        [0,np.sin(theta),np.cos(theta)]
    ]

img_norm = do_normalise(image)
img_rot = np.einsum("ijk,lk->ijl", img_norm, rotation_matrix(np.pi))
img = undo_normalise(img_rot)    
 
imgplot = plt.imshow(img_norm)

#copiando e incollando questa trasformazione su un altra immagine a caso potresti avere degli errori, ma non preoccuparti presto pubblicheremo guide complete anche sulla traformazione

Qui nell'output, potrete vedere che il sigmoid applicato allo spazio colore ha funzionato e stiamo applicando continuamente la rotazione del colore dei pixel. Ora, nel passaggio successivo, vedremo come convertire un'immagine in un'immagine in scala di grigi.

Conversione in scala di grigi

Possiamo anche usare NumPy per trasformare l'immagine in un'immagine in scala di grigi. Prendendo la media ponderata del valore RGB dell'immagine possiamo eseguire questo.

rgb_weights = [0.2989, 0.5870, 0.1140]
grayscale_image = np.dot(image[...,:3], rgb_weights)
imgplot = plt.imshow(grayscale_image)

Output:

Ecco l'immagine dell'output del nostro processo di conversione in scala di grigi. Passiamo alla fase successiva dell'elaborazione delle immagini.

Segmentazione dell'immagine

Questo è uno dei passaggi di elaborazione delle immagini più utilizzati in cui segmentiamo diverse regioni di immagini. Esistono vari modi per farlo, ad esempio in primo piano e in background. Ad esempio, in questo articolo vedremo come possiamo eseguire la segmentazione convertendo l'immagine in scala di grigi e trovando una soglia. I pixel nell'immagine che si trovano al di sopra della soglia si trovano in una regione e gli altri in un'altra regione.

def simple_threshold(image, threshold=128):
    return ((image > threshold) * 255).astype("uint8")
  
def rgb2gray(rgb):
    r, g, b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
    gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
    return gray
 
thresholds = [100,120,128,138,150]
 
fig, axs = plt.subplots(nrows=1, ncols=len(thresholds), figsize=(20,5));
gray_im = rgb2gray(image)
                        
for t, ax in zip(thresholds, axs):
    ax.imshow(simple_threshold(gray_im, t), cmap='Greys');
    ax.set_title("Threshold: {}".format(t), fontsize=20);
    ax.set_axis_off();

Nell'output che vi uscirà, potrete vedere che abbiamo segmentato l'immagine in due regioni usando diversi valori di soglia.

Conclusione

In questo articolo, abbiamo discusso le diverse attività di elaborazione delle immagini che abbiamo eseguito utilizzando la libreria NumPy. Inoltre, abbiamo utilizzato la libreria matplotlib per la visualizzazione delle immagini dopo l'elaborazione. Osservando i punti precedenti, possiamo dire che possiamo eseguire anche altri compiti semplicemente usando qualche altra logica.