`i8UdZddlZddlZddlmZddlmZddlmZm Z m Z ddl Z ddl mZmZmZddlmZmZdd lmZmZmZmZmZmZmZmZmZmZmZdd l m!Z!m"Z"m#Z#m$Z$dd l%m&Z&e#rddl'Z'e$j(e)Z*eZ+eZ,gd Z-gd Z.dZ/e0e1d<GddZ2e&dGddeZ3dgZ4dS)z Image processor class for Flava.N)Iterable) lru_cache)AnyOptionalUnion)BaseImageProcessor BatchFeature get_size_dict)resizeto_channel_dimension_format) OPENAI_CLIP_MEANOPENAI_CLIP_STDChannelDimension ImageInputPILImageResamplinginfer_channel_dimension_formatis_scaled_imagemake_flat_list_of_imagesto_numpy_array valid_imagesvalidate_preprocess_arguments) TensorTypefilter_out_non_signature_kwargsis_vision_availablelogging)requires)rr)?rrg?LOGIT_LAPLACE_EPSceZdZ ddeeeeeffdedeed ed eed eef d Zd Z dZ dZ dZ dS)FlavaMaskingGeneratorKN333333? input_sizetotal_mask_patchesmask_group_max_patchesmask_group_min_patchesmask_group_min_aspect_ratiomask_group_max_aspect_ratioct|ts|fdz}|\|_|_|j|jz|_||_||_||n||_|pd|z }tj |tj |f|_ dS)N) isinstancetupleheightwidth num_patchesr(r*r)mathloglog_aspect_ratio)selfr'r(r)r*r+r,s /home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/transformers/models/flava/image_processing_flava.py__init__zFlavaMaskingGenerator.__init__=s*e,, +$*J", TZ;3"4&<# [%d ~ %d], max = %d, %.3f ~ %.3f)rr/)r2r3r*r)r(r7)r8repr_strs r9__repr__zFlavaMaskingGenerator.__repr__SsKQ K J  '  '  #  !! $  !! $U  r;c|j|jfS)Nr2r3)r8s r9 get_shapezFlavaMaskingGenerator.get_shape_s{DJ&&r;c (d}tdD]~}tj|j|}t jtj|j}ttt j ||z}ttt j ||z }||j kr||j krtj d|j |z } tj d|j |z } || | |z| | |zf } d||z| z cxkr|krInnFt| | |zD]2} t| | |zD]} || | fdkr d|| | f<|dz }3|dkrn|S)Nr r/)rangerandomuniformr*r5expr7introundsqrtr3r2randintsum)r8maskmax_mask_patchesdelta_attempt target_area aspect_ratior2r3topleft num_maskedijs r9_maskzFlavaMaskingGenerator._maskbsb   H .)DFVWWK8FND4I$JKKLty|)CDDEEFFFdi l(BCCDDEEEtz!!ft{&:&:nQ f(<==~ae);<<!#f "4dTE\6I"IJNNPP v~ 2FFFF6FFFFFF"3f 55++!&tTE\!:!:++A#AqDzQ-.QT % + 199E r;ctj|t}d}||jkrL|j|z }t ||j}|||}|dkrn||z }||jkL|S)N)shapedtyper)npzerosrArHr(minr)rX)r8rM mask_countrNrOs r9__call__zFlavaMaskingGenerator.__call__zsxdnn..c::: 4222#6C "#3T5PQQ JJt%566Ezze# 4222 r;)r#r$Nr%r&N) __name__ __module__ __qualname__rrHr1rfloatr:r>rArXr`r;r9r"r"<s35"$04&(7:7;oo#uS#X./o o!) o !$ o &.e_ o&.e_oooo,   '''0     r;r")vision)backendscGeZdZdZdgZddejddddddddddd dd ddddejddddddddfd ed e e e e fd edede e e e fdede e efdede e eeefde e eeefdede de de de e dede ededede ede d ed!e e d"ed#e e efd$ed%ed&e e eeefd'e e eeefd(df<fd) Zed*e e efffd+ Zed(efd,Zejddfd-ejd e e e fd ed.e e e efd/e e e efd(ejf d0Zd-ejd(ejfd1Zdddddddddddejdf d-ed e ed e e e e fd e ede ede e e e fde ede ede ede e eeefde e eeefd2e ed.e ed/e ed(ejfd3Ze ddddddddddddddddddddddddddddddejdf d4ed e ed e e e e fd e ede ede e e e fde ede ede ede e eeefde e eeefde ede e de e de e de e de ede ede ede ede e e e fde e d e ed!e e e e fd"e ed#e ed$e ed%e ed&e eed'e eed5e e e e!fd.ed/e e e efd(e"j#j#fDd6Z$xZ%S)7FlavaImageProcessora  Constructs a Flava image processor. Args: do_resize (`bool`, *optional*, defaults to `True`): Whether to resize the image's (height, width) dimensions to the specified `size`. Can be overridden by the `do_resize` parameter in `preprocess`. size (`dict[str, int]` *optional*, defaults to `{"height": 224, "width": 224}`): Size of the image after resizing. Can be overridden by the `size` parameter in `preprocess`. resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`): Resampling filter to use if resizing the image. Can be overridden by the `resample` parameter in `preprocess`. do_center_crop (`bool`, *optional*, defaults to `True`): Whether to center crop the images. Can be overridden by the `do_center_crop` parameter in `preprocess`. crop_size (`dict[str, int]` *optional*, defaults to `{"height": 224, "width": 224}`): Size of image after the center crop `(crop_size["height"], crop_size["width"])`. Can be overridden by the `crop_size` parameter in `preprocess`. do_rescale (`bool`, *optional*, defaults to `True`): Whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by the `do_rescale` parameter in `preprocess`. rescale_factor (`int` or `float`, *optional*, defaults to `1/255`): Scale factor to use if rescaling the image. Can be overridden by the `rescale_factor` parameter in `preprocess`. do_normalize (`bool`, *optional*, defaults to `True`): Whether to normalize the image. Can be overridden by the `do_normalize` parameter in `preprocess`. image_mean (`float` or `list[float]`, *optional*, defaults to `IMAGENET_STANDARD_MEAN`): Mean to use if normalizing the image. This is a float or list of floats the length of the number of channels in the image. Can be overridden by the `image_mean` parameter in the `preprocess` method. image_std (`float` or `list[float]`, *optional*, defaults to `IMAGENET_STANDARD_STD`): Standard deviation to use if normalizing the image. This is a float or list of floats the length of the number of channels in the image. Can be overridden by the `image_std` parameter in the `preprocess` method. return_image_mask (`bool`, *optional*, defaults to `False`): Whether to return the image mask. Can be overridden by the `return_image_mask` parameter in `preprocess`. input_size_patches (`int`, *optional*, defaults to 14): Number of patches in the image in height and width direction. 14x14 = 196 total patches. Can be overridden by the `input_size_patches` parameter in `preprocess`. total_mask_patches (`int`, *optional*, defaults to 75): Total number of patches that should be masked. Can be overridden by the `total_mask_patches` parameter in `preprocess`. mask_group_min_patches (`int`, *optional*, defaults to 16): Minimum number of patches that should be masked. Can be overridden by the `mask_group_min_patches` parameter in `preprocess`. mask_group_max_patches (`int`, *optional*): Maximum number of patches that should be masked. Can be overridden by the `mask_group_max_patches` parameter in `preprocess`. mask_group_min_aspect_ratio (`float`, *optional*, defaults to 0.3): Minimum aspect ratio of the mask window. Can be overridden by the `mask_group_min_aspect_ratio` parameter in `preprocess`. mask_group_max_aspect_ratio (`float`, *optional*): Maximum aspect ratio of the mask window. Can be overridden by the `mask_group_max_aspect_ratio` parameter in `preprocess`. codebook_do_resize (`bool`, *optional*, defaults to `True`): Whether to resize the input for codebook to a certain. Can be overridden by the `codebook_do_resize` parameter in `preprocess`. `codebook_size`. codebook_size (`dict[str, int]`, *optional*, defaults to `{"height": 224, "width": 224}`): Resize the input for codebook to the given size. Can be overridden by the `codebook_size` parameter in `preprocess`. codebook_resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.LANCZOS`): Resampling filter to use if resizing the codebook image. Can be overridden by the `codebook_resample` parameter in `preprocess`. codebook_do_center_crop (`bool`, *optional*, defaults to `True`): Whether to crop the input for codebook at the center. If the input size is smaller than `codebook_crop_size` along any edge, the image is padded with 0's and then center cropped. Can be overridden by the `codebook_do_center_crop` parameter in `preprocess`. codebook_crop_size (`dict[str, int]`, *optional*, defaults to `{"height": 224, "width": 224}`): Desired output size for codebook input when applying center-cropping. Can be overridden by the `codebook_crop_size` parameter in `preprocess`. codebook_do_rescale (`bool`, *optional*, defaults to `True`): Whether to rescale the input for codebook by the specified scale `codebook_rescale_factor`. Can be overridden by the `codebook_do_rescale` parameter in `preprocess`. codebook_rescale_factor (`int` or `float`, *optional*, defaults to `1/255`): Defines the scale factor to use if rescaling the codebook image. Can be overridden by the `codebook_rescale_factor` parameter in `preprocess`. codebook_do_map_pixels (`bool`, *optional*, defaults to `True`): Whether to map the pixel values of the codebook input to (1 - 2e)x + e. Can be overridden by the `codebook_do_map_pixels` parameter in `preprocess`. codebook_do_normalize (`bool`, *optional*, defaults to `True`): Whether or not to normalize the input for codebook with `codebook_image_mean` and `codebook_image_std`. Can be overridden by the `codebook_do_normalize` parameter in `preprocess`. codebook_image_mean (`Optional[Union[float, Iterable[float]]]`, *optional*, defaults to `[0, 0, 0]`): The sequence of means for each channel, to be used when normalizing images for codebook. Can be overridden by the `codebook_image_mean` parameter in `preprocess`. codebook_image_std (`Optional[Union[float, Iterable[float]]]`, *optional*, defaults to `[0.5, 0.5, 0.5]`): The sequence of standard deviations for each channel, to be used when normalizing images for codebook. Can be overridden by the `codebook_image_std` parameter in `preprocess`. pixel_valuesTNgp?Fr#r$r%r& do_resizesizeresampledo_center_crop crop_size do_rescalerescale_factor do_normalize image_mean image_stdreturn_image_maskinput_size_patchesr(r*r)r+r,return_codebook_pixelscodebook_do_resize codebook_sizecodebook_resamplecodebook_do_center_cropcodebook_crop_sizecodebook_do_rescalecodebook_rescale_factorcodebook_do_map_pixelscodebook_do_normalizecodebook_image_meancodebook_image_stdreturnc tjdi|||nddd}t|}||nddd}t|d}||nddd}t|d}||nddd}t|d}||_||_||_||_||_||_||_ ||_ | | nt|_ | | nt|_| |_| |_| |_||_||_||_||_||_||_||_||_||_||_||_||_||_||_||_ ||ntB|_ ||ntD|_#dS) Nr@ro param_namepryr|re)$superr:r rkrlrmrprqrnrorrFLAVA_IMAGE_MEANrsFLAVA_IMAGE_STDrtrurvr(r*r)r+r,rwrxryrzr{r|r}r~rrrFLAVA_CODEBOOK_MEANFLAVA_CODEBOOK_STDr) r8rkrlrmrnrorprqrrrsrtrurvr(r*r)r+r,rwrxryrzr{r|r}r~rrrrkwargs __class__s r9r:zFlavaImageProcessor.__init__sF ""6"""'ttc-J-JT""!*!6IIsUX**DT&/&;!2"4"4&<#&<#+F(+F(&<#"4*!2'>$"4#6 '>$&<#%:"#6 :M:Y#6#6_r 8J8V"4"4\nr;image_processor_dictc |}d|vr|d|d<d|vr|d|d<tj|fi|S)z Overrides the `from_dict` method from the base class to make sure parameters are updated if image processor is created using from_dict and kwargs e.g. `FlavaImageProcessor.from_pretrained(checkpoint, codebook_size=600)` ryr|)copypopr from_dict)clsrrrs r9rzFlavaImageProcessor.from_dict4s} 488:: f $ $4:JJ4O4O  1 6 ) )9?DX9Y9Y !5 6 uww !5@@@@@r;c,t||||||S)N)r'r(r*r)r+r,)r")r8rvr(r*r)r+r,s r9masking_generatorz%FlavaImageProcessor.masking_generatorAs-%)1#9#9(C(C     r;image data_formatinput_data_formatc t|}d|vsd|vr$td||d|df}t|f||||d|S)a Resize an image to `(size["height"], size["width"])`. Args: image (`np.ndarray`): Image to resize. size (`dict[str, int]`): Dictionary in the format `{"height": int, "width": int}` specifying the size of the output image. resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`): `PILImageResampling` filter to use when resizing the image e.g. `PILImageResampling.BICUBIC`. data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format for the output image. If unset, the channel dimension format of the input image is used. 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. - `"none"` or `ChannelDimension.NONE`: image in (height, width) format. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format for the input image. If unset, the channel dimension format is inferred from 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. - `"none"` or `ChannelDimension.NONE`: image in (height, width) format. Returns: `np.ndarray`: The resized image. r2r3zFThe `size` dictionary must contain the keys `height` and `width`. Got )rlrmrr)r ValueErrorkeysr )r8rrlrmrrr output_sizes r9r zFlavaImageProcessor.resizeUsFT"" 4  7$#6#6sfjfofofqfqsstt tH~tG}5   #/       r;c2ddtzz |ztzS)Nr/r.)r )r8rs r9 map_pixelszFlavaImageProcessor.map_pixelssA)))U25FFFr; do_map_pixelsc t||| | | ||||| t|}|r)t|rtd|t |}|r|||||}|r||||}|r||||}| r| || | |}| r| |}| t|| |}|S) zPreprocesses a single image.) rprqrrrsrtrnrorkrlrmzIt looks like you are trying to rescale already rescaled images. If the input images have pixel values between 0 and 1, set `do_rescale=False` to avoid rescaling them again.N)rrlrmr)rrlr)rscaler)rmeanstdr)input_channel_dim) rrrlogger warning_oncerr center_croprescale normalizerr )r8rrkrlrmrnrorprqrrrsrtrrrs r9_preprocess_imagez%FlavaImageProcessor._preprocess_imagesW& &!)%!) u%%  /%00    s     $ >u E E   pKKe$]nKooE  g$$5yTe$ffE  iLLuNVgLhhE  uNNZYbsNttE  +OOE**E  "/{VghhhE r;imagesreturn_tensorsc"  !&njnjtnjnjnjtdnjnj  nj  nj  nj | | nj } | | nj } ||nj }||nj}||nj}||nj}||nj}||nj}njnjtdnjnjnjnjnjtdnjnjnjnjt=|}t?|stAd   !f d|D}"d|"i}#|r  !fd |D}$|$|#d <| r.!| ||||| &&fd |D}%|%|#d <tE|#|S)a Preprocess an image or batch of images. Args: images (`ImageInput`): Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If passing in images with pixel values between 0 and 1, set `do_rescale=False`. do_resize (`bool`, *optional*, defaults to `self.do_resize`): Whether to resize the image. size (`dict[str, int]`, *optional*, defaults to `self.size`): Size of the image. resample (`int`, *optional*, defaults to `self.resample`): Resampling filter to use if resizing the image. This can be one of the enum `PILImageResampling`, Only has an effect if `do_resize` is set to `True`. do_center_crop (`bool`, *optional*, defaults to `self.do_center_crop`): Whether to center crop the image. crop_size (`dict[str, int]`, *optional*, defaults to `self.crop_size`): Size of the center crop. Only has an effect if `do_center_crop` is set to `True`. do_rescale (`bool`, *optional*, defaults to `self.do_rescale`): Whether to rescale the image values between [0 - 1]. rescale_factor (`float`, *optional*, defaults to `self.rescale_factor`): Rescale factor to rescale the image by if `do_rescale` is set to `True`. do_normalize (`bool`, *optional*, defaults to `self.do_normalize`): Whether to normalize the image. image_mean (`float` or `list[float]`, *optional*, defaults to `self.image_mean`): Image mean. image_std (`float` or `list[float]`, *optional*, defaults to `self.image_std`): Image standard deviation. return_image_mask (`bool`, *optional*, defaults to `self.return_image_mask`): Whether to return the image mask. input_size_patches (`int`, *optional*, defaults to `self.input_size_patches`): Size of the patches to extract from the image. total_mask_patches (`int`, *optional*, defaults to `self.total_mask_patches`): Total number of patches to extract from the image. mask_group_min_patches (`int`, *optional*, defaults to `self.mask_group_min_patches`): Minimum number of patches to extract from the image. mask_group_max_patches (`int`, *optional*, defaults to `self.mask_group_max_patches`): Maximum number of patches to extract from the image. mask_group_min_aspect_ratio (`float`, *optional*, defaults to `self.mask_group_min_aspect_ratio`): Minimum aspect ratio of the patches to extract from the image. mask_group_max_aspect_ratio (`float`, *optional*, defaults to `self.mask_group_max_aspect_ratio`): Maximum aspect ratio of the patches to extract from the image. return_codebook_pixels (`bool`, *optional*, defaults to `self.return_codebook_pixels`): Whether to return the codebook pixels. codebook_do_resize (`bool`, *optional*, defaults to `self.codebook_do_resize`): Whether to resize the codebook pixels. codebook_size (`dict[str, int]`, *optional*, defaults to `self.codebook_size`): Size of the codebook pixels. codebook_resample (`int`, *optional*, defaults to `self.codebook_resample`): Resampling filter to use if resizing the codebook pixels. This can be one of the enum `PILImageResampling`, Only has an effect if `codebook_do_resize` is set to `True`. codebook_do_center_crop (`bool`, *optional*, defaults to `self.codebook_do_center_crop`): Whether to center crop the codebook pixels. codebook_crop_size (`dict[str, int]`, *optional*, defaults to `self.codebook_crop_size`): Size of the center crop of the codebook pixels. Only has an effect if `codebook_do_center_crop` is set to `True`. codebook_do_rescale (`bool`, *optional*, defaults to `self.codebook_do_rescale`): Whether to rescale the codebook pixels values between [0 - 1]. codebook_rescale_factor (`float`, *optional*, defaults to `self.codebook_rescale_factor`): Rescale factor to rescale the codebook pixels by if `codebook_do_rescale` is set to `True`. codebook_do_map_pixels (`bool`, *optional*, defaults to `self.codebook_do_map_pixels`): Whether to map the codebook pixels values. codebook_do_normalize (`bool`, *optional*, defaults to `self.codebook_do_normalize`): Whether to normalize the codebook pixels. codebook_image_mean (`float` or `list[float]`, *optional*, defaults to `self.codebook_image_mean`): Codebook pixels mean to normalize the codebook pixels by if `codebook_do_normalize` is set to `True`. codebook_image_std (`float` or `list[float]`, *optional*, defaults to `self.codebook_image_std`): Codebook pixels standard deviation to normalize the codebook pixels by if `codebook_do_normalize` is set to `True`. return_tensors (`str` or `TensorType`, *optional*): The type of tensors to return. Can be one of: - Unset: Return a list of `np.ndarray`. - `TensorType.TENSORFLOW` or `'tf'`: Return a batch of type `tf.Tensor`. - `TensorType.PYTORCH` or `'pt'`: Return a batch of type `torch.Tensor`. - `TensorType.NUMPY` or `'np'`: Return a batch of type `np.ndarray`. - `TensorType.JAX` or `'jax'`: Return a batch of type `jax.numpy.ndarray`. data_format (`ChannelDimension` or `str`, *optional*, defaults to `ChannelDimension.FIRST`): The channel dimension format for the output image. Can be one of: - `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `ChannelDimension.LAST`: image in (height, width, num_channels) format. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format for the input image. If unset, the channel dimension format is inferred from 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. - `"none"` or `ChannelDimension.NONE`: image in (height, width) format. Nrorryr|zkInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray.cV g|]%} |   d &S)Frrkrlrmrnrorprqrrrsrtrrrr).0imgrorrnrrrprkrsrtrrmrqr8rls r9 z2FlavaImageProcessor.preprocess..sj   "!  " "#!-#%-)%##'"3 #     r;rjcVg|]%}|    &S)rr)rrr|r{rrr}rxrrrzr~ryrrr8s r9rz2FlavaImageProcessor.preprocess..sj"!&&0&.#:02#:!620"8 +&7'r;codebook_pixel_values)rvr(r*r)r+r,c$g|] } Srere)r_mask_generators r9rz2FlavaImageProcessor.preprocess..s!666!^^%%666r;bool_masked_pos)data tensor_type)#rkrlr rmrnrorprqrrrsrtrurvr(r*r)r+r,rwrxryrzr}r~r{r|rrrrrrrrr )'r8rrkrlrmrnrorprqrrrsrtrurvr(r*r)r+r,rwrxryrzr{r|r}r~rrrrrrrprocessed_imagesrcodebook_imagesmasksrs'` `````````` ``````````` `` @r9 preprocesszFlavaImageProcessor.preprocesssM|"+!6IIDN 'ttTYT""'388+9+E4K^!*!6IIDN !) DDD #-#9ZZt +9+E4K^'3'?||TEV #-#9ZZt !*!6IIDN 1B1N--TXTj3E3Q//W[Wn3E3Q//W[Wn&<&H " "dNi '=&H " "dNi  +6 ( '1 $+6 ( '1 $'=&H " "dNi 4F3Q//W[Wn)6)B HZ %mPPP 1B1N--TXTj5H5T11Z^Zr'>'J # #PTPl (?'J # #PTPl 4F3Q//W[Wn*+=J^___&<&H " "dNi &;%F ! !DLf 6I5T11Z^Zr3E3Q//W[Wn)&11F## :                  "#   & 01 ! <""#O&-B=A"'"$"$&(04-07;',#'(,!3!;(,,0$(5<'+&*GKFJAMoMoMotCH~&Mo% Mo  Mo DcN+ MoMoc5j)MoMoU5(5/#9:;MoE%%"89:Mo Mo Mo Mo !$!Mo"!) #Mo$&+%Mo&&.e_'Mo*!%+Mo,!-Mo. ~/Mo01Mo2"&3Mo4%SM5Mo6"7Mo8"'sEz!29Mo:!%;Mo< $=Mo>&eE8E?,B&CD?Mo@%U5(5/+A%BCAMoD EMoMoMoMoMoMo^ AT#s(^ A A A A A[ A     Y .(:'A>BDH . . z. 38n. % . eC)9$9:; . $E#/?*?$@A .  . . . . `G GrzGGGG %))-15)-.2%)*.'+:>9=(,2B2H8<>>>D>>tCH~& > -. > ! >DcN+>TN>!>tn>U5$u+#567>E%e"456> ~>./>$$45> !>>>>@%$&&%))-15)-.2%)*.'+:>9=,0,0,004047;7;15-126+/267;.23715049=8<;?(8(>DHIvCvCvCD>vCtCH~& vC -. vC ! vCDcN+vCTNvC!vCtnvCU5$u+#567vCE%e"456vC$D>vC%SMvC %SM!vC"!) #vC$!) %vC&&.e_'vC(&.e_)vC,!)-vC.%TN/vC0 S#X/1vC2$C=3vC4"*$5vC6%T#s(^47vC8&d^9vC:"*%;vC<!)=vC> (~?vC@&huo6AvCB%Xe_5CvCD!sJ!78EvCF&GvCH$E#/?*?$@AIvCJ KvCvCvC'&vCvCvCvCvCr;ri)5rr5rEcollections.abcr functoolsrtypingrrrnumpyr\image_processing_utilsr r r image_transformsr r image_utilsrrrrrrrrrrrutilsrrrrutils.import_utilsrr get_loggerrarrrrrr rd__annotations__r"ri__all__rer;r9rsX'&& $$$$$$''''''''''UUUUUUUUUUCCCCCCCC                          _^^^^^^^^^^^******JJJ  H % %$!%oo$__5KKKKKKKK\ ;tCtCtCtCtC,tCtC tCn ! !r;