note.nkmk.me

NumPy: Flip array (np.flip, flipud, fliplr)

Posted: 2019-06-25 / Tags: Python, NumPy

Using numpy.flip() you can flip the NumPy array ndarray vertically (up / down) or horizontally (left / right). There are also numpy.flipud() specialized for vertical flipping and numpy.fliplr() specialized for horizontal flipping.

This post describes the following contents.

  • Flip ndarray vertically: np.flipud()
  • Flip ndarray horizontally: np.fliplr()
  • Flip ndarray along any axis: np.flip()
    • Default behavior
    • Specify the axis to flip: axis
  • Flip image vertically and horizontally

It is also possible to invert with slice ::-1 without using these functions.

Sponsored Link

Flip ndarray vertically: np.flipud()

Use numpy.flipud() to flip ndarray vertically. ud means Up / Down.

numpy.flipud() returns a view. Because a view shares memory with the original array, changing one value changes the other.

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

If you want to process as separate data, use 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() is equivalent to slice [::-1]. The array flips along the first axis.

print(a_2d[::-1])
# [[3 4 5]
#  [0 1 2]]

The same is true for one-dimensional arrays and multi-dimensional arrays of three or more dimensions, where the array is flipped along the first axis. In the case of one-dimensional array, it is different from the impression of "vertically", so be careful.

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

If you want to flip the multi-dimensional array along any axis, use numpy.flip() described later.

Flip ndarray horizontally: np.fliplr()

Use numpy.fliplr() to flip ndarray horizontally. lr means Left / Right.

numpy.flipud() returns a view. If you want to process as separate data, you can use copy() as in the example of 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() is equivalent to slice [:, ::-1]. The array flips along the second axis.

print(a_2d[:, ::-1])
# [[2 1 0]
#  [5 4 3]]

The same is true for one-dimensional arrays and multi-dimensional arrays of three or more dimensions, where the array is flipped along the second axis. Note that in the case of a one-dimensional array, an error occurs because the second axis does not exist.

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

Flip ndarray along any axis: np.flip()

Use numpy.flip() to flip ndarray along any axis. It is also possible to flip along multiple axes.

Default behavior

By default, the array is flipped along all axes. In the case of a two-dimensional array, it flips vertically and horizontally

numpy.flip() returns a view. If you want to process as separate data, you can use copy() as in the example of 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

This is equivalent to flipping all axes using slices.

print(a_2d[::-1, ::-1])
# [[5 4 3]
#  [2 1 0]]

The same is true for one-dimensional arrays and multidimensional arrays of three or more dimensions. By default, the array is flipped along all 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]]]

Specify the axis to flip: axis

The axis to be reversed can be specified by the second argument axis. axis=0 is equivalent to flipud() and axis=1 to 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]]]

You can specify multiple axes for axis using tuple or 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]]]

The operation of flip() is summarized below.

flip(m, 0) is equivalent to flipud(m).
flip(m, 1) is equivalent to fliplr(m).
flip(m, n) corresponds to m[...,::-1,...] with ::-1 at position n.
flip(m) corresponds to m[::-1,::-1,...,::-1] with ::-1 at all positions.
flip(m, (0, 1)) corresponds to m[::-1,::-1,...] with ::-1 at position 0 and position 1.
numpy.flip — NumPy v1.16 Manual

Flip image vertically and horizontally

Image files can be read as NumPy array ndarray using libraries such as Pillow (PIL) and OpenCV.

You can flip the image vertically and horizontally by using numpy.flip() etc. The following example uses a color image (three-dimensional array), but the specification of arguments is the same for gray images (two-dimensional array).

The following image is used as an example.

lena

Sample code and results are below.

import numpy as np
from PIL import Image

img = np.array(Image.open('data/src/lena.jpg'))
print(type(img))
# <class 'numpy.ndarray'>

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

nupmy flipud image

nupmy fliplr image

nupmy flip image

You can also rotate images with OpenCV functions.

Sponsored Link
Share

Related Categories

Related Posts