##hdL ddlZddlZddlmZddlmZddlmZddlm Z ddl m Z m Z m Z mZddlZddlZddlmZdd lmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*er ddl+Z,ddl-Z,ej\ej\e,j^j`ej\d k\re,jbjdZ3n e,jbZ3erdd l4mZ5dd l6m7Z7e3jpe7jpe3jre7jre3jte7jte3jve7jve3jxe7jxe3jze7jziZ>e r erddl?Z?e!jeAZBedejdeDdeDejeDdfZEeeDdddeDdeDdeDeDdeDeDdeDeDdfZFGddeZGGddeZHGddeZIeGddZJeKeLeeMeLeDeKffZNdZOGddeZPdZQdZRdeDfdZSd ZTd!ZUd"ejd#eVfd$ZWdhd%eMd#eDeEfd&ZXdeeDeEeEfd#eEfd'ZYdeeDeEeEfd#eEfd(ZZd#eFfd)Z[d#ejfd*Z\ did"ejd+e eeMe]eMd,ffd#eGfd-Z^ did"ejd.e eeGeLfd#eMfd/Z_did"ejd0eGd#e]eMeMffd1Z`d2e]eMeMfd3eMd4eMd#e]eMeMffd5Zad6eKeLeeDe]ffd#eVfd7Zbd6eKeLeeDe]ffd#eVfd8Zcd9eeKeLeeDe]ffd#eVfd:Zdd9eeKeLeeDe]ffd#eVfd;Zedid"eeLdfdeJfd?Zhd@eLdAe fdBZi did@eLdAe e fdCZjd@eLdAe fdDZkd@eLdAe fdEZlejeiekeldFZm dkdGeeLdHfdIe eMdJe eMdKeLdAe e d#ejf dLZo dideeDe]eLdfdt|rtjSt|rtjSt |rtj St|rtjSt|rtjStdt|)NzUnrecognised image type ) rJrLrFrrRrrSrrTrrU ValueErrortypeimages r/get_image_typer[suE}}ueE###U}} /U }= >>r.ct|xs2t|xs%t|xst|xs t |SrD)rJrrrrrHs r/is_valid_imager]s8   vs 3 vs7K v|\_O` vdqrudvvr.imagesc.|xrtd|DS)Nc32K|]}t|ywrD)r]).0rZs r/ z*is_valid_list_of_images..sDE./Dall)r^s r/is_valid_list_of_imagesrfs  DcDVDDDr.crt|ttfr|D]}t|ryyt |syy)NFT)rElisttuple valid_imagesr])imgsrIs r/rjrjs?$u & C$  D ! r.cLt|ttfrt|dSy)NrF)rErhrir]rHs r/ is_batchedrms"#e}%c!f%% r.rZreturnc|jtjk(rytj|dk\xrtj|dkS)zV Checks to see whether the pixel values have already been rescaled to [0, 1]. Frr )dtypenpuint8minmaxrYs r/is_scaled_imagerus> {{bhh 66%=A  4"&&-1"44r.expected_ndimsc (t|r|St|r|gSt|rU|j|dzk(r t |}|S|j|k(r|g}|St d|dzd|d|jdt dt |d)a Ensure that the output is a list of images. If the input is a single image, it is converted to a list of length 1. If the input is a batch of images, it is converted to a list of images. Args: images (`ImageInput`): Image of images to turn into a list of images. expected_ndims (`int`, *optional*, defaults to 3): Expected number of dimensions for a single input image. If the input image has a different number of dimensions, an error is raised. r z%Invalid image shape. Expected either z or z dimensions, but got z dimensions.ztInvalid image type. Expected either PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray, but got .)rmrJr]ndimrhrWrX)r^rvs r/make_list_of_imagesrzs& Fxf ;;.1, ,&\F [[N *XF  78J7K4P^O_`KK= .   $V ~Q 0 r.c<t|ttfr=td|Dr+td|Dr|Dcgc] }|D]}| c}}St|ttfrXt |rMt |ds|dj dk(r|S|dj dk(r|Dcgc] }|D]}| c}}St|r7t |s|j dk(r|gS|j dk(r t|Std|cc}}wcc}}w)a| Ensure that the output is a flat list of images. If the input is a single image, it is converted to a list of length 1. If the input is a nested list of images, it is converted to a flat list of images. Args: images (`Union[List[ImageInput], ImageInput]`): The input image. Returns: list: A list of images or a 4d array of images. c3HK|]}t|ttfywrDrErhriraimages_is r/rbz+make_flat_list_of_images..K 8dE]3K "c32K|]}t|ywrDrfr~s r/rbz+make_flat_list_of_images..Ih'1Ircrz*Could not make a flat list of images from rErhrirerfrJryr]rW)r^img_listrIs r/make_flat_list_of_imagesrs 6D%=) KFK K I&I I$*?h?s???&4-(-DV-L q "fQinn&9M !9>>Q (.CH(C3CCCC Cf  6;;!#38O ;;! <  A&J KK@ Ds D.Dct|ttfr&td|Drtd|Dr|St|ttfrYt |rNt |ds|dj dk(r|gS|dj dk(r|Dcgc] }t|c}St|r9t |s|j dk(r|ggS|j dk(r t|gStdcc}w)z Ensure that the output is a nested list of images. Args: images (`Union[List[ImageInput], ImageInput]`): The input image. Returns: list: A list of list of images or a list of 4d array of images. c3HK|]}t|ttfywrDr}r~s r/rbz-make_nested_list_of_images..rrc32K|]}t|ywrDrr~s r/rbz-make_nested_list_of_images..rrcrrrz]Invalid input type. Must be a single image, a list of images, or a list of batches of images.r)r^rZs r/make_nested_list_of_imagesr s 6D%=) KFK K I&I I &4-(-DV-L q "fQinn&98O !9>>Q -34EDK4 4f  6;;!#3H:  ;;! L> ! t uu5sC;c t|ttfr|t|dttfrct|ddrRt |dds?|ddj dk(r*|Dcgc]}|Dcgc] }|D]}| c}}}}}}|St|ttfr\t|drNt |ds|dj dk(r|gS|dj dk(r]|Dcgc] }t|c}St|r9t |s|j dk(r|ggS|j dk(r t|gSt d|cc}}wcc}}}wcc}w)z Ensure that the input is a list of videos. Args: videos (`VideoInput`): Video or videos to turn into a list of videos. Returns: list: A list of videos. rrrz"Could not make batched video from )rErhrir]rJryrW)videosbatched_videos batch_listvideos r/make_batched_videosr-sN&4-(Zq D%=-QVdeklmenopeqVrF1IaL)fQil.?.?1.Dmstt[i~V:V%uVuVtFt FT5M *~fQi/H q "fQinn&98O AY^^q -34EDK4 4    6;;!#3H:  [[A L> ! 9&B CC!Wt5s- E7EE0E$Ect|stdt|tr9t |t j j rtj|St|S)NzInvalid image type: ) r]rWrXrrErFrGrqarrayrrHs r/to_numpy_arrayrLsP # /S {;<<C!Axx} C=r. num_channels.c||nd}t|tr|fn|}|jdk(rd\}}n-|jdk(rd\}}ntd|j|j||vrD|j||vr3t j d|jdtjS|j||vrtjS|j||vrtjStd) a[ Infers the channel dimension format of `image`. Args: image (`np.ndarray`): The image to infer the channel dimension of. num_channels (`int` or `Tuple[int, ...]`, *optional*, defaults to `(1, 3)`): The number of channels of the image. Returns: The channel dimension of the image. r rr)rrz(Unsupported number of image dimensions: z4The channel dimension is ambiguous. Got image shape z,. Assuming channels are the first dimension.z(Unable to infer channel dimension format) rEr?ryrWshapeloggerwarningr%r+r,)rZr first_dimlast_dims r/infer_channel_dimension_formatrUs$0#;<L&0s&CL?L zzQ" 8 q" 8CEJJ<PQQ {{9-%++h2G<2WB5;;-O{ |  %%% Y < /%%% X , .$$$ ? @@r.input_data_formatc| t|}|tjk(r|jdz S|tjk(r|jdz St d|)a Returns the channel dimension axis of the image. Args: image (`np.ndarray`): The image to get the channel dimension axis of. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the image. If `None`, will infer the channel dimension from the image. Returns: The channel dimension axis of the image. rr Unsupported data format: )rr%r+ryr,rW)rZrs r/get_channel_dimension_axisrzsd :5A,222zzA~ .33 3zzA~ 01B0CD EEr. channel_dimc| t|}|tjk(r|jd|jdfS|tjk(r|jd|jdfSt d|)a Returns the (height, width) dimensions of the image. Args: image (`np.ndarray`): The image to get the dimensions of. channel_dim (`ChannelDimension`, *optional*): Which dimension the channel dimension is in. If `None`, will infer the channel dimension from the image. Returns: A tuple of the image's height and width. r)rr%r+rr,rW)rZrs r/get_image_sizers{4U; &,,,{{2 B// (-- -{{2 B//4[MBCCr. image_size max_height max_widthcx|\}}||z }||z }t||}t||z}t||z} || fS)a Computes the output image size given the input image and the maximum allowed height and width. Keep aspect ratio. Important, even if image_height < max_height and image_width < max_width, the image will be resized to at least one of the edges be equal to max_height or max_width. For example: - input_size: (100, 200), max_height: 50, max_width: 50 -> output_size: (25, 50) - input_size: (100, 200), max_height: 200, max_width: 500 -> output_size: (200, 400) Args: image_size (`Tuple[int, int]`): The image to resize. max_height (`int`): The maximum allowed height. max_width (`int`): The maximum allowed width. )rsr?) rrrheightwidth height_scale width_scale min_scale new_height new_widths r/#get_image_size_for_max_height_widthrsV,MFE&Le#KL+.IVi'(JEI%&I y  r. annotationct|trId|vrEd|vrAt|dttfr(t |ddk(st|ddtryy)Nimage_id annotationsrTFrEdictrhrilenrs r/"is_valid_annotation_coco_detectionrs`:t$ * $ Z ' z-04- @  =) *a /:j>WXY>Z\`3a r.ct|trMd|vrId|vrEd|vrAt|dttfr(t |ddk(st|ddtryy)Nr segments_info file_namerTFrrs r/!is_valid_annotation_coco_panopticrsh:t$ * $ z ) : % z/2T5M B  ?+ , 1Z ?@[\]@^`d5e r.rc&td|DS)Nc32K|]}t|ywrD)rraanns r/rbz3valid_coco_detection_annotations..sN31#6Nrcrdrs r/ valid_coco_detection_annotationsrs N+N NNr.c&td|DS)Nc32K|]}t|ywrD)rrs r/rbz2valid_coco_panoptic_annotations..sM#05Mrcrdrs r/valid_coco_panoptic_annotationsrs MM MMr.timeoutcttdgt|tr|j ds|j drHt j jttj||j}ntjj|r t j j|}n|j dr|jdd} t!j"|j%}t j jt|}n2t|t j j r|}n t+d t j,j/|}|j1d }|S#t&$r}t)d|d |d }~wwxYw) a3 Loads `image` to a PIL Image. Args: image (`str` or `PIL.Image.Image`): The image to convert to the PIL Image format. timeout (`float`, *optional*): The timeout value in seconds for the URL request. Returns: `PIL.Image.Image`: A PIL Image. visionhttp://https://rz data:image/,r zIncorrect image source. Must be a valid URL starting with `http://` or `https://`, a valid path to an image file, or a base64 encoded string. Got z. Failed with NzuIncorrect format used for image. Should be an url linking to an image, a base64 string, a local path, or a PIL image.RGB)r load_imagerErB startswithrFrGopenrrequestsgetcontentospathisfilesplitbase64 decodebytesencode ExceptionrW TypeErrorImageOpsexif_transposeconvert)rZrb64es r/rrsvj8*-%   I &%*:*::*FIINN78<<w+O+W+W#XYE WW^^E "IINN5)E . C(+ ((8 ws|4 E399?? + D   LL ' ' .E MM% E L  ijoipp~@~AB s2A F"" G+F<<Gmetadatac |j}|j}|-|+t||z |z}||kDrtd|d|d|d|"t j d|||z t}|St j d|t}|S)a` A default sampling function that replicates the logic used in get_uniform_frame_indices, while optionally handling `fps` if `num_frames` is not provided. Args: metadata (`VideoMetadata`): `VideoMetadata` object containing metadata about the video, such as "total_num_frames" or "fps". num_frames (`int`, *optional*): Number of frames to sample uniformly. fps (`int`, *optional*): Desired frames per second. Takes priority over num_frames if both are provided. Returns: `np.ndarray`: Array of frame indices to sample. z When loading the video with fps=z, we computed num_frames=z which exceeds total_num_frames=z. Check fps or video metadata.r)rp)r;r<r?rWrqarange)r num_framesr<kwargsr; video_fpsindicess r/default_sample_indices_fnrs  00 Ico)I5;< ( (23%7PQ[P\]22B1CCac  ))A/1AJ1NVYZ N))A/s; Nr. video_pathsample_indices_fnc ttdgddl}|j|}t |j |j }|j |j}|r||z nd}tt |t|t|d}|dd|i|} d} g} |jr|j\} } | snk| | vrI| j\}}}|j| |j} | j| d|d|d|f| r| dz } | |k\rn|jr|j!| |_t%j&| |fS) av Decode a video using the OpenCV backend. Args: video_path (`str`): Path to the video file. sample_indices_fn (`Callable`): A callable function that will return indices at which the video should be sampled. If the video has to be loaded using by a different sampling technique than provided by `num_frames` or `fps` arguments, one should provide their own `sample_indices_fn`. If not provided, simple uniform sampling with fps is performed. Example: def sample_indices_fn(metadata, **kwargs): return np.linspace(0, metadata.total_num_frames - 1, num_frames, dtype=int) Returns: Tuple[`np.array`, `VideoMetadata`]: A tuple containing: - Numpy array of frames in RGB (shape: [num_frames, height, width, 3]). - `VideoMetadata` object. cv2rNopencvr;r<r=r>rr r-)rread_video_opencvr VideoCapturer?rCAP_PROP_FRAME_COUNT CAP_PROP_FPSr:rAisOpenedreadrcvtColor COLOR_BGR2RGBappendreleaseframes_indicesrqstack)rrrrrr;rr=rrindexframessuccessframerrchannels r/rr?s_2'%1   Z (E599S%=%=>? #**+I/8)+aH-.E)4DuU]nvH <  QJE $ $  ..  MMO%H 88F X %%r.c Xttdgddlm}m}|||d}|j }t |}|r||z nd}tt|t|t|d} |dd| i|} |j| j} | | _ | | fS)a Decode a video using the Decord backend. Args: video_path (`str`): Path to the video file. sample_indices_fn (`Callable`, *optional*): A callable function that will return indices at which the video should be sampled. If the video has to be loaded using by a different sampling technique than provided by `num_frames` or `fps` arguments, one should provide their own `sample_indices_fn`. If not provided, simple uniform sampling with fps is performed. Example: def sample_indices_fn(metadata, **kwargs): return np.linspace(0, metadata.total_num_frames - 1, num_frames, dtype=int) Returns: Tuple[`np.array`, `VideoMetadata`]: A tuple containing: - Numpy array of frames in RGB (shape: [num_frames, height, width, 3]). - `VideoMetadata` object. decordr) VideoReadercpu)urictxrrr-) rread_video_decordr r r  get_avg_fpsrr:r?rA get_batchasnumpyr) rrrr r vrrr;r=rrrs r/rrxs2'(4' Q 0B I2w/8)+aH-.E)4DuU]nvH <.sample_indices_fn_func=s,Xc*RUcYbc cr.zhttps://www.youtube.comzhttp://www.youtube.comzETo load a video from YouTube url you have to install `yt_dlp` first.yt_dlpr) YoutubeDLrrzVIncorrect format used for video. Should be an url linking to an video or a local path.)rr*zlIf you are trying to load a video from URL, you can decode the video only with `pyav` or `decord` as backendr rrr*zYou chose backend=zf for loading the video but the required library is not found in your environment Make sure to install z before loading the video.)rWrr ImportErrorr load_videor8r9rrdownloadgetvaluerrrrrrr]rErhrirrrrrVIDEO_DECODERS)rrr<r3rrr7r9bufferf bytes_objfile_obj video_is_url video_decoderrs `` r/r;r;s.N :16G6O q    d3 12e6F6FG_6`"$ef f*xj1$ V $ ik Q JJw   OO% 9%   ) $(8(8(D8<<.667    :edE]#CW\]^W_H`pqq##I.N%2B2B:2NL#<< z   ! "w(':!g&7 "w(':(*w-/G  *$$+9,F H  #7+M#H.?J6JOE8 (?K    s$H  HH H H  H*c <t|ttfrjt|rDt|dttfr+|Dcgc]}|Dcgc]}t ||c}c}}S|Dcgc]}t ||c}St ||Scc}wcc}}wcc}w)aLoads images, handling different levels of nesting. Args: images: A single image, a list of images, or a list of lists of images to load. timeout: Timeout for loading images. Returns: A single image, a list of images, a list of lists of images. rr)rErhrirr)r^r image_grouprZs r/ load_imagesrGrs&4-( v;:fQi$?eklVa[QEZw7Ql lDJK5Jug6K K&'22 RlKs B B B*BB do_rescalerescale_factor do_normalize image_mean image_stddo_padsize_divisibilitydo_center_crop crop_size do_resizer-resamplePILImageResamplingc |r | td|r | td|r|| td|r | td| r| | tdyy)a Checks validity of typically used arguments in an `ImageProcessor` `preprocess` method. Raises `ValueError` if arguments incompatibility is caught. Many incompatibilities are model-specific. `do_pad` sometimes needs `size_divisor`, sometimes `size_divisibility`, and sometimes `size`. New models and processors added should follow existing arguments when possible. Nz=`rescale_factor` must be specified if `do_rescale` is `True`.zzDepending on the model, `size_divisibility`, `size_divisor`, `pad_size` or `size` must be specified if `do_pad` is `True`.zP`image_mean` and `image_std` must both be specified if `do_normalize` is `True`.z<`crop_size` must be specified if `do_center_crop` is `True`.zA`size` and `resample` must be specified if `do_resize` is `True`.)rW) rHrIrJrKrLrMrNrOrPrQr-rRs r/validate_preprocess_argumentsrUs,n,XYY #+ I  +y/@kll)+WXXdlh&6\]]'7yr.ceZdZdZdZddZdZdejde e e fdejfd Z dd Z d Zdd Zdd ZdZdZddZy)ImageFeatureExtractionMixinzD Mixin that contain utilities for preparing image features. ct|tjjtjfs$t |st dt|dyy)Nz Got type zS which is not supported, only `PIL.Image.Image`, `np.array` and `torch.Tensor` are.)rErFrGrqndarrayrrWrXselfrZs r/_ensure_format_supportedz4ImageFeatureExtractionMixin._ensure_format_supportedsQ%#))//2::!>?X]H^DK=)&& I_?r.Nc|j|t|r|j}t|tj r|'t|j dtj}|jdk(r$|jddvr|jddd}|r|dz}|jtj}tjj|S|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`): The image to convert to the PIL Image format. 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, `False` otherwise. rrrr r)r\rrOrErqrYflatfloatingryr transposeastyperrrFrG fromarray)r[rZrescales r/ to_pil_imagez(ImageFeatureExtractionMixin.to_pil_images %%e, 5 !KKME eRZZ ($UZZ]BKK@zzQ5;;q>V#;1a0 LL*E99&&u- - r.c|j|t|tjjs|S|j dS)z Converts `PIL.Image.Image` to RGB format. Args: image (`PIL.Image.Image`): The image to convert. r)r\rErFrGrrZs r/ convert_rgbz'ImageFeatureExtractionMixin.convert_rgbs8 %%e,%1L}}U##r.rZscalernc.|j|||zS)z7 Rescale a numpy image by scale amount )r\)r[rZrhs r/rdz#ImageFeatureExtractionMixin.rescales %%e,u}r.c|j|t|tjjrt j |}t |r|j}|'t|jdtjn|}|r/|j|jtjd}|r"|jdk(r|jddd}|S)a Converts `image` to a numpy array. Optionally rescales it and puts the channel dimension as the first dimension. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image to convert to a NumPy array. rescale (`bool`, *optional*): Whether or not to apply the scaling factor (to make pixel values floats between 0. and 1.). Will default to `True` if the image is a PIL Image or an array/tensor of integers, `False` otherwise. channel_first (`bool`, *optional*, defaults to `True`): Whether or not to permute the dimensions of the image to put the channel dimension first. rp?rrr )r\rErFrGrqrrrOr_integerrdrbfloat32ryra)r[rZrd channel_firsts r/rz*ImageFeatureExtractionMixin.to_numpy_arrays %%e, eSYY__ -HHUOE 5 !KKME;B?*UZZ]BJJ7PW LLbjj!99EE UZZ1_OOAq!,E r.c|j|t|tjjr|St |r|j d}|St j|d}|S)z Expands 2-dimensional `image` to 3 dimensions. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image to expand. r)axis)r\rErFrGr unsqueezerq expand_dimsrZs r/rrz'ImageFeatureExtractionMixin.expand_dimss_ %%e, eSYY__ -L 5 !OOA&E NN5q1E r.c|j|t|tjjr|j |d}nw|rut|t j r0|j|jt jd}n+t|r |j|jd}t|t j rt|t j s.t j|j|j}t|t j st j|j|j}nt|rddl}t||js?t|t j r|j |}n|j"|}t||js?t|t j r|j |}n|j"|}|j$dk(r)|j&ddvr||ddddfz |ddddfz S||z |z S)a  Normalizes `image` with `mean` and `std`. Note that this will trigger a conversion of `image` to a NumPy array if it's a PIL Image. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image to normalize. mean (`List[float]` or `np.ndarray` or `torch.Tensor`): The mean (per channel) to use for normalization. std (`List[float]` or `np.ndarray` or `torch.Tensor`): The standard deviation (per channel) to use for normalization. rescale (`bool`, *optional*, defaults to `False`): Whether or not to rescale the image to be between 0 and 1. If a PIL image is provided, scaling will happen automatically. T)rdrkrNrr)r\rErFrGrrqrYrdrbrmrrArrprNTensor from_numpytensorryr)r[rZmeanstdrdrNs r/ normalizez%ImageFeatureExtractionMixin.normalize$s %%e, eSYY__ -''t' eRZZ (dBJJ/xx~,,U[[9c2::.hhsm**5;;7 U # dELL1dBJJ/+5++D1D'5<<-Dc5<<0c2::.*%**3/C&%,,s+C ::?u{{1~7DD$//3q$}3EE EDLC' 'r.c||ntj}|j|t|tj j s|j |}t|tr t|}t|tst|dk(r|rt|tr||fn |d|df}n|j\}}||kr||fn||f\}} t|tr|n|d} || k(r|S| t| | z|z } } |.|| krtd|d|| |kDrt|| z| z |} } ||kr| | fn| | f}|j||S)a Resizes `image`. Enforces conversion of input to PIL.Image. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image to resize. size (`int` or `Tuple[int, 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). resample (`int`, *optional*, defaults to `PILImageResampling.BILINEAR`): The filter to user for resampling. 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*, defaults to `None`): 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`. Returns: image: A resized `PIL.Image.Image`. r rz max_size = zN must be strictly greater than the requested size for the smaller edge size = )rR)rSBILINEARr\rErFrGrerhrir?rr-rWresize) r[rZr-rRdefault_to_squaremax_sizerrshortlongrequested_new_short new_shortnew_longs r/r|z"ImageFeatureExtractionMixin.resizeXsy< (389K9T9T %%e,%1%%e,E dD !;D dC CIN '1$'<d|47DQRGBT % v16&ufovuo t.8s.Cda#// L&93?RUY?Y\a?a;b8 '#66()(4@@DvG (*.1(Y2F2Q.RT\8 05 8,hPYEZ||D8|44r.c|j|t|ts||f}t|st|tj rP|j dk(r|j|}|jddvr|jddn|jdd}n|jd|jdf}|d|dz dz}||dz}|d|dz dz}||dz}t|tjjr|j||||fS|jddvrdnd}|sKt|tj r|jddd}t|r|jddd}|dk\r!||dkr|dk\r||dkr |d||||fS|jdd t|d|dt|d|dfz} t|tj rt j || } nt|r|j#| } | d |dz dz} | |dz} | d |dz dz} | |dz}| d| | | |f<|| z }|| z }|| z }|| z }| dtd|t%| jd |td|t%| jd |f} | S) a Crops `image` to the given 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 has the size asked). Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor` of shape (n_channels, height, width) or (height, width, n_channels)): The image to resize. size (`int` or `Tuple[int, int]`): The size to which crop the image. Returns: new_image: A center cropped `PIL.Image.Image` or `np.ndarray` or `torch.Tensor` of shape: (n_channels, height, width). rrrr NTF.r)rr)r\rErirrqrYryrrrr-rFrGcroprapermutert zeros_like new_zerosrs)r[rZr- image_shapetopbottomleftrightrn new_shape new_imagetop_pad bottom_padleft_pad right_pads r/ center_cropz'ImageFeatureExtractionMixin.center_crops %%e,$&$1a7{1~- bMKN2q8{1~- AF #wz)8I+==> w'   Qs9??2#6??QPST]TcTcdfTginPoAo o r.c|j|t|tjjr|j |}|dddddddfS)a Flips the channel order of `image` from RGB to BGR, or vice versa. Note that this will trigger a conversion of `image` to a NumPy array if it's a PIL Image. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image whose color channels to flip. If `np.ndarray` or `torch.Tensor`, the channel dimension should be first. Nr)r\rErFrGrrZs r/flip_channel_orderz.ImageFeatureExtractionMixin.flip_channel_ordersI %%e, eSYY__ -''.ETrT1aZ  r.c||ntjj}|j|t |tjjs|j |}|j ||||||S)a Returns a rotated copy of `image`. This method returns a copy of `image`, rotated the given number of degrees counter clockwise around its centre. Args: image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): The image to rotate. If `np.ndarray` or `torch.Tensor`, will be converted to `PIL.Image.Image` before rotating. Returns: image: A rotated `PIL.Image.Image`. )rRexpandcenter translate fillcolor)rFrGNEARESTr\rErerotate)r[rZanglerRrrrrs r/rz"ImageFeatureExtractionMixin.rotatesn (389J9J %%e,%1%%e,E|| HVFicl  r.rD)NT)F)NTN)NrNNN)r(r)r*__doc__r\rergrqrYr rAr?rdrrrryr|rrrr-r.r/rWrWsj< $RZZeSj0Abjj@(2(hA5FIV!" r.rWannotation_formatsupported_annotation_formatsc||vrtdtd||tjurt |s td|tj urt |s tdyy)NzUnsupported annotation format: z must be one of zInvalid COCO detection annotations. Annotations must a dict (single image) or list of dicts (batch of images) with the following keys: `image_id` and `annotations`, with the latter being a list of annotations in the COCO format.zInvalid COCO panoptic annotations. Annotations must a dict (single image) or list of dicts (batch of images) with the following keys: `image_id`, `file_name` and `segments_info`, with the latter being a list of annotations in the COCO format.)rWrr1r4rr5r)rrrs r/validate_annotationsrs  <<:6(BRSoRpqrr,;;;/ <B  ,:::.{;M <;r.valid_processor_keyscaptured_kwargsct|jt|}|r+dj|}tj d|dyy)Nz, zUnused or unrecognized kwargs: rx)set differencejoinrr)rr unused_keysunused_key_strs r/validate_kwargsr)sJo&11#6J2KLK;/88HJKr.T)frozenceZdZUdZdZeeed<dZeeed<dZ eeed<dZ eeed<dZ eeed<dZ eeed<d Z y) SizeDictz> Hashable dictionary to store image size information. Nrr longest_edge shortest_edgerrcPt||r t||Std|d)NzKey z not found in SizeDict.)hasattrgetattrKeyError)r[keys r/ __getitem__zSizeDict.__getitem__>s. 4 4% %cU"9:;;r.)r(r)r*rrr r?r@rrrrrrr-r.r/rr1sb!FHSM E8C="&L(3-&#'M8C=' $J $#Ix}#rr;rGrUrWrrrr-r.r/rs $&!;;"w}}]W]]3??3@@A]W]]SZE[[ YY11 YY!4<  & &(9(A(A  " "$5$9$9  ' '):)C)C  & &(9(A(A  & &(9(A(A  & &(9(A(A + '   H %rzz>48I3JDQSQ[Q[L\^bcq^rr   !l n    | $|$ 9\9   c5c4:!5667F  ?wEDE  52::5$5$$D2::NR"A ::"A%-eCsCx4H.I%J"A"ALTXF ::F*259I39N3O*PFF0D"**D3CDuUXZ]U]D0!c3h!!! 38_ !> 4U4;=O8O3P UY  $sE$+ "&^+,&^T\ \ ~ '"'(8#(=">d 2L$s)Ld3iL $<<