
    sg`_                        d Z ddlmZmZmZmZmZmZ ddlZ	ddl
mZ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!m"Z"m#Z#m$Z$ dd	l%m&Z&  e#       rddl'Z' e!       rddl(Z( e$jR                  e*      Z+ G d
 de      Z,y)zImage processor class for Beit.    )AnyDictListOptionalTupleUnionN   )INIT_SERVICE_KWARGSBaseImageProcessorBatchFeatureget_size_dict)resizeto_channel_dimension_format)IMAGENET_STANDARD_MEANIMAGENET_STANDARD_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is_torch_availableis_torch_tensoris_vision_availablelogging)deprecate_kwargc            &           e Zd ZdZdgZ eddd       ee      dd	ej                  dd	d
ddd	d	dfde
deeef   dede
deeef   deeef   de
de
deeeee   f      deeeee   f      de
dd	f fd              Zedeeef   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dedej.                  fdZ	 	 	 	 	 	 	 	 	 	 	 	 d+dede
de
deeef   dede
deeef   de
dede
deeeee   f      deeeee   f      deeeef      fd Z	 	 	 	 	 	 	 	 	 	 	 	 d+dede
deeef   dede
deeef   de
dede
deeeee   f      deeeee   f      deeeef      deeeef      dej.                  fd!Z	 	 	 	 	 	 	 d,d"ede
deeef   dede
deeef   de
deeeef      fd#Zd- fd$	Z eddd       e       d	d	d	d	d	d	d	d	d	d	d	d	d	ej@                  d	fd%ed&ee   de
deeef   dede
deeef   de
dede
deeeee   f      deeeee   f      dee
   d'eeee!f      dedeeeef      de"jF                  jF                  f"d(              Z$d-d)ee%   fd*Z& xZ'S ).BeitImageProcessoraK  
    Constructs a BEiT 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 the `preprocess` method.
        size (`Dict[str, int]` *optional*, defaults to `{"height": 256, "width": 256}`):
            Size of the output image after resizing. 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 to center crop the image. If the input size is smaller than `crop_size` along any edge, the image
            is padded with 0's and then center cropped. Can be overridden by the `do_center_crop` parameter in the
            `preprocess` method.
        crop_size (`Dict[str, int]`, *optional*, defaults to `{"height": 224, "width": 224}`):
            Desired output size when applying center-cropping. Only has an effect if `do_center_crop` is set to `True`.
            Can be overridden by the `crop_size` 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_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.
        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_STANDARD_MEAN`):
            The mean to use if normalizing the image. This is a float or list of floats of length of the number of
            channels of 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`):
            The standard deviation to use if normalizing the image. This is a float or list of floats of length of the
            number of channels of the image. Can be overridden by the `image_std` parameter in the `preprocess` method.
        do_reduce_labels (`bool`, *optional*, defaults to `False`):
            Whether or not to reduce all label values of segmentation maps by 1. Usually used for datasets where 0 is
            used for background, and background itself is not included in all classes of a dataset (e.g. ADE20k). The
            background label will be replaced by 255. Can be overridden by the `do_reduce_labels` parameter in the
            `preprocess` method.
    pixel_valuesreduce_labelsdo_reduce_labelsz4.41.0)new_nameversion)extraTNgp?F	do_resizesizeresampledo_center_crop	crop_sizerescale_factor
do_rescaledo_normalize
image_mean	image_stdreturnc                 2   t        |   di | ||nddd}t        |      }||nddd}t        |d      }|| _        || _        || _        || _        || _        || _        || _	        || _
        |	|	nt        | _        |
|
nt        | _        || _        y )N   )heightwidth   r.   )
param_name )super__init__r   r*   r+   r,   r-   r.   r0   r/   r1   r   r2   r   r3   r&   )selfr*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r&   kwargs	__class__s                a/var/www/html/venv/lib/python3.12/site-packages/transformers/models/beit/image_processing_beit.pyr=   zBeitImageProcessor.__init__f   s    " 	"6"'tc-JT"!*!6IsUX<Y	!)D	"	 ,"$,((2(>*DZ&/&;AV 0    image_processor_dictc                 t    |j                         }d|v r|j                  d      |d<   t        |   |fi |S )z
        Overrides the `from_dict` method from the base class to save support of deprecated `reduce_labels` in old configs
        r%   r&   )copypopr<   	from_dict)clsrC   r?   r@   s      rA   rG   zBeitImageProcessor.from_dict   sK    
  488:227K7O7OP_7` !34w !5@@@rB   imagedata_formatinput_data_formatc                     t        |dd      }d|vsd|vrt        d|j                                t        |f|d   |d   f|||d|S )a  
        Resize an image to (size["height"], size["width"]).

        Args:
            image (`np.ndarray`):
                Image to resize.
            size (`Dict[str, int]`):
                Size of the output image.
            resample (`PILImageResampling`, *optional*, defaults to `PIL.Image.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 (`str` or `ChannelDimension`, *optional*):
                The channel dimension format of the input image. If not provided, it will be inferred.
        Tr+   default_to_squarer:   r7   r8   z@The `size` argument must contain `height` and `width` keys. Got )r+   r,   rJ   rK   )r   
ValueErrorkeysr   )r>   rI   r+   r,   rJ   rK   r?   s          rA   r   zBeitImageProcessor.resize   sw    0 TTfM47$#6_`d`i`i`k_lmnn
x.$w-0#/
 
 	
rB   labelc                 F    t        |      }d||dk(  <   |dz
  }d||dk(  <   |S )N   r         )r   )r>   rQ   s     rA   reduce_labelzBeitImageProcessor.reduce_label   s6    u%eqj	!eslrB   c                     |r| j                  |      }|r| j                  ||||      }|r| j                  |||      }|r| j                  ||	|      }|
r| j	                  ||||      }|S )N)rI   r+   r,   rK   )rI   r+   rK   )rI   scalerK   )rI   meanstdrK   )rV   r   center_croprescale	normalize)r>   rI   r&   r*   r+   r,   r-   r.   r0   r/   r1   r2   r3   rK   s                 rA   _preprocesszBeitImageProcessor._preprocess   s      %%e,EKKe$]nKoE$$5yTe$fELLuNVgLhENNZYbsNtErB   c                     t        |      }t        |      r|rt        j                  d       |t	        |      }| j                  |d||||||||	|
||      }|t        |||      }|S )zPreprocesses a single image.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.F)r&   r*   r+   r,   r-   r.   r0   r/   r1   r2   r3   rK   )input_channel_dim)r   r   loggerwarning_oncer   r^   r   )r>   rI   r*   r+   r,   r-   r.   r0   r/   r1   r2   r3   rJ   rK   s                 rA   _preprocess_imagez$BeitImageProcessor._preprocess_image   s    $ u%5!js $ >u E  ")!)%!/ ! 
 "/{VghErB   segmentation_mapc	                 N   t        |      }|j                  dk(  r|d   }d}	t        j                  }nd}	|t	        |d      }| j                  |||||||ddt        j                  
      }|	rt        j                  |d	      }|j                  t        j                        }|S )
z'Preprocesses a single segmentation map.   )N.TFrT   )num_channels)
rI   r&   r*   r,   r+   r-   r.   r1   r0   rK   r   )axis)
r   ndimr   FIRSTr   r^   npsqueezeastypeint64)
r>   rd   r*   r+   r,   r-   r.   r&   rK   added_dimensions
             rA   _preprocess_segmentation_mapz/BeitImageProcessor._preprocess_segmentation_map  s     **:;  A%/	:"O 0 6 6#O ($BCSbc$d!++"-).44 , 
 !zz*:C+22288<rB   c                 (    t        |   |fd|i|S )Nsegmentation_maps)r<   __call__)r>   imagesrr   r?   r@   s       rA   rs   zBeitImageProcessor.__call__5  s      wV:KVvVVrB   rt   rr   return_tensorsc                 8   ||n| j                   }||n| j                  }t        |dd      }||n| j                  }||n| j                  }||n| j
                  }t        |dd      }||n| j                  }|	|	n| j                  }	|
|
n| j                  }
||n| j                  }||n| j                  }||n| j                  }t        |      }|t        |d      }|t        |      st        d      t        |      st        d      t        ||	|
|||||||	
       |D cg c]   }| j!                  |||||
|||	|||||
      " }}d|i}|*|D cg c]  }| j#                  |||||||       }}||d<   t%        ||      S c c}w c c}w )aI  
        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`.
            segmentation_maps (`ImageInput`, *optional*)
                Segmentation maps 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 after resizing.
            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 image after center crop. If one edge the image is smaller than `crop_size`, it will be
                padded with zeros and then cropped
            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.
            do_reduce_labels (`bool`, *optional*, defaults to `self.do_reduce_labels`):
                Whether or not to reduce all label values of segmentation maps by 1. Usually used for datasets where 0
                is used for background, and background itself is not included in all classes of a dataset (e.g.
                ADE20k). The background label will be replaced by 255.
            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:
                - `"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.
        Tr+   rM   r.   rf   )expected_ndimszwInvalid segmentation_maps type. Must be of type PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray.zkInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray.)
r0   r/   r1   r2   r3   r-   r.   r*   r+   r,   )rI   r*   r-   r0   r1   r,   r+   r/   r.   r2   r3   rJ   rK   r$   )rd   r&   r*   r,   r+   r-   r.   labels)datatensor_type)r*   r+   r   r,   r-   r.   r0   r/   r1   r2   r3   r&   r   r   rO   r   rc   rp   r   )r>   rt   rr   r*   r+   r,   r-   r.   r0   r/   r1   r2   r3   r&   ru   rJ   rK   imgry   rd   s                       rA   
preprocesszBeitImageProcessor.preprocess:  s4   X "+!6IDNN	'tTYYTTfM'38+9+E4K^K^!*!6IDNN	!)tP[\	#-#9Zt
+9+E4K^K^'3'?|TEVEV#-#9Zt
!*!6IDNN	/?/K+QUQfQf$V,( 34EVW X(>O1P:  F#: 
 	&!)%!)	
: !
   ""#-%)!-#%#'"3 # 
 
& '( ):! % 11%5%5'%#1' 2 ! ! /DN>BBI
,!s   .%FFtarget_sizesc                 &   |j                   }|t        |      t        |      k7  rt        d      t        |      r|j	                         }g }t        t        |            D ]k  }t        j                  j                  j                  ||   j                  d      ||   dd      }|d   j                  d      }|j                  |       m |S |j                  d      }t        |j                  d         D cg c]  }||   	 }}|S c c}w )a6  
        Converts the output of [`BeitForSemanticSegmentation`] into semantic segmentation maps. Only supports PyTorch.

        Args:
            outputs ([`BeitForSemanticSegmentation`]):
                Raw outputs of the model.
            target_sizes (`List[Tuple]` of length `batch_size`, *optional*):
                List of tuples corresponding to the requested final size (height, width) of each prediction. If unset,
                predictions will not be resized.

        Returns:
            semantic_segmentation: `List[torch.Tensor]` of length `batch_size`, where each item is a semantic
            segmentation map of shape (height, width) corresponding to the target_sizes entry (if `target_sizes` is
            specified). Each entry of each `torch.Tensor` correspond to a semantic class id.
        zTMake sure that you pass in as many target sizes as the batch dimension of the logitsr   )dimbilinearF)r+   modealign_cornersrT   )logitslenrO   r   numpyrangetorchnn
functionalinterpolate	unsqueezeargmaxappendshape)	r>   outputsr}   r   semantic_segmentationidxresized_logitssemantic_mapis	            rA   "post_process_semantic_segmentationz5BeitImageProcessor.post_process_semantic_segmentation  s(   "  #6{c,// j  |,+113$&!S[) ;!&!4!4!@!@3K))a)0|C7Hzin "A "  .a077A7>%,,\:; %$ %+MMaM$8!GLMbMhMhijMkGl$m!%:1%=$m!$m$$ %ns   >D)NNNNNNNNNNNN)NNNNNNN)N)(__name__
__module____qualname____doc__model_input_namesr!   r   r
   r   BICUBICboolr   strintr   floatr   r   r=   classmethodr   rG   rk   ndarrayr   r   r   rV   r^   rc   rp   rs   rj   r   PILImager|   r   r   __classcell__)r@   s   @rA   r#   r#   9   s   (T ((_/A8T$+>? #'9'A'A#$(,3!:>9=!&11 38n1 %	1
 1 S>1 c5j)1 1 1 U5$u+#5671 E%e"4561 1 
1 @ U1@ AT#s(^ A A (:'A'A>BDH"
zz"
 38n"
 %	"

 eC)9$9:;"
 $E#/?*?$@A"
 
"
H*   "&#'+#$( $!:>9=DH  	
 38n %  S>    U5$u+#567 E%e"456 $E#/?*?$@AH #'+#$( $!:>9=>BDH++ + 38n	+
 %+ + S>+ + + + U5$u+#567+ E%e"456+ eC)9$9:;+ $E#/?*?$@A+ 
+` #'+#$(!%DH' $'  '  38n	' 
 %'  '  S>'  '  $E#/?*?$@A' RW
 _/A8T$& 37#'+#$( $!:>9=+/;?(8(>(>DH#YCYC $J/YC 	YC
 38nYC %YC YC S>YC YC YC YC U5$u+#567YC E%e"456YC #4.YC !sJ!78YC  &!YC" $E#/?*?$@A#YC$ 
%YC ' UYCv)%U )%rB   r#   )-r   typingr   r   r   r   r   r   r   rk   image_processing_utilsr
   r   r   r   image_transformsr   r   image_utilsr   r   r   r   r   r   r   r   r   r   r   utilsr   r   r   r   r   r    utils.deprecationr!   r   r   
get_loggerr   ra   r#   r;   rB   rA   <module>r      sv    & : :  j j C     1  
		H	%G%+ G%rB   