^j( ddlmZddlZddlmcmZddlmZddl m Z ddl m Z ddl mZddlmZmZdd lmZmZmZmZmZmZmZmZdd lmZmZdd lmZm Z m!Z!Gd d edZ"dZ#dZ$ d"dejJde&e'e'fde(de&ejJejJffdZ) d"dejJdejJde&e'e'fde(dejJf dZ*d#dejJde'dejJfdZ+dejJde&ejJejJffdZ, d#dejJdejJde'dejJfdZ-e Gd d!e Z.d!gZ/y)$)UnionN) functional)TorchvisionBackend)'SemanticSegmentationPostProcessorOutput) 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_availableceZdZUdZeed<y)Sapiens2ImageProcessorKwargsak 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____doc__bool__annotations__/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/sapiens2/image_processing_sapiens2.pyrr,sr"rF)totalct|jd\}}}}||||z||zg}tj|dS)Ndimunbindtorchstackxywhbs r#box_xywh_to_xyxyr37s>"JAq!Q qAEQU$A ;;qb !!r"c|jd\}}}}|d|zz|d|zz||g}tj|dS)Nr&?r'r)r-s r#box_xywh_to_cxcywhr6=sF"JAq!Q cAg+S1WQ0A ;;qb !!r"boxes output_sizepaddingreturnc8|jd\}}}}tj||gd}||z}||z} |\} } | | z } tj|| | zkDdtj||| z gdtj| | z| gd} || fS)aSCompute 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)r*r+r,where)r7r8r9center_xcenter_ywidthheightcenter scaled_width scaled_height output_height output_width aspect_ratioscales r#boxes_to_crop_paramsrHCs0). R(8%Hhv [[(H-2 6F7?LW$M"-M<-/L KK  4 4i@ \<,#>?RH ]\1=ArJ E 5=r"imagec >|\}}|j\}}}t|||\} } | jd\} } | jd\} }|dz | z }|dz |z }tj||dk}tj tj |tj|jtj |tj|jd\}}||ddddfz | ddddfzd | ddddfzz }||ddddfz | ddddfzd |ddddfzz }tjd |z|dz z dz d |z|dz z dz gd }|jd }tj|||||j|j }|jd }|df|dffD]V\}}|jstj|j!|j#ddd|||dd||<X|S)aRCrops 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)`. )r8r9r&?dtypedeviceij)indexingNr5g@r'rrOrNbilinearbicubiczerosT)mode padding_mode align_corners)shaperHr*r+minimummeshgridarangefloat32rOr,emptyrN unsqueezeanyF grid_sampleexpandsum)rIr7r8r9rDrE num_channels input_height input_widthrArGr=r> boxes_width boxes_heightscale_xscale_y is_bilineargrid_ygrid_xin_xin_ygrids num_boxesoutputimage_4dmaskrVs r#crop_and_resizervis;2#.M<.3kk+L, (KQXYMFEr*Hh % 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 [[L-V[VbVbjojuju vFq!H#Z0K<2KL d 88:== BB7d $" F4L Mr"heatmapskernelc|dzdk(s|dkr tdd|dz dzdz zdz}|dz dz}|jd }tj|||||fd d }t j |||g||g }|dd|| || f}|jd }t j|dkD|t j|} t j|dkD|| z t j|} || ddddfzS)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. rrKz2Kernel size must be an odd integer greater than 1.g333333?r5g?)rKrzr'constant)rVvalue) kernel_sizesigmaN) ValueErroramaxrapadtvF gaussian_blurr+r< ones_like) rwrxrborder origin_maxespaddedblurredresult result_maxes safe_maxesrGs r#gaussian_blur_preserve_maxrs#zQ&A+MNN FQJ#%) *S 0EqjQ F==V=,LUU8ffff=JVY ZFVV4DUTYN[G Qww6 7F;;6;*L\A-|U__\=Z[J KK q(,*CU__UaEb cE E!T4-( ((r"c |j\}}}}|j}|j||d}|jd}|j d}||zj } ||zj } t j|jddkDt j| | gdt j||dfd|} | |fS)aCPredict 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'r|rzgrO) rYrOreshaperargmaxfloatr+r<r_r,full) rw num_persons num_keypoints_ heatmap_widthrO heatmap_flatscores flat_index locations_x locations_y locationss r#get_keypoint_predictionsrs4<>>0K= __F##KCL   2  &F$$$,J -446K.557K s" [+.B7 K2DHI f r" keypointsblur_kernel_sizec .|j\}}}}|j}t|j||z|||j||||}|j ddj }t j|dd}|j} |dz} |dz} | | z} || z} |dddddfjd z|ddddd fjd z| zz}|| tj||tj dddfzz}|| tj||tj dddfzz}|jd }dd d | | | d z| d z d }|jDcic]\\}}}||f| ||z}}}}d |d|dz z}d |d|dz z}|dd|dzz |dz}|dd|dzz |dz}d |d|dz |dz |dz|dz|dz |dz |dzz}tj|jj }||z}||z}||z||zz }||z||zz |z }| |z||zz|z }|tj"||gd z Scc}}}w)aISub-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@)rKrKrKrK replicate)rVrzNrrKrRr&)rrrrKrr&rKrr&rrKrKr&r&r5rrrrrrrr')rYrOrrclamplograrflattenlongr+r\r_itemsfinforNepscat)rrwrrrheatmap_heightrrOheatmaps_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_processingrsiAI=K __F)}4nmTVf gk=.-H ~~dD)--/HeeHlEO(002"Q&M 1$L#l2O!O3M aAg  # # % )Yq!Qw-?-D-D-F-Jl,Z ZE Oell=W\WaWa&bcgijcj&kk kE MELLVSXS]S]$^_`bf_f$gg gE OOB Eq  1$% NfMkMkMm9I"b6R$UV^44Nt,~e/DDEJt,~e/DDEJ%N4,@(@@>RWCXXJ%N4,@(@@>RWCXXJt                       ! J ++j&& ' + +Cc!Jc!Jz)J,CCKZ'*z*AA[PH j(: +BBkQH uyy(H!52> >>5sJc"eZdZdZeZejZe Z e Z dddZ dZdddZdZdZdZdZdZdZdeeffd Ze d7d ed ed zd eeeed zdeedef fd Z d8d ed ed zd eeeed zdedede e!zd zde"e dfd zdefdZ#deddedfdZ$ d9d ee%jLdede'dddede'ded ed!ed"eeezd zd#eeezd zd$ed zd%ed&ed eeeed zdee%jLf d'Z( d:d(ee)d zd)edd*fd+Z* d;d eeeed,e+d-ed zd.e!ee)e+e+fzd zd(e!ee)e+e+fzd zdeee,e e%jLff d/Z- dBB +s)5C2rz torch.Tensorc ftt|D]}||}tj|dk(tjd|j |j |}|dz }tj|dk(tjd|j |j |}|||<|S)z/Reduce label values by 1, replacing 0 with 255.rrMrK)rangelenr+r<tensorrNrO)rridxlabels r# reduce_labelz#Sapiens2ImageProcessor.reduce_label~sV% C3KEKK ELLEKKX]XdXd,eglmEAIEKK ell3ekkZ_ZfZf.ginoEF3K   r" do_resizesizeresamplez7PILImageResampling | tvF.InterpolationMode | int | Nonedo_center_crop crop_sizerrescale_factorr image_mean image_stddisable_groupingrdo_padc L||d|df}g}t||D]\}}tj|tjd}t tj |tj|j}|jt||||}d}| r|j|}t|| \}}i}|jD]Z\}}|rN|r9t|d|d}|j|||}|j||}n|j|||}|||<\t!||}t|| \}}i}|jD]4\}}|r|j||}|j#|||| | | }|||<6t!||S) z"Custom preprocessing for Sapiens2.r@r?FrNrGrM)r7r8)r) max_height max_width)ziprto_dtype_imager+r]r6rrOextendrvrr rrresize center_cropr rescale_and_normalize)rrrrrrrrrrrrrrrr7rr8cropsrI image_boxes boxes_tensorgrouped_imagesgrouped_images_indexresized_images_groupedrYstacked_imagesaspect_ratio_sizeresized_imagesprocessed_images_groupeds r#rz"Sapiens2ImageProcessor._preprocesss(  >4=9KE&)&%&8 b"{**5 US1%,,{RWR_R_hmhtht2uv  _U,T_`a bFI &&v.F/DV^n/o,,!#%3%9%9%; ; !E>(0DNVZ[bVc(d%%)[[ART\%]N%)%5%5nd%KN%)[[x%PN,: "5 ) ;((>@TU/D^fv/w,,#% %3%9%9%; = !E>!%!1!1.)!L!77 NL*V_N/= $U +  =68LMMr" 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 [`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. 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 logitsrr'rSF)rrVrX) segmentationsegmentation_scores)rrK)r ImportErrorlogitsrr isinstancer+Tensornumpyrra interpolater_rappendrrYr) routputsrrrsemantic_segmentationrresized_logits semantic_mapseg_mapsiitems r#"post_process_semantic_segmentationz9Sapiens2ImageProcessor.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~ threshold source_sizesc t|tjr|j}t|tjr|j}t |}| | t d||t |k7r t d||t |k7r t d|j } || |j zdz } | j} | j\} } } }| dk(r|Dcgc]}gc}Stj|Dcgc] }|D]}| c}}tj| }| j} t| \}}t|| |}tt||j d |j d f \}}tj|d z | d z gtj| }||z |dddddfz|dddddfzd |dddddfzz }t#|}||tjt%||Dcgc]\\}}\}}||z ||z gc}}}}tj| }tj&t)|Dcgc]2}||j+dj-t ||d4c}}||dddddfz}||ddgdfz}g} t)| D]R}!||!}"||!}#tj.| | }$||#|kD}%|"|%}"|#|%}#|$|%}$| j1|"|#|$||!dTg}&d}'|D])}t |}(|&j1| |'|'|(z|'|(z }'+|&Scc}wcc}}wcc}}}}wcc}w)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)`): absolute 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.rzrrM)rrwrr@r?)r8rKr5)rrKrrKr)rrrbbox)rr+rtolistrrrwrOrYrr]rrrrHr6rr3rrrr_rcr\r))rr r7outputs_flippedr~r(r)r num_imagesrwrOnum_total_personsrrrrr boxr  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_estimationz3Sapiens2ImageProcessor.post_process_pose_estimationsd lELL 1'..0L lELL 1'..0LZ  # (<`a a  # c,6G(Ggh h  # c,6G(Ggh h##  & ?#;#;;q@HJR..G=.-  ! %&1B& &||$) A[[ AcS AS 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\\hjvXwT5 7T |"L0--2OPmm O %yy(-Z'8#$K0::1=DDS{I[E\^_`   *,)pr(rmapsr)rrDnormals)ra normalizerI_post_process_maps)rr r)rrDrIresultsrs r#post_process_normal_estimationz5Sapiens2ImageProcessor.post_process_normal_estimationsV<++gootD))|,bs* 3::F#:::s A c|j}|j||jddddddfz }|j||||}|Dcgc]}d|ic}Scc}w)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. NrGpointmap) pointmapsr4rK)rr r)rrDrPrLrs r# post_process_pointmap_estimationz7Sapiens2ImageProcessor.post_process_pointmap_estimationso:%% >> %!GNN1at3C$DDI))Ldu* 4;;V$;;;s A backgroundscttjrj|jj d}|jj }|jj}|tk7r tdduxstfdD}g|zt|}t|dk7rt||k7r td|D cgc]<} tjtj| |dj|>c}  xstfd D} tj |j|j"gd } <|r:t%d} t'j(| | d d d } | j+dd} g} |r| r| ddddf}| ddddf}dg|z}rtj,}|j dd| j ddk7r't'j(|| j ddd d d }|d|z |zzj+dd}tj|tj.d}t1|||D]\}}}| j3|||d| St5t| D]!}| |}rC|sAt'j(|j7d|d d d d}|j+dd}|dd}|dd}d}rtdk(rdn|}|j dd|j ddk7r9t'j(|j7d|j ddd d d d}|d|z |zzj+dd}tj|tj.d}| j3|||d$| Scc} w)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 outputc3RK|]}t|tdk( ywrN)tuple).0rrs r# zDSapiens2ImageProcessor.post_process_image_matting..s(= 6:E$K5a1 1= s$'rKz[Make sure that you pass in as many backgrounds as the batch dimension of the matting outputTrc3bK|]&}|jdddjddk((yw)Nr)rY)rW backgroundbackground_tensorss r#rXzDSapiens2ImageProcessor.post_process_image_matting..s=C JTJ  RS !%7%:%@%@%E EC s,/r'rSFrrVrX antialiasr|rLrrZ) foregroundalpha composite)rr+rr, foregroundsrYrOrNrrallrrrto_imagerralphasrVrarrr,uint8rrrr_)rr rrR batch_sizerOrNall_target_sizes_equalbackground_listbackground_imageall_background_sizes_equalmatting target_sizerrbre compositesr[r_r`rar matting_itemr\s ` @r#post_process_image_mattingz1Sapiens2ImageProcessor.post_process_image_mattings8: lELL 1'..0L((..q1 $$++##))  #S.. r".!5" = >J= :    "1+>O?#q(S-AZ-O q )8"$""3<<0@#AVZ[^^_ef" *<%;& sC XjC @ "))W00'..AqI  #(> Q0Kmm # GmmC-G !&@!!RaR%.KQU^F*,J!"[[);< ##BC(GMM"#,>>!""$]]23/'&+"' "J*QZ:,EELLSRUV  // %++UYZ 03K0T , E9 &0!&%. V As7|, b&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= b@ g"s!AOrHc t|tjr|j}t|tjr|j}||du}|r | t d|"t |t |k7r t d|"t |t |k7r t d|j d}|j d}g|ri|D]d\}}t||f||\} } | |kr|| z dznd} | |kr|| z dznd} j| | | t| |z| t| |zff xstfdD} g||Dcgc] }t|c}n||Dcgc] }t|c} xstfd D}g}| rK|rI|rd\}}}}|dddd||||f}rtj|dd d d }t|}|Stt |D]c}||}|r|\}}}}|dd||||f}r/tj|j!d|d d d d}|j|e|Scc}wcc}w) 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 outputsr@r?rzrc3.K|] }|dk(ywrUr!)rWcropr s r#rXz.s*N458+;*Nc3.K|] }|dk(ywrUr!)rWr final_sizess r#rXz.s6fRVt{1~7M6frtrSFr])rr+rr,rrrrrminrcrVrarlistrr_)rrHr)rrD model_height model_widthoriginal_heightoriginal_width new_height new_widthpad_toppad_leftall_crops_equalrall_final_sizes_equalrtopleftbottomrightrmap_itemr rvs @@r#rKz)Sapiens2ImageProcessor._post_process_mapses lELL 1'..0L lELL 1'..0L  $ ,D 8  !5]^ ^  #D S5F(Ftu u  #D S5F(Ftu uyy* ii(  3? /(K$n5|[)% I?I<>W<*4:]^=F=TK)39Z[  #j,"?? 3y+#>>  $)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 I5<I:)NN)N)FFN)NF)N NNN)NNN)3rrrrr valid_kwargsrBILINEARrr rr rrdefault_to_squarerrrrrrrrrrrrxrrrrr strrrrrr+rrrrVr'intdictrCrMrQrprK __classcell__)rs@r#rr'sQ=/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& 7EO2E   5CCX8Y4NPE?||E?',||E?GJE? \\E?PS /S S l $ $r"