Usando numpy.flip() puoi capovolgere l’array NumPy ndarray verticalmente (su-giù) o orizzontalmente (sinistra-destra). Ci sono anche numpy.flipud() per il capovolgimento verticale e numpy.fliplr() per il capovolgimento orizzontale.
In questo articolo vengono descritti i seguenti contenuti.
- Capovolgi ndarray verticalmente:
np.flipud() - Capovolgi ndarray orizzontalmente:
np.fliplr() - Capovolgi ndarray lungo qualsiasi asse:
np.flip()- Comportamento predefinito
- Specificare l’asse da capovolgere:
axis
- Capovolgere l’immagine verticalmente e orizzontalmente
È anche possibile invertire con slice ::-1 senza utilizzare queste funzioni.
Capovolgi ndarray verticalmente:np.flipud()
Usa numpy.flipud() per capovolgere ndarray verticalmente. ud significa “Su” e “Giù”.
numpy.flipud() porta una vista. Poiché una vista condivide la memoria con l’array originale, la modifica di un valore cambia l’altro.
import numpy as np
a_2d = np.arange(6).reshape(2, 3)
print(a_2d)
# [[0 1 2]
# [3 4 5]]
a_2d_flipud = np.flipud(a_2d)
print(a_2d_flipud)
# [[3 4 5]
# [0 1 2]]
print(np.shares_memory(a_2d, a_2d_flipud))
# True
Se vuoi elaborare dati separati, usa copy().
a_2d_flipud_copy = np.flipud(a_2d).copy()
print(a_2d_flipud_copy)
# [[3 4 5]
# [0 1 2]]
print(np.shares_memory(a_2d, a_2d_flipud_copy))
# False
numpy.flipud() equivale a una fetta [::-1]. L’array ruota lungo il primo asse.
print(a_2d[::-1])
# [[3 4 5]
# [0 1 2]]
Lo stesso vale per gli array unidimensionali e multidimensionali di tre o più dimensioni, in cui l’array viene capovolto lungo il primo asse. Nel caso dell’array unidimensionale, è diverso dall’impressione di “verticalmente”, quindi fai attenzione.
a_1d = np.arange(3)
print(a_1d)
# [0 1 2]
print(np.flipud(a_1d))
# [2 1 0]
print(a_1d[::-1])
# [2 1 0]
a_3d = np.arange(24).reshape(2, 3, 4)
print(a_3d)
# [[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]]
print(np.flipud(a_3d))
# [[[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]
#
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]]
print(a_3d[::-1])
# [[[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]
#
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]]
Se vuoi capovolgere l’array multidimensionale qualsiasi asse, usa numpy.flip() devi più avanti.
Capovolgi ndarray orizzontalmente:np.fliplr()
Usa numpy.fliplr() per capovolgere ndarray orizzontalmente. lr significa “sinistra” e “destra”.
numpy.flipud() porta una vista. Se vuoi elaborare dati separati, puoi usare copy() come nell’esempio di numpy.flipud().
import numpy as np
a_2d = np.arange(6).reshape(2, 3)
print(a_2d)
# [[0 1 2]
# [3 4 5]]
a_2d_fliplr = np.fliplr(a_2d)
print(a_2d_fliplr)
# [[2 1 0]
# [5 4 3]]
print(np.shares_memory(a_2d, a_2d_fliplr))
# True
numpy.fliplr() equivale a una fetta [:, ::-1]. L’array ruota lungo il secondo asse.
print(a_2d[:, ::-1])
# [[2 1 0]
# [5 4 3]]
Lo stesso vale per gli array unidimensionali e multidimensionali di tre o più dimensioni, in cui l’array viene capovolto lungo il secondo asse. Si noti che nel caso di una matrice unidimensionale, viene generato un errore perché il secondo asse non esiste.
a_1d = np.arange(3)
print(a_1d)
# [0 1 2]
# print(np.fliplr(a_1d))
# ValueError: Input must be >= 2-d.
a_3d = np.arange(24).reshape(2, 3, 4)
print(a_3d)
# [[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]]
print(np.fliplr(a_3d))
# [[[ 8 9 10 11]
# [ 4 5 6 7]
# [ 0 1 2 3]]
#
# [[20 21 22 23]
# [16 17 18 19]
# [12 13 14 15]]]
print(a_3d[:, ::-1])
# [[[ 8 9 10 11]
# [ 4 5 6 7]
# [ 0 1 2 3]]
#
# [[20 21 22 23]
# [16 17 18 19]
# [12 13 14 15]]]
Capovolgi ndarray lungo qualsiasi asse:np.flip()
Usa numpy.flip() per capovolgere qualsiasi cosa. È anche possibile capovolgere lungo più assi.
Comportamento predefinito
Per definizione predefinita, l’array viene capovolto lungo tutti gli assi. Nel caso di un array bidimensionale, si capovolge verticalmente e orizzontalmente.
numpy.flip() fornisce una vista. Se vuoi elaborare dati separati, puoi usare copy() come nell’esempio di numpy.flipud().
import numpy as np
a_2d = np.arange(6).reshape(2, 3)
print(a_2d)
# [[0 1 2]
# [3 4 5]]
a_2d_flip = np.flip(a_2d)
print(a_2d_flip)
# [[5 4 3]
# [2 1 0]]
print(np.shares_memory(a_2d, a_2d_flip))
# True
Ciò equivale a capovolgere tutti gli assi usando le fette.
print(a_2d[::-1, ::-1])
# [[5 4 3]
# [2 1 0]]
Lo stesso vale per gli array unidimensionali e multidimensionali di tre o più dimensioni. Per definizione predefinita, l’array viene capovolto lungo tutti gli assi.
a_1d = np.arange(3)
print(a_1d)
# [0 1 2]
print(np.flip(a_1d))
# [2 1 0]
print(a_1d[::-1])
# [2 1 0]
a_3d = np.arange(24).reshape(2, 3, 4)
print(a_3d)
# [[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]]
print(np.flip(a_3d))
# [[[23 22 21 20]
# [19 18 17 16]
# [15 14 13 12]]
#
# [[11 10 9 8]
# [ 7 6 5 4]
# [ 3 2 1 0]]]
print(a_3d[::-1, ::-1, ::-1])
# [[[23 22 21 20]
# [19 18 17 16]
# [15 14 13 12]]
#
# [[11 10 9 8]
# [ 7 6 5 4]
# [ 3 2 1 0]]]
Specificare l’asse da capovolgere:axis
L’asse da invertire può essere specificato dal secondo argomento. asse=0 equivale a flipud() e asse=1 a fliplr().
print(np.flip(a_3d, 0))
# [[[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]
#
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]]
print(a_3d[::-1])
# [[[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]
#
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]]
print(np.flipud(a_3d))
# [[[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]
#
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]]
print(np.flip(a_3d, 1))
# [[[ 8 9 10 11]
# [ 4 5 6 7]
# [ 0 1 2 3]]
#
# [[20 21 22 23]
# [16 17 18 19]
# [12 13 14 15]]]
print(a_3d[:, ::-1])
# [[[ 8 9 10 11]
# [ 4 5 6 7]
# [ 0 1 2 3]]
#
# [[20 21 22 23]
# [16 17 18 19]
# [12 13 14 15]]]
print(np.fliplr(a_3d))
# [[[ 8 9 10 11]
# [ 4 5 6 7]
# [ 0 1 2 3]]
#
# [[20 21 22 23]
# [16 17 18 19]
# [12 13 14 15]]]
print(np.flip(a_3d, 2))
# [[[ 3 2 1 0]
# [ 7 6 5 4]
# [11 10 9 8]]
#
# [[15 14 13 12]
# [19 18 17 16]
# [23 22 21 20]]]
print(a_3d[:, :, ::-1])
# [[[ 3 2 1 0]
# [ 7 6 5 4]
# [11 10 9 8]]
#
# [[15 14 13 12]
# [19 18 17 16]
# [23 22 21 20]]]
È possibile specificare più assi per l’asse utilizzando la tupla o l’elenco.
print(np.flip(a_3d, (1, 2)))
# [[[11 10 9 8]
# [ 7 6 5 4]
# [ 3 2 1 0]]
#
# [[23 22 21 20]
# [19 18 17 16]
# [15 14 13 12]]]
print(a_3d[:, ::-1, ::-1])
# [[[11 10 9 8]
# [ 7 6 5 4]
# [ 3 2 1 0]]
#
# [[23 22 21 20]
# [19 18 17 16]
# [15 14 13 12]]]
L’operazione di flip() è riassunta di seguito.
flip(m, 0) equivale a flipud(m).
flip(m, 1) equivale a fliplr(m).
flip(m, n) corrisponde am[…,::-1,…] con ::-1 alla posizione n.
flip(m) corrisponde am[::-1,::-1,…,::-1] con ::-1 in tutte le posizioni.
flip(m, (0, 1)) corrisponde am[::-1,::-1,…] con ::-1 in posizione 0 e posizione 1.
numpy.flip — NumPy v1.16 Manuale
Capovolgere l’immagine verticalmente e orizzontalmente
I file di immagine possono essere letti come array NumPy ndarray utilizzando librerie come Pillow (PIL) e OpenCV.
Puoi capovolgere l’immagine verticalmente e orizzontalmente usando numpy.flip(), numpy.flipud(), numpy.fliplr(). L’esempio seguente utilizza un’immagine a colori (array tridimensionale), ma la specifica degli argomenti è la stessa per le immagini in grigio (array bidimensionale).
L’immagine seguente viene utilizzata come esempio.
Il codice di esempio ei risultati sono seguiti.
import numpy as np
from PIL import Image
img = np.array(Image.open('data/src/lena.jpg'))
print(type(img))
#
print(img.shape)
# (225, 400, 3)
Image.fromarray(np.flipud(img)).save('data/dst/lena_np_flipud.jpg')
Image.fromarray(np.fliplr(img)).save('data/dst/lena_np_fliplr.jpg')
Image.fromarray(np.flip(img, (0, 1))).save('data/dst/lena_np_flip_ud_lr.jpg')
Puoi anche ruotare le immagini con le funzioni OpenCV.