o  hd@spddlZddlZddlmZddlmZddlmZddlm 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*erddl+Z,ddl-Z,e.e.e,j/j0e.d kre,j1j2Z3ne,j1Z3erdd l4mZ5dd l6m7Z7e3j8e7j8e3j9e7j9e3j:e7j:e3j;e7j;e3je rerddl?Z?e!@eAZBedejCdeDdeDejCeDdfZEeeDdddeDdeDdeDeDdeDeDdeDeDdfZFGdddeZGGdddeZHGdddeZIeGdddZJeKeLeeMeLeDeKffZNddZOGdddeZPddZQdd ZRd!eDfd"d#ZSd$d%ZTd&d'ZUd(ejCd)eVfd*d+ZWdd-eMd)eDeEfd.d/ZXd!eeDeEeEfd)eEfd0d1ZYd!eeDeEeEfd)eEfd2d3ZZd)eFfd4d5Z[d)ejCfd6d7Z\ dd(ejCd8e eeMe]eMd9ffd)eGfd:d;Z^ dd(ejCdZ_dd(ejCd?eGd)e]eMeMffd@dAZ`dBe]eMeMfdCeMdDeMd)e]eMeMffdEdFZadGeKeLeeDe]ffd)eVfdHdIZbdGeKeLeeDe]ffd)eVfdJdKZcdLeeKeLeeDe]ffd)eVfdMdNZddLeeKeLeeDe]ffd)eVfdOdPZedd(eeLdfdQe efd)dfdRdSZgddTeJfdUdVZhdWeLdXe fdYdZZi ddWeLdXe e fd[d\ZjdWeLdXe fd]d^ZkdWeLdXe fd_d`ZlejeiekeldaZm   b ddceeLddfdee eMdfe eMdgeLdXe e d)ejnf dhdiZo dd!eeDe]eLdfdQe efd)edeDdeDeDdffdjdkZp            ddle eVdme efdne eVdoe eefeDeffdpe eefeDeffdqe eVdre eMdse eVdte eKeLeMfdue eVdve eKeLeMfdwe dxfdydzZqGd{d|d|Zrd}eHd~e]eHd9fdLeDeKd)dfddZsdeDeLdeDeLfddZteddGdddZudS)N)Iterable)redirect_stdout) dataclass)BytesIO) TYPE_CHECKINGCallableOptionalUnion)version) ExplicitEnumis_av_availableis_cv2_availableis_decord_available is_jax_tensoris_numpy_array is_tf_tensoris_torch_availableis_torch_tensoris_torchvision_availableis_vision_availableis_yt_dlp_availableloggingrequires_backendsto_numpy)IMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STDIMAGENET_STANDARD_MEANIMAGENET_STANDARD_STDOPENAI_CLIP_MEANOPENAI_CLIP_STDz9.1.0)io)InterpolationModezPIL.Image.Imagez torch.Tensorz np.ndarrayc@eZdZdZdZdS)ChannelDimensionchannels_first channels_lastN)__name__ __module__ __qualname__FIRSTLASTr,r,l/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/transformers/image_utils.pyr$fr$c@r#)AnnotationFormatcoco_detection coco_panopticN)r'r(r)COCO_DETECTION COCO_PANOPTICr,r,r,r-r/kr.r/c@seZdZejjZejjZdS)AnnotionFormatN)r'r(r)r/r2valuer3r,r,r,r-r4ps r4c@s.eZdZUeed<eed<eed<eed<dS) VideoMetadatatotal_num_framesfpsduration video_backendN)r'r(r)int__annotations__floatstrr,r,r,r-r6us  r6cCsto t|tjjSN)r isinstancePILImageimgr,r,r- is_pil_imagesrEc@s eZdZdZdZdZdZdZdS) ImageTypepillowtorchnumpy tensorflowjaxN)r'r(r)rATORCHNUMPY TENSORFLOWJAXr,r,r,r-rFs rFcCsXt|rtjSt|rtjSt|rtjSt|rtjSt |r#tj St dt |)NzUnrecognised image type ) rErFrArrLrrMrrNrrO ValueErrortypeimager,r,r-get_image_typesrTcCs(t|pt|pt|pt|pt|Sr?)rErrrrrCr,r,r-is_valid_images(rUimagescCs|o tdd|DS)Ncs|]}t|VqdSr?)rU.0rSr,r,r- z*is_valid_list_of_images..allrVr,r,r-is_valid_list_of_imagesr_cCs:t|ttfr|D] }t|sdSq dSt|sdSdS)NFT)r@listtuple valid_imagesrU)imgsrDr,r,r-rcsrccCst|ttfr t|dSdS)NrF)r@rarbrUrCr,r,r- is_batcheds rerSreturncCs,|jtjkrdSt|dkot|dkS)zV Checks to see whether the pixel values have already been rescaled to [0, 1]. Frr )dtypenpuint8minmaxrRr,r,r-is_scaled_images rlexpected_ndimscCst|r|St|r |gSt|r9|j|dkrt|}|S|j|kr(|g}|Std|dd|d|jdtdt|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 .)rerErUndimrarPrQ)rVrnr,r,r-make_list_of_imagess*  rqcCst|ttfr tdd|Dr tdd|Dr dd|DSt|ttfrHt|rHt|ds8|djdkr:|S|djdkrHd d|DSt|rat|sU|jdkrX|gS|jdkrat|Std |) 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. cs|] }t|ttfVqdSr?r@rarbrYimages_ir,r,r-rZz+make_flat_list_of_images..csrWr?r_rtr,r,r-rZr[cSg|] }|D]}|qqSr,r,rYimg_listrDr,r,r- z,make_flat_list_of_images..rrmcSrxr,r,ryr,r,r-r{r|z*Could not make a flat list of images from r@rarbr]r_rErprUrPr^r,r,r-make_flat_list_of_imagess$  rcCst|ttfrtdd|Drtdd|Dr|St|ttfrDt|rDt|ds3|djdkr6|gS|djdkrDdd|DSt|r_t|sQ|jdkrU|ggS|jdkr_t|gStd ) 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. csrrr?rsrtr,r,r-rZrvz-make_nested_list_of_images..csrWr?rwrtr,r,r-rZr[rrmr}cSg|]}t|qSr,rarXr,r,r-r{!z.make_nested_list_of_images..z]Invalid input type. Must be a single image, a list of images, or a list of batches of images.r~r^r,r,r-make_nested_list_of_images s$   rcCst|ttfr2t|dttfr2t|ddr2t|dds0|ddjdkr0dd|D}|St|ttfr^t|dr^t|dsL|djdkrO|gS|djdkr]dd|DSnt|ryt|sk|jdkro|ggS|jdkryt|gStd|)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. rr}cSsg|] }dd|DqS)cSrxr,r,)rY batch_listvideor,r,r-r{9r|z2make_batched_videos...r,)rYbatched_videosr,r,r-r{9r|z'make_batched_videos..rmcSrr,r)rYrr,r,r-r{Arz"Could not make batched video from )r@rarbrUrErprP)videosr,r,r-make_batched_videos-s 0 "  rcCs@t|s tdt|trt|tjjrt|St |S)NzInvalid image type: ) rUrPrQrr@rArBrharrayrrCr,r,r-to_numpy_arrayLs  r num_channels.cCs|dur|nd}t|tr|fn|}|jdkrd\}}n|jdkr&d\}}ntd|j|j||vrI|j||vrItd|jdtjS|j||vrStjS|j||vr]tj Std ) 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. Nr rmrm)rr}z(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) r@r;rprPshapeloggerwarningr$r*r+)rSr first_dimlast_dimr,r,r-infer_channel_dimension_formatUs"     rinput_data_formatcCsF|durt|}|tjkr|jdS|tjkr|jdStd|)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. Nrmr Unsupported data format: )rr$r*rpr+rP)rSrr,r,r-get_channel_dimension_axiszs    r channel_dimcCsZ|durt|}|tjkr|jd|jdfS|tjkr&|jd|jdfStd|)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. Nr)rr$r*rr+rP)rSrr,r,r-get_image_sizes   r image_size max_height max_widthc CsB|\}}||}||}t||}t||}t||} || 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. )rjr;) rrrheightwidth height_scale width_scale min_scale new_height new_widthr,r,r-#get_image_size_for_max_height_widths   r annotationcCsVt|tr)d|vr)d|vr)t|dttfr)t|ddks't|ddtr)dSdS)Nimage_id annotationsrTFr@dictrarblenrr,r,r-"is_valid_annotation_coco_detections"rcCs^t|tr-d|vr-d|vr-d|vr-t|dttfr-t|ddks+t|ddtr-dSdS)Nr segments_info file_namerTFrrr,r,r-!is_valid_annotation_coco_panoptics"rrcCtdd|DS)NcsrWr?)rrYannr,r,r-rZr[z3valid_coco_detection_annotations..r\rr,r,r- valid_coco_detection_annotationsrcCr)NcsrWr?)rrr,r,r-rZr[z2valid_coco_panoptic_annotations..r\rr,r,r-valid_coco_panoptic_annotationsrrtimeoutc Csttdgt|tre|ds|dr$tjtt j ||dj }nOt j |r1tj|}nB|dr=|dd}zt|}tjt|}Wn$tyd}z td|d |d }~wwt|tjjro|}ntd tj|}|d }|S) 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_imager@r> startswithrArBopenrrequestsgetcontentospathisfilesplitbase64 decodebytesencode ExceptionrP TypeErrorImageOpsexif_transposeconvert)rSrb64er,r,r-rs2     rmetadatacKs|j}|j}|dur(|dur(t|||}||kr(td|d|d|d|dur9tjd|||td}|Stjd|td}|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. Nz When loading the video with fps=z, we computed num_frames=z which exceeds total_num_frames=z. Check fps or video metadata.r)rg)r7r8r;rPrharange)r num_framesr8kwargsr7 video_fpsindicesr,r,r-default_sample_indices_fnsr video_pathsample_indices_fncKsttdgddl}||}t||j}||j}|r#||nd}tt|t |t |dd}|dd|i|} d} g} | r}| \} } | sMn0| | vrn| j \}}}| | |j} | | d|d|d|f| rt| d7} | |kryn| sD|| |_t| |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. cv2rNopencvr7r8r9r:rr r,)rread_video_opencvr VideoCapturer;rCAP_PROP_FRAME_COUNT CAP_PROP_FPSr6r=isOpenedreadrcvtColor COLOR_BGR2RGBappendreleaseframes_indicesrhstack)rrrrrr7rr9rrindexframessuccessframerrchannelr,r,r-r?s8       rc Ksttdgddlm}m}|||dd}|}t|}|r$||nd}tt|t |t |dd} |dd| i|} | |  } | | _ | | 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)urictxrrNr,) rread_video_decordrrr get_avg_fpsrr6r;r= get_batchasnumpyr) rrrrrvrrr7r9rrrr,r,r-rxs rcKsttdgddl}||}|jjdj}|jjdj}|r#||nd}tt |t |t |dd}|d d|i|} g} | d| d} t |j ddD]\} } | | krYn| dkrf| | vrf| | qOtd d | D}| |_||fS) a} Decode the video with PyAV decoder. 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. avrNpyavrrr)rcSsg|]}|jddqS)rgb24)format) to_ndarray)rYxr,r,r-r{z#read_video_pyav..r,)rread_video_pyavrrstreamsrr average_rater6r;r=seek enumeratedecoderrhrr)rrrr containerr7rr9rrr end_indexirrr,r,r-rs,    rc Kstj|ddddd\}}}|d}|d}|r||nd}tt|t|t|dd } |d d | i|} || }| | _|| fS) a Decode the video with torchvision decoder. 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. gNsecTHWC) start_ptsend_ptspts_unit output_formatrr torchvisionrrr,) torchvision_io read_videosizer6r;r= contiguousrIr) rrrr_inforr7r9rrr,r,r-read_video_torchvisions(  r)rrrrrr VideoInputrr8backendc sdurdur|durtd|durfdd}|}|ds'|drsts.tdttdgd d lm}t}t |!|} | |gWdn1sVwYWdn1sewY| } t| } n4|d s}|d rtt |j} n!tj|r|} nt|st|ttfrt|d rd} ntd |d p|d } | r|dvrtd| dur|Sts|dksts|dksts|dksts|dkrtd|d|dt|} | | |fi|\}}||fS)a Loads `video` to a numpy array. Args: video (`str` or `VideoInput`): The video to convert to the numpy array format. Can be a link to video or local path. num_frames (`int`, *optional*): Number of frames to sample uniformly. If not passed, the whole video is loaded. fps (`int`, *optional*): Number of frames to sample per second. Should be passed only when `num_frames=None`. If not specified and `num_frames==None`, all frames are sampled. backend (`str`, *optional*, defaults to `"opencv"`): The backend to use when loading the video. Can be any of ["decord", "pyav", "opencv", "torchvision"]. Defaults to "opencv". 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 uniformt sampling with fps is performed, otherwise `sample_indices_fn` has priority over other args. The function expects at input the all args along with all kwargs passed to `load_video` and should output valid indices at which the video should be sampled. For example: Example: def sample_indices_fn(metadata, **kwargs): return np.linspace(0, metadata.total_num_frames - 1, num_frames, dtype=int) Returns: Tuple[`np.array`, Dict]: A tuple containing: - Numpy array of frames in RGB (shape: [num_frames, height, width, 3]). - Metadata dictionary. Nzc`num_frames`, `fps`, and `sample_indices_fn` are mutually exclusive arguments, please use only one!cst|fd|S)N)rr8)r)r fn_kwargsr8rr,r-sample_indices_fn_func=r`z*load_video..sample_indices_fn_funczhttps://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.)rrzlIf you are trying to load a video from URL, you can decode the video only with `pyav` or `decord` as backendrrrrzYou 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.)rPrr ImportErrorr load_videorrrrdownloadgetvaluerrrrrrrUr@rarbrrr rrVIDEO_DECODERS)rrr8rrrrrbufferf bytes_objfile_obj video_is_url video_decoderrr,rr-r!sl'    " r!csXt|ttfr&t|rt|dttfrfdd|DSfdd|DSt|dS)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. rcsg|] }fdd|DqS)cg|]}t|dqSrrrXrr,r-r{rz*load_images...r,)rY image_grouprr,r-r{szload_images..cr+r,r-rXrr,r-r{rr)r@rarbrr)rVrr,rr- load_imagesrs   r/ do_rescalerescale_factor do_normalize image_mean image_stddo_padsize_divisibilitydo_center_crop crop_size do_resizerresamplePILImageResamplingc Cs||r |dur td|r|durtd|r"|dus|dur"td|r,|dur,td| r:| dus6| durflatfloatingrpr transposeastyperirArB fromarray)r@rSrescaler,r,r- to_pil_images    z(ImageFeatureExtractionMixin.to_pil_imagecCs&||t|tjjs|S|dS)z Converts `PIL.Image.Image` to RGB format. Args: image (`PIL.Image.Image`): The image to convert. r)rAr@rArBrr?r,r,r- convert_rgbs  z'ImageFeatureExtractionMixin.convert_rgbrSscalerfcCs||||S)z7 Rescale a numpy image by scale amount )rA)r@rSrKr,r,r-rHs z#ImageFeatureExtractionMixin.rescaleTcCs||t|tjjrt|}t|r|}|dur&t|jdtj n|}|r4| | tj d}|rB|j dkrB|ddd}|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. Nrp?rmrr )rAr@rArBrhrrrIrCintegerrHrFfloat32rprE)r@rSrH channel_firstr,r,r-rs  z*ImageFeatureExtractionMixin.to_numpy_arraycCsD||t|tjjr|St|r|d}|Stj|dd}|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)rAr@rArBr unsqueezerh expand_dimsr?r,r,r-rRs  z'ImageFeatureExtractionMixin.expand_dimsFcCsh||t|tjjr|j|dd}n|r3t|tjr'||tj d}n t |r3|| d}t|tjrXt|tjsHt ||j }t|tjsWt ||j }n6t |rddl}t||jswt|tjrr||}n||}t||jst|tjr||}n||}|jdkr|jddvr||ddddf|ddddfS|||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)rHrLrNrmr)rAr@rArBrrhr>rHrFrNrr=rrgrHTensor from_numpytensorrpr)r@rSmeanstdrHrHr,r,r- normalize$s6             ( z%ImageFeatureExtractionMixin.normalizec CsJ|dur|ntj}||t|tjjs||}t|tr#t|}t|t s.t |dkr|rBt|t r9||fn|d|df}n\|j \}}||krO||fn||f\}} t|t r\|n|d} || krf|S| t | | |} } |dur|| krt d|d|| |krt || | |} } ||kr| | fn| | f}|j ||dS)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`. Nr rz max_size = zN must be strictly greater than the requested size for the smaller edge size = )r:)r;BILINEARrAr@rArBrIrarbr;rrrPresize) r@rSrr:default_to_squaremax_sizerrshortlongrequested_new_short new_shortnew_longr,r,r-rZXs4   $ z"ImageFeatureExtractionMixin.resizecCs||t|ts||f}t|st|tjr8|jdkr"||}|jddvr0|jddn|jdd}n |j d|j df}|d|dd}||d}|d|dd}||d}t|t j j rr| ||||fS|jddvr{dnd}|st|tjr| ddd}t|r|ddd}|dkr||dkr|dkr||dkr|d||||fS|jdd t|d|dt|d|df} t|tjrtj|| d } n t|r|| } | d |dd} | |d} | d |dd} | |d}|| d| | | |f<|| 7}|| 7}|| 7}|| 7}| 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)rAr@rbrrhr>rprRrrrArBcroprEpermuterk zeros_like new_zerosrj)r@rSr image_shapetopbottomleftrightrO new_shape new_imagetop_pad bottom_padleft_pad right_padr,r,r- center_cropsP    ,   (2    4z'ImageFeatureExtractionMixin.center_cropcCs>||t|tjjr||}|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)rAr@rArBrr?r,r,r-flip_channel_orders  z.ImageFeatureExtractionMixin.flip_channel_orderrcCsL|dur|ntjj}||t|tjjs||}|j||||||dS)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`. N)r:expandcenter translate fillcolor)rArBNEARESTrAr@rIrotate)r@rSangler:rsrtrurvr,r,r-rxs   z"ImageFeatureExtractionMixin.rotater?)NT)F)NTN)NrNNN)r'r(r)__doc__rArIrJrhr>r r=r;rHrrRrXrZrqrrrxr,r,r,r-r=s "   4CKr=annotation_formatsupported_annotation_formatscCsX||vrtdtd||tjurt|std|tjur(t|s*tddSdS)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.)rPrr/r2rr3r)r{r|rr,r,r-validate_annotationss  r}valid_processor_keyscaptured_kwargscCs:t|t|}|rd|}td|ddSdS)Nz, zUnused or unrecognized kwargs: ro)set differencejoinrr)r~r unused_keysunused_key_strr,r,r-validate_kwargs)s  rT)frozenc@szeZdZUdZdZeeed<dZeeed<dZ eeed<dZ eeed<dZ eeed<dZ eeed<d d Z dS) SizeDictz> Hashable dictionary to store image size information. Nrr longest_edge shortest_edgerrcCs$t||r t||Std|d)NzKey z not found in SizeDict.)hasattrgetattrKeyError)r@keyr,r,r- __getitem__>s  zSizeDict.__getitem__)r'r(r)rzrrr;r<rrrrrrr,r,r,r-r1s  r)rmr?)NN)NNrN) NNNNNNNNNNNN)vrrcollections.abcr contextlibr dataclassesrr!rtypingrrrr rIrhr packagingr utilsr r rrrrrrrrrrrrrutils.constantsrrrrrr PIL.ImagerA PIL.ImageOpsparse __version__ base_versionrB Resamplingr;rrtorchvision.transformsr"rwBOXrYHAMMINGBICUBICLANCZOSpil_torch_interpolation_mappingrH get_loggerr'rr>ra ImageInputrr$r/r4r6rr>r;AnnotationTyperErFrTrUr_rcreboolrlrqrrrrrbrrrrrrrrr=rrrrrrr$rr!r/r<r=r}rrr,r,r,r-s     D             ' # $  & "   ""&&$,# ; + 3 1   e     *a