gCzddlZddlZddlmZddlmZmZmZmZm Z m Z m Z ddl Z ddlZddlmZddlmZmZmZmZmZmZmZmZmZmZmZddlmZmZm Z m!Z!m"Z"m#Z#erddl$Z%ddl&Z%ej'ej'e%j(j)ej'dkr e%j*j+Z,ne%j*Z,erPdd l-m.Z.e,j/e.j/e,j0e.j0e,j1e.j1e,j2e.j2e,j3e.j3e,j4e.j4iZ5ererddl6Z6ej7e8Z9e d e j:d ed ee j:ed fZ;e ed d d ed ed eed eed eed fZ<GddeZ=GddeZ>GddeZ?ee@e eAe@eeffZBdZCGddeZDdZEdZFdZGdZHde j:deIfdZJdGdeAdee;fd ZKde j:fd!ZL dHde j:d"e e eAe eAd#ffde=fd$ZM dHde j:d%e e e=e@fdeAfd&ZNdHde j:d'e=de eAeAffd(ZOd)ee@e ee ffdeIfd*ZPd)ee@e ee ffdeIfd+ZQd,eee@e ee ffdeIfd-ZRd,eee@e ee ffdeIfd.ZSdHde e@d fd/e eTdd fd0ZU dId1e eId2e eTd3e eId4e e eTeeTfd5e e eTeeTfd6e eId7e eAd8e eId9e ee@eAfd:e eId;e ee@eAfdZVGd?d@ZWdAe>dBe e>d#fd,eeddfdCZXdDee@dEee@fdFZYdS)JN)BytesIO) TYPE_CHECKINGDictIterableListOptionalTupleUnion)version) ExplicitEnum is_jax_tensoris_numpy_array is_tf_tensoris_torch_availableis_torch_tensoris_torchvision_availableis_vision_availableloggingrequires_backendsto_numpy)IMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STDIMAGENET_STANDARD_MEANIMAGENET_STANDARD_STDOPENAI_CLIP_MEANOPENAI_CLIP_STDz9.1.0)InterpolationModezPIL.Image.Imagez torch.Tensorz np.ndarrayz np.ndarrrayceZdZdZdZdS)ChannelDimensionchannels_first channels_lastN)__name__ __module__ __qualname__FIRSTLASTT/var/www/html/ai-engine/env/lib/python3.11/site-packages/transformers/image_utils.pyr r _s E DDDr)r ceZdZdZdZdS)AnnotationFormatcoco_detection coco_panopticN)r#r$r%COCO_DETECTION COCO_PANOPTICr(r)r*r,r,ds%N#MMMr)r,c>eZdZejjZejjZdS)AnnotionFormatN)r#r$r%r,r/valuer0r(r)r*r2r2is$%4:N$28MMMr)r2c\tot|tjjSN)r isinstancePILImageimgs r* is_pil_imager;qs!  EZSY_%E%EEr)c"eZdZdZdZdZdZdZdS) ImageTypepillowtorchnumpy tensorflowjaxN)r#r$r%r7TORCHNUMPY TENSORFLOWJAXr(r)r*r=r=us' C E EJ CCCr)r=cNt|r tjSt|r tjSt |r tjSt|r tjSt|r tj Stdt|)NzUnrecognised image type ) r;r=r7rrCrrDrrErrF ValueErrortypeimages r*get_image_typerL}sE}ueE$##U} =U == > >>r)ct|p;t|p,t|pt|pt |Sr5)r;rrrrr9s r*is_valid_imagerNsG    vs 3 3 vs7K7K v|\_O`O` vdqrudvdvvr)ct|ttfr|D]}t|sdSnt |sdSdS)NFT)r6listtuple valid_imagesrN)imgsr:s r*rRrRsd$u &&  C$$ uu  D ! !u 4r)cht|ttfrt|dSdS)NrF)r6rPrQrNr9s r* is_batchedrUs/#e}%%&c!f%%% 5r)rKreturnc|jtjkrdStj|dkotj|dkS)zV Checks to see whether the pixel values have already been rescaled to [0, 1]. Frr )dtypenpuint8minmaxrJs r*is_scaled_imager]s? {bhu 6%==A  4"&--1"44r)expected_ndimsc ft|r|St|tjjr|gSt |rP|j|dzkrt |}n0|j|kr|g}n!td|dzd|d|jd|Stdt|d)a Ensure that the input is a list of images. If the input is a single image, it is converted to a list of length 1. If the input is a batch of images, it is converted to a list of images. Args: images (`ImageInput`): Image of images to turn into a list of images. expected_ndims (`int`, *optional*, defaults to 3): Expected number of dimensions for a single input image. If the input image has a different number of dimensions, an error is raised. r z%Invalid image shape. Expected either z or z dimensions, but got z dimensions.ztInvalid image type. Expected either PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray, but got .) rUr6r7r8rNndimrPrHrI)imagesr_s r*make_list_of_imagesrds& &#)/**xf  ;.1, , ,&\\FF [N * *XFF.8J..P^..K...   0 $V  0 0 0  r)ct|stdt|tr3t |t jjrtj|St|S)NzInvalid image type: ) rNrHrIrr6r7r8rYarrayrr9s r*to_numpy_arrayrgsl #  =;S ;;<<<C!A!Ax}} C==r) num_channels.c||nd}t|tr|fn|}|jdkrd\}}n(|jdkrd\}}ntd|j|j||vr>|j||vr/t d|jdtjS|j||vr tjS|j||vr tj Std ) a[ Infers the channel dimension format of `image`. Args: image (`np.ndarray`): The image to infer the channel dimension of. num_channels (`int` or `Tuple[int, ...]`, *optional*, defaults to `(1, 3)`): The number of channels of the image. Returns: The channel dimension of the image. Nr r^r^)rz(Unsupported number of image dimensions: z4The channel dimension is ambiguous. Got image shape z,. Assuming channels are the first dimension.z(Unable to infer channel dimension format) r6intrbrHshapeloggerwarningr r&r')rKrh first_dimlast_dims r*infer_channel_dimension_formatrss $0#;<<L&0s&C&CUL??L zQ" 88 q" 88PEJPPQQQ {9--%+h2G<2W2W |5; | | |    %% Y < / /%% X , . .$$ ? @ @@r)input_data_formatc|t|}|tjkr |jdz S|tjkr |jdz St d|)a Returns the channel dimension axis of the image. Args: image (`np.ndarray`): The image to get the channel dimension axis of. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the image. If `None`, will infer the channel dimension from the image. Returns: The channel dimension axis of the image. Nr^r Unsupported data format: )rsr r&rbr'rH)rKrts r*get_channel_dimension_axisrwsf :5AA,222zA~ .3 3 3zA~ D1BDD E EEr) channel_dimc|t|}|tjkr|jd|jdfS|tjkr|jd|jdfSt d|)a Returns the (height, width) dimensions of the image. Args: image (`np.ndarray`): The image to get the dimensions of. channel_dim (`ChannelDimension`, *optional*): Which dimension the channel dimension is in. If `None`, will infer the channel dimension from the image. Returns: A tuple of the image's height and width. Nrv)rsr r&rnr'rH)rKrxs r*get_image_sizer}sz4U;; &,,,{2 B// (- - -{2 B//B[BBCCCr) annotationct|trfd|vrbd|vr^t|dttfrWXY>Z\`3a3a /t 5r)ct|trjd|vrfd|vrbd|vr^t|dttfrz3valid_coco_detection_annotations..Qs+NN31#66NNNNNNr)allrs r* valid_coco_detection_annotationsrPs NN+NNN N NNr)c4td|DS)Nc34K|]}t|VdSr5)rrs r*rz2valid_coco_panoptic_annotations..Us+MM#055MMMMMMr)rrs r*valid_coco_panoptic_annotationsrTs MMMMM M MMr)timeoutcttdgt|tr[|ds|drGt jttj ||j }ntj |r t j|}n|dr|dd} t!j|}t jt|}nX#t&$r}t)d|d |d }~wwxYwt|t jjr|}nt+d t j|}|d }|S) a3 Loads `image` to a PIL Image. Args: image (`str` or `PIL.Image.Image`): The image to convert to the PIL Image format. timeout (`float`, *optional*): The timeout value in seconds for the URL request. Returns: `PIL.Image.Image`: A PIL Image. visionzhttp://zhttps://)rz data:image/,r zIncorrect image source. Must be a valid URL starting with `http://` or `https://`, a valid path to an image file, or a base64 encoded string. Got z. Failed with NzuIncorrect format used for image. Should be an url linking to an image, a base64 string, a local path, or a PIL image.RGB)r load_imager6str startswithr7r8openrrequestsgetcontentospathisfilesplitbase64 decodebytesencode ExceptionrH TypeErrorImageOpsexif_transposeconvert)rKrb64es r*rrXsj8*---%   I & & %*:*::*F*F INN78<w+O+O+O+W#X#XYYEE W^^E " " INN5))EE .. , C((+ (88 ws||44    BjoBB@BB  E39? + +  D    L ' ' . .E MM% E LsAE!! F+FF do_rescalerescale_factor do_normalize image_mean image_stddo_padsize_divisibilitydo_center_crop crop_size do_resizesizeresamplePILImageResamplingc |r|td|r|td|r||td|r|td| r| | tddSdS)a Checks validity of typically used arguments in an `ImageProcessor` `preprocess` method. Raises `ValueError` if arguments incompatibility is caught. Many incompatibilities are model-specific. `do_pad` sometimes needs `size_divisor`, sometimes `size_divisibility`, and sometimes `size`. New models and processors added should follow existing arguments when possible. Nz=`rescale_factor` must be specified if `do_rescale` is `True`.zzDepending on the model, `size_divisibility`, `size_divisor`, `pad_size` or `size` must be specified if `do_pad` is `True`.zP`image_mean` and `image_std` must both be specified if `do_normalize` is `True`.z<`crop_size` must be specified if `do_center_crop` is `True`.zA`size` and `resample` must be specified if `do_resize` is `True`.)rH) rrrrrrrrrrrrs r*validate_preprocess_argumentsrs,Zn,XYYY  #+ I   m+y/@klllY)+WXXX^dlh&6\]]]^^&6&6r)ceZdZdZdZddZdZdejde e e fdejfd Z dd Z d ZddZddZdZdZddZdS)ImageFeatureExtractionMixinzD Mixin that contain utilities for preparing image features. ct|tjjtjfs/t |s"t dt|ddSdS)Nz Got type zS which is not supported, only `PIL.Image.Image`, `np.array` and `torch.Tensor` are.)r6r7r8rYndarrayrrHrIselfrKs r*_ensure_format_supportedz4ImageFeatureExtractionMixin._ensure_format_supportedsq%#)/2:!>?? X]H^H^ &DKK&&&     r)Nc||t|r|}t|tjr|%t|jdtj}|jdkr&|j ddvr| ddd}|r|dz}| tj }tj|S|S)a" Converts `image` to a PIL Image. Optionally rescales it and puts the channel dimension back as the last axis if needed. Args: image (`PIL.Image.Image` or `numpy.ndarray` or `torch.Tensor`): The image to convert to the PIL Image format. rescale (`bool`, *optional*): Whether or not to apply the scaling factor (to make pixel values integers between 0 and 255). Will default to `True` if the image type is a floating type, `False` otherwise. Nrr^rjr rk)rrr@r6rYrflatfloatingrbrn transposeastyperZr7r8 fromarray)rrKrescales r* to_pil_imagez(ImageFeatureExtractionMixin.to_pil_images %%e,,, 5 ! ! "KKMME eRZ ( ( .$UZ]BK@@zQ5;q>V#;#;1a00 $ LL**E9&&u-- - r)c||t|tjjs|S|dS)z Converts `PIL.Image.Image` to RGB format. Args: image (`PIL.Image.Image`): The image to convert. r)rr6r7r8rrs r* convert_rgbz'ImageFeatureExtractionMixin.convert_rgbsE %%e,,,%11 L}}U###r)rKscalerVc6||||zS)z7 Rescale a numpy image by scale amount )r)rrKrs r*rz#ImageFeatureExtractionMixin.rescales" %%e,,,u}r)Tc||t|tjjrt j|}t |r|}|%t|jdtj n|}|r3| | tj d}|r"|j dkr|ddd}|S)a Converts `image` to a numpy array. Optionally rescales it and puts the channel dimension as the first dimension. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image to convert to a NumPy array. rescale (`bool`, *optional*): Whether or not to apply the scaling factor (to make pixel values floats between 0. and 1.). Will default to `True` if the image is a PIL Image or an array/tensor of integers, `False` otherwise. channel_first (`bool`, *optional*, defaults to `True`): Whether or not to permute the dimensions of the image to put the channel dimension first. Nrp?r^rkr )rr6r7r8rYrfrr@rintegerrrfloat32rbr)rrKr channel_firsts r*rgz*ImageFeatureExtractionMixin.to_numpy_arrays %%e,,, eSY_ - - $HUOOE 5 ! ! "KKMME;B?*UZ]BJ777PW  FLLbj!9!99EEE  -UZ1__OOAq!,,E r)c||t|tjjr|St |r|d}nt j|d}|S)z Expands 2-dimensional `image` to 3 dimensions. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image to expand. r)axis)rr6r7r8r unsqueezerY expand_dimsrs r*rz'ImageFeatureExtractionMixin.expand_dims sq %%e,,, eSY_ - - L 5 ! ! 2OOA&&EEN5q111E r)Fc||t|tjjr||d}n|rt|t jr4||t j d}n7t|r(|| d}t|t jrt|t js,t j ||j }t|t js,t j ||j }nt|rddl}t||js;t|t jr|j|}n|j|}t||js;t|t jr|j|}n|j|}|jdkr-|jddvr||ddddfz |ddddfz S||z |z S)a  Normalizes `image` with `mean` and `std`. Note that this will trigger a conversion of `image` to a NumPy array if it's a PIL Image. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image to normalize. mean (`List[float]` or `np.ndarray` or `torch.Tensor`): The mean (per channel) to use for normalization. std (`List[float]` or `np.ndarray` or `torch.Tensor`): The standard deviation (per channel) to use for normalization. rescale (`bool`, *optional*, defaults to `False`): Whether or not to rescale the image to be between 0 and 1. If a PIL image is provided, scaling will happen automatically. T)rrrNr^rj)rr6r7r8rgrYrrrrrfloatrfrXr?Tensor from_numpytensorrbrn)rrKmeanstdrr?s r* normalizez%ImageFeatureExtractionMixin.normalize!s6 %%e,,, eSY_ - - ?''t'<> eRZ ( ( ,dBJ// :x~~,,U[99c2:.. 8hsmm**5;77 U # # , LLLdEL11 .dBJ//.+5+D11DD'5<--Dc5<00 ,c2:..,*%*3//CC&%,s++C :??u{1~77DD$//3qqq$}3EE EDLC' 'r)c||n tj}||t|tjjs||}t|trt|}t|tst|dkr|r*t|tr||fn|d|df}n|j \}}||kr||fn||f\}} t|tr|n|d} || kr|S| t| | z|z } } |8|| krtd|d|| |krt|| z| z |} } ||kr| | fn| | f}| ||S)a Resizes `image`. Enforces conversion of input to PIL.Image. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image to resize. size (`int` or `Tuple[int, int]`): The size to use for resizing the image. If `size` is a sequence like (h, w), output size will be matched to this. If `size` is an int and `default_to_square` is `True`, then image will be resized to (size, size). If `size` is an int and `default_to_square` is `False`, then 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). resample (`int`, *optional*, defaults to `PILImageResampling.BILINEAR`): The filter to user for resampling. default_to_square (`bool`, *optional*, defaults to `True`): How to convert `size` when it is a single int. If set to `True`, the `size` will be converted to a square (`size`,`size`). If set to `False`, will replicate [`torchvision.transforms.Resize`](https://pytorch.org/vision/stable/transforms.html#torchvision.transforms.Resize) with support for resizing only the smallest edge and providing an optional `max_size`. max_size (`int`, *optional*, defaults to `None`): The maximum allowed for the longer edge of the resized image: if the longer edge of the image is greater than `max_size` after being resized according to `size`, then the image is resized again so that the longer edge is equal to `max_size`. As a result, `size` might be overruled, i.e the smaller edge may be shorter than `size`. Only used if `default_to_square` is `False`. Returns: image: A resized `PIL.Image.Image`. Nr rz max_size = zN must be strictly greater than the requested size for the smaller edge size = )r)rBILINEARrr6r7r8rrPrQrmrrrHresize) rrKrrdefault_to_squaremax_sizewidthheightshortlongrequested_new_short new_shortnew_longs r*rz"ImageFeatureExtractionMixin.resizeUs< (3889K9T %%e,,,%11 -%%e,,E dD ! ! ;;D dC  [CIINN  ['1$'<'<Td||47DQRGBT % v16&ufoovuo t.8s.C.C&Pdda#/// L&93?RUY?Y\a?a;b;b8 '#666(G(GG@DGG (**.1(Y2F2Q.R.RT\8 05 8,,hPYEZ||D8|444r)c^||t|ts||f}t|st|tjrN|jdkr||}|jddvr|jddn|jdd}n|j d|j df}|d|dz dz}||dz}|d|dz dz}||dz}t|tj j r| ||||fS|jddvrdnd}|sWt|tjr| ddd}t|r|ddd}|dkr-||dkr!|dkr||dkr|d||||fS|jdd t|d|dt|d|dfz} t|tjrt j|| } n$t|r|| } | d |dz dz} | |dz} | d |dz dz} | |dz}|| d| | | |f<|| z }|| z }|| z }|| z }| dtd|t%| jd |td|t%| jd |f} | S) a Crops `image` to the given size using a center crop. Note that if the image is too small to be cropped to the size given, it will be padded (so the returned result has the size asked). Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor` of shape (n_channels, height, width) or (height, width, n_channels)): The image to resize. size (`int` or `Tuple[int, int]`): The size to which crop the image. Returns: new_image: A center cropped `PIL.Image.Image` or `np.ndarray` or `torch.Tensor` of shape: (n_channels, height, width). rkrrjr NTF.rz)rnr{)rr6rQrrYrrbrrnrr7r8croprpermuter\ zeros_like new_zerosr[)rrKr image_shapetopbottomleftrightr new_shape new_imagetop_pad bottom_padleft_pad right_pads r* center_cropz'ImageFeatureExtractionMixin.center_cropsm %%e,,,$&& $1a7{1~- bMKN2q8{1~- AF #wz)8I+==> w'   Qs9?2#6???QPST]TcdfTginPoPoAo o r)c||t|tjjr||}|dddddddfS)a Flips the channel order of `image` from RGB to BGR, or vice versa. Note that this will trigger a conversion of `image` to a NumPy array if it's a PIL Image. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image whose color channels to flip. If `np.ndarray` or `torch.Tensor`, the channel dimension should be first. Nr{)rr6r7r8rgrs r*flip_channel_orderz.ImageFeatureExtractionMixin.flip_channel_orders` %%e,,, eSY_ - - /''..ETTrT111aaaZ  r)rc||ntjj}||t |tjjs||}|||||||S)a Returns a rotated copy of `image`. This method returns a copy of `image`, rotated the given number of degrees counter clockwise around its centre. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image to rotate. If `np.ndarray` or `torch.Tensor`, will be converted to `PIL.Image.Image` before rotating. Returns: image: A rotated `PIL.Image.Image`. N)rexpandcenter translate fillcolor)r7r8NEARESTrr6rrotate)rrKanglerrrrr s r*r z"ImageFeatureExtractionMixin.rotates} (3889J %%e,,,%11 -%%e,,E|| HVFicl   r)r5)NT)F)NTN)NrNNN)r#r$r%__doc__rrrrYrr rrmrrgrrrrrr r(r)r*rrs< $ $ $RZeSj0Abj@(2(2(2(2(hA5A5A5A5FIIIV!!!"      r)rannotation_formatsupported_annotation_formatsc||vrtdtd||tjurt |std|tjurt |stddSdS)NzUnsupported annotation format: z must be one of zInvalid COCO detection annotations. Annotations must a dict (single image) or list of dicts (batch of images) with the following keys: `image_id` and `annotations`, with the latter being a list of annotations in the COCO format.zInvalid COCO panoptic annotations. Annotations must a dict (single image) or list of dicts (batch of images) with the following keys: `image_id`, `file_name` and `segments_info`, with the latter being a list of annotations in the COCO format.)rHformatr,r/rr0r)rrrs r*validate_annotationsr s  <<<q6qqSoqqrrr,;;;/ << B  ,:::.{;; M ;:  r)valid_processor_keyscaptured_kwargsct|t|}|r5d|}td|ddSdS)Nz, zUnused or unrecognized kwargs: ra)set differencejoinrorp)rr unused_keysunused_key_strs r*validate_kwargsr&spo&&11#6J2K2KLLKL;//JJJJKKKKKLLr))r^r5) NNNNNNNNNNNN)Zrriortypingrrrrrr r r@rYr packagingr utilsr rrrrrrrrrrutils.constantsrrrrrr PIL.Imager7 PIL.ImageOpsparse __version__ base_versionr8 Resamplingrtorchvision.transformsrr BOXrHAMMINGBICUBICLANCZOSpil_torch_interpolation_mappingr? get_loggerr#ror ImageInput VideoInputr r,r2rrmAnnotationTyper;r=rLrNrRrUboolr]rdrgrsrwr}rrrrrrrrrrr(r)r*r2s  NNNNNNNNNNNNNNNNNN                           w}]W]3?33@AA]W]SZE[E[[[ Y1 Y!!  <<<<<<  &(9(A  "$5$9  '):)C  &(9(A  &(9(A  &(9(A + '   H % %rz>48I3JDQSQ[L\^bcq^rr   !m n    | $$$$$|$$$ 99999\999 c5c4:!5667FFF  ? ? ?www    52:5$5555$$$D "&^+,&^&^&^&^T\ \ \ \ \ \ \ \ ~ '"'(8#(=">d 2L$s)Ld3iLLLLLLr)