S^(hWddlZddlmZmZmZmZmZddlZddl m Z m Z m Z ddl mZmZmZmZmZddlmZmZmZmZmZmZmZmZmZddlmZdej>d e d eej>fd Z!d Z"Gd de Z#dgZ$y)N)IterableListOptionalTupleUnion)BaseImageProcessor BatchFeatureselect_best_resolution) PaddingModeconvert_to_rgbpadresizeto_channel_dimension_format) ChannelDimension ImageInputPILImageResamplingget_image_sizeinfer_channel_dimension_formatmake_flat_list_of_imagesto_numpy_array valid_imagesvalidate_preprocess_arguments) TensorTypeimage 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.array`): 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.array representing the patches.  channel_dimrN)rrangerLASTappend) rrinput_data_formatpatchesheightwidthijpatchs l/var/www/skyplay_api_hub/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 !  "" Nct||\}}|\}}||z }||z }||kr(|} ttj||z|} | | fS|} ttj||z|} | | fS)Nr)rminmathceil) rtarget_resolutionr$original_heightoriginal_width target_height target_widthscale_wscale_h new_width new_heights r+_get_patch_output_sizer;Fs&4UHY&Z#O^"3M<^+Go-G ?W#<=}M y  #  .7":;\J y  r-c2eZdZdZgdZddddddddej f deed eed e d e d e ee e e fd e e de e de e deffd Z dddddddddejdf deeeefde eeeefd e eeeefd e e d e e d e e de e de e dede eeefde ede eeeffdZdej,dededej,fdZdej,dededej,fdZej6dddfdej8dee e e e fee e e ffded eeeefde eeefde eeefdej8fd!Zdej,d"ee e e fd#e dedededeej,fd$ZxZ S)%AriaImageProcessora 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_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_cropsNiPFT image_mean image_stdmax_image_sizemin_image_sizesplit_resolutions split_imagedo_convert_rgb do_normalizeresamplec  t |di| |gd}|gd}||_||_||_||_||_|!gd}|D cgc]} | ddz| ddzf}} ||_||_||_ | |_ ycc} w)N)?rMrM)))rNr)rN)rN)rN)rN)rN)rOrP)rOr)rOrO)rOrN)rrN)rrO)rPrN)rPrO)rQrN)rRrN)rSrN)rTrNrrN) super__init__rErFrCrDrHrGrIrJrK) selfrCrDrErFrGrHrIrJrKkwargsel __class__s r+rXzAriaImageProcessor.__init__ss "6"  (J  'I,,$"&  $!y FW X"Q%#+r!us{!; X  X!2,(  !Ys Bptimagesreturn_tensors data_formatr$c z||n |j}||n |j}||n |j}||n |j}||n |j}||n |j }||n |j }| | n |j} |dvr tdt|}t|s tdt|||| |r|D cgc] } t| }} |D cgc] } t| }} | t|d} g}g}d}|D]j} |r"|j| |j || | | }n| g}|t#||kDr t#|}|D]}t%|\}}|t'||z }||k\rt't)||z||f}n|t't)||z|f}t+||| | | }||dz ||d z }}t-|d|fd|ff| | }t/j0||ft2 }d |d|dd|d f<|j5||r>|j7|d z |j|j| | }| t9|| | n|}|j5|"mt;t/j<|d t/j<|d |d | Scc} wcc} w)a! 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_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)rUrBz(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.)rJrCrDrKr)r`r$)rKr`r$rN)dtypego@)axisr>)data tensor_type)rCrDrErFrHrIrJrK ValueErrorrrrr rrget_image_patchesrGlenrmaxintrrnpzerosboolr# normalizerr stack)rYr^rCrDrErFrHrIrJrKr_r`r$rr? pixel_masksrA crop_images crop_imagehwscalenew_sizecrop_image_resizedpadding_bottom padding_rightcrop_image_paddedr@s r+ preprocesszAriaImageProcessor.preprocesssPF$.#9Zt !*!6IDNN +9+E4K^K^+9+E4K^K^%0%vay I    ; 7E"44**" 1&7 5  %g  C $4y$@ , ), 7 %j11&Q26 #CE NN C^TH .CE NN0STH%+% 1&7 &"1?!0Ln_ghi_jNj $'&(1m*<= 1&7 %! XX~~&FdS ;< =Xa[=-HQK-78"":.(,)E1$5*; )7)%'244E{Tef.& ##$56Y, 7; 7x "A > hh{;& '   SA=s J3J8rr2rcHt|||\}}t|||f||}|S)aC Resizes an image to a target resolution while maintaining aspect ratio. Args: image (np.array): 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.array: The resized and padded image. rKr$)r;r)rYrr2rKr$r:r9 resized_images r+_resize_for_patchingz'AriaImageProcessor._resize_for_patchingDs7&!7u>OQb c Iuz9&=duv r-c|\}}t|||\}}||z dz}||z dz} |j|| | f||ff} | S)zU Pad an image to a target resolution while maintaining aspect ratio. rO)padding)r;r) rYrr2r$r5r6r:r9paste_xpaste_y padded_images r+_pad_for_patchingz$AriaImageProcessor._pad_for_patching^sh '8# | 6u>OQb c I)+1 :-!3xx'0BWgDV/WxX 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. rPconstantreflectedge symmetric)rr) isinstancerjrhrrr CONSTANTREFLECT REPLICATE SYMMETRICrkr)rYrrrrr`r$padding_mode_mappings r+rzAriaImageProcessor.padns` gs #s7|q'8ugt_kK\] ]  $ >u E   *     ! !6  ! !;   ug,@,FXghR]Ri '{BDH@zz@sE#s(OXeCHo-FFG@ @ uhuo56 @ eC)9$9:; @$E#/?*?$@A@ @D0xx0U38_-0 0 % 0 & 0,0 bhh0r-r=)%r0typingrrrrrnumpyrkimage_processing_utilsr r r image_transformsr r rrr image_utilsrrrrrrrrrutilsrrrjr,r;r=__all__rVr-r+rs{* 99^^ee    RXX3dSUS[S[n8!"I+IX r-