def five_crop(img, size):
"""Crop the given Image Tensor into four corners and the central crop.
.. Note::
This transform returns a tuple of Tensors and there may be a
mismatch in the number of inputs and targets your ``Dataset`` returns.
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 not F._is_tensor_image(img):
raise TypeError('tensor is not a torch image.')
assert len(
size) == 2, "Please provide only two dimensions (h, w) for size."
_, image_width, image_height = img.size()
crop_height, crop_width = size
if crop_width > image_width or crop_height > image_height:
msg = "Requested crop size {} is bigger than input size {}"
raise ValueError(msg.format(size, (image_height, image_width)))
tl = crop(img, 0, 0, crop_width, crop_height)
tr = crop(img, image_width - crop_width, 0, image_width, crop_height)
bl = crop(img, 0, image_height - crop_height, crop_width, image_height)
br = crop(img, image_width - crop_width, image_height - crop_height,
image_width, image_height)
center = center_crop(img, (crop_height, crop_width))
return (tl, tr, bl, br, center)
def ten_crop(img, size, vertical_flip=False):
"""Crop the given Image Tensor into four corners and the central crop plus the
flipped version of these (horizontal flipping is used by default).
.. Note::
This transform returns a tuple of images and there may be a
mismatch in the number of inputs and targets your ``Dataset`` returns.
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.
vertical_flip (bool): Use vertical flipping instead of horizontal
Returns:
tuple: tuple (tl, tr, bl, br, center, tl_flip, tr_flip, bl_flip, br_flip, center_flip)
Corresponding top left, top right, bottom left, bottom right and center crop
and same for the flipped image's tensor.
"""
if not F._is_tensor_image(img):
raise TypeError('tensor is not a torch image.')
assert len(
size) == 2, "Please provide only two dimensions (h, w) for size."
first_five = five_crop(img, size)
if vertical_flip:
img = vflip(img)
else:
img = hflip(img)
second_five = five_crop(img, size)
return first_five + second_five
def resize(img, size, interpolation="bilinear"):
r"""Resize the input Tensor Image to the given size.
Args:
img (Tensor): Image to be resized.
size (sequence or int): Desired output size. If size is a sequence like
(h, w), the output size will be matched to this. If size is an int,
the smaller edge of the image will be matched to this number maintaing
the aspect ratio. i.e, if height > width, then image will be rescaled to
:math:`\left(\text{size} \times \frac{\text{height}}{\text{width}}, \text{size}\right)`
interpolation (string, optional): Desired interpolation ["bilinear", "nearest", "bicubic"]. Default is
``bilinear``
Returns:
Tensor: Resized image Tensor.
"""
if not F._is_tensor_image(img):
raise TypeError('tensor is not a torch image.')
if isinstance(size, int):
w, h = img.shape[2], img.shape[1]
if (w <= h and w == size) or (h <= w and h == size):
return img
if w < h:
ow = size
oh = int(size * h / w)
out_img = Fn.interpolate(img.unsqueeze(0), size=(oh, ow), mode=interpolation)
else:
oh = size
ow = int(size * w / h)
out_img = Fn.interpolate(img.unsqueeze(0), size=(oh, ow), mode=interpolation)
else:
out_img = Fn.interpolate(img.unsqueeze(0), size=size, mode=interpolation)
return(out_img.clamp(min=0, max=255).squeeze(0))
def denormalize(tensor, mean, std, inplace=False):
if not F._is_tensor_image(tensor):
raise TypeError('tensor is not a torch image.')
if not inplace:
tensor = tensor.clone()
dtype = tensor.dtype
mean = torch.as_tensor(mean, dtype=dtype, device=tensor.device)
std = torch.as_tensor(std, dtype=dtype, device=tensor.device)
tensor.mul_(std[:, None, None]).add_(mean[:, None, None])
return tensor
def vflip(img_tensor):
"""Vertically flip the given the Image Tensor.
Args:
img_tensor (Tensor): Image Tensor to be flipped in the form [C, H, W].
Returns:
Tensor: Vertically flipped image Tensor.
"""
if not F._is_tensor_image(img_tensor):
raise TypeError('tensor is not a torch image.')
return img_tensor.flip(-2)
def crop(img, top, left, height, width):
"""Crop the given Image Tensor.
Args:
img (Tensor): Image to be cropped in the form [C, H, W]. (0,0) denotes the top left corner of the image.
top (int): Vertical component of the top left corner of the crop box.
left (int): Horizontal component of the top left corner of the crop box.
height (int): Height of the crop box.
width (int): Width of the crop box.
Returns:
Tensor: Cropped image.
"""
if not F._is_tensor_image(img):
raise TypeError('tensor is not a torch image.')
return img[..., top:top + height, left:left + width]
def adjust_brightness(img, brightness_factor):
"""Adjust brightness of an RGB image.
Args:
img (Tensor): Image to be adjusted.
brightness_factor (float): How much to adjust the brightness. Can be
any non negative number. 0 gives a black image, 1 gives the
original image while 2 increases the brightness by a factor of 2.
Returns:
Tensor: Brightness adjusted image.
"""
if not F._is_tensor_image(img):
raise TypeError('tensor is not a torch image.')
return _blend(img, 0, brightness_factor)
def adjust_saturation(img, saturation_factor):
"""Adjust color saturation of an RGB image.
Args:
img (Tensor): Image to be adjusted.
saturation_factor (float): How much to adjust the saturation. 0 will
give a black and white image, 1 will give the original image while
2 will enhance the saturation by a factor of 2.
Returns:
Tensor: Saturation adjusted image.
"""
if not F._is_tensor_image(img):
raise TypeError('tensor is not a torch image.')
return _blend(img, rgb_to_grayscale(img), saturation_factor)
def renormalize(tensor: torch.Tensor, mean, std, inplace=False):
'''
recover from F.normalization
:param tensor:
:param mean:
:param std:
:param inplace:
:return:
'''
if not F._is_tensor_image(tensor):
raise TypeError('tensor is not a torch image.')
if not inplace:
tensor = tensor.clone()
mean = torch.as_tensor(mean, dtype=torch.float32, device=tensor.device)
std = torch.as_tensor(std, dtype=torch.float32, device=tensor.device)
tensor.mul_(std[:, None, None]).add_(mean[:, None, None])
return tensor
def adjust_contrast(img, contrast_factor):
"""Adjust contrast of an RGB image.
Args:
img (Tensor): Image to be adjusted.
contrast_factor (float): How much to adjust the contrast. Can be any
non negative number. 0 gives a solid gray image, 1 gives the
original image while 2 increases the contrast by a factor of 2.
Returns:
Tensor: Contrast adjusted image.
"""
if not F._is_tensor_image(img):
raise TypeError('tensor is not a torch image.')
mean = torch.mean(rgb_to_grayscale(img).to(torch.float))
return _blend(img, mean, contrast_factor)
def center_crop(img, output_size):
"""Crop the Image Tensor and resize it to desired size.
Args:
img (Tensor): Image to be cropped. (0,0) denotes the top left corner of the image.
output_size (sequence or int): (height, width) of the crop box. If int,
it is used for both directions
Returns:
Tensor: Cropped image.
"""
if not F._is_tensor_image(img):
raise TypeError('tensor is not a torch image.')
_, image_width, image_height = img.size()
crop_height, crop_width = output_size
crop_top = int(round((image_height - crop_height) / 2.))
crop_left = int(round((image_width - crop_width) / 2.))
return crop(img, crop_top, crop_left, crop_height, crop_width)
