Update app.py

app.py

@@ -44,15 +44,7 @@ colors = np.random.uniform(0, 255, size=(len(model.names), 3))
 # Performance tracking
 total_inference_time = 0
 inference_count = 0
-fps_queue = Queue(maxsize=30)  # Store last 30 FPS values for smoothing
-for _ in range(30):  # Initialize with reasonable values
-    fps_queue.put(30.0)
-
-# Threading variables
-processing_lock = threading.Lock()
-stop_event = threading.Event()
-frame_queue = Queue(maxsize=2)  # Small queue to avoid lag
-result_queue = Queue(maxsize=2)
+last_fps_values = []  # Store recent FPS values
 
 def detect_objects(image):
     """Process a single image for object detection"""
@@ -107,135 +99,71 @@ def detect_objects(image):
     
     return output_image
 
-def process_frame_thread():
-    """Background thread for processing frames"""
-    while not stop_event.is_set():
-        try:
-            if not frame_queue.empty():
-                frame = frame_queue.get()
-                
-                # Skip if there's a processing lock (from image upload)
-                if processing_lock.locked():
-                    result_queue.put(frame)  # Return unprocessed frame
-                    continue
-                    
-                # Process the frame
-                start_time = time.time()
-                with torch.no_grad():  # Ensure no gradients for inference
-                    input_size = 384  # Smaller size for real-time processing
-                    results = model(frame['image'], size=input_size)
-                
-                # Calculate FPS
-                inference_time = time.time() - start_time
-                current_fps = 1 / inference_time if inference_time > 0 else 30
-                
-                # Update rolling FPS average
-                if not fps_queue.full():
-                    fps_queue.put(current_fps)
-                else:
-                    try:
-                        fps_queue.get_nowait()
-                        fps_queue.put(current_fps)
-                    except:
-                        pass
-                
-                fps_values = list(fps_queue.queue)
-                avg_fps = sum(fps_values) / len(fps_values) if fps_values else 30.0
-                
-                # Draw detections
-                output = frame['image'].copy()
-                detections = results.pred[0].cpu().numpy()
-                
-                for *xyxy, conf, cls in detections:
-                    x1, y1, x2, y2 = map(int, xyxy)
-                    class_id = int(cls)
-                    color = colors[class_id].tolist()
-                    
-                    # Draw rectangle and label
-                    cv2.rectangle(output, (x1, y1), (x2, y2), color, 2, lineType=cv2.LINE_AA)
-                    
-                    label = f"{model.names[class_id]} {conf:.2f}"
-                    font_scale, font_thickness = 0.6, 1  # Smaller for real-time
-                    (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, font_scale, font_thickness)
-                    
-                    cv2.rectangle(output, (x1, y1 - h - 5), (x1 + w + 5, y1), color, -1)
-                    cv2.putText(output, label, (x1 + 3, y1 - 3),
-                                cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255), font_thickness, lineType=cv2.LINE_AA)
-                
-                # Add FPS counter
-                cv2.rectangle(output, (10, 10), (210, 80), (0, 0, 0), -1)
-                cv2.putText(output, f"FPS: {current_fps:.1f}", (20, 40),
-                            cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2, lineType=cv2.LINE_AA)
-                cv2.putText(output, f"Avg FPS: {avg_fps:.1f}", (20, 70),
-                            cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2, lineType=cv2.LINE_AA)
-                
-                # Put the processed frame in the result queue
-                if not result_queue.full():
-                    result_queue.put({'image': output, 'fps': current_fps})
-            else:
-                time.sleep(0.001)  # Small sleep to prevent CPU spinning
-        except Exception as e:
-            print(f"Error in frame processing thread: {e}")
-            time.sleep(0.1)  # Pause briefly on error
-
-def webcam_feed():
-    """Generator function for webcam feed"""
-    # Start the processing thread if not already running
-    if not any(thread.name == "frame_processor" for thread in threading.enumerate()):
-        stop_event.clear()
-        processor = threading.Thread(target=process_frame_thread, name="frame_processor", daemon=True)
-        processor.start()
+def process_webcam_frame(frame):
+    """Process a single frame from webcam"""
+    global last_fps_values
     
-    # Open webcam
-    cap = cv2.VideoCapture(0)
-    if not cap.isOpened():
-        print("Warning: Unable to open webcam! Using dummy frames instead.")
-        # Create a dummy frame with a message
-        dummy_frame = np.zeros((480, 640, 3), dtype=np.uint8)
-        cv2.putText(dummy_frame, "Webcam not available", (100, 240), 
-                    cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
-        while True:
-            yield dummy_frame
-            time.sleep(0.033)  # ~30 FPS
+    if frame is None:
+        return None
     
-    # Set webcam properties for best performance
-    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
-    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
-    cap.set(cv2.CAP_PROP_FPS, 30)  # Request 30 FPS from camera if supported
+    start_time = time.time()
     
-    try:
-        while cap.isOpened():
-            success, frame = cap.read()
-            if not success:
-                print("Failed to read from webcam")
-                break
-                
-            # Put frame in queue for processing if not full
-            if not frame_queue.full():
-                frame_queue.put({'image': frame, 'timestamp': time.time()})
-            
-            # Get processed frame from result queue if available
-            if not result_queue.empty():
-                result = result_queue.get()
-                yield result['image']
-            else:
-                # If no processed frame is available, yield the raw frame
-                yield frame
-                
-            # Control frame rate
-            time.sleep(0.01)  # Small delay to prevent overwhelming the system
-    finally:
-        cap.release()
+    # Use a smaller size for real-time
+    input_size = 384
+    
+    # Process the frame
+    with torch.no_grad():
+        results = model(frame, size=input_size)
+    
+    # Calculate FPS
+    inference_time = time.time() - start_time
+    current_fps = 1 / inference_time if inference_time > 0 else 30
+    
+    # Update FPS history (keep last 30 values)
+    last_fps_values.append(current_fps)
+    if len(last_fps_values) > 30:
+        last_fps_values.pop(0)
+    avg_fps = sum(last_fps_values) / len(last_fps_values)
+    
+    # Create output image
+    output = frame.copy()
+    
+    # Draw detections
+    detections = results.pred[0].cpu().numpy()
+    for *xyxy, conf, cls in detections:
+        x1, y1, x2, y2 = map(int, xyxy)
+        class_id = int(cls)
+        color = colors[class_id].tolist()
+        
+        # Draw rectangle and label
+        cv2.rectangle(output, (x1, y1), (x2, y2), color, 2, lineType=cv2.LINE_AA)
+        
+        label = f"{model.names[class_id]} {conf:.2f}"
+        font_scale, font_thickness = 0.6, 1
+        (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, font_scale, font_thickness)
+        
+        cv2.rectangle(output, (x1, y1 - h - 5), (x1 + w + 5, y1), color, -1)
+        cv2.putText(output, label, (x1 + 3, y1 - 3),
+                    cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255), font_thickness, lineType=cv2.LINE_AA)
+    
+    # Add FPS counter
+    cv2.rectangle(output, (10, 10), (210, 80), (0, 0, 0), -1)
+    cv2.putText(output, f"FPS: {current_fps:.1f}", (20, 40),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2, lineType=cv2.LINE_AA)
+    cv2.putText(output, f"Avg FPS: {avg_fps:.1f}", (20, 70),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2, lineType=cv2.LINE_AA)
+    
+    return output
 
 def process_uploaded_image(image):
-    """Process an uploaded image (this will be separate from real-time)"""
-    with processing_lock:  # Acquire lock to pause real-time processing
-        return detect_objects(image)
+    """Process an uploaded image"""
+    return detect_objects(image)
 
 # Setup Gradio interface
 example_images = ["spring_street_after.jpg", "pexels-hikaique-109919.jpg"]
 os.makedirs("examples", exist_ok=True)
 
+# Simplified interface with proper webcam handling
 with gr.Blocks(title="YOLOv5 Object Detection - Real-time & Image Upload") as demo:
     gr.Markdown("""
     # YOLOv5 Object Detection
@@ -248,7 +176,17 @@ with gr.Blocks(title="YOLOv5 Object Detection - Real-time & Image Upload") as de
             ### Real-time Object Detection
             Using your webcam for continuous object detection at 30+ FPS.
             """)
-            webcam_output = gr.Image(label="Real-time Detection", type="numpy")
+            # Use Gradio's webcam component with processing function
+            webcam = gr.Webcam(label="Webcam Input")
+            webcam_output = gr.Image(label="Real-time Detection")
+            detect_button = gr.Button("Detect Objects")
+            
+            # Connect webcam to processor
+            detect_button.click(
+                fn=process_webcam_frame,
+                inputs=webcam,
+                outputs=webcam_output
+            )
         
         with gr.TabItem("Image Upload"):
             gr.Markdown("""
@@ -275,16 +213,5 @@ with gr.Blocks(title="YOLOv5 Object Detection - Real-time & Image Upload") as de
     # Set up event handlers
     submit_button.click(fn=process_uploaded_image, inputs=input_image, outputs=output_image)
     clear_button.click(lambda: (None, None), None, [input_image, output_image])
-    
-    # Start webcam feed
-    demo.load(fn=lambda: None, inputs=None, outputs=webcam_output)
-    webcam_output.update(webcam_feed)
-
-# Cleanup function to stop threads when app closes
-def cleanup():
-    stop_event.set()
-    print("Cleaning up threads...")
 
-# Register cleanup handler
-demo.close = cleanup
 demo.launch(share=False)