Update app.py

app.py

@@ -1,8 +1,25 @@
+##############
+
+#Maximize CPU usage
+import multiprocessing
+import cv2
+
+# Get the number of CPU cores
+cpu_cores = multiprocessing.cpu_count()
+
+# Set OpenCV to use all available cores
+cv2.setNumThreads(cpu_cores)
+
+# Print the number of threads being used (optional)
+print(f"OpenCV using {cv2.getNumThreads()} threads out of {cpu_cores} available cores")
+
+##############
 import cv2
 import gradio as gr
 import numpy as np
 from PIL import Image, ImageDraw
 from ultralytics import YOLO
+from ultralytics.utils.plotting import Annotator, colors
 import logging
 import math
 
@@ -97,6 +114,37 @@ def reset_line():
     line_params = None
     return None, "Line reset. Click to draw a new line."
 
+def intersect(A, B, C, D):
+    """
+    Determines if two line segments AB and CD intersect.
+    """
+    def ccw(A, B, C):
+        return (C[1] - A[1]) * (B[0] - A[0]) - (B[1] - A[1]) * (C[0] - A[0])
+
+    def on_segment(A, B, C):
+        if min(A[0], B[0]) <= C[0] <= max(A[0], B[0]) and min(A[1], B[1]) <= C[1] <= max(A[1], B[1]):
+            return True
+        return False
+
+    # Check if the line segments intersect
+    ccw1 = ccw(A, B, C)
+    ccw2 = ccw(A, B, D)
+    ccw3 = ccw(C, D, A)
+    ccw4 = ccw(C, D, B)
+
+    if ((ccw1 * ccw2 < 0) and (ccw3 * ccw4 < 0)):
+        return True
+    elif ccw1 == 0 and on_segment(A, B, C):
+        return True
+    elif ccw2 == 0 and on_segment(A, B, D):
+        return True
+    elif ccw3 == 0 and on_segment(C, D, A):
+        return True
+    elif ccw4 == 0 and on_segment(C, D, B):
+        return True
+    else:
+        return False
+
 def is_object_crossing_line(box, line_params):
     """
     Determines if an object's bounding box is fully intersected by the user-drawn line.
@@ -154,8 +202,9 @@ def process_video(confidence_threshold=0.5, selected_classes=None, stream_url=No
         errors.append("Error: Could not open stream.")
         return None, "\n".join(errors)
 
-    model = YOLO(model="yolov8n.pt")
-    crossed_objects = set()  # Use a set to store unique object IDs (if available)
+    model = YOLO(model="yolo11n.pt")
+    crossed_objects = {}
+    max_tracked_objects = 1000  # Maximum number of objects to track before clearing
 
     logger.info("Starting to process the stream...")
     while cap.isOpened():
@@ -164,29 +213,32 @@ def process_video(confidence_threshold=0.5, selected_classes=None, stream_url=No
             errors.append("Error: Could not read frame from the stream.")
             break
 
-        # Perform object detection (no tracking)
-        results = model.predict(frame, conf=confidence_threshold)
+        # Perform object tracking with confidence threshold
+        results = model.track(frame, persist=True, conf=confidence_threshold)
 
-        for result in results:
-            boxes = result.boxes.xyxy.cpu().numpy()
-            clss = result.boxes.cls.cpu().numpy()
-            confs = result.boxes.conf.cpu().numpy()
+        if results[0].boxes.id is not None:
+            track_ids = results[0].boxes.id.int().cpu().tolist()
+            clss = results[0].boxes.cls.cpu().tolist()
+            boxes = results[0].boxes.xyxy.cpu()
+            confs = results[0].boxes.conf.cpu().tolist()
 
-            for box, cls, conf in zip(boxes, clss, confs):
-                if conf >= confidence_threshold and model.names[int(cls)] in selected_classes:
+            for box, cls, t_id, conf in zip(boxes, clss, track_ids, confs):
+                if conf >= confidence_threshold and model.names[cls] in selected_classes:
                     # Check if the object crosses the line
-                    if is_object_crossing_line(box, line_params):
-                        # Use the bounding box center as a unique identifier
-                        center = ((box[0] + box[2]) / 2, (box[1] + box[3]) / 2)
-                        crossed_objects.add(tuple(center))  # Add the center to the set
+                    if is_object_crossing_line(box, line_params) and t_id not in crossed_objects:
+                        crossed_objects[t_id] = True
 
-        # Visualize the results with bounding boxes
+                        # Clear the dictionary if it gets too large
+                        if len(crossed_objects) > max_tracked_objects:
+                            crossed_objects.clear()
+
+        # Visualize the results with bounding boxes, masks, and IDs
         annotated_frame = results[0].plot()
 
         # Draw the angled line on the frame
         draw_angled_line(annotated_frame, line_params, color=(0, 255, 0), thickness=2)
 
-        # Display the count on the frame
+        # Display the count on the frame with a modern look
         count = len(crossed_objects)
         (text_width, text_height), _ = cv2.getTextSize(f"COUNT: {count}", cv2.FONT_HERSHEY_SIMPLEX, 1, 2)
 
@@ -211,8 +263,12 @@ def process_video(confidence_threshold=0.5, selected_classes=None, stream_url=No
 with gr.Blocks() as demo:
     gr.Markdown("<h1>Real-time monitoring, object tracking, and line-crossing detection for CCTV camera streams.</h1></center>")
     gr.Markdown("## https://github.com/SanshruthR/CCTV_SENTRY_YOLO11")
-
+    
+   
+   
     # Step 1: Enter the IP Camera Stream URL
+    # gr.Markdown("### Step 0: Enter the IP Camera Stream URL")
+    # stream_url = gr.Textbox(label="Enter IP Camera Stream URL", value="https://s103.ipcamlive.com/streams/67n4ojknye7lkxpmf/stream.m3u8", visible=False)
     stream_url = gr.Textbox(label="Enter IP Camera Stream URL", value="https://s104.ipcamlive.com/streams/68idokwtondsqpmkr/stream.m3u8", visible=False)
 
     # Step 1: Extract the first frame from the stream
@@ -224,12 +280,18 @@ with gr.Blocks() as demo:
         # Image component for displaying the first frame
         image = gr.Image(value=first_frame, label="First Frame of Stream", type="pil")
 
+      
         line_info = gr.Textbox(label="Line Coordinates", value="Line Coordinates:\nStart: None, End: None")
         image.select(update_line, inputs=image, outputs=[image, line_info])
 
+        # Reset the line (optional)
+        # gr.Markdown("### Step 4: Reset the Line (Optional)")
+        # reset_button = gr.Button("Reset Line")
+        # reset_button.click(reset_line, inputs=None, outputs=[image, line_info])
+
         # Step 2: Select classes to detect
         gr.Markdown("### Step 2: Select Classes to Detect")
-        model = YOLO(model="yolov8n.pt")  # Load the model to get class names
+        model = YOLO(model="yolo11n.pt")  # Load the model to get class names
         class_names = list(model.names.values())  # Get class names
         selected_classes = gr.CheckboxGroup(choices=class_names, label="Select Classes to Detect")
 
@@ -237,7 +299,7 @@ with gr.Blocks() as demo:
         gr.Markdown("### Step 3: Adjust Confidence Threshold (Optional)")
         confidence_threshold = gr.Slider(minimum=0.0, maximum=1.0, value=0.2, label="Confidence Threshold")
 
-        # Process the stream
+        #process the stream
         process_button = gr.Button("Process Stream")
 
         # Output image for real-time frame rendering