o iz@sddlZddlZddlmZddlmZddlmZddlm Z m Z ddl Z ddl Z ddlmZmZmZmZmZmZmZmZmZddlmZmZmZmZmZmZerddlZ ddl!Z e j"j#Z$erdd l%m&Z&e$j'e&j(e$j)e&j)e$j*e&j*e$j+e&j+e$j,e&j,e$j-e&j-iZ.niZ.erddl/Z/e0e1Z2e d e j3d e4d e4e j3e4d fZ5Gd d d eZ6GdddeZ7e8e9e:e9Be4e8BfZ;ddZddZ?de4fddZ@ddZAddZBdd ZCd!e j3d"eDfd#d$ZEdld&e:d"e4e5fd'd(ZF %dlde4e5e5Bd&e:d"e5fd)d*ZG %dlde4e5e5Bd&e:d"e4e5fd+d,ZHd"e j3fd-d.ZI dmd!e j3d/e:eJe:d0fBdBd"e6fd1d2ZKdmd!e j3d3e6e9BdBd"e:fd4d5ZLdmd!e j3d6e6dBd"eJe:e:ffd7d8ZMd9eJe:e:fd:e:d;e:d"eJe:e:ffde8e9e4eJBfd"eDfd?d@ZOd>e8e9e4eJBfd"eDfdAdBZPdCee8e9e4eJBfd"eDfdDdEZQdCee8e9e4eJBfd"eDfdFdGZRdmd!e e9d fdHeSdBd"d fdIdJZT dmde e4eJe9d fdHeSdBd"e d e4d e4e4d ffdKdLZU             dndMeDdBdNeSdBdOeDdBdPeSe4eSBdBdQeSe4eSBdBdReDdBdSe8e9e:fe:BdBdTeDdBdUe8e9e:fdBdVeDdBdWe8e9e:fdBdXe dYdZe d[fd\d]ZVGd^d_d_ZWd`e7daeJe7d0fdCe4e8d"dfdbdcZXdde4e9dee4e9fdfdgZYedhdiGdjdkdkZZdS)oN)Iterable) dataclass)BytesIO)OptionalUnion) ExplicitEnumis_numpy_arrayis_torch_availableis_torch_tensoris_torchvision_availableis_vision_availableloggingrequires_backendsto_numpy)IMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STDIMAGENET_STANDARD_MEANIMAGENET_STANDARD_STDOPENAI_CLIP_MEANOPENAI_CLIP_STD)InterpolationModezPIL.Image.Imagez torch.Tensorc@eZdZdZdZdS)ChannelDimensionchannels_first channels_lastN)__name__ __module__ __qualname__FIRSTLASTr!r!Z/sda-disk/www/egybert/egybert_env/lib/python3.10/site-packages/transformers/image_utils.pyrOrc@r)AnnotationFormatcoco_detection coco_panopticN)rrrCOCO_DETECTION COCO_PANOPTICr!r!r!r"r$Tr#r$cCsto t|tjjSN)r isinstancePILImageimgr!r!r" is_pil_image\sr/c@seZdZdZdZdZdS) ImageTypepillowtorchnumpyN)rrrr+TORCHNUMPYr!r!r!r"r0`sr0cCs<t|rtjSt|rtjSt|rtjStdt|)NzUnrecognized image type ) r/r0r+r r4r r5 ValueErrortypeimager!r!r"get_image_typefsr:cCst|p t|p t|Sr))r/r r r-r!r!r"is_valid_imagepsr;imagescCs|o tdd|DS)Ncs|]}t|VqdSr))r;.0r9r!r!r" uz*is_valid_list_of_images..all)r<r!r!r"is_valid_list_of_imagestsrDcCs\t|dtrdd|DSt|dtjrtj|ddSt|dtjr,tj|ddSdS)NrcSg|] }|D]}|qqSr!r!)r?sublistitemr!r!r" zz$concatenate_list..axis)dim)r*listnpndarray concatenater2Tensorcat) input_listr!r!r"concatenate_listxsrTcCs:t|ttfr|D] }t|sdSq dSt|sdSdS)NFT)r*rMtuple valid_imagesr;)imgsr.r!r!r"rVsrVcCst|ttfr t|dSdS)NrF)r*rMrUr;r-r!r!r" is_batcheds rXr9returncCs,|jtjkrdSt|dkot|dkS)zV Checks to see whether the pixel values have already been rescaled to [0, 1]. Frr)dtyperNuint8minmaxr8r!r!r"is_scaled_images r^expected_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. rz%Invalid image shape. Expected either z or z dimensions, but got z dimensions.z]Invalid image type. Expected either PIL.Image.Image, numpy.ndarray, or torch.Tensor, but got .)rXr/r;ndimrMr6r7r<r`r!r!r"make_list_of_imagess&  rdcCst|ttfr tdd|Dr tdd|Dr dd|DSt|ttfrJt|rJt|ds8|dj|kr:|S|dj|dkrJdd|DSt|ret|sW|j|krZ|gS|j|dkret|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. expected_ndims (`int`, *optional*, defaults to 3): The expected number of dimensions for a single input image. Returns: list: A list of images or a 4d array of images. cs|] }t|ttfVqdSr)r*rMrUr?images_ir!r!r"r@z+make_flat_list_of_images..cs|] }t|p | VqdSr)rDrgr!r!r"r@ricSrEr!r!r?img_listr.r!r!r"rHrIz,make_flat_list_of_images..rrcSrEr!r!rlr!r!r"rHrIz*Could not make a flat list of images from r*rMrUrCrDr/rbr;r6rcr!r!r"make_flat_list_of_imagess$ rocCst|ttfrtdd|Drtdd|Dr|St|ttfrFt|rFt|ds3|dj|kr6|gS|dj|dkrFdd|DSt|rct|sS|j|krW|ggS|j|dkrct|gStd) as Ensure that the output is a nested list of images. Args: images (`Union[list[ImageInput], ImageInput]`): The input image. expected_ndims (`int`, *optional*, defaults to 3): The expected number of dimensions for a single input image. Returns: list: A list of list of images or a list of 4d array of images. csrer)rfrgr!r!r"r@riz-make_nested_list_of_images..csrjr)rkrgr!r!r"r@rirrcSsg|]}t|qSr!)rMr>r!r!r"rHsz.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.rnrcr!r!r"make_nested_list_of_imagess$  rpcCs@t|s tdt|trt|tjjrt|St |S)NzInvalid image type: ) r;r6r7r r*r+r,rNarrayrr-r!r!r"to_numpy_arrays  rr num_channels.cCs|dur|nd}t|tr|fn|}|jdkrd\}}n|jdkr&d\}}n|jdkr0d\}}ntd|j|j||vrS|j||vrStd |jd tjS|j||vr]tjS|j||vrgtj 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. Nrr_r_)r)rurvz(Unsupported number of image dimensions: z4The channel dimension is ambiguous. Got image shape z. Assuming channels are the first dimension. Use the [input_data_format](https://huggingface.co/docs/transformers/main/internal/image_processing_utils#transformers.image_transforms.rescale.input_data_format) parameter to assign the channel dimension.z(Unable to infer channel dimension format) r*intrbr6shapeloggerwarningrrr )r9rs first_dimlast_dimr!r!r"infer_channel_dimension_formats&       r~input_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. Nr_rUnsupported data format: )r~rrrbr r6)r9rr!r!r"get_channel_dimension_axisAs     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)r~rrryr r6)r9rr!r!r"get_image_sizeWs   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. )r\rx) rrrheightwidth height_scale width_scale min_scale new_height new_widthr!r!r"#get_image_size_for_max_height_widthos   r annotationcCsVt|tr)d|vr)d|vr)t|dttfr)t|ddks't|ddtr)dSdS)Nimage_id annotationsrTFr*dictrMrUlenrr!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)Ncsr=r))rr?annr!r!r"r@rAz3valid_coco_detection_annotations..rBrr!r!r" valid_coco_detection_annotationsrcCr)Ncsr=r))rrr!r!r"r@rAz2valid_coco_panoptic_annotations..rBrr!r!r"valid_coco_panoptic_annotationsrrtimeoutc Csttdgt|trf|ds|dr%tjtt j ||ddj }nLt j |r2tj|}n?|dr>|dd}zt|}tjt|}Wn!tye}z td |d |d }~wwt|tjjsqtd 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. visionzhttp://zhttps://T)rfollow_redirectsz data:image/,rzIncorrect 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*str startswithr+r,openrhttpxgetcontentospathisfilesplitbase64 decodebytesencode Exceptionr6 TypeErrorImageOpsexif_transposeconvert)r9rb64er!r!r"rs0      rcsXt|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|dqSrrr>rr!r"rHz*load_images...r!)r? image_grouprr!r"rHszload_images..crrrr>rr!r"rHrr)r*rMrUrr)r<rr!rr" load_imagess   r do_rescalerescale_factor do_normalize image_mean image_stddo_padpad_sizedo_center_crop crop_size do_resizesizeresamplePILImageResampling interpolationrc Cs|r |dur td|r|durtd|r"|dus|dur"td|r,|dur,td| dur8| dur8td| rJ| durF| dusL| dusNtddSdSdS)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`.zgDepending on the model, `size_divisor` or `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`.zbOnly one of `interpolation` and `resample` should be specified, depending on image processor type.zO`size` and `resample/interpolation` must be specified if `do_resize` is `True`.)r6) rrrrrrrrrrrrrr!r!r"validate_preprocess_argumentss"    rc@seZdZdZddZdddZddZd ejd e e Bd ejfd d Z d ddZ ddZ d!ddZd"ddZddZddZd#ddZdS)$ImageFeatureExtractionMixinzD Mixin that contain utilities for preparing image features. cCs8t|tjjtjfst|stdt|ddSdS)Nz Got type zU which is not supported, only `PIL.Image.Image`, `np.ndarray` and `torch.Tensor` are.)r*r+r,rNrOr r6r7selfr9r!r!r"_ensure_format_supported-s z4ImageFeatureExtractionMixin._ensure_format_supportedNcCs||t|r |}t|tjrE|dur t|jdtj}|jdkr3|j ddvr3| ddd}|r9|d}| tj }t j|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. Nrr_rtrru)rr r3r*rNrOflatfloatingrbry transposeastyper[r+r, fromarray)rr9rescaler!r!r" to_pil_image4s    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)rr*r+r,rrr!r!r" convert_rgbRs  z'ImageFeatureExtractionMixin.convert_rgbr9scalerYcCs||||S)z7 Rescale a numpy image by scale amount )r)rr9rr!r!r"r`s 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?r_rur)rr*r+r,rNrqr r3rintegerrrfloat32rbr)rr9r channel_firstr!r!r"rrgs  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. rrJ)rr*r+r,r unsqueezerN expand_dimsrr!r!r"rs  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)rrrNr_rt)rr*r+r,rrrNrOrrrr floatrqrZr2rQ from_numpytensorrbry)rr9meanstdrr2r!r!r" normalizes6             ( 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`. Nrrz max_size = zN must be strictly greater than the requested size for the smaller edge size = )r)rBILINEARrr*r+r,rrMrUrxrrr6resize) rr9rrdefault_to_squaremax_sizerrshortlongrequested_new_short new_shortnew_longr!r!r"rs4   $ z"ImageFeatureExtractionMixin.resizecCsx||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|jddv}|st|tjr| ddd}t|r|ddd}|dkr||dkr|dkr||dkr|d||||fS|jddt|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). rurrtrN.r)ryr)rr*rUr rNrOrbrryrr+r,croprpermuter] zeros_like new_zerosr\)rr9r image_shapetopbottomleftrightr 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)rr*r+r,rrrr!r!r"flip_channel_order]s  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)rexpandcenter translate fillcolor)r+r,NEARESTrr*rrotate)rr9anglerrr r r r!r!r"r ns   z"ImageFeatureExtractionMixin.rotater))NT)F)NTN)NrNNN)rrr__doc__rrrrNrOrrxrrrrrrrrr r!r!r!r"r(s    4CKrannotation_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.)r6formatr$r'rr(r)rrrr!r!r"validate_annotationss  rvalid_processor_keyscaptured_kwargscCs:t|t|}|rd|}td|ddSdS)Nz, zUnused or unrecognized kwargs: ra)set differencejoinrzr{)rr unused_keysunused_key_strr!r!r"validate_kwargss  rT)frozenc@szeZdZUdZdZedBed<dZedBed<dZedBed<dZ edBed<dZ edBed<dZ edBed<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)rkeyr!r!r" __getitem__s  zSizeDict.__getitem__) rrrrrrx__annotations__rrrrrr$r!r!r!r"rs  r)r_r)) NNNNNNNNNNNNN)[rrcollections.abcr dataclassesriortypingrrrr3rNutilsrr r r r r rrrutils.constantsrrrrrr PIL.Imager+ PIL.ImageOpsr, Resamplingrtorchvision.transformsrr  NEAREST_EXACTBOXrHAMMINGBICUBICLANCZOSpil_torch_interpolation_mappingr2 get_loggerrrzrOrM ImageInputrr$rrrxAnnotationTyper/r0r:r;rDrTrVrXboolr^rdrorprrrUr~rrrrrrrrrrrrrrrr!r!r!r"s&   ,         (  (  '  "'&   ""$+      4a