Skip to content

NumPy: Array rotieren (np.rot90)

Python

Mit numpy.rot90() can SIE das NumPy-Array ndarray um 90/180/270 Grad drehen.

Dieser Artikel hat folgenden Inhalt.

  • Grundlegende Verwendung von numpy.rot90()
    • Standardverhalten
    • Geben Sie an, wie oft gedreht werden soll:k
  • Für eindimensionales Array
  • Für mehrdimensionales Array
    • Standardverhalten
    • Geben Sie die zu drehende Ebene an:axes
  • Bild drehen

Wenn Sie transponieren statt drehen möchten, lesen Sie den following Artikel.

Grundlegende Verwendung von numpy.rot90()

Standardverhalten

Geben Sie ndarray als erstes Argument von numpy.rot90() an, das gedreht werden soll. Das Array dreht sich um 90 Grad gegen den Bildschirm.

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() gibt eine Ansicht zurück. Da eine Ansicht den Speicher mit dem ursprünglichen Array teilt, ändert sich das Wert eines Wertes den anderen.

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

Wenn Sie als separate Daten verarbeiten möchten, verwenden Sie 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

Geben Sie an, wie oft gedreht werden soll: k

Durch Angabe eines ganzzahligen Werts für das zweite Argument k WIRD das Array k-mal um 90 Grad gegen den Bildschirm gedreht.

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

Bei einem negativen Wert ist die Drehrichtung im Blickwinkel.

print(np.rot90(a_2d, -1))
# [[3 0]
#  [4 1]
#  [5 2]]

print(np.rot90(a_2d, -2))
# [[5 4 3]
#  [2 1 0]]

Für eindimensionales Array

Eindimensionale Arrays können nicht gedreht werden.

a_1d = np.arange(3)
print(a_1d)
# [0 1 2]

# print(np.rot90(a_1d))
# ValueError: Axes must be different.

Es kann gedreht werden, wenn es als zweidimensionales Array mit nur einer Zeile definiert ist.

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

Für mehrdimensionales Array

Mehrdimensionale Arrays mit drei oder mehr Dimensionen können ebenfalls gedreht werden.

Standardverhalten

Standardmäßig wird es wie folgt gedreht.

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)

Es WIRD in Einer Ebene gedreht, sterben aus den ersten beiden Achsen (Dimensionen) besteht.

print(a_3d[:, :, 0])
# [[ 0  4  8]
#  [12 16 20]]

print(np.rot90(a_3d)[:, :, 0])
# [[ 8 20]
#  [ 4 16]
#  [ 0 12]]

Geben Sie sterben zu drehende Ebene an: Achsen

Bei mehrdimensionalen Arrays kann das dritte Argument axis eine zu drehende Ebene angeben. Geben Sie unter Achsen zwei Achsen an, die eine Ebene mit einem Tupel oder einer Liste mit zwei Elementen bilden.

Der Standardwert ist Achse=(0, 1), wurde in der Ebene der ersten Achsen beider rotiert. Es kann bestätigt werden, dass das Ergebnis das gleiche wie im Beispielbeispiel ist.

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

Ein Beispiel für das Drehen in einer anderen Ebene ist wie folgt. Wird die in der Achse angegebene Reihenfolge der Achsen vertauscht, wird die Drehrichtung umgekehrt.

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)

Es kann auch zusammen mit dem zweiten Argument k angegeben werden.

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

Bild drehen

Bilddateien können als NumPy-Array in Darray mit Bibliotheken wie Pillow (PIL) und OpenCV gelesen werden.

Bilder können mit numpy.rot90() gedreht werden. Das Beispiel used ein Farbbild (dreidimensionales Array), aber ein graues Bild (zweidimensionales Array) muss ebenfalls keine Argumente angeben.

Das Bild dient als Beispiel.

Lena

Beispielcode und Ergebnisse sind unten.

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

numpy rot90-Bild

numpy rot90 180 Bild

numpy rot90 270 Bild

Sie können Bilder auch mit OpenCV-Funktionen drehen.