qi `ddlmZddlZddlmZmZmZmZddl m Z m Z m Z m Z mZddlmZmZmZmZmZmZmZmZmZmZddlmZmZej:eZdej@d e!d e"ej@fd Z#Gd d eZ$d gZ%y))IterableN)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_sizereturncg}t||\}}td||D]^}td||D]L}|tjk(r||||z|||zf}n|dd|||z|||zf}|j |N`|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 `/opt/pipecat/venv/lib/python3.12/site-packages/transformers/models/aria/image_processing_aria.pydivide_to_patchesr+,sG"56GHMFE 1fj )"q%, "A $4$9$99a!j.0!a*n2DDEaQ^!3QZ5GGH NN5 !  "" NcpeZdZdZgdZddddddddddej f d eedzd eedzd e d e d ee e e fdzde dzde dzde de ezde dzdeffd Z ddddddddddde jdf deeezd eeezdzd eeezdzd e dzd e dzde dzde dzde dzdedzde dzdedzdeezdzde dzdee zdzfdZdej(de de dej(fdZde de fd Zdej(de de dej(fd!Zej2d"ddfdej(d#e e e e fzee e e fzd$ed%eeezdee zdzdee zdzdej(fd&Zdej(d'ee e e fd(e dede de deej(fd)Zd-d*e d+e fd,ZxZS).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  &t|di| |gd}|gd}||_||_||_||_||_|!gd}|D cgc]} | ddz| ddzf}} ||_||_||_ | |_ | |_ | |_ ycc} w)N)?r@r@)))rAr)rA)rA)rA)rA)rA)rBrC)rBr)rBrB)rBrA)rrA)rrB)rCrA)rCrB)rDrA)rErA)rFrA)rGrArrA) super__init__r6r7r4r5r9r8r:r;r<r=r>)selfr4r5r6r7r8r9r:r;r<r=r>kwargsel __class__s r*rKzAriaImageProcessor.__init__js "6"  (J  'I,,$"&  $!y FW X"Q%#+r!us{!; X  X!2,$,(  !Ys Bptimagesreturn_tensors data_formatr#c P||n |j}||n |j}||n |j}||n |j}||n |j}||n |j }||n |j }| | n |j} | | n |j} | | n |j} |dvr td|j|}t|}t|s tdt| ||| || |r|Dcgc] }t|}}|Dcgc] }t!|}}|r#t#|drt$j'd|t)|d}g}g}d}|D]}}|r"|j+||j,|| ||}n|g}|t/||kDr t/|}|D]2}t1|\}}|t3||z }||k\rt3t5||z||f}n|t3t5||z|f}t7||| || }||dz ||d z }}t9|d|fd|ff||}t;j<||ft> }d |d|dd|d f<|jA||r|jC|| | }| r;|jE||j|j||}| tG|| |n|}|jA|5tIt;jJ|d t;jJ|d |d| Scc}wcc}w)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)rHr3z(max_image_size must be either 490 or 980zSInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, or torch.Tensor)r=r4r5r>r;r<rzIt looks like you are trying to rescale already rescaled images. If the input images have pixel values between 0 and 1, set `do_rescale=False` to avoid rescaling them again.)rSr#)r>rSr#rA)dtype)rscaler#)axisr/)data tensor_type)&r4r5r6r7r9r:r;r<r=r> ValueError fetch_imagesrrrr rrlogger warning_oncerget_image_patchesr8lenrmaxintr r npzerosboolr"rescale normalizer rstack)rLrQr4r5r6r7r9r:r;r<r=r>rRrSr#rr0 pixel_masksr2 crop_images crop_imagehwrVnew_sizecrop_image_resizedpadding_bottom padding_rightcrop_image_paddedr1s r* preprocesszAriaImageProcessor.preprocesssR$.#9Zt !*!6IDNN +9+E4K^K^+9+E4K^K^%0%vay I    @ 7E"44**" 1&7 5  %g  C $4y$@ , )1 7 %j11&Q26 #CE NN C^TH .CE NN0STH%+% 1&7 &"1?!0Ln_ghi_jNj $'&(1m*<= 1&7 %! XX~~&FdS ;< =Xa[=-HQK-78"":.(, /~Yj)5)% (,)$5*; )7)%'244E{Tef.& ##$56c1 7@ 7B "A > hh{;& '   iA=s 9LL#rtarget_resolutionrcHt|||\}}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#)rr )rLrrsr>r# new_height new_width resized_images r*_resize_for_patchingz'AriaImageProcessor._resize_for_patchingRs7&!6e=NPa b Iuz9&=duv r,original_resolutioncz|\}}|\}}t||z d\}}t||z d\} } | | | zf|||zffS)NrB)divmod) rLrzrsoriginal_heightoriginal_width target_height target_widthpaste_xr_xpaste_yr_ys r*_get_padding_sizez$AriaImageProcessor._get_padding_sizels]*='&7# |l^;Q? mo=qA 3''7S=)AAAr,cjt|||}|j||}|j||}|S)zU Pad an image to a target resolution while maintaining aspect ratio. )padding)rrr )rLrrsr#new_resolutionr padded_images r*_pad_for_patchingz$AriaImageProcessor._pad_for_patchingss? /u6GIZ[((9JKxxwx7 r,grmodeconstant_valuesc^t|tst|dk7rt||||||S| t |}t j dt jdt jdt jdi}tj|||||}|t|||}|S|}|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. rCconstantreflectedge symmetric)rr) isinstancerar_r rr CONSTANTREFLECT REPLICATE SYMMETRICrbr )rLrrrrrSr#padding_mode_mappings r*r zAriaImageProcessor.pads` gs #s7|q'8ugt_kK\] ]  $ >u E   *     ! !6  ! !;   ug,@,FXghR]Ri '{rSr#possible_resolutions image_sizebest_resolutionrxrr$r)s r*r^z$AriaImageProcessor.get_image_patchess:.$/TU U-#E7HI 0=QR11 ?XIZ2 --m_`q-r #LZ[lm !  (;Zk l    s2B r%r&c|jd|j}|jd|j}t||f|j\}}|sd}|S||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. r9r6rA)getr9r6rr8) rLr%r& images_kwargsr9r6resized_height resized_width num_patchess r*get_number_of_image_patchesz.AriaImageProcessor.get_number_of_image_patchess|$'' t7G7GH &**+;T=P=PQ(>PTPfPf(g% *a 1?.0PS`0`dr0r r,)N)__name__ __module__ __qualname____doc__model_input_namesrBICUBICrfloatratuplerdrKrFIRSTrstrrrrrbndarrayryrrr rrr r^r __classcell__)rOs@r*r.r.Hs>D*.(,!!:>#(&*&-$('9'A'A"!K$&"!;%"! "!  "!  c3h047 "!D["!t "!"!e "!Tk"!%"!N2604%)%)#'&*"&'+$(.226/?/E/E;?B T*--B DK'$.B 4;&- B d B d B D[B t B 4KB  B TkB %t+B j(4/B &,B !11D8B HZZ49Xh 4BUBuB ZZ 49 N^   "(003659;?@zz@uS#X&%S/)BB@ @ %0 @ ++d2 @!11D8@ @D0zz0U38_-0 0 % 0 & 0,0 bjj 0d#cr,r.)&collections.abcrnumpyrbimage_processing_utilsrrrrimage_transformsr r r r r image_utilsrrrrrrrrrrutilsrr get_loggerrr\rrarr+r.__all__rIr,r*rs(%uuee   )   H %RZZSPTUWU_U_P`8+D r,