import numpy as np
from PIL import Image, ImageOps, ImageEnhance, __version__
import random
import colorsys
import numbers
import math
import io
__all__ = [
    'CentralCrop',
    'HsvToRgb',
    'AdjustBrightness',
    'AdjustContrast',
    'AdjustHue',
    'AdjustSaturation',
    'Crop',
    'FlipHorizontal',
    'FlipVertical',
    'GrayToRgb',
    'Standardization',
    'RgbToGray',
    'PadToBoundingbox',
    'Pad',
    'RandomBrightness',
    'RandomContrast',
    'RandomHue',
    'RandomSaturation',
    'RandomCrop',
    'Resize',
    'CropAndResize',
    'CropOrPad',
    'ResizeAndPad',
    'RgbToHsv',
    'Transpose',
    'RandomRotation',
    'RandomShift',
    'RandomShear',
    'RandomZoom',
    'Rescale',
    'RandomFlipVertical',
    'RandomFlipHorizontal',
    'HWC2CHW',
    'CHW2HWC',
]

augment_error_message = 'img should be PIL image. Got {}.'


def ToTensor(image):

    image = np.asarray(image).astype(np.float32)
    return image


def ToPIL(image):
    """
    Convert the input image to PIL format.

    Args:
        img: Image to be converted.

    Returns:
        img (PIL image), Converted image.
    """
    return Image.fromarray(np.array(image).astype(np.uint8))


def Decode(image):
    """
    Decode the input image to PIL image format in RGB mode.

    Args:
        img: Image to be decoded.

    Returns:
        img (PIL image), Decoded image in RGB mode.
    """

    try:
        data = io.BytesIO(image)
        img = Image.open(data)
        return img.convert('RGB')
    except IOError as e:
        raise ValueError("{0}\nWARNING: Failed to decode given image.".format(e))
    except AttributeError as e:
        raise ValueError("{0}\nWARNING: Failed to decode, Image might already be decoded.".format(e))


def Crop(image, offset_height, offset_width, target_height, target_width, is_hwc=True):
    '''

	Parameters
	----------
	image:
		A image or  a batch of images
	offset_height:
		Vertical coordinate of the top-left corner of the result in the input.
	offset_width:
		Horizontal coordinate of the top-left corner of the result in the input.
	target_height:
		Height of the result.
	target_width:
		Width of the result.
    is_hwc:
        If is_hwc is True, the order of image channels is [B,H,W,C] or [H,W,C]. If is_hwc is False, the order of image channels is [B,C,H,W] or [C,H,W,]
	Returns:
		Output [batch, target_height, target_width, channels] or [target_height, target_width, channels]
	-------

    '''
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    shape_size = len(image.shape)

    if not shape_size in (3, 4):
        raise TypeError(
            'img shape should be (H, W, C)/(N, H, W, C)/(C, H, W)/(N, C, H, W). \
                             Got {}'.format(image.shape)
        )
    if shape_size == 3:
        if is_hwc:
            height, width, channels = image.shape
        else:
            channels, height, width = image.shape
    else:
        if is_hwc:
            batch, height, width, channels = image.shape
        else:
            batch, channels, height, width = image.shape

    if offset_width < 0:
        raise ValueError('offset_width must be >0.')
    if offset_height < 0:
        raise ValueError('offset_height must be >0.')
    if target_height < 0:
        raise ValueError('target_height must be >0.')
    if target_width < 0:
        raise ValueError('target_width must be >0.')
    if offset_width + target_width > width:
        raise ValueError('offset_width + target_width must be <= image width.')
    if offset_height + target_height > height:
        raise ValueError('offset_height + target_height must be <= image height.')

    if shape_size == 3:
        if is_hwc:
            return ToTensor(
                image[offset_height:offset_height + target_height, offset_width:offset_width + target_width, :]
            )
        else:
            return ToTensor(
                image[:, offset_height:offset_height + target_height, offset_width:offset_width + target_width]
            )
    else:
        if is_hwc:
            return ToTensor(
                image[:, offset_height:offset_height + target_height, offset_width:offset_width + target_width, :]
            )
        else:
            return ToTensor(
                image[:, :, offset_height:offset_height + target_height, offset_width:offset_width + target_width]
            )


def CentralCrop(image, central_fraction=None, size=None, is_hwc=True):
    '''

	Parameters
	----------
	image :
		input Either a 3-D float Tensor of shape [height, width, depth] or a 4-D Tensor of shape [batch, height, width, depth],
	central_fraction :
		float (0, 1], fraction of size to crop
	size:
		size (Union[int, sequence]) – The output size of the cropped image. If size is an integer, a square crop of size (size, size) is returned.
		If size is a sequence of length 2, it should be (height, width).
	Returns :
		3-D float Tensor or 4-D float Tensor, as per the input.
	-------
	If backend is tensorflow, central_fraction will be used preferentially. if size is used, the height-width ratio will be equivalent to original ratio..
	If backend is mindspore, size will be used preferentially.
	'''
    if size is None and central_fraction is None:
        raise ValueError('central_fraction and size can not be both None')
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    shape_size = len(image.shape)
    if not shape_size in (3, 4):
        raise TypeError(
            'img shape should be (H, W, C)/(N, H, W, C)/(C, H, W)/(N, C, H, W). \
                             Got {}'.format(image.shape)
        )

    if shape_size == 3:
        if is_hwc:
            height, width, channels = image.shape
        else:
            channels, height, width = image.shape
    else:
        if is_hwc:
            batch, height, width, channels = image.shape
        else:
            batch, channels, height, width = image.shape
    if size is None:
        if central_fraction > 1 or central_fraction <= 0:
            raise ValueError('central_fraction must be in (0,1].')
        target_height = int(round(height * central_fraction))
        target_width = int(round(width * central_fraction))
        size = (target_height, target_width)
    if isinstance(size, int):
        size = (size, size)
    crop_height, crop_width = size
    crop_top = int(round((height - crop_height) / 2.))
    crop_left = int(round((width - crop_width) / 2.))

    return Crop(image, crop_top, crop_left, crop_height, crop_width, is_hwc)


def hsv_to_rgb(np_hsv_img, is_hwc):
    """
    Convert HSV img to RGB img.

    Args:
        np_hsv_img (numpy.ndarray): NumPy HSV image array of shape (H, W, C) or (C, H, W) to be converted.
        is_hwc (Bool): If True, the shape of np_hsv_img is (H, W, C), otherwise must be (C, H, W).

    Returns:
        np_rgb_img (numpy.ndarray), NumPy HSV image with same shape of np_hsv_img.
    """
    if is_hwc:
        h, s, v = np_hsv_img[:, :, 0], np_hsv_img[:, :, 1], np_hsv_img[:, :, 2]
    else:
        h, s, v = np_hsv_img[0, :, :], np_hsv_img[1, :, :], np_hsv_img[2, :, :]
    to_rgb = np.vectorize(colorsys.hsv_to_rgb)
    r, g, b = to_rgb(h, s, v)

    if is_hwc:
        axis = 2
    else:
        axis = 0
    np_rgb_img = np.stack((r, g, b), axis=axis)
    return np_rgb_img


def HsvToRgb(image, is_hwc=True):

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    shape_size = len(image.shape)

    if not shape_size in (3, 4):
        raise TypeError(
            'img shape should be (H, W, C)/(N, H, W, C)/(C, H, W)/(N, C, H, W). \
                             Got {}'.format(image.shape)
        )
    if shape_size == 3:
        batch_size = 0
        if is_hwc:
            num_channels = image.shape[2]
        else:
            num_channels = image.shape[0]
    else:
        batch_size = image.shape[0]
        if is_hwc:
            num_channels = image.shape[3]
        else:
            num_channels = image.shape[1]

    if num_channels != 3:
        raise TypeError('img should be 3 channels RGB img. Got {} channels'.format(num_channels))
    if batch_size == 0:
        return hsv_to_rgb(image, is_hwc)
    return ToTensor([hsv_to_rgb(img, is_hwc) for img in image])


def AdjustBrightness(image, factor):
    '''

	Parameters
	----------
	image:
		input NumPy image array or PIL image
	factor:
		factor should be in the range (-1,1)
	Returns:
	-------
		np darray image
	'''
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    if factor >= 1 or factor <= -1:
        raise ValueError('factor must be in (-1,1).')
    image = image + factor * 255
    image = np.clip(image, 0, 255)

    return ToTensor(image)


def AdjustContrast(image, factor):

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))

    image = ImageEnhance.Contrast(image).enhance(factor)

    return ToTensor(image)


def AdjustHue(image, factor):

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))

    image_hue_factor = factor
    if not -1 <= image_hue_factor <= 1:
        raise ValueError('image_hue_factor {} is not in [-1, 1].'.format(image_hue_factor))

    mode = image.mode
    if mode in {'L', '1', 'I', 'F'}:
        return image

    hue, saturation, value = image.convert('HSV').split()

    np_hue = np.array(hue, dtype=np.uint8)

    with np.errstate(over='ignore'):
        np_hue += np.uint8(image_hue_factor * 255)
    hue = Image.fromarray(np_hue, 'L')

    image = Image.merge('HSV', (hue, saturation, value)).convert(mode)

    return ToTensor(image)


def AdjustSaturation(image, factor):

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))

    enhancer = ImageEnhance.Color(image)
    image = enhancer.enhance(factor)

    return ToTensor(image)


def FlipHorizontal(image):

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))

    image = np.fliplr(image)

    return image


def FlipVertical(image):

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    image = np.flipud(image)

    return image


def GrayToRgb(image):

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    shape = image.shape
    output_image = np.zeros((shape[0], shape[1], 3), dtype=np.uint8)
    if len(shape) == 3:
        for i in range(3):
            output_image[:, :, i] = image[:, :, 1]
    elif len(shape) == 2:
        for i in range(3):
            output_image[:, :, i] = image

    return ToTensor(output_image)


def RgbToGray(image):

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))
    '''
	将彩色图像转换为灰度（模式“L”）时，库使用ITU-R 601-2 Luma转换：
	L = R * 299/1000 + G * 587/1000 + B * 114/1000
	'''
    image = image.convert('L')
    return ToTensor(image)


def PadToBoundingbox(image, offset_height, offset_width, target_height, target_width, padding_value=0, is_hwc=True):
    '''

	Parameters
	----------
	image:
		A 3-D numpy ndarray or 4-D numpy ndarray image
	offset_height:
		 Number of rows of zeros to add on top.
	offset_width:
		 Number of columns of zeros to add on the left.
	target_height:
		Height of output image.
	target_width
		 Width of output image.
	Returns
		A numpy ndarray image
	-------
	'''

    if offset_height < 0:
        raise ValueError("offset_height must be >= 0")
    if offset_width < 0:
        raise ValueError("offset_width must be >= 0")
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    shape_size = len(image.shape)
    if not shape_size in (3, 4):
        raise TypeError(
            'img shape should be (H, W, C)/(N, H, W, C)/(C, H, W)/(N, C, H, W). \
                             Got {}'.format(image.shape)
        )
    if shape_size == 3:
        if is_hwc:
            height, width, channels = image.shape
        else:
            channels, height, width = image.shape
    else:
        if is_hwc:
            batch, height, width, channels = image.shape
        else:
            batch, channels, height, width = image.shape
    top = offset_height
    bottom = target_height - height - top
    left = offset_width
    right = target_width - width - left

    if bottom < 0:
        raise ValueError("target_height must be >= offset_height + height")

    if right < 0:
        raise ValueError("target_width must be >= offset_width + width")

    if shape_size == 3:
        if is_hwc:
            return ToTensor(
                np.pad(
                    image, ((top, bottom), (left, right), (0, 0)), mode='constant',
                    constant_values=(padding_value, padding_value)
                )
            )
        else:
            return ToTensor(
                np.pad(
                    image, ((0, 0), (top, bottom), (left, right)), mode='constant',
                    constant_values=(padding_value, padding_value)
                )
            )
    else:
        if is_hwc:
            return ToTensor(
                np.pad(
                    image, ((0, 0), (top, bottom), (left, right), (0, 0)), mode='constant',
                    constant_values=(padding_value, padding_value)
                )
            )
        else:
            return ToTensor(
                np.pad(
                    image, ((0, 0), (0, 0), (top, bottom), (left, right)), mode='constant',
                    constant_values=(padding_value, padding_value)
                )
            )


def Pad(image, padding, padding_value=0, mode='constant', is_hwc=True):
    '''

    Parameters
    ----------
    image:
        A 3-D or 4-D Tensor.
    padding:
        An integer or a list/tuple.  If a single number is provided, pad all borders with this value.
        If a tuple or list of 2 values is provided, pad the left and top with the first value and the right and bottom with the second value.
        If 4 values are provided as a list or tuple, pad the left, top, right and bottom respectively.
    padding_value:
        In "CONSTANT" mode, the scalar pad value to use. Must be same type as tensor.
    mode:
        One of "CONSTANT", "REFLECT", or "SYMMETRIC" (case-insensitive)
    Returns:
        A padded Tensor. Has the same type as tensor.
    -------

    '''
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    shape_size = image.shape
    if len(shape_size) == 3:
        batch_size = 0
    elif len(shape_size) == 4:
        batch_size = shape_size[0]
    else:
        raise TypeError(
            'img shape should be (H, W, C)/(N, H, W, C)/(C, H, W)/(N, C, H, W). \
                                      Got {}'.format(image.shape)
        )
    if mode not in ('constant', 'edge', 'reflect', 'symmetric'):
        raise TypeError('mode should be one of (constant,edge,reflect,symmetric).')

    if isinstance(padding, int):
        padding = ((padding, padding), (padding, padding))
    elif isinstance(padding, list) or isinstance(padding, tuple):
        if len(padding) == 2:
            padding = ((padding[0], padding[0]), (padding[1], padding[1]))
        elif len(padding) == 4:
            padding = ((padding[0], padding[1]), (padding[2], padding[3]))
        else:
            raise ValueError('The length of padding should be 2 or 4, but got {}.'.format(len(padding)))
    else:
        raise TypeError('Padding should be an integer or a list/tuple, but got {}.'.format(type(padding)))

    if batch_size == 0:
        if is_hwc:
            padding = (padding[0], padding[1], (0, 0))
        else:
            padding = (
                (0, 0),
                padding[0],
                padding[1],
            )
    else:
        if is_hwc:
            padding = ((0, 0), padding[0], padding[1], (0, 0))
        else:
            padding = ((0, 0), (0, 0), padding[0], padding[1])
    if mode == 'constant':
        return ToTensor(np.pad(image, padding, mode=mode, constant_values=(padding_value, padding_value)))
    else:
        return ToTensor(np.pad(image, padding, mode=mode))


def Standardization(image, mean=None, std=None, channel_mode=False, is_hwc=True):
    '''

	Parameters
	----------
	image:
		An n-D Tensor with at least 3 dimensions, the last 3 of which are the dimensions of each image.
	mean:
		List or tuple of mean values for each channel, with respect to channel order.
	std:
		 List or tuple of standard deviations for each channel.
	channel_mode:
		Decide to implement standardization on whole image or each channel of image.
	Returns:
		A Tensor with the same shape and dtype as image.
	-------
	'''

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    num_shape = image.shape
    if is_hwc:
        height, width, channels = 0, 1, 2
    else:
        channels, height, width = 0, 1, 2
    if mean is not None and std is not None:
        if len(mean) != len(std):
            raise ValueError("Length of mean and std must be equal")
        if len(mean) == 1:
            mean = [mean[0]] * num_shape[channels]
            std = [std[0]] * num_shape[channels]
        mean = np.array(mean, dtype=image.dtype)
        std = np.array(std, dtype=image.dtype)
        return ToTensor((image - mean[:, None, None]) / std[:, None, None])
    elif mean is None and std is None:
        if channel_mode:
            num_pixels = num_shape[height] * num_shape[width]
            image_mean = np.mean(image, axis=(height, width))
            stddev = np.std(image, axis=(height, width))
            min_sttdev = 1 / np.sqrt(num_pixels)
            min_sttdev = [min_sttdev] * num_shape[channels]
            adjusted_sttdev = np.maximum(stddev, min_sttdev)
            image -= image_mean
            image = np.divide(image, adjusted_sttdev)
            return ToTensor(image)
        else:
            num_pixels = num_shape[height] * num_shape[width] * num_shape[channels]
            image_mean = np.mean(image, axis=(0, 1, 2))
            image_mean = [image_mean] * 3
            stddev = np.std(image, axis=(0, 1, 2))
            min_sttdev = 1 / np.sqrt(num_pixels)
            adjusted_sttdev = np.maximum(stddev, min_sttdev)
            adjusted_sttdev = [adjusted_sttdev] * 3
            image -= image_mean
            image = np.divide(image, adjusted_sttdev)
            return ToTensor(image)
    else:
        raise ValueError('std and mean must both be None or not None')


def RandomBrightness(image, factor):
    '''

    Parameters
    ----------
    image:
        An image or images to adjust
    factor:
        Float, must be non-negative. Factor must be (0,1). Random range will be [-factor, factor).
    Returns:
        The brightness-adjusted image(s).
    -------

    '''
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    if factor < 0 or factor > 1:
        raise ValueError('factor should be in [0,1].')
    delta = random.uniform(-factor, factor)
    image = image + delta * 255
    image = np.clip(image, 0, 255)

    return image


def RandomContrast(image, lower, upper, seed=None):
    '''

    Parameters
    ----------
    image:
        An image tensor with 3 or more dimensions.
    lower:
        float.  Lower bound for the random contrast factor.
    upper:
        float.  Upper bound for the random contrast factor.
    seed:
        A Python integer. Used to create a random seed.

    Returns:
         The contrast-adjusted image(s).
    -------
    '''
    if upper <= lower:
        raise ValueError('upper must be > lower')
    if lower < 0:
        raise ValueError('lower must be non-negative')
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))

    factor = random.uniform(lower, upper)
    image = ImageEnhance.Contrast(image).enhance(factor)

    return ToTensor(image)


def RandomHue(image, factor, seed=None):
    '''

    Parameters
    ----------
    image:
        RGB image or images. The size of the last dimension must be 3.
    factor:
        float. The maximum value for the random factor.
    seed:
         An operation-specific seed. I

    Returns:
        Adjusted numpy ndarrry image(s).
    -------

    '''

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))

    if factor > 0.5 or factor < 0:
        raise ValueError('factor should be in [0,0.5].')

    image_hue_factor = random.uniform(-factor, factor)
    mode = image.mode
    if mode in {'L', '1', 'I', 'F'}:
        return image

    hue, saturation, value = image.convert('HSV').split()

    np_hue = np.array(hue, dtype=np.uint8)

    with np.errstate(over='ignore'):
        np_hue += np.uint8(image_hue_factor * 255)
    hue = Image.fromarray(np_hue, 'L')

    image = Image.merge('HSV', (hue, saturation, value)).convert(mode)

    return ToTensor(image)


def RandomSaturation(image, lower, upper, seed=None):
    '''
    Parameters
    ----------
    image:
        RGB image or images. The size of the last dimension must be 3.
    lower:
        float.  Lower bound for the random saturation factor.
    upper:
        float.  Upper bound for the random saturation factor.
    seed:
        An operation-specific seed.

    Returns；
        Adjusted numpy ndarray image(s).
    -------
    '''
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))
    if upper <= lower:
        raise ValueError('upper must be > lower.')

    if lower < 0:
        raise ValueError('lower must be non-negative.')
    factor = random.uniform(lower, upper)
    enhancer = ImageEnhance.Color(image)
    image = enhancer.enhance(factor)

    return ToTensor(image)


def RandomCrop(image, size, is_hwc=True):
    '''

    Parameters
    ----------
    image:
        Input an image  to crop.
    size:
        if size is an integer, shape of cropped image  will be [size, size, 3]. if length of size is 2.
        shape of cropped image  will be [height, width, 3].
    Returns:
        A cropped image of the same rank as image and shape size.
    -------
    '''
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    if isinstance(size, int):
        size = (size, size)
    elif isinstance(size, (tuple, list)) and len(size) == 2:
        size = size
    else:
        raise ValueError("Size should be a single integer or a list/tuple (h, w) of length 2.")

    def _input_to_factor_(image, size, is_hwc):
        if len(image.shape) == 3:
            if is_hwc:
                height, width, channels = image.shape
            else:
                channels, height, width = image.shape
        else:
            if is_hwc:
                batch, height, width, channels = image.shape
            else:
                batch, channels, height, width = image.shape

        target_height, target_width = size
        if target_height > height or target_width > width:
            raise ValueError("Crop size {} is larger than input image size {}".format(size, (height, width)))
        if target_height == height and target_width == width:
            return 0, 0, height, width

        top = random.randint(0, height - target_height)
        left = random.randint(0, width - target_width)
        return top, left, target_height, target_width

    top, left, height, width = _input_to_factor_(image, size, is_hwc)

    return Crop(image, top, left, height, width, is_hwc)


def Resize(image, size, method='bilinear', preserve_aspect_ratio=False, antialias=False):
    '''

    Parameters
    ----------
    images:
        Input an image to resize
    size:
        if size is an integer, shape of resized image  will be [size, size, 3]. if length of size is 2.
        shape of resized image  will be [height, width, 3].
    method:
        An image.ResizeMethod, or string equivalent. Defaults to bilinear.
    preserve_aspect_ratio:
        Whether to preserve the aspect ratio.
    antialias:
        Whether to use an anti-aliasing filter when downsampling an image.
    Returns:
        an resized image
    -------
    '''
    DE_PY_INTER_MODE = {
        'nearest': Image.NEAREST,
        'bilinear': Image.BILINEAR,
        'cubic': Image.CUBIC,
        'lanczos': Image.LANCZOS,
        'bicubic': Image.BICUBIC
    }
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))
    if isinstance(size, int):
        size = (size, size)
    elif isinstance(size, (tuple, list)) or len(size) == 2:
        target_height, target_width = size
        size = (target_width, target_height)
    else:
        raise ValueError("Size should be a single integer or a list/tuple (h, w) of length 2.")
    if method not in ('nearest', 'bilinear', 'cubic', 'lanczos', 'bicubic'):
        raise TypeError('Unknown resize method! resize method must be in (nearest bilinear cubic lanczos bicubic)')

    if preserve_aspect_ratio:
        width, height = image.size
        target_width, target_height = size
        scale_factor_height = float(target_height / height)
        scale_factor_width = float(target_width / width)
        scale_factor = np.minimum(scale_factor_height, scale_factor_width)
        new_target_height = int(scale_factor * height)
        new_target_width = int(scale_factor * width)
        size = (new_target_width, new_target_height)
    interpolation = DE_PY_INTER_MODE[method]
    image = image.resize(size, interpolation)
    if antialias:
        image = image.resize(size, Image.ANTIALIAS)

    return ToTensor(image)


def CropAndResize(image, boxes, box_indices, crop_size, method='bilinear', extrapolation_value=0, is_hwc=True):
    '''

    Parameters
    ----------
    image:
        A 4-D tensor of shape [batch, image_height, image_width, depth]. Both image_height and image_width need to be positive.
    boxes:
        A 2-D tensor of shape [num_boxes, 4].
    box_indices:
        A 1-D tensor of shape [num_boxes] with int32 values in [0,batch).
        The value of box_ind[i] specifies the image that the i-th box refers to.
    crop_size:
        A 1-D tensor of 2 elements, size = [crop_height, crop_width]. All cropped image patches are resized to this size.
        The aspect ratio of the image content is not preserved. Both crop_height and crop_width need to be positive.
    method:
        An optional string specifying the sampling method for resizing.
        It can be either "bilinear" or "nearest" and default to "bilinear".
    extrapolation_value:
        An optional float. Defaults to 0. Value used for extrapolation, when applicable.
    Returns:
        A 4-D tensor of shape [num_boxes, crop_height, crop_width, depth].
    -------

    '''
    if method not in ["bilinear", "nearest"]:
        raise ValueError('method must be bilinear or nearest.')
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    boxes = np.asarray(boxes)
    box_indices = np.asarray(box_indices)
    image_shape = image.shape
    if len(image_shape) == 4:
        batch_size = image_shape[0]
    elif len(image_shape) == 3:
        image = np.expand_dims(image, axis=0)
    else:
        raise ValueError('Input must be a 3-D or 4-D  image Tensor.')

    box_num = boxes.shape[0]  # boxes.shape is [n,4]. n is the number of boxes.
    if not is_hwc:  # 判断通道顺序,为了便于后续计算，将通道顺序调整为HWC or BHWC
        image = np.transpose(image, (0, 2, 3, 1))
    batch_size, height, width, channels = image.shape
    return_image = np.zeros((box_num, crop_size[0], crop_size[1], 3))
    for i in range(box_num):
        y1, x1, y2, x2 = boxes[i]  # 首先判断图像是否需要翻转 ， 若y1>y2 需要垂直翻转， 若x1>x2 需要水平翻转
        cur_image = image[box_indices[i]]
        if y1 > y2:
            cur_image = FlipVertical(cur_image)
            y1, y2 = y2, y1
        if x1 > x2:
            cur_image = FlipHorizontal(cur_image)
            x1, x2 = x2, x1
        top_padding = 0 if y1 > 0 else int(round(height * (-y1)))
        left_padding = 0 if x1 > 0 else int(round(width * (-x1)))
        bottom_padding = 0 if y2 < 1 else int(round(height * (y2 - 1)))
        right_padding = 0 if x2 < 1 else int(round(width * (x2 - 1)))
        # 判断是否需要padding
        target_height = top_padding + height + bottom_padding
        target_width = left_padding + width + right_padding
        if target_height != height or target_width != width:
            cur_image = PadToBoundingbox(
                cur_image, offset_height=top_padding, offset_width=left_padding, target_height=target_height,
                target_width=target_width, padding_value=extrapolation_value, is_hwc=is_hwc
            )
        offset_height = 0 if y1 < 0 else int(round(height * y1))
        offset_width = 0 if x1 < 0 else int(round(width * x1))
        target_height = int(round(height * (y2 - y1)))
        target_width = int(round(width * (x2 - x1)))
        crop_image = Crop(cur_image, offset_height, offset_width, target_height, target_width, is_hwc)
        resized_image = Resize(crop_image, crop_size, method=method)
        return_image[i] = resized_image
    if not is_hwc:
        return_image = np.transpose(return_image, (0, 3, 1, 2))
    return ToTensor(return_image)


def CropOrPad(image, target_height, target_width, is_hwc=True):
    '''
    Resizes an image to a target width and height by either centrally cropping the image or padding it evenly with zeros.
    Parameters
    ----------
    image:
        3-D Tensor of shape [height, width, channels].
    target_height:
        Target height.
    target_width:
        Target width.
    Returns:
        Cropped and/or padded image.
    -------
    '''

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    shape_size = len(image.shape)
    if not shape_size in (3, 4):
        raise TypeError(
            'img shape should be (H, W, C)/(N, H, W, C)/(C, H, W)/(N, C, H, W). \
                             Got {}'.format(image.shape)
        )
    if target_height < 0:
        raise ValueError('target_height must be >0.')
    if target_width < 0:
        raise ValueError('target_width must be >0.')
    if shape_size == 3:
        if is_hwc:
            height, width, channels = image.shape
        else:
            channels, height, width = image.shape
    else:
        if is_hwc:
            batch, height, width, channels = image.shape
        else:
            batch, channels, height, width = image.shape
    offset_height = height - target_height
    offset_width = width - target_width
    offset_crop_height = max(offset_height // 2, 0)
    offset_crop_width = max(offset_width // 2, 0)
    offset_pad_height = max(-offset_height // 2, 0)
    offset_pad_width = max(-offset_width // 2, 0)
    cropped = Crop(
        image, offset_crop_height, offset_crop_width, min(height, target_height), min(width, target_width), is_hwc
    )

    padded = PadToBoundingbox(cropped, offset_pad_height, offset_pad_width, target_height, target_width, is_hwc=is_hwc)

    return ToTensor(padded)


def ResizeAndPad(image, target_height, target_width, method='bilinear', antialias=False, is_hwc=True):
    '''

    Parameters
    ----------
    image:
        4-D Tensor of shape [batch, height, width, channels] or 3-D Tensor of shape [height, width, channels].
    target_height:
        Target height.
    target_width:
        Target height.
    is_hwc:
         The flag of image shape, (H, W, C) or (N, H, W, C) if True and (C, H, W) or (N, C, H, W) if False (default=True).
    Returns:
        Resized and padded image. If images was 4-D, a 4-D float Tensor of shape [batch, new_height, new_width, channels].
        If images was 3-D, a 3-D float Tensor of shape [new_height, new_width, channels].
    -------

    '''
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    shape_size = len(image.shape)
    if not shape_size in (3, 4):
        raise TypeError(
            'img shape should be (H, W, C)/(N, H, W, C)/(C, H, W)/(N, C, H, W). \
                             Got {}'.format(image.shape)
        )
    if target_height < 0:
        raise ValueError('target_height must be >0.')
    if target_width < 0:
        raise ValueError('target_width must be >0.')
    if shape_size == 3:
        if is_hwc:
            height, width, channels = image.shape
        else:
            channels, height, width = image.shape
    else:
        if is_hwc:
            batch, height, width, channels = image.shape
        else:
            batch, channels, height, width = image.shape
    height = float(height)
    width = float(width)
    ratio = max(height / target_height, width / target_width)
    resized_height = int(round(height / ratio))
    resized_width = int(round(width / ratio))
    padding_height = max(0, int(round((target_height - resized_height) / 2)))
    padding_width = max(0, int(round((target_width - resized_width) / 2)))
    resized = Resize(
        image, size=(resized_height, resized_width), method=method, antialias=antialias
    )  #需要解决 batch images的resize
    padded = PadToBoundingbox(resized, padding_height, padding_width, target_height, target_width, is_hwc=is_hwc)
    return ToTensor(padded)


def rgb_to_hsv(np_rgb_img, is_hwc):
    """
    Convert RGB img to HSV img.

    Args:
        np_rgb_img (numpy.ndarray): NumPy RGB image array of shape (H, W, C) or (C, H, W) to be converted.
        is_hwc (Bool): If True, the shape of np_hsv_img is (H, W, C), otherwise must be (C, H, W).

    Returns:
        np_hsv_img (numpy.ndarray), NumPy HSV image with same type of np_rgb_img.
    """
    if is_hwc:
        r, g, b = np_rgb_img[:, :, 0], np_rgb_img[:, :, 1], np_rgb_img[:, :, 2]
    else:
        r, g, b = np_rgb_img[0, :, :], np_rgb_img[1, :, :], np_rgb_img[2, :, :]
    to_hsv = np.vectorize(colorsys.rgb_to_hsv)
    h, s, v = to_hsv(r, g, b)
    if is_hwc:
        axis = 2
    else:
        axis = 0
    np_hsv_img = np.stack((h, s, v), axis=axis)
    return np_hsv_img


def RgbToHsv(image, is_hwc=True):

    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))

    shape_size = len(image.shape)

    if not shape_size in (3, 4):
        raise TypeError(
            'img shape should be (H, W, C)/(N, H, W, C)/(C ,H, W)/(N, C, H, W). \
                         Got {}'.format(image.shape)
        )

    if shape_size == 3:
        batch_size = 0
        if is_hwc:
            num_channels = image.shape[2]
        else:
            num_channels = image.shape[0]
    else:
        batch_size = image.shape[0]
        if is_hwc:
            num_channels = image.shape[3]
        else:
            num_channels = image.shape[1]

    if num_channels != 3:
        raise TypeError('img should be 3 channels RGB img. Got {} channels'.format(num_channels))
    if batch_size == 0:
        return ToTensor(rgb_to_hsv(image, is_hwc))
    return ToTensor([rgb_to_hsv(img, is_hwc) for img in image])


def Transpose(image, order):
    """
        Transpose the input image with order
    """
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))
    if len(image.shape) == 3:
        if len(order) != 3:
            raise ValueError('if image is 3-D tensor, order should be a list/tuple with length of 3')
        return ToTensor(np.transpose(image, order))
    elif len(image.shape) == 4:
        if len(order) != 3:
            raise ValueError('if image is 3-D tensor, order should be a list/tuple with length of 3')
        return ToTensor(np.transpose(image, order))
    else:
        raise ValueError('\'image\' must have either 3 or 4 dimensions.')


def RandomRotation(
    image, degrees, fill_mode='nearest', fill_value=0, center=None, expand=False, is_hwc=True, interpolation_order=1
):
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))

    if isinstance(degrees, numbers.Number):
        if degrees < 0:
            raise ValueError("If degrees is a single number, it cannot be negative.")
        degrees = (-degrees, degrees)
    elif isinstance(degrees, (list, tuple)):
        if len(degrees) != 2:
            raise ValueError("If degrees is a sequence, the length must be 2.")
    else:
        raise TypeError("Degrees must be a single non-negative number or a sequence")

    DE_PY_INTER_MODE = {
        'nearest': Image.NEAREST,
        'bilinear': Image.BILINEAR,
        'antialias': Image.ANTIALIAS,
        'bicubic': Image.BICUBIC
    }
    if fill_mode not in ('nearest', 'bilinear', 'antialias', 'bicubic'):
        raise TypeError('Fill_mode must be in (nearest,bilinear, antialias,bicubic)')

    if isinstance(fill_value, int):
        fill_value = tuple([fill_value] * 3)

    angle = random.uniform(degrees[0], degrees[1])
    fill_mode = DE_PY_INTER_MODE[fill_mode]
    return ToTensor(image.rotate(angle, fill_mode, expand, center, fillcolor=fill_value))


def RandomShift(image, shift, fill_mode='nearest', fill_value=0, is_hwc=True, interpolation_order=1):
    '''

    Parameters
    ----------
    image
        Input tensor. Must be 3D.
    shift:
        int or list/tuple, if shift is int, Width shift range will equal to height shift range.
        if shift is list/tuple,  shift range will be [width fraction, height fraction]
    is_hwc:
        The flag of image shape, (H, W, C) or (N, H, W, C) if True and (C, H, W) or (N, C, H, W) if False (default=True).
    fill_mode:
        Points outside the boundaries of the input are filled according to the given mode (one of {'constant', 'nearest', 'reflect', 'wrap'}).
    fill_value:
        Value used for points outside the boundaries of the input if mode='constant'.
    interpolation_order
        int, order of spline interpolation. see ndimage.interpolation.affine_transform
    Returns
        Shifted Numpy image tensor.
    -------

    '''
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))

    if isinstance(shift, numbers.Number):
        width_fraction = shift
        height_fraction = shift
    elif isinstance(shift, list) or isinstance(shift, tuple):
        if len(shift) == 2:
            width_fraction = shift[0]
            height_fraction = shift[1]
    else:
        raise ValueError('shift must be int or list/tuple of length 2')

    DE_PY_INTER_MODE = {'nearest': Image.NEAREST, 'bilinear': Image.BILINEAR, 'bicubic': Image.BICUBIC}
    if fill_mode not in ('nearest', 'bilinear', 'bicubic'):
        raise TypeError('Fill_mode must be in (nearest,bilinear,bicubic)')
    fill_mode = DE_PY_INTER_MODE[fill_mode]
    width, height = image.size
    max_dx = width_fraction * width
    max_dy = height_fraction * height
    translations = (np.round(random.uniform(-max_dx, max_dx)), np.round(random.uniform(-max_dy, max_dy)))

    scale = 1.0
    shear = 0.0
    output_size = image.size
    center = (width * 0.5 + 0.5, height * 0.5 + 0.5)

    angle = math.radians(0)
    shear = math.radians(shear)
    shear = [shear, 0]
    scale = 1.0 / scale
    d = math.cos(angle + shear[0]) * math.cos(angle + shear[1]) + \
        math.sin(angle + shear[0]) * math.sin(angle + shear[1])
    matrix = [
        math.cos(angle + shear[0]),
        math.sin(angle + shear[0]), 0, -math.sin(angle + shear[1]),
        math.cos(angle + shear[1]), 0
    ]
    matrix = [scale / d * m for m in matrix]
    matrix[2] += matrix[0] * (-center[0] - translations[0]) + matrix[1] * (-center[1] - translations[1])
    matrix[5] += matrix[3] * (-center[0] - translations[0]) + matrix[4] * (-center[1] - translations[1])

    # Apply center translation: C * RSS^-1 * C^-1 * T^-1
    matrix[2] += center[0]
    matrix[5] += center[1]

    if __version__ >= '5':
        kwargs = {"fillcolor": fill_value}
    else:
        kwargs = {}
    return ToTensor(image.transform(output_size, Image.AFFINE, matrix, fill_mode, **kwargs))


def RandomShear(image, degree, fill_mode='nearest', fill_value=0, is_hwc=True, interpolation_order=1):
    '''

    Parameters
    ----------
    image
        Input tensor. Must be 3D.
    shift:
        int or list/tuple, if shift is int, Width shift range will equal to height shift range.
        if shift is list/tuple,  shift range will be [width fraction, height fraction]
    is_hwc:
        The flag of image shape, (H, W, C) or (N, H, W, C) if True and (C, H, W) or (N, C, H, W) if False (default=True).
    fill_mode:
        Points outside the boundaries of the input are filled according to the given mode (one of {'constant', 'nearest', 'reflect', 'wrap'}).
    fill_value:
        Value used for points outside the boundaries of the input if mode='constant'.
    interpolation_order
        int, order of spline interpolation. see ndimage.interpolation.affine_transform
    Returns
        Shifted Numpy image tensor.
    -------

    '''
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))
    DE_PY_INTER_MODE = {'nearest': Image.NEAREST, 'bilinear': Image.BILINEAR, 'bicubic': Image.BICUBIC}
    if fill_mode not in ('nearest', 'bilinear', 'bicubic'):
        raise TypeError('Fill_mode must be in (nearest,bilinear,bicubic)')
    fill_mode = DE_PY_INTER_MODE[fill_mode]
    width, height = image.size
    translations = (0, 0)
    scale = 1.0
    shear = degree
    output_size = image.size
    center = (width * 0.5 + 0.5, height * 0.5 + 0.5)
    angle = math.radians(0)

    if shear is not None:
        if isinstance(shear, numbers.Number):
            shear = (-1 * shear, shear)
            shear = [random.uniform(shear[0], shear[1]), random.uniform(shear[0], shear[1])]
        elif len(shear) == 2 or len(shear) == 4:
            if len(shear) == 2:
                shear = [shear[0], shear[1], shear[0], shear[1]]
            elif len(shear) == 4:
                shear = [s for s in shear]
            shear = [random.uniform(shear[0], shear[1]), random.uniform(shear[2], shear[3])]
        else:
            raise ValueError(
                "Shear should be a single value or a tuple/list containing " + "two values. Got {}".format(shear)
            )
        shear = [math.radians(s) for s in shear]
    else:
        shear = [0, 0]


    d = math.cos(angle + shear[0]) * math.cos(angle + shear[1]) + \
        math.sin(angle + shear[0]) * math.sin(angle + shear[1])
    matrix = [
        math.cos(angle + shear[0]),
        math.sin(angle + shear[0]), 0, -math.sin(angle + shear[1]),
        math.cos(angle + shear[1]), 0
    ]
    matrix = [scale / d * m for m in matrix]
    matrix[2] += matrix[0] * (-center[0] - translations[0]) + matrix[1] * (-center[1] - translations[1])
    matrix[5] += matrix[3] * (-center[0] - translations[0]) + matrix[4] * (-center[1] - translations[1])

    # Apply center translation: C * RSS^-1 * C^-1 * T^-1
    matrix[2] += center[0]
    matrix[5] += center[1]

    if __version__ >= '5':
        kwargs = {"fillcolor": fill_value}
    else:
        kwargs = {}
    return ToTensor(image.transform(output_size, Image.AFFINE, matrix, fill_mode, **kwargs))


def RandomZoom(image, zoom_range, fill_mode='nearest', fill_value=0, is_hwc=True, interpolation_order=1):
    '''

    Parameters
    ----------
    image:
         Input tensor. Must be 3D.
    zoom_range:
        Tuple of floats; zoom range for width and height.
    is_hwc:
        The flag of image shape, (H, W, C) or (N, H, W, C) if True and (C, H, W) or (N, C, H, W) if False (default=True).
    fill_mode:
        Points outside the boundaries of the input are filled according to the given mode (one of {'constant', 'nearest', 'reflect', 'wrap'}).
    fill_value:
        Value used for points outside the boundaries of the input if mode='constant'.
    interpolation_order:
        int, order of spline interpolation. see ndimage.interpolation.affine_transform

    Returns
        Zoomed Numpy image tensor.
    -------

    '''
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, np.ndarray):
        image = ToPIL(image)
    if not isinstance(image, Image.Image):
        raise TypeError(augment_error_message.format(type(image)))
    DE_PY_INTER_MODE = {'nearest': Image.NEAREST, 'bilinear': Image.BILINEAR, 'bicubic': Image.BICUBIC}
    if isinstance(zoom_range, list) or isinstance(zoom_range, tuple):
        if len(zoom_range) == 2:
            scale = random.uniform(zoom_range[0], zoom_range[1])
        else:
            raise ValueError('The length of zoom_range must be 2')
    else:
        raise ValueError(
            "Zoom_range should be a single value or a tuple/list containing " + "two values. Got {}".format(zoom_range)
        )
    if fill_mode not in ('nearest', 'bilinear', 'bicubic'):
        raise TypeError('Fill_mode must be in (nearest,bilinear,bicubic)')
    fill_mode = DE_PY_INTER_MODE[fill_mode]
    width, height = image.size
    translations = (0, 0)
    shear = (0, 0)
    output_size = image.size
    center = (width * 0.5 + 0.5, height * 0.5 + 0.5)
    angle = math.radians(0)

    d = math.cos(angle + shear[0]) * math.cos(angle + shear[1]) + \
        math.sin(angle + shear[0]) * math.sin(angle + shear[1])
    matrix = [
        math.cos(angle + shear[0]),
        math.sin(angle + shear[0]), 0, -math.sin(angle + shear[1]),
        math.cos(angle + shear[1]), 0
    ]
    matrix = [scale / d * m for m in matrix]
    matrix[2] += matrix[0] * (-center[0] - translations[0]) + matrix[1] * (-center[1] - translations[1])
    matrix[5] += matrix[3] * (-center[0] - translations[0]) + matrix[4] * (-center[1] - translations[1])

    # Apply center translation: C * RSS^-1 * C^-1 * T^-1
    matrix[2] += center[0]
    matrix[5] += center[1]

    if __version__ >= '5':
        kwargs = {"fillcolor": fill_value}
    else:
        kwargs = {}
    return ToTensor(image.transform(output_size, Image.AFFINE, matrix, fill_mode, **kwargs))


def Rescale(image, scale, offset=0):
    '''

    Parameters
    ----------
    image:
        3-D image or 4-D images
    scale:
        Float, the scale to apply to the inputs.
    offset:
        Float, the offset to apply to the inputs.
    Returns:
        rescaled images
    -------
    '''
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))

    return ToTensor(image * scale + offset)


def RandomFlipVertical(image, prob=0.5):

    if prob > random.random():
        image = FlipVertical(image)
    return image


def RandomFlipHorizontal(image, prob=0.5):

    if prob > random.random():
        image = FlipHorizontal(image)
    return image


def HWC2CHW(image):
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))

    image_shape = image.shape
    if (len(image_shape) == 3):
        return Transpose(image, (2, 0, 1))
    elif (len(image_shape) == 4):
        return Transpose(image, (0, 3, 1, 2))
    else:
        raise ValueError('\'image\' must have either 3 or 4 dimensions.')


def CHW2HWC(image):
    if not isinstance(image, np.ndarray) and not isinstance(image, Image.Image):
        image = Decode(image)
    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
        image = ToTensor(image)
    if not isinstance(image, np.ndarray):
        raise TypeError('img should be NumPy image. Got {}'.format(type(image)))

    image_shape = image.shape
    if (len(image_shape) == 3):
        return Transpose(image, (1, 2, 0))
    elif (len(image_shape) == 4):
        return Transpose(image, (0, 2, 3, 1))
    else:
        raise ValueError('\'image\' must have either 3 or 4 dimensions.')