
Mit numpy.flip() can SIE das NumPy-Array ndarray vertikal (oben-unten) oder horizontal (links-rechts) spiegeln. Es gibt auch numpy.flipud(), das auf vertikales Spiegeln spezialisiert ist, und numpy.fliplr(), das auf horizontales Spiegeln spezialisiert ist.
Dieser Artikel hat folgenden Inhalt.
- Ndarray vertikale Spiegel:
np.flipud()
- Ndarray Horizontalspiegel:
np.fliplr()
- Spiegeln Sie ndarray entlang einer beliebigen Achse:
np.flip()
- Standardverhalten
- Geben Sie die zu spiegelnde Achse an:
axis
- Bild vertikal und horizontal spiegeln
Es ist auch möglich, mit Slice ::-1 zu invertieren, ohne diese Funktionen zu verwenden.
Ndarray vertikale Spiegel:np.flipud()
Verwenden Sie numpy.flipud(), um ndarray vertikal zu spiegeln. ud bedeutet „Auf“ und „Ab“.
numpy.flipud() gibt eine Ansicht zurück. Da eine Ansicht den Speicher mit dem ursprünglichen Array teilt, ändert sich das Wert eines Wertes den anderen.
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
Wenn Sie als separate Daten verarbeiten möchten, verwenden Sie 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() entspricht Slice [::-1]. Das Array dreht sich entlang der ersten Achse.
print(a_2d[::-1])
# [[3 4 5]
# [0 1 2]]
Dasselbe gilt für eindimensionale und mehrdimensionale Arrays mit drei oder mehr Dimensionen, bei denen das Array entlang der ersten Achse gekippt wird. Bei eindimensionalen Arrays unterscheidet es sich vom Eindruck von „vertikal“, also seien Sie vorsichtig.
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]]]
Wenn Sie das mehrdimensionale Array entlang einer beliebigen Achse spiegeln möchten, verwenden Sie numpy.flip(), das später beschrieben WIRD.
Ndarray Horizontalspiegel:np.fliplr()
Verwenden Sie numpy.fliplr(), um ndarray horizontal zu spiegeln. lr bedeutet „links“ und „rechts“.
numpy.flipud() gibt eine Ansicht zurück. Wenn Sie als separate Daten verarbeiten möchten, können Sie copy() wie im Beispiel von numpy.flipud() verwenden.
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() entspricht Slice [:, ::-1]. Das Array dreht sich entlang der zweiten Achse.
print(a_2d[:, ::-1])
# [[2 1 0]
# [5 4 3]]
Dasselbe gilt für eindimensionale und mehrdimensionale Arrays mit drei oder mehr Dimensionen, bei denen das Array entlang der zweiten Achse gekippt wird. Beachten Sie, dass bei einem eindimensionalen Array ein Fehler ausgelöst WIRD, da die zweite Achse nicht vorhanden ist.
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]]]
Spiegeln Sie ndarray entlang einer beliebigen Achse:np.flip()
Verwenden Sie numpy.flip(), um ndarray entlang einer beliebigen Achse zu spiegeln. Es ist auch möglich, entlang mehrerer Achsen zu spiegeln.
Standardverhalten
Standardmäßig wird das Array entlang aller Achsen gespiegelt. Im Fall eines zweidimensionalen Arrays wird es vertikal und horizontal gespiegelt.
numpy.flip() gibt eine Ansicht zurück. Wenn Sie als separate Daten verarbeiten möchten, können Sie copy() wie im Beispiel von numpy.flipud() verwenden.
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
Dies entspricht dem Spiegeln aller Achsen mit Slices.
print(a_2d[::-1, ::-1])
# [[5 4 3]
# [2 1 0]]
Dasselbe gilt für eindimensionale und mehrdimensionale Arrays mit drei oder mehr Dimensionen. Standardmäßig wird das Array entlang aller Achsen gespiegelt.
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]]]
Geben Sie die zu spiegelnde Achse an:axis
Die umzukehrende Achse kann durch das zweite Argument axis angegeben werden. axis=0 entspricht flipud() und axis=1 entspricht 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]]]
Sie können mehrere Achsen für die Achse mit Tupel oder Liste angeben.
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]]]
Die Operation von flip() ist unten zusammengefasst.
flip(m, 0) ist äquivalent zu flipud(m).
flip(m, 1) entspricht fliplr(m).
flip(m, n) entspricht m[…,::-1,…] mit ::-1 an Position n.
flip(m) entspricht m[::-1,::-1,…,::-1] mit ::-1 an allen Stellen.
flip(m, (0, 1)) entspricht m[::-1,::-1,…] mit ::-1 an Position 0 und Position 1.
numpy.flip — NumPy v1.16 Manual
Bild vertikal und horizontal spiegeln
Bilddateien können als NumPy-Array in Darray mit Bibliotheken wie Pillow (PIL) und OpenCV gelesen werden.
Sie können das Bild vertikal und horizontal spiegeln, indem Sie numpy.flip(), numpy.flipud(), numpy.fliplr() verwenden. Das Beispiel verwendet ein Farbbild (dreidimensionales Array), aber die Spezifikation der Argumente ist für graue Bilder (zweidimensionales Array) dieselbe.
Das Bild dient als Beispiel.
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.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')
Sie können Bilder auch mit OpenCV-Funktionen drehen.