gFFddlZddlmZddlmZmZmZmZmZddl Z ddl m Z m Z mZmZmZddlmZmZmZmZmZddlmZmZmZmZmZmZmZer ddlZddl m Z erddl!Z!erddl"Z#erddl$m Z%erdd l&m'Z(nerdd l)m'Z( dGd e j*d ee e+fd eee e+fd e j*fdZ,de j-dfd e j*de.dee de j/deee+e fd e j*f dZ0dZ1 dHd ee j*ddddfdee2dee+deee+e fd df dZ3 dIde j*dee4ee4e4fee4ee4fde2d ee4deee+e fd e5f d!Z6 dJd e j*dee4e4fd"d#d$ee4dee d%e2deee+e fd e j*fd&Z7 dKd e j*d'ee.ee.fd(ee.ee.fdee deee+e fd e j*f d)Z8 dHd e j*dee4e4fdeee+e fdeee+e fd%ee2d e j*f d*Z9dLd,Z:d+e j*d e j*fd-Z;dMd.Zd0e j*d e j*fd2Z?dOd3Z@d0ed efd4ZAd5ZBd6ZCGd7d8eZDeDjEd9ddfd e j*d:ee4ee4e4feee4e4ffd;eDdZG dKd e j*dee deee+e fd e j*fd?ZHd@ZIGdAdBZJGdCdDZKGdEdFZLdS)PN)ceil)IterableListOptionalTupleUnion)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_torchvision_availableis_torchvision_v2_availableis_vision_availablerequires_backends)PILImageResampling) functionalimage channel_diminput_channel_dimreturnct|tjstdt ||t |}t |}||kr|S|t jkr|d}nH|t j kr|d}n"td ||S)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 N)rr )r r#rz(Unsupported channel dimension format: {}) isinstancenpndarray TypeErrortyperr FIRST transposeLAST ValueErrorformat)rrrtarget_channel_dims Y/var/www/html/ai-engine/env/lib/python3.11/site-packages/transformers/image_transforms.pyto_channel_dimension_formatr0=s& eRZ ( (VTtE{{TTUUU :5AA)+66... -333 ** /4 4 4 **CJJ;WWXXX Lscale data_formatdtypeinput_data_formatc t|tjstdt ||tj|z}|t|||}||}|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(astypefloat64r0)rr2r3r4r5rescaled_images r/rescaler:ds4 eRZ ( (VTtE{{TTUUU\\"*--5N4^[Rcdd#**511N r1cF|jtjkrd}ntj||t rmtjd|krtj|dkrd}ntd|d| dtjd|krtj|dkrd}n:td |d| d|S) 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.r TzXThe image to be converted to a PIL image contains values outside the range [0, 1], got [) r4r%uint8allcloser7intallr,minmax)r do_rescales r/_rescale_for_pil_conversionrDs@ {bh UELL-- . . 6!u*   "&#"6"6 JJZ ZZ',yy{{ZZZ  U   uz 2 2   VIIKK V V#(99;; V V V    r1zPIL.Image.Image torch.Tensor tf.Tensorz jnp.ndarrayrC image_modecttdgt|tjjr|St |st |r|}nmt|rtj |}nIt|tj s/td t|t|t j|}|jddkrtj|dn|}|t)|n|}|rt+|d}|tj}tj||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: {}r axisNr<mode)r to_pil_imager$PILImagerrnumpyrr%arrayr&r,r-r(r0r r+shapesqueezerDr:r7r= fromarray)rrCrGr5s r/rOrOs^2lXJ///%)) uSe!4!4S  u  S rz * *S=DDT%[[QQRRR (/?/DFW X XE+0+b/Q*>*>BJu2 & & & &EE8B7I,U333zJ$s## LL " "E 9  u:  6 66r1T input_imagesizedefault_to_squaremax_sizect|ttfrMt|dkrt|St|dkr |d}nt d|r||fSt ||\}}||kr||fn||f\}}|} | t | |z|z } } |8|| krt d|d|| |krt || z| z |} } ||kr| | fn| | 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. r#r rz7size must have 1 or 2 elements if it is a list or tupleNz max_size = zN must be strictly greater than the requested size for the smaller edge size = )r$tuplelistlenr,r r?) rWrXrYrZr5heightwidthshortlongrequested_new_short new_shortnew_longs r/get_resize_output_image_sizerfsMJ$ &&X t99>>;;  YY!^^7DDVWW Wd|";0ABBMFE%*f__5&//65/KE4-s3F3MPU3U/V/VxI * * *;h;;48;;  h  "%h&:X&E"F"FxI$)VOOHi )X9NNr1resampler reducing_gap return_numpycXttdg||n tj}t |dkst d|t |}||n|}d}t|tj j s!t|}t|||}|\}} || |f||} |rgtj | } | jdkrtj| d n| } t!| |t"j } |rt'| 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. rINr#zsize must have 2 elementsF)rCr5)rgrhrJrKrgp?)rresizerBILINEARr^r,rr$rPrQrDrOr%rSndim expand_dimsr0r r+r:) rrXrgrhr3rir5rCr_r` resized_images r/rlrlsWBfxj)))#/xx5G5PH t99>>4555 :5AA'2':## KJ eSY_ - -`077 UzM^___MFELL%8R^L__M Y// CPBTXYBYBY}2>>>>_l 3 ;:J:O   | |kr8| dkr2| |kr,|d | | | | f}t||tj}|St'||}t'| |}|jdd ||fz}t j|| }t-||z dz }||z}t-||z dz }||z}||d ||||f<| |z } | |z } | |z } | |z } |d t'd| t/|| t'd| t/|| f}t||tj}|st1|}|S) a Crops the `image` to the specified `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 will always be of size `size`). Args: image (`np.ndarray`): The image to crop. size (`Tuple[int, int]`): The target size for the cropped image. 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 the inferred format of 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. return_numpy (`bool`, *optional*): Whether or not to return the cropped image as a numpy array. Used for backwards compatibility with the previous ImageFeatureExtractionMixin method. - Unset: will return the same type as the input image. - `True`: will return a numpy array. - `False`: will return a `PIL.Image.Image` object. Returns: `np.ndarray`: The cropped image. rINz8return_numpy is deprecated and will be removed in v.4.33Tr"r#zOsize must have 2 elements representing the height and width of the output imager.)rT)r center_cropwarningswarn FutureWarningr$r%r&r'r(rr^r,rr0r r)r r?rBrT zeros_likerrArO)rrXr3r5rioutput_data_format orig_height orig_width crop_height crop_widthtopbottomleftright new_height new_width new_shape new_imagetop_pad bottom_padleft_pad right_pads r/r~r~sFkH:... PR_```'/44\L eRZ ( (VTtE{{TTUUU dH % %lTajkkk :5AA(3(?EV (/?/EGX Y YE,U4D4JKKK"K!+..JK  $ *C ; F  # )D : E axxFk))daiiEZ>> NBJ / /<.~>>> n % %<+N;;; EtN/C/CEE F FFr1ct|tjrt|jdkri|jtjkr|tj}|dddddfd|dddddfzzd|dddddfzzSt|dd|dzzd|dzzS)z* Converts RGB color to unique ID. Nrr ir#) r$r%r&r^rTr4r=r7int32r?)colors r/ rgb_to_idrxs%$$RU[)9)9Q)>)> ;"( " "LL**EQQQ1W~eAAAqqq!Gn 44y5AAAq>7QQQ uQx#a.(9uQx+?? @ @@r1ct|tjr||}t t |jdgz}tj|tj}tdD]}|dz|d|f<|dz}|Sg}tdD]}| |dz|dz} |S)z* Converts unique ID to RGB color. rrtr.) r$r%r&copyr\r]rTzerosr=rangeappend)id_map id_map_copy rgb_shapergb_mapir_s r/ id_to_rgbrs&"*%%kkmm $v|,,s233 (9BH555q  A)C/GCFO C KK E 1XX Vc\"""3 Lr1c"eZdZdZdZdZdZdZdS) PaddingModezP Enum class for the different padding modes to use when padding images. constantreflect replicate symmetricN)__name__ __module__ __qualname____doc__CONSTANTREFLECT REPLICATE SYMMETRICr1r/rrs.HGIIIIr1rgpaddingrNconstant_valuesctfd}||}|tjkr$||}tj|d|n|tjkrtj|dnb|tjkrtj|dn:|tjkrtj|dntd ||t|nS) 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. Nct|ttfr ||f||ff}nt|tr4t |dkr!|d|df|d|dff}nt|tr3t |dkr t|dtr||f}nXt|tr1t |dkrt|dtr|}nt d|t jkrdg|Rng|dR}jdkrdg|Rn|}|S)za Convert values to be in the format expected by np.pad based on the data format. r rr#zUnsupported format: )rr) r$r?floatr\r^r,r r)rn)valuesrr5s r/_expand_for_data_formatz$pad.._expand_for_data_formatsh fsEl + + >v&(89FF  & & >3v;;!+;+;ay&),vay&).DEFF  & & >3v;;!+;+; 6RS9VY@Z@Z+;f%FF  & & >3v;;!+;+; 6RS9V[@\@\+;FF? <$$n(<= r1rrEcnt|}tj||j|j|jS)N)r)rFr{rqrrrrrs r/__call__zFusedRescaleNormalize.__call__Bs.%e,,{5$)TXt|LLLLr1N)rFrrE)rrrrrboolrrrr1r/rr8s_% MMMMMMr1rc(eZdZdZd defdZd dZdS) RescalezM Rescale the input image by rescale factor: image *= rescale_factor. rrc||_dSrr)rrs r/rzRescale.__init__Ls,r1rrEc||jz}|Srrrs r/rzRescale.__call__Os++ r1N)rr)rrrrrrrrr1r/rrGsR--u----r1rc(eZdZdZdejfdZdS) NumpyToTensorz4 Convert a numpy array to a PyTorch tensor. rcxtj|dddS)Nr#rr )r from_numpyr* contiguousrs r/rzNumpyToTensor.__call__Ys11a 8 899DDFFFr1N)rrrrr%r&rrr1r/rrTsBGbjGGGGGGr1rr)NNN)TNN)NNNTN)NN)rrEr rE)rrFr rF)rrEr rE)rrFr rF)MrmathrtypingrrrrrrRr% image_utilsr r r r rutilsrrrrrutils.import_utilsrrrrrrrrPrr tensorflowr jax.numpyjnptorchvision.transforms.v2rrtorchvision.transformsr&strr0rwrr4r:rDrrOr?r\rfrlr{r~rrrrrrrrrrrrrrrrrrrrr1r/rs  99999999999999ZYYYYYYYYYYYYY0JJJ//////LLL?  799999997666666 AE$$ :$',-$ &6&; <=$Z $$$$T/3j@D ## :# #*+# 8 #  c+;&; <= # Z ####L:"& $@D 3737 . ]Z [3737 37 c+;&; <= 37  37373737t#"@D @O@O@O U38_d3is; <@O@Osm @O  c+;&; <= @O  @O@O@O@OL&*"&.2@DDD :D S/D#D3- D *+ D  D c+;&; <=DZDDDDV/3@D :: :: x& ': uhuo% &:*+ :  c+;&; <= : Z ::::@;?@D#' `` :` S/`%%5 567` c+;&; <= ` 4. ` Z ````F2:"*FJF:FFFF*"""" BJ 2:        GZGJGGGG.AAA&,$,58:>@D SS :S 3c3h%S/)BB CS S5(5/12 S %%5 567 S  c+;&; <= SZSSSSn*,/3@D## :#*+# c+;&; <=#Z ####L M M M M M M M M        GGGGGGGGGGr1