Update app.py

app.py

@@ -40,61 +40,79 @@ np.random.seed(42)
 colors = np.random.randint(0, 255, size=(len(model.names), 3), dtype=np.uint8)
 
 def process_video(video_path):
-    # Fix: Handle different types of input from Gradio
-    if isinstance(video_path, dict) and 'name' in video_path:
-        video_path = video_path['name']
+    # Ensure we have a valid path
+    if video_path is None:
+        return None
     
-    cap = cv2.VideoCapture(video_path)
-    
-    if not cap.isOpened():
-        return "Error: Could not open video file."
-
-    frame_width = int(cap.get(3))
-    frame_height = int(cap.get(4))
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    output_path = "output_video.mp4"
-    out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))
-
-    total_frames = 0
-    total_time = 0
-
-    while cap.isOpened():
-        ret, frame = cap.read()
-        if not ret:
-            break  
-        
-        start_time = time.time()
+    try:
+        # For newer Gradio versions, video might be returned as a tuple
+        if isinstance(video_path, tuple) and len(video_path) >= 1:
+            video_path = video_path[0]
+        # Or a dict with a 'name' key
+        elif isinstance(video_path, dict) and 'name' in video_path:
+            video_path = video_path['name']
+        # Make sure it's a string
+        video_path = str(video_path)
         
-        # Convert frame for YOLOv5
-        img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        results = model(img, size=640)
+        cap = cv2.VideoCapture(video_path)
         
-        inference_time = time.time() - start_time
-        total_time += inference_time
-        total_frames += 1
+        if not cap.isOpened():
+            print(f"Error: Could not open video file at {video_path}")
+            return None
+
+        frame_width = int(cap.get(3))
+        frame_height = int(cap.get(4))
+        fps = cap.get(cv2.CAP_PROP_FPS)
         
-        detections = results.pred[0].cpu().numpy()
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        output_path = "output_video.mp4"
+        out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))
 
-        for *xyxy, conf, cls in detections:
-            x1, y1, x2, y2 = map(int, xyxy)
-            class_id = int(cls)
-            color = colors[class_id].tolist()
-            cv2.rectangle(frame, (x1, y1), (x2, y2), color, 3, lineType=cv2.LINE_AA)
-            label = f"{model.names[class_id]} {conf:.2f}"
-            cv2.putText(frame, label, (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 255, 255), 2)
+        total_frames = 0
+        total_time = 0
 
-        # Calculate FPS
-        avg_fps = total_frames / total_time if total_time > 0 else 0
-        cv2.putText(frame, f"FPS: {avg_fps:.2f}", (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break  
+            
+            start_time = time.time()
+            
+            # Convert frame for YOLOv5
+            img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            results = model(img, size=640)
+            
+            inference_time = time.time() - start_time
+            total_time += inference_time
+            total_frames += 1
+            
+            detections = results.pred[0].cpu().numpy()
 
-        out.write(frame)
+            for *xyxy, conf, cls in detections:
+                x1, y1, x2, y2 = map(int, xyxy)
+                class_id = int(cls)
+                color = colors[class_id].tolist()
+                cv2.rectangle(frame, (x1, y1), (x2, y2), color, 3, lineType=cv2.LINE_AA)
+                label = f"{model.names[class_id]} {conf:.2f}"
+                cv2.putText(frame, label, (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 255, 255), 2)
 
-    cap.release()
-    out.release()
+            # Calculate FPS
+            avg_fps = total_frames / total_time if total_time > 0 else 0
+            cv2.putText(frame, f"FPS: {avg_fps:.2f}", (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+
+            out.write(frame)
+
+        cap.release()
+        out.release()
+        
+        print(f"Video processed successfully, output at: {output_path}")
+        return output_path
     
-    return output_path
+    except Exception as e:
+        print(f"Error processing video: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return None
 
 def process_image(image):
     img = np.array(image)
@@ -164,10 +182,11 @@ with gr.Blocks(css=css, title="Video & Image Object Detection by YOLOv5") as dem
     with gr.Tabs():
         with gr.TabItem("Video Detection", elem_classes="tab-item"):
             with gr.Row():
-                # Fix: Changed from gr.Video to gr.File to ensure proper upload handling
-                video_input = gr.File(
-                    label="Upload Video File", 
-                    file_types=["video"],
+                # Keep using gr.Video but with source="upload" parameter
+                video_input = gr.Video(
+                    label="Upload Video", 
+                    interactive=True,
+                    source="upload",  # Explicitly set upload as source
                     elem_id="video-input"
                 )