
    qiL4                         d Z ddlZddlmZmZmZ ddl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j4                  e      Z G d d	e      Zd	gZy)
zImage processor class for Pvt.    N   )BaseImageProcessorBatchFeatureget_size_dict)resizeto_channel_dimension_format)IMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STDChannelDimension
ImageInputPILImageResamplinginfer_channel_dimension_formatis_scaled_imagemake_flat_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fdedee	e
f   dz  ded	ed
e
ez  dedeee   z  dz  deee   z  dz  ddf fdZej                  ddfdej                  dee	e
f   dede	ez  dz  de	ez  dz  dej                  fdZ e       dddddddddej&                  dfdededz  dee	e
f   dz  dedz  d	edz  d
edz  dedz  deee   z  dz  deee   z  dz  de	ez  dz  de	ez  de	ez  dz  fd       Z xZS )PvtImageProcessora  
    Constructs a PVT image processor.

    Args:
        do_resize (`bool`, *optional*, defaults to `True`):
            Whether to resize the image's (height, width) dimensions to the specified `(size["height"],
            size["width"])`. Can be overridden by the `do_resize` parameter in the `preprocess` method.
        size (`dict`, *optional*, defaults to `{"height": 224, "width": 224}`):
            Size of the output image after resizing. Can be overridden by the `size` parameter in the `preprocess`
            method.
        resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`):
            Resampling filter to use if resizing the image. Can be overridden by the `resample` parameter in the
            `preprocess` method.
        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 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`):
            Whether to normalize the image. Can be overridden by the `do_normalize` parameter in the `preprocess`
            method.
        image_mean (`float` or `list[float]`, *optional*, defaults to `IMAGENET_DEFAULT_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_DEFAULT_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.
    pixel_valuesTNgp?	do_resizesizeresample
do_rescalerescale_factordo_normalize
image_mean	image_stdreturnc	                     t        
|   di |	 ||nddd}t        |      }|| _        || _        || _        || _        || _        || _        ||nt        | _
        ||| _        y t        | _        y )N   )heightwidth )super__init__r   r   r   r   r   r   r   r	   r    r
   r!   )selfr   r   r   r   r   r   r    r!   kwargs	__class__s             ^/opt/pipecat/venv/lib/python3.12/site-packages/transformers/models/pvt/image_processing_pvt.pyr)   zPvtImageProcessor.__init__H   s~     	"6"'tc-JT""$(	 ,(2(>*DY&/&;AU    imagedata_formatinput_data_formatc                     t        |      }d|vsd|vrt        d|j                                |d   |d   f}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.
        r%   r&   zFThe `size` dictionary must contain the keys `height` and `width`. Got )r   r   r0   r1   )r   
ValueErrorkeysr   )r*   r/   r   r   r0   r1   r+   output_sizes           r-   r   zPvtImageProcessor.resize`   sy    H T"47$#6efjfofofqersttH~tG}5
#/
 
 	
r.   imagesreturn_tensorsc           
      z   ||n| j                   }||n| j                  }||n| j                  }||n| j                  }||n| j                  }||n| j
                  }|	|	n| j                  }	||n| j                  }t        |      }t        |      }t        |      st        d      t        |||||	|||       |D cg c]  }t        |       }}|r#t        |d         rt        j!                  d       |t#        |d         }|r"|D cg c]  }| j%                  ||||       }}|r!|D cg c]  }| j'                  |||       }}|r"|D cg c]  }| j)                  |||	|       }}|D cg c]  }t+        |||       }}d	|i}t-        ||

      S c c}w c c}w c c}w c c}w c c}w )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`):
                Dictionary in the format `{"height": h, "width": w}` specifying the size of the output image after
                resizing.
            resample (`PILImageResampling` filter, *optional*, defaults to `self.resample`):
                `PILImageResampling` filter to use if resizing the image e.g. `PILImageResampling.BICUBIC`. Only has
                an effect if `do_resize` 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 to use if `do_normalize` is set to `True`.
            image_std (`float` or `list[float]`, *optional*, defaults to `self.image_std`):
                Image standard deviation to use if `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.PYTORCH` or `'pt'`: Return a batch of type `torch.Tensor`.
                - `TensorType.NUMPY` or `'np'`: Return a batch of type `np.ndarray`.
            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.
        zSInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, or torch.Tensor)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/   r   r   r1   )r/   scaler1   )r/   meanstdr1   )input_channel_dimr   )datatensor_type)r   r   r   r   r   r    r!   r   r   r   r   r3   r   r   r   loggerwarning_oncer   r   rescale	normalizer   r   )r*   r6   r   r   r   r   r   r   r    r!   r7   r0   r1   	size_dictr/   r=   s                   r-   
preprocesszPvtImageProcessor.preprocess   s   t "+!6IDNN	#-#9Zt
'3'?|TEVEV'38+9+E4K^K^#-#9Zt
!*!6IDNN	'tTYY!$'	)&1F#rss%!)%!		
 6<<E.'<</&)4s
 $ >vay I $ %i(^opF 
  $ 5RcdF 
  $ U^opF  ou
ej'{N_`
 
 '>BBG =

s   F$F)7F.F3<F8)__name__
__module____qualname____doc__model_input_namesr   BICUBICbooldictstrintfloatlistr)   npndarrayr   r   r   FIRSTr   r   rD   __classcell__)r,   s   @r-   r   r   '   si   < (( &*'9'A'A&-!1504VV 38nt#V %	V
 V eV V DK'$.V 4;&-V 
V8 (:'A'A59;?/
zz/
 38n/
 %	/

 ++d2/
 !11D8/
 
/
b %& "&&*.2"&'+$(150426.>.D.D;?wCwC $;wC 38nt#	wC
 %t+wC 4KwC wC TkwC DK'$.wC 4;&-wC j(4/wC ++wC !11D8wC 'wCr.   r   )rH   numpyrQ   image_processing_utilsr   r   r   image_transformsr   r   image_utilsr	   r
   r   r   r   r   r   r   r   r   r   utilsr   r   r   
get_loggerrE   r?   r   __all__r'   r.   r-   <module>r\      sc    %  U U C    J I 
		H	%bC* bCJ 
r.   