^jGddlZddlmZddlmZddlmZmZmZddl Z ddl Z ddl m cmZddlmZddlmZddlmZdd lmZmZdd lmZmZmZmZmZmZdd l m!Z!m"Z"dd l#m$Z$m%Z%m&Z&e&rddl'Z'Gd de!dZ(ddde)de*fdZ+d1dZ,d2dZ-de.e*de*de*fdZ/ d3de*de*de)de*dzd e.e*dzd!e0e.e.e*e.e*ff d"Z1d#Z2d$e*d!e jffd%Z4 d4d&Z5 d5de*d'e jfd(e0e*e*fd!e jffd)Z6d*e7e8efd!e jffd+Z9d6d,Z:d7d-Z;d.Zy)8N)deepcopy)product)AnyOptionalUnion) batched_nms)TorchvisionBackend)'SemanticSegmentationPostProcessorOutput) BatchFeature get_size_dict)IMAGENET_STANDARD_MEANIMAGENET_STANDARD_STDChannelDimension ImageInputPILImageResamplingSizeDict) ImagesKwargsUnpack) TensorTypeauto_docstringis_vision_availablec&eZdZUdZeeefed<y)Sam3ImageProcessorKwargsz mask_size (`dict[str, int]`, *optional*): The size `{"height": int, "width": int}` to resize the segmentation maps to. mask_sizeN)__name__ __module__ __qualname____doc__dictstrint__annotations__y/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/sam3/image_processing_sam3.pyrr3s CH~r%rF)totalmasks torch.Tensormask_thresholdstability_score_offsetc(|||zkDjdtjjdtj}|||z kDjdtjjdtj}||z }|S)Ndtype)sumtorchint16int32)r(r*r+ intersectionsunionsstability_scoress r&_compute_stability_scorer7<s .#99 :??%++?VZZ[]ejepepZq~(>>? D DRu{{ D [ _ _`bjojuju _ vF$v- r%cltj|dk(r1tjg|jdddd|jiS|j}|dd\}}tj |d\}}|tj ||jdddfz}tj |d\}}|||zz}tj|d\}}tj |d\} }| tj || jdddfz} tj | d\} }| || zz} tj| d\} }| | k||kz} tj| || |gd}|| jdz}|jg|ddd}|S) aL Computes the bounding boxes around the given input masks. The bounding boxes are in the XYXY format which corresponds the following required indices: - LEFT: left hand side of the bounding box - TOP: top of the bounding box - RIGHT: right of the bounding box - BOTTOM: bottom of the bounding box Return [0,0,0,0] for an empty mask. For input shape channel_1 x channel_2 x ... x height x width, the output shape is channel_1 x channel_2 x ... x 4. Args: - masks (`torch.Tensor` of shape `(batch, nb_mask, height, width)`) rNdevicer-dimr;) r1numelzerosshaper;maxarangeminstack unsqueezereshape)r(rAheightwidth in_height_in_height_coords bottom_edges top_edgesin_widthin_width_coords right_edges left_edges empty_filterouts r&_batched_mask_to_boxrUGs" {{5Q{{EEKK,EaE EE KKE"#JMFE99U+LIq 5<<y?O?O#PQUWXQX#YYii 0b9OL!'&YJ*??99-26LIq))Er*KHaeHOO!LTSTW!UUOYYB7NK%((;;OIIo26MJ *, 1IJL ++z9k<Hb QC ,))"- -C #++ %uSbz %1 %C Jr%cptj|tj|j}tj|tj|j}|\}}}}tj||||gg|j} t |j dk(r| jd} || zj}tj||dddf|d} tj||dddf|d} tj| | } tj| dS) zNFilter masks at the edge of a crop, but not at the edge of the original image.r/r;r>r Nr)atolrtolr<) r1 as_tensorfloatr;tensorlenrArFisclose logical_andany) boxescrop_boxorig_boxrYcrop_box_torchorig_box_torchlefttoprKoffsetnear_crop_edgenear_image_edges r&_is_box_near_crop_edgerlxs__XU[[VN__XU[[VNOD#q! \\D#tS125<< HF 5;;1!!!$ V^ " " $E]]5.q*ASTUNmmE>$'+BTUVO&&~7GHN 99^ ++r%rc orig_height orig_widthc|\}}}}|dk(r|dk(r ||k(r||k(r|S|||z z |||z z } }|||z || |z f} tjjj|| dS)Nr)value)r1nn functionalpad) r(rcrmrnrgrhrightbottompad_xpad_yrss r& _pad_masksrxs'D#uf qySAX%:"5&K:O . v|0L5E sECK 0C 88   " "5#Q " 77r% target_size crop_n_layers overlap_ratiopoints_per_cropcrop_n_points_downscale_factorreturncpt|tr td|jdd}g}t |dzD]-}t |||zz } |j t| /t|||\} } t| ||| ||\} } tj| } | j} tj| }|jdjdddd}tj| } tj |dddddddftj"}| || |fS) a Generates a list of crop boxes of different sizes. Each layer has (2**i)**2 boxes for the ith layer. Args: image (`torch.Tensor`): Image to generate crops for. target_size (`int`): Size of the smallest crop. crop_n_layers (`int`, *optional*): If `crops_n_layers>0`, mask prediction will be run again on crops of the image. Sets the number of layers to run, where each layer has 2**i_layer number of image crops. overlap_ratio (`int`, *optional*): Sets the degree to which crops overlap. In the first crop layer, crops will overlap by this fraction of the image length. Later layers with more crops scale down this overlap. points_per_crop (`int`, *optional*): Number of points to sam3ple per crop. crop_n_points_downscale_factor (`int`, *optional*): The number of points-per-side sam3pled in layer n is scaled down by crop_n_points_downscale_factor**n. z.Only one image is allowed for crop generation.r9NrXrr r.) isinstancelist ValueErrorrAranger"append_build_point_grid_generate_per_layer_crops_generate_crop_imagesr1r]r\rErFpermute ones_likeint64)imageryrzr{r|r} original_size points_gridin_points crop_boxes layer_idxscropped_imagespoint_grid_per_crop input_labelss r&_generate_crop_boxesrs08%IJJKK$MK =1$ %8*H!*KLM,X6787}mUbcJ *?E; K+'N'j)J!!#Jkk"56O%//2::1aAFO[[0N???1aA:#>ekkRL  DDr%c gg}}|\}}t||}|jdd||g|jdt|D]}d|dzz} t||zd| z z} tt j | | dz z|z| z } tt j | | dz z|z| z } t| D cgc]} t| | z | z}} t| D cgc]} t| | z | z}} t ||D]J\}}||t|| z|t|| z|g}|j||j|dzL||fScc} wcc} w)aq Generates 2 ** (layers idx + 1) crops for each crop_n_layers. Crops are in the XYWH format : The XYWH format consists of the following required indices: - X: X coordinate of the top left of the bounding box - Y: Y coordinate of the top left of the bounding box - W: width of the bounding box - H: height of the bounding box rrrX)rDrrr"mathceilr)rzr{rrr im_heightim_width short_sidei_layern_crops_per_sideoverlap crop_width crop_heightr crop_box_x0 crop_box_y0rgrhboxs r&rrs  J'IxY)Jq!Xy12a' +1-mj0A8H4HIJG/?!/C$Dx$OSc#cde $))W0@10D%E %QUe$efg @EFV@WX1sJ0A56X XAFGWAXYAsK'1Q67Y Y k: +ID#c$"3X>C+DUW`@abC   c "   gk * + + z !!YYs E)/E. n_per_sidecdd|zz }tj|d|z |}tj|dddf|df}tj|dddfd|f}tj||gdj dd}|S)z;Generates a 2D grid of points evenly spaced in [0,1]x[0,1].rXrNr-r<)r1linspacetilerErG)rripoints_one_sidepoints_xpoints_ypointss r&rrs !j. !FnnVQZDOzz/$'2ZODHzz/!T'2Q ODH [[(H-2 6 > >r1 EF Mr%c\g}g}t|D]\} } | \} } } }|dd| || | f}|j||jdd}tj|j dj d}||| |z}t|||}|j|||fS)z Takes as an input bounding boxes that are used to crop the image. Based in the crops, the corresponding points are also passed. Nr9)r)dimsr) enumeraterrAr1r]fliprF_normalize_coordinates)rrrrryrinput_data_formatrtotal_points_per_croprrcrgrhrtru cropped_imcropped_im_size points_scalernormalized_pointss r&rrsN , 8 8#+ c5&1c&j$u*45 j)$**23/||O499t9DNNqQ Z]+l:2; V$$%67 8 0 00r%coordsrc<|\}}|dzt||z }||z||z}}t|dz}t|dz}t|j}|r|j ddd}|d||z z|d<|d||z z|d<|r|j dd}|S)z Expects a numpy array of length 2 in the final dimension. Requires the original image size in (height, width) format. g??r-r).r).rXr:)rBr"rr\rG) ryrris_bounding_box old_height old_widthscale new_height new_widths r&rrs*J # J : :E&. E0A JIO$IZ#%&J f  # # %FAq)F^y9'<=F6NF^zJ'>?F6NA& Mr%rlec|d\}}tj||zt}d}d}|dD]}|||||z||z }| }|j||}|j ddS)z/Compute a binary mask from an uncompressed RLE.sizer.rFcountsrX)r1emptyboolrG transpose)rrHrImaskidxparitycounts r& _rle_to_maskr*sKMFE ;;v~T 2D C FX"(S3; u  <<v &D >>!Q r%ct|j|tj|jd|}||}|Dcgc]}|| }}||}|Dcgc] }t |}}||||fScc}wcc}w)a Perform NMS (Non Maximum Suppression) on the outputs. Args: rle_masks (`torch.Tensor`): binary masks in the RLE format iou_scores (`torch.Tensor` of shape (nb_masks, 1)): iou_scores predicted by the model mask_boxes (`torch.Tensor`): The bounding boxes corresponding to segmentation masks amg_crops_nms_thresh (`float`, *optional*, defaults to 0.7): NMS threshold. r)rbscoresidxs iou_threshold)rr\r1r@rAr) rle_masks iou_scores mask_boxesamg_crops_nms_thresh keep_by_nmsrrr(s r&!_post_process_for_mask_generationr8s  [[))!, -* KK(J'23!13I3K(J*3 43\#  4E 4 *i 33 4 4s  A8A=c|j\}}}|jdddjd}|ddddf|ddddfz }|j}g}t |D]}||dddf|k(dfdz}t |dk(rA||dfdk(r|j ||g||zgdn|j ||gd||zgdf|dd|ddz } ||dfdk(rgndg} | |djg| jz||z|djz gzz } |j ||g| d|S)z^ Encodes masks the run-length encoding (RLE), in the format expected by pycoco tools. rrrXNr-)rr) rArflattennonzerorr^ritemtolist) input_mask batch_sizerHrIdiffchange_indicesrTrcur_idxsbtw_idxsrs r& _mask_to_rlerUs !+ 0 0J##Aq!,44Q7J ae z!SbS&1 1D\\^N C :  @!.A"6!";Q">?!C x=A !Q$1$ VUO?OPQ VUO6E>?RST AB<(3B-/!!Q$'1,1#8A;##%&)::funxXZ|O`O`Ob>b=ccc VUOv>? @ Jr%ct|ttfrMtj|Dcgc]}|d c}}tj|Dcgc]}|d c}}n:t|tj r|j d\}}n tdtj||||gd}|jdj|j}||z}|Scc}wcc}w)a Scale batch of bounding boxes to the target sizes. Args: boxes (`torch.Tensor` of shape `(batch_size, num_boxes, 4)`): Bounding boxes to scale. Each box is expected to be in (x1, y1, x2, y2) format. target_sizes (`list[tuple[int, int]]` or `torch.Tensor` of shape `(batch_size, 2)`): Target sizes to scale the boxes to. Each target size is expected to be in (height, width) format. Returns: `torch.Tensor` of shape `(batch_size, num_boxes, 4)`: Scaled bounding boxes. rrXz4`target_sizes` must be a list, tuple or torch.Tensorr<) rrtupler1r]Tensorunbind TypeErrorrErFtor;)rb target_sizesr image_height image_width scale_factors r& _scale_boxesrts,u .||<$@aQqT$@A ll,#?QAaD#?@ L%,, /$0$7$7$:! kNOO;; \; U[\]L))!,// =L L E L%A#?s C* C/c`eZdZeZej ZeZ e Z dddZ dddZ dZdZdZdZdZdZdZdeeffd Ze d*ded edzdeed effd Z d*d edzd effd Z d*ded edzdedede e!dfdzdeed efdZ"de#dde!e$zdzd dffd Z% d+ddde&de'de&dzde#e&dzde(df dZ) d,dZ* d-dZ+dZ,d e-j\d e-j\fd!Z/ d.d"e#e0e&e&fdzd#e'd$ed d%fd&Z1d/d#e'd"e#e0dzfd'Z2 d0d#e'd(e'd"e#e0dzfd)Z3xZ4S)1Sam3ImageProcessori)rHrIi TNkwargsc $t|di|y)Nr$)super__init__)selfr __class__s r&rzSam3ImageProcessor.__init__s "6"r%imagessegmentation_mapsr~c &t|||fi|S)zp segmentation_maps (`ImageInput`, *optional*): The segmentation maps to preprocess. )r preprocess)rrrrrs r&rzSam3ImageProcessor.preprocesssw!&*;FvFFr%rc ||&t|tstdit|d}||d<t|di|S)zT Update kwargs that need further processing before being validated. r) param_namer$)rrr r_standardize_kwargs)rrrrs r&rz&Sam3ImageProcessor._standardize_kwargssE  Ix)H T={#STI'{w*4V44r%do_convert_rgbrr;z torch.devicec 8|j||||}|Dcgc]}|jdd}}|j} |j|fi| } | |d} ||j|ddtj } |j} | j ddtj| jdd |jdd | i| } | jd jtj| d <t| |d Scc}w)z/ Preprocess image-like inputs. )rrrr;r9N) pixel_valuesoriginal_sizesrF)rexpected_ndimsrrr) do_normalize do_rescaleresamplerrrXlabelsreturn_tensors)data tensor_typer$)_prepare_image_like_inputsrAcopy _preprocessrFIRSTupdaterNEARESTpopsqueezerr1rr )rrrrrr;rrr images_kwargsrrprocessed_segmentation_mapssegmentation_maps_kwargss r&_preprocess_image_like_inputsz0Sam3ImageProcessor._preprocess_image_like_inputssE00.L]fl1 9??u%++bc*?? 't''@-@ (,   (*.*I*I( $"2"8"8 +J+ '(.{{} $ $ + +$)"' 2 : :488E  +;$*:*:+2+6N+ '9@@CFFu{{SDN6:J3KLL=@sDr)rc <t||fd|i|jS)Nr)rr r)rrrrrs r&r zSam3ImageProcessor._preprocesss% w"6S.SFS```r%rz+np.ndarray | PIL.Image.Image | torch.Tensorrzr{r|r}c|j|}t||||||\}}} } |tjd}|j |}|j |}| j |} ||| | fS)a Generates a list of crop boxes of different sizes. Each layer has (2**i)**2 boxes for the ith layer. Args: image (`torch.Tensor`): Input original image target_size (`int`): Target size of the resized image crop_n_layers (`int`, *optional*, defaults to 0): If >0, mask prediction will be run again on crops of the image. Sets the number of layers to run, where each layer has 2**i_layer number of image crops. overlap_ratio (`float`, *optional*, defaults to 512/1500): Sets the degree to which crops overlap. In the first crop layer, crops will overlap by this fraction of the image length. Later layers with more crops scale down this overlap. points_per_crop (`int`, *optional*, defaults to 32): Number of points to sam3ple from each crop. crop_n_points_downscale_factor (`list[int]`, *optional*, defaults to 1): The number of points-per-side sam3pled in layer n is scaled down by crop_n_points_downscale_factor**n. device (`torch.device`, *optional*, defaults to None): Device to use for the computation. If None, cpu will be used. cpu) process_imagerr1r;r) rrryrzr{r|r}r;rrrs r&generate_crop_boxesz&Sam3ImageProcessor.generate_crop_boxess>""5)DX      * E A O^\ >\\%(F]]6* ),,V4#v. ?NLHHr%c |\} } |jdd}|jdd}|jd|jdk7r td|j|jk7r|j |j}|jd} t j | t j|j} |dkDr| ||kDz} |dkDrt|||} | | |kDz} || }|| }||kD}t|}t||dd| | g} || }|| }|| }t||| | }t|}|||fS)a  Filters the predicted masks by selecting only the ones that meets several criteria. The first criterion being that the iou scores needs to be greater than `pred_iou_thresh`. The second criterion is that the stability score needs to be greater than `stability_score_thresh`. The method also converts the predicted masks to bounding boxes and pad the predicted masks if necessary. Args: masks (`torch.Tensor`): Input masks. iou_scores (`torch.Tensor`): List of IoU scores. original_size (`tuple[int,int]`): Size of the original image. cropped_box_image (`torch.Tensor`): The cropped image. pred_iou_thresh (`float`, *optional*, defaults to 0.88): The threshold for the iou scores. stability_score_thresh (`float`, *optional*, defaults to 0.95): The threshold for the stability score. mask_threshold (`float`, *optional*, defaults to 0): The threshold for the predicted masks. stability_score_offset (`float`, *optional*, defaults to 1): The offset for the stability score used in the `_compute_stability_score` method. rrXz4masks and iou_scores must have the sam3e batch size.rW) rrArr;rr1onesrr7rUrlrxr)rr(rrcropped_box_imagepred_iou_threshstability_score_threshr*r+original_heightoriginal_widthr keep_maskr6rconverted_boxess r& filter_maskszSam3ImageProcessor.filter_masks'swF+8'''1-  a# ;;q>Z--a0 0ST T <<:,, ,#u||4J[[^ JJzELLQ S !Z/%ABI "C '7~Oef !%58N%NOII&i &.u5+ .A~0W   "i ))45"3_nUU#fo--r%c t|tjtjfr|j }g} t |D]\} } t|| tjrtj|| || <n(t|| tjs tdtj|| | dd} |r|j| } |r| |kD} | j| | S)aG Remove padding and upscale masks to the original image size. Args: masks (`Union[torch.Tensor, List[torch.Tensor], np.ndarray, List[np.ndarray]]`): Batched masks from the mask_decoder in (batch_size, num_channels, height, width) format. original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`): The original sizes of each image before it was resized to the model's expected input shape, in (height, width) format. mask_threshold (`float`, *optional*, defaults to 0.0): Threshold for binarization and post-processing operations. binarize (`bool`, *optional*, defaults to `True`): Whether to binarize the masks. max_hole_area (`float`, *optional*, defaults to 0.0): The maximum area of a hole to fill. max_sprinkle_area (`float`, *optional*, defaults to 0.0): The maximum area of a sprinkle to fill. apply_non_overlapping_constraints (`bool`, *optional*, defaults to `False`): Whether to apply non-overlapping constraints to the masks. Returns: (`torch.Tensor`): Batched masks in batch_size, num_channels, height, width) format, where (height, width) is given by original_size. zIInput masks should be a list of `torch.tensors` or a list of `np.ndarray`bilinearF)mode align_corners) rr1rnpndarrayrr from_numpyrF interpolate"_apply_non_overlapping_constraintsr) rr(rr*binarize max_hole_areamax_sprinkle_area!apply_non_overlapping_constraintsr output_masksrrinterpolated_masks r&post_process_masksz%Sam3ImageProcessor.post_process_masksusF nu||RZZ&@ A+224N ). 9 3 A}%(BJJ/ ++E!H5aa%,,7 kll ! eAh Jfk l 0$($K$KL]$^!$5$F!    1 2 3r%ct||||S)a$ Post processes mask that are generated by calling the Non Maximum Suppression algorithm on the predicted masks. Args: all_masks (`torch.Tensor`): List of all predicted segmentation masks all_scores (`torch.Tensor`): List of all predicted iou scores all_boxes (`torch.Tensor`): List of all bounding boxes of the predicted masks crops_nms_thresh (`float`): Threshold for NMS (Non Maximum Suppression) algorithm. )r)r all_masks all_scores all_boxescrops_nms_threshs r& post_process_for_mask_generationz3Sam3ImageProcessor.post_process_for_mask_generations1J Scddr% pred_masksc |jd}|dk(r|S|j}tj|dd}tj||dddddf}||k(}tj ||tj |d}|S) z Apply non-overlapping constraints to the object scores in pred_masks. Here we keep only the highest scoring object at each spatial location in pred_masks. rrXT)r=keepdimr>Ng$)rB)rr;r1argmaxrCwhereclamp)rr<rr; max_obj_indsbatch_obj_indskeeps r&r.z5Sam3ImageProcessor._apply_non_overlapping_constraintss  __Q' ? ""||JAtD j@D$PTATU~-[[z5;;zu3UV r%r thresholdreturn_segmentation_scoreszBlist[torch.Tensor] | list[SemanticSegmentationPostProcessorOutput]c|j}| td|j}t|}|t|t|k7r tdg}t |D]} t j jj|| jd|| dd} |jt| d|kDjt j| dd  nMt |D cgc]9} t|| df|kDjt j|| d  ;}} |s|D cgc]} | j}} |Scc} wcc} w) a Converts the output of [`Sam3Model`] into semantic segmentation maps. Args: outputs ([`Sam3ImageSegmentationOutput`]): Raw outputs of the model containing semantic_seg. target_sizes (`list[tuple[int, int]]` 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. threshold (`float`, *optional*, defaults to 0.5): Threshold for binarizing the semantic segmentation masks. 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` (binary class IDs, shape `(height, width)`) and `segmentation_scores` (sigmoid probabilities, shape `(1, 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 `(1, height, width)`). In both cases, `(height, width)` corresponds to the target size (if `target_sizes` is specified). zSemantic segmentation output is not available in the model outputs. Make sure the model was run with semantic segmentation enabled.zTMake sure that you pass in as many target sizes as the batch dimension of the logitsrr<r&Frr'r()rr) segmentationsegmentation_scores)r) semantic_segrsigmoidr^rr1rqrrr-rFrr rlongrI) routputsrrErFsemantic_logitssemantic_probsrsemantic_segmentationr resized_probsrrs r&"post_process_semantic_segmentationz5Sam3ImageProcessor.post_process_semantic_segmentationsD"..  "R  )002)   #?#s<'88 j%' !Z(  % 3 3 ? ?"3'11a18%c*#"' !@! &,,;-:4-@9-L,P,PQVQ[Q[,\3@3C .z*% 8)71)= )I(M(Mejj(Y/=a/@% !%*CX$Y4T%6%6$Y !$Y$$%%Zs >EE"c|j}|j}|j}|jd}|t ||k7r t d|j }||j } || z}|} | t| |} g} t|| D](\} } | |kD}| |} | |} | j| | d*| S)aD Converts the raw output of [`Sam3Model`] into final bounding boxes in (top_left_x, top_left_y, bottom_right_x, bottom_right_y) format. Args: outputs ([`Sam3ImageSegmentationOutput`]): Raw outputs of the model containing pred_boxes, pred_logits, and optionally presence_logits. threshold (`float`, *optional*, defaults to 0.3): Score threshold to keep object detection predictions. target_sizes (`list[tuple[int, int]]`, *optional*): List of tuples (`tuple[int, int]`) containing the target size `(height, width)` of each image in the batch. If unset, predictions will not be resized. Returns: `list[dict]`: A list of dictionaries, each dictionary containing the following keys: - **scores** (`torch.Tensor`): The confidence scores for each predicted box on the image. - **boxes** (`torch.Tensor`): Image bounding boxes in (top_left_x, top_left_y, bottom_right_x, bottom_right_y) format. r9Make sure that you pass in as many target sizes as images)rrb) pred_logits pred_boxespresence_logitsrAr^rrLrzipr)rrNrErrVrWrXr batch_scorespresence_scores batch_boxesresultsrrbrDs r&post_process_object_detectionz0Sam3ImageProcessor.post_process_object_detection#s()) '' !11 &&q)  #L(9Z(GXY Y#**,  &-557O'/9L!   #&{LAK {; ?MFEI%DD\F$KE NNfu= >  ? r%r*c|j}|j}|j}|j}|jd} |t || k7r t d|j} ||j} | | z} |j} |} | t| |} g}tt| | | D]\}\}}}||kD}||}||}||}|^||}t |dkDrKtjjj|jd|ddj!d}||kDj#tj$}|j'|||d|S)aQ Converts the raw output of [`Sam3Model`] into instance segmentation predictions with bounding boxes and masks. Args: outputs ([`Sam3ImageSegmentationOutput`]): Raw outputs of the model containing pred_boxes, pred_logits, pred_masks, and optionally presence_logits. threshold (`float`, *optional*, defaults to 0.3): Score threshold to keep instance predictions. mask_threshold (`float`, *optional*, defaults to 0.5): Threshold for binarizing the predicted masks. target_sizes (`list[tuple[int, int]]`, *optional*): List of tuples (`tuple[int, int]`) containing the target size `(height, width)` of each image in the batch. If unset, predictions will not be resized. Returns: `list[dict]`: A list of dictionaries, each dictionary containing the following keys: - **scores** (`torch.Tensor`): The confidence scores for each predicted instance on the image. - **boxes** (`torch.Tensor`): Image bounding boxes in (top_left_x, top_left_y, bottom_right_x, bottom_right_y) format. - **masks** (`torch.Tensor`): Binary segmentation masks for each instance, shape (num_instances, height, width). rrUr&FrH)rrbr()rVrWr<rXrAr^rrLrrrYr1rqrrr-rFrrrMr)rrNrEr*rrVrWr<rXrrZr[ batch_masksr\r]rrrbr(rDrys r&"post_process_instance_segmentationz5Sam3ImageProcessor.post_process_instance_segmentationVs<)) '' '' !11 &&q)  #L(9Z(GXY Y#**,  &-557O'/9L!((* !   #&{LAK+4S{T_5`+a O 'C'&%I%DD\F$KE$KE'*3/ u:>!HH//;;*('&+ < gaj ^+// ;E NNfuuM N+ O.r%N)rg? rXN)g)\(?gffffff?rrX)rTrrF)NrF)333333?N)rerN)5rrrr valid_kwargsrBILINEARrr image_meanr image_stdrr do_resizerrrdo_padpad_size mask_pad_sizerrrrr rrr rrrrr!rrrr r"r\rrr$r5r;r1rr.rrSr^ra __classcell__)rs@r&rrs+L!**H'J%IT *D-IIJLNFHM#(@!A#04 G G&, G12 G  G G&* 5d? 5  5&59 -M-M&,-M -M , -M c>)*T1 -M12-M -M^a^$aj(4/a  a)&(;<+//I</I /I  /I t /I)-S D(8/I(/In# L.d*/3je U\\ell.6:+0 S%5c?+d2S% S% %) S% N S%j11[_`e[fim[m1l #+/ PP P 5kD( Pr%r)r(r))g4@)rrcrdrXrb)F)gffffff?)rr))?rr r itertoolsrtypingrrrnumpyr)r1torch.nn.functionalrqrrr,torchvision.ops.boxesrimage_processing_backendsr image_processing_outputsr image_processing_utilsr r image_utilsrrrrrrprocessing_utilsrrutilsrrrPILrr\r"r7rUrlrrxrrrrrrrr r!rrrrr__all__r$r%r&r|s, '' -;OA5DD|5NEcf.b,$8S 888%"$78 2E2E2E 2E 4Z 2E %)I$4 2E 4S ?DI %&2Ej"D#%,,_c14]b#ll;@c? \\8  d38n    4:>8U+UUp r%