^jH 2ddlZddlmZddlmZddlZddlmcmZ ddl mZ ddl m Z ddlmZddlmZdd lmZmZdd lmZmZmZmZdd lmZdd lmZmZdd lm Z m!Z!m"Z"m#Z#GddedZ$ddde%ee%zde&de%def dZ'e!Gdde Z(dgZ)y)N)Iterable)Union) functional)TorchvisionBackend) BatchFeature)'SemanticSegmentationPostProcessorOutput)group_images_by_shapereorder_images)ChannelDimension ImageInputPILImageResamplingSizeDict)DepthEstimatorOutput) ImagesKwargsUnpack) TensorTypeauto_docstringis_torch_availablerequires_backendsc:eZdZUdZeed<eed<eed<eed<y)CHMv2ImageProcessorKwargsa= 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__bool{/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/chmv2/image_processing_chmv2.pyrr's! 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_ofAs[ #. !H ,  1w; 3>*X5A w; #.)H4Ar%)r+heightwidth)rN)shapeabsr) r(r*rr+r8 input_height input_width output_height output_width scale_height scale_width new_height new_widths r&get_resize_output_image_sizerH;s !, 1 1"# 6L+"-M<!</L,K q; #a,&6"7 7&L'K),*EPXYJ({)BXVI :Y 77r%c$xeZdZdZeZejZgdZ gdZ dddZ dZ dZ dZdZdZdZdZdZd Zd ZdZd Zd eeffd Ze d7d ededzd eedeffd Z d7d ededzdedede e!zdzde"e dfdzdefdZ#de$dde$dfdZ%d e$ddedede&ddded e&d!ed"e'd#ed$e'e$e'zdzd%e'e$e'zdzd&ed'e(dzd(ed)e(dzd*edzdef$d+Z) d8d,e$e*dzd-edd.fd/Z+ d9d0dde&ddd1ed'e(dzd&eddffd2 Z, d:d0dd)e(ddfd3Z- d7d4d5d,e!e$e*e(e(fzdzdzde$e.e e!ffd6Z/xZ0S);CHMv2ImageProcessorz0PIL backend for CHMV2 with reduce_label support.)gzG?gM?gl?)g$C?g+?gM?ir;TNFgp?kwargsc $t|di|y)Nr$)super__init__)selfrL __class__s r&rOzCHMv2ImageProcessor.__init__zs "6"r%imagessegmentation_mapsr,c &t|||fi|S)zp segmentation_maps (`ImageInput`, *optional*): The segmentation maps to preprocess. )rN preprocess)rPrRrSrLrQs r&rUzCHMv2ImageProcessor.preprocess}sw!&*;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.)rRrVrWrYFr pixel_values)rRexpected_ndimsrVrW) do_normalize do_rescalerRrlabels)data tensor_typer$) _prepare_image_like_inputscopy _preprocessr FIRSTupdatesqueezetotorchint64r) rPrRrSrVrWrXrYrL images_kwargsraprocessed_segmentation_mapssegmentation_maps_kwargsprocessed_segmentation_maps r&_preprocess_image_like_inputsz1CHMv2ImageProcessor._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-r`r)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)dtyperYr:)rangelenrjwheretensorrsrY)rPr`idxlabels r& reduce_labelz CHMv2ImageProcessor.reduce_labelsV% C3KEKK ELLEKKX]XdXd,eglmEAIEKK ell3ekkZ_ZfZf.ginoEF3K   r%r do_resizesizeresamplez7PILImageResampling | tvF.InterpolationMode | int | Nonedo_center_crop crop_sizer_rescale_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 CHMV2.)r)imager}r~rr)r{r itemsresizer center_croprescale_and_normalize pad_image)rPrRrr|r}r~rrr_rr^rrrrrrrrLgrouped_imagesgrouped_images_indexresized_images_groupedr>stacked_imagesresized_imagesprocessed_images_groupedprocessed_imagess r&rezCHMv2ImageProcessor._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 [`CHMv2ForSemanticSegmentation`] into semantic segmentation maps. Args: outputs ([`CHMv2ForSemanticSegmentation`]): 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)dimbilinearFr}mode align_corners) segmentationsegmentation_scores)rar:)r ImportErrorlogitsrv ValueError isinstancerjTensornumpyruF interpolate unsqueezeargmaxappendr r>r) rPoutputsrrrsemantic_segmentationryresized_logits semantic_mapseg_mapsiitems r&"post_process_semantic_segmentationz6CHMv2ImageProcessor.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+)r~r)r<r=rkeysrHrNr) rPrr}r~rrrr*rQs r&rzCHMv2ImageProcessor.resize=sl:{{$**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. r9Nc^tj||z |z}||z }|dz}||z }||fS)Nr\)r1r3)r}rnew_sizepad_size pad_size_leftpad_size_rights r&_get_padz/CHMv2ImageProcessor.pad_image.._get_padusAyy !45 DH$H$MM% 5N .0 0r%)r>tvFpad) rPrrr<r=rpad_top pad_bottompad_left pad_rightpaddings r&rzCHMv2ImageProcessor.pad_imagees` BC(  1'v|<&ul;)Wi<wwug&&r%rrcvt|d|j}|"t|t|k7r tdg}|dgt|zn|}t ||D]X\}}|>t j jj|d|ddj}|jd|iZ|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. rjNz]Make sure that you pass in as many target sizes as the batch dimension of the predicted depth)NN.rTrpredicted_depth) rrrvrziprjnnrrrhr)rPrrrresultsdepth target_sizes r&post_process_depth_estimationz1CHMv2ImageProcessor.post_process_depth_estimations( $(!11  $3+?3|CT+To 8D8LvO 44R^ "%o|"D 7 E;&++77/*:]a8') NN-u5 6  7r%r/)NF)Tr:F)r:)1rrrr r valid_kwargsrBICUBICr~rrr}default_to_squarerr|rr_r^rrrrrrrrOrr rrUr#r strrrrplistr{rfloatr!retuplerrrdictr __classcell__)rQs@r&rJrJbsR:,L!))H&J%IC (DIINJL FNL#(A!B#04 G G&, G23 G  G G&59*C*C&,*C *C , *C j(4/ *Cc>)*T1*C *CX4#7DJN'''!4c3h#884?$F' d3 ?# $ 'r%rJ)*r1collections.abcrtypingrrjtorch.nn.functionalrrrtorchvision.transforms.v2rimage_processing_backendsrimage_processing_baserimage_processing_outputsr image_transformsr r image_utilsr r rrmodeling_outputsrprocessing_utilsrrutilsrrrrrr!r#rHrJ__all__r$r%r&rs* $ 7;1OEUU44VV E($8$8x}$$8$8 $8  $8NE,EEP ! !r%