Predict masks for the given input prompts, using the currently set image. Arguments: point_coords (np.ndarray or None): A

Compute the output size given input size and target long side length.

Calculates the image embeddings for the provided image, allowing masks to be predicted with the 'predict' method. Arguments:

Args: dim (int): Number of input channels. num_heads (int): Number of attention heads in each ViT block.

Positionally encode points that are normalized to [0,1].

Expects a numpy array of length 2 in the final dimension. Requires the original image size in (H, W) format.

Computes the stability score for a batch of masks. The stability score is the IoU between the binary masks obtained by thresholding the p

Returns the positional encoding used to encode point prompts, applied to a dense set of points the shape of the image encoding.

Resets the currently set image.

Calculates boxes in XYXY format around masks. Return [0,0,0,0] for an empty mask. For input shape C1xC2x...xHxW, the output shape is C1xC2x..

Positionally encode points that are not normalized to [0,1].

Get relative positional embeddings according to the relative positions of query and key sizes. Args: q_size (int): size of qu

Encodes masks to an uncompressed RLE, in the format expected by pycoco tools.

Remove padding and upscale masks to the original image size. Arguments: masks (torch.Tensor): Batched masks from the mask_

Predicts masks. See 'forward' for more details.

Predict masks for the given input prompts, using the currently set image. Input prompts are batched torch tensors and are expected to

Normalize pixel values and pad to a square input.

Removes small disconnected regions and holes in a mask. Returns the mask and an indicator of if the mask has been modified.

Compute a binary mask from an uncompressed RLE.

Encodes prompts for input to SAM's mask decoder. Arguments: embed_dim (int): The prompts' embedding dimension im

Embeds box prompts.

Embeds mask inputs.

Embeds point prompts.

Gets the batch size of the output given the batch size of the input prompts.

Calculate decomposed Relative Positional Embeddings from :paper:`mvitv2`. https://github.com/facebookresearch/mvit/blob/19786631e330df9f3622e

Expects a numpy array shape Bx4. Requires the original image size in (H, W) format.

Expects a torch tensor with length 2 in the last dimension. Requires the original image size in (H, W) format.

Expects a numpy array with shape HxWxC in uint8 format.

Generates point grids for all crop layers.

Generates a 2D grid of points evenly spaced in [0,1]x[0,1].

Generates a list of crop boxes of different sizes. Each layer has (2**i)**2 boxes for the ith layer.

Returns the image embeddings for the currently set image, with shape 1xCxHxW, where C is the embedding dimension and (H,W) are

Filter masks at the edge of a crop, but not at the edge of the original image.

Removes small disconnected regions and holes in masks, then reruns box NMS to remove any new duplicates. Edits mask_data in

Calculates the image embeddings for the provided image, allowing masks to be predicted with the 'predict' method. Expects the input

Partition into non-overlapping windows with padding if needed. Args: x (tensor): input tokens with [B, H, W, C]. window_size

Window unpartition into original sequences and removing padding. Args: windows (tensor): input tokens with [B * num_windows, window_s

Uses SAM to calculate the image embedding for an image, and then allow repeated, efficient mask prediction given prompts. Ar

Using a SAM model, generates masks for the entire image. Generates a grid of point prompts over the image, then filters low q

Predicts masks given an image and prompt embeddings, using a transformer architecture. Arguments: transformer_dim

Args: img_size (int): Input image size. patch_size (int): Patch size. in_chans (int): Number of input ima

Args: dim (int): Number of input channels. num_heads (int): Number of attention heads. qkv_bias (bool):

Args: kernel_size (Tuple): kernel size of the projection layer. stride (Tuple): stride of the projection layer.

A transformer decoder that attends to an input image using queries whose positional embedding is supplied. Args: d

A transformer block with four layers: (1) self-attention of sparse inputs, (2) cross attention of sparse inputs to dense inputs, (3)

SAM predicts object masks from an image and input prompts. Arguments: image_encoder (ImageEncoderViT): The backbone used t

Expects a torch tensor with shape Bx4. Requires the original image size in (H, W) format.

Expects batched images with shape BxCxHxW and float format. This transformation may not exactly match apply_image. apply_image is

Predict masks given image and prompt embeddings. Arguments: image_embeddings (torch.Tensor): the embeddings from the image