o ॵiQ@sLddlZddlZddlZddlZddlZddlZddlZejej ej ej dZ ej ejejejejdZddeDZddZdd Zd d Zd d ZejfddZd)ddZddZddZejfddZddZGdddeZ GdddeZ!Gdd d eZ"Gd!d"d"eZ#Gd#d$d$eZ$Gd%d&d&eZ%Gd'd(d(eZ&dS)*Nconstantedgereflect symmetric)nearestbilinearareabicubiclanczoscCsi|]\}}||qSr ).0kvr r ^/home/ubuntu/.local/lib/python3.10/site-packages/modelscope/preprocessors/cv/cv2_transforms.py srcCst|o |dkS)N)torch is_tensor ndimensionimgr r r_is_tensor_image"rcCst|tjo |jdvS)N>r) isinstancenpndarrayndimrr r r_is_numpy_image&rrcCsTt|s tdt|t|d}t|tjs!|j tj kr(| dS|S)zConvert a ``PIL Image`` or ``numpy.ndarray`` to tensor. See ``ToTensor`` for more details. Args: pic (PIL Image or numpy.ndarray): Image to be converted to tensor. Returns: Tensor: Converted image. zpic should be ndarray. Got {})rr) r TypeErrorformattyper from_numpy transposer ByteTensordtypeuint8floatdiv)picrr r r to_tensor*s r-cCs<t|stdt|||D] \}}}|||q|S)aNormalize a tensor image with mean and standard deviation. .. note:: This transform acts in-place, i.e., it mutates the input tensor. See :class:`~torchvision.transforms.Normalize` for more details. Args: tensor (Tensor): Tensor image of size (C, H, W) to be normalized. mean (sequence): Sequence of means for each channel. std (sequence): Sequence of standard deviations for each channely. Returns: Tensor: Normalized Tensor image. ztensor is not a torch image.)rr"zipsub_div_)tensormeanstdtmsr r r normalize>s  r7cCst|s tdt|t|ts&t|tjjrt |dks&td||j d|j d}}t|trb||kr>||ksF||krH||krH|S||krW|}t|||}n|}t|||}n |d|d}}t j |||f|d}|j ddkr|ddddt jfS|S)aResize the input numpy ndarray to the given size. Args: img (numpy ndarray): 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 (int, optional): Desired interpolation. Default is ``cv2.INTER_LINEAR`` Returns: PIL Image: Resized image. !img should be numpy image. Got {}rzGot inappropriate size arg: {}rr )dsize interpolationN)rr"r#r$rint collectionsabcIterablelenshapecv2resizernewaxis)rsizer:hwowohoutputr r rrBSs*     rBrc Cszt|s tdt|t|tjttfstdt|tjt tfs'tdt|t s0tdt|t j rGt |dvrGt ddt ||dvsOJd t|tr\|}}}}t|t j rtt |d krt|d }}|d }}t|t j rt |d kr|d }|d }|d }|d}|jd d krtj|||||t||dddddtjfStj|||||t||dS)aPad the given numpy ndarray on all sides with specified padding mode and fill value. Args: img (numpy ndarray): image to be padded. padding (int or tuple): Padding on each border. If a single int is provided this is used to pad all borders. If tuple of length 2 is provided this is the padding on left/right and top/bottom respectively. If a tuple of length 4 is provided this is the padding for the left, top, right and bottom borders respectively. fill: Pixel fill value for constant fill. Default is 0. 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 padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default is 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: Numpy image: padded image. z#img should be numpy ndarray. Got {}zGot inappropriate padding argzGot inappropriate fill argz"Got inappropriate padding_mode arg)rz9Padding must be an int or a 2, or 4 element tuple, not a z{} element tuplerzBPadding mode should be either constant, edge, reflect or symmetricrrr rJr)topbottomleftright borderTypevalueN)rr"r#r$rnumbersNumbertupleliststrr<Sequencer? ValueErrorr;r@rAcopyMakeBorder_cv2_pad_to_strrrC)rpaddingfill padding_modepad_left pad_rightpad_top pad_bottomr r rpadzsj        racCs<t|s tdt||||||||ddfS)a!Crop the given PIL Image. Args: img (numpy ndarray): Image to be cropped. i: Upper pixel coordinate. j: Left pixel coordinate. h: Height of the cropped image. w: Width of the cropped image. Returns: numpy ndarray: Cropped image. r8N)rr"r#r$)rijrErFr r rcrops "rdcCsnt|tjrt|t|f}|jdd\}}|\}}tt||d}tt||d}t|||||S)Nrrg@)rrQrRr;r@roundrdr output_sizerErFthtwrbrcr r r center_crops rjcCs2t|sJdt|||||}t|||d}|S)aCCrop the given numpy ndarray and resize it to desired size. Notably used in :class:`~torchvision.transforms.RandomResizedCrop`. Args: img (numpy ndarray): Image to be cropped. i: Upper pixel coordinate. j: Left pixel coordinate. h: Height of the cropped image. w: Width of the cropped image. size (sequence or int): Desired output size. Same semantics as ``scale``. interpolation (int, optional): Desired interpolation. Default is ``cv2.INTER_CUBIC``. Returns: PIL Image: Cropped image. zimg should be numpy image)r:)rrdrB)rrbrcrErFrDr:r r r resized_cropsrkcCsTt|s tdt||jddkr$t|dddddtjfSt|dS)zHorizontally flip the given numpy ndarray. Args: img (numpy ndarray): image to be flipped. Returns: numpy ndarray: Horizontally flipped image. r8rr N) rr"r#r$r@rAfliprrCrr r rhflips   rmc@s eZdZdZddZddZdS)ToTensorzConvert a ``PIL Image`` or ``numpy.ndarray`` to tensor. Converts a PIL Image or numpy.ndarray (H x W x C) in the range [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0]. cCst|S)z Args: pic (PIL Image or numpy.ndarray): Image to be converted to tensor. Returns: Tensor: Converted image. )r-)selfr,r r r__call__szToTensor.__call__cCs |jjdS)Nz()) __class____name__ror r r__repr__s zToTensor.__repr__N)rr __module__ __qualname____doc__rprtr r r rrns rnc@(eZdZdZddZddZddZdS) NormalizeaNormalize a tensor image with mean and standard deviation. Given mean: ``(M1,...,Mn)`` and std: ``(S1,..,Sn)`` for ``n`` channels, this transform will normalize each channel of the input ``torch.*Tensor`` i.e. ``input[channel] = (input[channel] - mean[channel]) / std[channel]`` .. note:: This transform acts in-place, i.e., it mutates the input tensor. Args: mean (sequence): Sequence of means for each channel. std (sequence): Sequence of standard deviations for each channel. cCs||_||_dSN)r2r3)ror2r3r r r__init__!s zNormalize.__init__cCt||j|jS)z Args: tensor (Tensor): Tensor image of size (C, H, W) to be normalized. Returns: Tensor: Normalized Tensor image. )r7r2r3)ror1r r rrp%zNormalize.__call__cC|jjd|j|jS)Nz(mean={0}, std={1}))rqrrr#r2r3rsr r rrt. zNormalize.__repr__Nrrrurvrwr{rprtr r r rrys   ryc@s.eZdZdZejfddZddZddZdS) ResizeaResize the input numpy ndarray to the given size. Args: size (sequence or int): Desired output size. If size is a sequence like (h, w), output size will be matched to this. If size is an int, smaller edge of the image will be matched to this number. i.e, if height > width, then image will be rescaled to (size * height / width, size) interpolation (int, optional): Desired interpolation. Default is ``cv2.INTER_CUBIC``, bicubic interpolation cCs`t|tr ||_n"t|tjjr$t|dkr$t|tkr t |}||_nt d |||_ dS)NrzUnknown inputs for size: {}) rr;rDr<r=r>r?r$rTrSrWr#r:)rorDr:r r rr{?s   zResize.__init__cCr|)z Args: img (numpy ndarray): Image to be scaled. Returns: numpy ndarray: Rescaled image. )rBrDr:rorr r rrpKr}zResize.__call__cCs t|j}|jjd|j|S)Nz(size={0}, interpolation={1}))_cv2_interpolation_from_strr:rqrrr#rD)rointerpolate_strr r rrtTs  zResize.__repr__N) rrrurvrwrA INTER_LINEARr{rprtr r r rr3s   rc@rx) CenterCropzCrops the given numpy ndarray at the center. 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. cCs,t|tjrt|t|f|_dS||_dSrz)rrQrRr;rD)rorDr r rr{bs  zCenterCrop.__init__cCs t||jS) Args: img (numpy ndarray): Image to be cropped. Returns: numpy ndarray: Cropped image. )rjrDrr r rrphs zCenterCrop.__call__cC|jjd|jS)Nz (size={0}))rqrrr#rDrsr r rrtqzCenterCrop.__repr__Nrr r r rrZs  rc@s>eZdZdZ    dddZedd Zd d Zd d ZdS) RandomCropaCrop the given numpy ndarray at a random location. 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. padding (int or sequence, optional): Optional padding on each border of the image. Default is None, i.e no padding. If a sequence of length 4 is provided, it is used to pad left, top, right, bottom borders respectively. If a sequence of length 2 is provided, it is used to pad left/right, top/bottom borders, respectively. pad_if_needed (boolean): It will pad the image if smaller than the desired size to avoid raising an exception. fill: Pixel fill value for constant fill. Default is 0. 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 padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default is 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] NFrrcCsBt|tjrt|t|f|_n||_||_||_||_||_dSrz) rrQrRr;rDrZ pad_if_neededr[r\)rorDrZrr[r\r r rr{s  zRandomCrop.__init__cCsb|jdd\}}|\}}||kr||krdd||fStd||}td||}||||fS)a Get parameters for ``crop`` for a random crop. Args: img (numpy ndarray): Image to be cropped. output_size (tuple): Expected output size of the crop. Returns: tuple: params (i, j, h, w) to be passed to ``crop`` for random crop. rr)r@randomrandintrfr r r get_paramss   zRandomCrop.get_paramscCs|jdurt||j|j|j}|jr/|jd|jdkr/t||jd|jddf|j|j}|jrO|jd|jdkrOt|d|jd|jdf|j|j}|||j\}}}}t|||||S)rNr r) rZrar[r\rr@rDrrdrorrbrcrErFr r rrps zRandomCrop.__call__cCr~)Nz(size={0}, padding={1}))rqrrr#rDrZrsr r rrtrzRandomCrop.__repr__)NFrr) rrrurvrwr{ staticmethodrrprtr r r rrus   rc@s>eZdZdZddejfddZeddZdd Z d d Z d S) RandomResizedCropa>Crop the given numpy ndarray to random size and aspect ratio. A crop of random size (default: of 0.08 to 1.0) of the original size and a random aspect ratio (default: of 3/4 to 4/3) of the original aspect ratio is made. This crop is finally resized to given size. This is popularly used to train the Inception networks. Args: size: expected output size of each edge scale: range of size of the origin size cropped ratio: range of aspect ratio of the origin aspect ratio cropped interpolation: Default: cv2.INTER_CUBIC )g{Gz?g?)g?gUUUUUU?cCs ||f|_||_||_||_dSrz)rDr:scaleratio)rorDrrr:r r rr{s  zRandomResizedCrop.__init__c CstdD]e}|jd|jd}tj||}tj|}ttt||}ttt||}tdkr=||}}||jdkri||jdkritd|jd|} td|jd|} | | ||fSqt |jd|jd}|jd|d} |jd|d} | | ||fS)aGet parameters for ``crop`` for a random sized crop. Args: img (numpy ndarray): Image to be cropped. scale (tuple): range of size of the origin size cropped ratio (tuple): range of aspect ratio of the origin aspect ratio cropped Returns: tuple: params (i, j, h, w) to be passed to ``crop`` for a random sized crop. rr ?r) ranger@runiformr;remathsqrtrmin) rrrattemptr target_area aspect_ratiorFrErbrcr r rrs"     zRandomResizedCrop.get_paramscCs2|||j|j\}}}}t||||||j|jS)z Args: img (numpy ndarray): Image to be cropped and resized. Returns: numpy ndarray: Randomly cropped and resized image. )rrrrkrDr:rr r rrpszRandomResizedCrop.__call__cCslt|j}|jjd|j}|dtdd|jD7}|dtdd|jD7}|d|7}|S)Nz (size={0}z , scale={0}cs|]}t|dVqdSrJNre)r r6r r r z-RandomResizedCrop.__repr__..z , ratio={0}csrrr)r rr r rrrz, interpolation={0})) rr:rqrrr#rDrSrr)ror format_stringr r rrts zRandomResizedCrop.__repr__N) rrrurvrwrArr{rrrprtr r r rrs   rc@s*eZdZdZd ddZddZddZd S) RandomHorizontalFlipzHorizontally flip the given PIL Image randomly with a given probability. Args: p (float): probability of the image being flipped. Default value is 0.5 rcCs ||_dSrz)p)rorr r rr{ s zRandomHorizontalFlip.__init__cCst|jkr t|S|S)zrandom Args: img (numpy ndarray): Image to be flipped. Returns: numpy ndarray: Randomly flipped image. )rrrmrr r rrp#szRandomHorizontalFlip.__call__cCr)Nz(p={}))rqrrr#rrsr r rrt.rzRandomHorizontalFlip.__repr__N)rrr r r rrs   r)rr)'r<rrQrrAnumpyrrBORDER_CONSTANTBORDER_REPLICATEBORDER_REFLECT_101BORDER_REFLECTrY INTER_NEARESTr INTER_AREA INTER_CUBICINTER_LANCZOS4_cv2_interpolation_to_stritemsrrrr-r7rBrardrjrkrmobjectrnryrrrrrr r r rsL 'H 'XM