T^(hhFdZddlZddlmZddlmZddlmZmZm Z m Z m Z m Z ddl ZddlmZmZmZddlmZmZmZmZdd lmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,e)r ddl-Z-ddl.m/cm0Z1e*rdd l2m3Z3e(rddl4Z5dd l6m Z7dd l8m9Z9m:Z:e+jve<Z=GddeZ>ddde?de@fdZAddde?de@fdZBde@dejfdZD d5de@dejde e@e@fdejfdZE d6de@de@de?d e e@d!e e e@d"e e eFefde e e e@e e@ffd#ZGd$ZH d7d%ZId&e e@d'e@d(e@fd)ZJd&e e@d'e@d(e@fd*ZKd8d+ZLd8d,ZMd9d-ZNd:d.ZOd;d/ZPdzImage processor class for SAM.N)deepcopy)product)AnyDictListOptionalTupleUnion)BaseImageProcessor BatchFeature get_size_dict)convert_to_rgbpadresizeto_channel_dimension_format) IMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STDChannelDimension ImageInputPILImageResamplingget_image_sizeinfer_channel_dimension_formatis_scaled_imagemake_list_of_imagesto_numpy_array valid_imagesvalidate_preprocess_arguments) TensorTypefilter_out_non_signature_kwargsis_tf_availableis_torch_availableis_torchvision_availableloggingrequires_backends) batched_nms)numpy)flatten shape_listc)leZdZdZdgZdddej dddddddddf dedee e fdee e fd ed ed e e e fd ed e e e ee fde e e ee fdede e de e deddffd Z d4dej"dee e fde e e efde e e efdej"f dZdee e fde fdZej,ddfdej"dee e fd ede e e efde e e efdej"f dZ d5deded ed ede ee e fd ed e e d e e e ee fde e e ee fde ede ee e fde e e effdZ d6dede edee e fd ed e ed e e d e ed e e e ee fde e e ee fde ede ee e fde ede e e efde e e efdeej"ee e fee e fffdZ d7dede edee e fde ede ee e fde e e efdej"fd Zedddddddddddddddej:dfd!ed"e ede ede ee e fde ee e fd e d#d e ed e e e e fd e ed e e e ee fde e e ee fde ede ee e fde ee e fde ed$e e e efdede e e eff$d%Z d8d&Z d9d'Z! d9d(Z" d:d)Z# d;d*e d+e d,e e d-e ee d.e d/de e e efd$e fd0Z$ dSamImageProcessora  Constructs a SAM image processor. Args: do_resize (`bool`, *optional*, defaults to `True`): Whether to resize the image's (height, width) dimensions to the specified `size`. Can be overridden by the `do_resize` parameter in the `preprocess` method. size (`dict`, *optional*, defaults to `{"longest_edge": 1024}`): Size of the output image after resizing. Resizes the longest edge of the image to match `size["longest_edge"]` while maintaining the aspect ratio. Can be overridden by the `size` parameter in the `preprocess` method. mask_size (`dict`, *optional*, defaults to `{"longest_edge": 256}`): Size of the output segmentation map after resizing. Resizes the longest edge of the image to match `size["longest_edge"]` while maintaining the aspect ratio. Can be overridden by the `mask_size` parameter in the `preprocess` method. resample (`PILImageResampling`, *optional*, defaults to `Resampling.BILINEAR`): Resampling filter to use if resizing the image. Can be overridden by the `resample` parameter in the `preprocess` method. do_rescale (`bool`, *optional*, defaults to `True`): Wwhether to rescale the image by the specified scale `rescale_factor`. Can be overridden by the `do_rescale` parameter in the `preprocess` method. rescale_factor (`int` or `float`, *optional*, defaults to `1/255`): Scale factor to use if rescaling the image. Only has an effect if `do_rescale` is set to `True`. Can be overridden by the `rescale_factor` parameter in the `preprocess` method. do_normalize (`bool`, *optional*, defaults to `True`): Whether to normalize the image. Can be overridden by the `do_normalize` parameter in the `preprocess` method. Can be overridden by the `do_normalize` parameter in the `preprocess` method. image_mean (`float` or `List[float]`, *optional*, defaults to `IMAGENET_DEFAULT_MEAN`): Mean to use if normalizing the image. This is a float or list of floats the length of the number of channels in the image. Can be overridden by the `image_mean` parameter in the `preprocess` method. Can be overridden by the `image_mean` parameter in the `preprocess` method. image_std (`float` or `List[float]`, *optional*, defaults to `IMAGENET_DEFAULT_STD`): Standard deviation to use if normalizing the image. This is a float or list of floats the length of the number of channels in the image. Can be overridden by the `image_std` parameter in the `preprocess` method. Can be overridden by the `image_std` parameter in the `preprocess` method. do_pad (`bool`, *optional*, defaults to `True`): Whether to pad the image to the specified `pad_size`. Can be overridden by the `do_pad` parameter in the `preprocess` method. pad_size (`dict`, *optional*, defaults to `{"height": 1024, "width": 1024}`): Size of the output image after padding. Can be overridden by the `pad_size` parameter in the `preprocess` method. mask_pad_size (`dict`, *optional*, defaults to `{"height": 256, "width": 256}`): Size of the output segmentation map after padding. Can be overridden by the `mask_pad_size` parameter in the `preprocess` method. do_convert_rgb (`bool`, *optional*, defaults to `True`): Whether to convert the image to RGB. pixel_valuesTNgp? do_resizesize mask_sizeresample do_rescalerescale_factor do_normalize image_mean image_stddo_padpad_size mask_pad_sizedo_convert_rgbreturnc t|d i|||nddi}t|ts t |dn|}| | nddd} t | d} ||nddi}t|ts t |dn|}| | nddd} t | d} ||_||_||_||_||_ ||_ ||_ ||nt|_ | | nt|_| |_| |_| |_| |_y) N longest_edgeiFmax_sizedefault_to_square)heightwidthTr?)super__init__ isinstancedictrr-r.r/r0r1r2r3rr4rr5r6r7r8r9)selfr-r.r/r0r1r2r3r4r5r6r7r8r9kwargs __class__s j/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/transformers/models/sam/image_processing_sam.pyrFzSamImageProcessor.__init__vs" "6"'tnd-CLVW[]aLb}deDhl'38DSW9X TB!*!6I^S*DY&/&;AU   *,image data_formatinput_data_formatc z|d|d}}t||\}} || z } ||z } t|d| fd| fff||d|} | S)a Pad an image to `(pad_size["height"], pad_size["width"])` with zeros to the right and bottom. Args: image (`np.ndarray`): Image to pad. pad_size (`Dict[str, int]`): Size of the output image after padding. data_format (`str` or `ChannelDimension`, *optional*): The data format of the image. Can be either "channels_first" or "channels_last". If `None`, the `data_format` of the `image` will be used. input_data_format (`str` or `ChannelDimension`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred. r@rA channel_dimr)rOrP)rr) rIrNr7rOrPrJ output_height output_width input_height input_width pad_width pad_height padded_images rL pad_imagezSamImageProcessor.pad_imagesy,'/x&8(7:K| $25FW$X! k ;. "\1  _q)n - $/    rM old_shaper<c|\}}|dzt||z }||z||z}}t|dz}t|dz}||fS)zW Compute the output size given input size and target long side length. ??)maxint)rIr\r<oldholdwscalenewhnewws rL_get_preprocess_shapez'SamImageProcessor._get_preprocess_shapesW ds"St_4E\4%u E &u:KL %)%5%5!)%!/&6 & ""  "/{VghEm%888rMsegmentation_mapc dt|}|jdk(rd}|d}tj}nd}| t |d}t ||}|j |||tjdd||| \}} |r|jd }|jtj}||fS) NT)N.F) num_channelsrR) rNr-r.r0r1r3r6r7rPr) rndimrFIRSTrrrrrNEARESTsqueezeastypenpint64) rIryr-r/r6r8rPadded_channel_dimrw_s rL_preprocess_maskz"SamImageProcessor._preprocess_mask\s**:;  A % $ / :  0 6 6  %  ($BCSbc$d!&'7EVW ".."'//"//  ! /77: +22288<..rMimagessegmentation_mapsrreturn_tensorsc n jn jtts t dnn j tts t dnn j n jn j  n j  n j  n j  n j  n j t d n jt dn jt!|}t#|s t%d|#t!|d}t#|s t%dt'  t)   fd |D\}}}|||d }|At) fd |D\}}t+d t)||DsJd||d<t-||S)a Preprocess an image or batch of images. Args: images (`ImageInput`): Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If passing in images with pixel values between 0 and 1, set `do_rescale=False`. segmentation_maps (`ImageInput`, *optional*): Segmentation map to preprocess. do_resize (`bool`, *optional*, defaults to `self.do_resize`): Whether to resize the image. size (`Dict[str, int]`, *optional*, defaults to `self.size`): Controls the size of the image after `resize`. The longest edge of the image is resized to `size["longest_edge"]` whilst preserving the aspect ratio. mask_size (`Dict[str, int]`, *optional*, defaults to `self.mask_size`): Controls the size of the segmentation map after `resize`. The longest edge of the image is resized to `size["longest_edge"]` whilst preserving the aspect ratio. resample (`PILImageResampling`, *optional*, defaults to `self.resample`): `PILImageResampling` filter to use when resizing the image e.g. `PILImageResampling.BILINEAR`. do_rescale (`bool`, *optional*, defaults to `self.do_rescale`): Whether to rescale the image pixel values by rescaling factor. rescale_factor (`int` or `float`, *optional*, defaults to `self.rescale_factor`): Rescale factor to apply to the image pixel values. do_normalize (`bool`, *optional*, defaults to `self.do_normalize`): Whether to normalize the image. image_mean (`float` or `List[float]`, *optional*, defaults to `self.image_mean`): Image mean to normalize the image by if `do_normalize` is set to `True`. image_std (`float` or `List[float]`, *optional*, defaults to `self.image_std`): Image standard deviation to normalize the image by if `do_normalize` is set to `True`. do_pad (`bool`, *optional*, defaults to `self.do_pad`): Whether to pad the image. pad_size (`Dict[str, int]`, *optional*, defaults to `self.pad_size`): Controls the size of the padding applied to the image. The image is padded to `pad_size["height"]` and `pad_size["width"]` if `do_pad` is set to `True`. mask_pad_size (`Dict[str, int]`, *optional*, defaults to `self.mask_pad_size`): Controls the size of the padding applied to the segmentation map. The image is padded to `mask_pad_size["height"]` and `mask_pad_size["width"]` if `do_pad` is set to `True`. do_convert_rgb (`bool`, *optional*, defaults to `self.do_convert_rgb`): Whether to convert the image to RGB. return_tensors (`str` or `TensorType`, *optional*): The type of tensors to return. Can be one of: - Unset: Return a list of `np.ndarray`. - `TensorType.TENSORFLOW` or `'tf'`: Return a batch of type `tf.Tensor`. - `TensorType.PYTORCH` or `'pt'`: Return a batch of type `torch.Tensor`. - `TensorType.NUMPY` or `'np'`: Return a batch of type `np.ndarray`. - `TensorType.JAX` or `'jax'`: Return a batch of type `jax.numpy.ndarray`. data_format (`ChannelDimension` or `str`, *optional*, defaults to `ChannelDimension.FIRST`): The channel dimension format for the output image. Can be one of: - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. - Unset: Use the channel dimension format of the input image. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format for the input image. If unset, the channel dimension format is inferred from the input image. Can be one of: - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. - `"none"` or `ChannelDimension.NONE`: image in (height, width) format. Fr=TrBzkInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray.r{)expected_ndimszvInvalid segmentation map type. Must be of type PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray.) r1r2r3r4r5r6size_divisibilityr-r.r0c3\K|]#}j|     %yw))rNr-r.r0r1r2r3r4r5r6r7r9rOrPN)rx).0imgrOr9r3r6r1r-r4r5rPr7r0r2rIr.s rL z/SamImageProcessor.preprocess.. sU"!&&'%)#1!-)'!%#1 +&7's),)r,original_sizesreshaped_input_sizesc 3LK|]}j|yw))ryr-r/r6r8rPN)r)rmaskr6r-rPr8r/rIs rLrz/SamImageProcessor.preprocess..'s= )))-"+"+%&3*; * s!$c3,K|] \}}||k(ywNrD)roriginal_im_sizeoriginal_mask_sizes rLrz/SamImageProcessor.preprocess..5s$8$&8!$66sz:Segmentation maps should be the same size as input images.labels)data tensor_type)r-r.rGrHrr/r0r1r2r3r4r5r6r7r8r9rrrirzipallr )rIrrr-r.r/r0r1r2r3r4r5r6r7r8r9rrOrPrrroriginal_mask_sizess` ````````````` `` rL preprocesszSamImageProcessor.preprocesssk`"+!6IDNN 'tTYYLVW[]aLb}deDhl!*!6IDNN i. 9 F  (38#-#9Zt +9+E4K^K^'3'?|TEVEV #-#9Zt !*!6IDNN !-4;;'38 TB)6)B HZHZ %mtL +9+E4K^K^$V,F#:   ( 34EVW X  12 > &!)%!& 8;""#8 4 4.#,$8   (58  !2  6 2 2BBrMc|dk(r|j||||||S|dk(r|j||||||Std)a Remove padding and upscale masks to the original image size. Args: masks (`Union[List[torch.Tensor], List[np.ndarray], List[tf.Tensor]]`): Batched masks from the mask_decoder in (batch_size, num_channels, height, width) format. original_sizes (`Union[torch.Tensor, tf.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. reshaped_input_sizes (`Union[torch.Tensor, tf.Tensor, List[Tuple[int,int]]]`): The size of each image as it is fed to the model, in (height, width) format. Used to remove padding. mask_threshold (`float`, *optional*, defaults to 0.0): The threshold to use for binarizing the masks. binarize (`bool`, *optional*, defaults to `True`): Whether to binarize the masks. pad_size (`int`, *optional*, defaults to `self.pad_size`): The target size the images were padded to before being passed to the model. If None, the target size is assumed to be the processor's `pad_size`. return_tensors (`str`, *optional*, defaults to `"pt"`): If `"pt"`, return PyTorch tensors. If `"tf"`, return TensorFlow tensors. Returns: (`Union[torch.Tensor, tf.Tensor]`): Batched masks in batch_size, num_channels, height, width) format, where (height, width) is given by original_size. pt)masksrrmask_thresholdbinarizer7tfz*return_tensors must be either 'pt' or 'tf')_post_process_masks_pt_post_process_masks_tfri)rIrrrrrr7rs rLpost_process_masksz$SamImageProcessor.post_process_masks>syD T !..-%9-!! / t #..-%9-!! / IJ JrMct|dg| |jn|}|d|df}t|tjt j fr|j}t|tjt j fr|j}g}t|D]\} } t|| t j rtj|| || <n(t|| tjs tdtj|| |dd} | d d|| d d|| d f} tj| | dd} |r| |kD} |j| |S) aF Remove padding and upscale masks to the original image size. Args: masks (`Union[List[torch.Tensor], 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. reshaped_input_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`): The size of each image as it is fed to the model, in (height, width) format. Used to remove padding. mask_threshold (`float`, *optional*, defaults to 0.0): The threshold to use for binarizing the masks. binarize (`bool`, *optional*, defaults to `True`): Whether to binarize the masks. pad_size (`int`, *optional*, defaults to `self.pad_size`): The target size the images were padded to before being passed to the model. If None, the target size is assumed to be the processor's `pad_size`. Returns: (`torch.Tensor`): Batched masks in batch_size, num_channels, height, width) format, where (height, width) is given by original_size. torchNr@rAzIInput masks should be a list of `torch.tensors` or a list of `np.ndarray`bilinearF)mode align_corners.rr|)r%r7rGrTensorrndarraytolist enumerate from_numpyriF interpolateappend) rIrrrrrr7target_image_size output_masksirwinterpolated_masks rLrz(SamImageProcessor._post_process_masks_ptusw2 $ *$,$44==(%h/'1BC nu||RZZ&@ A+224N *U\\2::,F G#7#>#>#@  ). 9 3 A}%(BJJ/ ++E!H5aa%,,7 !lmm ! eAh8IPZjo p  1#7S9Ma9PQR9S7SUqWklmWnopWqUq2q r  ! .?U_ot u $5$F!    1 2 3rMct|dg| |jn|}|d|df}g}t|D]\} } tj|| gd} tj j | |d} | ddd|| d d|| d ddf} tj j | | d} |r| |kD} |jtj| gd |S) a Remove padding and upscale masks to the original image size. Args: masks (`tf.Tensor`): Batched masks from the mask_decoder in (batch_size, num_channels, height, width) format. original_sizes (`tf.Tensor`): The original size of the images before resizing for input to the model, in (height, width) format. reshaped_input_sizes (`tf.Tensor`): The size of the image input to the model, in (height, width) format. Used to remove padding. mask_threshold (`float`, *optional*, defaults to 0.0): The threshold to use for binarizing the masks. binarize (`bool`, *optional*, defaults to `True`): Whether to binarize the masks. pad_size (`int`, *optional*, defaults to `self.pad_size`): The target size the images were padded to before being passed to the model. If None, the target size is assumed to be the processor's `pad_size`. Returns: (`tf.Tensor`): Batched masks in batch_size, num_channels, height, width) format, where (height, width) is given by original_size. rNr@rA)rr{r r|permr)methodrr|)rr r|r{)r%r7rr transposerNrr) rIrrrrrr7rrrrwrrs rLrz(SamImageProcessor._post_process_masks_tfs0 $'$,$44==(%h/'1BC ). 9 T A}<<a|\ R S TrMcP|dk(rt||||S|dk(rt||||Sy)a Post processes mask that are generated by calling the Non Maximum Suppression algorithm on the predicted masks. Args: all_masks (`Union[List[torch.Tensor], List[tf.Tensor]]`): List of all predicted segmentation masks all_scores (`Union[List[torch.Tensor], List[tf.Tensor]]`): List of all predicted iou scores all_boxes (`Union[List[torch.Tensor], List[tf.Tensor]]`): List of all bounding boxes of the predicted masks crops_nms_thresh (`float`): Threshold for NMS (Non Maximum Suppression) algorithm. return_tensors (`str`, *optional*, defaults to `pt`): If `pt`, returns `torch.Tensor`. If `tf`, returns `tf.Tensor`. rrN)_postprocess_for_mg_postprocess_for_mg_tf)rI all_masks all_scores all_boxescrops_nms_threshrs rL post_process_for_mask_generationz2SamImageProcessor.post_process_for_mask_generations=$ T !&y*iIYZ Z t #))ZL\] ]$rM crop_n_layers overlap_ratiopoints_per_cropcrop_n_points_downscale_factordevicez torch.devicec t|||||||\} }} } | dk(r]|tjd}tj| |} tj||}tj| |} n]| dk(rM| t dt j | } t j |}t j | } n t d| || | fS)aC Generates a list of crop boxes of different sizes. Each layer has (2**i)**2 boxes for the ith layer. Args: image (`np.array`): 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 sample from each crop. crop_n_points_downscale_factor (`List[int]`, *optional*, defaults to 1): The number of points-per-side sampled 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. input_data_format (`str` or `ChannelDimension`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred. return_tensors (`str`, *optional*, defaults to `pt`): If `pt`, returns `torch.Tensor`. If `tf`, returns `tf.Tensor`. rcpurrz=device is not a supported argument when return_tensors is tf!z+return_tensors must be either 'pt' or 'tf'.)_generate_crop_boxesrrtensorrirconvert_to_tensor) rIrN target_sizerrrrrrPr crop_boxescropped_images input_labelss rLgenerate_crop_boxesz%SamImageProcessor.generate_crop_boxessJEY      * E A O^\ T !~e,j@J#ll?6JO << VDL t #! !`aa--j9J 22?CO// =LJK K?NLHHrMc || dk(r|j||||||||S| dk(r|j||||||||Sy)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 (`Union[torch.Tensor, tf.Tensor]`): Input masks. iou_scores (`Union[torch.Tensor, tf.Tensor]`): List of IoU scores. original_size (`Tuple[int,int]`): Size of the orginal image. cropped_box_image (`np.array`): 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. return_tensors (`str`, *optional*, defaults to `pt`): If `pt`, returns `torch.Tensor`. If `tf`, returns `tf.Tensor`. r)r iou_scoresrwcropped_box_imagepred_iou_threshstability_score_threshrstability_score_offsetrN)_filter_masks_pt_filter_masks_tf) rIrrrwrrrrrrs rL filter_maskszSamImageProcessor.filter_masks&s|L T !((%+"3 /'=-'=)  t #((%+"3 /'=-'=)  $rMc t|dg|\} } |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 orginal image. cropped_box_image (`np.array`): 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. rrr|3masks and iou_scores must have the same batch size.dtyper)r%r(shaperirtoronesbool_compute_stability_score_pt_batched_mask_to_box_is_box_near_crop_edge _pad_masks_mask_to_rle_pytorchrIrrrwrrrrroriginal_heightoriginal_width batch_size keep_maskstability_scoresscoresconverted_boxess rLrz"SamImageProcessor._filter_masks_ptcsH $ **7'''1-  a# ;;q>Z--a0 0RS S <<:,, ,#u||4J[[^ JJzELLQ S !Z/%ABI "C ':5.Rhi !%58N%NOII&i &.u5+ .A~0W   "i ))45"3_nU$U+fo--rMc t|dg|\} } tj||jd|jdz|jddg}tj||jd|jdz|jddg}|jd|jdk7r t d|jd} tj | tj } |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 (`tf.Tensor`): Input masks. iou_scores (`tf.Tensor`): List of IoU scores. original_size (`Tuple[int,int]`): Size of the orginal image. cropped_box_image (`np.array`): 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. rrr|r{Nrrr) r%rreshaperrirr_compute_stability_score_tf_batched_mask_to_box_tf_is_box_near_crop_edge_tf _pad_masks_tf_mask_to_rle_tfrs rLrz"SamImageProcessor._filter_masks_tfsH $'*7'ZZ Z-=-=a-@:CSCSTUCV-VXbXhXhijikXl,mn  55;;q>EKKN#BEKKPQPRO"TU ;;q>Z--a0 0RS S[[^ GGJbgg6 S !Z/%ABI "C ':5.Rhi !%58N%NOII&i &1%8. .A~0W   "i ))4e%6X&fo--rM)NN)NNNNNNNN) NNNNNNNNNNNNN)NNNNN)rTNr)rTN)r)rg? r|NNr))\(?ffffff?rr|r)rrrr|))__name__ __module__ __qualname____doc__model_input_namesrBILINEARrrstrrar floatrrrFrrrr[r rgBICUBICrrrrrxrr rrrrrrrrrrr __classcell__)rKs@rLr+r+Cs.`((#$('9'B'B,3!:>9="&'+#.-.-38n.-S> .- % .-  .-c5j).-.-U5$u+#567.-E%e"456.-.-3-.- }.-.- !.-h?CDH #zz#sCx.#eC)9$9:; # $E#/?*?$@A # #J uS#X c (:'A'A>BDH / zz/ 38n/ % / eC)9$9:; / $E#/?*?$@A /  / n*.'+*.:>9=!%-1DH*** *  * tCH~& *%*!*U5$u+#567*E%e"456**4S>**$E#/?*?$@A*B%)#'+%)*.'+:>9=!%-1)->BDH5959D>5938n 59 % 59 TN 59!59tn59U5$u+#56759E%e"45659594S>*59!59eC)9$9:;59$E#/?*?$@A59 rzz5c?E#s(O; (/S> (/  (/  S#X/ (/$E#/?*?$@A(/ (/T%&37$()-.237%)6:'+:>9=!%-126)-;?(8(>(>DH'uCuC$J/uCD> uC tCH~& uC DcN+ uC/0uCTNuC!sEz!23uCtnuCU5$u+#567uCE%e"456uCuC4S>*uC S#X/uC !!uC"!sJ!78#uC$&%uC&$E#/?*?$@A'uC'uCx5Kphl-`hl(VRV^6))+>?+/DH"?I ?I  ?I "# ?I)1c(;?I(?I$E#/?*?$@A?I?IN# ;F# N.l# K.rMr+r torch.Tensorrrc(|||zkDjdtjjdtj}|||z kDjdtjjdtj}||z }|S)Nr)sumrint16int32rrr intersectionsunionsrs rLrrs .#99 :??%++?VZZ[]ejepepZq~(>>? D DRu{{ D [ _ _`bjojuju _ vF$v- rM tf.Tensorctj|||zkDddgtj}tj|||z kDddgtj}||z }|S)Nr)axisr)r count_nonzerofloat32rs rLrr sq$$ "889RPRPZPZM  e~8N'NOWY[]V^fhfpfp qF$v- rM n_per_sider:cdd|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].r|r{Nrr)rlinspacetilestackr)roffsetpoints_one_sidepoints_xpoints_ypointss rL_build_point_gridr's !j. !Fkk&!f*jAOwwtQw/*aAHwwq$w/!ZAH XXx* 4 < ?F6NA& MrMrrrrrPc `t|tr tdt|}t ||}g}t |dzD]-} t ||| zz } |jt| /t|||\} } t| ||| |||\} }tj| } | jtj} tj|g}tj|d}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 (Union[`numpy.ndarray`, `PIL.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 sample per crop. crop_n_points_downscale_factor (`int`, *optional*): The number of points-per-side sampled in layer n is scaled down by crop_n_points_downscale_factor**n. input_data_format (`str` or `ChannelDimension`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred. z.Only one image is allowed for crop generation.r|)rr{r|r )axesNrr)rGlistrirrrangerarr'_generate_per_layer_crops_generate_crop_imagesrarrayrrr ones_liker)rNrrrrrrPrw points_gridrn_pointsr layer_idxsrpoint_grid_per_croprs rLrr=s$>%IJJ 5 !E"5*;C+DUW`@abC   c "   gk * + + z !!YYs E)/E.cg}g}t|D]\} } | \} } } }t||}|tjk(r|| || | ddf}n|dd| || | f}|j |t ||}t j|ddddf}||| |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. Nr) rrrLASTrrrr7r0)rrNr9r;rrwrPrtotal_points_per_croprcrop_boxrKrLrightbottomrS cropped_imcropped_im_size points_scaler&normalized_pointss rLr6r6sN ,8 8#+ c5&4U$'+BTUVO&&~7GHN 99^ ++rMcrtj|tj}tj|tj}|\}}}}tj||||gg} t|jdk(rtj | d} tj || ztj}tj||dddf|d} tj||dddf|d} tjj| | } tj| dS)rdrr r|Nrrer) rrrrkr expand_dimscasttnprmr?rn reduce_any) rprQrqrf crop_box_tf orig_box_tfrKrLrr"rtrus rLrrs&&xrzzBK&&xrzzBKOD#q!  ! !D#tS#9": ;F 5;;1* GGEFNBJJ /E[[ D!G(<4aPNkk%T1W)=DqQOWW((/9IJN ==a 00rMcltj|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)`) rNrr*rrrhr) rnumelzerosrrr`aranger>r!rlr)rrr@rA in_heightrin_height_coords bottom_edges top_edgesin_widthin_width_coords right_edges left_edges empty_filterouts rLrrs" {{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 JrMc$tj|dk(r&tjg|jdddSt |}|dd\}}tj |d}|tj |dddfz}tj |d}|||zz}tj|d}tj |d\}} |tj |dddfz} tj | d\} } | ||zz} tj| d\} } | | k||kz} tj| || |gd}|tj| dz}tj|g|ddd}|S)aI 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 (`tf.Tensor` of shape `(batch, nb_mask, height, width)`) rNrr*rr) rr.rrr) reduce_maxr4 reduce_minr!rwr)rrr@rArrrrrrrrrrrs rLrrs  wwu~xx.%++cr*.A.// u E"#JMFE e"-I 288F#3D!G#<<==!1;L'&YJ*?? .R8I--B/KHa%q!99O]]??!C x=A !Q$1$ VUO?OPQ VUO6E>?RST AB<(3B-/!!Q$'1,1#8A;##%&)::funxXZ|O`O`Ob>b=ccc VUOv>? @ JrMc|j\}}}ttj|dd}|ddddf|ddddfz }tj|}g}t |D]}||dddf|k(dddfdz}t |dk(rA||dfdk(r|j||g||zgdn|j||gd||zgdl|dd|ddz } ||dfdk(rgndg} | |djjg| jjz||z|djjz gzz } |j||g| d |S)r)rr{r|rr|Nrrr) rr(rrwherer4rkrr'rrrs rLrrms !+ 0 0JjyA1EJ ae z!SbS&1 1DXXd^N C : @!.A"6!";?RST AB<(3B-/!!Q$'1,1# a[   % % ' (8>>+;+B+B+D DQVYabdYeYkYkYmYrYrYtHtGu u  VUOv>?@ JrMrlec|d\}}tj||zt}d}d}|dD]}|||||z||z }| }|j||}|j S)z/Compute a binary mask from an uncompressed RLE.r.rrFr)remptyrrr)rr@rAridxparitycounts rL _rle_to_maskrsKMFE 88FUN$ /D C FX"(S3; u  <<v &D >> rMct|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. rrpridxs iou_threshold)r&r rrrr rle_masksr mask_boxesamg_crops_nms_thresh keep_by_nmsrrrs rLrrs  [[))!, -* KK(J'23!13I3K(J*3 43\#  4E 4 *i 33 4 4s  A8A=c,tjj|j|t j |j d|}||}|Dcgc]}|| }}||}|Dcgc] }t|}}||||fScc}wcc}w)a Perform NMS (Non Maximum Suppression) on the outputs. Args: rle_masks (`tf.Tensor`): binary masks in the RLE format iou_scores (`tf.Tensor` of shape (nb_masks, 1)): iou_scores predicted by the model mask_boxes (`tf.Tensor`): The bounding boxes corresponding to segmentation masks amg_crops_nms_thresh (`float`, *optional*, defaults to 0.7): NMS threshold. rr)rrNcombined_non_max_suppressionr rrrrrs rLrrs((77  [[))!, -* 8KK(J'23!13I3K(J*3 43\#  4E 4 *i 33 4 4s  B 2B)F)rrrr|Nr)g4@)rr )rr)rr )rr)gffffff?)Vrr?copyr itertoolsrtypingrrrrr r r'rimage_processing_utilsr r rimage_transformsrrrr image_utilsrrrrrrrrrrrrutilsrr r!r"r#r$r%rtorch.nn.functionalr\r]rtorchvision.ops.boxesr& tensorflowrtensorflow.experimentalrytf_utilsr(r) get_loggerrrur+r rarrrr'r0r rr5r6rrrrrrrrrrr__all__rDrMrLrsW% ::UUXX    ##14/   H %{.*{.|~ufi{Ecf#"**[` jj9>sCxZZ>%%':;@D5E5E5E 5E c] 5E %-T#Y$7 5E c+;&; <=5E 4S ?DI %&5Ep"F_c1<8S 888149131C1,$1$.b-`>B d38n  4:4:  rM