o
    Qe                     @   s`  d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dl	m
Z
 d dlmZmZmZ d dlZddlmZ ddlmZ ddlmZ g Zd	d
 Zdd Zdd Zd:ddZd;ddZd<ddZdd Zdd Zdd Zdd Z d d! Z!d"d# Z"d$d% Z#d&d' Z$d(d) Z%	*	 	d=d+d,Z&	*	-		 d>d.d/Z'd0d1 Z(d?d2d3Z)d@d4d5Z*dAd6d7Z+dBd8d9Z,dS )C    )divisionN)Image)sincostan   )functional_pil)functional_cv2)functional_tensorc                 C   s   t | tjS N)
isinstancer   img r   SD:\Projects\ConvertPro\env\Lib\site-packages\paddle/vision/transforms/functional.py_is_pil_image#      r   c                 C   s   t | tjS r   )r   paddleZTensorr   r   r   r   _is_tensor_image'   r   r   c                 C   s   t | tjo
| jdv S )N>         )r   npZndarrayndimr   r   r   r   _is_numpy_image+   s   r   CHWc                 C   sl   t | st| st| stdt| t | rt| |S t| r)t| |S |	 dkr1| S | 
dS )a  Converts a ``PIL.Image`` or ``numpy.ndarray`` to paddle.Tensor.

    See ``ToTensor`` for more details.

    Args:
        pic (PIL.Image|np.ndarray): Image to be converted to tensor.
        data_format (str, optional): Data format of output tensor, should be 'HWC' or 
            'CHW'. Default: 'CHW'.

    Returns:
        Tensor: Converted image. Data type is same as input img.

    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            tensor = F.to_tensor(fake_img)
            print(tensor.shape)

    zLpic should be PIL Image or Tensor Image or ndarray with dim=[2 or 3]. Got {}Zchw)r   r   r   )r   r   r   	TypeErrorformattypeF_pil	to_tensorF_cv2lowerZ	transpose)Zpicdata_formatr   r   r   r   /   s   
r   bilinearc                 C   sd   t | st| st| stdt| t | r t| ||S t| r+t| ||S t	| ||S )a  
    Resizes the image to given size

    Args:
        input (PIL.Image|np.ndarray): Image to be resized.
        size (int|list|tuple): Target size of input data, with (height, width) shape.
        interpolation (int|str, optional): Interpolation method. when use pil backend, 
            support method are as following: 
            - "nearest": Image.NEAREST, 
            - "bilinear": Image.BILINEAR, 
            - "bicubic": Image.BICUBIC, 
            - "box": Image.BOX, 
            - "lanczos": Image.LANCZOS, 
            - "hamming": Image.HAMMING
            when use cv2 backend, support method are as following: 
            - "nearest": cv2.INTER_NEAREST, 
            - "bilinear": cv2.INTER_LINEAR, 
            - "area": cv2.INTER_AREA, 
            - "bicubic": cv2.INTER_CUBIC, 
            - "lanczos": cv2.INTER_LANCZOS4

    Returns:
        PIL.Image or np.array: Resized image.

    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            converted_img = F.resize(fake_img, 224)
            print(converted_img.size)
            # (262, 224)

            converted_img = F.resize(fake_img, (200, 150))
            print(converted_img.size)
            # (150, 200)
    Limg should be PIL Image or Tensor Image or ndarray with dim=[2 or 3]. Got {})
r   r   r   r   r   r   r   resizeF_tr    )r   sizeinterpolationr   r   r   r%   Y   s   ,
r%   constantc                 C   sj   t | st| st| stdt| t | r!t| |||S t| r-t| |||S t	| |||S )aD  
    Pads the given PIL.Image or numpy.array on all sides with specified padding mode and fill value.

    Args:
        img (PIL.Image|np.array): Image to be padded.
        padding (int|list|tuple): Padding on each border. If a single int is provided this
            is used to pad all borders. If list/tuple of length 2 is provided this is the padding
            on left/right and top/bottom respectively. If a list/tuple of length 4 is provided
            this is the padding for the left, top, right and bottom borders
            respectively.
        fill (float, optional): Pixel fill value for constant fill. If a tuple of
            length 3, it is used to fill R, G, B channels respectively.
            This value is only used when the padding_mode is constant. Default: 0. 
        padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default: 'constant'.

            - constant: pads with a constant value, this value is specified with fill

            - edge: pads with the last value on the edge of the image

            - reflect: pads with reflection of image (without repeating the last value on the edge)

                       padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode
                       will result in [3, 2, 1, 2, 3, 4, 3, 2]

            - symmetric: pads with reflection of image (repeating the last value on the edge)

                         padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode
                         will result in [2, 1, 1, 2, 3, 4, 4, 3]

    Returns:
        PIL.Image or np.array: Padded image.

    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            padded_img = F.pad(fake_img, padding=1)
            print(padded_img.size)

            padded_img = F.pad(fake_img, padding=(2, 1))
            print(padded_img.size)
    r$   )
r   r   r   r   r   r   r   padr&   r    )r   paddingfillZpadding_moder   r   r   r*      s   2
r*   c                 C   sp   t | st| st| stdt| t | r"t| ||||S t| r/t| ||||S t	| ||||S )ac  Crops the given Image.

    Args:
        img (PIL.Image|np.array): Image to be cropped. (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:
        PIL.Image or np.array: Cropped image.

    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            cropped_img = F.crop(fake_img, 56, 150, 200, 100)
            print(cropped_img.size)

    r$   )
r   r   r   r   r   r   r   cropr&   r    )r   topleftheightwidthr   r   r   r-      s   
r-   c                 C   ^   t | st| st| stdt| t | rt| |S t| r)t| |S t	| |S )a  Crops the given Image and resize it to desired size.

        Args:
            img (PIL.Image|np.array): 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:
            PIL.Image or np.array: Cropped image.

        Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            cropped_img = F.center_crop(fake_img, (150, 100))
            print(cropped_img.size)
        r$   )
r   r   r   r   r   r   r   center_cropr&   r    )r   Zoutput_sizer   r   r   r3      s   
r3   c                 C   X   t | st| st| stdt| t | rt| S t| r't| S t	| S )a?  Horizontally flips the given Image or np.array.

    Args:
        img (PIL.Image|np.array): Image to be flipped.

    Returns:
        PIL.Image or np.array:  Horizontall flipped image.

    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            flpped_img = F.hflip(fake_img)
            print(flpped_img.size)

    r$   )
r   r   r   r   r   r   r   hflipr&   r    r   r   r   r   r5   %     



r5   c                 C   r4   )a<  Vertically flips the given Image or np.array.

    Args:
        img (PIL.Image|np.array): Image to be flipped.

    Returns:
        PIL.Image or np.array:  Vertically flipped image.

    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            flpped_img = F.vflip(fake_img)
            print(flpped_img.size)

    r$   )
r   r   r   r   r   r   r   vflipr&   r    r   r   r   r   r7   K  r6   r7   c                 C   ^   t | st| st| stdt| t | rt| |S t| r)t| |S t	| |S )a  Adjusts brightness of an Image.

    Args:
        img (PIL.Image|np.array|paddle.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:
        PIL.Image|np.array|paddle.Tensor: Brightness adjusted image.

    Examples:
        .. code-block:: python
           :name: code-example1

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)
            print(fake_img.size) # (300, 256)
            print(fake_img.load()[1,1]) # (95, 127, 202)
            converted_img = F.adjust_brightness(fake_img, 0.5)
            print(converted_img.size) # (300, 256)
            print(converted_img.load()[1,1]) # (47, 63, 101)


    r$   )
r   r   r   r   r   r   r   adjust_brightnessr    r&   )r   Zbrightness_factorr   r   r   r9   q  s   
r9   c                 C   r8   )a:  Adjusts contrast of an Image.

    Args:
        img (PIL.Image|np.array|paddle.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:
        PIL.Image|np.array|paddle.Tensor: Contrast adjusted image.

    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            converted_img = F.adjust_contrast(fake_img, 0.4)
            print(converted_img.size)
    r$   )
r   r   r   r   r   r   r   adjust_contrastr    r&   )r   Zcontrast_factorr   r   r   r:     s   
r:   c                 C   r8   )a>  Adjusts color saturation of an image.

    Args:
        img (PIL.Image|np.array|paddle.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:
        PIL.Image|np.array|paddle.Tensor: Saturation adjusted image.

    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            converted_img = F.adjust_saturation(fake_img, 0.4)
            print(converted_img.size)

    r$   )
r   r   r   r   r   r   r   adjust_saturationr    r&   )r   Zsaturation_factorr   r   r   r;        
r;   c                 C   r8   )a  Adjusts hue of an image.

    The image hue is adjusted by converting the image to HSV and
    cyclically shifting the intensities in the hue channel (H).
    The image is then converted back to original image mode.

    `hue_factor` is the amount of shift in H channel and must be in the
    interval `[-0.5, 0.5]`.

    Args:
        img (PIL.Image|np.array|paddle.Tensor): Image to be adjusted.
        hue_factor (float):  How much to shift the hue channel. Should be in
            [-0.5, 0.5]. 0.5 and -0.5 give complete reversal of hue channel in
            HSV space in positive and negative direction respectively.
            0 means no shift. Therefore, both -0.5 and 0.5 will give an image
            with complementary colors while 0 gives the original image.

    Returns:
        PIL.Image|np.array|paddle.Tensor: Hue adjusted image.

    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            converted_img = F.adjust_hue(fake_img, 0.4)
            print(converted_img.size)

    r$   )
r   r   r   r   r   r   r   
adjust_huer    r&   )r   Z
hue_factorr   r   r   r=     s   $
r=   c                    sl  t |}t |d }t |d }t || t | }t ||  t | t | t | }	t || t | }
t ||  t | t | t | }| \}}|\}}||	 d|
 |dg} fdd|D }|d  |d | |  |d | |   7  < |d  |d | |  |d	 | |   7  < |d  |7  < |d  |7  < |S )
Nr   r           c                    s   g | ]}|  qS r   r   ).0xscaler   r   
<listcomp>5      z&_get_affine_matrix.<locals>.<listcomp>r      r      )mathradiansr   r   r   )centerangle	translaterB   shearZrotsxZsyabcdcxcyZtxtymatrixr   rA   r   _get_affine_matrix!  s    
..00rV   nearestc              
   C   sV  t | st| st| stdt| t|ttfs tdt|t	t
fs+tdt|dkr5td|dkr=tdt|tjt	t
ffsKtdt|tsTtd	t|tr]t|}t|t
rft	|}t|tjrp|dg}t|t
ryt	|}t|d
kr|d |d g}t|dkrtd| |durt|t	t
fstdt | r| j\}}	|du r|d |	d g}t|||||}
t| |
||S t| r| jdd \}}	|du r|d |	d f}t| |||||||S t| r)ddg}|dur| jd | jd }	}dd t|||	gD }dd |D }t|||||}
t| |
||S dS )aT  Apply affine transformation on the image.

    Args:
        img (PIL.Image|np.array|paddle.Tensor): Image to be affined.
        angle (int|float): The angle of the random rotation in clockwise order.
        translate (list[float]): Maximum absolute fraction for horizontal and vertical translations.
        scale (float): Scale factor for the image, scale should be positive.
        shear (list[float]): Shear angle values which are parallel to the x-axis and y-axis in clockwise order.
        interpolation (str, optional): Interpolation method. If omitted, or if the 
            image has only one channel, it is set to PIL.Image.NEAREST or cv2.INTER_NEAREST 
            according the backend. 
            When use pil backend, support method are as following: 
            - "nearest": Image.NEAREST, 
            - "bilinear": Image.BILINEAR, 
            - "bicubic": Image.BICUBIC
            When use cv2 backend, support method are as following: 
            - "nearest": cv2.INTER_NEAREST, 
            - "bilinear": cv2.INTER_LINEAR, 
            - "bicubic": cv2.INTER_CUBIC
        fill (int|list|tuple, optional): Pixel fill value for the area outside the transformed
            image. If given a number, the value is used for all bands respectively.
        center (2-tuple, optional): Optional center of rotation, (x, y).
            Origin is the upper left corner.
            Default is the center of the image.

    Returns:
        PIL.Image|np.array|paddle.Tensor: Affine Transformed image.

    Examples:
        .. code-block:: python

            import paddle
            from paddle.vision.transforms import functional as F

            fake_img = paddle.randn((3, 256, 300)).astype(paddle.float32)

            affined_img = F.affine(fake_img, 45, translate=[0.2, 0.2], scale=0.5, shear=[-10, 10])
            print(affined_img.shape)
    r$   z%Argument angle should be int or floatz'Argument translate should be a sequencer   z3Argument translate should be a sequence of length 2r>   z!Argument scale should be positivezAShear should be either a single value or a sequence of two valuesz)Argument interpolation should be a stringr   r   z6Shear should be a sequence containing two values. Got Nz$Argument center should be a sequence      ?c                 S   s    g | ]\}}d ||d   qS )      ?rX   r   )r?   rP   sr   r   r   rC     s    zaffine.<locals>.<listcomp>c                 S   s   g | ]}d | qS )r[   r   )r?   tr   r   r   rC     rD   )r   r   r   r   r   r   r   intfloatlisttuplelen
ValueErrornumbersNumberstrr'   rV   r   affineshaper    zipr&   )r   rJ   rK   rB   rL   r(   r,   rI   r1   r0   rU   Zcenter_fZtranslate_fr   r   r   rg   @  sz   0







rg   Fc                 C   s   t | st| st| stdt| t|trt|}t|tr't|}t | r5t	
| |||||S t| rCt
| |||||S t
| |||||S )aY  Rotates the image by angle.


    Args:
        img (PIL.Image|np.array): Image to be rotated.
        angle (float or int): In degrees degrees counter clockwise order.
        interpolation (str, optional): Interpolation method. If omitted, or if the 
            image has only one channel, it is set to PIL.Image.NEAREST or cv2.INTER_NEAREST 
            according the backend. when use pil backend, support method are as following: 
            - "nearest": Image.NEAREST, 
            - "bilinear": Image.BILINEAR, 
            - "bicubic": Image.BICUBIC
            when use cv2 backend, support method are as following: 
            - "nearest": cv2.INTER_NEAREST, 
            - "bilinear": cv2.INTER_LINEAR, 
            - "bicubic": cv2.INTER_CUBIC
        expand (bool, optional): Optional expansion flag.
            If true, expands the output image to make it large enough to hold the entire rotated image.
            If false or omitted, make the output image the same size as the input image.
            Note that the expand flag assumes rotation around the center and no translation.
        center (2-list|2-tuple, optional): Optional center of rotation.
            Origin is the upper left corner.
            Default is the center of the image.
        fill (3-list|3-tuple or int): RGB pixel fill value for area outside the rotated image.
            If int, it is used for all channels respectively.


    Returns:
        PIL.Image or np.array: Rotated image.

    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            rotated_img = F.rotate(fake_img, 90)
            print(rotated_img.size)

    r$   )r   r   r   r   r   r   r   r`   ra   r   rotater&   r    )r   rJ   r(   expandrI   r,   r   r   r   rj     s    3


rj   c           	      C   s   t dt|  df}tt|| D ]P\}\}}|d |d dddd|d  |d  |d  |d  g|d| ddf< ddd|d |d d|d  |d  |d  |d  g|d| d ddf< qt | dg}t j||d }t	|}|S )aJ  
    get coefficients (a, b, c, d, e, f, g, h) of the perspective transforms.

    In Perspective Transform each pixel (x, y) in the original image gets transformed as,
     (x, y) -> ( (ax + by + c) / (gx + hy + 1), (dx + ey + f) / (gx + hy + 1) )

    Args:
        startpoints (list[list[int]]): [top-left, top-right, bottom-right, bottom-left] of the original image,
        endpoints (list[list[int]]): [top-left, top-right, bottom-right, bottom-left] of the transformed image.

    Returns:
        output (list): octuple (a, b, c, d, e, f, g, h) for transforming each pixel.
    r      r   r   N)
r   Zzerosrb   	enumerateri   arrayZreshapeZlinalgZlstsqr`   )	startpoints	endpointsZa_matrixip1p2Zb_matrixresoutputr   r   r   _get_perspective_coeffs  s   44rv   c                 C   s   t | st| st| stdt| t | r&t||}t| |||S t| r7t||}t	| |||S t
| ||||S )aK  Perform perspective transform of the given image.

    Args:
        img (PIL.Image|np.array|paddle.Tensor): Image to be transformed.
        startpoints (list of list of ints): List containing four lists of two integers corresponding to four corners
            ``[top-left, top-right, bottom-right, bottom-left]`` of the original image.
        endpoints (list of list of ints): List containing four lists of two integers corresponding to four corners
            ``[top-left, top-right, bottom-right, bottom-left]`` of the transformed image.
        interpolation (str, optional): Interpolation method. If omitted, or if the 
            image has only one channel, it is set to PIL.Image.NEAREST or cv2.INTER_NEAREST 
            according the backend. 
            When use pil backend, support method are as following: 
            - "nearest": Image.NEAREST, 
            - "bilinear": Image.BILINEAR, 
            - "bicubic": Image.BICUBIC
            When use cv2 backend, support method are as following: 
            - "nearest": cv2.INTER_NEAREST, 
            - "bilinear": cv2.INTER_LINEAR, 
            - "bicubic": cv2.INTER_CUBIC
        fill (int|list|tuple, optional): Pixel fill value for the area outside the transformed
            image. If given a number, the value is used for all bands respectively.

    Returns:
        PIL.Image|np.array|paddle.Tensor: transformed Image.

    Examples:
        .. code-block:: python

            import paddle
            from paddle.vision.transforms import functional as F

            fake_img = paddle.randn((3, 256, 300)).astype(paddle.float32)

            startpoints = [[0, 0], [33, 0], [33, 25], [0, 25]]
            endpoints = [[3, 2], [32, 3], [30, 24], [2, 25]]

            perspectived_img = F.perspective(fake_img, startpoints, endpoints)
            print(perspectived_img.shape)

    r$   )r   r   r   r   r   r   rv   r   perspectiver&   r    )r   ro   rp   r(   r,   Zcoeffsr   r   r   rw   &  s    )


rw   c                 C   r2   )a  Converts image to grayscale version of image.

    Args:
        img (PIL.Image|np.array): Image to be converted to grayscale.

    Returns:
        PIL.Image or np.array: 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
    
    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            gray_img = F.to_grayscale(fake_img)
            print(gray_img.size)

    r$   )
r   r   r   r   r   r   r   to_grayscaler&   r    )r   Znum_output_channelsr   r   r   rx   `  r<   rx   c                 C   sD   t | rt| |||S t| rt| tj} t| ||||S )a  Normalizes a tensor or image with mean and standard deviation.

    Args:
        img (PIL.Image|np.array|paddle.Tensor): input data to be normalized.
        mean (list|tuple): Sequence of means for each channel.
        std (list|tuple): Sequence of standard deviations for each channel.
        data_format (str, optional): Data format of input img, should be 'HWC' or 
            'CHW'. Default: 'CHW'.
        to_rgb (bool, optional): Whether to convert to rgb. If input is tensor, 
            this option will be igored. Default: False.

    Returns:
        np.ndarray or Tensor: Normalized mage. Data format is same as input img.
    
    Examples:
        .. code-block:: python

            import numpy as np
            from PIL import Image
            from paddle.vision.transforms import functional as F

            fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')

            fake_img = Image.fromarray(fake_img)

            mean = [127.5, 127.5, 127.5]
            std = [127.5, 127.5, 127.5]

            normalized_img = F.normalize(fake_img, mean, std, data_format='HWC')
            print(normalized_img.max(), normalized_img.min())

    )	r   r&   	normalizer   r   rn   ZastypeZfloat32r    )r   meanZstdr"   Zto_rgbr   r   r   ry     s
   "ry   c              	   C   sX   t | rtj| ||||||dS t| r tj| ||||||dS tj| ||||||dS )a
  Erase the pixels of selected area in input image with given value.
    
        Args:
            img (paddle.Tensor | np.array | PIL.Image): input Tensor image. 
                 For Tensor input, the shape should be (C, H, W). For np.array input, 
                 the shape should be (H, W, C).
            i (int): y coordinate of the top-left point of erased region.
            j (int): x coordinate of the top-left point of erased region.
            h (int): Height of the erased region.
            w (int): Width of the erased region.
            v (paddle.Tensor | np.array): value used to replace the pixels in erased region. It 
                should be np.array when img is np.array or PIL.Image.
            inplace (bool, optional): Whether this transform is inplace. Default: False.

        Returns:
            paddle.Tensor | np.array | PIL.Image: Erased image. The type is same with input image.

        Examples:
            .. code-block:: python

                import paddle
                
                fake_img = paddle.randn((3, 2, 4)).astype(paddle.float32)
                print(fake_img)

                #Tensor(shape=[3, 2, 4], dtype=float32, place=Place(gpu:0), stop_gradient=True,
                #       [[[ 0.02169025, -0.97859967, -1.39175487, -1.07478464],
                #         [ 0.20654772,  1.74624777,  0.32268861, -0.13857445]],
                #
                #        [[-0.14993843,  1.10793507, -0.40056887, -1.94395220],
                #         [ 0.41686651,  0.44551995, -0.09356714, -0.60898107]],
                #
                #        [[-0.24998808, -1.47699273, -0.88838995,  0.42629015],
                #         [ 0.56948012, -0.96200180,  0.53355658,  3.20450878]]])

                values = paddle.zeros((1,1,1), dtype=paddle.float32)
                result = paddle.vision.transforms.erase(fake_img, 0, 1, 1, 2, values)
                
                print(result)

                #Tensor(shape=[3, 2, 4], dtype=float32, place=Place(gpu:0), stop_gradient=True,
                #       [[[ 0.02169025,  0.        ,  0.        , -1.07478464],
                #         [ 0.20654772,  1.74624777,  0.32268861, -0.13857445]],
                #
                #         [[-0.14993843,  0.        ,  0.        , -1.94395220],
                #           [ 0.41686651,  0.44551995, -0.09356714, -0.60898107]],
                #
                #         [[-0.24998808,  0.        ,  0.        ,  0.42629015],
                #          [ 0.56948012, -0.96200180,  0.53355658,  3.20450878]]])

    )inplace)r   r&   eraser   r   r    )r   rq   jhwvr{   r   r   r   r|     s
   4r|   )r   )r#   )r   r)   )rW   r   N)rW   FNr   )rW   r   )r   )r   F)F)-
__future__r   sysrG   rd   warningscollectionsnumpyr   ZPILr   r   r   r   r    r   r   r	   r    r
   r&   __all__r   r   r   r   r%   r*   r-   r3   r5   r7   r9   r:   r;   r=   rV   rg   rj   rv   rw   rx   ry   r|   r   r   r   r   <module>   sX   

*
:@+'&&-()2$
 
F

:
)+