Srini

app.py

@@ -0,0 +1,110 @@
+# Python In-built packages
+from pathlib import Path
+import PIL
+
+# External packages
+import streamlit as st
+
+# Local Modules
+import settings
+import helper
+
+# Setting page layout
+st.set_page_config(
+    page_title="Object Detection using YOLOv8",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Main page heading
+st.title("Object Detection using YOLOv8")
+
+# Sidebar
+st.sidebar.header("ML Model Config")
+
+# Model Options
+model_type = st.sidebar.radio(
+    "Select Task", ['Detection', 'Segmentation'])
+
+confidence = float(st.sidebar.slider(
+    "Select Model Confidence", 25, 100, 40)) / 100
+
+# Selecting Detection Or Segmentation
+if model_type == 'Detection':
+    model_path = Path(settings.DETECTION_MODEL)
+elif model_type == 'Segmentation':
+    model_path = Path(settings.SEGMENTATION_MODEL)
+
+# Load Pre-trained ML Model
+try:
+    model = helper.load_model(model_path)
+except Exception as ex:
+    st.error(f"Unable to load model. Check the specified path: {model_path}")
+    st.error(ex)
+
+st.sidebar.header("Image/Video Config")
+source_radio = st.sidebar.radio(
+    "Select Source", settings.SOURCES_LIST)
+
+source_img = None
+# If image is selected
+if source_radio == settings.IMAGE:
+    source_img = st.sidebar.file_uploader(
+        "Choose an image...", type=("jpg", "jpeg", "png", 'bmp', 'webp'))
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        try:
+            if source_img is None:
+                default_image_path = str(settings.DEFAULT_IMAGE)
+                default_image = PIL.Image.open(default_image_path)
+                st.image(default_image_path, caption="Default Image",
+                         use_column_width=True)
+            else:
+                uploaded_image = PIL.Image.open(source_img)
+                st.image(source_img, caption="Uploaded Image",
+                         use_column_width=True)
+        except Exception as ex:
+            st.error("Error occurred while opening the image.")
+            st.error(ex)
+
+    with col2:
+        if source_img is None:
+            default_detected_image_path = str(settings.DEFAULT_DETECT_IMAGE)
+            default_detected_image = PIL.Image.open(
+                default_detected_image_path)
+            st.image(default_detected_image_path, caption='Detected Image',
+                     use_column_width=True)
+        else:
+            if st.sidebar.button('Detect Objects'):
+                res = model.predict(uploaded_image,
+                                    conf=confidence
+                                    )
+                boxes = res[0].boxes
+                res_plotted = res[0].plot()[:, :, ::-1]
+                st.image(res_plotted, caption='Detected Image',
+                         use_column_width=True)
+                try:
+                    with st.expander("Detection Results"):
+                        for box in boxes:
+                            st.write(box.data)
+                except Exception as ex:
+                    # st.write(ex)
+                    st.write("No image is uploaded yet!")
+
+elif source_radio == settings.VIDEO:
+    helper.play_stored_video(confidence, model)
+
+elif source_radio == settings.WEBCAM:
+    helper.play_webcam(confidence, model)
+
+elif source_radio == settings.RTSP:
+    helper.play_rtsp_stream(confidence, model)
+
+elif source_radio == settings.YOUTUBE:
+    helper.play_youtube_video(confidence, model)
+
+else:
+    st.error("Please select a valid source type!")

helper.py

@@ -0,0 +1,219 @@
+from ultralytics import YOLO
+import streamlit as st
+import cv2
+import pafy
+
+import settings
+import tracker
+
+
+def load_model(model_path):
+    """
+    Loads a YOLO object detection model from the specified model_path.
+
+    Parameters:
+        model_path (str): The path to the YOLO model file.
+
+    Returns:
+        A YOLO object detection model.
+    """
+    model = YOLO(model_path)
+    return model
+
+
+def display_tracker_option():
+    display_tracker = st.radio("Display Tracker", ('Yes', 'No'))
+    is_display_tracker = True if display_tracker == 'Yes' else False
+    return is_display_tracker
+
+
+def _display_detected_frames(conf, model, st_frame, image, is_display_tracking=None):
+    """
+    Display the detected objects on a video frame using the YOLOv8 model.
+
+    Args:
+    - conf (float): Confidence threshold for object detection.
+    - model (YoloV8): A YOLOv8 object detection model.
+    - st_frame (Streamlit object): A Streamlit object to display the detected video.
+    - image (numpy array): A numpy array representing the video frame.
+    - is_display_tracking (bool): A flag indicating whether to display object tracking (default=None).
+
+    Returns:
+    None
+    """
+
+    # Resize the image to a standard size
+    image = cv2.resize(image, (720, int(720*(9/16))))
+
+    # Predict the objects in the image using the YOLOv8 model
+    res = model.predict(image, conf=conf)
+    result_tensor = res[0].boxes
+
+    # Display object tracking, if specified
+    if is_display_tracking:
+        tracker._display_detected_tracks(result_tensor.data, image)
+
+    # # Plot the detected objects on the video frame
+    res_plotted = res[0].plot()
+    st_frame.image(res_plotted,
+                   caption='Detected Video',
+                   channels="BGR",
+                   use_column_width=True
+                   )
+
+
+def play_youtube_video(conf, model):
+    """
+    Plays a webcam stream. Detects Objects in real-time using the YOLOv8 object detection model.
+
+    Parameters:
+        conf: Confidence of YOLOv8 model.
+        model: An instance of the `YOLOv8` class containing the YOLOv8 model.
+
+    Returns:
+        None
+
+    Raises:
+        None
+    """
+    source_youtube = st.sidebar.text_input("YouTube Video url")
+
+    is_display_tracker = display_tracker_option()
+
+    if st.sidebar.button('Detect Objects'):
+        try:
+            video = pafy.new(source_youtube)
+            best = video.getbest(preftype="mp4")
+            vid_cap = cv2.VideoCapture(best.url)
+            st_frame = st.empty()
+            while (vid_cap.isOpened()):
+                success, image = vid_cap.read()
+                if success:
+                    _display_detected_frames(conf,
+                                             model,
+                                             st_frame,
+                                             image,
+                                             is_display_tracker
+                                             )
+                else:
+                    vid_cap.release()
+                    break
+        except Exception as e:
+            st.sidebar.error("Error loading video: " + str(e))
+
+
+def play_rtsp_stream(conf, model):
+    """
+    Plays an rtsp stream. Detects Objects in real-time using the YOLOv8 object detection model.
+
+    Parameters:
+        conf: Confidence of YOLOv8 model.
+        model: An instance of the `YOLOv8` class containing the YOLOv8 model.
+
+    Returns:
+        None
+
+    Raises:
+        None
+    """
+    source_rtsp = st.sidebar.text_input("rtsp stream url")
+    is_display_tracker = display_tracker_option()
+    if st.sidebar.button('Detect Objects'):
+        try:
+            vid_cap = cv2.VideoCapture(source_rtsp)
+            st_frame = st.empty()
+            while (vid_cap.isOpened()):
+                success, image = vid_cap.read()
+                if success:
+                    _display_detected_frames(conf,
+                                             model,
+                                             st_frame,
+                                             image,
+                                             is_display_tracker
+                                             )
+                else:
+                    vid_cap.release()
+                    break
+        except Exception as e:
+            st.sidebar.error("Error loading RTSP stream: " + str(e))
+
+
+def play_webcam(conf, model):
+    """
+    Plays a webcam stream. Detects Objects in real-time using the YOLOv8 object detection model.
+
+    Parameters:
+        conf: Confidence of YOLOv8 model.
+        model: An instance of the `YOLOv8` class containing the YOLOv8 model.
+
+    Returns:
+        None
+
+    Raises:
+        None
+    """
+    source_webcam = settings.WEBCAM_PATH
+    is_display_tracker = display_tracker_option()
+    if st.sidebar.button('Detect Objects'):
+        try:
+            vid_cap = cv2.VideoCapture(source_webcam)
+            st_frame = st.empty()
+            while (vid_cap.isOpened()):
+                success, image = vid_cap.read()
+                if success:
+                    _display_detected_frames(conf,
+                                             model,
+                                             st_frame,
+                                             image,
+                                             is_display_tracker
+                                             )
+                else:
+                    vid_cap.release()
+                    break
+        except Exception as e:
+            st.sidebar.error("Error loading video: " + str(e))
+
+
+def play_stored_video(conf, model):
+    """
+    Plays a stored video file. Tracks and detects objects in real-time using the YOLOv8 object detection model.
+
+    Parameters:
+        conf: Confidence of YOLOv8 model.
+        model: An instance of the `YOLOv8` class containing the YOLOv8 model.
+
+    Returns:
+        None
+
+    Raises:
+        None
+    """
+    source_vid = st.sidebar.selectbox(
+        "Choose a video...", settings.VIDEOS_DICT.keys())
+
+    is_display_tracker = display_tracker_option()
+
+    with open(settings.VIDEOS_DICT.get(source_vid), 'rb') as video_file:
+        video_bytes = video_file.read()
+    if video_bytes:
+        st.video(video_bytes)
+
+    if st.sidebar.button('Detect Video Objects'):
+        try:
+            vid_cap = cv2.VideoCapture(
+                str(settings.VIDEOS_DICT.get(source_vid)))
+            st_frame = st.empty()
+            while (vid_cap.isOpened()):
+                success, image = vid_cap.read()
+                if success:
+                    _display_detected_frames(conf,
+                                             model,
+                                             st_frame,
+                                             image,
+                                             is_display_tracker
+                                             )
+                else:
+                    vid_cap.release()
+                    break
+        except Exception as e:
+            st.sidebar.error("Error loading video: " + str(e))

settings.py

@@ -0,0 +1,52 @@
+from pathlib import Path
+import sys
+
+# Get the absolute path of the current file
+file_path = Path(__file__).resolve()
+
+# Get the parent directory of the current file
+root_path = file_path.parent
+
+# Add the root path to the sys.path list if it is not already there
+if root_path not in sys.path:
+    sys.path.append(str(root_path))
+
+# Get the relative path of the root directory with respect to the current working directory
+ROOT = root_path.relative_to(Path.cwd())
+
+# Sources
+IMAGE = 'Image'
+VIDEO = 'Video'
+WEBCAM = 'Webcam'
+RTSP = 'RTSP'
+YOUTUBE = 'YouTube'
+
+SOURCES_LIST = [IMAGE, VIDEO, WEBCAM, RTSP, YOUTUBE]
+
+# Images config
+IMAGES_DIR = ROOT / 'images'
+DEFAULT_IMAGE = IMAGES_DIR / 'office_4.jpg'
+DEFAULT_DETECT_IMAGE = IMAGES_DIR / 'office_4_detected.jpg'
+
+# Videos config
+VIDEO_DIR = ROOT / 'videos'
+VIDEO_1_PATH = VIDEO_DIR / 'video_1.mp4'
+VIDEO_2_PATH = VIDEO_DIR / 'video_2.mp4'
+VIDEO_3_PATH = VIDEO_DIR / 'video_3.mp4'
+VIDEO_4_PATH = VIDEO_DIR / 'video_4.mp4'
+VIDEO_5_PATH = VIDEO_DIR / 'video_5.mp4'
+VIDEOS_DICT = {
+    'video_1': VIDEO_1_PATH,
+    'video_2': VIDEO_2_PATH,
+    'video_3': VIDEO_3_PATH,
+    'video_4': VIDEO_4_PATH,
+    'video_5': VIDEO_5_PATH,
+}
+
+# ML Model config
+MODEL_DIR = ROOT / 'weights'
+DETECTION_MODEL = MODEL_DIR / 'yolov8n.pt'
+SEGMENTATION_MODEL = MODEL_DIR / 'yolov8n-seg.pt'
+
+# Webcam
+WEBCAM_PATH = 0

sort.py

@@ -0,0 +1,372 @@
+from __future__ import print_function
+from filterpy.kalman import KalmanFilter
+import argparse
+import time
+import glob
+from skimage import io
+import matplotlib.patches as patches
+import matplotlib.pyplot as plt
+
+import os
+import numpy as np
+import matplotlib
+matplotlib.use('TkAgg')
+
+
+np.random.seed(0)
+
+
+def linear_assignment(cost_matrix):
+    try:
+        import lap  # linear assignment problem solver
+        _, x, y = lap.lapjv(cost_matrix, extend_cost=True)
+        return np.array([[y[i], i] for i in x if i >= 0])
+    except ImportError:
+        from scipy.optimize import linear_sum_assignment
+        x, y = linear_sum_assignment(cost_matrix)
+        return np.array(list(zip(x, y)))
+
+
+"""From SORT: Computes IOU between two boxes in the form [x1,y1,x2,y2]"""
+
+
+def iou_batch(bb_test, bb_gt):
+
+    bb_gt = np.expand_dims(bb_gt, 0)
+    bb_test = np.expand_dims(bb_test, 1)
+
+    xx1 = np.maximum(bb_test[..., 0], bb_gt[..., 0])
+    yy1 = np.maximum(bb_test[..., 1], bb_gt[..., 1])
+    xx2 = np.minimum(bb_test[..., 2], bb_gt[..., 2])
+    yy2 = np.minimum(bb_test[..., 3], bb_gt[..., 3])
+    w = np.maximum(0., xx2 - xx1)
+    h = np.maximum(0., yy2 - yy1)
+    wh = w * h
+    o = wh / ((bb_test[..., 2] - bb_test[..., 0]) * (bb_test[..., 3] - bb_test[..., 1])
+              + (bb_gt[..., 2] - bb_gt[..., 0]) * (bb_gt[..., 3] - bb_gt[..., 1]) - wh)
+    return (o)
+
+
+"""Takes a bounding box in the form [x1,y1,x2,y2] and returns z in the form [x,y,s,r] where x,y is the center of the box and s is the scale/area and r is the aspect ratio"""
+
+
+def convert_bbox_to_z(bbox):
+    w = bbox[2] - bbox[0]
+    h = bbox[3] - bbox[1]
+    x = bbox[0] + w/2.
+    y = bbox[1] + h/2.
+    s = w * h
+    # scale is just area
+    r = w / float(h)
+    return np.array([x, y, s, r]).reshape((4, 1))
+
+
+"""Takes a bounding box in the centre form [x,y,s,r] and returns it in the form
+    [x1,y1,x2,y2] where x1,y1 is the top left and x2,y2 is the bottom right"""
+
+
+def convert_x_to_bbox(x, score=None):
+    w = np.sqrt(x[2] * x[3])
+    h = x[2] / w
+    if (score == None):
+        return np.array([x[0]-w/2., x[1]-h/2., x[0]+w/2., x[1]+h/2.]).reshape((1, 4))
+    else:
+        return np.array([x[0]-w/2., x[1]-h/2., x[0]+w/2., x[1]+h/2., score]).reshape((1, 5))
+
+
+"""This class represents the internal state of individual tracked objects observed as bbox."""
+
+
+class KalmanBoxTracker(object):
+
+    count = 0
+
+    def __init__(self, bbox):
+        """
+        Initialize a tracker using initial bounding box
+
+        Parameter 'bbox' must have 'detected class' int number at the -1 position.
+        """
+        self.kf = KalmanFilter(dim_x=7, dim_z=4)
+        self.kf.F = np.array([[1, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 1], [
+                             0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1]])
+        self.kf.H = np.array([[1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [
+                             0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0]])
+
+        self.kf.R[2:,
+                  2:] *= 10.  # R: Covariance matrix of measurement noise (set to high for noisy inputs -> more 'inertia' of boxes')
+        self.kf.P[4:, 4:] *= 1000.  # give high uncertainty to the unobservable initial velocities
+        self.kf.P *= 10.
+        # Q: Covariance matrix of process noise (set to high for erratically moving things)
+        self.kf.Q[-1, -1] *= 0.5
+        self.kf.Q[4:, 4:] *= 0.5
+
+        self.kf.x[:4] = convert_bbox_to_z(bbox)  # STATE VECTOR
+        self.time_since_update = 0
+        self.id = KalmanBoxTracker.count
+        KalmanBoxTracker.count += 1
+        self.history = []
+        self.hits = 0
+        self.hit_streak = 0
+        self.age = 0
+        self.centroidarr = []
+        CX = (bbox[0]+bbox[2])//2
+        CY = (bbox[1]+bbox[3])//2
+        self.centroidarr.append((CX, CY))
+
+        # keep yolov5 detected class information
+        self.detclass = bbox[5]
+
+    def update(self, bbox):
+        """
+        Updates the state vector with observed bbox
+        """
+        self.time_since_update = 0
+        self.history = []
+        self.hits += 1
+        self.hit_streak += 1
+        self.kf.update(convert_bbox_to_z(bbox))
+        self.detclass = bbox[5]
+        CX = (bbox[0]+bbox[2])//2
+        CY = (bbox[1]+bbox[3])//2
+        self.centroidarr.append((CX, CY))
+
+    def predict(self):
+        """
+        Advances the state vector and returns the predicted bounding box estimate
+        """
+        if ((self.kf.x[6]+self.kf.x[2]) <= 0):
+            self.kf.x[6] *= 0.0
+        self.kf.predict()
+        self.age += 1
+        if (self.time_since_update > 0):
+            self.hit_streak = 0
+        self.time_since_update += 1
+        self.history.append(convert_x_to_bbox(self.kf.x))
+        # bbox=self.history[-1]
+        # CX = (bbox[0]+bbox[2])/2
+        # CY = (bbox[1]+bbox[3])/2
+        # self.centroidarr.append((CX,CY))
+
+        return self.history[-1]
+
+    def get_state(self):
+        """
+        Returns the current bounding box estimate
+        # test
+        arr1 = np.array([[1,2,3,4]])
+        arr2 = np.array([0])
+        arr3 = np.expand_dims(arr2, 0)
+        np.concatenate((arr1,arr3), axis=1)
+        """
+        arr_detclass = np.expand_dims(np.array([self.detclass]), 0)
+
+        arr_u_dot = np.expand_dims(self.kf.x[4], 0)
+        arr_v_dot = np.expand_dims(self.kf.x[5], 0)
+        arr_s_dot = np.expand_dims(self.kf.x[6], 0)
+
+        return np.concatenate((convert_x_to_bbox(self.kf.x), arr_detclass, arr_u_dot, arr_v_dot, arr_s_dot), axis=1)
+
+
+def associate_detections_to_trackers(detections, trackers, iou_threshold=0.3):
+    """
+    Assigns detections to tracked object (both represented as bounding boxes)
+    Returns 3 lists of 
+    1. matches,
+    2. unmatched_detections
+    3. unmatched_trackers
+    """
+    if (len(trackers) == 0):
+        return np.empty((0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 5), dtype=int)
+
+    iou_matrix = iou_batch(detections, trackers)
+
+    if min(iou_matrix.shape) > 0:
+        a = (iou_matrix > iou_threshold).astype(np.int32)
+        if a.sum(1).max() == 1 and a.sum(0).max() == 1:
+            matched_indices = np.stack(np.where(a), axis=1)
+        else:
+            matched_indices = linear_assignment(-iou_matrix)
+    else:
+        matched_indices = np.empty(shape=(0, 2))
+
+    unmatched_detections = []
+    for d, det in enumerate(detections):
+        if (d not in matched_indices[:, 0]):
+            unmatched_detections.append(d)
+
+    unmatched_trackers = []
+    for t, trk in enumerate(trackers):
+        if (t not in matched_indices[:, 1]):
+            unmatched_trackers.append(t)
+
+    # filter out matched with low IOU
+    matches = []
+    for m in matched_indices:
+        if (iou_matrix[m[0], m[1]] < iou_threshold):
+            unmatched_detections.append(m[0])
+            unmatched_trackers.append(m[1])
+        else:
+            matches.append(m.reshape(1, 2))
+
+    if (len(matches) == 0):
+        matches = np.empty((0, 2), dtype=int)
+    else:
+        matches = np.concatenate(matches, axis=0)
+
+    return matches, np.array(unmatched_detections), np.array(unmatched_trackers)
+
+
+class Sort(object):
+    def __init__(self, max_age=1, min_hits=3, iou_threshold=0.3):
+        """
+        Parameters for SORT
+        """
+        self.max_age = max_age
+        self.min_hits = min_hits
+        self.iou_threshold = iou_threshold
+        self.trackers = []
+        self.frame_count = 0
+
+    def getTrackers(self,):
+        return self.trackers
+
+    def update(self, dets=np.empty((0, 6))):
+        """
+        Parameters:
+        'dets' - a numpy array of detection in the format [[x1, y1, x2, y2, score], [x1,y1,x2,y2,score],...]
+
+        Ensure to call this method even frame has no detections. (pass np.empty((0,5)))
+
+        Returns a similar array, where the last column is object ID (replacing confidence score)
+
+        NOTE: The number of objects returned may differ from the number of objects provided.
+        """
+        self.frame_count += 1
+
+        # Get predicted locations from existing trackers
+        trks = np.zeros((len(self.trackers), 6))
+        to_del = []
+        ret = []
+        for t, trk in enumerate(trks):
+            pos = self.trackers[t].predict()[0]
+            trk[:] = [pos[0], pos[1], pos[2], pos[3], 0, 0]
+            if np.any(np.isnan(pos)):
+                to_del.append(t)
+        trks = np.ma.compress_rows(np.ma.masked_invalid(trks))
+        for t in reversed(to_del):
+            self.trackers.pop(t)
+        matched, unmatched_dets, unmatched_trks = associate_detections_to_trackers(
+            dets, trks, self.iou_threshold)
+
+        # Update matched trackers with assigned detections
+        for m in matched:
+            self.trackers[m[1]].update(dets[m[0], :])
+
+        # Create and initialize new trackers for unmatched detections
+        for i in unmatched_dets:
+            trk = KalmanBoxTracker(np.hstack((dets[i, :], np.array([0]))))
+            # trk = KalmanBoxTracker(np.hstack(dets[i,:])
+            self.trackers.append(trk)
+
+        i = len(self.trackers)
+        for trk in reversed(self.trackers):
+            d = trk.get_state()[0]
+            if (trk.time_since_update < 1) and (trk.hit_streak >= self.min_hits or self.frame_count <= self.min_hits):
+                # +1'd because MOT benchmark requires positive value
+                ret.append(np.concatenate((d, [trk.id+1])).reshape(1, -1))
+            i -= 1
+            # remove dead tracklet
+            if (trk.time_since_update > self.max_age):
+                self.trackers.pop(i)
+        if (len(ret) > 0):
+            return np.concatenate(ret)
+        return np.empty((0, 6))
+
+
+def parse_args():
+    """Parse input arguments."""
+    parser = argparse.ArgumentParser(description='SORT demo')
+    parser.add_argument('--display', dest='display',
+                        help='Display online tracker output (slow) [False]', action='store_true')
+    parser.add_argument(
+        "--seq_path", help="Path to detections.", type=str, default='data')
+    parser.add_argument(
+        "--phase", help="Subdirectory in seq_path.", type=str, default='train')
+    parser.add_argument("--max_age",
+                        help="Maximum number of frames to keep alive a track without associated detections.",
+                        type=int, default=1)
+    parser.add_argument("--min_hits",
+                        help="Minimum number of associated detections before track is initialised.",
+                        type=int, default=3)
+    parser.add_argument("--iou_threshold",
+                        help="Minimum IOU for match.", type=float, default=0.3)
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == '__main__':
+    # all train
+    args = parse_args()
+    display = args.display
+    phase = args.phase
+    total_time = 0.0
+    total_frames = 0
+    colours = np.random.rand(32, 3)  # used only for display
+    if (display):
+        if not os.path.exists('mot_benchmark'):
+            print('\n\tERROR: mot_benchmark link not found!\n\n    Create a symbolic link to the MOT benchmark\n    (https://motchallenge.net/data/2D_MOT_2015/#download). E.g.:\n\n    $ ln -s /path/to/MOT2015_challenge/2DMOT2015 mot_benchmark\n\n')
+        exit()
+    plt.ion()
+    fig = plt.figure()
+    ax1 = fig.add_subplot(111, aspect='equal')
+
+    if not os.path.exists('output'):
+        os.makedirs('output')
+    pattern = os.path.join(args.seq_path, phase, '*', 'det', 'det.txt')
+    for seq_dets_fn in glob.glob(pattern):
+        mot_tracker = Sort(max_age=args.max_age,
+                           min_hits=args.min_hits,
+                           iou_threshold=args.iou_threshold)  # create instance of the SORT tracker
+    seq_dets = np.loadtxt(seq_dets_fn, delimiter=',')
+    seq = seq_dets_fn[pattern.find('*'):].split(os.path.sep)[0]
+
+    with open(os.path.join('output', '%s.txt' % (seq)), 'w') as out_file:
+        print("Processing %s." % (seq))
+        for frame in range(int(seq_dets[:, 0].max())):
+            frame += 1  # detection and frame numbers begin at 1
+            dets = seq_dets[seq_dets[:, 0] == frame, 2:7]
+            # convert to [x1,y1,w,h] to [x1,y1,x2,y2]
+            dets[:, 2:4] += dets[:, 0:2]
+            total_frames += 1
+
+        if (display):
+            fn = os.path.join('mot_benchmark', phase, seq,
+                              'img1', '%06d.jpg' % (frame))
+            im = io.imread(fn)
+            ax1.imshow(im)
+            plt.title(seq + ' Tracked Targets')
+
+        start_time = time.time()
+        trackers = mot_tracker.update(dets)
+        cycle_time = time.time() - start_time
+        total_time += cycle_time
+
+        for d in trackers:
+            print('%d,%d,%.2f,%.2f,%.2f,%.2f,1,-1,-1,-1' %
+                  (frame, d[4], d[0], d[1], d[2]-d[0], d[3]-d[1]), file=out_file)
+            if (display):
+                d = d.astype(np.int32)
+                ax1.add_patch(patches.Rectangle(
+                    (d[0], d[1]), d[2]-d[0], d[3]-d[1], fill=False, lw=3, ec=colours[d[4] % 32, :]))
+
+        if (display):
+            fig.canvas.flush_events()
+            plt.draw()
+            ax1.cla()
+
+    print("Total Tracking took: %.3f seconds for %d frames or %.1f FPS" %
+          (total_time, total_frames, total_frames / total_time))
+
+    if (display):
+        print("Note: to get real runtime results run without the option: --display")

tracker.py

@@ -0,0 +1,116 @@
+import cv2
+import numpy as np
+
+from sort import Sort
+
+# SORT tracking algorithm initialization
+sort_max_age = 50
+sort_min_hits = 2
+sort_iou_thresh = 0.2
+sort_tracker = Sort(max_age=sort_max_age,
+                    min_hits=sort_min_hits,
+                    iou_threshold=sort_iou_thresh)
+track_color_id = 0
+
+# Sorting algorithm
+'''Computer Color for every box and track'''
+palette = (2 ** 11 - 1, 2 ** 15 - 1, 2 ** 20 - 1)
+
+
+def compute_color_for_labels(label):
+    color = [int(int(p * (label ** 2 - label + 1)) % 255) for p in palette]
+    return tuple(color)
+
+
+"""" Calculates the relative bounding box from absolute pixel values. """
+
+
+def bbox_rel(*xyxy):
+    bbox_left = min([xyxy[0].item(), xyxy[2].item()])
+    bbox_top = min([xyxy[1].item(), xyxy[3].item()])
+    bbox_w = abs(xyxy[0].item() - xyxy[2].item())
+    bbox_h = abs(xyxy[1].item() - xyxy[3].item())
+    x_c = (bbox_left + bbox_w / 2)
+    y_c = (bbox_top + bbox_h / 2)
+    w = bbox_w
+    h = bbox_h
+    return x_c, y_c, w, h
+
+
+"""Function to Draw Bounding boxes"""
+
+
+def draw_boxes(img, bbox, identities=None, categories=None,
+               names=None, color_box=None, offset=(0, 0)):
+    for i, box in enumerate(bbox):
+        x1, y1, x2, y2 = [int(i) for i in box]
+        x1 += offset[0]
+        x2 += offset[0]
+        y1 += offset[1]
+        y2 += offset[1]
+        cat = int(categories[i]) if categories is not None else 0
+        id = int(identities[i]) if identities is not None else 0
+        data = (int((box[0]+box[2])/2), (int((box[1]+box[3])/2)))
+        label = str(id)
+
+        if color_box:
+            color = compute_color_for_labels(id)
+            (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 1)
+            cv2.rectangle(img, (x1, y1), (x2, y2), color, 2)
+            cv2.rectangle(img, (x1, y1 - 20), (x1 + w, y1), (255, 191, 0), -1)
+            cv2.putText(img, label, (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6,
+                        [255, 255, 255], 1)
+            cv2.circle(img, data, 3, color, -1)
+        else:
+            (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 1)
+            cv2.rectangle(img, (x1, y1), (x2, y2), (255, 191, 0), 2)
+            # cv2.rectangle(img, (x1, y1 - 20), (x1 + w, y1), (255, 191, 0), -1)
+            # cv2.putText(img, label, (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6,
+            #             [255, 255, 255], 1)
+            cv2.rectangle(img, (x1, y1 - 3*h), (x1 + w, y1), (255, 191, 0), -1)
+            cv2.putText(img, label, (x1, y1 - 2*h), cv2.FONT_HERSHEY_SIMPLEX, 0.6,
+                        [255, 255, 255], 1)
+            cv2.circle(img, data, 3, (255, 191, 0), -1)
+    return img
+
+
+def _display_detected_tracks(dets, img, color_box=None):
+    # pass an empty array to sort
+    dets_to_sort = np.empty((0, 6))
+
+    # NOTE: We send in detected object class too
+    for x1, y1, x2, y2, conf, detclass in dets.cpu().detach().numpy():
+        # for x1, y1, x2, y2, conf, detclass in dets.cpu().detach().numpy():
+        dets_to_sort = np.vstack((dets_to_sort,
+                                  np.array([x1, y1, x2, y2,
+                                            conf, detclass])))
+
+    # Run SORT
+    tracked_dets = sort_tracker.update(dets_to_sort)
+    # tracks = sort_tracker.getTrackers()
+
+    # loop over tracks
+    # for track in tracks:
+    #     if color_box:
+    #         color = compute_color_for_labels(track_color_id)
+    #         [cv2.line(img, (int(track.centroidarr[i][0]), int(track.centroidarr[i][1])),
+    #                   (int(track.centroidarr[i+1][0]),
+    #                    int(track.centroidarr[i+1][1])),
+    #                   color, thickness=3) for i, _ in enumerate(track.centroidarr)
+    #             if i < len(track.centroidarr)-1]
+    #         track_color_id = track_color_id+1
+    #     else:
+    #         [cv2.line(img, (int(track.centroidarr[i][0]), int(track.centroidarr[i][1])),
+    #                   (int(track.centroidarr[i+1][0]),
+    #                    int(track.centroidarr[i+1][1])),
+    #                   (124, 252, 0), thickness=3) for i, _ in enumerate(track.centroidarr)
+    #             if i < len(track.centroidarr)-1]
+
+    # draw boxes for visualization
+    if len(tracked_dets) > 0:
+        bbox_xyxy = tracked_dets[:, :4]
+        identities = tracked_dets[:, 8]
+        categories = tracked_dets[:, 4]
+        names = None
+        draw_boxes(img, bbox_xyxy, identities,
+                   categories, names, color_box)

weights/yolov8n-seg.pt

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

weights/yolov8n.pt

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