
    Z jH,              
       "   S SK r S SKJr  S SKJr  S SKrSSKJr  SSKJ	r	  SSK
JrJr  SSKJrJrJrJr  SS	KJr  SS
KJrJrJr  SSKJr  \(       a  SSKJr  S SKJr  SSS\\\   -  S\ S\S\4
S jr! " S S\SS9r"\ " S S\5      5       r#S/r$g)    N)Iterable)TYPE_CHECKING   )TorchvisionBackend)BatchFeature)group_images_by_shapereorder_images)IMAGENET_STANDARD_MEANIMAGENET_STANDARD_STDPILImageResamplingSizeDict)ImagesKwargs)
TensorTypeauto_docstringrequires_backends   )BeitImageProcessor)DepthEstimatorOutput)
functionalinput_imagetorch.Tensoroutput_sizekeep_aspect_ratiomultiplereturnc                     SS jnU R                   SS  u  pVUu  pxXu-  n	X-  n
U(       a#  [        SU
-
  5      [        SU	-
  5      :  a  U
n	OU	n
U" X-  US9nU" X-  US9n[        XS9$ )Nc                     [        X-  5      U-  nUb   XC:  a  [        R                  " X-  5      U-  nXB:  a  [        R                  " X-  5      U-  nU$ N)roundmathfloorceil)valr   min_valmax_valxs        t/root/GenerationalWealth/GenerationalWealth/venv/lib/python3.13/site-packages/transformers/models/dpt/modular_dpt.pyconstrain_to_multiple_of>get_resize_output_image_size.<locals>.constrain_to_multiple_of0   sQ    #.!H,1;

3>*X5A;		#.)H4A       )r   heightwidth)r   N)shapeabsr   )r   r   r   r   r(   input_heightinput_widthoutput_heightoutput_widthscale_heightscale_width
new_height	new_widths                r'   get_resize_output_image_sizer:   *   s    	 !, 1 1"# 6L"-M !/L,Kq;#a,&6"77&L 'K),*EPXYJ()BXVI:77r*   c                   B    \ rS rSr% Sr\\S'   \\S'   \\S'   \\S'   Srg)	DPTImageProcessorKwargsQ   a  
ensure_multiple_of (`int`, *optional*, defaults to 1):
    If `do_resize` is `True`, the image is resized to a size that is a multiple of this value. Can be overridden
    by `ensure_multiple_of` in `preprocess`.
keep_aspect_ratio (`bool`, *optional*, defaults to `False`):
    If `True`, the image is resized to the largest possible size such that the aspect ratio is preserved. Can
    be overridden by `keep_aspect_ratio` in `preprocess`.
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.
ensure_multiple_ofsize_divisorr   do_reduce_labels N)	__name__
__module____qualname____firstlineno____doc__int__annotations__bool__static_attributes__rA   r*   r'   r<   r<   Q   s!     r*   r<   F)totalc            $          \ rS rSr\R
                  r\r\	r
SSS.rSrSrSrSrSrSrSrSrSrSr\r   S'S	S
S\SSS\S\S-  S\SS
4S jjr S(S	S
S\SS
4S jjrS\S
   S\S\S\SSS\S\S\S\S\S\\\   -  S-  S\\\   -  S-  S\S\S-  S\S\S-  S \S-  S\4$S! jr  S)S"S#S$\!\\"\\4      -  S-  S-  S\\#\$\!4      4S% jjr%S&r&g)*DPTImageProcessore   i  r-   TFgp?r,   Nimager   sizeresamplez7PILImageResampling | tvF.InterpolationMode | int | None	antialiasr>   r   r   c                     UR                   (       a  UR                  (       d  [        SUR                  5        35      e[	        UUR                   UR                  4UUS9n[
        R                  " XXsUS9$ )a  
Resize an image to `(size["height"], size["width"])`.

Args:
    image (`torch.Tensor`):
        Image to resize.
    size (`SizeDict`):
        Dictionary in the format `{"height": int, "width": int}` specifying the size of the output image.
    interpolation (`InterpolationMode`, *optional*, defaults to `InterpolationMode.BILINEAR`):
        `InterpolationMode` filter to use when resizing the image e.g. `InterpolationMode.BICUBIC`.
    antialias (`bool`, *optional*, defaults to `True`):
        Whether to use antialiasing when resizing the image
    ensure_multiple_of (`int`, *optional*):
        If `do_resize` is `True`, the image is resized to a size that is a multiple of this value
    keep_aspect_ratio (`bool`, *optional*, defaults to `False`):
        If `True`, and `do_resize` is `True`, the image is resized to the largest possible size such that the aspect ratio is preserved.

Returns:
    `torch.Tensor`: The resized image.
zDThe size dictionary must contain the keys 'height' and 'width'. Got )r   r   r   )rQ   rR   )r.   r/   
ValueErrorkeysr:   r   resize)selfrO   rP   rQ   rR   r>   r   r   s           r'   rV   DPTImageProcessor.resizez   sj    : {{$**cdhdmdmdocpqrr2djj1/'	
 "((k`ijjr*   r?   c                     UR                   SS u  p4S nU" X25      u  pgU" XB5      u  pXX4n
[        R                  " X5      $ )aL  
Center pad a batch of images to be a multiple of `size_divisor`.

Args:
    image (`torch.Tensor`):
        Image to pad.  Can be a batch of images of dimensions (N, C, H, W) or a single image of dimensions (C, H, W).
    size_divisor (`int`):
        The width and height of the image will be padded to a multiple of this number.
r+   Nc                 X    [         R                  " X-  5      U-  nX -
  nUS-  nX4-
  nXE4$ )Nr   )r    r"   )rP   r?   new_sizepad_sizepad_size_leftpad_size_rights         r'   _get_pad-DPTImageProcessor.pad_image.<locals>._get_pad   s9    yy!45DHH$MM%5N 00r*   )r0   tvFpad)rW   rO   r?   r.   r/   r_   pad_top
pad_bottompad_left	pad_rightpaddings              r'   	pad_imageDPTImageProcessor.pad_image   sP     BC(	1 'v<&u;i<wwu&&r*   imagesr@   	do_resizedo_center_crop	crop_size
do_rescalerescale_factordo_normalize
image_mean	image_stddo_paddisable_groupingc           	         U(       a  U R                  U5      n[        UUS9u  nn0 nUR                  5        H%  u  nnU(       a  U R                  UUUUUS9nUUU'   M'     [	        UU5      n[        UUS9u  nn0 nUR                  5        HQ  u  nnU(       a  U R                  UU5      nU R                  UXXU5      nU(       a  U R                  UU5      nUUU'   MS     [	        UU5      nU$ )N)rt   )rO   rP   rQ   r>   r   )reduce_labelr   itemsrV   r	   center_croprescale_and_normalizerh   )rW   rj   r@   rk   rP   rQ   rl   rm   rn   ro   rp   rq   rr   r   r>   rs   r?   rt   kwargsgrouped_imagesgrouped_images_indexresized_images_groupedr0   stacked_imagesresized_imagesprocessed_images_groupedprocessed_imagess                              r'   _preprocessDPTImageProcessor._preprocess   s'   * &&v.F 0EV^n/o,,!#%3%9%9%;!E>!%(%'9&7 "- " -;"5) &< ((>@TU 0E^fv/w,,#% %3%9%9%;!E>!%!1!1.)!L!77
LV_N !%!M.<$U+ &< **BDXYr*   outputsr   target_sizesc                    [        U S5        UR                  nUb#  [        U5      [        U5      :w  a  [        S5      e/ nUc  S/[        U5      -  OUn[	        X25       Hq  u  pVUbV  [
        R                  R                  R                  UR                  S5      R                  S5      USSS9R                  5       nUR                  S	U05        Ms     U$ )
aj  
Converts the raw output of [`DepthEstimatorOutput`] into final depth predictions and depth PIL images.
Only supports PyTorch.

Args:
    outputs ([`DepthEstimatorOutput`]):
        Raw outputs of the model.
    target_sizes (`TensorType` or `List[Tuple[int, int]]`, *optional*):
        Tensor of shape `(batch_size, 2)` or list of tuples (`Tuple[int, int]`) containing the target size
        (height, width) of each image in the batch. If left to None, predictions will not be resized.

Returns:
    `List[Dict[str, TensorType]]`: A list of dictionaries of tensors representing the processed depth
    predictions.
torchNz]Make sure that you pass in as many target sizes as the batch dimension of the predicted depthr   r,   bicubicF)rP   modealign_cornerspredicted_depth)r   r   lenrT   zipr   nnr   interpolate	unsqueezesqueezeappend)rW   r   r   r   resultsdepthtarget_sizes          r'   post_process_depth_estimation/DPTImageProcessor.post_process_depth_estimation   s    ( 	$(!11$3+?3|CT+To  8D8LvO 44R^"%o"DE&++77OOA&003+Iej 8 ')  NN-u56 #E r*   rA   )Tr,   F)r,   r   )'rB   rC   rD   rE   r   BICUBICrQ   r
   rq   r   rr   rP   rk   rn   rp   rs   ro   r>   r   rm   rl   r@   r<   valid_kwargsr   rI   rG   rV   rh   listfloatr   r   r   tupledictstrr   rJ   rA   r*   r'   rM   rM   e   s"   !))H'J%IC(DIJLFN IN*L )*"'&k&k &k L	&k
 &k  $J&k  &k 
&kV '' ' 
	'88 ^$8  8  	8 
 8  L8  8  8  8  8  8  DK'$.8  4;&-8   8   $J8   !8 " Dj#8 $ +%8 ( 
)8 z JN''' !4c3h#884?$F' 
d3
?#	$	' 'r*   rM   )%r    collections.abcr   typingr   r   image_processing_backendsr   image_processing_baser   image_transformsr   r	   image_utilsr
   r   r   r   processing_utilsr   utilsr   r   r   beit.image_processing_beitr   modeling_outputsr   torchvision.transforms.v2r   ra   rG   rI   r:   r<   rM   __all__rA   r*   r'   <module>r      s      $    ; 1 E  - B B ; 8 7$8$8x}$$8 $8 	$8
 $8Nl% ( y* y yx 
r*   