o wif@sddlmZddlmZmZddlmZmZmZm Z ddl Z ddl m Z mZmZddlmZmZmZmZmZddlmZmZmZmZmZmZmZmZmZm Z m!Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+dd l,m-Z-e*rwdd lm.Z.e'r~ddl/Z/e(rdd lm0Z0e)rddl1m2Z3n ddl4m2Z3ndZ0e+5e6Z7edddddddddddddddej8fdee9dee:dee9dee e:e;e:fdee e:e;e:fdee9dee<dee9deedee9deededdee e=e%fdeefd d!Z>d8d"d#d$ee<d%d#fd&d'Z?d(eed%e;efd)d*Z@d+e;d#d%eAe<fd,d-ZBd.e e jCd#fd/e safe_squeezeus rEvaluescCsddt|DS)zO Return the maximum value across all indices of an iterable of values. cSsg|]}t|qSr=)max).0values_ir=r=r> z&max_across_indices..)zip)rFr=r=r>max_across_indicessrMimagescCs tdd|D\}}}||fS)zH Get the maximum height and width across all images in a batch. cSsg|]}|jqSr=)shaperHimgr=r=r>rJsz(get_max_height_width..)rM)rN_ max_height max_widthr=r=r>get_max_height_widthsrUimage patch_sizecCsjg}t|tjd\}}td||D]!}td||D]}|dd||||||f}||qq|S)a6 Divides an image into patches of a specified size. Args: image (`Union[np.array, "torch.Tensor"]`): The input image. patch_size (`int`): The size of each patch. Returns: list: A list of Union[np.array, "torch.Tensor"] representing the patches. ) channel_dimrN)rrr<rangeappend)rVrWpatchesheightwidthijpatchr=r=r>divide_to_patchess" rac@seZdZUeeed<eeeefed<eeed<ee ded<eeed<eeeefed<eeed<ee ee fed <eeed <ee e e e fed <ee e e e fed <eeed <ee ee fed<ee ed<ee ee fed<eded<eeed<dS)DefaultFastImageProcessorKwargsr5r6default_to_squarer&F.InterpolationModer7r3r4r,r-r.r/r0do_convert_rgbr8r9input_data_format torch.devicedevicedisable_groupingN)__name__ __module__ __qualname__rbool__annotations__dictstrintrfloatlistrrr=r=r=r>rbs$        rbF)totalcsXeZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZejZdZdZdgZeZdZdeeddffdd Z  dLd d d ed d dedd f ddZe  dLd d dee e fd e!d dedd f ddZ"d d de#dd fddZ$d d de%e#e&e#fde%e#e&e#fdd fddZ'e(dd      dMde!ede!e%e#e)e#fde!e%e#e)e#fd e!ed!e!e#d"e!d#defd$d%Z*d&d d ed!e#dede%e#e)e#fde%e#e)e#fdd fd'd(Z+d d d e,e-e fdd fd)d*Z.d e/de/fd+d,Z0de,fd-d.Z1d&e/de/fd/d0Z2   dNd e/d1e!ed2e!e%e-efd"e!d#dd f d3d4Z3   dNd&e/d1e!ed2e!e%e-efd"e!d#de)d f d5d6Z4      dMd e!ed7e!ed8e!ede!e%e#e)e#fde!e%e#e)e#fd9e!ede,fd:d;Z5            dOd e!ed!e!e#de!ede!e%e#ee#fde!e%e#ee#fde!e%d?d@e!e%e-e6fd9e!efdAdBZ7d&e/deede8fdCdDZ9e:d&e/deede8fdEdFZ;d&e)d dS)PBaseImageProcessorFastNTgp? pixel_valueskwargsrCc stjdi|||}|d|j}|dur$t||d|jdnd|_|d|j}|dur8t|ddnd|_|jj D]}||d}|durTt |||qAt ||t ||dqAt |jj |_dS)Nr6rcr6rcr4 param_namer=)super__init__filter_out_unused_kwargspopr6r rcr4 valid_kwargsrokeyssetattrgetattrrt_valid_kwargs_names)selfrxr6r4keykwarg __class__r=r>r}s  zBaseImageProcessorFast.__init__rVrAr6 interpolationre antialiascKs|dur|ntjj}|jr|jrt|dd|j|j}n8|jr-t||jdtj d}n*|j rB|j rBt |dd|j |j }n|j rO|jrO|j |jf}ntd|dtjrgtrg|||||Stj||||dS)a@ Resize an image to `(size["height"], size["width"])`. Args: image (`torch.Tensor`): Image to resize. size (`SizeDict`): Dictionary in the format `{"height": int, "width": int}` specifying the size of the output image. interpolation (`InterpolationMode`, *optional*, defaults to `InterpolationMode.BILINEAR`): `InterpolationMode` filter to use when resizing the image e.g. `InterpolationMode.BICUBIC`. Returns: `torch.Tensor`: The resized image. NF)r6rcrgzjSize must contain 'height' and 'width' keys, or 'max_height' and 'max_width', or 'shortest_edge' key. Got .rr)FInterpolationModeBILINEAR shortest_edge longest_edgerr6rrr<rSrTrr\r]r;torchcompiler is_compilingr%compile_friendly_resizeresize)rrVr6rrrxnew_sizer=r=r>rs4   zBaseImageProcessorFast.resizercCs|jtjkr5|d}tj||||d}|d}t|dkd|}t|dkd|}|tj}|Stj||||d}|S)z{ A wrapper around `F.resize` so that it is compatible with torch.compile when the image is a uint8 tensor. rr) dtyperuint8rsrrwhereroundto)rVrrrr=r=r>r#s z.BaseImageProcessorFast.compile_friendly_resizescalecKs||S)a? Rescale an image by a scale factor. image = image * scale. Args: image (`torch.Tensor`): Image to rescale. scale (`float`): The scaling factor to rescale pixel values by. Returns: `torch.Tensor`: The rescaled image. r=)rrVrrxr=r=r>rescale8szBaseImageProcessorFast.rescalemeanstdcKst|||S)a Normalize an image. image = (image - image_mean) / image_std. Args: image (`torch.Tensor`): Image to normalize. mean (`torch.Tensor`, `float` or `Iterable[float]`): Image mean to use for normalization. std (`torch.Tensor`, `float` or `Iterable[float]`): Image standard deviation to use for normalization. Returns: `torch.Tensor`: The normalized image. )r normalize)rrVrrrxr=r=r>rLsz BaseImageProcessorFast.normalizer)r*r.r/r0r,r-rirhcCsB|r|rtj||dd|}tj||dd|}d}|||fS)N)rig?F)rr@)rr.r/r0r,r-rir=r=r>!_fuse_mean_std_and_rescale_factorcs   z8BaseImageProcessorFast._fuse_mean_std_and_rescale_factorrNcCsR|j||||||jd\}}}|r||jtjd||}|S|r'|||}|S)z/ Rescale and normalize images. )r.r/r0r,r-ri)r)rrirrrfloat32r)rrNr,r-r.r/r0r=r=r>rescale_and_normalizets    z,BaseImageProcessorFast.rescale_and_normalizecKs>|jdus |jdurtd|t||d|dfS)a Center crop an image to `(size["height"], size["width"])`. If the input size is smaller than `crop_size` along any edge, the image is padded with 0's and then center cropped. Args: image (`"torch.Tensor"`): Image to center crop. size (`dict[str, int]`): Size of the output image. Returns: `torch.Tensor`: The center cropped image. Nz=The size dictionary must have keys 'height' and 'width'. Got r\r])r\r]r;rr center_crop)rrVr6rxr=r=r>rsz"BaseImageProcessorFast.center_cropcCt|S)a' Converts an image to RGB format. Only converts if the image is of type PIL.Image.Image, otherwise returns the image as is. Args: image (ImageInput): The image to convert. Returns: ImageInput: The converted image. )r )rrVr=r=r>r z%BaseImageProcessorFast.convert_to_rgbcCsB|jdur|S|jD]}||vrtd|d||q |S)zJ Filter out the unused kwargs from the kwargs dictionary. Nz!This processor does not use the `z ` parameter. It will be ignored.) unused_kwargslogger warning_oncer)rrx kwarg_namer=r=r>r~s   z/BaseImageProcessorFast.filter_out_unused_kwargscCr)z Prepare the images structure for processing. Args: images (`ImageInput`): The input images to process. Returns: `ImageInput`: The images with a valid nesting. )r)rrNr=r=r>_prepare_images_structurerz0BaseImageProcessorFast._prepare_images_structurerfrgcCst|}|tjtjtjfvrtd||r||}|tjkr't|}n |tjkr3t | }|dur;t |}|t jkrI|ddd }|durR||}|S)NzUnsupported input image type rr )rrPILTORCHNUMPYr;r r pil_to_tensorr from_numpy contiguousrrLASTpermuter)rrVrfrgri image_typer=r=r>_process_images       z%BaseImageProcessorFast._process_imagecsj||}t|j|||dt|dkot|dttf}|r*fdd|D}|Sfdd|D}|S)a4 Prepare the input images for processing. Args: images (`ImageInput`): The input images to process. do_convert_rgb (`bool`, *optional*): Whether to convert the images to RGB. input_data_format (`str` or `ChannelDimension`, *optional*): The input data format of the images. device (`torch.device`, *optional*): The device to put the processed images on. Returns: List[`torch.Tensor`]: The processed images. )rfrgrircsg|] }fdd|DqS)cg|]}|qSr=r=rPprocess_image_partialr=r>rJrKzKBaseImageProcessorFast._prepare_input_images...r=)rH nested_listrr=r>rJsz@BaseImageProcessorFast._prepare_input_images..crr=r=rPrr=r>rJrK)rrrlen isinstancerttuple)rrNrfrgrihas_nested_structureprocessed_imagesr=rr>_prepare_input_imagess  z,BaseImageProcessorFast._prepare_input_imagesr4rcr9cKs|duri}|durtd it||d}|dur$td it|dd}t|tr-t|}t|tr6t|}|dur=tj}||d<||d<||d<||d<||d<||d <|S) z Update kwargs that need further processing before being validated Can be overridden by subclasses to customize the processing of kwargs. Nryr4rzr6rcr/r0r9r=)rr rrtrrr<)rr6r4rcr/r0r9rxr=r=r>_further_process_kwargss&  z.BaseImageProcessorFast._further_process_kwargsr5r3r7rdr8c Ks$t||||||||| | | | d dS)z@ validate the kwargs for the preprocess method. ) r,r-r.r/r0r5r6r3r4r7r8r9N)r?)rr,r-r.r/r0r5r6r3r4r7r8r9rxr=r=r>_validate_preprocess_kwargsCs z2BaseImageProcessorFast._validate_preprocess_kwargscOs|j|g|Ri|SN) preprocess)rrNargsrxr=r=r>__call__eszBaseImageProcessorFast.__call__c Ost||jd|jD] }||t||dq |d}|d}|d}|j||||d}|jd i|}|jd i||d}t |t t frQt |n||d<|d|d |j |g|Ri|S) N)captured_kwargsvalid_processor_keysrfrgri)rNrfrgrir7rrcr9r=)rrr setdefaultrrrrrrrrr&r' _preprocess) rrNrrxrrfrgrir7r=r=r>rhs"       z!BaseImageProcessorFast.preprocessrjc Kst|| d\}}i}|D]\}}|r|j|||d}|||<qt||}t|| d\}}i}|D]\}}|r@|||}||||| | | }|||<q4t||}| r]tj|ddn|}td|i| dS)N)rj)rVr6rr)dimrw)data tensor_type) ritemsrrrrrstackr )rrNr5r6rr3r4r,r-r.r/r0rjr8rxgrouped_imagesgrouped_images_indexresized_images_groupedrOstacked_imagesresized_imagesprocessed_images_groupedrr=r=r>rs&      z"BaseImageProcessorFast._preprocesscs&t}|dd|dd|S)N_valid_processor_keysr)r|to_dictr)r encoder_dictrr=r>rs   zBaseImageProcessorFast.to_dict)NT)NNNNNN)NNN) NNNNNNNNNNNN)?rkrlrmr7r/r0r6rcr4r5r3r,r-r.rfr8rr<r9rgrimodel_input_namesrbrrrr}rrnr staticmethodrrrrrrsrrrrrrtrrrprqrrr r~rrrrrrr rrrrr __classcell__r=r=rr>rvs 6            % + &     "'      ,rvr)Gcollections.abcr functoolsrrtypingrrrrnumpynpimage_processing_utilsr r r image_transformsr rrrr image_utilsrrrrrrrrrrrprocessing_utilsrutilsrrr r!r"r#r$utils.import_utilsr%r&rr'torchvision.transforms.v2r(rtorchvision.transforms get_loggerrkrr<rnrsrtrrrqr?rErMrrUarrayrarbrvr=r=r=r>s 4 $          *