Upload 11 files

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* 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
+data/150000[[:space:]](3.07)_orj.jpg filter=lfs diff=lfs merge=lfs -text
+data/150021[[:space:]](3.07)_orj.jpg filter=lfs diff=lfs merge=lfs -text
+data/150253[[:space:]](3.07)_orj.jpg filter=lfs diff=lfs merge=lfs -text
+data/150261[[:space:]](3.07)_orj.jpg filter=lfs diff=lfs merge=lfs -text

Lib/BirdNestDetection.py

@@ -0,0 +1,274 @@
+"""
+    # Model: YOLOv7
+    @inproceedings{wang2023yolov7,
+    title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors},
+    author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark},
+    booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
+    year={2023}
+    }
+"""
+import os
+import sys
+sys.path.append(os.getcwd())
+
+import random
+import time
+import torch
+import torchvision
+import onnxruntime as ort
+import cv2
+import numpy as np
+from Lib.Const import LABELS, COLOR_MAP, COLOR_MAP_RGB
+
+
+def scale_coords(img1_shape, coords, img0_shape, ratio_pad=None):
+    # Rescale coords (xyxy) from img1_shape to img0_shape
+    if ratio_pad is None:  # calculate from img0_shape
+        gain = min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1])  # gain  = old / new
+        pad = (img1_shape[1] - img0_shape[1] * gain) / 2, (img1_shape[0] - img0_shape[0] * gain) / 2  # wh padding
+    else:
+        gain = ratio_pad[0][0]
+        pad = ratio_pad[1]
+
+    coords[:, [0, 2]] -= pad[0]  # x padding
+    coords[:, [1, 3]] -= pad[1]  # y padding
+    coords[:, :4] /= gain
+    clip_coords(coords, img0_shape)
+    return coords
+
+
+def clip_coords(boxes, img_shape):
+    # Clip bounding xyxy bounding boxes to image shape (height, width)
+    boxes[:, 0].clamp_(0, img_shape[1])  # x1
+    boxes[:, 1].clamp_(0, img_shape[0])  # y1
+    boxes[:, 2].clamp_(0, img_shape[1])  # x2
+    boxes[:, 3].clamp_(0, img_shape[0])  # y2
+
+
+def box_iou(box1, box2):
+    # https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py
+    """
+    Return intersection-over-union (Jaccard index) of boxes.
+    Both sets of boxes are expected to be in (x1, y1, x2, y2) format.
+    Arguments:
+        box1 (Tensor[N, 4])
+        box2 (Tensor[M, 4])
+    Returns:
+        iou (Tensor[N, M]): the NxM matrix containing the pairwise
+            IoU values for every element in boxes1 and boxes2
+    """
+
+    def box_area(box):
+        # box = 4xn
+        return (box[2] - box[0]) * (box[3] - box[1])
+
+    area1 = box_area(box1.T)
+    area2 = box_area(box2.T)
+
+    # inter(N,M) = (rb(N,M,2) - lt(N,M,2)).clamp(0).prod(2)
+    inter = (torch.min(box1[:, None, 2:], box2[:, 2:]) - torch.max(box1[:, None, :2], box2[:, :2])).clamp(0).prod(2)
+    return inter / (area1[:, None] + area2 - inter)  # iou = inter / (area1 + area2 - inter)
+
+
+def xywh2xyxy(x):
+    # Convert nx4 boxes from [x, y, w, h] to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right
+    y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)
+    y[:, 0] = x[:, 0] - x[:, 2] / 2  # top left x
+    y[:, 1] = x[:, 1] - x[:, 3] / 2  # top left y
+    y[:, 2] = x[:, 0] + x[:, 2] / 2  # bottom right x
+    y[:, 3] = x[:, 1] + x[:, 3] / 2  # bottom right y
+    return y
+
+
+def non_max_suppression(prediction, conf_thres=0.25, iou_thres=0.45, classes=None, agnostic=False, multi_label=False, labels=()):
+    """Runs Non-Maximum Suppression (NMS) on inference results
+
+    Returns:
+         list of detections, on (n,6) tensor per image [xyxy, conf, cls]
+    """
+
+    nc = prediction.shape[2] - 5  # number of classes
+    xc = prediction[..., 4] > conf_thres  # candidates
+
+    # Settings
+    min_wh, max_wh = 2, 4096  # (pixels) minimum and maximum box width and height
+    max_det = 300  # maximum number of detections per image
+    max_nms = 30000  # maximum number of boxes into torchvision.ops.nms()
+    time_limit = 10.0  # seconds to quit after
+    redundant = True  # require redundant detections
+    multi_label &= nc > 1  # multiple labels per box (adds 0.5ms/img)
+    merge = False  # use merge-NMS
+
+    t = time.time()
+    output = [torch.zeros((0, 6), device=prediction.device)] * prediction.shape[0]
+    for xi, x in enumerate(prediction):  # image index, image inference
+        # Apply constraints
+        # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0  # width-height
+        x = x[xc[xi]]  # confidence
+
+        # Cat apriori labels if autolabelling
+        if labels and len(labels[xi]):
+            l = labels[xi]
+            v = torch.zeros((len(l), nc + 5), device=x.device)
+            v[:, :4] = l[:, 1:5]  # box
+            v[:, 4] = 1.0  # conf
+            v[range(len(l)), l[:, 0].long() + 5] = 1.0  # cls
+            x = torch.cat((x, v), 0)
+
+        # If none remain process next image
+        if not x.shape[0]:
+            continue
+
+        # Compute conf
+        if nc == 1:
+            x[:, 5:] = x[:, 4:5] # for models with one class, cls_loss is 0 and cls_conf is always 0.5,
+                                 # so there is no need to multiplicate.
+        else:
+            x[:, 5:] *= x[:, 4:5]  # conf = obj_conf * cls_conf
+
+        # Box (center x, center y, width, height) to (x1, y1, x2, y2)
+        box = xywh2xyxy(x[:, :4])
+
+        # Detections matrix nx6 (xyxy, conf, cls)
+        if multi_label:
+            i, j = (x[:, 5:] > conf_thres).nonzero(as_tuple=False).T
+            x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)
+        else:  # best class only
+            conf, j = x[:, 5:].max(1, keepdim=True)
+            x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]
+
+        # Filter by class
+        if classes is not None:
+            x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)]
+
+        # Apply finite constraint
+        # if not torch.isfinite(x).all():
+        #     x = x[torch.isfinite(x).all(1)]
+
+        # Check shape
+        n = x.shape[0]  # number of boxes
+        if not n:  # no boxes
+            continue
+        elif n > max_nms:  # excess boxes
+            x = x[x[:, 4].argsort(descending=True)[:max_nms]]  # sort by confidence
+
+        # Batched NMS
+        c = x[:, 5:6] * (0 if agnostic else max_wh)  # classes
+        boxes, scores = x[:, :4] + c, x[:, 4]  # boxes (offset by class), scores
+        i = torchvision.ops.nms(boxes, scores, iou_thres)  # NMS
+        if i.shape[0] > max_det:  # limit detections
+            i = i[:max_det]
+        if merge and (1 < n < 3E3):  # Merge NMS (boxes merged using weighted mean)
+            # update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)
+            iou = box_iou(boxes[i], boxes) > iou_thres  # iou matrix
+            weights = iou * scores[None]  # box weights
+            x[i, :4] = torch.mm(weights, x[:, :4]).float() / weights.sum(1, keepdim=True)  # merged boxes
+            if redundant:
+                i = i[iou.sum(1) > 1]  # require redundancy
+
+        output[xi] = x[i]
+        if (time.time() - t) > time_limit:
+            print(f'WARNING: NMS time limit {time_limit}s exceeded')
+            break  # time limit exceeded
+
+    return output
+
+
+def letterbox(img, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleFill=False, scaleup=True, stride=32):
+    # Resize and pad image while meeting stride-multiple constraints
+    shape = img.shape[:2]  # current shape [height, width]
+    if isinstance(new_shape, int):
+        new_shape = (new_shape, new_shape)
+
+    # Scale ratio (new / old)
+    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
+    if not scaleup:  # only scale down, do not scale up (for better test mAP)
+        r = min(r, 1.0)
+
+    # Compute padding
+    ratio = r, r  # width, height ratios
+    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
+    dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]  # wh padding
+    if auto:  # minimum rectangle
+        dw, dh = np.mod(dw, stride), np.mod(dh, stride)  # wh padding
+    elif scaleFill:  # stretch
+        dw, dh = 0.0, 0.0
+        new_unpad = (new_shape[1], new_shape[0])
+        ratio = new_shape[1] / shape[1], new_shape[0] / shape[0]  # width, height ratios
+
+    dw /= 2  # divide padding into 2 sides
+    dh /= 2
+
+    if shape[::-1] != new_unpad:  # resize
+        img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
+    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
+    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
+    img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)  # add border
+    return img, ratio, (dw, dh)
+
+
+def plot_one_box(x, img, color=None, label=None, line_thickness=3):
+    # Plots one bounding box on image img
+    tl = line_thickness or round(0.002 * (img.shape[2] + img.shape[3]) / 2) + 1  # line/font thickness
+    color = color or [random.randint(0, 255) for _ in range(3)]
+    c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3]))
+    cv2.rectangle(img, c1, c2, color, tl, cv2.LINE_AA)
+
+    if label:
+        tf = max(tl - 1, 1)  # font thickness
+        t_size = cv2.getTextSize(label, 0, fontScale=tl / 3, thickness=tf)[0]
+        c2 = c1[0] + t_size[0], c1[1] - t_size[1] - 3
+        cv2.rectangle(img, c1, c2, color, -1, cv2.LINE_AA)  # filled
+        cv2.putText(img, label, (c1[0], c1[1] - 2), 0, tl / 3, [225, 255, 255], thickness=tf, lineType=cv2.LINE_AA)
+
+
+print(ort.get_available_providers())
+session = ort.InferenceSession("Weight/yolov7_kus.onnx", providers=ort.get_available_providers())
+
+input_name = session.get_inputs()[0].name
+print("input name", input_name)
+input_shape = session.get_inputs()[0].shape
+print("input shape", input_shape)
+input_type = session.get_inputs()[0].type
+print("input type", input_type)
+output_name = session.get_outputs()[0].name
+
+
+def DetectNests(im0, model_threshold=0.25, iou_thres=0.45):
+    # Preprocess
+    img = letterbox(im0, (1280, 1280), stride=64, auto=False)[0]
+    img = img[:, :, ::-1].transpose(2, 0, 1)  # BGR to RGB, to 3x416x416
+    img = np.ascontiguousarray(img)
+    image = img.astype(np.float32) / 255.0
+    image = image[np.newaxis, ...]
+
+    # Inference
+    results = session.run([output_name], {input_name: image})
+    res = torch.from_numpy(results[0])
+    pred = non_max_suppression(res, conf_thres=model_threshold, iou_thres=iou_thres, classes=None, agnostic=False, multi_label=False, labels=())
+
+    # Postprocess
+    print(pred[0].shape)
+
+    boxes = []
+    classes = []
+    for i, det in enumerate(pred):
+        if len(det):
+            det[:, :4] = scale_coords(image.shape[2:], det[:, :4], im0.shape).round()
+            print(det)
+            for *xyxy, conf, cls in reversed(det):
+                _label = LABELS[int(cls)]
+                plot_one_box(xyxy, im0, label=f"{_label} - {float(conf):.2f}", color=COLOR_MAP_RGB[_label], line_thickness=2)
+                classes.append(int(cls))
+                boxes.append([int(xyxy[0]), int(xyxy[1]), int(xyxy[2]), int(xyxy[3])])
+
+    return im0, boxes, classes
+
+
+
+if "__main__" == __name__:
+    im0 = cv2.imread("data/150000 (3.07)_orj.jpg")
+    im0, boxes, classes = DetectNests(im0, model_threshold=0.25, iou_thres=0.45)
+    cv2.imwrite("result.png", im0)
+    # cv2.imshow("image", im0)
+    # cv2.waitKey(0)

Lib/Const.py

@@ -0,0 +1,3 @@
+LABELS = {0: "Kus Yuvasi"}
+COLOR_MAP = {"Kus Yuvasi":"#fc033d"}
+COLOR_MAP_RGB = {key : [ int(value[1:3], 16), int(value[3:5], 16), int(value[5:7], 16)] for key, value in COLOR_MAP.items()}

UI/Main.py

@@ -0,0 +1,78 @@
+import os
+import sys
+sys.path.append(os.getcwd())
+
+from Lib.Const import COLOR_MAP, LABELS
+from Lib.BirdNestDetection import DetectNests
+
+import cv2
+import gradio as gr
+
+demoImages = [
+    "data/150000 (3.07)_orj.jpg",
+    "data/150021 (3.07)_orj.jpg",
+    "data/150253 (3.07)_orj.jpg",
+    "data/150261 (3.07)_orj.jpg"
+]
+
+
+def Warning():
+    gr.Info("DGH ARGE YAZILIM DANIŞMANLIK ENERJİ İNŞAAT SAN.TİC.LTD.ŞTİ", duration=0.5)
+
+with gr.Blocks(css="footer{display:none !important}") as block:
+    gr.Markdown("## Yüksek Gerilim Hatlarında Kuş Yuvası Tespiti - Demo")
+    with gr.Row():
+        with gr.Column():
+            inputImage = gr.Image(label="Fotoğraf")
+
+        with gr.Column():
+            thresholdSlider = gr.Slider(0, 1, value=0.25, label="Model Eşik Değeri", info="0 ve 1 arası seçiniz.")
+            iouThresholdSlider = gr.Slider(0, 1, value=0.45, label="IOU (Intersection Over Union) Eşik Değeri", info="0 ve 1 arası seçiniz.")
+            with gr.Accordion("Demo Görsellerden Seçebilirsiniz", open=False):
+                imageGallery = gr.Examples(
+                    examples=[
+                        os.path.join("data", img_name) for img_name in sorted(os.listdir("data"))
+                    ],
+                    inputs=[inputImage],
+                    label="Örnekler",
+                    cache_examples=False,
+                    examples_per_page=7
+                )
+            results = gr.Textbox(label="Durum")
+            processButton = gr.Button("Tespit Et")
+
+    
+    gr.HTML("</hr>")
+    processedImageGallery = gr.Gallery(
+        label="Sonuçlar",
+        rows=1, 
+        columns=2, 
+        object_fit="contain", 
+        height="auto"
+    )
+
+    annotatedImage = gr.AnnotatedImage(color_map=COLOR_MAP)
+
+    @processButton.click(outputs=[processedImageGallery, annotatedImage, results], inputs=[inputImage, thresholdSlider, iouThresholdSlider])
+    def Process(image, model_threshold, iouThresholdSlider):
+        if image is None:
+            raise gr.Warning("Lütfen görüntü yükleyiniz veya hazır seçiniz!", duration=3)
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+        img0, boxes, labels = DetectNests(image, model_threshold, iouThresholdSlider)
+
+        if len(boxes) == 0:
+            raise gr.Error("Bir Hata ile Karşılaşıldı: Görüntüde Tespit Yapılamadı 💥!", duration=5)
+
+        sections = []
+        for b, c in zip(boxes, labels):
+            sections+=[(b, LABELS[c])]
+
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        return [img0], (image, sections), "Görüntü İşlendi!"
+  
+    block.load(Warning)
+
+
+block.queue(max_size=10)
+block.launch(server_name="0.0.0.0", server_port=1071)
+

Weight/yolov7_kus.onnx

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

dockerfile

@@ -0,0 +1,17 @@
+FROM pytorch/pytorch:2.4.1-cuda12.4-cudnn9-runtime
+
+ARG DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+RUN useradd -m -u 1000 user
+RUN apt-get update && apt-get install ffmpeg libsm6 libxext6 --no-install-recommends -y \
+   && apt-get clean \
+   && rm -rf /var/lib/apt/lists/*
+  
+RUN pip install --no-cache-dir gradio opencv-python pandas ultralytics onnx onnxruntime
+
+USER user
+WORKDIR /app
+COPY --chown=user ./ /app
+
+EXPOSE 1071
+CMD ["python", "/app/UI/Main.py"]