Update app.py

app.py

@@ -49,7 +49,7 @@ def draw_bounding_boxes(frame, detections):
     frame_with_boxes = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
     return frame_with_boxes
 
-def process_video(video_path):
+def process_video(video_path, progress=gr.Progress()):
     """
     Process the video file and return the path to the processed video
     """
@@ -57,36 +57,37 @@ def process_video(video_path):
         # Open the video file
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
-            return None
+            raise ValueError("Could not open video file")
 
         # Get video properties
         fps = int(cap.get(cv2.CAP_PROP_FPS))
         frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        
-        # Create temporary file for output video
-        temp_output = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False)
-        output_path = temp_output.name
-        temp_output.close()
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
 
-        # Initialize video writer
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        # Create output video file
+        output_path = os.path.join(tempfile.gettempdir(), 'output_video.mp4')
+        
+        # Initialize video writer with H264 codec
+        fourcc = cv2.VideoWriter_fourcc(*'avc1')
         out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))
 
+        if not out.isOpened():
+            raise ValueError("Could not create output video file")
+
         frame_count = 0
-        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        process_every_n_frames = 1  # Process every frame
         
-        # Process every nth frame to speed up processing
-        process_every_n_frames = 2  # Adjust this value to process more or fewer frames
+        progress(0, desc="Processing video...")
         
-        while cap.isOpened():
+        while True:
             ret, frame = cap.read()
             if not ret:
                 break
 
             frame_count += 1
             
-            # Only process every nth frame
+            # Process frame
             if frame_count % process_every_n_frames == 0:
                 # Convert frame to RGB for the model
                 frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
@@ -100,56 +101,57 @@ def process_video(video_path):
             # Write the frame
             out.write(frame)
             
-            # Print progress
-            progress = (frame_count / total_frames) * 100
-            print(f"Processing: {progress:.1f}% complete", end='\r')
+            # Update progress
+            progress((frame_count / total_frames), desc=f"Processing frame {frame_count}/{total_frames}")
 
         # Release everything
         cap.release()
         out.release()
         
+        # Verify the output file exists and has size
+        if not os.path.exists(output_path) or os.path.getsize(output_path) == 0:
+            raise ValueError("Output video file is empty or was not created")
+            
         return output_path
         
     except Exception as e:
         print(f"Error processing video: {str(e)}")
-        return None
+        raise gr.Error(f"Error processing video: {str(e)}")
 
 def detect_objects_in_video(video):
     """
     Gradio interface function for video object detection
     """
     if video is None:
-        return None
+        raise gr.Error("Please upload a video file")
     
     try:
         # Process the video
         output_path = process_video(video)
-        if output_path is None:
-            return None
-            
         return output_path
         
     except Exception as e:
-        print(f"Error during video processing: {str(e)}")
-        return None
+        raise gr.Error(f"Error during video processing: {str(e)}")
 
 # Create the Gradio interface
 demo = gr.Interface(
     fn=detect_objects_in_video,
     inputs=[
-        gr.Video(label="Upload Video")
+        gr.Video(label="Upload Video", format="mp4")
     ],
     outputs=[
-        gr.Video(label="Processed Video")
+        gr.Video(label="Processed Video", format="mp4")
     ],
-    title="Video Object Detection",
+    title="@GenAILearniverse Project: Video Object Detection",
     description="""
     Upload a video to detect and track objects within it. 
     The application will process the video and draw bounding boxes around detected objects 
     with their labels and confidence scores.
     Note: Processing may take some time depending on the video length.
-    """
+    """,
+    examples=[],
+    cache_examples=False
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()