app.py

import gradio as gr
import spaces
import supervision as sv
from PIL import ImageDraw
import PIL.Image as Image 
import PIL.Image as Image
from ultralytics import YOLO
from huggingface_hub import hf_hub_download, HfApi
import random
global repo_id

def download_models(model_id):
    hf_hub_download(repo_id, filename = f"{model_id}", local_dir = f"./")
    return f"./{model_id}"

def get_model_filenames(repo_id, file_extension = ".pt"):
    api = HfApi()
    files = api.list_repo_files(repo_id)
    model_filenames = [file for file in files if file.endswith(file_extension)]
    return model_filenames

def random_color():
    return tuple(random.randint(0, 255) for _ in range(3))

repo_id = "atalaydenknalbant/asl-yolo-models"
model_filenames = get_model_filenames(repo_id)
print("Model filenames:", model_filenames)

box_annotator = sv.BoxAnnotator()
category_dict = {0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I',
                 9: 'J', 10: 'K', 11: 'L', 12: 'M', 13: 'N', 14: 'O', 15: 'P', 16: 'Q',
                 17: 'R', 18: 'S', 19: 'T', 20: 'U', 21: 'V', 22: 'W', 23: 'X', 24: 'Y', 25: 'Z'}




@spaces.GPU
def yolo_inference(image, model_id, conf_threshold, iou_threshold, max_detection):
    model_path = download_models(model_id)
    model = YOLO(model_path)
    results = model(source=image, imgsz=640, iou=iou_threshold, conf=conf_threshold, verbose=False, max_det=max_detection)[0]
    
    detections = sv.Detections.from_ultralytics(results)
    
    labels = [
        f"{category_dict[class_id]} {confidence:.2f}"
        for class_id, confidence in zip(detections.class_id, detections.confidence)
    ]
    

    annotated_image = image.copy()  
    draw = ImageDraw.Draw(annotated_image)

    for label, (x1, y1, x2, y2) in zip(labels, detections.xyxy):  
        color = random_color() 
        draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
        draw.text((x1, y1), label, fill=color)

    return annotated_image

def app():
    with gr.Blocks():
        with gr.Row():
            with gr.Column():
                image = gr.Image(type="pil", label="Image", interactive=True)
    
                model_id = gr.Dropdown(
                    label="Model",
                    choices=model_filenames,
                    value=model_filenames[0] if model_filenames else "",
                )
                conf_threshold = gr.Slider(
                    label="Confidence Threshold",
                    minimum=0.1,
                    maximum=1.0,
                    step=0.1,
                    value=0.25,
                )
                iou_threshold = gr.Slider(
                    label="IoU Threshold",
                    minimum=0.1,
                    maximum=1.0,
                    step=0.1,
                    value=0.45,
                )
                
                max_detection = gr.Slider(
                    label="Max Detection",
                    minimum=1,
                    step=1,
                    value=1,
                )
                yolov_infer = gr.Button(value="Detect Objects")

            with gr.Column():
                output_image = gr.Image(type="pil", label="Annotated Image", interactive=False)

        yolov_infer.click(
            fn=yolo_inference,
            inputs=[
                image,
                model_id,
                conf_threshold,
                iou_threshold,
                max_detection,
            ],
            outputs=[output_image],
        )

        gr.Examples(
            examples=[
                [
                    "b.jpg",
                    "yolov10x.pt",
                    0.25,
                    0.45,
                    1,
                ],
                
                [
                    "a.jpg",
                    "yolov10s.pt",
                    0.25,
                    0.45,
                    1,
                ],
                [
                    "y.jpg",
                    "yolov10x.pt",
                    0.25,
                    0.45,
                    1,
                ],
            ],
            fn=yolo_inference,
            inputs=[
                image,
                model_id,
                conf_threshold,
                iou_threshold,
                max_detection,
            ],
            outputs=[output_image],
            cache_examples="lazy",
        )

gradio_app = gr.Blocks()
with gradio_app:
    gr.HTML(
        """
    <h1 style='text-align: center'>
    YOLO Powered ASL(American Sign Language) Letter Detector PSA: It can't detect J or Z
    </h1>
        """)
    with gr.Row():
        with gr.Column():
            app()

gradio_app.launch(debug=True)