Upload 17 files

.gitattributes

@@ -33,3 +33,6 @@ 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
+videos/video_1.mp4 filter=lfs diff=lfs merge=lfs -text
+videos/video_2.mp4 filter=lfs diff=lfs merge=lfs -text
+videos/video_3.mp4 filter=lfs diff=lfs merge=lfs -text

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 And Tracking 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,239 @@
+from ultralytics import YOLO
+import streamlit as st
+import cv2
+import yt_dlp
+import settings
+
+
+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_options():
+    display_tracker = st.radio("Display Tracker", ('Yes', 'No'))
+    is_display_tracker = True if display_tracker == 'Yes' else False
+    if is_display_tracker:
+        tracker_type = st.radio("Tracker", ("bytetrack.yaml", "botsort.yaml"))
+        return is_display_tracker, tracker_type
+    return is_display_tracker, None
+
+
+def _display_detected_frames(conf, model, st_frame, image, is_display_tracking=None, tracker=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))))
+
+    # Display object tracking, if specified
+    if is_display_tracking:
+        res = model.track(image, conf=conf, persist=True, tracker=tracker)
+    else:
+        # Predict the objects in the image using the YOLOv8 model
+        res = model.predict(image, conf=conf)
+
+    # # 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 get_youtube_stream_url(youtube_url):
+    ydl_opts = {
+        'format': 'best[ext=mp4]',
+        'no_warnings': True,
+        'quiet': True
+    }
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(youtube_url, download=False)
+        return info['url']
+
+
+def play_youtube_video(conf, model):
+    source_youtube = st.sidebar.text_input("YouTube Video url")
+    is_display_tracker, tracker = display_tracker_options()
+
+    if st.sidebar.button('Detect Objects'):
+        if not source_youtube:
+            st.sidebar.error("Please enter a YouTube URL")
+            return
+
+        try:
+            st.sidebar.info("Extracting video stream URL...")
+            stream_url = get_youtube_stream_url(source_youtube)
+
+            st.sidebar.info("Opening video stream...")
+            vid_cap = cv2.VideoCapture(stream_url)
+
+            if not vid_cap.isOpened():
+                st.sidebar.error(
+                    "Failed to open video stream. Please try a different video.")
+                return
+
+            st.sidebar.success("Video stream opened successfully!")
+            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,
+                        tracker
+                    )
+                else:
+                    break
+
+            vid_cap.release()
+
+        except Exception as e:
+            st.sidebar.error(f"An error occurred: {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:")
+    st.sidebar.caption(
+        'Example URL: rtsp://admin:12345@192.168.1.210:554/Streaming/Channels/101')
+    is_display_tracker, tracker = display_tracker_options()
+    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,
+                                             tracker
+                                             )
+                else:
+                    vid_cap.release()
+                    break
+        except Exception as e:
+            vid_cap.release()
+            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, tracker = display_tracker_options()
+    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,
+                                             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, tracker = display_tracker_options()
+
+    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,
+                                             tracker
+                                             )
+                else:
+                    vid_cap.release()
+                    break
+        except Exception as e:
+            st.sidebar.error("Error loading video: " + str(e))

packages.txt

@@ -0,0 +1,3 @@
+freeglut3-dev
+libgtk2.0-dev
+libgl1-mesa-glx

requirements.txt

@@ -0,0 +1,83 @@
+altair==5.3.0
+attrs==23.2.0
+blinker==1.8.2
+Brotli==1.1.0
+cachetools==5.4.0
+certifi==2024.7.4
+charset-normalizer==3.3.2
+click==8.1.7
+contourpy==1.2.1
+cycler==0.12.1
+filelock==3.15.4
+fonttools==4.53.1
+fsspec==2024.6.1
+gitdb==4.0.11
+GitPython==3.1.43
+idna==3.7
+Jinja2==3.1.4
+jsonschema==4.23.0
+jsonschema-specifications==2023.12.1
+kiwisolver==1.4.5
+lapx==0.5.9.post1
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.9.1
+mdurl==0.1.2
+mpmath==1.3.0
+mutagen==1.47.0
+networkx==3.3
+numpy==1.26.4
+nvidia-cublas-cu12==12.1.3.1
+nvidia-cuda-cupti-cu12==12.1.105
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cudnn-cu12==8.9.2.26
+nvidia-cufft-cu12==11.0.2.54
+nvidia-curand-cu12==10.3.2.106
+nvidia-cusolver-cu12==11.4.5.107
+nvidia-cusparse-cu12==12.1.0.106
+nvidia-nccl-cu12==2.20.5
+nvidia-nvjitlink-cu12==12.5.82
+nvidia-nvtx-cu12==12.1.105
+opencv-python==4.10.0.84
+packaging==24.1
+pafy==0.5.5
+pandas==2.2.2
+pillow==10.4.0
+protobuf==5.27.2
+psutil==6.0.0
+py-cpuinfo==9.0.0
+pyarrow==17.0.0
+pycryptodomex==3.20.0
+pydeck==0.9.1
+Pygments==2.18.0
+pyparsing==3.1.2
+python-dateutil==2.9.0.post0
+pytz==2024.1
+PyYAML==6.0.1
+referencing==0.35.1
+requests==2.32.3
+rich==13.7.1
+rpds-py==0.19.0
+scipy==1.14.0
+seaborn==0.13.2
+six==1.16.0
+smmap==5.0.1
+streamlit==1.36.0
+sympy==1.13.0
+tenacity==8.5.0
+toml==0.10.2
+toolz==0.12.1
+torch==2.3.1
+torchvision==0.18.1
+tornado==6.4.1
+tqdm==4.66.4
+triton==2.3.1
+typing_extensions==4.12.2
+tzdata==2024.1
+ultralytics==8.2.60
+ultralytics-thop==2.0.0
+urllib3==2.2.2
+watchdog==4.0.1
+websockets==12.0
+yt-dlp==2024.7.16

settings.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+import sys
+
+# Get the absolute path of the current file
+FILE = Path(__file__).resolve()
+# Get the parent directory of the current file
+ROOT = FILE.parent
+# Add the root path to the sys.path list if it is not already there
+if ROOT not in sys.path:
+    sys.path.append(str(ROOT))
+# Get the relative path of the root directory with respect to the current working directory
+ROOT = ROOT.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'
+VIDEOS_DICT = {
+    'video_1': VIDEO_DIR / 'video_1.mp4',
+    'video_2': VIDEO_DIR / 'video_2.mp4',
+    'video_3': VIDEO_DIR / 'video_3.mp4',
+}
+
+# ML Model config
+MODEL_DIR = ROOT / 'weights'
+DETECTION_MODEL = MODEL_DIR / 'yolov8n.pt'
+# In case of your custome model comment out the line above and
+# Place your custom model pt file name at the line below 
+# DETECTION_MODEL = MODEL_DIR / 'my_detection_model.pt'
+
+SEGMENTATION_MODEL = MODEL_DIR / 'yolov8n-seg.pt'
+
+# Webcam
+WEBCAM_PATH = 0

videos/video_1.mp4

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

videos/video_2.mp4

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

videos/video_3.mp4

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

weights/yolov8n-cls.pt

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

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