3j SSKJr SSKrSSKJs Jr SSKJr SSK J r SSK J r SSK JrJr SSKJrJrJrJrJrJrJrJr SS KJrJr SS KJrJrJr S S K J!r!J"r"J#r#J$r$ "S S\SS9r%Sr&Sr'S#S\RPS\)\*\*4S\+S\)\RP\RP44Sjjr,S#S\RPS\RPS\)\*\*4S\+S\RP4 Sjjr-S$S\RPS\*S\RP4Sjjr.S\RPS\)\RP\RP44Sjr/S$S\RPS\RPS\*S\RP4S jjr0\"S!S"\ 55r1S"/r2g)%)UnionN) functional)TorchvisionBackend) BatchFeature)group_images_by_shapereorder_images)IMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STDChannelDimension ImageInputPILImageResamplingSizeDict#get_image_size_for_max_height_widthmake_list_of_images) ImagesKwargsUnpack) TensorTypeauto_docstringis_torch_available)Sapiens2ImageMattingOutputSapiens2NormalEstimatorOutputSapiens2PointmapEstimatorOutputSapiens2PoseEstimatorOutputc$\rSrSr%Sr\\S'Srg)Sapiens2ImageProcessorKwargs1aW 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. do_reduce_labelsN)__name__ __module__ __qualname____firstlineno____doc__bool__annotations____static_attributes__r p/home/wildlama/miniconda3/lib/python3.13/site-packages/transformers/models/sapiens2/image_processing_sapiens2.pyrr1sr)rF)totalcfURS5upp#XX-X-/n[R"USS9$)Ndimunbindtorchstackxywhbs r*box_xywh_to_xyxyr:<s4"JA! AEQU$A ;;qb !!r)cvURS5upp#USU--USU--X#/n[R"USS9$)Nr-?r.r0r4s r*box_xywh_to_cxcywhr=Bs@"JA! cAg+S1W0A ;;qb !!r)boxes output_sizepaddingreturnc URS5up4pV[R"X4/SS9nXR-nXb-n UupX- n [R"XU -:S[R"XU - /SS9[R"X-U /SS95n X}4$)aCompute crop center and scale from bounding boxes, applying padding and aspect ratio correction. Accepts either a single box `(4,)` or multiple boxes `(num_boxes, 4)` and returns center/scale with a matching leading dimension. Args: boxes (`torch.Tensor` of shape `(4,)` or `(num_boxes, 4)`): Bounding box in (center-x, center-y, width, height) format, with values in absolute pixel coordinates. output_size (`tuple[int, int]`): Target output size as `(height, width)`, used to compute the aspect ratio for scale correction. padding (`float`, *optional*, defaults to `1.25`): Multiplicative factor applied to the bounding box dimensions, adding context around the region of interest. Returns: `tuple[torch.Tensor, torch.Tensor]`: A pair `(center, scale)` where `center` has shape `(..., 2)` with (x, y) in input-image pixel coordinates, and `scale` has shape `(..., 2)` with (width, height) in input-image pixels representing the dimensions of the padded, aspect-ratio-corrected crop window. r-r.).N)r1r2r3where)r>r?r@center_xcenter_ywidthheightcenter scaled_width scaled_height output_height output_width aspect_ratioscales r*boxes_to_crop_paramsrOHs0). R(8%H [[(-2 6F?L$M"-M/L KK  4 4i@ \,#>?RH ]1=ArJ E =r)imagec "UupEURupgn[XUS9upU RS5upU RS5upUS- U - nUS- U- n[R"UU5S:n[R "[R "U[RURS9[R "U[RURS9SS9unnUUSS2SS4- U SS2SS4-S U SS2SS4-- nUUSS2SS4- U SS2SS4-S USS2SS4-- n[R"S U-US- - S- S U-US- - S- /SS 9nURS n[R"UXdXPRURS 9nURS 5nUS4U)S44H[unnUR5(dM[R"UR!UR#5SSS5UUUSSS9UU'M] U$)aCrops and resizes bounding box regions from the input image to the target output size. Applies padding and aspect ratio correction to each crop before resizing. Uses bilinear interpolation for downscaling and bicubic for upscaling. This implementation is equivalent to the cv2 affine warp with rotation=0 used in the original Sapiens2 codebase. Rotation is always zero because we don't support rotated bounding boxes. Args: image (`torch.Tensor`): Input image tensor of shape `(C, H, W)` in float32. boxes (`torch.Tensor`): Bounding boxes in (center-x, center-y, width, height) format, shape `(num_boxes, 4)`, with values in absolute pixel coordinates. output_size (`tuple[int, int]`): Target output size as `(height, width)`. padding (`float`, *optional*, defaults to `1.25`): Multiplicative factor applied to the bounding box dimensions before cropping, adding context around the region of interest. Returns: `torch.Tensor`: Cropped and resized images of shape `(num_boxes, C, output_height, output_width)`. )r?r@r-r?dtypedeviceij)indexingNr<g@r.rrUrTbilinearbicubiczerosT)mode padding_mode align_corners)shaperOr1r2minimummeshgridarangefloat32rUr3emptyrT unsqueezeanyF grid_sampleexpandsum)rPr>r?r@rKrL num_channels input_height input_widthrHrNrDrE boxes_width boxes_heightscale_xscale_y is_bilineargrid_ygrid_xin_xin_ygrids num_boxesoutputimage_4dmaskr\s r*crop_and_resizer|ns(2#.M.3kk+L (QXYMFr*H % R 0Ka;.Gq L0G--1C7K^^ ]%-- M \u||LNFF GAtTM* *Xatm-D Ds[YZ\`bfYfMgGg gD GAtTM* *Xatm-D Ds\Z[]acgZgMhGh hD KKt{Q7#=sTz\\]M]?^ad?dekm nE AI [[LVbVbjojuju vFq!H#Z0K<2KL d 88::== BB7d $" F4LM Mr)heatmapskernelcUS-S:XdUS::a [S5eSUS- S-S- -S-nUS- S-nURSS 9n[R"XX3U4S S S 9n[R "XQU/X"/S 9nUSS2X3*2X3*24nURSS 9n[ R"US:U[ R"U55n [ R"US:XI- [ R"U55n XzSS2SS4-$)aGaussian blur per-keypoint heatmap, preserving the original max value. Matches cv2.GaussianBlur with sigma=0 which means that the sigma is automatically computed from the kernel size. Args: heatmaps: Shape `(K, height, width)`. kernel: Odd integer kernel size for the Gaussian blur. Must be greater than 1. Returns: `torch.Tensor`: Blurred heatmaps of the same shape as the input. rrz2Kernel size must be an odd integer greater than 1.g333333?r<g?)rrr.constant)r\value) kernel_sizesigmaN) ValueErroramaxrgpadtvF gaussian_blurr2rC ones_like) r}r~rborder origin_maxespaddedblurredresult result_maxes safe_maxesrNs r*gaussian_blur_preserve_maxrszQ&A+MNN FQJ#%) *S 0EqjQ F==V=,LUU8ff=JVY ZFV4DUN[G Qww6 7F;;6;*L\A-|U__\=Z[J KK q(,*CU__UaEb cE !T4-( ((r)c URupp4URnURXS5nURSS9nUR SS9nX-R 5n X-R 5n [ R"URS5S:[ R"X/SS9[ R"XS4SUS95n X4$)a+Predict keypoint locations and confidence scores from heatmaps. Args: heatmaps: Shape `(num_persons, num_keypoints, height, width)`. Returns: locations: `(num_persons, num_keypoints, 2)` x/y in heatmap pixel coordinates. scores: `(num_persons, num_keypoints)` per-keypoint confidence. r-r.rrgrU) r_rUreshaperargmaxfloatr2rCrer3full) r} num_persons num_keypoints_ heatmap_widthrU heatmap_flatscores flat_index locations_x locations_y locationss r*get_keypoint_predictionsrs4<>>0K __F##KCL   2  &F$$$,J-446K.557K s" [.B7 K2DHI  r) keypointsblur_kernel_sizec  URup4pVURn[URX4-XV5U5RX4XV5nUR SS5R 5n[ R"USSS9nUR5n US-n US-n X-n XL-n USS2SS2S4R5S -USS2SS2S 4R5S -U --nX[R"XG[RS 9SSS24--nX[R"X7[RS 9SS2S4--nURS 5nSS S U U *U S -U S -*S .nUR5VVVs0sHuunnnUU4XU-_M nnnnS USUS- -nS USUS- -nUSSUS-- US-nUSSUS-- US-nS USUS- US- US-US-US- US- US--n[R"UR5R nUU-nUU-nUU-UU-- nUU-UU-- U- nU*U-UU--U- nU[R""UU/S S9- $s snnnf)a1Sub-pixel refinement via Hessian on log-heatmaps (UDP Dark Pose). Args: keypoints: Shape `(num_persons, num_keypoints, 2)` x/y in heatmap pixel coordinates. heatmaps: Shape `(num_persons, num_keypoints, height, width)`. Returns: `(num_persons, num_keypoints, 2)` refined keypoint locations. gMbP?gI@)rrrr replicate)r\rNrrrXr-)rrrrrr-rrr-rrrr-r-r<rrrrrrrr.)r_rUrrclamplogrgrflattenlongr2rbreitemsfinforTepscat)rr}rrrheatmap_heightrrUheatmaps_paddedheatmaps_flattened padded_height padded_widthkeypoint_stride person_strideindexposition_to_index_offsetdxdyoffsetheatmap_values gradient_x gradient_y hessian_xx hessian_yy hessian_xyr determinantoffset_xoffset_ys r*"post_dark_unbiased_data_processingrsNAI=K __F)4nTVf gk.H ~~dD)--/HeeHlEO(002"Q&M 1$L#2O!3M aAg  # # % )Yq!Qw-?-D-D-F-Jl,Z ZE ell=W\WaWa&bcgijcj&kk kE ELLSXS]S]$^_`bf_f$gg gE OOB Eq  1$% NfMkMkMmMm9I"b6R$V^44Mmt,~e/DDEJt,~e/DDEJ%N4,@(@@>RWCXXJ%N4,@(@@>RWCXXJt                       ! J ++j&& ' + +Cc!Jc!Jz)J,CCKZ'*z*AA[PH j(: +BBkQH uyy(H!52> >>5s5I?c"^\rSrSrSr\r\Rr \ r \ r SSS.rSrSSS.rSrSrSrSrSrSrS \\4U4S jjr\S9S \S \S -S\\\\S -S \\S\4 U4Sjjj5rS:S \S \S -S\\\\S -S\S\ S\!\"-S -S\#\!S4S -S\4Sjjr$S\SS\S4Sjr%S;S \\&RNS\S\(SSS\S\(S \S!\S"\S#\\\-S -S$\\\-S -S%\S -S&\S'\S\\\\S -S\\&RN4 S(jjr)S:S)\\*S -4S*jjr+SSapiens2ImageProcessori,z3PIL backend for Sapiens2 with reduce_label support.ii)rGrFTFkwargsc &>[TU]"S0UD6 g)Nr )super__init__)selfr __class__s r*rSapiens2ImageProcessor.__init__?s "6"r)Nimagessegmentation_mapsr>rAc (>[TU]"XU40UD6$)a segmentation_maps (`ImageInput`, *optional*): The segmentation maps to preprocess. boxes (`list[list[list[float]]]` or `np.ndarray`, *optional*): List or array of bounding boxes for each image. Each box should be a list of 4 floats representing the bounding box coordinates in COCO format (top_left_x, top_left_y, width, height). When provided, each person crop is affine-warped to the model input size instead of resizing the full image. )r preprocess)rrrr>rrs r*r!Sapiens2ImageProcessor.preprocessBs"w!&UMfMMr)do_convert_rgbinput_data_formatreturn_tensorsrUz torch.devicec X8S'URXXWS9nUR5n SU S'0n UR"U40U D6U S'UbURUSS[RS9n UR5n U R SSS.5 UR"S S U 0U D6n U V s/sH1n U R S 5R[R5PM3 n n XS '[XS 9$s sn f)z"Handle extra inputs beyond images.r>)rrrrUFr pixel_valuesr)rexpected_ndimsrr) do_normalize do_rescalerrlabels)data tensor_typer ) _prepare_image_like_inputscopy _preprocessr FIRSTupdatesqueezetor2int64r)rrrr>rrrrUr images_kwargsrprocessed_segmentation_mapssegmentation_maps_kwargsprocessed_segmentation_maps r*_preprocess_image_like_inputs4Sapiens2ImageProcessor._preprocess_image_like_inputsUs( w00L]1  ,1 ()#//H-H^  (*.*I*I( $"2"8"8 +J+ '(.{{} $ $ + +URW,X Y*.*:*:+2+6N+ '3N+2M.+221588E2M (+9NBB +s!8C(rz torch.Tensorc b[[U55HnXn[R"US:H[R"SUR UR S9U5nUS- n[R"US:H[R"SUR UR S9U5nX1U'M U$)z/Reduce label values by 1, replacing 0 with 255.rrSr)rangelenr2rCtensorrTrU)rridxlabels r* reduce_label#Sapiens2ImageProcessor.reduce_labelsV%CKEKK ELLEKKX]XdXd,eglmEAIEKK ell3ekkZ_ZfZf.ginoE3K &  r) do_resizesizeresamplez7PILImageResampling | tvF.InterpolationMode | int | Nonedo_center_crop crop_sizerrescale_factorr image_mean image_stddisable_groupingrdo_padc XUbUSUS4n/n[X5H{unn[R"U[RSS9n[ [R "U[RURS95nUR[UUUS95 M} UnSnU (aURU5n[XS9unn0nUR5HaunnU(aOU(a6[USUSS9nURUUU5nURUU5nOURUX45nUUU'Mc [!UU5n[UU S9unn0nUR5H8unnU(aURUU5nUR#UXxXU 5nUUU'M: [!UU5$) z"Custom preprocessing for Sapiens2.rGrFFrTrNrS)r>r?)r) max_height max_width)ziprto_dtype_imager2rcr=rrUextendr|rrrrresize center_cropr rescale_and_normalize)rrrrrrrrrrrrrrr r>rr?cropsrP image_boxes boxes_tensorgrouped_imagesgrouped_images_indexresized_images_groupedr_stacked_imagesaspect_ratio_sizeresized_imagesprocessed_images_groupeds r*r"Sapiens2ImageProcessor._preprocesss(  >4=9KE&)&&8"{**5 US1%,,{RWR_R_hmhtht2uv  _U,T_`a'9FI &&v.F/DV/o,,!#%3%9%9%; !E>(0DNVZ[bVc(d%%)[[ART\%]N%)%5%5nd%KN%)[[%PN,: "5 )&<((>@TU/D^fv/w,,#% %3%9%9%; !E>!%!1!1.)!L!77 LV_N/= $U + &<68LMMr) target_sizescL[5(d [S5eURnUb[U5[U5:wa [ S5e[ U[ R5(aUR5n/n[[U55HNn[R"X5RSS9X%SSS9nUSRSS9nURU5 MP U$URSS9n[URS5Vs/sHoUPM nnU$s snf) a Converts the output of [`Sapiens2ForSemanticSegmentation`] into semantic segmentation maps. Args: outputs ([`Sapiens2ForSemanticSegmentation`]): 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. z:PyTorch is required for post_process_semantic_segmentationzTMake sure that you pass in as many target sizes as the batch dimension of the logitsrr.rYF)rr\r^r)r ImportErrorlogitsrr isinstancer2Tensornumpyrrg interpolatererappendr_) routputsrr"semantic_segmentationrresized_logits semantic_mapis r*"post_process_semantic_segmentation9Sapiens2ImageProcessor.post_process_semantic_segmentations+ "##Z[ [  #6{c,// j, 55+113 $& !S[)!"K))a)0|7Hzin" .a077A7> %,,\: *%$%+MMaM$8 !GLMbMhMhijMkGl$mGl!1%=Gl !$m$$%nsD!r(outputs_flippedr threshold source_sizesc  [U[R5(aUR5n[U[R5(aUR5n[ U5nUbUc [ S5eUbU[ U5:wa [ S5eUbU[ U5:wa [ S5eUR n UbXR -S- n U Rn U RuppU S:XaUVs/sHn/PM sn$[R"UVVs/sHnUHnUPM M snn[RU S9nU R5n [U 5unn[UXS9n[[U5UR S UR S 4S 9unn[R"US - U S - /[RU S9nUU- USS2SSS24-USS2SSS24-S USS2SSS24-- n[#U5nUbUb[R"[%Xg5VVVVs/sHuunnunnUU- UU- /PM snnnn[RU S9n[R&"[)U5Vs/sH3nUUR+S5R-[ UU5S5PM5 sn5nUUSS2SSS24-nUUSS2/SQ4-n/n [)U 5HQn!UU!n"UU!n#[R."XS9n$UbU#U:n%U"U%n"U#U%n#U$U%n$U R1U"U#U$UU!S.5 MS /n&Sn'UH*n[ U5n(U&R1U U'U'U(-5 U'U(- n'M, U&$s snfs snnfs snnnnfs snf)a Converts the output of [`Sapiens2ForPoseEstimation`] into keypoint predictions in image space. Args: outputs (`Sapiens2PoseEstimatorOutput`): Raw outputs of the model. `outputs.heatmaps` must have shape `(N_total, num_keypoints, heatmap_height, heatmap_width)` where `N_total = sum(len(b) for b in boxes)`. boxes (`list[list[list[float]]]` or `np.ndarray`): List or array of bounding boxes for each image in absolute pixel coordinates. Each box should be a list of 4 floats representing the bounding box coordinates in COCO format (top_left_x, top_left_y, width, height). Must match the `boxes` argument passed to `preprocess`. outputs_flipped (`Sapiens2PoseEstimatorOutput`, *optional*): Outputs from running the model on horizontally flipped inputs. When provided, heatmaps are averaged with `outputs` before keypoint extraction to improve accuracy: `avg_heatmaps = (outputs.heatmaps + outputs_flipped.heatmaps) / 2`. kernel_size (`int`, *optional*, defaults to 11): Kernel size for the Gaussian blur used in UDP Dark Pose refinement. threshold (`float`, *optional*): Score threshold. Keypoints with scores at or below this value are filtered out from the result dictionaries. source_sizes (`torch.Tensor` or `list[tuple[int, int]]` of length `batch_size`, *optional*): Original `(height, width)` of each image in pixels. Required when `target_sizes` is provided, as the source coordinate space for scaling keypoints and bounding boxes. target_sizes (`torch.Tensor` or `list[tuple[int, int]]` of length `batch_size`, *optional*): Desired output `(height, width)` coordinate space for each image. When provided alongside `source_sizes`, keypoint coordinates and bounding boxes are scaled from source to target space. Returns: `list[list[dict]]`: Outer list is over images, inner list is over persons. Each dict contains: - `keypoints` (`torch.FloatTensor` of shape `(num_keypoints, 2)`): absolut x/y coordinates in the source image space, or in target space if `target_sizes` is provided. - `scores` (`torch.FloatTensor` of shape `(num_keypoints,)`): per-keypoint confidence. - `labels` (`torch.LongTensor` of shape `(num_keypoints,)`): keypoint indices. - `bbox` (`torch.FloatTensor` of shape `(4,)`): bounding box in absolute (x_min, y_min, x_max, y_max) format, in the same coordinate space as `keypoints`. NzA`source_sizes` must be provided when `target_sizes` is specified.zHMake sure that you pass in as many source sizes as the number of images.zHMake sure that you pass in as many target sizes as the number of images.rrrS)rr}rrGrF)r?rr<)rrrrr)rrrbbox)r#r2r$tolistrrr}rUr_rrcrrrrOr=rr:rrrrerirbr'))rr(r>r/rr0r1r num_imagesr}rUnum_total_personsrrrrrboxr all_keypoints all_scorescentersscales heatmap_size all_boxes source_height source_width target_height target_widthper_image_scale image_indexper_person_scaleperson_results person_indexrrrkeepr person_offsetnum_persons_in_images) r*post_process_pose_estimation3Sapiens2ImageProcessor.post_process_pose_estimationsd lELL 1 1'..0L lELL 1 1'..0LZ  # (<`a a  # c,6G(Ggh h  # c,6G(Ggh h##  & #;#;;q@HJR..G.  ! %&1B& &||$) AE[[cS[SE A_e >>#%=X$F! z:#h / | ,499X;NPTPYPYZaPb:c ||]Q%68J$KSXS`S`iop L (6!T1*+= =4QR @S SVY\bcdfjlmcm\nVn n %\2  # (@#llY\\hXwXwT5 7T |"L0--2OPXwmm O %yy(-Z'8'8 $K0::1=DDS{I[E\^_`'8   *,)pr/rmapsr1rrLnormals)rg normalizerQ_post_process_maps)rr(r1rrLrQresultsrs r*post_process_normal_estimation5Sapiens2ImageProcessor.post_process_normal_estimationsU<++gootD)),* 3::'F#':::sAcURnURbXQRSS2SS2SS4- nURXRX4S9nUVs/sHnSU0PM sn$s snf)a Converts the output of [`Sapiens2ForPointmapEstimation`] into pointmap tensors in image space. Args: outputs (`Sapiens2PointmapEstimatorOutput`): Raw outputs of the model. source_sizes (`torch.Tensor` or `list[tuple[int, int]]` of length `batch_size`, *optional*): Original `(height, width)` of each image before preprocessing. When provided, the padding added during preprocessing is removed and predictions are resized back to the original image size (unless `target_sizes` overrides the final size). target_sizes (`torch.Tensor` or `list[tuple[int, int]]` of length `batch_size`, *optional*): Requested final `(height, width)` for each prediction. Overrides `source_sizes` as the resize target. do_remove_padding (`bool`, *optional*): Whether to crop away the zero-padding added during preprocessing before resizing. Defaults to `True` when `source_sizes` is provided, `False` otherwise. Returns: `list[dict[str, torch.Tensor]]` of length `batch_size`. Each dict has a `"pointmap"` key mapping to a tensor of shape `(3, height, width)` with per-pixel 3D XYZ coordinates in canonical camera space, optionally divided by `outputs.scales` to convert to metric coordinates. NrOpointmap) pointmapsr;rS)rr(r1rrLrYrTrs r* post_process_pointmap_estimation7Sapiens2ImageProcessor.post_process_pointmap_estimationsl:%% >> %!NN1at3C$DDI))L* 4;;7V$7;;;sA backgroundsc ^^[T[R5(aTR5mURR SnURR nURRnTbU[T5:wa [S5eTSL=(d [U4SjT55n/mUb~[U5n[U5S:wa[U5U:wa [S5eUV s/sH<n [R"[R"U 5USS9RU5PM> sn mT(+=(d [U4S jT55n [R "URUR"/SS 9n Tb?U(a8[%TS5n [&R("U U S S S S 9n U R+SS5n /n U(aU (aU SS2SS24nU SS2SS24nS/U-nT(a[R,"T5nUR SSU R SS:wa%[&R("UU R SSS S S S 9nUSU- U--R+SS5n[R"U[R.SS9n[1XU5HunnnU R3UUUS.5 M U $[5[U 55GH-nU UnT(aFU(d?[&R("UR7S5TUS S S S 9SnUR+SS5nUSSnUSSnSnT(a[T5S:XaTSOTUnUR SSUR SS:wa7[&R("UR7S5UR SSS S S S 9SnUSU- U--R+SS5n[R"U[R.SS9nU R3UUUS.5 GM0 U $s sn f)a` Converts the output of [`Sapiens2ForImageMatting`] into alpha mattes and foreground maps. Args: outputs (`Sapiens2ImageMattingOutput`): Raw outputs of the model. target_sizes (`torch.Tensor` or `list[tuple[int, int]]` of length `batch_size`, *optional*): Requested final `(height, width)` for each prediction. Resized with bilinear interpolation. If unset, predictions are returned at the model output resolution. backgrounds (`ImageInput`, *optional*): Background image(s) to composite over. Can be a single image (applied to every item in the batch) or a list of images, one per batch item. Accepts PIL images, numpy arrays, or torch tensors of any dtype; integer types (e.g. uint8) are scaled to `[0, 1]` automatically. When provided, each result dict gains a `"composite"` key with the composited image as a uint8 tensor in `[0, 255]`. Returns: `list[dict]` of length `batch_size`. Each dict has: - `"alpha"` (`torch.Tensor` of shape `(1, height, width)`): alpha values in `[0, 1]`. - `"foreground"` (`torch.Tensor` of shape `(3, height, width)`): pre-multiplied RGB in `[0, 1]`. - `"composite"` (`torch.Tensor` of shape `(3, height, width)` or `None`): foreground composited over `backgrounds` as a uint8 tensor in `[0, 255]`; `None` when `backgrounds` is not provided. rNz\Make sure that you pass in as many target sizes as the batch dimension of the matting outputc3X># UHn[U5[TS5:Hv M! g7frN)tuple).0rrs r* DSapiens2ImageProcessor.post_process_image_matting..s&= >JdE$K5a1 1ls'*rz[Make sure that you pass in as many backgrounds as the batch dimension of the matting outputTr c3f># UH&oRSSTSRSS:Hv M( g7f)Nr)r_)ra backgroundbackground_tensorss r*rbrcs9C Xj*  RS !%7%:%@%@%E EXjs.1r.rYFrr\r^ antialiasrrRrre) foregroundalpha composite)r#r2r$r4 foregroundsr_rUrTrrallrrrto_imagerralphasr`rgr&rr3uint8rr'rre)rr(rr\ batch_sizerUrTall_target_sizes_equalbackground_listbackground_imageall_background_sizes_equalmatting target_sizerrmrp compositesrfrjrkrlr matting_itemrgs ` @r*post_process_image_matting1Sapiens2ImageProcessor.post_process_image_mattings4: lELL 1 1'..0L((..q1 $$++##))  #S.. r".!5" = >J= :    "1+>O?#q(S-AZ-O q )8"(7$""3<<0@#AVZ[^^_ef(7" *<%;& sC XjC @ "))W00'..AqI  #(> Q0Kmm # GmmC-G !&@!!RaR%.KQU^F*,J!"[[);< ##BC(GMM"#,>>!""$]]23/'&+"' "J*QZ:,EELLSRUV  // %++UYZ 03K0T, E9 &0!&%.1UV As7|,&u~ (>#$==$..q1)%0'&+"' $  $L$0#5#5c3#?L)"1- $QR( %:=>P:QUV:V!3A!6\not\uJ!'', 0B0B230GG%&]]&003!-!3!3BC!8!+*/&+ &  & ",q5yJ.F!F M McSV WI # 2 29EKKW[ \I Z%V_`a=-@ g"s1AP rPc ^^[U[R5(aUR5n[U[R5(aUR5nUcUSLnU(aUc [ S5eUb#[ U5[ U5:wa [ S5eUb#[ U5[ U5:wa [ S5eUR SnUR Sn/mU(acUH]upx[Xx4XV5upX:aXY- S-OSn X:aXj- S-OSn TRU U U [X5-U [X5-45 M_ T(+=(d [U4SjT55n /mUbUVs/sHn[U5PM snmOUbUVs/sHn[U5PM snmT(+=(d [U4S jT55n/nU (aXU(aQU(aTSunnnnUSS2SS2UU2UU24nT(a[R"UTSS S S S 9n[U5nU$[[ U55HlnUUnU(aTUunnnnUSS2UU2UU24nT(a-[R"UR!S5TUS S S S 9SnURU5 Mn U$s snfs snf) Nz>`source_sizes` must be provided when `do_remove_padding=True`.zUMake sure that you pass in as many source sizes as the batch dimension of the outputszUMake sure that you pass in as many target sizes as the batch dimension of the outputsrGrFrrc32># UH oTS:Hv M g7fr_r )racroprs r*rb.}s*N58+;c32># UH oTS:Hv M g7fr_r )rar final_sizess r*rbrs6fZeRV{1~7MZerrYFrh)r#r2r$r4rrrrr'minrnr`rgr&listrre)rrPr1rrL model_height model_widthoriginal_heightoriginal_width new_height new_widthpad_toppad_leftall_crops_equalrall_final_sizes_equalrtopleftbottomrightrmap_itemrrs @@r*rS)Sapiens2ImageProcessor._post_process_mapsUs lELL 1 1'..0L lELL 1 1'..0L  $ ,D 8  !5]^ ^  #D S5F(Ftu u  #D S5F(Ftu uyy* ii(  3?/(K$5|)% ?I>W<4:]^=F=TK39Z[  #j"?? 3y#>>  4@$)Ns*N*N'N  #3?@<45;<@K  %3?@<45;<@K$/ f36fZe6f3f 4 +08(T65Aq#f*d5j89}}$Q#"'# $ZF* %s4y);$/4U|,Cvu'3v:tEz(ABH }} **1-(/'&+"'     H h'!*$ UA@s ?KKr )NN)N)FFN)N NNN)NNN)9r!r"r#r$r%r valid_kwargsrBILINEARrr rr rrdefault_to_squarerrrrrrr rrrr rrrrr&r strrrrrr2r$rrr`r-rintdictrJrrUrrZrr{rSr( __classcell__)rs@r*rr,so=/L!**H&J$IS )D-IINJL F#(D!E#0404 NN&,NDe%&- N 56 N  NN459,C,C&,,CDe%&- ,C  ,C , ,Cj(4/,Cc>)*T1,C ,C\4#7Drs& 7E2E   5CCX8Y4NPE?||E?',||E?GJE? \\E?P~ /~ ~ B $ $r)