| import numbers |
| import torch |
| import cv2 |
| import numpy as np |
| import PIL |
| from PIL import Image |
|
|
| def _is_tensor_clip(clip): |
| return torch.is_tensor(clip) and clip.ndimension() == 4 |
|
|
|
|
| def crop_clip(clip, min_h, min_w, h, w): |
| if isinstance(clip[0], np.ndarray): |
| cropped = [img[min_h:min_h + h, min_w:min_w + w, :] for img in clip] |
|
|
| elif isinstance(clip[0], PIL.Image.Image): |
| cropped = [ |
| img.crop((min_w, min_h, min_w + w, min_h + h)) for img in clip |
| ] |
| else: |
| raise TypeError('Expected numpy.ndarray or PIL.Image' + |
| 'but got list of {0}'.format(type(clip[0]))) |
| return cropped |
|
|
|
|
| def to_grayscale(img, num_output_channels=1): |
| """Convert image to grayscale version of image. |
| |
| Args: |
| img (PIL Image): Image to be converted to grayscale. |
| |
| Returns: |
| PIL Image: Grayscale version of the image. |
| if num_output_channels = 1 : returned image is single channel |
| |
| if num_output_channels = 3 : returned image is 3 channel with r = g = b |
| """ |
| if not isinstance(img,PIL.Image.Image): |
| raise TypeError('img should be PIL Image. Got {}'.format(type(img))) |
|
|
| if num_output_channels == 1: |
| img = img.convert('L') |
| elif num_output_channels == 3: |
| img = img.convert('L') |
| np_img = np.array(img, dtype=np.uint8) |
| np_img = np.dstack([np_img, np_img, np_img]) |
| img = Image.fromarray(np_img, 'RGB') |
| else: |
| raise ValueError('num_output_channels should be either 1 or 3') |
|
|
| return img |
|
|
| def resize_clip(clip, size, interpolation='bilinear'): |
| if isinstance(clip[0], np.ndarray): |
| if isinstance(size, numbers.Number): |
| im_h, im_w, im_c = clip[0].shape |
| |
| if (im_w <= im_h and im_w == size) or (im_h <= im_w |
| and im_h == size): |
| return clip |
| new_h, new_w = get_resize_sizes(im_h, im_w, size) |
| size = (new_w, new_h) |
| else: |
| size = size[1], size[0] |
| if interpolation == 'bilinear': |
| np_inter = cv2.INTER_LINEAR |
| else: |
| np_inter = cv2.INTER_NEAREST |
| scaled = [ |
| cv2.resize(img, size, interpolation=np_inter) for img in clip |
| ] |
| elif isinstance(clip[0], PIL.Image.Image): |
| if isinstance(size, numbers.Number): |
| im_w, im_h = clip[0].size |
| |
| if (im_w <= im_h and im_w == size) or (im_h <= im_w |
| and im_h == size): |
| return clip |
| new_h, new_w = get_resize_sizes(im_h, im_w, size) |
| size = (new_w, new_h) |
| else: |
| size = size[1], size[0] |
| if interpolation == 'bilinear': |
| pil_inter = PIL.Image.NEAREST |
| else: |
| pil_inter = PIL.Image.BILINEAR |
| scaled = [img.resize(size, pil_inter) for img in clip] |
| else: |
| raise TypeError('Expected numpy.ndarray or PIL.Image' + |
| 'but got list of {0}'.format(type(clip[0]))) |
| return scaled |
|
|
|
|
| def get_resize_sizes(im_h, im_w, size): |
| if im_w < im_h: |
| ow = size |
| oh = int(size * im_h / im_w) |
| else: |
| oh = size |
| ow = int(size * im_w / im_h) |
| return oh, ow |
|
|
|
|
| def normalize(clip, mean, std, inplace=False): |
| if not _is_tensor_clip(clip): |
| raise TypeError('tensor is not a torch clip.') |
|
|
| if not inplace: |
| clip = clip.clone() |
|
|
| dtype = clip.dtype |
| mean = torch.as_tensor(mean, dtype=dtype, device=clip.device) |
| std = torch.as_tensor(std, dtype=dtype, device=clip.device) |
| clip.sub_(mean[:, None, None, None]).div_(std[:, None, None, None]) |
|
|
| return clip |
|
|
