Upload 9 files

README.md

@@ -1,13 +1,13 @@
 ---
-title: YOLOPUPIL
-emoji: 👁
+title: Yolov8 Meter
+emoji: 😻
 colorFrom: purple
-colorTo: indigo
+colorTo: purple
 sdk: gradio
-sdk_version: 4.13.0
+sdk_version: 4.8.0
 app_file: app.py
 pinned: false
-license: mit
+license: cc
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,70 @@
+import gradio as gr
+
+from ultralytics import YOLO
+model = YOLO('./best.pt')  # load your custom trained model
+import torch
+#from ultralyticsplus import render_result
+from render import custom_render_result
+
+
+
+def yoloV8_func(image: gr.Image = None,
+                image_size: int = 640,
+                conf_threshold: float = 0.4,
+                iou_threshold: float = 0.5):
+    """This function performs YOLOv8 object detection on the given image.
+
+    Args:
+        image (gr.Image, optional): Input image to detect objects on. Defaults to None.
+        image_size (int, optional): Desired image size for the model. Defaults to 640.
+        conf_threshold (float, optional): Confidence threshold for object detection. Defaults to 0.4.
+        iou_threshold (float, optional): Intersection over Union threshold for object detection. Defaults to 0.50.
+    """
+    # Load the YOLOv8 model from the 'best.pt' checkpoint
+    model_path = "yolov8n.pt"
+    # model = torch.hub.load('ultralytics/yolov8', 'custom', path='/content/best.pt', force_reload=True, trust_repo=True)
+
+    # Perform object detection on the input image using the YOLOv8 model
+    results = model.predict(image,
+                            conf=conf_threshold,
+                            iou=iou_threshold,
+                            imgsz=image_size)
+
+    # Print the detected objects' information (class, coordinates, and probability)
+    box = results[0].boxes
+    print("Object type:", box.cls)
+    print("Coordinates:", box.xyxy)
+    print("Probability:", box.conf)
+
+    # Render the output image with bounding boxes around detected objects
+    render = custom_render_result(model=model, image=image, result=results[0])
+    return render
+
+
+inputs = [
+    gr.Image(type="filepath", label="Input Image"),
+    gr.Slider(minimum=320, maximum=1280, step=32, label="Image Size", value=640),
+    gr.Slider(minimum=0.0, maximum=1.0, step=0.05, label="Confidence Threshold"),
+    gr.Slider(minimum=0.0, maximum=1.0, step=0.05, label="IOU Threshold"),
+]
+
+outputs = gr.Image(type="filepath", label="Output Image")
+
+title = "YOLOv8 101: Custom Object Detection on meter"
+
+examples = [['img1.jpg', 640, 0.5, 0.7],
+            ['img2.jpg', 800, 0.5, 0.6],
+            ['img3.jpg', 900, 0.5, 0.8]]
+
+yolo_app = gr.Interface(
+    fn=yoloV8_func,
+    inputs=inputs,
+    outputs=outputs,
+    title=title,
+    examples=examples,
+    cache_examples=False,
+)
+
+# Launch the Gradio interface in debug mode with queue enabled
+yolo_app.launch(debug=True,share=True).queue()
+

best.pt

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

render.py

@@ -0,0 +1,63 @@
+import cv2
+import numpy as np
+from sahi.utils.cv import read_image_as_pil,get_bool_mask_from_coco_segmentation
+from sahi.prediction import ObjectPrediction, PredictionScore,visualize_object_predictions
+from PIL import Image
+def custom_render_result(model,image, result,rect_th=2,text_th=2):
+    if model.overrides["task"] not in ["detect", "segment"]:
+        raise ValueError(
+            f"Model task must be either 'detect' or 'segment'. Got {model.overrides['task']}"
+        )
+
+    image = read_image_as_pil(image)
+    np_image = np.ascontiguousarray(image)
+
+    names = model.model.names
+
+    masks = result.masks
+    boxes = result.boxes
+
+    object_predictions = []
+    if boxes is not None:
+        det_ind = 0
+        for xyxy, conf, cls in zip(boxes.xyxy, boxes.conf, boxes.cls):
+            if masks:
+                img_height = np_image.shape[0]
+                img_width = np_image.shape[1]
+                segments = masks.segments
+                segments = segments[det_ind]  # segments: np.array([[x1, y1], [x2, y2]])
+                # convert segments into full shape
+                segments[:, 0] = segments[:, 0] * img_width
+                segments[:, 1] = segments[:, 1] * img_height
+                segmentation = [segments.ravel().tolist()]
+
+                bool_mask = get_bool_mask_from_coco_segmentation(
+                    segmentation, width=img_width, height=img_height
+                )
+                if sum(sum(bool_mask == 1)) <= 2:
+                    continue
+                object_prediction = ObjectPrediction.from_coco_segmentation(
+                    segmentation=segmentation,
+                    category_name=names[int(cls)],
+                    category_id=int(cls),
+                    full_shape=[img_height, img_width],
+                )
+                object_prediction.score = PredictionScore(value=conf)
+            else:
+                object_prediction = ObjectPrediction(
+                    bbox=xyxy.tolist(),
+                    category_name=names[int(cls)],
+                    category_id=int(cls),
+                    score=conf,
+                )
+            object_predictions.append(object_prediction)
+            det_ind += 1
+
+    result = visualize_object_predictions(
+        image=np_image,
+        object_prediction_list=object_predictions,
+        rect_th=rect_th,
+        text_th=text_th,
+    )
+
+    return Image.fromarray(result["image"])

requirements.txt

@@ -0,0 +1,7 @@
+gradio==4.8.0
+numpy==1.26.2
+opencv_python==4.7.0.72
+Pillow==10.1.0
+sahi==0.11.15
+torch==2.1.1
+ultralytics==8.0.223