
    sg@                         d Z ddlmZmZmZmZ ddlZddlm	Z	m
Z
mZ ddlmZmZmZ ddlmZmZmZmZmZmZmZmZmZmZmZ ddlmZmZmZ  ej@                  e!      Z" G d	 d
e	      Z#y)z Image processor class for LeViT.    )DictIterableOptionalUnionN   )BaseImageProcessorBatchFeatureget_size_dict)get_resize_output_image_sizeresizeto_channel_dimension_format)IMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STDChannelDimension
ImageInputPILImageResamplinginfer_channel_dimension_formatis_scaled_imagemake_list_of_imagesto_numpy_arrayvalid_imagesvalidate_preprocess_arguments)
TensorTypefilter_out_non_signature_kwargsloggingc            !       `    e Zd ZdZdgZddej                  dddddeef
de	de
eef   ded	e	d
e
eef   de	deeef   de	deeeee   f      deeeee   f      ddf fdZej                  ddfdej&                  de
eef   dedeeeef      deeeef      dej&                  fdZ e       dddddddddddej.                  dfdedee	   dee
eef      ded	ee	   d
ee
eef      dee	   dee   dee	   deeeee   f      deeeee   f      dee   dedeeeef      defd       Z xZS )LevitImageProcessora  
    Constructs a LeViT image processor.

    Args:
        do_resize (`bool`, *optional*, defaults to `True`):
            Wwhether to resize the shortest edge of the input to int(256/224 *`size`). Can be overridden by the
            `do_resize` parameter in the `preprocess` method.
        size (`Dict[str, int]`, *optional*, defaults to `{"shortest_edge": 224}`):
            Size of the output image after resizing. If size is a dict with keys "width" and "height", the image will
            be resized to `(size["height"], size["width"])`. If size is a dict with key "shortest_edge", the shortest
            edge value `c` is rescaled to `int(c * (256/224))`. The smaller edge of the image will be matched to this
            value i.e, if height > width, then image will be rescaled to `(size["shortest_egde"] * height / width,
            size["shortest_egde"])`. Can be overridden by the `size` parameter in the `preprocess` method.
        resample (`PILImageResampling`, *optional*, defaults to `Resampling.BICUBIC`):
            Resampling filter to use if resizing the image. Can be overridden by the `resample` parameter in the
            `preprocess` method.
        do_center_crop (`bool`, *optional*, defaults to `True`):
            Whether or not to center crop the input to `(crop_size["height"], crop_size["width"])`. Can be overridden
            by the `do_center_crop` parameter in the `preprocess` method.
        crop_size (`Dict`, *optional*, defaults to `{"height": 224, "width": 224}`):
            Desired image size after `center_crop`. Can be overridden by the `crop_size` parameter in the `preprocess`
            method.
        do_rescale (`bool`, *optional*, defaults to `True`):
            Controls whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by the
            `do_rescale` parameter in the `preprocess` method.
        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 the
            `preprocess` method.
        do_normalize (`bool`, *optional*, defaults to `True`):
            Controls whether to normalize the image. Can be overridden by the `do_normalize` parameter in the
            `preprocess` method.
        image_mean (`List[int]`, *optional*, defaults to `[0.485, 0.456, 0.406]`):
            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 (`List[int]`, *optional*, defaults to `[0.229, 0.224, 0.225]`):
            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.
    pixel_valuesTNgp?	do_resizesizeresampledo_center_crop	crop_size
do_rescalerescale_factordo_normalize
image_mean	image_stdreturnc                 2   t        |   di | ||nddi}t        |d      }||nddd}t        |d      }|| _        || _        || _        || _        || _        || _        || _	        || _
        |	|	nt        | _        |
|
| _        y t        | _        y )	Nshortest_edge   Fdefault_to_squareheightwidthr#   
param_name )super__init__r
   r   r    r!   r"   r#   r$   r%   r&   r   r'   r   r(   )selfr   r    r!   r"   r#   r$   r%   r&   r'   r(   kwargs	__class__s               c/var/www/html/venv/lib/python3.12/site-packages/transformers/models/levit/image_processing_levit.pyr6   zLevitImageProcessor.__init__X   s     	"6"'tos-CTU;!*!6IsUX<Y	!)D	"	 ,"$,((2(>*DY&/&;AU    imagedata_formatinput_data_formatc                     t        |d      }d|v r+t        d|d   z        }t        ||d|      }	|	d   |	d   d}d	|vsd
|vrt        d|j	                                t        |f|d	   |d
   f|||d|S )a-  
        Resize an image.

        If size is a dict with keys "width" and "height", the image will be resized to `(size["height"],
        size["width"])`.

        If size is a dict with key "shortest_edge", the shortest edge value `c` is rescaled to `int(c * (256/224))`.
        The smaller edge of the image will be matched to this value i.e, if height > width, then image will be rescaled
        to `(size["shortest_egde"] * height / width, size["shortest_egde"])`.

        Args:
            image (`np.ndarray`):
                Image to resize.
            size (`Dict[str, int]`):
                Size of the output image after resizing. If size is a dict with keys "width" and "height", the image
                will be resized to (height, width). If size is a dict with key "shortest_edge", the shortest edge value
                `c` is rescaled to int(`c` * (256/224)). The smaller edge of the image will be matched to this value
                i.e, if height > width, then image will be rescaled to (size * height / width, size).
            resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`):
                Resampling filter to use when resiizing the image.
            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.
        Fr-   r+   g$I$I?)r    r.   r>   r      r/   r0   r1   zFSize dict must have keys 'height' and 'width' or 'shortest_edge'. Got )r    r!   r=   r>   )r
   intr   
ValueErrorkeysr   )
r7   r<   r    r!   r=   r>   r8   	size_dictr+   output_sizes
             r:   r   zLevitImageProcessor.resizew   s    D "$%@	d"d?.C CDM6MUVgK $/q>KNKI9$y(@XYbYgYgYiXjk  
H%y'9:#/
 
 	
r;   imagesreturn_tensorsc                 ,   ||n| j                   }||n| j                  }||n| j                  }||n| j                  }||n| j                  }|	|	n| j
                  }	|
|
n| j                  }
||n| j                  }||n| j                  }t        |d      }||n| j                  }t        |d      }t        |      }t        |      st        d      t        |||	|
||||||
       |D cg c]  }t        |       }}t!        |d         r|rt"        j%                  d       |t'        |d         }|r"|D cg c]  }| j)                  ||||	       }}|r!|D cg c]  }| j+                  |||	       }}|r!|D cg c]  }| j-                  |||	       }}|	r"|D cg c]  }| j/                  ||
||	       }}|D cg c]  }t1        |||
       }}d|i}t3        ||      S c c}w c c}w c c}w c c}w c c}w c c}w )a  
        Preprocess an image or batch of images to be used as input to a LeViT model.

        Args:
            images (`ImageInput`):
                Image or batch of images 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 output image after resizing. If size is a dict with keys "width" and "height", the image
                will be resized to (height, width). If size is a dict with key "shortest_edge", the shortest edge value
                `c` is rescaled to int(`c` * (256/224)). The smaller edge of the image will be matched to this value
                i.e, if height > width, then image will be rescaled to (size * height / width, size).
            resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`):
                Resampling filter to use when resiizing the image.
            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 output image after center cropping. Crops images to (crop_size["height"],
                crop_size["width"]).
            do_rescale (`bool`, *optional*, defaults to `self.do_rescale`):
                Whether to rescale the image pixel values by `rescaling_factor` - typical to values between 0 and 1.
            rescale_factor (`float`, *optional*, defaults to `self.rescale_factor`):
                Factor to rescale the image pixel values by.
            do_normalize (`bool`, *optional*, defaults to `self.do_normalize`):
                Whether to normalize the image pixel values by `image_mean` and `image_std`.
            image_mean (`float` or `List[float]`, *optional*, defaults to `self.image_mean`):
                Mean to normalize the image pixel values by.
            image_std (`float` or `List[float]`, *optional*, defaults to `self.image_std`):
                Standard deviation to normalize the image pixel values by.
            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*, defaults to `ChannelDimension.FIRST`):
                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.
            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.
        Fr-   r#   r2   zkInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray.)
r$   r%   r&   r'   r(   r"   r#   r   r    r!   r   zIt 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.)r>   )input_channel_dimr   )datatensor_type)r   r!   r"   r$   r%   r&   r'   r(   r    r
   r#   r   r   rB   r   r   r   loggerwarning_oncer   r   center_croprescale	normalizer   r	   )r7   rF   r   r    r!   r"   r#   r$   r%   r&   r'   r(   rG   r=   r>   r<   rJ   s                    r:   
preprocesszLevitImageProcessor.preprocess   sn   H "+!6IDNN	'38+9+E4K^K^#-#9Zt
+9+E4K^K^'3'?|TEVEV#-#9Zt
!*!6IDNN	'tTYYTU;!*!6IDNN	!)D	$V,F#:  	&!)%!)	
 6<<E.'<<6!9%*s
 $ >vay Ikqrbgdkk%xK\k]rFrkqrbgd&&uiK\&]rFrlrschdll5.L]l^sFsoufkuj)O`aF 
 ou
ej'{N_`
 
 '>BB? = s s t
s$   5G8G=(HH.HH)__name__
__module____qualname____doc__model_input_namesr   BICUBICr   r   boolr   strrA   r   floatr   r   r6   npndarrayr   r   r   FIRSTr   r   r	   rQ   __classcell__)r9   s   @r:   r   r   .   s   %N (( #'9'A'A#$(,3!>S=QVV 38nV %	V
 V S>V V c5j)V V U5(5/#9:;V E%%"89:V 
VF (:'A'A>BDH5
zz5
 38n5
 %	5

 eC)9$9:;5
 $E#/?*?$@A5
 
5
n %& %))-'+)-.2%)*.'+>B=A/3(8(>(>DHCCCC D>CC tCH~&	CC
 %CC !CC DcN+CC TNCC !CC tnCC U5(5/#9:;CC E%%"89:CC !,CC &CC $E#/?*?$@ACC  
!CC 'CCr;   r   )$rU   typingr   r   r   r   numpyr[   image_processing_utilsr   r	   r
   image_transformsr   r   r   image_utilsr   r   r   r   r   r   r   r   r   r   r   utilsr   r   r   
get_loggerrR   rL   r   r4   r;   r:   <module>rf      se    ' 2 2  U U 
    J I 
		H	%DC, DCr;   