Duplicate from An-619/FastSAM

Co-authored-by: Yongqi An <[email protected]>

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,47 @@
+---
+title: FastSAM
+emoji: 🐠
+colorFrom: pink
+colorTo: indigo
+sdk: gradio
+sdk_version: 3.35.2
+app_file: app.py
+pinned: false
+license: apache-2.0
+duplicated_from: An-619/FastSAM
+---
+
+# Fast Segment Anything
+
+Official PyTorch Implementation of the <a href="https://github.com/CASIA-IVA-Lab/FastSAM">.
+
+The **Fast Segment Anything Model(FastSAM)** is a CNN Segment Anything Model trained by only 2% of the SA-1B dataset published by SAM authors. The FastSAM achieve a comparable performance with
+the SAM method at **50× higher run-time speed**.
+
+
+## License
+
+The model is licensed under the [Apache 2.0 license](LICENSE).
+
+
+## Acknowledgement
+
+- [Segment Anything](https://segment-anything.com/) provides the SA-1B dataset and the base codes.
+- [YOLOv8](https://github.com/ultralytics/ultralytics) provides codes and pre-trained models.
+- [YOLACT](https://arxiv.org/abs/2112.10003) provides powerful instance segmentation method.
+- [Grounded-Segment-Anything](https://huggingface.co/spaces/yizhangliu/Grounded-Segment-Anything) provides a useful web demo template.
+
+## Citing FastSAM
+
+If you find this project useful for your research, please consider citing the following BibTeX entry.
+
+```
+@misc{zhao2023fast,
+      title={Fast Segment Anything}, 
+      author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang},
+      year={2023},
+      eprint={2306.12156},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV}
+}
+```

app.py

@@ -0,0 +1,289 @@
+from ultralytics import YOLO
+import gradio as gr
+import torch
+from tools import fast_process, format_results, box_prompt, point_prompt
+from PIL import ImageDraw
+import numpy as np
+
+# Load the pre-trained model
+model = YOLO('checkpoints/FastSAM.pt')
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+# Description
+title = "<center><strong><font size='8'>🏃 Fast Segment Anything 🤗</font></strong></center>"
+
+news = """ # 📖 News
+
+        🔥 2023/06/24: Add the 'Advanced options" in Everything mode to get a more detailed adjustment.
+        
+        🔥 2023/06/26: Support the points mode. (Better and faster interaction will come soon!)
+        
+        """  
+
+description_e = """This is a demo on Github project 🏃 [Fast Segment Anything Model](https://github.com/CASIA-IVA-Lab/FastSAM).
+                
+                🎯 Upload an Image, segment it with Fast Segment Anything (Everything mode). The other modes will come soon.
+                
+                ⌛️ It takes about 6~ seconds to generate segment results. The concurrency_count of queue is 1, please wait for a moment when it is crowded.
+                
+                🚀 To get faster results, you can use a smaller input size and leave high_visual_quality unchecked.
+                
+                📣 You can also obtain the segmentation results of any Image through this Colab: [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing)
+                
+                😚 A huge thanks goes out to the @HuggingFace Team for supporting us with GPU grant.
+                
+                🏠 Check out our [Model Card 🏃](https://huggingface.co/An-619/FastSAM)
+                
+              """
+
+description_p = """This is a demo on Github project 🏃 [Fast Segment Anything Model](https://github.com/CASIA-IVA-Lab/FastSAM).
+                
+                🎯 Upload an Image, add points and segment it with Fast Segment Anything (Points mode).
+                
+                ⌛️ It takes about 6~ seconds to generate segment results. The concurrency_count of queue is 1, please wait for a moment when it is crowded.
+                
+                🚀 To get faster results, you can use a smaller input size and leave high_visual_quality unchecked.
+                
+                📣 You can also obtain the segmentation results of any Image through this Colab: [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing)
+                
+                😚 A huge thanks goes out to the @HuggingFace Team for supporting us with GPU grant.
+                
+                🏠 Check out our [Model Card 🏃](https://huggingface.co/An-619/FastSAM)
+                
+              """
+
+examples = [["assets/sa_8776.jpg"], ["assets/sa_414.jpg"], ["assets/sa_1309.jpg"], ["assets/sa_11025.jpg"],
+            ["assets/sa_561.jpg"], ["assets/sa_192.jpg"], ["assets/sa_10039.jpg"], ["assets/sa_862.jpg"]]
+
+default_example = examples[0]
+
+css = "h1 { text-align: center } .about { text-align: justify; padding-left: 10%; padding-right: 10%; }"
+
+
+def segment_everything(
+    input,
+    input_size=1024, 
+    iou_threshold=0.7,
+    conf_threshold=0.25,
+    better_quality=False,
+    withContours=True,
+    use_retina=True,
+    mask_random_color=True,
+    ):
+    input_size = int(input_size)  # 确保 imgsz 是整数
+
+    # Thanks for the suggestion by hysts in HuggingFace.
+    w, h = input.size
+    scale = input_size / max(w, h)
+    new_w = int(w * scale)
+    new_h = int(h * scale)
+    input = input.resize((new_w, new_h))
+
+    results = model(input,
+                    device=device,
+                    retina_masks=True,
+                    iou=iou_threshold,
+                    conf=conf_threshold,
+                    imgsz=input_size,)
+    
+    fig = fast_process(annotations=results[0].masks.data,
+                        image=input,
+                        device=device,
+                        scale=(1024 // input_size),
+                        better_quality=better_quality,
+                        mask_random_color=mask_random_color,
+                        bbox=None,
+                        use_retina=use_retina,
+                        withContours=withContours,)
+    return fig
+
+def segment_with_points(
+    input,
+    input_size=1024, 
+    iou_threshold=0.7,
+    conf_threshold=0.25,
+    better_quality=False,
+    withContours=True,
+    mask_random_color=True,
+    use_retina=True,
+    ):    
+    global global_points
+    global global_point_label
+    
+    input_size = int(input_size)  # 确保 imgsz 是整数
+    # Thanks for the suggestion by hysts in HuggingFace.
+    w, h = input.size
+    scale = input_size / max(w, h)
+    new_w = int(w * scale)
+    new_h = int(h * scale)
+    input = input.resize((new_w, new_h))
+    
+    scaled_points = [[int(x * scale) for x in point] for point in global_points]
+
+    results = model(input,
+                    device=device,
+                    retina_masks=True,
+                    iou=iou_threshold,
+                    conf=conf_threshold,
+                    imgsz=input_size,)
+    
+    results = format_results(results[0], 0)
+    
+    annotations, _ = point_prompt(results, scaled_points, global_point_label, new_h, new_w)
+    annotations = np.array([annotations])
+        
+    fig = fast_process(annotations=annotations,
+                        image=input,
+                        device=device,
+                        scale=(1024 // input_size),
+                        better_quality=better_quality,
+                        mask_random_color=mask_random_color,
+                        bbox=None,
+                        use_retina=use_retina,
+                        withContours=withContours,)
+    global_points = []
+    global_point_label = []
+    return fig, None
+
+def get_points_with_draw(image, label, evt: gr.SelectData):
+    x, y = evt.index[0], evt.index[1]
+    point_radius, point_color = 15, (255, 255, 0) if label == 'Add Mask' else (255, 0, 255)
+    global global_points
+    global global_point_label
+    print((x, y))
+    global_points.append([x, y])
+    global_point_label.append(1 if label == 'Add Mask' else 0)
+    
+    # 创建一个可以在图像上绘图的对象
+    draw = ImageDraw.Draw(image)
+    draw.ellipse([(x - point_radius, y - point_radius), (x + point_radius, y + point_radius)], fill=point_color)
+    return image
+    
+
+# input_size=1024
+# high_quality_visual=True
+# inp = 'assets/sa_192.jpg'
+# input = Image.open(inp)
+# device = 'cuda' if torch.cuda.is_available() else 'cpu'
+# input_size = int(input_size)  # 确保 imgsz 是整数
+# results = model(input, device=device, retina_masks=True, iou=0.7, conf=0.25, imgsz=input_size)
+# pil_image = fast_process(annotations=results[0].masks.data,
+#                             image=input, high_quality=high_quality_visual, device=device)
+
+cond_img_e = gr.Image(label="Input", value=default_example[0], type='pil')
+cond_img_p = gr.Image(label="Input with points", value=default_example[0], type='pil')
+
+segm_img_e = gr.Image(label="Segmented Image", interactive=False, type='pil')
+segm_img_p = gr.Image(label="Segmented Image with points", interactive=False, type='pil')
+
+global_points = []
+global_point_label = [] # TODO:Clear points each image
+
+input_size_slider = gr.components.Slider(minimum=512,
+                                         maximum=1024,
+                                         value=1024,
+                                         step=64,
+                                         label='Input_size',
+                                         info='Our model was trained on a size of 1024')
+
+with gr.Blocks(css=css, title='Fast Segment Anything') as demo:
+    with gr.Row():
+            with gr.Column(scale=1):
+                # Title
+                gr.Markdown(title)
+        
+            with gr.Column(scale=1):
+                # News
+                gr.Markdown(news)
+                
+    with gr.Tab("Everything mode"):
+        # Images
+        with gr.Row(variant="panel"):
+            with gr.Column(scale=1):
+                cond_img_e.render()
+
+            with gr.Column(scale=1):
+                segm_img_e.render()
+
+        # Submit & Clear
+        with gr.Row():
+            with gr.Column():
+                input_size_slider.render()
+
+                with gr.Row():
+                    contour_check = gr.Checkbox(value=True, label='withContours', info='draw the edges of the masks')
+
+                    with gr.Column():
+                        segment_btn_e = gr.Button("Segment Everything", variant='primary')
+                        clear_btn_e = gr.Button("Clear", variant="secondary")
+
+                gr.Markdown("Try some of the examples below ⬇️")
+                gr.Examples(examples=examples,
+                            inputs=[cond_img_e],
+                            outputs=segm_img_e,
+                            fn=segment_everything,
+                            cache_examples=True,
+                            examples_per_page=4)
+
+            with gr.Column():
+                with gr.Accordion("Advanced options", open=False):
+                    iou_threshold = gr.Slider(0.1, 0.9, 0.7, step=0.1, label='iou', info='iou threshold for filtering the annotations')
+                    conf_threshold = gr.Slider(0.1, 0.9, 0.25, step=0.05, label='conf', info='object confidence threshold')
+                    with gr.Row():
+                        mor_check = gr.Checkbox(value=False, label='better_visual_quality', info='better quality using morphologyEx')
+                        with gr.Column():
+                            retina_check = gr.Checkbox(value=True, label='use_retina', info='draw high-resolution segmentation masks')
+                    
+                # Description
+                gr.Markdown(description_e)
+
+    with gr.Tab("Points mode"):
+        # Images
+        with gr.Row(variant="panel"):
+            with gr.Column(scale=1):
+                cond_img_p.render()
+
+            with gr.Column(scale=1):
+                segm_img_p.render()
+                
+        # Submit & Clear
+        with gr.Row():
+            with gr.Column():
+                with gr.Row():
+                    add_or_remove = gr.Radio(["Add Mask", "Remove Area"], value="Add Mask", label="Point_label (foreground/background)")
+
+                    with gr.Column():
+                        segment_btn_p = gr.Button("Segment with points prompt", variant='primary')
+                        clear_btn_p = gr.Button("Clear points", variant='secondary')
+
+                gr.Markdown("Try some of the examples below ⬇️")
+                gr.Examples(examples=examples,
+                            inputs=[cond_img_p],
+                            outputs=segm_img_p,
+                            fn=segment_with_points,
+                            # cache_examples=True,
+                            examples_per_page=4)
+
+            with gr.Column():
+                # Description
+                gr.Markdown(description_p)
+        
+    cond_img_p.select(get_points_with_draw, [cond_img_p, add_or_remove], cond_img_p)
+
+    segment_btn_e.click(segment_everything,
+                    inputs=[cond_img_e, input_size_slider, iou_threshold, conf_threshold, mor_check, contour_check, retina_check],
+                    outputs=segm_img_e)
+    
+    segment_btn_p.click(segment_with_points,
+                    inputs=[cond_img_p],
+                    outputs=[segm_img_p, cond_img_p])
+    
+    def clear():
+        return None, None
+    
+    clear_btn_e.click(clear, outputs=[cond_img_e, segm_img_e])
+    clear_btn_p.click(clear, outputs=[cond_img_p, segm_img_p])
+
+demo.queue()
+demo.launch()

app_debug.py

@@ -0,0 +1,287 @@
+from ultralytics import YOLO
+import numpy as np
+import matplotlib.pyplot as plt
+import gradio as gr
+import cv2
+import torch
+from PIL import Image
+
+# Load the pre-trained model
+model = YOLO('checkpoints/FastSAM.pt')
+
+# Description
+title = "<center><strong><font size='8'>🏃 Fast Segment Anything 🤗</font></strong></center>"
+
+description = """This is a demo on Github project 🏃 [Fast Segment Anything Model](https://github.com/CASIA-IVA-Lab/FastSAM).
+                
+                🎯 Upload an Image, segment it with Fast Segment Anything (Everything mode). The other modes will come soon.
+                
+                ⌛️ It takes about 4~ seconds to generate segment results. The concurrency_count of queue is 1, please wait for a moment when it is crowded.
+                
+                🚀 To get faster results, you can use a smaller input size and leave high_visual_quality unchecked.
+                
+                📣 You can also obtain the segmentation results of any Image through this Colab: [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing)
+                
+                😚 A huge thanks goes out to the @HuggingFace Team for supporting us with GPU grant.
+                
+                🏠 Check out our [Model Card 🏃](https://huggingface.co/An-619/FastSAM)
+                
+              """
+
+examples = [["assets/sa_8776.jpg"], ["assets/sa_414.jpg"],
+            ["assets/sa_1309.jpg"], ["assets/sa_11025.jpg"],
+            ["assets/sa_561.jpg"], ["assets/sa_192.jpg"],
+            ["assets/sa_10039.jpg"], ["assets/sa_862.jpg"]]
+
+default_example = examples[0]
+
+css = "h1 { text-align: center } .about { text-align: justify; padding-left: 10%; padding-right: 10%; }"
+
+def fast_process(annotations, image, high_quality, device, scale):
+    if isinstance(annotations[0],dict):
+        annotations = [annotation['segmentation'] for annotation in annotations]
+
+    original_h = image.height
+    original_w = image.width
+    if high_quality == True:
+        if isinstance(annotations[0],torch.Tensor):
+            annotations = np.array(annotations.cpu())
+        for i, mask in enumerate(annotations):
+            mask = cv2.morphologyEx(mask.astype(np.uint8), cv2.MORPH_CLOSE, np.ones((3, 3), np.uint8))
+            annotations[i] = cv2.morphologyEx(mask.astype(np.uint8), cv2.MORPH_OPEN, np.ones((8, 8), np.uint8))
+    if device == 'cpu':
+        annotations = np.array(annotations)
+        inner_mask = fast_show_mask(annotations,
+                       plt.gca(),
+                       bbox=None,
+                       points=None,
+                       pointlabel=None,
+                       retinamask=True,
+                       target_height=original_h,
+                       target_width=original_w)
+    else:
+        if isinstance(annotations[0],np.ndarray):
+            annotations = torch.from_numpy(annotations)
+        inner_mask = fast_show_mask_gpu(annotations,
+                           plt.gca(),
+                           bbox=None,
+                           points=None,
+                           pointlabel=None)
+    if isinstance(annotations, torch.Tensor):
+        annotations = annotations.cpu().numpy()
+    
+    if high_quality:
+        contour_all = []
+        temp = np.zeros((original_h, original_w,1))
+        for i, mask in enumerate(annotations):
+            if type(mask) == dict:
+                mask = mask['segmentation']
+            annotation = mask.astype(np.uint8)
+            contours, _ = cv2.findContours(annotation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+            for contour in contours:
+                contour_all.append(contour)
+        cv2.drawContours(temp, contour_all, -1, (255, 255, 255), 2 // scale)
+        color = np.array([0 / 255, 0 / 255, 255 / 255, 0.9])
+        contour_mask = temp / 255 * color.reshape(1, 1, -1)
+    image = image.convert('RGBA')
+    
+    overlay_inner = Image.fromarray((inner_mask * 255).astype(np.uint8), 'RGBA')
+    image.paste(overlay_inner, (0, 0), overlay_inner)
+    
+    if high_quality:
+        overlay_contour = Image.fromarray((contour_mask * 255).astype(np.uint8), 'RGBA')
+        image.paste(overlay_contour, (0, 0), overlay_contour)
+        
+    return image
+
+#   CPU post process
+def fast_show_mask(annotation, ax, bbox=None, 
+                   points=None, pointlabel=None,
+                   retinamask=True, target_height=960,
+                   target_width=960):
+    msak_sum = annotation.shape[0]
+    height = annotation.shape[1]
+    weight = annotation.shape[2]
+    # 将annotation 按照面积 排序
+    areas = np.sum(annotation, axis=(1, 2))
+    sorted_indices = np.argsort(areas)[::1]
+    annotation = annotation[sorted_indices]
+
+    index = (annotation != 0).argmax(axis=0)
+    color = np.random.random((msak_sum,1,1,3))
+    transparency = np.ones((msak_sum,1,1,1)) * 0.6
+    visual = np.concatenate([color,transparency],axis=-1)
+    mask_image = np.expand_dims(annotation,-1) * visual
+
+    mask = np.zeros((height,weight,4))
+
+    h_indices, w_indices = np.meshgrid(np.arange(height), np.arange(weight), indexing='ij')
+    indices = (index[h_indices, w_indices], h_indices, w_indices, slice(None))
+    # 使用向量化索引更新show的值
+    mask[h_indices, w_indices, :] = mask_image[indices]
+    if bbox is not None:
+        x1, y1, x2, y2 = bbox
+        ax.add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor='b', linewidth=1))
+    # draw point
+    if points is not None:
+        plt.scatter([point[0] for i, point in enumerate(points) if pointlabel[i]==1], [point[1] for i, point in enumerate(points) if pointlabel[i]==1], s=20, c='y')
+        plt.scatter([point[0] for i, point in enumerate(points) if pointlabel[i]==0], [point[1] for i, point in enumerate(points) if pointlabel[i]==0], s=20, c='m')
+    
+    if retinamask==False:
+        mask = cv2.resize(mask, (target_width, target_height), interpolation=cv2.INTER_NEAREST)
+    
+    return mask
+
+
+def fast_show_mask_gpu(annotation, ax,
+                       bbox=None, points=None, 
+                       pointlabel=None):
+    msak_sum = annotation.shape[0]
+    height = annotation.shape[1]
+    weight = annotation.shape[2]
+    areas = torch.sum(annotation, dim=(1, 2))
+    sorted_indices = torch.argsort(areas, descending=False)
+    annotation = annotation[sorted_indices]
+    # 找每个位置第一个非零值下标
+    index = (annotation != 0).to(torch.long).argmax(dim=0)
+    color = torch.rand((msak_sum,1,1,3)).to(annotation.device)
+    transparency = torch.ones((msak_sum,1,1,1)).to(annotation.device) * 0.6
+    visual = torch.cat([color,transparency],dim=-1)
+    mask_image = torch.unsqueeze(annotation,-1) * visual
+    # 按index取数，index指每个位置选哪个batch的数，把mask_image转成一个batch的形式
+    mask = torch.zeros((height,weight,4)).to(annotation.device)
+    h_indices, w_indices = torch.meshgrid(torch.arange(height), torch.arange(weight))
+    indices = (index[h_indices, w_indices], h_indices, w_indices, slice(None))
+    # 使用向量化索引更新show的值
+    mask[h_indices, w_indices, :] = mask_image[indices]
+    mask_cpu = mask.cpu().numpy()
+    if bbox is not None:
+        x1, y1, x2, y2 = bbox
+        ax.add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor='b', linewidth=1))
+    # draw point
+    if points is not None:
+        plt.scatter([point[0] for i, point in enumerate(points) if pointlabel[i]==1], [point[1] for i, point in enumerate(points) if pointlabel[i]==1], s=20, c='y')
+        plt.scatter([point[0] for i, point in enumerate(points) if pointlabel[i]==0], [point[1] for i, point in enumerate(points) if pointlabel[i]==0], s=20, c='m')
+    return mask_cpu
+
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+def segment_image(input, evt: gr.SelectData=None, input_size=1024, high_visual_quality=True, iou_threshold=0.7, conf_threshold=0.25):
+    point = (evt.index[0],evt.index[1])
+    input_size = int(input_size)  # 确保 imgsz 是整数
+    
+    # Thanks for the suggestion by hysts in HuggingFace.
+    w, h = input.size
+    scale = input_size / max(w, h)
+    new_w = int(w * scale)
+    new_h = int(h * scale)
+    input = input.resize((new_w, new_h))
+    
+    results = model(input, device=device, retina_masks=True, iou=iou_threshold, conf=conf_threshold, imgsz=input_size)
+    fig = fast_process(annotations=results[0].masks.data,
+                        image=input, high_quality=high_visual_quality,
+                        device=device, scale=(1024 // input_size),
+                        points=)
+    return fig
+
+# input_size=1024
+# high_quality_visual=True
+# inp = 'assets/sa_192.jpg'
+# input = Image.open(inp)
+# device = 'cuda' if torch.cuda.is_available() else 'cpu'
+# input_size = int(input_size)  # 确保 imgsz 是整数
+# results = model(input, device=device, retina_masks=True, iou=0.7, conf=0.25, imgsz=input_size)
+# pil_image = fast_process(annotations=results[0].masks.data,
+#                             image=input, high_quality=high_quality_visual, device=device)
+
+cond_img = gr.Image(label="Input", value=default_example[0], type='pil')
+
+segm_img = gr.Image(label="Segmented Image", interactive=False, type='pil')
+
+input_size_slider = gr.components.Slider(minimum=512, maximum=1024, value=1024, step=64, label='Input_size (Our model was trained on a size of 1024)')
+
+with gr.Blocks(css=css, title='Fast Segment Anything') as demo:
+    with gr.Row():
+        # Title
+        gr.Markdown(title)
+    #     # # Description
+    #     # gr.Markdown(description)
+        
+    # Images
+    with gr.Row(variant="panel"):
+        with gr.Column(scale=1):
+            cond_img.render()
+            
+        with gr.Column(scale=1):
+            segm_img.render()
+    
+    # Submit & Clear
+    with gr.Row():
+        with gr.Column():
+            input_size_slider.render()
+            
+            with gr.Row():
+                vis_check = gr.Checkbox(value=True, label='high_visual_quality')
+                
+                with gr.Column():
+                    segment_btn = gr.Button("Segment Anything", variant='primary')
+                    
+                # with gr.Column():
+                    # clear_btn = gr.Button("Clear", variant="primary")
+            
+            gr.Markdown("Try some of the examples below ⬇️")
+            gr.Examples(examples=examples,
+                        inputs=[cond_img],
+                        outputs=segm_img,
+                        fn=segment_image,
+                        cache_examples=True,
+                        examples_per_page=4)
+            # gr.Markdown("Try some of the examples below ⬇️")
+            # gr.Examples(examples=examples,
+            #             inputs=[cond_img, input_size_slider, vis_check, iou_threshold, conf_threshold],
+            #             outputs=output,
+            #             fn=segment_image,
+            #             examples_per_page=4)
+
+        with gr.Column():
+            with gr.Accordion("Advanced options", open=False):
+                iou_threshold = gr.Slider(0.1, 0.9, 0.7, step=0.1, label='iou_threshold')
+                conf_threshold = gr.Slider(0.1, 0.9, 0.25, step=0.05, label='conf_threshold')
+                
+            # Description
+            gr.Markdown(description)
+    
+    cond_img.select(segment_image, [], input_img)
+    
+    segment_btn.click(segment_image,
+                     inputs=[cond_img, input_size_slider, vis_check, iou_threshold, conf_threshold],
+                     outputs=segm_img)  
+    
+    # def clear():
+        # return None, None
+
+    # clear_btn.click(fn=clear, inputs=None, outputs=None)
+
+demo.queue()
+demo.launch()
+
+# app_interface = gr.Interface(fn=predict,
+#                     inputs=[gr.Image(type='pil'),
+#                             gr.components.Slider(minimum=512, maximum=1024, value=1024, step=64, label='input_size'),
+#                             gr.components.Checkbox(value=True, label='high_visual_quality')],
+#                     # outputs=['plot'],
+#                     outputs=gr.Image(type='pil'),
+#                     # examples=[["assets/sa_8776.jpg"]],
+#                     # #    ["assets/sa_1309.jpg", 1024]],
+#                     examples=[["assets/sa_192.jpg"], ["assets/sa_414.jpg"],
+#                               ["assets/sa_561.jpg"], ["assets/sa_862.jpg"],
+#                               ["assets/sa_1309.jpg"], ["assets/sa_8776.jpg"],
+#                               ["assets/sa_10039.jpg"], ["assets/sa_11025.jpg"],],
+#                     cache_examples=True,
+#                     title="Fast Segment Anything (Everything mode)"
+#                     )
+
+
+# app_interface.queue(concurrency_count=1, max_size=20)
+# app_interface.launch()

checkpoints/FastSAM.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0be4e7ddbe4c15333d15a859c676d053c486d0a746a3be6a7a9790d52a9b6d7
+size 144943063

requirements.txt

@@ -0,0 +1,18 @@
+# Base-----------------------------------
+matplotlib==3.2.2
+numpy
+opencv-python
+# Pillow>=7.1.2
+# PyYAML>=5.3.1
+# requests>=2.23.0
+# scipy>=1.4.1
+# torch
+# torchvision
+# tqdm>=4.64.0
+
+# pandas>=1.1.4
+# seaborn>=0.11.0
+
+# Ultralytics-----------------------------------
+ultralytics==8.0.121
+

tools.py

@@ -0,0 +1,361 @@
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+import cv2
+import torch
+# import clip
+
+
+def convert_box_xywh_to_xyxy(box):
+    x1 = box[0]
+    y1 = box[1]
+    x2 = box[0] + box[2]
+    y2 = box[1] + box[3]
+    return [x1, y1, x2, y2]
+
+
+def segment_image(image, bbox):
+    image_array = np.array(image)
+    segmented_image_array = np.zeros_like(image_array)
+    x1, y1, x2, y2 = bbox
+    segmented_image_array[y1:y2, x1:x2] = image_array[y1:y2, x1:x2]
+    segmented_image = Image.fromarray(segmented_image_array)
+    black_image = Image.new("RGB", image.size, (255, 255, 255))
+    # transparency_mask = np.zeros_like((), dtype=np.uint8)
+    transparency_mask = np.zeros(
+        (image_array.shape[0], image_array.shape[1]), dtype=np.uint8
+    )
+    transparency_mask[y1:y2, x1:x2] = 255
+    transparency_mask_image = Image.fromarray(transparency_mask, mode="L")
+    black_image.paste(segmented_image, mask=transparency_mask_image)
+    return black_image
+
+
+def format_results(result, filter=0):
+    annotations = []
+    n = len(result.masks.data)
+    for i in range(n):
+        annotation = {}
+        mask = result.masks.data[i] == 1.0
+
+        if torch.sum(mask) < filter:
+            continue
+        annotation["id"] = i
+        annotation["segmentation"] = mask.cpu().numpy()
+        annotation["bbox"] = result.boxes.data[i]
+        annotation["score"] = result.boxes.conf[i]
+        annotation["area"] = annotation["segmentation"].sum()
+        annotations.append(annotation)
+    return annotations
+
+
+def filter_masks(annotations):  # filte the overlap mask
+    annotations.sort(key=lambda x: x["area"], reverse=True)
+    to_remove = set()
+    for i in range(0, len(annotations)):
+        a = annotations[i]
+        for j in range(i + 1, len(annotations)):
+            b = annotations[j]
+            if i != j and j not in to_remove:
+                # check if
+                if b["area"] < a["area"]:
+                    if (a["segmentation"] & b["segmentation"]).sum() / b[
+                        "segmentation"
+                    ].sum() > 0.8:
+                        to_remove.add(j)
+
+    return [a for i, a in enumerate(annotations) if i not in to_remove], to_remove
+
+
+def get_bbox_from_mask(mask):
+    mask = mask.astype(np.uint8)
+    contours, hierarchy = cv2.findContours(
+        mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+    )
+    x1, y1, w, h = cv2.boundingRect(contours[0])
+    x2, y2 = x1 + w, y1 + h
+    if len(contours) > 1:
+        for b in contours:
+            x_t, y_t, w_t, h_t = cv2.boundingRect(b)
+            # 将多个bbox合并成一个
+            x1 = min(x1, x_t)
+            y1 = min(y1, y_t)
+            x2 = max(x2, x_t + w_t)
+            y2 = max(y2, y_t + h_t)
+        h = y2 - y1
+        w = x2 - x1
+    return [x1, y1, x2, y2]
+
+def fast_process(
+    annotations,
+    image,
+    device,
+    scale,
+    better_quality=False,
+    mask_random_color=True,
+    bbox=None,
+    use_retina=True,
+    withContours=True,
+    ):
+    if isinstance(annotations[0], dict):
+        annotations = [annotation['segmentation'] for annotation in annotations]
+
+    original_h = image.height
+    original_w = image.width
+    if better_quality:
+        if isinstance(annotations[0], torch.Tensor):
+            annotations = np.array(annotations.cpu())
+        for i, mask in enumerate(annotations):
+            mask = cv2.morphologyEx(mask.astype(np.uint8), cv2.MORPH_CLOSE, np.ones((3, 3), np.uint8))
+            annotations[i] = cv2.morphologyEx(mask.astype(np.uint8), cv2.MORPH_OPEN, np.ones((8, 8), np.uint8))
+    if device == 'cpu':
+        annotations = np.array(annotations)
+        inner_mask = fast_show_mask(
+            annotations,
+            plt.gca(),
+            random_color=mask_random_color,
+            bbox=bbox,
+            retinamask=use_retina,
+            target_height=original_h,
+            target_width=original_w,
+        )
+    else:
+        if isinstance(annotations[0], np.ndarray):
+            annotations = torch.from_numpy(annotations)
+        inner_mask = fast_show_mask_gpu(
+            annotations,
+            plt.gca(),
+            random_color=mask_random_color,
+            bbox=bbox,
+            retinamask=use_retina,
+            target_height=original_h,
+            target_width=original_w,
+        )
+    if isinstance(annotations, torch.Tensor):
+        annotations = annotations.cpu().numpy()
+
+    if withContours:
+        contour_all = []
+        temp = np.zeros((original_h, original_w, 1))
+        for i, mask in enumerate(annotations):
+            if type(mask) == dict:
+                mask = mask['segmentation']
+            annotation = mask.astype(np.uint8)
+            if use_retina == False:
+                annotation = cv2.resize(
+                    annotation,
+                    (original_w, original_h),
+                    interpolation=cv2.INTER_NEAREST,
+                )
+            contours, _ = cv2.findContours(annotation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+            for contour in contours:
+                contour_all.append(contour)
+        cv2.drawContours(temp, contour_all, -1, (255, 255, 255), 2 // scale)
+        color = np.array([0 / 255, 0 / 255, 255 / 255, 0.9])
+        contour_mask = temp / 255 * color.reshape(1, 1, -1)
+
+    image = image.convert('RGBA')
+    overlay_inner = Image.fromarray((inner_mask * 255).astype(np.uint8), 'RGBA')
+    image.paste(overlay_inner, (0, 0), overlay_inner)
+
+    if withContours:
+        overlay_contour = Image.fromarray((contour_mask * 255).astype(np.uint8), 'RGBA')
+        image.paste(overlay_contour, (0, 0), overlay_contour)
+
+    return image
+
+
+#   CPU post process
+def fast_show_mask(
+    annotation,
+    ax,
+    random_color=False,
+    bbox=None,
+    retinamask=True,
+    target_height=960,
+    target_width=960,
+):
+    mask_sum = annotation.shape[0]
+    height = annotation.shape[1]
+    weight = annotation.shape[2]
+    # 将annotation 按照面积 排序
+    areas = np.sum(annotation, axis=(1, 2))
+    sorted_indices = np.argsort(areas)[::1]
+    annotation = annotation[sorted_indices]
+
+    index = (annotation != 0).argmax(axis=0)
+    if random_color == True:
+        color = np.random.random((mask_sum, 1, 1, 3))
+    else:
+        color = np.ones((mask_sum, 1, 1, 3)) * np.array([30 / 255, 144 / 255, 255 / 255])
+    transparency = np.ones((mask_sum, 1, 1, 1)) * 0.6
+    visual = np.concatenate([color, transparency], axis=-1)
+    mask_image = np.expand_dims(annotation, -1) * visual
+
+    mask = np.zeros((height, weight, 4))
+
+    h_indices, w_indices = np.meshgrid(np.arange(height), np.arange(weight), indexing='ij')
+    indices = (index[h_indices, w_indices], h_indices, w_indices, slice(None))
+
+    mask[h_indices, w_indices, :] = mask_image[indices]
+    if bbox is not None:
+        x1, y1, x2, y2 = bbox
+        ax.add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor='b', linewidth=1))
+
+    if retinamask == False:
+        mask = cv2.resize(mask, (target_width, target_height), interpolation=cv2.INTER_NEAREST)
+
+    return mask
+
+
+def fast_show_mask_gpu(
+    annotation,
+    ax,
+    random_color=False,
+    bbox=None,
+    retinamask=True,
+    target_height=960,
+    target_width=960,
+):
+    device = annotation.device
+    mask_sum = annotation.shape[0]
+    height = annotation.shape[1]
+    weight = annotation.shape[2]
+    areas = torch.sum(annotation, dim=(1, 2))
+    sorted_indices = torch.argsort(areas, descending=False)
+    annotation = annotation[sorted_indices]
+    # 找每个位置第一个非零值下标
+    index = (annotation != 0).to(torch.long).argmax(dim=0)
+    if random_color == True:
+        color = torch.rand((mask_sum, 1, 1, 3)).to(device)
+    else:
+        color = torch.ones((mask_sum, 1, 1, 3)).to(device) * torch.tensor(
+            [30 / 255, 144 / 255, 255 / 255]
+        ).to(device)
+    transparency = torch.ones((mask_sum, 1, 1, 1)).to(device) * 0.6
+    visual = torch.cat([color, transparency], dim=-1)
+    mask_image = torch.unsqueeze(annotation, -1) * visual
+    # 按index取数，index指每个位置选哪个batch的数，把mask_image转成一个batch的形式
+    mask = torch.zeros((height, weight, 4)).to(device)
+    h_indices, w_indices = torch.meshgrid(torch.arange(height), torch.arange(weight))
+    indices = (index[h_indices, w_indices], h_indices, w_indices, slice(None))
+    # 使用向量化索引更新show的值
+    mask[h_indices, w_indices, :] = mask_image[indices]
+    mask_cpu = mask.cpu().numpy()
+    if bbox is not None:
+        x1, y1, x2, y2 = bbox
+        ax.add_patch(
+            plt.Rectangle(
+                (x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor="b", linewidth=1
+            )
+        )
+    if retinamask == False:
+        mask_cpu = cv2.resize(
+            mask_cpu, (target_width, target_height), interpolation=cv2.INTER_NEAREST
+        )
+    return mask_cpu
+
+
+# # clip
+# @torch.no_grad()
+# def retriev(
+#     model, preprocess, elements, search_text: str, device
+# ) -> int:
+#     preprocessed_images = [preprocess(image).to(device) for image in elements]
+#     tokenized_text = clip.tokenize([search_text]).to(device)
+#     stacked_images = torch.stack(preprocessed_images)
+#     image_features = model.encode_image(stacked_images)
+#     text_features = model.encode_text(tokenized_text)
+#     image_features /= image_features.norm(dim=-1, keepdim=True)
+#     text_features /= text_features.norm(dim=-1, keepdim=True)
+#     probs = 100.0 * image_features @ text_features.T
+#     return probs[:, 0].softmax(dim=0)
+
+
+def crop_image(annotations, image_path):
+    image = Image.open(image_path)
+    ori_w, ori_h = image.size
+    mask_h, mask_w = annotations[0]["segmentation"].shape
+    if ori_w != mask_w or ori_h != mask_h:
+        image = image.resize((mask_w, mask_h))
+    cropped_boxes = []
+    cropped_images = []
+    not_crop = []
+    filter_id = []
+    # annotations, _ = filter_masks(annotations)
+    # filter_id = list(_)
+    for _, mask in enumerate(annotations):
+        if np.sum(mask["segmentation"]) <= 100:
+            filter_id.append(_)
+            continue
+        bbox = get_bbox_from_mask(mask["segmentation"])  # mask 的 bbox
+        cropped_boxes.append(segment_image(image, bbox))  # 保存裁剪的图片
+        # cropped_boxes.append(segment_image(image,mask["segmentation"]))
+        cropped_images.append(bbox)  # 保存裁剪的图片的bbox
+
+    return cropped_boxes, cropped_images, not_crop, filter_id, annotations
+
+
+def box_prompt(masks, bbox, target_height, target_width):
+    h = masks.shape[1]
+    w = masks.shape[2]
+    if h != target_height or w != target_width:
+        bbox = [
+            int(bbox[0] * w / target_width),
+            int(bbox[1] * h / target_height),
+            int(bbox[2] * w / target_width),
+            int(bbox[3] * h / target_height),
+        ]
+    bbox[0] = round(bbox[0]) if round(bbox[0]) > 0 else 0
+    bbox[1] = round(bbox[1]) if round(bbox[1]) > 0 else 0
+    bbox[2] = round(bbox[2]) if round(bbox[2]) < w else w
+    bbox[3] = round(bbox[3]) if round(bbox[3]) < h else h
+
+    # IoUs = torch.zeros(len(masks), dtype=torch.float32)
+    bbox_area = (bbox[3] - bbox[1]) * (bbox[2] - bbox[0])
+
+    masks_area = torch.sum(masks[:, bbox[1] : bbox[3], bbox[0] : bbox[2]], dim=(1, 2))
+    orig_masks_area = torch.sum(masks, dim=(1, 2))
+
+    union = bbox_area + orig_masks_area - masks_area
+    IoUs = masks_area / union
+    max_iou_index = torch.argmax(IoUs)
+
+    return masks[max_iou_index].cpu().numpy(), max_iou_index
+
+
+def point_prompt(masks, points, pointlabel, target_height, target_width):  # numpy 处理
+    h = masks[0]["segmentation"].shape[0]
+    w = masks[0]["segmentation"].shape[1]
+    if h != target_height or w != target_width:
+        points = [
+            [int(point[0] * w / target_width), int(point[1] * h / target_height)]
+            for point in points
+        ]
+    onemask = np.zeros((h, w))
+    for i, annotation in enumerate(masks):
+        if type(annotation) == dict:
+            mask = annotation["segmentation"]
+        else:
+            mask = annotation
+        for i, point in enumerate(points):
+            if mask[point[1], point[0]] == 1 and pointlabel[i] == 1:
+                onemask += mask
+            if mask[point[1], point[0]] == 1 and pointlabel[i] == 0:
+                onemask -= mask
+    onemask = onemask >= 1
+    return onemask, 0
+
+
+# def text_prompt(annotations, args):
+#     cropped_boxes, cropped_images, not_crop, filter_id, annotaions = crop_image(
+#         annotations, args.img_path
+#     )
+#     clip_model, preprocess = clip.load("ViT-B/32", device=args.device)
+#     scores = retriev(
+#         clip_model, preprocess, cropped_boxes, args.text_prompt, device=args.device
+#     )
+#     max_idx = scores.argsort()
+#     max_idx = max_idx[-1]
+#     max_idx += sum(np.array(filter_id) <= int(max_idx))
+#     return annotaions[max_idx]["segmentation"], max_idx