`iaddlmZddlmZmZddlZddlmZm Z m Z m Z ddl m Z mZmZmZmZddlmZmZmZmZmZmZmZmZmZmZddlmZmZej e!Z"d ej#d e$d e%ej#fd Z&Gd deZ'dgZ(dS))Iterable)OptionalUnionN)BaseImageProcessor BatchFeatureget_patch_output_sizeselect_best_resolution) PaddingModeconvert_to_rgbpadresizeto_channel_dimension_format) ChannelDimension ImageInputPILImageResamplingget_image_sizeinfer_channel_dimension_formatis_scaled_imagemake_flat_list_of_imagesto_numpy_array valid_imagesvalidate_preprocess_arguments) TensorTypeloggingimage patch_sizereturnc$g}t||\}}td||D]g}td||D]S}|tjkr||||z|||zf}n|dd|||z|||zf}||Th|S)a Divides an image into patches of a specified size. Args: image (`np.ndarray`): The input image. patch_size (`int`): The size of each patch. input_data_format (`ChannelDimension` or `str`): The channel dimension format of the input image. Returns: list: A list of np.ndarray representing the patches.  channel_dimrN)rrangerLASTappend) rrinput_data_formatpatchesheightwidthijpatchs /home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/transformers/models/aria/image_processing_aria.pydivide_to_patchesr-.sG"56GHHHMFE 1fj ) )""q%,, " "A $4$999a!j.0!a*n2DDEaaaQ^!3QZ5GGH NN5 ! ! ! !  " Nc 4eZdZdZgdZddddddddddejf d eee d eee d e d e d eee e e fdee dee de de e e fdee deffd Zdddddddddddejdf de eeefd ee e ee fd ee e ee fd ee d ee dee dee dee dee dee deedee eefdeedee eeffdZdejde dedejfdZde de fd Zdejde dedejfd!Zejd"ddfdejd#e e e e e fee e e ffd$ed%e e ee fdee eefdee eefdejfd&Zdejd'ee e e fd(e dedededeejfd)Zd-d*e d+e fd,ZxZ S).AriaImageProcessoraG A vision processor for the Aria model that handles image preprocessing. Initialize the AriaImageProcessor. Args: image_mean (`list`, *optional*, defaults to [0.5, 0.5, 0.5]): Mean values for normalization. image_std (`list`, *optional*, defaults to [0.5, 0.5, 0.5]): Standard deviation values for normalization. max_image_size (`int`, *optional*, defaults to 980): Maximum image size. min_image_size (`int`, *optional*, defaults to 336): Minimum image size. split_resolutions (`list`, *optional*, defaults to a list of optimal,resolutions as tuples): The optimal resolutions for splitting the image. split_image (`bool`, *optional*, defaults to `False`): Whether to split the image. do_convert_rgb (`bool`, *optional*, defaults to `True`): Whether to convert the image to RGB. do_rescale (`bool`, *optional*, defaults to `True`): Whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by `do_rescale` in the `preprocess` method. rescale_factor (`int` or `float`, *optional*, defaults to `1/255`): Scale factor to use if rescaling the image. Can be overridden by `rescale_factor` in the `preprocess` method. do_normalize (`bool`, *optional*, defaults to `True`): Whether to normalize the image. resample (PILImageResampling, *optional*, defaults to `BICUBIC`): The resampling filter to use if resizing the image.  pixel_values pixel_mask num_cropsNiPFTgp? image_mean image_stdmax_image_sizemin_image_sizesplit_resolutions split_imagedo_convert_rgb do_rescalerescale_factor do_normalizeresamplec  tjdi| |gd}|gd}||_||_||_||_||_|gd}d|D}||_||_||_ | |_ | |_ | |_ dS)N)?rBrB)))rCr)rC)rC)rC)rC)rC)rDrE)rDr)rDrD)rDrC)rrC)rrD)rErC)rErD)rFrC)rGrC)rHrC)rIrCc:g|]}|ddz|ddzfS)rrC).0els r, z/AriaImageProcessor.__init__..s- X X X"Q%#+r!us{!; X X Xr.rL) super__init__r8r9r6r7r;r:r<r=r>r?r@)selfr6r7r8r9r:r;r<r=r>r?r@kwargs __class__s r,rQzAriaImageProcessor.__init__ls ""6"""  (J  'I,,$"&  $!y!y!y  X XFW X X X !2,$,(  r.ptimagesreturn_tensors data_formatr%c x||n|j}||n|j}||n|j}||n|j}||n|j}||n|j}||n|j}| | n|j} | | n|j} | | n|j } |dvrtd| |}t|}t|stdt| ||| || |r d|D}d|D}|r/t|drt d |t%|d}g}g}d}|D]}|r!|||j|| || }n|g}|t+||krt+|}|D]i}t-|\}}|t/||z }||kr#t/t1||z||f}n"|t/t1||z|f}t3||| || }||dz ||d z }}t5|d|fd|ff|| }t7j||ft: }d |d|dd|d f<|||r||| |}| r9| ||j|j|| }| tC|| |n|}||ktEt7j#|dt7j#|d|d| S)aI Process a list of images. Args: images (ImageInput or list of ImageInput): The input image or a list of images. image_mean (`list`, *optional*, defaults to [0.5, 0.5, 0.5]): Mean values for normalization. image_std (`list`, *optional*, defaults to [0.5, 0.5, 0.5]): Standard deviation values for normalization. max_image_size (`int`, *optional*, defaults to `self.max_image_size` (980)): Maximum image size. min_image_size (`int`, *optional*, defaults to `self.min_image_size` (336)): Minimum image size. split_image (`bool`, *optional*, defaults to `self.split_image` (False)): Whether to split the image. do_convert_rgb (`bool`, *optional*, defaults to `self.do_convert_rgb` (True)): Whether to convert the image to RGB. do_rescale (`bool`, *optional*, defaults to `self.do_rescale`): Whether to rescale the image. rescale_factor (`float`, *optional*, defaults to `self.rescale_factor`): Rescale factor to rescale the image by if `do_rescale` is set to `True`. do_normalize (`bool`, *optional*, defaults to `self.do_normalize` (True)): Whether to normalize the image. resample (PILImageResampling, *optional*, defaults to `self.resample` (BICUBIC)): The resampling filter to use if resizing the image. return_tensors (`str` or `TensorType`, *optional*, defaults to "pt"): The type of tensor to return. 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: BatchFeature: A BatchFeature object containing: - 'pixel_values': Tensor of processed image pixel values. - 'pixel_mask': Boolean pixel mask. This mask is a 2D tensor of shape (max_image_size, max_image_size) where: - True (1) values indicate pixels that belong to the original resized image. - False (0) values indicate pixels that are part of the padding. The mask helps distinguish between actual image content and padded areas in subsequent processing steps. - 'num_crops': The maximum number of crops across all images. N)rKr5z(max_image_size must be either 490 or 980zkInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray.)r?r6r7r@r=r>c,g|]}t|SrL)r rMrs r,rOz1AriaImageProcessor.preprocess..s @@@nU++@@@r.c,g|]}t|SrL)rr[s r,rOz1AriaImageProcessor.preprocess..s <<r?r@ ValueError fetch_imagesrrrrlogger warning_oncerget_image_patchesr:lenrmaxintrr npzerosboolr$rescale normalizerrstack)rRrVr6r7r8r9r;r<r=r>r?r@rWrXr%r2 pixel_masksr4r crop_images crop_imagehwr^new_sizecrop_image_resizedpadding_bottom padding_rightcrop_image_paddedr3s r, preprocesszAriaImageProcessor.preprocessstR$.#9ZZt !*!6IIDN +9+E4K^+9+E4K^%0%vay I I    @ 7@ 7E &"44*" 1&7 5  %g  C $4$4y$@$@ ,, )1 71 7 %j111&Q266 #CE NNN C C^THH .CE NNN0S0STH%+% 1&7 &&&"1?!0Ln_ghi_jNj $'&(1m*<= 1&7 %%%! X~~&FdSSS ;< =Xa[=-HQK-78"":...(, /~Yj)5))% (,)$5*; )7))%'244E{Tefff.& ##$56666c1 7d "A > > > h{;;;& '     r.rtarget_resolutionrcXt|||\}}t|||f||}|S)aG Resizes an image to a target resolution while maintaining aspect ratio. Args: image (np.ndarray): The input image. target_resolution (tuple): The target resolution (height, width) of the image. resample (`PILImageResampling`): Resampling filter to use if resizing the image. input_data_format (`ChannelDimension` or `str`): The channel dimension format of the input image. Returns: np.ndarray: The resized and padded image. r@r%)r r)rRrr{r@r% new_height new_width resized_images r,_resize_for_patchingz'AriaImageProcessor._resize_for_patchingWs@&!6e=NPa b b Iuz9&=duvvv r.original_resolutionc|\}}|\}}t||z d\}}t||z d\} } | | | zf|||zffS)NrD)divmod) rRrr{original_heightoriginal_width target_height target_widthpaste_xr_xpaste_yr_ys r,_get_padding_sizez$AriaImageProcessor._get_padding_sizeqsc*='&7# |l^;Q?? mo=qAA 3''7S=)AAAr.ct|||}|||}|||}|S)zU Pad an image to a target resolution while maintaining aspect ratio. )padding)r rr )rRrr{r%new_resolutionr padded_images r,_pad_for_patchingz$AriaImageProcessor._pad_for_patchingxsH /u6GIZ[[((9JKKxxwx77 r.grmodeconstant_valuescjt|tst|dkrt||||||S|t |}t jdt jdt jdt j di}tj|||||}|t|||n|}|S)a Pads the `image` with the specified `padding` and `mode`. Padding can be in the (`height`, `width`) dimension of in the (`num_patches`) dimension. In the second case an iterable if tuples is expected as input. 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. rENconstantreflectedge symmetric)rr) isinstancerirgr rr CONSTANTREFLECT REPLICATE SYMMETRICrjr)rRrrrrrXr%padding_mode_mappings r,r zAriaImageProcessor.pads` gs # # ^s7||q'8'8ugt_kK\]] ]  $ >u E E   *    !6  !;   ug,@,FXghhhR]Ri '{.s9    (;Zk l l l   r.)rlist TypeErrorrr rrr-) rRrrrr@rXr%possible_resolutions image_sizebest_resolutionrrr&s `` r,rfz$AriaImageProcessor.get_image_patchess:.$// VTUU U-#E7HIII 0=QRR11 ?XIZ2  --m_`q-rr #LZ[lmmm         r.r'r(c|d|j}|d|j}t||f|j\}}|sdn ||z|z|z}|S)a A utility that returns number of image patches for a given image size. Args: height (`int`): Height of the input image. width (`int`): Width of the input image. images_kwargs (`dict`, *optional*) Any kwargs to override defaults of the image processor. Returns: `int`: Number of patches per image. r;r8rC)getr;r8r r:) rRr'r( images_kwargsr;r8resized_height resized_width num_patchess r,get_number_of_image_patchesz.AriaImageProcessor.get_number_of_image_patchessv$'' t7GHH &**+;T=PQQ(>PTPf(g(g% *raa.0PS`0`dr0r r.)N)!__name__ __module__ __qualname____doc__model_input_namesrBICUBICrrfloatrituplerlrrQrFIRSTrstrrrzrjndarrayrrrr rrr rfr __classcell__)rTs@r,r0r0Js>DCC-1+/!!=A&+)-,3'+'9'A"!"!T%[)"!DK("! "!  "! $DsCx$9: "!d^"!!"!"!c5j)"!tn"!%"!"!"!"!"!"!N;?9=(,(,&*)-%)*.'+15;?2B2HDHE E j$z"223E U5$u+#567E E%e"456 E ! E ! E d^E !E TNE !E tnE -.E !sJ!78E ./E $E#/?*?$@AE E E E NZ49Xh 4BUBuBBBB Z 49 N^      "(09<>BDH@@z@sE#s(OXeCHo-FFG@ @ uhuo56 @ eC)9$9:; @$E#/?*?$@A@ @@@@D0z0U38_-0 0 % 0 & 0,0 bj 0000d#cr.r0))collections.abcrtypingrrnumpyrjimage_processing_utilsrrr r image_transformsr r r rr image_utilsrrrrrrrrrrutilsrr get_loggerrrdrrirr-r0__all__rLr.r,rs*%$$$$$""""""""uuuuuuuuuuuueeeeeeeeeeeeee                        )(((((((  H % %RZSPTUWU_P`8BBBBB+BBBJ r.