En utilisant numpy.flip(), vous pouvez retourner le tableau NumPy ndarray verticalement (haut-bas) ou horizontalement (gauche-droite). Il existe également numpy.flipud() spécialisé pour le retournement vertical et numpy.fliplr() spécialisé pour le retournement horizontal.
Cet article décrit le contenu suivant.
- Retourner verticalement :
np.flipud() - Retourner ndarray horizontalement :
np.fliplr() - Retournez ndarray le long de n’importe quel hache :
np.flip()- Comportement par défaut
- Spécifiez l’axe à retourner :
axis
- Retourner l’image verticalement et horizontalement
Il est également possible d’inverser avec slice ::-1 sans utiliser ces fonctions.
Retourner verticalement :np.flipud()
Utilisez numpy.flipud() pour retourner verticalement. ud signifie « Haut » et « Bas ».
numpy.flipud() renvoie une vue. Étant donné qu’une vue partagée de la mémoire avec le tableau d’origine, la modification d’une valeur modifie l’autre.
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
Si vous utilisez éventuellement des données séparées, utilisez 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() est équivalent à slice [::-1]. Le tableau bascule le long du premier hache.
print(a_2d[::-1])
# [[3 4 5]
# [0 1 2]]
Il en va de même pour les tableaux unidimensionnels et multidimensionnels de trois dimensions ou plus, où le tableau est inversé le long du premier axe. Dans le cas d’un tableau à une dimension, c’est différent de l’impression de « verticalement », alors sois prudent.
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]]]
Si vous souhaitez retourner le tableau multidimensionnel le long de n’importe quel axe, utilisez numpy.flip() décrit plus tard.
Retourner ndarray horizontalement :np.fliplr()
Utilisez numpy.fliplr() pour retourner ndarray horizontalement. lr signifie « Gauche » et « Droite ».
numpy.flipud() renvoie une vue. Si vous souhaitez traiter des données séparées, vous pouvez utiliser copy() comme dans l’exemple de 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() est équivalent à slice [:, ::-1]. Le tableau bascule le long du deuxième axe.
print(a_2d[:, ::-1])
# [[2 1 0]
# [5 4 3]]
Il en va de même pour les tableaux unidimensionnels et multidimensionnels de trois dimensions ou plus, où le tableau est inversé le long du deuxième axe. Notez que dans le cas d’un tableau à une dimension, une erreur est levée car le deuxième axe n’existe pas.
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]]]
Retournez ndarray le long de n’importe quel axe :np.flip()
Utilisez numpy.flip() pour retourner ndarray le long de n’importe quel axe. Il est également possible de retourner le long de plusieurs axes.
Comportement par défaut
Par défaut, le tableau est inversé le long de tous les axes. Dans le cas d’un tableau à deux dimensions, il bascule verticalement et horizontalement.
numpy.flip() renvoie une vue. Si vous souhaitez traiter des données séparées, vous pouvez utiliser copy() comme dans l’exemple de 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
Cela équivaut à retourner tous les axes à l’aide de tranches.
print(a_2d[::-1, ::-1])
# [[5 4 3]
# [2 1 0]]
Il en va de même pour les tableaux unidimensionnels et multidimensionnels de trois dimensions ou plus. Par défaut, le tableau est inversé le long de tous les axes.
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]]]
Spécifiez l’axe à retourner :axis
L’axe à inverser peut être spécifié par le second argument axis. axis=0 est équivalent à flipud() et axis=1 à 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]]]
Vous pouvez spécifier plusieurs axes pour l’axe en utilisant tuple ou list.
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]]]
Le fonctionnement de flip() est résumé ci-dessous.
flip(m, 0) est équivalent à flipud(m).
flip(m, 1) est équivalent à fliplr(m).
flip(m, n) correspond à m[…,::-1,…] avec ::-1 à la position n.
flip(m) correspond à m[::-1,::-1,…,::-1] avec ::-1 à toutes les positions.
flip(m, (0, 1)) correspond à m[::-1,::-1,…] avec ::-1 à la position 0 et à la position 1.
numpy.flip — NumPy v1.16 Manual
Retourner l’image verticalement et horizontalement
Les fichiers image peuvent être lus en tant que tableau NumPy ndarray à l’aide de bibliothèques telles que Pillow (PIL) et OpenCV.
Vous pouvez retourner l’image verticalement et horizontalement en utilisant numpy.flip(), numpy.flipud(), numpy.fliplr(). L’exemple suivant utilise une image couleur (tableau tridimensionnel), mais la spécification des arguments est la même pour les images grises (tableau bidimensionnel).
L’image suivante est utilisée comme exemple.
Exemple de code et résultats ci-dessous.
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')
Vous pouvez également faire pivoter des images avec les fonctions OpenCV.