
    sgT                         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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mZ ddlmZm Z m!Z! dd	l"m#Z#  e!jH                  e%      Z& e#       rddl'Z' G d
 de	      Z(y)z Image processor class for Donut.    )DictListOptionalUnionN   )BaseImageProcessorBatchFeatureget_size_dict)get_resize_output_image_sizepadresizeto_channel_dimension_format)IMAGENET_STANDARD_MEANIMAGENET_STANDARD_STDChannelDimension
ImageInputPILImageResamplingget_image_size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logging)is_vision_availablec            %           e Zd ZdZdgZ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de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	 	 d dej"                  d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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 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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ddej4                  dfdededee	e
f   d	ed
ededede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   deee	ef      dej<                  j<                  f"d       Z xZ S )"DonutImageProcessora	  
    Constructs a Donut 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
            `do_resize` in the `preprocess` method.
        size (`Dict[str, int]` *optional*, defaults to `{"shortest_edge": 224}`):
            Size of the image after resizing. The shortest edge of the image is resized to size["shortest_edge"], with
            the longest edge resized to keep the input aspect ratio. Can be overridden by `size` in the `preprocess`
            method.
        resample (`PILImageResampling`, *optional*, defaults to `Resampling.BILINEAR`):
            Resampling filter to use if resizing the image. Can be overridden by `resample` in the `preprocess` method.
        do_thumbnail (`bool`, *optional*, defaults to `True`):
            Whether to resize the image using thumbnail method.
        do_align_long_axis (`bool`, *optional*, defaults to `False`):
            Whether to align the long axis of the image with the long axis of `size` by rotating by 90 degrees.
        do_pad (`bool`, *optional*, defaults to `True`):
            Whether to pad the image. If `random_padding` is set to `True` in `preprocess`, each image is padded with a
            random amont of padding on each size, up to the largest image size in the batch. Otherwise, all images are
            padded to the largest image size in the batch.
        do_rescale (`bool`, *optional*, defaults to `True`):
            Whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by `do_rescale` 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 `rescale_factor` in the `preprocess`
            method.
        do_normalize (`bool`, *optional*, defaults to `True`):
            Whether to normalize the image. Can be overridden by `do_normalize` in the `preprocess` method.
        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`):
            Image standard deviation.
    pixel_valuesTNFgp?	do_resizesizeresampledo_thumbnaildo_align_long_axisdo_pad
do_rescalerescale_factordo_normalize
image_mean	image_stdreturnc                 N   t        |   di | ||nddd}t        |t        t        f      r|d d d   }t        |      }|| _        || _        || _        || _	        || _
        || _        || _        || _        |	| _        |
|
nt        | _        ||| _        y t"        | _        y )Ni 
  i  )heightwidth )super__init__
isinstancetuplelistr
   r"   r#   r$   r%   r&   r'   r(   r)   r*   r   r+   r   r,   )selfr"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   kwargs	__class__s                c/var/www/html/venv/lib/python3.12/site-packages/transformers/models/donut/image_processing_donut.pyr4   zDonutImageProcessor.__init__\   s     	"6"'tt-LdUDM*":DT""	 ("4$,((2(>*DZ&/&;AV    imagedata_formatinput_data_formatc                     t        ||      \  }}|d   |d   }}||k  r||kD  s
||kD  r||k  rt        j                  |d      }|t        |||      }|S )a  
        Align the long axis of the image to the longest axis of the specified size.

        Args:
            image (`np.ndarray`):
                The image to be aligned.
            size (`Dict[str, int]`):
                The size `{"height": h, "width": w}` to align the long axis to.
            data_format (`str` or `ChannelDimension`, *optional*):
                The data format of the output image. If unset, the same format as the input image is used.
            input_data_format (`ChannelDimension` or `str`, *optional*):
                The channel dimension format of the input image. If not provided, it will be inferred.

        Returns:
            `np.ndarray`: The aligned image.
        channel_dimr/   r0   r   input_channel_dim)r   nprot90r   )	r8   r=   r#   r>   r?   input_heightinput_widthoutput_heightoutput_widths	            r;   align_long_axisz#DonutImageProcessor.align_long_axis   so    . %35FW$X!k&*8nd7m|=([<-G=([<-GHHUA&E"/{VghEr<   random_paddingc                 6   |d   |d   }}t        ||      \  }}	||	z
  }
||z
  }|rIt        j                  j                  d|dz         }t        j                  j                  d|
dz         }n
|dz  }|
dz  }||z
  }|
|z
  }||f||ff}t	        ||||      S )	a  
        Pad the image to the specified size.

        Args:
            image (`np.ndarray`):
                The image to be padded.
            size (`Dict[str, int]`):
                The size `{"height": h, "width": w}` to pad the image to.
            random_padding (`bool`, *optional*, defaults to `False`):
                Whether to use random padding or not.
            data_format (`str` or `ChannelDimension`, *optional*):
                The data format of the output image. If unset, the same format as the input image is used.
            input_data_format (`ChannelDimension` or `str`, *optional*):
                The channel dimension format of the input image. If not provided, it will be inferred.
        r/   r0   rA   r      )lowhigh   )r>   r?   )r   rE   randomrandintr   )r8   r=   r#   rL   r>   r?   rI   rJ   rG   rH   delta_widthdelta_heightpad_toppad_left
pad_bottom	pad_rightpaddings                    r;   	pad_imagezDonutImageProcessor.pad_image   s    . '+8nd7m|$25FW$X!k"[0$|3ii''AL14D'EGyy((Q[1_(EH"a'G"a'H!G+
(*	Z(8Y*?@5'{N_``r<   c                 P    t         j                  d        | j                  |i |S )NzTpad is deprecated and will be removed in version 4.27. Please use pad_image instead.)loggerinfor[   )r8   argsr9   s      r;   r   zDonutImageProcessor.pad   s%    jkt~~t.v..r<   c           	          t        ||      \  }}|d   |d   }
}	t        ||	      }t        ||
      }||k(  r||k(  r|S ||kD  rt        ||z  |z        }n||kD  rt        ||z  |z        }t        |f||f|d||d|S )as  
        Resize the image to make a thumbnail. The image is resized so that no dimension is larger than any
        corresponding dimension of the specified size.

        Args:
            image (`np.ndarray`):
                The image to be resized.
            size (`Dict[str, int]`):
                The size `{"height": h, "width": w}` to resize the image to.
            resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`):
                The resampling filter to use.
            data_format (`Optional[Union[str, ChannelDimension]]`, *optional*):
                The data format of the output image. If unset, the same format as the input image is used.
            input_data_format (`ChannelDimension` or `str`, *optional*):
                The channel dimension format of the input image. If not provided, it will be inferred.
        rA   r/   r0   g       @)r#   r$   reducing_gapr>   r?   )r   minintr   )r8   r=   r#   r$   r>   r?   r9   rG   rH   rI   rJ   r/   r0   s                r;   	thumbnailzDonutImageProcessor.thumbnail   s    2 %35FW$X!k&*8nd7m| \=1K.\!e{&:L+%f,|;<E<'-;<F
%#/
 
 	
r<   c                     t        |      }t        |d   |d         }t        ||d|      }t        |f||||d|}	|	S )a  
        Resizes `image` to `(height, width)` specified by `size` using the PIL library.

        Args:
            image (`np.ndarray`):
                Image to resize.
            size (`Dict[str, int]`):
                Size of the output image.
            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.
        r/   r0   F)r#   default_to_squarer?   )r#   r$   r>   r?   )r
   rb   r   r   )
r8   r=   r#   r$   r>   r?   r9   shortest_edgeoutput_sizeresized_images
             r;   r   zDonutImageProcessor.resize  sh    0 T"DNDM:2Rc
 
#/
 
 r<   imagesreturn_tensorsc                    ||n| j                   }||n| j                  }t        |t        t        f      r|ddd   }t        |      }||n| j                  }||n| j                  }||n| j                  }||n| j                  }|	|	n| j                  }	|
|
n| j                  }
||n| j                  }||n| j                  }||n| j                  }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]  }| j1                  |||       }}|r"|D cg c]  }| j3                  ||||       }}|r!|D cg c]  }| j5                  |||	       }}|r"|D cg c]  }| j7                  ||||
       }}|	r!|D cg c]  }| j9                  ||
|       }}|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 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`):
                Size of the image after resizing. Shortest edge of the image is resized to min(size["height"],
                size["width"]) 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_thumbnail (`bool`, *optional*, defaults to `self.do_thumbnail`):
                Whether to resize the image using thumbnail method.
            do_align_long_axis (`bool`, *optional*, defaults to `self.do_align_long_axis`):
                Whether to align the long axis of the image with the long axis of `size` by rotating by 90 degrees.
            do_pad (`bool`, *optional*, defaults to `self.do_pad`):
                Whether to pad the image. If `random_padding` is set to `True`, each image is padded with a random
                amont of padding on each size, up to the largest image size in the batch. Otherwise, all images are
                padded to the largest image size in the batch.
            random_padding (`bool`, *optional*, defaults to `self.random_padding`):
                Whether to use random padding when padding the image. If `True`, each image in the batch with be padded
                with a random amount of padding on each side up to the size of the largest image in the batch.
            do_rescale (`bool`, *optional*, defaults to `self.do_rescale`):
                Whether to rescale the image pixel values.
            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.
            image_std (`float` or `List[float]`, *optional*, defaults to `self.image_std`):
                Image standard deviation to use for normalization.
            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.
                - Unset: defaults to 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.
        Nr1   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'   size_divisibilityr"   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=   r#   r$   r?   )r=   r#   r?   )r=   r#   rL   r?   )r=   scaler?   )r=   meanstdr?   rC   r!   )datatensor_type) r"   r#   r5   r6   r7   r
   r$   r%   r&   r'   r(   r)   r*   r+   r,   r   r   
ValueErrorr   r   r   r]   warning_oncer   rK   r   rd   r[   rescale	normalizer   r	   )r8   rj   r"   r#   r$   r%   r&   r'   rL   r(   r)   r*   r+   r,   rk   r>   r?   r=   rq   s                      r;   
preprocesszDonutImageProcessor.preprocess*  s   V "+!6IDNN	'tTYYdUDM*":DT"'38'3'?|TEVEV3E3Q/W[WnWn!-4;;#-#9Zt
+9+E4K^K^'3'?|TEVEV#-#9Zt
!*!6IDNN	$V,F#:  	&!)%!"	
 6<<E.'<<6!9%*s
 $ >vay Iouvfkd**5tO`*avFv $ %dXYjkF 
 ouvfkdnn5tO`navFv
 $	  d>]n  F   $ 5RcdF 
  $ U^opF  ou
ej'{N_`
 
 '>BBc = w w

s0   I#I#I(*I-I21I7I<6J)NN)FNN)!__name__
__module____qualname____doc__model_input_namesr   BILINEARboolr   strrc   r   floatr   r   r4   rE   ndarrayr   rK   r[   r   BICUBICrd   r   r   FIRSTr   r   PILImagerw   __classcell__)r:   s   @r;   r    r    5   si   "H (( #'9'B'B!#(,3!:>9=!W!W 38n!W %	!W
 !W !!W !W !W c5j)!W !W U5$u+#567!W E%e"456!W 
!WN ?CDH"zz" 38n" eC)9$9:;	"
 $E#/?*?$@A" 
"P  %>BDH(azz(a 38n(a 	(a
 eC)9$9:;(a $E#/?*?$@A(a 
(aT/ (:'A'A>BDH0
zz0
 38n0
 %	0

 eC)9$9:;0
 $E#/?*?$@A0
 
0
l (:'A'A>BDH%zz% 38n% %	%
 eC)9$9:;% $E#/?*?$@A% 
%N %& #'+!#'$ $!:>9=;?2B2H2HDH#`C`C `C 38n	`C
 %`C `C !`C `C `C `C `C `C U5$u+#567`C E%e"456`C !sJ!78`C  ./!`C" $E#/?*?$@A#`C$ 
%`C '`Cr<   r    ))r{   typingr   r   r   r   numpyrE   image_processing_utilsr   r	   r
   image_transformsr   r   r   r   image_utilsr   r   r   r   r   r   r   r   r   r   r   r   utilsr   r   r   utils.import_utilsr   
get_loggerrx   r]   r   r    r2   r<   r;   <module>r      ss    ' . .  U U     J I 5 
		H	% VC, VCr<   