Update app.py

app.py

@@ -22,26 +22,30 @@ def cleanup_temp_files():
 # Register cleanup function
 atexit.register(cleanup_temp_files)
 
-def detect_objects_image(image):
+def detect_objects_image(image, confidence):
     """Process image with YOLO detection."""
     if image is None:
-        return None
+        return None, "No image provided"
     
     # Convert PIL image to numpy array
     image_np = np.array(image)
     
-    # Perform detection
-    results = model(image_np)
+    # Perform detection with confidence threshold
+    results = model(image_np, conf=confidence)
     
     # Get annotated image
     annotated_image = results[0].plot()
     
-    return Image.fromarray(annotated_image)
+    # Count detections
+    num_detections = len(results[0].boxes)
+    detection_info = f"Detected {num_detections} object(s) with confidence ≥ {confidence:.0%}"
+    
+    return Image.fromarray(annotated_image), detection_info
 
-def detect_objects_video(video):
+def detect_objects_video(video, confidence, progress=gr.Progress()):
     """Process video with YOLO detection."""
     if video is None:
-        return None
+        return None, "No video provided"
     
     # Read input video
     cap = cv2.VideoCapture(video)
@@ -50,12 +54,16 @@ def detect_objects_video(video):
     fps = int(cap.get(cv2.CAP_PROP_FPS))
     width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     
     # Create output video file in our temp directory
     output_path = os.path.join(TEMP_DIR, f"output_{os.urandom(8).hex()}.mp4")
     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
     out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
     
+    frame_count = 0
+    total_detections = 0
+    
     try:
         # Process each frame
         while cap.isOpened():
@@ -63,20 +71,31 @@ def detect_objects_video(video):
             if not ret:
                 break
             
-            # Perform detection
-            results = model(frame)
+            # Perform detection with confidence threshold
+            results = model(frame, conf=confidence)
             annotated_frame = results[0].plot()
             
+            # Count detections in this frame
+            total_detections += len(results[0].boxes)
+            
             # Convert RGB to BGR for cv2.VideoWriter
             annotated_frame_bgr = cv2.cvtColor(annotated_frame, cv2.COLOR_RGB2BGR)
             
             # Write annotated frame
             out.write(annotated_frame_bgr)
+            
+            # Update progress
+            frame_count += 1
+            if total_frames > 0:
+                progress((frame_count / total_frames), desc=f"Processing frame {frame_count}/{total_frames}")
     finally:
         cap.release()
         out.release()
     
-    return output_path
+    avg_detections = total_detections / frame_count if frame_count > 0 else 0
+    video_info = f"Processed {frame_count} frames | Total detections: {total_detections} | Average per frame: {avg_detections:.1f}"
+    
+    return output_path, video_info
 
 # Periodic cleanup function to remove old processed videos
 def periodic_cleanup():
@@ -94,14 +113,23 @@ def periodic_cleanup():
                 except Exception:
                     pass
 
+# Custom CSS for Inter font
+custom_css = """
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+
+* {
+    font-family: 'Inter', sans-serif !important;
+}
+"""
+
 # Create Gradio interface
-with gr.Blocks(title="YOLO Object Detection", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🔍 YOLO Object Detection App")
-    gr.Markdown("Upload an image or video to detect objects using YOLOv8!")
+with gr.Blocks(title="YOLO Object Detection", theme=gr.themes.Soft(), css=custom_css) as demo:
+    gr.Markdown("# YOLO Object Detection")
+    gr.Markdown("Upload an image or video to detect objects using YOLOv8")
     
     with gr.Tabs():
         # Image Detection Tab
-        with gr.TabItem("📸 Image Detection"):
+        with gr.TabItem("Image Detection"):
             with gr.Row():
                 with gr.Column():
                     image_input = gr.Image(
@@ -109,59 +137,89 @@ with gr.Blocks(title="YOLO Object Detection", theme=gr.themes.Soft()) as demo:
                         label="Upload Image",
                         height=400
                     )
-                    image_button = gr.Button("🔍 Detect Objects", variant="primary")
+                    image_confidence = gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=0.25,
+                        step=0.05,
+                        label="Confidence Threshold",
+                        info="Minimum confidence for detection (lower = more detections)"
+                    )
+                    image_button = gr.Button("Detect Objects", variant="primary")
                 
                 with gr.Column():
                     image_output = gr.Image(
                         label="Detection Results",
                         height=400
                     )
+                    image_info = gr.Textbox(
+                        label="Detection Summary",
+                        interactive=False
+                    )
         
         # Video Detection Tab
-        with gr.TabItem("🎥 Video Detection"):
+        with gr.TabItem("Video Detection"):
             with gr.Row():
                 with gr.Column():
                     video_input = gr.Video(
                         label="Upload Video",
                         height=400
                     )
-                    video_button = gr.Button("🔍 Process Video", variant="primary")
+                    video_confidence = gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=0.25,
+                        step=0.05,
+                        label="Confidence Threshold",
+                        info="Minimum confidence for detection (lower = more detections)"
+                    )
+                    video_button = gr.Button("Process Video", variant="primary")
                 
                 with gr.Column():
                     video_output = gr.Video(
                         label="Processed Video",
                         height=400
                     )
+                    video_info = gr.Textbox(
+                        label="Processing Summary",
+                        interactive=False
+                    )
             
-            gr.Markdown("⚠️ **Note:** Video processing may take some time depending on file size and length.")
+            gr.Markdown("Note: Video processing may take some time depending on file size and length.")
     
     # Info section
-    with gr.Accordion("ℹ️ About", open=False):
+    with gr.Accordion("About", open=False):
         gr.Markdown("""
         ### About This App
         - **Model:** YOLOv8 nano for efficient object detection
         - **Supported Images:** JPG, JPEG, PNG
         - **Supported Videos:** MP4, AVI, MOV, WebM
-        - **Features:** Real-time detection, downloadable results
+        - **Features:** Confidence threshold control, detection counting, automatic cleanup
         
         ### How to Use
         1. Choose the **Image** or **Video** tab
         2. Upload your file
-        3. Click the detect/process button
-        4. Download your results
+        3. Adjust the confidence threshold if needed (default: 0.25)
+        4. Click the detect/process button
+        5. Download your results
+        
+        ### Confidence Threshold
+        - Higher values (0.5-1.0): Fewer, more certain detections
+        - Lower values (0.1-0.4): More detections, may include false positives
+        - Default (0.25): Balanced approach
         """)
     
     # Connect functions to buttons
     image_button.click(
         fn=detect_objects_image,
-        inputs=image_input,
-        outputs=image_output
+        inputs=[image_input, image_confidence],
+        outputs=[image_output, image_info]
     )
     
     video_button.click(
         fn=detect_objects_video,
-        inputs=video_input,
-        outputs=video_output
+        inputs=[video_input, video_confidence],
+        outputs=[video_output, video_info]
     )
     
     # Run periodic cleanup every time the interface loads