sgddlZddlmZmZmZmZmZmZmZddl Z ddl m Z m Z ddlmZmZmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZddl m!Z!m"Z"m#Z#e#jHe%Z&dZ'e"r ddl(Z(dd l(m)Z) d'd e*d e*d ee*d ee*dee*e*ff dZ+ d(d e*d e*d eee,e*fdee*e*ffdZ- d(de*deee,efdee*e*ffdZ.dedeee j^fdZ0deedeefdZ1 d(deee j^deee,efdee*fdZ2 d(de j^dee*e*fdeee,efde j^fdZ3 d)de j^dee(jhjhdeee,efdeee,efdef dZ5 d(de j^d e*d!e*d"e*d#e*deee,efde j^fd$Z6Gd%d&e Z7y)*N)AnyDictIterableListOptionalTupleUnion)BaseImageProcessor BatchFeature) PaddingModepadto_channel_dimension_format to_pil_image) IMAGENET_STANDARD_MEANIMAGENET_STANDARD_STDChannelDimension ImageInputPILImageResamplingget_image_sizeinfer_channel_dimension_formatis_scaled_imageis_valid_imageto_numpy_array valid_imagesvalidate_preprocess_arguments) TensorTypeis_vision_availableloggingi)Imageheightwidthmin_lenmax_lenreturnc| t||n|}||z }||k\r|}t||z }|dzdk7r(|dz }n"||kDr|}t||z}|dzdk7r|dz }t||}t||}||fS)a Get the output size of the image after resizing given a dictionary specifying the max and min sizes. Args: height (`int`): Height of the input image. width (`int`): Width of the input image. min_len (`int`, *optional*, defaults to 1): Minimum size of the output image. max_len (`int`, *optional*, defaults to the maximum size of the image): Maximum size of the output image. Returns: The output size of the image after resizing. rmaxint)r!r"r#r$ aspect_ratios i/var/www/html/venv/lib/python3.12/site-packages/transformers/models/idefics3/image_processing_idefics3.py&_resize_output_size_rescale_to_max_lenr.1s"%,Oc&% G6>L U\)* A:? aKF %F\)* 19> QJE !F w E 5=c| t||n|}||z }||k\r||kDr|}t||z }n||kDr||kDr|}t||z}t|d}t|d}||fS)a Get the output size of the image after resizing given a dictionary specifying the max and min sizes. Args: height (`int`): Height of the input image. width (`int`): Width of the input image. max_len (`Dict[str, int]`, *optional*, defaults to the maximum size of the image): Defines the maximum dimensions of the image. Returns: The output size of the image after resizing. r(r))r!r"r$r,s r-+_resize_output_size_scale_below_upper_boundr1Vs%,Oc&% G6>L 57?U\)* %FW,F\)*^F qME 5=r/resolution_max_sideinput_data_formatcvt||\}}t|||\}}t||t\}}||fS)a' Get the output size of the image after resizing given a dictionary specifying the max and min sizes. Args: image (`np.ndarray`): Image to resize. resolution_max_side (`int`): The longest edge of the image will be resized to this value. The shortest edge will be resized to keep the input aspect ratio. input_data_format (`ChannelDimension` or `str`): The channel dimension format of the input image. Returns: The output size of the image after resizing.  channel_dim)r$)rr.r1MAX_IMAGE_SIZE)imager2r3r!r"s r-get_resize_output_image_sizer9usG$#56GHMFE;65RefMFE?WefMFE 5=r/imagesclt|r|gg}|St|ttfr!t |dkDrt|dr|g}|St|ttfrLt |dkDr>t|dttfr%t |ddkDrt|ddr |St d)z Convert a single image or a list of images to a list of numpy arrays. Args: images (`ImageInput`): A single image or a list of images. Returns: A list of numpy arrays. rz]Invalid input type. Must be a single image, a list of images, or a list of batches of images.)r isinstancelisttuplelen ValueError)r:s r-make_list_of_imagesrAsf(" M FT5M *s6{Q>RXYZR[C\ M 6D%=) K!O vay4- 0 q NQ  6!9Q< ( M k  r/valuescJt|Dcgc] }t|c}Scc}w)zO Return the maximum value across all indices of an iterable of values. )zipr*)rBvalues_is r-max_across_indicesrFs +.v, 7hCM 77 7s  images_listc|t|ddd}tdx}}|D]1}|D]*}t||\}}t||}t||},3||fS)zH Get the maximum height and width across all images in a batch. rr(r  num_channelsz-infr5)rfloatrr*)rGr3 max_height max_widthr:r8r!r"s r-get_max_height_widthrPs  :;q>!;L[de"6]*J. .E*5>OPMFEVZ0JE9-I ..  ""r/r8 output_sizect||\}}tj|tj}d|d|d|f<|S)a Make a pixel mask for the image, where 1 indicates a valid pixel and 0 indicates padding. Args: image (`np.ndarray`): Image to make the pixel mask for. output_size (`Tuple[int, int]`): Output size of the mask. r5dtyper(N)rnpzerosint64)r8rQr3 input_height input_widthmasks r-make_pixel_maskr[sF!/uBS TL+ 88Krxx 0D()D,  $% Kr/palette data_formatc| t|d}||n|}|dnd}t|||}|jdk(r||j||j d}t j d|jd}t j||}|j d}tj|}t||tj }|S) a Converts an image to RGB format. Args: image (`np.ndarray`): The image to convert. palette (List[int], *optional*): The palette to use if given. data_format (ChannelDimension or str, *optional*): The channel dimension format for the output image. If not provided, it will be the same as the input image. input_data_format (ChannelDimension or str, *optional*): The channel dimension format of the input image. NrIrKP image_moder3RGBA)rcrcRGBinput_channel_dim)rrmode putpaletteconvertr newsizealpha_compositerUarrayrrLAST) r8r\r]r3rg image_rgba backgroundrl output_arrays r-convert_to_rgbrrs$ :5yY(3':# K%34D 4CT UE zzSW0 !v&J6:??ODJ++J CO%--e4O88O,L.|[\l\q\qrL r/w1h1w2h2c| t|d}|tjk(r|dd||||f}|S|tjk(r|||||ddf}|St d)NrIrK!Invalid channel dimension format.)rrFIRSTrnr@)r8rsrtrurvr]s r-_croprzs4US &,,,aB2o& L (-- -beRUAo& L<==r/c&BeZdZdZdgZdddej ddddddddf dededee e fd ed ed ee e fd ed e dede e e ee fde e e ee fdeddffd Zej ddfdej"dee e fd ede e e efde e e efdej"f dZej ddfd ee e fd ede e e efde e e effdZej ddfdej"de d ede e e efde e e eff dZ d%dej"dee e fde e ee fde ede e e efdej"f dZ d&deej"de e ee fded e e e efde ede e e efdefd!Zdddddddddddddd"ej8dfdede ede ede ee e fd ed e ed e ed e ee e fd e e de ede e e ee fde e e ee fde ed e e e efd#ede ede e e eff"d$ZxZS)'Idefics3ImageProcessora Constructs a Idefics3 image processor. Args: do_convert_rgb (`bool`, *optional*, defaults to `True`): Whether to convert the image to RGB. This is useful if the input image is of a different format e.g. RGBA. Only has an effect if the input image is in the PIL format. do_resize (`bool`, *optional*, defaults to `True`): Whether to resize the image. The longest edge of the image is resized to be <= `size["longest_edge"]`, with the shortest edge resized to keep the input aspect ratio. size (`Dict`, *optional*, defaults to `{"longest_edge": 4 * 364}`): Controls the size of the output image. This is a dictionary containing the key "longest_edge". The image will be resized such that the longest edge is <= `size["longest_edge"]` and the shortest edge is resized to keep the input aspect ratio. resample (`Resampling`, *optional*, defaults to `Resampling.LANCZOS`): Resampling filter to use when resizing the image. do_image_splitting (`bool`, *optional*, defaults to `True`): Whether to split the image into sub-images concatenated with the original image. They are split into patches such that each patch has a size of `max_image_size["height"]` x `max_image_size["width"]`. max_image_size (`Dict`, *optional*, defaults to `{"longest_edge": 364}`): Maximum resolution of the patches of images accepted by the model. This is a dictionary containing the key "longest_edge". do_rescale (`bool`, *optional*, defaults to `True`): Whether to rescale the image. If set to `True`, the image is rescaled to have pixel values between 0 and 1. rescale_factor (`float`, *optional*, defaults to `1/255`): Rescale factor to rescale the image by if `do_rescale` is set to `True`. do_normalize (`bool`, *optional*, defaults to `True`): Whether to normalize the image. If set to `True`, the image is normalized to have a mean of `image_mean` and a standard deviation of `image_std`. image_mean (`float` or `List[float]`, *optional*, defaults to `IDEFICS_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. Can be overridden by the `image_mean` parameter in the `preprocess` method. image_std (`float` or `List[float]`, *optional*, defaults to `IDEFICS_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. Can be overridden by the `image_std` parameter in the `preprocess` method. do_pad (`bool`, *optional*, defaults to `True`): Whether or not to pad the images to the largest height and width in the batch and number of images per sample in the batch, such that the returned tensor is of shape (batch_size, max_num_images, num_channels, max_height, max_width). pixel_valuesTNgp?do_convert_rgb do_resizerkresampledo_image_splittingmax_image_size do_rescalerescale_factor do_normalize image_mean image_stddo_padr%c  t|di| ||_||_||nddi|_||_||_||nddi|_||_||_ | |_ | | nt|_ | | nt|_| |_y)N longest_edgeiil)super__init__r~rrkrrrrrrrrrrr)selfr~rrkrrrrrrrrrkwargs __class__s r-rzIdefics3ImageProcessor.__init__Hs "6"," ,D>72K   "40>0JnQ_adPe$,((2(>*DZ&/&;AV r/r8r]r3c | t|d}||n|}d|vrt||d|}nd|vrd|vr |d|df}n tdd}|jd k(s|jd d k(rd }t ||| }|j |d |df|}tj|}|jd k(rtj|d n|}t||tj}|S)a Resize an image. The longest edge of the image is resized to size["longest_edge"], with the shortest edge resized to keep the input aspect ratio. Can also be used with size["height"] and size["width"]. Args: image (`np.ndarray`): Image to resize. size (`Dict[str, int]`): Size of the output image. resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.LANCZOS`): Resampling filter to use when resizing the image. data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the output image. If not provided, it will be the same as the input image. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred. NrIrKr)r2r3r!r"zJsize must be a dictionary with key 'longest_edge' or 'height' and 'width'.r'r(r_r`r)raxisre) rr9r@ndimshaperresizerUrm expand_dimsrrrn) rr8rkrr]r3rra resized_images r-rzIdefics3ImageProcessor.resizefs0  $ >uS\ ] ,7+>'K T !/4+?SdD 'T/NDM2Dij j ::?ekk"o2JUzM^_ d1gtAw%7( K / CPBTBTXYBY}2>_l 3 ;:J:O:O r/c `t||\}}|dx}} g} ||kDs|| kDrtj||z } tj|| z } tj|| z } tj|| z }t| D]\}t| D]L}||z}|| z}t ||z|}t || z|}t ||||||}| j |N^|| }}||k7s||k7r|j|||d||}nd\} } | j || | | fS)ap Split an image into squares of side max_image_size and the original image resized to max_image_size. That means that a single image becomes a sequence of images. This is a "trick" to spend more compute on each image with no changes in the vision encoder. 1) If one side of the original image is larger than `max_image_size`, resize it to `max_image_size` while preserving the aspect ratio. 2) Divide the resulting image into `ceil(height / max_image_size)` x `ceil(width / max_image_size)` sub-images of the same size each (image_size, image_size). Typically, 364x364. 3) Returns the list of the crops and the original image, in addition to the number of splits for the height and the width. Args: image (`np.ndarray`): Images to split. max_image_size (`Dict[str, int]`): Maximum size of the output image. If the image is larger than this size, it will be split into patches of this size, and the original image will be concatenated with the patches, resized to max_size. resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.LANCZOS`): Resampling filter to use when resizing the image. data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the output image. If not provided, it will be the same as the input image. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred. r5r)r]r!r"rr3)rr)rmathceilrangeminrzappendr)rr8rrr]r3r!r"rNrOframes num_splits_h num_splits_woptimal_height optimal_widthrcstart_xstart_yend_xend_y cropped_imageglobal_image_heightglobal_image_widths r- split_imagez"Idefics3ImageProcessor.split_images{:'u:KL !/!?? Y J %)"399Vj%89L99UY%67L!YYv '<=N IIel&:;M<( 1|,1A-/G.0G - 7?E. 8&AE%*$/ %MMM-0%1 1,7A)!3 ,,9K0K 2=OP%&1 $*. &L, e|\11r/vision_encoder_max_sizect||\}}||z }||k\rEtj||z |z}t||z }tj||z |z}nI||kDrDtj||z |z}t||z}tj||z |z}||d} |j || |||S)a Resize images to be multiples of `vision_encoder_max_size` while preserving the aspect ratio. Args: image (`np.ndarray`): Images to resize. vision_encoder_max_size (`int`): Maximum size of the output image. If the image is larger than this size, it will be split into patches of this size, and the original image will be concatenated with the patches, resized to max_size. resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.LANCZOS`): Resampling filter to use when resizing the image. data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the output image. If not provided, it will be the same as the input image. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred r5r)rkrr3r])rrrr+r) rr8rrr]r3r!r"r,new_sizes r-resize_for_vision_encoderz0Idefics3ImageProcessor.resize_for_vision_encoders.'u:KL v~ F?IIe&==>AXXE-.FYYv(??@CZZF e^YYv(??@CZZF-.EIIe&==>AXXE$u5{{ 8GXfq  r/rQconstant_valuesct||\}}|\}} ||z } | |z } d| fd| ff} t|| tj|||} | S)z< Pad an image with zeros to the given size. r5r)rgrr]r3)rrr CONSTANT)rr8rQrr]r3rXrY output_height output_width pad_bottom pad_rightpadding padded_images r- _pad_imagez!Idefics3ImageProcessor._pad_imagesp%35FW$X! k&1# |"\1  ;. z?Q N3  %%+#/  r/r:return_pixel_maskreturn_tensorsc .t||}t|}td|D} |t|dddn|}||n|}|tj k(r|ddj dn4|tjk(r|ddj dn tdfd } t|D cgc]"} t| D cgc] } | || c} $} } t|D cgc].} t| D cgc]} tj|c} 0} } t|D]H}t||D]5\}}|j||||| | ||<t||| | ||<7J|r| nd} | | fScc} wcc} wcc} wcc} w) a~ For a list of images, for each images, pads a batch of images to the bottom and right of the image with zeros to the size of largest height and width. For each sample in the batch, pads the sample with empty images to the max_number of images per sample in the batch. Optionally returns a pixel mask. Args: images (`List[np.ndarray]`): List of list of images to pad. Pads to the largest height and width in the batch. constant_values (`float` or `Iterable[float]`, *optional*): The value to use for the padding if `mode` is `"constant"`. return_pixel_mask (`bool`, *optional*, defaults to `True`): Whether to return a pixel mask. 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 (`str` or `ChannelDimension`, *optional*): The channel dimension format of the image. If not provided, it will be the same as the input image. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred. r3c32K|]}t|ywN)r?).0images_s r- z-Idefics3ImageProcessor.pad..Rs@gS\@sNrrIrKrrxc|tjk(r)tjg|tjS|tj k(r*tjg|tjSy)NrS)rryrUrVuint8rn)rkr3 n_channelss r- empty_imagez/Idefics3ImageProcessor.pad..empty_imageasc $4$:$::xx 3d 3288DD"&6&;&;;xx 3$ 3 3288DD(BST[ @@@!( +6!9Q'K  0 6 6 61++A.J "2"7"7 71++B/J@A A EZ__iYj TU~9N OA[; / O  V[[eUfgPQU>5JK(+Kg gz* I%.vi/@%A ! E<@OO$3 +&7 =L="9-j97FxCT7 Y' 3  (9|d !<//% P Lgs08F F F.FF FF FFreturn_row_col_infoc ||n |j}||n |j}||n |j}||n |j}| | n |j} ||n |j }||n |j }| | n |j} | | n |j} | | n |j} ||n |j}| | n |j} t|}t|ds tdt|| | | | ||||Dcgc]K}|Dcgc]=}t!|t"j"r|j$dk(r|j'nd?c}M}}}|Dcgc]}|Dcgc] }t)|c}}}}|t*j,dfvrF|Dcgc]8}|Dcgc]*}|j.dk(rt1j2|dn|,c}:}}}nX|t*j4k(rE|Dcgc]8}|Dcgc]*}|j.dk(rt1j2|dn|,c}:}}}t7|ddr|rt8j;d |t=|ddd }|r2|Dcgc]%}|Dcgc]}|j?|||| c}'}}}|r|Dcgc](}|Dcgc]}|jA||d ||c}*}}}g}g}g}g}tC||D]\}}g}g}g}g}tC||D]n\}} |jE|||\}!}"}#|jG|!|jG| gtI|!z|jK|"|jK|#p|jK||jK||jK||jK||}|}ns|Dcgc].}|Dcgc] }|j?||d |d d|| "c}0}}}|Dcgc]}dgtI|z}}|Dcgc]}dgtI|z}}|rItC||D cgc].\}}tC||D cgc]\}} tM|| c} }0}}}}} |r1|Dcgc]$}|Dcgc]}|jO|| |c}&}}}| r2|Dcgc]%}|Dcgc]}|jQ|| | |c}'}}}d}$| r|jS|d||\}}$|+|Dcgc]}|Dcgc]}tU|||c} }}}d| r|t1jV|n|i}%|$| r|t1jV|$n|$|%d<tY|%|}&|r ||&d<||&d<|&Scc}wcc}}wcc}wcc}}wcc}wcc}}wcc}wcc}}wcc}wcc}}wcc}wcc}}wcc}wcc}}wcc}wcc}wcc} }wcc} }}}wcc}wcc}}wcc}wcc}}wcc}wcc}}w)a Preprocess a batch of images. Args: images (`ImageInput`): A list of images to preprocess. do_convert_rgb (`bool`, *optional*, defaults to `self.do_convert_rgb`): Whether to convert the image to RGB. 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 after resizing. With the longest edge resized to keep the input aspect ratio. 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_image_splitting (`bool`, *optional*, defaults to `self.do_image_splitting`): Whether to split the image into sub-images concatenated with the original image. They are split into patches such that each patch has a size of `max_image_size["height"]` x `max_image_size["width"]`. max_image_size (`Dict`, *optional*, defaults to `self.max_image_size`): Maximum resolution of the images. If the image is larger than this size, the image is split into patches. do_rescale (`bool`, *optional*, defaults to `self.do_rescale`): Whether to rescale the image. 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 to use for normalization. Only has an effect if `do_normalize` is set to `True`. image_std (`float` or `List[float]`, *optional*, defaults to `self.image_std`): Image standard deviation to use for normalization. Only has an effect if `do_normalize` is set to `True`. do_pad (`bool`, *optional*, defaults to `self.do_pad`): Whether or not to pad the images to the largest height and width in the batch. 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`. return_row_col_info (`bool`, *optional*, default to `False`): Whether to return the number of rows and columns of the split images. This is used for the `Idefics3Processor` to generate prompt strings based on the number of rows and columns. data_format (`ChannelDimension` or `str`, *optional*, defaults to `ChannelDimension.FIRST`): The channel dimension format for the output 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. - Unset: Use the channel dimension format of the input image. 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. NrzkInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray.)rrrrrrrkrr_r'rrzIt 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.rIrK)r8rkrr3rr)rr3rr)r8meanstdr3T)rrr3rer}pixel_attention_mask)data tensor_typerowscols)-rrkrrrrrrrrr~rrArr@rr<r rg getpaletterrrnrrUrryrlogger warning_oncerrrrDrextendr?rrrrescale normalizerrrmr )'rr:r~rrkrrrrrrrrrrrr]r3rGim palettes_listr8imgimages_list_split_arrayspalettes_list_split_arraysimages_list_rowsimages_list_colspalettessplit_image_arrayssplit_palettes_arrays image_rows image_colsr\split_image_arrayrrrrencodings' r- preprocessz!Idefics3ImageProcessor.preprocess|s&T"+!6IDNN 'tTYY'38#-#9Zt +9+E4K^K^3E3Q/W[WnWn+9+E4K^K^'3'?|TEVEV #-#9Zt !*!6IDNN +9+E4K^K^!-4;;)&1 KN+:  &!)%! & dj j]_ 2u{{ ;3R]]_TX X j  R]]v6B%u-B] ] !1!6!6 = =it_eSYZCQ"-CGZK"2"8"8 8hs^dRXY3A !,3FYK ;q>!, -*   s   $ >{1~a?P_h i   *  "(KKe$]nKoK *"( 22~n=du3K(* $)+ &! ! $' ]$C 4 %'"(*%  &)&(&; ,NE7484D4D'5*;5E51%tT '--.?@)00'SAR=S1ST%%d+%%d+ ,)//0BC*112GH '' 3 '' 3% 4&3K6M* "( KK#(6~(FQ_`nQop!)*;   K ALLfc&k 1L L@KLfc&k 1L L ),K(G$FHCFfhBWX,#wW-XK *hnn^ce^GXYnK  *  "(NNZYbsNtK $ 04tNfw191 -K-  " *  "(0{VghKND^ 5dop  +28^=W-.]q ' ( T~F /HV /HV [ k C] [ Z J  MLYo s= VAV V VV 0V V/V V* V)3/V$ "V). V47V/ V4# V?,V: V? W  %W 0W <WWW W0W  W- W( &W-5 W8>W3 W8 XW> #XVVV$V)/V4:V?W W (W-3W8>X)rNN)rTNNN) __name__ __module__ __qualname____doc__model_input_namesrLANCZOSboolrstrr+rMrr rrrUndarrayrrrrrrrrr rryrr __classcell__)rs@r-r|r|s&P(( $#'9'A'A#')- '!:>9=38n  %  ! S#XU5$u+#567E%e"456 D(:'A'A>BDH 7zz738n7% 7 eC)9$9:; 7 $E#/?*?$@A 7 7z(:'A'A>BDH M2S#XM2% M2 eC)9$9:; M2 $E#/?*?$@A M2f(:'A'A>BDH % zz% "%% % % eC)9$9:; % $E#/?*?$@A % V:;26DH zz38_uhuo56  ./  $E#/?*?$@A  <:;"&;?26DHJ0RZZ J0uhuo56J0 J0 !sJ!78 J0 ./ J0$E#/?*?$@AJ0 J0^*.$()-'+-1%)37*.'+:>9=!%;?$)2B2H2HDH%yy!yD> y tCH~& y % y%TNyTNy!c3h0y!ytnyU5$u+#567yE%e"456yy!sJ!78y "!y"./#y$$E#/?*?$@A%yr/r|)r(Nr)NNN)8rtypingrrrrrrr numpyrUimage_processing_utilsr r image_transformsr rrr image_utilsrrrrrrrrrrrrutilsrrr get_loggerrrr7PILr r+r.rr1r9rrArFrPr[ ImagePaletterrrzr|rr/r-rs  DDDF[[    >=   H %SW" ""&.sm"BJ3-" 38_"LBF &.tCH~&> 38_DAE c+;&; <= 38_ 8 tD4D/ED8x}8c8fj#d2::&'#@D & ::& c&&33 4&%%5 567& c+;&; <= &  &`;?  ::     %%5 567 ZZ*X /X r/