^jI BddlZddlmZddlmZmZddlZddlmcm Z ddl m Z ddl mZddlmZddlmZdd lmZmZdd lmZmZmZmZmZmZdd lmZmZdd l m!Z!m"Z"m#Z#m$Z$erdd l%m&Z&GddedZ'ddde(ee(zde)de(def dZ*e"GddeZ+dgZ,y)N)Iterable) TYPE_CHECKINGUnion) functional)TorchvisionBackend) BatchFeature)'SemanticSegmentationPostProcessorOutput)group_images_by_shapereorder_images)IMAGENET_STANDARD_MEANIMAGENET_STANDARD_STDChannelDimension ImageInputPILImageResamplingSizeDict) ImagesKwargsUnpack) TensorTypeauto_docstringis_torch_availablerequires_backends)DepthEstimatorOutputc:eZdZUdZeed<eed<eed<eed<y)DPTImageProcessorKwargsa= 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_divisorkeep_aspect_ratiodo_reduce_labelsN)__name__ __module__ __qualname____doc__int__annotations__boolw/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/dpt/image_processing_dpt.pyrr2s! r(rF)total input_image torch.Tensor output_sizermultiplereturncdd}|jdd\}}|\}}||z } ||z } |r"td| z td| z kr| } n| } || |z|} || |z|} t| | S)Nct||z |z}| ||kDrtj||z |z}||krtj||z |z}|SN)roundmathfloorceil)valr.min_valmax_valxs r)constrain_to_multiple_ofz>get_resize_output_image_size..constrain_to_multiple_ofLs[ #. !H ,  1w; 3>*X5A w; #.)H4Ar()r.heightwidth)rN)shapeabsr) r+r-rr.r; input_height input_width output_height output_width scale_height scale_width new_height new_widths r)get_resize_output_image_sizerKFs !, 1 1"# 6L+"-M<!</L,K q; #a,&6"7 7&L'K),*EPXYJ({)BXVI :Y 77r(c$leZdZdZeZejZe Z e Z dddZ dZdZdZdZdZdZdZdZdZdZdZd eeffd Ze d5d ed edzd eed effd Z d5d ed edzdede de!e"zdzde#e!dfdzd efdZ$de%dd e%dfdZ&d e%ddedede'dddede'ded e(d!ed"e(e%e(zdzd#e(e%e(zdzd$ed%e)dzd&ed'e)dzd(edzd ef$d)Z* d6d*e%e+dzd+ed d,fd-Z, d7d.dde'ddd/ed%e)dzd$ed dffd0 Z- d8d.dd'e)d dfd1Z. d5d2d3d*e"e%e+e)e)fzdzdzd e%e/e!e"ffd4Z0xZ1S)9DPTImageProcessorz.PIL backend for DPT with reduce_label support.ir>TNFgp?r=kwargsc $t|di|y)Nr')super__init__)selfrN __class__s r)rQzDPTImageProcessor.__init__s "6"r(imagessegmentation_mapsr/c &t|||fi|S)zp segmentation_maps (`ImageInput`, *optional*): The segmentation maps to preprocess. )rP preprocess)rRrTrUrNrSs r)rWzDPTImageProcessor.preprocesssw!&*;FvFFr(do_convert_rgbinput_data_formatreturn_tensorsdevicez torch.devicec |j||||}|j}d|d<i} |j|fi|| d<||j|ddtj} |j} | j ddd|jd d| i| } | D cgc]0} | j d jtj2} } | | d <t| | Scc} w) z"Handle extra inputs beyond images.)rTrXrYr[Fr pixel_values)rTexpected_ndimsrXrY) do_normalize do_rescalerTrlabels)data tensor_typer') _prepare_image_like_inputscopy _preprocessrFIRSTupdatesqueezetotorchint64r ) rRrTrUrXrYrZr[rN images_kwargsrcprocessed_segmentation_mapssegmentation_maps_kwargsprocessed_segmentation_maps r)_preprocess_image_like_inputsz/DPTImageProcessor._preprocess_image_like_inputss+00.L]fl1  ,1 ()/t//H-H^  (*.*I*I( $"2"8"8 +J+ '(.{{} $ $ + +URW,X Y*:$*:*:+2+6N+ '3N+.+221588E+ '+9DN>BB +s$5C-rbr,c ftt|D]}||}tj|dk(tjd|j |j |}|dz }tj|dk(tjd|j |j |}|||<|S)z/Reduce label values by 1, replacing 0 with 255.r)dtyper[r=)rangelenrlwheretensorrur[)rRrbidxlabels r) reduce_labelzDPTImageProcessor.reduce_labelsV% C3KEKK ELLEKKX]XdXd,eglmEAIEKK ell3ekkZ_ZfZf.ginoEF3K   r(r do_resizesizeresamplez7PILImageResampling | tvF.InterpolationMode | int | Nonedo_center_crop crop_sizerarescale_factorr` image_mean image_stdrrdo_padrdisable_groupingc |r|j|}t||\}}i}|jD]"\}}|r|j||||| }|||<$t ||}t||\}}i}|jD]H\}}|r|j ||}|j ||| | | | }|r|j||}|||<Jt ||}|S)zCustom preprocessing for DPT.)r)imagerrrr)r}r itemsresizer center_croprescale_and_normalize pad_image)rRrTrr~rrrrrarr`rrrrrrrrNgrouped_imagesgrouped_images_indexresized_images_groupedrAstacked_imagesresized_imagesprocessed_images_groupedprocessed_imagess r)rgzDPTImageProcessor._preprocesss5, &&v.F0EV^n/o,,!#%3%9%9%; ; !E>!%(%'9&7 "-"-; "5 ) ;((>@TU0E^fv/w,,#% %3%9%9%; = !E>!%!1!1.)!L!77 NL*V_N!% !M.< $U + =**BDXYr( target_sizesreturn_segmentation_scoreszBlist[torch.Tensor] | list[SemanticSegmentationPostProcessorOutput]cts td|j}|t|t|k7r t dt |t jr|j}g}tt|D]g}tj||jd||dd}|djd}|jt||dd inJ|jd } t|j dD cgc]} t| | || d }} |s|D cgc]} | j"}} |Scc} wcc} w) a Converts the output of [`DPTForSemanticSegmentation`] into semantic segmentation maps. Args: outputs ([`DPTForSemanticSegmentation`]): 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. return_segmentation_scores (`bool`, *optional*, defaults to `False`): Whether to return segmentation scores alongside the segmentation map. When `True`, each element of the returned list is a [`SemanticSegmentationPostProcessorOutput`] with fields `segmentation` (class IDs, shape `(height, width)`) and `segmentation_scores` (shape `(num_classes, height, width)`). Returns: `list[torch.Tensor]` or `list[SemanticSegmentationPostProcessorOutput]`: When `return_segmentation_scores=False` (default), a list of length `batch_size` where each item is a segmentation map of shape `(height, width)` with class IDs. When `return_segmentation_scores=True`, a list of [`SemanticSegmentationPostProcessorOutput`] with fields `segmentation` (class IDs, shape `(height, width)`) and `segmentation_scores` (shape `(num_classes, height, width)`). In both cases, `(height, width)` corresponds to the target size (if `target_sizes` is specified). z:PyTorch is required for post_process_semantic_segmentationzTMake sure that you pass in as many target sizes as the batch dimension of the logitsr)dimbilinearFrmode align_corners) segmentationsegmentation_scores)rcr=)r ImportErrorlogitsrx ValueError isinstancerlTensornumpyrwF interpolate unsqueezeargmaxappendr rAr) rRoutputsrrrsemantic_segmentationr{resized_logits semantic_mapseg_mapsiitems r)"post_process_semantic_segmentationz4DPTImageProcessor.post_process_semantic_segmentationsy2"#Z[ [  #6{c,// j, 5+113 $& !S[) !"3K))a)0|C7Hzin" .a077A7> %,,;.:SabcSde }}}+H v||A/ %8*21+fUViX% !%*CX$Y4T%6%6$Y !$Y$$%%Zs EEr antialiasc|jr |jstd|jt ||j|jf||}t |||||S)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-rr.)rr)r?r@rkeysrKrPr) rRrrrrrrr-rSs r)rzDPTImageProcessor.resizeGsl:{{$**cdhdmdmdocpqr r2 djj1/'  w~e[8y~YYr(c|jdd\}}d}|||\}}|||\}} ||| |f} tj|| S)a 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^tj||z |z}||z }|dz}||z }||fS)Nr^)r4r6)rrnew_sizepad_size pad_size_leftpad_size_rights r)_get_padz-DPTImageProcessor.pad_image.._get_padsAyy !45 DH$H$MM% 5N .0 0r()rAtvFpad) rRrrr?r@rpad_top pad_bottompad_left pad_rightpaddings r)rzDPTImageProcessor.pad_imageos` BC(  1'v|<&ul;)Wi<wwug&&r(rrct|d|j}|"t|t|k7r tdg}|dgt|zn|}t ||D]s\}}|Yt j jj|jdjd|ddj}|jd |iu|S) a 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. rlNz]Make sure that you pass in as many target sizes as the batch dimension of the predicted depthrr=bicubicFrpredicted_depth) rrrxrziprlnnrrrrjr)rRrrrresultsdepth target_sizes r)post_process_depth_estimationz/DPTImageProcessor.post_process_depth_estimations( $(!11  $3+?3|CT+To 8D8LvO 44R^ "%o|"D 7 E;&++77OOA&003+Iej8') NN-u5 6  7r(r2)NF)Tr=F)r=)2r r!r"r#r valid_kwargsrBICUBICrr rrrrdefault_to_squarerr~rrar`rrrrrrrQrrr rWr&rstrrrrrlistr}rfloatr$rgtuplerrrdictr __classcell__)rSs@r)rMrMmsM8*L!))H'J%IC (DIINJL FN#(?!@#04 G G&, G01 G  G G&59*C*C&,*C *C , *C j(4/ *Cc>)*T1*C *CX4#7DJN'''!4c3h#884?$F' d3 ?# $ 'r(rM)-r4collections.abcrtypingrrrltorch.nn.functionalrrrtorchvision.transforms.v2rimage_processing_backendsrimage_processing_baser image_processing_outputsr image_transformsr r image_utilsr rrrrrprocessing_utilsrrutilsrrrrmodeling_outputsrrr$r&rKrM__all__r'r(r)rs, $' 7;1OE5VV8l%($8$8x}$$8$8 $8  $8ND*DDN  r(