Pytorch 图像变换函数集合小结

短命女 2022-10-26 01:22 355阅读 0赞

一、必要的 python 模块  
PyTorch 的 Vision 模块提供了图像变换的很多函数.

torchvision/transforms/functional.py

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
from \_\_future\_\_ import division  
import torch  
import sys  
import math  
from PIL import Image, ImageOps, ImageEnhance, PILLOW\_VERSION  
try:  
import accimage  
except ImportError:  
accimage = None  
import numpy as np  
import numbers  
import collections  
import warnings  
import matplotlib as plt  
  
if sys.version\_info < (3, 3):  
Sequence = collections.Sequence  
Iterable = collections.Iterable  
else:  
Sequence = collections.abc.Sequence  
Iterable = collections.abc.Iterable  
以下图为例：

1  
2  
3  
4  
img\_file = "test.jpe"  
img = Image.open(img\_file)  
width, height = img.size \#(750, 815)  
img.show()

二、PyTorch 图像变换函数  
2.1 判断图像数据类型  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
\# 图像格式检查，如，pil, tensor, numpy  
def \_is\_pil\_image(img):  
if accimage is not None:  
return isinstance(img, (Image.Image, accimage.Image))  
else:  
return isinstance(img, Image.Image)  
  
def \_is\_tensor\_image(img):  
return torch.is\_tensor(img) and img.ndimension() == 3  
  
def \_is\_numpy\_image(img):  
return isinstance(img, np.ndarray) and (img.ndim in \{2, 3\})  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
\# example:  
\_is\_pil\_image(img)  
\# True  
  
\_is\_tensor\_image(img)  
\# False  
  
\_is\_numpy\_image(img)  
\# False  
  
\_is\_numpy\_image(np.array(img))  
\# True  
2.2 to\_tensor(pic)  
将 PIL Image 或 nupy.ndarray 转换为 tensor

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
def to\_tensor(pic):  
"""  
Args:  
pic (PIL Image or numpy.ndarray): Image to be converted to tensor.  
  
Returns:  
Tensor: Converted image.  
"""  
if not(\_is\_pil\_image(pic) or \_is\_numpy\_image(pic)):  
raise TypeError('pic should be PIL Image or ndarray. Got \{\}'.format(type(pic)))  
  
if isinstance(pic, np.ndarray):  
\# handle numpy array  
img = torch.from\_numpy(pic.transpose((2, 0, 1)))  
\# backward compatibility  
if isinstance(img, torch.ByteTensor):  
return img.float().div(255)  
else:  
return img  
  
if accimage is not None and isinstance(pic, accimage.Image):  
nppic = np.zeros(\[pic.channels, pic.height, pic.width\], dtype=np.float32)  
pic.copyto(nppic)  
return torch.from\_numpy(nppic)  
  
\# handle PIL Image  
if pic.mode == 'I':  
img = torch.from\_numpy(np.array(pic, np.int32, copy=False))  
elif pic.mode == 'I;16':  
img = torch.from\_numpy(np.array(pic, np.int16, copy=False))  
elif pic.mode == 'F':  
img = torch.from\_numpy(np.array(pic, np.float32, copy=False))  
elif pic.mode == '1':  
img = 255 \* torch.from\_numpy(np.array(pic, np.uint8, copy=False))  
else:  
img = torch.ByteTensor(torch.ByteStorage.from\_buffer(pic.tobytes()))  
\# PIL image mode: L, P, I, F, RGB, YCbCr, RGBA, CMYK  
if pic.mode == 'YCbCr':  
nchannel = 3  
elif pic.mode == 'I;16':  
nchannel = 1  
else:  
nchannel = len(pic.mode)  
img = img.view(pic.size\[1\], pic.size\[0\], nchannel)  
\# put it from HWC to CHW format  
\# yikes, this transpose takes 80% of the loading time/CPU  
img = img.transpose(0, 1).transpose(0, 2).contiguous()  
if isinstance(img, torch.ByteTensor):  
return img.float().div(255)  
else:  
return img  
2.3 to\_pil\_image(pic, mode=None)  
将 tensor 或 ndarray 转换为 PIL Image

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
def to\_pil\_image(pic, mode=None):  
"""  
Args:  
pic (Tensor or numpy.ndarray): Image to be converted to PIL Image.  
mode (\`PIL.Image mode\`\_): color space and pixel depth of input data (optional).  
  
.. \_PIL.Image mode: https://pillow.readthedocs.io/en/latest/handbook/concepts.html\#concept-modes  
  
Returns:  
PIL Image: Image converted to PIL Image.  
"""  
if not(isinstance(pic, torch.Tensor) or isinstance(pic, np.ndarray)):  
raise TypeError('pic should be Tensor or ndarray. Got \{\}.'.format(type(pic)))  
  
elif isinstance(pic, torch.Tensor):  
if pic.ndimension() not in \{2, 3\}:  
raise ValueError('pic should be 2/3 dimensional. Got \{\} '\\  
'dimensions.'.format(pic.ndimension()))  
  
elif pic.ndimension() == 2:  
\# if 2D image, add channel dimension (CHW)  
pic.unsqueeze\_(0)  
  
elif isinstance(pic, np.ndarray):  
if pic.ndim not in \{2, 3\}:  
raise ValueError('pic should be 2/3 dimensional. Got \{\} '\\  
'dimensions.'.format(pic.ndim))  
  
elif pic.ndim == 2:  
\# if 2D image, add channel dimension (HWC)  
pic = np.expand\_dims(pic, 2)  
  
npimg = pic  
if isinstance(pic, torch.FloatTensor):  
pic = pic.mul(255).byte()  
if isinstance(pic, torch.Tensor):  
npimg = np.transpose(pic.numpy(), (1, 2, 0))  
  
if not isinstance(npimg, np.ndarray):  
raise TypeError('Input pic must be a torch.Tensor or NumPy ndarray, ' +  
'not \{\}'.format(type(npimg)))  
  
if npimg.shape\[2\] == 1:  
expected\_mode = None  
npimg = npimg\[:, :, 0\]  
if npimg.dtype == np.uint8:  
expected\_mode = 'L'  
elif npimg.dtype == np.int16:  
expected\_mode = 'I;16'  
elif npimg.dtype == np.int32:  
expected\_mode = 'I'  
elif npimg.dtype == np.float32:  
expected\_mode = 'F'  
if mode is not None and mode != expected\_mode:  
raise ValueError("Incorrect mode (\{\}) supplied for input type \{\}. Should be \{\}"  
.format(mode, np.dtype, expected\_mode))  
mode = expected\_mode  
  
elif npimg.shape\[2\] == 4:  
permitted\_4\_channel\_modes = \['RGBA', 'CMYK'\]  
if mode is not None and mode not in permitted\_4\_channel\_modes:  
raise ValueError("Only modes \{\} are supported for 4D inputs".format(permitted\_4\_channel\_modes))  
  
if mode is None and npimg.dtype == np.uint8:  
mode = 'RGBA'  
else:  
permitted\_3\_channel\_modes = \['RGB', 'YCbCr', 'HSV'\]  
if mode is not None and mode not in permitted\_3\_channel\_modes:  
raise ValueError("Only modes \{\} are supported for 3D inputs".format(permitted\_3\_channel\_modes))  
if mode is None and npimg.dtype == np.uint8:  
mode = 'RGB'  
  
if mode is None:  
raise TypeError('Input type \{\} is not supported'.format(npimg.dtype))  
  
return Image.fromarray(npimg, mode=mode)  
2.4 normalize(tensor, mean, std)  
归一化 tensor 的图像. in-place 计算.

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
def normalize(tensor, mean, std):  
"""  
Args:  
tensor (Tensor): Tensor image of size (C, H, W) to be normalized.  
mean (sequence): Sequence of means for each channel.  
std (sequence): Sequence of standard deviations for each channely.  
  
Returns:  
Tensor: Normalized Tensor image.  
"""  
if not \_is\_tensor\_image(tensor):  
raise TypeError('tensor is not a torch image.')  
  
\# This is faster than using broadcasting, don't change without benchmarking  
for t, m, s in zip(tensor, mean, std):  
t.sub\_(m).div\_(s)  
return tensor  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
\# example  
mean = \[0.485, 0.456, 0.406\]  
std = \[0.229, 0.224, 0.225\]  
img\_normalize = normalize(img\_tensor, mean, std)  
  
\# vis  
ax1 = plt.subplot(1, 2, 1)  
ax1.imshow(img)  
ax1.axis("off")  
ax1.set\_title("orig img")  
ax2 = plt.subplot(1, 2, 2)  
ax2.imshow(to\_pil\_image(img\_normalize))  
ax2.axis("off")  
ax2.set\_title("normalize img")  
plt.show()

2.5 resize(img, size, interpolation=Image.BILINEAR)  
对输入的 PIL Image 进行 resize 到给定尺寸.  
参数 size 为调整后的尺寸.  
如果 size 是数组(h, w)，则直接调整到该 (h, w) 尺寸.  
如果 size 是一个 int 值，则调整后图像的最短边是该值，且保持固定的长宽比.

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
def resize(img, size, interpolation=Image.BILINEAR):  
"""  
Args:  
img (PIL Image): Image to be resized.  
size (sequence or int): Desired output size.  
interpolation (int, optional): Desired interpolation. Default is  
\`\`PIL.Image.BILINEAR\`\`  
Returns:  
PIL Image: Resized image.  
"""  
if not \_is\_pil\_image(img):  
raise TypeError('img should be PIL Image. Got \{\}'.format(type(img)))  
if not (isinstance(size, int) or (isinstance(size, Iterable) and len(size) == 2)):  
raise TypeError('Got inappropriate size arg: \{\}'.format(size))  
  
if isinstance(size, int):  
w, h = img.size  
if (w <= h and w == size) or (h <= w and h == size):  
return img  
if w < h:  
ow = size  
oh = int(size \* h / w)  
return img.resize((ow, oh), interpolation)  
else:  
oh = size  
ow = int(size \* w / h)  
return img.resize((ow, oh), interpolation)  
else:  
return img.resize(size\[::-1\], interpolation)  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
\# example:  
img\_resize\_256x256 = resize(img, (256, 256)) \# (256, 256)  
img\_resize\_256 = resize(img, 256) \# (256, 278)  
  
\# vis  
ax1 = plt.subplot(1, 3, 1)  
ax1.imshow(img)  
ax1.axis("off")  
ax1.set\_title("orig img")  
ax2 = plt.subplot(1, 3, 2)  
ax2.imshow(img\_resize\_256x256)  
ax2.axis("off")  
ax2.set\_title("resize\_256x256 img")  
ax3 = plt.subplot(1, 3, 3)  
ax3.imshow(img\_resize\_256)  
ax3.axis("off")  
ax3.set\_title("resize\_256 img")  
plt.show()

2.6 pad(img, padding, fill=0, padding\_mode=‘constant')  
根据指定的 padding 模式和填充值，对给定的 PIL Image 的所有边进行 pad 处理.  
参数 padding - int 或 tuple 形式.

padding:

如果是 int 值 ，则对所有的边都 padding 该 int 值.  
如果是长度为 2 的tuple，则对 left/right 和 top/bottom 分别进行 padding.  
如果是长度为 4 的 tuple，则对 left，top，right， bottom 边分别进行 padding.  
参数 fill - 像素填充值，默认为 0. 如果值是长度为 3 的 tuple，则分别对 R，G，B 通道进行填充. 仅用于当 padding\_mode='constant' 的情况.  
参数 padding\_mode - 填充的类型，可选：constant，edge，reflect，symmetric. 默认为 constant. 填充常数值.

constant - padding 填充常数值 fill.

edge - padding 图像边缘的最后一个值.

reflect - padding 图像的反射(reflection)值，（不对图像边缘的最后一个像素值进行重复）  
如，\[1, 2, 3, 4\] 在 reflect 模式下在 两边 padding 2 个元素值，会得到：  
\[3, 2, 1, 2, 3, 4, 3, 2\]

symmetric - padding 图像的反射(reflection)值，(对图像边缘的最后一个像素值进行重复).  
如，\[1, 2, 3, 4\] 在 symmetric 模式下在 两边 padding 2 个元素值，会得到：  
\[2, 1, 1, 2, 3, 4, 4, 3\]

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
def pad(img, padding, fill=0, padding\_mode='constant'):  
"""  
Args:  
img (PIL Image): Image to be padded.  
padding (int or tuple): Padding on each border.  
fill: Pixel fill value for constant fill. Default is 0.  
padding\_mode: Type of padding. Should be: constant, edge, reflect or symmetric.  
Default is constant.  
Returns:  
PIL Image: Padded image.  
"""  
if not \_is\_pil\_image(img):  
raise TypeError('img should be PIL Image. Got \{\}'.format(type(img)))  
  
if not isinstance(padding, (numbers.Number, tuple)):  
raise TypeError('Got inappropriate padding arg')  
if not isinstance(fill, (numbers.Number, str, tuple)):  
raise TypeError('Got inappropriate fill arg')  
if not isinstance(padding\_mode, str):  
raise TypeError('Got inappropriate padding\_mode arg')  
  
if isinstance(padding, Sequence) and len(padding) not in \[2, 4\]:  
raise ValueError("Padding must be an int or a 2, or 4 element tuple, not a " +  
"\{\} element tuple".format(len(padding)))  
  
assert padding\_mode in \['constant', 'edge', 'reflect', 'symmetric'\], \\  
'Padding mode should be either constant, edge, reflect or symmetric'  
  
if padding\_mode == 'constant':  
if img.mode == 'P':  
palette = img.getpalette()  
image = ImageOps.expand(img, border=padding, fill=fill)  
image.putpalette(palette)  
return image  
  
return ImageOps.expand(img, border=padding, fill=fill)  
else:  
if isinstance(padding, int):  
pad\_left = pad\_right = pad\_top = pad\_bottom = padding  
if isinstance(padding, Sequence) and len(padding) == 2:  
pad\_left = pad\_right = padding\[0\]  
pad\_top = pad\_bottom = padding\[1\]  
if isinstance(padding, Sequence) and len(padding) == 4:  
pad\_left = padding\[0\]  
pad\_top = padding\[1\]  
pad\_right = padding\[2\]  
pad\_bottom = padding\[3\]  
  
if img.mode == 'P':  
palette = img.getpalette()  
img = np.asarray(img)  
img = np.pad(img,  
((pad\_top, pad\_bottom), (pad\_left, pad\_right)),  
padding\_mode)  
img = Image.fromarray(img)  
img.putpalette(palette)  
return img  
  
img = np.asarray(img)  
\# RGB image  
if len(img.shape) == 3:  
img = np.pad(img,  
((pad\_top, pad\_bottom),  
(pad\_left, pad\_right),  
(0, 0)),  
padding\_mode)  
\# Grayscale image  
if len(img.shape) == 2:  
img = np.pad(img,  
((pad\_top, pad\_bottom), (pad\_left, pad\_right)),  
padding\_mode)  
  
return Image.fromarray(img)  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
\# example:  
img\_padding = pad(img, (10, 20, 30 ,40), fill=128) \# (750, 815) -> (790, 875)  
  
\# vis  
ax1 = plt.subplot(1, 2, 1)  
ax1.imshow(img)  
ax1.axis("off")  
ax1.set\_title("orig img")  
ax2 = plt.subplot(1, 2, 2)  
ax2.imshow(img\_padding)  
ax2.axis("off")  
ax2.set\_title("padding img")  
plt.show()

2.7 crop(img, i, j, h, w)  
裁剪给定的 PIL Image.

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
def crop(img, i, j, h, w):  
"""  
Args:  
img (PIL Image): Image to be cropped.  
i: Upper pixel coordinate.  
j: Left pixel coordinate.  
h: Height of the cropped image.  
w: Width of the cropped image.  
  
Returns:  
PIL Image: Cropped image.  
"""  
if not \_is\_pil\_image(img):  
raise TypeError('img should be PIL Image. Got \{\}'.format(type(img)))  
  
return img.crop((j, i, j + w, i + h))  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
\# example  
img\_crop = crop(img, 100, 100, 500, 500) \# (750, 815) -> (500, 500)  
  
ax1 = plt.subplot(1, 2, 1)  
ax1.imshow(img)  
ax1.axis("off")  
ax1.set\_title("orig img")  
ax2 = plt.subplot(1, 2, 2)  
ax2.imshow(img\_crop)  
ax2.axis("off")  
ax2.set\_title("crop img")  
plt.show()

2.8 center\_crop(img, output\_size)  
1  
2  
3  
4  
5  
6  
7  
8  
def center\_crop(img, output\_size):  
if isinstance(output\_size, numbers.Number):  
output\_size = (int(output\_size), int(output\_size))  
w, h = img.size  
th, tw = output\_size  
i = int(round((h - th) / 2.))  
j = int(round((w - tw) / 2.))  
return crop(img, i, j, th, tw)  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
\#example  
img\_centercrop = center\_crop(img, (256, 256)) \# (750, 815) -> (256, 256)  
  
ax1 = plt.subplot(1, 2, 1)  
ax1.imshow(img)  
ax1.axis("off")  
ax1.set\_title("orig img")  
ax2 = plt.subplot(1, 2, 2)  
ax2.imshow(img\_centercrop)  
ax2.axis("off")  
ax2.set\_title("centercrop img")  
plt.show()  
2.9 resized\_crop(img, i, j, h, w, size, interpolation=Image.BILINEAR)  
对给定 PIL Image 进行裁剪，并 resize 到特定尺寸.

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
def resized\_crop(img, i, j, h, w, size, interpolation=Image.BILINEAR):  
"""  
Args:  
img (PIL Image): Image to be cropped.  
i: Upper pixel coordinate.  
j: Left pixel coordinate.  
h: Height of the cropped image.  
w: Width of the cropped image.  
size (sequence or int): Desired output size. Same semantics as \`\`resize\`\`.  
interpolation (int, optional): Desired interpolation. Default is  
\`\`PIL.Image.BILINEAR\`\`.  
Returns:  
PIL Image: Cropped image.  
"""  
assert \_is\_pil\_image(img), 'img should be PIL Image'  
img = crop(img, i, j, h, w)  
img = resize(img, size, interpolation)  
return img  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
\# example  
img\_resizedcrop = resized\_crop(img, 100, 100, 500, 500, (256, 256)) \# (750, 815) -> (500, 500) -> (256, 256)  
  
ax1 = plt.subplot(1, 2, 1)  
ax1.imshow(img)  
ax1.axis("off")  
ax1.set\_title("orig img")  
ax2 = plt.subplot(1, 2, 2)  
ax2.imshow(img\_resizedcrop)  
ax2.axis("off")  
ax2.set\_title("resizedcrop img")  
plt.show()

2.10 hflip(img)  
水平翻转 (Horizontally flip) 给定的 PIL Image.

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
def hflip(img):  
"""  
Args:  
img (PIL Image): Image to be flipped.  
  
Returns:  
PIL Image: Horizontall flipped image.  
"""  
if not \_is\_pil\_image(img):  
raise TypeError('img should be PIL Image. Got \{\}'.format(type(img)))  
  
return img.transpose(Image.FLIP\_LEFT\_RIGHT)  
2.11 vflip(img)  
垂直翻转 (Vertically flip) 给定的 PIL Image.

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
def vflip(img):  
"""  
Args:  
img (PIL Image): Image to be flipped.  
  
Returns:  
PIL Image: Vertically flipped image.  
"""  
if not \_is\_pil\_image(img):  
raise TypeError('img should be PIL Image. Got \{\}'.format(type(img)))  
  
return img.transpose(Image.FLIP\_TOP\_BOTTOM)  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
\# example:  
img\_hflip = hflip(img)  
img\_vflip = vflip(img)  
  
ax1 = plt.subplot(1, 3, 1)  
ax1.imshow(img)  
ax1.axis("off")  
ax1.set\_title("orig img")  
ax2 = plt.subplot(1, 3, 2)  
ax2.imshow(img\_hflip)  
ax2.axis("off")  
ax2.set\_title("hflip img")  
ax3 = plt.subplot(1, 3, 3)  
ax3.imshow(img\_vflip)  
ax3.axis("off")  
ax3.set\_title("vflip img")  
plt.show()

2.12 five\_crop(img, size)  
Crop the given PIL Image into four corners and the central crop.  
从给定 PIL Image 的四个角和中间裁剪出五个子图像.

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
def five\_crop(img, size):  
"""  
Args:  
size (sequence or int): Desired output size of the crop. If size is an  
int instead of sequence like (h, w), a square crop (size, size) is  
made.  
  
Returns:  
tuple: tuple (tl, tr, bl, br, center)  
Corresponding top left, top right, bottom left,  
bottom right and center crop.  
"""  
if isinstance(size, numbers.Number):  
size = (int(size), int(size))  
else:  
assert len(size) == 2, "Please provide only two dimensions (h, w) for size."  
  
w, h = img.size  
crop\_h, crop\_w = size  
if crop\_w > w or crop\_h > h:  
raise ValueError("Requested crop size \{\} is bigger than input size \{\}".format(size,  
(h, w)))  
tl = img.crop((0, 0, crop\_w, crop\_h))  
tr = img.crop((w - crop\_w, 0, w, crop\_h))  
bl = img.crop((0, h - crop\_h, crop\_w, h))  
br = img.crop((w - crop\_w, h - crop\_h, w, h))  
center = center\_crop(img, (crop\_h, crop\_w))  
return (tl, tr, bl, br, center)  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
\# example:  
img\_tl, img\_tr, img\_bl, img\_br, img\_center = five\_crop(img, (400, 400))  
  
ax1 = plt.subplot(2, 3, 1)  
ax1.imshow(img)  
ax1.axis("off")  
ax1.set\_title("orig img")  
ax2 = plt.subplot(2, 3, 2)  
ax2.imshow(img\_tl)  
ax2.axis("off")  
ax2.set\_title("tl img")  
ax3 = plt.subplot(2, 3, 3)  
ax3.imshow(img\_tr)  
ax3.axis("off")  
ax3.set\_title("tr img")  
ax4 = plt.subplot(2, 3, 4)  
ax4.imshow(img\_bl)  
ax4.axis("off")  
ax4.set\_title("bl img")  
ax5 = plt.subplot(2, 3, 5)  
ax5.imshow(img\_br)  
ax5.axis("off")  
ax5.set\_title("br img")  
ax6 = plt.subplot(2, 3, 6)  
ax6.imshow(img\_center)  
ax6.axis("off")  
ax6.set\_title("center img")  
plt.show()