S^(hddlmZmZddlmZddlmZmZddlZ ddl m Z m Z m Z mZmZddlmZmZmZmZmZddlmZmZmZmZmZer ddlZdd l mZerddlZerddlZ erddl!mZ" dHd e jFd ee e$fd eee e$fd e jFfdZ%de jLdfd e jFde'dee de jPdeee$e fd e jFf dZ)dZ* dId ee jFddddfdee+dee$deee$e fd df dZ,dHd e-e.e.ffdZ/ dJde jFdee.e-e.e.fe0e.e-e.fde+d ee.deee$e fd e-f d!Z1 dKd e jFde-e.e.fd"d#d$ee.dee d%e+deee$e fd e jFfd&Z2 dLd e jFd'ee'ee'fd(ee'ee'fdee deee$e fd e jFf d)Z3 dLd e jFde-e.e.fdeee$e fdeee$e fd e jFf d*Z4dMd,Z5d+e jFd e jFfd-Z6dNd.Z7d+ed efd/Z8dOd1Z9d0e jFd e jFfd2Z:dPd3Z;d0ed efd4ZGd7d8eZ?e?jd9ddfd e jFd:ee.e-e.e.fee-e.e.ffd;e?dZB dLd e jFdee deee$e fd e jFfd?ZCd@ZDdAe0dd e-eEe-e.e.fe0dfeEe.e-e-e.e.fe.ffffdBZFdCeEe-e.e.fdfdDeEe.e-e.e.ffd e0dfdEZGGdFdGZHy)Q) CollectionIterable)ceil)OptionalUnionN)ChannelDimension ImageInputget_channel_dimension_axisget_image_sizeinfer_channel_dimension_format) ExplicitEnum TensorType is_jax_tensor is_tf_tensoris_torch_tensor)is_flax_availableis_tf_availableis_torch_availableis_vision_availablerequires_backends)PILImageResamplingimage channel_diminput_channel_dimreturncVt|tjstdt || t |}t |}||k(r|S|t jk(r|jd}|S|t jk(r|jd}|Std|)a) Converts `image` to the channel dimension format specified by `channel_dim`. Args: image (`numpy.ndarray`): The image to have its channel dimension set. channel_dim (`ChannelDimension`): The channel dimension format to use. input_channel_dim (`ChannelDimension`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred from the input image. Returns: `np.ndarray`: The image with the channel dimension set to `channel_dim`. ,Input image must be of type np.ndarray, got )rr)rrrz&Unsupported channel dimension format: ) isinstancenpndarray TypeErrortyper r FIRST transposeLAST ValueError)rrrtarget_channel_dims [/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/transformers/image_transforms.pyto_channel_dimension_formatr+5s& eRZZ (FtE{mTUU :5A)+6.. -333 * L /44 4 * LA+OPPscale data_formatdtypeinput_data_formatct|tjstdt ||j tj |z}| t|||}|j |}|S)a Rescales `image` by `scale`. Args: image (`np.ndarray`): The image to rescale. scale (`float`): The scale to use for rescaling the image. data_format (`ChannelDimension`, *optional*): The channel dimension format of the image. If not provided, it will be the same as the input image. dtype (`np.dtype`, *optional*, defaults to `np.float32`): The dtype of the output image. Defaults to `np.float32`. Used for backwards compatibility with feature extractors. input_data_format (`ChannelDimension`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred from the input image. Returns: `np.ndarray`: The rescaled image. r)r r!r"r#r$astypefloat64r+)rr-r.r/r0rescaled_images r*rescaler5\sk4 eRZZ (FtE{mTUU\\"**-5N4^[Rcd#**51N r,c|jtjk(rd}|Stj||j t rbtj d|krtj |dkrd}|Std|jd|jdtj d|krtj |dkrd}|Std |jd|jd) z Detects whether or not the image needs to be rescaled before being converted to a PIL image. The assumption is that if the image is of type `np.float` and all values are between 0 and 1, it needs to be rescaled. FrzZThe image to be converted to a PIL image contains values outside the range [0, 255], got [z, z%] which cannot be converted to uint8.rTzXThe image to be converted to a PIL image contains values outside the range [0, 1], got [) r/r!uint8allcloser2intallr(minmax)r do_rescales r*_rescale_for_pil_conversionr?s {{bhh  UELL- . 66!u* "&&#"6J  }Buyy{m3XZ  U uz 2   IIK=599;-/T V  r,zPIL.Image.Image torch.Tensor tf.Tensorz jnp.ndarrayr> image_modecttdgt|tjjr|St |s t |r|j}nRt|rtj|}n1t|tjstdt|t|tj |}|j"ddk(rtj$|dn|}| t'|n|}|r t)|d}|j+tj,}tjj/||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` or `tf.Tensor`): The image to convert to the `PIL.Image` format. do_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 and casting to `int` would result in a loss of precision, and `False` otherwise. image_mode (`str`, *optional*): The mode to use for the PIL image. If unset, will use the default mode for the input image type. input_data_format (`ChannelDimension`, *optional*): The channel dimension format of the input image. If unset, will use the inferred format from the input. Returns: `PIL.Image.Image`: The converted image. visionz Input image type not supported: raxisr7mode)r to_pil_imager PILImagerrnumpyrr!arrayr"r(r$r+r r'shapesqueezer?r5r2r8 fromarray)rr>rBr0s r*rJrJs2lXJ/%) ue!4  u  rzz *;DK=IJJ (/?/D/DFW XE+0++b/Q*>BJJu2 &EE8B7I,U3zJs# LL "E 99  u:  66r,c|\}}d}|Stt||f}tt||f}||z |z|kDr||z|z }tt |}||kr||k(s ||kr ||k(r||} }|| fS||kr0|} ||t||z|z }|| fSt||z|z }|| fS|}||t||z|z } || fSt||z|z } || fS)aC Computes the output image size given the input image size and the desired output size. Args: image_size (`Tuple[int, int]`): The input image size. size (`int`): The desired output size. max_size (`int`, *optional*): The maximum allowed output size. N)floatr<r=r:round) image_sizesizemax_sizeheightwidthraw_sizemin_original_sizemax_original_sizeohows r*get_size_with_aspect_ratior_sFMFEH!#vuo"67!#vuo"67 0 04 7( B"336GGHuX'D%FdNETMB 8O    H$8X&./B 8OTF]U*+B 8O   H$8X%./B 8OTE\F*+B 8Or, input_imagerVdefault_to_squarerWct|ttfr8t|dk(r t|St|dk(r|d}n t d|r||fSt ||\}}||kr||fn||f\}}|} | t | |z|z } } |.|| krt d|d|| |kDrt || z| z |} } ||kr| | fS| | fS)a Find the target (height, width) dimension of the output image after resizing given the input image and the desired size. Args: input_image (`np.ndarray`): The image to resize. size (`int` or `Tuple[int, int]` or List[int] or `Tuple[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). 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*): 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`. input_data_format (`ChannelDimension`, *optional*): The channel dimension format of the input image. If unset, will use the inferred format from the input. Returns: `tuple`: The target (height, width) dimension of the output image after resizing. rrrz7size must have 1 or 2 elements if it is a list or tuplez max_size = zN must be strictly greater than the requested size for the smaller edge size = )r tuplelistlenr(r r:) r`rVrarWr0rXrYshortlongrequested_new_short new_shortnew_longs r*get_resize_output_image_sizerksJ$ & t9>;  Y!^7DVW Wd|";0ABMFE%*f_5&/65/KE4-s3F3MPU3U/VxI * *hZ(4486;  h "%h&:X&E"FxI$)VOHi N)X9NNr,resampler reducing_gap return_numpyc2ttdg||ntj}t |dk(s t d| t |}||n|}d}t|tjjst|}t|||}|\}} |j| |f||} |ritj| } | jdk(rtj| dn| } t!| |t"j$ } |r t'| d n| } | S) a Resizes `image` to `(height, width)` specified by `size` using the PIL library. Args: image (`np.ndarray`): The image to resize. size (`Tuple[int, int]`): The size to use for resizing the image. resample (`int`, *optional*, defaults to `PILImageResampling.BILINEAR`): The filter to user for resampling. reducing_gap (`int`, *optional*): Apply optimization by resizing the image in two steps. The bigger `reducing_gap`, the closer the result to the fair resampling. See corresponding Pillow documentation for more details. data_format (`ChannelDimension`, *optional*): The channel dimension format of the output image. If unset, will use the inferred format from the input. return_numpy (`bool`, *optional*, defaults to `True`): Whether or not to return the resized image as a numpy array. If False a `PIL.Image.Image` object is returned. input_data_format (`ChannelDimension`, *optional*): The channel dimension format of the input image. If unset, will use the inferred format from the input. Returns: `np.ndarray`: The resized image. rDrzsize must have 2 elementsF)r>r0)rlrmrErFrgp?)rresizerBILINEARrer(r r rKrLr?rJr!rNndim expand_dimsr+r r'r5) rrVrlrmr.rnr0r>rXrY resized_images r*rqrq>sBfxj)#/x5G5P5PH t9>455 :5A'2':# KJ eSYY__ -07 UzM^_MFELL%8R^L_M/ CPBTBTXYBY}2>_l 3 ;:J:O:O > NBJJ /.~>> n %+N;; .tN/C.DE FFr,cvt|tjrt|jdk(rh|j tj k(r|jtj}|dddddfd|dddddfzzd|dddddfzzSt|dd|dzzd|dzzS)z* Converts RGB color to unique ID. Nrrir) r r!r"rerOr/r8r2int32r:)colors r* rgb_to_idrs%$U[[)9Q)> ;;"(( "LL*EQ1W~eAq!Gn 44y5Aq>7QQQ uQx#a.(9uQx+?? @@r,ct|tjrx|j}t t |j dgz}tj|tj}tdD]}|dz|d|f<|dz}|Sg}tdD]}|j|dz|dz}|S)z* Converts unique ID to RGB color. rryr.) r r!r"copyrcrdrOzerosr8rangeappend)id_map id_map_copy rgb_shapergb_mapir_s r* id_to_rgbrs&"**%kkm $v||,s23 ((9BHH5q A)C/GCFO C K  E 1X Vc\"3 Lr,c eZdZdZdZdZdZdZy) PaddingModezP Enum class for the different padding modes to use when padding images. constantreflect replicate symmetricN)__name__ __module__ __qualname____doc__CONSTANTREFLECT REPLICATE SYMMETRICr,r*rrsHGIIr,rgpaddingrIconstant_valuesc tfd}||}|tjk(r"||}tj|d|n|tj k(rtj|dnf|tj k(rtj|dn:|tjk(rtj|dntd||t|SS) a Pads the `image` with the specified (height, width) `padding` and `mode`. Args: image (`np.ndarray`): The image to pad. padding (`int` or `Tuple[int, int]` or `Iterable[Tuple[int, int]]`): Padding to apply to the edges of the height, width axes. Can be one of three formats: - `((before_height, after_height), (before_width, after_width))` unique pad widths for each axis. - `((before, after),)` yields same before and after pad for height and width. - `(pad,)` or int is a shortcut for before = after = pad width for all axes. mode (`PaddingMode`): The padding mode to use. Can be one of: - `"constant"`: pads with a constant value. - `"reflect"`: pads with the reflection of the vector mirrored on the first and last values of the vector along each axis. - `"replicate"`: pads with the replication of the last value on the edge of the array along each axis. - `"symmetric"`: pads with the reflection of the vector mirrored along the edge of the array. constant_values (`float` or `Iterable[float]`, *optional*): The value to use for the padding if `mode` is `"constant"`. data_format (`str` or `ChannelDimension`, *optional*): The channel dimension format for the output image. Can be one of: - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. If unset, will use same as the input image. input_data_format (`str` or `ChannelDimension`, *optional*): The channel dimension format for the input image. Can be one of: - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. If unset, will use the inferred format of the input image. Returns: `np.ndarray`: The padded image. ct|ttfr ||f||ff}nt|tr#t |dk(r|d|df|d|dff}nxt|tr&t |dk(rt|dtr||f}nBt|tr$t |dk(rt|dtr|}nt d|t jk(rdg|ng|d}jdk(rdg|}|S|}|S)za Convert values to be in the format expected by np.pad based on the data format. rrrzUnsupported format: )rr) r r:rSrcrer(r r%rs)valuesrr0s r*_expand_for_data_formatz$pad.._expand_for_data_formats fsEl +v&(89F  &3v;!+;ay&),vay&).DEF  &3v;!+; 6RS9VY@Zf%F  &3v;!+; 6RS9V[@\F3F8<= ='8;K;Q;Q&Q&"6"WhY_WhagWh"'q!f 7= r,r)rIrrrHedgerzInvalid padding mode: ) r rrr!padrrrr(r+)rrrIrr.r0rs` ` r*rrsV :5A,&g.G {###1/BugJX $$ $ugI6 && &ugF3 && &ugK81$899R]Ri '{ Reconstructs a list of images in the original order. rr)rre)rrrs r*reorder_imagesr]sOs/01   -a0345I!5LQ5OP  s5c0eZdZdZdej fdZy) NumpyToTensorz4 Convert a numpy array to a PyTorch tensor. rcjtj|jdddjS)Nrrr)r from_numpyr& contiguous)selfrs r*__call__zNumpyToTensor.__call__ns+1a 89DDFFr,N)rrrrr!r"rrr,r*rrisGbjjGr,rr)NNN)TNN)NNNTN)NN)rr@rr@)rrArrA)rr@rr@)rrArrA)Icollections.abcrrmathrtypingrrrMr! image_utilsr r r r r utilsrrrrrutils.import_utilsrrrrrrKrr tensorflowr jax.numpyjnpr"strr+r|rSr/r5r?boolrJrcr:r_rdrkrqrrrrrrrrrrrrrrrrrrdictrrrrr,r*rs1"ZY/ AE$ ::$',-$ &6&; <=$ZZ $T/3jj@D # ::# #*+# 88 #  c+;&; <= # ZZ #L:"& $@D 37 . ]Z [3737 37 c+;&; <= 37  37l$5c?$V#"@D @O@O U38_d3is; <@O@Osm @O  c+;&; <= @O  @OL&*"&.2@DD ::D S/D#D3- D *+ D  D c+;&; <=DZZDV/3@D : ::: z%(( ): uj'' (:*+ :  c+;&; <= : ZZ :@;?@D Q ::Q S/Q%%5 567Q c+;&; <= Q ZZ Qh2::"**FJF:F*" BJJ 2::  GZGJG.A&,$,,58:>@D S ::S 3c3h%S/)BB CS S5(5/12 S %%5 567 S  c+;&; <= SZZSn*,/3@D# ::#*+# c+;&; <=#ZZ #L 0  0 4c3hn!55 6S%cSVhY\H\B]=]8^ ^_0* 5c?N:; SWX[]bcfhkck]lXlSm  . GGr,