Upload 10 files

onnx/friendfoe.onnx

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

onnx/hero.onnx

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

onnx/hp.onnx

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

onnx/ui.onnx

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

pt/friendfoe.pt

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

pt/hero.pt

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

pt/hp.pt

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

pt/ui.pt

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

quad_detect.py

@@ -0,0 +1,258 @@
+import os
+import sys
+import argparse
+import glob
+import time
+import cv2
+import numpy as np
+from ultralytics import YOLO
+import threading
+
+# -----------------------------------
+# Parse command-line arguments
+# -----------------------------------
+parser = argparse.ArgumentParser()
+parser.add_argument('--model1', help='Path to YOLO model #1', required=True)
+parser.add_argument('--model2', help='Path to YOLO model #2', required=True)
+parser.add_argument('--model3', help='Path to YOLO model #3', required=True)
+parser.add_argument('--model4', help='Path to YOLO model #4', required=True)
+parser.add_argument('--source', help='Image or video source (file, folder, or camera)', required=True)
+parser.add_argument('--thresh', help='Minimum confidence threshold for displaying detected objects',
+                    default=0.5, type=float)
+parser.add_argument('--resolution', help='Resolution in WxH (e.g., "640x480"), otherwise matches source',
+                    default=None)
+parser.add_argument('--record', help='Record results and save as "demo1.avi". Requires --resolution.',
+                    action='store_true')
+args = parser.parse_args()
+
+# -----------------------------------
+# Load YOLO models
+# -----------------------------------
+model_paths = [args.model1, args.model2, args.model3, args.model4]
+min_thresh = args.thresh
+models = []
+for path in model_paths:
+    if not os.path.exists(path):
+        print(f'ERROR: Model path {path} is invalid. Check the file path.')
+        sys.exit(0)
+    models.append(YOLO(path))
+
+# Class names for each model
+model_labels = [m.names for m in models]
+
+# -----------------------------------
+# Determine source type
+# -----------------------------------
+img_source = args.source
+img_ext_list = ['.jpg', '.jpeg', '.png', '.bmp']
+vid_ext_list = ['.avi', '.mov', '.mp4', '.mkv', '.wmv']
+
+if os.path.isdir(img_source):
+    source_type = 'folder'
+elif os.path.isfile(img_source):
+    _, ext = os.path.splitext(img_source)
+    if ext in img_ext_list:
+        source_type = 'image'
+    elif ext in vid_ext_list:
+        source_type = 'video'
+    else:
+        print(f'Unsupported file extension: {ext}')
+        sys.exit(0)
+elif 'usb' in img_source:
+    source_type = 'usb'
+    usb_idx = int(img_source[3:])
+else:
+    print(f'Invalid source: {img_source}')
+    sys.exit(0)
+
+# -----------------------------------
+# Set up resolution and recorder
+# -----------------------------------
+resize = False
+user_res = args.resolution
+record = args.record
+if user_res:
+    resize = True
+    resW, resH = map(int, user_res.split('x'))
+
+if record:
+    if source_type not in ['video', 'usb']:
+        print('Recording only works for video and camera sources.')
+        sys.exit(0)
+    if not user_res:
+        print('Please specify resolution to record.')
+        sys.exit(0)
+    record_name = 'demo1.avi'
+    record_fps = 30
+    recorder = cv2.VideoWriter(record_name, cv2.VideoWriter_fourcc(*'MJPG'),
+                               record_fps, (resW, resH))
+
+# -----------------------------------
+# Load image/video source
+# -----------------------------------
+if source_type == 'image':
+    imgs_list = [img_source]
+elif source_type == 'folder':
+    imgs_list = [file for file in glob.glob(img_source + '/*')
+                 if os.path.splitext(file)[1] in img_ext_list]
+elif source_type in ['video', 'usb']:
+    cap = cv2.VideoCapture(img_source if source_type == 'video' else usb_idx)
+    if resize:
+        cap.set(3, resW)
+        cap.set(4, resH)
+
+# -----------------------------------
+# Colors for each model's bounding boxes
+# -----------------------------------
+model_colors = [
+    (0, 128, 0),   # Model 1: dark green
+    (128, 0, 0),   # Model 2: dark red
+    (0, 0, 128),   # Model 3: dark blue
+    (128, 128, 0)  # Model 4: dark olive (muted cyan alternative)
+]
+# -----------------------------------
+# FPS tracking
+# -----------------------------------
+avg_frame_rate = 0
+frame_rate_buffer = []
+fps_avg_len = 200
+img_count = 0
+
+# -----------------------------------
+# Thread function for model inference
+# -----------------------------------
+def run_detection(index, frame, results_dict):
+    results_dict[index] = models[index](frame, verbose=False)[0]
+
+# -----------------------------------
+# draw_detections with left/right anchor
+# -----------------------------------
+def draw_detections(results, labels, frame, color, min_thresh, anchor='left'):
+    for det in results.boxes:
+        xyxy = det.xyxy.cpu().numpy().squeeze().astype(int)
+        class_idx = int(det.cls.item())
+        conf = det.conf.item()
+
+        if conf > min_thresh:
+            x1, y1, x2, y2 = xyxy
+
+            # Draw bounding box
+            cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
+
+            label = f'{labels[class_idx]}: {int(conf * 100)}%'
+            label_size, _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
+
+            if anchor == 'left':
+                # Label at top-left corner
+                text_x = x1
+                text_y = y1 - 5
+                box_x1 = x1
+                box_x2 = x1 + label_size[0]
+            else:
+                # Label at top-right corner
+                text_x = x2 - label_size[0]
+                text_y = y1 - 5
+                box_x1 = x2 - label_size[0]
+                box_x2 = x2
+
+            # Draw filled rectangle for label background
+            cv2.rectangle(
+                frame,
+                (box_x1, y1 - label_size[1] - 10),
+                (box_x2, y1),
+                color,
+                -1
+            )
+
+            # Draw label text in white
+            cv2.putText(
+                frame,
+                label,
+                (text_x, text_y),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.5,
+                (255, 255, 255),
+                1
+            )
+
+# -----------------------------------
+# Main loop
+# -----------------------------------
+while True:
+    t_start = time.perf_counter()
+
+    # Grab frame
+    if source_type in ['image', 'folder']:
+        if img_count >= len(imgs_list):
+            print('All images processed. Exiting.')
+            sys.exit(0)
+        frame = cv2.imread(imgs_list[img_count])
+        img_count += 1
+    elif source_type in ['video', 'usb']:
+        ret, frame = cap.read()
+        if not ret:
+            print('No more frames or camera disconnected. Exiting.')
+            break
+
+    # Resize if needed
+    if resize:
+        frame = cv2.resize(frame, (resW, resH))
+
+    # Dictionary to store results from each model
+    results_dict = {}
+
+    # Run all models in separate threads
+    threads = []
+    for i in range(4):
+        t = threading.Thread(target=run_detection, args=(i, frame, results_dict))
+        t.start()
+        threads.append(t)
+
+    # Wait for all threads to finish
+    for t in threads:
+        t.join()
+
+    # Draw each model’s detections
+    for i in range(4):
+        # Move the 3rd model's label to the right side (i == 2 in 0-based indexing)
+        if i == 2:
+            draw_detections(results_dict[i], model_labels[i], frame, model_colors[i],
+                            min_thresh, anchor='right')
+        else:
+            draw_detections(results_dict[i], model_labels[i], frame, model_colors[i],
+                            min_thresh, anchor='left')
+
+    # Show FPS
+    cv2.putText(frame, f'FPS: {avg_frame_rate:.2f}',
+                (10, 20),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.7,
+                (0, 255, 255),
+                2)
+
+    # Display frame
+    cv2.imshow('YOLO Detection Results', frame)
+    if record:
+        recorder.write(frame)
+
+    key = cv2.waitKey(5)
+    if key == ord('q'):
+        break
+
+    # Compute FPS
+    t_stop = time.perf_counter()
+    frame_rate_calc = 1 / (t_stop - t_start)
+    frame_rate_buffer.append(frame_rate_calc)
+    if len(frame_rate_buffer) > fps_avg_len:
+        frame_rate_buffer.pop(0)
+    avg_frame_rate = np.mean(frame_rate_buffer)
+
+# -----------------------------------
+# Cleanup
+# -----------------------------------
+print(f'Average FPS: {avg_frame_rate:.2f}')
+if source_type in ['video', 'usb']:
+    cap.release()
+if record:
+    recorder.release()
+cv2.destroyAllWindows()