En utilisant numpy.rot90(), vous pouvez faire pivoter le tableau NumPy ndarray de 90/180/270 degrés.
Cet article décrit le contenu suivant.
- Utilisation de base de numpy.rot90()
- Comportement par défaut
- Spécifiez le nombre de rotations :
k
- Pour un tableau unidimensionnel
- Pour un tableau multidimensionnel
- Comportement par défaut
- Spécifiez le plan à faire pivoter :
axes
- Faire pivoter l’image
Si vous souhaitez transposer au lieu de faire pivoter, consultez l’article suivant.
Utilisation de base de numpy.rot90()
Comportement par défaut
Spécifiez ndarray à faire pivoter comme premier argument de numpy.rot90(). Le tableau tourne de 90 degrés dans le sens inverse des aiguilles d’une montre.
import numpy as np
a_2d = np.arange(6).reshape(2, 3)
print(a_2d)
# [[0 1 2]
# [3 4 5]]
a_2d_rot = np.rot90(a_2d)
print(a_2d_rot)
# [[2 5]
# [1 4]
# [0 3]]
numpy.rot90() renvoie une vue. Étant donné qu’une vue partage de la mémoire avec le tableau d’origine, la modification d’une valeur modifie l’autre.
print(np.shares_memory(a_2d, a_2d_rot))
# True
a_2d_rot[0, 0] = 100
print(a_2d_rot)
# [[100 5]
# [ 1 4]
# [ 0 3]]
print(a_2d)
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print(a_2d)
# [[0 1 2]
# [3 4 5]]
print(a_2d_rot)
# [[2 5]
# [1 4]
# [0 3]]
Si vous souhaitez traiter des données séparées, utilisez copy().
a_2d_rot_copy = np.rot90(a_2d).copy()
print(a_2d_rot_copy)
# [[2 5]
# [1 4]
# [0 3]]
print(np.shares_memory(a_2d, a_2d_rot_copy))
# False
Spécifiez le nombre de rotations : k
Spécifier une valeur entière pour le deuxième argument k fait pivoter le tableau de 90 degrés dans le sens inverse des aiguilles d’une montre k fois.
print(np.rot90(a_2d, 2))
# [[5 4 3]
# [2 1 0]]
print(np.rot90(a_2d, 3))
# [[3 0]
# [4 1]
# [5 2]]
print(np.rot90(a_2d, 4))
# [[0 1 2]
# [3 4 5]]
print(np.rot90(a_2d, 100))
# [[0 1 2]
# [3 4 5]]
Dans le cas d’une valeur négative, le sens de rotation est le sens horaire.
print(np.rot90(a_2d, -1))
# [[3 0]
# [4 1]
# [5 2]]
print(np.rot90(a_2d, -2))
# [[5 4 3]
# [2 1 0]]
Pour un tableau unidimensionnel
Les tableaux unidimensionnels ne peuvent pas être pivotés.
a_1d = np.arange(3)
print(a_1d)
# [0 1 2]
# print(np.rot90(a_1d))
# ValueError: Axes must be different.
Il peut être pivoté s’il est défini comme un tableau à deux dimensions d’une seule ligne.
a_2d_row = np.arange(3).reshape(1, 3)
print(a_2d_row)
# [[0 1 2]]
print(np.rot90(a_2d_row))
# [[2]
# [1]
# [0]]
Pour un tableau multidimensionnel
Les tableaux multidimensionnels de trois dimensions ou plus peuvent également être pivotés.
Comportement par défaut
Par défaut, il est tourné comme suit.
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(a_3d.shape)
# (2, 3, 4)
print(np.rot90(a_3d))
# [[[ 8 9 10 11]
# [20 21 22 23]]
#
# [[ 4 5 6 7]
# [16 17 18 19]]
#
# [[ 0 1 2 3]
# [12 13 14 15]]]
print(np.rot90(a_3d).shape)
# (3, 2, 4)
Il est tourné dans un plan composé des deux premiers axes (dimensions).
print(a_3d[:, :, 0])
# [[ 0 4 8]
# [12 16 20]]
print(np.rot90(a_3d)[:, :, 0])
# [[ 8 20]
# [ 4 16]
# [ 0 12]]
Spécifiez le plan à faire pivoter : axes
Pour les tableaux multidimensionnels, le troisième argument axes peut spécifier un plan à faire pivoter. Dans axes, spécifiez deux axes qui composent un plan avec un tuple ou une liste avec deux éléments.
La valeur par défaut est axes=(0, 1), qui tourne dans le plan des deux premiers axes. On peut confirmer que le résultat est le même que dans l’exemple ci-dessus.
print(np.rot90(a_3d, axes=(0, 1)))
# [[[ 8 9 10 11]
# [20 21 22 23]]
#
# [[ 4 5 6 7]
# [16 17 18 19]]
#
# [[ 0 1 2 3]
# [12 13 14 15]]]
Un exemple de rotation dans un autre plan est le suivant. Si l’ordre des axes spécifié dans axes est inversé, le sens de rotation est inversé.
print(np.rot90(a_3d, axes=(1, 2)))
# [[[ 3 7 11]
# [ 2 6 10]
# [ 1 5 9]
# [ 0 4 8]]
#
# [[15 19 23]
# [14 18 22]
# [13 17 21]
# [12 16 20]]]
print(np.rot90(a_3d, axes=(1, 2)).shape)
# (2, 4, 3)
print(np.rot90(a_3d, axes=(2, 1)))
# [[[ 8 4 0]
# [ 9 5 1]
# [10 6 2]
# [11 7 3]]
#
# [[20 16 12]
# [21 17 13]
# [22 18 14]
# [23 19 15]]]
print(np.rot90(a_3d, axes=(2, 1)).shape)
# (2, 4, 3)
Il peut également être spécifié avec le deuxième argument k.
print(np.rot90(a_3d, 2, axes=(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(np.rot90(a_3d, -1, axes=(1, 2)))
# [[[ 8 4 0]
# [ 9 5 1]
# [10 6 2]
# [11 7 3]]
#
# [[20 16 12]
# [21 17 13]
# [22 18 14]
# [23 19 15]]]
Faire pivoter l’image
Les fichiers image peuvent être lus en tant que tableau NumPy ndarray à l’aide de bibliothèques telles que Pillow (PIL) et OpenCV.
Les images peuvent être tournées à l’aide de numpy.rot90(). L’exemple suivant utilise une image couleur (tableau tridimensionnel), mais une image grise (tableau bidimensionnel) n’a pas non plus besoin de spécifier d’arguments.
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.rot90(img)).save('data/dst/lena_np_rot90.jpg')
Image.fromarray(np.rot90(img, 2)).save('data/dst/lena_np_rot90_180.jpg')
Image.fromarray(np.rot90(img, 3)).save('data/dst/lena_np_rot90_270.jpg')
Vous pouvez également faire pivoter des images avec les fonctions OpenCV.